Inversion Modulaire

Dans cette section sont détaillées les techniques classiques pour effectuer l’inversion modulaire, c’est à dire étant donnés p et a, comment calculer l’élément b tel que ab ≡ 1 mod p. Cette opération est par exemple requise pour ECC, mais on en réduit le nombre au minimum car elle est très coûteuse vis à vis des autres opérations comme la multiplication. Il existe deux grandes familles d’algorithmes pour effectuer cette opération et qui sont présentées ci-dessous.

Inversion avec le petit théorème de Fermat

Le théorème porte le nom de Pierre de Fermat, qui semble-t-il a été le premier à énoncer le théorème qui suit dans une lettre à Frénicle de Bessy (voir [35], page 209) datant du 18 octobre 1640. Le théorème y est énoncé de la façon suivante : « Tout nombre premier mesure infailliblement une des puissances −1 de quelque progression que ce soit, et l’exposant de la dite puissance est sous-multiple du nombre premier donné −1 ». Ce qui peut se traduire par le théorème 3.

Théorème 3 (Petit Théorème de Fermat ou FLT pour Fermat Little Theorem).

Soit p un nombre premier et a un nombre qui n’est pas multiple de p. Alors ap−1_{− 1 ≡} 0 mod p.

De ce théorème découle directement le fait que si 0 < a < p alors a × ap−2_{≡ 1 mod p,} et donc ap−2 _{≡ a}−1 _{mod p. Ainsi, le calcul de l’inverse modulaire peut se résumer à un} grande exponentiation modulaire, implantée par exemple à l’aide de l’un des algorithmes présentés dans la section 1.1.4. Le nombre de tours de la boucle principale est donc en log p. Pour obtenir le coût total, il suffit de multiplier ce nombre par le coût des multiplica- tions internes à la boucle. Les avantages de l’algorithme issu du petit théorème de Fermat (noté FLT) viennent de sa nature d’exponentiation. Ces algorithmes sont très réguliers, et ils demandent principalement de savoir faire des multiplications modulaires et de savoir compter le nombre (fixe) de tours de boucle. Dans un contexte de cryptographie matérielle pour les courbes elliptiques par exemple, les multiplieurs sont déjà implantés pour calculer les opérations nécessaires au doublement de point par exemple. De plus, le contrôle est très simple puisqu’il s’agit juste d’un compteur.

Algorithmes d’Euclide étendus

L’algorithme d’Euclide est à l’origine une méthode permettant de trouver le « plus grand diviseur commun » (pgcd) de deux entiers, proposé par Euclide dans son œuvre Les Éléments (livre 7, propositions 1 et 2, voir par exemple l’édition [46]). Cet algorithme permet notamment, dans une version étendue, de trouver les éléments u et v tels que ua + vb = pgcd(a, b) (identité de Bézout). Supposons que l’algorithme soit calculé pour 0 < a < p et p premier, on obtient alors ua + vp = 1. Ce qui est équivalent à ua ≡ 1 mod p, on a donc bien calculé l’inverse de a modulo p. La méthode est détaillée dans l’algorithme 10 (issu de [66]).

L’idée principale de l’algorithme est d’utiliser l’égalité suivante : pgcd(a, p) = pgcd(p mod a, a) .

Algorithme 10: Algorithme d’Euclide étendu (source [66]). Entrées : a, p ∈ N avec pgcd(a, p) = 1

Sortie : U = a−1 _{mod p} 1 (u₁, u₂, u₃) ←− (0, 1, p) 2 (v₁, v₂, v₃) ←− (1, 0, a) 3 tant que v₃6= 0 faire

4 q ←− j u3 v3 k 5 (u₁, u₂, u₃) ←− (u₁, u₂, u₃) − q(v₁, v₂, v₃) 6 (u₁, u₂, u₃) ←→ (v₁, v₂, v₃) 7 si u₁ < 0 alors 8 u₁ ←− u₁+ p 9 retourner u₁

Ainsi en prenant successivement l’opérande le plus grand, modulo le plus petit, on réduit leur taille à chaque tour de boucle, pour finalement arriver au pgcd final (qui vaut 1 dans notre cas). Les opérandes sont d’abord stockés dans les variables u1, u2, u3, v1, v2 et v3. Ces variables sont telles que u1· a + u2· p = u3 et v1· a + v2· p = v3 à la fin de chaque tour de boucle. À la fin de l’algorithme, u3 vaut 1, le résultat est donc bien u1. On peut remar- quer qu’il n’est pas nécessaire de calculer u2 et v2, seuls u1 et v1 contiendront les valeurs pour arriver à l’inverse, u3 et v3 étant requis pour savoir quand arrêter l’algorithme. En moyenne, le nombre de tours de la boucle principale est environ 12 log 2

π2 ln p ≈ 0.58 log₂p, voir par exemple [41,59] si on considère en entrée p et a un élément de Fp. Cela est presque deux fois moins que pour l’algorithme de Fermat, mais il faut en contrepartie être capable de faire des divisions euclidiennes sur des grands nombres de façon efficace.

Une variante célèbre de l’algorithme d’Euclide est sa version dite « binaire », proposée initialement par Stein dans [117]. Cette variante va permettre de s’affranchir du coût des divisions Euclidiennes, pour les remplacer par des divisions par 2 et des tests modulo 2. Ces deux opérations étant triviales en représentation binaire, cet algorithme va permettre une grosse réduction du coût d’une itération de la boucle principale. En contrepartie, plus de tours de boucle principale sont effectués, environ 0.71 log₂p. La version étendue est décrite dans l’algorithme 11 (issu de [66]§ 4.5.2).

Tout au long de cet algorithme, on retrouve l’égalité u1·a ≡ u3 mod p, et la même chose pour les vi. La différence vient de la façon dont on fait évoluer ces valeurs intermédiaires. La propriété utilisée pour réduire les opérandes tout en gardant le même pgcd n’est plus pgcd(a, p) = pgcd(p mod a, a), mais on utilise le fait que

          

pgcd(u3, v3) = pgcd(u3/2, v3) si u3 pair et v3 impair pgcd(u3, v3) = 2 · pgcd(u3/2, v3/2) si u3 et v3 pairs pgcd(u3, v3) = pgcd((u3− v3)/2, v3) si u3 et v3 impairs.

(1.7)

Ainsi, dans la boucle principale on commence par diviser les deux opérandes par 2 tant qu’ils sont pairs. Lorsqu’on divise par 2 la valeur v3 par exemple, il faut mettre à jour la valeur associée v1 pour conserver (v1/2) · a ≡ (v3/2) mod p, quitte à rajouter p à v1 si sa valeur est impaire. Après les deux boucles internes de parité, u3 et v3 sont impairs (on est dans le troisième cas de l’équation 1.7) : on fait donc la différence du plus grand et du plus

Algorithme 11: Algorithme d’Euclide étendu binaire de [66]§ 4.5.2. Entrées : a, p ∈ N, p > 2 avec pgcd(a, p) = 1

Sortie : |a−1_| p

1 (u₁, u₃) ← (0, p), (v₁, v₃) ← (1, a) 2 tant que v₃ 6= 1 et u₃ 6= 1 faire 3 tant que |v₃|₂ = 0 faire

4 v₃ ← v3 2 5 si |v₁|₂ = 0 alors 6 v₁ ← v1 2 7 sinon 8 v₁ ← v1+p 2

9 tant que |u₃|₂= 0 faire

10 u₃← u3 2 11 si |u₁|₂= 0 alors 12 u₁← u1 2 13 sinon 14 u₁← u1+p 2 15 si v₃ ≥ u₃ alors 16 v₃ ← v₃− u₃ 17 v₁ ← v₁− u₁ 18 sinon 19 u₃← u₃− v₃ 20 u₁← u₁− v₁

21 si v₃ = 1 alors retourner |v₁|_p sinon retourner |u₁|_p

petit, puis on applique à nouveau la règle 1.7.

Pour finir est présentée ici une variante de l’algorithme binaire d’Euclide étendu, uti- lisant une astuce appelée plus-minus. Les auteurs de [22] ont proposé de remplacer la comparaison v3 > u3 par un test modulo 4 dans l’algorithme binaire du calcul du pgcd. Cette astuce est très intéressante pour les représentations dans lesquelles les comparai- sons sont difficiles (comme RNS). Il faut surtout être capable de faire de façon efficace des réductions modulo 4. L’algorithme 12, proposé dans [37], est une version étendue de l’algorithme de calcul de pgcd de [22]. L’astuce est de remarquer que si deux entiers sont impairs, alors leur somme ou (exclusif) leur différence est un multiple de 4. Ainsi, au lieu d’effectuer une comparaison entre les valeurs u3et v3 comme dans l’algorithme 11, on teste la valeur modulo 4 de leur somme. Si on obtient 0, on effectue ensuite une division par 4 de cette somme, sinon on divise par 4 la différence. Des petites comparaisons sont effectuées sur les valeurs de contrôle lu et lv, mais ces valeurs là sont très petites devant la taille des opérandes (elles sont de taille log₂log₂p). Dans l’algorithme 12, des fonctions div2 et div4sont définies. La fonction div2 effectue en fait les lignes 5,6,7 et 8 de l’algorithme 11, c’est à dire elle divise par 2 modulo p son entrée. De même div4 divise par 4 modulo p, sa définition complète dépend de la valeur |p|4. Par exemple, si |p|4 = 3, alors

       v1/4 si |v1|4= 0 (v1+ p)/4 si |v1|4= 1 (v1+ 2p)/4 si |v1|4= 2 (v1− p)/4 si |v1|4= 3 ,

ce qui correspond bien à la division par 4 modulo p. Autrement dit, on construit un multiple de 4, en ajoutant un certain nombre de fois p, qui est finalement divisé par 4.

Algorithme 12: Inversion modulaire plus-minus [37]. Entrées : a, p ∈ N avec pgcd(a, p) = 1, ℓ = ⌈log2p⌉ Sortie : |a−1_|

p

1 (u₁, u₃) ← (0, p), l_u ← ℓ 2 (v₁, v₃) ← (1, a), l_v ← ℓ 3 tant que l_v> 0 faire 4 si |v₃|₄= 0 alors 5 v₃← v₃/4 6 v₁← div4(v₁, p) 7 l_v ← l_v− 2 8 sinon si |v₃|₂= 0 alors 9 v₃← v₃/2 10 v₁← div2(v₁, p) 11 l_v ← l_v− 1 12 sinon 13 v∗ 3 ← v3, v∗1 ← v1, l∗u← lu, l∗v ← lv 14 si |u₃+ v₃|₄ = 0 alors 15 v₃← (v₃+ u₃)/4 16 v₁← div4(v₁+ u₁, p) 17 sinon 18 v₃← (v₃− u₃)/4 19 v₁← div4(v₁− u₁, p) 20 si l_v< l_u alors 21 u₃ ← v∗ 3, u1← v1∗ , lu ← lv∗ , lv ← l∗u− 1 22 sinon v ← v − 1 23 si u₁ < 0 alors u₁ ← u₁+ p

24 si u₃ = 1 alors retourner u₁ sinon retourner p − u₁

Les auteurs de [36] fournissent des résultats d’implantation FPGA Spartan 3 des diffé- rents algorithmes d’inversion présentés dans cette section (voir pages 113-116 de [36]). Pour leurs implantations, les algorithmes les plus efficaces sont clairement l’algorithme d’Euclide étendu binaire ainsi que sa variante plus-minus. Les deux implantations sont très proches en termes de temps, et la surface de la version plus-minus se révèle un peu plus petite. L’algorithme classique d’Euclide étendu et celui issu du FLT sont tous deux loin derrière (l’algorithme du FLT restant le plus lent).