Il est temps de pr´esenter le syst`eme de types de s´ecurit´e qui nous sert `a ´evaluer si un programme, ´ecrit dans le langage d´ecrit plus haut, soit satisfait la non-interf´erence, pourrait la satisfaire soit ne la satisfait pas du tout. C’est une am´elioration du langage pr´esent´e dans [12]. Un nouveau type de s´ecurit´e, B, est ajout´e pour identifier un canal qui doit ˆetre bloqu´e.
Les types de s´ecurit´e sont les suivants :
(types des donn´ees) τ ::= L | U | H | B
(types des phrases) ρ ::= τ val | τ chan | τ cmd
Nous consid´erons un ensemble de quatre niveaux de s´ecurit´e SL = {L, U, H, B}. Cet ensemble est ´etendu au treillis (SL, v) en se servant de l’ordre suivant :
L v U v H v B (nous utilisons les symboles w et A comme d’habitude). C’est par rapport `a cet ordre que le supremum t et l’infimum u sont d´efinis pour les types de s´ecurit´e. Nous ´elevons cet ordre aux types des phrases de fa¸con classique. Nous
(VAL) hv, µi →e v,
(VAR) hx, µi →e µ(x),
(OP) he1, µi →ev1 he2, µi →e v2 v1 op v2 = n
he1 op e2, µi →e n
(SKIP) hskip, µi → µ
(ASSIGN) he, µi →e v
hx := e, µi → µ[x 7→ v]
(RECEIVE-CONTENT) x2 ∈ dom(µ) read(µ(x2)) = n
hreceivec x1 from x2, µi → µ[x1 7→ n]
(RECEIVE-NAME) x2 ∈ dom(µ) read(µ(x2)) = nch
hreceiven x1 from x2, µi → µ[x1 7→ nch]
(SEND) x1 ∈ dom(µ)
hsend x1 to x2, µi → µ, update(µ(x2), µ(x1))
(CONDITIONAL) he, µi →e n n 6= 0
hif e then c1 else c2 end, µi → hc1, µi
he, µi →e n n = 0
hif e then c1 else c2 end, µi → hc2, µi
(LOOP) he, µi →e n n = 0
hwhile e do c end, µi → µ he, µi →e n n 6= 0
hwhile e do c end, µi → hc; while e then c end, µi
(SEQUENCE) hc1, µi → µ
0
hc1; c2, µi → hc2, µ0i
supposons que t et u retournent ⊥ lorsqu’ils sont appliqu´es `a des phrases de types diff´erents (par exemple Hchan t Hval = ⊥).
Le type d’une phrase est un ´el´ement de SL avec l’information pour indiquer que c’est une valeur enti`ere, un nom de canal ou une commande. Lors du typage d’un programme, des types de s´ecurit´e sont assign´es aux variables, aux canaux et aux commandes (mais aussi au contexte d’ex´ecution). Le sens donn´e aux types est le suivant. Une variable de type τ val a un contenu de type de s´ecurit´e τ ; un canal de type τ chan peut stocker de l’information de type τ ou plus bas (ainsi un canal priv´e est en mesure de stocker de l’information priv´ee mais aussi publique). Le typage des commandes est standard, mais a une signification un peu diff´erente : une commande de type τ cmd garantit qu’elle ne permet que des flots d’information vers des canaux dont les types de s´ecurit´e sont τ ou plus ´elev´es. Ainsi si une commande est de type L cmd alors elle permettra un flot vers un canal de type L chan ou mˆeme H chan. Tandis qu’une commande de type H cmd ne pourra permettre que des flots vers des canaux de type H chan. Le type B est assign´e `
a un canal uniquement pour indiquer qu’il ´etait de type L chan, mais doit ˆetre bloqu´e pour ´eviter un flot d’information implicite. Pour rappel, un flot implicite se produit lorsque le contenu affect´e `a une variable d´epend d’une autre variable, par exemple la garde d’un branchement conditionnel. Contrairement au flot explicite qui se produit lorsque le contenu d’une variable est directement affect´e `a une autre. Mentionnons que dans notre travail actuel, nous ne nous servons pas du type des commandes mais elle est faite pour garder l’´etiquetage comme dans les autres travaux. Cela pourrait s’av´erer utile dans des travaux futurs.
Notre syst`eme de types poss`ede deux propri´et´es int´eressantes : la s´ecurit´e simple qui s’applique aux expressions et le confinement qui s’applique aux commandes. Ces deux propri´et´es ont ´et´e mentionn´ees dans Smith [45]. La s´ecurit´e simple stipule qu’une ex- pression e de type τ val ou τ chan contient uniquement des variables de type τ ou plus bas. Le confinement quant `a lui stipule qu’une commande c de type τ cmd ex´ecut´ee dans un contexte de niveau de s´ecurit´e pc ne permet que des flots d’information vers des canaux de type τ t pc ou plus ´elev´e, afin d’´eviter des flots d’information d’un canal vers un autre de niveau de s´ecurit´e inf´erieur (de H vers L par exemple). Le niveau de s´ecurit´e du contexte pc sert `a empˆecher les flots d’information implicites. Les deux propri´et´es mentionn´ees servent `a d´emontrer la non-interf´erence.
Les r`egles de typage sont pr´esent´ees dans le tableau 3.2. Ce sont les mˆemes que celles de Desharnais et al. [12], `a l’exception des trois r`egles qui manipulent les canaux. Un
jugement de typage est de la forme Γ, pc ` c : ρ, Γ0 avec Γ et Γ0 des environnements de typage associant `a chaque variable un type de la forme τ val ou τ chan, repr´esentant son niveau de s´ecurit´e ; pc est le type de s´ecurit´e du contexte. Le programme est typ´e avec un contexte de type L ; selon les types de s´ecurit´e des conditions, certains blocs d’instructions sont typ´es avec des contextes plus ´elev´es, nous reviendrons sur ce point. Le jugement de typage peut ˆetre lu comme suit : `a partir d’un environnement initial Γ et un contexte de type de s´ecurit´e pc, la commande c a le type ρ et produit un environnement final Γ0. Lorsque l’environnement de typage n’est pas modifi´e, Γ0 est omis. Les types des canaux ´etant constants, un environnement de typage particulier TypeOf Channel est donn´e pour les canaux constants pr´ealablement `a l’analyse. Dans les r`egles, α remplace soit l’´etiquette val, soit l’´etiquette chan en fonction du contexte. Deux op´erateurs sur les environnements de typage doivent ˆetre d´efinis : Γ† [x 7→ ρ] et Γ t Γ0. Le premier est une mise `a jour simple de l’image de x `a ρ, peu importe si x faisait initialement partie du domaine de Γ ou pas. Pour la r`egle de la conditionnelle, il est n´ecessaire de faire une union d’environnements, dans laquelle les variables `a valeur commune doivent prendre pour type de s´ecurit´e le supremum des types dans les deux branches. En ce qui concerne les variables canaux dans la r`egle conditionnelle, lors- qu’elles ont deux types diff´erents dans les deux branches, le type r´esultant dans l’union doit ˆetre U . De fa¸con plus sp´ecifique, nous ´etendons t aux environnements selon la d´efinition suivante :
D´efinition 6. Le supremum de deux environnements est d´efini de telle sorte que dom(Γ t Γ0) = dom(Γ) ∪ dom(Γ0), et
Γ t Γ0(x) = Γ(x) si x ∈ dom(Γ) \ dom(Γ0) Γ0(x) si x ∈ dom(Γ0) \ dom(Γ)
U chan si B chan 6= Γ(x) = τ chan 6= τ0chan = Γ0(x) 6= B chan Γ(x) t Γ0(x) autrement.
Notons que Γ t Γ0(x) peut retourner ⊥, si Γ et Γ0 sont incompatibles pour la variable x. Par exemple si Γ(x) est une valeur et Γ0(x) est un canal (cela ne se produit que si Γ et Γ0 proviennent de diff´erentes branches d’une commande if ). Lorsqu’il est appliqu´e `a deux variables canaux, le supremum retourne le type incertain U , si aucune des deux variables n’est bloqu´ee et qu’elle n’ont pas la mˆeme valeur. Mentionnons que lorsque l’une d’entre elles est bloqu´ee, le type r´esultant est B chan car B est le niveau de s´ecurit´e le plus ´elev´e.
Une variable sp´eciale instr a ´et´e introduite dans [12]. Son type (stock´e dans l’environ- nement de typage) renseigne sur le fait que le programme n´ecessite une instrumentation ou pas. instr vaut initialement L ; lorsque l’algorithme d’inf´erence juge qu’une instru- mentation est n´ecessaire, sa valeur est mise `a U , H ou B. Elle est toujours modifi´ee avec l’op´erateur supremum pour assurer qu’une fois que l’algorithme a jug´e n´ecessaire d’instrumenter le programme, cette d´ecision sera pr´eserv´ee jusqu’`a la fin de l’analyse. Le dernier op´erateur `a d´efinir sert `a pr´evenir les potentielles fuites d’information de mani`ere flexible. Il est utilis´e dans les r`egles ASSIGN-CHAN S, RECEIVE-NAME S et SEND S. Sa d´efinition est la suivante :
D´efinition 7. La fonction HL d´etermine le niveau de s´ecurit´e de instr et des va- riables canaux dans les trois r`egles de typage qui modifient un canal
HLψν(a, b) = ψ si (a, b) = (H, L)
U si (a, b) ∈ {(U, L), (U, U ), (H, U )}
ν autrement.
Le tableau suivant donne une vue plus globale du r´esultat de HL en fonction de a et b : b L U H B a L ν ν ν ν U U U ν ν H ψ U ν ν B ν ν ν ν
Par exemple si (ψ, ν) = (H, L), le r´esultat de HL en fonction de a et b correspond au tableau suivant : b L U H B a L L L L L U U U L L H H U L L B L L L L
La notation HL est choisie pour signifier un flot vers un niveau plus bas “H vers L” car cette fonction formule (avec ψ et ν) comment un tel flot doit ˆetre trait´e dans les
trois r`egles mentionn´ees. Comme cela avait ´et´e soulign´e, nous souhaitons assurer qu’un programme ne sera rejet´e que s’il pr´esente un flot de H vers L. L’analyse de types distingue les programmes ayant des flots d’information s´ecuritaires de ceux pr´esentant un (ou plusieurs) flots incertains. Par exemple, tout flot de U vers H est s´ecuritaire car quel que soit le type de la variable incertaine `a l’ex´ecution (U ou H), le flot sera toujours s´ecuritaire. HLψ
ν(a, b) retournera toujours ν dans ces cas (o`u on consid`ere que
le flot va de a ver b). Par contre, d´ependamment de la valeur effective de la variable U `a l’ex´ecution, un flot U vers L, U vers U ou H vers U peut ˆetre s´ecuritaire ou pas. Une analyse conservative rejetterait les programmes pr´esentant ce genre de flots ; mais le nˆotre marquerait le programme comme n´ecessitant une instrumentation et poursui- vrait le typage. C’est la raison pour laquelle HL retournera U dans ces cas. Lorsqu’il est ´evident qu’il existe un flot d’information vers un niveau plus bas, de H vers L, alors HL retourne le type de ψ. Lorsque nous consid´erons le niveau de s´ecurit´e d’une variable canal, ψ sera toujours U ou B. N´eanmoins, un tel flot ne causera pas toujours le rejet d’un programme, ni son instrumentation. Il n’est ´evidemment pas n´ecessaire d’instru- menter le programme lorsqu’une variable est bloqu´ee. Cette explication de HL a pour but de donner l’intuition derri`ere celle-ci, qui en fait n’est qu’une fonction utilitaire pour notre analyse.
Certains auteurs qui traitent de l’analyse statique de programmes se servent de juge- ments de sous-typage de la forme ρ1 ⊆ ρ2 ou encore ρ1 ≤ ρ2 comme dans Smith [45] et
Volpano et al. [48]. Par exemple, ´etant donn´e deux types de s´ecurit´e τ et τ0, si τ ⊆ τ0 alors toute donn´ee de type τ peut ˆetre manipul´ee comme une donn´ee de type τ0. De fa¸con analogue, si une commande ne modifie que des variables de niveau H ou plus ´
elev´e, alors a fortiori, elle modifiera des variables de niveau L ou plus ´elev´e ; nous avons de ce fait Hcmd ⊆ Lcmd. Dans notre analyse, ces contraintes sont int´egr´ees directe- ment dans les r`egles de typage. Plutˆot que de se servir de contraintes sur les types, un type fixe est assign´e `a l’instruction en accord avec le type le plus g´en´eral. Pour deux expressions e1 et e2 de type τ1 et τ2 respectifs, e1 op e2 est typ´e τ1 t τ2. Pour deux
commandes c et c0 de types τ et τ0, leur composition lors d’une s´equence d’instructions ou lors de branchements conditionnels est typ´ee τ u τ0.
Commentons chacune des r`egles de typage. Dans tous les exemples que nous pr´esentons, highValue, lowValue, privateChannel et publicChannel sont pr´ed´efinies. Elles d´esignent respectivement une variable priv´ee, une variable publique, un canal priv´e et un canal public.
(CHAN S) TypeOf Channel(nch) = τ Γ, pc ` nch : τ chan (INT S) Γ, pc ` n : Lval (VAR S) Γ(x) = τ α Γ, pc ` x : τ α (OP S) Γ, pc ` e1: τ1α, Γ, pc ` e2: τ2α Γ, pc ` e1 op e2: (τ1t τ2)val (SKIP S) Γ, pc ` skip : H cmd (ASSIGN-VAL S) Γ, pc ` e : τ val Γ, pc ` x := e : (τ t pc)cmd, Γ † [x 7→ (τ t pc)val] (ASSIGN-CHAN S) Γ, pc ` e : τ chan Γ, pc ` x := e : τ cmd, Γ t [ instr 7→ HLL L(pc, τ )] † [x 7→ HLBτ(pc, τ )chan] (RECEIVE- CONTENT S) Γ(x2) = τ chan
Γ, pc ` receivecx1 from x2: (τ t pc)cmd, Γ † [x17→ (τ t pc)val]
(RECEIVE- NAME S)
Γ(x2) = τ chan
Γ, pc ` receivenx1 from x2: τ cmd, Γ t [ instr 7→ HLLτ(pc, τ )] † [x1 7→ HLBU tτ(pc, τ )chan]
(SEND S) Γ(x1) = τ1α, Γ(x2) = τ chan, ¬((τ1t pc) ∈ {H, B} ∧ τ = L) τ 6= B Γ, pc ` send x1 to x2: τ cmd, Γ t [ instr 7→ HLUL(τ1t pc, τ )] (CONDITIONAL S) Γ, pc ` e : τ0val Γ, (pc t τ0) ` c1: τ1cmd, Γ0 Γ, (pc t τ0) ` c2 : τ2cmd, Γ00 Γ0t Γ00A ⊥
Γ, pc ` if e then c1 else c2 end : (τ1u τ2)cmd, Γ0t Γ00
(LOOP1 S) Γ, pc ` e : τ0val Γ, (pc t τ0) ` c : τ cmd, Γ 0 Γ = Γ t Γ0A ⊥ Γ, pc ` while e do c end : τ cmd, Γ t Γ0 (LOOP2 S) Γ, pc ` e : τ0val Γ, (pc t τ0) ` c : τ cmd, Γ0 Γ 6= Γ t Γ0A ⊥ Γ t Γ0, (pc t τ0) ` while e do c end : τ0cmd, Γ00 Γ, pc ` while e do c end : τ0cmd, Γ00 (SEQUENCE S) Γ, pc ` c1: τ1cmd, Γ 0 Γ0, pc ` c2: τ2cmd, Γ00 Γ, pc ` c1; c2: (τ1u τ2)cmd, Γ00
CHAN S permet de typer un canal constant, ceci en lisant dans le registre de canaux T ypeOf Channel. VAR S quant `a lui permet de typer les variables en se servant de l’environnement Γ. Nous supposons que tous les entiers ont le type de s´ecurit´e L, le niveau de s´ecurit´e le plus bas pour les expressions. C’est la r`egle INT S qui est utilis´ee pour les entiers. Nous supposons ´egalement que la commande skip a le type Hcmd, le niveau de s´ecurit´e le plus bas pour les commandes. OP S assigne au r´esultat la plus petite borne sup´erieure des types des op´erandes.
ASSIGN-VAL S et RECEIVE-CONTENT S mettent `a jour l’environnement en asso-
ciant `a la variable modifi´ee, (τ t pc) val, et associe le type (τ t pc) cmd `a la commande. Ainsi dans le corps d’un bloc d’instructions qui doit ˆetre priv´e (le contexte pc vaut H) alors la valeur modifi´ee aura le type H. Cela a pour but d’empˆecher les flots d’infor- mation implicites dans le corps des commandes while et if lorsque la condition est de type H.
ASSIGN-CHAN S et RECEIVE-NAME S sont deux r`egles de typage qui ont ´et´e chan- g´ees par rapport `a [12]. Elles modifient toutes les deux, une variable canal et utilisent la fonction HLψ
ν. La condition usuelle pour la modification d’un canal serait d’empˆecher
les flots vers des niveaux de s´ecurit´e plus bas en imposant pc v τ ou comme dans [12], pc τ . Pour rappel, est une forme plus faible de v, qui retourne faux uniquement si pc = H et τ = L. Nous avons choisi dans ce travail de ne rejeter un programme que si un send non s´ecuritaire est effectu´e. Si un flot implicite est d´etect´e dans ASSIGN-
CHAN S ou RECEIVE-NAME S, pc = H et τ = L, nous bloquons plutˆot le canal
modifi´e (avec ψ = B dans HLB
−), comme dans le programme de la figure3.1, si le canal
n’est pas utilis´e par la suite, un faux positif est ´elimin´e. Si le canal est bloqu´e, il n’est pas n´ecessaire de faire une instrumentation, c’est la raison pour laquelle on a ψ = L dans HLL
− pour les deux r`egles. Dans RECEIVE-NAME S, il est n´ecessaire d’instru-
menter lorsque τ vaut U ou H pour empˆecher que le flot de x2 vers x1 soit un flot vers
un niveau plus bas. Dans ce cas la variable canal re¸coit le type de s´ecurit´e U t τ parce que son type est inconnu : on pourrait recevoir le nom d’un canal priv´e sur un canal public (mais on ne pourrait lire sur celui-ci). Dans la r`egle ASSIGN-CHAN S, ce type est τ , celui de l’expression assign´ee.
Dans la r`egle RECEIVE-CONTENT S, x1 est associ´e au supremum du type du canal
x2 et pc, du fait que le contenu de x2 est lu dans un contexte de type pc.
SEND S est la troisi`eme r`egle qui est modifi´ee par rapport `a [12]. La nouvelle r`egle pr´evoit deux situations o`u le typage ´echoue : soit le canal sur lequel x1 est envoy´e est
Programme `a analyser Analyse d’inf´erence if highValue then c := publicChannel else c := privateChannel end; send lowValue to c Environnement pc i pcif = H 2 G(2) = [instr 7→ L, c 7→ B chan] H 3 G(3) = [instr 7→ L, c 7→ H chan] H 4 G(1) = [instr 7→ L, c 7→ B chan] H 4 fail car c 7→ B chan
R´esultat : Rejet, on ne peut envoyer l’information lowValue au canal c car celui-ci est bloqu´e.
Figure 3.1 – Analyse d’un programme pr´esentant un flot d’information implicite non s´ecuritaire.
bloqu´e, soit son type est L et le contexte ou x1 a l’un des types H ou B. Dans ces cas,
la fuite d’information est ´evidente. Le programme de la figure 3.1 est un exemple avec τ = B. Si le programme n’est pas rejet´e par le typage, l’instrumentation sera appel´ee dans chacun des cas o`u `a l’ex´ecution il est possible que τ1tpc soit H ou B et que le canal
ait pour type L. Ces cas correspondent `a (τ1t pc, τ ) ∈ {(U, L), (U, U ), (H, U ), (B, U )}.
La “branche ψ” dans la d´efinition de HLψ− est inutile car dans ce cas-ci, le typage rejette
le programme.
La r`egle CONDITIONAL S n´ecessite de typer les branches c1 et c2 avec le contexte de
type pc t τ0. Ceci empˆeche que le flot de la garde vers les branches soit un flot vers
des niveaux de s´ecurit´e plus bas. Un exemple typique de cette situation est le premier programme de la figure 3.2. Puisque x est typ´e dans un contexte ´elev´e (la garde ´etant priv´ee), le type H lui sera attribu´e, et par cons´equent le programme rejet´e car x ne peut ˆ
etre envoy´e sur un canal public. L’environnement de typage r´esultant, tel que le pr´evoit la r`egle CONDITIONAL S est d´etermin´e en se servant de l’op´erateur t. Expliquons un peu plus la raison pour laquelle l’op´erateur t est d´efini diff´eremment pour les variables canaux et les variables valeurs. Si Γ et Γ0, les deux environnements associ´es aux branches de la commande if, diff`erent pour une variable valeur, nous choisissons d’ˆetre pessimiste et c’est le supremum des deux types de s´ecurit´e qui est assign´e. Un utilisateur souhaitant obtenir moins de faux positifs pourrait assigner le type U `a cette variable, laissant de ce fait l’analyse dynamique prendre la d´ecision finale. Dans le cas des variables canaux, nous n’avons pas le choix car le nom d’un canal peut ˆetre priv´e s’il provient d’une source priv´ee mais avoir un contenu public (et vice versa). C’est ce qu’illustre le dernier programme de la figure 3.2. La derni`ere ligne devrait causer le rejet du programme car la branche else fait de c une information priv´ee, nous pourrons ainsi conclure que le
bon typage de c lors du typage de la commande if est H. Cependant l’avant-derni`ere ligne send highValue to c ; n´ecessiterait que c soit typ´e L afin que le programme soit rejet´e. En somme nous devons typer c, U . Cet exemple illustre la raison pour laquelle l’op´erateur t a ´et´e ainsi d´efini.
SEQUENCE S assigne `a la commande la borne inf´erieure la plus ´elev´ee des types des deux instructions s´equentielles. Notons que c1 peut mettre `a jour l’environnement de
typage `a partir duquel c2 est typ´ee.
Notre analyse ´etant sensible au flot d’information, nous devons par cons´equent analyser le bloc while de mani`ere it´erative. Pour illustrer cela, consid´erons le programme de la figure 3.3. Dans cet exemple, l’instruction send dans le corps du while est s´ecuri- taire lors des trois premi`eres it´erations. Pendant celles-ci, l’information s´ecuritaire dans highValue passe progressivement de x1, puis `a x2 et `a x3. Lors de la quatri`eme it´eration,
l’instruction send n’est plus s´ecuritaire. En effet l’information priv´ee ainsi remont´ee est envoy´ee sur un canal public. Le typage correspondant est pr´esent´e de fa¸con sommaire du cˆot´e droit de la figure. La n´ecessit´e de faire une analyse it´erative est abord´ee au moyen de deux r`egles. La premi`ere r`egle, LOOP1 S, est la condition d’arrˆet : le typage de la commande c avec l’environnement Γ n’´el`eve le type d’aucune variable. Par cons´equent, quel que soit le nombre de fois que la commande c est r´ep´et´ee, le type des variables ne croˆıtra pas. Autrement, dans la seconde r`egle LOOP2 S, si l’environnement est modi- fi´e, nous it´erons en nous servant du supremum du type de l’environnement initial et de celui r´esultant. Nous affirmons que ce processus termine car il y a un nombre fini de variables dans c, et parce que l’op´eration t entre le type dans l’environnement initial et celui r´esultant est monotone. Evidemment, les types de variables sont modifi´es de fa¸con monotone en accord avec la relation v.
L’exemple de la figure 3.4 illustre le typage d’un programme qui n´ecessite une instru- mentation. La r`egle RECEIVE-NAME S assigne `a x le type de s´ecurit´e inconnu U chan dˆu au fait qu’un nom de canal est re¸cu d’un canal priv´e dans un contexte qui est public. Un appel `a l’instrumentation est fait `a l’instruction 4, car c’est un cas de flot explicite de h dont le type est H, vers x dont le type est inconnu.
Concluons cette section en discutant des cas de faux positifs qui peuvent survenir. C’est-`a-dire des cas o`u notre analyse rejette le programme alors qu’`a l’ex´ecution, celui- ci pourrait tout `a fait ˆetre s´ecuritaire. Un rejet ne se produit que suite `a l’application de la r`egle SEND S : soit le canal sur lequel x1 est envoy´e a ´et´e bloqu´e, soit il est de