Cryptage - Centrale Nantes

ECOLE CENTRALE DE NANTES
PROJET DE VEILLE
TECHNOLOGIQUE
Panorama des algorithmes de cryptage
d’information
Henri DER SARKISSIAN, Pierre BELLOUARD
Sommaire
Introduction _______________________________________________________________ 3
Cadre de l’étude ________________________________________________________________ 3
Cryptographie symétrique ____________________________________________________ 4
L’AES _________________________________________________________________________ 5
Algorithme de hachage SHA-1 _____________________________________________________ 8
IDEA (International Data Encryption Algorithm) ______________________________________ 10
L’algorithme Blowfish ___________________________________________________________ 12
L’algorithme Serpent ___________________________________________________________ 14
L’algorithme RC6 _______________________________________________________________ 16
Comparaison de différents algorithmes ____________________________________________ 18
Cryptographie asymétrique __________________________________________________ 19
RSA _________________________________________________________________________ 20
Algorithme d’ElGamal___________________________________________________________ 21
La signature DSA _______________________________________________________________ 22
ECIES ________________________________________________________________________ 24
La cryptographie hybride ____________________________________________________ 25
Conclusion ________________________________________________________________ 26
Bibliographie ______________________________________________________________ 27
Introduction
La cryptologie est une discipline mathématique qui comprend deux champs d’étude:
- la cryptographie : Conception de mécanismes cryptologiques destiné à garantir la sécurité à
des fins de confidentialité, d’authenticité et d’intégrité de l’information
- la cryptanalyse : Le déchiffrement de messages cryptés
La cryptographie est utilisée depuis l’antiquité, mais depuis l’apparition des ordinateurs, cette
discipline a pris une ampleur sans précédente. Ses domaines d’utilisation sont très vastes et vont du
domaine militaire au domaine commercial, en passant par l’utilisation privée.
Cadre de l’étude
Les technologies cryptographiques étant en constante évolution, nous ne nous intéresserons qu’aux
algorithmes les plus récents dans ce projet de veille technologique, c’est-à-dire qui datent de 20 ans
environ, ou du moins qui sont largement utilisés encore récemment.
De plus, nous nous intéresserons aux algorithmes de cryptage d’information au sens large, c’est-àdire de utilisés pour la confidentialité ou pour l’authentification d’information (signatures
numériques).
On distingue ainsi deux grandes classes d’algorithmes : la cryptographie symétrique ou à clé secrète
et la cryptographie asymétrique aussi appelée à clé publique.
Cryptographie symétrique
La cryptographie symétrique est la plus ancienne forme de cryptographie. Elle est basée sur
l’utilisation d’une clé unique qui sert à chiffrer et à déchiffrer le message. L’émetteur et le
destinataire ont alors le même niveau d’information.
L’AES
L’AES (Advanced Encryption Standard), est un algorithme de chiffrement symétrique établi par deux
chercheurs belges entre 1998 et 2000 sous le nom de code Rijndael. Cet algorithme a été choisi suite
à un concours international organisé par la NIST (National Institute of Standards and Technology),
une agence américaine, afin de désigner le successeur de l’algorithme DES qui commençait à montrer
ses limites.
Principe de l’algorithme
On prend en entrée le fichier à chiffrer et une clé générée aléatoirement avec une taille de 128,192
ou 256 bits.
Le fichier d’entrée est segmenté en paquets de 16 octets qui remplissent chacun une matrice 4x4
qu’on appelle Store.
L’étape suivante consiste à créer des sous-clés de la clé principale afin de faire des opérations sur
chacune d’entre elles et sur la matrice Store.
Dans des méthodes de chiffrement simples, ces sous-clés peuvent être des parties contigües de la clé
principale, mais pour l’AES, la détermination de ces sous-clés est beaucoup plus complexe.
Une fois les sous-clés calculées, il reste 10 étapes à effectuer (pour une clé de 128 bits) :
Etape 1 : On effectue un ou-exclusif entre la matrice Store et la première sous-clé rangée elle aussi
dans une matrice.
Etapes 2 à 8 : On effectue :
- Une transformation SubBytes (décrite ci-dessous) appliquée cette fois aux éléments de la
matrice Store
- Une transformation ShiftRows qui consiste à permuter circulairement les lignes de Store un
certain nombre de fois en fonction du numéro de la ligne.
- Une transformation MixColumns où chaque colonne de Store est multipliée par la matrice :
La multiplication est définie de la manière suivante : par 1 l’octet reste inchangé, par 2 on décale
l’octet vers la gauche, et par 3 on décale l’octet vers la gauche et on effectue un ou-exclusif avec
l’octet qui a été multiplié par 1
- Puis on refait l’étape 1.
Etape 10 : On effectue :
- La transformation SubBytes
- La transformation ShiftRows
- L’étape 1
On obtient à la fin une matrice Store chiffrée. Il ne reste qu’à réitérer les opérations sur tous les
octets restant du fichier d’entrée.
Exemple de détermination des sous-clés
Voici l’exemple d’une implémentation en C de la détermination des sous-clés (pour une clé principale
de 128 bits) :
KeyExpansion(byte Key[4*Nk] word W[Nb*(Nr+1)]) {
for(i = 0; i < Nk; i++)
W[i] = (Key[4*i],Key[4*i+1],Key[4*i+2],Key[4*i+3]);
for(i = Nk; i < Nb * (Nr + 1); i++) {
temp = W[i - 1];
if (i % Nk == 0)
temp = SubByte(RotByte(temp)) ^ Rcon[i / Nk];
W[i] = W[i - Nk] ^ temp;
}
}
݈‫݈ܿ ݈ܽ ݁݀ ݎݑ݁ݑ݃݊݋‬é
=4
32
݈‫݀ ݐ݁ݑݍܽ݌ ݑ݀ ݎݑ݁ݑ݃݊݋‬′݁݊‫ݎݐ‬é݁
ܰ௕ =
=4
32
ܰ௥ = 10
ܰ௞ =
La fonction KeyExpansion prend en paramètre la clé principale Key qui est rangée par octet (soit 16
cases pour une clé de 128 bits), et le tableau W.
W représente des parties contigües des sous-clés:
Les 4 premiers octets de la clé sont rangés tel quel dans W.
Pour les suivants, on utilise les fonctions RotByte, SubByte et Rcon.
RotByte effectue une permutation circulaire sur chaque octet qui compose W. Par exemple, si W est
composé de 4 octets a,b,c,d rangés dans cet ordre, on obtiendra en sortie (b,c,d,a).
SubByte est une transformation affine définie de la manière suivante :
Pour chaque octet, on prend son inverse dans le corps fini GF(28) qu’on met dans un vecteur de 8 bits
[x0, …, x7].
Puis on applique la transformation suivante :
Rcon est un tableau de 255 cases définie par :
‫݊݋ܿݎ‬ሺ݅ሻ = ‫ ݔ‬ሺଶହସା௜ሻ ݉‫ ଼ ݔ ݀݋‬+ ‫ ݔ‬ସ + ‫ ݔ‬ଷ + ‫ ݔ‬+ 1 en héxadécimal
Soit ‫݊݋ܿݎ‬ሺ255ሻ = {8d, 01, 02, 04, 08, … . . , 3a, 74, e8, cb}
Algorithme de hachage SHA-1
Le chiffrement par hachage sert à former des condensats de fichier afin entre autre d’identifier
l’auteur du fichier. Pour chaque fichier en entrée, il existe un condensat unique en sortie sauf bien
évidemment dans le cas où on arrive à trouver une collision. Ce condensat a une taille unique.
Dans le cas de SHA-1 (Secure Hash Algorithm), cette taille est de 160 bits. Mais celle-ci peut aller
jusqu’à 512 bits, ce qui offre un nombre déjà très important de condensats.
Principe de calcul des condensats
Initialisation
Le fichier d’entrée est d’abord adapté de manière à ce que sa taille soit un multiple de 512 bits. Pour
cela, on rajoute un bit 1 à la fin du fichier puis un certain nombre de bits 0 tel qu’on puisse insérer le
nombre 1 en binaire dans les 64 derniers bits.
Typiquement, on cherche la solution à l’équation :
‫ ܮ‬+ 1 + ݇ = 448 ݉‫ ݋݈ݑ݀݋‬512, k étant le nombre de zéro à rajouter et L la taille initiale du fichier.
,
Ensuite, on effectue la division par blocs de 512 bits qu’on stocke sur : M(1) M(2), …, M(N).
On va diviser ensuite chacun de ces « mots » en 16 sous-mots de 32 bits qu’on va stocker dans :
M0(i),M1(i) ,M2(i), M3(i) , M4(i) pour le ième mot.
On initialise ensuite les 5 variables suivantes en hexadécimal:
‫ܪ‬଴ ሺ଴ሻ ← 67452301
‫ܪ‬ଵ ሺ଴ሻ ← EDCDAB89
‫ܪ‬ଶ ሺ଴ሻ ← 98BADCFE
‫ܪ‬ଷ ሺ଴ሻ ← 10325476
‫ܪ‬ସ ሺ଴ሻ ← 3D2E1F0
On va utiliser aussi les variables locales suivantes :
- un tableau de 80 mots, qu’on note W0, W1, …, W79
- 5 variables a,b,c,d,e
- 5 variables contenant les valeurs de hachage, notées H0(i), H1(i), H2(i) ,H3(i),H4(i)
- une variable T de 32 bits.
Algorithme
Pour i=1 à N {
On remplit le tableau Wt tel que
Pour t entre 0 et 15 : Wt ←Mt(i)
Pour t entre 16 et 79 : Wt ←ROT L1 (Wt-3 xor Wt-8 xor Wt-14 xor Wt-16 )
1
//avec ROT L la rotation d’un bit vers la gauche, et xor : ou exclusif
On fait ensuite:
a ←H0(i-1)
b ←H1(i-1)
c ←H2(i-1)
d ←H3(i-1)
e ←H4(i-1)
Pour t=0 à 79 {
T ←ROTL5(a) + ft(b,c,d) + e + Kt + Wt
5
// avec ROTL la rotation de 5 bits vers la gauche
// f définit de la manière suivante
// pour t entre 0 et 19 : ft (x,y,z) = (x & y) xor ( -x & z)
// pour t entre 20 et 39 : ft (x,y,z) = x xor y xor z
// pour t entre 40 et 59 : ft (x,y,z) = (x & y) xor ( x & z) xor ( y & z)
// pour t entre 60 et 79 : ft (x,y,z) = xor y xor z
e ←d
d ←c
c ←ROTL30(b)
b ←a
a ←T
}
H0(i) ←a + H0i-1)
H1(i) ←b + H1i-1)
H2(i) ←c + H2i-1)
H3(i) ←d + H3i-1)
H4(i) ←e + H4i-1)
}
On concatène ensuite les valeurs: H0(N), H1(N), H2(N), H3(N), H4(N) pour obtenir le condensat final.
IDEA (International Data Encryption Algorithm)
C’est aussi un algorithme de chiffrement symétrique par bloc tout comme l’AES. Il a été développé en
1991 par Xuejia Lai et James Massey. Il se base sur des blocs de 64 bits en entrée avec une clé de 128
bits.
Notations
On se place dans des groupes algébriques de 216 éléments. On a les opérateurs suivants :
- xor : il s’agit du où exclusif
- + : il s’agit de l’addition modulo 216
- & : il s’agit de l’opérateur AND suivi de 0xFFFF en hexadécimal
- *: il s’agit de la multiplication modulo 216 +1
Algorithme
Tout d’abord, on calcule les sous-clés de 16 bits de la clé principale (128 bits) qui vont servir à
l’implémentation.
Il y aura 9 étapes dans le chiffrement. Pour chacune des 8 premières, on aura besoin de 6 sous-clés.
Pour la dernière, seules 4 sous-clés sont nécessaires.
Les sous-clés sont calculées de la manière suivante :
1. Les 8 premières sont extraites directement de la clé principale. On segmente tout
simplement en 8 cette dernière, chacun des morceaux étant une des 8 sous-clés.
2. Les 8 sous-clés suivantes sont obtenues en faisant une rotation de 25 bits de la clé principale
vers la gauche puis en segmentant la clé résultante en 8 comme en 1. .
3. On répète l’opération 2. jusqu’à ce qu’on ait pu définir entièrement les 52 sous-clés.
Ces sous clés sont rangés en une suite : K1(r), K2(r), K3(r), K4(r), K5(r), K6(r) avec r variant de 1 à 8
symbolisant les 6 sous-clés nécessaires pour chacune des 8 premières étapes. Puis K1(9), K2(9), K3(9), K4(9)
pour les sous-clés de la dernière étape.
Ensuite, on prend en entrée un fichier qu’on divise en blocs de 64 bits qu’on range dans 4 variables
de 16 bits chacune : X1, X2, X3, X4 .
On effectue ensuite les opérations suivantes :
Début
Pour r=1 à 8 {
X1 ← X1* K1(r)
X2 ← X2 & K2(r)
X3 ← X3 & K3(r)
X4 ←X4* K4(r)
t0 ←K5(r) * (X1 xor X3)
t1 ←K6(r) * (t0 & (X2 xor X4))
t2 ←t0 & t1
X1 ←X1 xor t1
X4 ←X4 xor t2
a ←X2 xor t2
X2 ← X3 xor t1
X3 ← a
}
Y1 ← X1*K1(9)
Y2 ← X3 & K2(9)
Y3 ← X2 & K3(9)
Y4 ← X4 * K4(9)
Fin
On obtient en sortie les 4 mots de 16 bits : Y1, Y2, Y3, Y4 chiffrés.
L’algorithme Blowfish
C’est un algorithme de chiffrement par bloc qui prend en entrée des blocs de 64 bits et une clé dont
la taille peut varier de 32 à 448 bits.
Génération des sous-clés de la clé principale
Ces sous-clés vont ensuite servir pour le chiffrement.
On définit donc un tableau P de 18 cases et 4 tableaux appelé S-box qui disposent de 256 cases
chacun.
1. On initialise le tableau P et les 4 tableaux S avec les valeurs décimales de Pi en hexadécimal.
Par exemple :
P1 ← 0x243f6a88
P2 ← 0x85a308d3
P3 ← 0x13198a2e
P4 ← 0x03707344
…..
2. On effectue ensuite un xor entre P1 et les 32 premiers bits de la clé principale, un xor entre P2
et les 32 bits suivants, et ainsi de suite pour tous les bits de la clé.
3. On utilise ensuite l’algorithme principale de Blowfish avec une suite de zéros comme entrée
de fichier et chacune des sous-clés P1, …, P14.
4. On affecte à P1 les 32 premiers bits du résultat du chiffrement, et à P2 les 32 suivants.
5. On chiffre de nouveau avec en entrée le résultat de 3. et les sous-clés modifiées P1, …, P14.
6. On affecte à P3 les 32 premiers bits du résultat et à P4 les 32 suivants.
7. On continue ainsi jusqu’à remplacer toutes les sous-clés P et toutes les entrées de S
Chiffrement principal
Soit x une fraction du fichier d’entré, de taille 64 bits.
Début de l’algorithme
On sépare x en deux parties égales de 32 bits : xL et xR
Pour i←1 à 16 {
xL ← xL xor Pi
xR ← F(xL) xor xR
on échange xL et xR
// la fonction F divise xL en 4 blocs de 8 bits : a,b,c,d et fait :
32
32
// F(xL) = ((S1,a + S2,b mod 2 ) xor S3,c) + S4,d mod 2
}
on échange de nouveau xL et xR
xR ← xR xor P17
xL ← xL xor P18
on rassemble xL et xR
}
Fin de l’algorithme
Pour le déchiffrement, on agit comme pour le chiffrement sauf que P1,…, P18 sont utilisés dans l’ordre
inverse.
L’algorithme Serpent
C’est un algorithme qui a aussi été présenté lors du concours de l’AES en 1998 mais qui
malheureusement a fini deuxième de la compétition derrière Rijndael.
Calcul des sous-clés de la clé principale
La première étape consiste à calculer les sous-clés de la clé principale. Celle-ci peut être de 128, 192
ou 256 bits.
Si la clé est inférieure à 256 bits (128 bits par exemple), on étend celle-ci en rajoutant un bit 1 à la fin
et autant de bits 0 qu’il faut. On va ensuite en tirer 33 clés de 128 bits de la manière suivante.
On répartit la clé de 256 bits dans 8 sous-clés de 32 bits : w-s, …, w-1 puis on effectue la récurrence
suivante afin d’obtenir 132 sous-clés :
wi ← (wi-8 xor wi-5 xor wi-3 xor wi-1 xor ϕ xor i ) <<< 11
<<< signifie rotation à gauche
ϕ est la partie décimale du nombre d’or (5^(1/2) + 1)/2
Ensuite on utilise les tables de substitution (S-box) sur les wi :
{k0,k1, k2, k3} ← S3(w0,w1,w2,w3)
{k4,k5, k6, k7} ← S2(w4,w5,w6,w7)
{k8,k9, k10, k11} ← S1(w8,w9,w10,w11)
{k12,k13, k14, k15} ← S0(w12,w13,w14,w15)
{k16,k17, k18, k19} ← S7(w16,w17,w18,w19)
…
{k124,k125, k126, k127} ← S4(w124,w125,w26,w127)
{k128,k129, k130, k131} ← S3(w128,w129,w130,w131)
Puis on stocke ces sous-clés de 32 bits dans 33 sous-clés Ki de 128 bits :
Ki ← { k4i, k4i+1, k4i+2, k4i+3}
On effectue ensuite une « permutation » sur les Ki grâce à la transformation suivante :
0 32 64 96 1 33 65 97 2 34 66 98 3 35 67 99
4 36 68 100 5 37 69 101 6 38 70 102 7 39 71 103
8 40 72 104 9 41 73 105 10 42 74 106 11 43 75 107
12 44 76 108 13 45 77 109 14 46 78 110 15 47 79 111
16 48 80 112 17 49 81 113 18 50 82 114 19 51 83 115
20 52 84 116 21 53 85 117 22 54 86 118 23 55 87 119
24 56 88 120 25 57 89 121 26 58 90 122 27 59 91 123
28 60 92 124 29 61 93 125 30 62 94 126 31 63 95 127
Ici, par exemple, la valeur 32 en position 1 signifie qu’on affecte à position 1 le bit situé en position
32.
On obtient donc les sous-clés Kpi
Chiffrement
Pour commencer le chiffrement, on applique la permutation précédente au bloc de 128 bits qui
constitue l’entrée. On obtient donc un bloc B0.
Puis on effectue les opérations suivantes :
Pour i de 0 à 30 :Bi+1 ← L(Si(Bi xor Kpi))
où
L est une transformation linéaire qu’on peut représenter de la manière suivante :
{X0;X1;X2;X3} = Si(Bi xor Kpi)
X0 ←X0 <<< 13
X2 ←X2 <<< 3
X1 ←X1 xor X0 xor X2
X3 ←X3 xor X2 xor (X0 << 3)
X1 ←X1 <<< 1
X3 ←X3 <<< 7
X0 ←X0 xor X1 xor X3
X2 ←X2 xor X3 xor (X1 << 7)
X0 ←X0 <<< 5
X2 ←X2 <<< 22
Bi+1 ←{X0;X1;X2;X3 }
// avec << un décalage de n bits vers la gauche
// et <<< une rotation de n bits vers la gauche
Pour i = 31 : Bi+1 ← Si (Bi xor Kpi ) xor Kp32
On applique au final une permutation à B32 pour obtenir le résultat final.
La permutation est la suivante :
0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60
64 68 72 76 80 84 88 92 96 100 104 108 112 116 120 124
1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61
65 69 73 77 81 85 89 93 97 101 105 109 113 117 121 125
2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62
66 70 74 78 82 86 90 94 98 102 106 110 114 118 122 126
3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63
67 71 75 79 83 87 91 95 99 103 107 111 115 119 123 127
Les tables de substitution utilisées sont les suivantes :
S0: 3 8 15 1 10 6 5 11 14 13 4 2 7 0 9 12
S1: 15 12 2 7 9 0 5 10 1 11 14 8 6 13 3 4
S2: 8 6 7 9 3 12 10 15 13 1 14 4 0 11 5 2
S3: 0 15 11 8 12 9 6 3 13 1 2 4 10 7 5 14
S4: 1 15 8 3 12 0 11 6 2 5 4 10 9 14 7 13
S5: 15 5 2 11 4 10 9 12 0 3 14 8 13 6 7 1
S6: 7 2 12 5 8 4 6 11 14 9 1 15 13 3 10 0
S7: 1 13 15 0 14 8 2 11 7 4 12 10 9 3 5 6
L’algorithme RC6
C’est un autre candidat à l’AES en 1998, qui est arrivé en seconde position après l’algorithme
Rijndael. C’est un algorithme dérivé de RC5 (crée en 1995), simple et performant à la fois.
Calcul des sous-clés
L’expansion de la clé principale (algorithme issu de RC5 ) du RC6 étant quasiment similaire.
On définit d’abord deux constants binaires Pw et Qw qui représentent les parties décimales de deux
nombres : e (2.7182….) et le nombre d’or (1.61803….) sur w bits (w=16, 32 ou 64 bits) . Par exemple
P16= 1011011111100001 = B7E1
Q16=1001111000110111 = 9E37
P32= B7E15163
Q32=9E3779B9
Ensuite, on divise la clé principale K en plusieurs sous-clés Li de même longueur.
On définit ensuite des tableaux S qu’on remplit de la façon suivante :
S[0]=Pw
Pour i de 1 à t-1
//t=2*(r+1) où r est le nombre de tours choisi pour chiffre les données
// Plus r est grand, plus solide sera le chiffrement
S[i] ←S[i-1] + Qw
Fin Pour
Puis on effectue l’algorithme suivant à partir de deux mots A et B de w bits chacun :
i←0
j←0
A←0
B←0
Faire 3*max(t,c) fois /*où c = 8*b/w avec b le nombre de bits de la clé principale) */
S[i] ← S[i] + A + B <<< 3
// <<< étant une rotation vers la gauche
A ← S[i]
L[j] ← (L[j]+A+B) <<< (A+B)
i ← i+1 mod(t)
j ← j+1 mod(e)
Fin faire
Chiffrement
On a comme paramètres d’entrée :
b le nombre de bits de la clé principale
w le nombre de bits des sous-clés (16, 32 ou 64 bits)
r le nombre de tours choisis pour le chiffrement
A, B, C, D les données d’entrées sur w bits chacune
En sortie, on aura A, B, C et D.
Début
B←B+S[0]
D←D+S[1]
Pour i de 1 à r faire
t ← (B*(2B+1)) <<< lg w
u ← (D * (2D +1)) <<< lg w
A ← ((A xor t) <<< u) + S[2i]
C ← ((C xor u) <<< t ) + S[2i+1]
(A,B,C,D) ← (B,C,D,A)
Fin Pour
A ← A+S[2r+2]
C ← C+S[2r+3]
Fin
L’opérateur * désigne la multiplication modulo 2w
L’opérateur + désigne l’addition modulo 2w
<<< n : la rotation à gauche de n bits
Déchiffrement
En entrée :
- A, B, C, D chiffrés
- le nombre r de tours utilisé pour le chiffrement
- w
En sortie :
- A, B, C, D déchiffré
Début
C ← C – S[2r+3]
A ←A - S[2r+2
Pour u de r à 1 faire
(A,B,C,D) ← (D,A,B,C)
u ← (D * (2D+1)) << lg w
t ← ((B * (2B+1)) << lg w
C ← ((C – S[2i+1]) >> t ) xor u
A ← (( A – S[2i]) >> u ) xor t
Fin pour
D ←D-S[1]
B ←B – S[0]
Fin
L’opérateur – désigne la soustraction modulo 2w.
>>> n : la rotation à droite de n bits
Comparaison de différents algorithmes
Ci-dessous se trouve la comparaison des 15 algorithmes candidats à l’AES entre 1998 et 2000.
Les performances des 15 algorithmes ont été comparées en temps sur un Pentium Pro 200Mhz.
A chaque algorithme, on a mesuré en nombre de cycle processeur le temps de chiffrement, de
déchiffrement et de calcul des sous-clés, pour plusieurs taille de clé principales (128, 192, et 256
bits).
Pour les algorithmes Rijndael, CRYPTON et CRYPTON v1, les deux valeurs dans le calcul des clés
représentent le chiffrement et le déchiffrement.
Les trois dernières lignes représentent les différentes vitesses de l’algorithme calculées en Mbits/s.
Sur le tableau, on voit que les algorithmes Rijndael, MARS et Twofish se suivent et ont à peu près les
même performances.
D’une manière générale, l’algorithme le plus performant est RC6, suivi par Rijndael. Or c’est ce
dernier qui a gagné le concours et est devenu l’AES. Une des raisons de l’échec de RC6 sont ses
faibles performances sur les processeurs 8-bits et 64 bits comparés aux autres finalistes du concours.
Cryptographie asymétrique
Un des problèmes majeurs qui résident en la cryptographie symétrique est l’échange de clés. En effet
il est nécessaire de donner la clé au destinataire afin qu’il puisse décrypter le message. Cet échange
de clé se fait à priori en clair si on n’utilise que des systèmes symétriques.
La cryptographie asymétrique ou à clé publique répond à ce problème. Elle repose sur l’utilisation de
deux clés :
- Une clé publique qui est diffusée
- Une clé privée gardée secrète
Ainsi, l’expéditeur peut utiliser la clé publique du destinataire pour crypter le message alors que seul
le destinataire peut le déchiffrer à l’aide de sa clé secrète. Ce mécanisme garantit la confidentialité
de l’information.
A l’inverse, l’expéditeur peut utiliser sa propre clé privée pour crypter l’information souhaitée alors
que le destinataire peut la décrypter à l’aide de la clé publique de l’expéditeur. Ce mécanisme
permet d’authentifier l’auteur du message, c’est la signature numérique.
La cryptographie asymétrique a été inventée par Diffie et Hellman.
RSA
RSA est un algorithme de cryptage asymétrique. Il a été inventé par Rivest, Shamir et Adleman en
1978. C’est l’exemple le plus courant en cryptographie asymétrique. Même s’il a été inventé il y a
plus de 30 ans, il reste toujours considéré comme sûr pour des clés suffisamment grosses et est
largement utilisé aujourd’hui dans le cadre de transactions sécurisées sur internet, paiement par
carte bleue, etc.
Description de l’algorithme
RSA utilise l'arithmétique de ℤ௡ où n est le produit de deux nombres premiers distincts p et q.
Alice est la destinataire et Bob l’émetteur.
1.
2.
3.
4.
5.
Alice génère grands nombres premiers (une centaine de chiffre en pratique) ‫ ݌‬et ‫ݍ‬, ainsi qu’un grand
nombre d premier avec le produit ‫ = ݓ‬ሺ‫ ݌‬− 1ሻ ∗ ሺ‫ ݍ‬− 1ሻ.
Alice calcule ݊ = ‫ ݍ݌‬et e tel que ݀ ∗ ݁ = 1 ݉‫ݓ ݀݋‬.
Alice diffuse ݊ et ݁, garde ݀ et détruit ‫ݓ‬. ሺ݊, ݁ሻ est donc la clé publique et ሺ‫݌‬, ‫ݍ‬, ݀ሻ la clé privée.
Pour crypter un message, Bob utilise ݁ et ݊ : ainsi le message ‫ ܯ‬est crypté par ‫ܯ‬௘ ݉‫ ݀݋‬n et l’envoie à
Alice
Alice décode le message crypté parl’opération ‫ܯ‬ௗ ݉‫݊ ݀݋‬.
Quelques précisions
L’algorithme repose, entre autres, sur les deux résultats arithmétiques suivants :
∀ ‫݌‬, ‫ݏݎ݁݅݉݁ݎ݌ ݍ‬,
߶ሺ‫ݍ݌‬ሻ = ሺ‫ ݌‬− 1ሻ ∗ ሺ‫ ݍ‬− 1ሻ
ሺ1ሻ
Et
ܵ݅ ‫ݔݑ݁ ݁ݎݐ݊݁ ݏݎ݁݅݉݁ݎ݌ ݐ݊݋ݏ ݊ ݐ݁ ݔ‬, ݈ܽ‫ ݔ ݏݎ݋‬థሺ௡ሻ ≡ 1 ݉‫݊ ݀݋‬
ሺ2ሻ
Ces résultats ne seront par démontrés.
Premièrement, vérifions que les opérations sont réciproques :
Comme ݀ ∗ ݁ = 1 ݉‫߶ ݀݋‬ሺ݊ሻ, ݀ ∗ ݁ = ‫߶ ∗ ݐ‬ሺ݊ሻ + 1.
Soit ‫ ∈ ܯ‬ℤ௡ , ‫݊ ܿ݁ݒܽ ݎ݁݅݉݁ݎ݌ ܯ‬, ‫ ܽ ݊݋‬ሺ‫ܯ‬௘ ሻௗ = ‫ ݔ‬௧∗థሺ௡ሻାଵ = ‫ ݊ ݀݋݉ ܯ‬d’après le résultat (2). On peut montrer
que ce résultat reste vrai même dans le cas où ‫ ܯ‬n’est pas premier avec ݊.
L’opération d’encryptage et décryptage sont donc réciproques.
Exemple pratique
Prenons ‫ = ݌‬101, ‫ = ݍ‬113, ݊ = ‫ = ݍ݌‬11413 ݁‫߶ ݐ‬ሺ݊ሻ = 11200.
11200 = 2଺ 5ଶ 7. ݁ peut être utilisé pour le chiffrement si et seulement si il n’est pas divisible par 2, 5 ou 7.
On prend ܾ = 3533, ݀‫ି ܾ ܿ݊݋‬ଵ = 6597. Donc l’exposant secret ݀ est 6597.
On publie ݊ = 11413 ݁‫ = ܾ ݐ‬3533. On garde ݁ et ‫݌‬, ‫ ݍ‬secrets.
Sécurité :
Attaquer RSA, c’est factoriser ݊. Pour que le système soit sûr il est donc nécessaire que ݊ = ‫ ݍ݌‬soit
suffisamment grand pour que sa factorisation soit calculatoirement impossible.
On considère que des clés de 768 bits sont sûrs pour un usage privé et 2048 bits voire 4096 pour un usage
sensible. Si on admet que la puissance des ordinateurs double tous les 18 mois (loi de Moore), une clé de 2048
bits devrait tenir jusque l’an 2079.
Cependant, il a été récemment infirmé que « casser » RSA est aussi difficile que factoriser ݊. On peut alors
imaginer d’autres moyens plus rapides pour casser la sécurité RSA.
Algorithme d’ElGamal
Le logarithme discret ?
Soit ሺ‫ܩ‬,∙ሻ un groupe multiplicatif, ߙ ∈ ‫ ܩ‬d’ordre ݊. Le problème du logarithme discret est de trouver pour
ߚ ∈< ߙ > l’unique exposant ܽ, 0 ≤ ܽ < ݊ tel que ߙ ௔ = ߚ.
L’utilité du logarithme discret vient du fait qu’il est difficile de le déterminer alors que l’opération inverse
d’exponentiation peut être effectuée facilement.
L’algorithme d’ElGamal
Cet algorithme repose sur l’utilisation du logarithme discret. Il a été publié par Tahar ElGamal en 1984. Cet
algorithme est utilisé par le logiciel libre GNU Privacy Guard, PGP, et d’autres systèmes de chiffrement. Aucun
brevet n’a été déposé, contrairement à RSA. Il peut être utilisé aussi bien pour le chiffrement que pour la
signature électronique.
Soit Alice l’émetteur d’un message et Bob le destinataire.
Bob possède deux clés :
Une clé privée : un entier ‫ݏ‬
Une clé publique : un grand nombre premier ‫ ݌‬tel que trouver le logarithme discret dans le groupe
cyclique ൫ℤ௣ ,∙൯ est difficile, un nombre ߙ premier avec ‫ ݌‬et ܲ = ߙ ௦ ݉‫݌ ݀݋‬
Chiffrement
1. Alice tire aléatoirement un nombre ݇.
2. Elle calcule ‫ܥ‬ଵ = ܽ௞ ݉‫ ݌ ݀݋‬et ‫ܥ‬ଶ = ‫ܲܯ‬௞ ݉‫݌ ݀݋‬
Le message chiffré est alors le couple ሺ‫ܥ‬ଵ , ‫ܥ‬ଶ ሻ.
Déchiffrement
1. A la réception du couple ሺ‫ܥ‬ଵ , ‫ܥ‬ଶ ሻ, Bob doit calculer ܴଵ = ‫ܥ‬ଵ௦ ݉‫݌ ݀݋‬
ܴଵ = ‫ܥ‬ଵ௦ ݉‫ = ݌ ݀݋‬ሺߙ ௞ ሻ௦ ݉‫ܲ = ݌ ݀݋‬௞ ݉‫݌ ݀݋‬
஼
2. Il lui reste à calculer la quantité ோమ =
భ
ெ௉ೖ
௉ೖ
=‫ܯ‬
Sécurité
Un attaquant éventuel doit pouvoir calculer ܲ௞ pour en déduire ‫ ܯ‬en connaissant ܲ, ܽ et ܽ௞ . Il doit
donc découvrir ݇, et est confronté au problème du logarithme discret.
Cet algorithme fonctionne également sur d’autres groupes cycliques où le problème du logarithme
discret est difficile.
L’introduction d’aléa (paramètre ݇) apporte une sécurité supplémentaire : deux messages identiques
ne seront pas codés de la même façon.
En revanche, cet algorithme a le défaut de générer un message crypté
La signature DSA
Le Digital Signature Algorithm est un algorithme de signature numérique standardisé par le NIST aux
Etats-Unis. Il fait partie de la spécification Digital Signature Standard (DSS) adoptée en 1993 mais ce
n’est plus le message lui-même qui est signé par une fonction de hachage mais l’empreinte du
message.
Le DSA est similaire à un autre type de signature développée par Claus Schnorr en 1989. Il a aussi des
points communs avec la signature ElGamal. Le processus se fait en trois étapes :
- génération des clés
- signature du document
- vérification du document signé
Génération des clés
La clé publique est composée de 4 nombres (p,q,g,y) et la clé publique d’un seul nombre x.
Le choix de ces nombres se fait de la manière suivante :
- p est un nombre premier de L-bit avec 512 ≤ ‫ ≤ ܮ‬1024 et L divisible par 64
- q est un nombre premier de 160 bits tel que ‫ ݌‬− 1 = ‫ݖݍ‬
- ݃ = ℎ² ݉‫ ݌ ݀݋‬avec 1 < ℎ < ‫ ݌‬− 1 et ݃ > 1
- ‫ ݃ = ݕ‬௫ ݉‫݌ ݀݋‬
- x est choisit aléatoirement entre 0 et q (non compris)
Signature
La signature est un doublet (s1,s2) généré de la manière suivante :
- on choisit s aléatoirement entre 1 et q (non compris)
- ‫ݏ‬1 = ሺ݃ହ ݉‫݌ ݀݋‬ሻ ݉‫ݍ ݀݋‬
- ‫ݏ‬2 = ሺ‫ܪ‬ሺ݉ሻ + ‫ݏ‬1 × ‫ݔ‬ሻ‫ି ݏ‬ଵ ݉‫ ݍ ݀݋‬avec m le message et H une fonction de hachage
cryptographique connu de tous les utilisateurs comme SHA-1 par exemple
Il faut aussi noter que ‫ݏ‬2 ≠ 0 ݉‫ ݍ ݀݋‬car ‫ݏ‬2ିଵ ݉‫ ݍ ݀݋‬est nécessaire à la validation de la
signature. Si l’émetteur obtient ‫ݏ‬2 = 0 ݉‫ݍ ݀݋‬, il doit rejeter la signature et en créer une
nouvelle avec une nouvelle valeur de k.
Vérification
Le destinataire doit ensuite vérifier la validité de la signature de la manière suivante :
- On commence par vérifier que 0 < ‫ݏ‬1 < ‫ ݍ‬et 0 < ‫ݏ‬2 < ‫ ݍ‬sinon la signature est directement
rejetée
- On calcule ‫ = ݓ‬ሺ‫ݏ‬2ሻିଵ ݉‫ݍ ݀݋‬
‫ݑ‬1 = ‫ܪ‬ሺ݉ሻ × ‫ݍ ݀݋݉ ݓ‬
‫ݑ‬2 = ‫ݏ‬1 × ‫ݍ ݀݋݉ ݓ‬
‫ = ݒ‬ሺ݃௨ଵ × ‫ ݕ‬௨ଶ ݉‫݌ ݀݋‬ሻ݉‫݌ ݀݋‬
- La signature est valide si ‫ݏ = ݒ‬1
L’intérêt de ce principe est que ce n’est plus le message entier qui est signé mais son empreinte
par la fonction de hachage H. La taille de la signature ne dépend donc plus de la taille du
message. L’objet que l’on signe est de taille fixe (environ 160 bits) ce qui permet de réduire la
taille du message signé transmis.
ECIES
L’Elliptic Curve Integrated Encryption Scheme est système de chiffrement variante de El Gamal. Ce
schéma est basé sur le problème de Diffie-Hellman.
Le problème de Diffie-Hellman
Alice et Bob veulent faire un échange de clé. Ils choisissent ensemble une courbe elliptique, une
génératrice g de cette courbe et un nombre premier p. Alice choisit au hasard un nombre a et envoie
à Bob ݃௔ ݉‫݌ ݀݋‬. Bob fait de même avec sa clé privé b, nombre choisi au hasard. Alice élève le
message reçu de Bob à la puissance a, elle obtient ݃௕௔ ݉‫݌ ݀݋‬. Bob fait le calcul analogue et obtient
donc la même chose. Les deux personnes obtiennent ainsi la même clé secrète sans qu’une personne
extérieure (de par la difficulté de calculer le logarithme discret) ne puisse calculer a et b.
Les clés privés sont donc a et b ; la clé public est composé de p et g.
Principe de l’algorithme ECIES
Les paramètres sont E une courbe elliptique et ‫ ܧ ∈ ݌‬d’ordre l avec l premier (c’est-à-dire que p est
premier avec l). On a aussi :
- SYM un algorithme de chiffrement symétrique
- MAC un code authentificateur de message
- KDF une fonction génératrice de clé
Alice envoie un message m à Bob. La clé publique est ݇஻ , la clé privée est ‫ܭ‬஻ = ‫݌‬௞ಳ ݉‫ ݈ ݀݋‬.
Chiffrement
On choisit ݇ ∈ ሾ1; ݈ሿ au hasard.
On calcule : ܴ = ‫݌‬௞ ݉‫ ݈ ݀݋‬et ܼ = ‫ܭ‬஻ ௞ ݉‫݈ ݀݋‬.
݇ଵ ||݇ଶ = ‫ܨܦܭ‬ሺܼ, ܴሻ
‫ܯܻܵ = ܥ‬ሺ݇ଵ , ݉ሻ
‫ܥܣܯ = ݐ‬ሺ݇ଶ , ‫ܥ‬ሻ
Alice envoie R, C et t à Bob.
Déchiffrement
On commence par vérifier que ܴ ∈ ‫ܧ‬.
On calcule ܴ௞ಳ ݉‫݌ = ݈ ݀݋‬௞௞ಳ ݉‫ܭ = ݈ ݀݋‬஻ ௞ ݉‫݈ ݀݋݉ ܼ = ݈ ݀݋‬
On calcule ݇ଵ ||݇ଶ = ‫ܨܦܭ‬ሺܼ, ܴሻ et ‫ ݐ‬ᇱ = ‫ܥܣܯ‬ሺ݇ଶ , ‫ܥ‬ሻ.
Si ‫ ݐ ≠ ݐ‬ᇱ , on rejette le message sinon on retrouve ݉ = ܻܵ‫ିܯ‬ଵ ሺ݇ଵ , ‫ܥ‬ሻ.
La cryptographie hybride
La cryptographie asymétrique est intrinsèquement lente de par les calculs complexes qui y sont
associés alors que la cryptographie symétrique brille par sa rapidité mais est beaucoup moins sure du
fait de l’obligation de la transmission des clés. La cryptographie hybride consiste donc à l’association
de ces deux techniques afin d’améliorer la rapidité tout en ayant une certaine sécurité. Les logiciels
PGP et GnuPG reposent sur ce système.
La plupart des systèmes hybrides procèdent de la manière suivante. On code tout d’abord le
message grâce à un algorithme de chiffrement symétrique utilisant une clé publique dite de session
générée aléatoirement et de taille comprise entre 128 et 512 bits. La clé de session est ensuite
chiffrée avec la clé publique du destinataire selon un algorithme cryptage asymétrique. Comme la clé
est courte, ce chiffrage prend peu de temps, ce qui n’aurait pas été le cas si on avait chiffré
l’ensemble du message à partir d’un algorithme de cryptographie asymétrique. Il suffit alors
d’envoyer l’ensemble composé du message chiffré ainsi que de la clé privée elle-même cryptée avec
une clé publique. L’utilisateur dit donc utiliser sa clé privée pour déchiffrer la clé de session et ensuite
il peut accéder au message grâce à cette dernière.
Conclusion
La cryptographie moderne a fait de nombreux progrès pour répondre aux besoins de confidentialité
et d’authentification croissants : commerce électronique, votes électroniques, défense…
Les algorithmes présentés dans ce document ne sont pas inviolables. Il existe des méthodes de
chiffrement réputées invulnérables (Chiffre de Vernom et cryptographie quantique) mais leur mise
en œuvre est excessivement difficile à mettre en place.
On préfère donc des algorithmes plus simples à mettre en œuvre, avec une taille de clés raisonnable,
qui garantissent une sécurité limitée dans le temps.
Enfin, l’avenir réside certainement en la cryptographie quantique. Cette dernière désigne un
ensemble de protocoles permettant de distribuer une clé de cryptage secrète entre deux
interlocuteurs distants grâce aux lois de la physique quantique et de la théorie de l’information. Ce
type de cryptographie ne peut néanmoins pas être utilisé pour crypter le message lui-même pour
deux raisons. Premièrement, les bits d’informations communiqués ne peuvent être obtenus que
aléatoirement ce qui ne convient pas pour un message. Enfin, même si le mécanisme de la
cryptographie quantique garantit que l’espion sera toujours détecté, rien n’assure que les
informations ne soient pas déjà détenues par ce dernier. Ceci n’est pas acceptable pour un message
mais sans importance pour une clé aléatoire qui doit alors simplement être jetée en cas
d’interception.
Bibliographie
Articles scientifiques
G.N KRISHNAMURTY, V. RAMASWANY, G.H LEELA, M.E ASHALATHA, « Blow-CAST-Fish : A New 64-bit
Block Cipher » dans IJCSNS International Journal of Computer Science and Network 282 Security, Avril
2008, VOL.8 N.4
« Secure Hash Standard » dans Federal Information Processing Standards Publication, 01 Août 2001,
180-2
B. GLADMAN, « Implementation Experience with AES Candidate Algorithms » dans Second AES
Conference
R.L RIVEST, M.J.B ROBSHAW, R. SYDNEY, Y.L YIN, « The RC6 TM Block Cipher », 20 Août 1998
M.J.B ROBSHAW, « RC6 and the AES », 9 Janvier 2001
R. ANDERSON, E. BIHAM, L. KNUDSEN, « A Proposal for the Advanced Encryption Standard »
J. DAEMEN, V. RIJMEN, « AES Proposal: Rijndael », 1998
Sites Internet
http://en.referencio.com/Algorithms_-_Ciphers
http://en.wikipedia.org/wiki/List_of_hash_functions
http://www.world-class-programme.com/IDEA.asp
http://www.schneier.com/paper-blowfish-fse.html
http://en.wikipedia.org/wiki/Rijndael_S-box
http://en.wikipedia.org/wiki/Finite_field_arithmetic
http://en.wikipedia.org/wiki/Key_schedule
http://en.wikipedia.org/wiki/RSA
http://fr.wikipedia.org/wiki/Courbe_elliptique
http://fr.wikipedia.org/wiki/Cryptographie_asymetrique
http://fr.wikipedia.org/wiki/Echange_de_clés_Diffie-Hellman
http://en.wikipedia.org/wiki/Integrated_Encryption_Scheme
http://etudes.univ-rennes1.fr/digitalAssets/27/27372_cours7_protocoles.pdf
http://calamar.univ-ag.fr/uag/ufrsen/coursenligne/vpage/new_site/cours/UEOI222/cours_crypto.pdf
http://www.supinfo-projects.com/fr/2006/la_cryptographie/2/
http://www.math.ens.fr/culturemath/maths/pdf/nombres/RSA.pdf
http://www.bibmath.net/crypto/complements/elgamal.php3
Autres
Cours de l’électif cryptographie enseigné en deuxième année à l’Ecole.