Cryptographie et algorithmique

Transcription

1 F.Gaudo 1 er ovembre 2010 Table des matières 1 Avat de commecer 2 2 Préformattage d'u texte pour aalyse Élimiatio de la poctuatio et des espaces das u texte Formatage du texte e lettres miuscules Aalyse de fréqueces Aalyse de fréqueces d'ue lettre de l'alphabet Aalyse de fréquece de l'esemble des lettres de l'alphabet Substitutio d'ue lettre par ue autre 9 5 Codage ae 10 6 Codage par la méthode de Vigeère 12 7 Algorithme RSA Géératio des clés publiques et privées Codage Décodage

2 1 Avat de commecer Ce documet cotiet ue liste d'algorithmes e rapport avec la cryptographie pour le lycée et les programmes correspodats. La cryptographie abordée ici porte essetiellemet sur les méthodes de chiremet de textes par substitutio (codage de César, Vigeère) à l'exceptio otable de l'algorithme RSA. Le lagage de programatio Pytho a été choisi car il est cosidéré par les développeurs professioels comme l'u des plus appropriés pour l'appretissage de la programmatio. Le lagage de programmatio du logiciel XCas a été choisi pour sa structure fracisée et éamois très proche de celle des lagages de programmatio usuels (Pytho, C etre autres), ce qui e fait u logiciel particulièremet adapté à u public fracophoe. Ce documet suppose ue coaissace des istructios fodametales (etrées, sorties, boucles, coditios) du lagage Pytho aisi que de celles du logiciel XCas. Il 'est fait usage das les programmes que de otios pouvat être abordées au iveau du lycée das le cadre de l'appretissage de l'algorithmique. E particulier, il 'est pas fait usage de la otio de foctio (iformatique...). Pour le lagage Pytho, a d'utiliser des caractères accetués das les programmes, o 'oubliera pas de préciser l'ecodage de caractères utilisé e plaçat au début de chaque programme la lige suivate sous Widows #-*- codig:lati-1 -*- et sous Liux ubutu #-*- codig:utf-8 -*- http: // mathsfg. et. free. fr 2

3 2 Préformattage d'u texte pour aalyse 2.1 Élimiatio de la poctuatio et des espaces das u texte Etrées : texte : chaîe de caractère. Début traitemet bcar pred la valeur de logueur(texte) ; alphabet="abcdefghijklmopqrstuvwxyz" ; texteformate pred la valeur ; pour k allat de 1 à bcar faire j pred la valeur 0 ; trouve pred la valeur 0 ; tat que j<logeur(alphabet) et trouve = 0 faire si texte[k] = alphabet[j] alors trouve = 1 ; si trouve = 0 alors j pred la valeur de j + 1 ; si trouve = 1 alors texteformate = texteformate + texte[k] ; Fi Sorties : textef ormate http: // mathsfg. et. free. fr 3

4 Programmes correspodats : XCas : texte:="ceci 'est qu'u exemple."; alphabet:="abcdefghijklmmopqrstuvwxyz......abcdefghijklmnopqrstuvwxyz"; bcar:=legth(texte); afficher("texte : "+texte); afficher("nombre de caractères :"+bcar); texteformate:=""; pour k de 0 jusque bcar-1 faire j:=0; trouve:=0; tatque (j<legth(alphabet)) et......(trouve==0) faire si texte[k]==alphabet[j] alors trouve:=1; fsi; si trouve==0 alors j:=j+1;fsi; ftatque; si trouve==1 alors texteformate:=texteformate+texte[k]; fsi; afficher(texteformate); Pytho : texte="ceci 'est qu'u exemple" alphabet="abcdefghijklmopqrstuvwxyz......abcdefghijklmnopqrstuvwxyz" bcar=le(texte) prit "Texte : ",texte prit "Nombre de caractères :",bcar texteformate="" for k i rage(bcar): j=0 trouve=0 while (j<le(alphabet))......ad (trouve==0): if texte[k]==alphabet[j]: trouve=1 if trouve==0: j=j+1 if trouve==1: texteformate=texteformate+texte[k] prit texteformate Remarques : Les... apparaissat ci-dessus e doivet pas apparaître das les programmes, ils sigalet juste que les deux liges e doivet e faire qu'ue. Le texte à traiter est ici etré sous forme d'ue chaîe de caractère. E cas de log texte à traiter. E pytho, o pourra le stocker das u chier à part et utiliser les istructios suivates : fichier=ope('icivotreomdefichier.txt','r') texte=fichier.read() fichier.close() http: // mathsfg. et. free. fr 4

5 2.2 Formatage du texte e lettres miuscules L'algorithme suivat met u texte préalablemet débarassé de tout sige de poctuatio e lettres miuscules. Etrées : texte : chaîe de caractère. Début traitemet bcar pred la valeur de logueur(texte) ; texteformate pred la valeur ; pour k allat de 1 à bcar faire si ord(texte[k])<97 alors textef ormate=textef ormate+chr(ord(texte[k])+32) ; sio texteformate pred la valeur de texteformate + texte[k] ; Fi Sorties : textef ormate Programmes correspodats : XCas : texte:="ceciestquunexemple"; bcar:=legth(texte); afficher("texte : "+texte); afficher("nombre de caractères :"+bcar); texteformate:=""; pour k de 0 jusque bcar-1 faire si ord(texte[k])<97 alors texteformate:=texteformate char(ord(texte[k])+32) else texteformate:=texteformate+texte[k]; fsi; afficher(texteformate); Pytho : texte="ceciestquunexemple" bcar=le(texte) prit "Texte : ",texte prit "Nombre de caractères :",bcar texteformate="" for k i rage(bcar): if ord(texte[k])<97: texteformate=texteformate chr(ord(texte[k])+32) else: texteformate=texteformate+texte[k] prit texteformate http: // mathsfg. et. free. fr 5

6 3 Aalyse de fréqueces L'aalyse de fréqueces d'u texte permet, lorsque l'o a simplemet remplacé ue lettre d'u texte par ue autre (méthode de substitutio simple), de recoaître les lettres les plus fréquetes du texte, le "e" e fraçais par exemple. 3.1 Aalyse de fréqueces d'ue lettre de l'alphabet L'algorithme suivat ache la fréquece d'apparitio de la lettre demadée par l'utilisateur das u texte préalablemet formatté (caractères mis e miuscules, espaces et siges de poctuatio supprimés) doé : Etrées : lettre : caractère ; texte : chaîe de caractère. Début traitemet bcar pred la valeur de logueur(texte) ; compteur pred la valeur 0 ; pour k allat de 1 à bcar faire si texte[k] = lettre alors compteur pred la valeur de compteur+1 ; freq pred la valeur compteur bcar Fi Sorties : freq Programmes correspodats : XCas : texte:="ceciestquuexemple"; bcar:=legth(texte); afficher("texte : "+texte); afficher("nombre de caractères :"+bcar); saisir(lettre); compteur:=0; pour k de 0 jusque bcar-1 faire si texte[k]==lettre alors compteur:=compteur+1;fsi; freq:=approx(compteur/bcar); afficher("fréquece :"+freq); Pytho : texte="ceciestquuexemple" bcar=le(texte) prit "Texte : ",texte prit "Nombre de caractères :",bcar lettre=raw_iput("lettre : ") compteur=0.0 for k i rage(bcar): if texte[k]==lettre: compteur=compteur+1 freq=compteur/bcar prit "Fréquece :",freq Remarque : Pour le programme sous XCAS, o etrera la lettre voulue etre parethèses a que le logiciel traite la lettre etrée comme u caractère. http: // mathsfg. et. free. fr 6

7 3.2 Aalyse de fréquece de l'esemble des lettres de l'alphabet Même problème que le précédet mais o ajoute ue boucle pour calculer la fréquece de chacue des lettres de l'alphabet. Etrées : texte : chaîe de caractères. Début traitemet bcar pred la valeur de logueur(texte) ; alpahbet pred la valeur "abcdefghijklmopqrstuvwxyz" pour j allat de 1 à 26 faire compteur pred la valeur 0 ; pour k allat de 1 à bcar faire si texte[k] = alphabet[j] alors compteur pred la valeur de compteur+1 ; freq pred la valeur compteur bcar Acher freq Fi http: // mathsfg. et. free. fr 7

8 Programmes correspodats : XCas : texte:="ceciestquuexemple"; bcar:=legth(texte); afficher("texte : "+texte); afficher("nombre de caractères :"+bcar); alphabet:="abcdefghijklmopqrstuvwxyz"; pour j de 0 jusque 25 faire compteur:=0; pour k de 0 jusque bcar-1 faire si texte[k]==alphabet[j] alors compteur:=compteur+1;fsi; freq:=approx(compteur/bcar); afficher(alphabet[j]+" : "+freq); Pytho : texte="ceciestquuexemple" bcar=le(texte) prit "Texte : ",texte prit "Nombre de caractères :",bcar alphabet="abcdefghijklmopqrstuvwxyz" for lettre i alphabet: compteur=0.0 for k i rage(bcar): if texte[k]==lettre: compteur=compteur+1 freq=compteur/bcar prit lettre," : ",freq Remarque : Das le programme pour Xcas, j est l'idice de la lettre das l'alphabet. O aurait pu procéder de même e lagage Pytho mais celui-ci permet aussi d'utiliser la variable lettre comme u caractère de l'alphabet ce qui est plus pratique. http: // mathsfg. et. free. fr 8

9 4 Substitutio d'ue lettre par ue autre L'algorithme suivat est à la base des méthodes de substitutio simple : il substitue ue lettre doée par ue autre lettre doée das u texte doé. Etrées : lettre1, lettre2 : caractères ; texte : chaîe de caractère. Début traitemet bcar pred la valeur de logueur(texte) ; pour k allat de 1 à bcar faire si texte[k] = lettre1 alors texte[k] = lettre2 ; Fi Sorties : texte Programmes correspodats : XCas : texte:="abcdefgh"; bcar:=legth(texte); afficher(texte); saisir("lettre à substituer : ",lettre1); saisir("lettre de substitutio:",lettre2); pour k de 0 jusque bcar-1 faire si texte[k]==lettre1 alors texte[k]:=lettre2;fsi; afficher(texte); Pytho : texte="abcdefgh" lettre1=raw_iput("lettre à substituer :") lettre2=raw_iput("lettre de substitutio:") bcar=le(texte) prit "Texte à coder : "+texte textecode="" for k i rage(bcar): if texte[k]==lettre1: textecode=textecode+lettre2 else: textecode=textecode+texte[k] prit "Texte codé : "+textecode Remarques : Das le programme sous Pytho, o a utilisé ue deuxième chaîe de caractères "textecode" car l'istructio lettre[k]=lettre2 'est pas acceptée et provoque ue erreur. O aurait cepedat pu utilisé l'istructio texte=texte.replace(lettre1,lettre2) par cotre à la place de l'esemble de la boucle for. Das le programme XCas, etrer les lettres etre guillemets a qu'elles soiet recoues comme du texte. http: // mathsfg. et. free. fr 9

10 5 Codage ae L'algorithme suivat est u exemple de chire de substitutio : il chire u texte préformatté e utilisat u cryptage ae doé par la foctio f mx + p où m et p sot etrés par l'utilisateur. Attetio, selo les valeurs choisis de m et p, o obtiet u cryptage qui 'est pas écessairemet ecace : e eet, pour certaies valeurs de m et p, deux lettres diéretes du texte o codé peuvet doer ue même lettre das le texte codé ce qui e permet pas par la suite de retrouver le message origial. O peut d'ailleurs motrer que cela arrive si et seulemet si la foctio ae utilisée est telle que m 'est pas premier avec 26. La programmatio de cet algorithme écessite l'utilisatio de ce que l'o appelle les codes ASCII. E eet, e iformatique, chaque caractère imprimable est représeté par u ombre etier. E particulier, les lettres miuscules sot représetées par les ombres allat de 97 (code ASCII de "a") à 122 (code ASCII de "b"). Etrées : texte : chaîe de caractère ; m, p : ombres. Début traitemet bcar pred la valeur de logueur(texte) ; textecode pred la valeur "" ; pour k allat de 1 à bcar faire u pred la valeur ASCII de texte[k] otée de 97 ; v pred la valeur de m u + p ; w pred la valeur du reste de la divisio euclidiee de v par 26 ; t pred la valeur du caractère de code ASCII w + 97 ; textecode[k] pred la valeur de t. Fi Sorties : textecode Programmes correspodats : XCas : texte:="abcdefgh"; saisir("m : ",m); saisir("p : ",p); afficher("texte : "+texte); f(x):=m*x+p; textecode:=""; pour k de 0 jusque legth(texte)-1 faire u:=ord(texte[k])-97; v:=f(u); w:=irem(v,26); t:=char(97+w); textecode:=textecode+t; afficher("texte codé : "+textecode); Pytho : texte="ceciestquuexemple" m=iput("m : ") p=iput("p : ") prit "Texte : ",texte textecode="" bcar=le(texte) for k i rage(bcar): u=ord(texte[k])-97 v=2*u-3 w=v%26 t=chr(97+w) textecode=textecode+t prit "Texte codé :",textecode http: // mathsfg. et. free. fr 10

11 Remarque : Le codage dit de César qui cosiste à décaler les lettres d'u certai ombre de rags est u cas particulier de codage ae : il cosiste à predre m = 1 et m égal au ombre de rags de décalage. http: // mathsfg. et. free. fr 11

12 6 Codage par la méthode de Vigeère Les programmes suivats implémetet la méthode de codage de Vigeère qui utilise u mot clef idiquat le codage par la méthode de César à utiliser pour chacue des lettres du texte. Programmes correspodats : XCas : texte:="ceciestquuexemple"; bcar:=legth(texte); saisir("clef ",clef); cleftexte:=strig(clef); logclef:=legth(cleftexte); afficher("texte à coder : "+texte); textecode:=""; pour k de 0 jusque bcar-1 faire j:=irem(k,logclef); cark:=cleftexte[j]; decalage:=ord(cark)-97; textecode:=textecode char(irem(ord(texte[k]) decalage,26)+97); afficher("texte codé : "+textecode); Pytho : texte="ceciestquuexemple" clef=raw_iput("clef de codage : ") logclef=le(clef) bcar=le(texte) prit "Texte à coder",texte textecode="" for k i rage(bcar): bcar=le(texte) j=k%logclef cark=clef[j] decalage=ord(cark)-97 textecode=textecode chr((ord(texte[k])-97+decalage)%26+97) prit "Texte codé : ",textecode http: // mathsfg. et. free. fr 12

13 7 Algorithme RSA Les programmes suivats, écrits pour XCas, implémetet l'algorithme de chiremet RSA (Rivest, Shamir, Adlema). Pour des précisios théoriques sur l'algorithme, o pourra se reporter à la littérature abodate déjà existate, e particulier l'aide du logiciel XCas das laquelle gure ue autre implémetatio de cet algorithme. Rappelos que cet algorithme utilise ue clé publique (u, ) écessaire au chiremet d'u message, et ue clé privé (m, ) écessaire au déchiremet, état le produit de deux grads (voire très grads ) ombres premiers p et q teus secrets. La diculté de la factoristatio e ombres premiers garatie aisi la robustesse de l'algorithme face aux tetatives de déchiremet. Les caractères du message sot préalablemet trasformés e liste de codes ASCII correspodats puis chirés par blocs de plusieurs ombres (pour mettre e échec les tetatives de déchiremet par aalyse de fréqueces). O a d'ailleurs fait gurer das le programme suivat la possibilité de choisir le ombre j de caractères regroupés das u même bloc. 7.1 Géératio des clés publiques et privées // Recherche de p et q premiers saisir(p1); p:=extprime(p1); saisir(q1); q:=extprime(q1); :=p*q; // Détermiatio de m et u m:=extprime(max((p-1)/2,(q-1)/2)); tatque ((gcd(m,p)!=1) et (gcd(m,q)!=1)) faire m:=extprime(m); ftatque; phi=(p-1)*(q-1); u:=bezout_etiers(m,phi)[1]; tatque (u<0) faire u:=u+phi;ftatque; afficher("clé publique : u = "+u+", = "+); afficher("clé privée : m = "+m+", = "+); // Recherche de la puissace j la plus grade telle que 26^j<mi(p,q) // pour les regroupemets e blocs de j ombres. j:=0; tatque (26^j<mi(p,q)) faire j:=j+1;ftatque; j:=j-1; afficher("codage par blocs de "+j+" ombre(s) maximum"); http: // mathsfg. et. free. fr 13

14 7.2 Codage Codage par l'algorithme RSA : // Trasformatio du texte e liste de ombres. texte:="ceciestquuexemple"; listeombres:=[]; bcar:=legth(texte); pour k de 0 jusque bcar-1 faire listeombres[k]:=ord(texte[k])-97; afficher(listeombres); // Codage par bloc avec la clef publique saisir(u); saisir(); saisir(j); ombreblocs:=itdiv(legth(listeombres),j)+1; k:=0; listecode:=[]; tatque (k<ombreblocs) faire ombre:=0; l:=0; tatque (l<j) et (j*k+l<bcar) faire ombre:=ombre*100+listeombres[j*k+l]; l:=l+1; ftatque; ombrecode:=irem(ombre^u,); listecode[k]:=ombrecode; k:=k+1; ftatque; afficher(listecode); Exemple : O pourra essayer la procédure de codage avec = et u = aisi que des blocs de j = 5. O obtiet la liste [ , , , ] qu'il est iutile de trasformer sous forme de caractères. Remarque : Das l'exemple précédet, XCas trouve la factorisatio de e p q avec p = et q = istataémet avec la commade idivis() mais e pratique o pred des valeurs de bie plus grades (de l'ordre de quelques cetaies de chires...). http: // mathsfg. et. free. fr 14

15 7.3 Décodage Décodage e utilisat l'algorithme RSA : saisir(m); saisir(); saisir(listecode); ombreblocs:=ops(listecode); textedecode:=""; afficher(ombreblocs); pour t de 0 jusque ombreblocs-1 faire ombredecode:=powmod(listecode[t],m,); s:=0; textedecodebloc:=""; taille:=legth(strig(ombredecode)); si irem(taille,2)==0 alors smax:=itdiv(taille,2) sio smax:=itdiv(taille,2)+1;fsi; tatque (s<smax) faire ombrecar:=irem(ombredecode,100); textedecodebloc:=textedecodebloc+char(ombrecar+97); ombredecode:=iquo(ombredecode,100); s:=s+1; ftatque; textedecodebloc2:=""; pour y de 1 jusque legth(textedecodebloc) faire textedecodebloc2:=textedecodebloc2+textedecodebloc[legth(textedecodebloc)-y]; textedecode:=textedecode+textedecodebloc2; afficher(textedecode); Exemple : O pourra décoder la liste de codes obteue ci-dessus e utilisat la clef privée doée par = et m = correspodate à la clef publique utilisée das l'exemple précédet. http: // mathsfg. et. free. fr 15