L’algorithme d’inf´erence impl´emente la sp´ecification donn´ee par le syst`eme de types avec quelques ajouts qui serviront par la suite pour l’instrumentation. Ces ajouts per- mettent de conserver le num´ero de ligne de la commande et l’environnement r´esultant de l’ex´ecution de celle-ci. Bien que cela puisse sembler une r´ep´etition, cette m´ethode all`ege par la suite l’´etape dynamique car elle ´evite d’effectuer `a nouveau l’inf´erence de type lorsque celle-ci avait ´et´e pr´ealablement effectu´ee. L’algorithme est impl´ement´e par la fonction Infer qui est appliqu´ee `a l’environnement courant, ge : Var → {L, H, U, B},
un nombre identifiant le num´ero de ligne i de la commande `a analyser, le niveau de s´ecurit´e du contexte courant pc et la commande courante `a analyser c. La fonction Infer retourne un environnement de typage repr´esentant l’environnement valide apr`es l’ex´ecution de la commande c et un entier repr´esentant le num´ero qui identifie la pro- chaine commande `a analyser. Infer met `a jour G : int → (Var → {L, H, U, B}) comme effet de bord ; G associe `a chaque num´ero de commande un environnement de typage valide apr`es son ex´ecution. Pour rappel, dans l’environnement de typage, une variable sp´eciale instr permet de conserver un niveau de s´ecurit´e renseignant sur la n´ecessit´e d’instrumenter le programme ou non. Apr`es l’ex´ecution de l’algorithme d’inf´erence, si le programme n’est pas rejet´e et que l’environnement r´esultant associe `a instr H ou U , cela signifie que le programme n´ecessite une instrumentation, autrement il est s´ecu- ritaire par rapport `a la propri´et´e de non-interf´erence. Pour analyser un programme P , Infer est invoqu´e avec ge= [ instr 7→ L] , i = 0, pc = L et c = P .
L’algorithme d’inf´erence utilise un ensemble de fonctions utilitaires qui impl´ementent des op´erateurs, fonctions et d´efinitions apparaissant dans le syst`eme de types. Leur signification et leur impl´ementation sont directes. Voici la liste de ces fonctions.
SecType (ensemble des types de s´ecurit´e) a pour d´efinition {τ ν : τ ∈ {L, U, H, B}, ν ∈ {val, chan}}, t et ti sont des ´el´ements de SecType, et gi est un ´el´ement de Env
– lessOrEqual : impl´emente v,
– inf : impl´emente l’infimum de deux niveaux de s´ecurit´e – sup : impl´emente le supremum de deux niveaux de s´ecurit´e
– supEnv : impl´emente le supremum de deux environnements, comme dans la D´efini- tion 6
– infV : SecType ×SecType → SecType ∪{⊥T} retourne ⊥T si les deux types de s´ecurit´e
n’ont pas la mˆeme nature. S’ils sont de mˆeme nature, alors infV retourne un type de s´ecurit´e dans lequel le niveau de s´ecurit´e est l’infimum des deux types de s´ecurit´e pris en param`etre.
– supV : SecType × SecType → SecType ∪ {⊥T} se comporte comme infV `a la seule
diff´erence qu’il retourne un type de s´ecurit´e dans lequel le niveau de s´ecurit´e est le supremum des deux types de s´ecurit´e pris en argument.
– incBottomEnv : Env → bool retourne vrai si au moins une variable dans l’environne- ment re¸cu en param`etre est associ´ee `a {⊥T}.
– updateEnv : Env × Var × SecType → Env impl´emente Γ † [x 7→ ρ],
– eqEnv : Env × Env → bool v´erifie si deux environnements de typage sont ´egaux. Il retourne vrai si les deux environnements ont le mˆeme domaine et toutes leurs variables ont le mˆeme type de s´ecurit´e, autrement il retourne faux.
– evalN : SecType → {val, chan}, extrait la nature d’un type de s´ecurit´e (val or chan), – evalT : SecType → {L, U, H, B}, exttrait le niveau de s´ecurit´e d’un type,
– inferE : Env × Exp → SecType retourne le type de s´ecurit´e le plus ´elev´e des variables pr´esentes dans l’expression `a laquelle elle est appliqu´ee,
– HL : {L, U, H, B}4 → {L, U, H, B} impl´emente la fonction HL conform´ement `a la D´efinition 7.
L’algorithme d’inf´erence est pr´esent´e dans le tableau 3.3. Pr´esentons le r´esultat de l’analyse par Infer de quelques programmes choisis judicieusement.
Exemples de r´esultats de l’application de l’algorithme Infer
Les prochains exemples servent `a illustrer l’application de Infer. Ces figures re- pr´esentent l’environnement r´esultant, le num´ero de commande retourn´e i ainsi que le
Infer : Env × int × Sec × cmd → Env × int Infer(ge, i, pc, c) = case c of skip : G(i) = ge return (G(i), i + 1) x := e : τ = evalT(inferE(ge, e)) case evalN(inferE(ge, e) ) of
val : G(i) = updateEnv(ge, x, sup(pc, τ ) val)
return (G(i), i + 1) chan : instrt= HL(L, L, pc, τ )
xt= HL(B, tau, pc, τ )
instrt2= ge(instr)
G(i) = updateEnv(updateEnv(ge, instr, sup(instrt, instrt2)), x, xt chan)
return (G(i), i + 1) receivecx1from x2 :
τ = evalT(ge(x2))
G(i) = updateEnv(ge, x1, sup(pc, τ ) val)
return (G(i), i + 1) receivenx1from x2: τ = evalT(ge(x2)) instrt= HL(L, τ, pc, τ ) instrt2= ge(instr) x1t= HL(B, sup(U, τ ), pc, τ )
G(i) = updateEnv(updateEnv(ge, instr, sup(instrt, instrt2)), x1, x1t chan)
return (G(i), i + 1) send x1to x2 :
τ1= evalT(ge(x1))
τ = evalT(ge(x2))
instrt= HL(U, L, sup(τ1, pc), τ )
instrt2= ge(instr)
if((τ 6= B) and ¬(sup(τ1, pc) in {H, B} and τ = L)))
then G(i) = updateEnv(ge, instr, sup(instrt, instrt2))
else fail return (G(i), i + 1) c1; c2 : (g1, j) = Infer(ge, i, pc, c1) (g2, k) = Infer(g1, j, pc, c2) return (g2, k)
if e then c1 else c2end :
t = evalT(inferE(ge, e))
pcif = sup(pc, t)
(g1, j) = Infer(ge, i + 1, pcif, c1)
(g2, k) = Infer(ge, j, pcif, c2)
if(¬incBottomEnv(supEnv(g1, g2))) then G(i) = supEnv(g1, g2)
else fail return (G(i), k) while e do c end :
t = evalT( inferE(ge, e))
pcwhile= sup(pc, t)
(ge0, j) = Infer(ge, i + 1, pcwhile, c)
if (eqEnv(ge, supEnv(ge, ge0)) and (¬incBottomEnv(supEnv(ge, ge0))))
then gres= supEnv(ge, ge0)
else if (¬eqEnv(ge, supEnv(ge, ge0)) and (¬incBottomEnv(supEnv(ge, ge0))))
then (gres, j) = Infer(supEnv(ge, ge0), i, pc
while, while e do c end)
else fail G(i) = supEnv(G(i), gres) return (gres, j)
niveau de s´ecurit´e du contexte pris en param`etre pc. Nous pr´esentons aussi le r´esultat de l’instrumentation lorsque celui-ci est n´ecessaire.
Exemple 8.
Le premier exemple est celui de la figure 3.1. Le programme est rejet´e parce que le canal c d´epend de la valeur d’une garde qui est priv´ee. C’est pour cette raison que c est bloqu´e lorsqu’on lui assigne un canal public `a l’int´erieur du if . Bien que dans la seconde branche on assigne un canal priv´e `a c, `a la fin le supremum des deux branches conservera pour celui-ci le type B qui est le niveau de s´ecurit´e le plus ´elev´e. A la derni`ere ligne, une information de contenu public est envoy´ee `a c, mais ceci ne peut ˆetre permis, car de l’information sur la garde confidentielle highValue serait r´ev´el´ee : l’envoi serait bloqu´e `a ce moment. On se servirait ainsi de l’avertissement qui a ´et´e pr´ealablement not´e, celui de donner `a c le type B parce qu’il devient un canal public alors que le contexte est de niveau de s´ecurit´e ´elev´e (du fait de la garde). Les analyses purement statiques rejettent une telle assignation, pour empˆecher un observateur de d´eduire la la garde priv´ee en observant publicChannel. Notre analyse va plutˆot bloquer le programme `a ce moment et ce n’est que lorsqu’une tentative d’envoi sur le canal est d´ecel´ee, que le programme sera rejet´e. S’il n’y avait aucune tentative d’envoi sur c, le programme n’aurait pas ´et´e rejet´e.
Exemple 9.
Le programme de la figure 3.6 est rejet´e. Le niveau de s´ecurit´e de x est H parce que sa valeur lui a ´et´e attribu´ee dans le contexte de niveau H highValue. Par la suite, la tentative d’envoi de cette variable priv´ee sur le canal public publicChannel provoque le rejet du programme.
Programme `a analyser Analyse d’inf´erence if highValue then x := lowValue else skip end; send x to publicChannel Environnement pc i pcif = H 2 G(2) = [x 7→ H val] H 3 G(3) = [] H 4 G(1) = [x 7→ H val] H 4 fail car H 6v L
R´esultat : Rejet, on ne peut envoyer x (H) sur publicChannel (L).
Exemple 10.
Le programme de la figure3.7 est semblable `a celui de la figure 3.1 (c’est le mˆeme que celui de la figure 3.4 ). Except´e que dans celui-ci la garde de la commande if n’est plus de niveau H mais plutˆot L. Le type retenu pour c est U , ´etant donn´e qu’il a deux types diff´erents dans chaque branche. La commande send provoquera une instrumentation car cette fois c’est une valeur priv´ee highValue, qui est envoy´ee sur c. Il faut donc s’assurer que dynamiquement, l’envoi ne sera effectu´e que si c est un canal priv´e.
Programme `a analyser Analyse d’inf´erence if lowValue then c := publicChannel else c := privateChannel end; send highValue to c Environnement pc i G(1) = [instr 7→ L, highValue 7→ H val] pcif = L 2
G(2) = [instr 7→ L, highValue 7→ H val,
c 7→ L chan] L 3 G(3) = [instr 7→ L, highValue 7→ H val,
c 7→ H chan] L 4 G(1) = [instr 7→ L, highValue 7→ H val,
c 7→ U chan] L 4 G(4) = [instr 7→ U, highValue 7→ H val,
c 7→ U chan] L 5 R´esultat : Ce programme doit ˆetre instrument´e.
Figure 3.7 – L’envoi d’une valeur priv´ee sur un canal de niveau inconnu provoque une instrumentation
Exemple 11.
Dans le programme de la figure 3.8, le canal c pourrait tout aussi bien avoir le type L que le type H lorsqu’il est lu du canal publicChannel . Par cons´equent le type U lui est attribu´e. Par la suite, l’envoi de la variable priv´ee v sur le canal inconnu c provoquera dans notre analyse une instrumentation du programme. Contrairement aux autres analyses conservatrices qui le rejetteraient, notre analyse l’instrumenterait afin de pr´evenir lors de la phase dynamique un ´eventuel envoi de v sur un canal public. Prenons maintenant un exemple plus r´ealiste qui est inspir´e de Zdancewic et Myers [56].
Exemple 12.
Le programme de la figure3.9 illustre une situation `a laquelle on est souvent confront´e dans la vie r´eelle. C’est un programme normal (gestionnaire d’activit´es financi`eres) qui manipule des informations confidentielles (num´ero de carte de cr´edit) et ´echange avec un interlocuteur de confiance `a travers un lien s´ecuris´e (connexion s´ecuris´ee `a la
Programme `a analyser Analyse d’inf´erence receivecv from privateChannel ;
if lowV alue then
receiven c from publicChannel ;
send v to c end Environnement pc i G(1) = [instr 7→ L, v 7→ H val] L 2 pcif = L 3 G(3) = [instr 7→ L, v 7→ H val, c 7→ U chan] L 4 G(4) = [instr 7→ U, v 7→ H val, c 7→ U chan] L 5 (else skip) G(5) = [instr 7→ L,
v 7→ H val] L 6 G(2) = [instr 7→ U, v 7→ H val,
c 7→ U chan] L 6 R´esultat : Ce programme doit ˆetre instrument´e.
Figure 3.8 – L’envoi d’une valeur priv´ee sur un canal de niveau inconnu provoque une instrumentation
banque). Cependant ce programme se sert aussi de l’Internet qui est un medium de communication public. On devrait pouvoir recevoir en toute s´ecurit´e des informations de celui-ci (bilans financiers par exemple), mais on doit s’assurer que ce programme n’envoie pas `a notre insu sur l’Internet, nos informations confidentielles (num´ero de carte de cr´edit). Il faut alors que le compilateur du programme v´erifie les flots d’information au sein de celui-ci. Dans la figure, tous les canaux sont priv´es except´e internet.
Programme `a analyser : receivecbilanMarcheBoursier from internet;
send bilanMarcheBoursier to moniteur; receivecnumeroCarteCredit from parametres;
send numeroCarteCredit to connexionSecuriseeABanque;
receivecdernieresTransactions from connexionSecuriseeABanque;
send dernieresTransactions to moniteur;
numeroCarteCreditBienEncode := numeroCarteCredit ∗ 3 + 2121311611218191; send numeroCarteCreditBienEncode to internet
R´esultat : Rejet, on ne peut envoyer numeroCarteCreditBienEncode (H) sur internet (L).
Figure 3.9 – Exemple inspir´e de Zdancewic et Myers [56]
Preuve de correction Pour garantir la correction de l’algorithme, nous devons d´e- montrer sa coh´erence et sa compl´etude par rapport au syst`eme de types. Mentionnons qu’on associe les types U ou H `a la variable instr dans l’environnement r´esultant pour signifier que le programme doit ˆetre instrument´e.
Th´eor`eme 13. (Correction de l’algorithme Infer) Soit P un programme dans notre langage cible, G un environnement de typage, et pc un niveau de s´ecurit´e, Infer(G, 0,
pc, P) = (G0, j) ⇔ G,pc ` P : ρ, G0, et Infer rejette P si et seulement si le syst`eme de types le rejette ´egalement.
D´emonstration. Nous supposons que tout programme soumis `a l’analyse de flot d’in- formation est bien typ´e. Par exemple, pour les commandes receiven x1 from x2
et send x1 to x2, la variable x2 est un canal. On peut facilement d´emontrer que
sup et supV tous deux encodent l’op´erateur t surcharg´e pour les types de s´ecurit´e. supEnv(G1, G2) correspond `a G1t G2; updateEnv(G1, x, τ ) correspond `a G1† [x 7→ τ ] ;
et HL(a, b, c, d) correspond `a HLa
b(c, d). Par d´efinition, nous avons Γ t [v 7→ τ α] =
Γ † [v 7→ (Γ(v) t τ α)].
Nous d´emontrons dans un premier temps que inferE se comporte comme le syst`eme de types pour les expressions, c’est-`a-dire pour l’acceptation, le rejet et l’environnement r´esultant. La preuve est faite par induction structurelle.
Cas de base
valeur constante inferE(G, n), avec n une valeur constante, retourne L val et la seule r`egle applicable est INT S : G, pc ` n : L val.
canal constant inferE(G, nch) = T ypeOf Channel(nch) chan, avec nch un canal constant. La seule r`egle applicable est CHAN S : G, pc ` nch : T ypeOf − Channel(nch) chan, avec T ypeOf Channel retourne pour un canal constant, son niveau de s´ecurit´e.
variable inferE(G, x) retourne G(x) et la seule r`egle applicable dans le syst`eme de types est VAR S : G, pc ` x : G(x).
Cas d’induction Notons que les expressions compos´ees ne peuvent ˆetre que des va- leurs.
e1 op e2. Supposons que inferE(G, e1) = t1 val et que inferE(G, e2) = t2 val
alors inferE(G, e1 op e2) = (sup(t1, t2))val. La seule r`egle applicable est OP S :
G, pc ` e1 op e2 : (τ1 t τ2) val. Avec G, pc ` e1 : τ1 val et G, pc ` e2 : τ2 val.
t1 = τ1 et t2 = τ2 par hypoth`ese d’induction. La preuve s’en suit.
Nous d´emontrons maintenant le r´esultat de Infer sur les commandes. La preuve est ´
egalement par induction sur la structure du programme. Cas de base P a l’une des structures suivantes.
skip Supposons que Infer(G, i, pc, skip) = (G, i + 1). La seule r`egle applicable dans le syst`eme de types pour skip est SKIP S : G, pc ` skip : H cmd. L’absence
d’environnement `a droite de ` signifie que l’environnement initial n’a pas ´et´e modifi´e. Il est ´evident que Infer retourne le mˆeme environnement qui est inf´er´e par les r`egles de typage et qu’aucun d’entre eux n’aboutit `a un rejet.
x := e. Nous distinguons deux cas.
– e est une variable val. Infer(G, i, pc, x := e) = (updateEnv(G, x, sup(pc, t) val), i + 1), avec t = evalT(inferE(G, e)). La seule r`egle applicable est ASSIGN- VAL S, selon laquelle G, pc ` x := e : (τ t pc) cmd, G † [x 7→ (τ t pc) val] si G, pc ` e : τ val. Nous savons que Infer et le syst`eme de types s’accordent sur le typage des expressions, ainsi t = τ , et updateEnv(G, x, sup(pc, t) val) = G † [x 7→ (τ t pc)], par cons´equent x := e, avec e une variable val est accept´e par Infer et l’environnement r´esultant est le mˆeme que celui qui est le jugement d´emontr´e par le syst`eme de types.
– e est une variable chan. Infer(G, i, pc, x := e) = (updateEnv(G0, x, xtchan), i+
1), o`u G0 = updateEnv(G, instr, sup(instrt, instrt2)), xt= HL(B, t, pc, t), instrt
= HL(L, L, pc, τ ), instrt2= G(instr), et t = evalT(inferE(G, e)). La seule r`egle
applicable est ASSIGN-CHAN S. Selon cette r`egle G, pc ` x := e : τ cmd, G t [ instr 7→ HLL
L(pc, τ )] † [x 7→ HLBτ(pc, τ ) chan] est vrai si G, pc ` e : τ chan
est vrai. Nous savons que Infer et le syst`eme de types s’accordent sur le ty- page des expressions, ainsi τ = t, et que †, HL, et t ´equivalent respectivement `
a updateEnv, HL, et sup, par cons´equent G t [ instr 7→ HLLL(pc, τ )] † [x 7→ HLBtau(pc, τ ) chan] est ´egal `a updateEnv(updateEnv(G, instr, sup(instrt, instrt2)),
x, xt chan).
Infer et le syst`eme de types produisent le mˆeme environnement et ne rejettent pas la commande.
receivecx1 from x2. Nous avons Infer(G, i, pc, receivecx1 from x2)
= (updateEnv(G, x1, sup(pc, t)val), i + 1), o`u t = evalT(G(x2)). La seule r`egle
applicable, dans le syst`eme de types est, RECEIVE-CONTENT S. Nous avons, G, pc ` receivecx1
from x2 : (τ t pc) cmd, G † [x1 7→ (τ t pc) val] si G(x2) = τ chan. Puisque
la r`egle de typage est appliqu´ee sur le mˆeme environnement qui est fourni `a Infer, alors t = τ . De plus, nous savons que updateEnv et sup sont ´equiva- lents respectivement `a † et t. Ainsi, l’environnement G † [x1 7→ (τ t pc) val] =
(updateEnv(G, x1, sup(pc, t)val).
Infer et le syst`eme de types produisent le mˆeme environnement et ne rejettent pas la commande.
= (updateEnv(updateEnv(G, instr, sup(instrt, instrt2)), x1, x1t chan), i + 1)
avec instrt= HL(L, t, pc, t), t = evalT(G(x2)), instrt2= G(instr), et x1t = HL(B,
sup(U, t), pc, t). La seule r`egle applicable dans le syst`eme de types est RECEIVE- NAME S, selon laquelle G, pc ` receiven x1from x2 : τ cmd, G t [ instr 7→
HLL
τ(pc, τ )] † [x1 7→ HLBU tτ(pc, τ ) chan] est vrai si G(x2) = τ chan. Infer est
appliqu´e au mˆeme environnement fourni `a la r`egle de typage donc t = τ . En nous basant sur le commentaire au d´ebut de la d´emonstration, nous concluons que updateEnv(updateEnv(G,
instr, sup(instrt, instrt2)), x1, x1t chan) = G t [ instr 7→ HLLτ(pc, τ )] † [x1 7→
HLBU tτ(pc, τ ) chan]. Ainsi, Infer et le syst`eme de types produisent le mˆeme en- vironnement lors du typage d’une commande receiven. Il n’y a aucun rejet dˆu `a
une fuite d’information.
send x1 to x2. Infer(G, i, pc, send x1 to x2) = (updateEnv(G, instr, sup(instrt,
instrt2)), i + 1), avec instrt = HL(U, L, sup(t1, pc), t), instrt2 = G(instr), t =
evalT(G(x2)), et t1 = evalT(G(x1)). Dans ce cas, Infer peut d´ecider de l’accep-
tation, avec une possible instrumentation, ou du rejet.
La seule r`egle applicable est SEND S, G, pc ` send x1 to x2 : τ cmd, Gt[ instr 7→
HLU
L(τ1 t pc, τ )] if G(x1) = τ1 α ∧ G(x2) = τ chan ∧ ¬((τ1t pc) ∈ {H, B} ∧ τ =
L) ∧ τ 6= B. Puisque Infer et la r`egle de typage re¸coivent le mˆeme environnement G, nous avons t = τ et t1 = τ1.
Pour Infer, le rejet se produit dans deux cas. Premi`erement, si evalT(G(x2)) =
t = B, dans ce cas, la proc´edure de rejet fail est appel´ee, et puisque Infer et le syst`eme de types re¸coivent le mˆeme environnement G alors le syst`eme de types conclut aussi `a un ´echec. Deuxi`emement, sup(t1, pc) in {H, B} ∧ t = L qui
´
equivaut `a ((τ1tpc) ∈ {H, B})∧(τ = L), dans ce cas ´egalement fail est appel´ee et
le syst`eme de types ´echoue dans sa tentative de d´emontrer le jugement de typage. Si Infer n’arrive pas `a un rejet alors l’environnement r´esultant est updateEnv(G, instr, sup(instrt, instrt2)) qui est ´equivalent `a G t [ instr 7→ HLUL(τ1 t pc, τ )]
puisque instrt2 = G(instr) et instrt= HL(U, L, sup(τ1, pc), τ ).
Cas d’induction Cas cmd de
c1; c2, Infer(G, i, pc, c1; c2) soit ´echoue, soit retourne (G2, k). Premi`erement
Infer est invoqu´e sur c1 puis s’il n’´echoue pas il est appliqu´e sur c2. Nous avons
par induction que Infer(G, i, pc, c1) soit retourne (G1, j), soit ´echoue et le syst`eme
de types soit produit le mˆeme environnement, soit ´echoue. Si c1 n’am`ene pas `a un
´
le syst`eme de types soit produit le mˆeme environnement soit ´echoue. Selon la seule r`egle applicable dans le syst`eme de types SEQUENCE S, le syst`eme de types soit ´echoue si l’un de ses pr´emisses ´echoue soit am`ene au r´esultat obtenu lorsqu’on essaie de d´emontrer G1, pc ` c2 : τ2cmd, G02. Par hypoth`ese d’induction,
ce jugement est vrai et la conclusion de la r`egle est vraie avec G2 = G02 comme
environnement r´esultant.
if e then c1 else c2 end, premi`erement Infer ´evalue (G1, j) = Infer(G, i +
1, pcif, c1) et (G2, k) = Infer(G, j, pcif, c2) avec pcif = sup(pc, t) et t = evalT(
inferE(G, e)) et si ¬incBottomEnv(supEnv(G1, G2)) alors Infer(G, i, pc, if e
then c1 else c2 end) = (supEnv(G1, G2), k) sinon fail.
CONDITIONAL S est la seule r`egle applicable. Selon celle-ci G, pc ` if e then c1
else c2 end : (τ1u τ2)cmd, G01t G02 si G, pc ` e : t val ; G, (pc t t) ` c1 : τ1cmd, G01;
G, (pc t t) ` c2 : τ2 cmd, G02; G01t G02 A ⊥. Puisque Infer et le syst`eme de types
s’accordent sur le typage de e, nous concluons que G, pc ` e : t val, et nous avons par induction qu’ils s’accordent sur le rejet ou l’environnement r´esultant pour les commandes c1 et c2. Si aucune des commandes n’est rejet´ee alors G1 = G01
et G2 = G02. supEnv(G1, G2) = G01 t G 0
2 associe soit ⊥ `a l’une des variables
appartenant `a son domaine soit est aussi bien le r´esultat de l’application de Infer que de la r`egle de typage.
while e do c end. Infer est invoqu´e comme suit Infer(G, i, pc, while e do c end). L’algorithme ´evalue premi`erement le niveau de s´ecurit´e de l’expression dans la condition e avec t = evalT(inferE(G, e)), par la suite il d´etermine la valeur du nouveau contexte de s´ecurit´e dans pcwhile = sup(pc, t) et (G1, j) = Infer(G, i +
1, pcwhile, c), alors Infer se comporte de trois fa¸cons diff´erentes.
Si ¬eqEnv(G, supEnv(G, G1)) ∧ ¬incBottomEnv(supEnv(G, G1)) alors Infer est
invoqu´e comme Infer(supEnv(G, G1), i, pcwhile, while e do c end), avec pour r´e-
sultat (gres, j).
Si eqEnv(G, supEnv(G, G1))∧¬incBottomEnv(supEnv(G, G1)) alors l’analyse s’a-
ch`eve pour while et le r´esultat est (Gres, j).
Si incBottomEnv(supEnv(G, G1)), c’est-`a-dire que l’une des variables est asso-
ci´ee `a ⊥ dans supEnv(G, G1) alors l’algorithme ´echoue.
En ce qui concerne le syst`eme de types, deux r`egles sont applicables LOOP1 S et LOOP2 S, toutes les deux ont pour pr´emisses G, pc ` e : τ0 val et G, (pc t τ0) `
c : τ cmd, G0, nous savons que τ0 = t puisque le syst`eme de types et Infer
s’accordent sur le typage des expressions. Par l’hypoth`ese d’induction nous avons soit que G0 = G1 soit Infer et le syst`eme de types ´echoue. Dans le cas de non
´
echec, LOOP1 S est applicable si G0 = G t G0, et puisque t ´equivaut `a supEnv, dans ce cas G = supEnv(G, G1) = G t G0 et si G t G0 6A ⊥ alors l’analyse du
while s’ach`eve et produit G t G0 comme environnement r´esultant de Infer. On d´emontre que le mˆeme r´esultat est correct avec les r`egles de typage. L’´echec se produit avec les r`egles de typage lorsque G t G0 A ⊥ comme dans Infer. Si G0 6= G t G0 alors LOOP2 S est appliqu´ee et s’il n’y a pas d’´echec le while est
analys´e `a nouveau avec G t G0 comme environnement de d´epart et pc t τ0 comme
contexte de s´ecurit´e. C’est semblable `a l’invocation de Infer avec les mˆemes param`etres. L’analyse avec Infer tout comme la preuve avec les r`egles de typage termine car l’ensemble des variables est fini et l’op´erateur t est monotone par rapport `a la relation v.