Introduction et modèles de sécurité

En 1883, dans le Journal des sciences militaires, Auguste Kerckhoffs énonce six règles pour les chiffres de campagne. Cinq sont datées — elles parlent de télégraphe et de portabilité. La seconde a fondé la discipline : le système ne doit pas exiger le secret, et doit pouvoir tomber sans inconvénient entre les mains de l'ennemi.

Ce premier chapitre ne chiffre rien. Il installe le vocabulaire sans lequel les treize suivants seraient une collection de recettes : ce qu'on protège, contre quel adversaire, et ce que « sûr » signifie exactement — car ce mot, employé sans modèle, ne veut rien dire.

Quatre garanties, à ne pas confondre

Un système cryptographique ne protège jamais « en général ». Il offre des garanties nommées, et l'erreur la plus commune consiste à croire que l'une entraîne les autres.

Deux confusions méritent d'être défaites tout de suite.

Chiffrer n'est pas protéger l'intégrité. Un message chiffré en mode flot — ou en CTR, que le chapitre 4 détaillera — se modifie sans être lu. Le chiffré est le clair masqué par une suite pseudo-aléatoire ; inverser un bit du chiffré inverse le bit correspondant du clair. Si le message est VIREMENT 0100 EUR, un attaquant qui sait où se trouve le montant le change sans posséder la clé et sans jamais lire le message. C'est la malléabilité, et c'est la raison d'être du chapitre 8.

Un MAC n'apporte pas la non-répudiation. Un code d'authentification repose sur une clé partagée : Alice et Bob la détiennent tous les deux. Si Bob présente à un juge un message authentifié, Alice répond qu'il a pu le fabriquer lui-même — et elle a raison, rien ne les distingue. Seule une signature à clé publique, où la clé de vérification n'est pas la clé de production, oppose une preuve à un tiers. C'est le chapitre 9.

Le principe de Kerckhoffs, et ce qu'il ne dit pas

La formulation moderne du principe tient en une phrase : toute la sécurité doit résider dans la clé. Shannon la reprendra en 1949 sous une forme plus brutale — l'ennemi connaît le système.

La justification est pratique avant d'être théorique. Une clé se change ; une conception ne se change pas. Le jour où un employé part, où un boîtier est démonté, où un binaire est décompilé, un système dont le secret était la conception est perdu définitivement, et pour tous ses utilisateurs à la fois. L'histoire a tranché sans appel : CSS des DVD, A5/1 du GSM, Crypto1 des cartes MIFARE — tous conçus dans le secret, tous cassés dans les semaines qui ont suivi leur rétro-ingénierie.

Une nuance d'honnêteté s'impose cependant, car le principe est souvent récité trop vite. Kerckhoffs n'interdit pas de garder une architecture confidentielle : il interdit d'en dépendre. Ne pas publier la topologie de son réseau interne est une mesure de défense en profondeur raisonnable. Faire reposer la confidentialité des communications sur le fait que personne ne devinera l'algorithme ne l'est pas. La différence est celle entre une couche supplémentaire et une fondation.

L'adversaire : ce qu'il voit, ce qu'il peut

On distingue d'abord deux postures.

L'attaquant passif observe. Il enregistre le trafic et l'analyse hors ligne, parfois des années plus tard — c'est le modèle du « récolter maintenant, déchiffrer plus tard » qui motive toute la migration post-quantique du chapitre 14.

L'attaquant actif intervient. Il modifie, rejoue, supprime, injecte, se place entre les correspondants. Un protocole sûr contre le premier peut s'effondrer entièrement devant le second : Diffie-Hellman non authentifié, au chapitre 10, en est l'exemple canonique.

Ces postures se raffinent en modèles d'attaque, qui précisent ce que l'adversaire obtient. Ils ne décrivent pas des attaquants réels ; ils décrivent des contrats. Prouver qu'un schéma résiste dans un modèle, c'est s'engager sur ce que l'adversaire peut faire, et sur rien d'autre.

Le sens de la progression est qu'un modèle plus fort n'est pas une paranoïa d'universitaire. CPA est le minimum dès que l'attaquant peut provoquer un chiffrement — c'est-à-dire dès qu'il y a un navigateur en face. CCA2 est le minimum dès qu'un serveur déchiffre ce qu'on lui envoie et se comporte différemment selon le résultat, ne serait-ce qu'en renvoyant un message d'erreur ou en répondant plus lentement. Les deux attaques les plus célèbres de la cryptographie appliquée — Bleichenbacher sur PKCS#1 en 1998, Vaudenay sur le padding CBC en 2002 — sont exactement cela : des attaques CCA contre des systèmes qu'on croyait déployés en sécurité.

Sécurité inconditionnelle et sécurité calculatoire

Deux ambitions très différentes coexistent sous le mot « sûr ».

La sécurité inconditionnelle ne suppose rien de l'adversaire : ni son temps, ni sa puissance, ni ses algorithmes. Le chiffré ne contient tout simplement pas l'information cherchée. Le masque jetable en est le seul exemple usuel, et le chapitre 3 montrera que cette perfection se paie d'une clé aussi longue que le message — ce qui la rend inutilisable dans presque tous les cas.

La sécurité calculatoire suppose l'adversaire limité, et c'est sur elle que repose la totalité de la cryptographie déployée. L'énoncé prend la forme : tout adversaire s'exécutant en temps polynomial probabiliste ne réussit qu'avec une probabilité négligeable. Trois termes techniques s'y cachent.

Un algorithme est PPT (probabiliste, polynomial) si son temps d'exécution est borné par un polynôme en le paramètre de sécurité $n$ et s'il peut tirer à pile ou face. Le probabilisme n'est pas un détail : un chiffrement déterministe ne peut pas être sûr contre CPA, et vous allez le vérifier vous-même dans un instant.

Une fonction $\varepsilon(n)$ est négligeable si elle décroît plus vite que l'inverse de tout polynôme : pour tout $c$, il existe $N$ tel que $\varepsilon(n) < n^{-c}$ pour $n > N$. En pratique, $2^{-128}$.

L'avantage d'un adversaire est l'écart entre son taux de succès et celui du hasard. Deviner un bit avec probabilité $1/2$ n'est pas une attaque ; le faire avec probabilité $1/2 + \varepsilon$ pour $\varepsilon$ non négligeable en est une.

On parle de « sécurité 128 bits » lorsque la meilleure attaque connue demande de l'ordre de $2^{128}$ opérations. L'ordre de grandeur mérite d'être posé une fois pour toutes : à $10^{12}$ essais par seconde et par machine, avec un milliard de machines, $2^{128}$ essais demandent environ $10^{7}$ fois l'âge de l'univers. Ce n'est pas « très difficile », c'est d'une autre nature. Toute la question est de savoir si la meilleure attaque connue est bien la meilleure attaque.

Ce que « cassé » veut dire

Le vocabulaire académique est plus exigeant que l'intuition. Un schéma est cassé dès qu'existe un algorithme qui fait mieux que l'attaque générique, même si cet algorithme reste hors de portée. La meilleure attaque publiée sur AES-128 demande environ $2^{126{,}1}$ opérations : c'est une cassure au sens théorique — elle bat la recherche exhaustive — et elle n'a strictement aucune conséquence pratique.

Cette exigence n'est pas un excès de rigueur. Les attaques ne s'améliorent jamais dans le sens de la difficulté : la première brèche sur MD5 était théorique en 1996, les collisions sont devenues pratiques en 2004, et un faux certificat a été forgé en 2008. Un affaiblissement théorique est un préavis, et la seule question raisonnable est de savoir combien de temps il laisse.

Symétriquement, un schéma prouvé sûr ne l'est que dans un modèle, sous une hypothèse, et pour les capacités que ce modèle accorde à l'adversaire. Aucune preuve du chapitre 12 ne protège contre une clé lue dans la mémoire, un générateur aléatoire défaillant ou un temps d'exécution qui dépend du secret. La cryptographie déployée casse presque toujours par là.

À vous

Le meilleur moyen de comprendre un modèle de sécurité est de tenir le rôle de l'adversaire. Le jeu ci-dessous est celui d'IND-CPA, réduit à son squelette : vous choisissez deux messages, le défieur en chiffre un au hasard en mode ECB, et vous devez dire lequel.

Vous ne chercherez aucune clé. Une attaque, dans ce cadre, c'est une question bien posée.

// Le jeu IND-CPA, en miniature.
//
// Le défieur choisit une clé et un bit secret b. Vous lui soumettez DEUX
// messages ; il chiffre celui d'indice b et vous rend le chiffré. Vous gagnez
// si vous devinez b mieux qu'à pile ou face.
//
// Le chiffrement ci-dessous est un mode ECB : chaque bloc de 4 caractères est
// chiffré indépendamment, avec la même clé.

const BLOC = 4;

// Une permutation jouet : le vrai AES ne changerait rien à l'attaque.
function chiffrerBloc(bloc, cle) {
  let sortie = "";
  for (let i = 0; i < bloc.length; i++) {
    sortie += String.fromCharCode(((bloc.charCodeAt(i) + cle * (i + 7)) % 26) + 97);
  }
  return sortie;
}

function ecb(message, cle) {
  let sortie = "";
  for (let i = 0; i < message.length; i += BLOC) {
    sortie += chiffrerBloc(message.slice(i, i + BLOC), cle);
  }
  return sortie;
}

// ── Le défieur ────────────────────────────────────────────────────────────
function defieur(m0, m1) {
  const cle = 1 + Math.floor(Math.random() * 25);
  const b = Math.random() < 0.5 ? 0 : 1;
  return { chiffre: ecb(b === 0 ? m0 : m1, cle), b };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Choisissez deux messages de MÊME longueur (8 caractères, soit 2 blocs).
//    Un seul des deux doit produire deux blocs chiffrés identiques.
// 2. Écrivez le distingueur : il ne voit que le chiffré et doit rendre 0 ou 1.

const m0 = "aaaabbbb"; // à modifier
const m1 = "aaaabbbb"; // à modifier

function distinguer(chiffre) {
  const bloc1 = chiffre.slice(0, BLOC);
  const bloc2 = chiffre.slice(BLOC, 2 * BLOC);
  return 0; // à compléter
}

// ── Mesure ────────────────────────────────────────────────────────────────
let succes = 0;
for (let essai = 0; essai < 10000; essai++) {
  const { chiffre, b } = defieur(m0, m1);
  if (distinguer(chiffre) === b) succes++;
}
console.log("taux de succès :", (succes / 100).toFixed(1) + " %");
console.log("le hasard donnerait 50 %. Au-dessus de 51 %, ECB est distingué.");

// Le message m0 répète le même bloc : en ECB, deux blocs identiques en clair
// donnent deux blocs identiques en chiffré. Le message m1 ne le fait pas.
const m0 = "aaaaaaaa"; // deux fois le bloc "aaaa"
const m1 = "aaaabbbb"; // deux blocs différents

function distinguer(chiffre) {
  const bloc1 = chiffre.slice(0, BLOC);
  const bloc2 = chiffre.slice(BLOC, 2 * BLOC);
  // Blocs chiffrés égaux ⇒ c'est m0 qui a été chiffré ⇒ b = 0.
  return bloc1 === bloc2 ? 0 : 1;
}

// Taux de succès : 100 %. Pas 51 %, pas 60 % — l'attaque est déterministe.
// Aucune clé n'a été retrouvée, et pourtant le schéma est cassé au sens
// IND-CPA : l'adversaire apprend quelque chose du clair, ce qui est
// exactement ce que la définition interdit.

Ce que la suite en fait

Le vocabulaire posé ici sert de grille de lecture à tout le cours. Chaque construction sera présentée avec le modèle dans lequel elle tient : AEAD au chapitre 8 vise la sécurité CCA pour le chiffrement symétrique, OAEP au chapitre 9 vise IND-CCA2 pour RSA, et le chapitre 12 donnera enfin la forme exacte de ces énoncés et la mécanique des réductions qui les démontrent.

Avant cela, le chapitre 2 installe les outils mathématiques dont tous ces schémas dépendent — sans quoi RSA reste une formule et le logarithme discret un mot.

À retenir