Mise en œuvre exp´ erimentale

Nous d´ecrivons dans ce chapitre et le suivant deux attaques par fautes qui peuvent

s’appli-quer `a des algorithmes cryptographiques dont les sp´ecifications ne sont pas connues. Malgr´e cette

ignorance, ces attaques permettent de retrouver la cl´e secr`ete utilis´ee. N´eanmoins, et

contrai-rement au chapitre pr´ec´edent, ces attaques n’ont pas pour objectif, et ne permettent pas, de

retrouver de l’information sur les d´etails fonctionnels de l’algorithme. Apr`es avoir retrouv´e la

cl´e, l’attaquant n’en sait pas plus au sujet des sp´ecifications de l’algorithme qu’auparavant.

12.1 Deux techniques d’analyses de fautes

Les premi`eres attaques par fautes, c’est-`a-dire exploitant des erreurs lors d’un calcul

cryp-tographique, furent invent´ees et publi´ees il y a une dizaine d’ann´ee par_{Dan Boneh},_Richard

DeMillo et _{Richard Lipton} [BDL97] dans le cas du

RSA

, et par _{Eli Biham} et _Adi

Sha-mir [BS97] dans le cas du

DES

. Ces attaques sont appel´ees analyses diff´erentielles de fautes

(

DFA

), car elles exploitent une diff´erence observ´ee sur les sorties de l’algorithme. Pour un mˆeme

message d’entr´eeM, la fonction est ´evalu´ee une premi`ere fois sans perturber le d´eroulement du

calcul pour donner le chiffr´e de r´ef´erence C, puis ex´ecut´ee `a nouveau en injectant cette fois-ci

une faute dont il r´esulte le chiffr´e faut´e C

⁰

. C’est de la diff´erence entre C et C

⁰

que l’attaquant

est capable de d´eduire de l’information sur la cl´e K. Le principe de la

DFA

est illustr´e `a la

Figure12.1.

Plutˆot que d’obtenir de l’information sur la cl´e `a partir de la diff´erence produite en sortie

par le chiffrement de la mˆeme entr´ee, il est possible de consid´erer le cas inverse dans lequel

on chiffre deux entr´ees diff´erentes M et M

^∗

, et on apprend de l’information sur la cl´e par

l’observation “rare” que les chiffr´es deM etM

^∗

, l’un faut´e, l’autre non, co¨ıncident. C’est parce

que l’attaquant essaie de provoquer une collision entre ces deux chiffr´es que cette technique est

Chapitre 12. G´en´eralisation d’une analyse de fautes par collisions sur l’AES

Fig.12.1 – Principe de l’analyse diff´erentielle de fautes.

Fig. 12.2 – Principe de l’analyse de fautes par collisions.

appel´eeanalyse de fautes par collisions(

CFA

). Parmi les premi`eres attaques par

CFA

publi´ees, on

peut citer celle de _{Ludger Hemme}sur les premiers tours de

DES

[Hem04]. On peut ´egalement

mentionner l’attaque de_{Johannes Bl¨omer}et_{Jean-Pierre Seifert}sur l’AddRoundKeyinitial

de l’

AES

[BS03], quoique celle-ci puisse aussi ˆetre consid´er´ee comme une analyse de fautes sans

effet (

IFA

).

Dans la pratique, un analyse de fautes par collisions est souvent men´ee en commen¸cant par

obtenir le chiffr´e faut´e C

^∗

correspondant `a une entr´ee M, puis en recherchant un message M

^∗

qui donne naturellement le mˆeme chiffr´eC

^∗

. Le principe de la

CFA

est illustr´e `a la Figure12.2.

Notons une certaine dualit´e entre l’analyse diff´erentielle de fautes et l’analyse de fautes

par collisions. La

DFA

utilise des entr´ees identiques et produit des sorties diff´erentes, alors que

la

CFA

observe au contraire une ´egalit´e des chiffr´es pour des messages diff´erents. ´Egalement,

la

DFA

exploite les sorties sans se pr´eoccuper de la valeur de l’entr´ee, alors que pour la

CFA

,

l’information retir´ee sur la cl´e est g´en´eralement li´ee `a la valeur du message M

^∗

provoquant la

collision. Enfin, pour les algorithmes sym´etriques, la faute doit ˆetre inject´ee vers la fin de la

fonction de chiffrement dans le cas de la

DFA

, alors qu’une collision ne pourra gu`ere ˆetre obtenue

qu’en visant le ou les premiers tours.

De mani`ere moins syst´ematique, cette dualit´e peut se prolonger jusqu’au mod`ele de faute.

L’analyse diff´erentielle pourra souvent s’accommoder d’une faute localis´ee de mani`ere impr´ecise,

et dont l’effet peut ˆetre al´eatoire, alors que pour provoquer une collision, il est g´en´eralement

n´ecessaire de cibler pr´ecis´ement un type d’instruction sp´ecifique, tout en requ´erant un mod`ele

de faute plus exigeant.

12.2. Une analyse de fautes par collisions sur l’AES

Fig.12.3 – Le mod`ele de faute sur l’instruction XOR.

12.2 Une analyse de fautes par collisions sur l’AES

Nous pr´esentons dans cette section une analyse de fautes par collisions sur l’

AES

. Cette

attaque a d´ej`a ´et´e consid´er´ee `a la Section10.2 du Chapitre10, et nous allons la d´ecrire ici plus

en d´etails.

Nous supposons qu’un attaquant dispose d’une carte `a puce contenant une cl´e secr`eteK =

(k

0

, . . . , k

15

) et une impl´ementation logicielle de l’

AES

. Cet attaquant est capable d’obtenir les

chiffr´esC=

AES_K

(M) pour autant de messagesM = (m

₀

, . . . , m

₁₅

) de son choix qu’il le d´esire.

Nous supposons ´egalement qu’il est capable de provoquer des erreurs de calcul de l’

AES

. Le

mod`ele de faute que nous consid´erons pr´evoit que lorsqu’un stress est appliqu´e pendant que le

micro-processeur ex´ecute une instruction XOR, une faute est produite dont l’effet est de rendre

nul le r´esultat de cette op´eration, et cela, quelles que soient les valeurs des op´erandes d’entr´ee.

Une illustration de ce mod`ele de faute est propos´ee `a la Figure 12.3.

Une fa¸con simple d’exploiter ce mod`ele de faute consiste `a obtenir le chiffr´e d’un message

M quelconque tout en provoquant une faute sur l’une des 16 instructions XOR de la fonction

initiale AddRoundKey de l’

AES

. Pour l’octet d’indice icorrespondant `a la position du XOR qui

a ´et´e vis´e, l’ex´ecution de l’

AES

se poursuit `a la suite du XOR, avec la valeur 0 plutˆot qu’avec

la donn´ee normale m

_i

⊕k

_i

. C’est pr´ecis´ement cette valeur nulle qui sera utilis´ee en entr´ee de la

fonctionSubBytesdu premier tour, plutˆot que la valeur normale.

La faute n’ayant d’effet que sur l’instruction XOR cibl´ee, il sera possible d’obtenir la mˆeme

valeur du chiffr´e sans faire de faute, en modifiant le message uniquement `a la position i, et en y

recherchant la valeurm

^∗_i

induisant une sortie naturelle du XOR ´egale `a 0. Cette valeur m

^∗_i

est

`

a rechercher exhaustivement parmi les 256 possibilit´es, et est pr´ecis´ement ´egale `a k

i

puisqu’elle

doit v´erifier m

^∗_i

⊕k

i

= 0. Un octet de la cl´e est ainsi r´ev´el´e, et il suffit de reconduire cette

attaque successivement aux 16 positions, pour obtenir la valeur compl`ete de K. Dans le cas

d’une impl´ementation non prot´eg´ee, cette attaque est donc de faible complexit´e puisqu’elle ne

n´ecessite que 16 injections de fautes, et 2

¹²

chiffrements normaux `a effectuer sur le dispositif

attaqu´e.

Remarquons que dans l’

AES

, chacun des octets de message n’est impliqu´e que dans le

AddRoundKey initial. C’est ce qui permet de reproduire un chiffr´e ´egal au chiffr´e faut´e en

re-produisant simplement une valeur identique `a la sortie du XOR. Si le message avait ´egalement

´et´e utilis´e ailleurs dans l’algorithme, alors la collision locale au niveau du XOR ne se serait pas

propag´ee jusqu’`a la sortie de la fonction.

Examinons maintenant le cas o`u l’

AES

attaqu´e impl´emente la contre-mesure simple qui

consiste `a rendre al´eatoire l’ordre dans lequel sont consid´er´es les couples (m

i

, k

i

) dans la

fonc-Chapitre 12. G´en´eralisation d’une analyse de fautes par collisions sur l’AES

Tab.12.1 – Complexit´e d’une

CFA

sur l’

AES

dans le cas d’une impl´ementation en ordre al´eatoire.

Nombre Nombre moyen Probabilit´e d’une complexit´e au plus Taille moyenne

de fautes d’octets connus 2

²⁴

2

³²

2

⁴⁰

de l’espace de cl´e

5 4,4 0, 0, 0, 2

^105,0

10 7,6 0, 0, 0, 2

^90,0

15 9,9 0,015 0,095 0,319 2

^78,1

20 11,6 0,239 0,535 0,809 2

^68,0

25 12,8 0,609 0,858 0,968 2

^59,3

30 13,7 0,851 0,968 0,996 2

^51,7

35 14,3 0,953 0,994 1,000 2

^45,1

40 14,8 0,987 0,999 1,000 2

^39,2

tion AddRoundKey. Cette fois-ci, lorsqu’il provoque une faute sur l’un des XOR, l’attaquant ne

connaˆıt pas la valeur de i qui lui correspond. Il lui faudra donc rechercher le message parmi

l’ensemble de tous ceux qui ne diff`erent du message initial que d’octet dont la position n’est pas

sp´ecifi´ee. L’attaquant peut donc commencer par ´etablir un dictionnaire contenant cette liste de

2

¹²

chiffr´es. `A chaque fois qu’il injecte une faute sur l’un des XOR, il recherche quelle valeur du

dictionnaire est ´egale `a celle du chiffr´e faut´e observ´e. Le message qui correspond `a cette entr´ee

dans le dictionnaire permet `a l’attaquant d’apprendre quelle valeur de i ´etait utilis´ee lors de

la faute, et de retrouver l’octet de cl´e k

_i

correspondant. Pour obtenir la cl´e compl`ete, il suffit

alors de r´ep´eter cette op´eration autant de fois qu’il est n´ecessaire pour que le nombre d’octets de

cl´e connus, c’est-`a-dire le nombre d’indicesi couverts, soit suffisant pour pouvoir entreprendre

une recherche exhaustive des octets inconnus de la cl´e. La Table 12.1 pr´esente, en fonction du

nombre de fautes inject´ees, le nombre moyen d’octets de cl´e r´ev´el´es, les probabilit´es pour que la

complexit´e de la recherche exhaustive finale soit respectivement de 2

²⁴

, 2

³²

ou 2

⁴⁰

cl´es, ainsi que

la taille moyenne de cet espace de recherche. Pour 40 fautes inject´ees, l’espace de recherche est de

taille moyenne 2

39,2

cl´es, mais sera plus petit que 2

24

dans presque tous les cas. Avec seulement

20 fautes, la recherche exhaustive sera de complexit´e moyenne ´egale `a 2

⁶⁸

, mais inf´erieure ou

´

egale `a 2

³²

plus d’une fois sur deux.

Il nous semble int´eressant de remarquer que les donn´ees de complexit´e pr´esent´ees ici

consti-tuent un bel exemple de ce que la complexit´e moyenne d’une recherche exhaustive n’est pas

n´ecessairement un crit`ere pertinent pour juger de la faisabilit´e d’une attaque. En effet, dans le

cas de 20 fautes inject´ees, est-il vraiment important de savoir que la complexit´e moyenne est de

2

⁶⁸

, c’est-`a-dire que l’attaque esta priori infaisable, alors qu’en r´ealit´e une recherche exhaustive

mod´er´ee parmi 2

⁴⁰

candidats (environ 10 jours de calcul sur un ordinateur standard) permettra

de retrouver effectivement la cl´e dans plus de 80% des cas.

Pour r´esumer, la complexit´e de la

CFA

sur l’

AES

dans le cas d’une ex´ecution en ordre al´eatoire

n’est pas significativement plus ´elev´ee que celle d’une impl´ementation en ordre fixe. Le nombre

d’injections de fautes n´ecessaires est l´eg`erement plus ´elev´e (20 `a 30 fautes au lieu de 16) et le

nombre de chiffrements non faut´es sur la carte attaqu´ee est le mˆeme. Il est simplement rajout´e

une recherche exhaustive sur ordinateur, tout `a fait abordable le plus souvent. Notons enfin que

d’un point de vue exp´erimental, l’attaque est l´eg`erement simplifi´ee dans le cas d’unAddRoundKey

en ordre al´eatoire car l’attaquant n’a pas besoin de faire varier l’instant o`u il injecte la faute.

162

12.3. Une observation triviale

12.3 Une observation triviale

Concernant l’attaque d´ecrite ci-dessus, nous pouvons faire la remarque suivante, certes

tri-viale, mais tout `a fait importante :

Remarque 10. L’attaque

CFA

pr´esent´ee `a la Section12.2dans le cas de l’

AES

ne n´ecessite pas de

connaˆıtre autre chose sur l’algorithme attaqu´e que le simple fait qu’il commence par un XOR

entre le messageM et la cl´e K.

La cons´equence de cette remarque est simple. L’attaque

CFA

de la Section 12.2, y compris

la version dans laquelle le XOR se fait en ordre al´eatoire, peut s’appliquer `a tout algorithme `a

sp´ecifications secr`etes dont l’attaquant ignore tout, except´e que cet algorithme commence par

un XOR entre le message et la cl´e

⁴⁸

.

L’importance de cette remarque tient au fait qu’il est classique de concevoir un algorithme

de chiffrement par bloc de cette mani`ere. Cette op´eration lin´eaire initiale est un moyen simple

de rendre d´ependant de la cl´e, d`es le d´ebut, le traitement qui suit appliqu´e au message. Ce

traitement est souvent une substitution non lin´eaire comme dans le cas de la fonctionSubBytes

de l’

AES

.

Une large classe d’algorithmes est donc concern´ee. Parmi les algorithmes propri´etaires utilis´es

par les op´erateurs de t´el´ephonie mobile ou de t´el´evision `a p´eage, ceux v´erifiant cette propri´et´e

ne sont pas rares et sont donc vuln´erables `a cette attaque permettant de d´evoiler la cl´e malgr´e

le secret de (l’essentiel de) la partie cryptographique.

12.3.1 Mise en œuvre exp´erimentale

Nous avons r´ealis´e cette attaque, dans des conditions de laboratoire, d`es l’automne 2001 dans

le d´epartement des technologies de la s´ecurit´e deGemplus.

La mise en œuvre avait ´et´e facilit´ee par une caract´erisation pr´ealable d’un certain

micro-processeur utilis´e couramment `a cette ´epoque dans les cartes `a puce. Cette caract´erisation visait

`

a ´etudier de mani`ere syst´ematique la vuln´erabilit´e de ce composant `a l’injection de faute par

lumi`ere blanche, lors de l’ex´ecution de diverses instructions arithm´etiques ou logiques. Entre

autres r´esultats, cela a permis d’´etablir la validit´e du mod`ele de faute pr´esent´e `a la Figure12.3.

Suite `a cette caract´erisation, nous avons demand´e `a un d´eveloppeur innocent, de nous fournir

une carte de test sur laquelle ´etait impl´ement´e un des algorithmes GSM commen¸cant par un

XOR entre le message et la cl´e. Nous ne connaissions, ni l’algorithme, ni la valeur de la cl´e.

Dans notre exp´erience, la lumi`ere blanche ´etait ´emise par un flash. Elle illuminait sur la

surface du composant, pr´ealablement mise au jour par abrasion chimique, un cercle d’environ 1

mm de diam`etre. Il ´etait donc possible de choisir assez pr´ecis´ement la zone que nous voulions

perturber. Le d´eclenchement du flash ´etait synchronis´e avec le programme ex´ecut´e dans la carte

et nous pouvions choisir l’instant d’illumination avec une pr´ecision d’un cycle d’horloge.

Une exp´erimentation similaire sur une carte impl´ementant l’

AES

avec le mˆeme composant

nous avait permis, quelques jours plus tˆot, de nous familiariser avec certains aspects pratiques

li´es `a l’exp´erience. L’attaque a essentiellement consist´e en un balayage, cycle d’horloge par cycle

d’horloge, d’une zone que nous soup¸connions contenir la boucle des 16 instructions XOR entre les

octets du messages et de la cl´e. Nous avons recueilli toute une liste de valeurs de sorties diff´erentes

du chiffr´e de r´ef´erence. Les valeurs communes `a cette liste et `a un dictionnaire pr´ealablement

´etabli nous ont permis de retrouver facilement la cl´e.

48_{A l’exception toutefois de ceux pour lesquels le message est impliqu´}` <sub>e ´egalement `a un autre endroit que dans</sub> le XOR initial. Ceci exclut donc, notamment, toutes les conceptions `a base de r´eseau de_Feistel.

Chapitre 13

Les encodages externes secrets ne

prot`egent pas des analyses de fautes

transitoires

Sommaire

13.1 Introduction . . . 166

13.2 Pr´eliminaires. . . 167

13.3 Analyse de fautes sans effet . . . 168

13.3.1 L’injection de fautes comme outil de sondage. . . 168

13.3.2 L’attaque basique . . . 168

13.3.3 Une version am´elior´ee de l’attaque . . . 173

13.4 Contre-mesures . . . 175

13.5 Conclusion . . . 178

Tout comme celle du chapitre pr´ec´edent, l’attaque que nous d´ecrivons dans ce chapitre

s’ap-plique `a une large classe d’algorithmes, et permet de retrouver une cl´e malgr´e l’ignorance de

la fonction cryptographique qui l’utilise. Cette contribution a fait l’objet d’une publication `a

Ches ’07[Cla07a].

Contrairement au principe de_Kerckhoffs, de nombreuses applications de la cryptographie

actuelle continuent d’adopter le paradigme de las´ecurit´e par l’obscurit´e. N´eanmoins, et afin de

profiter de sa s´ecurit´e empirique ou prouv´ee, certaines r´ealisations se basent sur un algorithme

cryptographique bien connu et largement utilis´e. En particulier, une conception possible consiste

`

a obfusquer un chiffrement par bloc standard E en l’encadrant par deux encodages externes

secrets P

₁

etP

₂

(bijections), d’o`u r´esulte l’algorithme propri´etaire E’ = P

₂

◦ E ◦ P

₁

.

Puisque les entr´ees et les sorties de la fonction sous-jacente E ne sont pas connues d’un

potentiel attaquant, une telle construction revendique g´en´eralement l’avantage d’empˆecher tout

type d’analyse de fautes transitoires qui pourrait s’appliquer sur la fonction interne E. Dans ce

chapitre, nous montrons que ce dernier argument n’est pas correct, en exhibant une attaque

r´ev´elant la cl´e qui s’applique `a la classe enti`ere des

DES

ou

Triple-DES

munis d’un encodage

externe. De plus, notre attaque reste applicable mˆeme en pr´esence de la contre-mesure

anti-fautes classique qui consiste `a ex´ecuter l’algorithme deux fois et `a ne retourner le chiffr´e que si

les deux r´esultats co¨ıncident.

Dans le document De la sécurité physique des crypto-systèmes embarqués (Page 180-187)