Cryptographie Rsa

DESTREE Lucile

MARCHAL Mickal

P2 Groupe B

MMiinnii--RRSSAA PPrrooggrraammmmee ddiinniittiiaattiioonn aauu cchhiiffffrreemmeenntt RRSSAA

Projet de Mathmatiques pour lInformatique N1

DESTREE Lucile MARCHAL Mickal P2 gr B Projet MPI n1 2

Sommaire

Introduction ........................................................................................................... 3

Prsentation du cryptage RSA ............................................................................ 4

Principe.................................................................................................................. 5 1) Gnration des cls ........................................................................................ 5 2) Cryptage et dcryptage ................................................................................... 5 3) Exemple .......................................................................................................... 6 4) Forcage du code RSA..................................................................................... 7

Dmonstration....................................................................................................... 8 1) Thorme de Fermat....................................................................................... 8 2) Gnralisation du thorme par Euler............................................................. 8

Les limites du RSA.............................................................................................. 10

Choix algorithmiques ......................................................................................... 11 1) Gnration des cls ...................................................................................... 11 2) Cryptage........................................................................................................ 15 3) Dcryptage.................................................................................................... 16 3) Dcryptage.................................................................................................... 17 4) Forage ......................................................................................................... 18 5) Interface Homme Machine, gestion du temps et des erreurs ........................ 19

Tests et performances........................................................................................ 21 1) Gnration des cls ...................................................................................... 21 2) Forage des cls........................................................................................... 22 3) Cryptage / dcryptage ................................................................................... 23 4) Conclusion .................................................................................................... 24

Conclusion .......................................................................................................... 25

Annexe : source du programme ....................................Erreur ! Signet non dfini. 1) Main.h ....................................................................Erreur ! Signet non dfini. 2) Main.c.....................................................................Erreur ! Signet non dfini. 3) Cles.c .....................................................................Erreur ! Signet non dfini. 4) Cryptage.c..............................................................Erreur ! Signet non dfini. 5) Decryptage.c ..........................................................Erreur ! Signet non dfini. 6) Forcage.c ...............................................................Erreur ! Signet non dfini. 7) Divers.c ..................................................................Erreur ! Signet non dfini.


Introduction

Le cryptage est historiquement lune des premires applications de linformatique. Ce domaine, qui tait il y a encore quelques annes, rserv aux militaires et aux grandes entreprises, concerne aujourdhui tous ceux qui souhaitent transmettre des donnes protges, quils soient professionnels ou particuliers. Pour cela, il existe de nombreuses mthodes de cryptage, mais peu dentre elles sont reconnues comme sres. La mthode RSA fait depuis longtemps partie de cette catgorie.

Dans ce projet, nous allons dvelopper un petit programme de cryptage et dcryptage bas sur ce chiffre. Le but ne sera pas de dvelopper un programme au code incassable , mais plutt de comprendre comment fonctionne le cryptage RSA.


Prsentation du cryptage RSA

Le cryptage RSA, du nom de ses concepteurs, Ron Rivest, Adi Shamir et Leonard Adleman, est le premier algorithme de chiffrement asymtrique. Il a t dcouvert en 1977 au Massachusetts Institute of Technology.

Un chiffrement asymtrique est un cryptage o lalgorithme de chiffrement nest pas le mme que celui de dchiffrement, et o les cls utilises sont diffrentes. Lintrt est norme : il ny a plus besoin de transmettre la cl son destinataire, il suffit de publier librement les cls de cryptage. Nimporte qui peut alors crypter un message, mais seul son destinataire, qui possde la cl de dcodage, pourra le lire. En quelques annes, RSA sest impos pour le cryptage comme pour lauthentification et a progressivement supplant son concurrent, le DES.

Le RSA est bas sur la thorie des nombres premiers, et sa robustesse tient du fait quil nexiste aucun algorithme de dcomposition dun nombre en facteurs premiers. Alors quil est facile de multiplier deux nombres premiers, il est trs difficile de retrouver ces deux entiers si lon en connat le produit.


Principe

1) Gnration des cls

Le RSA fonctionne partir de deux nombres premiers, que lon appellera p et q. Ces deux nombres doivent tre trs grands, car ils sont la cl de vote de notre cryptage. Aujourdhui, on utilise des cls de 128 1024 bits, ce qui reprsente des nombres dcimaux allant de 38 308 chiffres !

Une fois ces deux nombres dtermins, multiplions-les. On note n le produit n = p q, et z = (p 1) (q 1).

Cherchons maintenant un nombre e (infrieur z) , qui doit ncessairement tre premier avec z.

Calculons ensuite linverse de e modulo z, que nous noterons d. d e-1 mod((p - 1)(q - 1))

Le couple (e, n) est la cl publique, et (d, n) est la cl prive.

2) Cryptage et dcryptage

Pour crypter un nombre, il suffit de le mettre la puissance e. Le reste modulo n reprsente le nombre une fois crypt.

c

= te mod n

Pour dcrypter, on utilise la mme opration, mais en mettant la puissance d :

t

= cd mod n

Une fois e, d et n calculs, on peut dtruire p, q et z, qui ne sont pas ncessaires pour crypter et dcrypter. Pire encore, on peut calculer trs rapidement la cl prive d partir de p et q, il ne faut donc pas conserver ces nombres.

Note : En gnral, la cl prive est ensuite crypte laide dun cryptage symtrique. Cela permet de la conserver de faon sre, car la cl utilise par le cryptage symtrique na pas tre transmise, et donc ne risque pas dtre intercepte.


3) Exemple

Voici un exemple de lutilisation de RSA, avec des petits nombres :

Saddam souhaiterait envoyer le message suivant George : Kisses from Iraq . Malheureusement, Vladimir les espionne, et pourrait intercepter ce message. Nos deux compres vont donc crypter leurs changes avec la mthode RSA.

George a choisi p = 37 et q = 43. Il en dduit n = 37 43 = 1591, et z = 36 42 = 1512.

Il choisit ensuite e = 19, qui est premier avec 1512. Linverse de 19 modulo 1512 est d = 955.

George peut donc maintenant publier ses cls publiques, par exemple sur son site internet : e = 19 et n = 1591

Saddam va utiliser ces cls pour crypter son message, mais il doit avant tout convertir son texte en une suite de nombres. Comme Saddam veut envoyer le message sous forme dun fichier informatique, le mieux est dutiliser le code ASCII (Amercian Standard Code for Information Interchange). Ce code attribue un nombre entre 0 et 255 pour chaque caractre de base utilisable sur un ordinateur.

En ASCII, Kisses from Iraq devient :

K i s s e s f r o m I r a q 75 105 115 115 101 115 32 102 114 111 109 32 43 114 97 113

Il suffit Saddam de coder chaque nombre comme expliqu ci-dessus. Il obtient :

75 19 [1591] = 371 ; 105 19 [1591] = 1338 ; etc

75 105 115 115 101 115 32 102 114 111 109 32 43 114 97 113 371 1338 1410 1410 1174 1410 930 1397 632 703 483 930 1405 632 532 1441

Saddam envoie cette suite de nombres George, qui va le dcrypter avec sa cl d. Il va pouvoir retrouver le message original :

371 955 [1591] = 75 ; 1338 955 [1591] = 105 ; etc

371 1338 1410 1410 1174 1410 930 1397 632 703 483 930 1405 632 532 1441 75 105 115 115 101 115 32 102 114 111 109 32 43 114 97 113 K i s s e s f r o m I r a q

En recodant en ASCII, George va pouvoir lire le message de son ami, sans que Vladimir nait pu le dchiffrer.


4) Forcage du code RSA

Si Vladimir est vraiment curieux et veut absolument dcrypter le message de Saddam, il devra essayer de forcer le code RSA. Pour cela, il faut quil dtermine la cl prive d partir de ce quil connat, cest dire n et e (qui sont publiques).

Pour ce faire, il doit tenter de trouver p et q partir de n. Comme nous le disions prcdemment, il nexiste pas de mthode miraculeuse pour retrouver ces deux nombres. Il faut tenter toutes les combinaisons de nombres premiers pour trouver celle dont le produit donnera n . Selon le principe fondamental de la thorie des nombres, la dcomposition en facteurs premiers est unique, Vladimir sera donc sr davoir trouv les bonnes valeurs de p et q.

Une fois p et q trouv, il ne lui reste plus qua dterminer z, et de calculer d partir de e et z, de la mme faon que lors de la gnration de la cl. Vladimir pourra alors dcoder le message crypt et ainsi assouvir sa curiosit.

Bien sr, pour p = 37 et q = 43, lopration de forage ne prendra que quelques millisecondes. Mais si Saddam et George avaient employ des cls de 1024 bits, le pauvre Vladimir aurait du patienter quelques mois avant de pouvoir dchiffrer le fameux message !

Lalgorithme ne semble donc pas trs compliqu. Sa dmonstration fait appel des thormes comme le thorme dEuclide ou celui de Fermat.


Dmonstration

1) Thorme de Fermat

Le petit thorme de Fermat affirme que si p est un nombre premier, alors pour tout entier a, on a :

ou ap (mod p) a ou ap-1 (mod p) 1

ou ap-2 (mod p) a-1

Ce qui signifie que si vous considrez un entier a, et que vous le multipliez par lui-mme p fois et que vous lui soustrayez a, le rsultat est divisible par p.

2) Gnralisation du thorme par Euler

Lindicateur dEuler, not (n), est le nombre des nombres premiers avec n compris entre 1 et n-1.

( ) pkppnsipkpp

n =

= 2111

211

111

Chaque facteur premier de n nest utilis quune seule fois, quelque soit le nombre de fois quil apparat dans la dcomposition de n.

On a alors :

a(n) (mod n) 1

ou a(n)-1 (mod n) a-1

on a : a(n)-1 a = a(n)-1+1 = a(n)

Donc a(n) est un inverse de de a (mod n)


On a donc, grce au thorme de Fermat-Euler :

cid (mod n) (tie)d (mod n)

tied (mod n) tik(p-1)(q-1)+1 (mod n) ti * tik(p-1)(q-1) (mod n) ti * 1 (mod n) ti (mod n)

Puisque

tik(p-1)(q-1) (mod n) 1


Les limites du RSA

Dans la pratique, le RSA est un code sr, si lon respecte les quelques rgles suivantes :

- p et q doivent tre trs grands. En effet, on estime quil faut moins dune seconde pour casser un code base de nombres de 32 bits. Comme expliqu prcdemment, on doit utiliser des cls de 128 bits minimum (ou plus si la lgislation en vigueur le permet), pour garantir un code sr court terme.

- Il faut crypter le message par blocs de plusieurs caractres. En effet, si lon crypte caractre par caractre, chacun deux sera cod par le mme nombre. Il est alors facile de forcer le message par analyse frquentielle*, ou en testant systmatiquement les 256 combinaisons possibles. En codant par groupe de 4 ou 8 caractres (32 ou 64 bits), lanalyse frquentielle devient impossible, et le nombre de combinaisons possibles augmente normment (plus de 4 milliards de combinaisons sur 32 bits).

Le RSA possde galement quelques inconvnients dordre mathmatique :

- On ne peut pas choisir un n infrieur la valeur maximale coder. Ainsi, si on code caractre par caractre, on code des valeurs comprises entre 0 et 255. Si n < 255, notre cryptage ne sera pas bijectif. Cela sexplique car nous effectuons le modulo n lors du cryptage et du dcryptage. Si n est trop petit, plusieurs caractres pourront tre crypts par le mme nombre, et ne pourront donc plus tre diffrencis lors du dcryptage.

- Les calculs sont souvent trs lourds, du fait de la taille des entiers manipuler. Le cryptage dun message long, avec des cls de grande taille, peut prendre plusieurs heures sur un ordinateur puissant.

De plus, lorsquil sagit de programmer un logiciel de cryptage / dcryptage RSA, nous nous heurtons un nouveau problme : le dpassement de capacit des variables. En effet, le plus grand type dentier prvu dans le langage C est le type unsigned long int, qui ne peut grer que des nombres de 32 bits au maximum. Ceci est notoirement insuffisant pour un cryptage efficace.

Notre programme se contentera donc de fonctionner pour des petits nombres , cest dire pour des nombres p et q compris entre 0 et 255. Nous allons donc obtenir une cl n comprise entre 0 et 65535. Mais pour les raisons voques ci-dessus, il ne sera pas possible de crypter par blocs de plusieurs caractres (il nous faudrait n > 65536 pour pouvoir coder par blocs de 2 caractres).

Notre code est donc dune grande simplicit casser, cest pour cela que notre programme na quun but pdagogique et ne devra en aucun cas tre utilis pour un usage commercial .

* Note : lanalyse frquentielle consiste dchiffrer un message en se basant sur la frquence dapparition des lettres dans une langue. Ainsi, dans un texte en franais, le code apparaissant le plus souvent dans un message chiffr sera vraisemblablement celui correspondant la lettre e .


Choix algorithmiques

Nous allons maintenant dcrire les algorithmes utiliss dans le logiciel :

1) Gnration des cls

a) Gnration de p et q

Il existe quelques mthodes permettant de dterminer si un nombre est premier ou non. Ces mthodes ont une complexit et un taux de russite variables (certaines fonctionnent 100%, et dautres ne donnent quune probabilit que le nombre soit premier).

Dans le cas de petits nombres, la mthode la plus efficace est sans nul doute lapplication de la dfinition dun nombre premier :

Pour un nombre donn, il suffit donc de calculer les restes de tous les entiers > 1 qui sont strictement infrieurs sa racine carre. Si lun deux a un reste nul, il est diviseur, et le nombre nest pas premier. Dans le cas contraire, le nombre sera bien videmment premier.

Nous pouvons donc crire lalgorithme suivant :

EstPremier(n : entier long ; premier : boolen) $1 boolen premier

premier


FAIRE $1 FAIRE $11 p


b) Gnration de e

La cl publique e doit imprativement tre premire avec z. Nous devons donc construire un algorithme capable de dterminer si deux nombres sont premiers entre eux, cest dire que PGCD(a,b) = 1. La mthode la plus simple et la plus rapide pour dterminer un PGCD reste sans conteste lalgorithme de ce cher Euclide, que nous pouvons programmer de la manire suivante :

Pgcd (entier long a, entier long b ; entier long pgcd) $1 entier long c

c


d) Gnration de d

Le calcul de d, la cl prive, est lopration la plus lourde. Rappelons tout dabord ce quest linverse dun nombre modulo z :

d inverse de e modulo z d = e-1 [z] d e = 1 [z]

On utilise alors la boucle suivante pour dterminer d :

d


2) Cryptage

Notre programme est capable de coder nimporte quel fichier : texte, image, excutable ou encore MP3 pirate. Nous nallons donc pas pouvoir raisonner en termes de caractres, mais en termes doctets. Notre programme va lire le fichier octet par octet, coder cet octet en un nouveau nombre sur deux octets (16 bits), puis lcrire dans un nouveau fichier, qui sera notre fichier crypt. Il est ncessaire de coder sur 16 bits car chaque octet du fichier dorigine va devenir un nombre compris entre 0 et n (on a n < 65535 = 2 16 1). La taille de notre fichier crypt sera donc multiplie par deux.

Le cryptage fonctionne avec la formule suivante :

Cela correspond lalgorithme suivant :

codage(lettre : caractre, n : entier long , e : entier long ; c : entier court) $1

entiers courts : i, c, t

t = (entier court)lettre c = 1;

// effectue c = t^e mod n POUR i


A cet algorithme de codage, nous devons ajouter un certain nombre de protections et de vrifications concernant louverture des fichiers. Appelons fichier source le fichier coder, et fichier destination le fichier une fois crypt.

Dbut

Demande ou rcupre e et n.

Demande ou rcupre les noms des fichiers source et destination

Noms de fichiers valides ?

Fin (erreur)

Le fichier source existe t-il ?

Fin (erreur)

Le fichier dest. existe t-il ?

Ecraser ce fichier ?

Fin (erreur)

Se placer au dbut du fichier source

Fin du fichier source ?

Lire un octet dans le fichier source

Coder cet octet

Ecrire le rsultat (2 octets) dans le fichier destination

Fermer les deux fichiers

Fin (ok)

oui

oui

oui

oui

oui

non

non

non

non

non


3) Dcryptage

Le dcryptage fonctionne comme le cryptage, trois dtails prs : - Lalgorithme de dcodage devient ti = ci d [n], - Le fichier source devient le fichier crypt, et le fichier destination le fichier une

fois dcrypt, - Lors du dcodage, on lit 2 octets la fois dans le fichier source, et en

dcryptant, on obtient un caractre cod sur 1 octet.

Voici donc notre algorithme de dchiffrement :

decodage(lettre : entier court, n : entier long , d : entier long ; c : caractre) $1

entiers courts : i, c caractre : t

// effectue c = t^e mod n POUR i


4) Forage

Lalgorithme de forage est extrmement simple : il sagit principalement de deux boucles imbriques, qui vont tester toutes les combinaisons de p et q infrieurs 255 afin de dterminer le couple dont le produit donne n. La suite nous ramne en terrain connu : on recalcule z, puis enfin d. 0 est renvoy si d na pas pu tre trouv.

forcage(n : entier long, e : entier long ; d : entier long) $1 entiers longs : p, q, d, z

//boucle de recherche systmatique de p et q POUR p


5) Interface Homme Machine, gestion du temps et des erreurs

a) IHM

Le dialogue entre lutilisateur et la machine se fait au moyen dune boucle classique :

Le menu contient les lments suivants :

[k] gnrer les cls publiques et prives [c] crypter un fichier [d] dcrypter un fichier [f] pour lancer le module de forage [q] quitter

Nous ne rentrerons pas dans le dtail pour le code de ce menu, car ce nest pas lobjet du projet, et car il ne comporte pas de difficult particulire.

Dbut

Lutilisateur saisit sa commande

Interprtation de la commande et appel des fonctions concernes

Affichage des rsultats et des messages derreur ventuels

Affichage du menu

La commande est elle q ?

Fin oui

non

La commande existe-t-elle ?

non

oui

Affichage du titre


b) Gestion du temps

Les principales fonctions (gnration des cls, cryptage, dcryptage et forage) on t pourvues dun systme de chronomtrage, afin de pouvoir apprcier le temps dexcution des diffrents calculs. Son fonctionnement est extrmement simple : on mmorise lheure systme juste avant dexcuter lopration, puis on soustrait cette valeur celle de lheure laquelle se termine lopration. Nous obtenons une diffrence qui reprsente la dure du calcul, la seconde prs.

c) Gestion des erreurs

Chaque fonction renvoie un code dexcution, indiquant si celle-ci sest droule correctement. Cela permet notre programme dinformer lutilisateur si une opration sest droule sans souci, ou non.


Tests et performances

Dans cette partie, nous allons dtailler le comportement de notre programme pour des cls de diffrentes tailles, et nous tenterons de dresser un bilan de la complexit et de la scurit des algorithmes composant le RSA.

Tout dabord, il est trs difficile destimer la dure de calcul des cls, ainsi que la dure de forage pour des valeurs de p et q < 255. En effet, ces calculs se font quasiment instantanment. Afin de pouvoir avoir des rsultats significatifs, nous avons port la constante PQ_MAX 65535, ce qui est le maximum physiquement acceptable par le programme. Nous obtenons alors des cls allant jusqu' 4 milliards, beaucoup plus longues calculer. Il faut par contre signaler que, bien que les cls soient correctes, le cryptage/dcryptage ne fonctionne plus correctement, du fait dun dbordement de capacit.

1) Gnration des cls

Celle-ci se fait en trois tapes. La gnration de p et q est quasiment instantane, tout comme celle de e. Lopration prenant le plus de temps est le calcul de d. Ce calcul peut seffectuer en des temps trs variables, ne dpendant absolument pas de n. Prenons lexemple suivant :

n 465 236 741 155 744 969 e 25 261 13 313 d 62 738 725 179 086 157

Temps de calcul 4 secondes 11 secondes

Nous remarquons que le deuxime calcul, bien quutilisant des nombres n et e plus petits, a dur presque trois fois plus longtemps que le premier.

La vitesse de gnration des cls ne dpend donc pas de n, mais plutt de d. En effet, plus celui-ci est lev, plus le calcul sera long. Cela sexplique par lalgorithme utilis, qui sera dautant plus long que d est grand.

Nous pouvons donc dresser des statistiques du temps de calcul en fonction de d :

D= 323603 1960111 22607593 43389697 60954633 110268537 169580963 191413867 T(s) 0 0 1 3 4 7 11 12

D= 212757921 266988069 327264819 51214311 544384595 708356463 778516771 1870274413 T(s) 15 18 21 33 35 47 50 132

A titre indicatif, ces valeurs on t mesures sur un PC Intel Pentium III 650 MHz


0

100000000

200000000

300000000

400000000

500000000

600000000

700000000

800000000

900000000

0 10 20 30 40 50 60

Temps (s)

Vale

ur

de D

Nous pouvons facilement remarquer que cette courbe est peu prs proportionnelle. Notre algorithme de calcul des cls est donc complexit linaire (cela se vrifie en analysant le code source).

2) Forage des cls

Lopration de forage des cls se droule elle aussi en trois tapes : - Tout dabord, dterminer p et q - Ensuite, dterminer z (opration instantane) - Enfin, calculer d (de la mme faon que pour la gnration des cls)

Pour dterminer p et q partir de n, il faut tester systmatiquement les combinaisons de couples (p,q), pour trouver celle dont le produit fait n. Nous limitons p et q une certaine valeur maximum, de la mme faon que lors du cryptage. Appelons cette valeur PQ_MAX. Pour p et q infrieurs PQ_MAX, il existe donc (PQ_MAX) couples (p , q) possibles. Lorsquon double PQ_MAX, on quadruple de nombre de couples possibles, et donc le temps potentiel de calcul de p et q. Lalgorithme de forage est donc complexit polynomiale. Il faut en plus lui ajouter le calcul de d, qui est de complexit linaire.

Toutefois, la structure de ce dernier fait quil est trs rapide de casser une cl dont la composante p serait petite (et cela mme si q est grand). Nous allons donc donner quelques exemples de forage de cls, pour lesquels p et q sont de mme ordre de grandeur.


N 36051 37132441 419579269 649705789 897386827 P 183 6827 19767 24611 32069 Q 197 5483 19381 26399 27983

T(s) 0 1 4 6 9

0

5000

10000

15000

20000

25000

30000

35000

0 2 4 6 8 10

Temps (s)

Vale

ur

de P

Nous obtenons ici une relation quasiment linaire, ce qui est tout a fait normal, car nous navons pas fait varier la valeur de PQ_MAX (fixe 65535 pour tous ces tests).

Pour optimiser le forage, il faut donc choisir PQ_MAX le plus faible possible, mais bien videmment suprieur max(p,q).

3) Cryptage / dcryptage

Ces oprations dpendent de deux paramtres : - La taille du fichier traiter - La taille de e pour le codage, et d pour le dcodage.

En observant ces algorithmes, nous pouvons voir quils ont une complexit linaire, selon ces deux paramtres. Nous ne pourrons toutefois pas le prouver au moyen de valeurs releves, car le cryptage et dcryptage ne fonctionnent correctement que pour des valeurs trs faibles de p et q. Dans ce cas, le temps dexcution dpasse rarement la seconde, et nest donc pas significatif.


4) Conclusion

Soient : - TD le temps de calcul de d (qui est quasiment gal au temps total de calcul

des cls) - TCr le temps ncessaire pour crypter un fichier - TDcr le temps ncessaire pour le dcrypter - TPQ le temps ncessaire pour trouver p et q partir de n.

Reprenons notre exemple ci-dessus :

-

Pour gnrer les cls, puis la fin dcrypter le message, George va utiliser le temps TD + TDcr

- Pour crypter le fichier, Saddam va utiliser le temps TCr

- Pour forcer les cls et dcrypter le message, Vladimir va utiliser le temps TPQ + TD + TDcr

Vladimir va donc passer TPQ de temps en plus que George pour dcrypter le message de Saddam. Cest pour cela que toute la scurit du RSA repose sur le temps ncessaire pour calculer p et q partir de n.

Pour conclure, on peut constater que le codage RSA est viable, car le temps de gnration des cls augmente linairement, alors que le temps de forage de ces cls est suivant une parabole. Cela veut dire que plus on utilise des nombres grands, et plus la diffrence de temps sera significative entre le calcul des cls et le forage du code.

Cest ainsi que sur des cls de 1024 bits, on obtient souvent une diffrence de lordre de plusieurs semaines, ou plusieurs mois ! Ainsi George aura le temps de prendre toutes les dispositions ncessaires avant que Vladimir nai pu avoir connaissance du fameux message.


Conclusion

Ce programme de cryptage nous a permis davoir une nouvelle approche de la conception, o le temps la rflexion et les tudes pralables sont bien plus importantes et difficiles que la programmation en elle-mme.

Nous avons galement pu combiner les mathmatiques et linformatique dans un domaine concret et particulirement dactualit : la cryptographie.

Enfin, ce projet nous a montr la ncessit doptimiser nos algorithmes afin davoir des programmes plus performants.

Ce projet est donc un petit pas pour la cryptographie, mais un grand pas dans notre formation !

Les auteurs tiennent remercier George, Saddam et Vladimir, sans qui ce rapport naurait pas t ce quil est actuellement !

Cryptographie Rsa

Documents