See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/304335574

IMPLEMENTATION DES ALGORITHMES CRYPTOGRAPHIQUES CHIFFREMENT

PAR BLOCS A CLEF SECRETE : DES , 3 WAY, RC 5, IDEA ET A CLEF PUBLIQUE :
RSA , DSA

Article · June 2010

CITATIONS READS
0 2,013

1 author:

Aoued Boukelif
University of Sidi-Bel-Abbes
84 PUBLICATIONS 341 CITATIONS

SEE PROFILE

All content following this page was uploaded by Aoued Boukelif on 23 June 2016.

The user has requested enhancement of the downloaded file.

 IMPLEMENTATION DES ALGORITHMES
CRYPTOGRAPHIQUES CHIFFREMENT PAR BLOCS A CLEF SECRETE :
DES , 3 WAY, RC 5, IDEA ET A CLEF PUBLIQUE : RSA , DSA

BOUKELIF Aoued RAHMOUN Abdellatif

Maître de conférences, directeur de Professor of computer science at King
l’équipe de recherche ’’ techniques vidéo’’ Fahd University of Petroleum and
du laboratoire des télécommunications et Minerals
du traitement numérique de signal de
l’Université de S.B.A.
aboukelif@yahoo.fr

RESUME : La réalisation matérielle VLSI la plus rapide du RSA

avec un module de 512 bits a un débit de 64 kilo-bits
Dans cet article nous implémenterons les par secondes. Il existe aussi des puces qui effectuent le
algorithmes: chiffrement RSA à 1024 bits. Il y a environ 4 ans qu’ont
-DES « Data Encryption Standard » qui signifie standard de apparus des puces qui approchent un million de bits par
chiffrement de données, l’un des algorithmes les plus seconde avec un module de 512 bits [4] .
connus du monde de la cryptographie. C’est un algorithme
En logiciel, le DES est environ 100 fois plus rapide que
à clef secrète .
-RSA « RIVEST SHAMIR ADELLMAN » sans doute le RSA. Vu de développement de la technologie, le
l’algorithme à clef publique [1] le plus populaire. Il peut RSA pourrait augmenter en rapidité mais il
aussi bien être utilisée pour le chiffrement que pour la n’approchera jamais la vitesse des algorithmes à clef
signature numérique [2]. secrète.
-DSA « Digital Signature Algorithm » signifiant algorithme
de signature numérique, un autre algorithme à clef I.1.2 - Optimisation en logiciel
publique. Il fait partie du standard de signature Le chiffrement du RSA est bien plus rapide si
numérique DSS ou « Digital Signature Standard ». Il ne nous choisissons bien la valeur de e. Les plus courantes
peut être utilisé que pour la signature numérique. 4
-IDEA « Iternational Data Encryption Algorithm » conçu en sont 3, 17, 65537,et (216+1) .
1990 puis amélioré en 1992, il est basé sur des fondations
I.1.3 - Implémentation de l’algorithme à clef
théoriques impressionnantes, bien plus sûr que le DES
avec sa clef de 128 bits [3]. publique :le RSA
La réalisation du RSA est de loin l’algorithme à
clef publique le plus facile à réaliser bien que sa
Mots clés : Implémentation , Cryptographie , technique, ‘’ élévation d’un nombre à la puissance
cryptanalyse , algorithmes , clé secrète , clé entière modulo n : ax mod n ‘’, soit très simple.
publique. Pour aboutir au résultat, il sera plus commode
d’effectuer des multiplications avec des réductions
I - ALGORITHMES A CLEF PUBLIQUE modulo n à chaque étape intermédiaire puisque
l’arithmétique modulo est distributive, que d’effectuer
I.1 - RSA la méthode simpliste élévation suivie d’une coûteuse
Le message aurait tout aussi pu être chiffré réduction modulo n finale ; cela peut ne pas marcher si
avec d et déchiffré avec e : le choix est x est assez grand.
arbitraire. Cela n’est rien d’autre que la signature Ainsi après un arrangement de la mémorisation
numérique. des résultats intermédiaires, et appliquant la 1ère
technique qui consiste à multiplier et réduire à chaque
I.1.1 - Vitesse du RSA étape intermédiaire nous obtiendrons 6 multiplications
A sa vitesse maximum, le RSA est environ [5] .
1000 fois plus lent que le DES . Cela peut être donné par la fonction suivante :

1
fonction exponentiel_modulo( a :entier, x :entier, permuclef[1..56] = {
n :entier) :entier 56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25,
debut 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43,
s : entier; 35, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37,
s := 1; 29, 21, 13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19,
tant que (x<>0) faire 11, 3}.
debut i, j, k, l, m : entier ;
si (est-il-impaire(x)=vrai) alors tab1 : tableau[1..56] d’un octet
s := modulo((s * a),n); clef : pointeur sur un tableau de 8 cases d’un octet
decalage_circulaire_droite(x,1); chacun
a := (a * a) mod n; pos1 : tableau[1..8] de 2 octets
fin; et les données d’initialisation sont les suivantes :
exponentiel_modulo := s; pos1[1..8]= {128,64, 32,16,8,4,2,1}
fin; kn : tableau [1..32] de 4 octets
Nous avons implémenté le RSA avec une clef décalage : tableau [1..16] d’un octet
modulo ne dépassant pas la valeur de 256, puisqu’une
fois dépassé cet intervalle, il sera très difficile de diviser décalage[1..16] =
le résultat et de faire correspondre un caractère ASCII {1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 }.
qui devra à son tour être réassemblé pour donner le
texte en clair. tab2 : tableau [1..56] d’un octet
pos2 : tableau [1..24] de 4 octets
II – ALGORITHMES A CLEF SECRETE les valeurs du tableau pos2 sont en hexadécimales :

II.1. - IMPLEMENTATION DU DES pos2[1..24]={

La fonction de chiffrement et de déchiffrement 800000, 400000, 200000, 100000,
est la même à une exception :pour le chiffrement 80000, 40000, 20000, 10000,
l’algorithme utilise 16 sous-clefs dans un ordre alors 8000, 4000, 2000, 1000,
que pour le déchiffrement les sous-clefs seront utilisées 800, 400, 200, 100,
dans l’ordre inverse [6] . 80, 40, 20, 10,
Voici les étapes constituantes : 8, 4, 2, 1 }.
LES DECLARATIONS permucompres : tableau [1..48] d’un octet
1- Génération des 16 sous clefs permucompres [1..48]={
2- Table de substitutions 13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,
3- La permutation initiale et finale 22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1,
4- Procédure générale du des ( qui contient les 16 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
rondes ) 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31}.
5- La permutation expansive parti_gauche, parti_droit : pointeur sur un type de 4
octets
II.1.1. - DECLARATIONS DES DONNEES gauche, droit, mot64, valeur : de type 4 octets
variables tour : entier.
permuclef : tableau[1..56] d’un octet ptr : pointeur de type entier.
et les donnees d’initialisation sont les suivantes :

II.1.1.2 - GENERATION DES 16 SOUS CLEFS

entre chaîne de 64 bits c’est la clef

sortie tableau de 16 sous clefs de 32 positions
ainsi, la procédure de cette génération est la suivante :
procédure génération (ptr(clef) : entier ; opération : booléen)
si opération = vrai alors il sera question de déchiffrement
sinon si opération = faux chiffrement
Procédure génération (clef : pointeur; opération : booleen )
POUR J ALLANT DE 0 A 56 FAIRE
DEBUT
L:= PERMUCLEF [J] ;
M:= ET_LOGIQUE(L,7) ;
LA PARTIE QUI PRECEDE EST UTILISEE POUR CONSTRUIRE LA PERMUTATION DES CLEFS.
SI (( CLEF [DECALAGE_DROITE(L,3)] & POS1 [M] ) > 0) ALORS TAB[J] :=1 ;
P
EN UTILISANT UN TABLEAU
SINON TAB1 [J] := 0 ;
permuclef [1..56] contient la table de permutation de la clef.
FIN ;
Tous les bits de clef sont stockés dans la tab1[j] selon la table de permutation.
FIN ;

2
 Par exemple prenant la position de la table permuclef La partie P2 est utilisée seulement pour choisir
alors permuclef [0] : = 56 bits n° 56 la direction des sous clefs
Dans l’opération du chiffrement nous commençons par
l : = 56 ; la sous clef de position 0 jusqu’a 32
et dans le déchiffrement ce sera l’inverse.
l:= permuclef [0] : = 56 ; La partie P3 est utilisée pour le décalage des
m := et_logique(56,07) (0011 1000)2 x (0000 sous-clefs.
0111)2 = (0000 0000)2 Chacune des sous-clef est divisée en deux moities de 28
m := 0 (position 0 de tables pos1). bits ensuite les moities sont décalées vers la gauche
tab1 [0] : = et_logique(clef [decalage_droite(56,3)] , d’une ou deux positions selon les positions.
pos1 [m : = 0])) La partie P4 est utilisée pour construire la
tab1 [0] : = et_logique (clef [7],pos1[0]) ; permutation compressive .Les sous-clefs seront
tab1 [0] : = et_logique (clef [7],(0000 0001)2) ; manipulées dans le tableau permucompres[1..48], de 48
donc tab1[0] reçoit la valeur en bit de position 56 (0 ou positions et chaque sous clef se divise en deux parties de
1) 24 bits pour faciliter la représentation d’un type de 4
octets. Puisque nous ne pouvons représenter un mot de
REMARQUE 48 bits nous le diviserons.
La partie P1 est utilisée pour mettre les valeurs Le tableau pos2[24 ] quant à lui il sera utilisé
des bits de clef selon la table de permutation et le pour marquer les positions des bits.
stocker dans la tab1e [6] . Par exemple la position du bit 24 est représentée par
Cette partie est essentielle dans le choix du chiffrement 800000 := 1000 0000 0000 0000 0000 0000.
ou du déchiffrement selon la condition : Enfin toutes les sous clefs qui sont générées
Opération := chiffrement ou déchiffrement. seront stockées dans le tableau kn (tableau de 32
positions ou éléments ).

Pour i variant de 0 a 16 faire

DEBUT
si ( opération = vrai ) alors m := décalage_ gauche ((15-i), 1)
sinon m:= décalage_ gauche(i, 1) ;
N := M+1 ;
KN[M]:= KN[N]:= 0 ; p2
POUR J VARIANT DE 0 A 28 FAIRE
INITIALISATION
DEBUT
L:= J+ DECALAGE[I] ;
SI (L<28 ) ALORS TAB2[J]:= TAB1[L]
SINON TAB2[J]:= TAB1[L-28] ;
FIN
POUR J VARIANT DE 28 A 56 FAIRE
DEBUT
L:= J + DECALAGE [I] ;
SI (L<56) ALORS TAB2[J]:= TAB1[L] P3
SINON TAB2[J]:= TAB1[L-28] ;
FIN

POUR J VARIANT DE 0 A 24 FAIRE

DEBUT
SI (TAB2 [PERMUCOMPRES [J] ] ) ALORS KN[M] := OU_LOGIQUE
(KN[M],POS2[J]);
SI (TAB2 [PERMUCOMPRES[J+24] ] ) ALORS KN[N] := OU_LOGIQUE
(KN[N],POS2[J]);
FIN
p4

FIN

3
 II.1.1.3 - TABLE DE SUBSTITUTIONS

LES TABLES–S Nous avons inséré directement la permutation

La réalisation des tables–S (ou les tables de P dans les tables–S (8 tables) mais avec un changement
substitution) se fait de la façon suivante : de position des bits dans chaque table-S pour construire
Les tables–S seront combinées directement avec la une sortie représentant .
permutation P . La permutation P de 32 bits :
Donc les tables–S contiennent 16 colonnes et 4 lignes Par exemple la table S1 sera représentée par :
commençant de 0 a 3. Pour représenter cette matrice on S1 : table [64] de type long non signé,
utilise un tableau de 64 entées [7] . S1 [64]={
01010400, 00000000, 00010000, 01010404,
01010004, 00010404, 00000004, 00010000,
00000400, 01010400, 01010404, 00000400,
01000404, 01010004, 01000000, 00000004,
00000404, 01000400, 01000400, 00010400,
00010400, 01010000, 01010000, 01000404,
00010004, 01000004, 01000004, 00010004,

00000000, 00000404, 00010404, 01000000,

00010000, 01010404, 00000004, 01010000,
01010400, 01000000, 01000000, 00000400,
01010004, 00010000, 00010400, 01000004,
00000400, 00000004, 01000404, 00010404,
01010404, 00010004, 01010000, 01000404,
01000004, 00000404, 00010404, 01010400,
00000404, 01000400, 01000400, 00000000,
00010004, 00010400, 00000000, 01010004}.

II.1.1.4 - LA PERMUTATION INITIALE Avant de faire la permutation initiale il faut permuter le

ET FINALE bloc de données selon la permutation suivante :
LA PERMUTATION INITIALE On divise le bloc de données en deux parties
La réalisation de la permutation initiale est très (gauche et droite) et on fait une permutation qui vérifie
important dans l’algorithme DES. l’ordre suivant des deux parties (gauche et droite) .
partig :
50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 56 55 54 53 52 51
partd : 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 58 57 64 63 62 61 60 59 24 23 22 21
Remarque : cette permutation est supplémentaire dans le but de simplifier la réalisation de la permutation initiale.

INSTRUCTIONS DE LA PERMUTATION_INITIALE

gauche := partie_gauche ;
droit := partie_droite ;
mot64 :=et_logique (ou_exlusif (decalage_droite(gauche, 4),droit), en_hexa(0f0f0f0f));
droit :=ou_exlusif(droit, mot64) ;
gauche :=ou_exlusif(gauche,decalage_gauche (mot64,4));
mot64 :=et_logique (ou_exlusif(decalage_droite (gauche, 16), droit), en-hexa(0000ffff)) ;
droit :=ou_exlusif(droit, mot64) ;
gauche :=ou_exlusif(gauche,decalage_gauche(mot64, 16)) ;
mot64 :=et_logique(ou_exlusif(decalage_droite(droit, 2), gauche), en_hexa(33333333)) ;
gauche :=ou_exlusif(gauche, mot64) ;
droit :=ou_exlusif(droit, decalage_gauche(mot64, 2)) ;
mot64 := et_logique(ou_exlusif(decalage_droit(droit, 8), gauche), en_hexa(00ff00ff)) ;
gauche := ou_exlusif(gauche, mot64) ;
droit := ou_exlusif(droit, decalage_gauche(mot64, 8)) ;
droit :=et_logique(ou_logique((decalage_gauche(droit, 1)), (et_logique(decalage_droit
(droit, 3 1), 1))),en_hexa (ffffffff)) ;
mot64 := et_logique(ou_exlusif(gauche, droit), en_hexa (aaaaaaaa)) ;
gauche :=ou_exlusif (gauche, mot64) ;

4
 droit := ou_exlusif(droit,mot64) ;
gauche :=et_logique(ou_logique((decalage_gauche(gauche,1)),(et_logique(decalage_droit
(gauche, 31), 1))), en_hexa(ffffffff)) ;
Si nous suivons l’ordre de la permutation partig Pour la permutation finale c’est l’inverse des instructions
et partid nous arrivons a la permutation initiale selon les utilisées dans la permutation initiale :
instructions précédentes.

Instructions de la permutation finale

Droit := ou_logique((decalage_gauche (droit, 31)), (decalage_droit (droit, 1))) ;
Mot64 := et_logique(ou_exlusif(gauche, droit), en-hexa (aaaaaaaa)) ;
Gauche := ou_exlusif(gauche, mot64) ;
Droit := ou_exlusif(droit, mot64)
Gauche := ou_logique((decalage_gauche(gauche, 31)), (decalage_droit(gauche, 1))) ;
Mot64 := et_logique(ou_exlusif(decalage_droit(gauche, 8), droit), en_hexa (00ff00ff)) ;
Droit := ou_exlusif(droit, mot64) ;
Gauche := ou_exlusif(gauche(decalage_gauche(mot64, 8))) ;
Mot64 :=et_logique( ou_exlusif(decalage_droit(gauche, 2) , droit), en_hexa (33333333));
Droit := ou_exlusif(droit, mot64) ;
Gauche := ou_exlusif(gauche, decalage_gauche(mot64, 2)) ;
Mot64 := et_logique(ou-exlusif (decalage_droit(droit, 16), gauche), en_hexa (0000ffff)) ;
Gauche := ou_exlusif(gauche, mot64) ;
Droit := ou_exlusif(decalage_gauche(mot64, 16)) ;
Mot64 := et_logique(ou_exlusif(decalge_droit(droit, 4), gauche), en_hexa(0f0f0f0f)) ; Gauche := ou_exlusif(gauche,
mot64) ;
Droit := ou_exlusif(droit, decalage_gauche(mot64, 4)) ;
Ptr(bloc+1) : = droit ;
Ptr(bloc) : = gauche ;

II.1.1.5 - PROCEDURE GENERALE DU Dans le des il y a 16 rondes. ainsi la fonction

DES ( QUI CONTIENT LES 16 RONDES ) générale qui combine les sous clefs avec le bloc de
données est réalisée selon les instructions suivantes :
PROCEDURE GENERALE_DU_DES
Pour tour variant de 0 a 8 faire
Début
Mot64 := ou_logique((decalage_gauche(droit , 28)) , (decalage_droit(droit,4))) ;(*)
Mot64 := ou_exlusif(droit, ptr(clef + 1) ) ;
Valeur := table-7 [ et_logique(mot64, en_hexa(3f))] ;
Valeur := ou_logique(valeur, table-5 [et_logique(decalage_droit(mot64, 8), en_hexa(3f))]) ;
Valeur :=ou_logique(valeur, table-3 [et_logique(decalage_droit(mot64, 16), en_hexa(3f))]) ;
Valeur :=ou_logique (valeur, table-1[et_logique(decalage_droit(mot64, 24), en_hexa(3f))]) ;
Mot64 := ou_exlusif(droit, ptr(clef + 1) ) ;
Valeur :=ou_logique(valeur, table-8 [et_logique(mot64, en_hexa(3f))] );
Valeur := ou_logique(valeur, table-6 [et_logique(decalage_droit(mot64, 8), en_hexa(3f))]) ;
Valeur :=ou_logique(valeur, table-4 [et_logique(decalage_droit(mot64, 16), en_hexa(3f))]) ;
Valeur :=ou_logique(valeur, table-2 [et_logique(decalage_droit(mot64, 24), en_hexa(3f))]) ;
Gauche :=ou_exlusif (gauche, valeur) ;
Mot64 :=ou_logique((decalage_gauche(droit, 28)), (decalage_droit(droit, 4))) ; (*)
Mot64 := ou_exlusif(gauche, ptr(clef + 1) ) ;
Valeur := table-7 [ et_logique(mot64, en_hexa (3f))] ;
Valeur :=ou_logique(valeur, table-5 [et_logique(decalage_droit(mot64, 8), en_hexa(3f))] ) ;
Valeur :=ou_logique(valeur, table-3 [et_logique(decalage_droit(mot64, 16), en_hexa(3f))]) ;
Valeur :=ou_logique(valeur, table-1 [et_logique(decalage_droit(mot64, 24), en_hexa(3f))]) ;
Mot64 := ou_exlusif(gauche, ptr(clef + 1) ) ;
Valeur := ou_logique(valeur, table-8 [et_logique(mot64, en_hexa (3f))]);
Valeur :=ou_logique(valeur, table-6 [et_logique(decalage_droit(mot64, 8), en_hexa(3f))] ) ; Valeur
:=ou_logique(valeur, table-4 [et_logique(decalage_droit(mot64, 16), en_hexa(3f))]) ;
Valeur :=ou_logique(valeur, table-2 [et_logique(decalage_droit(mot64,24), en_hexa(3f))]) ;
Droit := ou_exlusif(droit, valeur) ;
Fin

5
 II.1.1.6 - LA PERMUTATION EXPANSIVE
Nous rappelons que cette permutation fait Dans la partie de la réalisation des permutations initiale
passer un mot de 32 bits en 48 bits. on obtient la partie ‘’droit’’. Cette partie est permutée
selon l’ordre suivant [7] :

Bloc droit : 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

En utilisant l’instruction (*) dans la procédure générale on trouve le résultat suivant :

19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 32 31 30 29 28 27 26 25 24 23 22 21 20

Donc cette permutation est la permutation l’un par l’inverse du second et combiner le résultat par
expansive, elle sera combinée par un ou exclusif avec un ‘’et logique’’ du troisième ) [8] .
les sous clefs du DES ( ‘’Data Encryption Standard ‘’).
En dépit de toutes ces années le DES reste le II.3 – RC code « Rivest’s Code » RC 5
standard le plus solide et le plus résistant aux attaques
cryptographiques. II.3.2 - Implémentation du RC5
Les algorithmes à chiffrement par blocs ne se L’algorithme RC5 est un algorithme
résument pas qu’au DES, il en existe plusieurs : ceux redoutable avec que sa taille de clef de 128 bits ;il
qui ont été inventés il y a plusieurs années et qui ont été chiffre plus rapidement que le DES . Sa réalisation est
cassés et ceux qui résistent toujours parce-qu’ils n’ont directe. De sa description nous pouvons écrire les
pas été cryptanalysés assez ou , au contraire , ils ont été fonctions de chiffrement, déchiffrement et initialisation
classés comme résistants. des sous-clefs [11] .

Cependant nous avons sélectionné parmi plusieurs Mot32 est un type de 32 bits.
algorithmes les 3 suivants :
• 3 WAY Constante
• RC5
• IDEA m := 32 de type entier { taille du mot en bits }
r := 12 de type entier { nombre de rondes }
D’une part ces algorithmes sont assez rapides en b := 16 de type entier { taille de la clef en octets soit
chiffrement et en déchiffrement et d’autre part, ils ont 16x8 =128 bits }
été inventés par les plus forts cryptanalyste du monde. c := 4 de type entier { nombre de mots dans la clef }
t := 26 de type entier { taille de la table-S soit 2*(r+1) }
II.2 - L’ algorithme 3-WAY
3-WAY est un algorithme de chiffrement par variable
blocs conçu par Joan Daemen. Il utilise des blocs et
une clef de même taille : 96 bits ; il est conçu pour être S[t] : tableau de Mot32;
efficace en réalisation matérielle.3-WAY n’est pas un P:=(b7e15163)16, Q:=(9e3779b9)16 de type Mot32; {
réseau de FEITEL mais un algorithme de chiffrement constantes de l’algorithme }
itératif. 3-WAY peut comprendre n rondes ; Daemen
en conseille 11. La procédure de chiffrement

II.2.1 - Implémentation de l’algorithme 3 procédure RC5_CHIFFRER(Mot32 ptr^.tcl, Mot32

WAY ptr^.tchi);
debut
Cet algorithme manipule des blocs de 96 bits avec var
une clef de taille égale. i, A:=tcl[0]+S[0], B:=tcl[1]+S[1] : de type Mot32;
Les fonctions qu’il utilise sont les suivantes :
- theta(X) est une fonction de substitution linéaire-en pour i allant de 1 à r faire
substance, un mélange de décalages circulaires et de ou début
exclusifs. A := décalage_circulaire_gauche(ou_exclusif(A,B),B)
- Pi_1(X) et Pi_2(X) sont des permutations simples. ( + S[2*i];
Nous avons utilisé des permutations circulaires de 10 et B := décalage_circulaire_gauche(ou_exclusif(B,A),A)
de 1 l’une l’inverse de l’autre ). + S[2*i+1];
- gamma(x) est une fonction de substitution non linéaire.
( une telle fonction est facile à réaliser, nous pouvons fin;
combiner par exemple par un ou exclusif les 3 mots , tchi[0]:=A; tchi[1]:=B;
fin;

6
 La procédure de déchiffrement assez récent 1992, aucune cryptanalyse définitive ne
peut être donnée à ce jour. Les concepteurs d’IDEA
procédure RC5_DECHIFFRER(Mot32 ptr^.tchi, l’ont conçu à ce qu’il soit immune à la cryptanalyse
Mot32 ptr^.tcl); différentielle. Le cryptanalyste Lai prétend en donnant
début des indices probants mais pas une preuve qu’IDEA est
var immune à la cryptanalyse différentielle après seulement
i, B:=tchi[1], A:=tchi[0]: de type Mot32; 4 de ses 8 rondes. Et d’après Eli Biham, l’attaque à texte
corrélé ne marche pas contre l’IDEA .
pour i allant de r à 1 pas (-1) faire Joan Daemen a découvert une classe de clefs
début faibles pour IDEA. Ces clefs sont faibles au sens où si
B := ou_exclusif(decalage_circulaire_droite(B- elles sont utilisées, un attaquant peut facilement les
S[2*i+1], A),A); identifier avec une attaque à texte en clair choisi.
A := ou_exclusif(decalage_circulaire_droite(A-S[2*i], Voici, cette classe de clefs faibles (en hexadécimal) :
B),B);
fin; 0000 0000 0X00 0000 0000 000X XXXX
tcl[1]:=B-S[1]; tcl[0]:=A-S[0]; X0000
fin;
où X pouvant être n’importe quel chiffre en
La procédure d’initialisation des sous-clefs hexadécimal.
L’avenir de l’IDEA est prometteur, mais pour
procédure RC5_INITIAL(ptr^.K : d’un octet); le moment les gens sont assez subtils et ainsi préfèrent
début garder un œil sur les nouvelles méthodes de
var cryptanalyse qui peuvent être faites sur l’algorithme.
i, j, k, u:=m/8, A, B, L[c] : Mot32;
L[c-1] :=0 ; II.4.3 - Implémentation de l’IDEA
pour i allant de (b-1) à –1 pas (-1) faire
L[i/u]:= decalage_gauche(L[i/u],8) + K[i]; Peut être l’algorithme le plus sûr de part sa
S[0]:=P; popularité ; sa réalisation logicielle est nettement plus
pour i allant de 1 à t faire difficile que le RC5 bien que les opérations qu’il utilise
S[i]:=S[i-1]+Q; sont assez faciles.
Dans cet algorithme il n’y a pas de table-S mais
A:=B:=i:=j:=k:=0; l’opération ‘‘multiplication modulo 216 +1’’ fait d’elle
pour k allant de 1 à 3*t faire une méthode similaire aux tables .
debut Remarque :
i:=(i+1) modulo t; Comme tout algorithme à clef secrète, IDEA
j:=(j+1) modulo c; comporte une classe de clefs faibles !
A := S[i] := décalage_gauche(S[i]+(A+B),3); Si cette clef est utilisée, la combinaison par ou exclusif
B := L[i] := de deux textes en clair donne la combinaison par ou
décalage_gauche(L[j]+(A+B),(A+B)); exclusif des deux textes chiffrés résultants.
fin ; Mais avec une petite modification d’IDEA,
fin; l’algorithme peut ne pas engendrer ce type de clef ; pour
cela nous devons combiner par ou exclusif chaque clef
II.4- IDEA avec la valeur 0DAE en hexadécimal.

II.4.1 -Vitesse d’IDEA BIBLIOGRAPHIE

Les réalisations actuelles d’IDEA sont presque aussi
rapides que le DES. [1] Cryptographie appliquée. 2ième édition. Auteur : Bruce
SCHNEIER
Traduction en langue France par Laurent Viennot
II.4.2 - Cryptanalyse d’IDEA International Thomson Publishing France 1996.
La longueur de clef d’IDEA est de 128 bits - [2] Les dix premières années de la cryptographie à clef publique.
plus du double de celle du DES. En faisant l’hypothèse Edition 1988.
[3] A Method for Obtaining Digital Signatures and Public-Key
que l’attaque exhaustive est la plus efficace, il faudrait
Cryptosystems. Communications of the ACM, Edition 1978.
2128( ≈ 1038) chiffrements pour retrouver la clef. Nous [4] Compression et cryptage des données.
pouvons la comparer à une machine qui contiendrait une Par Xavier MARSAULT 1995.
puce si elle peut exister, tel qu’elle peut tester un [5] Cryptologie contemporaine. Par Claude GAUTIER
milliard de clefs par seconde et une machine regroupant Paris Masson 1992.
[6] Sécurité INTERNET pour l’entreprise Edition : Thomson 1997
un milliard de cette puce à la tâche ; cela prendra 1013 Auteurs : Snish B. Bhimani et Terry Bernteen
années. [7] Paiement numérique sur l’Internet
Ainsi, l’attaque exhaustive ne nous permettra Edition Thomson Paris 1997 Auteurs : Pierre Bresse, Guillaume
pas d’avancer avec l’IDEA. Vu que l’algorithme est Beure Dangere et Stephanie Thaillier
[8] La sécurité des ordinateurs . Michael Alexander. Thompson 1997.

View publication stats