Évaluation des contraintes

     

accesses(user(1 , level(0(1(nil)))), object(1 , level(0(1(nil)))), read), accesses(user(1 , level(0(1(nil)))), object(1 , level(1(0(nil)))), write), accesses(user(1 , level(1(0(nil)))), object(1 , level(0(1(nil)))), read), accesses(user(2 , level(1(0(nil)))), object(2 , level(0(0(nil)))), write) tredlist= nilredlist et tblacklist= nilblacklist.

4.2.2 Évaluation des contraintes

Pour permettre la spécification des règles de transition et de politiques de sécu-rité, il est nécessaire de pouvoir évaluer les formules sûres dans un environnement donné à partir de sa représentation symbolique. La méthode retenue doit permettre de vérifier les propriétés précédemment évoquées sur les systèmes de réécriture ainsi que l’analyse des systèmes sécurisés obtenus. Les développements récents concer-nant la vérification de propriétés de systèmes décrits par des systèmes de réécriture ([Rusu, 2010,Rocha and Meseguer, 2011,Rocha, 2011]) nécessitent l’introduction de la notion de systèmes de réécriture « topmost » ou système de réécriture « à la ra-cine ».

Définition 4.26. Soit Σ une signature. On appelle système de réécriture à la racine sur Σ tout système de réécriture R tel qu’il existe une sorte stop de Σ vérifiant les propriétés suivantes :

• pour tout symbole f : s1× . . . × sn→ s, si 6= stop,

• pour toute règle lhs → rhs de R, lhs et rhs sont des termes de sorte stop. Les travaux évoqués présentent des méthodes de vérification de propriétés pour les systèmes de réécriture à la racine. C’est la raison pour laquelle nous nous attachons dans la suite à montrer que les différents processus (évaluation des requêtes, relations de transition, politiques de sécurité, . . . ) peuvent être modélisés au moyen de tels systèmes.

Proposition 4.27. Soit teo une théorie de sécurité, il existe :

• une extension de Σsym

teo notée ΣAR teo,

• un système de réécriture à la racine RAR sur ΣAR

teo, convergent, tels que pour toute formule sûre ϕ de ˜ΣEnv

teo = (S, F, P), il existe :

• un terme γteo(ϕ) de T (ΣAR teo,X ),

• une application σϕ :Var(γteo(ϕ))→ P tels que pour tout environnement η ∈ Env(teo) :

ση ϕ(γ_teo(ϕ))−→^∗ R_AR done( t1 1, . . . , t1 n  :: . . . :: h tm 1 , . . . , tm n i :: [ ]) si et seulement si η |= {x1 7→ tk 1, . . . , xn 7→ tk

n}(ϕ) pour tout k (à l’ordre des éléments de la liste près) où ση

(done est un symbole de ΣAR

teo et :: et [ ] sont utilisés en remplacement de cons et nil pour des raisons de lisibilité).

}Démonstration. Soit ϕ une formule sûre sur ˜Σ = (S, F, P). Alors, le théorème de Codd nous assure que l’on peut construire une expression basée sur les opéra-teurs de l’algèbre relationnelle évaluant ϕ dans n’importe quelle interprétation dans laquelle les prédicats sont interprétés par des relations finies [Codd, 1972] (l’algo-rithme correspondant est connu sous le nom d’algo(l’algo-rithme de réduction de Codd). En conséquence, étant donnée une formule sûre ϕ, on peut calculer une expression de l’algèbre relationnelle exprimée en fonction des prédicats de P. Par exemple, la formule ϕ = ∀x, q(x) ⇒ ∃y, p(x, y) peut se traduire par l’expression de l’algèbre relationnelle suivante : q \ (u1/2(p)) = ∅. Pour modéliser les expressions de l’algèbre relationnelle et l’évaluation de ces dernières par un système de réécriture à la racine, nous introduisons les symboles suivants :

_ . _ : OperationsList × ArgumentsList → Computation

symbolisant l’application de l’opération en-tête de la « pile d’opérations » en partie gauche du symbole . aux arguments en tête de la « pile des arguments » en partie droite du symbole . . Les termes de sorte OperationsList sont des listes de termes de sorte Operation et les termes de sorte ArgumentsList sont des listes de termes de sorte Argument. Pour des raisons de lisibilité, nous utiliserons les mêmes symboles de constructeurs de listes ( :: et [ ]). Ainsi, ΣAR

teo contient les symboles suivants de sorte Operation :

• uniondécrivant l’union de deux listes,

• diff décrivant la différences entre deux listes,

• prod_k1,k2 décrivant le produit cartésien entre une liste de k1-uplets et une liste de k2-uplets,

• proj_k1,...,km/k décrivant la projection des k-uplets d’une liste sur les compo-santes k1, . . . , k_m,

• join_k1,k2/k,k0 décrivant la jointure d’une liste de k-uplets et d’une liste de k0 -uplets lorsque la k1^èmecomposante des tuples de la première liste coïncide avec la k2^ème composante des tuples de la seconde,

• empty, modélisant le test du caractère vide d’une liste,

• isIn, modélisant le test d’appartenance d’un élément à une liste,

• first, min, max réfèrant respectivement au premier, plus petit et plus grand élément d’une liste,

• infNat, infBoolList, représentant respectivement les tests d’infériorité pour les ordres évoquées dans la section précédente,

• eq_s, décrivant le test d’égalité entre deux termes de sorte s,

• select_k1,k2/k décrivant la sélection (restriction) des k-uplets d’une liste à ceux dont la comparaison entre les k1^ème et k2^ème composantes correspond au com-parateur passé en paramètre (faisant référence à eq, infNat ou infBoolList),

• select_k0/k décrivant la sélection (restriction) des k-uplets d’une liste à ceux dont la comparaison de la kème composante avec le tuple en argument corres-pond au comparateur passé en paramètre,

4.2. SÉMANTIQUES BASÉES SUR LA RÉÉCRITURE

• swap_k/k0 décrit l’inversion des kème et k0ème arguments dans la liste des argu-ments.

Le terme γteo(ϕ) s’écrit alors : proj1/2:: swap_1/2:: diff :: empty :: [ ] . xp:: xq:: [ ]. Pour permettre au lecteur de se faire une idée précise du système de réécriture RAR

sans toutefois en énumérer toutes les règles, les règles de réécriture associées aux principales opérations sont données par la figure 4.1. Elles ne présentent aucune dif-ficulté particulière et sont construites à partir des algorithmes fonctionnels effectuant les opérations usuelles sur les listes. Pour obtenir un système de réécriture à la ra-cine, les opérations à effectuer sont regroupées sous la forme d’une liste d’opérations et les opérandes sous regroupés sous la forme d’une liste d’arguments. Le système de réécriture obtenu fournit un processus d’évaluation de toute formule sûre sur un environnement donné à partir du terme ση

ϕ(γ_teo(ϕ)).

~

Exemple 4.28. Pour bien comprendre le principe de fonctionnement du sys-tème RAR, étudions la réduction du terme ση

ϕ(γ_teo(ϕ)) où ϕ = ∀x, q(x) ⇒ ∃y, p(x, y) lorsque pη ={(a, b)} et qη ={a}.

proj1/2:: swap1/2:: diff :: empty :: [ ] � cons(� a, b �2, nil) :: cons(� a �1, nil) :: [ ]

��

projaux

1/2:: swap1/2:: diff :: empty :: [ ] � cons(� a, b �2, nil) :: nil :: cons(� a �1, nil) :: [ ]

��

projaux

1/2:: swap1/2:: diff :: empty :: [ ] � nil :: cons(� a �1, nil) :: cons(� a �1, nil) :: [ ]

��

swap1/2:: diff :: empty :: [ ] � cons(� a �1, nil) :: cons(� a �1, nil) :: [ ]

��

diff :: empty :: [ ] � cons(� a �1, nil) :: cons(� a �1, nil) :: [ ]

��

diffaux:: empty :: [ ] � cons(� a �1, nil) :: cons(� a �1, nil) :: nil :: [ ]

��

isIn :: diffif:: empty :: [ ] � � a �1:: cons(� a �1, nil) ::� a �1:: nil :: cons(� a �1, nil) :: nil :: [ ]

��

eq :: or :: isIn :: diffif:: empty :: [ ] � � a �1::� a �1::� a �1:: nil ::� a �1:: nil :: cons(� a �1, nil) :: nil :: [ ]

��

eq :: or :: isIn :: diffif:: empty :: [ ] � a :: a ::� a �1:: nil ::� a �1:: nil :: cons(� a �1, nil) :: nil :: [ ]

��

or :: isIn :: diffif:: empty :: [ ] � � :: � a �1:: nil ::� a �1:: nil :: cons(� a �1, nil) :: nil :: [ ]

��

diffif:: empty :: [ ] � � :: � a �1:: nil :: cons(� a �1, nil) :: nil :: [ ]

��

diffaux:: empty :: [ ] � nil :: cons(� a �1, nil) :: nil :: [ ]

�� empty :: [ ] � nil :: [ ] �� [ ] � � :: [ ] �� done(�)

(Les éléments soulignés correspondent aux symboles permettant de déterminer la règle de réécriture à appliquer).

[ ] . x :: q → done(x)

and :: q . > :: q⁰ → q . q⁰

and :: h :: q . ⊥ :: x :: q⁰ → q . ⊥ :: q⁰

or :: q . ⊥ :: q0 → q . q0

or :: op :: q . > :: x1:: . . . :: xm:: q⁰ → q . > :: q0 pour tout opérateur op d’arité m eq :: q . f (x1, . . . , xn) :: g(y1, . . . , ym) :: q⁰ → q . ⊥ :: q0

pour tous symboles f 6= g

eq :: q . f () :: f () :: q⁰ → q . > :: q0

pour tout symbole f d’arité 0

eq :: q . f (x1, . . . , xn) :: f (y1, . . . , yn) :: q⁰

→ eq :: and :: eq :: . . . :: and :: eq :: q . x1:: y₁:: . . . :: x_n:: y_n:: q0

pour tout symbole f d’arité n6= 0 proj_k1,...,km/k:: q . l :: q⁰ → projaux

k1,...,km/k:: q . l :: nil :: q⁰ projaux k1,...,km/k:: q . nil :: q⁰ → q . q⁰ projaux k1,...,km/k:: q . cons(h x1, . . . , x_kik, z) :: u :: q0 → projaux k1,...,km/k:: q . z :: cons(h xk1, . . . , x_kmim, u) :: q⁰ isIn :: q . x :: nil :: q⁰ → q . ⊥ :: q0

isIn :: q . x :: cons(y, z) :: q⁰ → eq_s :: or :: isIn :: q . x :: y :: x :: z :: q0

diff :: q . l :: l⁰:: q⁰ → diffaux:: q . l :: l⁰:: nil :: q⁰ diffaux:: q . nil :: l :: q0 → q . q0

diffaux:: q . cons(x, y) :: z :: u :: q0

→ isIn :: diffif:: q . x :: z :: x :: y :: z :: u :: q⁰

diffif:: q . ⊥ :: x :: y :: z :: u :: q0 → diffaux:: q . y :: z :: cons(x, u) :: q0

diffif:: q . > :: x :: y :: z :: u :: q0 → diffaux:: q . y :: z :: u :: q0

prod_k,k0:: q . l :: l0:: q0 → prodaux

k,k0:: q . l :: l0:: nil :: q0 prodaux k,k0:: q . nil :: l :: q0 → q . q0 prodaux k,k0:: q . cons(x, y) :: z :: u :: q0 → distaux k,k0:: prodaux k,k0:: q . x :: z :: y :: z :: u :: q⁰ distaux k,k0:: q . x :: nil :: y :: z :: u :: q0 → q . y :: z :: u :: q0 distaux k,k0:: q . h x1, . . . , x_kik :: cons(h v1, . . . , v_k0ik0, v) :: y :: z :: u :: q0 → distaux k,k0:: q . h x1, . . . , x_ki_k :: v :: y :: z :: cons(h x1, . . . , x_k, v1, . . . , v_k0i_k+k0, u) :: q⁰ first :: q . cons(x, l) :: q0 → q . x :: q0 empty :: q . cons(x, l) :: q⁰ → q . ⊥ :: q⁰ empty :: q . nil :: q⁰ → q . > :: q0

Figure 4.1 – Règles associées aux principales opérations de l’algèbre relationnelle 92

4.2. SÉMANTIQUES BASÉES SUR LA RÉÉCRITURE

À noter que l’intérêt du système de réécriture obtenu n’est pas l’efficacité de l’éva-luation mais sa spécification particulière permettant de tirer profit des techniques de vérification précédemment évoquées ainsi que des techniques de preuves inductives (ce point sera discuté dans la section 4.3).