Faculté des Sciences et des Techniques

Université de Rouen
Master 2 ITA

Cryptographie
2004-2005

Courbes Elliptiques
Implémentation de la Signature Électronique

Samuel G RAU
<samuel.grau@club-internet.fr>
 Table des matières

Introduction 4

1 Corps Finis 5
1.1 A la recherche de Corps Finis . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Opérations sur les corps . . . . . . . . . . . . . . . . . . 6
1.1.2 Existence et unicité . . . . . . . . . . . . . . . . . . . . . 6
1.1.3 Corps binaires . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 Opérations sur les corps binaires . . . . . . . . . . . . . . . . . . 8

2 Introduction aux Courbes Elliptiques 9

2.1 Courbes Elliptiques . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Loi de groupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Addition et Multiplication de points . . . . . . . . . . . . . . . . 13
2.3.1 Algorithmes de base d’addition, négation et doublement . 14
2.3.2 Algorithmes de base de multiplication . . . . . . . . . . . 15

3 ECDSA 17
3.1 Elliptic Curve Discrete Logarithm Problem . . . . . . . . . . . . 17
3.2 Génération de clefs . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Schéma de signature . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 ECDSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4 Implémentation et Optimisations 23
4.1 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.1 Description des classes . . . . . . . . . . . . . . . . . . . 23
4.2 Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.2.1 Coordonnées projectives . . . . . . . . . . . . . . . . . . 26
4.2.2 Multiplication de points inconnus . . . . . . . . . . . . . 28
4.2.3 Représentation Non Adjacent Form (NAF) . . . . . . . . 29

2
Conclusion 32

A Manuel 34
A.1 Installation et compilation . . . . . . . . . . . . . . . . . . . . . 34
A.1.1 Compilation . . . . . . . . . . . . . . . . . . . . . . . . 34
A.1.2 Installation . . . . . . . . . . . . . . . . . . . . . . . . . 34
A.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

B Code des en-têtes de classes utilisées 36

B.1 ECDomainParameters . . . . . . . . . . . . . . . . . . . . . . . . 36
B.2 ECSignature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
B.3 ECBFEquation . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
B.4 ECMessage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
B.5 ECKeyPair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
B.6 ECPoint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
B.7 ECDSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
B.8 ECPPoint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
B.9 ECNAF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

3
 Introduction

L’étude des courbes elliptiques remonte au milieu du XIXe siècle. Après

la découverte en 1984 d’un algorithme permettant la factorisation de ces
objets particuliers, cette découverte poussa le chercheurs à examiner l’ap-
plication des courbes elliptiques en cryptographie et théorie des nombres.

L’intérêt de telles courbes en cryptographie est que celles-ci permettent

d’atteindre les niveaux de sécurité désirés en utilisant des clef de plus petite
taille que celles utilisées avec RSA par exemple. Il est accepté qu’une clef
de courbe elliptique de 160 bits fourni le même niveau de sécurité qu’une
clef RSA de 1 024 bits. L’intérêt réel d’une clef de taille moindre inclue des
vitesses de calculs plus importantes, de l’espace nécessaire moins impor-
tant et une utilisation efficace de la puissance de cryptage.

Nous serons donc nous mener à traiter un ensemble particulier de

courbes elliptiques sur lequel l’utilisation d’un ordinateur offre des résultats
de performances convenables. Nous y étudierons dans un premier temps
la structure servant de support aux courbes, à savoir les corps finis. Puis,
après l’exploration des courbes et de leur représentation, nous étudierons
l’application de celles-ci à la signature électronique de documents au tra-
vers du schéma de signature ECDSA (Elliptic Curve Digital Signature Algo-
rithm). Celui-ci nous amènera à se pencher sur les gains d’implémentations
pouvant être obtenus ainsi que les performances résultantes.

4
 C HAPITRE 1

Corps Finis

Notre étude commence donc par celle du support des courbes el-
liptiques. L’implémentation efficace des corps finis devient donc un point
très important dans l’étude des courbes elliptiques car un grand nombre
d’opérations y seront réalisées. Il existe trois grands types de corps finis
qui sont utilisables pour l’implémentation de la cryptographie par courbes
elliptiques. Il s’agit des corps premiers, des corps binaires et des corps
d’extension optimaux.

Nous porterons toute notre attention dès à présent au deuxième type

de corps, les corps binaires, ceux-ci offrant une représentation très proche
de celle utilisée par les ordinateurs.

1.1. A la recherche de Corps Finis

Les corps sont des objets abstraits représentants des systèmes de nombre bien
connus (tels que les nombres rationnels Q ou les nombre réels R et les nombres
complexes C).

Ils consistent en un ensemble F possédant deux opérations élémentaires, l’addi-

tion (notée +) et la multiplication (notée ·), satisfaisant les propriétés arithmétiques
habituelles :

(i) (F , +) est un groupe abélien (avec l’addition) et l’élément neutre est 0.

(ii) (F \{0}, ·) est un groupe abélien (avec la multiplication) et où l’élément
neutre est 1.
(iii) La loi distributive est respectée : (a + b) · c = a · c + b · c pour tout a, b, c ∈ F .

Si l’ensemble F est fini, alors, le corps est dit fini.

5
 Nous allons présenter brièvement quelques propriétés et opérations sur les
corps finis. Les corps premiers, bien qu’importants seront moins détaillés que les
corps binaires, ceux-ci offrant comme nous l’avons déjà dit, de bien meilleurs per-
formances.

1.1.1 Opérations sur les corps

Un corps F est équipé de deux opérations, l’addition et la multiplication. La
soustraction des éléments du corps se définit par rapport à l’addition. Soit a, b ∈ F ,
a − b = a + (−b) où b est l’unique élément tel que b + (−b) = 0 (On appelle
−b la négation de b). De manière similaire, nous pouvons définir la division des
éléments du corps qui se définit en terme de multiplication. Soit a, b ∈ F , avec
b 6= 0, a/b = a · b−1 où b−1 est l’unique élément de F tel que b · b−1 = 1. (On
appelle b−1 l’inverse de b).

Nous verrons par la suite qu’il ne nous sera pas utile de mettre en oeuvre toutes
les opérations sur les corps. Pour cela, nous utiliserons une bibliothèque permettant
de faire de la théorie des nombres, qui se nomme NTL et dont nous détaillerons les
possibilités offertes par la suite.

1.1.2 Existence et unicité

L’ordre d’un corps fini est le nombre d’éléments présents dans ce corps. Il
existe un corps fini d’ordre q si et seulement si q est la puissance d’un nombre
premier, i.e., q = pm où p est un nombre premier appelé la caractéristique de F , et
où m est un entier positif. Si m = 1 alors F est appelé un corps premier. Si m ≥ 2,
alors F est appelé un corps d’extension.

Pour toute puissance première q, il y a essentiellement un unique corps premier

d’ordre q ; informellement parlant, ceci signifie que si l’on prend deux corps pre-
miers d’ordre q, ceux-ci sont structurellement identique au renommage près des
étiquettes utilisées pour représenter les éléments du corps. On dit que deux tels
corps d’ordre q sont alors isomorphes et on note un tel corps Fq .

1.1.3 Corps binaires

Les corps finis d’ordre 2m sont appelés des corps binaires, car ils sont à coef-
ficient dans {0, 1}. Une manière de construire F2m est d’utiliser une représentation
basée sur les polynômes. De cette manière, les éléments de F2m sont des polynômes
binaires (polynômes dont les coefficients appartiennent au corps F2 = {0, 1}) de
degré au plus m − 1 :

F2m = am−1 zm−1 + am−2 zm−2 + · · · + a2 z2 + a1 z1 + a0 z0 | ai ∈ {0, 1}



6
 Un polynôme binaire irréductible f (z) de degré m est choisi. Un tel polynôme
existe pour tout m et peut-être efficacement trouvé. L’irréductibilité de f (z) signifie
en fait que f (z) ne peut pas être factorisé comme un produit de polynômes binaires,
chacun de degré inférieur à m. Autrement dit, contrairement aux corps premier, ici
ce n’est pas la caractéristique mais le polynôme qui joue le rôle de nombre premier.
Son irréductibilité le place à la même position.

L’addition des éléments du corps est l’addition usuelle des polynômes, où est
utilisée l’arithmétique modulo 2 des coefficients. La multiplication des éléments
du corps est réalisée modulo le polynôme de réduction f (z). Pour tout polynôme
binaire a(z), a(z) mod f (z) doit représenter l’unique polynôme résiduel r(z) de
degré inférieur ou égal à m, obtenu après une longue division de a(z) par f (z) ;
cette opération est appelée réduction modulo f (z).
Exemple 1.1.1 (Corps binaire F24 ). Les éléments de F24 sont les 16 polynômes
binaires de degré au plus 3 :

0 z2 z3 z3 + z2
1 z2 + 1 z3 + 1 z3 + z2 + 1
z z2 + z z3 + z z3 + z2 + z
z+1 z2 + z + 1 z3 + z + 1 z3 + z2 + z + 1
Ce qui suit est un ensemble d’exemple d’opérations arithmétiques opérées sur
le corps binaire F24 en utilisant le polynôme f (z) = z4 + z + 1 comme polynôme de
réduction.
(i) Addition :
(z3 + z2 + 1) + (z2 + z + 1) = z3 + z
(ii) Soustraction :
(z3 + z2 + 1) − (z2 + z + 1) = z3 + z
On peut remarquer que puisque −1 = 1 dans F2 , on a −a = a pour tout
a ∈ F 2m .
(iii) Multiplication :
(z3 + z2 + 1) · (z2 + z + 1) = z2 + 1
puisque
(z3 + z2 + 1) · (z2 + z + 1) = z5 + z + 1
et que
(z5 + z + 1) mod (z4 + z + 1) = z2 + 1
(iv) Inversion :
(z3 + z2 + 1)−1 = z2
puisque
(z3 + z2 + 1) · z2 mod (z4 + z + 1) = 1

7
1.2. Opérations sur les corps binaires
L’implémentation des opérations sur les corps binaires demande un grand jeu
de fonction, allant de la représentation et des opérations de base sur le corps à des
fonctions bien plus complexes.

L’intérêt aurait pu être de réaliser cette implémentation. Cependant, nous avons

utilisé pour l’implémentation, une bibliothèque de multiprécision intitulée NTL.

NTL une librairie écrite en C++, portable et hautement performante, fournissant

des structures de donnée et algorithmes permettant de manipuler des entiers signés
de longueur arbitraire, des vecteurs, matrices et polynômes sur les entiers et les
corps finis. Autrement dit, cette bibliothèque ne peux pas tomber mieux.

Cette bibliothèque nous offrira donc tous les outils nécessaires afin de réaliser
des additions, multiplications, inversions ou toute autre opération qui pourrait être
utile à l’implémentation d’un programme de chiffrement de signature électronique
pour les courbes elliptiques.

8
 C HAPITRE 2

Introduction aux Courbes

Elliptiques

Un point important de la cryptographie par courbes elliptiques est l’uti-

lisation de ces courbes. Celles-ci possèdent des propriétés que nous ten-
terons de mettre en évidence après avoir apporté une description de ces
courbes.

Après une petite mise en bouche, nous verrons comment passer d’un
point à un autre sur une courbe et les possibilités de calculs qui nous sont
offertes. Ces possibilités sont l’addition, la multiplication par un scalaire, le
calcul de l’opposé d’un point d’une courbe et le calcul du point à l’infini.

2.1. Courbes Elliptiques

Définition 2.1.1. Une courbe elliptique E sur un corps K est définie par une
équation de la forme :

E : y2 + a1 xy + a3 y = x3 + a2 x2 + a4 x + a6 (2.1)

Où a1 , a2 , a3 , a4 , a5 , a6 ∈ K et ∆ 6= 0, où ∆ est le descriminant de E et est défini

de la manière suivante :

∆ = −d22 d8 − 8d43 − 27d62 + 9d2 d4 d6



d2 = a21 + 4a2




d4 = 2a4 + a1 a3 (2.2)
d6 = a3 + 4a62 



d8 = a21 a6 + 4a2 a6 − a1 a3 a4 + a2 a23 − a24


Si L est est une extension du corps K, alors l’ensemble des points L-rationnels
de E est l’ensemble suivant où ∞ est le point à l’infini :

9
 E(L) = (x, y) ∈ L2 | y2 + a1 xy + a3 y − x3 − a2 x2 − a4 x − a6 = 0 ∪ {∞}


Nous pourrions apporter les remarques suivantes. En fait, l’équation (2.1) est
appelée une équation de Weierstrass. On dit que E est défini sur K pour la rai-
son que les coefficients a1 , a2 , a3 , a4 , a5 , a6 qui définissent cette équation sont des
éléments de K. Nous pouvons aussi ajouter que le faite que ∆ 6= 0 assure que la
courbe obtenue est « lisse ». Ceci étant, la courbe ne possédant aucun point ayant
deux ou plus de tangentes. Le point ∞ est le seul point de la courbe à l’infini qui
satisfait la forme projective de l’équation de Weierstrass.
y
4
y
2

2
1

0 2 x −1 0 1 2 x

−1
−2

−2

(a) E1 : y2 = x3 − x (b) E2 : y2 = x3 + 14 x + 54

F IG . 2.1 – Courbes Elliptiques sur R.

Exemple Nous pouvons alors prendre l’exemple des courbes elliptiques sur R en
considérant les deux courbes suivantes :
E1 : y2 = x3 − x
1 5
E2 : y2 = x3 + x +
4 4
définies sur le corps des nombres réels R. Les points E1 (R)\{∞} et E2 (R)\{∞}
sont affichés Figure 2.1.

L’équation de Weierstrass possède une version simplifiée.

Définition 2.1.2. Deux courbes elliptiques E1 et E2 définies sur K et données par
les équations de Weierstrass :

10
 E1 : y2 + a1 xy + a3 y = x3 + a2 x2 + a4 x + a6
E2 : y2 + a1 xy + a3 y = x3 + a2 x2 + a4 x + a6
sont dites isomorphes sur K si il existe u, r, s,t ∈ K avec u 6= 0 tel que le chan-
gement de variables
(x, y) 7→ u2 x + r, u3 y + u2 sx + t

transforme l’équation E1 en l’équation E2 . Cette transformation est appelée un

changement admissible de variables.
Parmis tous les changements de variables, selon les différents cas possibles et
considérés, nous pourrons avoir des courbes dites supersingulières qu’il n’est pas
judicieux d’utiliser en cryptographie par courbes elliptiques. Nous ne traiterons
que le cas des équations simplifiées pour le cas où K est de caractéristique 2 car
c’est celui des corps binaires.

Si l’on considère l’équation de Weierstrass

E : y2 + a1 xy + a3 y = x3 + a2 x2 + a4 x + a6
définie sur K, celle-ci peut-être fortement simplifiée en appliquant un changement
admissible de variables. L’équation simplifiée pour notre cas, sera utilisée durant
tout le reste de cette étude. Considérons donc le cas où le corps sous-jacent K est
de caractéristique 2.

Si la caractéristique du corps K est 2, il faut alors considérer deux cas distincts.

Si a1 6= 0, alors, le changement admissible de variables
!
2 a3 3 a21 a4 + a23
(x, y) 7→ a1 x + , a1 y +
a1 a31

transforme E en la courbe
y2 + xy = x3 + ax2 + b
où a, b ∈ K. Une telle courbe est dite non-supersingulière et possède un discrimi-
nant ∆ = b. Si a1 = 0, alors, le changement admissible de variables
(x, y) 7→ (x + a2 , y)
transforme E en la courbe
y2 + cy = x3 + ax2 + b
Une telle courbe est dite supersingulière et possède un discriminant ∆ = a4 .

11
2.2. Loi de groupe
Nous venons de voir que l’équation de Weierstrass peut-être agréablement sim-
plifiée pour l’utilisation d’un corps binaire. Mais à quoi cela va-t-il bien pouvoir
nous servir si nous ne sommes pas en mesure d’effectuer des opérations sur cette
courbe ? Nous allons donc traiter la mécanique des éléments des courbes ainsi
considérées.

Soit E une courbe elliptique définie sur K. Il existe une règle corde-et-tangente
pour additionner deux points de E(K) pour donner un troisième point appartenant,
lui aussi à E(K). Du coup, nous « fermons » la courbe. En effet, E(K) forme alors
un groupe abélien avec ∞ servant d’élément neutre. C’est ce groupe que nous uti-
liserons pour construire le système cryptographique basé sur courbes elliptiques.

L’addition de deux points est mieux expliquée géométriquement. Soit P =

(x1 , y1 ) et Q = (x2 , y2 ) deux points distincts d’une courbe elliptique E. Alors, la
somme R de P et de Q est définie de la manière suivante. On commence par dessi-
ner une ligne passant par les points P et Q ; cette ligne intersecte la courbe elliptique
en un troisième point. Enfin, R est la réflexion de ce point par rapport à l’axe des x,
ce qui est expliqué Fig. 2.2 (a).

Le double R de P est défini de la manière suivante. On commence par dessiner

la tangente au point P. Cette ligne intersecte alors la courbe en un deuxième point,
dont on prend l’image par réflexion par rapport à l’axe des x, ce qui est expliqué
Fig. 2.2 (b).

y y

Q = (x2 , y2 ) P = (x1 , y1 )

0 x 0 x

P = (x1 , y1 )

R = (x3 , y3 ) R = (x3 , y3 )

(a) Addition : P + Q = R (b) Doublement : P + P = R

F IG . 2.2 – Addition et doublement géométrique des points d’une courbe elliptique.

12
 Sachant que nous savons maintenant sur quel type support vont reposer nos
courbes et par conséquent, tout notre système cryptographique, intéressons-nous
aux moyen de les mettre en œuvre.

2.3. Addition et Multiplication de points

Nous allons maintenant traiter les formules pour les courbes elliptiques qui
sont non-supersingulières E et de la forme y2 + xy = x3 + ax2 + b en coordonnées
affines sur K = F2m . Voici donc, la loi de groupe correspondante :

Loi de groupe (non-supersingulière) E/F2m : y2 + xy = x3 + ax2 + b

1. Identité. P + ∞ = ∞ + P = P pour tout P ∈ E(F2m )
2. Négation. Si P = (x, y) ∈ E(F2m ), alors (x, y) + (x, x + y) = ∞. On note −P
le point (x, x + y) et on l’appelle le négatif de P ; on peut remarquer que −P
est un point de E(F2m ) et que −∞ = ∞.
3. Addition. Soit P = (x1 , y1 ) ∈ E(F2m ) et Q = (x2 , y2 ) ∈ E(F2m ) où P 6= ±Q.
Alors, P + Q = (x3 , y3 ) où
x3 = λ 2 + λ + x1 + x2 + a et y3 = λ (x1 + x3 ) + x3 + y1
avec λ = (y1 + y2 )/(x1 + x2 ).
4. Doublement. Soit P = (x1 , y1 ) ∈ E(F2m ), où P 6= −P. Alors 2P = (x3 , y3 ),
avec,
b
x3 = λ 2 + λ + a = x12 + 2 et y3 = x12 + λ x3 + x3
x1
avec λ = x1 + y1 /x1 .

Exemple de courbe elliptique non-singulière sur F24 On considère le corps

fini F24 tel que représenté par le polynôme de réduction f (z) = z4 + z + 1. Un
élément a3 z3 + a2 z2 + a1 z + a0 ∈ F24 est représenté par la chaı̂ne de bits (a3 a2 a1 a0 )
de longueur 4 ; par exemple (0101) représente z2 + 1. Soit a = z3 , b = z3 + 1, et
considérons la courbe elliptique non-singulière
E : y2 + xy = x3 + z3 x2 + (z3 + 1)
définie sur F24 . Les points de E(F24 ) sont alors les suivants :
∞ (0011, 1100) (1000, 0001) (1100, 0000)
(0000, 1011) (0011, 1111) (1000, 1001) (1100, 1100)
(0001, 0000) (0101, 0000) (1001, 0110) (1111, 0100)
(0001, 0001) (0101, 0101) (1001, 1111) (1111, 1011)
(0010, 1101) (0111, 1011) (1011, 0010)
(0010, 1111) (0111, 1100) (1011, 1001)

13
2.3.1 Algorithmes de base d’addition, négation et doublement
Bien que ces algorithmes soient très simples à utiliser et à implémenter, nous
les présentons afin de montrer que lorsque nous arriverons dans la section 4.2 les
gains en temps de calculs seront plus visibles.

Le premier algorithme est celui de l’addition dont nous avons pu apercevoir le

fonctionnement au travers de la définition de la courbe elliptique étudiée jusqu’à
présent.

F IG . 2.3 : Addition basique de deux points

Entrées : P = (x1 , y1 ) et Q = (x2 , y2 ) qui appartiennent à E(F2m ).
Sorties : R = P + Q = (x3 , y3 ) ∈ E(F2m ).
début
X ← x1 + x2 ;
y1 + y2
λ← ;
X
x3 ← λ + λ + X + a;
2

y3 ← λ (x1 + x3 ) + x3 + y1 ;
retourner (x3 , y3 );
fin

L’algorithme suivant correspond au cas où il est nécessaire de doubler un point.

Il y deux cas possibles d’après la définition précédente. Nous utiliserons celle fai-
sant intervenir le coefficient a car elle fait intervenir par la même occasion la valeur
λ . Le calcul de λ demande une inversion. Si l’on utilise la version avec le coef-
ficient b, nous ajoutons une inversion supplémentaire, qui, rappelons-le est une
opération assez coûteuse dans notre cas.

F IG . 2.4 : Doublement basique d’un point

Entrées : P ∈ E(F2m ).
Sorties : 2P ∈ E(F2m ).
début
y1
λ ← x1 + ;
x1
x3 ← λ 2 + λ + a;
y3 ← λ x12 + λ x3 + x3 ;
retourner (x3 , y3 );
fin

Avant de conclure par l’algorithme général d’addition évitant les cas que nous
dirons, problématiques, nous voyons l’algorithme le plus simple. Il s’agit de celui
de la négation d’un point P de E(F2m ).

14
 F IG . 2.5 : Négation d’un point
Entrées : P(x1 , y1 ) ∈ E(F2m ).
Sorties : −P ∈ E(F2m ).
début
x1 ← x1 ;
y1 ← x1 + y1 ;
retourner (x1 , y1 );
fin

Il ne nous reste plus qu’à combiner ces algorithmes en gérant les cas particu-
liers afin de bien composer les calculs et éviter les calculs inutiles envoyant les
points à l’infini ou hors de la courbe.

F IG . 2.6 : Addition propre de base

Entrées : P = (x1 , y1 ) et Q = (x2 , y2 ) qui appartiennent à E(F2m ).
Sorties : R = P + Q = (x3 , y3 ) ∈ E(F2m ).
début
si (P = ∞) alors
retourner Q;
finsi
si (Q = ∞) alors
retourner P;
finsi
si P =Négation( Q) alors
retourner ∞;
finsi
si P = Q alors
retourner Doublement base( P) ;
sinon
retourner Addition base( P) ;
finsi
fin

Il reste cependant un point important et incontournable. Il s’agit de celui de

la multiplication d’un point par un entier. Les algorithmes de signature effectuent
cette opération si souvent que c’est à se demander si la cryptographie ne repose pas
essentiellement sur cette opération.

2.3.2 Algorithmes de base de multiplication

Nous allons être amené à considérer deux méthodes très proches permettant de
calculer kP, où k est un entier positif et où P est un point de la courbe elliptique E
sur un corps F2m .

Ce sont donc deux algorithmes simples que nous allons voir. Ces algorithmes

15
ne sont que les représentations additives des algorithmes utilisés pour l’exponen-
tiation. L’algorithme Fig. 2.7 effectue l’opération en traitant les bits de k de gauche
à droite alors que l’algorithme Fig. 2.8 les traite de droite à gauche.

L’intérêt des deux méthodes est certains et nous verrons les complexités résul-
tantes ainsi que les résultats de performance obtenus en section 4.2.

F IG . 2.7 : Méthode binaire de multiplication droite/gauche.

Entrées : k = (kt−1 , . . . , k1 , k0 )2 et P ∈ F2m .
Sorties : kP.
début
Q ← ∞;
pour i de 0 à t − 1 faire
si ki = 1 alors
Q ← Q + P;
finsi
P ← 2P;
finpour
retourner Q;
fin

F IG . 2.8 : Méthode binaire de multiplication gauche/droite.

Entrées : k = (kt−1 , . . . , k1 , k0 )2 et P ∈ F2m .
Sorties : kP.
début
Q ← ∞;
pour i de t − 1 à 0 faire
Q ← 2Q;
si ki = 1 alors
Q ← Q + P;
finsi
finpour
retourner Q;
fin

16
 C HAPITRE 3

ECDSA

Définir un support mathématique basé sur les corps fini est une chose,
mais définir l’objet qui reposera sur ce support en est une bien plus im-
portante. C’est donc dans ce chapitre que nous introduirons de nouvelles
notions qui permettrons de finaliser la mise en place de ce système cryp-
tographique basé sur les courbes elliptiques.

Un tel système est-il sûr, cryptographiquement parlant ? Au travers

du problème du logarithme discret étendu aux courbes elliptiques, nous
tenterons de démontrer cette sécurité. Seront ensuite présentés tous les
éléments et algorithmes permettant d’implémenter un tel système. Enfin,
seront exposés les algorithmes, en pseudo-code, du schéma de signature
électronique utilisé, à savoir, ECDSA.

3.1. Elliptic Curve Discrete Logarithm Problem

L’intraçabilité de la solution au problème du logarithme discret étendu aux
courbes elliptiques est nécessaire pour tous les schémas cryptographiques utilisant
des courbes elliptique.

Le problème du logarithme discret pour les courbes elliptiques est le suivant.

Définition 3.1.1 (ECDLP). Étant donné une courbe elliptique E définie sur le
corps fini Fq , un point P ∈ E(Fq ) d’ordre n et un point Q ∈ hPi, trouver l’en-
tier l ∈ [0, n − 1] tel que Q = lP. L’entier l est appelé le logarithme discret de Q
en base P, noté l = logP Q.

Le fait que ce problème soit si difficile nous assure la sécurité attendue. Il faut
pour cela que les paramètres des courbes elliptiques pour les schémas cryptogra-
phiques soient judicieusement choisis afin de résister à toutes les attaques connues
sur l’ECDLP.

17
 L’algorithme le plus naı̈f est une recherche exhaustive de Q en calculant les va-
leurs successives P, 2P, 3P, 4P . . . jusqu’à ce qu’il soit rencontré. Avec la puissance
de calcul des ordinateurs actuels, le problème reste cependant infaisable dans le
temps.

Le problème est que grand nombre d’études ont eu lieu et certaines ont donné
de bons résultats. C’est pourquoi, nous devons absolument choisir des paramètres
pour la courbe qui puissent résister à toutes ces attaques. Nous allons voir dans
ce qui suit comment choisir ces paramètres. Pour un gain de temps, nous utilise-
rons des paramètres recommandés par le NIST (National Institute of Standards and
Technology).

Cette utilisation nous permet d’éviter d’avoir à générer par nous même des
paramètres de domaines ainsi que les algorithmes permettant leur validation. Nous
allons tout de même nous intéresser aux paramètres de domaine en donnant la
définition qui nous sera utile par la suite. Cette définition est des plus formelle et
nous n’utiliserons pas la totalité de ce qu’elle définie dans notre implémentation du
système cryptographique.
Définition 3.1.2 (Paramètres de domaines). Les paramètres de domaine D tels que
D = (q, FR, S, a, b, P, n, h) sont composés de :
1. L’ordre du corps q.
2. Une indication FR (représentation du corps) sur la représentation utilisée
pour les éléments de Fq .
3. Une graine S si la courbe elliptique a été générée aléatoirement.
4. Deux coefficients a, b ∈ Fq qui définissent l’équation de la courbe elliptique
E sur Fq (i.e., y2 = x3 + ax + b dans le cas d’un corps premier ou d’extension
optimal, et y2 + xy = x3 + ax3 + b dans le cas d’un corps binaire).
5. Deux éléments du corps xP et yP dans Fq qui définissent un point fini P =
(xP , yP ) ∈ E(Fq ) en coordonnées affines. P a un ordre premier et est appelé
le point de base.
6. L’ordre n de P.
7. Le cofacteur h = card(E(Fq ))/n.

3.2. Génération de clefs

La génération des clefs aussi bien publique que privées est un l’outil qui va
nous permettre « d’ouvrir et de fermer les verrous » du système cryptographique.

On associe un couple de clefs pour une courbe elliptique à des paramètres de

domaine particuliers D = (q, FR, S, a, b, P, n, h). La clef publique est un point Q
de la courbe elliptique choisi aléatoirement dans le groupe hPi généré par P. La

18
clef privée correspondante est d = logP Q. L’entité A qui génère le couple de clefs
doit être assuré que les paramètres de domaine sont valides. De plus, l’association
de paramètres de domaines et d’une clef publique doit être vérifiable par toutes les
entités qui pourraient, plus tard, être amener à utiliser la clef publique de l’entité
A. En pratique, cette association peut être obtenue à l’aide de moyens cryptogra-
phiques (e.g., l’autorité de certification génère un certificat qui atteste cette asso-
ciation) ou selon le contexte (e.g., toutes les entités utilisent les mêmes paramètres
de domaine).

F IG . 3.1 : Génération d’un couple de clefs.

Entrées : Paramètres de domaine D = (q, FR, S, a, b, P, n, h).
Sorties : Clef publique Q, clef privée d.
début
Choisir aléatoirement d ∈ [1, n − 1];
Calculer Q = dP;
retourner (Q, d);
fin

Désormais, nous possédons un outil permettant de générer un couple (Clef pu-

blique, Clef privée) que nous utiliserons lors de la signature de messages. Mais
comment être assuré de la validité de ces clefs conformément aux paramètres de
domaines utilisés. L’algorithme Fig. 3.2 permet d’assurer cette validité en accep-
tant ou rejetant une paire de clef en fonction des paramètres de domaine proposés.

F IG . 3.2 : Validation de clef publique.

Entrées : Paramètres de domaine D = (q, FR, S, a, b, P, n, h), Clef
publique Q.
Sorties : Acceptation ou rejet de la validité de la clef publique Q.
début
Vérifier que Q 6= ∞;
Vérifier que xQ et yQ sont bien représentés comme des éléments de F2m
(i.e., ce sont des chaı̂nes de bits de longueur m);
Vérifier que Q satisfait l’équation de la courbe elliptique définie par a et
b;
Vérifier que nQ = ∞;
si échec de l’une des vérification alors
retourner Clef non valide;
finsi
sinon
retourner Clef valide;
finsi
fin

19
3.3. Schéma de signature
Les schémas de signature ne sont rien d’autre que l’équivalent électronique de
la signature manuscrite. Il est possible d’en faire usage afin d’authentifier l’origine
ou l’intégrité des données. Les schémas de signature sont communément utilisées
par des autorités de confiance afin de signer des certificats qui relient entre eux,
une entité et sa clef public.

Définition 3.3.1 (Schéma de signature). Un schéma de signature se résume à

quatre algorithmes.
1. Un algorithme de génération de paramètres de domaines, qui génère un
ensemble D de paramètres de domaines.
2. Un algorithme de génération de clefs qui prend en entrée un ensemble D de
paramètres de domaine et génère un couple de clefs (Q, d)
3. Un algorithme de génération de signature qui prend en entrée un ensemble
D de paramètres de domaine, une clef privée d, et un message m, produisant
en sortie, une signature Σ.
4. Un algorithme de vérification de signature qui prend en entrée un ensemble
D de paramètres de domaine, une clef publique Q, et un message m, ainsi
qu’une signature Σ prétendue valable. Cet algorithme accepte ou rejette
alors la signature proposée.
Les paramètres de domaine D sont présumés valides et que la clef publique Q
est valide et associée à D. L’algorithme de vérification de signature accepte tou-
jours l’entrée (D, Q, m, Σ) à condition bien sûr que Σ a été généré par l’algorithme
de génération de signature avec (D, d, m) comme entrée.

Cependant, même s’il est possible de chiffrer le message et de lui attribuer

une signature, qu’en est-il de la sécurité ? La notion suivante de sécurité pour un
schéma de signature est due à Goldwasser, Micali et Rivest (GMR).

Définition 3.3.2. Un schéma de signature est dit sécurisé (ou GMR-sécurisé) si

celui-ci est existenciellement non forgeable par un adversaire à la capacité de
calcul limité qui pourrait monter une attaque adaptable pour des messages choisis.
En d’autres mots, un adversaire qui est en mesure d’obtenir des signatures pour
tout message de son choix de la part du l’entité signataire légitime est incapable de
reproduire par elle-même une nouvelle signature pour tout autre nouveau message
(pour lequel il n’a pas déjà demandé ou obtenu une signature).

Nous sommes maintenant rassurés de savoir que le schéma utilisé est on ne

peut plus sûr. D’autant que la définition de sécurité est très forte.

20
3.4. ECDSA
Nous venons de définir tout ce qui était nécessaire à la réalisation de base d’un
système de signature électronique, le système même mis à part. C’est donc ici, que
nous allons commencer réellement à nous amuser.

L’algorithme de signature numérique par courbe elliptique (ECDSA) est l’algo-

rithme analogue à celui de la signature numérique (DSA). Il s’agit de l’algorithme
le plus sauvagement standardisé des schémas de signature basés sur courbes ellip-
tique. Il apparaı̂t dans les standards ANSI X9.62, FIPS 186-2, IEEE 1363-2000 et
ISO/IEC 15946-2 ainsi que dans d’autres standards encore à l’état de brouillon.

Dans tout ce qui va suivre, H représente une fonction de hachage cryptogra-

phique dont la sortie possède une longueur de bits pas plus grande que celle de
n. Cette condition dans notre cas, nous le verrons n’est pas satisfaite. En effet, la
fonction de hashage que nous utiliserons est SHA-512 dont la sortie fait 512 bits
alors que le nombre de bits de n sera sûrement plus petite. Nous tronquerons donc
la taille de la sortie de la fonction de hachage à celle de n en ne conservant que les
bits les plus à droite.

Nous allons maintenant présenter les deux algorithmes essentiels à l’utilisation

de notre système. Le premier algorithme est un algorithme de génération de signa-
ture pour un message donné et le second est celui qui va servir de vérificateur de
signature pour un message donné.

F IG . 3.3 : Génération de signature ECDSA.

Entrées : Paramètres de domaine D = (q, FR, S, a, b, P, n, h), une clef
privée d, un message m.
Sorties : Signature (r, s).
début
répéter
répéter
Choisir aléatoirement k ∈ [1, n − 1];
Calculer kP = (x1 , y1 );
Convertir x1 en un entier x1 ;
Calculer r = x1 mod n;
jusqu’à r 6= 0;
Calculer e = H(m);
Calculer s = k−1 (e + dr) mod n;
jusqu’à s 6= 0;
retourner (r, s);
fin

Nous pouvons être assuré que la vérification de la signature fonctionne bel et

bien.

21
 F IG . 3.4 : Vérification de signature ECDSA.
Entrées : Paramètres de domaine D = (q, FR, S, a, b, P, n, h), une clef
publique Q, un message m, une signature (r, s).
Sorties : Acceptation ou rejet de la signature.
début
si (r 6∈ [1, n − 1]) ou (s 6∈ [1, n − 1]) alors
retourner « Rejet de la signature »;
finsi
Calculer e = H(m);
Calculer w = s−1 mod n;
Calculer u1 = ew mod n;
Calculer u2 = rw mod n;
Calculer X = u1 P + u2 Q;
si X = ∞ alors
retourner « Rejet de la signature »;
finsi
Convertir la coordonnée x1 de X en un entier x1 ;
Calculer v = x1 mod n;
si v = r alors
retourner « Acceptation de la signature »;
sinon
retourner « Rejet de la signature »;
finsi
fin

Preuve du fonctionnement de la vérification de signature. Si l’on considère que la

signature (r, s) d’un message m fût bel et bien générée par le signataire légitime,
alors,
s ≡ k−1 (e + dr) mod n
dont le réarrangement nous donne
k ≡ s−1 (e + dr) ≡ s−1 e + s−1 rd ≡ we + wrd ≡ u1 + u2 d mod n.
Par conséquent, nous avons
X = u1 P + u2 Q = (u1 + u2 d)P = kP
et donc, v = r comme voulu.

En ce qui concerne la sécurité de ECDSA, le choix de la fonction de hachage

joue un rôle primordial car si celle-ci peut-être cassée, alors, la signature suivra
sans procédures.

Nous allons maintenant expliquer dans le chapitre suivant comment toutes ces
notions ont pu être mise en œuvre afin de réaliser l’implémentation du schéma de
signature ECDSA.

22
 C HAPITRE 4

Implémentation et Optimisations

Nous y voilà enfin. Que peuvent bien donner, une fois implémentées,
toutes ces notions que nous venons d’étaler. Nous allons présenter dans
ce chapitre les choix que nous avons faits concernant les structures de
données utilisées pour l’implémentation. Ensuite, nous traiterons du choix
de la ou les courbes utilisées. Comme nous l’avons vu précédemment,
le choix d’une fonction de hachage fut faite de manière à ce qu’elle ne
soient pas faible face aux attaques. Enfin, nous étudierons les gains de
performances que nous avons pu obtenir durant toute l’implémentation au
travers de l’utilisation de coordonnées projectives ou de représentations
particulières.

Tout aussi étonnant que l’assimilation de ces nouvelles notions, vient

l’apprentissage d’un nouveau langage de programmation, le C++. Ce lan-
gage orienté objet est celui choisi pour l’implémentation.

4.1. Structures de données

Globalement, face à toutes ces notions, le nombre de classes utilisées pour
l’implémentation est loin d’être exhaustif. C’est pourquoi nous prendrons le temps
de les présenter brièvement dans cette section. Nous allons par conséquent donner
les explications nécessaires au fonctionnement de cette implémentation.

4.1.1 Description des classes

ECDomainParameters
Nous savons tout d’abord que nous aurons besoin de paramètres de domaine.
Cela a été englobé dans une classe, ECDomainParameters, qui va générer les pa-
ramètres de domaines. Le problème se posait sur la générations. En réalité, comme
nous utilisons uniquement les paramètres fournis par le NIST, cette classe ne fait

23
que fixer les paramètres de domaine de la courbe elliptique de Köblitz K-163. Les
paramètres que nous fixons pour l’utilisation de la courbe K-163 sont présentés
Fig. 4.1.

m = 163
f (z) = z163 + z7 + z6 + z3 + 1
a = 1
b = 1
h = 2
n = 0x 00000004 00000000 00000000 00020108 A2E0CC0D 99F8A5EF

x = 0x 00000002 FE13C053 7BBC11AC AA07D793 DE4E6D5E 5C94EEE8

y = 0x 00000002 89070FB0 5D38FF58 321F2E80 0536D538 CCDAA3D9

F IG . 4.1 – Paramètres de domaines pour K-163

Nous pouvons aussi jeter un oeil à la courbe K-233 dont les paramètres sont
aussi fournis. A terme, cette classe devrait être dans la mesure de générer les pa-
ramètres pour toutes les courbes recommandées par le NIST ainsi que de les générer
par elle même.

m = 233
f (z) = z233 + z7 4 + 1
a = 0
b = 1
h = 4
n = 0x 00000080 00000000 00000000 00000000 00069D5B B915BCD4 6EFB1AD5 F173ABDF

x = 0x 00000172 32BA853A 7E731AF1 29F22FF4 149563A4 19C26BF5 0A4C9D6E EFAD6126

y = 0x 000001DB 537DECE8 19B7F70F 555A67C4 27A8CD9B F18AEB9B 56E0C110 56FAE6A3

F IG . 4.2 – Paramètres de domaines pour K-233

ECSignature
Ensuite, nous avons la classe qui s’occupe de maintenir les informations con-
cernant la signature d’un message m par les valeurs r et s. Cette classe n’est autre
qu’une classe de stockage permettant l’échange de données entre les fonctions de
génération et de vérification de signature de ECDSA.

ECBFEquation
Une autre classe très simple est la classe ECBFEquation qui va maintenir les
informations concernant les coefficients a et b de la courbe elliptique. Ces coeffi-
cients sont très souvent sollicités tout au long de la génération ou de la vérification

24
de signature car elle intervient dans chaque multiplication et par conséquent, dans
chaque addition de points dans F2m . C’est pourquoi les méthodes sont inline afin
de gagner quelques petits temps de calcul.

ECMessage
Toujours dans le même genre de classes, petites mais très utiles, voici la classe
ECMessage. Celle-ci aura pour rôle la gestion des messages, à savoir, pointer aussi
bien sur des chaı̂nes de caractères que sur des fichiers. De plus c’est elle qui aura
comme charge le hachage du message.

Nous l’avons vu précédemment, nous utilisons la fonction de hachage SHA-

512 dans les algorithmes de génération et de vérification de signature ECDSA.
L’algorithme utilisé fait appel à la librairie mhash qui gère un certain nombre d’al-
gorithmes de hachage dont SHA-512. Bien évidemment, ce n’est sûrement pas la
librairie la plus rapide connue pour ce genre d’opération mais ce fût cependant la
plus simple à utiliser et mettre en œuvre dans cette implémentation.

Cette librairie est disponible sur le site de Sourceforge à l’adresse suivante :

http ://mhash.sourceforge.net.

Nous pouvons ajouter la chose suivante concernant la classe ECMessage. Soit

e = H(m) le hash du message m par l’algorithme SHA-512, et tel que
e = e511 e510 . . . e3 e2 e1 e0
alors la méthode ZZ hashMeTruncated(unsigned int nbbits) retourne le hash e′ tel
que
e′ = enbbits−1 enbbits−1 . . . e3 e2 e1 e0

ECKeyPair
Au chapitre 3, nous avons vu comment il était possible de générer un couple
de clefs, publique et privé (Q, d). Cette classe s’occupe de réaliser ces opérations à
l’aide de deux méthodes principales qui prennent comme paramètre, hé bien. . . des
paramètre de domaine D représentés par la classe ECDomainParameters :

• void ECKeyPair::generateKeyPair(ECDomainParameters ∗ D);

• bool ECKeyPair::validatePublicKey(ECDomainParameters ∗ D);

Nous arrivons désormais aux deux classes les plus importantes de ce pro-
gramme. Il s’agit des classes ECDSA et ECPoint que nous allons présenter d’ici
peu.
Remarque 4.1.1. Il reste tout de même deux classes qui ne sont pas présentées ici.
Elles le seront dans la partie réservée aux optimisations car celles-ci apporte des
améliorations notables de performance au programme et au calculs effectués sur
les courbes elliptiques E(F2m ).

25
 ECPoint
La classe ECPoint à pour rôle la représentation d’un point P = (x, y) de la
courbe elliptique E(F2m ) en coordonnées affines. En utilisant de manière habile la
surcharge des opérateurs du langage C++, nous offrons ainsi un code source facile
et agréable à lire.

ECDSA
La classe ECDSA quand à elle est très succincte. Elle s’occupe uniquement de
réaliser les opérations de génération et de vérification de signature ECDSA. Elle
implémente en fait l’ensemble de tout ce que nous avons pu étayer depuis le début
de ce papier. Du coup, elle devient très simple d’utilisation. Il suffit de donner au
constructeur, un domaine D de paramètres pour la courbe à utiliser, la clef privée
d et le message m à signer et elle s’occupe alors de calculer le tout pour nous
redonner en sortie la jolie signature de 163 bits (dans notre cas). Il nous est alors
enfin possible de vérifier l’authenticité de la signature.

4.2. Optimisations
Maintenant que nous sommes en présence d’un programme fonctionnel que
nous dirons naı̈f, implémentant le schéma de signature électronique ECDSA, nous
pouvons désormais porter notre attention sur les optimisations possibles, si elles
existent, des calculs effectuer. Il en existe bel et bien et nous allons exposer les
deux principales optimisations obtenues pour ces calculs.

La première optimisation est obtenue en utilisant des coordonnées projectives

plutôt que des coordonnées affines. Pour être plus précis, l’optimisation est en fait
une combinaison des deux types de coordonnées.

La seconde optimisation importante est obtenue en utilisant une autre repré-

sentation des entiers utilisés par les calculs de points de la courbe. En utilisant la
représentation NAF il devient alors possible d’éviter certains calculs qui deviennent
par conséquent, superflus.

4.2.1 Coordonnées projectives

L’arithmétique des courbes elliptiques va se voir améliorer par l’utilisation de
coordonnées projectives plutôt qu’essentiellement de coordonnées affines. Les for-
mules qui permettaient d’additionner des points ont déjà été présentée. Celles-ci
nécessitaient une inversion dans le corps considéré ainsi que plusieurs multiplica-
tions dans le corps. Si l’inversion dans le corps K est significativement beaucoup
plus coûteuse que celle de la multiplication, alors il peut-être beaucoup plus avan-
tageux de représenter ces points en utilisant des coordonnées projectives.

26
 Les courbes que nous étudions depuis le début de ce papier sont de la forme
y2 + xy = x3 + ax2 + b. Il existe différents systèmes de coordonnées permettant une
représentation projective des points pour les courbes non supersingulières de la
forme
E : y2 + xy = x3 + ax2 + b
définies sur la corps binaire K. Parmis ces différents types de coordonnées projec-
tives qui ont été proposées, nous pouvons retrouver les systèmes suivants :

• Coordonnées projectives Standards,

• Coordonnées projectives Jacobiennes,
• Coordonnées projectives LD (López-Dahab).

C’est ce dernier système de coordonnées qui va attirer notre attention.

Définition 4.2.1. Soit K un corps et soient c et d deux entier positifs. On peut

définir une relation d’équivalence ∼ sur l’ensemble K 3 \{(0, 0, 0)} des triplets non
nuls de K par

(X1 ,Y1 , Z1 ) ∼ (X2 ,Y2 , Z2 ) si X1 = λ c X2 , Y1 = λ d Y2 , Z1 = λ Z2 avec λ ∈ K∗

La classe d’équivalence contenant (X, Y, Z) ∈ K 3 \{(0, 0, 0)} est

n  o
(X : Y : Z) = λ c X, λ d Y, λ Z | λ ∈ K ∗

(X : Y : Z) est appelé un point projectif et (X, Y, Z) est appelé le représentant de

(X : Y : Z).

Le système de coordonnées considéré dans notre cas est donc celui de López-
Dahab (LD). Dans ce cas, c = 1 et d = 2. Le point projectif (X : Y : Z) avec
Z 6= 0 correspond au point affine (X/Z, Y /Z 2 ). L’équation projective de la courbe
elliptique est
Y 2 + XY Z = X 3 Z + aX 2 Z 2 + bZ 4 .
Le point infini ∞ correspond au point (1 : 0 : 0), alors que le négatif de (X : Y : Z)
est (X : X + Y : Z). Les formules permettant de calculer le double (X3 : Y3 : Z3 )
du point (X1 : Y1 : Z1 ) sont :

Z3 ← X12 · Z12
X3 ← X14 · bZ14
Y3 ← bZ14 · Z3 + X3 · aZ3 +Y12 + bZ14

27
Les formules permettant de calculer la somme (X3 : Y3 : Z3 ) des points (X1 : Y1 :
Z1 ) et (X2 : Y2 : 1) sont :

A ← Y2 · Z12 +Y1
B ← X2 · Z1 + X1
C ← Z1 · B
D ← B2 · C + aZ12

Z3 ← C 2
E ← A ·C
X3 ← A2 + D + E
F ← X3 + X2 · Z3
G ← (X2 +Y2 ) · Z32
Y3 ← (E + Z3 ) · F + G

L’inconvénient majeur de ces deux algorithmes est que ceux-ci ne sont valables
que dans le cas où le coefficient a de l’équation appartient à {0, 1}. Les deux al-
gorithmes ne sont pas présentés car ils représentent approximativement les mêmes
instructions au test près des retours du point ∞, que les formules que nous venons
de présenter.
Le tableau suivant va nous montrer l’intérêt d’utiliser de tels algorithmes plutôt
que les algorithmes initiaux.

Système de coordonnées Addition générale Addition générale Doublement

Coordonnées mixed
Affine D+M - D+M
Projectif Standard 13M 12M 7M
Projectif Jacobien 14M 10M 5M
Projectif (LD) 14M 8M 4M

F IG . 4.3 – Coûts pour l’addition et le doublement sur y2 + xy = x3 + ax2 + b. D =

division, M = multiplication.

Si l’on souhaite, revenir à une représentation en coordonnées affine il suffit

de convertir le point en coordonnées projective en son équivalent en coordonnées
affine. Ce résultat à toute son importance dans la multiplication, comme nous allons
le voir.

4.2.2 Multiplication de points inconnus

Nous avons vu précédemment que nous étions en possession de deux algo-
rithmes permettant la multiplication d’un point P par un entier positif k. Le pre-
mier algorithme utilisait une méthode droite/gauche alors que le second utilisait

28
une méthode gauche/droite. Nous utiliserons le deuxième algorithme pour une rai-
son très simple mais qui a toute son importance.

En utilisant des coordonnées projectives, la seule opération d’addition que nous

savons réaliser fait intervenir à la fois un point en coordonnées projectives LD et
un point en coordonnées affines. L’algorithme Fig. 2.7 oblige le point Q à être
représenté en coordonnées projectives et le doublement ne peut être obtenu de
manière performante qu’en utilisant des coordonnées projectives. Il faut donc à
chaque fois que l’addition Q ← Q + P à lieu, convertir le point P vers des coor-
données affines. Nous perdons alors tout l’intérêt de l’utilisation des coordonnées
projective permettant d’éviter des inversions inutiles dans le corps considéré.

En contre partie, l’algorithme Fig. 2.8 quand à lui en traitan les bits, de la
droite vers la gauche nous offre la possibilité d’utiliser le point Q en coordonnées
projectives afin d’effectuer tous les doublement nécessaires. Et pour ce qui est du
point P, une seule conversion est nécessaire.

Les résultats obtenus en utilisant l’algorithme Fig. 2.7 sont de 4, 8ms alors que
ceux obtenus avec Fig. 2.8 descendent alors à 3, 615ms en moyenne. C’est un gain
non négligeable et nous allons voir qu’il est encore possible de diminuer les va-
leur de l’addition de point avec l’utilisation d’une représentation particulière des
entiers.

4.2.3 Représentation Non Adjacent Form (NAF)

Si le point P = (x, y) ∈ E(Fq ) alors le point −P = (x, x+y) dans le cas où Fq est
un corps binaire. Par conséquent, la soustraction des points d’une courbe elliptique
est aussi efficace que l’addition de ceux-ci. Ceci va nous donner l’envie d’utiliser
une représentation signée des bits de l’entier k = ∑i=0 l − 1ki 2i , où ki ∈ {0, ±1}.
Une représentation signée des bits particulièrement intéressante est la forme non-
adjacente (NAF).
Définition 4.2.2 (NAF). Une forme non-adjacente (NAF) d’un entier positif k est
une expression
k = ∑ l − 1ki 2i
i=0
où ki ∈ {0, ±1}, kl−1 6= 0 et deux bits consécutifs ki ne sont pas tous deux non nuls.
La longueur de NAF est l.
L’avantage de cette représentation est déjà que celle-ci est unique pour un entier
positif donné. Mais le plus important est que l’on sait que l’algorithme de multi-
plication utilisé effectue une addition chaque fois qu’un bit de la représentation
de l’entier vaut 1. Il se trouve que la représentation NAF possède en général, par
définition un nombre inférieur de zéros. Nous pouvons donc nous attendre à ce
que les temps de calculs de kP en soient réduits. Voyons tout d’abord quelques
propriétés concernant les NAFs afin de justifier nos dires.

29
Théorème 4.2.1 (Propriétés des NAFs). Soit k un entier positif.
(i) k possède un NAF unique noté NAF(k).
(ii) NAF(k) possède le moins de bits non nuls parmis toutes les représentations
signées de bits de l’entier k.
(iii) La longueur de NAF(k) est au plus celle de la représentation binaire de k
plus un.
(iv) Si la longueur de NAF(k) est l, alors

2l 2l+1
<k<
3 3
(v) La densité moyenne des bits non-nuls sur l’ensemble de toutes les NAFs de
longueur l est approximativement 1/3.

NAF(k) peut-être calculer efficacement grâce à l’algorithme Fig. 4.4. Les bits
de NAF(k) sont générés en divisant k successivement par 2, permettant des restes
de 0 ou ±1. Si k est impair, alors, le reste r ∈ {−1, 1} est choisi de telle sorte que
le quotient (k − r)/2 soit pair. Ceci assure que le prochain bit de la représentation
NAF sera un 0.

F IG . 4.4 : Calcul du NAF d’un entier positif.

Entrées : Un entier positif k.
Sorties : NAF(k).
début
i ← 0;
tant que k ≥ 1 faire
si k est impair alors
ki ← 2 − (k mod 4);
k ← k − ki ;
sinon
ki ← 0;
finsi
k ← k/2;
i ← i + 1;
fintq
retourner (ki−1 , ki−2 , . . . , k1 , k0 );
fin

Enfin, l’algorithme Fig. 4.5 modifie l’algorithme de multiplication de point

utilisant la méthode binaire gauche/droite (Fig. 2.8) en utilisant NAF(k) plutôt que
la représentation binaire de k. Il en découle que la complexité de calcul de cet
algorithme sera réduit par rapport à Fig. 2.8.
Cette dernière optimisation nous fait diminuer les temps de calculs, en les fai-
sant passer de 3, 615ms à 3, 3ms.

30
 F IG . 4.5 : Méthode binaire NAF pour la multiplication de points.
Entrées : Un entier positif k, P ∈ E(Fq ).
Sorties : kP.
début
Calculer NAF(k) = ∑l−1 i
i=0 ki 2 ;
Q ← ∞;
pour i allant de l − 1 à 0 par pas de −1 faire
Q ← 2Q;
si ki = 1 alors
Q ← Q + P;
finsi
si ki = −1 alors
Q ← Q − P;
finsi
finpour
retourner Q;
fin

Il existe encore grand nombre d’optimisation qu’il aurait pu être possible de

mettre en œuvre si le temps ne nous pressait pas. Cependant, le programme implé-
mentant l’algorithme fonctionne et c’est là l’essentiel.

31
 Conclusion

Un mois d’écoulé et un projet qui fonctionne. Après l’étude des courbes

elliptiques et de leur application en cryptographie ce semestre, la mise au
point de l’implémentation est terminée. Le schéma de signature électro-
nique appliqué aux courbes elliptiques ECDSA est alors implémenté. Sont
ensuite apportés quelques optimisations, le rendant ainsi plus rapide et
plus efficace.

Cependant, regrets et idées émergent subitement. Des regrets car le

temps restants intrinsèquement incompressible, toutes les optimisations
prévues n’ont pas pu être mises au point. Des idées car ce fameux temps,
je le cherche afin de proposer dans un futur proche, je l’espère, un pro-
gramme complet ou une librairie permettant l’utilisation de nombreux algo-
rithmes utilisant les courbes elliptiques en ne se restreignant pas unique-
ment à la signature électronique mais aussi à d’autres protocoles à clef
partagé, etc.

De plus, l’apprentissage d’un nouveau langage de programmation tel

que le C++ durant toutes ces heures augmente par la même occasion le
panel des langages qui m’étaient connus.

32
 Table des figures

2.1 Courbes Elliptiques sur R. . . . . . . . . . . . . . . . . . . . . . 10

2.2 Addition et doublement géométrique des points d’une courbe el-
liptique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Addition basique de deux points . . . . . . . . . . . . . . . . . . 14
2.4 Doublement basique d’un point . . . . . . . . . . . . . . . . . . 14
2.5 Négation d’un point . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6 Addition propre de base . . . . . . . . . . . . . . . . . . . . . . 15
2.7 Méthode binaire de multiplication droite/gauche. . . . . . . . . . 16
2.8 Méthode binaire de multiplication gauche/droite. . . . . . . . . . 16

3.1 Génération d’un couple de clefs. . . . . . . . . . . . . . . . . . . 19

3.2 Validation de clef publique. . . . . . . . . . . . . . . . . . . . . 19
3.3 Génération de signature ECDSA. . . . . . . . . . . . . . . . . . 21
3.4 Vérification de signature ECDSA. . . . . . . . . . . . . . . . . . 22

4.1 Paramètres de domaines pour K-163 . . . . . . . . . . . . . . . . 24

4.2 Paramètres de domaines pour K-233 . . . . . . . . . . . . . . . . 24
4.3 Coûts pour l’addition et le doublement sur y2 + xy = x3 + ax2 + b.
D = division, M = multiplication. . . . . . . . . . . . . . . . . . 28
4.4 Calcul du NAF d’un entier positif. . . . . . . . . . . . . . . . . . 30
4.5 Méthode binaire NAF pour la multiplication de points. . . . . . . 31

33
 A NNEXE A

Manuel

Nous allons brièvement détailler comment compiler, installer et exé-

cuter le programme implémenté.

A.1. Installation et compilation

Je pense qu’il ne devrait pas être trop difficile d’effectuer la compilation et
l’installation du programme sur une machine. Mais, il est important d’apporter
quelques petites informations qui pourraient aider.

A.1.1 Compilation
Pour compiler le programme il suffit de lancer la commande ./configure.
Celle-ci génèrera les paramètres nécessaires à la compilation. Un pré requis utile
est de savoir que les deux bibliothèques utilisées NTL et mhash se situent dans le
répertoire /usr/lib. Le cas échéant, une modification du fichier Makefile du
répertoire src du projet sera sans doute nécessaire à une compilation sans erreur.

Il ne reste plus alors qu’à taper la commande miracle, dans le répertoire racine
du projet. Il suffit de taper make dans le shell. La compilation devrait se passer sans
torp de problèmes.

A.1.2 Installation
Une fois le programme compilé, il est alors possible de l’installer à l’aide de la
commande make install. Cependant, sachant que cette version est encore très
simple, une simple exécution du programme ecci dans le répertoire src du projet
est sûrement bien plus judicieuse.

34
A.2. Utilisation
L’utilisation aussi ne demande pas de grandes connaissances. Pour signer un
fichier et obtenir la vérification de sa signature, il suffit dans le cas du fichier
foo.bar à signer, de taper la commande suivante : ./ecci -f foo.bar.

Le programme est assez rudimentaire, il est vrai, mais dans le cadre actuel des
choses, réalise les opérations.

35
 A NNEXE B

Code des en-têtes de classes

utilisées
B.1. ECDomainParameters

c l a s s ECDomainParameters
{
public :
ECDomainParameters ( ) ;

inline ZZ g e t q ( ) { r e t u r n t h i s −>q ; }
inline ZZ g e t n ( ) { r e t u r n t h i s −>n ; }
inline ZZ g e t s ( ) { r e t u r n t h i s −>s ; }
inline ZZ g e t h ( ) { r e t u r n t h i s −>h ; }
inline ZZ g e t m ( ) { r e t u r n t h i s −>m; }
inline ECBFEquation g e t e ( ) { r e t u r n t h i s −>e ; }
inline ECPoint g e t P ( ) { r e t u r n t h i s −>P ; }

private :
GF2X f z ;
ECPoint P ;
ZZ q ;
ZZ s ;
ZZ h ;
ZZ m;
ZZ n ;
ECBFEquation e ;

ZZ ECDomainParameters : : hash2ZZ ( u n s i g n e d char ∗ h , ZZ v ) ;

void setCurveK163Koblitz ( ) ;

};

B.2. ECSignature

c l a s s ECSignature
{
public :
ECSignature ( ) {}
ECSignature (ZZ r , ZZ s ) ;
i n l i n e v o i d s e t R (ZZ r ) { t h i s −>r = r; }
i n l i n e v o i d s e t S (ZZ s ) { t h i s −>s = s; }
i n l i n e ZZ g e t R ( ) { r e t u r n t h i s −>r ; }
i n l i n e ZZ g e t S ( ) { r e t u r n t h i s −>s ; }
private :
ZZ r ;

36
 ZZ s ;
};

B.3. ECBFEquation

c l a s s ECBFEquation
{
public :
ECBFEquation ( ) ;
ECBFEquation ( GF2E a , GF2E b ) ;

i n l i n e v o i d s e t C o e f f a ( GF2E a ) { t h i s −>a = a ; }
i n l i n e v o i d s e t C o e f f b ( GF2E b ) { t h i s −>b = b ; }

i n l i n e GF2E g e t C o e f f a ( ) { r e t u r n t h i s −> a ; }
i n l i n e GF2E g e t C o e f f b ( ) { r e t u r n t h i s −> b ; }

private :
GF2E a ;
GF2E b ;
};

B.4. ECMessage

c l a s s ECMessage
{
public :
s t a t i c c o n s t u n s i g n e d i n t SELECTION TYPE FILE = 1 ;
s t a t i c c o n s t u n s i g n e d i n t SELECTION TYPE STRING = 2 ;

ECMessage ( ) ;

v o i d s e l e c t I n p u t ( char ∗ f i l e n a m e , u n s i g n e d i n t i n p u t t y p e ) ;
v o i d s e l e c t O u t p u t ( char ∗ f i l e n a m e , u n s i g n e d i n t o u t p u t t y p e ) ;

b o o l hashMe ( ) ;
ZZ h a s h M e T r u n c a t e d ( u n s i g n e d i n t n b b i t s ) ;

i n l i n e u n s i g n e d char ∗ g e t H a s h ( ) { r e t u r n t h i s −>h a s h ; }
v o i d showHash ( ) ;

˜ ECMessage ( ) ;
private :
s t a t i c c o n s t u n s i g n e d i n t SELECTION TYPE NO SELECTION = 0 ;

char ∗ o u t p u t ;
char ∗ i n p u t ;

bool i n p u t s e l e c t e d ;
bool o u t p u t s e l e c t e d ;

u n s i g n e d char ∗ h a s h ;

unsigned i n t i n p u t s e l e c t e d t y p e ;
unsigned i n t o u t p u t s e l e c t e d t y p e ;

37
 bool hashFromInputFile ( ) ;
bool hashFromInputString ( ) ;
};

B.5. ECKeyPair

c l a s s ECKeyPair
{
public :
ECKeyPair ( ) ;
ECKeyPair ( ECDomainParameters ∗ D ) ;
v o i d g e n e r a t e K e y P a i r ( ECDomainParameters ∗ D ) ;

i n l i n e ECPoint g e t Q ( ) { r e t u r n t h i s −>Q; }
i n l i n e ZZ g e t d ( ) { r e t u r n t h i s −>d ; }

b o o l v a l i d a t e P u b l i c K e y ( ECDomainParameters ∗ D ) ;

private :
ECPoint Q ;
ZZ d ;
};

B.6. ECPoint

c l a s s ECPoint
{
public :
ECPoint ( ) ;
ECPoint ( GF2E x , GF2E y ) ;

i n l i n e v o i d s e t X ( GF2E x ) { t h i s −>x = x ; }
i n l i n e v o i d s e t Y ( GF2E y ) { t h i s −>y = y ; }

i n l i n e GF2E getX ( ) { r e t u r n t h i s −>x ; }

i n l i n e GF2E getY ( ) { r e t u r n t h i s −>y ; }

i n l i n e ECPoint o p e r a t o r −()
{
r e t u r n ECPoint ( t h i s −>x , t h i s −>x+ t h i s −>y ) ;
}
ECPoint o p e r a t o r ∗ (ZZ n ) ;
ECPoint o p e r a t o r ∗ (ECNAF k ) ;
ECPoint o p e r a t o r +( ECPoint Q ) ;

i n l i n e v o i d s e t I n f i n i t y ( ) { t h i s −> i n f i n i t y p o i n t = t r u e ; }
i n l i n e b o o l i s I n f i n i t y ( ) { r e t u r n t h i s −> i n f i n i t y p o i n t ; }

v o i d show ( ) ;
private :
bool i n f i n i t y p o i n t ;
GF2E x ;
GF2E y ;
};

38
B.7. ECDSA

c l a s s ECDSA
{
public :
ECDSA( ECDomainParameters D ) ;
ECSignature g e n e r a t e S i g n a t u r e (ZZ d , ECMessage ∗m ) ;
b o o l v e r i f y S i g n a t u r e ( ECPoint Q, ECMessage ∗m, ECSignature s i g n a t u r e ) ;

private :
ECDomainParameters D ;

ZZ c o o r d i n a t e T o Z Z ( c o n s t GF2E& a ) ;
};

B.8. ECPPoint

c l a s s ECPPoint
{
public :
ECPPoint ( c o n s t GF2E& x , c o n s t GF2E& y , c o n s t GF2E& z ) ;
ECPPoint ( v o i d ) ;
ECPPoint ( ECPoint P ) ;
ECPPoint ( c o n s t ECPPoint& P ) ;

i n l i n e v o i d s e t X ( GF2E x ) { t h i s −>x = x ; }
i n l i n e v o i d s e t Y ( GF2E y ) { t h i s −>y = y ; }
i n l i n e v o i d s e t Z ( GF2E z ) { t h i s −>z = z ; }

i n l i n e GF2E getX ( ) { r e t u r n t h i s −>x ; }

i n l i n e GF2E getY ( ) { r e t u r n t h i s −>y ; }
i n l i n e GF2E g e t Z ( ) { r e t u r n t h i s −>z ; }

/ / ECPPoint o p e r a t o r +( c o n s t ECPPoint& Q ) ;
i n l i n e ECPPoint o p e r a t o r −()
{
r e t u r n ECPPoint ( t h i s −>x , t h i s −>x + t h i s −>y , t h i s −>z ) ;
}
ECPPoint o p e r a t o r − ( ECPoint Q ) ;
ECPPoint o p e r a t o r ∗ (ZZ n ) ;
ECPPoint o p e r a t o r ∗ (ECNAF k ) ;
ECPPoint o p e r a t o r +( ECPoint Q ) ;

ECPoint c o n v e r t ( ) ;
i n l i n e bool i s I n f i n i t y ( )
{
r e t u r n ( I s O n e ( t h i s −>x ) && I s Z e r o ( t h i s −>y ) && I s Z e r o ( t h i s −>z ) ) ;
}

inline void s e t I n f i n i t y ( ) {
conv ( t h i s −>x , GF2X ( 0 , 1));
conv ( t h i s −>y , GF2X ( 0 , 0));
conv ( t h i s −>z , GF2X ( 0 , 0));
}

v o i d show ( ) ;

private :

39
 GF2E x ;
GF2E y ;
GF2E z ;
int c ;
int d ;

ECPPoint p o i n t D o u b l i n g ( ECBFEquation e ) ;
ECPPoint double moi ( ) ;
ECPPoint add ( ECPoint Q, ECBFEquation e ) ;
ECPPoint mul (ZZ k ) ;
ECPPoint m u l n a f (ECNAF k ) ;
};

B.9. ECNAF

c l a s s ECNAF
{
public :
ECNAF( c o n s t ZZ& k ) ;

/ / ˜ ECNAF ( ) ;

i n l i n e i n t g e t L e n g t h ( ) { r e t u r n t h i s −>l e n g t h ; }
i n l i n e i n t g e t V a l ( i n t i ) { r e t u r n t h i s −>n a f [ i ] ; }

v o i d show ( ) ;
private :
i n t w;
int size ;
int length ;
int naf [512];
/ / char ∗ naf ;

b o o l ZZ to NAF ( c o n s t ZZ& k ) ;

};

40