Introduction à la cryptologie.

Dimension: px

Commencer à balayer dès la page:

Download "Introduction à la cryptologie."

Sabine Bourgeois
il y a 8 ans
Total affichages :

1 Université Joseph Fourier, Grenoble I UFR IM 2 AG, Master 1 maths/info Année 2011/2012, 1er semestre Introduction à la cryptologie. TP du 9 décembre 2011, de 13h30 à 16h45, durée 3h. Cours de Alexei Pantchichkine Un compte-rendu par binôme est à adresser par courriel à Alexei Pantchichkine, panchish@ujf-grenoble.fr avant le 14 décembre Il devra comporter : un rapport (au format PDF de préférence) avec vos réponses aux questions ainsi que les commentaires que vous jugerez utile sur votre code ; les sources des programmes réalisés ; d'autres annexes, le cas échéant. Un rendu de TP sans rapport sera noté 0/20. Des commentaires éparpillés dans le code ne constituent pas un rapport valide. Groupez vos chiers et n'oubliez pas d'indiquer vos deux noms. Le but de ce TP est de programmer les fonctions d'arithmétique modulaire et les appliquer au chirement à clef publique. 1. Arithmétique modulaire Pour m N on note Z/mZ l'ensemble des classes modulo m, et π m : Z Z/mZ l'application quotient. On note (Z/mZ) le groupe des éléments inversibles dans (Z/mZ) Factoriser m = en produit des nombres premiers Trouver le nombre des éléments inversibles dans (Z/mZ) Calculer la fonction d'euler ϕ(m) à l'aide de PARI et de Maple Pour tout élément x Z/mZ déterminer x 1+ϕ(m) Décomposer le groupe (Z/mZ) en produit en utilisant le théorème chinois des restes Trouver l'ordre d'élément 2 mod m dans le groupe (Z/mZ) Quels sont les ordres d'éléments possibles du groupe (Z/mZ) et de ces composants? 1.8. Le groupe (Z/mZ), est-il cyclique? 1

Il devra comporter : un rapport (au format PDF de préférence) avec vos réponses aux questions ainsi que les commentaires que vous jugerez utile sur votre code ; les sources des programmes réalisés ;

2 2.1. Justier l'algorithme suivant 2. Algorithme d'euclide étendu Entrée: deux entiers a et b Sortie: deux entiers x et y tels que a x + b y = pgcd(a, b) (a, b) ( a, b ) (x 0, x 1, y 0, y 1 ) (1, 0, 0, 1) s 1 tant que b 0 r a mod b q a b a b b r x x 1 y y 1 x 1 qx 1 + x 0 y 1 qy 1 + y 0 x 0 x y 0 y x sx 0 s s y sy 0 retourner (x, y) 2.2. Prouver la validité de cet algorithme. Écrire un programme qui l'implémente. Consulter le modèle suivant : > bezout:=proc(a::integer,b::integer) > local u0,u1,u2,v0,v1,v2,d0,d1,r,t,i; > if a<0 then a:=-a; > else fi; > if b<0 then b:=-b; > else fi; > u0:=1:v0:=0: u1:=0:v1:=1: > d0:=a; d1:=b;r:=b;i:=0; > while(d1<>0) do > i:=i+1;t:=iquo( d0,d1 );r:=irem( d0,d1 ); > d0:=d1; d1:= r; > u2:=u0-t*u1; > v2:=v0-t*v1; > u0:=u1;u1:= u2; > v0:=v1;v1:= v2; > printf("i=%d,%d*%d+%d*%d=%d\n" >,i,a,(u0), b,v0, d0) > od; > printf("les valeurs de [d,u, v] sont :"); > return [d0,u0, v0]; > end proc:

a b b r x x 1 y y 1 x 1 qx 1 + x 0 y 1 qy 1 + y 0 x 0 x y 0 y x sx 0 s s y sy 0 retourner (x, y) 2.2. Prouver la validité de cet algorithme. Écrire un programme qui l'implémente.

3 bezout(17,61);i=1,17*0+61*1=61 i=2,17*1+61*0=17 i=3,17*-3+61*1=10 i=4,17*4+61*-1=7 i=5,17*-7+61*2=3 i=6,17*18+61*-5=1 les valeurs de [d,u, v] sont : [1, 18, -5] 3. Exponentiation rapide Prouver la validité de l'algorithme suivant : Entrée: Entier n de congruence. Puissance e. Élément a de Z/mZ Sortie : Valeur de a e dans Z/mZ. Algorithme : 1. x := a, y = e; 2. z := 1; 3. Tant que y n'est pas nul 3.1 si y est impaire, z := z x mod n 3.2 x := x x mod n 3.3 y := y/2 4. renvoyer z Écrire un programme qui l'implémente en utilisant le modèle >Puismod:= > proc(a::nonnegint, e::nonnegint, m::nonnegint) > local x, y, z, ei; > x:=a; > y:=e; > z:=1; > while (y<>0) do > ei:=y mod 2; > if (ei=1) then > printf(" ei=%d, x=%d, y=%d, z=%d\n",ei,x,y,z); > z := z*x mod m; > else > printf(" ei=%d, x=%d, y=%d, z=%d\n",ei,x,y,z); > fi; > x:=x*x mod m; > y:=floor(y/2); > od; > return z; > end proc: > Puismod(6,73,100); > ei=1, x=6, y=73, z=1 ei=0, x=36, y=36, z=6 ei=0, x=96, y=18, z=6 ei=1, x=16, y=9, z=6 ei=0, x=56, y=4, z=96

4 > Puismod(2,11,100); ei=0, x=36, y=2, z=96 ei=1, x=96, y=1, z=96 16 ei=1, x=2, y=11, z=1 ei=1, x=4, y=5, z=2 ei=0, x=16, y=2, z=8 ei=1, x=56, y=1, z= Théorème chinois des restes Soient m 1,..., m n des entiers positifs, deux-à-deux premiers entre eux, et a 1,..., a n des entiers. On cosidère les congruences simultanees : 4.1. Posons x a 1 mod m 1, x a 2 mod m 2,... x a n mod m n. m = n m i, M i = m/m i, i=1 1 i n On utilise l'algorithme d'euclide étendu pour calculer des nombres y i Z, i i n tels que puis on pose y i M i 1 mod m i (puisque pgcd(m i, m i ) = 1) x n a i y i M i mod m Prouver la validité de cet algorithme. Écrire un programme qui l'implémente Étudier la fonction de Maple i=1 chrem - Chinese Remainder Algorithm Calling Sequence chrem(u, m) Parameters u - list [u1,..., un] of evaluations m - list of moduli [m1,..., mn] Description The list of moduli m must be pairwise relatively prime positive integers. Both lists u and m mu If u is a list of integers, chrem(u, m) computes the unique positive integer a such that a mod If the global variable mod has been assigned to mods then the result a is returned in the symme If u is a list of polynomials, chrem is applied across the polynomials so that the output f is If u is a list of lists, chrem is applied across the lists so that the output will be a list L For a definition, see Chinese remainder theorem. > chrem( [2,3,2], [3,5,7] ); Exemple de cryptage avec RSA On considère avec les notations usuelles, une clef publique RSA: (n, e) = ( , ), et soit E : x x e mod n l'application de cryptage de l'ensemble Z/nZ dans Z/nZ.

m = n m i, M i = m/m i, i=1 1 i n On utilise l'algorithme d'euclide étendu pour calculer des nombres y i Z, i i n tels que puis on pose y i M i 1 mod m i (puisque pgcd(m i, m i ) = 1) x n a i y i M i

5 5.1. En utilisant ordinateur trouver la valeur de la fonction d'euler ϕ(n) Calculer la clef secrète d correspondente, telle que l'application D : y y d mod n soit réciproque de E On considère le message M1 = Déterminer le message C1 obtenu en cryptant m avec la clef publique RSA(n, e) Décrypter le message C1 avec la clef secrète d Etudier en PARI le programme RSAcrypt(PubKey, Message)= { \\ PubKey should be a pair of positive integers [N,e] \\ We assume that N>Message. local(e,n); N=PubKey[1]; e=pubkey[2]; C=gcd(Message,N); if(c!=1,print("rsa module is broken. A factor is ",C), /* ELSE */ C=lift(Mod(Message,N)^e); ); return(c); } /* end of RSAcrypt */ RSAdecrypt(PrivateKey, CipheredMessage)= { \\ PrivateKey is either a pair [N,d] or a quadruple [p,q,dp,dq] \\ of positive integers. In the last case, dp is the remainder of \\ d modulo p-1 and dq is the remainder of d modulo q-1. local(d,dp,dq,n,p,q); if(length(privatekey)==2, N=PrivateKey[1]; d=privatekey[2]; M=lift(Mod(CipheredMessage,N)^d);,/* ELSE */ p=privatekey[1]; q=privatekey[2]; dp=privatekey[3]; dq=privatekey[4]; M=lift(chinese(Mod(CipheredMessage,p)^dp,Mod(CipheredMessage,q)^dq)); ); return(m); } /* end of RSAdecrypt */ 5.6. Chirer le message "BEZOUT" avec un nombre M mod n en utilisant l'alphabeth, N = 26, k = 6, l = 7 A=0,B=1,C=2,D=3,E=4,F=5,G=6,H=7,I=8 J=9,K=10,L=11,M=12;N=13,O=14,P=15,Q=16,R=17,S=18,T=19,U=20,V=21,W=22,X=23,Y=24,Z=25 et la procedure Chiffres:= proc( d::nonnegint,l::nonnegint,n::nonnegint ) > local i,m, v;

$4. Décrypter le message C1 avec la clef secrète d. 5.5. Etudier en PARI le programme RSAcrypt(PubKey, Message)= { \\ PubKey should be a pair of positive integers [N,e] \\ We assume that N>Message.$

6 > v:=vector(l); > m:=n; > for i from 0 to l-1 do > v[l-i]:=modp(m,d);m:=floor(m/d); od; > return v; > end proc: et la clef publique RSA: (n, e) = ( , ) Représenter le message chiré avec les lettres Décrypter le message C avec la clef secrète d.

Documents pareils

Cryptographie RSA. Introduction Opérations Attaques. Cryptographie RSA NGUYEN Tuong Lan - LIU Yi 1

Cryptographie RSA. Introduction Opérations Attaques. Cryptographie RSA NGUYEN Tuong Lan - LIU Yi 1 Cryptographie RSA Introduction Opérations Attaques Cryptographie RSA NGUYEN Tuong Lan - LIU Yi 1 Introduction Historique: Rivest Shamir Adleman ou RSA est un algorithme asymétrique de cryptographie à clé