3.2.1 Le syst`eme de types de Hunt et Sands
Introduction
C’est en 1996 que Volpano propose pour la premi`ere fois un syst`eme de types pour l’analyse de la s´ecurit´e du flot d’information [32]. Dix ans plus tard, Hunt et Sands [16] proposent un nouveau syst`eme de types pour l’analyse de la s´ecurit´e du flot d’information. La nouveaut´e de ce dernier par rapport `a celui de Volpano r´eside dans la prise en compte de la sensibilit´e aux flots dans l’analyse. Le syst`eme de types est d´efini pour un langage imp´eratif simple, puis ´etendu `a un langage avec la commande output par Russo et Sabelfeld.
L’approche en bref
On suppose que le programme est ´ecrit dans le langage d´ecrit dans le paragraphe 2.3.3. Soit Var l’ensemble fini des variables du programme, on attribue initialement `a chaque ´el´ement de Var un type qui est une ´etiquette correspondant `a son niveau de s´ecurit´e, ce qui d´efinit une fonction entre l’ensemble des variables du programme et l’ensemble des niveaux de s´ecurit´e not´ee Γ. On note L l’ensemble des niveaux de s´ecurit´e et on d´efinit sur L une relation d’ordre partiel not´ee v. On montre que le couple (L, v) poss`ede les propri´et´es d’un treillis telles que d´ecrites dans2.3.1. Ce sera dans la suite notre treillis de s´ecurit´e.
Rappelons que dans un syst`eme de types insensible aux flots comme celui de Volpano et Smith [32], on attribue aussi des niveaux de s´ecurit´e aux variables du programme et, lorsqu’on affecte une expression `a une variable sous la forme x := Exp, toutes les variables de Exp doivent avoir un niveau de s´ecurit´e plus bas ou ´egal `a celui de x. De plus, si l’affectation a lieu dans une branche d’un bloc conditionnel ou dans une boucle, le niveau de x doit ˆetre au moins
aussi haut que celui de toutes les variables des expressions de garde. L’id´ee derri`ere le mod`ele de Hunt et Sands est de ne pas bloquer un flot (implicite ou explicite) d’une variable de haut niveau vers une autre variable dont le niveau est plus bas. Ils proposent de laisser aller le flot, mais de s’assurer que le contenu de la variable nouvellement affect´ee ne sera pas r´ev´el´e par la suite. Pour ce faire, ils modifient le niveau de s´ecurit´e de cette derni`ere variable, pour le mettre `a la hauteur du secret qu’elle contient. Afin de tenir compte de la sensibilit´e aux flots dans un bloc conditionnel ou une boucle, Hunt et Sands introduisent une nouvelle variable pc, qui garde en tout temps le niveau de s´ecurit´e du contexte. Ceci va permettre de bien contrˆoler les changements des niveaux de s´ecurit´e du contexte pour ´eviter les flots implicites ill´egaux. Par exemple, consid´erons le treillis de s´ecurit´e `a deux points {L v H}. Lorsqu’on affecte une expression `a une variable x := y + x, si x est de type L avant l’affectation, et y de type H, alors apr`es l’affectation x doit prendre le type H. Plus g´en´eralement, si l’affectation x := Exp se fait dans un contexte de niveau pc, le niveau de la variable affect´ee x devient la borne sup´erieure de pc et du niveau de l’expression affect´ee.
Le syst`eme de types
Le syst`eme de types d´efinit les jugements de la forme : pc ` Γ {C} Γ0, o`u pc est le niveau de s´ecurit´e du contexte, Γ et Γ0 sont des fonctions d´efinies de l’ensemble des variables vers le treillis de s´ecurit´e. Le jugement stipule que le niveau de s´ecurit´e des variables est d´etermin´e par Γ avant l’ex´ecution de la commande C, et Γ0 apr`es son ex´ecution. Ces jugements utilisent une extension de Γ aux expressions, d´efinie pour une expression e par : Γ(e) est ´egale `a la borne sup´erieure des Γ(x), pour toutes les variables x impliqu´ees dans la d´efinition de e. Ces jugements utilisent aussi la variable pc. Au d´ebut du processus de typage d’un programme, la variable pc est initialis´ee avec le plus petit ´el´ement du treillis de s´ecurit´e. Son contenu change de valeur d`es qu’on entre ou sort d’un bloc conditionnel ou d’une boucle. `A l’entr´ee, la nouvelle valeur de pc devient la borne sup´erieure de son ancienne valeur et du niveau de s´ecurit´e de l’expression de garde. `A la sortie, la variable pc reprend la valeur qu’elle avait avant l’entr´ee dans ledit bloc.
Les r`egles de typage des commandes s’´enoncent comme suit :
skip, end et stop
Les commandes skip, end et stop ne modifient pas l’environnement de typage. On a :
(skip)
Γ{skip}Γ (ST OP ) Γ{stop}Γ (EN D) Γ{end}Γ
L’affectation
(aff) Γ ` E : t
pc ` Γ{x := E}Γ[x 7→ pc t t].
La r`egle pour les affectations capture l’essence mˆeme de la sensibilit´e aux flots. Une affectation v´erifie toujours les types, mais le niveau de s´ecurit´e de la variable affect´ee est mis `a jour avec la borne sup´erieure de pc et le niveau de l’expression.
La s´equence
La r`egle pour la s´equence s’´enonce :
(seq) pc ` Γ{C1}Γ
0 pc ` Γ0{C 1}Γ00
pc ` Γ{C1; C2}Γ00
.
Pour typer la s´equence C1; C2, on commence par typer C1 en partant de l’environnement Γ
pour aboutir `a l’environnement Γ0, puis on type C2 en partant de Γ0 pour aboutir `a l’environ-
nement d’arriv´ee Γ00.
Le If Then et le While
Les r`egles pour ces deux commandes utilisent une extension de la d´efinition de la relation d’ordre v aux environnements de typage. Cette extension s’´enonce comme suit :
(sub) Dom(Γ1) = Dom(Γ2) ∀x ∈ Dom(Γ1).Γ1(x) v Γ2(x) Γ1v Γ2
.
Elle stipule que Γ1 v Γ2 si les deux environnements ont le mˆeme domaine et que pour tout
´el´ement x du domaine, on a Γ1(x) v Γ2(x).
La r`egle pour le if s’´enonce comme suit :
(if) Γ ` E : t pc t t ` Γ{Ci}Γi Γiv Γ
0 i = 1, 2
pc ` Γ{if E C1 C2}Γ0
.
Elle stipule que le jugement pc ` Γ{if E C1 C2}Γ0 est valide si les deux conditions suivantes
sont r´eunies pour chaque i (i = 1,2) :
– Le jugement pc t t ` Γ{Ci}Γi, o`u t est le type de l’expression e dans l’environnement,
est valide. – Γiv Γ0.
La r`egle pour le while s’´enonce comme suit :
(where) Γ v Γ
0 Γ0` e : t pc t t ` Γ0{C}Γ00 Γ00 v Γ0
Elle stipule que le jugement , pc ` Γ{while E do C}Γ0 est valide si les conditions suivantes sont r´eunies :
– Il existe un environnement de typage Γ00tel que Γ00v Γ0 et le jugement pc t t ` Γ0{C}Γ00, o`u t est le type de l’expression e dans l’environnement Γ0, est valide.
– Γ v Γ0.
D’apr`es ces r`egles, une commande C est bien typ´ee si pour un certain niveau de s´ecurit´e du contexte pc, et ´etant donn´es deux environnements de typage Γ et Γ0, il existe une d´erivation `
a partir des r`egles de typage qui rend valide le jugement pc ` Γ{C}Γ0. La r`egle de d´erivation assure que seules les variables qui se terminent dans Γ0 avec un niveau plus grand ou ´egal `
a pc peuvent ˆetre mises `a jour par le programme C. De ce fait, dans le triplet pc, Γ et Γ0, l’environnement Γ0 n’est pas arbitraire, mais doit respecter cet invariant par rapport `a l’environnement initial Γ pour que la commande C soit bien typ´ee. En d’autres termes, la propri´et´e de non-interf´erence est traduite par des contraintes impos´ees `a l’environnement d’arriv´ee Γ0 par rapport `a l’environnement de d´epart Γ.
Version algorithmique du syst`eme de types
Dans cette section, on introduit une variante des r`egles de typage qui calcule le plus petit environnement Γ0 ´etant donn´es un programme C et un environnement initial Γ. Les r`egles pour le skip, l’affectation et la s´equence ne changent pas dans cette version. Pour ´etablir les nouvelles r`egles pour le if et le while, on aura besoin d’´etendre la d´efinition de l’op´erateur t aux environnements de typage. Cette extension s’´enonce comme suit :
Γ1t Γ2(x) = Γ1(x) si x ∈ dom(Γ1) \ dom(Γ2) Γ2(x) si x ∈ dom(Γ2) \ dom(Γ1) Γ1(x) t Γ2(x) sinon.
Dans les nouvelles r`egles, on utilise le symbole `A comme version algorithmique de `, pour
marquer la diff´erence entre les deux. La r`egle pour le if s’´enonce comme suit :
Γ ` E : t pc t t `A Γ{Ci}Γ0i i = 1, 2
pc `A Γ{if E C
1 C2}Γ0
Γ0= Γ01t Γ02.
La r`egle pour le while s’´enonce comme suit :
Γ0i` E : ti pc t ti `AΓ0i{C}Γ00i 0 6 i 6 n
pc `AΓ{while E do C}Γ0 n
Les r`egles sont d´eterministes, en ce sens que pour un programme C et ´etant donn´es un environnement de typage initial Γ et un niveau de contexte pc, on a exactement une d´erivation possible Γ0 qui rend valide le jugement pc ` Γ{C}Γ0.
On note que l’unicit´e n’est pas tout `a fait absolue, car la r`egle pour le while permet `a la chaˆıne d’environnement Γ00, Γ01, ..., Γ0n d’ˆetre ´etendue arbitrairement en ajoutant des r´ep´etitions non n´ecessaires. On suppose que l’entier n est choisi de fa¸con minimale.
L’existence et l’unicit´e d’une telle d´erivation sont formalis´ees par : Th´eor`eme 4. Exactitude de l’algorithme
Pour tout treillis de s´ecurit´e L, pour tout programme C, on a :
(1) Pour tout p ∈ L et Γ un environnement, il existe un autre environnement Γ0 unique tel que p `A Γ{C}Γ0. De plus, en notant AC(p,Γ) la fonction qui qui associe `a Γ cet unique Γ0 pour un p donn´e, la fonction AC(p,Γ) est monotone.
(2) Si p ` Γ{C}Γ0, alors AC(p,Γ) v Γ0. (3) Si p `A Γ{C}Γ0, alors p ` Γ{C}Γ0. Corollaire 5.
AC(p,Γ) est le plus petit Γ0 tel que p ` Γ{C}Γ0.
Cette r`egle sp´ecifie implicitement un calcul du point fixe.
La version algorithmique permet d’affirmer qu’´etant donn´e un environnement de typage Γ, tout programme C est typable pour un certain environnement Γ0. Ce qui veut dire qu’on peut toujours avoir une description valide du flot d’information dans le programme. Cela n’implique pas que tous ces flots d’information sont ceux qu’on d´esire ! Le caract`ere s´ecuritaire d´epend du niveau de s´ecurit´e que l’on souhaite avoir dans Γ0. Supposons par exemple un programme C avec une seule instruction z := x + y et un environnement de typage initial Γ avec les variables x publique et y priv´ee. Supposons que z est une variable qui sera visible par le public lorsque le programme va se terminer. Un environnement de typage final dans lequel la variable z est publique sera s´ecuritaire, alors qu’un autre environnement final dans lequel z sera secret ne sera pas s´ecuritaire. Une mani`ere de rendre ceci plus explicite serait d’ajouter au langage la primitive de sortie output. La r`egle pour cette commande va permettre de bloquer les programmes non typables.
Extension du langage avec la commande Output ´
Etant donn´es une expression e et un canal C, la commande outputC(e) envoie sur le canal
C le r´esultat de l’´evaluation de l’expression e. Pour simplifier, on identifiera souvent le canal avec son niveau de s´ecurit´e. Pour un ´el´ement quelconque l du treillis L, on ´ecrira outputl(e)
Le langage cible du syst`eme de types de Hunt et Sands [16] n’inclut pas la commande output. C’est Russo et Sabelfeld [24] qui ajoutent par la suite au syst`eme de types la r`egle pour le typage de cette commande dans leurs travaux o`u ils transcrivent les r`egles de typage de Hunt et Sands dans le comportement d’un moniteur pour le contrˆole du flot d’information.
La r`egle pour la commande output s’´enonce comme suit : Γ ` e : t pc t t v l pc ` Γ{outputl(e)}Γ
.
D’apr`es cette r`egle, la commande ne modifie pas l’environnement de typage initial. Elle exige que le niveau de s´ecurit´e du canal soit plus grand que la borne sup´erieure du niveau de s´ecurit´e de l’expression e et pc. Dans le cas d’un treillis `a deux niveaux, L pour public et H pour secret, on aura deux canaux d’affichage. Seul le canal public sera visible par un attaquant. Avec cette r`egle, les programmes malicieux comme outputl(secret) ou if secret then outputl(v) else skip
seront rejet´es.
Cette r`egle permettra de pi´eger les programmes non s´ecuritaires lors de la tentative d’ex´ecution de la commande d’affichage. Elle joue un rˆole particuli`erement d´eterminant dans l’instrumen- tation du code comme on le verra dans la suite.
3.2.2 Le syst`eme de types de Desharnais et al.
Introduction
Ce syst`eme de types a ´et´e propos´e en 2012 par Desharnais et al. [12]. Les auteurs partent du constat que l’analyse statique rejette souvent un programme tout simplement parce qu’il n’est pas possible d’´etablir avec pr´ecision le niveau de s´ecurit´e de certaines variables ou autres entit´es du programme. C’est dans le but de r´eduire l’impact de cette approximation qu’un nouvel ´el´ement est ajout´e `a l’ensemble {L, H} des niveaux de s´ecurit´e, en l’occurrence le niveau U pour incertain (de l’anglais uncertain). Lors de l’analyse statique, ce niveau de s´ecurit´e est attribu´e aux variables du programme dont le niveau ne peut ˆetre d´etermin´e qu’`a l’ex´ecution.
Langage de programmation et propri´et´e de s´ecurit´e
Le langage consid´er´e est une extension de celui d´ecrit au paragraphe 2.3.3. Les nouvelles primitives ajout´ees sont utilis´ees pour envoyer ou recevoir de l’information sur les canaux. En effet, des constantes de type « nom de canal » sont ajout´ees `a la syntaxe du langage. Ce nouveau type garde le nom de tous les canaux de communication par lesquels le programme peut ´echanger avec l’ext´erieur, comme un fichier d’entr´ee ou de sortie, un clavier, un moniteur ou toute autre p´eriph´erie sur le r´eseau. Le programme peut ainsi lire la valeur x1 sur le canal
une variable de nom de canal, la primitive receiven est utilis´ee `a la place de receivec. De la
mˆeme fa¸con, le programme peut envoyer l’information x1 sur le canal x2 avec la commande
send x1 to x2. La commande send met `a jour le contenu du canal dont la variable de nom de
canal x2 contient le nom. Ce nom n’est donc pas modifi´e par la commande send.
La condition de s´ecurit´e s’´enonce comme suit : les sorties sur les canaux publics ne doivent pas ˆetre influenc´ees par les entr´ees `a partir des canaux priv´es. Autrement, une personne qui observe les sorties publiques ne peut deviner ni en partie ni en entier le contenu des entr´ees priv´ees. Le treillis de s´ecurit´e est constitu´e de l’ensemble {L, U, H} muni de la relation d’ordre v d´efini par L v U v H.
Le syst`eme de types
Le typage d’un programme se fait par l’attribution d’un type aux variables, aux noms de canaux et aux commandes. Une variable peut ˆetre typ´ee avec la valeur τ val, ce qui signifie qu’elle a un contenu dont le niveau de s´ecurit´e est τ , avec τ ∈ {L, U, H}. Une variable nom de canal peut ˆetre typ´ee avec la valeur τ chan, ce qui signifie qu’elle peut conserver l’information dont le niveau de s´ecurit´e est τ ou inf´erieur. Comme dans le syst`eme de types de Volpano et al. [32], une commande peut ˆetre associ´ee `a un type de la forme τ cmd, ce qui garantit que la commande ne peut que v´ehiculer un flot vers un canal de type τ chan ou sup´erieur. Le syst`eme de types utilise aussi une variable particuli`ere, en l’occurrence instr, unique pour un programme et dont le contenu peut prendre une des valeurs L, U ou H. Le contenu de instr indique si le programme aura besoin d’ˆetre instrument´e ou pas. Cette variable est initialis´ee avec la valeur L. Si `a la fin du typage du programme, la variable instr contient comme valeur U ou H, alors une instrumentation du programme est n´ecessaire. Sinon, pas besoin d’instrumenter le programme. Pour les besoins du programme d’instrumentation, une extension de l’environnement de typage inclut la variable instr typ´ee avec son contenu. Le syst`eme de types d´efinit les jugements de la forme Γ, pc ` p : ρ, Γ0; o`u pc est le niveau de s´ecurit´e du contexte, Γ et Γ0sont deux environnements de typage qui associent les variables du programme `a un type de la forme τ val ou τ chan. La variable pc garde la mˆeme signification que dans le mod`ele de Hunt et Sands. Le jugement stipule qu’avec un environnement de typage initial Γ et dans un contexte de niveau pc, le programme p a pour type ρ, et son ex´ecution aboutit `a l’environnement de typage Γ0. Ces jugements utilisent le type d’une expression, qui correspond `a son niveau de s´ecurit´e tel que d´efini dans la section 3.2.1.
Les r`egles de typage sont repr´esent´ees dans la figure3.1.
On suppose au d´ebut du typage que toutes les constantes enti`eres sont de type L val et que la commande skip est de type H cmd.
Figure 3.1 – R`egles de typage du mod`ele Desharnais et al. tir´ees de [12]
Pour que le syst`eme de types reste sensible aux flots, les r`egles (ASSIGN -VAL S ) et (RECEIVE - CONTENT S ) calculent d’abord la borne sup´erieure entre le niveau de l’expression `a droite de l’affectation ou la valeur re¸cue du canal d’une part et le niveau du contexte pc d’autre part. Le r´esultat associ´e `a l’´etiquette val est attribu´e au type de la variable modifi´ee. La commande est aussi typ´ee avec ce mˆeme r´esultat, associ´e cette fois `a l’´etiquette cmd.
Les r`egles (ASSIGN -CHAN S ) et (RECEIVE -NAME S ) modifient toutes les deux le contenu d’une variable de nom de canal. Pour typer ces deux commandes, les auteurs d´efinissent une autre relation d’ordre sur l’ensemble des niveaux de s´ecurit´e not´ee et d´efinie par :
Cette relation, qui peut ˆetre interpr´et´ee comme « peut ˆetre v », est utilis´ee pour identifier et empˆecher seulement les flots de H vers L. La r`egle (ASSIGN -CHAN S ) affecte `a une variable de nom de canal un nom de canal dont le type τ chan est connu, dans un contexte donc le niveau est pc. La r`egle impose que pc τ pour que cette affectation soit possible et met `a jour l’environnement de typage comme suit : le type de la variable de nom de canal est modifi´e avec la valeur τ chan (en accord avec la sensibilit´e aux flots) et la variable instr re¸coit comme valeur la borne sup´erieure de τ et pc.
La commande receiven affecte `a une variable de nom de canal un nom de canal lu sur un
autre canal. Le niveau du canal dont le nom vient d’ˆetre lu ne sera connu qu’`a l’ex´ecution. La r`egle (RECEIVE -NAME S ) impose que pc τ pour que cette op´eration soit possible. Si c’est le cas, l’environnement de typage est mis `a jour de fa¸con suivante : le type de la variable qui vient d’ˆetre modifi´ee devient U chan et la variable d’instrumentation instr re¸coit comme valeur la borne sup´erieure de τ et pc.
Remarquons que la pr´emisse pc τ dans les deux derni`eres r`egles permet, d’apr`es la d´efinition de la relation , de rejeter le programme imm´ediatement dans le cas o`u τ = H et pc = L. Cela permet d’empˆecher les flots implicites entre une variable de type H et une autre de type L `a l’int´erieur d’un bloc conditionnel ou d’une boucle. Dans tous les autres cas, les deux commandes se typent normalement et, en fonction de la valeur re¸cue par la variable instr, c’est-`a-dire τ chan t pc, le programme pourra ˆetre accept´e ou instrument´e.
La r`egle (SEN D S) exige que le canal de sortie soit `a un niveau de s´ecurit´e sup´erieur, au sens de la relation d’ordre , `a celui de l’expression qui est envoy´ee (τ ) et `a celui du contexte courant (pc). Cette r`egle attribue `a l’instruction le mˆeme type que celui du canal, auquel est ajout´ee l’´etiquette cmd.
Am´elioration du mod`ele avec le blocage des canaux
En 2013, Bedford et al. [5] introduisent dans l’analyse de Desharnais et al. [12] la notion de blocage des canaux. Bloquer un canal consiste `a empˆecher toute tentative de sortie sur un canal en bloquant ce dernier. Cette intervention est n´ecessaire lorsqu’une variable de nom de canal de niveau public est mise `a jour dans un contexte priv´e. Pour ce faire, un quatri`eme niveau de