maple

MAPLE
La Méthode De Feistel
SOMMAIRE
I. INTRODUCTION ............................................................................ 3
II. Principe de la Méthode de Feistel ................................................. 4
1. Le XOR (« non ou » littéralement) ................................................. 4
2. Un exemple d’utilisation de la Sbox Sbox1 et du Xor ....................... 5
3. Un exemple d’utilisation de la Sbox Sbox2 et du Xor ....................... 5
III. Algorithme détaillé des procédures Maple ................................... 6
1. La Sbox ........................................................................................ 6
2. L’algorithme de codage ................................................................. 7
A. L’algorithme commenté .............................................................. 7
B. Le schema explicatif................................................................... 8
C. Le code Maple ........................................................................... 9
3. L’algorithme de décodage ............................................................ 10
A. L’algorithme commenté ............................................................ 10
B. Le code Maple ......................................................................... 10
IV. Le programme principal .............................................................. 11
1. Le codage : Fround ..................................................................... 12
2. Le décodage : Fdecod ................................................................. 13
V. Les tests et jeux d’essais ............................................................ 14
1. Les tests des sous-programmes simple ......................................... 14
A. La procédure Encod : ............................................................... 14
B. La procedure Decod : .............................................................. 16
2. Le test du programme principal ................................................... 17
A. La procédure Fround : ............................................................. 17
B. La procedure Fdecod : ............................................................. 17
VI. Pour aller plus loin avec Feistel .................................................. 18
VII. Conclusion ................................................................................... 19
VIII. Annexe ..................................................................................... 20
2 2
I. INTRODUCTION
Petite Biographie : Horst Feistel était un emigré allemand arrivé en Amérique en
1934. Il a été un employé d'IBM dans les années 1960 et 1970. La construction
Feistel a été utilisée au tout début dans le chiffrement Lucifer, puis dans le DES.
En cryptographie, on distingue deux grands types d’algorithme de chiffrement : Les
algorithmes à clé publique comme le RSA et les algorithmes à clé secrète comme
celui imaginé par Horst Feistel.
L’objectif de la cryptographie est de coder un message en le rendant le plus
incompréhensible possible pour ceux qui n’en sont pas destinataire. Pour cela il faut
que le message codé paraisse aussi aléatoire que possible. Les algorithmes à clé
secrète comme celui de Feistel utilise l’aléatoire afin d’y parvenir.
Grâce aux travaux de Feistel, on ne construit plus seulement des fonctions qui ont
l’air aléatoire mais désormais des bijections aléatoires. L’avantage de la bijection sur
la fonction aléatoire est qu’à une image donnée correspond un seul antécédent, ce
qui permet de crypter mais aussi de décrypter un message.
3 3
II. Principe de la Méthode de Feistel
La solution apportée par Feistel est très ingénieuse : on suppose par exemple
qu'on a une fonction f "presque aléatoire" qui prend comme argument un mot de n
bits, et renvoie un mot de n bits (qui donne l'impression d'avoir été choisi au
hasard). L'algorithme de chiffrement va procéder en chiffrant des blocs de 2n bits,
qu'on partage en 2, partie gauche G, partie droite D. L'image du bloc (G,D) par le
schéma de Feistel est le bloc (L,R), avec L=D, et R= G xor f(D). Cette transformation
est cette fois bijective, car si on a un tel couple (L,R), on retrouve (G,D) par D=L et
G=R xor f(L). Bien sûr, la partie droite n'a pas été transformée (juste envoyée à
gauche). C'est pourquoi on répète le schéma de Feistel un certain nombre de fois (on
parle de tours - le DES par exemple en comporte 16).
1. Le XOR (« non ou » littéralement)
La procédure qui suit, codée en Maple, permet de réaliser un XOR sur 2 listes b1 et
b2 :
Xor := proc(b1,b2)
local n,i,c;
n:=nops(b1);
for i from 1 to n do
c[i] := b1[i]+b2[i] mod 2;
od;
convert(c,list);
end proc;
On veut construire ici une bijection qui transforme quatre bits en quatre autres bits.
La bijection est contitué de deux fonctions que l'on appelle sbox1 et sbox2 qui à
deux bits donnés font correspondre deux autres bits. La Sbox est en fait un
algorithme de substitution.
Les procédures qui suivent, codée en Maple, sont deux exemples de sbox :
Sbox1 := proc(b) local c;
if b[1]=0 and b[2]=0 then
if b[1]=0 and b[2]=1 then
if b[1]=1 and b[2]=0 then
if b[1]=1 and b[2]=1 then
convert(c,list);
end proc:
Sbox2 := proc(b) local c;
if b[1]=0 and b[2]=0 then
if b[1]=0 and b[2]=1 then
if b[1]=1 and b[2]=0 then
if b[1]=1 and b[2]=1 then
convert(c,list);
end proc:
c:=[0,1];
c:=[1,1];
c:=[1,0];
c:=[0,1];
fi:
fi:
fi:
fi:
c:=[0,1];
c:=[0,0];
c:=[0,0];
c:=[0,1];
fi:
fi:
fi:
fi:
4 4
2. Un exemple d’utilisation de la Sbox Sbox1 et du Xor
On applique ici la Sbox1 à D0 et on fait un Xor du résultat de la Sbox avec G0.
G0:=[1,1];
D0:=[0,1];
Sb1:=Sbox1(D0);
R:=Xor(G0,Sb1);
3. Un exemple d’utilisation de la Sbox Sbox2 et du Xor
On applique ici la Sbox2 à D1 et on fait un Xor du résultat de la Sbox avec G1.
G1:=[1,1];
D1:=[0,1];
Sb2:=Sbox2(G1);
R:=Xor(D1,Sb2);
5 5
III. Algorithme détaillé des procédures Maple
L’algorithme de Feistel qui nous est demandé est un peu spécial. En effet, sa le
message à coder est de 4 chiffres et la clé à utiliser est elle de 3 chiffres. Ceci
complique un peu le processus de codage et de decodage.
1. La Sbox
Ce sous-programme fait correspondre une liste à 3 paramètres b1,b2 et b3 une liste
de 2 paramètres c1 et c2.
Sbox:=proc(b) local c;
if b[1]=0 and b[2]=0 and
if b[1]=0 and b[2]=0 and
if b[1]=0 and b[2]=1 and
if b[1]=0 and b[2]=1 and
if b[1]=1 and b[2]=0 and
if b[1]=1 and b[2]=0 and
if b[1]=1 and b[2]=1 and
if b[1]=1 and b[2]=1 and
convert(c,list);
end proc:
b[3]=0
b[3]=1
b[3]=0
b[3]=1
b[3]=0
b[3]=1
b[3]=0
b[3]=1
then
then
then
then
then
then
then
then
c:=[1,1];
c:=[0,1];
c:=[0,0];
c:=[1,0];
c:=[0,1];
c:=[0,0];
c:=[1,1];
c:=[1,1];
fi:
fi:
fi:
fi:
fi:
fi:
fi:
fi:
6 6
2. L’algorithme de codage
A. L’algorithme commenté
L’algorithme de codage suivant appelé Encod code avec la méthode de Feistel le
message [[X[1],X[2],X[3],X[4]] avec la clé K.
Encod:=proc(x,K)
local X1,X2,Y1,Y2,C,aux;
On prépare ici le codage en séparant X[1],X[2],X[3] et X[4] en deux : X1 et X2 (cf
schéma étape 1) :
X1:=[x[3],x[4],x[3]]:
X2:=[x[1],x[2]]:
On effectue ensuite un Xor de X1 avec la clé K. On met ensuite le résultat appelé aux
dans la Sbox (cf étape 2) :
aux:=Xor(X1,K):
Y1:=Sbox(aux);
Ensuite, on fait un Xor de X2 et de Y1, le résultat de l’expression précédente (cf
étape 3)
Y2:=Xor(X2,Y1);
On obtient alors le résultat souhaité, une liste de quatre éléments codant la liste de
départ, le message (cf étape 4)
C:=[x[3],x[4],Y2[1],Y2[2]]:
convert(C,list);
end proc:
7 7
B. Le schema explicatif
8 8
C. Le code Maple
Encod:=proc(x,K)
local X1,X2,Y1,Y2,C,aux;
X1:=[x[3],x[4],x[3]]:
X2:=[x[1],x[2]]:
aux:=Xor(X1,K):
Y1:=Sbox(aux);
Y2:=Xor(X2,Y1);
C:=[x[3],x[4],Y2[1],Y2[2]]:
convert(C,list);
end proc:
9 9
3. L’algorithme de décodage
Dans la méthode de Feistel, l’algorithme de décodage n’est pas très différent de celui
de codage. La seule grosse différence évidente est que l’on part d’une liste codée
afin d’obtenir le message d’origine.
A. L’algorithme commenté
L’algorithme de dédage suivant appelé Decod décode avec la méthode de Feistel le
message [Y[1],Y[2],Y[3],Y[4]] avec la clé K.
Decod:=proc(y,K)
local C1,C2,T1,T2,C3,aux;
On prépare ici le décodage en séparant Y[1],Y[2],Y[3] et Y[4] en deux : C1 et C2:
C1:=[y[1],y[2],y[1]]:
C2:=[y[3],y[4]]:
On effectue ensuite un Xor de C1 avec la clé K. On met ensuite le résultat appelé aux
dans la Sbox :
aux:=Xor(C1,K):
T1:=Sbox(aux):
Ensuite, on fait un Xor de C2 et de T1, le résultat de l’expression précédente :
T2:=Xor(C2,T1):
On obtient alors le résultat souhaité, le message décodé C3:
C3:=[T2[1],T2[2],y[1],y[2]]:
convert(C3,list):
end proc:
B. Le code Maple
Decod:=proc(y,K)
local C1,C2,T1,T2,C3,aux;
C1:=[y[1],y[2],y[1]]:
C2:=[y[3],y[4]]:
aux:=Xor(C1,K):
T1:=Sbox(aux):
T2:=Xor(C2,T1):
C3:=[T2[1],T2[2],y[1],y[2]]:
convert(C3,list):
end proc:
1010
IV. Le programme principal
Notre programme ne doit pas encoder une seule fois le message de départ. En effet,
celui-ci va devoir subir la méthode d’encodage de Feistel 3 fois de suite. Cette
répétition de ce processus permet bien sûr une plus grande fiabilité.
Voici donc les procédures permettant de coder et de décoder.
1111
1. Le codage : Fround
Le schéma pour mieux comprendre :
Cette procédure est très simple. Elle fait appel à la procédure Encod trois de suite en
appliquant Encod au résultat du Encod précedent.
Fround:=proc(x,K)
local i,r;
r:=x;
for i from 1 to 3 do
r:=Encod(r,K);
od;
end proc;
1212
2. Le décodage : Fdecod
Cette procedure est le processus inverse de Fround. Elle fait appel à Decod trios fois
de suite.
Fdecod:=proc(x,K)
local i,r;
r:=x;
for i from 1 to 3 do
r:=Decod(r,K);
od;
end proc;
1313
V. Les tests et jeux d’essais
Afin de tester notre programme, nous l’avons testé en y appliquant comme message
à coder la liste : [1,1,0,1] et comme clé : [0,1,1].
1. Les tests des sous-programmes simple
Afin de valider au fur et à mesure nos algorithmes, nous avons d’abord testé Encod
et Decod.
Voici les tests intermédiaires qui ont été effectués :
A. La procédure Encod :
K:=[0,1,1];
a:=[1,1,0,1];
resultat:=Encod(a,K);
1414
Le shéma de la procédure Encod :
1515
B. La procedure Decod :
Cette procedure permet de valider Encod si on retrouve le message de depart en
résultat:
Decod(resultat,K);
Les procédures Encod et Decod peuvent être validées.
1616
2. Le test du programme principal
De la même manière que précédemment. Afin de valider Fround et Fdecod, il faut
appliquer la première procedure qui code et tenter de décoder son résultat. Ainsi, on
voit bien si le codage est bon.
A. La procédure Fround :
K:=[0,1,1];
a:=[1,1,0,1];
resultat:=Fround(a,K);
B. La procedure Fdecod :
Fdecod(resultat,K);
Nous retrouvons donc le message de départ a et les deux procédure Fround et
Fdecod peuvent être validées.
1717
VI. Pour aller plus loin avec Feistel
 Un exemple d’utilisation de la Méthode de Feistel : Le DES (Data
Encryption Standard) :
Petit Historique
Adopté en tant que standard du gouvernement américain (dont la célèbre NSA
National Security Agency) le 23 novembre 1976, c'est en fait simplement la version à
56 bits du chiffre Lucifer conçu par IBM et établi par Horst Feistel. Avec 72 057 594
037 927 936 clés différentes la NSA semblait croire qu'un tel algorithme apporterait
une confidentialité suffisante pour le public.
Fonctionnement
L'algorithme comporte une permutation initale sur des blocs de 64 bits, suivie de
l'application d'une même fonction f, 16 fois de suite, et une permutation finale.
La fonction f comporte un certain nombre d'opérations simples comme des
permutations (Xor) et substitutions (Sbox). Le même algorithme est utilisé pour
chiffrer et déchiffrer.
Le problème majeur du DES est celui de la distribution de la clé. Dans les années
1970, les banques essayèrent de faire distribuer les clefs par des coursiers
sélectionnés munis de cartables cadenassés.
Décryptage du DES
Il est apparu au fil des années, que le DES est un algorithme sûr. L'attaque ayant le
plus de chance de réussir est la recherche exhaustive de la clé. Aujourd'hui, avec des
systèmes spécialisés (Deep crack conçu par l'Electronique Frontier Foundation) et/ou
la collaboration de milliers d'internautes, il est possible de déchiffrer des clés DES de
56 bits en quelques heures.
1818
VII. CONCLUSION
Feistel a inventé une méthode à la fois simple à comprendre et à utiliser mais aussi
difficile à déchiffré depuis l’extérieur. C’est ce qui fait la force de sa méthode
d’encodage.
Nous avons réussi à utiliser et à comprendre la méthode imaginée par Feistel et le
code écrit en Maple effectue correctement aussi bien le codage que le décodage du
message souhaité.
1919
VIII. Annexe
Ici, nous mettons à disposition l’ensemble du code Maple tel qu’il était sur le PC,
c'est-à-dire exécutable. Ceci permet également de mieux voir l’enchaînement de
notre travail.
> restart;
> with(linalg):
> Xor := proc(b1,b2)
local n,i,c;
n:=nops(b1);
for i from 1 to n do
c[i] := b1[i]+b2[i] mod 2;
od;
convert(c,list);
end proc;
> b1:=[1,1,0,0,1,0,0,0,1];
> b2:=[1,0,0,1,1,0,1,1,0];
> c:=Xor(b1,b2);
> Sbox1 := proc(b) local c;
if b[1]=0 and b[2]=0 then c:=[0,1];
if b[1]=0 and b[2]=1 then c:=[1,1];
if b[1]=1 and b[2]=0 then c:=[1,0];
if b[1]=1 and b[2]=1 then c:=[0,1];
convert(c,list);
end proc:
fi:
fi:
fi:
fi:
> Sbox2 := proc(b) local c;
2020
if b[1]=0 and b[2]=0
if b[1]=0 and b[2]=1
if b[1]=1 and b[2]=0
if b[1]=1 and b[2]=1
convert(c,list);
end proc:
then
then
then
then
c:=[0,1];
c:=[0,0];
c:=[0,0];
c:=[0,1];
fi:
fi:
fi:
fi:
> G0:=[1,1];D0:=[0,1];
Sb1:=Sbox1(D0);
R:=Xor(G0,Sb1);
> G1:=[1,1];D1:=[0,1];
Sb2:=Sbox2(G1);
R:=Xor(D1,Sb2);
> Sbox:=proc(b) local c;
if b[1]=0 and b[2]=0 and
if b[1]=0 and b[2]=0 and
if b[1]=0 and b[2]=1 and
if b[1]=0 and b[2]=1 and
if b[1]=1 and b[2]=0 and
if b[1]=1 and b[2]=0 and
if b[1]=1 and b[2]=1 and
if b[1]=1 and b[2]=1 and
convert(c,list);
end proc:
b[3]=0
b[3]=1
b[3]=0
b[3]=1
b[3]=0
b[3]=1
b[3]=0
b[3]=1
then
then
then
then
then
then
then
then
c:=[1,1];
c:=[0,1];
c:=[0,0];
c:=[1,0];
c:=[0,1];
c:=[0,0];
c:=[1,1];
c:=[1,1];
fi:
fi:
fi:
fi:
fi:
fi:
fi:
fi:
> Encod:=proc(x,K)
local X1,X2,Y1,Y2,C,aux;
X1:=[x[3],x[4],x[3]]:
X2:=[x[1],x[2]]:
aux:=Xor(X1,K):
Y1:=Sbox(aux);
Y2:=Xor(X2,Y1);
C:=[x[3],x[4],Y2[1],Y2[2]]:
convert(C,list);
2121
end proc:
TEST DE LA PROCEDURE ENCOD
> K:=[0,1,1];
a:=[1,1,0,1];
resultat:=Encod(a,K);
> Decod:=proc(y,K)
local C1,C2,T1,T2,C3,aux;
C1:=[y[1],y[2],y[1]]:
C2:=[y[3],y[4]]:
aux:=Xor(C1,K):
T1:=Sbox(aux):
T2:=Xor(C2,T1):
C3:=[T2[1],T2[2],y[1],y[2]]:
convert(C3,list):
end proc:
TEST DE LA PROCEDURE DECOD
> Decod(resultat,K);
Ecriture de la procedure Fround
> Fround:=proc(x,K)
local i,r;
r:=x;
for i from 1 to 3 do
r:=Encod(r,K);
od;
end proc;
TEST DE LA PROCEDURE Fround
> resultat:=Fround(a,K);
Ecriture de la procedure Fround
2222
> Fdecod:=proc(x,K)
local i,r;
r:=x;
for i from 1 to 3 do
r:=Decod(r,K);
od;
end proc;
TEST DE LA PROCEDURE Fround
> Fdecod(resultat,K);
2323