Cryptographie post-quantique & Distribution quantique de clés (QKD)

Cryptographie post-quantique (PQC) — survivre à Shor

La cryptographie post-quantique regroupe des algorithmes classiques : ils tournent sur ton CPU habituel, pas sur un ordinateur quantique. Leur particularité ? Ils reposent sur des problèmes mathématiques qu’aucun algorithme quantique connu ne sait casser efficacement. Pour un développeur, c’est un remplacement de bibliothèque, pas un nouveau matériel.

Le problème en clair. Toute notre cryptographie à clé publique (RSA, Diffie-Hellman, courbes elliptiques) repose sur deux difficultés : factoriser un grand nombre et le logarithme discret. L’algorithme de Shor résout les deux en temps polynomial sur un ordinateur quantique. Ces systèmes s’effondrent donc d’un coup.

La parade : trouver d’autres problèmes durs (réseaux euclidiens, hachage, codes correcteurs) et y reconstruire échange de clé et signatures. C’est exactement ce que le NIST a standardisé en 2024.

Shor casse, Grover affaiblit

Menace	Cible	Effet	Réaction
Shor	Clé publique : RSA, DH, ECC/ECDSA	Cassé (temps polynomial)	Changer d’algorithme (PQC)
Grover	Symétrique : AES ; hachage : SHA-2/3	Accélération √N seulement	Doubler la taille de clé (AES-256)

Grover cherche une clé parmi N = 2ⁿ valeurs en environ √N = 2^(n/2) essais : il divise par deux la sécurité effective. Concrètement, AES-128 ne vaut plus que ~64 bits de sécurité ; on passe donc à AES-256 (≈128 bits effectifs, large marge). Le chiffrement symétrique et le hachage ne sont pas en crise — seule la clé publique l’est.

Les standards NIST (2024)

Nom historique	Norme	Rôle	Famille
Kyber	ML-KEM (FIPS 203)	Échange de clé (KEM)	Réseaux euclidiens
Dilithium	ML-DSA (FIPS 204)	Signature	Réseaux euclidiens
SPHINCS+	SLH-DSA (FIPS 205)	Signature (secours)	Hachage

« Harvest now, decrypt later ». Un attaquant peut enregistrer aujourd’hui ton trafic chiffré et le déchiffrer plus tard, quand un ordinateur quantique existera. D’où l’urgence de migrer maintenant, avant même qu’une machine ne soit prête.

Côté code, l’écosystème est déjà là — en Python comme en .NET :

# Python — liboqs : un KEM post-quantique (ML-KEM / Kyber)
import oqs
with oqs.KeyEncapsulation("ML-KEM-768") as bob:
    public_key = bob.generate_keypair()       # Bob publie sa clé publique
    # Alice encapsule un secret partagé pour cette clé publique :
    ciphertext, secret_alice = oqs.KeyEncapsulation("ML-KEM-768").encap_secret(public_key)
    secret_bob = bob.decap_secret(ciphertext) # Bob retrouve le MÊME secret
    assert secret_alice == secret_bob          # clé symétrique commune

// .NET — Bouncy Castle : génération d'une paire de clés ML-KEM
using Org.BouncyCastle.Pqc.Crypto.MLKem;
using Org.BouncyCastle.Security;

var gen = new MLKemKeyPairGenerator();
gen.Init(new MLKemKeyGenerationParameters(
    new SecureRandom(), MLKemParameters.ml_kem_768));
var pair = gen.GenerateKeyPair();   // clés publique/privée résistantes à Shor
// System.Security.Cryptography intègre aussi ML-KEM dans .NET récent.

⚠️ PQC ≠ QKD. La PQC est du logiciel classique (nouvelles mathématiques). La QKD, ci-dessous, utilise des qubits physiques. Les confondre est l’erreur n°1 sur ce sujet.

---

Distribution quantique de clés (QKD)

La QKD ne chiffre pas un message : elle permet à Alice et Bob de se mettre d’accord sur une clé secrète aléatoire (ensuite utilisée avec un chiffrement symétrique). Sa sécurité ne vient pas d’un problème mathématique dur, mais des lois de la physique : on ne peut pas copier un état inconnu (non-clonage) et toute mesure perturbe l’état.

BB84, pas à pas

1. Alice tire un bit aléatoire et une base aléatoire : Z (rectiligne, |0⟩/|1⟩) ou X (diagonale, |+⟩/|−⟩). Elle encode le bit dans cette base et envoie le qubit.
2. Bob mesure chaque qubit dans une base choisie au hasard (il ignore celle d’Alice).
3. Tri (sifting). Ils annoncent publiquement leurs bases (jamais les bits) et ne gardent que les positions où les bases coïncident (~50 %). Ailleurs, le résultat est aléatoire → jeté.
4. Contrôle. Ils sacrifient un échantillon des bits restants pour estimer le taux d’erreur (QBER). Trop élevé → espion probable → on abandonne.

Protocole	Ressource	Détection d’espion
BB84 (1984)	Qubits isolés, 2 bases	Erreurs dues à la mesure en mauvaise base
E91 (1991)	Paires intriquées (Bell)	Violation de l’inégalité de Bell (CHSH)

# Qiskit — BB84 : Alice encode UN bit dans une base aléatoire
from qiskit import QuantumCircuit
qc = QuantumCircuit(1, 1)
if bit == 1:
    qc.x(0)            # |0> -> |1>  (valeur du bit)
if base == 'X':
    qc.h(0)            # bascule en base diagonale (|+>, |->)
# Le qubit part vers Bob, qui mesure dans SA propre base aléatoire.
# Si base_Bob == base_Alice -> bit correct ; sinon -> résultat aléatoire.

# Qiskit — Bob mesure un qubit dans une base choisie (Z ou X)
from qiskit import QuantumCircuit

def mesurer_dans_base(base_bob: str) -> QuantumCircuit:
    qc = QuantumCircuit(1, 1)
    if base_bob == 'X':
        qc.h(0)             # base X : on ramène en base Z avant de mesurer
    qc.measure(0, 0)        # mesure en base computationnelle (Z)
    return qc
# Mesurer dans la MAUVAISE base donne un résultat aléatoire : c'est
# exactement ce qui trahit un espion et ce qui fonde la sécurité.

Pourquoi un espion se fait prendre

Eve ne connaît pas la base d’Alice. Si elle intercepte et mesure, elle se trompe de base une fois sur deux ; dans ce cas elle perturbe le qubit et en renvoie un faux. Sur les bits conservés (Alice et Bob d’accord sur la base), cela introduit un QBER d’environ 25 % : ½ (mauvaise base) × ½ (bit erroné). Le théorème de non-clonage lui interdit de copier le qubit pour mesurer la copie tranquillement : il n’y a aucune échappatoire.

PQC vs QKD — et le piège de l’authentification

Critère	PQC	QKD
Nature	Logiciel classique	Matériel quantique
Sécurité fondée sur	Problèmes mathématiques durs	Lois physiques
Déploiement	Mise à jour logicielle	Fibre/optique dédiée, portée limitée
Authentification	Fournie (signatures)	Non fournie — canal classique à authentifier

⚠️ La QKD ne remplace pas tout. Elle garantit la confidentialité de l’échange de clé, mais pas l’authentification : sans canal classique authentifié (souvent par de la PQC ou une clé pré-partagée), un attaquant se place en homme du milieu. La QKD est donc complémentaire de la PQC, pas un substitut.

⚠️ Limites pratiques. Pertes de photons dans la fibre → portée limitée et débit qui chute avec la distance ; pas de répéteur quantique mûr ; attaques par canaux auxiliaires sur les détecteurs réels. La PQC, elle, se déploie partout par simple mise à jour logicielle.

---