Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

known plain text attack

14 réponses
Avatar
Senderos
Bonjour j'ai quelques questions a propos de ce niveau d'attaque en
cryptanalyse.

En supposant un cour texte crypt=E9 avec vig=E9n=E8re, on va dire d'une
longueur =E9gale =E0 cent caract=E8res
.
Kasiski m'a donn=E9 la longueur de la cl=E9, on va dire 8 mais je ne peux
pas aller plus loin, car l'analyse fr=E9quentielle des lettres ne donne
rien. Par contre je connais un mot en clair du ciphertext
correspondant.

Comment attaquer le chiffrement ?

- Si je connaissais la position du mot en clair dans le texte chiffr=E9
correspondant je n'aurais plus qu'a d=E9crypt=E9 avec ce mot comme cl=E9
en prennant soin d'ajuster le d=E9cryptement pour qu'il d=E9marre
exactement a la position du mot en clair dans le texte chiffr=E9,
j'aurais ainsi la cl=E9 de d=E9voil=E9 dans le resultat du texte
d=E9crypt=E9.

- Mais si je ne connais pas la position du mot en clair, donc je dois
faire un petit brute force : je dois d=E9crypter n fois (ou n est la
longueur du texte) en utilisant le mot en clair connu comme cl=E9 et je
commence a d=E9crypter le texte a chaque d=E9cryptage une position plus
loin.

Est ce bien la seule attaque possible ? est ce comme cela qu'on
l'impl=E9mente ? parmis les 100 d=E9cryptement que je vais devoir faire
pour trouver la cl=E9, il y a t'il un moyen de savoir quand est ce que
la cl=E9 a =E9t=E9 trouv=E9 (sinon ca va etre p=E9nible de chercher quelque
chose qui ressemble a une cl=E9 parmis les 100 textes d=E9chiffr=E9s).

Et si jamais la longueur de la portion de texte connu en clair est
inf=E9rieur a la la longueur de cl=E9, comment attaquer le chiffrement ?

Est cette attaque qui est appell=E9 "crib" ou "crib dragging" (ou
quelque chose du genre) en anglais ?

Merci pour vos =E9clairements.

4 réponses

1 2
Avatar
grapheus



Que le texte est un sens ou pas ca ne change rien pour ce que
souhaitais faire, c'etait juste pour illustrer, bon si tu veux un vrai
texte :

uhtfw aevol zllgs hxvqc srvgk ybzxa shtzx wxjpb kuiwd tezot uxpdq
zotux pdqzo wirqv jnkym oxwsb viiwo yeafi iwoki appaa lekcq uogrc
prbzs jqryg kxcpn rvgku orjxk tinor jxkti nofhv xqwmw zwyea fmwzw
vxrpj wchws bvhdp ftlnw zafuv wpthu arewr vitle ceonh jwdsp ndymq
sgtcr wxasg tcrwx asgtc rwxas gtcrw xasgp rkulp vgsev

mais je ne sais plus trop si ca illustre bien ce que voulais faire.


C'est vraiment un VRAI texte, je veux dire un texte écrit dans un
français correct, avec un sens ?..
Car il est étonnant d'y trouver vers la fin 8 lettres répétées
trois fois (sgtcrwxa)... Bon, on peut penser à un truc comme "Bon
dieu ! pourquoi? pourquoi. pourquoi ?"... Mais ça paraît bizarre...

grapheus



Oui c'est un vrai texte, mais disons pour illustrer ce que je voulais
faire, effectivement quelques mots se repetent voir lettres, mais comme
tu le dis, le mot "pourquoi" qui se répete 3 fois suite, j'aurais pu
en mettre un au début, un au milieu, un a la fin, tout en gardant le
sens du texte, ca aurait changé quoi ?


Ca fausse toutes les approches statistiques. Mais cela ne rend pas le
texte indéchiffrable pour autant. Simplement son déchiffrement "à la
main" car il y a trop d'hypothèses à tester. Il faut utiliser un
programme de calculateur (Je ne vais pas plus loin, car si je sais que
de tels programmes existent, je ne les connais pas, ne connaissant que
les "basics" en crypto).

grapheus


Mais bon, c'est comme le livre "disparition" ou il n'y a pas de E, on
pourrait très bien trouvé un texte écrit en bon francais, très
agréable a lire ou aucunes des frequences de ses lettres de se
distinguent plus que d'autres, ou alors pas les habituelles (e, a, n).
Ca existe très souvent surtout les cours textes, alors comment se
passe le décryptage dans ces cas la ?

Est ce possible ? et si l'on connait une partie du texte en clair ?




Avatar
grapheus

"Senderos" writes:

Que le texte est un sens ou pas ca ne change rien pour ce que
souhaitais faire, c'etait juste pour illustrer, bon si tu veux un vrai
texte :

uhtfw aevol zllgs hxvqc srvgk ybzxa shtzx wxjpb kuiwd tezot uxpdq
zotux pdqzo wirqv jnkym oxwsb viiwo yeafi iwoki appaa lekcq uogrc
prbzs jqryg kxcpn rvgku orjxk tinor jxkti nofhv xqwmw zwyea fmwzw
vxrpj wchws bvhdp ftlnw zafuv wpthu arewr vitle ceonh jwdsp ndymq
sgtcr wxasg tcrwx asgtc rwxas gtcrw xasgp rkulp vgsev

Voila par exemple pour le texte ci dessus, j'ai utilisé une clé de
longueur 8 et dans le texte il y a le mot "toujours". Est il possible
de faire une attaque par brute force avec comme clé le mot "toujours"
en esperant retrouver la clé dans tout les textes déchiffrer. Est ce
comme cela que vous fairiez si l'attaque traditionnelle (kasiski +
fréquences) ne marche pas ?


salut jaime raipo uvoir parti rtouj oursp luslo inala cammm mmmmm
mmmmm mmmmm pagne faire dufoo tball handb allte nnisp ingpo ngvol
lezsk ynaut iquek artin ggggg ggggg ggggg gguee tdufo othan dfoot
etenc orefo otave cchau ssure scram ponse tblab labla blabl abref
ppppp ppppp ppppp ppppp ppppp ppppp ppppl einde sport

Autrement dit:

salut j aimerai pouvoir partir toujours plus loin a la
cammmmmmmmmmmmmmmmmmpagne faire du football handball tennis pingpong
vollez sky nautique kartingggggggggggggggggue et du foot handfoot et
encore foot avec chaussures crampons et bla bla bla bla bla bref
pppppppppppppppppppppppppppppppppplein de sport


mais je ne sais plus trop si ca illustre bien ce que voulais faire.
Bon tu peux essayer de décrypter celui ci en regardant la fréquence
des lettres,


Bien si tu as un une partie du texte clair de longueur supérieure ou
égale à la clé, il n'y a pas besoin de faire des statistiques. Juste
avec un correcteur orthographique, on peut identifier le message
secret.


mais ma question etait : si l'analyse linguistique ne fonctionne pas,
comment déchiffrer du vigènere sachant que l'on a une infime partie
du texte clair.


Clairement, on a besoin d'avoir une façon d'identifier un texte clair.
Si on encrypte une séquence aléatoire, les séquences obtenues en
décryptant le texte secret avec toutes les clés possibles seront
toutes aléatoires: Edmont ne pourra pas identifier intrinsèquement la
bonne séquence aléatoire.

Avec du texte textuel, on peut identifier le clair facilement, quand
il suit les règles d'orthographe, de grammaire et sémantiques. Ça
fait pas mal de filtre pour sélectionner la bonne hypothèse.


Est ce faisable pour un long texte ? est ce une bonne méthode ? est ce
comme cela que l'on fait normalement lorsque l'on a tout essayé du
point de vue "fréquence des lettres" ?


Plus le texte est long, plus il y a de clés possible différentes. Mais
ça reste en O(n), et c'est borné par |alphabet|^|cle|: on ne fera pas
pire qu'une recherche exhaustive ; avoir une partie du texte clair
permet de d'éliminer des hypothèses fausses.




(defparameter *alphabet* "abcdefghijklmnopqrstuvwxyz")
(defun numerical (string)
(map 'vector (lambda (ch) (or (position ch *alphabet*) 25)) string))
(defun alphabetical (vector)
(map 'string (lambda (code) (if (< 26 code) #? (aref *alphabet* code)) ) vector))


(defun encode (clear key)
(mod (+ clear key) (length *alphabet*)))
(defun decode (secret key)
(mod (- secret key) (length *alphabet*)))

(defun encrypt (clear key)
(loop
:with secret = (make-array (length clear))
:for i :from 0 :below (length clear)
:for j = 0 :then (mod (1+ j) (length key))
:do (setf (aref secret i) (encode (aref clear i) (aref key j)))
:finally (return secret)))

(defun decrypt (secret key)
(loop
:with clear = (make-array (length secret))
:for i :from 0 :below (length secret)
:for j = 0 :then (mod (1+ j) (length key))
:do (setf (aref clear i) (decode (aref secret i) (aref key j)))
:finally (return clear)))

(defun gen-key-at (secret i clear-part)
(loop
:with key = (make-array (length clear-part))
:for c :from 0 :below (length clear-part)
:for s :from i
:for k = (mod i (length clear-part)) :then (mod (1+ k) (length cle ar-part))
:do (setf (aref key k) (decode (aref secret s) (aref clear-part c)))
:finally (return key)))

(defun gen-keys (secret clear-part)
(loop
:for i :from 0 :below (- (length secret) (length clear-part))
:collect (gen-key-at secret i clear-part)))


(defun try-decrypt (secret clear-part)
(let ((secret (numerical secret))
(clear-part (numerical clear-part)))
(loop
:for key :in (gen-keys secret clear-part)
:do (print (alphabetical (decrypt secret key))))))

(defparameter *secret*
(remove-if (lambda (ch) (member ch '(#space #newline))) "
uhtfw aevol zllgs hxvqc srvgk ybzxa shtzx wxjpb kuiwd tezot uxpdq
zotux pdqzo wirqv jnkym oxwsb viiwo yeafi iwoki appaa lekcq uogrc
prbzs jqryg kxcpn rvgku orjxk tinor jxkti nofhv xqwmw zwyea fmwzw
vxrpj wchws bvhdp ftlnw zafuv wpthu arewr vitle ceonh jwdsp ndymq
sgtcr wxasg tcrwx asgtc rwxas gtcrw xasgp rkulp vgsev
"))

(defparameter *clear-part* "toujours")
(defparameter *key-length* 8)



;; On identifie tout de suite le message:

LISP> (try-decrypt *secret* *clear-part*)

"toujoursnsapdafewcrgklidjfcdpufesgyapdcyjbjavnrwnavbhxdwnavbhxdwndjvipwk jfnspqfyupjagsrxepjagevxowbedyxzpbpkjwcoagtnilldjedtflidjbpvbrxqhupvbrxqhup jzpknvtxdosrxetxdopkooqxgzqfyuoetxnykvgbjmpjmsovejyjoupupwwrlmokavmckcfnuka gzqdyekagzqdyekagzqdyekagzqdyekacojbmtnafbu"
"ytoujoursxuayuidbhlrfflcokwokoidxlslkxfxogdlqhuvsfpmcrgvsfpmcrgvsidgdjzj okhdkkixzudlbmuwjudlbyywtbvpysayugjveqfnflnydfocojxeaflcogjgwlapmzjgwlapmzj uujnmayrojmuwjyrojjnntvrrukixztyeshbjalvuhjmlxtppesmnzuoarqukrtelqgfjhkhffu jyvispfujyvispfujyvispfujyvispfufnoggeiuiaz"
[...]
"ydjyxxdyshpemdrkbrgvtoujoursyxrkxvnpygoeoqypeqdcspkqqapcspkqqapcssykrsiq ouchytrezeyppvddjeypphhdtlqtmbjfuqezszoufvicroxjotsiooujoqekkujwmjekkujwmje yiswtaimsxvddjimsxswutfmvitrezdtigqkqavqyvsvsxdktsbvuzejefzdrrdzpepoqhucjtd sfvsnttdsfvsnttdsfvsnttdsfvsnttdouoqbiwdrhz"
"txmxrcxjnbsdgilvwljuntoujoursclvspqoslipjkboyvxnnjnpkfjnnjnpkfjnnmbjlxcb jofgsylpuybojaxoeybojmbooftsggdqpkhymeifaplbltrujnvhitoujkhjezdhhdhjezdhhdh xcxqevcprraxoecprrxqfozpucylpuxwhavebvptxpxpdsxnsmgpfuymdzexcmxcoyuibcofini mqqmqsnimqqmqsnimqqmqsnimqqmqsniifjkehqilsu"
"esgaqscdywmgfyqphgdxmjtoujoursqpdkkrrbnjufvrxlchyehsjvohyehsjvohyhvmknhv ujzjroqjftvriqciptvricgizanvfwikafbblunzlkfekjwouipkhjtoufbmdpibsybmdpibsyb abnvygxjuqqcipxjuqnvzzujxboqjfsqkzljvgknaonuxdshvlwuzftggyucwxswrxknvnjzlmy rkbhkvmyrkbhkvmyrkbhkvmyrkbhkvmynzufykpyqmf"
"ydbutreishhaixsubryrpivtoujoursuxvfluapooqqlakemspcmmuqmspcmmuqmssqgnmja ouudunsozeqllpenjeqllbintlipivkpuqwvotpefvayniytotkekivtoqwggokgmjwggokgmjw uemxdaieotpenjieotmxetferensozdlecklaaviurmwcxdcpovwezebabtebrdrlajpahuufpx tpvsfppxtpvsfppxtpvsfppxtpvsfppxpeoqtesxsrz"
"dxmpnudgxbsvcarsgljmjlurtoujourscpqgodomtkbgundkxjnhgxpkxjnhgxpkxmbbhpiy tofyoqrmeybgfsdloybgfehlyftkcyjnzkhqiwockplthlxrtnvzelurtkhbarjerdhbarjerdh pypwbfcpjnsdlocpjnpwcyzpmyqrmexwzwnkyfptplpvacxnkiyvceymvvwdzwxcgumoymofaja snamqkjasnamqkjasnamqkjasnamqkjaoctkezmarpe"
"tcgaiogfngmgxuurwqdxefxqjtoujoursukrjxrljpvrphgjnohsbrsjnohsbrsjnrvmcjlx jtzjjkuludvramgkedvraykkoknvxsmmppbbdqrbaufecfaqjspkzfxqjpbmvlmdhibmvlmdhib atjzavhjuimgkehjuijzboejxtkulucqkrhnxvunagjyzschvdsybudggqqgymcwrpgrxctzleu vmqrkveuvmqrkveuvmqrkveuvmqrkveurbjpykhuuou"
"salutjaimeraipouvoirpartirtoujoursplusloinalacammmmmmmmmmmmmmmmmmpagnefa iredufootballhandballtennispingpongvollezskynautiquekartinggggggggggggggggg ueetdufoothandfootetencorefootavecchaussurescramponsetblablablablablabrefpp ppppppppppppppppppppppppppppppppleindesport"
"vzoznuvcpdufcajoynlwjlmnlqwtoujoursqodgilmdqunvgplprgxhgplprgxhgpodlhpau lqhioqjiwadqfsvhgadqfezhqhvucybjrmjaiwgycrndhlpnlpxjelmnlmjlarbajfjlarbajfj zypoxxertnsvhgertnpoyqbrwyqjiwzyjwncuxrvzlpnwuzpuiynywaofvwvvozequmgueqhkja kjsosujakjsosujakjsosujakjsosujagylmgjmajlw"
"pcnbsogxjgthhuujsqkyofxiftvvtoujourstxrdfpcszhgbjootlrsbjootlrsbjrcnmjlp ftgktkudqdcskmgcadcskykckkuwhsmelpicnqrtwumfmfaifswljfxifpinflmvdiinflmvdii bdjzsrhqvsmgcahqvsjztkeqydkudqcxlbhnpruubqjyrocownsytqdnhaqgqicdszgrpytgmou vemrrwouvemrrwouvemrrwouvemrrwourtfpflruugq"
"kwqartaieawggzounknxnkrtanyustoujourscloajfrymameirskwmmeirskwmmelfmlofa anjjspoolxfrjranvxfrjdenfexvgxgpgjlbmvleropelkutamzkikrtajlmeqggyclmeqggycl acotdmbturranvbturotefytxcpoolwakamhamoxaposcjwrvmxselxqgzvabdwgryllatnjlnz pphluvnzpphluvnzpphluvnzpphluvnzleajikqzorl"
"vrkdqjfcpvqjfptoyfhamawnlisxrjtoujoursqilezuxcfgpdlvjmrgpdlvjmrgpgzpkeku lidmrftiwszuihfhgszuitjhqzryfnljrefellqycjjhkaznlhtnhawnlefpdglajxfpdglajxf dbeyxxwnxqhfhgwnxqeyyqtnabftiwrunzcmuxjrdoexwurlylnxywskjylfvorauxbqueidomp ujsgoympujsgoympujsgoympujsgoympqylecnpptlw"
"pcfxtihhjgldiovtsqcupzysftnruivtoujoursnfpuoabhljogpmltljogpmltljrujndmz ftyguevnqduolghmaduolslmkkmsimnolpayoksdwuebnzbsfsohkzysfpajgfnfdiajgfnfdia xedacrhirtghmahirtdadkeiueevnqcphcbozrumxrdzbocgsomzdqdfdbkhaicvoaaszytyipo womrjspowomrjspowomrjspowomrjsposdfpxhsovqq"
[...]

--
__Pascal Bourguignon__ http://www.informatimago.com/


Ah, je savais bien qu'il exitait un programme pour résoudre un texte
codé en Vigenère. Merci à Pascal de l'avoir donné... Une variante
(tout aussi longue) est de chercher la clef quand elle a un sens, ce
qui était le cas ici puisque c'est "children".

grapheus


Avatar
Senderos
Merci Pascal Bourguignon;
tu as répondu à mes interrogations à la perfection

La variante, rechercher la clé, c'est le semblant d'algorithme que
j'avais donné ?
"En prennant le mot ou la partie en clair que l'on connait comme clé
on décrypte le message a chaque fois en commencant une position plus
loin ..." ?
Avatar
grapheus

Merci Pascal Bourguignon;
tu as répondu à mes interrogations à la perfection

La variante, rechercher la clé, c'est le semblant d'algorithme que
j'avais donné ?
"En prennant le mot ou la partie en clair que l'on connait comme clé
on décrypte le message a chaque fois en commencant une position plus
loin ..." ?


Oui, c'est ça.

grapheus

1 2