FR2859585A1

FR2859585A1 - Reduction modulaire pour un procede cryptographique, et coprocesseur pour la realisation d'une telle reduction modulaire

Info

Publication number: FR2859585A1
Application number: FR0310445A
Authority: FR
Inventors: Jean Francois Dhem
Original assignee: Gemplus Card International SA; Gemplus SA
Current assignee: Gemplus SA
Priority date: 2003-09-04
Filing date: 2003-09-04
Publication date: 2005-03-11
Also published as: US20070162530A1; WO2005024627A2; EP1660989A2; WO2005024627A3

Abstract

L'invention concerne un procédé cryptographique au cours duquel, pour réaliser une division entière polynomiale de type Q(x) = └ U(x) / N (x) ┘, où Q(x), N(x) et U(x) sont des polynômes, respectivement un résultat, un dividende et un diviseur, on réalise une multiplication de deux polynômes puis un décalage des bits du résultat de la multiplication.On réalise finalement l'opération suivante, sur le corps des polynômes Fp[x] :L'invention permet de réaliser également des opérations plus complexes, y compris des opérations modulaire.L'invention est une alternative à la méthode de Montgomery : elle ne nécessite pas de correction. Elle est notamment intéressante pour des procédés cryptographiques au cours desquels on réalise des opérations polynômiales sur le corps F2[x].L'invention concerne également un coprocesseur approprié pour la mise en oeuvre du procédé.Application préférée : cartes à puces

Description

REDUCTION MODULAIRE POUR UN PROCEDE CRYPTOGRAPHIQUE, ET
COPROCESSEUR POUR LA REALISATION D'UNE TELLE REDUCTION MODULAIRE
La présente invention concerne un procédé cryptographique au cours duquel on réalise un division entière polynômiale de type Q(x) = L U(x) / N(x) J, où Q(x), N(x) et U(x) sont des polynômes, respectivement un quotient, un diviseur et un dividende. L'invention concerne également un composant électronique comprenant des moyens de mise en #uvre d'un tel procédé. L'invention est notamment applicable pour la mise en #uvre de procédés cryptographiques du type à clé publique sur courbe elliptique, par exemple dans des cartes à puce.

Les algorithmes à clé publique sur courbe elliptique permettent des applications cryptographiques de type chiffrement, signature numérique, authentification... Ils sont notamment très utilisés dans des applications de type carte à puce, parce qu'ils permettent d'utiliser des clés de faible longueur, autorisant des temps de traitement assez courts.

Pour réaliser une réduction modulaire de type S = U mod N, il est connu de réaliser tout d'abord une division entière de type Q = L U/N J, visant à calculer le quotient Q défini par la relation Q*N+S = U, puis de déterminer le reste de la division entière, reste qui est égal au résultat de la réduction modulaire.

Un procédé connu pour réaliser des divisions entières sur des nombres entiers est l'algorithme de Montgomery, dit de droite à gauche, décrit notamment dans Dl (Menezes, A., Van Oorschot, P., Vanstone, S.

Handbook of Applied Cryptography, CRC Press 1997).

La pratique montre cependant que, pour réaliser des calculs sur courbes elliptiques, on peut travailler soit sur des entiers (dans Zp) soit sur des polynômes dans Fq(x), q étant un entier. Dans la présente invention,

nous ne traiterons que le cas traitant des polynômes dans Fq(x) .

Le procédé initial de Montgomery a donc été adapté pour la réalisation de calculs modulaires sur des polynômes dans le corps F2[x]. Voir notamment à ce sujet D2 (Koç, c., Acar, T. : Montgomery multiplication in GF(2k) , ed. : Designs, Codes and Cryptography, Volume 14, Boston 1998, pp 57-69). Cet algorithme adapté réalise notamment une division entière polynomiale de U(x) par N (x) notée. Q (x) défini par la relation U(x) = Q(x).N(x) + S(x), S(x) étant le reste de la division. La notation L A(x)/B(x) J signifie partie entière par défaut de A(x)/B(x).

S(x) est le reste de la division entière polynomiale, il est aussi égal au résultat de la réduction modulaire polynomiale U(x) mod N(x). Le degré du polynôme N(x) est noté deg(N). On définit également a = deg(U) - deg(N). Dans la plupart des applications, telles que les cryptosystèmes sur courbes elliptiques, N(x) est fixé et constant, du moins lorsqu'on travaille sur une courbe elliptique donnée.

L'algorithme de Montgomery adapté est très souvent utilisé pour des implémentations logicielles de cryptosystèmes (ensemble d'un procédé de chiffrement déchifrement et d'un procédé de signature authentification) sur courbes elliptiques tels que ECDSA, utilisant des représentations polynomiales. voir par exemple à ce sujet D3 : IEEE Std 1363-2000 standard spécifications for public-key cryptography, New York, 2000) .

Le procédé de calcul modulaire sur des polynômes selon Montgomery est certes efficace, mais il présente l'inconvénient d'introduire pendant le calcul un facteur d'erreur, connu sous le nom de constante de Montgomery, facteur d'erreur qu'il est nécessaire de corriger à la fin d'un calcul pour obtenir un résultat correct. On

constate dans la pratique que les étapes nécessaires à l'élimination du facteur d'erreur sont particulièrement consommatrices de temps de calcul et de ressources (place mémoire, nombre d'accès mémoire, nombre d'opérations à réaliser, etc. ), ce qui peut être est rédhibitoire pour des applications telles que les cartes à puce où le temps et les ressources sont limitées.

Un premier objet de l'invention est de proposer, pour la mise en #uvre d'un procédé cryptographique, une alternative au procédé de Montgomery au moins aussi performante, en terme d'utilisation des ressources ou de temps de calcul, mais ne présentant pas les inconvénients du procédé de calcul de Montgomery. L'invention détermine la partie entière du quotient de deux polynômes, et peut être utilisée pour réaliser des opérations plus complexes, y compris des opérations modulaires dans le corps des polynômes.

Ainsi, selon l'invention, pour réaliser une division entière polynomiale de type Q(x) = L U(x)/N(x) J, où Q (x), N (x) et U (x) des polynômes, respectivement un résultat, un dividende et un diviseur, on réalise une multiplication de deux polynômes puis un décalage des bits du résultat de la multiplication.

On réalise la multiplication des deux polynômes suivants : #U(x)/xp], correspondant au dividende décalé de p bits, p étant la taille du diviseur N, et #xp+ss / N(x)J, résultat de la division d'un monôme xp+ss par le diviseur N, P étant un entier supérieur ou égal à a. On décale ensuite de P bits le résultat de la multiplication. On réalise finalement l'opération globale suivante :

Q(x)= [u(x)/xPJ<lxP + |3/N(x)j x

Comme on le verra mieux par la suite, la mise en #uvre pratique d'une telle opération ne nécessite pas plus de ressources, et peut être exécutée aussi rapidement que l'algorithme de Montgomery.

Par ailleurs, comme on le verra plus en détail également par la suite, le procédé selon l'invention produit un résultat exact, il n'introduit pas d'erreur et aucune correction d'erreur n'est nécessaire à la fin du procédé ; les besoins en mémoire pour les données et en ROM pour le code sont donc plus faibles que pour les procédés équivalents connus, notamment l'algorithme de Montgomery. Ceci est notamment intéressant pour des applications à contrainte (ex carte à puce).

Le procédé selon l'invention est en pratique basé sur un procédé de division modulaire sur des entiers, procédé dit de gauche à droite décrit par Barrett dans le document D4 (Barrett, P : Implementing the Rivest Shamir and Adleman public key encryption algorithm on a standard digital processor, CRYPTO'86, volume 263 of Lecture Notes in Computer Science, Springer Verlag 1987, pp 311-323).

L'algorithme de Barrett est basé sur la méthode scolaire de division, consistant à mettre à zéro les bits de poids les plus forts du numérateur, puis à ajouter ou retrancher un multiple du dénominateur. L'algorithme de Barrett est modifié selon l'invention pour réaliser le calcul d'un quotient dans le corps Fp[x] des polynômes (ie l'ensemble des polynômes dont le coefficient de chaque monôme est un entier compris entre 0 et p-1).

On définit Q (x) la relation suivante :

et on va montrer ci-dessous que, pour une valeur appropriée de (3, Q (x) est égal au quotient Q (x) recherchédéfini par la relation Q(x) = L U (x) / N (x) J.

Pour cela, on note Np (x) indiquer que le polynôme N (x) de taille p. On définit par ailleurs :

U(x) (x) Qp-1(x) xP '*'a x + xp où a(x) et cpp-i (x) sont respectivement le quotient et le reste de la division de U(x) par xP. De la même manière on peut écrire :

- xp+ rp (x) + il'p ~1(x) N (x) Np(x)

où Fp (x) et ;p-1 (x) sont respectivement le quotient et le reste de la division de xp+ss par N(x).
On peut écrire :

Les trois derniers termes du développement de Q(x) sont nuls si ss # a. Dans ce cas, on a :

Il n'y a pas d'intérêt à choisir ss > a. De plus un tel choix demande plus de calcul que de choisir P = a puisque R (x) plus long. En d'autres termes, en choisissant P = a = deg(U) - deg(N), le quotient Q(x) peut être calculé par l'équation 1 :

On rappelle que diviser un numérateur par xP revient à décaler les bits du dit numérateur de ss bits vers la droite. Par ailleurs, p, ss et N(x) étant fixés, on peut calculer dans une phase initiale R(x) = L xp~b / N (x) J. Ainsi, selon le procédé de l'invention, le calcul du quotient se réduit à un décalage de p bits, une multiplication polynomiale T (x)*R(x) un décalage de ss bits.

Le procédé selon l'invention, mettant en #uvre l'équation 1, est utilisable sur le corps Fp [x] polynômes, quel que soit p.

Le procédé selon l' invention peut être mis en #uvre dans tout polynôme d'architecture t-bits, par exemple 32 bits, dans lequel la multiplication modulaire polynomiale est implémentée.

Le procédé selon l'invention est notamment avantageusement utilisable pour réaliser des réductions modulaires polynômiales dans le corps F2[x]. Dans F2[x], les coefficients ni du nombre polynomial N(x) = np.xp + np-1.xp-1 +... + nl.xl + no sont égaux soit à 1 soit à 0. Ceci donne une représentation binaire des polynômes dans F2[x] : les bits de poids les plus forts de la représentation (= un nombre binaire associé au polynôme) sont les coefficients associés aux monômes de

plus forte puissance du polynôme. Par exemple, le polynôme x5 + x3 + 1 peut être représenté par le nombre binaire '101001'.

La multiplication modulaire dans F2[x] est une des opérations les plus importantes dans la cryptographie sur courbes elliptiques sur le corps de Gallois GF(2P) de taille p. On va montrer ci-dessous qu'on peut obtenir, avec le procédé selon l'invention décrit de manière générale dans les paragraphes précédents, des performances similaires à ce qu'on peut obtenir en utilisant la multiplication modulaire de Montgomery dans GF (2) (voir Dl).

La multiplication modulaire polynômiale A(x)B(x) mod N(x) peut être écrite comme une somme de produits : pA-1 it Q(x) = # Ai(x) x B(x) x xit mod N (x) U (x) N(x) (EQ. 2 ) i=0 avec Ai(x) un polynôme de degré t-1, pA-1 it

A(x) = E Ai(x) x xlt , PA=f P / t l, et Pa le degré de i=0 A(x). La notation r X 1 signifie partie entière par excès de X.

Avant de décrire plus longuement la réduction modulaire dans F2[x] selon l'invention, il convient de rappeler quelques caractéristiques des calculs polynomiaux dans F2(x).

* Le produit d'un polynôme de degré t-1 (qui peut être représenté comme un vecteur binaire de t bits) par un polynôme de degré n-1 est un polynôme de degré n+t-2 représenté comme un vecteur de n+t-1 bits. En comparaison, sur les entiers, le résultat du produit d'un nombre de t bits par un nombre de n bits est un entier de n+t bits.

* Le résultat de l'addition polynomiale de deux polynômes de degré p est un polynôme de degré p (même nombre de bits dans sa représentation binaire). Sur les

entiers, le résultat d'une addition peut avoir un bit de plus dans sa représentation binaire à cause d'une éventuelle propagation de retenue.

* L'opération "modulo" (le reste de la division de deux polynômes) donne un polynôme de degré strictement plus petit que le diviseur appelé module. Cela signifie que le vecteur binaire représentant le reste a toujours un bit de moins que le vecteur représentant le module.

* Sur les entiers, le reste est plus petit que le module mais peut avoir le même nombre de bits dans sa représentation binaire.

On va maintenant évaluer comment changer le quotient Q (x) l'équation 1 (calcul général dans Fp[x]) dans le cas de l'équation 2 (appliqué au calcul dans F2[x]). Pour réduire la mémoire nécessaire et le nombre d'accès à la mémoire, l'équation 2 peut être réalisée en entrelaçant la multiplication depuis le plus fort index de Ai jusqu'au plus faible avec la réduction par N (x). obtient l'algorithme 1 ci-dessous qui réalise une multiplication modulaire dans F2(x):
1 : U(x) = 0
2: Pour i variant de PA - 1 à 0
3 : U(x) = U(x).xt # Ai(x)B(x)
4: Q(x) = Lu(x)/N(x)J
5: U(x) = U (x) # Q (x) N (x) (équivalent à U(x) = U(x)mod N(x) )
6 : Fin pour
7 : Retourner Q(x)
Ai est le mot de poids i de A, # est la fonction logique XOR.

On note que, pour réaliser une multiplication modulaire selon l'algorithme 1, seules des

multiplications standard sont nécessaires, de même que dans l'algorithme de Montgomery décrit dans D2.

Pour la méthode de Montgomery, une multiplication polynômiale de t bits (avec des polynômes de degré t-1) et une division par xt (un décalage de t bits) sont nécessaires (voir D2). Pour l'algorithme 1, une multiplication polynômiale de t bits et une division par xt-1 sont nécessaires. Le reste des calculs est le même pour la méthode de l'invention et celle de Montgomery.

Seul l'ordre dans lequel les calculs sont effectués est différent : dans l'invention, on commence à partir du mot de poids le plus fort ApA-1 au lieu du mot de poids le plus faible Ao comme dans Montgomery.

Dans l'algorithme 1, il est possible de réduire les accès mémoire quand on manipule U (x). est très important car les accès mémoire sont un important goulot d'étranglement en terme de réduction de vitesse d'exécution, particulièrement pour les applications cartes à puce. Pour cela, le premier calcul ApA(x)B(x) est sorti de la boucle sur i (cf algorithme 2) de sorte que la boucle sur i puisse commencer avec le calcul du quotient (Q(x) ) et les deux calculs de U (x) lignes 3 et 5 de l'algorithme 1 peuvent être regroupés en la ligne 5 de l'algorithme 2 ci-dessous (multiplication entrelacée dans F2(x)) :
1: U(x) = ApA-1(x) .B (x)
2: Pour i variant de pA-2 à 0
3 : Q (x) =L (T(x) R (x) ) /xt-1
4 : Pour j variant de 0 à PN-1

5: U(x) = [U(x) 0 Q (x) Nj (x) ] .xt (j+1) C Ai(x) .B(j) xt' 6: Fin pour j 7: Fin pour i 8: Q = L (T (x) .R(x))/xt-1 9: U(x) = U (x) # Q(x) .N(x)

Ces modifications nécessitent une réduction finale en dehors de la boucle i (lignes 8 et 9 de l'algorithme 2) .

Le seul désavantage d'entrelacer la multiplication et la phase de réduction en utilisant une unique boucle j est que le nombre de Nj(x) et de Bj(x) doit être identique (PB = pN), signifiant que si, par exemple, le degré de B(x) est plus petit que celui de N(x), on doit compléter par des zéros lorsqu'on le mémorise dans les B[j]. Cependant, ceci n'influence pas la vitesse des implémentations pratiques puisque B (x) normalement considéré de taille identique à N(x).

Une implémentation logicielle de l'algorithme 2 sur un processeur d'architecture t-bits va maintenant être décrite.

Pour des soucis de clarté et de facilité de comparaison avec une implémentation existante, on supposera dans l'exemple ci-dessous que p = pA = pN, en d'autres termes que les nombres A et N sont de p bits.

Le détail de l'implémentation donnée à titre d'exemple correspond à l'algorithme 4.

Dans cet algorithme 4, (HI, LO) est un registre virtuel de 2t bits (un tel registre est classique dans une architecture RISC réalisant une multiplication de t*t bits avec un résultat sur 2t bits) qui correspond à la valeur résultant d'une concaténation de deux registres HI et LO, chacun de t bits. HI et LO sont respectivement la partie supérieure (les bits de poids les plus forts) et la partie inférieure (les bits de poids les plus faibles) du registre (HI, LO) de 2t bits. L'expression "(HI, LO)#t" signifie que le contenu du registre virtuel (HI, LO) est décalé à droite de t bits. t étant la taille des registres, le résultat est HI = 0 et LO = HI.

Dans l'algorithme 4, # représente une opération XOR bit à bit et 0 représente une multiplication polynomiale

dans F2[x] sur des polynômes de degré au plus t-1.

L'opération (HI, LO)# = A#B est un calcul de multiplication et accumulation du résultat dans HI, LO (présent sur la plupart des processeurs RISCs ou DSP) où les retenues internes dans les multiplications et les additions sont invalidées. Une représentation algorithmique de ce calcul (HI, LO)# = A # B est montrée à l'algorithme 3 ci-dessous.

Pour i variant de 0 à t-1 (HI,LO) = (HI,LO) # ( (A. ( (B i) ET 1)) i)
Fin pour i
Note : ((B i)ET 1) est en pratique le ième bit de B
Un tel calcul est déjà implémenté comme une instruction dans certains processeurs de pointe pour carte à puce pour améliorer les calculs sur courbes elliptiques dans GF(2P).

Dans l'algorithme 4 également, la notation A[j] représente le polynôme Aj(x) de degré t-1 tel que décrit à l'équation 2 (EQ2).

Enfin, Usup utilisé aux lignes 10 et 26 de l'algorithme 4 est en général égal à la valeur courante dans LO. Ceci est seulement vrai si le bit de poids le plus fort (MSB) de N[p-1] correspond au degré le plus significatif de N(x). Dans les autres cas, Usup = (LO k) + (Rg (t-k)) où k est la valeur de décalage nécessaire pour aligner le coefficient de poids le plus fort de N(x) mémorisé dans N[p-1] sur le bit de poids le plus fort de N[p-1].

Sur l'algorithme 4 est également montré le nombre d'instructions de multiplication et d'accumulation sans retenues (colonne ##) et le nombre d'accès à la mémoire (colonnes #Load et #Store). En comparaison avec le

document D2, nous avons exactement le même nombre de multiplications sans retenues, mais sans opérations XOR additionnelles. Pour être correct, la plupart des XOR sont inclus dans notre opération de multiplication et accumulations.

Ci-dessus est détaillé l'algorithme 4 de multiplication modulaire entrelacée dans F2[x].

#0 #Load #store
1: HI = 0
2: LO = 0
3: Ap-1 = A[p-1] 1
4: Pour j variant de 0 à p-1

5: (HI,LO)e = Ap-1 ED B[j] p p 6: RS = LO ; U [j] = RS p 7: (HI, LO >t 8: Fin pour j 9: Pour i variant de p-2 à 0 10: Q = (Usup R) (t-1) p-1 11: Ai = A[i] p-1 12: HI = U[0] p-1 13: LO = 0 14: (HI, LO)# = AiB[0] p-1 p-1 15: U[0] = LO p-1 16: (HI, LO) t 17: Pour j variant de 1 à p-1 18: HI = U[j] (p-1)2 19: (HI, LO)# = AiB[j] (p-1)2 (p-1)2 20: (HI, LO)# = Q#N[j-1] (p-1)2 (p-1)2 21: RS= LO; U[j] = RS (p-1)2 22: (HI, LO) t 23: Fin pour j 24: (HI, LO)# = Q#N[p-1] p-1 p-1 25: Fin pour i

26: Q = (UsupR) (t-1 ) 1
27: LO = U[0] 1
28: Pour j variant de 0 à p-2
29: HI = U[j+1] p-1
30: (HI, LO)/ = QN[j] p-1 p-1
31: U [j] = LO p-1 32: (HI, LO >t
33: Fin pour j
34: (HI, LO) / = Q#N[p-1] 1 1
35: U[p-1] = LO 1 total 2p2+p 3p2+p p2+p
Le code de l'algorithme 4 ci-dessus peut être compacté en calculant Ai(x).B(x) entrelacé avec Q(x).N(x)

et dans l'ordre inverse (voir algorithme 5), dans lequel j est décrémenté dans l'algorithme 5, ligne 11, contrairement à l'algorithme 4, ligne 17 : on calcule d'abord Ai.B[p-1] et Q(x).N[p-1]. Cela est possible car il n'y a pas de propagation de retenue en travaillant sur F2[x], contrairement à ce qui se passe lorsqu'on travaille sur des entiers.

B (x) ayant un degré inférieur à N(x), on simplifie encore les calculs en alignant le modulus N(x) à gauche lorsqu'on le mémorise dans les N[j] (ie lorsqu'on mémorise ses coefficients N [j] le répertoire associé à N), le coefficient supérieur de N(x) correspondant au bit de poids le plus fort (MSB) de N[p-1] (voir algorithme 5). Ceci nécessite une seule adaptation (décalage à droite final) au tout dernier résultat si le module N est constant sur un ensemble de multiplications.

Ceci est notamment le cas avec la plupart des algorithmes cryptographiques tels que ECDSA sur courbes elliptiques dans GF(2p) (D3).

Dans le cas présent (algorithme 5), Usup est simplement ((HI, LO) ) # (A[i] # B[p-1]) (t-l). En

effet, il n'y a pas d' influence du terme A [ i ] B [p-2 sur la partie supérieure souhaitée de U (x) le terme A[i]B[p-2] influence seulement les t-1 premiers bits de

(U[p-1], U[p-2])A[i]B[p-1]) et il n'y a pas de propagation de retenue. Une autre conséquence avantageuse d'un tel calcul est qu'il n'y a plus besoin de calculer Ap-1(x)B(x) en avance et aucune réduction finale additionnelle par Q (x)N(x) plus nécessaire de sorte que les lignes 1 à 8 et 26 à 35 de l'algorithme 4 ne sont plus nécessaires dans l'algorithme 5.

Ci-dessous est détaillé l'algorithme 5 de multiplication modulaire entrelacée, avec une boucle interne commençant dans l'ordre inverse.

## #Load #Store l:Pour j variant de 0 à p-1

2: U [j] =0 p 3: Fin pour j 4:Pour i variant de p-1 à 0 5: HI = U[p-1] p 6: LO = U[p-2] p 7: Ai = A[i] p

8: (HI, L0)e = AiB[p-1] p p 9: Q = ( (HI, LO)supR (t-1) p 10 (HI, LO) = QN[p-1] p p
11 Pour j variant de p-2 à 1
12: (HI, LO) t
13: LO = U[j-1] p(p-2) 14: (HI, LO)# = Ai#B[j] p(p-2) p(p-2)
15: (HI, LO)# = QN[j] p(p-2) p(p-2)
16: U[j+1] = HI p(p-2)
17: Fin pour j
18: (HI, LO) t
19: (HI, LO)# = Ai#B[0] p p
20: (HI, LO)# = Q#N[0] p p
21: U[l] = HI p
22: U[0] = LO p
23: Fin pour i total 2p2+p 3p2+p p2+p
Comme on le voit sur l'algorithme 5, le nombre total d'opérations est identique à celui de l'algorithme 4, seul la taille du code est un peu plus petite, le code peut donc être mémorisé dans un ROM un peu plus petite.

Excepté pour cette dernière raison, le choix entre les deux implémentations se fait en considérant l'architecture utilisée (CPU ou tout autre hardware spécifique) avec lequel les calculs sont effectués et l'application dans lequel il sera utilisé (par exemple ECDSA sur des courbes spécifiques).

L'algorithme 6 présente la multiplication modulaire de Montgomery implémentée de la même manière que l'algorithme de l'invention. La principale différence dans l'implémentation de l'invention par rapport à l'implémentation de Koç et Acar (D2), est le mélange entre la multiplication et la phase de réduction de l'algorithme pour réduire le nombre d'accès à la mémoire. Le nombre d'accès à la mémoire est bien plus faible dans

le cas de l'invention par rapport à celui nécessaire dans le cas de l'implémentation de Koç et Acar. Ils nécessitent (6p2-p) chargement et (3p2+2p+l) opérations de mémorisation.

Ci-dessous est détaillé l'algorithme 6 de multiplication modulaire entrelacée dans F2[x], selon Montgomery.

## #Load #store
1: Pour j variant de 0 à p-1
2: U [j] =0 p
3: Fin pour j
4: Pour i variant de 0 à p-1
5: Ai = A[i] p
6: LO = U[0] p
7: HI = U[l] p
8: (Rt, LO)# = AiB[0] p p
9: (HI, Q) = LO#N'0 p
10 (Rt, LO)# = QN[0] p p
11 : (HI, LO) t
12 Pour j variant de 1 à p-2
13 : HI = U[j+1] p(p-2)
14 : (HI, LO)# = AiB[j] p(p-2) p(p-2)
15 : (HI, LO)# = QN[j] p(p-2) p(p-2)
16: U[j-1] = LO p(p-2)
17 (HI, LO) t
18 Fin pour j
19 (HI, LO) t

20 (HI, L0)e = AiB[p-1] p p 21 (HI, L0)0 = QN [p-1] p p
22 U[p-2] = LO p
23 U[p-1] = HI p
24 Fin pour i total 2p2+p 3p2+p p2+p N'o (ligne 9) est défini par la relation :

N' p = N [ 0 ] (-1 ) mod xt .

Comme on le voit sur les algorithmes 4,5 et 6, la méthode selon l'invention est similaire à celle de Montgomery en terme de nombre d'opérations de type multiplication et accumulation sans retenue et de nombre d'accès mémoire. L'avantage de la méthode proposée est qu'elle calcule exactement A(x)B(x) modulo N(x), ce qui n'est pas le cas avec la méthode de Montgomery qui calcule A(x) B (x) x(-p) modulo N(x) (Dl). Le seul

inconvénient possible de la méthode selon l'invention (cela dépend du contexte) par rapport à la méthode de Montgomery peut être une plus lente extraction de Usup à partir des valeurs intermédiaires de U (x) également le décalage à droite de t-1 bits lors du calcul de Q. Ce possible inconvénient logiciel peut être simplement (avec un faible coût) pris en compte dans une implémentation hardware. Ce n'est pas le cas pour enlever l'encombrant x(-p) de la multiplication de Montgomery.

Le tableau 1 montre les résultats, en termes de cycles d'horloges, obtenus à partir de la méthode de Montgomery (algorithme 6) et de deux versions de la méthode selon l'invention (algorithmes 4 et 5). Ceci a été réalisé sur un simulateur modifié de l'architecture de processeur MIPS 32 optimisée pour Montgomery et utilisable pour des applications cartes à puce pour réaliser des opérations de multiplications sans retenues internes. multiplication multiplication
256 bits 512 bits algorithme 4 910 3230 algorithme 5 812 3028 algorithme 6 756 2916 tableau 1 vitesse des algorithmes en cycles d'horloge
Le tableau 1 donne un avantage à la méthode de Montgomery. Ceci s'explique par la complexité logicielle de l'évaluation du quotient aux lignes 10 et 26 de l'algorithme 4 et à la ligne 8 de l'algorithme 5 par rapport à la ligne 9 de l'algorithme 6 (Montgomery), le processeur utilisé ne possédant pas d'instructions permettant de tirer profit de la nouvelle architecture

proposée. Ceci ne donne cependant aucune différence dans une implémentation hardware. Par ailleurs, rappelons que les algorithmes 4 et 5, selon l'invention, présentent l'avantage de fournir un résultat exact. Au contraire, l'algorithme 6 fournit un résultat à une constante près, qu'il faut enlever à la fin de l'algorithme (ceci n'est pas inclus dans l'algorithme 6 et doit être ajouté).

Un deuxième objet de l'invention est de proposer une architecture de processeur particulièrement bien adaptée à la mise en #uvre d'un procédé selon l'invention tel que décrit ci-dessus, et notamment pour la mise en #uvre des opérations spécifiques des algorithmes 4 et 5.

Un exemple d'un bloc additionnel selon l'invention est représenté sur la figure unique jointe. Cette architecture est à considérer comme un bloc spécifique (coprocesseur) que l'on peut greffer sur un processeur existant et adapté pour la réalisation de calculs élémentaires (chargement de registre, addition, multiplication, etc. ). Le fonctionnement de ce coprocesseur sera détaillé en prenant comme exemple les opérations de l'algorithme 5. A noter que sur la figure, seuls sont représentés les chemins de données. Par souci de simplification, notamment les moyens nécessaires à la commande des différents éléments du coprocesseur n'ont pas été représentés.

Le coprocesseur de la figure se greffe sur le chemin de donnée d'un processeur existant par la voie d'un bus d'entrée IN BUS et d'un bus de sortie "OUT BUS".

Le coprocesseur comprend un circuit de calcul "Multiply-Accu", deux multiplexeurs MUX1 et MUX2 et six registres (HI, LO) , U, RBN, A, Q et k.

Le bloc "Multiply-Accu" est un bloc purement combinatoire prenant en entrée 3 valeurs (X, Y et Z) sur

deux bus de taille t-bits (X et Y) et un bus de taille 2t bits et donnant en sortie le résultat (sur 2t-bit) de l' opération (X#Y#Z).

Le multiplexeur MUX1 est un multiplexeur à trois entrées (0,1, 2) et une sortie (toutes de 2t-bits), sa sortie est connectée à l'entrée Z du circuit MultiplyAccu". Le multiplexeur MUX2 comprend trois entrées et une sortie de t-bits chacune, sa sortie est connectée à l'entrée X du circuit "Multiply-Accu". Les multiplexeurs MUX1, MUX2 sont des circuits classiques qui, en fonction d'une commande externe relie une de leurs entrées à leur sortie.

Le bloc (HI, LO) est un registre interne de 2tbits, comprenant une entrée de 2t-bits connectée à la sortie du circuit "Multiply-Accu et une sortie de 2t-bits dont les t-bits de poids les plus forts sont connectés à l'entrée du bus OUT~BUS. De plus, les 2t-bits de la sortie du bloc (HI, LO) sont connectés à l'entrée 0 du multiplexeur MUX1 et les t bits de poids faibles de la sortie du bloc (HI, LO) sont connectés aux t bits de poids forts de l'entrée 1 du multiplexeur MUX1.

Le bloc U est un registre interne de t-bits comprenant une entrée de t-bits connectée au bus IN BUS et une sortie de t bits connectés aux t bits de poids faibles des entrées 1 et 2 du multiplexeur MUX1. Les t bits de poids forts de l'entrée 2 du multiplexeur MUX1 sont forcés à zéro. Le registre U comprend également une entrée d'initialisation RESET.Le registre U est utilisé pour mémoriser le nombre U[...] utilisé dans l'algorithme 5.

Le registre RBN de t-bits comprend une entrée de tbits connectée au bus IN BUS et une sortie de t-bits connectée à l'entrée Y du circuit Multiply-Accu. Le registre RBN est utilisé pour mémoriser le nombre B[...] ou le nombre N [...] .

Le registre A de t-bits comprend une entrée de tbits connectée au bus IN BUS et une sortie connectée à l'entrée 0 du multiplexeur MUX2. Le registre A est utilisé pour mémoriser le nombre A[...].

Le registre Q de t-bits comprend une sortie de tbits connectée à l'entrée 1 du multiplexeur MUX2 et une entrée de t-bits connectée aux t-bits de poids t-1 à 2t-2 de la sortie du circuit Multiply-Accu (le bit de poids le plus fort 2t-l est nul et les bits de poids les plus faibles ne sont pas significatifs). Le registre Q est utilisé pour mémoriser une donnée intermédiaire de calcul.

Le registre k de t bits comprend une entrée de 2t-bits connectée à la sortie du registre (HI, LO) et une sortie de t-bits connectée à l'entrée 2 du multiplexeur MUX2. Le bloc k est un registre à décalage qui prend en entrée une valeur de 2t-bit, la décale de k-bit vers la droite (ce qui revient à diviser le nombre entrant par 2k) et donne un résultat de t-bit en sortie (les t premiers bits du résultat de la division par 2k).

Les opérations de lecture mémoire (faisant intervenir U[...] , B[...] , N[...] et A[...]) chargent une donnée dans les registres U, RBN ou A de taille t, les données venant d'une mémoire externe (non représentée) par l'intermédiaire du bus d'entrée "IN~BUS". Les données résultant d'une opération dans le coprocesseur seront écrites en mémoire externe par l'intermédiaire du bus "OUT bus". Les données devant être écrites en mémoire externe seront toujours stockées dans le registre "Hi" (correspondant au t-bits de poids les plus forts du registre (HI, LO) .

Le fonctionnement du coprocesseur va maintenant être décrit dans le cadre de la mise en #uvre de l'algorithme 5. Comme il a été dit précédemment, le coprocesseur n'est le plus souvent pas utilisé pour des

opérations de base telles que des opérations de boucle ou l'initialisation de données en mémoire. Par exemple, les lignes 1, 2,3, 4,11 17 et 23 de la figure 5 ne sont pas traitées par le coprocesseur mais par le processeur général auquel il est associé.

De manière générale, le processeur "maître" exécute l'algorithme et fait appel ponctuellement au coprocesseur (et donc pilote le coprocesseur) pour réaliser certaines opérations spécifiques que l'on va décrire ci-dessous.

Ces opérations spécifiques pourraient par exemple être appelées par des instructions de type coprocesseur dans une architecture dédiée ou directement intégrées aux instructions du processeur "maître".

L'opération 1 correspondant aux lignes 5 et 6 de l'algorithme 5 est réalisée de la manière suivante : a) la valeur U[p-1] est transférée de la mémoire externe vers le registre U et le registre RBN est mis à zéro par la commande RESET afin que le résultat de la multiplication réalisée par le multiplieur-accumulateur soit nul. Le MUX1 est placé en position 2 de telle manière que la sortie du multiplieur-accumulateur renvoie la valeur du registre U (U[p-1]) qui sera alors stockée dans le registre (HI, LO) qui contient ainsi (0, U[p-1]). b) la valeur U[p-2] est transférée de la mémoire externe vers le registre U et le registre RBN est mis à zéro par une commande RESET afin que le résultat de la multiplication soit nul. Le MUX1 est placé en position 1 de telle manière que la sortie du multiplieuraccumulateur renvoie la valeur du registre LO concaténée avec celle du registre U (U[p-2]). Au final, (HI,LO) va donc bien contenir (U[p-1],U[p-2]).

On notera que l'opération 1, qui correspond à des opérations de chargement de données en mémoire, pourrait être réalisée par le processeur "maître" ; est toutefois utilisée ici en parallèle pour initialiser le

coprocesseur avant la réalisation de l'opération 2 cidessous.

L'opération 2 correspondant à la ligne 7 de l'algorithme 5 consiste simplement à transférer la valeur de A[i] de la mémoire externe vers le registre A de la présente architecture via le bus "IN~BUS".

L'opération 3 correspondant à la ligne 8 , 14 ou 19 de l'algorithme 5 se fait simplement par: a) Transfert de B[p-1] (ou B[j] et B[0] respectivement aux lignes 14 et 19) de la mémoire externe vers le registre RBN. b) Les MUX2 et MUX1 sont placés en position 0. c) le résultat en sortie du multiplieuraccumulateur est placé dans le registre (HI,LO)
L'opération 4 correspondant à la ligne 9 de l'algorithme 5 est effectuée de la manière suivante: a) la valeur de la constante R, en provenance d'une mémoire externe, est placée dans le registre RBN via le bus externe "IN~BUS". b) Le registre U est remis à zéro (RESET). c) Le registre à décalage ( k) est programmé pour un décalage de t-1 (k=t-1) bits. d) Les MUX1 et MUX2 sont placés en position 2. e) La partie supérieure du résultat du calcul en sortie du multiplieur-accumulateur est stockée dans Q. Le choix de la partie supérieur du résultat est automatique (et immédiat) puisque la sortie supérieure du multiplieur-accumulateur correspondant à ce résultat est câblée directement à l'entrée du registre Q. Il est important de noter que le registre (HI, LO) ne doit pas être mis à jour par cette opération.

L'opération 5 correspondant à la ligne 10 (ou aux lignes 15 ou 20) de l'algorithme 5 est effectuée de la manière suivante: a) N[p-1] (respectivement N [j] etN[0] pour les lignes 15 et 20) est transféré dans le registre RBN. b) Le MUX1 est placé en position 0 et le MUX2 est placé en position 1. c) Le résultat en sortie du multiplieuraccumulateur est placé dans le registre (HI, LO).

L'opération 6, correspondant aux lignes 12 et 13 est réalisée de la manière suivante: a) La valeur U[j-1] est transférée de la mémoire externe vers le registre U. b) Le registre RBN est mis à zéro (RESET) afin que le résultat de la multiplication soit nul. c) Le MUX1 est placé en position 1 de telle manière que la sortie du multiplieur-accumulateur renvoie la valeur (LO, U[j-1]) qui sera alors stockée dans le registre en gris foncé (HI, LO).

L'opération 7 correspondant aux lignes 16 ou 21 est effectuée de la manière suivante : est transféré à la mémoire externe via le bus "OUT~BUS" à l'emplacement voulu (U[j+l] et U[l] respectivement).

L'opération 8 correspondant à la ligne 18 est effectuée de la manière suivante (l'opération en ligne 11 est identique mais avait été regroupée avec celle de la ligne 12 pour effectuer le travail plus rapidement, opérations pouvant être simultanées): a) Les registres U et RBN sont remis à zéro (RESET) . b) le MUX1 est placé en position 1. c) le résultat en sortie du multiplieur accumulateur est stocké dans (HI, LO)

L'opération 9 correspondant à la ligne 22 peut se faire en effectuant une opération 8 suivie d'une opération 7 sur U[0]. Les deux opérations peuvent être effectuées ensemble si nécessaire pour améliorer la vitesse.

Remarques : * les "sous opérations" a)...d) peuvent (doivent) en générale être effectuées simultanément (parallélisme) ou en utilisant une architecture "pipeline" donnant l'impression qu'elles s'effectuent réellement en une seule fois.

* Les opérations nécessitant un transfert d'une mémoire externe de/vers un registre interne pourront être réalisées par des opérations de type coprocesseur ou processeur prenant en argument l'emplacement mémoire dans lequel il faut aller chercher ou mettre la valeur traitée (opérations 1,2, 3,5, 6 et 7)

Claims

REVENDICATIONS

1. Procédé cryptographique caractérisé en ce que, pour réaliser une division entière polynomiale de type Q(x) = L U(x) / N (x) J, où Q(x), U (x) et N (x) sont des polynômes, respectivement un résultat, un dividende et un diviseur, on réalise une multiplication de deux polynômes puis un décalage des bits du résultat de la multiplication.

2. Procédé selon la revendication 1, au cours duquel on réalise la multiplication des deux polynômes suivants : LU(x) / xp#, correspondant au dividende décalé de p bits, p étant la taille du diviseur N #xp+ss / N(x)J, résultat de la division d'un monôme xp+ss par le diviseur N, (3 étant un entier supérieur ou égal à a.

3. Procédé selon la revendication 2, dans lequel on décale de (3 bits le résultat de la multiplication.

4. Procédé selon l'une des revendications 1 à 3, dans lequel on réalise l'opération suivante :

5. Procédé selon l'une des revendications précédentes, dans lequel : - le dividende est obtenu par la multiplication de deux polynômes A(x), B (x), - les polynômes A(x), B(x), le dividende U(x), le diviseur N (x) le résultat S(x) sont des polynômes définis sur F2[x], à chaque polynôme étant associé un

19 : (HI, LO)# = Ai#B[0]

18 : (HI, LO) t g : multiplication sans retenue de Ai par B[0] et accumulation du résultat dans le registre virtuel (HI, LO)

17: Fin pour j f : décalage de t bits vers la gauche du contenu du registre virtuel (HI, LO)

16 : U[j+l] = HI

15 : (HI, LO)# = Q#N[j] ee : mémorisation du contenu du registre HI dans le coefficient de polynôme U[j+l]

14 : (HI, LO)# = Ai#B[j] dd : multiplication sans retenue de Q par N [j] accumulation du résultat dans le registre virtuel (HI, LO)

13: LO = U[j-1] cc : multiplication sans retenue de Ai par B [j] accumulation du résultat dans le registre virtuel (HI, LO)

12 : (HI, LO) t bb : mémorisation du coefficient de polynôme U[j-1] dans le registre LO

11 Pour j variant de p-2 à 1 aa : décalage de t bits vers la gauche dans le registre virtuel (HI, LO)

10 (HI, LO)# = Q#N[p-1] e : décrémentation de la variable j de p-2 à 0 et pour chaque valeur de j réalisation des étapes aa à ee suivantes :

9: Q = ((HI, Lü) sup<8>R > (t-l) d : multiplication sans retenue du registre Q par N[p-l], et mémorisation dans le registre virtuel (HI, LO)

8: (HI, LO)# = Ai#B[p-1] c : multiplication sans retenue de (HI, LO)sup par R, et mémorisation dans le registre Q du résultat décalé de t-1 bits vers la droite

7 : Ai = A[i] b : multiplication sans retenue de Ai par B[p-1] et accumulation du résultat dans un registre virtuel (HI, LO) constitué des registres HI et LO

6: LO = U[p-2]

5 : HI = U[p-1]

4 : Pour i variant de p-1 à 0 a : initialisation des registres HI, LO, Ai

3: Fin pour j E2 : Décrémentation de la variable i de p-1 à 0 et pour chaque valeur de i, réalisation des étapes suivantes (a à j) :

2 : U[j] = 0

1 : Pour j variant de 0 à p-1

nombre binaire dont la valeur et le poids de chaque bit correspond à la valeur et au poids d'un coefficient du polynôme associé, et le quotient est calculé selon les étapes suivantes: El : Initialisation des coefficients du polynôme U(X)

23: Fin pour i

22 : U[0] = LO

U[0]

21 : U[l] = HI j : mémorisation du registre LO dans le coefficient de polynôme

20 : (HI, LO)# = Q#N[0] i : mémorisation du registre HI dans le coefficient de polynôme [1]

h : multiplication sans retenue de Q par N[0] et accumulation du résultat dans le registre virtuel (HI, LO)

6. Procédé selon l'une des revendications 1 à 4, dans lequel : - le dividende est obtenu par la multiplication de deux polynômes A(x), B(x), - les polynômes A(x), B(x), le dividende U(x), le diviseur N (x) le résultat S(x) sont des polynômes définis sur F2[x], à chaque polynôme étant associé un nombre binaire dont la valeur et le poids de chaque bit correspond à la valeur et au poids d'un coefficient du polynôme associé, et le quotient est calculé selon les étapes suivantes: El : Initialisation des registres HI, LO, Ap-1

1 : HI = 0

2: LO = 0

3 : Ap-1 = A[p-1] E2 : Incrémentation de la variable j de 0 à p-1 et pour chaque valeur de j, réalisation des étapes suivantes (a à c) :

4 : Pour j variant de 0 à p-1 a : multiplication sans retenue de Ap-1 par B [j] mémorisation du résultat dans un registre virtuel (HI, LO) constitué des registres HI et LO

5: (HI,Lü)E9 = Ap-1 E9 B[j] b : initialisation du registre RS et du coefficient de polynôme

U[j]

6 : RS = LO ; U [j] = RS c : décalage de t bits vers la droite dans le registre (HI, LO)

7: (HI, LO)#t

8: Fin pour j E3 : Décrémentation de la variable i de p-2 à 0 et pour chaque valeur de i, réalisation des étapes suivantes (al à gl) :

9 : Pour i variant de p-2 à 0 al : multiplication sans retenue de Usup par R et mémorisation du résultat décalé de t bits vers la droite dans le registre virtuel (HI, LO)

10 : Q = (Usup # R) (t-1) bl : initialisation des registres Ai, HI, LO

34: (HI, LO)E9 = Q(&N[p-1] E8 : mémorisation du coefficient U[p-1] contenu dans le registre LO

33: Fin pour j E7 : multiplication sans retenue de Q par N[j] et mémorisation du résultat dans le registre virtuel (HI, LO)

31: U[j] = LO d2 : décalage de t bits vers la droite dans le registre (HI, LO) 32 : (HI, LO) t

30 : (HI, LO)# = Q#N[j] c2 : initialisation du coefficient de polynôme U[j]

29 : HI = U[j+1] b2 : multiplication sans retenue de Q par N [j] mémorisation du résultat dans le registre virtuel (HI, LO)

28 : Pour j variant de 0 à p-2 a2 : initialisation du registre HI

27: LO = U[0] E6 : Incrémentation de la variable j de 0 à p-2 et pour chaque valeur de j, réalisation des étapes suivantes (a2 à d2) :

26 : Q = (Usup#R)#(t-1) E5 : initialisation du registre LO

25: Fin pour i E4 : multiplication sans retenue de Usup par R, et mémorisation dans le registre Q du résultat décalé de t-1 bits vers la droite

24 : (HI, LO)# = Q#N[p-1]

23: Fin pour j gl : multiplication sans retenue de Q par N[p-1] et mémorisation du résultat dans le registre virtuel (HI, LO)

22 : (HI, LO) t

21 : RS= LO; U[j] = RS ee : décalage de t bits vers la droite dans le registre (HI, LO)

20 : (HI, LO)# = Q#N[j-1] dd : initialisation du registre RS et du coefficient de polynôme U[j]

19 : (HI, LO)# = Ai#B[j] cc : multiplication sans retenue de Q par N[j-1] et mémorisation du résultat dans le registre virtuel (HI, LO)

18 : HI = U[j] bb : multiplication sans retenue de Ai par B [j] mémorisation du résultat dans le registre virtuel (HI, LO)

17 : Pour j variant de 1 à p-1 aa : initialisation du registre HI

16 : (HI, LO) t fl : Incrémentation de la variable j de 0 à p-1 et pour chaque valeur de j, réalisation des étapes suivantes (aa à ee) :

15: U[0] = LO el : décalage de t bits vers la droite dans le registre (HI, LO)

14 : (HI, LO)# = Ai#B[0] dl : initialisation du coefficient de polynôme U[0]

13: LO = 0 cl : multiplication sans retenue de Ai par B[0] et mémorisation du résultat dans le registre virtuel (HI, LO)

12 : HI = U[0]

11: Ai = A[i]

35 : U[p-1] = LO

7. Coprocesseur comprenant des moyens (RU, RBN, A, Q) pour mémoriser et fournir des nombres de t bits, caractérisé en ce qu'il comprend également : - un moyen (registre k) pour mémoriser et décaler de k bits un résultat partiel précédemment obtenu (Ai#B[p-1]), - un circuit de calcul pour réaliser une première multiplication polynômiale (#) du résultat partiel précédemment obtenu et décalé par un premier nombre (R) de t bits et mémoriser (registre Q) les t bits de poids forts (HI) du résultat de la première multiplication.

8. Coprocesseur selon la revendication 7, dans lequel le circuit de calcul réalise également une deuxième multiplication polynômiale (Ai#B[p-1]) d'un deuxième nombre (Ai) de t bits par un troisième nombre (B[p-1]) de t-bits pour produire le résultat partiel précédemment obtenu.

9. Coprocesseur selon la revendication 7 ou 8, dans lequel le circuit de calcul réalise également : - une troisième multiplication polynômiale des t bits de poids forts (HI) du résultat de la première multiplication par un quatrième nombre de t-bits (N[p-1]), et - une addition du résultat de la troisième multiplication et des bits de poids faibles (LO) du résultat de la première multiplication.

10. Composant électronique pour mettre en #uvre le procédé selon l'une des revendications 1 à 6.

11. Composant électronique comprenant un coprocesseur selon l'une des revendications 7 à 9.

12. Carte à puce comprenant un composant électronique selon la revendication 10 ou selon la revendication 11.