Attaques par canaux auxiliaires : nouvelles attaques, contre-mesures et mises en œuvre

attaques, contre-mesures et mises en œuvre

Abraham Lincoln

« Le seul endroit où le succès vient avant le travail est dans le dictionnaire. »

Je tiens à remercier, en premier lieu, ma famille : mes parents, mon frère Alexandre et mon épouse Rukiye pour leurs encouragements et leur soutien inconditionnel tout au long de ce travail de recherche. Je remercie également mon épouse pour le travail de relecture finale qu’elle a fourni.

Je remercie tout particulièrement les deux personnes qui m’ont permis de réa-liser ce travail dans les meilleures conditions possibles : mon duo de promot-teurs, Olivier Markowitch et Yves Roggeman, pour m’avoir donné l’opportu-nité de continuer mon parcours universitaire et réaliser cette thèse, pour les conseils fournis lors de mon parcours, pour toutes les relectures des différents travaux réalisés, pour les « coups de pieds » administrés aux bons moments et pour l’encadrement qui m’a permis d’arriver à la réalisation de ce document. Je remercie Dragomir Milojevic pour son suivi tout au long de mon parcours et pour sa présence comme membre de mon jury ainsi que pour ses remarques concernant mon travail et qui m’ont permis de l’améliorer.

Je remercie Jean-Luc Danger et Gilles Van Assche pour avoir accepté d’être membres de mon jury et pour leurs remarques précieuses visant à améliorer mon travail.

Je m’en voudrais d’oublier les personnes du département d’informatique qui m’ont aidé tout au long de ces années, à commencer par les secrétaires : Véro-nique Bastin, Pascaline Browaeys-Auria, Angélique Dufrasnes et Maryka Pee-troons pour leur aide logistique et leurs rappels sur le déroulement des mis-sions scientifques (et pour la Saint-Nicolas évidemment). Je remercie aussi les professeurs avec lesquels j’ai collaboré lors de mes tâches d’assistant : Vandy Berten, Jean Cardinal, Raymond Devillers, Gilles Geeraerts, Christian Hernal-steen, Guy Leduc et Thierry Massart.

1 Introduction 1 2 Préliminaires 5 2.1 Notations et concepts . . . 5 2.1.1 Notations . . . 5 2.1.2 Concepts . . . 6 2.2 AES . . . 9 2.2.1 Fonctionnement . . . 10 2.2.2 SubBytes . . . 11 2.2.3 ShiftRows . . . 11 2.2.4 MixColumns . . . 12 2.2.5 Gestion des clés . . . 12 2.2.6 Déchiffrement . . . 15 2.2.7 Algorithmes . . . 15 2.3 RSA . . . 16

2.4 Notions d’apprentissage automatique . . . 17

2.4.1 Apprentissage supervisé . . . 17

2.4.2 Apprentissage non-supervisé . . . 22

2.5 Réduction de la dimentionalité . . . 24

2.5.1 Ranking . . . 24

2.5.2 mRMR . . . 25

2.5.3 Analyse en composantes principales . . . 25

2.6 Programmation orientée aspects . . . 26

3 Attaques par canaux auxiliaires 31

3.1 Introduction . . . 32

3.1.1 Attaques temporelles . . . 32

3.1.2 Attaques par analyse de consommation . . . 33

3.1.3 Attaques par analyse d’émanations électromagnétiques . 34 3.1.4 Attaques sur d’autres sources d’information . . . 35

3.1.5 Attaques par injection de fautes . . . 35

3.2 Attaques non-profilées . . . 36

3.2.1 Attaques temporelles . . . 36

3.2.2 Analyse simple de consommation . . . 38

3.2.3 Analyse différentielle de consommation . . . 40

3.2.4 Analyse par corrélation de la consommation . . . 42

3.2.5 Analyse de l’information mutuelle . . . 44

3.3 Attaques profilées . . . 46

3.3.1 Attaques par templates . . . 46

3.3.2 Attaques stochastiques . . . 47 3.3.3 Apprentissage automatisé . . . 48 4 Contre-Mesures 51 4.1 Introduction . . . 51 4.2 Hiding . . . 52 4.2.1 Introduction . . . 52

4.2.2 Application à AES - État de l’art . . . 54

4.2.3 Gestion de traces non-alignées . . . 60

4.3 Masking . . . 63

4.3.1 Introduction . . . 63

4.3.2 Application à AES - État de l’art . . . 64

4.4 Efficacité et résistance au bruit . . . 82

5 Nos Attaques 83 5.1 Attaque par templates semi-supervisée . . . 83

5.1.1 Introduction . . . 83

5.1.2 Présentation de l’attaque . . . 83

5.1.4 Conclusion . . . 94

5.2 Apprentissage automatisé contre une implantation masquée . . 95

5.2.1 Introduction . . . 95 5.2.2 Présentation de l’attaque . . . 96 5.2.3 Expériences . . . 97 5.2.4 Conclusion . . . 107 6 Nos Contre-Mesures 109 6.1 SchedAES . . . 109 6.1.1 Motivations . . . 109 6.1.2 Notation . . . 110 6.1.3 Présentation . . . 110 6.1.4 Représentations . . . 113 6.1.5 Analyses et résultats . . . 114 6.1.6 Pseudo-codes . . . 125 6.1.7 Conclusion . . . 129

6.2 Application partielle de contre-mesures . . . 129

6.2.1 Introduction . . . 129

6.2.2 Expériences . . . 130

6.2.3 Masking partiel . . . 131

6.2.4 Shuffling partiel . . . 138

6.2.5 Masking et shuffling partiels . . . 144

6.2.6 Conclusion . . . 147

7 Nos implantations 149 7.1 Programmation Orientée Aspects . . . 149

7.1.1 POA pour RSA . . . 150

7.1.2 POA pour AES . . . 153

7.1.3 Conclusion . . . 164

8 Conclusion 165 A Algorithmes 177 A.1 SchedAES . . . 177

B Résumé des expériences 197

B.1 Cible . . . 197

B.2 Objectif . . . 197

B.3 Méthode . . . 197

B.4 Support . . . 198

Introduction

Dans un monde où l’électronique embarquée prend le dessus sur les anciennes technologies, nous sommes dans l’obligation de faire confiance aux compo-sants (tant logiciels que matériels) que nous manipulons. Qu’il s’agisse de notre carte de banque, de notre smartphone, de notre PC portable ou de bien d’autres appareils, nous sommes forcés de constater la quantité d’informa-tions, secrètes ou non, nous concernant que l’on y retrouve.

S’agissant de données secrètes, le sujet devient encore plus sensible car il se pose alors la question de la sureté de ces informations, entendu par là leur non-accessibilité à toute personne non autorisée. Qu’il s’agisse d’un code PIN permettant de valider nombre de transactions électroniques liées à notre compte en banque, de mot de passe permettant d’acheter quantité de choses sur Internet ou encore de données relatives à la vie privée, nous pensons ces informations protégées par des techniques plus ou moins sophistiquées mais dont la majorité des gens n’ont aucune notion si ce n’est qu’il s’agit de crypto-graphie.

Depuis des siècles, l’Homme cherche à cacher des informations à ses alter-ego ou en cherche à avoir accès à des informations dont il ne peut normalement prendre connaissance. Cette lutte symbolise le combat entre la cryptographie et la cryptanalyse, deux branches de la cryptologie (science du secret). La cryptographie (écriture secrète) cherche à assurer, entre autres1, la confiden-tialité d’un message (c’est-à-dire que seules les personnes autorisées pourront prendre connaissance du message) à l’aide d’une information secrète, connue ou non de tous les participants (selon que l’on parle de chiffrement à clé se-crète ou à clé publique) pour le transformer en un message inintelligible à toute personne ne connaissant pas la clé permettant de retransformer celui-ci en sa version d’origine. La cryptanalyse (étude de l’écriture secrète) s’intéresse

aux méthodes de cryptographie pour, soit démontrer leur sureté, soit identifier leurs failles.

Jusqu’à la fin du millénaire précédent, la cryptanalyse des méthodes de chif-frement se résumait, dans un premier temps, à l’étude des principes logiques ou encore linguistiques, régissant ceux-ci (analyse fréquentielle. . .) et dans un second temps (avec la cryptographie moderne, i.e. à partir de 1970) à l’étude des principes mathématiques (cryptanalyse linéaire, cryptanalyse dif-férentielle, . . .). Depuis la fin des années 1990 et les travaux de Kocher, un nouveau champs de bataille a fait place aux anciennes luttes : les attaques par canaux auxiliaires.

Les attaques par canaux auxiliaires utilisent toute information pouvant être obtenue de l’implantation (ou la mise en œuvre) des méthodes de chiffrement dans le but de les casser en retrouvant la clé secrète utilisée. Qu’il s’agisse du temps d’exécution d’un algorithme sur un appareil donné, de la consommation d’énergie associée à son exécution, des émanations électromagnétiques, du bruit produit par l’appareil ou encore d’autres sources d’informations, toutes ces sources ont en commun la possibilité pour une personne, autorisée ou non, de retrouver des informations sur des données secrètes (telle une clé de chif-frement par exemple) indépendamment de la sureté éventuelle, prouvée, de la méthode utilisée.

Ces techniques ouvrent les voies à la découverte de nouvelles failles sur des implantations de méthodes cryptographiques permettant de développer de nouvelles attaques efficaces. Ces avancées offensives, sur quantité d’appareils, poussent au développement de techniques de protection des implantations visant à réduire la quantité d’informations pouvant être extraites de l’observa-tion des différents canaux auxiliaires.

Le présent travail s’intéresse donc aux attaques par canaux auxiliaires et aux contre-mesures face à ces attaques en s’intéressant aux méthodes de chiffre-ment, principalement aux méthodes à clé secrète (AES) mais également aux méthodes à clé publique (RSA).

L’objectif initial était d’étudier l’influence d’un milieu fortement bruité sur le système d’acquisition ainsi que l’efficacité des contre-mesures aux attaques par canaux auxiliaires et les vulnérabilités qu’elles soulèvent pour d’autres at-taques du genre.

trouver de nouvelles méthodes pour mettre en pratique les contre-mesures. La nouveauté absolue étant un objectif difficilement accessible, j’ai cherché, soit via diverses collaborations, soit seul, à améliorer des approches déjà connues et à tenter de les généraliser. Les nouvelles attaques obtenues concernent l’ap-plication de techniques issues de l’apprentissage automatique pour : (1) créer une variante aux attaques par templates (« Semi-Supervised Template Attack » avec Liran Lerman, Nikita Veshchikov, Cédric Meuter, Gianluca Bontempi et Olivier Markowitch) [42] et (2) attaquer une version protégée d’AES utilisant des masques (« A Machine Learning Approach Against a Masked AES » avec Liran Lerman, Gianluca Bontempi et Olivier Markowitch) [41]. Deux travaux portant sur les contre-mesures ont vu le jour : une contre-mesure pour AES qui pousse plus loin le concept de mélange d’instructions (« The Schedulabi-lity of AES as a Countermeasure against Side Channel Attacks ») [48] et une réflexion sur le niveau de protection à apporter aux implantations (ce travail a été réalisé avec Liran Lerman et est en cours de publication). Enfin, l’utilisa-tion d’un paradigme de programmal’utilisa-tion (la programmal’utilisa-tion orientée aspect) a été proposé comme moyen d’application des mesures : (1) une contre-mesure simple pour un cas particulier d’implantation de RSA (« Enhancing Cryptographic Code against Side Channel Cryptanalysis with Aspects » avec Jérôme Dossogne) [19] et (2) l’implantation de différentes contre-mesures pour AES (ce travail est en cours de publication).

Ces différents travaux ont été conduits dans des contextes (collaborateurs, dé-lais...) différents, ce qui fait qu’il n’est donc pas évident de les comparer entre eux. Ces travaux sont à replacer dans leus différents contextes du moment pour les différents choix effectués lors de chaque expérience.

Préliminaires

2.1

Notations et concepts

2.1.1 Notations

Nous allons introduire, dans cette section, les notations les plus couramment utilisées par la suite.

Trace

Une trace T est un vecteur de points T = {T(t) ∈ R | t ∈ [1; n]}, où le point T(t)

se situe avant le point T_(t+1). Chaque point d’une trace indique une mesure (si-mulée ou mesurée) liée aux opérations réalisées par l’appareil sur lequel elle a été mesurée (pour des traces réelles). Pour des traces simulées, la consomma-tion sera une estimaconsomma-tion de la consommaconsomma-tion en foncconsomma-tion de l’opéraconsomma-tion réali-sée. Les données utilisées ont également une influence sur la consommation. Dans notre cas, la mesure correspond, la plupart du temps, à la consommation d’énergie. Nous utilisons les notations suivantes pour les traces :

– pour une trace : T ,

– pour un point d’une trace (le i-ième) : T(i),

– pour un ensemble de traces : T = {Ti | i ∈ [1; n]},

– pour une matrice de traces : T = {Ti,j | Ti,j = Ti(j)},

– pour une moyenne de traces : ˜T = { ˜T_(i) | ˜T_(i)=Pn

i=1T(i)}.

Clé

Une clé est un paramètre qui modifie le comportement d’un algorithme de chiffrement et, de ce fait, influe sur les données chiffrées.

– pour un byte de la clé : K(i) ou ki ou ki,jsi la clé est représentée sous forme

matricielle1,

– pour un ensemble de clés : K, – pour une matrice de clés : K.

Textes clairs et chiffrés

– pour un texte clair : D (pour Données),

– pour un byte du texte clair2: D(i)ou diou di,jsi le texte est représenté sous

forme matricielle,

– pour un ensemble de textes clairs : D, – pour une matrice de textes clairs : D.

La lettre C (pour Chiffrés) sera utilisée pour les textes chiffrés.

Masques

– pour un masque : m,

– pour un ensemble de masques : M, – pour une matrice de masques : M.

2.1.2 Concepts

Corrélation de Pearson

Le coefficient de corrélation permet de mesurer la relation qui existe entre deux variables aléatoires X et Y. Cette relation peut être :

– positive : une augmentation de X correspond à une augmentation de Y. X et Y varient dans le même sens ;

– négative : une augmentation de X correspond à une diminution de Y. X et Y varient dans des sens opposés ;

– nulle : X et Y ne varient pas de la même façon et une augmentation de X ne correspond ni à une augmentation ni à une diminution de Y.

Le coefficient de corrélation de Pearson exprime l’intensité et le sens de la re-lation linéaire entre deux variables quantitatives. Il varie entre −1 et +1 et est nul lorsqu’il n’existe pas de relation linéaire entre les deux variables3_{. Une}

valeur proche de +1 montre une forte liaison entre les deux variables dont la 1. Il s’agit ici de la représentation d’une clé, comme elle est représentée souvent dans AES par exemple.

2. La lettre s peut également servir à désigner une partie du texte clair dans le cadre d’AES lorsque celui-ci est placé dans la matrice STATE.

relation linéaire est croissante (ou positive). Une valeur proche de −1 montre également une forte liaison entre les deux variables mais dont la relation li-néaire est décroissante (ou négative). Une valeur proche de 0 indique une absence de relation linéaire.

Le coefficient de corrélation rp de Pearson entre deux variables X et Y se

cal-cule de la sorte :

rp =

σxy

σxσy

(2.1) où σxy désigne la covariance entre les variables X et Y et σx, σy leur écart type.

Nous pouvons donc estimer rpde la sorte :

ˆ rp = N X i=1 (xi− ˜x) · (yi− ˜y) v u u t N X i=1 (xi− ˜x)2· v u u t N X i=1 (yi− ˜y)2 (2.2)

où ˜xet ˜ydésignent la moyenne des variables X et Y.

Entropie

Pour X étant une variable aléatoire discrète comportant n symboles, chaque symbole xi ayant une probabilité Pid’apparaitre, l’entropie H de X est définie

comme : H(X) = − n X i=1 Pilog2Pi (2.3)

On a, de plus :

H(X, Y ) = −X

i,j

P (X = xi, Y = yj) log2P (X = xi, Y = yj) (2.4)

l’entropie conjointe des variables X et Y , et : H(X|Y ) = −X

i,j

P (X = xi, Y = yj) log2P (X = xi|Y = yj) (2.5)

l’entropie conditionnelle de X relativement à Y , avec H(X|Y ) = H(X, Y ) − H(Y ).

Information mutuelle

Soient deux variables aléatoires X et Y dans les espaces discrets X et Y et dont les distributions de probabilité sont respectivement PX et PY. La réduction de

l’incertitude sur X obtenue en ayant observé Y est égale à l’information obte-nue sur X en ayant observé Y et correspond à l’information mutuelle entre X et Y : I(X; Y ) ou I(Y ; X) (s’agissant d’une relation symétrique).

La formule permettant de calculer l’information mutuelle entre X et Y est :

I(X; Y ) = H(X) − H(X|Y ) = H(X) + H(Y ) − H(X, Y ) = I(Y ; X) (2.6) Notons enfin la propriété suivante : 0 ≤ I(X; Y ) ≤ H(X). La valeur minimum est atteinte si X et Y sont indépendantes et la valeur maximum est atteinte si Xest complètement déterminée par Y .

Méthode d’estimation

Il n’est pas toujours possible de connaitre la distribution de probabilité d’une variable X. Une des méthodes permettant d’estimer la densité de probabilité d’une variable X est la méthode des histogrammes. Elle consiste à regrouper les observations de X en classes. La probabilité P (X = xi) sera alors estimée

de la sorte :

ˆ

P (X = xi) =

|xi|

|X | (2.7)

où |xi| désigne la cardinalité de la classe où X = xi et |X | désigne le nombre

Multiplication de Montgomery

La multiplication de Montgomery [49, 52, 73] permet la multiplication modu-laire de deux nombres de manière rapide et en évitant le calcul (couteux en temps) de la réduction modulo N en privilégiant les opérations binaires na-tives (additions, multiplications (par un bit) et glissements). Soient A, B et N (0 ≤ A, B < N < 2n_{) trois nombres binaires représentables sur n bits. On}

veut calculer A × B mod N sous l’hypothèse que N est impair. L’algorithme de Montgomery, pour la multiplication modulaire binaire, peut être donné par l’algorithme 1. On note Ai le i-ième bit de A en partant du bit de poids faible.

Algorithme 1 Multiplication modulaire de Montgomery Require: A, B, N

Ensure: X /* Le résultat de A × B × (2n₎−1 _{mod N */}

X = 0 for i = 0 to n − 1 do X = X + Ai× B X = (X + X0× N ) >> 1 end for if (X ≥ N ) then X = X − N end if

En plus d’éviter le calcul de la division par N, cet algorithme a l’avantage de prendre un temps constant pour la multiplication. La seule différence de temps observée provient de la réduction modulaire finale si X est plus grand que N . Pour obtenir le résultat de la multiplication, modulo N , de A par B, il reste à multiplier le résultat obtenu, X, par (2n₎2 _{en utilisant le même algorithme.}

2.2

AES

Dans la deuxième moitié des années 1990, alors que l’algorithme de chiffre-ment DES (Data Encryption Standard) arrivait en bout de vie, le NIST (Na-tional Institute of Standards and Technology4) estima qu’il était grand temps de lui trouver un successeur. C’est pourquoi, le NIST organisa un concours cryptographique. Dès janvier 1997, les chercheurs du monde entier furent in-vités à soumettre des propositions pour ce nouveau standard qu’on appelle-rait AES, pour Advanced Encryption Standard. Le vainqueur de ce concours fut Rijndael [17]. Le nom de Rijndael, choisi comme nom pour l’algorithme, vient d’un mélange des noms de ses concepteurs, Joan Daemen et Vincent Rijmen, tous deux de nationalité belge. Rijndael est un algorithme de chiffre-ment symétrique itératif par bloc, c’est-à-dire qu’il procède en plusieurs tours ;

le nombre de tours dépend de la taille de la clé et de la taille des blocs de données :

– 10 tours pour une clé de 16 octets et des blocs de données de 16 octets, – 12 tours pour une clé de 24 octets et des blocs de données de 16 octets ou

24 octets,

– 14 tours pour une clé de 32 octets ou des blocs de données de 32 octets. La version standard de l’algorithme Rijndael qui fut choisie pour devenir le nouveau standard de chiffrement, l’AES, fut la version à 128 bits de données par bloc. AES est donc un algorithme de chiffrement par bloc qui reçoit des blocs de 128 bits de données et des clés de chiffrement de 128, 192 ou 256 bits. Signalons que la proposition initiale de Rijndael pouvait fonctionner avec des tailles de clé de 128, 160, 192, 224 et 256 bits ainsi que des tailles de mes-sages de 128, 160, 192, 224 et 256 bits. Le nombre de tours en fonction de la taille de la clé a été fixé afin de contrer les attaques de types linéaires [46] et différentielles [9].

2.2.1 Fonctionnement

Introduisons d’abord la matrice STATE, structure qui contiendra les résultats intermédiaires au cours de l’exécution de l’algorithme AES. Chaque case de cette matrice contient un byte. Cette matrice aura toujours 4 lignes et 4 co-lonnes :     s0,0 s0,1 s0,2 s0,3 s1,0 s1,1 s1,2 s1,3 s2,0 s2,1 s2,2 s2,3 s3,0 s3,1 s3,2 s3,3    

La première étape est l’assignation ; on place les données (un octet par case) dans STATE, colonne par colonne, comme suit :

    s0,0 s0,1 s0,2 s0,3 s1,0 s1,1 s1,2 s1,3 s2,0 s2,1 s2,2 s2,3 s3,0 s3,1 s3,2 s3,3     ←     d0 d4 d8 d12 d1 d5 d9 d13 d2 d6 d10 d14 d3 d7 d11 d15    

où diindique le i-ième octet du message traité.

2.2.2 SubBytes

Vient ensuite l’étape du subBytes, qui correspond à une substitution non-linéaire appliquée à chaque octet. Chaque octet de STATE sera transformé suivant une SBox. Algorithmiquement5_{, cette étape se traduit de la sorte :}

Algorithme 2 SubBytes Require: octet z

Ensure: octet z modifié if z ! = 0 then

z = z−1dans GF(28₎

end if

c = {01100011} for i = 0 to 7 do

b[i] = (z[i] + z[i+4 mod 8] + z[i+5 mod 8] + z[i+6 mod 8] + z[i+7 mod 8] + c[i]) mod 2

i = i+1 end for z = b return z

On calcule d’abord l’inverse du byte, dans GF(28_{), avant de lui appliquer}

une transformation affine. Afin de ne pas constamment répéter les calculs ci-dessus, notamment le calcul de l’inverse d’un nombre, une SBox est pré-calculée6; cette SBox contient le résultat final des opérations réalisées dans l’algorithme 2. Pour obtenir ce résultat pour un octet donné, on décompose l’octet en deux parties : la première partie sera un indice de ligne dans la SBox et la deuxième partie sera un indice de colonne. À la case renseignée par ces deux indices se trouve le résultat final de toutes les opérations appliquées à l’octet.

2.2.3 ShiftRows

Une fois la transformation non-linéaire effectuée, on réorganise la matrice STATE en effectuant un décalage circulaire, vers la gauche, des octets d’une ligne. L’amplitude de ce décalage dépend de la ligne de la matrice ; pour la i-ième ligne, on décalera chaque élément de i positions vers la gauche, en considérant que la première a pour indice 0. Cette manipulation s’appelle Shif-5. La notation x[i] indique le i-ième bit de x, x[0] étant le bit de poids faible. En considé-rant la représentation polynomiale, le poids du bit est celui de la puissance de la variable du polynôme, par analogie avec le poids de la puissance de 2 dans une représentation binaire de nombres entiers.

tRows. Cette étape a pour but de réaliser une meilleure diffusion des données à l’intérieur de STATE en changeant le contenu des colonnes. La matrice STATE devient donc :     s0,0 s0,1 s0,2 s0,3 s1,0 s1,1 s1,2 s1,3 s2,0 s2,1 s2,2 s2,3 s3,0 s3,1 s3,2 s3,3     →     s0,0 s0,1 s0,2 s0,3 s1,1 s1,2 s1,3 s1,0 s2,2 s2,3 s2,0 s2,1 s3,3 s3,0 s3,1 s3,2     2.2.4 MixColumns

Enfin, il reste à effectuer une dernière manipulation, appelée mixColumns, sur les colonnes de STATE. Ici aussi, le but recherché est une bonne diffusion des données à l’intérieur du bloc. On peut représenter cette étape de la manière suivante :     b0 b1 b2 b3     =     02 03 01 01 01 02 03 01 01 01 02 03 03 01 01 02         s0 s1 s2 s3    

La colonne b est simplement l’état final de la colonne s après que la multipli-cation, dans GF(28_{), ait été effectuée. On fait donc cela pour chaque colonne}

de STATE ; si indique l’élément de la i-ième ligne pour la colonne considérée.

Cette représentation à l’aide de matrices peut également s’exprimer sous la forme polynomiale7:

b(x) = a(x) ⊗ s(x),où a(x) = 03x3_{+ 01x}2_{+ 01x + 02}

où x représente la multiplication de polynômes sur GF(28_{) modulo x}4_{+ 1. Ces}

multiplications s’effectuent souvent à l’aide de tables pré-calculées donnant le résultat d’une multiplication par 2 (polynôme x) et d’une multiplication par 3 (polynôme x + 1) pour chaque valeur d’octet possible.

2.2.5 Gestion des clés

La gestion des clés se fait au travers des fonctions addRoundKey et keyExpan-sion. AddRounkey réalise un XOR entre STATE et la clé courante (roundkey8_).

7. La forme polynomiale n’est rien d’autre qu’une représentation d’un nombre binaire où un bit à 1 est représenté par la puissance correspondante et un bit à 0 par l’absence de cette puissance, exemple : 1011 = x3_{+ x + 1.}

Le résultat de ce XOR est placé dans STATE. Cette roundkey est dérivée de la clé secrète. On change de clé courante à chaque tour pour éviter d’utiliser toujours la même valeur ; cela rend la tâche d’attaquants plus difficile. KeyEx-pansion est là pour étendre la clé afin, comme nous l’avons dit plus haut, de ne pas utiliser la même clé à chaque tour. La taille de la clé, après avoir été étendue, est égale à la longueur d’un bloc multipliée par le nombre de tours plus un. En effet, il nous faut une clé différente par tour ; de plus, au début de l’algorithme, on exécute un addRounKey initial avant le premier tour. Pour AES-128 (10 tours et clé de 16 octets), la clé, après avoir été étendue, aura 176 octets ; 16 × (10+1) = 176 octets.

FIGURE2.1 – Le KeyExpansion de l’AES Rotword SubBytes K tour (i - 1) 1ère colonne 2ème colonne 3ème colonne 4ème colonne 2(i-1) K tour i 1ère colonne 2ème colonne 3ème colonne 4ème colonne

la première colonne contient, de haut en bas, les valeurs 1,0,0,0 ; les colonnes suivantes sont obtenues en multipliant par 2 (dans GF(28_{)) les valeurs de la}

colonne précédente. Le résultat ainsi obtenu constitue la première colonne de la première sous-clé. Pour les trois autres colonnes de la première sous-clé, les manipulations sont plus simples. Pour la deuxième colonne, on « XOR-e » la deuxième colonne de la clé de départ avec la première colonne de la première sous-clé : le résultat forme la deuxième colonne de la première sous-clé. Pour la troisième colonne, elle est le résultat du XOR de la troisième colonne de la clé de départ et de la deuxième colonne de la première sous-clé, de même pour la dernière colonne, résultat du XOR de son homologue dans la clé de départ et de la colonne qui la précède dans la première sous-clé.

2.2.6 Déchiffrement

Pour déchiffrer, il suffit de réaliser l’inverse des opérations dans l’ordre inverse à celui du chiffrement.

2.2.7 Algorithmes

Algorithme 3 Chiffrement AES Require: state, key

Algorithme 4 Déchiffrement AES Require: state, key

Ensure: state, qui est le résultat final du bloc déchiffré KeyExpansion(key,expandkey[]) AddRoundKey(state,expandkey[10]) for i = 9 > 0 do InvShiftRow(state) InvSubBytes(state) AddRoundKey(state,expandkey[i]) InvMixColumn(state) i = i - 1 end for InvShiftRow(state) InvSubBytes(state) AddRoundKey(state,expandkey[0])

2.3

RSA

Le cryptosystème RSA (initiales de ses trois inventeurs) a été décrit pour la première fois par Ron Rivest, Adi Shamir et Lan Adleman en 1977 [61]. Il s’agit d’un algorithme à clé publique, utilisé aussi bien pour le chiffrement que pour les signatures digitales. Nous ne rentrerons pas dans les détails de l’algo-rithme et nous nous contenterons de décrire brièvement son fonctionnement. L’algorithme RSA utilise deux clés : une clé publique (n, e) et une clé privée (d) qui sont générées de la manière suivante :

1. Deux nombres premiers distincts p et q sont choisis aléatoirement, 2. On calcule n = pq et φ(n) = (p − 1)(q − 1) où φ(n) correspond à la

fonction d’Euler,

3. On choisit aléatoirement un entier e ∈ ]1, φ(n)[ tel que (e, φ(n)) = 1 (on note ainsi le PGCD),

4. On calcule d ∈ ]1, φ(n)[ tel que e · d ≡ 1(mod φ(n)) où d est unique.

Sur base de la paire clé privée / clé publique, le chiffrement d’un message m se réalise en calculant le chiffré c = me_{mod n. Le déchiffrement de c pour}

obtenir le message initial m se réalise en calculant m = cd_{mod n.}

Il existe plusieurs façons de calculer l’exponentiation modulaire : la méthode naïve (an ₌ Qn

i=1a), l’algorithme square-and-multiply [18], le théorème du

2.4

Notions d’apprentissage automatique

Nous allons introduire dans cette section différents outils d’apprentissage au-tomatique (Machine Learning en anglais) utilisés tout au long du travail de thèse. L’apprentissage automatique n’est pas le thème essentiel de ce travail, ni de la recherche effectuée, mais il a servi lors de certains de nos travaux. Il doit dès lors être considéré comme un outil et la présente section n’a vo-cation qu’à introduire les différents concepts utilisés pendant nos travaux de recherche. Nous utiliserons le cas qui nous intéresse (recherche de clé, analyse de traces) pour illustrer ces concepts.

L’apprentissage automatique peut être défini comme l’étude des algorithmes qui apprennent de manière automatique au travers d’expériences [51]. Il cher-che à trouver des relations entre les données ou un modèle de dépendance.

2.4.1 Apprentissage supervisé

L’apprentissage supervisé est une technique d’apprentissage automatique où des règles sont produites automatiquement à partir d’un ensemble de données connues, appelé ensemble d’apprentissage.

L’ensemble d’apprentissage est une association entre un ensemble d’entrées xi = {x1i, ..., x

j

i, ..., xZi } avec x j

i ∈ X, 1 ≤ j ≤ Z et des valeurs de sortie yi ∈ Y

avec 1 ≤ i ≤ N . La méthode d’apprentissage utilisée va alors, à l’aide de l’en-semble d’apprentissage, déterminer une fonction de prédiction qui va modé-liser la relation existante entre les xi et les yi connus (phase d’apprentissage)

de telle sorte à pouvoir généraliser cette relation à des entrées inconnues. Deux types de problèmes peuvent être résolus de la sorte :

– Des problèmes de régression : où l’on cherche à estimer la valeur de yj, dans

un ensemble continu pour, par exemple, estimer la température attendue dans les prochains jours sur base de celles des années précédentes ou de celles des derniers jours, estimer le cours d’une action en bourse, etc. – Des problèmes de classification : où l’on cherche à attribuer une étiquette à

yj, parmi un ensemble fini, pour, par exemple, classer une personne comme

Validation

Avant d’utiliser un modèle pour lequel on réalise une phase d’apprentissage, il faut s’assurer de la validité (qualité) de celui-ci, c’est-à-dire tester ses ré-ponses sur un ensemble de données connues. Typiquement, lors de la phase d’apprentissage, une partie des données connues est mise de côté afin d’être utilisée pour tester la validité du modèle en se basant sur le taux de succès du modèle, ou sur la minimisation de l’erreur par exemple.

Validation par retenue

La technique de validation par retenue (holdout validation en anglais) revient à séparer en deux ensembles (un pour l’apprentissage et un pour la validation) les données de départ. Typiquement, la répartition se fait en gardant 30% des données pour la phase de validation. Une fois que le modèle a appris, à l’aide de l’ensemble d’apprentissage, on estime sa qualité en lui soumettant tour à tour les données de l’ensemble de validation. Cette approche nécessite d’avoir la capacité de se passer d’une partie du jeu de données, afin de tester ensuite le modèle et également de ne pas jouer de malchance lors du partage « en-semble d’apprentissage / enen-semble de validation » pour ne pas tomber sur des résultats induisant en erreur en laissant croire que soit le modèle n’est pas bon, soit, au contraire, qu’il est correct alors que ce n’est pas le cas.

Validation croisée

FIGURE2.2 – Illustration validations par retenue et croisée Holdout Validation Cross Validation Ensemble de validation Ensemble d'apprentissage Arbres de décision

Les arbres de décision sont un outil d’aide à la décision qui permet, notam-ment9 [32], de classifier des données à l’aide d’un arbre où chaque feuille de l’arbre représente une décision finale (attribution de classe) et où chaque nœud est atteint en suivant successivement une série de décisions se basant sur des critères relatifs aux données mises à disposition. On peut répartir un ensemble de données en différents groupes homogènes à l’aide d’une ou de plusieurs variables discriminantes (e.g. âge, sexe, ville, salaire, profession pour des individus, ou dans notre cas : la consommation d’énergie au temps t1dans

une trace, au temps t2, ... pour classer des traces).

Illustrons le concept d’arbres de décision sur un cas qui nous intéresse : re-trouver une valeur secrète associée à des traces de consommation d’énergie. Soit l’ensemble des traces à disposition montré au tableau 2.1, ainsi que la va-leur secrète associée à chaque trace. La figure 2.3 illustre un arbre de décision possible pour répartir les traces en groupes homogènes sur base de la valeur secrète associée.

TABLE2.1 – Jeu de données pour l’arbre de décision de la Figure 2.3. trace T(1) T(2) T(3) T(4) T(5) valeur secrète

T1 1 3 2 5 1 114 T2 1 4 2 4 2 114 T3 2 3 3 4 1 114 T4 2 4 4 3 5 247 T5 1 3 4 4 5 247 T6 1 4 3 4 2 247

FIGURE2.3 – Illustration d’un arbre de décision

tr1,tr2,tr3, tr4,tr5,tr6 tr1,tr3, tr5 tr2,tr4, tr6 tr1,tr3 tr5 tr4 tr2,tr6 tr2 tr6 t2 <= 3 t2 > 3 t5 <= 3 t5 > 3 t4 <= 3 t4 > 3 t3 <= 2 t3 > 2 114 114 247 247 247

Notons qu’il ne s’agit ici que d’une illustration du concept d’arbre de décision. De meilleures partitions existent pour le jeu de données utilisé mais ce n’était pas notre but de montrer la meilleure partition possible.

Les arbres de décisions sont un concept assez simple à comprendre, à expliquer et sont facilement visualisables (surtout s’ils sont de petite dimension). En revanche, les arbres de décisions sont fortement dépendants de l’ensemble d’apprentissage et peuvent apprendre « par cœur » celui-ci, ce qui peut amener, par la suite, à des erreurs de classification sur des exemples non vus [32]. Une solution à ce problème est d’en utiliser plusieurs et ainsi constituer une forêt aléatoire d’arbres de décision.

Forêts aléatoires

Les forêts aléatoires constituent un ensemble d’arbres de décision. La parti-cularité de ces arbres est qu’à chaque étape (chaque création de fils ou de feuilles), les variables discriminantes sont tirées aléatoirement parmi les pos-sibilités de variables. De la sorte, chaque arbre constituant la forêt sera, a priori, différent des autres, mais si des variables fortement corrélées à la ré-partition en classes des données existent, elles devraient être utilisées dans plusieurs arbres. Lors de l’évaluation d’une nouvelle donnée, la classe retenue sera celle qui ressort le plus souvent, via un système de vote par exemple, de l’ensemble des arbres.

Machines à vecteurs de support

Les machines à vecteurs de support (support vector machine (SVM) en anglais) sont des classificateurs linéaires. Un classificateur linéaire cherche à séparer les données linéairement. Cette séparation a lieu à l’aide d’un point pour un espace à une dimension, d’une droite pour un espace à deux dimensions, d’un plan pour un espace à trois dimensions et à l’aide d’un hyperplan pour un nombre de dimensions supérieur. S’il n’est pas possible de séparer linéaire-ment les données, les SVM vont ajouter une dimension aux données (comme nous pouvons le voir sur la Figure 2.4), afin de pouvoir les séparer. Cette nouvelle dimension est calculée à l’aide des autres variables caractérisant les données à séparer (aucune information n’est créée). La séparation entre les groupes sera choisie pour maximiser la marge qui est la distance entre la fron-tière (séparation) des deux groupes observés et les plus proches observations des groupes vis-à-vis de cette séparation.

FIGURE2.4 – Illustration de l’ajout d’une dimension afin d’obtenir une sépa-ration linéaire des données.

ajout d'une dimension

2.4.2 Apprentissage non-supervisé

Les méthodes d’apprentissage non-supervisé essayent de classer des données reçues en entrées sans connaissance a priori (sans ensemble de valeurs de sor-tie associées) du ou des liens qu’elles ont entre elles. Il s’agit de regrouper les xi, reçus en entrée, en groupes de telle sorte que les xi classés au sein d’un

groupe soient plus proches entre eux que vis-à-vis des xi d’autres groupes.

L’apprentissage non-supervisé est, en général, plus complexe que l’apprentis-sage supervisé, car le lien entre les données n’est pas connu. Lors de l’ap-prentissage supervisé, il est toujours possible de vérifier à l’aide de nouvelles entrées la validité du modèle produit. Ce qui n’est pas forcément le cas pour l’apprentissage non-supervisé, car la réponse correcte n’est pas connue, du fait de la non-supervision du problème.

Ces techniques sont utilisées dans des domaines variés comme la recherche médicale afin d’identifier certains facteurs, non connus, favorisant l’apparition ou non d’une maladie, pour conseiller des acheteurs de sites d’achats en ligne en fonction des achats effectués par d’autres utilisateurs présentant des simi-litudes dans leurs comportements d’achats...

Clustering

données est une notion assez vague qui va dépendre de la technique utilisée (deux techniques différentes ne donneront pas nécessairement la même partition en clusters) et du nombre de clusters que l’on désire avoir au final. Nous allons nous concentrer sur deux techniques de clustering : l’algorithme des k-moyennes et l’algorithme des k-médoïdes. Pour ces deux algorithmes, il faudra, à chaque fois, préciser le nombre K de clusters Ci voulus, où chaque

cluster Ci contiendra les indices de chaque observation (ou donnée) qu’il

contient. Il est important de noter quelques propriétés importantes du clus-tering :

1. C1∪ C2∪ · · · ∪ CK= {x1, . . . , xn}, l’union de tous les clusters représente

l’ensemble des n observations. 2. Ck∩ Ck0 = ∅ ∀k 6= k

0

, l’intersection de deux clusters distincts est vide. Ces deux propriétés font qu’une donnée appartient à un et un seul cluster.

K-moyennes

L’objectif de l’algorithme des k-moyennes est de faire en sorte que les va-riations au sein d’un cluster soient les plus petites possibles. La variation du cluster Ckse mesure à l’aide d’une fonction W (Ck)qui calcule la variation des

données, du cluster, entre elles. Il s’agit alors de minimiser l’équation 2.8.

minimize C1,...,Ck { K X k=1 W (Ck)}. (2.8)

La façon la plus courante d’évaluer la fonction W (Ck) est d’utiliser la

dis-tance euclidienne (au carré) qui sera normalisée par le nombre d’observations contenues dans le cluster :

minimize C1,...,Ck { K X k=1 1 |C_k| X i,i0∈Ck p X j=1 (xij− x_i0 j) 2_{} (2.9)}

où chaque variable xi est composée de p variables : xi1, . . . , xip. La

minimisa-tion de l’expression 2.9 se fait de la façon suivante :

1. Attribuer, arbitrairement, à chaque observation un cluster (entre 1 et K), 2. Répéter jusqu’à ce que les clusters ne varient plus :

(b) Attribuer chaque observation au cluster ayant le centre le plus proche (distance euclidienne).

K-médoïdes

En statistiques, un médoïde est le représentant le plus central d’une classe, celui dont la distance euclidienne aux autres éléments est la plus petite. L’al-gorithme des k-médoïdes se comporte comme l’alL’al-gorithme des k-moyennes à ceci près qu’il minimise l’erreur quadratique moyenne (distance euclidienne au carré) entre les points d’un cluster et son médoïde, au lieu des points du cluster entre eux pour les k-moyennes.

2.5

Réduction de la dimentionalité

Face au grand nombre de données que peut représenter une trace : entre un millier de points et plusieurs millions de points (1,7 millions de points pour le DPA contest V4 [1]), il est essentiel, pour mener efficacement l’attaque, de filtrer l’information qu’elle contient. Ce filtrage vise à garder un nombre restreint de points qui garantiront le bon déroulement de l’attaque. On ap-pelle cette diminution de points considérés : la réduction de la dimentionalité. Certaines des techniques de réduction de la dimentionalité isolent p points parmi les n points disponibles (réduction directe), alors que d’autres trans-forment les données, via des combinaisons linéaires par exemple, et partent de cette modification pour garder, éventuellement, un sous-ensemble suffi-samment représentatif des données initiales (projection). Nous allons aborder ici quelques-unes de ces techniques, qui sont celles abordées dans le docu-ment. D’autres techniques de réduction de dimentionalité existent. Citons, par exemple, la technique NICV de Bhasin et al. [8] qui présente l’avantage de ne nécessiter aucun appareil identique à celui attaqué pour identifier le ou les point(s) intéressants, ni de connaissances sur des paramètres secrets (clé) de l’algorithme de chiffrement. Cette technique se base sur les connaissances des textes clairs et/ou des textes chiffrés.

2.5.1 Ranking

dans les traces qui ne correspondent pas au chiffrement10) et ne tient pas compte non plus de la complémentarité ou de la redondance d’information : il n’est pas nécessaire de garder deux points voisins dans la trace, car même s’ils sont identifiés comme étant ceux dont la variance est la plus grande, il y a de fortes chances qu’ils soient énormément corrélés. Il vaut mieux alors prendre un point situé à un autre endroit de la trace.

2.5.2 mRMR

Minimum Redundancy Maximum Relevance est une technique qui trie les

don-nées en avantageant celles qui ont une dépendance mutuelle faible (et donc une faible redondance) et qui garantissent, malgré tout, une grande quantité d’information sur la sortie (la valeur secrète associée à la trace dans notre cas) à laquelle elles sont associées (et donc une grande pertinence) [40].

La méthode commence par choisir une variable r (un point de la trace) qui a la plus grande information mutuelle avec la valeur cible (une partie de la clé par exemple). Ensuite, la méthode va mettre à jour un ensemble R avec des points p (p = {T_i(j)|i ∈ [1; K]; j ∈ [1; N ]}) dans les traces, qui maximisent l’information mutuelle avec la valeur cible O tout en minimisant l’information mutuelle avec les points déjà sélectionnés :

max I(p; O) − 1 |R|

X

r∈R

I(p; r). (2.10)

2.5.3 Analyse en composantes principales

Les deux précédentes techniques, que nous avons présentées, sont des tech-niques qui sélectionnent les points dans la trace sans modification. Il existe une autre façon de procéder à la diminution de dimentionalité : la projection. La projection consiste à réduire le nombre de dimensions en utilisant des com-binaisons linéaires des valeurs initiales. La technique la plus connue et la plus utilisée de projection est l’analyse en composantes principales (Principal

Com-ponent Analysis (PCA) en anglais).

La PCA [33] projète les données sur un espace de dimensions plus petit en faisant en sorte que la distance entre la donnée initiale et sa projection soit faible (aussi appelée erreur de projection). L’idée de la PCA est de passer d’un espace de n dimensions à un espace à k dimensions (avec11_{k ≤ n). Pour cela,}

il faut trouver les k vecteurs u(1)_{, u}(2)_{, ..., u}(k) _{qui définissent l’espace de}

pro-10. Par exemple, les points initiaux ou finaux de la trace où le chiffrement n’aurait pas encore commencé ou serait déjà terminé.

jection sur lequel les données vont être projetées, tout en minimisant l’erreur de projection. Sans rentrer dans les détails sur le choix de k, l’idée est de faire en sorte que la variance des données projetées corresponde à un seuil vis-à-vis des données initiales : garder 95% de la variance de l’ensemble de départ par exemple.

2.6

Programmation orientée aspects

La Programmation Orientée Aspects (POA, ou AOP en anglais pour

Aspect-Oriented Programming) définit un nouveau paradigme12 de programmation. Présenté en 1996 par Gregor Kiczales et son équipe au Palo Alto Research

Cen-ter, ce paradigme introduit la notion d’aspect, qui est l’équivalent de l’objet

pour la programmation orientée objets (POO, ou OOP (Object-Oriented

Pro-gramming) en anglais), c’est-à-dire l’élément central.

Certaines limitations de la POO sont à la base de l’apparition des aspects, et notamment celles de préoccupations transversales qui, grâce aux aspects, vont pouvoir être traitées séparément du cœur même de l’application. C’est pourquoi la POA ne remplace pas la POO, mais vient la compléter. Les deux techniques peuvent coexister. Ce mélange des genres doit, à terme, offrir des facilités de développement en garantissant un code plus réutilisable, car les aspects transversaux seront gérés en dehors des classes, et donc, ces classes pourront plus facilement servir pour d’autres applications. De plus, le code sera plus simple à maintenir à jour en ce qui concerne ces aspects transver-saux, car le code qui y sera lié sera localisé en un seul endroit : l’implantation de l’aspect et non plus éparpillé dans le code des différentes classes.

FIGURE 2.5 – Illustration de la répartition des fonctionnalités sans et avec utilisation de POA.

POO POO + POA

code du programme

code noyau code des aspects

La POA n’est pas limitée à un seul langage. Plusieurs langages comme le C, C++, PHP, Delphi, Smalltalk, Java, ... permettent de programmer en utilisant ce paradigme. Dans la suite de cette présentation et lors de nos recherches, nous nous sommes intéressés à la POA via AspectJ, une implantation de la POA en Java.

2.6.1 Terminologie

Définissons les termes essentiels de la POA que sont les weaver, pointcuts,

ad-vice et joinpoints. Commençons par la définition essentielle de cette section :

la définition d’un aspect.

Définition 1 Un aspect est un module implantant une « préoccupation » (concern

en anglais). Il encapsule une fonctionnalité et est constitué d’un ou de plusieurs points de coupure (pointcuts) et de code associé (advice).

Afin de pouvoir assembler les objets et les aspects pour en faire un programme exécutable, un tisseur (weaver en anglais) est nécessaire. L’opération qui se charge de lier ces deux notions est appelée tissage.

Définition 2 Un tisseur est l’entité chargée du tissage, c’est-à-dire de lier objets

au moment de la compilation ou dynamique à l’exécution.

AspectJ est un tisseur qui effectue le tissage au moment de la compilation. Les avantages et inconvénients de chacune de ces techniques ne sont pas discutés dans ce travail, mais sont abordés par Filman [20].

Afin de pouvoir tisser aspects et objets, le tisseur va se baser sur la notion de points de jonction (joinpoints en anglais).

Définition 3 Un point de jonction est un point dans le flux d’exécution d’un

pro-gramme où un ou plusieurs aspects peuvent être appliqués.

Potentiellement, n’importe quel point du programme est susceptible d’être un point de jonction, mais tous ne sont pas pertinents dans le cadre de la POA. On discerne essentiellement quatre types de points de jonction.

– Point de jonction sur les méthodes : grâce à la POO, l’exécution d’un pro-gramme peut être vue comme une succession d’appels de méthodes et d’exé-cutions de méthodes. Ces moments d’appel et d’exécution représentent les points de jonction les plus couramment utilisés en POA. La différence entre l’appel et l’exécution se situe au niveau du contexte dans lequel se trouve le programme : contexte de l’appelant pour l’appel et contexte de l’appelé pour l’exécution.

– Point de jonction sur les constructeurs : l’appel et l’exécution des construc-teurs d’objets représentent, comme pour l’appel et l’exécution de méthodes, une possibilité de points de jonction.

– Point de jonction sur les exceptions : la levée d’une exception ou sa capture constituent des points de jonction.

– Point de jonction sur les champs : les opérations d’écriture et de lecture des champs (attributs, variables) sont également des points de jonction.

Définition 4 Un point de coupure est un ensemble de points de jonction dans le

flux d’exécution d’un programme.

Le point de coupure définit le ou les endroit(s) où l’aspect sera tissé au code principal. De la même façon qu’il existe différents types de points de jonction, il existe différents types de points de coupures. Quelques exemples sont don-nés au code 1.

Code 1 Différents points de coupures

1 //point de coupure nomme dataModification place sur

2 //la modification de n’importe quel attribut de la classe C

3

4 pointcut dataModification(): set(C.*); 5

6 //point de coupure nomme calls place sur l’appel a

7 //n’importe quelle methode de type void de la classe B

8

9 pointcut calls(): call(void B.*(..)); 10

11 //point de coupure nomme executions place sur l’execution

12 //de n’importe quelle methode de type void de la classe A

13

14 pointcut executions(): execution(void A.*(..)); 15

16 //point de coupure nomme move place sur l’appel aux methodes

17 //setX ou setY de la classe point de type void, et qui prennent

18 //un entier en parametre

19

20 pointcut move(): call(void Point.setX(int)) || call(void Point.setY(int));

Une fois le "où" d’un aspect défini, encore faut-il y associé un "quoi". Ce rôle est joué par le code advice (advice code en anglais), nommé simplement advice. Définition 5 Un code advice définit le comportement d’un aspect.

Un code advice est associé à un point de coupure afin de réaliser des opé-rations qui y sont liées. À l’inverse des méthodes, le code advice n’est pas directement appelé explicitement, mais est tissé aux points de jonction atta-chés au point de coupure auquel il est associé. Trois types principaux de code advice existent :

– before : le code advice est exécuté avant le point de jonction. – after : le code advice est exécuté après le point de jonction.

en AspectJ).

Attaques par canaux auxiliaires

Avant la découverte des attaques par canaux auxiliaires, qui seront le sujet principal de ce chapitre, la cible de la cryptanalyse était les algorithmes cryp-tographiques. On « attaquait tel ou tel algorithme de chiffrement » en se ba-sant sur des propriétés statistiques (analyse de fréquence des lettres...) ou en se basant sur des dépendances linéaires [46] et/ou différentielles [9] entre des entrées de différentes exécutions. On démontrait alors la robustesse d’un algorithme en se basant sur des principes mathématiques complexes, jusqu’au jour [35, 36] où l’on constata qu’une autre façon d’attaquer était possible. Dans un monde de plus en plus informatisé, dissocier modèle (propriétés et algorithmes) et implantation (programme et appareil) est de plus en plus ir-réaliste. La sécurité d’un ensemble (algorithme/machine dans notre cas) étant dépendante de la sécurité de tous ses maillons, les attaques allaient pouvoir s’intéresser de plus près à ce nouveau maillon : l’appareil cryptographique où était implanté l’algorithme ciblé. De ce fait, la sécurité ne concerne plus seule-ment l’algorithme en lui-même, mais égaleseule-ment son implantation.

FIGURE3.1 – Illustration générale d’attaques par canaux auxiliaires. texte clair texte chiffré Appareil Cryptographique Algorithme Cryptographique temps consommation d'énergie température émanations bruit clé

3.1

Introduction

des temps d’exécution estimés en fonction des valeurs attaquées afin d’ensuite comparer ces estimations aux mesures et tenter de retrouver l’information désirée. Les mesures de temps se doivent d’être précises. Il ne s’agit pas de mesurer en millisecondes, mais plutôt de l’ordre de la microseconde ou plus encore.

FIGURE3.2 – Canevas général d’une timing attack

Serveur, Carte à puce, Ordinateur requête

réponse temps écoulé

3.1.2 Attaques par analyse de consommation

Les attaques par analyse de consommation (power analysis attacks en anglais) se basent sur la consommation d’énergie des appareils attaqués afin de retrou-ver des informations sensibles. La consommation de courant d’un appareil va-rie en fonction des instructions qu’il exécute, mais également des données que ces instructions utilisent. Il est alors possible, en mesurant un certain nombre de fois la consommation d’énergie d’un appareil, de retrouver des informa-tions telles que : les instrucinforma-tions exécutées (permet d’identifier l’algorithme par exemple), des informations secrètes complètes (clé de chiffrement) ou partielles (poids de Hamming d’une clé de chiffrement).

Pour réaliser ces attaques, il faut disposer, en plus de l’appareil à attaquer, d’un oscilloscope1 et, éventuellement, d’un appareil identique à celui qui va être attaqué. Afin de réaliser un ampèremètre, une résistance est insérée en série entre la source d’alimentation et le dispositif attaqué afin de mesurer la différence de potentiel aux bornes de la résistance et de l’enregistrer à l’aide de l’oscilloscope. Le résultat d’une telle acquisition est une trace qui représente la consommation d’énergie au cours du temps.

FIGURE3.3 – Dispositif d’acquisition. [2] Commandes / Données Configuration / Traces Signal / Trigger

L’essentiel de la consommation C_totalliée à chaque point d’une trace peut être décrit comme étant le résultat de la somme de différentes sources de consom-mation d’énergie : Ctotal= Copération+ Cdonnées+ Cbruit, c’est-à-dire les

consom-mations liées à l’opération exécutée, aux données manipulées, mais entachées de bruit. L’objectif pour un attaquant étant de tirer parti au maximum des deux premiers composants, tout en réduisant l’effet du bruit.

3.1.3 Attaques par analyse d’émanations électromagnétiques

Les analyses d’émanations électromagnétiques permettent d’analyser l’activité (rayonnement électromagnétique) à différents endroits d’un appareil : le cou-rant nécessaire au fonctionnement des différents composants d’un appareil in-duit un champ électromagnétique qui est, dès lors, mesuré par un attaquant. En plus de délivrer des informations sur les données sensibles, via des varia-tions d’intensité des champs induits, il est également possible de récupérer des informations sur chaque composant de manière séparée, en se concentrant sur la mesure de ceux-ci2, permettant ainsi une analyse plus détaillée de l’appareil attaqué.

3.1.4 Attaques sur d’autres sources d’information

En plus de mesurer le temps, la consommation d’énergie et/ou les émana-tions électromagnétiques, il existe d’autres moyens moins répandus de récol-ter des informations via des canaux auxiliaires. Le canal accoustique est un de ces moyens : en fonction du temps qui sépare deux pressions successives de touches d’un clavier, il est possible de retrouver un mot de passe par exemple. Le son produit et l’activité de différents composants [22] peuvent également être analysés pour obtenir des compléments d’informations.

3.1.5 Attaques par injection de fautes

Les attaques que nous avons mentionnées jusqu’à présent sont des attaques dites passives, car on se contente, très souvent, de récupérer les informations d’un appareil, sans interagir sur son comportement. Un autre type d’attaques, appelées attaques par injection de fautes, permet, quant à lui, d’interagir avec l’appareil afin de provoquer des comportements erronés permettant de récu-pérer des informations sur son état, ses données ou autre.

3.2

Attaques non-profilées

3.2.1 Attaques temporelles

La première attaque temporelle a été présentée en 1996 par Paul Kocher [35] et appliquée ensuite par Dhem, Koeune, Leroux, Mestré, Quisquater et Willems [18]. Cette attaque visait l’algorithme de RSA, implanté sous la forme

left to right square and multiply (algorithme 5), utilisant la multiplication de

Montgomery. Cet algorithme reçoit en paramètre un message m et une clé k (de w bits) et produit comme résultat x (x = mk_{mod n).}

Algorithme 5 Algorithme left to right square and multiply x = m for i = w − 2 down to 0 do x= x2_{mod n} if ki== 1then x= x.m mod n end if end for return x

L’attaquant va attaquer la clé, bit à bit, en commençant par le deuxième bit de poids fort3(le bit d’indice w − 2) et en finissant par le bit de poids faible. L’attaque se réalise en connaissant le modulus n, les messages m fournis à l’appareil et avec une clé k qui ne change pas tout au long de l’attaque. La multiplication et la mise au carré se font à l’aide de l’algorithme de Montgo-mery (section 2.1.2). Pour rappel, avec cet algorithme, la multiplication est exécutée en temps constant pour un même modulus m. Une réduction éven-tuelle peut avoir lieu après la multiplication et créer une différence de temps d’exécution.

Pour certains messages m (ceux pour lesquels le résultat de la multiplication est plus grand que le modulus), une réduction est nécessaire alors que pour d’autres messages cette étape n’est pas nécessaire. L’attaquant peut alors scin-der l’ensemble des messages m en deux ensembles ; un premier sous-ensemble pour lequel la multiplication implique la réalisation de l’étape de réduction et un second sous-ensemble pour lequel la multiplication ne néces-site pas cette étape.

Si la valeur du bit attaqué est réellement 1, alors on devrait voir apparaitre une différence entre la moyenne des temps d’exécution des deux sous-ensembles4_:

3. Le premier bit de poids fort vallant 1.

le temps moyen d’exécution du premier sous-ensemble devrait être supérieur à celui du second sous-ensemble. À l’inverse, si la valeur du bit attaqué est 0, alors aucune différence notable ne devrait apparaître entre les temps moyens des deux sous-ensembles, car la réduction ciblée (c’est-à-dire celle ayant lieu pour les messages du premier sous-ensemble si le bit attaqué vaut 1) n’a pas lieu.

De manière plus formelle, considérons l’algorithme A(m, k) qui peut être dé-composé en L(m, k) et R(m, k) où L(m, k) désigne la partie de l’algorithme liée au calcul de la réduction ayant lieu après la multiplication, pour le bit attaqué, et R(m, k) désigne le reste de l’algorithme. Le temps d’exécution5_,

T (m), de l’algorithme peut, lui aussi, être décomposé en deux parties : T (m) = TL(m) + TR(m)où TL_{(m)et T}R_{(m)sont respectivement les temps}

d’exécu-tion de L(m, k) et R(m, k).

Nous avons également un oracle O : O : m →



1 si m · m2 _{nécessite une réduction}

0 si m · m2 _{ne nécessite pas de réduction}

Nous avons de plus :

M1= {m ∈ M : O(m) = 1},

M2 = {m ∈ M : O(m) = 0},

F1 : M1 → R : m → F1(m) = T (m),

F2 : M2 → R : m → F2(m) = T (m).

où M1 désigne l’ensemble des messages pour lesquels l’oracle donne la

va-leur 1, c’est-à-dire les messages pour lesquels une réduction a lieu après la multiplication modulaire, M2 désigne l’ensemble des messages pour lesquels

la réduction n’a pas lieu après la multiplication. F1 et F2 sont les fonctions

associées à chaque sous-ensemble et qui à un message associent un temps d’exécution.

acquiert suffisamment de données).

Nous avons : 

F1 = TR si le bit attaqué vaut 0

F1= TR+ TL si le bit attaqué vaut 1

et :

F2 = TR,

indépendamment de la valeur du bit attaqué.

En observant le temps d’exécution moyen des messages des ensembles M1 et

M2 l’attaquant supposera que le bit attaqué vaut 0 si aucune différence

signifi-cative n’est observée ou qu’il vaut 1 si une différence signifisignifi-cative est observée. Comme l’indiquent Dhem et al. [18], en procédant de la sorte, les auteurs ont réussi à retrouver une clé de 128 bits à l’aide de 50 000 mesures.

Notons enfin que les attaques temporelles ne sont pas seulement réservées aux chiffrements asymétriques. En 2005, Daniel Bernstein a présenté une attaque sur AES qui se basait sur les temps d’accès aux caches des processeurs [6].

3.2.2 Analyse simple de consommation

FIGURE3.4 – Trace mesurée pour DES, où l’on voit la répétition de 16 motifs correspondant aux 16 tours de DES - [36]

FIGURE3.5 – Trace mesurée pour AES, où l’on voit la répétition de 9 motifs correspondant aux 9 premiers tours d’AES, plus un motif différent pour le dernier tour - [69]

FIGURE 3.6 – Trace où l’on peut constater le mapping entre les instructions exécutées et la trace - [45]

FIGURE3.7 – Partie de trace où l’on peut lire visuellement la partie de la clé utilisée lors du square-and-multiply de RSA - [15]

3.2.3 Analyse différentielle de consommation

FIGURE3.8 – Traces de DES - [36]

partie de la clé. On peut voir, à la figure 3.8, quatre traces. La première trace est une trace moyenne pour les n chiffrements. La seconde est une trace issue de la différence des traces moyennes de chaque groupe pour une hypothèse correcte sur une partie de la clé. Nous pouvons y voir un pic significatif indi-quant une différence de consommation liée aux données manipulées. Les deux dernières traces sont des traces issues de la soustraction des traces moyennes de chaque groupe pour des hypothèses incorrectes sur la partie de la clé atta-quée. La présence (resp. l’absence) de pics indique une bonne (resp. mauvaise) hypothèse pour la partie de la clé attaquée.

Les attaques DPA se différencient essentiellement des attaques SPA par le nombre de traces requis. Les attaques SPA ne nécessitent qu’un faible nombre de traces alors que les attaques DPA nécessitent un plus grand nombre d’ac-quisition, de part le traitement mathématique qu’elles réalisent sur celles-ci. En effet, les attaques DPA collectent un grand nombre de traces pour pouvoir ensuite éliminer le bruit de celles-ci lors du calcul des moyennes, laissant ainsi la suite de l’analyse s’effectuer sur des traces moins bruitées et où les diffé-rences mesurées seront plus liées à des diffédiffé-rences de données manipulées qu’au bruit.

3.2.4 Analyse par corrélation de la consommation

Dans l’article introductif des analyses par corrélation de la consommation (correlation power analysis (CPA) en anglais) [11], Brier, Clavier et Olivier montrent une autre façon de s’intéresser aux traces et aux données sensibles. Au lieu de s’attaquer à un bit de données sensibles à la fois et de chercher des différences de consommation liées à la valeur de ce (ces) bit(s) en les scindant en deux (ou plusieurs) groupes, l’auteur va s’attaquer à un ensemble de bits à la fois. Pour cela, il part de l’observation qu’un bit fait partie d’un ensemble de données et qu’il n’agit pas seul sur la consommation : dans DES, les bits sont manipulés par sous-blocs de 4 ou 6, dans AES par 8 au minimum. Les autres bits faisant partie du même groupe que le bit attaqué, ont eux aussi, leur influence sur la consommation. Ensuite, l’auteur introduit la notion de

leakage model qui va servir à mesurer la corrélation linéaire avec les traces

obtenues. L’auteur mentionne deux modèles de leakage : le modèle basé sur la distance de Hamming et le modèle basé sur le poids de Hamming (notons que le dernier est un cas particulier du premier).

Définition 6 Un modèle de consommation (ou leakage model en anglais) permet

consécutives d’une variable).

L’attaque CPA peut se résumer en 5 étapes :

1. L’attaquant choisit un résultat intermédiaire de l’algorithme. Ce résultat doit être une fonction f (d, k), où d est une valeur non constante connue (souvent une partie ou l’entièreté du texte clair ou chiffré) et k une partie de la clé (e.g. un byte). Nous considérons dans la suite de la description une attaque qui vise un byte (le b-ième byte) de la clé.

2. L’attaquant mesure ensuite la consommation d’énergie de l’appareil lors-qu’il opère sur un ensemble D de données. Pour chacune de ces expé-riences, l’attaquant note les parties de données impliquées dans la fonc-tion f dans un vecteur D = (d1, ..., dD), où di désigne la partie de

don-nées impliquées dans la fonction f pour la i-ième exécution. À chaque donnée di va être associée une trace Ti = (Ti,(1), ..., Ti,(T )), où T est le

nombre de points dans la trace Ti. L’attaquant obtient alors une matrice

Tde taille D × T dont chaque ligne représente la mesure de consomma-tion de l’appareil lors de la i-ième exécuconsomma-tion.

3. Pour toutes les valeurs possibles du byte cible de la clé, stockées dans un vecteur K = (Ki,(b), ..., KK,(b)), l’attaquant va calculer les valeurs de

la fonction f (d, k) en utilisant les vecteurs D et K. Il obtient alors une matrice V, de taille D × K, où chaque case vi,j représente l’output de la

fonction f (di, Kj,(b)).

4. L’attaquant applique ensuite le modèle de consommation choisi aux va-leurs de la matrice V. Il obtient une matrice H dont les cases hi,j

contien-nent la fuite d’information estimée de l’appareil lors de l’exécution de la fonction f (di, Kj,(b)).

5. Enfin, l’attaquant calcule la corrélation linéaire (équation 3.1) entre chaque colonne hi de la matrice H et chaque colonne tj de la matrice

T. En d’autres mots, il compare le leakage estimé à chaque instant des traces. Il obtient une matrice R, de taille K × T , où chaque case ri,j

contient la corrélation linéaire de hi et tj. La plus grande valeur ri,j

dans R indiquera, selon toute vraisemblance, que le byte de la clé re-cherché est le byte Kj,(b).

ri,j = PD d=1(hd,i− ˜hi).(td,j− ˜tj) q PD d=1(hd,i− ˜hi)2. PD d=1(td,j− ˜tj)2 (3.1)