Mathematics on kenji.blog

Fondements et implémentation de la cryptographie à l'aide du petit théorème de Fermat

Fri, 11 Sep 2026 22:00:00 +0900

1. Introduction : Le mystère mathématique qui sous-tend la cryptographie moderne

Dans la société numérique d’aujourd’hui, et particulièrement dans les communications sur Internet, le “chiffrement” est devenu une technologie fondamentale indispensable. Le fait que nous puissions naviguer en toute sécurité sur des sites web via HTTPS dans nos navigateurs, effectuer des transactions financières par le biais des services bancaires en ligne, et avoir des échanges privés sur des applications de messagerie est dû aux protocoles cryptographiques basés sur des théories mathématiques avancées fonctionnant en arrière-plan. Parmi ceux-ci, la “cryptographie à clé publique” joue un rôle particulièrement important, dont le représentant le plus célèbre est le chiffrement RSA.

La sécurité et la validité de nombreux algorithmes cryptographiques, y compris RSA, dépendent fortement d’un théorème extrêmement beau et puissant découvert par le mathématicien français du 17e siècle, Pierre de Fermat. Il s’agit du petit théorème de Fermat (Fermat’s Little Theorem). De plus, le théorème de Leonhard Euler, qui généralise ce théorème, joue également un rôle décisif dans la théorie cryptographique.

Cet article explique en détail, depuis les bases, comment la découverte mathématique pure qu’est le petit théorème de Fermat s’applique aux technologies cryptographiques pratiques modernes, en particulier aux “tests de primalité” et au “chiffrement RSA”. Il s’agit d’un guide technique très détaillé couvrant tout, des preuves mathématiques, aux mécanismes de chiffrement et de déchiffrement, jusqu’à l’implémentation concrète des algorithmes en C++ et Python.

2. Bases des congruences et de l’arithmétique modulaire

Pour comprendre le petit théorème de Fermat, vous devez d’abord vous familiariser avec le concept mathématique d’“arithmétique modulaire (congruences)”. L’arithmétique modulaire est un système de calcul qui se concentre sur le “reste” lorsqu’un nombre est divisé par un nombre fixe (appelé module). Comme il s’agit d’un calcul similaire à celui du cadran d’une horloge (qui fait un tour en 12 heures), on l’appelle aussi parfois “mathématiques de l’horloge”.

Lorsque le reste de la division de deux entiers $a$ et $b$ par un entier positif $n$ est égal, on l’écrit mathématiquement comme suit :

$$ a \equiv b \pmod n $$

Cela se lit “$a$ et $b$ sont congrus modulo $n$”. Par exemple, le reste de 17 divisé par 5 est 2, et le reste de 12 divisé par 5 est également 2. Par conséquent, on peut écrire ce qui suit :

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

En arithmétique modulaire, les quatre opérations arithmétiques habituelles (addition, soustraction, multiplication) s’appliquent telles quelles.

Addition : Si $a \equiv b \pmod n$ et $c \equiv d \pmod n$, alors $a + c \equiv b + d \pmod n$
Soustraction : Si $a \equiv b \pmod n$ et $c \equiv d \pmod n$, alors $a - c \equiv b - d \pmod n$
Multiplication : Si $a \equiv b \pmod n$ et $c \equiv d \pmod n$, alors $a \times c \equiv b \times d \pmod n$
Exponentiation : Si $a \equiv b \pmod n$, alors pour tout entier naturel $k$, $a^k \equiv b^k \pmod n$

Cependant, il faut faire attention à la division. En général, même si $a \times c \equiv b \times c \pmod n$, vous ne pouvez pas diviser les deux côtés par $c$ pour obtenir $a \equiv b \pmod n$. Cela n’est vrai que si $c$ et $n$ sont premiers entre eux (leur plus grand commun diviseur est 1). Ce concept d’“inverse modulaire” devient extrêmement important dans la génération de clés pour le chiffrement RSA, que nous aborderons plus tard.

3. Contexte mathématique et preuve du petit théorème de Fermat

Maintenant que nous avons couvert les bases de l’arithmétique modulaire, examinons le sujet principal, le petit théorème de Fermat.

3.1 Définition du théorème

Le petit théorème de Fermat est formulé comme suit :

Petit théorème de Fermat (Fermat’s Little Theorem) Soit $p$ un nombre premier et $a$ un entier quelconque qui n’est pas un multiple de $p$ (c’est-à-dire que $a$ et $p$ sont premiers entre eux). Alors, la congruence suivante est vraie :
$$ a^{p-1} \equiv 1 \pmod p $$

Il est également courant d’exprimer ce théorème sous une forme valable pour tout entier $a$, en supprimant la condition “$a$ n’est pas un multiple de $p$”. Dans ce cas, on multiplie les deux côtés par $a$, ce qui donne :

$$ a^p \equiv a \pmod p $$

3.2 Vérification par des exemples concrets

Vérifions si le théorème se vérifie vraiment en utilisant des nombres concrets. Soit le nombre premier $p = 5$. Alors $p-1 = 4$. Nous choisissons un entier pour $a$ qui n’est pas un multiple de $p$.

Pour $a = 2$ : $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ avec un reste de $1$. Donc $16 \equiv 1 \pmod 5$. (Vérifié)
Pour $a = 3$ : $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ avec un reste de $1$. Donc $81 \equiv 1 \pmod 5$. (Vérifié)
Pour $a = 4$ : $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ avec un reste de $1$. Donc $256 \equiv 1 \pmod 5$. (Vérifié)

Ainsi, quel que soit le $a$ que vous choisissez (à condition qu’il ne soit pas un multiple de 5), le reste de sa 4ème puissance divisée par 5 sera toujours 1. Cela ressemble à de la magie, mais cela découle des magnifiques propriétés des nombres premiers.

3.3 Preuve mathématique du théorème

Pourquoi cela est-il vrai ? Nous présentons ici une preuve élégante utilisant l’ensemble des classes de restes.

Considérons l’ensemble $S = \{1, 2, 3, \dots, p-1\}$. Ce sont les représentants des entiers dont les restes de la division par $p$ vont de $1$ à $p-1$. Considérons maintenant un nouvel ensemble $T$ obtenu en multipliant chaque élément par un entier $a$ qui est premier avec $p$.

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

Considérons les restes de chaque élément de cet ensemble $T$ divisé par $p$. Étonnamment, ces restes, bien que leur ordre puisse changer, correspondent exactement à l’ensemble des éléments de l’ensemble d’origine $S$. Pourquoi ?

Les éléments de $T$ ne peuvent jamais être des multiples de $p$ (car ni $a$ ni les éléments d’origine ne sont des multiples de $p$).
Il n’y a pas deux éléments distincts dans $T$ qui sont congrus modulo $p$. Si $ia \equiv ja \pmod p$ ($i \neq j$), puisque $a$ et $p$ sont premiers entre eux, nous pouvons diviser par $a$ pour obtenir $i \equiv j \pmod p$, ce qui est une contradiction.

Par conséquent, le produit de tous les éléments de $S$ et le produit de tous les éléments de $T$ sont congrus modulo $p$.

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

En réorganisant le côté gauche, puisqu’il y a $p-1$ termes de $a$,

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

Comme $(p-1)!$ est premier avec $p$, nous pouvons diviser les deux côtés par $(p-1)!$, ce qui conduit finalement au théorème suivant :

$$ a^{p-1} \equiv 1 \pmod p $$

Ceci est la preuve du petit théorème de Fermat.

4. La fonction indicatrice d’Euler et le théorème d’Euler

Le petit théorème de Fermat est un théorème concernant “un nombre premier $p$”, mais il a été généralisé à “tout entier positif $n$” par Leonhard Euler. Cette extension est essentielle pour comprendre le chiffrement RSA.

4.1 La fonction indicatrice d’Euler $\phi(n)$

La fonction indicatrice d’Euler (ou fonction $\phi$ d’Euler) $\phi(n)$ est une fonction qui représente “le nombre d’entiers de $1$ à $n$ qui sont premiers avec $n$”.

Dans le cas d’un nombre premier $p$, puisque tous les entiers de $1$ à $p-1$ sont premiers avec $p$, $\phi(p) = p - 1$.
Pour le produit de deux nombres premiers distincts $p$ et $q$, c’est-à-dire $n = p \times q$, $\phi(n)$ peut être calculé avec une formule très simple : $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Cette propriété est la logique fondamentale derrière la génération de clés dans le chiffrement RSA.

4.2 Le théorème d’Euler

Euler a généralisé le petit théorème de Fermat comme suit :

Théorème d’Euler (Euler’s Theorem) Pour tout entier positif $n$ et tout entier $a$ qui lui est premier entre eux, ce qui suit est vrai :
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Si $n$ est un nombre premier $p$, alors $\phi(p) = p - 1$, donc cela devient exactement le petit théorème de Fermat ($a^{p-1} \equiv 1 \pmod p$). En d’autres termes, le petit théorème de Fermat n’est qu’un cas particulier du théorème d’Euler.

5. Trouver d’énormes nombres premiers : Le test de primalité de Fermat

Dans les technologies cryptographiques (comme le chiffrement RSA et l’échange de clés Diffie-Hellman), il est nécessaire de trouver rapidement “d’énormes nombres premiers” s’étendant sur des centaines de chiffres. Cependant, utiliser la méthode de la “division par essais”, qui consiste à essayer de diviser par tous les nombres de $2$ à $\sqrt{N}$ pour déterminer si un grand nombre $N$ est premier, prendrait un temps équivalent à l’âge de l’univers.

C’est là qu’intervient le test de primalité de Fermat (Fermat Primality Test), un “test de primalité probabiliste” qui utilise le petit théorème de Fermat à l’envers.

5.1 Qu’est-ce qu’un test de primalité probabiliste ?

Selon le petit théorème de Fermat, si $p$ est premier, alors $a^{p-1} \equiv 1 \pmod p$ est toujours vrai pour tout $a$ ($1 < a < p$). La contraposée de cette affirmation est : “S’il existe un $a$ pour lequel $a^{p-1} \not\equiv 1 \pmod p$, alors $p$ n’est absolument pas un nombre premier (c’est un nombre composé)”.

Par conséquent, si vous voulez déterminer si $N$ est premier, vous choisissez quelques valeurs aléatoires de $a$, calculez $a^{N-1} \pmod N$ et vérifiez si le résultat est $1$. Si vous obtenez une réponse autre que $1$ ne serait-ce qu’une seule fois, il est certain que $N$ est un nombre composé. S’il vaut $1$ peu importe le nombre de fois que vous essayez, vous pouvez juger avec une forte probabilité que $N$ est “probablement premier”.

5.2 Explication de l’algorithme et organigramme

L’algorithme du test de Fermat est le suivant :

flowchart TD Start["Début"] --> Input["Entrer le nombre à tester p et le nombre de tests k"] Input --> LoopStart["Boucle de i = 0 à k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Oui" --> RandomA["Choisir un entier aléatoire a dans la plage 1 < a < p-1"] RandomA --> Calc["Calculer l'exponentiation modulaire a^(p-1) mod p"] Calc --> CheckPrime{"Le résultat est-il 1 ?"} CheckPrime -- "Non" --> ReturnComposite["p est un nombre composé (certain)"] CheckPrime -- "Oui" --> Increment["Incrémenter i"] Increment --> Condition Condition -- "Non" --> ReturnPrime["p est probablement premier (probabiliste)"] ReturnComposite --> End["Fin"] ReturnPrime --> End

5.3 Le piège des nombres de Carmichael (pseudo-premiers)

Bien que le test de Fermat soit extrêmement rapide, il présente un défaut majeur. Il existe des nombres diaboliques qui, bien qu’ils soient composés, satisfont $a^{N-1} \equiv 1 \pmod N$ pour tous les $a$. Ceux-ci sont appelés nombres de Carmichael (Carmichael numbers). Le plus petit nombre de Carmichael est $561$ ($3 \times 11 \times 17$).

En raison de l’existence des nombres de Carmichael, un test de Fermat pur seul ne peut pas déterminer la primalité de manière absolue. C’est pourquoi, dans les systèmes cryptographiques réels (comme OpenSSL), le test de primalité de Miller-Rabin (Miller-Rabin primality test), qui est une version améliorée du test de Fermat, est utilisé en standard. Le test de Miller-Rabin peut détecter les nombres de Carmichael, réduisant ainsi la probabilité de fausse détection à presque zéro.

5.4 Exponentiation modulaire rapide (Méthode d’exponentiation par carrés)

Dans l’algorithme de test de primalité, il est nécessaire de calculer $a^{N-1} \pmod N$. Si $N$ est énorme, $a^{N-1}$ aura un nombre de chiffres astronomique et ne tiendra pas dans la mémoire d’un ordinateur. La solution à ce problème est la méthode d’exponentiation par carrés (Exponentiation by Squaring) ou exponentiation modulaire. En prenant le modulo (mod N) à chaque étape du calcul, la valeur est toujours maintenue plus petite que $N$, ce qui permet un calcul très rapide (complexité temporelle $O(\log N)$).

6. Implémentation du test de primalité et de l’exponentiation modulaire

Maintenant, implémentons le test de primalité de Fermat et la méthode d’exponentiation par carrés en C++ et Python.

6.1 Implémentation en C++

En C++, les types d’entiers standard ont tendance à déborder facilement, donc une bibliothèque d’entiers à précision multiple (comme GMP) est nécessaire pour manipuler des nombres géants. Cependant, pour comprendre l’algorithme, nous montrons ici une implémentation dans la limite des entiers 64 bits (unsigned long long).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// Exponentiation modulaire rapide (a^b mod m) - Exponentiation par carrés
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Si le bit de poids faible de b est 1, multiplier le résultat par a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Extension en 128 bits pour éviter le débordement
 }
 // Élever a au carré
 a = (__int128)a * a % m;
 // Décaler b vers la droite (diviser par la moitié)
 b /= 2;
 }
 return result;
}

// Test de primalité de Fermat
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Si a^(p-1) mod p n'est pas 1, alors c'est un nombre composé
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Probablement premier
}

int main() {
 unsigned long long num = 1000000007; // Nombre premier connu
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Implémentation en Python

En Python, le type entier standard prend en charge les entiers à précision multiple, il n’y a donc pas besoin de s’inquiéter du débordement. De plus, la fonction intégrée pow(a, b, m) de Python utilise l’exponentiation par carrés en interne et est très rapide.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 Test de primalité probabiliste utilisant le test de Fermat
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Choisir un nombre aléatoire a entre 2 et p-2
 a = random.randint(2, p - 2)
 # Calculer a^(p-1) mod p. La fonction intégrée pow est rapide.
 if pow(a, p - 1, p) != 1:
 return False # Certitude que c'est un nombre composé

 return True # Probablement premier

# Test
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} est probablement premier.")
else:
 print(f"{number_to_test} est un nombre composé.")

7. Application au chiffrement RSA : Où Fermat et Euler se rencontrent

La plus grande application du petit théorème de Fermat (et du théorème d’Euler) est le chiffrement RSA, développé en 1977 par Rivest, Shamir et Adleman. Le chiffrement RSA est un système révolutionnaire de “cryptographie à clé publique”, qui réalise un mécanisme où la clé de chiffrement (clé publique) est rendue publique au monde entier, tandis que la clé de déchiffrement (clé privée) n’est connue que du destinataire.

Cette asymétrie repose sur la sécurité computationnelle selon laquelle “la factorisation en nombres premiers de nombres composés géants est extrêmement difficile”.

7.1 Fonctionnement du chiffrement RSA (Génération de clés, Chiffrement, Déchiffrement)

Vérifions le flux de communication global du chiffrement RSA avec un diagramme de séquence Mermaid.

sequenceDiagram participant Alice["Alice (Destinataire)"] participant Bob["Bob (Expéditeur)"] Alice->>Alice: "Générer d'énormes nombres premiers p, q" Alice->>Alice: "Calculer N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Calculer la clé publique e et la clé privée d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Envoyer la clé publique (N, e)" Note over Bob: "Préparer le texte clair M (M < N)" Bob->>Bob: "Calculer le texte chiffré C = M^e mod N" Bob->>Alice: "Envoyer le texte chiffré C" Alice->>Alice: "Calculer le texte clair M = C^d mod N pour déchiffrer"

Voici une explication des étapes mathématiques détaillées.

Étape 1 : Génération de clés (Travail du destinataire Alice)

Générer aléatoirement deux énormes nombres premiers $p$ et $q$ (c’est là que la méthode de test de primalité mentionnée ci-dessus est utilisée).
Calculer leur produit $N = p \times q$. Ce $N$ est rendu public.
En utilisant la fonction indicatrice d’Euler, calculer $\phi(N) = (p-1)(q-1)$.
Choisir un entier $e$ (exposant public) qui est premier avec $\phi(N)$ (souvent $e = 65537$ est utilisé).
Calculer l’inverse modulaire $d$ (exposant privé) de $e$. C’est-à-dire, trouver $d$ qui satisfait ce qui suit : $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ L’algorithme d’Euclide étendu est utilisé pour ce calcul.

La clé publique est maintenant $(N, e)$ et la clé privée est $(N, d)$. ($p$, $q$, et $\phi(N)$ doivent être immédiatement détruits ou strictement dissimulés).

Étape 2 : Chiffrement (Travail de l’expéditeur Bob)

Supposons que Bob veuille envoyer un message $M$ à Alice ($M$ est la version numérisée des caractères, avec $0 \le M < N$). Bob utilise la clé publique d’Alice $(N, e)$ pour effectuer le calcul suivant et créer le texte chiffré $C$.

$$ C \equiv M^e \pmod N $$

Ce $C$ est envoyé à Alice via le réseau.

Étape 3 : Déchiffrement (Travail du destinataire Alice)

Alice, après avoir reçu le texte chiffré $C$, effectue le calcul suivant en utilisant sa clé privée $d$, qu’elle seule connaît.

$$ M' \equiv C^d \pmod N $$

Étonnamment, ce résultat de calcul $M'$ correspond parfaitement au message original $M$.

7.2 Pourquoi cela peut-il être déchiffré ? (Preuve mathématique)

C’est ici que le petit théorème de Fermat (le théorème d’Euler) montre sa véritable valeur. Pourquoi $C^d \pmod N$ revient-il à $M$ ?

Développons la formule de déchiffrement. Puisque $C \equiv M^e \pmod N$,

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Lors de l’étape de génération de clés, nous avons choisi $d$ de sorte que $e \cdot d \equiv 1 \pmod{\phi(N)}$. Cela signifie qu’il existe un entier $k$ tel qu’il peut s’écrire comme suit :

$$ e \cdot d = 1 + k \cdot \phi(N) $$

En substituant cela dans la formule ci-dessus :

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

Ici, le théorème d’Euler ($M^{\phi(N)} \equiv 1 \pmod N$) entre en jeu. (Strictement parlant, $M$ et $N$ doivent être premiers entre eux, mais dans RSA, la probabilité que $M$ et $N$ ne soient pas premiers entre eux est astronomiquement faible, et en utilisant le théorème des restes chinois, il peut être prouvé que cela est vrai même s’ils ne sont pas premiers entre eux).

En appliquant le théorème d’Euler, puisque $M^{\phi(N)} \equiv 1$,

$$ M \cdot (1)^k \equiv M \pmod N $$

$M$ est magnifiquement restauré ! Les propriétés des nombres que Fermat et Euler ont découvertes il y a des centaines d’années garantissent parfaitement la confidentialité des communications numériques modernes.

8. Implémentation jouet du chiffrement RSA (Python)

Comme il est difficile de saisir cela uniquement en théorie, utilisons Python pour implémenter réellement le processus de génération de clés, de chiffrement et de déchiffrement RSA. Bien qu’il s’agisse d’une “implémentation jouet” à des fins éducatives, les mathématiques utilisées sont exactement les mêmes que les vraies.

Nous inclurons également une implémentation de “l’algorithme d’Euclide étendu” pour trouver l’inverse modulaire $d$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# Trouver le plus grand commun diviseur
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Algorithme d'Euclide étendu (trouver x, y pour ax + by = gcd(a,b))
# Utilisé pour trouver d pour e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception("L'inverse n'existe pas")
 else:
 return x % phi

# Fonction de génération de nombres premiers (Version simplifiée : génère de petits nombres premiers)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Jugement simplifié au lieu du test de Fermat mentionné ci-dessus
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Génération de clés RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # S'assurer que p et q ne sont pas identiques
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e est souvent un nombre premier comme 65537, mais ici il est choisi aléatoirement
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Calcul de la clé privée d
 d = mod_inverse(e, phi)

 # Clé publique (e, n), Clé privée (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Calculer plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Calculer cipher^d mod n et reconvertir en caractères
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Exemple d'exécution
if __name__ == '__main__':
 print("--- Implémentation jouet du chiffrement RSA ---")
 public_key, private_key = generate_keypair(bits=12) # Utilisation de nombres premiers de 12 bits

 print(f"Clé publique (e, n): {public_key}")
 print(f"Clé privée (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nMessage d'origine : {message}")

 # Chiffrement
 encrypted_msg = encrypt(public_key, message)
 print(f"Texte chiffré : {encrypted_msg}")

 # Déchiffrement
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Message déchiffré : {decrypted_msg}")

Lorsque vous exécutez ce code, vous pouvez voir le tableau de caractères être converti en un tableau de nombres peu familiers (texte chiffré), qui est ensuite magnifiquement restauré en la chaîne d’origine par la clé privée.

9. Conclusion : L’intersection de la beauté mathématique et de la praticité

Au 17ème siècle, lorsque Pierre de Fermat a découvert ce “petit théorème”, personne ne pensait qu’il serait utile à quoi que ce soit. Fermat lui-même a mené des recherches en théorie des nombres par pure curiosité mathématique.

Cependant, environ 300 ans plus tard, dans les années 1970, à l’aube des réseaux informatiques, le théorème de Fermat a fait un retour spectaculaire en tant que technologie cryptographique essentielle pour l’établissement de protocoles de communication sécurisés. La technologie de test de primalité basée sur le petit théorème de Fermat et le chiffrement RSA basé sur le théorème d’Euler soutiennent littéralement l’infrastructure Internet moderne.

Les messages LINE que nous envoyons nonchalamment tous les jours, les achats sur Amazon, tout cela danse sur cette belle et simple formule $a^{p-1} \equiv 1 \pmod p$. Le petit théorème de Fermat nous enseigne que peu importe à quel point les mathématiques peuvent être abstraites, le moment viendra toujours où elles seront utiles à l’humanité.

Dans l’apprentissage de la programmation et de la théorie cryptographique, comprendre les structures mathématiques à la base de celles-ci sera une arme puissante pour comprendre en profondeur le comportement des bibliothèques fournies sous forme de boîtes noires et pour concevoir des systèmes plus sécurisés.

L'intuition mathématique de la cryptographie basée sur les réseaux (Lattice-based cryptography)

Fri, 11 Sep 2026 21:00:00 +0900

1. Introduction : L’aube de la cryptographie post-quantique (PQC) et l’essor de la cryptographie basée sur les réseaux

L’infrastructure numérique de la société moderne repose sur des technologies de cryptographie à clé publique telles que le chiffrement RSA et la cryptographie sur les courbes elliptiques (ECC). Ces méthodes cryptographiques basent leur sécurité sur la difficulté mathématique de problèmes tels que le “problème de la factorisation en nombres premiers” ou le “problème du logarithme discret”, qui sont considérés comme impossibles à résoudre efficacement (nécessitant un temps exponentiel) par les ordinateurs classiques conventionnels.

Cependant, en 1994, l’algorithme de Shor, publié par Peter Shor, a provoqué une onde de choc dans le monde de la cryptographie. Cet algorithme a prouvé mathématiquement qu’une fois qu’un ordinateur quantique à grande échelle sera réalisé, il pourra résoudre les problèmes de factorisation en nombres premiers et de logarithme discret en un temps polynomial. Cela signifie que la cryptographie à clé publique largement utilisée aujourd’hui deviendra complètement décryptable à l’avenir.

Pour contrer cette “menace quantique (Quantum Threat)”, il est devenu urgent de rechercher de nouvelles méthodes cryptographiques difficiles à décrypter, même avec un ordinateur quantique. C’est le domaine appelé “Cryptographie Post-Quantique (Post-Quantum Cryptography : PQC)” ou “Cryptographie résistante aux ordinateurs quantiques”.

Il existe plusieurs candidats prometteurs pour la PQC, tels que la cryptographie basée sur les fonctions de hachage, sur les codes, sur des polynômes multivariés et sur les isogénies. Parmi eux, celle qui attire actuellement le plus l’attention et qui est au cœur du processus de standardisation PQC par le NIST (Institut national des normes et de la technologie des États-Unis) est la “cryptographie basée sur les réseaux (Lattice-based cryptography)”. Comparée à d’autres méthodes, la cryptographie basée sur les réseaux se distingue par une vitesse de traitement très élevée pour le chiffrement et le déchiffrement. De plus, elle possède une caractéristique remarquable en théorie cryptographique : une preuve de sécurité extrêmement solide basée sur la réduction de la “complexité dans le pire des cas (Worst-case complexity)” à la “complexité en moyenne (Average-case complexity)”.

Dans cet article, nous partirons de la définition mathématique du “réseau (Lattice)” qui est à la base de cette cryptographie, pour expliquer en profondeur les problèmes difficiles sur les réseaux tels que le SVP (Problème du vecteur le plus court) et le CVP (Problème du vecteur le plus proche), ainsi que le problème LWE (Learning With Errors) qui est le cœur de la cryptographie moderne sur les réseaux. Nous utiliserons des formules mathématiques, des intuitions géométriques et des exemples numériques concrets.

2. Définition mathématique et intuition géométrique du réseau (Lattice)

2.1 Espace vectoriel et réseau

En mathématiques, un “réseau (Lattice)” est un ensemble de points discrets disposés de manière régulière dans un espace vectoriel réel à $n$ dimensions $\mathbb{R}^n$. Il ressemble à un espace vectoriel (Vector Space) étudié en algèbre linéaire, mais il présente une différence cruciale. Alors qu’un espace vectoriel est un espace continu représenté par des combinaisons linéaires de vecteurs de base avec des “coefficients réels”, un réseau est un espace discret représenté par des combinaisons linéaires de vecteurs de base avec des “coefficients entiers”.

Donnons une définition mathématique rigoureuse. Considérons $n$ vecteurs linéairement indépendants ($n \le m$) $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ dans un espace vectoriel réel à $m$ dimensions $\mathbb{R}^m$. La matrice dont les colonnes sont ces vecteurs est notée $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. On appelle $B$ la “base (Basis)” du réseau.

Le réseau $\mathcal{L}(B)$ généré par cette base $B$ est défini comme suit :

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

Ce qui est important ici, c’est que les coefficients $x_i$ sont restreints aux entiers $\mathbb{Z}$ et non aux nombres réels $\mathbb{R}$. Par conséquent, au lieu de former un nombre infini de points continus dans l’espace, cela forme un “ensemble de points discrets” semblables à des intersections espacées uniformément.

2.2 Image géométrique

Considérons l’exemple du plan bidimensionnel $\mathbb{R}^2$. Si nous choisissons les vecteurs de base $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ et $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$, le réseau généré par ceux-ci est l’ensemble de toutes les coordonnées entières $(x, y) \in \mathbb{Z}^2$ sur le plan cartésien. C’est le “réseau carré” le plus simple.

Cependant, les réseaux ne sont pas toujours orthogonaux. Par exemple, si nous considérons la base $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ et $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, les points générés ressembleront aux intersections d’une maille déformée en biais.

2.3 Non-unicité de la base et transformation unimodulaire

Il existe une propriété importante liée au fondement de la sécurité de la cryptographie sur les réseaux : “Il existe une infinité de bases qui génèrent le même réseau”.

Par exemple, la base $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ qui génère le réseau $\mathbb{Z}^2$, génère exactement le même réseau $\mathbb{Z}^2$ si nous utilisons la base $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$.

Une condition nécessaire et suffisante pour qu’une base $B$ et une autre base $B'$ génèrent le même réseau est l’existence d’une matrice à coefficients entiers $U \in \mathbb{Z}^{n \times n}$ avec un déterminant $\det(U) = \pm 1$, telle que

$$ B' = B U $$

Une telle matrice $U$ est appelée “matrice unimodulaire (Unimodular matrix)”.

L’idée fondamentale dans son application à la cryptographie est d’utiliser une “bonne base (une base proche de l’orthogonalité, composée de vecteurs courts)” comme clé privée, et une “mauvaise base (une base avec des vecteurs extrêmement obliques les uns par rapport aux autres et très longs)” comme clé publique. Calculer une bonne base à partir d’une mauvaise base devient extrêmement difficile à mesure que la dimension augmente. C’est l’intuition fondamentale de la cryptographie basée sur les réseaux.

3. Problèmes mathématiquement difficiles dans les réseaux

La sécurité de la cryptographie basée sur les réseaux repose sur la difficulté de résoudre certains problèmes mathématiques sur les réseaux. Nous présentons ici les deux problèmes les plus fondamentaux et célèbres.

3.1 Problème du vecteur le plus court (Shortest Vector Problem: SVP)

Le SVP est le problème le plus classique et célèbre de la théorie des réseaux.

Définition (SVP) : Étant donné une base de réseau arbitraire $B$, trouver le vecteur $\mathbf{v}$ non nul appartenant à ce réseau $\mathcal{L}(B)$ qui a la norme euclidienne (longueur) minimale.

Mathématiquement, c’est le problème de trouver $\mathbf{v}$ tel que $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Cette longueur minimale est notée $\lambda_1(\mathcal{L})$ et est appelée le “premier minimum successif (First successive minimum) du réseau”.

En basse dimension, comme en 2 ou 3 dimensions, vous pouvez trouver le vecteur le plus court à l’œil nu en dessinant un graphique, ou bien le résoudre efficacement en utilisant l’algorithme de réduction de base de Gauss. Cependant, lorsque la dimension $n$ atteint des centaines ou des milliers de dimensions, il est connu que résoudre strictement le SVP est un problème NP-difficile.

Dans les systèmes cryptographiques réels, on utilise le SVP approché ($\gamma$-SVP), qui consiste à trouver un “vecteur approximativement court” au lieu du vecteur strictement le plus court. Lorsque le facteur d’approximation $\gamma$ est de taille polynomiale, ce problème est toujours considéré comme extrêmement difficile.

3.2 Problème du vecteur le plus proche (Closest Vector Problem: CVP)

Le CVP est également un problème extrêmement important dans la cryptographie sur les réseaux.

Définition (CVP) : Étant donné une base de réseau arbitraire $B$ et un vecteur cible arbitraire $\mathbf{t} \in \mathbb{R}^m$ dans l’espace (qui n’est pas nécessairement un point du réseau), trouver le point du réseau $\mathbf{v} \in \mathcal{L}(B)$ qui est le plus proche de $\mathbf{t}$.

Mathématiquement, c’est le problème de trouver un point du réseau $\mathbf{v}$ tel que $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

Le CVP, tout comme le SVP, est NP-difficile en haute dimension. Du point de vue des applications cryptographiques, le problème LWE décrit ci-dessous est étroitement lié à une variante spéciale de ce CVP (Bounded Distance Decoding: BDD).

3.3 Pourquoi est-il impossible de les résoudre en haute dimension ? (Limites de LLL et BKZ)

L’algorithme LLL (algorithme de Lenstra-Lenstra-Lovász) est un algorithme célèbre pour résoudre les problèmes de réseau en haute dimension. L’algorithme LLL fonctionne en temps polynomial et peut réduire (Reduction) la base du réseau en une “bonne base” dans une certaine mesure. Cependant, le vecteur le plus court que l’algorithme LLL peut trouver a un facteur d’approximation exponentiel ($2^{\mathcal{O}(n)}$) par rapport à la longueur du vrai vecteur le plus court, ce qui ne suffit pas pour briser la sécurité de la cryptographie.

En utilisant des algorithmes de réduction de base plus puissants comme l’algorithme BKZ (Block Korkine-Zolotarev), qui est une amélioration de LLL, il est possible de trouver des vecteurs plus courts, mais la complexité de calcul augmente de manière exponentielle par rapport à la taille du bloc. Dans la cryptographie sur les réseaux, des paramètres de sécurité (comme la taille de la dimension $n$) sont déterminés en estimant le temps d’exécution de cet algorithme BKZ. Avec les paramètres standard actuels de la PQC, la dimension $n$ est choisie avec des valeurs de 500 à plus de 1000, et on estime qu’il faudrait un temps supérieur à l’âge de l’univers pour la déchiffrer, même avec des superordinateurs ou de futurs ordinateurs quantiques.

4. Formulation mathématique du problème LWE (Learning With Errors)

La majeure partie de la cryptographie moderne sur les réseaux est basée sur le “problème LWE (Learning With Errors)” proposé par Oded Regev en 2005. La beauté du problème LWE réside dans la simplicité de sa formulation et dans sa solide preuve mathématique basée sur “la réduction de la complexité dans le pire des cas à la complexité en moyenne”.

4.1 Système d’équations linéaires sans bruit

Pour comprendre le problème LWE, considérons d’abord un simple système d’équations linéaires sans bruit. Supposons qu’il existe un vecteur secret inconnu $\mathbf{s} \in \mathbb{Z}_q^n$ (chaque composante est un entier de $0$ à $q-1$). Ici, $q$ est un nombre premier.

Nous choisissons des vecteurs de coefficients aléatoires $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ et calculons le produit scalaire avec le vecteur secret $\mathbf{s}$ modulo $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Si l’on nous donne un nombre suffisant (plus de $n$) de paires $(\mathbf{a}_i, b_i)$, nous pouvons facilement restaurer le vecteur secret $\mathbf{s}$ en utilisant l’“élimination de Gauss (Gaussian elimination)” en algèbre linéaire. C’est un problème qui peut être facilement résolu en temps polynomial.

4.2 Définition du problème LWE : Ajout de bruit

Alors, que se passe-t-il si nous ajoutons un léger “bruit (erreur)” à ce problème ? C’est là l’essence du problème LWE.

Pour un vecteur secret inconnu $\mathbf{s} \in \mathbb{Z}_q^n$, nous ajoutons une petite erreur $e_i \in \mathbb{Z}_q$ au résultat de chaque équation. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Ici, $e_i$ est une petite valeur entière dont la moyenne est 0 et l’écart-type est relativement faible (par exemple, choisie à partir d’une distribution gaussienne discrète, similaire à une distribution normale). L’information fournie est une liste de paires de vecteurs aléatoires $\mathbf{a}_i$ et de $b_i$ calculés en ajoutant l’erreur. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

C’est beaucoup plus clair lorsqu’on l’exprime sous forme de matrice. En utilisant une matrice aléatoire $A \in \mathbb{Z}_q^{m \times n}$, un vecteur secret $\mathbf{s} \in \mathbb{Z}_q^n$, et un vecteur d’erreur $\mathbf{e} \in \mathbb{Z}_q^m$, on peut écrire :

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

Seuls $A$ et $\mathbf{b}$ sont fournis. Le “problème de recherche LWE (Search LWE problem)” consiste à trouver $\mathbf{s}$ à partir de cela.

Puisque l’erreur $e_i$ est introduite, si l’on essaie d’utiliser l’élimination de Gauss, l’erreur s’amplifiera de manière exponentielle lors de l’addition et de la soustraction d’équations, et il deviendra impossible d’arriver à la bonne réponse. À première vue, cela ressemble à un simple système d’équations linéaires, mais l’ajout de ce petit bruit fait bondir le niveau de difficulté au stade NP-difficile.

4.3 Problème de décision LWE (Decision LWE)

Une variante du problème de recherche LWE, appelée “problème de décision LWE (Decision LWE problem)”, est fréquemment utilisée dans les preuves en théorie cryptographique.

Le problème de décision LWE est le problème de déterminer, étant donné une liste d’échantillons obtenus à partir des deux distributions suivantes, de quelle distribution elle provient.

Distribution LWE : $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$ calculé intentionnellement.
Distribution aléatoire uniforme : $(A, \mathbf{u})$ constitué d’une matrice $A$ et d’un vecteur $\mathbf{u}$ choisis de manière totalement aléatoire.

Étonnamment, si les paramètres du problème LWE sont choisis de manière appropriée, les paires obtenues à partir de la distribution LWE deviennent “informatiquement indiscernables (Computationally Indistinguishable)” des paires de données totalement aléatoires. Cette propriété est la raison pour laquelle la cryptographie basée sur LWE peut générer “un texte chiffré indiscernable de nombres aléatoires”.

4.4 Réduction de la complexité du pire des cas à la complexité en moyenne (Théorème de Regev)

La plus grande réalisation d’Oded Regev a été de lier mathématiquement la difficulté de ce problème LWE à la difficulté des problèmes de réseaux susmentionnés (SVP et CVP).

En utilisant la réduction quantique (Quantum reduction), il a prouvé que “s’il existe un algorithme en temps polynomial capable de résoudre le problème LWE en moyenne (pour des $A$ et $\mathbf{e}$ choisis aléatoirement), alors il existe un algorithme quantique en temps polynomial capable de résoudre le Gap-SVP pour le pire des cas (le cas le plus difficile) de n’importe quel réseau.” (Plus tard, une réduction classique a également été démontrée par Peikert et al.).

C’est une propriété de rêve en théorie cryptographique. En effet, elle dissipe la crainte que “la cryptographie puisse être brisée parce que nous avons peut-être choisi par hasard une clé faible (une partie du cas moyen)”, et fournit la puissante garantie que “si le LWE moyen peut être résolu, alors tous les problèmes difficiles des réseaux peuvent être résolus (donc LWE est absolument difficile)”.

graph TD A["Problèmes de réseau dans le pire des cas (Gap-SVP, SIVP)"] -->|Réduction quantique/classique| B["Problème LWE en moyenne"] B -->|Construction cryptographique| C["Systèmes cryptographiques basés sur LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Construction du cryptosystème à clé publique basé sur LWE (Cryptosystème de Regev)

Maintenant que nous avons compris la difficulté du problème LWE, examinons le cryptosystème à clé publique de base proposé par Oded Regev pour voir comment il est utilisé pour le chiffrement et le déchiffrement. Nous expliquerons ici le mécanisme le plus fondamental de chiffrement d’un message d’un bit $M \in \{0, 1\}$.

5.1 Génération de clé (Key Generation)

En tant que paramètres du système, déterminez le module premier $q$, la dimension $n$, et le nombre d’équations $m$ ($m > n \log q$).
En tant que clé privée, choisissez aléatoirement un vecteur $\mathbf{s} \in \mathbb{Z}_q^n$.
Générez une matrice aléatoire $A \in \mathbb{Z}_q^{m \times n}$.
Choisissez un petit vecteur d’erreur $\mathbf{e} \in \mathbb{Z}_q^m$ à partir d’une distribution d’erreur telle que la distribution gaussienne discrète.
Calculez le vecteur $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
La clé publique (Public Key) sera $(A, \mathbf{b})$.
La clé secrète (Secret Key) sera $\mathbf{s}$.

La clé publique est littéralement une “instance du problème LWE”. Puisque trouver la clé secrète $\mathbf{s}$ à partir de la clé publique $(A, \mathbf{b})$ équivaut à résoudre le problème de recherche LWE, la sécurité est garantie.

5.2 Chiffrement (Encryption)

Alice utilise la clé publique de Bob $(A, \mathbf{b})$ pour chiffrer un message d’un bit $M \in \{0, 1\}$.

Choisissez un vecteur binaire aléatoire (dont les composantes sont 0 ou 1) $\mathbf{r} \in \{0, 1\}^m$.
Comme première partie du texte chiffré, calculez le vecteur $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ est la matrice transposée de $A$. C’est-à-dire que nous additionnons les lignes de $A$ dont la composante correspondante de $\mathbf{r}$ est 1).
Comme deuxième partie du texte chiffré, calculez le scalaire $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Si le message $M$ est 0, n’ajoutez rien ; s’il est $1$, ajoutez exactement la moitié de $q$, soit $\lfloor \frac{q}{2} \rfloor$).
Le texte chiffré (Ciphertext) sera $(\mathbf{u}, v)$.

L’intuition derrière le chiffrement est de prendre la “somme d’un sous-ensemble aléatoire” par rapport à la matrice $A$ et au vecteur $\mathbf{b}$ de la clé publique. En raison de la difficulté du problème de décision LWE, ce texte chiffré $(\mathbf{u}, v)$ semble indiscernable de vecteurs totalement aléatoires et de nombres uniformément aléatoires (Sécurité sémantique : Semantic Security).

flowchart LR M["Message M dans {0,1}"] --> Enc PK["Clé publique (A, b)"] --> Enc r["Vecteur binaire aléatoire r"] --> Enc subgraph Enc ["Processus de chiffrement"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Texte chiffré (u, v)"]

5.3 Déchiffrement (Decryption)

Bob déchiffre le texte chiffré $(\mathbf{u}, v)$ en utilisant sa clé secrète $\mathbf{s}$.

Calculez la valeur suivante : $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Si le résultat calculé est proche de $0$, le message est de $M=0$, s’il est proche de $\lfloor \frac{q}{2} \rfloor$, le message est de $M=1$.

Montrons mathématiquement pourquoi cela permet le déchiffrement. Rappelez-vous que $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Ici, le terme $\mathbf{s}^T A^T \mathbf{r}$ s’est parfaitement annulé et a disparu de l’équation ! Ce qui reste, c’est $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ est un vecteur de bruit dont les composantes sont très petites, et $\mathbf{r}$ est un vecteur binaire dont les composantes sont 0 ou 1. Par conséquent, leur produit scalaire $\mathbf{e}^T \mathbf{r}$ restera également une valeur relativement faible (si les paramètres sont choisis de manière appropriée).

Si $M=0$, le résultat sera $\mathbf{e}^T \mathbf{r}$, qui est une petite valeur proche de $0$.
Si $M=1$, le résultat sera $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, qui sera situé autour de la moitié de $q$, soit $\lfloor \frac{q}{2} \rfloor$.

Si les paramètres sont conçus de sorte que la valeur absolue de l’erreur $\mathbf{e}^T \mathbf{r}$ soit inférieure à $\frac{q}{4}$, Bob peut déterminer (déchiffrer) avec précision le message $M$ en regardant simplement si le résultat du calcul est plus proche de $0$ ou de $\lfloor \frac{q}{2} \rfloor$. C’est le mécanisme élégant par lequel la cryptographie basée sur LWE fonctionne.

flowchart LR CT["Texte chiffré (u, v)"] --> Dec SK["Clé secrète s"] --> Dec subgraph Dec ["Processus de déchiffrement"] direction TB calc["Calculer D = v - s^T * u mod q"] check["Vérifier si D est plus proche de 0 ou de q/2"] end calc --> check Dec --> M_out["Message récupéré M"]

6. Exemple jouet (Toy Example) de chiffrement LWE avec des valeurs numériques spécifiques

Il est difficile de comprendre seulement avec une liste de formules mathématiques, alors établissons des paramètres numériques très petits et suivons les calculs du chiffrement au déchiffrement. (* Dans un système cryptographique réel, pour assurer la sécurité, $n$ est de 500 ou plus et $q$ est de plusieurs milliers).

【Paramétrage】

Module $q = 17$ (Un nombre premier. Les valeurs seront donc de $0$ à $16$).
Dimension $n = 2$
Nombre d’équations $m = 4$
Supposons que nous chiffrons le message $M = 1$.
Montant du décalage du message : $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

【1. Phase de génération de clé】 Bob choisit aléatoirement une clé secrète $\mathbf{s}$, une matrice $A$, et un vecteur d’erreur $\mathbf{e}$.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Ensuite, calculez la clé publique $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Nous calculons cela modulo 17. (par exemple, $66 = 17 \times 3 + 15$)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Ajoutez le vecteur d’erreur $\mathbf{e}$.

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

La clé publique est $A$ et $\mathbf{b} = (16, 0, 11, 1)^T$.

【2. Phase de chiffrement】 Alice chiffre le message $M = 1$. Choisissez un vecteur aléatoire $\mathbf{r}$. Ici, supposons $\mathbf{r} = (1, 0, 1, 0)^T$.

Calculez $\mathbf{u}$.

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Calculez $v$.

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Ajoutez la valeur $\lfloor 17/2 \rfloor = 8$ correspondant au message $M=1$.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Alice envoie le texte chiffré $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ à Bob.

【3. Phase de déchiffrement】 Après avoir reçu le texte chiffré, Bob le déchiffre en utilisant la clé secrète $\mathbf{s} = (3, 4)^T$. Formule de déchiffrement : calculez $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Ici, dans le monde modulo 17, $-8$ est égal à $9$ ($-8 + 17 = 9$). Déterminez si la valeur obtenue $D = 9$ est plus proche de $0$ ou de $8$ ($\lfloor 17/2 \rfloor$). Étant donné que $9$ est clairement plus proche de $8$ que de $0$, Bob a pu restaurer correctement $M = 1$ !

Pourquoi est-ce devenu $9$ ? Rappelons la preuve précédente. La partie d’erreur est $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Par conséquent, le résultat du calcul est $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, et il est confirmé que la valeur théorique a été calculée.

7. Évolution vers une application pratique : Ring-LWE et Module-LWE

Le problème LWE standard (Standard LWE) expliqué jusqu’à présent possède une preuve de sécurité très solide, mais présente un défaut fatal dans la pratique. C’est “la taille énorme de la clé” et le “coût de calcul élevé”.

Dans le Standard LWE, la clé publique contient une énorme matrice $A \in \mathbb{Z}_q^{m \times n}$. Lorsque le paramètre $n$ atteint des centaines ou des milliers, la taille de cette matrice atteint plusieurs mégaoctets, ce qui est trop lourd pour être envoyé et reçu à chaque fois dans les protocoles de communication Internet (tels que TLS). De plus, la multiplication d’une matrice et d’un vecteur nécessite une complexité de calcul de $\mathcal{O}(n^2)$.

Pour résoudre ce problème, on a introduit “Ring-LWE (RLWE)” et “Module-LWE (MLWE)”, qui intègrent une structure algébrique appelée anneaux de polynômes (Polynomial rings) dans le réseau.

7.1 Intuition de Ring-LWE

Dans Ring-LWE, les vecteurs et les matrices sont remplacés par des éléments (polynômes) sur l’anneau de polynômes $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Ici, $n$ est choisi comme une puissance de 2).

Alors que la clé publique de Standard LWE était la matrice $A$, Ring-LWE utilise un seul polynôme $a(x)$. La clé secrète $s(x)$ et l’erreur $e(x)$ deviennent également des polynômes. L’équation est la suivante :

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Comme il s’agit d’une multiplication de polynômes, la complexité de calcul peut être considérablement réduite à $\mathcal{O}(n \log n)$ en utilisant la “Transformation Numérique Théorique (Number Theoretic Transform: NTT)”, qui est similaire à la Transformation de Fourier Rapide (FFT). De plus, puisque la taille de la clé publique est également réduite d’une matrice à un seul polynôme, la taille des données est réduite à $\mathcal{O}(n)$. Cela apporte un avantage écrasant en termes de bande passante de communication.

D’un point de vue mathématique, Ring-LWE ne repose pas sur un réseau général, mais se réduit à un problème sur un réseau doté d’une symétrie spéciale appelé “réseau idéal (Ideal Lattice)”.

7.2 Module-LWE et normalisation du NIST (Kyber / ML-KEM)

Ring-LWE est efficace, mais il y avait quelques inquiétudes quant au fait que la structure algébrique spéciale du réseau idéal puisse devenir un indice pour de futures attaques. Ainsi, le “Module-LWE (MLWE)” a été créé en prenant le meilleur des deux mondes : la sécurité conservatrice de Standard LWE et l’efficacité de Ring-LWE.

Dans Module-LWE, nous considérons de petites matrices et des vecteurs dont les éléments sont des polynômes. En d’autres termes, nous traitons des modules sur l’anneau. Actuellement, “CRYSTALS-Kyber” (nom standardisé : ML-KEM), qui a été sélectionné par le NIST comme norme pour l’algorithme d’échange de clés PQC (KEM), est construit précisément sur la difficulté de ce problème Module-LWE.

8. Pourquoi est-ce sûr face aux ordinateurs quantiques ?

Enfin, abordons le point essentiel : “Pourquoi considère-t-on que la cryptographie basée sur les réseaux ne sera pas brisée même avec des ordinateurs quantiques ?”

L’algorithme de Shor, grâce auquel les ordinateurs quantiques brisent le chiffrement RSA et la cryptographie sur les courbes elliptiques, est essentiellement un algorithme qui résout le “problème du sous-groupe caché (Hidden Subgroup Problem: HSP)”. La structure mathématique derrière RSA et ECC (groupes abéliens finis) présente une périodicité, et en utilisant une opération spécifique à l’algorithme quantique appelée Transformée de Fourier Quantique (QFT), cette période (le sous-groupe caché) peut être extraite en une seule fois.

Cependant, les problèmes de réseaux sont fondamentalement différents. Bien que les réseaux aient également une périodicité, ce qui est requis dans SVP et CVP sont des propriétés géométriques non linéaires telles que “la distance la plus courte” ou “la suppression du bruit”. Même si nous appliquons la “Transformée de Fourier quantique sur un groupe abélien” comme l’algorithme de Shor tel quel, nous ne pouvons pas extraire efficacement les informations utiles qui seraient la solution au problème du réseau. Jusqu’à présent, aucun algorithme quantique capable de résoudre SVP ou LWE en temps polynomial n’a été découvert, et on croit largement que même avec la capacité de calcul parallèle des ordinateurs quantiques, seuls des moyens de résolution proches d’une recherche par force brute (une accélération de l’ordre de la racine carrée grâce à l’algorithme de Grover) sont valables.

9. Conclusion

Dans cet article, nous avons expliqué en détail l’intuition mathématique de la cryptographie sur les réseaux, en commençant par la définition géométrique du réseau, la formulation du problème LWE, et jusqu’à la construction d’une cryptographie à clé publique.

Le réseau (Lattice) est un espace discret représenté par des combinaisons linéaires à coefficients entiers de vecteurs de base, et il devient difficile de trouver une “bonne base” proche de l’orthogonalité dans les dimensions élevées (SVP).
Le problème LWE (Learning With Errors) est le problème de la résolution d’équations linéaires simultanées avec du bruit, ce qui est lié à la difficulté du problème du pire cas du réseau, fournissant ainsi une base solide de sécurité.
En utilisant le problème LWE, le chiffrement et le déchiffrement (Cryptosystème de Regev) sont réalisés grâce à un mécanisme ingénieux d’ajout et de suppression intentionnelle de bruit.
Dans les protocoles réels, Ring-LWE et Module-LWE utilisant des anneaux de polynômes sont adoptés pour améliorer l’efficacité de la communication et la vitesse de calcul, et servent de base au ML-KEM standard du NIST.

À l’approche du changement de paradigme informatique sans précédent que représentent les ordinateurs quantiques, il est très romantique de penser que la “cryptographie sur les réseaux”, née des profondeurs de l’algèbre linéaire classique et de la théorie des nombres, soutiendra la fondation de la sécurité Internet de demain. Les mathématiques qui sous-tendent la cryptographie sur les réseaux ne sont en aucun cas trop complexes, et avec des connaissances de base en algèbre linéaire et en probabilités, vous pouvez parfaitement comprendre sa belle structure. Nous espérons que cet article vous aidera à comprendre la cryptographie basée sur les réseaux, qui est au cœur de la PQC.

Hypothèse de Riemann et distribution des nombres premiers : une relation profonde avec la cryptographie moderne

Fri, 11 Sep 2026 16:00:00 +0900

1. Introduction : Le mystère cosmique des nombres premiers et l’hypothèse de Riemann

Les « nombres premiers » (Prime Numbers) sont des entiers naturels qui ne sont divisibles que par 1 et par eux-mêmes, et sont souvent appelés les « atomes » du monde mathématique. La suite 2, 3, 5, 7, 11, 13… semble à première vue désordonnée et aléatoire. Depuis que le mathématicien grec antique Euclide a prouvé qu’« il existe une infinité de nombres premiers », d’innombrables mathématiciens ont tenté de percer les régularités cachées dans cette suite de nombres premiers.

Celle qui s’est le plus rapprochée du mystère des nombres premiers est l’« Hypothèse de Riemann » (Riemann Hypothesis), proposée en 1859 par le mathématicien allemand Bernhard Riemann. L’hypothèse de Riemann est l’un des problèmes les plus importants et non résolus des mathématiques modernes, et elle fait partie des Problèmes du prix du millénaire définis par l’Institut de mathématiques Clay, avec une récompense d’un million de dollars.

À première vue, un problème difficile de mathématiques pures concernant la distribution des nombres premiers peut sembler sans rapport avec notre vie quotidienne. Cependant, la sécurité de l’infrastructure d’Internet qui soutient la société moderne, en particulier les technologies de cryptographie moderne telles que le chiffrement RSA et la cryptographie sur les courbes elliptiques (ECC), dépend profondément des propriétés des nombres premiers géants.

Dans cet article, nous entreprendrons un voyage mathématique allant de la distribution des nombres premiers au théorème des nombres premiers, à la fonction zêta de Riemann, pour atteindre le cœur de l’hypothèse de Riemann. Nous explorerons en profondeur comment elle est liée à la cryptographie moderne et ce qu’il adviendrait du monde si l’hypothèse de Riemann venait à être prouvée.

2. Le théorème des nombres premiers et la distribution des nombres premiers : La découverte de Gauss

Afin de comprendre comment les nombres premiers sont distribués, les mathématiciens ont considéré la fonction de compte des nombres premiers (Prime-counting function) $\pi(x)$, qui représente « combien de nombres premiers existent inférieurs ou égaux à un certain nombre $x$ ».

Par exemple :

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

Carl Friedrich Gauss, mathématicien de génie de 15 ans, a calculé d’énormes tables de nombres premiers et a découvert que la fréquence d’apparition des nombres premiers diminue de manière inversement proportionnelle au logarithme népérien $\ln x$. En d’autres termes, il a conjecturé que la probabilité de trouver un nombre premier autour d’un certain nombre $x$ est d’environ $\frac{1}{\ln x}$.

L’expression de cela à l’aide d’une intégrale est le logarithme intégral (Logarithmic integral) $\text{Li}(x)$.

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

La conjecture de Gauss a ensuite été prouvée indépendamment en 1896 par Jacques Hadamard et Charles-Jean de La Vallée Poussin, et a été établie en tant que théorème des nombres premiers (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

Ou de manière approximative, il s’exprime comme suit :

$$ \pi(x) \sim \frac{x}{\ln x} $$

Grâce à ce théorème, nous savons que les nombres premiers ont une distribution très lisse et prévisible d’un point de vue macroscopique. Cependant, d’un point de vue microscopique, il existe toujours une « erreur » ou une « fluctuation » entre $\pi(x)$ et $\text{Li}(x)$. La véritable nature de cette fluctuation est le plus grand mystère que l’hypothèse de Riemann tente de résoudre.

3. La fonction zêta de Riemann et le produit eulerien

L’arme la plus puissante pour analyser la distribution des nombres premiers est la fonction zêta de Riemann (Riemann Zeta Function). À l’origine, il s’agissait d’une série infinie définie par Leonhard Euler pour les nombres réels $s > 1$.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

L’une des plus grandes réalisations d’Euler a été de prouver que cette série infinie peut être exprimée comme un produit infini sur tous les nombres premiers $p$. C’est le produit eulerien (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

La compréhension intuitive de la preuve est que si vous développez chaque terme du côté droit comme une série géométrique et que vous les multipliez, le théorème fondamental de l’arithmétique (tout entier naturel est exprimé de manière unique comme un produit de nombres premiers) reconstruira parfaitement la somme des inverses des entiers naturels du côté gauche.

Cette seule équation est devenue un pont reliant l’analyse (séries infinies / fonctions continues) et la théorie des nombres (nombres premiers / nombres discrets). Étudier la fonction zêta est synonyme d’étudier la distribution des nombres premiers.

4. Prolongement analytique et extension au plan complexe

Le génie de Riemann réside dans l’extension de la variable $s$ de $\zeta(s)$, qu’Euler ne considérait que pour les nombres réels, à des nombres complexes $s = \sigma + it$ ($\sigma$ est la partie réelle, $t$ est la partie imaginaire).

La série infinie originale ne converge que pour $\sigma > 1$, mais Riemann a utilisé une méthode appelée « prolongement analytique (Analytic Continuation) » pour étendre la définition de sorte que $\zeta(s)$ ait un sens sur l’ensemble du plan complexe, à l’exception du pôle en $s = 1$.

Il a en outre dérivé une magnifique équation fonctionnelle (Functional equation) satisfaite par la fonction zêta.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Où $\Gamma(x)$ est la fonction gamma. Cette équation nous permet de connaître les propriétés du demi-plan gauche à partir des propriétés du demi-plan droit.

Zéros (Zeros of the Zeta Function)

Les nombres complexes $s$ où la valeur de la fonction zêta devient 0 sont appelés « zéros ». D’après l’équation fonctionnelle, lorsque $s$ est un nombre pair négatif ($-2, -4, -6, \dots$), $\sin(\pi s / 2)$ devient 0, donc $\zeta(s) = 0$. Ceux-ci sont appelés les zéros triviaux (Trivial zeros).

Cependant, ce qui est important dans la distribution des nombres premiers, ce sont les autres zéros, à savoir les zéros non triviaux (Non-trivial zeros) qui existent dans la « bande critique (Critical strip) » où $0 \le \sigma \le 1$.

5. Le cœur de l’hypothèse de Riemann et la formule explicite

Riemann a calculé un petit nombre de zéros et a formulé une conjecture étonnante. C’est l’hypothèse de Riemann.

Hypothèse de Riemann (Riemann Hypothesis) Tous les zéros non triviaux de la fonction zêta de Riemann $\zeta(s)$ ont une partie réelle égale à $1/2$ (c’est-à-dire $\text{Re}(s) = 1/2$).

Cette droite où la partie réelle est de 1/2 est appelée la « droite critique (Critical line) ».

graph TD A["Fonction zêta de Riemann ζ(s)"] --> B["Extension au plan complexe par prolongement analytique"] B --> C["Zéros triviaux (s = -2, -4, -6 ...)"] B --> D["Zéros non triviaux (0 <= Re(s) <= 1)"] D --> E["Hypothèse de Riemann"] E --> F["Tous les zéros non triviaux sont sur Re(s) = 1/2"] F --> G["Vers la preuve de la limite du terme d'erreur de la distribution des nombres premiers"]

Pourquoi l’hypothèse de Riemann est-elle si importante ? C’est parce que les zéros de la fonction zêta déterminent complètement la distribution des nombres premiers.

Riemann, et plus tard le mathématicien von Mangoldt, ont dérivé une « formule explicite (Explicit formula) » qui décrit avec précision la distribution des nombres premiers. En utilisant la fonction de Tchebychev $\psi(x)$, elle s’exprime comme suit :

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Où $\rho$ est la somme sur tous les zéros non triviaux de la fonction zêta. Le terme principal est $x$ (qui correspond au théorème des nombres premiers), et en ajoutant et en soustrayant des termes ondulatoires dépendant des zéros $\rho$, la distribution en escalier exacte des nombres premiers est restaurée. On peut dire que les zéros non triviaux représentent les « fréquences (ondes) » de la distribution des nombres premiers.

Si l’hypothèse de Riemann est vraie, et que la partie réelle de tous les zéros non triviaux $\rho$ est exactement de $1/2$, alors le terme d’erreur du théorème des nombres premiers se situera dans la plus petite plage théoriquement concevable.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

En d’autres termes, si l’hypothèse de Riemann est vraie, il sera prouvé que les nombres premiers sont distribués de la manière la plus « régulière et belle » que nous puissions imaginer.

6. La cryptographie moderne et sa relation indissociable avec les nombres premiers

Jusqu’ici, nous étions dans le monde profond des mathématiques pures, mais ces propriétés des nombres premiers soutiennent fondamentalement la société numérique moderne. Le représentant de cela est la cryptographie à clé publique telle que le chiffrement RSA.

La sécurité de toutes les communications, y compris les paiements par carte de crédit sur Internet, la transmission de mots de passe et les signatures numériques de la blockchain, dépend des « nombres premiers ».

Fonctionnement du chiffrement RSA

La sécurité du chiffrement RSA est basée sur le fait mathématique (problème de la factorisation) qu’« il est très difficile de factoriser un nombre composé avec un grand nombre de chiffres ».

Génération de clés: Choisissez au hasard de très grands nombres premiers $p$ et $q$ (par exemple, 2048 bits chacun). Multipliez-les pour calculer $N = p \times q$. Ce $N$ fera partie de la clé publique. En utilisant l’indicatrice d’Euler $\phi(N) = (p-1)(q-1)$, générez la clé privée $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Chiffrement et déchiffrement: Le texte en clair $M$ est converti en texte chiffré $C$ à l’aide de la clé publique $e, N$.
$$ C \equiv M^e \pmod{N} $$
Seul celui qui possède la clé privée $d$ peut le déchiffrer.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Texte en clair (Plaintext)"] --> B["Chiffrer avec la clé publique (e, N)"] B --> C["Texte chiffré (Ciphertext)"] C --> D["Déchiffrer avec la clé privée (d)"] D --> E["Texte en clair original"] F["Attaquant (Attacker)"] -- "Tente de factoriser N" --> C F -.-> G["Impossible de calculer d sans connaître p et q"]

Pour casser le chiffrement RSA, il faut trouver (factoriser) les nombres premiers originaux $p$ et $q$ à partir du gigantesque $N$. Même en utilisant les algorithmes les plus courants (Crible algébrique : GNFS, etc.), la factorisation d’un nombre de centaines de chiffres prendrait un temps dépassant de loin l’âge de l’univers, même avec des superordinateurs.

7. L’impact de l’hypothèse de Riemann sur la cryptographie

Alors, comment « l’hypothèse de Riemann » au sommet des mathématiques pures et la « cryptographie » se croisent-elles ?

7.1. Algorithmes de génération de nombres premiers (test de primalité) et l’hypothèse de Riemann généralisée (GRH)

Pour utiliser le chiffrement RSA, il faut d’abord générer des nombres premiers géants $p$ et $q$. Cependant, déterminer de manière fiable et rapide si « un certain nombre est premier » n’est pas facile.

Actuellement, l’algorithme pratique utilisé est le test de primalité de Miller-Rabin (Miller-Rabin primality test), qui est un algorithme probabiliste. Cet algorithme est rapide, mais il existe un risque de « pseudo-premiers » où un nombre composé est identifié à tort comme premier avec une probabilité extrêmement faible.

Cependant, si l’« Hypothèse de Riemann généralisée (Generalized Riemann Hypothesis, GRH) », qui étend l’hypothèse de Riemann aux fonctions L de Dirichlet, est supposée vraie, la situation change radicalement. Si la GRH est vraie, la limite supérieure du nombre de tests dans le test de Miller-Rabin est mathématiquement garantie, et elle passe d’un algorithme probabiliste à un « algorithme déterministe en temps polynomial » (C’était un fait majeur connu avant même la découverte du test de primalité AKS).

En d’autres termes, l’hypothèse de Riemann (et son extension) joue un rôle dans l’approbation directe de la génération de base de la cryptographie : « Pouvons-nous générer des nombres premiers géants rapidement et avec une confiance absolue ? ».

7.2. Relation avec les algorithmes de factorisation

Lors de l’évaluation de la complexité des algorithmes pour le décryptage (comme le crible algébrique), la connaissance de la distribution des nombres premiers est indispensable. De nombreux algorithmes de factorisation dépendent de la distribution des « nombres friables (Smooth numbers : nombres qui n’ont que de petits facteurs premiers) ».

Pour évaluer rigoureusement la fréquence d’apparition des nombres friables, une compréhension profonde de la distribution des nombres premiers est requise, et ici aussi, des techniques de théorie analytique des nombres directement liées à la fonction zêta et à l’hypothèse de Riemann sont pleinement utilisées. Si l’hypothèse de Riemann est prouvée et que l’erreur de la distribution des nombres premiers est complètement déterminée, il sera possible d’évaluer plus précisément les limites de performance des algorithmes de factorisation.

8. Si l’hypothèse de Riemann est prouvée, la cryptographie sera-t-elle cassée ?

On dit parfois comme une légende urbaine que « si l’hypothèse de Riemann est résolue, le chiffrement RSA s’effondrera en un instant », mais c’est mathématiquement inexact.

La preuve de l’hypothèse de Riemann elle-même ne créera pas immédiatement un algorithme magique qui accélère considérablement la factorisation. L’hypothèse de Riemann n’est qu’un théorème sur la « régularité de la distribution macroscopique » des nombres premiers, et elle ne nous dit pas directement par quels nombres premiers un nombre individuel $N$ est divisible (propriété locale).

Cependant, l’impact n’est pas nul. Il est extrêmement probable que de « nouveaux outils mathématiques » et des « méthodes analytiques inconnues » soient découverts au cours du processus de démonstration de l’hypothèse de Riemann. L’histoire montre que lorsque le dernier théorème de Fermat et la conjecture de Poincaré ont été prouvés, les nouvelles théories développées au cours du processus ont fait progresser les mathématiques dans leur ensemble.

Si des méthodes géométriques algébriques inconnues ou des méthodes géométriques non commutatives permettant de manipuler complètement les propriétés des zéros de la fonction zêta de Riemann sont établies, il n’est pas exclu que cela conduise à la découverte d’un algorithme révolutionnaire de factorisation (par exemple, un algorithme classique qui réduit la complexité au temps polynomial). En ce sens, les cryptographes ne peuvent jamais quitter des yeux les développements de l’hypothèse de Riemann.

Ordinateurs quantiques et algorithme de Shor

Une menace plus directe et réaliste pour la cryptographie n’est pas la preuve de l’hypothèse de Riemann, mais les ordinateurs quantiques. « L’algorithme de Shor » publié par Peter Shor en 1994 a prouvé qu’avec un ordinateur quantique suffisamment performant, la factorisation peut être résolue en temps polynomial. Cela casserait fondamentalement le chiffrement RSA et la cryptographie sur les courbes elliptiques.

Actuellement, une transition vers la « cryptographie post-quantique (Post-Quantum Cryptography, PQC) » (comme la cryptographie fondée sur les réseaux) qui ne peut pas être déchiffrée même par des ordinateurs quantiques progresse dans le monde entier. Les technologies de cryptographie basées sur les nombres premiers peuvent en un sens atteindre la fin de leur âge d’or, mais la valeur mathématique des nombres premiers eux-mêmes ne sera jamais perdue.

9. Conclusion : L’intersection de l’abstraction mathématique et de la société réelle

graph TD A["Exploration des mathématiques pures"] --> B["Élucidation de l'hypothèse de Riemann"] B --> C["Compréhension complète de la distribution des nombres premiers"] C --> D["Développement spectaculaire de la théorie des nombres et de la géométrie algébrique"] D -.-> E["Possibilité de nouveaux algorithmes de factorisation"] E -.-> F["Mise à jour de l'évaluation de la sécurité cryptographique"] A --> G["Mathématiques appliquées et informatique"] G --> H["Efficacité des tests de primalité et de la génération cryptographique"] H --> F

La quête insatiable des nombres premiers, qui se poursuit depuis la Grèce antique, a été sublimée par le génie de Riemann en une magnifique symphonie sur le plan complexe (les zéros de la fonction zêta). Et étonnamment, ce cristal pur et immaculé des mathématiques est appliqué des siècles plus tard comme le bouclier le plus puissant garantissant la sécurité de la société de l’information.

L’hypothèse de Riemann est une entité qui symbolise à la fois la « beauté abstraite » des mathématiques et sa « stupéfiante applicabilité au monde physique et à la société réelle ».

Lorsqu’un jour cette immense montagne mathématique, dont personne n’a encore atteint le sommet, sera conquise, nous comprendrons parfaitement la vérité cosmique des nombres premiers et acquerrons une nouvelle perspective sur les fondements de la société de l’information. L’étude de la cryptographie est aussi un voyage à travers l’histoire de la sagesse humaine.

Algorithmes de test de primalité rapides implémentés en C++ (méthode de Miller-Rabin, etc.)

Fri, 11 Sep 2026 14:00:00 +0900

Introduction : Pourquoi avons-nous besoin de tests de primalité rapides ?

Dans le monde de l’informatique, de la théorie de la cryptographie ou de la programmation compétitive, déterminer rapidement et précisément “si un certain nombre est premier ou non” est un défi fondamental et extrêmement important. Par exemple, la cryptographie à clé publique telle que RSA, qui soutient la sécurité de la société Internet moderne, base sa sécurité sur la génération d’énormes nombres premiers et sur la difficulté de les multiplier (la difficulté de la factorisation en nombres premiers). Par conséquent, il n’est pas exagéré de dire que la technologie capable d’identifier instantanément si un nombre énorme est premier est la technologie qui soutient le fondement de la société numérique.

De plus, en programmation compétitive (comme AtCoder et Codeforces), les tests de primalité sont un thème récurrent. Dans des situations où des dizaines de milliers de tests de primalité doivent être effectués en moins d’une seconde pour des entrées énormes avec des contraintes telles que $N \le 10^{18}$, les algorithmes traditionnels et naïfs ne peuvent absolument pas respecter la limite de temps de calcul (Time Limit Exceeded : TLE).

Dans cet article, nous expliquerons en profondeur, de la base mathématique jusqu’aux implémentations hautement optimisées en C++, en commençant par des algorithmes naïfs de test de primalité, puis le “test de Fermat”, qui est un test de primalité probabiliste, et enfin l’algorithme rapide de niveau pratique le plus puissant qui surmonte ses faiblesses : le “test de primalité de Miller-Rabin”. En particulier, pour les entiers de 64 bits ($N < 2^{64}$), nous expliquerons en détail la méthode qui ne se limite pas à un test probabiliste mais “peut tester la primalité avec 100% de certitude (test déterministe)”, et fournirons un code source en C++ prêt à être utilisé en pratique.

1. Les bases du test de primalité et la méthode des divisions successives (Trial Division)

Un nombre premier (Prime number) est un entier naturel supérieur ou égal à 2 qui n’a de diviseurs positifs que 1 et lui-même. En suivant fidèlement la définition d’un nombre premier, pour déterminer si un certain entier $N$ est premier, nous pouvons essayer de diviser $N$ par tous les entiers de $2$ à $N-1$ ; s’il n’est jamais divisible, il est premier, et s’il est divisible au moins une fois, il est considéré comme un nombre composé (pas un nombre premier).

Cependant, la complexité temporelle de cette méthode est de $O(N)$, et lorsque $N$ est un nombre énorme comme $10^{18}$, même les ordinateurs modernes prendront énormément de temps pour le calcul.

Optimisation de la méthode des divisions successives : recherche jusqu’à $\sqrt{N}$

Lorsqu’un nombre composé $N$ est exprimé comme $a \times b = N$ ($a \le b$), il est certain que $a \le \sqrt{N}$. Par conséquent, il n’est pas nécessaire d’exécuter la boucle du test de primalité jusqu’à $N-1$ ; il suffit de vérifier jusqu’à $\sqrt{N}$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>

// Test de primalité par la méthode des divisions successives (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // Vérifier uniquement les nombres impairs supérieurs ou égaux à 3
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

La complexité de cet algorithme est de $O(\sqrt{N})$. Si $N \le 10^{12}$, il peut être calculé en un instant, mais dans le cas de $N \approx 10^{18}$, le nombre de boucles devient d’environ $10^9$ fois, ce qui prend de quelques centaines de millisecondes à quelques secondes même avec un environnement C++, et n’est donc pas adapté pour de multiples évaluations.

2. Le test de Fermat : L’aube du test de primalité probabiliste

Ce qui a été conçu pour surmonter les limites de la méthode des divisions successives est l’“algorithme probabiliste (Probabilistic Algorithm)” qui utilise des théorèmes de la théorie des nombres. L’exemple typique en est le “test de primalité de Fermat” utilisant le petit théorème de Fermat.

Le petit théorème de Fermat (Fermat’s Little Theorem)

Ce théorème, découvert par Pierre de Fermat, affirme ce qui suit :

Pour tout nombre premier $p$ et tout entier $a$ qui lui est premier (non multiple de $p$), la congruence suivante est vraie :
$$ a^{p-1} \equiv 1 \pmod p $$

En prenant la contraposée de ce théorème, on peut dire que “pour un certain entier $N$ et un entier $a$ premier avec $N$, si $a^{N-1} \not\equiv 1 \pmod N$, alors $N$ est définitivement un nombre composé”. En utilisant cette propriété, le test de Fermat consiste à choisir une base (base) aléatoire $a$ pour le nombre cible $N$, à calculer $a^{N-1} \pmod N$ et à vérifier s’il devient $1$.

Exponentiation modulaire rapide (Méthode d’exponentiation binaire)

Pour effectuer le test de Fermat, il est nécessaire de calculer rapidement d’énormes puissances telles que $a^{N-1} \pmod N$. Pour cela, nous utilisons la “méthode d’exponentiation binaire (Modular Exponentiation / Binary Exponentiation)”. La complexité est de $O(\log N)$, ce qui est extrêmement rapide.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Calcul de a^b mod m en utilisant la méthode d'exponentiation binaire
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

Ici, pour éviter les dépassements de capacité, l’extension GCC/Clang __int128_t (entier de 128 bits) est utilisée pour conserver les produits intermédiaires.

Nombres pseudo-premiers et nombres de Carmichael (Carmichael Numbers)

Le test de Fermat est très puissant, mais il a une faiblesse fatale. Il existe des nombres tels que bien que $N$ soit un nombre composé, $a^{N-1} \equiv 1 \pmod N$ reste vrai pour tous les $a$ ($a$ premiers avec $N$).

De tels nombres sont appelés “nombres pseudo-premiers absolus” ou “nombres de Carmichael”. Le plus petit nombre de Carmichael est $561 = 3 \times 11 \times 17$. En raison de la présence de nombres de Carmichael, il n’est pas possible d’effectuer un test déterministe avec une “probabilité de 100%” en utilisant uniquement le test de Fermat. Peu importe le nombre de bases différentes $a$ que vous essayez, un nombre comme $561$ fera toujours semblant d’être premier (une tromperie).

3. Test de primalité de Miller-Rabin (Miller-Rabin Primality Test)

Le “test de primalité de Miller-Rabin”, conçu par Miller (Gary L. Miller) et Rabin (Michael O. Rabin), a brillamment surmonté la faiblesse du test de Fermat (l’existence des nombres de Carmichael). Aujourd’hui, il est le plus largement utilisé dans la génération de clés des systèmes cryptographiques et des bibliothèques internes de divers langages de programmation en tant algorithme de test de primalité rapide et pratique.

Principes mathématiques

En plus du petit théorème de Fermat, l’algorithme de Miller-Rabin utilise la propriété selon laquelle “dans un corps fini modulo un nombre premier ($\mathbb{Z}/p\mathbb{Z}$), les seules solutions à $x^2 \equiv 1 \pmod p$ sont $x \equiv 1$ ou $x \equiv -1$” (dans le cas modulo un nombre composé, d’autres racines carrées non triviales peuvent exister).

Si l’on soustrait $1$ au nombre impair $N$ que nous voulons tester, $N-1$ sera toujours un nombre pair. Par conséquent, nous divisons $N-1$ par $2$ autant de fois que possible, et l’exprimons sous la forme suivante :

$$ N-1 = d \cdot 2^s $$

(Ici, $d$ est un nombre impair, $s \ge 1$)

Pour toute base arbitraire $a$ ($1 < a < N-1$), nous vérifions si $a^{N-1} \equiv 1 \pmod N$ selon le petit théorème de Fermat, mais nous effectuons ce calcul par étapes. Plus précisément, nous répétons la mise au carré dans l’ordre : $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$.

La condition pour que le test de Miller-Rabin détermine que $N$ est “premier (ou probablement premier avec une forte probabilité)” est que l’une des conditions suivantes soit remplie.

$a^d \equiv 1 \pmod N$
Il existe un certain $r$ ($0 \le r < s$) tel que $a^{d \cdot 2^r} \equiv -1 \pmod N$ soit vrai.
- En arithmétique modulaire en C++, $-1 \pmod N$ devient $N-1$.

Si $N$ est premier, cette condition sera toujours remplie pour n’importe quel $a$. Inversement, si $N$ est un nombre composé, lorsqu’un $a$ aléatoire est choisi, il est prouvé mathématiquement que la probabilité de remplir cette condition (la probabilité d’être trompé) est inférieure ou égale à $\frac{1}{4}$. En effectuant $k$ tests indépendants, la probabilité d’une fausse identification devient inférieure ou égale à $\left(\frac{1}{4}\right)^k$, ce qui peut être considéré comme pratiquement nul. Il n’existe pas de nombres qui puissent “tromper de manière absolue” comme les nombres de Carmichael.

Flux de l’algorithme de la méthode de Miller-Rabin (Organigramme Mermaid)

Le diagramme ci-dessous illustre le flux logique d’un seul test (un test pour une base $a$) de la méthode de test de primalité de Miller-Rabin.

graph TD Start["Début du test (Entrée : N, a)"] --> CalcDS["Calculer d (impair) et s tels que N-1 = d * 2^s"] CalcDS --> CalcX["Calculer x = a^d mod N"] CalcX --> CheckX1{"x == 1 ou x == N-1 ?"} CheckX1 -- "Oui" --> ReturnTrue["Peut-être premier (Probably Prime)"] CheckX1 -- "Non" --> LoopStart["Début de la boucle de r = 1 à s-1"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "Non" --> ReturnFalse["Certainement composé (Composite)"] LoopCondition -- "Oui" --> SquareX["Calculer x = (x * x) mod N"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Oui" --> ReturnTrue CheckXMinus1 -- "Non" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Oui" --> ReturnFalse CheckXOne -- "Non" --> LoopNext["Incrémenter r de 1 et continuer"] LoopNext --> LoopCondition

4. Test déterministe pour les entiers de 64 bits

Bien que le test de primalité de Miller-Rabin soit fondamentalement un algorithme “probabiliste”, lorsque la limite supérieure de $N$ est fixe, on peut tester la primalité avec “100% de certitude” en essayant toutes les bases spécifiques $a$ (bases). Ceci est appelé le test de Miller-Rabin déterministe (Deterministic Miller-Rabin Test).

Grâce aux recherches de Jim Sinclair et d’autres, il a été révélé que pour tous les entiers $N < 2^{64}$ (environ $1.8 \times 10^{19}$), un test complètement déterministe et suffisant est possible en choisissant les $7$ nombres premiers suivants comme base $a$.

Liste des bases $a$ à tester : {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

Alternativement, en utilisant un autre ensemble bien connu des $12$ nombres premiers suivants, une détermination parfaite peut également être effectuée en dessous de $N < 2^{64}$. {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

Cette fois, pour améliorer la simplicité et la fiabilité de l’algorithme, nous adopterons la méthode utilisant ces derniers $12$ nombres premiers comme bases (ou les $7$ bases plus optimisées). Dans l’implémentation C++, en divisant la plage avec un branchement conditionnel, nous optimiserons pour minimiser le nombre de tests.

5. Implémentation avancée en C++ (Highly Optimized C++ Implementation)

Maintenant, en résumant les théories mathématiques et la conception des algorithmes discutées jusqu’à présent, nous présenterons le code d’implémentation de la fonction de test de primalité de Miller-Rabin au niveau le plus fort dans le C++ moderne.

Points clés de l’implémentation

Éviter le dépassement de capacité de la multiplication des entiers de 64 bits : Dans le cas de $N \approx 10^{18}$, $x \times x$ dans la multiplication modulaire sera au maximum de $10^{36}$, ce qui dépassera facilement la valeur maximale de $1.8 \times 10^{19}$ d’un entier normal de 64 bits (uint64_t ou long long). Pour résoudre ce problème, le type d’extension GCC ou Clang __int128_t (ou unsigned __int128) est utilisé, et le calcul est effectué avec une précision de 128 bits avant de prendre le modulo. Cela permet une multiplication modulaire à grande vitesse sans l’utilisation d’algorithmes complexes.
Choix de la base déterministe : Si la valeur de $N$ est petite, elle est optimisée de manière à ce qu’un plus petit nombre de bases n’aient besoin d’être testées.

Code source C++ complet

Voici le code source complet prêt à être utilisé en pratique. Ce code peut être copié et utilisé tel quel dans des environnements tels que la programmation compétitive.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// (a * b) mod m rapide avec des entiers de 128 bits
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// Calcul de (base^exp) mod m par la méthode d'exponentiation binaire
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// Test déterministe pour les entiers 64 bits par la méthode de Miller-Rabin
bool is_prime_miller_rabin(uint64_t n) {
 // Valeurs limites et évaluation préalable des petits nombres premiers
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // Décomposer sous la forme n-1 = d * 2^s
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // Liste des bases utilisées pour le test
 // Optimisation pour minimiser le nombre de bases testées selon la taille de N
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 7 bases qui sont déterministes pour tous les nombres N < 2^64
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // Exécuter le test pour chaque base
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // Si a est un multiple de n, cela ne peut pas être testé, mais ce n'est pas premier

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // Première condition remplie, passer à la base suivante

 bool composite = true;
 // Boucle de s-1 itérations (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // Seconde condition remplie, peut-être premier
 break;
 }
 }

 // Si aucune condition n'est remplie, il est certainement composé
 if (composite) return false;
 }

 // Si la condition est remplie pour toutes les bases, il est certainement premier
 return true;
}

int main() {
 // Échantillons pour les tests
 vector<uint64_t> test_cases = {
 1000000007, // Nombre premier célèbre
 998244353, // Nombre premier célèbre
 1000000000000000003, // Nombre premier autour de 10^18
 1000000000000000007, // Nombre composé (10^18 + 7)
 561, // Nombre de Carmichael (Composé)
 18446744073709551557ULL // Un des plus grands nombres premiers près de 2^64
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

6. Évaluation de la complexité et des performances de l’algorithme

Examinons les performances de l’algorithme implémenté.

Complexité temporelle (Time Complexity)

Méthode des divisions successives : $O(\sqrt{N})$
Test de Fermat : Calcul d’exponentiation $O(\log N) \times k$ ($k$ étant le nombre d’essais)
Méthode de Miller-Rabin : Calcul d’exponentiation et boucle $O(\log N) \times k$

Dans un environnement 64 bits ($N \le 2^{64}$), la méthode déterministe de Miller-Rabin ci-dessus vérifie au maximum $7$ bases. Par conséquent, $k$ peut être considéré comme une constante $k \le 7$, et la complexité temporelle globale devient strictement $O(\log N)$. Même dans le pire des cas ($N \approx 10^{19}$), le nombre d’étapes d’exécution tient dans un maximum de $7 \times 64 = 448$ opérations de base, et le temps d’exécution est inférieur à quelques microsecondes ($10^{-6}$ secondes). Par rapport au $O(\sqrt{N})$ de la méthode des divisions successives (environ $4 \times 10^9$ boucles), une accélération de plusieurs millions de fois est atteinte.

Optimisation supplémentaire : Multiplication de Montgomery (Montgomery Multiplication)

Dans l’implémentation de cet article, le type étendu entier de 128 bits __int128_t est utilisé pour la division (opération modulo %). Même sur les processeurs modernes, la division entière (instruction DIV) est une instruction coûteuse qui nécessite des dizaines de cycles par rapport à l’addition ou la multiplication.

Les créateurs de bibliothèques et les programmeurs compétitifs cherchant à atteindre les limites de l’optimisation adoptent parfois une méthode appelée multiplication de Montgomery (Montgomery Multiplication). La multiplication de Montgomery est un algorithme remarquable qui remplace les opérations modulo coûteuses (division) par “seulement des décalages de bits et des multiplications” en mappant les nombres dans un “espace de Montgomery” spécial. En intégrant cela dans la multiplication modulaire du test de Miller-Rabin, la vitesse d’exécution peut encore être augmentée d’environ 2 à 3 fois. Comme c’est un sujet très profond, nous l’expliquerons en détail dans un autre article.

7. Conclusion

Dans cet article, nous avons expliqué d’un coup de nombreux concepts, des bases aux sujets avancés du test de primalité. Récapitulons les points clés.

La méthode des divisions successives est certaine, mais manque d’utilité pratique lorsque $N$ dépasse $10^{12}$ en raison de sa complexité de $O(\sqrt{N})$.
Le test de Fermat est extrêmement rapide avec $O(\log N)$, mais a une faiblesse fatale en étant trompé par des nombres pseudo-premiers absolus tels que les nombres de Carmichael.
Le test de primalité de Miller-Rabin est l’algorithme le plus puissant et pratique qui résout les faiblesses du test de Fermat.
Dans l’implémentation C++, le dépassement de capacité de multiplication d’entiers 64 bits peut être géré en toute sécurité en utilisant __int128_t.
Dans la plage des entiers de 64 bits ($N < 2^{64}$), en choisissant $7$ ou $12$ nombres premiers spécifiques comme base, un test de primalité déterministe (100% précis) plutôt que probabiliste est possible.

Le test de primalité rapide est une technologie incontournable dans les calculs manipulant de grands nombres. Le code source en C++ de Miller-Rabin fourni dans cet article est robuste et peut être utilisé en pratique tel quel. N’hésitez pas à l’utiliser dans vos propres projets ou compétitions d’algorithmes.

graph LR TrialDivision["Méthode des divisions successives (O(√N))"] --> Fermat["Test de Fermat (O(log N), avec faiblesses)"] Fermat --> MillerRabin["Méthode de Miller-Rabin (O(log N), rendable déterministe)"] MillerRabin --> Montgomery["+ Multiplication de Montgomery (Accélération constante)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

Le monde des algorithmes, où se croisent la programmation et les mathématiques, est extrêmement beau et profond. J’espère que cela vous sera utile dans votre apprentissage futur.

Reference:

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

【Explication mathématique】Le fonctionnement de la cryptographie RSA expliqué aux lycéens

Fri, 11 Sep 2026 13:00:00 +0900

L’une des technologies qui soutient fondamentalement la sécurité de la société Internet est la « cryptographie RSA ». La plupart des communications que nous utilisons négligemment chaque jour, telles que les paiements par carte de crédit lors des achats en ligne, les échanges sur les réseaux sociaux avec des amis, ou l’envoi et la réception d’informations confidentielles d’entreprise, sont protégées par cette cryptographie RSA ou par ses technologies successives.

Cependant, lorsque l’on entend le mot « cryptographie », on peut imaginer des machines de chiffrement complexes comme celles des films d’espionnage, ou des mathématiques super avancées que seuls quelques génies peuvent comprendre. S’il est vrai que la théorie cryptographique moderne repose sur des mathématiques avancées, le mécanisme fondamental de la cryptographie RSA peut être pleinement compris avec des connaissances mathématiques acquises au lycée (propriétés des entiers, nombres premiers, congruences, etc.).

Dans cet article, en partant des connaissances mathématiques du lycée, nous expliquerons étape par étape et de manière exhaustive les principes mathématiques sur lesquels repose la cryptographie RSA et pourquoi son décryptage est si difficile. Nous l’expliquerons soigneusement avec des exemples concrets pour que même ceux qui ne sont pas très à l’aise avec les mathématiques puissent comprendre.

1. Cryptographie à clé symétrique et cryptographie à clé publique

Avant d’aborder le mécanisme mathématique de la cryptographie RSA, passons d’abord en revue les concepts de base de la cryptographie. Les méthodes de chiffrement sont généralement divisées en deux types : la « cryptographie à clé symétrique » (ou clé secrète) et la « cryptographie à clé publique ».

1.1 Les limites de la cryptographie à clé symétrique

La plupart des cryptographies utilisées depuis l’Antiquité sont appelées « cryptographie à clé symétrique ». C’est une méthode où la même clé est utilisée pour le « chiffrement (conversion du message en un texte chiffré secret) » et le « déchiffrement (restauration du texte chiffré en son message d’origine) ».

Par exemple, supposons qu’Alice veuille envoyer une lettre secrète à Bob. Alice met la lettre dans une boîte et la verrouille à l’aide d’un cadenas (clé symétrique). Pour que Bob puisse ouvrir cette boîte, il doit posséder la même clé que celle utilisée par Alice.

Cette méthode pose un problème majeur : le « problème de distribution des clés ». Lorsque Alice et Bob, éloignés l’un de l’autre, communiquent pour la première fois, comment peuvent-ils partager la clé sans être sur écoute ? Si la clé est volée par un tiers pendant son envoi par la poste, toutes les communications chiffrées ultérieures seront complètement compromises.

1.2 L’invention révolutionnaire : la « Cryptographie à clé publique »

La « cryptographie à clé publique » a été inventée pour résoudre ce problème de distribution des clés. La cryptographie RSA en est un type.

Dans la cryptographie à clé publique, deux clés différentes sont utilisées : une « clé pour chiffrer (clé publique) » et une « clé pour déchiffrer (clé privée) ».

Le destinataire, Bob, crée une paire composée d’une « clé publique » et d’une « clé privée ».
Bob publie la « clé publique » dans le monde entier (peu importe qui l’obtient).
L’expéditrice, Alice, utilise la « clé publique » de Bob pour chiffrer son message et l’envoie.
Le message chiffré ne peut être déchiffré qu’avec la « clé privée », que seul Bob possède.

Si l’on compare cela à un cadenas, Bob fabrique de nombreux « cadenas ouverts (clés publiques) » et les disperse à travers le monde. Alice place un message destiné à Bob dans une boîte et la verrouille avec un cadenas de Bob qu’elle a trouvé. Une fois fermé, le cadenas ne peut être ouvert qu’avec la « clé passe-partout (clé privée) » détenue par Bob. Même si quelqu’un vole la boîte en cours de route, il ne peut pas l’ouvrir sans la clé passe-partout.

graph TD A["Alice (Expéditrice)"] --> B["Texte clair (Message)"] B --> C["Processus de chiffrement"] D["Clé publique de Bob (Accessible à tous)"] --> C C --> E["Transmission via Internet : Texte chiffré"] E --> F["Processus de déchiffrement"] G["Clé privée de Bob (Détenue uniquement par Bob)"] --> F F --> H["Texte clair restauré (Message)"] H --> I["Bob (Destinataire)"]

Pour réaliser ce système révolutionnaire, une sorte de « fonction à sens unique (un puzzle mathématique à sens unique) » est nécessaire : « un chiffrement facile avec la clé publique, mais un déchiffrement absolument impossible sans la clé privée ». C’est là que les « nombres premiers » que nous connaissons bien ont été choisis comme pièces de ce puzzle.

2. Base mathématique de la cryptographie RSA 1 : Nombres premiers et décomposition en facteurs premiers

La sécurité de la cryptographie RSA repose sur le fait mathématique que « la décomposition en facteurs premiers de nombres gigantesques est extrêmement difficile ».

2.1 Qu’est-ce qu’un nombre premier ?

Un nombre premier est « un entier naturel supérieur à 1 qui ne peut être divisé de manière exacte que par 1 et par lui-même ». Exemples : $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Les nombres premiers sont comme les « atomes » de tous les nombres entiers. Tout entier naturel peut être décomposé sous la forme d’une multiplication de nombres premiers. C’est ce qu’on appelle la décomposition en facteurs premiers. Par exemple, $60 = 2^2 \times 3 \times 5$. Le fait que l’on puisse décomposer un nombre en facteurs premiers d’une seule et unique manière (si l’on ignore l’ordre) est connu sous le nom de « Théorème fondamental de l’arithmétique ».

2.2 La difficulté de la décomposition en facteurs premiers (Fonction à sens unique)

Ce qui est important ici, c’est l’asymétrie selon laquelle « la multiplication est facile, mais la décomposition en facteurs premiers est difficile ».

Par exemple, essayez de calculer mentalement la multiplication des deux nombres premiers suivants. $11 \times 13 = ?$ C’est facile. La réponse est $143$.

Alors, qu’en est-il du nombre suivant ? Décomposez $323$ en facteurs premiers. Qu’en pensez-vous ? Cela devrait prendre un peu plus de temps. (La réponse est $17 \times 19$).

Si les nombres sont petits, les humains peuvent s’en sortir d’une manière ou d’une autre, mais lorsque les nombres deviennent grands, les calculs deviennent explosivement difficiles, même avec des ordinateurs. Dans la cryptographie RSA principalement utilisée aujourd’hui, on utilise un nombre $N = p \times q$, qui est le produit de deux nombres premiers immenses, $p$ et $q$, de 2048 bits (environ 600 chiffres en base 10).

Lorsqu’on donne deux immenses nombres premiers $p$ et $q$, un ordinateur peut calculer $N$ en un instant (moins d’une milliseconde). Cependant, à l’inverse, si l’on ne donne que $N$, trouver les $p$ et $q$ originaux prendrait tellement de temps que même les superordinateurs les plus rapides actuels ne pourraient pas le résoudre en le calculant pendant des milliers de milliards d’années.

Cette « asymétrie de calcul (l’aller est facile, le retour est difficile) » devient le fondement qui crée la relation entre la clé publique et la clé privée.

3. Base mathématique de la cryptographie RSA 2 : Congruence (Arithmétique modulaire)

Les calculs de la cryptographie RSA ne se font pas dans le monde des additions et multiplications où les nombres deviennent infiniment grands comme nous en avons l’habitude, mais dans le monde des « restes » après division par un certain nombre. C’est ce qu’on appelle la congruence (ou arithmétique modulaire).

3.1 Les mathématiques de l’horloge

L’arithmétique modulaire est souvent comparée aux « mathématiques de l’horloge ». S’il est 10 heures actuellement, quelle heure sera-t-il dans 5 heures ? $10 + 5 = 15$ heures, mais sur une horloge classique de 12 heures, on répond « 3 heures ». C’est parce que le reste de la division de 15 par 12 est 3.

Dans le monde mathématique, on écrit cela comme suit :

$$ 15 \equiv 3 \pmod{12} $$

Cela se lit « 15 est congru à 3 modulo 12 (le reste de la division par 12 est égal) ».

3.2 Propriétés fondamentales des congruences

Les congruences ont des propriétés très pratiques qui ressemblent beaucoup à celles des équations ($=$). Soit $N$ le module (le diviseur). Lorsque $a \equiv b \pmod N$ et $c \equiv d \pmod N$, ce qui suit est vrai :

Addition : $a + c \equiv b + d \pmod N$
Soustraction : $a - c \equiv b - d \pmod N$
Multiplication : $a \times c \equiv b \times d \pmod N$
Exponentiation (puissance) : $a^k \equiv b^k \pmod N$ ($k$ est un entier naturel)

La propriété d’« exponentiation » est particulièrement importante. Elle signifie que « le reste d’une puissance est égal à la puissance du reste ». Par exemple, supposons que nous voulions trouver le reste de la division de $7^{100}$ par $5$. Il serait fastidieux de multiplier sérieusement $7$ cent fois avant de diviser par $5$, mais en utilisant la propriété des congruences, puisque $7 \equiv 2 \pmod 5$, on a $7^{100} \equiv 2^{100} \pmod 5$, ce qui permet de simplifier considérablement le calcul. Dans le monde de la cryptographie, on manipule des puissances de très grands nombres, cette propriété est donc indispensable.

4. Base mathématique de la cryptographie RSA 3 : La fonction d’Euler et le théorème d’Euler

Voici la mathématique magique qui est au cœur de la cryptographie RSA. Le « théorème d’Euler », qui est une généralisation du « petit théorème de Fermat », fait son apparition.

4.1 L’indicatrice d’Euler $\phi(N)$

La fonction indicatrice d’Euler (fonction $\phi$) est une fonction qui, pour un entier naturel $N$ donné, renvoie le « nombre d’entiers naturels compris entre 1 et $N$ qui sont premiers avec $N$ (dont le plus grand commun diviseur est 1) ».

Regardons quelques exemples.

$\phi(5)$ : Parmi 1, 2, 3, 4, 5, les nombres premiers avec 5 sont 1, 2, 3, 4, soit 4 nombres. Donc, $\phi(5) = 4$.
$\phi(6)$ : Parmi 1, 2, 3, 4, 5, 6, les nombres premiers avec 6 sont 1, 5, soit 2 nombres. Donc, $\phi(6) = 2$.

【Propriété spéciale dans le cas d’un nombre premier】 Si $p$ est un nombre premier, tous les nombres de 1 à $p-1$ sont premiers avec $p$. Par conséquent,

$$ \phi(p) = p - 1 $$

【Propriété spéciale dans le cas du produit de deux nombres premiers】 Pour deux nombres premiers distincts $p$ et $q$, si on pose $N = p \times q$, $\phi(N)$ peut être facilement calculée avec la formule suivante.

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Cette propriété agit comme la « porte dérobée secrète (trapdoor) » de la cryptographie RSA. La personne qui connaît $p$ et $q$ (le créateur de la clé) peut calculer $\phi(N)$ en un instant, mais une tierce personne qui ne connaît que $N$ ne peut pas trouver $\phi(N)$ sans factoriser $N$.

4.2 Le théorème d’Euler

Leonhard Euler a prouvé le magnifique théorème suivant en utilisant cette $\phi(N)$.

Théorème d’Euler : Si les entiers $a$ et $N$ sont premiers entre eux, la congruence suivante est vraie :

$$ a^{\phi(N)} \equiv 1 \pmod N $$

C’est une propriété surprenante selon laquelle « si l’on multiplie un certain nombre $a$ par lui-même $\phi(N)$ fois et qu’on le divise par $N$, le reste sera toujours $1$ ». (Si $N$ est un nombre premier $p$, cela devient $a^{p-1} \equiv 1 \pmod p$, ce qui est appelé le petit théorème de Fermat).

Transformons ce théorème d’Euler. Multiplions les deux côtés par $a$ une fois de plus.

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

De plus, pour tout entier $k$, comme $a^{k \cdot \phi(N)}$ sera également égal à $1^k = 1$, l’équation suivante est vraie :

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

Cette équation est le principe fondamental qui permet à la magie de la cryptographie RSA de fonctionner : « chiffrer puis déchiffrer permet de revenir à l’original ».

5. Algorithme de la cryptographie RSA : Étapes de génération de clé, de chiffrement et de déchiffrement

Maintenant que nous avons les connaissances de base, examinons les étapes spécifiques de la cryptographie RSA. La cryptographie RSA est globalement divisée en trois phases : « 1. Génération de la clé », « 2. Chiffrement » et « 3. Déchiffrement ».

flowchart TD A1["1. Choisir les nombres premiers p, q"] --> A2["Calculer N = p × q"] A1 --> A3["Calculer φ(N) = (p-1)(q-1)"] A3 --> A4["Choisir e premier avec φ(N)"] A3 --> A5["Calculer d tel que e × d ≡ 1 (mod φ(N))"] A2 --> A6["Clé publique (N, e)"] A4 --> A6 A5 --> A7["Clé privée d"] B1["2. Message en texte clair M"] --> B2["Calculer C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Envoyer le texte chiffré C"] B3 --> C1["3. Texte chiffré reçu C"] C1 --> C2["Calculer M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Obtenir le message en texte clair d'origine M"]

5.1 Génération de clé (Key Generation)

Bob, qui est le destinataire, génère sa « clé publique » et sa « clé privée ».

Sélection des nombres premiers : Il choisit aléatoirement deux grands nombres premiers $p$ et $q$.
Calcul du module $N$ : Il calcule $N = p \times q$. Ce $N$ est rendu public.
Calcul de $\phi(N)$ : Il calcule la fonction d’Euler $\phi(N) = (p - 1)(q - 1)$. C’est le nombre secret de Bob uniquement.
Sélection de la clé publique $e$ : Il choisit un entier $e$ tel que $1 < e < \phi(N)$ et qui est premier avec $\phi(N)$.
Calcul de la clé privée $d$ : Il trouve un entier $d$ qui satisfait la condition suivante. $$ e \times d \equiv 1 \pmod{\phi(N)} $$ En d’autres termes, c’est « un nombre $d$ tel que le reste de $e \times d$ divisé par $\phi(N)$ est égal à $1$ ».

La préparation de la clé est maintenant terminée.

Clé publique : La paire $(N, e)$. Elle est publiée dans le monde entier.
Clé privée : $d$. Il ne le dit absolument à personne.

5.2 Chiffrement (Encryption)

Supposons qu’Alice veuille envoyer un message secret $M$ à Bob. (On suppose que $M$ est un nombre représentant des caractères et $0 \le M < N$). Alice utilise la clé publique de Bob $(N, e)$ et calcule comme suit :

$$ C \equiv M^e \pmod N $$

Elle calcule « le reste $C$ de la division de la puissance $e$ du message $M$ par $N$ ». Ce $C$ est le texte chiffré.

5.3 Déchiffrement (Decryption)

Bob reçoit le texte chiffré $C$. Bob utilise sa clé privée $d$ et calcule comme suit :

$$ M \equiv C^d \pmod N $$

En calculant « le reste de la division de la puissance $d$ du texte chiffré $C$ par $N$ », étonnamment, le message d’origine $M$ est restauré !

6. Pourquoi le déchiffrement permet-il de revenir à l’original ? (Preuve mathématique)

Vous vous demandez peut-être : « Comment se fait-il que le simple fait d’élever $C$ à la puissance $d$ nous ramène au $M$ d’origine ? ». C’est ici que le « théorème d’Euler » que nous avons vu plus tôt entre en jeu.

Substituons la formule de chiffrement $C = M^e$ dans la formule de déchiffrement $C^d \pmod N$.

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Rappelez-vous ici de l’étape 5 de la génération de clé. Lors de la création de $d$, Bob l’a choisi de sorte que $e \times d \equiv 1 \pmod{\phi(N)}$. Cela signifie que « $ed$ est un multiple de $\phi(N)$ plus $1$ ». En utilisant un entier $k$, on peut l’écrire comme suit :

$$ ed = k \cdot \phi(N) + 1 $$

Substituons cela dans l’exposant et décomposons-le en utilisant les lois des exposants.

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

Ici, en supposant que le message $M$ et $N$ sont premiers entre eux, d’après le théorème d’Euler, on a $M^{\phi(N)} \equiv 1 \pmod N$.

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

Par conséquent, la formule suivante est magnifiquement vérifiée.

$$ C^d \equiv M \pmod N $$

Alice ne connaît pas $d$, et les personnes sur écoute ne connaissent pas $d$ non plus, donc seul Bob, qui possède $d$, peut extraire $M$ de $C$.

7. Exemple concret : Faisons l’expérience de RSA par un calcul manuel avec de petits nombres premiers

Faisons une communication chiffrée d’Alice à Bob en utilisant de petits nombres (nombres premiers) en pratique.

【Phase de génération de la clé de Bob】

Choisir deux nombres premiers $p=11$, $q=13$.
Calculer $N = 11 \times 13 = 143$.
Calculer $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Choisir une clé publique $e$ première avec $\phi(N)=120$. Prenons ici $e=7$.
Trouver la clé privée $d$. Chercher $d$ tel que $7 \times d \equiv 1 \pmod{120}$. Dans l’équation $7d = 120k + 1$, pour $k=6$, on obtient $721$, et $721 \div 7 = 103$. Donc, $d = 103$.

Clé publique : $(N=143, e=7)$
Clé privée : $d=103$

【Phase de chiffrement d’Alice】 Supposons que nous voulions envoyer le message $M = 9$. Formule : $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$. Divisé par 143, cela donne $33447$ avec un reste de $48$. Le texte chiffré est devenu $C = 48$.

【Phase de déchiffrement de Bob】 Bob reçoit le texte chiffré $C = 48$ et le déchiffre à l’aide de sa clé privée $d = 103$. Formule : $M \equiv 48^{103} \pmod{143}$ Si vous exécutez (48 ** 103) % 143 sur une calculatrice, le résultat est magnifiquement « 9 » ! Il a pu recevoir avec succès le message d’origine.

8. Comment trouver la clé privée $d$ : L’algorithme d’Euclide étendu

Dans l’exemple de calcul manuel, nous avons trouvé $k$ par intuition pour découvrir $d=103$, mais cette méthode est impossible lorsque les nombres atteignent des centaines de chiffres. Dans les programmes réels, nous utilisons un algorithme appelé « algorithme d’Euclide étendu ».

Résoudre $7d \equiv 1 \pmod{120}$ équivaut à trouver des entiers $d, y$ qui satisfont $7d + 120y = 1$. En calculant à l’envers avec l’algorithme d’Euclide, nous pouvons le trouver mécaniquement.

$120 \div 7 = 17$ reste $1$
En transformant cela, $1 = 120 - 17 \times 7$
En d’autres termes, $-17 \times 7 \equiv 1 \pmod{120}$

$-17$ signifie la même chose que $120 - 17 = 103$ dans le monde du modulo $120$. Par conséquent, on trouve $d = 103$ en un instant. Cette méthode permet de calculer très rapidement même pour des nombres extrêmement grands.

9. L’autre visage de la cryptographie RSA : Les signatures numériques

Ce qui est merveilleux avec la cryptographie RSA, c’est qu’en inversant les rôles de la clé publique et de la clé privée, on peut aussi l’utiliser comme « signature numérique ».

Pour le chiffrement, c’était « chiffrement avec la clé publique $\Rightarrow$ déchiffrement avec la clé privée », mais pour la signature numérique, on suit les étapes : « chiffrement avec la clé privée $\Rightarrow$ déchiffrement avec la clé publique ».

flowchart TD A1["1. Alice crée une signature avec sa clé privée"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Envoyer le message M et la signature S"] A3 --> B1["2. Bob vérifie la signature avec la clé publique"] B1 --> B2["Calculer M' ≡ S^e (mod N)"] B2 --> B3["Vérifier si M' et M correspondent"]

Alice convertit le message en utilisant sa propre clé privée $d$ (c’est la signature $S$) et l’envoie à Bob. Bob effectue le calcul de vérification en utilisant la clé publique $e$ d’Alice. Si le résultat du calcul correspond au message d’origine, cela prouve simultanément que « ce sont des données qui ne peuvent être créées qu’avec la clé privée d’Alice » et que « le message n’a pas été falsifié en cours de route ».

10. Expérimenter la cryptographie RSA avec la programmation

Même les calculs de puissance qui sont difficiles à faire à la main peuvent être très facilement implémentés avec Python. Voici un code Python qui vous permet d’expérimenter la logique de base de la cryptographie RSA.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """Trouver le plus grand commun diviseur"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Trouver la clé privée d (utilisation de la fonction intégrée à partir de Python 3.8)"""
 return pow(e, -1, phi)

# 1. Génération de clé
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Clé publique : (N={N}, e={e}), Clé privée : d={d}")

# 2. Chiffrement
message = 9
ciphertext = pow(message, e, N)
print(f"Texte chiffré : {ciphertext}")

# 3. Déchiffrement
decrypted_message = pow(ciphertext, d, N)
print(f"Message déchiffré : {decrypted_message}")

La fonction pow(base, exp, mod) de Python utilise un algorithme rapide appelé « exponentiation rapide (par carrés successifs) » en interne, de sorte que même pour des nombres de centaines de chiffres, le calcul se termine en un clin d’œil.

11. Résumé et avenir des technologies cryptographiques

Nous avons percé les secrets du mécanisme de la cryptographie RSA, en nous basant sur les connaissances mathématiques du lycée.

La difficulté de la décomposition en facteurs premiers : Il est facile de calculer $p \times q = N$, mais il est très difficile de trouver $p, q$ à partir de $N$.
Congruence et théorème d’Euler : Grâce à la règle $a^{\phi(N)} \equiv 1 \pmod N$, la porte dérobée magique « revenir à l’original lorsqu’on élève à une certaine puissance » est achevée.
Clé publique et clé privée : N’importe qui peut chiffrer, mais seul le destinataire légitime peut déchiffrer.

Le $N$ de la cryptographie RSA actuellement utilisé comporte plus de 600 chiffres, et même si on mobilisait tous les superordinateurs du monde, la décomposition en facteurs premiers prendrait plus de temps que l’âge de l’univers. Cependant, si les « ordinateurs quantiques » dont la recherche a progressé ces dernières années deviennent un jour utilisables en pratique, cette décomposition pourrait être résolue en un instant grâce à l’« algorithme de Shor ». Pour cette raison, le développement d’une « cryptographie post-quantique », qui ne pourrait pas être cassée même par des ordinateurs quantiques, avance rapidement partout dans le monde.

Les mathématiques avancées, souvent perçues comme « inutiles », protègent en réalité fondamentalement notre vie quotidienne. La cryptographie RSA est le meilleur matériel pédagogique qui nous enseigne la profondeur et la beauté de telles mathématiques. J’espère qu’à travers cet article, vous avez pu ressentir, ne serait-ce qu’un peu, l’intérêt de la cryptographie et des mathématiques.

Qu'est-ce que le chiffrement homomorphe complet (FHE) ? Explication de la clé de la sécurité de nouvelle génération

Fri, 11 Sep 2026 11:00:00 +0900

Alors que le cloud computing et les technologies d’IA s’imposent comme les fondations de notre société, le compromis entre la « confidentialité des données » et l’« utilisation des données » est devenu l’un des défis les plus importants. Bien qu’il y ait une demande croissante pour que les IA analysent des données hautement confidentielles dans le cloud, telles que des données médicales, des informations financières ou des données biométriques personnelles, de nombreuses entreprises hésitent à envoyer leurs données à l’extérieur en raison de préoccupations liées à la sécurité.

Les technologies de chiffrement traditionnelles (telles qu’AES et RSA) excellent à protéger les données stockées (Data at Rest) et les données en transit sur le réseau (Data in Transit). Cependant, lorsque le serveur effectue des traitements (calculs) sur les données, comme des recherches ou de l’apprentissage automatique (Data in Use), il est nécessaire de déchiffrer au préalable les données pour les ramener en texte clair. Si le serveur est piraté au moment du déchiffrement, ou si un administrateur interne malveillant jette un coup d’œil aux données, cela conduit directement à une fuite d’informations.

La technologie de rêve qui surmonte cette faiblesse fondamentale du « déchiffrement lors du traitement » est le Chiffrement Homomorphe Complet (Fully Homomorphic Encryption : FHE). L’utilisation du FHE permet d’effectuer des calculs sur les données tout en les gardant chiffrées, sans jamais les déchiffrer, et de renvoyer uniquement le texte chiffré du résultat au client.

Dans cet article, nous expliquerons en profondeur le FHE, clé de la sécurité de nouvelle génération, de son concept à son histoire, en passant par la percée révolutionnaire de Craig Gentry, ses bases mathématiques (comme le Ring-LWE), son plus grand défi qu’est le « bruit » et sa solution (le bootstrapping), jusqu’aux dernières bibliothèques d’implémentation.

1. Qu’est-ce que le chiffrement homomorphe ? Concepts de base

« Homomorphe » est un terme d’algèbre qui désigne la propriété de pouvoir mapper des ensembles ayant une certaine structure tout en préservant la structure de leurs opérations. Dans la théorie de la cryptographie, l’« homomorphisme » est la propriété selon laquelle les opérations dans l’espace du texte clair correspondent aux opérations dans l’espace du texte chiffré.

Exprimé par une formule mathématique simple, soit $E(\cdot)$ la fonction de chiffrement et $D(\cdot)$ la fonction de déchiffrement pour les textes clairs $m_1$ et $m_2$. Si $\circ$ est une opération (comme l’addition ou la multiplication) sur les textes clairs, et $\diamond$ une opération sur les textes chiffrés, la relation suivante est établie :

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

En d’autres termes, déchiffrer le résultat de l’application d’une certaine opération $\diamond$ sur les textes chiffrés $E(m_1)$ et $E(m_2)$ donnera exactement le même résultat que l’opération $\circ$ appliquée sur les textes clairs d’origine.

Flux de données dans le cloud computing

L’architecture de traitement dans le cloud utilisant le FHE est complètement différente des architectures traditionnelles. Le diagramme ci-dessous illustre le flux de traitement de données sécurisé tirant parti du FHE.

graph TD A["Client (Détient la clé privée)"] -->|1. Chiffre le texte clair x : E(x)| B["Serveur Cloud (Uniquement données chiffrées)"] B -->|2. Applique la fonction f en gardant le chiffrement : E(f(x))| B B -->|3. Texte chiffré du résultat du calcul E(y)| A A -->|4. Déchiffre avec la clé privée : y = f(x)| A style A fill:#d4edda,stroke:#28a745 style B fill:#f8d7da,stroke:#dc3545

Le serveur reçoit les données chiffrées $E(x)$, mais ne possédant pas la clé privée, il lui est absolument impossible d’en connaître le contenu. Cependant, en utilisant les propriétés du FHE, il peut appliquer une fonction $f$ (par exemple, un modèle d’inférence d’apprentissage automatique) au texte chiffré pour générer $E(f(x))$. Le client le reçoit et le déchiffre avec sa propre clé privée, obtenant ainsi le résultat souhaité $y = f(x)$.

2. L’histoire de l’évolution du chiffrement homomorphe : PHE, SHE, FHE

Le chiffrement homomorphe n’a pas atteint sa forme « complète » actuelle en une seule fois. Il est largement classé en trois étapes selon le type et le nombre d’opérations réalisables.

Chiffrement Partiellement Homomorphe (PHE : Partially Homomorphic Encryption)

Le PHE est un schéma de chiffrement permettant d’effectuer soit des additions, soit des multiplications, de manière illimitée. En réalité, des chiffrements possédant cette propriété existent depuis longtemps.

Chiffrement RSA (homomorphisme vis-à-vis de la multiplication) Le chiffrement RSA possède involontairement un homomorphisme multiplicatif. Soit les textes clairs $m_1, m_2$ et la clé publique $(e, N)$ : $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ En les multipliant : $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ Ainsi, la multiplication des textes chiffrés correspond à la multiplication des textes clairs.
Chiffrement de Paillier (homomorphisme vis-à-vis de l’addition) Inventé en 1999, le chiffrement de Paillier possède un homomorphisme pour l’addition. Il est utilisé de manière pratique dans des applications telles que le vote électronique (où les votes chiffrés sont comptés, et seul le résultat final est déchiffré).

Chiffrement Quelque Peu Homomorphe (SHE : Somewhat Homomorphic Encryption)

C’est une méthode permettant d’exécuter à la fois des additions et des multiplications, mais avec une limite sur le nombre d’opérations (la profondeur du circuit). En raison de l’accumulation du « bruit » (expliqué plus tard), effectuer plus d’un certain nombre de multiplications rend le déchiffrement impossible. Le chiffrement BGN (Boneh-Goh-Nissim) de 2005 en est un exemple, mais il a ses limites pour effectuer des calculs pratiques complexes (comme le deep learning).

Chiffrement Homomorphe Complet (FHE : Fully Homomorphic Encryption)

Il s’agit d’un schéma de chiffrement permettant d’effectuer à la fois l’addition et la multiplication un nombre illimité de fois. Semblable à la complétude de Turing en théorie de l’information, pouvoir combiner infiniment des additions (équivalentes au XOR) et des multiplications (équivalentes au AND) signifie qu’en principe, n’importe quelle fonction ou algorithme calculable peut être exécuté tout en restant chiffré.

Le FHE a longtemps été considéré comme le « Saint Graal de la cryptographie », et certains disaient même qu’il pourrait être irréalisable. Cependant, en 2009, Craig Gentry, alors étudiant en doctorat à l’Université de Stanford, a proposé le premier schéma FHE utilisant les réseaux idéaux (Ideal Lattices), bouleversant ainsi le monde.

3. Les bases mathématiques du FHE : le problème LWE et Ring-LWE

La plupart des schémas FHE actuellement dominants sont basés sur le problème LWE (Learning With Errors), un défi mathématique de la « cryptographie fondée sur les réseaux (Lattice-based Cryptography) », également connue sous le nom de cryptographie post-quantique.

Compréhension intuitive du problème LWE

Résoudre un système d’équations linéaires est facile en utilisant l’élimination de Gauss ou des méthodes similaires.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

Mais que se passe-t-il si l’on ajoute une très petite « erreur (bruit) aléatoire » $e$ au résultat de ces équations ?

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

Le simple ajout de cette erreur $e$ transforme le problème de la découverte du vecteur de variables secrètes $\vec{s}$ en un problème NP-difficile, complexe à déchiffrer même en utilisant les supercalculateurs actuels ou les ordinateurs quantiques. C’est le problème LWE.

Le problème Ring-LWE (RLWE)

Comme le problème LWE standard implique des opérations matricielles, la taille des clés est extrêmement importante (atteignant parfois des gigaoctets) et l’efficacité des calculs est faible. Pour résoudre ce problème, le problème Ring-LWE (RLWE) utilisant des opérations sur des anneaux de polynômes a été introduit.

Dans le RLWE, les éléments appartiennent à l’anneau polynomial $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ (où $N$ est une puissance de 2 et $q$ est un nombre premier servant de modulo). Soit $s(x)$ le polynôme représentant la clé privée, $a(x)$ un polynôme aléatoire et $e(x)$ un petit polynôme de bruit, la clé publique sera la paire suivante :

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

Lors du chiffrement, on utilise les propriétés de ces polynômes pour encoder le texte clair $m(x)$ et générer le texte chiffré.

4. Le plus grand obstacle : le « bruit » et le Bootstrapping de Gentry

Le concept le plus important pour comprendre le FHE est la « gestion du bruit ».

Dans les chiffrements basés sur LWE/RLWE, on introduit intentionnellement un petit « bruit (erreur) » pour garantir la sécurité. En termes généraux, le processus de déchiffrement d’un texte chiffré $c$ d’un texte clair $m$ peut être exprimé par l’équation suivante :

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

Lors du déchiffrement, le texte clair correct $m$ est obtenu en éliminant ce noise par un processus tel que l’arrondi. Cependant, effectuer des opérations homomorphes (en particulier la multiplication) entre des textes chiffrés amplifie considérablement ce bruit.

Addition homomorphe : Le bruit augmente de manière additive ($e_1 + e_2$). C’est une augmentation relativement modérée.
Représentation mathématique de l’homomorphisme par addition homomorphe : $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
Multiplication homomorphe : Le bruit explose de manière multiplicative (car il implique des termes comme $e_1 \times e_2$). Après seulement quelques multiplications, le bruit dépasse le seuil $q/2$, ce qui rend l’arrondi correct impossible et entraîne un échec de déchiffrement.
Représentation mathématique de l’homomorphisme par multiplication homomorphe : $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

C’est la raison pour laquelle le FHE est resté longtemps irréalisable, se limitant au SHE (avec un nombre d’opérations restreint).

La magie du Bootstrapping

La contribution géniale de Craig Gentry a été d’inventer une méthode de réduction de bruit appelée « bootstrapping ». Ce fut un changement de paradigme en cryptographie.

Intuitivement, il s’agit d’une opération où l’« on ‘déchiffre’ le texte chiffré tout en le gardant à l’état chiffré pour le nettoyer et le placer dans un nouveau texte chiffré avant qu’il ne soit submergé de bruit et ne se corrompe ».

Supposons qu’il y ait un texte chiffré avec un bruit élevé, $C_{noisy}$.
Le client remet au préalable au serveur sa clé privée $sk$ « chiffrée avec la clé publique » $E_{pk}(sk)$ (appelée clé de bootstrapping).
Le serveur exécute homomorphiquement un circuit de déchiffrement (Decryption Circuit) sur $C_{noisy}$.
Concrètement, il effectue un « déchiffrement dans l’espace chiffré » sur $E_{pk}(C_{noisy})$ en utilisant $E_{pk}(sk)$.
Bien que ce circuit de déchiffrement lui-même soit une opération homomorphe et génère donc un nouveau bruit, le bruit du nouveau texte chiffré produit, $C_{fresh}$, est réinitialisé à un « niveau fixe » constant.

graph LR A["Texte chiffré à haut bruit C_noisy"] --> B["Circuit de déchiffrement homomorphe (Eval_Dec)"] C["Clé privée chiffrée E(sk)"] --> B B --> D["Texte chiffré à faible bruit C_fresh"] style B fill:#ffeeba,stroke:#ffc107

En exécutant périodiquement ce bootstrapping au cours des calculs, il est théoriquement devenu possible de calculer des circuits d’une profondeur infinie (réalisant ainsi le FHE). Cependant, dans le schéma initial de Gentry, le coût de calcul du processus de bootstrapping était désespérément élevé, prenant de quelques dizaines de minutes à plusieurs heures pour chaque exécution.

5. Générations de FHE et évolution des principaux schémas

Afin de rendre le FHE pratique, les cryptographes du monde entier ont rivalisé pour améliorer les algorithmes. Actuellement, le FHE est principalement classé en quatre générations ou familles.

2ème Génération : Opérations exactes sur les entiers (BGV, BFV)

Apparus entre 2011 et 2012, il s’agit des schémas BGV (Brakerski-Gentry-Vaikuntanathan) et BFV (Brakerski/Fan-Vercauteren). Ils sont basés sur le RLWE et sont adaptés à l’arithmétique modulaire sur les nombres entiers (calculs exacts). Leur particularité est de supporter des techniques de traitement par lots (Batching) telles que SIMD (Single Instruction, Multiple Data), ce qui permet de regrouper des milliers d’emplacements de données dans un seul énorme texte chiffré polynomial pour effectuer des calculs parallèles en une seule fois.

3ème Génération : Accélération du Bootstrapping (GSW, FHEW, TFHE)

Le schéma GSW (Gentry-Sahai-Waters) de 2013 a simplifié la structure du FHE. Et son développement a conduit au TFHE (Fast Fully Homomorphic Encryption over the Torus), qui est l’un des schémas dominants aujourd’hui. La caractéristique du TFHE est que son bootstrapping est extrêmement rapide (de l’ordre de la milliseconde). Il excelle dans les opérations au niveau des portes (circuits logiques tels que AND, XOR), et la taille de son texte chiffré étant relativement petite, il est adapté à l’évaluation rapide de n’importe quel circuit logique.

4ème Génération : Spécialisation dans les calculs approchés et l’apprentissage automatique (CKKS)

Le schéma CKKS (Cheon-Kim-Kim-Song) proposé par Cheon et al. en 2017 est actuellement considéré comme la technologie ultime pour la protection de la vie privée dans l’IA et l’apprentissage automatique. Contrairement aux FHE précédents qui se concentraient sur les « calculs entiers exacts », CKKS supporte les « calculs approchés de nombres à virgule flottante » tout en conservant le chiffrement. Il offre des performances écrasantes dans les calculs de nombres réels où de petites erreurs sont tolérées, comme la formation ou l’inférence des réseaux de neurones.

Le tableau ci-dessous résume comment choisir un schéma en fonction de l’objectif.

Nom du Schéma	Type de Données Préféré	Cas d’Utilisation Recommandés	Caractéristiques
BFV / BGV	Entiers (Integer)	Calculs statistiques exacts, agrégation de données financières, recherche dans des bases de données	Haut débit grâce au traitement par lots SIMD
CKKS	Nombres réels (Real/Complex)	Apprentissage automatique (DNN, régression logistique), traitement du signal	Accélération par calculs approchés, redimensionnement
TFHE	Valeurs booléennes (Boolean)	N’importe quel circuit logique, recherche de chaînes de caractères, évaluation de fonctions non linéaires	Bootstrapping ultra-rapide (de l’ordre de la milliseconde)

6. Pratique : Bibliothèques FHE et code conceptuel

Aujourd’hui, il existe de nombreuses bibliothèques open-source permettant d’utiliser le FHE sans nécessiter une connaissance approfondie de la cryptographie.

Microsoft SEAL (Simple Encrypted Arithmetic Library) : Une bibliothèque C++ supportant BFV, BGV et CKKS. C’est l’une des normes de l’industrie. Son binding Python, TenSEAL, est très populaire parmi les ingénieurs en IA.
Zama (Concrete) : Un framework basé sur TFHE. Il peut être écrit en Rust/Python et fournit la fonctionnalité de compiler des modèles PyTorch existants pour les exécuter sur le FHE (Concrete ML).
OpenFHE : Le successeur de PALISADE, c’est une bibliothèque C++ complète qui supporte tous les principaux schémas.

Exemple de programmation FHE avec Python (TenSEAL)

Ici, nous présentons un exemple conceptuel de code Python utilisant le schéma CKKS pour additionner et multiplier des vecteurs de nombres réels tout en les gardant chiffrés.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. Configuration du contexte (incluant la génération des clés)
# Utilise le schéma CKKS et définit le degré du polynôme à 8192
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # Facteur d'échelle pour les nombres réels

# 2. Côté client : Chiffrement des données
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# Convertit les vecteurs en texte clair en textes chiffrés (initialement exécuté côté client)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. Côté serveur : Opérations tout en gardant le chiffrement (Protection des Data in Use)
# Le serveur ne connaît pas le texte clair, mais peut effectuer des additions et des multiplications
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. Côté client : Déchiffrement des résultats
# Seul le client possédant la clé privée peut voir le résultat
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"Résultat de l'addition déchiffrée : {res_add}")
# Exemple de sortie : [3.5000001, 5.5000001, 7.5000002] (Comprend de légères erreurs dues au calcul approché)

print(f"Résultat de la multiplication déchiffrée : {res_mul}")
# Exemple de sortie : [3.0000002, 7.5000005, 14.0000003]

Comme on peut le voir dans le code ci-dessus, les opérateurs Python normaux comme enc_v1 + enc_v2 peuvent être surchargés pour écrire des calculs entre des textes chiffrés de manière intuitive. Du côté du serveur, l’opération vectorielle est réalisée sans jamais connaître le contenu du vecteur.

7. Les défis du FHE : Performances et Accélération Matérielle

Le FHE offre une sécurité théoriquement parfaite, mais son plus grand défi en matière d’application pratique est la « surcharge de performances ».

Surcharge de calcul : Comparés aux calculs en texte clair, les calculs sur les textes chiffrés sont des milliers à des dizaines de milliers de fois plus lents sur un CPU. La multiplication de polynômes et le bootstrapping nécessitent d’énormes calculs de FFT (Transformée de Fourier Rapide) et de NTT (Transformée Théorique des Nombres).
Expansion de la taille des données (Ciphertext Expansion) : Quelques octets de texte clair peuvent devenir plusieurs mégaoctets une fois chiffrés. Cela exerce une forte pression sur la bande passante de la mémoire et du réseau.

Approches de résolution basées sur le matériel

Pour surmonter cette surcharge, des accélérateurs matériels dédiés au FHE (supportant ASIC, FPGA, GPU) sont en cours de développement dans le monde entier.

Accélération GPU : Des efforts sont en cours pour paralléliser les calculs NTT et le bootstrapping à l’aide de GPU puissants de NVIDIA et d’autres, rapportant des accélérations de plusieurs dizaines de fois par rapport aux implémentations logicielles (par exemple : 100x.ai, le backend CUDA TFHE-rs de Zama).
Projet DARPA DPRIVE : La Defense Advanced Research Projects Agency (DARPA) mène un projet de développement matériel dédié appelé « DPRIVE (Data Protection in Virtual Environments) » visant à ramener la vitesse de calcul du FHE à un niveau équivalent à celui du traitement en texte clair (une surcharge inférieure à 10 fois), avec la participation d’entreprises telles qu’Intel, Microsoft et Intellectual Ventures.
L’émergence du FPU (FHE Processing Unit) : Des startups comme Cornami et Optalysys se lancent dans le développement de puces dédiées au FHE utilisant l’informatique optique ou des architectures en silicium spécialisées.

Dans un avenir proche, tout comme pour les NPU (Neural Processing Unit) en IA, nous pourrions voir une époque où les « FPU » deviendront des équipements standard dans les serveurs et les infrastructures cloud.

8. Cas d’utilisation attendus

Maintenant que le FHE atteint des vitesses pratiques, des innovations disruptives sont attendues dans les domaines suivants :

Protection de la vie privée dans le domaine médical et l’analyse génomique : En utilisant le FHE pour former l’IA dans le cloud sur des dossiers médicaux et des données ADN de patients provenant de plusieurs hôpitaux tout en conservant les données chiffrées, il est possible de développer des modèles de diagnostic du cancer très précis et de nouveaux médicaments sans violer les lois sur la vie privée (comme HIPAA ou le RGPD).
Détection des fraudes et lutte contre le blanchiment d’argent (AML) dans les institutions financières : Des banques concurrentes pourraient effectuer des analyses interbancaires en croisant leurs données à l’état chiffré, sans révéler les informations des comptes de leurs clients ou l’historique de leurs transactions, ce qui permettrait de détecter d’énormes réseaux de transferts frauduleux.
API d’inférence d’IA sécurisée (MaaS : Model as a Service) : Les utilisateurs chiffrent leur propre voix, l’image de leur visage ou leurs requêtes avant de les envoyer à des services d’IA (tels que des LLM comme ChatGPT). Le fournisseur d’IA génère une réponse sans jamais connaître l’entrée de l’utilisateur, et la renvoie sous forme de texte chiffré. Cela dissipe complètement la crainte que « l’IA apprenne ou s’approprie des informations personnelles ».

9. Conclusion : L’avenir de la cryptographie se dirige vers le « calcul invisible »

Tout comme l’invention de la cryptographie à clé publique (RSA) dans les années 1970 a rendu possible des communications sécurisées sur Internet (comme le HTTPS), l’invention du FHE par Craig Gentry constitue l’une des étapes les plus importantes de l’histoire de la cryptographie.

Aujourd’hui, le Chiffrement Homomorphe Complet (FHE) est sorti de la théorie des laboratoires, et des entreprises telles que Microsoft, IBM, Intel, Google et de nombreuses startups se font une concurrence féroce pour le rendre pratique. Bien que des défis liés aux coûts de calcul et à la taille des données subsistent, grâce au raffinement des algorithmes et à l’évolution des accélérateurs matériels, les performances continuent de s’améliorer à un rythme dépassant la loi de Moore.

Dans quelques années, « effectuer des calculs sur des données tout en les gardant chiffrées » ne sera plus quelque chose de spécial, mais deviendra une bonne pratique standard en matière de protection des données dans les services cloud. Le FHE est la clé de la sécurité de nouvelle génération qui réalise l’équilibre ultime entre la vie privée et l’utilisation des données dans une société axée sur les données.

Fondements mathématiques de la cryptographie sur les courbes elliptiques (ECC) et implémentation en C++

Fri, 11 Sep 2026 10:00:00 +0900

Fondements mathématiques de la cryptographie sur les courbes elliptiques (ECC) et implémentation en C++

Dans les technologies de cryptographie modernes, la cryptographie sur les courbes elliptiques (Elliptic Curve Cryptography : ECC) joue un rôle extrêmement important. De nos communications Internet quotidiennes (HTTPS/TLS) aux enclaves sécurisées des smartphones, en passant par l’authentification des serveurs via SSH, l’authentification sans mot de passe comme FIDO, et même les crypto-actifs tels que Bitcoin et Ethereum, on peut dire sans exagérer que la base de confiance de la société numérique moderne est soutenue par l’ECC.

Dans cet article, nous expliquerons en profondeur, avec un volume de contenu impressionnant, le fonctionnement de cette cryptographie sur les courbes elliptiques. Nous partirons de la théorie mathématique sous-jacente, belle mais complexe (géométrie algébrique sur les corps finis), pour aller jusqu’à la méthode d’implémentation réelle en C++, et enfin aux techniques de codage sécurisé pour prévenir les attaques par canaux auxiliaires (attaques temporelles).

1. Pourquoi la cryptographie sur les courbes elliptiques ? (Comparaison avec RSA)

Pendant longtemps, le synonyme de cryptographie à clé publique a été la cryptographie RSA. La sécurité de RSA repose sur la “difficulté de la factorisation en nombres premiers de très grands nombres composés”. Cependant, avec l’amélioration de la puissance de calcul des ordinateurs, il a été nécessaire d’allonger continuellement la taille des clés RSA (le nombre de bits du module) pour maintenir la sécurité. Aujourd’hui, une taille de clé d’au moins 2048 bits est recommandée, voire 3072 bits ou 4096 bits pour plus de sécurité.

En revanche, la cryptographie sur les courbes elliptiques (ECC) repose sur une autre difficulté mathématique appelée le “problème du logarithme discret sur les courbes elliptiques (ECDLP)”. Jusqu’à présent, aucun algorithme efficace (comme les algorithmes en temps sous-exponentiel) pour résoudre l’ECDLP n’a été découvert, et même les méthodes d’attaque les plus efficaces connues nécessitent un temps exponentiel.

Grâce à cette propriété, l’ECC possède l’avantage décisif de pouvoir atteindre un niveau de sécurité équivalent à celui de RSA avec une taille de clé beaucoup plus courte.

Niveau de sécurité (bits)	Taille de clé RSA (bits)	Taille de clé ECC (bits)	Ratio des tailles de clé
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Comme le montre le tableau ci-dessus, pour obtenir un niveau de sécurité de 128 bits (le standard actuel), RSA nécessite une clé de 3072 bits, alors que l’ECC ne nécessite que 256 bits. Cela permet de réduire la quantité de calculs, l’utilisation de la mémoire et d’économiser la bande passante du réseau. L’ECC présente ainsi une supériorité écrasante, en particulier dans les environnements aux ressources limitées comme les appareils IoT et les cartes à puce.

2. Prérequis mathématiques : La théorie des groupes et le monde des corps finis

Pour véritablement comprendre la cryptographie sur les courbes elliptiques, il est nécessaire de maîtriser les concepts de base de l’algèbre abstraite (théorie des groupes et théorie des corps). Nous résumons ici brièvement les connaissances préalables pour construire l’ECC.

2.1. Groupes (Group) et Groupes abéliens

Un groupe (Group) est défini par un ensemble $G$ et une opération binaire sur cet ensemble (nous utiliserons ici l’addition $+$) formant une paire $(G, +)$ qui satisfait aux 4 axiomes suivants :

Clôture (Closure) : Pour tous $a, b \in G$, $a + b \in G$.
Associativité (Associativity) : Pour tous $a, b, c \in G$, $(a + b) + c = a + (b + c)$.
Existence de l’élément neutre (Identity element) : Il existe un élément $e \in G$ tel que pour tout $a \in G$, $a + e = e + a = a$. Dans le cas d’un groupe additif, cet élément neutre est généralement noté $0$ ou $\mathcal{O}$.
Existence de l’inverse (Inverse element) : Pour tout $a \in G$, il existe un élément $b \in G$ tel que $a + b = b + a = e$. Ce $b$ est noté $-a$.

De plus, un groupe qui satisfait la condition suivante, où l’ordre des opérations ne change pas le résultat, est appelé un groupe abélien (ou groupe commutatif) :

Commutativité (Commutativity) : Pour tous $a, b \in G$, $a + b = b + a$.

L’ensemble des points sur une courbe elliptique forme ce groupe abélien en définissant une règle d’addition spécifique.

2.2. Corps finis (Finite Field)

Dans la théorie cryptographique, nous n’utilisons pas des corps ayant un nombre infini et continu d’éléments comme les nombres réels ou complexes, mais plutôt des corps finis (Finite Field) ou corps de Galois (Galois Field), dont le nombre d’éléments est fini.

Le corps fini le plus fondamental est le corps premier $\mathbb{F}_p$ utilisant un nombre premier $p$. Il s’agit de l’ensemble des entiers $\{0, 1, 2, \dots, p-1\}$ muni des quatre opérations arithmétiques (addition, soustraction, multiplication, division) définies modulo $p$ (le reste de la division par $p$).

Addition : $(a + b) \pmod p$
Soustraction : $(a - b) \pmod p$
Multiplication : $(a \times b) \pmod p$
Division : $a \times b^{-1} \pmod p$ (où $b^{-1}$ est l’inverse multiplicatif de $b$ modulo $p$)

Le calcul de l’inverse multiplicatif (Modular Multiplicative Inverse) est extrêmement important dans l’implémentation cryptographique. Pour trouver $b^{-1}$ satisfaisant $b \times b^{-1} \equiv 1 \pmod p$, les deux algorithmes suivants sont principalement utilisés :

Algorithme d’Euclide étendu (Extended Euclidean Algorithm) : Il est rapide, mais selon l’implémentation, le temps de traitement dépend des valeurs d’entrée, ce qui présente un risque d’attaque temporelle.
Petit théorème de Fermat (Fermat’s Little Theorem) : Lorsque $p$ est un nombre premier et $b \neq 0$, $b^{p-1} \equiv 1 \pmod p$ est vrai. En divisant les deux côtés par $b$, on obtient $b^{p-2} \equiv b^{-1} \pmod p$. Autrement dit, l’inverse peut être trouvé en calculant $b$ à la puissance $p-2$. Comme l’opération d’exponentiation est plus facile à implémenter en temps constant, elle est préférée dans les implémentations cryptographiques.

3. L’équation de la courbe elliptique et géométrie

3.1. Forme normale de Weierstrass

Une courbe elliptique (Elliptic Curve) est une courbe plane généralement définie par l’équation suivante, appelée forme normale de Weierstrass (Weierstrass normal form) :

$$ y^2 = x^3 + ax + b $$

Ici, $a$ et $b$ sont des constantes, et pour que la courbe n’ait pas de points singuliers (auto-intersections ou points de rebroussement) (pour qu’elle soit une courbe lisse), la condition est que le discriminant (Discriminant) $\Delta$ suivant ne soit pas nul :

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

Les courbes avec des points singuliers compromettent la sécurité cryptographique, c’est pourquoi on choisit toujours des coefficients $a, b$ qui satisfont à cette condition.

3.2. Le point à l’infini (Point at Infinity)

Pour faire de la courbe elliptique un groupe mathématiquement complet, en plus des points sur le plan, un point virtuel appelé “point à l’infini (Point at Infinity)” est introduit. Il est noté $\mathcal{O}$ (O majuscule).

Le point à l’infini $\mathcal{O}$ est défini comme le point où toutes les lignes verticales se croisent à l’infini. Dans la théorie des groupes, ce point à l’infini $\mathcal{O}$ fonctionne comme l’élément neutre de l’addition (zéro).

Autrement dit, pour tout point $P$ sur la courbe :

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

De plus, l’inverse $-P$ du point $P = (x, y)$ est défini comme le point symétrique par rapport à l’axe des x, soit $(x, -y)$. Par conséquent :

$$ P + (-P) = \mathcal{O} $$

4. Opérations de groupe sur la courbe elliptique (Addition de points et doublement)

Le fondement de la cryptographie sur les courbes elliptiques est l’opération d’“addition (Addition)” de points sur la courbe. Ceci est différent de l’addition d’entiers ordinaires et est défini sur la base d’opérations géométriques.

4.1. Addition géométrique (Méthode de la tangente et de la sécante)

La procédure pour ajouter deux points distincts $P$ et $Q$ sur la courbe pour obtenir un nouveau point $R$ ($R = P + Q$) est la suivante :

Tracez une ligne droite (sécante) passant par les points $P$ et $Q$.
Cette droite coupera toujours la courbe elliptique en un autre point (que nous appellerons $-R$). (*Selon un théorème de la géométrie algébrique)
Le point symétrique de l’intersection $-R$ par rapport à l’axe des x (le point avec le signe de la coordonnée y inversé) est le point recherché $R$.

graph TD Step1["Tracer une droite reliant P(x1, y1) et Q(x2, y2)"] --> Step2["Trouver la 3ème intersection avec la courbe, -R"] Step2 --> Step3["Refléter -R sur l'axe des x pour obtenir R(x3, y3)"] Step3 -.-> Result["Ceci est R = P + Q"]

4.2. Doublement de point (Point Doubling)

Lorsque l’on ajoute le même point $P$ à $P$ ($P + P = 2P$), on ne peut pas tracer une ligne passant par deux points. Dans ce cas, nous tracons la tangente (Tangent) à la courbe au point $P$.

Tracez la tangente à la courbe au point $P$.
Cette tangente coupera la courbe en un autre point $-R$.
Le point symétrique de cette intersection par rapport à l’axe des x est le point recherché $R = 2P$.

4.3. Formules de calcul algébrique

Nous transposons les opérations géométriques en formules algébriques afin qu’elles puissent être calculées par un ordinateur. Tous les calculs sont effectués sur le corps fini $\mathbb{F}_p$ (modulo $p$).

Soient le point $P = (x_1, y_1)$ et le point $Q = (x_2, y_2)$. Et soit le point de résultat calculé $R = P + Q = (x_3, y_3)$.

Soit $\lambda$ (lambda) la pente de la droite.

[Cas 1 : Lorsque $P \neq Q$ (Addition de points)] La pente $\lambda$ est le taux de variation entre les deux points.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

En utilisant ce $\lambda$, $x_3, y_3$ sont calculés comme suit :

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[Cas 2 : Lorsque $P = Q$ (Doublement de point)] La pente $\lambda$ est la pente de la tangente obtenue par dérivation. (On dérive implicitement $y^2 = x^3 + ax + b$)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

Par conséquent,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

Les équations pour $x_3, y_3$ ont la même forme que l’addition, mais puisque $x_2 = x_1$, elles deviennent :

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] Ces formules contiennent des divisions (calcul de l’inverse modulo) telles que $(x_2 - x_1)^{-1}$ et $(2y_1)^{-1}$. Le calcul de l’inverse modulo ayant un coût de calcul très élevé, les implémentations réelles utilisent généralement des systèmes de coordonnées projectives comme les “coordonnées jacobiennes (Jacobian Coordinates)” pour retarder la division.

5. Multiplication scalaire et problème du logarithme discret sur les courbes elliptiques (ECDLP)

Dans la cryptographie sur les courbes elliptiques, l’opération qui demande le plus de calculs et qui constitue le cœur de la sécurité est la multiplication scalaire (Scalar Multiplication).

5.1. Qu’est-ce que la multiplication scalaire ?

L’opération consistant à additionner un certain point $P$, $k$ fois est appelée multiplication scalaire, notée $kP$.

$$ kP = \underbrace{P + P + \dots + P}_{k\text{ fois}} $$

Ici, $k$ est un très grand nombre entier (par exemple, un entier de 256 bits).

5.2. Problème du logarithme discret sur les courbes elliptiques (ECDLP)

La sécurité de l’ECC dépend de la difficulté du problème suivant :

Problème du logarithme discret sur les courbes elliptiques (Elliptic Curve Discrete Logarithm Problem : ECDLP) Étant donné un point connu $P$ (point de base) et un point calculé $Q$, trouver le scalaire $k$ tel que $Q = kP$.

Il est facile (en temps polynomial) de calculer $Q$ à partir de $k$ et $P$ (sens direct) en utilisant l’algorithme décrit plus loin, mais il est pratiquement impossible de calculer à l’envers $k$ à partir de $P$ et $Q$ (sens inverse), car il n’existe pas de méthode efficace autre que la recherche exhaustive (fonction à sens unique). Dans les protocoles cryptographiques, $k$ correspond à la “clé privée” et $Q$ à la “clé publique”.

5.3. L’algorithme Double-and-Add

Lorsque $k$ est un nombre énorme (par exemple, $2^{256}$), l’addition naïve de $P$ $k$ fois ne se terminerait pas avant la fin de l’univers. Par conséquent, pour effectuer rapidement la multiplication scalaire, on utilise la méthode Double-and-Add (méthode binaire).

C’est la version courbe elliptique de l’“exponentiation rapide” utilisée pour calculer rapidement les puissances entières. Le scalaire $k$ est représenté en binaire, et traité dans l’ordre, du bit de poids fort au bit de poids faible.

Initialiser le point de résultat $R$ avec $\mathcal{O}$.
Répéter ce qui suit du bit de poids fort de $k$ jusqu’au bit de poids faible :
- Doubler $R$ (Point Doubling : $R = 2R$)
- Si le bit actuel est 1, ajouter $P$ à $R$ (Point Addition : $R = R + P$)

Grâce à cet algorithme, la complexité passe de $O(k)$ à $O(\log_2 k)$ de façon drastique, permettant des calculs dans un temps réaliste (de l’ordre de la milliseconde).

6. L’échange de clés Diffie-Hellman sur courbes elliptiques (ECDH)

Nous expliquons ici le fonctionnement du protocole d’échange de clés ECDH (Elliptic Curve Diffie-Hellman), qui est l’application la plus représentative de l’ECC. L’ECDH est un mécanisme permettant à Alice et Bob de générer et de partager en toute sécurité une clé secrète commune (clé de session) sur un canal de communication vulnérable à l’écoute (c’est le cœur du handshake TLS).

[Paramètres préalables (Paramètres de domaine)] Les deux parties partagent au préalable la courbe elliptique $E$ à utiliser, le nombre premier $p$ et le point de base $G$. (Par exemple NIST P-256 ou secp256k1)

sequenceDiagram participant Alice as "Alice" participant Bob as "Bob" Note over Alice,Bob: "Paramètres publics : Courbe E, point de base G, premier p" Alice->>Alice: "Générer la clé privée d_A (entier aléatoire)" Alice->>Alice: "Calculer la clé publique Q_A = d_A * G" Bob->>Bob: "Générer la clé privée d_B (entier aléatoire)" Bob->>Bob: "Calculer la clé publique Q_B = d_B * G" Alice->>Bob: "Envoyer la clé publique Q_A (en clair)" Bob->>Alice: "Envoyer la clé publique Q_B (en clair)" Alice->>Alice: "Calculer le secret partagé S = d_A * Q_B" Bob->>Bob: "Calculer le secret partagé S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "Les résultats de calcul S des deux parties correspondent parfaitement !"

Un attaquant (Eve) peut intercepter $G$, $Q_A$ et $Q_B$ circulant sur le canal de communication, mais en raison de la difficulté de l’ECDLP, il ne peut pas déduire la clé privée d’Alice $d_A$ à partir de $Q_A = d_A \cdot G$. De plus, multiplier $Q_A$ et $Q_B$ ne donne pas la clé partagée $S$, donc un attaquant ne peut pas calculer $S$.

7. Pièges d’implémentation : Attaques par canaux auxiliaires et contre-mesures

Même avec un algorithme cryptographique théoriquement parfait, des vulnérabilités peuvent apparaître lors du processus d’implémentation du programme. C’est ce qu’on appelle les “attaques par canaux auxiliaires (Side-Channel Attack)”.

7.1. Attaque temporelle (Timing Attack)

Revenons sur l’algorithme Double-and-Add mentionné précédemment.

1
2
3
4
5
6
7
8


// Pseudo-code vulnérable du Double-and-Add
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Toujours exécuté
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // Exécuté uniquement quand le bit est à 1 !
 }
}

Cette implémentation présente un défaut fatal. Comme la Point Addition est exécutée lorsque le bit est 1, le temps de calcul est légèrement plus long que lorsque le bit est 0. De plus, la prédiction de branchement du processeur et le comportement de la mémoire cache changent. En observant statistiquement cette infime différence de temps de calcul (ou de consommation d’énergie) des milliers de fois, un attaquant peut récupérer complètement la séquence de bits de la clé privée $k$ un par un. C’est une attaque temporelle.

7.2. Implémentation en temps constant (Constant-Time) : L’échelle de Montgomery (Montgomery Ladder)

Pour empêcher les attaques temporelles, il est nécessaire d’adopter un algorithme dont la séquence d’instructions exécutées et le temps de calcul sont toujours constants (Constant-Time), quelle que soit la valeur des bits de la clé privée.

L’exemple le plus représentatif est l’échelle de Montgomery (Montgomery Ladder).

graph TD Start["Initialisation : R0 = O, R1 = P"] --> LoopStart["Pour chaque bit i (depuis le poids fort)"] LoopStart --> Cond{"Valeur de k_i ?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["Bit suivant"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Tous les bits terminés"| End["Fin : R0 est le résultat (kP)"]

La beauté de l’échelle de Montgomery réside dans le fait que, que le bit soit 0 ou 1, “exactement 1 Point Addition et 1 Point Doubling” sont toujours exécutés. Cela élimine complètement la dépendance des données sur le temps de calcul.

Cependant, si le branchement conditionnel (if (k_i == 0)) lui-même existe, il reste un risque que le temps d’exécution fluctue en raison des optimisations du compilateur ou de la prédiction de branchement du processeur. Par conséquent, dans les implémentations réelles en temps constant, les branchements conditionnels (instructions if) sont éliminés, et un échange conditionnel utilisant des opérations bit à bit (Conditional Swap) est utilisé.

8. Implémentation de la cryptographie sur les courbes elliptiques en C++

À partir de là, nous allons traduire la théorie en code C++. Les bibliothèques cryptographiques pratiques (telles que OpenSSL ou libsodium) utilisent des optimisations avancées en assembleur et des systèmes de coordonnées jacobiennes, mais ici, pour approfondir la compréhension mathématique, nous présenterons le squelette d’une implémentation claire en temps constant utilisant des coordonnées affines.

Nous supposerons l’utilisation de boost::multiprecision::cpp_int pour les opérations sur les très grands entiers.

8.1. Arithmétique modulaire et inverse

Tout d’abord, nous définissons des fonctions d’aide pour les opérations sur les corps finis. Nous implémentons le calcul de l’inverse en utilisant le petit théorème de Fermat.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// Exemple avec le premier p et les paramètres de secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Opération modulo retournant un reste positif
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// Calcul de l'exponentiation modulaire (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// Inverse modulo utilisant le petit théorème de Fermat
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Prémisse que m est premier : n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Représentation des points et opérations de groupe (Addition, Doublement)

Nous définissons une structure Point qui gère le point à l’infini avec un drapeau, et nous implémentons les formules d’addition.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // Création d'un point à l'infini
 Point() : x(0), y(0), isInfinity(true) {}

 // Création d'un point normal
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Addition de points sur la courbe elliptique (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = Point à l'infini
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (Cas où P = Q)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (Cas où P != Q)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Implémentation du Conditional Swap en temps constant

Lors de l’échange du contenu des variables basé sur la valeur du bit de la clé privée, nous effectuons l’échange uniquement avec des opérations bit à bit (masque) sans utiliser l’instruction if. Cela garantit que le chemin d’exécution reste parfaitement constant.

[!TIP] Dans une implémentation réelle, une classe d’entiers à précision multiple allouée dynamiquement comme cpp_int ne convient pas au traitement en temps constant. En effet, des informations temporelles fuient en raison des allocations de mémoire et des variations de taille des tableaux. Les bibliothèques pratiques les représentent sous forme de taille fixe (par exemple, un tableau de uint64_t × 4 éléments) et implémentent le traitement des masques au niveau du bit. Voici un exemple conceptuel.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Conditional Swap conceptuel en temps constant (supposant des entiers de taille fixe)
// Si le bit est 1, échanger P1 et P2, sinon ne pas échanger
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit vaut 0 ou 1. Le masque est tout à 1 (0xFF..) si bit=1, et tout à 0 si bit=0.
 // (Ici pour l'explication, nous supposons que chaque mot de la classe BigInt de taille fixe est w)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // Traiter les coordonnées y et le drapeau isInfinity de la même manière
 }
 */

 // * Un échange parfait en temps constant est difficile avec boost::multiprecision,
 // donc nous nous limitons ici à une simulation par branchement pour la compréhension de la logique.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Multiplication scalaire avec l’échelle de Montgomery

En combinant les pointAdd et cswap précédents, nous implémentons une multiplication scalaire sécurisée.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Multiplication scalaire k * P (Méthode Montgomery Ladder)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Point à l'infini
 Point R1 = P;

 // Obtenir la longueur en bits de k (256 bits pour secp256k1)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Obtenir la valeur du i-ème bit (0 ou 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Si bit == 1, échanger R0 et R1
 cswap(R0, R1, bit);

 // Toujours exécuter les mêmes opérations (Point Addition et Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Si bit == 1, échanger à nouveau pour restaurer l'état
 cswap(R0, R1, bit);
 }

 return R0;
}

Avec cette logique d’implémentation, que chaque bit du scalaire $k$ soit 0 ou 1, les opérations exécutées dans chaque itération de la boucle (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) suivent exactement le même flux. Cela empêche efficacement la fuite d’informations secrètes via des différences de timing ou de modèles d’accès au cache.

9. Conclusion

La cryptographie sur les courbes elliptiques (ECC) peut sembler mystérieuse à première vue : “Comment une opération géométrique consistant à tracer une droite et refléter son intersection peut-elle devenir une cryptographie ?”. Cependant, en la mappant sur le monde discret des corps finis, on peut construire une magnifique fonction à sens unique (problème du logarithme discret), fruit d’une fusion miraculeuse entre les mathématiques et la cryptographie.

Cet article a expliqué les points importants suivants :

Supériorité par rapport à RSA : Offre une sécurité forte avec une taille de clé très courte, ce qui est optimal pour l’ère moderne du mobile et de l’IoT.
Fondements de la théorie des groupes et des corps finis : Les structures mathématiques sur lesquelles repose l’ECC.
Formules d’addition et de doublement : Méthode d’implémentation des opérations algébriques de groupe à l’aide de l’équation de Weierstrass.
Menace des attaques par canaux auxiliaires : Le fait que les branchements conditionnels dépendants des bits de la clé privée créent une vulnérabilité fatale.
Implémentation en temps constant (Constant-Time) : Technique de codage en C++ pour homogénéiser le comportement au niveau matériel et prévenir les attaques à l’aide du Montgomery Ladder et du Conditional Swap.

Écrire soi-même une bibliothèque cryptographique fonctionnant en environnement de production est fortement déconseillé (“Don’t roll your own crypto”) car les risques de sécurité sont extrêmement élevés. Cependant, comprendre en profondeur les algorithmes et le contexte mathématique qui fonctionnent en son sein devrait être une arme incroyablement puissante pour les ingénieurs concevant et exploitant des systèmes plus sécurisés et plus performants.

Dans le prochain article, nous approfondirons le mécanisme de l’ECDSA (Elliptic Curve Digital Signature Algorithm), un algorithme de signature numérique utilisant ces courbes elliptiques, ainsi que les signatures de Schnorr adoptées par Bitcoin.

Simulation de l'algorithme de Shor en Python

Fri, 11 Sep 2026 08:00:00 +0900

1. Introduction : La crise de la cryptographie provoquée par les ordinateurs quantiques

Une grande partie de la sécurité dans notre société Internet moderne repose sur la cryptographie à clé publique (en particulier le chiffrement RSA). Lorsque nous transmettons nos informations de carte de crédit lors d’achats en ligne ou que nous échangeons des données hautement confidentielles, ces communications sont solidement protégées par le chiffrement RSA.

La sécurité du chiffrement RSA repose sur un fait mathématique : « la factorisation en nombres premiers de très grands entiers est extrêmement difficile pour les ordinateurs classiques (les PC ou supercalculateurs que nous utilisons habituellement) ». Cependant, l’« algorithme de Shor » (Shor’s Algorithm), publié en 1994 par Peter Shor, a complètement remis en cause ce postulat. Il a été prouvé mathématiquement que si l’algorithme de Shor était exécuté sur un ordinateur quantique à grande échelle, il pourrait résoudre en quelques minutes ou quelques heures une factorisation qui prendrait plus de temps que l’âge de l’univers sur un ordinateur classique.

Dans cet article, nous expliquerons en détail comment cet algorithme de Shor parvient à effectuer cette factorisation à grande vitesse, de son mécanisme mathématique jusqu’à une implémentation de simulation concrète en Python utilisant le framework de calcul quantique Qiskit.

2. Le changement spectaculaire de la complexité : De la fonction exponentielle au temps polynomial

Pourquoi la factorisation en nombres premiers est-elle si difficile ? Même en utilisant le « crible général du corps de nombres » (General Number Field Sieve, GNFS), connu comme le meilleur algorithme de factorisation pour les ordinateurs classiques, sa complexité en temps reste sous-exponentielle.

La complexité en temps pour factoriser un nombre composé de $N$ chiffres avec une méthode classique est la suivante :

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Pour cette raison, il suffit d’augmenter la longueur de la clé (par exemple à 2048 ou 4096 bits) pour que le temps de décryptage sur un ordinateur classique devienne irréaliste, atteignant des milliers ou des dizaines de milliers d’années.

Cependant, en utilisant l’algorithme de Shor sur un ordinateur quantique, la complexité est considérablement réduite à un temps polynomial par rapport au nombre de bits d’entrée $\log N$.

$$ O((\log N)^3) $$

Cela signifie que si l’on double le nombre de bits, le temps de calcul augmente de manière astronomique pour un ordinateur classique, alors qu’il n’est multiplié que par 8 environ pour un ordinateur quantique. Cette réduction de la classe de complexité d’un temps exponentiel à un temps polynomial (inclusion dans la classe BQP) est ce qui rend l’algorithme de Shor si impressionnant.

graph TD A["Augmentation de la taille de l'entrée N (nombre de bits)"] --> B{"Choix de l'algorithme"} B -->|Classique : Crible général du corps de nombres| C["Augmentation sous-exponentielle O(exp(...))"] B -->|Quantique : Algorithme de Shor| D["Temps polynomial O((log N)^3)"] C --> E["Milliers à milliards d'années (Indéchiffrable)"] D --> F["Quelques minutes à quelques heures (Déchiffrable en un temps réaliste)"]

3. Vue d’ensemble de l’algorithme et contexte mathématique

En réalité, l’algorithme de Shor n’effectue pas toutes les opérations sur un ordinateur quantique. Il repose sur la collaboration entre des pré-traitements et post-traitements par un ordinateur classique, et la partie centrale (l’algorithme de recherche de période) exécutée par un ordinateur quantique.

Le flux global de l’algorithme est le suivant :

graph TD A["Entrée : Nombre composé N à factoriser"] --> B["Choisir un nombre aléatoire a tel que a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Oui" --> D["Afficher le facteur trivial gcd(a, N) et terminer"] C -- "Non" --> E["Trouver la période r de f(x) = a^x mod N avec un algorithme quantique"] E --> F{"r est pair ET a^(r/2) ≢ -1 mod N ?"} F -- "Non" --> B F -- "Oui" --> G["Calculer les facteurs p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Sortie : p, q"]

Réduction de la factorisation au problème de recherche de période

L’intuition géniale de Shor réside dans la transformation du « problème de factorisation » en un « problème de recherche de période » (Order Finding Problem).

Considérons un entier $N$ (le nombre à factoriser) et un entier premier avec lui $a$ ($1 < a < N$). Nous définissons la fonction d’exponentiation modulaire suivante :

$$ f(x) = a^x \bmod N $$

Cette fonction possède une certaine période $r$. Cela signifie que pour tout $x$, on a $f(x+r) = f(x)$. En particulier pour $x=0$, le plus petit entier positif $r$ tel que :

$$ a^r \equiv 1 \pmod N $$

est appelé l’« ordre » (Order) de $a$ modulo $N$. Si nous parvenons à trouver cette période $r$, nous pouvons en déduire les facteurs premiers de la manière suivante.

En transformant l’équation, on obtient :

$$ a^r - 1 \equiv 0 \pmod N $$

Si $r$ est pair, nous pouvons factoriser en utilisant la différence de deux carrés :

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Cela implique que $N$ partage un diviseur commun avec $(a^{r/2} - 1)$ ou $(a^{r/2} + 1)$ (à condition que $a^{r/2} \not\equiv -1 \pmod N$). Ainsi, en utilisant l’algorithme d’Euclide pour calculer :

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

nous pouvons trouver des facteurs non triviaux $p$ et $q$ de $N$. Ces calculs (le plus grand commun diviseur et la génération de nombres aléatoires) sont très rapides sur un ordinateur classique. Le cœur du problème est donc de savoir comment trouver rapidement la période $r$. Sur un ordinateur classique, trouver cette période requiert un temps exponentiel. C’est ici que l’ordinateur quantique entre en jeu.

4. La partie algorithmique quantique : Le mécanisme de recherche de période

La sous-routine permettant de trouver la période $r$ à l’aide d’un ordinateur quantique se compose des 4 étapes suivantes :

graph LR subgraph "Évolution de l'état quantique" S1["|0⟩|0⟩ (Initialisation)"] --> S2["Porte H : Superposition Σ|x⟩|0⟩"] S2 --> S3["Oracle U : Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT : Extraction de la période par interférence"] S4 --> S5["Mesure : Obtention de la valeur approchée y"] end

Étape 1 : Initialisation des registres quantiques et superposition

Tout d’abord, nous préparons deux registres quantiques. Le premier registre sert à entrer l’état, et le second sert à stocker le résultat du calcul de la fonction. L’état initial est entièrement $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Nous appliquons une porte de Hadamard (Hadamard Gate) à tous les qubits du premier registre, créant un état de superposition équiprobable de toutes les entrées possibles $x$ (de $0$ à $Q-1$, avec $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Ainsi, l’ordinateur quantique conserve simultanément l’état pour les $Q$ entrées en une seule opération. C’est la source puissante du parallélisme quantique.

Étape 2 : Application de la fonction oracle (exponentiation modulaire)

Ensuite, nous utilisons un circuit quantique $U_f$ pour calculer la fonction $f(x) = a^x \bmod N$ et stockons le résultat dans le second registre.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

À ce stade, le premier et le second registre sont dans un état d’intrication quantique (entanglement). Si (hypothétiquement) nous observions le second registre et obtenions une valeur spécifique $k = a^{x_0} \bmod N$, l’état du premier registre s’effondrerait sur la superposition des $x$ qui donnent cette valeur $k$. Puisque la fonction a une période $r$, les états restants seront espacés de $r$, soit $x_0, x_0+r, x_0+2r, \dots$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Cependant, ce n’est pas $x_0$ que nous voulons connaître, mais la période $r$ elle-même. Il est impossible d’observer directement $r$ à partir de cet état. C’est pourquoi nous utilisons la transformée de Fourier quantique.

Étape 3 : Interférence de phase par la transformée de Fourier quantique (QFT)

Nous appliquons la transformée de Fourier quantique (Quantum Fourier Transform, QFT) au premier registre. La QFT est la version quantique de la transformée de Fourier discrète classique et convertit les amplitudes des vecteurs d’état. L’action de la QFT sur l’état de base $|x\rangle$ est définie comme suit :

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Où $\omega = e^{2\pi i / Q}$.

Lorsque la QFT est appliquée, les amplitudes de l’état interfèrent. Bien que nous omettions les détails mathématiques, lorsqu’on applique la QFT à un état ayant une période $r$, les ondes provoquent une interférence constructive uniquement lorsque $y$ est très proche d’un multiple entier de $Q/r$. Pour les autres états, les amplitudes de probabilité s’annulent à cause d’une interférence destructive et s’approchent de zéro.

Étape 4 : Mesure et développement en fractions continues

Enfin, nous mesurons le premier registre. La valeur mesurée $y$ satisfait très probablement à la condition suivante :

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ est un entier inconnu tel que $0 \le c < r$)

En appliquant un algorithme classique de développement en fractions continues (Continued Fraction Expansion) au nombre rationnel obtenu $y/Q$, nous pouvons calculer la fraction approchée $c/r$ et extraire la période $r$ du dénominateur.

5. Implémentation de simulation avec Python et Qiskit

Puisque la théorie seule peut être abstraite, simulons l’algorithme de Shor en pratique avec Python et le framework quantique d’IBM, Qiskit.

Nous implémenterons ici le scénario le plus classique et le plus célèbre : « factoriser $N=15$ en utilisant $a=7$ ».

Préparation de l’environnement d’exécution

Veuillez installer Qiskit au préalable.

1

pip install qiskit qiskit-aer numpy

Aperçu du code de l’implémentation Python

Le code suivant est un exemple d’implémentation de l’algorithme de Shor spécifiquement pour $N=15$ et $a=7$. Étant donné que le coût de calcul pour construire un circuit d’exponentiation modulaire généralisé est trop élevé sur les simulateurs actuels, la logique des portes pour le cas particulier de $a=7$ a été codée en dur (hardcoded).

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Fonction pour construire la transformée de Fourier quantique inverse (QFT†)
def qft_dagger(n):
 """Génère le circuit de la transformée de Fourier quantique inverse pour n qubits"""
 qc = QuantumCircuit(n)
 # Portes SWAP pour inverser l'ordre
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Application des portes de phase contrôlée et H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Fonction pour construire l'opération contrôlée d'exponentiation modulaire 7^x mod 15
def c_amod15(a, power):
 """Génère la porte U contrôlée pour un 'a' spécifique et une puissance (Dédié à N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Logique codée en dur pour 7^x mod 15 avec a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Construction du circuit quantique principal
def shor_circuit(a, n_count):
 # n_count : nombre de bits du registre de contrôle
 # Le registre cible utilise 4 bits pour représenter de 0 à 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Initialisation du 1er registre (registre de contrôle) pour créer la superposition
 for q in range(n_count):
 qc.h(q)

 # Initialisation du 2ème registre (registre cible) à |1> (0001)
 qc.x(3 + n_count)

 # Application de l'opération d'exponentiation modulaire contrôlée (Oracle)
 for q in range(n_count):
 # Applique l'opération à la puissance 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Application de la transformée de Fourier quantique inverse au 1er registre
 qc.append(qft_dagger(n_count), range(n_count))

 # Mesure du 1er registre
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Section d'exécution ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Utilisation de 8 qubits pour le registre de contrôle (Q=256)

 print(f"Paramètres de recherche : N={N}, a={a}, qubits de contrôle={n_count}")

 # Génération du circuit
 qc = shor_circuit(a, n_count)

 # Exécution avec le simulateur
 sim = AerSimulator()
 # La transpilation est recommandée dans les versions récentes de Qiskit
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nRésultats de la mesure (chaîne de bits : nombre d'observations) :")
 for bitstring, count in counts.items():
 print(f" {bitstring} : {count} fois")

 # Post-traitement classique : Détermination de la période r via les fractions continues
 print("\n--- Calcul de la période et factorisation ---")
 phases = []
 for output in counts:
 # Conversion de la chaîne de bits en décimal
 decimal = int(output, 2)
 # Phase = valeur mesurée / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Obtention de la fraction approchée. Le dénominateur max est N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Mesure : {decimal:3d} | Phase : {phase:.4f} | Fraction continue : {frac} | Période estimée r = {r}")

 # Vérification : la période r est-elle paire et produit-elle un résultat valide ?
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Succès ! Les facteurs de {N} sont {guess1} et {guess2}.")
 else:
 print(f" => Facteurs triviaux uniquement. À refaire.")
 else:
 print(f" => Échec car la période est impaire.")

Explication du code et analyse des résultats

L’exécution du code ci-dessus montre des pics spécifiques (valeurs mesurées) avec une forte probabilité pour le registre de contrôle. Dans le cas où n_count=8 ($Q=256$), si nous avions un ordinateur quantique idéal (ou un simulateur), les valeurs 0, 64, 128, 192 apparaîtraient avec une probabilité écrasante.

En divisant ces valeurs par $Q=256$, nous obtenons les phases respectives $y/Q$ de $0.0$, $0.25$, $0.5$ et $0.75$. Le développement en fractions continues de ces phases donne :

$0.25 \to 1/4$ (Période estimée $r=4$)
$0.50 \to 1/2$ (Période estimée $r=2$)
$0.75 \to 3/4$ (Période estimée $r=4$)

En utilisant la période $r=4$ ainsi obtenue, nous calculons les facteurs premiers. Puisque $a=7$ et $r=4$, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Nous avons réussi brillamment la factorisation de $15 = 3 \times 5$.

[!TIP] Si la valeur mesurée est $y=128$ (phase $0.5$), le dénominateur devient $2$, et nous obtenons un diviseur de la vraie période au lieu de $r=4$. Dans ce cas, nous pouvons relancer l’algorithme ou tester les multiples de la période $r$ obtenue pour trouver la vraie période.

6. Défis pour l’application pratique et les limites de l’ère NISQ

Bien qu’il soit facile de factoriser $N=15$ sur un simulateur, factoriser le chiffrement RSA-2048 utilisé dans le monde réel (un nombre de 617 chiffres) se heurte encore à de nombreux obstacles avec les ordinateurs quantiques actuels.

L’époque dans laquelle nous vivons actuellement est appelée l’ère NISQ (Noisy Intermediate-Scale Quantum : ordinateurs quantiques bruités de taille intermédiaire). Les qubits sont extrêmement sensibles au bruit ambiant et subissent de la « décohérence » pendant les calculs, ce qui détruit leur état.

Pour exécuter avec précision un circuit profond (avec de nombreuses portes quantiques) comme l’algorithme de Shor, il est indispensable de disposer de la correction d’erreurs quantiques (Quantum Error Correction). Pour créer un seul « qubit logique » sans bruit, il faut encoder des milliers de « qubits physiques » en utilisant des méthodes comme le code de surface (Surface Code).

Pour casser le chiffrement RSA 2048 bits, on estime qu’il faudrait quelques milliers de qubits logiques parfaits, ce qui nécessiterait un ordinateur quantique tolérant aux pannes (fault-tolerant) doté de plusieurs millions à dizaines de millions de qubits physiques. Les processeurs quantiques les plus avancés d’aujourd’hui ne comptant que quelques centaines à quelques milliers de qubits physiques, les chiffrements du monde entier ne seront pas brisés dans l’immédiat.

[!WARNING] Cependant, il existe un modèle de menace appelé « Store Now, Decrypt Later » (Sauvegarder maintenant, déchiffrer plus tard). Des attaquants pourraient stocker massivement les communications chiffrées actuelles et les déchiffrer entièrement dans 10 à 20 ans dès qu’un ordinateur quantique suffisamment puissant sera construit.

7. Transition vers la cryptographie post-quantique (PQC)

Pour se préparer à l’arrivée du « Q-Day » (le jour où les ordinateurs quantiques briseront la cryptographie), les cryptographes du monde entier, menés par le National Institute of Standards and Technology (NIST) américain, élaborent la cryptographie post-quantique (Post-Quantum Cryptography, PQC).

La PQC est basée sur de nouveaux problèmes mathématiques (problèmes de réseaux euclidiens, polynômes multivariés, fonctions de hachage, etc.) que l’on considère impossibles à résoudre efficacement même avec l’algorithme de Shor (ou l’algorithme de Grover). Des algorithmes comme « CRYSTALS-Kyber » et « CRYSTALS-Dilithium » ont déjà été sélectionnés comme normes standards, et leur intégration commence progressivement dans les protocoles de communication des navigateurs web ou iMessage d’Apple.

Pour les ingénieurs qui gèrent les infrastructures informatiques, intégrer l’« agilité cryptographique » (la capacité à changer rapidement de méthode de chiffrement) pour passer du RSA existant ou de la cryptographie sur les courbes elliptiques à la PQC, constituera une mission majeure dans le futur.

8. Conclusion

Dans cet article, nous avons fourni une explication exhaustive d’environ 10 000 caractères, allant du contexte mathématique théorique de l’algorithme de Shor aux mécanismes d’extraction de période par la transformée de Fourier quantique, jusqu’au code de simulation concret avec Python et Qiskit.

Le fait que les lois physiques du monde microscopique de la mécanique quantique bouleversent fondamentalement les fondations de l’informatique macroscopique telles que la théorie de la complexité et la cryptographie est l’un des changements de paradigme les plus excitants de l’histoire des sciences. Il est crucial de continuer à suivre cette bataille en cours entre l’évolution des technologies informatiques quantiques et les nouvelles technologies cryptographiques conçues pour y résister.

N’hésitez pas à exécuter le code Python présenté dans cet article sur votre propre environnement pour expérimenter la « magie du calcul » créée par la superposition et l’interférence des états quantiques.

Références

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Documentation Qiskit : https://qiskit.org/documentation/

【Illustration PQC】 Comparaison des principaux algorithmes de la cryptographie post-quantique

Fri, 11 Sep 2026 07:00:00 +0900

1. Introduction : La « crise de la cryptographie » provoquée par les ordinateurs quantiques

Dans la société Internet moderne, la cryptographie à clé publique est une infrastructure indispensable pour protéger la confidentialité des communications et l’intégrité des données. Les méthodes de cryptographie largement utilisées aujourd’hui, telles que RSA et la cryptographie sur les courbes elliptiques (ECC), reposent sur des barrières mathématiques telles que la « difficulté de la factorisation de très grands nombres composés » ou la « difficulté du problème du logarithme discret sur les courbes elliptiques » pour garantir leur sécurité. Avec les ordinateurs classiques (les ordinateurs que nous utilisons actuellement, y compris les superordinateurs), il a été prouvé qu’il faudrait plus de temps que l’âge de l’univers pour résoudre ces problèmes mathématiques, ce qui constitue le fondement de leur sécurité.

Cependant, cette prémisse solide est sur le point d’être fondamentalement bouleversée par l’avancée de la théorie et de la mise en pratique des ordinateurs quantiques. En 1994, l’algorithme de Shor, publié par le cryptographe Peter Shor (« Algorithme de Shor »), a prouvé théoriquement que les problèmes de factorisation et de logarithme discret pourraient être résolus en « temps polynomial » s’ils étaient exécutés sur un ordinateur quantique universel tolérant aux pannes (CRQC : Cryptographically Relevant Quantum Computer) d’une capacité suffisante. Cela signifie que toutes les cryptographies à clé publique utilisées actuellement seront rendues inefficaces.

graph TD A["Ordinateur quantique à grande échelle (CRQC)"] -->|Exécution| B["Algorithme de Shor"] B -->|Déchiffrement en temps polynomial| C["Problème de factorisation en nombres premiers (RSA)"] B -->|Déchiffrement en temps polynomial| D["Problème du logarithme discret (ECC / ECDSA)"] C --> E["Écoute de communications chiffrées, altération de données, usurpation d'identité"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Il est très dangereux de penser que « l’achèvement à grande échelle des ordinateurs quantiques n’est pas prévu avant plusieurs décennies, il n’y a donc pas de problème ». En effet, la méthode d’attaque appelée Store Now, Decrypt Later (SNDL : Stocker maintenant, déchiffrer plus tard) est déjà une menace réelle. Il s’agit d’une attaque dans laquelle des États malveillants ou des groupes de pirates stockent massivement les données de communication chiffrées actuelles (comme le trafic TLS) sur des supports de stockage, afin de les déchiffrer toutes dès qu’un ordinateur quantique puissant sera disponible à l’avenir. Les secrets d’État, les informations d’infrastructure et les données médicales qui doivent être protégées à long terme sont déjà exposés à cette menace.

De plus, il existe l’algorithme de Grover, découvert en 1996, qui s’applique à la cryptographie à clé symétrique (comme AES) et aux fonctions de hachage (comme SHA-256). Cet algorithme réduit la complexité de l’attaque par force brute à sa racine carrée. En d’autres termes, le niveau de sécurité de l’AES-128 est effectivement réduit de moitié, pour atteindre 2 à la puissance 64. Par conséquent, à l’ère quantique, il est recommandé d’utiliser des longueurs de clés et des longueurs de hachage plus grandes, telles que l’AES-256 et le SHA-384.

Pour faire face à cette crise cryptographique sans précédent, une nouvelle cryptographie post-quantique (Post-Quantum Cryptography : PQC) a vu le jour, reposant sur de nouveaux problèmes mathématiques difficiles à déchiffrer même avec des ordinateurs quantiques. Cet article explique de manière très détaillée, sur la base des résultats du processus de standardisation PQC mené par le National Institute of Standards and Technology (NIST) des États-Unis, les principaux algorithmes PQC, depuis leur contexte mathématique jusqu’à leurs mécanismes et la comparaison de leurs architectures.

2. Aperçu et histoire du projet de standardisation PQC par le NIST

La transition des technologies cryptographiques, qui implique la refonte des protocoles, la mise à jour des systèmes et le remplacement du matériel, prendra des années, voire des décennies. C’est pourquoi les cryptographes du monde entier ont commencé très tôt à faire des recherches sur la PQC. Le NIST (National Institute of Standards and Technology) américain a joué un rôle central dans ce domaine. En 2016, le NIST a lancé un appel public pour le processus de standardisation de la PQC et a accepté des propositions de tout nouveaux algorithmes cryptographiques de la part de la communauté cryptographique mondiale.

Les deux principales catégories ciblées par la standardisation étaient les suivantes :

Cryptographie à clé publique / Mécanisme d’encapsulation de clé (KEM : Key Encapsulation Mechanism) : Mécanisme permettant de partager (distribuer) en toute sécurité une clé symétrique pour chiffrer le canal de communication dans des connexions telles que TLS.
Signatures numériques (Digital Signatures) : Mécanisme permettant de prouver, dans les mises à jour logicielles et les certificats électroniques, que les données n’ont pas été altérées et qu’il n’y a pas d’usurpation d’identité de l’expéditeur (authenticité).

Après environ six années de concurrence acharnée en matière d’évaluation, d’analyse et de cryptanalyse (Round 1 à Round 3), une évaluation supplémentaire (Round 4) a été menée pour certains algorithmes. En conséquence, les algorithmes suivants ont été officiellement publiés en tant que Federal Information Processing Standards (FIPS) en 2024, s’établissant comme les futures normes mondiales.

FIPS 203 (ML-KEM) : KEM basé sur CRYSTALS-Kyber
FIPS 204 (ML-DSA) : Signature numérique basée sur CRYSTALS-Dilithium
FIPS 205 (SLH-DSA) : Signature basée sur le hachage sans état (stateless) reposant sur SPHINCS+
(À formuler ultérieurement) FN-DSA : Signature numérique basée sur FALCON

Ces algorithmes sélectionnés reposent chacun sur des « problèmes de difficulté » mathématiques différents. Ainsi, si une vulnérabilité fatale venait à être découverte dans l’un des algorithmes à l’avenir, la diversité (Crypto Agility) est assurée pour éviter que l’ensemble du système ne s’effondre. Dans le processus de standardisation, la cryptographie basée sur les réseaux (Lattice-based cryptography) a joué le rôle principal en raison de ses performances, mais la cryptographie basée sur le hachage et la cryptographie basée sur les codes ont été adoptées comme de solides solutions de secours.

3. Classification des principales approches mathématiques de la PQC

Les algorithmes PQC sont principalement classés en cinq catégories en fonction des problèmes mathématiques qui sous-tendent leur sécurité. Dans cet article, nous approfondirons particulièrement les trois premiers.

Cryptographie basée sur les réseaux (Lattice-based Cryptography) : Elle repose sur le problème du vecteur le plus court (SVP) et le problème du vecteur le plus proche (CVP) dans un espace de réseau multidimensionnel, ainsi que sur le problème LWE qui en dérive. Elle est au cœur de la standardisation du NIST, et Kyber, Dilithium et FALCON en font partie. Elle offre le meilleur équilibre entre la vitesse de traitement, la taille de la clé publique et la taille du texte chiffré, ce qui la rend adaptée à une utilisation polyvalente.
Cryptographie basée sur le hachage (Hash-based Cryptography) : Elle fonde sa sécurité uniquement sur la « résistance aux collisions » et la « propriété unidirectionnelle » des fonctions de hachage cryptographique (telles que SHA-2 et SHAKE). Bien qu’elle ne soit applicable qu’aux signatures numériques (comme SPHINCS+), ses preuves de sécurité sont les plus robustes et elle se caractérise par une résistance extrêmement élevée aux attaques mathématiques inconnues.
Cryptographie basée sur les codes (Code-based Cryptography) : Basée sur la théorie des codes correcteurs d’erreurs, elle dépend de la difficulté du problème du décodage de syndrome (Syndrome Decoding Problem). Le Classic McEliece, proposé dans les années 1970, en est représentatif et possède une très longue histoire et une sécurité éprouvée, bien que la taille de la clé publique soit extrêmement importante (de l’ordre du mégaoctet).
Cryptographie polynomiale multivariée (Multivariate Polynomial Cryptography) : Elle repose sur la difficulté de résoudre des systèmes d’équations quadratiques à plusieurs variables sur un corps fini (problème MQ). Principalement proposée pour les signatures numériques (comme Rainbow), une méthode d’attaque puissante permettant de la déchiffrer en quelques jours sur un simple PC a été découverte lors du dernier round du NIST, entraînant l’élimination de nombreux algorithmes de la standardisation.
Cryptographie basée sur les isogénies (Isogeny-based Cryptography) : Elle repose sur le problème de recherche de chemin sur des graphes d’isogénies de courbes elliptiques. Avec des tailles de clé très petites, elle était attendue comme le successeur légitime de l’ECC, mais « SIKE », le candidat final, a été complètement déchiffré en seulement quelques heures sur un PC normal en 2022 à l’aide de mathématiques classiques (comme l’attaque de Castryck-Decru), symbolisant la fin dramatique, ainsi que la difficulté et le danger liés à la conception de la PQC.

4. Les abysses de la cryptographie sur les réseaux : Les bases mathématiques du problème LWE et du Module-LWE

Considérée aujourd’hui comme la plus prometteuse et devenue le centre de la standardisation, voici la cryptographie basée sur les réseaux (Lattice cryptography). À la base de sa sécurité se trouve le problème LWE (Learning with Errors : Apprentissage avec erreurs). Proposé par Oded Regev en 2005, cette réalisation historique lui a valu le prix Gödel. Il est impossible de parler de la PQC moderne sans comprendre le problème LWE.

4.1. Qu’est-ce que le problème LWE (Learning with Errors) ?

Considérons tout d’abord un simple système d’équations linéaires. Sous un certain module $q$ (modulo $q$), supposons que nous ayons une matrice aléatoire connue $A$, un vecteur secret inconnu $\vec{s}$, et que leur produit $\vec{b}$ soit donné.

$$ \vec{b} = A\vec{s} \pmod q $$

Dans ce cas, il est facile de trouver le vecteur inconnu $\vec{s}$ à partir des informations publiques $A$ et $\vec{b}$. En utilisant un algorithme classique comme « l’élimination de Gauss (ou pivot de Gauss) », on peut facilement calculer $\vec{s}$ en temps polynomial.

Cependant, si l’on ajoute à cette équation une « petite erreur intentionnelle (bruit) », le niveau de difficulté du problème augmente considérablement. C’est ce qu’on appelle le problème LWE.

On prépare un vecteur secret inconnu $\vec{s} \in \mathbb{Z}_q^n$ et une matrice choisie au hasard $A \in \mathbb{Z}_q^{m \times n}$. De plus, un vecteur d’erreur $\vec{e} \in \mathbb{Z}_q^m$ dont « la valeur des éléments est suffisamment petite » est choisi selon une distribution normale ou binomiale, et $\vec{b}$ est calculé comme suit.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Le problème Search LWE (LWE de recherche) consiste à « trouver l’information secrète $\vec{s}$ à partir des informations publiques $(A, \vec{b})$ ». En raison de la présence de cette erreur $\vec{e}$, toute tentative d’utiliser des méthodes de résolution algébriques telles que l’élimination de Gauss fera que l’erreur $\vec{e}$ s’amplifiera de manière exponentielle lors de l’addition et de la soustraction des équations, devenant finalement indiscernable d’une valeur aléatoire et conduisant à un échec.

La puissance du problème LWE réside dans le fait qu’il existe une forte preuve théorique (réduction) affirmant que le problème LWE ne peut pas non plus être résolu en moyenne (Average-case), à moins qu’il n’existe un algorithme quantique capable de résoudre le problème du plus court vecteur de décision (GapSVP) ou le problème des vecteurs indépendants les plus courts (SIVP), qui sont des problèmes de « complexité dans le pire des cas (Worst-case hardness) » sur les réseaux. En d’autres termes, même pour des clés de chiffrement générées aléatoirement, une sécurité robuste, soutenue par des limites théoriques, est garantie.

4.2. Amélioration drastique de l’efficacité grâce à Ring-LWE et Module-LWE

Le problème LWE normal (Standard LWE) a une base de sécurité très claire, mais n’est pas pratique car la taille de la matrice $A$ devient très grande et les tailles de clés atteignent le niveau du mégaoctet. L’approche proposée a donc été d’utiliser des anneaux de polynômes (Polynomial Rings) pour lui donner une structure algébrique.

Dans le problème Ring-LWE, on utilise des éléments (polynômes) d’un certain anneau de polynômes $R_q$ au lieu de simples vecteurs et matrices. Dans la norme NIST, l’anneau de polynômes cyclotomiques suivant est généralement utilisé.

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Ici, $n$ est une puissance de 2 (par exemple 256) et $q$ est un nombre premier approprié. Sur cet anneau, on calcule $b = a \cdot s + e \pmod q$ en utilisant les éléments $a, s, e \in R_q$. Comme un seul polynôme $a$ possède $n$ coefficients, les données peuvent être considérablement compressées. De plus, l’utilisation d’une version de transformée de Fourier rapide (FFT) sur corps fini, appelée NTT (Number Theoretic Transform : Transformée de la théorie des nombres), permet une multiplication de polynômes ultra-rapide avec une complexité de calcul de $O(n \log n)$.

Cependant, il y avait des inquiétudes concernant le Ring-LWE quant à « l’existence possible de vulnérabilités inconnues dues à la structure algébrique spécifique de l’anneau ». Il y avait également le défi d’ingénierie selon lequel, lors de la modification du niveau de sécurité (par exemple, équivalent à AES-128, 192, 256), il fallait modifier le degré $n$ du polynôme lui-même, ce qui nécessitait de réécrire l’ensemble de l’implémentation, y compris l’algorithme NTT.

C’est pourquoi les algorithmes standardisés Kyber et Dilithium ont adopté le problème Module-LWE (M-LWE). Le Module-LWE est un compromis situé exactement entre le Standard LWE sans structure et le Ring-LWE qui possède trop de structure, en utilisant une matrice de taille $k \times k$ (module) dont les composants sont les éléments de l’anneau de polynômes $R_q$.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Le plus grand avantage du Module-LWE est qu’il permet de faire évoluer facilement le niveau de sécurité en modifiant simplement la dimension $k$ de la matrice, tout en gardant fixe le degré $n$ du polynôme (dans la norme NIST, $n=256$). Par exemple, pour Kyber, la dimension $k$ est ajustée de la manière suivante :

Kyber512 (Niveau 1) : $k = 2$ (équivalent AES-128)
Kyber768 (Niveau 3) : $k = 3$ (équivalent AES-192)
Kyber1024 (Niveau 5) : $k = 4$ (équivalent AES-256)

Cela a permis de réutiliser à 100 % le code NTT sous-jacent et le circuit matériel des opérations polynomiales pour tous les niveaux de sécurité, ce qui a permis d’améliorer considérablement la sécurité et l’efficacité de l’implémentation.

5. CRYSTALS-Kyber (ML-KEM) : Le mécanisme d’encapsulation de clé de nouvelle génération

Officiellement standardisé sous le nom de FIPS 203 (ML-KEM), CRYSTALS-Kyber est un mécanisme d’encapsulation de clé (KEM) basé sur le problème Module-LWE susmentionné. Il s’agira de la norme mondiale de facto pour le partage sécurisé des clés de session à l’avenir, notamment pour TLS 1.3 et SSH.

5.1. Architecture du KEM (Key Encapsulation Mechanism)

À l’ère de la PQC, l’approche directe telle que RSA où « le client crée une clé partagée, la chiffre avec la clé publique du serveur et l’envoie » est remplacée par le cadre d’encapsulation appelé KEM.

sequenceDiagram participant Client as "Client (Alice)" participant Server as "Serveur (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Générer la clé secrète (sk) et la clé publique (pk)" Client->>Server: "Envoyer la clé publique (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Générer une clé partagée aléatoire (K)" Server->>Server: "Encapsuler K avec pk pour créer le texte chiffré (c)" Server->>Client: "Envoyer le texte chiffré (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Déchiffrer le texte chiffré (c) à l'aide de la clé secrète (sk)" Client->>Client: "Désencapsuler et extraire la clé partagée (K)" Note over Client, Server: "Commencer la communication chiffrée (par ex. AES) avec la clé partagée (K)"

5.2. Fonctionnement interne de Kyber et Transformation de Fujisaki-Okamoto

La conception de Kyber est extrêmement raffinée. Tout d’abord, un schéma de chiffrement à clé publique (Kyber.CPAPKE), sûr uniquement contre les attaques à texte clair choisi (CPA), est construit, puis une technique cryptographique très puissante appelée Transformation de Fujisaki-Okamoto (Fujisaki-Okamoto Transform) est appliquée, ce qui permet de le faire évoluer vers un KEM complet et sûr contre les attaques à chiffré choisi adaptatif (CCA).

Le mécanisme de chiffrement et de déchiffrement au cœur de CPAPKE est le suivant :

Génération de clé (Key Generation) :
- À partir d’une valeur de graine aléatoire (seed), générer une matrice $A \in R_q^{k \times k}$ sur le domaine NTT. Le modulo $q$ utilisé est $3329$.
- Échantillonner un vecteur secret $\vec{s}$ et un vecteur d’erreur $\vec{e}$ avec de petits coefficients à partir d’une distribution binomiale centrée (CBD).
- Calculer $\vec{t} = A\vec{s} + \vec{e}$. La clé publique est $(A, \vec{t})$ et la clé secrète est $\vec{s}$. (En pratique, $A$ est publiée en tant que valeur de graine (seed) pour économiser de la bande passante).
Chiffrement (Encryption) :
- Encoder le message de 32 octets (matériau de la clé partagée) $m$ que l’on souhaite partager en un polynôme.
- Générer un nouveau vecteur aléatoire $\vec{r}$ et de petites erreurs $\vec{e_1}, e_2$.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- Le texte chiffré est $(\vec{u}, v)$.
Déchiffrement (Decryption) :
- Le destinataire calcule $v - \vec{s}^T\vec{u}$.
- Le développement de cette équation donne ce qui suit. $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- En remplaçant $\vec{t} = A\vec{s} + \vec{e}$, le terme principal $\vec{s}^TA^T\vec{r}$ s’annule.
- Il reste $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Les termes entre parenthèses étant des « produits ou sommes de petites erreurs », l’ensemble reste une valeur (bruit) suffisamment petite. Par conséquent, en déterminant si chaque coefficient est proche de $0$ ou de $q/2$, les bits (0 ou 1) du message d’origine $m$ peuvent être parfaitement restaurés sans aucune erreur.

La plus grande force de Kyber réside dans sa vitesse de traitement impressionnante et sa taille de clé modérée. Pour Kyber768, la taille de la clé publique est de 1 184 octets et la taille du texte chiffré est de 1 088 octets. Bien qu’elles soient plus importantes par rapport à RSA-3072 (taille de clé d’environ 384 octets), il est possible de les faire tenir dans l’unité de transmission maximale (MTU) des communications Internet modernes sans fragmentation des paquets, ce qui n’a presque aucun impact négatif sur la latence du réseau.

6. CRYSTALS-Dilithium (ML-DSA) : Signature numérique polyvalente basée sur les réseaux

Dans la standardisation des signatures numériques, des algorithmes avec différentes philosophies de conception ont concouru au sein de la même approche de la cryptographie sur les réseaux. Parmi eux, CRYSTALS-Dilithium a été sélectionné comme signature numérique polyvalente sous le nom de FIPS 204 (ML-DSA).

6.1. Le paradigme Fiat-Shamir with Aborts

Comme Kyber, Dilithium est un schéma de signature numérique basé sur le problème Module-LWE (ainsi que sur le problème Module-SIS). À la base de sa conception, le paradigme extrêmement important appelé « Fiat-Shamir with Aborts (Transformation de Fiat-Shamir avec rejets) » est utilisé.

La transformation de Fiat-Shamir elle-même est une méthode standard pour convertir un protocole interactif de preuve à divulgation nulle (zero-knowledge proof) en une signature numérique non interactive. Le prouveur (signataire) génère un engagement (commitment) $y$, calcule $w = Ay$ et le passe par une fonction de hachage pour obtenir un défi aléatoire $c$, puis calcule la réponse $z = y + cs$.

Cependant, dans la cryptographie sur les réseaux, l’application naïve de cette méthode entraînait un problème fatal (fuite mathématique de type canal auxiliaire) où la distribution de la réponse $z$ devenait asymétrique en fonction de la valeur de la clé secrète $s$, et un attaquant observant de nombreuses signatures obtiendrait peu à peu des informations sur la clé secrète $s$.

L’équipe de conception de Dilithium (Lyubashevsky et al.) a introduit une technique appelée « Échantillonnage par rejet (Rejection Sampling) » : si les coefficients du résultat de la signature $z$ ne tombent pas dans une plage de seuil de sécurité prédéfinie, l’ensemble du processus de signature est abandonné (Abort) et le calcul est recommencé depuis le début en utilisant un nouveau nombre aléatoire $y$.

Grâce à cela, la signature finale produite $z$ est une distribution complètement uniforme qui ne dépend en aucun cas de la clé secrète, réussissant à prévenir complètement la fuite d’informations sur le plan mathématique.

6.2. Les avantages de Dilithium et la facilité de son implémentation

Le grand avantage de la conception de Dilithium est qu’elle n’utilise absolument pas d’« échantillonnage complexe à partir de distributions gaussiennes » ou d’« opérations en virgule flottante » dans le processus de génération de signature. Puisqu’il peut être mis en œuvre uniquement avec un échantillonnage à partir d’une distribution uniforme, des opérations simples en modulo entier, des NTT et des fonctions de hachage (SHAKE), il est facile de l’implémenter de manière sécurisée et en temps constant (Constant-time) dans un large éventail d’environnements, allant des microcontrôleurs embarqués aux serveurs cloud. De ce fait, il possède également une forte résistance contre les attaques physiques par canal auxiliaire, telles que les attaques par chronométrage (timing attacks).

7. FALCON (FN-DSA) : Signature sur réseaux ultra-compacte

Le NIST a sélectionné FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) comme autre candidat standard de signature basée sur les réseaux, avec des caractéristiques différentes de celles de Dilithium (actuellement en cours de rédaction en tant que FN-DSA).

7.1. Réseaux NTRU et échantillonnage gaussien

La plus grande caractéristique de FALCON est qu’il n’utilise pas le problème LWE, mais plutôt le réseau NTRU (N-th degree Truncated polynomial Ring Units), très ancien et existant depuis 1996. De plus, il adopte le paradigme « Hash-and-Sign (Hachage et Signature) » basé sur le framework GPV (Gentry-Peikert-Vaikuntanathan).

Dans Hash-and-Sign, la valeur de hachage du message est utilisée comme point cible dans l’espace, et le point sur le réseau le plus proche de ce point (une solution approchée du problème du vecteur le plus proche) est trouvé pour servir de signature. Pour cela, il est nécessaire d’échantillonner des points selon une distribution gaussienne discrète en utilisant une « base courte de bonne qualité » qui est la clé secrète.

FALCON a considérablement accéléré ce calcul intensif en utilisant une technique appelée « Orthogonalisation de Fourier rapide (Fast Fourier Orthogonalization : FFO) ».

7.2. Avantages et inconvénients de FALCON

L’avantage écrasant de FALCON réside dans le fait que la taille de sa signature et la taille de sa clé publique sont extrêmement petites (compactes). Alors que la taille de la signature de Dilithium3 est d’environ 3 309 octets, celle de FALCON-512 n’est que d’environ 666 octets. La clé publique est également très petite, avec 897 octets, ce qui en fait un sauveur dans les environnements où la bande passante de communication est extrêmement limitée, pour les appareils IoT et dans certains protocoles réseau.

Cependant, il existe un inconvénient majeur. Puisque l’échantillonnage gaussien discret impliquant des opérations complexes en virgule flottante (64-bit IEEE 754) est indispensable lors de la génération de la signature, l’implémentation en temps constant (Constant-time implementation) pour prévenir les fuites de temps est extrêmement difficile, et le code devient énorme. C’est pourquoi FALCON est positionné comme un puissant algorithme spécialisé pour des usages spécifiques, par opposition à l’utilisation polyvalente (Dilithium).

graph LR A["Exigences en matière de signatures numériques"] --> B{"Quelle est la contrainte prioritaire ?"} B -->|"Simplicité d'implémentation, polyvalence, facilité d'implémentation en temps constant"| C["Dilithium (ML-DSA)"] B -->|"Minimisation de la bande passante de communication, compacité de la taille des données"| D["FALCON (FN-DSA)"] C --> E["Certificats TLS génériques, signature électronique de logiciels"] D --> F["Protocoles avec des limites strictes de taille de paquet, environnements spéciaux"]

8. SPHINCS+ (SLH-DSA) : Signature basée sur le hachage offrant la plus forte sécurité

Pour se préparer au pire des scénarios (le cas échéant) où la sécurité de la cryptographie sur les réseaux serait brisée à l’avenir par une percée d’un brillant mathématicien, le NIST a formulé FIPS 205 (SLH-DSA), c’est-à-dire SPHINCS+, en tant que norme basée sur une approche complètement différente de celle de la cryptographie sur les réseaux.

SPHINCS+ est classé comme une signature basée sur le hachage. Sa sécurité repose uniquement sur un seul point : « la fonction de hachage cryptographique utilisée (comme SHA-2 ou SHAKE256) possède une résistance aux collisions et une propriété unidirectionnelle ». Contrairement au LWE ou à la factorisation, qui dépendent de problèmes mathématiques possédant des structures algébriques spécifiques, SPHINCS+ peut faire face à n’importe quel algorithme quantique puissant qui pourrait apparaître à l’avenir, simplement en allongeant la longueur de sortie de la fonction de hachage. Il s’enorgueillit ainsi d’une sécurité extrêmement robuste (la sécurité la plus conservatrice).

8.1. Architecture sans état (stateless) avec WOTS+ et FORS

L’histoire des signatures basées sur le hachage est ancienne et remonte aux signatures Lamport et aux signatures à usage unique (One-Time Signatures) Winternitz (WOTS) des années 1970. Il s’agissait de clés jetables où « l’on ne peut signer en toute sécurité qu’une seule fois ». Afin de pouvoir les utiliser plusieurs fois, des algorithmes tels que XMSS (eXtended Merkle Signature Scheme) et LMS ont été développés en combinant des arbres de Merkle pour gérer d’innombrables clés à usage unique avec un seul hachage racine.

Cependant, XMSS et LMS présentaient un défaut majeur : ils étaient « avec état (stateful) ». Chaque fois qu’une signature était effectuée, il était nécessaire de conserver un enregistrement strict de l’état de l’index « quelle clé à usage unique a été utilisée » dans une mémoire non volatile. Si l’état était restauré (par exemple, par la restauration d’un snapshot de machine virtuelle) et que la même clé à usage unique était utilisée deux fois, la clé secrète serait immédiatement divulguée et le système s’effondrerait.

SPHINCS+ est une signature basée sur le hachage « sans état (stateless) » qui a résolu les tracas liés à la gestion des états. Sa technologie de base est la combinaison suivante :

WOTS+ (Winternitz One-Time Signature Plus) : Signature à usage unique de base.
FORS (Forest of Random Subsets) : Technologie de signature à faible fréquence d’utilisation (Few-Time Signature). La sécurité est maintenue même si la même clé est réutilisée un petit nombre de fois.
Hyper-Tree (Structure arborescente géante) : Structure géante composée de plusieurs couches d’arbres de Merkle empilées.

Dans SPHINCS+, lors de la signature, au lieu de gérer des états, une clé FORS est sélectionnée de manière aléatoire parmi un nombre colossal de clés au bas de l’Hyper-Tree à l’aide d’un nombre pseudo-aléatoire pour effectuer la signature. Étant donné que le nombre de feuilles de l’arbre est astronomique, la probabilité de sélectionner la même clé deux fois par accident (collision) est si faible qu’elle peut être ignorée, ce qui permet d’atteindre l’absence d’état (stateless).

La seule et plus grande faiblesse de SPHINCS+ est que la taille de sa signature est extrêmement grande. Selon les paramètres, la taille de la signature peut atteindre 17 kilo-octets à 49 kilo-octets, et la vitesse de génération des signatures est également très lente par rapport à la cryptographie sur les réseaux. Par conséquent, il est prévu de l’utiliser dans des applications nécessitant une sécurité absolue à long terme et où les signatures ne sont pas effectuées fréquemment, telles que les signatures de mise à jour logicielle et les certificats d’Autorité de Certification (CA) racine, plutôt que pour la navigation Web quotidienne.

9. Cryptographie basée sur les codes : Classic McEliece, le bon vieux géant

Dans le processus de standardisation du NIST, Classic McEliece, de la cryptographie basée sur les codes, est une approche importante dont l’évaluation se poursuit toujours en tant que candidat final de la phase 4.

Proposé par Robert McEliece en 1978, cet algorithme est l’un des plus anciens de l’histoire de la cryptographie à clé publique, aux côtés du RSA. Il utilise des codes de géométrie algébrique appelés « codes de Goppa », qui ajoutent intentionnellement une erreur (vecteur de bruit) au message lors du chiffrement. Seule la personne possédant la matrice de contrôle de parité du code de Goppa comme clé secrète peut utiliser sa puissante capacité de correction d’erreurs pour supprimer l’erreur et déchiffrer le message d’origine, un principe basé sur le « problème du décodage de syndrome (Syndrome Decoding Problem) ».

$$ \vec{c} = \vec{m} G + \vec{e} $$

（$G$ est la matrice génératrice brouillée qui est la clé publique, et $\vec{e}$ est le vecteur d’erreur de poids $t$）

Ce qui est surprenant avec Classic McEliece, c’est son bilan impressionnant : bien que plus de 40 ans se soient écoulés depuis sa proposition et qu’il ait fait l’objet d’intenses recherches de déchiffrement par des cryptographes du monde entier, aucune vulnérabilité intrinsèque n’y a jamais été découverte. Il possède la « sécurité éprouvée par le temps » la plus solide de toute la PQC.

De plus, il a l’avantage d’avoir une taille de texte chiffré très petite (seulement 100 à 200 octets). Cependant, il présente un défaut majeur : la taille de la clé publique est en mégaoctets (Mo). Même pour le niveau de sécurité le plus bas (équivalent à AES-128), la clé publique est d’environ 250 Ko, et elle dépasse 1 Mo pour des niveaux plus élevés.

Pour cette raison, il est totalement inadapté aux applications qui envoient des clés publiques sur le réseau à chaque communication, telles que les poignées de main TLS. Cependant, pour des cas d’utilisation spécifiques où la clé publique peut être placée à l’avance dans le système, comme l’échange de clés pré-partagées pour les VPN, le codage en dur de clés publiques dans le firmware ou la communication par satellite, il continue d’être considéré comme une option très prometteuse en raison de sa forte sécurité.

10. Comparaison des performances et compromis de chaque algorithme PQC

Le tableau suivant résume les caractéristiques de performance des principaux algorithmes abordés jusqu’à présent à des niveaux de sécurité courants (équivalents aux niveaux 2 à 3 du NIST, soit le niveau AES-128 à 192).

Algorithme (Nom standard)	Catégorie	Base mathématique	Taille de la clé publique	Taille de la clé secrète	Taille du chiffré/signature	Tendance de la vitesse de traitement	Principales caractéristiques et utilisations
Kyber768 (ML-KEM)	KEM	Module-LWE	1 184 octets	2 400 octets	1 088 octets	Très rapide	Meilleur équilibre entre taille de clé et vitesse. Norme KEM générique comme TLS 1.3.
Dilithium3 (ML-DSA)	Signature	Module-LWE	1 952 octets	4 032 octets	3 309 octets	Génération et vérification rapides	Implémentation simple. Norme de signature numérique polyvalente.
FALCON-512 (FN-DSA)	Signature	Réseaux NTRU	897 octets	1 281 octets	666 octets	Génération plus lente, vérification ultra-rapide	Taille de signature minime. Nécessite des opérations en virgule flottante. Pour IoT/embarqué.
SPHINCS+ (SLH-DSA)	Signature	Fonction de hachage	32 octets	64 octets	Env. 17 000 octets	Génération très lente	Risque mathématique quasi nul. Pour applications de haute sécurité comme certificats racine.
Classic McEliece	KEM	Codes de Goppa	Env. 1.04 Mo	13 568 octets	188 octets	Encapsulation rapide	40 ans de sécurité éprouvée. Clé publique énorme. Pour environnements avec codage en dur.

Comprendre les compromis

Dans le monde de la PQC, il n’existe pas d’algorithme unique et magique qui soit « petit en taille, rapide, et avec des garanties mathématiques parfaites ».

Les normes d’Internet (Kyber / Dilithium) : Elles offrent le meilleur équilibre des performances et sont les mieux adaptées au remplacement direct (drop-in replacement) du RSA et de l’ECC actuels.
La conservativité ultime (SPHINCS+) : Elle est choisie lorsque l’on souhaite une assurance absolue contre les futures percées mathématiques, même au prix de la taille des données et de la vitesse de traitement.
Pour des environnements spécifiques (FALCON / Classic McEliece) : Ce sont des armes spécialisées choisies en fonction des contraintes de l’environnement, telles que des bandes passantes de communication extrêmement étroites ou la possibilité d’une distribution préalable.

11. Défis vers la mise en pratique et la solution réaliste de la « cryptographie hybride »

Avec l’achèvement de la standardisation par le NIST et la publication officielle des normes FIPS, la transition mondiale de l’infrastructure informatique vers la PQC (Migration PQC) a véritablement commencé. Le navigateur Chrome de Google, iMessage d’Apple (protocole PQ3) et les fournisseurs de réseaux comme Cloudflare ont déjà implémenté le support de la PQC dans leurs protocoles et ont commencé leur exploitation commerciale.

Cependant, basculer soudainement et complètement vers de nouveaux algorithmes de cryptographie comporte des risques très élevés. Si un brillant mathématicien venait à découvrir dans quelques années une faille mathématique fatale dans la cryptographie sur les réseaux (comme Kyber) qui pourrait être résolue même par un ordinateur classique, l’ensemble des systèmes qui en dépendent seraient instantanément exposés.

L’approche réaliste et recommandée pour atténuer ce risque d’incertitude est la « cryptographie hybride (Hybrid Cryptography) ».

Dans la cryptographie hybride, l’échange de clés est effectué en utilisant simultanément les cryptographies classiques actuelles ayant fait leurs preuves depuis longtemps (par exemple, la cryptographie sur courbe elliptique comme X25519) et les nouvelles PQC (par exemple, Kyber768). Les composants de la clé partagée sont générés individuellement par chaque algorithme, puis enfin, une fonction de dérivation de clé (KDF) sécurisée est utilisée pour mélanger les deux composants et générer le secret maître final.

graph TD A["Client"] -->|① Envoi de la clé publique X25519 + clé publique Kyber| B["Serveur"] B -->|② Réponse avec clé partagée X25519 + chiffré encapsulé Kyber| A A --> C{"Dérivation du secret maître (KDF)"} B --> C C -->|"Entrée : (Clé partagée X25519) || (Clé partagée Kyber)"| D["Clé de communication sécurisée (AES-256 / ChaCha20)"] D -->|"Résistance aux menaces quantiques ET aux vulnérabilités classiques"| E["Communication chiffrée hybride sécurisée (TLS 1.3)"]

Grâce à cela, il est possible d’atteindre une sécurité robuste à deux niveaux : « même si un ordinateur quantique est réalisé et que l’ECC est brisé, Kyber protège la communication », et inversement, « même si un défaut mathématique inconnu est trouvé dans Kyber, l’ECC protège la communication ». Un exemple typique est le brouillon X25519MLKEM768 (anciennement X25519Kyber768) en cours de standardisation à l’IETF, et la communication entre les navigateurs Web actuels et les serveurs de pointe est précisément réalisée à l’aide de cette méthode hybride.

De plus, le concept de Crypto Agility (Agilité cryptographique), qui consiste à concevoir des systèmes avec « une architecture qui ne dépend pas excessivement d’un algorithme cryptographique spécifique et qui permet de basculer rapidement vers un autre algorithme (par exemple, de Kyber à McEliece, de Dilithium à SPHINCS+) en cas de compromission de l’algorithme », deviendra une exigence indispensable dans le développement futur des systèmes.

12. Conclusion : Un nouvel horizon pour les technologies cryptographiques

Paradoxalement, l’ordinateur quantique, la technologie de rêve de l’humanité, est devenu la plus grande menace, capable de briser les barrières mathématiques telles que la « factorisation en nombres premiers » et le « problème du logarithme discret » sur lesquelles nous nous reposons depuis de nombreuses années. Cependant, les cryptographes du monde entier ne se sont pas avoués vaincus et ont exploré des domaines mathématiques multidimensionnels plus complexes et profonds, tels que la théorie des réseaux, les arbres de fonctions de hachage et les codes correcteurs d’erreurs, pour bâtir une nouvelle barrière : la cryptographie post-quantique (PQC).

L’achèvement de la standardisation des normes FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) et FIPS 205 (SLH-DSA) par le NIST n’est pas une ligne d’arrivée. Ce n’est que la première étape d’un voyage épique de migration vers la PQC qui durera plusieurs décennies. Pour les ingénieurs logiciels et les architectes système, le grand défi technique de l’avenir consistera à adapter au mieux l’« augmentation de la taille des clés » et les « changements de coûts de calcul » apportés par ces nouveaux algorithmes aux protocoles réseau et aux systèmes.

La bataille entre l’ordinateur quantique et la cryptographie est un domaine passionnant où la quête mathématique de l’humanité et l’évolution technologique se croisent de la manière la plus intense. À travers cet article, nous espérons que vous aurez acquis une compréhension approfondie de la belle théorie mathématique qui sous-tend la PQC, ainsi que des mécanismes surprenants de chaque algorithme qui façonnera l’avenir de la cybersécurité.

Références :

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

Le jour où les ordinateurs quantiques seront mis en pratique : situation en 2026

Fri, 11 Sep 2026 06:00:00 +0900

1. Introduction : Où en sont les ordinateurs quantiques en 2026 ?

En 2026, l’informatique quantique a connu un changement décisif, passant d’un ancien “rêve théorique” à une “réalité technique”. Alors que les limites des dispositifs NISQ (Noisy Intermediate-Scale Quantum), qui dominaient jusqu’à il y a quelques années, sont devenues claires, les instituts de recherche et les géants de la technologie du monde entier se sont orientés vers la réalisation de “l’informatique quantique tolérante aux pannes (FTQC : Fault-Tolerant Quantum Computing)”.

Dans cet article, nous explorerons en profondeur l’état actuel des ordinateurs quantiques, en intégrant les dernières avancées de 2026. En particulier, nous détaillerons la correction d’erreurs quantiques (code de surface), la différence entre les qubits physiques et les qubits logiques, les progrès de l’informatique quantique topologique, et l’avant-garde des méthodes à supraconducteurs et à pièges à ions.

2. Fondements de l’état quantique et fidélité (Fidelity)

L’unité fondamentale d’un ordinateur quantique, le bit quantique (Qubit), contrairement au bit classique (0 ou 1), peut prendre un état de superposition de 0 et de 1. L’état d’un seul qubit est représenté comme un vecteur dans l’espace de Hilbert comme suit :

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Ici, $\alpha$ et $\beta$ sont des amplitudes de probabilité complexes, satisfaisant la condition de normalisation suivante :

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Un indicateur extrêmement important pour mesurer les performances des calculs quantiques est la fidélité (Fidelity). La fidélité $F$ entre l’état quantique idéal $|\psi\rangle$ et la matrice densité réelle $\rho$, qui s’est dégradée pour devenir un état mixte à cause du bruit, est définie comme suit :

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

À l’heure actuelle en 2026, la fidélité des portes à 2 qubits (ex : portes CNOT et portes CZ) dépasse désormais de manière stable le mur des 99,99 % (ce que l’on appelle les “4 neufs”) dans les systèmes supraconducteurs. Il s’agit d’un chiffre qui dépasse largement le seuil de correction d’erreurs par le code de surface (environ 99 %), et constitue l’une des plus grandes avancées vers une application pratique.

3. Les limites de l’ère NISQ et le changement de paradigme vers FTQC

La période allant de la fin des années 2010 au début des années 2020 fut l’ère des NISQ (Noisy Intermediate-Scale Quantum), des dispositifs de quelques dizaines à quelques centaines de qubits dépourvus de correction d’erreurs. Cependant, les dispositifs NISQ avaient des limites claires.

À mesure que la profondeur (Depth) du circuit augmente, les erreurs s’accumulent de manière exponentielle, rendant impossible l’obtention de résultats de calcul significatifs. La probabilité de succès globale $P_{success}$ à une profondeur de circuit $D$ décroît par rapport à la fidélité d’une seule porte $f$ et au nombre de portes $N$ comme suit :

$$ P_{success} \approx f^N $$

Si $f = 0.99$ et que 1000 portes sont appliquées, le résultat sera $0.99^{1000} \approx 4.3 \times 10^{-5}$, et sera presque enfoui dans le bruit aléatoire. Pour cette raison, en 2026, au lieu d’une mise à l’échelle directe des algorithmes NISQ (comme VQE ou QAOA), les ressources se concentrent sur la génération de qubits logiques (Logical Qubit).

4. Correction d’erreurs quantiques et qubits logiques : À la pointe du code de surface

La correction d’erreurs quantiques (QEC : Quantum Error Correction) est une technologie qui encode plusieurs “qubits physiques” pour créer un “qubit logique”, permettant de détecter et de corriger les erreurs. Actuellement, le code le plus prometteur est le code de surface (Surface Code).

4.1 Structure du code de surface (Surface Code)

Dans le code de surface, les qubits sont disposés dans une grille bidimensionnelle. Les qubits de données (conservant les informations réelles) et les qubits de mesure (pour la mesure du syndrome) sont disposés comme sur un damier.

graph TD A["Qubit de données (D1)"] --- B["Qubit de mesure (M1)"] B --- C["Qubit de données (D2)"] C --- D["Qubit de mesure (M2)"] D --- E["Qubit de données (D3)"] B --- F["Qubit de données (D4)"] D --- G["Qubit de données (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Il utilise les opérateurs de stabilisateur $S_x$ et $S_z$ pour surveiller constamment le retournement de bit (erreur X) et le retournement de phase (erreur Z).

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

L’avancée majeure de 2026 est le dépassement complet du “seuil de rentabilité (Break-even point)”. En d’autres termes, le bruit éliminé par la correction d’erreurs est devenu plus important que le bruit causé par les circuits supplémentaires pour l’effectuer, permettant ainsi à la durée de vie du qubit logique de dépasser de plusieurs ordres de grandeur celle du qubit physique.

4.2 Cycle de correction d’erreurs quantiques

La correction d’erreurs fonctionne comme une boucle de rétroaction continue.

sequenceDiagram participant D as "Qubits de données" participant M as "Qubits ancillaires/de mesure" participant C as "Contrôleur classique" loop "Cycle d'extraction de syndrome (approx 1 microsec)" D->>M: "Intriquer (CNOT/CZ)" M->>C: "Mesurer l'état (Syndrome)" C->>C: "Décoder le syndrome (ex: Minimum Weight Perfect Matching)" C-->>D: "Appliquer la correction de Pauli (si nécessaire)" end

Aujourd’hui, la technologie pour exécuter ce traitement de décodage classique (analyse de syndrome) en nanosecondes avec des FPGA ou des ASIC dédiés a été établie, et la correction d’erreurs en temps réel est entrée dans la phase de mise en œuvre pratique.

5. Évolution de l’architecture matérielle (Édition 2026)

Le matériel quantique en 2026 évolue principalement selon trois axes : la “méthode à supraconducteurs”, la “méthode à pièges à ions” et la “méthode topologique”.

5.1 Intégration des qubits supraconducteurs

La méthode supraconductrice est un domaine mené par IBM et Google, et le qubit transmon utilisant des jonctions Josephson y est dominant. En 2026, des mégapuces intégrant des milliers à dix mille qubits physiques sur une seule puce ont été réalisées.

Il convient de noter tout particulièrement l’établissement d’interconnexions quantiques inter-modules (Quantum Interconnects). La téléportation quantique entre puces utilisant des photons micro-ondes a été implémentée au niveau commercial, permettant de contourner les limites de taille d’un seul réfrigérateur à dilution.

5.2 Mise à l’échelle bidimensionnelle des pièges à ions et interconnexion optique

La méthode des pièges à ions (menée par Quantinuum, IonQ, etc.) utilise les états d’énergie interne des ions en suspension dans le vide comme qubits. Comparée à la méthode supraconductrice, elle présente l’avantage d’un temps de cohérence T1/T2 extrêmement long et permet une connectivité globale (All-to-All Connectivity).

La percée de 2026 fut la bidimensionnalisation de l’architecture QCCD (Quantum Charge Coupled Device) et la génération d’intrication à grande vitesse entre plusieurs pièges à l’aide d’interconnexions photoniques. Cela a considérablement amélioré la “lenteur de la vitesse de porte” et la “scalabilité”, qui étaient les points faibles des pièges à ions.

5.3 Informatique quantique topologique : Contrôle des anyons

L’informatique quantique topologique, longtemps considérée comme une existence théorique, est finalement entrée dans la phase de démonstration expérimentale en 2026. Cette méthode, promue par des entreprises telles que Microsoft, utilise des anyons non abéliens (Non-Abelian Anyons) appelés “modes zéro de Majorana (Majorana Zero Modes)”.

Les portes quantiques sont exécutées par une opération de tressage (Braiding) qui intervertit les positions des particules d’anyons.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Ici, $B_{ij}$ est l’opérateur de tressage. L’approche topologique est intrinsèquement résistante au bruit de l’environnement (tolérance aux pannes au niveau matériel) car la préservation de l’information ne dépend pas de l’état local de la particule, mais de la topologie globale du “nœud”. En 2026, la création du premier qubit logique topologique à haute fidélité au monde a été confirmée, attirant l’attention en tant que raccourci puissant vers le FTQC.

6. Feuille de route et perspectives vers une application pratique

Pour que l’ordinateur quantique démontre véritablement l’avantage quantique (Quantum Advantage) en surpassant les ordinateurs classiques (supercalculateurs) dans des domaines tels que la “chimie computationnelle”, la “science des matériaux” et la “modélisation financière”, des milliers de qubits logiques sont nécessaires.

gantt title "Feuille de route de l'informatique quantique (Révisée en 2026)" dateFormat YYYY axisFormat %Y section "Ère NISQ" "Qubits bruités (<1000)" :done, 2018, 2024 section "Début de la FTQC" "Démonstration du seuil de rentabilité" :done, 2024, 2026 "Centaines de qubits logiques" :active, 2026, 2028 section "FTQC à grande échelle" "1000+ qubits logiques (App commerciale)" : 2028, 2030 "Ordinateur quantique universel tolérant aux pannes" : 2030, 2035

6.1 Défis actuels et avenir

Le plus grand défi à l’heure actuelle en 2026 réside dans la capacité de refroidissement des immenses cryostats (réfrigérateurs à dilution) nécessaires au maintien de températures extrêmement basses, et dans le câblage (goulot d’étranglement des E/S) reliant l’équipement de contrôle à température ambiante et la puce quantique à température cryogénique. Face à cela, le développement de puces de contrôle CMOS fonctionnant en environnement cryogénique (Cryo-CMOS) progresse à un rythme effréné.

Conclusion

L’année 2026 sera enregistrée dans l’histoire des ordinateurs quantiques comme “l’année inaugurale de la mise à l’échelle des qubits logiques”. Grâce à la démonstration des algorithmes de correction d’erreurs, à la modularisation du matériel et aux progrès rapides de l’approche topologique, le “jour de la mise en pratique” n’est plus une histoire lointaine, mais un jalon concret à atteindre d’ici quelques années. Pour les développeurs d’algorithmes quantiques et les entreprises, c’est le moment idéal pour investir sérieusement dans la résolution de problèmes en mode “quantum-native”.

Cet article a été rédigé sur la base des dernières recherches et tendances de l’industrie de l’informatique quantique en 2026.