Algorithmes Parallèles de Multiplication Scalaire Optimisée sur Courbes Elliptiques Binaires

(1)

HAL Id: lirmm-01121960

https://hal-lirmm.ccsd.cnrs.fr/lirmm-01121960

Submitted on 15 Apr 2015

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Algorithmes Parallèles de Multiplication Scalaire

Optimisée sur Courbes Elliptiques Binaires

Jean-Marc Robert

To cite this version:

Jean-Marc Robert. Algorithmes Parallèles de Multiplication Scalaire Optimisée sur Courbes Ellip-tiques Binaires. C2: Journées Codage et Cryptographie, GT-C2, Mar 2014, Les Sept-Laux, France. �lirmm-01121960�

(2)

Approches Parallèles de Multiplication Scalaire

sur Courbe Elliptique Binaire

Jean-Marc ROBERT

Team DALI/LIRMM, Université de Perpignan, France

le 3 mars 2014

(3)

Table des matières

1 Problématique

Un exemple : l’échange de clé de Diffie-Hellmann Opérations entre points de courbe elliptique Le Produit scalaire de points

2 Parallélisation Right-to-left

Comparaison Left-to-right/Right-to-left Algorithme parallèle Halving/Doubling Synthèse sur ces algorithmes

3 Montgomery parallèle

Une attaque : Simple Power Analysis

Une contre mesure à l’attaque SPA : Montgomery

Variantes : Montgomery-Halving et Montgomery parallèle Synthèse sur ces algorithmes

(4)

Problématique Un exemple : l’échange de clé de Diffie-Hellmann

Table des matières

1 Problématique

Un exemple : l’échange de clé de Diffie-Hellmann

Opérations entre points de courbe elliptique Le Produit scalaire de points

(5)

Échange de clé de Diffie-Hellmann

Alice et Bob s’accordent sur un groupe mathématique (G , +, O) et un générateur de ce groupe P.

Bob Alice

a ← random() b ← random()

calcule A = a · P

envoie B calcule B = b · P envoie A

calcule K = a · B calcule K = b · A

clé secrète partagée K = a · b · P

→La multiplication scalaire est la principale opération

effectuée a · P.

(6)

Échange de clé de Diffie-Hellmann

Alice et Bob s’accordent sur un groupe mathématique (G , +, O) et un générateur de ce groupe P. Bob Alice a ← random() b ← random() calcule A = a · P calcule B = b · P

envoie B envoie A

calcule K = a · B calcule K = b · A clé secrète partagée K = a · b · P

→La multiplication scalaire est la principale opération

effectuée a · P.

(7)

Échange de clé de Diffie-Hellmann

Bob Alice

a ← random() b ← random() calcule A = a · P

envoie B calcule B = b · P

envoie A

→La multiplication scalaire est la principale opération

effectuée a · P.

(8)

Échange de clé de Diffie-Hellmann

Bob Alice

envoie A

→La multiplication scalaire est la principale opération

effectuée a · P.

(9)

Échange de clé de Diffie-Hellmann

Bob Alice

envoie A

→La multiplication scalaire est la principale opération

effectuée a · P.

(10)

Notre groupe : Courbe Elliptique

(11)

Notre groupe : Courbe Elliptique

(12)

Notre groupe : Courbe Elliptique

Notre courbe est sur F2m (et non R) :

E : Y2+ XY = X3+ aX2+ b, _{a, b ∈ F}2m.

Les coordonnées des points appartiennent à F2m = F₂[x ]/(f (x ) · F₂[x ])

Soit A =Pm−1 i =0 ai · xi et B = Pm−1 i =0 bi · xi, ai, bi ∈ {0, 1} alors : A + B = m−1 X i =0 (ai + bi) · xi, et : A × B = A · B mod f .

(13)

Problématique Opérations entre points de courbe elliptique

Table des matières

1 Problématique

Un exemple : l’échange de clé de Diffie-Hellmann

Opérations entre points de courbe elliptique

Le Produit scalaire de points

(14)

Opérations entre points de courbe elliptique

Les formules pour le doublement et l’addition sont :

x3 = λ2+ λ + x1+ x2+ a y3 = (x1+ x3)λ + x3+ y1 avec    λ = y1+y2 x1+x2 if P16= P2 λ = y1 x1 + x1 if P1 = P2

Un doublementnécessite 1 inversion, 2 multiplications, 1 élévation au carré , et 8 additions de polynômes ;

Uneadditionnécessite 1 inversion, 2 multiplications, 1 élévation au carré , et 9 additions de polynômes ;

(15)

Opérations entre points de courbe elliptique

Les formules pour le doublement et l’addition sont :

x3 = λ2+ λ + x1+ x2+ a y3 = (x1+ x3)λ + x3+ y1 avec    λ = y1+y2 x1+x2 if P16= P2 λ = y1 x1 + x1 if P1 = P2

Un doublementnécessite 1 inversion, 2 multiplications, 1 élévation au carré , et 8 additions de polynômes ;

Uneadditionnécessite 1 inversion, 2 multiplications, 1 élévation au carré , et 9 additions de polynômes ;

(16)

Points de Courbes Elliptiques : Coordonnées Projectives

Lopez-Dahab ont montré l’intérêt des coordonnées "projectives" . Un point en coordonnées affines est transformé comme suit :

P = (x , y ) devient (X : Y : Z ) avec (

x =X_Z y =_ZY2

Maintenant, on effectue le doublement de la façon suivante :

2.(X : Y : Z ) = (X1: Y1: Z1) avec    X1= X4+ b · Z4 Y1= bZ4· Z1+ X1· (aZ1+ Y2+ bZ4) Z1= X2· Z2

Operation Affine Lopez-Dahab

Doublement 2M + 1S + 1I 4M + 4S

Addition 2M + 1S + 1I 13M + 4S

Addition - 9M + 5S

(17)

Points de Courbes Elliptiques : Coordonnées Projectives

x =X_Z y =_ZY2

Addition - 9M + 5S

(18)

Points de Courbes Elliptiques : Coordonnées Projectives

x =X_Z y =_ZY2

Addition - 9M + 5S

(19)

Problématique Le Produit scalaire de points

Table des matières

1 Problématique

Un exemple : l’échange de clé de Diffie-Hellmann Opérations entre points de courbe elliptique

Le Produit scalaire de points

(20)

L’Algorithme de Produit Scalaire : Double-and-add

Soit k = (kt−1, ..., k1, k0)2∈ N, P ∈ E (F2m) k · P = (Pt−1 i =02 i_k i) · P = ((. . . ((kt−1· 2 + kt−2) · 2 + kt−3) · 2 . . . + k1) · 2 + k0) · P = ((. . . ((kt−1· P · 2 + kt−2· P) · 2 + kt−3· P) · 2 . . . + k1· P) · 2 + k0· P)

On traduit cela dans l’algorithme suivant :

Left-to-Right double-and-add

Elliptic Curve Scalar Multiplication (ECSM)

Require: k = (kt−1, . . . , k1, k0), P ∈ E (F2m) Ensure: Q = k · P

1: Q ← O

2: for i from t − 1 downto 0 do

3: Q ← 2 · Q 4: if ki = 1then 5: Q ← Q + P 6: end if 7: end for 8: return (Q)

(21)

L’Algorithme de Produit Scalaire : Double-and-add

1: Q ← O

(22)

L’Algorithme de Produit Scalaire : Double-and-add

1: Q ← O

(23)

Amélioration de Double-and-add : NAF et W-NAF.

NAF remplace les séquences de 1 consecutifs : soit k ∈ N tel que k = 2i_{− 1, alors}

(k)2= 111...1

| {z } i fois

et on peut écrire : (k)NAF = 100...00 − 1

| {z }

i+1 chiffres .

⇒ Nombre moyen de chiffres non nuls : den/2 à n/3.

W-NAF réduit davantage encore le nombre moyen de chiffres non nuls à

n/(w + 1)en utilisant :

{−2w −1+ 1, ..., −5, −3, −1, 0, 1, 3, 5, ..., 2w −1− 1}. Bilan sur la complexité du produit scalaire sur E (F2m) :

nb. de doublements nb. d’additions

Double-and-add n n/2

NAF Double-and-add n n/3

(24)

Amélioration de Double-and-add : NAF et W-NAF.

NAF remplace les séquences de 1 consecutifs : soit k ∈ N tel que k = 2i_{− 1, alors}

(k)2= 111...1

| {z } i fois

et on peut écrire : (k)NAF = 100...00 − 1

| {z }

i+1 chiffres .

⇒ Nombre moyen de chiffres non nuls : den/2 à n/3.

W-NAF réduit davantage encore le nombre moyen de chiffres non nuls à

n/(w + 1)en utilisant :

{−2w −1_{+ 1, ..., −5, −3, −1, 0, 1, 3, 5, ..., 2}w −1_{− 1}.}

Bilan sur la complexité du produit scalaire sur E (F2m) :

nb. de doublements nb. d’additions

Double-and-add n n/2

NAF Double-and-add n n/3

(25)

Parallélisation Right-to-left Comparaison Left-to-right/Right-to-left

Table des matières

1 Problématique

Comparaison Left-to-right/Right-to-left

Algorithme parallèle Halving/Doubling Synthèse sur ces algorithmes

(26)

Comparaison Left-to-right/Right-to-left

Require: k = (kt−1, . . . , k1, k0), P ∈

E (F2m) Ensure: Q = k · P

1: Q ← O

3: Q ← 2 · Q 4: if ki = 1then 5: Q ← Q + P 6: end if 7: end for 8: return (Q) Right-to-Left double-and-add

Require: k = (kt−1, . . . , k1, k0), P ∈ E (F2m) Ensure: Q = k · P 1: Q ← O 2: for i from 0 to t − 1 do 3: if ki= 1then 4: Q ← Q + P 5: end if 6: P ← 2 · P 7: end for 8: return (Q) ⇑ ⇑

"mixed coordinates addition" "general addition" L’algorithme Left-to-right est plus performant ("mixed coordinates addition")

(27)

Comparaison Left-to-right/Right-to-left

Require: k = (kt−1, . . . , k1, k0), P ∈

1: Q ← O

"mixed coordinates addition" "general addition"

L’algorithme Left-to-right est plus performant ("mixed coordinates addition")

(28)

Comparaison Left-to-right/Right-to-left

Require: k = (kt−1, . . . , k1, k0), P ∈

1: Q ← O

"mixed coordinates addition" "general addition" L’algorithme Left-to-right est plus performant ("mixed coordinates addition")

(29)

Double-and-add parallèle

Require: scalar k, P ∈ F2m. Ensure: kP. (Barrier) Compute Doublings 1: D[0] ← P 2: for i = 1 to 21 do 3: //Doubling LD projective D[i ] ← D[i − 1] × 2 4: end for

5: signal to thread addition 6: for i = 22 to M − 1 do 7: //Doubling LD projective D[i ] ← D[i − 1] × 2 8: end for Compute Additions 9: Q ← O

10: Wait for signal from thread Doubling 11: for i = 0 to M − 1 do

12: if ki= 1then

13: //Full LD projective addition Q ← Q + D[i ]

14: end if 15: end for

(Barrier) 16: return Q

(30)

Rappel sur le Halving

Si Q est un point de la courbe d’ordre impair, il appartient à un sous groupe au sein duquel le halving de Q(u, v ) est l’unique point P(x, y ) tel que P = Q/2.

(u, v ) = 2 · (x, y )

λ = x + y /x, (1)

u = λ2+ λ + a, (2)

v = x2+ u(λ + 1). (3)

Pour effectuer le calcul de P :

on résoud l’équation (2): λ2+ λ = u + a → λ (Quadratic Solver); on résoud l’équation (3): x2 = v + u(λ + 1) → x (Square Root); on calcule y (1): y = λx + x2_.

→ un halving nécessite : 1 Quadratic Solver, 1 Square Root, 1 M et 1 S.

(31)

Rappel sur le Halving

(u, v ) = 2 · (x, y )

λ = x + y /x, (1)

u = λ2+ λ + a, (2)

v = x2+ u(λ + 1). (3)

on résoud l’équation (2): λ2+ λ = u + a → λ (Quadratic Solver); on résoud l’équation (3): x2 = v + u(λ + 1) → x (Square Root); on calcule y (1): y = λx + x2.

(32)

Rappel sur le Halving

(u, v ) = 2 · (x, y )

λ = x + y /x, (1)

u = λ2+ λ + a, (2)

v = x2+ u(λ + 1). (3)

on résoud l’équation (2): λ2+ λ = u + a → λ (Quadratic Solver); on résoud l’équation (3): x2 = v + u(λ + 1) → x (Square Root); on calcule y (1): y = λx + x2.

(33)

Halve-and-add parallèle

Require: scalar k, P ∈ F2m of odd order r .

Ensure: kP.

1: Recode: k0_{= k · 2}m _{mod r .}

2: Compute NAFk0_{, NAF representation of k}0_(Barrier)

Compute Halvings 3: H[M − 1] ← P 4: H[M − 2] ← P/2 5: for i = M − 2 downto M − 11 do 6: //Halving H[i ] ← H[i + 1]/2 7: end for

8: signal to thread addition 9: for i = M − 12 downto 0 do 10: H[i ] ← H[i + 1]/2 // 11: end for

Compute Additions

12: Wait for signal from thread halving 13: Q ← O

14: for i = M − 1 downto 0 do 15: if NAFk0

i = 1then

16: Q ← Q + H[i ] //mixed addition

projective-affine 17: end if

18: if NAFk0

i = −1then

19: Q ← Q − H[i ] //mixed addition

projective-affine 20: end if

21: end for

(Barrier) 22: return Q

(34)

Parallélisation Right-to-left Algorithme parallèle Halving/Doubling

Table des matières

1 Problématique

Comparaison Left-to-right/Right-to-left

Algorithme parallèle Halving/Doubling

Synthèse sur ces algorithmes

(35)

Algorithme parallèle

Le scalaire k est recodé en k0 = k · 2`−1 mod #< P > :

k = k02−(`−1) = ( m−1 X i =0 k_i02i)2−(`−1)= `−1 X i =0 k_i02i −(`−1) | {z } ≤0 powers of2 + m−1 X i =` k_i02i −(`−1) | {z } >0powers of2

On en déduit l’algorithme suivant :

Recode k

k is split in two subkeys (> 0 powers of 2, and ≤ 0 powers of 2).

. & Double-and-add // (2 threads) ComputePm−1 i =` k 0 i2 i −(`−1)_{· P.} Halve-and-add // (2 threads) ComputeP`−1 i =0k 0 i2 i −(`−1)_{· P.} thread 1 Compute doublings of P thread 2 Compute additions thread 3 Compute halvings of P thread 4 Compute additions & . Final reconstruction Q = k · P.

(36)

Algorithme parallèle

Recode k

. & Double-and-add // (2 threads) ComputePm−1 i =` ki02i −(`−1)· P. Halve-and-add // (2 threads) ComputeP`−1 i =0ki02i −(`−1)· P. thread 1 Compute doublings of P thread 2 Compute additions thread 3 Compute halvings of P thread 4 Compute additions & . Final reconstruction Q = k · P.

(37)

Algorithme parallèle

Recode k

. & Double-and-add ComputePm−1 i =` k 0 i2 i −(`−1)_{· P.} Halve-and-add ComputeP`−1 i =0k 0 i2 i −(`−1)_{· P.} . & Double-and-add // (2 threads) ComputePm−1 i =` k 0 i2 i −(`−1)_{· P.} Halve-and-add // (2 threads) ComputeP`−1 i =0k 0 i2 i −(`−1)_{· P.} thread 1 Compute doublings of P thread 2 Compute additions thread 3 Compute halvings of P thread 4 Compute additions & . Final reconstruction Q = k · P.

(38)

Algorithme parallèle

Recode k

. & Double-and-add ComputePm−1 i =` k 0 i2 i −(`−1)_{· P.} Halve-and-add ComputeP`−1 i =0k 0 i2 i −(`−1)_{· P.} & . Final reconstruction Q = k · P. . & Double-and-add // (2 threads) ComputePm−1 i =` ki02i −(`−1)· P. Halve-and-add // (2 threads) ComputeP`−1 i =0ki02i −(`−1)· P. thread 1 Compute doublings of P thread 2 Compute additions thread 3 Compute halvings of P thread 4 Compute additions & . Final reconstruction Q = k · P.

(39)

Algorithme parallèle

Recode k

. & Double-and-add ComputePm−1 i =` k 0 i2 i −(`−1)_{· P.} Halve-and-add ComputeP`−1 i =0k 0 i2 i −(`−1)_{· P.} & . Final reconstruction Q = k · P.

Cet algorithme lance donc 2 threads (référence) !

.

&

Double-and-add //

(2 threads)

Compute

Pm−1

i =`

k

i0

2

i −(`−1)

·P.

Halve-and-add

//

(2 threads)

Compute

P`−1

i =0

k

i0

2

i −(`−1)

· P.

thread 1

Compute

doublings

of P

thread 2

Compute

additions

thread 3

Compute

halvings

of P

thread 4

Compute

additions

&

.

Final

recon-struction

Q = k · P.

(40)

Algorithme parallèle

Recode k

(41)

Algorithme parallèle

Recode k

(42)

Parallélisation Right-to-left Synthèse sur ces algorithmes

Table des matières

1 Problématique

Comparaison Left-to-right/Right-to-left Algorithme parallèle Halving/Doubling

(43)

Synthèse sur ces algorithmes

Stratégies d’implémentation : langage C ;

utilisation du jeux d’instructions SSE2/AVX (processeur Intel core i7, multiplication PCLMULQDQ, 128 bits) ;

compilateur gcc 4.6.3, option -O3 ; bibliothèque PThread ;

optimisations de l’état de l’art (opérations combinées, lazy reduction...) ;

courbes elliptiques sur F2m : NIST B233 et B409.

Algorithmes parallèles

courbe NIST Double-and-add Halve-and-add Parallel R-L WNAF R-L WNAF R-L WNAF L-R 2 threads L-R seq. 2 threads L-R seq. 4 threads 2 threads B233 130696 159000 98872 135000 104492 98000

(-18,6 %) (-26,7 %) (+6,6 %) B409 615328 706000 407772 539000 326436 347000

(-12,8 %) (-24,3 %) (-5,9 %)

Nombre de cycles (minimum sur 2000 exécutions, implémentations en C, Optiplex 990, Intel core i7, TurboMode et hyperthreading désactivés)

(44)

Synthèse sur ces algorithmes

Résultats (performances) :

courbe NIST Double-and-add Halve-and-add Parallel R-L WNAF R-L WNAF R-L WNAF L-R 2 threads L-R seq. 2 threads L-R seq. 4 threads 2 threads

B233 130696 159000 98872 135000 104492 98000

(-18,6 %) (-26,7 %) (+6,6 %)

B409 615328 706000 407772 539000 326436 347000

(-12,8 %) (-24,3 %) (-5,9 %)

(-18,6 %) (-26,7 %) (+6,6 %) B409 615328 706000 407772 539000 326436 347000

(-12,8 %) (-24,3 %) (-5,9 %)

(45)

Synthèse sur ces algorithmes

(-18,6 %) (-26,7 %) (+6,6 %) B409 615328 706000 407772 539000 326436 347000

(-12,8 %) (-24,3 %) (-5,9 %)

(46)

Montgomery parallèle Une attaque : Simple Power Analysis

Table des matières

1 Problématique

(47)

ECSM vulnérable : cas Double-And-Add

Require:k = (kt−1, . . . , k1, k0), P ∈ E (F2m) Ensure:Q = k · P

1:Q ← O

2:fori from t − 1 downto 0 do

3: Q ← 2 · Q 4: ifk_i= 1 then 5: Q ← Q + P 6: end if 7:end for 8:return (Q)

→ Vulnérable : pas de régularité des opérations

(48)

ECSM vulnérable : cas Double-And-Add

Require:k = (kt−1, . . . , k1, k0), P ∈ E (F2m) Ensure:Q = k · P

1:Q ← O

2:fori from t − 1 downto 0 do

3: Q ← 2 · Q 4: ifk_i= 1 then 5: Q ← Q + P 6: end if 7:end for 8:return (Q)

→ Vulnérable : pas de régularité des opérations

(49)

Montgomery parallèle Une contre mesure à l’attaque SPA : Montgomery

Table des matières

1 Problématique

(50)

Une contre mesure à l’attaque précédente : Montgomery

Montgomery

Require: k = (kt−1, . . . , k1, k0) with kt−1= 1, P ∈ E (Fq)

Ensure: Q = k · P

1: Q0 ← P, Q1← 2P

3: if (ki = 0) then 4: Q1← Q0+ Q1, Q0← 2 · Q0 5: else 6: Q0← Q0+ Q1, Q1← 2 · Q1 7: end if 8: end for 9: return (Q0)

(51)

Comment cet algorithme fonctionne-t-il ?

Exemple : k = 4510= 0x 2D = [1, 0, 1, 1, 0, 1]2 On initialise : Q0 = P; Q1 = 2P. 1: if (ki = 0) then 2: Q1 ← Q0+ Q1,Q0← 2 · Q0 3: else 4: Q0 ← Q0+ Q1,Q1← 2 · Q1 5: end if i init 4 3 2 1 0 ki 1 0 1 1 0 1 Q0 P 2P 5P 11P 22P 45P Q1 2P 3P 6P 12P 23P 46P

Valeur retournée par l’algorithme :

(52)

Comment cet algorithme fonctionne-t-il ?

(53)

Comment cet algorithme fonctionne-t-il ?

(54)

Comment cet algorithme fonctionne-t-il ?

(55)

Comment cet algorithme fonctionne-t-il ?

→ Q

₀

= 45P

⇐

Double : Q0← 2 · Q0 (Q1← Q0+ Q1= 2 · Q0+ P d’où Q1− Q0= P)

(56)

Comment cet algorithme fonctionne-t-il ?

→ Q

₀

= 45P

⇐

Double-and-add : Q0← Q0+ Q1= 2 · Q0+ P (Q1← 2 · (Q0+ P) d’où Q1− Q0= P)

(57)

Comment cet algorithme fonctionne-t-il ?

(58)

Comment cet algorithme fonctionne-t-il ?

→ Q

₀

= 45P

⇐

(59)

Comment cet algorithme fonctionne-t-il ?

(60)

Comment cet algorithme fonctionne-t-il ?

(61)

Comment cet algorithme fonctionne-t-il ?

→ Q

₀

= 45P

⇐

Double : Q0← 2 · Q0 (Q1← Q0+ Q1= 2 · Q0+ P d’où Q1− Q0= P)

(62)

Comment cet algorithme fonctionne-t-il ?

→ Q

₀

= 45P

⇐

(63)

Comment cet algorithme fonctionne-t-il ?

(64)

Comment cet algorithme fonctionne-t-il ?

(65)

Résultats de performances

Résultats des implémentations, multiplication scalaire de point de courbe elliptique.

Comparaison

Algorithmes Montgomery’s WNAF Halve-and-add Binary Ladder

B233

157307

135000

B409

734256

539000

(66)

Montgomery parallèle Variantes : Montgomery-Halving et Montgomery parallèle

Table des matières

1 Problématique

Variantes : Montgomery-Halving et Montgomery parallèle

(67)

Construction avec Halving

Comme pour l’algorithme de Montgomery classique (avec doublings), on recherche :

la régularité des opérations ;

la différence constante entre les deux points Q0 et Q1 calculés au long

de la multiplication scalaire.

Pour un algorithme Montgomery-Halving, on est contraint à un recodage du scalaire k comme suit :

(68)

Construction avec Halving

(69)

Construction avec Halving

(70)

Construction avec Halving

(71)

Algorithme Montgomery Halving

Montgomery Halving Require: k = Pt−1 i =0ki · 2 i ₌ Pm i =0 k_i0 2i mod n, ki0 ∈ {0, 1} = (k_t−10 , . . . , k₁0, k₀0) with k_t−10 = 1, P ∈ E (Fq) Ensure: Q = k · P 1: Q0← P, Q1← −P

2: for i from t − 2 downto 0 do 3: if (k_i0= 0)then 4: T ← Q0/2, Q0← T , Q1← Q1− T 5: else 6: T ← Q1/2, Q1← T , Q0← Q0− T 7: end if 8: end for 9: return (Q0)

Les deux critères recherchés sont maintenant bien remplis :

la régularité recherchée est bien obtenue, de 1H + 1A à chaque itération ; maintenant, on a Q1,j− Q0,j = −2 · P à chaque itération ;

(72)

Algorithme parallèle

Le scalaire k est recoded en k0_{= k · 2}`−1 _{mod #< P > , et on a dans ce cas :}

k = k02−(`−1)= ( m−1 X i =0 k_i02i)2−(`−1)= `−1 X i =0 k_i02i −(`−1) | {z } ≤0powers of2 + m−1 X i =` k_i02i −(`−1) | {z } >0powers of2

Parallel Montgomery Halving/Doubling

Require: scalar k, P ∈ F2mof odd order r , constant `.

Ensure: kP.

1: Recode: k0_{= 2}`−1_{k mod r . (Barrier)}

2: Compute

Montgomery Doubling ECSM QD← [(kt0, . . . , k`0)] · P

3: Compute

Montgomery Halving ECSM QH← [(k`−10 , . . . , k

0 0)/2`] · P

(Barrier)

(73)

Algorithme parallèle

Le scalaire k est recoded en k0_{= k · 2}`−1 _{mod #< P > , et on a dans ce cas :}

k = k02−(`−1)= ( m−1 X i =0 k_i02i)2−(`−1)= `−1 X i =0 k_i02i −(`−1) | {z } ≤0powers of2 + m−1 X i =` k_i02i −(`−1) | {z } >0powers of2

Parallel Montgomery Halving/Doubling

Require: scalar k, P ∈ F2mof odd order r , constant `.

Ensure: kP.

1: Recode: k0_{= 2}`−1_{k mod r . (Barrier)}

2: Compute

Montgomery Doubling ECSM QD← [(kt0, . . . , k`0)] · P

3: Compute

Montgomery Halving ECSM QH← [(k`−10 , . . . , k

0 0)/2`] · P

(Barrier)

(74)

Montgomery parallèle Synthèse sur ces algorithmes

Table des matières

1 Problématique

Variantes : Montgomery-Halving et Montgomery parallèle

(75)

Synthèse sur ces algorithmes

Algorithmes Montgomery’s Binary Ladder

B233 Doubling Halving Parallel Gain (//-Doubling) 157307 707385 149117 5,09 % B409 Doubling Halving Parallel Gain (//-Doubling)

734256 4212043 659460 10.5%

(76)

Synthèse sur ces algorithmes

Algorithmes Montgomery’s Binary Ladder

B233 Doubling Halving Parallel Gain (//-Doubling) 157307 707385 149117 5,09 % B409 Doubling Halving Parallel Gain (//-Doubling)

734256 4212043 659460 10.5%

(77)

Conclusion et travaux en cours

Conclusion et Travaux en cours

Nous avons passé en revue les deux principales approches sur lesquelles nous travaillons, et conclu sur des résultats d’implémentation.

Travaux en cours :

débuts d’implémentation hardware (VHDL) en collaboration avec l’équipe CAIRN à l’IRISA (Lannion) ;

implémentation sur Fp ;

gestion des threads ;

Conclusion :

les performances de tous ces algorithmes restent perfectibles ; l’évaluation de la robustesse aux attaques reste théorique ; on n’en est qu’au début !

(78)

Conclusion et Travaux en cours

Travaux en cours :

Conclusion :

(79)

Conclusion et Travaux en cours

Travaux en cours :

Conclusion :

(80)

Conclusion et Travaux en cours

Travaux en cours :

gestion des threads ; Conclusion :

(81)

Conclusion et Travaux en cours

Travaux en cours :

les performances de tous ces algorithmes restent perfectibles ;

l’évaluation de la robustesse aux attaques reste théorique ; on n’en est qu’au début !

(82)

Conclusion et Travaux en cours

Travaux en cours :

les performances de tous ces algorithmes restent perfectibles ; l’évaluation de la robustesse aux attaques reste théorique ;

(83)

Conclusion et Travaux en cours

Travaux en cours :

(84)

Algorithmes Parallèles de Multiplication Scalaire Optimisée sur Courbes Elliptiques Binaires

HAL Id: lirmm-01121960

https://hal-lirmm.ccsd.cnrs.fr/lirmm-01121960

Algorithmes Parallèles de Multiplication Scalaire

Optimisée sur Courbes Elliptiques Binaires

Jean-Marc Robert

To cite this version:

Approches Parallèles de Multiplication Scalaire

sur Courbe Elliptique Binaire

Table des matières

Table des matières

Échange de clé de Diffie-Hellmann





→La multiplication scalaire est la principale opération

effectuée a · P.

Échange de clé de Diffie-Hellmann





→La multiplication scalaire est la principale opération

effectuée a · P.

Échange de clé de Diffie-Hellmann





→La multiplication scalaire est la principale opération

effectuée a · P.

Échange de clé de Diffie-Hellmann





→La multiplication scalaire est la principale opération

effectuée a · P.

Échange de clé de Diffie-Hellmann





→La multiplication scalaire est la principale opération

effectuée a · P.

Notre groupe : Courbe Elliptique

Notre groupe : Courbe Elliptique

Notre groupe : Courbe Elliptique

Table des matières

Opérations entre points de courbe elliptique

Opérations entre points de courbe elliptique

Points de Courbes Elliptiques : Coordonnées Projectives

Points de Courbes Elliptiques : Coordonnées Projectives

Points de Courbes Elliptiques : Coordonnées Projectives

Table des matières

L’Algorithme de Produit Scalaire : Double-and-add

L’Algorithme de Produit Scalaire : Double-and-add

L’Algorithme de Produit Scalaire : Double-and-add

Amélioration de Double-and-add : NAF et W-NAF.

Amélioration de Double-and-add : NAF et W-NAF.

Table des matières

Comparaison Left-to-right/Right-to-left

Comparaison Left-to-right/Right-to-left

Comparaison Left-to-right/Right-to-left

Double-and-add parallèle

Rappel sur le Halving

Rappel sur le Halving

Rappel sur le Halving

Halve-and-add parallèle

Table des matières

Algorithme parallèle

Algorithme parallèle

Algorithme parallèle

Algorithme parallèle

Algorithme parallèle

Cet algorithme lance donc 2 threads (référence) !

.

&

Double-and-add //

(2 threads)

Compute

Pm−1

k

2

·P.

Halve-and-add

//

(2 threads)

Compute

₀

₀

₀

₀

₀