Cours d’arithmétique et cryptologie

Guilhem Castagnos

Janvier – Avril 2023

version du 6 janvier 2023

Table des matières

I Introduction à la cryptographie 1
1 Vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Historique (non exhaustif) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3 Sécurité du chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
4 Quelques Fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
5 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

II Notions de complexité 5
1 Sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Complexité algorithmique élémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Complexité des algorithmes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Exponentiation modulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

III Rappels d’arithmétique 9

1 Arithmétique dans les entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Algorithme d’Euclide étendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3 L’anneau 𝐙/𝑛𝐙 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

IV Le chiffrement RSA et problèmes associés 13

1 RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Factorisation d’entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3 Tests de primalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

V Cryptographie basée sur le problème du logarithme discret 17

1 Le problème du logarithme discret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2 Quelques applications cryptographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3 Algorithmes de calcul de logarithmes discrets . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4 Conséquences cryptographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

VI Chiffrement symétrique par bloc 21

1 Rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2 Principes de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Corps finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4 L’AES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

VII Panorama des développements actuels en cryptographie asymétrique 27

1 Quelques autres applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2 Quelques autres outils mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

– ii –
Chapitre I

Introduction à la cryptographie

1. Vocabulaire
Cryptographie : ensemble de méthodes pour sécuriser l’information et les communications numé-
riques contre des adversaires.
Cryptanalyse : consiste à casser ces méthodes (attaques), alors que la cryptographie consiste à les
concevoir.
Cryptologie = Cryptographie + Cryptanalyse. En pratique, on emploie souvent le terme cryptographie
à la place de cryptologie.
Lorsque l’on transforme l’information de manière à la rendre inintelligible pour un adversaire, on parle
de chiffrer l’information (le procédé est le chiffrement). Le destinataire légitime déchiffre ensuite
(déchiffrement). On dit qu’un adversaire qui réussirait à casser le système de chiffrement décrypte. Les
termes « crypter », « cryptage » ne sont pas corrects.
D’autre part les mots coder et décoder correspondent à une autre problématique : celle de protéger l’in-
formation contre les modifications que pourraient apporter le bruit qui intervient lors de sa transmission.
Les codes correcteurs d’erreurs sont utilisés pour cela, il n’y a pas ici de notion de secret, tout le monde
même un adversaire peut décoder.

2. Historique (non exhaustif)

Chiffrement de César
Un premier exemple classique : Le chiffrement de César consiste à décaler les lettres de 3 rangs dans
l’alphabet. Ainsi « CRYPTO » devient « FUBSWR » (on revient à A si on « dépasse » Z). Si on code les
lettres de l’alphabet par un nombre de 0 à 25 (A par 0, B par 1…), cela correspond à travailler modulo 26,
en utilisant la fonction de chiffrement de 𝐙/26𝐙 dans 𝐙/26𝐙, 𝑚 ↦ 𝑚 + 3.
On généralise ceci en utilisant la fonction de chiffrement de 𝐙/26𝐙 dans 𝐙/26𝐙, 𝑚 ↦ 𝑚 + 𝑘. C’est le
chiffrement par décalage. Le déchiffrement consiste à retrancher 𝑘. Cette quantité 𝑘 est donc un secret
utilisé lors du chiffrement et du déchiffrement, appelé clef secrète. L’entrée du chiffrement 𝑚 est le
message clair, sa sortie 𝑐 = 𝑚 + 𝑘 est le message chiffré.
Un autre généralisation consiste à utiliser pour clef secrète n’importe quelle bijection σ de 𝐙/26𝐙 dans
𝐙/26𝐙 (c’est à dire une permutation de 𝐙/26𝐙) et de chiffrer par 𝑚 ↦ σ(𝑚). On parle de chiffrement par
substitution.
On a maintenant 26! clefs possibles au lieu de 26 clefs pour le chiffrement par décalage. Il est donc plus
difficile pour un adversaire de retrouver la bonne clef en les testant toute. Cependant tous ces systèmes sont
vulnérables à une analyse des fréquences. Dans un texte en français, la lettre apparaissant le plus souvent
est le E. Le caractère apparaissant le plus souvent dans le message chiffré correspondra donc au E.

–1–
 Chapitre I : Introduction à la cryptographie

Chiffrement de Vigenère (16e siècle)

C’est une autre extension du chiffrement par décalage. On travaille maintenant sur plusieurs, disons ℓ
caractères. Pour chiffrer « CRYPTO » on répète autant de fois que nécessaire la clef secrète, disons «CLEF »
et on additionne les deux comme précédemment, ce qui donne « ECCUVZ ».
Plus précisément, on découpe le message clair en blocs de longueur ℓ, et on utilise la fonction de
chiffrement de (𝐙/26𝐙)ℓ dans (𝐙/26𝐙)ℓ qui a 𝑚 = (𝑚0 , 𝑚1 , 𝑚2 , 𝑚3 ) associe (𝑚0 +𝑘0 , 𝑚1 +𝑘1 , 𝑚2 +𝑘2 , 𝑚3 +𝑘3 )
où 𝑘 = (𝑘0 , 𝑘1 , 𝑘2 , 𝑘3 ) est la clef secrète.
Ceci reste cependant sensible à une analyse des fréquences : on retrouve un chiffrement par décalage
en regardant les sous textes correspondant aux indices 0 des blocs, puis ceux correspondant aux indices 1
des blocs…

Principe de Kerckhoffs (fin 19e siècle)

Il peut se formuler par « l’adversaire connaît le système ». C’est à dire que l’on suppose que la description
de la fonction de chiffrement est connue. La seule donnée secrète est la clef 𝑘.

Chiffrement de Vernam (1917)

Aussi appelé masque jetable ou One Time Pad en anglais. Ceci peut être considéré comme un chiffrement
de Vigenère avec une clef secrète à usage unique aussi longue que le message à transmettre. C’est à dire
que si on a un message clair de 𝑘 caractères à chiffrer, on prend au hasard avec équiprobabilité une clef
secrète de 𝑘 caractères, et le chiffré est l’addition du message clair et de la clef.
Ce chiffrement est avant tout théorique, mais a été tout de même utilisé en pratique par exemple pour
le téléphone rouge, une très longue clef secrète étant transmise physiquement via des diplomates.
Ce chiffrement est dit parfait : le message chiffré n’apporte aucune information supplémentaire sur le
message clair. Si on formalise le message clair (resp. le chiffré) comme une variable aléatoire M (resp. C),
cela signifie que Pr[M = 𝑚|C = 𝑐] = Pr[M = 𝑚]. Ceci a été formalisé par Shannon dans les années 1940.

Enigma (deuxième guerre mondiale)

C’est une machine électromécanique utilisée par les allemands pour chiffrer l’information. Elle fut
cassée par une équipe autour de Turing. Le fait d’utiliser une machine permet d’avoir un chiffrement plus
complexe. La clef secrète correspond à une permutation initiale de l’alphabet, qui est utilisée pour chiffrer
le premier caractère, puis cette permutation est mise à jour à chaque chiffrement de caractère.

Chiffrement à clef secrète

Tous ces chiffrements relèvent de ce qu’on appelle maintenant la cryptographie symétrique ou
à clef secrète. La même clef sert pour le chiffrement et le déchiffrement. On distingue deux grandes
catégories de chiffrement symétriques :

• Le chiffrement par blocs. Comme pour le chiffrement de Vigenère, le message clair est découpé
en blocs de ℓ bits. À une clef secrète 𝑘, une chaîne de bits aléatoire d’une certaine longueur, on fait
correspondre une permutation σ𝑘 de {0, 1}ℓ : la description de cette correspondance correspond à la
description de l’algorithme de chiffrement. La fonction de chiffrement est alors 𝑚 ↦ σ𝑘 (𝑚). Tout
l’enjeu est de produire une permutation σ𝑘 la plus « aléatoire » possible tout en gardant une certaine
structure pour avoir un algorithme de longueur succincte (décrire une permutation sans structure
quelconque se fait en donnant la liste de ses images ici 2ℓ × ℓ bits).
Les standards successifs sont le DES pour Data Encryption Standard de 1977 à 2000, qui utilise une
clef 𝑘 de 56 bits et ℓ = 64, maintenant obsolète à cause de sa petite taille de clef ; puis l’AES pour
Advanced Encryption Standard depuis 2000, qui utilise une clef de 128, 192 ou 256 bits et ℓ = 128. Cet
algorithme est massivement utilisé aujourd’hui (4G, 5G, WPA pour le Wifi, TLS/SSL pour le Web).

–2–
3. Sécurité du chiffrement

• Le chiffrement à flot est une version pratique du chiffrement de Vernam. À partir d’une clef se-
crète, une chaîne de bits aléatoire d’une certaine longueur, on crée de manière déterministe une suite
(pseudo-aléatoire) de bits (𝑧𝑘 )𝑘∈𝐍 . Puis on chiffre une suite de bits (𝑚𝑘 )𝑘∈𝐍 par 𝑐𝑘 = 𝑚𝑘 + 𝑧𝑘 mod 2
pour tout 𝑘 ∈ 𝐍. On perd cependant le caractère parfait du chiffrement de Vernam car la suite de
bits est pseudo-aléatoire. Exemple : RC4 (1987), SNOW3G (2002), ChaCha20 (2008)

Tous ces algorithmes de chiffrement à clef secrète sont sensibles à la recherche exhaustive. Connais-
sant un message clair 𝑚 et son chiffré correspondant 𝑐, on calcule le chiffrement de 𝑚 par toutes les clefs
possibles jusqu’à trouver 𝑐. Si la clef secrète fait 𝑛 bits, on doit donc faire 2𝑛 chiffrements dans le cas le pire.
Pour le DES où 𝑛 = 56 ceci se fait maintenant en quelques heures en utilisant un matériel peu onéreux.
Le but du cryptographe symétrique est de concevoir un système dont la meilleure attaque connue soit la
recherche exhaustive.
Le principal problème pratique de ces algorithmes est le suivant : pour communiquer de manière sécuri-
sée, Alice et Bob doivent tous les deux connaître la clef secrète 𝑘 et donc se l’être communiquée de manière
sûre, par exemple en main propre. On parle d’échange de clef. Ceci ne posait pas trop de problème pour
les applications militaires, mais est impensable pour des applications civiles telle que le chiffrement des
communications Web.

Diffie-Hellman (1976)
Ces deux chercheurs conceptualisent la cryptographie asymétrique ou cryptographie à clef pu-
blique qui résout ce problème. Ils proposent aussi un protocole interactif d’échange de clef, qui porte leur
nom. Ce procédé permet à Alice et Bob d’échanger publiquement des informations et à la fin du protocole
de connaître une quantité qui pourra servir comme clef secrète pour faire du chiffrement symétrique : on
souhaite qu’un adversaire Oscar qui écoute la conversation entre Alice et Bob n’ait aucune information sur
cette clef.

Chiffrement à clef publique

Ou chiffrement asymétrique. Bob possède un couple clef publique, clef privée. Cette dernière
est connue de lui seul, alors que sa clef publique est connue de tous. Pour envoyer un message 𝑚 à Bob, Alice
utilise la clef publique de Bob et un algorithme de chiffrement pour obtenir le chiffré 𝑐. Pour retrouver
𝑐, Bob lui appliquera un algorithme de déchiffrement en utilisant sa clef privée. Exemples : RSA (1977),
Elgamal (1985)…
Les algorithmes de chiffrement à clef publique sont beaucoup plus lents que ceux à clef secrète mais ne
nécessitent pas d’échange de clef. Leur sécurité est reliée à un problème algorithmique réputé difficile (la
factorisation d’entiers pour RSA, le problème du logarithme discret pour Elgamal) et non à la recherche
exhaustive de la clef secrète comme en symétrique.

3. Sécurité du chiffrement
Que ce soit en clef secrète ou en clef publique, on définit la sécurité en définissant un adversaire : ses
buts et ses moyens.

Buts de l’adversaire
• Bris total : retrouver la clef secrète ou privée (but le plus fort)

• Casser la notion de sens unique : étant donné un chiffré 𝑐 ; retrouver le message clair 𝑚 ;

• Casser la notion de sécurité sémantique : étant donné un chiffré 𝑐 retrouver une information sur
le message clair 𝑚 (but le plus faible).

–3–
 Chapitre I : Introduction à la cryptographie

Moyens de l’adversaire
On a, par ordre décroissant de difficulté pour l’adversaire :

• l’attaque à chiffré(s) seul(s) : l’adversaire ne connaît que le chiffré ( moyen le plus faible) ;

• l’attaque à clair(s) connu(s) : l’adversaire connaît un ou plusieurs (éventuellement un très grand

nombre) couples clairs chiffrés ;

• l’attaque à clair(s) choisi(s) : semblable à la précédente, mais pour laquelle l’adversaire peut choi-
sir les clairs

• l’attaque à chiffré(s) choisi(s) : l’adversaire obtient les déchiffrements correspondants.

Notions de sécurité
En combinant moyens et buts on définit plusieurs notions de sécurité plus ou moins fortes : par exemple
un chiffrement sera résistant à une attaque contre le bris total un utilisant des chiffrés seuls (sécurité la
plus basse on ne résiste qu’à l’attaque la plus difficile) ou un chiffrement sera résistant à une attaque contre
la sécurité sémantique pour une attaque à chiffrés choisis (sécurité la plus haute).
En asymétrique, le moyen minimal que l’on considère est l’attaque à clairs choisis. La clef publique
étant connue, un adversaire peut obtenir les chiffrés des messages clairs de son choix.
En symétrique, on considère souvent comme moyen minimal l’attaque à clair(s) connus(s) : entête de
fichier connu (mail, image jpeg…), début de protocole.

4. Quelques Fonctionnalités
• confidentialité de l’information

• intégrité de l’information : un adversaire ne peut la modifier sans que cela soit détecté.

• authentification : prouve l’identité de l’auteur d’un message, permet aussi le contrôle d’accès

• non répudiation : l’auteur d’un message ne peut nier l’avoir écrit.

La confidentialité est assurée par les algorithmes de chiffrement (symétriques et asymétriques).

Les fonctions de hachages, objets de cryptographie symétrique, permettent d’assurer l’intégrité. Tou-
jours en cryptographie symétrique, les codes d’authentification de message (MAC, Message Authentication
Code) assurent intégrité et authentification.
Enfin les signatures numériques, objets de cryptographie asymétrique, assurent à la fois intégrité, au-
thentification et non répudiation.

5. Bibliographie
• Douglas Stinson, Cryptographie : Théorie et pratique, 2003 (également des éditions plus récentes en
anglais).

• Gilles Zémor, Cours de cryptographie, Cassini, 2000.

–4–
Chapitre II

Notions de complexité

1. Sens unique
Les algorithmes de chiffrement asymétriques reposent sur la notion de fonctions à sens unique.
Intuitivement, il s’agit de fonctions faciles à évaluer (il existe un algorithme efficace qui fait cela) mais
difficile à inverser.
Dans la suite du cours, nous traiterons deux exemples.

RSA
Soit N = 𝑝𝑞 où 𝑝 et 𝑞 sont deux grands nombres premiers distincts. Soit 1 < 𝑒 < N un entier.
Étant donné un entier 𝑥 ∈ 𝐙/N𝐙 nous verrons qu’il est facile de calculer 𝑦 = 𝑥𝑒 mod N. Par contre,
étant donné 𝑦 il est difficile de retrouver 𝑥 (on ne connaît pas d’algorithme efficace qui le fait).

Logarithme discret
Soit (G, ×) un groupe cyclique d’ordre 𝑛 et 𝑔 un générateur. G = {𝑔, 𝑔2 , … , 𝑔𝑛−1 , 𝑔𝑛 = 1}.
S’il est facile de calculer dans G, il sera facile de calculer ℎ = 𝑔𝑥 étant donné 𝑥. Par contre étant donné
ℎ, dans certains groupes il est difficile de retrouver 𝑥, c’est le problème du logarithme discret, 𝑥 = log𝑔 (ℎ).

On a utilisé « facile » pour « il existe un algorithme efficace » et « difficile » pour « on ne connaît pas
d’algorithme efficace ». Pour donner une définition plus rigoureuse, on va voir des notions de complexité
algorithmique.

2. Complexité algorithmique élémentaire

On note 𝑛 la taille de l’entrée d’un algorithme. Par exemple la taille binaire, c’est à dire le nombre de
bits nécessaires pour représenter l’entrée. Si l’entrée est un entier N, sa taille binaire sera la longueur de sa
représentation en base 2 soit 𝑘 = ⌊log2 (N)⌋ + 1. On a alors 2𝑘−1 ⩽ N ⩽ 2𝑘 − 1.

La complexité d’un algorithme est l’ordre de grandeur du nombre d’opérations binaires effectuées dans
le cas le pire, en fonction de 𝑛.
On dit qu’un algorithme est en 𝒪 (𝑓(𝑛)) s’il existe des entiers 𝑛0 et M tels que son nombre d’opérations
binaires est ⩽ M𝑓(𝑛) pour 𝑛 ⩾ 𝑛0 . Cette notion de complexité permet donc de comparer et classifier des
algorithmes asymptotiquement.

Complexité polynomiale
Si 𝑓 est un polynôme. Ce sont les algorithmes efficaces correspondant à des problèmes algorithmiques
faciles ! Exemple : additions, multiplications d’entiers de taille 𝑛 (voir plus bas)…
Complexités courantes :

–5–
 Chapitre II : Notions de complexité

• 𝒪 (𝑛) : complexité linéaire

• 𝒪 (𝑛2 ) : complexité quadratique

Complexité exponentielle
Algorithmes en 𝒪 (2𝑐𝑛 ) pour un entier 𝑐. Par exemple la recherche exhaustive d’une clef de 𝑛 bits effec-
tue 𝒪 (2𝑛 ) chiffrements.

Complexité sous exponentielle

α 1−α
Algorithmes en 𝒪 (2𝑐𝑛 (𝑙𝑜𝑔2 (𝑛)) ) avec 0 < α < 1. Pour α = 0, on obtiendrait 𝒪 (2𝑐(𝑙𝑜𝑔2 (𝑛)) ) = 𝒪 (𝑛𝑐 )
soit une complexité polynomiale. Pour α = 1, on a 𝒪 (2𝑐𝑛 ) c’est à dire une complexité exponentielle. Les
meilleurs algorithmes cassant les fonctions à sens unique basées sur RSA et le logarithme discret dans
certains groupes ont une complexité sous-exponentielle.

Pour résumer, une attaque avec complexité polynomiale (en la taille de la clef, ou en un paramètre de
sécurité dont dépend la taille de la clef) sur un système cryptographique correspondra donc à une attaque
efficace et le système sera considéré cassé et donc non sûr. Par contre une complexité exponentielle (ou
sous-exponentielle) permettra d’ajuster la taille de la clef pour rendre l’attaque inenvisageable tout en gar-
dant un système possible à utiliser. Ainsi pour une complexité polynomiale en 𝒪 (𝑛𝑘 ), doubler la taille de
la clef 𝑛, multipliera le coût de l’attaque uniquement par 2𝑘 alors que pour une complexité exponentielle
en 𝒪 (2𝑛 ), doubler la taille de la clef mettra au carré le coût de l’attaque.

3. Complexité des algorithmes de base

Addition de deux entiers de taille 𝑛
Complexité 𝒪 (𝑛) avec l’algorithme de l’école primaire : optimal on calcule aussi vite que l’on lit l’entrée.

Multiplication de deux entiers de taille 𝑛

Algorithme de l’école primaire en 𝒪 (𝑛2 ).
Pour les tailles cryptographiques on utilise des algorithmes plus efficaces comme Karatsuba (1960, en
𝒪 (𝑛𝑙𝑜𝑔2 (3) ) avec 𝑙𝑜𝑔2 (3) ≈ 1, 58), plus efficace à partir de nombres de quelques centaines de bits.
Pour de très grandes tailles, l’algorithme de Schönhage et Strassen (1971) qui utilise la transformée de
Fourier rapide (FFT) est plus efficace (en 𝒪 (𝑛 log 𝑛 log log 𝑛)) pour des nombres de plusieurs dizaines de
milliers de chiffres. Récemment des meilleures complexités théoriques ont été prouvées (Harvey, van der
Hoeven (2019) O(𝑛 log 𝑛)) mais ce ne sont pas des algorithmes utilisables en pratique.

Division euclidienne des deux entiers

Soient 𝑥 et 𝑦 deux entiers et 𝑥 = 𝑞𝑦 + 𝑟 avec 0 ⩽ 𝑟 < 𝑦 la division euclidienne de 𝑥 par 𝑦. L’algorithme
naïf calcule 𝑟 en 𝒪 (taille(𝑦)taille(𝑞)).
Un cas typique d’utilisation est le calcul de 𝑎𝑏 mod N avec N de 𝑛 bits et 𝑎, 𝑏 < N. La multiplication
dans les entiers 𝑎𝑏 donne un entier de 2𝑛 bits et on veut calculer le reste de la division euclidienne par N.
On a alors un quotient de 𝑛 bits et la complexité est en 𝒪 (𝑛2 ).
Des méthodes plus efficaces ont des complexités similaires à celle de la multiplication.

4. Exponentiation modulaire
On désire calculer 𝑥𝑎 mod N avec 𝑥, 𝑎 < N et N de 𝑛 bits. Calcul usuel en cryptographie.
Le calcul 𝑥 × 𝑥 × ⋯ × 𝑥 est trop coûteux : 𝑎 − 1 multiplications, c’est à dire 𝒪 (2𝑛 ) multiplications, donc
une complexité exponentielle.

–6–
4. Exponentiation modulaire

On utilise un algorithme bien plus efficace (appelé exponentiation rapide ou exponentiation binaire)
ℓ−1
en décomposant le calcul en utilisant la représentation binaire de 𝑎 = ∑𝑖=0 𝑎𝑖 2𝑖 .
On note 𝑏ℓ = 0, puis
𝑏ℓ−𝑖 = 2𝑏ℓ−𝑖+1 + 𝑎ℓ−𝑖 ,
pour 𝑖 = 1, … , ℓ de telle sorte que 𝑏0 = 𝑎. On calcule ensuite 𝑥𝑎 mod N itérativement : 𝑥𝑏ℓ = 1 puis

𝑥𝑏ℓ−𝑖 ≡ (𝑥𝑏ℓ−𝑖+1 )2 × 𝑥𝑎ℓ−𝑖 (mod N),

pour 𝑖 = 1, … , ℓ de telle sorte que 𝑥𝑏0 ≡ 𝑥𝑎 (mod N).

Au final on obtient l’algorithme suivant :

Entrée : 𝑥, N, 𝑎 = (𝑎ℓ−1 , 𝑎ℓ−2 , … , 𝑎1 , 𝑎0 )

𝑦 ∶= 1
Pour 𝑖 de ℓ − 1 à 0 faire
𝑦 ∶= 𝑦2 mod N
Si 𝑎𝑖 == 1 alors
𝑦 ∶= 𝑦 × 𝑥 mod N
Retourner 𝑦

Du fait de sa structure, cet algorithme est appelé square and multiply en anglais. On a considéré ici une
variante de « gauche à droite » : des bits de poids forts de l’exposant 𝑎 aux bits de poids faibles. Il existe
une version de « droite à gauche » de complexité similaire et de nombreuses variantes et optimisations.
Cette version utilise dans le cas le pire 2ℓ multiplications modulo N (3/2ℓ en moyenne). Comme ℓ ⩽ 𝑛
et en utilisant les multiplications et divisions euclidiennes naïves on obtient un algorithme en 𝒪 (𝑛3 ).

–7–
 Chapitre II : Notions de complexité

–8–
Chapitre III

Rappels d’arithmétique

1. Arithmétique dans les entiers

Soient 𝑎, 𝑏 deux entiers relatifs.

• Division euclidienne. si de plus 𝑏 ≠ 0, il existe un unique couple (𝑞, 𝑟) ∈ 𝐙 × N tel que 𝑎 = 𝑏𝑞 + 𝑟

et 0 ⩽ 𝑟 < |𝑏|.

• Diviseurs. On dit que 𝑏 divise 𝑎 s’il existe un entier 𝑞 tel que 𝑎 = 𝑏𝑞. On note 𝑏|𝑎.

• Plus grand diviseur commun de 𝑎 et 𝑏 avec (𝑎, 𝑏) ≠ (0, 0) : le plus grand entier 𝑑 tel que 𝑑|𝑎 et 𝑑|𝑏.
On notera pgcd(𝑎, 𝑏). De plus si 𝑢|𝑎 et 𝑢|𝑏 alors 𝑢| pgcd(𝑎, 𝑏).

• Entiers premiers entre eux. Si pgcd(𝑎, 𝑏) = 1. Équivalent à : il existe 𝑢, 𝑣 ∈ 𝐙 tels que 𝑢𝑎 + 𝑏𝑣 = 1.

• Relation de Bézout. Il existe 𝑢, 𝑣 ∈ 𝐙 tels que pgcd(𝑎, 𝑏) = 𝑎𝑢 + 𝑏𝑣.

• Lemme de Gauss. Si 𝑎|𝑏𝑐 et pgcd(𝑎, 𝑏) = 1 alors 𝑎|𝑐.

• Nombres premiers. Un entier naturel 𝑝 est dit premier si 𝑝 > 1 et l’ensemble de ses diviseurs est
{1, 𝑝}. Il existe une infinité de nombres premiers.

• Factorisation. Tout entier naturel 𝑛 non nul se factorise de manière unique (à l’ordre près) en
produit de puissances de nombres premiers :

𝑛= 􏾟 𝑝𝑛𝑝 avec 𝑛𝑝 ⩾ 0.
𝑝 premiers

2. Algorithme d’Euclide étendu

L’algorithme d’Euclide étendu explicite la relation de Bézout pgcd(𝑎, 𝑏) = 𝑎𝑢 + 𝑏𝑣 étant donnés 𝑎 et 𝑏.

–9–
 Chapitre III : Rappels d’arithmétique

Entrée : 𝑎, 𝑏 avec 𝑎 ⩾ 𝑏 > 0.

𝑟 ∶= 𝑎
𝑟′ ∶= 𝑏
𝑢 ∶= 1 ; 𝑣 ∶= 0
𝑢′ ∶= 0 ; 𝑣′ ∶= 1
Tant que 𝑟′ > 0 faire
𝑟 = 𝑟′ 𝑞 + 𝑟″ (Division euclidienne)
𝑟 ∶= 𝑟′
𝑟′ ∶= 𝑟″
𝑢″ ∶= 𝑢 − 𝑞𝑢′
𝑣″ ∶= 𝑣 − 𝑞𝑣′
𝑢 ∶= 𝑢′ ; 𝑣 ∶= 𝑣′
𝑢′ ∶= 𝑢″ ; 𝑣′ ∶= 𝑣″
Retourner 𝑟, 𝑢, 𝑣

Montrons que cet algorithme retourne le résultat attendu. On note (𝑟𝑛 )𝑛∈𝐍 la suite des restes successifs,
avec l’initialisation 𝑟0 = 𝑎, 𝑟1 = 𝑏. De même (𝑞𝑛 )𝑛⩾1 désigne la la suite des quotients. À chaque étape, on
fait la division euclidienne 𝑟𝑛−1 = 𝑞𝑛 𝑟𝑛 + 𝑟𝑛+1 de sorte que 𝑟𝑛+1 = 𝑟𝑛−1 − 𝑞𝑛 𝑟𝑛 . On note 𝑘 tel que 𝑟𝑘 soit le
dernier reste non nul. On a pgcd(𝑎, 𝑏) = pgcd(𝑟0 , 𝑟1 ) = pgcd(𝑟1 , 𝑟2 ) = ⋯ = pgcd(𝑟𝑘 , 0) = 𝑟𝑘 .
𝑢 𝑣0 1 0
On note (𝑢𝑛 )𝑛∈𝐍 , (𝑣𝑛 )𝑛∈𝐍 les suites des coefficients 𝑢 et 𝑣 avec l’initialisation 􏿶 0 = . Sous
𝑢1 𝑣1 􏿹 􏿶0 1􏿹
forme matricielle chaque étape correspond à

𝑟𝑛 0 1 𝑟𝑛−1
􏿶𝑟 􏿹 = 􏿶1 −𝑞𝑛 􏿹 􏿶 𝑟𝑛 􏿹
⋅
𝑛+1
De même,

𝑢𝑛 𝑣𝑛 0 1 𝑢𝑛−1 𝑣𝑛−1
􏿶𝑢 = ⋅
𝑛+1 𝑣𝑛+1 􏿹 􏿶1 −𝑞𝑛 􏿹 􏿶 𝑢𝑛 𝑣𝑛 􏿹
Par conséquent,

𝑢𝑛 𝑣𝑛 0 1 0 1 𝑢0 𝑣0 0 1 0 1
􏿶𝑢 = ⋯ = ⋯ .
𝑛+1 𝑣𝑛+1 􏿹 􏿶1 −𝑞𝑛 􏿹 􏿶1 −𝑞1 􏿹 􏿶𝑢1 𝑣1 􏿹 􏿶1 −𝑞𝑛 􏿹 􏿶1 −𝑞1 􏿹
En déroulant l’identité sur les restes, on obtient donc que
𝑟𝑛 𝑢𝑛 𝑣𝑛 𝑟0 𝑢𝑛 𝑣𝑛 𝑎
􏿶𝑟 􏿹 = 􏿶𝑢 =
𝑣𝑛+1 􏿹 􏿶𝑟1 􏿹 􏿶𝑢𝑛+1 𝑣𝑛+1 􏿹 􏿶𝑏􏿹
⋅
𝑛+1 𝑛+1

À la dernière étape, on obtient

𝑟𝑘 𝑢𝑘 𝑣𝑘 𝑎
􏿶 0 􏿹 = 􏿶𝑢 𝑣𝑘+1 􏿹 􏿶𝑏􏿹
⋅
𝑘+1
Donc pgcd(𝑎, 𝑏) = 𝑟𝑘 = 𝑎𝑢𝑘 + 𝑏𝑣𝑘 .

3. L’anneau 𝐙/𝑛𝐙
Soit 𝑛 ⩾ 2 un entier naturel. Soit 𝑎, 𝑏 ∈ 𝐙, 𝑎 ≡ 𝑏 (mod 𝑛) si et seulement si 𝑎 − 𝑏 est un multiple de
𝑛. Ceci donne une relation d’équivalence et on note 𝐙/𝑛𝐙 l’ensemble des entiers modulo 𝑛, 𝐙/𝑛𝐙 = {0
(mod 𝑛), 1 (mod 𝑛), … , 𝑛 − 1 (mod 𝑛)}.
L’addition et la multiplication dans 𝐙 sont compatibles avec la relation d’équivalence et on définit les
opérations dans 𝐙/𝑛𝐙 par 𝑎 (mod 𝑛) + 𝑏 (mod 𝑛) = (𝑎 + 𝑏) (mod 𝑛) de même, 𝑎 (mod 𝑛) × 𝑏 (mod 𝑛) =
(𝑎 × 𝑏) (mod 𝑛). Par conséquent, (𝐙/𝑛𝐙, +, ×) est un anneau commutatif. On note alors les classes et les
opérations plus simplement par 𝑎𝑏 (mod 𝑛), ou encore 𝑎𝑏 dans 𝐙/𝑛𝐙.

– 10 –
3. L’anneau 𝐙/𝑛𝐙

Inversibles
Définition III – 1. On dit que 𝑎 ∈ 𝐙 est inversible modulo 𝑛 s’il existe 𝑏 ∈ 𝐙 tel que 𝑎𝑏 ≡ 1 (mod 𝑛). C’est à
×
dire que 𝑎 (mod 𝑛) ∈ (𝐙/𝑛𝐙) . On notera 𝑎−1 ≡ 𝑏 (mod 𝑛) ou 𝑎−1 = 𝑏 dans 𝐙/𝑛𝐙.
Proposition III – 2. Caractérisation des inversibles
1. Un entier 𝑎 est inversible modulo 𝑛 si et seulement si pgcd(𝑎, 𝑛) = 1. De plus si 1 = 𝑎𝑢 + 𝑛𝑣 est une relation de
Bézout, alors 𝑎−1 = 𝑢 dans 𝐙/𝑛𝐙.
×
2. L’ ensemble des inversibles modulo 𝑛, noté (𝐙/𝑛𝐙) , est un groupe pour la multiplication.
×
Proposition III – 3. L’anneau 𝐙/𝑛𝐙 est un corps si et seulement si 𝑛 est premier. Si 𝑝 est premier, 􏿴𝐙/𝑝𝐙􏿷 =
∗
􏿴𝐙/𝑝𝐙􏿷 est un groupe multiplicatif d’ordre 𝑝 − 1.

Indicatrice d’Euler
Définition III – 4. La fonction ou indicatrice d’Euler :
×
φ(𝑛) = Card {𝑎, 1 ⩽ 𝑎 ⩽ 𝑛, pgcd(𝑎, 𝑛 = 1} = Card (𝐙/𝑛𝐙) .
Proposition III – 5. Soit 𝑝 premier
• φ(𝑝) = 𝑝 − 1.
• φ(𝑝𝑘 ) = 𝑝𝑘 − 𝑝𝑘−1 = 𝑝𝑘−1 (𝑝 − 1) pour 𝑘 ⩾ 1.
Théorème III – 6. Théorème des restes chinois. Soient 𝑚 et 𝑛 deux entiers premiers entre eux, on a l’iso-
morphisme
∼
𝐙/𝑚𝑛𝐙 ⟶ 𝐙/𝑚𝐙 × 𝐙/𝑛𝐙
𝑎 ⟼ (𝑎 (mod 𝑚), 𝑎 (mod 𝑛))
Une manière de prouver ce théorème est d’établir la surjectivité de ce morphisme ce qui donne un
algorithme pour reconstituer 𝑎 (mod 𝑚𝑛) à partir de 𝑎 (mod 𝑚) et 𝑎 (mod 𝑛). On réalise pour cela une
interpolation. À partir d’une relation de Bézout 1 = 𝑚𝑢 + 𝑛𝑣, on pose 𝑦 = 𝑚𝑢 et 𝑥 = 𝑛𝑣. En notant 𝑓 le
morphisme de l’énoncé du théorème, on a 𝑓(𝑥) = (1, 0) et 𝑓(𝑦) = (0, 1). Étant donné (𝑐, 𝑑) ∈ 𝐙/𝑚𝐙 × 𝐙/𝑛𝐙,
on a alors 𝑓(𝑐𝑥 + 𝑑𝑦) = (𝑐, 𝑑).
Une conséquence pratique de ce théorème est qu’il est équivalent de calculer dans 𝐙/𝑚𝑛𝐙 et dans
𝐙/𝑚𝐙 × 𝐙/𝑛𝐙. Or calculer dans ce produit cartésien est en général plus rapide.
Corollaire III – 7. Soient 𝑚 et 𝑛 deux entiers premiers entre eux, on a
φ(𝑚𝑛) = φ(𝑚) φ(𝑛).
ℓ α
Au final, on obtient la formule : si 𝑛 = ∏𝑖=1 𝑝𝑖 𝑖 avec les 𝑝𝑖 premiers distincts et les α𝑖 ⩾ 1,
ℓ ℓ
α α −1
φ(𝑛) = 􏾟 φ(𝑝𝑖 𝑖 ) = 􏾟 𝑝𝑖 𝑖 (𝑝𝑖 − 1).
𝑖=1 𝑖=1

Conséquences du théorème de Lagrange

Par le théorème de Lagrange, pour tout sous-groupe H d’un groupe fini G, le cardinal de H divise le
cardinal de G. Si 𝑥 ∈ (G, ×), on rappelle que l’ordre de 𝑥 est le cardinal 𝑡 du sous-groupe ⟨𝑥⟩ = {𝑥, 𝑥2 , … , 𝑥𝑡 =
𝑒} avec 𝑒 le neutre de G. Une conséquence du théorème de Lagrange est que l’ordre 𝑡 de 𝑥 divise Card G.
Comme on a 𝑥𝑡 = 𝑒, on a aussi 𝑥Card G = 𝑥𝑡 Card G/𝑡 = 𝑒Card G/𝑡 = 𝑒.
× ×
Dans les cas G = 􏿴𝐙/𝑝𝐙􏿷 et (𝐙/𝑛𝐙) , ceci donne les théorèmes de Fermat et sa généralisation le
théorème d’Euler :
• Pour tout 𝑎 ∈ 𝐙 et 𝑝 premier, 𝑎𝑝 ≡ 𝑎 (mod 𝑝). (Petit théorème de Fermat)
• Pour tout 𝑎, 𝑛 ∈ 𝐙 avec pgcd(𝑎, 𝑛) = 1, 𝑎φ(𝑛) ≡ 1 (mod 𝑛).(Théorème d’Euler)

– 11 –
 Chapitre III : Rappels d’arithmétique

Cyclicité
Pour la cryptographie basée sur le problème du logarithme discret, nous utiliserons le résultat (admis)
suivant.
× ×
Si 𝑝 est premier 􏿴𝐙/𝑝𝐙􏿷 est cyclique : il existe 𝑔 ∈ 􏿴𝐙/𝑝𝐙􏿷 d’ordre 𝑝 − 1 et ⟨𝑔⟩ = {𝑔, 𝑔2 , … , 𝑔𝑝−1 = 1} =
×
􏿴𝐙/𝑝𝐙􏿷 .

– 12 –
Chapitre IV

Le chiffrement RSA et problèmes

associés

1. RSA
L’un des premiers systèmes de chiffrements asymétriques. Rivest, Shamir, Adleman, 1977.

Principe
Pour recevoir des messages Bob choisit deux grands nombres premiers 𝑝 et 𝑞 distincts et pose N = 𝑝𝑞.
On a alors φ(N) = (𝑝 − 1)(𝑞 − 1). Bob choisit 𝑒, un entier premier avec φ(N) et pose 𝑑 tel que 𝑒𝑑 ≡ 1
(mod φ(N)).

Le couple KBpub = (N, 𝑒) constitue la clef publique de Bob, et KBpriv = 𝑑 est sa clef privée.

×
Pour envoyer un message 𝑚 ∈ (𝐙/N𝐙) à Bob, Alice calcule ChiffKB (𝑚) ∶= 𝑐 ∶= 𝑚𝑒 (mod N).
pub

Pour déchiffrer, Bob calcule DechiffKB (𝑐) ∶= 𝑐𝑑 (mod N).

priv

Ce système de chiffrement est correct car si 𝑐 ≡ 𝑚𝑒 (mod N), 𝑐𝑑 ≡ 𝑚𝑒𝑑 ≡ 𝑚1+𝑘φ(N) ≡ 𝑚 (mod N) par
le théorème d’Euler.

Sécurité
Dans le cadre d’un chiffrement asymétrique on se place dans le contexte minimal d’une attaque à clairs
choisis, la clef publique étant connue, un adversaire peut obtenir les chiffrés des messages clairs de son
choix.
Le but le plus fort pour un adversaire est le bris total : retrouver la clef secrète à partir de la clef publique,
c’est à dire 𝑑 à partir de (N, 𝑒). On peut montrer que cela est équivalent à factoriser N : retrouver les facteurs
premiers 𝑝 et 𝑞.
Un but moins fort est de casser la notion de sens unique : retrouver 𝑚 à partir de 𝑐 ≡ 𝑚𝑒 (mod N)
connaissant N et 𝑒. On ne connaît pas d’autres méthodes que de factoriser N (pour retrouver 𝑑) afin de
résoudre ce problème.

Mise en œuvre
On sait déjà comment calculer efficacement les exponentiations modulaires des algorithmes de chif-
frement et déchiffrement. Il reste deux problèmes à résoudre :

1. Quelle taille pour N afin de se prémunir des attaques ? Pour cela on va étudier les algorithmes de
factorisation d’entiers.

– 13 –
 Chapitre IV : Le chiffrement RSA et problèmes associés

2. Comment Bob peut il construire N, c’est à dire trouver 𝑝 et 𝑞 ? Pour cela on va étudier des tests de
primalité.

2. Factorisation d’entiers
L’entier N de RSA ne doit pas pouvoir être factorisé (en temps raisonnable). On utilise actuellement des
N d’au moins 2048 bits (plus de 600 chiffres décimaux). On estime que factoriser un tel nombre prendrait
de l’ordre de 2112 opérations élémentaires.
Le record actuel date de février 2020 : factorisation d’un entier RSA de 829 bits (250 chiffres décimaux)
en utilisant le meilleur algorithme connu, l’algorithme du crible sur corps de nombres (NFS, Number Field
Sieve). Cet algorithme a une complexité sous-exponentielle que l’on note traditionnellement sous la forme
α 1−α
L N [1/3] avec L N [α] = 𝑒𝑐(log N) (log log N) où 𝑐 est une certaine constante strictement positive.
D’autres algorithmes de factorisation sont adaptés à trouver des facteurs relativement petits d’un entier
N : méthode ρ de Pollard (1975), de complexité exponentielle 𝒪 (√𝑝) où 𝑝 est le plus petit facteur premier de
N. De même un algorithme basé sur les courbes elliptiques a une complexité sous-exponentielle en L 𝑝 [1/2].
Nous allons étudier un autre algorithme qui donne les idées de base du crible sur corps de nombres.

Algorithme de factorisation de Dixon (81)

Complexité L N [1/2]
La première idée vient de la méthode de factorisation de Fermat. Pour factoriser un entier N, on
cherche deux entiers 𝑥 et 𝑦 tels que

𝑥 ≢ ±𝑦 (mod N) et 𝑥2 ≡ 𝑦2 (mod N).

On a alors (𝑥 − 𝑦)(𝑥 + 𝑦) ≡ 0 (mod N) et les deux facteurs étant non nuls, on a forcément

1 < pgcd(𝑥 − 𝑦, N) < N et 1 < pgcd(𝑥 + 𝑦, N) < N.

On obtient donc deux facteurs non triviaux de N.

La deuxième idée est de « fabriquer » ces deux entiers en utilisant un base de petits facteurs premiers
ℬ = {𝑝1 , 𝑝2 , … 𝑝𝑘 }. On tire des entiers 𝑧 au hasard avec 1 < 𝑧 < N. On calcule ensuite 𝑟 = 𝑧2 mod N et on
essaye de factoriser 𝑟 dans la base ℬ . Si cela non fonctionne pas, on « jette » 𝑧. Sinon on le garde ainsi que
la décomposition obtenue (on parle de relation). On recommence ce procédé jusqu’à obtenir un certain
nombre, ℓ, de relations :
⎧ 2 𝑚 𝑚 𝑚
⎪
⎪ 𝑧1 ≡ 𝑝1 1,1 𝑝2 1,2 ⋯ 𝑝𝑘 1,𝑘 (mod N)
⎪
⎪
⎨ ⋮
⎪
⎪ ⋮
⎪
⎪
⎩ 2 𝑚 𝑚 𝑚
𝑧ℓ ≡ 𝑝1 ℓ,1 𝑝2 ℓ,2 ⋯ 𝑝𝑘 ℓ,𝑘 (mod N)

Exemple On prend ℬ = {2, 3, 5, 7, 11, 13} et N = 388979. On a

⎧
⎪
⎪ 20872 ≡ 76800 ≡ 210 ⋅ 3 ⋅ 52 (mod N)
⎨
⎪
⎪ 34732 ≡ 3380 ≡ 22 ⋅ 5 ⋅ 132 (mod N)
⎩ 37252 ≡ 261360 ≡ 24 ⋅ 33 ⋅ 5 ⋅ 112 (mod N)

Par conséquent
(2087 ⋅ 3473 ⋅ 3725)2 ≡ (28 ⋅ 32 ⋅ 52 ⋅ 11 ⋅ 13)2 (mod N).
On pose 𝑥 = 2087 ⋅ 3473 ⋅ 3725 et 𝑦 = 28 ⋅ 32 ⋅ 52 ⋅ 11 ⋅ 13, on a 𝑥 ≢ ±𝑦 (mod N) et pgcd(𝑥 − 𝑦, N) = 541,
pgcd(𝑥 + 𝑦, N) = 719. On a en fait N = 541 ⋅ 719.

Dans le cas général, on forme une matrice M à coefficients dans le corps 𝐙/2𝐙 à partir des exposants
trouvés dans les relations :

– 14 –
3. Tests de primalité

⎛ ⎞
⎜⎜𝑚1,1 𝑚1,2 … 𝑚1,𝑘 ⎟⎟
⎜⎜𝑚 𝑚2,2 … 𝑚2,𝑘 ⎟⎟⎟
M = ⎜⎜⎜ 2,1 ⎟,
⎜⎜ ⋮ ⋮ ⋮ ⎟⎟⎟
⎝ ⎠
𝑚ℓ,1 𝑚ℓ,2 … 𝑚ℓ,𝑘
et on cherche α = (α1 , α2 , … , αℓ ) ∈ (𝐙/2𝐙)𝑘 non nul tel que αM ≡ (0, 0, … , 0) (mod 2). Ainsi α est un
élément non nul du noyau (à gauche) de M et son existence sera assurée si le nombre de relations trouvées
ℓ est strictement plus grand que 𝑘 (la taille de la base de facteurs). Une base de facteurs petite permettra
d’avoir cette condition satisfaite rapidement mais diminuera la probabilité que 𝑟 se factorise dans cette
base.
Une fois α trouvé on obtient
α α α 𝑛 𝑛 𝑛
(𝑧1 1 𝑧2 2 ⋯ 𝑧ℓ ℓ )2 ≡ 𝑝1 1 𝑝2 2 ⋯ 𝑝𝑘 𝑘 (mod N),

où les 𝑛𝑖 sont tous pairs. On a donc une congruence entre deux carrés.

Retour à l’exemple On a
⎛ ⎞
⎜⎜0 1 0 0 0 0⎟⎟
M = ⎜⎜⎜0 0 1 0 0 0⎟⎟⎟ ,
⎝ ⎠
0 1 1 0 0 0
on est chanceux, avec seulement 3 relations, on obtient 3 lignes liées : (1, 1, 1)M = (0, 0, … , 0).

3. Tests de primalité
Pour construire les clefs RSA actuelles, on doit générer deux grands nombres premiers aléatoires 𝑝 et
𝑞 afin de construire le module public N = 𝑝𝑞. Actuellement on prend 𝑝 et 𝑞 d’au moins 1024 bits (plus de
300 chiffres décimaux). Pour générer ces premiers, on prend des nombres aléatoires de cette taille et on
teste s’ils sont premiers ou non. Pour cela, on utilise des tests de primalité.

Le test de Miller Rabin (80)

Il s’agit d’un algorithme probabiliste très rapide. Étant donné un entier N, il retourne
• soit « non » : dans ce cas on sait de façon certaine que N est composé ;
• soit « oui » : dans ce cas on sait que N est probablement premier.
Dans le cas « non » on dispose de plus d’un « témoin » prouvant que N est composé. Pour le cas « oui », par
répétitions de l’algorithme, on peut rendre aussi faible que l’on veut la probabilité qu’un nombre composé
N soit déclaré probablement premier.

Une première idée pour établir un test de primalité et de se baser sur le petit théorème de Fermat. Si
𝑝 est premier on sait que pour tout 𝑎 premier avec 𝑝, 𝑎𝑝−1 ≡ 1 (mod 𝑝).
Pour établir si un entier N est premier ou pas, on tire donc des entiers 𝑎 au hasard premiers avec N et
on calcule 𝑏 ≡ 𝑎N−1 (mod N). Ensuite,
• si 𝑏 ≢ 1 (mod N), alors on est sûr que N est composé par contraposée du petit théorème de Fermat,
𝑎 est un témoin de non primalité ;
• si 𝑏 ≡ 1 (mod N), alors est N est peut-être premier. On recommence donc ce test avec un autre 𝑎.
Cependant, il existe une infinité de nombres composés N tels que 𝑎N−1 ≡ 1 (mod N) pour tout 𝑎
premier avec N. Ce sont les nombres de Carmichael (le plus petit est 561). Ainsi pour ces nombres, il
n’existe pas de témoin de non primalité pour ce test naïf.
Le test de Miller Rabin est un raffinement de ce test naïf, qui donne un algorithme aussi efficace pour
lequel il existe une grande proportion de témoins de non primalité pour tous les nombres composés.

– 15 –
 Chapitre IV : Le chiffrement RSA et problèmes associés

Théorème IV – 1. Soit N un nombre impair avec N − 1 = 2𝑠 𝑡, où 𝑡 est impair. S’il existe un entier 𝑎 premier avec
𝑖
N tel que 𝑎𝑡 ≢ 1 (mod N) et 𝑎2 𝑡 ≢ −1 (mod N) pour 𝑖 = 0, 1, … 𝑠 − 1 alors N est composé.
Démonstration. Par contraposée, on démontre que si N est premier alors pour tout entier 𝑎 premier avec
𝑖
N, soit 𝑎𝑡 ≡ 1 (mod N) soit il existe 𝑖 avec 0 ⩽ 𝑖 ⩽ 𝑠 − 1 tel que 𝑎2 𝑡 ≡ −1 (mod N).
D’après le théorème de Fermat, 𝑎 N−1 ≡ 1 (mod N), c’est à dire
𝑠−1 𝑡
(𝑎2 )2 ≡ 1 (mod N).
Or comme N est premier, si X 2 ≡ 1 (mod N) alors X ≡ 1 (mod N) ou X ≡ −1 (mod N).
𝑠−1 𝑠−1
Donc soit 𝑎2 𝑡 ≡ −1 (mod N) et 𝑖 = 𝑠 − 1 convient, soit 𝑎2 𝑡 ≡ 1 (mod N). Dans ce dernier cas, si
𝑠 − 1 > 0 on itère le procédé jusqu’à trouver une puissance de 2 nulle.
𝑖 𝑖
Ainsi, soit on trouve 𝑖 avec 0 ⩽ 𝑖 ⩽ 𝑠 − 1 tel que 𝑎2 𝑡 ≡ −1 (mod N), soit pour tout 0 ⩽ 𝑖 ⩽ 𝑠 − 1, 𝑎2 𝑡 ≡ 1
(mod N) et en particulier, 𝑎 ≡ 1 (mod N).
𝑡

On va utiliser de tels 𝑎 comme témoins de non primalité. De plus, si N est composé, on peut borner la
proportion de nombres qui ne sont pas témoins.
Théorème IV – 2 (admis). Soit N > 9 un nombre composé impair avec N − 1 = 2𝑠 𝑡, où 𝑡 est impair. Alors
× 𝑖 φ(N)
Card 􏿺𝑎 ∈ (𝐙/N𝐙) , 𝑎𝑡 ≡ 1 (mod N) ou 𝑎2 𝑡 ≡ −1 (mod N) pour un 0 ⩽ 𝑖 ⩽ 𝑠 − 1􏿽 ⩽ ⋅
4
1
Ainsi si N est composé, en tirant 𝑎 premier avec N avec équiprobabilité, on a une probabilité ⩽ de
4
ne pas tomber sur un témoin de non primalité.

On obtient l’algorithme suivant,

Entrée : N > 9 impair

Écrire N − 1 = 2𝑠 𝑡 avec 𝑡 impair
Tirer 1 < 𝑎 < N au hasard avec pgcd(𝑎, N) = 1
Si 𝑎𝑡 ≡ 1 (mod N)
Retourner « N est probablement premier »
Pour 𝑖 = 0, 1, … , 𝑠 − 1 faire
𝑖
Si 𝑎2 𝑡 ≡ −1 (mod N)
Retourner « N est probablement premier »
Retourner « N est composé »

Cet algorithme a à peu près la même complexité qu’une exponentiation dans 𝐙/N𝐙 du type 𝑎N−1 . En
utilisant les opérations naïves on obtient donc une complexité en 𝒪 (𝑛3 ) où 𝑛 est la taille de N.
En itérant 𝑘 fois cet algorithme (pour des tirs aléatoires indépendants), on obtient une probabilité
⩽ 1/4𝑘 qu’un nombre composé soit déclaré probablement premier. Avec quelques dizaines d’itérations,
ceci devient négligeable !

D’autres tests
Le test de Miller Rabin et des variantes sont suffisants pour des applications cryptographiques et en
particulier pour générer des nombres premiers pour RSA. On parle en général de test de pseudo primalité
(et donc de nombres pseudo premiers).
Il existe aussi une classe de véritables tests de primalité retournant soit « N est premier » soit « N est
composé » avec dans les deux cas une preuve de la réponse. Ainsi le test AKS (Agrawal, Kayal et Saxena,
2002) est le premier algorithme polynomial déterministe à la complexité prouvée de cette classe. Résolvant
un problème théorique, il est cependant inefficace en pratique. On lui préfère donc l’algorithme APRCL
utilisant les corps cyclotomiques à la complexité quasi-polynomiale ou un test utilisant les courbes ellip-
tiques (ECPP) conjecturé polynomial. Ces deux algorithmes nécessitent plusieurs dizaines de secondes
pour tester un nombre de 1024 bits contre quelques millisecondes pour un test à la Miller Rabin.

– 16 –
Chapitre V

Cryptographie basée sur le problème

du logarithme discret

1. Le problème du logarithme discret

Soit (G, ×) un groupe cyclique d’ordre 𝑛 et 𝑔 un générateur. G = {𝑔, 𝑔2 , … , 𝑔𝑛−1 , 𝑔𝑛 = 1}. Étant donné
ℎ ∈ G, le problème du logarithme discret consiste à retrouver 𝑥 défini modulo 𝑛 tel que ℎ = 𝑔𝑥 . On
note log𝑔 (ℎ) = 𝑥.

Si ce problème est difficile dans G alors la fonction 𝑥 ↦ 𝑔𝑥 est à sens unique. Ce problème n’est pas
toujours difficile par exemple si G = (𝐙/𝑛𝐙, +). Dans ce cas un entier 𝑔 engendre G si pgcd(𝑔, 𝑛) = 1. Si
ℎ ∈ G, en notation additive, on a ℎ ≡ 𝑥𝑔 (mod 𝑛) et on peut trouver 𝑥 en calculant 𝑥 = ℎ𝑔−1 (mod 𝑛).
Cependant il existe des groupes dans lequel ce problème est supposé difficile notamment dans des sous
×
groupes de 􏿴𝐙/𝑝𝐙􏿷 pour 𝑝 premier et des groupes utilisant des courbes elliptiques sur des corps finis. Ces
deux groupes permettent de construire de nombreux systèmes cryptographiques basés sur le problème du
logarithme discret.

2. Quelques applications cryptographiques

L’échange de clefs de Diffie-Hellman (76)
Ce protocole interactif permet à Alice et Bob d’échanger publiquement des informations et à la fin
du protocole de connaître une quantité qui pourra servir comme clef secrète pour faire du chiffrement
symétrique : on souhaite qu’un adversaire Oscar qui écoute la conversation entre Alice et Bob n’ait aucune
information sur cette clef.
Pour cela Alice et Bob se mettent tout d’abord publiquement d’accord sur un groupe (G, ×) cyclique
d’ordre 𝑛 et 𝑔 un générateur.

• Ensuite Alice choisit un 𝑎 aléatoire 1 < 𝑎 < 𝑛 et calcule A ∶= 𝑔𝑎 et envoie cette quantité à Bob sur
un canal public.
• Parallèlement Bob choisit un 𝑏 aléatoire 1 < 𝑏 < 𝑛 et calcule B ∶= 𝑔𝑏 et envoie cette quantité à Alice
sur ce canal public.
• Alice calcule B 𝑎 = 𝑔𝑎𝑏 . Bob de son côté calcule A𝑏 = 𝑔𝑎𝑏 . Cette quantité C = 𝑔𝑎𝑏 sera leur secret
commun.

Pour retrouver cette quantité, Oscar qui écoute les échanges entre Alice et Bob doit résoudre le pro-
blème suivant : étant donné A, B ∈ G calculer C ∈ G tel que C = 𝑔𝑎𝑏 où 𝑎 et 𝑏 sont tels que A = 𝑔𝑎 et
B = 𝑔𝑏 . Ce problème est appelé problème calculatoire de Diffie-Hellman, et (A, B, C) est appelé un
triplet Diffie-Hellman.

– 17 –
 Chapitre V : Cryptographie basée sur le problème du logarithme discret

Si on sait calculer des logarithmes discrets dans G alors on peut résoudre ce problème (en calculant 𝑎
ou 𝑏). Cependant on ne sait pas s’il est possible de résoudre ce problème sans savoir calculer de logarithme
discret.
Un but moins fort pour Oscar serait d’obtenir une information sur C à partir de A et B. Ceci est
équivalent à résoudre le problème décisionnel suivant : étant donné A, B, C ∈ G, décider si (A, B, C) est
un triplet Diffie-Hellman ou non. On parle de problème décisionnel de Diffie-Hellman. La seule
manière connue de résoudre ce problème est de résoudre le problème calculatoire associé en calculant un
logarithme discret.

Le chiffrement d’Elgamal (85)

Principe
C’est un chiffrement à clef publique qui peut se déduire de l’échange de clef Diffie-Hellman. Pour
recevoir des messages Bob choisit un groupe (G, ×) cyclique d’ordre 𝑛 et 𝑔 un générateur. Il choisit ensuite
un 𝑥 aléatoire 1 < 𝑥 < 𝑛 et calcule ℎ = 𝑔𝑥 .
Le triplet KBpub = (𝑛, 𝑔, ℎ) constitue la clef publique de Bob, et KBpriv = 𝑥 est sa clef privée.

Pour envoyer un message 𝑚 ∈ G à Bob, Alice choisit 𝑟 aléatoire 1 < 𝑟 < 𝑛, et calcule ChiffKB (𝑚) ∶=
pub
𝑐 ∶= (𝑐1 , 𝑐2 ) = (𝑔𝑟 , 𝑚ℎ𝑟 ) ∈ G × G.

Pour déchiffrer, Bob calcule DechiffKB (𝑐1 , 𝑐2 ) ∶= 𝑐2 𝑐−𝑥

1 .
priv

Ce système de chiffrement est correct car si (𝑐1 , 𝑐2 ) = (𝑔𝑟 , 𝑚ℎ𝑟 ), 𝑐𝑥1 = 𝑔𝑟𝑥 = ℎ𝑟 comme dans l’échange de
clef Diffie-Hellman. Donc 𝑐2 𝑐−𝑥 𝑟 𝑟 −1 = 𝑚.
1 = 𝑚ℎ (ℎ )

Sécurité
Comme pour RSA on se place dans le contexte minimal d’une attaque à clairs choisis, la clef publique
étant connue, un adversaire peut obtenir les chiffrés des messages clairs de son choix.
Le bris total (retrouver la clef secrète à partir de la clef publique) est équivalent au problème du loga-
rithme discret dans G.
On peut montrer que casser la notion de sens unique est équivalent à résoudre un problème calculatoire
Diffie-Hellman dans G, en effet (ℎ, 𝑐1 , ℎ𝑟 ) est un triplet Diffie-Hellman.
De même ce système est sémantiquement sûr (étant donné un chiffré 𝑐 il est difficile de retrouver une
information sur le message clair 𝑚) si et seulement si le problème décisionnel de Diffie-Hellman est difficile
dans G.
Remarquons que le chiffrement RSA n’atteint pas une telle sécurité sémantique car le chiffrement est
déterministe (contrairement à Elgamal) : un message 𝑚 a un unique chiffré 𝑐, et on peut donc tester si un
chiffré 𝑐 chiffre un message 𝑚 donné.

3. Algorithmes de calcul de logarithmes discrets

Pour mettre en œuvre ces applications cryptographiques, il faut savoir quel groupe G prendre pour
que le problème du logarithme discret soit difficile ; donc connaître les meilleures méthodes connues pour
résoudre ce problème.
On va d’abord voir une méthode générique, qui fonctionne dans tout groupe cyclique G, puis une
×
méthode spécifique à 􏿴𝐙/𝑝𝐙􏿷 .

Algorithme de Shanks
On se place toujours dans le contexte d’un groupe (G, ×) cyclique d’ordre 𝑛 et 𝑔 un générateur. Soit
ℎ ∈ G dont on souhaite calculer le logarithme discret 𝑥 en base 𝑔 : 𝑥 = log𝑔 (ℎ).

– 18 –
3. Algorithmes de calcul de logarithmes discrets

La méthode naïve consiste à calculer les puissances successives 𝑔, 𝑔2 , 𝑔3 , … jusqu’à trouver ℎ = 𝑔𝑥 . Le

coût dans le cas pire est en 𝒪 (𝑛) multiplications dans G, soit exponentiel en la taille de 𝑛.

Un compromis temps mémoire a été proposé par Shanks (1971) connu sous le nom « pas de bébé, pas
de géant ». On pose 𝑚 = ⌈√𝑛⌉ et on écrit 𝑥 = 𝑦 + 𝑚𝑧 avec 0 ⩽ 𝑦, 𝑧 < 𝑚. On a alors ℎ = 𝑔𝑥 = (𝑔𝑚 )𝑧 𝑔𝑦 . Donc

ℎ(𝑔−1 )𝑦 = (𝑔𝑚 )𝑧 . (V.1)

L’idée est de chercher indépendamment 𝑦 et 𝑧 en utilisant de la mémoire.

Dans une phase de précalculs on fait la liste des ((𝑔𝑚 )𝑗 , 𝑗) avec 0 ⩽ 𝑗 < 𝑚. Ce sont les pas de géants. On
ordonne cette liste en triant par rapport à la première coordonnée (on suppose qu’il existe un ordre sur les
représentations des éléments de G).
Le coût algorithmique est en 𝒪 (√𝑛) multiplications dans G pour calculer tous les éléments de la liste
et en 𝒪 (√𝑛 log(𝑛)) comparaisons pour le tri. On doit de plus stocker 𝒪 (√𝑛) éléments de G en mémoire.

Ensuite dans une phase active, on calcule successivement ℎ, ℎ𝑔−1 , ℎ(𝑔−1 )2 , … et on cherche à chaque
fois l’élément dans la liste par recherche dichotomique. Ce sont les pas de bébé. À l’itération 𝑦 on trouvera
l’élément, et on en déduira le logarithme discret en utilisant (V.1).
Dans le cas le pire, cette phase utilise 𝒪 (√𝑛) multiplications dans G et les recherches 𝒪 (√𝑛 log(𝑛))
comparaisons.

Au final cette méthode est toujours exponentielle mais améliore la recherche naïve : on utilise 𝒪 (√𝑛)
multiplications dans G, cependant on doit stocker autant d’éléments en mémoire, ce qui est le point blo-
quant. Il existe une méthode probabiliste due à Pollard (1978) qui garde la même complexité calculatoire
mais en utilisant très peu de mémoire. Ce sont les meilleures méthodes connues dans un groupe générique.

Calcul d’indice
La première idée de cet algorithme vient de Kraitchik (1922) puis cela a été redécouvert et développé
à la fin des années 1970.
×
On considère maintenant le cas de sous groupes d’ordre premier de 􏿴𝐙/𝑝𝐙􏿷 avec 𝑝 premier, cas typique
×
en cryptographie. On note α un générateur de 􏿴𝐙/𝑝𝐙􏿷 (donc d’ordre 𝑝 − 1). Soit 𝑞 un diviseur premier de
𝑝 − 1, on note 𝑧 ∶= (𝑝 − 1)/𝑞 et on suppose de plus que pgcd(𝑞, 𝑧) = 1. On pose 𝑔 = α𝑧 . Cet élément est
d’ordre 𝑞 et on note G le sous-groupe qu’il engendre.
Soit ℎ ∈ G dont on souhaite toujours calculer le logarithme discret 𝑥 en base 𝑔 : 𝑥 = log𝑔 (ℎ), qui est
définit modulo 𝑞.
Comme pour la méthode de Dixon pour factoriser, on se donne une base de petits facteurs premiers
ℬ = {𝑝1 , 𝑝2 , … , 𝑝𝑘 }.
Dans une étape de précalculs, on établie les valeurs 𝑥𝑖 ∶= logα 𝑝𝑖 modulo 𝑞 pour 1 ⩽ 𝑖 ⩽ 𝑘. Pour cela on
tire des entiers 𝑟 au hasard avec 1 < 𝑟 < 𝑝 − 1, on calcule ensuite α𝑟 mod 𝑝 et on essaye de factoriser ce
nombre dans la base ℬ . Si cela ne fonctionne pas, on « jette » 𝑟. Sinon, on obtient une relation du type
𝑚 𝑚 𝑚
α𝑟 ≡ 𝑝1 1 𝑝2 2 ⋯ 𝑝𝑘 𝑘 (mod 𝑝).
En passant au logarithme discret en base α réduit modulo 𝑞 (qui divise 𝑝 − 1, l’ordre de α), on obtient
l’équation linéaire

𝑟 ≡ 𝑚1 𝑥1 + 𝑚2 𝑥2 + ⋯ + 𝑚𝑘 𝑥𝑘 (mod 𝑞).
En ayant obtenu suffisamment de relations pour avoir 𝑘 équations linéairement indépendantes, on peut
résoudre un système linéaire dans le corps 𝐙/𝑞𝐙 pour obtenir la valeur des 𝑥𝑖 = logα 𝑝𝑖 modulo 𝑞.
Durant la phase active, on tire des 𝑟 au hasard et on calcule des ℎα𝑟 jusqu’à pouvoir factoriser dans ℬ :
𝑘 𝑒
ℎα = ∏𝑖=1 𝑝𝑖 𝑖 . On obtient alors l’équation
𝑟

𝑟 + logα ℎ ≡ 𝑒1 𝑥1 + 𝑒2 𝑥2 + ⋯ + 𝑒𝑘 𝑥𝑘 (mod 𝑞),

– 19 –
 Chapitre V : Cryptographie basée sur le problème du logarithme discret

dont on peut tirer la valeur 𝑦 ∶= logα ℎ modulo 𝑞. Pour trouver la valeur de 𝑥 ∶= log𝑔 ℎ (définie modulo 𝑞),
on utilise l’égalité suivante :
ℎ = 𝑔𝑥 = α𝑧𝑥 = α𝑦 .
On a donc en particulier 𝑧𝑥 ≡ 𝑦 (mod 𝑞) et comme on a supposé que pgcd(𝑞, 𝑧) = 1, on en déduit

𝑥 ≡ 𝑦𝑧−1 (mod 𝑞).

Cette méthode a une complexité sous exponentielle en L 𝑝 [1/2] similairement à la factorisation de

Dixon. Une amélioration de cet algorithme utilisant un crible sur corps de nombre comme pour la fac-
torisation donne le meilleur algorithme connu, de complexité L 𝑝 [1/3].
Le record actuel est le calcul d’un logarithme discret dans 𝐙/𝑝𝐙 avec 𝑝 de 795 bits (240 chiffres déci-
maux) en décembre 2019.

4. Conséquences cryptographiques
Pour implanter l’échange de clef Diffie-Hellman et Elgamal, il faut utiliser un groupe cyclique G où
le problème du logarithme est difficile. Un choix classique est d’utiliser comme précédemment un sous
×
groupe d’ordre premier 𝑞 de 􏿴𝐙/𝑝𝐙􏿷 avec 𝑝 premier et 𝑞|𝑝 − 1. Le fait d’avoir 𝑞 premier permet d’éviter une
méthode due à Pohlig-Hellman qui ramène le calcul modulo les facteurs premiers de l’ordre du groupe en
utilisant les restes chinois.
Pour que les meilleures attaques connues fonctionnent en 2112 opérations il faut donc prendre 𝑞 d’au
moins 224 bits pour éviter les attaques génériques (algorithme de Pollard). La taille de 𝑝 est elle donnée
par la complexité du crible sur corps de nombres pour le logarithme discret. On estime aujourd’hui qu’il
faut 𝑝 de 2048 bits (comme pour la factorisation) pour que cet algorithme utilise au moins 2112 opérations.
Un autre choix pour la cryptographie est d’utiliser des groupes issus des courbes elliptiques. Là seule
les méthodes génériques fonctionnent et on peut donc prendre des paramètres beaucoup plus petits.

– 20 –
Chapitre VI

Chiffrement symétrique par bloc

1. Rappels
On s’intéresse ici à un chiffrement symétrique ou à clef secrète. La même clef sert pour le chiffrement
et le déchiffrement.
Dans le chiffrement par bloc, le message clair est découpé en blocs de ℓ bits. À une clef secrète 𝑘,
une chaîne de bits aléatoire d’une certaine longueur, on fait correspondre une permutation σ𝑘 de {0, 1}ℓ :
la description de cette correspondance correspond à la description de l’algorithme de chiffrement. La
fonction de chiffrement est alors 𝑚 ↦ σ𝑘 (𝑚).
Tout l’enjeu est de produire une permutation σ𝑘 la plus « aléatoire » possible tout en gardant une certaine
structure pour avoir un algorithme de longueur succincte (décrire une fonction sans structure quelconque
se fait en donnant la liste de ses images ici en 2ℓ × ℓ bits).
Les standards successifs sont le DES pour Data Encryption Standard de 1977 à 2000, qui utilise une clef
𝑘 de 56 bits et ℓ = 64, maintenant obsolète à cause de sa petite taille de clef ; puis l’AES pour Advanced
Encryption Standard depuis 2000, qui utilise une clef de 128, 192 ou 256 bits et ℓ = 128. Cet algorithme est
massivement utilisé aujourd’hui (3G, 4G, WPA pour le Wifi, TLS/SSL pour le Web).

2. Principes de conception
Comme dit précédemment on veut décrire un algorithme de chiffrement qui correspond à une permu-
tation σ𝑘 de {0, 1}ℓ paramétrée par la clef secrète 𝑘.
Ainsi on généralise le chiffrement historique par substitution : la clef était une permutation σ de 𝐙/26𝐙
et on chiffrait 𝑚 par σ(𝑚). Ce chiffrement avait deux principaux inconvénients. Premièrement une grande
taille de clef secrète par rapport à la taille du message clair 𝑚 : la clef secrète est la description de la
permutation, soit la liste (σ(0), σ(1), … , σ(25)), 26 éléments de 𝐙/26𝐙. Deuxièmement, une faible sécurité :
on peut analyser les fréquences, et on peut faire une attaque par dictionnaire. C’est une attaque à texte
clair connu qui consiste à établir la correspondance entre les 26 clairs possibles et leurs chiffrés.
Pour le chiffrement par blocs on utilise donc ℓ grand (128 pour l’AES) afin que l’espace des messages
{0, 1}ℓ soit grand. La description d’une permutation quelconque de {0, 1}ℓ devient donc impossible. On
redécoupe donc ces ℓ bits en plusieurs paquets plus petits (16 paquets de 8 bits par exemple pour l’AES)
sur lesquels on applique des permutations complexes que l’on peut décrire de manière succincte par une
table. Ces permutations sont appelées boîtes S. Cette étape de substitution apporte de la confusion,
elle complexifie les relations entre entrée et sortie.
Après cette étape, on « mélange » les sorties afin de propager sur le bloc tout entier le résultat des
substitutions. C’est une étape de diffusion. Ceci peut se faire en appliquant une permutation des bits
(donc une permutation de l’ensemble des indices {1, … , ℓ}) ou plus généralement une application linéaire
(ou affine) bijective de (𝐙/2𝐙)ℓ dans (𝐙/2𝐙)ℓ . Ci-dessous, un exemple avec un bloc de 16 bits découpés en
4 paquets de 4 bits.

– 21 –
 Chapitre VI : Chiffrement symétrique par bloc

σ1 σ2 σ3 σ4

Ces concepts de diffusion et de confusion ont été introduits par Shannon en 1949. Les chiffrements
par blocs modernes sont bâtis sur l’alternance de ces étapes de confusion et de diffusion.
Plus précisément, on utilise une construction itérative. On définit une fonction de tour, F 𝑘𝑖 dépen-
dant d’une clef de tour 𝑘𝑖 et opérant sur un bloc. Cette fonction utilise au moins une étape de confusion et
une de diffusion. À partir d’une clef secrète 𝑘 on dérive des clefs de tour (𝑘1 , … , 𝑘𝑟 ) par un algorithme dit
de cadencement de clefs. Puis on itère 𝑟 fois la fonction de tour sur le message clair 𝑚 en utilisant chacune
des clefs de tour. On obtient ainsi le chiffré 𝑐.
Cette construction itérative permet une description concise de l’algorithme de chiffrement. On doit
juste décrire la fonction F et l’algorithme de cadencement de clefs.

F 𝑘1 F 𝑘2 F 𝑘𝑟
𝑚 = 𝑥0 𝑥1 𝑥2 … 𝑥𝑟 = 𝑐

Une construction classique, appelée réseau de substitutions et permutations, suit un tel procédé
itératif. Elle est à la base du chiffrement AES. À partir de la clef secrète 𝑘 on crée 𝑟 + 1 clefs de tour,
(𝑘0 , 𝑘1 , … , 𝑘𝑟 ) par un algorithme de cadencement de clefs. Ces clefs de tours sont toutes des chaînes de ℓ
bits.
On effectue une étape initiale d’ajout de la première clef de tour : étant donné un bloc de message clair
𝑚 ∈ {0, 1}ℓ , on pose 𝑥0 = 𝑚 + 𝑘0 . Cette addition se fait modulo 2, c’est à dire que l’on additionne deux
vecteurs de (𝐙/2𝐙)ℓ . Cela correspond à calculer le « ou exclusif » (X-OR) bit à bit. On note parfois aussi
𝑚 ⊕ 𝑘0 et on dit en franglais que l’on « xore » 𝑚 et 𝑘0 .
Puis pour 𝑖 = 0, … , 𝑟 − 1, on calcule 𝑥𝑖+1 = F 𝑘𝑖+1 (𝑥𝑖 ) pour obtenir le chiffré 𝑐 = 𝑥𝑟 . La fonction de tour
F commence par l’application de 𝑠 boîtes S bijectives (étape de confusion) sur 𝑥𝑖 découpé en 𝑠 sous blocs,
pour donner un nouveau bloc 𝑢𝑖 . Puis on applique une permutation linéaire P (étape de diffusion) sur les
bits de 𝑢𝑖 , on note 𝑣𝑖 le résultat. Enfin, on ajoute la clef de tour : 𝑥𝑖+1 = 𝑣𝑖 + 𝑘𝑖+1 .

𝑥𝑖

S1 S2 S𝑠

𝑢𝑖

P
𝑣𝑖

𝑘𝑖+1 (clef de tour)

𝑥𝑖+1

– 22 –
3. Corps finis

L’étape initiale évite qu’un attaquant puisse calculer le début du chiffrement jusqu’à l’ajout de clef 𝑘1 .
Le déchiffrement se fait en « remontant » tout le chiffrement, toutes les opérations étant inversibles. Bien
noter que seule la clef secrète 𝑘 constituera un secret, toutes les fonctions utilisées (boîtes S, fonction P,
cadencement des clefs) seront publiques.

L’AES suit une telle construction. Cet algorithme de chiffrement par bloc utilise une clef de 128, 192
ou 256 bits avec des blocs de 128 bits. Suivant la taille de la clef, le nombre de tours est respectivement
10, 12 et 14. Afin de décrire explicitement les fonctions utilisées pour le fonctionnement de l’AES, nous
avons besoin d’un outil mathématique, les corps finis.

3. Corps finis
Nous avons vu que l’anneau (𝐙/𝑛𝐙, +, ×) est un corps si et seulement si 𝑛 est premier. Pour 𝑝 premier,
on note 𝐅𝑝 ∶= 𝐙/𝑝𝐙 qui est un corps fini à 𝑝 éléments. On va construire d’autres corps finis, notamment
des corps à 2𝑘 éléments qui nous seront utile pour décrire l’AES. Pour cela on va considérer des quotients
de 𝐅2 [X]. Avant cela, rappelons les similarités entre les anneaux euclidiens 𝐙 et K[X] où K est un corps
commutatif.

On a dans K[X] une division euclidienne, le degré jouant le rôle de la valeur absolue dans 𝐙. Plus
précisément, pour tout A(X), B(X) ∈ K[X] avec B non nul, il existe Q(X), R(X) ∈ K[X] uniques tels que
A(X) = B(X)Q(X) + R(X) avec R(X) = 0 ou deg R < deg B.
Un exemple dans K[X] = 𝐅2 [X] : A(X) = X 3 et B(X) = X 2 +X+1. On trouve X 3 = (X+1)(X 2 +X+1)+1.

Un polynôme P(X) ∈ K[X] non constant est dit irréductible sur K s’il n’existe pas A(X), B(X) ∈ K[X]
tels que P(X) = A(X)B(X) avec A(X), B(X) tout deux non constants.
Par exemple toujours dans 𝐅2 [X], P(X) = X 2 +X+1 est irréductible. S’il ne l’était pas il devrait avoir deux
diviseurs de degré 1 (parmi X + 1 et X). En particulier, il devrait avoir une racine dans 𝐅2 , or P(0) = P(1) = 1.
Par contre X 2 , X 2 + 1 = (X + 1)2 et X 2 + X = X(X + 1) ne sont pas irréductibles.

On peut faire le parallèle suivant entre 𝐙 et K[X] :

𝐙 K[X]

valeur absolue, |𝑎| degré, deg P(X)

div. eucl. 𝑎 = 𝑏𝑞 + 𝑟, avec 0 ⩽ 𝑟 < |𝑏|
nombres premiers
pgcd (𝑑 > 0)
Bézout : 𝑑 = 𝑎𝑢 + 𝑏𝑣
algo d’Euclide étendu
𝐙/𝑛𝐙 = {0, 1, 2, … , 𝑛 − 1 mod 𝑛}
𝐙/𝑛𝐙 corps ssi 𝑛 est premier
div. eucl. A(X) = B(X)Q(X) + R(X) avec deg R < deg B
polynômes irréductibles
pgcd (D(X) unitaire)
Bézout : D(X) = A(X)U(X) + B(X)V(X)
algo d’Euclide étendu
K[X]/P(X)K[X] = K[X]/(P(X)) = {R(X) mod P(X), deg R < deg P}
K[X]/(P(X)) corps ssi P est irréductible

Pour construire des corps à 2𝑘 éléments, notés 𝐅2𝑘 , on va considérer 𝐅2 [X]/(P(X) avec P un polynôme de
degré 𝑘 irréductible. Noter qu’il y a en général plusieurs choix possibles pour P, donnant des représentations
isomorphes pour 𝐅2𝑘 .
Le calcul dans 𝐅2 [X]/(P(X) sur le système de représentants canonique se fait ainsi :
• l’addition se fait coefficients par coefficients, cela correspond à « xorer » les deux listes des coeffi-
cients ;
• la multiplication se fait par multiplication dans 𝐅2 [X] suivie par une réduction modulo P(X) ;
• l’inversion par un Euclide étendu.

– 23 –
 Chapitre VI : Chiffrement symétrique par bloc

Exemple de 𝐅4
On pose 𝐅4 = 𝐅2 [X]/(X 2 + X + 1) corps à 4 éléments (attention ne pas confondre avec 𝐙/4𝐙 qui n’est
pas un corps !).
Pour alléger les notations, on note α = X mod X 2 + X + 1. Ainsi 𝐅4 = {0, 1, α, α + 1} et α est une racine
de X 2 + X + 1 dans 𝐅4 : α2 + α + 1 = 0.

On a α + (1 + α) = 1, α(1 + α) = α + α2 = α + α + 1 = 1 (on a utilisé ici le fait que α2 + α + 1 = 0). Le

calcul α + α2 = 1 revient à faire la division euclidienne X 2 + X = 1(X 2 + X + 1) + 1.
Pour calculer l’inverse de 1 + α, il faut appliquer l’algorithme d’Euclide étendu entre X 2 + X + 1 et X + 1.
On trouve la relation de Bézout, 1(X 2 + X + 1) + X(X + 1) = 1. Ainsi X(X + 1) ≡ 1 (mod X 2 + X + 1) ou
encore α(1 + α) = 1 (ce qu’on avait déjà établi), donc (1 + α)−1 = α.

Corps fini de l’AES

Dans l’AES, on utilise le corps 𝐅256 à 256 = 28 éléments, construit par 𝐅2 [X]/(T(X)) avec le polynôme
irréductible de degré 8 :
T(X) = X 8 + X 4 + X 3 + X + 1.
En notant toujours α = X mod T(X), on a
⎧ ⎫
⎪
⎪ 7 ⎪
⎪
⎨ 𝑖, 𝑏 ∈ 𝐅 ⎬ .
𝐅256 =⎪
⎪􏾜 𝑏𝑖 α 𝑖 2 ⎪
⎪
⎩ 𝑖=0 ⎭

Ainsi comme les éléments de 𝐅2 sont les bits 0 et 1, un élément de 𝐅256 peut être représenté par 8 bits,
c’est à dire un octet. Plus précisément, dans l’AES, chaque élément 𝑏0 + 𝑏1 α + ⋯ + 𝑏7 α7 est identifié avec
l’octet (𝑏7 , 𝑏6 , … , 𝑏0 ) ∈ 𝐅2 (Attention au sens d’écriture !).

L’addition correspond donc à un xor de deux octets. Par exemple l’addition de (0100 0100) et de
(0101 0010) donne (0001 0110). Cela correspond au calcul (α6 + α2 ) + (α6 + α4 + α) = α4 + α2 + α.
Pour la multiplication, il faut comme vu pour 𝐅4 faire une réduction : soit par une division euclidienne,
soit en utilisant plusieurs fois l’identité α8 = α4 + α3 + α + 1. Ainsi la multiplication des deux octets
(1100 0011) et (0000 0110) donne (1011 1100). En effet, cela correspond à (α7 + α6 + α + 1)(α2 + α) =
α9 + α 7 + α 3 + α = α 7 + α 5 + α 4 + α 3 + α 2 .
Pour l’inversion, on utilise un Euclide étendu comme dans 𝐅4 . Par exemple l’inverse de (0000 0011)
donne (1111 0110). Une vérification : (α + 1)(α7 + α6 + α5 + α4 + α2 + α) = 1.

4. L’AES
On donne ici la description dans les grandes lignes de Advanced Encryption Standard (AES). C’est un
chiffrement itératif par bloc utilisant une construction de réseau de substitutions et permutations. Il admet
des clefs de 128, 192 ou 256 bits. Le nombre de tours, 𝑟, (en plus de l’étape initiale d’ajout de clef 𝑘0 ) est
respectivement de 10, 12 ou 14 pour chacune des tailles de clef. L’AES opère sur des blocs de 128 bits.
Un algorithme de cadencement de clefs1 calcule à partir de la clef secrète 𝑘 une suite de 𝑟 + 1 clefs de
tour (𝑘0 , … , 𝑘𝑟 ), comportant toutes 128 bits.
La fonction de tour est construite suivant le principe du réseau de substitutions et permutations : étape
de substitution, étape de permutation, ajout de la clef de tour. Pour l’étape de substitution, dans l’AES, on
applique une seule boîte S notée SubBytes sur chacun des 16 sous blocs de 8 bits, c’est à dire sur chaque
octet, du bloc de 128 bits. L’étape de permutation est constituée de l’application de deux opérations, notées
ShiftRows et MixColumns. Enfin, l’ajout de la clef de tour est noté AddRoundKey. On décrit ces opérations
plus bas.
Au final, le fonctionnement à haut niveau de l’AES est le suivant. On part d’un bloc de 128 bits de texte
clair et on applique successivement sur ce bloc les opérations suivantes :
1 voir par exemple https://en.wikipedia.org/wiki/AES_key_schedule pour une description.

– 24 –
4. L’AES

1. AddRoundKey(𝑘0 ) ;
2. Pour 𝑖 = 0, … , 𝑟−2, on effectue le tour comportant les 4 opérations SubBytes, ShiftRows, MixColumns,
AddRoundKey(𝑘𝑖+1 ) dans cet ordre ;
3. Un dernier tour ne comporte plus que 3 étapes : SubBytes, ShiftRows, AddRoundKey(𝑘𝑟 ) ;
4. Le contenu actuel du bloc donne les 128 bits du texte chiffré.

On détaille maintenant le fonctionnement plus précis des 4 opérations de l’AES.

Représentation des éléments

Tout d’abord, le message clair, puis chaque résultat intermédiaire est un bloc de 128 bits. On le voit
comme 16 × 8 bits c’est à dire 16 octets. Plutôt qu’une représentation en ligne comme vu précédemment,
on range ces octets dans un tableau 4 × 4 :

𝑎0,0 𝑎0,1 𝑎0,2 𝑎0,3

𝑎1,0 𝑎1,1 𝑎1,2 𝑎1,3
𝑎2,0 𝑎2,1 𝑎2,2 𝑎2,3
𝑎3,0 𝑎3,1 𝑎3,2 𝑎3,3

D’autre part, comme vu dans la section précédente, chaque octet est identifié avec un élément du corps
fini 𝐅256 .

SubBytes (boîte S)
Elle opère indépendamment sur chacun des 16 octets. C’est la composée S = 𝑓 ∘ I des applications

I ∶ 𝐅256 → 𝐅256
⎧
⎪
⎨𝑥−1 si 𝑥 ≠ 0,
𝑥 ↦ ⎪
⎩0 si 𝑥 = 0,
et
𝑓 ∶ (𝐅2 )8 → (𝐅2 )8
𝑦 ↦ A𝑦 + B

où A est une matrice 8×8 à coefficients dans 𝐅2 , B est un vecteur de (𝐅2 )8 , explicités en dessous. Plus préci-
7
sément, on identifie comme on l’a vu l’élément ∑𝑖=0 𝑦𝑖 α𝑖 de 𝐅256 calculé par I avec l’octet 𝑦 = (𝑦7 , 𝑦6 , … , 𝑦0 )
puis on calcule A𝑦 + B ainsi :
⎛ ⎞⎛ ⎞ ⎛ ⎞
⎜⎜1 0 0 0 1 1 1 1⎟⎟ ⎜⎜𝑦0 ⎟⎟ ⎜⎜1⎟⎟
⎜⎜⎜1 1 0 0 0 1 1 1⎟⎟⎟⎟ ⎜⎜⎜⎜𝑦1 ⎟⎟⎟⎟ ⎜⎜⎜⎜1⎟⎟⎟⎟
⎜⎜
⎜⎜1 1 1 0 0 0 1 1⎟⎟⎟ ⎜⎜⎜𝑦2 ⎟⎟⎟ ⎜⎜⎜0⎟⎟⎟
⎜⎜ ⎟⎜ ⎟ ⎜ ⎟
⎜⎜1 1 1 1 0 0 0 1⎟⎟⎟ ⎜⎜⎜𝑦3 ⎟⎟⎟ ⎜⎜⎜0⎟⎟⎟
⎜⎜ ⎟⎜ ⎟ + ⎜ ⎟.
⎜⎜⎜1 1 1 1 1 0 0 0⎟⎟⎟ ⎜⎜⎜𝑦4 ⎟⎟⎟ ⎜⎜⎜0⎟⎟⎟
⎜⎜0 ⎟⎜ ⎟ ⎜ ⎟
⎜⎜ 1 1 1 1 1 0 0⎟⎟⎟ ⎜⎜⎜𝑦5 ⎟⎟⎟ ⎜⎜⎜1⎟⎟⎟
⎜⎜0 ⎟⎜ ⎟ ⎜ ⎟
⎜⎝ 0 1 1 1 1 1 0⎟⎟⎟ ⎜⎜⎜𝑦6 ⎟⎟⎟ ⎜⎜⎜1⎟⎟⎟
⎠⎝ ⎠ ⎝ ⎠
0 0 0 1 1 1 1 1 𝑦7 0
En pratique, lorsque l’on implante l’AES, cette boîte S est donnée par une table décrivant toutes les
sorties2 , on ne fait pas les calculs dans le corps 𝐅256 et dans l’espace vectoriel (𝐅2 )8 .
La fonction I d’inversion dans le corps 𝐅256 a été choisie car on peut montrer qu’elle a de très bonnes
propriétés pour se protéger contre certaines attaques avancées. Ensuite, on compose par la fonction affine
𝑓 pour casser le caractère algébrique de I et enlever le point fixe 0 ↦ 0.
Exemple de calcul : on a déjà vu que l’inverse de l’octet (0000 0011) donne (1111 0110). En appliquant
𝑓, on trouve (0111 1011).
2 On peut la trouver ici : https://en.wikipedia.org/wiki/Rijndael_S-box

– 25 –
 Chapitre VI : Chiffrement symétrique par bloc

ShiftRows
Elle fait subir une permutation circulaire vers la gauche aux lignes du tableau, respectivement de 0, 1,
2, 3 cases :

𝑎0,0 𝑎0,1 𝑎0,2 𝑎0,3 𝑎0,0 𝑎0,1 𝑎0,2 𝑎0,3

𝑎1,0 𝑎1,1 𝑎1,2 𝑎1,3 𝑎1,1 𝑎1,2 𝑎1,3 𝑎1,0
⟶
𝑎2,0 𝑎2,1 𝑎2,2 𝑎2,3 𝑎2,2 𝑎2,3 𝑎2,0 𝑎2,1
𝑎3,0 𝑎3,1 𝑎3,2 𝑎3,3 𝑎3,3 𝑎3,0 𝑎3,1 𝑎3,2

MixColumns
Elle s’interprète comme une multiplication matricielle :

𝑎0,0 𝑎0,1 𝑎0,2 𝑎0,3 𝑏0,0 𝑏0,1 𝑏0,2 𝑏0,3

𝑎1,0 𝑎1,1 𝑎1,2 𝑎1,3 𝑏1,0 𝑏1,1 𝑏1,2 𝑏1,3
⟶
𝑎2,0 𝑎2,1 𝑎2,2 𝑎2,3 𝑏2,0 𝑏2,1 𝑏2,2 𝑏2,3
𝑎3,0 𝑎3,1 𝑎3,2 𝑎3,3 𝑏3,0 𝑏3,1 𝑏3,2 𝑏3,3

où ⎛ ⎞ ⎛ ⎞⎛ ⎞
⎜⎜𝑏0,0 𝑏0,1 𝑏0,2 𝑏0,3 ⎟⎟ ⎜⎜ α α+1 1 1 ⎟⎟ ⎜⎜𝑎0,0 𝑎0,1 𝑎0,2 𝑎0,3 ⎟⎟
⎜⎜𝑏 𝑏1,1 𝑏1,2 𝑏1,3 ⎟⎟⎟ ⎜⎜⎜ 1 α α+1 1 ⎟⎟⎟ ⎜⎜⎜𝑎1,0 𝑎1,1 𝑎1,2 𝑎1,3 ⎟⎟⎟
⎜⎜ 1,0 ⎟=⎜ ⎟⎜ ⎟.
⎜⎜𝑏 𝑏2,1 𝑏2,2 𝑏2,3 ⎟⎟⎟ ⎜⎜⎜ 1 1 α α + 1⎟⎟⎟ ⎜⎜⎜𝑎2,0 𝑎2,1 𝑎2,2 𝑎2,3 ⎟⎟⎟
⎜⎝ 2,0 ⎠ ⎝ ⎠⎝ ⎠
𝑏3,0 𝑏3,1 𝑏3,2 𝑏3,3 α+1 1 1 α 𝑎3,0 𝑎3,1 𝑎3,2 𝑎3,3
est le produit des matrices à coefficients dans 𝐅256 . La matrice de cette opération a été choisie pour ses
propriétés de diffusion.

AddRoundKey(𝑘𝑖+1 )
C’est l’addition bit à bit (le xor) de la clef de tour 𝑘𝑖+1 , case par case.

– 26 –
Chapitre VII

Panorama des développements

actuels en cryptographie
asymétrique

Dans ce cours, on a surtout abordé la notion de chiffrement autant en cryptographie à clef publique
qu’en cryptographie à clef secrète. D’autre part, on a principalement développé des solutions mises en
place de la fin des années 70 à la fin des années 90. Du point de vue des objets mathématiques, on a surtout
utilisé les quotients de 𝐙 et les corps finis.
Dans ce chapitre, on donne une ouverture à quelques autres applications, notamment des applications
plus récentes, à d’autres objets mathématiques utilisés en cryptographie à clef publique et à quelques enjeux
actuels de la recherche dans le domaine.

1. Quelques autres applications

Signatures numériques
Outre le chiffrement, une application cruciale et extrêmement répandue en cryptographie à clef pu-
blique est celle de la signature numérique. Alice dispose toujours d’un couple clef publique, clef secrète. La
clef secrète va lui permettre à l’aide d’un algorithme de signature de pouvoir signer un document numérique
représenté par une chaîne de bits 𝑚 (un fichier pdf, un email, une transaction bancaire…) en produisant
une signature σ.
Bob ayant à sa disposition la clef publique d’Alice, le document 𝑚 et la signature σ de 𝑚 émise par Alice,
va utiliser un algorithme de vérification qui lui permettra de vérifier que cette signature est bien valide.
On veut pour ces schémas de signatures des propriétés analogues à la signature manuscrite classique.

Un exemple est la signature RSA. On utilise les mêmes notations que pour le chiffrement. On pose
N = 𝑝𝑞 avec 𝑝, 𝑞 deux grands nombres premiers distincts . On note 𝑒 et 𝑑 tels que 𝑒𝑑 ≡ 1 (mod φ(N)). La
clef publique d’Alice est toujours (N, 𝑒) et 𝑑 sa clef privée. Pour signer une chaîne de bits 𝑚, Alice com-
mence par appliquer sur 𝑚 une fonction ℎ (que l’on veut entre autre à sens unique), qui envoie 𝑚 sur ℎ(𝑚) un
×
élément de (𝐙/N𝐙) . Une telle fonction est appelée une fonction de hachage et on peut la construire à par-
tir de fonctions de hachages standardisées (SHA-2, SHA-3). La construction de ces fonctions ressemblent
aux constructions de chiffrement par blocs (mais sans clef).
Alice calcule ensuite
σ ∶≡ ℎ(𝑚)𝑑 (mod N).
Bob disposant de 𝑚, (N, 𝑒) et σ pourra vérifier que σ est bien la signature d’Alice du message 𝑚 en
testant si
?
σ𝑒 ≡ ℎ(𝑚) (mod N).

– 27 –
 Chapitre VII : Panorama des développements actuels en cryptographie asymétrique

Il existe d’autres schémas de signatures, notamment basés sur le problème du logarithme discret,
×
comme le schéma DSA utilisant un sous groupe d’ordre premier 𝑞 de 􏿴𝐙/𝑝𝐙􏿷 ou le schéma ECDSA utili-
sant des courbes elliptiques.

Schémas de chiffrements avancés

Il s’agit de raffinements du chiffrement asymétrique, théorisés tout comme le chiffrement asymétrique
et la signature à la fin des années 70. Si le chiffrement et la signature ont connu des réalisations rapides,
notamment par RSA, il aura fallu attendre le début de années 2000 pour donner des schémas concrets et
efficaces pour ces schémas de chiffrement avancés.
Parmi eux le chiffrement basé sur l’identité (2000) et le chiffrement basé sur les attributs
(2005). L’idée est qu’un utilisateur pourra déchiffrer un message s’il possède une certaine identité ou cer-
tains attributs (avoir un certain âge, un certain niveau de responsabilité, habiter une certaine région géo-
graphique…).
Plus récemment, des réalisations concrètes du chiffrement homomorphe (2009) ont été proposées.
Ce chiffrement permet de faire des calculs sur des données chiffrées. L’idée est par exemple de chiffrer ses
emails et de les stocker sur un serveur (dans le fameux cloud). Le serveur n’aura pas la clef de déchiffre-
ment et ne connaitra pas le contenu des emails mais pourra faire des opérations dessus, par exemple pour
renvoyer tous les emails contenant le mot « frites ». Si les premières réalisations de ce concept étaient peu
pratiques, la recherche sur le sujet a été très active ces dix dernières années pour proposer des solutions de
plus en plus efficaces.

Calcul multipartite sécurisé

Il s’agit d’un concept proche, théorisé au début des années 1980 avec le problème des millionnaires :
Alice a une fortune de 𝑎 euros et Bob de 𝑏 euros. Alice et Bob veulent savoir lesquels des deux est le plus
riche, mais sans dévoiler sa fortune à l’autre. Ainsi ils veulent évaluer si 𝑎 ⩾ 𝑏 et rien d’autre.
La généralisation de ce problème est la suivante : on a maintenant 𝑛 parties, ayant chacune un secret 𝑥𝑖
pour 𝑖 = 1, … , 𝑛 et elles veulent évaluer une certaine fonction 𝑓 de leur secret, en calculant conjointement
𝑓(𝑥1 , … , 𝑥𝑛 ) mais sans révéler rien d’autres sur les 𝑥𝑖 .
C’est un domaine très actif actuellement avec des solutions de plus en plus efficaces même pour un
grand nombre de parties 𝑛 ou des fonctions 𝑓 complexes. Ceci est motivé par l’émergence de protocoles
décentralisés (sans autorité centrale) comme les monnaies cryptographiques (bitcoin), et les applications de
la blockchain en général.

2. Quelques autres outils mathématiques

Bon nombre d’applications cryptographiques, y compris actuelles utilisent les quotients de 𝐙 et les
corps finis. Cependant, certaines sont plus efficaces voire ne sont possibles qu’en considérant d’autres
objets mathématiques.

Les courbes elliptiques

C’est un objet qu’on a souvent mentionné dans le cours. En effet, il permet de construire des applica-
tions cryptographiques basées sur le problème du logarithme discret très proches de celles qu’on a vu dans
𝐙/𝑝𝐙. D’autre part ce problème y est plus difficile : on ne dispose que d’algorithmes exponentiels pour le
résoudre contre des algorithmes sous-exponentiels dans 𝐙/𝑝𝐙. Ainsi on peut avoir des tailles de clefs plus
courtes.
L’usage des courbes elliptiques en cryptographie remonte à 1985 et les applications couramment utili-
sées de nos jours sont l’échange de clef Diffie-Hellman (ECDH) ou la signature ECDSA.
Il s’agit d’un objet important en théorie des nombres. En quelques mots, c’est une courbe algébrique
plane définie par une équation du type 𝑦2 = 𝑥3 + 𝑎𝑥 + 𝑏. On considère l’ensemble E des points à coordon-
nées (𝑥, 𝑦) vérifiant cette équation dans un corps fini (pour les applications cryptographiques). Le point
particulier de ces courbes elliptiques est que l’on peut munir cet ensemble E d’une loi de groupe.

– 28 –
2. Quelques autres outils mathématiques

D’autre part, à partir des années 2000, de nombreuses nouvelles applications cryptographiques (no-
tamment le chiffrement basé sur l’identité) sont apparus en utilisant un outil plus avancé, une application
bilinéaire de E × E dans un corps fini, appelée un couplage (pairing). L’utilisation de ce couplage a ainsi
permis de construire concrètement certains protocoles cryptographiques jusqu’alors théoriques.

Outils post-quantique
Un enjeu actuel en cryptographie est l’arrivée possible dans quelques (dizaines ?) d’années d’un ordi-
nateur quantique. Un tel ordinateur utiliserait des propriétés de physique quantique. Certains problèmes
algorithmiques réputés difficiles actuellement deviendraient facile avec un ordinateur quantique. En effet,
même si on ne dispose pas aujourd’hui d’un ordinateur quantique, on dispose d’algorithmes qu’il pourrait
exécuter.
En cryptographie, c’est notamment le cas pour le problème de la factorisation d’entiers ou celui du lo-
garithme discret dans n’importe quel groupe cyclique : l’algorithme de Shor (1994) permettrait de résoudre
ces deux problèmes en temps polynomial avec un ordinateur quantique, provoquant l’effondrement de
tous les systèmes cryptographiques que nous avons vu et largement déployés à l’heure actuelle ! On est
encore loin de cela, le record de factorisation avec l’algorithme de Shor étant celle du nombre 21 (en 2012).
Cependant, une cryptographie dite post-quantique est développée, c’est à dire une cryptographie dont
la sécurité repose sur des problèmes algorithmiques pour lesquels on ne connaît pas d’algorithmes quan-
tiques plus efficaces que les algorithmes classiques. Une compétition est actuellement organisée par le
NIST (l’organisme de normalisation américain) pour établir des standards de protocoles cryptographiques
post-quantiques. Des premiers algorithmes ont été standardisé en Juillet 2022.
Deux principaux objets mathématiques sont à l’œuvre : les réseaux euclidiens et les codes correc-
teurs. Pour les premiers il s’agit de sous groupes discrets de 𝐑𝑛 , c’est à dire de l’ensemble des combinaisons
linéaires à coefficients entiers de vecteurs de base 𝑏1 , … , 𝑏𝑑 ∈ 𝐑𝑛 :
⎧ ⎫
⎪
⎪ 𝑑 ⎪
⎪
⎨ 𝑛 ⎬
L=⎪ ⎪𝑣 ∈ 𝐑 , 𝑣 = 􏾜 λ 𝑏 ,
𝑖 𝑖 𝑖λ ∈ 𝐙 ⎪
⎪ .
⎩ 𝑖=1 ⎭

Pour les seconds, il s’agit de sous-espaces vectoriels C de 𝐅𝑛2 . Pour les deux, on considère des problèmes
algorithmiques similaires, par exemple celui du décodage : étant donné un point de l’espace, 𝐑𝑛 pour un
réseau, (resp. 𝐅𝑛2 pour un code) trouver le point du réseau L (resp. du code C) le plus proche. La notion de
proche différent dans les deux cas : au sens de la métrique euclidienne pour les réseaux, et au sens de la
métrique de Hamming pour les codes.

– 29 –