Thesis 1 30 FR - Merged

Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux.
Visitez www.DeepL.com/propour en savoir plus.
Un nouveau cryptosystème McEliece basé sur le LDPC
Pedro de Melo Branco
Thèse pour obtenir le Master of Science Degree en
Matemática e Aplicações
Superviseur : Prof. Paulo Alexandre Carreira Mateus
Comité d'examen
Présidente : Prof. Maria Cristina De Sales Viana Serôdio Sernadas
Superviseur : Prof. Paulo Alexandre Carreira Mateus
Membre du Comité : Prof. André Souto
Octobre 2017
ii
Remerciements
Ce fut un plaisir de travailler avec le professeur Paulo Mateus. Je tiens à le remercier d'avoir supervisé
cette thèse.
iii
iv
Resumo
O sistema cp
rio
tgra'fico McEliece foi apresentado por Robert McEliece e e' um dos mais antigos cripto-
sistemas de chave-pu'blica que ainda estaõ por quebrar. A sua simplicidade e a sua eficieˆncia tornam-
no num candidato interessante para a era po's-quaˆntica dado que se conjectura que e' seguro contra
ataques quaˆnticos.
Nesta dissertaçaõ, analisamos o sistema cp
rio
tga
r' fico McEliece. Nous présenterons ses avana
tgeset ses
inconvénients, ainsi que ses principes fondamentaux. Vamos a
tmbe'm apresentar alguns conceitos
ba'sicos de teoria dos co'digos de modo a compreender totalmente o sistema cp
rio
tgra'fico McEliece.
Propomos um sistema cp
ritogra'fico eficiente baseado no McEliece para tratar blocos de mensagens
grandes e que pode ser facilmente implementado em hardware. Para conseguirmos isso, usamos
co'digos LDPC no sistema cripo
tgra'fico McEliece tirando partido das suas capacidades para tratar blocos de
mensagagens grandes. Conjecture-se que o sistema cp
rio
tgra'fico proposto seja resistente a ataques
quaˆnticos vu qu'a sua segurança esta' alavancada na segurança do sistema cp
rio
tga
r' fico McEliece. Ae
l' m
disto, provamos que o sistema cp
rio
tga
r' fico e' taõ dif'ıcil de quebrar como o McEliece. Fomos capazes de
reduzir significativemente o tamanho da chave do sistema cp
rio
tgra'fico McEliece, um dos seus maiores
problemas e a principal razaõ pela qual naõ e' usado na pra'ctica. Analisamos a
tmbe'm a sua eficieˆncia
e propomos uma versaõ IND-CCA2 segura alavancadas em alguns problemas que se conjecturam
dif'ıceis.
Palavras-chave : criptografia, teoria de co'digos, encriptaçaõ de chave-pu'blica, sistema crip-

o
tgra'fico McEliece, co'digos LDPC, indistinguibilidade.
v
vi
Résumé
Le système de cryptage de McEliece a été présenté pour la première fois par Robert McEliece et est
l'un des plus anciens systèmes de cryptage à clé publique qui reste inviolable. Sa simplicité et son
efficacité en font un candidat très intéressant pour l'ère post-quantique puisqu'il est supposé être
sécurisé contre un ordinateur quantique.
Dans cette thèse, nous analysons le cryptosystème McEliece. Nous passerons en revue ses
avantages et ses inconvénients ainsi que ses fondements. De plus, nous présentons quelques
concepts de base de la théorie du codage afin de bien comprendre le système cryptographique de
McEliece.
De plus, nous proposons un cryptosystème efficace basé sur McEliece pour traiter de grands
messages et qui peut être facilement implémenté en matériel. Pour ce faire, nous utiliserons des
codes LDPC dans le cryptosystème de McEliece en tirant parti de leur capacité à traiter de grands
blocs de messages. Le cryptosystème proposé est conjecturé être robuste aux attaques quantiques
puisqu'il repose sur la sécurité du cryptosystème McEliece. De plus, nous prouvons que ce
cryptosystème est au moins aussi difficile à casser que le McEliece. Nous avons été capables de
réduire significativement la taille des clés du cryptosystème, un de ses problèmes majeurs et la raison
principale pour laquelle il n'est pas utilisé dans le monde réel. Nous analysons également son
efficacité et proposons une variante sécurisée IND-CCA2 sous certaines hypothèses difficiles.
vii
Mots clés : cryptographie, théorie du codage, cryptage à clé publique, cryptosystème de
McEliece, codes LDPC, indiscernabilité.
viii
ix
Contenu
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii
1 Introduction 1
2 Théorie du codage 3
2.1 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Codes Goppa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Codes LDPC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3 Schéma de cryptage à clé publique 17

3.1 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Notions de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 Indistinction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.2 Non-malléabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.3 Relations entre les notions de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Connaissance du texte brut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Conversion générique Fujisaki-Okamoto IND-CCA2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4 Cryptosystème de McEliece 25
4.1 Le système cryptographique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.1.1 Le cryptosystème de Niederreiter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.2 Sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.3 Efficacité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.4 Variants de IND-CCA2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.5 Utilisation des codes LDPC dans le PKC de McEliece . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
..
5 Un nouveau cryptosystème : McEliece basé sur le LDPC 43
5.1 Proposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.2 Sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3 Efficacité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.4 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
x
5.5 De l'indiscernabilité du McEliece basé sur le LDPC ......................................................................... 56
6 Conclusions 61
Bibliographie 63
xi
Chapitre 1
Introduction
La cryptographie vise à fournir des moyens de communication sécurisés entre deux parties et en
présence d'un tiers malveillant. Jusqu'au XXe siècle, la cryptographie était principalement axée sur la
conception de systèmes de cryptage utilisant des codes ou des techniques similaires. Mais avec
l'avènement de l'internet, la cryptographie est devenue un sujet crucial dans notre vie quotidienne. Les
chercheurs ont commencé à utiliser les mathématiques pour la conception de protocoles
cryptographiques, et à l'heure actuelle, la cryptographie est considérée comme un sous-domaine des
mathématiques.
La cryptographie post-quantique est un sous-domaine de la cryptographie qui traite des algo-
rithmes cryptographiques classiques qui sont conjecturés comme étant robustes contre les attaques
quantiques. Il s'agit d'un domaine en plein essor depuis que Shor a prouvé que les ordinateurs
quantiques peuvent briser les protocoles cryptographiques les plus utilisés de nos jours [51], tels que
les cryptosystèmes RSA [47] et El Gamal [17]. Pour cette raison, beaucoup pensent que les
protocoles post-quantiques seront largement utilisés dans un avenir proche. La cryptographie post-
quantique est basée sur des problèmes difficiles qui sont considérés comme insolubles par les
ordinateurs quantiques, tels que les problèmes basés sur les treillis, les codes ou les polynômes
multivariés [10].
Dans cette thèse, nous nous concentrerons principalement sur un protocole de cryptage basé sur
un code : le cryptosystème McEliece [39]. C'est l'un des plus anciens cryptosystèmes qui reste
inviolable. Il a été proposé par Robert McEliece en 1978, peu après la présentation du cryptosystème
RSA. Le cryptosystème de sécurité est basé sur des problèmes qui sont supposés être insolubles par
les ordinateurs quantiques et donc le cryptosystème est supposé être robuste contre les attaques en
temps polynomial quantique. Cependant, le système de cryptage de McEliece présente encore
quelques problèmes, notamment la taille de sa clé, qui est probablement son principal problème [18],
et son temps de décryptage [38]. Ce cryptosystème fait donc l'objet d'études approfondies de la part
des cryptographes, non seulement pour réduire la taille de sa clé, mais aussi pour améliorer sa
sécurité contre les attaques connues et pour améliorer ses temps de cryptage et de décryptage.
Les codes Goppa [5] sont la famille de codes utilisée dans le McEliece original. Il y a eu des
tentatives d'utiliser d'autres familles de codes dans le cryptosystème, mais elles ont toutes échoué (voir,
1
par exemple, [41, 52]). Le problème avec les codes de Goppa est que leur algorithme de décodage ne
s'adapte pas bien, ce qui rend l'algorithme de décryptage du cryptosystème McEliece trop lent pour
les grands messages, en particulier dans les implémentations matérielles [38].
Nous proposons un nouveau cryptosystème basé sur McEliece qui utilise les codes de Goppa, la
famille utilisée dans les
2
original McEliece, et les codes LDPC, une famille de codes basés sur des graphes et qui permet un
décodage rapide sur le matériel. Cette nouvelle construction permet un cryptage et un décryptage
rapides à la fois dans le logiciel et dans le matériel et s'adapte très bien aux grands messages,
résolvant ainsi le problème présenté ci-dessus. De plus, avec cette construction, nous sommes
capables de réduire la taille de la clé jusqu'à dix fois par rapport au McEliece original. Cependant,
cette construction ne répond pas à certaines notions de sécurité importantes telles que
l'indiscernabilité ou la non-malléabilité. Nous présentons donc une variante de la construction qui
répond à ces notions de sécurité et qui peut être utilisée en pratique avec un coût supplémentaire très
faible.
Plan de la thèse
Dans le chapitre 2 de cette thèse, nous commençons par introduire quelques notions de base sur la
théorie du codage, afin d'introduire plus tard dans le chapitre deux familles de codes : la famille des
codes de Goppa, qui est une famille de codes très importante pour la cryptographie, et la famille des
codes LDPC, où la recherche récente en théorie du codage s'est concentrée. L'introduction de ces
deux familles de codes est essentielle pour la compréhension des chapitres suivants. Dans le chapitre
3, nous continuons à introduire les concepts de base, mais maintenant sur la cryptographie à clé
publique, une idée cruciale en cryptographie. Nous définissons également quelques notions de
sécurité dont nous aurons besoin pour notre étude.
Après que le lecteur se soit familiarisé avec certains concepts de base de la théorie des codes,
avec ces classes de codes et avec la cryptographie, nous expliquons dans le chapitre 4 comment les
codes peuvent être utilisés en cryptographie, notamment en présentant deux systèmes
cryptographiques basés sur des codes : les systèmes McEliece et Niederreiter. Nous nous
concentrerons principalement sur la sécurité et l'efficacité du cryptosystème McEliece. En même
temps, nous donnerons quelques définitions importantes de la sécurité.
Les principaux résultats de cette thèse sont présentés dans le chapitre 5, où nous proposons un
nouveau cryptosystème basé sur des codes utilisant des codes Goppa et LDPC. Nous présentons
également quelques variations qui permettent d'atteindre certaines notions de sécurité importantes (à
savoir IND-CPA et IND-CCA2) et les preuves de sécurité correspondantes.
Enfin, dans le chapitre 6, nous exposons quelques réflexions pour conclure cette thèse ainsi que
quelques directions de travaux futurs.
3
Chapitre 2
Théorie du codage
Dans le monde réel, lorsque nous voulons envoyer un message à quelqu'un d'autre, ce message est
généralement envoyé par un canal bruyant. Cela signifie que le récepteur recevra probablement le
message avec des erreurs, typiquement des bits inversés (où est censé être un 1, il apparaît 0 dans le
message reçu par exemple) ou des bits effacés. Nous pouvons résoudre ce problème en utilisant des
codes qui détectent ces erreurs et, idéalement, les corrigent. La théorie du codage est l'étude des
codes et de leurs propriétés. Elle est apparue dans les années 40, principalement grâce aux travaux
développés par Claude Shannon [49] et, depuis, c'est un domaine en pleine expansion. Comme elle a
de nombreuses applications dans le monde réel, la théorie du codage est un sujet très intéressant
pour les mathématiciens, les informaticiens, les ingénieurs électriques, les informaticiens, etc. Les
études sur la théorie du codage consistent généralement à essayer de construire efficacement des
codes et à trouver des algorithmes efficaces de détection et de correction des erreurs dans ces codes.
Nous commencerons ce chapitre par une brève introduction à la théorie du codage, en présentant
quelques notations et résultats de base dans la Section 2.1. Ensuite, dans la Section 2.2, nous nous
concentrerons sur les codes de Goppa, une famille de codes très utile pour la cryptographie. Enfin,
dans la Section 2.3, nous présenterons les codes LDPC, une famille de codes qui a été récemment
présentée ; nous commencerons par quelques notions de théorie des graphes, puis nous
présenterons quelques constructions de ces codes.
2.1 Notions de base
Nous commençons cette section par quelques notations : si S est un ensemble, |S| désigne le
nombre d'éléments dans S. Nous désignerons un champ par F. Un champ fini avec q éléments sera
désigné par Fq , où q est un nombre premier ou qune puissance d'un nombre premier. Par espace
vectoriel Fn , nous entendons un espace vectoriel dont les vecteurs ont des coordonnées dans qF .1
q
Nous définissons la distance de Hamming d(v, u) de deux vecteurs v, u dans un espace vectoriel F n
comme suit
le nombre de coordonnées de ces vecteurs qui sont différentes les unes des autres, soit
4
d(v, u) = #{i : vi /= ui }.
1 Tout au long de cette thèse, nous ferons souvent référence au champ à deux éléments, F2 , par Z2 = Z/(2) = {0, 1}.
5
Le poids de Hamming d'un vecteur v ∈ V est le nombre de coordonnées qui ne sont pas nulles. Nous
le désignerons par wt(v).
Un code linéaire C de longueur n sur un champ Fq est unq sous-espace de Fn . La distance
minimale de Hamming, ou distance minimale, d'un code C est la distance minimale entre deux mots2
quelconques du code. Par un

Par code [n, k, d]q , on entend un code C dont les mots de code ont des symboles dans Fq , avec une
longueur n, une dimension k et une distance de Hamming minimale d entre deux mots de code
quelconques. Tout au long de cette thèse, lorsque nous faisons référence à un code C, nous
entendons un code [n, k, d]q , sauf indication contraire. De même, lorsque nous omettons q, cela
signifie que q = 2.
Trouver la distance minimale d'un code donné n'est pas un problème trivial, en fait c'est un
problème NP -complet [59] ; mais il y a certaines classes de codes pour lesquelles cette valeur est
connue ou, au moins, certaines limites pour elle [6, 25].
Un code linéaire C possède une matrice génératrice G, dont les lignes forment une base de C. Il
possède également un contrôle de parité.
matrice H, dont l'espace nul est C et telle que GHT = 0. On dit que G est écrit sous la forme
systématique, ou forme standard, si
( )
G = Ik |Gt
( )
où Ik est la matrice d'identité de taille k et Gt est une matrice à k lignes et n - k colonnes. Si G = Ik|Gt
est écrite sous la forme systématique, nous pouvons dériver la matrice de contrôle de parité H très
facilement :
)
H = (-GtT |In−k .
Évidemment, si G et H sont associés à un code binaire (qui est défini dans Z2 ), nous avons -Gt = Gt .
Un code de paramètres [n, k, d] peut corriger au plus t erreurs, où t ≤ d-1
. Sa2 redondance est r = n
- k (c'est à dire le nombre de bits supplémentaires que l'on obtient en codant un message). Par taux R
d'un code C, on entend la fraction de bits d'un mot de code qui n'est pas redondante, c'est-à-dire R =
k/n.
Exemple 1. [Le code de Hamming] Cette classe de codes linéaires a été inventée par Richard
Hamming au début des années 50 et constitue un exemple classique de code linéaire. Les colonnes
de la matrice de contrôle de parité H d'un code2 de Hamming sont tous les vecteurs non nuls de Fr , où
r est la redondance du code. Ces codes sont
dénoté par Ham(r, 2).
La matrice
1001011
H= 0101101
1
0 01011
est une matrice de contrôle de parité de Ham(3, 2). Ce code a des paramètres [7, 4, 3] donc il peut
2
corriger jusqu'à t ≤ 3-1 =.
1 erreur.
6
Par algorithme de décodage DC d'un code C qui corrige t erreurs, on entend un algorithme tel que,
étant donné un mot d'entrée w + e, où w ∈ C et e est un vecteur de poids wt(e) ≤ t, il sort w.
Étant donné un code C (de longueur n, sur Fq ) et une matrice de contrôle de parité H de C, un
syndrome d'un vecteur
w ∈ Fqn est le produit wH. Si le syndrome d'un vecteur w est wH = 0 alors w ∈ C. D'autre part, si nous
2 Un mot est identique à un vecteur ; nous utiliserons souvent cette terminologie.
7
calculer le syndrome d'un vecteur y = w + e, où w ∈ C et e est un vecteur d'erreur tel que wt(e) ≤ t,
on obtient.
yH = (w + e)H = wH + eH = eH.
Le syndrome peut donc être utilisé pour le décodage, puisque le problème du décodage est égal à la
recherche du vecteur d'erreur e tel que yH = eH.
Étant donné un code C et une matrice de parité H de C, nous définissons SH (s)−1 comme l'ensemble
des mots tels que ont
syndrome s, c'est-à-dire
SH (s)−1 = y + C = {y + w : yH = s, w ∈ C}.
Trouver un vecteur y ∈ SH (s)−1 peut être fait en temps polynomial. Mais le problème suivant est connu
pour être difficile à calculer.
Problème 2 (vecteur de syndrome computationnel). Etant donné un

2
code C ∈ Zn de dimension k ≤ n,
une matrice de contrôle de parité H de C, un syndrome s ∈ Zr et t ∈ N, trouver un mot x ∈ Zn tel que x
∈ SH (s)−1 et x a un poids 2 2
wt(x) ≤ t.
Il a été prouvé que ce problème est NP -complet pour un code linéaire arbitraire [7]. Si l'on veut
minimiser t, alors le problème est NP -hard. Par conséquent, si les paramètres sont suffisamment
grands, le problème devient infaisable à résoudre. Ce que ce problème nous dit, c'est que le
décodage d'un mot de code corrompu d'un code arbitraire est un problème non trivial.
L'un des principaux objectifs de la théorie des codes est de trouver des familles de codes telles
que le problème du vecteur de syndrome computationnel soit facile à résoudre, c'est-à-dire qu'il soit
dans P (ou BPP ). Si nous pouvons le faire efficacement pour une famille particulière de codes, nous
avons une famille de codes pour laquelle le décodage est efficace. De plus, il n'y a pas d'algorithme
quantique connu pour résoudre ce problème, ce qui rend ce problème intéressant pour la
cryptographie post-quantique comme nous le verrons plus tard.
2.2 Codes Goppa
Dans cette thèse, nous nous intéressons aux familles de codes que nous pouvons utiliser en
cryptographie et l'une des plus importantes familles de ces codes est celle des codes de Goppa. Ils
ont été présentés pour la première fois dans [23], puis une version anglaise a été publiée dans [5].
Nous allons maintenant voir ce qu'est un code de Goppa et quelles sont ses propriétés.
Un code de Goppa est un code binaire correcteur d'erreurs qui présente certaines propriétés
intéressantes pour la cryptographie, à savoir le nombre d'erreurs qu'il peut corriger et le nombre de
codes différents que l'on peut créer, pour une longueur fixe et une distance minimale.
Soit p ∈ N. Un code de Goppa est défini par (g, L) où g ∈ F2 p [x] est un polynôme de degré t (avec
coefficients dans F2 p et variable x), et sans zéros multiples, et L est une séquence L0 , ..., Ln−1 ∈ F2
p
de sorte que
8
Li /= Lj ∧ g(Li ) /= 0 ∀i, j ∈ {0, ..., n - 1},
c'est-à-dire que tous les éléments de L doivent être différents les uns des autres et aucun d'entre eux
n'est une racine de g. Le code est le suivant
9
l'ense f n-1
mble n L wi
G(g, L) = w∈ Z2 :
= 0 mod g(x) .
x - Li
i=0
Théorème 3 ([8]). Pour une paire donnée (g, L = {L0 , . . . , Ln−1 }), la matrice de contrôle de parité du
code correspondant est très facile à dériver. Elle peut être calculée de la manière suivante :
1
g(L0)
... 1
g(Ln-1)
L0
g(L0)
.. Ln-1 g(Ln-1)
H . .
= . .
L
t-1 L t-1
0
g(L0) .. n-1
g(Ln-1)
.
La facilité avec laquelle nous créons différents codes Goppa vient de la facilité avec laquelle nous
créons différentes matrices de contrôle de parité.
Ce code a une distance minimale supérieure ou égale à 2t + 1 puisqu'il peut corriger jusqu'à t
erreurs (la raison pour laquelle il peut corriger t erreurs sera expliquée plus loin). La dimension de ce
code est k = n - mt. En utilisant l'algorithme de Patterson [45], on peut décoder facilement un mot de
code de Goppa corrompu. L'existence d'un tel algorithme de décodage est ce qui rend les codes de
Goppa utiles pour les applications. Un exemple simple d'un code de Goppa est présenté dans
l'exemple 4.
Exemple 4. Soit p = 4 et on considère le polynôme f (x) = x4 + x + 1 qui est irréductible dans F2 . On

a que F16 = Z2 [x]/(f (x)) est un corps. Soit α une solution pour l'équation x4 + x + 1 = 0 dans F16 ; α
est un
élément primitif de F16 , c'est-à-dire qu'il est un générateur du groupe multiplicatif
16 F∗ = F16 \ {0}.
Considérons maintenant le polynôme g(x) = x2 + x + α3 dans F16 [x] et L = {αi : 2 ≤ i ≤ 13} un

ensemble d'éléments de F16 . Le code défini par g et l a une longueur 12, une distance minimale d ≥
2t + 1 = 5 et une dimension 4. Ses paramètres sont donc [12, 4, d] où d ≥ 5.
g(1α2) g(1α3) g(1α4) g(1α5) g(1α6) g(1α7) g(1α8) g(1α9) 1 )

g(α10 1 )
g(α11 1 )
g(α12 1 )
g(α13
H= α2 α3 α4 α5 α6 α7 α8 α9 α10 α11 α12 α13 g(α13)
g(α2) g(α3) g(α4) g(α5) g(α6) g(α7) g(α8) g(α9) g(α10) g(α11) g(α12)
3 αα9 α4 α α8 α6 α3 α6 α α2 α2 α21
8
= .
α5 α12 α8 α6 α14 α13 α11 α15 α10 α13 α14
α
10
En écrivant les vecteurs dans la base {1, α, α2 , α3 }, on obtient
11
0
0 1 0 1 0 0 0 0 0 0 1
0 1 1 1 0 0 0 0 1 0 0 0
0 0 0 0 1 1 0 1 0 1 1 1
1 11100101111
H=
0 11011011110
1 10000101000
1 11101101101
1
0 1011110011
et puisque GHT = 0, nous pouvons calculer la matrice de générateur G, pour le code généré par la
paire (g, L).
110110000001
111011010010
G= .
011010100100
0
1 1000010100
L'algorithme de Patterson
Pour décoder les codes Goppa, nous pouvons utiliser l'algorithme de Patterson qui est décrit dans
l'Algorithme 1 à la page 9. Cette procédure, présentée dans [45], peut corriger jusqu'à t erreurs.
Avant de présenter l'algorithme, notons que nous pouvons considérer un mot codé de longueur n
comme un polynôme de degré n - 1 dans une variable x. Ainsi, le syndrome d'un mot reçu y est donné
par
n-1
L yi
sy(x) = mod g(x)
i=0 x - Li
par la définition du code de Goppa. Ainsi, si le mot reçu y est y = w + e, où w est un mot de code et e
un vecteur d'erreur tel que wt(e) ≤ t, on a .
n-1 n-1 n-1
L yi
L wi ei
L ei
sy(x) = = + = = se(x)
i=0 x - Li i=0 x - Li x - Li i=0 x - Li
et donc, le syndrome de y est le même que le vecteur d'erreur e (comme prévu).
On définit le polynôme localisateur d'erreurs de y = w + e où w ∈ C et e est tel que wt(e) ≤ t.
IT
σy (x) = (x - Li )
i:eiI=0
dont les racines donnent la position des erreurs et, évidemment, deg σy donne le nombre d'erreurs. Si
nous trouvons le polynôme de localisation des erreurs associé à un mot corrompu, nous pouvons
y
12
corriger l'erreur. Dans notre cas, nous supposerons que deg σy ≤ t, sinon nous ne sommes pas en
mesure de corriger les erreurs. Soit σt (x) la dérivée de σy (x).
13
Nous l'avons
:
L IT L 1 IT
σt (x) = (x - L ) = (x - L ) = s (x)σ (x).
y j j e y
i:eiI=0 j:ej I=0 i:eiI=0 x - Li j:ej I=0
jI=i
Ainsi, nous cherchons à trouver σy (x) et σt (x) qui satisfont l'équation se (x)σy (x) = σt (x) mod g(x) avec
deg σy (x) ≤
y y
t
y ≤ t - 1.
t et deg σ (x)
Rappelons que (a + b)2 = a2 + b2 dans un corps de caractéristique 2. Puisque σy est un polynôme
défini sur un corps de caractéristique 2, il peut être décomposé en α2 (x) + xβ2 (x), avec deg(α) ≤ lt/2J
et
deg β ≤ 2 J.
lt-1
Par conséquent,
y σt (x) = β2 (x). Nous avons
se (x)σy (x) = σyt (x) ⇔ se (x)(α2 (x) + xβ2 (x)) = β2 (x) ⇔ α(x) = β(x)d(x) mod g(x)
où d(x)2 = x + se (x)−1 . Pour calculer efficacement d(x), nous disposons du lemme suivant.
Lemme 5 ([48]). Soit x + s−1 (x) = t2 (x) + xt2 (x) ∈ F2 p [x] /(g(x)) et g(x) = h2 (x) + xh2 (x). Soit
e 0 1 0 1
d(x) = t0 (x) + h0 (x)h−1

1 (x)t
1 (x). Alors d(x) = /x+ s−1
e (x).
Il existe un algorithme pour trouver de tels α et β (une variante de l'algorithme d'Euclide étendu
[45], en notant que α(x) = β(x)d(x) + g(x)k(x) pour un certain polynôme k(x)), puis nous pouvons
calculer σy (x) et trouver ses zéros (en vérifiant pour lequel des Li nous avons σy (Li ) = 0). En
décomposant
IT
σy (x) = (x - Li )
i:eiI=0
on peut obtenir les coordonnées non nulles du vecteur d'erreur et ainsi corriger le mot corrompu reçu.
Si le code est défini par un polynôme g à coefficients sur F2 p tel que deg g = t et par une séquence de
nombres L de taille n, alors cet algorithme s'exécute en temps O(n.t.p2 ) [10, 18].
2.3 Codes LDPC
Les codes LDPC (Low-Density Parity-Check) forment une classe de codes linéaires qui sont obtenus
à partir de graphes bipartis épars. Soit X un graphe biparti ; les nœuds de gauche de X sont appelés
les nœuds de message (ou nœuds de variable) et les nœuds de droite sont appelés les nœuds de
contrôle (ou nœuds de contrainte). Nous construisons un LDPC à partir de X de la manière suivante :
étant donné un mot w, nous associons chaque sommet gauche du graphe à chaque bit de w ; w est
un mot codé si, pour tous les nœuds de contrôle, la somme des bits voisins (les bits associés aux
nœuds voisins) est nulle.
En termes de matrice, la matrice de contrôle de parité H est la matrice d'adjacence de X. Puisque X
est un graphe clairsemé,
H est une matrice éparse. Comme d'habitude, le code est défini par l'ensemble des mots w tels que wH
= 0.
14
Exemple 6. Considérons le graphique présenté à la figure 2.1.
Les sommets du côté gauche sont appelés variables, notées v1 , . . . . . , v10 . Les sommets du côté
droit sont appelés des contraintes, désignées par C1 , . . . . , C5 . Nous associons chaque variable à un
bit d'un mot.
15
Algorithme 1 Algorithme de décodage de Patterson
entrée : Mot corrompu y = w + e, où w est un mot codé et wt(e) ≤ t ;
sortie : Mot de code
w. w := y ;
Calculez le syndrome de y, s(x). Calculez 1/s(x) = s(x)−1 ;
si s(x)−1 = x alors
σy (x) = x et terminer ;
sinon
/
d(x) = x + se (x)-1 ;
Trouver α(x) et β(x) tels que α(x) = β(x)d(x) mod g(x) ;
σy (x) = α2 (x) + xβ2 (x) et calculer ses racines. Soit S = {i : σ(Li ) = 0} ;
pour chaque i dans S faire
Retourner le bit ith de w ;
fin pour
retourn
er w
fin si
Figure 2.1 : Code LPDC.
Le code LDPC défini par ce graphe est l'ensemble des mots de longueur 10 tels que, pour chaque
contrainte C1 , . . . . , C5 , la somme des variables adjacentes est égale à 0. En d'autres termes, le code
est l'ensemble des mots v = v1 ...v10 qui satisfont aux équations suivantes :
v2 + v4 = 0
v1 + v3 + v7 + v8 + v9 = 0
v2 = 0
v1 + v6 + v7 = 0
v2 + v4 + v5 + v6 + v9 + v10 = 0.
16
La matrice de contrôle de parité est
0000001010
1100111010
H= 0 000000010 ,
0001100001
1
0 11100010
c'est-à-dire qu'il s'agit de la matrice d'adjacence du graphe. De manière équivalente, nous pouvons
définir le code comme l'ensemble des mots w
tel que wH = 0.
Le grand avantage des codes LDPC est leur algorithme de décodage. Ces codes peuvent être
décodés en utilisant les techniques dites de propagation de croyance qui les rendent extrêmement
efficaces [30, 36, 37, 50] (nous verrons plus loin des exemples de ces techniques).
Les codes LDPC sont très différents des codes à géométrie algébrique (comme, par exemple, les
codes de Goppa). Pour ces derniers, il peut être extrêmement difficile de trouver des algorithmes de
décodage, car ils sont construits à l'aide d'arguments combinatoires et le décodage n'est pas pris en
compte lors de la création du code. En revanche, les codes LDPC ont des algorithmes de décodage
très faciles et rapides, puisque le décodage est pris en compte lors de la création du code.
Ici, nous allons jeter un coup d'œil rapide sur quelques familles différentes de codes LDPC. Ces
familles sont les codes LDPC réguliers et les codes expansifs. Mais avant de présenter ces familles,
nous avons besoin de quelques notions de théorie des graphes.
Théorie des graphes
Nous allons commencer par quelques définitions de base sur la théorie des graphes. Un graphe X de
taille n est un tuple (V, E), où
V = {v1 , . . . , vn } est l'ensemble des sommets et E = {(u, v) : u, v ∈ V } est l'ensemble des arêtes. Le
degré d'un sommet est le nombre d'arêtes qui lui sont connectées.
Définition 7 (graphe régulier). Un graphe a-régulier est un graphe dont chaque sommet a un degré a.
Par graphe régulier (a, d), nous entendons un graphe biparti dans lequel : i) l'ensemble des
sommets peut être divisé en deux ensembles disjoints de telle sorte qu'il n'y ait pas de connexions
entre les sommets d'un même ensemble ; et ii) tous les sommets d'un ensemble ont un degré a et
tous les sommets de l'autre ensemble ont un degré d.
Définition 8 (graphe de Cayley). Soit G un groupe et S un ensemble générateur de G. Le graphe de

Cayley X = X(G, S) est le graphe où chaque élément g ∈ G est affecté d'un sommet et l'ensemble des
arêtes E de X est formé par les paires (g, gs) pour tous les g ∈ G et s ∈ S.
Définition 9 (Graphe à incidence bord-vertex). Soit X un graphe. Le graphe d'incidence bord-vertex
17
de X est un graphe biparti avec un ensemble de sommets Vt = E ∪ V et un ensemble d'arêtes Et =
{(e, v) ∈ E × V : v est un point d'extrémité de e}.
18
Par un facteur d'expansion δ, on entend que, pour tout sous-ensemble de sommets S ⊂ V ayant au
plus un nombre fixe de sommets (c'est-à-dire que |S| ≤ n pour un certain n ∈ N), le nombre de
sommets adjacents des éléments de S est au moins δ|S|.
Définition 10 (graphe expansif). Un graphe expanseur (a, d, c, δ) est un graphe régulier (a, d), où V
est l'ensemble des sommets de degré a, tel que tout S ⊂ V s'étend par un facteur d'au moins δ, où S a
au plus une fraction c des sommets de degré a.
Les graphes d'expansion sont des graphes épars dont chaque petit ensemble de sommets a
beaucoup de sommets d'adjacence. L'existence de ces graphes a été prouvée en utilisant des
méthodes probabilistes [27]. En fait, si nous générons un graphe régulier (a, d) aléatoire en suivant
une heuristique simple, nous obtiendrons très probablement un graphe expanseur [58].
Il existe également une méthode déterministe pour construire des graphes d'expansion [33] que nous
allons analyser.
Il existe une relation entre les graphes expansifs et la première et la deuxième plus grande valeur
propre (en valeur absolue) de la matrice d'adjacence du graphe [2] : plus la différence entre la
première et la deuxième valeur propre est grande, plus le facteur d'expansion du graphe est grand.
Nous allons donc maintenant étudier les graphes dans lesquels cette différence est maximale.
Supposons maintenant que X est un graphe d-régulier connecté de n sommets. Il est connu que sa
matrice d'adjacence a des valeurs propres λ0 > λ1 ≥ - - - ≥ λn−1 , où λ0 = d et |λj | ≤ d [33]. A partir de
maintenant, nous allons
définir λ(X) = maxi |λi | tel que |λi | = d.
Définition 11 (graphe de Ramanujan [33]). Un graphe X est appelé un graphe de Ramanujan si λ(X) ≤
2√d - 1.
Asymptotiquement, cette borne est la plus petite valeur possible pour λ(X) [2], puisqu'il est prouvé
que...
lim λ(X) ≥ 2√d - 1.

n→∞
Ainsi, pour un graphe de Ramanujan, lorsque le nombre de sommets n est suffisamment grand,
l'égalité tient. Et puisque la différence entre la première et la deuxième valeur propre sera maximale,
ces graphes auront de bons facteurs d'expansion (en raison des relations entre cette différence et les
facteurs d'expansion mentionnés ci-dessus).
Nous devons introduire une dernière notion avant de présenter l'algorithme de création de graphes
de Ramanujan explicites, à savoir la notion de groupe linéaire projectif et de groupe linéaire spécial
projectif.
Définition 12 (Groupe linéaire projectif). Soit V un espace vectoriel. Nous définissons le groupe linéaire
projectif
PGLn (V ) := GLn (V )/Zn (V )
où GLn (V ) est le groupe linéaire général3 de degré n et Zn (V ) ≤ GLn (V ) son centre.4 De manière
19
identique, nous définissons le groupe linéaire spécial projectif PSLn (V ) = SLn (V )/SZn (V ) où SLn (V )
est le groupe linéaire spécial de taille n et SZn (V ) ≤ SLn (V ) son centre. Rappelons que SLn (V ) est
un sous-groupe de GLn (V ) formé par les matrices dont le déterminant est 1.
3Le groupe des matrices inversibles.
4Le centre d'un groupe est l'ensemble des éléments qui commuent avec tous les autres éléments du groupe.
20
Pour notre propos, nous ne nous intéressons qu'au cas où n = 2 et V = Zq , pour un certain nombre
premier
q.
Le centre de GL2 (Zq ) est le sous-groupe Z2 (Zq ) formé par les matrices scalaires (les matrices qui
sont
un multiple de l'identité).
Par définition, nous avons que deux éléments de GL2 (Zq ) appartiennent à la même classe
d'équivalence en
PGL2 (Zq ) s'ils diffèrent par multiplication d'un scalaire dans Zq . En d'autres termes, pour et
q
certains α ∈ Z∗
A, B ∈ GL2 (Zq )
A ∼ B ⇐⇒ A = αB.
Proposition 13. L'ordre de PGL2 (Zq ) est (q2 - 1)q. L'ordre de PSL2 (Zq ) est (q2 - 1)q/2.
Preuve. Pour dériver l'ordre du groupe PGL2 (Zq ), on utilise le théorème de Lagrange qui nous dit que
l'ordre du groupe quotient G/H est l'ordre de G divisé par l'ordre de H, pour le cas fini. Ainsi, nous
avons que l'ordre de GL2 (Zq ) est (q2 - 1)(q2 - q) ce qui correspond à choisir un vecteur v /= 0 (et
nous avons q2 - 1 choix pour cela) et ensuite choisir un autre vecteur qui n'est pas un multiple de v (et
nous avons q2 - q choix pour cela). D'autre part, nous avons que l'ordre de Zn (Zq ) est q - 1. Nous
concluons donc que l'ordre de PGL2 (Zq ) est (q2 - 1)q.
Pour dériver l'ordre du groupe
PSL2 (Zq ) = SL2 (Zq )/SZ2 (Zq )
nous utiliserons à nouveau le théorème de Lagrange. L'ordre de SL2 (Zq ) peut être calculé en notant
que l'homomorphisme
φ : GL2 (Zq ) → Fq∗
qui donne le déterminant de la matrice est surjective et que son noyau est SL2 (Zq ) ; par le premier
théorème d'isomorphisme5 et le théorème de Lagrange, nous avons que
2 2
|GL2 (Zq )| (q - 1)(q - q)
|SL
2 (Z
q )| = = .
|F∗|
q q- 1
Pour calculer l'ordre de SZ2 (Zq ), notez que ce groupe est l'intersection entre SL2 (Zp ) et Z2 (Z2 ).
Ainsi, un élément de SZ2 (Zq ) est une matrice scalaire, puisque toutes les matrices de Z2 (Z2 ) sont
scalaires. Soit A une matrice scalaire de taille 2, alors A = λI où I est la matrice d'identité et λ ∈ Zp .
Le déterminant de A est λ2 . L'équation x2 = 1 dans Zp n'a que deux solutions dans Zp (puisque p est
premier) donc l'ordre de SZ2 (Zq ) est 2.
Nous concluons
que |SL2 (Zq )| (q -2 1)q
|PSL 2(Z )|
2 = = .
|SZ2 (Zq )| 2
21
5
Rappelons que si φ : A → B est un homomorphisme surjectif, alors A/Ker(φ) ∼= B. Ce résultat est appelé le premier
théorème d'isomorphisme.
22
Construction des graphes de Ramanujan
L'algorithme 2 décrit la construction de graphes de Ramanujan explicites et a été présenté pour la

première fois dans [33].
Algorithme 2 Construction des graphes de Ramanujan

Choisir p, q premiers s.t. p /= q et p, q = 1 mod 4. On choisit i ∈ Z, sous réserve que i2 = -1 mod q ;
Calculer les p + 1 solutions possibles α = (a0 , a1 , a2 , a3 ) de p = a2 + a2 + a2 + a2 où a0 > 0 est impair
0 1 2 3
et un1 , un2 , un3 sont pairs ;

Utilisez ces solutions α = (a0 , a1 , a2 , a3 ) pour construire
l'ensemble
a0 + i.a1a2 +
S= ia3 : α = (a , a , a , a )∈ PGL (Z );
0 1 2 3 2 q
-a2 + ia3 a0 - ia1
( )
si q p = 1
alors
Formez le graphe de Cayley X(G, S) où G = PSL2 (Zq ) ;
()
else pq = -1
Formez le graphe de Cayley X(G, S) où G = PGL2 (Zq ) ;
fin si
( )
p
Ici, représente
q
le symbole de Jacobi, qui est défini comme suit
( ) 0 si p = 0
p =
1 s'il y a x s.t. p = x2 mod q .
q
-1sinon
( )
p
Cet algorithme nous donne un graphe (p + 1) régulier de taille n = q(q2 - 1), si = -1, ou n = q(q2 -
q
1)/2,
( )
p
si = 1.
q
( )
p
Dans le cas où =q -1, le graphe obtenu est également bipartite (entre le sous-groupe PSL2 (Zq )
et son complément).
Théorème 14 ([33]). Le graphe donné par l'algorithme 2 est un graphe de Ramanujan (p + 1) régulier.
Exemple 15. Considérons un graphe de Ramanujan construit à l'aide de l'algorithme 2 avec p = 13 et

( )
q = 5. Puisque le symbole
5
de Jacobi13 est égal à -1, ce graphe a 5(52 - 1) = 120 sommets. C'est un
graphe régulier (14) et il est bipartite. La figure 2.2 présente une représentation de ce graphe, réalisée
à l'aide de Mathematica.
Codes LDPC réguliers
Les codes LDPC réguliers sont une sous-classe de codes LDPC dans laquelle le graphe associé au
23
code est un graphe biparti régulier (a, d), où tous les nœuds de variables ont un degré a et tous les
nœuds de contraintes un degré d. Ils ont été présentés pour la première fois par Gallager avec un
algorithme de décodage [22]. Figure 2.3
24
Figure 2.2 : Graphe de Ramanujan avec p = 13 et q = 5.
montre un exemple de LDPC régulier où les nœuds de variables ont un degré 3 et les nœuds de
contraintes un degré 5.
Figure 2.3 : LDPC ordinaire.
L'algorithme de décodage de ces codes est appelé propagation de croyance ou algorithme de
passage de message [50]. Les messages sont transmis entre les variables et les contraintes avec la
probabilité qu'une certaine variable ait une certaine valeur. La valeur de la variable est envoyée à ses
nœuds de contraintes adjacents, où cette probabilité est calculée (la façon dont ce calcul est effectué
dépend de l'algorithme choisi). Ensuite, cette probabilité est envoyée aux variables, et sa valeur est
inversée en fonction du message (proba- bilité) reçu. La nouvelle valeur de la variable est envoyée à
ses nœuds de contraintes adjacents et le processus est répété. Ce processus est effectué jusqu'à ce
que toutes les probabilités soient égales à 1 ou pour un nombre fixe de fois. A la fin de ce processus,
nous pouvons évaluer si le mot a été bien décodé ou non (en vérifiant si le mot résultant appartient au
code). Si le mot n'a pas été bien décodé, nous supposons que nous ne sommes pas capables de
décoder ce mot.
Nous présentons une version simplifiée de l'algorithme de décodage par propagation de croyances
pour les graphes réguliers dans l'Algorithme 3, appelée typiquement le décodage par décision dure.
Cette version simplifiée est le résultat de la discrétisation de l'algorithme de propagation de croyances,
c'est-à-dire que les messages passant des nœuds sont des bits au lieu de probabilités. Il est
intéressant de noter que cette version est celle utilisée en pratique (ou des versions similaires) car elle
conduit à une augmentation de la vitesse [34, 35, 37, 50]. C'est également la version proposée par
25
Gallager dans son article [22].
Malheureusement, il n'y a pas de résultat sur la limite du nombre d'erreurs que cet algorithme (ou tout
autre algorithme pour l'analyse des erreurs) peut commettre.
26
Algorithme 3 Une version plus simple de l'algorithme de décodage par propagation de croyance
entrée : Mot corrompu y = w + e ;
sortie : Mot de code w ;
Les nœuds de variables envoient leur valeur aux nœuds de contraintes adjacents ;
pour un nombre fixe de fois
Message d'une contrainte C à une variable adjacente v : La somme (modulo 2) de toutes les
valeurs des variables adjacentes, sauf v, de C est envoyée à v ;
Message d'une variable v à une contrainte adjacente C : Si, pour toutes les contraintes
adjacentes, sauf C, de v, la valeur calculée est la même, alors v prend cette valeur et elle est
envoyée à C. Sinon, v garde sa valeur initiale et cette valeur est envoyée à C.
fin pour
codes LDPC réguliers) correctes.
Codes d'expansion
Les codes expanseurs sont également un type de codes à contrôle de parité à faible densité (codes
LDPC). Ils ont été présentés pour la première fois par Sipser et Spielman dans [54]. Comme nous le
verrons, cette famille de codes possède de belles propriétés et peut être décodée très facilement. Les
codes expanseurs ont également un taux et une distance constants, contrairement aux codes LDPC
génériques.
Nous allons maintenant définir ce qu'est un code expanseur. Le code est défini par un graphique et
par un code interne correcteur d'erreurs.
Définition 16 (Code expanseur [54]). Soient a, d ∈ N tels que a < d. Soit B = (V, E) un graphe biparti
régulier (a, d) entre un ensemble de n sommets {v1 , ... . , vn } (appelés variables) de degré a et un
ensemble de an/d sommets {C1 , ... . , Can/d } (appelés nœuds de contrôle ou contraintes) de degré d.
Soit b(i, j) une fonction qui, pour chaque contrainte Ci , donne vb(i,1) , ..., vb(i,d) comme variables
voisines de Ci . Soit C un code correcteur d'erreurs de longueur d. Le code expanseur E = (B, C) est le
code de longueur n défini comme suit :
{(w1 , . . . , wn ) ∈ Z2 : (wb(i,1) , . . . , wb(i,d) ) ∈ C, pour 1 ≤ i ≤ cn/d}.
En d'autres termes, les variables voisines de chaque contrainte doivent former un mot de code de C.
À titre d'exemple, notez que si C dans la définition ci-dessus est le code formé par tous les mots de
poids pair, alors le code est un code LDPC régulier.
Il existe un algorithme de décodage très intuitif et efficace pour les codes expanseurs [54]. Dans
cet algorithme, il suffit de voir laquelle des variables est reliée à un plus grand nombre de contraintes
non satisfaites et de retourner le bit correspondant à cette variable (s'il y a deux variables ou plus dans
cette condition, on en choisit une au hasard). Ce processus est répété jusqu'à ce qu'on obtienne un
mot codé de pour un nombre fixe de fois (si, après ce nombre de fois, on n'obtient pas de mot codé,
alors le mot est considéré comme non décodable).
Il est prouvé que cet algorithme converge pour les codes expansifs pour lesquels le graphe expansif
27
a un facteur d'expansion supérieur à 3a/4 et pour lesquels le code interne est le code de tous les mots
de poids pair (Théorème 17).
28
Cet algorithme peut également être utilisé pour les codes LDPC réguliers qui ne sont pas expansibles,
bien que la convergence ne soit pas garantie [37].
Notez que l'algorithme s'exécute en temps polynomial et qu'il est extrêmement rapide, car il
n'implique que des opérations de basculement de bits.
Théorème 17 ([54]). Soit B un graphe expanseur (a, d, α, 3a/4) et C le code de tous les mots de poids
pair de longueur d. Étant donné un mot de code corrompu du code expanseur E = (B, C), l'algorithme
de décodage peut corriger jusqu'à nα/2 erreurs, où n est la longueur de E = (B, C).
On ne connaît pas de constructions explicites pour les graphes avec cette expansion, puisque
nous ne pouvons garantir qu'une expansion supérieure ou égale à a/2, comme cela se produit avec
les graphes de Ramanujan construits à l'aide de l'algorithme 2 [28]. Cependant, si nous choisissons
un graphe régulier (a, d) aléatoire, il est probable que ce graphe soit un bon graphe expanseur [54,
58].
Nous pouvons également construire des codes expanseurs à partir de graphes de Ramanujan. La
construction est exactement la même que dans la définition 16, mais le graphe utilisé est la matrice
d'incidence bord-vertex d'un graphe de Ramanujan d-régulier (ce qui nous donne un graphe (2, d)-
régulier avec de bonnes propriétés d'expansion). Pour ce cas, Sipser et Spielman ont obtenu des
limites inférieures sur le taux et la distance minimale pour le code résultant. Ils ont également prouvé
une limite inférieure sur le nombre d'erreurs corrigées en utilisant une variation simple de l'algorithme
de décodage pour les codes expansifs [54].
Proposition 18 ([54]). Soit E = (B, C) un code expanseur où B est la matrice d'incidence bord-vertex
d'un graphe de Ramanujan d-régulier, avec la deuxième plus grande valeur propre λ, et C est un
code avec un taux r et une distance relative minimale6 D. Alors E = (B, C) a un taux rt ≥ 2r - 1 et une
distance relative minimale
Dt D≥ - λ/d 2.
1 - λ/d
Dans ce qui suit, H- (x) désigne la fonction d'entropie binaire et est définie comme suit :
H- (x) = -x log2 x - (1 - x) log2(1 - x)
- = 0.
et H(0)
Théorème 19 ([54]). Pour tout δ0 tel que 1 - -2H(δ0 ) > 0, il existe une famille de codes expanseurs, qui
-
peuvent être construits en temps polynomial, avec un taux 1 - 2H(δ0 ) et une distance relative
minimale
0
arbitrairement proche de δ2 dans laquelle toute fraction α < δ0 /48 d'erreurs peut être
corrigée par l'algorithme de décodage.
Le théorème 19 nous donne une limite sur le nombre d'erreurs que les codes Expander peuvent
corriger. Malheureusement, le nombre d'erreurs corrigées est très faible mais ce résultat peut être
amélioré en utilisant un algorithme de décodage légèrement différent [60] (cet algorithme de décodage
peut décoder jusqu'à quatre fois plus d'erreurs). Néanmoins, ce résultat est très utile pour la
cryptographie, car dans la cryptographie à base de codes, il est essentiel de connaître exactement le
nombre d'erreurs que le code peut corriger afin de prouver l'exactitude des protocoles. Il semble que
29
les seuls codes LDPC dont l'algorithme de décodage garantit une fraction d'erreurs corrigées sont les
codes LDPC basés sur des expanseurs. Des exemples de tels codes, leurs constructions et leurs
algorithmes de décodage sont présentés dans [24, 54, 55, 60].
6
Rappelons que la distance relative minimale est la distance minimale du code divisée par sa longueur.
30
Chapitre 3
Schéma de cryptage à clé publique
Dans ce chapitre, nous analyserons les systèmes de cryptage à clé publique et certaines notions de
sécurité les concernant. Nous commencerons par définir ce qu'est un schéma de chiffrement à clé
publique. Dans la section 3.2, nous poursuivons notre analyse en introduisant deux notions de
sécurité importantes : l'(in)distinguabilité, qui est la capacité de distinguer différents textes chiffrés, et
la malléabilité, qui est la capacité de créer de nouveaux textes chiffrés à partir d'un texte chiffré connu.
Nous donnons également les relations entre ces notions de sécurité. La conscience du texte clair est
une notion de sécurité qui est introduite dans la section 3.3, où nous présentons également un résultat
important qui relie cette notion avec les autres introduites auparavant. Enfin, nous terminerons ce
chapitre en donnant une technique générique, la conversion générique de Fujisaki-Okamoto, pour
réaliser certaines des notions de sécurité. Cette technique est pertinente car elle peut être appliquée à
n'importe quel schéma de chiffrement à clé publique, pourvu que certaines conditions soient vérifiées.
3.1 Notions de base
Le cryptage à clé publique permet à deux parties de communiquer en privé. Contrairement à la

configuration symétrique, où les deux parties doivent partager une clé secrète, dans les systèmes de
cryptage à clé publique, chacune des parties crée une paire de clés publique et secrète. La clé
publique est publique, de sorte que tout le monde peut crypter des messages. La clé secrète est
gardée privée par le propriétaire de la clé afin que personne d'autre ne puisse décrypter les
messages. Nous commençons ce chapitre par une définition simple. Dans cette définition et tout au
long de cette thèse, lorsque nous disons qu'une valeur est choisie au hasard, cela signifie qu'elle est
choisie selon une distribution uniforme. Lorsqu'un vecteur ou une chaîne de caractères est choisi(e)
au hasard, cela signifie que chaque bit est choisi en fonction d'une distribution uniforme.
Définition 20 (cryptosystème à clé publique). Un système de cryptage à clé publique, ou schéma de

cryptage à clé publique,
Π = (K, E, D) est composé de trois algorithmes :
La création de clés est un algorithme probabiliste en temps polynomial K qui reçoit en entrée 1k ,
où k est un paramètre de sécurité, et produit une paire K(1k ) = (pk, sk) où pk est la clé publique et sk
31
la clé secrète (ou clé privée).
Le chiffrement est un algorithme probabiliste en temps polynomial E qui reçoit en entrée une clé
publique pk et une clé de sécurité.
32
un message à chiffrer m, et une chaîne de pièces aléatoires r, et produit un texte chiffré E (pk, m ; k) =
c. De manière informelle, r représente le caractère aléatoire du cryptosystème. Tout au long de cette

thèse, si nous omettons r, il
signifie que ces pièces ont été choisies au hasard.
Le décryptage est un algorithme déterministe en temps polynomial D qui reçoit en entrée un texte
chiffré c et une clé secrète sk, et produit un message D(sk, c) = m, si c est un texte chiffré valide ;
sinon, il s'arrête.
Un système de cryptage à clé publique (PKC) doit également posséder deux autres propriétés : i)
la correction, qui signifie qu'un texte chiffré valide doit pouvoir être décrypté de manière unique en un
message à l'aide d'une clé secrète valide,
D[E (pk, m ; r), sk] = m
pour chaque paire (pk, sk) générée par K. Et ii) la sécurité, qui signifie qu'il doit être difficile sur le plan
informatique de récupérer le message à partir de son texte chiffré sans la clé secrète.
Avant de poursuivre, définissons la fonction de hachage et la fonction de hachage cryptographique.
Définition 21 (Fonction de hachage). Une fonction de hachage h est une fonction qui prend en entrée
une chaîne de caractères x de taille arbitraire et la met en correspondance avec une chaîne de
caractères de taille fixe. Nous appellerons souvent valeur de hachage de x la sortie d'une fonction de
hachage prenant x en entrée.
Définition 22 (Fonction de hachage cryptographique). Une fonction de hachage cryptographique H est

une fonction de hachage qui possède les propriétés suivantes :
• Il est difficile de trouver des collisions, c'est-à-dire qu'il est difficile de trouver deux chaînes x et y
telles que H(x) = H(y) ;
• Il est difficile à inverser, c'est-à-dire qu'étant donné le hachage h, il est difficile de trouver x tel que
H(x) = h ;
• C'est une fonction honnête, c'est-à-dire que la taille de la sortie est polynomialement limitée par la
taille de l'entrée.
Une fonction de hachage cryptographique est une fonction de hachage dont le comportement est
imprévisible. Les fonctions de hachage, et en particulier les fonctions de hachage cryptographiques,
ont de nombreuses applications en cryptographie, comme nous allons le voir.
Dans la suite du chapitre, nous nous concentrerons sur les notions de sécurité pour les schémas
de chiffrement à clé publique.
3.2 Notions de sécurité
Dans cette section, nous présenterons deux notions de sécurité importantes : l'indiscernabilité et la non-
malléabilité.
Tout d'abord, nous devons définir les modèles et les hypothèses avec lesquels nous allons
travailler. Nous allons considérer deux modèles de sécurité : le modèle standard et le modèle de
33
l'oracle aléatoire.
Définition 23 (modèle standard). Le modèle standard est un modèle de sécurité dans lequel
l'adversaire est limité par le temps et l'espace de calcul disponibles.
Définition 24 (oracle aléatoire). Le modèle de l'oracle aléatoire est un modèle similaire au modèle
standard mais où l'on suppose l'existence d'un oracle qui est un hachage idéal H (par hachage idéal,
on entend une fonction de hachage qui renvoie des nombres vraiment uniformément aléatoires pour
une nouvelle requête et qui renvoie la même valeur pour la même requête).
34
L'oracle aléatoire simule les fonctions de hachage cryptographiques et suppose qu'elles ont un
comportement totalement aléatoire. Il s'agit d'un modèle théorique qui est très utile pour établir des
preuves de sécurité. Le problème est que les oracles aléatoires ne sont pas réalistes dans le sens où
il n'existe aucune preuve théorique ou empirique de l'existence d'un tel oracle. En pratique, la fonction
utilisée comme oracle aléatoire ne se comportera pas comme un véritable oracle aléatoire.
Néanmoins, une preuve dans l'oracle aléatoire nous donne une certaine garantie et un certain espoir
qu'elle puisse être utilisée en pratique. En d'autres termes, une preuve dans l'oracle aléatoire est
mieux que pas de preuve du tout.
3.2.1 Indiscernabilité
Un système de chiffrement à clé publique est indiscernable si, étant donné deux messages et le
chiffrement de l'un d'eux, un adversaire n'est pas capable de dire lequel des messages a été chiffré.
Plus précisément, dans ce scénario (où l'un des messages est chiffré et où l'on demande à
l'adversaire de dire lequel l'a été), l'adversaire a une probabilité négligeable de deviner juste. Il existe
trois notions différentes d'indiscernabilité : l'indiscernabilité en cas d'attaque en texte clair choisi (IND-
CPA), l'indiscernabilité en cas d'attaque en texte chiffré choisi (IND-CCA) et l'indiscernabilité en cas
d'attaque en texte chiffré choisi adaptative (IND-CCA2).
Dans ce qui suit, soit Π = (K, E, D) un système de cryptage à clé publique et soit A un système de
cryptage probabiliste.
adversaire en temps polynomial et C un challenger en temps polynomial probabiliste. Supposons que
le challenger C génère une paire de clés (pk, sk) = K(1k ) où k est le paramètre de sécurité de Π. C
publie pk et garde sk comme un secret.
IND-CPA
Par cryptosystème sécurisé IND-CPA, nous entendons un cryptosystème pour lequel l'adversaire A a
une probabilité négligeable de gagner le jeu suivant :
1. A peut faire un nombre polynomial arbitraire de cryptages ;
2. À un moment donné, A soumet deux messages différents m0 et m1 à C ;
3. C choisit au hasard un bit b ∈ {0, 1} et envoie le challenge-ciphertext c = E (pk, mb ), le

chiffrement de mb , à A ;
4. Là encore, A peut effectuer un nombre polynomial arbitraire de cryptages ;
5. A produit ¯b, une estimation de b.
A gagne le jeu s'il peut deviner correctement le bit b.
INC-CCA
Par cryptosystème sécurisé IND-CCA, nous entendons un cryptosystème pour lequel l'adversaire A a
35
36
1. A peut effectuer un nombre polynomial arbitraire de cryptages et d'appels à un oracle de
décryptage ;

IND-CCA2
Par un cryptosystème sûr IND-CCA2, nous entendons un cryptosystème pour lequel l'adversaire A a
une probabilité négligeable de gagner la partie précédente, à la différence qu'à l'étape 4, l'adversaire
A peut également faire un nombre polynomial d'appels à l'oracle de description, à la condition qu'il ne
puisse pas demander le décryptage de c.
Pour un schéma de chiffrement à clé publique donné Π, nous définissons formellement l'avantage de
l'adversaire A
pour n'importe lequel de ces jeux de la manière suivante :
Π,A
Adv ind-aaa (k) = 2.Pr(¯b = b) - 1
où aaa ∈ {cpa, cca, cca2}. L'avantage mesure les chances de l'adversaire de gagner la partie.
De toute évidence, la propriété la plus forte est la propriété IND-CCA2 : si un cryptosystème est
IND-CCA2, alors il est IND-CCA ; et s'il est IND-CCA, alors il est IND-CPA.
Notez que si l'algorithme de chiffrement du cryptosystème à clé publique Π est déterministe, alors Π
n'est pas sécurisé par IND- CPA : pour qu'un adversaire trouve le bit b étant donné le challenge-
ciphertext, il lui suffit de chiffrer m0
et m1 à l'avance et vérifier quel chiffrement est égal au texte de défi et de chiffrement.
3.2.2 Non-malléabilité
Une autre propriété de sécurité importante est la non-malléabilité . Un cryptosystème non malléable
empêche un adversaire de créer des textes chiffrés valides à partir d'un autre texte chiffré. La
malléabilité est généralement considérée comme une propriété indésirable pour un cryptosystème car
elle menace l'intégrité du message (bien que, dans certains cas, ce soit exactement ce que nous
recherchons, comme dans le cryptage homomorphique). Comme pour l'indiscernabilité, nous pouvons
définir 3 niveaux de sécurité non-malléable : non-malléabilité sous attaque en texte clair choisi (NM-
CPA), non-malléabilité sous attaque en texte chiffré choisi (NM-CCA) et non-malléabilité sous attaque
en texte chiffré choisi adaptative (NM-CCA2). Comme pour l'indiscernabilité, ces trois niveaux ne
diffèrent que par l'utilisation d'un oracle de décryptage par l'adversaire. De même que pour
37
l'indiscernabilité, la non-malléabilité est définie par un jeu où l'adversaire doit construire des
cryptogrammes valides qui correspondent à des messages valides étant donné un cryptogramme
valide.
38
1. A peut effectuer un nombre polynomial arbitraire de cryptages et d'appels à un oracle de décryptage ;

IND-CCA2
Par un cryptosystème sûr IND-CCA2, nous entendons un cryptosystème pour lequel l'adversaire A a
une probabilité négligeable de gagner la partie précédente, à la différence qu'à l'étape 4, l'adversaire
A peut également faire un nombre polynomial d'appels à l'oracle de description, à la condition qu'il ne
puisse pas demander le décryptage de c.
Pour un schéma de chiffrement à clé publique donné Π, nous définissons formellement l'avantage de
l'adversaire A
pour n'importe lequel de ces jeux de la manière suivante :
Π,A
Adv ind-aaa (k) = 2.Pr(¯b = b) - 1
où aaa ∈ {cpa, cca, cca2}. L'avantage mesure les chances de l'adversaire de gagner la partie.
De toute évidence, la propriété la plus forte est la propriété IND-CCA2 : si un cryptosystème est
IND-CCA2, alors il est IND-CCA ; et s'il est IND-CCA, alors il est IND-CPA.
Notez que si l'algorithme de cryptage du système de cryptage à clé publique Π est déterministe,
alors Π n'est pas sécurisé par IND- CPA : pour qu'un adversaire trouve le bit b étant donné le
challenge-ciphertext, il lui suffit de crypter m0 et m1 au préalable et de vérifier quel cryptage est égal
au challenge-ciphertext.
3.2.2 Non-malléabilité
Une autre propriété de sécurité importante est la non-malléabilité . Un cryptosystème non malléable
empêche un adversaire de créer des textes chiffrés valides à partir d'un autre texte chiffré. La
malléabilité est généralement considérée comme une propriété indésirable pour un cryptosystème car
elle menace l'intégrité du message (bien que, dans certains cas, ce soit exactement ce que nous
recherchons, comme dans le cryptage homomorphique). Comme pour l'indiscernabilité, nous pouvons
définir 3 niveaux de sécurité non-malléable : non-malléabilité sous attaque en texte clair choisi (NM-
CPA), non-malléabilité sous attaque en texte chiffré choisi (NM-CCA) et non-malléabilité sous attaque
en texte chiffré choisi adaptative (NM-CCA2). Comme pour l'indiscernabilité, ces trois niveaux ne
20
diffèrent que par l'utilisation d'un oracle de décryptage par l'adversaire. Comme pour l'indiscernabilité,
la non-malléabilité est définie par un jeu où l'adversaire doit construire des cryptogrammes valides qui
correspondent à des messages valides étant donné un cryptogramme valide.
21
Encore une fois, laissez Π = (K, E, D) être un cryptosystème à clé publique et laissez A être un
adversaire et C un challenger. Supposons que le challenger C génère une paire de clés (pk, sk) = K(1k
) où k est le paramètre de sécurité de Π. C publie pk et garde sk comme un secret.
NM-CPA
Par cryptosystème sécurisé NM-CPA, nous entendons un cryptosystème pour lequel l'adversaire A a
1. A peut faire un nombre polynomial arbitraire de cryptages ;
2. A produit un espace de messages M ;
3. C choisit un message m de M au hasard et le chiffre. Il envoie c = E (pk, m) à A ;
4. Étant donné c, A produit (R, c ¯ ) , où R est une relation et c¯ est un vecteur (c1 , . . . , ck ) pour un
certain k ∈ N. Ici
c¯ est une estimation des cryptogrammes telle que leur décryptage est lié à m par la relation R.
NM-CCA
Par cryptosystème sécurisé NM-CCA, nous entendons un cryptosystème pour lequel l'adversaire A a
1. A peut effectuer un nombre polynomial arbitraire de cryptages et d'appels à un oracle de décryptage ;
2. A produit un espace de messages M ;
3. C choisit un message m de M au hasard et le chiffre. Il envoie c = E (pk, m) à A ;
4. A produit (R, c ¯ ) .
NM-CCA2
Par cryptosystème sécurisé NM-CCA2, nous entendons un cryptosystème pour lequel l'adversaire A a
une probabilité négligeable de gagner la partie précédente, à la différence que, avant de sortir (R,
c ¯ ) , l'adversaire A a accès à un oracle de décryptage qu'il peut interroger un nombre polynomial de
fois.
Pour un schéma de chiffrement à clé publique donné Π, nous définissons l'avantage de

l'adversaire A pour l'un de ces jeux de la manière suivante :
Π,A
Adv nm-aaa (k) = Pr = D(sk, c) : c ∈/ c ¯ ∧ ⊥ ∈ / m¯ ∧ R(m, m¯ )]- = D(sk, c) : c ∈/ c ¯ ∧ ⊥ ∈ / m¯ ∧ R(mt ,
[m¯ Pr [m¯ m¯ )]
où aaa ∈ {cpa, cca, cca2} et mt ∈ M tel que m /= mt . Pour empêcher l'adversaire de gagner le jeu
en donnant des réponses triviales, c¯ ne peut pas avoir le texte chiffré de défi et chaque texte chiffré
dans c¯ doit être un texte valide un déchiffrer à un message valide (nous empêchons cela en laissant
⊥ ∈ / m¯ , où ⊥ est le résultat de déchiffrer un texte chiffré invalide).
22
Encore une fois, notez que la propriété la plus forte est celle de NM-CCA2.
23
3.2.3 Relations entre les notions de sécurité
L'indiscernabilité et la non-malléabilité peuvent sembler deux concepts très différents mais, en fait, il
existe des relations entre eux. Ces relations ont été prouvées par Belare et al. dans [3]. Nous allons
présenter certains des résultats les plus pertinents concernant ces relations. Dans la figure 3.1, nous
pouvons voir les relations entre toutes les notions de sécurité introduites jusqu'à présent.
→ A B signifie que A implique B. A/→B signifie qu'il existe,

Figure 3.1 : Schéma des notions de sécurité [3].
au moins, un cryptosystème qui possède la propriété A mais pas la propriété B.
Théorème 25 ([3]). Soit Π un cryptosystème à clé publique. Si Π est sécurisé par NM-CPA alors il est
sécurisé par IND-CPA (l'inverse n'est pas vrai).
Théorème 26 ([3]). Soit Π un cryptosystème à clé publique. Si Π est sécurisé par NM-CCA alors il est
sécurisé par IND-CCA (l'inverse n'est pas vrai).
Théorème 27 ([3]). Soit Π un cryptosystème à clé publique.
Π est IND-CCA2 ⇐⇒ Π est NM-CCA2 sécurisé.
Dans les théorèmes 25 et 26, lorsque nous disons que l'implication inverse n'est pas vraie, nous
voulons dire qu'il existe au moins un cryptosystème qui satisfait la sécurité IND-CPA (IND-CCA, resp.)
qui ne satisfait pas la sécurité NM- CPA (NM-CCA, resp.). De manière informelle, casser la non-
malléabilité est généralement plus difficile que casser l'indiscernabilité, sauf si on nous donne un
oracle de décryptage après le texte chiffré de défi. Dans ce cas, bien que cela puisse ne pas sembler
intuitif, l'indiscernabilité et la non-malléabilité sont la même chose.
3.3 Sensibilisation au texte brut
Pour un cryptosystème donné, un adversaire peut souvent produire des cryptogrammes valides pour
lesquels il ne connaît pas le message correspondant. Cela peut être fait en utilisant, par exemple, la
malléabilité du cryptosystème. Un cryptosystème est conscient du texte en clair si un adversaire ne
peut pas produire un texte chiffré valide sans connaître le message correspondant, c'est-à-dire que la
seule façon de créer un texte chiffré valide est de suivre le processus de chiffrement d'un
cryptosystème. Bien que très facile à expliquer intuitivement, il n'est pas trivial de formaliser cette
définition. Formellement, la définition de la connaissance du texte en clair a été présentée pour la
première fois dans [4], puis elle a été affinée dans [3]. La définition que nous allons présenter ici est la
dernière. Tout au long de cette section, nous travaillerons exclusivement dans le modèle de l'oracle
24
aléatoire, puisque la définition de la connaissance du texte en clair que nous présenterons n'a de sens
que dans ce modèle de sécurité.
25
Définition 28 (connaissance du texte en clair). Soit Π = (K, E, D) un schéma de chiffrement à clé
publique, A un adversaire, H une fonction de hachage cryptographique et K un algorithme appelé
extracteur de connaissance. Considérons le jeu suivant entre un challenger C et l'adversaire A.
• C crée une paire de clés (pk, sk) = K(1k ). Il publie pk.
• A a accès à l'oracle H et à un oracle de chiffrement. Elle peut effectuer un nombre

polynomial de requêtes à chaque oracle. Finalement, elle produit (τ, η, y) où τ = {(h1 , H1 ), . .
. , (hq H , Hq h )} est une liste de requêtes h1 , ... . , hq H à l'oracle H et les réponses
correspondantes H1 , . . . , Hq H , η =
{y1 , . . . , yq E } est une liste de réponses reçues par A aux requêtes faites à l'oracle de chiffrement et
y ∈/ η.
• C utilise l'algorithme K, qui reçoit en entrée (τ, η, y, pk), pour essayer de trouver le décryptage de y.
Nous définissons
Adv K,Π,B (k) := Pr[K(τ, η, y, pk) = D(sk, y)].
pa
K,Π,B (k)
pa polynomial et Adv
Nous disons que K est un extracteur de connaissance λ(k) si K s'exécute en temps
≥ λ(k).
Si Π est sécurisé par IND-CPA et qu'il existe un extracteur de connaissance λ(k) K, où 1 - λ(k) est
une valeur négligeable, alors nous disons que Π est sécurisé par connaissance du texte en clair (PA).
De manière informelle, un extracteur de connaissances reçoit un texte chiffré et essaie de trouver

son déchiffrement en utilisant uniquement les requêtes faites par A et les réponses respectives à
l'oracle de hachage et aux réponses de l'oracle de chiffrement. Encore une fois, nous pouvons relier le
concept de connaissance du texte en clair avec les concepts de sécurité d'indiscernabilité.
bilité et non-malléabilité. En fait, la connaissance du texte en clair est la propriété de sécurité la plus
forte. Cela signifie que si l'on ne peut construire des ciphertexts valides qu'en suivant l'algorithme de
cryptage, on ne peut pas distinguer les ciphertexts.
Théorème 29 ([3]). Si un système de cryptage à clé publique est sécurisé par PA, alors il est sécurisé par
IND-CCA2.
En guise de corollaire, nous pouvons affirmer que si un système de cryptage à clé publique est sécurisé
PA, il est sécurisé NM-CCA2.
3.4 Fujisaki-Okamoto IND-CCA2 conversion générique
Malheureusement, les cryptosystèmes sécurisés IND-CCA2 ne sont pas faciles à construire. Mais,
bien que la plupart des cryptosystèmes ne soient pas sécurisés par IND-CCA2, il existe quelques
conversions génériques, que nous pouvons appliquer à un cryptosystème qui n'est pas sécurisé par
IND-CCA2 pour obtenir un nouveau cryptosystème qui est sécurisé par IND-CCA2.
Dans cette thèse, nous présentons une de ces conversions, la version simple IND-CCA2 de
Fujisaki-Okamoto [21]. Nous pensons qu'il s'agit de l'une des conversions les plus simples et les plus
26
efficaces dont nous disposons.
sont conscients. La conversion a pour but de construire un nouveau cryptosystème sécurisé IND-CCA2 Π¯
= ( K ¯ , E¯, D ¯ ) , dans la
modèle d'oracle aléatoire, d'un cryptosystème sécurisé IND-CPA Π = (K, E, D), où K est l'algorithme
de création de clé, E est l'algorithme de cryptage et D est l'algorithme de décryptage. Le
cryptosystème est présenté dans l'Algorithme 4. Avant d'examiner le cryptosystème, nous avons
besoin d'une petite définition.
27
Définition 30 (cryptosystème γ-uniforme). Soit Π un cryptosystème à clé publique. Pour tout message
m et tout texte chiffré c, on dit que Π est γ-uniforme si, compte tenu d'un message m et d'un texte
chiffré c, la probabilité de
deviner les pièces de chiffrement r au hasard de sorte que E (pk, m ; r) = c est inférieur ou égal à γ.
De manière informelle, cette valeur γ mesure le caractère aléatoire qui est utilisé dans le
chiffrement d'un message dans le cryptosystème Π. Si le cryptage d'un certain schéma de cryptage à
clé publique est complètement déterministe, alors γ = 1. Pour que cette conversion fonctionne, γ < 1.
Rappelons que si le chiffrement d'un cryptosystème Π est déterministe, alors Π n'est pas sécurisé
IND-CPA.
Nous présentons maintenant la conversion dans l'Algorithme 4. L'idée est très simple : le message
concaténé avec une chaîne aléatoire1 déterminera les pièces aléatoires utilisées dans le processus de
cryptage. En d'autres termes, elles détermineront le caractère aléatoire utilisé dans le cryptage. Lors
du décryptage du texte chiffré, il suffit de vérifier si le chiffrement du message à l'aide de ces pièces
est le texte chiffré reçu ; si ce n'est pas le cas, alors ce texte chiffré est invalide.
Algorithme 4 Conversion générique Π¯ = ( K ¯ , E¯, D ¯ ) de [21] basée sur un cryptosystème Π = (K, E, D).
Paramètres : Identique à Π plus une fonction de hachage cryptographique H.
Création de clés : Identique à Π.
Cryptage : Nous définissons le cryptage
c = E¯(pk, m ; s) = E (pk, (m|s) ; H(m|s))
où s est une chaîne aléatoire. Le caractère aléatoire du chiffrement de Π est défini par la fonction de
hachage H. Déchiffrement : Pour décrypter un texte chiffré c, appliquer l'algorithme de décryptage
D de Π pour obtenir (m|s). On vérifie si c est un texte chiffré valide en testant si
c = E pk, D(c) ; H D(c) .
Théorème 31 ([21]). La conversion Π¯ est sécurisée par IND-CCA2 dans le modèle de l'oracle
aléatoire étant donné que Π est sécurisé par IND-CPA et γ-uniforme.
La preuve de ce théorème se fait en prouvant l'existence d'un extracteur de connaissances, tel que
K,Π,B (k) ≥ γ,
Advpa
et en prouvant que Π est IND-CPA secure. Par conséquent, nous pouvons conclure que Π est
sécurisé PA et, par Théo- rem 29, Π est sécurisé IND-CCA2.
28
1 Nous pouvons parfois appeler chaîne un vecteur, comme cela arrive fréquemment dans la littérature. Si x et y sont deux
vecteurs (ou chaînes de caractères), nous désignerons leur concaténation par x|y. Nous pouvons également désigner cette
opération par padding.
29
Chapitre 4
Cryptosystème McEliece
Depuis que Diffie et Hellman ont introduit le concept de cryptographie à clé publique [15], de
nombreux systèmes de cryptage à clé publique (PKC) ont été proposés par la communauté
cryptographique. Les plus connus et les plus utilisés en pratique sont le RSA, basé sur le problème de
la factorisation des nombres entiers [47], et le PKC d'El Gamal, basé sur le problème du logarithme
discret [17]. La situation pourrait être dramatique si l'on parvenait à trouver un algorithme pratique
capable de résoudre l'un de ces problèmes, et donc de briser les cryptosystèmes. Malheureusement,
personne ne peut dire si un tel algorithme sera ou ne sera pas trouvé.
En fait, Shor a déjà trouvé un algorithme quantique en temps polynomial qui résout le problème de
la factorisation des entiers et le problème du logarithme discret [51]. Comme il s'agit d'un algorithme
quantique, il ne peut pas encore être utilisé dans la pratique. Cependant, plusieurs propositions
alternatives apparaissent pour remplacer le RSA PKC et le El Gamal PKC. Ces alternatives sont
basées sur des problèmes de calcul difficiles qui ont été récemment présentés et qui sont supposés
ne pas pouvoir être résolus en temps polynomial, même par des ordinateurs quantiques. La
cryptographie post-quantique traite des algorithmes cryptographiques classiques basés sur ces
problèmes, et donc des algorithmes cryptographiques qui sont supposés être robustes aux attaques
quantiques, c'est-à-dire qui sont dans la classe de complexité BQP . Les problèmes basés sur les
codes, les treillis et les polynômes multivariés font partie de ces problèmes et sont actuellement
utilisés pour la cryptographie post-quantique [10].
Parmi ces cryptosystèmes, nous avons le cryptosystème de McEliece proposé par Robert
McEliece [39] qui est un cryptosystème basé sur le code. Ce cryptosystème est l'un des plus anciens
cryptosystèmes à clé publique encore sûrs et constitue donc un candidat très intéressant pour la
cryptographie post-quantique. Bien qu'il n'existe pas de réduction de sécurité pour la PKC de
McEliece, la cryptanalyse approfondie dont elle a fait l'objet au fil des ans n'a pas permis de trouver
des attaques en temps polynomial. Ce fait a renforcé la conjecture selon laquelle le cryptosystème de
McEliece n'est pas efficacement cassable.
Dans ce chapitre, nous allons analyser le PKC de McEliece. Nous commencerons par présenter,
dans la Section 4.1, le cryptosystème ainsi que sa version double, le PKC de Niederreiter. Dans la
section 4.2, nous analyserons la sécurité du cryptosystème de McEliece et nous explorerons certaines
30
de ses faiblesses. La section 4.3 est celle où nous analysons la complexité et l'efficacité
computationnelle de la PKC de McEliece, deux aspects très importants qui doivent être pris en compte
à des fins pratiques. Dans la section 4.4, nous présenterons quelques variantes connues de la PKC.
31
ants qui répondent à certaines propriétés de sécurité importantes, comme IND-CPA et IND-CCA2.
Enfin, dans la section 4.5, nous parlerons de l'utilisation des codes LDPC dans la PKC de McEliece et
de ses avantages et inconvénients.
4.1 Le cryptosystème
La PKC de McEliece a été présentée par Robert McEliece dans [39]. Il reste inviolable et on suppose
également qu'il est robuste aux attaques quantiques. Le cryptosystème de McEliece est décrit dans
l'algorithme 5.
Algorithme 5 Système de cryptage à clé publique McEliece

Paramètres de sécurité : n, t ∈ N avec t << n.
Création de la clé : Choisir un code Goppa G2 ⊂ Zn : Il doit s'agir d'un code à k dimensions de
longueur n qui peut corriger jusqu'à t erreurs. Générer les matrices G, S et P où :
G est une matrice génératrice de G de taille k × n ;
S est une matrice non singulière k × k choisie au
hasard ; P est une matrice de permutation n × n
choisie au hasard ; Calculez Gpub = SGP , une
matrice k × n.
Clé publique : (Gpub , t).
Clé privée : (S, P, DG ) où DG est un algorithme de décodage pour G, typiquement l'algorithme de
Patterson.
Cryptage : Choisir e ∈ Zn aléatoirement de telle sorte que e ait un poids t. Pour chiffrer un message m ∈
Zk , on
2 2
doit calculer le texte chiffré c

c = mGpub + e.
Décryptage : Pour décrypter c, il faut calculer cP−1 , puis appliquer DG au résultat et enfin multiplier par
S−1 pour faire passer le message m.
Les paramètres de sécurité du cryptosystème de McEliece sont n et t qui vont définir le code utilisé
pour créer les clés. La dimension du code k ne peut être choisie indépendamment, puisqu'elle est une
fonction de n et de t (chapitre 2). Pour que les attaques soient inefficaces, t doit croître en même
temps que n (nous discuterons du choix des paramètres plus tard).
La proposition 32 nous dit que le cryptosystème de McEliece est correct.
Proposition 32. Soit c le chiffrement de m à l'aide du système cryptographique de McEliece. En

appliquant l'algorithme de dé-cryptage du McEliece à c on obtient m.
Preuve. Soit (Gpub , t) une clé publique du cryptosystème de McEliece, soit c = mGpub + e le cryptage
d'un message m à l'aide de ce cryptosystème. Nous allons appliquer l'algorithme de décryptage à c.
En multipliant c par P−1 nous obtenons
cP−1 = (mGpub + e)P−1 = (mSGPP−1 + eP−1 ) = mSG + eP−1

32
et notez que eP−1 est toujours un vecteur de poids t. Donc, en appliquant l'algorithme de décodage de
Patterson, nous pouvons extraire mS de mSG + eP−1 . Ensuite, il suffit de multiplier par S−1 pour
récupérer m.
33
Un exemple simple de l'algorithme 5 est présenté.
Exemple 33. Supposons que Bob veuille envoyer un message m à Alice. D'abord Alice choisit un code de
Goppa
G ; supposons qu'elle choisisse le code avec la même matrice de générateur G que dans l'exemple 4 :
110110000001
111011010010
G= .
011010100100
0
1 1000010100
Ensuite, elle choisit au hasard une matrice non singulière S de taille 4 et une matrice de
permutation P de taille 12, par exemple,
0
1 0000000000
001000000000
0 0 0000001000
000001000000
1
1 00 0 00010000000
0 100 0 10000000000
S= ;P= .
1100 0 00100000000
1
0 01 000000000001
0 00000010000
0 00000000100
000000000010
0
0 0000010000
Elle calcule Gpub = SGP et publie la paire (Gpub , t = 2) comme sa clé publique :
0 0
0 0 1 1 1 1 1 0 0 0
Gpub =
1 1 1 0 1 0 0 0 1 0 1
1.
010001101011
0
1 0001001110
Supposons que Bob veuille chiffrer le message m = (1, 0, 1, 1) en utilisant la clé publique d'Alice. Il
calcule d'abord
mGpub = (1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1)
puis il choisit un vecteur aléatoire e de poids t = 2, par exemple
e = (0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0).
34
Il calcule
c = mGpub + e = (1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1)
et envoie c à Alice.
Pour qu'Alice puisse déchiffrer le code c à l'aide de sa clé privée, elle calcule d'abord
cP−1 = (1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0)
puis elle applique l'algorithme de Patterson (Algorithme 1 à la page 9) à cP−1 pour obtenir mt = (0, 1, 1,
0) et enfin elle calcule mt S−1 pour récupérer le message m.
4.1.1 Le système cryptographique de Niederreiter
Le cryptosystème de Niederreiter a été proposé par Harald Niederreiter en 1986, dans [43]. Il est très
similaire au cryptosystème de McEliece ; en fait, le cryptosystème de Niederreiter est la version duale
du cryptosystème précédent. La principale différence est que l'espace du message est l'ensemble des
erreurs de poids t d'un code C donné et que le message est crypté sous forme de syndrome.
Puisque ce protocole ne chiffre que les mots de longueur n et de poids t, nous avons besoin d'une fonction
pour transformer chaque mot de longueur n en un mot de poids t.
mot dans2Zl dans un mot qui peut être chiffré. Soit φn,t2: Zl → Wn,t , où Wn,t = {e ∈ Zn2: wt(e) = t}
et l = llog |Wn,t |J, soit cette fonction. Une construction explicite de cette fonction peut être trouvée
dans [20] mais nous la traiterons comme une boîte noire.
De plus, et puisque ce cryptosystème est la version duale du précédent, nous aurons besoin d'un
algorithme de décodage différent. Nous l'appellerons l'algorithme de décodage du syndrome.
Définition 34. Soit C un code qui corrige jusqu'à t erreurs et H sa matrice de contrôle de parité. Soit e
un vecteur d'erreur avec wt(e) ≤ t. Un algorithme de décodage de syndrome SD est un algorithme tel
que, étant donné un syndrome s = eHT , il produit e.
Proposition 35. Soit C un code avec des paramètres [n, k, d] qui corrige jusqu'à t erreurs. S'il existe
un algorithme de décodage D, alors il existe un algorithme de décodage de syndrome SD, et vice
versa.
Preuve. Soit G et H la matrice génératrice et la matrice de contrôle de parité de C, respectivement.

Soit e un vecteur d'erreur avec wt(e) ≤ t.
Soit SD un algorithme de décodage de syndrome de C tel que pour tout e ∈ Wn,t nous avons
SD(eHT ) = e. Étant donné un mot mG + e nous voulons dériver un algorithme de décodage D tel que
D(mG + e) = mG. Nous pouvons le faire
de la manière suivante : multipliez mG + e par HT pour obtenir eHT , puis calculez mG = (mG + e) + SD(eHT ).
Maintenant, étant donné un algorithme de décodage D, nous allons construire un algorithme de
décodage de syndrome. Étant donné un syndrome s = eHT , nous devons d'abord trouver un vecteur
et tel que et HT = s (ceci peut être fait en temps polynomial, voir le chapitre 2). Nous savons que et - e
est un mot de code de C, puisque
35
(et - e)HT = et HT - eHT = s - s = 0.
36
Ainsi, et = w + e où w est un mot de code de C. Ensuite, nous appliquons D à et pour obtenir w et, enfin,
nous pouvons calculer
e = et - w.
Une description de la PKC de Niederreiter est présentée dans l'algorithme 6. Habituellement, le code
utilisé dans le cryptosystème est un code Goppa.
Algorithme 6 Système de cryptage à clé publique de Niederreiter

Paramètres de sécurité : n, t ∈ N avec t << n.
Création de la clé : Choisir un code binaire de dimension k C de longueur n qui peut corriger jusqu'à t
erreurs. Générer les matrices H, S et P où :
H est une matrice de contrôle de parité de C de
taille (n - k) × k ; S est une matrice non singulière
k × k choisie au hasard ; P est une matrice de
permutation n × n choisie au hasard.
Calculer Hpub
k×n= SHP .
Clé publique : (Hpub , t).

Clé privée : (S, P, SDC ) où SDC est un algorithme de décodage syndromique pour C.
Cryptage : Pour crypter m ∈ Z2 l , calculer φn,t (m) = e où φn,t est une fonction qui prend un
message
2 dans Zl et le fait correspondre à un vecteur de longueur n et de poids t. Calculer le texte
chiffré c comme suit
c = e(Hpub )T .
Décryptage : Pour décrypter c, on calcule c(S−1 )T = ePT HT , puis on applique SDC pour obtenir ePT .
Enfin, calculez
e = ePT (P−1 )T et récupérer m avec m = φ−n,t
1 (e).
L'avantage d'utiliser ce protocole au lieu du système cryptographique de McEliece est que les clés
sont beaucoup plus petites et que le cryptage est plus rapide (bien que le décryptage prenne plus de
temps) [10]. Un autre avantage est qu'il peut être utilisé pour produire un schéma de signature
sécurisé [14].
4.2 Sécurité
Dans cette section, nous allons d'abord parler des hypothèses sur lesquelles la sécurité du système de
cryptage de McEliece est basée. Ensuite, nous passerons en revue certaines des attaques les plus
importantes sur le cryptosystème. Enfin, nous analyserons les paramètres de sécurité du McEliece
ainsi que le niveau de sécurité et la taille des clés correspondants.
Sécurité du McEliece
37
Nous définissons le problème de McEliece :
Problème 36 (problème de McEliece). Étant donné une clé publique pk et un texte chiffré c, qui a été
obtenu en chiffrant un message m en utilisant le système de cryptage McEliece avec pk, récupérer le
message m.
38
Le système de cryptage de McEliece, comme d'autres systèmes de cryptage, repose sur le
problème de la recherche exhaustive (qui est un problème difficile à calculer), puisque nous pouvons
définir le problème de McEliece comme suit : compte tenu de
une clé publique (Gpub , t) et un texte chiffré 2c ∈ Zn , trouver le message
2 m ∈ Z tel que wt(mG
k pub - c) = t.
Évidemment, résoudre le problème de McEliece est équivalent à casser le cryptosystème de

McEliece. Ceci peut être fait de deux manières : récupérer le message m directement ou récupérer la
clé secrète à partir de la clé publique.
Tout d'abord, nous allons parler de la sécurité du message. La sécurité du message dans le
cryptosystème de McEliece repose sur la dureté du Vecteur de Syndrome Computationnel puisque
nous pouvons définir le
Le problème de McEliece est le suivant : étant donné un code de Goppa irréductible G sur Z2 et un texte
chiffré c, trouvez un vecteur
e avec un poids wt(e) ≤ t tel que c + e est un mot de code permuté de C. Il est donc évident que si on
résout le problème du vecteur de syndrome computationnel, alors on casse le cryptosystème (à part la
permutation). Mais les problèmes ne sont pas connus pour être équivalents. La réciproque n'est pas
connue pour être vraie, puisque si l'on casse le cryptosystème, on ne résout le problème du vecteur
de syndrome computationnel que pour une certaine classe de codes, à savoir, dans ce cas, les codes
Goppa. Mais on peut choisir les paramètres de
le code G de manière à ce que le cryptosystème de McEliece soit aussi difficile que le cryptosystème de
Computational
Problème du syndrome. De manière équivalente, nous pouvons dire que le cryptosystème McEliece
repose sur le problème de l'apprentissage avec bruit de parité (LPN), un problème classique de la
théorie de l'apprentissage.
Problème 37 (apprentissage avec bruit de parité). Soit s (le secret) un mot de longueur l. Étant donné la
paire
(a, (s, a) + e)
où a ∈ Zl , (s,
2 a) désigne le produit interne habituel de s et a, et e est choisi à l'aide de la distribution de
Bernoulli Bθ avec le paramètre θ ∈ [0, 1/2], trouver s.
Ce problème est également conjecturé comme étant dur, et il est souvent utilisé pour argumenter
que le système cryptique McEliece est difficile à casser. Il est utile, dans certaines circonstances,
d'utiliser la dureté de ce problème pour les preuves au lieu de la dureté du problème du vecteur de
syndrome computationnel, comme nous le verrons plus tard.
Une autre hypothèse sur laquelle la sécurité de la PKC de McEliece est basée est la difficulté de
distinguer une matrice génératrice de code Goppa permutée d'une matrice binaire choisie au hasard
(uniformément) [14].
Problème 38 (problème de distinction de Goppa). Étant donné une matrice Mk×n , on obtient 1 si M
représente une matrice génératrice d'un code de Goppa et 0 si M a été choisie uniformément au
39
hasard (c'est-à-dire que chaque coordonnée de M a été choisie uniformément au hasard).
Bien qu'il n'y ait pas de preuve que ce problème soit NP -complet, il reste insoluble pendant
longtemps et, par conséquent, il est considéré comme un problème difficile. Cela ne se produit pas
avec d'autres classes de codes. Plusieurs tentatives d'utiliser d'autres codes dans le McEliece, avec
l'objectif de réduire la taille de la clé ou d'augmenter l'efficacité, se sont avérées des échecs car tous
révèlent presque immédiatement leur structure et cela peut être utilisé pour casser le cryptosystème
[10, 41, 52]. Mais étonnamment, les théoriciens du codage n'ont pas trouvé le moyen de distinguer les
matrices génératrices de codes de Goppa des matrices aléatoires.
40
Nous concluons que, dans le cryptosystème McEliece, la sécurité du message est basée sur le
problème du Vecteur de Syndrome Com- putationnel (ou, parfois, sur le problème de l'Apprentissage
avec Bruit de Parité) et la sécurité de la clé publique est basée sur le problème du Distinguisseur de
Goppa. En supposant que les problèmes du vecteur de syndrome computationnel et du distinguateur
de Goppa sont difficiles, nous pouvons conjecturer que le problème du McEliece est difficile.
Attaques contre le McEliece
Plusieurs attaques ont été trouvées contre le cryptosystème McEliece. Si certaines d'entre elles
peuvent être évitées en augmentant simplement les paramètres de sécurité, d'autres sont plus
difficiles à prévenir car elles sont basées sur la structure du cryptosystème. Dans ce qui suit, nous
utiliserons la même notation que dans l'Algorithme 5. Nous présentons maintenant certaines de ces
attaques :
• Attaque par décodage d'ensemble d'informations : Le décodage par ensemble

d'informations est un algorithme permettant de décoder n'importe quel code arbitraire. Bien qu'il
puisse être appliqué à n'importe quel code, il n'est pas très efficace si les paramètres du
cryptosystème de McEliece sont choisis correctement. Néanmoins, cette attaque (ou des
variantes de celle-ci) est la plus connue. L'idée de cette attaque est de choisir un ensemble de
coordonnées du texte chiffré non affecté par le vecteur d'erreur et cet ensemble doit être
suffisammentKgrand pour que les colonnes de la matrice du générateur public soient une matrice
inversible. Autrement dit, on choisit KK⊂ {1, . . . n} avec k éléments (k est la dimension du code).
Gpub , cK et eK sont formées par les colonnes de Gpub , c et e (respectivement) dans les positions
des éléments de K. Donc, si eK = 0 et Gpub est inversible, alors
m = cK (Gpub )−1 = (ck + ek )(Gpub )−1

K K
et le message m peut être récupéré. Ce processus prend au moins Ω(n2 ) opérations (pour multiplier
( (n-t/
matrices, il faut au moins les écrire) et pour réussir, il faut l'itérer n// k k
fois. Ainsi, la complexité1 de cette attaque est
(n/ !
Ωn ( n-t
2 k
k / .
Ainsi, en élargissant simplement les paramètres, l'attaque devient infaisable.
Les attaques les plus connues contre le PKC de McEliece sont des variantes et des optimisations de
cet algorithme, comme l'attaque de Stern [56].
• Attaque quantique : L'attaque quantique la plus connue du cryptosystème de McEliece est

l'attaque par décodage d'ensemble quantique, qui est basée sur l'algorithme de Grover [9].
L'idée principale est d'utiliser l'algorithme de Grover pour augmenter la vitesse de l'attaque par
41
décodage d'ensemble d'informations. Cette approche augmente
1 Dans cette thèse, nous présentons des bornes inférieures sur la complexité des attaques (notation Big-Omega), au lieu des
bornes supérieures habituelles utilisées pour analyser la complexité des algorithmes (notation Big-O).
42
la vitesse d'attaque considérablement et sa complexité est
s (n/ !
Ωn 2 (k n-t /
0.29 k
ce qui signifie que les paramètres doivent être augmentés de manière substantielle si l'on
souhaite que le cryptosystème McEliece soit robuste aux attaques quantiques.
• Attaque en connaissant une partie du texte en clair : La connaissance d'une partie du texte
en clair réduit considérablement le coût de calcul d'une attaque par force brute du système
cryptographique de McEliece [13]. Supposons que m = ml |mr et que l'adversaire connaît ml .
Nous avons k = kl + kr où kl (kr , resp.) est la longueur de ml (mr , resp.). La difficulté de
récupérer le message m est alors réduite à la récupération d'un message à partir d'un
cryptosystème McEliece avec des paramètres plus petits, à savoir n et kl . Des preuves
empiriques montrent que la connaissance d'environ 23% du texte en clair est suffisante pour
récupérer le message entier pour les paramètres de sécurité originaux du PKC (ces paramètres
seront présentés plus tard).
• Malléabilité de la PKC de McEliece : Puisque la PKC de McEliece est basée sur l'algèbre
linéaire, le système cryptique est extrêmement vulnérable aux attaques de malléabilité [57].
Notez que, même sans connaître le texte en clair, un adversaire peut modifier le texte chiffré de
manière à ce que le texte en clair soit également modifié. Si c est le chiffrement de m, alors
l'adversaire choisit un autre message mt et il peut créer un texte chiffré valide ct pour m + mt en
calculant
c + mt Gpub = mGpub + e + mt Gpub = (m + mt )Gpub + e = ct .
Pour cette raison, McEliece n'est pas robuste contre les attaques par texte chiffré choisi, comme nous
le verrons plus tard.
La malléabilité permet également des attaques par messages connexes [12]. Ce type d'attaque
se produit lorsque l'adversaire chiffre deux messages pour lesquels il sait qu'il existe une relation
entre eux. Par exemple, lorsque l'adversaire chiffre deux fois le même message m, on obtient c1
= mGpub + e1 et c2 = mGpub + e2 . Si un adversaire possède ces cryptogrammes, il obtient
c1 + c2 = (mGpub + e1 ) + (mGpub + e2 ) = e1 + e2
et si t << n/2, si une coordonnée est égale à 0 dans e1 +e2 , elle est égale à 0 dans e1 et dans e2 ,
avec une très forte probabilité. Compte tenu de ces informations, il serait plus facile pour un
adversaire d'utiliser, par exemple, une attaque de décodage d'ensemble d'informations pour
récupérer le message.
• Clés faibles : Un autre aspect important que nous devons prendre en compte pour avoir une
PCC de McEliece sécurisée est le choix des clés. Le nombre de polynômes différents des codes
43
de Goppa est très élevé, ce qui ne permet pas une recherche exhaustive d'une clé donnée.
Cependant, il est prouvé que, pour certains choix de clés, le cryptosystème devient cassable
[32]. Ces clés sont obtenues en choisissant des polynômes de la forme g(x) = xt , où g est le
polynôme qui définit le code Goppa utilisé comme clé publique. Mais le nombre de clés qui
permettent cette attaque est trop faible, il suffit donc d'éviter
44
en choisissant l'une de ces touches.
• Attaque à haut débit : Les PKC de McEliece utilisant des codes de Goppa avec un taux élevé
(i.e., avec très peu de redondance) sont aussi cassables [19]. En choisissant un code de Goppa
avec un taux proche de 1, il existe un algorithme qui est capable de briser le problème du
Distinguisseur de Goppa pour ces paramètres. Cela signifie qu'un adversaire est capable de
trouver la clé secrète associée à ce code.
Comme nous pouvons le voir, il existe plusieurs attaques contre la PKC de McEliece, certaines
d'entre elles sont assez efficaces mais, pour autant que nous le sachions, nous pouvons toujours
changer les paramètres ou apporter de petites modifications au cryptosystème pour empêcher les
attaques. Nous concluons qu'il y a des clés qui ne devraient pas être choisies afin d'éviter les clés
faibles et les attaques à haut débit. Plus tard, nous verrons comment nous pouvons éviter les attaques
de malléabilité sur la PKC de McEliece.
Il convient de mentionner que la sécurité du cryptosystème de Niederreiter est équivalente à la
sécurité de McEliece [31]. Ils sont tous deux basés sur les mêmes problèmes de calcul et il est prouvé
que pour un choix approprié de paramètres, ils atteignent le même niveau de sécurité.
Choix des paramètres
Nous allons maintenant analyser le choix des paramètres du cryptosystème. A l'origine dans [39],
l'auteur propose de choisir un code de Goppa G de longueur n = 1024 = 210 et de fixer t = 50, et donc
le code a une dimension 1024-50×10 = 524. La raison du choix de ces paramètres est d'essayer de
rendre le prob- lem de casser le cryptosystème aussi difficile que le problème du vecteur de syndrome
computationnel. Pour ce choix de paramètres, nous rendons également les attaques par force brute
infaisables. Le cryptosystème de McEliece est devenu moins sûr pour ces paramètres et au fil des
années, plusieurs nouveaux paramètres ont été proposés [1, 11, 42].
Dans le tableau 4.1, nous pouvons voir les paramètres clés et les estimations de sécurité pour le
cryptosystème McEliece. Toutes les valeurs sont en bits, sauf mention contraire. La sécurité du
message est une estimation du temps nécessaire à l'attaque de décodage de l'ensemble
d'informations pour réussir (dans la colonne Sécurité) et du temps de l'attaque de décodage de
l'ensemble d'informations quantique (colonne Sécurité PQ) pour récupérer le message. Nous
utiliserons la complexité présentée ci-dessus pour calculer les estimations, bien qu'il ne s'agisse pas
des meilleures limites connues sur la complexité des attaques (il existe des optimisations pour celles-
ci [56]). Néanmoins, cela nous donnera une idée de la sécurité que nous pouvons atteindre pour un
certain choix de paramètres. Notez que la clé publique est supposée être sous la forme systématique,
ce qui signifie que les k premières colonnes représentent la matrice d'identité. Nous n'avons donc
besoin de stocker que les n - k dernières colonnes de la clé publique et, par conséquent, la taille en
bits de la clé publique peut être calculée par la formule (n - k)k. En général, cette méthode réduit
considérablement la taille de la clé publique [10]. Dans le tableau 4.1, la taille de la clé publique est
exprimée en kilo-octets (Ko) et en méga-octets (Mo).2
45
Dans la première ligne, les paramètres n = 1024, k = 524 et t = 50 sont ceux proposés à
l'origine par McEliece. Dans la dernière ligne, les paramètres n = 6960, k = 5413 et t = 119 sont les
derniers proposés à notre connaissance et ils atteignent, après quelques optimisations de l'attaque
quantique, une sécurité post-quantique de 2128 bits [1].
2 Rappelons qu'un octet est équivalent à huit bits.
46
Paramètres Taille de la clé
publique Sécurité Sécurité PQ
n k t
(systématique) 73 48
1024 524 50 32.8 KB ≈ 2105 ≈ 264
2048 1696 32 74.6 KB ≈ 2158 ≈ 288
4096 3616 40 217 KB ≈ 2289 ≈ 2158
6960 5413 119 1.05 MB ≈2 ≈2
Tableau 4.1 : Paramètres du McEliece
Comme nous pouvons le constater, la clé publique du système cryptographique de McEliece est
très grande, ce qui rend ce système cryptographique inadapté à certaines applications. Actuellement,
les chercheurs tentent de trouver des moyens efficaces et sûrs de réduire la taille de la clé.
4.3 Efficacité
Le PKC de McEliece est assez efficace par rapport aux autres cryptosystèmes. Son principal
inconvénient est la taille énorme de sa clé.
Nous présentons quelques résultats sur l'efficacité du cryptosystème McEliece. Nous présentons des
résultats con-
cernant le cryptage, le décryptage et la génération de clés. Les preuves des propositions 39, 40 et 41
peuvent être trouvées dans [18]. Dans ce qui suit, on considère une instance PKC de McEliece avec
un code de Goppa G = (g, L) avec les paramètres [n, k, d], où g est défini dans F2 m , qui peut
corriger jusqu'à t erreurs.
Proposition 39. La génération d'une paire de clés pour le cryptosystème de McEliece prend
( /
O k2 n + n2 + t3 (n - k) + (n - k)3
opérations.
Proposition 40. Le cryptage de McEliece prend O(k.n) opérations.

( /
Proposition 41. Le décryptage de McEliece prend O ntm2 opérations.
Bien que la complexité du décryptage soit acceptable pour une utilisation pratique, nous notons
que la mise en œuvre de l'algorithme de décryptage dans le matériel peut être très difficile et
inefficace lorsque la longueur du texte chiffré augmente [37]. Alors que la mise en œuvre d'opérations
de base (comme la somme ou la multiplication) dans le matériel est assez simple, certaines
opérations requises pour l'algorithme de Patterson, comme le calcul des racines d'un polynôme,
peuvent être extrêmement difficiles à mettre en œuvre et peuvent avoir un coût en temps prohibitif.
4.4 Variants IND-CCA2
Notez que le cryptosystème original de McEliece n'est pas sécurisé par IND-CCA2. Nous pouvons
utiliser la malléabilité du cryptosystème pour attaquer son indiscernabilité.
47
En fait, le cryptosystème n'est même pas sûr IND-CPA. Par souci d'exhaustivité, nous montrons
que le système de cryptage McEliece n'est pas IND-CPA ni IND-CCA2.
48
Proposition 42. Le cryptosystème original de McEliece n'est pas sécurisé par IND-CPA.
Preuve. Pour prouver que le McEliece original n'est pas sécurisé par IND-CPA, nous allons construire
un adversaire A qui a une probabilité non-négligeable de gagner le jeu IND-CPA.
A suit cette stratégie simple : lorsque A reçoit le texte de défi et de chiffrement c, il calcule
e0 = c + m0 Gpub et e1 = c + m1 Gpub .
Notez que
e0 = c + m0 Gpub = mb Gpub + e + m0 Gpub = (mb + m0 )Gpub + e
et de même, e1 = (mb + m1 )Gpub + e.

Si b = 0 alors e0 = e et e1 = (m0 + m1 )Gpub + e. Donc e0 a un poids inférieur ou égal à t (car
wt(e) ≤ t) et e1 a un poids supérieur ou égal à t car (m0 + m1 )Gpub sera un mot-code différent de 0,
( ]
puisque m0 + m1 /= 0, et wt (m0 + m1 )Gpub ≥ 2t + 1 ( la distance minimale du code est 2t + 1) ;
donc.
( ]
wt(e1 ) = wt (m0 + m1 )Gpub + e > t.
De même, nous avons que, si b = 1 alors wt(e1 ) ≤ t et wt(e0 ) > t.

A n'a qu'à voir lequel des ei a un poids égal ou inférieur à t (le nombre d'erreurs corrigées par le
code) qui est public. Il sort b où wt(eb ) ≤ t et A va sûrement deviner le bit b juste. Nous avons que
AdvMcEliece ,A (n, t) = 2.Pr(¯b = b) - 1 = 1

ind-cpa
ce qui signifie que A gagne toujours le jeu.
Corollaire 43. Le McEliece original n'est pas IND-CCA2.
Preuve. La preuve est une conséquence directe de la proposition précédente. Mais nous présentons
quand même l'attaque car l'idée de cette attaque est différente de la précédente et pour souligner que
la malléabilité du McEliece original est un problème.
Étant donné le texte chiffré de défi c, qui est le chiffrement de mb , l'adversaire A peut suivre les
étapes suivantes
cette stratégie : elle choisit un message mt , différent de m0 et m1 . Elle calcule
ct = c + mt Gpub
= (mb + mt )Gpub + e
et demande à l'oracle de décryptage le décryptage de ct . Elle recevra mb + mt et, comme elle connaît
m0 ,m1 et mt elle peut récupérer le bit b. Nous avons que
AdvMcEliece ,A (n, t) = 1.
ind-cca2
et ceci conclut la preuve.

49
Variante IND-CPA dans le modèle standard
La proposition 42 nous indique que le cryptosystème de McEliece n'est malheureusement pas

sécurisé par IND-CPA. Pour résoudre ce problème, nous devons trouver un moyen tel que les
relations entre les plaintexts ne résultent pas en relations entre les ciphertexts. Dans [44], les auteurs
ont proposé une variante très simple de la PKC de McEliece originale, la PKC de McEliece
randomisée. L'idée est simplement d'ajouter un certain caractère aléatoire à une partie du message
qui sera chiffré, rendant le texte chiffré pseudo-aléatoire pour un attaquant. Pour ce faire, on ajoute
une chaîne binaire aléatoire s au message m que l'on veut chiffrer3, puis on applique le McEliece
original, c'est-à-dire que le texte chiffré c est calculé de la manière suivante :
c = (m|s) Gpub + e
où Gpub est la clé publique du PKC de McEliece, e le vecteur aléatoire et s une chaîne aléatoire. La
chaîne aléatoire s doit être suffisamment grande pour que le texte chiffré ressemble à une valeur
pseudo-aléatoire (il est proposé que s ait 9 fois la longueur du message). Il est prouvé que cette
variante simple atteint la sécurité IND-CPA dans le modèle standard.
Théorème 44 ([44]). Le McEliece randomisé est sûr IND-CPA étant donné que les problèmes LPN et
Goppa Distinguisher sont difficiles à calculer.
Variantes IND-CCA2 dans le modèle de l'oracle aléatoire
Des conversions génériques pour obtenir un cryptosystème sécurisé IND-CCA2 à partir d'un autre
cryptosystème (qui n'a pas cette propriété) existent [21, 46], cependant ces conversions peuvent
ajouter beaucoup de redondance aux messages cryptés lorsqu'elles sont appliquées au
cryptosystème McEliece [10, 29]. Ainsi, dans [29], les auteurs ont présenté des conversions
spécialement pour le cryptosystème McEliece qui sont sécurisées par IND-CCA2. Dans l'Algorithme 7
est présentée une conversion de [29] ; pour des raisons de brièveté et de simplicité, nous ne
présentons ici qu'une des conversions (nous l'appellerons conversion α et elle est présentée dans
l'Algorithme 7), bien que les auteurs de [29] aient présenté trois conversions possibles. Nous
mentionnons juste ici que l'une des conversions (pas celle que nous présentons dans cette thèse)
permet de réduire la redondance du texte chiffré, par rapport à la version originale du cryptosystème
McEliece.
Rappelons qu'un générateur de nombres pseudo-aléatoires est un algorithme qui génère des
nombres pseudo-aléatoires. Le générateur de nombres pseudo-aléatoires doit avoir la propriété qu'il
est impossible de faire la distinction entre un nombre généré par le générateur de nombres pseudo-
aléatoires et un nombre choisi au hasard. Cet algorithme reçoit une graine en entrée ; la sortie (le
nombre pseudo-aléatoire) dépend de la graine. Plus d'informations sur les générateurs de nombres
pseudo-aléatoires dans [26, 40].
Théorème 45 ([29]). Briser la propriété IND-CCA2 de la conversion présentée dans l'Algorithme 7

dans le modèle de l'oracle aléatoire est aussi difficile que de briser le McEliece original.
50
Une autre variante que nous allons analyser est celle présentée dans [21] et présentée
précédemment dans le chapitre 3. Il s'agit d'une conversion générique pour tout système de cryptage
à clé publique, mais nous présenterons cette conversion appliquée
3 Rappelons que x|y désigne la concaténation (ou le remplissage) des chaînes x et y.
51
Algorithme 7 Conversion α de la PKC de McEliece [29].
Paramètres de sécurité : Les mêmes que dans le McEliece original, plus un générateur de
(/
nombres pseudo-aléatoires Gen et une fonction de hachage cryptographique Ht avec une sortie
dans l'ensemble {1, . . . , K} où K =n . Rappelons que n est la longueur du texte chiffré et t le

nombre d'erreurs corrigées par le code utilisé dans le cryptosystème. Nous utiliserons également
Conv qui est une bijection entre l'ensemble {1, . . . , K} et les vecteurs d'erreurs de poids t.
Création de la clé : Comme dans le McEliece original.

Cryptage : Pour crypter le message m, choisissez d'abord une valeur aléatoire s. Définissez z¯ = H(s|m)
et
(y1 |y2 ) = Gen(z¯) + (s|m) .
Créer le vecteur d'erreur z = Conv(z¯). Retourner le texte chiffré
( z/
c = y1 Gpub + |y2 .
Décryptage : Pour décrypter le texte chiffré c, on prend les n premiers bits de c et, à l'aide d'un
algorithme de décodage, on récupère y1 . Récupérer le vecteur d'erreur z utilisé dans le chiffrement
en prenant les n premiers bits de c et en les soumettant à un XOR avec y1 Gpub . Calculez z¯ =
Conv−1 (z) et
(s|m) = Gen(z¯) + (y1 |y2 ).
Vérifiez si
z¯ = H (s|m) ;
si c'est le cas, retourner m ;

sinon, rejeter c.
52
au système de cryptage McEliece (Algorithme 8 à la page 38).
Algorithme 8 Conversion générique de [21] appliquée au McEliece

Paramètres : Les mêmes que dans le McEliece original, plus une fonction de hachage
cryptographique H (définition
(/ à la page 18). Aussi, laissez K =n où n est la longueur du texte chiffré
t
et t le nombre d'erreurs corrigées.
par le code utilisé dans le cryptosystème.
Création de la clé : Même chose que dans le McEliece original.
Cryptage : Pour crypter un message m, on calcule
c = (m|s)Gpub + Conv[H(m|s)]
où s est une chaîne aléatoire.

Décryptage : Pour décrypter un texte chiffré c, appliquer le même algorithme de décodage que
dans le McEliece original pour obtenir m|s. Calculez le vecteur d'erreur e = c + (m|s)Gpub . Vérifiez si
c est un texte chiffré valide en vérifiant si e est égal à Conv [H(m|s)]. Si ce n'est pas le cas, rejeter c.
Il est prouvé que la conversion générique est sécurisée IND-CCA2 si le cryptosystème original est
sécurisé IND-CPA. Nous savons que le McEliece original n'est pas sécurisé IND-CPA, donc nous
nous attendons à ce que cette conversion ne fonctionne pas lorsqu'elle est appliquée au McEliece
original. Cependant, nous pouvons l'appliquer au McEliece randomisé dont nous savons qu'il est
sécurisé par IND-CPA. Le résultat est le même que lorsqu'on l'applique au McEliece original, puisque
l'opération de concaténation est associative et donc (m|s)|st = m|(s|st ) où s et st sont des chaînes
aléatoires. Pour éviter les attaques, à savoir l'attaque connaissant une partie du texte en clair, il suffit
d'augmenter la taille de la chaîne aléatoire s. Avec cela en tête, nous pouvons énoncer le résultat
suivant.
Théorème 46 ([21]). Briser la propriété IND-CCA2 de la conversion présentée dans l'Algorithme 8

dans le modèle de l'oracle aléatoire est aussi difficile que de briser la propriété IND-CPA du McEliece
aléatoire. Ainsi, c'est aussi difficile que de casser les problèmes LPN et Goppa Distinguisher.
Bien que très efficaces, les conversions précédentes sont seulement prouvées comme étant
sécurisées sur le modèle de l'oracle aléatoire. Mais nous préférons une construction dont la sécurité
est prouvée dans le modèle standard, et récemment une nouvelle variante du McEliece a été
proposée [16].
Variante IND-CCA2 dans le modèle standard
Tout d'abord, nous devons introduire la notion de PKC à k-répétition. En gros, une PKC à k-
répétition est un algorithme PKC qui est répété k fois sur une seule PKC.
Définition 47. Considérons un cryptosystème à clé publique Π = (K, E, Dc). Un cryptosystème à clé
publique à k répétitions Πk = (Kk , Ek , Dck ) est composé des trois algorithmes :
53
La création de clés est un algorithme probabiliste en temps polynomial (PPT) Kk qui appelle l'al-
gorithme de création de clés K de Π, k fois afin d'obtenir pk = (pk1 , . . . , pkk ) et les clés secrètes
correspondantes sk = (sk1 , . . . , skk ) ;
54
Le chiffrement est un algorithme PPT Ek qui appelle l'algorithme de chiffrement E de Π, k fois
avec chacune des clés publiques pk = (pk1 , . . . , pkk ). Il produit Ek (pk, m)c = (c1 , . . . , ck ) ;
Le décryptage est un algorithme D en temps polynomial déterministek qui appelle l'algorithme de
décryptage D de
Π, k fois afin de déchiffrer c = (c1 , . . . , ck ) avec la clé secrète sk = (sk1 , . . . , skk ). Il s'arrête si l'un
des ci est un texte chiffré invalide.
Dans cette optique, étant donné une PKC, nous pouvons construire une variante de la PKC qui est IND-
CCA2 à partir de son
variante de k-répétition. Notez qu'il s'agit d'une construction générique, qui peut donc être appliquée à
n'importe quel PKC.
Avant de présenter le protocole, nous devons introduire la notion de signature et quelques notions
de sécurité sémantique concernant les signatures.
Définition 48 (schéma de signature). Un schéma de signature est défini par les algorithmes suivants :
La création de clés est un algorithme PPT qui prend en entrée un paramètre de sécurité et produit une
paire (dsk, vk).
où dsk est la clé de signature et la clé secrète et vk est la clé de vérification correspondante ;
La signature est un algorithme PPT qui prend en entrée un tuple (m, dsk), un message à signer et
une clé de signature, et produit une signature σ.
La vérification est un algorithme déterministe en temps polynomial qui prend comme entrée un
tuple (σ, m, vk), une signature, un message et une clé de vérification, et sort 1 si σ est une signature
valide pour m ; sort 0, sinon.
Nous aurons besoin d'une autre notion de sécurité concernant le schéma de signature que nous
utiliserons dans notre construction. Par schéma de signature non falsifiable fort à un moment donné,
nous entendons un schéma de signature pour lequel tout adversaire probabiliste en temps polynomial
A a une probabilité négligeable de gagner le jeu suivant :
1. Le challenger crée une paire de clés de signature et de vérification (dsk, vk). dsk est gardé privé, alors
que
vk est public ;
2. A demande la signature d'un message donné mt ;
3. C signe le message mt en utilisant dsk et l'envoie à A ;
4. À un moment donné, A soumet la paire (σ, m) à C, où σ est la signature d'un message m /= mt ;
5. C vérifie si la signature est valide.
L'adversaire A gagne la partie s'il parvient à falsifier correctement la
signature. Nous avons besoin d'une définition supplémentaire avant de

présenter la conversion.
Définition 49 (PKC vérifiable). Un système de cryptage à clé publique à k répétitions est vérifiable s'il
existe un algorithme qui reçoit en entrée un texte chiffré c, une clé publique pk = (pk1 , ... , pkk ) et tout
55
ski , pour i ∈
{1, . . . , k} et à la condition que, si cet algorithme produit 1, cela signifie que le texte chiffré peut être
décrypté en un message valide.
Théorème 50 ([16]). Supposons que SS est un schéma de signature non falsifiable forte à un temps
et que Πk est sécurisé par IND-CPA et vérifiable. Alors ΠCCA2 est sécurisé par IND-CCA2 dans le
modèle standard.
56
Algorithme 9 ΠCCA2 schéma de cryptage de Π
Paramètres de sécurité : Un système de cryptage à clé publique et un système de signature unique,
forte et infalsifiable SS ;
Création de la clé : Appelez 2k fois l'algorithme de création de clé de Π. Il produit pk = (pk0 , pk1 , . . . ,
pk0 , pk1 )
1 1 k k
et la clé secrète correspondante
sk = (sk0 , sk1 , . . . , sk0 , sk1 ).

1 1 k k
Cryptage : D'abord, créer une paire de clés de signature et de vérification (dsk, vk) de SS. Chiffrer m en
utilisant l'algorithme de chiffrement Ek (de Πk ) avec
1
la clé publique
k
(pkvk 1 , . . . , pkvk k ). Le texte chiffré
résultant est
c = (c1 , . . . , ck ).
Signer le message c, avec dsk, la signature résultante est σ. Envoyer ct = (c, vk, σ) ;
Décryptage : Déchiffrer en utilisant Πk avec la clé privée sk = (skvk 1 , . . . , skvk k ).
1 k
Une autre version qui atteint la sécurité IND-CCA2, basée sur des produits corrélés, est présentée
dans [16]. Nous ne la présenterons pas ici car l'idée est très similaire au protocole présenté dans
l'Algorithme 9. Bien qu'il soit prouvé que cette version est sécurisée IND-CCA2 dans le modèle
standard, nous voudrions souligner que cette construction est purement théorique car son utilisation
dans la pratique n'est pas possible. Les raisons en sont le coût du chiffrement pour un seul message
(un message est chiffré plusieurs fois) et la taille importante de la clé.
4.5 Utilisation des codes LDPC dans le PKC de McEliece
Comme nous l'avons dit précédemment, l'un des principaux inconvénients du système
cryptographique de McEliece est la taille importante de ses clés. Plusieurs solutions ont été
présentées pour surmonter ce problème. Une solution possible est d'utiliser une autre famille de codes
à la place des codes de Goppa, une famille dont la matrice peut être stockée de manière plus efficace.
Par exemple, on peut penser à utiliser un code LDPC dans le cryptosystème : puisque les codes
LDPC sont basés sur des matrices éparses, ils ont peut-être une structure qui permet la compression
de la clé publique. De plus, les codes LDPC sont très bien adaptés, c'est-à-dire que les algorithmes de
décodage sont très rapides dans les implémentations logicielles et matérielles pour les grandes
longueurs de code, ce qui améliorerait l'efficacité du système de cryptage pour les grands messages.
Pour autant que nous le sachions, la seule tentative d'utiliser les codes LDPC dans le
cryptosystème McEliece est présentée dans [41]. Puisque la matrice de contrôle de parité est très peu
dense, nous pourrions la garder comme clé publique (multipliée par une autre matrice, afin qu'elle soit
cachée4), ce qui réduirait considérablement la taille de la clé publique. Cependant, il existe une attaque
qui permet de récupérer la clé secrète en se basant sur la rareté de la matrice de contrôle de parité
57
[41]. Esquissons l'idée de cette attaque.
Supposons que H soit la matrice de contrôle de parité d'un code LDPC. La clé publique est Hpub = RH
où
4 La matrice de contrôle de parité d'un code LDPC doit être cachée car cette matrice est souvent utilisée dans l'algorithme de
décryptage. Dans la plupart des cas, la connaissance de la matrice de contrôle de parité nous donne l'algorithme de
décryptage.
58
R est une matrice non singulière. Si R est clairsemée, alors la clé publique RH est également
clairsemée, ce qui peut permettre la compression de la clé. Pour chiffrer un message m, il suffit de
calculer la matrice génératrice G associée à Hpub et de calculer mSG + e où S est une matrice
publique non singulière qui est utilisée pour cacher le message et e est un vecteur d'erreur de poids t.
Pour déchiffrer, il suffit de noter que G et SG sont des codes équivalents. On peut donc utiliser H pour
décoder le mot de code corrompu et retirer le vecteur d'erreur.
Pour que le cryptosystème soit sûr, Hpub ne doit pas admettre le décodage à l'aide d'une
quelconque technique de décodage pour les codes LDPC et un adversaire ne doit pas être en mesure
de récupérer H, ou un autre Ht équivalent à H et admettant le décodage, à partir de Hpub . Toutefois,
la rareté de la matrice de la clé publique peut être utilisée pour récupérer
quelques lignes de la matrice de contrôle de parité originale H qui peuvent être suffisantes pour
permettre à l'adversaire de récupérer la clé secrète H [41].
Nous pourrions éviter cette attaque si nous choisissions R de manière à ce qu'elle soit une matrice
dense, et donc que Hpub soit dense. Mais alors nous ne pourrions pas réduire la taille de la clé
publique. Les auteurs concluent donc qu'il n'y a aucun avantage à utiliser un code LDPC plutôt qu'un
code Goppa dans le cryptosystème McEliece.
Nous pensons qu'il y a un grand avantage à utiliser les codes LDPC en cryptographie. Les codes
LDPC sont beaucoup plus efficaces que les codes Goppa et nous pensons que cela peut être utile
pour les implémentations matérielles. Nous pensons également qu'il existe des méthodes pour
prévenir les attaques comme celle-ci et tirer parti des algorithmes de décodage peu complexes des
codes LDPC dans le cryptosystème de McEliece. C'est ce que nous allons étudier dans le prochain
chapitre.
59
60
Chapitre 5
Un nouveau cryptosystème : McEliece

basé sur le LDPC
L'une des caractéristiques les plus importantes qu'un cryptosystème asymétrique doit remplir est
d'être implémentable au niveau matériel. Les cryptosystèmes RSA et ECC (elliptic curve
cryptosystems) sont très exigeants en termes de temps de traitement, ce qui les rend très lents à
utiliser, même dans des implémentations matérielles dédiées [38]. De plus, ils ne sont pas résistants
au niveau quantique [51], ce qui a incité la communauté à rechercher des systèmes cryptographiques
post-quantiques [10]. L'un des candidats les plus prometteurs est le cryptosystème de McEliece [39]
qui est basé sur des codes correcteurs d'erreurs, qui se comportent généralement bien dans les
implémentations matérielles. Ce cryptosystème est le plus ancien qui n'a pas encore été cassé, que
ce soit par des algorithmes classiques ou quantiques.
Malheureusement, bien que beaucoup plus efficace que RSA et ECC [18], le système de cryptage
de McEliece a encore quelques inconvénients : la taille de la clé est beaucoup plus grande que RSA
et ECC, ce qui est un problème pour les implémentations (en particulier les implémentations
matérielles, où la mémoire disponible pour stocker les données est très limitée) ; et l'algorithme de
décryptage a un effet de goulot d'étranglement lorsque la taille de la clé augmente puisque
l'algorithme de décodage des codes Goppa (les codes utilisés dans le McEliece original) prend trop de
temps lorsque la taille de la clé augmente [38]. D'autre part, nous savons que les codes LDPC [50]
s'adaptent très bien aux implémentations matérielles car leurs algorithmes de décodage sont
beaucoup plus simples. Mais l'utilisation des codes LDPC dans le McEliece peut ne pas être aussi
sûre que l'utilisation des codes Goppa [41].
Le cryptosystème de McEliece a encore un autre inconvénient : il n'est pas indiscernable contre les
attaques adaptatives par texte choisi (IND-CCA2). La sécurité IND-CCA2 est une propriété cruciale
pour les cryptosystèmes de nos jours, car cette notion révèle combien d'informations un adversaire
peut obtenir sur le message à partir du texte chiffré.
Nous proposons un schéma de cryptage à clé publique qui, étant donné un message à crypter, le
divise en plusieurs parties et crypte chaque partie individuellement en utilisant le cryptosystème
McEliece avec un code Goppa (de sorte qu'il peut être mis en œuvre en parallèle), puis crypte le
61
résultat en utilisant le cryptosystème McEliece avec un code LDPC. Nous pouvons dire que nous
ajoutons un peu plus de sécurité au McEliece traditionnel en cryptant à nouveau en utilisant un
cryptosystème McEliece basé sur un code LDPC. Avec cette proposition, nous cherchons à obtenir la
sécurité fournie par le McEliece traditionnel et l'évolutivité fournie par les codes LDPC. Comme notre
approche diffère
62
de celle de [41], l'attaque présentée là ne fonctionne pas sur notre construction.
Dans la Section 5.1, nous présentons la proposition. Dans les sections suivantes, nous
commençons à analyser le cryptosystème proposé : dans la Section 5.2, nous prouvons sa sécurité,
dans la Section 5.3, nous analysons son efficacité et dans la Section 5.4, nous calculons la sécurité
estimée pour certains paramètres et comparons les résultats avec le McEliece original. Enfin, dans la
Section 5.5, nous présentons une variante du cryptosystème qui est sécurisée par IND-CCA2 ainsi
qu'une preuve de sécurité.
5.1 Proposition
Avant d'entrer dans la construction formelle, nous donnons l'idée principale derrière cette construction.
Comme on le sait, les codes de Goppa ne sont pas très évolutifs puisque l'algorithme de Patterson est
relativement inefficace pour les messages de grande longueur de bloc [38]. Pour surmonter cette
difficulté, nous proposons un cryptosystème dans lequel un message m est divisé en plusieurs petits
blocs. Chacun de ces blocs est codé à l'aide d'un code de Goppa. Le mot de code résultant, qui est la
concaténation des mots de code du code Goppa choisi, sera ensuite codé en utilisant un code LDPC.
Des erreurs seront ajoutées au mot-code résultant de telle sorte que ces erreurs puissent être
corrigées par le code LDPC et par chacun des petits blocs, en utilisant l'algorithme de Patterson.
Notez que, puisque ces blocs sont choisis pour être relativement petits, l'algorithme de Patterson
devrait être assez efficace.
Nous présentons maintenant de façon rigoureuse le schéma de chiffrement à clé publique.

Supposons un système avec Alice et Bob, où Bob veut envoyer un message crypté m à Alice en
utilisant sa clé publique. Il peut être utile de faire suivre la description des figures 5.1, 5.3 et 5.2.
Création de clés :
Pour créer une paire de clés publique et secrète, Alice doit choisir un code de Goppa G, avec une
matrice génératrice G de taille k × n, qui est capable de corriger t erreurs. Elle doit ensuite choisir au
hasard une matrice carrée non singulière S, de taille k, et une matrice de permutation P , de taille n.
Elle calcule U1 = SGP , comme dans le PKC de McEliece original. Considérons maintenant
U1 0 ... 0
⊕£
0 U1 .. 0
U1 = . .. .
. . .
0 ... 0 U1
où la matrice U1 apparaît £ fois dans la diagonale de U⊕£1 . Notez que U1⊕£ est une matrice de taille k£ × n£.
Maintenant, Alice choisit un code LDPC binaire L avec une matrice génératrice G ˆ , une matrice
n£ × m, qui est capable de corriger δ erreurs. Elle choisit ensuite au hasard une autre matrice non
singulière Sˆ, de taille n£ × n£, et une autre matrice de permutation Pˆ, de taille m ×1 m. Elle calcule U2
= S ˆ G ˆ P ˆ . La matrice U = U⊕£ U2 fera partie de
sa clé publique.
63
Pour compléter le processus de création de la clé, elle construit une liste de vecteurs, que nous
appellerons A, de la manière suivante : laissez {e1 , . . . . , en } est la base canonique de Zn . Soit {ej , . . . , ej }
2 1 £
est une permutation aléatoire de
64
£ vecteurs uniformément choisis de la base canonique. Ensemble
vj = (ej |1 . . . |e£j )U2
et répéter ce processus c fois pour créer la liste A = {v1 , ... . , vc }, où c ∈ N est une constante telle
que c >> t. Notez que chaque vecteur de A est la concaténation de l vecteurs d'erreur de taille n et de
poids 1 qui ont été développés par U2 . Pour chiffrer un message, Bob choisira les vecteurs d'erreur de
cette liste pour créer le texte chiffré, comme nous le verrons plus tard.
La clé publique est constituée de (U, A, t, δ). La clé privée est constituée de (S, G, P, Sˆ, G ˆ , Pˆ)
et des algorithmes de décodage correspondants pour G et L, que nous appellerons
respectivement DG et DL .
Le cryptage :
Pour chiffrer, Bob choisit au hasard t vecteurs dans A et les soumet à une opération XOR. Le résultat de
cette opération est
E = vi 1 + - - - + vi t .
Le chiffrement d'un bloc de message m = (m1 | . . . |m£ ) est obtenu en calculant
c = mU + E + rδ
où rδ est un vecteur aléatoire de2 Zm avec un poids δ choisi par Bob (voir la figure 5.1 pour un schéma
de l'algorithme de cryptage). Le facteur E + rδ représente les erreurs qui seront corrigées par les
algorithmes de décodage (voir la figure 5.2).
Figure 5.1 : Schéma de cryptage
T
E 1T E t T
.1 .1
rδ +. U2 + - - - +. U2
e1 et
£ £
Figure 5.2 : Schéma de construction des erreurs
65
Décryptage
66
Pour décrypter un texte chiffré c, Alice calcule d'abord cPˆ-1 et applique l'algorithme de
décodage DL du code LDPC au résultat. Ensuite, elle multiplie le résultat par Sˆ-1 pour obtenir
E9t
mU⊕1£ + (ej 1| . . . |e£j ) = ct .
j=1
Notez que ct est juste la concaténation de c1 , . . . , c£ où chaque ci est le cryptage de mi par le

McEliece original. Ensuite, Alice peut utiliser l'algorithme de décryptage du McEliece original pour
obtenir chaque mi à partir de ci (c'est-à-dire, multiplier par P − 1 , appliquer l'algorithme de Patterson
pour corriger les erreurs et multiplier par S−1 ). Cette tâche peut être effectuée en parallèle, puisque
chacune des mi est indépendante des autres. Après avoir récupéré tous les mi , elle les concatène
pour obtenir m. La figure 5.3 présente un schéma de l'algorithme de décryptage.
Figure 5.3 : Schéma de décryptage : DL et DG désignent les algorithmes de décodage des codes
LDPC et Goppa, respectivement.
Le système de cryptage à clé publique se trouve dans l'Algorithme 10. Nous appellerons McEliece
basé sur le LDPC à ce système de cryptage.
La raison pour laquelle nous créons et publions la liste des erreurs A (qui seront corrigées par
l'algorithme de Patterson) est que nous n'avons pas besoin de publier les matrices U1 et U2 . Ceci est
utile pour deux raisons : nous avons eu une petite sécurité supplémentaire puisque nous croyons
fermement qu'il est difficile de factoriser U en deux matrices U1 et U2 et, si U1 et U2 étaient publiques,
le cryptosystème serait juste une composition de cryptosystèmes.
La liste d'erreurs A qui est rendue publique ne peut pas contenir toutes les erreurs i la forme (e | ... |e
de 1 £
i
)U2 , puisque cela
La liste croît exponentiellement avec le nombre de blocs (il faut un temps O(n£ ) pour produire cette
liste). Cependant, pour des raisons pratiques, nous n'avons besoin que d'un nombre constant d'entre
eux, tant que ce nombre est bien supérieur à
t (le nombre d'erreurs corrigées par le code Goppa interne). Le propriétaire de la clé publique peut
mettre à jour cette partie de la clé de temps en temps, pour éviter que les mêmes modèles d'erreurs
soient utilisés dans différents cryptages. Nous verrons plus tard qu'un adversaire n'obtient aucune
information sur la clé secrète à partir de cette liste.
Il y a deux cas particuliers que nous voudrions évoquer. Le premier cas extrême est celui où £ = 1.
67
Dans ce cas, le protocole est juste la composition de deux cryptosystèmes basés sur McEliece,
l'original et une variante utilisant un code LDPC. Dans ce cas particulier, nous pourrions trouver la
factorisation de U jusqu'à la permutation
(que nous voulons garder secret) en utilisant la liste A. Un autre cas particulier est celui où l = |m| (où |m|
est
la taille du message m), ce qui n'est pas possible puisqu'il n'existe pas de codes de Goppa de taille 1. Pour
ces
68
Algorithme 10 Système de cryptage McEliece basé sur le LDPC
Paramètres de sécurité : n, m, t, δ, £, c ∈ N.
Création de la clé : Choisir un code Goppa G capable de corriger t erreurs en utilisant un
algorithme de décodage DG . Ce code a une longueur n et une dimension k. Choisissez un code
LDPC L capable de corriger δ erreurs en utilisant un algorithme de décodage DL . Ce code doit avoir
une longueur m et une dimension n£. Générer les matrices G, S, P , G ˆ , Sˆ et Pˆ où :
G est une matrice génératrice de G de taille
k × n ; Gˆ est une matrice génératrice de L
de taille n£ × m ;
S et Sˆ sont des matrices non singulières, de taille k et de taille n£ (resp.),
choisies au hasard ; P et Pˆ sont des matrices de permutation, de taille n et de
taille m (resp.), choisies
1 au hasard ; Calculer U = U⊕£ U2 = (SGP ) ⊕ £ S ˆ G ˆ P ˆ
;
Construire la liste A = {v1 , . . . , vc }, où chaque vj = (ej |1 . . . |ej£ )U2 et {ej , . 1. . , ej } est
£ un nombre
aléatoire
permutation de £ vecteurs uniformément choisis de la base canonique
2 de Z .
n£
Clé publique : (U, A = {v1 , . . . , vc }, t, δ).

Clé privée : (S, P, DG , Sˆ, Pˆ, DL ) où DG est un algorithme de décodage pour G et DL est un
algorithme de décodage pour L.
Cryptage : Choisissez t vecteurs de A et faites-en la somme, le résultat de cette opération étant E.
Choisissez
rδ ∈ Zm aléatoirement de telle sorte que rδ ait un poids δ. Pour chiffrer un message m ∈ Zk£ en un texte
chiffré c, on
2 2
doit calculer
c = mU + E + rδ .
Décryptage : Pour décrypter c, il faut multiplier c par Pˆ-1, appliquer DL pour prendre l'erreur rδ et
Sˆ-1. t
multiplier par On obtient c après ces opérations. Ensuite, en parallèle, on multiplie chaque
partie de longueur n de ct par P − 1 , on applique l'algorithme de décodage DG pour prendre chaque
vecteur d'erreur de poids t et on multiplie par S−1 . On concatène dans l'ordre chacun des mi
résultants pour obtenir m.
69
Pour des raisons de sécurité, ces cas doivent être évités.
Le choix du code LDPC est un point crucial pour garantir l'efficacité de notre proposition. D'une
part, le LDPC choisi doit avoir une faible complexité de décodage. D'autre part, le LDPC doit corriger
n'importe quel modèle d'erreurs de poids δ, afin de garantir la correction de notre cryptosystème.
Comme nous l'avons mentionné dans les chapitres précédents et pour autant que nous le sachions, il
semble que les seuls codes LDPC dont l'algorithme de décodage garantit une fraction d'erreurs
corrigées sont les codes LDPC basés sur des expanseurs [24, 54, 55, 60].
Un autre aspect que nous devons prendre en compte lors du choix du code LDPC est la
redondance du code. La redondance du texte chiffré est un problème qui ne peut être évité dans le
système cryptique de McEliece, comme nous l'avons vu précédemment. Néanmoins, nous devrions
éviter les codes LDPC qui ont trop de redondance dans le texte chiffré. Pour un meilleur rapport
d'information, il faut choisir des codes LDPC avec le rapport d'information le plus élevé possible, sans
compromettre la sécurité.
5.2 Sécurité
Dans cette section, nous présentons quelques arguments pour la sécurité de notre cryptosystème.
Nous avons pu prouver que récupérer le message en connaissant simplement le texte chiffré et la clé
publique est au moins aussi difficile que de récupérer le message s'il a été chiffré en utilisant le
cryptosystème original de McEliece et que d'attaquer la clé publique du cryptosystème de McEliece
basé sur le LDPC est au moins aussi difficile que d'attaquer la clé publique du McEliece original. Nous
donnons également quelques arguments pour expliquer pourquoi nous pensons qu'il est difficile de
factoriser la clé publique du cryptosystème.
Compte tenu de cela, nous présentons le lemme suivant qui prouve qu'il est difficile de récupérer
des messages à partir de leurs ciphertextes.
Proposition 51. Briser la sécurité du message du cryptosystème McEliece basé sur le LDPC est au
moins aussi difficile que de briser la sécurité du message du McEliece original.
Preuve. Nous pouvons voir le protocole comme la composition de deux protocoles différents, l'un
d'eux étant le McEliece original.
Considérons la PKC originale de McEliece avec la clé publique (G, t). Soit A, un algorithme qui, étant
donné a
ciphertext du cryptosystème basé sur le LDPC et sa clé publique, renvoie le message correspondant.
Supposons également que cet algorithme s'exécute en temps polynomial. Nous allons construire un
algorithme B qui casse
le McEliece original. Soit ct le cryptage d'un message en utilisant le McEliece original. B reçoit comme
entrée ct et la clé publique du McEliece original (G, t) et fait ce qui suit :
• Construit d = (ct | . . . |ct ) où ct est répété £ fois ;
• Choisit un code LDPC L, et en suivant l'algorithme de création de clé du PKC de McEliece basé
sur LDPC, calcule U2 = S ˆ G ˆ P ˆ où Gˆ est une matrice génératrice de L, et la liste A ;
70
• Calcule c = dU2 + rδ où rδ est un vecteur aléatoire de poids δ (le nombre d'erreurs corrigées par
L) ;
71
• Applique A avec des entrées c et la clé publique (U = G⊕£ U2 , A, t, δ) ; A produira m = (mt | . . .
|mt )
où mt est répété £ fois ;
• Sortie mt .
Chacune de ces tâches peut être effectuée en temps polynomial, étant donné que A s'exécute en temps
polynomial. Ainsi, B
s'exécute en temps polynomial et donc nous pouvons casser McEliece en temps polynomial.
Nous avons prouvé que dans notre cryptosystème, il est difficile de récupérer le message à partir
du texte chiffré. Nous allons donc maintenant parler de la sécurité de la clé publique.
Proposition 52. Briser la sécurité de la clé publique du cryptosystème McEliece basé sur le LDPC est
au moins aussi difficile que de briser la sécurité de la clé publique du McEliece original.
Preuve. La réduction est similaire à la précédente : considérons la PKC de McEliece originale avec la
clé publique (G, t). Soit A un algorithme qui, étant donné une clé publique du cryptosystème basé sur
le LDPC, retourne la clé secrète correspondante. Supposons également que cet algorithme s'exécute
en temps polynomial. Nous allons construire un algorithme B qui casse la clé publique du McEliece
original. B reçoit en entrée (G, t) et fait ce qui suit :
⊕£
• Construit
⊕
£ U1 = G ;
• Choisit un code LDPC L qui corrige δ et, en suivant l'algorithme de création de clé du PKC de
McEliece basé sur le code LDPC, calcule U2 = S ˆ G ˆ P ˆ où Gˆ est une matrice génératrice de
L. Crée également la liste A ;
• Calcule U = U1 U2⊕
£;
• Applique A avec des entrées (U, A, t, δ) ; A produira en sortie (S, P, DG , Sˆ, Pˆ, DL ) où S et P font
partie de la factorisation de G (selon le protocole de McEliece) et DG et DL sont les algorithmes
de décodage pour le code de Goppa et pour le code LDPC respectivement utilisés ;
• Sortie (S, P, DG ) qui est la clé secrète du système cryptographique de McEliece avec la clé publique G.
Chacune de ces tâches peut être effectuée en temps polynomial, étant donné que A s'exécute en temps
polynomial. Ainsi, B
s'exécute en temps polynomial et donc nous pouvons casser la clé publique du McEliece en temps
polynomial.
Bien que la récupération de la clé secrète soit difficile (étant donné que casser le cryptosystème de
McEliece est difficile), cela peut être un problème si un adversaire est capable de factoriser la clé
publique U . Rappelons que la clé publique est (U, A = {v1 , . . . , vc }, t, δ) où U est une matrice avec
1
k£ lignes et m colonnes et c'est le produit de U1⊕£ (une matrice k£ × n£) par U2 ( matrice n£ × m).
Puisque U⊕£ représente la concaténation du cryptosystème original de McEliece (qui est conjecturé
72
pour être indiscernable d'une matrice uniformément choisie), la vraie menace au cryptosystème est si
un adversaire pourrait trouver le LDPC qui est utilisé. S'il pouvait le faire, alors casser le
cryptosystème serait équivalent à casser le McEliece original pour de petits paramètres.
73
Pour trouver le code LDPC utilisé dans le cryptosystème, un adversaire devrait factoriser la
matrice U . Notez que certaines informations sont extraites de la liste A, à savoir les paramètres du
code LDPC utilisé. Pour trouver les paramètres, un adversaire peut procéder de la manière suivante :
L'adversaire choisit un vecteur dans la liste A. Puis il choisit un autre vecteur dans A qui est
linéairement indépendant du premier vecteur choisi. De nouveau, il choisit un autre vecteur qui est
linéairement indépendant des deux premiers vecteurs choisis. Il procède ainsi jusqu'à ce qu'il n'y ait
plus de vecteur linéairement indépendant à choisir. Très probablement, elle obtiendra un ensemble de
n£ vecteurs linéairement indépendants puisque chaque vecteur
vj = uj U
où uj = (ej | . . . |ej ) est un vecteur de taille n£. Soit {vt , . . } est la liste obtenue à l'issue de cette
. , vt procédure.
1 £ 1 n£
La matrice
v1t
U2t= .
t
vn£
est un changement de base de la matrice U2 . Avec cela, l'adversaire peut obtenir la valeur n£ et, ainsi, il
obtient les paramètres du code LDPC, qui est un code de dimension n£ de longueur m. Mais notez qu'il n'a
pas plus de
l'information, en particulier sur la nouvelle base, puisqu'il ne sait pas quelle base {ut , . . . . , ut } a été
utilisée pour
1 n£
t t
. . , v }. Il ne peut donc pas récupérer U2 à partir
construire la liste des vecteurs1 {v , . n£ 2 de sa matrice U t .
Une autre menace pour notre cryptosystème est l'attaque présentée dans [41] et dans le chapitre
précédent. Mais notez que cette attaque ne fonctionne que si la matrice de contrôle de parité du code
LDPC est rendue publique (plus précisément, le contrôle de parité fois une autre matrice éparse est
rendue publique), ce qui n'est pas le cas dans notre approche.
Avec ceci en tête, nous concluons que toutes les attaques connues sur le cryptosystème ne
semblent pas fonctionner. Même si un adversaire était capable de trouver d'une manière ou d'une
autre la matrice U2 ou la matrice de contrôle de parité correspondante, il lui faudrait encore trouver le
nombre de blocs £ et casser £ McEliece ciphertexts. Cela nous amène à croire fermement qu'il est
difficile de récupérer la clé secrète à partir de la clé publique. Compte tenu de cela, nous pensons que
notre cryptosystème est sûr.
Notez que le cryptosystème est également robuste contre les attaques quantiques, sinon nous
pourrions attaquer quantiquement le McEliece original aussi bien. En outre, puisque notre protocole
est basé sur le McEliece, nous croyons fermement que chaque attaque sur le McEliece (et chaque
façon de le défendre contre les attaques) peut être adaptée à notre cryptosystème.
Si au lieu d'utiliser un code LDPC, nous utilisons un code Goppa (avec des paramètres plus
74
grands), nous pouvons prouver qu'il est difficile de factoriser la clé publique. Pour prouver cela, nous
supposons que le problème du distinguateur de Goppa est difficile et que, par conséquent, nous ne
pouvons pas distinguer la clé publique d'une matrice uniformément choisie. Mais l'utilisation d'un code
de Goppa peut compromettre l'efficacité du cryptosystème.
75
Pour trouver le code LDPC utilisé dans le cryptosystème, un adversaire devrait factoriser la
matrice U . Notez que certaines informations sont extraites de la liste A, à savoir les paramètres du
code LDPC utilisé. Pour trouver les paramètres, un adversaire peut procéder de la manière suivante :
L'adversaire choisit un vecteur dans la liste A. Puis il choisit un autre vecteur dans A qui est
linéairement indépendant du premier vecteur choisi. De nouveau, il choisit un autre vecteur qui est
linéairement indépendant des deux premiers vecteurs choisis. Il procède ainsi jusqu'à ce qu'il n'y ait
plus de vecteur linéairement indépendant à choisir. Très probablement, il obtiendra un ensemble de nf
vecteurs linéairement indépendants puisque chaque vecteur
vj = uj U
où uj = (ej | . . . |ej ) est un vecteur de taille nf. Soit {vi , . } est la liste obtenue à l'issue de cette
. . , vi procédure.
1 .e 1 n.e
La matrice
v1i
U2i = .
i
vn.e
est un changement de base de la matrice U2 . Avec cela, l'adversaire peut obtenir la valeur nf et, ainsi, il
obtient les paramètres du code LDPC, qui est un code à nf dimensions de longueur m. Mais notez qu'il
n'a plus
l'information, en particulier sur la nouvelle base, puisqu'il ne sait pas quelle base {ui , . . . . , ui } a été
utilisée pour
1 n.e
i i
construire la liste des vecteurs1 {v , . .n.e. , v }. Il ne peut donc pas récupérer U2 à partir
2 de sa matrice U i .
Une autre menace pour notre cryptosystème est l'attaque présentée dans [41] et dans le chapitre
précédent. Mais notez que cette attaque ne fonctionne que si la matrice de contrôle de parité du code
LDPC est rendue publique (plus précisément, le contrôle de parité fois une autre matrice éparse est
rendue publique), ce qui n'est pas le cas dans notre approche.
Avec ceci en tête, nous concluons que toutes les attaques connues sur le cryptosystème ne
semblent pas fonctionner. Même si un adversaire était capable de trouver d'une manière ou d'une
autre la matrice U2 ou la matrice de contrôle de parité correspondante, il lui faudrait encore trouver le
nombre de blocs f et casser f ciphertextes McEliece. Cela nous amène à croire fermement qu'il est
difficile de récupérer la clé secrète à partir de la clé publique. Compte tenu de cela, nous pensons que
notre cryptosystème est sûr.
Notez que le cryptosystème est également robuste contre les attaques quantiques, sinon nous
pourrions attaquer quantiquement le McEliece original aussi bien. En outre, puisque notre protocole
est basé sur le McEliece, nous croyons fermement que chaque attaque sur le McEliece (et chaque
façon de le défendre contre les attaques) peut être adaptée à notre cryptosystème.
50
Si au lieu d'utiliser un code LDPC, nous utilisons un code Goppa (avec des paramètres plus
grands), nous pouvons prouver qu'il est difficile de factoriser la clé publique. Pour prouver cela, nous
supposons que le problème du distinguateur de Goppa est difficile et que, par conséquent, nous ne
pouvons pas distinguer la clé publique d'une matrice uniformément choisie. Mais l'utilisation d'un code
de Goppa peut compromettre l'efficacité du cryptosystème.
51
5.3 Efficacité
L'efficacité du cryptosystème de McEliece basé sur les LDPC dépend grandement du choix des LDPC
utilisés. Dans cette section, nous allons analyser l'efficacité du cryptosystème proposé en termes de
complexité temporelle et de complexité du circuit. Pour la première, une unité de temps est une
opération binaire ; nous mesurerons le temps d'un algorithme comme le nombre d'opérations binaires
qu'il prend. Pour l'analyse de la complexité du circuit, nous analyserons la taille et la profondeur d'un
circuit, utilisant des portes ET, OU et NON, qui calcule l'algorithme.
Complexité du temps
Dans la suite, nous utiliserons la même notation que dans la section précédente. Considérons un
cryptosystème utilisant un code de Goppa de dimension k et de longueur n défini par (g, L), où g est
un polynôme avec des coefficients dans F2 p, qui peut corriger t erreurs, et utilisant un code LDPC de
dimension (nf) et de longueur m qui peut corriger δ erreurs.
Tout d'abord, nous avons besoin d'un lemme auxiliaire qui nous indique la complexité temporelle de
la multiplication de deux matrices.
Lemma 53. Soit Mn×m et Mi m×p deux matrices. La complexité de la multiplication de ces deux
matrices est de
O(nmp).
La preuve de ce lemme est faite en évaluant la complexité de la multiplication matricielle scolaire

entre ces deux matrices. Ce lemme est évidemment nécessaire pour l'analyse de notre algorithme
puisqu'il utilise beaucoup d'opérations matricielles.
Proposition 54. La complexité temporelle de l'algorithme de chiffrement de notre cryptosystème est la

suivante
( )
O mkf + Trand
t + Tˆδrand
ˆδ
où Tt rand et T rand sont les temps qu'il faut pour choisir t vecteurs de A et pour créer un vecteur
d'erreur
de poids δ, respectivement.
Preuve. La complexité de calcul du cryptage est juste la complexité de la multiplication d'un vecteur
par une matrice plus le temps de choisir t vecteurs dans la liste A, de les additionner et le temps de
choisir un vecteur aléatoire de poids δ.
En utilisant le lemme ci-dessus, nous concluons que la complexité en temps du calcul du texte
chiffré d'un message donné est de
t
O(mkf) + O(Trand) ) + O(Tˆδ
rand )
où Tt est le temps nécessaire pour choisir t vecteurs de la liste A et certains est le

rand
d'entre eux, et Tˆδ rand temps
nécessaire pour créer un vecteur d'erreur de taille m et de poids δ. Le facteur mkf correspond à la
multiplication du message m (de taille kf) par la clé publique U (de taille kf × m).
52
Proposition 55. La complexité temporelle de l'algorithme de décryptage de notre cryptosystème est de
( )
O fntp2 + T DLDPC + km2 + kn2 f2
53
où T D LDPC est le temps nécessaire pour décoder un mot corrompu en utilisant le code LDPC.
Preuve. Ici, l'analyse est un peu plus complexe. Nous supposerons que le propriétaire de la clé
secrète a préalablement calculé et stocké l'inverse des matrices P , S, Pˆ et Sˆ. Donc le temps que
prend l'algorithme de décryptage est le temps de multiplication des matrices plus le temps de
décodage d'un code de Goppa f fois et le temps de décodage d'un code LDPC.
Comme précédemment, supposons que le code Goppa utilisé dans le cryptosystème est un code
à k dimensions de longueur n avec un polynôme générateur g défini dans F2 p et que le LDPC utilisé
est un code à (nf)-dimensions de longueur m. L'algorithme de décryptage du cryptosystème original
de McEliece, comme nous l'avons vu au chapitre 4 (théorème 41), nécessite O(ntp2 ) opérations
binaires. Notez que l'algorithme de Patterson sera appliqué f fois. Ainsi, la complexité de l'algorithme
de décryptage est de
( ) ( D )
O fntp2 + O TLDPC + km2 + kn2 f2
où le facteur km2 correspond à la multiplication par la matrice Pˆ, le facteur kn2 f2 correspond à
la multiplication par la matrice Sˆ (par le Lemma 53) et LDPC
TD est le temps qu'il faut pour décoder un mot
à l'aide de
le code LDPC.
Proposition 56. La complexité temporelle de l'algorithme de création de clé de notre cryptosystème est
la suivante
( C
)
O k2 n + n2 + t3 (n - k) + (n - k)3 + TLDPC + km2 + kn2 f2 + ckfm
où T C LDPC est le temps nécessaire à la création d'un code LDPC.
Preuve. Notez que, pour créer une paire de clés pour le cryptosystème McEliece basé sur le code
LDPC, nous créons une paire de clés pour le cryptosystème McEliece original plus un code LDPC, les
matrices Pˆ et Sˆ et les multiplions. Cela prend
K ) ( C )
O McEliece + O TLDPC + km2 + kn2 f2
(
K est le temps T
nécessaire à la création d'une paire de clés pour le
où T McEliece est le
C
McEliece original, T LDPC temps
il faut pour créer une matrice génératrice d'un code LDPC et les facteurs km2 et kn2 f2 correspondent à
la multiplication par les matrices Pˆ et Sˆ respectivement. Le temps nécessaire pour créer la matrice
1
⊕.e
U est O(fnk), ce qui est négligeable pour la complexité. Nous devons également créer une liste A
d'erreurs, ce qui peut être fait en O(ckfm) opérations. Par conséquent, la complexité temporelle est
( C
)
O k2 n + n2 + t3 (n - k) + (n - k)3 + TLDPC + km2 + kn2 f2 + ckfm .
Rappelons que la liste A peut être renouvelée de temps en temps. La rénovation de la liste d'erreurs
A peut être faite avec O(ckfm) opérations.
54
L'algorithme de création de clé n'est pas aussi rapide que les algorithmes de cryptage et de
décryptage, mais nous tenons à souligner que la création de clé n'est appelée qu'une seule fois (avec un
peu de chance) alors que les autres sont appelés plusieurs fois.
55
L'idée principale à retenir est que les codes LDPC ont généralement des algorithmes de décodage
à faible complexité temporelle par rapport aux codes de Goppa. Cela signifie que les codes LDPC
s'adaptent généralement beaucoup mieux que les codes de Goppa [37]. Ainsi, le cryptage et le
décryptage pour un grand m devraient être plus rapides que le McEliece original, en utilisant un code
de même longueur.
Un autre aspect que nous voudrions souligner est le fait que ce cryptosystème est extrêmement
parallélisable. Tous les blocs Goppa peuvent être mis en œuvre en parallèle, ce qui rend l'algorithme
de décryptage beaucoup plus rapide que s'il était mis en œuvre de manière séquentielle. De plus, le
système de cryptage utilise beaucoup de multiplication de matrice dans ses algorithmes de cryptage
et de décryptage, et cette opération peut également être parallélisée. Ce fait rend le cryptosystème de
McEliece basé sur le LDPC très utile pour les implémentations matérielles. Pour appuyer ce fait, nous
allons analyser la complexité du circuit du cryptosystème.
Complexité du circuit
Avant de commencer, vérifions quelques notions de base sur la complexité des circuits. Alors que la
complexité computationnelle analyse les ressources en espace et en temps nécessaires à l'exécution
d'un programme, la complexité des circuits étudie la taille (le nombre de portes) du circuit qui calcule
un programme en utilisant uniquement des portes ET, OU et NON. Nous évaluons également ces
circuits en termes de profondeur, qui peut exprimer la capacité de parallélisation d'un programme.
Notez qu'il existe un circuit différent pour des entrées de taille différente, nous analysons donc la taille
du circuit en fonction de la taille de l'entrée.
Le résultat suivant nous donne une limite supérieure pour la complexité de la taille du circuit d'un
programme à partir de sa complexité temporelle.
Lemme 57 ([53]). Soit T (n) : N → N. Si A est un programme qui s'exécute en temps O (T (n)) alors A
( )
peut être implémenté dans un circuit de taille O T (n)2 où n est la taille de l'entrée.
La preuve de ce théorème se fait en implémentant chaque instruction de A séquentiellement dans

( )
un circuit. Ainsi, le théorème nous dit que A peut être implémenté dans un circuit de taille (et de
profondeur) O T (n)2 mais ne garantit pas qu'il n'existe pas un circuit qui calcule A avec une taille et
une profondeur plus petites, c'est-à-dire qu'il nous donne seulement une limite supérieure pour la taille
du circuit (et ne donne pas d'indice sur la limite inférieure). Un circuit plus petit peut éventuellement
être construit en optimisant le nombre de portes ou en parallélisant certaines instructions de A pour
une complexité de profondeur plus faible.
Avant de commencer l'analyse, rappelons que notre système de cryptage utilise de nombreuses
opérations matricielles, nous prouvons donc le lemme suivant qui nous donne une limite supérieure
pour la complexité du circuit de multiplication de deux matrices.
Lemme 58. Soit C un circuit qui calcule le produit de deux matrices An×k et Bk×m . Alors C a une taille
O(nkm) et une profondeur O(log k).
56
Preuve. La taille de l'entrée est la taille de A plus la taille de B, donc la taille totale est nk + mk.
Soit Cn×m = AB. Les entrées de C peuvent être calculées de la façon suivante
k
_
cij = (ail ∧ blj ).
l=1
57
Il nous faut donc une porte ET pour calculer chaque terme ail ∧ blj , ce qui nous donne un total de
V
nmk portes ET. Ensuite, nous avons besoin de k - 1 portes OU pour chacun des l(ail ∧ blj ) pour i
et j fixes. Nous pouvons calculer cela en utilisant un arbre binaire, en calculant deux par deux et
cela nous donne un circuit de profondeur log k.
Le circuit a une taille O(nmk + (k - 1)) = O(nmk) et une profondeur O(log k).
Commençons par analyser la complexité du circuit de l'algorithme de cryptage.
Proposition 59. L'algorithme de cryptage du système de cryptage McEliece basé sur le LDPC peut
être implémenté avec un circuit de taille O(mkf) et de profondeur O(log kf) plus la taille et la
profondeur du circuit pour choisir t vecteurs aléatoires de A et un vecteur aléatoire de taille m et de
poids δ.
Preuve. Pour le cryptage, nous devons calculer la complexité du circuit pour multiplier une matrice
Uk.e×m par un vecteur de message m de taille kf,
c1×m = m1×k.eUk.e×m.
Ici, la taille de l'entrée est mkf + kf.

En utilisant le lemme 58, la complexité du circuit de cryptage est de O(mkf) plus la taille du circuit
pour choisir les vecteurs aléatoires. La complexité du circuit en profondeur est O(log kf) plus la
profondeur du circuit pour choisir les vecteurs aléatoires.
Le théorème suivant nous donne la complexité du circuit pour décrypter un texte chiffré en utilisant
l'algorithme de décryptage présenté pour notre cryptosystème.
Proposition 60. L'algorithme de décryptage du système de cryptage McEliece basé sur le LDPC peut
être mis en œuvre avec un circuit de taille
( )
O m2 + (nf)2 + (ntp2 )2 + k2 + SD
LDPC
et la
profondeu ( )
O log(mn2 fk) + (ntp2 )2 + DSD
r LDPC
où SD LDPC est la taille du circuit de l'algorithme de décodage du LDPC et du DSD sa

choisis. LDPC profondeur.
Preuve. Une fois encore, nous supposons que nous avons préalablement calculé et stocké l'inverse
des matrices dans la clé secrète. Ce sont les tâches à effectuer dans le processus de décryptage :
• multiplication matricielle Pˆ-1 qui peut être implémentée avec un circuit de taille O(m2 ) et de
profondeur O(log m)
par le Lemma 58 ;
• décoder un mot de code corrompu du code LDPC, ce qui dépend du choix du code LDPC.
D DSD
Soit LDPC la taille du circuit de l'algorithme de décodage des algorithmes LDPC et LDPC son
S choisis.
profondeur
;
• multiplication matricielle Sˆ-1 qui peut être implémentée dans un circuit de taille O(n2 f2 ) et de
58
profondeur O(log nf) ;
• multiplication de la matrice P − 1 , répétée f fois, ce qui peut être fait en parallèle avec un circuit de
taille
O(n2 ) et profondeur O(log n) ;
59
• décoder un mot de code corrompu du code de Goppa. Par le Lemma 57, cette tâche peut être
( )
implémentée avec un circuit de taille (et de profondeur) O (ntp2 )2 ;
• multiplication de la matrice S−1 , répétée f fois, qui peut être effectuée en parallèle avec un circuit
de taille
O(k2 ) et profondeur O(log k)
Cela donne une limite supérieure pour la taille du circuit de
( ) ( )
O m2 + n2 f2 + n2 + (ntp2 )2 + k2 = O m2 + (nf)2 + (ntp2 )2 + k2
et la
profondeur
de ( ) ( )
O log m + log nf + log n + (ntp2 )2 + log k = O log(mn2 fk) + (ntp2 )2 .
Notez que, tant que nous choisissons la longueur du code de Goppa comme étant petite
(paramètre n et, par conséquent, les paramètres t et p), le cryptosystème a une très faible complexité
en profondeur et devrait donc être assez efficace.
5.4 Paramètres
Nous analyserons les paramètres à utiliser et la sécurité attendue du cryptosystème en tenant compte
des attaques classiques et quantiques de décodage de l'ensemble des informations (voir le chapitre
4). Rappelons que, pour un code de dimension k et de taille n qui corrige t erreurs, la complexité de
l'attaque classique de décodage de l'ensemble des informations
() ! est la suivante
n
2 k n-t
Ωn ( k )
et la complexité de l'attaque de décodage de l'ensemble des informations quantiques est de

s (n) !
Ωn 2 (k n-t ) .
0.29 k
Si l'on veut utiliser le décodage classique de l'ensemble d'informations pour notre cryptosystème, il
faut noter que l'on doit l'utiliser pour décoder le code LDPC et ensuite pour décoder chacun des blocs
Goppa. Ainsi, la complexité
m (m / ,
2 ) m-δ))
de cette attaque à notre cryptosystème est Ω n.e
( n.e
( ce qui correspond à décoder le code
LDPC,
(n / ),
plus Ω (fn2 k ) (n-t)
k
ce qui correspond à décoder chacun des blocs de Goppa. Une borne inférieure
dans le
la complexité totale de
l'attaque est ( m) (n) !
2 n. e 2k
Ω m (m-δ) + fn (n-t) .
n.e k
Pour un choix de paramètres m = 1024, n = 64, f = 12, k = 30, δ = 70, t = 4, le nombre attendu
60
d'opérations d'une attaque par décodage d'ensemble d'informations est d'environ 2172 . Pour ces
paramètres, la taille de la clé (sous la forme systématique) est (m - kf) × kf ≈ 30KB (kilo-octet),
ce qui est beaucoup plus petit que le McEliece.
61
clé publique. Pour le même niveau de sécurité, la taille de la clé de notre cryptosystème est environ dix
fois plus petite que celle de la clé de McEliece.
De manière analogue, la complexité de l'attaque par décodage d'ensembles quantiques pour notre
cryptosystème est la suivante
s (m ) s (n ) !
Ωm 2 (n.m-δ
e )
+ fn 2
(k ) .
0,29 n.e 0,29 n-t
k
Pour le même choix de paramètres que ci-dessus, le cryptosystème a une sécurité quantique
d'approximativement
297 opérations.
En gardant cela à l'esprit, nous pouvons estimer les paramètres de notre cryptosystème. Ces
estimations sont présentées dans le tableau 5.1.
Paramètres Taille de la clé

publique Sécurité PQ Sécurité
m n f k δ t
(systématique) 172 97
1024 64 12 30 70 4 30 KB ≈ 2103 ≈ 263
1000 12 50 4 60 2 20 KB ≈2 ≈2
Tableau 5.1 : Paramètres du cryptosystème McEliece basé sur le LDPC
Pour maximiser la sécurité, nous devons augmenter la taille des blocs de Goppa. Cela conduit à
une augmentation du nombre d'opérations pour l'attaque de décodage de l'ensemble d'informations.
Mais, comme nous l'avons vu dans la section précédente, si chacun des blocs de Goppa devient trop
grand, le cryptosystème n'est pas aussi efficace. Il existe donc un compromis entre la sécurité et
l'efficacité : si l'on recherche l'efficacité, il est préférable de choisir des blocs de Goppa plus petits ; si
l'on cherche à maximiser la sécurité, il faut choisir des blocs de Goppa plus grands.
5.5 Sur l'indiscernabilité du McEliece basé sur le LDPC
Malheureusement, le McEliece basé sur le LDPC n'est pas sécurisé par IND-CCA2, car il est
extrêmement malléable (comme le McEliece original).
Proposition 61. Le McEliece basé sur le LDPC n'est pas sûr IND-CCA2.
Preuve. Pour prouver que le McEliece basé sur le LDPC n'est pas sécurisé par IND-CCA2, nous allons
construire un adversaire A
qui a une probabilité non négligeable de gagner le jeu IND-CCA2 présenté à la page 20.
A suit cette stratégie : lorsque A reçoit le texte chiffré de défi c = mb U + E + rδ , elle choisit un
message m, différent de m0 et m1 , et calcule ci = mU + c. Notez que ci est un texte chiffré valide.
Donc, A peut demander à l'oracle de décryptage le décryptage de ci , qui est m + mb . Maintenant,
puisque A connaît m, m0 et m1 , elle peut découvrir exactement quelle est la valeur de b. Nous
concluons que l'avantage de A dans le jeu IND-CCA2 pour le McEliece basé sur LDPC est maximal.
62
Dans cette section, nous allons proposer une variante IND-CCA2 du cryptosystème McEliece basé
sur le LDPC. Comme nous l'avons déjà souligné dans cette thèse, la propriété IND-CCA2 est une
propriété de sécurité cruciale pour les crypto-systèmes de nos jours (voir chapitre 3).
63
Pour notre variante IND-CCA2 du cryptosystème, nous aurons besoin du concept de fonction de
hachage cryptographique, présenté précédemment au chapitre 3. Rappelons qu'une fonction de
hachage cryptographique prend une entrée de n'importe quelle taille et l'applique à une sortie de taille
fixe, de sorte qu'il est difficile de l'inverser et de trouver des collisions.
Pour obtenir la propriété IND-CCA2, nous allons supprimer la malléabilité du cryptosystème. L'idée
est très simple : l'erreur qui sera corrigée par le LDPC (noté rδ , comme dans les sections
précédentes) qui sera utilisé dans la construction d'un texte chiffré sera choisi en fonction d'une
fonction de hachage cryptographique. Étant donné un texte chiffré, si nous faisons cela, il devient
infaisable de créer d'autres textes chiffrés valides à partir d'un texte valide, ce qui est l'idée de
l'attaque IND-CCA2 présentée dans la preuve ci-dessus.
Nous choisissons une fonction de hachage cryptographique H telle que H fait correspondre des
()
entrées de taille arbitraire à une taille fixe.
sortie. Soit K =m , où
δ
δ est le nombre d'erreurs corrigées par le code LDPC de longueur m dans le
cryptosystème1 et choisissons H de telle sorte que son ensemble de sortie soit {1, . . . , K}. Nous
définissons une nouvelle fonction He
en utilisant H :
H e(x) := Conv [H(x)]
où Conv est une bijection entre {1, . . . , K} et les vecteurs d'erreur de taille m et de poids δ. Notez que,
comme
m croît, K croît aussi. La probabilité de trouver des collisions pour cette fonction est donc
exponentiellement faible.
Nous présentons maintenant formellement la construction. Lorsque nous cryptons un message m,
nous choisissons d'abord une valeur aléatoire s de taille fixe et calculons
r = He(m|s).
De plus, au lieu de simplement chiffrer m, nous chiffrerons m|s. Ce sera le vecteur d'erreur à ajouter
au texte chiffré dans l'algorithme de chiffrement et qui sera corrigé par l'algorithme de décodage
LDPC. Lors du décryptage, il suffit de vérifier si rδ = He(m|s). Si c'est le cas, le texte chiffré était valide.
Dans le cas contraire, le texte chiffré est rejeté comme étant invalide.
L'algorithme 11 décrit brièvement la version IND-CCA2 du McEliece basé sur le LDPC.
Algorithme 11 Version IND-CCA2 de McEliece basée sur le LDPC

Paramètres de sécurité : Les mêmes que dans le système de cryptage McEliece basé sur le
LDPC, plus une fonction de hachage cryptographique H.
Création de la clé : Même chose que pour le McEliece basé sur le LDPC.
Cryptage : Choisissez une chaîne aléatoire s et cryptez m|s en utilisant l'algorithme de cryptage du
McEliece basé sur le LDPC, sauf que le vecteur aléatoire de poids δ ne sera pas choisi au hasard,
mais en accord avec H, c'est-à-dire rδ = He(m|s). Le texte chiffré sera
c = (m|s)U + E + He(m|s).
Décryptage : Appliquer l'algorithme de décryptage du McEliece basé sur le LDPC pour obtenir m|s.
Calculez le vecteur d'erreur rδ = c + (m|s)U + E. Vérifiez si c est un texte chiffré valide en vérifiant si
rδ est égal à He(m|s). Si ce n'est pas le cas, rejeter c.
64
1 Une fois de plus, nous voyons l'importance de choisir un LDPC qui corrige une fraction constante d'erreurs.
65
Ce protocole est similaire à la conversion générique de Fujisako-Okamoto, présentée au chapitre
3. La différence est que, dans notre conversion, seule une partie de la randomisation du
cryptosystème est déterminée par la fonction de hachage cryptographique alors que, dans la
conversion générique de Fujisako et Okamoto, toute la randomisation est déterminée par la fonction
de hachage cryptographique.
Nous allons maintenant prouver que cet algorithme est effectivement sécurisé par IND-CCA2. Tout
d'abord, nous montrons qu'il est sécurisé par IND-CPA.
Théorème 62. Le cryptosystème McEliece basé sur le LDPC est sécurisé IND-CPA dans le modèle
d'oracle aléatoire étant donné que le McEliece randomisé est sécurisé IND-CPA. Ainsi, il est sécurisé
IND-CPA étant donné que les problèmes LNP et Goppa Distinguisher sont difficiles.
Preuve. Considérons les deux jeux suivants :

Jeu 1 : jeu IND-CPA où m est chiffré de la manière suivante : (m|s)U + E + r, où r est un vecteur
aléatoire de poids δ.
Jeu 2 : jeu IND-CPA où m est chiffré de la manière suivante : (m|s)U + E + He(m|s). Nous
allons prouver le théorème en prouvant quelques affirmations.
Affirmation 1 : Du point de vue de l'adversaire, le jeu 1 et le jeu 2 sont indiscernables du point de
vue du calcul, étant donné que H est une fonction de hachage cryptographique.
Puisque l'adversaire ne connaît pas la valeur aléatoire s choisie lors du cryptage et que H est un
cryptogramme, il est possible d'utiliser le cryptogramme.
tographique, la valeur He(m|s) semblera complètement aléatoire pour l'adversaire, ce qui signifie qu'il
ne peut pas faire la distinction entre He(m|s) et un vecteur aléatoire de poids δ. Il ne peut donc pas
distinguer
entre ces deux jeux.
Affirmation 2 : L'avantage d'un adversaire A dans le jeu 1 est négligeable.
La preuve se fait par réduction. Supposons que l'avantage d'un adversaire A soit non-négligeable
pour le jeu 1, c'est-à-dire,
A
Adv Jeu 1 (γ) > E
où γ est le paramètre de sécurité et E est une valeur non-négligeable. Ensuite, nous construirons un
adversaire B qui a un avantage non négligeable de casser la sécurité IND-CPA du cryptosystème
McEliece randomisé (ce qui est un problème difficile, étant donné que les problèmes LPN et Goppa
Distinguisher sont tous deux difficiles, comme nous l'avons vu dans le chapitre précédent).
B fonctionne comme suit :
1. B reçoit une clé publique du cryptosystème aléatoire de McEliece U1 du challenger. B choisit un

LDPC capable de corriger δ erreurs, avec une matrice génératrice U2 (qu'il gardera pour lui) et
calcule U = U1 .U2 . B simule A et lui donne U comme clé publique pour le cryptosystème ;
2. Finalement, A produit deux messages m0 , m1 . B produit ces deux messages au challenger ;
3. B reçoit c du challenger, où c est un texte chiffré McEliece aléatoire de mb , avec b ∈

{0, 1} ;
4. B calcule ci = cU2 +r, où r est un vecteur aléatoire de poids δ. Il soumet ci à A comme texte
66
chiffré de défi ;
67
5. B produit tout ce que A produit.
L'avantage de B de casser la sécurité IND-CPA du McEliece randomisé est le suivant
RM,B i
Adv ind-cpa (γ ) = (γ) > E
A
Adv Jeu 1
où γi est le paramètre de sécurité du McEliece randomisé. Puisqu'il est prouvé que cet avantage est
négligeable, nous concluons que l'avantage de casser la sécurité IND-CPA de la version IND-CCA2
du cryptosystème McEliece basé sur le LDPC est également négligeable.
Théorème 63. Pour tout qH , il existe un extracteur (λ) K pour la version IND-CCA2 du McEliece basé
sur le LDPC, où 1 - λ est une valeur négligeable.
Preuve. Soit (U, A, t, δ) la clé publique du McEliece basé sur le LDPC. Nous désignerons l'étendue de
U par Im(U ). La spécification de K est présentée dans l'algorithme 12. Soit τ = {(h1 , H1 ), . . . (hq H , Hq H
)} est une liste de questions posées à l'oracle aléatoire par un adversaire et les réponses respectives,
η = {y1 , . . . , yq E } sont une liste de réponses aux questions posées à l'oracle de chiffrement par le
même adversaire et que c ∈/ η soit un texte chiffré.
Algorithme 12 Spécification de l'extracteur de connaissances K

entrée : (τ, η, c, U ) ;
sortie : m.
pour qH fois faire
ci = c - Hi où (hi , Hi ) ∈ τ ;
si ci ∈ Im(U ) alors
m = (hi )k.e (les kf premiers bits de hi ) ;
pause
; sinon
m =⊥, où ⊥ est la chaîne vide ;

fin si fin
pour
retourner m.
Vérifier si le vecteur ci est dans le domaine de la transformation linéaire U peut être fait en temps
polynomial (par exemple, en vérifiant si l'équation ci = Ux a une solution ou non).
K court dans le temps
)
ti = qH (|c| + TIm(U) + kf
où |c| est la longueur de c et TIm(U) est le temps nécessaire pour évaluer si ci est dans l'image de U . La
complexité temporelle est donc la suivante
( )
O qH (|c| + TIm(U) + kf) .
Analysons maintenant la probabilité de succès de K. Soit D l'algorithme de décryptage de la version
68
IND-CCA2 du McEliece basé sur le LDPC, sk sa clé secrète et soit ζ une borne supérieure pour la
probabilité de K.
69
trouver une collision pour la fonction de hachage H, c'est-à-dire,
Pr trouve x, y : H(x) = H(y) ≤ ζ.
Définissons deux événements : Fail et AskH. Fail se produit lorsque m /= D(c, sk). AskH se produit
lorsqu'il existe (hi , Hi ) ∈ τ tel que ci = c - Hi est dans l'image de U. Alors, nous avons
Pr(Fail) = Pr(Fail|AskH).Pr(AskH) + Pr(Fail|¬AskH).Pr(¬AskH)

≤ Pr(Fail|AskH) + Pr(Fail|¬AskH) 1
≤ ζ + (m ) .
δ
Si AskH est vrai, alors la probabilité que K échoue est égale à la probabilité de trouver une collision
pour la fonction de hachage H. Donc
Pr(Fail|AskH) ≤ ζ .
Lorsque AskH est faux, alors K sortira m =⊥, c'est-à-dire que K considérera c comme un texte chiffré
invalide. Si c est un texte chiffré valide, cela signifie que l'adversaire B a réussi à créer un texte chiffré
valide sans interroger l'oracle H. Donc,
1
|¬demandeH)
Pr(Échec à la () =m
δ
qui est la probabilité de deviner le bon vecteur d'erreur pour un message m donné et une valeur
aléatoire s. Par conséquent, la probabilité que K n'échoue pas est la suivante
Pr(¬Fail) = 1 − Pr(Fail)
1
≥ 1 - ζ + (m )
δ
et nous concluons que K est un extracteur de connaissances λ-, où
1
λ ≥ 1 - ζ + (m ) .
δ
Puisque ζ +1 est une valeur négligeable, nous ≈ 1.

avons que λ
(mδ)
Nous sommes maintenant en mesure d'affirmer que cette version du cryptosystème possède la
propriété IND-CCA2, en connectant les deux théorèmes précédents et en notant que la sécurité PA
implique la sécurité IND-CCA2 (voir chapitre 3, théorème 29).
Théorème 64. La version IND-CCA2 du McEliece basé sur le LDPC est sécurisée par IND-CCA2
étant donné que le McEliece randomisé basé sur le LDPC est sécurisé par IND-CPA.
En corollaire, nous avons que cette version est également non-malléable.
Corollaire 65. La version IND-CCA2 du cryptosystème McEliece basé sur le LDPC est sécurisée par
NM-CCA2.
70
Chapitre 6
Conclusions
Le post-quantique sera bientôt une réalité dans notre vie quotidienne. Il est donc essentiel de trouver
de nouveaux protocoles post-quantiques efficaces et sûrs, et c'est ce que fait actuellement la
communauté cryptographique.
Actuellement, le système cryptographique de McEliece est un candidat sérieux pour devenir très
bientôt l'un des systèmes cryptographiques les plus utilisés dans la pratique. Sa structure est simple et
élégante et, bien qu'il n'existe pas de preuve formelle de sécurité, personne n'a la moindre idée de la
façon de le casser, que ce soit de manière classique ou quantique. Cependant, le cryptosystème
présente encore quelques inconvénients, le plus problématique étant la taille de la clé.
Nous avons pu construire une variante du cryptosystème de McEliece que nous avons appelé le
cryptosystème de McEliece basé sur les codes LDPC. Ce cryptosystème utilise des codes LDPC qui
ont des algorithmes de décodage très efficaces et rendent le décryptage encore plus rapide et plus
simple à mettre en œuvre. De plus, la composition des codes de Goppa et des codes LDPC utilisés
dans la nouvelle construction réduit considérablement la taille de la clé par rapport au McEliece
original. Nous pensons que ces deux améliorations rendent notre cryptosystème adapté aux
applications logicielles et matérielles.
Nous avons pu prouver à la fois la sécurité du texte chiffré et la sécurité de la clé publique pour
cette nouvelle construction. Nous n'avons pas pu prouver qu'il est difficile de factoriser la clé publique.
Cependant, nous avons donné quelques arguments pour expliquer pourquoi nous pensons qu'il est
difficile de trouver des attaques qui factorisent la clé publique.
Bien que notre construction ne satisfasse pas la propriété IND-CCA2, nous avons présenté une
variante IND-CCA2 du cryptosystème McEliece basé sur le LDPC. Il est prouvé que cette variante est
consciente du texte en clair dans le modèle de l'oracle aléatoire, et qu'elle est donc sécurisée par la
propriété IND-CCA2 dans ce modèle.
Orientations des travaux futurs
Bien que nous n'ayons pas pu prouver que la factorisation de la clé publique est un problème difficile,
nous croyons fermement qu'il l'est. Trouver une preuve de ce fait sera laissé comme travail futur.
Dans la variante IND-CCA2 du cryptosystème McEliece basé sur le LDPC, nous ne voyons
71
aucune raison d'utiliser une fonction de hachage cryptographique plutôt qu'une fonction de hachage
universelle. Nous pensons que l'utilisation d'une fonction de hachage universelle est suffisante pour
qu'un adversaire ne puisse pas créer de ciphertextes valides sans connaître le message
correspondant. Si nous pouvions prouver la sécurité IND-CCA2 pour un protocole utilisant une
fonction de hachage universelle, nous prouverions la sécurité IND-CCA2 dans le modèle standard, ce
qui est un résultat beaucoup plus fort que la sécurité dans le modèle standard.
72
modèle d'oracle aléatoire. En effet, les fonctions de hachage cryptographiques n'existent pas encore
dans la vie réelle, alors que les constructions de fonctions de hachage universelles existent.
De plus, trouver des méthodes pour réduire encore plus la taille de la clé du cryptosystème de
McEliece est d'une grande importance si nous espérons remplacer les protocoles cryptographiques
actuels par des protocoles résistants aux quanta, en particulier par le cryptosystème de McEliece.
73
Bibliographie
[1] Premières recommandations de systèmes post-quantiques sécurisés à long terme. Rapport

technique, 2015.
[2] Noga Alon. Eigenvalues et expanseurs. Combinatorica, 6(2):83-96, 1986.
[3] Mihir Bellare, Anand Desai, David Pointcheval et Phillip Rogaway. Relations entre les notions de
sécurité pour les schémas de chiffrement à clé publique. Dans Advances in Cryptology-
CRYPTO'98, pages 26-
45. Springer, 1998.
[4] Mihir Bellare et Phillip Rogaway. Optimal asymmetric encryption. Dans Advances in Cryptol- ogy-
EUROCRYPT'94, pages 92-111. Springer, 1995.
[5] Elwin R. Berlekamp. Goppa codes. IEEE Transactions on Information Theory, 19(5):590-592,
1973.
[6] Elwin. R. Berlekamp. Théorie du codage algébrique - Édition révisée. World Scientific Publishing
Co., Inc., River Edge, NJ, USA, 2015.
[7] Elwyn R. Berlekamp, Robert J. McEliece, et Henk Van Tilborg. On the inherent intractability of
certain coding problems (corresp.). IEEE Transactions on Information Theory, 24(3):384-386,
1978.
[8] Daniel Bernstein, Tanja Lange et Christiane Peters. Attaque et défense du système cryptique
McEliece. Post-Quantum Cryptography, pages 31-46, 2008.
[9] Daniel J. Bernstein. Grover vs. McEliece. Dans International Workshop on Post-Quantum
Cryptogra- phy, pages 73-80. Springer, 2010.
[10] Daniel J. Bernstein, Johannes Buchmann et Erik Dahmen. Cryptographie post-quantique.

Springer Berlin Heidelberg, 2009.
[11] Daniel J. Bernstein, Tanja Lange et Christiane Peters. Attaque et défense du cryptosystème
McEliece. Dans International Workshop on Post-Quantum Cryptography, pages 31-46. Springer,
2008.
[12] Thomas A. Berson. Failure of the McEliece public-key cryptosystem under message-resend and
related-message attack. Dans Advances in Cryptology - CRYPTO '97, 17th Annual International
Cryp- tology Conference, Santa Barbara, California, USA, August 17-21, 1997, Proceedings,
74
volume 1294 of Lecture Notes in Computer Science, pages 213-220. Springer, 1997.
75
[13] Anne Canteaut et Nicolas Sendrier. Cryptanalyse du cryptosystème original de McEliece. In
International Conference on the Theory and Application of Cryptology and Information Security,
pages 187-199. Springer, 1998.
[14] Nicolas T. Courtois, Matthieu Finiasz, et Nicolas Sendrier. Comment réaliser un schéma de
signature numérique basé sur McEliece. Dans International Conference on the Theory and
Application of Cryptology and Information Security, pages 157-174. Springer, 2001.
[15] Whitfield Diffie et Martin Hellman. New directions in cryptography. IEEE Transactions on Infor-
mation Theory, 22(6):644-654, 1976.
[16] Nico Dottling, Rafael Dowsley, Jo¨ rn Muller-Quade, et Anderson C. A. Nascimento. Une variante
sécurisée CCA2 du cryptosystème McEliece. IEEE Transactions on Information Theory,
58(10):6672- 6680, 2012.
[17] Taher ElGamal. Un système de cryptage à clé publique et un schéma de signature basés sur les
logarithmes discrets.
IEEE Transactions on Information Theory, 31(4):469-472, 1985.
[18] Daniela Engelbert, Raphael Overbeck, et Arthur Schmidt. A summary of McEliece-type cryp-
tosystems and their security. J. Mathematical Cryptology, 1(2):151-199, 2007.
[19] Jean-Charles Faugere, Vale'rie Gauthier-Umana, Ayoub Otmani, Ludovic Perret, et Jean-Pierre
Tillich. A distinguisher for high-rate McEliece cryptosystems. IEEE Transactions on Information
Theory, 59(10):6830-6844, 2013.
[20] Jean-Bernard Fischer et Jacques Stern. An efficient pseudo-random generator provably as se-
cure as syndrome decoding. In International Conference on the Theory and Applications of Cryp-
tographic Techniques, pages 245-255. Springer, 1996.
[21] Eiichiro Fujisaki et Tatsuaki Okamoto. How to enhance the security of public-key encryption at
minimum cost. Dans International Workshop on Public Key Cryptography, pages 53-68. Springer,
1999.
[22] Robert G. Gallager. Low-density Parity-check Codes. Monographies de recherche du M.I.T.

Press. M.I.T. Press, 1963.
[23] Valerii D. Goppa. Une nouvelle classe de codes correcteurs linéaires. Problemy Peredachi
Informatsii, 6(3):24- 30, 1970.
[24] Venkatesan Guruswami et Piotr Indyk. Codes codables/décodables en temps linéaire avec un
taux quasi-optimal. IEEE Transactions on Information Theory, 51(10):3393-3400, 2005.
[25] Raymond Hill. Un premier cours sur la théorie du codage. Oxford Applied Linguistics. Clarendon
Press, 1986.
[26] Jeffrey Hoffstein, Jill Catherine Pipher, Joseph H Silverman, et Joseph H Silverman. An introduc-
tion to mathematical cryptography, volume 1. Springer, 2008.
76
[27] Shlomo Hoory, Nathan Linial, et Avi Wigderson. Les graphes d'expansion et leurs applications.
Bulletin of the American Mathematical Society, 43(4):439-561, 2006.
[28] Nabil Kahale. Sur la deuxième valeur propre et l'expansion linéaire des graphes réguliers. Dans
Foundations of Computer Science, 1992. Proceedings, 33rd Annual Symposium on, pages 296-
303. IEEE, 1992.
[29] Kazukuni Kobara et Hideki Imai. Semantically secure McEliece public-key cryptosystems - Con-
versions for McEliece PKC-. In Proceedings of the 4th International Workshop on Practice and
Theory in Public Key Cryptography : Public Key Cryptography, PKC '01, pages 19-35, Londres,
UK, 2001. Springer-Verlag.
[30] Frank R. Kschischang, Brendan J. Frey, et H-A. Loeliger. Factor graphs and the sum-product
algorithm. IEEE Transactions on information theory, 47(2):498-519, 2001.
[31] Yuan Xing Li, Robert H. Deng, et Xin Mei Wang. On the equivalence of McEliece's and Niederre-
iter's public-key cryptosystems. IEEE Transactions on Information Theory, 40(1):271-273, 1994.
[32] Pierre Loidreau et Nicolas Sendrier. Weak keys in the McEliece public-key cryptosystem. IEEE
Transactions on Information Theory, 47(3):1207-1211, 2001.
[33] Alexander Lubotzky, Ralph Phillips, et Peter Sarnak. Les graphes de Ramanujan. Combinatorica,
8(3):261-277, 1988.
[34] Michael G. Luby, Michael Mitzenmacher, Amin Shokrollahi et Daniel A. Spielman. Analysis of low
density codes and improved designs using irregular graphs. In Proceedings of the Thirtieth
Annual ACM Symposium on Theory of Computing, STOC '98, pages 249-258, New York, NY,
USA, 1998. ACM.
[35] Michael G. Luby, Michael Mitzenmacher, Amin Shokrollahi et Daniel A. Spielman. Improved low-
density parity-check codes using irregular graphs. IEEE Transactions on Information Theory,
47(2):585-598, septembre 2006.
[36] David J. C. MacKay. Théorie de l'information, inférence et algorithmes d'apprentissage.

Cambridge university press, 2003.
[37] David J. C. MacKay. Good error-correcting codes based on very sparse matrices. IEEE Transac-
tions on Information Theory, 45(2):399-431, septembre 2006.
[38] Pedro Maat C Massolino, Paulo SLM Barreto, et Wilson V Ruggiero. Coprocesseur optimisé et
évolutif pour mceliece avec codes binaires goppa. ACM Transactions on Embedded Computing
Systems (TECS), 14(3):45, 2015.
[39] Robert. J. McEliece. A public-key cryptosystem based on algebraic coding theory. DSN Progress
Report, 42(44):114-116, 1978.
[40] Alfred J Menezes, Paul C Van Oorschot, et Scott A Vanstone. Handbook of applied cryptography.
CRC press, 1996.
77
[41] Chris Monico, Joachim Rosenthal et Amin Shokrollahi. Utilisation de codes de contrôle de parité
à faible densité dans le cryptosystème McEliece. Dans Information Theory, 2000. Proceedings.
IEEE International Sympo- sium on, page 215. IEEE, 2000.
[42] Robert Niebuhr, Mohammed Meziani, Stanislav Bulygin, et Johannes Buchmann. Sélection des
pa- ramètres pour les cryptosystèmes sécurisés basés sur McEliece. International Journal of
Information Security, 11(3):137-147, 2012.
[43] Harald Niederreiter. Knapsack-type cryptosystems and algebraic coding theory. Problems of Con-
trol and Information Theory - Problemy Upravleniya i Teorii Informatsii, 15(2):159-166, 1986.
[44] Ryo Nojima, Hideki Imai, Kazukuni Kobara et Kirill Morozov. Sécurité sémantique pour le
cryptosystème McEliece sans oracles aléatoires. Designs, Codes and Cryptography, 49(1):289-
305, 2008.
[45] Nicholas Patterson. Le décodage algébrique des codes de Goppa. IEEE Transactions on
Information Theory, 21(2):203-207, mars 1975.
[46] David Pointcheval. Chosen-ciphertext security for any one-way cryptosystem. In Proceedings of
the Third International Workshop on Practice and Theory in Public Key Cryptography : Public Key
Cryptography, PKC '00, pages 129-146, Londres, Royaume-Uni, 2000. Springer-Verlag.
[47] Ronald L. Rivest, Adi Shamir, et Leonard Adleman. Une méthode pour obtenir des signatures
numériques et des cryptosystèmes à clé publique. Communications of the ACM, 21(2):120-126,
1978.
[48] Christopher Roering. Cryptographie basée sur la théorie du codage : Les cryptosystèmes de
McEliece dans Sage. 2013.
[49] Claude E. Shannon. Une théorie mathématique de la communication. ACM SIGMOBILE Mobile
Comput- ing and Communications Review, 5(1):3-55, 2001.
[50] Amin Shokrollahi. Codes LDPC : An introduction. Fontaine numérique, Inc, Tech. Rep, page 2,
2003.
[51] Peter W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a
quantum computer. SIAM review, 41(2):303-332, 1999.
[52] Vladimir M Sidelnikov et Sergey O Shestakov. On insecurity of cryptosystems based on general-

ized reed-solomon codes. Discrete Mathematics and Applications, 2(4):439-444, 1992.
[53] Michael Sipser. Introduction à la théorie du calcul, volume 2. Thomson Course Technology
Boston, 2006.
[54] Michael Sipser et Daniel A. Spielman. Expander codes. IEEE Transactions on Information The-
ory, 42:1710-1722, 1996.
[55] Daniel A. Spielman. Linear-time encodable and decodable error-correcting codes. IEEE Transac-
tions on Information Theory, 42(6):1723-1731, 1996.
78
[56] Jacques Stern. Une méthode pour trouver des mots de code de petit poids. In International
Colloquium on Coding Theory and Applications, pages 106-113. Springer, 1988.
79
[57] Hung-Min Sun. Further cryptanalysis of the McEliece public-key cryptosystem. IEEE Communica-
tions Letters, 4(1):18-19, 2000.
[58] Salil P. Vadhan et al. Pseudorandomness. Foundations and T r e n d s O R en informatique théorique

Science, 7(1-3):1-336, 2012.
[59] Alexander Vardy. The intractability of computing the minimum distance of a code. IEEE
Transactions on Information Theory, 43(6):1757-1766, novembre 1997.
[60] Glie's Ze'mor. On expander codes. IEEE Transactions on Information Theory, 47(2):835-837, 2001.
80
81
Index
propagation des LDPC, 8

croyances, 14 fonction Système de cryptage McEliece basé sur le
d'entropie binaire, 16 LDPC, 47 Apprentissage avec bruit de parité,
30
Graphe de Cayley, 10
Vecteur de syndrome
PKC de McEliece, 26
computationnel, 5 correction, 18
Niederreiter PKC, 28
algorithme de décodage, 4
NM-CCA, 21
graphe d'incidence bord-vertex, 10 NM-CCA2, 21
Code Expander, 15 NM-CPA, 21
graphique de l'expandeur, 11 non-malléabilité, 20
Fusisaki-Okamoto, 23 ans
algorithme de Patterson, 7
Code Goppa, 5 groupe linéaire projectif, 11
Problème de distinction de Goppa, cryptosystème à clé
30 graphique, 10 publique, 17
fonction de hachage, 18 Graphe de Ramanujan, 11

oracle aléatoire, 18
IND-CCA, 19
IND-CCA2, 20 graphique régulier, 10
IND-CPA, 19 LDPC normal, 13
indiscernabilité, 19
sécurité, 18
extracteur de connaissances, 23 groupe linéaire spécial, 11
modèle standard, 18
82

Thesis 1 30 FR - Merged

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Thesis 1 30 FR - Merged

Enviado por

Direitos autorais:

Formatos disponíveis

Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux.

Visitez www.DeepL.com/propour en savoir plus.

Un nouveau cryptosystème McEliece basé sur le LDPC

Pedro de Melo Branco

Thèse pour obtenir le Master of Science Degree en

Superviseur : Prof. Paulo Alexandre Carreira Mateus

Palavras-chave : criptografia, teoria de co'digos, encriptac¸a˜o de chave-pu'blica, sistema crip-

3 Schéma de cryptage à clé publique 17

2.1 Notions de base

quelconques du code. Par un

Problème 2 (vecteur de syndrome computationnel). Etant donné un

2.2 Codes Goppa

Exemple 4. Soit p = 4 et on considère le polynôme f (x) = x4 + x + 1 qui est irréductible dans F2 . On

Considérons maintenant le polynôme g(x) = x2 + x + α3 dans F16 [x] et L = {αi : 2 ≤ i ≤ 13} un

g(1α2) g(1α3) g(1α4) g(1α5) g(1α6) g(1α7) g(1α8) g(1α9) 1 )

et donc, le syndrome de y est le même que le vecteur d'erreur e (comme prévu).

On définit le polynôme localisateur d'erreurs de y = w + e où w ∈ C et e est tel que wt(e) ≤ t.

d(x) = t0 (x) + h0 (x)h−1

2.3 Codes LDPC

Figure 2.1 : Code LPDC.

Théorie des graphes

Définition 8 (graphe de Cayley). Soit G un groupe et S un ensemble générateur de G. Le graphe de

Définition 9 (Graphe à incidence bord-vertex). Soit X un graphe. Le graphe d'incidence bord-vertex

lim λ(X) ≥ 2√d - 1.

PGLn (V ) := GLn (V )/Zn (V )

PSL2 (Zq ) = SL2 (Zq )/SZ2 (Zq )

L'algorithme 2 décrit la construction de graphes de Ramanujan explicites et a été présenté pour la

Algorithme 2 Construction des graphes de Ramanujan

et un1 , un2 , un3 sont pairs ;

Exemple 15. Considérons un graphe de Ramanujan construit à l'aide de l'algorithme 2 avec p = 13 et

Codes LDPC réguliers

Figure 2.3 : LDPC ordinaire.

codes LDPC réguliers) correctes.

H- (x) = -x log2 x - (1 - x) log2(1 - x)

Schéma de cryptage à clé publique

3.1 Notions de base

Le cryptage à clé publique permet à deux parties de communiquer en privé. Contrairement à la

Définition 20 (cryptosystème à clé publique). Un système de cryptage à clé publique, ou schéma de

c. De manière informelle, r représente le caractère aléatoire du cryptosystème. Tout au long de cette

D[E (pk, m ; r), sk] = m

Définition 22 (Fonction de hachage cryptographique). Une fonction de hachage cryptographique H est

3.2 Notions de sécurité

1. A peut faire un nombre polynomial arbitraire de cryptages ;

2. À un moment donné, A soumet deux messages différents m0 et m1 à C ;

3. C choisit au hasard un bit b ∈ {0, 1} et envoie le challenge-ciphertext c = E (pk, mb ), le

4. Là encore, A peut effectuer un nombre polynomial arbitraire de cryptages ;

5. A produit ¯b, une estimation de b.

A gagne le jeu s'il peut deviner correctement le bit b.

2. À un moment donné, A soumet deux messages différents m0 et m1 à C ;

3. C choisit au hasard un bit b ∈ {0, 1} et envoie le challenge-ciphertext c = E (pk, mb ), le

4. Là encore, A peut effectuer un nombre polynomial arbitraire de cryptages ;

5. A produit ¯b, une estimation de b.

A gagne le jeu s'il peut deviner correctement le bit b.

1. A peut effectuer un nombre polynomial arbitraire de cryptages et d'appels à un oracle de décryptage ;

2. À un moment donné, A soumet deux messages différents m0 et m1 à C ;

3. C choisit au hasard un bit b ∈ {0, 1} et envoie le challenge-ciphertext c = E (pk, mb ), le

4. Là encore, A peut effectuer un nombre polynomial arbitraire de cryptages ;

5. A produit ¯b, une estimation de b.

A gagne le jeu s'il peut deviner correctement le bit b.

1. A peut faire un nombre polynomial arbitraire de cryptages ;

2. A produit un espace de messages M ;

3. C choisit un message m de M au hasard et le chiffre. Il envoie c = E (pk, m) à A ;