EP1656611A1 - Procede de realisation d une multiplication modulaire et pro cede de realisation d une multiplication euclidienne sur des nombres de 2n bits - Google Patents

Procede de realisation d une multiplication modulaire et pro cede de realisation d une multiplication euclidienne sur des nombres de 2n bits

Info

Publication number
EP1656611A1
EP1656611A1 EP04786385A EP04786385A EP1656611A1 EP 1656611 A1 EP1656611 A1 EP 1656611A1 EP 04786385 A EP04786385 A EP 04786385A EP 04786385 A EP04786385 A EP 04786385A EP 1656611 A1 EP1656611 A1 EP 1656611A1
Authority
EP
European Patent Office
Prior art keywords
mod
multmoddiv
bits
numbers
xxy
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP04786385A
Other languages
German (de)
English (en)
Inventor
Benoit Chevallier-Mames
Marc Joye
Pascal Paillier
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Gemplus SA
Original Assignee
Gemplus Card International SA
Gemplus SA
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Gemplus Card International SA, Gemplus SA filed Critical Gemplus Card International SA
Publication of EP1656611A1 publication Critical patent/EP1656611A1/fr
Withdrawn legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F7/00—Methods or arrangements for processing data by operating upon the order or content of the data handled
    • G06F7/60—Methods or arrangements for performing computations using a digital non-denominational number representation, i.e. number representation without radix; Computing devices using combinations of denominational and non-denominational quantity representations, e.g. using difunction pulse trains, STEELE computers, phase computers
    • G06F7/72—Methods or arrangements for performing computations using a digital non-denominational number representation, i.e. number representation without radix; Computing devices using combinations of denominational and non-denominational quantity representations, e.g. using difunction pulse trains, STEELE computers, phase computers using residue arithmetic
    • G06F7/722—Modular multiplication
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F7/00—Methods or arrangements for processing data by operating upon the order or content of the data handled
    • G06F7/38—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation
    • G06F7/48—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation using non-contact-making devices, e.g. tube, solid state device; using unspecified devices
    • G06F7/52—Multiplying; Dividing
    • G06F7/523—Multiplying only
    • G06F7/53—Multiplying only in parallel-parallel fashion, i.e. both operands being entered in parallel
    • G06F7/5324—Multiplying only in parallel-parallel fashion, i.e. both operands being entered in parallel partitioned, i.e. using repetitively a smaller parallel parallel multiplier or using an array of such smaller multipliers

Definitions

  • the invention relates to a method of carrying out a modular multiplication of the AxB mod N type on numbers A, B, N of 2xn bits with a processor adapted to work on numbers of n bits.
  • the invention also relates to a method of carrying out an operation of the (XxY) / Z type on numbers X, Y, Z of n bits, suitable for implementing the method of carrying out a modular multiplication according to the invention.
  • the invention is particularly interesting for the implementation of operations on large numbers (for example n of the order of 2048 bits), which is used for example for carrying out cryptographic calculations.
  • Performing modular arithmetic operations on numbers larger than n poses significant implementation problems and generally involves the implementation of complex algorithms, such as the methods of Montgomery, Barrett, Quisquater or Walter, during which the large numbers are divided into words of n bits and then elementary operations are carried out on the words of n bits.
  • Such algorithms cannot be implemented using limited modular arithmetic processors, from a hardware point of view, to process numbers of at most n bits. For example, a simple multiplication of two numbers of n bits cannot be performed on some processors, for the simple reason that the result of the multiplication is a number of 2xn which cannot be processed by said processors.
  • X, Y, T, Z are whole numbers of at most n bits, X, Y, T are positive or negative, Z is positive, Q a , Q b , Ra f R b are results of n bits.
  • Each MultModDiv and MultModDivInit operation performs, among other things, two multiplications on numbers of n bits.
  • the notation "LAJ” means "whole part of A” (in other words, A is rounded down to the nearest whole number).
  • the notation "mod” is the usual abbreviation for "modulo”.
  • the notation "X” is used to speak of Euclidean multiplication.
  • _ (XxY + T ⁇ 2 n ) / z] ) whose result is rounded to its integer value by default, and a modular multiplication (R (XxY) mod Z) or (XxY +
  • the first solution uses 7 MultModDiv functions, and can be summarized by the following FSl algorithm (Fisher and Seifert modular multiplication algorithm, 1st version):
  • Ri to R 7 , Qi to Q7 are intermediate variables of n bits, necessary to obtain the final result.
  • MultModDivInit function generally requires a greater number of elementary operations than the implementation of a MultModDiv function. (See in particular Dl for examples of implementation of the MultModDiv and MultModDivInit functions). At best, with certain processors, the implementation of the MultModDivInit operation is also expensive than the MultModDiv operation (see for example the Sedlak algorithm).
  • emulation means (software) are generally used to carry out the Euclidean operations from a set of modular elementary operations.
  • An object of the invention is to perform the same operations (AXB mod N, with A, B, N of 2xn bits) as the algorithms proposed by Fisher and Seifert, but using a smaller number of elementary functions of type MultModDiv or MultModDivInit, so as to provide a result more quickly while consuming less energy.
  • the method according to the invention can be used for carrying out a modular multiplication according to the invention.
  • the invention relates to a method of producing a modular multiplication of the AXB mod N, A, B, N being numbers of 2xn bits.
  • the numbers A, B, N are broken down into words of n bits. Then, during the process, operations are performed on the numbers, Ao, Bi, Bo, i, No of n bits.
  • the n most significant bits of A, respectively B, N form the word Ai, respectively Bi, Ni and the n least significant bits of A, respectively B, N, form the word Ao, respectively BQ , O-
  • AXB mod N 2 n (R3 + R5-Q6-R2-R4) + (R 2 + R 4 -Rg)
  • the method A1 according to the invention uses a MultModDiv function less than the method FS1 known from the prior art. There is therefore indeed, for the same result, a decrease in the overall number of operations to be performed, and therefore a decrease as a result of the overall time and of the overall energy consumed to execute the process.
  • a MultModDiv operation carrying out 2 modular multiplications on numbers of n bits
  • A A ⁇ X2 n + Ao
  • B B ⁇ X2 n + B 0
  • N N ⁇ * 2 n + No.
  • AxB 2 n (2 n -l) A ⁇ xB ⁇ + 2 n (A1 + A0) (B ⁇ + B 0 ) - (2 n -l) AoxBo
  • the method A2 uses a MultModDiv function less than the method FS2 known from the prior art.
  • a MultModDiv operation or a MultModDivInit operation performing 2 multiplications modular on numbers of n bits
  • Ri to R5 (U-1) XA 0 XB 0 ⁇ N (Ul) (QiX ⁇ + Ri) UX (A ⁇ + A 0 ) (B ⁇ + B 0 ) ⁇ N U (Q 2 XU + R 2 ) ⁇ N Q 2 x ⁇ + R 2 xu U (Ul) XA ⁇ XB ⁇ ⁇ N U 2 XA ⁇ XB ⁇ - UXA1XB1 ⁇ N UX (R 3 XU + Q3XOC) - UX (Q3XU + R 3 ) ⁇ M R 3 x + Q3XCCXU - Q3x + R3XU ⁇ N (-Q3 + R3) xoc + (- R 3 + Q 3 x
  • AxB U (Ul) A ⁇ xB ⁇ + UX (A ⁇ + A 0 ) x (B ⁇ + B 0 ) - (U -l) A 0 xB 0 , that is: AxB ⁇ N ( -Q 3 + R 3 ) x ⁇ + (- R 3 + Q 3 X0 XU + Q 2 x ⁇ + R 2 XU - QiX ⁇ + Ri - (R ⁇ -Q ⁇ ) XU ⁇ N (-Q ⁇ + Q 2 - Q3 + R3) + Ri + U (-R ⁇ + Q ⁇ + R 2 - R3 + Q3X0C) ⁇ N (-Q ⁇ + Q 2 - Q3 + R3) + Ri + U (Q ⁇ + Q 2 - Q3 + R3) + Ri + U (Q ⁇ + Q 2 - Q3 + R3) + Ri + U (Q 4 XU + R 4 - Ri + Qi + R 2 - R3) ⁇ N cc (-Q ⁇ + Q 2
  • the A3 method of the invention uses a number of further reduced MultModDiv functions than known methods or same as the first embodiment or the second embodiment of the invention.
  • a MultModDiv operation or a MultModDivInit operation realizing 2 modular multiplications on numbers of n bits
  • U is defined by the relationship: U 2 + ⁇ N 0C ⁇ xU.
  • ⁇ and ⁇ are integers preferably constant and as small as possible (less than 256 bits)
  • ⁇ and ⁇ are preferably chosen so that ⁇ + ⁇ 2 is also a constant and small integer.
  • N an element of a key of a cryptographic algorithm
  • the algorithm A4 achieves the modular multiplication AxB mod N. Indeed, using U 2 ⁇ ⁇ ⁇ + ⁇ xU and the Karatsuba lemma, we obtain: (U-1) XA 0 XB 0 ⁇ ( ⁇ -1) ( QiXU + Ri) N -QiXU- Ri + R1XU + Q1 ( ⁇ + ⁇ x ⁇ ) ⁇ N Qix ⁇ - Ri + (R ⁇ -Q ⁇ + Q ⁇ X ⁇ ) XU UX (A ⁇ + A 0 ) (B ⁇ + B 0 ) ⁇ N U (Q 2 XU + R 2 ) ⁇ w R 2 xu + Q 2 x (oc + ⁇ U) ⁇ N ⁇ xQ 2 + (R 2 + ⁇ xQ 2 ) U UXA1XB1 ⁇ N U (Q 3 XU + R 3 ) ⁇ N ⁇ Q 3 + ( R3 + ⁇ xQ3) UU 2 XA ⁇ XB ⁇ ⁇ N U (
  • the A4 method according to the invention uses a still reduced number of MultModDiv functions than the known methods or even that the first embodiment or the second embodiment of the invention.
  • R3 (Ao + (Ai mod 2) U - 3 (Ai div 2)) x (B 0 + (Bi mod 2) U - 3 (B ⁇ div 2)) mod (2 ⁇ + 3)
  • AXB X 1 XU 3 + Y 1 XU 2 + ZiXU + Ri ⁇ N Ri + ⁇ xYi + ( ⁇ xxi + Z ⁇ ) xu ⁇ N Ri + xYi + (Q 2 XU + R 2 + Zi) xu ⁇ N Ri + ⁇ x (Y ⁇ + Q 2 ) + (R 2 + Z ⁇ ) xu ⁇ N R ⁇ + R 3 + (R 2 + Z ⁇ + Q 3 ) XU
  • This process is likely to be used for the implementation of a multiplication modular as described above and more generally of a MultModDiv function.
  • E3 if the intermediate data is not an integer, then we increment the variable ⁇ by 1 and repeat the step E2 then step E3.
  • LxY / zJ is equal to (C-C ⁇ ) / ⁇ minus a corrective term ⁇ (Z + ⁇ ) / ⁇ .
  • LXY / ZJ is an integer, as are ⁇ and ⁇ .
  • calculating [C-C ⁇ - ⁇ x (Z + ⁇ )] / ⁇ in a systematic way with the different possible values of ⁇ , and by checking if the result is whole, we calculate the correct value of ⁇ and therefore the value correct from LXY / zJ.

Landscapes

  • Physics & Mathematics (AREA)
  • Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Mathematical Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Pure & Applied Mathematics (AREA)
  • Computational Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • Computing Systems (AREA)
  • Mathematical Physics (AREA)
  • General Engineering & Computer Science (AREA)
  • Error Detection And Correction (AREA)
  • Complex Calculations (AREA)

Abstract

L'invention concerne des procédés de réalisation de multiplication modulaire sur des nombres de 2n bits. Selon l'invention, on décompose les nombres A, B dans une base 2<n> ou dans une base U, U étant un entier approprié, puis on réalise des opérations élémentaires de type MultModDiv et / ou MultModDivInit sur des nombres de n bits issus de la décomposition. L'invention propose également un procédé de calcul d'une multiplication / division euclidienne. Application aux calculs cryptographiques.

Description

PROCEDE DE REALISATION D'UNE MULTIPLICATION MODULAIRE ET PROCEDE DE REALISATION D'UNE MULTIPLICATION EUCLIDIENNE SUR DES NOMBRES DE 2N BITS
L'invention concerne un procédé de réalisation d'une multiplication modulaire de type AxB mod N sur des nombres A, B, N de 2xn bits avec un processeur adapté pour travailler sur des nombres de n bits. L'invention concerne également un procédé de réalisation d'une opération de type (XxY) /Z sur des nombres X, Y, Z de n bits, adapté pour la mise en œuvre du procédé de réalisation d'une multiplication modulaire selon l'invention. L'invention est notamment intéressante pour la mise en œuvre d'opérations sur des grands nombres (par exemple n de l'ordre de 2048 bits), que l'on utilise par exemple pour la réalisation de calculs cryptographiques.
La réalisation d'opération d'arithmétique modulaire sur des nombres de taille supérieure à n pose d'importants problèmes de mise en œuvre et passe généralement par la mise en œuvre d'algorithmes complexes, comme par exemple les méthodes de Montgomery, Barrett, Quisquater ou Walter, au cours desquelles on découpe les grands nombres en mots de n bits puis on réalise des opérations élémentaires sur les mots de n bits.
De tels algorithmes cependant ne peuvent être pas être mis en œuvre à l'aide de processeurs d'arithmétique modulaire limités, d'un point de vue matériel, pour traiter des nombres de au plus n bits. Par exemple, une simple multiplication de deux nombres de n bits ne peut pas être réalisée sur certains processeurs, pour la simple raison que le résultat de la multiplication est un nombre de 2xn qui ne peut pas être traité par les dits processeurs .
Il est donc nécessaire d'émuler ces matériels, d'un point de vue logiciel, pour pouvoir réaliser des opérations sur des grands nombres . Pour cela, Fisher et Seifert ont proposé récemment dans Dl (Increasing the Bitlength of a Crypto-processor, Wieland FISHER and Jean Pierre SEIFERT, CHES 2002, LNCS 2523, pp 71-81, Springer-Verlang Berlin Heidelberg 2003) deux solutions, qui permettent de réaliser des multiplications modulaires de type AXB mod N sur des nombres A, B, N de taille 2xn (n étant la taille des mots traités par le processeur utilisé) à partir de deux fonctions élémentaires travaillant sur des nombres de n bits .
Les deux fonctions élémentaires MultModDiv et MultModDivInit sont définies par : MultModDi (X, Y, Z) = (Qa, Ra) = { L(XxY)/zJ , (XxY) mod Z ) MultModDivInit (X, Y, T, Z) = <Qb, Rb) = ( L(XxY+Tx2n)/zJ , (XxY + Tx2n) mod Z )
X, Y, T, Z sont des nombres entiers de au plus n bits, X, Y, T sont positifs ou négatifs, Z est positif, Qa, Qb, Raf Rb sont des résultats de n bits. Chaque opération MultModDiv et MultModDivInit réalise entre autre deux multiplications sur des nombres de n bits .
La notation "LAJ" signifie "partie entière de A" (en d'autres termes, A est arrondi au nombre entier inférieur le plus proche) . La notation "mod" est l'abréviation habituelle pour "modulo" . La notation "X" est utilisée pour parler de la multiplication euclidienne. Chaque fonction MultModDiv ou MultModDivInit réalise ainsi en pratique deux opérations élémentaires sur des nombres X, Y, Z de n bits : une multiplication euclidienne (Q = L(X*Y)/zJ ou |_(XxY+Tχ2n) /z] ) dont le résultat est arrondi à sa valeur entière par défaut, et une multiplication modulaire (R = (XxY) mod Z ) ou (XxY +
On déduit rapidement de la définition de la fonction (Q, R) = MultModDiv (X, Y, Z) que : XXY = QXZ + R
De manière similaire, on déduit de la définition de la fonction (Q, R) = MultModDiv (X, Y, Z, T) que : Xxγ+Tx2n = QXZ + R
Ces fonctions, et de manière plus générale, toutes les opérations d'arithmétique nécessaires à la mise en œuvre des procédés dont il sera question dans ce qui suit, sont mises en œuvre dans un processeur d'arithmétique modulaire, dimensionnés pour travailler sur des nombres de au plus n bits et produire des nombres de au plus n bits .
Ici, et dans tout ce qui suit, par souci de clarté, on utilisera le même nom pour parler d'un registre du processeur et du mot ou nombre de n bits qu'il contient. Ainsi, écrire "C = AXB" signifie concrètement en terme de procédé "multiplier le contenu du registre A par le contenu du registre B dans un circuit de multiplication, et mémoriser le résultat de la multiplication dans le registre C".
Les solutions proposées par Fisher et Seifert utilisent, pour réaliser l'opération AXB mod N, avec A, B, N des nombres de 2n bits, une décomposition des nombres A, B, N en deux mots de n bits, un mot de poids fort Ai, B , Ni et un mot de poids faible Ao, Bo, No-
La première solution utilise 7 fonctions MultModDiv, et peut être résumée par l'algorithme FSl suivant (algorithme de multiplication modulaire de Fisher et Seifert, lΘre version) :
Entrée : A, B, N, entiers de 2n bits, décomposés sous la forme : A = Aιx2n+A0 ; B = Bι 2n+Bo ; N = ι 2n+N0 , ' Sortie : AxB mod N Faire : (Ql, Ri) = MultModDiv (Bi, 2n, i) (Q2, R2) = MultModDi (Qi, N0, 2n) (0,3, R3) = MultModDiv (Ai, Rι-Q_2+Bo, NI) (Q4, R4) = MultModDiv (A0, Bi, i) (Q5, R5) = MultModDiv (Q3+Q4, No, 2n) (Qβr β) = MultModDiv (Ai, R2, 2n) (Q7, R7) = MultModDiv (Ao, Bo, 2n) Retourner (R3+R4-Q5-Q6+Q7) χ2n + (R7-R6-R5)
Ri à R7, Qi à Q7 sont des variables intermédiaires de n bits, nécessaires à l'obtention du résultat final.
La deuxième solution proposée par Fisher et Seifert utilise cinq fonctions de type MultModDiv et une fonction MultModDivInit. Cette deuxième solution peut être résumée par l'algorithme FS2 suivant (algorithme de multiplication modulaire de Fisher et Seifert, 2 version) : Entrée : A, B, N, entiers de 2n bits, décomposés sous la forme A ≈ Aιχ2n+A0 ; B = B! 2n+B0 ; N = Nιχ2n+ 0 ; Sortie : AxB mod N Faire : (Ql Ri) = MultModDiv (Ai, Bi, Ni) (Q2 r 2) = MultModDivInit (No, -Qi, Ri, i) (Q3 3) = MultModDiv (Ai, Bo, Ni) (Q4, R4) = MultModDiv (Ao, Bi, i) (Q5, R5) = MultModDiv (A0, Bo, 2n) (Qβ Re) = MultModDi (Q2+Q3+Q4, N0, 2n) Retourner (R2+R3+R4+Q5-Q6) χ2n + (R5-R6)
Des détails et des compléments d'information sur les modes de réalisation des deux solutions proposées par Fisher et Seifert sont proposés dans Dl .
Comme il a été dit précédemment, ces deux solutions permettent de réaliser des opérations modulaires sur des nombres de au plus 2xn bits avec un processeur intrinsèquement limité à des nombres de n bits . Toutefois, ces deux solutions sont consommatrices d'énergie dans la mesure où chaque fonction MultModDiv ou MultModDivInit requiert un certain nombre d'opérations élémentaires (additions, soustractions de contenus de registres, décalages de bits dans un registre, etc.).
A noter que la mise en œuvre d'une fonction MultModDivInit requiert en général un nombre d'opérations élémentaires plus important que la mise en œuvre d'une fonction MultModDiv. (Voir notamment Dl pour des exemples de mises en œuvre des fonctions MultModDiv et MultModDivInit) . Au mieux, avec certains processeurs, la mise en œuvre de l'opération MultModDivInit est aussi coûteuse que l'opération MultModDiv (voir par exemple l'algorithme de Sedlak) .
La mise en œuvre de fonctions de type MultModDiv ou MultModDivInit nécessite la réalisation d'opérations élémentaires de type Q = L(XxY)/zJ et R = (XxY) mod Z, sur des nombres de n bits. Les processeurs dédiés aux calculs cryptographiques intègrent généralement des moyens matériels pour calculer des opérations modulaires de type R = (XxY) mod Z, mais pas toujours des moyens matériels pour réaliser des opérations euclidiennes de type Q = L(XχY)/zJ. Dans ce cas, on utilise généralement des moyens d'émulation (logicielle) pour réaliser les opérations euclidienne à partir d'un ensemble d'opérations élémentaires modulaires.
Par exemple, dans Dl, est décrit un procédé permettant de calculer Q = L(XχY)/zJ, à partir d'opérations de type Ri = (XxY) mod Z et R2 = (XxY) mod (Z+l) . Plus précisément, dans Dl, on calcule Q par la relation suivante : Q = ( (X*Y) mod Z) - ( (X*Y) mod (Z+l) si cette valeur est positive, ou Q ≈ ((X*Y) mod Z) - ( (X*Y) mod (Z+l)) + (Z+l)
L'opération R = (XxY) mod Z est mise en œuvre en utilisant l'algorithme bien connu de Montgomery. Toutefois, si cet algorithme est particulièrement efficace (en terme de précision et de temps de calcul) lorsque le modulo Z est un entier impair, ce n'est pas le cas lorsque Z est un entier pair. Il en résulte que le procédé proposé dans Dl n'est pas efficace puisque l'un ou l'autre des nombres Z et Z+l est nécessairement pair.
Un objet de l'invention est de réaliser les mêmes opérations (AXB mod N, avec A, B, N de 2xn bits) que les algorithmes proposés par Fisher et Seifert, mais en utilisant un nombre plus petit de fonctions élémentaires de type MultModDiv ou MultModDivInit, de sorte à fournir un résultat plus rapidement tout en consommant moins d'énergie.
Un autre objet de l'invention est un procédé de réalisation d'une opération de type S = L(XXY)/zJ sur des nombres de n bits plus efficace que le procédé proposé dans Dl . Le procédé selon l'invention est susceptible d'être utilisé pour la réalisation d'une multiplication modulaire selon l'invention.
Ainsi, l'invention concerne un procédé de réalisation d'une multiplication modulaire de type AXB mod N, A, B, N étant des nombres de 2xn bits . Quel que soit le mode de réalisation d'un procédé selon l'invention, les nombres A, B, N sont décomposés en mots de n bits. Puis on exécute, au cours du procédé, des opérations sur les nombres , Ao, Bi, Bo, i, No de n bits.
Selon un premier mode de réalisation de l'invention, les nombres A, B, N sont décomposés en base 2n sous la forme : A = AιX2n + A0, B = BιX2n + B0, et N = Nι*2n + N0. En d'autres termes, les n bits de poids forts de A, respectivement B, N forment le mot Ai, respectivement Bi, Ni et les n bits de poids faibles de A, respectivement B, N, forment le mot Ao, respectivement BQ, O- On réalise ensuite 6 fonctions élémentaires de type MultModDiv, la sixième fournissant le résultat de la multiplication modulaire.
Concrètement, on réalise le procédé Al suivant
Entrée : A, B, N, entiers de 2χn bits, décomposés sous la forme A ≈ Aιx2n+A0 ; B = Bιx2n+B0 ; N = Nι 2n+ 0 ; Sortie : AxB mod N Faire (Ql, Ri) = MultModDiv (Ai, Bi, Ni) (Q2, R2) = MultModDiv (Qi, N0, 2n) (Q3, R3) = MultModDiv (Ai+A0, B1+B0, 2n -1) (Q4, R4) = MultModDiv (Ao, Bo, 2n) (Q5, R5) = MultModDi (2n-l, R1+Q3-Q2-Q4, i) (Qβ, Rβ) = MultModDiv (Q5, No, 2n) Retourner (R3+R5-Q6-R2-R4) 2n + (R2+R4-R6)
L'algorithme Al ci-dessus réalise bien la multiplication modulaire AXB mod N. En effet, selon le lemme de aratsuba (voir notamment D2 : "Multiplication Of Multidigit Numbers On Automata" Soviet Physics - Doklady, volume 7, pages 595-596, 1963), on a : AxB = 2n(2n-l)AιxBι + 2n (Aι+A0) (Bι+B0) - (2n-l)A0xB0
Comme N = ιχ2n+No, on a Nι 2n ηN -No, où • est la relation d'équivalence modulo N.
De la définition de Qi à Qg, Ri à Rg dans l'algorithme Al et de la définition de la fonction MultModDiv, on déduit que : 2n(2n-l)χAιχBιηN 2n(2n-l) (QiχNι+Rχ) ηN -(2n-l)χ(QιχN0)+2n(2n-l)χRι ηN -(2n-l) (Q2x2n+R2) + 2n(2n-l)Rι ηM 2n(2n-l) (R1-Q2) - (2n-l)χR2 2n(Aι+A0) (Bι+B0)=2n( (2n-l)Q3+R3) ≈ 2n (2n-l) Q3+2nxR3 (2n-l)χA0xB0=(2n-l) (2nxQ4+R4)=2n(2n-l)Q4+(2n-l)R4
On en déduit finalement : AxB ηN 2n(2n-l) (Rι+Q3-Q2-Q4)+2nxR3-(2n-D (R2+R4) ηN 2n(Q5xNι+R5)+2nxR3-(2n-l) (R2+R4) ηM -Q5 N0+2n(R3+R5)-(2n-l) (R2+R4) ηN -(Q6x2n+R6)+2n(R3+R5)-(2n-l) (R2+R4) ηN 2n(R3+R5-Q6-R2-R4)+(R2+R4-R6)
et donc : AXB mod N = 2n (R3+R5-Q6-R2-R4) + (R2+R4-Rg)
ce qui est le résultat produit par l'algorithme Al.
On notera que le procédé Al selon l'invention utilise une fonction MultModDiv de moins que le procédé FS1 connu de l'art antérieur. On a donc bien, pour un même résultat, une diminution du nombre global d'opérations à réaliser, et donc une diminution en conséquence du temps global et de l'énergie globale consommés pour exécuter le procédé. Concrètement, une opération MultModDiv réalisant 2 multiplications modulaires sur des nombres de n bits, l'algorithme Al utilise ici 12 multiplications modulaires sur des nombres de n bits au lieu de 14 dans l'algorithme FS1, d'où un gain en temps de calcul de (14-12) /14 = 14%.
Selon un deuxième mode de réalisation de l'invention, les nombres A, B, N sont également décomposés en base 2n sous la forme : A = AιX2n + Ao, B = BιX2n + B0, et N = Nι*2n + No. On réalise ensuite une fonction de type MultModDivInit et quatre fonctions élémentaires de type MultModDiv, la quatrième fournissant le résultat de la multiplication modulaire.
Concrètement, on réalise le procédé A2 suivant : Entrée : A, B, N, entiers de 2χn bits, décomposés sous la forme A = Aιx2n+ o ; B = Bι 2n+Bo ; N ≈ ιx2n+No ; Sortie : AxB mod N Faire : (Qi, Ri) = MultModDiv (Ai, Bi, Ni) (Q2, R2) = MultModDiv (AI+AQ, BI+BQ, 2n-l) (Q3, R3) = MultModDiv (Ao, B0, 2n) (Q4, R4) = MultModDivInit (Qi, N0, Q3- 1-Q2, i) (0.5, 5) = MultModDiv (N0+Nι, Q4, 2n) Retourner (R2+Q5-R3-R4) *2n + (R3+R4+R5)
L'algorithme A2 réalise bien la multiplication modulaire AxB mod N. En effet, on a, de par les définitions de Qi à Q5, Ri à R5 : 2n(2n-l)xAιxBι ηN 2n(2n-l)QιxNι+Rι) (2n-l ) (-QιxN0+Rι <2n) 2n (Aι+A0) (Bι+B0 ) = 2n ( (2n-l) Q2+R2) ≈ 2* (2n-l) Q2+2n R2 (2n-l ) A0xB0= (2n-l ) (2nχQ3+R3) = 2n (2n-l) Q3+ (2n-l) χR3
Du lemme de Karatsuba (D2 ) , on a : AxB = 2n (2n-l) AιxBι + 2n (A1+A0) (Bι+B0) - (2n-l) AoxBo
On en déduit donc (car ^n-l) ηN -No- χ) : AxB ηN -(2n-l) (QιxNo+(Q3-Rl-Q2)χ2n)+2nxR2-(2n-l)R3 (2n-l) (Q4χNι+R4)+2nχR2-(2n-l)R3 (N0+Nι)Q +2nxR2-(2n-l) (R3+R4) (2nχQ5+R5)+2nxR2-(2n-l) (R3+R4) 2n (R2+Q5-R3-R4) + (R3+R4+R5)
II vient finalement : AXB mod N = 2n (R2+Q5-R3-R ) + (R3+R4+R5)
ce qui est le résultat produit par l'algorithme A2.
On notera que le procédé A2 selon l'invention utilise une fonction MultModDiv de moins que le procédé FS2 connu de l'art antérieur. On a donc bien là encore, pour un même résultat, une diminution du nombre global d'opérations à réaliser, et donc une diminution en conséquence du temps global et de l'énergie globale consommés pour exécuter le procédé. Concrètement, une opération MultModDiv ou une opération MultModDivInit réalisant 2 multiplications modulaires sur des nombres de n bits, l'algorithme A2 utilise ici 10 multiplications modulaires sur des nombres de n bits au lieu de 12 dans l'algorithme FS2, d'où un gain en temps de calcul de (12-10) /12 = 16% par rapport au procédé équivalent FS2 de Dl .
Selon un troisième mode de réalisation de l'invention, les nombres A, B, N sont décomposés dans une base U, U étant différent de 2n, telle que : A = AiXU + Ao, B = BiXU + Bo, et N = NiXU + No- Ai, Ao, Bi, Bo, Ni et N0 sont des mots de n bits . On réalise ensuite opérations élémentaires de type MultModDiv sur les mots A , Ao, B , Bo, i et o.
Dans un premier exemple, on réalise le procédé A3 suivant : Entrée : A, B, N, entiers de 2χn bits, décomposés sous la forme A = AιχU+Ao ; B = BιχU+Bo ; N = NιχU+ 0 ; Sortie : AxB mod N Faire : (Ql, Ri) = MultModDiv (Ao Bo U) (0.2, R2) ≈ MultModDiv (A1+A0, Bι+B0, U) (Q3, R3) = MultModDiv (Ai, Bi, U) (Q4, R4) = MultModDiv (0, Q3, U) (Q5, R5) = MultModDiv (α, -Qι+Q2-Q3+Q4+R3, U) Retourner (R5+R1) + (R4~Rι+ ι+R2-R3+Q5) XU
avec α = U2 mod N.
Dans ce 1er exemple, l'algorithme A3 réalise bien la multiplication modulaire AXB mod N. En effet, comme α = U2 mod N, on a U2 ηw OC. De plus, on a, grâce aux définitions de Qi à Q5, Ri à R5 : (U-1)XA0XB0 ηN (U-l) (QiXϋ + Ri) UX (Aι+A0 ) (Bι+B0 ) ηN U (Q2XU+R2) ηN Q2xα + R2xu U (U-l) XAιXBι ηN U2XAιXBι - UXA1XB1 ηN UX (R3XU+ Q3XOC) - UX (Q3XU+R3 ) ηM R3x + Q3XCCXU - Q3x + R3XU ηN (-Q3 + R3) xoc + ( - R3 + Q3xα) xu
Du lemme de Karatsuba (D2 ) , on obtient : AxB = U (U-l ) AιxBι + UX (Aι+A0) x (Bι+B0) - (U -l ) A0xB0 , soit : AxB ηN (-Q3 + R3)xα + (- R3 + Q3X0 XU + Q2xα + R2XU - QiXα + Ri - (Rι-Qι)XU ηN (-Qι + Q2 - Q3 + R3) + Ri + U(-Rι+ Qι+ R2 - R3 + Q3X0C) ηN (-Qι + Q2 - Q3 + R3) + Ri + U(Q4XU + R4 - Ri + Qi + R2 - R3) ηN cc(-Qι + Q2 - Q3 + Q4 + R3) + Ri + U(R4 - Ri + Qi + R2 - R3) ηN (R5 + Ri) + U(R4 - Ri + Qi + R2 - R3 + Q5)
ce qui est le résultat produit par l'algorithme A3.
On notera que, dans ce 1er exemple, le procédé A3 selon l'invention utilise un nombre encore réduit de fonctions MultModDiv que les procédés connus ou même que le premier mode de réalisation ou le deuxième mode de réalisation de l'invention. On a donc bien là encore, pour un même résultat, une diminution encore plus importante du nombre global d'opérations à réaliser, et donc une diminution en conséquence du temps global et de l'énergie globale consommés pour exécuter le procédé. Concrètement, une opération MultModDiv ou une opération MultModDivInit réalisant 2 multiplications modulaires sur des nombres de n bits, l'algorithme A3 utilise ici 10 multiplications modulaires sur des nombres de n bits au lieu de 14 dans l'algorithme FSl, d'où un gain en temps de calcul de (14- 10) /14 = 28% par rapport au procédé équivalent FSl de Dl .
Pour la mise en œuvre de ce premier exemple, on pourra par exemple choisir U = | 1, où N est la racine carrée de N et [ w 1 est la partie entière par excès de "N (en d'autres termes, U est l'arrondi à l'entier immédiatement supérieur de "VN) . On pourra également choisir U = T v(k.N) 1, avec k un nombre entier. De préférence, k est choisi tel que OC = U2 mod N soit le plus petit possible.
Dans un 2ème exemple, U est défini par la relation : U2 ηN 0C + δxU. α et δ sont des nombres entiers de préférence constants et aussi petits que possibles (inférieurs à 256 bits) α et δ sont choisis de préférence de sorte que α+δ2 soit également un entier constant et petit.
Idéalement, δ = 1 et α = -1, 2 ou 3. De telles valeurs de α, δ peuvent être obtenues en choisissant un nombre N approprié, c'est-à-dire en choisissant un procédé de génération de clé approprié (on rappelle que N est ici un élément d'une clé d'un algorithme cryptographique) .
Le procédé A3 se simplifie pour donner le procédé A4 suivant : Entrée : A, B, N, entiers de 2n bits, décomposés sous la forme A = AixU+ o ; B = BιxU+Bo ; N = ιxU+ 0 ; Sortie : AxB mod N Faire : (Qi, Ri) = MultModDiv (Ao, Bo, U) (Q2, R2) = MultModDiv (A1+A0, B1+B0, U) (Q3, R3) = MultModDiv (Ai, Bi, U) Retourner αx (-Qι+Q2-Q3+R3+δχQ3) +RX +U x[(-Rι-R3+Qι+R2+Q3(0C+δ2) + (-Q3+R3-Q1+Q2) *δ]
L'algorithme A4 réalise bien la multiplication modulaire AxB mod N. En effet, en utilisant U2 η^ α + δxU et le lemme de Karatsuba, on obtient : (U-1)XA0XB0 η (ϋ-1) (QiXU + Ri) N -QiXU- Ri + R1XU+Q1 (α+δxϋ) ηN Qixα - Ri + (Rι-Qι+QιXδ) XU UX(Aι+A0) (Bι+B0) ηN U(Q2XU+R2) ηw R2xu + Q2x(oc + δU) ηN αxQ2 + (R2 + δxQ2)U UXA1XB1 ηN U(Q3XU+R3) ηN αQ3+(R3+δxQ3)U U2XAιXBι ηN U(αxQ3+(R3+ÔXQ3)XU) ηN αxUXQ3+(R3+δxQ3)X(α+δ XU) ηN αx (R3+ÔXQ3) + ( (δx(R3+δxQ3)+αxQ3)XU U(U-l)XAιXBι ηN αx(R3-Q3+δxQ3) + ( (R3+δxQ3) X (δ-1) +αxQ3) XU ηN αx(R3-Q3+δxQ3) + [~R3+δx(-Q3+R3)+Q3X (δ2+α)]XU
Et donc : AXB ηN ocx(-Qι+ Q2-Q3+R3+δxQ3) + Ri + ux (-R1-R3+Q1+R2+Q3X (α+δ2) + δx(-Q3+R3-Qι+Q2)
On notera que le procédé A4 selon l'invention utilise un nombre encore réduit de fonctions MultModDiv que les procédés connus ou même que le premier mode de réalisation ou le deuxième mode de réalisation de l'invention. On a donc bien là encore, pour un même résultat, une diminution encore plus importante du nombre global d'opérations à réaliser, et donc une diminution en conséquence du temps global et de l'énergie globale consommés pour exécuter le procédé. Dans un 3eme exemple, on réalise le procédé A5 suivant : Entrée : A, B, N, entiers de 2n bits, décomposés sous la forme A = ιxU+ o ; B = BixU+Bo ; N = NixU+No ; Sortie : AxB mod N Faire : (XI, Yl, Zl, RI) = Coefficients (A, B, U) <Q2, R2) = MultModDiv (α, Xl r U) (Q3, R3) = MultModDiv (α, Y1+Q2, U) Retourner R1+R3+ (R2+Z1+Q3) xU
La fonction Coefficient calcule dans une base U les coefficients du polynôme produit de deux nombres entiers A, B décomposés dans la base U (A= AixX+Ao et B = Coefficients (A, B, U) = (C3, C2, Ci, Co) tels que C3 = f ; C2 = d + 3f ; Cl = e + 2f ; CO = RO ; avec : Rθ = (A mod U) (Bmod U) mod U Ri = (A mod(U+l)) (Bmod (U+l)) mod (U+l) R2 = (A mod(U+2) ) (Bmod(U+2) )mod(U+2) R3 = (A mod(2U+3)) (Bmod(2U+3) )mod(2U+3) et a = (R0 - R2 + ((R0-R2) mod 2) (U+2))/2 mod U + 2 b = R0 - RI mod (U+l) c = (2(R0-R3) + (2(R0-R3) mod 3) (2U+3) ) /3 mod (2U+3) d = ( (b-a) mod (U+l) ) e = a + 2d f = -6d + 4e-4c mod (2U + 3)
C3, C2, Ci, Co vérifient AxB = C3XU3 + C2xU2 + Cx U+ C0
A noter que, comme A = AixU+ o et B = BixU+Bo , RO , Ri , R2 , R3 peuvent être calculés facilement à partir des relations suivantes : Rθ = A0Bo mod U Ri = (A0-Aι) (B0-Bι) mod (U+l) 2 = (Ao - 2Aι) (Bo-2Bι) mod (U+2) R3 = (Ao + (Ai mod 2)U - 3 (Ai div 2)) x (B0+ (Bi mod 2)U - 3(Bι div 2)) mod (2ϋ + 3)
Comme précédemment, le coût, en terme de temps de calcul, des opérations auxiliaires telles que les additions, soustractions, etc., est négligeable.
L'algorithme A5 réalise bien la multiplication modulaire AxB mod N. En effet, en utilisant la définition de la fonction Coefficients, on obtient : AXB = X1XU3 + Y1XU2 + ZiXU + Ri ηN Ri + αxYi + (αxxi + Zι)xu ηN Ri + xYi + (Q2XU + R2 + Zi) xu ηN Ri + αx(Yι+Q2) + (R2+Zι)xu ηN Rι+R3+(R2+Zι+Q3)XU
Dans ce troisième exemple, on pourra choisir U = | |. On pourra également choisir U = I V(k.N) I avec k un nombre entier.
k est choisi de préférence aussi petit que possible tel que U soit impair et premier avec trois (c'est-à-dire que trois ne divise pas U) . On testera pour cela par exemple plusieurs valeurs croissantes de k, jusqu'à obtenir une valeur satisfaisante de U. On pourra également choisir k aussi petit que possible, tel que U soit impair, premier avec trois et tel que α = U2 mod N soit le plus petit possible.
L'invention concerne enfin un procédé de réalisation d'une opération de type S = L(XXY)/ZJ, où X, Y, Z sont des nombres de n bits. Ce procédé est susceptible d'être utilisé pour la mise en œuvre d'une multiplication modulaire telle que décrite ci-dessus et plus généralement d'une fonction MultModDiv. Au cours du procédé, on réalise les étapes suivantes : El : on initialise à zéro une variable Δβ et on calcule deux données : C = XXY mod Z et Cβ = XxY mod (Z+β) , β étant un nombre entier positif prédéfini de n bits. E2 : on calcule le résultat S = [C - Cβ - Δβ(Z+β)]/β E3 : si la donnée intermédiaire n'est pas un nombre entier, alors on incrémente de 1 la variable Δβ et on répète l'étape E2 puis l'étape E3.
Pour justifier le procédé tel que décrit ci-dessus, dans ce qui suit, on va montrer dans un 1er temps qu'il existe un nombre entier Δβ tel que S = LxY/zJ = [C - C β - Δβ(Z+β)]/β. Puis on montrera que le procédé ci-dessus permet de trouver la valeur correcte de Δβ et de S .
Soit β un nombre entier positif de n bits . On définit : C = XXY mod Z Cβ = XXY mod (Z+β) ,
Δβ vérifie : 0 < Δβ < β. En effet, comme Z < Z + β, on a XY/(Z+β) < XY/Z, on en déduit que LxY/(Z+β)J < LxY/zJ. Par ailleurs : XY/Z = [XY/(Z+β) ]X(l+β/Z) < XY/(Z+β) + [ (Z-l)2/((Z+β)Z) ] < XY/(Z+β) + β
Comme β est entier, Tβl = β et donc : LXY/ZJ ≤ Lχγ/ (z+β) J + fpl = Lχγ/ (z+β) J + β
Ces deux dernières inégalités nous permettent de conclure que LxY/(Z+β)J < LxY/zJ < LxY/(Z+β)J + β soit : 0 < Δβ < β Ensuite, par définition de C et Cβ : XY = LXY/ZJXZ + C = LxY/(Z+β)Jx(Z+β) + Cβ = (Δβ + LxY/Z)J)X(Z+β) + Cβ
Soit C = LxY/zJxβ + Δβx(Z+β) + Cβ et donc : LxY/zJ = [C-Cβ - Δβx(Z+β)] / β (calcul de l'étape E3 du procédé)
De la dernière relation, on déduit que LxY/zJ est égal à (C-Cβ)/β moins un terme correctif Δβ(Z+β)/β. Par ailleurs, par définition, LXY/ZJ est un nombre entier, de même que β et Δβ. Aussi, en calculant = [C-Cβ - Δβx(Z+β)] / β de manière systématique avec les différentes valeurs possibles de Δβ, et en vérifiant si le résultat est entier, on calcule la valeur correcte de β et donc la valeur correcte de LXY/zJ.
Comme on l'a montré précédemment, 0 < Δβ < β. Aussi, en choisissant un paramètre β petit, on limite le nombre de valeurs possibles pour Δβ et donc le nombre d'essais nécessaires pour obtenir la valeur correcte de LXY/ZJ.
L'expérience montre que les meilleurs résultats (en terme de rapidité de calcul notamment) sont obtenus pour des valeurs de b choisies égales à une puissance de 2, valeurs parmi lesquelles β = 2 donnent les meilleurs résultats. En effet, avec β = 2, on effectue des réductions modulaires (C = XXY mod Z et Cβ = XxY mod (Z+β) ) uniquement avec des moduli (Z et Z+2) de même parité que Z et donc on supprime toute difficulté liée au calcul d'une multiplication modulaire avec un modulo pair) . Par ailleurs, la division par β=2 n'est pas coûteuse en terme de temps de calcul, puisqu'une telle opération revient en pratique à décaler le contenu d'un registre de un bit à droite. Enfin, au maximum deux valeurs de Δβ sont à tester (0 et 1) .

Claims

REVENDICATIONS
1. Procédé cryptographique de réalisation d'une multiplication modulaire de type AXB mod N, procédé au cours duquel :
- si ils ne sont pas donnés décomposés, on décompose les nombres A, B, N de 2xn bits dans une base U tels que A =
AiXU + Ao, B = BiXU + Bo, et N = iXU + No, Ai, Ao, Bi, Bo, Ni et No étant des mots de n bits, puis
- on réalise des opérations de type MultModDiv sur les nombres Ai, AQ, BI, Bo, Ni et No, l'opération élémentaire MultModDiv étant définie par MultModDiv (X, Y, Z) = ( L(XxY)/zJ , (XXY) mod Z ) , X, Y, Z étant des nombres entiers de au plus n bits .
2. Procédé selon la revendication 1, dans lequel U est différent de 2n.
3. Procédé selon la revendication 2, au cours duquel :
- on réalise les opérations suivantes : (Ql, Ri) = MultModDiv (Ao, Bo, U) (Q2, R2) = MultModDiv (A1+A0, B1+B0, U) (Q3, R3) = MultModDiv (Ai, Bi, U) (Q4, R4) = MultModDiv (α, Q3, U) (Qδr R5) = MultModDiv (α, -Q1+Q2-Q3+Q4+R3Λ U)
Ri à R5, Qi à Q5 étant des résultats intermédiaires de n bits, α étant défini par la relation : α = U2 mod N, puis
- on retourne le résultat suivant : (R5+Rι) + (R4-Rι+Qι+R2-R3+Q5)XU
4. Procédé selon la revendication 3, au cours duquel le nombre U est choisi égal à T N 1.
5. Procédé selon la revendication 3, au cours duquel le nombre U est choisi égal à T v(k.N) ], k étant un nombre entier.
6. Procédé selon la revendication 5, au cours duquel le nombre k est choisi tel que soit le plus petit possible.
7. Procédé selon la revendication 2, au cours duquel :
- on calcule initialement le nombre U selon la relation U2 ηu α + δxU, α et δ étant des nombres entiers, puis
- on réalise les opérations suivantes : (Ql, Ri) = MultModDiv (Ao, B0, U) (0.2, R2) = MultModDiv (Aι+A0, Bι+B0, U) (Q3, R3) = MultModDiv (Ai, Bi, U)
Ri à R5, Qi à Q5 étant des résultats intermédiaires de n bits, puis
- on retourne le résultat suivant : ocχ (-Qι+Q2-Q3+R3+δχQ3) +Rι +U χ[(-Rι-R3+Qι+R2+Q3(α+δ2) + (-Q3+R3-Q1+Q2) χδ]
8. Procédé selon la revendication 7, dans lequel les nombres α et δ sont choisis constants, aussi petits que possibles et de sorte que α+δ2 soit également un entier constant et petit.
9. Procédé selon la revendication 2, au cours duquel :
- on réalise les opérations suivantes : (XI, Yl, Zl, RI) = Coefficients (A, B, ϋ) (Q2r R2) = MultModDiv (α, Xi, U) (Q3, R3) = MultModDiv (α, Yι+Q2, U)
α étant un nombre entier défini par α = U2 mod N, l'opération élémentaire Coefficient étant définie par Coefficients (A, B, U) = (C3, C2, Ci, Co) tels que C3 = f ; C2 = d + 3f ; Cl = e + 2f ; CO = RO ; avec : Rθ = (A mod U) (Bmod U) mod U Ri = (A mod (U+l) ) (Bmod (U+l) ) mod (U+l) R2 = (A mod(U+2) ) (Bmod(U+2) )mod(U+2) R3 = (A mod(2U+3)) (Bmod (2U+3) ) mod (2U+3) et a = (RO - R2 + ((R0-R2) mod 2) (U+2))/2 mod U + 2 b = RO - RI mod (U+l) c = (2(R0-R3) + (2(R0-R3) mod 3) (2U+3) ) /3 mod (2U+3) d = ((b-a) mod (U+l) ) e = a + 2d f = -6d + 4e-4c mod (2U + 3)
- on retourne le résultat suivant : R1+R3+ (R2+Zι+Q3) xU
10. Procédé selon la revendication 2, au cours duquel :
- on réalise les opérations suivantes : (XI, Yl, Zl, RI) = Coefficients (A, B, U) (0.2, R2) = MultModDiv (α, Xi, U) (Q3, R3) = MultModDiv (α, Y1+Q2, U)
α étant un nombre entier défini par α = U2 mod N, l'opération élémentaire Coefficient étant définie par Coefficients (A, B, U) = (C3, C2, Ci, C0) tels que C3 = f ; C2 = d + 3f ; Cl = e + 2f ; CO = RO ; avec : Ro = A0B0 mod U Ri = (AQ-AI) (BQ-BI) mod (U+l) R2 = (A0 - 2Aι) (B0-2Bι) mod (U+2) R3 = (Ao + (Ai mod 2)U - 3 (A 1 div 2)) (Bo+(Bι mod 2)U - 3(Bι div 2)) mod (2U + 3) et a = (RO - R2 + ( (R0-R2) mod 2) (U+2))/2 mod U + 2 b = RO - RI mod (U+l) c = (2(R0-R3) + (2(R0-R3) mod 3)(2U+3))/3 mod (2U+3) d = ((b-a) mod (U+l) ) e = a + 2d f = -6d + 4e-4c mod (2U + 3)
- on retourne le résultat suivant : Rl+R3+(R2+Zι+Q3)xU
11. Procédé selon la revendication 9 ou 10, au cours duquel le nombre U est choisi égal à I N 1.
12. Procédé selon la revendication 9 ou 10, au cours duquel le nombre U est choisi égal à | V(k.N) 1, k étant un nombre entier.
13. Procédé selon la revendication 12, dans lequel k est choisi aussi petit que possible tel que U soit impair et premier avec trois.
14. Procédé selon la revendication 13, au cours duquel le nombre k est choisi tel que α soit le plus petit possible.
15. Procédé selon la revendication 1, dans lequel U est égal à 2n et au cours duquel :
- on réalise les fonctions suivantes : (Ql, Ri) = MultModDiv (Ai, Bl f Ni) (Q2, R2) = MultModDiv (Qi, N0, 2n) (Q3, R3) = MultModDiv (Ai+A0, BI+BQ, 2n -1) (Q4, R4) = MultModDiv (A0, B0, 2n) (Q5, R5) = MultModDiv (2n-l, R1+Q3-Q2-Q4, Ni) (Q6, R6) = MultModDiv (Q5, N0, 2*)
R à Rg, Qi à Qg étant des résultats intermédiaires de n bits, l'opération élémentaire MultModDiv étant définie par MultModDiv (X, Y, Z) = ( L(XxY)/zJ , (XXY) mod Z ) , X, Y, Z étant des nombres entiers de au plus n bits, puis
- on retourne le résultat suivant : (R3+R5-Q6-R2-R4) *2n + (R2+R4-Rg)
16. Procédé selon la revendication 1, dans lequel U est égal à 2n et au cours duquel :
- on réalise les fonctions suivantes : (Ql, Rl) = MultModDiv (A , Bl r Nx) (Q2, R2) = MultModDiv (Ai+A0, Bι+B0, 2n-l) (Q3, R3) = MultModDiv (A0, B0, 2n) (Q4, R4) = MultModDivInit (Qi, No, Q3-Rι-Q2, Ni) (Q5, R5) = MultModDiv (N0+Nι, Q4, 2n)
Rl à R5, Qi à Q5 étant des résultats intermédiaires de n bits, l'opération élémentaire MultModDiv étant définie par MultModDiv (X, Y, Z) = ( L(XxY)/zJ , (XxY) mod Z ) , et l'opération élémentaire MultModDivInit étant définie par MultModDivInit (X, Y, T, Z) = ( L (XxY+Tx2n) /zj , (XxY + Tχ2n)mod Z ) , X, Y, Z et T étant des nombres entiers de au plus n bits, puis
- on retourne le résultat suivant : (R2+Q5-R3-R4) 2n + (R3+R4+R5)AUT0NUMAUT0NUM
EP04786385A 2003-08-21 2004-08-20 Procede de realisation d une multiplication modulaire et pro cede de realisation d une multiplication euclidienne sur des nombres de 2n bits Withdrawn EP1656611A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR0310060A FR2859030B1 (fr) 2003-08-21 2003-08-21 Procede de realisation d'une multiplication modulaire et procede de realisation d'une multiplication euclidienne sur des nombres de 2n bits
PCT/FR2004/050387 WO2005022378A1 (fr) 2003-08-21 2004-08-20 Procede de realisation d'une multiplication modulaire et procede de realisation d'une multiplication euclidienne sur des nombres de 2n bits

Publications (1)

Publication Number Publication Date
EP1656611A1 true EP1656611A1 (fr) 2006-05-17

Family

ID=34112838

Family Applications (1)

Application Number Title Priority Date Filing Date
EP04786385A Withdrawn EP1656611A1 (fr) 2003-08-21 2004-08-20 Procede de realisation d une multiplication modulaire et pro cede de realisation d une multiplication euclidienne sur des nombres de 2n bits

Country Status (6)

Country Link
US (1) US20080063184A1 (fr)
EP (1) EP1656611A1 (fr)
JP (1) JP2007503036A (fr)
CN (1) CN1867890A (fr)
FR (1) FR2859030B1 (fr)
WO (1) WO2005022378A1 (fr)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP1515226B1 (fr) * 2003-09-10 2008-12-24 Giesecke &amp; Devrient GmbH Multiplication modulaire

Families Citing this family (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP5027422B2 (ja) * 2006-02-09 2012-09-19 ルネサスエレクトロニクス株式会社 剰余演算処理装置
FR2897964B1 (fr) * 2006-02-28 2017-01-13 Atmel Corp Procede de calcul numerique incluant la division euclidienne
JP2011007820A (ja) * 2007-09-14 2011-01-13 Hitachi Ltd 剰余乗算処理装置

Family Cites Families (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5073870A (en) * 1989-01-30 1991-12-17 Nippon Telegraph And Telephone Corporation Modular multiplication method and the system for processing data
CA2253009C (fr) * 1997-11-04 2002-06-25 Nippon Telegraph And Telephone Corporation Methode et appareil d'inversion modulaire servant a proteger des informations et support d'enregistrement portant un programme d'implantation de cette methode
DE10107376A1 (de) * 2001-02-16 2002-08-29 Infineon Technologies Ag Verfahren und Vorrichtung zum modularen Multiplizieren und Rechenwerk zum modularen Multiplizieren
US6973470B2 (en) * 2001-06-13 2005-12-06 Corrent Corporation Circuit and method for performing multiple modulo mathematic operations
US7958374B2 (en) * 2002-03-19 2011-06-07 Shansun Technology Company Digital information protecting method and apparatus, and computer accessible recording medium
DE10219161A1 (de) * 2002-04-29 2003-11-20 Infineon Technologies Ag Vorrichtung und Verfahren zum Umrechnen eines Terms
US7558817B2 (en) * 2002-04-29 2009-07-07 Infineon Technologies Ag Apparatus and method for calculating a result of a modular multiplication
DE10219158B4 (de) * 2002-04-29 2004-12-09 Infineon Technologies Ag Vorrichtung und Verfahren zum Berechnen eines Ergebnisses einer modularen Multiplikation
US7461115B2 (en) * 2002-05-01 2008-12-02 Sun Microsystems, Inc. Modular multiplier

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
None *
See also references of WO2005022378A1 *

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP1515226B1 (fr) * 2003-09-10 2008-12-24 Giesecke &amp; Devrient GmbH Multiplication modulaire

Also Published As

Publication number Publication date
FR2859030A1 (fr) 2005-02-25
FR2859030B1 (fr) 2005-11-04
WO2005022378A1 (fr) 2005-03-10
US20080063184A1 (en) 2008-03-13
JP2007503036A (ja) 2007-02-15
CN1867890A (zh) 2006-11-22

Similar Documents

Publication Publication Date Title
CN110351087B (zh) 流水线型的蒙哥马利模乘运算方法
US8051124B2 (en) High speed and efficient matrix multiplication hardware module
US20040098440A1 (en) Multiplication of multi-precision numbers having a size of a power of two
EP1032873B1 (fr) Appareil pour arithmetique multiprecision d&#39;entiers
EP1368747B1 (fr) Procede et dispositif pour reduire le temps de calcul d&#39;un produit, d&#39;une multiplication et d&#39;une exponentiation modulaire selon la methode de montgomery
CA2741698C (fr) Procede et appareil pour une reduction de module
FR2867579A1 (fr) Multiplieur modulaire de montgomery
EP0984357B1 (fr) Appareil et méthode à multiplications courbe-elliptique et support d&#39;enregistrement enregistrant un programme pour implementer la méthode
US6018758A (en) Squarer with diagonal row merged into folded partial product array
CN118796152B (zh) 一种基于并行k-red模约减算法的格密码模乘器
FR2793971A1 (fr) Multiplieur de nombres complexes
US7627114B2 (en) Efficient modular reduction and modular multiplication
EP1656611A1 (fr) Procede de realisation d une multiplication modulaire et pro cede de realisation d une multiplication euclidienne sur des nombres de 2n bits
FR2867580A1 (fr) Multiplieur modulaire de montgomery et procede de multiplication correspondant
EP0237382A1 (fr) Dispositif de transformée en cosinus d&#39;un signal numérique échantilloné
van Hoeij et al. Solving conics over function fields
US11750366B2 (en) Reduced complexity modular polynomial multiplication for R-LWE cryptosystems
EP0784262B1 (fr) Dispositif et procédé améliorant la vitesse de traitement d&#39;un coprocesseur d&#39;arithmétique modulaire
JP2957845B2 (ja) 高速フーリエ変換装置
EP0175623A1 (fr) Dispositif de traitement en temps réel de signal numérique par convolution
CN116149605A (zh) 模数乘法电路与计算模数乘法的方法
EP1650869A1 (fr) Dispositif mettant en oeuvre un calcul de l&#39;expression de la somme de produits
Zhang et al. Efficient and Flexible Differet-Radix Montgomery Modular Multiplication for Hardware Implementation
EP1660989A2 (fr) Reduction modulaire pour un procede cryptographique, et coprocesseur pour la realisation d&#39;une telle reduction modulaire
CA2359198C (fr) Unite de calcul pour l&#39;execution d&#39;un protocole cryptographique

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20060221

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IT LI LU MC NL PL PT RO SE SI SK TR

DAX Request for extension of the european patent (deleted)
17Q First examination report despatched

Effective date: 20070226

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20070909