Pourquoi n'est-ce pas un algorithme d'échange de clés viable? [dupliquer]
Je me demandais simplement pourquoi ce type d'algorithme ne peut pas être utilisé à la place de, disons, Diffie-Hellman pour échanger des clés:
- Alice décide d'une clé qu'elle souhaite partager avec Bob.
- Alice génère un flux d'octets de la même longueur que la clé (en toute sécurité, par exemple, avec un CSPRNG).
- Alice envoie à Bob:
C1 = (key ^ alice_random_bytes)
- Bob génère un flux d'octets aléatoires d'une manière similaire à Alice.
- Bob revient vers Alice:
C2 = (C1 ^ bob_random_bytes)
- Alice XORs
C2
avec sa séquence d'octets aléatoires à nouveau, ne laissant quekey ^ bob_random_bytes
comme ça et l'envoie à 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)
- Bob XORs
C3
avec ses octets aléatoires et obtient la clé:K = (C3 ^ bob_random_bytes) = (key ^ bob_random_bytes ^ bob_random_bytes) = key
Cela semble beaucoup plus simple que Diffie Hellman, alors je me demandais: quel est le problème avec un tel algorithme?
Réponses
J'ai simplifié les octets aléatoires d'Alice en ARB et Bob en octets aléatoires BRB. Ensuite, le protocole suit comme;
Alice sait $key$ et $ARB$et envoie $$C_1 = key \oplus ARB$$
Bob sait $C_1$ et $BRB$et envoie
$$C_2 = C_1 \oplus BRB = key \oplus ARB \oplus BRB$$
Alice calcule $C_2 \oplus key \oplus ARB = key \oplus key \oplus ARB \oplus BRB = BRB$
Alice sait $key, ARB,$ et $BRB$et envoie
$$C_3 = (C_2 \oplus ARB) = key \oplus ARB \oplus BRB \oplus ARB = key \oplus BRB$$
Maintenant, tout d'abord, cela nécessite un protocole à trois passes.
Maintenant, un observateur voit
\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}
Un observateur passif (espion) se contente de x-ors tout pour dériver la clé $$key = C_1 \oplus C_2 \oplus C_3.$$Par conséquent, il n'est pas sûr contre l'hypothèse faible de l'attaquant; passif!.
Donc, vous vous fiez au xor, cependant, vous n'avez pas vérifié ce qu'un observateur peut obtenir et calculer à partir d'eux.
L' échange de clés Diffie-Hellman (DHKE) , en revanche, fuit$g^a$ et $g^b$ où Alice sélectionne un entier aléatoire $a$et envoie $g^a$ et Bob sélectionne un entier aléatoire $b$et envoie $g^b$. Découverte$a$ ou $b$d'eux est le problème du logarithme discret . D'autre part, l'hypothèse de calcul Diffie – Hellman (CDH), est demandée pour trouver$g^{ab}$ donné $g^a$ et $g^b$, et le DHKE est relayé à ce sujet. Si le logarithme discret est facile, CDH est facile. On ne sait pas l'inverse, dans le cas général.
Les algorithmes d'échange de clés tentent de se protéger contre les écoutes clandestines. Vous devez supposer que ce que vous envoyez sur le fil (C1, C2 et C3) est intercepté. C'est un problème avec la méthode car C2 est simplement C1 x ou les octets aléatoires de Bob et C3 est simplement la clé x ou les octets aléatoires de Bob.
Un attaquant avec C1, C2 et C3 pourrait prendre C1 x ou C2 pour obtenir les octets aléatoires de Bob, puis xor avec C3 pour obtenir la clé comme Bob le ferait.