Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Arnaud W.
Bonjour,
Si je n'ai pas fait d'erreur, je pense avoir trouvé la faille.
Si je résume votre protocole (ci-dessous, ===> signifie qu'on envoi quelque chose):
A B ---------------------------------------- 1 nA nB 2 génération de m1 3 m1'= m1 xor nA ===> m1' 4 m1 = m1' xor nA 5 génération de m2 6 m1" <============== m1" = m1 xor m2 7 m2' <============== m2' = m2 xor nB
A vérifie : m1" XOR m2' XOR nB = m1 <=> m1 xor m2 XOR m2 xor nB XOR nB = m1 (par substitution) <=> m1 = m1 (par simplification)
Dans ce protocole, quelqu'un qui écoute ce qui est échangé (on le nomme parfois Black Hat, noté BH) connait uniquement :
m1', m1" et m2' (dont il ne peut déduire nA ou nB si m1 et m2 sont bien aléatoires)
Il peut faire : m1' xor m1" xor m2' = m1 xor nA xor m1 xor m2 xor m2 xor nB (par substitution) = nA xor nB (par simplification)
Jusque là, BH ne peut pas connaitre nA ou nB séparément. Mais il n'en a pas besoin.
BH tente sa chance et demande à s'authentifier auprès de A (il veut se faire passer pour B) :
A BH ---------------------------------------- 1 nA 2 génération de m1-2 3 m1-2'= m1-2 xor nA ===> m1-2' 4 (BH ne calcul pas m1-2 puisqu'il ne connait pas nA) 5 génération de m2-2 (aléatoire) 6 m1-2" <================ m1-2" = m1- 2' xor m2-2 <--- on calcul avec m1-2' et non m1-2 7 m2-2' <================ m2-2' = m2- 2 xor nA xor nB <-- on calcul avec (nA xor nB) et non nB uniquement
A vérifie : m1-2" xor m2-2' xor nB = m1-2 <=> m1-2' xor m2-2 xor m2-2 xor nA xor nB xor nB = m1-2 (par substitution) <=> m1-2' xor nA = m1-2 (par simplification) <=> m1-2 = m1-2 (par substitution)
Sans connaitre nA ou nB, BH peut se faire passer pour B auprès de A (i.e. passer le test) après avoir écouté uniquement les données publiques d'un échange.
De plus, je précise que le chiffre de Vernam qui est basé sur des clefs aléatoires et l'opération xor, est indécryptable uniquement ssi : - les clefs sont parfaitement aléatoires (impossible avec un ordinateur qui est une machine déterministe) - ET les clefs sont aussi longues que les données à transmette - ET les clefs ne sont utilisées qu'une seule fois (puis complètement détruites, difficile à réaliser sur un ordinateur).
En effet, deux messages (m1 et m2) chiffrés avec la même clef (K), par simplification, cela donne m1 xor m2 (la clef s'élimine). m1 xor m2 permet de récupérer des informations partielles, par exemple si une partie de m1 ou m2 vaut 1 (ou 0).
Dans le monde réel, il y a souvent beaucoup de redondance dans les données informatique (par exemple dans une image, un document texte...etc) ce qui fait qu'on peut récupérer des informations (même partielles) sur les données claires.
Cordialement, Arnaud W. http://awr.free.fr
Bonjour,
Si je n'ai pas fait d'erreur, je pense avoir trouvé la faille.
Si je résume votre protocole (ci-dessous, ===> signifie qu'on envoi
quelque chose):
A B
----------------------------------------
1 nA nB
2 génération de m1
3 m1'= m1 xor nA ===> m1'
4 m1 = m1' xor nA
5 génération de m2
6 m1" <============== m1" = m1 xor m2
7 m2' <============== m2' = m2 xor nB
A vérifie :
m1" XOR m2' XOR nB = m1
<=> m1 xor m2 XOR m2 xor nB XOR nB = m1 (par substitution)
<=> m1 = m1 (par simplification)
Dans ce protocole, quelqu'un qui écoute ce qui est échangé (on le
nomme parfois Black Hat, noté BH) connait uniquement :
m1', m1" et m2' (dont il ne peut déduire nA ou nB si m1 et m2 sont
bien aléatoires)
Il peut faire :
m1' xor m1" xor m2'
= m1 xor nA xor m1 xor m2 xor m2 xor nB (par substitution)
= nA xor nB (par simplification)
Jusque là, BH ne peut pas connaitre nA ou nB séparément. Mais il n'en
a pas besoin.
BH tente sa chance et demande à s'authentifier auprès de A (il veut se
faire passer pour B) :
A BH
----------------------------------------
1 nA
2 génération de m1-2
3 m1-2'= m1-2 xor nA ===> m1-2'
4 (BH ne calcul pas m1-2 puisqu'il ne
connait pas nA)
5 génération de m2-2 (aléatoire)
6 m1-2" <================ m1-2" = m1- 2' xor m2-2 <--- on calcul
avec m1-2' et non m1-2
7 m2-2' <================ m2-2' = m2- 2 xor nA xor nB <-- on
calcul avec (nA xor nB) et non nB uniquement
A vérifie :
m1-2" xor m2-2' xor nB = m1-2
<=> m1-2' xor m2-2 xor m2-2 xor nA xor nB xor nB = m1-2 (par
substitution)
<=> m1-2' xor nA = m1-2 (par simplification)
<=> m1-2 = m1-2 (par substitution)
Sans connaitre nA ou nB, BH peut se faire passer pour B auprès de A
(i.e. passer le test) après avoir écouté uniquement les données
publiques d'un échange.
De plus, je précise que le chiffre de Vernam qui est basé sur des
clefs aléatoires et l'opération xor, est indécryptable uniquement
ssi :
- les clefs sont parfaitement aléatoires (impossible avec un
ordinateur qui est une machine déterministe)
- ET les clefs sont aussi longues que les données à transmette
- ET les clefs ne sont utilisées qu'une seule fois (puis complètement
détruites, difficile à réaliser sur un ordinateur).
En effet, deux messages (m1 et m2) chiffrés avec la même clef (K), par
simplification, cela donne m1 xor m2 (la clef s'élimine).
m1 xor m2 permet de récupérer des informations partielles, par exemple
si une partie de m1 ou m2 vaut 1 (ou 0).
Dans le monde réel, il y a souvent beaucoup de redondance dans les
données informatique (par exemple dans une image, un document
texte...etc) ce qui fait qu'on peut récupérer des informations (même
partielles) sur les données claires.
Si je n'ai pas fait d'erreur, je pense avoir trouvé la faille.
Si je résume votre protocole (ci-dessous, ===> signifie qu'on envoi quelque chose):
A B ---------------------------------------- 1 nA nB 2 génération de m1 3 m1'= m1 xor nA ===> m1' 4 m1 = m1' xor nA 5 génération de m2 6 m1" <============== m1" = m1 xor m2 7 m2' <============== m2' = m2 xor nB
A vérifie : m1" XOR m2' XOR nB = m1 <=> m1 xor m2 XOR m2 xor nB XOR nB = m1 (par substitution) <=> m1 = m1 (par simplification)
Dans ce protocole, quelqu'un qui écoute ce qui est échangé (on le nomme parfois Black Hat, noté BH) connait uniquement :
m1', m1" et m2' (dont il ne peut déduire nA ou nB si m1 et m2 sont bien aléatoires)
Il peut faire : m1' xor m1" xor m2' = m1 xor nA xor m1 xor m2 xor m2 xor nB (par substitution) = nA xor nB (par simplification)
Jusque là, BH ne peut pas connaitre nA ou nB séparément. Mais il n'en a pas besoin.
BH tente sa chance et demande à s'authentifier auprès de A (il veut se faire passer pour B) :
A BH ---------------------------------------- 1 nA 2 génération de m1-2 3 m1-2'= m1-2 xor nA ===> m1-2' 4 (BH ne calcul pas m1-2 puisqu'il ne connait pas nA) 5 génération de m2-2 (aléatoire) 6 m1-2" <================ m1-2" = m1- 2' xor m2-2 <--- on calcul avec m1-2' et non m1-2 7 m2-2' <================ m2-2' = m2- 2 xor nA xor nB <-- on calcul avec (nA xor nB) et non nB uniquement
A vérifie : m1-2" xor m2-2' xor nB = m1-2 <=> m1-2' xor m2-2 xor m2-2 xor nA xor nB xor nB = m1-2 (par substitution) <=> m1-2' xor nA = m1-2 (par simplification) <=> m1-2 = m1-2 (par substitution)
Sans connaitre nA ou nB, BH peut se faire passer pour B auprès de A (i.e. passer le test) après avoir écouté uniquement les données publiques d'un échange.
De plus, je précise que le chiffre de Vernam qui est basé sur des clefs aléatoires et l'opération xor, est indécryptable uniquement ssi : - les clefs sont parfaitement aléatoires (impossible avec un ordinateur qui est une machine déterministe) - ET les clefs sont aussi longues que les données à transmette - ET les clefs ne sont utilisées qu'une seule fois (puis complètement détruites, difficile à réaliser sur un ordinateur).
En effet, deux messages (m1 et m2) chiffrés avec la même clef (K), par simplification, cela donne m1 xor m2 (la clef s'élimine). m1 xor m2 permet de récupérer des informations partielles, par exemple si une partie de m1 ou m2 vaut 1 (ou 0).
Dans le monde réel, il y a souvent beaucoup de redondance dans les données informatique (par exemple dans une image, un document texte...etc) ce qui fait qu'on peut récupérer des informations (même partielles) sur les données claires.
Cordialement, Arnaud W. http://awr.free.fr
Benjamin Dauvergne
Le 12-08-2008, Arnaud W. a écrit :
Bonjour,
Si je n'ai pas fait d'erreur, je pense avoir trouvé la faille.
Merci pour cette réponse exhaustive.
Le 12-08-2008, Arnaud W. <ab6y5keot0gpy3h@jetable.net> a écrit :
Bonjour,
Si je n'ai pas fait d'erreur, je pense avoir trouvé la faille.
