Preuves de sécurité des schémas cryptographiques

t
PARIS 8
q
q
UN I V E R S I T É
Vincennes-Saint-Denis
UFR 6 – MITSIC
Mathématiques, Informatique, Technologies, Sciences de l’Information et de la Communication
Preuves de sécurité
des schémas cryptographiques
Hieu Phan & Philippe Guillot
 octobre 
Master Mathématiques Fondamentales et Protection de l’Information
Sommaire
3
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
chapitre I.
Rappels de théorie de la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
§ 1. Machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 2. Problèmes P, problèmes N P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 3. Problèmes N P–complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
7
7
Sommaire
chapitre II.
Fonctions à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
§ 1. Fonction à sens unique concrète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 2. Fonction à sens unique asymptotique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
9
12
chapitre III.
§
§
§
§
1.
2.
3.
4.
Bits difficiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Théorème de Goldreich-Levin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
14
18
19
chapitre IV.
§
§
§
§
§
1.
2.
3.
4.
5.
Générateurs pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
Approche intuitive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Indiscernabilité calculatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Générateur pseudo aléatoire avec expansion d’un bit . . . . . . . . . . . . . . . . . . . . . . . . .
Générateur pseudo-aléatoire avec expansion polynomiale . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
21
22
23
25
chapitre V.
Fonctions pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
§ 1. Motivation et définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 2. Construction d’une famille de fonctions pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . .
§ 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
28
30
chapitre VI.
Permutations pseudo-aléatoires
...............................
32
§ 1. Motivation et définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 2. Construction à partir d’une famille de FPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
§ 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
33
36
4
Sommaire
chapitre VII.
Chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
Schéma de chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Notions de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modèles d’attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Construction d’un schéma de chiffrement IND–CPA . . . . . . . . . . . . . . . . . . . . . . . . . .
Chiffrement de messages de tailles variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Malléabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Codes d’authentification de message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Chiffrement CCA-sûr générique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
37
41
42
44
45
46
50
51
chapitre VIII. Signatures numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
1.
2.
3.
4.
5.
6.
7.
8.
9.
1.
2.
3.
4.
5.
6.
7.
8.
9.
Les cinq mondes d’Impagliazzo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Définition et sécurité des signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le paradigme de Fiat-Shamir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La signature hh une fois ii de Lamport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Une signature hh plusieurs fois ii avec état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fonction de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le paradigme hh hache puis signe ii. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fonctions de hachage universelles à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
chapitre IX.
53
54
55
56
57
59
61
64
65
Chiffrement à clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
Sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CPA-sécurité sémantique du schéma ElGamal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Chiffrement CCA-sûr dans le modèle standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
68
69
70
75
Corrigé des exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
Index alphabétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
§
§
§
§
§
1.
2.
3.
4.
5.
Introduction
Introduction
Dans l’approche classique de la conception de schémas cryptographiques sûr, un concepteur propose
une fonction de chiffrement. Elle est soumise à la sagacité de la communauté cryptographique
qui va tenter de développer des attaques en identifiant des faiblesses. Si ces faiblesses sont
avérées, le schéma est déclaré comme non-sûr. Éventuellement des modifications du schéma initial
sont proposées par le concepteur. Le nouveau schéma est à nouveau soumis aux attaques de la
communauté qui pourra à nouveau découvrir d’éventuelles faiblesses.
Finalement, la communauté accepte la sécurité du schéma si aucune faiblesse critique n’a été mise
en évidence par les travaux des cryptanalystes pendant un certain temps.
Cette approche a montré ses limites. Au bout de combien de temps la sécurité soit-elle être
acceptée ? trois ans ? cinq ans ?
En novembre , la version 1.5 du standard de chiffrement à clés publiques PKCS#1 est publié
par l’entreprise RSA Laboratories. Cinq ans plus tard, en , Daniel Bleichenbacher publie un
article décrivant comment un adversaire peut déchiffrer un message de son choix par une attaque
à cryptogrammes choisis.
Un système de chiffrement à clé publique, reposant sur le problème du sac à dos a été proposé
par Benny Chor et Ronald Rivest en  et a été cassé 10 ans plus tard, en  par Serge
Vaudenay.
Ces exemples montrent qu’il devient nécessaire de développer des arguments pour attester la
sécurité d’un schéma cryptographique.
En cryptographie asymétrique, la sécurité n’est plus inconditionnelle. Un adversaire tout puissant
dispose de toutes les informations pour retrouver la clé privée. Les adversaires réels ne disposent
pas de la puissance de calcul pour effectuer ce travail. La sécurité est devenue calculatoire. Des
éléments quantitatifs de sécurité deviennent nécessaires. Quelle est la puissance de calcul, dont
dispose un adversaire, et qui ne remet pas en cause la sécurité ?
Pour aboutir à des preuves de sécurité, les cryptologues revendiquent une approche scientifique
du problème qui consiste à formaliser l’adversaire, ainsi que les moyens et les informations dont il
dispose pour venir à bout du schéma cryptographique.
La construction des schémas cryptographique repose sur des problèmes réputés difficiles, comme
le problème de la factorisation des entiers, ou le problème du calcul du logarithme discret.
Il est admis que les seules attaques réalistes ne peuvent reposer que sur des algorithmes efficaces, qui
sont par définition des algorithmes dont la complexité en temps et en mémoire ne dépasse pas un
polynôme de la taille des données d’entrée. Au delà d’une complexité polynomiale, l’attaque n’est
pas réaliste. Il suffit d’augmenter légèrement la taille des paramètres pour la rendre impossible.
On suppose également que l’adversaire peut accéder à des sources auxiliaires d’informations, comme
par exemple des cryptogrammes dont le clair est connu, afin de couvrir ce qui est raisonnable
d’envisager en pratique. Pour que la sécurité du schéma cryptographique ne fasse aucun doute, on
se place généralement dans le cas le plus favorable pour l’adversaire.
La sécurité sera avéré si une démonstration existe du fait que l’adversaire ne peut pas atteindre
le but qui lui est assigné malgré tous les moyens et les informations qui sont à sa disposition. Le
but dépend du schéma cryptographique. Cela peut être : retrouver le message clair, retrouver une
information partielle sur le clair, forger une fausse signature, s’authentifier, etc.
Ainsi, dans l’approche moderne de la conception des schéma cryptographique, la boucle de
conception est évitée. La construction repose sur un processus qui consiste à :
5
6
Introduction
– s’appuyer sur des primitive reposant sur des hypothèses admises, comme la difficulté de
factoriser, ou de calculer un logarithme discret, ou encore sur l’existence de fonctions à sens
unique ;
– formaliser la cible de sécurité, l’adversaire, ses moyens, le type d’attaque ;
– construire un schéma cryptographique ;
– apporter la preuve de sa sécurité.
Une fois cette preuve apportée, la sécurité du schéma s’impose, sans avoir recours à la boucle infinie
conception → attaque → correction → attaque → · · · de l’approche traditionnelle.
Une preuve de sécurité est la réduction de la sécurité du schéma aux propriété de la primitive. On
cherchera à montrer que si un adversaire peut casser le schéma cryptographique, alors on peut en
déduire un algorithme pour nier les propriétés de la primitive.
Supposons par exemple qu’un schéma repose sur la difficulté de factoriser. Si montre l’implication
suivante :
Si un adversaire existe contre ce schéma, alors factoriser est un problème facile,
alors par contraposition, on aura finalement montré que
Si factoriser est un problème difficile, alors il n’existe pas d’adversaire contre ce schéma.
Comme il est largement admis que la factorisation est un problème difficile, la conclusion s’impose.
Dans ce domaine de la cryptographie théorique, les acteurs sont des algorithmes. Le principe général
des preuves est d’utiliser un adversaire comme sous-programme d’un programme de factorisation.
Exercice. Rappelons que le système de chiffrement à clé publique de Rabin consiste à élever au
carré un message modulo un entier n égal au produit de deux nombres premiers de même taille.
Le déchiffrement consiste à extraire une racine carrée du cryptogramme. Une redondance dans le
clair permet de choisir entre les quatre racines carrées possibles.
Montrer que si la factorisation des entiers est un problème difficile, alors le chiffrement de Rabin
est sûr contre une attaque à clair choisi.
§ I.1
Machine de Turing
I – RAPPELS DE THÉORIE DE LA COMPLEXITÉ
§ I.1
Machine de Turing
La notion de calculabilité a été formalisé indépendamment par Church et Turing en  pour
formaliser ce qui est intuitivement considéré comme calculable.
La machine de Turing est un dispositif théorique qui permet de définir ce qui est calculable.
Définition I.1 [machine de Turing]
Une machine de Turing est ...
Définition I.2 [machine de Turing non déterministe]
Une machine de Turing non déterministe est ...
§ I.2
Problèmes P , problèmes N P
Un problème est appelé un problème P s’il est résoluble par une machine de Turing déterministe
en temps polynomial.
Exemples.
Un problème est appelé un problème N P s’il est résoluble par une machine de Turing non
déterministe en temps polynomial.
§ I.3
Problèmes N P –complets
Une réduction polynomiale d’un problème P à un problème Q est...
7
8
Fonctions à sens unique
II – FONCTIONS À SENS UNIQUE
Les fonctions à sens unique constituent une primitive de base de la théorie cryptographique. À
partir d’elles, on peut construire des générateurs pseudo aléatoires ainsi que des fonctions et des
permutations pseudo aléatoires qui sont les composants essentiels des procédés de chiffrement
symétriques.
§ II.1
Fonction à sens unique concrète
De façon informelle, une fonction f est dite à sens unique s’il est facile de calculer la valeur pour
tout paramètre, mais à l’opposé, pour presque toute valeur, il est en pratique impossible de trouver
un antécédent ayant cette valeur pour image. Finalement, les seules valeurs qu’on peut inverser
sont les valeurs qui ont été préalablement calculées. Lorsqu’on a calculé f (x) = y, on sait qu’un
antécédent de y est x. Une fonction est à sens unique, si on ne peut pratiquement pas en dire
davantage.
La notion d’impossibilité pratique repose sur la non existence d’algorithme de complexité polynomiale pour résoudre ce problème. Cette notion est asymptotique.
Les algorithmes de chiffrement du monde réel, comme le DES ou l’AES, ont une taille de clé fixée
(56, ou 128 bits), et opèrent sur des blocs de données d’une taille fixée (64 ou 128 bits). Cela oblige
à distinguer les notions de sécurité concrète ou de sécurité asymptotique.
Définition II.1 [Fonction à sens unique concrète]
Soient m et n deux entiers fixés. Pour deux réels positifs t et ε, une fonction f : {0, 1}n −→
{0, 1}m est dite (t, ε)– à sens unique si pour tout algorithme de complexité inférieure ou égale
à t en temps et en espace, la probabilité qu’il trouve un antécédent à un élément y = f (x)
dans l’image de f , où x est choisi aléatoirement dans {0, 1}n , ne dépasse pas ε.
r
La notion de fonction à sens unique est une notion probabiliste. Il sera toujours possible
de trouver un antécédent aux valeurs qui ont été calculées. La difficulté est exigée pour un
élément aléatoire de l’image de f .
Les algorithmes d’attaques génériques, c’est-à-dire ceux qui n’utilisent pas la structure particulière
des fonctions f , conduisent à des bornes sur les valeurs de t et de ε.
L’algorithme de la force brute, qui consiste à faire un calcul exhaustif des valeurs donne une
première borne.
Proposition II.2 [Borne de la force brute]
Soit f : {0, 1}n −→ {0, 1}m une fonction (t, ε)–à sens unique, alors les paramètres t et ε
vérifient
t
= O (m + n)2n .
ε
Preuve. Pour prouver ce résultat, il suffit d’exhiber un algorithme de complexité t qui réussit avec
un probabilité ≥ ε à trouver un antécédent x à une valeur y aléatoire de l’image f ({0, 1}n ).
Considérons l’algorithme suivant : Pour k valeurs aléatoires distinctes xi , calculer yi = f (xi ). Si
yi = y alors rendre xi comme antécédent. Sinon, renvoyer une valeur aléatoire. La probabilité de
succès de cet algorithme vaut la probabilité que l’un des yi soit égal à y, soit k/2n . Or la complexité
de calcul de la valeur f (yi ) est est au moins égale à (m + n). La complexité de l’algorithme est
bornée par t = k/(n + m), donc ε ≥ k/2n = t/(m + n)2n , donc y/ε ≤ (n + m)2n .
§ II.2
Fonction à sens unique asymptotique
r
En pratique, pour atteindre un paramètre de sécurité de 280 pour le temps de calcul et de
1/260 pour la probabilité de succès, il faut que 2n ≥ 280+60 , soit n ≥ 140.
Des attaques plus subtiles que la force brute sont apparues, en particulier, l’attaque par compromis
temps-mémoire, introduite par Martin Hellman dans son article A cryptanalytic time-memory
trade-off, publié en .
Proposition II.3 [Borne du compromis temps-mémoire]
Soit f : {0, 1}n −→ {0, 1}m une fonction (t, ε)–à sens unique, alors les paramètres t et ε
vérifient
t2
= O (m + n)2 2n .
ε
Preuve. Considérons l’algorithme suivant :
1. Précalcul. Pour j = 1 jusqu’à t, calculer zj f = f t (xj ) pour t valeurs aléatoires x1 , . . . xt .
Mémoriser les couples (xj , zj ) dans une table.
2. Pour l’entrée y, et pour i = 1 jusqu’à t, calculer yj = f i (y).
Si un des yi vaut un des zj alors c’est qu’un image itérée de xj vaut y. L’image itérée précédente
est un antécédent de y.
La complexité de l’algorithme est t × t × (m + n) pour la phase de précalcul qui est effectuée une
fois pour toute.
L’algorithme réussit s’il existe un élément commun dans les listes (zj ) et (yi ) et il échoue dans
le cas contraire. La probabilité de succès vaut la probabilité de trouver un élément commun dans
deux listes aléatoires de t éléments choisies aléatoirement parmi 2n . Le paradoxe des anniversaires
indique que cette probabilité vaut ε = t2 /2n+1 . Pour chaque y, la complexité du calcul est majorée
par (m + n) × t.
r
Cette borne impose que, pour atteindre les paramètres de sécurité t ≥ 280 et ε ≤ 1/260 , la
valeur de n doit vérifier 2n ≥ 22×80+60 = 2220 , donc n ≥ 220.
§ II.2
Fonction à sens unique asymptotique
Définissons tout d’abord ce qu’est une fonction négligeable.
Définition II.4 [fonction négligeable]
Une fonction µ : N −→ R est négligeable si elle est inférieure à l’inverse de tout polynôme
à partir d’un certain rang, c’est-à-dire s’il pour tout polynôme P (x) ∈ R[x], on a :
∃N ∈ N,
∀n ≥ N,
µ(n) ≤
1
.
P (n)
Exemples. La fonction n : 7−→ 1/2n/2 est négligeable, la fonction n : 7−→ n−k ne l’est pas.
r
Une fonction non négligeable est une fonction qui est asymptotiquement supérieure à l’inverse
d’un polynôme. L’ensemble des fonctions non-négligeables est stable par addition, par
multiplication. La puissance d’une fonction non négligeable est non négligeable.
L’ensemble {0, 1}∗ est par définition le monoı̈de libre sur l’alphabet {0, 1}, c’est-à-dire l’ensemble
des mots de longueur quelconque, y compris le mot vide noté ε, écrits avec des 0 et des 1.
Pour définir les fonctions à sens unique asymptotique, la taille des paramètres et des valeurs n’est
pas fixée. Ce sont des mots de longueur quelconque.
9
10
Fonctions à sens unique
Définition II.5 [Fonction à sens unique asymptotique]
Une fonction f : {0, 1}∗ −→ {0, 1}∗ est dite à sens unique si les deux conditions suivantes
sont remplies :
1. La fonction f est facile à calculer, c’est-à-dire il existe un algorithme efficace qui, pour
tout élément x ∈ {0, 1}∗ calcule f (x).
2. La fonction f est difficile à inverser, c’est-à-dire, pour tout algorithme A qui s’exécute en
temps polynomial en n, la probabilité de trouver un antécédent de taille n d’un élément
aléatoire y de l’image de f est une fonction négligeable en n.
On exprime la seconde condition en énonçant que pour tout algorithme efficace A, la fonction :
(1)
n 7−→ Probx∈R {0,1}n A 1n , f (x) = x0 et f (x) = f (x0 ) ,
est une fonction négligeable.
Quelques explications sur les notations de l’écriture (1) :
– La notation x ∈R {0, 1, }n signifie que la probabilité est exprimée lorsque x est un élément choisi
aléatoirement avec la probabilité uniforme dans l’ensemble {0, 1}n .
– Le paramètre 1n de l’algorithme A est un artifice technique pour imposer un paramètre de
taille n à l’algorithme A. L’algorithme A est supposé efficace, c’est-à-dire qu’il a une complexité
polynomiale en la taille des données. Avec ce paramètre, la complexité de A est bornée par un
polynôme en n. Sans ce paramètre, si par exemple la taille de f (x) est en log(n), la complexité
de A serait simplement bornée par un polynôme en log(n), ce qui change complètement la
complexité supposée de l’algorithme A.
r
Comme le calcul de la valeur d’une fonction à sens unique est d’une complexité polynomiale,
retrouver un antécédent d’une fonction à sens unique est un problème N P. En conséquence,
une fonction à sens unique ne peut exister que si P 6= N P.
q
On ne sait pas s’il existe une fonction à sens unique. Cette existence est vraisemblable, mais
qqAA
on ne peut pas la prouver tant que la conjecture P =
6 N P n’est pas résolue. La seule chose
qu’on puisse dire actuellement est que si une fonction à sens unique existe, alors P =
6 N P.
Un problème est N P complet s’il est difficile à résoudre dans le pire des cas. La définition des
fonctions à sens unique stipule qu’elles sont difficiles à inverser dans le cas moyen. Même si on
savait qu’il existe un problème N P qui n’est pas P, le problème de l’existence de fonction à sens
unique resterait ouvert.
La notion de fonction à sens unique est commode pour traiter des résultats théoriques, mais en
pratique, on a plutôt affaire à des familles de fonctions à sens unique, comme par exemple la
fonction puissance qui opère sur un groupe Z/pZ avec une taille donnée pour p.
Soit p un nombre premier. Pour tout entier n ∈ {0, . . . , p − 1} et un générateur g de Z/pZ, il
existe un algorithme efficace pour calculer g n , par exemple par une succession de multiplications
et d’élévations au carré.
Inversement, étant donné un élément y de Z/pZ, on ne connaı̂t actuellement pas d’algorithme de
complexité polynomiale en la taille de y pour trouver l’exposant n qui vérifie y = g n . Ce problème
est le problème du logarithme discret.
La fonction puissance est en pratique une fonction à sens unique. Comme la fonction est différente
pour chaque taille de paramètre, on a affaire à une famille de fonctions à sens unique. Nous sommes
donc amené à définir cette dernière notion.
§ II.2
Fonction à sens unique asymptotique
Définition II.6 [Famille de fonctions à sens unique]
Soit I un ensemble d’indices inclus dans {0, 1}∗ . Une famille de fonctions (fi )i∈I de fonctions
Di −→ {0, 1}∗ est une famille de fonctions à sens unique si les deux conditions suivantes
sont remplies :
1. La famille est facile à échantillonner, c’est à dire :
a) Il existe un algorithme probabiliste S1 , prenant en paramètre un entier n, de
complexité polynomiale en n qui génère un élément i, de taille n, aléatoire dans I.
b) Il existe un algorithme probabiliste efficace S2 , qui à partir d’un élément i de I, génère
un élément aléatoire x du domaine Di .
2. Les fonctions fi sont faciles à calculer, c’est-à-dire il existe un algorithme efficace A qui,
à partir d’un élément i ∈ I et d’un élément x ∈ Di calcule fi (x).
3. Les fonctions fi sont difficiles à inverser, ce qui signifie que la probabilité de succès de
tout algorithme efficace qui prend en entrée un élément i produit par l’algorithme S1 et
un élément aléatoire y de l’image de fi , égal à fi (x), où x est produit par l’algorithme
S2 , pour trouver un antécédent de y, a une probabilité de succès négligeable en la taille
de l’indice i et de l’élément y.
r
La notion de famille de fonction à sens unique est plus proche des fonctions qu’on utilise en
cryptologie réelle, comme le produit d’entiers, la fonction puissance ou la fonction RSA. À
l’opposé, la notion de fonction à sens unique asymptotique, donnée par la définition II.5, est plus
théorique et est plus commode pour manipuler les preuves de sécurité. Nous verrons que ces deux
notions sont équivalentes.
r
Dans les applications cryptologiques, en particulier à clé publique, il faut penser l’indice i
comme étant la clé publique qui permet le chiffrement. L’inversion de la fonction est réservée
aux détenteurs de la clé privée correspondantes.
r
Un algorithme probabiliste est un algorithme qui produit un résultat aléatoire dans l’ensemble
des valeurs possibles. On peut considérer qu’un tel algorithme est un algorithme déterministe
qui a un argument supplémentaire constitué d’une chaı̂ne aléatoire r ∈ {0, 1}∗ en fonction de
laquelle l’élément aléatoire est produit.
La fonction qui à un couple de nombre premiers distincts de même taille associe leur produit est
supposé être une fonction à sens unique. C’est précisément sur cette supposition que repose la
sécurité du système RSA. Voici comment il est formalisé :
– L’ensemble d’indices est l’ensemble N des entiers naturels.
– Pour un entier i ∈ N, le domaine Di est l’ensemble des couples de nombres premiers dont la
taille vaut i.
– Pour un entier n ∈ N, l’algorithme S1 renvoie un entier i aléatoire de taille n.
– L’algorithme S2 génère deux nombres premiers de taille i. Pour générer un nombre premier de
taille i, on génère un entier aléatoire, puis on teste sa primalité à l’aide d’un test probabiliste
de type Miller-Rabin, ou bien à l’aide du test AKS qui est déterministe et de complexité
polynomiale.
– Pour i ∈ I, la fonction fi est (p, q) 7−→ p × q.
Trouver un antécédent de fi revient à factoriser un entier qui est le produit de nombre premiers
de tailles similaires. Les meilleurs algorithmes actuels de factorisation ont une complexité qui n’est
pas polynomiale.
La notion de fonction à sens unique asymptotique est plus facile à utiliser pour démontrer des
résultats de sécurité, mais la notion de famille de fonctions à sens unique correspond mieux au
fonctions utilisées en pratique.
Le théorème suivant énonce que ces deux notions sont équivalentes, ce qui permettra de considérer
l’un ou l’autre cas selon ce qui est le plus commode.
11
12
Fonctions à sens unique
Théorème II.7
Il existe une fonction à sens unique si et seulement si il existe une famille de fonctions à sens
unique.
Preuve. Supposons tout d’abord qu’il existe une fonction à sens unique f : {0, 1}∗ −→ {0, 1}∗ et
construisons à partir de f une famille de fonctions à sens unique.
L’ensemble d’indices I est I = {0, 1}∗ l’ensemble des mots binaires.
Pour un mot binaire i donné dans I, on définit le domaine Di comme étant l’ensemble des mots
binaires de la même longueur que i, c’est-à-dire Di = {0, 1}|i| .
L’algorithme S1 choisit un mot aléatoire binaire de longueur n.
L’algorithme S2 choisit un mot aléatoire binaire de longueur |i|.
Pour tout i ∈ I, la fonction fi est :
fi :
Di
x
−→
7−→
{0, 1}∗
f (x)
Comme la fonction f est à sens unique, toutes les fonctions fi sont à sens unique, car dans le cas
contraire, on pourrait immédiatement en déduire un algorithme qui inverse la fonction f sur une
entrée de longueur n, en trouvant un inverse de fn .
Ceci montre donc l’existence d’une famille de fonctions à sens unique (fu )i∈I .
Réciproquement, à partir d’une famille de fonctions à sens unique, construisons une fonction à sens
unique f .
Rappelons qu’un algorithme qui rend un résultat aléatoire peut se modéliser comme un algorithme
déterministe qui prend en paramètre un mot binaire aléatoire servant de germe à la génération de
l’aléa nécessaire à son calcul.
Pour un élément z de {0, 1}∗ , on définit la valeur de f (x) ainsi :
On coupe le mot binaire z en deux mots de taille moitié. Soit x = (r, s).
On utilise la première moitié r comme chaı̂ne aléatoire qui alimente l’algorithme S1 de la famille
de fonctions à sens unique, et on utilise la deuxième moitié s comme chaı̂ne aléatoire qui alimente
l’algorithme S2 . Ces algorithmes fournissent de manière déterministe un indice i = S1 (r) ∈ I, puis
un élément x = S2 (s, i) ∈ Di . On pose finalement :
f (r, s) = fi (x), i .
Il reste à montrer que la fonction f est à sens unique. Pour cela, supposons le contraire. Cela
signifie que sur une entrée (y, i) ∈ {0, 1}∗ × I, il existe un algorithme efficace qui trouve un élément
(r, s) vérifiant i = S1 (r) et f (r, s) = fi (y). Si on pose x = S2 (s, i), qui est calculable en temps
polynomial, on a trouvé un antécédent x de y par fi , ce qui montre que sous cette hypothèse, la
famille (fi ) n’est pas à sens unique.
§ II.3
Exercices
1. Formaliser précisément la famille de fonctions supposée à sens unique reposant sur le logarithme
discret dans un corps Fp .
2. Même question pour la fonction RSA.
3. Montrer que si P =
6 N P, alors il existe des fonctions qui sont difficiles à inverser dans le pire
des cas, mais qui ne sont pas des fonctions à sens unique.
4. Une fonction {0, 1}∗ −→ {0, 1}∗ est dite à longueur régulière si
∀x, y ∈ {0, 1}∗ ,
|x| = |y| =⇒ |f (x)| = |f (y)|
§ II.3
Exercices
Montrer que s’il existe une fonction à sens unique, alors il existe une fonction à sens unique à
longueur régulière.
5. On dit qu’une fonction {0, 1}∗ −→ {0, 1}∗ conserve les longueurs si, pour tout x ∈ {0, 1}∗ , on a
|f (x)| = |x|. Montrer que s’il existe une fonction à sens unique, alors il existe une fonction à sens
unique qui conserve les longueurs.
6. Soit f : E −→ E une fonction à sens unique.
1. La fonction f ◦ f est-elle à sens unique ?
2. La fonction g : x 7−→ f (x), f ◦ f (x) est-elle à sens unique ?
3. On suppose maintenant que f est bijective. La fonction f ◦ f est-elle à sens unique ?
13
14
Bits difficiles
III – BITS DIFFICILES
Si une fonction est à sens unique, c’est qu’elle cache l’information sur l’antécédent d’une valeur
donnée. Un bit difficile d’une fonction est une information binaire sur l’entrée qu’il est difficile de
retrouver à partir de la valeur de la fonction. Le minimum qu’on puisse exiger d’une fonction à
sens unique est l’existence d’une information calculatoirement inaccessible à partir de la valeur.
Cela caractérise en fait les fonctions à sens unique.
§ III.1
Définition
Soit f : {0, 1}∗ −→ {0, 1}∗ une fonction à sens unique. Considérons la fonction F , qui au couple
(x, i), avec x ∈ {0, 1}∗ et i ∈ {1, . . . , |x|} associe le triplet (f (x), xi , i). La fonction F a la propriété
d’être à la fois à sens unique et de ne cacher aucun bit de son entrée, en ce sens qu’il existe un
algorithme qui, à partir d’une valeur (y, b, i) trouve la valeur de tout bit xj de l’entrée avec une
1
1
, où n est la taille de l’entrée.
probabilité supérieure à +
2 2n
Plus précisément, pour tout entier n, pour tout i compris entre 1 et n, il existe un algorithme Ai
tel que, pour tout x = (x1 , . . . , xn ) choisi aléatoirement dans {0, 1}n , la probabilité que Ai trouve
1
1
.
la valeur de xi à partir de y = F (x) est supérieure à +
2 2n
Exercice. Montrer que la fonction puissance sur un corps fini premier Z/pZ ne cache pas le bit
de poids faible.
Définition III.1
[Bit difficile]
Étant donnée une fonction f : {0, 1}∗ −→ {0, 1}∗, une fonction booléenne {0, 1}∗ −→ {0, 1}
est un bit difficile pour f si
1. La fonction b est calculable en temps polynomial.
2. Tout algorithme polynomial ne peut calculer b(x) à partir de f (x) qu’avec une probabilité
négligeable, c’est-à-dire, pour tout entier n,
1 − 2 Probx∈R {0,1}n [A(1n , f (x)) = b(x)]
est une fonction négligeable en n.
r
L’exemple introductif montre qu’il existe des fonctions à sens unique telles qu’aucune fonction
x 7−→ xi ne soit un bit difficile.
§ III.2
Théorème de Goldreich-Levin
D’après le résultat de l’exercice 3 ci-dessus, une fonction injective qui a un bit difficile est
nécessairement à sens unique. Le théorème de Goldreich-Levin énonce réciproquement qu’à
partir d’une fonction à sens unique, on peut construire une autre fonction à sens unique qui lui est
similaire et qui a un bit difficile. Ce résultat est au cœur de la théorie cryptoglogique.
Théorème III.2 [Goldreich-Levin]
Soit f une fonction à sens unique. Soit g la fonction définie à partir de f par :
g : (x, r) 7−→ f (x), r ,
avec |x| = |r|, alors la fonction booléenne
Pn (x, r) 7−→ x · r est un bit difficile pour g, le produit
scalaire x · r étant défini par x · r = i=1 xi ri (modulo 2)
§ III.2
Théorème de Goldreich-Levin
Preuve. Supposons pour une contradiction que la fonction g n’est pas à sens unique. Il existe alors
un algorithme efficace qui permet de trouver un antécédent (x, r) à partir d’une valeur (y, r), et
cet algorithme permet en particulier de trouver un antécédent x de y par f . Ceci montre que f
n’est alors pas à sens unique, ce qui contredit l’hypothèse.
On suppose pour une contradiction qu’il existe un algorithme B, capable de trouver x · r avec une
probabilité non négligeable.
Supposons dans un premier temps que B trouve x·r avec certitude, c’est-à-dire avec une probabilité
égale à 1 à partir d’une valeur (y, r). Cet algorithme, appliqué successivement avec r égal aux
éléments de la base canonique de {0, 1}n , renvoie les composantes successives de x.
Si maintenant, l’algorithme B rend une réponse non certaine, par exemple avec une probabilité
1 1
non négligeable, égale par exemple à + , alors la méthode ci-dessus ne permet pas de conclure,
2 n
1 n 1
1 n
1 n
=
1+
qui devient
car il rend une bonne réponse avec une probabilité
+
2
n
2
2n
négligeable. Il faut trouver une autre idée.
Cette idée est de construire un algorithme A qui trouve x avec une probabilité non négligeable
en faisant une hypothèse sur ` bits de x. Si ces ` bits sont choisis au hasard, la probabilité qu’ils
soient justes est en 1/2` , mais si ` est assez petit devant n, la probabilité de succès restera non
négligeable.
Soit donc B(y, r) un algorithme qui, pour tout entier n, à partir de y = f (x), pour un élément
x ∈R {0, 1}n aléatoire, et un élément r ∈R {0, 1}n aléatoire également, trouve b(x, r) = x · r à avec
une complexité est bornée par un polynôme en n et réussit avec une probabilité non négligeable
en n. Notons
(2)
1
Probx,r∈R {0,1}n B f (x), r = x · r ≥ + ε(n).
2
Construisons un algorithme A qui utilise B comme sous-programme, efficace en n et qui inverse f ,
c’est-à-dire trouve x, avec une probabilité non négligeable.
L’algorithme A s’appuiera sur ` valeurs supposées connues b1 = x · r1 , . . . b` = x · r` , pour ` valeurs
aléatoires de l’élément r ∈ {0, 1}n .
P
Pour tout sous-ensemble I deP{1, . . . , `}, posons rI =
i∈I ri (modulo 2). Par bilinéarité du
produit scalaire, on a x · rI = i∈I c · ri (modulo 2). Finalement, la connaissance de ` bits permet
de connaitre 2` valeurs.
La valeur de r étant connue, pour tout indice i ∈ {1, . . . , n}, la valeur de xi se déduit de celle de
x · (r + ei ), par :
x · r + x · (r + ei ) = x · ei = xi ,
oà ei est le vecteur de {0, 1}n dont la seule composante non nulle est la ie qui vaut 1.
Considérons l’algorithme A qui, sur une entrée y = f (x), pour x aléatoire dans {0, 1}n , fait appel à
l’algorithme B(y, rI + ei ) pour tous les sous-ensembles non vides de {1, . . . `} pour estimer la valeur
de xi . La valeur de rI · xi étant incertaine et afin d’amplifier la probabilité de succès, la valeur de
xi est estimée par un vote majoritaire pour toutes les valeurs x · rI + B(y, rI + ei ). Précisément,
posons bi,I la réponse de B(y, rI + ei ). Soit xi,I = x · rI + bi,I la valeur estimée de xi à partir de
la réponse bi,I de l’algorithme B. Soit m = 2` − 1 le nombre de sous-ensembles I non vides de
{1, . . . , `}. Il s’agit du nombre d’appels à l’algorithme B. L’estimation de xi par vote majoritaire
est
P
0 si PI xi,I < m/2 ;
∗
xi =
1 si I xi,I ≥ m/2.
Pour montrer cet algorithme convient pour inverser f avec une probabilité non négligeable, il reste
à évaluer sa probabilité de succès et sa complexité.
15
16
Bits difficiles
L’algorithme A fait appel à l’algorithme B sur des valeurs aléatoires de r, mais avec toujours la
même valeur de y = f (x) à inverser. La probabilité de succès de B dans ces conditions ne peut pas
se déduire directement de la relation (2), car cette valeur est donnée pour une entrée y aléatoire. Le
lemme suivant majore la probabilité de succès de B(y, r) lorsque qu’il est appelé avec une valeury
fixée.
Lemme III.3
Soit x un élément fixé de {0, 1}n . Considérons l’évènement S(x) suivant : hh L’algorithme
B f (x), r trouve le bit difficile x · r avec une probabilité non négligeable au moins égale à
1/2 + ε(n). ii Lorsque x est choisi au hasard dans {0, 1}n , la probabilité de l’évènement S(x)
est non négligeable et supérieure à ε(n)/2.
Preuve. Soit Sn l’ensemble des vecteurs x pour lesquels l’algorithme B(f (x), r) réussit avec une
probabilité non négligeable supérieure à 1/2 + ε(n)/2. Montrons que le cardinal de l’ensemble Sn
satisfait |Sn | ≥ 2n × ε(n)/2. Pour cela, supposons le contraire en vue d’une contradiction. Dans ce
cas, on a
Probx,r (B(f (x), r) = x · r) = Probr B(f (x), r) = x · r | x ∈ Sn Prob(x ∈ Sn )
{z
}
{z
}|
|
≤1
< ε(n)/2
+ Probr B(f (x), r) = x · r | x 6∈ Sn Prob(x 6∈ Sn )
{z
},
|
{z
}|
≤
1
< 1/2 + ε(n)/2
<
1
ε(n) 1 ε(n)
+ +
= + ε(n)
2
2
2
2
ce qui est contradictoire avec l’hypothèse (2). Cette inégalité sur le cardinal de l’ensemble Sn
montre que la probabilité de l’évènement S(x) vaut au moins ε(n)/2.
Lemme III.4
Si l’entier ` satisfait 2` ≤ n/ε(n)2 , et sous l’hypothèse que les ` valeurs b1 , . . . , b` de
x · r1 , . . . x · r` sont
√ exacte, la probabilité de succès de l’algorithme A est asymptotiquement
supérieure à 1/ e ≈ 0, 6.
Preuve. Soit Xi,I la variable aléatoire qui vaut 1 si l’estimation xiI est fausse et qui vaut 0 sinon,
c’est-à-dire Xi,I = xi + xi,I (modulo 2). D’après le lemme III.3, on a :
1 ε(n)
+
.
2
2
Prob(Xi,I = 0) ≥
Par conséquent, l’espérance de la variable Xi,I satisfait E(Xi,I ) ≥ 1/2 + ε(n)/2. Posons Xi la
variable aléatoire égale au nombre d’estimations fausses faites pour chacun des sous-ensembles non
vides I de {1, . . . , `}, c’est-à-dire :
X
Xi =
Xi,I .
I⊂{1,...,`}
I6=∅
Par linéarité de l’espérance, on a :
(3)
E(Xi ) ≥
m
ε(n)
+m
,
2
2
donc :
Xi − E(Xi ) ≤ Xi −
m
ε(n)
−m
.
2
2
§ III.2
Théorème de Goldreich-Levin
Or, en raison de la façon d’estimer la composante xi du vecteur x, la probabilité que x∗i soit
différent de xi est exactement la probabilité que Xi soit supérieure à m/2. En raison de l’inégalité
(3), on a :
ε(n) m
Prob(xi 6= x∗i ) = Prob Xi ≥
≤ Prob Xi − E(Xi ) ≤ −m
2
2
ε(n)
≤ Prob Xi − E(Xi ) ≥ m
2
D’après l’inégalité de Chebychev, on a :
Prob(xi 6= x∗i ) ≤
4 Var(Xi )
.
m2 ε(n)2
Comme pour deux sous-ensembles distincts de {1, . . . , `} il existe nécessairement un élément qui
appartient à l’un sans appartenir à l’autre, les variables Xi,I sont deux-à-deux indépendantes. La
variance de Xi est donc la somme des variances des Xi,I :
Var(Xi ) =
X
Var(Xi,I ).
I⊂{1,...,`}
I6=∅
Or :
2
Var(Xi,I ) = E(Xi,I
) − E(Xi,I )2 .
Mais comme la variable Xi,I prend ses valeurs dans l’ensemble {0, 1}, elle est égale à son carré,
d’oà :
Var(Xi,I ) = E(Xi,I ) − E(Xi,I )2 .
Pour majorer Var(Xi,I ), étudions la fonction x 7−→ x − x2 = x(1 − x). Elle a son maximum qui
vaut 1/4 en 1/2, par conséquent :
1
Var(Xi,I ) ≤ ,
4
et donc
m
Var(XXi ) ≤
4
Par conséquent,
1
Prob(xi 6= x∗i ) ≤
mε(n)2
Lorsque l’entier ` satisfait 2` ≤ n/ε(n)2 , on a m = 2` − 1 donc 2m > 2` et donc :
Prob(xi 6= x∗i ) ≤
1
,
2n
ce qui signifie que l’algorithme A calcule correctement le bit xi avec une probabilité supérieure à
1 n
1 − 1/2n. L’ensemble des bits de x est donc calculé avec une probabilité supérieure à 1 −
,
2n
√
et cette quantité converge vers 1/ e. L’algorithme A calcule le vecteur x avec une probabilité non
négligeable, asymptotiquement minorée par une constante.
Fin de la preuve du théorème de Goldreich-Levin. Montrons maintenant que l’algorithme A
hh les `
trouve un antécédent de y = f (x) avec une probabilité non négligeable. Soit C l’évènement
valeurs estimées b1 , . . . , b` sont correctes, et S(x) l’évènement L’algorithme B f (x), r trouve le bit
difficile x · r avec une probabilité non négligeable au moins égale à 1/2 + ε(n). ii. Ces évènements
sont indépendants. Soit R l’évènement qui énonce le succès de l’algorithme A. On a :
Prob(R) ≥ Prob(R | C, S(x)) × Prob(C ∩ S(x)).
17
18
Bits difficiles
ε(n)
. La probabilité de l’évènement S(x) est
n
supérieure à ε(n), et la probabilité
de succès de A sachant que les évènements C et S(x) sont
√
réalisés est supérieure à 1/ e. Il en résulte que :
La probabilité de l’évènement C vaut 1/2` ≥
1
ε(n)3
Probx∈R {0,1}n R ≥ √ ×
,
n
e
qui est non négligeable.
L’algorithme A fait n × 2` appels à l’algorithme B. Si l’algorithme B est efficace, alors l’algorithme
A l’est aussi.
§ III.3
Applications
III.3.1.
Engagement de bit
L’image typique de l’engagement de bit est le jeu de pile ou face par téléphone. Si les partenaires
ne se font pas confiance, il faut un protocole particulier.
1.
n
A
2.
3.
Engagement c Jeu b0
Ouverture d -
n
B
1. Le joueur A choisit un bit b et engage ce bit par le calcul de deux valeurs :
– une valeur d’engagement (commit) c, qu’il transmet à B lors de la première passe.
– une valeur de désengagement d, qu’il conserve pour plus tard.
2. Le joueur B joue un bit b0 et le transmet à A lors de la deuxième passe.
3. Le joueur A transmet la valeur du désengagement d qui va révéler la valeur de son choix b au
joueur B.
Pour mettre en œuvre ce jeu, deux fonctions sont requises :
– Une fonction d’engagement com, qui à partir d’un bit b, calcule un couple (c, d) d’engagement
de désengagement.
– Une fonction d’ouverture open, qui à partir du couple (c, d) d’engagement et de désengagement,
dévoile la valeur du bit b.
Pour empêcher la triche, deux propriétés de sécurité sont définies :
– La propriété d’enchérissement (biding) : la probabilité de trouver deux valeurs de désengagement
d et d0 est négligeable. Cette propriété signifie qu’une fois l’engagement émis, il n’est pas possible
de changer le résultat. En d’autres termes, il n’existe pas d’algorithme efficace qui calcule un
triplet (c, d, d0 ) tel que open(c, d) = open(c, d0 ).
– La propriété de discrétion (hiding) : la valeur de c ne divulgue aucune information sur la valeur
du bit b choisi. En d’autres termes, il n’existe pas d’algorithme efficace qui permet de trouver la
valeur de b à partir de a.
Un bit difficile d’une fonction à sens unique permet de satisfaire la propriété de discrétion. Si de
plus, cette fonction à sens unique est choisie injective, la propriété d’enchérissement sera assurée.
§ III.4
III.3.2.
Exercices
Preuve sans divulgation
L’existence de fonction à sens unique injective implique l’existence de preuve sans divulgation de
la connaissance d’une solution de problème N P (ZK=Zero-Knowledge proof).
Un protocole de preuve sans divulgation comprend deux acteurs :
– Un prouveur qui prouve sa connaissance d’une donnée sans la révéler.
– Un vérifieur, qui vérifie la preuve. À l’issue du protocole, le vérifieur est convaincu que le prouveur
détient la donnée en question, mais n’a acquis aucune information sur cette dernière.
Pour montrer cette assertion, il suffit de la montrer pour un problème N P–complet.
Illustrons cette propriété sur le problème 3–COL. Il s’agit de convaincre qu’un graphe G est
coloriable avec trois couleurs, sans révéler aucune information sur la façon de la colorier.
Le prouveur A peut prouver au vérifieur B qu’il connait un coloriage, mais cette preuve n’est pas
transmissible : B ne pourra pas convaincre d’autres personnes que le graphe est coloriable.
Une preuve sans divulgation se construit à partir d’un engagement de bits.
Un graphe G est un couple (V, E) de sommets et d’arrêtes. Les arrêtes sont un sous-ensemble de
paires {i, j} de sommets.
Un coloriage à trois couleurs est une application σ ; V −→ {1, 2, 3} telle que pour toute arrête
{i, j}, on a σ(i) 6= σ(j).
La preuve sans divulgation de la connaissance d’une telle application σ est interactive et se déroule
sur plusieurs tours. Pour chaque tour :
1. Engagement : le prouveur choisit une permutation aléatoire des couleurs π : {1, 2, 3} −→
{1, 2, 3}, et pour chaque sommet, transmet un engagement de la composition du coloriage avec
cette permutation π.
2. Défi : Le vérifieur défie le prouveur de révéler le coloriage d’une arrête {i, j} aléatoire.
3. Révélation : Le prouveur révèle la valeur de désengagement, ce qui permet de vérifier que les
sommets i et j sont coloriés différemment.
En raison de la propriété d’enchérissage, le prouveur ne peut plus changer les couleurs σ(i) et σ(j).
Si le graphe n’est pas coloriable en trois couleurs, alors il existe au moins une arrête dont les
sommets ont la même couleur, et le vérifieur pourra l’observer à l’issue du désengagement.
La probabilité de convaincre le vérifieur alors qu’on ne connait pas le coloriage du graphe vaut
1 |E|×n
1
1−
. Après un nombre de tours égal à n×|E|, la probabilité de fausse preuve vaut 1−
.
|E|
|E|
1 n
Si le nombre d’arrête est assez grand, une bonne approximation de cette valeur est
qui
e
converge vers O. La probabilité de prouver la connaissance d’une donnée qu’on ignore est donc
négligeable.
§ III.4
Exercices
1. Montrer que, si on suppose que la fonction RSA est à sens unique sans la connaissance de la
factorisation du modulo, alors le bit de parité de la fonction RSA est difficile.
2. Montrer que le bit de parité de la fonction d’exponentiation sur un corps fini n’est pas un bit
difficile
3. Montrer que si une fonction injective a un bit difficile, alors elle est à sens unique, et que ce
résultat est faux si on ne suppose pas la fonction injective.
4. Construire précisément un schéma d’engagement de bit à partir d’une fonction à sens unique
injective et prouver sa sécurité.
19
20
Générateurs pseudo-aléatoires
IV – GÉNÉRATEURS PSEUDO-ALÉATOIRES
§ IV.1
Approche intuitive
Un générateur pseudo-aléatoire (GPA) agit comme un amplificateur d’aléa. Il s’agit d’un algorithme
déterministe qui, à partir d’une petite source aléatoire, produit une suite plus longue, constituée
de symboles qu’on ne peut pas distinguer d’une véritable source aléatoire. Ceci est illustré par le
schéma suivant :
graine
-
GPA
-
(courte)
pseudo-aléa
(long)
Tout d’abord, montrons qu’il est impossible de réaliser un générateur pseudo-aléatoire parfait. Il
est impossible de créer du véritable aléa à partir d’une fonction déterministe.
Définition IV.1 [distance statistique]
Soient X et Y deux variables aléatoires à valeur dans un même ensemble fini X . On appelle
distance statistique de X et Y la quantité :
X ∆(X, Y ) =
Prob(X = α) − Prob(Y = α).
α∈X
Définition IV.2 [Familles statistiquement indiscernables]
Soient X = (Xn )n∈N et Y = (Yn )n∈N deux familles de variables aléatoires à valeur dans le
même ensemble fini X . On dit que les deux familles sont statistiquement indiscernables si
la distance statistique de Xn à Yn est une fonction négligeable de n.
Montrons qu’un GPA parfait n’existe pas. Ce résultat est similaire au principe de non création
d’information en théorie de l’information qui énonce qu’il est impossible de créer de l’information
à partir d’une manipulation déterministe des données.
Proposition IV.3
[Inexistence d’un GPA statistique]
Pour tout entier n, soit Un la variable aléatoire uniforme sur l’ensemble {0, 1}n . Soit g
une fonction
quelconque {0, 1}n −→ {0, 1}n+1 . Alors, les familles de variables aléatoires
g(Un ) n∈N et (Un+1 )n∈N ne sont pas statistiquement indiscernables.
Preuve. La loi de g(Un ) est donnée, pour y ∈ {0, 1}n+1 , par :
X
1
Prob g(Un ) = y =
Prob(Un = x) = n #{x ∈ {0, 1}n | g(x) = y}.
2
x,g(x)=y
Soit n un entier. La distance statistique ∆(n) = ∆ g(Un ), Un+1 entre les variables aléatoires g(Un )
et Un+1 est donnée par :
X ∆(n) =
Prob g(Un ) = y − Prob(Un+1 = y)
y∈{0,1}n+1
=
1
2n+1
X
2# x ∈ {0, 1}n | g(x) = y − 1
y∈{0,1}n+1
Dans cette somme, comme 2# x ∈ {0, 1}n | g(x) = y est un entier pair, chaque terme est
supérieur ou égal à 1. D’où ∆(n) ≥ 1 qui n’est pas négligeable.
§ IV.2
Indiscernabilité calculatoire
§ IV.2
Indiscernabilité calculatoire
La qualité d’un générateur pseudo-aléatoire, qui est l’impossibilité de discerner entre une source
issue d’un véritable générateur d’aléa (GDA) et une source issue d’un générateur pseudo-aléatoire
(GPA) est donc une notion calculatoire. Si le GPA est sûr, un algorithme efficace ne doit pouvoir
le distinguer d’un GDA qu’avec une probabilité négligeable.
Définition IV.4 [avantage d’un distingueur]
Considérons deux familles variables aléatoires X = (Xn )n∈N et Y = (Yn )y∈N . Un distingueur
de ces familles est un algorithme D qui est supposé discerner l’une de l’autre et qui rend
une valeur binaire 0 ou 1, sur une réalisation de l’une ou l’autre de ces variables aléatoires.
L’avantage de D est la fonction :
AdvD (Xn , Yn ), : n 7−→ Prob D(1n , Xn ) = 1 − Prob D(1n , Yn ) = 1 r
Un distingueur prend en paramètre la réalisation d’une variable aléatoire. La valeur rendue
est donc aléatoire.
L’avantage d’un distingueur est nul s’il ne peut pas discerner l’une et l’autre famille. Il vaut 1 s’il
discerne toujours une réalisation de Xn d’une réalisation de Yn .
Pour deux familles de variables aléatoires, l’ensemble des avantages de tous les distingueurs est un
sous-ensemble de R majoré par 1. Il admet donc une borde supérieure, ce qui autorise la définition
suivante :
Définition IV.5 [distance calculatoire de familles de variables aléatoires]
Étant données deux familles de variables aléatoires X = (Xn )n∈N et Y = (Yn )y∈N sur
un même ensemble, la distance calculatoire entre ces deux familles, notée ∆X,Y (n) est la
fonction en n qui donne l’avantage du meilleur distingueur, c’est-à-dire pour tout n entier :
∆X,Y (n) = sup AdvD (Xn , Yn ) ,
D∈D
où D est l’ensemble des distingueurs de complexité polynomiale.
La distance calculatoire satisfait l’inégalité triangulaire.
Proposition IV.6
[inégalité triangulaire sur la distance calculatoire]
Soient X = (Xn )n∈N , Y = (Yn )y∈N et Z = (Zn )y∈N trois familles de variables aléatoires. La
distance calculatoire satisfait pour tout entier n :
(4)
∆X,Z (n) ≤ ∆X,Y (n) + ∆Y,Z (n).
Preuve. Pour tout réel strictement positif ε, il existe un distingueur Dε tel que :
∆X,Z (n) ≤ Prob Dε (1n , Xn ) = 1 − Prob Dε (1n , Zn ) = 1 ≤ Prob Dε (1n , Xn ) = 1 − Prob Dε (1n , Yn ) = 1 +
Prob Dε (1n , Yn ) = 1 − Prob Dε (1n , Zn ) = 1 ≤ AdvDε (Xn , Yn ) + AdvDε (Yn , Zn )
21
22
Générateurs pseudo-aléatoires
L’inégalité pour la distance calculatoire est obtenue par passage à la borne supérieure sur tous les
distingueurs polynomiaux. Pour tout ε > 0, on a :
∆X,Z − ε ≤ ∆(X, Y ) + ∆(Y, Z).
Cette inégalité étant satisfaite pour tout ε > 0, l’inégalité (4) s’en déduit.
L’indiscernabilité calculatoire, définie ci-après, est l’objectif à atteindre pour un générateur pseudoaléatoire.
Définition IV.7 [indiscernabilité calculatoire]
Deux familles de variables aléatoires X = (Xn )n∈N et Y = (Yn )y∈N sont calculatoirement
indiscernables si pour tout algorithme efficace D, l’avantage de D pour discerner Xn de Yn
est une fonction négligeable en n.
L’indiscernabilité calculatoire signifie que tout distingueur efficace est incapable de discerner l’une
de l’autre variable aléatoire avec une probabilité non négligeable.
Définition IV.8 [générateur pseudo-aléatoire]
Un générateur pseudo-aléatoire est un algorithme déterministe G qui vérifie les deux
conditions suivantes :
1. Expansion : il existe une fonction ` : N −→ N telle que pour tout entier n, on a `(n) > n
et tel que pour tout mot binaire s ∈ {O, 1}∗ , on a |G(s)| = `(|s|).
2. Pseudo-aléa : L’image par G de la distribution uniforme Un est calculatoirement indistinguable de la distribution uniforme U`(n) .
La propriété d’expansion signifie que la longueur de l’image par G d’un mot binaire s de {0, 1}∗
ne dépend que de la longueur de s et est toujours plus longue que s.
r
Notons U = (Un )n∈N la famille des variables aléatoires
uniformes sur {0, 1}n . Posons Y la
famille de variables aléatoires Y = g(Un−1 )
. La propriété de pseudo-aléa s’exprime
n≥1
également en énonçant que la distance calculatoire :
∆Y,U (n)
est négligeable.
§ IV.3
Générateur pseudo aléatoire avec expansion d’un bit
La première étape dans la construction de générateurs pseudo-aléatoire est d’en construire avec une
expansion d’un seul bit, c’est-à-dire de GPA {0, 1}n −→ {0, 1}n+1 . Le théorème suivant propose
une réponse à ce problème.
Théorème IV.9
Si f est une permutation à sens unique et b est un bit difficile de f , alors la fonction
g :
{0, 1}n
x
−→
7−→
{0, 1}n+1 f (x), b(x)
est un générateur pseudo-aléatoire.
Preuve. Supposons, pour une contradiction, que la fonction g ainsi définie n’est pas un générateur
pseudo-aléatoire, c’est-à-dire qu’il existe un distingueur D sachant discerner avec une probabilité
non négligeable, entre l’image par g d’une valeur aléatoire et une valeur aléatoire.
§ IV.4
Générateur pseudo-aléatoire avec expansion polynomiale
Utilisons ce distingueur D pour construire un algorithme A qui va trouver le bit difficile b(x) à
partir d’une image f (x).
Sur une entrée y = f (x), l’algorithme A choisit un bit aléatoire r ∈ {0, 1}, puis soumet le couple
(y, r) à l’algorithme D supposé discerner entre une valeur
aléatoire (GDA) et une valeur pseudoaléatoire (GPA) qui est le résultat du calcul f (x), b(x) .
Si le distingueur D répond hh GPA ii, c’est probablement que le bit r choisi aléatoirement vaut b(x),
et alors l’algorithme A renvoie r comme candidat au bit difficile.
Si au contraire, le distingueur D répond hh GDA ii, c’est probablement que le bit r n’est pas la
valeur de b(x), et alors l’algorithme A renvoie son complémentaire r = 1 − r comme candidat au
bit difficile.
Montrons que cette stratégie est efficace en calculant sa probabilité de succès en fonction de celle du
distingueur D. Par hypothèse, la probabilité de succès de D est non négligeable, ce qui s’exprime
par la relation :
h
i
h
i
Probx∈R {0,1}n D f (x), b(x) = GPA − Probz∈R {0,1}n+1 D x = GPA = ε(n)
où ε(n) est une fonction non négligeable de n. Maintenant, évaluons l’avantage de A, qui est égal à
h
i 1
AdvA = Probx∈R {0,1}n A f (x) = b x − ,
2
et montrons qu’il est non négligable. Décomposons la probabilité de succès de l’algorithme A selon
la valeur de b(x). Par construction, si b(x) = r, il s’agit de la probabilité que le distingueur D
réponde GPA. De même, si b(x) = 1 − r, l’algorithme A répond correctement si le disgingueur D
répond GDA. Par conséquent, en application de la formule de Bayes, on a :
h
i
h
i
AdvA = Probx∈R {0,1}n b(x) = r × Probx∈R {0,1}n D f (x), r = GP A
h
i
h
i
+ Probx∈R {0,1}n b(x) = 1 − r × Probx∈R {0,1}n D f (x), 1 − r = GDA
−
1
2
Le bit r choisi par A étant aléatoire, il vaut b(x) avec une probabilité
1/2. De même, 1−r vaut b(x)
avec probabilité 1/2. De plus, si b(x) = 1 − r, l’entrée f (x), r de l’algorithme D est finalement
une entrée aléatoire. La probabilité que D réponde GDA est le complément à 1 de la probabilité
qu’il réponde GPA, donc finalement :
h
i 1
h
i 1
1
AdvA = Probx∈R {0,1}n D f (x), r = GP A +
1 − Probx∈R {0,1}n+1 D x) = GP A −
2
2
2
h
i
h
i
1
=
Probx∈R {0,1}n D f (x), b(x) = GPA − Probz∈R {0,1}n+1 D x = GPA
2
ε(n)
=
2
L’avantage de A est finalement le même que celui de D. Il est non négligeable.
§ IV.4
Générateur pseudo-aléatoire avec expansion polynomiale
La deuxième étape de la construction des générateurs pseudo-aléatoires est d’en construire avec
une expansion supérieure à un seul bit. Soit p(n) une fonction d’expansion polynomiale en n. Le
procédé suivant utilise un générateur pseudo-aléatoire g1 d’expansion 1 bit, pour construire un
générateur pseudo-aléatoire d’expansion ` = p(n).
On suppose qu’on dispose d’un générateur pseudo-aléatoire g1 tel qu’il soit calculatoirement
impossible de discerner g1 (x) de y, avec x aléatoire dans {0, 1}n et y aléatoire dans {0, 1}n+1 .
23
24
Générateurs pseudo-aléatoires
On peut par exemple utiliser la construction du paragraphe précédent reposant sur une fonction à
sens unique et un bit difficile de cette fonction.
{0, 1}n
s
La construction d’un générateur pseudo-aléatoire
−→
7−→
{0, 1}`
est illustrée par la
σ1 σ2 · · · σ`
figure suivante :
s
g :
g1
g1
g1
- s1
- s2
- ...
g1
- s`
q
q
q
?
σ1
?
σ2
?
σ`
Théorème IV.10 [générateur pseudo-aléatoire avec expansion polynomiale]
Étant donné un générateur pseudo-aléatoire g1 d’expansion 1 bit, soit p(n) un polynôme en
n vérifiant pour tout n entier p(n) > n, soit n un entier et ` = p(n), soit g la fonction définie
sur {0, 1}∗ sont la valeur sur les vecteurs binaires s de dimension n est :
g(s) = σ1 σ2 · · · σ` ,
définie par s0 = s, et, pour i = 1 jusqu’à `, par g1 (si−1 ) = (si , σi ). Alors g est un générateur
pseudo-aléatoire.
Preuve. Soit Y la variable aléatoire produite par le générateur pseudo-aléatoire g avec une graine
S aléatoire. Il faut montrer que la distance calculatoire ∆(Y, U ) est négligeable. Pour montrer cela,
on utilise un procédé dit hybride de démonstration. Cela consiste à définir une suite de variables
aléatoires H0 = Y, H1 , . . . , H` = U , et à montrer que pour tout k ∈ {0, . . . , ` − 1}, la distance
calculatoire ∆Hk ,Hk+1 (n) est négligeable. Par l’inégalité triangulaire (4), on déduit que :
∆Y,U (n) ≤
`−1
X
∆Hk ,Hk+1 (n),
k=0
qui est négligeable, car une somme d’un nombre de terme polynomial en n de termes négligeables
reste négligeable.
Pour k = 1 jusqu’à `, on considère le procédé hk qui consiste à produire de l’aléa véritable jusqu’au
rang k, puis d’appliquer le même procédé que g pour produire la séquence pseudo-aléatoire à partir
du rang k + 1, en utilisant sk comme germe initial.
sk
hk :
q
?
σ1
q
q
?
?
σ2 . . . σk
g1
-
g1
- ...
g1
- s`
q
q
?
σk+1
?
σ`
Ainsi, les symboles σ1 · · · σk sont aléatoires, alors que les symboles σk+1 · · · σ` sont pseudoaléatoires.
Soit Hk la variable aléatoire égale à la production du générateur pseudo-aléatoire hk . Montrons
que la distance calculatoire entre Hk et Hh+1 est négligeable, ce qui démontrera le théorème. Pour
§ IV.5
Exercices
cela, il suffit de montrer que s’il existe un algorithme capable de discerner la production de hk
de la production de hk+1 , alors on peut en déduire un algorithme contre le générateur pseudoaléatoire g1 . Ceci montrera que si g1 est un générateur pseudo-aléatoire, alors hk et hk+1 sont
calculatoirement indiscernables.
Supposons donc l’existence d’un distingueur Dk , capable de discerner une réalisation de hk
d’une réalisation de hk+1 avec un avantage non-négligeable. Ce distingueur peut être utilisé pour
réaliser un algorithme A qui discerne une réalisation de g1 (GPA) d’une réalisation d’une variable
entièrement aléatoire (GDA) comme suit :
Sur une entrée y ∈ {0, 1}n+1 , l’algorithme construit la séquence σ1 . . . σ` , en tirant σ1 · · · σk
au hasard, puis en posant y = (sk+1 , σk+1 ), puis, pour i = k + 2 jusqu’à `, en calculant
(si , σi ) = g1 (si−1 ).
Si le distingueur Dk répond hk , intuitivement, c’est que la valeur de y est elle-même issue d’un
calcul y = g1 (s). L’algorithme A renvoie GPA.
Si au contraire, le distingueur Dk répond hk+1 , c’est que la valeur de y est aléatoire, et donc
l’algorithme A renvoie GDA.
Par construction, l’algorithme A répond GPA sur une entrée y avec la même probabilité que Dk
répond hk sur une entrée σ = σ1 , . . . , σ` .
Prob A(y) = GPA = Prob Dk (σ) = hk
Il en résulte que A et Dk ont le même avantage. Si celui de Dk n’est pas négligeable en `, alors
celui de A n’est pas négligeable non plus en n.
§ IV.5
Exercices
1. Une application de la technique hybride Soit g : {0, 1}n −→ {0, 1}2n un générateur pseudoaléatoire d’expansion `(n) = 2n. Démontrer que pour tout polynôme t(n) en n, la fonction
gt(n) :
{0, 1}n×t(n)
x1 · · · xt(n)
−→
7−→
{0, 1}2n×t(n)
g(x1 ) · · · g(xt(n) )
définit un générateur pseudo-aléatoire. Plus précisément, montrer que si G est la variable aléatoire
G = g(X) avec X aléatoire dans {0, 1}n , et Gt(n) = gt(n) (X1 , . . . , Xt(n) ), avec les Xi aléatoires
dans {0, 1}n
∆ Gt(n) , U2nt(n) ≤ t(n)∆ G, U2n
2. Démontrer que s’il existe un générateur pseudo-aléatoire avec une expansion `(n) = 2n, alors il
existe une fonction à sens unique.
3. Construire un générateur pseudo-aléatoire avec la fonction RSA.
4. Démontrer la sécurité du générateur de Blum-Blum-Shub défini comme suit :
N =p×q
sk+1 = s2k mod N
σk = sk mod 2
5. (multiples message RSA avec le même exposant public) Montrer qu’on peut facilement retrouve
un message m en observant les e cryptogrammes de m chiffrés avec le même exposant public e.
6. (chiffrement de Paillier) Soit N = p × q le produit de deux nombres premiers distincts. La
fonction de chiffrement est :
E;
Z/(N ) × Z/(N )∗
(m, r)
−→
7−→
Z/(N 2 )∗
(1 + N )m rN
25
26
Générateurs pseudo-aléatoires
1. Démontrer que la fonction E est une bijection.
2. Étant donné la clé privée p × q, décrire la fonction de déchiffrement pour retrouver la valeur de
m.
3. Supposons que l’ensemble {rN mod N 2 | r ∈ Z/(N )∗ } est calculatoirement indiscernale
de l’ensemble Z/(N 2 ). Démontrer que pour tout message m, l’ensemble des cryptogrammes
{E(m, r) | r ∈ Z/(N )∗ } est calculatoirement indiscernable de Z/(N 2 ). Cela montrera qu’aucune
information sur m ne transparaı̂t dans le cryptogramme.
r
La fonction de chiffrement de Paillier a la propriété intéressante d’homomorphisme suivante :
E(m1 , r1 ) × E(m2 , r2 ) = E(m1 + m2 , r1 r2 )
Montrer comment cela peut avantageusement s’appliquer au vote électronique, en association avec
une fonction de partage de secret.
§ V.1
Motivation et définition
V – FONCTIONS PSEUDO-ALÉATOIRES
§ V.1
Motivation et définition
Les générateurs pseudo-aléatoires présentés au paragraphe précédent permettent déjà de réaliser
un chiffrement de messages plus longs que la clé. Dans le chiffrement de Vernam, chaque symbole
binaire du message est additionné modulo 2 au symbole correspondant d’une chaı̂ne aléatoire
partagée par les correspondants, comme illustré ci-après :
s
⊕
m
=
c
Pour assurer la sécurité de ce type de chiffrement, il est primordial de n’utiliser la séquence aléatoire
qu’une seule fois (one time pad). Pour chiffrer un autre message, il faut utiliser une autre graine.
Un générateur pseudo-aléatoire peut permettre d’utiliser la même graine pour chiffrer plusieurs
messages.
Une manière de procéder est de produire une très longue chaı̂ne pseudo-aléatoire, et de communiquer un indice à partir duquel considérer la séquence pseudo-aléatoire pour le chiffrement.
s
GPA -
σi
⊕
m
=
c
Comme la production des symboles pseudo-aléatoires est itérative, l’inconvénient est alors d’avoir
à recommencer tous les calculs depuis le premier à chaque message.
L’idéal serait d’avoir un accès direct aux termes suivants de la séquence pseudo-aléatoire, sans
avoir à calculer les précédents.
La notion famille de fonctions pseudo-aléatoires réponds à cet objectif. Il s’agit de construire une
famille de fonctions (Fk )k∈N , calculable en temps acceptable, et qu’on ne doit pas pouvoir distinguer
d’une fonction aléatoire.
Notons Hn l’ensemble de toutes les fonctions {0, 1}`(n) −→ {0, 1}≤`(n) . Une famille pseudo-aléatoire
est une famille de fonction qu’on ne sait pas distinguer de Hn .
Définition V.1 [famille de fonctions pseudo-aléatoires]
Une famille de fonctions Fn = Fk : {0, 1}`(n) −→ {0, 1}≤`(n) | k ∈ {0, 1}n est dite
pseudo-aléatoire si elle satisfait les deux propriétés suivantes :
1. Elle est efficacement calculable, c’est-à-dire il existe un algorithme en temps polynomial
qui sur l’entrée k ∈ {0, 1}n et x ∈ {0, 1}`(n) , retourne la valeur Fk (x).
2. Elle est pseudo-aléatoire, c’est à dire l’avantage de tout algorithme A en temps polynomial, qui distingue un élément de la famille Fn d’une fonction aléatoire de Hn est
négligeable :
ProbF ∈R Fn AF (1n ) = 1 − ProbH∈R Hn AH (1n ) = 1 est une fonction négligeable de n.
q
qqAA
Le nombre des paramètres k ∈ {0, 1}n des fonctions Fk vaut 2n qui est une fonction
exponentielle en n. Un générateur pseudo-aléatoire ne définit donc pas directement une famille
de fonctions pseudo-aléatoires, car on ne peut pas calculer efficacement toutes les valeurs.
27
28
Fonctions pseudo-aléatoires
Un adversaire contre une famille de fonctions aléatoires est un algorithme qui fait des requêtes à
un oracle. Il existe deux sortes d’oracles : les oracles qui, sur une entrée x, rendent la valeur FK (x)
d’un élément fixé, mais inconnu de la famille Fn , et les oracles qui, sur une entrée x, rendent la
valeur H(x) d’une fonction aléatoire fixée. L’algorithme doit pouvoir efficacement répondre si les
réponses de l’oracle sont celles d’une fonction aléatoire ou d’une fonction pseudo-aléatoire.
§ V.2
Construction d’une famille de fonctions pseudo-aléatoires
Ce paragraphe présente la construction d’une famille de fonctions pseudo-aléatoires (FPA) à partir
d’un générateur pseudo-aléatoire (GPA). Elle est due à Goldreich, Goldwasser et Micali.
On suppose que l’on dispose d’un générateur pseudo-aléatoire d’expansion `(n) = 2n :
g :
{0, 1},
k
{0, 1}2n
g(k) = g0 (s), g1 (s)
−→
−→
On note g0 et g1 les fonctions dont les valeurs sont respectivement les n premiers et les n derniers
symboles binaires de la valeur du générateur pseudo-aléatoire g.
g
s
g0 (k)
-
g1 (k)
Soit s la graine du générateur pseudo-aléatoire g. On étend récursivement, pour tout entier ` et
tout mot x ∈ {0, 1}` , la fonction g x (s) en posant x = x0 e avec x0 ∈ {0, 1}`−1 et e ∈ {0, 1} et :
0
g x (s) = g x ◦ ge (s) = sx
La famille Fn est alors définie, pour x ∈ {0, 1}`(n) , par :
fs (x) = g x (s).
Cette construction peut se représenter par un arbre :
g0
n
s00
sn
!
aa g
g0 !
aa1
!!
!
a n
n
s0
s1
g
g
@ 1
0
@ g1
@
@
n
n
n
s01
s10
s11
A
...
A
...
A
A
A
A
...
A
A
...
Chaque feuille contient la valeur de fs (x) = sx .
Lorsque le vecteur x s’écrit x = x1 x2 · · · xn , la valeur fs (x) vaut fs (x) = gxn ◦ · · · ◦ gx2 ◦ gx1 (s).
§ V.2
Construction d’une famille de fonctions pseudo-aléatoires
Théorème V.2
La famille Fn = fk k∈{0,1}n construite comme ci-dessus avec fk : {0, 1}n 7−→ {0, 1}n est
une famille de fonctions pseudo-aléatoires.
Preuve. La preuve de ce théorème utilise la technique hybride. Construisons une suite de familles
de fonctions H 0 , H 1 , H 2 , . . . , H n telle que H 0 = Fn et H n = Hn .
Le choix aléatoire d’un élément dans H 0 est dans le choix aléatoire de la valeur s situé à la racine
de l’arbre ci-dessus.
Le choix aléatoire d’un élément dans la famille H n est dans le choix aléatoire de chacune des feuilles
de l’arbre.
Les familles H i , pour i = 1 jusqu’à n − 1 seront définies en choisissant aléatoirement les valeurs
situées à la profondeur i dans l’arbre, puis en calculant les fils avec les deux fonctions g0 et g1 du
générateur pseudo-aléatoire.
Toutes ces familles sont des familles de fonctions de n variables binaires.
La famille H 0 est l’ensemble des 2n fonctions {fs }s∈{0,1}n , dont la valeur en x = x1 , . . . xn est
donnée par fs (x) = gxn ◦ · · · ◦ gx2 ◦ gx1 (s). Cette famille est illustrée par l’arbre ci-dessus.
La famille H 1 est l’ensemble des 22n fonctions {fs0 s1 }s0 s1 ∈{0,1}2n dont la valeur en x = x1 , . . . xn
est donnée par fs0 s1 (x) = gxn ◦ · · · ◦ gx2 (sx0 ). Une illustration de cette famille est donnée par :
n
s00
sn
0
@ g1
@
n
s01
A
A
...
A
A
...
g0
sn
1
g0
@ g1
@
n
n
s10
s11
A
...
← indices s0 s1 de l’élément de la famille
← valeurs calculées par g0 ou g1 selon x2
A
A
A
...
2
La famille H 2 est l’ensemble des 22 n fonctions {fs00 s01 s10 s11 }s00 s01 s10 s11 ∈{0,1}22 n dont la valeur en
x = x1 , . . . xn est donnée par fs00 s01 s10 s11 (x) = gxn ◦ · · · ◦ gx3 (sx0 x1 ). L’arbre suivant illustre cette
famille :
n
s00
n
s01
A
A
A
A
n
n n
n
...
...
n
s10
n ← indices s00 s01 s10 s11 de l’élément
s11
de la famille
A
A
A
A
n
n n
n← valeurs calculées par g0 ou g1 selon x2
...
...
Ainsi de suite. . .
k
Pour un entier k compris entre 1 et n − 1, la famille H k est l’ensemble des 22 n fonck
tions fs0···0 ···s1···1 }s0···0 · · · s1···1 ∈ {0, 1}2 n dont la valeur en x = x1 , . . . xn est donnée par
fs0···0 ···s1···1 (x) = gxn ◦ · · · ◦ gxk+1 (sx0 ···xk ).
Pour achever la preuve, il reste à montrer que la distance calculatoire entre deux familles
consécutives reste négligeable. C’est l’objet du lemme qui suit.
Lemme V.3
On reprend les notations de l’exercice 1 de la section précédente. Soit t(n) un polynôme en
n. Pour tout distingueur D de H k et H k+1 qui effectue moins de t(n) requêtes un oracle
répond selon un élément d’une de ces deux familles, alors
AdvD H k , H k+1 ≤ ∆(Gt(n) , U2nt(n)
29
30
Fonctions pseudo-aléatoires
Preuve.
Par contraposée, supposons qu’il existe un distingueur D, capable de discerner entre H k et
H k+1 avec t(n) requêtes avec un avantage non négligeable, et montrons qu’on peut construire
un distingueur B capable de discerner entre la variable aléatoire Gt(n) , développement t(n) fois
du générateur pseudo-aléatoire G, et la variable aléatoire uniforme U2nt(n) sur 2nt(n) symboles
binaires.
L’entrée de l’algorithme B est un vecteur α = α1 , . . . αt(n) , où chaque αi = (αi0 , αi1 ) est constitué de
deux composantes dans {0, 1}n . L’algorithme B utilise le distingueur D pour répondre si l’entrée
α est le résultat du générateur pseudo-aléatoire ou est du véritable aléa.
L’algorithme B va simuler un oracle auprès du distingueur D. Afin de discerner entre H k et H k+1 ,
le distingueur D va déposer des requêtes qui consistent à calculer la valeur de l’oracle pour une
valeur x = x1 , . . . xn . Lorsque D dépose la ie requête x1 · · · xn , l’algorithme B vérifie d’abord si
le préfixe x1 · · · xk+1 n’est pas le préfixe d’une requête déjà déposée. Si le préfixe est nouveau,
l’algorithme B calcule la valeur fs (x) de l’oracle en simulant un élément de la famille H k+1 en
utilisant le vecteur αi comme paramètre :
gxk+2 (αi0 ) si xk+1 = 0
fs0···0 ···s1···1 (x) = gxn ◦ · · · ◦
gxk+2 (αi1 ) si xk+1 = 1
αn
00
αn
01
A
...
A
...
A
A
← valeurs initialisées selon xk
← valeurs calculées par g0 ou g1 selon xk+1
Si le préfixe de la requête est le même qu’une requête déjà déposée, alors l’algorithme B renvoie à
D la valeur antérieurement calculée pour ce préfixe.
Ainsi, si αi est le résultat du générateur pseudo-aléatoire g, alors cet oracle simule exactement H k
et si αi est un aléa véritable, alors cet oracle simule exactement H k+1 .
Par conséquent, si le distingueur D sait discerner entre Gt(n) et Unt(n) , alors, en rendant le même
résultat que D,l’algorithme B sait discerner entre H k et H k+1 avec le même avantage :
AdvD H k , H k+1 = AdvB Gt(n) , U2nT (n)
Le résultat du lemme s’obtient par passage à la borne supérieure sur tous les distingueurs de Gt(n)
et U2nt(n) .
Fin de la preuve du théorème V.2. D’après l’exercice 1 de la section précédente, on a
∆ Gt(n) , U2nt(n) ≤ t(n)∆ G, U2n
Par composition, l’avantage d’un
distingueur
de
F
et
H
est
majoré
par
nt(n)∆
G,
U
qui est
n
n
2n
négligeable dès que ∆ G, U2n est négligeable.
§ V.3
Exercices
1. On reprend la construction de Goldreich, Goldwasser et Micali, mais au lieu de définir
des fonctions {0, 1}n , on les définit sur {0, 1}≤n . C’est-a-dire que f (x) est défini pour des tailles
de x variables de 1 jusqu’à n symboles binaires. Cela définit-il encore une famille de fonctions
pseudo-aléatoire ?
2. Construction d’une famille pseudo-aléatoire de fonctions vectorielles à partir d’une famille de
fonctions booléennes pseudo-aléatoires. Étant donnée une famille pseudo-aléatoire fk k∈{0,1}n de
§ V.3
Exercices
fonctions
booléennes fk : {0, 1}p(n) −→ {0, 1}, construire une famille de fonctions pseudo-aléatoire
gs s∈S de fonctions vectorielles gs : {0, 1}p(n) → {0, 1}` .
3. Une famille de fonctions pseudo-aléatoires est toujours à sens unique
On dit qu’une famille de fonctions pseudo-aléatoires {0, 1} −→ {0, 1} est une famille pseudoaléatoire de fonctions à sens unique si, étant donnée un élément y de l’image {0, 1}n , et étant
donné un oracle qui réalise un élément aléatoire fk de la famille, tout algorithme efficace ne peut
trouver un antécédent de y de fk qu’avec une probabilité négligeable.
q
Cela ne signifie pas que les éléments fk de la famille sont des fonctions à sens unique.
qqAA
Connaissant la clé k, il n’y a aucune raison que ces fonctions soient difficiles à inverser.
La définition stipule seulement qu’il n’est pas possible de trouver un antécédent d’un élément y
sans connaissance de la clé k et lorsqu’on ne dispose que d’un oracle pour déterminer les valeurs
fk (x).
Montrer que si la famille Fn est une famille de fonctions pseudo-aléatoire, alors elle est une famille
pseudo-aléatoire de fonctions à sens unique.
31
32
Permutations pseudo-aléatoires
VI – PERMUTATIONS PSEUDO-ALÉATOIRES
§ VI.1
Motivation et définition
Une famille de fonctions pseudo-aléatoires permet de réaliser du chiffrement symétrique. Le
paramètre d’indice de la famille est la clé secrète s. Pour chiffrer un message m de n symboles
binaires, on masque m avec une valeur fs (x) pour une valeur x aléatoire qui est transmise avec le
cryptogramme :
(s, x) 7−→
fs (x)
⊕
m
=
c = m ⊕ fs (x)
Le cryptogramme est γ = (x, c).
Un défaut de cette méthode est l’obligation d’adjoindre au cryptogramme un paramètre x,
obligatoire pour le déchiffrement. L’opération de chiffrement ne préserve pas la longueur.
L’objet de cette section est de définir des familles de permutations pseudo-aléatoires, qui sont
chacune inversible, pour réaliser le chiffrement par bloc. Le cryptogramme est directement l’image
du clair par un élément de cette famille. Le clair se retrouve en inversant la fonction.
Définition VI.1 [famille de permutations pseudo-aléatoires]
Une famille Pn = pk k∈{0,1}n de permutations pk : {0, 1}p(n) −→ {0, 1}p(n) est dite pseudoaléatoire si les trois conditions suivantes sont satisfaites :
1. chaque élément est efficacement calculable : il existe un algorithme efficace V qui calcule
la valeur de tout élément pour tout paramètre k et toute entrée x :
∀k ∈ {0, 1}n ,
∀x ∈ {0, 1}p(n) ,
V (k, x) = pk (x).
2. chaque élément est efficacement inversible : il existe un algorithme efficace V qui calcule
l’antécédent de tout élément y pour tout paramètre k :
∀k ∈ {0, 1}n ,
∀y ∈ {0, 1}p(n) ,
N (k, y) = p−1
k (y).
3. elle a le caractère pseudo-aléatoire : tout algorithme efficace A ne sait distinguer un
élément de la famille d’une permutation réellement aléatoire qu’avec une probabilité
négligeable, c’est-à-dire l’avantage de A défini par :
AdvA = Probp∈R Pn Ap (1n ) = 1 − Probf ∈R Rn Af (1n ) = 1 où Rn désigne l’ensemble de toutes les bijection sur {0, 1}p(n) , est une fonction négligeable
de n.
L’algorithme Ah fait appel à un oracle qui réalise le calcul y = h(x). Il renvoie une valeur qui vaut
1 si A redonnait en h un élément pseudo-aléatoire et renvoie 0 dans le cas contraire, c’est-à-dire
que A reconnaı̂t en h un élément aléatoire. Une famille de permutations est pseudo-aléatoire si
tout algorithme Ah ne donne la bonne réponse qu’avec un avantage négligeable.
r
Il existe également une notion plus forte de famille de permutation super pseudo-aléatoire,
dont les éléments restent indistinguable d’une permutation aléatoire, y compris lorsque
−1
l’algorithme Ah,h dispose de deux oracles : un pour la permutation, et l’autre pour la permutation
inverse.
§ VI.2
§ VI.2
Construction à partir d’une famille de FPA
Construction à partir d’une famille de FPA
Le schéma de Feistel est une construction d’une bijection à partir d’une fonction non
nécessairement bijective. C’est cette construction, itérée sur 16 tours, qui est à l’œuvre dans beaucoup d’algorithmes de chiffrement par bloc comme le DES.
Un mot de 2n symboles binaires est partagé en deux parties de n symboles binaires chacune : la
partie gauche notée L et la partie droite notée R.
L
R
@
@
@
fn
@
@
@ k
+
L1
L1 = R
R1 = L ⊕ f (R)
Réciproque :
R = L1
L = R1 ⊕ f (L1 )
R1
Ce schéma est toujours inversible, y compris lorsque la fonction f utilisée ne l’est pas.
q
Même si on suppose que la fonction f est aléatoire, un tour de Feistel n’a pas la propriété
qqAA
d’être pseudo-aléatoire, puisque la partie gauche du résultat est toujours égale à la partie
droite.
Il est immédiat de construire un distingueur qui saura presque toujours distinguer entre un tour de
Feistel et une fonction aléatoire. Il n’échouera que si fortuitement une fonction aléatoire renvoie
une valeur gauche égale à son entrée droite, ce qui est négligeable.
Essayons deux tours de Feistel :
L
R
@
@
@
fn
1
@
@
@ k
+
@
@
@
fn
2
@
@
@ k
+
L2
L2 = f (R) ⊕ R
R2 = R ⊕ f2 L ⊕ f1 (R)
R2
Le schéma à deux tours n’a pas non plus la propriété d’être pseudo-aléatoire. Alors que pour une
bijection aléatoire, deux entrées différentes ont des sorties distinctes, aléatoires et indépendantes.
Dans le schéma de Feistel à deux tours, on a la relation :
L ⊕ L2 = f (R).
Ainsi en envoyant deux requêtes (L, R) et (L0 , R) à l’oracle avec la même partie droite R, on peut
reconnaı̂tre le schéma de Feistel à deux tours en calculant la somme modulo 2 des entrées gauche
et des sorties gauches L ⊕ L2 et L0 ⊕ L02 . Si on trouve que ces sommes sont égales, alors avec une
très forte probabilité, l’oracle est celui d’un schéma de Feistel à deux tours. Il est hautement
improbable d’avoir cette propriété avec une fonction aléatoire.
33
34
Permutations pseudo-aléatoires
Il faut au moins trois tours avec trois fonctions de tour choisie aléatoirement dans une famille
pseudo-aléatoire de fonctions pour atteindre la propriété d’être une famille pseudo-aléatoire de
permutations, et il faut quatre tours pour atteindre la propriété d’être une famille super pseudoaléatoire de permutations. Nous allons démontrer la première propriété.
L
R
@
@
@
fn
1
@
@
@ k
+
L1 @
R1
@
@
fn
2
@
@
@ k
+
L2 @
R2
@
@
fn
3
@
@
@ k
+
L3
R3
Soit Fn une famille de fonctions pseudo-aléatoires de {0, 1}n vers {0, 1}n . Pour toute application
f : {0, 1}n 7−→ {0, 1}n , on note Feistelf la bijection :
Feistelf :
{0, 1}2n
(l, r)
−→
7−→
{0, 1}n r, l ⊕ f (r)
On note :
Feistelf1 f2 = Feistelf2 ◦ Feistelf1
le schéma avec deux itérations utilisant dans cet ordre les fonctions f1 et f2 sur {0, 1}n .
Cela se généralise en posant pour tout entier ` :
Feistelf1 ···f` = Feistelf` ◦ Feistelf1 ···f`−1 .
Si les fonctions fi sont choisies dans la famille pseudo-aléatoire Fn , cela définit une famille de
bijections. Pour tout entier `, la famille des fonctions de Feistel à ` tours, construite à partir de
la famille Fn est notée Feistel`Fn :
Feistel`Fn = Feistelf1 ···f` | f1 , · · · , f` ∈ Fn .
Théorème VI.2 [Luby – Rackoff, ]
La famille Feistel3Fn est une famille de permutations pseudo-aléatoires.
Preuve. Notons Rn la famille de toutes les bijections sur {0, 1}n . Il faut montrer que les familles
Feistel3Fn et R2n sont indistinguable, c’est-à-dire que leur distance calculatoire est négligeable.
La première étape est de montrer que la famille Feistel3Fn est indistinguable de la famille des
schémas de Feistel à trois tours où les fonctions de tour sont des fonctions aléatoires. En d’autres
§ VI.2
Construction à partir d’une famille de FPA
termes, si on note Hn la famille des fonctions aléatoires de {0, 1}n vers {0, 1}n , il s’agit de montrer
que les familles Feistel3Fn et Feistel3Hn sont indistinguables.
Cela se montre aisément avec la technique hybride. En remplaçant successivement une fonction
de tour pseudo-aléatoire par une fonction aléatoire, on peut observer que distinguer ces deux cas
revient à distinguer un élément de Fn d’un élément de Hn , d’où :
∆ Feistel3Fn , Feistel3Hn = 3∆ Fn , Hn
La famille Fn étant supposée pseudo-aléatoire, le membre de droite ci-dessus est négligeable.
Montrons maintenant que la famille Feistel3Hn est indistinguable de la famille R2n . Notons pour
simplifier Fn3 = Feistel3Hn . On suppose que les trois fonction f1 , f2 et f3 du schéma de Feistel
sont des fonctions aléatoires.
Si on montre que la valeur n’est pas distinguable d’un aléa, on aura montré qu’un algorithme ne
peut pas discerner un schéma de Feistel à trois tours avec des fonctions de tour aléatoire d’une
permutation aléatoire.
Soit R1i la valeur R1 interne au schéma de Feistel au cours de la ie requête. On note Em
l’énènement :
Em :
hh
Il existe deux requêtes différentes i et j, avec i ≤ j telles que R1i = R1j et R2i = R2j ii.
Évaluons la probabilité de cet évènement.
Prob[Em ] = Prob[Em−1 ] + Prob[Em | ¬Em−1 ] × Prob[Em−1 ]
{z
}
|
≤1
≤ Prob[Em−1 ] + Prob[Em | ¬Em−1 ]
Si l’évènement Em a lieu sans que l’évènement Em−1 a lieu, c’est que l’indice j vaut m. On a donc
R1i = R1m pour un indice i compris entre 1 et m − 1 ou bien on a R2i = E2m pour un indice i compris
entre 1 et m − 1. Il en résulte :
(5)
Prob[Em | ¬Em−1 ] ≤
m
X
Prob[R1i = R1m ] +
i=1
m
X
Prob[R2i = R2m ]
i=1
On est amené à évaluer Prob[R1i = R1m ].
Examinons ce qui se passe au tour précédent au cours des ie et me requêtes.
Si R0i 6= R0m , comme la fonction f1 est aléatoire, les valeurs de R1 au tour i et m sont aléatoires
avec probabilité uniforme. Elles sont égales avec une probabilité égale à 1/2n .
Si R0i = R0m , alors, comme les requêtes sont distinctes, on a nécessairement Li0 6= Lm
0 donc
R1i 6= R1m .
Pour tout indice i de requête inférieur à m, on a Prob[R1i = R1m ] = 1/2n . Donc :
m
X
i=1
Prob[R1i = R1m ] ≤
m−1
.
2n
On a un résultat identique pour le deuxième terme de (5) en remplaçant l’indice 1 par l’indice 2,
donc :
m−1
Prob[Em | ¬Em−1 ] ≤ n−1 ,
2
et
m−1
Prob[Em ] ≤ Prob[Em−1 ] + n−1 .
2
35
36
Permutations pseudo-aléatoires
En appliquant récursivement cette inégalité pour Prob[Em−1 ], Prob[Em−2 ], . . ., on obtient :
Prob[Em ] ≤
n(n − 1)
m2
(m − 1) + (m − 2) + · · · + 1
=
≤
.
2n−1
2 × 2n−1
2n
Cette quantité est négligeable, car m est borné par un polynôme en n.
Évaluons maintenant l’avantage d’un adversaire A supposer distinguer entre Fn3 et R2n .
AdvA = ProbF ∈Fn3 AF = 1 − ProbF ∈R2n AF = 1 Dans le premier terme, l’algorithme A reçoit une fonction de Fn3 . Pour évaluer la probabilité de
succès de A dans ce cas, conditionnons par l’évènement Em :
ProbF ∈Fn3 AF = 1 = Prob Em × ProbF ∈Fn3 AF = 1 | Em +
| {z } |
{z
}
≤1
m2
≤ n
2
Prob ¬Em × ProbF ∈Fn3 AF = 1 | ¬Em
|
{z
}
≤1
Finalement, on a l’inégalité :
AdvA ≤
F
F
m2 3 A
+
=
1
|
¬E
−
Prob
A
=
1
Prob
m
F
∈R
F
∈F
2n
n
2n
L’évènement Em signifie que pour toutes requêtes i et j, on a R2i 6= R2j et R1i 6= R1j . Par conséquent,
comme f3 est une fonction aléatoire, les valeurs R3i sont indépendantes et uniformément distribuées.
De même, par passage dans la fonction aléatoire f2 , les R2i sont indépendants et uniformément
distribués sur {0; 1}n .
Le seul écart à une sortie vraiment aléatoire des couples (Li3 , R3i ) dans le cas d’un schéma de
Feistel, est qu’on a toujours Li3 6= Lj3 puisque L3 = R2 . L’écart à une distribution uniforme est
donné par la probabilité de collision de m valeurs aléatoires parmi 2n possible, qui, par le paradoxe
des anniversaire, est approximativement m2 /2n .
m2
Finalement, pour tout adversaire A, on a AdvA ≤ 2 × n . Par passage au maximum, la distance
2
m2
3
calculatoire ∆ = Fn , Rn est inférieure à 2 × n qui est négligeable.
2
§ VI.3
Exercices
1. Considérons la famille des schémas de Feistel à trois tours dans laquelle la fonction centrale
f2 est définie par f2 : x 7−→ x ⊕ i(x), oà la fonction i est involutive, c’est-à-dire vérifie i ◦ i(x) = x
pour tout x ∈ {0, 1}n .
a) Montrer que f2 ◦ i = f2 .
b) En déduire que qu’alors, la famille de bijections obtenue n’est plus pseudo-aléatoire.
Indication : chercher deux requêtes différentes qui donneront la même partie gauche L3 = L03 avec
ce shéma.
2. Soit Fn = fk k∈{0,1}n une famille pseudo-aléatoire de bijection de {0, 1}n . Pour tout paramètre
k, on définit la fonction gk par :
gk :
La famille Gn = gk
k∈{0,1}n
{0, 1}n+1
(x, b)
−→
7−→
{0, 1}n+1 fk (x), b ⊕ x0
est-elle une famille de bijections à est-elle pseudo-aléatoire ?
§ VII.1
Schéma de chiffrement
VII – CHIFFREMENT
§ VII.1
Schéma de chiffrement
Un schéma de chiffrement consiste en une famille de fonctions de chiffrement et de déchiffrement,
selon la valeur d’un paramètre de sécurité n qui évalue sa résistance calculatoire.
Définition VII.1 [schéma de chiffrement]
Pour un paramètre de sécurité donné, un schéma de chiffrement est la donnée d’un domaine
Dn des messages, d’un domaine Rn des cryptogrammes et de trois algorithmes efficaces :
1. Un algorithme G(1n ) de génération de clé qui produit une paire de clé (e, d). Une clé e
pour le chiffrement, et une clé d pour le déchiffrement.
2. Un algorithme E de chiffrement, éventuellement non déterministe qui, pour chaque
message m dans Dn produit un cryptogramme c dans Rn en fonction de la clé de
chiffrement e :
c = E(e, m).
3. Un algorithme D, nécessairement déterministe, qui pour un cryptogramme qui est le
résultat d’un chiffrement, produit le message clair correspondant, à l’aide de la clé de
déchiffrement, c’est-à-dire pour tout m ∈ Dn , on a :
D d, E(e, m) = m.
On distingue deux cas :
– Si e = d, c’est-à-dire si la clé de chiffrement est la même que la clé de chiffrement, le schéma de
chiffrement est dit symétrique.
– Dans le cas contraire, c’est-à-dire si e 6= d, le schéma de chiffrement est dit asymétrique.
q
La clé de déchiffrement doit impérativement rester secrète. Si e 6= d, et si on ne sait pas
qqAA
calculer la clé de déchiffrement d à partir de la clé de chiffrement e, alors il n’y a aucune
raison de cacher e. Elle peut être publiée. On a alors affaire à un schéma de chiffrement à clé
publique.
r
Si l’algorithme de chiffrement n’est pas déterministe, alors un même message peut avoir
plusieurs cryptogrammes. Mais pour chacun de ces cryptogrammes, l’algorithme de déchiffrement retourne toujours le même message d’origine.
C’est par exemple le cas du système de chiffrement El Gamal.
§ VII.2
Notions de sécurité
La notion de fonction à sens unique est insuffisante pour une fonction de chiffrement satisfaisante.
On a vu que si f est une fonction à sens unique sur {0, 1}n , alors la fonction :
g :
{0, 1}n −→
(m1 , m2 ) 7−→
{0, 1}n f (m1 ), m2
est toujours une fonction à sens unique, puisque pour inverser g, il est nécessaire de pouvoir inverser
f . Par contre il s’agit d’une piteuse fonction de chiffrement, car la moitié des symboles binaires du
clair ne sont pas chiffrés.
Ce qu’on attend d’une fonction de chiffrement est qu’elle protège tous les bits du message clair.
On peut imaginer par exemple qu’un long message militaire contienne une information cruciale,
comme la décision ou non d’attaquer l’ennemi.
37
38
Chiffrement
Il existe deux notions de sécurité : la sécurité sémantique et l’indistinguabilité. La première décrit
bien ce que les acteurs d’un système cryptographique attendent comme service de confidentialité.
La seconde est commode pour établir des preuves de sécurité. Nous montrons dans ce paragraphe
que ces deux notions sont finalement équivalentes.
VII.2.1.
Sécurité sémantique
La sécurité sémantique est la version calculatoire de la sécurité parfaite. Elle énonce que le
cryptogramme n’apporte aucune information que l’adversaire ne puisse calculer sans lui. Tout
ce qui est calculable sur le clair peut se calculer sans le cryptogramme.
Si l’adversaire sait calculer le moindre bit du message clair à partir du cryptogramme alors la
sécurité sémantique n’est pas atteinte.
Un adversaire d’un schéma de chiffrement contre la sécurité sémantique est un algorithme A, à qui
on fournit le cryptogramme d’un message x, et qui doit retourner la valeur f (x) d’une information
arbitraire sur x.
Définition VII.2 [Sécurité sémantique]
Un schéma de chiffrement C = (D, Rn , G, E, D) est dit sémantiquement sûr, noté SEM–sûr,
si pour tout adversaire A en temps polynomial, pour toute fonction f sur sur Dn et toute
distribution de probabilité Xn , son avantage :
h
i
h
i
A
0
(6) Adv = Prob e←G(1n ) A E(e, x) = f (x) − Prob e←G(1n ) A E(e, x ) = f (x) x∈X Dn
n
x,x0 ∈X
n
Dn
est une fonction négligeable.
Un adversaire contre un schéma de chiffrement pour la sécurité sémantique est un algorithme qui
doit retrouver une information f (x) sur le clair x à partir du cryptogramme E(e, x). L’expression
de l’avantage donné par la relation (6) exprime qu’il n’y a pas de différence de probabilité de succès
notable de l’algorithme A pour trouver l’information f (x) qu’on lui fournisse le chiffré du message
x (premier terme) ou le chiffré d’un autre message aléatoire x0 (second terme).
r
La probabilité exprimée dans cette définition est pour une clé de chiffrement aléatoire e fournie
par l’algorithme de génération de clé, et pour des messages clairs aléatoires.
L’adversaire connaı̂t la distribution de probabilités et la fonction f , mais ignore bien sûr la clé de
déchiffrement ainsi que le message clair correspondant au cryptogramme qu’il reçoit en entrée.
q
qqAA
La sécurité sémantique est atteinte si l’avantage de tout adversaire est négligeable, pour toute
distribution de probabilité sur les clairs. En particuier si deux messages clairs seulement sont
également probales.
VII.2.2.
Indistinguabilité
Un chiffrement a la propriété d’indistinguabilité si un adversaire est incapable de dire si le cryptogramme qu’on lui présente provient de l’un ou de l’autre message, sachant que le cryptogramme
est le chiffré d’un de ces deux messages.
Un adversaire d’un schéma de chiffrement contre la propriété d’indistinguabilité est un algorithme
A à qui on fournit le cryptogramme d’un message mi choisi aléatoirement dans un ensemble de
deux messages distincts {m0 , m1 } et qui doit rendre l’indice i ∈ {0, 1}.
§ VII.2
Notions de sécurité
Définition VII.3 [indistinguabilité]
On dit qu’un schéma de chiffrement C = (Dn , Rn , G, E, D) a la propriété d’indistinguabilité
si pour tout adversaire A en temps polynomial et pour tout couple (m0 , m1 ) de messages de
Dn , on a
AdvA = Probe←G(1n ) A E(e, m0 ) = 1 − Probe←G(1n ) A E(e, m0 ) = 1 est une fontion négligeable.
r
Pour que cette définition ait un sens, il faut que les messages aient la même taille, ou que la
taille du cryptogramme ne donne pas d’information sur la nature du message qui a été chiffré.
r
La propriété d’indistinguabilité énonce que tout adversaire échoue pour tout couple (m0 , m1 )
de message. On peut supposer sans restriction que l’adversaire peut choisir les deux messages
m0 et m1 qui lui donneront les meilleures chances de succès.
Exemple. Soit E la fonction de chiffrement d’un schéma de chiffrement C. Soit C 0 le schéma de
chiffrement presque identique à C, mais dans lequel la fonction de chiffrement a été remplacé par
la fonction E 0 donnée par :
(
E(e, m) si m 6= 1n , 0n
0
E (e, m) = 0n
si m = 0n
n
1
si m = 1n
Le schéma de chiffrement C 0 n’est pas sémantiquement sûr, car avec la distribution de probabilité
donné par :
n
n
n
Prob[m] = 1/2 si m = 0 ou 1 ,
0
sinon
il est très facile de construire un adversaire contre la sécurité sémantique de C 0 qui donne toujours
la bonne réponse pour tout fonction d’information f .
Le shéma de chiffrement C 0 n’a pas non plus la propriété d’indistinguabilité, car il est immédiat
également de construire un adversaire qui sait distinguer entre le chiffré de 0n et celui de 1n .
VII.2.3.
Équivalence des deux notions
La sécurité sémantique correspond à ce qui est intuitivement requis pour avérer la sécurité d’un
schéma de chiffrement. L’indistingabilité est une notion plus commode à manipuler. Mais les deux
notions sont équivalentes.
Théorème VII.4 [équivalence de la sécurité sémantique et de l’indistinguabilité]
Un shéma de chiffrement est sémantiquement sûr si et seulement si il a la propriété
d’indistinguabilité.
Preuve. Montrons tout d’abord l’implication SEM =⇒ IND, ou , ce qui est équivalent, la
contraposée ¬IND =⇒ ¬SEM.
On suppose qu’il existe un algorithme efficace A et deux messages m0 et m1 tel que A sait distinguer
un chiffré de m0 d’un chiffrer de m1 avec un avantage ε(n) non négligeable.
ε(n) = AdvA = Probe←G(1n ) A E(e, m0 ) = 1 − Probe←G(1n ) A E(e, m0 ) = 1 L’algorithme A est un adversaire contre la sécurité sémantique avec la distribution sur les messages
clairs donnée par :
n
Prob(m) = 1/2 si m = m0 ou m1
0
sinon
39
40
Chiffrement
et la fonction d’information :
f (m) =
1
0
si m = m0
si m = m1
Montrons que l’avantage de A pour la sécurité sémantique vaut ε(n)/2. Pour cela, évaluons la
probabilité que A donne f (x) selon que x vaut m0 ou m1 . L’avantage de A pour l’indistinguabitité
est :
AdvA = Prob A E(e, x) = f (x) − Prob A E(e, x) = f (x0 ) |
{z
} |
{z
}
A
B
Dans le second terme B, comme x et x0 sont indépendants, chacun avec probabilité
1
1
, on a B = .
2
2
Intéressons nous maintenant au premier terme A :
A = Prob A E(e, x) = f (x) | x = m0 × Prob[x = m0 ] +
{z
}
|
{z
} |
= 1/2
= Prob A E(e, m0 ) = 0
Prob A E(e, x) = f (x) | x = m1 × Prob[x = m1 ]
{z
}
|
{z
} |
=
1/2
= Prob A E(e, m1 ) = 1
Notons que Prob A E(e, m0 ) = 1 = 1 − Prob A E(e, m0 ) = 0 . Il en résulte que :
1
1 − Prob A E(e, m0 ) = 1 + Prob A E(e, m1 ) = 1
2
1
= 1 − ε(n) .
2
A=
Finalement :
1
AdvA = 1 − ε(n) −
2
1 ε(n)
=
.
2
2
Montrons maintenant la réciproque IND =⇒ SEM, ou , ce qui est équivalent, la contraposée
¬SEM =⇒ ¬IND.
On suppose qu’il existe une distribution de probabilité Xn sur les messages clairs, et un algorithme
A, efficace contre la sécurité sémantique pour la fonction f dont l’avantage ε(n) est une fonction
non négligeable.
Construisons un algorithme B contre l’indistinguabilité :
– On choisit deux messages m0 et m1 de probabilité non nulle.
– L’entrée c de l’algorithme B est le chiffré d’un de ces deux messages, avec probabilité 1/2.
– L’algorithme B doit décider si c provient du chiffrement de m0 ou de m1 . Pour cela, il soumet
c à l’algorithme A. Soit α la réponse de A qui est supposée être la valeur f (m) avec un certain
avantage. On a trois cas :
1. Si f (m0 ) = α alors B renvoie 0 ;
2. Si f (m1 ) = α alors B renvoie 1 ;
3. Si ni f (m0 ) ni f (m1 ) ne sont égaux à α, alors cela signifie un échec de l’algorithme A, et B
répond aléatoirement 0 ou 1 avec une probabilité uniforme.
Calculons l’avantage de cet algorithme contre
l’indistinguabilité.
Pour cela, posons c1 = R(e, m1 ) le
chiffré du message m1 et estimons Prob B(c1 ) = 1 suivant les trois évènements qui correspondent
§ VII.3
Modèles d’attaques
aux trois cas ci-dessus. Par définition de l’algorithme B, on a :
Prob B(c1 ) = 1 = Prob B(c1 ) = 1 | f (m1 ) = α × Prob f (m1 ) = α +
|
{z
}
=1
Prob B(c1 ) = 1 | f (m0 ) = α × Prob f (m0 ) = α +
|
{z
}
=0
Prob B(c1 ) = 1 | f (m1 ), f (m0 ) 6= α × Prob f (m1 ), f (m0 ) 6= α
|
{z
}
= 1/2
1
= Prob f (m1 ) = α + Prob f (m1 ), f (m0 ) 6= α
2
Par un calcul en tout point similaire, on a :
1
Prob B(c0 ) = 1 = Prob f (m0 ) = α + Prob f (m1 ), f (m0 ) 6= α
2
Par différence et après simplification de la différence des termes égaux, ceci montre que :
AdvB = Prob B(c0 ) = 1 − Prob B(c1 ) = 1 = Prob f (m0 ) = α − Prob f (m1 ) = α = AdvA
L’avantage de l’algorithme B contre l’indistinguabilité est le même que l’avantage de l’algorithme
A contre la sécurité sémantique.
§ VII.3
Modèles d’attaques
Pour résoudre le problème qui lui est assigné, contre la sécurité sémantique ou contre l’indistinguabilité, un adversaire contre un schéma de chiffrement peut disposer de certaines informations, ce qui
classifie les attaques en deux catégories : les attaques à clair choisi et les attaques à cryptogramme
choisi.
VII.3.1.
Attaques à clair choisi
Au cours de son exécution, l’algorithme contre un shéma de chiffrement peut accéder à un oracle de
chiffrement qui lui répondra le chiffré des requêtes qui lui sont soumises. On parle alors d’attaque
à clair choisi, noté CPA (Chosen Plaintext Attack).
On notera par exemple CPA-IND la propriété d’indistinguabilité d’un schéma de chiffrement pour
tout adversaire qui dispose d’un oracle de chiffrement.
r
Noter que dans un chiffrement à clé publique, la clé de chiffrement étant publique, l’adversaire
peut toujours chiffrer les messages de son choix. La notion d’attaque à clair choisi n’est
pertinente que pour le chiffrement symétrique, où l’adversaire, ne disposant pas de la clé de
chiffrement, doit avoir recours à un oracle pour obtenir des couples (clair, cryptogramme) de
son choix.
VII.3.2.
Attaques à cryptogramme choisi
Dans certaines situations concrètes, le modèle d’attaque à clair choisi peut s’avérer insuffisant,
et on peut exiger un niveau supplémentaire de sécurité. Imaginons par exemple qu’un adversaire
concret emprunte le dispositif de déchiffrement pendant un certain temps, ou bien puisse accéder
temporairement au local où le déchiffrement se réalise.
Il faut alors considérer un modèle où l’adversaire peut accéder à un oracle de chiffrement. Il s’agit
d’attaque à cryptogramme choisi, notée CCA (Chosen Ciphertext Attack).
r
Pour que cette attaque ait un sens, il faut bien sûr interdire les requêtes qui consiste à
demander le déchiffrement du défi qui est soumis à l’adversaire.
On notera par exemple CCA-SEM la sécurité sémantique d’un schéma de chiffrement pour tout
adversaire qui dispose d’un oracle de déchiffrement.
41
42
Chiffrement
§ VII.4
Construction d’un schéma de chiffrement IND–CPA
Dans cette section, on montre que le schéma de chiffrement symétrique construit à partir d’une
famille de fonctions pseudo-aléatoires a la propriété d’indistinguabilité dans une attaque à clairs
choisis.
Rappelons tout d’abord la construction. On suppose qu’on a une famille Fn de fonctions pseudoaléatoires Fn = (fk )k∈{0,1}n , où les fk sont des fonctions {0, 1}n −→ {0, 1}n .
Le schéma de chiffrement est défini par :
– L’algorithme G(1n ) de génération de clé choisit aléatoirement une clé k dans {0, 1}n .
– L’algorithme Ek (r, m) de chiffrement est un algorithme probabiliste qui, à un aléa r dans {0, 1}n
et un message m dans {0, 1}n associe le couple (r, fk (r) ⊕ m). Dans le cryptogramme, le second
terme fk (r) ⊕ m contient l’information du message, masqué par une valeur pseudo-aléatoire
fk (m). La première composante r permet au détenteur de la clé secrète k de retrouver le masque.
– L’algorithme de déchiffrement Dk (r, c) retrouve le message m par le calcul m = c ⊕ fk (r).
r
La valeur fk (r) est une clé de session utilisée uniquement au cours du chiffrement de ce
message. On peut potentiellement utiliser la même clé k pour produire un nombre exponentiel
de clés de session.
On considère ici que les messages ont une taille fixe, de n symboles binaires.
Montrons dans la suite de cette section que ce schéma de chiffrement est IND-CPA, c’est-a-dire
qu’il a la propriété d’indistinguabilité au cours d’une attaque à clairs choisis.
La première étape de la preuve est de montrer que si on remplace dans le schéma de chiffrement
la fonction pseudo-aléatoire fh par une fonction entièrement aléatoire h, alors l’avantage d’un
adversaire ne dépasse pas l’avantage d’un algorithme qui sait discerner une fonction pseudoaléatoire d’une fonction aléatoire.
L’interaction entre l’adversaire A du schéma de chiffrement et l’environnement lors d’une attaque
est modélisée par un jeu.
Le jeu, noté jeu 0, correspond à la situation réelle. L’adversaire A joue contre un maitre du jeu qui
correspond à l’environnement E. Les étapes sont les suivantes :
Une clé k est choisie aléatoirement k = G(1n ).
Au cours du jeu, l’adversaire A accède à un oracle de chiffrement fk . L’adversaire soumet à cet
oracle un message m, et l’oracle lui renvoie (r, c) = Ek (r, m) pour une valeur r, aléatoire dans
{0, 1}n .
L’adversaire A choisit deux messages m0 et m1 .
L’environnement E choisit un bit aléatoire b dans {0, 1}, puis lance à l’adversaire A le défi de
retrouver b en lui indiquant le cryptogramme du message mb qui vaut (α, fk (α) ⊕ mb ).
Ce cryptogramme est un chiffré de m0 si le bit b vaut 0, et est un chiffré de m1 si le bit b vaut 1.
L’objectif de l’adversaire A est de savoir si ce cryptogramme est le chiffré de m0 ou de m1 .
Après un certain nombre d’appels à l’oracle, l’algorithme A donne sa réponse. Soit b0 la réponse
de A.
L’algorithme A a gagné si b = b0 et il a perdu dans le cas contraire.
Notons E0 l’évènement hh A a gagné dans le jeu 0 ii. Définissons l’avantage de A dans ce jeu comme
étant la valeur AdvA
0 = 2 Prob(E0 ) − 1. Il est nul si A a répond au hasard, vaut 1 si A gagne
toujours et −1 s’il perd toujours.
Considérons aussi le jeu noté jeu 1, similaire au jeu 0, mais au lieu d’utiliser une fonction pseudoaléatoire fk pour le chiffrement, l’environnement utilise une fonction h parfaitement aléatoire
{0, 1}n → {0, 1}n .
On note E1 l’évènement hh A gagne au cours du jeu 1 ii. L’avantage de A dans ce jeu est
AdvA
1 = 2 Prob(E1 ) − 1.
Montrons le lemme suivant, qui énonce que la différence des probabilités de gain de A dans le jeu 0
et dans le jeu 1 ne peut pas dépasser l’avantage d’un adversaire contre la famille pseudo-aléatoire.
§ VII.4
Construction d’un schéma de chiffrement IND–CPA
Lemme VII.5
Soit εfpa l’avantage maximal d’un adversaire contre la famille de fonctions pseudo aléatoires
(fk )k∈{0,1}n . Alors :
Prob(E0 ) − Prob(E1 ) ≤ εfpa .
Preuve. Construisons un distingueur D, qui utilise l’adversaire A, et qui sait discerner un élément
fk de la
famille pseudo-aléatoire
d’une fonction parfaitement aléatoire avec un avantage au moins
égal à Prob(E0 ) − Prob(E1 ).
Le distingueur D accède à un oracle O qui est soit un élément fk de la famille de fonctions pseudoaléatoires, soit une fonction h parfaitement aléatoire.
Ce distingueur, pour établir sa réponse, va utiliser l’adversaire A contre notre schéma de chiffrement. Pour cela, il va simuler l’environnement, c’est-à-dire fournir à A tout ce dont il a besoin pour
décider. Il va utiliser l’oracle 0 pour générer les clés de session.
Lorsque A demande à chiffrer un message m, le distingueur D choisit un élément r aléatoire de
{0, 1}n et renvoie à A la valeur (r, O(r) ⊕ m).
Lorsque A fournit les messages m0 et m1 pour son défi, le distingueur D choisit un bit aléatoire
b ∈ {0, 1}, une valeur aléatoire α ∈ {0, 1}n et lance le défi à A de trouver b à partir du cryptogramme
(α, O(α) ⊕ mn ).
L’algorithme A donne une réponse b0 .
L’heuristique est de dire que, si A a donné la bonne réponse, c’est que l’oracle réalise une fonction
pseudo-aléatoire, alors que s’il a donné la mauvaise réponse, c’est que l’oracle réalise une fonction
parfaitement aléatoire. Aussi, si b = b0 , alors D renvoie A pour signifier que l’oracle réalise une
fonction pseudo-aléatoire, et si b 6= b0 , il renvoie 0 pour signifier que l’oracle réaliser une fonction
aléatoire.
Il reste à évaluer l’avantage de D.
Si l’oracle réalise une fonction pseudo-aléatoire, tout ce que D simule correspond au jeu 0, alors
que si l’oracle réalise une fonction aléatoire, tout ce que D simule correspond au jeu 1.
Il en résulte que l’avantage de D est le même que l’avantage de A, car :
fk n
h n
εD
fpa = Prob D (1 ) = 1 − Prob D (1 ) = 1 = Prob b = b0 | O = fk − Prob b = b0 | O = h = Prob(E0 ) − Prob(E1 )
Montrons maintenant que le lemme VII.5 suffit à prouver la propriété d’indistinguabilité du schéma
de chiffrement dans une attaque à clairs choisis.
Évaluons la probabilité Prob(E1 ) de gain au cours du jeu 1.
Notons D l’évènement hh la valeur α dans le cryptogramme que doit décider A est différente des
valeurs aléa ri ayant défini les clés de session au cours des q requêtes ii. Dans ce cas, la valeur des
h(α) est parfaitement aléatoire, et la probabilité de gain de A ne peut pas dépasser 1/2 :
Prob(E1 | D) ≤
1
.
2
q
Par ailleurs, avec une probabilité n , la valeur de α du cryptogramme tombe dans l’une des valeurs
2
ri au cours des s requêtes. Donc :
43
44
Chiffrement
Prob(E1 ) = Prob(E1 | D) × Prob(D) + Prob(E1 | ¬D) × Prob(¬D)
|
{z
} | {z } |
{z
} | {z }
q
1
≤1
≤1
= n
≤
2
2
q
1
≤ + n
2 2
La preuve de la propriété IND-CPA vient ensuite de :
1 1 Prob(E0 ) − = Prob(E0 ) − Prob(E1 ) + Prob(E1 ) − 2
2
1 ≤ Prob(E0 ) − Prob(E1 ) + Prob(E1 ) − ,
2}
|
{z
} |
{z
≤ εfpa
q
≤ n
2
qui est une fonction négligeable en n.
q
Il est crucial pour la preuve de ce résultat, que l’aléa choisi pour définir la clé de session
qqAA
soit parfaitement aléatoire. Si cela n’est pas le cas, la preuve de l’indistinguabilité n’est pas
assurée.
§ VII.5
Chiffrement de messages de tailles variables
On suppose que l’on dispose d’une famille Pn = (pk )k∈{0,1}n de permutations pseudo-aléatoires
{0, 1}n −→ {0, 1}n .
La question est : hh Comment peut-on chiffrer des messages constitués de blocs de n symboles
binaires ? ii.
On suppose pour simplifier que les messages ont une taille qui est multiple de n. Dans le cas
contraire, on peut toujours compléter avec des zéros pour atteindre cette taille.
Mode dictionnaire, ou mode ECB (Electronic Code Book).
Dans le mode ECB, le message est partagé en blocs de n symboles binaires. Chaque bloc est chiffré
de manière indépendante.
m1
...
m`
?
?
?
pk
pk
pk
?
c1
q
qqAA
m2
?
c2
...
?
c`
Le mode ECB n’est pas sûr ! Il n’a pas la propriété d’indistinguabilité lors d’une attaque à
clairs choisis. Voir l’exercice 3.
Mode chainé, ou mode CBC (Cipher Block Chaining).
Dans le mode CBC, le chiffrement des blocs ne sont plus indépendants les uns des autres. Le
chiffrement d’un bloc dépend du cryptogramme du bloc précédent.
Pour cela, il nécessite un vecteur initial (V I).
§ VII.6
Malléabilité
VI
?
c0
m1
m2
?
- +i
?
- +i
...
m`
?
- +i
- ...
?
?
?
pk
pk
pk
?
c1
...
?
c2
...
?
c`
Les données chiffrées sont rendues aléatoires par l’addition du bloc de cryptogramme précédent.
Le mode CBC est envisageable avec deux possibilités pour le vecteur initial :
– Le vecteur initial peut être un compteur incrémenté à chaque message.
– Le vecteur initial peut être initialisé avec de l’aléa à chaque message.
q
Lorsque l’adversaire peut prévoir la valeur du vecteur initial, le mode CBC n’est pas sûr. Voir
qqAA
l’exercice 4. En conséquence, il ne peut pas être un compteur.
Théorème VII.6
Le mode CBC avec vecteur initial aléatoire est IND-CPA.
Preuve. (plan) La méthode de preuve est la même que précédemment. On définit deux jeux pour
l’adversaire. L’un, le jeu 0, avec une permutation pseudo aléatoire, l’autre, le jeu 1, avec une
permutation parfaitement aléatoire. On montre en deux étapes que les avantages d’un adversaire
au cours des jeux 0 et 1 ne diffèrent pas plus que l’avantage d’un distingueur entre une permutations
pseudo-aléatoire et une permutation parfaitement aléatoire.
Ensuite, observer les valeurs de Ti à l’entrée de la permutation à chaque requête de l’adversaire
et distinguer le cas où toutes les valeurs de Ti pour le défi lancé à l’adversaire sont différentes des
valeurs atteintes au cours de ses requêtes.
§ VII.6
Malléabilité
Le schéma de chiffrement défini dans le paragraphe VII.4 est sûr contre une attaque à clair
choisi, c’est- ?-dire lors s’une attaque au cours de laquelle l’adversaire peut accéder ? un oracle
de chiffrement qui lui renvoie les cryptogrammes pour toute requête de message clair qui lui est
faite.
Supposons maintenant que adversaire peut accéder ? un oracle de déchiffrement. On parle alors
d’attaque ? cryptogramme choisi.
r
Bien sûr, pour que cette attaque ait un sens, il faut bien sûr interdire une requête qui
consisterait ? déchiffrer un cryptogramme sur lequel l’adversaire doit se prononcer. Par
exemple, un adversaire contre l’indistinguabilité qui doit répondre si le cryptogramme c qui lui
est soumis est celui d’un message m0 ou m1 , ne doit pas demander ? l’oracle le déchiffrement du
cryptogramme c.
Le schéma de chiffrement du paragraphe VII.4 n’a pas la propriété d’indistinguabilité face ? une
attaque ? cryptogramme choisi.
Si l’adversaire reçoit le cryptogramme (r, c), où c = r ⊕ fk (mb ), il peut demander le déchiffrement
d’un cryptogramme (r, c∗ ), avec c∗ 6= c. Il reçoit alors le message clair qui est par définition :
m∗ = fk (r) ⊕ c∗ .
45
46
Chiffrement
Il peut en déduire :
fk (r) = m∗ ⊕ c,
et donc :
mb = (m∗ ⊕ c) ⊕ c.
Connaissant mb , il pourra répondre avec certitude s’il s’agit de m0 ou de m1 .
r
Il est sans espoir d’obtenir la moindre information en posant des requêtes ? l’oracle de
déchiffrement avec une valeur quelconque de r∗ , car, la famille de fonctions (fk ) étant pseudoaléatoire, aucune information ne sera obtenue quant au masque fk (r∗ ).
Le défaut de ce type de chiffrement est qu’il est malléable, c’est- ?-dire il est possible de manipuler
le cryptogramme pour obtenir des relations avec d’autres cryptogrammes. En d’autres termes,
même sans connaitre la clé, il est possible de construire des cryptogrammes dont les clairs sont en
relations.
Dans le cas présent, si (r, c) est le chiffré de m, alors (r, c ⊕ u) est le chiffré de ⊕x.
Un chiffrement malléable j’est jamais sûr contre une attaque ? cryptogramme choisi.
Pour construire un schéma de chiffrement résistant contre ce type d’attaque, il ne doit pas être
malléable.
Si l’adversaire change, ne serait-ce qu’un seul bit du cryptogramme, alors les messages clairs
correspondants ne doivent pas avoir de relation.
Une autre possibilité est de rendre impossible en pratique la modification du cryptogramme, c’est?-dire que tout cryptogramme modifié ne soit plus cohérent, et donc non déchiffrable.
§ VII.7
Codes d’authentification de message
VII.7.1.
Motivation
Afin de rendre un schéma de chiffrement résistant aux attaques ? cryptogramme choisi, l’idée est
d’ajouter une empreinte τ au cryptogramme telle que l’adversaire ne puiossa pas construire un
cryptogramme différent avec une empreinte τ 0 différente qui donne un chiffré correct.
De telles empreintes, dépendant d’une clé s’appellent des Codes d’Authentification de Message
(MAC, Message Authentication Code).
Un code d’authentification de message est une primitive cryptographique de signature symétrique.
La clé pour générer l’empreinte est la même que la clé pour la vérifier. Ceux qui peuvent signer
sont les mêmes que ceux qui peuvent vérifier.
Un MAC ne satisfait donc pas la propriété de non répudiation.
Définition VII.7 [Code d’Authentification de Message]
Un code d’authentification de message (MAC) se compose de trois familles d’algorithmes :
1. Un algorithme efficace de génération de clé G(1n ) qui renvoie une clé aléatoire.
2. Un algorithme déterministe efficace qui génère d’empreinte d’un message ? partir d’une
clé k : M ACk (m) = τ .
3. Un algorithme déterministe de vérification Verif k (m, τ ) qui renvoie 1 ou 0 selon que
l’empreinte τ du message m est conrrecte ou non.
r
On peut toujours supposer que l’algorithme de vérification est le suivant, qui n’invoque que
la fonction M ACk :
1. Calculer l’empreinte τ 0 = M ACk (m) ;
2. Vérifier si τ 0 = τ . Si c’est le cas, alors renvoyer 1, et sinon, renvoyer 0.
§ VII.7
VII.7.2.
Codes d’authentification de message
Sécurité d’un code d’authentification de message
La sécurité d’un code d’authentification de message se mesure ? la difficulté de forger une empreinte
contre des attaques ? messages choisis.
L’objectif de l’adversaire est de construire un message et une empreinte valide qui passera
l’algorithme de vérification sans disposer de la clé.
Pour cela, il peut interroger un oracle qui lui indiquera des empreintes valides de messages de son
choix, ? l’exception bien sûr du message qu’il signe.
Définition VII.8 [Sécurité d’un MAC]
On dit qu’un MAC est sûr si la probabilité de succès d’un adversaire polynomial A pour
produire un message correctement signé, c’est- ?-dire la fonction en n donnée par :
Prob AM ACk (1n ) = (m, τ ) | Verif k (m, τ ) = 1 ,
est négligeable.
Les messages demandés ? l’oracle doivent être différent de la réponse m de l’algorithme A.
r
Un MAC diffère d’une signature. La procédure de vérification n’est pas publique, mais
réservée ? ceux qui disposent de la clé. Pour cette raison, les signatures produites par un
MAC sont répudiables. Comme la clé est partagée entre le signataire et le vérificateur, il ne sera
pas possible de prouver que c’est bien le prétendu signataire qui a produit la signature, et non pas
un vérificateur malhonnête.
r
Lorsqu’on dit qu’une fonction est un MAC, on sous-entend qu’elle satisfait la propriété de
sécurité donnée dans la définition VII.8.
VII.7.3.
Une première construction
Si fk : {0, 1}n −→ {0, 1}n est une fonction pseudo-aléatoire, alors elle peut être directement
utilisée pour authentifier les messages, simplement en posant M ACk (m) = fk (m).
Théorème VII.9
Une famille de fonctions pseudo-aléatoire définit un code d’authentification de message.
Preuve. Soit A un adversaire contre ce MAC défini par une fonction pseudo-aléatoire. On soumet ?
cet adversaire deux jeux, qui correspondent ? deux situations.
Le jeu 0 est le jeu réel. L’oracle fourni ? l’algorithme A pour qu’il puisse produire son message
correctement signé est une fonction pseudo-aléatoire. Soit E0 l’évènement hh A a réussit ? produire
un message correctement signé ii au cours du jeu 0.
Le jeu 1 est comme le jeu réel, mais l’oracle fourni ? l’algorithme A est une fonction parfaitement
aléatoire. Soit E1 l’évènement hh A a réussit ? produire un message correctement signé ii au cours
du jeu 1.
Montrons dans un premier temps l’inégalité :
(7)
Prob(E0 ) − Prob(E1 ) ≤ εfpa ,
où εfpa est l’avantage maximal d’un adversaire contre la famille pseudo-aléatoire.
Pour cela, considérons un algorithme B, chargé de discerner entre une fonction aléatoire et une
fonction pseudo-aléatoire, qui utilise l’algorithme A pour répondre. Soit f l’entrée de B qui est
soit une fonction fk pseudo-aléatoire, soit une fonction h parfaitement aléatoire.
Il simule l’environnement de A en répondant ? ses requêtes avec de la fonction f . Si l’algorithme A
fournit un message correctement signé, alors l’algorithme B renvoie 0 pour signifier que f est une
47
48
Chiffrement
fonction pseudo-aléatoire, et si l’algorithme A échoue, alors l’algorithme B renvoie 1 pour signifier
que la fonction f est parfaitement aléatoire.
L’heuristique est de dire que si A répond correctement, cela signifie que B simule correctement le
jeu pour lequel il est programmé.
Par construction de l’algorithme B, son avantage contre la famille pseudo-aléatoire est donné par :
h
i
h
i
fk n
h n
εB
=
Prob
Verif
A
(1
)
=
1
−
Prob
Verif
A
(1
)
=
1
k
h
fpa
= Prob(E0 ) − Prob(E1 ).
L’inégalité (7) s’obtient par passage au maximum sur tous les adversaires.
Lorsque la fonction MAC est parfaitement aléatoire, l’algorithme A ne peut produire une empreinte
correcte qu’avec une probabilité égale ? 1/2n . Comme la fonction est aléatoire, les requêtes
n’apportent aucune information. La valeur f (m) est équiprobable. Donc :
Prob(E1 ) =
1
2n
Donc
Prob(E0 ) ≤ Prob(E1 ) + Prob(E0 ) − Prob(E1 )
1
≤ n + εfpa ,
2
qui est une fonction négligeable par hypothèse.
VII.7.4.
Le CBC-MAC
Le code d’authentification de message présenté dans le paragraphe précédent présente peu d’intérêt,
car l’empreinte est aussi longue que le message lui-même. Le CBC-MAC permet de proposer des
empreintes de taille fixe pour des messages bien plus longs.
Le CBC-MAC est représenté par le schéma ci-dessous :
m1
m2
?
- +i
...
m`
?
- +i
- ...
?
?
?
fk
fk
fk
?
τ
...
MACk (m1 , . . . , m` ) = τ
Ce schéma permet de produire des empreintes pour des messages dont la taille est ` × n bits.
r
Contrairement au mode CBC pour le chiffrement, il n’est pas nécessaire que la fonction
utilisée ? chaque tour soit une permutation. Le déchiffrement n’est pas requis. On a seulement
besoin d’une fonction pseudo-aléatoire.
§ VII.7
Codes d’authentification de message
Théorème VII.10 [Sécurité du CBC-MAC]
Le CBC-MAC est sûr.
Preuve. Comme dans la preuve du théorème VII.9, considérons un adversaire A contre ce schéma
CBC-MAC. On soumet cet algorithme ? deux jeux.
Le jeu 0 est le jeu réel, la fonction utilisée ? chaque tour du CBC-MAC est une fonction pseudoaléatoire fk . On note E0 l’évènement hh l’algorithme A a réussit ? produire une signature valide au
cours du jeu 0 ii.
Le jeu 1 est similaire au jeu 1, mais la fonction utilisée ? chaque tour du CBC-MAC est une fonction
parfaitement aléatoire. On note E1 l’évènement hh l’algorithme A a réussit ? produire une signature
valide au cours du jeu 1 ii.
On montre, de la même manière que dans la preuve du théorème VII.9 que :
Prob(E0 ) − Prob(E1 ) ≤ εfpa ,
(8)
où εfpa est l’avantage maximal d’un adversaire contre la famille pseudo-aléatoire. Comme dans la
preuve du théorème VII.9, on construit un adversaire contre la famille pseudo-aléatoire qui utilise
l’adversaire A en simulant son environnement, et dont l’avantage est par construction donnée par
le premier membre de l’inégalité (8).
Évaluons maintenant Prob(E1 ). Pendant le déroulement du jeu 1, l’algorithme A effectue un certain
nombre de requêtes de signatures et obtient les couples de messages signés (m1 , τ1 ), . . . , (mq , τq ).
Considérons l’évènement C égal ? hh il existe deux requêtes i et j telles que les valeurs de f ? l’avantdernière itération sont égales ii. La probabilité de C est la probabilité que deux valeurs aléatoires
soient égales parmi n. Elle est approchée par le paradoxe des anniversaires :
Prob(C) ≈
q2
.
2n+1
En l’absence de collision, la valeur de la fonction f était parfaitement aléatoires, les requêtes
n’apportent aucune information ? l’algorithme A et la probabilité qu’il trouve une signature correcte
pour un nouveau message ne dépasse pas le tirage de la valeur au hasard :
1
Prob(E1 | ¬C) = n
2
On a finalement la probabilité
Prob(E1 ) = Prob(E1 | C) × Prob(C) + Prob(E1 | ¬C) × Prob(¬C)
|
{z
} | {z } |
{z
} | {z }
≤1
1
≤1
q2
= n
≈ n+1
2
2
qui est une fonction négligeable ainsi que :
Prob(E0 ) ≤ Prob(E1 ) + εfpa .
q
qqAA
Dans la preuve, on utilise de manière explicite que les messages ? signer ont tous la même
taille, égale ? ` blocs de n bits. Si les messages ont une taille variable, il est possible de forger
une fausse empreinte ? partir des signatures deux messages bien choisis.
– Soit τ1 la signature d’un message d’un seul bloc (m1 ).
– Soit τ2 la signature d’un message d’un seul bloc égal ? (τ1 ).
Il est immédiat de vérifier que τ2 est une empreinte correcte du message constitué de deux blocs
(m1 , τ1 ).
Pour pallier ce problème, il existe plusieurs remèdes :
– Utiliser pour paramétrer la fonction pseudo-aléatoire, non pas directement la clé k, mais une clé
de session obtenue comme la valeur k ∗ = fk (`), qui est une fonction du nombre de blocs.
– Surchiffrer l’empreinte, qui est obtenue comme τ 0 = fk0 (τ ).
49
50
Chiffrement
§ VII.8
Chiffrement CCA-sûr générique
Dans ce paragraphe, on propose la construction d’un schéma de chiffrement sûr contre une attaque ?
cryptogramme choisi par la combinaison d’un schéma de chiffrement qui n’est sûr que contre une
attaque ? clair choisie, et d’un code d’authentification de messages.
On suppose qu’on dispose de :
– un schéma de chiffrement (G, E, D) qui est sûr contre une attaque ? clairs choisis ;
– un code d’authentification de messages (GM , MAC, Verif) qui est sûr contre une attaque ?
messages choisis.
On construit un schéma de chiffrement (G∗ , E ∗ D∗ ) comme suit :
– La fonction de génération de clé G∗ génère un couple de clé, l’une pour le schéma de chiffrement,
n
l’autre pour le code
d’authentification de message. En d’autres termes, G(1 ) renvoie le couple
n
n
G(1 ), GM (1 ) = (k, kM ).
– Pour chiffrer un message m, la fonction de chiffrement E ∗ (m) renvoie le couple (c, τ ), où c est
le cryptogramme c = Ek (m) et τ est l’empreinte du cryptogramme τ = MACKM (c).
– Pour déchiffrer le cryptogramme (c, τ ), l’algorithme E ∗ vérifie tout d’abord si τ = VerifkM (c, τ ) =
1. Si c’est le cas, alors l’algorithme E ∗ renvoie Dk (c), et sinon, renvoie un symbole ⊥ pour signifier
l’échec du déchiffrement.
L’adjonction d’un code d’authentification sur le cryptogramme rend le cryptogramme non
malléable.
Théorème VII.11
Le schéma de chiffrement (G∗ , E ∗ , D∗ ) est sûr contre une attaque ? cryptogrammes choisis.
Preuve. Soit A un adversaire contre ce schéma de chiffrement. On suppose qu’il a accès ? un oracle
de chiffrement et ? un oracle de déchiffrement.
Notons le jeu réel le jeu 0. Au cours de ce jeu, l’algorithme A soumet des requêtes m1 , . . . , mq ?
l’oracle de chiffrement, et il obtient une liste L de cryptogramme L = (c1 , τ1 ), . . . , (cq , τq ) .
Il soumet également des cryptogrammes (c, τ ) et obtient le résultat de ce déchiffrement, soit ⊥ si
il y a échec du déchiffrement, soit le message clair en cas de succès.
L’algorithme A propose deux messages m∗0 et m∗1 , et obtient en retour le cryptogramme (cb , τb ) de
l’un des deux messages, qui correspond ? une valeur b aléatoire dans {0, 1}. Ce cryptogramme est
défini par cb = Ek (mn ) et τb = MaCKM (cb ).
L’algorithme renvoie une réponse b0 ∈ {0, 1}. Il a réussit si b = b0 et il a échoué dans le cas contraire.
On note E0 l’évènement hh b = b0 ii de réussite de l’algorithme A.
Le jeu 1 est similaire au jeu 0, est joué par un simulateur qui réalise correctement l’oracle de
déchiffrement, mais simule l’oracle de déchiffrement.
Lorsque l’algorithme A soumet un cryptogramme (c, τ ), le simulateur vérifie s’il est présent dans la
liste L. S’il est présent, alors il renvoie le message qui a été soumis pour obtenir ce cryptogramme,
et s’il n’est pas présent, renvoie ⊥ pour signifier l’échec.
L’oracle de déchiffrement peut être simulé en toute ignorance de la clé du code d’authentification
de message.
On note E1 l’évènement qui signifie la réussite de l’algorithme A au cours du jeu 1.
Notons ValDec l’évènement où l’adversaire A soumet un cryptogramme valide (c, τ ) qui n’est pas
dans la liste L. S’il peut réaliser cela, c’est qu’il peut forger une empreinte du cryptogramme c. On
a le résultat suivant :
Prob ValDec ≤ qD εmac ,
où qD désigne le nombre de requêtes de déchiffrement et εmac désigne la probabilité de succès
maximale d’un adversaire contre le code d’authentification de message pour forger une empreinte.
Ce point assez intuitif est toutefois assez délicat ? démontrer formellement.
§ VII.9
Exercices
Si l’évènement ValDec n’est pas réalisé, alors le jeu 1 est identique au jeu 0 :
Prob E0 | ¬Valdec = Prob E1 | ¬Valdec .
Montrons que dans le jeu 1, l’avantage de A est celui d’un adversaire contre le schéma de chiffrement
E dans une attaque ? clair choisi.
Pour montrer cela, construisons un algorithme B contre le chiffrement E qui utilise l’algorithme A.
C’est possible, car on n’a pas besoin de l’oracle de déchiffrement pour simuler le jeu 1. L’algorithme
B peut générer une clé MAC lui même qu’il utilisera pour répondre aux requêtes de chiffrement
de l’algorithme A.
∗
L’algorithme B génère lui même une clé kM
par appel ? GM (1n ) et utilisera cette clé lors des
requêtes de chiffrement de l’algorithme A.
Si A demande ? chiffrer le message m, l’algorithme B lui répond (c, τ ∗ ), où c = E(m), l’algorithme
∗ (c). L’algorithme B ajoute ce cryptogramme ? la
E étant l’oracle de l’algorithme B, et τ ∗ = MACkM
liste L pour pouvoir répondre ? A un message clair m si le cryptogramme qu’il a requis appartient ?
la liste L et le symbole ⊥ l’il n’y appartient pas.
Ainsi, l’algorithme B simule parfaitement le jeu 1.
Lorsque l’algorithme A renvoie les deux messages m∗0 et m∗1 , alors l’algorithme renvoie ? son
environnement ces mêmes messages m∗0 et m∗1 .
Lorsque l’algorithme B reçoit son défi sous la forme du chiffré c par E de l’un des deux messages
∗
et fournit ? A
m∗0 ou m∗1 , alors, il calcul une étiquette du cryptogramme τ ∗ avec sa propre clé kM
∗ ∗
le défi sous la forme du couple (c , τ ).
Lorsque l’algorithme A renvoie son résultat b0 , l’algorithme B renvoie le même résultat b0 .
Ainsi par construction, l’avantage de l’algorithme B contre le schéma de chiffrement E est
exactement l’avantage de A au cours du jeu 1.
On peut finalement majorer l’avantage de l’algorithme A au jeu 0. Notons εcpa l’avantage maximal
d’un adversaire contre le chiffrement E au cours d’une attaque ? clair choisi. L’avantage de A contre
le chiffrement E ∗ est majoré par :
εA
cca = 2 Prob(E0 ) − 1 ≤ qD εmac + εcpa ,
qui est une fonction négligeable.
§ VII.9
Exercices
1. On définit ci-après des schémas de chiffrement. Dans chaque cas dire s’ils ont la propriété
d’indistinguabilité dans une attaque ? clair choisi, ? cryptogramme choisi :
a) E(k, m) = m ⊕ fk (r), où Fn = (fk )k∈{0,1}n est une famille de fonctions pseudo-aléatoires
{0, 1}n −→ {0, 1}n , et r est un élément aléatoire de {0, 1}n .
b) Le mode dictionnaire d’un chiffrement par bloc. Le message est découpé en blocs de même
taille, et chaque bloc est chiffré avec une même fonction de chiffrement :
E k, (m1 , . . . , m` ) = pk (m1 ), . . . , pk (m` ) ,
où Pn = (pk )k∈{0,1}n est une famille de permutations aléatoires.
c) La fonction RSA.
e) Le chiffrement El Gamal.
e) Le chiffrement de Paillier.
2. Le schéma de chiffrement défini dans le paragraphe VII.4 reste-t-il sûr face ? une attaque ?
cryptogramme choisi ?
51
52
Chiffrement
Indication : poser des requêtes avec la même clé de session.
3. Montrer que le mode ECB n’est pas sûr, c’est- ?-dire qu’il n’a pas la propriété IND-CPA.
Montrer que le mode ECB n’est pas sûr, y compris lorsqu’on impose que tous les blocs du message
clair sont différents.
4. Montrer que le mode CBC avec une valeur prédictible pour le vecteur initial n’est pas sûr.
5. Montrer que le mode CBC avec vecteur initial aléatoire est malléable, et n’est donc pas sûr
contre une attaque ? cryptogramme choisi.
6. Dans la preuve du théorème VII.10 page 49, montrer que si l’évènement C survient, il est
possible de construire un message correctement signé.
§ VIII.1
Les cinq mondes d’Impagliazzo
VIII – SIGNATURES NUMÉRIQUES
La signature numérique assure le service d’authentification dans le contexte de la cryptographie ?
clé publique. Seul le signataire peut signer avec sa clé priée. Tous peuvent vérifier avec la clé
publique correspondante.
Le premier schéma de signature asymétrique qui a été inventé est le RSA (). On peut
transformer le schéma de chiffrement en schéma de signature simplement en inversant le rôle
de la clé publique et de la clé privée.
La signature d’un message m ∈ Z/nZ est la quantité σ = md mod n, où d est l’exposant privé, et
n le module public.
Pour vérifier que σ est une signature valide du message m, on vérifie que m = σ e mod n, où e est
l’exposant public.
Finalement, la signature apparait ici comme un chiffrement avec la clé privée, la vérification étant
un déchiffrement avec la clé publique, ou bien, ce qui revient au même, que la génération de
signature est un déchiffrement du message, et la vérification de signature est un chiffrement de la
signature.
Ceci donne l’idée que la signature est le dual du chiffrement ? clé publique, et que cela nécessite,
comme pour le chiffrement d’une fonction ? sens unique avec trappe. Cette approche est fausse !
D’une part, il n’est pas toujours possible d’utiliser un schéma de chiffrement pour signer. Par
exemple, si le chiffrement est probabiliste, il n’est pas toujours possible d’appliquer l’algorithme de
déchiffrement, invoquant la clé privée, ? un message arbitraire. Dans ce cas, la signature ne pourra
être valide qu’avec une probabilité négligeable.
D’autre part, le chiffrement ? clé publique nécessite une fonction ? sens unique avec trappe, alors
que pour construire un schéma de signature, il suffit de disposer d’une fonction ? sens unique. La
signature ne nécessite pas de trappe.
Rappelons que l’existence de fonction ? sens unique est l’exigence minimale pour réaliser de la
cryptographie. La signature, même asymétrique, peut être construite sur cette condition minimale.
Même si un jour le chiffrement ? clé publique disparait, il sera peut-être quand même possible de
réaliser des signatures ? clé publique.
§ VIII.1
Les cinq mondes d’Impagliazzo
On ne sait pas aujourd’hui si la famille P des problèmes pour lesquels un algorithme efficace existe
pour les résoudre est ou non égal ? la famille N P des problèmes qui sont vérifiables efficacement.
Russel Impagliazzo a imaginé cinq mondes imaginaires possibles selon une hiérarchie de difficulté
de résolution des problèmes. Rappelons qu’on dit qu’un problème est facile s’il existe un algorithme
efficace pour le résoudre.
1. Algorithmica. Ce monde est le monde où P = N P. Dans ce monde, tout les problèmes qui sont
faciles ? vérifier sont aussi facile ? résoudre. La seule cryptographie possible dans Algorithmica
est la cryptographie ? sécurité inconditionnelle, par exemple reposant sur le masque jetable.
2. Heuristica. Dans le monde Heuristica, P =
6 N P, c’est- ?-dire il existe des problèmes difficiles ?
résoudre dans le pire des cas qui sont faciles ? vérifier, mais tous les problèmes faciles ? vérifier
sont faciles ? résoudre en moyenne.
3. Pessiland. Dans le monde Pessiland, il existe des problèmes faciles ? vérifier mais difficile ?
résoudre, y compris dans le pire des cas, mais il n’existe pas de fonction ? sens unique. Toutes
les fonctions sont inversibles efficacement.
4. Minicrypt. Dans le monde Minicrypt, il existe des fonctions ? sens unique. Il est possible de
trouver des problèmes difficiles qu’on sait résoudre, comme trouver l’antécédent de y par une
fonction ? sens unique f , alors qu’on vient de calculer y = f (x). Le monde minicrypt est le
monde minimal dans lequel il est possible de faire de la cryptographie symétrique. Dans ce
monde, on peut également établir des preuves sans divulgation et des signatures asymétriques.
53
54
Signatures numériques
5. Cryptomania. Le monde Cryptomania est le plus proche du monde réel actuel. Dans ce
monde, il existe des fonctions ? sens unique avec trappe, comme la fonction RSA, qu’on sait
inverser lorsque la factorisation du module est connu, mais qui reste difficile pour tous ceux
qui ignorent cette factorisation. La cryptographie asymétrique n’est possible que dans le monde
cryptomania.
Il se peut que certains de ces mondes disparaissent avec le développement de notre connaissance
de la théorie de la complexité. Le premier ? disparaitre serait Cryptomania. Même si ce dernier
venait ? disparaitre, tant que le monde Minicrypt existe encore, la signature asymétrique restera
possible.
Le schéma de signature RSA est construit dans le monde Cryptomania. Il en est de même de
la plupart des schémas de signature actuels, comme le DSA, ElGamal, Schnorr, ECDSA, etc. La
suite de cette section est consacrée ? la preuve que la signature numérique appartient au monde
Minicrypt. L’objet est de construire une signature asymétrique ? partir d’une fonction ? sens unique.
§ VIII.2
Définition et sécurité des signatures
Définissons tout d’abord ce qu’est un schéma de signature, ainsi que les conditions de sécurité qu’il
doit vérifier.
Définition VIII.1 [Schéma de signature]
Un schéma de signature numérique π, opérant sur une famille de messages M = Mn n∈N ,
se compose de trois algorithmes probabilistes : Gen, Sign et Verif.
– L’algorithme de génération des clés Gen(1n ) prend un paramètre de sécurité 1n retourne
le couple (kpub , kpriv ) où kpub est la clé publique et kpriv est la clé privée correspondante.
– Pour le paramètre de sécurité 1n , l’algorithme de production de signature Sign(kpub , m),
prend comme paramètre une clé privée kpriv et un message m ∈ Mn et produit une
signature σ.
– L’algorithme de vérification Verif(kpub , m, σ) est l’algorithme de vérification de la signature σ du message m. Il invoque la clé publique kpub . Il rend une valeur 1 pour signifier
que la signature est acceptée, ou bien 0 pour signifier que la signature est rejetée.
Les algorithmes doivent vérifier les conditions suivantes :
– Condition de validité : les signatures qui ont été produite correctement doivent être
acceptées. Si (kpub , kpriv ) ← Gen(1n ), si σ = Sign(kpriv , m) alors on doit toujours avoir
Verif(kpub , m, σ) = 1.
– Condition de sécurité : un adversaire ne doit pas pouvoir produire de message correctement signé, y compris lorsqu’il accède ? un oracle qui lui signe des document de son choix.
Pour tout algorithme polynomial A qui accède ? l’oracle de signature Sign, son avantage,
égal par définition ? la probabilité que A produise une signature valide, est négligeable.
Pour tout (kpub , kpriv ) ← Gen(1n ),
h
i
Adv(A) = Prob ASign(kpriv ,·) (kpub ) = (m, σ) | Verif(kpub , m, σ) = 1 ,
où le message m n’a pas été demandé ? l’oracle de signature Sign(kpriv , ·), est négligeable
en n.
On se place ici dans les conditions les plus sévères pour la sécurité. Le faussaire peut faire signer les
messages de son choix pour pouvoir produire un message quelconque correctement signé. Il s’agit
ici de l’attaque ? messages choisi, notée UF-CMA (Unforgeable under Chosen Messages Attack).
Il existe des conditions plus faibles de sécurité.
– L’observation passive : l’adversaire peut accéder ? un ensemble de messages signés, mais non
choisis.
§ VIII.3
Le paradigme de Fiat-Shamir
– Pas d’observation : l’adversaire ne peut accéder ? aucun message signé. Cette condition est trop
faible. En pratique, il est toujours possible d’observer des messages signés.
kpub
?
miA
σi
?
(m, σ)
Sign(kpriv , ·)
valide avec m différent de tous les mi
La signature RSA n’est pas sure dans une attaque ? messages choisis. Par exemple si σ1 est une
signature valide d’un message m1 et si σ2 est une signature valide d’un message m2 , alors cela
signifie que σ1e = m1 et σ2e = m2 . Il en résulte que le produit σ1 σ2 est une signature valide du
message m1 m2 , puisque (σ1 σ2 )e = σ1e σ2e = m1 m2 .
Pour corriger cela, on applique au message une fonction de hachage. Une fonction de hachage
idéale est une fonction aléatoire appelée un oracle aléatoire. Soit H : M −→ Z/nZ une fonction
aléatoire, la signature FDH-RSA (Full Domain Hash RSA) est calculée par
σ(m) = H(m)d mod n.
Si la fonction H est aléatoire, c’est- ?-dire s’il s’agit d’un oracle aléatoire, alors ce schéma de
signature peut être prouvé sûr contre une attaque ? messages choisis.
§ VIII.3
Le paradigme de Fiat-Shamir
Le paradigme de Fiat-Shamir () est une méthode générale qui permet de construire un
schéma de signature ? partir d’un protocole d’authentification sans divulgation de connaissance
(Zero Knowledge) et d’un oracle aléatoire.
Rappelons que les protocoles d’authentification sans divulgation sont des protocoles interactifs ?
trois passes qui permettent de prouver la détention d’une donnée secrète sans révéler aucune
information sur cette donnée :
−→ Engagement.
←− Défi.
−→ Réponse.
Une condition de sécurité de ce type de protocole est le caractère aléatoire du défi. Si la fonction
H est un oracle aléatoire, alors l’image d’un message m par H est une valeur aléatoire qui peut
tenir lieu de défi. On obtient alors un protocole non interactif qui peut faire office de schéma de
signature. Il s’agit de prouver que l’on détient bien la clé privée associée ? la clé publique kpub .
−→ Engagement : la clé publique kpub .
−→ Défi : H(m) le haché du message m par un oracle aléatoire.
−→ Réponse : la signature σ du message m.
Considérons par exemple le protocole suivant qui est un protocole sans divulgation, de la
connaissance du logarithme discret x d’une donnée publique y dans un groupe cyclique G d’ordre
q, engendré par un générateur g. Les trois passes de ce protocole sont :
−→ Engagement : y = g x et u = g r avec r aléatoire.
←− Défi : un valeur k aléatoire.
55
56
Signatures numériques
−→ Réponse : la valeur t telle que u = g t y k .
Ce protocole est sans divulgation, car si on connait ? l’avance la valeur k du défi, alors il est facile
de choisir la réponse t que l’on donnera, et de s’engager sur le défi u = g t y k . Les trois passes
du protocole peuvent par conséquent être simulées et rien ne peut distinguer la simulation d’un
protocole réel d’authentification.
Le prouveur qui détient la valeur de x peut calculer la valeur t de la réponse en calculant
t = r − kx mod q.
Ce protocole peut être transformé en schéma de signature numérique avec un oracle aléatoire
H(m, u). On obtient alors le schéma de signature de Schnorr.
Il est possible de construire une preuve sans divulgation ? partir d’une fonction ? sens unique, sans
nécessairement disposer d’une trappe dans la fonction ? sens unique. Cette preuve sans divulgation
peut être dérivée en un schéma de signature gr ?ce au paradigme de Fiat-Shamir et ? un oracle
aléatoire qui est prouvée sure. En conclusion, il est possible de construire un schéma de signature ?
partir d’une fonction ? sens unique et d’un oracle aléatoire. Le problème de cette approche est que
la condition de disposer d’un oracle aléatoire est très forte, et les fonctions de hachage réelles sont
loin de satisfaire cette hypothèse. Contrairement au modèle de l’oracle aléatoire, dans le modèle
standard, on suppose seulement que les fonctions de hachage résistent aux collisions.
La suite de cette section est de construire une signature asymétrique ? partir d’une fonction ? sens
unique dans le modèle standard.
§ VIII.4
La signature hh une fois ii de Lamport
La signature définie dans cette section est une signature jetable, utilisable une fois seulement. Elle
ne nécessite qu’une fonction ? sens unique f : {0, 1}∗ −→ {O, 1}∗ .
Pour le paramètre de sécurité n, l’espace Mn des messages est l’ensemble {0, 1}n des mots binaires
de longueur n. La signature jetable de Lamport signe des messages de longueur fixe égale ? n.
1. L’algorithme Gen de génération de clé procède ainsi :
– Générer aléatoirement 2n éléments de {0, 1}n qui constituent la clé privée :
kpriv =
x01
x11
x02
x12
···
···
x0n
x1n
– La clé publique est constitué des images des xij par la fonction ? sens unique f :
kpub =
y01
y11
y02
y12
···
···
y0n
y1n
avec, pour i ∈ {0, 1} et j ∈ {1, . . . n}, yij = f (xij ).
2. L’algorithme Sign de signature, pour signer un message m, fait de n symboles binaires
m = m1 , . . . , mn , avec mi ∈ {0, 1}, est constitué des éléments de la clé secrète choisis sur la
ligne correspondant au symbole mi . La signature est :
σ = (xm1 1 , xm2 2 , . . . , xmn n )
3. Pour vérifier la signature σ = (σ1 , . . . , σn ) d’un message m, il suffit alors de vérifier que pour
tous les indices i, on a f (σi ) = yi . La signature est considérée comme non valide si pour un des
indices i on a f (σi ) 6= yi .
r
Pour signer un message, on révèle un des secrets. Avec seulement les signatures de deux
messages, pourvu qu’ils soient complémentaires l’un de l’autre, toute la clé secrète est révélée.
Cette clé n’est utilisable que pour signer un seul message.
§ VIII.5
Une signature
hh
plusieurs fois
ii
avec état
En demandant une seule signature d’un message m, pour produire une signature valide d’un
message m∗ 6= m, l’adversaire doit pouvoir inverser f sur la valeur yi , où l’indice i est l’un de
ceux où les messages m et m∗ diffèrent. La fonction f étant ? sens unique, trouver σi tel que
f (σi ) = yi est supposé difficile.
Montrons la sécurité du schéma de signature une fois de Lamport de manière plus formelle. Pour
cela, ? partir d’un algorithme A qui forge une signature, construisons un algorithme B qui inverse
la fonction f sur une entrée arbitraire y. En évaluant les avantages de ces algorithmes, on montre
la sécurité de ce schéma.
L’algorithme B va simuler les trois algorithmes du schéma de signature auprès de l’algorithme A.
Le principe est de placer y ? une position dans la clé publique. Lorsque A demande la signature
d’un message m, il faudra espérer que le symbole mi∗ ? la position i∗ permette ? B de proposer une
signature valide, et aussi que le message correctement signé que A fournisse un antécédent de y.
Tout d’abord, B choisit une position j ∗ et un symbole binaire aléatoire i∗ .
Ensuite, B impose que y soit placé en position yi∗ j ∗ de la clé publique. Les autres entrées des
clés publiques et privées sont celles produites par l’algorithmes de génération de clé standard Gen.
C’est- ?-dire, pour i 6= i∗ et j 6= j ∗ , la valeur de xij est aléatoire et yij = f (xij ).
Ensuite, l’algorithme A va demander la signature d’un message m = m1 · · · mn . Si mj ∗ = i∗ , ce
qui survient avec probabilité 1/2, alors l’algorithme B échoue. Sinon, il peut révéler les éléments
secrets (xm1 1 , . . . , xmn n ).
L’algorithme A va proposer un message m+ et sa signature σ + . Sur au moins une des positions j,
le message m diffère du message m+ Si mj ∗ = m+
j ∗ , alors l’élément secret révélé pour la signature
+
∗
de m en position j est le même que celui du message m et l’algorithme B échoue. Dans le cas
contraire, ce qui survient avec une probabilité au moins égale ? 1/n, l’algorithme A propose en
position j ∗ un antécédent de y par f que l’algorithme B peut renvoyer.
Finalement, l’algorithme B utilise avec pertinence la réponse de l’algorithme A avec une probabilité
supérieure ? 1/2n, et dans ce cas, l’avantage de l’algorithme B est celui de l’algorithme A. On a
donc :
1
Adv(A),
Advf (B) ≥
2n
qui reste non négligeable dès que l’avantage de A est non négligeable, et achève la preuve de la
sécurité du schéma de signature jetable de Lamport.
§ VIII.5
Une signature hh plusieurs fois ii avec état
Pour passer ? des signatures utilisable plusieurs fois, on utilise une structure d’arbre, similaire ?
celle utilisée pour construire des fonctions pseudo-aléatoires. La signature dépend d’un état, ce qui
n’est pas conforme ? la définition, mais constitue une étape avant la construction d’un schéma de
signature sans état, ne nécessitant qu’une fonction ? sens unique.
La construction de cette signature avec état est possible ? partir de n’importe quel schéma de
signature une fois π = (Gen, Sign, Verif), et il sera applicable au schéma de signature de Lamport
décrit au paragraphe précédent.
La signature d’un message binaire m = m1 · · · mn consiste ? parcourir un arbre binaire ? partir de
la racine. Lors de la lecture d’un 0, l’arbre est parcouru ? gauche, et lors de la lecture d’un 1, il est
parcouru ? droite.
Chaque nœud est indexé par un préfixe m0 = m1 · · · m` du message. La racine est indexée par le
m0
m0
, kpriv
). À
préfixe vide ε. Chacun nœud contient également une nouvelle paire de clé km0 = (kpub
ε
ε
la racine, il s’agit de la paire de clé kε = (kpub
, kpriv
). Aux autres nœuds de l’arbre, il s’agit d’une
signature qui est générée lorsqu’un nouveau préfixe est parcouru. Pour un nouveau message avec
le même préfixe, c’est la même clé qui est utilisée.
Lorsqu’on parcourt l’arbre, la clé publique du nœud courant est ajoutée ? la signature produite.
Cette clé est authentifiée avec la clé de niveau précédent, constituant un certificat ? la manière
57
58
Signatures numériques
d’une infrastructure de clés publiques. Au final, la clé km signe le message m. La signature est
constituée de cette signature et des clés publiques certifiées pour tous les préfixes. Le schéma de
signature π ne pouvant être utilisé qu’une seule fois, la clé du nœud courant est utilisée pour signer
les deux clés publiques du niveau inférieur. La clé racine kε authentifie le premier préfixe.
De plus, afin de ne pas générer de nouvelles clés inutilement lors de la signature de nouveaux
messages, un état mémorisant les préfixes et les clés correspondantes est mis ? jour. Une nouvelle
clé n’est générée pour un préfixe que si ce préfixe n’appartient pas ? l’état. Lorsqu’une nouvelle clé
est générée, le préfixe pour lequel elle l’a été est ajouté ? l’état.
Voici un exemple pour signer le message m = 0110 :
0
ε
qHkH
1
H
Hq k1
qk
Q
Q 01
0
Q
Q
Q
qk00
Qq
k01
@1
@
0
@
q k010 @q k011
@1
0
q k0110 @q k0111
m
1. Lors de la lecture du premier symbole 0, deux clés sont générées par appel ? la fonction de
ε
génération Gen pour générer les clés k0 et k1 . La clé privée kpriv
est utilisée pour produire une
0
1
signature des deux clés publiques kpub et kpub , produisant une signature σε . Le certificat cε est la
0
1
donnée des clés publiques et de leur signature : cε = (kpub
, kpub
, σε ).
2. Lors de la lecture du deuxième symbole 1, les clés k01 et k00 sont générées, les clés publiques sont
0
00
01
signées avec la clé privée kpriv
, produisant une signature σ0 . Le certificat c0 est c0 = (kpub
, kpub
, σ0 ).
3. Lors de la lecture du troisième symbole 1, les clés k011 et k010 sont générées, les clés
01
publiques sont signées avec la clé privée kpriv
, produisant une signature σ01 . Le certificat c01
010
011
est c01 = (kpub , kpub , σ01 ).
4. Lors de la lecture du dernier symbole 0, les clés k0110 et k0111 sont générées, les clés
011
publiques sont signées avec la clé privée kpriv
, produisant une signature σ011 . Le certificat c011
0110 0111
est c011 = (kpub , kpub , σ011 ).
5. Le message m est finalement signé avec la clé privée k0110 produisant la signature σ0110 . La
signature totale du message m par le schéma π ∗ est constitué de cette signature et de tous les
certificats produits. σ ∗ = (cε , c0 , c01 , c011 , σ0110 ).
Pour vérifier cette signature, les signatures des certificats sont vérifiées dans cet ordre, établissant
la confiance dans les clés publiques successives, pour finalement vérifier la signature du message
m.
Dans ce schéma, chaque signature n’est utilisée qu’une seule fois, soit pour signer les clés publiques
du niveau suivant, soit au final pour signer le message.
Pour un nouveau message, il y a au moins un nœud nouveau. Si un adversaire peut forger une
signature pour un nouveau message, alors il peut forger une signature pour le schéma initial π à
ce nœud.
Ce schéma de signature ne convient pas encore. Il reste deux problèmes à résoudre :
1. La fonction de génération de signature comprend un état qui est mis à jour au fur et à mesure
que des messages sont signés. Ceci sort du cadre de la définition des signatures numériques.
Pour se débarrasser de l’état, il faut savoir générer les mêmes signatures pour un préfixe donné.
Ceci peut être réalisé en remplaçant l’algorithme probabiliste de génération Gen(1n ) par un
algorithme déterministe, avec une chaine aléatoire comme paramètre supplémentaire, alimenté
par un générateur pseudo-aléatoire.
§ VIII.6
Fonction de hachage
2. Les signatures des certificats signent des couples de clés publiques, qui sont deux fois plus longs
que la clé servant à signer. Le schéma de Lamport n’est pas directement utilisable. La résolution
de ce problème repose sur une fonction de hachage pour que la signature opère sur une donnée
de la taille de la clé.
§ VIII.6
VIII.6.1.
Fonction de hachage
Motivation
Pour signer un message de grande taille, celui-ci est d’abord soumis à une fonction de hachage,
afin d’en produire un condensé de taille fixée, et c’est ce condensé qui est soumis à la fonction de
signature. Il existe deux notions de sécurité pour les fonctions de hachage :
– la résistance au collision ;
– la notion de fonction de hachage universelle à sens unique.
La seconde notion est moins forte que la première, mais peut être construite à partir d’une fonction
à sens unique, alors que la construction de fonctions de hachage à partir de fonctions à sens unique
reste un problème ouvert. Il est par ailleurs suffisant de disposer de fonction de hachage universelle
à sens unique pour construire un schéma de signature sûr.
VIII.6.2.
Définition
L’analyse de la sécurité étant une notion asymptotique, il est nécessaire de définir une famille de
fonctions de hachage, selon un paramètre de sécurité.
Définition VIII.2 [famille de fonctions de hachage]
Une famille de fonctions de hachage H est constituée de deux algorithmes :
1. un algorithme probabiliste Gen(1k ), où k ∈ N est le paramètre de sécurité, génère un
indice s public, appartenant à un ensemble d’indices S.
2. Pour indice s ∈ S, un algorithme polynomial Hs calcule,pour tout élément x de {0, 1}∗ ,
une valeur Hs (x) qui appartient à {0, 1}`(k) , où `(x) est un polynôme.
r
En pratique, on utilise toujours une fonction de hachage sans clé, de type SHA 1 ou MD 5, qui
correspond à une famille à un seul indice. Ces fonctions produisent un condensé de taille fixe,
égale respectivement à 160 et 128 symboles binaires. Toute analyse asymptotique de la sécurité est
impossible avec ces fonctions fixée.
VIII.6.3.
Notions de sécurité
1. Résistance aux collisions. Une famille de fonctions de hachage est résistante aux collisions
(CR, Collision Resistant) s’il est difficile de trouver deux éléments x et x0 dans {0, 1}∗ qui ont le
même condensé.
Un adversaire d’une famille de fonctions de hachage contre les collisions est un algorithme qui
produit deux messages différents qui ont le même condensé. L’avantage d’un adversaire est sa
probabilité de réussite :
h
i
0
0
0
Advcr
H (A) = Probs←Gen(1k ) A(x) = (x, x ) | Hs (x) = Hs (x ) et x 6= x
Cette valeur est une fonction du paramètre de sécurité k.
59
60
Signatures numériques
Définition VIII.3 [résistance aux collisions – CR]
On dit qu’une famille de fonctions de hachage H est résistante aux collisions (CR) si
l’avantage Advcr
H de tout adversaire polynomial A est une fonction négligeable du paramètre
de sécurité.
2. Fonction de hachage universelle à sens unique (UOWHF Universal One Way Hash
Function Cette propriété de sécurité est une formalisation de la résistance au second antécédent.
Étant donné un message x, il doit être difficile de trouver un second message x0 ayant le même
condense que x. Un adversaire contre la propriété UOWHF est un algorithme qui produit d’abord
un élément x de {0, 1}∗ en fonction du paramètre de sécurité, sans connaı̂tre l’indice public s,
puis qui doit trouver un second antécédent x0 à Hs (x), pour un indice s aléatoire produit par
l’algorithme Gen(1k ).
L’avantage d’un adversaire A contre la propriété UOWHF est sa probabilité de succès. Soit
x ← A(1k ) un message choisi par l’adversaire A.
i
h
0
0
0
Advuowhf
(A)
=
Prob
A(s)
=
x
|
H
(x)
=
H
(x
)
et
x
=
6
x
k
s
s
s←Gen(1 )
H
Définition VIII.4 [Fonction de hachage universelle à sens unique – UOWHF]
On dit qu’une famille de fonctions de hachage H est universelle à sens unique (UOWHF)
si l’avantage Advuowhf
de tout adversaire polynomial A est une fonction négligeable du
H
paramètre de sécurité.
VIII.6.4.
Une construction de fonction de hachage résistante aux collisions
Les exercices de ce chapitre proposent des constructions de fonctions de hachage résistantes aux
collisions reposant sur le problème du logarithme discret dans un groupe fini, ou sur le problème
de la factorisation. Si un calculateur quantique venait à voir le jour, ces problèmes deviendraient
facile, ce qui rendraient caduques les familles de fonctions de hachage reposant sur ceux-ci. On
propose dans cette section la construction d’une famille de fonctions de hachage résistante aux
collisions reposant sur le problème du plus court vecteur d’un réseau, qui est un problème qui
résisterait à l’existence d’un calculateur quantique.
Soit q un entier et A une matrice de m lignes et n colonnes à coefficients dans Z/qZ. Le réseau
engendré par A est l’ensemble des combinaisons linéaires à coefficients entiers des lignes de la
matrice A :
Λq (A) =
t
s A mod q | s ∈ Zm
Il existe aussi le réseau dual qui est l’ensemble des vecteurs à coefficients entiers qui annulent la
matrice A :
m
Λ⊥
q (A) = y ∈ Z | A y = 0 mod q
Ajtai a montré que pour un choix convenable de n, m et q, le problème de trouver un élément
d’un réseau Λ⊥
q (A) dont les composantes sont 0, 1 ou −1 modulo q, est un problème difficile. Ce
problème est appelé le problème SIS (Small Integer Solution).
En d’autres termes, il est difficile de trouver un vecteur z ∈ {−1, 0, 1}m tel que A z = 0 mod q.
La famille de fonctions de hachage définie par :
1. Gen(1k ) 7→ s = (n, m, q, A), où A est une matrice de n lignes et m colonnes,
{0, 1}m −→ (Z/qZ)n
2. Hs :
x
7−→
Ax
est résistante aux collisions.
§ VIII.7
Le paradigme
hh
hache puis signe ii.
En effet, si on peut trouver deux vecteurs x et x0 qui ont le même condensé, alors on a trouvé un
vecteur x − x0 du réseau Λ⊥
q (A) dont les composantes appartiennent à {−1, 0, 1}, c’est- ?-dire une
solution du problème SIS.
VIII.6.5.
La construction de Merkle-Damgård
La construction du paragraphe précédent opère sur un domaine de taille fixée. L’objet des fonctions
de hachage est d’assurer une compression pour produire, à partir d’un long message, un condensé
de taille plus réduite. La construction de Merkle-Damgård définit une fonction de hachage sur des
messages de longueur quelconque, à partir d’une fonction de facteur de compression égal à 2, c’est à
dire qui opère sur des messages de 2` symboles binaires pour produire des condensés de ` symboles
binaires. Le principe est similaire à celui du CBC-MAC.
Un long message m est partagé en b blocs de ` symboles binaires chacun. Chaque bloc entre dans
la fonction de hachage Hs . Le calcul est chainé selon la figure suivante.
m1
m2
m3
- Hs
...
L : longueur du message
mb
L
- Hs - . . . - Hs
- Hs - Hs∗
Chaque fonction Hs est une fonction {0, 1}2` −→ {0, 1}` .
La longueur L du message est ajoutée afin de se prémunir contre les collisions construites à partir
de la concaténation de messages.
À partir d’une famille de fonctions de hachage H = (Gen, H), la construction de Merlke-Damgård
consiste à produire une famille H∗ = (Gen∗ , H ∗ ), où
– l’indice public s est le même : Gen(1k ) 7→ s, avec s ← Gen(1k ) ;
– la valeur Hs∗ est définie par le schéma ci-dessus.
Théorème VIII.5 [sécurité de la construction de Merkle-Damgård]
Si la famille H est résistante aux collisions, alors la construction de Merkle-Damgård produit
une famille de fonctions de hachage H∗ résistante aux collisions.
Preuve. La preuve est laissée en exercice.
§ VIII.7
Le paradigme hh hache puis signe ii.
Ce paradigme correspond à la pratique usuelle de la signature. Pour signer un long document, on
commence par lui appliquer une fonction de hachage. On obtient alors un condensé de longueur
fixe. Et c’est sur ce condensé que la fonction de signature est appliquée.
VIII.7.1.
Avec un hachage résistant aux collisions
À partir de :
– Un schéma de signature π = (Genπ , Sign, Verif) et
– Une famille de fonctions de hachage H = (GenH , H),
on construit un schéma de signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) ainsi défini :
– La fonction de génération Genπ∗ appelle la fonction de génération Genπ qui produit le couple
de clés publique et privée (kpub , kpriv ) et la fonction de génération GenH qui produit l’indice
∗
public s. Le résultat de la fonction Genπ∗ est la clé publique kpub
= (kpub , s) et la clé privée
∗
kpriv = (kpriv , s).
61
62
Signatures numériques
– La génération de signature Sign∗ applique la génération de signature Sign au condensé du
message m par la fonction de hachage Hs . Elle est est définie par :
∗
σ ∗ = Sign∗ kpriv
, m = Sign kpriv , Hs (m) .
– La vérification de signature Verif ∗ applique la fonction de vérification de signature Verif au
même condensé du message m, soit :
∗
Verif ∗ (kpub
, σ ∗ , m) = Verif kpub , σ ∗ , Hs (m)
L’intérêt de cette façon de faire est d’utiliser une signature sur des données courtes pour signer de
longs documents. Le théorème suivant montre la sécurité du schéma π ∗ .
Théorème VIII.6
Si le schéma de signature π est sûr contre une attaque à messages choisis, et si la famille de
fonctions de hachage H est résistante aux collisions, alors le schéma de signature π ∗ est sûr
contre une attaque à messages choisis.
Preuve. Supposons qu’il existe un adversaire A contre le schéma π ∗ et déduisons-en un adversaire
B, soit contre π, soit contre H.
(kpub , s)
?
µi = Hs (mi)
Oracle Sign
σ
i
B
contre kpub π ou H mi
σi - A contre π ∗
(m, σ)
? Hs (m), σ ou une collision
L’entrée de l’algorithme B est une clé publique pour le schéma π ∗ , c’est- ?-dire un couple (kpub , s).
La composante kpub est directement fournie à A.
Lorsque l’algorithme A demande la signature d’un message mi , l’algorithme lui applique la fonction
de hachage Hs , transmet le condensé µi = Hs (m) à l’oracle de signature Sign, qui retourne une
signature σ directement transmise à l’algorithme A.
À la fin de son travail, l’algorithme A fournit un message m et une signature σ. Le message m est
différent de tous les messages mi dont A a demandé la signature.
Si le haché Hs (m) est égal à l’un des hachés H(mi ), alors l’algorithme B a trouvé une collision sur
Hs .
Dans le cas contraire, il peut fournir le couple Hs (m), σ qui est une signature forgée avec le même
avantage que l’algorithme A.
§ VIII.7
Le paradigme
hh
hache puis signe ii.
VIII.7.2.
Avec un hachage universel à sens unique
L’objet est maintenant d’affaiblir l’hypothèse sur la fonction de hachage de manière à pouvoir se
contenter d’une famille de fonctions de hachage universelles à sens unique, dont on sait qu’elles
sont dans le monde minicrypt, c’est- ?-dire constructible à partir d’une famille de fonctions à sens
unique.
Le principe est similaire au précédent. La différence réside dans la génération de l’indice public s
qui n’est pas faite une fois pour toutes, mais qui est faite à chaque signature.
À partir du schéma de signature π = (Genπ , Sign, Verif) et de la famille de fonctions de hachage
H = (GenH , H), on construit un schéma de signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) de la façon
suivante :
– Pour le paramètre de sécurité k, la fonction de génération Genπ∗ (1k ) produit la clé publique
∗
∗
kpub
= kpub et la clé privée kpriv
= kpriv par simple appel à la fonction Genπ (1k ).
∗
– La génération de signature Sign appelle la génération de l’indice public de la famille de fonctions
de hachage s ← GenH (1k ), puis applique la génération de signature Sign au condensé du message
m par la fonction de hachage Hs . Pour que la vérification soit possible, l’indice public s est fourni
avec la signature, et pour s’assurer que cet indice est authentique, il est concaténé au condensé
pour être inclus dans la donnée signée. La fonction de génération est donc est définie par :
∗
σ ∗ = Sign∗ kpriv
, m = s, Sign kpriv , s||Hs (m) .
– La vérification de signature Verif ∗ , calcule le haché Hs (m) avec l’indice public inclus dans la
signature, puis applique la fonction de vérification de signature Verif à la donnée s||Hs (m). Soit :
∗
Verif ∗ (kpub
, σ ∗ , m) = Verif kpub , σ ∗ , s||Hs (m)
Cette construction fournit une signature sûe avec seulement la condition que la famille de fonctions
de hachage H est universelle à sens unique.
Théorème VIII.7
Si le schéma de signature π est sûr contre une attaque à messages choisis, et si la famille de
fonctions de hachage H est universelle à sens unique, alors le schéma de signature π ∗ défini
ci-dessus est sûr contre une attaque à messages choisis.
Preuve. La preuve est similaire à celle du théorème VIII.6 et est laissée en exercice.
q
qqAA
L’indice public étant concaténé au condensé Hs (m), il ne convient pas si cet indice est trop
long. Pour pallier cela, on utilise une seconde famille de fonctions de hachage H0 avec un
indice public s0 choisi à la génération des clés et utilisé pour condenser l’indice s pour sa signature.
Le schéma est alors le suivant : Étant donné un schéma de signature π = (Genπ , Sign, Verif) et deux
familles de fonctions de hachage H = (GenH , H) et H0 = (GenH0 , H 0 ), on construit un schéma de
signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) de la façon suivante :
– Génération de clé :
∗
∗
Gen∗ (1k ) = kpub
, kpriv
,
∗
∗
= (s0 , kpriv ) avec s0 ← GenH0 (1k ) et (kpub , kpriv ) ← Genπ (1k ).
où kpub
= (s0 , kpub ) et kpriv
– Production de la signature : à chaque signature, un indice public s est produit par s ← GenH (1k ),
puis la signature du message m est :
∗
σ ∗ = Sign∗ kpriv
, m = s, Sign kpriv , Hs0 (s)||Hs (m) .
– Vérification de la signature :
∗
Verif ∗ (kpub
, σ ∗ , m) = Verif kpub , σ ∗ , Hs0 (s)||Hs (m) ,
où l’indice s fait partie de la signature, et l’indice s0 de la clé publique.
63
64
Signatures numériques
§ VIII.8
Fonctions de hachage universelles à sens unique
Ce paragraphe présente la construction d’une famille de fonctions de hachage universelle à sens
unique à partir d’une famille de permutations à sens unique. Comme cette dernière peut être
construite à partir d’une famille de fonctions à sens unique, cela achèvera de montrer que la
signature numérique asymétrique appartient au monde Minicrypt.
La construction repose sur une famille universelle deux vers un ont on suppose l’existence dans un
premier temps. On suppose l’existence d’une famille de fonctions de hachage H ayant les propriétés
suivantes :
– Toutes les fonctions de la famille sont des fonctions deux vers un, ce qui signifie que pour toute
valeur du paramètre de sécurité k et tout élément de l’ensemble d’arrivée a exactement deux
antécédents. Ceci implique en particulier que l’ensemble de départ Dk a un cardinal double de
l’ensemble d’arrivée Uk .
– Pour tout couple (x, x0 ) d’éléments distincts de Dk , il existe un algorithme S(x, y) qui produit
un indice public s d’une fonction Hs vérifiant Hs (x) = Hs (x0 ) et tel que la production d’un
indice s avec l’algorithme S pour un élément x fixé de Dk et un élément x0 aléatoire de Dk
revient exactement à produire l’indice s avec l’algorithme de génération Gen(1k ).
On suppose aussi l’existence d’une famille F de permutations à sens unique fk : Dk −→ Dk ,
indexée par le paramètre de sécurité k.
À partir des familles H et F, on construit la famille de fonctions de hachage Hash de la façon
suivante :
– La fonction de génération est celle de la famille H : GenHash (1k ) 7→ s avec s ← GenH .
– Les fonctions de la famille calculent la valeur d’un élément du domaine Dk en composant
D −→
Dk préalablement avec la permutation à sens unique : Hashs : k
x 7−→ Hs fk (x)
Le résultat de cette section est :
Théorème VIII.8
La famille Hash définie ci-dessus est une famille de fonctions de hachage universelles à sens
unique (UOWHF)
Preuve. Montrons que si la famille Hash n’a pas la propriété d’être une famille de fonctions de
hachage universelles à sens unique, alors il est possible d’inverser les éléments de la famille F,
ce qui contredira l’hypothèse qu’il s’agit d’une famille de permutations à sens unique. Pour cela,
supposons l’existence d’un adversaire A contre la propriété UONHF de la famille Hash et déduisons
en un adversaire B contre la famille F.
L’entrée de B est un élément y de Dk et son objectif est de trouver un antécédent α par fk . Pour
atteindre cet objectif, l’algorithme B va utiliser l’algorithme A contre la famille Hash.
L’algorithme B commence par exécuter l’algorithme A(1k ) qui retourne un élément x de Dk . On
pose z = fk (x). On peut supposer que z 6= y, car dans le cas contraire, un antécédent de y est
trouvé. L’indice public passé en paramètre à l’algorithme A est l’indice retourné par l’algorithme
S(z, y). L’hypothèse faite sur la famille H indique que cet indice est comme s’il était produit par
l’algorithme GenH . Les éléments y et z vérifient par construction Hs (y) = Hs (z).
0
L’algorithme A(s) retourne un
second antécédent 0de par Hashs0 , c’est- ?-dire un élément x de Dk
tel que Hashs (x) = Hs fk (x) = Hs (z) = Hashs (x ) = Hs fk (x ) . Comme les éléments de Dk ont
tous exactement deux antécédents par Hs , l’un d’eux est z et l’autre est y, donc f (x0 ) = y.
§ VIII.9
Exercices
Il ne reste plus maintenant qu’ ? exhiber une famille de fonctions de hachage H qui vérifie les
hypothèses requises. Une telle famille est appelée une famille universelle et est utilisée pour limiter
les collisions dans les tables de recherches par clé de hachage.
Pour toute valeur k du paramètre de sécurité, on identifie l’ensemble des vecteurs de k symboles
binaires avec le corps F2k .
– La fonction de génération GenH produit un couple (a, b) aléatoire dans F2k \ {0} × F2k .
– La fonction dont l’indice public est le couple (a, b) est :
Hab :
F2k
x
−→
7−→
(F2 )k−1
,
Hab (x) = p(ax + b)
où p est une projection F2k −→ (F2 )k qui consiste à extraire les k − 1 premières composantes.
Montrons que cette fonction satisfait les deux conditions requises.
Tout d’abord, ax + b = (z, ε) où z = Hab (x) et ε ∈ {0, 1}. Comme a est non nul, la fonction
x 7−→ ax + b est inversible, et tout élément z a exactement deux antécédents correspondants aux
deux valeurs possibles de ε.
Ensuite, deux éléments distincts x et x0 de F2k tels que Hab (x) = Hab (x0 ) satisfont le système
d’inconnues a et b suivant :
ax + b = (z, ε)
ax0 + b = (z, ε)
Pour z et b fixé, ce système a pour déterminant x − x0 qui est non nul. La solution est unique. Un
choix aléatoire du couple (a, b), avec a 6= 0 correspond à un choix (x0 , z, ε) avec x0 6= x.
§ VIII.9
Exercices
1. Montrer que la signature RSA n’est pas sure, y compris dans le modèle le moins exigeant pour
la sécurité, où l’adversaire ne connait que les paramètres publics, et n’a accès à aucun document
signé.
2. Soit G un groupe cyclique d’ordre q engendré par g, où le problème du logarithme discret est
un problème difficile. Soit x un élément de Z/qZ et y = g x . On pose l’indice public s = (G, q, g, x).
Montrer que la famille de fonctions de hachage Hs : (α, β) 7−→ g α y β , pour α, β ∈ Z/qZ, est
résistante aux collisions.
3. Démontrer que si la famille de fonctions de hachage H est résistante aux collisions, alors elle est
universelle à sens unique.
4. Prouver le théorème VIII.5 page 61 établissant la sécurité de la construction de Merkle-Damgård.
5. Rédiger la preuve détaillée du théorème VIII.7 page 63.
6. Soit H = (Gen, H) une famille de fonctions de hachage universelle à sens unique Dk −→ Dk .
On définit H∗ par :
– Gen∗ (1k ) 7→ (s, s0 ) où s ← Gen(1k ) et s0 ← Gen(1k ).
– Hss0 : x 7−→ Hs ◦ Hs0 (x).
Montrer que la famille H∗ est aussi une famille de fonctions de hachage universelle à sens unique.
65
66
Signatures numériques
7. Bijections sans pince (claw free permutation).
Définition VIII.9 [pince de deux bijections]
Soient f0 et f1 deux bijections sur un même domaine D. Un triplet (x, y, z) d’éléments de
D est une pince de f0 et f1 si f0 (x) = f1 (y) = z.
Une famille de bijections est dite sans pince s’il est difficile de trouver une pince pour deux d’entre
elles.
À partir d’une famille de bijections sans pince, construire une famille de fonctions de hachage
résistante aux collisions.
{0, 1}n
−→ D
Indication : considérer Hs :
.
(x1 , . . . , xn ) 7−→ fxn ◦ · · · ◦ fx1 (s)
8. Soit N un module RSA. Montrer que la famille constituée des deux fonctions f0 : x 7−→
x3 mod N et f1 : x 7−→ x5 mod N n’est pas sans pince.
9. Soit N un module RSA et e un exposant RSA. Montrer que si le RSA est sûr, alors la famille
constituée des deux fonctions f0 : x 7−→ xe mod N et f1 : x −
7 → 2xe mod N est sans pince.
En déduire une famille de fonctions de hachage résistante aux collisions reposant sur le problème
RSA.
10. Signer un symbole binaire avec une famille sans pince à trappe.
Soit (f0 , f1 ) une famille sans pince, montrez que la signature définie par Sign(kpub b) = σ(b) =
|
fb −1(x), où la clé publique kpub est constituée de x, f0 et f1 est sure.
r
En composant les signatures d’un symbole binaire, il est possible de définir un schéma de
signature sur plusieurs symboles binaires.
§ IX.1
Sécurité
IX – CHIFFREMENT À CLÉ PUBLIQUE
§ IX.1
Sécurité
Le niveau de sécurité standard communément admis pour le chiffrement à clé publique est
la sécurité sémantique contre des attaques adaptatives à chiffré choisi. La notion de sécurité
sémantique est équivalente à celle d’indistinguabilité.
L’attaque contre l’indistinguabilité se déroule en deux temps comme un jeu entre un adversaire A
et son environnement E.
1. Dans un premier temps, l’adversaire fournit un couple de messages clairs m0 et m1 à
l’environnement.
2. L’environnement choisit un bit aléatoire b ∈ {0, 1} et fournit à l’adversaire le cryptogramme c
du message cb . L’objectif de l’adversaire est de fournir la valeur du bit b. Sa réponse est un bit
b0 et il a gagné si b = b0 .
L’avantage de l’adversaire est la quantité :
Adv(A) = Prob b = b0 −
1 .
2
En répondant au hasard, sa probabilité de gagner vaut 1/2 est son avantage est nul. Si l’adversaire
n’a aucun avantage, c’est qu’il ne peut pas extraire le moindre bit d’information du cryptogramme.
C’est ce qui est attendu d’un système sûr de cryptographie à clé publique. L’ennemi ne doit pas
savoir extraire du cryptogramme si l’information qu’il contient est l’ordre d’attaquer ou non.
Pendant les deux phases de jeu, l’adversaire peut avoir accès à un oracle de déchiffrement D à qui
il soumet des cryptogramme et dont il obtient en retour les messages clairs correspondants. On
parle alors d’attaque à cryptogramme choisis (CCA Chosen Ciphertext Attack).
CCA1. Si l’adversaire n’a accès à cet oracle que pendant la première phase du jeu, avant de
transmettre le couple de messages (m0 , m1 ), on parle d’attaque à cryptogramme choisi de niveau
1, notée CCA1.
CCA2. Si l’adversaire a accès à l’oracle de déchiffrement D pendant les deux phases du jeu, y
compris après avoir reçu le cryptogramme de la part de l’environnement, on parle alors d’attaque
à cryptogramme choisi de niveau 2, notée CCA2.
Le niveau standard de sécurité admis pour considérer qu’un schéma de chiffrement est sûr, et qui
est noté CCA, est l’attaque de niveau 2 : CCA = CCA2.
m0 , m1 A1
1 phase
D b ← {0, 1}
c
b
A2 2e phase
D si CCA2
b0
?
ère
Schéma de l’attaque contre l’indistinguabilité
67
68
Chiffrement à clé publique
§ IX.2
Historique
En 1991, Naor et Yung ont proposé une méthode pour construire un schéma de chiffrement résistant
aux attaques à cryptogramme choisi à partir de schéma de chiffrement qui sont seulement résistants
contre les attaques à clair choisis.
Le principe de la méthode est d’utiliser deux algorithmes de chiffrement E1 et E2 , chacun agissant
sur les messages respectifs m1 et m2 , le tout étant assorti d’une preuve sans divulgation et non
interactive que les messages m1 et m2 sont égaux au message m à chiffrer. Le message m est chiffré
deux fois :
E(m) = E1 (m1 ), E2 (m2 ), NIZK(m1 = m2 = m) ,
où NISZ désigne un schéma de preuve sans divulgation non interactive (Non Interactive Zeroknowledge Proof).
Pour construire un chiffré valide, il faut fournir la preuve que les deux cryptogrammes E1 (m1 ) et
E2 (m2 ) proviennent bien du même message m. L’objectif de la preuve est de neutraliser l’accès
à l’oracle de déchiffrement en rendant difficile la construction de chiffrés valides. L’oracle ne rend
de réponse correcte que si le chiffré est bien construit. Et dans ce cas, il renvoie à l’adversaire le
message qu’il vient de chiffrer, ce qui ne lui apporte aucune information. Dans le cas où l’adversaire
tente de tromper l’oracle en fournissant deux cryptogrammes qui ne proviennent pas forcément du
chiffrement d’un même message, l’oracle rendra une réponse hh chiffré invalide ii, qui n’apporte
aucune information non plus. C’est ainsi que ce schéma est prouvé CCA1. Mais les preuves sans
divulgation sont malléables. Par exemple, après transmis son défi (m1 , m2 ), l’adversaire reçoit :
cb = E1 (mb,1 ), E2 (mb,2 ), N IZK(mb = mb,1 = mb,2 ) ,
l’adversaire peut laisser identiques les deux cryptogrammes E1 (mb,1 ) et E2 (mb,2 ), et construire
une autre preuve correcte P 0 que mb = mb,1 = mb,2 . En demandant à l’oracle le déchiffrement de
c0b = E1 (mb,1 ), E2 (mb,2 ), P 0 ,
l’oracle lui donne directement m0b , ce qui lui permet à coup sûr de rendre la bonne valeur du bit b.
Il est possible de construire des schémas de chiffrement CCA2-surs avec ce principe en utilisant
une preuve sans divulgation interactive, et en la rendant non-interactive. Une preuve interactive
peut être transformée en preuve non interactive lorsque le prouveur et le vérifieur partagent une
même séquence aléatoire (crs Common Random String) qui simule l’interaction dans la preuve.
Toutefois, les constructions obtenues sont très peu efficaces, nécessitent des permutations à sens
unique avec trappe améliorées (ETP Ehanced Trapdoor Permutation).
Pour atteindre des schémas CCA2-surs efficaces, Bellare et Rogaway, ont eu recours à la notion
d’oracle aléatoire. Il s’agit d’une vision idéale d’une fonction de hachage. Cela correspond à une
fonction aléatoire, dont les valeurs seraient comme tirées aléatoirement, mais bien sûr, s’agissant
d’une fonction, la même valeur est retournée pour le même paramètre.
Cela a aboutit en  au schéma OAEP (Optimal Asymetric Ecryption Padding) , où une quantité
aléatoire est ajoutée au message, puis brouillée par un schéma de Feistel à deux tours comme
schématisé ci-après :
m||Ok
?
+n
R
- H
G ?
- +n
?
?
Fonction à sens unique à trappe
§ IX.3
CPA-sécurité sémantique du schéma ElGamal
Dans ce schéma, les fonctions F et G sont supposées être des oracles aléatoires. La partie gauche
du schéma de Feistel est constituée du message m, complété par des zéros pour avoir la taille
convenable, et la partie droite est constituée d’une quantité aléatoire R de la taille convenable.
Lorsque la fonction à sens unique avec trappe est le RSA, ce schéma est standardisé pour la sécurité
de l’internet dans les normes ANSI X9.44, IEEE P1363 et SET.
Ce schéma a été présenté comme CCA2-sûr, mais sans donner de preuve jusqu’en , où Victor
Shoup a présenté une attaque contre ce schéma avec une fonction à sens unique avec trappe
particulière. Une semaine après, il apporte la preuve de la sécurité CCA2, à condition que la
fonction de chiffrement utilisée soit à sens unique partielle, c’est- ?-dire qu’on ne puisse pas calculer
la partie gauche de l’entrée à partir de la sortie. E. Fujisaki, T. Okamoto, D. Pointcheval et
J. Stern ont finalement prouvé en  que la fonction RSA satisfait cette propriété d’être à sens
unique partielle, pouvant finalement la sécurité CCA2 du standard OAEP-RSA. En , D.H.
Phan et D. Pointcheval ont prouvé qu’avec un schéma de Feistel à trois tours au lieu de
deux, d’une part la fonction de chiffrement n’a plus besoin d’avoir la propriété d’être à sens unique
partielle, toute fonction à sens unique avec trappe convient, mais la redondance R devient inutile.
Toutefois, cette sécurité n’est assurée que si les fonction G et H utilisées sont des oracles aléatoires,
ce qui est une hypothèse considérée comme trop forte. L’objet de la suite est de présenter une
solution au problème du chiffrement à clé publique qui ne repose pas sur le modèle de l’oracle
aléatoire. Si les fonctions requises pour réaliser le chiffrement ont seulement des propriétés de
résistance aux collisions ou sont à sens unique, on parle alors de modèle standard.
§ IX.3
CPA-sécurité sémantique du schéma ElGamal
Rappelons la définition du chiffrement ElGamal. Soit un groupe G, cyclique d’ordre q, où q est
un nombre premier. Soit g un générateur de G, de telle sorte que G = (g).
– La clé privée est un élément x, choisi aléatoirement dans Z/qZ.
– La clé publique est l’élément p = g x .
– L’espace des messages est le groupe G. Le chiffrement d’un message m ∈ G procède ainsi :
– Choisir un élément r aléatoire dans Z/qZ.
– Le cryptogramme est constitué du couple (c1 , c2 ), où c1 = g r et c2 = pr × m.
c2
c2
– À partir du cryptogramme (c1 , c2 ), le message m se retrouve par m = x . En effet, x =
c1
c1
pr × m
g xr × m
=
= m.
x
gr
g rx
Sous l’hypothèse de la difficulté de ce qu’on appelle le problème Diffie-Hellmann décisionnel
(DDH Decision Diffie-Hellman), ce schéma de chiffrement est sémantiquement sûr dans une attaque
à clairs choisis.
L’hypothèse DDH signifie que le problème de décision Diffie-Hellmann est difficile, c’est- ?-dire
qu’il est difficile de distinguer les deux quadruplets :
(g, g x , g y , g xy )
et
(g, g x , g y , s),
où z est un élément aléatoire de G. Cela signifie qu’il est difficile de décider si une donnée z est
ou non égal à g xy lorsqu’on connait g, g x et g y . Cette hypothèse équivaut à l’indistinguabilité
calculatoire des deux quadruplets :
(g1 , g2 , g1x g2x )
et
0
(g1 , g2 , g1x g2x ),
où g1 et g2 sont des éléments du groupe G et les éléments x et x0 de Z/qZ sont distincts.
La suite de ce paragraphe décrit le principe de la preuve. On construit un algorithme B, qui
résout le problème DDH en utilisant un adversaire A contre le schéma de chiffrement ElGamal.
L’algorithme B a pour entrée le quadruplet (g, g x , g y , Z), et il doit décider si oui ou non on a
69
70
Chiffrement à clé publique
Z = g xy . Pour cela, il dispose d’un adversaire A contre l’indistinguabilité du schéma de chiffrement
ElGamal. L’algorithme B va exploiter l’adversaire A en simulant l’environnement qui lui permet
de travailler.
(g, g x , g y , Z)
?
Kpub = g x B
(m0 , m1 )
cb = (g r , y r × mb )
A
b0
b = b0
?
La clé publique que B fournit à l’adversaire A est y = g x . Si la composante Z vient de Z = g xy , alors
la situation est parfaite pour l’adversaire A qui sait répondre avec un avantage non négligeable. Á
l’opposé, si Z est aléatoire, le chiffré est parfaitement aléatoire et donc A n’a aucun avantage. Il
ne peut répondre correctement qu’avec une probabilité égale à 1/2. Il en résulte que l’avantage de
cet algorithme B pour résoudre le problème DDH est non négligeable.
On n’a pas de preuve que le schéma de chiffrement ElGamal est CCA1-sûr, mais on sait qu’il
n’est pas CCA2-sûr, car il est homomorphique. Si on sait déchiffrer le cryptogramme (R, M ), alors
on sait déchiffrer aussi le cryptogramme R, k × M ) (voir exercice 2).
§ IX.4
Chiffrement CCA-sûr dans le modèle standard
IX.4.1.
Principe général
Le schéma de Cramer-Shoup a été conçu comme une évolution du chiffrement ElGamal de
manière à pouvoir établir la preuve de sa sécurité dans une attaque à cryptogrammes choisis CCA2
dans le modèle standard, c’est- ?-dire sans avoir recours à des oracles aléatoires. En reprenant la
preuve du paragraphe précédent, l’objectif, pour l’algorithme B est de pouvoir résoudre le problème
DDH en utilisant un adversaire qui peut avoir accès à un oracle de déchiffrement. Il va simuler la
possession de la clé privée de manière à pouvoir répondre aux requêtes de déchiffrement formulées
par l’adversaire A pendant les deux phases de son travail : avant et après la production du défi
(m0 , m1 ).
Selon la méthodologie de Naor et Yung, le cryptogramme ressemblera à quelque chose comme :
c = (g1r , g2r , y r × m, . . .),
avec une preuve que ce chiffré est valide, c’est- ?-dire que les deux premières composantes sont
construites à partir du même aléa r.
r
Dans la méthodologie de Naor et Yung, la condition de preuve non interactive sans
divulgation est trop forte. Avec cette condition, tout le monde peut effectuer la vérification.
Cela n’est pas nécessaire. On a seulement besoin que le destinataire puisse effectuer cette
vérification. Or le destinataire dispose de la clé privée. Il est possible d’affaiblir la condition,
et d’avoir un modèle de preuve uniquement pour un vérifieur désigné (designated verifier). Pour
ce modèle, il est possible de dégager une méthodologie générale.
§ IX.4
Chiffrement CCA-sûr dans le modèle standard
IX.4.2.
Preuve avec vérifieur désigné
Le problème DDH peut s’exprimer en terme de langage. Le langage DDH est défini par :
LDDH = {g1 , g2 , g1x , g2x | x ∈ Z/qZ}.
Il est formé des mots qui sont des quadruplets bien formés, c’est- ?-dire dont les deux dernières
composantes sont construites avec le même exposant x de Z/qZ. Ce langage est un sous-langage
du langage plus général :
L = {g1 , g2 , g1x , g2y | x, y ∈ Z/qZ}.
Dans L, les deux dernières composantes n’ont pas forcément le même exposant. Le problème
décisionnel Diffie-Hellmann consiste à décider si un élément de L appartient ou non au langage
LDDH .
Une preuve qu’un quadruplet (g1 , g2 , X, Y ) appartient au langage LDDH est l’élément x. Cet
élément s’appelle un témoin. Il permet de vérifier que X = g1x et Y = g2x .
L’élément x est un témoin qui permet à tous de vérifier l’appartenance d’un mot au langage LDDH .
Pour rendre la preuve réservée à un vérifieur désigné, il suffit de chiffrer ce témoin pour que sa
valeur ne soit accessible qu’au détenteur de la clé privée correspondante.
En remplaçant la preuve non interactive par une preuve pour un vérifieur désigné, l’adversaire
ne peut pas jouer avec un cryptogramme qui n’appartient pas au langage L. Sur une requête de
déchiffrement, soit le cryptogramme n’est pas valide et il n’apprend rien, soit le cryptogramme est
bien formé, mais alors c’est qu’il a été chiffré correctement et l’adversaire connait la réponse, il
n’apprend rien non plus.
IX.4.3.
Système universel de preuve
Définition IX.1 [système de preuve]
Un système de preuve (HPS Hash Proof System) pour un langage L consiste en trois
algorithmes :
1. Gen(1k ) est un algorithme de génération, où k est un paramètre de sécurité est qui produit
une chaine aléatoire crs (Common Random Strinbg) et une clé de trappe tk (Trapdoor
Key).
2. P(y, x, crs) est le prouveur. Il produit une donnée π à partir du témoin.
3. V(y, tk) est le vérifieur. Il produit une donnée π 0 à partir de la clé de trappe tk.
r
Le prouveur utilise le témoin x pour établir la preuve, alors que le vérifieur utilise la clé de
trappe pour le même usage.
Les propriétés requises pour un système de preuve sont :
1. La correction : si le mot y appartient au langage L, alors le prouveur et le vérifieur produisent
la même donnée avec certitude, c’est- ?-dire Prob[π = π 0 ] = 1.
2. La t–universalité : Si t mots y1 , . . . , yt n’appartiennent pas au langage L, alors la donnée :
crs, V(y1 , tk1 ), . . . , V(yt , tkt ,
est statistiquement indistinguable d’une donnée :
crs, r1 , . . . , rt
où les ri sont des aléas véritables.
Ainsi, le prouveur P pourra produire une preuve π qu’un mot y appartient à L que seul le vérifieur
V pourra vérifier avec sa clé privée tk. Si l’élément y n’appartient pas à L la vérification échouera.
Donnons maintenant deux exemples de schémas de preuve 1–universel et 2–universel.
71
72
Chiffrement à clé publique
Un schéma de preuve 1–universel reposant sur DDH
Considérons le schéma de preuve suivant : pour un paramètre de sécurité k, on a un nombre q
premier dont l’écriture binaire comprend k chiffres. Soit G un groupe cyclique d’ordre q et soient
g1 et g2 deux éléments quelconques de G∗ . Comme q est premier, ce sont des générateurs du groupe
G. Posons g2 = g1ω .
La fonction de génération Gen(−1k ) produit la clé de trappe tk = (x1 , x2 ) où x1 et x2 sont des
éléments aléatoires de Z/qZ, ainsi que la chaı̂ne aléatoire c = g1x1 g2x2 .
Le langage LDDH est constituée des mots de la forme (g1r , g2r ), pour r ∈ Z/qZ. La valeur de r est le
témoin d’appartenance à LDDH . Ce langage est un sous-ensemble du langage L constitué de tous
les couples de G × G. Pour un élément y = (u1 , u2 ) de L, où u1 = g1r et u2 = g2r , le témoin r et la
chaine aléatoire c, le prouveur P renvoie la donnée :
P(y, r, c) = cr .
À partir de la clé de trappe tk et de l’élément y = (u1 , u2 ) de L, le vérifieur V calcule la donnée :
V(y, tk) = ux1 1 ux2 2
Montrons que ce schéma de preuve satisfait les propriétés requises. Ce schéma est correct, car pour
un élément du langage LDDH , c’est- ?-dire si y = (u1 , u2 ) = (g1r , g2r ) ∈ LDH , alors on a
V(y, tk) = ux1 1 ux2 2 = (g1x1 g2x2 )r = cr = P(y, r, c).
Pour prouver la 1–universalité, il faut montrer que si le couple (u1 , u2 ) n’appartient pas à LDDH ,
alors, si x1 est x2 sont choisis aléatoirement, le couple c, ux1 1 ux2 2 n’est pas distinguable d’un
couple c, r) où r est un véritable aléa. Comme (u1 , u2 ) n’appartient pas à LDDH , il est le résultat
de u1 = g1r1 x1 et u2 = g2r2 x2 , avec r1 6= r2 . Pour cela, montrons que la fonction :
f : (x1 , x2 ) 7−→ g1x1 g2x2 , g1r1 x1 g2r2 x2
est injective. En passant aux exposants, cela revient à montrer que la fonction :
(x1 , x2 ) 7−→ x1 + ωx2 , r1 x1 + ωr2 x2 ,
1
ω
ce qui est le cas, car cette fonction est linéaire de matrice
, dont le déterminant vaut
r1 ωr2
ω(r2 − r1 ) et n’est donc pas nul. La fonction f étant injective, si x1 et x2 sont aléatoires, alors la
valeur f (x1 , x2 ) l’est aussi, ce qui achève de démontrer que le schéma de preuve présenté dans ce
paragraphe a la propriété de 1–universalité.
Un schéma de preuve 2–universel
La construction précédente s’applique aussi pour construire un schéma de preuve 2–universel, en
doublant les données. Il faut aussi disposer d’une fonction h : G × G −→ Z/qZ résistante aux
collisions. Considérons le schéma de preuve suivant :
La fonction Gen(1k ) génère quatre éléments aléatoires x1 , x2 , y1 et y2 de Z/qZ. À partir de ces
quatre éléments, la chaı̂ne aléatoire est crs = (c, d) avec c = g1x1 g2x2 et d = g1y1 g2y2 . La clé de trappe
tl est tk = (x1 x2 , y1 y2 ).
Le prouveur P, à partir d’un élément (u1 , u2 ) = (g1r , g2r ) du langage LDDH , du témoin r et de la
chaı̂ne aléatoire crs, calcule la donnée donnée par :
P(u1 , u2 , r, crs) = cr drα ,
où α = h(u1 , u2 ) est l’image par la fonction de hachage h de l’élément (u1 , u2 ) du langage.
§ IX.4
Chiffrement CCA-sûr dans le modèle standard
La fonction de vérification est donnée par :
V (u1 , u2 , tk = (ux1 1 ux2 2 )(uy11 uy22 )α .
Vérifier que ce schéma de preuve est correct est immédiat. Il suffit de montrer que si (u1 , u2 ) ∈ LDDH
alors P(u1 , u2 , r, crs) = V (u1 , u2 , tk), ce qui découle directement des expressions de P et V.
Pour montrer la 2–universalité, considérons deux mots y e y 0 qui appartiennent au langage L sans
appartenir au langage LDDH , c’est à dire qu’on a y = (u1 , u2 ) avec u1 = g1r1 , u2 = g2r2 et r1 6= r2 .
r0
r0
De même, on a y 0 = (u01 , u02 ) avec u01 = g11 , u02 = g22 et r10 6= r20 . Il
faut alors montrer que le
triplet crs, V(y, tk), V(y 0 , tk) est indistinguable d’un triplet crs, r, r0 où r et r0 sont des données
aléatoires. Pour montrer cela, comme au paragraphe précédent, montrons que la fonction :
r 0 x +α0 r10 y1 r20 x2 +α0 r20 y2 ,
g2
f ; (x1 , x2 , y1 , y2 ) 7−→ g1x1 g2x2 , g1y1 g2y2 , g1r1 x1 +αr1 y1 g2r2 x2 +αr2 y2 , g11 1
est injective, où α = h(u1 , u2 ) et α0 = h(u01 , u02 ). En passant aux exposants et en remplaçant g2
par g1ω , montrer que f est injective revient à montrer que la matrice :


1
ω
0
0
0
1
ω 
0
M =

r1 ωr2 αr1 αωr2
r10 ωr20 α0 r10 α0 ωr20
est inversible. Le déterminant de la matrice M vaut :
det(M ) = ω 2 (r2 − r1 )(r20 − r10 )(α − α0 ).
Comme on a r1 6= r2 et r10 6= r20 , le déterminant est nul si et seulement si α = α0 , c’est- ?-dire si on
a une collision sur la fonction de hachage h.
IX.4.4.
Un chiffrement CCA-sûr
Ce paragraphe présente la construction d’un chiffrement CCA-sûr. Le problème difficile sous-jacent
est celui de distinguer l’appartenance ou non d’un mot y à un langage L. On suppose également
qu’on a les systèmes de preuves suivants avec les propriétés indiquées :
– le système (Gen, P, V) a la propriété de 1–universalité pour le langage L ;
– le système (Gen0 , P0 , V0 ) a la propriété de 2–universalité pour le langage L0 = L||{0, 1}n .
Les mots du langage L0 sont la concaténation des mots du langage L avec n’importe quelle étiquette
constituée de n symboles binaires.
Définissons le système de chiffrement à clé publique (GenE , Enc, Dec) :
– Génération des clés GenE (1k ) pour le paramètre de sécurité k :
– Soit (crs, tk) ← Gen(1k ).
– Soit (crs0 , tk0 ) ← Gen0 (1k ).
– La clé publique Kpub est (crs, crs0 ).
– La clé privée Kpriv est (tk, tk0 ).
– Chiffrement EncKpub (m) :
– Choisir un élément y dans le langage L avec un témoin x.
– La clé de session est π = P(t, x, crs). Le message m est masqué avec cette clé de session comme
un masque jetable : c = m ⊕ π.
– Soit π 0 = P(y||c, x, crs0 ).
– Le cryptogramme est C = (y, c, π 0 ).
– Déchiffrement DecKpriv (y, c, π 0 ) :
– Calculer π
e = V(y, tk)
– Calculer π
e0 = V0 (y||c, tk).
– Vérifier si π = π 0 . Si ce n’est pas le cas, signifier l’échec du déchiffrement. Si c’est le cas, alors
retourner m0 = π
e ⊕ c.
73
74
Chiffrement à clé publique
Preuve. La preuve de la sécurité CCA de ce système de chiffrement considère des jeux.
Le jeu 0 est le jeu réel. L’adversaire A peut accéder à l’oracle de déchiffrement, et celui-ci fournit
les bonnes réponses conformément à la définition du schéma de chiffrement :
L’adversaire fournit un défi (m0 , m1 ). L’environnement choisit un bit b aléatoire dans {0, 1}, un
élément y du langage L avec un témoin x, calcule les données P(y, x, crs) = π et P0 (y||c, x, crs0 ) = π 0 .
Il fournit le cryptogramme C = (y, c, π 0 ), où c = m ⊕ π. L’objectif de l’adversaire A est de trouver
la valeur du bit b.
Le Jeu 1 est semblable au jeu 0, mais au lieu de calculer les données π et π 0 par les prouveurs P
et P0 , ces données vont être crées par le vérifieur avec la clé de trappe tk. Le calcul des données π
et π 0 se fait ainsi : V(y, tk) = π et V0 (y||c, tk0 ) = π 0 .
Les jeux 0 et 1 sont identiques, car comme y appartient au langage L, les valeurs π et π 0 calculées
au cours de ces deux jeux sont les mêmes. La différence réside dans le fait que, dans le jeu 1, le
simulateur de l’environnement dispose de la clé privée et n’a plus besoin du témoin de y.
Dans le jeu 2, le cryptogramme est calculé avec un élément y qui n’appartient pas au langage L. Les
défis des jeux 1 et 2 sont indistinguables, à cause de la propriété d’indistinguabilité d’appartenance
au langage L. La question est de savoir si les requêtes ont plus de chance d’être invalides dans le
jeu 1 ou dans le jeu 2.
Notons DecInv l’évènement hh le cryptogramme est invalide mais passe le test de validité ii. C’est le
cas si l’adversaire A pose un cryptogramme invalide avec y 6∈ L, mais qui passe la vérification, car
π
e0 = π 0 .
Dans le jeu 1, comme la valeur de V(y, tk) est aléatoire, la probabilité de cet évènement est
négligeable, égale à l’inverse du cardinal de l’ensemble d’arrivée.
Dans le jeu 2, c’est différent, car l’adversaire reçoit V(y, tk) pour y 6∈ L. C’est la 2–universalité qui
rend la probabilité de l’évènement DecInv négligeable.
Si l’adversaire pose à l’oracle un cryptogramme C ∗ = (y ∗ , c∗ , π 0∗ ) avec y ∗ = y et c∗ = c, alors
nécessairement π 0∗ 6= π 0 , car la question posée à l’oracle doit être différente du défi, et dans ce cas,
la vérification rejette le cryptogramme.
Un cryptogramme invalide qui passe la vérification doit nécessairement vérifier (y ∗ , c∗ ) 6= (y, c). Si le
cryptogramme C ∗ passe la vérification, c’est que π 0∗ = V0 (y ∗ ||c∗ , tk), mais comme les éléments y et
y ∗ n’appartiennent pas au langage L, en raison de la 2–universalité, le couple (y, c, π 0 ), (y ∗ , c∗ , π 0∗ )
est constitué de composantes aléatoires, et le test passe avec une probabilité négligeable.
Si A pose des cryptogrammes valides, cela se passe comme dans le jeu 1.
Par conséquent, l’avantage de l’adversaire A entre le jeu 1 et le jeu 2 change d’une quantité
négligeable.
Dans le jeu 3, on remplace la composante c = π ⊕ mb dans le défi par un aléa. Statistiquement, le
jeu 3 est comme le jeu 1, et dans le jeu 3, l’avantage de l’adversaire est nul.
IX.4.5.
Le chiffrement Cramer-Shoup
Le chiffrement de Cramer-Shoup est la construction de la section précédente avec les schémas de
preuve 1–universel et 2–universel du paragraphe IX.4.3. Ce système de chiffrement opère dans un
groupe G, cyclique dont l’ordre q est un nombre premier. Soient g1 et g2 deux générateurs de ce
groupe. Soit également une fonction h : G × G −→ Z/qZ supposée sans collision.
La clé privée est la clé de trappe, constituée de six éléments aléatoires x1 , x2 , y1 , y2 , z1 et z2 de
Z/qZ.
La clé publique correspondante est le triplet (c, d, h) de G3 , où c = g1x1 g2x2 , d = g1y1 g2y2 ry h = g1z1 g2z2 .
r
Dans la clé privée, les quatre éléments x1 , x2 , y1 et y2 sont la clé de trappe d’un système de
preuve, et le couple (c, d) est la chaine aléatoire commune.
Pour chiffrer un message m de G, on choisit un élément aléatoire r dans Z/qZ, puis on calcule
u1 = g1r et u2 = g2r , puis e = hr × m. On pose α = h(u1 u2 , e) et v = cr drα . Le cryptogramme est
constitué du quadruplet C = (u1 , u2 , e, v).
§ IX.5
r
Exercices
La donnée e est l’étiquette définissant les mots du langage L0
Pour déchiffrer ce cryptogramme, on vérifie tout d’abord si v est ou non égal à ux1 1 ux2 2 (uy11 uy22 )α ,
avec α = h(u1 u2 , e). Si non, on déclare l’échec du déchiffrement, et si oui, on retourne le clair
e/uz11 uz22 .
§ IX.5
Exercices
1. Écrire en détail la preuve de la sécurité CPA du schéma de chiffrement ElGamal sous
l’hypothèse de la difficulté du problème Diffie-Hellmann décisionnel.
2. Trouver une attaque contre la sécurité CCA2 du schéma de chiffrement ElGamal.
Indication : Si c = (R, M ) demander le déchiffrement de (R, 2M ).
3. Démontrer que le système de chiffrement de Cramer-Shoup est correct, c’est-à-dire que la
procédure de déchiffrement retrouve bien le message clair qui a été chiffré, et qu’il est CCA-sûr
sous l’hypothèse de la difficulté du problème de décision Diffie-Hellmann.
4. Le système de Cramer-Shoup reste-t-il sûr si on détache la composante ve = (cr , drα ) dans le
cryptogramme au lieu de ne transmettre que le produit v = cr drα .
75
76
Corrigé des exercices
Corrigé des exercices
II.1. La fonction supposée à sens unique reposant sur la difficulté du logarithme discret est la
fonction puissance dans le corps Fp
– L’ensemble d’indices est l’ensemble des couples (p, g), où p est un nombre premier, et g est un
générateur du groupe multiplicatif Z/pZ∗ . Pour pouvoir trouver efficacement un générateur du
groupe multiplicatif Z/pZ, il faut connaitre la factorisation de p − 1.
– Pour un indice i = (p, g), le domaine Di est l’ensemble des entiers {1, . . . , p − 1}.
– L’algorithme S1 génère un nombre premier aléatoire p dont la factorisation de p − 1 est connue,
ainsi qu’un générateur aléatoire g. Pour tester qu’un élément g est générateur du groupe
multiplicatif Z/pZ∗ , on vérifie que rr 6= 1 pour tout r = (p − 1)/r, où r est un diviseur premier
de p − 1.
– L’algorithme S2 génère un entier aléatoire dans l’ensemble {1, . . . , p − 1}.
– Pour i = (p, g) et n ∈ {1, . . . , p − 1}, la fonction fi est n 7−→ g n mod p.
II.2. Pour la fonction RSA :
– L’ensemble d’indices est I est l’ensemble des couples (n, e), où n est un entier égal au produit de
deux nombres premiers de même taille, et où e est un exposant public valide pour n, c’est-à-dire
un entier qui est premier avec ϕ(n).
– Le domaine des fonctions Di est l’ensemble Z/nZ.
– L’algorithme S1 génère un couple (n, e). Pour cela il génère un couple de nombre premiers
aléatoires, en tirant au hasard un entier quelconque, puis en testant sa primalité. Cette façon de
faire est de complexité polynomiale à l’aide par exemple du test de primalité de Miller-Rabin,
ainsi qu’en raison de la densité des nombres premiers donnée par le théorème des nombres
premiers.
– L’algorithme S2 génère un élément aléatoire de Z/nZ.
– Pour i = (n, e) ∈ I, la fonction RSA fi est x 7−→ xe mod n.
r
Il n’est pas nécessaire de restreindre le domaine seulement aux éléments inversibles modulo
n. En raison du théorème chinois, les formules RSA restent valables pour tout élément de
Z/nZ. Certes, la donnée d’un élément non inversible non nul de Z/nZ permet de factoriser n, mais
trouver un tel élément est un problème difficile et la situation d’avoir à chiffrer un tel élément est
hautement improbable.
II.3. Rappelons que si P 6= N P, alors un problème N P–complet est un problème difficile dans
le pire des cas. L’idée pour cet exercice est de construire une fonction à partir d’un problème
N P–complet. Elle sera difficile à inverser dans le pire des cas, mais pourra être facile à inverser en
moyenne.
Prenons le problème 3COL du coloriage d’un graphe avec trois couleurs.
Un graphe G de n sommet est par définition une matrice n × n dont les coefficients appartiennent
à l’ensemble {0, 1}. Les coefficients égaux à 1 représentent une arrête entre deux sommets.
Un coloriage avec trois couleurs du graphe G = (gij )i,j∈{1,...,n} est une application c de l’ensemble
{1, . . . , n} des sommets vers l’ensemble {1, 2, 3} des couleurs, qui à chaque sommet associe une
couleur, et tel que deux sommets adjacents ne soient pas coloriés avec la même couleur, c’est-àdire, pour tout couple (i, j) de sommets adjacents, c’est-à-dire tels que gij = 1, on a c(i) 6= c(j).
Rappelons ces résultats :
– Si on sait qu’un graphe est coloriable avec trois couleurs, il est toujours difficile de trouver un
coloriage.
Corrigé des exercices
– Si on tire au hasard un graphe G et une application c, il est hautement improbable que c soit
un coloriage pour G.
Notons Mn l’ensemble des graphes de n sommets. Construisons donc la fonction suivante :
Mn × {1, 2, 3}n
f :
(G, c)
−→
M
n × {0, 1}
(G, 0) si c colorie G
7 →
−
(G, 1) sinon
Pour un couple (G, c) aléatoire, très probablement, c ne colorie pas G, et donc la valeur par f vaut
(G, 1). Dans ce cas, en renvoyant une valeur c0 elle aussi aléatoire, on aura trouvé un antécédent
par f .
Le seul cas où trouver l’antécédent sera un problème difficile sera lorsqu’il faudra chercher un
antécédent de (G, 0). Il suffira de répondre au hasard. Ce sera sûement un échec, mais cela survient
très rarement.
La fonction f n’est pas à sens unique en moyenne, mais est difficile à inverser dans le pire des cas.
r
Il est crucial comprendre que que les défis qu’un algorithme doit chercher à inverser sont des
images d’éléments aléatoires de l’ensemble de départ. S’il s’agissait d’éléments aléatoires de
l’ensemble d’arrivée, la probabilité de succès serait toujours négligeable.
II.4. Soit f une fonction à sens unique. Construisons à partir de f une fonction F à longueur
régulière. Pour cela, on complète la valeur f (x) par des zéros jusqu’à atteindre une longueur
constante pour toutes les entrées de taille n. Comme f est à sens unique, elle est calculable
efficacement et pour toute entrée de taille n, la taille de f (x) est bornée par un polynôme en
n. Soit P (n) ce polynôme connu.
La fonction F : x 7−→ (f (x), 0k ), où k = P (n) − |f (x)|, est à longueur régulière par construction.
La fonction F est aussi à sens unique, car si elle ne l’était pas, cela conduirait directement à un
algorithme pour inverser f .
II.5.
II.6.
1. Non ! Pas toujours ! Soit E = F × F et f1 une fonction à sens unique F −→ F . On montre
facilement que la fonction :
E × E −→ E × E f :
(x1 , x2 ) 7−→ f1 (x2 ), 0
est à sens unique et vérifie f ◦ f : (x1 , x2 ) 7−→ (f1 (0), 0). Et une fonction constante n’est
clairement pas à sens unique.
2. Oui. Montrons que si la fonction f est à sens unique, alors la fonction g l’est aussi. Pour cela,
montrons la contraposée. Si la fonction g n’est pas à sens unique, alors la fonction f ne l’est pas
non plus. On suppose qu’il existe un algorithme qui inverse g, et déduisons en un algorithme B
qui inverse f .
L’algorithme B prend en entrée un élément y de l’image de f .
– Calculer f (y). C’est possible car f est calculable dans le sens direct.
– Soumettre le couple y, f (y) à l’algorithme A. L’algorithme A retourne un antécédent y par
g qui est un antécédent de f .
La probabilité de succès de l’algorithme B est la même que la probabilité de succès de
l’algorithme A.
3. Oui. Comme à la question précédente, soit un algorithme A qui inverse f ◦ f et construisons un
algorithme B qui inverse f .
L’algorithme B prend en entrée un élément y de l’image de f . Il doit trouver l’unique antécédent
de y par f .
77
78
Corrigé des exercices
– Soumettre y à l’algorithme A. Soit x la valeur rendue par l’algorithme A qui est supposée
être la valeur qui vérifie f ◦ f (x) = y.
– Rendre comme résultat f (x) qui est par construction l’antécédent de y par f .
L’algorithme B donne la bonne réponse avec une probabilité égale à celle de l’algorithme A.
La différence avec la première question est que, comme f est une bijection, un élément aléatoire
du domaine de f est aussi un élément aléatoire de l’image de f , ce qui est faux si f est
III.1. Soit (N, e) la clé publique RSA. Supposons pour une contradiction qu’il existe un oracle qui
permet, pour tout message chiffré xe mod N donné, de retourner la parité de x. Montrons que cette
fonction peut être utilisée pour retrouver x tout entier à partir du cryptogramme y = xe mod N .
L’interrogation de l’oracle informe du bit de parité de x, c’est à dire de la valeur de son dernier
chiffre dans la numération en base 2.
Interrogeons maintenant l’oracle avec la valeur 2e y mod N qui vaut (2x)e mod N . Notons tout
d’abord que le dernier chiffre binaire x0 de x est l’avant dernier chiffre binaire de 2x. Il existe deux
possibilités pour 2x :
1. soit x < N/2, donc 2x < N et 2x mod N = 2x. Dans ce cas 2x mod N est pair.
2. soit x ≥ N/2, donc 2x ≥ N et 2x mod N = 2x − N . Et dans ce cas 2x − N est impair.
Dans les deux cas, on connaı̂t à la fois le dernier chiffre binaire de 2x mod N , mais aussi son avant
dernier chiffre qui vaut x0 dans le premier cas et x0 − N1 dans le second, où N1 est l’avant dernier
chiffre binaire du module N .
En interrogeant l’oracle successivement avec les valeurs 4y mod N, 8y mod N, . . ., on obtiendra
successivement trois derniers bits de 4x mod N , les quatre derniers bits de 8x, etc.
Ainsi, si la taille de x est de ` bits, en interrogeant ` fois l’oracle, on obtient finalement tous les
bits de 2`−1 x. La valeur de x est obtenue par simple division par 2`−1 modulo N .
III.2. Soit α un générateur du groupe multiplicatif (Fp , ×). Pour tout entier n, la valeur de αn est
un carré dans Fp si et seulement si n est pair. À partir d’une valeur y = αn , il est facile, avec le
symbole de Legendre par exemple, de savoir si y est un carré, et donc de savoir si n est pair.
III.3. La contraposée est quasi immédiate. Si une fonction f injective n’est pas à sens unique, alors
il existe un algorithme efficace pour trouver un antécédent x pour une valeur y donnée. Comme x
est injective, cette valeur est unique. Tout bit de b de f se calcule alors efficacement à partir de x.
q
L’hypothèse d’injectivité est cruciale. Une fonction constante n’est bien sûr pas à sens unique,
qqAA
et pourtant, toute fonction booléenne non dégénérée de l’entrée, par exemple le bit de poids
faible, est un bit difficile, puisque la connaissance de la valeur n’est d’aucune utilité pour trouver
ce bit.
IV.1. Cet exercice est destiné à montrer que, si t(n) est un polynôme en n, la concaténation t(n)
fois d’un générateur pseudo-aléatoire reste un générateur pseudo-aléatoire.
Il faut montrer que les deux variables aléatoires suivantes sont calculatoirement indistinguables :
X =
g(X1 ) , . . . , g(Xt(n) ) Y =
Y1
,...,
Yt(n)
où les Xi sont des variables aléatoires uniformes sur {0, 1}n et les Yi sont des variables aléatoires
uniformes sur {0, 1}2n .
Afin d’appliquer la technique hybride, construisons une suite de variables aléatoires Zi , pour i = 0
à t(n), telle que Z0 = X et Zt(n) = Y , et telles qu’on puisse montrer que deux termes consécutifs
Zi et Zi+1 sont calculatoirement indistinguable.
Si on arrive à majorer uniformément ∆(Zi , Zi+1 ) par une quantité négligeable ε(n), cela permettra
de conclure avec l’inégalité triangulaire :
∆(Z0 , Zt(n) ) ≤ t(n)ε(n).
Corrigé des exercices
La construction est la suivante :
Z0
Z1
Z2
..
.
=
=
=
Zt(n)−1
Zt(n)
=
=
g(X1 ) g(X2 ) · · ·
Y1
g(X2 ) · · ·
Y1
Y2
···
..
..
.
.
Y1
Y2
···
Y1
Y2
···
g(Xt(n) ) g(Xt(n) ) g(Xt(n) )
g(Xt(n) ) Yt(n)
La seule différence entre les variables Zi et Zi+1 est dans la (i − 1)e composante qui vaut g(Xi )
pour Zi et qui vaut Yi pour Zi+1 .
S’il existe un distingueur D entre Zk et Zk+1 , on en déduit donc directement
un distingueur de
même avantage entre g(Xi ) et Yi . Par conséquent ∆(Zi , Zi+1 ) ≤ ∆ g(X), Y .
IV.2.
IV.3.
IV.4.
IV.5. Considérons pour simplifier un exposant public e égal à 3. Rappelons que l’extraction des
racine cubique dans Z n’est pas un problème difficile. Il existe des algorithme efficace pour les
extraire, par exemple la méthode de newton. Soient n1 , n2 et n3 les trois modules RSA publics.
L’exercice revient à montrer que la foncion :
fn1 n2 n3 : m 7−→ (m3 mod n1 , m3 mod n2 , m3 mod n3 )
n’est pas à sens unique. La connaissance de l’image y = (m3 mod n1 , m3 mod n2 , m3 mod n3 )
permet, à l’aide du théorème des restes chinois, de trouver un élément z de Z/n1 n2 n3 Z tel que
z ≡ m3 modulo n1 n2 n3 . On suppose bien sûr que n1 , n2 et n3 sont deux à deux premiers entre
eux, sinon, le calcul de pgcd donne un facteur strict de l’un d’entre eux, ce qui suffit à inverser
la fonction RSA. Comme chaque composante m3 mod ni de y est inférieure à ni , la valeur z vaut
exactement m3 . Il suffit d’extraire sa racine cubique pour retrouver m.
IV.6.
V.1 Non ! Si la famille Fn contient des fonctions qui admettent des paramètres de taille variable,
le caractère pseudo-aléatoire de la famille n’est plus assuré. Pour montrer cela, exhibons un
distingueur sachant reconnaı̂tre un élément d’une telle famille d’une fonction aléatoire.
r
Comme la famille constituée de fonction avec une taille fixe de paramètre, le distingueur devra
interroger l’oracle avec des paramètres de taille différente.
En interrogeant l’oracle avec f (0) = y et f (00) = z, si z = g0 (y) alors f est très probablement
un élément de la famille Fn , sinon, c’est une fonction aléatoire.
q
Pour définir une famille de fonctions pseudo-aléatoires, il est crucial que les fonctions de cette
qqAA
famille opèrent sur des paramètres de taille fixe.
V.2 On suppose que pour tout entier n, la famille F = fk
p(n)
k∈{0,1}n
est une famille pseudo-aléatoire
de fonctions {0, 1}
−→ {0, 1} booléennes.
Pour construire une famille pseudo-aléatoires de fonctions vectorielles à valeurs dans {0, 1}n , le
principe est de prendre un ensemble de n fonctions booléennes qui définiront les n composantes.
79
80
Corrigé des exercices
Considérons donc la famille G = gs
s∈{0,1}n×n
, définie par :
s = (k1 , . . . , kn )
gs (x) = fk1 (x), . . . , fkn (x)
Il reste à montrer que la famille G est une famille pseudo aléatoire. Montrons cela par la technique
hybride. On construit une suite de familles de fonctions H0 , . . . , n telle que H0 = G et Hn est la
famille de fonctions vectorielles {0, 1}p(n) −→ {0, 1}n dont les n composantes sont des fonctions
booléennes alétoires. La suite de famille est construite en remplaçant à chaque fois une composante
pseudo-aléatoire de F par une composante aléatoire :
H0 = F :
x 7−→ (fk1 (x), fk2 (x), . . . , fkn (x))
H1 :
x 7−→ (h1 (x), fk2 (x), . . . , fkn (x))
H2 :
..
.
x 7−→ (h1 (x), h2 (x), . . . , fkn (x))
Hn :
x 7−→ (h1 (x), h2 (x), . . . , hn (x))
oà h1 , . . . , hn sont des fonctions booléennes aléatoires {0, 1}p(n) −→ {0, 1}.
La distance calculatoire entre deux familles Hi et Hi+1 est négligeable, car un distingueur de ces
deux familles est exactement comme un distingueur entre les composantes qui diffèrent qui sont
fki et hi , et on a supposé que la famille F des fonctions booléennes est pseudo-aléatoire.
On en déduit que la distance calculatoire Delta G, Hn entre les familles G et Hn vaut n fois
la distance calculatoire entre F et la famille des fonctions booléennes aléatoires, ce qui reste
négligeable.
V.3 Par contraposée, montrons que si la famille n’est pas une famille pseudo-aléatoire de fonctions
à sens unique, alors elle n’est pas une famille pseudo-aléatoire.
Par hypothèse, on suppose qu’il existe un algorithme A qui, étant donnée un élément y de {0, 1}n ,
est capable de trouver un antécédent x de y par un élément aléatoire fk de la famille, avec une
probabilité non négligeable, uniquement en utilisant un oracle pour déterminer les valeurs de fk
dont il a besoin pour effectuer cette tàche.
Considérons l’algorithme B qui exécute les instructions suivantes :
– Choisir un élément x aléatoire de {0, 1}n .
– Soumettre cet élément à l’oracle qui renvoie y = fk (x).
– Soumettre maintenant y à l’algorithme A qui est supposé retourner un antécédent de y. Soit x0
l’élément de {0, 1} retourné par l’algorithme A.
– Soumettre à nouveau x0 à l’oracle qui retournera y 0 = f (x0 ).
– Si y = y 0 alors l’algorithme A a réussit. Il y a de fortes chances que l’oracle réalise un élément de
la famille pseudo-aléatoire. Dans ce cas, l’algorithme B rend 1 pour signifier que l’oracle réalise
une fonction pseudo-aléatoire.
Sinon, il y a de fortes chances aussi pour que l’oracle réalise une fonction parfaitement aléatoire,
l’algorithme rend 0 pour signifier que l’oracle réalise une fonction aléatoire.
Il reste des détails de calcul pour vérifier que si l’avantage de l’algorithme A n’est pas négligeable,
alors l’avantage de l’algorithme B n’est pas négligeable non plus.
r
Par un raisonnement similaire, on peut montrer qu’une famille de fonctions pseudo-aléatoire
cache tous les bits des entrées. Un adversaire ne peut déterminer un bit f (x) d’un antécédent
x d’un élément y qu’avec une probabilité négligeable.
VI.1 a) La preuve est directe : f2 ◦ i(x) = i(x) ⊕ i ◦ i(x) = i(x) ⊕ x = f2 (x).
Corrigé des exercices
b) On a L3 = L1 + f2 (R1 ), mais L1 = R0 , donc L3 = R0 + f2 (R1 ). On peut utiliser la question
a) pour trouver deux requêtes telles que R0 = R00 . Pour avoir L3 = L03 , il faut f2 (R1 ) = f2 (R10 ).
Prendre R1 = R10 ne convient pas, car cela conduirait à L0 = R00 . Par contre, on peut chercher à
avoir R10 = i(R1 ). D’après la question a), ces deux valeurs ont la même image par f2 .
Cela impose comme condition R10 = i(R1 ) = R1 ⊕ f2 (R1 ) = R1 ⊕ L3 ⊕ R0 d’une part, et
R10 ⊕ R1 = L0 + ⊕L00 d’autre part. Si on choisit L00 = R0 ⊕ L0 ⊕ L3 , alors on aura L3 = l30 .
L’algorithme A pour discerner entre un tel schéma F et une foncion aléatoire R est donc le suivant :
1. Poser une requête (L0 , R0 ). Soit (L3 , R3 ) la réponse.
2. Pouser une seconde requête (L0 0, R00 ) avec R00 = R0 et L00 = L0 ⊕ R0 ⊕ L3 . Soit (L03 , R30 ) la
réponse.
3. Si L3 = L3 , alors rendre 1 pour décider que l’oracle est un shéma F, sinon, rendre 0 pour
décider que l’oracle est un shcéma R.
Estimons l’avantage d’un tel algorithme.
AdvA = Prob AF = 1 − Prob AR = 1 ,
F
oà Prob
RA
= 1 est la probabilité que l’algorithme A réponde 1 en présence d’un schéma F et
Prob A est la probabilité que l’algorithme A réponde 1 en présence d’une fonction aléatoire R.
Si l’oracle est un shéma F,
répond toujours correctement, car on a toujours L3 = L03
l’algorithme
F
dans ce cas l ?, donc Prob A = 1 = 1.
L’algorithme échoue en face d’un oracle qui est une fonction aléatoire si R0 = L3 , car dans ce
cas, la deuxième requête sera identique à la première, ou si fortuitement, L3 = L03 . Partageons
l’évènnement hh AR = 1 ii selon que L3 est ou non égal à R0 .
Prob AR = 1 = Prob AR = 1 | R0 = L3 × Prob R0 = L3 −
{z
} |
{z
}
|
≤1
1
= n
2
R
Prob A = 1 | R0 6= L3 × Prob R0 6= L3
|
{z
} |
{z
}
1
≤1
= n
2
En effet, si la fonction est aléatoire, la probabilité d’avoir R0 = L3 vaut 1/2n , et si l’oracle est une
fonction aléatoire, la probabilité que l’algorithme réponde 1 est la probabilité que fortuitement, on
ait L3 = L03 qui vaut aussi 1/2n . L’avantage de l’algorithme A vaut donc 1 − 1/2n−1 qui est proche
de 1, et donc non négligeable.
VI.2 La famille (Gn ) est une famille de bijections, car l’image réciproque par gk du vecteur
(y0 , . . . , yn ) est le vecteur (x0 , . . . , xn−1 , x0 ⊕ yn ), oà (x0 , . . . , xn−1 ) est l’image réciproque par
fk du vecteur (y0 , . . . , yn−1 ).
Si une famille de fonctions ou de permutations n’est pas pseudo-aléatoire, c’est qu’il existe une
relation prévisible entre les entrées et les sorties. Une fois cette relation trouvée, il est facile
d’élaborer un altorithme qui distinguera cette famille d’une famille de fonctions aléatoires. Dans
le cas de cet exercice, la première composante de la valeur vaut toujours x0 ⊕ b, ce qui suggère
immédiatement l’algorithme suivant :
1. Soumettre une requête quelconque (x0 , . . . , xn−1 , b). Soit (y0 , . . . , yn ) la réponse.
2. Si yn = x0 ⊕ b alors retourner 1 pour signifier le l’oracle réalise la famille G de l’énoncé. Sinon,
retourner 0 pour signifier que l’oracle réalise une permutation aléatoire.
L’avantage de cet algorithme est
1
AdvA = ProbF ∈R R AF = 1 − ProbF ∈R G AF = 1 =
2
{z
} |
{z
}
|
=1
= 1/2
81
82
Corrigé des exercices
En effet, cet algorithme donne une réponse toujours juste si l’oracle réaliser un élément de la famille
G, et si l’oracle est une permutation aléatoire, il se peut que fortuitement on ait yn = xn−1 ⊕ b,
auquel cas l’algorithme donne une fausse réponse, et cela survient avec une probabilité égale à 1/2.
VII.1
VII.2
VII.3
VII.4
VII.5
VII.6
VIII.1
VIII.2
Index alphabétique
Index alphabétique
Algorithmica
–A–
. . . . . . . . . . . . . . . . . . . . 53.
–C–
CBC
mode — . . . . . . . . . . . . . . . . . . . . . .
— MAC . . . . . . . . . . . . . . . . . . . . . .
CCA . . . . . . . . . . . . . . . . . . . . . . . . . .
Cryptomania . . . . . . . . . . . . . . . . . . . .
44.
48.
67.
54.
–D–
distance calculatoire . . . . . . . . . . . . . . . 21.
–E–
ECB
mode —
. . . . . . . . . . . . . . . . . . . . . . 44.
–F–
famille
— de fonctions pseudo-aléatoire . . . . 27.
— de permutations pseudo-aléatoire . 32.
fonction
— négligeable . . . . . . . . . . . . . . . . . . . 9.
— à sens unique asymptotique . . . . . 10.
Feistel
shéma de — . . . . . . . . . . . . . . . . . . . 33.
–G–
générateur pseudo-aléatoire (GPA) . . . . 20.
–H–
Heuristica . . . . . . . . . . . . . . . . . . . . . . . 53.
hybride
procédé — de démonstration . . . . . . 24.
–I–
indistinguabilité . . . . . . . . . . . . . . . . . . 39.
–L–
Luby – Rackoff . . . . . . . . . . . . . . . . 34.
–M–
MAC . . . . . . . . . . . . . . . . . . . . . . . . . . 46.
malléabilité . . . . . . . . . . . . . . . . . . . . . 45.
Minicrypt . . . . . . . . . . . . . . . . . . . . 53, 64.
mode
— CBC . . . . . . . . . . . . . . . . . . . . . . 44.
— ECB . . . . . . . . . . . . . . . . . . . . . . . 44.
monoı̈de libre . . . . . . . . . . . . . . . . . . . . . 9.
–O–
oracle aléatoire . . . . . . . . . . . . . . . . . . . 68.
–P–
Paillier
chiffrement de — . . . . . . . . . . . . . . .
Pessiland . . . . . . . . . . . . . . . . . . . . . . .
pince (de bijection) . . . . . . . . . . . . . . .
preuve sans divulgation . . . . . . . . . . . .
problème
— 3COL . . . . . . . . . . . . . . . . . . . . . .
26.
53.
66.
19.
76.
–S–
sémantique
sécurité —
. . . . . . . . . . . . . . . . . . . . 38.
–Z–
zero knowledge . . . . . . . . . . . . . . . . . . . 19.
83