t PARIS 8 q q UN I V E R S I T É Vincennes-Saint-Denis UFR 6 – MITSIC Mathématiques, Informatique, Technologies, Sciences de l’Information et de la Communication Preuves de sécurité des schémas cryptographiques Hieu Phan & Philippe Guillot octobre Master Mathématiques Fondamentales et Protection de l’Information Sommaire 3 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 chapitre I. Rappels de théorie de la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 § 1. Machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 2. Problèmes P, problèmes N P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 3. Problèmes N P–complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 7 7 Sommaire chapitre II. Fonctions à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 § 1. Fonction à sens unique concrète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 2. Fonction à sens unique asymptotique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 9 12 chapitre III. § § § § 1. 2. 3. 4. Bits difficiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Théorème de Goldreich-Levin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 14 18 19 chapitre IV. § § § § § 1. 2. 3. 4. 5. Générateurs pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Approche intuitive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Indiscernabilité calculatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Générateur pseudo aléatoire avec expansion d’un bit . . . . . . . . . . . . . . . . . . . . . . . . . Générateur pseudo-aléatoire avec expansion polynomiale . . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 21 22 23 25 chapitre V. Fonctions pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 § 1. Motivation et définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 2. Construction d’une famille de fonctions pseudo-aléatoires . . . . . . . . . . . . . . . . . . . . . . § 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 28 30 chapitre VI. Permutations pseudo-aléatoires ............................... 32 § 1. Motivation et définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 2. Construction à partir d’une famille de FPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . § 3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 33 36 4 Sommaire chapitre VII. Chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Schéma de chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notions de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Modèles d’attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Construction d’un schéma de chiffrement IND–CPA . . . . . . . . . . . . . . . . . . . . . . . . . . Chiffrement de messages de tailles variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Malléabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codes d’authentification de message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chiffrement CCA-sûr générique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 37 41 42 44 45 46 50 51 chapitre VIII. Signatures numé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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Définition et sécurité des signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le paradigme de Fiat-Shamir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La signature hh une fois ii de Lamport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Une signature hh plusieurs fois ii avec état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonction de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le paradigme hh hache puis signe ii. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions de hachage universelles à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . chapitre IX. 53 54 55 56 57 59 61 64 65 Chiffrement à clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . CPA-sécurité sémantique du schéma ElGamal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chiffrement CCA-sûr dans le modèle standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 68 69 70 75 Corrigé des exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Index alphabétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 § § § § § 1. 2. 3. 4. 5. Introduction Introduction Dans l’approche classique de la conception de schémas cryptographiques sûr, un concepteur propose une fonction de chiffrement. Elle est soumise à la sagacité de la communauté cryptographique qui va tenter de développer des attaques en identifiant des faiblesses. Si ces faiblesses sont avérées, le schéma est déclaré comme non-sûr. Éventuellement des modifications du schéma initial sont proposées par le concepteur. Le nouveau schéma est à nouveau soumis aux attaques de la communauté qui pourra à nouveau découvrir d’éventuelles faiblesses. Finalement, la communauté accepte la sécurité du schéma si aucune faiblesse critique n’a été mise en évidence par les travaux des cryptanalystes pendant un certain temps. Cette approche a montré ses limites. Au bout de combien de temps la sécurité soit-elle être acceptée ? trois ans ? cinq ans ? En novembre , la version 1.5 du standard de chiffrement à clés publiques PKCS#1 est publié par l’entreprise RSA Laboratories. Cinq ans plus tard, en , Daniel Bleichenbacher publie un article décrivant comment un adversaire peut déchiffrer un message de son choix par une attaque à cryptogrammes choisis. Un système de chiffrement à clé publique, reposant sur le problème du sac à dos a été proposé par Benny Chor et Ronald Rivest en et a été cassé 10 ans plus tard, en par Serge Vaudenay. Ces exemples montrent qu’il devient nécessaire de développer des arguments pour attester la sécurité d’un schéma cryptographique. En cryptographie asymétrique, la sécurité n’est plus inconditionnelle. Un adversaire tout puissant dispose de toutes les informations pour retrouver la clé privée. Les adversaires réels ne disposent pas de la puissance de calcul pour effectuer ce travail. La sécurité est devenue calculatoire. Des éléments quantitatifs de sécurité deviennent nécessaires. Quelle est la puissance de calcul, dont dispose un adversaire, et qui ne remet pas en cause la sécurité ? Pour aboutir à des preuves de sécurité, les cryptologues revendiquent une approche scientifique du problème qui consiste à formaliser l’adversaire, ainsi que les moyens et les informations dont il dispose pour venir à bout du schéma cryptographique. La construction des schémas cryptographique repose sur des problèmes réputés difficiles, comme le problème de la factorisation des entiers, ou le problème du calcul du logarithme discret. Il est admis que les seules attaques réalistes ne peuvent reposer que sur des algorithmes efficaces, qui sont par définition des algorithmes dont la complexité en temps et en mémoire ne dépasse pas un polynôme de la taille des données d’entrée. Au delà d’une complexité polynomiale, l’attaque n’est pas réaliste. Il suffit d’augmenter légèrement la taille des paramètres pour la rendre impossible. On suppose également que l’adversaire peut accéder à 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 sécurité du schéma cryptographique ne fasse aucun doute, on se place généralement dans le cas le plus favorable pour l’adversaire. La sécurité sera avéré si une démonstration existe du fait que l’adversaire ne peut pas atteindre le but qui lui est assigné malgré tous les moyens et les informations qui sont à sa disposition. Le but dépend du schéma cryptographique. Cela peut ê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 schéma cryptographique, la boucle de conception est évitée. La construction repose sur un processus qui consiste à : 5 6 Introduction – s’appuyer sur des primitive reposant sur des hypothèses admises, comme la difficulté de factoriser, ou de calculer un logarithme discret, ou encore sur l’existence de fonctions à sens unique ; – formaliser la cible de sécurité, l’adversaire, ses moyens, le type d’attaque ; – construire un schéma cryptographique ; – apporter la preuve de sa sécurité. Une fois cette preuve apportée, la sécurité du schéma s’impose, sans avoir recours à la boucle infinie conception → attaque → correction → attaque → · · · de l’approche traditionnelle. Une preuve de sécurité est la réduction de la sécurité du schéma aux propriété de la primitive. On cherchera à montrer que si un adversaire peut casser le schéma cryptographique, alors on peut en déduire un algorithme pour nier les propriétés de la primitive. Supposons par exemple qu’un schéma repose sur la difficulté de factoriser. Si montre l’implication suivante : Si un adversaire existe contre ce schéma, alors factoriser est un problème facile, alors par contraposition, on aura finalement montré que Si factoriser est un problème difficile, alors il n’existe pas d’adversaire contre ce schéma. Comme il est largement admis que la factorisation est un problème difficile, la conclusion s’impose. Dans ce domaine de la cryptographie théorique, les acteurs sont des algorithmes. Le principe général des preuves est d’utiliser un adversaire comme sous-programme d’un programme de factorisation. Exercice. Rappelons que le système de chiffrement à clé publique de Rabin consiste à élever au carré un message modulo un entier n égal au produit de deux nombres premiers de même taille. Le déchiffrement consiste à extraire une racine carrée du cryptogramme. Une redondance dans le clair permet de choisir entre les quatre racines carrées possibles. Montrer que si la factorisation des entiers est un problème difficile, alors le chiffrement de Rabin est sûr contre une attaque à clair choisi. § I.1 Machine de Turing I – RAPPELS DE THÉORIE DE LA COMPLEXITÉ § I.1 Machine de Turing La notion de calculabilité a été formalisé indépendamment par Church et Turing en pour formaliser ce qui est intuitivement considéré comme calculable. La machine de Turing est un dispositif théorique qui permet de définir ce qui est calculable. Définition I.1 [machine de Turing] Une machine de Turing est ... Définition I.2 [machine de Turing non déterministe] Une machine de Turing non déterministe est ... § I.2 Problèmes P , problèmes N P Un problème est appelé un problème P s’il est résoluble par une machine de Turing déterministe en temps polynomial. Exemples. Un problème est appelé un problème N P s’il est résoluble par une machine de Turing non déterministe en temps polynomial. § I.3 Problèmes N P –complets Une réduction polynomiale d’un problème P à un problème Q est... 7 8 Fonctions à sens unique II – FONCTIONS À SENS UNIQUE Les fonctions à sens unique constituent une primitive de base de la théorie cryptographique. À partir d’elles, on peut construire des générateurs pseudo aléatoires ainsi que des fonctions et des permutations pseudo aléatoires qui sont les composants essentiels des procédés de chiffrement symétriques. § II.1 Fonction à sens unique concrète De façon informelle, une fonction f est dite à sens unique s’il est facile de calculer la valeur pour tout paramètre, mais à l’opposé, pour presque toute valeur, il est en pratique impossible de trouver un antécédent ayant cette valeur pour image. Finalement, les seules valeurs qu’on peut inverser sont les valeurs qui ont été préalablement calculées. Lorsqu’on a calculé f (x) = y, on sait qu’un antécédent de y est x. Une fonction est à sens unique, si on ne peut pratiquement pas en dire davantage. La notion d’impossibilité pratique repose sur la non existence d’algorithme de complexité polynomiale pour résoudre ce problème. Cette notion est asymptotique. Les algorithmes de chiffrement du monde réel, comme le DES ou l’AES, ont une taille de clé fixée (56, ou 128 bits), et opèrent sur des blocs de données d’une taille fixée (64 ou 128 bits). Cela oblige à distinguer les notions de sécurité concrète ou de sécurité asymptotique. Définition II.1 [Fonction à sens unique concrète] Soient m et n deux entiers fixés. Pour deux réels positifs t et ε, une fonction f : {0, 1}n −→ {0, 1}m est dite (t, ε)– à sens unique si pour tout algorithme de complexité inférieure ou égale à t en temps et en espace, la probabilité qu’il trouve un antécédent à un élément y = f (x) dans l’image de f , où x est choisi aléatoirement dans {0, 1}n , ne dépasse pas ε. r La notion de fonction à sens unique est une notion probabiliste. Il sera toujours possible de trouver un antécédent aux valeurs qui ont été calculées. La difficulté est exigée pour un élément aléatoire de l’image de f . Les algorithmes d’attaques génériques, c’est-à-dire ceux qui n’utilisent pas la structure particulière des fonctions f , conduisent à des bornes sur les valeurs de t et de ε. L’algorithme de la force brute, qui consiste à faire un calcul exhaustif des valeurs donne une première borne. Proposition II.2 [Borne de la force brute] Soit f : {0, 1}n −→ {0, 1}m une fonction (t, ε)–à sens unique, alors les paramètres t et ε vérifient t = O (m + n)2n . ε Preuve. Pour prouver ce résultat, il suffit d’exhiber un algorithme de complexité t qui réussit avec un probabilité ≥ ε à trouver un antécédent x à une valeur y aléatoire de l’image f ({0, 1}n ). Considérons l’algorithme suivant : Pour k valeurs aléatoires distinctes xi , calculer yi = f (xi ). Si yi = y alors rendre xi comme antécédent. Sinon, renvoyer une valeur aléatoire. La probabilité de succès de cet algorithme vaut la probabilité que l’un des yi soit égal à y, soit k/2n . Or la complexité de calcul de la valeur f (yi ) est est au moins égale à (m + n). La complexité de l’algorithme est bornée par t = k/(n + m), donc ε ≥ k/2n = t/(m + n)2n , donc y/ε ≤ (n + m)2n . § II.2 Fonction à sens unique asymptotique r En pratique, pour atteindre un paramètre de sécurité de 280 pour le temps de calcul et de 1/260 pour la probabilité de succè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-mémoire, introduite par Martin Hellman dans son article A cryptanalytic time-memory trade-off, publié en . Proposition II.3 [Borne du compromis temps-mémoire] Soit f : {0, 1}n −→ {0, 1}m une fonction (t, ε)–à sens unique, alors les paramètres t et ε vérifient t2 = O (m + n)2 2n . ε Preuve. Considérons l’algorithme suivant : 1. Précalcul. Pour j = 1 jusqu’à t, calculer zj f = f t (xj ) pour t valeurs aléatoires x1 , . . . xt . Mémoriser les couples (xj , zj ) dans une table. 2. Pour l’entrée y, et pour i = 1 jusqu’à t, calculer yj = f i (y). Si un des yi vaut un des zj alors c’est qu’un image itérée de xj vaut y. L’image itérée précédente est un antécédent de y. La complexité de l’algorithme est t × t × (m + n) pour la phase de précalcul qui est effectuée une fois pour toute. L’algorithme réussit s’il existe un élément commun dans les listes (zj ) et (yi ) et il échoue dans le cas contraire. La probabilité de succès vaut la probabilité de trouver un élément commun dans deux listes aléatoires de t éléments choisies aléatoirement parmi 2n . Le paradoxe des anniversaires indique que cette probabilité vaut ε = t2 /2n+1 . Pour chaque y, la complexité du calcul est majorée par (m + n) × t. r Cette borne impose que, pour atteindre les paramètres de sécurité t ≥ 280 et ε ≤ 1/260 , la valeur de n doit vérifier 2n ≥ 22×80+60 = 2220 , donc n ≥ 220. § II.2 Fonction à sens unique asymptotique Définissons tout d’abord ce qu’est une fonction négligeable. Définition II.4 [fonction négligeable] Une fonction µ : N −→ R est négligeable si elle est inférieure à l’inverse de tout polynôme à partir d’un certain rang, c’est-à-dire s’il pour tout polynôme P (x) ∈ R[x], on a : ∃N ∈ N, ∀n ≥ N, µ(n) ≤ 1 . P (n) Exemples. La fonction n : 7−→ 1/2n/2 est négligeable, la fonction n : 7−→ n−k ne l’est pas. r Une fonction non négligeable est une fonction qui est asymptotiquement supérieure à l’inverse d’un polynôme. L’ensemble des fonctions non-négligeables est stable par addition, par multiplication. La puissance d’une fonction non négligeable est non négligeable. L’ensemble {0, 1}∗ est par définition le monoı̈de libre sur l’alphabet {0, 1}, c’est-à-dire l’ensemble des mots de longueur quelconque, y compris le mot vide noté ε, écrits avec des 0 et des 1. Pour définir les fonctions à sens unique asymptotique, la taille des paramètres et des valeurs n’est pas fixée. Ce sont des mots de longueur quelconque. 9 10 Fonctions à sens unique Définition II.5 [Fonction à sens unique asymptotique] Une fonction f : {0, 1}∗ −→ {0, 1}∗ est dite à sens unique si les deux conditions suivantes sont remplies : 1. La fonction f est facile à calculer, c’est-à-dire il existe un algorithme efficace qui, pour tout élément x ∈ {0, 1}∗ calcule f (x). 2. La fonction f est difficile à inverser, c’est-à-dire, pour tout algorithme A qui s’exécute en temps polynomial en n, la probabilité de trouver un antécédent de taille n d’un élément aléatoire y de l’image de f est une fonction négligeable en n. On exprime la seconde condition en énonç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 négligeable. Quelques explications sur les notations de l’écriture (1) : – La notation x ∈R {0, 1, }n signifie que la probabilité est exprimée lorsque x est un élément choisi aléatoirement avec la probabilité uniforme dans l’ensemble {0, 1}n . – Le paramètre 1n de l’algorithme A est un artifice technique pour imposer un paramètre de taille n à l’algorithme A. L’algorithme A est supposé efficace, c’est-à-dire qu’il a une complexité polynomiale en la taille des données. Avec ce paramètre, la complexité de A est bornée par un polynôme en n. Sans ce paramètre, si par exemple la taille de f (x) est en log(n), la complexité de A serait simplement bornée par un polynôme en log(n), ce qui change complètement la complexité supposée de l’algorithme A. r Comme le calcul de la valeur d’une fonction à sens unique est d’une complexité polynomiale, retrouver un antécédent d’une fonction à sens unique est un problème N P. En conséquence, une fonction à sens unique ne peut exister que si P 6= N P. q On ne sait pas s’il existe une fonction à 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 résolue. La seule chose qu’on puisse dire actuellement est que si une fonction à sens unique existe, alors P = 6 N P. Un problème est N P complet s’il est difficile à résoudre dans le pire des cas. La définition des fonctions à sens unique stipule qu’elles sont difficiles à inverser dans le cas moyen. Même si on savait qu’il existe un problème N P qui n’est pas P, le problème de l’existence de fonction à sens unique resterait ouvert. La notion de fonction à sens unique est commode pour traiter des résultats théoriques, mais en pratique, on a plutôt affaire à des familles de fonctions à sens unique, comme par exemple la fonction puissance qui opère sur un groupe Z/pZ avec une taille donnée pour p. Soit p un nombre premier. Pour tout entier n ∈ {0, . . . , p − 1} et un générateur g de Z/pZ, il existe un algorithme efficace pour calculer g n , par exemple par une succession de multiplications et d’élévations au carré. Inversement, étant donné un élément y de Z/pZ, on ne connaı̂t actuellement pas d’algorithme de complexité polynomiale en la taille de y pour trouver l’exposant n qui vérifie y = g n . Ce problème est le problème du logarithme discret. La fonction puissance est en pratique une fonction à sens unique. Comme la fonction est différente pour chaque taille de paramètre, on a affaire à une famille de fonctions à sens unique. Nous sommes donc amené à définir cette dernière notion. § II.2 Fonction à sens unique asymptotique Définition II.6 [Famille de fonctions à 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 à sens unique si les deux conditions suivantes sont remplies : 1. La famille est facile à échantillonner, c’est à dire : a) Il existe un algorithme probabiliste S1 , prenant en paramètre un entier n, de complexité polynomiale en n qui génère un élément i, de taille n, aléatoire dans I. b) Il existe un algorithme probabiliste efficace S2 , qui à partir d’un élément i de I, génère un élément aléatoire x du domaine Di . 2. Les fonctions fi sont faciles à calculer, c’est-à-dire il existe un algorithme efficace A qui, à partir d’un élément i ∈ I et d’un élément x ∈ Di calcule fi (x). 3. Les fonctions fi sont difficiles à inverser, ce qui signifie que la probabilité de succès de tout algorithme efficace qui prend en entrée un élément i produit par l’algorithme S1 et un élément aléatoire y de l’image de fi , égal à fi (x), où x est produit par l’algorithme S2 , pour trouver un antécédent de y, a une probabilité de succès négligeable en la taille de l’indice i et de l’élément y. r La notion de famille de fonction à sens unique est plus proche des fonctions qu’on utilise en cryptologie réelle, comme le produit d’entiers, la fonction puissance ou la fonction RSA. À l’opposé, la notion de fonction à sens unique asymptotique, donnée par la définition II.5, est plus théorique et est plus commode pour manipuler les preuves de sécurité. Nous verrons que ces deux notions sont équivalentes. r Dans les applications cryptologiques, en particulier à clé publique, il faut penser l’indice i comme étant la clé publique qui permet le chiffrement. L’inversion de la fonction est réservée aux détenteurs de la clé privée correspondantes. r Un algorithme probabiliste est un algorithme qui produit un résultat aléatoire dans l’ensemble des valeurs possibles. On peut considérer qu’un tel algorithme est un algorithme déterministe qui a un argument supplémentaire constitué d’une chaı̂ne aléatoire r ∈ {0, 1}∗ en fonction de laquelle l’élément aléatoire est produit. La fonction qui à un couple de nombre premiers distincts de même taille associe leur produit est supposé être une fonction à sens unique. C’est précisément sur cette supposition que repose la sécurité du système RSA. Voici comment il est formalisé : – 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 aléatoire de taille n. – L’algorithme S2 génère deux nombres premiers de taille i. Pour générer un nombre premier de taille i, on génère un entier aléatoire, puis on teste sa primalité à l’aide d’un test probabiliste de type Miller-Rabin, ou bien à l’aide du test AKS qui est déterministe et de complexité polynomiale. – Pour i ∈ I, la fonction fi est (p, q) 7−→ p × q. Trouver un antécédent de fi revient à factoriser un entier qui est le produit de nombre premiers de tailles similaires. Les meilleurs algorithmes actuels de factorisation ont une complexité qui n’est pas polynomiale. La notion de fonction à sens unique asymptotique est plus facile à utiliser pour démontrer des résultats de sécurité, mais la notion de famille de fonctions à sens unique correspond mieux au fonctions utilisées en pratique. Le théorème suivant énonce que ces deux notions sont équivalentes, ce qui permettra de considérer l’un ou l’autre cas selon ce qui est le plus commode. 11 12 Fonctions à sens unique Théorème II.7 Il existe une fonction à sens unique si et seulement si il existe une famille de fonctions à sens unique. Preuve. Supposons tout d’abord qu’il existe une fonction à sens unique f : {0, 1}∗ −→ {0, 1}∗ et construisons à partir de f une famille de fonctions à sens unique. L’ensemble d’indices I est I = {0, 1}∗ l’ensemble des mots binaires. Pour un mot binaire i donné dans I, on définit le domaine Di comme étant l’ensemble des mots binaires de la même longueur que i, c’est-à-dire Di = {0, 1}|i| . L’algorithme S1 choisit un mot aléatoire binaire de longueur n. L’algorithme S2 choisit un mot alé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 à sens unique, toutes les fonctions fi sont à sens unique, car dans le cas contraire, on pourrait immédiatement en déduire un algorithme qui inverse la fonction f sur une entrée de longueur n, en trouvant un inverse de fn . Ceci montre donc l’existence d’une famille de fonctions à sens unique (fu )i∈I . Réciproquement, à partir d’une famille de fonctions à sens unique, construisons une fonction à sens unique f . Rappelons qu’un algorithme qui rend un résultat aléatoire peut se modéliser comme un algorithme déterministe qui prend en paramètre un mot binaire aléatoire servant de germe à la génération de l’aléa nécessaire à son calcul. Pour un élément z de {0, 1}∗ , on définit la valeur de f (x) ainsi : On coupe le mot binaire z en deux mots de taille moitié. Soit x = (r, s). On utilise la première moitié r comme chaı̂ne aléatoire qui alimente l’algorithme S1 de la famille de fonctions à sens unique, et on utilise la deuxième moitié s comme chaı̂ne aléatoire qui alimente l’algorithme S2 . Ces algorithmes fournissent de manière déterministe un indice i = S1 (r) ∈ I, puis un élément x = S2 (s, i) ∈ Di . On pose finalement : f (r, s) = fi (x), i . Il reste à montrer que la fonction f est à sens unique. Pour cela, supposons le contraire. Cela signifie que sur une entrée (y, i) ∈ {0, 1}∗ × I, il existe un algorithme efficace qui trouve un élément (r, s) vé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 trouvé un antécédent x de y par fi , ce qui montre que sous cette hypothèse, la famille (fi ) n’est pas à sens unique. § II.3 Exercices 1. Formaliser précisément la famille de fonctions supposée à sens unique reposant sur le logarithme discret dans un corps Fp . 2. Même question pour la fonction RSA. 3. Montrer que si P = 6 N P, alors il existe des fonctions qui sont difficiles à inverser dans le pire des cas, mais qui ne sont pas des fonctions à sens unique. 4. Une fonction {0, 1}∗ −→ {0, 1}∗ est dite à longueur régulière si ∀x, y ∈ {0, 1}∗ , |x| = |y| =⇒ |f (x)| = |f (y)| § II.3 Exercices Montrer que s’il existe une fonction à sens unique, alors il existe une fonction à sens unique à longueur réguliè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 à sens unique, alors il existe une fonction à sens unique qui conserve les longueurs. 6. Soit f : E −→ E une fonction à sens unique. 1. La fonction f ◦ f est-elle à sens unique ? 2. La fonction g : x 7−→ f (x), f ◦ f (x) est-elle à sens unique ? 3. On suppose maintenant que f est bijective. La fonction f ◦ f est-elle à sens unique ? 13 14 Bits difficiles III – BITS DIFFICILES Si une fonction est à sens unique, c’est qu’elle cache l’information sur l’antécédent d’une valeur donnée. Un bit difficile d’une fonction est une information binaire sur l’entrée qu’il est difficile de retrouver à partir de la valeur de la fonction. Le minimum qu’on puisse exiger d’une fonction à sens unique est l’existence d’une information calculatoirement inaccessible à partir de la valeur. Cela caractérise en fait les fonctions à sens unique. § III.1 Définition Soit f : {0, 1}∗ −→ {0, 1}∗ une fonction à sens unique. Considé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 propriété d’être à la fois à sens unique et de ne cacher aucun bit de son entrée, en ce sens qu’il existe un algorithme qui, à partir d’une valeur (y, b, i) trouve la valeur de tout bit xj de l’entrée avec une 1 1 , où n est la taille de l’entrée. probabilité supérieure à + 2 2n Plus précisé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 aléatoirement dans {0, 1}n , la probabilité que Ai trouve 1 1 . la valeur de xi à partir de y = F (x) est supérieure à + 2 2n Exercice. Montrer que la fonction puissance sur un corps fini premier Z/pZ ne cache pas le bit de poids faible. Définition III.1 [Bit difficile] Étant donnée une fonction f : {0, 1}∗ −→ {0, 1}∗, une fonction boolé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) à partir de f (x) qu’avec une probabilité négligeable, c’est-à-dire, pour tout entier n, 1 − 2 Probx∈R {0,1}n [A(1n , f (x)) = b(x)] est une fonction négligeable en n. r L’exemple introductif montre qu’il existe des fonctions à sens unique telles qu’aucune fonction x 7−→ xi ne soit un bit difficile. § III.2 Théorème de Goldreich-Levin D’après le résultat de l’exercice 3 ci-dessus, une fonction injective qui a un bit difficile est nécessairement à sens unique. Le théorème de Goldreich-Levin énonce réciproquement qu’à partir d’une fonction à sens unique, on peut construire une autre fonction à sens unique qui lui est similaire et qui a un bit difficile. Ce résultat est au cœur de la théorie cryptoglogique. Théorème III.2 [Goldreich-Levin] Soit f une fonction à sens unique. Soit g la fonction définie à partir de f par : g : (x, r) 7−→ f (x), r , avec |x| = |r|, alors la fonction booléenne Pn (x, r) 7−→ x · r est un bit difficile pour g, le produit scalaire x · r étant défini par x · r = i=1 xi ri (modulo 2) § III.2 Théorème de Goldreich-Levin Preuve. Supposons pour une contradiction que la fonction g n’est pas à sens unique. Il existe alors un algorithme efficace qui permet de trouver un antécédent (x, r) à partir d’une valeur (y, r), et cet algorithme permet en particulier de trouver un antécédent x de y par f . Ceci montre que f n’est alors pas à sens unique, ce qui contredit l’hypothèse. On suppose pour une contradiction qu’il existe un algorithme B, capable de trouver x · r avec une probabilité non négligeable. Supposons dans un premier temps que B trouve x·r avec certitude, c’est-à-dire avec une probabilité égale à 1 à partir d’une valeur (y, r). Cet algorithme, appliqué successivement avec r égal aux éléments de la base canonique de {0, 1}n , renvoie les composantes successives de x. Si maintenant, l’algorithme B rend une réponse non certaine, par exemple avec une probabilité 1 1 non négligeable, égale par exemple à + , alors la mé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 réponse avec une probabilité + 2 n 2 2n négligeable. Il faut trouver une autre idée. Cette idée est de construire un algorithme A qui trouve x avec une probabilité non négligeable en faisant une hypothèse sur ` bits de x. Si ces ` bits sont choisis au hasard, la probabilité qu’ils soient justes est en 1/2` , mais si ` est assez petit devant n, la probabilité de succès restera non négligeable. Soit donc B(y, r) un algorithme qui, pour tout entier n, à partir de y = f (x), pour un élément x ∈R {0, 1}n aléatoire, et un élément r ∈R {0, 1}n aléatoire également, trouve b(x, r) = x · r à avec une complexité est bornée par un polynôme en n et réussit avec une probabilité non né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-à-dire trouve x, avec une probabilité non négligeable. L’algorithme A s’appuiera sur ` valeurs supposées connues b1 = x · r1 , . . . b` = x · r` , pour ` valeurs aléatoires de l’élément r ∈ {0, 1}n . P Pour tout sous-ensemble I deP{1, . . . , `}, posons rI = i∈I ri (modulo 2). Par bilinéarité 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 étant connue, pour tout indice i ∈ {1, . . . , n}, la valeur de xi se déduit de celle de x · (r + ei ), par : x · r + x · (r + ei ) = x · ei = xi , oà ei est le vecteur de {0, 1}n dont la seule composante non nulle est la ie qui vaut 1. Considérons l’algorithme A qui, sur une entrée y = f (x), pour x aléatoire dans {0, 1}n , fait appel à 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 étant incertaine et afin d’amplifier la probabilité de succès, la valeur de xi est estimée par un vote majoritaire pour toutes les valeurs x · rI + B(y, rI + ei ). Précisément, posons bi,I la réponse de B(y, rI + ei ). Soit xi,I = x · rI + bi,I la valeur estimée de xi à partir de la ré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 à 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 probabilité non négligeable, il reste à évaluer sa probabilité de succès et sa complexité. 15 16 Bits difficiles L’algorithme A fait appel à l’algorithme B sur des valeurs aléatoires de r, mais avec toujours la même valeur de y = f (x) à inverser. La probabilité de succès de B dans ces conditions ne peut pas se déduire directement de la relation (2), car cette valeur est donnée pour une entrée y aléatoire. Le lemme suivant majore la probabilité de succès de B(y, r) lorsque qu’il est appelé avec une valeury fixée. Lemme III.3 Soit x un élément fixé de {0, 1}n . Considérons l’évènement S(x) suivant : hh L’algorithme B f (x), r trouve le bit difficile x · r avec une probabilité non négligeable au moins égale à 1/2 + ε(n). ii Lorsque x est choisi au hasard dans {0, 1}n , la probabilité de l’évènement S(x) est non négligeable et supérieure à ε(n)/2. Preuve. Soit Sn l’ensemble des vecteurs x pour lesquels l’algorithme B(f (x), r) réussit avec une probabilité non négligeable supérieure à 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’hypothèse (2). Cette inégalité sur le cardinal de l’ensemble Sn montre que la probabilité de l’évènement S(x) vaut au moins ε(n)/2. Lemme III.4 Si l’entier ` satisfait 2` ≤ n/ε(n)2 , et sous l’hypothèse que les ` valeurs b1 , . . . , b` de x · r1 , . . . x · r` sont √ exacte, la probabilité de succès de l’algorithme A est asymptotiquement supérieure à 1/ e ≈ 0, 6. Preuve. Soit Xi,I la variable aléatoire qui vaut 1 si l’estimation xiI est fausse et qui vaut 0 sinon, c’est-à-dire Xi,I = xi + xi,I (modulo 2). D’après le lemme III.3, on a : 1 ε(n) + . 2 2 Prob(Xi,I = 0) ≥ Par conséquent, l’espérance de la variable Xi,I satisfait E(Xi,I ) ≥ 1/2 + ε(n)/2. Posons Xi la variable aléatoire égale au nombre d’estimations fausses faites pour chacun des sous-ensembles non vides I de {1, . . . , `}, c’est-à-dire : X Xi = Xi,I . I⊂{1,...,`} I6=∅ Par linéarité de l’espérance, on a : (3) E(Xi ) ≥ m ε(n) +m , 2 2 donc : Xi − E(Xi ) ≤ Xi − m ε(n) −m . 2 2 § III.2 Théorème de Goldreich-Levin Or, en raison de la façon d’estimer la composante xi du vecteur x, la probabilité que x∗i soit différent de xi est exactement la probabilité que Xi soit supérieure à m/2. En raison de l’inégalité (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’après l’inégalité 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 nécessairement un élément qui appartient à l’un sans appartenir à l’autre, les variables Xi,I sont deux-à-deux indé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 égale à son carré, d’oà : Var(Xi,I ) = E(Xi,I ) − E(Xi,I )2 . Pour majorer Var(Xi,I ), étudions la fonction x 7−→ x − x2 = x(1 − x). Elle a son maximum qui vaut 1/4 en 1/2, par conséquent : 1 Var(Xi,I ) ≤ , 4 et donc m Var(XXi ) ≤ 4 Par consé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 probabilité supérieure à 1 n 1 − 1/2n. L’ensemble des bits de x est donc calculé avec une probabilité supérieure à 1 − , 2n √ et cette quantité converge vers 1/ e. L’algorithme A calcule le vecteur x avec une probabilité non négligeable, asymptotiquement minorée par une constante. Fin de la preuve du théorème de Goldreich-Levin. Montrons maintenant que l’algorithme A hh les ` trouve un antécédent de y = f (x) avec une probabilité non négligeable. Soit C l’évènement valeurs estimées b1 , . . . , b` sont correctes, et S(x) l’évènement L’algorithme B f (x), r trouve le bit difficile x · r avec une probabilité non négligeable au moins égale à 1/2 + ε(n). ii. Ces évènements sont indépendants. Soit R l’évènement qui énonce le succès de l’algorithme A. On a : Prob(R) ≥ Prob(R | C, S(x)) × Prob(C ∩ S(x)). 17 18 Bits difficiles ε(n) . La probabilité de l’évènement S(x) est n supérieure à ε(n), et la probabilité de succès de A sachant que les évènements C et S(x) sont √ réalisés est supérieure à 1/ e. Il en résulte que : La probabilité de l’évènement C vaut 1/2` ≥ 1 ε(n)3 Probx∈R {0,1}n R ≥ √ × , n e qui est non négligeable. L’algorithme A fait n × 2` appels à 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 télé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 à B lors de la première passe. – une valeur de désengagement d, qu’il conserve pour plus tard. 2. Le joueur B joue un bit b0 et le transmet à A lors de la deuxième passe. 3. Le joueur A transmet la valeur du désengagement d qui va révé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 à partir d’un bit b, calcule un couple (c, d) d’engagement de désengagement. – Une fonction d’ouverture open, qui à partir du couple (c, d) d’engagement et de désengagement, dévoile la valeur du bit b. Pour empêcher la triche, deux propriétés de sécurité sont définies : – La propriété d’enchérissement (biding) : la probabilité de trouver deux valeurs de désengagement d et d0 est négligeable. Cette propriété signifie qu’une fois l’engagement émis, il n’est pas possible de changer le ré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 propriété de discré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 à partir de a. Un bit difficile d’une fonction à sens unique permet de satisfaire la propriété de discrétion. Si de plus, cette fonction à sens unique est choisie injective, la propriété d’enchérissement sera assurée. § III.4 III.3.2. Exercices Preuve sans divulgation L’existence de fonction à sens unique injective implique l’existence de preuve sans divulgation de la connaissance d’une solution de problème N P (ZK=Zero-Knowledge proof). Un protocole de preuve sans divulgation comprend deux acteurs : – Un prouveur qui prouve sa connaissance d’une donnée sans la révéler. – Un vérifieur, qui vérifie la preuve. À l’issue du protocole, le vérifieur est convaincu que le prouveur détient la donnée en question, mais n’a acquis aucune information sur cette dernière. Pour montrer cette assertion, il suffit de la montrer pour un problème N P–complet. Illustrons cette propriété sur le problème 3–COL. Il s’agit de convaincre qu’un graphe G est coloriable avec trois couleurs, sans révéler aucune information sur la façon de la colorier. Le prouveur A peut prouver au vé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 à partir d’un engagement de bits. Un graphe G est un couple (V, E) de sommets et d’arrêtes. Les arrêtes sont un sous-ensemble de paires {i, j} de sommets. Un coloriage à trois couleurs est une application σ ; V −→ {1, 2, 3} telle que pour toute arrête {i, j}, on a σ(i) 6= σ(j). La preuve sans divulgation de la connaissance d’une telle application σ est interactive et se déroule sur plusieurs tours. Pour chaque tour : 1. Engagement : le prouveur choisit une permutation alé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. Défi : Le vérifieur défie le prouveur de révéler le coloriage d’une arrête {i, j} aléatoire. 3. Révélation : Le prouveur révèle la valeur de désengagement, ce qui permet de vérifier que les sommets i et j sont coloriés différemment. En raison de la propriété d’enché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 arrête dont les sommets ont la même couleur, et le vérifieur pourra l’observer à l’issue du désengagement. La probabilité de convaincre le vérifieur alors qu’on ne connait pas le coloriage du graphe vaut 1 |E|×n 1 1− . Après un nombre de tours égal à n×|E|, la probabilité de fausse preuve vaut 1− . |E| |E| 1 n Si le nombre d’arrête est assez grand, une bonne approximation de cette valeur est qui e converge vers O. La probabilité de prouver la connaissance d’une donnée qu’on ignore est donc négligeable. § III.4 Exercices 1. Montrer que, si on suppose que la fonction RSA est à sens unique sans la connaissance de la factorisation du modulo, alors le bit de parité de la fonction RSA est difficile. 2. Montrer que le bit de parité 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 à sens unique, et que ce résultat est faux si on ne suppose pas la fonction injective. 4. Construire précisément un schéma d’engagement de bit à partir d’une fonction à sens unique injective et prouver sa sécurité. 19 20 Générateurs pseudo-aléatoires IV – GÉNÉRATEURS PSEUDO-ALÉATOIRES § IV.1 Approche intuitive Un générateur pseudo-aléatoire (GPA) agit comme un amplificateur d’aléa. Il s’agit d’un algorithme déterministe qui, à partir d’une petite source aléatoire, produit une suite plus longue, constituée de symboles qu’on ne peut pas distinguer d’une véritable source aléatoire. Ceci est illustré par le schéma suivant : graine - GPA - (courte) pseudo-aléa (long) Tout d’abord, montrons qu’il est impossible de réaliser un générateur pseudo-aléatoire parfait. Il est impossible de créer du véritable aléa à partir d’une fonction déterministe. Définition IV.1 [distance statistique] Soient X et Y deux variables aléatoires à valeur dans un même ensemble fini X . On appelle distance statistique de X et Y la quantité : X ∆(X, Y ) = Prob(X = α) − Prob(Y = α). α∈X Définition IV.2 [Familles statistiquement indiscernables] Soient X = (Xn )n∈N et Y = (Yn )n∈N deux familles de variables aléatoires à valeur dans le même ensemble fini X . On dit que les deux familles sont statistiquement indiscernables si la distance statistique de Xn à Yn est une fonction négligeable de n. Montrons qu’un GPA parfait n’existe pas. Ce résultat est similaire au principe de non création d’information en théorie de l’information qui énonce qu’il est impossible de créer de l’information à partir d’une manipulation déterministe des données. Proposition IV.3 [Inexistence d’un GPA statistique] Pour tout entier n, soit Un la variable alé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 aléatoires g(Un ) n∈N et (Un+1 )n∈N ne sont pas statistiquement indiscernables. Preuve. La loi de g(Un ) est donné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 aléatoires g(Un ) et Un+1 est donné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 supérieur ou égal à 1. D’où ∆(n) ≥ 1 qui n’est pas négligeable. § IV.2 Indiscernabilité calculatoire § IV.2 Indiscernabilité calculatoire La qualité d’un générateur pseudo-aléatoire, qui est l’impossibilité de discerner entre une source issue d’un véritable générateur d’aléa (GDA) et une source issue d’un générateur pseudo-aléatoire (GPA) est donc une notion calculatoire. Si le GPA est sûr, un algorithme efficace ne doit pouvoir le distinguer d’un GDA qu’avec une probabilité négligeable. Définition IV.4 [avantage d’un distingueur] Considérons deux familles variables aléatoires X = (Xn )n∈N et Y = (Yn )y∈N . Un distingueur de ces familles est un algorithme D qui est supposé discerner l’une de l’autre et qui rend une valeur binaire 0 ou 1, sur une réalisation de l’une ou l’autre de ces variables alé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 paramètre la réalisation d’une variable aléatoire. La valeur rendue est donc alé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 réalisation de Xn d’une réalisation de Yn . Pour deux familles de variables aléatoires, l’ensemble des avantages de tous les distingueurs est un sous-ensemble de R majoré par 1. Il admet donc une borde supérieure, ce qui autorise la définition suivante : Définition IV.5 [distance calculatoire de familles de variables aléatoires] Étant données deux familles de variables aléatoires X = (Xn )n∈N et Y = (Yn )y∈N sur un même ensemble, la distance calculatoire entre ces deux familles, notée ∆X,Y (n) est la fonction en n qui donne l’avantage du meilleur distingueur, c’est-à-dire pour tout n entier : ∆X,Y (n) = sup AdvD (Xn , Yn ) , D∈D où D est l’ensemble des distingueurs de complexité polynomiale. La distance calculatoire satisfait l’inégalité triangulaire. Proposition IV.6 [inégalité triangulaire sur la distance calculatoire] Soient X = (Xn )n∈N , Y = (Yn )y∈N et Z = (Zn )y∈N trois familles de variables aléatoires. La distance calculatoire satisfait pour tout entier n : (4) ∆X,Z (n) ≤ ∆X,Y (n) + ∆Y,Z (n). Preuve. Pour tout ré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 Générateurs pseudo-aléatoires L’inégalité pour la distance calculatoire est obtenue par passage à la borne supérieure sur tous les distingueurs polynomiaux. Pour tout ε > 0, on a : ∆X,Z − ε ≤ ∆(X, Y ) + ∆(Y, Z). Cette inégalité étant satisfaite pour tout ε > 0, l’inégalité (4) s’en déduit. L’indiscernabilité calculatoire, définie ci-après, est l’objectif à atteindre pour un générateur pseudoaléatoire. Définition IV.7 [indiscernabilité calculatoire] Deux familles de variables alé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 négligeable en n. L’indiscernabilité calculatoire signifie que tout distingueur efficace est incapable de discerner l’une de l’autre variable aléatoire avec une probabilité non négligeable. Définition IV.8 [générateur pseudo-aléatoire] Un générateur pseudo-aléatoire est un algorithme déterministe G qui vé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-aléa : L’image par G de la distribution uniforme Un est calculatoirement indistinguable de la distribution uniforme U`(n) . La propriété d’expansion signifie que la longueur de l’image par G d’un mot binaire s de {0, 1}∗ ne dépend que de la longueur de s et est toujours plus longue que s. r Notons U = (Un )n∈N la famille des variables aléatoires uniformes sur {0, 1}n . Posons Y la famille de variables aléatoires Y = g(Un−1 ) . La propriété de pseudo-aléa s’exprime n≥1 également en énonçant que la distance calculatoire : ∆Y,U (n) est négligeable. § IV.3 Générateur pseudo aléatoire avec expansion d’un bit La première étape dans la construction de générateurs pseudo-aléatoire est d’en construire avec une expansion d’un seul bit, c’est-à-dire de GPA {0, 1}n −→ {0, 1}n+1 . Le théorème suivant propose une réponse à ce problème. Théorème IV.9 Si f est une permutation à 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 générateur pseudo-aléatoire. Preuve. Supposons, pour une contradiction, que la fonction g ainsi définie n’est pas un générateur pseudo-aléatoire, c’est-à-dire qu’il existe un distingueur D sachant discerner avec une probabilité non négligeable, entre l’image par g d’une valeur aléatoire et une valeur aléatoire. § IV.4 Générateur pseudo-aléatoire avec expansion polynomiale Utilisons ce distingueur D pour construire un algorithme A qui va trouver le bit difficile b(x) à partir d’une image f (x). Sur une entrée y = f (x), l’algorithme A choisit un bit aléatoire r ∈ {0, 1}, puis soumet le couple (y, r) à l’algorithme D supposé discerner entre une valeur aléatoire (GDA) et une valeur pseudoaléatoire (GPA) qui est le résultat du calcul f (x), b(x) . Si le distingueur D répond hh GPA ii, c’est probablement que le bit r choisi aléatoirement vaut b(x), et alors l’algorithme A renvoie r comme candidat au bit difficile. Si au contraire, le distingueur D ré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 complémentaire r = 1 − r comme candidat au bit difficile. Montrons que cette stratégie est efficace en calculant sa probabilité de succès en fonction de celle du distingueur D. Par hypothèse, la probabilité de succès de D est non né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) où ε(n) est une fonction non négligeable de n. Maintenant, évaluons l’avantage de A, qui est égal à h i 1 AdvA = Probx∈R {0,1}n A f (x) = b x − , 2 et montrons qu’il est non négligable. Décomposons la probabilité de succès de l’algorithme A selon la valeur de b(x). Par construction, si b(x) = r, il s’agit de la probabilité que le distingueur D réponde GPA. De même, si b(x) = 1 − r, l’algorithme A répond correctement si le disgingueur D répond GDA. Par consé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 étant aléatoire, il vaut b(x) avec une probabilité 1/2. De même, 1−r vaut b(x) avec probabilité 1/2. De plus, si b(x) = 1 − r, l’entrée f (x), r de l’algorithme D est finalement une entrée aléatoire. La probabilité que D réponde GDA est le complément à 1 de la probabilité qu’il ré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 même que celui de D. Il est non négligeable. § IV.4 Générateur pseudo-aléatoire avec expansion polynomiale La deuxième étape de la construction des générateurs pseudo-aléatoires est d’en construire avec une expansion supérieure à un seul bit. Soit p(n) une fonction d’expansion polynomiale en n. Le procédé suivant utilise un générateur pseudo-aléatoire g1 d’expansion 1 bit, pour construire un générateur pseudo-aléatoire d’expansion ` = p(n). On suppose qu’on dispose d’un générateur pseudo-aléatoire g1 tel qu’il soit calculatoirement impossible de discerner g1 (x) de y, avec x aléatoire dans {0, 1}n et y aléatoire dans {0, 1}n+1 . 23 24 Générateurs pseudo-aléatoires On peut par exemple utiliser la construction du paragraphe précédent reposant sur une fonction à sens unique et un bit difficile de cette fonction. {0, 1}n s La construction d’un générateur pseudo-aléatoire −→ 7−→ {0, 1}` est illustrée par la σ1 σ2 · · · σ` figure suivante : s g : g1 g1 g1 - s1 - s2 - ... g1 - s` q q q ? σ1 ? σ2 ? σ` Théorème IV.10 [générateur pseudo-aléatoire avec expansion polynomiale] Étant donné un générateur pseudo-aléatoire g1 d’expansion 1 bit, soit p(n) un polynôme en n vérifiant pour tout n entier p(n) > n, soit n un entier et ` = p(n), soit g la fonction définie sur {0, 1}∗ sont la valeur sur les vecteurs binaires s de dimension n est : g(s) = σ1 σ2 · · · σ` , définie par s0 = s, et, pour i = 1 jusqu’à `, par g1 (si−1 ) = (si , σi ). Alors g est un générateur pseudo-aléatoire. Preuve. Soit Y la variable aléatoire produite par le générateur pseudo-aléatoire g avec une graine S aléatoire. Il faut montrer que la distance calculatoire ∆(Y, U ) est négligeable. Pour montrer cela, on utilise un procédé dit hybride de démonstration. Cela consiste à définir une suite de variables aléatoires H0 = Y, H1 , . . . , H` = U , et à montrer que pour tout k ∈ {0, . . . , ` − 1}, la distance calculatoire ∆Hk ,Hk+1 (n) est négligeable. Par l’inégalité triangulaire (4), on déduit que : ∆Y,U (n) ≤ `−1 X ∆Hk ,Hk+1 (n), k=0 qui est négligeable, car une somme d’un nombre de terme polynomial en n de termes négligeables reste négligeable. Pour k = 1 jusqu’à `, on considère le procédé hk qui consiste à produire de l’aléa véritable jusqu’au rang k, puis d’appliquer le même procédé que g pour produire la séquence pseudo-aléatoire à 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 aléatoires, alors que les symboles σk+1 · · · σ` sont pseudoaléatoires. Soit Hk la variable aléatoire égale à la production du générateur pseudo-aléatoire hk . Montrons que la distance calculatoire entre Hk et Hh+1 est négligeable, ce qui démontrera le théorè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 déduire un algorithme contre le générateur pseudoaléatoire g1 . Ceci montrera que si g1 est un générateur pseudo-aléatoire, alors hk et hk+1 sont calculatoirement indiscernables. Supposons donc l’existence d’un distingueur Dk , capable de discerner une réalisation de hk d’une réalisation de hk+1 avec un avantage non-négligeable. Ce distingueur peut être utilisé pour réaliser un algorithme A qui discerne une réalisation de g1 (GPA) d’une réalisation d’une variable entièrement aléatoire (GDA) comme suit : Sur une entrée y ∈ {0, 1}n+1 , l’algorithme construit la séquence σ1 . . . σ` , en tirant σ1 · · · σk au hasard, puis en posant y = (sk+1 , σk+1 ), puis, pour i = k + 2 jusqu’à `, en calculant (si , σi ) = g1 (si−1 ). Si le distingueur Dk répond hk , intuitivement, c’est que la valeur de y est elle-même issue d’un calcul y = g1 (s). L’algorithme A renvoie GPA. Si au contraire, le distingueur Dk répond hk+1 , c’est que la valeur de y est aléatoire, et donc l’algorithme A renvoie GDA. Par construction, l’algorithme A répond GPA sur une entrée y avec la même probabilité que Dk répond hk sur une entrée σ = σ1 , . . . , σ` . Prob A(y) = GPA = Prob Dk (σ) = hk Il en résulte que A et Dk ont le même avantage. Si celui de Dk n’est pas négligeable en `, alors celui de A n’est pas négligeable non plus en n. § IV.5 Exercices 1. Une application de la technique hybride Soit g : {0, 1}n −→ {0, 1}2n un générateur pseudoaléatoire d’expansion `(n) = 2n. Démontrer que pour tout polynô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) ) définit un générateur pseudo-aléatoire. Plus précisément, montrer que si G est la variable aléatoire G = g(X) avec X aléatoire dans {0, 1}n , et Gt(n) = gt(n) (X1 , . . . , Xt(n) ), avec les Xi aléatoires dans {0, 1}n ∆ Gt(n) , U2nt(n) ≤ t(n)∆ G, U2n 2. Démontrer que s’il existe un générateur pseudo-aléatoire avec une expansion `(n) = 2n, alors il existe une fonction à sens unique. 3. Construire un générateur pseudo-aléatoire avec la fonction RSA. 4. Démontrer la sécurité du générateur de Blum-Blum-Shub défini comme suit : N =p×q sk+1 = s2k mod N σk = sk mod 2 5. (multiples message RSA avec le même exposant public) Montrer qu’on peut facilement retrouve un message m en observant les e cryptogrammes de m chiffrés avec le mê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 Générateurs pseudo-aléatoires 1. Démontrer que la fonction E est une bijection. 2. Étant donné la clé privée p × q, décrire la fonction de dé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 ). Dé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 propriété intéressante d’homomorphisme suivante : E(m1 , r1 ) × E(m2 , r2 ) = E(m1 + m2 , r1 r2 ) Montrer comment cela peut avantageusement s’appliquer au vote électronique, en association avec une fonction de partage de secret. § V.1 Motivation et définition V – FONCTIONS PSEUDO-ALÉATOIRES § V.1 Motivation et définition Les générateurs pseudo-aléatoires présentés au paragraphe précédent permettent déjà de réaliser un chiffrement de messages plus longs que la clé. Dans le chiffrement de Vernam, chaque symbole binaire du message est additionné modulo 2 au symbole correspondant d’une chaı̂ne aléatoire partagée par les correspondants, comme illustré ci-après : s ⊕ m = c Pour assurer la sécurité de ce type de chiffrement, il est primordial de n’utiliser la séquence aléatoire qu’une seule fois (one time pad). Pour chiffrer un autre message, il faut utiliser une autre graine. Un générateur pseudo-aléatoire peut permettre d’utiliser la même graine pour chiffrer plusieurs messages. Une manière de procéder est de produire une très longue chaı̂ne pseudo-aléatoire, et de communiquer un indice à partir duquel considérer la séquence pseudo-aléatoire pour le chiffrement. s GPA - σi ⊕ m = c Comme la production des symboles pseudo-aléatoires est itérative, l’inconvénient est alors d’avoir à recommencer tous les calculs depuis le premier à chaque message. L’idéal serait d’avoir un accès direct aux termes suivants de la séquence pseudo-aléatoire, sans avoir à calculer les précédents. La notion famille de fonctions pseudo-aléatoires réponds à 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 aléatoire. Notons Hn l’ensemble de toutes les fonctions {0, 1}`(n) −→ {0, 1}≤`(n) . Une famille pseudo-aléatoire est une famille de fonction qu’on ne sait pas distinguer de Hn . Définition V.1 [famille de fonctions pseudo-aléatoires] Une famille de fonctions Fn = Fk : {0, 1}`(n) −→ {0, 1}≤`(n) | k ∈ {0, 1}n est dite pseudo-aléatoire si elle satisfait les deux propriétés suivantes : 1. Elle est efficacement calculable, c’est-à-dire il existe un algorithme en temps polynomial qui sur l’entrée k ∈ {0, 1}n et x ∈ {0, 1}`(n) , retourne la valeur Fk (x). 2. Elle est pseudo-aléatoire, c’est à dire l’avantage de tout algorithme A en temps polynomial, qui distingue un élément de la famille Fn d’une fonction aléatoire de Hn est négligeable : ProbF ∈R Fn AF (1n ) = 1 − ProbH∈R Hn AH (1n ) = 1 est une fonction négligeable de n. q qqAA Le nombre des paramètres k ∈ {0, 1}n des fonctions Fk vaut 2n qui est une fonction exponentielle en n. Un générateur pseudo-aléatoire ne définit donc pas directement une famille de fonctions pseudo-aléatoires, car on ne peut pas calculer efficacement toutes les valeurs. 27 28 Fonctions pseudo-aléatoires Un adversaire contre une famille de fonctions aléatoires est un algorithme qui fait des requêtes à un oracle. Il existe deux sortes d’oracles : les oracles qui, sur une entrée x, rendent la valeur FK (x) d’un élément fixé, mais inconnu de la famille Fn , et les oracles qui, sur une entrée x, rendent la valeur H(x) d’une fonction aléatoire fixée. L’algorithme doit pouvoir efficacement répondre si les réponses de l’oracle sont celles d’une fonction aléatoire ou d’une fonction pseudo-aléatoire. § V.2 Construction d’une famille de fonctions pseudo-aléatoires Ce paragraphe présente la construction d’une famille de fonctions pseudo-aléatoires (FPA) à partir d’un générateur pseudo-aléatoire (GPA). Elle est due à Goldreich, Goldwasser et Micali. On suppose que l’on dispose d’un générateur pseudo-alé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 générateur pseudo-aléatoire g. g s g0 (k) - g1 (k) Soit s la graine du générateur pseudo-aléatoire g. On étend ré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 définie, pour x ∈ {0, 1}`(n) , par : fs (x) = g x (s). Cette construction peut se repré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’é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-aléatoires Théorè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-aléatoires. Preuve. La preuve de ce théorè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 aléatoire d’un élément dans H 0 est dans le choix aléatoire de la valeur s situé à la racine de l’arbre ci-dessus. Le choix aléatoire d’un élément dans la famille H n est dans le choix aléatoire de chacune des feuilles de l’arbre. Les familles H i , pour i = 1 jusqu’à n − 1 seront définies en choisissant aléatoirement les valeurs situées à la profondeur i dans l’arbre, puis en calculant les fils avec les deux fonctions g0 et g1 du générateur pseudo-alé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 donnée par fs (x) = gxn ◦ · · · ◦ gx2 ◦ gx1 (s). Cette famille est illustré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 donnée par fs0 s1 (x) = gxn ◦ · · · ◦ gx2 (sx0 ). Une illustration de cette famille est donné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’élément de la famille ← valeurs calculé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 donné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’élément s11 de la famille A A A A n n n n← valeurs calculé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 donnée par fs0···0 ···s1···1 (x) = gxn ◦ · · · ◦ gxk+1 (sx0 ···xk ). Pour achever la preuve, il reste à montrer que la distance calculatoire entre deux familles consécutives reste négligeable. C’est l’objet du lemme qui suit. Lemme V.3 On reprend les notations de l’exercice 1 de la section précédente. Soit t(n) un polynôme en n. Pour tout distingueur D de H k et H k+1 qui effectue moins de t(n) requêtes un oracle répond selon un élément d’une de ces deux familles, alors AdvD H k , H k+1 ≤ ∆(Gt(n) , U2nt(n) 29 30 Fonctions pseudo-aléatoires Preuve. Par contraposée, supposons qu’il existe un distingueur D, capable de discerner entre H k et H k+1 avec t(n) requêtes avec un avantage non négligeable, et montrons qu’on peut construire un distingueur B capable de discerner entre la variable aléatoire Gt(n) , développement t(n) fois du générateur pseudo-aléatoire G, et la variable aléatoire uniforme U2nt(n) sur 2nt(n) symboles binaires. L’entrée de l’algorithme B est un vecteur α = α1 , . . . αt(n) , où chaque αi = (αi0 , αi1 ) est constitué de deux composantes dans {0, 1}n . L’algorithme B utilise le distingueur D pour répondre si l’entrée α est le résultat du générateur pseudo-aléatoire ou est du véritable aléa. L’algorithme B va simuler un oracle auprès du distingueur D. Afin de discerner entre H k et H k+1 , le distingueur D va déposer des requêtes qui consistent à calculer la valeur de l’oracle pour une valeur x = x1 , . . . xn . Lorsque D dépose la ie requête x1 · · · xn , l’algorithme B vérifie d’abord si le préfixe x1 · · · xk+1 n’est pas le préfixe d’une requête déjà déposée. Si le préfixe est nouveau, l’algorithme B calcule la valeur fs (x) de l’oracle en simulant un élément de la famille H k+1 en utilisant le vecteur αi comme paramè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 initialisées selon xk ← valeurs calculées par g0 ou g1 selon xk+1 Si le préfixe de la requête est le même qu’une requête déjà déposée, alors l’algorithme B renvoie à D la valeur antérieurement calculée pour ce préfixe. Ainsi, si αi est le résultat du générateur pseudo-aléatoire g, alors cet oracle simule exactement H k et si αi est un aléa véritable, alors cet oracle simule exactement H k+1 . Par conséquent, si le distingueur D sait discerner entre Gt(n) et Unt(n) , alors, en rendant le même résultat que D,l’algorithme B sait discerner entre H k et H k+1 avec le même avantage : AdvD H k , H k+1 = AdvB Gt(n) , U2nT (n) Le résultat du lemme s’obtient par passage à la borne supérieure sur tous les distingueurs de Gt(n) et U2nt(n) . Fin de la preuve du théorème V.2. D’après l’exercice 1 de la section précédente, on a ∆ Gt(n) , U2nt(n) ≤ t(n)∆ G, U2n Par composition, l’avantage d’un distingueur de F et H est majoré par nt(n)∆ G, U qui est n n 2n négligeable dès que ∆ G, U2n est négligeable. § V.3 Exercices 1. On reprend la construction de Goldreich, Goldwasser et Micali, mais au lieu de définir des fonctions {0, 1}n , on les définit sur {0, 1}≤n . C’est-a-dire que f (x) est défini pour des tailles de x variables de 1 jusqu’à n symboles binaires. Cela définit-il encore une famille de fonctions pseudo-aléatoire ? 2. Construction d’une famille pseudo-aléatoire de fonctions vectorielles à partir d’une famille de fonctions booléennes pseudo-aléatoires. Étant donnée une famille pseudo-aléatoire fk k∈{0,1}n de § V.3 Exercices fonctions booléennes fk : {0, 1}p(n) −→ {0, 1}, construire une famille de fonctions pseudo-aléatoire gs s∈S de fonctions vectorielles gs : {0, 1}p(n) → {0, 1}` . 3. Une famille de fonctions pseudo-aléatoires est toujours à sens unique On dit qu’une famille de fonctions pseudo-aléatoires {0, 1} −→ {0, 1} est une famille pseudoaléatoire de fonctions à sens unique si, étant donnée un élément y de l’image {0, 1}n , et étant donné un oracle qui réalise un élément aléatoire fk de la famille, tout algorithme efficace ne peut trouver un antécédent de y de fk qu’avec une probabilité négligeable. q Cela ne signifie pas que les éléments fk de la famille sont des fonctions à sens unique. qqAA Connaissant la clé k, il n’y a aucune raison que ces fonctions soient difficiles à inverser. La définition stipule seulement qu’il n’est pas possible de trouver un antécédent d’un élément y sans connaissance de la clé k et lorsqu’on ne dispose que d’un oracle pour déterminer les valeurs fk (x). Montrer que si la famille Fn est une famille de fonctions pseudo-aléatoire, alors elle est une famille pseudo-aléatoire de fonctions à sens unique. 31 32 Permutations pseudo-aléatoires VI – PERMUTATIONS PSEUDO-ALÉATOIRES § VI.1 Motivation et définition Une famille de fonctions pseudo-aléatoires permet de réaliser du chiffrement symétrique. Le paramètre d’indice de la famille est la clé secrète s. Pour chiffrer un message m de n symboles binaires, on masque m avec une valeur fs (x) pour une valeur x aléatoire qui est transmise avec le cryptogramme : (s, x) 7−→ fs (x) ⊕ m = c = m ⊕ fs (x) Le cryptogramme est γ = (x, c). Un défaut de cette méthode est l’obligation d’adjoindre au cryptogramme un paramètre x, obligatoire pour le déchiffrement. L’opération de chiffrement ne préserve pas la longueur. L’objet de cette section est de définir des familles de permutations pseudo-aléatoires, qui sont chacune inversible, pour réaliser le chiffrement par bloc. Le cryptogramme est directement l’image du clair par un élément de cette famille. Le clair se retrouve en inversant la fonction. Définition VI.1 [famille de permutations pseudo-aléatoires] Une famille Pn = pk k∈{0,1}n de permutations pk : {0, 1}p(n) −→ {0, 1}p(n) est dite pseudoaléatoire si les trois conditions suivantes sont satisfaites : 1. chaque élément est efficacement calculable : il existe un algorithme efficace V qui calcule la valeur de tout élément pour tout paramètre k et toute entrée x : ∀k ∈ {0, 1}n , ∀x ∈ {0, 1}p(n) , V (k, x) = pk (x). 2. chaque élément est efficacement inversible : il existe un algorithme efficace V qui calcule l’antécédent de tout élément y pour tout paramètre k : ∀k ∈ {0, 1}n , ∀y ∈ {0, 1}p(n) , N (k, y) = p−1 k (y). 3. elle a le caractère pseudo-aléatoire : tout algorithme efficace A ne sait distinguer un élément de la famille d’une permutation réellement aléatoire qu’avec une probabilité négligeable, c’est-à-dire l’avantage de A défini par : AdvA = Probp∈R Pn Ap (1n ) = 1 − Probf ∈R Rn Af (1n ) = 1 où Rn désigne l’ensemble de toutes les bijection sur {0, 1}p(n) , est une fonction négligeable de n. L’algorithme Ah fait appel à un oracle qui réalise le calcul y = h(x). Il renvoie une valeur qui vaut 1 si A redonnait en h un élément pseudo-aléatoire et renvoie 0 dans le cas contraire, c’est-à-dire que A reconnaı̂t en h un élément aléatoire. Une famille de permutations est pseudo-aléatoire si tout algorithme Ah ne donne la bonne réponse qu’avec un avantage négligeable. r Il existe également une notion plus forte de famille de permutation super pseudo-aléatoire, dont les éléments restent indistinguable d’une permutation alé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 à partir d’une famille de FPA Construction à partir d’une famille de FPA Le schéma de Feistel est une construction d’une bijection à partir d’une fonction non nécessairement bijective. C’est cette construction, itérée sur 16 tours, qui est à l’œuvre dans beaucoup d’algorithmes de chiffrement par bloc comme le DES. Un mot de 2n symboles binaires est partagé en deux parties de n symboles binaires chacune : la partie gauche notée L et la partie droite notée R. L R @ @ @ fn @ @ @ k + L1 L1 = R R1 = L ⊕ f (R) Réciproque : R = L1 L = R1 ⊕ f (L1 ) R1 Ce schéma est toujours inversible, y compris lorsque la fonction f utilisée ne l’est pas. q Même si on suppose que la fonction f est aléatoire, un tour de Feistel n’a pas la propriété qqAA d’être pseudo-aléatoire, puisque la partie gauche du résultat est toujours égale à la partie droite. Il est immédiat de construire un distingueur qui saura presque toujours distinguer entre un tour de Feistel et une fonction aléatoire. Il n’échouera que si fortuitement une fonction aléatoire renvoie une valeur gauche égale à son entrée droite, ce qui est né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 schéma à deux tours n’a pas non plus la propriété d’être pseudo-aléatoire. Alors que pour une bijection aléatoire, deux entrées différentes ont des sorties distinctes, aléatoires et indépendantes. Dans le schéma de Feistel à deux tours, on a la relation : L ⊕ L2 = f (R). Ainsi en envoyant deux requêtes (L, R) et (L0 , R) à l’oracle avec la même partie droite R, on peut reconnaı̂tre le schéma de Feistel à deux tours en calculant la somme modulo 2 des entrées gauche et des sorties gauches L ⊕ L2 et L0 ⊕ L02 . Si on trouve que ces sommes sont égales, alors avec une très forte probabilité, l’oracle est celui d’un schéma de Feistel à deux tours. Il est hautement improbable d’avoir cette propriété avec une fonction aléatoire. 33 34 Permutations pseudo-aléatoires Il faut au moins trois tours avec trois fonctions de tour choisie aléatoirement dans une famille pseudo-aléatoire de fonctions pour atteindre la propriété d’être une famille pseudo-aléatoire de permutations, et il faut quatre tours pour atteindre la propriété d’être une famille super pseudoaléatoire de permutations. Nous allons démontrer la première propriété. L R @ @ @ fn 1 @ @ @ k + L1 @ R1 @ @ fn 2 @ @ @ k + L2 @ R2 @ @ fn 3 @ @ @ k + L3 R3 Soit Fn une famille de fonctions pseudo-alé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 schéma avec deux itérations utilisant dans cet ordre les fonctions f1 et f2 sur {0, 1}n . Cela se généralise en posant pour tout entier ` : Feistelf1 ···f` = Feistelf` ◦ Feistelf1 ···f`−1 . Si les fonctions fi sont choisies dans la famille pseudo-aléatoire Fn , cela définit une famille de bijections. Pour tout entier `, la famille des fonctions de Feistel à ` tours, construite à partir de la famille Fn est notée Feistel`Fn : Feistel`Fn = Feistelf1 ···f` | f1 , · · · , f` ∈ Fn . Théorème VI.2 [Luby – Rackoff, ] La famille Feistel3Fn est une famille de permutations pseudo-alé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-à-dire que leur distance calculatoire est négligeable. La première étape est de montrer que la famille Feistel3Fn est indistinguable de la famille des schémas de Feistel à trois tours où les fonctions de tour sont des fonctions aléatoires. En d’autres § VI.2 Construction à partir d’une famille de FPA termes, si on note Hn la famille des fonctions alé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 aisément avec la technique hybride. En remplaçant successivement une fonction de tour pseudo-aléatoire par une fonction aléatoire, on peut observer que distinguer ces deux cas revient à distinguer un élément de Fn d’un élément de Hn , d’où : ∆ Feistel3Fn , Feistel3Hn = 3∆ Fn , Hn La famille Fn étant supposée pseudo-aléatoire, le membre de droite ci-dessus est né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 schéma de Feistel sont des fonctions aléatoires. Si on montre que la valeur n’est pas distinguable d’un aléa, on aura montré qu’un algorithme ne peut pas discerner un schéma de Feistel à trois tours avec des fonctions de tour aléatoire d’une permutation aléatoire. Soit R1i la valeur R1 interne au schéma de Feistel au cours de la ie requête. On note Em l’énènement : Em : hh Il existe deux requêtes différentes i et j, avec i ≤ j telles que R1i = R1j et R2i = R2j ii. Évaluons la probabilité de cet évènement. Prob[Em ] = Prob[Em−1 ] + Prob[Em | ¬Em−1 ] × Prob[Em−1 ] {z } | ≤1 ≤ Prob[Em−1 ] + Prob[Em | ¬Em−1 ] Si l’évènement Em a lieu sans que l’évè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 résulte : (5) Prob[Em | ¬Em−1 ] ≤ m X Prob[R1i = R1m ] + i=1 m X Prob[R2i = R2m ] i=1 On est amené à évaluer Prob[R1i = R1m ]. Examinons ce qui se passe au tour précédent au cours des ie et me requêtes. Si R0i 6= R0m , comme la fonction f1 est aléatoire, les valeurs de R1 au tour i et m sont aléatoires avec probabilité uniforme. Elles sont égales avec une probabilité égale à 1/2n . Si R0i = R0m , alors, comme les requêtes sont distinctes, on a nécessairement Li0 6= Lm 0 donc R1i 6= R1m . Pour tout indice i de requête inférieur à m, on a Prob[R1i = R1m ] = 1/2n . Donc : m X i=1 Prob[R1i = R1m ] ≤ m−1 . 2n On a un résultat identique pour le deuxième terme de (5) en remplaç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-aléatoires En appliquant récursivement cette inégalité 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 quantité est négligeable, car m est borné par un polynôme en n. É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 reçoit une fonction de Fn3 . Pour évaluer la probabilité de succès de A dans ce cas, conditionnons par l’évè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’inégalité : AdvA ≤ F F m2 3 A + = 1 | ¬E − Prob A = 1 Prob m F ∈R F ∈F 2n n 2n L’évènement Em signifie que pour toutes requêtes i et j, on a R2i 6= R2j et R1i 6= R1j . Par conséquent, comme f3 est une fonction aléatoire, les valeurs R3i sont indépendantes et uniformément distribuées. De même, par passage dans la fonction aléatoire f2 , les R2i sont indépendants et uniformément distribués sur {0; 1}n . Le seul écart à une sortie vraiment aléatoire des couples (Li3 , R3i ) dans le cas d’un schéma de Feistel, est qu’on a toujours Li3 6= Lj3 puisque L3 = R2 . L’écart à une distribution uniforme est donné par la probabilité de collision de m valeurs alé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 inférieure à 2 × n qui est négligeable. 2 § VI.3 Exercices 1. Considérons la famille des schémas de Feistel à trois tours dans laquelle la fonction centrale f2 est définie par f2 : x 7−→ x ⊕ i(x), oà la fonction i est involutive, c’est-à-dire vérifie i ◦ i(x) = x pour tout x ∈ {0, 1}n . a) Montrer que f2 ◦ i = f2 . b) En déduire que qu’alors, la famille de bijections obtenue n’est plus pseudo-aléatoire. Indication : chercher deux requêtes différentes qui donneront la même partie gauche L3 = L03 avec ce shéma. 2. Soit Fn = fk k∈{0,1}n une famille pseudo-aléatoire de bijection de {0, 1}n . Pour tout paramètre k, on dé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 à est-elle pseudo-aléatoire ? § VII.1 Schéma de chiffrement VII – CHIFFREMENT § VII.1 Schéma de chiffrement Un schéma de chiffrement consiste en une famille de fonctions de chiffrement et de déchiffrement, selon la valeur d’un paramètre de sécurité n qui évalue sa résistance calculatoire. Définition VII.1 [schéma de chiffrement] Pour un paramètre de sécurité donné, un schéma de chiffrement est la donnée d’un domaine Dn des messages, d’un domaine Rn des cryptogrammes et de trois algorithmes efficaces : 1. Un algorithme G(1n ) de génération de clé qui produit une paire de clé (e, d). Une clé e pour le chiffrement, et une clé d pour le déchiffrement. 2. Un algorithme E de chiffrement, éventuellement non déterministe qui, pour chaque message m dans Dn produit un cryptogramme c dans Rn en fonction de la clé de chiffrement e : c = E(e, m). 3. Un algorithme D, nécessairement déterministe, qui pour un cryptogramme qui est le résultat d’un chiffrement, produit le message clair correspondant, à l’aide de la clé de déchiffrement, c’est-à-dire pour tout m ∈ Dn , on a : D d, E(e, m) = m. On distingue deux cas : – Si e = d, c’est-à-dire si la clé de chiffrement est la même que la clé de chiffrement, le schéma de chiffrement est dit symétrique. – Dans le cas contraire, c’est-à-dire si e 6= d, le schéma de chiffrement est dit asymétrique. q La clé de déchiffrement doit impérativement rester secrète. Si e 6= d, et si on ne sait pas qqAA calculer la clé de déchiffrement d à partir de la clé de chiffrement e, alors il n’y a aucune raison de cacher e. Elle peut être publiée. On a alors affaire à un schéma de chiffrement à clé publique. r Si l’algorithme de chiffrement n’est pas déterministe, alors un même message peut avoir plusieurs cryptogrammes. Mais pour chacun de ces cryptogrammes, l’algorithme de déchiffrement retourne toujours le même message d’origine. C’est par exemple le cas du système de chiffrement El Gamal. § VII.2 Notions de sécurité La notion de fonction à sens unique est insuffisante pour une fonction de chiffrement satisfaisante. On a vu que si f est une fonction à 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 à sens unique, puisque pour inverser g, il est nécessaire de pouvoir inverser f . Par contre il s’agit d’une piteuse fonction de chiffrement, car la moitié des symboles binaires du clair ne sont pas chiffrés. Ce qu’on attend d’une fonction de chiffrement est qu’elle protège tous les bits du message clair. On peut imaginer par exemple qu’un long message militaire contienne une information cruciale, comme la décision ou non d’attaquer l’ennemi. 37 38 Chiffrement Il existe deux notions de sécurité : la sécurité sémantique et l’indistinguabilité. La première décrit bien ce que les acteurs d’un système cryptographique attendent comme service de confidentialité. La seconde est commode pour établir des preuves de sécurité. Nous montrons dans ce paragraphe que ces deux notions sont finalement équivalentes. VII.2.1. Sécurité sémantique La sécurité sémantique est la version calculatoire de la sécurité parfaite. Elle é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 à partir du cryptogramme alors la sécurité sémantique n’est pas atteinte. Un adversaire d’un schéma de chiffrement contre la sécurité sémantique est un algorithme A, à qui on fournit le cryptogramme d’un message x, et qui doit retourner la valeur f (x) d’une information arbitraire sur x. Définition VII.2 [Sécurité sémantique] Un schéma de chiffrement C = (D, Rn , G, E, D) est dit sémantiquement sûr, noté SEM–sûr, si pour tout adversaire A en temps polynomial, pour toute fonction f sur sur Dn et toute distribution de probabilité 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 négligeable. Un adversaire contre un schéma de chiffrement pour la sécurité sémantique est un algorithme qui doit retrouver une information f (x) sur le clair x à partir du cryptogramme E(e, x). L’expression de l’avantage donné par la relation (6) exprime qu’il n’y a pas de différence de probabilité de succès notable de l’algorithme A pour trouver l’information f (x) qu’on lui fournisse le chiffré du message x (premier terme) ou le chiffré d’un autre message aléatoire x0 (second terme). r La probabilité exprimée dans cette définition est pour une clé de chiffrement aléatoire e fournie par l’algorithme de génération de clé, et pour des messages clairs aléatoires. L’adversaire connaı̂t la distribution de probabilités et la fonction f , mais ignore bien sûr la clé de déchiffrement ainsi que le message clair correspondant au cryptogramme qu’il reçoit en entrée. q qqAA La sécurité sémantique est atteinte si l’avantage de tout adversaire est négligeable, pour toute distribution de probabilité sur les clairs. En particuier si deux messages clairs seulement sont également probales. VII.2.2. Indistinguabilité Un chiffrement a la propriété d’indistinguabilité si un adversaire est incapable de dire si le cryptogramme qu’on lui présente provient de l’un ou de l’autre message, sachant que le cryptogramme est le chiffré d’un de ces deux messages. Un adversaire d’un schéma de chiffrement contre la propriété d’indistinguabilité est un algorithme A à qui on fournit le cryptogramme d’un message mi choisi aléatoirement dans un ensemble de deux messages distincts {m0 , m1 } et qui doit rendre l’indice i ∈ {0, 1}. § VII.2 Notions de sécurité Définition VII.3 [indistinguabilité] On dit qu’un schéma de chiffrement C = (Dn , Rn , G, E, D) a la propriété d’indistinguabilité 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 négligeable. r Pour que cette définition ait un sens, il faut que les messages aient la même taille, ou que la taille du cryptogramme ne donne pas d’information sur la nature du message qui a été chiffré. r La propriété d’indistinguabilité énonce que tout adversaire é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 succès. Exemple. Soit E la fonction de chiffrement d’un schéma de chiffrement C. Soit C 0 le schéma de chiffrement presque identique à C, mais dans lequel la fonction de chiffrement a été remplacé par la fonction E 0 donnée par : ( E(e, m) si m 6= 1n , 0n 0 E (e, m) = 0n si m = 0n n 1 si m = 1n Le schéma de chiffrement C 0 n’est pas sémantiquement sûr, car avec la distribution de probabilité donné par : n n n Prob[m] = 1/2 si m = 0 ou 1 , 0 sinon il est très facile de construire un adversaire contre la sécurité sémantique de C 0 qui donne toujours la bonne réponse pour tout fonction d’information f . Le shéma de chiffrement C 0 n’a pas non plus la propriété d’indistinguabilité, car il est immédiat également de construire un adversaire qui sait distinguer entre le chiffré de 0n et celui de 1n . VII.2.3. Équivalence des deux notions La sécurité sémantique correspond à ce qui est intuitivement requis pour avérer la sécurité d’un schéma de chiffrement. L’indistingabilité est une notion plus commode à manipuler. Mais les deux notions sont équivalentes. Théorème VII.4 [équivalence de la sécurité sémantique et de l’indistinguabilité] Un shéma de chiffrement est sémantiquement sûr si et seulement si il a la propriété d’indistinguabilité. Preuve. Montrons tout d’abord l’implication SEM =⇒ IND, ou , ce qui est équivalent, la contraposée ¬IND =⇒ ¬SEM. On suppose qu’il existe un algorithme efficace A et deux messages m0 et m1 tel que A sait distinguer un chiffré de m0 d’un chiffrer de m1 avec un avantage ε(n) non né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 sécurité sémantique avec la distribution sur les messages clairs donné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 sécurité sémantique vaut ε(n)/2. Pour cela, évaluons la probabilité que A donne f (x) selon que x vaut m0 ou m1 . L’avantage de A pour l’indistinguabitité 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 indépendants, chacun avec probabilité 1 1 , on a B = . 2 2 Inté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 ré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 réciproque IND =⇒ SEM, ou , ce qui est équivalent, la contraposée ¬SEM =⇒ ¬IND. On suppose qu’il existe une distribution de probabilité Xn sur les messages clairs, et un algorithme A, efficace contre la sécurité sémantique pour la fonction f dont l’avantage ε(n) est une fonction non négligeable. Construisons un algorithme B contre l’indistinguabilité : – On choisit deux messages m0 et m1 de probabilité non nulle. – L’entrée c de l’algorithme B est le chiffré d’un de ces deux messages, avec probabilité 1/2. – L’algorithme B doit décider si c provient du chiffrement de m0 ou de m1 . Pour cela, il soumet c à l’algorithme A. Soit α la réponse de A qui est supposé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 égaux à α, alors cela signifie un échec de l’algorithme A, et B répond aléatoirement 0 ou 1 avec une probabilité uniforme. Calculons l’avantage de cet algorithme contre l’indistinguabilité. Pour cela, posons c1 = R(e, m1 ) le chiffré du message m1 et estimons Prob B(c1 ) = 1 suivant les trois évènements qui correspondent § VII.3 Modèles d’attaques aux trois cas ci-dessus. Par dé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 différence et après simplification de la différence des termes é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’indistinguabilité est le même que l’avantage de l’algorithme A contre la sécurité sémantique. § VII.3 Modèles d’attaques Pour résoudre le problème qui lui est assigné, contre la sécurité sémantique ou contre l’indistinguabilité, un adversaire contre un schéma de chiffrement peut disposer de certaines informations, ce qui classifie les attaques en deux catégories : les attaques à clair choisi et les attaques à cryptogramme choisi. VII.3.1. Attaques à clair choisi Au cours de son exécution, l’algorithme contre un shéma de chiffrement peut accéder à un oracle de chiffrement qui lui répondra le chiffré des requêtes qui lui sont soumises. On parle alors d’attaque à clair choisi, noté CPA (Chosen Plaintext Attack). On notera par exemple CPA-IND la propriété d’indistinguabilité d’un schéma de chiffrement pour tout adversaire qui dispose d’un oracle de chiffrement. r Noter que dans un chiffrement à clé publique, la clé de chiffrement étant publique, l’adversaire peut toujours chiffrer les messages de son choix. La notion d’attaque à clair choisi n’est pertinente que pour le chiffrement symétrique, où l’adversaire, ne disposant pas de la clé de chiffrement, doit avoir recours à un oracle pour obtenir des couples (clair, cryptogramme) de son choix. VII.3.2. Attaques à cryptogramme choisi Dans certaines situations concrètes, le modèle d’attaque à clair choisi peut s’avérer insuffisant, et on peut exiger un niveau supplémentaire de sécurité. Imaginons par exemple qu’un adversaire concret emprunte le dispositif de déchiffrement pendant un certain temps, ou bien puisse accéder temporairement au local où le déchiffrement se réalise. Il faut alors considérer un modèle où l’adversaire peut accéder à un oracle de chiffrement. Il s’agit d’attaque à cryptogramme choisi, notée CCA (Chosen Ciphertext Attack). r Pour que cette attaque ait un sens, il faut bien sûr interdire les requêtes qui consiste à demander le déchiffrement du défi qui est soumis à l’adversaire. On notera par exemple CCA-SEM la sécurité sémantique d’un schéma de chiffrement pour tout adversaire qui dispose d’un oracle de déchiffrement. 41 42 Chiffrement § VII.4 Construction d’un schéma de chiffrement IND–CPA Dans cette section, on montre que le schéma de chiffrement symétrique construit à partir d’une famille de fonctions pseudo-aléatoires a la propriété d’indistinguabilité dans une attaque à clairs choisis. Rappelons tout d’abord la construction. On suppose qu’on a une famille Fn de fonctions pseudoaléatoires Fn = (fk )k∈{0,1}n , où les fk sont des fonctions {0, 1}n −→ {0, 1}n . Le schéma de chiffrement est défini par : – L’algorithme G(1n ) de génération de clé choisit aléatoirement une clé k dans {0, 1}n . – L’algorithme Ek (r, m) de chiffrement est un algorithme probabiliste qui, à un alé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, masqué par une valeur pseudo-aléatoire fk (m). La première composante r permet au détenteur de la clé secrète k de retrouver le masque. – L’algorithme de déchiffrement Dk (r, c) retrouve le message m par le calcul m = c ⊕ fk (r). r La valeur fk (r) est une clé de session utilisée uniquement au cours du chiffrement de ce message. On peut potentiellement utiliser la même clé k pour produire un nombre exponentiel de clés de session. On considère ici que les messages ont une taille fixe, de n symboles binaires. Montrons dans la suite de cette section que ce schéma de chiffrement est IND-CPA, c’est-a-dire qu’il a la propriété d’indistinguabilité au cours d’une attaque à clairs choisis. La première étape de la preuve est de montrer que si on remplace dans le schéma de chiffrement la fonction pseudo-aléatoire fh par une fonction entièrement aléatoire h, alors l’avantage d’un adversaire ne dépasse pas l’avantage d’un algorithme qui sait discerner une fonction pseudoaléatoire d’une fonction aléatoire. L’interaction entre l’adversaire A du schéma de chiffrement et l’environnement lors d’une attaque est modélisée par un jeu. Le jeu, noté jeu 0, correspond à la situation réelle. L’adversaire A joue contre un maitre du jeu qui correspond à l’environnement E. Les étapes sont les suivantes : Une clé k est choisie aléatoirement k = G(1n ). Au cours du jeu, l’adversaire A accède à un oracle de chiffrement fk . L’adversaire soumet à cet oracle un message m, et l’oracle lui renvoie (r, c) = Ek (r, m) pour une valeur r, aléatoire dans {0, 1}n . L’adversaire A choisit deux messages m0 et m1 . L’environnement E choisit un bit aléatoire b dans {0, 1}, puis lance à l’adversaire A le défi de retrouver b en lui indiquant le cryptogramme du message mb qui vaut (α, fk (α) ⊕ mb ). Ce cryptogramme est un chiffré de m0 si le bit b vaut 0, et est un chiffré de m1 si le bit b vaut 1. L’objectif de l’adversaire A est de savoir si ce cryptogramme est le chiffré de m0 ou de m1 . Après un certain nombre d’appels à l’oracle, l’algorithme A donne sa réponse. Soit b0 la réponse de A. L’algorithme A a gagné si b = b0 et il a perdu dans le cas contraire. Notons E0 l’évènement hh A a gagné dans le jeu 0 ii. Définissons l’avantage de A dans ce jeu comme étant la valeur AdvA 0 = 2 Prob(E0 ) − 1. Il est nul si A a répond au hasard, vaut 1 si A gagne toujours et −1 s’il perd toujours. Considérons aussi le jeu noté jeu 1, similaire au jeu 0, mais au lieu d’utiliser une fonction pseudoaléatoire fk pour le chiffrement, l’environnement utilise une fonction h parfaitement aléatoire {0, 1}n → {0, 1}n . On note E1 l’évè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 énonce que la différence des probabilités de gain de A dans le jeu 0 et dans le jeu 1 ne peut pas dépasser l’avantage d’un adversaire contre la famille pseudo-aléatoire. § VII.4 Construction d’un schéma de chiffrement IND–CPA Lemme VII.5 Soit εfpa l’avantage maximal d’un adversaire contre la famille de fonctions pseudo alé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 élément fk de la famille pseudo-aléatoire d’une fonction parfaitement aléatoire avec un avantage au moins égal à Prob(E0 ) − Prob(E1 ). Le distingueur D accède à un oracle O qui est soit un élément fk de la famille de fonctions pseudoaléatoires, soit une fonction h parfaitement aléatoire. Ce distingueur, pour établir sa réponse, va utiliser l’adversaire A contre notre schéma de chiffrement. Pour cela, il va simuler l’environnement, c’est-à-dire fournir à A tout ce dont il a besoin pour décider. Il va utiliser l’oracle 0 pour générer les clés de session. Lorsque A demande à chiffrer un message m, le distingueur D choisit un élément r aléatoire de {0, 1}n et renvoie à A la valeur (r, O(r) ⊕ m). Lorsque A fournit les messages m0 et m1 pour son défi, le distingueur D choisit un bit aléatoire b ∈ {0, 1}, une valeur aléatoire α ∈ {0, 1}n et lance le défi à A de trouver b à partir du cryptogramme (α, O(α) ⊕ mn ). L’algorithme A donne une réponse b0 . L’heuristique est de dire que, si A a donné la bonne réponse, c’est que l’oracle réalise une fonction pseudo-aléatoire, alors que s’il a donné la mauvaise réponse, c’est que l’oracle réalise une fonction parfaitement aléatoire. Aussi, si b = b0 , alors D renvoie A pour signifier que l’oracle réalise une fonction pseudo-aléatoire, et si b 6= b0 , il renvoie 0 pour signifier que l’oracle réaliser une fonction aléatoire. Il reste à évaluer l’avantage de D. Si l’oracle réalise une fonction pseudo-aléatoire, tout ce que D simule correspond au jeu 0, alors que si l’oracle réalise une fonction aléatoire, tout ce que D simule correspond au jeu 1. Il en résulte que l’avantage de D est le mê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 à prouver la propriété d’indistinguabilité du schéma de chiffrement dans une attaque à clairs choisis. Évaluons la probabilité Prob(E1 ) de gain au cours du jeu 1. Notons D l’évènement hh la valeur α dans le cryptogramme que doit décider A est différente des valeurs aléa ri ayant défini les clés de session au cours des q requêtes ii. Dans ce cas, la valeur des h(α) est parfaitement aléatoire, et la probabilité de gain de A ne peut pas dépasser 1/2 : Prob(E1 | D) ≤ 1 . 2 q Par ailleurs, avec une probabilité n , la valeur de α du cryptogramme tombe dans l’une des valeurs 2 ri au cours des s requê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 propriété 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 négligeable en n. q Il est crucial pour la preuve de ce résultat, que l’aléa choisi pour définir la clé de session qqAA soit parfaitement aléatoire. Si cela n’est pas le cas, la preuve de l’indistinguabilité n’est pas assuré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-aléatoires {0, 1}n −→ {0, 1}n . La question est : hh Comment peut-on chiffrer des messages constitué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 compléter avec des zéros pour atteindre cette taille. Mode dictionnaire, ou mode ECB (Electronic Code Book). Dans le mode ECB, le message est partagé en blocs de n symboles binaires. Chaque bloc est chiffré de manière indépendante. m1 ... m` ? ? ? pk pk pk ? c1 q qqAA m2 ? c2 ... ? c` Le mode ECB n’est pas sûr ! Il n’a pas la propriété d’indistinguabilité lors d’une attaque à clairs choisis. Voir l’exercice 3. Mode chainé, ou mode CBC (Cipher Block Chaining). Dans le mode CBC, le chiffrement des blocs ne sont plus indépendants les uns des autres. Le chiffrement d’un bloc dépend du cryptogramme du bloc précédent. Pour cela, il nécessite un vecteur initial (V I). § VII.6 Malléabilité VI ? c0 m1 m2 ? - +i ? - +i ... m` ? - +i - ... ? ? ? pk pk pk ? c1 ... ? c2 ... ? c` Les données chiffrées sont rendues aléatoires par l’addition du bloc de cryptogramme précédent. Le mode CBC est envisageable avec deux possibilités pour le vecteur initial : – Le vecteur initial peut être un compteur incrémenté à chaque message. – Le vecteur initial peut être initialisé avec de l’aléa à chaque message. q Lorsque l’adversaire peut prévoir la valeur du vecteur initial, le mode CBC n’est pas sûr. Voir qqAA l’exercice 4. En conséquence, il ne peut pas être un compteur. Théorème VII.6 Le mode CBC avec vecteur initial aléatoire est IND-CPA. Preuve. (plan) La méthode de preuve est la même que précédemment. On définit deux jeux pour l’adversaire. L’un, le jeu 0, avec une permutation pseudo aléatoire, l’autre, le jeu 1, avec une permutation parfaitement aléatoire. On montre en deux étapes que les avantages d’un adversaire au cours des jeux 0 et 1 ne diffèrent pas plus que l’avantage d’un distingueur entre une permutations pseudo-aléatoire et une permutation parfaitement aléatoire. Ensuite, observer les valeurs de Ti à l’entrée de la permutation à chaque requête de l’adversaire et distinguer le cas où toutes les valeurs de Ti pour le défi lancé à l’adversaire sont différentes des valeurs atteintes au cours de ses requêtes. § VII.6 Malléabilité Le schéma de chiffrement défini dans le paragraphe VII.4 est sûr contre une attaque à clair choisi, c’est- ?-dire lors s’une attaque au cours de laquelle l’adversaire peut accéder ? un oracle de chiffrement qui lui renvoie les cryptogrammes pour toute requête de message clair qui lui est faite. Supposons maintenant que adversaire peut accéder ? un oracle de déchiffrement. On parle alors d’attaque ? cryptogramme choisi. r Bien sûr, pour que cette attaque ait un sens, il faut bien sûr interdire une requête qui consisterait ? déchiffrer un cryptogramme sur lequel l’adversaire doit se prononcer. Par exemple, un adversaire contre l’indistinguabilité qui doit répondre si le cryptogramme c qui lui est soumis est celui d’un message m0 ou m1 , ne doit pas demander ? l’oracle le déchiffrement du cryptogramme c. Le schéma de chiffrement du paragraphe VII.4 n’a pas la propriété d’indistinguabilité face ? une attaque ? cryptogramme choisi. Si l’adversaire reçoit le cryptogramme (r, c), où c = r ⊕ fk (mb ), il peut demander le déchiffrement d’un cryptogramme (r, c∗ ), avec c∗ 6= c. Il reçoit alors le message clair qui est par définition : m∗ = fk (r) ⊕ c∗ . 45 46 Chiffrement Il peut en déduire : fk (r) = m∗ ⊕ c, et donc : mb = (m∗ ⊕ c) ⊕ c. Connaissant mb , il pourra ré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 requêtes ? l’oracle de déchiffrement avec une valeur quelconque de r∗ , car, la famille de fonctions (fk ) étant pseudoaléatoire, aucune information ne sera obtenue quant au masque fk (r∗ ). Le défaut de ce type de chiffrement est qu’il est malléable, c’est- ?-dire il est possible de manipuler le cryptogramme pour obtenir des relations avec d’autres cryptogrammes. En d’autres termes, même sans connaitre la clé, il est possible de construire des cryptogrammes dont les clairs sont en relations. Dans le cas présent, si (r, c) est le chiffré de m, alors (r, c ⊕ u) est le chiffré de ⊕x. Un chiffrement malléable j’est jamais sûr contre une attaque ? cryptogramme choisi. Pour construire un schéma de chiffrement résistant contre ce type d’attaque, il ne doit pas être mallé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 possibilité est de rendre impossible en pratique la modification du cryptogramme, c’est?-dire que tout cryptogramme modifié ne soit plus cohérent, et donc non déchiffrable. § VII.7 Codes d’authentification de message VII.7.1. Motivation Afin de rendre un schéma de chiffrement résistant aux attaques ? cryptogramme choisi, l’idée est d’ajouter une empreinte τ au cryptogramme telle que l’adversaire ne puiossa pas construire un cryptogramme différent avec une empreinte τ 0 différente qui donne un chiffré correct. De telles empreintes, dépendant d’une clé s’appellent des Codes d’Authentification de Message (MAC, Message Authentication Code). Un code d’authentification de message est une primitive cryptographique de signature symétrique. La clé pour générer l’empreinte est la même que la clé pour la vérifier. Ceux qui peuvent signer sont les mêmes que ceux qui peuvent vérifier. Un MAC ne satisfait donc pas la propriété de non répudiation. Dé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 génération de clé G(1n ) qui renvoie une clé aléatoire. 2. Un algorithme déterministe efficace qui génère d’empreinte d’un message ? partir d’une clé k : M ACk (m) = τ . 3. Un algorithme déterministe de vé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 vérification est le suivant, qui n’invoque que la fonction M ACk : 1. Calculer l’empreinte τ 0 = M ACk (m) ; 2. Vé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 Sécurité d’un code d’authentification de message La sécurité d’un code d’authentification de message se mesure ? la difficulté 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 vérification sans disposer de la clé. Pour cela, il peut interroger un oracle qui lui indiquera des empreintes valides de messages de son choix, ? l’exception bien sûr du message qu’il signe. Définition VII.8 [Sécurité d’un MAC] On dit qu’un MAC est sûr si la probabilité de succès d’un adversaire polynomial A pour produire un message correctement signé, c’est- ?-dire la fonction en n donnée par : Prob AM ACk (1n ) = (m, τ ) | Verif k (m, τ ) = 1 , est négligeable. Les messages demandés ? l’oracle doivent être différent de la réponse m de l’algorithme A. r Un MAC diffère d’une signature. La procédure de vérification n’est pas publique, mais réservée ? ceux qui disposent de la clé. Pour cette raison, les signatures produites par un MAC sont répudiables. Comme la clé est partagée entre le signataire et le vérificateur, il ne sera pas possible de prouver que c’est bien le prétendu signataire qui a produit la signature, et non pas un vérificateur malhonnête. r Lorsqu’on dit qu’une fonction est un MAC, on sous-entend qu’elle satisfait la propriété de sécurité donnée dans la définition VII.8. VII.7.3. Une première construction Si fk : {0, 1}n −→ {0, 1}n est une fonction pseudo-aléatoire, alors elle peut être directement utilisée pour authentifier les messages, simplement en posant M ACk (m) = fk (m). Théorème VII.9 Une famille de fonctions pseudo-aléatoire définit un code d’authentification de message. Preuve. Soit A un adversaire contre ce MAC défini par une fonction pseudo-aléatoire. On soumet ? cet adversaire deux jeux, qui correspondent ? deux situations. Le jeu 0 est le jeu réel. L’oracle fourni ? l’algorithme A pour qu’il puisse produire son message correctement signé est une fonction pseudo-aléatoire. Soit E0 l’évènement hh A a réussit ? produire un message correctement signé ii au cours du jeu 0. Le jeu 1 est comme le jeu réel, mais l’oracle fourni ? l’algorithme A est une fonction parfaitement aléatoire. Soit E1 l’évènement hh A a réussit ? produire un message correctement signé ii au cours du jeu 1. Montrons dans un premier temps l’inégalité : (7) Prob(E0 ) − Prob(E1 ) ≤ εfpa , où εfpa est l’avantage maximal d’un adversaire contre la famille pseudo-aléatoire. Pour cela, considérons un algorithme B, chargé de discerner entre une fonction aléatoire et une fonction pseudo-aléatoire, qui utilise l’algorithme A pour répondre. Soit f l’entrée de B qui est soit une fonction fk pseudo-aléatoire, soit une fonction h parfaitement aléatoire. Il simule l’environnement de A en répondant ? ses requêtes avec de la fonction f . Si l’algorithme A fournit un message correctement signé, alors l’algorithme B renvoie 0 pour signifier que f est une 47 48 Chiffrement fonction pseudo-aléatoire, et si l’algorithme A échoue, alors l’algorithme B renvoie 1 pour signifier que la fonction f est parfaitement aléatoire. L’heuristique est de dire que si A répond correctement, cela signifie que B simule correctement le jeu pour lequel il est programmé. Par construction de l’algorithme B, son avantage contre la famille pseudo-aléatoire est donné 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’inégalité (7) s’obtient par passage au maximum sur tous les adversaires. Lorsque la fonction MAC est parfaitement aléatoire, l’algorithme A ne peut produire une empreinte correcte qu’avec une probabilité égale ? 1/2n . Comme la fonction est aléatoire, les requêtes n’apportent aucune information. La valeur f (m) est équiprobable. Donc : Prob(E1 ) = 1 2n Donc Prob(E0 ) ≤ Prob(E1 ) + Prob(E0 ) − Prob(E1 ) 1 ≤ n + εfpa , 2 qui est une fonction négligeable par hypothèse. VII.7.4. Le CBC-MAC Le code d’authentification de message présenté dans le paragraphe précédent présente peu d’intérêt, car l’empreinte est aussi longue que le message lui-même. Le CBC-MAC permet de proposer des empreintes de taille fixe pour des messages bien plus longs. Le CBC-MAC est représenté par le schéma ci-dessous : m1 m2 ? - +i ... m` ? - +i - ... ? ? ? fk fk fk ? τ ... MACk (m1 , . . . , m` ) = τ Ce sché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 nécessaire que la fonction utilisée ? chaque tour soit une permutation. Le déchiffrement n’est pas requis. On a seulement besoin d’une fonction pseudo-aléatoire. § VII.7 Codes d’authentification de message Théorème VII.10 [Sécurité du CBC-MAC] Le CBC-MAC est sûr. Preuve. Comme dans la preuve du théorème VII.9, considérons un adversaire A contre ce schéma CBC-MAC. On soumet cet algorithme ? deux jeux. Le jeu 0 est le jeu réel, la fonction utilisée ? chaque tour du CBC-MAC est une fonction pseudoaléatoire fk . On note E0 l’évènement hh l’algorithme A a réussit ? produire une signature valide au cours du jeu 0 ii. Le jeu 1 est similaire au jeu 1, mais la fonction utilisée ? chaque tour du CBC-MAC est une fonction parfaitement aléatoire. On note E1 l’évènement hh l’algorithme A a réussit ? produire une signature valide au cours du jeu 1 ii. On montre, de la même manière que dans la preuve du théorème VII.9 que : Prob(E0 ) − Prob(E1 ) ≤ εfpa , (8) où εfpa est l’avantage maximal d’un adversaire contre la famille pseudo-aléatoire. Comme dans la preuve du théorème VII.9, on construit un adversaire contre la famille pseudo-aléatoire qui utilise l’adversaire A en simulant son environnement, et dont l’avantage est par construction donnée par le premier membre de l’inégalité (8). Évaluons maintenant Prob(E1 ). Pendant le déroulement du jeu 1, l’algorithme A effectue un certain nombre de requêtes de signatures et obtient les couples de messages signés (m1 , τ1 ), . . . , (mq , τq ). Considérons l’évènement C égal ? hh il existe deux requêtes i et j telles que les valeurs de f ? l’avantdernière itération sont égales ii. La probabilité de C est la probabilité que deux valeurs aléatoires soient égales parmi n. Elle est approchée par le paradoxe des anniversaires : Prob(C) ≈ q2 . 2n+1 En l’absence de collision, la valeur de la fonction f était parfaitement aléatoires, les requêtes n’apportent aucune information ? l’algorithme A et la probabilité qu’il trouve une signature correcte pour un nouveau message ne dépasse pas le tirage de la valeur au hasard : 1 Prob(E1 | ¬C) = n 2 On a finalement la probabilité 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 négligeable ainsi que : Prob(E0 ) ≤ Prob(E1 ) + εfpa . q qqAA Dans la preuve, on utilise de manière explicite que les messages ? signer ont tous la même taille, é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 égal ? (τ1 ). Il est immédiat de vérifier que τ2 est une empreinte correcte du message constitué de deux blocs (m1 , τ1 ). Pour pallier ce problème, il existe plusieurs remèdes : – Utiliser pour paramétrer la fonction pseudo-aléatoire, non pas directement la clé k, mais une clé 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-sûr générique Dans ce paragraphe, on propose la construction d’un schéma de chiffrement sûr contre une attaque ? cryptogramme choisi par la combinaison d’un schéma de chiffrement qui n’est sûr que contre une attaque ? clair choisie, et d’un code d’authentification de messages. On suppose qu’on dispose de : – un schéma de chiffrement (G, E, D) qui est sûr contre une attaque ? clairs choisis ; – un code d’authentification de messages (GM , MAC, Verif) qui est sûr contre une attaque ? messages choisis. On construit un schéma de chiffrement (G∗ , E ∗ D∗ ) comme suit : – La fonction de génération de clé G∗ génère un couple de clé, l’une pour le sché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, τ ), où c est le cryptogramme c = Ek (m) et τ est l’empreinte du cryptogramme τ = MACKM (c). – Pour déchiffrer le cryptogramme (c, τ ), l’algorithme E ∗ vé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’échec du déchiffrement. L’adjonction d’un code d’authentification sur le cryptogramme rend le cryptogramme non malléable. Théorème VII.11 Le schéma de chiffrement (G∗ , E ∗ , D∗ ) est sûr contre une attaque ? cryptogrammes choisis. Preuve. Soit A un adversaire contre ce schéma de chiffrement. On suppose qu’il a accès ? un oracle de chiffrement et ? un oracle de déchiffrement. Notons le jeu réel le jeu 0. Au cours de ce jeu, l’algorithme A soumet des requêtes m1 , . . . , mq ? l’oracle de chiffrement, et il obtient une liste L de cryptogramme L = (c1 , τ1 ), . . . , (cq , τq ) . Il soumet également des cryptogrammes (c, τ ) et obtient le résultat de ce déchiffrement, soit ⊥ si il y a échec du déchiffrement, soit le message clair en cas de succè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 aléatoire dans {0, 1}. Ce cryptogramme est défini par cb = Ek (mn ) et τb = MaCKM (cb ). L’algorithme renvoie une réponse b0 ∈ {0, 1}. Il a réussit si b = b0 et il a échoué dans le cas contraire. On note E0 l’évènement hh b = b0 ii de réussite de l’algorithme A. Le jeu 1 est similaire au jeu 0, est joué par un simulateur qui réalise correctement l’oracle de déchiffrement, mais simule l’oracle de déchiffrement. Lorsque l’algorithme A soumet un cryptogramme (c, τ ), le simulateur vérifie s’il est présent dans la liste L. S’il est présent, alors il renvoie le message qui a été soumis pour obtenir ce cryptogramme, et s’il n’est pas présent, renvoie ⊥ pour signifier l’échec. L’oracle de déchiffrement peut être simulé en toute ignorance de la clé du code d’authentification de message. On note E1 l’évènement qui signifie la réussite de l’algorithme A au cours du jeu 1. Notons ValDec l’évènement où l’adversaire A soumet un cryptogramme valide (c, τ ) qui n’est pas dans la liste L. S’il peut réaliser cela, c’est qu’il peut forger une empreinte du cryptogramme c. On a le résultat suivant : Prob ValDec ≤ qD εmac , où qD désigne le nombre de requêtes de déchiffrement et εmac désigne la probabilité de succès maximale d’un adversaire contre le code d’authentification de message pour forger une empreinte. Ce point assez intuitif est toutefois assez délicat ? démontrer formellement. § VII.9 Exercices Si l’évènement ValDec n’est pas réalisé, 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 sché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 déchiffrement pour simuler le jeu 1. L’algorithme B peut générer une clé MAC lui même qu’il utilisera pour répondre aux requêtes de chiffrement de l’algorithme A. ∗ L’algorithme B génère lui même une clé kM par appel ? GM (1n ) et utilisera cette clé lors des requêtes de chiffrement de l’algorithme A. Si A demande ? chiffrer le message m, l’algorithme B lui répond (c, τ ∗ ), où c = E(m), l’algorithme ∗ (c). L’algorithme B ajoute ce cryptogramme ? la E étant l’oracle de l’algorithme B, et τ ∗ = MACkM liste L pour pouvoir ré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 mêmes messages m∗0 et m∗1 . Lorsque l’algorithme B reçoit son défi sous la forme du chiffré c par E de l’un des deux messages ∗ et fournit ? A m∗0 ou m∗1 , alors, il calcul une étiquette du cryptogramme τ ∗ avec sa propre clé kM ∗ ∗ le défi sous la forme du couple (c , τ ). Lorsque l’algorithme A renvoie son résultat b0 , l’algorithme B renvoie le même résultat b0 . Ainsi par construction, l’avantage de l’algorithme B contre le sché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 majoré par : εA cca = 2 Prob(E0 ) − 1 ≤ qD εmac + εcpa , qui est une fonction négligeable. § VII.9 Exercices 1. On définit ci-après des schémas de chiffrement. Dans chaque cas dire s’ils ont la propriété d’indistinguabilité dans une attaque ? clair choisi, ? cryptogramme choisi : a) E(k, m) = m ⊕ fk (r), où Fn = (fk )k∈{0,1}n est une famille de fonctions pseudo-aléatoires {0, 1}n −→ {0, 1}n , et r est un élément aléatoire de {0, 1}n . b) Le mode dictionnaire d’un chiffrement par bloc. Le message est découpé en blocs de même taille, et chaque bloc est chiffré avec une même fonction de chiffrement : E k, (m1 , . . . , m` ) = pk (m1 ), . . . , pk (m` ) , où Pn = (pk )k∈{0,1}n est une famille de permutations aléatoires. c) La fonction RSA. e) Le chiffrement El Gamal. e) Le chiffrement de Paillier. 2. Le schéma de chiffrement défini dans le paragraphe VII.4 reste-t-il sûr face ? une attaque ? cryptogramme choisi ? 51 52 Chiffrement Indication : poser des requêtes avec la même clé de session. 3. Montrer que le mode ECB n’est pas sûr, c’est- ?-dire qu’il n’a pas la propriété IND-CPA. Montrer que le mode ECB n’est pas sûr, y compris lorsqu’on impose que tous les blocs du message clair sont différents. 4. Montrer que le mode CBC avec une valeur prédictible pour le vecteur initial n’est pas sûr. 5. Montrer que le mode CBC avec vecteur initial aléatoire est malléable, et n’est donc pas sûr contre une attaque ? cryptogramme choisi. 6. Dans la preuve du théorème VII.10 page 49, montrer que si l’évènement C survient, il est possible de construire un message correctement signé. § VIII.1 Les cinq mondes d’Impagliazzo VIII – SIGNATURES NUMÉRIQUES La signature numérique assure le service d’authentification dans le contexte de la cryptographie ? clé publique. Seul le signataire peut signer avec sa clé priée. Tous peuvent vérifier avec la clé publique correspondante. Le premier schéma de signature asymétrique qui a été inventé est le RSA (). On peut transformer le schéma de chiffrement en schéma de signature simplement en inversant le rôle de la clé publique et de la clé privée. La signature d’un message m ∈ Z/nZ est la quantité σ = md mod n, où d est l’exposant privé, et n le module public. Pour vérifier que σ est une signature valide du message m, on vérifie que m = σ e mod n, où e est l’exposant public. Finalement, la signature apparait ici comme un chiffrement avec la clé privée, la vérification étant un déchiffrement avec la clé publique, ou bien, ce qui revient au même, que la génération de signature est un déchiffrement du message, et la vérification de signature est un chiffrement de la signature. Ceci donne l’idée que la signature est le dual du chiffrement ? clé publique, et que cela né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 schéma de chiffrement pour signer. Par exemple, si le chiffrement est probabiliste, il n’est pas toujours possible d’appliquer l’algorithme de déchiffrement, invoquant la clé privée, ? un message arbitraire. Dans ce cas, la signature ne pourra être valide qu’avec une probabilité négligeable. D’autre part, le chiffrement ? clé publique nécessite une fonction ? sens unique avec trappe, alors que pour construire un schéma de signature, il suffit de disposer d’une fonction ? sens unique. La signature ne nécessite pas de trappe. Rappelons que l’existence de fonction ? sens unique est l’exigence minimale pour réaliser de la cryptographie. La signature, même asymétrique, peut être construite sur cette condition minimale. Même si un jour le chiffrement ? clé publique disparait, il sera peut-être quand même possible de réaliser des signatures ? clé publique. § VIII.1 Les cinq mondes d’Impagliazzo On ne sait pas aujourd’hui si la famille P des problèmes pour lesquels un algorithme efficace existe pour les résoudre est ou non égal ? la famille N P des problèmes qui sont vérifiables efficacement. Russel Impagliazzo a imaginé cinq mondes imaginaires possibles selon une hiérarchie de difficulté de résolution des problèmes. Rappelons qu’on dit qu’un problème est facile s’il existe un algorithme efficace pour le résoudre. 1. Algorithmica. Ce monde est le monde où P = N P. Dans ce monde, tout les problèmes qui sont faciles ? vérifier sont aussi facile ? résoudre. La seule cryptographie possible dans Algorithmica est la cryptographie ? sécurité inconditionnelle, par exemple reposant sur le masque jetable. 2. Heuristica. Dans le monde Heuristica, P = 6 N P, c’est- ?-dire il existe des problèmes difficiles ? résoudre dans le pire des cas qui sont faciles ? vérifier, mais tous les problèmes faciles ? vérifier sont faciles ? résoudre en moyenne. 3. Pessiland. Dans le monde Pessiland, il existe des problèmes faciles ? vérifier mais difficile ? ré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 problèmes difficiles qu’on sait résoudre, comme trouver l’antécé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 symétrique. Dans ce monde, on peut également établir des preuves sans divulgation et des signatures asymétriques. 53 54 Signatures numériques 5. Cryptomania. Le monde Cryptomania est le plus proche du monde ré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 asymétrique n’est possible que dans le monde cryptomania. Il se peut que certains de ces mondes disparaissent avec le développement de notre connaissance de la théorie de la complexité. Le premier ? disparaitre serait Cryptomania. Même si ce dernier venait ? disparaitre, tant que le monde Minicrypt existe encore, la signature asymétrique restera possible. Le schéma de signature RSA est construit dans le monde Cryptomania. Il en est de même de la plupart des schémas de signature actuels, comme le DSA, ElGamal, Schnorr, ECDSA, etc. La suite de cette section est consacrée ? la preuve que la signature numérique appartient au monde Minicrypt. L’objet est de construire une signature asymétrique ? partir d’une fonction ? sens unique. § VIII.2 Définition et sécurité des signatures Définissons tout d’abord ce qu’est un schéma de signature, ainsi que les conditions de sécurité qu’il doit vérifier. Définition VIII.1 [Schéma de signature] Un schéma de signature numérique π, opérant sur une famille de messages M = Mn n∈N , se compose de trois algorithmes probabilistes : Gen, Sign et Verif. – L’algorithme de génération des clés Gen(1n ) prend un paramètre de sécurité 1n retourne le couple (kpub , kpriv ) où kpub est la clé publique et kpriv est la clé privée correspondante. – Pour le paramètre de sécurité 1n , l’algorithme de production de signature Sign(kpub , m), prend comme paramètre une clé privée kpriv et un message m ∈ Mn et produit une signature σ. – L’algorithme de vérification Verif(kpub , m, σ) est l’algorithme de vérification de la signature σ du message m. Il invoque la clé publique kpub . Il rend une valeur 1 pour signifier que la signature est acceptée, ou bien 0 pour signifier que la signature est rejetée. Les algorithmes doivent vérifier les conditions suivantes : – Condition de validité : les signatures qui ont été produite correctement doivent être acceptées. Si (kpub , kpriv ) ← Gen(1n ), si σ = Sign(kpriv , m) alors on doit toujours avoir Verif(kpub , m, σ) = 1. – Condition de sécurité : un adversaire ne doit pas pouvoir produire de message correctement signé, y compris lorsqu’il accède ? un oracle qui lui signe des document de son choix. Pour tout algorithme polynomial A qui accède ? l’oracle de signature Sign, son avantage, égal par définition ? la probabilité que A produise une signature valide, est négligeable. Pour tout (kpub , kpriv ) ← Gen(1n ), h i Adv(A) = Prob ASign(kpriv ,·) (kpub ) = (m, σ) | Verif(kpub , m, σ) = 1 , où le message m n’a pas été demandé ? l’oracle de signature Sign(kpriv , ·), est négligeable en n. On se place ici dans les conditions les plus sévères pour la sécurité. Le faussaire peut faire signer les messages de son choix pour pouvoir produire un message quelconque correctement signé. Il s’agit ici de l’attaque ? messages choisi, notée UF-CMA (Unforgeable under Chosen Messages Attack). Il existe des conditions plus faibles de sécurité. – L’observation passive : l’adversaire peut accéder ? un ensemble de messages signés, mais non choisis. § VIII.3 Le paradigme de Fiat-Shamir – Pas d’observation : l’adversaire ne peut accéder ? aucun message signé. Cette condition est trop faible. En pratique, il est toujours possible d’observer des messages signés. kpub ? miA σi ? (m, σ) Sign(kpriv , ·) valide avec m diffé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 ré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 idéale est une fonction aléatoire appelée un oracle aléatoire. Soit H : M −→ Z/nZ une fonction aléatoire, la signature FDH-RSA (Full Domain Hash RSA) est calculée par σ(m) = H(m)d mod n. Si la fonction H est aléatoire, c’est- ?-dire s’il s’agit d’un oracle aléatoire, alors ce schéma de signature peut être prouvé sûr contre une attaque ? messages choisis. § VIII.3 Le paradigme de Fiat-Shamir Le paradigme de Fiat-Shamir () est une méthode générale qui permet de construire un schéma de signature ? partir d’un protocole d’authentification sans divulgation de connaissance (Zero Knowledge) et d’un oracle aléatoire. Rappelons que les protocoles d’authentification sans divulgation sont des protocoles interactifs ? trois passes qui permettent de prouver la détention d’une donnée secrète sans révéler aucune information sur cette donnée : −→ Engagement. ←− Défi. −→ Réponse. Une condition de sécurité de ce type de protocole est le caractère aléatoire du défi. Si la fonction H est un oracle aléatoire, alors l’image d’un message m par H est une valeur aléatoire qui peut tenir lieu de défi. On obtient alors un protocole non interactif qui peut faire office de schéma de signature. Il s’agit de prouver que l’on détient bien la clé privée associée ? la clé publique kpub . −→ Engagement : la clé publique kpub . −→ Défi : H(m) le haché du message m par un oracle aléatoire. −→ Réponse : la signature σ du message m. Considérons par exemple le protocole suivant qui est un protocole sans divulgation, de la connaissance du logarithme discret x d’une donnée publique y dans un groupe cyclique G d’ordre q, engendré par un générateur g. Les trois passes de ce protocole sont : −→ Engagement : y = g x et u = g r avec r aléatoire. ←− Défi : un valeur k aléatoire. 55 56 Signatures numériques −→ Ré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 défi, alors il est facile de choisir la réponse t que l’on donnera, et de s’engager sur le défi u = g t y k . Les trois passes du protocole peuvent par conséquent être simulées et rien ne peut distinguer la simulation d’un protocole réel d’authentification. Le prouveur qui détient la valeur de x peut calculer la valeur t de la réponse en calculant t = r − kx mod q. Ce protocole peut être transformé en schéma de signature numérique avec un oracle aléatoire H(m, u). On obtient alors le schéma de signature de Schnorr. Il est possible de construire une preuve sans divulgation ? partir d’une fonction ? sens unique, sans nécessairement disposer d’une trappe dans la fonction ? sens unique. Cette preuve sans divulgation peut être dérivée en un schéma de signature gr ?ce au paradigme de Fiat-Shamir et ? un oracle aléatoire qui est prouvée sure. En conclusion, il est possible de construire un schéma de signature ? partir d’une fonction ? sens unique et d’un oracle aléatoire. Le problème de cette approche est que la condition de disposer d’un oracle aléatoire est très forte, et les fonctions de hachage réelles sont loin de satisfaire cette hypothèse. Contrairement au modèle de l’oracle aléatoire, dans le modèle standard, on suppose seulement que les fonctions de hachage résistent aux collisions. La suite de cette section est de construire une signature asymétrique ? partir d’une fonction ? sens unique dans le modèle standard. § VIII.4 La signature hh une fois ii de Lamport La signature définie dans cette section est une signature jetable, utilisable une fois seulement. Elle ne nécessite qu’une fonction ? sens unique f : {0, 1}∗ −→ {O, 1}∗ . Pour le paramètre de sécurité 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 égale ? n. 1. L’algorithme Gen de génération de clé procède ainsi : – Générer aléatoirement 2n éléments de {0, 1}n qui constituent la clé privée : kpriv = x01 x11 x02 x12 ··· ··· x0n x1n – La clé publique est constitué 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 constitué des éléments de la clé secrète choisis sur la ligne correspondant au symbole mi . La signature est : σ = (xm1 1 , xm2 2 , . . . , xmn n ) 3. Pour vérifier la signature σ = (σ1 , . . . , σn ) d’un message m, il suffit alors de vérifier que pour tous les indices i, on a f (σi ) = yi . La signature est considérée comme non valide si pour un des indices i on a f (σi ) 6= yi . r Pour signer un message, on révèle un des secrets. Avec seulement les signatures de deux messages, pourvu qu’ils soient complémentaires l’un de l’autre, toute la clé secrète est révélée. Cette clé n’est utilisable que pour signer un seul message. § VIII.5 Une signature hh plusieurs fois ii avec é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 , où l’indice i est l’un de ceux où les messages m et m∗ diffèrent. La fonction f étant ? sens unique, trouver σi tel que f (σi ) = yi est supposé difficile. Montrons la sécurité du schéma de signature une fois de Lamport de maniè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 entrée arbitraire y. En évaluant les avantages de ces algorithmes, on montre la sécurité de ce schéma. L’algorithme B va simuler les trois algorithmes du schéma de signature auprès de l’algorithme A. Le principe est de placer y ? une position dans la clé publique. Lorsque A demande la signature d’un message m, il faudra espérer que le symbole mi∗ ? la position i∗ permette ? B de proposer une signature valide, et aussi que le message correctement signé que A fournisse un antécédent de y. Tout d’abord, B choisit une position j ∗ et un symbole binaire aléatoire i∗ . Ensuite, B impose que y soit placé en position yi∗ j ∗ de la clé publique. Les autres entrées des clés publiques et privées sont celles produites par l’algorithmes de génération de clé standard Gen. C’est- ?-dire, pour i 6= i∗ et j 6= j ∗ , la valeur de xij est alé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 probabilité 1/2, alors l’algorithme B échoue. Sinon, il peut révéler les élé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 diffère du message m+ Si mj ∗ = m+ j ∗ , alors l’élément secret révélé pour la signature + ∗ de m en position j est le même que celui du message m et l’algorithme B échoue. Dans le cas contraire, ce qui survient avec une probabilité au moins égale ? 1/n, l’algorithme A propose en position j ∗ un antécédent de y par f que l’algorithme B peut renvoyer. Finalement, l’algorithme B utilise avec pertinence la réponse de l’algorithme A avec une probabilité supé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 négligeable dès que l’avantage de A est non négligeable, et achève la preuve de la sécurité du schéma de signature jetable de Lamport. § VIII.5 Une signature hh plusieurs fois ii avec état Pour passer ? des signatures utilisable plusieurs fois, on utilise une structure d’arbre, similaire ? celle utilisée pour construire des fonctions pseudo-aléatoires. La signature dépend d’un état, ce qui n’est pas conforme ? la définition, mais constitue une étape avant la construction d’un schéma de signature sans état, ne nécessitant qu’une fonction ? sens unique. La construction de cette signature avec état est possible ? partir de n’importe quel schéma de signature une fois π = (Gen, Sign, Verif), et il sera applicable au schéma de signature de Lamport décrit au paragraphe précé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 indexé par un préfixe m0 = m1 · · · m` du message. La racine est indexée par le m0 m0 , kpriv ). À préfixe vide ε. Chacun nœud contient également une nouvelle paire de clé km0 = (kpub ε ε la racine, il s’agit de la paire de clé kε = (kpub , kpriv ). Aux autres nœuds de l’arbre, il s’agit d’une signature qui est générée lorsqu’un nouveau préfixe est parcouru. Pour un nouveau message avec le même préfixe, c’est la même clé qui est utilisée. Lorsqu’on parcourt l’arbre, la clé publique du nœud courant est ajoutée ? la signature produite. Cette clé est authentifiée avec la clé de niveau précédent, constituant un certificat ? la manière 57 58 Signatures numériques d’une infrastructure de clés publiques. Au final, la clé km signe le message m. La signature est constituée de cette signature et des clés publiques certifiées pour tous les préfixes. Le schéma de signature π ne pouvant être utilisé qu’une seule fois, la clé du nœud courant est utilisée pour signer les deux clés publiques du niveau inférieur. La clé racine kε authentifie le premier préfixe. De plus, afin de ne pas générer de nouvelles clés inutilement lors de la signature de nouveaux messages, un état mémorisant les préfixes et les clés correspondantes est mis ? jour. Une nouvelle clé n’est générée pour un préfixe que si ce préfixe n’appartient pas ? l’état. Lorsqu’une nouvelle clé est générée, le préfixe pour lequel elle l’a été est ajouté ? l’é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 clés sont générées par appel ? la fonction de ε génération Gen pour générer les clés k0 et k1 . La clé privée kpriv est utilisée pour produire une 0 1 signature des deux clés publiques kpub et kpub , produisant une signature σε . Le certificat cε est la 0 1 donnée des clés publiques et de leur signature : cε = (kpub , kpub , σε ). 2. Lors de la lecture du deuxième symbole 1, les clés k01 et k00 sont générées, les clés publiques sont 0 00 01 signées avec la clé privée kpriv , produisant une signature σ0 . Le certificat c0 est c0 = (kpub , kpub , σ0 ). 3. Lors de la lecture du troisième symbole 1, les clés k011 et k010 sont générées, les clés 01 publiques sont signées avec la clé privé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 clés k0110 et k0111 sont générées, les clés 011 publiques sont signées avec la clé privée kpriv , produisant une signature σ011 . Le certificat c011 0110 0111 est c011 = (kpub , kpub , σ011 ). 5. Le message m est finalement signé avec la clé privée k0110 produisant la signature σ0110 . La signature totale du message m par le schéma π ∗ est constitué de cette signature et de tous les certificats produits. σ ∗ = (cε , c0 , c01 , c011 , σ0110 ). Pour vérifier cette signature, les signatures des certificats sont vérifiées dans cet ordre, établissant la confiance dans les clés publiques successives, pour finalement vérifier la signature du message m. Dans ce schéma, chaque signature n’est utilisée qu’une seule fois, soit pour signer les clé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 schéma initial π à ce nœud. Ce schéma de signature ne convient pas encore. Il reste deux problèmes à résoudre : 1. La fonction de génération de signature comprend un état qui est mis à jour au fur et à mesure que des messages sont signés. Ceci sort du cadre de la définition des signatures numériques. Pour se débarrasser de l’état, il faut savoir générer les mêmes signatures pour un préfixe donné. Ceci peut être réalisé en remplaçant l’algorithme probabiliste de génération Gen(1n ) par un algorithme déterministe, avec une chaine aléatoire comme paramètre supplémentaire, alimenté par un générateur pseudo-aléatoire. § VIII.6 Fonction de hachage 2. Les signatures des certificats signent des couples de clés publiques, qui sont deux fois plus longs que la clé servant à signer. Le schéma de Lamport n’est pas directement utilisable. La résolution de ce problème repose sur une fonction de hachage pour que la signature opère sur une donnée de la taille de la clé. § VIII.6 VIII.6.1. Fonction de hachage Motivation Pour signer un message de grande taille, celui-ci est d’abord soumis à une fonction de hachage, afin d’en produire un condensé de taille fixée, et c’est ce condensé qui est soumis à la fonction de signature. Il existe deux notions de sécurité pour les fonctions de hachage : – la résistance au collision ; – la notion de fonction de hachage universelle à sens unique. La seconde notion est moins forte que la première, mais peut être construite à partir d’une fonction à sens unique, alors que la construction de fonctions de hachage à partir de fonctions à sens unique reste un problème ouvert. Il est par ailleurs suffisant de disposer de fonction de hachage universelle à sens unique pour construire un schéma de signature sûr. VIII.6.2. Définition L’analyse de la sécurité étant une notion asymptotique, il est nécessaire de définir une famille de fonctions de hachage, selon un paramètre de sécurité. Définition VIII.2 [famille de fonctions de hachage] Une famille de fonctions de hachage H est constituée de deux algorithmes : 1. un algorithme probabiliste Gen(1k ), où k ∈ N est le paramètre de sécurité, génère un indice s public, appartenant à un ensemble d’indices S. 2. Pour indice s ∈ S, un algorithme polynomial Hs calcule,pour tout élément x de {0, 1}∗ , une valeur Hs (x) qui appartient à {0, 1}`(k) , où `(x) est un polynôme. r En pratique, on utilise toujours une fonction de hachage sans clé, de type SHA 1 ou MD 5, qui correspond à une famille à un seul indice. Ces fonctions produisent un condensé de taille fixe, égale respectivement à 160 et 128 symboles binaires. Toute analyse asymptotique de la sécurité est impossible avec ces fonctions fixée. VIII.6.3. Notions de sécurité 1. Résistance aux collisions. Une famille de fonctions de hachage est résistante aux collisions (CR, Collision Resistant) s’il est difficile de trouver deux éléments x et x0 dans {0, 1}∗ qui ont le même condensé. Un adversaire d’une famille de fonctions de hachage contre les collisions est un algorithme qui produit deux messages différents qui ont le même condensé. L’avantage d’un adversaire est sa probabilité de ré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 paramètre de sécurité k. 59 60 Signatures numériques Définition VIII.3 [résistance aux collisions – CR] On dit qu’une famille de fonctions de hachage H est résistante aux collisions (CR) si l’avantage Advcr H de tout adversaire polynomial A est une fonction négligeable du paramètre de sécurité. 2. Fonction de hachage universelle à sens unique (UOWHF Universal One Way Hash Function Cette propriété de sécurité est une formalisation de la résistance au second antécédent. Étant donné un message x, il doit être difficile de trouver un second message x0 ayant le même condense que x. Un adversaire contre la propriété UOWHF est un algorithme qui produit d’abord un élément x de {0, 1}∗ en fonction du paramètre de sécurité, sans connaı̂tre l’indice public s, puis qui doit trouver un second antécédent x0 à Hs (x), pour un indice s aléatoire produit par l’algorithme Gen(1k ). L’avantage d’un adversaire A contre la propriété UOWHF est sa probabilité de succè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 Définition VIII.4 [Fonction de hachage universelle à sens unique – UOWHF] On dit qu’une famille de fonctions de hachage H est universelle à sens unique (UOWHF) si l’avantage Advuowhf de tout adversaire polynomial A est une fonction négligeable du H paramètre de sécurité. VIII.6.4. Une construction de fonction de hachage résistante aux collisions Les exercices de ce chapitre proposent des constructions de fonctions de hachage résistantes aux collisions reposant sur le problème du logarithme discret dans un groupe fini, ou sur le problème de la factorisation. Si un calculateur quantique venait à voir le jour, ces problè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 résistante aux collisions reposant sur le problème du plus court vecteur d’un réseau, qui est un problème qui résisterait à l’existence d’un calculateur quantique. Soit q un entier et A une matrice de m lignes et n colonnes à coefficients dans Z/qZ. Le réseau engendré par A est l’ensemble des combinaisons linéaires à coefficients entiers des lignes de la matrice A : Λq (A) = t s A mod q | s ∈ Zm Il existe aussi le réseau dual qui est l’ensemble des vecteurs à coefficients entiers qui annulent la matrice A : m Λ⊥ q (A) = y ∈ Z | A y = 0 mod q Ajtai a montré que pour un choix convenable de n, m et q, le problème de trouver un élément d’un réseau Λ⊥ q (A) dont les composantes sont 0, 1 ou −1 modulo q, est un problème difficile. Ce problème est appelé le problè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 définie par : 1. Gen(1k ) 7→ s = (n, m, q, A), où A est une matrice de n lignes et m colonnes, {0, 1}m −→ (Z/qZ)n 2. Hs : x 7−→ Ax est ré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 même condensé, alors on a trouvé un vecteur x − x0 du réseau Λ⊥ q (A) dont les composantes appartiennent à {−1, 0, 1}, c’est- ?-dire une solution du problème SIS. VIII.6.5. La construction de Merkle-Damgård La construction du paragraphe précédent opère sur un domaine de taille fixée. L’objet des fonctions de hachage est d’assurer une compression pour produire, à partir d’un long message, un condensé de taille plus réduite. La construction de Merkle-Damgård définit une fonction de hachage sur des messages de longueur quelconque, à partir d’une fonction de facteur de compression égal à 2, c’est à dire qui opère sur des messages de 2` symboles binaires pour produire des condensés de ` symboles binaires. Le principe est similaire à celui du CBC-MAC. Un long message m est partagé en b blocs de ` symboles binaires chacun. Chaque bloc entre dans la fonction de hachage Hs . Le calcul est chainé 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 ajoutée afin de se prémunir contre les collisions construites à partir de la concaténation de messages. À partir d’une famille de fonctions de hachage H = (Gen, H), la construction de Merlke-Damgård consiste à produire une famille H∗ = (Gen∗ , H ∗ ), où – l’indice public s est le même : Gen(1k ) 7→ s, avec s ← Gen(1k ) ; – la valeur Hs∗ est définie par le schéma ci-dessus. Théorème VIII.5 [sécurité de la construction de Merkle-Damgård] Si la famille H est résistante aux collisions, alors la construction de Merkle-Damgård produit une famille de fonctions de hachage H∗ résistante aux collisions. Preuve. La preuve est laissée en exercice. § VIII.7 Le paradigme hh hache puis signe ii. Ce paradigme correspond à la pratique usuelle de la signature. Pour signer un long document, on commence par lui appliquer une fonction de hachage. On obtient alors un condensé de longueur fixe. Et c’est sur ce condensé que la fonction de signature est appliquée. VIII.7.1. Avec un hachage résistant aux collisions À partir de : – Un schéma de signature π = (Genπ , Sign, Verif) et – Une famille de fonctions de hachage H = (GenH , H), on construit un schéma de signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) ainsi défini : – La fonction de génération Genπ∗ appelle la fonction de génération Genπ qui produit le couple de clés publique et privée (kpub , kpriv ) et la fonction de génération GenH qui produit l’indice ∗ public s. Le résultat de la fonction Genπ∗ est la clé publique kpub = (kpub , s) et la clé privée ∗ kpriv = (kpriv , s). 61 62 Signatures numériques – La génération de signature Sign∗ applique la génération de signature Sign au condensé du message m par la fonction de hachage Hs . Elle est est définie par : ∗ σ ∗ = Sign∗ kpriv , m = Sign kpriv , Hs (m) . – La vérification de signature Verif ∗ applique la fonction de vérification de signature Verif au même condensé du message m, soit : ∗ Verif ∗ (kpub , σ ∗ , m) = Verif kpub , σ ∗ , Hs (m) L’intérêt de cette façon de faire est d’utiliser une signature sur des données courtes pour signer de longs documents. Le théorème suivant montre la sécurité du schéma π ∗ . Théorème VIII.6 Si le schéma de signature π est sûr contre une attaque à messages choisis, et si la famille de fonctions de hachage H est résistante aux collisions, alors le schéma de signature π ∗ est sûr contre une attaque à messages choisis. Preuve. Supposons qu’il existe un adversaire A contre le schéma π ∗ et dé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’entrée de l’algorithme B est une clé publique pour le schéma π ∗ , c’est- ?-dire un couple (kpub , s). La composante kpub est directement fournie à A. Lorsque l’algorithme A demande la signature d’un message mi , l’algorithme lui applique la fonction de hachage Hs , transmet le condensé µi = Hs (m) à l’oracle de signature Sign, qui retourne une signature σ directement transmise à l’algorithme A. À la fin de son travail, l’algorithme A fournit un message m et une signature σ. Le message m est différent de tous les messages mi dont A a demandé la signature. Si le haché Hs (m) est égal à l’un des hachés H(mi ), alors l’algorithme B a trouvé une collision sur Hs . Dans le cas contraire, il peut fournir le couple Hs (m), σ qui est une signature forgée avec le même avantage que l’algorithme A. § VIII.7 Le paradigme hh hache puis signe ii. VIII.7.2. Avec un hachage universel à sens unique L’objet est maintenant d’affaiblir l’hypothèse sur la fonction de hachage de manière à pouvoir se contenter d’une famille de fonctions de hachage universelles à sens unique, dont on sait qu’elles sont dans le monde minicrypt, c’est- ?-dire constructible à partir d’une famille de fonctions à sens unique. Le principe est similaire au précédent. La différence réside dans la génération de l’indice public s qui n’est pas faite une fois pour toutes, mais qui est faite à chaque signature. À partir du schéma de signature π = (Genπ , Sign, Verif) et de la famille de fonctions de hachage H = (GenH , H), on construit un schéma de signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) de la façon suivante : – Pour le paramètre de sécurité k, la fonction de génération Genπ∗ (1k ) produit la clé publique ∗ ∗ kpub = kpub et la clé privée kpriv = kpriv par simple appel à la fonction Genπ (1k ). ∗ – La génération de signature Sign appelle la génération de l’indice public de la famille de fonctions de hachage s ← GenH (1k ), puis applique la génération de signature Sign au condensé du message m par la fonction de hachage Hs . Pour que la vérification soit possible, l’indice public s est fourni avec la signature, et pour s’assurer que cet indice est authentique, il est concaténé au condensé pour être inclus dans la donnée signée. La fonction de génération est donc est définie par : ∗ σ ∗ = Sign∗ kpriv , m = s, Sign kpriv , s||Hs (m) . – La vérification de signature Verif ∗ , calcule le haché Hs (m) avec l’indice public inclus dans la signature, puis applique la fonction de vérification de signature Verif à la donnée s||Hs (m). Soit : ∗ Verif ∗ (kpub , σ ∗ , m) = Verif kpub , σ ∗ , s||Hs (m) Cette construction fournit une signature sûe avec seulement la condition que la famille de fonctions de hachage H est universelle à sens unique. Théorème VIII.7 Si le schéma de signature π est sûr contre une attaque à messages choisis, et si la famille de fonctions de hachage H est universelle à sens unique, alors le schéma de signature π ∗ défini ci-dessus est sûr contre une attaque à messages choisis. Preuve. La preuve est similaire à celle du théorème VIII.6 et est laissée en exercice. q qqAA L’indice public étant concaténé au condensé 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 à la génération des clés et utilisé pour condenser l’indice s pour sa signature. Le schéma est alors le suivant : Étant donné un schéma de signature π = (Genπ , Sign, Verif) et deux familles de fonctions de hachage H = (GenH , H) et H0 = (GenH0 , H 0 ), on construit un schéma de signature π ∗ = (Genπ∗ , Sign∗ , Verif ∗ ) de la façon suivante : – Génération de clé : ∗ ∗ Gen∗ (1k ) = kpub , kpriv , ∗ ∗ = (s0 , kpriv ) avec s0 ← GenH0 (1k ) et (kpub , kpriv ) ← Genπ (1k ). où kpub = (s0 , kpub ) et kpriv – Production de la signature : à 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) . – Vérification de la signature : ∗ Verif ∗ (kpub , σ ∗ , m) = Verif kpub , σ ∗ , Hs0 (s)||Hs (m) , où l’indice s fait partie de la signature, et l’indice s0 de la clé publique. 63 64 Signatures numériques § VIII.8 Fonctions de hachage universelles à sens unique Ce paragraphe présente la construction d’une famille de fonctions de hachage universelle à sens unique à partir d’une famille de permutations à sens unique. Comme cette dernière peut être construite à partir d’une famille de fonctions à sens unique, cela achèvera de montrer que la signature numérique asymé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 propriétés suivantes : – Toutes les fonctions de la famille sont des fonctions deux vers un, ce qui signifie que pour toute valeur du paramètre de sécurité k et tout élément de l’ensemble d’arrivée a exactement deux antécédents. Ceci implique en particulier que l’ensemble de départ Dk a un cardinal double de l’ensemble d’arrivée Uk . – Pour tout couple (x, x0 ) d’éléments distincts de Dk , il existe un algorithme S(x, y) qui produit un indice public s d’une fonction Hs vérifiant Hs (x) = Hs (x0 ) et tel que la production d’un indice s avec l’algorithme S pour un élément x fixé de Dk et un élément x0 aléatoire de Dk revient exactement à produire l’indice s avec l’algorithme de génération Gen(1k ). On suppose aussi l’existence d’une famille F de permutations à sens unique fk : Dk −→ Dk , indexée par le paramètre de sécurité k. À partir des familles H et F, on construit la famille de fonctions de hachage Hash de la façon suivante : – La fonction de génération est celle de la famille H : GenHash (1k ) 7→ s avec s ← GenH . – Les fonctions de la famille calculent la valeur d’un élément du domaine Dk en composant D −→ Dk préalablement avec la permutation à sens unique : Hashs : k x 7−→ Hs fk (x) Le résultat de cette section est : Théorème VIII.8 La famille Hash définie ci-dessus est une famille de fonctions de hachage universelles à sens unique (UOWHF) Preuve. Montrons que si la famille Hash n’a pas la propriété d’être une famille de fonctions de hachage universelles à sens unique, alors il est possible d’inverser les éléments de la famille F, ce qui contredira l’hypothèse qu’il s’agit d’une famille de permutations à sens unique. Pour cela, supposons l’existence d’un adversaire A contre la propriété UONHF de la famille Hash et déduisons en un adversaire B contre la famille F. L’entrée de B est un élément y de Dk et son objectif est de trouver un antécédent α par fk . Pour atteindre cet objectif, l’algorithme B va utiliser l’algorithme A contre la famille Hash. L’algorithme B commence par exécuter l’algorithme A(1k ) qui retourne un élément x de Dk . On pose z = fk (x). On peut supposer que z 6= y, car dans le cas contraire, un antécédent de y est trouvé. L’indice public passé en paramètre à l’algorithme A est l’indice retourné par l’algorithme S(z, y). L’hypothèse faite sur la famille H indique que cet indice est comme s’il était produit par l’algorithme GenH . Les éléments y et z vérifient par construction Hs (y) = Hs (z). 0 L’algorithme A(s) retourne un second antécédent 0de par Hashs0 , c’est- ?-dire un élément x de Dk tel que Hashs (x) = Hs fk (x) = Hs (z) = Hashs (x ) = Hs fk (x ) . Comme les éléments de Dk ont tous exactement deux antécé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 vérifie les hypothèses requises. Une telle famille est appelée une famille universelle et est utilisée pour limiter les collisions dans les tables de recherches par clé de hachage. Pour toute valeur k du paramètre de sécurité, on identifie l’ensemble des vecteurs de k symboles binaires avec le corps F2k . – La fonction de génération GenH produit un couple (a, b) alé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) où p est une projection F2k −→ (F2 )k qui consiste à extraire les k − 1 premières composantes. Montrons que cette fonction satisfait les deux conditions requises. Tout d’abord, ax + b = (z, ε) où z = Hab (x) et ε ∈ {0, 1}. Comme a est non nul, la fonction x 7−→ ax + b est inversible, et tout élément z a exactement deux antécédents correspondants aux deux valeurs possibles de ε. Ensuite, deux éléments distincts x et x0 de F2k tels que Hab (x) = Hab (x0 ) satisfont le système d’inconnues a et b suivant : ax + b = (z, ε) ax0 + b = (z, ε) Pour z et b fixé, ce système a pour déterminant x − x0 qui est non nul. La solution est unique. Un choix aléatoire du couple (a, b), avec a 6= 0 correspond à 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 modèle le moins exigeant pour la sécurité, où l’adversaire ne connait que les paramètres publics, et n’a accès à aucun document signé. 2. Soit G un groupe cyclique d’ordre q engendré par g, où le problème du logarithme discret est un problème difficile. Soit x un élé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 résistante aux collisions. 3. Démontrer que si la famille de fonctions de hachage H est résistante aux collisions, alors elle est universelle à sens unique. 4. Prouver le théorème VIII.5 page 61 établissant la sécurité de la construction de Merkle-Damgård. 5. Rédiger la preuve détaillée du théorème VIII.7 page 63. 6. Soit H = (Gen, H) une famille de fonctions de hachage universelle à sens unique Dk −→ Dk . On définit H∗ par : – Gen∗ (1k ) 7→ (s, s0 ) où 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 à sens unique. 65 66 Signatures numériques 7. Bijections sans pince (claw free permutation). Définition VIII.9 [pince de deux bijections] Soient f0 et f1 deux bijections sur un même domaine D. Un triplet (x, y, z) d’élé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. À partir d’une famille de bijections sans pince, construire une famille de fonctions de hachage résistante aux collisions. {0, 1}n −→ D Indication : considérer Hs : . (x1 , . . . , xn ) 7−→ fxn ◦ · · · ◦ fx1 (s) 8. Soit N un module RSA. Montrer que la famille constitué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 sûr, alors la famille constituée des deux fonctions f0 : x 7−→ xe mod N et f1 : x − 7 → 2xe mod N est sans pince. En déduire une famille de fonctions de hachage résistante aux collisions reposant sur le problème RSA. 10. Signer un symbole binaire avec une famille sans pince à trappe. Soit (f0 , f1 ) une famille sans pince, montrez que la signature définie par Sign(kpub b) = σ(b) = | fb −1(x), où la clé publique kpub est constituée de x, f0 et f1 est sure. r En composant les signatures d’un symbole binaire, il est possible de définir un schéma de signature sur plusieurs symboles binaires. § IX.1 Sécurité IX – CHIFFREMENT À CLÉ PUBLIQUE § IX.1 Sécurité Le niveau de sécurité standard communément admis pour le chiffrement à clé publique est la sécurité sémantique contre des attaques adaptatives à chiffré choisi. La notion de sécurité sémantique est équivalente à celle d’indistinguabilité. L’attaque contre l’indistinguabilité se dé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 à l’environnement. 2. L’environnement choisit un bit aléatoire b ∈ {0, 1} et fournit à l’adversaire le cryptogramme c du message cb . L’objectif de l’adversaire est de fournir la valeur du bit b. Sa réponse est un bit b0 et il a gagné si b = b0 . L’avantage de l’adversaire est la quantité : Adv(A) = Prob b = b0 − 1 . 2 En répondant au hasard, sa probabilité 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 système sûr de cryptographie à clé 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 accès à un oracle de déchiffrement D à qui il soumet des cryptogramme et dont il obtient en retour les messages clairs correspondants. On parle alors d’attaque à cryptogramme choisis (CCA Chosen Ciphertext Attack). CCA1. Si l’adversaire n’a accès à cet oracle que pendant la première phase du jeu, avant de transmettre le couple de messages (m0 , m1 ), on parle d’attaque à cryptogramme choisi de niveau 1, notée CCA1. CCA2. Si l’adversaire a accès à l’oracle de déchiffrement D pendant les deux phases du jeu, y compris après avoir reçu le cryptogramme de la part de l’environnement, on parle alors d’attaque à cryptogramme choisi de niveau 2, notée CCA2. Le niveau standard de sécurité admis pour considérer qu’un schéma de chiffrement est sûr, et qui est noté 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 ? ère Schéma de l’attaque contre l’indistinguabilité 67 68 Chiffrement à clé publique § IX.2 Historique En 1991, Naor et Yung ont proposé une méthode pour construire un schéma de chiffrement résistant aux attaques à cryptogramme choisi à partir de schéma de chiffrement qui sont seulement résistants contre les attaques à clair choisis. Le principe de la méthode est d’utiliser deux algorithmes de chiffrement E1 et E2 , chacun agissant sur les messages respectifs m1 et m2 , le tout étant assorti d’une preuve sans divulgation et non interactive que les messages m1 et m2 sont égaux au message m à chiffrer. Le message m est chiffré deux fois : E(m) = E1 (m1 ), E2 (m2 ), NIZK(m1 = m2 = m) , où NISZ désigne un schéma de preuve sans divulgation non interactive (Non Interactive Zeroknowledge Proof). Pour construire un chiffré valide, il faut fournir la preuve que les deux cryptogrammes E1 (m1 ) et E2 (m2 ) proviennent bien du même message m. L’objectif de la preuve est de neutraliser l’accès à l’oracle de déchiffrement en rendant difficile la construction de chiffrés valides. L’oracle ne rend de réponse correcte que si le chiffré est bien construit. Et dans ce cas, il renvoie à l’adversaire le message qu’il vient de chiffrer, ce qui ne lui apporte aucune information. Dans le cas où l’adversaire tente de tromper l’oracle en fournissant deux cryptogrammes qui ne proviennent pas forcément du chiffrement d’un même message, l’oracle rendra une réponse hh chiffré invalide ii, qui n’apporte aucune information non plus. C’est ainsi que ce schéma est prouvé CCA1. Mais les preuves sans divulgation sont malléables. Par exemple, après transmis son défi (m1 , m2 ), l’adversaire reç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 à l’oracle le déchiffrement de c0b = E1 (mb,1 ), E2 (mb,2 ), P 0 , l’oracle lui donne directement m0b , ce qui lui permet à coup sûr de rendre la bonne valeur du bit b. Il est possible de construire des sché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 être transformée en preuve non interactive lorsque le prouveur et le vérifieur partagent une même séquence aléatoire (crs Common Random String) qui simule l’interaction dans la preuve. Toutefois, les constructions obtenues sont très peu efficaces, nécessitent des permutations à sens unique avec trappe améliorées (ETP Ehanced Trapdoor Permutation). Pour atteindre des schémas CCA2-surs efficaces, Bellare et Rogaway, ont eu recours à la notion d’oracle aléatoire. Il s’agit d’une vision idéale d’une fonction de hachage. Cela correspond à une fonction aléatoire, dont les valeurs seraient comme tirées aléatoirement, mais bien sûr, s’agissant d’une fonction, la même valeur est retournée pour le même paramètre. Cela a aboutit en au schéma OAEP (Optimal Asymetric Ecryption Padding) , où une quantité aléatoire est ajoutée au message, puis brouillée par un schéma de Feistel à deux tours comme schématisé ci-après : m||Ok ? +n R - H G ? - +n ? ? Fonction à sens unique à trappe § IX.3 CPA-sécurité sémantique du schéma ElGamal Dans ce schéma, les fonctions F et G sont supposées être des oracles aléatoires. La partie gauche du schéma de Feistel est constituée du message m, complété par des zéros pour avoir la taille convenable, et la partie droite est constituée d’une quantité aléatoire R de la taille convenable. Lorsque la fonction à sens unique avec trappe est le RSA, ce schéma est standardisé pour la sécurité de l’internet dans les normes ANSI X9.44, IEEE P1363 et SET. Ce schéma a été présenté comme CCA2-sûr, mais sans donner de preuve jusqu’en , où Victor Shoup a présenté une attaque contre ce schéma avec une fonction à sens unique avec trappe particulière. Une semaine après, il apporte la preuve de la sécurité CCA2, à condition que la fonction de chiffrement utilisée soit à sens unique partielle, c’est- ?-dire qu’on ne puisse pas calculer la partie gauche de l’entrée à partir de la sortie. E. Fujisaki, T. Okamoto, D. Pointcheval et J. Stern ont finalement prouvé en que la fonction RSA satisfait cette propriété d’être à sens unique partielle, pouvant finalement la sécurité CCA2 du standard OAEP-RSA. En , D.H. Phan et D. Pointcheval ont prouvé qu’avec un schéma de Feistel à trois tours au lieu de deux, d’une part la fonction de chiffrement n’a plus besoin d’avoir la propriété d’être à sens unique partielle, toute fonction à sens unique avec trappe convient, mais la redondance R devient inutile. Toutefois, cette sécurité n’est assurée que si les fonction G et H utilisées sont des oracles aléatoires, ce qui est une hypothèse considérée comme trop forte. L’objet de la suite est de présenter une solution au problème du chiffrement à clé publique qui ne repose pas sur le modèle de l’oracle aléatoire. Si les fonctions requises pour réaliser le chiffrement ont seulement des propriétés de résistance aux collisions ou sont à sens unique, on parle alors de modèle standard. § IX.3 CPA-sécurité sémantique du schéma ElGamal Rappelons la définition du chiffrement ElGamal. Soit un groupe G, cyclique d’ordre q, où q est un nombre premier. Soit g un générateur de G, de telle sorte que G = (g). – La clé privée est un élément x, choisi aléatoirement dans Z/qZ. – La clé publique est l’élément p = g x . – L’espace des messages est le groupe G. Le chiffrement d’un message m ∈ G procède ainsi : – Choisir un élément r aléatoire dans Z/qZ. – Le cryptogramme est constitué du couple (c1 , c2 ), où c1 = g r et c2 = pr × m. c2 c2 – À 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’hypothèse de la difficulté de ce qu’on appelle le problème Diffie-Hellmann décisionnel (DDH Decision Diffie-Hellman), ce schéma de chiffrement est sémantiquement sûr dans une attaque à clairs choisis. L’hypothèse DDH signifie que le problème de dé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), où z est un élément aléatoire de G. Cela signifie qu’il est difficile de décider si une donnée z est ou non égal à g xy lorsqu’on connait g, g x et g y . Cette hypothèse équivaut à l’indistinguabilité calculatoire des deux quadruplets : (g1 , g2 , g1x g2x ) et 0 (g1 , g2 , g1x g2x ), où g1 et g2 sont des éléments du groupe G et les éléments x et x0 de Z/qZ sont distincts. La suite de ce paragraphe décrit le principe de la preuve. On construit un algorithme B, qui résout le problème DDH en utilisant un adversaire A contre le schéma de chiffrement ElGamal. L’algorithme B a pour entrée le quadruplet (g, g x , g y , Z), et il doit décider si oui ou non on a 69 70 Chiffrement à clé publique Z = g xy . Pour cela, il dispose d’un adversaire A contre l’indistinguabilité du sché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 clé publique que B fournit à 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 répondre avec un avantage non négligeable. Á l’opposé, si Z est aléatoire, le chiffré est parfaitement aléatoire et donc A n’a aucun avantage. Il ne peut répondre correctement qu’avec une probabilité égale à 1/2. Il en résulte que l’avantage de cet algorithme B pour résoudre le problème DDH est non négligeable. On n’a pas de preuve que le schéma de chiffrement ElGamal est CCA1-sûr, mais on sait qu’il n’est pas CCA2-sûr, car il est homomorphique. Si on sait déchiffrer le cryptogramme (R, M ), alors on sait déchiffrer aussi le cryptogramme R, k × M ) (voir exercice 2). § IX.4 Chiffrement CCA-sûr dans le modèle standard IX.4.1. Principe général Le schéma de Cramer-Shoup a été conçu comme une évolution du chiffrement ElGamal de manière à pouvoir établir la preuve de sa sécurité dans une attaque à cryptogrammes choisis CCA2 dans le modèle standard, c’est- ?-dire sans avoir recours à des oracles aléatoires. En reprenant la preuve du paragraphe précédent, l’objectif, pour l’algorithme B est de pouvoir résoudre le problème DDH en utilisant un adversaire qui peut avoir accès à un oracle de déchiffrement. Il va simuler la possession de la clé privée de manière à pouvoir répondre aux requêtes de déchiffrement formulées par l’adversaire A pendant les deux phases de son travail : avant et après la production du défi (m0 , m1 ). Selon la méthodologie de Naor et Yung, le cryptogramme ressemblera à quelque chose comme : c = (g1r , g2r , y r × m, . . .), avec une preuve que ce chiffré est valide, c’est- ?-dire que les deux premières composantes sont construites à partir du même aléa r. r Dans la mé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 vérification. Cela n’est pas nécessaire. On a seulement besoin que le destinataire puisse effectuer cette vérification. Or le destinataire dispose de la clé privée. Il est possible d’affaiblir la condition, et d’avoir un modèle de preuve uniquement pour un vérifieur désigné (designated verifier). Pour ce modèle, il est possible de dégager une méthodologie générale. § IX.4 Chiffrement CCA-sûr dans le modèle standard IX.4.2. Preuve avec vérifieur désigné Le problème DDH peut s’exprimer en terme de langage. Le langage DDH est défini par : LDDH = {g1 , g2 , g1x , g2x | x ∈ Z/qZ}. Il est formé des mots qui sont des quadruplets bien formés, c’est- ?-dire dont les deux dernières composantes sont construites avec le même exposant x de Z/qZ. Ce langage est un sous-langage du langage plus général : L = {g1 , g2 , g1x , g2y | x, y ∈ Z/qZ}. Dans L, les deux dernières composantes n’ont pas forcément le même exposant. Le problème décisionnel Diffie-Hellmann consiste à décider si un élément de L appartient ou non au langage LDDH . Une preuve qu’un quadruplet (g1 , g2 , X, Y ) appartient au langage LDDH est l’élément x. Cet élément s’appelle un témoin. Il permet de vérifier que X = g1x et Y = g2x . L’élément x est un témoin qui permet à tous de vérifier l’appartenance d’un mot au langage LDDH . Pour rendre la preuve réservée à un vérifieur désigné, il suffit de chiffrer ce témoin pour que sa valeur ne soit accessible qu’au détenteur de la clé privée correspondante. En remplaçant la preuve non interactive par une preuve pour un vérifieur désigné, l’adversaire ne peut pas jouer avec un cryptogramme qui n’appartient pas au langage L. Sur une requête de déchiffrement, soit le cryptogramme n’est pas valide et il n’apprend rien, soit le cryptogramme est bien formé, mais alors c’est qu’il a été chiffré correctement et l’adversaire connait la réponse, il n’apprend rien non plus. IX.4.3. Système universel de preuve Définition IX.1 [système de preuve] Un système de preuve (HPS Hash Proof System) pour un langage L consiste en trois algorithmes : 1. Gen(1k ) est un algorithme de génération, où k est un paramètre de sécurité est qui produit une chaine aléatoire crs (Common Random Strinbg) et une clé de trappe tk (Trapdoor Key). 2. P(y, x, crs) est le prouveur. Il produit une donnée π à partir du témoin. 3. V(y, tk) est le vérifieur. Il produit une donnée π 0 à partir de la clé de trappe tk. r Le prouveur utilise le témoin x pour établir la preuve, alors que le vérifieur utilise la clé de trappe pour le même usage. Les propriétés requises pour un système de preuve sont : 1. La correction : si le mot y appartient au langage L, alors le prouveur et le vérifieur produisent la même donnée avec certitude, c’est- ?-dire Prob[π = π 0 ] = 1. 2. La t–universalité : Si t mots y1 , . . . , yt n’appartiennent pas au langage L, alors la donnée : crs, V(y1 , tk1 ), . . . , V(yt , tkt , est statistiquement indistinguable d’une donnée : crs, r1 , . . . , rt où les ri sont des aléas véritables. Ainsi, le prouveur P pourra produire une preuve π qu’un mot y appartient à L que seul le vérifieur V pourra vérifier avec sa clé privée tk. Si l’élément y n’appartient pas à L la vérification échouera. Donnons maintenant deux exemples de schémas de preuve 1–universel et 2–universel. 71 72 Chiffrement à clé publique Un schéma de preuve 1–universel reposant sur DDH Considérons le schéma de preuve suivant : pour un paramètre de sécurité k, on a un nombre q premier dont l’écriture binaire comprend k chiffres. Soit G un groupe cyclique d’ordre q et soient g1 et g2 deux éléments quelconques de G∗ . Comme q est premier, ce sont des générateurs du groupe G. Posons g2 = g1ω . La fonction de génération Gen(−1k ) produit la clé de trappe tk = (x1 , x2 ) où x1 et x2 sont des éléments aléatoires de Z/qZ, ainsi que la chaı̂ne aléatoire c = g1x1 g2x2 . Le langage LDDH est constituée des mots de la forme (g1r , g2r ), pour r ∈ Z/qZ. La valeur de r est le témoin d’appartenance à LDDH . Ce langage est un sous-ensemble du langage L constitué de tous les couples de G × G. Pour un élément y = (u1 , u2 ) de L, où u1 = g1r et u2 = g2r , le témoin r et la chaine aléatoire c, le prouveur P renvoie la donnée : P(y, r, c) = cr . À partir de la clé de trappe tk et de l’élément y = (u1 , u2 ) de L, le vérifieur V calcule la donnée : V(y, tk) = ux1 1 ux2 2 Montrons que ce schéma de preuve satisfait les propriétés requises. Ce schéma est correct, car pour un élé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–universalité, il faut montrer que si le couple (u1 , u2 ) n’appartient pas à LDDH , alors, si x1 est x2 sont choisis aléatoirement, le couple c, ux1 1 ux2 2 n’est pas distinguable d’un couple c, r) où r est un véritable aléa. Comme (u1 , u2 ) n’appartient pas à LDDH , il est le ré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 à montrer que la fonction : (x1 , x2 ) 7−→ x1 + ωx2 , r1 x1 + ωr2 x2 , 1 ω ce qui est le cas, car cette fonction est linéaire de matrice , dont le déterminant vaut r1 ωr2 ω(r2 − r1 ) et n’est donc pas nul. La fonction f étant injective, si x1 et x2 sont aléatoires, alors la valeur f (x1 , x2 ) l’est aussi, ce qui achève de démontrer que le schéma de preuve présenté dans ce paragraphe a la propriété de 1–universalité. Un schéma de preuve 2–universel La construction précédente s’applique aussi pour construire un schéma de preuve 2–universel, en doublant les données. Il faut aussi disposer d’une fonction h : G × G −→ Z/qZ résistante aux collisions. Considérons le schéma de preuve suivant : La fonction Gen(1k ) génère quatre éléments aléatoires x1 , x2 , y1 et y2 de Z/qZ. À partir de ces quatre éléments, la chaı̂ne aléatoire est crs = (c, d) avec c = g1x1 g2x2 et d = g1y1 g2y2 . La clé de trappe tl est tk = (x1 x2 , y1 y2 ). Le prouveur P, à partir d’un élément (u1 , u2 ) = (g1r , g2r ) du langage LDDH , du témoin r et de la chaı̂ne aléatoire crs, calcule la donnée donnée par : P(u1 , u2 , r, crs) = cr drα , où α = h(u1 , u2 ) est l’image par la fonction de hachage h de l’élément (u1 , u2 ) du langage. § IX.4 Chiffrement CCA-sûr dans le modèle standard La fonction de vérification est donnée par : V (u1 , u2 , tk = (ux1 1 ux2 2 )(uy11 uy22 )α . Vérifier que ce schéma de preuve est correct est immédiat. Il suffit de montrer que si (u1 , u2 ) ∈ LDDH alors P(u1 , u2 , r, crs) = V (u1 , u2 , tk), ce qui découle directement des expressions de P et V. Pour montrer la 2–universalité, considérons deux mots y e y 0 qui appartiennent au langage L sans appartenir au langage LDDH , c’est à dire qu’on a y = (u1 , u2 ) avec u1 = g1r1 , u2 = g2r2 et r1 6= r2 . r0 r0 De mê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 où r et r0 sont des données aléatoires. Pour montrer cela, comme au paragraphe précé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, où α = h(u1 , u2 ) et α0 = h(u01 , u02 ). En passant aux exposants et en remplaçant g2 par g1ω , montrer que f est injective revient à montrer que la matrice : 1 ω 0 0 0 1 ω 0 M = r1 ωr2 αr1 αωr2 r10 ωr20 α0 r10 α0 ωr20 est inversible. Le dé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 dé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-sûr Ce paragraphe présente la construction d’un chiffrement CCA-sûr. Le problème difficile sous-jacent est celui de distinguer l’appartenance ou non d’un mot y à un langage L. On suppose également qu’on a les systèmes de preuves suivants avec les propriétés indiquées : – le système (Gen, P, V) a la propriété de 1–universalité pour le langage L ; – le système (Gen0 , P0 , V0 ) a la propriété de 2–universalité pour le langage L0 = L||{0, 1}n . Les mots du langage L0 sont la concaténation des mots du langage L avec n’importe quelle étiquette constituée de n symboles binaires. Définissons le système de chiffrement à clé publique (GenE , Enc, Dec) : – Génération des clés GenE (1k ) pour le paramètre de sécurité k : – Soit (crs, tk) ← Gen(1k ). – Soit (crs0 , tk0 ) ← Gen0 (1k ). – La clé publique Kpub est (crs, crs0 ). – La clé privée Kpriv est (tk, tk0 ). – Chiffrement EncKpub (m) : – Choisir un élément y dans le langage L avec un témoin x. – La clé de session est π = P(t, x, crs). Le message m est masqué avec cette clé de session comme un masque jetable : c = m ⊕ π. – Soit π 0 = P(y||c, x, crs0 ). – Le cryptogramme est C = (y, c, π 0 ). – Déchiffrement DecKpriv (y, c, π 0 ) : – Calculer π e = V(y, tk) – Calculer π e0 = V0 (y||c, tk). – Vérifier si π = π 0 . Si ce n’est pas le cas, signifier l’échec du déchiffrement. Si c’est le cas, alors retourner m0 = π e ⊕ c. 73 74 Chiffrement à clé publique Preuve. La preuve de la sécurité CCA de ce système de chiffrement considère des jeux. Le jeu 0 est le jeu réel. L’adversaire A peut accéder à l’oracle de déchiffrement, et celui-ci fournit les bonnes réponses conformément à la définition du schéma de chiffrement : L’adversaire fournit un défi (m0 , m1 ). L’environnement choisit un bit b aléatoire dans {0, 1}, un élément y du langage L avec un témoin x, calcule les données P(y, x, crs) = π et P0 (y||c, x, crs0 ) = π 0 . Il fournit le cryptogramme C = (y, c, π 0 ), où 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 données π et π 0 par les prouveurs P et P0 , ces données vont être crées par le vérifieur avec la clé de trappe tk. Le calcul des donné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 calculées au cours de ces deux jeux sont les mêmes. La différence réside dans le fait que, dans le jeu 1, le simulateur de l’environnement dispose de la clé privée et n’a plus besoin du témoin de y. Dans le jeu 2, le cryptogramme est calculé avec un élément y qui n’appartient pas au langage L. Les défis des jeux 1 et 2 sont indistinguables, à cause de la propriété d’indistinguabilité d’appartenance au langage L. La question est de savoir si les requêtes ont plus de chance d’être invalides dans le jeu 1 ou dans le jeu 2. Notons DecInv l’évènement hh le cryptogramme est invalide mais passe le test de validité ii. C’est le cas si l’adversaire A pose un cryptogramme invalide avec y 6∈ L, mais qui passe la vérification, car π e0 = π 0 . Dans le jeu 1, comme la valeur de V(y, tk) est aléatoire, la probabilité de cet évènement est négligeable, égale à l’inverse du cardinal de l’ensemble d’arrivée. Dans le jeu 2, c’est différent, car l’adversaire reçoit V(y, tk) pour y 6∈ L. C’est la 2–universalité qui rend la probabilité de l’évènement DecInv négligeable. Si l’adversaire pose à l’oracle un cryptogramme C ∗ = (y ∗ , c∗ , π 0∗ ) avec y ∗ = y et c∗ = c, alors nécessairement π 0∗ 6= π 0 , car la question posée à l’oracle doit être différente du défi, et dans ce cas, la vérification rejette le cryptogramme. Un cryptogramme invalide qui passe la vérification doit nécessairement vérifier (y ∗ , c∗ ) 6= (y, c). Si le cryptogramme C ∗ passe la vérification, c’est que π 0∗ = V0 (y ∗ ||c∗ , tk), mais comme les éléments y et y ∗ n’appartiennent pas au langage L, en raison de la 2–universalité, le couple (y, c, π 0 ), (y ∗ , c∗ , π 0∗ ) est constitué de composantes aléatoires, et le test passe avec une probabilité négligeable. Si A pose des cryptogrammes valides, cela se passe comme dans le jeu 1. Par conséquent, l’avantage de l’adversaire A entre le jeu 1 et le jeu 2 change d’une quantité négligeable. Dans le jeu 3, on remplace la composante c = π ⊕ mb dans le défi par un alé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 précédente avec les schémas de preuve 1–universel et 2–universel du paragraphe IX.4.3. Ce système de chiffrement opère dans un groupe G, cyclique dont l’ordre q est un nombre premier. Soient g1 et g2 deux générateurs de ce groupe. Soit également une fonction h : G × G −→ Z/qZ supposée sans collision. La clé privée est la clé de trappe, constituée de six éléments aléatoires x1 , x2 , y1 , y2 , z1 et z2 de Z/qZ. La clé publique correspondante est le triplet (c, d, h) de G3 , où c = g1x1 g2x2 , d = g1y1 g2y2 ry h = g1z1 g2z2 . r Dans la clé privée, les quatre éléments x1 , x2 , y1 et y2 sont la clé de trappe d’un système de preuve, et le couple (c, d) est la chaine aléatoire commune. Pour chiffrer un message m de G, on choisit un élément alé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 constitué du quadruplet C = (u1 , u2 , e, v). § IX.5 r Exercices La donnée e est l’étiquette définissant les mots du langage L0 Pour déchiffrer ce cryptogramme, on vérifie tout d’abord si v est ou non égal à ux1 1 ux2 2 (uy11 uy22 )α , avec α = h(u1 u2 , e). Si non, on déclare l’échec du déchiffrement, et si oui, on retourne le clair e/uz11 uz22 . § IX.5 Exercices 1. Écrire en détail la preuve de la sécurité CPA du schéma de chiffrement ElGamal sous l’hypothèse de la difficulté du problème Diffie-Hellmann décisionnel. 2. Trouver une attaque contre la sécurité CCA2 du schéma de chiffrement ElGamal. Indication : Si c = (R, M ) demander le déchiffrement de (R, 2M ). 3. Démontrer que le système de chiffrement de Cramer-Shoup est correct, c’est-à-dire que la procédure de déchiffrement retrouve bien le message clair qui a été chiffré, et qu’il est CCA-sûr sous l’hypothèse de la difficulté du problème de décision Diffie-Hellmann. 4. Le système de Cramer-Shoup reste-t-il sûr si on détache la composante ve = (cr , drα ) dans le cryptogramme au lieu de ne transmettre que le produit v = cr drα . 75 76 Corrigé des exercices Corrigé des exercices II.1. La fonction supposée à sens unique reposant sur la difficulté du logarithme discret est la fonction puissance dans le corps Fp – L’ensemble d’indices est l’ensemble des couples (p, g), où p est un nombre premier, et g est un générateur du groupe multiplicatif Z/pZ∗ . Pour pouvoir trouver efficacement un géné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 génère un nombre premier aléatoire p dont la factorisation de p − 1 est connue, ainsi qu’un générateur aléatoire g. Pour tester qu’un élément g est générateur du groupe multiplicatif Z/pZ∗ , on vérifie que rr 6= 1 pour tout r = (p − 1)/r, où r est un diviseur premier de p − 1. – L’algorithme S2 génère un entier alé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), où n est un entier égal au produit de deux nombres premiers de même taille, et où e est un exposant public valide pour n, c’est-à-dire un entier qui est premier avec ϕ(n). – Le domaine des fonctions Di est l’ensemble Z/nZ. – L’algorithme S1 génère un couple (n, e). Pour cela il génère un couple de nombre premiers aléatoires, en tirant au hasard un entier quelconque, puis en testant sa primalité. Cette façon de faire est de complexité polynomiale à l’aide par exemple du test de primalité de Miller-Rabin, ainsi qu’en raison de la densité des nombres premiers donnée par le théorème des nombres premiers. – L’algorithme S2 génère un élément aléatoire de Z/nZ. – Pour i = (n, e) ∈ I, la fonction RSA fi est x 7−→ xe mod n. r Il n’est pas nécessaire de restreindre le domaine seulement aux éléments inversibles modulo n. En raison du théorème chinois, les formules RSA restent valables pour tout élément de Z/nZ. Certes, la donnée d’un élément non inversible non nul de Z/nZ permet de factoriser n, mais trouver un tel élément est un problème difficile et la situation d’avoir à chiffrer un tel élément est hautement improbable. II.3. Rappelons que si P 6= N P, alors un problème N P–complet est un problème difficile dans le pire des cas. L’idée pour cet exercice est de construire une fonction à partir d’un problème N P–complet. Elle sera difficile à inverser dans le pire des cas, mais pourra être facile à inverser en moyenne. Prenons le problème 3COL du coloriage d’un graphe avec trois couleurs. Un graphe G de n sommet est par définition une matrice n × n dont les coefficients appartiennent à l’ensemble {0, 1}. Les coefficients égaux à 1 représentent une arrê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 à chaque sommet associe une couleur, et tel que deux sommets adjacents ne soient pas coloriés avec la même couleur, c’est-àdire, pour tout couple (i, j) de sommets adjacents, c’est-à-dire tels que gij = 1, on a c(i) 6= c(j). Rappelons ces résultats : – Si on sait qu’un graphe est coloriable avec trois couleurs, il est toujours difficile de trouver un coloriage. Corrigé 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) aléatoire, trè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 aléatoire, on aura trouvé un antécédent par f . Le seul cas où trouver l’antécédent sera un problème difficile sera lorsqu’il faudra chercher un antécédent de (G, 0). Il suffira de répondre au hasard. Ce sera sûement un échec, mais cela survient très rarement. La fonction f n’est pas à sens unique en moyenne, mais est difficile à inverser dans le pire des cas. r Il est crucial comprendre que que les défis qu’un algorithme doit chercher à inverser sont des images d’éléments aléatoires de l’ensemble de départ. S’il s’agissait d’éléments aléatoires de l’ensemble d’arrivée, la probabilité de succès serait toujours négligeable. II.4. Soit f une fonction à sens unique. Construisons à partir de f une fonction F à longueur régulière. Pour cela, on complète la valeur f (x) par des zéros jusqu’à atteindre une longueur constante pour toutes les entrées de taille n. Comme f est à sens unique, elle est calculable efficacement et pour toute entrée de taille n, la taille de f (x) est bornée par un polynôme en n. Soit P (n) ce polynôme connu. La fonction F : x 7−→ (f (x), 0k ), où k = P (n) − |f (x)|, est à longueur régulière par construction. La fonction F est aussi à sens unique, car si elle ne l’était pas, cela conduirait directement à un algorithme pour inverser f . II.5. II.6. 1. Non ! Pas toujours ! Soit E = F × F et f1 une fonction à sens unique F −→ F . On montre facilement que la fonction : E × E −→ E × E f : (x1 , x2 ) 7−→ f1 (x2 ), 0 est à sens unique et vérifie f ◦ f : (x1 , x2 ) 7−→ (f1 (0), 0). Et une fonction constante n’est clairement pas à sens unique. 2. Oui. Montrons que si la fonction f est à sens unique, alors la fonction g l’est aussi. Pour cela, montrons la contraposée. Si la fonction g n’est pas à sens unique, alors la fonction f ne l’est pas non plus. On suppose qu’il existe un algorithme qui inverse g, et déduisons en un algorithme B qui inverse f . L’algorithme B prend en entrée un élé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) à l’algorithme A. L’algorithme A retourne un antécédent y par g qui est un antécédent de f . La probabilité de succès de l’algorithme B est la même que la probabilité de succès de l’algorithme A. 3. Oui. Comme à la question précédente, soit un algorithme A qui inverse f ◦ f et construisons un algorithme B qui inverse f . L’algorithme B prend en entrée un élément y de l’image de f . Il doit trouver l’unique antécédent de y par f . 77 78 Corrigé des exercices – Soumettre y à l’algorithme A. Soit x la valeur rendue par l’algorithme A qui est supposée être la valeur qui vérifie f ◦ f (x) = y. – Rendre comme résultat f (x) qui est par construction l’antécédent de y par f . L’algorithme B donne la bonne réponse avec une probabilité égale à celle de l’algorithme A. La différence avec la première question est que, comme f est une bijection, un élément aléatoire du domaine de f est aussi un élément aléatoire de l’image de f , ce qui est faux si f est III.1. Soit (N, e) la clé publique RSA. Supposons pour une contradiction qu’il existe un oracle qui permet, pour tout message chiffré xe mod N donné, de retourner la parité de x. Montrons que cette fonction peut être utilisée pour retrouver x tout entier à partir du cryptogramme y = xe mod N . L’interrogation de l’oracle informe du bit de parité de x, c’est à dire de la valeur de son dernier chiffre dans la numé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 possibilité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 à 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, où 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 générateur du groupe multiplicatif (Fp , ×). Pour tout entier n, la valeur de αn est un carré dans Fp si et seulement si n est pair. À partir d’une valeur y = αn , il est facile, avec le symbole de Legendre par exemple, de savoir si y est un carré, et donc de savoir si n est pair. III.3. La contraposée est quasi immédiate. Si une fonction f injective n’est pas à sens unique, alors il existe un algorithme efficace pour trouver un antécédent x pour une valeur y donnée. Comme x est injective, cette valeur est unique. Tout bit de b de f se calcule alors efficacement à partir de x. q L’hypothèse d’injectivité est cruciale. Une fonction constante n’est bien sûr pas à sens unique, qqAA et pourtant, toute fonction booléenne non dégénérée de l’entrée, par exemple le bit de poids faible, est un bit difficile, puisque la connaissance de la valeur n’est d’aucune utilité pour trouver ce bit. IV.1. Cet exercice est destiné à montrer que, si t(n) est un polynôme en n, la concaténation t(n) fois d’un générateur pseudo-aléatoire reste un générateur pseudo-aléatoire. Il faut montrer que les deux variables aléatoires suivantes sont calculatoirement indistinguables : X = g(X1 ) , . . . , g(Xt(n) ) Y = Y1 ,..., Yt(n) où les Xi sont des variables aléatoires uniformes sur {0, 1}n et les Yi sont des variables aléatoires uniformes sur {0, 1}2n . Afin d’appliquer la technique hybride, construisons une suite de variables aléatoires Zi , pour i = 0 à t(n), telle que Z0 = X et Zt(n) = Y , et telles qu’on puisse montrer que deux termes consécutifs Zi et Zi+1 sont calculatoirement indistinguable. Si on arrive à majorer uniformément ∆(Zi , Zi+1 ) par une quantité négligeable ε(n), cela permettra de conclure avec l’inégalité triangulaire : ∆(Z0 , Zt(n) ) ≤ t(n)ε(n). Corrigé 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 diffé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 déduit donc directement un distingueur de même avantage entre g(Xi ) et Yi . Par conséquent ∆(Zi , Zi+1 ) ≤ ∆ g(X), Y . IV.2. IV.3. IV.4. IV.5. Considérons pour simplifier un exposant public e égal à 3. Rappelons que l’extraction des racine cubique dans Z n’est pas un problème difficile. Il existe des algorithme efficace pour les extraire, par exemple la méthode de newton. Soient n1 , n2 et n3 les trois modules RSA publics. L’exercice revient à montrer que la foncion : fn1 n2 n3 : m 7−→ (m3 mod n1 , m3 mod n2 , m3 mod n3 ) n’est pas à sens unique. La connaissance de l’image y = (m3 mod n1 , m3 mod n2 , m3 mod n3 ) permet, à l’aide du théorème des restes chinois, de trouver un élément z de Z/n1 n2 n3 Z tel que z ≡ m3 modulo n1 n2 n3 . On suppose bien sûr que n1 , n2 et n3 sont deux à deux premiers entre eux, sinon, le calcul de pgcd donne un facteur strict de l’un d’entre eux, ce qui suffit à inverser la fonction RSA. Comme chaque composante m3 mod ni de y est inférieure à 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 paramètres de taille variable, le caractère pseudo-aléatoire de la famille n’est plus assuré. Pour montrer cela, exhibons un distingueur sachant reconnaı̂tre un élément d’une telle famille d’une fonction aléatoire. r Comme la famille constituée de fonction avec une taille fixe de paramètre, le distingueur devra interroger l’oracle avec des paramètres de taille différente. En interrogeant l’oracle avec f (0) = y et f (00) = z, si z = g0 (y) alors f est très probablement un élément de la famille Fn , sinon, c’est une fonction aléatoire. q Pour définir une famille de fonctions pseudo-aléatoires, il est crucial que les fonctions de cette qqAA famille opèrent sur des paramè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-aléatoire de fonctions {0, 1} −→ {0, 1} booléennes. Pour construire une famille pseudo-aléatoires de fonctions vectorielles à valeurs dans {0, 1}n , le principe est de prendre un ensemble de n fonctions booléennes qui définiront les n composantes. 79 80 Corrigé des exercices Considérons donc la famille G = gs s∈{0,1}n×n , définie par : s = (k1 , . . . , kn ) gs (x) = fk1 (x), . . . , fkn (x) Il reste à montrer que la famille G est une famille pseudo alé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 booléennes alétoires. La suite de famille est construite en remplaçant à chaque fois une composante pseudo-aléatoire de F par une composante alé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)) oà h1 , . . . , hn sont des fonctions booléennes aléatoires {0, 1}p(n) −→ {0, 1}. La distance calculatoire entre deux familles Hi et Hi+1 est négligeable, car un distingueur de ces deux familles est exactement comme un distingueur entre les composantes qui diffèrent qui sont fki et hi , et on a supposé que la famille F des fonctions booléennes est pseudo-aléatoire. On en dé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 booléennes aléatoires, ce qui reste négligeable. V.3 Par contraposée, montrons que si la famille n’est pas une famille pseudo-aléatoire de fonctions à sens unique, alors elle n’est pas une famille pseudo-aléatoire. Par hypothèse, on suppose qu’il existe un algorithme A qui, étant donnée un élément y de {0, 1}n , est capable de trouver un antécédent x de y par un élément aléatoire fk de la famille, avec une probabilité non négligeable, uniquement en utilisant un oracle pour déterminer les valeurs de fk dont il a besoin pour effectuer cette tàche. Considérons l’algorithme B qui exécute les instructions suivantes : – Choisir un élément x aléatoire de {0, 1}n . – Soumettre cet élément à l’oracle qui renvoie y = fk (x). – Soumettre maintenant y à l’algorithme A qui est supposé retourner un antécédent de y. Soit x0 l’élément de {0, 1} retourné par l’algorithme A. – Soumettre à nouveau x0 à l’oracle qui retournera y 0 = f (x0 ). – Si y = y 0 alors l’algorithme A a réussit. Il y a de fortes chances que l’oracle réalise un élément de la famille pseudo-aléatoire. Dans ce cas, l’algorithme B rend 1 pour signifier que l’oracle réalise une fonction pseudo-aléatoire. Sinon, il y a de fortes chances aussi pour que l’oracle réalise une fonction parfaitement aléatoire, l’algorithme rend 0 pour signifier que l’oracle réalise une fonction aléatoire. Il reste des détails de calcul pour vérifier que si l’avantage de l’algorithme A n’est pas négligeable, alors l’avantage de l’algorithme B n’est pas négligeable non plus. r Par un raisonnement similaire, on peut montrer qu’une famille de fonctions pseudo-aléatoire cache tous les bits des entrées. Un adversaire ne peut déterminer un bit f (x) d’un antécédent x d’un élément y qu’avec une probabilité négligeable. VI.1 a) La preuve est directe : f2 ◦ i(x) = i(x) ⊕ i ◦ i(x) = i(x) ⊕ x = f2 (x). Corrigé 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 requêtes telles que R0 = R00 . Pour avoir L3 = L03 , il faut f2 (R1 ) = f2 (R10 ). Prendre R1 = R10 ne convient pas, car cela conduirait à L0 = R00 . Par contre, on peut chercher à avoir R10 = i(R1 ). D’après la question a), ces deux valeurs ont la mê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 schéma F et une foncion aléatoire R est donc le suivant : 1. Poser une requête (L0 , R0 ). Soit (L3 , R3 ) la réponse. 2. Pouser une seconde requête (L0 0, R00 ) avec R00 = R0 et L00 = L0 ⊕ R0 ⊕ L3 . Soit (L03 , R30 ) la réponse. 3. Si L3 = L3 , alors rendre 1 pour décider que l’oracle est un shéma F, sinon, rendre 0 pour décider que l’oracle est un shcéma R. Estimons l’avantage d’un tel algorithme. AdvA = Prob AF = 1 − Prob AR = 1 , F oà Prob RA = 1 est la probabilité que l’algorithme A réponde 1 en présence d’un schéma F et Prob A est la probabilité que l’algorithme A réponde 1 en présence d’une fonction aléatoire R. Si l’oracle est un shéma F, répond toujours correctement, car on a toujours L3 = L03 l’algorithme F dans ce cas l ?, donc Prob A = 1 = 1. L’algorithme échoue en face d’un oracle qui est une fonction aléatoire si R0 = L3 , car dans ce cas, la deuxième requête sera identique à la première, ou si fortuitement, L3 = L03 . Partageons l’évènnement hh AR = 1 ii selon que L3 est ou non égal à 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 aléatoire, la probabilité d’avoir R0 = L3 vaut 1/2n , et si l’oracle est une fonction aléatoire, la probabilité que l’algorithme réponde 1 est la probabilité 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 négligeable. VI.2 La famille (Gn ) est une famille de bijections, car l’image réciproque par gk du vecteur (y0 , . . . , yn ) est le vecteur (x0 , . . . , xn−1 , x0 ⊕ yn ), oà (x0 , . . . , xn−1 ) est l’image réciproque par fk du vecteur (y0 , . . . , yn−1 ). Si une famille de fonctions ou de permutations n’est pas pseudo-aléatoire, c’est qu’il existe une relation prévisible entre les entrées et les sorties. Une fois cette relation trouvée, il est facile d’élaborer un altorithme qui distinguera cette famille d’une famille de fonctions aléatoires. Dans le cas de cet exercice, la première composante de la valeur vaut toujours x0 ⊕ b, ce qui suggère immédiatement l’algorithme suivant : 1. Soumettre une requête quelconque (x0 , . . . , xn−1 , b). Soit (y0 , . . . , yn ) la réponse. 2. Si yn = x0 ⊕ b alors retourner 1 pour signifier le l’oracle réalise la famille G de l’énoncé. Sinon, retourner 0 pour signifier que l’oracle réalise une permutation alé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 Corrigé des exercices En effet, cet algorithme donne une réponse toujours juste si l’oracle réaliser un élément de la famille G, et si l’oracle est une permutation aléatoire, il se peut que fortuitement on ait yn = xn−1 ⊕ b, auquel cas l’algorithme donne une fausse réponse, et cela survient avec une probabilité égale à 1/2. VII.1 VII.2 VII.3 VII.4 VII.5 VII.6 VIII.1 VIII.2 Index alphabétique Index alphabé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-aléatoire . . . . 27. — de permutations pseudo-aléatoire . 32. fonction — négligeable . . . . . . . . . . . . . . . . . . . 9. — à sens unique asymptotique . . . . . 10. Feistel shéma de — . . . . . . . . . . . . . . . . . . . 33. –G– générateur pseudo-aléatoire (GPA) . . . . 20. –H– Heuristica . . . . . . . . . . . . . . . . . . . . . . . 53. hybride procédé — de démonstration . . . . . . 24. –I– indistinguabilité . . . . . . . . . . . . . . . . . . 39. –L– Luby – Rackoff . . . . . . . . . . . . . . . . 34. –M– MAC . . . . . . . . . . . . . . . . . . . . . . . . . . 46. malléabilité . . . . . . . . . . . . . . . . . . . . . 45. Minicrypt . . . . . . . . . . . . . . . . . . . . 53, 64. mode — CBC . . . . . . . . . . . . . . . . . . . . . . 44. — ECB . . . . . . . . . . . . . . . . . . . . . . . 44. monoı̈de libre . . . . . . . . . . . . . . . . . . . . . 9. –O– oracle aléatoire . . . . . . . . . . . . . . . . . . . 68. –P– Paillier chiffrement de — . . . . . . . . . . . . . . . Pessiland . . . . . . . . . . . . . . . . . . . . . . . pince (de bijection) . . . . . . . . . . . . . . . preuve sans divulgation . . . . . . . . . . . . problème — 3COL . . . . . . . . . . . . . . . . . . . . . . 26. 53. 66. 19. 76. –S– sémantique sécurité — . . . . . . . . . . . . . . . . . . . . 38. –Z– zero knowledge . . . . . . . . . . . . . . . . . . . 19. 83