Cryptographie à clé publique : Constructions et preuves de sécurité

Université Paris VII Denis Diderot UFR Algorithmique École Normale Supérieure, Paris Équipe de cryptographie Cryptographie à clé publique : Constructions et preuves de sécurité THÈSE présentée et soutenue publiquement le 16 Novembre 2006, à l École normale supérieure, Paris pour l obtention du Doctorat de l Université Paris VII Denis Diderot (Spécialité informatique) par Benoît Chevallier-Mames Composition du jury: Directeur : Dr. David Pointcheval (École normale supérieure & CNRS) Rapporteurs : Dr. Marc Girault (France Télécom R&D) Prof. David Naccache (Université de Paris II Panthéon - Assas) Examinateurs : Prof. Arnaud Durand Dr. Marc Joye Prof. Adi Shamir Prof. Jacques Stern (Université de Paris VII Denis Diderot) (Thomson R&D) (Weizmann Institute of Science, Israël) (École normale supérieure) Thèse effectuée au sein du Security Technology Department, Gemplus/Gemalto, La Ciotat

Remerciements Trois ans. Cela fait bientôt trois ans que j ai commencé cette thèse, et pratiquement depuis le début, j ai eu envie d en écrire la partie Remerciements. Pas seulement parce que c est la partie finale, la dernière touche que quelqu un apporte à une thèse, mais plutôt pour remercier comme il se doit les gens qui m ont aidé, soutenu et encouragé durant tout ce temps, et sans qui je ne serais pas là aujourd hui. Voila enfin venu le temps de pouvoir leur dire publiquement merci. Durant cette thèse, je considère que j ai eu la chance d avoir trois Pygmalion : mon directeur de thèse, David Pointcheval ; mon correspondant scientifique, c est-à-dire mon encadrant à Gemplus/Gemalto, Marc Joye ; et enfin, mon collègue Pascal Paillier. En plus d être devenus, je le crois, des amis, David, Marc et Pascal ont toujours été pour moi d intarissables sources d idées et des exemples à suivre. Ils m ont donné des directions de recherche et appris à rédiger les articles. Enfin, tâche ô combien importante et difficile, ils ont relu, annoté et corrigé cette thèse. Bref, ils ont participé à faire de moi le chercheur que je suis aujourd hui. Ici, je leur dis encore une fois merci pour tout. J ai eu la chance d effectuer ma thèse dans le laboratoire de l École normale supérieure, tout en travaillant à Gemplus/Gemalto. Merci David d avoir accepté d être mon directeur de thèse dans ces conditions, en me laissant une grande liberté dans mon organisation et dans mes travaux. Je voudrais également remercier ici tous les membres de l équipe Cryptographie de l École normale supérieure de m avoir si bien accueilli. Je voudrais aussi remercier chaleureusement toutes les personnes de Gemplus/Gemalto qui m ont permis de faire cette thèse. Ceci s adresse particulièrement à ceux qui ont été mes chefs d équipe durant ces années : Nathalie Feyt, Jean-François Dhem, Mathieu Ciet, Philippe Proust et David Naccache. J adresse des remerciements spéciaux à ce dernier, pour avoir encouragé durant sa carrière à Gemplus, la recherche dans l entreprise, et le démarrage de thèses d un grand nombre de personnes de son groupe, dont moi-même. J adresse également mes remerciements aux membres passés et présents de l équipe Sécurité de Gemplus/Gemalto avec qui j ai eu le plaisir de travailler. Je ne pourrais tous les citer, mais toutes les personnes de ce groupe m ont apporté quelque chose, et je les en remercie. Merci enfin à l entreprise Gemplus/Gemalto, qui m a permis d aller durant mes années de thèse à de nombreuses conférences (Ches 03, Ct-rsa 04, Crypto 05, Eurocrypt 05, Acns 05, Pkc 06 et Eurocrypt 06). Je voudrais également remercier Arnaud Durand, Marc Girault, Marc Joye, David Naccache, Adi Shamir et Jacques Stern pour m avoir fait l honneur d être membres du jury. C est un privilège d avoir de telles personnalités comme examinateurs. Un remerciement tout particulier va vers mes rapporteurs, Marc Girault et David Naccache, qui ont eu la patience de relire cette thèse et de la corriger. Un des plaisirs de la recherche est de travailler à plusieurs. J ai eu moi-même la chance de co-écrire certains papiers. Je remercie ici mes co-auteurs pour ce qu ils m ont apporté et appris, et pour avoir accepté ces collaborations : Nuttapong Attrapadung, Éric Brier, Mathieu Ciet, Christophe Clavier, Jun Furukawa, Takeshi Gomi, Goichiro Hanaoka, Hideki Imai, Marc Joye, David Naccache, Pascal Paillier, Duong Hieu Phan, David Pointcheval et Rui Zhang. Durant ma thèse, j ai également eu la chance d être membre du comité de programme de grandes conférences : merci à Marc Joye de m avoir permis d être membre du comité de i

Ches 04, merci à Raphael Chung-Wei Phan de m avoir choisi pour être membre du comité de Ish 05 et enfin merci à David Pointcheval qui m a donné l opportunité d être membre du comité de Ct-rsa 06. Être membre de ces comités m a permis d avoir une autre vision de la recherche, et m a beaucoup apporté. J en profite d ailleurs pour remercier les nombreux relecteurs qui m ont aidé dans ces tâches. Durant ma thèse, j ai pu participé à certains projets européens ou français. Ils m ont permis de rencontrer d autres chercheurs et de financer certains déplacements. Je remercie donc le réseau européen d excellence Ecrypt, le projet français Crypto ++ et le projet français Saphir. Enfin, je réserve ici une place pour ceux que je n ai pu mettre dans une autre catégorie : merci à Denis Roegel pour sa classe LATEX ; merci à Damien Vergnaud de m avoir invité à faire une présentation au séminaire de Cryptographie de l Université de Caen ; merci à Jean-Sébastien Coron pour les conseils et l aide qu il m a apportés ; merci à l École des Mines de Gardanne de m avoir permis de donner des cours de Cryptographie ; merci aux membres de Dream Theater pour la musique qu ils font et que j adore. Je ne saurais finir cette partie sans remercier également mes amis et ma famille. Merci à ma sœur Gaëlle, mon frère Thibault, merci à mes parents François et Christine de m avoir permis de faire des études et encouragé à travailler à l école. Toutes mes pensées à ceux et celles qui ont jalonné ma vie, aux élèves du Lycée Victor Hugo, de la prépa Camille Guérin, à mes amis de promotion de Supélec, et notamment au fabuleux d3. Enfin, je voudrais terminer cette partie par un remerciement général à tous ceux qui ont été mes professeurs depuis mon plus jeune âge, et ont ainsi été participants de la thèse que je vais présenter ici. ii

À ceux que j aime. iii

iv

Sganarelle : Mais encore faut-il croire quelque chose dans le monde : qu est ce donc que vous croyez? Dom Juan : Ce que je crois? Sganarelle : Oui. Dom Juan : Je crois que deux et deux font quatre, Sganarelle, et que quatre et quatre font huit. Dom Juan ou le festin de pierre, Molière v

vi

Table des matières Notations xv Partie I. Introduction générale Chapitre 1. Introduction à la cryptologie 1.1 La cryptologie en quelques mots......................... 3 1.1.1 Science du secret.............................. 3 1.1.2 Cryptographie, cryptanalyse....................... 4 1.1.3 Cryptographie symétrique et cryptographie asymétrique........ 4 1.2 Buts de la cryptologie............................... 4 1.2.1 Confidentialité............................... 4 1.2.2 Intégrité.................................. 4 1.2.3 Identification................................ 5 1.2.4 Authentification.............................. 5 1.3 Fonctions de base en cryptologie......................... 5 1.3.1 Fonction à sens unique.......................... 5 1.3.2 Fonction de hachage............................ 5 1.3.3 Fonction pseudo-aléatoire......................... 5 1.3.4 Permutation à sens unique........................ 6 1.3.5 Fonction bilinéaire admissible...................... 6 1.3.6 Famille de fonctions............................ 6 1.3.7 Fonction de padding........................... 6 1.4 Notions de complexité............................... 7 1.4.1 Algorithme................................. 7 1.4.2 Algorithme polynomial ou sous-exponentiel............... 7 1.4.3 Complexité d un algorithme....................... 7 vii

Table des matières 1.4.4 Réduction d un problème à un autre................... 7 1.5 Conclusion..................................... 8 Chapitre 2. Sécurité prouvée et cryptologie 2.1 Réduction de sécurité et sécurité prouvée.................... 9 2.1.1 Réduction de sécurité et sécurité prouvée................ 9 2.1.2 Finesses des réductions de sécurité.................... 10 2.1.3 Modèle de sécurité............................. 10 2.1.4 Modèle standard, modèle de l oracle aléatoire.............. 10 2.2 Problèmes cryptographiques difficiles...................... 11 2.2.1 Problèmes cryptographiques difficiles basés sur la factorisation.... 11 2.2.2 Problèmes cryptographiques difficiles basés sur le logarithme discret. 12 2.2.3 Problèmes cryptographiques difficiles avec fonction bilinéaire..... 13 2.3 Conclusion..................................... 14 Chapitre 3. Résumé de nos travaux Partie II. Schéma de signature à sécurité prouvée Chapitre 4. Introduction aux schémas de signature 4.1 Introduction.................................... 25 4.1.1 Schémas de signature........................... 26 4.1.2 Protocole d identification à divulgation nulle de connaissance..... 27 4.2 Σ-protocole..................................... 28 4.2.1 Heuristique de Fiat-Shamir........................ 29 4.2.2 Signatures à coupons........................... 30 4.3 Sécurité des schémas de signature........................ 30 4.3.1 Notions de sécurité pour les schémas de signature........... 30 4.3.2 Σ-protocoles et lemme de bifurcation.................. 32 4.3.3 Exemple de la sécurité de la primitive RSA............... 32 4.4 Schémas de signature classiques avec oracles aléatoires............. 33 4.4.1 Signature RSA............................... 33 4.4.2 Signature Schnorr............................. 34 viii

4.4.3 Signature GQ................................ 35 4.4.4 Signature GPS............................... 35 4.4.5 Signature PS................................ 36 4.5 Preuves classiques de schémas de signature................... 37 4.5.1 Preuve de RSA-FDH dans le modèle de l oracle aléatoire........ 37 4.5.2 Preuve de Schnorr dans le modèle de l oracle aléatoire......... 38 4.6 Nos travaux sur les schémas de signature.................... 40 Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine 5.1 Méthode générique proposée........................... 42 5.1.1 Notre construction............................. 42 5.1.2 Sécurité de cette construction...................... 44 5.2 Un exemple concret d application de notre heuristique............. 46 5.2.1 Un schéma de signature à coupon, basé sur le RSA et à réduction fine 46 5.2.2 Sécurité de notre exemple......................... 46 5.2.3 Comparaison de notre schéma avec RSA-PSS.............. 48 5.2.4 Extensions à d autres problèmes cryptographiques........... 50 5.3 Conclusion..................................... 50 Chapitre 6. Un schéma de signature efficace basé sur le CDH 6.1 Le schéma de signature EDL........................... 52 6.1.1 Présentation du schéma.......................... 52 6.1.2 Sécurité du schéma EDL......................... 52 6.1.3 Caractéristiques du schéma de signature EDL.............. 54 6.2 Les schémas de signature de Katz-Wang..................... 54 6.2.1 Présentation du schéma KW-CDH.................... 55 6.2.2 Sécurité du schéma KW-CDH....................... 55 6.2.3 Présentation du schéma KW-DDH.................... 57 6.2.4 Sécurité du schéma KW-DDH....................... 58 6.3 Un nouveau schéma de signature......................... 59 6.3.1 Une étape de notre construction..................... 60 6.3.2 Description de notre schéma....................... 61 6.3.3 Preuve de sécurité de notre schéma................... 61 6.3.4 Utilisation de coupons dans notre schéma................ 63 6.3.5 Taille des paramètres........................... 64 ix

Table des matières 6.3.6 Comparaison de notre schéma avec EDL, KW-CDH et autres schémas 65 6.3.7 Derniers raffinements........................... 66 6.3.8 À propos du test d appartenance de z à G............... 66 6.4 Conclusion..................................... 67 Chapitre 7. Un schéma de signature dans le modèle standard 7.1 Schéma de signature dans le modèle standard.................. 70 7.1.1 Introduction................................ 70 7.1.2 Sécurité prouvée et modèle standard................... 70 7.2 Survol des schémas de signature basés sur FlexibleRSA............. 71 7.2.1 Schéma de signature Gennaro-Halevi-Rabin............... 71 7.2.2 Schéma des signatures jumelles GHR................... 72 7.2.3 Schéma de signature Cramer-Shoup................... 73 7.2.4 Schéma de signature Camenisch-Lysyanskaya.............. 73 7.2.5 Schéma de signature Fischlin....................... 74 7.3 Un nouveau schéma de signature dans le modèle standard........... 74 7.3.1 Description................................. 74 7.3.2 Analyse de sécurité............................ 75 7.3.3 Comparaison avec les autres schémas.................. 77 7.3.4 Version en-ligne/hors-ligne........................ 79 7.4 Conclusion..................................... 81 Partie III. Schéma de chiffrement à sécurité prouvée Chapitre 8. Introduction aux schémas de chiffrement 8.1 Chiffrement à clé publique............................ 85 8.1.1 Définition.................................. 85 8.1.2 Notions de sécurité pour le chiffrement à clé publique......... 86 8.2 Quelques cryptosystèmes classiques....................... 88 8.2.1 Cryptosystème RSA............................ 88 8.2.2 Cryptosystème ElGamal.......................... 89 8.2.3 Cryptosystème Paillier........................... 89 8.3 Chiffrement basé sur l identité.......................... 90 8.3.1 Définition.................................. 90 x

8.3.2 Notions de sécurité pour le chiffrement basé sur l identité....... 91 8.3.3 Cryptosystème Boneh-Franklin...................... 91 8.4 Nos travaux sur les schémas de chiffrement................... 92 Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard 9.1 Le cryptosystème ElGamal............................. 94 9.1.1 Description du cryptosystème ElGamal................. 94 9.1.2 Le cryptosystème ElGamal avec fonction de hachage.......... 95 9.2 Chiffrement ElGamal sans encodage dans le modèle standard......... 95 9.2.1 La fonction Classe............................. 96 9.2.2 Problèmes de classe Diffie-Hellman.................... 97 9.2.3 Chiffrement additif sans encodage.................... 99 9.2.4 Chiffrement multiplicatif sans encodage................. 99 9.2.5 Propriétés de nos schémas de chiffrement................ 100 9.3 Preuve de sécurité de nos schémas........................ 100 9.4 Généralisation à Z p k................................ 102 9.5 Conclusion et problèmes ouverts......................... 102 Chapitre 10. Cryptographie basée sur l identité avec réduction fine 10.1 Deux schémas classiques de chiffrement basés sur l identité.......... 105 10.1.1 Schéma de Boneh-Franklin........................ 106 10.1.2 Schéma de Katz-Wang.......................... 106 10.2 Preuve fine pour un schéma basé sur l identité................. 108 10.2.1 Description du schéma.......................... 108 10.2.2 Étude de la sécurité de ce schéma.................... 109 10.2.3 Réduction aux problèmes classiques DBDH et GBDH......... 113 10.3 Comparaison des schémas............................. 114 10.4 Conclusion..................................... 114 Chapitre 11. Padding universel optimal 11.1 Notions préliminaires............................... 118 11.1.1 Redondance et entropie.......................... 118 11.1.2 Fonction de padding universel...................... 118 11.1.3 Signature et chiffrement.......................... 119 xi

Table des matières 11.1.4 Permutations sans griffe.......................... 119 11.2 Fonction de padding basée sur une permutation : OPbP............ 119 11.2.1 Description................................. 119 11.2.2 Analyse de sécurité............................ 120 11.2.3 Taille des paramètres et optimalité.................... 121 11.3 Construction basée sur OAEP3.......................... 122 11.3.1 Description................................. 122 11.3.2 Analyse de sécurité............................ 122 11.3.3 Taille des paramètres........................... 123 11.4 Conclusion..................................... 124 Partie IV. Résistance aux attaques à canaux cachés Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA 12.1 Introduction.................................... 129 12.2 Atomicité face aux attaques à canaux cachés.................. 130 12.2.1 Blocs atomiques.............................. 130 12.2.2 Illustration................................. 130 12.2.3 Méthodologie générale........................... 132 12.3 Atomicité et exponentiations........................... 133 12.3.1 Hypothèses de nos constructions..................... 133 12.3.2 Algorithmes génériques d exponentiation à fenêtre glissante...... 133 12.3.3 Algorithmes simplifiés........................... 134 12.4 Atomicité et courbes elliptiques......................... 135 12.4.1 Courbes elliptiques définies sur un corps premier............ 135 12.4.2 Courbes elliptiques définies sur un corps binaire............ 136 12.5 Version atomique de l exponentiation MIST................... 138 12.6 Conclusion..................................... 139 Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA 13.1 Exponentiation intrinsèquement aléatoire.................... 143 13.1.1 Algorithmes classiques d exponentiation................. 143 13.1.2 Principe général.............................. 143 13.2 Algorithmes basiques............................... 144 xii

13.2.1 Premier algorithme............................ 144 13.2.2 Second algorithme............................. 146 13.3 Algorithmes avancés................................ 147 13.3.1 Atomicité face aux attaques simples à canaux cachés......... 147 13.3.2 Réversibilité................................ 148 13.3.3 Optimisations supplémentaires...................... 150 13.3.4 Temps moyen............................... 151 13.4 Conclusion..................................... 151 Conclusion générale Bibliographie 157 Index 169 xiii

Table des matières xiv

Notations p, q Des nombres premiers n Un nombre composite (et typiquement un module RSA) N L ensemble des entiers strictement positifs QR n L ensemble des résidus quadratiques modulo n G, G p Des groupes g Le groupe engendré par g F p Un corps premier Z n L anneau des entiers modulo n Z n Le groupe multiplicatif de l anneau des entiers modulo n G Le nombre d éléments d un ensemble fini G L F, L G, L H Des listes x R X L élément x est tiré aléatoirement dans l ensemble X S Z E IBE Schéma sk pk params ID Un schéma de signature Un protocole d identification Un schéma de chiffrement Un schéma de chiffrement basé sur l identité Le nom d un schéma, le plus souvent d après le nom de ses inventeurs Une clé privée Une clé publique Des paramètres d un système Une identité O f(x) = O(g(x)) si (k, x 0 ), x > x 0, f(x) k g(x) e : G 1 G 2 G T Une fonction bilinéaire admissible F, G, H Des fonctions de hachage Ψ, ς Une fonction pseudo-aléatoire Ψ utilisant une clé ς [ ], [ ] k Des fonctions Classe DL g (y) Le logarithme de y en base g L opérateur ou-exclusif x, y Le nombre retrouvé par la combinaison par théorème des restes chinois de x et y φ La fonction indicatrice d Euler λ La fonction de Carmichael Φ pk, ψ sk Une permutation à sens unique à trappe Φ pk, dont l inverse est ψ sk xv

A, B Un attaquant, une réduction, un algorithme Succ Le succès d un attaquant, d une réduction Adv L avantage d un attaquant, d une réduction UBK, UF, EUF, seuf Des notions de sécurité pour les schémas de signature KOA, KMA, CMA Des ressources pour les attaquants des schémas de signature UBK, OW, IND, NM Des notions de sécurité pour les schémas de chiffrement CPA, CCA Des ressources pour les attaquants des schémas de chiffrement q s q h, q F, q G, q H q d q e Le nombre de requêtes autorisées à un oracle de signature Le nombre de requêtes autorisées à un oracle de hachage Le nombre de requêtes autorisées à un oracle de déchiffrement Le nombre de requêtes autorisées à un oracle d extraction de clé P 1 P 2 P 1 se réduit à P2, c est-à-dire que résoudre P 2 permet de résoudre P 1 P 1 P 2 P 1 et P 2 sont équivalents poly (l) Un polynôme en l DL DL x DL n CDH DDH CCDH DCDH CBDH, BDH GBDH DBDH LBDH RSA FlexibleRSA FACT Div Personne SPA DPA Le problème du logarithme discret Le problème du logarithme discret dans un groupe d ordre secret Le problème du logarithme discret modulo un module RSA n Le problème calculatoire Diffie-Hellman Le problème décisionnel Diffie-Hellman Le problème calculatoire de la Classe Diffie-Hellman Le problème décisionnel de la Classe Diffie-Hellman Le problème calculatoire Diffie-Hellman bilinéaire Le problème échelon Diffie-Hellman bilinéaire Le problème décisionnel Diffie-Hellman bilinéaire Le problème calculatoire Diffie-Hellman bilinéaire par liste Le problème de la racine e-ième Le problème souple de la racine e-ième Le problème de la factorisation de module RSA Le problème de casser l indivisibilité d une fonction de hachage Le nom d une personne Une attaque simple par canaux cachés Une attaque différentielle par canaux cachés xvi

Première partie Introduction générale 1

Chapitre 1 Introduction à la cryptologie Sommaire 1.1 La cryptologie en quelques mots....................... 3 1.1.1 Science du secret................................ 3 1.1.2 Cryptographie, cryptanalyse.......................... 4 1.1.3 Cryptographie symétrique et cryptographie asymétrique.......... 4 1.2 Buts de la cryptologie............................. 4 1.2.1 Confidentialité................................. 4 1.2.2 Intégrité..................................... 4 1.2.3 Identification.................................. 5 1.2.4 Authentification................................. 5 1.3 Fonctions de base en cryptologie...................... 5 1.3.1 Fonction à sens unique............................. 5 1.3.2 Fonction de hachage.............................. 5 1.3.3 Fonction pseudo-aléatoire........................... 5 1.3.4 Permutation à sens unique........................... 6 1.3.5 Fonction bilinéaire admissible......................... 6 1.3.6 Famille de fonctions.............................. 6 1.3.7 Fonction de padding.............................. 6 1.4 Notions de complexité............................. 7 1.4.1 Algorithme................................... 7 1.4.2 Algorithme polynomial ou sous-exponentiel................. 7 1.4.3 Complexité d un algorithme.......................... 7 1.4.4 Réduction d un problème à un autre..................... 7 1.5 Conclusion.................................... 8 Ce chapitre constitue une très courte introduction à la cryptologie. Il n est pas un cours sur le sujet, mais doit plutôt être vu comme un rapide survol de la cryptologie, et comme le moyen de poser certaines notations utilisées dans le reste de cette thèse. 1.1 La cryptologie en quelques mots 1.1.1 Science du secret La cryptologie est étymologiquement la science du secret. Ceci regroupe en fait de nombreuses notions. Historiquement, la cryptologie a servi à sécuriser certaines transmissions militaires, c est-à-dire à chiffrer des messages. Plus récemment, et notamment depuis l avènement de l ère 3

Chapitre 1. Introduction à la cryptologie numérique, la cryptologie a connu d autres usages, comme celui de la signature numérique ou de l identification des personnes. De façon la plus simplifiée possible, la cryptologie consiste en la manipulation de données variables, les messages et les identités, par des données constantes secrètes ou publiques, les clés, au travers d algorithmes, les schémas cryptographiques. 1.1.2 Cryptographie, cryptanalyse La cryptologie regroupe deux sciences duales et étroitement liées : la cryptographie, qui est la science de la construction de schémas cryptographiques, et la cryptanalyse, qui est la science de l étude des attaques sur ces schémas. Comme nous pouvons l imaginer, ces deux sciences ne vont pas l une sans l autre, et parfois, la frontière entre elles est ténue. Ainsi, par exemple, concevoir un schéma résistant à tel ou tel type d attaque, est-ce faire de la cryptographie ou de la cryptanalyse? 1.1.3 Cryptographie symétrique et cryptographie asymétrique Les schémas cryptographiques sont de nos jours de deux types. Le premier type est celui qui existe depuis le début de la cryptographie, dès les temps antiques. Dans cette famille de schémas, deux entités partagent une même clé, secrète pour les autres utilisateurs, et peuvent ainsi opérer des opérations symétriques chacune de leur coté, d où le nom de cryptographie à clé secrète ou cryptographie symétrique. Le second type de schémas cryptographiques est très récent, et a inauguré ce qui est parfois appelé l ère moderne de la cryptographie. Cette forme de cryptographie a été introduite par Whitfield Diffie et Martin Hellman, dans le célèbre New directions in cryptography [DH76]. Dans cette famille de schémas, deux clés coexistent, l une privée, c est-à-dire réservée à un utilisateur, et l autre publique, c est-à-dire connue de tous. Ce type de schéma est tel que, pour certaines opérations, comme le chiffrement, seule la clé publique est nécessaire, et que pour certaines autres opérations, comme le déchiffrement, la clé privée est indispensable. Ceci explique le nom de cryptographie à clé publique ou de cryptographie asymétrique. 1.2 Buts de la cryptologie Dans cette section, nous listons quelques-uns des principaux buts de la cryptologie, c est-àdire les services que la cryptologie délivre. Nous donnons également la ou les primitives usuellement utilisées pour atteindre chacun des buts cités. 1.2.1 Confidentialité Comme évoqué dans la section précédente, le but premier de la cryptologie a été la confidentialité, c est-à-dire l échange entre entités de messages chiffrés, qui, sans clé de déchiffrement, sont inintelligibles. La confidentialité est obtenue principalement au travers de schémas de chiffrement, qu ils soient à clé secrète ou à clé publique. 1.2.2 Intégrité Un autre but de la cryptologie est l intégrité. Ceci désigne le fait qu une personne veuille s assurer que le message reçu n a pas été modifié par une tierce personne. L intégrité est gérée 4

1.3. Fonctions de base en cryptologie au travers de fonctions de hachage à clé secrète (en anglais, message authentication code, MAC), ou à l aide de schémas de signature à clé publique. 1.2.3 Identification L identification est la partie de la cryptologie permettant de reconnaître une personne, au travers d un secret qu elle seule possède. Pour cela, la primitive cryptographique principale est le protocole d identification. Un sous-type, appelé protocole d identification à divulgation nulle de connaissance, est d un intérêt plus particulier : dans ce type de protocole, le prouveur montre qu il connaît un secret associé à une donnée publique, sans rien dévoiler de plus sur ce secret. 1.2.4 Authentification Un dernier but de la cryptologie est l authentification. Il s agit là pour une personne de prouver qu un message a bien été envoyé par elle. Cette notion est très proche de l identification, dans laquelle, en plus, un message interviendrait. L authentification se gère en cryptographie principalement au travers de schémas de signature à clé publique. L usage de schémas de signature à clé publique plutôt que de fonctions de hachage à clé secrète permet la non-répudiation, c est-à-dire qu une signature valide d un message donné ne puisse être contestée par le signataire. 1.3 Fonctions de base en cryptologie Dans cette section, nous allons donner une définition informelle des fonctions les plus importantes en cryptographie. 1.3.1 Fonction à sens unique Une fonction f est à sens unique s il est facile de calculer f(x) à partir de x, mais s il est difficile, étant donné g = f(x) pour un élément x aléatoire, de trouver un x tel que f(x) = g. Les fonctions à sens unique sont la base de nombreuses primitives, aussi bien en cryptographie à clé secrète qu en cryptographie à clé publique. Une fonction à sens unique f est dite à trappe si, à l aide d un secret, appelée la trappe, il est possible de calculer aisément un antécédent (appelé pré-image) de tout élément dans l image de f. 1.3.2 Fonction de hachage Une fonction de hachage est une fonction créant une empreinte appelée le haché de taille fixe (typiquement, 128, 160 ou 256 bits) d un message de taille arbitraire. Intuitivement, les fonctions de hachage doivent résister aux collisions, c est-à-dire qu il doit être difficile pour un algorithme de créer deux messages différents ayant le même haché. De même, les fonctions de hachage doivent être à sens unique, c est-à-dire qu étant donné un haché, il doit être difficile d en trouver une pré-image. 1.3.3 Fonction pseudo-aléatoire Une fonction est dite pseudo-aléatoire s il est difficile de distinguer une sortie de cette fonction d une valeur aléatoire. Plus précisément, si un adversaire a accès à un oracle lui retournant soit 5

Chapitre 1. Introduction à la cryptologie un aléa, soit le résultat de la fonction pseudo-aléatoire, son avantage à deviner la nature de l oracle doit être négligeable. 1.3.4 Permutation à sens unique Une fonction à sens unique f est une permutation à sens unique si elle est bijective d un ensemble fini sur lui-même. Une permutation à sens unique est dite à trappe si la fonction f 1 est efficacement calculable avec un secret, ladite trappe. C est notamment le cas de la fonction RSA (voir Section 4.4.1). 1.3.5 Fonction bilinéaire admissible Une fonction bilinéaire admissible est une application e : G 1 G 2 G T, où G 1, G 2 et G T sont trois groupes d ordre q (notés multiplicativement), telle que la fonction e soit : 1. bilinéaire : pour tout (u, v) G 1 G 2 et pour tout a, b Z q, e(u a, v b ) = e(u, v) ab ; 2. non-dégénérée : il existe un (u, v) G 1 G 2, tel que e(u, v) 1 ; 3. calculable : il existe un algorithme efficace pour calculer e(u, v) pour tous (u, v) G 1 G 2. Souvent, dans les constructions cryptographiques, les groupes G 1 et G 2 sont égaux. Notons enfin que les fonctions bilinéaires sont aussi appelées des couplages. 1.3.6 Famille de fonctions En cryptographie, comme l usage de clés est primordial, des familles de fonctions sont utilisées, plutôt que des fonctions fixes. L indice de la fonction choisie dans cette famille constitue alors la clé. Ainsi apparaissent les familles de fonctions de hachage, les familles de fonctions pseudo-aléatoires, les familles de permutations à sens unique à trappe, etc. 1.3.7 Fonction de padding Pour certaines constructions, comme nous le verrons dans la suite, il est parfois nécessaire d utiliser des fonctions de padding. Ces fonctions assurent, comme les fonctions de hachage, une résistance à la malléabilité, mais sont, contrairement à ces dernières, inversibles. De façon générique, soient un ensemble de messages M, un ensemble d aléas R, et un ensemble d arrivée T. Une fonction de padding est une fonction injective µ : M R T, telle qu il existe une fonction µ 1 : T M { } qui soit publiquement calculable et qui retourne µ 1 (t) = m si t = µ(m, r) et si aucun antécédent n existe. Une fonction de padding est dite déterministe si l ensemble des aléas R est vide ou réduit à un élément. Elle est dite probabiliste dans le cas contraire. Les fonctions de paddings probabilistes classiques µ sont souvent telles qu il existe une fonction inverse complète µ 1, telle que µ 1 : T (M R) { } soit publiquement calculable et qui retourne µ 1 (t) = (m, r) si t = µ(m, r) et si aucun antécédent n existe La mention admissible sera sous-entendue dans le reste de ce document. Exceptionnellement, nous préférerons dans cette thèse la dénomination anglaise plutôt que sa terminologie française : fonction de bourrage voire fonction de remplissage. 6

1.4. Notions de complexité 1.4 Notions de complexité Enfin, cette dernière partie contient certaines notions primordiales de la théorie de la complexité. 1.4.1 Algorithme Un algorithme est un ensemble d instructions qui permettent le calcul d une valeur de sortie, pour des données d entrée dans un certain ensemble. C est une notion très générique, et pour s en donner une autre idée, il est possible de considérer qu un algorithme est une sorte de programme informatique, permettant l exécution d une tâche le calcul d une certaine valeur de sortie définie par des paramètres d entrée. Chaque algorithme est caractérisé par un temps d exécution, calculé comme le nombre d étapes élémentaires dont il a besoin pour calculer la sortie. Comme ce temps peut dépendre des données d entrée et d aléas internes, le temps d exécution moyen et le temps d exécution maximal sont distingués. Certains algorithmes retournent, pour une même entrée, toujours la même sortie : ils sont dits déterministes. Au contraire, un algorithme ne retournant pas toujours la même valeur, pour une entrée inchangée, est dit probabiliste. 1.4.2 Algorithme polynomial ou sous-exponentiel Un algorithme est dit polynomial si son temps d exécution τ(l), pour des entrées de taille l, est majoré par un polynôme P en l, c est-à-dire τ(l) P (l). Ceci est noté τ = poly (l). Les algorithmes polynomiaux sont les algorithmes qui sont considérés efficaces, que ce soit en cryptologie ou en mathématique en général. Deux algorithmes polynomiaux peuvent être comparés, et l un dit plus efficace que l autre, en comparant les degrés et les coefficients des polynômes. Un algorithme non-polynomial est dit sous-exponentiel si, pour des entrées de taille l, son temps d exécution τ(l) peut être majoré par exp(f(l)), où f(l) est une fonction telle que f(l) = o(l). 1.4.3 Complexité d un algorithme Certains algorithmes ne retournent pas toujours la/une valeur valide. Nous définissons alors la probabilité de succès. Par extension, un algorithme retournant toujours une valeur correcte est dit avoir une probabilité de succès de 1. Ainsi, pour mesurer l efficacité d un algorithme probabiliste, il faut envisager à la fois son temps d exécution et sa probabilité de succès. La notion de complexité est alors utilisée : exprimée en bits, elle correspond au logarithme, en base 2, du temps d exécution moyen divisé par la probabilité de succès. La complexité correspond au temps moyen nécessaire pour obtenir une réponse valide. Par conséquent, pour un niveau de sécurité désiré κ, il est dit qu un schéma est κ-sûr s il n existe pas d algorithme de complexité inférieure ou égale à κ qui attaque une de ses propriétés de sécurité. 1.4.4 Réduction d un problème à un autre En théorie de la complexité, il est dit qu un problème P 1 se réduit à un problème P 2, s il est possible de résoudre, en temps polynomial, P 1 à l aide d un oracle résolvant P 2. Ceci est noté 7

Chapitre 1. Introduction à la cryptologie P 1 P 2. De même, il est dit que deux problèmes P 1 et P 2 sont équivalents si P 1 se réduit à P 2 et P 2 se réduit à P 1. Ceci est noté P 1 P 2. 1.5 Conclusion Nous terminons ce chapitre en rappelant que, dans celui-ci, seules certaines notions élémentaires ont été abordées. Nous encourageons le lecteur à se tourner vers des ouvrages généraux de cryptologie pour plus d informations sur les bases de la cryptographie [MOV97, Sti95], et passons, chapitre suivant, à la notion de sécurité prouvée, avant d entrer dans les Parties II, III ou IV dans le détail de nos recherches. 8

Chapitre 2 Sécurité prouvée et cryptologie Sommaire 2.1 Réduction de sécurité et sécurité prouvée................. 9 2.1.1 Réduction de sécurité et sécurité prouvée................... 9 2.1.2 Finesses des réductions de sécurité...................... 10 2.1.3 Modèle de sécurité............................... 10 2.1.4 Modèle standard, modèle de l oracle aléatoire................ 10 2.2 Problèmes cryptographiques difficiles.................... 11 2.2.1 Problèmes cryptographiques difficiles basés sur la factorisation....... 11 2.2.2 Problèmes cryptographiques difficiles basés sur le logarithme discret... 12 2.2.3 Problèmes cryptographiques difficiles avec fonction bilinéaire........ 13 2.3 Conclusion.................................... 14 Dans ce chapitre, nous introduisons les bases de la sécurité prouvée appliquée à la cryptologie. Nous ne serons pas exhaustifs sur ce sujet, et renvoyons ainsi le lecteur à des ouvrages plus complets pour une vue plus détaillée de ce large sujet. 2.1 Réduction de sécurité et sécurité prouvée 2.1.1 Réduction de sécurité et sécurité prouvée De façon informelle, la sécurité des schémas cryptographiques est prouvée en montrant que si un adversaire peut violer une propriété de sécurité, alors il peut être utilisé pour résoudre un problème algorithmique difficile la nature même de ces problèmes étant détaillée dans la Section 2.2. Pour cela, un algorithme (la réduction) est construit ; il simule l environnement de l attaquant, et à l aide d un ou plusieurs appels à l attaquant, retrouve la solution au problème. Comme les problèmes sont choisis difficiles (ou plus précisément sont supposés difficiles, dans l état actuel des connaissances), il est possible d en déduire par contraposée qu un tel adversaire n existe pas. Cette méthodologie pour s assurer de la sécurité d un schéma est appelée la sécurité prouvée. Certains, comme Neal Koblitz et Alfred Menezes dans [KM04], préfèrent parler de sécurité par réduction, pour bien mettre en avant que la sécurité n est pas absolue, mais n est valide que si l hypothèse de difficulté du problème sous-jacent est vérifiée. 9

Chapitre 2. Sécurité prouvée et cryptologie 2.1.2 Finesses des réductions de sécurité La qualité d une réduction de sécurité est mesurée en comparant la complexité de la réduction et la complexité de l attaque contre le schéma cryptographique prouvé par la réduction. Une réduction de sécurité est ainsi dite fine (en anglais, tight) quand le rapport entre ces complexités est proche de 1. Au contraire, la réduction est dite lâche (en anglais, loose) lorsque la complexité de la réduction est bien supérieure à la complexité de l attaque. La finesse d une réduction est souvent relative : nous parlons alors de réduction plus fine qu une autre. Cette notion de finesse permet de distinguer la sécurité asymptotique et la sécurité exacte : la première permettant de dire qu un schéma est sûr pour des clés assez grandes, alors que la seconde permet de donner des tailles de clés effectives pour lesquelles le schéma est κ-sûr, pour un niveau de sécurité κ fixé. 2.1.3 Modèle de sécurité Comme défini dans la section précédente, une réduction doit utiliser un adversaire violant une propriété de sécurité du schéma considéré. Une réduction est donc dépendante des attaquants considérés. Aussi, une partie de la sécurité prouvée consiste à définir un modèle de sécurité (encore appelé scénario d attaque) : ce modèle comprend tout d abord la définition des propriétés de sécurité désirées du schéma et ainsi, des buts d un éventuel attaquant contre ces propriétés ; ensuite, le modèle comprend la définition de l environnement de l attaquant, c est-à-dire les ressources auxquelles ce dernier aura droit. Ces modèles dépendent du type de schéma considéré (schéma de signature ou de chiffrement par exemple), et seront donc détaillés dans les parties spécifiques II et III, pour les primitives de signature et de chiffrement, respectivement. 2.1.4 Modèle standard, modèle de l oracle aléatoire Une étape importante dans l avancée de la sécurité prouvée en cryptographie est due à Mihir Bellare et Phillip Rogaway [BR93], avec la formalisation du modèle de l oracle aléatoire. Notons que les prémices de ce modèle étaient apparus dans la publication [FS86] d Amos Fiat et d Adi Shamir. Dans le modèle de l oracle aléatoire, les fonctions de hachage sont supposés parfaites, c est-àdire qu il est considéré que l attaquant ne peut faire des calculs de hachés qu à travers des appels à un oracle de hachage. Tout l intérêt de ce modèle consiste alors à profiter de ces oracles dans la construction de la réduction. En les définissant d une certaine façon (qui doit malgré tout rester indistinguable d une fonction parfaitement aléatoire), la réduction peut plus aisément soit simuler l environnement de l attaquant, soit déduire de l attaque de l adversaire la solution à son problème. Nous ne rentrerons pas plus dans les détails de la définition du modèle de l oracle aléatoire, mais renvoyons le lecteur à certaines parties (par exemple la Section 4.5 ou les Chapitres 5, 6, 10 ou 11) de cette thèse pour en voir tout l intérêt. Le modèle de l oracle aléatoire est si puissant qu il fut longtemps la seule façon de prouver la sécurité de schémas efficaces. Pourtant, assez récemment (voir Chapitre 7 pour les schémas de signature, ou le schéma de chiffrement [CS98]), de nouveaux schémas ont été proposés, avec une preuve ne nécessitant pas l idéalisation des fonctions de hachage. Dans ce cas, l appellation de modèle standard est utilisée, bien que le qualificatif sans oracles aléatoires soit parfois préféré. Nous précisons ici que des schémas basés sur les arbres furent prouvés sûrs sans ce modèle dès 1988 [GMR88, DN94, CD96, CG05]. Malheureusement, ils souffrent d une certaine inefficacité. 10

2.2. Problèmes cryptographiques difficiles Lors de la comparaison de schémas à sécurité prouvée, il faut bien avoir à l esprit que le modèle de l oracle aléatoire est un modèle idéalisé, dans lequel les fonctions de hachage sont parfaites. Avoir une preuve sans oracles aléatoires est un meilleur gage de sécurité, même si aucun schéma non-pathologique prouvé dans le modèle de l oracle aléatoire n a été cassé jusqu ici. Un avantage néanmoins du modèle de l oracle aléatoire est qu il permet des preuves relativement simples (et donc aisément vérifiables) de schémas très pratiques, alors que la sécurité de schémas dans le modèle standard est établie parfois au dépens de la simplicité. 2.2 Problèmes cryptographiques difficiles Comme nous l avons précédemment évoqué, la cryptographie à clé publique est basée sur la notion de problème supposé difficile. Par définition, un problème sera dit difficile s il n existe pas d algorithme connu polynomial pour le résoudre. Ainsi, comme nous pouvons le voir, un problème est dit difficile ou non suivant les connaissances scientifiques, à un moment donné. Autrement dit, l évolution des savoirs pourrait éventuellement changer la nature de certains problèmes. Dans cette section, nous rappelons quelques-uns des principaux problèmes difficiles utilisés en cryptographie et que nous appellerons problèmes cryptographiques. 2.2.1 Problèmes cryptographiques difficiles basés sur la factorisation La première famille de problèmes cryptographiques est celle des problèmes basés sur la factorisation des entiers. Factoriser un nombre consiste à l écrire sous forme d un produit de nombres premiers. C est un des problèmes calculatoires qui ont été étudiés depuis le plus longtemps, mais, à ce jour, aucun algorithme polynomial pour le résoudre n est connu. Cette famille a été utilisée de façon révolutionnaire dans [RSA78] par Ronald Rivest, Adi Shamir et Leonard Adleman pour donner naissance aux premiers schémas de signature et de chiffrement à clé publique (voir Sections 4.4.1 et 8.2.1). Définissons tout d abord ce qu est un module RSA, ainsi qu un sous-type de ces modules, les modules RSA forts (en anglais, safe modulus). Définition 1 (Module RSA). Un module RSA de taille l n est un entier n = pq de l n bits, pour deux premiers distincts p et q. Avant de définir ce qu est un module RSA fort, rappelons qu un premier p est fort si p 1 2 est également premier. Définition 2 (Module RSA fort). Un module RSA fort de taille l n est un entier n = pq de l n bits, pour deux premiers forts distincts p et q. Nous considérons maintenant le problème de la factorisation appliqué aux modules RSA. Définition 3 (Factorisation FACT). Soient n un module RSA. Le problème de la factorisation (sous-entendu, des modules RSA) est de décomposer n en un produit de deux facteurs premiers. Le problème RSA, sur lequel sont basés de nombreux schémas de chiffrement ou de signature, se définit alors comme suit [RSA78]. C est-à-dire qui n a pas été créé de façon artificielle pour montrer une faiblesse du modèle de l oracle aléatoire. 11

Chapitre 2. Sécurité prouvée et cryptologie Définition 4 (Racine e-ième RSA). Soient n un module RSA, y Z n, et e 3 un entier premier avec φ(n). Le problème de la racine e-ième est de trouver x Z n, tel que y = x e mod n. Enfin, un troisième problème de cette famille a été introduit [BP97, FO97]. Définition 5 (Problème souple RSA FlexibleRSA). Étant donné un module RSA fort n et un élément y Z n, le problème FlexibleRSA est de trouver un x Z n et un entier e > 1 tels que y = x e mod n. De façon claire, nous avons de simples réductions entre ces problèmes : FlexibleRSA RSA FACT. Chacun de ces problèmes est supposé difficile, pour des modules équilibrés, c est-à-dire pour lesquels les tailles de p et de q sont à peu près équivalentes. Plus précisément, il est conjecturé qu il n existe pas d attaquant qui puisse résoudre un de ces problèmes avec une probabilité non négligeable, en un temps polynomial. Ces hypothèses sont appelées respectivement l hypothèse de difficulté de la factorisation, l hypothèse RSA et l hypothèse RSA forte. 2.2.2 Problèmes cryptographiques difficiles basés sur le logarithme discret La seconde famille de problèmes cryptographiques est celle des problèmes basés sur le logarithme discret. C est la famille qui a servi aux premières constructions cryptographiques à clé publique, puisque c est sur cette base que Whitfield Diffie et Martin Hellman ont construit l échange de clé Diffie-Hellman [DH76]. Dans cette section, les groupes sont considérés cycliques et leur loi est notée multiplicativement. Définition 6 (Logarithme discret - DL). Soient g un générateur d un groupe G d ordre q, et y un élément du groupe G. Le problème du logarithme discret dans G est de trouver x Z q, tel que g x = y. La valeur x ainsi obtenue est appelée le logarithme discret de y en base g et est notée DL g (y). Un sous-problème fut introduit plus tard, grâce à l invention par Taher ElGamal [ElG85] du premier cryptosystème basé sur le logarithme discret (voir Section 8.2.2). Définition 7 (Problème calculatoire Diffie-Hellman - CDH). Soit g un générateur d un groupe G d ordre q. Le problème calculatoire Diffie-Hellman dans G est de calculer g ab à partir de (g, g a, g b ), pour des aléas a et b tirés dans Z q. La version décisionnelle de ce problème est définie ci-dessous. Définition 8 (Problème décisionnel Diffie-Hellman - DDH). Soit g un générateur d un groupe G d ordre q. Le problème décisionnel Diffie-Hellman dans G est de distinguer les distributions (g, g a, g b, g ab ) et (g, g a, g b, g c ), pour des aléas a, b et c tirés dans Z q. L hypothèse RSA forte stipule que le problème FlexibleRSA est difficile. Cette dénomination sera préférée à hypothèse FlexibleRSA, pour bien préciser que ce qui est conjecturé est plus fort. 12

2.2. Problèmes cryptographiques difficiles Nous avons de simples réductions entre ces problèmes : DDH CDH DL. Chacun de ces problèmes est supposé difficile, pour des groupes G bien choisis, tels que les sous-groupes de Z p d ordre q, pour un grand premier p et un grand premier q divisant (p 1), ou encore les points d une courbe elliptique [Mil85, Kob87]. Il est ainsi conjecturé qu il n existe pas d attaquant qui puisse résoudre un de ces problèmes avec une probabilité non négligeable, en un temps polynomial. Ces hypothèses sont appelées respectivement l hypothèse de difficulté du logarithme discret, l hypothèse Diffie-Hellman et l hypothèse décisionnelle Diffie-Hellman. Un dernier problème, à la frontière entre les problèmes basés sur le logarithme discret et les problèmes basés sur la factorisation, est apparu, depuis son utilisation par Marc Girault dans [Gir90]. Définition 9 (Logarithme discret dans un groupe d ordre secret - DL x ). Soient g un générateur d un groupe d ordre secret G et y un élément de G. Le problème du logarithme discret dans le groupe d ordre secret G est de trouver x, tel que g x = y. Tout particulièrement, les groupes d ordre secret peuvent être les sous-groupes de Z n, pour un module RSA n. Nous notons le problème correspondant DL n. Nous avons alors une réduction supplémentaire : FACT DL n. En effet, si un algorithme A peut résoudre DL n pour un module n, il est possible de l utiliser pour factoriser un module RSA n de l n bits. Pour cela, il suffit de prendre g Z n et r {0, 1} ln+80, puis de calculer y = g r mod n. En donnant (g, y, n) à l algorithme A, celui-ci retourne r tel que y = g r mod n. Or, dans y, seule l information r modulo l ordre de g peut être accessible à l attaquant, et donc, sauf une probabilité plus petite que 2 80, r r. Dans ce cas, r r est un multiple non-nul de l ordre de g. En renouvelant cette procédure plusieurs fois, et en utilisant l algorithme de Garry Miller [Mil76], la factorisation de n est alors déduite. 2.2.3 Problèmes cryptographiques difficiles avec fonction bilinéaire La troisième et dernière famille de problèmes cryptographiques dont nous parlerons dans cette thèse est celle des problèmes basés sur l utilisation de fonctions bilinéaires (voir Section 1.3.5). C est la famille de problèmes qui a permis l invention des premiers cryptosystèmes basés sur l identité [BF01, BF03] par Dan Boneh et Matthew Franklin (voir Section 8.3.3). Dans cette section encore, les groupes sont considérés cycliques et leur loi est notée multiplicativement. Les problèmes les plus immédiats, lorsque les fonctions bilinéaires sont considérées, sont les suivants [Jou00, BF01]. Définition 10 (Problème calculatoire Diffie-Hellman bilinéaire - CBDH). Soient G 1 et G T deux groupes d ordre q, une application bilinéaire e : G 1 G 1 G T et un générateur g de G 1. Le problème calculatoire Diffie-Hellman bilinéaire est de calculer e(g, g) abc à partir de (g, g a, g b, g c ), pour des aléas a, b et c tirés dans Z q. La version décisionnelle de ce problème est définie ci-dessous. 13

Chapitre 2. Sécurité prouvée et cryptologie Définition 11 (Problème décisionnel Diffie-Hellman bilinéaire - DBDH). Soient G 1 et G T deux groupes d ordre q, une application bilinéaire e : G 1 G 1 G T et un générateur g de G 1. Le problème décisionnel Diffie-Hellman bilinéaire est de distinguer les distributions (g, g a, g b, g c, e(g, g) abc ) et (g, g a, g b, g c, e(g, g) d ), pour des aléas a, b, c et d tirés dans Z q. Il existe également un problème échelon entre les versions décisionnelles et calculatoires (en anglais, un problème gap [OP01b]). Définition 12 (Problème échelon Diffie-Hellman bilinéaire - GBDH). Soient G 1 et G T deux groupes d ordre q, une application bilinéaire e : G 1 G 1 G T et un générateur g de G 1. Le problème échelon Diffie-Hellman bilinéaire est de calculer e(g, g) abc, à partir de (g, g a, g b, g c ) et d un accès à un oracle résolvant le problème DBDH, pour des aléas a, b et c tirés dans Z q. Nous avons de simples réductions entre ces problèmes : DBDH CBDH DL G1 et GBDH CBDH DL G1. Enfin, nous définissons ci-dessous un problème qui simplifiera certaines de nos preuves dans la suite de cette thèse. Définition 13 (Problème calculatoire Diffie-Hellman bilinéaire par liste - LBDH). Soient G 1 et G T deux groupes d ordre q, une application bilinéaire e : G 1 G 1 G T et un générateur g de G 1. Le problème calculatoire Diffie-Hellman bilinéaire par liste de taille l est de calculer, à partir de (g, g a, g b, g c ), une liste L, telle qu un des éléments de cette liste soit e(g, g) abc, pour des aléas a, b et c tirés dans Z q. Ce dernier problème est équivalent aux problèmes DBDH et GBDH, comme nous le montrerons Section 10.2.3. 2.3 Conclusion Dans cette partie, nous avons rappelé certaines notions de base de la sécurité prouvée. Nous avons insisté notamment sur les notions de réduction, de modèle de sécurité, de modèle de l oracle aléatoire et de modèle standard. Nous avons également listé quelques-uns des problèmes cryptographiques les plus importants. 14

Chapitre 3 Résumé de nos travaux Dans ce chapitre, nous énumérons l ensemble de nos travaux de thèse, dans l ordre chronologique de leur publication. Nous détaillons d avantage les publications que nous n avons pas incluses dans ce mémoire, par souci d unité de sujet. Multiplication double-taille à base de multiplieurs Euclidiens Les dispositifs cryptographiques (comme les cartes à puce) possèdent parfois, pour accélérer les algorithmes à clé publique, des coprocesseurs cryptographiques. Ceux-ci permettent entre autres d effectuer des opérations modulaires sur des nombres de n bits. Malheureusement, la taille des clés utilisées augmente souvent plus vite que la taille de ces coprocesseurs hardware. Aussi, le développeur se retrouve face au problème d émuler une multiplication modulaire de 2n-bits, à l aide de multiplications modulaires n-bits. Ce problème s appelle le doublement de taille (en anglais, size-doubling). Une nouvelle technique de doublement de taille fut introduite à Ches 02 par Wieland Fischer et Jean-Pierre Seifert. Leur technique utilise ce qui est appelé un multiplieur Euclidien, qui calcule le quotient et le reste d une multiplication modulaire, c est-à-dire qui retourne, pour une entrée (x, y, z), à la fois xy/z et xy mod z. Pour être le plus générique possible, Wieland Fischer et Jean-Pierre Seifert montrent comment simuler une multiplication Euclidienne à l aide de deux multiplications modulaires simples. Dans une publication de Ches 03 [CJP03], avec Marc Joye et Pascal Paillier, nous améliorons les algorithmes de Wieland Fischer et Jean-Pierre Seifert, en proposant des stratégies plus avancées qui minimisent le nombre d appels aux opérations élémentaires, offrant ainsi un gain en vitesse pouvant aller jusqu à 57%. De plus, dans le cas où les multiplications Euclidiennes sont elles-mêmes émulées au moyen de multiplications modulaires simples, nous proposons de nouveaux algorithmes qui améliorent les solutions originales de Wieland Fischer et Jean-Pierre Seifert d un facteur pouvant atteindre 71%. Exponentiation intrinsèquement protégée contre la DPA Chapitre 13 En 1999, Paul Kocher, Joshua Jaffe et Benjamin Jun ont introduit les attaques différentielles par analyse de signaux cachés (comme la consommation de courant ou les rayonnements électromagnétiques), attaques notées DPA pour l acronyme anglais Differential Power Analysis. Heureusement, il est possible de se protéger de ce type d attaque, grâce à la construction de hardware sécurisé ou grâce à la sécurisation software des algorithmes cryptographiques. Bien souvent, c est l utilisation conjointe de ces deux méthodes qui est la plus efficace. Une règle générale pour prévenir les attaques différentielles est de rendre les valeurs internes de l algorithme le plus aléatoire possible. 15

Chapitre 3. Résumé de nos travaux Dans le cas du schéma RSA, il y a ainsi deux façons de rendre aléatoire le calcul de y = x d mod n. Il est possible : 1. de rendre aléatoires les entrées avant l algorithme d exponentiation ; par exemple, en utilisant (a) ˆx x + r 1 n pour un aléa r 1 de k bits (b) ˆd d + r 2 φ(n) pour un aléa r 2 de k bits et en évaluant alors y comme y = ŷ mod n, avec ŷ = ˆx ˆd mod 2 k n ; 2. de rendre aléatoire l algorithme d exponentiation lui-même. La première approche présente l avantage d être indépendante de la méthode d exponentiation. Malheureusement, un tel masquage de l exposant d est limité aux mises en œuvre du RSA basées sur le théorème des restes chinois (CRT), comme l ordre du groupe φ(n) est habituellement inconnu lors d une exponentiation privée en mode standard (c est-à-dire sans CRT). Le meilleur exemple de la seconde approche est sans doute l algorithme MIST, proposé par Colin Walter. MIST a été conçu pour générer aléatoirement une chaîne de division correspondant à l exposant d, de façon à calculer x d mod n de façon aléatoire. Un autre exemple est une version améliorée de l algorithme à fenêtre glissante due à Kouichi Itoh, Jun Yajima, Masahiko Takenaka et Naoya Torii. La seconde approche permet de rendre aléatoire l algorithme d exponentiation sans la connaissance de φ(n), mais nécessite, pour nos exemples, un algorithme de division sûr contre les attaques à canaux cachés ou un algorithme d exponentiation plus complexe. Dans une publication de Ct-rsa 04 [Che04] nous introduisons une nouvelle méthode pour rendre aléatoire une exponentiation, dans le but de se prémunir des attaques différentielles, combinant les avantages des deux approches. Comme dans la première approche, notre méthode ne requiert pas une méthode d exponentiation particulière. Comme dans la seconde approche, c est l algorithme lui-même qui est la source de l exécution aléatoire (en particulier, notre méthode ne nécessite pas la connaissance préalable de l ordre du groupe φ(n)). L atomicité : une solution générique et peu coûteuse contre la SPA Chapitre 12 En 1996, Paul Kocher décrivit les attaques par mesure de temps et leur généralisation, les attaques simples par analyse de signaux cachés (comme la consommation de courant ou les rayonnements électromagnétiques), notées SPA pour l acronyme anglais Simple Power Analysis. Une façon de se protéger de ce type d attaques a fait l objet d une publication dans le journal IEEE Transactions on Computers, 53 [CCJ04], co-écrite avec Mathieu Ciet et Marc Joye. Dans ce papier, nous introduisons de nouvelles méthodes, efficaces et simples, pour transformer un algorithme cryptographique en un algorithme équivalent résistant aux attaques simples par canaux cachés. Contrairement aux solutions précédemment connues, la technique proposée ne se fait pas au détriment du temps d exécution. De plus, notre technique est générique, et peut ainsi s appliquer à toutes sortes d algorithmes. En guise d application, nous proposons plusieurs nouvelles routines d exponentiation : un algorithme binaire d exponentiation gauche-droite, son équivalent droite-gauche, et plusieurs algorithmes à fenêtre glissante. Nous illustrons également notre méthodologie dans le cadre de la multiplication scalaire de points sur les courbes elliptiques. Tous les algorithmes présentés ont en commun d avoir une complexité approximativement égale à leur mise en œuvre non sécurisée. 16

Comment externaliser un programme? Dans une publication de Ches 04 [CNPP04], avec David Naccache, Pascal Paillier et David Pointcheval, nous présentons un nouveau type d objet sécurisé, appelé le microprocesseur externalisé (XµP). Le XµP se différencie des cartes à puces ou des autres dispositifs cryptographiques en ne contenant aucune mémoire ROM (en anglais, read-only memory). Ainsi, le code que le XµP exécute lui est donné par l extérieur (un ordinateur appelé le terminal), qui, potentiellement, est malveillant ou corrompu. Bien qu exporter tout le code exécutable d un objet sécurisé dans un terminal pose de vastes problèmes de sécurité, les avantages d un produit sans ROM sont nombreux : le temps de masquage des puces disparaît, la correction des erreurs software (les bugs) est ramenée à une simple modification des codes stockés dans les terminaux, et ne nécessite donc plus de coûteux retraits de produits sur le terrain. Encore mieux, la taille de code cesse d être un facteur limitant. Ceci est particulièrement significatif, étant donné la tendance actuelle des systèmes d exploitation à se complexifier. Nous introduisons une architecture pour le XµP, basée sur un système à clé publique de type RSA. Le surplus de communication entre le terminal et la carte dû à la sécurisation du protocole est assez faible. Nous proposons deux protocoles permettant l exécution et l authentification dynamique des programmes, exposons un modèle de sécurité pour ces protocoles et prouvons leur sécurité sous des hypothèses appropriées. Une heuristique pour dériver des schémas de signature à réduction fine Chapitre 5 Les schémas basés sur le logarithme discret sont très appréciés, notamment car ils permettent l utilisation de coupons. Il est possible de prouver la sécurité de la plupart d entre eux, dans le modèle de l oracle aléatoire, en utilisant le lemme de bifurcation de David Pointcheval et Jacques Stern. Malheureusement, la réduction de sécurité est alors lâche. Au contraire, des schémas basés sur la factorisation, tels que RSA-PSS, permettent une réduction de sécurité fine, toujours dans le modèle de l oracle aléatoire. Cependant, dans ces schémas, il n existe pas de moyen d utiliser des coupons. Dans une publication à la conférence Acns 05 [Che05b], nous proposons une heuristique utilisant un protocole d identification à trois passes à divulgation nulle de connaissance et un schéma de signature vérifiant certaines propriétés de sécurité. Avec ces composantes, notre transformation permet d obtenir un schéma de signature à coupons, avec une réduction de sécurité fine, dans le modèle de l oracle aléatoire. Plus précisément, si ses deux composantes sont sûres, notre schéma de signature l est aussi. En application, nous proposons un schéma de signature à coupons avec une réduction fine au problème RSA. Notre schéma se compare très bien à RSA-PSS, comme il possède une réduction aussi fine tout en apportant en plus l usage de coupons pour de meilleures performances en-ligne. Padding universel optimal Chapitre 11 Lorsque la sécurité des schémas de chiffrement est considérée, l indistinguabilité lors d attaques à chiffrés choisis est la notion requise. De même, pour la sécurité des schémas de signature, la résistance aux falsifications existentielles sous attaques à messages choisis est indispensable. Pourtant, la sécurité n est pas la seule notion importante pour les schémas cryptographiques : toute bonne primitive se devrait d être rapide, avec une bande passante efficace, compacte en code et simple d utilisation. Le masquage est une étape assez longue et assez coûteuse de la fabrication des cartes à puces. 17

Chapitre 3. Résumé de nos travaux Les deux premiers critères sont habituellement les plus prisés, et ont fait l objet de nombreuses publications. Ainsi, après le travail fondateur de Mihir Bellare et Phillip Rogaway, la rapidité et la bande passante des schémas de signature ou de chiffrement ont été étudié à travers la conception de nombreuses fonctions de padding. À Crypto 02, Jean-Sébastien Coron, Marc Joye, David Naccache et Pascal Paillier ont introduit les paddings universels. Ce nouveau type de padding simplifie au maximum l utilisation, puisque les paddings universels peuvent être communément utilisés avec les primitives de chiffrement ou de signature. La première instance d un tel padding fut proposée par ces auteurs à l aide d une variante de PSS, appelée PSS-ES. Depuis, d autres solutions ont vu le jour, et notamment celle de Yuichi Komano et Kazuo Ohta, basée sur OAEP. Dans un papier de la conférence Acns 05 [CPP05], avec Duong Hieu Phan et David Pointcheval, nous jetons un nouveau regard sur la notion de padding universel, en essayant d optimiser tous les critères en même temps. Ceci poursuit une idée qui permet de construire des schémas de chiffrement sûrs basés sur des paddings sans redondance. Pour optimiser les critères précédemment évoqués, les paddings que nous proposons sont simples, sans redondance pour le chiffrement et déterministes pour la signature. Nos propositions sont très simples d utilisation, car nous prouvons que l utilisateur peut n utiliser qu une seule paire de clés pour le chiffrement et la signature. Plus précisément, nous étudions deux fonctions de paddings universels. La première est construite à l aide d une permutation sur tout le domaine, étudiée précédemment par Louis Gramboulan pour une utilisation dans le cadre des schémas de signature et par Duong Hieu Phan et David Pointcheval pour le chiffrement. Cette proposition peut être prouvée optimale en terme de bande passante, dans le modèle de la permutation aléatoire, et a donc été nommée en anglais, Optimal Permutation-based Padding (OPbP). Notre deuxième proposition est basée sur l utilisation de la fonction de padding OAEP3, et sa sécurité est prouvée dans un modèle moins fort, le modèle de l oracle aléatoire. Un schéma de signature efficace basé sur le CDH Chapitre 6 Lors de la conférence Eurocrypt 03, Eu-Jin Goh et Stanislaw Jarecki ont montré que, contrairement aux autres schémas de signature basés sur le logarithme discret, le schéma de signature EDL avait une réduction de sécurité fine au problème calculatoire Diffie-Hellman (CDH), dans le modèle de l oracle aléatoire. Ces auteurs ont également remarqué que le schéma de signature EDL pouvait être transformé en un schéma de signature à coupons, en utilisant la technique générique d Adi Shamir et Yael Tauman, technique basée sur les fonctions de hachage caméléon. Dans une publication de la conférence Crypto 05 [Che05a], nous proposons un nouveau schéma de signature qui présente également une réduction de sécurité fine au problème CDH, mais pour lequel les signatures produites sont plus courtes que celles d EDL. De plus, de façon similaire au schéma de signature Schnorr (mais contrairement à EDL), le schéma proposé permet l utilisation de coupons de façon extrêmement naturelle, sans calculs supplémentaires et sans que l algorithme de vérification ne soit modifié. Dans le cas des courbes elliptiques, notre schéma améliore de 25% l état de l art des schémas de signature basés sur le logarithme discret, tout en gardant le même niveau de sécurité. Chiffrement ElGamal sans encodage dans le modèle standard Chapitre 9 Le chiffrement ElGamal est l alternative la plus courante au chiffrement RSA. Il est facilement adaptable à de nombreux groupes cryptographiques et possède des propriétés homomorphiques, tout en restant sûr (au sens des attaques à clairs choisis) sous l hypothèse de difficulté du problème DDH dans le groupe choisi. 18

Malheureusement, l usage en pratique du chiffrement ElGamal est complexe : les messages doivent être encodés en éléments du groupe avant le chiffrement proprement dit, ce qui requiert des conversions incommodes, limite la taille des messages et peut même détruire les propriétés homomorphiques du schéma. En utilisant des fonctions de hachage, il est certes possible de passer outre l encodage du message en élément du groupe, mais alors, la sécurité dans le modèle standard n est plus assurée. Dans une publication de la conférence Pkc 06 [CPP06], co-écrite avec Pascal Paillier et David Pointcheval, nous introduisons une nouvelle alternative n utilisant ni encodage des messages en éléments du groupe ni fonction de hachage, et restant ainsi totalement compatible avec le modèle standard. Partiellement homomorphique, notre variante du schéma de chiffrement ElGamal est comparable au schéma originel en terme d efficacité, tout en diminuant le rapport entre la taille du chiffré et la taille du clair (souvent appelé le ratio de chiffrement) à la valeur optimale de 2, alors que, pour des paramètres classiques, le cryptosystème ElGamal possède un ratio de chiffrement de 13. Cryptographie basée sur l identité avec réduction fine Chapitre 10 Dans un papier de Crypto 01 resté depuis célèbre, Dan Boneh et Matthew Franklin proposèrent la première réalisation pratique d un schéma de chiffrement basé sur l identité (IBE). La sécurité de leur schéma, au sens de l indistinguabilité sous attaque à chiffrés et identités choisis, est équivalente au problème CBDH, dans le modèle de l oracle aléatoire. Cependant, la réduction proposée est loin d être fine. Dans le Chapitre 10, en collaboration avec Nuttapong Attrapadung, Jun Furukawa, Takeshi Gomi, Goichiro Hanaoka, Hideki Imai et Rui Zhang [ACF+05], nous proposons de simples modifications au schéma Boneh-Franklin permettant une réduction de sécurité fine. Notre variante peut être vue comme un schéma IBE pour lequel, pour chaque identité, deux clés équivalentes pourraient servir au déchiffrement. Chaque identité ne reçoit qu une seule de ces deux clés, ce choix étant aléatoire et secret pour tout utilisateur autre que l autorité et le détenteur. Notre construction est la continuation d une idée introduite par Jonathan Katz et Nan Wang. En ce sens, notre travail ne définit pas complètement un nouveau schéma ; il doit plus être considéré comme une poursuite de l idée de ces deux auteurs, pour permettre d obtenir une sécurité fine pour un schéma basé sur l identité, dans le modèle de l oracle aléatoire. Protéger les éléments publics de clés contre les fautes est nécessaire De nos jours, il est connu qu un adversaire peut essayer de retrouver des informations secrètes en provoquant des fautes durant un calcul cryptographique. Dans un article de la conférence Ches 06 [BCCC06] co-écrit avec Éric Brier, Mathieu Ciet et Christophe Clavier, nous poursuivons un travail de Jean-Pierre Seifert, utilisant une faute sur des éléments publics durant la vérification de signature. Plus précisément, nous considérons l analogue dans les calculs de signature. Notre article introduit la première attaque par fautes applicable au RSA en mode standard (c est-à-dire sans CRT), qui permet de retrouver l exposant privé en ne corrompant qu un élément public de clé. En effet, à la manière d une attaque proposée par Jean-Pierre Seifert permettant de faire accepter, grâce à une faute, de fausses signatures, nous ne ciblons que le module RSA durant notre attaque. Un des points forts de notre attaque est que les hypothèses sur les effets des fautes que nous provoquons sont très limitées. En effet, dans un premier mode de notre attaque, nous n avons besoin d absolument aucune connaissance particulière de l effet de la faute pour retrouver 19

Bibliographie l exposant privé dans sa totalité. Dans un second mode, basé sur un modèle de faute permettant la définition de ce que nous appelons des dictionnaires, nous améliorons l attaque, en réduisant d un facteur significatif le nombre de fautes nécessaires. Toutes nos attaques sont tout à fait applicables sur des produits non sécurisés. Notons que l utilisation de paddings déterministes (comme RSA-FDH) ou probabilistes (comme RSA-PFDH) n a pas d influence sur notre attaque, la seule impossibilité correspondant aux schémas probabilistes dans lesquels l aléa est retrouvé dans la signature elle-même (comme par exemple RSA-PSS). Tout ceci nous montre la nécessité de sécuriser les éléments publics des clés contre les fautes. Un schéma de signature dans le modèle standard Chapitre 7 En 1999, deux schémas de signature basés sur le problème FlexibleRSA furent proposés indépendamment : le schéma de signature de Rosario Gennaro, Shai Halevi et Tal Rabin (GHR) et le schéma de signature de Ronald Cramer et Victor Shoup (CS). Ces schémas atteignent le niveau de sécurité le plus élevé dans le modèle standard, c est-à-dire sans avoir besoin d oracles aléatoires. Cependant, ces schémas diffèrent dans leur mise en œuvre. Le schéma CS et ses variantes assurent une sécurité lâche, qui, in fine, impose de prendre des paramètres de sécurité plus grands. Au contraire, le schéma GHR ou sa variante, appelée signatures jumelles GHR, possèdent une réduction fine, mais nécessitent (i) soit une hypothèse supplémentaire et non-standard, dénommée indivisibilité de la fonction de hachage (ii) soit l usage d une fonction injective dans l ensemble des nombres premiers, lors des algorithmes de signature et de vérification. Dans une publication de Ct-rsa 07 [CJ07], en collaboration avec Marc Joye, nous présentons une nouvelle variante du schéma GHR, dans laquelle nous nous affranchissons complètement de cette hypothèse sur la fonction de hachage, sans pour autant utiliser une fonction injective dans l ensemble des premiers. Nous obtenons ainsi un nouveau schéma de signature (ainsi qu une variante en-ligne/hors-ligne) dont la sécurité dépend uniquement de la difficulté du problème FlexibleRSA, et ceci au travers d une réduction fine. Bibliographie personnelle Les références des travaux que nous avons publiés dans des journaux ou des conférences avec comité de sélection sont les suivantes. [BCCC06] Éric Brier, Benoît Chevallier-Mames, Mathieu Ciet et Christophe Clavier. Why one should secure its public elements. Dans Cryptographic Hardware and Embedded Systems CHES 2006, volume 4249 de Lecture Notes in Computer Science, pages 324 338. Springer-Verlag, 2006. [Che04] [Che05a] [Che05b] [CCJ04] 20 Benoît Chevallier-Mames. Self-randomized exponentiation algorithms. Dans Topics in Cryptology CT-RSA 2004, volume 2964 de Lecture Notes in Computer Science, pages 236 249. Springer-Verlag, 2004. Benoît Chevallier-Mames. An efficient CDH-based signature scheme with a tight security reduction. Dans Advances in Cryptology CRYPTO 2005, volume 3621 de Lecture Notes in Computer Science, pages 511 526. Springer-Verlag, 2005. Benoît Chevallier-Mames. New signature schemes with coupons and tight reduction. Dans Applied Cryptography and Network Security ACNS 2005, volume 3531 de Lecture Notes in Computer Science, pages 513 528. Springer-Verlag, 2005. Benoît Chevallier-Mames, Mathieu Ciet et Marc Joye. Low-cost solutions for preventing simple side-channel analysis : Side-channel atomicity. IEEE Transactions on Computers, 53(6):760 768, 2004.

[CJ07] Benoît Chevallier-Mames et Marc Joye. A practical and tightly secure signature scheme without hash function. Dans Topics in Cryptology CT-RSA 2007, Lecture Notes in Computer Science. Springer-Verlag, 2007. À paraître. [CJP03] Benoît Chevallier-Mames, Marc Joye et Pascal Paillier. Faster double-size modular multiplication from Euclidean multipliers. Dans Cryptographic Hardware and Embedded Systems CHES 2003, volume 2779 de Lecture Notes in Computer Science, pages 214 227. Springer-Verlag, 2003. [CNPP04] Benoît Chevallier-Mames, David Naccache, Pascal Paillier et David Pointcheval. How to disembed a program? Dans Cryptographic Hardware and Embedded Systems CHES 2004, volume 3156 de Lecture Notes in Computer Science, pages 441 454. Springer-Verlag, 2004. [CPP06] [CPP05] Benoît Chevallier-Mames, Pascal Paillier et David Pointcheval. Encodingfree ElGamal encryption without random oracles. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 91 104. Springer-Verlag, 2006. Benoît Chevallier-Mames, Duong Hieu Phan et David Pointcheval. Optimal asymmetric encryption and signature paddings. Dans Applied Cryptography and Network Security ACNS 2005, volume 3531 de Lecture Notes in Computer Science, pages 254 268. Springer-Verlag, 2005. Liste des brevets Ci-dessous, nous dénombrons les brevets publiés desquels nous avons fait partie des inventeurs. Nos co-auteurs pour ces brevets sont, par ordre alphabétique, Marc Chancerel, Jean-Sébastien Coron, Nathalie Feyt, Marc Joye, David Naccache, Pascal Paillier, David Pointcheval, Florence Quès et Karine Villegas. [01] Procédé et dispositif de vérification de données signées par groupe et application pour la transmission de données depuis une mémoire annexe. Brevet français. Numéro de publication : FR2831364. [02] Procédé de mise en œuvre, dans un composant électronique, d un algorithme de cryptographie et composant correspondant. Brevet français. Numéro de publication : FR2830146. [03] Procédé cryptographique protégé contre les attaques de type à canal caché. Brevet français. Numéro de publication : FR2838210. [04] Procédé pour la mise en œuvre sécurisée d un algorithme de cryptographie de type RSA et composant correspondant. Brevet français. Numéro de publication : FR2858496. [05] Procédé de réalisation d une multiplication modulaire et procédé de réalisation d une multiplication Euclidienne sur des nombres de 2n bits. Brevet français. Numéro de publication : FR2859030. [06] Procédé cryptographique d exponentiation modulaire protégé contre les attaques de type DPA. Brevet français. Numéro de publication : FR2864390. [07] Procédé d authentification dynamique de programmes par un objet portable électronique. Brevet français. Numéro de publication : FR2867929. [08] Procédé de réalisation d une opération de couplage sur une courbe elliptique, par un système comprenant une carte à puce et un lecteur de carte. Brevet français. Numéro de publication : FR2871970. 21

Bibliographie [09] Procédé de génération de signature à la volée avec preuve de sécurité. Brevet français. Numéro de publication : FR2874770. [10] Procédé de génération de signature avec preuve de sécurité tight, procédé de vérification et schéma de signature associés basés sur le modèle de Diffie-Hellman. Brevet français. Numéro de publication : FR2877788. [11] Cryptographic method protected against covert channel type attacks. Brevet européen. Numéro de publication : EP1493078, US20050163312. [12] Method for the secure application of a cryptographic algorithm of the RSA type and corresponding component. Numéro de publication : EP1652336, WO2005022820. [13] Method of performing a modular multiplication and method of performing a euclidean multiplication using numbers with 2n bits. Brevet européen. Numéro de publication : EP1656611, WO2005022378. [14] Cryptographic method for modular exponentiation, protected against dpa-type attacks. Brevet européen. Numéro de publication : EP1695204, WO2005069122. [15] A method of having programs dynamically authenticated by a portable elctronic object. Demande PCT. Numéro de publication : WO2005101725. [16] A method of having coupliing operation performed on an elliptical curve by a system comprising a smart card and a card reader. Demande PCT. Numéro de publication : WO2005125085. [17] A method of generating a signature on the fly with proof of security. Demande PCT. Numéro de publication : WO2006045660. 22

Deuxième partie Schéma de signature à sécurité prouvée 23

Chapitre 4 Introduction aux schémas de signature Sommaire 4.1 Introduction................................... 25 4.1.1 Schémas de signature.............................. 26 4.1.2 Protocole d identification à divulgation nulle de connaissance....... 27 4.2 Σ-protocole................................... 28 4.2.1 Heuristique de Fiat-Shamir........................... 29 4.2.2 Signatures à coupons.............................. 30 4.3 Sécurité des schémas de signature...................... 30 4.3.1 Notions de sécurité pour les schémas de signature.............. 30 4.3.2 Σ-protocoles et lemme de bifurcation..................... 32 4.3.3 Exemple de la sécurité de la primitive RSA.................. 32 4.4 Schémas de signature classiques avec oracles aléatoires......... 33 4.4.1 Signature RSA.................................. 33 4.4.2 Signature Schnorr................................ 34 4.4.3 Signature GQ.................................. 35 4.4.4 Signature GPS.................................. 35 4.4.5 Signature PS.................................. 36 4.5 Preuves classiques de schémas de signature................ 37 4.5.1 Preuve de RSA-FDH dans le modèle de l oracle aléatoire.......... 37 4.5.2 Preuve de Schnorr dans le modèle de l oracle aléatoire........... 38 4.6 Nos travaux sur les schémas de signature................. 40 Les schémas de signature constituent certainement la partie la plus utilisée de la cryptographie asymétrique. Aussi, une première partie de notre travail de thèse a été consacrée à leur étude, de leur conception à leur preuve de sécurité. Ainsi, nous avons proposé quelques nouvelles constructions, avec, pour chacune, des avantages sur les schémas existants. Ce premier chapitre est consacré à certains rappels sur les schémas de signature, les chapitres suivants étant consacrés à nos travaux dans ce domaine de la cryptologie. 4.1 Introduction Dans cette première section, nous définissons plus précisément les notions élémentaires qui sont associées aux schémas de signature. 25

Chapitre 4. Introduction aux schémas de signature 4.1.1 Schémas de signature Intuitivement, dans un schéma de signature, une partie, appelée le signataire, génère, pour un message donné, une valeur, appelée signature. Pour cela, le signataire utilise sa clé privée. Ensuite, une autre partie, appelée le vérifieur peut, à l aide de la clé publique correspondante, vérifier la validité de la signature. Formellement, nous pouvons donner la définition suivante. Définition 14 (Schéma de signature). Un schéma de signature est défini par les quatre algorithmes suivants : L initialisation des paramètres Set S. Recevant en entrée 1 κ, l algorithme Set S initialise des paramètres communs nécessaires au schéma ; La génération de clés Gen S. Étant donné une entrée 1κ, l algorithme Gen S produit une paire de clés : pk S, la clé publique, et sk S la clé privée correspondante ; L algorithme de signature Sign. Étant donné un message m dans un ensemble de messages M et une paire de clés (pk S, sk S ), l algorithme Sign produit une signature σ ; L algorithme de vérification Verify. Étant donné une signature σ, un message m M et une clé publique pk S, l algorithme Verify teste si σ est une signature valide de m sous la clé publique pk S. Il existe des schémas de signature sans paramètres communs, auquel cas l algorithme d initialisation des paramètres est omis. S il n existe qu une signature possible par message, l algorithme de signature est dit déterministe ; dans le cas contraire, il est dit probabiliste. Le concept de schéma de signature (sous-entendu, à clé publique) fut concrétisé pour la première fois par Ronald Rivest, Adi Shamir et Leonard Adleman dans un papier resté depuis célèbre [RSA78]. Ce schéma, appelé signature RSA du nom de ses auteurs, repose sur la difficulté de la factorisation. Il fut décrit dans sa version originale sous une forme qui est maintenant appelée primitive RSA. Celle-ci est en effet sujette à des attaques, les notions de sécurité pour les schémas de signature (voir Section 4.3.1) n ayant pas encore été réellement définies en 1978. Le schéma fut heureusement rendu conforme à ces notions de sécurité, comme nous le décrirons dans la Section 4.4.1, et c est cette version sécurisée qui forme avec une fonction de hachage comme FDH ou une fonction de padding comme PSS ce qui est maintenant appelé signature RSA. La primitive RSA se décrit comme suit, pour une taille de clés de l n bits (typiquement, l n = 1024) : Primitive RSA [RSA78] Génération de clés : Pour générer une paire de clés, l utilisateur choisit un exposant public e > 2 impair, et génère un module RSA n = pq de l n bits (voir Définition 1), tel que (p 1)(q 1) et e soient premiers entre eux. Ensuite, l utilisateur calcule d = e 1 mod (p 1)(q 1). La clé privée de l utilisateur est d tandis que sa clé publique est (e, n). Signature : Pour signer un message m M = Z n, l utilisateur calcule la valeur s = m d mod n. La signature de m est s. Vérification : Pour vérifier une signature s d un message m, il suffit de vérifier si m = s e mod n, auquel cas la signature est acceptée. Avant d aller plus loin dans l étude des schémas de signature, nous voudrions introduire un autre type de protocole, interactif celui-ci, qui, comme nous le verrons dans la Section 4.2.1, peut être relié aux schémas de signature. 26

4.1. Introduction 4.1.2 Protocole d identification à divulgation nulle de connaissance Les protocoles d identification à divulgation nulle de connaissance (zero-knowledge identification protocols, en anglais) furent inventés par Amos Fiat et Adi Shamir dans la publication [FS86] comme un moyen de s identifier, c est-à-dire de prouver son identité à quelqu un. Ces protocoles sont souvent vus comme des échanges (habituellement à trois ou quatre passes) entre un prouveur et un vérifieur. Dans cette thèse, nous nous focaliserons sur les protocoles d identification à divulgation nulle de connaissance à trois passes. Protocole d identification à divulgation nulle de connaissance. De façon intuitive, les protocoles d identification à divulgation nulle de connaissance sont un moyen pour le prouveur de convaincre qu il connaît un secret (et ainsi prouver son identité) sans révéler d autre information que le fait qu il connaisse ce secret. Plus précisément, les protocoles d identification à divulgation nulle de connaissance sont une preuve de connaissance qui, additionnellement, possède la propriété de divulgation nulle de connaissance. Définition 15 (Protocole d identification à divulgation nulle de connaissance). Un protocole d identification à divulgation nulle de connaissance (sous-entendu à trois passes) est défini par les trois algorithmes suivants : L initialisation des paramètres Set Z. Recevant en entrée 1 κ, l algorithme Set Z initialise des paramètres communs nécessaires au protocole ; La génération de clés Gen Z. Étant donné une entrée 1κ, l algorithme Gen Z produit une paire de clés : pk Z, la clé publique, et sk Z la clé privée correspondante. De plus, cet algorithme définit des ensembles U, V, K et G, ainsi que des fonctions publiquement calculables sur ces ensembles U : K U, V skz : K G V et W pkz : G V U ; Le protocole d identification, défini par trois échanges et une vérification finale : 1. Engagement. Le prouveur génère un aléa k K, et envoie u = U(k) au vérifieur ; 2. Challenge. Le vérifieur s assure que u U et envoie en retour un aléa c G au prouveur ; 3. Réponse. Finalement, le prouveur calcule s = V skz (k, c) et l envoie au vérifieur ; 4. Vérification. Le vérifieur s assure alors que u = W pkz (c, s) et s V. Il existe des protocoles d identification à divulgation nulle de connaissance sans paramètres communs, auquel cas l algorithme d initialisation des paramètres est omis. Sécurité des protocoles d identification à divulgation nulle de connaissance. Pour être dit sûr contre les vérifieurs honnêtes, un protocole d identification à divulgation nulle de connaissance doit posséder deux propriétés : la propriété de significativité (c est-à-dire que la probabilité pour un attaquant de s identifier comme quelqu un qu il n est pas est négligeable pour des paramètres correctement choisis). Grâce à cette propriété, le protocole est une preuve de connaissance ; la propriété de simulabilité (c est-à-dire qu il est possible de simuler, et ceci de façon indistinguable, un échange entre un prouveur et un vérifieur, en prenant (c, s) G V aléatoirement, et en calculant u = W pkz (c, s)). C est la propriété qui assure une divulgation nulle de connaissance. Pour être sûr contre les vérifieurs malhonnêtes, qui se caractérisent en ne choisissant pas le challenge c de façon aléatoire, mais en fonction de l engagement u, le protocole doit pouvoir être simulé sans supposer que c est aléatoire. 27

Chapitre 4. Introduction aux schémas de signature Pour obtenir une telle sécurité pour un protocole déjà sûr contre les vérifieurs honnêtes, le moyen le plus classique est de choisir l espace G assez petit. Ainsi, le simulateur peut deviner, avec une probabilité non négligeable, le challenge c qui sera demandé par le vérifieur malhonnête. Si la valeur n est pas celle espérée, le vérifieur malhonnête est alors relancé au même point par le simulateur, et la procédure est réitérée. Comme l espace G est petit, la probabilité du simulateur de deviner cette valeur n est pas négligeable, et le protocole peut ainsi être simulé. Cependant, comme le fait de choisir G petit diminue dans le même temps la significativité d un échange valide, il est souvent nécessaire en contrepartie de réitérer plusieurs fois le protocole, afin que la significativité du protocole séquentiel soit satisfaisante. 4.2 Σ-protocole Parmi les protocoles d identification à divulgation nulle de connaissance, il existe une sousclasse particulièrement intéressante, constituée de protocoles appelés les Σ-protocoles. Définition 16 (Σ-protocole). Un Σ-protocole est un protocole d identification à divulgation nulle de connaissance (à trois passes), possédant en plus la propriété de super-significativité : à l aide de deux échanges corrects (u, c 1, s 1 ) et (u, c 2, s 2 ), avec c 1 c 2, il existe un algorithme permettant (en temps polynomial) de retrouver la clé secrète sk Z du prouveur. Cette propriété additionnelle est remplie très souvent par les protocoles d identification à divulgation nulle de connaissance. Remarquons qu elle implique notamment qu un engagement ne doit servir qu une seule fois à s identifier, sous peine de divulguer la clé privée. Σ-protocoles classiques. Le premier Σ-protocole fut proposé par Amos Fiat et Adi Shamir dans [FS86]. Ce protocole repose sur la difficulté de la factorisation et peut être décrit comme suit : Identification FS [FS86] Génération de clés : Pour se créer une paire de clés, l utilisateur génère un module RSA n = pq, puis tire un aléa s Z n, et calcule t = s 2 mod n. Sa clé publique est (t, n) et sa clé privée est s. Phase d engagement : Pour s engager, le prouveur tire un nombre aléatoire r Z n, et calcule u = r 2 mod n. Il envoie alors u au vérifieur. Phase de challenge : Le vérifieur choisit un bit aléatoire b {0, 1} et le renvoie au prouveur. Phase de réponse : Le prouveur calcule alors v = r s b mod n, qu il renvoie au vérifieur. Vérification : Le vérifieur teste si v 2 = u t b mod n. Ce protocole doit être exécuté (avec succès) un certain nombre de fois consécutives, avant que le vérifieur n accepte finalement l identification du prouveur. En effet, pour chaque tour, l attaquant pourrait tenter de deviner le challenge b qui lui sera posé, calculer l engagement u = r 2 t b mod n et donner la réponse v = r t b mod n, et obtenir ainsi une probabilité de succès de 1 2. En exécutant i tours de suite, la significativité est accrue jusqu à 1 2 i. Ce protocole séquentiel est sûr contre les vérifieurs malhonnêtes sous l hypothèse de difficulté de la racine carrée [Poi96], que nous rappelons être équivalente à la factorisation [Rab79]. 28

4.2. Σ-protocole Un autre célèbre Σ-protocole fut proposé par Claus-Peter Schnorr dans [Sch91]. Il repose sur la difficulté du logarithme discret. Sa version sûre contre les vérifieurs honnêtes se décrit comme suit : Identification Schnorr [Sch91] Initialisation des paramètres : Un premier p de l p bits est choisi, tel que p 1 soit divisible par un premier q de l q bits. Une base g Z p d ordre q est tirée aléatoirement. Génération de clés : Pour générer une paire de clés, l utilisateur tire un aléa x Z q. Sa clé privée est x et sa clé publique est y = g x mod p. Phase d engagement : Pour s engager, le prouveur tire un nombre aléatoire k Z q, et calcule u = g k mod p. Il envoie alors u au vérifieur. Phase de challenge : Le vérifieur choisit un nombre aléatoire c Z q et le renvoie au prouveur. Phase de réponse : Le prouveur calcule alors s = k + c x mod q, qu il renvoie au vérifieur. Vérification : Le vérifieur teste si u = g s y c mod p, auquel cas l identification est réussie. Le protocoles d identification Schnorr est un Σ-protocole : à l aide de (u, c 1, s 1, c 2, s 2 ), tels que u = g s 1 y c 1 = g s 2 y c 2 et c 1 c 2 (mod q), nous pouvons retrouver le logarithme de y en base g (c est-à-dire la clé x) par la formule x = s 1 s 2 c 1 c 2 mod q. Remarquons que ce protocole est sûr contre les vérifieurs honnêtes. Par contre, pour être sûr contre les vérifieurs malhonnêtes, il faut définir l espace du challenge non plus comme Z q mais comme {0, 1} t, pour un t petit, et réitérer le protocole i fois de façon séquentielle, de façon à obtenir une significativité de 1 2 it. Pour finir, notons que ce protocole d identification se généralise à d autres groupes que les sous-groupes de Z p, et notamment aux courbes elliptiques. Dorénavant, nous prendrons donc pour le protocole Schnorr un groupe quelconque G d ordre premier q. Dans la section suivante, nous présentons le lien essentiel qui a été fait entre les schémas de signature et les protocoles d identification à divulgation nulle de connaissance. 4.2.1 Heuristique de Fiat-Shamir Il existe une célèbre heuristique [FS86], appelée heuristique de Fiat-Shamir du nom de ses auteurs Amos Fiat et Adi Shamir, qui permet de transformer un protocole d identification à divulgation nulle de connaissance (à trois passes) sûr contre les vérifieurs honnêtes en un schéma de signature. Le but de cette transformation est de rendre le protocole non-interactif. Pour cela, le principe est d utiliser une fonction de hachage G, et de remplacer le challenge c (qui, normalement, viendrait d un vérifieur honnête, et serait donc aléatoire) par le haché du message m et de l engagement u, c est-à-dire G(m, u). La signature ainsi obtenue (c, s) peut être vérifiée en testant si G(m, W pkz (c, s)) = c. Intuitivement, si la fonction de hachage est suffisamment sûre, c est-à-dire se comporte comme une fonction aléatoire, le challenge ainsi calculé sera aussi aléatoire que celui qui aurait été retourné par un vérifieur honnête, et trouver la réponse correspondante à ce challenge sera aussi difficile que trouver la réponse lors du protocole d identification (voir la Section 4.3.2 pour une étude formelle de la sécurité des signatures basées sur l heuristique Fiat-Shamir). 29

Chapitre 4. Introduction aux schémas de signature Ainsi, le protocole d identification à divulgation nulle de connaissance Schnorr utilisé avec cette heuristique donne lieu au schéma de signature Schnorr, décrit ci-dessous. Signature Schnorr [Sch91] Initialisation des paramètres : Un groupe G d ordre premier q est choisi, ainsi qu un générateur g. De plus, un ensemble M = {0, 1} lm est défini, et une fonction de hachage G : M G Z q est choisie. Génération de clés : Pour générer une paire de clés, l utilisateur tire un aléa x Z q. Sa clé privée est x et sa clé publique est y = g x. Signature : Pour signer un message m M, l utilisateur tire un nombre aléatoire k Z q, calcule u = g k, puis c = G(m, u) et s = k + c x mod q. La signature du message m est alors σ = (s, c). Vérification : Pour vérifier une signature σ = (s, c) d un message m, il faut calculer u = g s y c. La signature est alors acceptée si et seulement si c = G(m, u ). 4.2.2 Signatures à coupons Les schémas de signature dérivés des protocoles d identification à divulgation nulle de connaissance sont d un grand intérêt, notamment parce qu ils permettent l usage de coupons : ainsi, la première phase, qui consiste à calculer u = U(k) peut être exécutée avant la connaissance du message m. Une fois calculée, cette valeur, appelée un coupon, est stockée pour être utilisée dans le futur. La signature est calculée plus tard, lorsque le message m à signer est présenté, via le calcul de c = G(m, u) et de s = V skz (k, c). Cette seconde phase, qui dépend du message, est bien plus rapide que la première phase, du moins pour les protocoles usuels d identification à divulgation nulle de connaissance, comme le protocole Schnorr. De telles signatures sont appelées dans la littérature signatures à coupons, signatures en-ligne/hors-ligne, ou encore signature à la volée. Elles sont particulièrement efficaces et intéressantes pour des environnements contraints comme celui de la carte à puce et trouvent ainsi de nombreuses applications, dans le domaine des transports notamment. 4.3 Sécurité des schémas de signature Après avoir établi un panorama rapide de la notion de schéma de signature, nous nous intéressons dans cette section à leur sécurité. 4.3.1 Notions de sécurité pour les schémas de signature Un schéma de signature doit être protégé contre différentes attaques. Pour cela, de nombreuses notions de sécurité ont été définies, basées principalement sur le travail de Shafi Goldwasser, Silvio Micali et Ronald Rivest [GMR84, GMR88]. La résistance des schémas de signature s évalue dans différents scénarios d attaque (ou modèles de sécurité). Chaque scénario est défini en donnant à l attaquant un but, c est-à-dire ce qu il va chercher à mettre en défaut dans le système, et des ressources, c est-à-dire les informations et les moyens auxquels il aura accès pour réaliser son attaque. Bien sûr, si le protocole est un Σ-protocole, la propriété de super-significativité impose de n utiliser un coupon qu une seule fois. 30

4.3. Sécurité des schémas de signature Ressources de l attaquant. Les ressources disponibles peuvent être de différentes natures. Dans un premier mode, l attaquant ne reçoit que la clé publique du signataire. Clairement, c est l information minimale pour réaliser une attaque. Cela caractérise les attaques à clé seule ou attaques sans message, notées KOA (en anglais, key-only attack) ou NMA (en anglais, nomessage attack). Un mode supérieur est celui où l attaquant connaît des couples message-signature. Ceci est très réaliste, car, par définition, une signature est publique, pour être vérifiable par tout le monde. Ce sont les attaques à messages connus, notées KMA (en anglais, known-message attack). Enfin, les ressources les plus puissantes qu il est possible de donner à un attaquant sont un accès à un oracle de signature, limité seulement en nombre de requêtes. L attaquant peut alors demander la signature d un ensemble de messages de son choix. C est l attaque à messages choisis. Il existe deux façons de gérer ces requêtes : soit l ensemble des messages est donné en une seule fois, ce qui est appelé attaque non-adaptative, soit l attaquant peut choisir le message dont il demande la signature en fonction des réponses qu il a reçues précédemment. Ces dernières ressources forment les attaques adaptatives à messages choisis, et sont les ressources les plus puissantes qui peuvent être fournies à un attaquant. Elles sont notées CMA (en anglais, chosenmessage attack). But de l attaquant. Une fois ses ressources fournies, l attaquant va tenter d atteindre un but. Pour chacun de ces buts, une notion de sécurité correspondant à l impossibilité de le réaliser est alors définie. Le but le plus immédiat est de retrouver la clé de signature. La notion de sécurité correspondante, la résistance de la clé, est notée UBK (en anglais, unbreakability). Cette notion est la première qui soit apparue, sans doute dès l invention de la cryptographie à clé publique par Whitfield Diffie et Martin Hellman [DH76]. Il existe néanmoins des buts plus faciles à atteindre pour un attaquant, et qui pourtant peuvent conduire à des failles de sécurité. Le but suivant est d être capable de signer n importe quel message. La notion associée est la résistance aux falsifications universelles et est notée UF (en anglais, unforgeability). Réaliser ce but est largement suffisant pour n importe quel attaquant, car cela lui permet de signer n importe quel message : le fait que, pour cela, il ait besoin ou non de retrouver la clé privée n est donc pas crucial pour lui. Enfin, le troisième but possible pour l attaquant est d être capable de signer un message de son choix, dont il n aurait pas déjà reçu la signature. La notion de sécurité correspondante est la résistance aux falsifications existentielles et est notée EUF (en anglais, existential unforgeability). Un attaquant qui réaliserait ce but ne remettrait pas en jeu toute utilisation du schéma de signature, par exemple si le message signé n avait pas de sens. Cependant, un schéma qui résisterait à ce but serait ipso facto résistant aux buts plus conséquents. Nous pouvons noter qu un quatrième but est apparu (pour les schémas probabilistes), celui d arriver à exhiber un couple message-signature qui n aurait pas été donné à l attaquant par l oracle de signature. La notion de sécurité associée est la résistance forte aux falsifications existentielles et est notée seuf (en anglais, strong existential unforgeability). Elle se distingue de EUF, car l attaquant peut retourner dans sa falsification un message dont il aurait reçu une signature, si la signature présentée est nouvelle : la falsification existentielle est alors dite faible. Néanmoins, exhiber des falsifications faibles remet difficilement en jeu la sécurité d un système dans le monde réel. La notion seuf est toutefois parfois utilisée, car elle implique les autres notions. 31

Chapitre 4. Introduction aux schémas de signature Schéma de signature sûr. Chaque attaquant est ainsi mesuré en lui adjoignant la notion de sécurité qu il cherche à mettre en défaut et des ressources : nous notons alors chaque attaque Notion-Ressource, où Notion {UBK, UF, EUF, seuf} et Ressource {KOA, KMA, CMA}. Il est de nos jours habituel de demander qu un schéma de signature résiste aux falsifications existentielles sous attaques adaptatives à messages choisis. Ainsi, nous dirons qu un schéma de signature est sûr s il protège des falsifications existentielles sous attaques (sous-entendu, adaptatives) à messages choisis (c est-à-dire les attaques EUF-CMA). Ceci est mesuré par la probabilité pour n importe quel attaquant A de retourner une signature valide σ d un message m qu il n a jamais soumis à l oracle de signature. Cette probabilité est calculée en donnant à l attaquant un temps raisonnablement limité pour réaliser son attaque et un maximum de q s requêtes à l oracle de signature : [ Succ EUF-CMA (pks, sk S (A, q s ) = Pr S ) Gen S (1 κ ), (m, σ) A Sign sk ( ) ] S (pk S ) : Verify pks (m, σ) = True. Dans le modèle de l oracle aléatoire [BR93], l adversaire A a également accès à un oracle de hachage, auquel il peut faire q h requêtes. 4.3.2 Σ-protocoles et lemme de bifurcation Une façon générique de prouver la sécurité de certains schémas de signature est le lemme de bifurcation de David Pointcheval et Jacques Stern [PS96, Poi96]. Ce lemme s applique sur ce que ces auteurs ont appelé des schémas de signature génériques, dont font notamment partie les schémas de signature basés sur l application de l heuristique Fiat-Shamir à des Σ-protocoles. Ce lemme permet d établir la sécurité de tels schémas, dans le modèle de l oracle aléatoire. L intuition est d utiliser, dans une première étape, un attaquant contre le schéma de signature pour obtenir une première falsification, puis, dans une seconde étape, appelée étape de rejeu, de redémarrer cet attaquant avec le même ruban aléatoire, pour obtenir une seconde falsification. Le point crucial est de répondre dans la seconde étape différemment aux requêtes à l oracle de hachage, ce qui est tout à fait possible dans le modèle de l oracle aléatoire. Les auteurs ont alors prouvé que la probabilité d obtenir deux falsifications (u, c 1, s 1 ) et (u, c 2, c 2 ) avec c 1 c 2 était non négligeable, et pouvait être, suivant différents modes de leur lemme en O( ε2 q h ) ou en O( ε q h ). Pour plus de précision sur le lemme de bifurcation, nous invitons le lecteur intéressé à consulter la thèse de David Pointcheval [Poi96]. Finesse des preuves basées sur le lemme de bifurcation. Le lemme de bifurcation est très générique, et s applique donc à nombre de schémas de signature. Malheureusement, la réduction de sécurité qu il assure est loin d être fine. En effet, un attaquant qui attaque un schéma avec une certaine probabilité est transformé en un attaquant qui retrouve la clé du schéma avec une probabilité bien plus faible. 4.3.3 Exemple de la sécurité de la primitive RSA Nous terminons notre section sur la sécurité des schémas de signature en étudiant la sécurité de la primitive RSA (comme décrite dans la Section 4.1.1). Cela nous permet de donner un exemple concret des différents scénarios d attaque. Il est possible de montrer que la résistance de la primitive RSA face aux attaques UBK-KOA est égale à la difficulté du problème FACT [May04, CM04]. De même, le problème RSA peut être réduit au problème d attaquer la sécurité UF-KOA. 32

4.4. Schémas de signature classiques avec oracles aléatoires Par contre, la primitive RSA n a aucune sécurité contre les attaquants EUF-KOA : en effet, avec la clé publique (n, e) d un utilisateur, un attaquant peut facilement prendre un aléa r Z n, puis calculer m = r e mod n. Trivialement, σ = r est une falsification existentielle du message m. De même, la primitive RSA n a aucune sécurité contre les attaquants UF-CMA, où l attaquant n a le droit qu à une requête de signature : en effet, avec la clé publique (n, e) d un utilisateur, un attaquant, cherchant à créer la signature d un message m Z n qu il a choisi, peut facilement prendre un aléa r Z n, puis demander la signature du message m = m r e mod n. Une fois connue la signature σ de m, il peut alors en déduire la signature σ = σ r 1 mod n du message m qu il ciblait. Heureusement, la primitive RSA a été renforcée, grâce à l utilisation de fonctions de padding, donnant lieu à ce que, aujourd hui, nous appelons les signatures RSA. Ces schémas de signature sont décrits plus précisément dans la Section 4.4.1. 4.4 Schémas de signature classiques avec oracles aléatoires Dans cette section, nous rappelons quelques schémas de signature dont la sécurité a été prouvée dans le modèle de l oracle aléatoire. Cette liste ne saurait bien sûr être exhaustive, mais nous espérons qu elle donne un panorama représentatif des schémas de signature existants. Récemment [GHR99, CS99, CL02, Fis03, BB04, Wat05], de nouveaux schémas de signature, avec une preuve dans le modèle standard, sont apparus. Certains d entre eux, ayant un rapport étroit avec le travail exposé dans cette thèse, sont discutés dans la Section 7.2. Pour les autres, nous conseillons au lecteur intéressé de se référer aux articles correspondants. 4.4.1 Signature RSA Nous rappelons que la primitive RSA fut inventée par Ronald Rivest, Adi Shamir et Leonard Adleman dans [RSA78]. Cette construction fut sujette aux attaques décrites dans la Section 4.3.3. Heureusement, des solutions ont été proposées, et principalement l usage d une fonction qui casse la malléabilité de la fonction RSA : la fonction de padding (voir Section 1.3.7). L utilisation de la fonction de padding donne lieu à ce qui est appelé aujourd hui la signature RSA. La fonction probabiliste de padding standardisée est appelée PSS, et l ensemble forme la signature RSA-PSS [BR96]. RSA-PSS possède, dans le modèle de l oracle aléatoire une réduction fine vers le problème RSA [BR96]. Sig. RSA-PSS [RSA78, BR96] Initialisation des paramètres : Le padding PSS est défini par deux fonction µ : M R {0, 1} ln 1 et µ 1 : {0, 1} ln 1 M { }. Génération de clés : Pour générer une paire de clés, l utilisateur choisit un exposant public e > 2 impair, et génère un module RSA n = pq de l n bits (voir Définition 1), tel que (p 1)(q 1) et e soient premiers entre eux. Ensuite, l utilisateur calcule d = e 1 mod (p 1)(q 1). La clé privée de l utilisateur est d tandis que sa clé publique est (e, n). Signature : Pour signer un message m M, l utilisateur tire un aléa r R et calcule la valeur s = µ(m, r) d mod n. La signature de m est s. Vérification : Pour vérifier une signature s d un message m, il suffit de calculer v = s e mod n. Si et seulement si µ 1 (v) = m, la signature est acceptée. 33

Chapitre 4. Introduction aux schémas de signature Plutôt qu une fonction de padding, une simple fonction de hachage peut également être utilisée. La plus courante dans le cas du RSA est la fonction de hachage sur le domaine complet (en anglais, Full-Domain Hash, notée FDH), donnant lieu à la signature RSA-FDH [BR93]. Sig. RSA-FDH [RSA78, BR93] Initialisation des paramètres : Une famille de fonctions de hachage sur tout le domaine H n : M Z n est définie. Génération de clés : Pour générer une paire de clés, l utilisateur choisit un exposant public e > 2 impair, et génère un module RSA n = pq de l n bits, tel que (p 1)(q 1) et e soient premiers entre eux. Ensuite, l utilisateur calcule d = e 1 mod (p 1)(q 1). La clé privée de l utilisateur est d tandis que sa clé publique est (e, n). Signature : Pour signer un message m M, l utilisateur calcule la valeur s = H n (m) d mod n. La signature de m est s. Vérification : Pour vérifier une signature s d un message m, il suffit de tester si H n (m) = s e mod n, auquel cas la signature est acceptée. RSA-FDH possède, dans le modèle de l oracle aléatoire une réduction lâche vers le problème RSA [BR93, Cor00] (voir Section 4.5.1). Notons que dans [KW03], Jonathan Katz et Nan Wang ont proposé une variante très proche de RSA-FDH possédant une sécurité fine. De façon générale, les signatures RSA font une taille de l n bits. D après les algorithmes connus pour résoudre le problème RSA, les paramètres choisis sont usuellement l n = 1024, et e = 2 16 + 1. 4.4.2 Signature Schnorr Nous rappelons ici la signature Schnorr, comme inventée par Claus-Peter Schnorr dans l article [Sch91]. Signature Schnorr [Sch91] Initialisation des paramètres : Un groupe G d ordre premier q de l q bits est choisi, ainsi qu un générateur g. De plus, un ensemble M = {0, 1} lm est défini, et une fonction de hachage G : M G Z q est choisie. Génération de clés : Pour générer une paire de clés, l utilisateur tire un aléa x Z q. Sa clé privée est x et sa clé publique est y = g x. Signature : Pour signer un message m M, l utilisateur tire un nombre aléatoire k Z q, calcule u = g k, puis c = G(m, u) et s = k + c x mod q. La signature du message m est alors σ = (s, c). Vérification : Pour vérifier une signature σ = (s, c) d un message m, il faut calculer u = g s y c. La signature est alors acceptée si et seulement si c = G(m, u ). La signature Schnorr est basée sur l heuristique de Fiat-Shamir appliquée à un Σ-protocole, et possède donc, dans le modèle de l oracle aléatoire une réduction lâche vers le problème DL, grâce au lemme de bifurcation [PS96]. Typiquement, un groupe G d ordre q de 160 bits est utilisé, pour une sécurité lâche. Ce groupe peut être un sous-groupe de Z p pour un premier p de 1024 bits, ou une courbe elliptique 34

4.4. Schémas de signature classiques avec oracles aléatoires sur un corps premier d environ 160 bits. Les signatures Schnorr font une taille de 2l q bits, mais peuvent être réduites à une taille de l q + 80 bits, en prenant des valeurs de challenge c plus petites [GS94]. 4.4.3 Signature GQ Dans l article [GQ88], Louis Guillou et Jean-Jacques Quisquater ont adapté l idée de Σ-protocole introduite par Amos Fiat et Adi Shamir, pour donner naissance à un nouveau Σ-protocole basé sur le problème RSA. En appliquant l heuristique Fiat-Shamir, ces auteurs obtiennent également un schéma de signature, noté GQ, basé sur le problème RSA. Sa description est la suivante. Signature GQ [GQ88] Initialisation des paramètres : Un ensemble M = {0, 1} lm est défini, et une fonction de hachage G : M Z n {0, 1} lg est choisie. Génération de clés : Pour générer une paire de clés, l utilisateur choisit un exposant public premier e > 2 lg, et génère un module RSA n = pq de l n bits, tel que (p 1)(q 1) et e soient premiers entre eux. L utilisateur calcule alors d = e 1 mod (p 1)(q 1). Enfin, l utilisateur prend un aléa g Z n et calcule a = g d mod n. La clé privée de l utilisateur est a tandis que sa clé publique est (e, n, g). Signature : Pour signer un message m M, l utilisateur tire un nombre aléatoire k Z n, calcule u = k e mod n, puis c = G(m, u) et s = k a c mod n. La signature du message m est alors σ = (s, c). Vérification : Pour vérifier une signature σ = (s, c) d un message m, il faut calculer u = s e g c mod n. La signature est alors acceptée si et seulement si c = G(m, u ). Un avantage de la signature GQ est qu il permet un schéma de signature basé sur l identité. Dans ce type de schéma, la paire de clés est générée par une autorité, la partie publique ici (e, n) étant commune à tous les utilisateurs et la partie privée ici d étant gardée secrète par l autorité. Un utilisateur d identifiant ID peut obtenir sa clé privée de cette autorité : celle-ci est H(ID) d mod n. Ce type de signature permet une simplification de l infrastructure à clé publique ; dans le même temps, la non-répudiation n est plus assurée, comme l autorité peut signer au nom de n importe quel utilisateur. La signature GQ est basée sur l heuristique de Fiat-Shamir appliquée à un Σ-protocole (appelé protocole d identification GQ), et possède donc, dans le modèle de l oracle aléatoire une réduction lâche vers le problème RSA, grâce au lemme de bifurcation [PS96]. D après les façons connues à ce jour de résoudre le problème RSA, l g = 160 bits, l n = 1024 bits et e premier d au moins 161 bits sont des paramètres sûrs, pour une sécurité lâche. Les signatures GQ font une taille de l n + l g bits, mais peuvent être réduites à une taille de l n + 80 en prenant des valeurs de challenge c plus petites [GS94]. 4.4.4 Signature GPS Le schéma de signature GPS fut inventé par Marc Girault [Gir91], puis prouvé sûr par Guillaume Poupard et Jacques Stern dans [PS98]. Il s agit d une adaptation du schéma Schnorr sur des groupes d ordre secret. Ce schéma est basé sur la difficulté du logarithme discret dans 35

Chapitre 4. Introduction aux schémas de signature un groupe Z n d ordre secret (noté DL n voir Définition 9), problème qui est un problème plus difficile que la factorisation. Signature GPS [Gir91, PS98] Initialisation des paramètres : Un module RSA n = pq de l n bits est généré. Une base g d ordre maximal est tirée aléatoirement dans Z n. De plus, un ensemble M = {0, 1} lm est défini, et une fonction de hachage G : M Z n {0, 1} lg est choisie. Génération de clés : Pour générer une paire de clés, l utilisateur génère un aléa x {0, 1} lx. Sa clé privée est x et sa clé publique est y = g x mod n. Signature : Pour signer un message m M, l utilisateur tire un nombre aléatoire k {0, 1} l k, calcule u = g k mod n, puis c = G(m, u) et s = k + c x. La signature du message m est alors σ = (s, c). Vérification : Pour vérifier une signature σ = (s, c) d un message m, il faut calculer u = g s y c mod n. La signature est alors acceptée si et seulement si c = G(m, u ). La signature GPS est basée sur l heuristique de Fiat-Shamir appliquée à un Σ-protocole (appelé protocole d identification GPS), et possède donc, dans le modèle de l oracle aléatoire une réduction lâche vers le problème DL n, grâce au lemme de bifurcation [PS96, PS98]. La différence notable de ce schéma avec Schnorr est que l ordre du groupe est secret. Aussi, la borne 2 lx est choisie de telle façon que le logarithme discret de y en base g soit difficile, et la borne 2 l k est telle que k cache statistiquement cx (voir pour plus de précisions [PS98] ou la thèse de Guillaume Poupard [Pou00]) : des valeurs typiques sont l x = 160, l g = 160, l k = 400 et l n = 1024. Les signatures GPS font une taille de l k + l g bits, mais peuvent être réduites à une taille de l k + 80 en prenant des valeurs de challenge c plus petites [GS94]. 4.4.5 Signature PS Le schéma de signature PS fut inventé par Guillaume Poupard et Jacques Stern dans la publication [PS99]. Il est basé sur une preuve de connaissance à divulgation nulle de connaissance de la factorisation d un module RSA. Signature PS [PS99] Initialisation des paramètres : Un ensemble M = {0, 1} lm est défini, et une fonction de hachage G : M {0, 1} ln {0, 1} lg est choisie. Génération de clés : Pour générer une paire de clés, l utilisateur génère un module RSA n = pq de l n bits. Une base g d ordre maximal est tirée aléatoirement dans Z n. La clé publique est (n, g) et la clé secrète est x = n (p 1)(q 1) = p + q 1. Signature : Pour signer un message m M, l utilisateur tire un nombre aléatoire k {0, 1} l k, calcule u = g k mod n, puis c = G(m, u) et s = k + c x. La signature du message m est alors σ = (s, c). Vérification : Pour vérifier une signature σ = (s, c) d un message m, il faut calculer u = g s c n mod n. La signature est alors acceptée si et seulement si c = G(m, u ) et si s {0, 2 l k + 2 lg+ ln 2 +1 }. 36

4.5. Preuves classiques de schémas de signature La signature PS est basée sur l heuristique de Fiat-Shamir appliquée à un Σ-protocole (appelé le protocole d identification PS), et possède donc, dans le modèle de l oracle aléatoire une réduction lâche vers le problème FACT, grâce au lemme de bifurcation [PS96, PS99]. En effet, le lemme de bifurcation permet d obtenir l ordre du groupe, et l algorithme de Garry Miller [Mil76] permet alors d en déduire la factorisation de n. La borne 2 l k est telle que k cache statistiquement c x (voir pour plus de précision [PS99]) : des valeurs typiques sont l n = 1024, l g = 160, l k = 753. Les signatures PS font une taille de l k +l g bits, mais peuvent être réduites à une taille de l k +80 en prenant des valeurs de challenge c plus petites [GS94]. 4.5 Preuves classiques de schémas de signature Dans cette section, nous allons rappeler quelques preuves typiques de sécurité, dans le modèle de l oracle aléatoire, pour permettre ensuite au lecteur d avoir une connaissance des techniques classiques de preuves. Cela sera ensuite utile pour suivre plus aisément les preuves des schémas que nous proposerons. 4.5.1 Preuve de RSA-FDH dans le modèle de l oracle aléatoire Dans cette section, nous rappelons brièvement la preuve de RSA-FDH dans le modèle de l oracle aléatoire, telle qu exposée par Mihir Bellare et Phillip Rogaway [BR93, BR96], puis améliorée par Jean-Sébastien Coron [Cor00]. Nous rappelons (voir Section 4.4.1) que la signature RSA-FDH est s = H(m) d mod n, pour une fonction de hachage H : M Z n. Théorème 1 (Coron [Cor00]). Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle contre le schéma de signature RSA- FDH, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors il est possible d utiliser cet attaquant pour résoudre le problème RSA, avec une probabilité ε et en un temps τ, tels que et ε ε exp(1) q s τ τ + (q s + q h + 1)T où T est le temps pour calculer une exponentiation modulo n. Démonstration. Notre réduction reçoit une instance quelconque (n, e, y) du problème RSA. Elle utilise alors un attaquant contre le schéma de signature RSA-FDH pour résoudre cette instance. Par définition, l attaquant A, après avoir eu droit à q h requêtes à un oracle de hachage H et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. L attaquant A est utilisé avec la simulation suivante. Initialisation : A est initialisé avec la clé publique (e, n). 37

Chapitre 4. Introduction aux schémas de signature Réponse à une nouvelle requête H : le simulateur tire un nombre aléatoire k Z n, et retourne yk e mod n avec une probabilité (1 η), et k e mod n avec une probabilité η. La valeur de η sera précisée plus tard dans la démonstration. Réponse à une requête de signature sur un message m i M : pour la requête i de signature, la simulation fait un appel à l oracle de hachage, pour connaître h = H(m i ) : si h a été défini comme yk e mod n, la simulation échoue ; sinon, h a été défini comme k e mod n, et donc la simulation peut calculer la signature de m i. En effet, celle-ci vaut s = k, et peut être retournée à l attaquant. Ainsi, la simulation est valide et indistinguable d un véritable signataire, malgré une probabilité d échec que nous calculerons dans la suite. Utilisation de la falsification : Si la simulation réussit, l attaquant A retourne avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Si l attaquant échoue, notre réduction échoue elle aussi. Dans le cas contraire, l attaquant retourne s et m. La simulation fait alors un appel à l oracle de hachage, pour connaître h = H(m) : si h a été défini comme k e mod n, la simulation échoue ; sinon, h a été défini comme yk e mod n, et donc la simulation peut calculer la solution du challenge RSA : il s agit de y d mod n = sk 1 mod n. Calculons maintenant la probabilité de succès de notre réduction. Pour les q s requêtes de signature, il faut qu à chaque fois, h soit de la forme k e mod n, ce qui arrive avec une probabilité η qs. Pour la falsification finale, il faut que h soit de la forme yk e mod n, ce qui donne un facteur supplémentaire (1 η). Il ne reste alors plus qu à trouver la probabilité η qui maximise la probabilité de succès de la réduction, c est-à-dire η qs (1 η)ε. Clairement, cette probabilité est maximale pour η = 1 1 q, s+1 donnant une probabilité finale ε ε(1 1 q s+1 )qs q s + 1. Pour une valeur q s > 1, cela donne ε ε exp(1) q s. De plus, le temps de notre réduction τ est majorée comme suit τ τ + (q s + q h + 1)T, le +1 venant de l appel à l oracle de hachage effectué lors de la vérification finale de la falsification, au cas où l attaquant n aurait pas demandé lui-même la valeur H(m) à l oracle de hachage. 4.5.2 Preuve de Schnorr dans le modèle de l oracle aléatoire Dans cette section, nous rappelons brièvement la preuve du schéma de signature Schnorr dans le modèle de l oracle aléatoire, telle qu exposée par David Pointcheval et Jacques Stern dans [PS96, Poi96]. 38

4.5. Preuves classiques de schémas de signature Théorème 2 (Pointcheval-Stern [PS96]). Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle contre le schéma de signature Schnorr, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors il est possible d utiliser cet attaquant pour résoudre le problème DL, avec une probabilité ε et en un temps τ, tels que et ε 1 ( ε q ) s(q h + q s ) 2 1 q h q q τ 2τ + 4q s T où T est le temps pour calculer une exponentiation dans le groupe G. La preuve est une application du lemme de bifurcation. Nous utilisons ici la forme la plus simple du lemme de bifurcation, et ainsi, la réduction n est pas la plus fine qui puisse être obtenue par ce lemme. Démonstration. Notre réduction reçoit une instance quelconque (g, y) du problème DL, sur un groupe G d ordre premier q. Elle utilise alors un attaquant contre le schéma de signature Schnorr pour résoudre cette instance. Par définition, l attaquant A, après avoir eu droit à q h requêtes à un oracle de hachage H et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. L attaquant A est utilisé avec la simulation suivante. Réponse à une nouvelle requête G(m, u) : le simulateur retourne un nombre aléatoire dans Z q. Réponse à une requête de signature sur un message m i M : le simulateur tire deux aléas (s, c) Z q Z q et calcule u = g s y c. Si G(m i, u) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 1). Sinon, le simulateur pose G(m i, u) = c et retourne la signature valide (s, c). Comme nous pouvons le voir, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors de l Événement 1 : celui-ci n a heureusement qu une probabilité inférieure à qs(q h+q s) q de se produire. Ainsi, la simulation est valide et indistinguable d un véritable signataire, sauf sous cette probabilité d échec. Étape initiale, étape de rejeu : Comme dans toute utilisation du lemme de bifurcation, l attaquant est utilisé deux fois, en lui répondant de façon différente aux oracles de hachage, à partir d un index j des requêtes de hachage, index que la réduction tire au hasard. D après le travail de David Pointcheval et Jacques Stern [PS96, Poi96], nous savons alors qu avec une probabilité ε ε2 q h, l attaquant a répondu avec succès deux fois, sur un même engagement u celui correspondant à la requête à la fonction de hachage à l indice j lors de l étape initiale et de l étape de rejeu. Utilisation des falsifications : Si l attaquant échoue lors de l étape initiale ou de l étape de rejeu, notre réduction échoue elle aussi. Dans le cas contraire, l attaquant a retourné (s 0, c 0 ) 39

Chapitre 4. Introduction aux schémas de signature comme une première falsification du message m, et (s 1, c 1 ) comme une seconde falsification du message m, où u = g s 0 y c 0 = g s 1 y c 1. La simulation peut donc en déduire la solution du challenge DL, dès lors que c 0 c 1 mod q : il s agit de s 1 s 0 c 1 c 0 mod q. Il ne reste plus pour arriver au résultat qu à ajouter qu à part avec une probabilité plus petite que 1 q, nous avons c 0 c 1 (mod q), puisque c 0 et c 1 sont des valeurs aléatoires qui ont été retournées par l oracle de hachage durant des étapes indépendantes, au même index de requête. Pour le temps de la réduction, nous obtenons le résultat τ 2τ + 4q s T, en remarquant que l attaquant doit être exécuté deux fois, et que, lors de chaque attaque, pour chaque signature, il est nécessaire de calculer une double exponentiation. 4.6 Nos travaux sur les schémas de signature Après avoir présenté dans ce chapitre le contexte des schémas de signature, nous allons dans les chapitres suivants développer nos travaux sur ce domaine de la cryptographie. Tout d abord, dans le Chapitre 5, nous présentons une nouvelle heuristique pour transformer un schéma de signature et un protocole d identification à divulgation nulle de connaissance en un schéma de signature à réduction fine permettant l usage de coupons. Ensuite, dans le Chapitre 6, nous proposons un nouveau schéma de signature basé sur le problème CDH (dans le modèle de l oracle aléatoire), avec une réduction fine et l usage naturel de coupons. Enfin, dans le Chapitre 7, nous présentons un nouveau schéma de signature basé sur le problème FlexibleRSA (dans le modèle standard). Ce schéma possède lui aussi une réduction fine et permet, dans une de ses variantes, l usage de coupons. 40

Chapitre 5 Une heuristique pour dériver des schémas de signature à réduction fine Sommaire 5.1 Méthode générique proposée......................... 42 5.1.1 Notre construction............................... 42 5.1.2 Sécurité de cette construction......................... 44 5.2 Un exemple concret d application de notre heuristique......... 46 5.2.1 Un schéma de signature à coupon, basé sur le RSA et à réduction fine.. 46 5.2.2 Sécurité de notre exemple........................... 46 5.2.3 Comparaison de notre schéma avec RSA-PSS................ 48 5.2.4 Extensions à d autres problèmes cryptographiques............. 50 5.3 Conclusion.................................... 50 Les schémas basés sur le logarithme discret sont très appréciés, notamment car ils permettent l utilisation de coupons. Il est possible de prouver la sécurité de la plupart d entre eux, dans le modèle de l oracle aléatoire, en utilisant le lemme de bifurcation de David Pointcheval et Jacques Stern [PS96]. Malheureusement, la réduction de sécurité est alors lâche. Au contraire, des schémas basés sur la factorisation, tels que RSA-PSS, permettent une réduction de sécurité fine, toujours dans le modèle de l oracle aléatoire. Cependant,dans ces schémas, il n existe pas de moyen d utiliser des coupons. Ce chapitre introduit une heuristique utilisant un protocole d identification à trois passes à divulgation nulle de connaissance et un schéma de signature vérifiant certaines propriétés de sécurité. Avec ces composantes, notre transformation permet d obtenir un schéma de signature à coupons, avec une réduction de sécurité fine, dans le modèle de l oracle aléatoire. Plus précisément, si ses deux composantes sont sûres, notre schéma de signature l est aussi. En application, nous proposons un schéma de signature à coupons avec une réduction fine au problème RSA. Notre schéma se compare très bien à RSA-PSS, comme il possède une réduction aussi fine tout en permettant en plus l usage de coupons pour de meilleures performances enligne. Approche de Shamir-Tauman. Pour être précis, nous voudrions discuter ici d une autre approche générique qui permet elle aussi d atteindre notre but. Cette technique est due à Adi Shamir et Yael Tauman [ST01]. Leur technique fait usage des fonctions de hachage caméléon. Ces fonctions de hachage, introduites par Hugo Krawczyk et Tal Rabin dans [KR00], sont particulières en ceci qu avec 41

Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine une clé particulière, il est aisé de trouver des collisions. Une telle fonction basée sur le problème DL peut par exemple être H(m, r) = G(g r y m ), où G est une fonction de hachage classique : si le logarithme de y en base g est connu, il est aisé de trouver des collisions. L idée générale d Adi Shamir et Yael Tauman est de générer (m, r ) et de calculer σ = Sign sks (H(m, r )) dans la phase hors-ligne, puis, dans la phase en-ligne, lorsque le message m à signer est connu, de calculer r tel que H(m, r) = H(m, r ). La signature de m est alors (σ, r), et peut être aisément vérifiée en testant si Verify pks (H(m, r), σ) = True. La construction décrite dans ce chapitre est différente, malgré un résultat final à peu près équivalent. Ce chapitre a fait l objet d une publication à la conférence Acns 05 [Che05b]. 5.1 Méthode générique proposée Dans cette section, nous définissons notre nouvelle conversion, puis discutons de sa sécurité et de ses caractéristiques. 5.1.1 Notre construction Le premier ingrédient de notre construction est un Σ-protocole Z (à trois passes), défini, comme présenté dans la Section 4.1.2, par un algorithme d initialisation des paramètres Set Z, un algorithme de génération de clés Gen Z, et des fonctions U : K U, V skz : K G V et W pkz : G V U. Des exemples de tels protocoles sont nombreux, par exemple Schnorr, GQ, PS ou GPS. Le deuxième ingrédient de notre construction est un schéma de signature EUF-KMA-sûr, défini par le quadruplet (Set S, Gen S, Sign, Verify). Ce schéma de signature possède un ensemble de messages H et produit des signatures dans l ensemble T. Comme le schéma est EUF-KMAsûr, il existe un simulateur probabiliste S, qui fabrique à la demande, dans le modèle de l oracle aléatoire, q s paires aléatoires de messages-signatures valides, en un temps polynomial T 0 = poly(q s ). Nous utiliserons ce simulateur dans nos preuves de sécurité. De tels schémas de signature sont typiquement RSA-FDH ou Rabin-FDH. Enfin, le dernier ingrédient de notre construction est une paire de fonctions de hachage G : M T G et H : U H. Notre schéma de signature se construit alors comme suit. Acns 05 [Che05b] Génération de clés : Une paire de clés est générée en exécutant les algorithmes Gen Z et Gen S. La clé publique est (pk Z, pk S ) et la clé secrète est (sk Z, sk S ). Signature : Dans la phase hors-ligne, le signataire génère un aléa k K, et calcule u = U(k), puis h = H(u) et t = Sign sks (h). Une fois le message m M connu, le signataire calcule c = G(m, t) et s = V skz (k, c). La signature de m est σ = (t, s) T V. Vérification : Pour vérifier une signature σ = (t, s) d un message m M, il faut calculer c = G(m, t), u = W pkz (c, s) et h = H(u ). La signature doit être acceptée si et seulement si Verify pks (h, t) = True. 42

5.1. Méthode générique proposée Pour simplifier la description de l étape de vérification, nous avons supposé que les fonctions G et W pkz étaient uniquement définies sur leur espace d entrée M T et G V, de façon à vérifier implicitement que t T et s V. Quand les fonctions G et W sont définies sur des ensembles plus grands, il faut ajouter ces tests sur t et s avant d accepter une signature. Fonctionnement intuitif. Notre étape de signature se déroule intuitivement en trois étapes. Tout d abord, nous calculons un engagement du Σ-protocole. Ensuite, nous le signons avec le schéma de signature. Enfin, à la réception du message, nous retournons la réponse du Σ-protocole, correspondant à un challenge qui vaudrait le haché de ce message et de la signature de l engagement précédemment produite. Taille des signatures. La taille des signatures produites par le schéma précédent est de T + V. Ceci diffère légèrement de la taille du schéma de signature S. Taille des paramètres. Étant une combinaison de deux schémas Z et S, le nouveau schéma contient de nombreux paramètres, qu ils soient publics ou privés. Heureusement, pour des instances particulières, des paramètres peuvent être avantageusement partagés entre le schéma de signature et le protocole d identification. Un exemple concret est donné dans la Section 5.2, basé sur le problème RSA. Performances de l algorithme de signature. Notre schéma est performant lorsqu il est utilisé en mode en-ligne/hors-ligne. Dans cet emploi, le temps du calcul en-ligne est équivalent au temps de calcul d un haché et de l exécution de la fonction V. Or, dans la plupart des protocoles d identification connus et utilisés, le temps de calcul de V est très court. C est notamment le cas avec les schémas Schnorr, GPS et PS, pour lesquels ce calcul consiste en une multiplication et une addition (éventuellement modulaires). Facilité de mise en œuvre. Les briques élémentaires de notre schéma sont des fonctions de hachage, un schéma de signature EUF-KMA-sûr et un Σ-protocole. Ainsi, mettre en œuvre notre schéma est très aisé, puisque ces briques sont parmi les plus classiques de la cryptographie à clé publique. Cela est particulièrement intéressant pour des environnements contraints tels que la carte à puce, où la taille de code est limitée et où les nouveaux développements peuvent être longs. De plus, des routines déjà testées contre les attaques à canaux cachés (voir la Partie IV, qui est consacrée à ces attaques) ou les attaques par fautes peuvent servir de base à notre construction, assurant ainsi sa propre sécurité contre les attaques physiques. Enfin, la gestion des clés publiques peut être faite en réutilisant l infrastructure existante (PKI), si les schémas S et Z préexistent eux-mêmes dans la PKI. Comparaison avec les techniques de [EGM89] et [ST01]. L approche de [EGM89] est plus rapide que la nôtre, mais impose de construire des signatures bien plus longues. Au contraire, la construction de [ST01] est bien plus proche de celle présentée dans ce chapitre, même si elle est a priori basée sur un design différent. Le même niveau de sécurité est atteint : [ST01] est basé, de façon fine, sur le problème de trouver des collisions avec une fonction de hachage caméléon et sur celui de falsifier avec un schéma de signature EUF-CMA-sûr ; la sécurité de notre construction, comme montré dans la suite de ce chapitre, se réduit, elle aussi de façon fine, à la difficulté de retrouver la clé secrète du protocole d identification Z ou de falsifier avec un schéma de signature EUF-KMA-sûr S. La récente publication [KH06], qui a redécouvert indépendamment nos résultats, explique le lien très étroit découvert entre notre construction et celle de [ST01]. 43

Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine 5.1.2 Sécurité de cette construction Dans cette section, nous allons montrer qu un attaquant EUF-CMA contre notre schéma peut être utilisé pour attaquer soit le Σ-protocole Z, soit le schéma de signature. Plus précisément, nous allons, dans le modèle de l oracle aléatoire, prouver que si l attaquant exhibe une falsification existentielle sur notre construction, nous pouvons soit retrouver la clé du protocole d identification Z, soit falsifier une nouvelle signature du schéma S, avec une probabilité approximativement égale à celle de l attaquant. Ainsi, si les deux briques utilisées dans la construction sont sûres, l ensemble l est également. Théorème 3. Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma proposé Section 5.1.1, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors il est possible d utiliser cet attaquant pour soit retrouver la clé du Σ-protocole Z, soit exhiber une falsification existentielle du schéma de signature S, avec une probabilité ε et en un temps τ, tels que ε ε (q h + q s ) q s T (q h + q s ) 2 H (q h + q s ) 2 G et τ τ + q s T W + T 0 où T W est le temps de calculer W et T 0 est le temps nécessaire au simulateur S pour calculer q s paires de message-signatures. Dans notre publication [Che05b], nous avons utilisé le formalisme des jeux incrémentaux, comme défini notamment par Victor Shoup. Ici, du fait de la simplicité de la preuve, nous ferons une preuve classique. Démonstration. Notre réduction reçoit un Σ-protocole Z ainsi qu un schéma de signature S EUF-KMA-sûr. Elle utilise alors un attaquant contre le schéma de signature de la Section 5.1.1 formé à partir de ces deux briques, pour soit retrouver la clé du Σ-protocole Z, soit falsifier une nouvelle signature pour S. Par définition, l attaquant A, après avoir eu droit à q H requêtes à un oracle de hachage H, q G requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. Notons q h = q H + q G. L attaquant A est utilisé avec la simulation suivante. Préparation de la réduction : Avant d initialiser A, la réduction tire q s paires aléatoires (c i, s i ) G V, et calcule la valeur u i = W pkz (c i, s i ) correspondante. Sans perte de généralité, nous supposons dans la suite que les u i ainsi obtenus sont différents, car sinon, par la propriété du Σ-protocole, la simulation peut en déduire la clé du protocole Z et la réduction termine ainsi avec succès. Ensuite, la réduction utilise le simulateur S, pour obtenir q s paires aléatoires de message-signature (h i, t i ) H T. À ce moment-là, la réduction pose H(u i ) = h i. Comme l attaquant n a pu faire encore de requêtes à l oracle de hachage et comme les u i sont différents, ceci ne peut provoquer de problèmes de définition de H. De plus, comme les paires générées par le simulateur S 44

5.1. Méthode générique proposée sont aléatoires, de telles définitions de l oracle ne modifient pas la distribution des sorties de H. Initialisation : A est initialisé avec les clés publiques et paramètres correspondant aux schémas S et Z. Réponse à une nouvelle requête G : le simulateur retourne un nombre aléatoire dans Z q. Réponse à une nouvelle requête H : la simulation retourne un nombre aléatoire dans H. Réponse à une requête de signature sur un message m i M : pour la requête i de signature, la simulation procède comme suit. Si la valeur G(m i, t i ) est déjà définie, la simulation s arrête et la réduction échoue (Événement 1). Dans le cas contraire, la simulation pose G(m i, t i ) = c i. La signature (t i, s i ) est retournée à l attaquant. Nous pouvons remarquer qu elle est bien valide, comme c i = G(m i, t i ), u i = W pkz (c i, s i ), h i = H(u i ) et Verify pks (h i, t i ) = True. Ainsi, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors de l événement suivant : Événement 1 : comme les paires (h i, t i ) générées par la simulation sont aléatoires, l attaquant ne peut deviner la valeur des t i, avant d avoir reçu la réponse à la i-ème requête de signature. Aussi, la probabilité de l Événement 1 est bornée par (q h+q s) q s T. Utilisation de la falsification : À part lors de l événement précédent, la simulation est parfaite pour l attaquant A, et celui-ci retourne donc avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Si l attaquant échoue, notre réduction échoue. Dans le cas contraire, l attaquant retourne σ = (t, s) avec le message m lui correspondant. La réduction calcule alors les données correspondant à cette falsification, c est-à-dire c = G(m, t), u = W pkz (c, s) et h = H(u). Dans un premier cas, h h i, pour tout i. Dans ce cas, notre réduction peut retourner une falsification sur le schéma de signature S : en effet, t est une falsification existentielle valide du message h. Dans un deuxième cas, pour un i particulier, h = h i. Alors, soit l attaquant a trouvé une collision sur la fonction de hachage H (Événement 2), soit u = u i. Ainsi, si l Événement 2 n a pas eu lieu, u = u i et par la propriété de sécurité du Σ-protocole, notre réduction peut retrouver la clé en temps polynomial, sauf si c = c i (Événement 3). Ainsi, à part deux événements, la réduction peut soit retrouver la clé du Σ-protocole Z, soit réaliser une falsification existentielle sur le schéma de signature S. Calculons la probabilité de ces deux événements fatals pour la réduction. L Événement 2 n est possible, dans le modèle de l oracle aléatoire, qu avec une probabilité plus petite que (q h+q s) 2 H. De même, l Événement 3 n est possible, dans le modèle de l oracle aléatoire, qu avec une probabilité plus petite que (q h+q s) 2 G Aussi, nous pouvons conclure que notre réduction a une probabilité de succès ε satisfaisant ε ε (q h + q s ) q s T (q h + q s ) 2 H De plus, le temps de notre réduction τ est majorée comme suit τ τ + q s T W + T 0. (q h + q s ) 2 G. 45

Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine 5.2 Un exemple concret d application de notre heuristique Dans cette section, nous donnons un exemple type de ce que peut donner notre construction. Cet exemple est basé sur le problème RSA. Il utilise la signature RSA-FDH et le protocole d identification PS comme briques de base. 5.2.1 Un schéma de signature à coupon, basé sur le RSA et à réduction fine Comme précédemment expliqué, les coupons ne sont pas supportés dans les signatures RSA et ses variantes, y compris le schéma de signature déduit du protocole d identification GQ. Le schéma que nous proposons ici répond à ce besoin, tout en assurant une sécurité fine sur le problème RSA, dans le modèle de l oracle aléatoire. Pour ce schéma, nous utilisons un module RSA n de l n bits, dont la factorisation (p, q) est gardée secrète par le signataire. Ce module est commun aux briques RSA-FDH et PS. Comme dans le schéma RSA, la clé contient également un exposant public e, premier avec (p 1)(q 1), et un exposant privé d = e 1 mod λ(n). Enfin, comme dans PS, nous utilisons la valeur secrète x = n mod φ(n) et une base g Z n. Nous utilisons également deux fonctions de hachage H : Z n Z n et G : M Z n {0, 1} lg, et un paramètre de sécurité l. Typiquement, l n = 1024, l g = 160 et l = 110 pour un nombre autorisé de requêtes à l oracle de signature de q s = 2 30. Notre schéma se décrit alors comme suit. Acns 05 [Che05b] Génération de clés : L utilisateur génère un module RSA n = pq et un exposant public e, tel que e et (p 1)(q 1) soient premiers entre eux. Ensuite, il calcule x = p + q 1 et d = e 1 mod λ(n). Enfin, il tire une base g Z n. La clé publique est (e, n, g) tandis que la clé secrète est (x, d). Signature : Pour calculer un coupon, le signataire génère un aléa k {0, 1} ln 2 +lg+l+1, et calcule u = g k mod n, puis t = H(u) d mod n. Une fois le message m M connu, le signataire calcule c = G(m, t) et s = k +x c. La signature de m est σ = (t, s) Z n {0, 1} ln 2 +lg+l+2. Vérification : Pour vérifier une signature σ = (t, s) d un message m M, il faut calculer c = G(m, t), u = g s n c mod n. La signature est alors validée si H(u ) = t e mod n et s {0, 1} ln 2 +lg+l+2. Pour montrer la sécurité de ce schéma, nous ne pouvons utiliser directement le théorème de la section précédente, car la fonction de hachage H et la fonction de hachage incluse dans RSA-FDH ont été mixées. Cependant, une telle modification n implique que peu de changements dans la preuve, comme nous allons le montrer. 5.2.2 Sécurité de notre exemple Dans cette section, nous allons montrer qu un attaquant EUF-CMA contre notre schéma peut être utilisé pour résoudre le problème RSA. Plus précisément, nous allons, dans le modèle de l oracle aléatoire, prouver que si l attaquant exhibe une falsification existentielle sur notre construction, nous pouvons résoudre une instance quelconque (n, e, y) du problème RSA. 46

5.2. Un exemple concret d application de notre heuristique Théorème 4. Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma proposé Section 5.2.1, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors il est possible d utiliser cet attaquant pour résoudre le problème RSA, avec une probabilité ε et en un temps τ, tels que et ε ε (q h + q s ) q s 2 ln 1 (q h + q s ) 2 2 lg 2 l q s τ τ + (2q s + q h )T où T est le temps pour calculer une exponentiation modulo n. Nous reprenons le déroulement de la preuve générique de notre publication [Che05b], tout en prenant le cas particulier de la fonction RSA comme exemple de fonction auto-réductible, pour plus de lisibilité. Démonstration. Notre réduction reçoit une instance quelconque (n, e, y) du problème RSA. Elle utilise alors un attaquant contre le schéma de signature de la Section 5.2.1 pour la résoudre. Par définition, l attaquant A, après avoir eu droit à q H requêtes à un oracle de hachage H, q G requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. Notons q h = q H + q G. L attaquant A est utilisé avec la simulation suivante. Préparation de la réduction : Avant d initialiser A, la réduction donne à la base g la valeur g = y. Alors, elle tire q s paires aléatoires (c i, s i ) {0, 1} lg {0, 1} ln 2 +lg+l+1, et calcule les valeurs u i = g s i n c i mod n correspondantes. Ensuite, la réduction prend q s valeurs aléatoires t i Z n, et pose H(u i ) = h i = t e i mod n. Bien sûr, si deux u i sont identiques, nous reprenons le même t i pour assurer la cohérence de la fonction de hachage. La simulation est quasiment parfaite, à part le fait que les s i générés sont statistiquement indistinguables de ce qu un véritable signataire retournerait, avec un biais de 2 l q s. Initialisation : A est initialisé avec la clé publique (e, n, g). Réponse à une nouvelle requête G : le simulateur retourne un aléa dans {0, 1} lg. Réponse à une nouvelle requête H : le simulateur tire un nombre aléatoire k Z n, et retourne y k e mod n. Réponse à une requête de signature sur un message m i M : pour la requête i de signature, la simulation procède comme suit. Si la valeur G(m i, t i ) est déjà définie, la simulation s arrête et la réduction échoue (Événement 1). Dans le cas contraire, la simulation pose G(m i, t i ) = c i. La signature (t i, s i ) est retournée à l attaquant. Nous pouvons remarquer qu elle est bien valide, comme c i = G(m i, t i ), u i = g s i n c i mod n, H(u i ) = t e i mod n et s i {0, 1} ln 2 +lg+l+2. Ainsi, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors de l événement suivant : Événement 1 : comme les t i sont générés par le simulateur aléatoirement, l attaquant ne peut deviner leur valeur, avant d avoir reçu la réponse à la i-ème requête de signature. Aussi, la probabilité de l Événement 1 est bornée par (q h+q s) q s 2 ln 1. 47

Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine Utilisation de la falsification : À part lors de l événement précédent, la simulation est parfaite pour l attaquant A, et celui-ci retourne donc avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Si l attaquant échoue, notre réduction échoue elle aussi. Dans le cas contraire, l attaquant retourne σ = (t, s) avec le message m lui correspondant. La réduction calcule alors les données correspondant à cette falsification, c est-à-dire c = G(m, t), u = g s n c mod n et h = H(u). Il y a alors deux cas : soit u = u i pour un i donné, soit u u i pour tout i. Si u = u i, s n c = s i n c i (mod Q), où Q est l ordre g = y. Ainsi s s i + n (c i c) = 0 (mod Q). D après les tailles de ces entiers, s s i + n(c i c) 0, sauf si c i = c et s = s i. Ceci est impossible, sauf si l attaquant trouve une collision sur la fonction de hachage G (Événement 2). Ainsi, mis à part cet événement, la réduction peut retrouver un multiple non-nul de l ordre de g. Elle peut alors découper s s i +n(c i c) en s s i +n(c i c) = e j Q, où e Q et j 0. Comme e est premier avec φ(n), e est premier avec l ordre de y, et donc Q est un multiple non nul de l ordre Q de y. La réduction peut ainsi calculer d = e 1 mod Q, et en déduire la solution x = y d mod n du problème RSA. Si u u i pour tout i, la réduction peut retrouver dans sa mémoire le k Z n, tel que h = y k e mod n, comme la valeur h = H(u) a été définie par une requête de hachage, et non lors de la préparation de la réduction. Grâce à la signature de l attaquant t = h d mod n, la réduction peut alors calculer la solution du problème y d mod n = t k 1 mod n. Enfin, nous terminons notre preuve en remarquant que l Événement 2 n est possible, dans le modèle de l oracle aléatoire, qu avec une probabilité plus petite que (q h+q s) 2. 2 lg Aussi, nous pouvons conclure que notre réduction a une probabilité de succès ε satisfaisant ε ε (q h + q s ) q s 2 ln 1 (q h + q s ) 2 2 lg 2 l q s. De plus, le temps de notre réduction τ est majorée comme suit τ τ + (2q s + q h )T. Ainsi, ce schéma est aussi sûr que RSA-PSS, mais présente le grand avantage de donner la possibilité de calculer des coupons, pour une utilisation extrêmement rapide en-ligne. Grâce à ce système, générer une signature est aussi rapide que la deuxième étape de PS, c est-à-dire que cela consiste à calculer un haché, et à effectuer une multiplication et une addition dans les entiers. Encore une fois, cette rapidité n est pas au prix d une sécurité plus faible, puisque nous n avons pas besoin du lemme de bifurcation pour prouver la sécurité de notre schéma, et qu ainsi, notre réduction est fine. Une comparaison plus précise de notre schéma avec RSA-PSS est donné dans la section suivante. 5.2.3 Comparaison de notre schéma avec RSA-PSS RSA-PSS est décrit dans le standard des schémas de signature [PKCS1] et est utilisé dans le monde entier. Nous comparons donc notre schéma avec cette référence des signatures basées sur le problème RSA. 48 Nous avons supposé bien sûr ici que l g + l + 2 < ln, pour des paramètres raisonnables. 2

5.2. Un exemple concret d application de notre heuristique Dans la suite, nous supposons que nous désirons un niveau de sécurité du schéma de κ = 80 bits, pour un nombre maximal de requêtes de signature de q s = 2 30. Nous prenons alors un paramètre l = κ + log 2 q s = 110, et nous utilisons un module de longueur supérieure ou égale à 1024 bits, correspondant selon les algorithmes de factorisation connus à ce jour à un niveau de sécurité de 80 bits. Taille des fonctions de hachage. Grâce au Théorème 4, nous pouvons déduire qu une taille l g = 162 est suffisante pour un attaquant qui peut effectuer q h = 2 80 oracles de hachage (dans le modèle de l oracle aléatoire). Taille des paramètres. Dans RSA-PSS, les éléments publics sont n et e (e est habituellement choisi petit, par exemple e = 2 16 + 1), et la clé privée est d. Dans notre schéma, la clé publique est e, n et g, et la clé privée est constituée de d et x. Cependant, le coût des paramètres supplémentaires de notre système peut être réduit. En effet, d et x peuvent être compressés, si la taille des paramètres est plus importante que le temps de signature. En ne prenant comme clé privée que d et k d = ed 1 φ(n) (qui est un élément de la même taille que e), il est possible de retrouver durant le calcul de la signature la valeur x = n mod ed 1 k d. Il est même possible (comme dans RSA-PSS) de ne stocker que p comme clé privée, puis durant la phase de signature, de retrouver q = n p, et d en dériver les valeurs de d et de x. Ainsi, la clé publique de notre schéma est à peu près de même taille que celle de RSA-PSS, et la clé privée est de 50% plus longue, même si, en perdant un peu d efficacité, il est possible de la réduire à une taille équivalente. Taille des signatures. Les signatures RSA-PSS font l n bits, alors que celles de notre schéma font environ 3 2 l n + 3l + log 2 q s bits. L avantage pour RSA-PSS est ici conséquent, même si nos signatures sont toutefois moins de deux fois plus longues. Performances de l algorithme de signature. Comme mentionné précédemment, notre schéma est essentiellement utile pour une utilisation en-ligne/hors-ligne, où il prend tout son intérêt. Dans ce cas, la comparaison des temps d exécution rend notre schéma très attractif : RSA-PSS nécessite une exponentiation pouvant être accélérée grâce à l utilisation du théorème des restes chinois [QC82] (CRT), avec, à la clé, un gain asymptotique d un facteur 4 des exponentiations modulo n alors que la phase en-ligne de notre schéma est faite en seulement un calcul de haché, une addition et une multiplication dans les entiers. De façon claire, quand il est utilisé avec des coupons, notre schéma est plus rapide que RSA-PSS de plusieurs ordres de grandeur. Facilité de mise en place. Notre schéma et RSA-PSS utilisent essentiellement les mêmes briques de base. Nous pouvons donc aisément réutiliser les parties développées pour RSA-PSS pour notre schéma, rendant la mise en place de celui-ci des plus simples. C est notamment le cas pour la gestion des clé publiques (PKI), qui peut être commune aux deux systèmes. Sécurité. Comme nous l avons vu en Section 5.2.2, notre schéma possède une réduction fine sur le problème RSA, dans le modèle de l oracle aléatoire, tout comme RSA-PSS. Conclusion. D après cette comparaison, nous en déduisons que si la taille des signatures n est pas le paramètre le plus critique et si le schéma de signature peut être utilisé en-ligne, notre schéma peut être préféré à RSA-PSS, comme il propose une amélioration significative des performances, tout en assurant le même niveau de sécurité. 49

Chapitre 5. Une heuristique pour dériver des schémas de signature à réduction fine 5.2.4 Extensions à d autres problèmes cryptographiques Comme décrite dans la Section 5.1, notre méthode est absolument générique, et s applique donc à d autres exemples que celui donné en Section 5.2, et à d autres problèmes que RSA. Les meilleures combinaisons sont celles dans lesquelles le schéma de signature sous-jacent et le Σ-protocole reposent sur un problème cryptographique de même type. Ainsi, une solution intéressante est obtenue en combinant la signature EDL [CP92, JS99, GJ03], qui possède une preuve de sécurité fine sur le CDH et le protocole d identification Schnorr. Comme le problème DL est plus difficile que le problème CDH, l ensemble donne un schéma de signature à coupons, avec une réduction fine au CDH dans le modèle de l oracle aléatoire. Néanmoins, la suite de nos recherches nous a amenés à trouver une solution plus efficace, donnant lieu à la publication [Che05a] et exposée dans le Chapitre 6. Un autre exemple est obtenu en combinant PS et Rabin-FDH [Rab79], pour obtenir un schéma basé sur la factorisation, à coupons et réduction fine dans le modèle de l oracle aléatoire. 5.3 Conclusion Dans ce chapitre, nous avons introduit une heuristique utilisant un protocole d identification à trois passes à divulgation nulle de connaissance et un schéma de signature vérifiant certaines propriétés de sécurité. Avec ces composantes, notre transformation permet d obtenir un schéma de signature à coupons, avec une réduction de sécurité fine, dans le modèle de l oracle aléatoire. Plus précisément, si ses deux composantes sont sûres, notre schéma de signature l est aussi. En application, nous avons proposé un schéma de signature à coupons avec une réduction fine au problème RSA. Notre schéma se compare très bien à RSA-PSS, comme il possède une réduction aussi fine tout en permettant en plus l usage de coupons pour de meilleures performances enligne. 50

Chapitre 6 Un schéma de signature efficace basé sur le CDH Sommaire 6.1 Le schéma de signature EDL......................... 52 6.1.1 Présentation du schéma............................ 52 6.1.2 Sécurité du schéma EDL............................ 52 6.1.3 Caractéristiques du schéma de signature EDL................ 54 6.2 Les schémas de signature de Katz-Wang.................. 54 6.2.1 Présentation du schéma KW-CDH....................... 55 6.2.2 Sécurité du schéma KW-CDH......................... 55 6.2.3 Présentation du schéma KW-DDH....................... 57 6.2.4 Sécurité du schéma KW-DDH......................... 58 6.3 Un nouveau schéma de signature...................... 59 6.3.1 Une étape de notre construction........................ 60 6.3.2 Description de notre schéma.......................... 61 6.3.3 Preuve de sécurité de notre schéma...................... 61 6.3.4 Utilisation de coupons dans notre schéma.................. 63 6.3.5 Taille des paramètres.............................. 64 6.3.6 Comparaison de notre schéma avec EDL, KW-CDH et autres schémas... 65 6.3.7 Derniers raffinements.............................. 66 6.3.8 À propos du test d appartenance de z à G.................. 66 6.4 Conclusion.................................... 67 Lors de la conférence Eurocrypt 03, Eu-Jin Goh et Stanislaw Jarecki ont montré que, contrairement aux autres schémas de signature basés sur le logarithme discret, le schéma de signature EDL avait une réduction de sécurité fine au problème calculatoire Diffie-Hellman (CDH), dans le modèle de l oracle aléatoire. Ces auteurs ont également remarqué que le schéma de signature EDL pouvait être transformé en un schéma de signature à coupons, en utilisant la technique générique d Adi Shamir et Yael Tauman, technique basée sur les fonctions de hachage caméléon. Dans ce chapitre, nous proposons un nouveau schéma de signature qui présente également une réduction de sécurité fine au problème CDH, mais pour lequel les signatures produites sont plus courtes que celles d EDL. De plus, de façon similaire au schéma de signature Schnorr (mais contrairement à EDL), le schéma proposé permet l utilisation de coupons de façon extrêmement naturelle, sans calculs supplémentaires et sans que l algorithme de vérification ne soit modifié. Dans le cas des courbes elliptiques, notre schéma améliore de 25% l état de l art des schémas de signature basés sur le logarithme discret, tout en gardant le même niveau de sécurité. Ce chapitre a fait l objet d une publication à la conférence Crypto 05 [Che05a]. 51

Chapitre 6. Un schéma de signature efficace basé sur le CDH 6.1 Le schéma de signature EDL 6.1.1 Présentation du schéma Le schéma de signature EDL, indépendamment proposé dans [CP92, JS99] et prouvé sûr dans [GJ03] est défini comme suit. Signature EDL [CP92, JS99, GJ03] Initialisation des paramètres : Soient l p, l q, et l r des paramètres de sécurité, avec, pour des cas d utilisations normales, l r l q. Soit G le groupe cyclique d ordre q, engendré par g, où q est un premier de l q bits et la représentation des éléments de G est incluse dans {0, 1} lp. Enfin, soient H : M {0, 1} lr G \ {1} et G : G 6 Z q deux fonctions de hachage. Génération de clés : La clé privée est un nombre aléatoire x Z q. La clé publique correspondante est y = g x. Signature : Pour signer un message m M, le signataire choisit un nombre aléatoire r {0, 1} lr, et calcule h = H(m, r) et z = h x. Ensuite, le signataire prouve une égalité de logarithmes, c est-à-dire que DL h (z) = DL g (y). Pour cela, il tire un autre aléa k Z q, et calcule u = g k, v = h k, c = G(g, h, y, z, u, v) et s = k + cx mod q. La signature ainsi produite du message m est σ = (z, r, s, c) G {0, 1} lr Z q 2. Vérification : Pour vérifier une signature σ = (z, r, s, c) d un message m M, il faut calculer h = H(m, r), u = g s y c et v = h s z c. La signature σ est alors acceptée si et seulement si c = G(g, h, y, z, u, v ) et z G. Dans EDL, la seule quantité qui peut être précalculée avant de connaître le message est u. Ainsi, la partie en-ligne consiste en un calcul de deux hachés et de deux exponentiations modulaires. 6.1.2 Sécurité du schéma EDL Dans cette partie, nous réduisons la sécurité du schéma EDL à la sécurité du problème calculatoire Diffie-Hellman. La preuve suit l idée originalement présentée dans [GJ03], et consiste à montrer que l étape de vérification est une preuve que DL h (z) = DL g (y) = x. Théorème 5 ([GJ03]). Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma EDL, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors le problème calculatoire Diffie-Hellman peut être résolu avec une probabilité ε et en un temps τ, tels que ( ε qs + q h ε q s q (q 1) + q ) s + q h q h 2 lr q et τ τ + (6q s + q h )τ 0, où τ 0 désigne le temps d une exponentiation dans G. 52

6.1. Le schéma de signature EDL Démonstration. La réduction reçoit en entrée un groupe G ainsi qu un challenge CDH (g, y = g x, A = g a ). Nous utilisons alors l attaquant A contre le schéma de signature EDL pour résoudre ce challenge, c est-à-dire pour calculer g ax. Par définition, l attaquant A, après avoir eu droit à q H requêtes à un oracle de hachage H, q G requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. Notons q h = q H + q G. L attaquant A est utilisé avec la simulation suivante. Initialisation : A est initialisé avec les paramètres publics (g, q, G) et la clé publique y. Réponse à une nouvelle requête G(g, h, y, z, u, v) : le simulateur retourne un nombre aléatoire dans Z q. Réponse à une nouvelle requête H(m, r) : le simulateur tire un nombre aléatoire d Z q, et retourne A d. Réponse à une requête de signature sur un message m i M : le simulateur tire alors un aléa r {0, 1} lr. Si H(m i, r) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 1). Dans le cas contraire, le simulateur génère un nombre aléatoire κ Z q, pose h = H(m i, r) = g κ et calcule z = y κ nous pouvons alors remarquer que DL h (z) = DL g (y) (= x). Puis, le simulateur tire deux aléas (s, c) Z q Z q et calcule u = g s y c et v = h s z c. Si G(g, h, y, z, u, v) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 2). Sinon, le simulateur pose G(g, h, y, z, u, v) = c et retourne la signature valide (z, r, s, c). Comme nous pouvons le voir, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors des événements suivants : Événement 1 : comme r est un aléa de {0, 1}lr, la probabilité que H(m, r) soit déjà posé est plus petite que q H+q s 2 lr, lors d une requête de signature. Pour l ensemble des q s requêtes de signature, la probabilité d apparition de l Événement 1 est donc majorée par qs (q H+q s) 2 lr. Événement 2 : d après la simulation des requêtes de signature, les entrées de l oracle G sont de la forme (g, h, y, z, u, v) = (g, g κ, y, y κ, g k, g κk ) avec (k, κ) Z q Z q. De plus, comme l Événement 1 n a pu arriver, la valeur de H(m, r) n est pas encore définie, et donc κ est totalement aléatoire aux yeux de l adversaire. Aussi, la probabilité que G(g, h, y, z, u, v) ait déjà été posé est plus petite que q G+q s q (q 1), pour une requête de signature donnée. Pour l ensemble des requêtes de signature, la probabilité d apparition de l Événement 2 est donc bornée par qs (q G+q s) q (q 1). Résolution du challenge CDH : À part lors des événements précédemment étudiés, la simulation est parfaite pour l attaquant A, et celui-ci retourne donc avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Si l attaquant échoue, la réduction échoue. Dans le cas contraire, l attaquant retourne σ = (z, r, s, c) avec le message m lui correspondant. Alors, la réduction retrouve dans l historique de la simulation la valeur d 0 correspondant à h = H(m, r), puisque, comme m est un message qui n est pas apparu dans les simulations de signature, H(m, r) a forcément été défini comme un A d. Si nous supposons pour l instant que DL h (z) = DL g (y) = x, la solution du challenge CDH est alors facilement calculée par la réduction : il s agit de z 1/d mod q. La valeur de d est connue, même si l attaquant n a pas demandé H(m, r) lors de la simulation, car alors l appel à l oracle H est fait par la procédure de vérification. 53

Chapitre 6. Un schéma de signature efficace basé sur le CDH Ainsi, le point principal restant dans cette démonstration est de prouver que DL h (z) = DL g (y) = x. Calculons la probabilité que l attaquant retourne une falsification valide telle que DL h (z) DL g (y) = x. Pour cela, posons k = DL g (u), k = DL h (v) et x = DL h (z), c est-à-dire u = g k, v = h k et z = h x, ce qui est possible puisque g et h sont des générateurs de G. Il s ensuit alors que, comme la falsification est valide, k = s cx mod q et k = s cx mod q. C est pourquoi, si x x, c = G(g, h, y, h x, g k, h k ) = k k x x mod q. Or, comme les valeurs de sortie de G dans la simulation (qu elles soient définies dans les requêtes directes à l oracle G ou dans les requêtes de signature) sont aléatoires, une telle relation ne peut être satisfaite qu avec une probabilité q G q. Aussi, nous pouvons conclure que la réduction a une probabilité de succès ε satisfaisant ε ε q s ( qs + q h q (q 1) + q s + q h 2 lr De plus, le temps de la réduction τ est majorée par τ τ + (6q s + q h )τ 0. ) q h q. 6.1.3 Caractéristiques du schéma de signature EDL Le schéma de signature EDL est prouvé sûr sous l hypothèse de difficulté du problème calculatoire Diffie-Hellman. De plus, la réduction est fine. Ainsi, la sécurité de ce schéma est un de ses points forts. Dans ce schéma, les signatures sont longues de (l p +2l q +l r ) bits. Cela peut paraître long mais il faut relativiser cette taille, étant donné la sécurité de ce schéma. Des paramètres classiques sont l q = 176 et l r = 111, l p variant en fonction du groupe utilisé. Dans son usage classique, le schéma ne peut être utilisé avec des coupons. Cependant, comme noté par Eu-Jin Goh et Stanislaw Jarecki, il est possible d utiliser la technique générique d Adi Shamir et Yael Tauman [ST01], technique basée sur les fonctions de hachage caméléon [KR00]. Nous appelons dans la suite EDL-CH l ensemble formé par cette technique générique et par EDL. Falsifier une signature EDL-CH est équivalent à falsifier une signature du schéma EDL ou à trouver une collision sur la fonction de hachage caméléon. Aussi, il est intéressant d utiliser une fonction de hachage caméléon dont la résistance aux collisions est elle-même basée sur le DL ou le CDH (par exemple, H(m, r) = H 0 (g m y r ), où H 0 : G G est une fonction de hachage). Malheureusement, le coût de la technique de coupons est alors une vérification plus lente. De plus, utiliser la fonction de hachage H(m, r) = H 0 (g m y r ) implique le fait que le nombre aléatoire r doit être tiré dans Z q (et non plus dans {0, 1} lr ). Cela rend les signatures EDL-CH légèrement plus longues que celles d EDL : elles font (l p + 3l q ) bits. 6.2 Les schémas de signature de Katz-Wang Dans [KW03], Jonathan Katz et Nan Wang ont proposé deux modifications au schéma EDL. La première est un schéma proche de EDL (et notamment avec une réduction fine sur le CDH), mais avec des signatures plus courtes, alors que la deuxième est un schéma avec réduction fine sur le DDH. Nous noterons ces schémas respectivement KW-CDH et KW-DDH. C est notamment ici qu il est nécessaire que la sortie de la fonction de hachage H soit G \ {1} et non G Ainsi, dans [GJ03], les auteurs estiment que si le problème du logarithme discret est supposé infaisable pour des premiers de 1000 bits, le lemme de bifurcation nous assure seulement de la sécurité des signatures Schnorr dans un groupe modulo un premier de 8000 bits. 54

6.2.1 Présentation du schéma KW-CDH 6.2. Les schémas de signature de Katz-Wang L idée de Jonathan Katz et Nan Wang est de remplacer l aspect aléatoire de r par une imprédictibilité. Plus précisément, les auteurs remplacent r par un bit b qui peut être seulement calculé par le signataire (par exemple, b pourrait être le résultat d une fonction pseudo-aléatoire, sous une clé secrète incluse dans la clé de signature). En d autres termes, signer plusieurs fois un même message avec EDL ferait intervenir différents aléas r, alors qu avec KW-CDH, le bit b resterait le même. La signature est alors (z, s, c, b), et est donc plus courte de 110 bits que la signature du schéma EDL. Signature KW-CDH [KW03] Initialisation des paramètres : Soient l p et l q des paramètres de sécurité. Soit G le groupe cyclique d ordre q, engendré par g, où q est un premier de l q bits et la représentation des éléments de G est incluse dans {0, 1} lp. Soient H : M {0, 1} G \ {1} et G : G 6 Z q deux fonctions de hachage. Enfin, soit Ψ. une famille de fonctions pseudo-aléatoires. Génération de clés : La clé privée est un nombre aléatoire x Z q, et une clé ς pour la famille de fonctions pseudo-aléatoires. La clé publique correspondante est y = g x. Signature : Pour signer un message m M, le signataire calcule tout d abord b = Ψ ς (m), puis h = H(m, b) et z = h x. Ensuite, le signataire prouve une égalité de logarithmes, c est-à-dire que DL h (z) = DL g (y). Pour cela, il tire un aléa k Z q, et calcule u = g k, v = h k, c = G(g, h, y, z, u, v) et s = k + cx mod q. La signature ainsi produite du message m est σ = (z, b, s, c) G {0, 1} Z q 2. Vérification : Pour vérifier une signature σ = (z, b, s, c) d un message m M, il faut calculer h = H(m, b), u = g s y c et v = h s z c. La signature σ est alors acceptée si et seulement si c = G(g, h, y, z, u, v ) et z G. Comme dans EDL, dans ce schéma, la seule quantité qui peut être précalculée avant de connaître le message est u. 6.2.2 Sécurité du schéma KW-CDH Dans cette partie, nous réduisons la sécurité du schéma KW-CDH à la sécurité du problème calculatoire Diffie-Hellman. La preuve suit l idée originalement présentée dans [KW03]. Théorème 6 ([KW03]). Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma KW-CDH, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors le problème calculatoire Diffie-Hellman peut être résolu avec une probabilité ε et en un temps τ, tels que et ε ε 2 q s(q s + q h ) q q h q τ τ + (6q s + q h )τ 0, où τ 0 désigne le temps d une exponentiation dans G. 55

Chapitre 6. Un schéma de signature efficace basé sur le CDH Démonstration. La réduction reçoit en entrée un groupe G ainsi qu un challenge CDH (g, y = g x, A = g a ). Nous utilisons alors l attaquant A contre le schéma de signature KW-CDH pour résoudre ce challenge, c est-à-dire pour calculer g ax. Par définition, l attaquant A, après avoir eu droit à q H requêtes à un oracle de hachage H, q G requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. Notons q h = q H + q G. Dans la réduction, nous supposons la fonction pseudo-aléatoire Ψ. parfaite, c est-à-dire retournant un nombre parfaitement aléatoire pour chaque nouvelle requête : elle est alors simulée en utilisant une fonction aléatoire B : M {0, 1}. L attaquant A est utilisé avec la simulation suivante. Initialisation : A est initialisé avec les paramètres publics (g, q, G) et la clé publique y. Réponse à une nouvelle requête G(g, h, y, z, u, v) : le simulateur retourne un nombre aléatoire dans Z q. Réponse à une nouvelle requête H(m, b) : le simulateur calcule la valeur du bit aléatoire b 0 correspondante au message m, c est-à-dire b 0 = B(m). si b = b 0, alors le simulateur tire κ Z q, et retourne g κ comme réponse de l oracle ; si b b 0, alors le simulateur tire d Z q, et retourne A d comme réponse de l oracle. Réponse à une requête de signature sur un message m i M : le simulateur calcule la valeur du bit aléatoire b 0 correspondante au message m i, c est-à-dire b 0 = B(m), et pose b = b 0, puis demande à l oracle H la valeur de H(m i, b). Par définition de cet oracle et de b 0, le simulateur connaît la valeur κ, telle que h = H(m i, b) = g κ. Le simulateur peut donc aisément calculer z = y κ nous pouvons alors remarquer que DL h (z) = DL g (y) (= x). Puis, le simulateur tire deux aléas (s, c) Z q Z q et calcule u = g s y c et v = h s z c. Si G(g, h, y, z, u, v) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 1). Sinon, le simulateur pose G(g, h, y, z, u, v) = c et retourne la signature valide (z, b, s, c). Comme nous pouvons le voir, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors d un événement : Événement 1 : d après la simulation des requêtes de signature, les entrées de l oracle G sont de la forme (g, h, y, z, u, v) = (g, g κ, y, y κ, g k, g κk ) avec (k, κ) Z q Z q. Contrairement à la preuve d EDL, ici, la valeur de H(m, b) peut être déjà définie, et donc κ n est pas aléatoire aux yeux de l adversaire. Aussi, la probabilité que G(g, h, y, z, u, v) ait déjà été posé est plus petite que q G+q s q, pour une requête de signature donnée. Pour l ensemble des requêtes de signature, la probabilité d apparition de l Événement 1 est donc bornée par qs (q G+q s) q. Résolution du challenge CDH : À part lors de l événement précédemment étudié, la simulation est parfaite pour l attaquant A, et celui-ci retourne donc avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Si l attaquant échoue, la réduction échoue. Dans le cas contraire, l attaquant retourne σ = (z, b, s, c) avec le message m lui correspondant. Alors se présentent deux cas : si b est la valeur du bit aléatoire b 0 correspondante au message m, c est-à-dire b 0 = B(m), la réduction échoue. Dans le cas contraire, par définition de l oracle H, notre réduction peut retrouver dans l historique de la simulation la valeur d correspondant à h = H(m, b). La valeur de d est connue, même si l attaquant n a pas demandé H(m, b) lors de la simulation, car alors l appel à l oracle H est fait par la procédure de vérification. 56

6.2. Les schémas de signature de Katz-Wang De la même façon que dans la preuve d EDL, nous pouvons montrer que DL h (z) = DL g (y) = x. Aussi, la solution du challenge CDH est alors facilement calculée par notre réduction : il s agit de z 1/d mod q. Ainsi, le point principal restant dans cette démonstration est de calculer la probabilité que b b 0. Probabilité que b b 0 : En fait, cette probabilité est très facile à calculer, si nous supposons que la fonction pseudo-aléatoire est parfaite. En effet, dans ce cas, l adversaire n a aucune information sur la valeur de b 0 = B(m), et donc Pr(b b 0 ) = 1 2. Aussi, nous pouvons conclure que la réduction a une probabilité de succès ε satisfaisant ε ε 2 q s(q s + q h ) q De plus, le temps de notre réduction τ est majorée par q h q. τ τ + (6q s + q h )τ 0. 6.2.3 Présentation du schéma KW-DDH L idée du deuxième schéma de Jonathan Katz et Nan Wang est de fixer une fois pour toute (dans la clé publique) la valeur de h (et donc de z). Plus précisément, la description du schéma est la suivante. Signature KW-DDH [KW03] Initialisation des paramètres : Soient l p et l q des paramètres de sécurité. Soit G le groupe cyclique d ordre q, engendré par g, où q est un premier de l q bits et la représentation des éléments de G est incluse dans {0, 1} lp. Soit G : M G 6 Z q une fonction de hachage. Enfin, soit h un élément aléatoire du groupe G. Génération de clés : La clé privée est un nombre aléatoire x Z q. La clé publique correspondante est (y = g x, z = h x ). Signature : Pour signer un message m M, le signataire prouve une égalité de logarithmes, c est-à-dire que DL h (z) = DL g (y). Pour cela, il tire un aléa k Z q, et calcule u = g k, v = h k, c = G(m, g, h, y, z, u, v) et s = k + cx mod q. La signature ainsi produite du message m est σ = (s, c) Z q 2. Vérification : Pour vérifier une signature σ = (s, c) d un message m M, il faut calculer u = g s y c et v = h s z c. La signature σ est alors acceptée si et seulement si c = G(m, g, h, y, z, u, v ). Contrairement à EDL ou à KW-CDH, dans ce schéma, u et v peuvent être précalculés avant de connaître le message : ainsi, la partie en-ligne consiste simplement en un calcul de haché, une multiplication et une addition modulaires. Ceci est aussi compétitif que pour des schémas comme Schnorr, PS ou GPS. 57

Chapitre 6. Un schéma de signature efficace basé sur le CDH 6.2.4 Sécurité du schéma KW-DDH Dans cette partie, nous réduisons la sécurité du schéma KW-DDH à la sécurité du problème décisionnel Diffie-Hellman. La preuve suit l idée originalement présentée dans [KW03]. Théorème 7 ([KW03]). Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma KW-DDH, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors le problème décisionnel Diffie-Hellman peut être résolu avec un avantage ε et en un temps τ, tels que et ε ε q s(q s + q h ) q τ τ + 4q s τ 0, où τ 0 désigne le temps d une exponentiation dans G. Démonstration. La réduction reçoit en entrée un groupe G ainsi qu un challenge DDH (g, y = g x, h, z). Nous utilisons alors l attaquant A contre le schéma de signature KW-DDH pour résoudre ce challenge, c est-à-dire pour décider si z vaut h x ou si z est un élément autre du groupe. Par définition, l attaquant A, après avoir eu droit à q h requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. L attaquant A est utilisé avec la simulation suivante. Initialisation : A est initialisé avec les paramètres publics (g, h, q, G) et la clé publique (y, z). Réponse à une nouvelle requête G(m, g, h, y, z, u, v) : le simulateur retourne un aléa de Z q. Réponse à une requête de signature sur un message m i M : le simulateur tire deux aléas (s, c) Z q Z q et calcule u = g s y c et v = h s z c. Si G(m i, g, h, y, z, u, v) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 1). Sinon, le simulateur pose G(m i, g, h, y, z, u, v) = c et retourne la signature valide (s, c). Comme nous pouvons le voir, la simulation est valide et indistinguable d un véritable signataire, si z = h x, et n échoue que lors d un événement : Événement 1 : d après la simulation des requêtes de signature, les entrées de l oracle G comportent u, un élément aléatoire du groupe. Aussi, la probabilité que G(m, g, h, y, z, u, v) ait déjà été posé est plus petite que q G+q s q, pour une requête de signature donnée. Pour l ensemble des requêtes de signature, la probabilité d apparition de l Événement 1 est donc bornée par qs (q G+q s) q. Résolution du challenge DDH : À part lors de l événement précédent, nous pouvons voir que la simulation est parfaite pour l attaquant A, si z = h x. Ainsi, dans le cas où z = h x, A retourne avec une probabilité ε une falsification sur un message qu il n a jamais soumis à l oracle de signature. Au contraire, si z est un élément aléatoire du groupe non égal à h x, la simulation n est pas parfaite. Aussi, l attaquant pourrait très bien avoir un comportement différent de son comportement dans le monde réel (c est-à-dire que sa probabilité de succès pourrait être différente de celle escomptée). Nous allons néanmoins montrer qu il lui est impossible, dans le cas où z h x, de retourner une falsification. 58 q h q

6.3. Un nouveau schéma de signature Supposons que l adversaire puisse retourner une falsification, bien que z h x. Posons alors k = DL g (u), k = DL h (v) et x = DL h (z), c est-à-dire u = g k, v = h k et z = h x. Il s ensuit alors que, comme la falsification est valide, k = s cx mod q et k = s cx mod q. Ainsi, comme x x, c = G(g, h, y, h x, g k, h k ) = k k x x mod q. Or, comme les valeurs de sortie de G dans la simulation (qu elles soient définies dans les requêtes directes à l oracle G ou dans les requêtes de signature) sont aléatoires, une telle relation ne peut être satisfaite qu avec une probabilité q G q. Aussi, dans le cas où z est un élément aléatoire du groupe non égal à h x, la probabilité de succès de l attaquant est au maximum de q G q. Toutefois, il faut bien noter que le fait que l attaquant ne retourne pas de falsification n est pas la preuve que z h x, car même si z = h x, A n a qu une probabilité ε de produire une falsification. La réduction résout donc ainsi l instance DDH : si l attaquant A retourne une falsification, elle répond que z = h x ; dans le cas contraire, elle répond au hasard au challenge. Aussi, nous pouvons conclure que notre réduction à un avantage ε satisfaisant ε ε q s(q s + q h ) q De plus, le temps de notre réduction τ est majorée par τ τ + 4q s τ 0. q h q. 6.3 Un nouveau schéma de signature Lorsque nous regardons la description d EDL, nous pouvons voir que deux valeurs aléatoires sont utilisées : k d une part, pour générer la preuve d égalité des logarithmes discrets, et r d autre part, afin que l attaquant ne puisse prévoir la valeur de h qui sera utilisée dans les requêtes de signature. Plus précisément, dans EDL, h est pris égal à H(m, r), avec un nombre aléatoire r suffisamment grand. Comme le fait RSA-PSS dans un certain sens, le but est d éviter, avec une probabilité écrasante, que l attaquant ne demande à l oracle de hachage H une valeur H(m, r) avec un aléa r qui apparaîtra par la suite dans une requête de signature. En effet, il est nécessaire dans la réduction de construire les H(m, r) apparaissant dans les requêtes de hachage d une certaine façon, et ceux apparaissant dans les requêtes de signature d une autre façon (comme montré dans la preuve d EDL, Section 6.1.2). Notre première idée a donc été la suivante : Comment serait-il possible d utiliser l aléa k dans l expression H(m, ) pour arriver au même but? Bien sûr, il est impossible d utiliser directement H(m, k), mais nous prouvons dans la Section 6.3.1 que nous pouvons utiliser H(m, u). L effet est alors immédiat : la taille de la signature est réduite de l r bits. Notre deuxième idée s est alors exprimée comme suit : Serait-il alors possible, sur cette nouvelle construction, de mettre la contribution du message à l intérieur de la fonction de hachage G, plutôt qu à l intérieur de la fonction de hachage H, comme cela est possible dans les schémas Schnorr ou KW-DDH? Le but est là de permettre le plus de précalculs possible. Cette technique ne peut être appliquée à EDL, mais nous prouvons à la fin de cette section que cela est possible pour notre construction. 59

Chapitre 6. Un schéma de signature efficace basé sur le CDH L intuition est la suivante : utiliser z = H(r) x et mettre m dans G( ) dans EDL ne peut être prouvé sûr, car un attaquant peut facilement réutiliser un z fourni par une simulation, et ainsi empêcher celle-ci de résoudre le problème CDH. Au contraire, dans notre construction, nous allons montrer qu utiliser z = H(u) x est sûr, car un attaquant ne peut réutiliser un H(u) x fourni par le signataire, à moins que le logarithme discret ne soit révélé : en effet, u satisfait une relation (u = g s y c ) qui ne peut être dévoilée pour deux valeurs de c différentes sans révéler le logarithme discret. Dans cette section, nous introduisons le nouveau schéma de signature obtenu à partir des deux idées évoquées dans ce préambule. La preuve de sécurité est ensuite exposée, pour confirmer l intuition que nous venons d exposer. 6.3.1 Une étape de notre construction Tout d abord, afin de rendre notre démarche la plus claire possible, nous présentons le schéma intermédiaire obtenu lors de nos recherches. Il faut néanmoins voir cette section plus comme une étape (vers le schéma décrit en Section 6.3.2) que comme une fin en soi. Pour ce schéma, nous conservons les étapes d initialisation et de génération de clés de EDL, à l exception près que la fonction de hachage H est maintenant définie par H : M G G \ {1}. Signature : Pour signer un message m M, le signataire choisit un nombre aléatoire k Z q, et calcule u = g k, h = H(m, u), z = h x, v = h k, c = G(g, h, y, z, u, v) et s = k + cx mod q. La signature ainsi produite du message m est σ = (z, s, c) G Z q 2. Vérification : Pour vérifier une signature σ = (z, s, c) correspondant à un message m M, il suffit de calculer u = g s y c, h = H(m, u ) et v = h s z c. La signature doit alors être acceptée si et seulement si c = G(g, h, y, z, u, v ) et z G. Cette modification du schéma EDL permet de réduire les signatures : elles sont plus petites de l r bits que dans la version originale de EDL. Nous montrons également que la sécurité n est pas affectée par cette modification. Théorème 8. Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma présenté dans cette section, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors le problème calculatoire Diffie-Hellman peut être résolu avec une probabilité ε et en un temps τ, tels que ( ) ε 2qs + q h ε q s q h q q et τ τ + (6q s + q h )τ 0 où τ 0 désigne le temps d une exponentiation dans G. La preuve complète de ce théorème est très similaire à la preuve d EDL présentée Section 6.1.2 et est omise dans cette thèse. Néanmoins, le lecteur intéressé pourra la trouver dans la version complète de notre article [Che05a, Annexe B]. Décrivons maintenant le schéma final. 60

6.3. Un nouveau schéma de signature 6.3.2 Description de notre schéma Notre schéma est le suivant : Crypto 05 [Che05a] Initialisation des paramètres : Soient l p et l q des paramètres de sécurité. Soit G le groupe cyclique d ordre q, engendré par g, où q est un premier de l q bits et la représentation des éléments de G est incluse dans {0, 1} lp. Enfin, soient H : G G \ {1} et G : M G 6 Z q deux fonctions de hachage. Génération de clés : La clé privée est un nombre aléatoire x Z q. La clé publique correspondante est y = g x. Signature : Pour signer un message m M, le signataire choisit un nombre aléatoire k Z q, et calcule u = g k, h = H(u), z = h x et v = h k. Ensuite, le signataire prouve une égalité de logarithmes, c est-à-dire que DL h (z) = DL g (y). Pour cela, il calcule c = G(m, g, h, y, z, u, v) et s = k + cx mod q. La signature ainsi produite du message m est σ = (z, s, c) G Z q 2. Vérification : Pour vérifier une signature σ = (z, s, c) d un message m M, il faut calculer u = g s y c, h = H(u ), et v = h s z c. La signature σ est alors acceptée si et seulement si c = G(m, g, h, y, z, u, v ) et z G. Un avantage de notre schéma apparaît alors clairement : nos signatures sont plus petites que les signatures EDL ou même KW-CDH : elles ne font que (l p + 2l q ) bits de long. Il nous reste encore à prouver que notre schéma possède une réduction fine au problème CDH, ce qui est fait dans la prochaine partie mais dès à présent, nous pouvons constater que, pour les valeurs numériques données dans [GJ03, KW03] le gain est de 111 bits par signature par rapport à EDL, et de 1 bit par rapport à KW-CDH. 6.3.3 Preuve de sécurité de notre schéma Dans cette section, nous réduisons le schéma proposé dans la section précédente à la sécurité du problème CDH. La preuve est assez proche de la preuve du schéma EDL. Théorème 9. Soit A un adversaire qui produit, avec une probabilité de succès ε et en un temps τ, une falsification existentielle dans le schéma présenté Section 6.3.2, sous une attaque à messages choisis, après avoir eu droit à q h requêtes à un oracle de hachage et q s requêtes à un oracle de signature, dans le modèle de l oracle aléatoire. Alors le problème calculatoire Diffie-Hellman peut être résolu avec une probabilité ε et en un temps τ, tels que ( ) ε qs + q h ε 2q s q et τ τ + (6q s + q h )τ 0 où τ 0 désigne le temps d une exponentiation dans G. Démonstration. Notre réduction reçoit en entrée un groupe G ainsi qu un challenge CDH (g, y = g x, A = g a ). Nous utilisons alors l attaquant A contre le schéma de signature de la Section 6.3.2 pour résoudre ce challenge, c est-à-dire pour calculer g ax. Par définition, l attaquant A, après 61

Chapitre 6. Un schéma de signature efficace basé sur le CDH avoir eu droit à q H requêtes à un oracle de hachage H, q G requêtes à un oracle de hachage G et q s requêtes à un oracle de signature, est capable de produire une falsification sur un nouveau message, en un temps τ et avec une probabilité de succès de ε. Notons q h = q H + q G. L attaquant A est utilisé avec la simulation suivante. Initialisation : A est initialisé avec les paramètres publics (g, q, G) et la clé publique y. Réponse à une nouvelle requête G(m, g, h, y, z, u, v) : le simulateur retourne un aléa de Z q. Réponse à une nouvelle requête H(u) : le simulateur tire un nombre aléatoire d Z q, et retourne A d. Les valeurs de u sont mémorisées dans une liste appelée U-List. Réponse à une requête de signature sur un message m i M : le simulateur tire trois nombres aléatoires (κ, s, c) Z q Z 2 q. Alors, il calcule u = g s y c. Si H(u) est déjà défini, le simulateur s arrête, et la réduction échoue (Événement 1). Sinon, le simulateur pose H(u) = g κ, et calcule z = y κ nous remarquons alors que DL h (z) = DL g (y) (= x). Finalement, le simulateur calcule v = h s z c. Si la valeur G(m i, g, h, y, z, u, v) est déjà définie, le simulateur s arrête et la réduction échoue (Événement 2). Sinon, le simulateur pose G(m i, g, h, y, z, u, v) = c. Il peut alors retourner (z, s, c) comme une signature valide de m i. Tous les u apparaissant dans les requêtes de signature sont stockés dans une liste Υ -List. Comme nous pouvons le voir, la simulation est valide et indistinguable d un véritable signataire, et n échoue que lors des événements suivants : Événement 1 : Comme u est un aléa de G, la probabilité que H(u) soit déjà posé est plus petite que q H+q s q, lors d une requête de signature. Pour l ensemble des q s requêtes de signature, la probabilité d apparition de l Événement 1 est donc majorée par qs (q H+q s) q. Événement 2 : d après notre simulation des requêtes de signature, les entrées de l oracle G sont de la forme (m, g, h, y, z, u, v) = (m, g, g κ, y, y κ, g k, g κk ) avec (k, κ) Z q Z q. De plus, comme l Événement 1 n est pas arrivé, la valeur de H(u) n est pas encore définie, et donc κ est totalement aléatoire aux yeux de l adversaire. Aussi, la probabilité que G(m, g, h, y, z, u, v) ait déjà été posé est plus petite que q G+q s q (q 1), pour une requête de signature donnée. Pour l ensemble des requêtes de signature, la probabilité d apparition de l Événement 2 est donc limitée à qs (q G+q s) q (q 1) qs (q G+q s) q. ( Aussi, exceptés les événements précédents, dont la probabilité est plus petite que δ sim = q qh +2q s ) s q, notre simulation est un succès, et est indistinguable du monde réel. En d autres termes, avec une probabilité ε sim ε δ sim, l attaquant A est capable de retourner une falsification (ẑ, ŝ, ĉ) d un message ˆm M qu il n a jamais soumis à l oracle de signature. Le simulateur peut alors en déduire les valeurs (û, ˆv, ĥ) correspondantes : û = gŝ y ĉ, ĥ = H(û), et ˆv = ĥŝ ẑ ĉ. Notamment, si la valeur H(û) n avait pas été demandée explicitement par l attaquant à l oracle de hachage ou calculée lors d une requête de signature, le simulateur fait la demande à l oracle de hachage H lui-même. Aussi, û est nécessairement membre de la liste U-List ou de la liste Υ -List. Résolution du challenge CDH : À cette étape, notre preuve se divise en deux cas, contrairement aux preuves de EDL ou de KW-CDH. 62 Dans le premier de ces cas, û appartient à la liste U-List. C est la situation qui correspond à la preuve de EDL ou de KW-CDH. Comme pour ces preuves, comme h est un générateur de G, nous écrivons û = g k, ˆv = ĥk et ẑ = ĥx, et nous obtenons alors grâce à l étape de vérification, comme la signature est valide, que k = ŝ ĉx mod q et k = ŝ ĉx mod q.

6.3. Un nouveau schéma de signature Ainsi, si x x, nous avons ĉ = G( ˆm, g, ĥ, y, ĥx, g k, ĥk ) = k k x x mod q. Par les mêmes arguments que dans les preuves de EDL ou de KW-CDH, nous savons qu une telle équation ne peut être résolue, sauf avec une probabilité de q G q. Aussi, mis à part ce cas minime d erreur, nous avons DLĥ(ẑ) = DL g (y) (= x). Alors, l attaquant a retourné ẑ = ĥx, et la réduction connaît d 0 tel que ĥ = H(û) = Ad. La réduction peut donc résoudre le problème CDH, en retournant la réponse ẑ 1/d mod q. En conclusion, dans ce premier cas, la falsification est utilisée avec succès pour résoudre le problème, sauf avec une probabilité δ 1 = q h q. Dans le second cas, û n appartient pas à la liste U-List, et donc appartient à la liste Υ -List. Ce cas peut arriver, contrairement au schéma EDL, car il n y a pas, dans notre schéma, de message en entrée de la fonction de hachage H, et ainsi, nous pouvons imaginer que l attaquant réutilise un u qui serait apparu lors des requêtes de signatures. Dans ce second cas, la réduction retrouve, dans son historique, les quantités correspondant à ce u = û, c est-à-dire h, v, z, s, c et m. À ce moment, nous pouvons voir que nous avons u = g s y c = û = gŝ y ĉ. C est exactement le genre d équation qui est utilisée par le lemme de bifurcation pour prouver une sécurité lâche. Cependant, ici, cette égalité n est pas obtenue en redémarrant l attaquant (comme cela est fait dans le lemme de bifurcation), mais juste par construction. Ainsi, nous pouvons retrouver la clé privée x, si ĉ c mod q. Comme le message ˆm est nouveau, c ĉ ou alors une collision sur la fonction de hachage G a été trouvée par l attaquant, entre un G-haché retourné par la simulation de signature, et un G-haché retourné par un appel direct à l oracle de hachage G. Ceci ne peut arriver qu avec une probabilité plus petite que qs q G q. Aussi, mise à part une erreur plus petite que δ 2 = qs q G q, nous avons ĉ c, et donc la réduction peut retrouver la clé secrète x. L équation s xc = ŝ xĉ (mod q) donne en effet x = s ŝ c ĉ mod q. Nous pouvons voir que ce second cas ne donne pas seulement la solution du challenge CDH, mais aussi la solution au problème du logarithme discret. En conclusion, dans les deux cas, notre réduction peut utiliser la falsification produite par l attaquant pour résoudre le problème CDH. Sa probabilité de succès satisfait la relation ε ε δ sim max(δ 1, δ 2 ), ce qui, en utilisant q H + q G = q h, donne ε ε 2q s ( qs + q h q De plus, le temps d exécution de la réduction τ est tel que ). τ τ + (6q s + q h )τ 0. 6.3.4 Utilisation de coupons dans notre schéma L un des avantages de notre schéma est qu il permet l utilisation de coupons, et ceci sans aucun coût pour le signataire et le vérifieur. En effet, le signataire peut décider d utiliser ou non des coupons, sans que ce choix ne change l étape de vérification (et notamment, sans la rendre plus coûteuse). Ceci est également le cas de la signature Schnorr, mais par exemple n est pas vrai pour les signatures à coupons basées sur les fonctions de hachage caméléon, et notamment pas pour la signature EDL-CH. 63

Chapitre 6. Un schéma de signature efficace basé sur le CDH Ce procédé de coupon est fait de façon très naturelle : l étape de signature (voir Section 6.3.2) est simplement divisée en deux sous-étapes. Crypto 05 Signature, partie hors-ligne : Pour créer un coupon, le signataire choisit k Z q et calcule u = g k, h = H(u), z = h x et v = h k. Le coupon est alors (u, v, h, z, k) G 4 Z q. Signature, partie en-ligne : Pour signer un message m M, le signataire utilise un nouveau coupon (u, v, h, z, k) et calcule simplement c = G(m, g, h, y, z, u, v) et s = k + cx mod q. La signature sur le message m est σ = (z, s, c) G Z q 2. Comme nous pouvons le voir, la procédure de vérification reste la même. Cette propriété de signature en-ligne/hors-ligne est très utile, car elle permet au calcul en-ligne d être le plus rapide possible, sa durée étant réduite au temps de calcul d un haché et d une multiplication modulaire. Ceci est tout à fait comparable aux signatures à coupons les plus rapides actuellement, Schnorr, GPS ou PS. Le lecteur remarquera que le schéma GPS ne nécessite pas de réduction modulo l ordre du groupe, au prix d une signature légèrement plus longue. Cette technique peut aussi être utilisée dans notre schéma, afin d accélérer encore l étape en-ligne, au prix d une signature légèrement plus longue. Comme décrit dans cette section, les coupons font (4l p + l q ) bits. Cette taille peut être facilement réduite à (3l p + l q ) bits, en ne stockant simplement pas h, c est-à-dire en ayant un coupon (u, v, z, k). Alors, la valeur h = H(u) est simplement recalculée lors de l étape en-ligne. Ceci peut être intéressant lorsque la mémoire est limitée, par exemple sur certaines cartes à puces. Une version qui minimise encore plus la taille des coupons est décrite dans les annexes de notre publication [Che05a, Annexe A]. 6.3.5 Taille des paramètres Dans cette section, nous expliquons comment définir les paramètres de sécurité l q et l p, pour atteindre un niveau de sécurité donné. Notre analyse suit celle d Eu-Jin Goh et Stanislaw Jarecki pour le schéma EDL. Prenons le meilleur attaquant (q h, q s, τ, ε) contre notre schéma : il peut trouver, en un temps moyen τ ε une falsification. En posant τ = 2n et ε = 2 e, nous obtenons log 2 ( τ ε ) = n + e = κ, par définition le niveau de sécurité d un schéma en bits. Comme prouvé dans la Section 6.3.3, nous pouvons utiliser cet attaquant pour résoudre le problème CDH dans un temps moyen τ ε. Notons 2 κ le niveau de difficulté du problème CDH dans le groupe G. Alors, par définition, κ log 2 ( τ ε ). De plus, par les attaques génériques en O( q) sur le logarithme discret (et donc sur le problème calculatoire Diffie-Hellman), nous avons l q 2κ. Utilisons le coût de calcul d un haché comme temps unitaire. Alors, q h 2 n. Si de plus, nous estimons que τ 0 (le temps d une exponentiation dans G) est d environ 100 fois le temps du calcul d un haché, en sachant que q s q h, nous obtenons que τ 2 n+7 et ε ε 4qs q h q. Du moment que q s 2 lq e 3 n = 2 lq κ 3 (par exemple, κ = 80, q s 2 80, q h 2 80 et l q 176), nous avons ε 2 e 1. Aussi, log 2 ( τ ε ) n + 7 + e + 1 = κ + 8. Finalement, nous obtenons κ κ 8. Citons notamment l attaque par pas-de-bébé pas-de-géant et l attaque rho de Pollard 64

6.3. Un nouveau schéma de signature Dans notre exemple, si le niveau de sécurité escompté κ est de 80 bits, il est suffisant d utiliser κ = 88 (et notamment l q 176). Ceci prouve que notre schéma est très efficace en terme de taille de signature, comme il nous est possible d utiliser le même sous-groupe G que celui utilisé par Eu-Jin Goh et Stanislaw Jarecki, en ayant le même niveau de sécurité. Nous pouvons remarquer aussi que notre schéma reste aussi sûr, avec les mêmes paramètres de sécurité, même pour un q s pouvant aller jusqu à 2 80, alors que dans EDL, q s est limité à 2 30 ou l aléa r doit être rendu plus grand. 6.3.6 Comparaison de notre schéma avec EDL, KW-CDH et autres schémas Dans ce paragraphe, nous résumons les avantages de notre schéma. Comparé à EDL, notre schéma a les caractéristiques suivantes : 1. une procédure de signature plus rapide, avec l utilisation de coupons, sans surcoût pour le vérifieur : la partie en-ligne de notre schéma ne requiert que le calcul d un haché suivi du calcul d une multiplication modulaire dans Z q, alors que dans EDL, cette phase consiste en deux calculs de hachés et surtout deux exponentiations dans G ; 2. même efficacité de vérification des signatures ; 3. des signatures plus petites de l r 111 bits : en prenant un sous-groupe de Z p, avec alors l p = 1024 et l q = 176, c est une amélioration de 7%. Dans le cas des courbes elliptiques, le gain est encore plus important, comme z peut être représenté avec une longueur autour de l q = 176 : notre schéma résulte alors en une amélioration de la taille des signatures de 17%. Avec KW-CDH, notre schéma se compare comme suit : 1. une procédure de signature plus rapide, avec l utilisation de coupons, sans coût pour le vérifieur : la partie en-ligne de notre schéma ne requiert que le calcul d un haché suivi du calcul d une multiplication modulaire dans Z q, alors que dans KW-CDH, cette phase consiste en deux calculs de hachés et surtout deux exponentiations dans G ; 2. même efficacité de vérification des signatures ; 3. de façon moins significative, des signatures plus petites de 1 bit, et un niveau de sécurité supérieur de 1 bit. 4. une taille de clés plus petite, car le calcul de b dans KW-CDH par une fonction pseudoaléatoire nécessite une clé additionnelle, qu il vaudrait mieux, pour des raisons de sécurité, ne pas relier à la clé privée x. De plus, comme noté dans [KW03], le calcul d une fonction de hachage H : G G peut être très long, par exemple dans le cas des sous-groupes de Z p, si l q l p. En effet, il faut alors procéder à une exponentiation de (l p l q ) bits, ce qui est bien plus long que les deux exponentiations dans G, pour l q = 176. Dans notre schéma, ce calcul de haché peut être fait hors-ligne, au contraire des schémas EDL ou KW-CDH. Enfin, si nous comparons notre schéma à EDL-CH, la version avec coupons de EDL, nous voyons que notre schéma présente : 1. une procédure de vérification plus rapide et surtout inchangée (il faut se rappeler qu EDL- CH s appuie sur des fonctions de hachage caméléon, qui nécessitent des exponentiations additionnelles) ; 2. des signatures plus petites, c est-à-dire un gain de l q 176 bits par rapport à EDL-CH ; pour le cas des sous-groupes de Z p, si nous prenons l p = 1024 et l q = 176, cela représente une amélioration de 11%, et, pour les courbes elliptiques, un gain de 25%. 65

Chapitre 6. Un schéma de signature efficace basé sur le CDH De façon générale, en raison de sa réduction fine de sécurité, notre schéma possède les mêmes avantages que ceux de EDL et KW-CDH, en comparaison avec les schémas basés sur le logarithme discret tels que Schnorr et GPS, pour un niveau de sécurité donné. D une part, si nous prenons G Z p, il est possible d utiliser des modules p huit fois plus petits et des ordres q deux fois plus petits que dans les schémas basés sur le problème DL à preuve de sécurité lâche même s il faut cependant noter que le problème sous-jacent (CDH) est plus facile que DL. Cela signifie notamment que les clés publiques sont huit fois plus petites et que les clés privées sont deux fois plus petites. Par contre, les signatures sont environ deux fois plus grandes que les signatures de Schnorr. D autre part, si nous prenons le cas des courbes elliptiques, nos clés (publiques et privées) sont deux fois plus petites, et nos signatures sont réduites de 25% par rapport aux schémas basés sur le logarithme discret à réduction lâche. 6.3.7 Derniers raffinements Dans la version complète de notre papier [Che05a, Annexe C], nous montrons également qu il est possible de gagner encore quelques bits sur la taille de la signature, par une technique assez classique due à Marc Girault et Jacques Stern [GS94] (elle s applique ainsi également aux schémas Schnorr, EDL, KW-CDH et KW-DDH). Pour cela, nous proposons d utiliser une fonction de hachage M G 6 {0, 1} lc, plutôt que celle utilisée dans la Section 6.3.2. La preuve du schéma est alors très légèrement modifiée, pour arriver à un théorème similaire au Théorème 9, où ε ε 2q s ( qs+q h q ) q h 2lc. Nous pouvons alors adapter la discussion de la Section 6.3.5, et voir que l c = 82 bits est suffisant pour un niveau de sécurité de 80 bits. Cela permet ainsi d obtenir des signatures dans un sous-groupe de Z p (en prenant l p = 1024, l q = 176 et l c = 82), faisant 1024 + 176 + 82 = 1282 bits. Dans le cas des courbes elliptiques, le gain est encore plus important, car z peut être représenté avec une longueur d environ l q = 176 : les signatures font alors 176 2 + 82 + 1 = 435 bits. 6.3.8 À propos du test d appartenance de z à G Tels que nous les avons présentés, les schémas EDL, KW-CDH et le schéma présenté dans cette section nécessitent, dans l étape de vérification, de tester que z G. Ceci n est pas coûteux pour les courbes elliptiques qui sont, rappelons-le, le meilleur cas d utilisation de nos schémas. Au contraire, pour les sous-groupes de Z p d ordre premier q, avec q p, ce test peut être très pénalisant, puisqu il est fait au moyen d une exponentiation de l p l q bits. Dans [GJKW06], Eu-Jin Goh, Stanislaw Jarecki, Jonathan Katz and Nan Wang ont expliqué comment se passer de ce test pour EDL et KW-CDH. Cette méthode s applique également à notre schéma, comme nous allons le montrer. Considérons notre schéma de la Section 6.3.2, dans lequel la vérification ne comporterait plus la vérification de l appartenance de z à G. Ainsi, considérons que le groupe G est inclus dans un groupe plus grand H d ordre α q, où α est appelé le co-facteur. Nous restreignons seulement l usage du schéma à des groupes où α et q sont premiers entre eux. Dans la falsification proposée par l adversaire, z pourrait appartenir à H sans appartenir à G. Or, dans les preuves, nous avons supposé z G pour pouvoir écrire ˆv = ĥk et ẑ = ĥx, et en déduire ensuite que x = x sauf avec une probabilité de q h q (voir Section 6.3.3, lors de l utilisation de la falsification dans le cas où u U-List). L idée est dorénavant que le schéma n est plus une preuve que z = h x, mais plutôt que 66

6.4. Conclusion (z α ) α 1 mod q = h x. Nous pouvons reprendre la preuve de la Section 6.3.3, au moment de l utilisation de la falsification dans le cas où u U-List (les autres points étant identiques). Démonstration (Modification par rapport à la Section 6.3.3). Dans le premier cas, û appartient à la liste U-List. Comme ĥ est un générateur de G, nous pouvons écrire û = g k, ˆv = g 0 ĥ k et ẑ = g 1 ĥ x, où (k, k, x ) Z 3 q et où g 0 et g 1 sont des éléments de H d ordre α. D après l équation de vérification, k = ŝ ĉx mod q et ˆv = ĥŝ ẑ ĉ. En élevant la seconde équation à la puissance α, nous obtenons alors α k = α (ŝ ĉ x ) mod q, et ainsi, comme α est inversible modulo q, k = ŝ ĉ x mod q. C est pourquoi, si x x, nous avons ĉ = G( ˆm, g, ĥ, y, ĥx, g k, ĥk ) = k k x x mod q. Par les mêmes arguments que dans les preuves de EDL ou de KW-CDH, nous savons qu une telle équation ne peut être résolue, sauf avec une probabilité de q G q. Aussi, mis à part ce cas minime d erreur, nous avons (ẑ α ) α 1 mod q = ĥx. Comme la réduction connaît d 0 tel que ĥ = H(û) = Ad, elle peut résoudre le problème CDH, en retournant la réponse (ẑ α ) (α d) 1 mod q. En conclusion, dans ce premier cas, la falsification est utilisée avec succès pour résoudre le problème, sauf avec une probabilité δ 1 = q h q. Ainsi, comme nous pouvons le voir, il n est pas nécessaire de vérifier que z G, pas plus dans les schémas EDL, KW-CDH que dans nos schémas, du moment que le co-facteur est premier avec q. 6.4 Conclusion Lors de la conférence Eurocrypt 03, Eu-Jin Goh et Stanislaw Jarecki ont montré que contrairement aux autres schémas de signature basés sur le logarithme discret, le schéma de signature EDL avait une réduction de sécurité fine au problème calculatoire Diffie-Hellman (CDH), dans le modèle de l oracle aléatoire. Ces auteurs ont également remarqué que le schéma de signature EDL pouvait être transformé en un schéma de signature à coupons, en utilisant la technique générique d Adi Shamir et Yael Tauman, technique basée sur les fonctions de hachage caméléon. Dans ce chapitre, nous avons proposé un nouveau schéma de signature qui présente également une réduction de sécurité fine au problème CDH, mais pour lequel les signatures produites sont plus courtes que celles d EDL. De plus, de façon similaire au schéma de signature Schnorr (mais contrairement à EDL), le schéma proposé permet l utilisation de coupons de façon extrêmement naturelle, sans calculs supplémentaires et sans que l algorithme de vérification ne soit modifié. C est dans le contexte des courbes elliptiques que notre schéma est le plus intéressant, car il améliore alors de 25% l état de l art des schémas de signature basés sur le logarithme discret, tout en gardant le même niveau de sécurité. Depuis sa parution, notre schéma de signature a été utilisé comme brique de base d un schéma de signcryption dans une publication [BD06] de Tor Bjørstad et d Alexander Dent à la conférence Pkc 06. La signcryption est une primitive mêlant le chiffrement et la signature. 67

Chapitre 6. Un schéma de signature efficace basé sur le CDH 68

Chapitre 7 Un schéma de signature dans le modèle standard Sommaire 7.1 Schéma de signature dans le modèle standard.............. 70 7.1.1 Introduction................................... 70 7.1.2 Sécurité prouvée et modèle standard..................... 70 7.2 Survol des schémas de signature basés sur FlexibleRSA.......... 71 7.2.1 Schéma de signature Gennaro-Halevi-Rabin................. 71 7.2.2 Schéma des signatures jumelles GHR..................... 72 7.2.3 Schéma de signature Cramer-Shoup...................... 73 7.2.4 Schéma de signature Camenisch-Lysyanskaya................ 73 7.2.5 Schéma de signature Fischlin......................... 74 7.3 Un nouveau schéma de signature dans le modèle standard....... 74 7.3.1 Description................................... 74 7.3.2 Analyse de sécurité............................... 75 7.3.3 Comparaison avec les autres schémas..................... 77 7.3.4 Version en-ligne/hors-ligne........................... 79 7.4 Conclusion.................................... 81 En 1999, deux schémas de signature basés sur le problème FlexibleRSA furent proposés indépendamment : le schéma de signature de Rosario Gennaro, Shai Halevi et Tal Rabin (GHR) et le schéma de signature de Ronald Cramer et Victor Shoup (CS). Ces schémas atteignent le niveau de sécurité le plus élevé dans le modèle standard, c est-à-dire sans avoir besoin d oracles aléatoires. Cependant, ces schémas diffèrent dans leur mise en œuvre. Le schéma CS et ses variantes assurent une sécurité lâche, qui, in fine, impose de prendre des paramètres de sécurité plus grands. Au contraire, le schéma GHR ou sa variante, appelée signatures jumelles GHR, possèdent une réduction fine, mais nécessitent (i) soit une hypothèse supplémentaire et non-standard, dénommée indivisibilité de la fonction de hachage, (ii) soit l usage d une fonction injective dans l ensemble des nombres premiers, lors des algorithmes de signature et de vérification. Dans ce chapitre, nous présentons une nouvelle variante du schéma GHR, dans laquelle nous nous affranchissons complètement de l hypothèse sur la fonction de hachage, sans avoir besoin d une fonction injective dans l ensemble des premiers. Nous obtenons ainsi un nouveau schéma de signature (ainsi qu une variante en-ligne/hors-ligne) dont la sécurité dépend uniquement de la difficulté du problème FlexibleRSA, et ceci au travers d une réduction fine. Ce chapitre a fait l objet d une collaboration avec Marc Joye et apparaîtra à la conférence Ct-rsa 07 [CJ07]. 69

Chapitre 7. Un schéma de signature dans le modèle standard 7.1 Schéma de signature dans le modèle standard 7.1.1 Introduction Dans cette section, nous rappelons quelques notations et définitions qui seront utilisées tout au long de ce chapitre. Par simplicité, nous identifions souvent un entier avec sa représentation binaire : a {0, 1} l est aussi vu comme un entier dans l intervalle [0, 2 l 1]. Nous disons que a est un entier de l bits si a est un entier de l intervalle [2 l 1, 2 l 1]. Étant donné un module RSA n, nous appelons QR n Z n l ensemble des résidus quadratiques modulo n, c est-à-dire QR n = {x 2 mod n, pour x Z n}. Enfin, nous rappelons que selon la Définition 2, un module RSA fort est le produit de deux premiers forts. 7.1.2 Sécurité prouvée et modèle standard Les schémas que nous avons vus pour l instant dans cette thèse (dans les Chapitres 4, 5 et 6) ont été prouvés dans le modèle de l oracle aléatoire. Ce modèle idéalise les fonctions de hachage, et certains auteurs ont montré des différences importantes avec le modèle standard [CGH98, PV05]. Ainsi, les schémas de signature possédant une preuve de sécurité dans le modèle standard suscitent le plus grand intérêt. Le premier schéma de signature avec une sécurité dans le modèle standard fut proposé par Shafi Goldwasser, Silvio Micali et Ronald Rivest [GMR88]. Ce schéma fut ensuite successivement amélioré par Cynthia Dwork et Moni Naor [DN94], puis par Ronald Cramer et Ivan Damgård [CD96], et finalement par Dario Catalano et Rosario Gennaro [CG05]. Tous ces schémas sont des schémas basés sur des arbres, et souffrent donc d une certaine inefficacité. Il existe nos jours encore très peu de schémas efficaces avec une preuve de sécurité dans le modèle standard, et la plupart d entre eux repose sur des problèmes souples, un-de-plus ou de type q. Les problèmes souples (en anglais, flexible problems) sont des problèmes qui admettent plusieurs solutions, mais pour lesquels il est conjecturé qu il est néanmoins difficile d en trouver une quelconque. Le plus connu des problèmes de ce type est certainement le problème FlexibleRSA [BP97, FO97], tel que défini dans la Définition 5. Les problèmes un-de-plus (en anglais, one-more problems) sont des problèmes dans lesquels il est demandé de résoudre (k + 1) instances d un problème difficile, en ayant k accès à un oracle résolvant une instance choisie. Des exemples types sont le one-more RSA, le one-more DL et le one-more CDH [BNPS03]. Enfin, les q-problèmes (en anglais, q-type problems) sont des problèmes dans lesquels le challenge contient, entre autres, q données reliées à un secret par une relation connue. Classiquement, la valeur à en déduire est une (nouvelle) donnée, du même type que les q données du challenge. Le q-problème Diffie-Hellman [BB04] est un exemple typique de cette classe de problèmes. Construire dans le modèle standard un schéma de signature efficace basé sur le même type de problème qu avec le modèle de l oracle aléatoire est très difficile. De façon remarquable, Brent Waters a obtenu un schéma de signature basé sur le CDH [Wat05] dans un groupe possédant une application bilinéaire, mais avec une réduction très lâche. Obtenir un schéma efficace basé sur un problème tel que le RSA, le DL ou le CDH dans un groupe quelconque est actuellement un problème ouvert. 70

7.2. Survol des schémas de signature basés sur FlexibleRSA 7.2 Survol des schémas de signature basés sur FlexibleRSA Nous rappelons brièvement dans cette section les principaux schémas de signature efficaces, dont la sécurité est basée sur l hypothèse RSA forte, dans le modèle standard. Nous encourageons le lecteur intéressé à se référer aux papiers originaux pour une description plus complète et pour les preuves de sécurité associées aux schémas. Pour permettre une lecture et une comparaison plus simple, nous avons parfois modifié les notations originales. Nous commençons avec les deux principaux schémas, tous deux introduits en 1999 : le schéma de signature de Rosario Gennaro, Shai Halevi et Tal Rabin [GHR99] (GHR) et le schéma de signature de Ronald Cramer et Victor Shoup [CS99, CS00] (CS). Le schéma CS fut sujet à de nombreuses variantes, parmi lesquelles celle de Huafei Zhu [Zhu01, Zhu03], celle de Jan Camenisch et Anna Lysyanskaya [CL02] et celle de Marc Fischlin [Fis03]. Tout comme les signatures jumelles GHR [NPS01], notre nouveau schéma peut quant à lui (voir Section 7.3) être vu comme une variante du schéma GHR. 7.2.1 Schéma de signature Gennaro-Halevi-Rabin Soient l n et l h des paramètres de sécurité (typiquement, l n = 1024, l h = 160). L ensemble des messages est M = {0, 1}, et une fonction de hachage H : M {0, 1} l h est utilisée. Le schéma GHR est alors le suivant. Sig. GHR [GHR99] Génération de clés : La clé publique est pk = {n, u}, où n = (2p +1)(2q + 1) est un module RSA fort de l n bits et u est un élément aléatoire de Z n. La clé privée est sk = {p, q }. Signature : La signature d un message m M est σ = u c 1 mod 2p q mod n, où c = H(m). Vérification : La signature σ d un message m M est acceptée si et seulement si u = σ H(m) mod n. Dans la description originale, la fonction de hachage doit être indivisible (en anglais, division intractable) : cette hypothèse sera notée Div. Intuitivement, l hypothèse suppose qu il est impossible pour l attaquant de trouver un message m, tel que H(m) divise le produit i H(m i), où les m i sont les messages soumis à l oracle de signature. Pour une définition plus précise de cette propriété particulière des fonctions de hachage, nous renvoyons le lecteur à l article original [GHR99]. Le temps avançant, et notamment grâce au travail de Jean-Sébastien Coron et David Naccache [CN00] (voir aussi [CS99, CS00] pour une discussion à ce sujet), il est communément admis que le moyen le plus simple et le plus sûr d obtenir une telle propriété est de définir l ensemble d arrivée de la fonction de hachage comme un sous-ensemble de l ensemble des nombres premiers. Variante à réduction fine. Le schéma de signature GHR comme décrit plus haut possède une preuve de sécurité lâche sur le problème FlexibleRSA [GHR99, Cor00]. Cependant, dans [GHR99], les auteurs proposent une variante de leur schéma possédant, elle, une réduction fine. Intuitivement, leur idée est d utiliser une fonction de hachage caméléon [KR00], qui dans leur exemple est basée sur le problème du logarithme discret, mais qui pourrait a priori être d un autre type. Soient P un grand premier, Q un grand diviseur premier de P 1, et G le groupe cyclique d ordre Q généré par un élément g Z P. Cette fois, l ensemble des messages est M = Z Q et la fonction de hachage (qui doit toujours être indivisible) est H : G {0, 1} l h. 71

Chapitre 7. Un schéma de signature dans le modèle standard Le schéma devient alors : Sig. GHR [GHR99] Génération de clés : La clé publique est pk = {n, u, g, y, P }, où n = (2p + 1)(2q + 1) est un module RSA fort de l n bits, u est un élément aléatoire de Z n, g est un générateur de G et y est un élément aléatoire de G. La clé privée est sk = {p, q }. Signature : La signature d un message m M est donnée par σ = (r, s), où r est un aléa de Z Q et s = u c 1 mod 2p q mod n, avec c = H(g m y r mod P ). Vérification : La signature σ du message m M est acceptée si et seulement si u = s c mod n, où c = H(g m y r mod P ). Rosario Gennaro, Shai Halevi et Tal Rabin obtiennent ainsi un schéma de signature dans lequel un attaquant peut être utilisé pour résoudre soit le logarithme discret dans G, soit le problème FlexibleRSA, et ceci de façon fine. Clairement, il est possible d utiliser d autres types de fonction de hachage caméléon (par exemple sur le problème RSA, comme dans [KS06]). 7.2.2 Schéma des signatures jumelles GHR Le paradigme des signatures jumelles fut introduit par David Naccache, David Pointcheval et Jacques Stern dans [NPS01]. Il s applique particulièrement bien aux signatures GHR, pour des messages très courts. Soit P une fonction injective de l ensemble {0, 1} 2lm vers l ensemble des nombres premiers. Par exemple, cette fonction pourrait être P : {0, 1} 2lm {primes}, µ NextPrime(µ 2 τ ) avec τ 5 log 2 (2l m ), fonction pouvant être évaluée en moins de 40 l m tests de primalité [NPS01, Annexe B]. Le schéma Twin-GHR est alors défini comme suit : Sig. Twin-GHR [NPS01] Génération de clés : La clé publique est pk = {n, N, u 1, u 2 } où n = (2p + 1)(2q + 1) et N = (2P + 1)(2Q + 1) sont deux modules RSA forts, u 1 est un élément aléatoire de Z n et u 2 est un élément aléatoire de Z N. La clé privée est sk = {p, q, P, Q }. Signature : La signature d un message m M = {0, 1} lm est donnée par σ = (µ 1, s 1, s 2 ), calculée, pour un aléa µ 1 {0, 1} 2lm et µ 2 = (m m) µ 1, comme P(µ s 1 = u 1 ) 1 mod 2p q 1 mod n et s 2 = u 2 P(µ 2 ) 1 mod 2P Q mod N. Vérification : La signature σ = (µ 1, s 1, s 2 ) du message m M est acceptée si u 1 = s 1 P(µ 1 ) mod n et u 2 = s 2 P((m m) µ 1 ) mod N. La signature Twin-GHR possède une réduction fine sur le problème FlexibleRSA [NPS01]. 72

7.2.3 Schéma de signature Cramer-Shoup 7.2. Survol des schémas de signature basés sur FlexibleRSA Le schéma de signature de Ronald Cramer et Victor Shoup [CS99, CS00] (CS) est défini comme suit. Soient l n et l h des paramètres de sécurité (typiquement, l n 1024, l h 160). Soit M = {0, 1} l ensemble des messages, et soit H : M {0, 1} l h une fonction de hachage. Sig. CS [CS99, CS00] Génération de clés : La clé publique est pk = {n, e, x, h}, où n = (2p + 1)(2q + 1) est un module RSA fort de l n bits, e est un premier de (l h + 1) bits et x, h sont des éléments aléatoires de QR n. La clé privée est sk = {p, q }. Signature : La signature d un message m M est σ = (c, u, v), où c est un premier aléatoire de (l h + 1) bits, u est un élément aléatoire de QR n et v = (x h H(w) ) c 1 mod p q mod n, avec w = u e h H(m) mod n. Vérification : La signature σ = (c, u, v) du message m M est acceptée si et seulement si c est un entier impair de (l h +1) bits et x = v c h H(w ) mod n, avec w = u e h H(m) mod n. Ce schéma de signature, comme démontré dans [CS99, CS00], est sûr sous l hypothèse RSA forte. Malheureusement, la réduction de sécurité est lâche, avec un facteur de perte approximativement égal à q s, le nombre autorisé de requêtes de signature. Pour être précis, la réduction de sécurité du schéma CS est divisée en deux sous-parties : une première, permettant une réduction fine basée sur le problème FlexibleRSA, et une seconde, lâche, basée sur le problème RSA. Même si le problème RSA est peut être significativement plus difficile que le problème FlexibleRSA, dans l état actuel des connaissances, la seule chose qui soit connue est que le problème RSA est au moins aussi difficile que le problème FlexibleRSA. Aussi, la seule conclusion qui puisse être tirée actuellement est que la réduction de CS est lâche sur le problème FlexibleRSA. Dans le même temps, un avantage du schéma CS par rapport au schéma GHR est que la fonction de hachage H n a pas besoin d avoir comme image un nombre premier, ni d être indivisible, mais uniquement d être résistante aux collisions. 7.2.4 Schéma de signature Camenisch-Lysyanskaya Dans [CL02], Jan Camenisch et Anna Lysyanskaya ont introduit une variante du schéma CS (que nous désignons par CL). Indépendamment, dans un journal chinois [Zhu01], Huafei Zhu avait proposé un schéma essentiellement similaire (voir également [Zhu03]). Soient l le niveau de sécurité désiré du schéma de signature, l n, l m et l c (l m + 2) des paramètres de sécurité (typiquement, l = 80, l n 1024 et l c = l m + 2). Le schéma de signature CL se décrit alors comme suit. Sig. CL [CL02] Génération de clés : La clé publique est pk = {n, x, g, h}, où n = (2p + 1)(2q + 1) est un module RSA fort de l n bits, et x, g, h sont des éléments aléatoires de QR n. La clé privée est sk = {p, q }. Signature : La signature d un message m M = {0, 1} lm est donnée par σ = (c, t, v), où c est un nombre premier aléatoire de l c bits, t est un aléa de (l n + l m + l) bits et v = (x g t h m ) c 1 mod p q mod n. Vérification : La signature σ = (c, t, v) du message m M est acceptée si et seulement si c est un entier impair de l c bits et x = v c g t h m mod n. 73

Chapitre 7. Un schéma de signature dans le modèle standard Dans ce schéma, nous pouvons voir qu aucune fonction de hachage n est utilisée, ce qui est un avantage, obtenu malheureusement au prix d une signature plus longue et d une restriction aux messages courts. Si signer des messages longs est important pour l utilisateur, il est possible d utiliser une fonction de hachage, avec l hypothèse supplémentaire de sa résistance aux collisions. 7.2.5 Schéma de signature Fischlin Une dernière variante du schéma CS fut proposée par Marc Fischlin dans [Fis03]. Soient l n et l h des paramètres de sécurité (typiquement, l n 1024, l h 160). L ensemble des messages est M = {0, 1} et une fonction de hachage H : M {0, 1} l h est utilisée. Sig. Fischlin [Fis03] Génération de clés : La clé publique est pk = {n, x, g, h}, où n = (2p + 1)(2q + 1) est un module RSA fort de l n bits, et x, g, h sont des éléments aléatoires de QR n. La clé privée est sk = {p, q }. Signature : La signature d un message m M est σ = (c, t, v), où c est un premier aléatoire de (l h + 1) bits, t est un entier aléatoire de l h bits et v = (x g t h t H(m) ) c 1 mod p q mod n. Vérification : La signature σ = (c, t, v) du message m M est acceptée si et seulement si c est un entier impair de (l h + 1) bits et x = v c g t h (t H(m)) mod n. Une comparaison de tous les schémas de cette section et de celui que nous présentons Section 7.3 est proposée dans la Table 7.1. 7.3 Un nouveau schéma de signature dans le modèle standard Cette section est la partie principale de ce chapitre. Nous y introduisons TSS, un nouveau schéma de signature, et prouvons sa sécurité dans le modèle standard. Notre réduction est fine, et basée uniquement sur le problème FlexibleRSA. Comme nous l avons vu, d un côté, le schéma GHR nécessite l utilisation d une fonction de hachage dont les images sont des nombres premiers (ou au moins, une fonction de hachage indivisible). Le schéma CS et ses variantes, d un autre côté, n assure qu une sécurité lâche : le facteur de perte est de q s. Notre but, lors du design du schéma TSS, a été de combiner l aspect pratique du schéma CS et la finesse de la réduction de sécurité du schéma GHR. 7.3.1 Description Intuitivement, il y a deux idées à la base de notre schéma. Tout d abord, comme dans les schémas de type CS (voir Section 7.2), nous voulons utiliser un exposant premier c, renouvelé à chaque génération de signature et, parmi les éléments de la signature, retourner une racine c-ième modulo un module RSA fort n. De plus, nous voulons que le premier c soit libre de toute relation, de façon à autoriser l usage de génération rapide de premiers. La seconde idée est, comme dans le schéma GHR, d utiliser une fonction de hachage caméléon, de façon à rendre fine la réduction de sécurité. De manière à n avoir qu un problème sous-jacent dans notre schéma de signature, nous voulons que la clé de cette fonction de hachage caméléon soit également du type des trappes RSA : pour cela, nous définissons un second module RSA fort N. Soit M = {0, 1} lm l ensemble des messages de notre schéma. Soit également l n un paramètre de sécurité. Alors, une description détaillée du schéma TSS est la suivante. 74

7.3. Un nouveau schéma de signature dans le modèle standard TSS [CJ07] Génération de clés : L utilisateur choisit un premier impair E de (l m + 1) bits, génère deux modules RSA forts n et N de l n bits, de telle façon que gcd(e, λ(n)) = 1, calcule D = E 1 mod λ(n) et enfin tire deux éléments aléatoires u Z n et g Z N. La clé publique est pk = {N, n, u, g, E} et la clé privée est sk = {λ(n), D}. Signature : Pour signer le message m {0, 1} lm, il faut choisir un premier aléatoire c de [ N+1 2, N 1], puis calculer s = u c 1 mod λ(n) mod n et r = (c g m ) D mod N. La signature du message m est alors σ = (r, s) Z N Z n. Vérification : Soit σ = (r, s) une signature supposée du message m {0, 1} lm. Pour la vérifier, il suffit de calculer c = g m r E mod N, puis de s assurer que s c = u mod n, c 2 et (r, s) Z N Z n. Si cette condition est vérifiée, la signature σ est acceptée. Remarque 1. Comme dans le schéma CS et dans ses variantes, il n est pas nécessaire de vérifier la primalité de c dans l algorithme de vérification. Pour TSS, nous ne devons même plus tester sa taille ou sa parité, mais seulement vérifier que c 2. Typiquement, nous pourrions avoir l m = 160 et l n = 1024, pour une utilisation avec des messages courts. Pourtant, s il est nécessaire de signer de longs messages, rien n empêche de prendre un paramètre l m plus grand. Alternativement, il est possible de précéder TSS d une étape de hachage des messages, en supposant alors également la résistance aux collisions. Ce schéma est sujet, comme bien souvent, à de nombreuses variantes. Il est par exemple possible de légèrement accélérer le calcul de la signature, en précalculant g 1 mod N ou g D mod N et en évaluant alors r comme r = (c (g 1 ) m ) D mod N ou bien comme r = c D (g D ) m mod N. 7.3.2 Analyse de sécurité Dans cette section, nous montrons que la sécurité de notre schéma est basée de façon fine sur l hypothèse RSA forte. Plus formellement, nous posons le théorème suivant. Théorème 10. Supposons que le problème FlexibleRSA est (τ, ε )-difficile. Alors, pour tout nombre q s de requêtes permis, le schéma de signature TSS est (τ, q s, ε)-sûr, où ε ε 2 et τ τ + O ( l n 5 + q s l n 3 max(log 2 q s, l n ) ). Dans ce théorème, la sécurité du schéma est entendue dans son sens le plus fort, c est-à-dire par la résistance aux falsifications existentielles faibles, sous attaques à messages choisis. Démonstration. De façon habituelle, la preuve est par contraposée. Nous supposons qu il existe un adversaire A capable de produire une falsification existentielle faible avec une probabilité non négligeable ε, en un temps polynomial τ, après avoir eu droit à q s requêtes de signature. Nous utilisons alors cet attaquant A pour résoudre en un temps τ et avec une probabilité ε le problème FlexibleRSA : étant donné un module RSA fort ˆn de l n bits et un élément aléatoire ŷ Z ˆn, nous voulons trouver une paire (ˆx, ê) Z ˆn N >1 satisfaisant ŷ ˆxê (mod ˆn). Dans la version finale de notre article [CJ07], nous expliquons comment se passer de tout test sur c. La même chose est possible dans le schéma CL. 75

Chapitre 7. Un schéma de signature dans le modèle standard Simulation. Au démarrage de l attaquant, nous prenons une valeur aléatoire b {0, 1} et exécutons la Simulation b définie ci-dessous. Simulation 0 Nous posons n = ˆn. Nous choisissons alors un premier (impair) E de (l m + 1) bits. Ensuite, nous générons un module RSA fort aléatoire N = (2P + 1)(2Q + 1) de l n bits, tel que gcd(e, 2P Q ) = 1 et en déduisons D = E 1 mod 2P Q. Nous choisissons un élément aléatoire g Z N. Finalement, pour tout i {1,..., q s}, nous tirons un premier c i de [ N+1 2, N 1], et définissons u = ŷ Q i c i mod n. Nous créons alors la clé publique pk = {N, n, u, g, E}. Nous pouvons voir aisément que l algorithme de génération de clés est parfaitement simulé. Quand A demande une signature d un message m j {0, 1} lm, pour j {1,..., q s }, nous simulons la signature par le calcul suivant : r j = (c j g m j ) D mod N et s j = ŷ Q i j c i mod n. Nous retournons σ j = (r j, s j ) comme une signature de m j. Là encore, la simulation est parfaite. Simulation 1 Nous posons N = ˆn et g = ŷ. Nous générons alors un module RSA fort n = (2p + 1)(2q + 1) de l n bits, ainsi qu un premier (impair) E de (l m + 1) bits. Sans perte de généralité, nous pouvons supposer que gcd(e, λ(n)) = 1, car sinon, E permettrait de factoriser N et d en déduire une infinité de solutions du challenge. Finalement, nous choisissons un élément aléatoire u Z n. Nous créons la clé publique pk = {N, n, u, g, E}. L algorithme de génération de clés est parfaitement simulé. Quand A demande une signature d un message m j {0, 1} lm, pour j {1,..., q s }, nous simulons la signature de la façon suivante : 1. Nous choisissons un élément aléatoire r j Z N et posons c j = g m j r j E mod N ; 2. Si c j n est pas un premier de [ N+1 2, N 1], nous retournons à l étape 1. Ensuite, nous calculons s j = u c j 1 mod 2p q mod n et retournons σ j = (r j, s j ) comme une signature de m j. La simulation est parfaite. Utilisation de la falsification. À la fin de l attaque, l adversaire A exhibe, avec une probabilité ε une falsification valide σ = (r, s ) Z N Z n sur un message m {0, 1} lm, avec (m, σ ) (m i, σ i ) pour tout i {1,..., q s }. Nous calculons c = g m r E mod N. Si c c j pour tout j {1,..., q s } et si b = 0 (c est-à-dire que la Simulation 0 a été exécutée), alors nous avons gcd(c, i c i) = 1, comme c est un entier de [0, N 1] et 76 comme les c i sont des nombres premiers de [ N+1 2, N 1]. C est pourquoi, par l algorithme étendu d Euclide, il est Q possible de trouver α et β entiers tels que α c + β i c i = 1. Aussi, en notant que ŷ i c i u s c (mod n) et n = ˆn, nous avons ŷ ŷ α c +β Q i c i ( ŷ α s β ) c (mod ˆn).

7.3. Un nouveau schéma de signature dans le modèle standard La paire (ˆx, ê) avec ˆx = ŷ α s β mod ˆn et ê = c est donc une solution de l instance du problème FlexibleRSA. Si c = c j pour un certain j {1,..., q s } (et par conséquent s = s j ) et si b = 1 (c est-à-dire que la Simulation 1 a été exécutée), alors, comme N = ˆn et g = ŷ, nous avons ( g m j r E j g m r E (mod N) = ŷ (m j m ) r ) E (mod ˆn), r j s j = s. Il est impossible d avoir m = m j car sinon nous aurions r = r j et donc (m, σ ) = (m j, σ j ), ce qui signifierait que la falsification ne serait pas nouvelle, et donc serait invalide. Aussi, comme E est un premier de (l m +1) bits, nous pouvons trouver des entiers α et β par l algorithme étendu d Euclide tels que α E+β (m j m ) = gcd(e, m j m ) = 1. Ainsi, nous avons ( ŷ ŷ α E+β (m j m ) ŷ α (r /r j ) β) E (mod ˆn) et la paire (ˆx, ê) avec ˆx = ŷ α (r /r j ) β mod ˆn et ê = E est une solution de l instance du problème FlexibleRSA. Dans les autres cas, c est-à-dire si c = c j pour un certain j {1,..., q s } et b = 0, ou si c c j pour tout j {1,..., q s } et b = 1, la réduction échoue. Comme la vue de l adversaire A est parfaitement simulée, et que donc celui-ci ne peut deviner b avec une probabilité meilleure que 1 2, la probabilité de notre réduction est de ε/2. Pour finir la démonstration, nous calculons le temps de notre réduction, en sachant qu il existe un algorithme de génération de premier fort qui soit quintique, un algorithme de génération de premier qui soit quartique, que l évaluation des exponentiations et des inverses modulaires est cubique, et que le test de primalité est cubique, toutes ces complexités étant données en terme de longueur binaire. Pour la Simulation 0, nous devons générer un module RSA N de l n bits, un premier E de (l m + 1) bits, un inverse modulaire D et un paramètre u durant la phase de génération de clés ; nous devons aussi, pour chaque requête de signature, calculer r j et s j. L évaluation de u et des q s valeurs s j peut être fait en O(q s log 2 q s ) exponentiations de l n bits, en utilisant la technique de [CLP05, Paragraphe 3.3]. C est pourquoi le temps d exécution approximatif de la Simulation 0 est de τ + O(l 5 n + q s log 2 q s l 3 n ). Pour la Simulation 1, nous devons de manière assez similaire générer un module RSA n de l n bits et un premier E de (l m + 1) bits. Enfin, pour chaque requête de signature, nous devons effectuer une exponentiation, tester la primalité du résultat, et réitérer jusqu à obtenir un premier, pour terminer par le calcul d un inverse modulaire et d une exponentiation. Comme la probabilité d un aléa de l n bits d être premier est en 1 l n, nous obtenons pour la Simulation 1 un temps total d exécution approximatif de τ + O(l 5 n + q s l 4 n ). 7.3.3 Comparaison avec les autres schémas Dans la Table 7.1, nous comparons les avantages et les inconvénients des schémas présentés en Section 7.1 avec le schéma TSS. Nous incluons notamment les différences de finesse des Notamment, nous avons bien ê 2. Il est pour cela très important de tester que c 2 dans l algorithme de vérification. 77

Chapitre 7. Un schéma de signature dans le modèle standard réductions de sécurité dans le modèle standard, et la taille des signatures, des clés publiques et privées. Quand cela est nécessaire, nous donnons également les conditions que la fonction de hachage doit remplir (en plus de la résistance aux collisions). GHR O 1 q s Tab. 7.1 Comparaison des performances. Sécurité Tailles Longueurs Finesse Hypothèse typiques σ pk sk Div + FlexibleRSA l n 1024 l n 2l n 1 2 ln GHR (caméléon) O(1) Div + DL + FlexibleRSA Twin-GHR O(1) FlexibleRSA CS O 1 q s CL O 1 q s Fischlin O 1 q s FlexibleRSA FlexibleRSA FlexibleRSA TSS O(1) FlexibleRSA l n = l p = 1024 l q = 160 l n = 1024 l m = 160 l n 1024 l h = 160 l n 1024 l m = 160, l = 80 l n 1024 l h = 160 l n = 1024 l m = 160 l n + l q 2l n + 3l p 1 2 ln 2l n + 2l m 4l n l n 2l n + l h 3l n + l h 1 2 ln 2l n + 2l m + l 4l n 1 2 ln l n + 2l h 4l n 1 2 ln 2l n 4l n + l m l n Pour les tailles des clés secrètes, nous avons considéré les faits suivants. Dans la description de GHR et des schémas de type CS, nous avons sk = {p, q } ; cependant, il est possible de ne stocker que la valeur p et de retrouver q à partir de p et de pk. De façon similaire, dans Twin-GHR, le stockage de sk = {p, P } est suffisant, et dans TSS, il est possible de retrouver sk = {λ(n), D} à partir d un facteur de n, d un facteur de N et de pk. À partir de cette table, il apparaît que TSS et Twin-GHR sont les seuls schémas dont la sécurité prouvée, dans le modèle standard, se réduit uniquement à l hypothèse RSA forte, avec une réduction fine. De plus, nous voyons que cela n est pas fait au prix d hypothèses supplémentaires sur la fonction de hachage, comme l indivisibilité du schéma GHR. C est pourquoi nous avons placé dans une table séparée ces deux schémas, pour offrir une comparaison plus détaillée. Tab. 7.2 Comparaison entre TSS et Twin-GHR. Premiers à générer Tailles Signature Vérification Longueur σ pk sk Twin-GHR 2 2 2l m + τ 2l n + 2l m 4l n l n TSS 1 0 l n 2l n 4l n + l m l n Comparé aux signatures jumelles GHR, notre schéma offre une vérification plus simple et plus rapide, car aucune génération de premier n est effectuée dans la vérification de TSS, quand deux appels à la fonction injective P sont nécessaires dans Twin-GHR. Notons également que le Pour simplifier la lecture, nous avons arrondi les tailles à quelques bits près. 78

7.3. Un nouveau schéma de signature dans le modèle standard premier généré dans TSS peut être calculé hors-ligne, contrairement à l un des deux premiers à générer dans Twin-GHR. De plus, dans notre schéma, les signatures sont plus courtes que dans le schéma Twin-GHR. Tout ceci rend notre schéma intéressant, du moment que le prix à payer, une clé publique plus grande, n est pas un point bloquant. Du côté des désavantages, notre schéma produit des signatures plus longues que les schémas Fischlin ou GHR (mais qui restent plus courtes que celles des schémas CS ou CL). Un autre désavantage est le temps de calcul d une signature : le schéma TSS nécessite la génération d un premier aléatoire de [ N+1 2, N 1]. Même en utilisant des méthodes efficaces de génération de premier (par exemple, [JPV00]), ceci peut être très consommateur de temps pour des objets cryptographiques à faibles ressources. Aussi, nous présentons dans la section suivante une version en-ligne/hors-ligne (voir les Sections 4.2.2, 5.2.1 et 6.3.4) de notre schéma pour résoudre ce problème de rapidité. 7.3.4 Version en-ligne/hors-ligne Soit M = {0, 1} lm l ensemble des messages de notre schéma. Soient également l n et l deux paramètres de sécurité. Typiquement, nous pourrions avoir l = 80 + log 2 (q s ) = 110 et l n = 1024. Alors, une description détaillée du schéma TSS, dans sa version en-ligne/hors-ligne, est la suivante. TSS en-ligne/hors-ligne [CJ07] Signature, partie hors-ligne : Pour préparer un coupon, le signataire choisit un premier aléatoire c de [ N+1 2, N 1], et un aléa k de (l n + l m + l) bits. Ensuite, il calcule s = u c 1 mod λ(n) mod n et r = g k c D mod N, et stocke le coupon (k, r, s). Signature, partie en-ligne : Pour signer un message m M, le signataire utilise un nouveau coupon (k, r, s) et calcule simplement k = k + D m. La signature sur le message m est σ = (k, r, s) {0, 1} ln+lm+l+1 Z N Z n. Vérification : Soit σ = (k, r, s) la signature du message m {0, 1} lm qui doit être testée. Pour la vérifier, il suffit de calculer c = g m (r g k ) E mod N, puis de s assurer que s c = u mod n et c 2. Si cette condition est vérifiée, la signature σ est acceptée. Il est intéressant de noter que la génération de clés de cette variante de notre schéma reste la même que la version classique de TSS décrite en Section 7.3.1. Preuve de sécurité. Nous montrons maintenant que la notion de sécurité EUF-CMA de cette version en-ligne/hors-ligne de notre schéma peut se réduire de façon fine à l hypothèse RSA forte. En fait, nous prouvons exactement que si un attaquant EUF-CMA (que nous appellerons A ) contre cette version en-ligne/hors-ligne existe, alors il est un attaquant EUF-CMA contre la version classique de TSS décrite en Section 7.3.1. De façon plus détaillée, soit une clé publique pk = { ˆN, ˆn, û, ĝ, Ê}. Avec au maximum q s requêtes de signature à un oracle TSS, nous voulons produire une falsification TSS notée ˆσ = (ˆr, ŝ ) d un nouveau message ˆm, en utilisant l attaquant A. Initialisation de l attaquant. Nous posons pk = pk (c est-à-dire {N, n, u, g, E} = { ˆN, ˆn, û, ĝ, Ê}) la clé de la version en-ligne/hors-ligne de TSS. 79

Chapitre 7. Un schéma de signature dans le modèle standard Requêtes de signature. Quand A demande une signature (en-ligne/hors-ligne) d un message m j {0, 1} lm, pour un j {1,..., q s }, nous utilisons une requête à l oracle de signature TSS avec comme message ˆm j = m j et recevons en retour la signature TSS notée ˆσ j = (ˆr j, ŝ j ) telle que ĉ j = ĝ mj ˆr Ê j mod ˆN est un premier de [ N + 1, N 1 ] ĉ et ŝ j j = û mod ˆn. 2 Ensuite, nous tirons un nombre aléatoire k j de (l n + l m + l) bits. Nous calculons r j = ˆr j ĝ k j mod ˆN et posons s j = ŝ j. Nous retournons alors à l attaquant A la signature en-ligne/hors-ligne σ j = (k j, r j, s j ) du message m j. La signature σ j est une signature valide, car c j = g m j (r j g k j ) E mod N = ĝ mj ˆr Ê j mod ˆN = ĉ j est un premier de [ N+1 2, N 1] et s c j ĉ j ŝ j j û u (mod n). Utilisation de la falsification : À la fin de son attaque, avec une probabilité ε A et en un temps τ A, A retourne une falsification existentielle (non-faible) contre la version enligne/hors-ligne du schéma σ = (k, r, s ) d un message m {0, 1} lm, avec m m j pour tout j {1,..., q s }. À partir de σ = (k, r, s ), nous fabriquons la falsification existentielle (non-faible) contre le schéma TSS que nous notons ˆσ = (ˆr, ŝ ), avec ˆr = r ĝ k mod ˆN et ŝ = s mod n, du message ˆm = m. Il est aisé de voir que cette falsification est une falsification valide sur un nouveau message, car, comme m m j, il s ensuit que ˆm, ˆm j pour tout j {1,..., q s }. Finesse de la réduction. La distance statistique entre les k j retournés par la simulation et les k j qui seraient retournés par le véritable signataire est de q s 2 l. C est pourquoi, notre réduction réussit, avec une probabilité ε ε A q s 2 l et en un temps τ τ A + (q s + 1) O(l n 3 ) à transformer un attaquant EUF-CMA de la variante en-ligne/hors-ligne en un attaquant EUF- CMA de la forme classique de TSS. Comme la version classique de notre schéma est sûre sous l hypothèse forte RSA, la version en-ligne/hors-ligne du schéma est donc, elle aussi, sûre contre les attaques EUF-CMA, sous l hypothèse RSA forte, et ceci avec une réduction fine. À propos des attaques seuf-cma. La preuve de sécurité ci-dessus prend l hypothèse de l existence d un attaquant EUF-CMA (et non d un attaquant seuf-cma) contre la version enligne/hors-ligne de TSS. Nous expliquons ci-dessous pourquoi la preuve ne serait pas valide pour un attaquant seuf- CMA. Imaginons un tel attaquant, retournant une falsification σ = (k, r, s ) σ j pour un message déjà soumis à l oracle de signature m = m j, pour un certain j {1,..., q s }. Alors, la falsification déduite par la réduction ci-dessus est ˆσ = (ˆr, ŝ ), pour le message ˆm = m. Cette falsification n est pas forcément valide, c est-à-dire telle que ( ˆm, ˆσ ) ( ˆm j, ˆσ j ). En effet, ˆm = ˆm j et σ σ j (k, ˆr ĝ k mod ˆN, ŝ ) (k j, ˆr j ĝ k j mod ˆN, ŝ j ) (ˆr, ŝ ) (ˆr j, ŝ j ). Ceci est encore plus explicite avec un contre-exemple : si σ = (k, r, s) est une signature enligne/hors-ligne valide du message m, alors σ = (k+1, g r mod N, s) est également une signature Contre les attaques seuf-cma et donc aussi contre les attaques EUF-CMA. 80

7.4. Conclusion en-ligne/hors-ligne valide de ce même message m. Aussi, la version en-ligne/hors-ligne de TSS décrite dans ce paragraphe n est pas seuf-cma-sûre, mais seulement EUF-CMA-sûre. Cependant, pour la plupart des applications cryptographiques, la résistance aux falsifications existentielles (simples) est suffisante. Le schéma TSS en-ligne/hors-ligne peut néanmoins être transformé en un schéma de signature qui résiste aux falsifications existentielles faibles (c est-àdire qui atteint le niveau seuf) en utilisant la technique d Adi Shamir et Yael Tauman [ST01] (voir Chapitre 5), au prix d une clé plus longue. 7.4 Conclusion Dans ce chapitre, nous avons proposé un schéma de signature sûr contre les attaques seuf- CMA sous la seule hypothèse de difficulté du problème FlexibleRSA, dans le modèle standard et avec une réduction fine. Contrairement au schéma CS et à ses variantes, la sécurité du schéma TSS est optimale ; contrairement au schéma GHR, l optimalité de la réduction n est pas obtenue au prix d une propriété particulière de la fonction de hachage. En fait, le schéma TSS ne fait pas même usage pour une utilisation avec des messages courts d une fonction de hachage, ce qui peut être vu comme un avantage supplémentaire au vu des dernières publications exposant des collisions sur des fonctions de hachage pourtant réputées. D après ses caractéristiques, TSS est plus proche des signatures jumelles GHR, même si ces deux schémas sont construits de façon bien différente. La comparaison de ces deux derniers schémas montrent que TSS est plus efficace dans l étape de vérification des signatures et dans la taille de celles-ci, au prix d une clé publique plus grande. Le schéma TSS est aussi proposé en version en-ligne/hors-ligne, ce qui est très utile pour des applications contraintes ou des objets cryptographiques bas-coût. 81

Chapitre 7. Un schéma de signature dans le modèle standard 82

Troisième partie Schéma de chiffrement à sécurité prouvée 83

Chapitre 8 Introduction aux schémas de chiffrement Sommaire 8.1 Chiffrement à clé publique.......................... 85 8.1.1 Définition.................................... 85 8.1.2 Notions de sécurité pour le chiffrement à clé publique............ 86 8.2 Quelques cryptosystèmes classiques..................... 88 8.2.1 Cryptosystème RSA............................... 88 8.2.2 Cryptosystème ElGamal............................ 89 8.2.3 Cryptosystème Paillier............................. 89 8.3 Chiffrement basé sur l identité........................ 90 8.3.1 Définition.................................... 90 8.3.2 Notions de sécurité pour le chiffrement basé sur l identité......... 91 8.3.3 Cryptosystème Boneh-Franklin......................... 91 8.4 Nos travaux sur les schémas de chiffrement................ 92 Après l étude des schémas de signature, une deuxième partie de notre travail de thèse a été consacrée à l étude des schémas de chiffrement, de leur conception à leur sécurité prouvée. Nous avons ainsi conçu de nouveaux cryptosystèmes, présentés dans cette partie. 8.1 Chiffrement à clé publique Tout d abord, dans cette section, nous rappelons quelques notions élémentaires permettant l étude des schémas de chiffrement. 8.1.1 Définition Le chiffrement est sans doute la partie la plus ancienne de la cryptographie : depuis toujours pour des raisons militaires tout d abord puis pour de simples besoins de confidentialité, des personnes ont exprimé le besoin de communiquer en s échangeant des messages chiffrés, c est-àdire qui, sans une clé, ne pouvaient être analysés. Ces schémas de chiffrement étaient symétriques, en ce sens que la clé de chiffrement était la même que la clé de déchiffrement. C est avec l invention de la clé publique par Whitfield Diffie et Martin Hellman [DH76] que la cryptographie est passée dans une nouvelle ère. 85

Chapitre 8. Introduction aux schémas de chiffrement Dans un schéma de chiffrement à clé publique, toute entité peut chiffrer un message pour un destinataire, en utilisant la clé publique de celui-ci. Le destinataire peut alors, avec la clé privée correspondante, déchiffrer le chiffré pour retrouver le message clair correspondant. Définition 17 (Schéma de chiffrement). Un schéma de chiffrement (sous-entendu, à clé publique) est un ensemble d algorithmes probabilistes définis comme suit : L initialisation des paramètres Set E. Recevant en entrée 1 κ, l algorithme Set S initialise des paramètres communs nécessaires au schéma ; La génération de clés Gen E. Étant donné une entrée 1κ, l algorithme Gen E produit une paire de clés : pk E, la clé publique, et sk E la clé privée correspondante ; L algorithme de chiffrement Encrypt. Étant donné un message m dans un ensemble de messages M et une clé publique pk E, l algorithme Encrypt produit un chiffré c = Encrypt pke (m; r), où r désigne l aléa utilisé par Encrypt ; L algorithme de déchiffrement Decrypt. Étant donné un chiffré c et une clé privée sk E, l algorithme Decrypt retourne le clair correspondant, ou un symbole particulier si le chiffré c est invalide. Il existe des schémas de chiffrement sans paramètres communs, auquel cas l algorithme d initialisation des paramètres est omis. 8.1.2 Notions de sécurité pour le chiffrement à clé publique Tout comme un schéma de signature (voir Section 4.3.1), un schéma de chiffrement doit protéger de différentes attaques. Pour cela, de nombreuses notions de sécurité ont été définies, basées principalement sur le travail de Shafi Goldwasser et Silvio Micali [GM84]. La résistance des schémas de chiffrement s évalue dans différents scénarios d attaque. Chaque scénario est défini en donnant à l attaquant un but, c est-à-dire ce qu il va chercher à mettre en défaut dans le système, et des ressources, c est-à-dire les informations auxquelles il aura accès pour réaliser son attaque. Ressources de l attaquant. Les ressources disponibles peuvent être de différentes natures. Dans un premier mode, l attaquant ne reçoit que la clé publique du destinataire. Dans le monde de la cryptographie à clé publique, c est l information minimale que l attaquant peut posséder. Comme ce dernier peut alors chiffrer grâce à la clé publique, cela caractérise les attaques à clairs choisis, notées CPA (en anglais, chosen-plaintext attack). Pourtant, un mode supérieur et plus réaliste est celui où l attaquant accède à un oracle de déchiffrement, avec éventuellement une limitation sur les requêtes. Comme pour les attaques sur les schémas de signature, cet accès peut être non-adaptatif [NY90] ou adaptatif [RS91]. Ces dernières ressources forment les attaques adaptatives à chiffrés choisis, et sont les ressources les plus puissantes qui peuvent être fournies à un attaquant contre un schéma de chiffrement. Elles sont notées CCA (en anglais, chosen-ciphertext attack). Notons que certaines limitations sur les ressources de l attaquant apparaîtront naturellement dans la suite. But de l attaquant. Une fois ses ressources fournies, l attaquant doit avoir un but. Pour chacun de ces buts, une notion de sécurité correspondant à l impossibilité de réaliser cet objectif est alors définie. Nous ne rappellerons ici que les buts et notions les plus classiques. Le but le plus immédiat est le cassage de la clé. C est le but qui est apparu le plus immédiatement, dès l invention de la cryptographie à clé publique. La notion de sécurité associée, appelée résistance de la clé, est notée UBK (en anglais, unbreakability). Néanmoins, même si le 86

8.1. Chiffrement à clé publique cassage de la clé est le but ultime de tout attaquant, il existe des buts plus faciles à atteindre pour un attaquant, et qui pourtant peuvent conduire à des failles de sécurité. Un deuxième but est d être capable de déchiffrer un chiffré donné. La notion associée est le sens unique de la fonction de chiffrement, et est notée OW (en anglais, one-wayness). Ce type d attaque est aussi dangereux en pratique que le cassage de clé. En effet, il importe peu de savoir si l attaquant, pour déchiffrer un message, utilise directement la clé privée ou s il utilise une procédure détournée : avec ce type d attaque, l attaquant peut tout autant mettre en danger le système de chiffrement que lors d un cassage de clé. Enfin, un troisième but pour l attaquant, le plus faible, est d obtenir un simple bit d information sur le clair correspondant à un chiffré donné. La notion correspondante est appelée la sécurité sémantique ou indistinguabilité [GM84], et est notée IND. Elle signifie qu un attaquant ne peut deviner, parmi deux clairs qu il a précédemment choisis, lequel correspond à un chiffré qui lui a été retourné. En pratique, ce type d attaque correspond au cas où l adversaire sait que le clair est dans un espace restreint de messages (par exemple, si c est une réponse oui ou non ). Ainsi, la sécurité sémantique ne peut être atteinte par un schéma de chiffrement déterministe. Notons qu il existe une autre autre notion [DDN00], appelée la non-malléabilité et notée NM, qui en simplifiant stipule qu un attaquant ne peut former un chiffré à partir d un chiffré fourni, tel que les clairs correspondants suivent une relation non triviale. Il a été montré dans [BDPR98] que, dans le cadre des attaques à chiffrés choisis, cette notion est équivalente à l indistinguabilité. Schéma de chiffrement sûr. Chaque attaquant est ainsi mesuré en lui adjoignant la notion de sécurité qu il cherche à mettre en défaut et des ressources : nous notons alors chaque attaque Notion-Ressource, où Notion {UBK, OW, IND, NM} et Ressource {CPA, CCA}. Il est de nos jours classique de demander qu un schéma de chiffrement offre une sécurité sémantique sous attaques à chiffrés choisis. Ainsi, nous dirons qu un schéma de chiffrement est sûr s il protège de la distinguabilité sous attaques (sous-entendu, adaptatives) à chiffrés choisis (c est-à-dire les attaques IND-CCA). Ceci est mesuré par l avantage de n importe quel attaquant A dans le jeu suivant : Mise en place : Le système choisit un paramètre de sécurité κ, et exécute l algorithme Gen E. Il retourne alors à l adversaire la clé publique pk E, et garde la clé secrète correspondante sk E. Phase 1 : L adversaire peut effectuer adaptativement des requêtes Decrypt : pour un chiffré c i de son choix, le système renvoie le clair associé (s il existe). À la fin de cette phase, l adversaire retourne une paire de messages (m 0, m 1 ), de même longueur, de l ensemble M, sur lesquels il veut que le challenge soit effectué. Challenge : Le système tire un bit aléatoire b {0, 1}, et calcule un chiffré c de m b. Ce chiffré est envoyé à l adversaire. Phase 2 : À la manière de la première phase, l adversaire peut effectuer adaptativement des requêtes à l oracle de déchiffrement, avec pour seul contrainte de ne pas lui soumettre le chiffré c. Réponse : À la fin de son attaque, l adversaire retourne son estimation b {0, 1}. Il gagne alors le jeu si b = b. Symboliquement, cela est résumé par l expression [ AdvE IND-CCA (pk, sk) Gen (A) = 2 Pr E (1 κ ), (m 0, m 1, s) A Decrypt ] sk E ( ) 1 (pk), b,r c = Encrypt pke (m b ; r) : A Decrypt sk E ( ) 2 (m 0, m 1, s, c ) = b 1. 87

Chapitre 8. Introduction aux schémas de chiffrement Précisons ici que la sécurité d un schéma de chiffrement est mesurée au travers d un avantage, alors que la sécurité d un schéma de signature est mesurée grâce à une probabilité (celle d exhiber une falsification existentielle sous attaque à messages choisis, voir Section 4.3.1). En effet, dans le jeu défini ci-dessus, il existe toujours un attaquant possédant une probabilité de succès de 1 2, puisqu il suffit pour cela de retourner un b aléatoire. Ainsi, pour qu un attaquant puisse prouver un vrai gain d information, il faut qu il puisse deviner avec une probabilité significativement supérieure à 1 2 la valeur de b. C est pourquoi les cryptologues utilisent l avantage, qui est la différence entre la probabilité qu un attaquant devine la bonne valeur de b et 1 2, multiplié par un facteur 2, pour normalisation entre 0 (aucun avantage) et 1 (avantage parfait). 8.2 Quelques cryptosystèmes classiques Dans cette section, nous décrivons succinctement quelques schémas de chiffrement. Nous donnons ici les versions sûres contre les attaques à clairs choisis, sachant que des transformations génériques [FO99, FO00, Poi00] permettent dans le modèle de l oracle aléatoire de transformer un schéma avec une telle sécurité en un schéma résistant aux attaques à chiffrés choisis. La seule exception que nous ferons sera pour le schéma de chiffrement RSA qui est très classiquement connu pour l ensemble qu il constitue avec la fonction de padding OAEP comme RSA-OAEP(voir la Section 1.3.7 sur les fonctions de padding ). 8.2.1 Cryptosystème RSA Le schéma de chiffrement RSA fut inventé par Ronald Rivest, Adi Shamir et Leonard Adleman dans [RSA78], en même temps que le schéma de signature du même nom (voir Section 4.4.1). Tout comme pour ce dernier, le schéma de chiffrement RSA fut décrit tout d abord au travers de la primitive RSA, avant que l intérêt de fonctions de padding ne soit démontré (voir Section 4.3.3). Le chiffrement RSA se décrit comme suit, pour une fonction de padding µ. Chiffrement RSA [RSA78] Génération de clés : Pour générer une paire de clés, l utilisateur choisit un exposant public e > 2 impair, et tire un module RSA n = pq (voir Définition 1) de l n bits, tel que (p 1)(q 1) et e soient premiers entre eux. Ensuite, l utilisateur calcule d = e 1 mod (p 1)(q 1). La clé privée de l utilisateur est d tandis que sa clé publique est (e, n). Chiffrement : Pour chiffrer un message m M pour une identité dont la clé publique est (e, n), l utilisateur tire un aléa r R et calcule la valeur c = µ(m, r) e mod n. Le chiffré de m est c. Déchiffrement : Pour déchiffrer c, il suffit de calculer v = c d mod n. Si et seulement si µ 1 (v), le message clair m = µ 1 (v) est retourné. Typiquement, la fonction de padding utilisée est OAEP [BR94], donnant lieu à l ensemble RSA-OAEP, pour lequel il existe, dans le modèle de l oracle aléatoire une réduction lâche du problème RSA vers les attaques IND-CCA [BR94, Sho01, FOPS04]. Les chiffrés RSA font une taille de l n bits. De façon usuelle, d après les algorithmes connus pour résoudre le problème RSA, les paramètres choisis sont l n = 1024, et e = 2 16 + 1, pour une sécurité lâche. 88

8.2. Quelques cryptosystèmes classiques 8.2.2 Cryptosystème ElGamal Le chiffrement ElGamal fut introduit par Taher ElGamal [ElG85]. Ce cryptosystème a fait l objet de travaux de notre part, exposés dans cette thèse dans le Chapitre 9. Aussi, nous ne donnons ici qu une définition succincte de ce schéma, et renvoyons le lecteur intéressé à ce chapitre pour de plus amples informations. Chiffrement ElGamal [ElG85] Génération de clés : Pour générer une paire de clés, l utilisateur choisit un groupe cyclique G (noté ici multiplicativement) d ordre premier q et un générateur g. Il génère alors un aléa x Z q, et calcule y = g x. La clé privée de l utilisateur est x tandis que sa clé publique est (y, g, G). Toutefois, les paramètres g et G peuvent être communs à un groupe d utilisateurs. Chiffrement : Pour chiffrer un message m G pour une identité dont la clé publique est (y, g, G), l utilisateur tire un aléa r Z q et calcule les valeurs u = g r et v = y r m. Le chiffré de m est (u, v). Déchiffrement : Pour déchiffrer (u, v), il suffit de calculer m = v u x. Ce cryptosystème est à sens unique sous l hypothèse de difficulté du CDH, et est sémantiquement sûr si le problème DDH est difficile, tout ceci étant entendu sous attaque à clairs choisis, dans le modèle standard (voir Section 9.1 pour plus de détails). Les chiffrés ElGamal font une taille de 2l p bits, où l p est le nombre de bits nécessaires pour représenter un élément du groupe G. Habituellement, G est un sous-groupe de Z p (pour un grand premier p) ou un sous-groupe de points d une courbe elliptique. 8.2.3 Cryptosystème Paillier Le schéma de chiffrement Paillier fut inventé par Pascal Paillier dans [Pai99b]. Nous référons également le lecteur intéressé à la thèse [Pai99a]. Ce schéma utilise la fonction L(u) = uφ(n) 1 mod n 2 n. Chiffrement Paillier [Pai99a, Pai99b] Génération de clés : Pour générer une paire de clés, l utilisateur sélectionne un module RSA n = pq. Ensuite, l utilisateur choisit une base g Z n 2, tel que L(g) Z n. La clé privée de l utilisateur est φ(n) tandis que sa clé publique est (g, n). Chiffrement : Pour chiffrer un message m Z n pour une identité dont la clé publique est (g, n), l utilisateur tire un aléa r Z n et calcule la valeur Le chiffré de m est c. c = g m r n mod n 2. Déchiffrement : Pour déchiffrer c, il suffit d utiliser la fonction L pour retrouver m selon m = L(c) L(g) mod n. 89

Chapitre 8. Introduction aux schémas de chiffrement Ce cryptosystème est indistinguable sous l hypothèse de la résiduosité composite [Pai99a, Pai99b], pour les attaques à clairs choisis. Pour les attaques à chiffrés choisis, ce schéma peut être rendu sûr dans le modèle de l oracle aléatoire à travers l usage de techniques génériques [FO99, FO00, Poi00], ou par une technique dédiée [PP99]. Les chiffrés Paillier font une taille de 2l n bits pour un module qui, d après les algorithmes connus pour résoudre le problème de la résiduosité composite, fait l n = 1024 bits. 8.3 Chiffrement basé sur l identité 8.3.1 Définition Une des difficultés de la mise en place de systèmes à clé publique est la gestion de l infrastructure des clés publiques (PKI). En effet, avant d utiliser une clé publique, il faut s assurer que celle-ci est vraiment la clé du destinataire, pour éviter des attaques dites par-le-milieu (en anglais, man-in-the-middle). Ceci est classiquement vérifié grâce à des certificats, qui ne sont autres que des signatures émanant d autorités de confiance validant le fait que la clé publique utilisée est bien celle d un utilisateur donné. Une autre solution fut proposée par Adi Shamir [Sha84] : la cryptographie basée sur l identité (en anglais, Identity-Based Encryption, IBE). Dans ce type de schéma, chaque personne est identifiée par une chaîne unique de bits (son identité), pouvant prendre a priori n importe quelle valeur. Typiquement, l identité peut être un numéro de sécurité sociale ou une adresse mél. D autre part, une autorité génère une clé maître et publie des paramètres de système. Ces paramètres sont suffisants à tout utilisateur pour chiffrer un message destiné à une identité choisie. Un utilisateur peut, à tout moment (c est-à-dire éventuellement après la création par un tiers d un chiffré à son attention), demander à l autorité la clé privée correspondant à son identité : avec cette clé, l utilisateur pourra alors retrouver le message clair qui lui a été envoyé. Définition 18 (Schéma de chiffrement basé sur l identité). Un schéma de chiffrement basé sur l identité IBE est défini par quatre algorithmes : La mise en place du système Set IBE. Étant donné une entrée 1κ, l algorithme Set IBE produit une clé maître sk IBE et un ensemble de paramètres publics params, incluant notamment la description d un ensemble de messages M et d un ensemble de chiffrés C ; L algorithme d extraction Extract. Étant donné une clé maître sk IBE, un ensemble de paramètres publics params et une identité ID, l algorithme Extract produit une clé privée sk ID ; L algorithme de chiffrement Encrypt. Étant donné un message m dans un ensemble de messages M, une identité ID et un ensemble de paramètres publics params, l algorithme Encrypt produit un chiffré c = Encrypt ID (m; r), où r désigne l aléa utilisé par Encrypt ; L algorithme de déchiffrement Decrypt. Étant donné un chiffré c, une identité ID, un ensemble de paramètres publics params et une clé privée sk ID, l algorithme Decrypt retourne le clair correspondant, ou un symbole particulier si le chiffré c est invalide. Alors que le concept fut inventé par Adi Shamir en 1984, il fallu attendre 2001 et le schéma de Dan Boneh et Matthew Franklin [BF01] pour voir la première réalisation concrète et sûre d un schéma de chiffrement basé sur l identité. Ce schéma est rappelé en Section 8.3.3 et a fait l objet d une partie de nos recherches, exposée au Chapitre 10. 90

8.3. Chiffrement basé sur l identité 8.3.2 Notions de sécurité pour le chiffrement basé sur l identité Comme toute primitive cryptographique, les schémas de chiffrement basés sur l identité sont prouvés sûrs selon des scénarios d attaque. Ceux-ci sont en fait très proches des scénarios des schémas de chiffrement (voir Section 8.1.2), avec en plus quelques spécificités pour la fonction Extract. Nous ne donnerons donc ici que les deux principaux modèles d attaquant. La notion de sécurité d un IBE la plus forte est l indistinguabilité contre les attaques à chiffrés et identités choisis (IND-ID-CCA) [BF01, BF03]. Dans ce modèle, l attaquant est supposé pouvoir accéder adaptativement à un oracle de déchiffrement (comme dans les schémas de chiffrement classiques), mais également à un oracle lui donnant la clé privée correspondant à des identités de son choix. Ceci symbolise le fait que l adversaire pourrait être un regroupement d entités utilisant leurs clés privées pour attaquer un tiers. Le succès de l attaquant IND-ID-CCA est formalisé par son avantage dans le jeu suivant : Mise en place : Le système choisit un paramètre de sécurité κ, et exécute l algorithme Set IBE. Il retourne alors à l adversaire les paramètres params, et garde la clé maître sk IBE. Phase 1 : L adversaire peut effectuer adaptativement les requêtes suivantes : Extract pour une identité ID i : le système renvoie alors la clé privée sk IDi. Decrypt pour une identité ID i et un chiffré c i : le système renvoie alors le clair (s il existe) qui correspond au chiffré c i pour l identité ID i. À la fin de cette phase, l adversaire retourne une paire de messages (m 0, m 1 ), de même longueur, de l ensemble M et une identité ID, sur lesquels il veut que le challenge soit effectué. Une contrainte de bon sens veut toutefois que l adversaire n ait pas demandé à l oracle Extract la clé secrète correspondant à l identité ID. Challenge : Le système tire un bit aléatoire b {0, 1}, et calcule un chiffré c de m b. Ce chiffré est alors envoyé à l adversaire. Phase 2 : À la manière de la première phase, l adversaire peut effectuer adaptativement les requêtes suivantes : Extract pour une identité ID i ID : le système renvoie alors la clé privée sk IDi. Decrypt pour une identité ID i et un chiffré c i (avec bien évidemment (ID i, c i ) (ID, c )) : le système renvoie alors le clair (s il existe) qui correspond au chiffré c i pour l identité ID i. Réponse : À la fin de son attaque, l adversaire retourne son estimation b {0, 1}. Il gagne alors le jeu si b = b. Un autre niveau de sécurité est l indistinguabilité contre les attaques à clairs et identités choisis (IND-ID-CPA) [BF01, BF03]. Dans ce scénario d attaque, le succès de l attaquant est mesuré par un jeu essentiellement similaire à celui de l attaque IND-ID-CCA, dans lequel les requêtes à l oracle Decrypt lui sont retirées. 8.3.3 Cryptosystème Boneh-Franklin Le schéma de chiffrement basé sur l identité Boneh-Franklin fut inventé par Dan Boneh et Matthew Franklin dans [BF01, BF03]. Il a permis la première réalisation d une idée vieille de plus de quinze ans [Sha84], grâce à l utilisation à des fins constructives d une fonction bilinéaire (voir aussi [Jou00]) : le couplage de Weil ou le couplage de Tate. Ce schéma se décrit plus aisément en partant de la version IND-ID-CPA ci-dessous, en sachant qu il est possible d appliquer à cette version la transformation générique de Eiichiro Fujisaki Historiquement [MOV93, FMR99], les fonctions bilinéaires servaient plutôt à casser des schémas. 91

Chapitre 8. Introduction aux schémas de chiffrement et Tatsuaki Okamoto [FO99] pour obtenir un schéma IND-ID-CCA, dans le modèle de l oracle aléatoire, tel qu expliqué dans [BF01, BF03]. Chiffrement Boneh-Franklin [BF01, BF03] Mise en place des paramètres : L autorité génère des paramètres, composés de deux groupes G 1 et G T d ordre q, d une application bilinéaire e : G 1 G 1 G T et d un générateur g de G 1. Ensuite, l autorité génère un aléa x Z q, et calcule y = g x. Elle choisit également la longueur l m des messages, et pose M = {0, 1} lm. Enfin, deux fonctions de hachage H : {0, 1} G 1 et G : G T {0, 1} lm sont sélectionnées. Alors, params = q, G 1, G T, e, M, g, y, G, H et sk IBE = x Extraction de clé : Pour générer la clé privée de l identité ID, l autorité calcule h ID = H(ID), puis sk ID = h ID x est retournée. Chiffrement : Pour chiffrer un message m M à une identité ID, l utilisateur tire un aléa r Z q, puis calcule h ID = H(ID) et w = e(y, h ID ) r. Ensuite, il calcule c 0 = g r et c 1 = m G(w). Le chiffré c = (c 0, c 1 ) est alors retourné. Déchiffrement : Pour déchiffrer un chiffré c = (c 0, c 1 ) G 1 M, l utilisateur ID calcule w = e(c 0, sk ID ), puis retrouve le message m selon m = c 1 G(w ). Le schéma Boneh-Franklin avec la transformation générique de Eiichiro Fujisaki et Tatsuaki Okamoto [FO99] est sûr, dans le modèle de l oracle aléatoire, contre les attaques IND-ID- CCA sous l hypothèse de la difficulté du problème CBDH. 8.4 Nos travaux sur les schémas de chiffrement Après avoir présenté dans ce chapitre le contexte des schémas de chiffrement, avec une particularité pour les schémas basés sur l identité, nous allons dans les chapitres suivants développer nos travaux sur ce domaine de la cryptographie. Tout d abord, dans le Chapitre 9, nous étudions le schéma de chiffrement ElGamal dans son utilisation pratique, et en dévoilons quelques désagréments auxquels nous proposons une solution, au travers d une nouvelle variante basée sur la classe des éléments de certains sous-groupes de Z p 2. Ensuite, dans le Chapitre 10, nous présentons une variante du schéma de chiffrement basé sur l identité Boneh-Franklin, possédant une réduction non plus lâche mais fine (dans le modèle de l oracle aléatoire). Enfin, dans le Chapitre 11, nous exposons un padding universel optimal à la fois pour le chiffrement et la signature. 92

Chapitre 9 Chiffrement ElGamal sans encodage dans le modèle standard Sommaire 9.1 Le cryptosystème ElGamal........................... 94 9.1.1 Description du cryptosystème ElGamal.................... 94 9.1.2 Le cryptosystème ElGamal avec fonction de hachage............. 95 9.2 Chiffrement ElGamal sans encodage dans le modèle standard...... 95 9.2.1 La fonction Classe............................... 96 9.2.2 Problèmes de classe Diffie-Hellman...................... 97 9.2.3 Chiffrement additif sans encodage....................... 99 9.2.4 Chiffrement multiplicatif sans encodage................... 99 9.2.5 Propriétés de nos schémas de chiffrement................... 100 9.3 Preuve de sécurité de nos schémas..................... 100 9.4 Généralisation à Z p k.............................. 102 9.5 Conclusion et problèmes ouverts...................... 102 Le chiffrement ElGamal est l alternative la plus courante au chiffrement RSA. Il est facilement adaptable à de nombreux groupes cryptographiques et possède des propriétés homomorphiques, tout en restant sûr (au sens des attaques à clairs choisis) sous l hypothèse de difficulté du problème DDH dans le groupe choisi. Malheureusement, l usage en pratique du chiffrement ElGamal est complexe : les messages doivent être encodés en éléments du groupe avant le chiffrement proprement dit, ce qui requiert des conversions incommodes, limite la taille des messages et peut même détruire les propriétés homomorphiques du schéma. En utilisant des fonctions de hachage, il est certes possible de passer outre l encodage du message en élément du groupe, mais alors, la sécurité dans le modèle standard n est plus assurée. Ce chapitre introduit une nouvelle alternative n utilisant ni encodage des messages en éléments du groupe ni fonction de hachage, et restant ainsi totalement compatible avec le modèle standard. Partiellement homomorphique, notre variante du schéma de chiffrement ElGamal est comparable au schéma originel en terme d efficacité, tout en diminuant le rapport entre la taille du chiffré et la taille du clair (souvent appelé le ratio de chiffrement) à la valeur optimale de 2, alors que, pour des paramètres classiques, le cryptosystème ElGamal possède un ratio de chiffrement de 13. Le travail présenté ici a fait l objet d une collaboration avec Pascal Paillier et David Pointcheval et a été publié à la conférence Pkc 06 [CPP06]. 93

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard 9.1 Le cryptosystème ElGamal Le schéma de chiffrement ElGamal fut introduit en 1985 par Taher ElGamal [ElG85]. Il nécessite un groupe cryptographique G d ordre q, engendré par un élément g. Pour générer une paire de clés, l utilisateur tire un aléa x Z q et calcule y = g x. La clé publique est alors y tandis que la clé privée est x. Ensuite, pour chiffrer un message m M, il suffit de prendre un nombre aléatoire r Z q et de calculer u = g r et v = y r m. Le chiffré est alors c = (u, v). À l aide de la clé privée x, le chiffré c = (u, v) peut être déchiffré en m = v u x. Un point clé dans ce schéma réside dans la description du groupe G, de son ordre et de l espace des messages M. Les algorithmes classiques de calcul de logarithme dans les sous-groupes de petit ordre démontrent que l ordre du groupe G ne doit pas être divisible par un petit premier. Ainsi, prendre pour q, l ordre du groupe G, un nombre premier est considéré plus sûr. Pour assurer l indistinguabilité du schéma de chiffrement, une restriction sur l espace des messages M est également imposée : celui-ci (s il est un groupe) doit être inclus dans le groupe G. Prouvons cela par l absurde. Imaginons tout d abord que M n est pas inclus dans G, mais que ces deux ensembles ne sont pas disjoints. Prenons alors une paire de messages m 0 M\G et m 1 G M, et un chiffré c = (u, v) d un de ces deux messages. Alors, si v q = 1, c chiffre m 1 ; dans le cas contraire, il chiffre m 0. Ainsi, dans ce cas, le chiffrement est distinguable. Supposons maintenant que M et G sont disjoints et que M est un groupe. Tirons alors une paire de messages m 0 M et m 1 M, et prenons un chiffré c = (u, v) d un de ces deux messages. Comme m 0 M et m 1 M, et comme M est un groupe, m 0 m 1 1 M et notamment m 0 m 1 1 / G. Ainsi, m 0q m q 1. Aussi, il est facile de distinguer si c chiffre m 0 ou m 1, en testant si v q vaut m q 0 ou m q 1. La conclusion partielle est donc la suivante : pour espérer la sécurité sémantique, soit M est inclus dans G, soit M n est pas un groupe. Comme les groupes sont des ensembles privilégiés en cryptographie et dans le but de garder les propriétés homomorphiques du schéma ElGamal, le choix d inclure M d inclure dans G est en général celui qui est fait. Note 1. Remarquons que même si l utilisateur voulait obtenir l indistinguabilité sans prendre un ensemble de messages inclus dans G, c est-à-dire en essayant de prendre un ensemble de messages qui ne soit pas un groupe, la sécurité du système ne pourrait être obtenue que s il était difficile de trouver une paire (m 0, m 1 ) M M, telle que m 0q m 1 q. Montrons ici néanmoins un exemple d ensemble de messages qui n est pas un groupe, mais qui pourrait être utilisé pour le schéma : il s agit de M = α G = {α g k, k Z q }, où α est un élément n appartenant pas à G. Comme nous pouvons le voir, le choix de cet ensemble serait artificiel, et ne serait pas différent, en termes de sécurité, d un ensemble M G. 9.1.1 Description du cryptosystème ElGamal Ainsi, avant l étape de chiffrement proprement dite, le message doit être encodé en un élément du groupe. Cet encodage doit de plus être inversible efficacement, de façon à permettre de retrouver le message durant le déchiffrement. Un tel encodage peut être très coûteux en temps, et peut aussi partiellement ou totalement détruire les propriétés homomorphiques du système. De façon encore plus problématique, utiliser un tel encodage est incompatible avec l optimisation classique qui consiste à travailler dans un petit sous-groupe de Z p d ordre premier q, où q est un premier d environ 160 bits, un choix de paramètre qui permet d obtenir des exponentiations bien plus rapides. 94

9.2. Chiffrement ElGamal sans encodage dans le modèle standard Chiffrement ElGamal [ElG85] Initialisation des paramètres : Soient p un premier de l p bits et q un premier de l q bits divisant (p 1). Soient G le sous-groupe de Z p d ordre q, et g un générateur de G. Soit enfin Ω un encodage bijectif de Z q dans G. Génération de clés : La clé privée est un nombre aléatoire x Z q. La clé publique correspondante est y = g x. Chiffrement : Pour chiffrer un message m Z q, il faut encoder m en calculant ω = Ω(m), puis tirer un aléa r Z q et calculer (u, v) = (g r, y r ω). Le chiffré est alors c = (u, v). Déchiffrement : Pour déchiffrer c = (u, v), l utilisateur calcule ω = v u x et retrouve le message original m = Ω 1 (ω). Le cryptosystème ElGamal est à sens unique sous l hypothèse de difficulté du problème CDH, et est indistinguable sous l hypothèse de difficulté du problème DDH, ces notions de sécurité étant entendues dans le contexte des attaques à clairs choisis, dans le modèle standard. 9.1.2 Le cryptosystème ElGamal avec fonction de hachage Pour contourner le problème de l encodage en élément du groupe, une variante au cryptosystème ElGamal à base de fonction de hachage fut proposée. Chif. ElGamal avec hachage Initialisation des paramètres : Soient p un premier de l p bits et q un premier de l q bits divisant (p 1). Soient G le sous-groupe de Z p d ordre q, et g un générateur de G. Soit enfin H : G {0, 1} lm une fonction de hachage. Génération de clés : La clé privée est un nombre aléatoire x Z q. La clé publique correspondante est y = g x. Chiffrement : Pour chiffrer un message m {0, 1} lm, il faut tirer un aléa r Z q et calculer (u, v) = (g r, H(y r ) m). Le chiffré est alors c = (u, v). Déchiffrement : Pour déchiffrer c = (u, v), l utilisateur retrouve le message original m = v H(u x ). Cette variante de ElGamal est à sens unique et indistinguable contre les attaques à clairs choisis sous la seule hypothèse de difficulté du problème CDH. Cependant, la preuve de sécurité nécessite le modèle de l oracle aléatoire. Sous l hypothèse de difficulté du problème DDH, il est également possible d utiliser des extracteurs d aléa à la place du modèle de l oracle aléatoire, pour générer un masque parfaitement aléatoire. Cependant cette technique nécessite ou bien de grands groupes ou bien réduit de façon très importante la taille des masques produits [CFGP06]. 9.2 Chiffrement ElGamal sans encodage dans le modèle standard Dans cette section, nous décrivons notre nouvelle technique pour obtenir un chiffrement ElGamal sans encodage. Notre cryptosystème possède des performances similaires au schéma 95

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard classique ElGamal tel que décrit dans la Section 9.1.1, tout en ne nécessitant ni encodage ni extracteur d aléa. De plus, la sécurité de notre schéma est valable dans le modèle standard, sous de nouvelles hypothèses que nous introduisons. Nous commençons en donnant quelques définitions ainsi que quelques propriétés mathématiques. 9.2.1 La fonction Classe Soient p et q des premiers tels que q p 1. Soient g un entier d ordre pq modulo p 2 et G = g le groupe formé par tous les éléments d ordre pq modulo p 2. Alors G p = g mod p est le sous-groupe d ordre q de Z p. Par le théorème des restes chinois, il existe une bijection canonique entre Z p Z q et Z pq. Pour tous entiers x Z p et y Z q, x, y désigne l unique entier modulo pq tel que x, y = x (mod p) et x, y = y (mod q). Définition 19 (Classe d un élément de G). Tout élément w de G peut être écrit comme w = g x, y mod p 2, pour un unique x Z p et un unique y Z q. Cet entier x est appelé la classe de w en base g, et est noté x = [w ]. Il est facile de voir que si w = g x, y mod p 2, alors w = g y mod p. En d autres termes, y est le logarithme discret de (w mod p) en base (g mod p) dans le groupe G p. Ceci signifie que y est difficile à calculer à partir de w, à moins que le logarithme discret ne soit facile sur G p. Au contraire, calculer la classe d un élément de G peut être fait efficacement, comme nous le montrons ci-dessous. Lemme 1. Définissons sur G la fonction L(w) = (wq 1 mod p 2 ) p. La classe de w = g x, y mod p 2 peut être calculée comme x = L(w) L(g) 1 mod p. Démonstration. Comme g est d ordre q modulo p, g q = 1 mod p. Aussi, il existe un entier l Z p, tel que g q = 1+l p (mod p 2 ). Par définition de la fonction L, cet entier l est donné par l = L(g) et est non nul, g étant d ordre pq modulo p 2 et non d ordre q. De même, w q = 1 + L(w) p (mod p 2 ). Comme w q = g x,y q = g ( x,y mod p) q = g xq (mod p 2 ), il s ensuit, avec g q = 1 + L(g) p (mod p 2 ), que 1 + L(w) p = (1 + L(g) p) x = 1 + L(g) p x (mod p 2 ), d où le résultat. Cette propriété est bien connue et a notamment servi à construire les schémas de chiffrement Okamoto-Uchiyama [OU98] et Paillier [Pai99b]. Considérons maintenant un entier a Z q ainsi que w = g a mod p. Comme 1 = w pq (mod p 2 ), w peut être vu comme un élément de G, et donc il existe des entiers x, y tels que w = g x, y mod p 2. De plus, g x, y = g y (mod p) et donc y = a par unicité du logarithme. Il apparaît que la classe x de w peut être calculée comme une fonction de a, comme le montre le lemme suivant. Lemme 2. Définissons, pour tout w G et Alors, pour tout élément w G, Upper(w) = (w) = w (w mod p) p q L(g) Upper(w) mod p. w [w mod p] = [w ] (w) mod p. 96

9.2. Chiffrement ElGamal sans encodage dans le modèle standard Démonstration. Tout d abord, remarquons que, par définition de la fonction L, g q = 1+L(g) p = g q,0 (mod p 2 ). D où 1 + p = g q L(g),0 mod p 2, où L(g) est non-nul comme g est d ordre pq modulo p 2. Nous pouvons écrire w comme w = g x,y mod p, avec x = [w ] et y = DL g (w mod p). Par définition des fonctions Upper et et comme w mod p = g y mod p 0, nous avons w = (w mod p) + p Upper(w) = (w mod p) ( 1 + p ( Upper(w) w )) mod p mod p 2,0 = (w mod p) (1 + p) Upper(w) mod w p mod p 2 = (w mod p) g q Upper(w) mod p L(g) w = (w mod p) g (w),0 mod p 2. mod p 2 Aussi, en appliquant la fonction Classe de chaque coté de la dernière égalité, nous obtenons [w ] = [w mod p] + (w) mod p, dont se déduit le résultat. Lemme 3. La fonction f : Z q Z p, définie par a [g a mod p], est aléatoirement autoréductible (en anglais, random self-reducible). Démonstration. Supposons que nous désirons [A] pour un certain A = g a mod p. Nous utilisons alors le fait que pour tout r Z q, nous avons [A r mod p] = [A r mod p 2 ] (A r mod p) = r [A] (A r mod p) mod p. Si r est tiré aléatoirement dans Z q, A r mod p est un élément aléatoire de G p, comme A est un générateur de G p. Connaissant la classe de [A r mod p] et r, [[A] peut alors être facilement retrouvé par [A] = r 1 ([A r mod p] + (A r )) mod p. 9.2.2 Problèmes de classe Diffie-Hellman Nous définissons maintenant un problème calculatoire basé sur la fonction Classe introduite dans la section précédente. Ce problème sera à la base du schéma de chiffrement que nous introduirons ensuite. Définition 20 (Problème calculatoire de classe Diffie-Hellman - CCDH). Soit G = g le sous-groupe d ordre pq de Z p 2. Le problème calculatoire de classe Diffie-Hellman dans G est défini comme suit : étant donné des éléments g a mod p et g b mod p, pour des aléas a et b tirés dans Z q, calculer [g ab mod p]. La version décisionnelle de ce problème se décrit comme suit. Définition 21 (Problème décisionnel de classe Diffie-Hellman - DCDH). Soit G = g le sous-groupe d ordre pq de Z p 2. Le problème décisionnel de classe Diffie-Hellman dans G est de distinguer les distributions (g a mod p, g b mod p, [g ab mod p]) et (g a mod p, g b mod p, z), pour a, b tirés aléatoirement dans Z q et z aléa de Z p. 97

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard Ces problèmes sont nouveaux. Cependant, nous avons été en mesure de montrer la difficulté de la version calculatoire du problème. Plus précisément, nous posons le théorème suivant. Théorème 11. Les problèmes CCDH et CDH sont équivalents. Démonstration. La preuve est découpée en deux étapes, suivant les deux sens de l équivalence. Nous commençons avec l implication la plus évidente. [CCDH CDH]. Supposons que nous ayons accès à un algorithme probabiliste A tel que A(g a mod p, g b mod p) retourne g ab mod p avec une probabilité ε et en un temps τ, la probabilité de succès étant prise sur les données variables de A et les aléas a, b Z q. Étant donné A, B G p, nous exécutons A(A, B) pour obtenir CDH(A, B) et en déduisons alors [CDH(A, B)] grâce au Lemme 1, de façon à résoudre le problème CCDH avec une probabilité ε et un temps limité à τ + poly (log p). [CDH CCDH]. Supposons que nous ayons accès à un algorithme probabiliste A qui résout le problème CCDH. Grâce au Lemme 3, nous pouvons supposer que la distribution des entrées de A ne nécessite pas d être uniforme pour que la probabilité de succès de A soit assurée. Nous construisons une réduction B calculant C = CDH(A, B) pour des aléas A, B G p. B exécute une première fois A(A, B) pour obtenir [C ]. B pose ensuite A = Ag mod p et ré-exécute A pour obtenir [C ] = A(A, B), où C = CDH(A, B) = BC mod p. Nous avons alors les égalités suivantes : [C ] = [BC mod p] = [BC mod p 2 ] (BC mod p) = [B ] + [C ] (BC mod p) mod p d où (BC mod p) = [B ] + [C ] [C ] mod p. Comme BC = (BC mod p) + p Upper(BC mod p 2 ) = C + p Upper(BC mod p 2 ) ( Upper(BC mod p = C (1 2 )) ( ) + p mod p = C 1 + p L(g) ) (BC mod p) mod p 2. BC q B n a plus qu à trouver une solution à cette équation modulaire ( C C = B 1 1 + p L(g) ( ) ) [B ] + [C ] [C ] mod p 2 q dans laquelle les inconnues ( sont C, C Z p. En posant µ = B 1 1 + p L(g) q ([B ] + [C ] [C ] )) mod p 2, B applique l algorithme étendu d Euclide sur µ et p 2 pour trouver de petites solutions C, C < p satisfaisant C/C = µ mod p 2. Pour arrêter l algorithme étendu d Euclide au bon moment, la validité de C est vérifiée en s assurant que C C 1 mod p est égal à B. Cette étape finit ainsi avec succès en une complexité en O(log 3 p), et permet le calcul de C = CDH(A, B), en deux appels à A et un temps supplémentaire polynomial. Jusqu à présent, l étude du problème DCDH reste un problème ouvert. En particulier, la relation entre les problèmes DCDH et DDH reste encore mystérieuse. Bien que nous n ayons pas de preuve à apporter, nous suspectons ces deux problèmes d être étroitement reliés. Nous ferons l hypothèse que le problème DCDH ne peut être résolu en temps polynomial dans le reste de ce chapitre. 98

9.2. Chiffrement ElGamal sans encodage dans le modèle standard 9.2.3 Chiffrement additif sans encodage Comme annoncé dans l introduction de cette section, notre but est de rendre le schéma ElGamal d un usage le plus aisé possible, en évitant l usage d un mécanisme d encodage en éléments de groupe, tout en maintenant une sécurité dans le modèle standard (par opposition au schéma ElGamal avec fonction de hachage tel que décrit Section 9.1.2 par exemple). Notre idée est de ne plus incorporer le message dans un élément du groupe, mais, à la place, de transformer une clé de session extraite d un échange Diffie-Hellman en un entier modulo p à l aide de la fonction Classe définie Section 9.2.1. Pkc 06 [CPP06] Initialisation des paramètres : Soient p un entier de l p bits et q un premier de l q bits diviseur de p 1. Soit g un générateur du groupe G des éléments d ordre pq modulo p 2. Génération de clés : La clé privée est un aléa x Z q. La clé publique correspondante est y = g x mod p. Chiffrement : Pour chiffrer un message m Z p, il suffit de tirer un aléa r Z q et de calculer u = g r mod p et v = [y r mod p] + m mod p. Le chiffré est alors c = (u, v). Déchiffrement : Pour déchiffrer c = (u, v), l utilisateur calcule m = v [u x mod p] mod p. 9.2.4 Chiffrement multiplicatif sans encodage La procédure de chiffrement peut alternativement être faite à base de multiplication modulaire, si le message est pris non plus dans le groupe additif Z p, mais dans le groupe multiplicatif Z p. Pkc 06 [CPP06] Initialisation des paramètres : Soient p un entier de l p bits et q un premier de l q bits diviseur de p 1. Soit g un générateur du groupe G des éléments d ordre pq modulo p 2. Génération de clés : La clé privée est un aléa x Z q. La clé publique correspondante est y = g x mod p. Chiffrement : Pour chiffrer un message m Z p, il suffit de tirer un aléa r Z q et de calculer u = g r mod p et v = [y r mod p] m mod p. Le chiffré est alors c = (u, v). Déchiffrement : Pour déchiffrer c = (u, v), l utilisateur calcule simplement m = v [u x mod p] 1 mod p. Le chiffrement ElGamal peut en effet être vu comme un échange de clé Diffie-Hellman, dans lequel la publication de la clé publique y fait office de première passe. 99

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard 9.2.5 Propriétés de nos schémas de chiffrement Absence de conversion des messages. Nos schémas de chiffrement ne nécessitent aucune conversion avant la procédure de chiffrement : l espace des messages est réellement le groupe additif Z p dans la version additive ou le groupe multiplicatif Z p dans la version multiplicative. C est pourquoi toute chaîne de moins de k bits, où p > 2 k, peut être chiffrée directement. C est une propriété très forte, car nous pouvons utiliser dans le même temps un ordre q beaucoup plus petit que p sans impacter les procédures de chiffrement ou de déchiffrement. Efficacité. Nous pouvons voir que les chiffrés dans nos schémas sont exactement de même taille que dans le schéma classique ElGamal. De plus, le ratio est exactement de 2, alors que dans le schéma ElGamal, celui-ci est de 2p q. Ainsi, pour des paramètres classiques l p = 1024 et l q = 160, le ratio du chiffrement ElGamal est ainsi d environ 13. Du point de vue des performances en temps de calcul, nos schémas nécessitent pour le chiffrement, en plus des deux exponentiations inhérentes aux schémas de type ElGamal, une exponentiation additionnelle dans Z p avec un exposant de l 2 q bits. Cette exponentiation équivaut en temps à environ quatre exponentiations dans Z p. Ainsi, en tout, l étape de chiffrement de nos schémas nécessite six exponentiations de l q bits contre deux exponentiations dans le schéma ElGamal. Cependant, aucun encodage n est nécessaire, encodage souvent réalisé par des exponentiations et au prix d un ordre du groupe plus grand. De même, nos procédures de déchiffrement nécessitent une exponentiation de l q bits dans Z p puis le calcul de la fonction Classe. Ainsi, l étape de déchiffrement de nos schémas nécessite cinq exponentiations de l q bits à comparer avec la simple exponentiation du schéma ElGamal. Le schéma multiplicatif nécessite en sus un calcul d inverse modulaire. Cependant, encore une fois, cet écart est à relativiser, car aucun décodage n est nécessaire. Homomorphisme additif ou multiplicatif. Enfin, notre schéma additif (respectivement multiplicatif) possède une propriété homomorphique partielle additive (respectivement multiplicative) sur le groupe additif Z p (respectivement le groupe multiplicatif Z p). Par partielle, nous voulons dire qu il est possible d ajouter (respectivement de multiplier par) une constante à un chiffré sans avoir besoin de la clé privée. Bien que ce type de propriété soit incompatible avec une résistance contre les attaques à chiffrés choisis, il est souvent considéré comme intéressant pour certaines applications cryptographiques telles que le vote électronique, et nous espérons ainsi voir des applications concrètes de nos schémas basées sur cette propriété. Une restriction importante de cette propriété homomorphique est néanmoins qu elle ne permet pas de transformer aléatoirement un chiffré en un autre chiffré du même message, ni même d ajouter (respectivement de multiplier) deux chiffrés entre eux. 9.3 Preuve de sécurité de nos schémas Dans cette partie, nous décrivons la sécurité de nos schémas. Bien évidement, nous ne pouvons nous prémunir des attaques à chiffrés choisis, du fait de la malléabilité précédemment décrite. Cependant, des conversion génériques existent pour transformer des schémas sûrs sous attaques CPA en schémas sûrs sous attaques CCA (dans le modèle de l oracle aléatoire) [FO99, FO00, Poi00], quand le contexte nécessite une sécurité contre les attaques à chiffrés choisis. Sens unique du chiffrement. En se focalisant sur la version additive de notre schéma, nous énonçons le théorème suivant : 100

9.3. Preuve de sécurité de nos schémas Théorème 12. Soit A un adversaire pouvant inverser notre schéma de chiffrement, sous attaque à clairs choisis, avec une probabilité ε et en un temps τ. Alors le problème calculatoire de la classe Diffie-Hellman peut être résolu avec une probabilité ε et en un temps similaire à τ. Démonstration. Étant donné une instance du problème calculatoire de classe Diffie-Hellman dans Z p (g, y = g x mod p, w = g s mod p), nous voulons calculer z = [[g xs mod p]. Pour cela, 2 nous utilisons un attaquant OW-CPA A contre notre schéma, dans lequel nous initialisons g comme le générateur, et y comme la clé publique. Nous soumettons à l attaquant A le chiffré (u, v) = (w, a) pour un aléa a Z p. Comme il s agit d un chiffré valide et aléatoire d un message aléatoire, pour lequel nous avons contraint r = s, l attaquant A réussit avec une probabilité ε à retrouver le message clair m correspondant. Si A réussit dans son attaque, nous apprenons alors [g xs mod p], le résultat espéré, par la formule z = a m mod p. De façon aisée, le lecteur pourra voir que le même théorème s applique pour la version multiplicative de notre schéma. Il faut simplement noter que l espace des messages dans cette dernière version est Z p, et non Z p, car il est nécessaire de calculer l inverse m 1 mod p pour déduire z de a et m. Indistinguabilité. Concernant l indistinguabilité, nous pouvons poser un théorème similaire : Théorème 13. Soit A un adversaire contre l indistinguabilité de notre schéma de chiffrement, avec un avantage ε et en un temps τ, sous une attaque à clairs choisis. Alors le problème décisionnel de la classe Diffie-Hellman peut être résolu avec un avantage ε/2 en un temps similaire à τ. Démonstration. Supposons que nous recevons une instance (g, y = g x mod p, w = g s mod p, z) du problème décisionnel de la classe Diffie-Hellman dans Z p 2, et que nous désirons décider si z a été aléatoirement choisi dans Z p ou si z = [g xs mod p]. Comme dans la preuve précédente, nous utilisons un attaquant IND-CPA A contre notre schéma, dans lequel nous initialisons g comme le générateur, et y comme la clé publique. Nous laissons alors l attaquant choisir deux messages m 0 et m 1, puis nous tirons un bit aléatoire b, et chiffrons m b comme (u, v) = (w, z + m b mod p). Finalement, nous retournons ce chiffré à l attaquant A comme la valeur du challenge. Clairement, si z = [g xs mod p], c est un chiffré valide de m b, pour lequel nous avons contraint r = s, et ainsi, l attaquant A peut deviner la valeur de b avec un avantage ε. Au contraire, si z est un élément aléatoire de Z p, z = z + m b mod p est aussi un élément aléatoire de Z p, rendant ainsi le chiffré soumis indépendant du message m b. L avantage de l attaquant A est dans ce cas nécessairement nul. C est pourquoi, pour répondre au problème décisionnel, nous retournons True si la réponse de l attaquant A est correcte, et sinon, nous retournons une réponse aléatoire. Calculons alors l avantage de notre réduction. Si z a été aléatoirement choisi dans Z p (ce qui arrive avec une probabilité de 1 2 ), la réduction répond au hasard, et a donc une probabilité de 1 2 de donner la bonne réponse. Si z = [gxs mod p] (ce qui arrive avec une probabilité de 1 2 ), la réduction répond la bonne réponse si l attaquant réussit son attaque (c est-à-dire avec une probabilité de 1 2 + ε 2 ). La probabilité totale de réussite de la réduction est donc : 101

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard 1 2 1 2 + 1 ( 1 2 2 + ε ) = 1 2 2 + ε 4 Notre réduction résout ainsi le problème DCDH avec un avantage égal à ε/2. 9.4 Généralisation à Z p k Tout comme le schéma proposé par Ivan Damgård et Mats Jurik [DJ01] est une généralisation du schéma de chiffrement Paillier, nous pouvons généraliser notre schéma en utilisant Z p k pour tout entier k > 2. Pour un tel entier k > 2, nous définissons de façon naturelle L k la fonction X Xq 1 mod p k p, et notons la classe de w par [w ] k = L k (w) L k (g) 1 mod p k 1. Alors, la généralisation de notre technique à Z p k est comme suit : Pkc 06 [CPP06] Initialisation des paramètres : Soient p un entier de l p bits et q un premier de l q bits diviseur de p 1. Soit g un générateur du groupe G des éléments d ordre p k 1 q modulo p k. Génération de clés : La clé privée est un aléa x Z q. La clé publique correspondante est y = g x mod p. Chiffrement : Pour chiffrer un message m Z p k 1, il suffit de tirer un aléa r Z q et de calculer u = g r mod p et v = [y r mod p] k + m mod p k 1. Le chiffré est alors c = (u, v). Déchiffrement : Pour déchiffrer c = (u, v), l utilisateur calcule m = v [u x mod p] k mod p k 1. Bien sûr, nous pourrions tout aussi bien utiliser la multiplication au lieu de l addition. Dans k cette généralisation, le ratio de chiffrement vaut k 1, et peut ainsi être rendu quasi optimal. De plus, les propriétés de malléabilité partielle sont conservées. Concernant la sécurité, nous renvoyons le lecteur à [DJ01] pour y trouver des preuves que les problèmes CCDH et DCDH avec k > 2 sont équivalents au cas k = 2. Il est également possible de modifier légèrement les preuves que nous présentons en Section 9.3 pour notre schéma Z p, de façon à montrer que le caractère 2 à sens unique et l indistinguabilité de nos généralisations sont sûrs sous l hypothèse de difficulté des problèmes CCDH k et DCDH k, versions généralisées des problèmes CCDH et DCDH. 9.5 Conclusion et problèmes ouverts Dans ce chapitre, nous avons proposé de nouveaux cryptosystèmes basés sur de nouveaux problèmes reliés aux problèmes Diffie-Hellman. Nos schémas de chiffrement de type ElGamal ne nécessitent pas que les messages soient convertis en éléments du groupe, par opposition à tous les schémas connus de chiffrement basés sur le logarithme discret possédant une preuve de sécurité dans le modèle standard. Nos schémas proposent de plus un meilleur ratio de chiffrement (réduit d un facteur 6.5 pour des paramètres communément utilisés), une taille de chiffrés rigoureusement égale, et sont comparables en vitesse à la version classique du schéma ElGamal. Leur sécurité dans le modèle standard sous attaque à messages choisis repose sur l hypothèse de difficulté du problème 102

9.5. Conclusion et problèmes ouverts CDH pour le caractère à sens unique et sur l hypothèse de difficulté du problème DCDH pour l indistinguabilité. Nos schémas possèdent un caractère partiellement homomorphique, soit additif soit multiplicatif. À notre connaissance, notre schéma additif est le premier exemple d un chiffrement homomorphe pour l addition (même si ce caractère n est que partiel) possédant une preuve dans le modèle standard, sur un problème de type logarithme discret. Une voie de recherche serait la conception d un cryptosystème basé sur le logarithme discret qui posséderait un caractère homomorphique entier, soit additif soit multiplicatif. Un autre point important serait l étude approfondie des relations entre les problèmes DCDH et DDH. 103

Chapitre 9. Chiffrement ElGamal sans encodage dans le modèle standard 104

Chapitre 10 Cryptographie basée sur l identité avec réduction fine Sommaire 10.1 Deux schémas classiques de chiffrement basés sur l identité...... 105 10.1.1 Schéma de Boneh-Franklin........................... 106 10.1.2 Schéma de Katz-Wang............................. 106 10.2 Preuve fine pour un schéma basé sur l identité.............. 108 10.2.1 Description du schéma............................. 108 10.2.2 Étude de la sécurité de ce schéma....................... 109 10.2.3 Réduction aux problèmes classiques DBDH et GBDH............ 113 10.3 Comparaison des schémas........................... 114 10.4 Conclusion.................................... 114 Dans un papier de Crypto 01 resté depuis célèbre, Dan Boneh et Matthew Franklin proposèrent la première réalisation pratique d un schéma de chiffrement basé sur l identité (IBE). La sécurité de leur schéma, au sens de l indistinguabilité sous attaque à chiffrés et identités choisis, est équivalente au problème CBDH, dans le modèle de l oracle aléatoire. Cependant, la réduction proposée est loin d être fine. Dans ce chapitre, nous proposons de simples modifications au schéma Boneh-Franklin permettant une réduction de sécurité fine. Notre variante peut être vue comme un schéma IBE pour lequel, pour chaque identité, deux clés équivalentes pourraient servir au déchiffrement. Chaque identité ne reçoit qu une seule de ces deux clés, ce choix étant aléatoire et secret pour tout autre utilisateur que l autorité et le détenteur. Notre construction est la continuation d une idée introduite par Jonathan Katz et Nan Wang. En ce sens, notre travail ne définit pas complètement un nouveau schéma ; il doit plus être considéré comme une poursuite de l idée de ces deux auteurs, pour permettre d obtenir une sécurité fine pour un schéma basé sur l identité, dans le modèle de l oracle aléatoire. Ce chapitre a fait l objet d une collaboration [ACF+05] avec Nuttapong Attrapadung, Jun Furukawa, Takeshi Gomi, Goichiro Hanaoka, Hideki Imai et Rui Zhang. 10.1 Deux schémas classiques de chiffrement basés sur l identité Dans cette section, nous rappelons les schémas de chiffrement basés sur l identité de Dan Boneh et Matthew Franklin [BF01, BF03] et la variante de Jonathan Katz et Nan Wang [KW03]. 105

Chapitre 10. Cryptographie basée sur l identité avec réduction fine 10.1.1 Schéma de Boneh-Franklin Nous rappelons ici le schéma Boneh-Franklin, en renvoyant à la Section 8.3.3 pour plus de précisions. La version IND-ID-CPA est définie ainsi : Chiffrement Boneh-Franklin [BF01, BF03] Mise en place des paramètres : L autorité génère des paramètres, composés de deux groupes G 1 et G T d ordre q, d une application bilinéaire e : G 1 G 1 G T et d un générateur g de G 1. Ensuite, l autorité génère un aléa x Z q, et calcule y = g x. Elle choisit également la longueur l m des messages, et pose M = {0, 1} lm. Enfin, deux fonctions de hachage H : {0, 1} G 1 et G : G T {0, 1} lm sont sélectionnées. Alors, params = q, G 1, G T, e, M, g, y, G, H et sk IBE = x Extraction de clé : Pour générer la clé privée de l identité ID, l autorité calcule h ID = H(ID), puis sk ID = h ID x est retournée. Chiffrement : Pour chiffrer un message m M à une identité ID, l utilisateur tire un aléa r Z q, puis calcule h ID = H(ID) et w = e(y, h ID ) r. Ensuite, il calcule c 0 = g r et c 1 = m G(w). Le chiffré c = (c 0, c 1 ) est alors retourné. Déchiffrement : Pour déchiffrer un chiffré c = (c 0, c 1 ) G 1 M, l utilisateur ID calcule w = e(c 0, sk ID ), puis retrouve le message m selon m = c 1 G(w ). Le schéma Boneh-Franklin est sûr, dans le modèle de l oracle aléatoire, contre les attaques IND-ID-CPA sous l hypothèse de la difficulté du problème CBDH. Sous la même hypothèse et toujours dans le modèle de l oracle aléatoire, la version utilisant la transformation générique de Eiichiro Fujisaki et Tatsuaki Okamoto assure une sécurité IND-ID-CCA (voir [BF01, BF03]). Malheureusement, la réduction du schéma Boneh-Franklin est très lâche. Initialement, un facteur 1 (q e+q d ) q 2 était annoncé dans [BF01, BF03], où q h e désigne le nombre autorisé de requêtes à l oracle Extract et q d le nombre autorisé de requêtes à l oracle de déchiffrement. Récemment [Gal05], David Galindo a pointé une erreur dans la preuve originale, et montré que le facteur était en fait O( 1 q 3 ). h 10.1.2 Schéma de Katz-Wang Le problème de l absence de finesse de la réduction du schéma Boneh-Franklin fut abordé en fin d un article de Jonathan Katz et Nan Wang [KW03]. Le sujet principal de ce papier était différent, et l idée que nous allons rappeler ne fut que rapidement abordée dans la conclusion. Jonathan Katz et Nan Wang ont proposé que, pour chaque identité, il y ait deux clés publiques différentes : au lieu de H(ID), deux valeurs H(ID, 0) et H(ID, 1) sont utilisées. Le chiffrement est alors effectué en chiffrant le même message pour ces deux clés publiques, à l aide d un double chiffrement de type Boneh-Franklin. Par contre, une seule et quelconque des deux clés privées correspondantes est détenue par l utilisateur. Cette idée permet de construire une réduction telle que, pour chaque identité, la valeur d une des deux clés privées soit connue. Ainsi, il devient plus aisé de simuler les oracles de déchiffrement ou d extraction de clé. Et donc, par conséquent, deux clés privées. 106

10.1. Deux schémas classiques de chiffrement basés sur l identité Chiffrement Katz-Wang [KW03] Mise en place des paramètres : L autorité génère des paramètres, composés de deux groupes G 1 et G T d ordre q, d une application bilinéaire e : G 1 G 1 G T et d un générateur g de G 1. Ensuite, l autorité génère un aléa x Z q, et calcule y = g x. Elle choisit également la longueur l m des messages, et pose M = {0, 1} lm. Enfin, deux fonctions de hachage H : {0, 1} G 1 et G : G T {0, 1} lm sont sélectionnées. Alors, params = q, G 1, G T, e, M, g, y, G, H et sk IBE = x Extraction de clé : Pour générer la clé privée de la nouvelle a identité ID, l autorité génère un bit aléatoire b ID puis calcule d ID = H(ID, b ID ) x. La clé sk ID = (b ID, d ID ) est alors retournée. Chiffrement : Pour chiffrer un message m M à une identité ID, l utilisateur tire deux aléas r 0 Z q et r 1 Z q, puis calcule h ID0 = H(ID, 0), h ID1 = H(ID, 1), w 0 = e(y, h ID0 ) r 0 et w 1 = e(y, h ID1 ) r 1. Ensuite, il calcule c 0,0 = g r 0, c 1,0 = g r 1, c 0,1 = m G(w 0 ) et c 1,1 = m G(w 1 ). Le chiffré c = (c 0,0, c 1,0, c 0,1, c 1,1 ) est alors retourné. Déchiffrement : Pour déchiffrer un chiffré c = (c 0,0, c 1,0, c 0,1, c 1,1 ) G 1 2 M 2, l utilisateur ID calcule w b ID = e(c bid,0, d ID ), puis retrouve le message m selon m = c bid,1 G(w b ID ). a Si l identité ID a déjà reçu sa clé privée, la même clé lui est retournée. Un désavantage de ce schéma est son coût : dans cette construction, les chiffrés ont doublé de taille par rapport à la construction Boneh-Franklin ; de même, le chiffrement prend deux fois plus de temps que dans le schéma original. La sécurité fine de cette construction contre les attaques IND-ID-CPA est expliquée brièvement dans [KW03], sous la même hypothèse que le schéma Boneh-Franklin, c est-à-dire la difficulté du problème CBDH. Par contre, l usage de la méthode de Eiichiro Fujisaki et Tatsuaki Okamoto pour obtenir une sécurité contre les attaques à chiffrés et identités choisis n est pas abordé. De façon plus précise, pour obtenir la sécurité OW-ID-CCA (et donc pour espérer une sécurité IND-ID-CCA), il faudrait que l utilisateur puisse vérifier l égalité des clairs dans les deux parties du chiffré. Sinon, un adversaire peut, à partir du challenge c = (c 0,0, c 1,0, c 0,1, c 1,1 ) (chiffrant pour une identité ID le message m qu il désire retrouver), créer un autre chiffré valide c = (c 2,0, c 1,0, c 2,1, c 1,1 ) ou c = (c 0,0, c 2,0, c 0,1, c 2,1 ), selon un bit aléatoire β. Pour cela, il lui suffit de prendre un message aléatoire m 2, un aléa r 2 Z q, puis de calculer w 2 = e(y, h IDβ ) r 2, c 2,0 = g r 2 et c 2,1 = m G(w 2 ). En soumettant ce chiffré à l oracle de déchiffrement, l attaquant reçoit m 2 (si b ID = β) ou m (si b ID = 1 β). Si la réponse est m 2, l attaquant reproduit l opération en changeant de valeur β. Aussi, avec probabilité 1, l adversaire peut casser l aspect sens-unique du chiffrement, si l égalité des clairs dans les deux parties du chiffré n est pas vérifiée. Notre conclusion partielle est la suivante : en un sens, la technique du double chiffrement permet d obtenir une réduction fine (pour les attaques IND-ID-CPA), mais d un autre côté, cette technique permet à un attaquant à chiffrés choisis de casser le schéma, si un moyen de tester l égalité des clairs dans les deux parties n est pas ajouté. 107

Chapitre 10. Cryptographie basée sur l identité avec réduction fine 10.2 Preuve fine pour un schéma basé sur l identité Dans cette section, nous élaborons une nouvelle variante basée sur l identité, et montrons ensuite que sa réduction est fine. Notre schéma est une continuation de l idée de Jonathan Katz et Nan Wang exposée précédemment, dans le sens où nous reprenons la technique du chiffrement sous deux clés publiques. Néanmoins, pour assurer une sécurité contre les attaques à chiffrés choisis, une modification a été nécessaire, de façon à pouvoir vérifier l égalité des clairs dans les deux parties du chiffré. 10.2.1 Description du schéma Le schéma modifié se décrit ainsi : Mise en place des paramètres : L autorité génère des paramètres, composés de deux groupes G 1 et G T d ordre q (de taille l q ), d une application bilinéaire e : G 1 G 1 G T et d un générateur g de G 1. Ensuite, l autorité génère un aléa x Z q, et calcule y = g x. Elle choisit également un paramètre de sécurité l et la longueur l m des messages, et pose M = {0, 1} lm. Enfin, trois fonctions de hachage H : {0, 1} G 1, G : G T G 1 {0, 1} lm 2 +lq et F : {0, 1} {0, 1} l sont sélectionnées. Alors, params = q, G 1, G T, e, M, g, y, F, G, H et sk IBE = x Extraction de clé : Pour générer la clé privée de la nouvelle a identité ID, l autorité génère un bit aléatoire b ID puis calcule d ID = H(ID, b ID ) x. La clé sk ID = (b ID, d ID ) est alors retournée. Chiffrement : Pour chiffrer un message m = (m 0, m 1 ) {0, 1} lm 2 {0, 1} lm 2 à une identité ID, l utilisateur tire un aléa r Z q ; calcule les deux clés publiques h ID0 = H(ID, 0) et h ID1 = H(ID, 1) ; calcule w 0 = e(y, h ID0 ) r et w 1 = e(y, h ID1 ) r ; calcule c 0 = g r, c 0,1 = (m 0 r) G(c 0, w 0 ), c 1,1 = (m 1 r) G(c 0, w 1 ) ; calcule la redondance f = F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ). Le chiffré c = (c 0, c 0,1, c 1,1, f) est alors retourné. Déchiffrement : Pour déchiffrer un chiffré c = (c 0, c 0,1, c 1,1, f) G 1 {0, 1} lm 2 +lq {0, 1} lm 2 +lq {0, 1} κ, l utilisateur ID calcule w b ID = e(c 0, d ID ) ; retrouve une partie du message m bid et l aléa r selon m bid r = c bid,1 G(c 0, w b ID ) ; calcule w 1 b ID = e(y, H(ID, 1 b ID )) r ; retrouve la seconde partie du message m 1 bid selon m 1 bid r = c 1 bid,1 G(c 0, w 1 b ID ) ; si la redondance f = F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ) est satisfaite, le message m = (m 0, m 1 ) est retourné, sinon est renvoyé. a Si l identité ID a déjà reçu sa clé privée, la même clé lui est retournée. Comme nous pouvons le voir, cette variante est plus efficace que le double chiffrement de la variante de Jonathan Katz et Nan Wang. En effet, un seul aléa est nécessaire et surtout la taille 108

10.2. Preuve fine pour un schéma basé sur l identité des chiffrés est plus petite. Une comparaison complète est donnée en Section 10.3. 10.2.2 Étude de la sécurité de ce schéma Dans cette section, nous étudions la sécurité de la variante que nous proposons. Nous posons le théorème suivant, reposant sur le problème q h -LBDH (voir Définition 13). Théorème 14. Soit A un adversaire qui attaque la sécurité sémantique du schéma présenté Section 10.2.1, sous une attaque à messages et identités choisis, après avoir eu droit à q h requêtes à un oracle de hachage, q d requêtes à un oracle de déchiffrement et q e requêtes à un oracle d extraction de clé, dans le modèle de l oracle aléatoire. Soit ε l avantage de A, et τ son temps d exécution. Alors il est possible d utiliser cet attaquant pour résoudre le problème q h -LBDH, avec une probabilité ε et en un temps τ, tels que et ε AdvIND-ID-CCA (A) 4 2 l 1. τ τ + 2q d T p + (2q e + q h + 3q d ) T e où T e est le temps pour calculer une exponentiation et T p est le temps pour calculer un couplage. Démonstration. La preuve de ce théorème est donnée sous forme de jeux successifs, à la manière développée à l origine par Victor Shoup. Soit (g, y = g x, g α = g α, g β = g β ) G 1 4 une instance aléatoire du problème LBDH. Soit ε LBDH la probabilité que la réduction résolve le problème LBDH et ε DL la probabilité que la réduction retrouve β. Nous posons y comme clé publique. Jeu J 0 : Ce jeu correspond à la définition du jeu IND-ID-CCA, tel que défini en Section 8.3.2. Notons S 0 l événement b = b pour ce jeu, et S i l événement similaire pour les jeux suivants J i. Par définition, nous avons Pr[S 0 ] = 1 2 + AdvIND-ID-CCA (A) 2 et τ 0 = τ. Les jeux suivants contiennent de nombreuses règles, pour chacune des ressources de l attaquant : - requêtes de hachage F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ) ; - requêtes de hachage G(v, w) ; - requêtes de hachage H(ID, b) ; - requêtes d extraction de clé de l identité ID ; - requêtes de déchiffrement Decrypt(c 0, c 0,1, c 1,1, f) pour l identité ID ; - challenge. L objectif des jeux suivants est de simuler les réponses de ces oracles. Jeu J 1 : Le but de ce jeu est de simuler les oracles de hachage F et G, de façon très simple, au moyen de listes L F et L G initialisées au départ de l attaque à la liste vide. 109

Chapitre 10. Cryptographie basée sur l identité avec réduction fine Requête de hachage F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ) - Si une valeur (m 0, m 1, r, ID, c 0, c 0,1, c 1,1, f) existe dans la liste L F, la même réponse f est retournée ; - Sinon, la réduction teste si g β = g r, auquel cas le logarithme discret de g β en base g est retrouvé par la réduction. Dans ce cas, la réduction s arrête ; - Sinon, si g r g β, la réduction choisit aléatoirement f {0, 1} l et ajoute la valeur (m 0, m 1, r, ID, c 0, c 0,1, c 1,1, f) à la liste L F. La valeur f est retournée. Requête de hachage G(v, w) - Si une valeur (v, w, g) existe dans la liste L G, la même réponse g est retournée ; - Sinon, la réduction choisit aléatoirement g {0, 1} lm 2 +lq et ajoute la valeur (v, w, g) à la liste L G. La valeur g est retournée. Ce jeu est identique au jeu précédent, sauf si la réponse au problème DL (pouvant être trivialement transformée en réponse au challenge LBDH) est obtenue par la réduction : Pr[S 0 ] Pr[S 1 ] + ɛ DL et τ 1 = τ 0 + q F T e. Jeu J 2 : Dans ce jeu, nous simulons les oracles de hachage H, de façon à faire que les requêtes d extraction de clé deviennent simples à simuler à partir du jeu suivant. Pour cela, au début du jeu, la réduction tire une fonction aléatoire B : {0, 1} {0, 1}, permettant de calculer, pour chaque identité ID, le bit b ID = B(ID). Comme pour les fonctions de hachage F et G, la fonction de hachage H est gérée au moyen d une liste L H, prenant au départ la valeur vide. Requête de hachage H(ID, b) - Si une valeur (ID, b,, h) existe dans la liste L H, la même réponse h est retournée ; - Sinon, si b = b ID = B(ID), alors la réduction choisit aléatoirement t Z q et pose h = g t. La valeur (ID, b, t, h) est ajoutée à la liste L H et h est retourné ; - Sinon, la réduction choisit aléatoirement t Z q et pose h = g α t. La valeur (ID, b, t, h) est ajoutée à la liste L H et h est retourné. Ce jeu est identique au jeu précédent, dans le modèle de l oracle aléatoire : Pr[S 1 ] = Pr[S 2 ] et τ 2 = τ 1 + q H T e. Jeu J 3 : Grâce au jeu précédent, il est maintenant possible, pour la réduction, de répondre aux requêtes Extract. Plus précisément, les réponses à ces requêtes sont maintenant simulées comme suit. Requête d extraction de clé de l identité ID - La simulation calcule b ID = B(ID) puis demande la valeur H(ID, b ID ) à l oracle de hachage de la fonction H ; - Ensuite, la réduction retrouve la valeur (ID, b ID, t, h) dans la liste L H, et calcule d ID = y t ; - La clé (b ID, d ID ) est alors retournée. Le bit b ID est bien aléatoire et la clé est bien valide, c est-à-dire telle que d ID = H(ID, b ID ) x. En effet, H(ID, b ID ) = g t par définition de H et de b ID dans le jeu précédent. Aussi, les deux jeux J 2 et J 3 sont parfaitement indistinguables : Pr[S 2 ] = Pr[S 3 ] et τ 3 = τ 2 + 2q e T e. 110

10.2. Preuve fine pour un schéma basé sur l identité Jeu J 4 : Dorénavant, notre but est de changer la façon dont nous fabriquons le challenge, de façon à inclure une partie de l instance du problème LBDH. La première façon, exposée dans ce jeu, est fictive, c est-à-dire que nous supposons que la réduction connaît la valeur β. Dans le jeu suivant, nous verrons qu il est possible de se passer de celle-ci. Challenge, pour deux messages (m 0,0, m 1,0 ) et (m 0,1, m 1,1 ) et une identité ID - La simulation calcule b = B(ID ), et pose (m 0, m 1 ) = (m 0,b, m 1,b ) ; - Elle calcule les deux clés publiques h ID0 = H(ID, 0) et h ID1 = H(ID, 1) ; - Elle prend comme aléa r = β ; - Elle calcule w 0 = e(y, h ID0 ) β et w 1 = e(y, h ID1 ) β ; - Elle calcule c 0 = gβ = g β, c 0,1 = (m 0 β) G(c 0, w 0), c 1,1 = (m 1 β) G(c 0, w 1) ; - Elle calcule la redondance f = F(m 0, m 1, β, ID, c 0, c 0,1, c 1,1 ) ; - Elle retourne le challenge c = (c 0, c 0,1, c 1,1, f ) à l adversaire. Clairement, ce jeu est indistinguable du précédent, puisque β est bien un nombre aléatoire. Pr[S 3 ] = Pr[S 4 ] et τ 4 = τ 3. Jeu J 5 : Dans ce jeu, nous changeons la façon dont est fabriqué le challenge. Le but est de pouvoir calculer celui-ci sans avoir besoin de la valeur β. Premièrement, nous retournons un aléa f au lieu de f = F(m 0, m 1, β, ID, c 0, c 0,1, c 1,1 ) : ceci ne peut poser de problème, car depuis le jeu J 1, ce genre de requêtes ne peut plus être posé par l adversaire. Deuxièmement, au lieu des définitions du jeu précédent, nous retournons des aléas c 0,1 et c 1,1. Si les valeurs G(c 0, w 0 ) et G(c 0, w 1 ) où w 0 = e(y, H(ID, 0))z et w 1 = e(y, H(ID, 1))z n apparaissent pas, ce jeu est indistinguable du précédent. Le challenge est alors défini comme suit. Challenge, pour deux messages (m 0,0, m 1,0 ) et (m 0,1, m 1,1 ) et une identité ID - La simulation calcule b = B(ID ) ; - Elle pose c 0 = g β ; - Elle tire également aléatoirement c 0,1 {0, 1} lm 2 +lq, c 1,1 {0, 1} lm 2 +lq et f {0, 1} l ; - Le challenge c = (c 0, c 0,1, c 1,1, f ) est retourné à l adversaire. Les deux jeux J 4 et J 5 sont indistinguables, à moins que les valeurs G(c 0, w 0 ) ou G(c 0, w 1 ) n apparaissent. Nous noterons cet événement Bad i dans les jeux J i suivants : Pr[S 4 ] Pr[S 5 ] + Pr[Bad 5 ] et τ 5 = τ 4. Comme le challenge ne dépend plus des messages choisis par l attaquant, l avantage de celui-ci est nécessairement nul, c est-à-dire Pr[S 5 ] = 1 2, et Adv IND-ID-CCA (A) 2 Pr[Bad 5 ] + 2ɛ DL. La fin de la preuve consiste donc à borner la valeur de la probabilité Pr[Bad]. Pour cela, nous pouvons remarquer qu il existe pour l adversaire deux façons de connaître une des valeurs G(c 0, w 0 ) ou G(c 0, w 1 ) : soit en la demandant à l oracle de hachage G (noté dans les jeux suivants 111

Chapitre 10. Cryptographie basée sur l identité avec réduction fine Ask i ), soit en la faisant intervenir dans un oracle de déchiffrement (noté dans les jeux suivants Coll i ). Adv IND-ID-CCA (A) 2 Pr[Ask 5 ] + 2 Pr[Coll 5 ] + 2ɛ DL. Jeu J 6 : Dans ce jeu, nous simulons l oracle de déchiffrement. Requête de déchiffrement Decrypt(c 0, c 0,1, c 1,1, f) pour l identité ID - Si c 0 = c 0, la simulation retourne, pour signifier que le message est invalide ; - Sinon, la simulation calcule b ID = B(ID) et demande la valeur H(ID, b ID ) à l oracle de hachage de la fonction H. Ensuite, la réduction retrouve la valeur (ID, b ID, t, h) dans la liste L H, et calcule d ID = y t. Avec la clé (b ID, d ID ), la simulation peut procéder à l étape de déchiffrement telle que donnée dans la description du schéma, et retourner le résultat correspondant. Ce jeu a été créé pour que, dorénavant, nous ayons Pr[Coll 6 ] = 0, c est-à-dire pour que les valeurs G(c 0, w 0 ) ou G(c 0, w 1 ) ne puissent être apprises grâce à l oracle de déchiffrement. Ce jeu est indistinguable du précédent, sauf si l adversaire est capable de former un chiffré valide avec un c 0 = c 0. Calculons maintenant cette probabilité. Pour qu un chiffré (c 0, c 0,1, c 1,1, f) soumis par l adversaire à l oracle de déchiffrement soit un chiffré valide pour l identité ID, il faut qu il existe (m, r) = (m 0 m 1, r) M Z q, avec r = β, tel que f = F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ). Ainsi, l adversaire pourrait avoir tenté de : deviner cette valeur f = F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ) sans la demander à l oracle de hachage (avec, dans le modèle de l oracle aléatoire, une probabilité de 2 l ) ; demander à l oracle de hachage F, mais ceci est en fait impossible, car depuis le jeu J 1, une telle valeur ne peut plus apparaître dans les requêtes de l oracle de hachage F ; connaître f = F(m 0, m 1, r, ID, c 0, c 0,1, c 1,1 ) grâce au challenge c est-à-dire utiliser la relation implicite (,, z, ID, c 0, c 0,1, c 1,1, f ) définie dans le jeu J 5 : ceci est impossible, car alors le chiffré soumis à l oracle de déchiffrement serait précisément le chiffré du challenge, ce qui est interdit. Aussi Adv IND-ID-CCA (A) 2 l+1 + 2 Pr[Ask 6 ] + 2ɛ DL et τ 6 = τ 5 + q d (3T e + 2T p ). Jeu J 7 : Finalement, nous séparons l événement Ask en deux : AskGood, pour lequel la valeur G(c 0, w b ) est demandée par l attaquant et AskBad, pour lequel la valeur 1 ID G(c 0, w b ) est ID demandée par l attaquant. Clairement, Pr[Ask 7 ] Pr[AskBad 7 ] + Pr[AskGood 7 ]. De plus, comme le bit b ID est indistinguable pour l adversaire (que ce soit au niveau de l extraction de clé ou de l algorithme de déchiffrement), Pr[AskBad 7 ] = Pr[AskGood 7 ], et Pr[Ask 7 ] 2 Pr[AskGood 7 ]. Remarquons que w 1 b ID vaut, par définition, w 1 b ID = e(y, h ID1 b ID ) β = e(g, g) txαβ. Aussi, au cas où l événement AskGood 7 a lieu, la réduction peut retrouver (ID, 1 b ID, t, h) dans la liste L H, calculer, pour chaque élément (w, g) de la liste L G, la valeur w 1 t, et ainsi résoudre le problème q h -LBDH. En conséquence, Pr[Ask 7 ] 2ɛ LBDH. 112

10.3. Comparaison des schémas et Adv IND-ID-CCA (A) 2 l+1 + 2ɛ LBDH + 2ɛ DL et τ 7 = τ 6 + q G T e. Le résultat découle du fait que ɛ LBDH ɛ DL et que q h = q F + q G + q H. 10.2.3 Réduction aux problèmes classiques DBDH et GBDH Pour terminer l étude de la sécurité de notre variante, nous exhibons de simples réductions des problèmes GBDH et DBDH au problème LBDH. Lemme 4. Le problème GBDH se réduit au problème q h -LBDH. Plus précisément, si un algorithme A résout le problème q h -LBDH en un temps τ et avec une probabilité ε, alors il existe un algorithme B qui résout le problème GBDH en un temps τ et avec une probabilité ε, avec ε ε et τ τ + q h T, où T est le temps d un oracle de test DBDH. Démonstration. La preuve consiste simplement à transférer le challenge GBDH (g, g 1, g 2, g 3 ) à l algorithme A qui résout le problème q h -LBDH. A retourne alors, en un temps τ et avec une probabilité ε, une liste contenant la réponse du problème CBDH. En testant un-à-un les éléments de cette liste, grâce à l oracle DBDH, la réponse au challenge GBDH est obtenue en un temps avec une probabilité 1 et un temps additionnel q h T. Lemme 5. Le problème DBDH se réduit au problème q h -LBDH. Plus précisément, si un algorithme A résout le problème q h -LBDH en un temps τ et avec une probabilité ε, alors il existe un algorithme B qui résout le problème DBDH en un temps τ et avec un avantage ε, avec ε ε 2q h q et τ τ. Démonstration. L algorithme B reçoit un challenge DBDH (g, g 1, g 2, g 3, w). B transfert alors (g, g 1, g 2, g 3 ) à l algorithme A qui résout le problème q h -LBDH. A retourne alors, en un temps τ et avec une probabilité ε, une liste L contenant la réponse du problème CBDH. Si l algorithme A réussit, alors, si w L, l algorithme B répond True, sinon, B répond False. Si A échoue, B répond au hasard. Ainsi, la réponse au challenge DBDH est obtenue sans temps additionnel. De plus, la probabilité que w soit dans la liste L alors que w n est pas la réponse au problème CBDH est de q hq. Comme nous pouvons le voir, ces deux lemmes montrent que notre variante est sûre sous l hypothèse de la difficulté du problème DBDH ou sous l hypothèse de la difficulté du problème GBDH, et ceci avec une réduction fine. 113

Chapitre 10. Cryptographie basée sur l identité avec réduction fine Tab. 10.1 Comparaison entre schéma IBE sûrs dans le modèle de l oracle aléatoire. Schéma [BF01] (Section 10.1.1) CBDH CCA O( [Gal05] CBDH CCA O( Sécurité au sens IND-ID-X Taille des chiffrés Efficacité Chiffrement Déchiffrement Hypothèse X Réduction (en bits) Coupl. Exp. Coupl. Exp. 1 q h 3 ) 2l m + 170 1 2 1 1 1 q h 2 ) l m + 250 1 2 1 1 [LQ05] GBDH CCA O( 1 q e ) l m + 170 1 2 1 0 [KW03] (Section 10.1.2) CBDH CPA O(1) 4l m 2 4 1 1 Schéma Section 10.2.1 GBDH CCA O(1) DBDH CCA O(1) l m + 590 2 2 1 1 10.3 Comparaison des schémas Dans cette section, nous comparons l efficacité de divers schémas de chiffrement basés sur l identité. Dans cette comparaison, nous incluons notamment l hypothèse sous laquelle le schéma est sûr, le scénario d attaque, le coût de la réduction et la taille des chiffrés. Le schéma [BF01, BF03] est prouvé sûr sous l hypothèse de la difficulté du problème CBDH. Comme nous l avons dit, une erreur dans le coût de la réduction de cet IBE a été rapportée par David Galindo dans [Gal05] : nous avons donc pris la réduction corrigée en O( 1 q 3 ). h Pour le schéma [KW03], comme nous l avons dit en Section 10.1.2, la façon d appliquer une transformation générique pour obtenir une sécurité contre les attaques à chiffrés et identités choisis n est pas précisée. Nous avons donc donné pour la taille un minimum de 4l m, et précisé que la sécurité assurée IND-ID-CPA. Dans [Gal05], David Galindo proposa également une variante du schéma Boneh-Franklin, que nous n avons pas détaillée dans ce chapitre. De même, Beno^ıt Libert et Jean-Jacques Quisquater ont proposé une variante [LQ05] dans laquelle toute redondance a été supprimée, et dans laquelle le déchiffrement ne nécessite qu un couplage. Pour notre comparaison, nous avons pris l q = 170 bits. Notons que les schémas ayant une réduction lâche devraient utiliser des paramètres plus grands, pour obtenir le même niveau de sécurité que les schémas à réduction fine. Pour notre variante, nous avons considéré que la valeur e(y, H(ID, 1 b ID )) pouvait être précalculée et stockée lors du déchiffrement (celle-ci étant toujours la même pour le déchiffreur). Nous voulions finalement signaler que très récemment, un schéma de chiffrement basé sur l identité avec une preuve dans le modèle standard a été conçu par Brent Waters [Wat05]. Malheureusement, cette preuve est très lâche, et ne peut a priori pas être améliorée par notre technique. 10.4 Conclusion À Crypto 01, Dan Boneh et Matthew Franklin proposèrent la première réalisation pratique d un schéma de chiffrement basé sur l identité (IBE). La sécurité de leur schéma, au sens de l indistinguabilité sous attaque à chiffrés et identités choisis, est équivalente au problème 114

10.4. Conclusion CBDH, dans le modèle de l oracle aléatoire. Cependant, la réduction proposée est loin d être fine. Dans ce chapitre, nous avons proposé de simples modifications au schéma Boneh-Franklin permettant une réduction de sécurité fine. Notre variante peut être vue comme un schéma IBE pour lequel, pour chaque identité, deux clés équivalentes pourraient servir au déchiffrement. Chaque identité ne reçoit qu une seule de ces deux clés, ce choix étant aléatoire et secret pour tout autre utilisateur que l autorité et le détenteur. Notre construction poursuit une idée introduite par Jonathan Katz et Nan Wang, qui n avaient pas explicité la façon d obtenir une résistance contre les attaques à chiffrés choisis. 115

Chapitre 10. Cryptographie basée sur l identité avec réduction fine 116

Chapitre 11 Padding universel optimal Sommaire 11.1 Notions préliminaires............................. 118 11.1.1 Redondance et entropie............................ 118 11.1.2 Fonction de padding universel......................... 118 11.1.3 Signature et chiffrement............................ 119 11.1.4 Permutations sans griffe............................ 119 11.2 Fonction de padding basée sur une permutation : OPbP......... 119 11.2.1 Description................................... 119 11.2.2 Analyse de sécurité............................... 120 11.2.3 Taille des paramètres et optimalité...................... 121 11.3 Construction basée sur OAEP3........................ 122 11.3.1 Description................................... 122 11.3.2 Analyse de sécurité............................... 122 11.3.3 Taille des paramètres.............................. 123 11.4 Conclusion.................................... 124 Lorsque la sécurité des schémas de chiffrement est considérée, l indistinguabilité lors d attaques à chiffrés choisis est la notion requise. De même, pour la sécurité des schémas de signature, la résistance aux falsifications existentielles sous attaques à messages choisis est indispensable. Pourtant, la sécurité n est pas la seule notion importante pour les schémas cryptographiques : toute bonne primitive se devrait d être rapide, avec une bande passante efficace, compacte en code et simple d utilisation. Les deux premiers critères sont habituellement les plus prisés, et ont fait l objet de nombreuses publications. Ainsi, après le travail fondateur de Mihir Bellare et Phillip Rogaway [BR93, BR94, BR96], la rapidité et la bande passante des schémas de signature ou de chiffrement ont été étudié, à travers la conception des fonctions de padding, dans [OP01a, PP03, PP04, Pha05]. Les signatures avec recouvrement de messages [NR94, NS00, BR96] et l idée de Jonathan Katz et Nan Wang [KW03] vont également dans le sens d une maximisation de la bande passante. Le dernier critère, regroupant la compacité du code et la simplicité d utilisation, fut considéré assez récemment par Jean-Sébastien Coron, Marc Joye, David Naccache et Pascal Paillier [CJNP02], au travers de l invention des paddings universels. Ce nouveau type de padding simplifie au maximum l utilisation, puisque les paddings universels peuvent être communément utilisés avec les primitives de chiffrement ou de signature. La première instance d un tel padding fut proposée par ces auteurs à l aide d une variante de PSS, appelée PSS-ES. Depuis, d autres solutions ont vu le jour, et notamment celle de Yuichi Komano et Kazuo Ohta [KO03], basée sur OAEP. 117

Chapitre 11. Padding universel optimal Dans ce chapitre, nous jetons un nouveau regard sur la notion de padding universel, en essayant d optimiser tous les critères en même temps. Ces recherches ont fait l objet d une publication à la conférence Acns 05 [CPP05] avec Duong Hieu Phan et David Pointcheval. Ceci poursuit l idée de deux papiers [PP03, PP04], qui consistait à proposer des schémas de chiffrement sûrs basés sur des paddings sans redondance. Pour optimiser les critères précédemment évoqués, les paddings que nous proposons sont simples, sans redondance pour le chiffrement et déterministes pour la signature. Nos propositions sont très simples d utilisation, car nous prouvons que l utilisateur peut n utiliser qu une seule paire de clés pour le chiffrement et la signature (voir également [HP01]). Plus précisément, nous étudions deux fonctions de padding universel. La première est construite à l aide d une permutation sur tout le domaine (en anglais, Full-Domain Permutation), étudiée dans [Gra02] pour une utilisation dans le cadre des schémas de signature et dans [PP03] pour le chiffrement. Cette proposition peut être prouvée optimale en terme de bande passante, dans le modèle de la permutation aléatoire, et a donc été nommée en anglais, Optimal Permutation-based Padding (OPbP). Notre deuxième proposition est basée sur l utilisation de la fonction de padding OAEP3 [PP03, PP04], et sa sécurité est prouvée dans un modèle moins fort, le modèle de l oracle aléatoire [BR93]. 11.1 Notions préliminaires 11.1.1 Redondance et entropie Un pré-requis pour le chiffrement, pour assurer une sécurité sémantique, est d utiliser un mécanisme de chiffrement probabiliste, de façon à rendre les distributions des chiffrés indistinguables. Mais jusqu à récemment, les cryptologues pensaient que de la redondance était également nécessaire (pour une sorte de preuve de connaissance du message clair associé au chiffré [BR94, BDPR98, CS98]). Cependant, Duong Hieu Phan et David Pointcheval [PP03, PP04] ont montré qu il était possible d atteindre, dans le modèle de l oracle aléatoire, une sécurité des schémas de chiffrement sans redondance. De façon similaire, pour les schémas de signature, la redondance est nécessaire, pour prévenir des falsifications existentielles. Mais la plupart des schémas de signature sont probabilistes (par exemple [Sch91, NIST94, BR96, CS99]), alors que ce n est a priori pas une nécessité. Récemment, Jonathan Katz et Nan Wang ont montré qu une sécurité fine pouvait être obtenue même avec une construction déterministe, en ajoutant un simple bit non plus aléatoire mais dépendant du message [KW03] (voir Section 6.2.1). Plus précisément, ce bit ne doit pas être prévisible par une autre personne que le signataire, et ces auteurs ont donc proposé qu il soit le résultat d une fonction pseudo-aléatoire avec une clé secrète. 11.1.2 Fonction de padding universel Le but des paddings universels est de pouvoir être utilisés aussi bien dans le cadre des schémas de signature que des schémas de chiffrement. Cette utilisation peut être soit indépendante soit parallèle (c est-à-dire avec une seule et même clé pour la signature et le déchiffrement). Aussi, dans le modèle de sécurité, les adversaires (cherchant à distinguer le schéma de chiffrement ou à exhiber une falsification existentielle pour le schéma de signature) ont un accès simultané à deux oracles de signature et de déchiffrement, ce qui n est pas le cas du scénario correspondant à une utilisation exclusive en chiffrement ou en signature. En effet, l oracle de déchiffrement pourrait aider à falsifier une signature et réciproquement. 118

11.1.3 Signature et chiffrement 11.2. Fonction de padding basée sur une permutation : OPbP Comme précédemment évoqué, une de nos motivations est de construire un padding universel pouvant être aussi bien utilisé pour la signature que pour le chiffrement, et ceci, en parallèle, avec la même primitive asymétrique et un unique couple de clés. Le but d un adversaire est donc le même que dans la Section 4.3.1 ou la Section 8.1.2 : concevoir une falsification existentielle (correspondant à la notion de sécurité EUF) contre le schéma de signature ou distinguer un chiffré (correspondant à la notion de sécurité IND) du schéma de chiffrement. Cependant, l attaquant peut pour cela utiliser les moyens des deux attaques : un accès simultané à l oracle de signature et à l oracle de déchiffrement, et ceci de façon entièrement adaptative. Aussi, nous noterons ce scénario comme une attaque CMA+CCA. 11.1.4 Permutations sans griffe Dans [KW03], Jonathan Katz et Nan Wang ont montré qu en utilisant une permutation à trappe induite par une permutation sans griffe (en anglais, claw-free permutation), il était possible d obtenir une variante de RSA-FDH (en ajoutant un simple bit) avec une réduction fine. Nous allons également utiliser cette technique. L existence de permutations sans griffe est en effet raisonnable : toute permutation aléatoire auto-réductible peut être vue comme une permutation à trappe induite par une permutation sans griffe [DR02], et tous les exemples connus de permutations à trappe sont auto-réductibles. Définition 22 (Permutations sans griffe). Une famille de permutations sans griffe est un ensemble d algorithmes {Gen E ; f i ; g i i I}, pour un ensemble d index I, tel que : Gen E génère un index aléatoire i et une trappe sk ; f i, g i sont deux permutations sur le même domaine D i ; il y a un algorithme efficace qui, pour un index i, génère un aléa x D i ; fi 1 (l inverse de f i ) et gi 1 (l inverse de g i ) sont efficacement calculables avec la trappe sk. Une griffe est une paire (x 0, x 1 ) telle que f(x 0 ) = g(x 1 ). Un algorithme probabiliste A (τ, ɛ)-casse une famille de permutations sans griffe si l exécution de A prend un temps inférieur à τ et si A génère une griffe avec une probabilité supérieure à ɛ : Pr [ (i, td) Gen E (1 k ), (x 0, x 1 ) A(i) : f i (x 0 ) = g i (x 1 ) ] ɛ. Une famille de permutations sans griffe est (τ, ɛ)-sûre si aucun algorithme ne peut la (τ, ɛ)-casser. 11.2 Fonction de padding basée sur une permutation : OPbP 11.2.1 Description Dans cette section, nous proposons un padding universel basé sur la construction de [PP03], dans le modèle de la permutation aléatoire. Notre proposition est optimale aussi bien pour le chiffrement que pour la signature, c est-à-dire n a besoin que de 82 bits de plus que le message : ces bits servent d entropie pour le chiffrement et de redondance pour la signature. Dans ce chapitre, nous décrivons la fonction proposée, et renvoyons à notre publication [CPP05] ou à la thèse de Duong Hieu Phan [Pha05] pour une preuve complète de sa sécurité. Soient l n et l t deux paramètres de sécurité, avec l m = l n l t 1 > 0. Pour notre construction, nous avons besoin d une permutation P : {0, 1} ln {0, 1} ln, que nous supposerons agir comme 119

Chapitre 11. Padding universel optimal une permutation aléatoire. Soit également Φ pk : {0, 1} ln {0, 1} ln une permutation à sens unique à trappe (dont l inverse sera noté ψ sk ). Nous utilisons également une famille de fonctions pseudo-aléatoires Ψ ς : {0, 1} lm {0, 1}, où ς constitue la clé. Les messages à signer ou à chiffrer appartiennent à l ensemble M = {0, 1} lm = {0, 1} ln lt 1, et les chiffrés et signatures appartiennent à l ensemble N = {0, 1} ln. Nous notons T l ensemble {0, 1} lt et U l ensemble {0, 1} lm+1. Padding universel OPbP [CPP05] Padding : Notre fonction de padding est très simple : elle prend en entrée un bit γ, un message m M et une donnée complémentaire r T. Alors nous définissons OPbP comme OPbP(γ, m, r) = P(γ m r) = t u, où t T et u U et l opération inverse comme OPbP 1 (t, u) = P 1 (t u) = γ m r. Chiffrement : Pour chiffrer un message m M, l utilisateur tire un aléa r T, un bit aléatoire γ, et calcule le chiffré c comme c = Φ pk (t u), pour t u = OPbP(γ, m, r). Déchiffrement : Pour déchiffrer c N, l usager calcule t u = ψ sk (c), où t T et u U, puis γ m r = OPbP 1 (t, u). Le clair correspondant est le message m. Signature : Pour signer un message m M, il faut calculer γ = Ψ ς (m), puis t u = OPbP(γ, m, 0 lt ). La signature est σ = ψ sk (t u). Vérification : Pour vérifier une signature σ N, il faut calculer t u = Φ pk (σ), où t T et u U, puis γ m r = OPbP 1 (t, u). Si r = 0 lt, la signature est acceptée et l algorithme de vérification retourne le message m ; sinon, la signature est rejetée. Le découpage de N en T U peut sembler ici arbitraire, mais la raison sous-jacente apparaîtra dans la seconde section de ce chapitre. 11.2.2 Analyse de sécurité Dans [PP03], cette fonction de padding a déjà été prouvée sûre contre les attaques IND- CCA, pour son utilisation dans les schémas de chiffrement (dans le modèle de la permutation aléatoire). Dans notre publication, nous avons étendu cette preuve au scénario CMA+CCA, puis la sécurité du schéma de signature utilisé en parallèle du schéma de chiffrement (c est-à-dire la sécurité EUF-CMA+CCA). Nous rappelons ici simplement le résultat, tout en renvoyant à [CPP05, Pha05] pour une preuve complète. La construction est équivalente, à l exception du bit additionnel γ qui peut être vu comme un simple ajout d un bit d entropie supplémentaire. 120

11.2. Fonction de padding basée sur une permutation : OPbP Théorème 15. Soient A et B des adversaires à chiffrés choisis (pour l oracle de déchiffrement) et à messages choisis (pour l oracle de signature), respectivement contre le schéma de chiffrement et le schéma de signature. Si A peut casser la sécurité sémantique du chiffrement avec un avantage ε E, ou si B peut produire une falsification existentielle avec une probabilité ε S (en un temps τ, après q p, q s, q d requêtes aux oracles de permutation, signature et déchiffrement respectivement), alors la permutation Φ pk peut être inversée avec une probabilité ε en un temps τ, avec : où τ τ + O(q p + q d + q s + 1) et ε ε E et ε ε S q p + q s + 1 = (q p + q d + q s + 1) 2 2 lt+lm+1 + (q d + 1) 2 2 lm + 2q p + q d + q s + 2 2 lt. Plus particulièrement, si la fonction Φ pk est induite par une permutation sans griffe (τ, ε )- sûre, nous avons également ε ε S 2. 11.2.3 Taille des paramètres et optimalité Pour obtenir un niveau de sécurité de 2 κ, nous cherchons des paramètres de sécurité tels que le rapport entre le temps τ et la probabilité de l adversaire ε soit au moins de 2 κ, ou, de façon similaire, tels que ε/τ 2 κ, avec un niveau de sécurité usuel κ = 80. Pour obtenir les tailles nécessaires des paramètres, nous pouvons simplifier tout d abord le Théorème 15. Soit Q le nombre total de requêtes, c est-à-dire Q = q p + q s + q d. Comme le temps de l attaque τ est limité à 2 80, ce nombre Q est lui aussi limité à 2 80. Nous obtenons donc 2 Q2 Q2 + lt+lm 2Q +. lm 2 2 lt De plus, pour des utilisations pratiques, nous savons que la taille l m des messages est bien plus grande que le paramètre de sécurité l t. Aussi, les quantités Q/2 lm ou Q 2 /2 lm peuvent être négligées en comparaison à Q/2 lt. Nous obtenons alors (en utilisant que Q τ) : et ε E τ ε τ + 2 2 lt ε S τ Qε + 2 dans le cas général τ 2 lt 2ε τ + 2 2 lt si la fonction Φ pk est induite par une permutation sans griffe En conclusion, pour le cas général, nous pouvons choisir l t = 82 si le niveau de sécurité de la fonction Φ pk est de 2 161. Pour le cas particulier d une permutation à trappe induite par une permutation sans griffe, un niveau de sécurité de la fonction Φ pk de 2 82 est suffisant. Ainsi, pour le RSA, selon l estimation de Arjen Lenstra et Eric Verheul [LV00], un module de 1024 bits est suffisant. Nous remarquons qu avec seulement 82 bits de redondance, nous obtenons le même niveau de sécurité que RSA-PSS [BR96] ou RSA-OAEP [BR94], qui, comparés à notre schéma, possèdent une bande-passante plus petite. 121

Chapitre 11. Padding universel optimal 11.3 Construction basée sur OAEP3 11.3.1 Description Pour obtenir une construction similaire dans le modèle plus usuel de l oracle aléatoire [BR93], nous considérons maintenant la version à 3 tours de OAEP, comme proposée dans [PP03, PP04]. La sécurité de ce padding pour le chiffrement a également été étudiée dans ces papiers. Nous étendons la preuve pour l appliquer également à une utilisation pour la signature. Comme dans la Section 11.2, l t et l n sont des paramètres de sécurité avec l m = l n l t 1 > 0, Φ pk : {0, 1} ln {0, 1} ln est une permutation à sens unique à trappe (dont l inverse sera noté ψ sk ), et Ψ ς : {0, 1} lm {0, 1} est une famille de fonctions pseudo-aléatoires, où ς désigne la clé. Les messages à signer ou à chiffrer appartiennent à l ensemble M = {0, 1} lm = {0, 1} ln lt 1, et les chiffrés et signatures appartiennent à l ensemble N = {0, 1} ln. Nous notons T l ensemble {0, 1} lt et U l ensemble {0, 1} lm+1. Par contre, en lieu et place de la permutation P utilisée en Section 11.2, nous utilisons trois fonctions de hachage : F, G, H (que nous supposerons agir comme des oracles aléatoires) : F : T U G : U T H : T U. Padding universel OAEP3 [CPP05] Padding : La fonction de padding prend en entrée un bit γ, un message m M et une donnée complémentaire r T. Alors nous définissons OAEP3(γ, m, r) comme : s = (γ m) F(r), t = r G(s), u = s H(t), OAEP3(γ, m, r) = t u et OAEP3 1 (t, u) comme : s = u H(t), r = t G(s), γ m = s F(r), OAEP3 1 (t, u) = γ m r. Chiffrement : Pour chiffrer un message m M, l utilisateur tire un aléa r T, un bit aléatoire γ, et calcule le chiffré c comme c = Φ pk (t u), pour t u = OAEP3(γ, m, r). Déchiffrement : Pour déchiffrer c N, l usager calcule t u = ψ sk (c), où t T et u U, puis γ m r = OAEP3 1 (t, u). Le clair correspondant est le message m. Signature : Pour signer un message m M, il faut calculer γ = Ψ ς (m), puis t u = OAEP3(γ, m, 0 lt ). La signature est σ = ψ sk (t u). Vérification : Pour vérifier une signature σ N, il faut calculer t u = Φ pk (σ), où t T et u U, puis γ m r = OAEP3 1 (t, u). Si r = 0 lt, la signature est acceptée et l algorithme de vérification retourne le message m ; sinon, la signature est rejetée. 11.3.2 Analyse de sécurité 122 Nous étendons alors le résultat de [PP04] par le théorème suivant :

11.3. Construction basée sur OAEP3 Théorème 16. Soient A et B des adversaires à chiffrés choisis (pour l oracle de déchiffrement) et à messages choisis (pour l oracle de signature), respectivement contre le schéma de chiffrement et le schéma de signature. Si A peut casser la sécurité sémantique du chiffrement avec un avantage ε E, ou si B peut produire une falsification existentielle avec une probabilité ε S (en un temps τ, après q F, q G, q H, q s, q d requêtes aux oracles de hachage F, G et H, et aux oracles de signature et déchiffrement), alors la permutation Φ pk peut être inversée avec une probabilité ε en un temps τ, avec : ε ε E et ε ε S q p + q s + 1 où τ τ + O(q F + q 2 d + q d q G q H ) et ( 1 = q 2 d 2 lm+1 + 6 ) + 4q dq G 2 lt 2 lm+1 + 5q dq F + q Gq H + q Gq s + q G 2 lt 2 lt 2 lt 2 lm+1 + q F 2 + q d. lt 2 lt Plus particulièrement, si la fonction Φ pk est induite par une permutation sans griffe (τ, ε )- sûre, nous avons également ε ε S 2. Encore une fois, pour la preuve complète, nous référons le lecteur à notre publication [CPP05] ou à la thèse de Duong Hieu Phan [Pha05]. 11.3.3 Taille des paramètres En utilisant des arguments similaires à la Section 11.2.3, les tailles des paramètres sont obtenues. Pour le chiffrement : ε E τ ε τ + Q 2 lt. Aussi, l t = 161 est suffisant si les paramètres de sécurité sont suffisamment grands (c està-dire si ε /τ < 2 81 ). Pour la signature, dans le cas général : τ Qε + Q. τ 2 lt Dans cas cas, l t = 161 reste valide, tant que ε /τ < 2 161. ε S Pour la signature, si la fonction Φ pk est induite par une permutation sans griffe : ε S τ 2ε τ + Q. 2 lt Nous avons ainsi une expression similaire au cas du chiffrement (le terme ε /τ étant remplacé par 2ε /τ), ce qui permet de plus petits paramètres de sécurité. Dans l ensemble, l t = 161 est requis, dès que ε /τ < 2 82. Pour résumer, dans le cas le plus intéressant, celui du RSA, le paramètre l t = 161 peut être choisi, si le paramètre de sécurité l n implique un niveau de sécurité de la fonction Φ pk d environ 2 82, ce qui correspond à un module de 1024 bits. 123

Chapitre 11. Padding universel optimal 11.4 Conclusion Dans ce chapitre, nous avons jeté un nouveau regard sur la notion de padding universel, en essayant d optimiser en même temps les critères de rapidité, de bande passante, de compacité en code et de simplicité d utilisation. Pour optimiser les critères précédemment évoqués, les paddings que nous avons proposés sont simples, sans redondance pour le chiffrement et déterministes pour la signature. Nos propositions sont très simples d utilisation, car nous prouvons que l utilisateur peut utiliser une même paire de clés pour une utilisation simultanée en chiffrement et signature. Plus précisément, une première construction (nommée en anglais Optimal Permutation-based Padding OPbP), basée sur une permutation sur tout le domaine, a été proposée. Elle a pu être prouvée optimale selon nos critères, dans le modèle de la permutation aléatoire. Une deuxième proposition, basée sur l utilisation de la fonction de padding OAEP3, a été prouvée dans un modèle moins fort, le modèle de l oracle aléatoire. 124

Quatrième partie Résistance aux attaques à canaux cachés 125

Introduction D après Oded Goldreich [Gol01], la cryptographie est la mise en place des concepts, la définition et la construction de systèmes concernant les problèmes de sécurité. Nous voudrions ajouter que le domaine de la cryptographie comporte également la mise en place de tels systèmes. En d autres termes, les définitions des systèmes mais également leur mise en œuvre logicielle ou matérielle doivent protéger de toute fraude. Une dernière partie de nos recherches durant cette thèse a concerné les protections contre les attaques sur les mises en œuvre des algorithmes (appelées aussi attaques physiques). Notre travail à Gemplus nous a également permis de nous confronter à ces attaques. Parmi les attaques sur les mises en œuvre des algorithmes, nous distinguerons deux grandes familles : les attaques par fautes, introduites par Dan Boneh, Richard DeMillo et Richard Lipton [BDL97] et les attaques par canaux cachés, comme présentées par Paul Kocher, Joshua Jaffe et Benjamin Jun [Koc96, KJJ99]. Attaques par fautes. Les attaques par fautes sont des attaques actives, c est-à-dire dans lesquelles l attaquant perturbe le comportement du programme exécuté. Cette perturbation peut être notamment due à l utilisation d un laser, à une variation rapide de la tension, ou encore à une perturbation électromagnétique. Le but est alors de récupérer un résultat erroné, en rapport direct avec le secret visé, l attaque étant achevée par une cryptanalyse. Le cas le plus célèbre d attaque par fautes fut présenté par Marc Joye, Arjen Lenstra et Jean-Jacques Quisquater [JLQ99], et s applique à l accélération du RSA par le théorème des restes chinois (appelée le RSA-CRT). Rappelons que le RSA-CRT consiste à retrouver s = m d mod n par le calcul et la recombinaison par théorème des restes chinois de s p = m d mod p et de s q = m d mod q, ce que nous noterons s = s p, s q. Le principe est le suivant : l attaquant tire un message aléatoire m. Ensuite, il fait exécuter le calcul du RSA-CRT sur m, et perturbe uniquement une des deux demi-exponentiations. Supposons pour notre exemple que le calcul modifié soit le calcul de s p. L attaquant reçoit alors ŝ = k, m d mod q, dans lequel k est le résultat modifié de s p, c est-à-dire k m d mod p. L attaquant peut alors retrouver la factorisation secrète par q = gcd(ŝ e m, n). Ainsi, les attaques par faute sur le RSA-CRT sont très efficaces, puisqu une seule faute suffit et qu il n est pas nécessaire de contrôler l effet de la faute. Bien sûr, l attaque exposée ne s applique qu à la primitive RSA, c est-à-dire au RSA utilisé sans padding. Il est néanmoins aisé de la généraliser au RSA utilisé avec les paddings déterministes (comme FDH) ou les paddings probabilistes où l aléa est adjoint à la signature (comme PFDH [Cor02]). Étendre cette attaque au RSA utilisé avec un padding probabiliste où l aléa est retrouvé dans la signature (comme PSS) est un problème ouvert à ce jour. Au contraire des attaques par fautes contre le RSA-CRT, les attaques par faute contre le mode standard du RSA sont assez inefficaces. Les méthodes classiques consistent à modifier un-à-un les bits de l exposant d ou à perturber, à un moment particulier de la boucle d exponentiation, 127

Introduction le test de la valeur du bit courant de d. Ce type de méthodes nécessite à la fois un grand nombre de fautes et une grande précision dans celles-ci (il est en effet bien plus difficile de modifier un bit particulier de l exposant que de provoquer une erreur quelconque de calcul comme cela était le cas sur le RSA-CRT). Nous avons proposé à la conférence Ches 06 [BCCC06], avec Éric Brier, Mathieu Ciet et Christophe Clavier, une nouvelle méthode pour appliquer une attaque par fautes, dans le RSA en mode standard. Notre article, non repris dans cette thèse, introduit la première attaque par fautes applicable au RSA en mode standard qui permet de retrouver l exposant privé en ne corrompant qu un élément public de clé. En effet, à la manière d une attaque proposée par Jean- Pierre Seifert permettant de faire accepter, grâce à une faute, de fausses signatures [Sei05], nous ne ciblons que le module RSA durant notre attaque. Un des points forts de notre attaque est que les hypothèses sur les effets des fautes que nous provoquons sont très limitées. En effet, dans un premier mode de notre attaque, nous n avons besoin d absolument aucune connaissance particulière de l effet de la faute pour retrouver l exposant privé dans sa totalité. Dans un second mode, basé sur un modèle de faute permettant la définition de ce que nous appelons des dictionnaires, nous améliorons l attaque, en réduisant d un facteur significatif le nombre de fautes nécessaires. Toutes nos attaques sont tout à fait applicables sur des produits non sécurisés. Notons que l utilisation de paddings déterministes (comme RSA-FDH) ou probabilistes (comme RSA-PFDH) n a pas d influence sur notre attaque, la seule impossibilité correspondant aux schémas probabilistes dans lesquels l aléa est retrouvé dans la signature elle-même (comme par exemple RSA-PSS). Attaques par canaux cachés. Cette partie de notre thèse ne concerne que la seconde famille des attaques physiques : les attaques par canaux cachés. Ces attaques sont des attaques passives, dans le sens où l attaquant n a pas besoin de modifier l exécution de l algorithme, mais uniquement de mesurer celle-ci. Par mesure, nous entendons l enregistrement de données physiques durant l algorithme, ces données pouvant être de différentes natures (notamment la consommation de courant, les émissions électromagnétiques ou le temps d exécution). Or, selon des modèles validés par l expérience, ces données physiques sont reliées aux secrets manipulés durant l algorithme, soit parce ces derniers influent le déroulement (au travers de tests par exemple), soit parce que leur simple manipulation entraîne des modifications physiques visibles de l extérieur. Le but des attaques à canaux cachés consiste ainsi à inférer les secrets recherchés à travers les données physiques mesurées. Parmi les attaques à canaux cachés, une première forme est constituée des attaques simples, dans lesquelles le recouvrement des données secrètes se fait sur une simple courbe (par recherche de formes particulières sur la courbe, par exemple, pour identifier différentes opérations). Une seconde forme est constituées des attaques différentielles, dans lesquelles une étude statistique est utilisée, sur plusieurs courbes, pour révéler les données secrètes. Dans le reste de cette partie, nous considérons de nouvelles protections contre les attaques à canaux cachés. Les attaques simples par canaux cachés sont le sujet du Chapitre 12, alors que les attaques différentielles par canaux cachés sont prises en compte dans le Chapitre 13. 128

Chapitre 12 L atomicité : une solution générique et peu coûteuse contre la SPA Sommaire 12.1 Introduction................................... 129 12.2 Atomicité face aux attaques à canaux cachés............... 130 12.2.1 Blocs atomiques................................. 130 12.2.2 Illustration................................... 130 12.2.3 Méthodologie générale............................. 132 12.3 Atomicité et exponentiations......................... 133 12.3.1 Hypothèses de nos constructions....................... 133 12.3.2 Algorithmes génériques d exponentiation à fenêtre glissante........ 133 12.3.3 Algorithmes simplifiés............................. 134 12.4 Atomicité et courbes elliptiques....................... 135 12.4.1 Courbes elliptiques définies sur un corps premier.............. 135 12.4.2 Courbes elliptiques définies sur un corps binaire............... 136 12.5 Version atomique de l exponentiation MIST................ 138 12.6 Conclusion.................................... 139 Ce chapitre introduit de nouvelles méthodes, efficaces et simples, pour transformer un algorithme cryptographique en un algorithme équivalent résistant aux attaques simples par canaux cachés. Contrairement aux solutions précédemment connues, la technique proposée ne se fait pas au détriment du temps d exécution. De plus, notre technique est générique, et peut ainsi s appliquer à toutes sortes d algorithmes. En application, nous proposons plusieurs nouvelles routines d exponentiation : un algorithme binaire d exponentiation gauche-droite, son équivalent droite-gauche, et plusieurs algorithmes à fenêtre glissante. Nous illustrons également notre méthodologie dans le cadre de la multiplication scalaire de points sur les courbes elliptiques. Tous les algorithmes présentés ont en commun d avoir une complexité approximativement égale à leur mise en œuvre non sécurisée. Ce chapitre a fait l objet d une publication dans le journal IEEE Transactions on Computers, 53 [CCJ04], co-écrite avec Mathieu Ciet et Marc Joye. 12.1 Introduction Supposons qu un algorithme consiste en une boucle, dans laquelle le code exécuté dépend de certaines valeurs d entrée secrètes (comme une clé par exemple). Si, à partir de canaux cachés 129

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA (comme le temps d exécution ou la consommation de courant), il est possible à un attaquant de distinguer quelles instructions sont exécutées, alors l attaquant peut en déduire la valeur de la donnée secrète. Cette idée est la base même des attaques par canaux cachés simples, connues sous le nom anglais Simple Power Analysis, SPA [Koc96, KJJ99]. Imaginons par exemple qu à un moment donné, un bit secret serve à choisir, entre deux processus Π 0 ou Π 1, lequel exécuter. Une contre-mesure naïve pour protéger d une attaque à canaux cachés simple consiste à rendre les deux processus Π 0 et Π 1 indistinguables par canaux cachés. Cela est obtenu usuellement en exécutant des processus factices, qui ne changent pas le résultat de l algorithme mais qui, d un point de vue des canaux cachés, sont les plus indistinguables possible des processus classiques. Malheureusement, ce genre de solution est assez insatisfaisante, car le temps d exécution peut alors être augmenté d un facteur non négligeable. En un sens, notre approche affine la solution naïve autant que possible. En insérant un minimum d opérations factices, nous transformons chaque processus en une suite de blocs apparaissant, par analyse des canaux cachés, comme équivalents. Nous appelons ces blocs des blocs atomiques. Nous développons alors plusieurs approches pour réécrire un code complet sous la forme d une série ininterrompue de blocs atomiques. Ainsi, pour l attaquant, l exécution de l algorithme apparaît comme une succession de blocs équivalents, ne lui offrant d autre information que le nombre de ces blocs. Avantageusement et contrairement aux contre-mesures précédentes, notre technique est très peu coûteuse et présente l avantage d être entièrement générique : tout algorithme cryptographique pourrait, a priori, être modifié sous forme de blocs atomiques. 12.2 Atomicité face aux attaques à canaux cachés 12.2.1 Blocs atomiques Chaque processus peut être vu comme une séquence d instructions. Nous dirons que deux instructions (ou séquences d instructions) sont équivalentes en canal caché si elles sont indistinguables à travers l étude des canaux cachés. Cette relation sera notée par le symbole. À partir de là, nous définissons ce que nous appelons un bloc atomique commun. Définition 23 (Atomicité en canal caché [CJ02]). Étant donné un ensemble de processus {Π 0,..., Π n }, un bloc atomique commun Γ pour Π 0,..., Π n est une séquence d instructions équivalentes en canal caché, telle que chaque processus Π j (0 j n) puisse être exprimé comme une répétition de ce bloc Γ, c est-à-dire telle qu il existe une séquence γ j,i Γ telle que Π j = γ j,1 γ j,2 γ j,lj. Ces séquences d instructions γ j,i sont appelées blocs atomiques. Un bloc atomique commun Γ existe toujours, étant donné que des instructions factices peuvent toujours être ajoutées artificiellement à un processus existant, dans le but de rendre les différents processus indistinguables. En fait, la principale difficulté de notre approche est plutôt de trouver un bloc Γ qui soit le plus petit suivant une métrique donnée (par exemple le temps d exécution ou la taille du code). Notons qu un réordonnancement ou une réécriture des processus peuvent réduire Γ ou limiter le nombre d instructions factices, et ainsi améliorer les performances. 12.2.2 Illustration Avant d aller plus loin, nous voudrions illustrer notre propos d un exemple simple mais significatif : la sécurisation de l algorithme binaire d exponentiation (en anglais, l algorithme 130

12.2. Atomicité face aux attaques à canaux cachés square-and-multiply). Étant donné un élément x d un groupe multiplicatif G et un exposant d écrit sous forme binaire d = (d m 1,..., d 0 ) 2, l algorithme binaire d exponentiation retourne y = x d. Entrée : x, d = (d m 1,..., d 0) 2 Sortie : y = x d R 0 1 ; R 1 x ; i m 1 tant que (i 0){ R 0 R 0 2 si (d i = 1) alors R 0 R 0 R 1 i i 1 } retourne R 0 Fig. 12.1 Algorithme binaire d exponentiation non sécurisé. Comme précédemment dit, un choix valide pour un bloc atomique commun Γ serait une opération de mise au carré suivie d une instruction (possiblement factice) de multiplication et d une décrémentation du compteur. Nous retrouvons alors l algorithme classique square-andmultiply always [Cor99]. C est le moyen classiquement utilisé pour prévenir des attaques simples par canaux cachés contre l algorithme binaire d exponentiation. Pourtant, comme nous allons le voir, un tel choix de Γ est sous-optimal. En supposant que (i) une opération de mise au carré peut être exécutée en appelant la routine de multiplication (qu elle soit hardware ou software), et (ii) les instructions R 0 R 0 R 0 et R 0 R 0 R 1 sont équivalentes en canal caché, nous pouvons réécrire l algorithme pour révéler un bloc commun Γ bien plus petit (voir la Figure 12.2-a). Remarquons également l instruction factice i i 0. Naturellement, nous supposons que cette instruction est équivalente en canal caché à i i 1. 1111 ÓÒ Ò ÈÖÓ ¼ µ ½ ¼ ½ ÈÖÓ ½ ¼ ¾¾ Entrée : x, d = (d m 1,..., d 0) Ò 2 Sortie : y = x d R 0 1 ; R 1 x k 0 ; i m 1 tant que (i 0) { 0000 R 0 R 0 R k k k d i i i k } retourne R 0 (a) Synopsis. (b) Version atomique de l algorithme binaire d exponentiation. Fig. 12.2 Algorithme d exponentiation binaire protégé. Comme décrit à la Figure 12.2-a, l algorithme n est pas équilibré : il y a deux copies du bloc Γ quand d i = 1 alors qu il n y en a qu une quand d i = 0. Cependant, comme nous l expliquerons dans la prochaine section, il est aisé de dérouler le code de telle façon que l analyse en canal caché ne révèle qu une séquence ininterrompue de copies de Γ, sans rendre possible la distinction entre Ces hypothèses sont discutées en Section 12.3.1. 131

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA les processus exécutés (c est-à-dire Π 0 ou Π 1 ). Après simplification, nous obtenons par notre méthode l algorithme présenté à la Figure 12.2-b. Il est important de noter que notre algorithme protégé (Figure 12.2-b) ne requiert que 1.5m multiplications en moyenne, pour calculer y = x d, ce qui est la complexité de la version non protégée de l algorithme binaire d exponentiation (Figure 12.1). 12.2.3 Méthodologie générale Après l exemple de la section précédente, nous donnons maintenant une explication plus formelle de notre technique. Étant donné différents processus Π 0,..., Π n, nous identifions tout d abord un bloc atomique commun Γ. Ensuite, nous écrivons les processus Π j (0 j n) comme des répétitions du bloc Γ, c est-à-dire Π j = γ cj γ cj +l j 1, où l j est le nombre de copies de Γ dans Π j, { c0 = 0 c j = c j 1 + l j 1 pour 1 j n et où γ k Γ pour tous c 0 k c n + l n 1. Notre stratégie est alors d exécuter exactement l j fois une séquence de blocs Γ pour remplacer le processus Π j. Ainsi, en notant t le temps d exécution du bloc Γ, le temps requis pour le processus Π j sera seulement de l j t au lieu de (max 0 j n l j ) t pour la solution triviale de sécurisation. Pour enchaîner les différents processus, nous utilisons un bit s (s pour stop), pour retenir s il y a encore des blocs γ k Γ à exécuter pour simuler l exécution du processus en cours Π j. Quand le processus Π j est terminé (et ainsi s = 1), nous devons alors exécuter le processus suivant selon les données d entrée de l algorithme. Aussi, au début de chaque boucle, nous mettons à jour k, le compteur du bloc γ courant, par k ( s) (k + 1) + s f(valeurs d entrée) de telle façon que f(valeurs d entrée) = c j si le prochain processus à exécuter est Π j. Nous voyons ainsi que, lorsque s = 0, k est incrémenté de 1 pour poursuivre le processus courant, et que lorsque s = 1, k vaut c j, pour débuter le processus suivant Π j. Bien sûr, l expression de k doit être codée de telle façon qu aucune information à propos des données d entrée ne soit révélée par canal caché. De façon alternative, k peut être défini comme le compteur du processus courant ; l étape de rafraîchissement devient alors : k ( s) (k + 1). Les données d entrée sont alors utilisées pour faire la distinction entre les différents blocs atomiques. La dernière étape de notre méthodologie consiste à exprimer chaque bloc γ k : comme un élément d une table (approche explicite ou matricielle de l atomicité), ou comme une fonction de k, de s et des données d entrée (approche implicite de l atomicité). Dans les sections suivantes, nous mettons en pratique notre technique, en donnant des exemples des deux approches. En conséquence, notre algorithme révèle, en canal caché, le poids de Hamming de l exposant. Ceci n est généralement pas un problème, notamment car l exposant est en général long. Si cependant cette fuite était gênante, le poids de Hamming pourrait être dissimulé en utilisant des techniques standards, telles que le découpage (en anglais, splitting) ou le masquage (en anglais, blinding) de l exposant. 132

12.3. Atomicité et exponentiations 12.3 Atomicité et exponentiations Le cryptosystème le plus largement utilisé est le RSA [RSA78] voir la Section 4.4.1. Son opération de base est l exponentiation modulaire, qui est habituellement calculée grâce à l algorithme binaire d exponentiation (en anglais, l algorithme square-and-multiply). Une version atomique de cet algorithme a déjà été donnée à la Figure 12.2 (voir aussi [Joy02]). Cette section présente une version protégée de l algorithme d exponentiation à fenêtre glissante de ω bits, pour n importe quel ω > 1. Nous présentons également une version simplifiée pour le cas ω = 2, ainsi qu une variante droite-gauche de l algorithme binaire d exponentiation. Tous ces nouveaux algorithmes utilisent l approche implicite. 12.3.1 Hypothèses de nos constructions Notre méthodologie suppose qu une analyse simple des canaux cachés ne permet pas la distinction entre les différents blocs atomiques (voir Définition 23). En conséquence, les blocs atomiques sont dépendants du composant sur lequel le code est exécuté. Avec la plupart des cartes à puces actuelles équipées d un coprocesseur arithmétique, notre expérience nous a montré que les opérations suivantes étaient équivalentes en canal caché : 1. La multiplication (modulaire) entre deux grands registres : R i R j, pour tout i, j. Ceci inclut le cas i = j, en supposant que la mise au carré peut être remplacée par un appel à la multiplication (au lieu d être effectuée par un appel à la routine parfois optimisée de mise au carré) ; 2. L addition/soustraction (modulaire) de deux grands registres : R i ± R j, pour tout i, j ; 3. Les opérations du CPU, c est-à-dire toutes les opérations arithmétiques ou logiques à partir des registres du CPU. Si le composant ne remplit pas ces hypothèses, la résistance aux attaques par canaux cachés peut toujours être obtenue par une mise en œuvre software. Par exemple, si l évaluation hardware de b A se comporte en canal caché différemment si le bit vaut 0 ou 1, une astuce simple consiste à évaluer b A comme (b + t)a ta pour un aléa t ; de façon similaire, l addition A ± b peut être calculée comme A ± (b + t) t ; 4. Le test d égalité entre deux registres CPU : A =? B. À nouveau, si le composant ne remplit pas cette condition, une émulation software pourrait par exemple être de lire le flag zéro résultant de A B ou de procéder à une opération de ou logique entre tous les bits de A B ; 5. Le chargement/la sauvegarde des valeurs des différents registres. Les algorithmes présentés dans cette section et dans la Section 12.4 supposent que les mises en œuvre hardware de ces instructions ou leur émulation software suivent ces hypothèses. 12.3.2 Algorithmes génériques d exponentiation à fenêtre glissante Comme cela a été vu précédemment, l algorithme binaire d exponentiation permet, à l aide de deux registres, de calculer le résultat d une exponentiation y = x d, en 1.5m multiplications en moyenne. Quand des registres additionnels sont disponibles, ce nombre moyen peut être réduit, en précalculant et en stockant les valeurs x 2j+1 pour j {1,..., 2 ω 1 1}, puis en effectuant une lecture de gauche à droite des bits de l exposant à l aide d une fenêtre glissante de L algorithme binaire d exponentiation correspond au cas ω = 1. Ceci est d autant plus vérifié lorsque les contre-mesures hardware sont activées. 133

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA ω bits [MOV97, Algorithme 14.85]. C est une généralisation très efficace de l algorithme binaire d exponentiation [HL94, LH94]. Entrée : x, d = (d m 1,..., d 0) 2, et un entier ω > 1 Sortie : y = x d Précalcul : R j+1 x 2j+1 pour 1 j 2 ω 1 1 R 0 1 ; R 1 x ; i m 1 pour j = 1 à ω 1, d j 0 s 1 tant que (i 0) { k ( s) (k + 1) b 0 ; t 1 ; l ω ; u 0 pour j = 1 à ω { b b d i ω+j ; l l b u u + t d i ω+j ; t b (2t) + b } l l d i ; u [(u + 1) div 2] d i s (k = l) R 0 R 0 R u s i i k s d i } retourne R 0 Fig. 12.3 Version atomique de l algorithme à fenêtre glissante de ω bits. 12.3.3 Algorithmes simplifiés Une plus grande valeur de ω dans l algorithme à fenêtre glissante de ω bits accélère les calculs, mais en même temps augmente la mémoire nécessaire. Un choix particulièrement intéressant pour des environnements contraints est le cas ω = 2. L algorithme résultant est habituellement appelé l algorithme (M, M 3 ). L algorithme générique de la Figure 12.3 peut alors être simplifié, jusqu à aboutir à l algorithme présenté à la Figure 12.4-a. Entrée : x, d = (d m 1,..., d 0) 2 Sortie : y = x d R 0 1 ; R 1 x ; R 2 x 3 d 1 0 ; i m 1 ; s 1 tant que (i 0) { k ( s) (k + 1) s s d i (d i 1 (k mod 2)) R 0 R 0 R k s i i k s d i } retourne R 0 (a) Version atomique de l algorithme (M, M 3 ). Entrée : x, d = (d m 1,..., d 0) 2 Sortie : y = x d R 0 1 ; R 1 x k 1 ; i 0 tant que (i m 1) { } k k d i R k R k R 1 i i + k retourne R 0 (b) Version atomique droite-gauche de l algorithme binaire d exponentiation. Fig. 12.4 Algorithmes pour environnements contraints. Dans certains cas, il est plus facile de parcourir les bits du bit le moins significatif au bit le plus significatif. Il est alors fait usage de l algorithme binaire d exponentiation droite-gauche. De 134

12.4. Atomicité et courbes elliptiques façon analogue à la Figure 12.2, nous pouvons modifier cet algorithme, pour prévenir les attaques simples par canal caché. Après simplification, nous obtenons alors l algorithme atomique présenté en Figure 12.4-b. Il y a bien sûr encore de nombreuses variantes qui pourraient être plus efficaces sur telle ou telle architecture : appliquer notre technique permet ainsi à chacun de trouver le meilleur bloc atomique sur un composant donné. Les algorithmes protégés ainsi obtenus ont de façon notable la même complexité (en temps d exécution et en mémoire consommée) que leur version non protégée. 12.4 Atomicité et courbes elliptiques Notre méthodologie s applique virtuellement à tout algorithme. Nous montrons ainsi dans cette section comment l adapter au contexte de la cryptographie sur courbes elliptiques [BSS99]. Deux catégories de courbes elliptiques sont communément utilisées [P1363] : les courbes elliptiques sur un corps premier et les courbes elliptiques non-supersingulières sur un corps binaire. L opération de base sur les courbes elliptiques consiste à calculer le multiple d un point, c està-dire, étant donné un point P 1 sur une courbe elliptique, à calculer P d = d P 1. Pour simplifier notre présentation, nous supposons que ceci est fait grâce à la version additive de l algorithme binaire d exponentiation (appelée en anglais l algorithme double-and-add). Cette méthode est discutée dans [Gor98]. D autres méthodes de multiplication scalaire d un point, plus complexes mais plus rapides, pourraient également être rendues sûres contre les attaques simples grâce à l atomicité. 12.4.1 Courbes elliptiques définies sur un corps premier Considérons la courbe elliptique E définie sur un corps premier F p (avec p > 3), donnée par l équation de Weierstraß E /Fp : y 2 = x 3 + ax + b. Pour éviter les inversions dans le corps, les coordonnées Jacobiennes sont en général utilisées [P1363] pour représenter les points sur E. Avec les coordonnées Jacobiennes, le doublement d un P 1 est 2(X 1, Y 1, Z 1 ) = (X 3, Y 3, Z 3 ), où X 3 = M 2 2S, Y 3 = M(S X 3 ) T, Z 3 = 2Y 1 Z 1 avec M = 3X1 2 + az4 1, S = 4X 1Y1 2 et T = 8Y 4 1. La somme de deux points distincts P 1 = (X 1, Y 1, Z 1 ) et P 2 = (X 2, Y 2, Z 2 ) est (X 3, Y 3, Z 3 ), où X 3 = W 3 2U 1 W 2 + R 2, Y 3 = S 1 W 3 + R(U 1 W 2 X 3 ), Z 3 = Z 1 Z 2 W avec U 1 = X 1 Z 2 2, U 2 = X 2 Z 2 1, S 1 = Y 1 Z 3 2, S 2 = Y 2 Z 3 1, W = U 1 U 2 et R = S 1 S 2. Nous utiliserons l approche explicite de l atomicité. Nous référons le lecteur à l annexe de notre publication [CCJ04] ou à la thèse de Mathieu Ciet [Cie03] pour les formules détaillées conduisant à l expression du bloc atomique γ k comme la ligne correspondante de la matrice 135

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA suivante : (u k,l )0 k 25 0 l 9 4 1 1 5 4 4 3 4 4 5 5 3 3 1 1 1 3 1 1 3 5 5 5 1 1 3 3 1 1 3 5 0 5 4 4 5 3 5 2 2 3 3 5 1 1 3 3 1 1 3 2 2 2 2 2 2 4 1 1 3 5 1 2 1 1 5 5 1 1 5 1 4 4 1 1 5 4 1 1 5 2 2 2 2 2 2 3 5 1 5 4 4 5 2 2 4 2 4 4 5 4 9 9 5 1 5 5 5 1 5 1 1 4 5 1 5 5 5 1 5 4 4 9 5 1 5 5 5 1 5 = 2 2 4 5 1 5 5 5 1 5. 4 3 3 5 1 5 5 5 1 5 5 4 7 2 2 5 5 5 1 5 4 3 4 2 2 5 6 6 5 6 4 4 8 6 5 6 4 4 2 4 3 3 9 6 5 6 6 6 5 6 3 3 5 6 5 6 6 6 5 6 6 5 5 6 3 6 3 6 3 6 1 1 6 1 1 4 4 1 1 4 5 5 6 6 1 2 2 6 2 6 1 4 4 1 1 5 6 1 1 6 2 2 5 1 1 6 3 6 1 6 4 4 6 2 2 4 6 6 1 6 L algorithme résultant est alors donné dans la figure suivante. Entrée : P 1 = (X 1, Y 1, Z 1), d = (1, d m 2,..., d 0) 2, et la matrice (u k,l) définie comme ci-dessus Sortie : P d = dp 1 R 0 a ; R 1 X 1 ; R 2 Y 1 ; R 3 Z 1 ; R 7 X 1 ; R 8 Y 1 ; R 9 Z 1 i m 2 ; s 1 tant que (i 0) { k ( s) (k + 1) s d i (k div 25) + ( d i) (k div 9) R u k,0 R u k,1 R u k,2 ; R u k,3 R u k,4 + R u k,5 R u k,6 R u k,6 ; R u k,7 R u k,8 + R u k,9 i i s } retourne (R 1, R 2, R 3) Fig. 12.5 Version atomique de l algorithme double-and-add sur les courbes elliptiques sur F p. Encore une fois, il est important de noter qu en terme de multiplications, notre algorithme est aussi efficace que la version correspondante non protégée (voir [P1363]). 12.4.2 Courbes elliptiques définies sur un corps binaire L atomicité est une notion relative. Dans les exemples précédents, nous avons considéré l addition et la multiplication comme les opérations de base. Nous pourrions aussi imaginer qu une division est une opération de base, par exemple si elle est calculable par une routine Notons que plus les opérations de base sont différentes (du point de vue des canaux cachés), plus il est difficile d exhiber un bloc atomique commun Γ. 136

12.4. Atomicité et courbes elliptiques hardware. Nous donnons ci-dessous un tel exemple. Pour des raisons d efficacité, il est recommandé d utiliser les coordonnées affines pour additionner les points d une courbe elliptique définie sur un corps binaire [WMPW98]. Une courbe elliptique (non-supersingulière) E définie sur le corps binaire F 2 q est donnée par l équation de Weierstraß E /F2 q : y 2 + xy = x 3 + ax 2 + b. En coordonnées affines (voir [P1363]), le doublement d un point P 1 = (x 1, y 1 ) est 2(x 1, y 1 ) = (x 3, y 3 ), où x 3 = a + λ 2 + λ, y 3 = (x 1 + x 3 )λ + x 3 + y 1 avec λ = x 1 + (y 1 /x 1 ). La somme de deux points distincts P 1 = (x 1, y 1 ) et P 2 = (x 2, y 2 ) est (x 3, y 3 ), où x 3 = a + λ 2 + λ + x 1 + x 2, y 3 = (x 1 + x 3 )λ + x 3 + y 1 avec λ = (y 1 + y 2 )/(x 1 + x 2 ). Nous voyons alors clairement que le doublement et l addition de points peuvent être codés de façon similaire. Ainsi, nous choisissons, dans le bloc commun Γ, de simuler en totalité un doublement ou une addition sur une courbe elliptique (voir Figure 12.6-a). Seules, deux additions supplémentaires (dans le corps) sont nécessaires pour le doublement en comparaison avec la version non protégée de [P1363]. Grâce à cela, un algorithme efficace protégé de double-and-add peut être déduit (voir Figure 12.6-b). Entrée : (T 1, T 2) = P 1, (T 3, T 4) = P 2 Sortie : P 1 + P 2 ou 2P 1 Entrée : P 1 = (x 1, y 1), d = (1, d m 2,..., d 0) 2 Sortie : P d = dp 1 Addition : P 1 P 2 + P 1 Doublement : P 1 2P 1 T 1 T 1 + T 3 (= x 1 + x 2) T 6 T 1 + T 3 (factice) T 2 T 2 + T 4 (= y 1 + y 2) T 6 T 3 + T 6 (= x 1 ) T 5 T 2/T 1 (= λ) T 5 T 2/T 1 (= y 1/x 1) T 1 T 1 + T 5 T 5 T 1 + T 5 (= λ) 2 T 6 T 5 (= λ 2 2 ) T 1 T 5 (= λ 2 ) T 6 T 6 + a (= λ 2 + a) T 1 T 1 + a (= λ 2 + a) T 1 T 1 + T 6 (= x 3) T 1 T 1 + T 5 (= x 3) T 2 T 1 + T 4 (= x 3 + y 2) T 2 T 1 + T 2 (= x 3 + y 1) T 6 T 1 + T 3 (= x 2 + x 3) T 6 T 1 + T 6 (= x 1 + x 3) T 5 T 5 T 6 T 5 T 5 T 6 T 2 T 2 + T 5 (= y 3) T 2 T 2 + T 5 (= y 3) retourne (T 1, T 2) R 1 x 1 ; R 2 y 1 ; R 3 x 1 ; R 4 y 1 i m 2 ; s 1 tant que (i 0) { k ( s) (k + 1) ; s k ( d i) R 6 5k R 1 + R 3 ; R 6 4k R 3 k + R 6 2k R 5 R 2/R 1 R 5 4k R 1 + R 5 R 1+5k R 5 2 R 1+5k R 1+5k + a R 1 R 1 + R 5+k R 2 R 1 + R 2+2k ; R 6 R 1 + R 6 3k R 5 R 5 R 6 ; R 2 R 2 + R 5 i i s } retourne (R 1, R 2) (a) Addition et doublement (b) Version atomique du double-and-add sur courbes elliptiques sur F 2 q. pour courbes elliptiques sur F 2 q. Fig. 12.6 Algorithmes sur courbes elliptiques sur F 2 q. Nous avons T 6 = x 1 car nous sommes sur un corps binaire, et donc 2 T 3 = 0. Pour sauver un registre, nous utilisons la commutativité en calculant P 1 P 2 + P 1 au lieu de P 1 P 1 + P 2 lors de l addition sur courbe elliptique. 137

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA 12.5 Version atomique de l exponentiation MIST Pour finir ce chapitre, nous donnons une version atomique de l algorithme MIST, proposé par Colin Walter [Wal02]. MIST est un algorithme d exponentiation à exécution aléatoire pour prévenir des attaques différentielles (voir également le Chapitre 13 consacré à ce sujet). Cependant, tel qu il est présenté dans [Wal02], l algorithme MIST pourrait être attaqué par analyse simple de canal caché. Nous donnons dans cette section une version atomique de MIST prévenant les attaques simples par canaux cachés comme une illustration supplémentaire de la généralité de notre méthodologie pour prévenir ces attaques. Pour cela, nous utilisons les matrices suivantes : (F δ,r )2 δ 5 = 0 r 4 0 1 3 5 8 11 14 18 22 26 et (G k,l )0 k 29 0 l 4 = 0 B @ 1 1 1 1 1 3 3 0 1 1 1 1 1 1 2 0 1 2 1 1 1 1 2 0 1 3 3 0 1 2 1 1 1 1 2 0 2 3 3 0 1 2 1 1 1 1 2 0 1 2 1 0 1 2 1 1 1 1 2 0 1 3 3 0 1 2 1 0 1 2 1 1 1 1 2 0 2 3 3 0 1 2 1 0 1 2 1 1 1 1 2 0 1 2 1 0 1 3 3 0 1 2 1 1 1 1 2 0 2 2 2 0 2 3 3 0 1 2 1 1 Pour éviter une réécriture des registres, la chaîne de division correspondant à une paire diviseur/reste [2, 1] a été remplacée par {(133), (111)}. La version originale de MIST utilise au contraire la sous-chaîne {(112), (133)} et une copie de registres (voir [Wal02, Table 3.1]). À nouveau, nous supposons dans cette section que toutes les opérations utilisées sont équivalentes en canal caché (et si ce n est pas le cas, le sont rendues par une émulation software). 1 C A. 138

12.6. Conclusion L algorithme MIST peut alors se réécrire dans une forme atomique comme suit. Entrée : x, d = (d m 1,..., d 0) 2, et les matrices (F δ,r ) et (G k,l ) Sortie : y = x d R 1 x ; R 3 1 ; i 0 ; s 1 tant que (d > 0) { ρ R {2, 3, 5} δ s δ + s ρ r d mod δ k s (k + 1) + s F δ,r (u 1, u 2, u 3, s) (G k,0, G k,1, G k,2, G k,3 ) R u3 R u1 R u2 d s d + s (d div δ) } retourne R 3 Fig. 12.7 Exponentiation MIST en version atomique. 12.6 Conclusion Ce chapitre a introduit la notion d atomicité. Grâce à cela, nous avons proposé de nouvelles solutions permettant de résister aux attaques simples à canaux cachés. Les solutions proposées sont génériques et s appliquent à une large variété de système cryptographiques. En particulier, l atomicité s applique aux systèmes basés sur les exponentiations (ou sur les multiplications scalaires pour les groupes additifs) pour lesquels elle conduit à des algorithmes protégés qui ont à peu près la même efficacité que leur version naïve (c est-à-dire non protégée). Finalement, il peut être noté que notre méthodologie se combine très bien avec les contre-mesures contre les autres types d attaques par canaux cachés, et notamment les attaques différentielles. Depuis sa parution, notre technique a été reprise dans de nombreuses publications, aussi bien pour l adapter à d autres algorithmes que pour l appliquer dans le monde même de la conception sûre des circuits ou encore pour la comparer à de nouvelles approches [Kum04, KS04, BP05, OTV05a, OTV05b, DIM05]. 139

Chapitre 12. L atomicité : une solution générique et peu coûteuse contre la SPA 140

Chapitre 13 Exponentiation intrinsèquement protégée contre la DPA Sommaire 13.1 Exponentiation intrinsèquement aléatoire................. 143 13.1.1 Algorithmes classiques d exponentiation................... 143 13.1.2 Principe général................................. 143 13.2 Algorithmes basiques............................. 144 13.2.1 Premier algorithme............................... 144 13.2.2 Second algorithme............................... 146 13.3 Algorithmes avancés.............................. 147 13.3.1 Atomicité face aux attaques simples à canaux cachés............ 147 13.3.2 Réversibilité................................... 148 13.3.3 Optimisations supplémentaires........................ 150 13.3.4 Temps moyen.................................. 151 13.4 Conclusion.................................... 151 Depuis l invention de la clé publique par Whitfield Diffie et Martin Hellman [DH76], de nombreux cryptosystèmes ont été proposés. Parmi ceux qui ont résisté à la cryptanalyse, le cryptosystème RSA est sans doute celui qui est le plus largement utilisé. Sa sécurité repose sur la difficulté du problème de la factorisation de grands entiers. Malgré de nombreuses années de recherche, ce problème est toujours considéré comme difficile, faisant du RSA un algorithme tout à fait adapté aux applications sensibles comme le chiffrement de données ou la signature numérique [PKCS1]. Plutôt que de chercher à casser le cryptosystème RSA au niveau mathématique, certains cryptographes ont alors orienté leurs recherches vers les mises en œuvre concrètes du RSA. Ceci a alors donné naissance aux attaques par fautes [BDL01] et aux attaques par canaux cachés [Koc96, KJJ99]. Ces attaques ont alors profondément modifié la façon dont les algorithmes cryptographiques devaient être codés. Une règle générale pour prévenir des attaques dues à une mauvaise mise en œuvre logicielle consiste à rendre les valeurs internes de l algorithme le plus aléatoire possible. Dans le cas du cryptosystème RSA, il y a ainsi deux façons de rendre aléatoire le calcul de y = x d mod n. Il est possible : 1. de rendre aléatoires les entrées avant l algorithme d exponentiation [Koc96] ; par exemple, en utilisant 141

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA (a) ˆx x + r 1 n pour un aléa r 1 de k bits (b) ˆd d + r 2 φ(n) pour un aléa r 2 de k bits et en évaluant alors y comme y = ŷ mod n avec ŷ = ˆx ˆd mod 2 k n ; 2. de rendre aléatoire l algorithme d exponentiation lui-même (à la façon de [Wal02] ou de [MDS99], par exemple). La première approche, discutée notamment par Paul Kocher (voir [Koc96, Section 10]), présente l avantage d être indépendante de la méthode d exponentiation. Malheureusement, un tel masquage de l exposant d est limité aux mises en œuvre du RSA basées sur le théorème des restes chinois (CRT) [QC82], comme l ordre du groupe φ(n) est habituellement inconnu lors d une exponentiation privée en mode standard (c est-à-dire sans CRT). Le meilleur exemple de la seconde approche est sans doute l algorithme MIST, proposé par Colin Walter [Wal02] voir également la version atomique de MIST que nous avons proposée Section 12.5. MIST a été conçu pour générer aléatoirement une chaîne de division correspondant à l exposant d, de façon à calculer x d mod n de façon aléatoire. Pour minimiser le nombre de registres utilisés, cette chaîne est calculée dynamiquement via une adaptation d un autre algorithme d exponentiation basé sur les chaînes de division [Wal98]. Un autre exemple est la version améliorée de l algorithme à fenêtre glissante proposée dans [IYTT02]. La seconde approche permet de rendre aléatoire l algorithme d exponentiation sans la connaissance de φ(n), mais nécessite, pour nos exemples, un algorithme de division sûr contre les attaques à canaux cachés ou un algorithme plus complexe. Ce chapitre introduit une nouvelle méthode pour rendre aléatoire une exponentiation, dans le but de prévenir des attaques différentielles (en anglais, Differential Power Analysis, DPA) [KJJ99], combinant les avantages des deux approches. Comme dans la première approche, notre méthode ne requiert pas une méthode d exponentiation particulière. Comme dans la seconde approche, c est l algorithme lui-même qui est la source de l exécution aléatoire (en particulier, notre méthode ne nécessite pas la connaissance préalable de l ordre du groupe φ(n) ni celle de l exposant publique e dans les exponentiations privées RSA). Nous introduisons ainsi le concept d algorithme d exponentiation intrinsèquement aléatoire (en anglais, self-randomized exponentiation), signifiant par là que l exposant d est lui-même utilisé comme une source d entropie. Notre méthode nécessite seulement que les bits de l exposant privé soient utilisés de la valeur la plus significative à la valeur la moins significative (c est-à-dire de la gauche vers la droite) et s applique ainsi à la plupart des algorithmes d exponentiation [MOV97, Chapitre 14]. Notre méthode peut être combinée avec la plupart des autres contre-mesures, telle que le masquage de l exposant préalablement à l exponentiation. Finalement, notre méthode n est pas restreinte aux exponentiations de type RSA et s applique tout autant aux autres groupes tels que le groupe des points d une courbe elliptique sur un corps premier [Kob87, Mil85]. Ce chapitre a fait l objet d une publication à la conférence Ct-rsa 04 [Che04]. Par méthode, nous entendons ici l algorithme mathématique tel que l algorithme binaire ou l algorithme de la fenêtre glissante. Lorsque l exposant publique e est connu et n est pas trop grand, il est également possible de rendre aléatoire l exposant privé par la formule ˆd d + r(ed 1). Malheureusement, dans la plupart des cas pratiques, e est inconnu (c est-à-dire n est pas mis à la disposition de la routine d exponentiation, car il n est pas nécessaire au calcul). 142

13.1. Exponentiation intrinsèquement aléatoire 13.1 Exponentiation intrinsèquement aléatoire 13.1.1 Algorithmes classiques d exponentiation Il existe principalement deux familles d exponentiations pour calculer la valeur y = x d mod n, suivant la direction dans laquelle les bits de l exposant d sont parcourus. Ce chapitre ne concerne que les algorithmes gauche-droite (c est-à-dire parcourant d du bit le plus significatif au bit le moins significatif), incluant l algorithme binaire d exponentiation et ses variantes sur ω bits, l algorithme de fenêtre glissante (voir [MOV97, Chapitre 14]). Les algorithmes gauche-droite nécessitent moins de mémoire que les algorithmes droite-gauche, et permettent d utiliser des petites puissances pré-calculées x i mod n pour accélérer les calculs. 13.1.2 Principe général Soit d = (d l,..., d 0 ) 2 = l i=0 d i 2 i, avec d i {0, 1}, la représentation binaire de l exposant d. Définissons d k j = (d k,..., d j ) 2 = d i 2 i j. k i j Les algorithmes gauche-droite ont la propriété commune d utiliser un registre (appelé souvent accumulateur) tout au long du calcul pour stocker la valeur x d l i mod n pour des valeurs décroissantes de i, jusqu à ce que, finalement, l accumulateur contienne y = x d l 0 = x d mod n. Par exemple, l algorithme binaire d exponentiation (voir Figure 12.1) utilise la relation de récurrence x d l i = (x d l i+1 ) 2 x d i avec x d l l x d l i. = x d l. Ainsi, dans la Figure 12.1, l accumulateur R 0 contient à l étape i la valeur D après des idées antérieures [CJRR99, CJ01], nous utilisons un découpage additif de l exposant, de la forme x d = x d a x a pour un aléa a, comme un moyen de masquer l exposant d. Une application simple de cette technique serait inefficace, car le temps d exécution serait approximativement doublé, pour calculer x d a et x a. L idée principale que nous proposons dans ce chapitre consiste à prendre (une partie de) d comme source d entropie. Ainsi, l aléa a dans le découpage ci-dessus est choisi égal à d l i, pour un indice aléatoire i. Comme la valeur x d i est directement disponible dans l accumulateur, le surcoût de notre technique n est que d une multiplication par tel découpage. Il y a différentes façons d appliquer notre idée, les sections suivantes vont les décrire. 143

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA 13.2 Algorithmes basiques 13.2.1 Premier algorithme Notre premier algorithme repose sur la simple observation que, pour tout l i j 0, nous avons x d = x d l 0 = x d l 0 d l i1 x d l i 1 = x (d l 0 d l i1 ) d l i2 x d l i 1 x d l i 2 =... = x (((d l 0 d l i1 ) d l i2 ) d l i3 ) d l if x d l i 1 x d l i 2 x d l i 2 x d l i f. Si les i j sont choisis aléatoirement, le processus d exponentiation deviendra probabiliste, dans le sens que la façon d arriver au résultat (ce que nous appelons parfois le chemin d exponentiation) sera variable. Pour cela, nous définissons un Booléen ρ pour déterminer si l indice courant de la boucle i appartient à l ensemble {i 1,..., i f }. Si c est le cas, alors l exposant d est remplacé par d d l ij. Ceci est illustré dans la figure suivante, dans laquelle la partie grisée correspond à la valeur modifiée, et donc rendue variable. d l 0 d l ij i j d ij 1 0 d d l ij dl ij 000000000000000000 111111111111111111 0000 1111 d l ij 0000 1111 0000 1111 Fig. 13.1 Masquage de l exposant d (I). Tout comme dans l algorithme classique binaire d exponentiation gauche-droite, un accumulateur R 0 est utilisé pour contenir la valeur x d l i. Nous utilisons également un second registre R 1 pour garder la valeur correspondant à i j i xd l i j. Pour s assurer du fonctionnement du processus, les étapes de découpage d d d l ij ne doivent pas modifier les (l i j + 1) bits les plus significatifs de d (c est-à-dire d l ij ). Cette dernière condition (appelée dans la suite condition de consistance) est garantie en vérifiant que d ij 1 0 d l ij (voir Figure 13.1). Appliquée à l algorithme binaire d exponentiation gauche-droite, nous obtenons alors l algorithme décrit à la Figure 13.2. Remarque 2. À l étape i = i j, la phase de rafraîchissement d d d l i ne modifie pas les (l i + 1) bits les plus significatifs de d, elle pourrait donc tout autant être remplacée par d i 1 0 d i 1 0 d l i. Analyse. Nous remarquons que l étape de découpage additif (c est-à-dire d d d l ij ) modifie les (l i j + 1) bits les moins significatifs de d. Avec la condition de consistance (c est-à-dire d ij 1 0 d l ij ), ceci implique que seulement la moitié basse environ de l exposant d est rendue aléatoire. Pour le cryptosystème RSA avec un exposant public petit, ce n est pas un problème, Graphiquement, il faut que la partie grisée n empiète pas au delà de l indice i j. 144

13.2. Algorithmes basiques Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d R 0 1; R 1 1; R 2 x; i l tant que (i 0) { R 0 R 0 R 0 si (d i = 1) alors R 0 R 0 R 2 ρ R {0, 1} si ((ρ = 1) (d i 1 0 d l i )) { d d d l i R 1 R 1 R 0 } i i 1 } R 0 R 0 R 1 retourne R 0 Fig. 13.2 Algorithme intrinsèquement aléatoire (I). car la moitié la plus significative de l exposant privé d est connue d après la clé publique [Bon99, Section 4.5]. Une variante simple. La méthode précédente peut être généralisée en : d d g d l ij pour un aléa g tel que d ij 1 0 g d l ij. Le second registre (R 1 dans la Figure 13.2) peut alors être calculé comme R 1 R 1 R g 0 mod N. Les valeurs les plus intéressantes sont de type g = 2 τ, comme l opération g d l ij est alors effectuée par un simple décalage et le calcul de R g 0 mod N ne nécessite que τ mises au carré. Encore une fois, avec l exemple de l algorithme binaire d exponentiation gauche-droite, nous obtenons : Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d R 0 1; R 1 1; R 2 x; i l tant que (i 0) { R 0 R 0 R 0 si (d i = 1) alors R 0 R 0 R 2 ρ R {0, 1}; τ R {0,..., T } si ((ρ = 1) (d i 1 τ d l i )) { d i 1 τ d i 1 τ d l i R 3 R 0 tant que (τ > 0) { R 3 R 3 2 ; τ τ 1 } R 1 R 1 R 3 } i i 1 } R 0 R 0 R 1 retourne R 0 Fig. 13.3 Algorithme intrinsèquement aléatoire (I ). 145

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA Notons qu à l étape i = i j, la condition de consistance d i 1 0 2 τ d l i est remplacée par le test plus efficace d i 1 τ d l i et que la phase de découpage d d 2 τ d l i est remplacée par d l τ d l τ d l i d i 1 τ d i 1 τ d l i, comme mentionné dans la Remarque 2. La borne T doit être choisie pour offrir un bon compromis entre l entropie apportée sur les bits de d et la perte d efficacité de l algorithme due aux τ mises au carré, pour un τ choisi aléatoirement dans {0,..., T }. 13.2.2 Second algorithme Notre premier algorithme (Figure 13.2) ne rend aléatoire que la partie inférieure des bits de l exposant d par d d d l ij ; la condition de consistance impose en effet un masque de demie-taille. Dans le but de masquer tout l exposant d, nous utilisons l astuce suivante d l ij c j = (d l ij c j d l ij ) + d l ij pour tout i j c j 0. En fait, nous appliquons successivement la méthode du premier algorithme au sous-exposant d l ij c j. De plus, pour éviter l utilisation d un registre supplémentaire, nous n effectuons qu un découpage à la fois. En d autres termes, si nous rafraîchissons l exposant d comme décrit dans la figure suivante d l i j i j c j 0 d l ij d ij 1 i j c dl ij cj 000000000000000000 111111111111111111 d d l ij 0000 1111 d l ij 0000 1111 0000 1111 d l ij c j d l ij Fig. 13.4 Masquage de l exposant d (II). une nouvelle étape de découpage de l exposant d sera impossible tant que le calcul x d l i j c j mod n ne sera pas achevé. Un sémaphore σ est pour cela utilisé, pour savoir si un découpage est permis ou non. Sur la Figure 13.4, nous observons que les (l i j +1) bits les plus significatifs de d (c est-à-dire d l ij ) restent inchangés après le découpage si { dij 1 i j c j d l ij, (i j 1) (i j c j ) l i j c j l i j + 1. Nous définissons c j = l i j + 1 + ν j pour un entier positif ν j. Avec la condition i j c j 0, ceci implique que 2i j l + 1 + ν j. Remarque 3. Si ν j est égal à 0, la condition de consistance (c est-à-dire d ij 1 i j c j d l ij ) est satisfaite la moitié du temps, en supposant que d ij 1 i j c j et d l ij se comportent comme Notre premier algorithme correspond au cas c j = i j, j. 146

13.3. Algorithmes avancés des aléas de (l i j + 1) bits. Autrement dit, si ν j = 0, la moitié du temps, la condition de consistance n empêche pas une éventuelle étape de découpage. Une valeur plus grande de ν j accroît la probabilité de remplir la condition de consistance (et donc la probabilité d effectuer un découpage). D un autre côté, une telle valeur réduit également le nombre d indices i satisfaisant la condition 2i j l+1+ν j, et diminue donc l entropie du chemin d exponentiation de l algorithme. La Figure 13.5 présente l algorithme ainsi obtenu pour l exemple de l algorithme binaire d exponentiation gauche-droite. Pour tout j, la valeur ν j est prise égale à 0 (et ainsi c j = l i j +1). Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d R 0 1; R 1 1; R 2 x i l; c 1; σ 1 tant que (i 0) { R 0 R 0 R 0 si (d i = 1) alors R 0 R 0 R 2 } si ((2i l + 1) (σ = 1)) alors c l i + 1 [ ] sinon σ 0 ρ R {0, 1} ɛ ρ (d i 1 i c d l i ) σ si (ɛ = 1) { R 1 R 0; σ 0 d i 1 i c d i 1 i c d l i } si (c = 0) { R 0 R 0 R 1; σ 1 } c c 1; i i 1 retourne R 0 Fig. 13.5 Algorithme intrinsèquement aléatoire (II). 13.3 Algorithmes avancés 13.3.1 Atomicité face aux attaques simples à canaux cachés Dans les versions présentées dans la section précédente, nos algorithmes utilisent de nombreux tests dépendant de bits secrets de l exposant. Aussi, malgré leur protection contre les attaques différentielles, nos algorithmes basiques sont potentiellement vulnérables à des attaques à canaux cachés simples (SPA) [KJJ99]. Cette partie est dédiée à la protection contre cet autre type d attaque. Nous utilisons la méthode des blocs atomiques, telle que décrite dans le Chapitre 12, pour supprimer ces tests, et ceci pour un coût négligeable. Nous référons le lecteur à ce chapitre pour plus d explications sur l atomicité, et donnons Figure 13.6, sans plus de détails, une version atomique de notre premier algorithme. Comme nous pouvons le voir, cette version ne fait plus aucun test sur les bits de l exposant, et est donc protégée contre les attaques à canaux cachés simples, sous l hypothèse d équivalence en canal caché des blocs atomiques. 147

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d R 0 1; R 1 1; R 2 x i l; k 0; ɛ 0 tant que (i 0) { R ɛ R 0 R ɛ+2k mod N k k (d i ɛ) d d + d l i d l i (1 + ɛ) i i ( k ɛ) ρ R {0, 1} ɛ ρ k ɛ (d i 1 0 d l i ) } R 0 R 0 R 1 retourne R 0 Fig. 13.6 Algorithme intrinsèquement aléatoire, version atomique (I). Une version atomique de notre second algorithme est donnée Figure 13.7. Elle repose toujours sur la même méthodologie, même si la lecture devient plus complexe. Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d R 0 1; R 1 1; R 2 x i l; k 0; ɛ 0; σ 1 ; c 1 tant que (i 0) { θ (c = 0) R 0 R 0 R θ+2k mod N k k (d i θ); i i ( k θ) σ (σ θ) (2i l + 1) c σ(c k) + (l i + 1) σ ρ R {0, 1} ɛ ρ k σ (d i 1 i c d l i ) σ σ ɛ d i 1 i c d i 1 i c + d l i d l i (1 + ɛ) R 1 R ɛ } retourne R 0 Fig. 13.7 Algorithme intrinsèquement aléatoire, version atomique (II). 13.3.2 Réversibilité Tout au long de cette section, nous supposons que nos algorithmes sont sans branchements conditionnels (par exemple, en utilisant la méthodologie de l atomicité). Nous étudions alors la résistance des algorithmes contre un attaquant imaginaire, très puissant, qui serait capable de distinguer les multiplications modulaires effectuées. Les Algorithmes I et II impliquent quatre types de multiplication : S : R 0 R 0 R 0 mod N M : R 0 R 0 R 2 mod N C 1 : R 1 R 0 R 1 mod N C 2 : R 0 R 0 R 1 mod N 148

13.3. Algorithmes avancés selon les registres utilisés dans la multiplication. En supposant qu un tel attaquant ne fasse aucune erreur, les Algorithmes I et II peuvent être inversés pour retrouver la valeur de l exposant d. Cet algorithme d inversion est donné à la Figure 13.8. Entrée : L = (L l,..., L 0) Sortie : d u 0; d 0; i l tant que (i 0) { par cas { (L i = S) : d 2d (L i = M) : d d + 1 (L i = C 1) : u u + d } } i i 1 retourne (u + d ) (a) Algorithme I. Entrée : L = (L l,..., L 0) Sortie : d d 0; j l; i l tant que (i 0) { par cas { (L i = S) : d 2d (L i = M) : d d + 1 (L i = C 2) : d d + D[ l+j+1 ] 2 } si (L i 1 = S) alors D[j] d ; j j 1 i i 1 } retourne d (b) Algorithme II. Fig. 13.8 Retrouver l exposant d dans des algorithmes intrinsèquement aléatoires, en distinguant les multiplications utilisées. Nous insistons sur le fait que l hypothèse de l existence d un tel attaquant est très forte (et même sans doute non réaliste sur les composants actuels), comme les diverses contre-mesures hardware ou software sont pensées pour empêcher de telles distinction entre S, M et C i. Cependant, même sous ce scénario d attaque très fort, l Algorithme II peut être légèrement modifié pour rendre l attaque impraticable. L Algorithme II (Figure 13.5) est construit en choisissant le paramètre ν j = 0 pour tout j. En fait, le paramètre ν j pourrait être tout nombre positif tel que 2i j l + 1 + ν j (voir la Remarque 3). Ainsi, la plus grande valeur possible pour ν j est 2i j l 1 et ainsi, comme ν j 0, le paramètre c j = l i j +1+ν j peut prendre toute valeur dans l ensemble {l i j +1,..., i j }. Nous généralisons donc notre algorithme en tirant c j dans l ensemble {l i j + 1,..., i j } ; c est-à-dire en remplaçant la ligne de la Figure 13.5 par si ((2i l + 1) (σ = 1)) alors c biais {l i + 1, i} En faisant ainsi, nous obtenons un troisième algorithme. La version atomique correspondante est donnée dans la Figure 13.9. Remarque 4. La distribution des valeurs c j ne doit pas être aléatoire, mais biaisé. En effet, il faut favoriser les valeurs basses de c j, car une fois que c j = i j, il ne peut plus y avoir de nouveau découpage jusqu à la fin de l algorithme. Favoriser les valeurs petites de c j permet ainsi de s assurer d un nombre minimal de découpage de l exposant, et donc d une entropie suffisante. Ce tirage ne doit pas être aléatoire mais biaisé, voir Remarque 4. 149

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA Entrée : x, d = (d l,..., d 0) 2 Sortie : y = x d mod N R 0 1; R 1 1; R 2 x; i l; k 0; ɛ = 0 σ 1 ; c 1 tant que (i 0) { θ (c = 0) R 0 R 0 R θ+2k mod N k k (d i θ); i i ( k θ) σ (σ θ) (2i l + 1) γ biais {l i + 1, i} c σ(c k) + γ σ ρ R {0, 1} ɛ ρ k σ (d i 1 i c d l i ) σ σ ɛ d i 1 i c d i 1 i c + d l i d l i (1 + ɛ) R 1 R ɛ } retourne R 0 Fig. 13.9 Algorithme intrinsèquement aléatoire, version atomique (III). En supposant qu un attaquant puisse distinguer les multiplications, inverser l Algorithme III revient alors à exécuter avec succès l algorithme suivant : Entrée : L = (L l,..., L 0) Sortie : d d 0; j l; j old l; i l tant que (i 0) { par cas { (L i = S) : d 2d (L i = M) : d d + 1 (L i = C 2) : for l+j+1 j 2 try j old, try d d + D[j try] ; j old j } si (L i 1 = S) alors D[j] d ; j j 1 i i 1 } retourne d Fig. 13.10 Recherche exhaustive sur l Algorithme III. Comme l attaquant ne connaît pas les valeurs des aléas c j choisis dans l ensemble {l i j + 1, i j }, il doit essayer toutes ces valeurs. Une telle recherche exhaustive devient rapidement impraticable, rendant ainsi notre algorithme sûr même contre cet attaquant très puissant. 13.3.3 Optimisations supplémentaires La fréquence avec laquelle le Booléen ρ = 1 peut être vue comme un paramètre pour choisir le meilleur compromis entre la performance et la sécurité. Un autre moyen pour minimiser le coût des opérations supplémentaires serait de légèrement modifier le générateur d aléas qui permet de tirer ρ, de telle façon que, si le poids de Hamming de d a (a pouvant avoir plusieurs définitions, suivant l Algorithme I, II, ou III) est plus petit que 150

13.4. Conclusion le poids de Hamming de d, ρ a une plus grande probabilité de valoir 1. Grâce à cette technique, nos algorithmes intrinsèquement aléatoires tendraient à sélectionner le cas ayant le plus petit poids de Hamming, c est-à-dire la branche la plus rapide. Bien sûr, l algorithme ne doit pas trop fausser l aléa ρ, car sinon, l algorithme deviendrait déterministe, réversible et potentiellement susceptibles aux attaques différentielles. 13.3.4 Temps moyen Dans la table suivante, nous donnons la complexité des différents algorithmes, en terme de multiplications. Tab. 13.1 Nombre moyen de multiplications modulaires pour calculer une exponentiation de longueur 1024. S, M, C 1, C 2 Alg. binaire Nos algorithmes naïf avec masquage (I) (II) (III) Multiplications 1536 1536 + 96 1536 + 512 ρ 1536 + 10 1536 + 10 Le surcoût des Algorithmes II et III (10 multiplications) correspond en fait à une borne supérieure de log 2 log 2 d. C est une très petite quantité mais elle apporte une entropie suffisante : le nombre possible de façon d opérer les découpages pour un exposant donné est supérieur à ( 10 512) > 2 64. 13.4 Conclusion Ce chapitre a introduit le concept d exponentiation intrinsèquement aléatoire comme un moyen efficace de se prémunir des attaques différentielles. Trois algorithmes (et leur variante protégée également contre les attaques simples) ont été décrits. Notre méthodologie présente les avantages suivants : elle est flexible, au sens où elle n est pas limitée à une méthode d exponentiation particulière ; elle est ajustable : un paramètre de sécurité permet de définir le meilleur compromis entre la sécurité et les performances ; elle peut être combinée avec la plupart des autres contre-mesures ; elle est peu coûteuse en mémoire, car seul un registre supplémentaire est nécessaire ; elle est générique, c est-à-dire ne repose pas sur des propriétés particulières du groupe ; elle ne nécessite pas la connaissance préalable de l ordre du groupe dans lequel les exponentiations sont effectuées. De plus, la notion de réversibilité a été définie et une construction concrète résistante a été proposée. Par avec masquage, nous entendons l utilisation de ˆd comme expliqué dans l introduction, avec un aléa r 2 de 64 bits. 151

Chapitre 13. Exponentiation intrinsèquement protégée contre la DPA 152

Conclusion générale 153

Résumé et recherches futures Dans cette thèse, nous avons exposé nos recherches suivant deux axes, représentatifs des travaux effectués durant ces trois années au sein de Gemplus/Gemalto et de l École normale supérieure. Le premier axe de nos recherches a été la conception de schémas cryptographiques à clé publique avec preuves de sécurité. Nous avons ainsi rappelé le principe des réductions de sécurité, puis donné un état de l art des schémas de signature et de chiffrement. Ensuite, nous avons exposé de nouvelles constructions. Concernant les schémas de signature, nous avons proposé : une heuristique pour concevoir des schémas de signature à coupons, avec réduction fine dans le modèle de l oracle aléatoire (Chapitre 5) ; un schéma de signature à coupons basé sur le problème RSA, avec réduction fine dans le modèle de l oracle aléatoire (Section 5.2) ; un schéma de signature à coupons basé sur le problème CDH, avec réduction fine dans le modèle de l oracle aléatoire (Chapitre 6) ; un schéma de signature à coupons basé sur le problème FlexibleRSA, avec réduction fine dans le modèle standard (Chapitre 7). Concernant les schémas de chiffrement, nous avons décrit : un schéma de chiffrement basé sur un nouveau problème, appelé le problème de la classe Diffie-Hellman (Chapitre 9) ; un schéma de chiffrement basé sur l identité avec une preuve fine, continuant ainsi le travail de Jonathan Katz et Nan Wang (Chapitre 10) ; une fonction de padding universel optimale en bande passante, dans le modèle de la permutation aléatoire (Chapitre 11). Un second axe de recherches a été la protection des composants cryptographiques (et notamment des cartes à puces) contre les attaques physiques. Dans ce manuscrit, nous nous sommes concentrés sur les protections contre les attaques par canaux cachés. Nous avons ainsi exposé : l atomicité, une méthode très efficace pour se protéger des attaques simples par canaux cachés (Chapitre 12) ; le concept des exponentiations intrinsèquement aléatoires, comme une protection efficace contre les attaques différentielles par canaux cachés (Chapitre 13). Ces trois années de recherches nous ont permis d avoir une vue plus précise de la cryptographie à clé publique, du niveau le plus appliqué (la protection physique des composants cryptographiques) aux concepts mêmes de la cryptographie asymétrique (la définition de nouveaux schémas cryptographiques et la preuve de leur sécurité). Nous espérons que la suite de nos recherches nous permettra d avoir une vue semblable sur la cryptographie symétrique. 155

Résumé et recherches futures 156

Bibliographie [ACF+05] [BB04] [BCCC06] [BD06] Nuttapong Attrapadung, Benoît Chevallier-Mames, Jun Furukawa, Takeshi Gomi, Goichiro Hanaoka, Hideki Imai et Rui Zhang. Efficient identitybased encryption with tight security reduction. Cryptology eprint Archive, Report 2005/320, 2005. Dan Boneh et Xavier Boyen. Short signatures without random oracles. Dans Advances in Cryptology EUROCRYPT 2004, volume 3027 de Lecture Notes in Computer Science, pages 56 73. Springer-Verlag, 2004. Éric Brier, Benoît Chevallier-Mames, Mathieu Ciet et Christophe Clavier. Why one should secure its public elements. Dans Cryptographic Hardware and Embedded Systems CHES 2006, Lecture Notes in Computer Science. Springer- Verlag, 2006. À paraître. Tor E. Bjørstad et Alexander W. Dent. Building better signcryption schemes with tag-kems. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 491 507. Springer-Verlag, 2006. [BDL01] Dan Boneh, Richard A. DeMillo et Richard Lipton. On the importance of eliminating errors in cryptographic computations. Journal of Cryptology, 14(2):101 119, 2001. [BDL97] [BDPR98] [BF01] [BF03] [BNPS03] [Bon99] Dan Boneh, Richard A. DeMillo et Richard Lipton. On the importance of checking cryptographic protocols for faults (extended abstract). Dans Advances in Cryptology EUROCRYPT 97, volume 1233 de Lecture Notes in Computer Science, pages 37 51. Springer-Verlag, 1997. Mihir Bellare, Anand Desai, David Pointcheval et Phillip Rogaway. Relations among notions of security for public-key encryption schemes. Dans Advances in Cryptology CRYPTO 98, volume 1462 de Lecture Notes in Computer Science, pages 26 45. Springer-Verlag, 1998. Dan Boneh et Matthew K. Franklin. Identity-based encryption from the Weil pairing. Dans Advances in Cryptology CRYPTO 2001, volume 2139 de Lecture Notes in Computer Science, pages 213 229. Springer-Verlag, 2001. Dan Boneh et Matthew K. Franklin. Identity-based encryption from the Weil pairing. SIAM Journal on Computing, 32(3):586 615, 2003. Mihir Bellare, Chanathip Namprempre, David Pointcheval et Michael Semanko. The one-more-rsa-inversion problems and the security of Chaum s blind signature scheme. Journal of Cryptology, 16(3):185 215, 2003. Dan Boneh. Twenty years of attacks on the RSA cryptosystem. Notices of the AMS, 46(2):203 209, 1999. 157

Bibliographie [BP05] Manuel Barbosa et Dan Page. On the automatic construction of indistinguishable operations. Dans Cryptography and Coding IMA 2005, volume 3796 de Lecture Notes in Computer Science, pages 233 247. Springer-Verlag, 2005. [BP97] Niko Barić et Birgit Pfitzmann. Collision-free accumulators and fail-stop signature schemes without trees. Dans Advances in Cryptology EURO- CRYPT 97, volume 1233 de Lecture Notes in Computer Science, pages 480 494. Springer-Verlag, 1997. [BR93] Mihir Bellare et Phillip Rogaway. Random oracles are practical: a paradigm for designing efficient protocols. Dans ACM Conference on Computer and Communications Security ACM CCS 1993, pages 62 73. ACM Press, 1993. [BR94] [BR96] [BSS99] [CCJ04] Mihir Bellare et Phillip Rogaway. Optimal asymmetric encryption. Dans Advances in Cryptology EUROCRYPT 94, volume 839 de Lecture Notes in Computer Science, pages 92 111. Springer-Verlag, 1994. Mihir Bellare et Phillip Rogaway. The exact security of digital signatures - How to sign with RSA and Rabin. Dans Advances in Cryptology EURO- CRYPT 96, volume 1070 de Lecture Notes in Computer Science, pages 399 416. Springer-Verlag, 1996. Ian F. Blake, Gadiel Seroussi et Nigel P. Smart. Elliptic Curves in Cryptography. Cambridge University Press, 1999. Benoît Chevallier-Mames, Mathieu Ciet et Marc Joye. Low-cost solutions for preventing simple side-channel analysis: side-channel atomicity. IEEE Transactions on Computers, 53(6):760 768, 2004. [CD96] Ronald Cramer et Ivan Damgård. New generation of secure and practical RSA-based signatures. Dans Advances in Cryptology CRYPTO 96, volume 1109 de Lecture Notes in Computer Science, pages 173 185. Springer-Verlag, 1996. [CFGP06] [CG05] [CGH98] [Che04] [Che05a] 158 Olivier Chevassut, Pierre-Alain Fouque, Pierrick Gaudry et David Pointcheval. The twist-augmented technique for key exchange. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 410 426. Springer-Verlag, 2006. Dario Catalano et Rosario Gennaro. Cramer-Damgård signatures revisited: efficient flat-tree signatures based on factoring. Dans Public Key Cryptography PKC 2005, volume 3386 de Lecture Notes in Computer Science, pages 313 327. Springer-Verlag, 2005. Ran Canetti, Oded Goldreich et Shai Halevi. The random oracle methodology, revisited (preliminary version). Dans ACM Symposium on the Theory of Computing STOC 98, pages 209 218. ACM Press, 1998. Benoît Chevallier-Mames. Self-randomized exponentiation algorithms. Dans Topics in Cryptology CT-RSA 2004, volume 2964 de Lecture Notes in Computer Science, pages 236 249. Springer-Verlag, 2004. Benoît Chevallier-Mames. An efficient CDH-based signature scheme with a tight security reduction. Dans Advances in Cryptology CRYPTO 2005, volume 3621 de Lecture Notes in Computer Science, pages 511 526. Springer-Verlag, 2005. Version complète disponible sur le serveur Cryptology eprint Archive, rapport 2005/035.

[Che05b] Benoît Chevallier-Mames. New signature schemes with coupons and tight reduction. Dans Applied Cryptography and Network Security ACNS 2005, volume 3531 de Lecture Notes in Computer Science, pages 513 528. Springer- Verlag, 2005. [Cie03] [CJ01] [CJ02] [CJ07] [CJNP02] [CJP03] [CJRR99] [CL02] [CLP05] [CM04] [CN00] [CNPP04] Mathieu Ciet. Aspects of fast and secure arithmetics for elliptic curve cryptography. PhD thesis, Université catholique de Louvain, Louvain, 2003. Christophe Clavier et Marc Joye. Universal exponentiation algorithm. Dans Cryptographic Hardware and Embedded Systems CHES 2001, volume 2162 de Lecture Notes in Computer Science, pages 300 308. Springer-Verlag, 2001. Benoît Chevallier-Mames et Marc Joye. Procédé cryptographique protégé contre les attaques de type à canal caché. Demande de brevet français, FR 28 38 210, Avril 2002. Benoît Chevallier-Mames et Marc Joye. A practical and tightly secure signature scheme without hash function. Dans Topics in Cryptology CT-RSA 2007, Lecture Notes in Computer Science. Springer-Verlag, 2007. À paraître. Jean-Sébastien Coron, Marc Joye, David Naccache et Pascal Paillier. Universal padding schemes for RSA. Dans Advances in Cryptology CRYPTO 2002, volume 2442 de Lecture Notes in Computer Science, pages 226 241. Springer- Verlag, 2002. Benoît Chevallier-Mames, Marc Joye et Pascal Paillier. Faster double-size modular multiplication from Euclidean multipliers. Dans Cryptographic Hardware and Embedded Systems CHES 2003, volume 2779 de Lecture Notes in Computer Science, pages 214 227. Springer-Verlag, 2003. Suresh Chari, Charanjit S. Jutla, Josyula R. Rao et Pankaj Rohatgi. Towards sound approaches to counteract power-analysis attacks. Dans Advances in Cryptology CRYPTO 99, volume 1666 de Lecture Notes in Computer Science, pages 398 412. Springer-Verlag, 1999. Jan Camenisch et Anna Lysyanskaya. A signature scheme with efficient protocols. Dans Security in Communication Networks SCN 2002, volume 2576 de Lecture Notes in Computer Science, pages 268 289. Springer-Verlag, 2002. Jean-Sébastien Coron, David Lefranc et Guillaume Poupard. A new babystep giant-step algorithm and some applications to cryptanalysis. Dans Cryptographic Hardware and Embedded Systems CHES 2005, volume 3659 de Lecture Notes in Computer Science, pages 47 60. Springer-Verlag, 2005. Jean-Sébastien Coron et Alexander May. Computing the RSA secret key is deterministic polynomial time equivalent to factoring. Cryptology eprint Archive, Report 2004/208, 2004. Jean-Sébastien Coron et David Naccache. Security analysis of the Gennaro- Halevi-Rabin signature scheme. Dans Advances in Cryptology EURO- CRYPT 2000, volume 1807 de Lecture Notes in Computer Science, pages 91 101. Springer-Verlag, 2000. Benoît Chevallier-Mames, David Naccache, Pascal Paillier et David Pointcheval. How to disembed a program? Dans Cryptographic Hardware and Embedded Systems CHES 2004, volume 3156 de Lecture Notes in Computer Science, pages 441 454. Springer-Verlag, 2004. 159

Bibliographie [Cor00] Jean-Sébastien Coron. On the exact security of full domain hash. Dans Advances in Cryptology CRYPTO 2000, volume 1880 de Lecture Notes in Computer Science, pages 229 235. Springer-Verlag, 2000. [Cor02] Jean-Sébastien Coron. Optimal security proofs for PSS and other signature schemes. Dans Advances in Cryptology EUROCRYPT 2002, volume 2332 de Lecture Notes in Computer Science, pages 272 287. Springer-Verlag, 2002. [Cor99] [CP92] [CPP05] Jean-Sébastien Coron. Resistance against differential power analysis for elliptic curve cryptosystems. Dans Cryptographic Hardware and Embedded Systems CHES 99, volume 1717 de Lecture Notes in Computer Science, pages 292 302. Springer-Verlag, 1999. David Chaum et Torben P. Pedersen. Wallet databases with observers. Dans Advances in Cryptology CRYPTO 92, volume 740 de Lecture Notes in Computer Science, pages 89 105. Springer-Verlag, 1992. Benoît Chevallier-Mames, Duong Hieu Phan et David Pointcheval. Optimal asymmetric encryption and signature paddings. Dans Applied Cryptography and Network Security ACNS 2005, volume 3531 de Lecture Notes in Computer Science, pages 254 268. Springer-Verlag, 2005. [CPP06] Benoît Chevallier-Mames, Pascal Paillier et David Pointcheval. Encoding-free ElGamal encryption without random oracles. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 91 104. Springer-Verlag, 2006. [CS00] [CS98] [CS99] [DDN00] [DH76] Ronald Cramer et Victor Shoup. Signature schemes based on the strong RSA assumption. ACM Transactions on Information and System Security (TISSEC), 3(3):161 185, 2000. Ronald Cramer et Victor Shoup. A practical public key cryptosystem provably secure against adaptive chosen ciphertext attack. Dans Advances in Cryptology CRYPTO 98, volume 1462 de Lecture Notes in Computer Science, pages 13 25. Springer-Verlag, 1998. Ronald Cramer et Victor Shoup. Signature schemes based on the strong RSA assumption. Dans ACM Conference on Computer and Communications Security ACM CCS 1999, pages 46 51. ACM Press, 1999. Danny Dolev, Cynthia Dwork et Moni Naor. Non-malleable cryptography. SIAM Journal on Computing, 30(2):391 437, 2000. Whitfield Diffie et Martin E. Hellman. New directions in cryptography. IEEE Transactions on Information Theory, 22(6):644 654, 1976. [DIM05] Vassil S. Dimitrov, Laurent Imbert et Pradeep Kumar Mishra. Efficient and secure elliptic curve point multiplication using double-base chains. Dans Advances in Cryptology ASIACRYPT 2005, volume 3788 de Lecture Notes in Computer Science, pages 59 78. Springer-Verlag, 2005. [DJ01] Ivan Damgård et Mats Jurik. A generalisation, a simplification and some applications of Paillier s probabilistic public-key system. Dans Public Key Cryptography PKC 2001, volume 1992 de Lecture Notes in Computer Science, pages 119 136. Springer-Verlag, 2001. 160

[DN94] [DR02] Cynthia Dwork et Moni Naor. An efficient existentially unforgeable signature scheme and its applications. Dans Advances in Cryptology CRYPTO 94, volume 839 de Lecture Notes in Computer Science, pages 234 246. Springer-Verlag, 1994. Yevgeniy Dodis et Leonid Reyzin. On the power of claw-free permutations. Dans Security in Communication Networks SCN 2002, volume 2576 de Lecture Notes in Computer Science, pages 55 73. Springer-Verlag, 2002. [EGM89] Shimon Even, Oded Goldreich et Silvio Micali. On-line/off-line digital schemes. Dans Advances in Cryptology CRYPTO 89, volume 435 de Lecture Notes in Computer Science, pages 263 275. Springer-Verlag, 1989. [ElG85] Taher ElGamal. A public key cryptosystem and a signature scheme based on discrete logarithms. IEEE Transactions on Information Theory, 31(4):469 472, 1985. [Fis03] Marc Fischlin. The Cramer-Shoup strong-rsa signature scheme revisited. Dans Public Key Cryptography PKC 2003, volume 2567 de Lecture Notes in Computer Science, pages 116 129. Springer-Verlag, 2003. [FMR99] [FO00] Gerhard Frey, Michael Müller et Hans-Georg Rück. The Tate pairing and the discrete logarithm applied to elliptic curve cryptosystems. IEEE Transactions on Information Theory, 45(5):1717 1719, 1999. Eiichiro Fujisaki et Tatsuaki Okamoto. How to enhance the security of publickey encryption at minimum cost. IEICE Transaction of Fundamentals of Electronic Communications and Computer Science, E83-A(1):24 32, 2000. [FO97] Eiichiro Fujisaki et Tatsuaki Okamoto. Statistical zero knowledge protocols to prove modular polynomial relations. Dans Advances in Cryptology CRYPTO 97, volume 1294 de Lecture Notes in Computer Science, pages 16 30. Springer-Verlag, 1997. [FO99] [FOPS04] [FS86] [Gal05] [GHR99] Eiichiro Fujisaki et Tatsuaki Okamoto. Secure integration of asymmetric and symmetric encryption schemes. Dans Advances in Cryptology CRYPTO 99, volume 1666 de Lecture Notes in Computer Science, pages 537 554. Springer- Verlag, 1999. Eiichiro Fujisaki, Tatsuaki Okamoto, David Pointcheval et Jacques Stern. RSA-OAEP is secure under the RSA assumption. Journal of Cryptology, 17(2):81 104, 2004. Amos Fiat et Adi Shamir. How to prove yourself: practical solutions to identification and signature problems. Dans Advances in Cryptology CRYPTO 86, volume 263 de Lecture Notes in Computer Science, pages 186 184. Springer- Verlag, 1986. David Galindo. Boneh-Franklin identity based encryption revisited. Dans Automata, Languages and Programming ICALP 2005, volume 3580 de Lecture Notes in Computer Science, pages 791 802. Springer-Verlag, 2005. Rosario Gennaro, Shai Halevi et Tal Rabin. Secure hash-and-sign signatures without the random oracle. Dans Advances in Cryptology EUROCRYPT 99, volume 1592 de Lecture Notes in Computer Science, pages 123 139. Springer- Verlag, 1999. 161

Bibliographie [Gir90] [Gir91] [GJ03] [GJKW06] [GM84] [GMR84] Marc Girault. An identity-based identification scheme based on discrete logarithms modulo a composite number. Dans Advances in Cryptology EURO- CRYPT 90, volume 473 de Lecture Notes in Computer Science, pages 481 486. Springer-Verlag, 1990. Marc Girault. Self-certified public keys. Dans Advances in Cryptology EURO- CRYPT 91, volume 547 de Lecture Notes in Computer Science, pages 490 497. Springer-Verlag, 1991. Eu-Jin Goh et Stanislaw Jarecki. A signature scheme as secure as the Diffie- Hellman problem. Dans Advances in Cryptology EUROCRYPT 2003, volume 2656 de Lecture Notes in Computer Science, pages 401 415. Springer-Verlag, 2003. Eu-Jin Goh, Stanislaw Jarecki, Jonathan Katz et Nan Wang. Efficient signature schemes with tight security reductions to the Diffie-Hellman problems. À paraitre dans Journal of Cryptology. Version préliminaire disponible à l adresse http://www.cs.umd.edu/~jkatz/. Shafi Goldwasser et Silvio Micali. Probabilistic encryption. Journal of Computer and System Sciences, 28(2):270 299, 1984. Shafi Goldwasser, Silvio Micali et Ronald L. Rivest. A paradoxical solution to the signature problem (extended abstract). Dans Symposium on Foundations of Computer Science FOCS 84, pages 441 448. IEEE Press, 1984. [GMR88] Shafi Goldwasser, Silvio Micali et Ronald L. Rivest. A digital signature scheme secure against adaptive chosen-message attacks. SIAM Journal on Computing, 17(2):281 308, 1988. [Gol01] Oded Goldreich. Foundations of Cryptography Basic Tools. Cambridge University Press, 2001. [Gor98] [GQ88] [Gra02] [GS94] [HL94] [HP01] 162 Daniel M. Gordon. A survey of fast exponentiation methods. Journal of Algorithms, 27(1):129 146, 1998. Louis C. Guillou et Jean-Jacques Quisquater. A practical zero-knowledge protocol fitted to security microprocessor minimizing both trasmission and memory. Dans Advances in Cryptology EUROCRYPT 88, volume 330 de Lecture Notes in Computer Science, pages 123 128. Springer-Verlag, 1988. Louis Granboulan. Short signatures in the random oracle model. Dans Advances in Cryptology ASIACRYPT 2002, volume 2501 de Lecture Notes in Computer Science, pages 364 378. Springer-Verlag, 2002. Marc Girault et Jacques Stern. On the length of cryptographic hash-values used in identification schemes. Dans Advances in Cryptology CRYPTO 94, volume 839 de Lecture Notes in Computer Science, pages 202 215. Springer- Verlag, 1994. Lucas Chi Kwong Hui et Kwok-Yan Lam. Fast square-and-multiply exponentiation for RSA. Electronics Letters, 30(17):1396 1397, 1994. Stuart Haber et Benny Pinkas. Securely combining public-key cryptosystems. Dans ACM Conference on Computer and Communications Security ACM CCS 2001, pages 215 224. ACM Press, 2001.

[IYTT02] [JLQ99] [Jou00] Kouichi Itoh, Jun Yajima, Masahiko Takenaka et Naoya Torii. DPA countermeasures by improving the window method. Dans Cryptographic Hardware and Embedded Systems CHES 2002, volume 2523 de Lecture Notes in Computer Science, pages 303 317. Springer-Verlag, 2002. Marc Joye, Arjen K. Lenstra et Jean-Jacques Quisquater. Chinese remaindering based cryptosystems in the presence of faults. Journal of Cryptology, 12(4):241 245, 1999. Antoine Joux. A one round protocol for tripartite Diffie-Hellman. Dans Algorithmic Number Theory Symposium ANTS 2000, volume 1838 de Lecture Notes in Computer Science, pages 385 394. Springer-Verlag, 2000. [Joy02] Marc Joye. Recovering lost efficiency of exponentiation algorithms on smart cards. Electronics Letters, 38(19):1095 1097, 2002. [JPV00] Marc Joye, Pascal Paillier et Serge Vaudenay. Efficient generation of prime numbers. Dans Cryptographic Hardware and Embedded Systems CHES 2000, volume 1965 de Lecture Notes in Computer Science, pages 340 354. Springer- Verlag, 2000. [JS99] Markus Jakobsson et Claus-Peter Schnorr. Efficient oblivious proofs of correct exponentiation. Dans Communications and Multimedia Security CMS 1999, volume 152 de IFIP Conference Proceedings, pages 71 86. IFIP, 1999. [KH06] [KJJ99] [KM04] Kaoru Kurosawa et Swee-Huay Heng. The power of identification schemes. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 364 377. Springer-Verlag, 2006. Paul C. Kocher, Joshua Jaffe et Benjamin Jun. Differential power analysis. Dans Advances in Cryptology CRYPTO 99, volume 1666 de Lecture Notes in Computer Science, pages 388 397. Springer-Verlag, 1999. Neal Koblitz et Alfred Menezes. Another look at provable security. Cryptology eprint Archive, Report 2004/152, 2004. À paraître au Journal of Cryptology. [KO03] Yuichi Komano et Kazuo Ohta. Efficient universal padding techniques for multiplicative trapdoor one-way permutation. Dans Advances in Cryptology CRYPTO 2003, volume 2729 de Lecture Notes in Computer Science, pages 366 382. Springer-Verlag, 2003. [Kob87] Neal Koblitz. Elliptic curve cryptosystems. Mathematics of Computation, 48(177):203 209, 1987. [Koc96] Paul C. Kocher. Timing attacks on implementations of Diffie-Hellman, RSA, DSS, and other systems. Dans Advances in Cryptology CRYPTO 96, volume 1109 de Lecture Notes in Computer Science, pages 104 113. Springer-Verlag, 1996. [KR00] Hugo Krawczyk et Tal Rabin. Chameleon signatures. Dans Network and Distributed System Security Symposium NDSS 2000, pages 143 154, 2000. [KS04] François Koeune et François-Xavier Standaert. A tutorial on physical security and side-channel attacks. Dans Foundations of Security Analysis and Design FOSAD 2004, volume 3655 de Lecture Notes in Computer Science, pages 78 108. Springer-Verlag, 2004. 163

Bibliographie [KS06] Kaoru Kurosawa et Katja Schmidt-Samoa. New online/offline signature schemes without random oracles. Dans Public Key Cryptography PKC 2006, volume 3958 de Lecture Notes in Computer Science, pages 330 346. Springer- Verlag, 2006. [Kum04] [KW03] Pradeep Kumar Mishra. Pipelined computation of scalar multiplication in elliptic curve cryptosystems. Dans Cryptographic Hardware and Embedded Systems CHES 2004, volume 3156 de Lecture Notes in Computer Science, pages 328 342. Springer-Verlag, 2004. Jonathan Katz et Nan Wang. Efficiency improvements for signature schemes with tight security reductions. Dans ACM Conference on Computer and Communications Security ACM CCS 2003, pages 155 164. ACM Press, 1993. [LH94] Kwok-Yan Lam et Lucas Chi Kwong Hui. Efficiency of SS(l) square-andmultiply exponentiation algorithms. Electronics Letters, 30(25):2115 2116, 1994. [LQ05] [LV00] [May04] [MDS99] Benoît Libert et Jean-Jacques Quisquater. Identity based encryption without redundancy. Dans Applied Cryptography and Network Security ACNS 2005, volume 3531 de Lecture Notes in Computer Science, pages 285 300. Springer- Verlag, 2005. Arjen K. Lenstra et Eric R. Verheul. Selecting cryptographic key sizes. Dans Public Key Cryptography PKC 2000, volume 1751 de Lecture Notes in Computer Science, pages 446 465. Springer-Verlag, 2000. Alexander May. Computing the RSA secret key is deterministic polynomial time equivalent to factoring. Dans Advances in Cryptology CRYPTO 2004, volume 3152 de Lecture Notes in Computer Science, pages 213 219. Springer-Verlag, 2004. Thomas S. Messerges, Ezzy A. Dabbish et Robert H. Sloan. Power analysis attacks of modular exponentiation in smartcards. Dans Cryptographic Hardware and Embedded Systems CHES 99, volume 1717 de Lecture Notes in Computer Science, pages 144 157. Springer-Verlag, 1999. [Mil76] Gary L. Miller. Riemann s hypothesis and tests for primality. Journal of Computer and System Sciences, 13(3):300 317, 1976. [Mil85] Victor S. Miller. Use of elliptic curves in cryptography. Dans Advances in Cryptology CRYPTO 85, volume 218 de Lecture Notes in Computer Science, pages 417 426. Springer-Verlag, 1985. [MOV93] [MOV97] [NIST94] [NPS01] 164 Alfred Menezes, Tatsuaki Okamoto et Scott A. Vanstone. Reducing elliptic curve logarithms to logarithms in a finite field. IEEE Transactions on Information Theory, 39(5):1639 1646, 1993. Alfred J. Menezes, Paul C. van Oorschot et Scott A. Vanstone. Handbook of Applied Cryptography. CRC Press, 1997. NIST. Digital signature standard (DSS). Federal Information Processing Standards Publication 186, Novembre 1994. David Naccache, David Pointcheval et Jacques Stern. Twin signatures: an alternative to the hash-and-sign paradigm. Dans ACM Conference on Computer and Communications Security ACM CCS 2001, pages 20 27. ACM Press, 2001.

[NR94] [NS00] [NY90] [OP01a] [OP01b] [OTV05a] [OTV05b] [OU98] [P1363] [Pai99a] [Pai99b] [Pha05] Kaisa Nyberg et Rainer A. Rueppel. Message recovery for signature schemes based on the discrete logarithm problem. Dans Advances in Cryptology EURO- CRYPT 94, volume 950 de Lecture Notes in Computer Science, pages 182 193. Springer-Verlag, 1994. David Naccache et Jacques Stern. Signing on a postcard. Dans Financial Cryptography FC 2000, volume 1962 de Lecture Notes in Computer Science, pages 121 135. Springer-Verlag, 2000. Moni Naor et Moti Yung. Public-key cryptosystems provably secure against chosen ciphertext attacks. Dans ACM Symposium on the Theory of Computing STOC 90, pages 427 437. ACM Press, 1990. Tatsuaki Okamoto et David Pointcheval. REACT: rapid enhanced-security asymmetric cryptosystem transform. Dans Topics in Cryptology CT-RSA 2001, volume 2020 de Lecture Notes in Computer Science, pages 159 175. Springer- Verlag, 2001. Tatsuaki Okamoto et David Pointcheval. The gap-problems: a new class of problems for the security of cryptographic schemes. Dans Public Key Cryptography PKC 2001, volume 1992 de Lecture Notes in Computer Science, pages 104 118. Springer-Verlag, 2001. Katsuyuki Okeya, Tsuyoshi Takagi et Camille Vuillaume. Short memory scalar multiplication on Koblitz curves. Dans Cryptographic Hardware and Embedded Systems CHES 2005, volume 3659 de Lecture Notes in Computer Science, pages 91 105. Springer-Verlag, 2005. Katsuyuki Okeya, Tsuyoshi Takagi et Camille Vuillaume. Efficient representations on Koblitz curves with resistance to side channel attacks. Dans Information Security and Privacy ACISP 2005, volume 3574 de Lecture Notes in Computer Science, pages 218 229. Springer-Verlag, 2005. Tatsuaki Okamoto et Shigenori Uchiyama. A new public-key cryptosystem as secure as factoring. Dans Advances in Cryptology EUROCRYPT 98, volume 1403 de Lecture Notes in Computer Science, pages 308 318. Springer-Verlag, 1998. IEEE Std 1363-2000. IEEE standard specifications for public-key cryptography. IEEE Computer Society, Aout 2000. Pascal Paillier. Cryptographie à clé publique basée sur la résiduosité de degré composite. Thèse de Doctorat, École Nationale Supérieure des Télécommunications, Paris, 1999. Pascal Paillier. Public-key cryptosystems based on composite degree residuosity classes. Dans Advances in Cryptology EUROCRYPT 99, volume 1592 de Lecture Notes in Computer Science, pages 223 238. Springer-Verlag, 1999. Duong Hieu Phan. Sécurité et efficacité de schémas cryptographiques. Thèse de Doctorat, École Polytechnique, Palaiseau, 2005. [PKCS1] RSA Laboratories. PKCS #1 v2.1: RSA cryptography standard, Juin 2002. [Poi00] David Pointcheval. Chosen-ciphertext security for any one-way cryptosystem. Dans Public Key Cryptography PKC 2000, volume 1751 de Lecture Notes in Computer Science, pages 129 146. Springer-Verlag, 2000. 165

Bibliographie [Poi96] David Pointcheval. Les preuves de connaissances et leurs preuves de sécurité. Thèse de Doctorat, Université de Caen, Caen, 1996. [Pou00] Guillaume Poupard. Authentification d entités, de messages et de clés cryptographiques: Théorie et pratique. Thèse de Doctorat, École Polytechnique, Palaiseau, 2000. [PP03] [PP04] [PP99] [PS96] [PS98] [PS99] [PV05] [QC82] [Rab79] Duong Hieu Phan et David Pointcheval. Chosen-ciphertext security without redundancy. Dans Advances in Cryptology ASIACRYPT 2003, volume 2894 de Lecture Notes in Computer Science, pages 1 18. Springer-Verlag, 2003. Duong Hieu Phan et David Pointcheval. OAEP 3-round: a generic and secure asymmetric encryption padding. Dans Advances in Cryptology ASIA- CRYPT 2004, volume 3329 de Lecture Notes in Computer Science, pages 63 77. Springer-Verlag, 2003. Pascal Paillier et David Pointcheval. Efficient public-key cryptosystems provably secure against active adversaries. Dans Advances in Cryptology ASIA- CRYPT 99, volume 1716 de Lecture Notes in Computer Science, pages 165 179. Springer-Verlag, 1999. David Pointcheval et Jacques Stern. Security proofs for signature schemes. Dans Advances in Cryptology EUROCRYPT 96, volume 1070 de Lecture Notes in Computer Science, pages 387 398. Springer-Verlag, 1996. Guillaume Poupard et Jacques Stern. Security analysis of a practical on the fly authentication and signature generation. Dans Advances in Cryptology EUROCRYPT 98, volume 1403 de Lecture Notes in Computer Science, pages 422 436. Springer-Verlag, 1998. Guillaume Poupard et Jacques Stern. On the fly signatures based on factoring. Dans ACM Conference on Computer and Communications Security ACM CCS 1999, pages 37 45. ACM Press, 1999. Pascal Paillier et Damien Vergnaud. Discrete-log-based signatures may not be equivalent to discrete log. Dans Advances in Cryptology ASIACRYPT 2005, volume 3788 de Lecture Notes in Computer Science, pages 1 20. Springer-Verlag, 2005. Jean-Jacques Quisquater et Chantal Couvreur. Fast decipherment algorithm for RSA public-key cryptosystem. Electronics Letters, (18):905 907, 1982. Michael O. Rabin. Digital signatures and public-key functions as intractable as factorization. Technical Report MIT/LCS/TR-212, MIT Laboratory for Computer Science, Janvier 1979. [RS91] Charles Rackoff et Daniel R. Simon. Non-interactive zero-knowledge proof of knowledge and chosen ciphertext attack. Dans Advances in Cryptology CRYPTO 91, volume 576 de Lecture Notes in Computer Science, pages 433 444. Springer-Verlag, 1991. [RSA78] [Sch91] 166 Ronald L. Rivest, Adi Shamir et Leonard M. Adleman. A method for obtaining digital signatures and public-key cryptosystems. Communications of the ACM, 21(2):120 126, 1978. Claus-Peter Schnorr. Efficient signature generation by smart cards. Journal of Cryptology, 4(3):161 174, 1991.

[Sei05] [Sha84] Jean-Pierre Seifert. On authenticated computing and RSA-based authentication. Dans ACM Conference on Computer and Communications Security ACM CCS 2005, pages 122 127. ACM Press, 2005. Adi Shamir. Identity-based cryptosystems and signature schemes. Dans Advances in Cryptology CRYPTO 84, volume 196 de Lecture Notes in Computer Science, pages 47 53. Springer-Verlag, 1984. [Sho01] Victor Shoup. OAEP reconsidered. Dans Advances in Cryptology CRYPTO 2001, volume 2139 de Lecture Notes in Computer Science, pages 239 259. Springer-Verlag, 2001. [ST01] Adi Shamir et Yael Tauman. Improved online/offline signature schemes. Dans Advances in Cryptology CRYPTO 2001, volume 2139 de Lecture Notes in Computer Science, pages 355 367. Springer-Verlag, 2001. [Sti95] Douglas R. Stinson. Cryptography: Theory and Practice. CRC Press, 1995. [Wal02] [Wal98] [Wat05] [WMPW98] [Zhu01] [Zhu03] Colin D. Walter. MIST: an efficient, randomized exponentiation algorithm for resisting power analysis. Dans Topics in Cryptology CT-RSA 2002, volume 2271 de Lecture Notes in Computer Science, pages 53 66. Springer-Verlag, 2002. Colin D. Walter. Exponentiation using division chains. IEEE Transactions on Computers, 47(7):757 765, 1998. Brent Waters. Efficient identity-based encryption without random oracles. Dans Advances in Cryptology EUROCRYPT 2005, volume 3494 de Lecture Notes in Computer Science, pages 114 127. Springer-Verlag, 2005. Erik De Win, Serge Mister, Bart Preneel et Michael J. Wiener. On the performance of signature schemes based on elliptic curves. Dans Algorithmic Number Theory Symposium ANTS 1998, volume 1423 de Lecture Notes in Computer Science, pages 252 266. Springer-Verlag, 1998. Huafei Zhu. New digital signature scheme attaining immunity against adaptive chosen message attack. Chinese Journal of Electronics, 10(4):484 486, 2001. Huafei Zhu. A formal proof of Zhu s signature scheme. Cryptology eprint Archive, Report 2003/155, 2003. 167

Bibliographie 168

Index Σ-protocole, 28, 32, 42 GPS, 35 GQ, 35 PS, 36 Schnorr, 34, 38 Algorithme, 7 complexité, 7 déterministe, 7 efficace, 7, 11 polynomial, 7, 11 probabiliste, 7 sous-exponentiel, 7 Atomicité, 129, 130, 147 MIST, 138 algorithme (M, M 3 ), 134 algorithme binaire, 131 algorithme d exponentiation à fenêtre glissante, 133 algorithme droite-gauche, 134 approche explicite, 132, 135 approche implicite, 131 134 approche matricielle, 132 bloc atomique, 130 bloc atomique commun, 130 hypothèses, 133 instructions équivalentes en canal caché, 130, 133 méthodologie, 132 Attaque à chiffrés choisis (CCA), 86, 87 à clé seule (KOA), 30 à clairs choisis (CPA), 86 à clairs et identités choisis (ID-CPA), 91 à messages choisis (CMA), 31, 32 à messages connus (KMA), 31 à messages et identités choisis (ID-CCA), 91 sans message (NMA), 30 Attaque par canal caché, 141 169

Index attaque différentielle (DPA), 127, 128, 142 attaque simple (SPA), 127 129, 147 Attaque par fautes, 127, 141 Contre-mesure découpage additif de l exposant, 132, 143 données rendues aléatoires, 141 exponentiations aléatoires, 141 masquage de l exposant, 132 Courbe elliptique, 13, 135, 136 équation de Weierstraß, 135, 136 double-and-add, 135, 137 addition de point, 135, 137 coordonnées affines, 137 coordonnées Jacobiennes, 135 doublement de point, 135, 137 multiplication scalaire de point, 135, 137 sur un corps binaire, 136 sur un corps premier, 135 Cryptologie, 3 Authentification, 5 Confidentialité, 4 Cryptanalyse, 4 Cryptographie, 4 Cryptographie asymétrique, 4, 155 Cryptographie symétrique, 4, 155 Identification, 5 Intégrité, 4 Encodage en éléments de groupe, 94, 100 Exponentiation, 143 MIST, 138, 142 MIST en version atomique, 138 square-and-multiply always, 131 algorithme (M, M 3 ) atomique, 134 algorithme à fenêtre glissante atomique, 133 algorithme binaire, 143, 144, 147 algorithme binaire (square-and-multiply), 130 algorithme binaire atomique, 131 algorithme binaire droite-gauche atomique, 134 algorithme d exponentiation intrinsèquement aléatoire, 142, 144, 146 Fonction bilinéaire admissible, 6, 13, 91 Fonction de padding, 6, 117 OAEP3, 122 OPbP, 119 padding universel, 117, 118 Fonction de classe, 96 dans Z p k, 102 170

Index dans Z p 2, 96 Fonction de hachage, 5 hachage caméléon, 41 Heuristique Fiat-Shamir, 29, 30 Hypothèse RSA forte, 12 Lemme de bifurcation, 32, 38, 63 Modèle de l oracle aléatoire, 10, 32, 33, 37, 38, 44, 46, 52, 55, 58, 61, 70, 95, 105, 109, 122 Modèle de la permutation aléatoire, 119, 120 Modèle standard, 10, 69 71, 75, 79, 93, 95, 100, 101 Notion de sécurité falsification existentielle (EUF), 31, 32 falsification existentielle faible (EUF), 31 falsification existentielle forte (seuf), 31 falsification universelle (UF), 31 indistinguabilité (IND), 86, 87, 91 non-malléabilité (NM), 86, 87 résistance de la clé (UBK), 31, 86 sécurité sémantique (IND), 87 sens unique (OW), 86, 87 Preuve de sécurité de OAEP3, 122 de OPbP, 120 de notre schéma d Acns 05, 44, 46 de notre schéma de Crypto 05, 61 de notre schéma de Ct-rsa 07, 75, 79 de notre schéma de Pkc 06, 100, 101 du schéma EDL, 52 du schéma KW-CDH, 55 du schéma KW-DDH, 58 Problème cryptographique, 11 q-problème, 70 basés sur les fonctions bilinéaires, 13 factorisation (FACT), 11, 50 logarithme discret (DL), 12, 38 logarithme discret dans Z n (DL n ), 13 logarithme discret dans un groupe d ordre secret (DL x ), 13 problème échelon Diffie-Hellman bilinéaire (GBDH), 14 problème calculatoire de classe Diffie-Hellman (CCDH), 97 problème calculatoire Diffie-Hellman (CDH), 12, 52, 55, 61 problème calculatoire Diffie-Hellman bilinéaire (CBDH), 13 problème calculatoire Diffie-Hellman bilinéaire par liste (LBDH), 14 problème décisionnel de classe Diffie-Hellman (DCDH), 97 problème décisionnel Diffie-Hellman (DDH), 12, 58 problème décisionnel Diffie-Hellman bilinéaire (DBDH), 13 171

Index problème souple, 70 problème souple de la racine e-ième (FlexibleRSA), 12, 70, 75, 79 problème un-de-plus, 70 problèmes basés sur la factorisation, 11 problèmes basés sur le logarithme discret, 12 racine e-ième (RSA), 11, 32, 37, 46 Problème difficile, 11 Protocole d identification à divulgation nulle de connaissance, 27, 32, 42 FS, 28 GPS, 35 GQ, 35 PS, 36 Schnorr, 28, 29, 34, 38 Réduction, 7, 9, 10 d un problème à un autre, 7 finesse, 10 réduction fine, 10, 37, 41, 44, 46, 52, 55, 58, 61, 77, 80, 100, 101, 109 réduction lâche, 10, 32, 39 Sécurité buts de l attaquant, 30, 31, 86, 87 d un schéma de chiffrement, 86, 87 d un schéma de chiffrement basé sur l identité, 91 d un schéma de signature, 30, 31 modèles de sécurité, 10, 30 ressources de l attaquant, 30, 31, 86, 87 sécurité asymptotique, 10 sécurité exacte, 10 sécurité par réduction, 9, 10 sécurité prouvée, 9, 10 scénarios d attaque, 10, 30, 31, 86, 87 Schéma de chiffrement, 85, 86 ElGamal, 89, 93, 94 ElGamal avec fonction de hachage, 95 Paillier, 89, 96 RSA, 88 présenté à Pkc 06, 99, 102 sécurité, 86 Schéma de chiffrement basé sur l identité, 90, 114 Boneh-Franklin, 91, 105, 106, 114 Katz-Wang, 105, 106, 114 avec réduction fine, 105, 108 Schéma de signature, 25, 26, 33, 42 CL, 73, 77 CS, 73, 77 EDL, 50, 52, 65 Fischlin, 74, 77 172

Index GHR, 71, 77 GPS, 35, 65 GQ, 35 KW-CDH, 55, 65 KW-DDH, 57, 65 PS, 36, 46 RSA, 33, 141 RSA mode CRT, 142 RSA mode standard, 142 RSA-FDH, 33, 37, 46 RSA-PSS, 33, 48 Rabin-FDH, 50 Schnorr, 29, 34, 38, 65 TSS, 74, 77, 79 Twin-GHR, 72, 77 présenté à Acns 05, 42, 46 présenté à Crypto 05, 61 présenté à Ct-rsa 07, 74 primitive RSA, 26, 32 sécurité, 30 signatures jumelles, 72 Signature à coupons, 29, 30, 34 36, 41, 42, 46, 54, 57, 63, 79 173

Index 174

Index 175

Résumé Le concept de cryptographie à clé publique, initiée par Whitfield Diffie et Martin Hellman, a donné naissance à une nouvelle ère de la cryptologie. Après la description de schémas sûrs de façon heuristique, la formalisation de modèles et de notions de sécurité a permis la naissance de la cryptographie à sécurité prouvée. Après un rappel des concepts mêmes de la cryptographie et des preuves par réduction, nous proposons de nouveaux schémas de signature et de chiffrement, tout en décrivant certains avantages sur les schémas existants. Ainsi, nous proposons deux nouveaux schémas de signature sûrs dans le modèle de l oracle aléatoire, et exposons un nouveau schéma de signature sûr dans le modèle standard. Tous nos schémas possèdent une preuve fine et autorisent l usage de coupons. Ensuite, nous décrivons un nouveau schéma de chiffrement, basé sur un nouveau problème algorithmique. Nous jetons également un nouveau regard sur la notion de padding universel, et montrons comment obtenir, pour un schéma de chiffrement basé sur l identité, une preuve fine dans le modèle de l oracle aléatoire. Dans une partie finale de cette thèse, nous abordons le thème de la sécurité des mises en œuvre des algorithmes cryptographiques. Nous proposons ainsi des contre-mesures contre les attaques par canaux cachés, qu elles soient simples (SPA) ou différentielles (DPA). Mots-clés: Cryptographie, Clé publique, Sécurité prouvée, Preuve par réduction, Finesse des réductions, Schémas de signature, Schémas de chiffrement, Attaques par canaux cachés et protections, Atomicité. Abstract The public key cryptography concept, proposed by Whitfield Diffie et Martin Hellman, changed the cryptology world. After the description of first heuristically secure schemes, the formalization of models and security notions has allowed the emergency of provable security. After some reminds about cryptography and security reduction, we propose new signature and encryption schemes, with some advantages over the existing systems. Indeed, we propose two new signature schemes with a security proof in the random oracle model, and expose a new signature scheme which features a provable security in the standard model. All of these schemes feature both tight security and the possible use of coupons. Next, we describe a new encryption scheme, based on a new cryptographical problem. We also give another look to the universal paddings, and show how to obtain tight security for identity-based encryption schemes. In the last part of this thesis, we deal with the physical security of cryptographical software. We propose notably new efficient countermeasures against simple side-channel attacks (SPA) and differential side-channel attacks (DPA). Keywords: Cryptography, Public key, Provable security, Reductionist security, Reduction tightness, Signature schemes, Encryption schemes, Side-channel attacks and protections, Atomicity. 176