Brevet FR2838210A1 — publié le 20031010

PROCEDE CRYPTOGRAPHIQUE PROTEGE CONTRE LES ATTAQUES DE TYPE A CANAL CACHE L'invention concerne un procédé cryptographique protégé contre les attaques de type à canal caché. L'invention est notamment intéressante pour protéger des algorithmes au cours duquel on exécute un bloc d'instructions parmi plusieurs bloc d'instructions différents en fonction d'une variable d'entrée. Un tel algorithme est par exemple, mais non limitativement, un algorithme binaire d'exponentiation, réalisant un calcul de type Y = XD, X, Y et D étant des nombres entiers. Un tel algorithme est par exemple mis en #uvre dans des dispositifs électroniques tels que des cartes à puce. Le diagramme de principe d'un tel algorithme est représenté sur la figure 1. Il comprend une première étape de test de la valeur d'une donnée d'entrée. En fonction du résultat du test, on réalise ensuite un bloc d'instructions Iii ou un bloc d'instructions II1. L'algorithme peut ensuite se terminer, ou bien une nouvelle étape de test est réalisée sur une autre variable d'entrée. Les blocs d'instructions Ilo, rli comprennent chacun un ensemble d'instructions à exécuter. Le nombre et /ou le type des instructions peuvent être différents d'un bloc d'instructions Ho, Il, à l'autre. De nombreux algorithmes cryptographiques sont basés sur le diagramme de principe de la figure 1. C'est notamment le cas des algorithmes cryptographiques basés sur des calculs d'exponentiation du type Y = XD, où X, Y sont des nombres entiers le plus souvent de grande taille, et D un nombre prédéterminé. Les nombres X, Y peuvent correspondre par exemple à un texte chiffré ou à chiffrer, une donnée signée ou à signer, une donnée vérifiée ou à vérifier, etc. Le nombre D peut correspondre à des éléments de clés, privées ou publiques utilisées pour le chiffrage ou le déchiffrage des nombres X, Y. A titre d'exemple des algorithmes tels que l'algorithme dit "Square-And-Multiply", l'algorithme dit "Right-To-Left binary algorithm", l'algorithme dit "(M, M3) algorithm" peuvent être utilisés pour réaliser des calculs d'exponentiation. Un utilisateur malveillant peut éventuellement engager des attaques, visant à découvrir notamment des informations confidentielles (comme par exemple la clé D ou une donnée dérivée de cette clé) contenues et manipulées dans des traitements effectués par le dispositif de calcul exécutant une opération d'exponentiation. Une attaque simple, dite "timing attack", contre l'algorithme de la figure 1 consiste à mesurer le temps nécessaire au dispositif pour exécuter un bloc d'instructions entre deux étapes de test. Si les temps d'exécution des blocs d'instructions IIo, II1 sont différents, alors il est facile d'identifier un bloc d'instructions 110 ou nl et d'en déduire la valeur de la variable d'entrée associée. Pour se prémunir contre cette attaque, il est possible d'ajouter des instructions fictives dans le bloc d'instructions Ho ou 111 le plus court (dans le sens où le temps mis pour le réaliser est le plus petit) de sorte à ce que les deux blocs d'instructions Ho, 111 soient de même durée. Une instruction est dite fictive si son exécution ne modifie pas les données manipulées par l'algorithme. Par exemple, l'instruction i Si cette solution est efficace contre les "timing attacks", elle n'est pas efficace contre d'autres types d'attaques à canal caché et elle peut également pénaliser les temps d'exécution de l'algorithme. Les attaques à canaux cachés les plus connues sont dites simples ou différentielles. On entend par attaque à canal caché une attaque basée sur une grandeur physique mesurable de l'extérieur du dispositif, et dont l'analyse directe (attaque simple) ou l'analyse selon une méthode statistique (attaque différentielle) permet de découvrir des informations contenues et manipulées dans des traitements réalisés dans le dispositif. Par exemple, dans une "timing attack", le canal caché (la grandeur physique mesurable depuis l'extérieur) est le temps. Les attaques à canal caché peuvent permettre de découvrir des informations confidentielles. Ces attaques ont notamment été dévoilées par Paul Kocher (Advances in Cryptology - CRYPTO'99, vol. 1666 of Lecture Notes in Computer Science, pp.388-397. Springer-Verlag, 1999). Parmi les grandeurs physiques qui peuvent être exploitées à ces fins, on peut citer le temps d'exécution, la consommation en courant, le champ électromagnétique rayonné par la partie du composant utilisée pour exécuter le calcul, etc. Ces attaques sont basées sur le fait que, au cours de l'exécution d'un algorithme, la manipulation d'un bit, c'est à dire son traitement par une instruction particulière, laisse une empreinte particulière sur la grandeur physique considérée, selon la valeur de ce bit et/ ou selon l'instruction. Les attaques à canaux cachés peuvent aboutir sur des algorithmes tels que celui de la figure 1 si les blocs d'instructions n0, 111 ne sont pas équivalents vis- à-vis de ces attaques. Le terme "équivalent" doit être compris ici et dans tout ce qui suit de la manière suivante. Deux instructions INST1, INST2 (ou deux blocs d'instructions #0, ni) sont dits équivalentes (noté INSTo - INSTi) s'il n'est pas possible de les différencier par une attaque à canal caché. C'est le cas notamment si la grandeur physique mesurée au cours de l'attaque suit la même évolution pour les deux instructions. A noter toutefois que deux instructions peuvent être équivalentes vis-à-vis d'une attaque à canal caché et ne pas être équivalentes vis-à-vis d'une autre attaque à canal caché. Dans le même esprit, on dira que deux instructions (ou blocs d'instructions) sont égales si lorsqu'elles sont utilisées avec les mêmes données d'entrée, elles produisent des données de sortie identiques. Il est connu de se prémunir contre les attaques à canaux cachés en ajoutant des instructions fictives à l'algorithme. On supposera dans ce qui suit qu'une instruction fictive est équivalente à une instruction réelle similaire. Par exemple l'instruction i Dans le cas de l'algorithme de la figure 1, il est ainsi connu de réaliser un bloc d'instructions #1 fictif après chaque bloc d'instructions #0, et de réaliser de manière symétrique un bloc d'instructions #0 fictif avant chaque bloc d'instructions #1 (voir les étapes en pointillés sur la figure 1). Ainsi, quelle que soit la valeur de la donnée d'entrée, on réalisera un bloc d'instructions n0 et un bloc d'instructions II1, dans l'ordre, l'un ou l'autre étant fictif, de sorte qu'il ne soit pas possible de prédire la valeur de la donnée d'entrée, les grandeurs physiques relatives à un calcul étant équivalentes. On note ainsi : (1-io il 111(fictif - (1-10(fictif) Il ni) Si cette solution est efficace contre les attaques à canaux cachés, elle présente cependant l'inconvénient de multiplier en moyenne par deux le temps d'exécution de l'algorithme. En effet, dans le cas d'un algorithme non protégé utilisant M données d'entrée, on réalise statistiquement en moyenne M/2 bloc d'instructions #0 et M/2 bloc d'instructions #1, Si TO, respectivement Tl sont les temps moyens d'exécution d'un bloc d'instructions #0, respectivement #1, alors le temps moyen d'exécution de l'algorithme non protégé est égal à M*(TO + Tl) / 2. Par contre, dans le cas de l'algorithme protégé par des blocs d'instructions rlo, rh fictifs, on réalise systématiquement un bloc d'instructions #0 et un bloc d'instructions #1 pour chacune des M données d'entrée. En conséquence, le temps moyen d'exécution de l'algorithme protégé par des blocs d'instructions fictifs est égal à M*(TO + Tl) . Un but de l'invention est de proposer un algorithme cryptographique sécurisé contre les attaques à canaux cachés et plus rapide que les algorithmes protégés existants. Ce but est atteint par un procédé de calcul cryptographique selon l'invention, caractérisé en ce que, pour exécuter un bloc d'instructions choisi (#j) en fonction d'une variable d'entrée (Di) parmi N blocs d'instructions prédéfinis (111, ..., Fin), on exécute un nombre prédéfini (Lj) de fois un bloc élémentaire commun (F(k,s)) aux N blocs d'instructions prédéfinis (TIll ..., Fin), le nombre prédéfini (Lj) étant associé au bloc d'instructions choisi (rIj). Ainsi, avec l'invention on réalise un seul bloc élémentaire, le bloc élémentaire commun, un nombre prédéfini de fois, selon la variable d'entrée. Il n'est alors pas possible de déterminer par une attaque à canal caché quel bloc d'instructions est exécuté. Le nombre prédéfini (Lj) est variable d'un bloc d'instructions prédéfini (rll, ..., IIN) à l'autre. Le bloc élémentaire commun (r(k,s)) comprend de préférence au moins une instruction de calcul équivalente vis-à-vis d'une attaque à canal caché à une instruction de calcul de chaque bloc prédéfini (rI,, ..., TIN). Le bloc élémentaire commun (r(k,s)) peut également comprendre une instruction de mise à jour d'un pointeur de boucle (k) indiquant un nombre d'exécutions déjà exécutées du bloc élémentaire commun (r(k,s)). Si nécessaire, le bloc élémentaire commun (r(k,s)) peut comprendre en complément une instruction de mise à jour d'un pointeur d'état (s) indiquant si le nombre prédéfini (Lj) a été atteint. La valeur du pointeur de boucle (k) et / ou la valeur du pointeur d'état (s) sont fonction de la valeur de la variable d'entrée (Di) et / ou du nombre d'instructions du bloc d'instructions (Pj) associé à la valeur de donnée d'entrée. De préférence, si plusieurs blocs élémentaires sont possibles, le bloc élémentaire commun est choisi minimal, en ce sens qu'il comprend un nombre d'instructions minimal et / ou qu'il s'effectue en un temps minimal. Selon un autre mode de réalisation, pour réaliser successivement plusieurs blocs d'instructions choisis parmi les N blocs d'instructions prédéfinis (1-Il, ..., FIN) en fonction d'une variable d'entrée (Dj) associée à un indice d'entrée (i), on exécute un nombre total (LT) de fois le bloc élémentaire commun (r(k,s)), le nombre total (LT) étant égal à une somme des nombres prédéfinis (Lj) associés à chaque bloc d'instructions choisi (Iii). Là encore, on exécute seulement le bloc élémentaire commun, quel que soient les blocs d'instructions à exécuter, de sorte qu'il n'est pas possible de prédire à quel bloc d'instructions est associé le bloc élémentaire commun en cours d'exécution. Une attaque à canal caché ne peut donc pas aboutir. A noter qu'un même bloc d'instructions peut être choisi plusieurs fois selon la variable d'entrée associée à l'indice d'entrée (i). L'invention concerne également un procédé d'obtention d'un bloc élémentaire commun (F(k,s)) à N blocs d'instructions (TI1, ..., fin) prédéfinis. Ledit procédé est susceptible d'être utilisé pour la mise en #uvre d'un procédé de calcul cryptographique sécurisé tel que celui décrit ci-dessus. Selon l'invention, on obtient un bloc élémentaire commun en réalisant les étapes suivantes : El : décomposition de chaque bloc d'instructions prédéfini (Pli, ..., IIN) en une suite de blocs élémentaires (y) équivalents vis-à-vis d'une attaque à canal caché, et classement de l'ensemble des blocs élémentaires, E2 recherche d'un bloc élémentaire commun (r(k,s)) équivalents à tous les blocs élémentaires (y) de tous les blocs d'instructions prédéfinis. Le bloc élémentaire commun recherché comprend au moins un bloc élémentaire précédemment obtenu lors de l'étape El et une instruction de mise à jour d'un pointeur de boucle (k) tel que une exécution du bloc élémentaire commun associée à la valeur du pointeur de boucle (k) et une exécution du bloc élémentaire de rang égal à la valeur du pointeur de boucle (k) soient identiques. Si nécessaire, au cours de l'étape El, une ou des instructions fictives peuvent être ajoutée à la série des instructions d'un ou plusieurs blocs d'instructions : ceci peut faciliter composition de chaque blocs d'instructions en des blocs élémentaires tous équivalents vis-à-vis d'une attaque à canal caché. Au cours de l'étape El, on découpe chaque bloc d'instructions prédéfinis ##1 à Fin en blocs élémentaires équivalents vis-à-vis d'une attaque donnée ; les blocs élémentaires sont classés. Par exemple : Plus généralement, chaque bloc d'instructions #1, ..., #N se décompose ainsi : avec Ci = 0 C2 = Li Cj = Lx+L2+ ... + L~1 CN = Li+ ... LN-1 où Lj est le nombre de blocs élémentaires nécessaires pour décomposer complètement le bloc prédéfini d'instructions #j. Au cours de l'étape E2, on recherche un bloc élémentaire commun r tel que chaque bloc d'instructions Ih (1 De préférence, le bloc commun est choisi minimal, ayant un nombre d'instructions le plus petit possible et / ou s'effectuant en un temps minimal. Le bloc élémentaire commun peut comprendre : - un ou plusieurs blocs élémentaires obtenus lors de l'étape El, et - une instruction de mise à jour d'un pointeur de boucle (k) tel que une exécution du bloc élémentaire commun associée à la valeur du pointeur de boucle (k) et une exécution du bloc élémentaire de rang égal à la valeur du pointeur de boucle (k) soient identiques. Si nécessaire, un pointeur d'état peut également être utilisé en complément du pointeur de boucle : - le pointeur d'état s indique si le bloc élémentaire commun a été exécuté un nombre prédéfini de fois correspondant au nombre de blocs élémentaires décomposant un bloc d'instructions données ; dans un exemple, le pointeur d'état s est égal à 1 lorsque le nombre prédéfini de blocs élémentaires a été exécuté, et il est égal à 0 sinon. - le pointeur de boucle indique le rang du bloc élémentaire à exécuter parmi l'ensemble des blocs élémentaires. De manière très générale, le pointeur de boucle peut être défini selon la relation suivante : k La relation ci-dessus donnant la valeur de k est obtenue par le raisonnement suivant. Lorsqu'on réalise un bloc d'instructions #j, le pointeur de boucle k doit être incrémenté de 1 à chaque exécution du bloc élémentaire commun (associée à un bloc élémentaire équivalent de la décomposition du bloc #j) tant que s = 0, c'est-à-dire tant que le nombre de blocs élémentaires associés au bloc #j n'a pas été atteint. Ceci se traduit par la relation : k Inversement, lorsqu'on réalise le bloc élémentaire commun associé au dernier bloc élémentaire du bloc #j (c'est-à-dire lorsque s = 1), il est nécessaire d'incrémenter k de sorte à réaliser le bloc élémentaire commun associé au premier bloc élémentaire du bloc d'instructions suivant rij.. Ceci se traduit par la relation suivante : k En combinant les deux dernières relations , on obtient finalement : k L'invention et les avantages qui en découlent apparaîtront plus clairement à la lecture de la description qui suit d'exemples de mise en #uvre d'un procédé cryptographique sécurisé selon l'invention. La description est à lire en référence aux dessins annexés dans lesquels : - la figure 1 est un diagramme générique de procédés connus et susceptibles d'être protégés selon l'invention, - la figure 2 est un diagramme du procédé générique de la figure 1 protégé selon l'invention, - les figures 3 et 4 détaillent la réalisation de certaines étapes du procédé de la figure 2 dans le cas de procédés d'exponentiation connus. Dans les exemples qui suivent, on va décrire notamment l'obtention d'un bloc élémentaire commun selon l'invention et l'utilisation de ce bloc élémentaire, dans les cas pratiques de trois procédés de calcul cryptographique. Dans un premier exemple pratique, on considère un algorithme d'exponentiation de type "Square-and-Multiply" (qu'on appellera par la suite algorithme 1 par souci de simplification). L'algorithme 1 permet de réaliser une opération d'exponentiation de type Y = X , où D = (DM~i, ..., Do) est un nombre de M bits. Cet algorithme peut être représenté comme suit : Initialisation : Ro Tant que i # 0, répéter : Si Di 1, alors réaliser #0 : Ro Si Di = 0, alors réaliser #1 : Ro Algorithme "Square-and-Multiply" (algorithme 1) Dans l'algorithme 1, les blocs d'instructions IIo, ri, sont réalisés selon la valeur d'un bit de l'exposant D, et on incrémente un indice de boucle i à la fin de chaque bloc d'instructions Ho, IIi de sorte à traiter successivement tous les bits de D. Dans l'algorithme 1, les bloc d'instructions Ho, Pli ne sont pas équivalents vis-à-vis d'une attaque à canal caché, notamment parce ce que le nombre d'instructions de n0 est différent du nombre d'instructions de 111 . Pour protéger l'algorithme 1 selon l'invention, on recherche un bloc élémentaire commun susceptible d'être utilisé pour l'exécution des blocs n0/ 111. Pour cela, on décompose tout d'abord chaque bloc d'instructions n0, II1 en une suite de blocs élémentaires, tous équivalents entre eux vis-à-vis d'une attaque donnée. Le bloc d'instructions #0 peut s'écrire : Ro Ro L'instruction i #0 peut alors se décomposer en deux blocs élémentaires : rIo = y0 j) yl avec y0 : Ro IIl = Y2 avec y2 R0 équivalents (y0 - yl - y2) si on suppose que les instructions Ro On a ainsi décomposé chaque bloc d'instructions #0, #1 en un nombre variable (d'un bloc d'instructions à l'autre) de blocs élémentaires, tous équivalents les uns aux autres. On définit ensuite un pointeur d'état s et un pointeur de rang k. Lorsqu'un bloc d'instructions # est en cours d'exécution : - k est utilisé pour indiquer quel bloc élémentaire yk doit être réalisé ; valeur de k dépend notamment du bloc II en cours d'exécution (et donc de la variable d'entrée testée) - s est utilisé pour indiquer si au moins un bloc yk doit être encore être réalisé ou si le bloc y en cours est le dernier du bloc #. Dans le cas de l'exemple ci-dessus relatif à l'algorithme 1, on peut résumer l'évolution des pointeurs k, s par le tableau ci-dessous. k s (Di = 1) [gamma]0 : Ro Ro.Ro ; i i-0 0 0 y1 : Ro Dans le cas de l'algorithme 1, on peut par exemple calculer s par la relation suivante (div est la division entière) : s = (k mod 2) + (k div 2) On retrouve les différentes valeurs de s en fonction de k (cf tableau 1). k peut être calculé à partir de s et de DI, Dl étant représentatif du bloc # en cours : - si s = 0 (bloc # en cours de réalisation) , k est incrémenté de 1 à chaque réalisation d'un bloc élémentaire y , pour effectuer le bloc élémentaire y suivant. - si s = 1, le bloc # en cours est terminée et le bloc élémentaire suivant y à effectuer est le premier bloc du prochain bloc # à exécuter ; k dépend donc de Di. De ce qui précède, on en déduit que k peut être obtenu par la relation suivante : k avec /s la valeur complémentaire de s (fonction NON logique), et f une fonction logique de Di, qui dépend de l'algorithme à protéger (voir aussi figure 3). Dans le cas de l'algorithme 1, on peut par exemple choisir f(Di) = 2. (/Di) Ainsi, avec la relation : k On définit finalement un bloc élémentaire commun F(k, s), équivalent aux blocs élémentaires [gamma]0, yl, y2 et tel que R(0, 0) = yO, I-'(1, 1) = yl et H(2, 1) = y2. Pour l'algorithme 1, on peut par exemple choisir : r(k, s) Ro En utilisant la fonction F, l'algorithme 1 peut finalement s'écrire (voir aussi figure 3) : Initialisation : Ro Tant que i > 0 : répéter le bloc élémentaire commun F(k,s) : k Ro Retourner Ro. Algorithme 1 ("Square-And-Multiply") protégé Dans cet algorithme, un seul bloc # est utilisé, quelles que soient les valeurs de Di. Dans le cas où Di = 0, on exécute un seul bloc r. Dans le cas où D1 = 1, on exécute successivement deux fois le bloc r. Quelles que soient les valeurs des pointeurs k, s et quelle que soit la valeur de Di, le bloc # associé est équivalent, vis-à-vis d'une attaque à canal caché, au bloc précédemment exécuté et au bloc exécuté ensuite. En conséquence il n'est pas possible de les distinguer, de savoir à quel bloc d'instructions # correspond un bloc r en cours. A noter que par rapport à l'algorithme 1 non protégé, l'algorithme 1 protégé selon l'invention utilise le même nombre d'instructions de calcul (telles que des instructions de multiplication par exemple) pour aboutir au même résultat final. L'algorithme 1 protégé selon l'invention comprend simplement une étape supplémentaire de mise à jour de pointeurs : une telle étape est beaucoup plus rapide et beaucoup moins consommatrice de ressources qu'un bloc d'instructions de calcul tel qu'un bloc destiné à la réalisation d'une multiplication. En conséquence, le temps d'exécution de l'algorithme protégé est le même que celui de l'algorithme 1 non protégé : Tex = 1.5*M*TO, TO étant le temps d'exécution d'une multiplication. A noter également que le bloc r n'est pas unique pour un même algorithme. D'autres décompositions du bloc d'instructions #0 peuvent être envisagées, par exemple : no = 'y' 0 y' 1 avec y' 0 . Ro Y'1 : Ro Cette décomposition est envisageable dans la mesure où l'instruction fictive i k s (Di = 1) [gamma]'0 : Ro Ro.Ro ; i i-1 0 0 [gamma]'1 : Ro Ro.Ri ; i i-0 1 1 (Di = 0) [gamma]'0 : Ro Ro.Ro ; i i-1 0 1 tableau 1' Le pointeur s devient ici superflu dans la mesure où seules deux blocs élémentaires sont possibles [gamma]'0 et y'1. On obtient finalement le bloc élémentaire commun r' et l'algorithme protégé suivant (voir aussi figure 4) : Initialisation : Ro Tant que i # 0 : répéter le bloc élémentaire commun r'(k,s) . k Ro Retourner Ro. Algorithme "Square-And-Multiply" protégé (2ème version) D'autres algorithmes peuvent également être protégés selon l'invention. L'algorithme d'exponentiation dit "Right-To-Left binary algorithm" (appelé par la suite algorithme 2) par exemple est assez similaire à l'algorithme "Square-And Multiply". Il permet de réaliser une opération de type Y = XDen partant du bit le plus faible de D de la manière suivante : Initialisation . Ro Tant que i # M-1, répéter : Si Di = 1, alors réaliser le bloc #0 : Ro Ri Si Di = 0, alors réaliser le bloc #1 : Ri Retourner Ro . Algorithme 2, dit "Right-To-Left binary algorithm" Les bloc #0, l'Il peuvent par exemple se décomposer de la manière suivante : k s #0 (Di = 1) yO : Ro Ro.Ri ; i i+O 0 0 [gamma]1 : R1 Ri. Ri ; i i+1 1 1 fil (Di = 0) -Y2 R.1 yO, yl sont utilisés pour décomposer Ho, I-11, le pointeur s est donc inutile. On peut par exemple choisir le bloc élémentaire commun r suivant : #(k) : Rk On obtient finalement l'algorithme 2 protégé ci-dessous, où # désigne l'opérateur OU-Exclusif : Initialisation : Ro Tant que i # M-l : répéter le bloc élémentaire commun F(k,s) : k Rk Retourner Ro. Algorithme "Right-To-Left binary algorithm" (algorithme 2) protégé Les exemples ci-dessus décrivent des algorithmes au cours desquels on exécute deux blocs d'instructions #0 ou #1 en fonction d'une variable d'entrée D1. L'invention peut cependant s'appliquer à des algorithmes utilisant plus de deux blocs d'instructions #. Par exemple, si on considère l'algorithme dit "(M, M3) algorithm" (appelé par la suite algorithme 3) : Initialisation : Ro Tant que i 0, répéter : Si Di = 0, réaliser le bloc d'instructions #0 : Ro Si Di = 1 ET (Di-i = 0), réaliser le bloc #1 : Ro Ro Si Di = 1 ET (Di-1 = 1), réaliser le bloc #2 : Ro Ro Ro Retourner Ro. Algorithme dit " (M, M3) algorithm" (algorithme 3) ET est la fonction ET logique. En remplaçant les carrés (Ro)2 par des multiplications R0.R0, et en introduisant des instructions fictives de type i k s Ho (Di = 0) YO : Ro #2 (Di = 1) et (Di-1 = 1) y3 : Ro Ro.Ro ; i i-0 3 0 [gamma]4 : Ro Ro.Ro ; i i-0 4 0 [gamma]5 : Ro Ro.R2 ; i i-2 5 1 tableau 3 Le tableau 3 permet de calculer assez aisément le pointeur k en fonction de s et de Di, et le pointeur s en fonction de k, comme précédemment. Par ailleurs, les blocs [gamma]0 à y5 sont tous équivalents, et on peut par exemple choisir le bloc élémentaire commun r(k, s) suivant : F(k, s) . Ro Ro D-1 k Algorithme dit " (M, M3) algorithm" (algorithme 3) protégé REVENDICATIONS 1. Procédé de calcul cryptographique caractérisé en ce que, pour exécuter un bloc d'instructions choisi (#j) en fonction d'une variable d'entrée (Di) parmi N blocs d'instructions prédéfinis (#1, ..., FIN) , on exécute un nombre prédéfini (Lj) de fois un bloc élémentaire commun (F(k,s)) aux N blocs d'instructions prédéfinis #1, #N),le nombre prédéfini (Lj) étant associé au bloc d'instructions choisi #j). 2. Procédé selon la revendication 1, dans lequel le nombre prédéfini (Lj) est variable d'un bloc d'instructions prédéfini (rll, ..., IIN) à l'autre. 3. Procédé selon l'une des revendications 1 à 2, dans lequel le bloc élémentaire commun (F(k,s)) comprend au moins une instruction de calcul équivalente vis-à-vis d'une attaque à canal caché à une instruction de calcul de chaque bloc prédéfini (111, ..., IIN) . 4. Procédé selon la revendication 3, dans lequel le bloc élémentaire commun (F(k,s)) comprend également une instruction de mise à jour d'un pointeur de boucle (k) indiquant un nombre d'exécutions déjà exécutées du bloc élémentaire commun (r(k,s)). 5. Procédé selon la revendication 3 ou la revendication 4, dans lequel le bloc élémentaire commun (r(k,s)) comprend également une instruction de mise à jour d'un pointeur d'état (s) indiquant si le nombre prédéfini (Lj) a été atteint. 6. Procédé selon la revendication 4 ou la revendication 5, dans lequel la valeur du pointeur de boucle (k) et ou la valeur du pointeur d'état (s) sont fonction de la valeur de la variable d'entrée (Di) et/ ou du nombre d'instructions du bloc d'instructions (Pj) associé à la valeur de donnée d'entrée. 7. Procédé selon l'une des revendications 1 à 6, dans lequel, pour réaliser successivement plusieurs blocs d'instructions choisis parmi les N blocs d'instructions prédéfinis (#1, ..., Fin) en fonction d'une variable d'entrée (Dj) associée à un indice d'entrée (i), on exécute un nombre total (LT) de fois le bloc élémentaire commun (I-' ((k,s)), le nombre total (LT) étant égal à une somme des nombres prédéfinis (Lj) associés à chaque bloc d'instructions choisi (#I). 8. Procédé selon la revendication 7, au cours duquel un même bloc d'instructions peut être choisi plusieurs fois selon la variable d'entrée associée à l'indice d'entrée (i). 9. Procédé selon l'une des revendications 7 ou 8, utilisé dans la mise en #uvre d'un calcul d'exponentiation de type Y = XD, D étant un nombre entier de M bits, chaque bit (Di) correspondant à une variable d'entrée d'indice d'entrée i, le procédé comprenant les étapes suivantes : Initialisation : Ro Tant que i # 0 : répéter le bloc élémentaire F(k,s) : k Ro Retourner Ro. 10. Procédé selon l'une des revendications 7 ou 8, utilisé dans la mise en #uvre d'un calcul d'exponentiation de type Y = XD, D étant un nombre entier de M bits, chaque bit (Di) correspondant à une variable d'entrée d'indice d'entrée i, le procédé comprenant les étapes suivantes : Initialisation : Ro Tant que i 3 0 : répéter le bloc élémentaire commun #(k) : k Ro Retourner Ro. 11. Procédé selon l'une des revendications 7 ou 8, utilisé dans la mise en #uvre d'un calcul d'exponentiation de type Y = XD, D étant un nombre entier de M bits, chaque bit (Di) correspondant à une variable d'entrée d'indice d'entrée i, le procédé comprenant les étapes suivantes : Initialisation : Ro Tant que i Rk Retourner Ro. 12. Procédé selon l'une des revendications 7 ou 8, utilisé dans la mise en #uvre d'un calcul d'exponentiation de type Y = XD, D étant un nombre entier de M bits, chaque bit (Di) correspondant à une variable d'entrée d'indice d'entrée i, le procédé comprenant les étapes suivantes : Initialisation : Ro 0 : répéter le bloc élémentaire commun F(k,s) : k Ro 13. Procédé d'obtention d'un bloc élémentaire commun (F(k,s)) à N blocs d'instructions (rll, ..., TIN) prédéfinis, procédé susceptible d'être utilisé pour la mise en #uvre d'un procédé de calcul cryptographique selon l'une des revendications 1 à 12, le procédé étant caractérisé en ce qu'il comprend les étapes suivantes : El : décomposition de chaque bloc d'instructions prédéfini (FI,, ..., IIN) en une suite de blocs élémentaires (y) équivalents vis-à-vis d'une attaque à canal caché, et classement de l'ensemble des blocs élémentaires, E2 recherche d'un bloc élémentaire commun (F(k,s)) équivalents à tous les blocs élémentaires (y) de tous les blocs d'instructions prédéfinis, le bloc élémentaire commun comprenant au moins un bloc élémentaire précédemment obtenu et une instruction de mise à jour d'un pointeur de boucle (k) tel que une exécution du bloc élémentaire commun associée à la valeur du pointeur de boucle (k) et une exécution du bloc élémentaire de rang égal à la valeur du pointeur de boucle (k) soient identiques. 14. Procédé selon la revendication 13, caractérisé en ce que au cours de l'étape El, on ajoute au moins une instruction fictive à au moins un bloc d'instructions prédéfini.