TD: Cryptage RSA

TD: Cryptage RSA
1 Position du probl`eme
On propose de r´ealiser la m´ethode de cryptage due `a Rivest, Shamir et Adleman (dite m´ethode RSA). Cet
algorithme date de 1977, il repose sur le fait que, si l’on multiplie ensemble deux nombres premiers tr`es grands
(pet q), il est tr`es difficile1de red´ecomposer le r´esultat obtenu (n=p.q) en facteurs premiers (pet q).
La m´ethode RSA, dite `a clef publique, est la suivante2:
1. `a chaque lettre `de l’alphabet, on affecte un nombre n`compris entre 1 et nmax.
(Si on ne prend que les lettres majuscules non accentu´ees et le caract`ere blanc, on a nmax = 27).
2. on transforme le texte `a transmettre (form´e de `max lettres) en un nombre: message =
`max
X
`=1
n`×n`
max.
3. un interlocuteur 1 choisit secr`etement deux nombres premiers tr`es grands p1et q1congrus3`a 2 modulo 3.
Il publie leur produit (la clef publique): n1=p1.q1. Il garde secr`etement le r´esultat d’un autre calcul (la clef
priv´ee): k1=2.(p1−1).(q1−1)+1
3(k1est forc´ement un entier).
La fonction codage de xconsiste `a calculer une certaine fonction fn1(x);
la fonction d´ecodage de xconsiste `a calculer la fonction inverse: f−1
n1,k1(x).
4. un interlocuteur 2 fait de mˆeme avec p2,q2,n2=p2.q2et k2=2.(p2−1).(q2−1)+1
3.
5. lorsque 1 veut transmettre le message `a 2, il envoie: xxxx =fn2(f−1
n1,k1(message)).
6. lorsque 2 veut d´ecoder xxxx, il calcule fn1(f−1
k2,n2(xxxx)) = message.
7. le r´ecepteur d´ecompose le nombre message dans la base nmax et transforme chaque nombre de la d´ecompo-
sition en lettre de l’alphabet pour retrouver le texte.
La fonction codage fni(yyyy) consiste `a d´ecomposer yyyy dans la base nipuis `a ´elever chaque terme de la
d´ecomposition au cube modulo ni.
La fonction d´ecodage f−1
ni,ki(zzzz) consiste `a ´elever zzzz `a la puissance 3.kimodulo ni. Cette proc´edure
utilise le petit th´eor`eme de Fermat g´en´eralis´e:
- soit met ndeux nombres premiers entre eux (m<n);
- soit Φ(n) la fonction d’Euler donnant le nombre des entiers inf´erieurs et premiers avec n.
Ici Φ(n)=(p−1) ∗(q−1).
On a alors: mΦ(n)≡1 [n]⇒m(p−1).(q−1) ≡1 [n]⇒ ∀k∈N,mk.(p−1).(q−1) ≡1 [n]
⇒ ∀k∈N,mk.(p−1).(q−1)+1 ≡m[n]
Comme p≡q≡2 [3], on a: 2.(p−1).(q−1) + 1 ≡0 [3] et donc ∃k∈Ntel que 2.(p−1).(q−1) + 1 = 3.k
2 Code avec Mathematica
RSA
Transformation: lettres <-> chiffres
In[1]:= Code[texte ]:=Module[{elements,ii,imax},
elements=ToCharacterCode[texte]; imax=Length[elements];
For[res=0;ii=1,ii<=imax,ii++,res=res+elements[[ii]]*65537^(imax-ii)]; Return[res]];
Decode[nombre ]:=( texte=IntegerDigits[nombre,65537]; FromCharacterCode[texte]);
Code["message"]
Decode[Code["message"]]
1Historiquement, p´etait un nombre de 64 chiffres et qun nombre de 65 chiffres. En 1994, le nombre n=p.q
de 129 chiffres (RSA129) a pu ˆetre d´ecompos´e en pet qgrˆace `a 1600 ordinateurs travaillant en parall`ele pendant
deux jours.
2Les 2 premi`eres ´etapes sont communes `a toutes les m´ethodes de codage.
3i.e. dont le reste de la division euclidienne par 3 est 2.
1

ISEN-Brest. Kany. TD: Cryptage RSA
Out[3]= 8636782494647089498447787918053
Out[4]= message
Clefs de 1 et 2
In[5]:= p1=Prime[30001]
q1=Prime[30002]
Mod[p1,3]
Mod[q1,3]
Out[5]= 350381
Out[6]= 350411
Out[7]= 2
Out[8]= 2
In[9]:= n1=p1*q1
k1=(2*(p1-1)*(q1-1)+1)/3
Out[9]= 122777356591
Out[10]= 81851103867
In[11]:= p2=Prime[30003]
q2=Prime[30004]
Mod[p2,3]
Mod[q2,3]
Out[11]= 350423
Out[12]= 350429
Out[13]= 2
Out[14]= 2
In[15]:= n2=p2*q2
k2=(2*(p2-1)*(q2-1)+1)/3
Out[15]= 122798381467
Out[16]= 81865120411
Codage
In[17]:= ListeEnNombre[liste ,cle ]:=Module[{NbreTermes,ii,res},
NbreTermes=Length[liste];
For[res=0;ii=1,ii<=NbreTermes,ii++,res+=liste[[ii]]*cle^(ii-1)]; Return[res];];
Codage[liste ]:=Module[{nombre,cle},
nombre=liste[[1]];cle=liste[[2]];Return[Mod[nombre^3,cle]]];
In[19]:= (*Pour insersion de la clef entre chaque element de la liste*)
Sow[expr ,object ]:=Insert[expr,object,List/@Range[2,Length[expr]+1]]
RSA[nombre ,ClePublique ]:=Module[{ListeCodee,ListeDecodee,res},
2

ISEN-Brest. Kany. TD: Cryptage RSA
ListeDecodee=IntegerDigits[nombre,ClePublique];
ListeDecodee=Partition[Sow[ListeDecodee,ClePublique],2];
ListeCodee=Map[Codage,ListeDecodee];
Return[ListeEnNombre[ListeCodee,ClePublique]];];
MessageCode=RSA[Code["Message"],n1]
Out[22]= 683863267296776668652927526278887
Decodage
In[23]:= expomodulo[xx ,nn ,mm ]:=Module[{liste,ii,imax,res,puissance},
puissance=Mod[xx,mm]; liste=IntegerDigits[nn,2]; imax=Length[liste];
If[liste[[imax]]==1,res=xx,res=1];
For[ii=imax-1,ii>=1,ii--,
puissance=Mod[puissance^2,mm]; If[liste[[ii]]==1,res=Mod[res*puissance,mm];];];
Return[res];]
Decodage[liste ]:=Module[{nombre,ClePrivee,ClePublique},
nombre=liste[[1]];ClePrivee=liste[[2]][[1]];ClePublique=liste[[2]][[2]];
Return[expomodulo[nombre,ClePrivee,ClePublique]]];
ASR[nombre ,ClePrivee ,ClePublique ]:=Module[{ListeCodee,ListeDecodee,res},
ListeCodee=IntegerDigits[nombre,ClePublique];
ListeCodee=Partition[Sow[ListeCodee,{ClePrivee,ClePublique}],2];
ListeDecodee=Map[Decodage,ListeCodee];
Return[ListeEnNombre[ListeDecodee,ClePublique]];];
ASR[MessageCode,k1,n1]
Out[26]= 6101249171578647385225561440965
1 envoie un message 2
In[27]:= Code["Bonjour, ca va ?"]
ASR[Code["Bonjour, ca va ?"],k1,n1]
MessageEnvoye=RSA[ASR[Code["Bonjour, ca va ?"],k1,n1],n2]
Out[27]= 116641592712282001463149217660028982581610315105012093918877189000477672773
Out[28]= 159071632319608592115103484642891131233449708039690962730108017175548532624434
Out[29]= 351613662903029463412718813642207235213337678647855147225107131666234478270218
2 d´ecode le message de 1
In[30]:= ASR[MessageEnvoye,k2,n2]
MessageRecu=RSA[ASR[MessageEnvoye,k2,n2],n1]
Decode[MessageRecu]
Out[30]= 159071632319608592115103484642891131233449708039690962730108017175548532624434
Out[31]= 116641592712282001463149217660028982581610315105012093918877189000477672773
Out[32]= Bonjour, ca va ?
3 connait n1 et n2 mais pas k2, il ne peut pas d´ecoder. Exemple:
In[33]:= p3=Prime[30008]
q3=Prime[30009]
Mod[p3,3]
3

ISEN-Brest. Kany. TD: Cryptage RSA
Mod[q3,3]
k3=(2*(p3-1)*(q3-1)+1)/3
Out[33]= 350447
Out[34]= 350453
Out[35]= 2
Out[36]= 2
Out[37]= 81876334395
In[38]:= Decode[RSA[ASR[MessageEnvoye,k3,n2],n1]]
Out[38]= ΛˆuDˆu?⊂ˆu!µˆu > ˆu?GˆupˆuOX ˆuˆe?ˆu¨e←ˆuQ?ˆul&ˆu¨ E∃ˆu∪+ˆu]9ˆu??ˆu?
3 Code avec Python
T´el´echargez la biblioth`eque PyPrime `a l’adresse:
https://pypi.python.org/pypi/pyprimes/
et installez le package pyprimes-0.1.1a.tar.gz `a l’aide de WinPython Control Panel (Add packages
suivi de Install packages).
# -*- coding: utf-8 -*-
import random
import pyprimes
import math
4