II. Présentation du système de McEliece

Chiffre de McEliece
Sommaire
I.
Historique de la cryptographie ...................................................................... 2
II. Présentation du système de McEliece ........................................................... 2
1. Posons le problème ...................................................................................... 2
2. Construction des paramètres du code .......................................................... 3
3. Le chiffrement .............................................................................................. 5
4. Le déchiffrement ........................................................................................... 5
III. Sûreté du système de McEliece ...................................................................... 7
5. Une première attaque .................................................................................. 7
6. Une méthode probabiliste ............................................................................ 8
7. En conclusion ............................................................................................. 10
Annexes ................................................................................................................. 11
1. Nombre moyen de tirages avant de trouver une matrice inversible ........ 11
2. Construction des corps finis .................................................................... 11
3. Trouver  un élément primitif ................................................................. 13
4. Trouver P un polynôme irréductible ....................................................... 14
5. Calcul explicite dans un corps fini .......................................................... 16
6. Complexité de la méthode du pivot de Gauss .......................................... 17
7. Détermination de k colonnes indépendantes ........................................... 19
8. Primalité et factorisation ......................................................................... 21
9. Quelques procédures écrites sous Maple ................................................ 22
10. Démonstration des théorèmes ................................................................. 24
11. La loi française sur la cryptographie ...................................................... 26
Bibliographie ........................................................................................................ 27
Cryptographie – Chiffre de McEliece
La cryptographie peut être décrite par l’image suivante : Bob veut envoyer un message secret (en général « Bonjour ») à
Alice mais pour cela il doit utiliser un canal public. Seulement, Oscar espionne et écoute tous les échanges qui se font par
l’intermédiaire de ce canal. L’idée naturelle est donc de chiffrer le message afin que seul Alice puisse le déchiffrer.
Formellement, on peut résumer tout cela par le schéma suivant :
Les clés que nous voyons apparaître sur le schéma sont des paramètres « personnels » que l’on prend en compte lors des
étapes de chiffrement et de déchiffrement et qui permettent d’apporter une diversité quasiment infinie.
Nous allons dans ce mémoire présenter principalement un système de chiffrement particulier proposé par McEliece. Nous
expliquons dans un premier temps son fonctionnement et nous testons par la suite (ce qui est indispensable pour tout système
cryptographique) la sécurité qu’il fournit. Nous nous sommes efforcés par ailleurs d’étudier en Annexes les problèmes
pratiques que l’on rencontre avec McEliece et également de présenter quelques procédures.
Signalons finalement que, dans un souci de clarté, nous avons adopté le code suivant : les théorèmes sont annoncés par un
trait bleu en marge et sont démontrés en Annexes, les exemples sont annoncés par un trait rouge en marge et les quelques
démonstrations isolées sont annoncées par un trait vert en marge.
I. Historique de la cryptographie
Les systèmes cryptographiques sont utilisés depuis très longtemps et répondaient à l’origine à des besoins militaires. On
sait par exemple que Jules César utilisait le chiffre suivant : chaque lettre du message à transmettre était remplacée par celle
qui la suivait dans l’alphabet. Par exemple, le mot BONJOUR était codé par CPOKPVS. L’utilisation de clés est également
apparue rapidement et le chiffrement de Jules César a alors fait place au chiffrement de Vigenère. Toutefois tous ces systèmes
utilisaient une clé privée, c’est-à-dire que la clé de chiffrement et la clé de déchiffrement étaient en réalité identiques. Ceci
présente un défaut important : avant de pouvoir discuter en toute sécurité, Bob et Alice devaient s’être mis d’accord sur la clé
commune, et cela en utilisant forcément un canal public. Oscar pouvait alors intercepter facilement le renseignement et puis
déchiffrer tous les messages par la suite.
La grande révolution de la cryptographie moderne a été l’introduction des systèmes à clé publique, par Diffie et Hellman,
pour lesquels la clé de chiffrement et la clé de déchiffrement ne sont pas identiques. Ainsi, Alice peut informer Bob
publiquement (en pratique par l’intermédiaire d’un annuaire ou d’un serveur de clés) de la clé de chiffrement sans pour autant
compromettre la sécurité du chiffre. Bien sûr, il y a un revers à la médaille : comme il existe forcément un lien entre les clés de
chiffrement et de déchiffrement, pour que ces méthodes puissent être utilisées, il doit être calculatoirement difficile de reformer
la clé de déchiffrement à partir celle de chiffrement, alors que l’opération inverse doit être aisée. De tels problèmes trouvent
généralement leur solution dans les mathématiques et notamment en arithmétique, par exemple pour RSA.
Cette nouvelle idée a apporté de nouvelles perspectives à la cryptographie et très vite de nombreux systèmes
cryptographiques à clé publique sont nés. Cependant, très souvent dans la précipitation, les systèmes créés se sont avérés peu
efficaces soit parce que trop compliqués à mettre en œuvre, soit parce que n’offrant pas assez de sécurité. Le système de
McEliece est l’un d’entre eux et, comme nous allons le voir, illustre bien cette période hésitante et révolutionnaire.
II. Présentation du système de McEliece
Dans tout ce qui suit F2 désigne l’ensemble {0,1} que l’on munit d’une structure de corps.
Attention ! Pour écrire les messages qui seront représentés par des vecteurs en ligne et non en colonne, nous allons
transposer toutes les matrices.
1) Posons le problème
Donnons-nous un entier n strictement positif et posons E=F2n. E est alors un espace vectoriel sur F 2 que l’on peut munir de
la norme suivante que l’on appelle le poids :
x   x1 ,..., x n   E , on pose
n
w( x)   x i
(dans R)
i 1
La distance définie par cette norme est appelée distance de Hamming.
Soit maintenant F un sous-espace vectoriel de E de dimension k. On appelle distance minimale de F la quantité suivante :
d  min wx, x  F  0
Page 2
Cryptographie – Chiffre de McEliece
i)
On a alors la propriété suivante :
d

 x  F , we  
Si x’ est un élément de E, alors il existe au plus un couple (x,e) vérifiant S  : 
2
 x'  x  e
S’il existe, le vecteur e est alors appelé le vecteur d’erreur.
Et réciproquement si pour tout x’ élément de E, il existe au plus un couple (x,e) vérifiant
x  F , we   t
où t est
 x'  x  e
S ' : 
un entier, alors la distance minimale de F est strictement supérieure à (2t).
Le problème est alors le suivant : Si on se donne x’, existe-t-il un couple solution et s’il existe, comment peut-on le
trouver ?
Ce problème est en général difficile mais il se trouve que si F a une structure particulière (que nous qualifierons de
sympathique), alors on peut trouver des algorithmes efficaces pour répondre à la question. C’est sur cette remarque que repose
le principe du système de McEliece.
Avant d’exposer celui-ci, nous allons remarquer que l’on peut trouver une application linéaire de F2k dans E, qui réalise une
bijection de F2k dans F. Appelons alors G la matrice canonique de cette application. La donnée de G entraîne bien évidemment
celle de F (on dit que F est le code engendré par G), c’est-à-dire au lieu de se donner un sous-espace vectoriel de E de
dimension k, on peut se donner une matrice de taille (k,n) (Attention, on transpose !) à coefficients dans F2; c’est ce que nous
ferrons par la suite.
Exposons donc maintenant le principe du système de McEliece. Alice choisit une matrice sympathique G de taille (k,n),
une matrice inversible S de taille (k,k) et une matrice de permutation P de taille (n,n), calcule ensuite le produit G’=SGP. Elle
rend ensuite publique la matrice G’ et le nombre maximal d’erreurs, que l’on notera t, qu’elle sait corriger avec un algorithme
simple.
Bob veut alors envoyer le message m à Alice. Pour cela, il calcule le produit de m par G’ auquel il ajoute un vecteur
d’erreur de poids convenable (inférieur ou égal au nombre publié). Il envoie alors à Alice le vecteur calculé que l’on appellera
x’. Mathématiquement cela s’écrit x'  m.G'e où w e  t .

où w(e.P 1 )  we  t . Comme G est une matrice
sympathique, elle peut facilement éliminer le vecteur d’erreur et donc retrouver m.S.G . Connaissant S et G, elle retrouve
Lorsque Alice reçoit x’, elle calcule x'.P
1
 m.S.G  e.P 1
ensuite le message original m.
Oscar, quant à lui, est confronté au problème difficile puisqu’il ne connaît que G’ (qui n’est pas une matrice sympathique),
ainsi il ne peut pas a priori éliminer l’erreur et retrouver le message.
2) Construction des paramètres du code
Bien que pratiquement, la construction des paramètres doive obligatoirement débuter par la construction de G, nous
présentons ici un ordre différent gradué par la difficulté que revêt chaque construction.
Notons également que nous utiliserons ici un code sympathique de la classe BCH, alors que McEliece avait suggéré un
code sympathique de la classe de Goppa. Ceci ne change en rien l’état d’esprit du système de chiffrement.

Construction de la matrice S
Il s’agit ici de construire une matrice de taille (k,k) inversible et aléatoire. La première idée consiste à générer une première
matrice aléatoire. On regarde ensuite si elle est inversible (par la méthode du pivot de Gauss qui est rapide lorsque les
coefficients sont dans F2 – voir Annexe 6). Si c’est le cas, on a trouvé une matrice S convenable, sinon on réitère le procédé
jusqu’à réussite. Toutefois, pour que cette méthode soit raisonnable, il faut s’assurer que le nombre de matrices que l’on va
générer ne soit pas trop grand même pour des valeurs de k élevées.
On montre (voir Annexe 1) que le nombre moyen de matrices à générer n’excède pas quatre. Ainsi cette méthode est
satisfaisante.
La procédure 1 présentée en Annexes renvoie une matrice inversible et son inverse.

Construction de la matrice P
Construire la matrice P revient à générer une permutation de l’ensemble {1,2,…,n}. La première idée simpliste consisterait
à engendrer un nombre aléatoire entre 1 et n. On le compare ensuite à ceux engendrés précédemment : s’il est distinct de tous,
on passe à l’élément suivant, sinon on essaye avec un autre nombre. Il est clair que cette méthode devient rapidement très
lente.
On peut proposer l’algorithme suivant plus efficace :
1. On définit la liste LST par LST(i)=i et r par r=0
2. On génère un nombre aléatoire a entre 1 et n-r (r définit l’étape en cours)
Page 3
Cryptographie – Chiffre de McEliece
3.
4.
On place en (r+1)° position de la permutation le nombre LST(a)
On remplace alors LST(a) déjà choisi par LST(n-r) pas encore choisi
On remarque que les LST(i) (in-r) ne pourront plus être choisis par la suite
5. On ajoute 1 à r
6. On recommence l’étape 2 jusqu’à ce que la permutation soit toute générée (i.e. r=n)
La procédure 2 présentée en Annexes renvoie une matrice de permutation et son inverse.

Construction de la matrice G
Nous allons présenter ici une catégorie de matrices sympathiques. Notre étude repose en particulier sur la théorie
mathématique des corps finis dont nous présentons les bases en Annexes. D’autre part, afin de ne pas noyer un lecteur non
averti dans des formules simplement théoriques, nous allons accompagner notre exposé d’un exemple.
Tout d’abord choisissons un entier r strictement positif et un entier t strictement positif et « pas trop grand ».
Posons alors n=2r–1 et définissons sur
Z
nZ
x et y  Z
, la relation binaire suivante :
nZ
x  y   k  N / x  2 k y 
,
Cette relation est une relation d’équivalence. On peut alors poser  t 
2 t 1
 l .
l 1
  1,2,4,8 3,6,12,9 .
POUR NOTRE EXEMPLE, CHOISISSONS r=4 ET t=1. ON A ALORS n=15 ET
Considérons maintenant  un élément primitif du corps fini F2 r (voir Annexes 2 & 3) et formons le polynôme

At  X    X   i

i t
ii)
On a alors la propriété suivante : At est un polynôme à coefficients dans F2.
SUR NOTRE EXEMPLE, CELA DONNE







A X    X   . X   2 . X   4 . X   8 . X   3 . X   6 . X   12 . X   9

SELON L’ELEMENT PRIMITIF CHOISI, ON PEUT TROUVER PLUSIEURS POLYNOMES (QUI CONVIENNENT TOUS). ON PEUT PAR
   2  1:
A X   1  X  X 2  X 4  X 8
EXEMPLE PARVENIR A (VOIR ANNEXE 5) SI ON CHOISIT
 F2 X k 1  F2 X n 1 

 At .P
 P

Considérons maintenant l’application linéaire  : 
n  1  deg At   k  1 soit k  n  deg At 
où k est défini par
Alors la matrice canonique de  est une matrice sympathique. Autrement dit, on a construit G.
SUR NOTRE EXEMPLE, ON A deg(A)=8 D’OU ON TROUVE k=7.
AINSI  EST DEFINIE PAR
 F2 X 6  F2 X 14

.

 P  P X . 1  X  X  X  X 
 : 

2
4
8

CE QUI NOUS DONNE G (ATTENTION, ON TRANSPOSE !) :
1
0

0
G  0
0
0
0

1 1 0 1 0 0 0 1 0 0 0 0 0 0


0

0
0
0

1
1 1 1 0 1 0 0 0 1 0 0 0 0 0
0 1 1 1 0 1 0 0 0 1 0 0 0
0 0 1 1 1 0 1 0 0 0 1 0 0
0 0 0 1 1 1 0 1 0 0 0 1 0
0 0 0 0 1 1 1 0 1 0 0 0 1
0 0 0 0 0 1 1 1 0 1 0 0 0
La procédure 3 présentée en Annexes génère une matrice G sympathique.
Page 4
Cryptographie – Chiffre de McEliece

En conclusion
Nous verrons plus loin, lorsque nous étudierons le déchiffrement que l’on peut corriger facilement jusqu’à t erreurs. C’est
donc la valeur que l’on doit rendre publique avec la matrice G’.
On notera également que c’est seulement lors de la génération de G que l’on peut déterminer le paramètre k. Ainsi, il est
nécessaire de construire G avant de construire S.
CELA DIT, REPRENONS L’EXEMPLE PRECEDENT ET CONSTRUISONS S ET P.
ON PEUT PAR EXEMPLE CHOISIR
0
1

0
S  1
1
1
1

1 0 0 0 0 0


0

0
1
1

1
0 0 0 0 1 1
1 1 0 0 0
0 0 0 0 1
0 0 0 1 0
1 1 1 0 1
1 1 0 1 1
ET POUR P LA MATRICE DE PERMUTATION ASSOCIEE A (3,11,4,6,13,5,14,2,10,9,12,7,8,1,15).
ALICE PUBLIE
0
1

0
G'   1
0
1
1

0 0 1 1 1 0 0 1 0 1 0 0 0 0


0

0
1
1

1
0 1 1 1 0 0 0 1 0 1 1 1 0 1
0 0 0 1 0 0 0 1 0 1 1 1 1
1 1 1 1 0 0 0 1 1 1 0 1 1
1 1 1 1 0 0 1 0 1 1 1 0 0
1 1 1 1 1 1 0 0 0 0 0 1 1
0 1 1 1 0 0 1 0 1 0 0 1 0
ET t=1.
Il ne reste plus qu’à vérifier que G’ n’a pas une tête trop sympathique, mais là il n’existe pas, à notre connaissance, de
veritables critères (car il peut toujours exister un cas facile que l’on n’a pas encore étudié).
3) Le chiffrement
Le chiffrement est facile à mettre en œuvre : il s’agit tout d’abord de mettre son message sous forme d’une suite de bits.
Ensuite, on découpe celui-ci en blocs de k bits. On multiplie chacun d’eux par la matrice G’ qui est publique et on ajoute au
résultat obtenu un vecteur d’erreur aléatoire de poids inférieur à la valeur publiée. On met alors bout à bout tous les blocs de n
bits obtenus pour obtenir le message chiffré à transmettre.
SUPPOSONS QUE BOB VEUILLE ENVOYER A ALICE LE MESSAGE SECRET
m = (1,0,1,0,1,1,0).
IL CALCULE ALORS LE PRODUIT m.G’ (TOUJOURS DANS F2). IL OBTIENT
c = m.G’ = (1,0,0,1,0,0,1,1,0,1,1,0,0,0,0).
IL CHOISIT UN VECTEUR D’ERREUR DE POIDS INFERIEUR OU EGAL A 1. PAR EXEMPLE,
e = (0,0,0,0,0,0,0,0,0,0,1,0,0,0,0).
IL ENVOIE ENSUITE LE MESSAGE C’ A ALICE.
c’ = c + e = (1,0,0,1,0,0,1,1,0,1,0,0,0,0,0).
La procédure 4 présentée en Annexes permet de chiffrer un message. On notera le parallélisme entre les procédures de
construction d’un vecteur d’erreur aléatoire et d’une matrice de permutation aléatoire.
4) Le déchiffrement
 désigne toujours l’élément primitif de F2 r choisi lors que la construction de la matrice G.
Tout d’abord, précisons que si p=(p0, …, pd), on notera P X  
d
p X
i 0
i
i
de telle sorte que p représente les coordonnées
de P dans la base canonique. D’autre part, on gardera les notations employées dans le paragraphe précédent. Le déchiffrement
se décompose alors en quatre étapes.
En premier lieu, on calcule r '  c'.P
syndrome :
1
 m.S .G  e.P 1  r  e' puis le polynôme suivant, appelé polynôme
2t
 
S Z    R'  i .Z i 1
i 1
Page 5
Cryptographie – Chiffre de McEliece
ALICE RECOIT LE MESSAGE ENVOYE PAR BOB ET CALCULE r’=(0,0,1,0,0,0,0,0,1,0,0,1,1,1,0).
R'  X   X 2  X 8  X 11  X 12  X 13
2
3
2
PUIS ELLE CALCULE ENSUITE S Z     1       .Z (VOIR ANNEXE 5)
ELLE DETERMINE ALORS

 

On applique alors l’algorithme d’Euclide étendu aux polynômes Z2t et S(Z) mais on s’arrête non pas au dernier reste non
nul mais au premier reste de degré strictement inférieur à t. On obtient ainsi l’égalité :
degRi 1   t
Ri Z   Ai Z .Z 2t  Bi Z .S Z  avec 
degRi   t
ICI t=1. L’ALGORITHME D’EUCLIDE ETENDU DONNE (VOIR ANNEXE 5) :
Quotient

Reste
Z2

    1.Z  
    1
D’OU ON TIRE L’EGALITE SUIVANTE :     1  Z
3


Coefficient en Z 2
1
Coefficient en S Z 
0
0
1
  2   .Z   2  1
3
2
3
3
2


1


3

   1 .Z   2
  3    1 Z   2 .S Z  .
Notons maintenant  le nombre d’erreurs contenues dans le message. On a par hypothèse   t.
E'X  
Définissons alors les (rj) par l’égalité suivante :
iii) On a alors la relation suivante : Zéros
Bi   

X
j 1
nr j
,1 j  
rj
.

Ainsi, ayant calculé le polynôme Bi, on trouve facilement les (rj) simplement en essayant successivement toutes les
puissances de .
POUR NOTRE EXEMPLE, ALICE CALCULE (VOIR ANNEXE 5) :
m
 
Bi 
m
m
Bi 
m
 
4
2
3

 1
6
1
7
  2 1
3
2
5
 
 
3
m
1
3
8
2
9
 
    
 
12
13
 1
 1
Bi 
m
m
Bi 
m
3
2
3
3
2
10
11
  1
  1
2
3
14
15
0
  2  1
3
AINSI LE COEFFICIENT ERRONE EST CELUI DU MONOME EN X.
ALICE RETROUVE AINSI R X   X  X  X  X  X  X
ALICE AURAIT BIEN SUR DU S’ARRETER LORSQU’ELLE A DECOUVERT LA RACINE PARCE QU'ELLE SAIT QUE LE MESSAGE
ENVOYE RENFERME UNE UNIQUE ERREUR ET EVITER AINSI LE CALCUL DE BI(15).
2
8
11
12
13
On effectue finalement la division exacte de R par At. Le quotient de cette division est le vecteur de coordonnées m.S.
Comme on connaît l’inverse de S, on détermine facilement m.
Remarquons toutefois que si on a calculé auparavant le quotient Ct de la division exacte de (Xn + 1) par At, on a
alors : R
 X .Ct  X   R X  .Ct  X . At  X   R X  .X n  R X 
At  X 
At  X 
At  X 
et
R
deg
 At

  k . Donc, le quotient de la

division exacte de R par At s’obtient plus simplement en ne gardant dans le produit de R par Ct que les monômes de degré
strictement inférieur à k.
On notera que le fait que l’on puisse retrouver le message initial et donc que l’on puisse corriger t erreurs prouve que la
distance minimale du code engendré par G’ est supérieure ou égale à (2t+1).
Page 6
Cryptographie – Chiffre de McEliece
X 15  1
1 X  X 3  X 7 .
1 X  X 2  X 4  X 8
R X .C  X   X  X 3  X 4  X 5  ...
ON SUPPOSE QU’ALICE A PREALABLEMENT CALCULE
CX  
AINSI, ELLE CALCULE
D’OU ELLE TROUVE m.S = (0,1,0,1,1,1,0) ET PUIS m = (1,0,1,0,1,1,0), CE QUI EST BIEN LE MESSAGE ORIGINAL ENVOYE
PAR BOB.
La procédure 5 présentée en Annexes permet de déchiffrer un message reçu.
III. Sûreté du système de McEliece
Dans tout ce chapitre, nous poserons E=F2n et F désignera le code engendré par la matrice publique G’.
Pour Oscar, le problème est le suivant : il connaît G’ et le message chiffré c’ qu’il a intercepté et il doit trouver le couple
c'  m.G 'e
.
we   t
(m,e) qui vérifie : 
La méthode de déchiffrement a prouvé l’existence et l’unicité de ce couple mais comment peut-on faire pour le
déterminer ?
5) Une première attaque

Un peu d’algèbre linéaire
x y  X .t Y (dans F2) où X et Y
Définissons tout d’abord sur E, ce qui pourrait s’apparenter à un produit scalaire par :
sont les coordonnées respectives de x et de y dans la base canonique (attention, on transpose !).
On dit, toujours par analogie, que x et y sont orthogonaux si
x y  0 et on note x  y .
Nous insistons bien sur le fait que ceci n’est pas un véritable produit scalaire. Par exemple le fait que x soit orthogonal à
lui-même ne veut pas dire qu’il est nul mais seulement qu’il est de poids pair.
On note ensuite si G est un sous-espace vectoriel de E :
iv)
G   x  E / y  G, x  y .

On a alors la propriété suivante : G est un sous-espace vectoriel de E de codimension la dimension de G. De là découle
F 
 
F.

Définissons alors la matrice H en écrivant en ligne les vecteurs d’une base de F . On a alors :
x. H  0  x est orthogonal à toute une base de F   x  F 
 


F
On dispose ainsi d’un test permettant de reconnaître si x est un élément du code. La quantité x. H s’appelle le syndrome
t
t
de x (on notera qu’il dépend de H, mais sa nullité n’en dépend pas).

Détermination de H
G’ est par hypothèse de rang maximal. Donc on peut trouver k colonnes qui forment une famille libre. Autrement dit, on
peut trouver M une matrice de permutation (voir Annexe 7) telle que : G'.M  G1 G2 où G1 est une matrice inversible de
taille (k,k) et G2 une matrice quelconque de taille (k,n-k).

Posons alors H

 G
t
1
1
.G2



Id nk .t M et vérifions que H ainsi définie convient. Notons que l’inversion de la
matrice G1 est une opération relativement rapide (voir Annexe 7).
La présence de la matrice identité d’ordre (n-k) prouve que les vecteurs ligne forment une famille libre. D’autre part, ils

sont au nombre de (n-k). Il ne reste donc plus qu’à s’assurer qu’ils appartiennent tous à F .
Pour cela, calculons G '. H  G1
t
 G 1 .G 2 
  G1 .G1 1 .G 2  G 2  2.G 2  0 , ce qui assure le
G 2 .M 1 .M  1

 Id n  k 
résultat annoncé
POUR NOTRE EXEMPLE, OSCAR PEUT PARVENIR A :
Page 7
Cryptographie – Chiffre de McEliece
0
1

0
0
H 
0
0
0
0

0
0
0
1
0
0
1
0
1
0
1
0
1
0
1
1
0
1
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
1
1
0
1
1
1
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
1
1
1
1
1
1
0
0
1
1
0
0
1
0
0
0
0
1
0
1
1
0
0

0

0

0
0
1
0 1 0 0 0 0 1 1 0 1 1 0 1 0

0 1 1 0 1 1 0 0 0 0 0 0 0 0
REMARQUONS QUE OSCAR NE DOIT EFFECTUER CE TRAVAIL SEULEMENT LORSQUE ALICE PUBLIE LA MATRICE G’ ET PAS A
CHAQUE FOIS QU’IL VEUT DECHIFFRER UN MESSAGE.

Algorithme d’attaque
t
On raisonne sur les valeurs que peut prendre le vecteur d’erreur. Il y en a
C
i 0
i
n
. On a en général une approximation
t
suffisante de ce nombre en prenant la valeur C n .
On dresse alors un tableau où l’on met en correspondance tous les vecteurs d’erreur possibles et leur syndrome. Cette
opération ne doit être effectuée, comme la précédente, qu’une seule fois.
OSCAR DRESSE ALORS LE TABLEAU SUIVANT (A COMPLETER) :
Vecteur d ' erreur
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
Syndrome
0 0 0 0 0 0 0 0
1 0 1 1 1 1 1 0
0 0 0 0 0 1 0 0
CE TABLEAU COMPTE NORMALEMENT 16 LIGNES.
Lorsque l’on intercepte le message chiffré, on calcule alors son syndrome. Le vecteur d’erreur est le seul élément en
correspondance dans le tableau précédent avec le syndrome calculé. On retrouve alors le message clair.
En effet, on a par hypothèse c'  m.G'e d’où c’ et e ont le même syndrome car m.G’ est un mot du code. Il reste à voir
que deux vecteurs d’erreur distincts ont des syndromes distincts. Mais, si tel n’était pas le cas, alors la différence de ces deux
vecteurs aurait un syndrome nul et serait donc un mot du code. Seulement, le poids de cette différence serait inférieur à (2t),
mais on a vu que la distance minimale du code est supérieure à (2t+1), ce qui est contradictoire. Ceci fonde l’algorithme
proposé.
LORSQUE OSCAR INTERCEPTE C’ = (1,0,0,1,0,0,1,1,0,1,0,0,0,0,0), IL CALCULE SON SYNDROME.
IL TROUVE ALORS c'. H  1 0 1 1 1 1 1 0
IL CHERCHE ENSUITE DANS LE TABLEAU LE VECTEUR D’ERREUR CORRESPONDANT, AINSI IL OBTIENT LE MESSAGE
CORRIGE : C = (1,0,0,1,0,0,1,1,0,1,1,0,0,0,0).
t
IL PEUT ALORS ECRIRE : m.G'  m.G1
D’OU IL TROUVE m  C1 .M .G1

1

G2 .M 1  m.G1 .M 1

m.G2 .M 1  c  C1
C2 
 1 0 1 0 1 1 0 , CE QUI EST BIEN LE MESSAGE CLAIR.
En conclusion
On a pu remarquer sur l’exemple précédent que cet algorithme est très efficace pour de petits codes (c’est à dire pour des
valeurs de n et de t suffisamment petites).
Cependant dans la pratique les valeurs de n et de t sont suffisamment grandes. Supposons, ce qui est plus raisonnable (ce
sont les quantités suggérées par McEliece), que n=1024 et que t=50. Alors, le nombre de vecteurs d’erreur possibles est
86
monstrueux, de l’ordre de 10 . Ainsi, le calcul de tous les éléments du tableau de déchiffrement serait pratiquement
impossible, car trop long, et le stockage de toutes ces informations demanderait beaucoup plus de mémoire que ne peuvent en
contenir un milliard de milliards de disques durs de 10 Gigaoctets.
On peut essayer de fixer une limite raisonnable : cette approche devient totalement impraticable dès que l’on choisit n
supérieur à 150.
Page 8
Cryptographie – Chiffre de McEliece
6) Une méthode probabiliste
Nous allons présenter ci-dessous l’algorithme d’attaque  :
1. (Voir Annexe 7) On permute les colonnes de G’ pour obtenir la matrice
G0  G1
2.
inversible de taille k. On sait que cela est possible car G’ est de rang maximal.
On effectue la même permutation sur le message capté c’ et on obtient c0 '  c1 '
3.
On calcule le produit T  G1 .G ' .
4.
G2  où G1 est une matrice
c 2 ' .
1
Pour chaque vecteur d’erreur e de longueur k et de poids inférieur à , on calcule la quantité suivante :
e'  c0 'e.T  r ' . Si le poids de ce vecteur est inférieur ou égal à t, alors le message clair est donné par
m  c0 'e.G1 .
1
5.
Si aucun succès n’a été rencontré, on recommence à l’étape 1 (avec une autre permutation).
Remarquons tout de suite que la méthode précédente est le cas particulier un peu amélioré où l’on prendrait =t. Nous
verrons plus loin que c’est un très mauvais choix.
Vérifions maintenant, le résultat énoncé à l’étape 4. Les égalités écrites fournissent
avons vu que cette décomposition est unique, ce qui permet de conclure.
c'  m.G'e' avec we'  t . Or nous
Nous allons essayer de déterminer la vitesse de cet algorithme en fonction de . Pour cela, appelons
à une vérification (c’est-à-dire à l’étape 4 en ne considérant qu’un vecteur d’erreur) et
étapes 1, 2 et 3. On pourra considérer l’étape 5 comme très rapide.
i 0
i
k
d’où on en déduit le temps nécessaire pour effectuer

C
un cycle : T  t 2  t1 .
t 2 le temps nécessaire à l’exécution des

C
Le temps nécessaire pour exécuter l’étape 4 vaut alors T1  t1.
t1 le temps nécessaire
i 0
i
k
.
Calculons le nombre moyen de cycles que l’on va devoir effectuer avant de réussir. Il est clair que la réussite passe par un
choix judicieux de la permutation. Pour être plus clair, l’algorithme réussit si et seulement si les k bits retenus dans le vecteur
c1 ' contiennent moins de  erreurs. Déterminons alors la probabilité de cet événement (en considérant que le fait que l’on ne
tire que des groupes de colonnes indépendantes n’influence pas le résultat).
Nous allons supposer en outre pour simplifier les calculs que le message intercepté contient exactement t erreurs, ce qui est
le cas le plus défavorable pour cet algorithme probabiliste.
k
Le nombre de tirages de k bits parmi n bits vaut : C n .
i
k i
Le nombre de tirages contenant exactement i erreurs est donné par : C t .C n t .

 C .C
On en déduit que la probabilité recherchée vaut :
i 0
i
t
k i
n t
. On peut montrer alors que dans ces conditions (voir Annexe
Cnk
1) le nombre moyen de tirages est égal à l’inverse de la probabilité, soit :
m  

Cnk
 C .C
i 0
i
t
k i
n t
Finalement le temps d’exécution moyen de l’algorithme vaut :
    m .T 
C nk

 C .C
i 0
i
t
k i
n t



. t 2  t1 . C ki 
i 0


Essayons alors de déterminer une relation entre t1 et t2. Pour cela, on appellera opération toute addition, multiplication ou
comparaison entre deux bits.
Précisons également que dans les calculs qui vont être faits, nous ne garderons à chaque fois que le terme dominant dans un
souci de simplification.
Page 9
Cryptographie – Chiffre de McEliece
On peut montrer (voir Annexe 7) que l’étape 1 nécessite environ
rapides. Il est facile de voir que l’étape 3, demande environ 2.n.k
opérations. Ainsi on peut raisonnablement penser que :
2
k 2 .4.n  k  opérations. Les étapes 2 et 5 sont très
opérations. De même l’étape 4 requiert environ
2.n.k
t 2 k 2 .4.n  k   2.n.k 2
k2

 3.k 
t1
2.n.k
2.n
Donc le temps d’exécution s’écrit
    K .
3.k 


k2
 . Cki
2.n i  0
 C .C
i 0
i
t
où K est une constante positive ne dépendant pas de .
k i
n t
On peut alors chercher à optimiser ce temps.
Prenons maintenant des valeurs numériques. Comme l’a suggéré McEliece, testons la rapidité de notre algorithme avec
n=1024, k=534 et t=50. La fonction définie n’étant pas spécialement facile à étudier, construisons plutôt le tableau suivant :

0
1
2
3
5
10
50






log 10 
 287,16  288,81  288,48  287,52  285,55  280,47  236,05
K 

On constate que l’algorithme le plus rapide correspond à =1.
Toutefois, si l’on calcule le nombre d’opérations nécessaires à son exécution, on trouve un nombre encore beaucoup trop
23
grand, de l’ordre de 10 .
On peut également ici essayer de fixer une limite raisonnable : pour n inférieur à 400, cet algorithme d’attaque est
relativement adapté mais pour des valeurs de n beaucoup plus grandes, il devient extrêmement lent (tout en restant quand
même plus rapide que la première méthode présentée).
7) En conclusion
On a pu constater qu’il est difficile de casser le système de chiffrement de McEliece dès que Alice choisit pour n des
valeurs supérieures à 500 (pour être tranquille). Cela signifie-t-il pour autant que ce système de chiffrement est sûr ?
En fait, pratiquement tous les systèmes de chiffrement deviennent « incassables », dès que la longueur de la clé est
suffisamment importante. Le chiffre de Vigenère, par exemple, est totalement sûr si l’on choisit une clé aussi longue que le
message, retrouvant ainsi le chiffre de Vernan. Et c’est pourtant un système cryptographique assez primitif.
Or le système de McEliece n’est sûr que si l’on choisit une clé de plus de cent mille bits, ce qui est énorme (voir Annexe
11). Donc, bien que l’on n’ait pas encore trouvé d’algorithme qui permette de casser McEliece à coup sûr, la remarque
précédente suffit à se convaincre que l’on a ici affaire à un système d’une sûreté toute relative.
Pour finir, faisons la remarque suivante. Une attaque qui serait basée sur la recherche de S et de P (comme ils sont définis
dans la présentation du système de McEliece) se heurtera très vite au problème de la reconnaissance d’une matrice
sympathique. En effet, comme nous l’avons déjà évoqué, il existe plusieurs classes de matrices sympathiques : nous avons
utilisé la classe BCH, McEliece suggérait la classe de Goppa mais rien ne peut empêcher une Alice malicieuse de choisir une
matrice sympathique d’un autre genre, relative par exemple à un code de Golay. Il n’est donc finalement pas très intéressant de
poursuivre dans cette direction.
Comme nous l’avons déjà signalé, le système cryptographique de McEliece a pris naissance à une époque où la
cryptographie connaissait un bouleversement avec l’apparition de la clé publique. Quelques autres systèmes qui reprennent
l’idée d’utiliser un cas particulier simple d’un problème complexe et de le déguiser sont à mettre en parallèle avec le système
cryptographique de McEliece. Citons par exemple le chiffre de Merkle-Hellman qui met à profit le problème du sac à dos qui
est le suivant : étant donnés un sac à dos de volume donné et divers objets dont on connaît également le volume, est-il possible
(et si oui, comment) de remplir exactement le sac à dos. Toutefois, le système cryptographique proposé par Merkle-Hellman
est loin d’être sûr puisque l’on connaît aujourd’hui des méthodes d’attaque permettant de le casser quelle que soit la longueur
de la clé utilisée. A côté de cela, le chiffrement RSA par exemple ne résulte pas de la particularisation d’un problème difficile.
Contrairement aux systèmes précédents, pour déchiffrer RSA il faut connaître absolument la clé de déchiffrement et il n’y a
pas d’autre moyen (ce qui faisait en partie la faiblesse des systèmes précédents, ce qu’il était tout à fait possible de casser le
chiffre sans chercher à déterminer cette clé simplement en essayant de résoudre le problème général). Signalons quand même
que l’affirmation précédente est en réalité une conjecture mais qui semble convaincre tout le monde. Concrètement, la clé de
déchiffrement se compose de deux nombres premiers aléatoires d’une soixantaine de chiffres et la clé de chiffrement n’est
autre que le produit de ces deux nombres. Ainsi la sécurité de RSA repose sur la difficulté pratique que l’on a à factoriser un
nombre de plus de cent cinquante chiffres (voir Annexe 8). En conclusion, l’expérience semble montrer que cette seconde
approche conduit à des systèmes plus sûrs : le chiffrement RSA est de nos jours largement répandu.
Page 10
Cryptographie – Chiffre de McEliece
ANNEXeS
1. Nombre moyen de tirages avant de trouver une matrice inversible
Fixons pour le moment un entier k strictement positif et calculons la probabilité de tomber sur une matrice inversible
lorsque l’on génère une matrice a priori quelconque à coefficients dans F 2.
k2
Pour cela, dénombrons les matrices de taille (k,k) : il y en a bien sûr 2 .
Pour dénombrer les matrices inversibles de taille (k,k), il faut remarquer qu’à chacune d’entre elles correspond une et une
unique base de F2k. Il s’agit donc de dénombrer les bases de F2k.
Pour que la famille  x1 ,..., x k  soit une base, il faut et il suffit que :
x p  Vect x1 ,..., x p 1 .
p  1,2,..., k ,
On a d’autre part
et Card Vect x1 ,..., x p 1   2 p 1 .
Card F2k  2 k
 2
k
On en déduit que le nombre de matrices inversibles est
k
 2 p 1 .
p 1
Ainsi, la probabilité de tomber sur une matrice inversible vaut :
 2
k
k
 2 p 1
p 1
uk 
2k
2

k
1  k 
1 

  1  k  p 1   1  p 
2
2 
 p 1 
p 1 

Calculons alors le nombre moyen de tirages à effectuer défini par
t k   1  u k 
m 1
m 1
.u k .m
Or après dérivation justifiée par une convergence normale sur tout compact de la fonction dérivée, on a le résultat suivant :

x   1,1,
 m.x m1 
m 1
Donc il vient
tk 
Posons maintenant
uk
1  1  u k 
2

1
uk
car
d   m d  x 
1
 x   

dx  m 1  dx  1  x  1  x 2
on a 1  u k    1,1
k
1 

v k  ln u k    ln 1  p  . On a alors la minoration suivante :
 2 
p 1
 1
x  0, , ln 1  x   2. ln 2.x (par concavité de la fonction)
 2

2. ln 2
1
D’où, il vient k  N , v k   




ln
2
   2. ln 2

p
2
p 1
p 0  2 
1
1
et donc
 tk  4
Et finalement k  N , u k 
4
uk
p
k
Le nombre moyen de tirages est donc inférieur à quatre.
On notera que l’on a démontré au passage le résultat suivant que l’on réutilisera plus loin : si lors d’un tirage aléatoire, p
désigne la probabilité pour que l’objet tiré convienne, alors le nombre moyen de tirages avant de tomber sur un objet adéquat
vaut
1 .
p
2. Construction des corps finis
On considère K un corps fini commutatif de caractéristique 2.
On a alors les règles de calcul suivantes :
x  K , x  x  x.1  1  0 ou encore x   x
x, y   K 2 ,
x  y 2  x 2  2.x. y  y 2  x 2  y 2
Page 11
Cryptographie – Chiffre de McEliece
On en déduit, par une récurrence immédiate, que :
x, y  K 2 , r  N ,

 x  y 2
r
 x2  y2
r
r
Extension algébrique
On considère désormais un polynôme P à coefficients dans K et irréductible dans K.
On définit la relation binaire suivante :
Q, R   K X  ,
Q  R   P divise Q  R 
2
Cette relation est une relation d’équivalence et on notera
Nous allons montrer que
K X 
P
K X 
P
son ensemble quotient.
peut être muni d’une structure de corps qui prolonge celle de K.
Q  Q'
Q  R   Q' R'
permet de définir l’addition et la
 
 R  R'
Q.R   Q'.R'
La fait que l’on ait l’implication suivante : 
multiplication dans
K X  .
P
L’associativité, la commutativité, l’existence d’éléments neutres et d’un opposé sont des propriétés immédiates. Le seul
point délicat est l’inversibilité de tout élément non nul.
Soit alors
Q  K X 
P
tel que
Q  0 (ie Q n’est pas un multiple de P). Comme P est irréductible, P et Q sont alors
premiers entre eux. Le théorème de Bezout permet d’écrire :
2
 U , V   K X  / U  X .P X   V  X .Q X   1 et donc V .Q  1
K X  , ,   est bien un corps.
Donc Q est inversible et K '  

P


Finalement, remarquons qu’il s’agit encore d’un corps commutatif de caractéristique 2 et que le sous-corps de K1 formé des
polynômes constants est isomorphe à K (ainsi K1 prolonge bien K).
D’autre part si K compte n éléments alors K’ en dénombre n
deg  P 
.
Enfin, notons   X . On a évidemment P divise P et donc si on considère P comme polynôme à coefficients dans K’, il
vient P()=0 et donc  P1  K ' X  / P X    X   .P1  X  .

Construction
Prenons maintenant un entier strictement positif r et K=F2.
 
n 1
Posons alors n = 2r - 1 et P X  X  X  X
X.
Nous allons montrer par récurrence qu’il existe un sur-corps K’ de K tel que P soit scindé dans K’
2r
L’hypothèse de récurrence est la suivante :
HR i  :  K i surcorps de K et  0 ,..., i   K i

i 1
i
et Q  K i X  / P X   Q.  X   k 
k 0

On a P X   X . X  1 , ce qui initialise notre récurrence.
Si on suppose HR(i-1), pour i compris entre 1 et n, alors le polynôme Q est de degré supérieur ou égal à 1. On peut donc
trouver un polynôme irréductible Q0 divisant Q. Le résultat de l’extension algébrique prouve alors HR(i) et donc l’hérédité.
Le résultat annoncé correspond à HR(n) et est donc démontré.
n
Considérons maintenant l’ensemble suivant : F2r


 x  K ' / x n1  x . Il s’agit d’un sous-corps de K’ de cardinal 2r.
En effet, on a bien F2 r  . De plus, si x et y sont des éléments de F2 r , alors, comme K’ est commutatif et de
caractéristique 2, les règles de calcul permettent d’écrire :
 x  y 2
r
 x  y   x 2  y 2  x  y  x  y et x. y   x 2 . y 2  x. y
2r
r
r
2r
r
r
Page 12
Cryptographie – Chiffre de McEliece
 
D’autre part y. y
r
1 2
 
2r
 y 2 . y 1
r

 y. y 1

2r
 
 1 d’où y 1
2r
 y 1 .
Finalement F2 r est bien un sous-corps de K’.
P'  X   2 r . X n  1  1 . On en déduit que P’ ne s’annule
pas et donc les racines de P sont simples. Comme P est scindé dans K’, il en a 2 r, ce qui revient à dire que F2 r est bien de
Reste à montrer qu’il est de cardinal 2 r. Pour cela, calculons
cardinal 2r.
Finalement, on a bien construit un corps de cardinal 2 r (qui existe donc). On peut montrer en outre que ce corps est unique à
un isomorphisme près, ce qui justifie la notation F2 r .
On peut remarquer enfin que l’on a montré que F2 r est un corps de caractéristique 2.
3. Trouver  un élément primitif
r désigne toujours un entier strictement positif et on a n = 2r – 1. On désigne par F2 r le corps fini à 2r éléments (voir
*
Annexe 2) et par F2r ce corps privé de l’élément nul. On se propose dans un premier temps de démontrer que
F , est un
*
2r
groupe cyclique.
Remarquons tout d’abord que
Notons alors

n  p1 1 ... pd
F , est un groupe fini de cardinal n.
*
2r
d
où les pi sont des nombres premiers deux à deux distincts et les i sont des entiers
strictement positifs.
Soit
i  1,2,..., d . Posons P X   X pi  1 . On a alors P'  X   p i i . X
i

Or n est un nombre impair, car il précède un nombre pair, donc p i
i
pi  i 1
.
aussi.
Comme F2 r est de caractéristique 2 (voir Annexe 2), on en déduit que P'
X   X p
i
i
1
.
D’où P’ n’admet que 0 comme racine et donc les racines de P sont toutes simples.

Il vient alors Card x  F2 r / x
*
pi  i



 1  p i i . Et de même Card x  F2*r / x pi
 i 1

 1  pi
 i 1
.
 x pi i  1
i
d’où on en déduit que :  x i  F / 
.
 i 1
 x i pi  1

Or on a
pi
i
 pi
 i 1
*
2r
Autrement dit, pour tout i, il existe un élément xi d’ordre p i
i
.
Le produit de tous les xi fournit alors un élément d’ordre n, ce qui prouve que
Les éléments qui engendrent
F , est un groupe cyclique
*
2r
F , sont appelés les éléments primitifs.
*
2r
Comment déterminer un élément primitif quelconque ? Une première idée consiste à générer un élément aléatoire et à
vérifier s’il est primitif. S’il ne l’est pas, on recommence le procédé jusqu’à réussite. Vérifions si cet algorithme est acceptable.
Pour cela, il faut dénombrer le nombre d’éléments primitifs. Or si  est l’un d’entre eux, on peut écrire :


F2*r  1,  ,  2 ,...,  n1 et ordre ( i ) 
n
.
PGCD(n, i )
Ainsi, il y a autant d’éléments primitifs que de nombres à la fois inférieurs à n et premiers avec n. La fonction indicatrice
d’Euler que l’on note  calcule ce nombre et on a la relation suivante :
Si

n  p1 1 ... p d
d
d

1 
Alors  n   n. 1  
pi 
i 1 
On en déduit (voir Annexe 1) que le nombre moyen de tirages à effectuer est donné par :
Page 13
Cryptographie – Chiffre de McEliece
tn 
1
d

i 1

1 

i 
 1  p

1
 p  est une série divergente, ce qui assure que la suite (tn) prend
 p premier


Or un résultat d’analyse prouve que 
malheureusement des valeurs aussi grandes que l’on veut lorsque n décrit l’ensemble des entiers naturels. Toutefois, on peut
regarder les valeurs prises par tn lorsque r est compris entre 1 et 15 (ce qui regroupe largement toutes les applications
pratiques).
r
n
tn
r
n
1
1
1,000
6
63
2
3
1,500
7
3
7
1,167
4 15 1,875
tn
r
n
tn
1,750 11
2047
1,057
127
1,008 12
4095
2,370
8
255
1,992 13
8191
1,000
9
511
1,183 14 16383 1,548
5 31 1,033 10 1023 1,705 15 32767 1,214
Les résultats obtenus sont rassurants. Pour se convaincre pleinement, la procédure suivante écrite sous Maple prouve que
pour excéder le nombre de 10 tirages, il faut choisir r supérieur à 343.
minr :=
proc(emax)
local n,nb,e;
e := 1;
nb := 0;
n := 1;
while e < emax do n := nextprime(n); nb := evalf(nb+log(n));
e := evalf(e/(1-1/n)) od;
floor(nb/log(2))+1
end
Il reste à vérifier que tester si un élément est primitif est une opération rapide.
Supposons que l’on vienne de générer l’élément aléatoire . Il suffit, pour le tester, de calculer les exponentielles

n
pi
pour i allant de 1 à d et de vérifier que chacun des nombres calculés est différent de l’unité. Essayons alors de majorer d.
d est défini par

n  p1 1 ... pd
d
donc on en déduit que 2  n  p1 ... p d  2 et donc
r
d
d  r 1.
Notons que cette majoration est très grossière et qu’en général d est bien plus petit que cela. Toutefois, elle permet de
conclure que le nombre de calculs à effectuer est très réduit.
Enfin, on dispose d’algorithmes puissants pour effectuer une exponentielle (voir Annexe 5) donc l’algorithme proposé est
efficace.
Remarquons cependant que la détermination de la décomposition en facteurs premiers de n n’est pas toujours facile si n est
grand, mais dans la pratique n n’excède que très rarement 10 000.
4. Trouver P un polynôme irréductible de F2[X]
r désigne toujours un entier strictement positif et on a n = 2 r – 1. On désigne par F2 r le corps fini à 2r éléments (voir
X   X 2
Annexe 2). Appelons  un élément primitif de F2 r (voir Annexe 3) et considérons le polynôme suivant : P
P se décompose en produits de polynômes irréductibles sur F 2[X] de la façon suivante: P 
r
X.
P1 ...Pk . Or  annule P
donc  i / Pi    0 et par hypothèse Pi est un polynôme irréductible. Montrons que P i est un polynôme de degré r.
Page 14
Cryptographie – Chiffre de McEliece
Pour cela, notons
 
r '  degPi  et considérons K  F2 X
donc si on note encore   X , on a
(voir Annexe 2). Alors K est un corps de cardinal 2 r’ et
Pi
 2   , ce qui s’écrit également Pi divise X 2  X
r'
r'
 2   ou encore  2 1  1 , ce qui prouve que r '  r.
2
D’autre part, notons E  S  K / S  S . Par hypothèse   E
r'
déduit que
. Comme  annule Pi, on en
r'


r
multiplication. On en déduit que E  K , c’est à dire
primitif de K ne pourrait satisfaire à la condition).
On a bien démontré le résultat annoncé.
S  K , S
2r
et on a vu que E est stable par addition et par
 S . Ceci prouve que r '  r (car sinon un élément
Ainsi, on a prouvé que dans F2[X], il existe des polynômes irréductibles de tout degré. Comment peut-on les déterminer ?
On pourrait là encore générer des polynômes jusqu’à l’obtention d’un qui convient. Pour savoir si cette méthode est
raisonnable, il faut essayer de dénombrer les polynômes irréductibles de degré r.
On peut affiner le théorème précédent et montrer qu’en fait P est égal au produit de tous les polynômes irréductibles de
degré divisant r. Donc si on note (k) le nombre de polynômes irréductibles de degré k, on a l’égalité suivante obtenue en
raisonnant sur les degrés :
2 m   k. k 
k m
Ainsi, on en déduit que
m  N *, m. m  2 . Puis en réinjectant dans l’égalité précédente, il vient :
m
2 r  r. r    2 m  m. m  
mr
mr
2r  2
Donc il vient  r  
r
2
1 m 
m
 r. r   2
r 1
2
r
2
r 1
2
. Ainsi le nombre de tirages moyen est inférieur à
r
1 2
1 r
dès que r est supérieur à
2
3. En particulier pour r supérieur à 4, le nombre de tirages reste inférieur à (2r). Pour les valeurs de r inférieures à 3, on peut
vérifier que ce résultat reste vrai.
Comme les valeurs de r sont dans la pratique très petites, la méthode proposée est de ce point de vue efficace.
Il faut maintenant trouver un algorithme qui permette de tester assez rapidement si un polynôme donné R est irréductible ou
non. Pour cela, on aura besoin du résultat suivant : un polynôme de degré r est irréductible si et seulement s’il
divise X
2r
 X et s’il est premier avec tous les X 2
r
q
 X où q est un facteur premier de r.
En effet, si R est un polynôme irréductible de degré r alors on a vu qu’il divise X
2r
X.
r
Considérons maintenant q un facteur premier de r. Si R n’était pas premier avec
r
vu que tous les diviseurs de X
2
q
X2
q
 X , alors il le diviserait, mais on a
 X sont de degré inférieur à r , ce qui n’est pas le cas. On a ainsi la première
q
implication.
X 2  X et qui est premier avec tous les
r
Réciproquement, supposons que R soit un polynôme de degré r qui divise
r
 X où q est un facteur premier de r.
Si R n’était pas irréductible, alors on pourrait trouver un polynôme R 0 irréductible qui diviserait R et qui serait de degré d
X2
q
 X d’où on déduirait que d est un diviseur de r et puis un diviseur strict.
r
2 q
Mais alors on pourrait trouver q un facteur premier de r tel que d divise r , ce qui impliquerait que R0 divise X
X,
q
strictement inférieur à r. R0 diviserait alors X
2r
d’où la contradiction. Ainsi, on a bien démontré le théorème.
On peut alors proposer l’algorithme suivant :
Soit R un polynôme de degré r. On écrit tout d’abord

r  r1 1 ...rd
d
où les ri sont des nombres premiers deux à deux
distincts et les i sont des entiers strictement positifs. Cette opération est relativement rapide si r n’est pas trop grand.
Remarquons également qu’il n’est pas nécessaire de la répéter pour chaque polynôme R que l’on doit tester.
Page 15
Cryptographie – Chiffre de McEliece
2 ri
On calcule ensuite les Qi, reste de la division euclidienne de X par R. Il existe des algorithmes puissants (voir Annexe 5)
pour effectuer ces calculs et d’autre part on a d  r  1 (voir Annexe 3), donc relativement peu de divisions à effectuer. Ainsi
cette étape est globalement rapide.
On vérifie enfin si tous les polynômes Qi  X   X sont premiers avec R (simplement en appliquant l’algorithme
d’Euclide) et puis si X  X est un diviseur de R (en calculant le reste de la division euclidienne de X
précédent prouve que si c’est le cas R est irréductible, sinon il ne l’est pas.
2r
2r
par R). Le théorème
En conclusion, pour des valeurs de r par trop grandes (ce qui est en général le cas), on peut considérer que la méthode
proposée est très acceptable.
5. Calcul explicite dans un corps fini
Soit r un entier strictement positif et le corps fini de cardinal 2 r, F2 r (voir Annexe 2). Considérons d’autre part un
polynôme irréductible de degré r à coefficients dans F2 d’indéterminée  (voir Annexe 4). Alors F2 r est isomorphe à
K  
P
(voir Annexe 2). Nous allons donc considérer que les éléments de F2 r sont des polynômes réduits modulo P, l’addition et la
multiplication se définissent alors de façon naturelle.
CHOISISSONS PAR EXEMPLE r=4 ET
MEMOIRE)
ET CONSIDERONS X    
ON PEUT ALORS CALCULER :
3
P    4   3   2    1 (COMME C’EST EGALEMENT LE CAS DANS TOUT LE
   1 ET Y     2   .
 X  Y     3   2  1
 X .Y     5   4   3     2 P 
On remarquera que pour l’addition la réduction modulo P est déjà faite alors que pour une multiplication, il est nécessaire
de pratiquer une division euclidienne.

Calcul de l’inverse
Supposons que l’on veuille calculer l’inverse de X qui est non nul modulo P. Comme P est irréductible, X et P sont alors
premiers entre eux et l’algorithme d’Euclide permet alors de trouver des polynômes U et V qui vérifient P.U+X.V=1. Cette
égalité réduite modulo P prouve alors que V est l’inverse de X.
CONSIDERONS TOUJOURS LES MEMES PARAMETRES ET CALCULONS L’INVERSE DE L’ELEMENT X    
L’ALGORITHME D’EUCLIDE SE PRESENTE ALORS COMME SUIT :
Quotient

VERIFIONS EN CALCULANT X  . 

2
 1.
Reste
Coefficient en X  
2
    1
0
3
 1
1
2

 1
2
1
  1
4
 1

3
3

   1   5   4   3   2    1  1 P 
Calcul de puissances
Soit X un élément de F2 r et n un entier relatif. Une idée innocente pour calculer l’exponentielle modulaire X n serait la
suivante : si n est positif, on multiplie X par lui-même n fois, ce qui fournit le résultat, sinon, on calcule l’inverse de X (par
l’algorithme d’Euclide) que l’on multiplie par lui-même (-n) fois. Il est assez évident que cette méthode sera fort lente si n
atteint de trop grandes valeurs.
Si X est nul, le calcul est vite fait. On supposera donc par la suite X non nul. On sait qu’alors
X2
r
1
 1 . Ainsi, si on note
m le reste de la division euclidienne de n par (2 r-1), on a X  X et donc il suffit en fait de calculer Xm pour avoir le
résultat. L’intérêt est double. Tout d’abord, bien sûr, les valeurs prises par m sont relativement petites et donc le calcul pourra
n
m
Page 16
Cryptographie – Chiffre de McEliece
être accéléré. Mais également, m est par définition toujours positif, ainsi on a détourné le calcul de l’inverse si n était au départ
négatif.
Ecrivons ensuite m en base 2 : m 
2
i
. Le plus grand élément de  est alors
i
d  Elog 2 m  1  r . On calcule
alors, par élévations au carré successives, les quantités suivantes pour i allant de 0 à d : X i
 X 2 . Remarquons que le fait
i
que F2 r soit de caractéristique 2 et que donc on ait  x  y   x  y prouve qu’une élévation au carré est une opération
2
simple à effectuer. L’exponentielle cherchée est alors égale à X
2
n
2
  Xi .
i
Ce qui est encore plus intéressant, c’est que l’on peut effectuer de manière simple la décomposition en base 2 en même
temps que le calcul. En effet 0 est un élément de  veut simplement dire que m est impair, ce qui suggère l’algorithme suivant :
1. On affecte à m la valeur du reste de la division euclidienne de n par (2 r-1).
2. On affecte la valeur 1 à la variable RES (pour résultat).
3. On pose X0=X et i=0.
4. Si m est impair, on substitue à RES le produit de RES par Xi.
5. On calcule Xi+1=Xi2.
6. On ajoute 1 à i.
7. On enlève à m le dernier chiffre de son écriture binaire. Autrement dit, on remplace m par la partie entière de sa moitié.
8. Si m est non nul, on reprend à l’étape 4. Sinon, RES renferme le résultat de l’opération demandée
On obtient sous Maple, la procédure suivante où MULT est une procédure externe qui effectue la multiplication des
polynômes et la réduit modulo P.
puis := proc(p,n)
local res,c,m;
res := 1;
c := p;
m := mods(n,15);
while 0 < m do
if m mod 2 = 1 then res := mult(res,c) fi;
m := floor(1/2*m); c := mult(c,c)
od;
res
end
Pour effectuer cette méthode, il faut donc faire une division euclidienne, moins de r élévations au carré et moins de r
multiplications. Il s’agit donc d’une méthode rapide.
On remarquera finalement que pour (n=-1), on obtient ici une autre méthode du calcul de l’inverse plus rapide si r est grand
mais moins efficace si r est petit.
CALCULONS L’INVERSE DE L’ELEMENT X    
COMME r=4, IL S’AGIT EN FAIT DE CALCULER
X14
 1 AVEC CETTE NOUVELLE METHODE.
, ON ECRIT ALORS 14  2  4  8 . ON CALCULE ALORS :
X 0     3  1
3
X 1     6  1    1
X 2     2  1
X 3     4  1   3   2  
ON TROUVE ENFIN : X
1
 X 1 .X 2 .X 3   6   4   3     2    1 .
ON RETROUVE BIEN LE MEME RESULTAT.
6. Complexité de la méthode du pivot de Gauss
Comme les opérations vont s’effectuer dans le corps F2, nous allons considérer que l’addition, la multiplication et la
comparaison des nombres sont aussi rapides les unes que les autres. Ainsi, on ne dénombrera que le nombre d’opérations à
effectuer pour exécuter la méthode du pivot de Gauss.
Donnons-nous une matrice carrée M de taille n, inversible ou non.
Page 17
Cryptographie – Chiffre de McEliece
On cherche tout d’abord à construire une suite (P i) telle que l’on ait à chaque étape :
Pi  M i
N i  où

si 1  l  i et k  l , alors mk ,l   k ,l

1

 N i est inversible et M i .N i  M
On part de la position initiale P0
 M
I n .
Voyons comment on peut passer de Pi-1 à Pi pour i supérieur ou égal à 1.
Remarquons tout d’abord que permuter deux colonnes d’une matrice A ou remplacer une colonne de A par la somme
d’elle-même et d’une autre peut être fait au moyen de la multiplication à droite de A par une matrice inversible. Ainsi, on
pourra se contenter de faire des opérations sur les colonnes.
Ceci dit, posons M i 1  m k ,l et appelons C l les colonnes de M i 1 . L’algorithme est alors le suivant :


i  l 0  n
.
m i , l 0  1
On cherche un entier l0 (par la méthode exhaustive) vérifiant : 
Si aucun entier ne convient, alors les i premières lignes de
M i 1 sont liées et donc M i 1 n’est pas inversible, ce qui
prouve, par là même que M n’est pas inversible. Ainsi, on a terminé le test.
Si on a trouvé un entier convenable, on permute les colonnes C i et C l0 et on obtient ainsi une nouvelle matrice
M '  m' k ,l . Ensuite, pour l variant de (i+1) à n, on remplace la colonne C l par C i  C l si le coefficient m' i ,l est non nul
de sorte que l’on obtienne finalement une matrice
M i satisfaisant à la condition souhaitée.
 M i 1 .S où S est une matrice
inversible. Définissons alors N i par N i  N i 1 .S (ce qui revient à effectuer les mêmes opérations sur N i 1 que celles que
l’on a effectuées sur M i 1 ). Alors on a bien N i inversible, comme produit de deux matrices inversibles et la
On a vu que toutes ces opérations peuvent se résumer par l’écriture suivante : M i
relation : M i .N i
1
 M i 1 .S 
. N i 1 .S   M i 1 .N i 1  M
1
1
Si on est arrivé à construire P n, alors il est clair que M est une matrice inversible (car M n est inversible). Ainsi, on est à ce
moment capable de répondre à la question de l’inversibilité de M.
Comptons alors le nombre d’opérations maximum que l’on a du effectuer. Pour la i° étape, on a au plus :
 2. n  i  1 comparaisons




6.n opérations dues à la permutation des deux colonnes
2.n.n  i  additions
 2.n
n 1
Ainsi le nombre d’opérations est certainement majoré par
2


 8.n  2  2.n  2.i  n  4
3
i 0
Si on veut de plus calculer l’inverse de M dans le cas où il s’agit d’une matrice inversible, on élimine alors successivement
les 1 superflus de la matrice M n qui ne se trouvent pas sur la diagonale.
Pour cela, on procède encore par récurrence. Il s’agit de construire cette fois une suite Qi
 M ' i
N ' i  qui vérifierait

 Ai 0 
 où Ai est triangulai re in férieure
M ' i  

I
i




1
 N ' i est inversible et M ' i .N ' i  M
Le couple Q1  M n N n  qui convient permet d’initialiser la récurrence.
Supposons que l’on ait construit le couple Qi . Alors, en remplaçant successivement la (n-i)° colonne par la somme des (ni)° et k° colonne si le coefficient M ' i k , n  i est égal à 1, pour k variant de (n-i+1) à n, on obtient la matrice M ' i 1 . De même
que précédemment, on construit la matrice
N ' i 1 et on a ainsi l’hérédité de la récurrence.
Finalement la matrice M ' n nous donne l’inverse de M.
Comptons le nombre d’opérations que demande cet algorithme. Pour l’étape i, il faut au plus :
Page 18
Cryptographie – Chiffre de McEliece

i comparaisons

2.n.i
additions
n 1
Ainsi le nombre d’opérations pour cette étape est inférieur à
 i.2.n  1  n
3
.
i 1
Si on regroupe les deux résultats, on obtient le résultat suivant : le nombre d’opérations nécessaires pour tester si une
matrice est inversible et le cas échéant pour l’inverser est inférieur à 2.n  2  .
On remarque alors que l’algorithme du pivot de Gauss est raisonnablement rapide même lorsque n prend des valeurs
grandes.
3
Pour se convaincre de la rapidité de cet algorithme, évaluons le nombre d’opérations qu’il est nécessaire de faire pour
multiplier deux matrices carrées de taille n. Pour le calcul de chaque coefficient, il faut faire n multiplications et (n-1)
n 2 .2.n  1 qui est de l’ordre de grandeur du
additions. Comme il y a n2 coefficients à calculer, le nombre cherché vaut
nombre calculé pour l’inversion.
Ainsi lorsque les coefficients sont dans F2, inverser une matrice est presque aussi rapide que, par exemple, l’élever au
carré ! Signalons toutefois que le pivot de Gauss demande un effort de « gestion » assez important, ce qui ralentit quelque peu
le calcul.
7. Détermination de k colonnes indépendantes
Donnons-nous des entiers n et k vérifiant 1  k
 n et une matrice M de taille (k,n) de rang maximal. Notons Ci les
colonnes de M. Le problème est de trouver  1 ,...,  k  tel que la matrice C1 ... C k  soit inversible. Ce qui revient en
fait à chercher deux matrices G et H telles que G soit une matrice inversible de taille k et que la juxtaposition de G et de H
fournisse une permutation des colonnes de M.
Nous allons présenter un algorithme permettant d’arriver au résultat. Nous insistons sur le fait qu’il s’inspire grandement de
l’algorithme du pivot de Gauss présenté précédemment. C’est pourquoi nous l’appellerons algorithme du pivot de Gauss
étendu.


On se donne tout d’abord  une permutation de l’ensemble 1,..., n , que l’on peut facilement générer comme nous
l’avons décrit dans le mémoire.
Nous allons alors construire G et H.
Pour cela, on construit par récurrence une suite u p  G p , A p , S p , H p vérifiant les conditions suivantes :


S p  GLk F2 

Si l  m, alors A p l , m  0
S .G  A
 p p
p

rang G p   rang C 1 ... C  p  
G est de rang maximal et ses colonnes sont indépendan tes
 p
G p H p   C 1 ... C  p   à une permutation des colonnes près

On initialise la récurrence en posant u 0   ,  , I k ,   (qui convient).
Examinons maintenant l’hérédité de la récurrence. Supposons que l’on ait réussi à construire u p
1  p  n  1
et
considérons alors la matrice C  S p .C  p 1 (que l’on calcule dans la pratique).
Appelons L le nombre de colonnes de Gp.
L  1  l 0  k
.
C l0  1
On cherche alors par la méthode exhaustive un entier l0 vérifiant : 

Deux cas se présentent alors. Si l’on n’a trouvé aucun entier convenable, alors la matrice A p

maximal. L’inversibilité de Sp, l’égalité A p
C   S p .G p
C  n’est pas de rang
C  p 1  et le fait que Gp soit de rang maximal prouvent que
Page 19
Cryptographie – Chiffre de McEliece
rang C 1
... C  p 1   rang G p   rang C 1
G p 1  G p ; A p 1  A p ; S p 1  S p ; H p 1  H p
... C  p   . Ainsi l’on peut définir up+1 de la façon suivante :
C  p 1 .

Si l’on est parvenu à trouver un l0 convenable, posons A  A p
C  et permutons dans A les lignes l0 et (L+1) pour
obtenir la matrice A’. On élimine ensuite les 1 superflus de la dernière colonne en additionnant, si besoin est, avec la ligne
(L+1). Autrement dit, pour tout l  L  1 , on effectue la substitution Ll  Ll  L L 1 si et seulement si  A'l , L 1  1 . On
obtient finalement la matrice A p 1 .
On a vu que mathématiquement cela peut s’écrire A p 1  S . A (où S est une matrice inversible). Définissons alors
G p 1  G p
C  p 1 ; S p 1  S .S p ; H p 1  H p . Le calcul du produit de matrices s’effectue en opérant sur Sp les
mêmes transformations que sur A. On vérifie successivement que toutes les conditions imposées sont vérifiées.
Dans tous les cas, on a bien construit le terme suivant.
Intéressons-nous maintenant au terme un. Gn est alors une matrice « indépendante » de rang k. Comme elle compte k
colonnes, il s’agit d’une matrice carrée inversible. La dernière condition assure que la juxtaposition des matrices G n et Hn
fournit bien une permutation des colonnes de M. Finalement, on a trouvé le résultat recherché.
On remarquera que le choix de la permutation initiale permet de rendre le caractère aléatoire de l’algorithme. Autrement
dit, deux exécutions de cet algorithme ne fournissent pas a priori le même résultat, ce qui est inévitable pour l’approche
probabiliste.
Essayons maintenant d’évaluer le temps d’exécution de cet algorithme, en comptant le nombre d’opérations qu’il effectue
au maximum.
Pour l’étape p on dénombre :
 k. 2.k  1 opérations pour le calcul de S p .C   p 1


k  L  k comparaisons
6.L  1  6.k opérations dues à la permutation des deux colonnes
2
 2.k .k  L  1  2.k additions
 k opérations pour juxtaposer les matrices


4.n.k.k  2 , ce qui reste encore relativement rapide. On pourra
2
retenir que, pour des grandes valeurs de k et de n, ce nombre est de l’ordre de grandeur de 4.n.k .
Ainsi le nombre d’opérations total reste inférieur à
Si l’on veut de plus calculer l’inverse de G, on peut remarquer que l’algorithme présentée ici permet de commencer
directement à la deuxième étape lors de l’exécution du pivot de Gauss puisqu’il fournit le couple Q1 

t
An
t

S n qui
permet d’initialiser la récurrence (voir Annexe 6) qui fournira la transposée de l’inverse recherché. Remarquons que nous
avons transposé toutes les matrices pour rester cohérent mais dans la pratique, il n’est nullement nécessaire de la faire.
3
Ainsi l’opération d’inversion demande un nombre d’opérations inférieur à k .
Finalement, trouver k colonnes indépendantes et inverser la matrice obtenue en juxtaposant celles-ci est une opération
rapide qui demande environ
k 2 .4.n  k  opérations.
L’algorithme suivant programmé sous Maple renvoie les matrice G et H mais dans un souci de simplicité, nous n’avons
pas présenté l’inversion de la matrice G.
indep := proc(m)
local lst,chx,i,g,s,h,v,L,tst,j,v0,k,n;
lst := matrix([[seq(i,i = 1 .. n)]]);
s := array(identity,1 .. k,1 .. k);
L := 0; k:=rowdim(m); n:=coldim(m);
g := matrix([seq([0],i = 1 .. k)]);
h := matrix([seq([0],i = 1 .. k)]);
for i from 0 to n-1 do
chx := (rand() mod (n-i))+1;
v0 := convert(col(m,lst[1,chx]),matrix);
v := z2(s &* v0);
tst := false;
Page 20
Cryptographie – Chiffre de McEliece
for j from L+1 to k while not tst do
tst := evalb(v[j,1] = 1) od;
if tst then
s := swaprow(s,L+1,j-1);
v := swaprow(v,L+1,j-1);
for j from L+2 to k do
if v[j,1] = 1 then s := addrow(s,L+1,j) fi od;
g := concat(g,v0);
L := L+1
else h := concat(h,v0)
fi;
lst[1,chx] := lst[1,n-i]
od;
g := delcols(g,1 .. 1); h := delcols(h,1 .. 1);
[evalm(g),evalm(h)]
end
Cette procédure fonctionne après avoir chargé le package LINALG.
8. Primalité et factorisation
Ces deux problèmes apparemment très proches sont tous deux présents dans le système de chiffrement RSA. Toutefois, la
sécurité de ce dernier repose sur la difficulté pratique de factoriser de grands nombres entiers et pourtant, il est nécessaire pour
l’utiliser de générer de grands nombres premiers. Il semble y avoir là un paradoxe mais en réalité on peut trouver des
algorithmes efficaces qui permettent de s’assurer qu’un nombre est composé sans déterminer le moindre diviseur strict.
Ces algorithmes sont basés sur les propriétés remarquables des nombres premiers. Nous allons en présenter un élémentaire
mais déjà très efficace.
Donnons-nous un nombre n impair et supérieur ou égal à 9 (ce qui est loin d'être restrictif) et écrivons n sous la forme
n  1  2 s .r (où r est un nombre impair).
Définissons alors la proposition suivante (pour a compris entre 1 et n-1) :
Pa : a r  1 n ou
 i 0, 1, ..., s  1/ a
2i r

 1 n
On a alors le résultat suivant : si n est un nombre premier, alors pour tout a compris entre 1 et n-1, la proposition Pa est
vraie.
En effet, supposons n premier et impair. Par hypothèse le nombre a est non nul modulo n. La structure de corps de
Z
n.Z
permet alors d’affirmer que :
n
 1 n , on en déduit par une récurrence descendante et en
a n1  a 2 r  1
s
i  0, 1, ..., s  1, a
r
utilisant toujours la structure de corps que a  1 n .
Si l'on suppose en outre que
2i r
Ce qui correspond bien au résultat annoncé.
Intéressons nous à la contraposée : elle nous dit que si on parvient à trouver un entier a qui mette en défaut la proposition
précédente, alors n est composé. C’est ce que allons rechercher.
Pratiquement, on engendre a un entier aléatoire compris entre 1 et n-1, et on vérifie ou on infirme la proposition P a. Dans
un des deux cas, on peut conclure comme le montre l'exemple ci-dessous. On notera qu’on connaît des algorithmes rapides
pour calculer des telles exponentielles.
PAR EXEMPLE PRENONS n = 42 115 916 893. DONC
ON CALCULE ALORS :
n  1  2 2.1052 899 223  2 s.r
2 r  24183 448 388  1 n
2 2.r  161471 296 052  1 n
ON EN DEDUIT QUE n EST COMPOSE MAIS ON N’A AUCUN RENSEIGNEMENT SUR SES DIVISEURS.
Si l'on n’a pas réussi à infirmer la proposition P a, on recommence avec un autre nombre aléatoire a et ainsi de suite.
Page 21
Cryptographie – Chiffre de McEliece
Nous voyons que cet algorithme a l’énorme inconvénient de ne pas pouvoir assurer que n est premier s’il l’est. Toutefois, il
est légitime de penser qu’au bout d’une cinquantaine d’essais infructueux (c’est à dire qui n’ont pas réussi à mettre en défaut la
primalité de n), le nombre n que l’on teste a de fortes chances d’être réellement premier. Vérifions ce point.
Cette étude s’appuie principalement sur le théorème de Rabin et que nous énonçons et admettons ici. Si n est un nombre
impair composé et supérieur ou égal à 9, alors il existe au plus
n 1
4
entiers qui satisfont à la proposition Pa et en réalité
cette majoration est souvent très grossière.
Pour faire un calcul rigoureux, il est alors nécessaire de définir les événements suivants :
C : Le nombre n est composé.
Tk : La proposition est vraie pour k valeurs de l'entier a.
Le théorème de Rabin permet alors d’écrire en supposant que les k tests soient indépendants (ce qui n’est en réalité pas le
k
1
cas) : P Tk C     . La probabilité qui nous intéresse, c’est PC Tk  .
4
Pour la déterminer, il nous faut auparavant calculer P(C). Un résultat d’arithmétique permet d’apporter une réponse
satisfaisante. Celui-ci dit que si N est grand, alors le nombre de nombres premiers inférieurs à N est « de l’ordre de »
N
.
ln N
Fixons nous donc une borne supérieure N aux nombres aléatoires que l’on génère. On a ainsi le résultat
suivant : PC   1 
1
. Les théorèmes classiques de probabilité permettent d’écrire :
ln N

1 
1
 
PTk   PTk C .PC   PTk C .PC   PTk C .1 
 ln N  ln N

1 

et PTk  C   PTk C .PC   PTk C .1 
 ln N 
D’où on trouve aisément la probabilité recherchée :
PC Tk  
PTk  C 
ln N  1
1
1
 k
PTk 
1  PTk C 
. ln N  1 4  1  ln N
Pratiquement pour le système RSA, on souhaite obtenir des nombres premiers d’une soixantaine de chiffres, ce qui
correspond à peu près à ln N  1  140 . Ainsi après cinquante essais infructueux, la probabilité que le nombre testé soit


28
composé est inférieure à 10 , ce qui est vraiment « ridicule ». A titre de comparaison, on a autant de chance d’avoir laisser
passer miraculeusement un nombre composé que de gagner au Loto quatre fois d’affilée.
Pratiquement, pour générer de grands nombres premiers aléatoires d’une centaines de chiffres, on génère des nombres
impairs d’une centaine de chiffres et on teste leur primalité par l’algorithme précédent. L’étude ci-dessus prouve alors que le
nombre moyen de tirages à effectuer est de l’ordre de 115, et donc il s’agit ici d’une méthode rapide et relativement sûre.
La factorisation, elle, est beaucoup plus compliquée. En effet, il s’agit de trouver des diviseurs stricts sans se contenter de
dire seulement qu’ils existent. Bien sûr, on connaît des méthodes plus élaborées que la recherche exhaustive qui consisterait à
tester tous les éventuels diviseurs jusqu’à en trouver un. Ces algorithmes sont basés sur des théories assez complexes comme
par exemple l'étude des courbes elliptiques mais ont des temps d'exécution qui croissent rapidement avec la taille du nombre à
tester et qui utilisent des méthodes probabilistes certes plus rapides mais moins sûres (c'est-à-dire que l'on est pas sûr a priori
de parvenir à un résultat). En effet, le nombre le plus grand factorisé à ce jour ne compte pas plus de 129 chiffres et il a fallu de
nombreux ordinateurs travaillant nuit et jour pour arriver à ce résultat.
9. Quelques procédures écrites sous MAPLE
Toutes ces procédures fonctionnent après avoir chargé le package LINALG.
Procédure 1 : Génération d’une matrice inversible aléatoire et de son inverse
has2 := proc() rand() mod 2 end
Page 22
Cryptographie – Chiffre de McEliece
findinv := proc(k)
local dt;
global s,invs;
dt := 0;
while dt mod 2 = 0 do s := randmatrix(k,k,entries = has2);
dt := det(s) od;
invs := inverse(s)*dt;
invs := z2(invs);
[evalm(s),evalm(invs)]
end
On notera que cette procédure fait appel à la sous-procédure Z2 qui permet de rester avec des coefficients dans F 2.
Procédure 2 : Génération d’une matrice de permutation et de son inverse
perm := proc(n)
local lst,chx,i,j,r;
global pm,invpm;
lst := matrix([[seq(i,i = 1 .. n)]]);
pm := matrix([seq([seq(0,i = 1 .. n)],j = 1 .. n)]);
for r from 0 to n-1 do
chx := (rand() mod (n-r))+1;
pm[r+1,lst[1,chx]] := 1; lst[1,chx] := lst[1,n-r]
od;
invpm := transpose(pm);
[evalm(pm),evalm(invpm)]
end
Procédure 3 : Génération d’une matrice sympathique et du couple (n,k)
gencode :=
proc(err,r)
local a2,i,j,cf,i1,j1;
global grp,alpha,a,n,k,t,ainv,g;
t := err;
readlib(GF);
grp := GF(2,r); (Cette opération construit le corps fini de cardinal 2 r)
a := 1;
alpha := grp[PrimitiveElement]();
a2 := grp[`^`](alpha,2);
cf := alpha;
for i by 2 to (2*t+1) do
for j to r do a := mult(a,x+cf); cf := grp[`^`](cf,2) od;
cf := grp[`*`](cf,a2)
od;
n := 2^r-1;
k := n-degree(a,x);
ainv := diveuc(x^(n-1)+1,a)[1];
g := matrix([seq([seq(coeff(expand(a*x^j1),x,i1),i1 = 0 .. n-1)],j1 = 0 .. k-1)])
end
On notera que cette procédure fait appel à la sous-procédure DIVEUC qui effectue la division euclidienne de deux
polynômes et renvoie la liste [Quotient, Reste] et à la sous-procédure MULT qui multiplie deux polynômes.
Procédure 4 : Chiffrement du message MES
erreur := proc()
local lst,err,chx,i;
lst := matrix([[seq(i,i = 1 .. n)]]);
err := matrix([[seq(0,i = 1 .. n)]]);
for i from 0 to t-1 do
chx := (rand() mod (n-i))+1;
Page 23
Cryptographie – Chiffre de McEliece
err[1,lst[1,chx]] := 1; lst[1,chx] := lst[1,n-i]
od;
evalm(err)
end
codage := proc(mes)
local cod;
cod := z2(mes &* gp + erreur()); evalm(cod)
end
Procédure 5 : Déchiffrement du message MES
decodage := proc(mes)
local xs,i,msg,yp;
yp := z2(mes &* invpm);
xs := finderr(sum(yp[1,i+1]*x^i,i = 0 .. n-1));
xs := matrix([[seq(coeff(xs,x,i),i = 0 .. k-1)]]);
msg := z2(xs &* invs);
evalm(msg)
end
finderr :=
proc(p)
local val,i,s,err,dec;
val := alpha;
s := 0;
for i from 0 to 2*t-1 do
s := s+calcul(p,val)*x^i; val := grp[`*`](val,alpha) od;
s := algo(s);
val := alpha;
err := 0;
dec := p;
for i to n while err < degree(s,x) do
if calcul(s,val) = 0 then dec := moins(dec,x^(n-i));
err := err+1 fi;
val := grp[`*`](val,alpha)
od;
multn(dec,ainv)
end
On notera que cette procédure fait appel à la sous-procédure ALGO qui met en œuvre l’algorithme d’Euclide et renvoie le
polynôme Bi défini précédemment et à la sous-procédure MULTN qui multiplie deux polynômes modulo X n.
10. Démonstration des théorèmes
 Théorème i)
 Si (x1,e1) et (x2,e2) sont deux couples qui vérifient (S), alors on a l’égalité suivante :
x'  x1  e1  x2  e2 et donc e2  e1  x1  x2  F
Mais on a également we2  e1   we1   we2   d . D’où on en déduit que e2  e1  0 .

Ainsi on a bien démontré l’unicité voulue.
Pour la réciproque, raisonnons par l’absurde. Si
 x0  F / wx0   2.t , alors on pourrait écrire :
x0  x1  x 2
wx   t
.
avec  1
wx 2   t
Ce qui fournit deux décompositions distinctes et convenables pour le vecteur x2 (x2=x0+x1 et x2=0+x2), ce qui est
supposé faux.
Page 24
Cryptographie – Chiffre de McEliece

Théorème ii)
Remarquons tout d’abord que la structure de
clairement injective et le fait que
   t 
 . Cette application est
 t permet de définir l’application  :  t
 x  2.x 
 t soit un ensemble fini prouve qu’elle est bijective. On en déduit l’égalité suivante en
appliquant également les règles de calcul (voir Annexe 2) :
    X
At X
2
2
i t
Ecrivons maintenant At  X  


   X 
i
2
2.i
i t


   X   i
 it

2

  At  X 2 .



d
  .X
i
i
i 1
. La relation précédente devient alors, toujours en appliquant les mêmes règles
de calcul :
d
  .X
d
2.i
i
i 1
   i . X 2.i
2
i 1
et donc i  1,..., d ,  i   i
2
soit  i  F2
Autrement dit, At est un polynôme à coefficient dans F2.

Théorème iii)
On peut montrer facilement à l’aide d’une récurrence que :
Ai .Bi 1  Ai 1 .Bi   1
degBi   2.t  degRi 1 
On peut alors en déduire que Ai et Bi sont premiers entre eux et que degBi   t .
i

Posons alors

 Z    1   .Z
j 1
rj
 et remarquons que :
i  1,...,2.t,
alors
     
 
R'  i  R  i  E '  i  E '  i


2.t .r j
2.t  
 
m 1
.Z 2.t 
rj
rj 
rj 1  
m
m 1



R
'

.
Z


.
Z
.



.
.


r

 
1   j .Z 
m 1
m 1  j 1
 j 1 

  r

1
r
rk

 Z      j .
.
1


.
Z

 j .  1   rk .Z de sorte


rj

1   .Z  1 k 
j 1
1 k 
 j 1
k j
Calculons alors S Z  
Posons
et
2.t
 

ait : S Z . Z    Z 


Z . On remarquera que deg     1  t et deg     t

que
l’on
2.t
 .
D’autre part l’égalité fournie par l’algorithme d’Euclide permet d’écrire : S Z .Bi Z   Ri Z  Z
 Z .Bi Z   S Z . Z .Bi Z   Ri Z . Z  Z 2.t  .
Mais on a d’autre part deg.Bi  Ri .   2.t d’où on trouve  .Bi  Ri . .
2.t
D’où, il vient
 est scindé et ses racines sont les

rj
et on a
    .  1     0 . Ceci prouve que les polynômes  et

rj
rk  r j
rj
1 k 
k j
 sont premiers entre eux et donc le théorème de Gauss permet de prouver l’existence d’un polynôme Q vérifiant
 Bi  Q.
. L’égalité fournie par l’algorithme d’Euclide s’écrit alors :

 Ri  Q.
QZ . Z   Ai Z .Z 2.t  QZ . Z .S Z 
On en déduit que Q est un diviseur commun à Ai et Bi. Mais on a vu que ces polynômes sont premiers entre eux. Ainsi, Q
est un polynôme constant non nul (car Ri ne peut être nul). Donc les racines de Bi sont exactement celles de , ce qui démontre
le résultat voulu.

Théorème iv)


 E . Si maintenant x et y sont des éléments de G  , alors :
g  G, x  y g   x g    y g   0 donc x  y  G 
On vérifie que l’on a bien 0  G
et G
Page 25
Cryptographie – Chiffre de McEliece

Ceci prouve que G est un sous-espace vectoriel de E. (On remarquera qu’il n’est pas utile de prendre un scalaire, comme
à l’habitude, qui ne pourrait valoir ici que 0 ou 1).
Notons d la dimension de G et considérons désormais BG  e1 ,..., ed  une base de G. Définissons alors :
i  1,..., d , ei* : x  x ei 
et
Toutes ces applications sont linéaires et on a immédiatement
  .e
i 1
d
que
  .e
i 1
i
i
i

G   Ker u .
d
D’autre part si 1,…, d sont des scalaires vérifiant

u : x  e1* x ,..., e d* x 
*
i

 0 , alors x  E ,  x


d
  .e   0 d’où on déduit
i 1
i
i
 0 puis que 1  ...   d  0 . Autrement dit, la famille e1* ,..., e d*  est libre dans E*. Un théorème de cours
prouve alors de
codim Ker u   codim G   d , ce qu’il fallait démontrer.
D’autre part, si
x  F , alors y  F  , x  y d’où on trouve x  F   . L’égalité des dimensions des deux sous
espaces vectoriels prouve finalement que
F  F   .

11. La loi française sur la cryptographie
Il est intuitivement évident que la sûreté d’un chiffre repose principalement sur la longueur de la clé que l’on utilise. Bien
sûr, cela dépend également du système cryptographique. On évalue en général la sécurité d’un système cryptographique en
calculant la taille minimale d’une clé qui le rend calculatoirement inviolable. Par cette définition, nous voyons que le système
de chiffrement de McEliece est peu sûr.
Le tableau suivant répertorie les systèmes cryptographiques présents dans ce mémoire et la taille minimale d’une clé le
rendant sûr.
Système
Taille minimale (en bits )
Vigenère
1 000
McEliece
100 000
Merkle Hellman

RSA
500
Le symbole « infini » signifie que l’on connaît des algorithmes rapides pour casser le chiffre quelle que soit la longueur de
la clé.
Nous constatons aisément qu’une clé de quarante bits apparaît comme ridicule. C’était pourtant la limite fixée par la loi
française jusqu’à l’année dernière. Il y a bien sûr des raisons politiques à tout cela mais nous n’allons pas nous attarder làdessus.
Voyons plutôt ce que représentent quarante bits.
Pour le chiffre de Vigenère, il s’agit d’un mot de cinq lettres. Un système d’attaque statistique basée sur une étude de la
fréquence des lettres dans un langage donné permet de retrouver la clé en un temps record d’autant plus rapide que le message
à chiffrer est long.
Pour le système de McEliece, signalons simplement que l’exemple ridicule qui est présenté dans ce mémoire utilise déjà
une clé de 128 bits.
Pour le chiffrement de Merkle-Hellmann, il s’agit au maximum d’une suite de cinq nombres inférieurs à 250, et donc
retrouver le message original par une étude exhaustive est encore une opération plus rapide que celle du déchiffrement.
Pour le chiffrement RSA, quarante bits correspondent à un modulus d’environ douze chiffres, un nombre plutôt simple à
factoriser même avec une vulgaire calculatrice programmable.
Signalons enfin que la même restriction est en vigueur aux Etats-Unis sur le réseau Internet. Outrée par cette pratique qui
n’assure plus aucune confidentialité à tous les particuliers et toutes les sociétés utilisant le réseau, la société américaine RSA
Data Security a organisé un concours afin de dénoncer ce « scandale ». Une offre de cinquante mille dollars était faite à ceux
qui seraient capables de décrypter des messages chiffrés avec des clés allant de 40 à 256 bits. La réponse ne s’est pas fait
attendre : trois heures et demi plus tard, le premier chiffre utilisant une clé de quarante bits a été cassé, il disait : « Voilà
pourquoi vous devez utiliser une clef plus longue ».
Page 26
Cryptographie – Chiffre de McEliece
BIBLIOGRAPHIE
Douglas Stinson, Cryptographie Théorie et Pratique, pages 1 à 35
Douglas Stinson, Cryptographie Théorie et Pratique, pages 101 à 111
Douglas Stinson, Cryptographie Théorie et Pratique, pages 132 à 137
Douglas Stinson, Cryptographie Théorie et Pratique, pages 170 à 178
André Warusfel, Structures algébriques finies, pages 190 à 202
Michel Demazure, Cours d’algèbre, pages 47 à 51
Michel Demazure, Cours d’algèbre, pages 60 à 64
Michel Demazure, Cours d’algèbre, pages 89 à 92
Michel Demazure, Cours d’algèbre, pages 195 à 246
Science&Vie, Juin 1997, La clef du secret, page 180
Cours de M. Bruno Martin, professeur à l’ESSI, Complexité & Théorie des codes
Page 27