Preuve de sécurité pour Paillier IND-TCPA

Partie III Applications 157

Chapitre 10 Chiffrement du même message sous plusieurs clés 203

4.1 Preuve de sécurité pour Paillier IND-TCPA

Décrivons maintenant comment alimenter un adversaireApour le schéma à seuil afin de construire un attaquant contre la sécurité sémantique. Dans l’étape A1 du jeu A, l’adversaire choisit de corrompret serveurs. Sans perte de généralité, on fait l’hypothèse que lestpremiers serveursP₁, . . . P_tsont corrom-pus.

Dans la phase “find”, l’attaquant obtient la clé publiquepk = (N, g)du schéma régulier de Paillier.

Il choisit au hasard(a1, b1, θ)∈ZN ×Z^∗_N×Z^∗_N et calculeg1 =g^a¹×b^N₁ modN². Il choisit aussi au

hasardtvaleurssk1, . . .sktdans l’intervalle{0, . . .bN²/4c}, un élémentαau hasard dansZ^∗_N et calcule v=g₁^2α modN².

Ensuite, il calculevk_i =v^∆sⁱ modN², pouri= 1, . . . t, et les autres clés de vérifications vk_i = (1 + 2αθN)^λ^S^i,0× Y

j∈S\{0}

v^sk^j^λ^S^i,j modN²

oùS={0,1, . . . t}. L’attaquant envoie(N, g₁, θ, v,vk₁, . . .vk_n,sk₁, . . .sk_t)àAà l’étape A2 du jeu A.

La nouvelle clé publique est notéepk⁰ dans la figure 4.1 et comprend l’ensemble des clés de vérification vki.

Durant l’étape A3,Achoisit un messageMet l’envoie à l’attaquant. Il calculec=g^M₁ x^N modN², un chiffrement valide de M. Les parts de déchiffrement des joueurs corrompus sont calculées correc-tement en utilisant lesski:σi = c^2∆skⁱ modN², pouri = 1, . . . t. Les autres parts sont obtenues par interpolation de la manière suivante :

σi= (1 + 2M θN)^λ^S^i,0 × Y

j∈S\{0}

c^2skⁱ^λ^S^i,j modN²

Finalement, l’attaquant fabrique une preuvepreuve_i. La simulation d’une telle preuve a été vue dans la section 3.2.4. Il retourne(c, σ₁, . . . σ_n,preuve₁, . . .preuve_n).

Dans l’étape A4,Aretourne deux messagesM₀etM₁. L’attaquant retourne au challengeur ces deux messages comme le résultat de la phase “find”.

Ensuite, le challengeur pour le schéma non distribué de Paillier choisit un bit aléatoire et envoie un chiffréc^∗_b deM_bà l’attaquant. Ce dernier randomise le chiffréΓ^∗_b =c^a_b¹ modN² aveca₁et envoieΓ^∗_b à l’adversaireA.

L’étape A5 est similaire à l’étape A3. Finalement, à l’étape A6,Arépond un bitb⁰ qui est renvoyé par l’adversaire dans la phase “guess”.

On prouve maintenant que les données simulées par l’attaquant ne peuvent pas être distinguées des données réelles parA. Par conséquent, s’il existe un adversaire Afonctionnant en temps polynomial capable de casser la sécurité sémantique du schéma à seuil, on peut construire un attaquant capable de casser la sécurité sémantique du schéma de Paillier originel.

Indistinguabilité des données reçues parAdurant l’étape A2.

On observe tout d’abord que g1 = g^a¹b^N₁ modN² est uniformément distribué dans l’ensemble des éléments d’ordre un multiple deN, si l’ordre degest aussi un multiple deN. Une telle modification sur gest nécessaire. En effet, on choisitv comme une puissance paire deg₁ et nous voulons quev génère le sous-groupe des carrés modulo N². Par conséquent,g doit être randomisé afin d’obtenir avec forte probabilité une base d’un ordre très grand. Par exemple, la base valideg = 1 +N ne fournirait jamais unvcorrect.

Nous notons aussi queθ etv sont uniformément distribués respectivement dansZ^∗_N et dansQ_N2, l’ensemble des carrés moduloN². De plus,v est un générateur deQ_N² avec probabilité écrasante : la distance statistique entre la distribution uniforme sur le sous-ensemble des générateurs Q_N², d’ordre ϕ(N m), et la distribution uniforme surQ_N2, d’ordreN m, estO(N^−1/2).

Ensuite, l’attaquant choisit les clés secrètes sk1, . . .skt des joueurs corrompus ; lesski doivent être dans l’intervalle[0, N m[mais, commemest inconnu, nous prenonsskidans[0,bN²/4c[. Néanmoins, la distance statistique entre la distribution uniforme sur[0,bN²/4c[et la distribution uniforme sur[0, N m[

est O(N^−1/2) et par conséquent l’adversaire ne peut pas distinguer les clés secrètes réelles des clés simulées.

Quand le distributeur distribue correctement les parts, les deux conditions suivantes sont vérifiées : – Pour tout ensembleSde taillet+ 1et pour touti6∈S,vk_i^∆=Y

j∈S

vk_j^λ^S^i,j modN²

– Pour toutSde taillet+ 1,Y

j∈S

vkjλ^S_0,j

modN² ∈ {u < N²|u= 1 modN}

Dans la simulation, on choisit v^mβ = 1 + 2αθN modN² sans connaître mmais juste en choisissant au hasardθ. Les clés de vérification des serveurs corrompus sont calculées en utilisant les clés secrètes connuesski et les clés de vérification manquantes vki sont obtenues par la formule d’interpolation de Lagrange. Bien sûr, nous ne sommes pas capables de trouver les clés secrètes manquantes mais en fait nous n’en avons pas besoin. Ainsi, la distribution reçue par Adurant l’étape de génération des clés est indistinguable de la distribution réelle.

Indistinguabilité des données reçues parAdurant les étapes A3 et A5.

Aux étapes A3 et A5, le chiffrement du message M est calculé par c = g₁^Mx^N modN². Ensuite, les partsσ₁, . . . σ_t des serveurs corrompus sont calculées en utilisant les clés secrètessk₁, . . .sk_tde la manière suivanteσi =c^2∆skⁱ modN². Enfin, lesσimanquantes sont obtenues par interpolation, comme lesvki, en utilisant lesσ1, . . . σtet le(t+ 1)-ième pointc^mβ modN²que nous pouvons calculer sans aucun secret supplémentaire car il est égal à1 + 2M θN. Finalement, dans la preuve de la simulation, la distribution produite par l’attaquant est statistiquement proche d’une simulation parfaite comme il est rappelé en section 3.2.4. Cette simulation est apparue auparavant dans [174]. Dans le modèle de l’oracle aléatoire où l’attaquant a un contrôle total des valeurs retournées par la fonction de hachageH, on définit la valeur deHau point(v, c^4∆,vki, σ_i², v^y/vkie, c^4∆²^y/σ_i^2e)comme valante. Avec probabilité écrasante, l’attaquant n’a pas encore défini l’oracle aléatoire en ce point et l’adversaireAne peut pas détecter la

fraude. ut

4.3.5 Partage complet du déchiffrement de Paillier

On observe que pour partager complètement le déchiffrement précédent, nous devons avoir un al-gorithme distribué génération de clés. Pour distribuer la génération du module RSA, nous pouvons em-ployer les techniques du chapitre 3. Ensuite, les preuves de validité des parts de déchiffrement sont identiques à celles pour RSA afin de tenir compte du fait queN n’est plus le produit de deux nombres premiers sûrs.

Par rapport à RSA où la clé secrète est l’inverse deemoduloϕ(N), dans le cryptosystème partagé de Paillier, la clé secrète estsk =βmoùm = ^p−1₂ ×^q−1₂ etβ un nombre aléatoire dansZ^∗_N tel que2 diviseβ. La clé publique est composée depk= (g, N,vk,vk_u,i, θ =aβmmodN)pour1≤i≤n, où nest le nombre de serveurs et1 ≤ u ≤ k, oùkest un paramètre de sécurité du même ordre que dans le chapitre 3. Les générations partagées deg,vk,vku,i ne posent pas de problème. Étudions le cas de la génération desket deθ.

Génération de la clé secrète

On observe qu’à la fin du protocole de génération de clé RSA, les serveurs ont un partage deϕ(N) car ils doivent calculerpgcd(N −1, ϕ(N)). Cependant, obtenir un partage deλ(N) = ϕ(N)/2ou de m = ϕ(N)/4 n’est pas aisé si aucune condition particulière n’est fixée sur le choix des pi etqi. La division dePn

i=1p_iet dePn

i=1q_ipar 2 ou 4 pose problème si lesp_ietq_isont impairs. Comment savoir qui doit poserbp_i/2cetdp_j/2eoudp_i/2eetbp_j/2centre les participantsPietPj?

Si4 divisepi etqi pour tous les serveurs sauf pouri = 1, où p1 ≡ q1 ≡ 3 mod 4, on obtient le partage suivant dem:

m= ϕ(N)

4 = N −p₁−q₁+ 1

4 −

i=2

p_i+q_i 4

carpgcd(p−1, q−1) = 1etp ≡q ≡3 mod 4. La part du premier serveur est ^N−p¹₄^−q¹⁺¹ qui est un entier carp1+q1 ≡2 mod 4etN + 1≡2 mod 4. La part des autres serveurs est clairement un entier et donc, chaque serveur peut calculer sa part dem sans protocole supplémentaire à partir du partage deϕ(N). De manière identique, on peut générer un partage deλ(N). Pour assurer la robustesse de ce partage, les serveurs doivent être sûrs queP1et tous les autres serveurs ont correctement choisi leurspi

etq_i. Pour ce faire,P₁fait une preuve qu’il connaît le logarithme discret deg^p¹⁻³et deg^q¹⁻³ en baseg⁴ et tous les autres, qu’ils connaissent le logarithme discret deg^pⁱ etg^qⁱ en baseg⁴. Ces preuves sont des preuves à la Schnorr pourgun générateur d’un sous-groupe d’ordreQdeZ^∗_P oùP est un nombre de la formeP = 2Q+ 1avecP etQpremiers etQ≥2^L(N)² ⁺¹oùL(N)représente la taille deN en bits.

Génération deθ

Les serveurs doivent encore générer un nombre aléatoire β et calculer θ = amβ modN. Pour ce faire, les serveurs génèrent g aléatoirement dans Z^∗_N2. Puis, chaque serveur tire aléatoirement un nombre,α_i dans l’intervalle[0, N[. Les serveurs calculent ensuiteY = g^βu^N modN² en utilisant par exemple le protocole que l’on décrira dans le chapitre 6. Dans ce chapitre, nous décrivons un protocole pour générer une clé Diffie-Hellman de manière partagée, alors qu’ici nous voulons générer un chiffré de Paillier Y. Ainsi, au lieu de calculer une clé publique Diffie-Hellman, g^αⁱ modp, chaque serveur génère un chiffrement deαi. A la fin, du protocole de génération de clé Diffie-Hellman, les serveurs ont engendré un chiffré de Paillier de la “clé secrète”β. Ensuite, les serveurs calculent de manière partagée Y^λ(N) = g^βλ(N)u^{N λ(N}⁾modN²et obtiennentaβλ(N) modN. Enfin, ils en déduisentaβmmodN carλ(N) = 2m. Il reste que chaque serveur doit faire un partage de Feldman dansZ^∗_N2 et non dansZ^∗_p (cf. chapitre 2).

Chaque serveur effectue un partage à la Shamir de sa part α_i en choisissant un polynôme aléatoire fitel quefi(0) =αiettcoefficientsai,kau hasard dansZN et pose

fi(X) =

k=0

ai,kX^k∈ZN

La part du joueurjest alors définie comme la valeur du polynômefienj, soitfi(j) modN. Puis, il tire aléatoirementu₀, u₁, . . . , u_t, et calcule pour chaque coefficient,A_i,k =g^a^i,ku_kmodN². Il broadcaste ces valeurs sur un canal public ainsi quef_i(j)sous forme chiffrée auj-ème serveur en utilisant les clés publiques de Paillier (g_j, N_j) et (g, N). Pour ce faire, il calcule u⁰_j = Qt

k=0u^j_k^k modN et c⁰_i,j = g^fⁱ^(j)u^0N_j modN², tire aléatoirementu⁰⁰_j ∈Z^∗_N_j et calculec⁰⁰_i,j =g_j^fⁱ^(j)u⁰⁰^N_j^j modN_j². Enfin, le serveur ifait une preuve publiquement vérifiable queD_sk(c⁰_i,j) =D_sk_j(c⁰⁰_i,j). Un tel exemple de preuve est donné dans le chapitre 5.

Tous les serveurs peuvent vérifier la partfi(j) =αi,jdeαien calculant c⁰_i,j =^?

k=0

A^j_i,k^k =g^fⁱ^(j)×

" _t Y

k=0

u^j_k^k

=g^α^i,j×[u⁰_j]^N modN²

Ainsi, nous avons complètement distribué le déchiffrement de Paillier⁵⁰.

50. Si nous voulons partager le cryptosystème de Goldwasser et Micali, nous devons pouvoir décider si un nombrexest un

Cryptosystèmes partagés sûrs contre les attaques à chiffrés choisis

Dans ce chapitre, nous décrivons l’article [74] qui sera présenté avec David Pointcheval à la confé-rence Asiacrypt ’01. Dans cet article nous avons réhabilité le modèle du double-chiffrement proposé par Naor et Yung pour proposer un schéma de conversion générique pour tout cryptosystème sémantique-ment sûr contre les attaques passives en cryptosystème à seuil sémantiquesémantique-ment sûr contre les attaques adaptatives à chiffrés choisis. En particulier, nous proposons une version du cryptosystème de Paillier sûr dans ce modèle, ce qui fournit le premier schéma de ce type basé sur la factorisation. De plus, nous revisitons la notion de sécurité dans le cas distribué.

Sommaire

5.1 Introduction . . . 128 5.1.1 Sécurité contre les attaques à chiffrés choisis . . . 128 5.1.2 Problématique du partage de cryptosystèmesIND-CCA . . . 128 5.1.3 Solutions existantes . . . 129 5.1.4 Preuves Zero-Knowledge Non-Interactives . . . 130 5.1.5 Proposition de schémasIND-CCAà seuil . . . 131 5.2 Modèle de sécurité . . . 131 5.2.1 Hypothèses sur le canal de communication . . . 131 5.2.2 Classification des adversaires . . . 132 5.2.3 Systèmes de chiffrement à seuil . . . 132 5.2.4 Notions de sécurité . . . 132 5.3 Conversion générique . . . 134 5.3.1 Description . . . 134 5.3.2 Preuve Non-Interactive Zero-Knowledge . . . 135 5.3.3 Preuve de sécurité . . . 135 5.3.4 Adversaire passif . . . 135 5.3.5 Adversaire actif . . . 138 5.4 Exemples . . . 138 5.4.1 Cryptosystème El Gamal . . . 138 5.4.2 Cryptosystème de Paillier . . . 140 5.5 Conclusion . . . 142

5.1 Introduction

5.1.1 Sécurité contre les attaques à chiffrés choisis

La sécurité sémantique contre les attaques adaptatives à chiffrés choisis représente la définition de sécurité correcte pour un système de chiffrement [98, 160, 5]. Par conséquent, un grand nombre de travaux [81, 83, 82, 147, 134] ont récemment proposé des schémas pour convertir toute fonction à sens unique en un système de chiffrement sûr selon cette notion de sécurité.

Avant cette notion, Naor et Yung dans [129] ont proposé une notion de sécurité plus faible, appelée attaque de midi (Lunch-time attack), ou encore attaque indifférente à chiffrés choisis ou non-adaptative.

L’adversaire ne peut demander des déchiffrements qu’avant de recevoir le chiffré cible. Naor et Yung [129] ont présenté une conversion pour sécuriser des schémas contre des attaques à chiffrés choisis dans le scénario lunch-time. Ils ont utilisé des systèmes de preuves non-interactive zero-knowledge (preuve d’appartenance à un langage [23, 22]) pour montrer la consistance d’un chiffré, et non pour prouver que la personne qui a construit le chiffré “connaît nécessairement son déchiffrement”.

Ensuite Rackoff et Simon [160] ont rafiné cette construction en remplaçant les preuves non-interactive d’appartenance à un langage par des preuves zero-knowledge de connaissance. Par conséquent, à tout chiffré est ajoutée une preuve non-interactive de connaissance du clair. Ceci conduit à des systèmes de chiffrement sûrs contre des attaques adaptatives à chiffrés choisis. En effet, l’émetteur prouve qu’il connaît le clair et par conséquent, les attaquesCCAne peuvent être que des attaquesCPA.

Une notion similaire dite “plaintext-awareness” [10, 5] a été ensuite définie. Un schéma possède cette propriété si pour produire un chiffré valide, la connaissance du clair correspondant est nécessaire. Pour prouver cette propriété, il faut construire un “plaintext-extractor” qui est un algorithme permettant de déchiffrer en ayant accès à un oracle. Si nous ne sommes pas dans un modèle de sécurité à oracle, et que nous sommes dans le modèle standard, l’existence de cette machine de Turing revient à savoir déchiffrer sans avoir la clé secrète. Ainsi, cette dernière notion ne prend son sens que dans un modèle à oracle comme celui de l’oracle aléatoire [9]⁵¹. Par exemple, le cryptosystème Cramer-Shoup [55] prouvé sûr IND-CCAdans le modèle standard ne vérifie pas cette propriété de “plaintext-awareness”.

Pendant de nombreuses années, plusieurs schémas ont été proposés pour atteindre la notion de sé-curité IND-CCA. La plupart d’entre eux a été prouvée dans le modèle de l’oracle aléatoire [10, 84, 175, 140, 81, 82, 83, 147, 134] en utilisant la propriété de plaintext-awareness. Seul le cryptosystème Cramer-Shoup [55] a été prouvéIND-CCAdans le modèle standard.

5.1.2 Problématique du partage de cryptosystèmesIND-CCA

Pour distribuer les processus de déchiffrement, des techniques similaires à celles pour signer un mes-sage peuvent être utilisées pour éviter les attaques à clairs choisis par des adversaires passifs. Cependant, ces méthodes ne permettent pas d’éviter les attaques à chiffrés choisis. En effet, en général, les serveurs ne peuvent pas commencer le déchiffrement sans savoir si le chiffré est valide ou non parce qu’un atta-quant peut se faire passer pour un des serveurs et, dans le cas de chiffrés invalides, il peut alors apprendre de l’information.

Par conséquent, quand on cherche à partager un système de chiffrement, on ne peut pas attendre la fin du déchiffrement pour savoir si les serveurs peuvent réellement déchiffrer ou non. Ainsi, nous devons intégrer des preuves de validité du chiffré qui soient publiquement vérifiables. Malheureusement, la plupart des systèmes de chiffrement connus sûrs contre des attaques à chiffrés choisis ne sont pas facilement partageables. En effet, dans les processus de déchiffrement, les clairs supposés sont déchiffrés,

51. Le modèle de l’oracle aléatoire n’est pas le seul modèle à oracle. Le modèle générique [173] est aussi un modèle à oracle.

et ensuite une redondance est vérifiée juste avant de retourner le clair. Comme la redondance met en jeu une fonction de hachage, la vérification finale ne peut pas être distribuée de manière efficace.

5.1.3 Solutions existantes

Il existe deux méthodes pour distribuer le processus de déchiffrement d’un système de chiffrement.

Alors que le premier utilise de l’aléa, le second suit le modèle décrit par Lee et Lim dans [121] dans lequel pour rendre un système de chiffrement sûr contre les attaquesCCAle processus de déchiffrement initial est renversé : le destinataire commence par vérifier si le chiffré est valide avant de déchiffrer.

Preuve de validité vérifiable uniquement par le possesseur de la clé secrète

La première méthode a été proposée par Canetti et Goldwasser dans [37]. Dans le système de chif-frement Cramer-Shoup [55], le destinataire peut vérifier la validité d’un chiffré en utilisant une partie de la clé secrète, avant de déchiffrer le chiffré valide en utilisant la deuxième partie de la clé secrète. Par conséquent, on peut penser qu’il est facile de partager ce système de chiffrement. Mais au lieu de vérifier la validité du chiffré dans un premier tour et de déchiffrer selon la validité, Canetti et Goldwasser [37]

ont proposé une nouvelle stratégie avec seulement un tour. Les serveurs déchiffrent tout chiffré soumis et le processus de déchiffrement est randomisé. Les serveurs calculentm(v⁰/v)^soùsest un aléa partagé entre les serveurs (une partie de la clé secrète),vla preuve contenue dans le chiffré, etv⁰ la preuve cal-culée par les serveurs. Dans la version centralisée, le processus de déchiffrement vérifiev=^? v⁰. Dans la version distribuée, si la preuve est correcte,(v/v⁰)^s = 1et le déchiffrement donnem, sinon il retourne une valeur aléatoire. Personne ne sait alors si le message déchiffré est correct ou non, s’il n’y a pas de redondance dans le clairm. Une solution est de déchiffrer deux fois le même chiffré. Si les résultats sont identiques, le message était bien formé. Le principal inconvénient est que les serveurs doivent conserver dans la clé secrète un partage de l’aléaset ainsi, la longueur de la clé est linéaire en le nombre de mes-sages déchiffrés. Par conséquent, même si la méthode basique en deux tours apparaît plus lente, vérifier la preuve et déchiffrer, elle possède des caractéristiques intéressantes en termes de stockage de la clé et évite l’utilisation d’un protocole de calcul d’un aléa partagé.

Preuve de validité universellement vérifiable

La première méthode de Canetti et Goldwasser est malheureusement spécifique au système de chif-frement de Cramer et de Shoup. La méthode qui commence par vérifier la preuve et déchiffrer ensuite est applicable à d’autres cryptosystèmes mais aucun autre n’a ce type de preuve. La seconde méthode, utilisée par Shoup et Gennaro [175], suit l’article de Lee et Lim [121], avec le système de chiffrement El Gamal [66], mais dans le modèle de l’oracle aléatoire [9]. Initialement, ils ont tenté d’ajouter une preuve non-interactive de connaissance d’un logarithme discret, en utilisant la signature de Schnorr [166]. Mais, ils ont remarqué que la simulation du déchiffrement sans la clé secrète nécessitait un temps exponentiel dû à l’explosion combinatoire du lemme de bifurcation [150, 151].

En effet, le problème est dans la simulation de l’oracle de déchiffrement. Pour simuler le déchiffre-ment, il faut extraire de la signature le random r qui a permis de chiffrer. La preuve de sécurité de la signature de Schnorr (cf. chapitre 2) faite par Pointcheval et Stern utilise le forking lemma qui permet de rembobiner la machine et fournir au signataire un deuxième challenge comme résultat de la fonction de hachage. Les deux équations de vérification obtenues à partir des deux challenges différents permettent d’extraire le randomr. Soit par exemple un adversaire qui choisit`randomsriet des messages clairsmi

de façon à ce qu’ils dépendent tous les deux des challengese_i précédents,r_i = m_i =H(e₁, . . . , ei−1) fournis par l’oracle de hachage. Puis, l’adversaire demande à l’oracle de déchiffrement, le déchiffré des

chiffrésc`, . . . , c1. L’adversaire fait alors une première requête de déchiffrement,c`. Le simulateur doit donc rembobiner l’adversaire jusqu’au point où il a obtenu le challenge e_` de l’oracle H et envoie à l’adversaire un challenge différente⁰_`. On continue et quand il présente un chiffréc⁰_`correspondant, on peut extrairer` et déchiffrerc`. Maintenant, l’adversaire continue et fait une requête de déchiffrement pour c`−1. On rembobine l’adversaire jusqu’au point où il a obtenu la réponsee`−1 de l’oracle H et on envoie un challengee⁰`−1différent. Si l’on poursuit, avant que l’algorithme de l’adversaire émette la requêtec⁰`−1, il va demander de déchiffrerc⁰⁰_`. Malheureusement, on ne peut pas déchiffrer car en général r_`⁰⁰6=r_`etm⁰⁰_` 6=m_`car ils sont tous les deux,(r_`⁰⁰, m⁰⁰_`), calculés comme le haché dee₁, . . . , e`−2, e⁰`−1

avec e⁰`−1 6= e`−1. Nous devons donc rembobiner l’adversaire jusqu’au point où il a obtenue⁰⁰_` et re-commencer pour déchiffrerc⁰⁰_`. Il est clair qu’un tel adversaire force le simulateur à s’exécuter en temps proportionnel à2^`.

Cette explosion peut être évitée sous des hypothèses plus fortes [168]. Pour résoudre cette explosion combinatoire, Gennaro et Shoup ont utilisé des preuves non-interactives d’appartenance à un langage (comme dans [129]) pour éviter l’extraction (cf. chapitre 2), et ainsi l’explosion combinatoire dans la simulation du déchiffrement. En fait, la simulation du processus de déchiffrement ne peut pas éviter le rembobinage de la machine. Le problème est le même que dans le cadre du zero-knowledge resettable (cf.

chapitre 2). Par conséquent, le même genre de techniques de preuve d’appartenance à un langage difficile peut être utilisé [6]. Nous pouvons remarquer que la preuve de connaissance de Rackoff et Simon est en même temps une preuve d’appartenance et une preuve de connaissance. Dans ce système de chiffrement, il y a deux clés comme dans [129] : la première appartient au destinataire, mais la seconde appartient à l’émetteur. Comme le prouveur possède une des deux clés, il peut déchiffrer et obtenir le clair. Par conséquent, la preuve devient une preuve de connaissance pour un émetteur spécifique. L’émetteur peut alors déchiffrer tous les messages et comme la preuve est une preuve d’appartenance, nous pouvons la simuler sans utiliser de technique de rembobinage.

5.1.4 Preuves Zero-Knowledge Non-Interactives

Le modèle proposé par Naor et Yung utilise les preuves non-interactives zero-knowledge d’apparte-nance à un langage dans le modèle d’un ruban aléatoire commun. Le même messagemest chiffré sous deux clés publiques différentes. On obtient donc a₀ et a₁ et l’émetteur ajoute une preuve que le mot (a₀, a₁)appartient au langage L = {(a, b) tqD(a₀) = D(a₁)}. En 1990, les preuves non-interactives d’appartenance à un langage [23, 22] supposaient l’existence d’un ruban aléatoire commun entre le prou-veur et le vérifieur comme ruban d’aléa. A cause de ce ruban commun, ils ont dû restreindre la puissance du modèle de sécurité aux attaques lunch-time. En effet dans une attaque à chiffrés choisis, l’adversaire pourrait être capable à partir du chiffré cible (a^∗₀, a^∗₁,preuve^∗) de forger une nouvelle preuve preuve⁰ d’appartenance pour le même couple(a^∗₀, a^∗₁). Dans la phase “guess”, dans le cas d’une attaque adap-tative, l’adversaire a le droit de poser la requête de déchiffrement du chiffré suivant :(a^∗₀, a^∗₁,preuve^0∗).

Ainsi, l’oracle de déchiffrement renvoie le clair et l’adversaire pourrait gagner son jeu (one-wayness ou sécurité sémantique par exemple). Mais Naor et Yung n’ont pas pu prouver que la preuve d’apparte-nance ne pouvait pas être modifiée par l’adversaire s’il ne connaissait pas le clairm. Récemment, cette propriété a été considérée dans [164], mais seulement pour des systèmes de preuve théoriques.

Dans ce chapitre, nous utilisons l’hypothèse idéale du modèle de l’oracle aléatoire [9], qui dit que les fonctions de hachage se comportent comme de véritables fonctions aléatoires. Ceci permet de construire des preuves zero-knowledge non-interactives efficaces sans hypothèse de ruban d’aléa commun, et d’at-teindre une forme plus faible de non-malléabilité, mais suffisamment forte pour notre propos, appelée significativité simulable [164].

Significativité simulable.

Soit un langageLet un système de preuve non-interactive zero-knowledge pourL. Pour tout adver-saireA, ayant accès à une preuvep^?, pour un motx^?, en dehors ou dansL, nous considérons sa capacité à forger une nouvelle preuve p, pour un mot en dehors deL. Par conséquent, pour tout adversaireA, nous considérons

Succ^sim−nizk(A) =Pr

(x, p)← A(Q)|x∈L ∧¯ (x, p)6∈Q ,

ayant accès à une liste bornée Q de mots prouvés(x^?, p^?), où le mot w^? est n’importe quel mot (en dehors ou dans le langageL) etp^? une preuve acceptée pourw^?. Nous notons parL¯le complément de L, soit l’ensemble des mots en dehors du langageL.

Plus généralement, nous notonsSucc^sim−nizk(t)la probabilité de succès maximale sur tous les ad-versaires, ayant un temps d’exécution borné part, pour forger une nouvelle preuve acceptée pour un mot non valide, même après avoir vu un nombre borné de preuves pour des mots (non) valides. Dans notre situation, ce nombre borné sera simplement un.

Ceci est une notion plus forte que la significativité classique pour des preuves zero-knowledge interactives, mais est plus faible que la malléabilité. En effet, Sahai [164] a montré que la non-malléabilité de preuves non-interactives zero-knowledge impliquait cette notion, qu’il a appelée signifi-cativité simulable.

Comme nous le verrons dans la suite, dans le modèle de l’oracle aléatoire, nous pouvons faire des preuves efficaces qui atteignent ce niveau de sécurité.

5.1.5 Proposition de schémasIND-CCAà seuil

A PKC ’99, Fujisaki et Okamoto [81] ont proposé une conversion générique de n’importe quel sys-tème de chiffrementIND-CPAen un schémaIND-CCA, dans le modèle de l’oracle aléatoire [9]. Dans ce chapitre, nous revisitons la technique de double-chiffrement de Naor etYung [129], en fournissant une conversion générique de tout système de chiffrement IND-CPAen un schémaIND-CCAavec une preuve de validité publiquement vérifiable. Cette conversion fournit des systèmes de chiffrement à seuil sûrs contre des attaques à chiffrés choisis. Nous présentons de plus des instanciations pratiques dans le modèle de l’oracle aléatoire qui atteignent le niveau de sécuritéIND-CCAcontre des adversaires actifs.

5.2 Modèle de sécurité

5.2.1 Hypothèses sur le canal de communication

Nous supposons un groupe de n serveurs probabilistes tous connectés à un medium commun de broadcast, appelé le canal de communication. Il peut être vu comme un canal asynchrone comme Internet.

5.2.2 Classification des adversaires

L’adversaire est calculatoirement borné. De plus, il peut corrompre des serveurs à n’importe quel moment en ayant accès à la mémoire des serveurs corrompus (adversaire passif), et/ou en modifiant leur fonctionnement (adversaire actif). L’adversaire décide quels serveurs il veut corrompre au début du protocole (adversaire statique). Nous supposons aussi que l’adversaire ne corrompt pas plus detserveurs parminau cours du protocole, oùn≥2t+ 1.

5.2.3 Systèmes de chiffrement à seuil

Un système de chiffrement à seuiltparmincomprend les composants suivants :

– Un algorithme de génération de clésK qui prend comme entrées un paramètre de sécurité en notation unaire1^k, le nombrende serveurs de déchiffrement, et un paramètre de seuilt; il retourne une clé publiquepk, une listesk₁, . . . ,sk_nde clés privées (qui correspondent à un partage de la clé privéesk) et une listevk₁, . . . ,vk_nde clés de vérification.

– Un algorithme de chiffrementEqui prend en entrée la clé publiquepket un clairm, et retourne un chiffréc.

– Plusieurs algorithmes de déchiffrementD_i(pour1≤i≤n) qui prennent en entrée la clé publique pk, la clé privéesk_i, un chiffréc, et retourne une part de déchiffrementσ_i(qui peut contenir une part de vérification pour atteindre la propriété de robustesse).

– Un algorithme de combinaison qui prend en entrée la clé publiquepk, un chiffréc, et une liste σ1, . . . , σnde parts de déchiffrement (ou au moinst+ 1parmi elles), avec les clés de vérification vk₁, . . . ,vk_n, et retourne un clairmou rejette si moins det+1parts de déchiffrement sont correctes dans le cas d’adversaire actif. Tous les utilisateurs peuvent faire tourner cet algorithme.

5.2.4 Notions de sécurité

Dans cette section, nous définissons le jeu qu’un adversaire joue et tente de gagner afin d’atteindre le but de l’attaque. Les adversaires contre les systèmes de chiffrement à seuil tentent d’attaquer les propriétés suivantes :

– Sécurité de la primitive sous-jacente. Dans le cas de système de chiffrement, ceci signifie la one-wayness, la sécurité sémantique [98], ou la non-malléabilité [65].

– Robustesse. Cette propriété assure que les joueurs corrompus ne sont pas capable d’empêcher les serveurs non-corrompus de déchiffrer des chiffrés. Cette notion est utile seulement en présence d’adversaires actifs. En d’autres termes, elle dit que le service de déchiffrement est toujours dis-ponible même si l’adversaire peut envoyer de mauvaises parts de déchiffrement.

Un utilisateur qui souhaite déchiffrer un chiffrécl’envoie à un serveur spécial, appelé le combineur, qui le transmet à tous les serveurs. Les serveurs commencent par vérifier la validité du chiffré, calculent leur part de déchiffrementσi et la retournent au combineur. Ce dernier recombine les parts de déchiffre-ment pour obtenir le clairmet le retourne à l’utilisateur. Si nous voulons résister aux adversaires actifs, le combineur doit pouvoir décider de la validité des partsσide déchiffrement qu’il reçoit. Une manière élégante consiste à utiliser des protocoles de vérifications [79], et des clés de vérification sont alors né-cessaires. Le but des protocoles de vérification est de permettre à chaque serveur de prouver aux autres qu’il a effectué correctement sa tâche.

Sécurité sémantique

Dans la suite, nous nous focalisons sur l’objectif de sécurité sémantique [98], noté IND, et nous oublions toutes les autres notions de sécurité (one-wayness et non-malléabilité.) Par conséquent, le jeu à considérer est le suivant :

1. L’algorithme de génération de clésKest exécuté. L’adversaire reçoit par conséquent la clé publique pk. Avec cette clé publique, l’adversaire a la capacité de chiffrer tout clair de son choix (d’où le nom “attaque à clairs choisis”).

Dans le document Le partage de clés cryptographiques : Théorie et Pratique (Page 117-132)