4.3.1 Introduction
Peu de temps après la publication des attaques par mesure de la consomma-tion d’énergie par Kocher, Chari et al. [12] se sont penchés sur la quesconsomma-tion des mesures. Leur objectif était de trouver, théoriquement, une contre-mesure générique aux attaques de contre-mesure d’énergie.
En s’inspirant des méthodes de partage de secret (secret sharing), leur pro-position est de diviser chaque bit sensible (clé ou message) en k shares in-dépendants, de sorte que k − 1 shares ne suffisent pas à retrouver la valeur initiale du bit divisé. Ainsi, un bit b sera encodé comme les k shares suivants : b ⊕ r1, r2, . . . , rk−1, r1⊕ · · · ⊕ rk−1, où les risont des bits aléatoirement choisis. Finalement, afin de rendre leur schéma pratique, les auteurs proposent de l’appliquer au niveau du byte plutôt qu’au niveau du bit. On voit apparaitre, avec ce schéma, la première proposition d’un schéma de type masking géné-rique (car non appliqué à un algorithme en particulier). Notons qu’il n’est pas nécessaire d’exécuter sur chaque share l’algorithme initial, mais qu’une mo-dification (modifier une SBox pour tenir compte du masque par exemple) de celui-ci, tenant compte du ou des masques, peut s’avérer tout aussi judicieuse. Bien que s’agissant d’une première proposition de contre-mesure, un point en particulier mérite une attention spéciale : le schéma semble adapté pour les opérations linéaires, où l’exécution des instructions sur les différents shares, et leur réunification par la suite, ne devrait pas poser de problème. En
re-vanche, pour des opérations non-linéaires, on ne peut se contenter d’exécuter séparément les instructions et de réunir les shares ensuite : l’exécution sur les différentes parties et leur réunification ne permettent pas de retrouver le ré-sultat espéré.
Voyons à présent des exemples concrets de contre-mesures de type masking, appliquées à l’algorithme d’AES. Les exemples que nous allons voir ne re-présentent pas l’entièreté des mesures possibles. Il s’agit des contre-mesures algorithmiques. D’autres types de contre-contre-mesures existent et s’ap-pliquent à l’aspect matériel plutôt qu’au logiciel de l’implantation. Citons, à titre d’exemple et sans rentrer dans les détails, les « implantations à seuil » (threshold implementations en anglais) de Nikova et al. [55] qui, bien que de-mandant des calculs plus complexes que les contre-mesures que nous allons voir dans la suite, lors de l’initialisation, ne requièrent pas de nouvelles va-leurs aléatoires au cours de l’exécution. Citons égalemment les « circuits pri-vés » (private circuits en anglais) de Ishai et al. [30] dont le but est de rendre une implantation sécurisée même si l’attaquant peut observer jusqu’à un cer-tain nombre de bits produits pendant l’exécution. Enfin, citons le travail de Maghrebi et al. [44] qui vise à balancer la consommation d’énergie pour des implantations matérielles masquées et rendre ainsi l’activité liée à la valeur masquée et celle liée au masque indépendantes l’une de l’autre.
4.3.2 Application à AES - État de l’art
Nous l’avons déjà mentionné, il existe différentes façons d’appliquer un masque aux données. Nous avons déjà vu, à la section précédente, une façon d’ap-pliquer des masques booléens en divisant les données sensibles en k shares. Nous allons à présent étudier d’autres possibilités de masking en utilisant l’al-gorithme d’AES comme support à son application.
Masking booléen
Thomas Messerges [50] a étudié séparément le masking pour chaque type d’opération constituant les candidats au concours d’AES. En ce qui concerne le vainqueur du concours, Rijndael, il a identifié quatre types d’opérations : – La consultation de table (Table-Lookup en anglais) pour l’opération
sub-Bytes. L’opération subBytes correspond à une inversion dans GF (28), suivie d’une transformation affine, mais pour des raisons de performance, elle est très souvent implantée sous forme de table (matrice 16 × 16 ou vecteur de 256 éléments).
– Les opérations booléennes bit à bit pour l’opération d’addRoundKey. – Les rotations circulaires pour l’opération de shiftRows.
– La multiplication dans GF (28)pour l’opération de mixColumns.
La consultation de table pour l’opération de subBytes peut facilement tenir compte d’entrées masquées, à condition de calculer une nouvelle table pour chaque masque utilisé. Pour une implantation non masquée, la SBox S d’AES renvoie, pour une entrée x (0 ≤ x ≤ 255), une sortie y (0 ≤ y ≤ 255) en suivant le principe d’inversion dans GF (28), suivi d’une transformation af-fine : S(x) = y. La version masquée correspondante utilisera deux masques (le masque d’entrée min et le masque de sortie mout) comme paramètres sup-plémentaires et associera à l’entrée masquée xmin la sortie masquée ymout à l’aide d’une SBox modifiée Smin,mout : Smin,mout(xmin) = ymout.
La seule opération booléenne d’AES est le XOR. Celui-ci ne rencontre aucune difficulté à manipuler des données masquées. La valeur obtenue, en combi-nant deux valeurs masquées, sera masquée par le XOR des deux masques : xm1 ⊕ ym2 = (x ⊕ y)m1⊕m2. Si m1et m2sont identiques, la sortie ne sera plus masquée.
Les rotations circulaires d’AES ne posent aucun problème à la manipulation de valeurs masquées : les valeurs masquées sont manipulées de la même façon que si elles ne l’étaient pas et le masque qui leur est appliqué les suit dans ce déplacement circulaire.
La multiplication dans GF (28), correspondant à l’opération mixColumns, peut être facilement réalisée à l’aide de consultations de tables et de « ou-exclusifs », auquel cas, la manipulation de valeurs masquées revient à ce qui a déjà été mentionné précédemment. Notons que pour mixColumns, il n’est même pas besoin de toucher aux tables utilisées, car l’on peut considérer que les valeurs sont masquées à l’aide de nouveaux masques résultant de l’application de mix-Columns sur les masques en entrée.
Les masques booléens sont moins adaptés aux opérations arithmétiques, comme les additions et les multiplications modulaires pour lesquelles il est conseillé [50] d’utiliser des masques arithmétiques. L’application d’un masque arith-métique, pour des valeurs de 32 bits, peut être de la forme : xm = (x − m) mod 232. Dans ce cas, lors d’opérations d’additions et de multiplications mo-dulaires impliquant deux valeurs masquées, les résultats seront masqués de la sorte :
– zm3 = (xm1+ ym2) mod 232où m3 = (m1+ m2) mod 232.
– zm3 = (xm1 × ym2) mod 232où m3 = (m1× ym2 + m2× xm1 + m1× m2) mod 232.
Voyons à présent quelques schémas de masking sur AES, présents dans la lit-térature.
Tillich, Herbst et Mangard et Herbst, Oswald et Mangard
Le schéma de masking pour AES proposé par Herbst, Oswald et Mangard pour des architectures 8 bits [27] et par Tillich, Herbst et Mangard pour des archi-tectures 32 bits [68], que l’on retrouve également dans [45], est le premier schéma de masking de type booléen pour AES, que nous allons présenter en détails dans ce travail. Bien que les articles [27] et [68] présentent le schéma de masking en association avec une contre-mesure de type hiding, nous nous contenterons ici de présenter uniquement la partie masking du schéma. Au début de l’exécution, six masques aléatoires de 8 bits sont générés : m, m0, m1, m2, m3, m4. Les masques m et m0 correspondent respectivement au masque d’entrée de l’opération subBytes et au masque de sortie de l’opéra-tion subBytes. Les quatre autres masques correspondent aux masques d’entrée de l’opération mixColumns. Ensuite, une SBox masquée S0 est calculée où S0(x ⊕ m) = S(x) ⊕ m0 et quatre masques m0
1, m0 2, m0
3, m0
4 sont dérivés des masques m1, m2, m3, m4 où (m01, m20, m03, m04) = mixColumns(m1, m2, m3, m4).
Avant de commencer le chiffrement, chaque byte de chaque clé de tour est masqué à l’aide du même masque m. De plus, chaque byte de la première ligne de chaque clé de tour et de la matrice STATE est masqué par m1, chaque byte de la deuxième ligne de chaque clé de tour et de STATE est masqué par m2, chaque byte de la troisième ligne de chaque clé de tour et de STATE est masqué par m3et finalement chaque byte de la quatrième ligne de chaque clé de tour et de STATE est masqué par m4. Le schéma est construit de telle sorte que, à chaque début de tour, STATE soit masquée par m1, m2, m3, m4. Une opération de remasking est également prévue entre shiftRows et mixColumns. Elle a pour but de remplacer les masques appliqués à STATE en modifiant ceux-ci de m0 à m1, m2, m3, m4, afin de se retrouver dans la même situation (mêmes masques appliqués aux mêmes bytes de STATE) au début de chaque tour. Cette opération de remasking, doit faire attention à l’ordre des opéra-tions : il faut, dans un premier temps, ajouter les masques m1, m2, m3 et m4
avant de retirer le masque m0, pour éviter que STATE soit temporairement non masquée. La figure 4.5 résume l’application des masques pour STATE et la clé de tour.
Ce schéma présente l’avantage de très peu modifier l’algorithme original d’AES. L’opération de subBytes doit être modifiée pour utiliser la SBox masquée en lieu et place de la SBox originale. Les trois autres opérations ne nécessitent
aucune modification. Enfin, comme déjà mentionné, une opération de
remas-king doit être ajoutée avant chaque opération de mixColumns.
Les auteurs ont comparé les temps d’exécution du schéma sur un micro-con-trolleur 8 bits de leur schéma de masking et d’un AES non masqué. L’exécution de l’AES masqué requiert deux fois plus de cycles d’horloges que la version non protégée. Ce ralentissement s’explique, en grande partie, par le temps de préparation nécessaire : calcul de la SBox masquée, calcul des masques dérivés (m01, m02, m03, m04)... Les auteurs ont également remarqué que ne pas masquer les six tours au milieu de l’exécution (tours 3 à 8) offrait un gain de temps d’à peine 5 %, démontrant que le gain obtenu en agissant de la sorte est assez faible (et indiquant que la préparation de la contre-mesure est une cause importante du surcoût observé). Enfin, notons un inconvénient à ce schéma, discuté dans [24] et [58] : l’utilisation du même masque pour tous les bytes, au moment du subBytes (entre autres), n’est pas conseillée, car cela permet de réaliser une attaque DPA de second ordre en combinant deux valeurs masquées, afin d’éliminer le masque : (d1⊕ m) ⊕ (d2⊕ m) = (d1⊕ d2).
Rivain et Prouff
Le schéma de masking proposé par Rivain et Prouff se veut, avant tout, un schéma générique de masking appliqué à AES et pouvant gérer un nombre indéfini de masques pour une même donnée sensible [59]. Dans ce schéma, chaque donnée sensible va être séparée en plusieurs shares de telle sorte que l’entièreté de ces shares est requise pour reconstituer la donnée sensible. L’opé-ration de XOR va être utilisée pour diviser les données sensibles en d + 1
shares : x = x0⊕ x1⊕ · · · ⊕ xdouL
ixi = x.
Comme pour les précédentes contre-mesures de masking présentées, la partie non-linéaire de l’exécution est la plus compliquée à gérer. La version modifiée de subBytes proposée par les auteurs, nommée SecSbox, requiert plusieurs al-gorithmes : un algorithme6 pour réaliser la multiplication de deux nombres (SecMult, algorithme 6), un algorithme pour calculer l’exponentiation à la puissance 254 d’un nombre (c’est-à-dire calculer son inverse, SecEXP 254, al-gorithme 8) et un alal-gorithme pour rafraichir les masques dont le but est de garantir l’indépendance des masques lors de l’opération de multiplication Sec-Mult (RefreshMasks, algorithme 7).
A l’aide de ces trois algorithmes, il est, dès lors, possible de réaliser l’opération de subBytes adapté aux d shares (algorithme 9). On commence par calculer l’inverse du nombre x, reçu en paramètre sous forme de shares. Cette inver-sion est une succesinver-sion d’appels à la fonction de multiplication et de mise au carré. Comme nous sommes dans un champ de caractéristique 2, la mise au carré est une opération linéaire7et nous avons donc : x2
0⊕ x2
1⊕ · · · ⊕ x2 d= x2. Les opérations de mise au carré (ainsi que les opérations de mise en exposant 4 et 16) peuvent se réaliser à l’aide de tables prédéfinies. Après l’inversion des shares de x, nous appliquons la transformation affine sur chaque share séparément. Enfin, si le nombre de shares est impair, la constante 0x63 est ajoutée au premier share (partie additive de la transformation affine). Il s’agit de la constante additive dans l’opération de subBytes. Avec un nombre pair de
shares, il n’est pas nécessaire de l’ajouter, car ajouter cette valeur un nombre
pair de fois revient à ne pas l’ajouter.
Dans [59], les auteurs prouvent que le schéma de multiplication (inspiré de [31]), qui est la clé de voûte du schéma proposé, est sécurisé contre des at-taques d’ordre d. Les auteurs démontrent également la sécurité du schéma complet. Finalement, les auteurs montrent que leur schéma est considéra-blement plus lent (entre 2 à 13 fois plus lent que les techniques auxquelles 6. Dans les algorithmes de cette section, la fonction rand(n) renvoie une valeur aléatoire de n bits.
ils se comparent) quand un seul masque est utilisé (en rapport à d’autres contre-mesures d’ordre un), mais que à partir de deux masques, leur schéma se montre très compétitif (deux à trois fois plus rapide) vis-à-vis des contre-mesures d’ordre identique...
Définition 8 Une contre-mesure d’ordre n est une contre-mesure qui vise à rendre
impossible une attaque d’ordre n et qui oblige l’attaquant à procédér à une at-taque d’ordre n + 1 au moins.
Pour les autres opérations d’AES, nous avons les relations suivantes : – AddRoundKey : s ⊕ kr = (s0⊕ kr 0) ⊕ (s1⊕ kr 1) ⊕ · · · ⊕ (sd⊕ kr d), – ShiftRows : ShiftRows(s) =Ld i=0ShiftRows(si), – MixColumns : MixColumns(s) =Ld i=0MixColumns(si). Algorithme 6 SecMult - Multiplication dans F2n
Require: shares ai qui satisfontL
iai = a, shares bi qui satisfontL
ibi = b Ensure: shares ci qui satisfontL
ici= ab for i = 0 to d do for j = i+1 to d do ri,j ← rand(n) rj,i← (ri,j⊕ aibj) ⊕ ajbi end for end for for i = 0 to d do ci ← aibi for j = 0 to d, j 6= i do ci← ci⊕ ri,j end for end for Algorithme 7 RefreshMasks Require: shares xiqui satisfontL
ixi= x Ensure: shares xi qui satisfontL
ixi = x for i = 0 to d do tmp ←rand(8) (x0 ← x0⊕ tmp) (xi ← xi⊕ tmp) end for
Algorithme 8 SecEXP254 - Exponentiation à la puissance 254 dans F2n
Require: shares xiqui satisfontL
ixi= x Ensure: shares yi qui satisfontL
iyi= x254 for i = 0 to d do zi← x2 i /* {L izi= x2} */ end for RefreshMasks(z0, z1, . . . , zd) (y0, y1, . . . , yd) ←SecMult((z0, z1, . . . , zd), (x0, x1, . . . , xd)) /* {L iyi = x3} */ for i = 0 to d do wi ← y4 i /* {L iwi= x12} */ end for RefreshMasks(w0, w1, . . . , wd) (y0, y1, . . . , yd) ←SecMult((y0, y1, . . . , yd), (w0, w1, . . . , wd)) /* {L iyi = x15} */ for i = 0 to d do yi ← y16 i /* {L iyi= x240} */ end for (y0, y1, . . . , yd) ←SecMult((y0, y1, . . . , yd), (w0, w1, . . . , wd)) /*{L iyi= x252} */ (y0, y1, . . . , yd) ←SecMult((y0, y1, . . . , yd), (z0, z1, . . . , zd)) /* {L iyi= x254} */ Algorithme 9 SecSbox
Require: shares xiqui satisfontL
ixi= x Ensure: shares yi qui satisfontL
iyi= S(x) (y0, y1, . . . , yd) ←SecExp254(x0, x1, . . . , xd) for i = 0 to d do yi ← Af(yi) end for if d mod 2 = 1 then y0 ← y0⊕ 0x63 end if
Algorithme 10 KeyExpansion Require: shares ki qui satisfontL
iki = k Ensure: shares wiqui satisfontL
iwi = w for j = 1 to Nkdo for i = 0 to d do (wi)∗,j ← (ki)∗,j end for end for for j = N k + 1 to 4(N r + 1) do for i = 0 to d do ti ← (wi)∗,j−1 end for
if ((j mod Nk= 0) or (Nk = 8) and (j mod Nk = 4))then for l = 1 to 4 do ((t0)l, (t1)l, . . . , (td)l) ←SecSbox((s0)l, (t1)l, . . . , (td)l) end for end if if (j mod Nk= 0)then for i = 0 to d do ti← RotWord(ti) end for t0 ← t0⊕ Rconj/N k end if for i = 0 to d do (wi)∗,j−1← (wi)∗,j−Nk ⊕ ti end for end for
Algorithme 11 AES masqué
Require: texte clair p, shares kiqui satisfontL
iki= kpour la clé Ensure: texte chiffré c
s0← p for i = 0 to d do si ← rand(16 × 8) s0 ← s0⊕ si end for for r = 1 to N r − 1 do for i = 0 to d do si ← si⊕ kr i end for for l = 1 to 4 do for j = 1 to 4 do ((s0)l,j, (s1)l,j, . . . , (sd)l,j) ←SecSbox((s0)l,j, (s1)l,j, . . . , (sd)l,j) end for end for for i = 0 to d do si ← MixColumns(ShiftRows(si)) end for end for for i = 0 to d do si ← si⊕ kN r i end for for l = 1 to 4 do for j = 1 to 4 do ((s0)l,j, (s1)l,j, . . . , (sd)l,j) ←SecSbox((s0)l,j, (s1)l,j, . . . , (sd)l,j) end for end for for i = 0 to d do si ← ShiftRows(si) end for for i = 0 to d do si ← si⊕ kN r+1i end for c ← s0 for i = 1 to d do c ← c ⊕ si end for
Nassar, Souissi, Guilley et Danger
Nassar, Souissi, Guilley et Danger ont proposé un schéma de masking, prin-cipalement destiné pour des implantations hardware [54], appelé RSM (pour
Rotating SBoxes Masking). La raison de ceci est, qu’en hardware, le surcoût
de la contre-mesure se révèle plus petit qu’en software. En effet, ce schéma nécessite 16 masques différents de 8 bits fixes, c’est-à-dire que les masques ne changent pas d’une exécution à l’autre et sont pré-calculés avant une quel-conque exécution. Pour chacun de ces masques, une SBox masquée doit donc être également pré-calculée et stockée en mémoire (ROM). Ces 16 SBoxes, pré-calculées et stockées en ROM, ne présentent pas un surcoût pour une im-plantation hardware par rapport à une version non protégée, car celle-ci utilise déjà 16 SBoxes identiques (pour permettre l’exécution de l’algorithme en pa-rallèle sur tous les bytes).
Initialement, et avant même la programmation de l’appareil, 16 masques de 8 bits m0−15vont être choisis une fois pour toutes et seront donc utilisés tout au long de la contre-mesure. Ensuite, 16 SBoxes masquées Sj0(x)(0 ≤ j ≤ 15) vont être calculées en respectant la structure suivante : Sj0(x ⊕ mj) = S(x) ⊕ m(j+1)( mod 16), avec 0 ≤ j ≤ 15, S la SBox non masquée, S’ une SBox mas-quée. En d’autres mots, la donnée est masquée avec un masque mj en entrée et, une fois l’opération de subBytes réalisée, cette même donnée est masquée à l’aide du masque suivant : m(j+1)(mod16). Enfin, à chaque tour, les SBoxes sont décalées d’une position.
Afin de masquer la partie linéaire d’AES avec les masques mj (0 ≤ j ≤ 15) choisis, cinq ensembles de 16 éléments de 128 bits doivent également être calculés :
– le premier ensemble M0−15 contient tous les différents Mj possibles, avec Mj = mj, m(j+1)( mod 16), . . . , m(j+15)( mod 16), ∀j ∈ [0 - 15], représentant chaque décalage possible de l’ensemble initial des masques,
– le deuxième ensemble M M S0−15contient les différents M M Sj, avec M M Sj = mixColumns(shif tRows(Mj)) ⊕ Mj , ∀j ∈ [0 - 15], – le troisième ensemble M S0−15contient, quant à lui, les M Sj, avec
M Sj = shif tRows(Mj), ∀j ∈ [0 - 15],
– les deux derniers ensembles IM M S0−15 et IM S0−15 sont construits de la même façon que les ensembles M M S0−15et M S0−15, mais à l’aide des fonc-tions inverses.
Algorithme 12 RSM pour AES 256 bits
Require: texte clair X, composé de 16 bytes Xi (i ∈ [0, 15]), 15 Clés de tour Kr(r ∈ [0, 14])
Ensure: texte chiffré X, composé de 16 bytes Xi (i ∈ [0, 15]) choisir aléatoirement j dans [0, 15]
X = X ⊕ Mj for r = 0 to 12 do X = X ⊕ Kr for i = 0 to 15 do Xi = Sj+i+r0 (Xi) end for X = Shif tRows(X) X = M ixColumns(X) X = X ⊕ M M Sj+1+r end for X = X ⊕ K13 for i = 0 to 15 do Xi= Sj+i+130 (Xi) end for X = Shif tRows(X) X = X ⊕ K14 X = X ⊕ M Sj+14
La figure 4.6 et l’algorithme 12 illustrent8l’exécution de l’algorithme AES avec la contre-mesure RSM. Finalement, la sécurité de la contre-mesure revient à trouver le décalage initial choisi pour l’utilisation des masques, ce qui donne 16 possibilités différentes. Les auteurs indiquent que cette contre-mesure est effective contre des attaques de premier ordre et contre certaines attaques de deuxième ordre, tout en imposant un surcoût raisonnable au niveau hardware [54].
FIGURE4.6 – AES avec RSM Texte Clair : X STATE : X Mj SubBytes Masqué ShiftRows MixColumns Texte Chiffré : X Mj MMSj+1 MSj+1 K K K Dernier Tour
D’autres types de masking ont été proposés dans la littérature : le masking multiplicatif et le masking affin, que nous allons brièvement introduire à pré-sent, afin de compléter l’état de l’art des types de masking9.
Masking multiplicatif
Présenté pour la première fois par Akkar et Giraud [3], le schéma de masking multiplicatif est utilisé lors de l’étape d’inversion dans GF(256) durant l’opé-ration de subBytes. L’objectif des auteurs est d’obtenir Di,j−1⊕ mi,j à partir de Di,j ⊕ mi,j, sans dévoiler la valeur Di,j. Nous avons vu précédemment qu’il était possible de réaliser l’opération de subBytes à l’aide d’une matrice, SBox, et que, dans le cas de valeurs masquées, il fallait calculer une SBox modi-fiée, au début de l’exécution, en tenant compte du masque utilisé. Si un seul masque est utilisé, une seule SBox modifiée doit être calculée, mais si l’on dé-cide que chaque byte de STATE sera masqué à l’aide d’un masque différent, 16 SBoxes doivent être calculées et il faut stocker 16×256 bytes10en mémoire au lieu de 256 bytes. Dans certains contextes, la place en mémoire est fortement limitée et ce genre de surcoût ne peut être autorisé. Dés lors, une méthode permettant de se passer du calcul et du stockage de ces SBoxes est la bienve-nue.
Cette méthode, issue de [3], est présentée aux figures 4.7, 4.8 et 4.9. La figure 4.7 illustre la différence, pour l’opération de subBytes, entre une version non-protégée d’AES (partie supérieure) et le schéma proposé par les auteurs (partie inférieure). L’inversion modifiée de la figure 4.7 est détaillée à la figure 4.8, où l’on observe que la valeur en entrée est déjà masquée additivement (par Mi,j). Cette valeur est ensuite masquée multiplicativement (par Yi,j). Le masque Mi,j est alors retiré pour ne laisser que le masque multiplicatif lors du calcul de l’inverse dans GF (28). Le masque Mi,j est finalement ajouté conjointement à la suppression du masque multiplicatif. Au final, la valeur de sortie possède le même masque qu’au début de l’étape. La figure 4.9 compare un tour d’AES normal (partie de gauche) à un tour protégé (partie de droite).
9. Même si ces types de masking n’ont pas été utilisés lors de nos travaux. 10. Chaque SBox a une taille de 256 bytes.
FIGURE4.7 – SubBytes
Xi,j Inversion dans GF(28)
Transformation affine f (Xi,j)-1 (Xi,j)' Inversion modifiée dans GF(28) Transformation affine f
Xi,j Mi,j (Xi,j)-1 Mi,j
(Xi,j)' M1i,j
FIGURE4.8 – Inversion modifiée dans GF (28)
Xi,j Mi,j
Yi,j (Xi,j Mi,j) Yi,j
Xi,j Yi,j Mi,j Yi,j Mi,j Yi,j Inversion dans GF(28) (Xi,j Yi,j)-1 Mi,j (Yi,j)-1 Mi,j Yi,j Inversion dans GF(28)
((Xi,j Yi,j)-1) (Mi,j (Yi,j)-1) Yi,j (Xi,j)-1 Mi,j
FIGURE4.9 – Round d’AES X X' X'' X''' X'''' subBytes shiftRows mixColumns Ki X M X' M1 X'' M2 X''' M3 X'''' M subBytes shiftRows mixColumns Ki M M3
Chaque appel à une SBox masquée est dorénavant remplacé par 2 XORs, 4 multiplications et 2 inversions dans GF (28).
Dans ces figures, nous avons :
– M, le masque booléen appliqué à STATE (sous forme de matrice 4x4), – Y, le masque multiplicatif,
– M 1 = f1(M ), où f1 est la partie linéaire de la transformation affine f de