Le temps d’exécution d’un calcul d’exponentiation modulaire ou d’une multiplication sca- laire de point de courbe elliptique est une donnée facilement accessible pour un adversaire. En effet, dans un protocole interactif, un adversaire peut solliciter une cible en envoyant un mes- sage à traiter. Il chronomètre alors simplement le temps mis pour obtenir une réponse. Dans un algorithme non régulier, le temps de calcul peut varier en fonction du poids de Hamming de l’exposant ou du scalaire. Ceci donne une information à l’attaquant. Cependant, cela reste
insuffisant pour retrouver la totalité de l’exposant ou du scalaire. Un lot de chronométrages de calculs avec plusieurs jeux de données différents, mais avec le même exposant ou scalaire se- cret, peut présenter des propriétés statistiques qui révèlent plus d’informations sur l’exposant ou le scalaire. Ainsi, et contrairement à la SPA précédente, il faudra obtenir plusieurs mesures. Cette attaque repose donc sur un principe statistique : la distribution des temps présente des caractéristiques (variance) dépendantes de l’implantation et des messages à traiter, mais qui révèlent l’exposant ou le scalaire secret convoité.
Cette attaque a été présentée par Kocher dans [37]. Nous reprenons sa présentation avec en premier lieu une attaque simplifiée, puis la version générale de l’attaque. Nous conclurons sur l’application et les contre-mesures de cette attaque.
3.3.1 Description de l’attaque
Kocher dans [37] se place dans le cas de l’exponentiation modulaire que nous avons pré- sentée en algorithme 2.1 page 53. Nous reprenons les notations de l’algorithme 2.1 avec en plus : pour b < t, Xb est la valeur obtenue après b tours de boucle (on a donc ge= Xt−1).
3.3.1.1 Attaque simplifiée
Dans un premier temps, Kocher suppose que le temps d’exécution de la multiplication mo- dulaire dépend des données en entrée, et que l’attaquant connaît les données pour lesquelles ce temps est anormalement long. Dans cette hypothèse extrême, l’attaquant qui a recueilli plu- sieurs temps et qui connaît les premiers bits de l’exposant peut deviner le bit suivant. En pro- cédant de façon itérative, la totalité de l’exposant peut être connue.
On suppose donc que l’attaquant connaît les b premiers bits de l’exposant. Il peut calculer les différentes valeurs de Xbcorrespondant à chaque temps qu’il a obtenu après avoir sollicité
différents calculs de la cible. À l’itération suivante, l’algorithme calcule Y = X2
b, puis Y ·
g mod N si le (b + 1)ème bit vaut 1 (et−b−1 = 1). Deux cas se présentent :
— soit l’hypothèse et−b−1 = 1est vraie : la multiplication Y · g mod N est donc calculée par l’algorithme. Dans certains cas que l’attaquant peut déterminer, cette multiplication va prendre un temps plus long. Il peut alors vérifier que c’est le cas des exécutions correspondantes ;
— soit l’hypothèse et−b−1= 0est vraie : la multiplication n’est jamais effectuée, l’attaquant peut alors voir que les exécutions lentes n’apparaissent pas de façon corrélée ;
— enfin, l’attaquant peut vérifier l’hypothèse et−b−1 = 1 ou et−b−1 = 0 en contrôlant le temps d’exécution du carré suivant, selon les données en entrée par rapport au temps d’exécution de ce carré qu’il prédit.
Cette version simplifiée de l’attaque est peu réaliste. Elle suppose une propriété particu- lière de la multiplication modulaire, soit un temps d’exécution dépendant du jeu de données d’entrée, au moins pour certains d’entre eux, que l’attaquant connaît. Ceci dit, le principe est posé d’une attaque que l’on va raffiner sur le plan statistique pour en renforcer l’efficacité.
3.3.1.2 Attaque générale
Soient m messages y0, y1, . . . , yj−1et les temps de calcul T0, T1, . . . , Tj−1. Kocher dans [37]
remarque que chaque temps de calcul peut s’écrire T = ǫ +Pt−1
i=0τioù τi est le temps d’exécu-
tion de chacune des itérations i de la boucle for de l’algorithme 2.1 et ǫ les erreurs et bruit de mesure. Connaissant les b premiers bits de l’exposant e, deviner eb peut s’effectuer avec une
bonne probabilité de la façon suivante : — l’attaquant peut calculerPb−1
— les temps Tj étant indépendants les uns des autres, il peut calculer la variance des θj =
ǫ +Pt−1i=bτi = Tj−Pb−1i=0τipour chacun des j messages ;
— l’attaquant formule une hypothèse sur eb, il a deux alternatives, 0 ou 1 ; l’attaquant peut
ensuite calculer τb etPbi=0τi, et après avoir effectué ce calcul pour les j messages, en
déduire la nouvelle valeur de la variance de θj = Tj−Pbi=0τi:
— si l’hypothèse sur ebest correcte, la valeur attendue de la variance correspond à celle
que l’on calcule directement à partir de celle du bruit et des itérations de la boucle avec les bonnes hypothèses sur les bits. Cette valeur est
Var(ǫ) + (t − b)Var(τ);
— si l’hypothèse sur ebest fausse, les valeurs réelles de τbattendues par l’attaquant sont
décorrélées de son hypothèse, et on accroît donc la variance attendue par rapport à une hypothèse correcte. La variance attendue devient donc
Var(ǫ) + (t − b + 2)Var(τ).
L’attaquant réitère ce processus pour chaque bit. Le succès de l’attaque est assuré par le fait que Var(ǫ) n’est pas grand devant (t − b)Var(τ) et que chaque hypothèse successive correcte sur les bits de l’exposant diminue la variance de θj de Var(τ), alors qu’une hypothèse incor-
recte l’augmente de Var(τ). Ainsi, plus simplement, la bonne hypothèse est celle qui produit la variance de θj la plus petite.
Kocher tire aussi de cette dernière propriété le nombre de chronométrages requis pour as- surer le succès de l’attaque. Il évalue pour ce faire la probabilité de vérifier la bonne hypothèse sur le bit b en négligeant Var(ǫ), c’est à dire que les variances mentionnées plus haut sont correctement ordonnées. Il utilise pour ce faire l’hypothèse que les valeurs τi suivent une loi
normale. On a dans ce cas :
Pb = P j−1 X i=0 √ t − bXi+ √ 2Yi 2 > j−1 X i=0 √ t − bXi 2! ,
où X et Y sont deux variables aléatoires standards suivant la loi normale (les moyennes de X et Y sont 0 et leur écart-type est 1). Après développements et quelques réarrangements, cette probabilité s’écrit : Pb = P Z > − √ j p 2(t − b) ! ,
où Z est une variable aléatoire suivant la loi normale dont la moyenne est 0 et l’écart-type est 1. On écrit aussi Pb = Φ s j 2(t − b) ! .
Φ représente l’aire sous la courbe de Gauss représentant Z entre −∞ et son argument, ici q
j 2(t−b).
Exemple 3.3.1. Nous calculons la probabilité d’avoir la bonne hypothèse sur le bit b dans les conditions
suivantes :
— le nombre de calculs chronométrés est j = 1000 ;
— on veut deviner le premier bit b = 1 ;
alors, la probabilité de succès dans l’hypothèse réalisée est
Pb = Φ s 1000 × 1 2(1024 − 1) ! ≈ 0, 7580.
Dans notre exemple, la taille correspond à ce qui est préconisé pour une signature. On remarque aussi que si une hypothèse est fausse, il est toujours possible de le constater car dans ce cas, la variance, qui doit diminuer au fur et à mesure des hypothèses, augmente au contraire. Ainsi, une hypothèse incorrecte peut être détectée et l’attaque ajustée en conséquence.
3.3.2 Contre-mesures et conclusion
La Timing Attack s’appuie sur le manque de régularité des opérations internes à la boucle for des algorithmes d’exponentiation modulaire ou de multiplication scalaire de point de courbe elliptique. Ce manque de régularité peut avoir deux causes : soit les opérations réalisées dépendent du bit du scalaire (comme dans l’algorithme 2.1 pour l’exponentiation modulaire), soit en raison d’une dépendance du temps de calcul d’une opération élémentaire en fonction du jeu de données d’entrée de cette opération.
La parade consiste donc à utiliser des opérations régulières autant que faire se peut afin de rendre la variance des erreurs de mesure du bruit Var(ǫ) aussi grande que possible devant le terme (t − b)Var(τ) de chaque tour de boucle.
Kocher pense cependant que l’utilisation d’opérations dont la séquence d’instructions est indépendante des données d’entrée telles que la multiplication modulaire de Montgomery dans l’exponentiation modulaire (voir l’algorithmes 1.3 à 1.8 pages 25 à 30) n’est pas une contre-mesure suffisante si le niveau de bruit reste acceptable. Il ne donne cependant pas d’évaluation précise. Le cas de la multiplication scalaire de point de courbe elliptique est aussi menacée, avec la même remarque au niveau de la régularité des opérations de doublement, addition ou halving pour les courbes sur corps de caractéristique 2.
Le cas des algorithmes réguliers d’exponentiation ou de multiplication scalaire répond ce- pendant à cette critique. En effet, si les opérations effectuées à chaque tour de boucle sont strictement identiques et indépendantes des données, la variance du temps de calcul τi pour
chaque tour est constante. Cette régularité ne permet donc pas de distinguer les différents bits. Il ne reste dans la variance que Var(ǫ). Ceci reste à prendre avec prudence dans la mesure où une indépendance totale vis à vis des données d’entrée ne peut être garantie pour des raisons qui peuvent relever de l’architecture (défauts de cache, ou l’exemple des tests étape 9 de l’algo- rithme 1.8 page 30 de débordement dans la réduction modulaire...) Nous pouvons cependant admettre dans la suite que les algorithmes réguliers tels que l’échelle binaire de Montgomery ou les exponentiations régulières 2γ-aires sont résistantes à ces attaques (les algorithmes 3.5 à
3.6, 3.9 et 3.10).
Pour finir, une contre-mesure plus radicale peut être mise en œuvre : c’est la randomisation de l’exposant/scalaire. Nous examinons quelques-unes de ces techniques plus loin, dans la section 3.4.2 sur les contre-mesures face à l’attaque Differential Power Analysis. Dans ce dernier cas, le masquage des bits de l’exposant/scalaire entre chaque calcul ne donne plus aucune signification au calcul de variance précédent.