G´en´eration de Nombres Al´eatoires

Dans la section pr´ec´edente, nous avons vu que l’obtention des param`etres

d’in-jection de faute fait lourdement appel `a la g´en´eration de nombres pseudo-al´eatoires

distribu´es entre 0 et 1, notamment par l’interm´ediaire de la fonction my_rand().

Dans cette section, nous ´evaluons plusieurs g´en´erateurs. Une fois que le plus

ad´e-quat sera choisi, nous discuterons des am´eliorations qui lui sont apport´ees.

4.3. Injection de Fautes 83

tranches d’exécution routine CEU injection de fautes Liste originale

Transformation en cycles d’horloge Découpage en tranche d’exécutions

Insertion de la durée de l’injection de fautes

temps

temps

cycles

Fig. 4.9 – D´ecoupage des temps d’injections en injections relatives `a l’ex´ecution.

G´en´erateur Taux d’´echec au Taux d’´echec au Dur´ee

test duχ

2

test du χ

2

d’ex´ecution

au seuil 95% au seuil 99%

rand() 5.72% 1.20% 3902 s

Lehmer 5.99% 1.26% 3945 s

Mersenne-Twister 5.87% 1.24% 3897 s

Tab.4.2 – Test des diff´erents g´en´erateurs de nombres al´eatoires

Comparaison de Diff´erents G´en´erateurs

Nous avons ´evalu´e trois g´en´erateurs diff´erents :

1. La fonction de la librairie C accompagnant le syst`eme d’exploitation Linux

rand() [58] qui utilise un non-linear additive feedback random number

gene-rator. La p´eriode est estim´ee `a 16(2

31

−1).

2. Une implantation d’un g´en´erateur de Lemer [59]. La p´eriode est 2

31

−1.

3. Mersenne Twister [60]. La p´eriode est 2

19937

−1.

Nous avons g´en´er´e 50000 listes de 60000 nombres avec chaque g´en´erateur. Pour

chaque liste, le test du χ

2

de Pearson contre la distribution uniforme a ´et´e r´ealis´e

aux seuils de 95% et 99%. La table 4.2 r´esume les r´esultats obtenus. A l’issu de ces

tests, nous avons s´electionn´e la fonction rand(). Tout d’abord parce qu’elle est la

plus sˆure (taux d’´echec le plus bas), ensuite parce qu’elle est relativement rapide.

Cependant deux probl`emes persistent :

– La p´eriode : la liste de param`etres peut ˆetre longue, et beaucoup de tirages

sont effectu´es. Nous voulons ´eviter de d´epasser la p´eriode du g´en´erateur ;

– Les interf´erences : nous voulons ´eviter de tirer les nombres al´eatoires des

diff´e-rents param`etres d’injection de faute avec le mˆeme g´en´erateur afin d’´eviter des

interf´erences. En effet nous avons v´erifi´e qu’une liste issue de rand() est bien

uniform´ement distribu´ee, mais rien ne certifie qu’une liste g´en´er´ee `a partir de

valeurs prises toutes les N g´en´erations est conforme `a la distribution.

Am´eliorations

Nous pr´esentons ci-dessous les deux am´eliorations apport´ees au g´en´erateur afin

d’adresser les deux probl`emes mentionn´es

Extension de P´eriode Les g´en´erateurs de nombres pseudo-al´eatoires sont

d´eter-ministes. Si l’on poss`ede une valeur g´en´er´ee al´eatoirement, on peut d´eterminer celle

qui va suivre. Cette propri´et´e fait qu’ils sont en g´en´eral inutilisables tel quel en

cryp-tographie. Cette propri´et´e n’est par contre pas d´erangeante pour les applications de

type Monte-Carlo.

Une autre propri´et´e est qu’ils sont p´eriodiques. Une fois la p´eriode d´epass´ee, ils

reproduisent la liste pr´ec´edemment g´en´er´ee. Une technique permettant de

s’affran-chir de cette p´eriodicit´e est la technique de self-reseeding [61]. Avant que la p´eriode

ne soit d´epass´ee, on utilise le g´en´erateur pour g´en´erer une graine qui servira `a

r´e-amorcer le g´en´erateur. On ´etend ainsi sensiblement la p´eriode. Cette technique est

illustr´ee sur la figure 4.10.

Parall´elisation Un g´en´erateur de nombres pseudo-al´eatoires est d´efini par sa

p´e-riode, son algorithme mais aussi ses variables d’´etat. Dans le cas du g´en´erateur

lin´eaire congruentiel pr´esent´e sur la figure 4.10, l’algorithme s’´ecrit :

X

n+1

= (a×X

n

+c) mod m

o`uas’appelle le multiplicateur,cl’incr´ement etm le module. Ce jeu de 3 constantes

d´efinit, avec l’algorithme, le comportement du g´en´erateur. D’o`u l’id´ee de partager

l’algorithme (le «code») mais de s´eparer les variables d’´etats. Au d´ebut de la

g´en´e-ration des param`etres d’injection, on cr´ee un nombre suffisant de jeux de variables

d’´etats qui sont associ´es `a une liste particuli`ere (instant, mot, bit). Avant de tirer

des valeurs pour une des listes, on «force» le jeu de variables d’´etat correspondant

dans l’algorithme, et on le retire pour le remplacer par le jeu de la prochaine liste.

4.3. Injection de Fautes 85

X = (2X + 1) mod 15 n+1 n Liste générée 1 3 7 0 1 3 7 0 3 7 0 1 5 11 8 17 7 0 1 9 3 ...

... Liste générée par période self−reseeding X0 = 0 + 1 X0 = 1 + 1 X0 = 17 + 1 X0 = 3 + 1 Algorithme du générateur linéaire congruentiel:

graine: X0 = 0

Fig. 4.10 – Illustration de la technique de self-reseeding `a l’aide d’un g´en´erateur

lin´eaire congruentiel. La graine initiale est X

0

= 0.

tableau de pointeurs vers les variables d’état des n générateurs

Nombre aléatoire associé au i−ème générateur lecture 0 n−1 choix du générateur i−ème algorithme variables d’état du i−ème générateur variables d’état de l’algorithme

sauvegarde copie

modification

Fig.4.11 – Sch´ema d’implantation de la fonctionmy_rand(). La partieself-reseeding

est masqu´ee.

De cette fa¸con, nous pouvons cr´eer des instances diff´erentes du mˆeme algorithme et

´eviter les probl`emes d’interf´erence : l’algorithme est partag´e, les variables d’´etat ne

le sont pas.

En pratique la fonction rand() est encapsul´ee dans la fonction my_rand() qui

prend comme param`etre le num´ero d’identification du g´en´erateur cible, copie le jeu

de variables d’´etat associ´e au g´en´erateur, appelle le g´en´erateur, sauvegarde le jeu

modifi´e par le g´en´erateur, et retourne le nombre al´eatoire renvoy´e par rand(). Cette

implantation est sch´ematis´ee sur la figure 4.11.

Synth`ese Un sch´ema de synth`ese de l’implantation du mod`ele est donn´e sur la

figure 4.12.

Dans le document INJECTION DE FAUTES SIMULANT LES EFFETS DE BASCULEMENT DE BITS INDUITS PAR RADIATION (Page 107-111)