Etude et Implémentation de RSA

Réalisé par :

COHEN Achraf YACOUBOU S. Bouraima

Encadré par :

Pr. S.LAZAAR

Algorithme RSA   :

Présentation :

Le RSA a été inventé par Rivest, Shamir et Adleman en 1978. C’est l’exemple le plus courant de cryptographie asymétrique, toujours considéré comme sûr, avec la technologie actuelle, pour des clés suffisamment grosses (1024, 2048 voire 4096 bits). D’ailleurs le RSA128 (algorithme avec des cl´es de 128 bits), propos´e en 1978 par Rivest, Shamir et Adleman, n’a été “cassé” qu’en 1996, en faisant travailler en parallèle de nombreux ordinateurs sur internet. Mais le concept de chiffrement asymétrique avec une clef publique était légèrement antérieur (1976). L’idée générale était de trouver deux fonctions f et g sur les entiers, telles que fog = Id, et telle que l’on ne puisse pas trouver f, la fonction de décryptage, à partir de g, la fonction de cryptage. L’on peut alors rendre publique la fonction g (ou clef), qui permettra aux autres de crypter le message à envoyer, tout en étant les seuls à connaître f, donc à pouvoir décrypter. On trouvera un expos´e complet sur RSA.

Description du protocole   :

Le but du jeu est bien sûr de pouvoir transmettre un message codé, que seul le récepteur “officiel” puisse décrypter, c’est-`a-dire qui ne puisse pas être décrypté par un tiers qui intercepterait ledit message. Nous appellerons Alice la destinatrice du message, et Bernard l’´emetteur.

1. Alice génère deux gros nombres premiers p et q, ainsi qu’un gros nombre d premier avec le produit w = (p − 1) (q − 1).

2. Alice calcule n = pq et e tel que de Ξ 1[w].3. Alice diffuse n et e, garde d et oublie w.4. Bernard crypte un message M par M => Me[n] et envoie le résultat à Alice.5. Alice décode alors le message crypté par C => Cd[n]

Exemple :

Voyons ce qui se passe si l’on prend pour les deux nombres p et q les valeurs 11 et 17. On a alors n = 187 et w = (11 − 1) (17 − 1) = 160. Comme : 161 = 7 × 23, on peut prendre e = 7 et d = 23. Alice va rendre public le couple (187, 7).

Bernard veut transmettre à Alice un message codé plus petit que n = 187, mettons la date à laquelle ils vont faire une surprise à Cédric (par exemple, le 10), message qui ne doit pas être intercepté par ledit Cédric, bien sûr.Bernard va donc calculer 107 = 187×53475+175, et envoyer le résultat 175 à Alice.

Alice va calculer le reste de la division euclidienne de 17523 par 187 :

– Elle calcule d’abord 1752 = 30625 = 163×187+144, donc 1752 Ξ144[187].– Ensuite, 1442 = 20736 = 110 × 187 + 166, donc 1754 Ξ 166[187].

2

– Puis, 1662 = 27556 = 147 × 187 + 67 donc 1758 Ξ 67[187].– Et 672 = 4489 = 24 × 187 + 1 donc 17516 Ξ 1[187].– Enfin, 17523 = 17516 × 1754 × 1752 × 175 donc17523 _ 1 × 166 × 144 × 175[187]Or 166 × 144 × 175 = 4183200 = 22370 × 187 + 10.

Alice retrouve donc bien le message envoyé, à savoir 10.

Implémentation en JAVA :

Dans cette partie nous présentons notre code Java permettant de manipuler les différentes fonctions de l’algorithme RSA, comme le montre le schéma ci-dessous :

Le code source détaillé :

package gstr.rsa;import java.io.IOException;import java.math.BigInteger;import java.util.Random;import java.util.Scanner;public class rsa {

public static void main(String[] args) throws IOException {System.out.print("Saisir le message :");Scanner sc = new Scanner(System.in);String M =sc.nextLine();int P, Q, Z, E, D;BigInteger N;//Générer P et QP=generateP();Q=generateP();//calcul NN=BigInteger.valueOf(P).multiply(BigInteger.valueOf(Q));//calcul Z

3

Z=(P-1)*(Q-1); //recherche E et DE=rechercheE(Z);D=rechercheD(E,Z);

System.out.println("P="+P);System.out.println("Q="+Q);System.out.println("N="+N+" et Z="+Z);System.out.println("E="+E);System.out.println("D="+D);System.out.println("Le Message :"+M);

byte[] Me=M.getBytes("ASCII");System.out.print("Le Message en ASCII :");for(int k=0; k<M.length();k++){

System.out.print(Me[k]+" ");}

BigInteger[] c =new BigInteger[M.length()];c=crypte(M,E,N);System.out.print("\nLe message Crypté :");

for(int l=0; l<M.length(); l++) { System.out.print(c[l]+" "); }BigInteger[] dec =new BigInteger[M.length()];dec=decrypte(c,D,N);System.out.print("\nLe message Decrypté :");for(int l=0; l<c.length; l++) { System.out.print(dec[l]+" "); }System.out.print("\nLe message en Clair:");for(int l=0; l<c.length; l++) {

String pa= dec[l].toString();int ii= Integer.parseInt(pa);String aChar = new Character((char)ii).toString();

4

System.out.print(aChar); }}

// la fonction permettant de déchiffrer le message chiffrépublic static BigInteger[] decrypte(BigInteger c[],int d, BigInteger n) throws

IOException{

BigInteger[] dec= new BigInteger[c.length];for(int i=0; i<c.length;i++){

dec[i]=(c[i].pow(d)).mod(n);//System.out.println((c[i].pow(d)));

}return dec;}

// la fonction permettant de chiffrer le messagepublic static BigInteger[] crypte(String ch, int e, BigInteger n) throws

IOException{byte[] Me=ch.getBytes("ASCII");BigInteger[] c= new BigInteger[ch.length()];for(int i=0; i<ch.length();i++){

c[i]=(BigInteger.valueOf(Me[i]).pow(e)).mod(n);}return c;}

// permet de rechercher le paramètre epublic static int rechercheE(int z){int e;for(e=1;e<z;e++)

{if(z%e!=0)

{break;}

}return e;

}// permet de rechercher le paramètre d

5

public static int rechercheD(int e, int z){ int d; for(d=1;d<z;d++) { int p=d*e; if(p%z==1) { break; } }return d;}

// permet de generer les P et Qpublic static int generateP(){int P;do{

P=generate();}while(!isFirst(P) || P<10);

return P;}

// permet de verfier paire/impairepublic static boolean isFirst(int p){boolean b=true;int i;for(i=2; (i<=p/2) && (p%i!=0);i++);if(p%i==0) b=false;else b=true;return b;}

// genere un nombre aléatoirepublic static int generate(){int p;Random rn = new Random();p=rn.nextInt(200);return p;}

}

6

Démonstration   :

D’après le schéma ci-dessus, on retrouve le message chiffré souhaité.

Client/serveur RSA   :

Dans cette partie nous abordons une autre façon de l’utilisation de l’algorithme RSA, il s’agit de deux personnes distantes qui s’échangent des messages cryptés à l’aide de l’algorithme RSA.

Pour ce, nous avons crée un programme Java basé sur les Sockets et suivant l’architecture Client/Serveur qui permet de communiquer de façon sécurisée.

Les classes sont jointes à ce rapport.

7

Démonstration :

Client Serveur

Dans cette démo le client a demandé la clé publique du serveur qui la lui a envoyée, ensuite le client a envoyé son message chiffré à l’aide de la clé publique du serveur. A la réception le serveur a déchiffré le message reçu à l’aide de sa clé privée.

N.B : à noter que toute l’opération se déroule en temps réel.

Conclusion   :

Ce TP nous a permis de comprendre et de manipuler l’algorithme RSA ; son implémentation en Java a été la partie la plus intéressante car elle constitue la mise en pratique des connaissances acquises durant le cours de la cryptographie.

8