Prime Numbers on kenji.blog

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.