Typage

L’objet de ce chapitre est de limiter l’espace de recherche pour les traces de non-inclusion en se limitant aux traces bien typées. Un tel résultat est toujours vrai pour le système de type trivial où tous les termes ont le même type ; la section 2.2.1 définira les systèmes de types en général, ainsi que les systèmes structurés qui nous intéresseront plus particulièrement, puis la section 2.2.2 énoncera les conditions qu’un système de types doit vérifier, par rapport à un protocole donné, pour démontrer le résultat. La section 2.2.3 énoncera les théorèmes qui seront démontrés dans ce chapitre.

2.2.1 Système de types

Définissons d’abord un système de types en toute généralité.

Définition 2.1. Un système de types est la donnée d’une paire (T , δ) où T est un ensemble de types, δ une fonction qui envoie les termes de t ∈ T₀(Σ_c, Σ⁺₀ ∪ N ∪ X ) sur des types de T , et (T , δ) vérifie les propriétés suivantes :

— Si t est un terme et σ une substitution bien typée, alors δ(tσ) = δ(t).

— Pour tous sous-termes unifiables t et t⁰de même type, c’est-à-dire δ(t) = δ(t⁰), leur unificateur le plus général (mgu(t, t⁰)) est bien typé.

où une substitution σ est bien typée si pour tout d ∈ dom(σ), δ(dσ) = δ(d).

Une exécution K=^tr=⇒ (P; φ; σ; i) est bien typée si σ est une substitution bien typée, et lorsqu’il existe une telle exécution, on dit également que tr est bien typée. L’un des avantages à considérer seulement les exécutions bien typées consiste à pouvoir borner la taille des messages en termes de nombre d’opérations cryptographiques, c’est-à-dire leur profondeur comme termes. Les systèmes de types structurés donnent naturellement cette propriété.

Définition 2.2. On appelle système de types structuré la donnée d’une paire (T₀, δ₀) où T₀ est un ensemble de types initiaux et δ0 une fonction qui envoie les données de Σ⁺₀ ] N ] X vers les types τ engendrés par la grammaire suivante :

τ, τ1, τ2= τ0| f(τ1, . . . , τn) avec f ∈ Σc et τ0∈ T0

Ensuite, δ0 est étendue aux termes constructeurs de la façon suivante : δ0(f(t1, . . . , tn)) = f(δ0(t1), . . . , δ0(tn)) avec f ∈ Σc

Comme la définition 2.2 ne l’indique pas directement, le lemme suivant montre que les systèmes de types structurés sont bien des systèmes de types.

Lemme 2.1. Soit (T₀, δ) un système de types structuré. Alors (T (Σ_c, T₀), δ) est un système de types comme dans la définition 2.1.

Démonstration. Nous devons prouver les deux énoncés suivants :

— Si t est un terme et σ une substitution bien typée, alors δ(tσ) = δ(t).

— Pour tous termes unifiables t et t⁰ de même type, leur unificateur le plus général mgu(t, t⁰) est bien typé.

Le premier item se prouve par récurrence sur t. Si t est une donnée et t /∈ dom(σ), alors tσ = t d’où δ(tσ) = δ(t). Si t ∈ dom(σ), alors δ(tσ) = δ(t) car σ est bien typée. Si t = f(t1, . . . , tn), alors δ(f(t1, . . . , tn)) = f(δ(t1), . . . , δ(tn)) par définition de δ pour les termes composés. De même :

δ(tσ) = δ(f(t1, . . . , tn)σ) = δ(f(t₁σ, . . . , t_nσ)) = f(δ(t1σ), . . . , δ(tnσ))

Par hypothèse de récurrence, pour chaque i, δ(tiσ) = δ(ti) et donc δ(tσ) = δ(t), ce qui conclut la preuve de cet item.

Prouvons maintenant le second item. Étant donné un ensemble Γ d’équations bien typées, on note #vars(Γ) le nombre de variables de Γ, et |Γ| sa taille, à savoir

X

t=t0∈Γ

(|t| + |t⁰|)

où |t| est le nombre de symboles dans t. Notre mesure kΓk est déterminée par ces deux éléments dans l’ordre lexicographique. Prouvons que mgu(Γ) est bien typé par récurrence sur kΓk, en nous appuyant sur cette mesure.

Initialisation. kΓk = (0, 0), c’est-à-dire Γ = ∅, et donc le résultat est évident. Hérédité. Γ = Γ⁰] {t = t⁰}. Plusieurs cas se présentent :

— t ou t⁰ est une variable. Alors on suppose, sans perte de généralité, que t est une variable x, et on pose σ = {x . t⁰}. σ est bien typée car les équations de Γ sont bien typées. De plus, en appliquant l’hypothèse de récurrence sur Γ⁰, on déduit que mgu(Γ⁰) est bien typé, et donc la substitution {x . t⁰mgu(Γ⁰)} est bien typée. Il en découle que mgu(Γ) = mgu(Γ⁰) ] {x . t⁰mgu(Γ⁰)} est bien typé.

— t est une donnée, mais pas une variable. Dans ce cas, t⁰ est aussi une variable puisque δ(t) = δ(t⁰), et t⁰n’est pas une variable (ou bien on est ramené au cas précédent). Comme t et t⁰ sont unifiables, t = t⁰et mgu(Γ) = mgu(Γ⁰), avec kΓ⁰k < kΓk. Par hypothèse de récurrence, mgu(Γ⁰) est bien typé, donc mgu(Γ) est bien typé.

— t est un terme composé : t = f(t1, . . . , tk). Dans ce cas, t⁰ = f(t⁰₁, . . . , t⁰_k) car t⁰ n’est pas une variable et t et t⁰ sont unifiables. On en déduit que mgu(Γ) = mgu(Γ⁰⁰) avec Γ⁰⁰ = Γ ] {t1 = t⁰₁, . . . , tk = t⁰_k}. Γ⁰⁰ est un ensemble d’équations bien typées et kΓ⁰⁰k < kΓk donc mgu(Γ⁰⁰) est bien typé par hypothèse de récurrence.

Dans la suite, nous supposerons l’existence d’un nombre infini de constantes de chaque type dans chacun des ensembles Σ⁻₀, Σatom

fresh et Σ^bitstring_fresh . L’exemple suivant donne un exemple de système de types structuré, à partir du protocole d’Otway-Rees introduit dans le chapitre précédent. Exemple 2.2. La modélisation du protocole d’Otway-Rees, dans l’exemple 1.12, s’appuyait sur les données

x, ya, yb, ym, zm, z¹_senc, z_senc² , zab∈ X a, b ∈ Σ⁻₀, m, n_a, n_b, k_as, k_bs, k_ab∈ N

Considérons l’ensemble de types initiaux T₀ = {τ_a, τ_b, τ_m, τ_na, τ_nb, τ_as, τ_bs, τ_ab}. La fonction de typage δ se définit naturellement sur les noms et les constantes, par exemple δ(a) = τ_a, δ(m) = τ_m,

δ(na) = τna, δ(kas) = τas. Sur les variables, on peut donner le type attendu pour une exécution honnête :

δ(x) = δ(z_ab) = τ_ab δ(y_a) = τ_na δ(y_b) = τ_nb δ(y_m) = δ(z_m) = τ_m δ(z¹_senc) = senc(hτ_na, τ_m, τ_a, τ_bi⁴, τ_as) δ(z_senc² ) = senc(hτ_na, τ_abi², τ_as)

La substitution σ de l’exemple 1.13 est bien typée pour ce système de type, et le témoin tr⁰ de l’exemple 1.16 est donc un témoin bien typé. Si l’on avait donné des types différents à kabet x, alors il n’y aurait eu aucun témoin de non-inclusion bien typé, puisque senc(hna, kabi2, kas) est le seul message connu de l’attaquant qui peut s’unifier avec senc(hna, kabi2, kas), et que cette unification serait interdite par le système de types.

Un autre système de types (T₀⁰, δ⁰) intéressant consiste à prendre T₀⁰ = T0] {τf wd} et δ⁰ qui coïncide avec δ sauf pour δ⁰(z1

senc) = δ⁰(z2

senc) = τ_{f wd}, De cette manière, le témoin tr⁰ est mal typé, mais il existe un autre témoin (par rapport à Σ⁺₀)

tr⁰⁰= out(cA, w1).in(cB, R1).out(cB, w2).in(cS, R2).out(cS, w3).in(cA, R).phase 1.out(c, w4) où R a été définie à l’exemple 1.13, et :

R1= hproj⁴₁(w1), a, b, cf wdi4

R₂= hproj⁴₁(w₁), a, b, proj₄⁴(w₁), proj⁴₄(w₂)i⁵ avec c_{f wd} ∈ Σ+

0 une constante de l’attaquant de type δ(c_{f wd}) = τ_{cf w}. Il est facile de transformer tr⁰⁰ en un témoin par rapport à Σ⁻₀ en appliquant le renommage ρ = {c_{f wd}. c} avec c ∈ Σ⁻₀ : tr⁰⁰ρ est alors un témoin par rapport à Σ⁻₀. L’utilité des constantes de Σ_fresh sera plus claire à partir de l’exemple 2.8. Les exécutions bien typées pour (T₀⁰, δ⁰) ont l’avantage de ne pas affecter de messages composés aux variables z1

senc et z2 senc.

2.2.2 Conformité

Nous avons vu dans l’exemple 2.2 qu’il n’était pas possible d’exiger des témoins bien typés pour certains systèmes de types trop contraignants. Plus précisément, lorsque le système de types empêche certaines unifications, une partie des processus peut se transformer en code mort. Une restriction naturelle consisterait à imposer que tous les sous-termes unifiables aient le même type, mais alors seuls des systèmes de types triviaux seraient autorisés. Il faut donc choisir une hypothèse plus fine, et qui concerne uniquement les sous-termes chiffrés. Ces sous-termes sont définis par opposition aux symboles transparents, c’est-à-dire inversibles.

Formellement, soit n un entier et f ∈ Σ_cun symbole d’arité n. Nous disons que f est transparent s’il existe un terme f(Rf

1, . . . , Rf

n) ∈ T (Σ, ), noté Cf, tel que pour tout t ∈ T₀(Σ, Σ⁺₀ ] N ] X ) avec root(t) = f, on a f(Rf

1, . . . , Rf

n){ . t}↓ = t. Pour tout terme t, on note Cf[t] = Cf{ . t}. Intuitivement, les symboles transparents correspondent à des termes qui peuvent toujours être ouverts par l’attaquant, comme les paires ou les tuples. Les sous-termes chiffrés ESt (t) d’un terme t sont les sous-termes de t dont la racine n’est pas transparente, c’est-à-dire

ESt (t) = {u ∈ St (t) | u est un terme composé et root(u) n’est pas transparent.} Exemple 2.3. Considérons les symboles hi2 et senc de la signature Σstd

n définie en section 1.1.7. Pour tout message t avec root(t) = h·, ·i2, t = hproj²₁(t), proj²₂(t)i2↓, et donc C_hi2 = hproj²₁(), proj²2()i2. Au contraire, le symbole de fonction senc n’est pas transparent car la seule règle qui contient senc ne permet pas d’en déduire la clé.

Les sous-termes chiffrés d’une configuration initiale (P; φ; ∅; i) sont les sous-termes chiffrés de P et ceux de φ. Nous pouvons maintenant exprimer notre hypothèse sur les systèmes de types, qui suit celles de Chrétien, Cortier et Delaune [51] et Blanchet et Podelski [38].

Définition 2.3. Soit Σ0 un ensemble de constantes. Soit K une Σ0-configuration initiale. On dit que K est conforme au système de types (T , δ) si tous les sous-termes chiffrés unifiables ont le même type, c’est-à-dire si pour tous t, t⁰ ∈ ESt (K), δ(t) = δ(t⁰) chaque fois que t et t⁰ sont unifiables.

Dans les cas usuels, il est facile de savoir quels sont les symboles transparents, et les contraintes sur nos règles de réécriture, comme la propriété des sous-termes pour les théories à construc-teurs, doivent permettre de décider si un symbole est transparent ou non. Cependant, comme la conformité porte uniquement sur les sous-termes chiffrés, il est superflu de savoir exactement quels sont les symboles transparents : simplement, lorsque nous savons qu’un symbole est transparent, l’hypothèse nous autorise à ne pas prendre en compte certaines unifications.

Revenons à notre exemple de référence.

Exemple 2.4. Les processus P_OR⁰ et P_OR⁰⁰ introduits par l’exemple 1.16 sont conformes aux sys-tèmes de types (T0, δ) et (T₀⁰, δ⁰) décrit dans l’exemple 2.2. En effet, les sous-termes chiffrés de P_OR⁰ et P_OR⁰⁰ sonti ceux de POR, c’est-à-dire :

senc(hn_a, m, a, bi⁴, k_as) senc(hn_a, xi², k_as) senc(hy_a, y_m, a, bi⁴, k_as) senc(hy_a, k_abi2, k_as) senc(hy_b, y_m, a, bi⁴, k_bs) senc(hn_b, z_abi², k_bs) senc(hn_b, z_m, a, bi⁴, k_bs) senc(hy_b, k_abi², k_bs) Les termes ne sont unifiables que s’ils sont chiffrés par la même clé (kas ou kbs). Une fois la clé fixée, la taille des tuples empêche toutes les unifications, hormis les unifications honnêtes, et donc les protocoles P_OR⁰ et P_OR⁰⁰ sont conformes à (T0, δ). Comme (T₀⁰, δ⁰) ne diffère de (T0, δ) que sur z¹_senc et z_senc² , qui n’apparaissent pas dans les sous-termes chiffrés, les protocoles P_OR⁰ et P_OR⁰⁰ sont également conformes à (T₀⁰, δ⁰). Pour chacun de ces systèmes de types, l’exemple 2.2 donnait un témoin bien typé.

Au contraire, ces deux protocoles ne sont pas conformes à l’autre système de types envisagé dans l’exemple 2.2, où x et k_ab ne sont pas de même type, car alors les sous-termes chiffrés unifiables senc(hn_a, xi2, k_as) et senc(hy_a, k_abi2, k_as) n’ont pas le même type. Rappelons qu’il n’existe aucun témoin bien typé pour ce système de types.

L’objet de ce chapitre est de démontrer que l’exemple 2.4 se généralise, c’est-à-dire que pour tous protocoles et tout système de types, lorsque les protocoles sont conformes au système de types, il suffit d’explorer les traces bien typées pour démontrer l’équivalence des protocoles.

2.2.3 Énoncé des résultats du chapitre

Dans ce chapitre, nous démontrons que, pour l’accessibilité et l’équivalence, s’il existe une trace tr, il existe une trace tr⁰bien typée telle que tr⁰ et tr partagent la même séquence d’émissions (out) et de réceptions (in) de messages sur les mêmes canaux. En d’autres termes, tr et tr⁰ ont le même squelette tr.

Pour chaque Σ0-trace tr, la séquence tr est définie récursivement par : — Si tr est vide, alorstr = tr.

— Si tr = tr⁰.phase i pour un certain entier i, alors tr = tr0.phase i. — Si tr = tr⁰.out(c, w) pour un certain w ∈ W, alors tr = tr0.out(c, _). — Si tr = tr⁰.in(c, R) pour une certaine Σ₀-recette R alors tr = tr⁰.in(c, _).

Le résultat constitue une étape intermédiaire pour le théorème principal, qui porte sur l’équi-valence, mais possède un intérêt indépendant.

Théorème 2.1. Soit K_P une Σ⁻₀-configuration conforme à un système de types (T₀, δ₀). Si K_P =^tr=⇒ (P; φ; σ; i) par rapport à Σ⁻₀ alors il existe une exécution bien typée K_P ^tr

0

==⇒ (P; φ⁰; σ⁰; i) par rapport à Σ⁺₀ telle que tr0= tr.

Réciproquement, si K_P ^tr

0

==⇒ (P; φ⁰; σ⁰; i) est une exécution bien typée par rapport à Σ⁺₀, alors il existe une exécution KP

tr

==⇒ (P; φ; σ; i) par rapport à Σ⁻₀ telle que tr = tr⁰.

Ce résultat est suffisant pour modéliser certaines propriétés d’accessibilité, comme le secret. Par exemple, toute trace de P |in(c, s) contenant une réception sur le canal c est un témoin d’attaque sur le secret de s ∈ N , pourvu que c n’apparaisse pas dans le processus P . La démonstration de ce théorème sera exposée dans la section 2.4. Les constantes de Σ_fresh permettent de remplacer des termes composés d’une exécution arbitraire dans une exécution bien typée : le terme t sera remplacé par une constante c ∈ Σ_fresh du bon type.

Nous en arrivons au théorème principal de cette section.

Théorème 2.2. Soient K_P une Σ⁻₀-configuration conforme à (T0, δ₀) et K_Q une Σ⁻₀-configuration déterministe. On a K_P 6vatKQ par rapport à Σ⁻₀ si, et seulement si, il existe un témoin bien typé (tr, φ) ∈ trace_Σ+

0(K_P) de cette non-inclusion.

Seule la configuration KP doit être conforme au système de types, puisque la trace n’est bien typée que par rapport à KP. De plus, comme l’inclusion de trace stipule que le protocole KQ doit pouvoir imiter toute exécution de KP, l’attaquant peut choisir l’exécution exacte de KP qui doit être imitée, donc le déterminisme n’est utile que pour KQ. Ce théorème sera démontré précisément dans la section 2.5.