3.3.1 Introduction
Nous pr´esentons dans cette section un m´ecanisme dynamique de contrˆole de flot d’information, bas´e sur la surveillance de l’ex´ecution du programme par un moniteur sensible aux flots. On d´ecrit un cadre de travail g´en´eralis´e pour un moniteur hybride, param´etr´e par la partie statique du m´ecanisme et par le choix de sa r´eaction en pr´esence des flots illicites. L’approche est tir´ee des travaux de Russo et Sabelfeld [24] et de ceux de Chudnov et Naumann [8]. Pour la suite de cette section, nous allons pr´esenter la s´emantique op´erationnelle des expressions et des commandes, pr´eciser le mod`ele de s´ecurit´e et examiner les configurations et le comportement du moniteur.
3.3.2 Syntaxe et s´emantique dynamique des programmes
Les programmes consid´er´es dans cette section sont ´ecrits dans le langage imp´eratif simple que nous avons pr´esent´e dans le chapitre2, auquel est ajout´e la commande output d´ecrite dans la section 3.2.1.
L’´etat du programme est repr´esent´e par les configurations de la forme hc, mi, o`u c est la commande qui reste `a ex´ecuter, et m une fonction qui associe aux variables du programme des valeurs (voir figure3.2). La s´emantique des expressions est donn´ee par une extension de la fonction m aux expressions arbitraires. Par exemple, m(e1⊕ e2) est d´efini par m(e1) ⊕ m(e2).
Les r`egles pour la s´emantique des commandes ont la forme hc, mi−→S αhc0, m0i, qui correspond `
a la plus petite ´etape entre deux ´etats du programme, o`u α est un ´ev´enement de sortie visible par le moniteur. S est l’´etiquette de la transition et traduit une sortie visible `a l’ext´erieur du programme s’il y a lieu. On parle dans ce cas de transition ´etiquet´ee. Lorsqu’une transition aboutit `a une configuration avec la commande sp´eciale stop et une certaine m´emoire m, on dit que l’ex´ecution se termine avec la m´emoire m. Par exemple, la commande if e then c1 else c2
se r´eduit `a c1 lorsque l’expression e est ´evalu´ee `a un entier non nul sous la m´emoire m. On
´
hif e then c1 else c2, mi S
−→αhc1, mi si m(e) 6= 0.
L’ex´ecution de la commande outputl(e) pour afficher la valeur de l’expression e sur le canal de
niveau de s´ecurit´e l produit une ´etiquette S. Cette ´etiquette d´eclenche l’´ev´enement d’affichage qu’on note ol(v), o`u v est la valeur de l’expression e dans la m´emoire courante.
On ´ecrira m[x 7→ v] pour signifier que la variable x est mise `a jour avec la valeur v dans la m´emoire m.
Figure 3.2 – S´emantique des commandes tir´ee de [24]
3.3.3 Le moniteur : configuration et fonctionnement
Rappelons que dans notre contexte, le moniteur est un programme qui surveille l’ex´ecution des autres programmes afin de contrˆoler le flot d’information. Le syst`eme est constitu´e du programme et du moniteur. L’´etat du syst`eme est repr´esent´e par les configurations de la forme hhc, mi|µcfgmi o`u hc, mi est la configuration du programme tel que d´ecrite dans la
repr´esente une transition du syst`eme par le symbole −→. Quand la transition produit une sortie visible, on la repr´esente par −→αo`u α est de la forme ol(v) pour un niveau de s´ecurit´e l
et une valeur v. On repr´esente une s´equence de transitions du syst`eme, possiblement vide, par : −→∗
−
→α o`u −→α est une liste de sorties produites durant l’ex´ecution. On utilise une convention
similaire pour repr´esenter une ex´ecution non surveill´ee par le moniteur par les transitions de la forme−→S α.
Les moniteurs peuvent avoir diff´erents comportements face `a une tentative d’ex´ecution des instructions non s´ecuritaires. Il est possible de mod´eliser ces comportements en utilisant les configurations du syst`eme. Arrˆeter une ex´ecution `a l’atteinte d’une instruction non s´ecuri- taire correspond `a la configuration du moniteur qui est incapable de faire une progression. Le moniteur peut supprimer une sortie ou remplacer le contenu par une valeur par d´efaut quand la s´ecurit´e est compromise. On mod´elise ces cas par une configuration du syst`eme qui peut produire une transition non ´etiquet´ee (aucune sortie visible), ou qui peut d´eclencher un ´
ev´enement d’affichage OL(d ) pour une valeur par d´efaut d.
D´efinition 6. Sˆuret´e d’un moniteur
On dira qu’un moniteur est sˆur s’il n’accepte aucune ex´ecution non s´ecuritaire d’un programme sans modifier ce dernier.
Cette condition de sˆuret´e du moniteur est suffisante pour en faire un moniteur coh´erent. En effet, pour ˆetre coh´erent, un moniteur en plus d’ˆetre sˆur, ne doit pas changer la s´emantique d’un programme qu’il modifie. Nous avons vu que le moniteur ne peut modifier un programme qu’au niveau de ses sorties visibles, le risque d’alt´erer la s´emantique est alors tr`es limit´e.
3.3.4 La condition de s´ecurit´e par rapport au moniteur
Le mod`ele de s´ecurit´e comprend le treillis constitu´e de l’ensemble des niveaux de s´ecurit´e muni d’une relation d’ordre, de l’´etiquetage initial des variables du programme Γ0et de l’attribution
d’un niveau de s´ecurit´e `a chaque canal de sortie. On suppose que l’attaquant connaˆıt ou fournit les programmes et a une capacit´e de raisonnement `a propos de la s´emantique du programme. Toutefois, il n’a pas de contrˆole sur les m´ecanismes de surveillance de l’ex´ecution des programmes. Il ne peut ni observer directement les valeurs en m´emoire, ni influencer le comportement du syst`eme autrement que de fournir les programmes et y introduire des entr´ees non secr`etes, qui sont les valeurs initiales des variables de bas niveau de s´ecurit´e. On suppose que l’attaquant peut observer des sorties sur les canaux `a un niveau de s´ecurit´e sp´ecifique ou plus bas et qu’il est insensible `a la consommation de la puissance de calcul de l’ordinateur, du temps d’ex´ecution et de tout autre canal cach´e.
D´efinition 7. M´emoires L-´equivalentes
On dit que deux m´emoires sont L-´equivalentes si elles co¨ıncident sur leur partie visible par un observateur public, c’est-`a-dire que les variables publiques ont toutes les mˆemes valeurs dans les deux m´emoires.
Observons que cette d´efinition est li´ee `a un environnement de typage donn´e Γ o`u on peut iden- tifier le niveau de s´ecurit´e de chaque variable. Soient m1 et m2 deux m´emoires L-´equivalentes
par rapport `a l’environnement Γ, on note m1 ≡Γm2
Pour la formulation de la propri´et´e de s´ecurit´e, on se restreindra `a un treillis `a deux niveaux de s´ecurit´e, un niveau public et un niveau priv´e. On suppose donc que l’auteur de l’attaque n’observe que les sorties publiques et la partie publique de la m´emoire initiale.
Condition de s´ecurit´e
La condition de s´ecurit´e impose que, en pr´esence du moniteur, si deux ex´ecutions quelconques commencent avec deux m´emoires initiales L-´equivalentes et ´emettent deux s´equences de sorties publiques, alors les deux s´equences doivent ˆetre identiques. Sinon, l’une doit ˆetre une sous- s´equence de l’autre, et l’ex´ecution qui a produit la plus courte s´equence ne doit plus produire d’autres sorties publiques. Plus formellement, en notant :
– L(−→α ) la projection sur l’ensemble des sorties publiques de la liste des ´ev´enements −→α , – |−→α | le nombre d’´ev´enements dans la liste −→α et
– hhc, m1i|µcfgmi ⇒ H une ex´ecution en pr´esence du moniteur qui ne produit aucune
sortie publique ;
soit µ un moniteur, m1 et m2 deux m´emoires et un environnement de typage Γ, tel que
m1 ≡Γm2. Si hhc, m1i|µcfgmi −→∗−α→ 1 hhc 0, m0 1i|µcfgm10i, alors ∃c00, m02, cfgm20. hhc, m2i|µcfgmi −→∗−α→ 2 hhc 00, m0 2i|µcfgm20i. avec : – |L(−α→2)| ≤ |L(−α→1)| et – si |L(−α→2)| = |L(−α→1)| alors L(−α→2) = L(−α→1)
– si |L(−α→2)| < |L(−α→1)| alors L(−α→2) est une sous-s´equence de L(−α→1)et
hhc00, m02i|µcfgm20i ⇒ H.
Cette condition veut que deux ex´ecutions qui commencent avec deux m´emoires L-´equivalentes, produisent des sorties publiques identiques si elles se terminent. C’est une autre formulation de la non-interf´erence non sensible `a la terminaison. Le moniteur n’est pas sensible `a la terminaison ou `a la non-terminaison du programme.
Condition de permissivit´e
Pour ´etablir la coh´erence de leur moniteur, Russo et Sabelfeld [24] s’appuient sur le syst`eme de types sensible aux flots de Hunt et Sands [16] dont la coh´erence a ´et´e rigoureusement d´emontr´ee. Ceci est tout `a fait raisonnable puisque leur moniteur imite le fonctionnement dudit syst`eme de types. Dans l’article o`u Hunt et Sands d´evoilent leur syst`eme de type [16], ces derniers d´emontrent que dans un contexte sensible aux flots, il n’est pas possible pour un moniteur purement dynamique d’ˆetre `a la fois sˆur et plus permissif que leur syst`eme de types. En particulier, ils ´etablissent que la sensibilit´e aux flots introduit un autre canal de fuite pour une ex´ecution en pr´esence d’un moniteur purement dynamique. Ce canal peut ˆetre exploit´e par un attaquant, comme on peut voir dans l’exemple suivant. Consid´erons le programme :
1 : a := 1; 2 : t := 0;
3 : if s then t := 1 else skip; 4 : if t 6= 1 then a := 0 else skip; 5 : outputL(a);
On suppose que ce programme s’ex´ecute avec un environnement initial o`u les variables a et t sont publiques et la variable s est secr`ete.
Ce programme n’est pas s´ecuritaire. En effet, un attaquant qui peut observer la valeur de la variable a `a la fin de l’ex´ecution peut d´eduire celle du secret contenu dans s. Si a se termine avec la valeur 1, c’est que t vaut 0 et donc que s vaut 1. Si a se termine avec la valeur 0, c’est que t vaut 1 et donc que s vaut 0.
Observons que ce programme est rejet´e par le syst`eme de types sensible aux flots d´ecrit dans la section 3.2.1. En effet, apr`es l’instruction 3, la variable t devient secr`ete et apr`es l’instruction 4, la variable a le devient aussi. L’instruction outputL(a) ne peut donc ˆetre typ´ee
et le programme est donc rejet´e.
Supposons un simple moniteur purement dynamique qui garde les traces des niveaux de s´ecurit´e des variables et les met `a jour de la mani`ere suivante : le niveau de s´ecurit´e de la variable est mis `a H dans le cas o`u l’expression de droite de l’affectation contient une variable de niveau H ou que l’affectation se passe dans un contexte de niveau H. Le niveau de s´ecurit´e de la variable affect´ee est mis `a L dans le cas contraire.
En ex´ecutant le programme pr´ec´edent en pr´esence de ce moniteur, ce dernier met les niveaux des variables a et t `a L apr`es les deux premi`eres instructions, car les deux variables re¸coivent des informations de niveau L (les constantes). Si s est diff´erent de 0, le niveau de t devient H apr`es l’ex´ecution du premier bloc conditionnel. La condition de branchement du second bloc devient fausse et la branche a := 0 n’est pas prise. Le moniteur accepte donc cette ex´ecution.
Si s est ´egal 0, le niveau de la variable t reste L et son contenu vaut encore 0. Le moniteur laisse alors ex´ecuter le second bloc conditionnel mˆeme si la branche du then est prise, parce que sa garde n’est pas de niveau H. Comme r´esultat, la fuite du secret de s vers a ´echappe au moniteur.
Pour r´epondre au besoin de disposer d’un moniteur sˆur et au moins aussi permissif que le syst`eme de types de Hunt et Sands, Russo et Sabelfeld proposent un moniteur hybride [24].
`
A l’oppos´e d’un moniteur purement dynamique, celui-ci prend en compte les r´esultats de l’analyse statique dans son analyse de s´ecurit´e. C’est le moniteur hybride sensible aux flots. La condition de permissivit´e veut que le moniteur soit au moins aussi permissif que le sys- t`eme de types de Hunt et Sands. Autrement dit, si un programme est bien typ´e dans ledit syst`eme de types, le moniteur ne modifie pas son comportement au cours de l’ex´ecution. Plus formellement, soit cfgm0 l’´etat initial du moniteur, si on a
pc ` Γ{c}Γ0 et hc, mi−→S ∗−→α hc0, m0i
alors,
∃ cfgm0, c00. hhc, m1i|µcfgm0i −→→−∗α hhc00, m0i|µcfgm0i.
Avec l’hypoth`ese que le moniteur transforme le programme pour faciliter son analyse du flot d’information, et que la commande stop est invariable par cette transformation, la commande c00 est la transform´ee de c0 par le moniteur.
Remarquons que cette condition impose que la liste de sortie −→α soit identique pour les deux ex´ecutions (en la pr´esence et en l’absence du moniteur).
3.3.5 Configuration du moniteur hybride, formulation de Russo et Sabelfeld
L’´etat du moniteur est repr´esent´e par les configurations de la forme hΓ, Γsi o`u Γ est un
environnement de typage et Γs une pile d’environnement de typage. Pour prendre en compte
la sensibilit´e aux flots, l’environnement Γ, qui associe `a chaque variable un niveau de s´ecurit´e, change au cours de l’ex´ecution du programme. On consid`ere donc Γ comme faisant partie de l’´etat du moniteur. Le rˆole de Γs dans cette configuration sera pr´ecis´e plus loin.
Le moniteur effectue des transitions de la forme hΓ, Γsi α
−→γ hΓ0, Γ0si, o`u α parcourt les ´ev´e- nements internes produits par les commandes du programme et γ est l’´ev´enement ordinaire ´emis par le moniteur en r´eponse `a l’´ev´enement interne α. L’´ev´enement γ peut ˆetre une sortie visible au cas o`u la commande courante serait un output. Dans l’autre cas, γ sera toujours une liste vide d’´ev´enements not´ee . Les ´ev´enements internes r´egulent la communication entre
le programme et le moniteur. Intuitivement, chaque fois qu’une commande d´eclenche un ´ev´e- nement interne α, le moniteur permet `a l’ex´ecution de se poursuivre en toute s´ecurit´e s’il est lui-mˆeme en mesure d’effectuer la transition ´etiquet´ee α. Cette r`egle se formalise comme suit :
hc, mi−→ hcα 0, m0i hΓ, Γsi−→α γ hΓ0, Γ0si
hhc, mi|µ Γ, Γsi−→ hhcγ 0, m0i|µ Γ0, Γ0 si
.
Ceci stipule que chaque α est synchronis´e avec le moniteur et l’´ev´enement γ est la r´eponse. En pr´esence des instructions non s´ecuritaires, le moniteur peut d´ecider d’arrˆeter ou de modifier l’ex´ecution du programme. S’il y a modification, les ´ev´enements α et γ seront diff´erents. Ces deux ´ev´enements sont consid´er´es comme l’interface du moniteur.
´
Ev´enements internes transmis par le programme au moniteur
La table 3.1pr´esente la s´emantique des ´etapes unitaires de g´en´eration d’´ev´enements pour un langage imp´eratif simple. On peut voir que chaque commande envoie un ´ev´enement interne particulier au moniteur :
– La commande skip envoie l’´ev´enement s,
– L’affectation de e `a x envoie l’´ev´enement a(x, e), – La commande if e then c1 else c2 envoie :
– l’´ev´enement b(e, c2) si m(e) 6= 0 et
– l’´ev´enement b(e, c1) si m(e) = 0,
– La commande while e do c envoie : – l’´ev´enement b(e, skip) si m(e) 6= 0 et – l’´ev´enement b(e, c) si m(e) = 0, – La commande end envoie l’´ev´enement f ,
– La commande outputl(e) envoie l’´ev´enement ol(e, v) .
Les param`etres du moniteur : la pile Γs et les fonctions lev et update
Avant de pr´esenter la configuration du moniteur, pr´ecisons le sens de la pile Γset des fonctions
lev(e, Γ) et updatel(c) dans cette configuration.
La pile Γs
La pile des environnements de typage joue le mˆeme rˆole que pc dans le syst`eme de types. Lorsque la pile est vide (Γs = ), cela indique que l’instruction courante n’est pas dans
un contexte de haut niveau. Avoir Γs = correspond `a avoir pc = L. D’autre part, Γs 6=
implique que l’instruction courante est dans un contexte de haut niveau (c’est-`a-dire pc = H). En outre, la longueur de Γsindique la profondeur de la branche et chaque ´el´ement de la liste
hskip, mi−→ hstop, mis m(e) = v
hx := e, mi−−−→ hstop, m[x 7→ v]ia(x,e) hc1, mi α −→ hstop, m0i hc1; c2, mi−→ hcα 2, m0i hc1, mi−→ hcα 0 1, m0i c016= stop hc1; c2, mi α −→ hc01; c2, m0i m(e) 6= 0 hif e then c1 else c2, mi
b(e,c2)
−−−−→ hc1; end, mi
m(e) = 0 hif e then c1 else c2, mi
b(e,c1)
−−−−→ hc2; end, mi
hend, mi−→ hstop, mif m(e) 6= 0
hwhile e do c, mi−−−−−→ hc; end; while e do c, mib(e,skip) m(e) = 0
hwhile e do c, mi−−−→ hend, mib(e,c) m(e) = v
houtputl(e), mi ol(e,v)
−−−−→ hstop, mi
Table 3.1 – S´emantique des commandes avec ´ev´enements internes tir´ee de [24]
if secret then (if secret then x := 0 else skip) else skip;
la longueur de Γs est de deux au moment de l’ex´ecution de l’affectation x := 0 et son contenu
est l’analyse statique des deux commandes skip. La profondeur de la branche permet au moniteur de d´etecter le point de branchement le plus `a l’ext´erieur dont la garde implique un secret. L’information est utilis´ee pour fournir la sensibilit´e aux flots aux variables `a l’int´erieur des contextes de haut niveau.
Les fonctions lev et update
La fonction lev(e, Γ) (de l’anglais level ) retourne le niveau de s´ecurit´e de l’expression e en consid´erant l’environnement de typage Γ. La fonction updatel(c) retourne un environnement
hΓ, Γsi s −→ hΓ, Γsi hΓ, Γsi a(x,e) −→ hΓ[x 7→ lev(e, Γ) t lev(Γs)], Γsi (b-low) lev(e, Γ) = L hΓ, ib(e,c)−→ hΓ, i (b-high) lev(e, Γ) = H ∨ Γs6= hΓ, Γsib(e,c)−→ hΓ, updateH(c) : Γsi (j-high) hΓ, Γ0 : Γsi f −→ hΓ t Γ0, Γsi (j-low) hΓ, i−→ hΓ, if
Table 3.2 – S´emantique op´erationnelle du moniteur tir´ee de [24]
au niveau de s´ecurit´e l, o`u l un ´el´ement quelconque du treillis de s´ecurit´e. S´emantique op´erationnelle du moniteur
La table 3.2pr´esente les diff´erentes r´eactions du moniteur `a la suite des ´ev´enements internes produits par l’ex´ecution.
– L’´ev´enement s, d´erivant de l’ex´ecution de la commande skip, est toujours accept´e par le moniteur sans aucun changement de configuration.
– L’´ev´enement a(x, e), issu de l’ex´ecution de l’affectation x := e, met le niveau de s´ecurit´e de x `a lev(Γs) t lev(e, Γ). La fonction lev(Γs) retourne H lorsque Γs est diff´erent de la
liste vide , sinon, elle retourne L.
– L’´ev´enement b(e, c), issu d’une instruction conditionnelle ou d’une boucle, indique au moniteur qu’il y a eu branchement sur l’expression e et que la branche c est celle qui n’est pas prise. Par exemple, la commande if e then x := 1 else x := 2 d´eclenche l’´ev´enement b(e, x := 2) si l’expression e est ´evalu´ee `a vraie. Connaissant la branche non prise par l’ex´ecution, le moniteur peut traiter efficacement les blocs conditionnels et les boucles r´ep´etitives. En fonction du niveau de s´ecurit´e du contexte courant, le moniteur r´eagit de deux mani`eres :
– La r`egle (b-low) est appliqu´ee lorsqu’on branche dans un contexte de bas niveau de s´ecurit´e. Il faut constater que Γs vaut avant et apr`es la transition.
– La r`egle (b-high) est appliqu´ee quand on branche sur une instruction condition- nelle ou sur une boucle de haut niveau (lev(e, Γ) = H), ou lorsqu’on est `a l’int´erieur d’un contexte de haut niveau (lev(Γs) = H). Le moniteur applique alors l’analyse
pile Γs un nouvel environnement dans lequel les variables qui seraient modifi´ees
dans la branche non prise avec la fonction updateH(c) ont pour niveau H. Cet
environnement de typage est conserv´e par le moniteur jusqu’`a l’atteinte du point de branchement, o`u il est pr´elev´e de la pile par la r`egle (j-high) `a la r´eception de l’´ev´enement f par le moniteur.
– L’´ev´enement f , d´erivant de l’ex´ecution de la commande end, indique au moniteur le point de sortie d’un bloc conditionnel ou d’une boucle. Le moniteur r´eagit de deux mani`eres, en fonction du niveau de s´ecurit´e du contexte courant :
– La r`egle (j-high) est appliqu´ee si on est dans un contexte de haut niveau. Elle se sert de l’information obtenue de l’analyse statique des branches non prises (Γ0) pour ´
elever le niveau de s´ecurit´e des variables dans Γ, en calculant Γ t Γ0. L’op´eration t entre les environnements est d´efinie comme dans la sous-section 3.2.1.
– La r`egle (j-low) est appliqu´ee `a l’arriv´ee du point de jointure dans un contexte de bas niveau. Observez qu’il n’y a aucun changement dans l’´etat du moniteur. C’est au niveau de l’application de la r`egle (j-high) que les r´esultats du typage sont mis `a contribution. L’environnement de typage Γ0qui est pr´elev´e de la pile Γspour ˆetre fusionn´e avec
l’environnement courant Γ, est construite avec la r`egle (b-high) par la fonction updatel(c).
C’est donc tout simplement le r´esultat de l’analyse statique de la branche non prise par l’ex´ecution du programme. Un moniteur purement dynamique ignorerait tout de la branche