OVH Cloud OVH Cloud

Simple algo: 4e étape - la clef de session

32 réponses
Avatar
Raymond H.
Étape 4 du simple algo:

"Christophe HENRY" <forumslkm.sbgodin@nerim.net.sans_lkm> a écrit dans le
message de news: csc16i$31i4$1@biggoron.nerim.net...
> Le Sat, 15 Jan 2005 13:42:43 -0500, Raymond H. a écrit :
>
>> Dans ce cas ce ne serait pas vraiment sur l'algo de cryptage du clair
>> qu'il faudrait se pencher mais sur l'algo de prolongement d'une clef,
>
> C'est une erreur. Je vais faire description imagée. Imagine que la clé
> en question fasse deux caractères a et b, tu la prolonges de un
> caractère au moyen de l'opération c=a+b.
> La clé est ainsi (a,b,c). Question : (a,b,c) peut-il avoir toutes les
> combinaisons possibles de a,b et c ? Il s'agit de l'une des conditions
> draconiennes imposées à l'OTP auquel ton algo est, au mieux, équivalent.
>
> La réponse est non : le nombre de combinaisons ne sera que de 256², le
> troisième élément étant dépendant des deux autres. Or, la clé doit
> remplir entièrement les possibilités de combinaisons, soit 256**3, pour
> être correcte.
>
Il est presque certain qu'avec c=a+b ça ne tiendra pas. On suppose que
la clef doit avoir un minimum de caractères: 32 bits par exemple.

k = 1-2-3-4 (clef de session initiale créée aléatoirement)
m = 5-6-7-8-9-0 (clair)
x = 0 (au départ)
k5 = (((k2 + k3) xor m1) + k4) Modulo 256
c(x+1) = (((k1 + m(x+1) xor k2) + k1) Modulo 256 [Je simplifie ici]
x = x + 1

Dans notre exemple, on conserverait toujours 4 caractères dans notre
clef de session puisqu'elle avait 4 caractères lors de son initialisation.
donc k = 1-2-3-4
donc m = 5-6-7-8-9-0

1a- k5 = ((k2 + k3) xor m1) + k4
k5 = ((2 + 3) xor 5) + 4 = 4
donc k = 1-2-3-4-4

1b- k = k2, k3, k4, k5 = 2-3-4-4
donc k = 2-3-4-4

1c- c1 = ((k1 + m1) xor k2) + k1
c1 = ((2 + 5) xor 3) + 2 = 6
donc c = 6

2a- k5 = ((k2 + k3) xor m2) + k4
k5 = ((3 + 4) xor 6) + 4 = 5
donc k = 2-3-4-4-5

2b- k = k2, k3, k4, k5
donc k = 3-4-4-5

2c- c2 = ((k1 + m2) xor k2) + k1
c2 = ((3 + 6) xor 4) + 3 = 16
donc c = 6-16

3a- k5 = ((k2 + k3) xor m3) + k4
k5 = ((4 + 4) xor 7) + 5 = 20
donc k = 3-4-4-5-20

3b- k = k2, k3, k4, k5
donc k = 4-4-5-20

3c- c3 = ((k1 + m3) xor k2) + k1
c3 = ((4 + 7) xor 4) + 4 = 19
donc c = 6-16-19

4a- k5 = ((k2 + k3) xor m4) + k4
k5 = ((4 + 5) xor 8) + 20 = 21
donc k = 4-4-5-20-21

4b- k = k2, k3, k4, k5
donc k = 4-5-20-21

4c- c4 = ((k1 + m4) xor k2) + k1
c4 = ((4 + 8) xor 5) + 4 = 13
donc c = 6-16-19-13

5a- k5 = ((k2 + k3) xor m5) + k4
k5 = ((5 + 20) xor 9) + 21 = 37
donc k = 4-5-20-21-37

5b- k = k2, k3, k4, k5
donc k = 5-20-21-37

5c- c5 = ((k1 + m5) xor k2) + k1
c5= ((5 + 9) xor 20) + 5 = 31
donc c = 6-16-19-13-31

6a- k5 = ((k2 + k3) xor m6) + k4
k5 = ((20 + 21) xor 0) + 37 = 78
donc k = 5-20-21-37-78

6b- k = k2, k3, k4, k5
donc k = 20-21-37-78

6c- c6 = ((k1 + m6) xor k2) + k1
c6 = ((20 + 0) xor 21) + 20 = 21
donc c = 6-16-19-13-31-21

On conserve donc la clef de session finale 20-21-37-78 pour pouvoir
déchiffrer le cryptogramme 6-16-19-13-31-21
En résumé avec:
m = 5-6-7-8-9-0
k = 1-2-3-4

on produit:

k = 2-3-4-4
c = 6

k = 3-4-4-5
c = 6-16

k = 4-4-5-20
c = 6-16-19

k = 4-5-20-21
c = 6-16-19-13

k = 5-20-21-37
c = 6-16-19-13-31

k = 20-21-37-78
c = 6-16-19-13-31-21

La question est: 'Pouvons-nous trouver le clair à partir de l'algo et du
chiffré 6-16-19-13-31-21 ?
x = 0 (au départ)
k5 = (((k2 + k3) xor m1) + k4) Modulo 256
c(x+1) = (((k1 + m(x+1) xor k2) + k1) Modulo 256
x = x + 1

Ici, j'ai fait un peu vite la partie de l'algo pour le prolongement de
la clef de session; faudrait regarder la façon la plus sûre. Mais, on
pourrait faire les additions et les xor avec d'autres valeurs:
Par exemple, au lieu de faire
k5 = ((k2 + k3) xor m1) + k4

on pourrait faire (en ajoutant le modulo que je n'ai pas mis pour que ce
soit plus simple à l'oeil):
k5 =( ((k2 + m1) xor k3) + k4) Modulo 256

Bonne journée.
Raymond H.

=================
N.B.:
En transformant
c1=(((k1 + k2 + m1 + m2) xor k2) + k1) Mod 256
c2=(((k2 + k3 + m2 + m3) xor k3) + k2) Mod 256
c3=(((k3 + k4 + m3 + k4 ) xor k4) + k3) Mod 256 (k4 remplace aussi m4)

en

c1=(((k1 + m1) xor k2) + k1) Mod 256
c2=(((k2 + m2) xor k3) + k2) Mod 256
c3=(((k3 + m3) xor k4) + k3) Mod 256 (k4 remplace aussi m4)

? ? ? ? = k
8 12 21 = 1m
32 51 62 = 1c
donne 256 clefs au lieux de 640.
000-040-063-171
001-022-063-171
002-020-063-171
003-022-063-171
004-016-063-171
005-022-063-171
006-020-063-171
007-022-063-171
008-008-063-171
009-006-063-171
010-004-063-171
011-006-063-171
012-000-063-171
013-006-063-171
014-004-063-171
015-006-063-171
016-008-063-171
017-022-063-171
018-020-063-171
019-022-063-171
020-016-063-171
021-022-063-171
022-020-063-171
023-022-063-171
024-040-063-171
025-038-063-171
026-036-063-171
027-038-063-171
028-032-063-171
029-038-063-171
030-036-063-171
031-038-063-171
032-040-063-171
033-214-191-171
034-212-191-171
035-214-191-171
036-208-191-171
037-214-191-171
038-212-191-171
039-214-191-171
040-200-191-171
041-198-191-171
042-196-191-171
043-198-191-171
044-192-191-171
045-198-191-171
046-196-191-171
047-198-191-171
048-200-191-171
049-214-191-171
050-212-191-171
051-214-191-171
052-208-191-171
053-214-191-171
054-212-191-171
055-214-191-171
056-168-063-171
057-166-063-171
058-164-063-171
059-166-063-171
060-160-063-171
061-166-063-171
062-164-063-171
063-166-063-171
064-168-063-171
065-150-063-171
066-148-063-171
067-150-063-171
068-144-063-171
069-150-063-171
070-148-063-171
071-150-063-171
072-136-063-171
073-134-063-171
074-132-063-171
075-134-063-171
076-128-063-171
077-134-063-171
078-132-063-171
079-134-063-171
080-136-063-171
081-150-063-171
082-148-063-171
083-150-063-171
084-144-063-171
085-150-063-171
086-148-063-171
087-150-063-171
088-168-063-171
089-166-063-171
090-164-063-171
091-166-063-171
092-160-063-171
093-166-063-171
094-164-063-171
095-166-063-171
096-168-063-171
097-214-191-171
098-212-191-171
099-214-191-171
100-208-191-171
101-214-191-171
102-212-191-171
103-214-191-171
104-200-191-171
105-198-191-171
106-196-191-171
107-198-191-171
108-192-191-171
109-198-191-171
110-196-191-171
111-198-191-171
112-200-191-171
113-214-191-171
114-212-191-171
115-214-191-171
116-208-191-171
117-214-191-171
118-212-191-171
119-214-191-171
120-040-063-171
121-038-063-171
122-036-063-171
123-038-063-171
124-032-063-171
125-038-063-171
126-036-063-171
127-038-063-171
128-040-063-171
129-022-063-171
130-020-063-171
131-022-063-171
132-016-063-171
133-022-063-171
134-020-063-171
135-022-063-171
136-008-063-171
137-006-063-171
138-004-063-171
139-006-063-171
140-000-063-171
141-006-063-171
142-004-063-171
143-006-063-171
144-008-063-171
145-022-063-171
146-020-063-171
147-022-063-171
148-016-063-171
149-022-063-171
150-020-063-171
151-022-063-171
152-040-063-171
153-038-063-171
154-036-063-171
155-038-063-171
156-032-063-171
157-038-063-171
158-036-063-171
159-038-063-171
160-040-063-171
161-214-191-171
162-212-191-171
163-214-191-171
164-208-191-171
165-214-191-171
166-212-191-171
167-214-191-171
168-200-191-171
169-198-191-171
170-196-191-171
171-198-191-171
172-192-191-171
173-198-191-171
174-196-191-171
175-198-191-171
176-200-191-171
177-214-191-171
178-212-191-171
179-214-191-171
180-208-191-171
181-214-191-171
182-212-191-171
183-214-191-171
184-168-063-171
185-166-063-171
186-164-063-171
187-166-063-171
188-160-063-171
189-166-063-171
190-164-063-171
191-166-063-171
192-168-063-171
193-150-063-171
194-148-063-171
195-150-063-171
196-144-063-171
197-150-063-171
198-148-063-171
199-150-063-171
200-136-063-171
201-134-063-171
202-132-063-171
203-134-063-171
204-128-063-171
205-134-063-171
206-132-063-171
207-134-063-171
208-136-063-171
209-150-063-171
210-148-063-171
211-150-063-171
212-144-063-171
213-150-063-171
214-148-063-171
215-150-063-171
216-168-063-171
217-166-063-171
218-164-063-171
219-166-063-171
220-160-063-171
221-166-063-171
222-164-063-171
223-166-063-171
224-168-063-171
225-214-191-171
226-212-191-171
227-214-191-171
228-208-191-171
229-214-191-171
230-212-191-171
231-214-191-171
232-200-191-171
233-198-191-171
234-196-191-171
235-198-191-171
236-192-191-171
237-198-191-171
238-196-191-171
239-198-191-171
240-200-191-171
241-214-191-171
242-212-191-171
243-214-191-171
244-208-191-171
245-214-191-171
246-212-191-171
247-214-191-171
248-040-063-171
249-038-063-171
250-036-063-171
251-038-063-171
252-032-063-171
253-038-063-171
254-036-063-171
255-038-063-171
Fin

10 réponses

1 2 3 4
Avatar
Raymond H.
Bonjour,

je voudrais mentionner qu'à cette étape 4 c'est la sûreté de la clef et
de l'algo qui prime.



Je préfère que l'utilisateur puisse utiliser à volonté une phrase de
passe qui elle, génère un code d'identification de la phrase de passe et
crypte la clef de session finale avec ce code d'identification. Ce pourrait
être le sujet de l'étape 5 après être arriver à un moyen de prolonger la
clef de session de façon sûre.

Donc, la clef de session est créée aléatoirement au début (du même
nombre de caractères que la phrase de passe), puis prolongée via l'algo, les
valeurs du clair et de la clef de session elle-même; cela de la manière que
j'ai décrite dans mon message précédent.



Raymond H.
Avatar
Christophe HENRY

Étape 4 du simple algo:


Cassé. Et je me suis amélioré au niveau de la rapidité :-)

$ time ./sae
[ ,201,178,155] : [103, 77, 22,113,100,102]
nbCles : 1

real 0m0.003s
user 0m0.003s
sys 0m0.000s


...
Ici, j'ai fait un peu vite la partie de l'algo pour le prolongement de
la clef de session; faudrait regarder la façon la plus sûre. Mais, on
pourrait faire les additions et les xor avec d'autres valeurs:
Par exemple, au lieu de faire k5 = ((k2 + k3) xor m1) + k4
on pourrait faire (en ajoutant le modulo que je n'ai pas mis pour que ce
soit plus simple à l'oeil):
k5 =( ((k2 + m1) xor k3) + k4) Modulo 256


Aucun effet visible sur ma méthode. Par ailleurs, agrandir la taille de
la clé ne va avoir aucune influence sur mes calculs.


Histoire de voir si je n'ai pas fait d'erreur :
M=[ 99; 78; 45; 85; 1;225]
K=[251;201;178;155]
Donne-t-il bien le chiffré C=[103; 77; 22;113;100;102] ?

Envoie ensuite envoi un clair et son chiffré pour voir...

Au suivant !

--
Christophe HENRY
(sans lkm)
GnuPG : 3922239E60036EC86BF7268A877C52AC 4883C02A

Avatar
Raymond H.
Bonjour,

"Christophe HENRY" a écrit dans le
message de news: cse612$t7j$

Étape 4 du simple algo:


Cassé.


Non. Meilleure chance la prochaine fois ;-)
Juste une valeur à corriger.

Et je me suis amélioré au niveau de la rapidité :-)


Ça été très rapide.

Histoire de voir si je n'ai pas fait d'erreur :
M=[ 99; 78; 45; 85; 1;225]
K=[251;201;178;155]
Donne-t-il bien le chiffré C=[103; 77; 22;113;100;102] ?


Non, mais presque. La réponse est C=[103; 77; 22;113;100;200]. Ça ne
donnait pas la même réponse avec mes codes, alors j'ai dû recommencer à la
main pour être certain, mais c'est bien votre dernière valeur qui est
fausse.
L'avez-vous calculé à l'aide de Scilab?
L'avez-vous calculé seulement à partir de l'algo et du chiffré ou bien
l'avez-vous calculé à partir de l'algo, du chiffré et du clair? Car
j'aimerais savoir dans un premier temps s'il est possible, à partir
seulement du chiffré et de l'algo, de trouver le clair. C'est le point le
plus important.
Avez-vous essayé en cherchant plusieurs clefs possibles (par logiciel ou
autres) ou bien avez-vous tentez par une inversion de l'algo seulement?

Voici le chiffré 225-111-037-088-088-057 suivant à partir duquel on doit
essayer de trouver le clair avec l'aide de l'algo seulement? Mais avec la
1re façon, c'est à dire avec c(x+1) = (((k1 + m(x+1)) xor k2) + k1) Modulo
256

Je fais remarquer que je n'avais pas reproduis exactement l'étape 3 du
'Simple algo' dans le 1er message de ce fil (étape 4). Car j'ai mis la
ligne de code simplifiée selon que vous aviez suggéré disant qu'il n'y avait
pas de différence entre elle et celle de l'étape 3. Voudriez-vous tentez
l'expérience avec la ligne de l'étape 3 aussi? C'est à dire, avec la ligne
qui n'est pas simplifiée; et cela afin de me dire si l'algo est cassable de
cette façon.
Voici donc le chiffré, à partir duquel trouver le clair:
129-153-008-071-039-248

x=0
c(x+1)=(((k1 + k2 + m(x+1) + m(x+2)) xor k2) + k1) Mod 256
x=x+1

On fait ainsi en conformité avec la ligne de l'étape 3 du 'Simple algo':

1a- k5 = (((k2 + k3) xor m1) + k4) Modulo 256

1b- k = k2, k3, k4, k5

1c- c1)=(((k1 + k2 + m1 + m2)) xor k2) + k1) Mod 256

2a- k5 = (((k2 + k3) xor m2) + k4) Modulo 256

2b- et ainsi de suite...
[Attention! À la dernière ligne, pour le 'c6 =' on remplace le m7 par le
k2 puisque le m7 n'existe pas dans notre exemple.]

a+
Raymond H.


Avatar
Christophe HENRY

Cassé.


Non. Meilleure chance la prochaine fois ;-)
Juste une valeur à corriger.


Si si. Il l'est. Je m'étais juste trompé dans le programme. Même pas
dans l'algo lui-même mais dans l'appel de fonction : j'avais mis 255 au
lieu de 225 pour le clair...


L'avez-vous calculé à l'aide de Scilab?


Langage C. Mais en fait, cela se calcule avec des formules
mathématiques. Qu'importe l'outil pourvu qu'on ait le résultat.


L'avez-vous calculé seulement à partir de l'algo et du chiffré ou bien
l'avez-vous calculé à partir de l'algo, du chiffré et du clair?


Attaque à clair connu.


Car j'aimerais savoir dans un premier temps s'il est possible, à
partir seulement du chiffré et de l'algo, de trouver le clair. C'est
le point le plus important.


Il est possible, à mon avis, de remonter jusqu'au clair avec le chiffré
seul. Là ou tu vois un calcul itératif compliqué, il n'y a que deux
couches de chiffrement successifs et distincts introduisant beaucoup de
redondances.

La clé de session est fonction de la phrase de passe.
S=f(M,P) qui peut être calculé *totalement* avant le chiffrement.
C=f(M,S) qui est le chiffrement proprement dit.

Je ne crains que je ne sache pas expliquer de manière claire mes calculs
dans ce cas.


Avez-vous essayé en cherchant plusieurs clefs possibles (par logiciel
ou autres) ou bien avez-vous tentez par une inversion de l'algo
seulement?


L'algo a été complétement inversé. Tu peux augmenter à plein
d'octets la phrase de passe ou le chiffré que ça ne changera strictement
rien. Faire de la force brute sur 4 octet reste facile et ce n'est pas
représentatif des cas ou cette phrase de passe est plus longue.


Voici le chiffré 225-111-037-088-088-057 suivant à partir duquel
on doit essayer de trouver le clair avec l'aide de l'algo seulement?


Je pense que c'est possible, vu mes calculs théoriques. Mais je n'ai pas
la quantité de temps avec mes compétences pour ce faire. Il faudrait
augmenter l'un ou l'autre et ce n'est pas à l'ordre du jour.
Ce n'est pas que c'est compliqué : les idées suivent la secondes où
j'ai fini de comprendres tes phrases de dix kilomètres. Après, il faut
rédiger, prototyper, tester...


Mais avec la 1re façon, c'est à dire avec c(x+1) = (((k1 + m(x+1)) xor
k2) + k1) Modulo 256


Je travaille avec les spécifications de départ. Les changements vont
juste me faire perdre du temps sans solidifier le procédé.


Je fais remarquer que je n'avais pas reproduis exactement l'étape 3
du 'Simple algo' dans le 1er message de ce fil (étape 4). Car j'ai
mis la ligne de code simplifiée selon que vous aviez suggéré disant
qu'il n'y avait pas de différence entre elle et celle de l'étape 3.
Voudriez-vous tentez l'expérience avec la ligne de l'étape 3 aussi?


Aucun intérêt. J'ai apprécié la simplification apporté au prototype
qui évite de me faire perdre du temps. Compliquer les plus ou les moins
ne changera rien.
J'ai suffisament prouvé que je savais casser tes produits en en apportant
la preuve pour me passer de complications inutiles.


C'est à dire, avec la ligne qui n'est pas simplifiée; et cela afin de
me dire si l'algo est cassable de cette façon.
Voici donc le chiffré, à partir duquel trouver le clair:
129-153-008-071-039-248


Il me faut des spécifications complètes, claires, sans ambiguité,
uniques, stables, documentées avec des exemples de résultats de calculs.


Tu cumules deux algos de chiffrement : un pour construire D'ABORD une clé
de session aussi longue que le clair à la base de la phrase de passe, un
autre pour chiffrer le clair à l'aide de la clé de session qui n'est
pas aléatoire. C'est faible, lourd et apporte une sécurité illusoire.

--
Christophe HENRY
(sans lkm)
GnuPG : 3922239E60036EC86BF7268A877C52AC 4883C02A


Avatar
Mister Jack
Salut !

l'avez-vous calculé à partir de l'algo, du chiffré et du clair? Car
j'aimerais savoir dans un premier temps s'il est possible, à partir
seulement du chiffré et de l'algo, de trouver le clair. C'est le point le
plus important.


Pour ma part, je regarde de ce côté. Au premier coup d'oeil on voit
qu'une attaque à clair connu marchera encore très facilement.
Pour l'instant j'en suis à faire des essais et trouver des méthodes
d'optimisation. Les temps de calculs seront (a priori) plus longs
qu'avec une attque à clair connu.

Voici le chiffré 225-111-037-088-088-057 suivant à partir duquel on doit
essayer de trouver le clair avec l'aide de l'algo seulement? Mais avec la
1re façon, c'est à dire avec c(x+1) = (((k1 + m(x+1)) xor k2) + k1) Modulo
256


Je suis parti là-dessus ce matin.

Je fais remarquer que je n'avais pas reproduis exactement l'étape 3 du
'Simple algo' dans le 1er message de ce fil (étape 4). Car j'ai mis la
ligne de code simplifiée selon que vous aviez suggéré disant qu'il n'y avait
pas de différence entre elle et celle de l'étape 3. Voudriez-vous tentez
l'expérience avec la ligne de l'étape 3 aussi? C'est à dire, avec la ligne
qui n'est pas simplifiée; et cela afin de me dire si l'algo est cassable de
cette façon.
Voici donc le chiffré, à partir duquel trouver le clair:
129-153-008-071-039-248


Décidez-vous !!! Je suis parti sur le premier pour me détendre un peu.
Je continuerai parce qu'il me semble plus amusant. Je ne pense pas m'en
prendre à l'ancienne méthode après, sauf si mon programme s'y adapte
facilement.

@Tchao !
--
Mister Jack (MJ)
"Linux c'est pas pour les manchots !"
Un don pour les victimes du Tsunami : http://www.croix-rouge.fr/

Avatar
Raymond H.
Bonjour,
j'ai pris assez de temps à répondre ce message-ci car j'ai relu beaucoup
de message que vous et 'Mister Jack' aviez écris auparavant aux étapes 1, 2
et 3 du 'Simple Algo'. J'ai relu plusieurs de vos commentaires pour mieux
m'en souvenir.

"Christophe HENRY" a écrit dans le
message de news: csg2s7$1mor$

Cassé.


Non. Meilleure chance la prochaine fois ;-)
Juste une valeur à corriger.


Si si. Il l'est. Je m'étais juste trompé dans le programme. Même pas
dans l'algo lui-même mais dans l'appel de fonction : j'avais mis 255 au
lieu de 225 pour le clair...


Non non. Vous n'avez pas cassé l'algo :-)

Relisez bien ma question:

La question était: " 'Pouvons-nous trouver le clair à partir de l'algo
et du chiffré 6-16-19-13-31-21 ? "

Vous n'avez pas trouvé le clair puisque vous vous êtes créé vous-même un
clair :-)



Voici ce que vous m'avez écris:

*****

Histoire de voir si je n'ai pas fait d'erreur :
M=[ 99; 78; 45; 85; 1;225]
K=[251;201;178;155]
Donne-t-il bien le chiffré C=[103; 77; 22;113;100;102] ?
*****
Vous dites ici que votre erreur était d'écrire 255 dans votre programme
au lieu de 225. Or ce 225 fait partie du clair dans votre exemple juste
ci-avant. Vous vous êtes donc créé un clair (vous dites aussi plus bas que
c'est une attaque à clair connu que vous avez fait; or, vous n'étiez pas
supposé de savoir le clair à l'avance mais seulement le chiffré), et je
m'imagine que vous vous êtes créer une clef aussi; et cela afin de trouver
le chiffré correspondant. Je trouve ça drôle :-) car il fallait trouver le
clair et non le créer pour trouver le chiffré. Dans ce cas vous n'avez donc
pas cassé l'algo de l'étape 4.



Si vous désirez refaire le teste, je vous redonne le chiffré
225-111-037-088-088-057 suivant à partir duquel vous pouvez essayer de
trouver le clair avec l'aide de l'algo seulement? Car l'utilisateur qui
crypte un fichier se retrouverait seulement avec le chiffré et l'algo pour
essayer de trouver le clair. Ça ne devrait pas déranger trop vos calculs
puisque ça demeure avec la même façon de faire, c'est à dire avec c1 = (((k1
+ m1) xor k2) + k1) Modulo 256


L'avez-vous calculé seulement à partir de l'algo et du chiffré ou bien
l'avez-vous calculé à partir de l'algo, du chiffré et du clair?


Attaque à clair connu.


Car j'aimerais savoir dans un premier temps s'il est possible, à
partir seulement du chiffré et de l'algo, de trouver le clair. C'est
le point le plus important.


Il est possible, à mon avis, de remonter jusqu'au clair avec le chiffré
seul. Là ou tu vois un calcul itératif compliqué, il n'y a que deux
couches de chiffrement successifs et distincts introduisant beaucoup de
redondances.

La clé de session est fonction de la phrase de passe.
S=f(M,P) qui peut être calculé *totalement* avant le chiffrement.
C=f(M,S) qui est le chiffrement proprement dit.

Je ne crains que je ne sache pas expliquer de manière claire mes calculs
dans ce cas.


Avez-vous essayé en cherchant plusieurs clefs possibles (par logiciel
ou autres) ou bien avez-vous tentez par une inversion de l'algo
seulement?


L'algo a été complétement inversé.



Ici, ce n'est pas clair pour moi, puisque vous dîtes avoir fait une
attaque avec le clair connu, et ici vous dites avoir inversé l'algo.
Pouvez-vous me préciser les étapes que vous avez faites? Je m'imagine que
ça doit être à partir du clair.


Tu peux augmenter à plein
d'octets la phrase de passe ou le chiffré que ça ne changera strictement
rien. Faire de la force brute sur 4 octet reste facile et ce n'est pas
représentatif des cas ou cette phrase de passe est plus longue.


Voici le chiffré 225-111-037-088-088-057 suivant à partir duquel
on doit essayer de trouver le clair avec l'aide de l'algo seulement?


Je pense que c'est possible, vu mes calculs théoriques.


Donc, vous n'avez pas cassé l'algo puisque vous n'avez pas trouvé le
clair à partir du chiffré.

Mais je n'ai pas
la quantité de temps avec mes compétences pour ce faire. Il faudrait
augmenter l'un ou l'autre et ce n'est pas à l'ordre du jour.
Ce n'est pas que c'est compliqué : les idées suivent la secondes où
j'ai fini de comprendres tes phrases de dix kilomètres. Après, il faut
rédiger, prototyper, tester...


Mais avec la 1re façon, c'est à dire avec c(x+1) = (((k1 + m(x+1)) xor
k2) + k1) Modulo 256


Je travaille avec les spécifications de départ. Les changements vont
juste me faire perdre du temps sans solidifier le procédé.


Je fais remarquer que je n'avais pas reproduis exactement l'étape 3
du 'Simple algo' dans le 1er message de ce fil (étape 4). Car j'ai
mis la ligne de code simplifiée selon que vous aviez suggéré disant
qu'il n'y avait pas de différence entre elle et celle de l'étape 3.
Voudriez-vous tentez l'expérience avec la ligne de l'étape 3 aussi?


Aucun intérêt. J'ai apprécié la simplification apporté au prototype
qui évite de me faire perdre du temps. Compliquer les plus ou les moins
ne changera rien.
J'ai suffisament prouvé que je savais casser tes produits en en apportant
la preuve pour me passer de complications inutiles.


C'est à dire, avec la ligne qui n'est pas simplifiée; et cela afin de
me dire si l'algo est cassable de cette façon.
Voici donc le chiffré, à partir duquel trouver le clair:
129-153-008-071-039-248


Il me faut des spécifications complètes, claires, sans ambiguité,
uniques, stables, documentées avec des exemples de résultats de calculs.


Tu cumules deux algos de chiffrement : un pour construire D'ABORD une clé
de session aussi longue que le clair à la base de la phrase de passe,


Plutôt à la base de la clef de session initiale, puisque je n'ai pas
écris de phrase de passe dans cette étape encore.

un
autre pour chiffrer le clair à l'aide de la clé de session qui n'est
pas aléatoire.


La clef de session initiale serait aléatoire, et par la suite elle
serait prolongée à partir d'elle-même et du clair. Ceci via des additions
et des xor. Or, le xor est une bonne chose de l'utiliser.


C'est faible, lourd et apporte une sécurité illusoire.


C'est votre opinion.

Bonne journée
Raymond H.



Avatar
Mister Jack
Salut !

Non non. Vous n'avez pas cassé l'algo :-)
Relisez bien ma question:
La question était: " 'Pouvons-nous trouver le clair à partir de l'algo
et du chiffré 6-16-19-13-31-21 ? "


Après avoir un peu testé l'algo, je dois dire que cette attaque à clair
connu est démonstrative de la faiblesse de l'algo.
Avec uniquement du bruit blanc en entrée de l'algo il n'est pas
extrêmement simple de trouver la clé utilisée, mais avec juste quelques
infos éparses on y arrive très facilement.
J'ai fais un programme d'une trentaine de lignes, qui ne trouve pas la
clé à partir du chiffré seul, mais trouve la clé à partir du moment où
il sait que le clair était une image JPEG. Cette seule info suffit à
permettre une attaque réussie.

Si vous désirez refaire le teste, je vous redonne le chiffré
225-111-037-088-088-057 suivant à partir duquel vous pouvez essayer de
trouver le clair avec l'aide de l'algo seulement?


Cette question montre bien votre méconaissance des méthodes utilisées
pour faire sauter votre système. Donner 48bits d'infos et dire : "quel
est le clair ?", c'est exactement le même que si vous nous demandiez
quels sont a et b donnant a+b = 60.
On a quelques infos permettant de simplifier le problème, mais pas assez
pour donner un verdict précis.

Par contre, si vous nous donnez une image BMP de taille raisonnable
chiffrée avec une clé de session compréhensible par son auteur, alors
là, oui, on peut faire quelque chose.
Il y a de l'information : les caractères de la clé de session ne
couvrent pas [0-255] entièrement, et quelques octets du clair sont
connus ou du moins sont trouvables en cherchant un peu.
Si du texte a été chiffré, alors on a des infos sur les plages de
valeurs utilisées, et les fréquences de caractères selon les langues.

Pensez à vous mettre dans un cas d'utilisation normale de votre algo...

@Tchao !
--
Mister Jack (MJ)
"Linux c'est pas pour les manchots !"
Un don pour les victimes du pingouin : http://www.microsoft.com/

Avatar
Christophe HENRY

(Je n'ai pas encore reçu le message auquel Jack répond)

Après avoir un peu testé l'algo, je dois dire que cette attaque à clair
connu est démonstrative de la faiblesse de l'algo.
Avec uniquement du bruit blanc en entrée de l'algo il n'est pas
extrêmement simple de trouver la clé utilisée, mais avec juste quelques
infos éparses on y arrive très facilement.


J'en suis arrivé à la même conclusion évidente. Le problème, c'est
que ça devient une histoire de conviction. Et je ne sais pas comment
expliquer cela de manière simple/compréhensible.


J'ai fais un programme d'une trentaine de lignes, qui ne trouve pas la
clé à partir du chiffré seul, mais trouve la clé à partir du moment où
il sait que le clair était une image JPEG. Cette seule info suffit à
permettre une attaque réussie.


De toutes façons, ma méthode (la théorie) et ta méthode (débuscage de
clés) laissent entièrement de côté la cryptanalyse basée sur
plusieurs chiffrés dont la nature est connue, basées sur un clair
choisi, diffing, etc.


...
Par contre, si vous nous donnez une image BMP de taille raisonnable
chiffrée avec une clé de session compréhensible par son auteur, alors
là, oui, on peut faire quelque chose.


Je me demande quoi ;-)


Pensez à vous mettre dans un cas d'utilisation normale de votre algo...


A mon avis, mais ce n'est que mon avis, il n'y a pas de cas normaux
d'utilisation du 'simple algo' ;-) A chaque chiffrement on change de clé
et d'algo.


Plus sérieusement, je donne ici mes résultats :

Le procédé utilise une clé de TROIS octets. Pas 4, mais bien 3. En
effet, le premier tour de clé écrase k4 par sa nouvelle valeur, k3 par
k4, k2 par k3 et k1 qui finit par être écrasé par k2 sans avoir été
utilisé. k1 est donc inutile...

Le procédé est l'équivalent strict de deux couches de chiffrement
faibles induisant beaucoup de redondance. La première couche est la phase
de génération de la clé de session, la deuxième est le chiffrement
proprement dit.

Voici la formulation exacte de l'algorithme avec ses rotations :

Pour i de 1 à [longueur du clair]
k_1 <- k_2
k_2 <- k_3
k_3 <- k_4
k_4 <- (k_2 + k_3) XOR m_i + k_4 (mod 256)
c_i = (k_1 + m_i) XOR k_2 + k_1 (mod 256)
FinPour

Voici les équations décrivant totalement le chiffrement :

(k_1, k_2, k_3, k_4) ¤ N^4
'A' i>4, k_i = (k_i-3 + k_i-2) XOR m_i-4 + k_i-1 (mod 256)
'A' i>0, c_i = (k_i+1 + m_i ) XOR k_i+2 + k_i+1 (mod 256)

La clé de session n'est plus décalée mais les indices utilisés pour la
clé vont croissant. Cela permet de voir que le chiffrement est en fait
composé de deux sous-chiffrements cumulés.


L'attaque a clair connu ne dépend que de la longueur de la clé. Il
suffit en effet - pour notre cas - de n'avoir que les TROIS (3, drei,
three) premier octets du clair et du chiffré pour avoir une clé. En
fait, il y a toujours un multiple de 256 clés puisque le premier octet ne
sert pas :-o
Autrement dit, il n'y a besoin que d'un nombre d'octets du clair et du
chiffré équivalent à la longueur de la clé.

Le temps de l'attaque est très court et ne dépend pas/peu de la longueur
de la clé.


Voici le code source :
==================================================== #include <stdio.h>
#include <stdlib.h>

typedef unsigned int octet ; // int obligatoire pour le test %6 !!

int test(octet c, octet ka, octet m, octet kb) {
return c == (((ka+m)^kb)+ka)%256 ;
}

octet* chiffre(int longueur, octet M[], octet K[]) {
int i ;
octet* C = malloc(longueur*sizeof(octet)) ;
octet KK[4] ; memcpy(KK,K,4*sizeof(octet)) ;
octet Ktemp[4] ;
for (i=0;i<longueur;i++) {
Ktemp[0]=KK[1] ; Ktemp[1]=KK[2] ; Ktemp[2]=KK[3] ; Ktemp[3]=(( (KK[1]+KK[2])^M[i] ) +KK[3])%256 ;
memcpy(KK,Ktemp,4*sizeof(octet)) ;
C[i]=(((KK[0]+M[i])^KK[1])+KK[0])%256 ;
}
return C ;
} // chiffre

long casse(octet M[], octet C[]) {
// M et C doivent contenir les trois premiers octets du clair (M) et
// du chiffré (C). Les autres octets seront ignorés.
long nbCle = 0 ;
octet K[5] ;
octet* CC ;

for (K[1]=0;K[1]<%5;K[1]++) {
for (K[2]=0;K[2]<%5;K[2]++) {
if ( test(C[0],K[1],M[0],K[2]) ) { // k2, k3 bons
for (K[3]=0;K[3]<%5;K[3]++) {
if ( test(C[1],K[2],M[1],K[3]) ) { // k3, k4 bons
for (K[4]=0;K[4]<%5;K[4]++) {
if ( test(C[2],K[3],M[2],K[4]) ) { // k4, k5 bons
if ( K[4] == (((K[1]+K[2])^M[0])+K[3])%256 ) { // k2, k3, k4, k5 bons
CC = chiffre(6,M,K) ;
printf("[ ,%3d,%3d,%3d] ", K[1], K[2], K[3]) ;
nbCle++ ;
}
}
}
}
}
}
}
} // for
return nbCle ;
} //casse

int main() {

octet* C ;

octet M[6]={99,78,45,85,1,225} ;
octet K[6]={251,201,178,155} ;

C=chiffre(6,M,K) ;

printf("C = [%3d,%3d,%3d,%3d,%3d,%3d]n", C[0], C[1], C[2], C[3], C[4], C[5]) ;

long nbCles = casse(M, C) ;
printf("nbCles : %dn", nbCles) ;

return 0 ;
}
====================================================
Au plaisir,

--
Christophe HENRY
(sans lkm)
GnuPG : 3922239E60036EC86BF7268A877C52AC 4883C02A

Avatar
Raymond H.
Bonjour,
"Mister Jack" a écrit dans le message de news:
41ecd480$0$20346$
Salut !

Non non. Vous n'avez pas cassé l'algo :-)
Relisez bien ma question:
La question était: " 'Pouvons-nous trouver le clair à partir de
l'algo et du chiffré 6-16-19-13-31-21 ? "


Après avoir un peu testé l'algo, je dois dire que cette attaque à clair
connu est démonstrative de la faiblesse de l'algo.



Il ne peut pas y avoir d'attaque à partir du clair, puisque vous ne
connaissez pas le clair et c'est le clair qui construit la clef de session
et ça prend la clef de session pour déchiffrer le chiffré pour trouver le
clair. De même on ne peut pas vraiment appeler 'attaque à clair connu' une
attaque avec le principe de Vernam puisqu'il n'utilise la clef qu'une seule
fois: 'masque jetable'. Le problème serait plutôt de trouver le clair.
Dans cette étape 4, c'est le but, puisque la clef de session est un 'masque
jetable'; elle ne sert qu'une seule fois, même si on chiffre plusieurs fois
le même fichier.
Et de plus je veux simplifier la partie de l'algo qui crypte le clair:
par exemple enlever cette ligne-ci
"c(x+1) = (((k1 + m(x+1)) xor k2) + k1) Modulo 256"
pour la remplacer par celle-ci
"c(x+1) = (((k1 + m(x+1)) xor m1) + k1) Modulo 256"
De cette façon, je pense qu'il n'y aurait plus plusieurs possibilités de
clef dans l'étape 3 mais une seule. Cela pour tenter d'empêcher les
attaques à force brute à partir d'une clef de session (et non de la phrase
de passe). J'ai testé avec cette nouvelle ligne de code (selon l'étape 3)
pour voir le nombre de clefs possibles pour un même clair et son chiffré, et
le résultat m'a donnée une seule clef possible.

Selon l'étape 3, donc:

c1 = (((k1 + m1) xor k1) + k1) Modulo 256

c2 = (((k2 + m2) xor k2) + k2) Modulo 256

c3 = (((k3 + m3) xor k3) + k3) Modulo 256



J'ai fait le test avec:
c = 010-024-036

m = 008-012-021
et la seule clef possible est
k = 002-004-005
Cependant, il semble qu'une attaque à clair connu soit impossible (je ne
parle pas d'attaque à force brute). Pourrait-on confirmer cette affirmation
avec l'exemple suivant (selon l'étape 3)?
Clef: ? - ? - ?
Clair: 008-012-021
Chiffré: 132-070-010


Avec uniquement du bruit blanc en entrée de l'algo il n'est pas
extrêmement simple de trouver la clé utilisée, mais avec juste quelques
infos éparses on y arrive très facilement.
J'ai fais un programme d'une trentaine de lignes, qui ne trouve pas la clé
à partir du chiffré seul, mais trouve la clé à partir du moment où il sait
que le clair était une image JPEG. Cette seule info suffit à permettre une
attaque réussie.


De quelle façon saurait-on que l'image est en JPEG? Par répétition d'une
même couleur ou de l'entête indiquant le type de fichier?

Si vous désirez refaire le teste, je vous redonne le chiffré
225-111-037-088-088-057 suivant à partir duquel vous pouvez essayer de
trouver le clair avec l'aide de l'algo seulement?


Cette question montre bien votre méconaissance des méthodes utilisées pour
faire sauter votre système. Donner 48bits d'infos et dire : "quel est le
clair ?", c'est exactement le même que si vous nous demandiez quels sont a
et b donnant a+b = 60.
On a quelques infos permettant de simplifier le problème, mais pas assez
pour donner un verdict précis.


Quand j'ai écris "trouver le clair avec l'aide de l'algo seulement" je
voulais dire à partir de l'algo et du chiffré. Mais je comprends le fait
que pas assez de données limite les comparaisons, etc.

Par contre, si vous nous donnez une image BMP de taille raisonnable
chiffrée avec une clé de session compréhensible par son auteur, alors là,
oui, on peut faire quelque chose.


D'accord. Faudrait dans ce cas que je crée un petit programme pour le
faire sinon autrement ça va être trop long. Je pourrait ainsi vous envoyer
deux petits bmp, et l'entête y serait du même coup. L'un des deux serait
quelques couleurs simple qui se répètent: cela pourrait vous faciliter les
choses. C'est ok?

Il y a de l'information : les caractères de la clé de session ne couvrent
pas [0-255] entièrement,


Vous ne voulez pas plutôt dire: "Il y AURAIT de l'information..."?
Sinon, je ne comprends pas puisqu'il n'existe pas de caractères hors de
cette plage (0-255). Ça peut être n'importe lesquels des caractères de 0 à
255 puisque la clef de session initiale serait générée aléatoirement par le
logiciel. Ici, je n'ose pas parler d'OTP qui signifie 'One Time Password'
puisque ce n'est pas un mot de passe que l'utilisateur tape, mais plutôt une
clef de session initiale créée aléatoirement par le logiciel. Le 'mot de
passe' ou 'clef personnelle' serait indépendant et traité dans une étape
ultérieure.


et quelques octets du clair sont connus ou du moins sont trouvables en
cherchant un peu.
Si du texte a été chiffré, alors on a des infos sur les plages de valeurs
utilisées, et les fréquences de caractères selon les langues.



Mais je ne pense pas vraiment qu'on puisse chercher par fréquences de
caractère puisqu'un même caractère n'a pas nécessairement la même valeur
d'un endroit à l'autre, à cause du calcul de l'algo. Tantôt un P pourrait
être calculé (via addition et xor) à partir de certaines valeurs et tantôt
par d'autres valeurs. Je ne pense pas vraiment qu'on puisse procéder par
statistique. Si vous voulez, dans AllCrypter il y a le 4e onglet qui donne
automatiquement les fréquences de chaque caractère qui se retrouve dans le
texte de sa fenêtre de gauche.



Pensez à vous mettre dans un cas d'utilisation normale de votre algo...


D'accord.

a+
Raymond H.


Avatar
Raymond H.
Bonjour,

"Christophe HENRY" a écrit dans le
message de news: csjflb$29n$
...
Dans la version actuelle avec les rotations, je pense que tu as affaibli
ton algorithme et qu'il doit être possible de sélectionner des clairs
possibles correpondant à un chiffré. Il est probable qu'avec un chiffré
suffisament long et avec des renseignements sur la nature du fichier, il
est faisable de trouver le clair sans la clé.


D'accord. Je veux travailler à faire un code pour chiffrer deux bmp, et
l'envoyer lorsqu'il sera prêt. Ainsi, l'entête cryptée y sera aussi.

Cependant, cela dépasse mes capacités/compétences de bénévole à
être compris.

Je reste donc toujours sur les attaques à clair connu. Ce ne sont pas
des futilités théoriques : imagine que tu m'envoies un fichier chiffré
avec ton procédé. Tu me communiquera la clé pour le déchiffrer. Je le
déchiffrerai, c'est fait pour. A partir de là, j'aurai le clair et le
chiffré, donc la clé, donc ta clé. De là, si tu utilises toujours la
même clé (ce qui est une utilisation normale) je pourrai déchiffrer les
messages chiffrés chez d'autres correspondants, et vice-versa. Cette
vulnérabilité suffit à invalider ton procédé, voilà pourquoi je ne
considère pas utile de tenter la cryptanalyse.


Mais qui donnerait une même clef à plusieurs correspondants? Faire cela
avec peu importe le logiciel de chiffrage, ça serait du pareil au même. Ça
n'indique pas une vulnérabilité du logiciel lui-même mais de la clef dont
plusieurs auraient.

Mais dans le cas de cette étape 4, cette logique ne peut pas être
utilisée concernant la clef de session, car personne ne l'aurait et elle ne
serait jamais créée deux fois par le logiciel. Mais par contre, si la
phrase de passe (qui crypte la clef de session) est transmisse à plus d'une
personne à la fois, alors cela relèverait de la responsabilité de l'envoyeur
et ce serait la confiance envers celui qui chiffre que le destinataire
aurait à prendre le risque. C'est comme ça avec tous les logiciels de
chiffrage, à moins qu'il y ait un procédé que je ne connais pas.



J'ai transmis l'état de mes recherches et le programme en C servant à
trouver cette clé dans l'article : <csiovk$2q71$


Merci.

Donne-moi trois octet du clair, trois octet du chiffré, quelque soient
leurs longueurs et je te trouve la clé. Si ta clé fais N octets, ça
marche aussi avec N octets du clair et du chiffré.



J'avais déjà pensé qu'en faisant des tests aléatoirement en essayant
différents caractères au début du chiffré et de la clef de session, qu'il y
aurait matière à amélioration, justement à cause de cela. Je vais réfléchir
à cette logique au début du processus de chiffrement. Ensuite, je pourrais
vous envoyer les trois octets si je ne vois pas bien comment il est possible
en peu de temps de cryptanalyser cela.


a+
r.h.

1 2 3 4