Algorithmes de cryptographie et le probl`eme du

Algorithmes de cryptographie et le problème du logarithme
discret
Vitor Lima (vitor [email protected])
31 janvier 2013
1
Introduction
La cryptographie est un domaine de l’informatique et des mathématiques qui étudie procédés
pour qu’un message ne puisse être compris que par un ensemble particulier de communicateurs
(i.e. personnes, ordinateurs, logiciels, ...). Normalement, cet ensemble est l’ensemble de ceux qui
ont une clée.
Aujourd’hui, la cryptographie est utilisée, par exemple, dans les transactions bancaires, les achats
sur internet et les communications confidentielles. Les systèmes de cryptographie sont traditionnellement divisés en symétrique (comme DES, AES et RC4) et asymétrique (comme RSA et
ElGamal). Dans ce texte, on verra deux algorithmes de cryptographie asymétrique qui sont
basés sur le problème du logarithme discret et quelques algorithmes pour résoudre ce problème.
2
Quelques définitions et notations
Définition 2.1 (Ordre d’un groupe). Soit A = (G, ·) un groupe fini, alors, on défini l’ordre de
A comme le cardinal de G et on note
o(G) = |G|
Si le groupe est infini, on dit que son ordre est infini.
Définition 2.2 (Ordre d’un élément). Soient (G, ·) un groupe, e l’élément neutre de G et g ∈ G.
On définit l’ordre de g comme
min{x ∈ N∗ : g x = e},
et on le note o(g).
Remarque 2.3. L’ordre du groupe < g > est égal à l’ordre de l’élément g.
Pour voir cette proprieté, il faut remarquer que < g >= {g 0 , g 1 , g 2 , ..g o(g)−1 } possède o(g)
éléments.
Définition 2.4 (Grand O). On note
O(f (x)),
où f est une fonction à valeurs positifs, l’ensemble des fonctions asymptotiquement plus petites
que f , i.e.
g(x) ∈ O(f (x)) ⇔ ∃(c, x0 ) ∈ R∗ : ∀x ≥ x0 , g(x) ≤ cf (x)
1
Remarque 2.5. Dans les algorithmes de cryptographie, généralement, on travaille avec des nombres très grands (comme 1024 bits), alors, les opérations de multiplications sont très chères. Pour
cette raison, quand on fait le calcul de la complexité asymptotique (trouver à quelle ensemble
”Grand O” de fonction l’algorithme appartient), on compte le nombres de multiplications (et
aussi de division) faites.
3
Problème du Logarithme Discret
Définition 3.1. Soit A = (G, ·) un groupe et (g, h) ∈ G2 . Le problème du logarithme discret
(PLD) consiste à trouver x ∈ Z tel que
g x = h.
Si un tel x existe, on l’appelle logarithme discret de h dans la base g et on le note x = logg h
(ou, parfois, x = indg h).
Remarque 3.2. Une condition nécessaire et suffisante pour que ce problème possède une solution
est
h ∈< g > .
En particulier, si G =< g > (g est un générateur de G), le PLD a toujours solution.
Remarque 3.3. La solution n’est pas forcement unique. En fait, si g est d’ordre fini et si g x = h,
alors, pour tout α ∈ Z, on a g x+αo(g) = g x e = h
Proposition 3.4 (Quelques propriétés du logarithme discret). Soit (G, ·) un groupe.
1. (Logarithme d’un produit) Si (g, h, k) ∈ G3 alors logg hk = logg h + logg k.
2. (Changement de bases) Si x = logg h alors x =
logn h
logn g
(si logn h est défini dans le groupe).
Preuve :
1. En fait, par les propriétés de la loi interne du groupe, si on a g x = h et g y = k, alors, on a
g x+y = hk.
Par la définition du logarithme discret, logg hk = x + y, or x = logg h et y = logg k, donc
logg hk = logg h + logg k.
2. Soit z ∈ G. S’il existe y ∈ Z tel que ny = g (ça veut dire, y = logz g), on a :
z xy = (z y )x = g x = h,
alors, par définition
logz h = xy = logg h logz g.
4
4.1
Comment résoudre le PLD
Recherche exhaustive
La façon la plus simple de résoudre un PLD consiste à calculer g i pour tout i appartient à
{1, 2, 3, .., o(g)} et voir quelle valeur de i satisfait g i = h.
On peut commencer en voyant si g et h sont égaux, s’ils ne le sont pas, on mutiplie g par lui
même, en obtenant g 2 et on le compare avec h. S’ils sont encore différent, on multiplie g 2 par g
pour obtenir g 3 et on compare cette valeur avec h. On continue ainsi jusqu’à trouver la réponse.
Notons que dans le pire cas on va faire un nombre de multiplications égal à l’ordre de g, donc,
la complexité asymptotique de cette méthode est O(o(g)).
2
4.2
4.2.1
Baby-step, giant-step
L’algorithme
Soient A = (G, ·) un groupe, (g, h) ∈ G2 et N = o(g). On peut résoudre le PLD g x = h de la
manière suivante :
Si on écrit la division euclidienne de x par n, x = nq + r, avec 0 ≤ r < n, on a
g x = h ⇔ g nq+r = h ⇔ g r = hg −nq
et comme 0 ≤ x ≤ N ,
N −r
N
0 ≤ nq + r ≤ N ⇒ 0 ≤ q ≤
≤ .
n
n
√
N
Alors, si on choisit n = 1 + b N c, on a n ≤ n et on peut construire deux listes :
{g r }0≤r<n : g 0 , g 1 , g 2 , , g 3 , .., g n−1
(∗)
2
{hg −qn }0≤q≤n : hg 0 , hg −n , hg −2n , .., hg −n (∗∗)
et chercher g i dans (∗) 1 et hg −jn dans (∗∗) tels que g i = hg −jn .
Ainsi, on trouvera la solution du PLD
x = i + jn
Voici une implémentation en language C, en utilisant la bibliothèque GMP 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void b a b y s t e p ( mpz t g , mpz t h , mpz t p , mpz t n , mpz t x ) {
unsigned long int i ;
long int j = 0 ;
mpz t N;
mpz t∗ g r ; /∗ l i s t e g ˆ r ∗/
unsigned long int ∗ i n d i c e s ; /∗ i n d i c e [ i ] = k <=> g r [ i ] = g ˆk ∗/
mpz t hgNq ; /∗ hgˆ(−Nq) ∗/
mpz t i n v ; /∗ gˆ(−N) ∗/
mpz init (N) ;
mpz sqrt (N, n ) ;
mpz add ui (N, N, 1 ) ;
g r = m a l l o c ( mpz get ui (N) ∗ s i z e o f ( mpz t ) ) ;
i n d i c e s = m a l l o c ( mpz get ui (N) ∗ s i z e o f ( long int ) ) ;
mpz init set ui ( g r [ 0 ] , 1 ) ;
/∗ on c a l c u l e l a s u i t e { g ˆ r } r = 1 , . . ,N
( Baby s t e p ) ∗/
f o r ( i = 1 ; i <= mpz get ui (N) ; i ++){
indices [ i − 1] = i − 1;
mpz init ( g r [ i ] ) ;
mpz mul ( g r [ i ] , g r [ i − 1 ] , g ) ;
mpz mod ( g r [ i ] , g r [ i ] , p ) ;
}
/∗ on t r i e l e s v a l e u r s ( k , g ˆk ) par r a p p o r t à g ˆk ∗/
1. Pour que l’agorithme soit plus efficace, on trie la première liste
2. GNU MP est une bibliothèque portable écrite en C pour l’arithmétique en précision arbitraire sur des
entiers, rationnels et virgule flottante. (Cf. gmplib.org)
3
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
q u i c k s o r t ( gr , i n d i c e s , 0 , mpz get ui (N) ) ;
/∗ on c a l c u l e gˆ(−N)
( Giant s t e p ) ∗/
mpz init set ( inv , g ) ;
e x p o n e n t i a t i o n r a p i d e ( inv , N, p ) ;
i n v e r s e ( inv , p , i n v ) ;
mpz init set ( hgNq , h ) ;
/∗ on c h e r c h e l e s é lé m e n t é g a l e s dans l e deux s u i t e s ∗/
f o r ( i = 0 ; i <= mpz get ui (N) ; i ++){
/∗ busque b i n a i r e ( c h e r c h e r hgNq dans l e t a b l e a u g r ) ∗/
j = b u s q u e b i n a i r e ( gr , hgNq , 0 , mpz get ui (N) ) ;
i f ( j >= 0 ) {
mpz mul ui (N, N, i ) ;
mpz add ui (N, N, i n d i c e s [ j ] ) ;
mpz set ( x , N) ;
break ;
}
/∗ s i non , on c a l c u l e l e p r o c h a i n v a l e u r de gˆ(−Nq) ∗/
mpz mul ( hgNq , hgNq , i n v ) ;
mpz mod ( hgNq , hgNq , p ) ;
}
/∗ on e n l e v e l a memoire ∗/
f o r ( i = 0 ; i <= mpz get ui (N) ; i ++){
mpz clear ( g r [ i ] ) ;
}
mpz clear ( i n v ) ; mpz clear ( hgNq ) ;
f r e e ( gr ) ;
}
4.2.2
Complexité
Pour faire la première liste, on fait n multiplications (de g avec la dernière valeur calculée).
Après, on calcule l’inverse modulo p de g (on peut le faire en O((log p)2 ) et on calcule g −n (avec
l’algorithme de exponentiation rapide, on peut calculer g −n en O(log n)).
Après, pour calculer la deuxième liste, on fait aussi O(n) produits de g −n avec la dernière valeur
calculée (en considérant la première valeur de la liste égal à h). Ainsi, à la fin, on a :
√
O(n) + O((log p)2 ) + O(log n) + O(n) = O(n) = O( N )
En fait, en pratique, la complexité n’est pas aussi bonne que ça, car, en considérant les opérations
de comparaison, pour trier la première liste on a besoin de O(n log n) étapes et pour trouver
l’élément de la première liste, on a aussi besoin de O(n log n) étapes.
Alors,
√ si on
√ considére aussi ces opérations dans le calcul de la complexité, on a O(n log n) =
O( N log N ). 3
3. Comme on a vu dans la première section, les multiplications sont plus chères que les comparaisons, mais,
comme N est, en général, très grand, on ne peut pas négliger le coût de trier la liste et de chercher les éléments.
4
4.2.3
Exemple
Pour illustrer le fonctionnement de cet algorithme, considérons l’exemple suivant :
Z ∗
, ·), g = 2 et h = 7. On essaye trouver x tel que g x = h avec cet
Soient p = 59, A = ( pZ
algorithme.
Alors, comme
√ A =< g >, on a o(g) = o(A) = p − 1 = 58, donc, on a N = 58. En plus, on calcule
n = 1 + b N c = 7 + 1 = 8 et on fait la premier liste :
{g r
(mod 59)}0≤r<n : 1, 2, 4, 8, 16, 32, 5, 10.
Après, on calcule g −n : on sait que g −1 = 30, car gg −1 ≡ 60 ≡ 1 (mod 59). Et comme 308 ≡ 3
(mod 59), on a g −1 = 3.
Ainsi, on calcule chaque élément de la deuxième liste et essaye trouver une colision :
{hg −nq
(mod 59)}0≤q<n : 7, 21, 4
On s’arrête à hg −n2 ≡ 4 (mod 59), car, 4 est dans la première liste. Maintenant, on a trouvé :
g 2 ≡ 4 ≡ g −2n
(mod 59),
donc, une solution est x = 2+2n = 2+2·8 = 18. (En fait, on peut vérifier que 218 ≡ (26 )3 ≡ 53 ≡ 7
(mod 59)).
4.3
4.3.1
Pohlig Hellman
L’algorithme
Avec cet algorithme on peut diviser un PLD en sous-problèmes (tous PLD aussi) et après
utiliser les résultats de ces sous-problèmes pour constuire une solution.
Soient A = (G, ·) un groupe, (g, h) ∈ G2 , e l’élément neutre et N = o(g). S’il existe une solution
pour le PLD g x = h, alors, il existe x ∈ {0, 1, N − 1} tel que x est solution. Donc, on peut
considérer x ∈ NZZ .
n
Y
On écrit N =
pi ui (factoriser l’ordre de g en facteurs premiers)
i=1
N
ui
et pour tout i ∈ {1, 2, . . . , n}, on pose gi = g pi ui , hi = hpi et xi une solution modulo
l’équation gi xi = hi .
Après, on utilise le Théorème des Restes Chinois pour trouver x ∈ NZZ tel que :
N
pui
pour
∀ i ∈ {1, 2, .., n}, x ≡ xi (mod pi ui )
et ce x est une solution du PLD g x = h.
Pour résoudre les sous-problèmes gi xi = hi , on utilise la procedure suivante :
Pour simplifier la notation, on considère pi = p et ui = u. On écrit xi = a0 + a1 p + a2 p2 + a3 p3 +
... + au−1 pu−1 (xi dans la base p).
On voit que
n
n
hi p = (gi xi ) p = gi (a0 +a1 p+...+au−1 p
u−1 n
)p
n
= gi a0 p +n(a1 +a2 p+...+ac−1 p
c−2
)
n
Z
et celui-ci est un PLD dans pZ
qu’on peut résoudre rapidement pour trouver a0 .
Après, on peut faire presque le même raisonnement pour trouver a1 :
n
n
hi p2 = (gi xi ) p2 = gi
(a0 +a1 p+...+au−1 pu−1 ) pn2
5
= gi
n
n
= (gi a0 p )e = gi a0 p = (gi p )a0
(a0 +a1 p) pn2
mais comme on connait maintenant le valeur a0 , on peut trouver a1 en résolvant le PLD (aussi
Z
dans pZ
)
n
hi p2 gi
−a0 pn2
= gi
a1 p pn2
n
= (gi p2 )a1 .
Et, pour trouver a2 ,
n
n
hi p3 = (gi xi ) p3 = gi
(a0 +a1 p+a2 p2 +...+au−1 pu−1 ) pn3
= gi
(a0 +a1 p+a2 p2 ) pn3
.
comme on connait les valeurs de a0 et a1 , on fait
n
hi p3 gi
−a0 pn3 −a1 p pn3
= gi
a2 p2 pn3
n
et on résout ce PLD. (Notons que si on fait b = hi p3 gi
ca2 = b). On continue jusqu’à trouver ac−1 en résolvant
n
n
n
n
n
= (gi p3 )a2
−a0 pn3 −a1 p pn3
n
hi pc gi −a0 pc −a1 p pc −a2 pc −...−ac−2 pc = gi ac−1 p
c−1 n
pc
n
, et c = gi p3 on a le PLD
n
= (gi pc )ac−1
et on peut, finalement, construire xi = a0 + a1 p + a2 p2 + ... + ac−1 pc−1 .
4.3.2
Complexité
En considérant la factorisation de N = O(G) en nombres premiers : N =
n
Y
pi ui , on résout,
i=1
pour chaque i appartenant à {1, 2, .., n}, ui PLD dans pZi Z . Alors, si on considère qu’on met
√
O( pi ) pour résoudre chacun de ces problèmes, la complexité du Pohlig Hellman est
n
X
√
ui O( pi ) = O(
i=1
4.3.3
n
X
√
ui pi ).
i=1
Exemple
Z
Soient ( 19Z
, ·) un groupe, et g = 2 et h = 9 deux éléments de ce groupe.
On va résoudre le PLD g x = h.
Avant, notons que l’ordre du groupe N = 18 peut être écrit comme N = 32 2 (facteurs premiers)
et que dans cette section on va faire les calculs modulo 19.
N
N
Alors, on calcule g1 = g 32 = g 2 = 4, h1 = h2 = 81 = 5, g2 = g 2 = g 9 = 29 = 18 et
9
9
h2 = h = 9 = 1.
Maintenant, on résout ces deux sous-problèmes :
N
N
1. g1x1 = h1 : On écrit x1 = a0 + a1 3 et on trouve a0 , la solution du PLD (g13 )a0 = h13 ⇔
11a0 = 7 ⇒ a0 = 2.
Et on trouve a1 en résolvant le PLD suivant :
N
N
−a0 3N2
g132 = h132 g1
⇔ (42 )a1 = 52 (4)−2·2 = 52 54 = 7 ⇔ 8a1 = 7
qui donne a1 = 2.
Alors, x1 = a0 + a1 3 = 2 + 6 = 8.
2. g2x2 = h2 : en résolvant ce PLD, on va trouver x2 = 2
6
Ainsi, on utilise le Théorème des Restes Chinois pour calculer x tel que x = 8( (mod 32 )) et
x = 2( (mod 2)), il vient x = 26.
On peut vérifier que
g 26 = 226 = (25 )4 2 = (13)4 2 = (4)2 = 8 = h
donc, celle solution est correcte.
4.4
4.4.1
Pollard Rho
L’algorithme
Soient (G, ·) un groupe d’ordre premier 4 p et (g, h) ∈ G2 . On essaye de trouver x ∈ Z tel que
g = h.
S S
On définit une partition G = S0 S1 S2 et la fonction

 (hy, a, b + 1 (mod p)) si y ∈ S0 ,
(y 2 , 2a (mod p), 2b (mod p)) si y ∈ S1 ,
f (y, a, b) =

(gy, a + 1 (mod p), b) si y ∈ S2 .
x
de G × Z × Z dans G × Z × Z.
Notons que si y = g a hb , alors, en prenant (z, k, l) = f (y, a, b), z satisfait aussi z = g k hl .
Alors, on peut itérer f jusqu’à trouver deux résultats identiques : (y, a, b) = (z, k, l)
et après,
g a hb = y = z = g k hl ⇒ g a−k = hl−b
comme g x = h, on a
g a−k = g x(l−b) ⇒ x(l − b) ≡ (a − k)
(mod p).
Si l − b est inversible modulo p, on trouve finalement la solution
x ≡ (a − k)(l − b)−1
(mod p).
Si l − b n’est pas inversible modulo p, alors, l’algorithme ne trouve pas de solution.
Heureusement, dans la plupart des cas, cette différence est inversible, car,
∃k ∈ Z : k(l − b) ≡ 1
(mod p) ⇔ pgcd((l − b), p) = 1
et comme p est premier, pgcd((l − b), p) 6= 1 ⇔ p|(l − b) ⇔ l ≡ b (mod p).
Comme, de la définition de f , on voit que (l, b) ∈ 0, 1, 2, .., p − 1, alors, on conclut que pour que
l’algorithme ne trouve pas une solution, il faut que l = b, et dans la plupart des cas, l va être
différent de b.
Pour itérer la fonction, on commence avec (y1 , a1 , b1 ) = (1, 0, 0) et après, en prenant, pour tout
i > 1, (yi , ai , bi ) = f (yi−1 , ai−1 , bi−1 ), on calcule la i-ème et la 2i-ème iterée de f , on compare yi
avec y2i , si ces valeurs sont égaules, on calcule la solution, sinon, on itére de nouveau (ça veut
dire, on calcule le (i + 1)-ème et le (2i + 2)-ème triplet) 5 .
Notons qu’une fois qu’on a (yi , ai , bi ) et (y2i , a2i , b2i ), pour itérer de nouveau, il suffit de faire
(yi+1 , ai+1 , bi+1 ) = f (yi , ai , bi ) et (y2i+2 , a2i+2 , b2i+2 ) = f (f (y2i , a2i , b2i ))
4. En fait, si on veut résoudre le PLD dans un groupe dont l’ordre n’est pas premier, on peut utiliser l’algorithme
du Pohlig Hellman, diviser en sous-problèmes d’ordre premier.
5. Il s’agit de la méthode de détection de cycle de Floyd.
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
∗ D é f i n i t i o n de l a f o n c t i o n f :
∗ x a p p a r t i e n t à G
∗ ( a , b ) a p p a r t i e n t à Zˆ2
∗ g e t h s o n t l e s v a l e u r s du PLD
∗ n = o (G)
∗ ordre g = o(g)
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/
void f ( mpz t x , mpz t a , mpz t b , mpz t g , mpz t h , mpz t n , mpz t
ordre g ){
/∗ x = 0 (mod 3 ) ∗/
i f ( m p z d i v i s i b l e u i p (x , 3) ) {
mpz mul ( x , x , x ) ;
mpz mul ui ( a , a , 2 ) ;
mpz mul ui ( b , b , 2 ) ;
mpz mod ( a , a , o r d r e g ) ;
mpz mod ( b , b , o r d r e g ) ;
/∗ x = 1 (mod 3 ) ∗/
} else i f ( mpz congruent ui p (x , 1 , 3) ) {
mpz mul ( x , x , h ) ;
mpz add ui ( b , b , 1 ) ;
mpz mod ( b , b , o r d r e g ) ;
} e l s e { /∗ x = 2 (mod 3 ) ∗/
mpz mul ( x , x , g ) ;
mpz add ui ( a , a , 1 ) ;
mpz mod ( a , a , o r d r e g ) ;
}
mpz mod ( x , x , n ) ;
}
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
∗ C e t t e f o n c t i o n e s s a y e ré s o u d r e l e PLD g ˆx = h
∗ dans l e groupe Z/nZ .
∗ S i e l l e r é u s s i , l e v a l e u r 1 e s t r e t o u r né e t l a
∗ s o l u t i o n e s t g a r dé en x .
∗ S i non , l e v a l e u r 0 e s t r e t o u r né .
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/
int p o l l a r d r h o ( mpz t g , mpz t h , mpz t o r d r e g , mpz t n , mpz t x ) {
mpz t x1 , x2 ;
mpz t a1 , a2 ;
mpz t b1 , b2 ;
mpz
mpz
mpz
mpz
init
init
init
init
set
set
set
set
ui
ui
ui
ui
( x1 ,
( a1 ,
( b1 ,
( x2 ,
1) ;
0) ;
0) ;
1) ;
8
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
mpz init set ui ( a2 , 0 ) ;
mpz init set ui ( b2 , 0 ) ;
do {
f ( x1 , a1 , b1 , g , h , n , o r d r e g ) ;
f ( x2 , a2 , b2 , g , h , n , o r d r e g ) ;
f ( x2 , a2 , b2 , g , h , n , o r d r e g ) ;
} while (mpz cmp ( x1 , x2 ) != 0 ) ;
mpz sub ( x1 , b1 , b2 ) ;
mpz mod ( x1 , x1 , o r d r e g ) ;
/∗ s i b1 − b2 n ’ a pas d ’ i n v e r s e mod o r d r e g ∗/
i f ( mpz cmp ui ( x1 , 0 ) == 0 )
return 0 ;
m p z i n v e r t ( x1 , x1 , o r d r e g ) ;
mpz sub ( a2 , a2 , a1 ) ;
mpz mul ( x1 , x1 , a2 ) ;
mpz mod ( x1 , x1 , o r d r e g ) ;
mpz set ( x , x1 ) ;
return 1 ;
}
4.4.2
Complexité
Pour calculer la complexité de cet algorithme, il faut connaı̂tre le résultat suivant :
Théorème 4.1 (Paradoxes des Anniversaires). Soient A = {a1 , a2 , .., aN } et I = {1, 2, 3, .., N }
tels que
1. (Distribution uniforme) ∀(i, a) ∈ I × A, P (a = ai ) =
1
N
2. (Indépendence) ∀((i, j), (a, b)) ∈ I 2 × A2 , a 6= b, P (a = ai | b = aj ) = P (a = ai )
alors, si on prends m éléments de A, la probabilité pm d’avoir au moins deux éléments égaux
satisfait la relation suivante :
s
1
m ≈ 2N ln
1 − pm
Démonstration. Soit p la probabilité de n’avoir aucun éléments égaux en m tentatives. Alors,
pour les proprietés 1 et 2, on a
p=
N −1
N
N −2
N
...
Mais, comme ex = 1 + x +
Ainsi, on a
N −m+1
N
x2
2!
+
x3
3!
p≈
m−1
Y
1
2
m−1
i
= 1−
1−
... 1 −
=
1−
.
N
N
N
N
i=1
i
+ ..., on peut faire x = − Ni et approximer e− N par 1 −
m−1
Y
i
e− N = e
Pm−1
i=1
i=1
9
i
−N
m2
≈ e− 2N .
i
N.
m2
m2
Alors, pm = 1 − p ≈ 1 − e− 2N ,donc, e− 2N ≈ 1 − pm , ainsi, pour la définit du logarithme naturel,
m2
1
on a 2N ≈ − ln (1 − pm ) = ln 1−pm , d’où,
s
m≈
2N ln
1
1 − pm
√ Ce théorème dit que dans un ensemble avec N éléments, il faut prendre approximativement
N éléments au hasard pour trouver une colision,√ça veut dire, deux éléments égaux (notez que
si on fait pm = 0.99 on va avoir encore m près de N )
Alors, si on considère que la première composante de l’image de la fonction f utilisée dans
l’algorithme Pollard
p Rho a une distribution uniforme en G avec des probabilités indépendentes,
on devrait faire o(G) pour trouver une colision. Donc, on peut dire que la complexité de
√
l’algorithme de Pollard Rho est appartient à O( p), où p = o(G).
Remarquons que dans cet algorithme, on ne prend pas de temps pour trier ou chercher éléments
comme dans le Baby-Step.
4.4.3
Exemple
Z
, ·) un groupe, g = 2 et h = 228. Alors, on peut vérifier que o(g) = 191.
Soient ( 383Z
On définit la partition suivante de G :
Z
: y ≡ 1 (mod 3)}
383Z
Z
S1 = {y ∈
: y ≡ 0 (mod 3)}
383Z
Z
S2 = {y ∈
: y ≡ 2 (mod 3)}
383Z
La table suivante montre les valeurs de f à chaque itéreration :
S0 = {y ∈
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
(yi , ai , bi )
(228, 0, 1)
(279, 0, 2)
(92, 0, 4)
(184, 1, 4)
(205, 1, 5)
(14, 1, 6)
(28, 2, 6)
(256, 2, 7)
(152, 2, 8)
(304, 3, 8)
(372, 3, 9)
(121, 6, 18)
(12, 6, 19)
(144, 12, 38)
(y2i , a2i , b2i )
(279, 0, 2)
(184, 1, 4)
(14, 1, 6)
(256, 2, 7)
(304, 3, 8)
(121, 6, 18)
(144, 12, 38)
(235, 48, 152)
(72, 48, 154)
(14, 96, 118)
(256, 97, 119)
(304, 98, 120)
(121, 5, 51)
(144, 10, 104)
On trouve, quand i = 14, yi = 144 = y2i . Alors, la solution est
x ≡ (ai − a2i )(b2i − bi )−1 ≡ (12 − 10)(104 − 38)−1 ≡ 2 · 66−1 ≡ 2 · 55 ≡ 110
10
(mod 191)
5
Algorithmes de cryptographie
Dans cette section, on verra 2 algorithmes de cryptographie basés sur le problème du logarithme discret.
5.1
Diffie-Hellman
Supposons qu’Alice et Bob veulent partager une clé privée, mais ils vont échanger des informations en utilisant un réseau non sécurisé.
Alors,
1. Alice choisit un groupe (G, ·) et g ∈ G. Le groupe et la valeur g sont publics.
2. Alice choisit a ∈ Z et Bob choisit b ∈ Z.
3. Alice fait A0 = g a et Bob fait B0 = g b .
4. Alice envoie A0 à Bob et Bob envoie B0 à Alice.
5. Alice calcule A1 = B0 a et Bob calcule B1 = A0 a .
Et les valeurs A1 et B1 sont les clés privées. En fait, on voit que
A1 = g ab = B1
alors, à la fin, Alice et Bob partagent la même valeur.
Dans cette procédure, les valeurs g, A0 , B0 et le groupe (G, ·) sont connues par tous (car on
a supposé que la chaı̂ne de communication n’était pas sûre). Alors, quelqu’un peut essayer de
résoudre le PLD g x = A0 (ou g x = B0 ) et après utiliser a (ou b) pour trouver la clé A1 = A0 b
(ou B0 a ).
5.2
El-Gamal
Supposons que Bob veut envoyer un message m à Alice par un réseau non sécurisé. Avec cet
algorithme (basé en clé publique), elle peut envoyer m de la manière suivante :
1. Alice choisit g ∈ G (où (G, ·) est un groupe). La valeur g est publique.
2. Alice choisit une clé privée a ∈ G
3. Alice calcule la clé publique A, où A = g a
4. Bob choisit une valeur aléatoire k, calcule
B0 = g k
et
B1 = mAk
et envoie (B0 , B1 ) à Alice.
5. Alice calcule A0 = B0 a (qui est égal à g ak ) et A0 −1 .
Ainsi, elle fait
B1 · A0 −1 = (mAk )(A0 −1 ) = (mg ak )(g ak )−1 = m
et réussit à trouver le message m.
Voici une implémentation en language C, en utilisant la bibliothèque GMP, des algorithmes
de chiffrement et déchiffrement :
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
1
2
3
4
5
6
7
8
9
10
11
12
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
∗ C e t t e f o n c t i o n c h i f f r e l e message m
∗ avec l a méthode de c l e f p u b l i q u e ElGamal .
∗ On t r a v a i l l e s u r l e groupe m u l t i p l i c a t i v e
∗
Z/pZ∗ ( s a n s l e zé r o )
∗ La c l e f p u b l i q u e e s t l e c o u p l e
∗
(g , a)
∗ où g e s t un é lé m e n t du groupe e t a e s t
∗ é g a l à g ˆx ( où x e s t l a c l e f p r i v é e ) .
∗ Alors , e l g a m a l e n c f a i t b é g a l
∗
g ˆk (mod p )
∗ où k e s t un nombre a l é a t o i r e e t f a i t
∗ m = m∗ a ˆk (mod p ) .
∗ Alors , l e message c h i f f r é e s t
∗
( b , m) = ( g ˆk , m∗ a ˆk )
∗
∗ On assume que b e s t dé j à i n i t i a l i s é .
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/
void e l g a m a l e n c ( mpz t m, mpz t g , mpz t a , mpz t p , mpz t b ) {
mpz t k ;
gmp randstate t state ;
gmp randinit default ( state ) ;
mpz set ( b , a ) ;
mpz init ( k ) ;
do{
mpz urandomm ( k , s t a t e , p ) ;
} while ( mpz cmp ui ( k , 0 ) == 0 ) ; /∗ pendant k e s t é g a l à zé r o ∗/
e x p o n e n t i a t i o n r a p i d e ( b , k , p ) ; /∗ bˆk (mop p ) , où b = a ∗/
mpz mul (m, m, b ) ;
mpz mod (m, m, p ) ;
mpz set ( b , g ) ;
e x p o n e n t i a t i o n r a p i d e ( b , k , p ) ; /∗ bˆk (mod p ) , où b = g ∗/
mpz clear ( k ) ;
}
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
∗ C e t t e f o n c t i o n r e ç o i t un message c h i f f r é
∗ ( c1 , c2 ) = ( g ˆk , m ∗ a ˆk ) ,
∗ ( avec l a méthode ElGamal )
∗ et trouve l e texte c l a i r correspondant ( et
∗ l e g a r d e s u r c1 ) .
∗ I l f a u t a u s s i donner l a c l e f p u b l i q u e
∗ x ( t e l que a = g ˆx ) .
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/
void e l g a m a l d e c ( mpz t c1 , mpz t c2 , mpz t x , mpz t p ) {
mpz t tmp ;
12
13
14
15
16
17
18
19
mpz init ( tmp ) ;
e x p o n e n t i a t i o n r a p i d e ( c1 , x , p ) ;
i n v e r s e ( c1 , p , tmp ) ;
mpz mul ( c2 , c2 , tmp ) ;
mpz mod ( c2 , c2 , p ) ;
mpz clear ( tmp ) ;
}
5.3
Conclusion
Un des systèmes de cryptographie asymétrique le plus utilisé est ElGamal, ce qui montre déjà
son importance. Aussi, il semble que le PLD est un problème plus difficile (sur certains groupes)
que celui de factorisation de nombres entiers, ce que lui donne quelque avantage sur le RSA. En
plus, le ElGamal est plus generique, il est possible de le mettre en oeuvre sur plusieurs groupes
différents et proffiter des proprietés de chaque groupe (par exemple, sur les courbes elliptiques
la multiplication est plus compliquée, ce qui fait qu’on puisse utiliser les nombres plus petits que
Z
).
sur le groupe pZ
Comment a vu, le Baby-Step Giant-Step est plus facile à mettre en oeuvre que le Pollard Rho,
en plus, il donne toujours une solution (si elle existe). Par contre, il est plus lent.
On voit qu’on ne connait pas encore un algorithme efficace en pratique pour résoudre le PLD,
parce que, malgré la complexité asymptotique presenté ici être raisonnable, elle a été calculée
en fonctions des opérations de multiplications et ces opérations prennent des temps en fonction
de la taille de chaque nombre (nombre des bits). Par exemple, si on considère qu’un ordinateur
prends 10−5 seconds pour mutiplier un nombre de 1024 bits, alors, si on a p ≈ 21024 , l’algorithme
de Pollard Rho va prends
√
10−5 p secondes ≈ 2512 10−5 secondes = 2512 10−5 · 3.16887646 · 10−8 années > 4.2 · 10141 années
5.4
Références
1. A. Menezes, P. van., Oorschot, and S. Vanstone. Handbook of Applied Cryptography. CRC
Press, 1996.
2. Douglas R. Stinson. Cryptography : Theory And Practice. Chapman and Hall/CRC, 2006.
3. J.H. Silverman, Jill Pipher, Jeffrey Hoffstein. An Introduction to Mathematical Cryptography. Springer New York.
13