Warum ist dies kein praktikabler Schlüsselaustauschalgorithmus? [Duplikat]

Question

Ich habe mich nur gefragt, warum diese Art von Algorithmus nicht anstelle von beispielsweise Diffie-Hellman zum Austausch von Schlüsseln verwendet werden kann:

1. Alice entscheidet sich für einen Schlüssel, den sie mit Bob teilen möchte.
2. Alice generiert einen Strom von Bytes mit der gleichen Länge wie der Schlüssel (beispielsweise sicher mit einem CSPRNG).
3. Alice schickt an Bob:

   C1 = (key ^ alice_random_bytes)
   

4. Bob erzeugt einen Strom von zufälligen Bytes auf ähnliche Weise wie Alice.
5. Bob kehrt zu Alice zurück:

   C2 = (C1 ^ bob_random_bytes)
   

6. Alice XORs C2mit ihrer zufälligen Byte-Sequenz wieder, lässt nur key ^ bob_random_bytesso und sendet es an Bob:

   C3 = (C2 ^ alice_random_bytes)
      = (C1 ^ bob_random_bytes ^ alice_random_bytes)
      = (key ^ alice_random_bytes ^ bob_random_bytes ^ alice_random_bytes)
      = (key ^ bob_random_bytes)
   

7. Bob XORs C3mit seinen zufälligen Bytes und erhält den Schlüssel:

   K = (C3 ^ bob_random_bytes)
     = (key ^ bob_random_bytes ^ bob_random_bytes) 
     = key
   

Dies scheint viel einfacher zu sein als Diffie Hellman, also habe ich mich gefragt: Was ist das Problem mit einem solchen Algorithmus?

Answer 1

Ich habe die Alice-Zufallsbytes zu ARB und die Bob-Zufallsbytes zu BRB vereinfacht . Dann folgt das Protokoll wie folgt:

Alice weiß es $key$ und $ARB$und sendet $$C_1 = key \oplus ARB$$

Bob weiß es $C_1$ und $BRB$und sendet

$$C_2 = C_1 \oplus BRB = key \oplus ARB \oplus BRB$$

Alice rechnet $C_2 \oplus key \oplus ARB = key \oplus key \oplus ARB \oplus BRB = BRB$

Alice weiß es $key, ARB,$ und $BRB$und sendet

$$C_3 = (C_2 \oplus ARB) = key \oplus ARB \oplus BRB \oplus ARB = key \oplus BRB$$

Dies erfordert zunächst ein Drei-Pass-Protokoll.

Jetzt sieht ein Beobachter

\begin{align} C_1 & = key \oplus ARB \oplus {}\\ C_2 & = key \oplus ARB \oplus BRB\\ C_3 & = key \oplus \phantom{ARB}\oplus BRB \\ \end{align}

Ein passiver Beobachter (Lauscher) x-ors einfach alle, um den Schlüssel abzuleiten $$key = C_1 \oplus C_2 \oplus C_3.$$Daher ist es unsicher gegen die schwache Annahme des Angreifers; passiv!.

Sie verlassen sich also auf das xor, haben jedoch nicht geprüft, was ein Beobachter von ihm erhalten und berechnen kann.

Der Diffie-Hellman-Schlüsselaustausch (DHKE) ist dagegen undicht$g^a$ und $g^b$ wobei Alice eine zufällige ganze Zahl auswählt $a$und sendet $g^a$ und Bob wählen eine zufällige ganze Zahl $b$und sendet $g^b$. Finden$a$ oder $b$von ihnen ist das diskrete Logarithmusproblem . Andererseits wird die Annahme der Computational Diffie-Hellman (CDH) gefragt$g^{ab}$ gegeben $g^a$ und $g^b$und der DHKE wird darauf weitergeleitet. Wenn der diskrete Logarithmus einfach ist, ist CDH einfach. Im allgemeinen Fall kennen wir das Gegenteil nicht.

Answer 2

Schlüsselaustauschalgorithmen versuchen, sich vor Abhören zu schützen. Sie müssen davon ausgehen, dass das, was Sie über die Leitung (C1, C2 und C3) senden, abgefangen wird. Das ist ein Problem mit der Methode, weil C2 einfach C1 xoder Bobs zufällige Bytes und C3 einfach der Schlüssel xor Bobs zufällige Bytes ist.

Ein Angreifer mit C1, C2 und C3 könnte C1 xor C2 nehmen, um Bobs zufällige Bytes zu erhalten, und dann xor das mit C3, um den Schlüssel zu erhalten, genau wie Bob es tun würde.