Conditionnelles

Une extension naturelle consiste à considérer des processus avec des branches else. Cepen-dant, lorsque les messages émis sur ces branches peuvent dépendre, directement ou indirectement, de certaines constantes, il devient nécessaire que l’attaquant dispose d’un nombre arbitraire de constantes. Ce résultat négatif est déjà valable pour les propriétés d’accessibilité.

Étant donné un entier n arbitraire, nous notons Σⁿ un ensemble de cardinal n de constantes de type τ^?. Formellement, nous montrons que nous pouvons associer, pour chaque instance de PCP, deux protocoles P et Q (qui utilisent exclusivement le chiffrement symétrique et la paire) tels que P 6vatQ avec n constantes, si, et seulement si, l’instance de PCP a une solution de longueur plus petite que n. Il s’agit donc de modifier les protocoles de la section précédente pour que l’attaquant ne puisse vérifier sa solution que s’il dispose d’autant de constantes que la longueur (en nombre de tuiles) de la solution de PCP.

L’étape la plus nouvelle consiste à établir un moyen de vérifier que l’attaquant dispose d’une liste de constantes toutes différentes. Le nom D (avec δ(D) = τ_k) représente une clé inconnue de

l’attaquant, la variable x0

c représente une clé ajoutée par l’attaquant, de type δ(x0

c) = τc ∈ T , et les nonces nc, n⁰_c, ainsi que la constante ⊥ncet les variables xnc, x⁰_nc, sont de type τnc. ⊥ncpermet de représenter la liste vide.

V0(c) = in(c, x⁰_c).new nc.out(c, senc(hnc, x⁰_c, ⊥nci, D))

V₁(c) = in(c, senc(hx_nc, x¹_c, x⁰_nci, D)). in(c, senc(hy_nc, y¹_c, x⁰_nci, D)). if x¹_c 6= y1

cthen

new n⁰_c.out(c, senc(hn⁰_c, x¹_c, ynci, D))

Le processus V0 permet d’obtenir des jetons hnc, x⁰_c, ⊥nci. Ensuite, le principe de V1 est que les éléments de la liste a :: b :: ` sont deux à deux distincts si, et seulement si :

— les éléments des listes a :: ` et b :: ` sont deux à deux distincts ; — et a 6= b.

À ce titre, la construction if x1 c 6= y1

cthen a la sémantique attendue : elle continue de s’exécuter seulement si x1

c et y1

c sont instanciées par des valeurs différentes. Cette instruction peut se coder comme if x1

c = y1

cthen 0 else . . . . Si nous conservions chaque fois le même pointeur de tête, il se-rait facile d’obtenir hn1, a, n2i puis hn2, b, n1i, et ainsi de disposer d’une liste chaînée infinie avec seulement deux constantes. Le changement de pointeur, grâce au nonce n⁰_c, résout ce problème. Exemple 3.3. Si l’attaquant dispose de trois constantes a, b, c, il peut obtenir les termes suivants après trois utilisations de V0 :

ta= senc(hn1, a, ⊥nci, D) tb= senc(hn2, b, ⊥nci, D) tc= senc(hn3, c, ⊥nci, D)

Il peut donc en déduire par exemple t⁰_b = senc(hn⁰₂, b, n1i, D) et t⁰_c = senc(hn⁰₃, c, n1i, D) en appli-quant V1 à tb, t_a puis à tc, t_a. Enfin, il peut obtenir t⁰⁰_c = senc(hn⁰⁰₃, c, n⁰₂i, D) en appliquant V1 à t⁰_c, t⁰_b. Il pourra alors certifier qu’il possède trois constantes distinctes en fournissant t⁰⁰_c, t⁰_b et t_a, dont les nonces se suivent. Si il tente de tricher et d’utiliser deux fois la même constante, et récupère par exemple senc(hn₄, c, ⊥_nci, D), il peut arriver à obtenir senc(hn00

4, c, n⁰₂i, D), senc(hn00

2, b, n⁰₄i, D) ou senc(hn⁰₁, a, n₄i, D), mais à chaque fois ces termes représentent la tête d’une liste de trois constantes seulement. Il ne peut pas obtenir de liste plus longue sans utiliser une constante supplémentaire.

Plus formellement, démontrons le lemme suivant :

Lemme 3.3. Soit E = {senc(hn₁, a₀, n₀i, D), senc(hn₂, a₁, n₁i, D) . . . , senc(hn_k+1, a_k, n_ki, D)} un ensemble de termes. Posons P = {( ! new c⁰₀.out(c₀, c⁰₀).V₀(c⁰₀) | ! new c⁰₁.out(c₁, c⁰₁).V₁(c⁰₁))} et sup-posons (tr, φ) ∈ trace_Σ+

0(P), tels que E ⊆ img(φ). Alors pour tout i 6= j, a_i6= a_j.

Démonstration informelle. Nous procédons par récurrence sur k. Si k = 1, le résultat est évident. Supposons que le résultat soit vrai pour un k quelconque, et démontrons-le pour k + 1. Posons t_i= senc(hn_i+1, a_i, n_ii, D) pour tout i. Si l’attaquant a réussi à connaître l’ensemble {t1, . . . , t_k+1} alors il a réussi à connaître {t₁, . . . , t_k} et {t₁, . . . , t_k−1, t_k+1}. L’hypothèse de récurrence s’applique, et nous avons a_i 6= a_j pour tout i 6= j tels que i, j6 k. Or, comme le nom D n’est pas déductible (puisqu’il n’apparaît qu’en position de clé), l’attaquant a nécessairement appris t_k+1 après avoir

exécuté V1. Donc, il connaissait nécessairement senc(hn⁰_k+2, ak+1, n⁰_ki, D) et senc(hnk+1, a, n⁰_ki, D) avec n⁰_k+2, n⁰_k des noms et a 6= ak+1. Pour un nonce n donné, il n’existe qu’un seul terme de la forme senc(hn, _, _i, D), donc a = ak et n⁰_k = nk et ak+1 6= ak. En appliquant l’hypothèse de récurrence à {t1, . . . , tk−1, senc(hn⁰_k+2, ak+1, nki, D)}, nous obtenons de plus que ak+1 6= ai pour chaque i < k, ce qui démontre le résultat.

À partir de ce point, il suffit d’adapter les processus de la section précédente pour vérifier l’existence d’une liste chaînée de constantes toutes différentes au moins aussi longue que la solution. Nous modifions B pour que l’attaquant doive fournir un jeton senc(hp1, c, p2i, D) : charge à lui de pouvoir fournir les jetons suivants au moment de construire la solution. Les variables xp et x⁰_p vérifient δ(xp) = δ(xp) = τnc, et la variable x0 satisfait δ(x0) = τc :

B = in(c0, senc(hxp, x0, x⁰_pi, D)).out(c0, senc(h⊥U, ⊥V, xpi, K))

Nous modifions Pi(ci) en demandant à l’attaquant de fournir un jeton qui pointe vers la bonne adresse. À la fin, nous mettons à jour l’adresse cible pour la prochaine étape (le nonce n1du terme senc(hn1, m1, y_p⁰i, K)). Les données yp, y0, yp0 sont des variables, et δ(yp) = δ(y⁰_p) = τnc tandis que δ(y0) = τc. De plus, les jetons chiffrés par K contiennent maintenant une troisième information : en plus des pointeurs x et y vers les solutions en construction, ils contiennnent également un pointeur yp vers le dernier élément de la liste de constantes construite : de cette manière, l’attaquant doit fournir une constante différente pour chaque nouvelle tuile.

Pi(ci) = in(ci, senc(hy_p⁰, y0, ypi, D)).in(ci, senc(hx, y, ypi, K). new n₂.out(c_i, senc(hx, u¹_i, n₂i, U )).

. . .

new nk_i.out(ci, senc(hnk_i−1, u^ki

i , nk_ii, U )). new m₂.out(c_i, senc(hy, v_i¹, m₂i, V )).

. . .

new m_ji.out(c_i, senc(hm_ji−1, v^ji

i , m_jii, V )). out(ci, senc(hnki, mji, y_p⁰i, K)

Ces changements suffisent à garantir que l’attaquant ne peut obtenir la solution que s’il dispose d’autant de constantes que la taille de la solution, en nombre de tuiles. Les autres modifications (avec z⁰, z⁰⁰ des variables de type τnc) sont triviales :

C(cj) =in(cj, senc(hx⁰, y⁰, z⁰i, K). in(c_j, senc(hx⁰, z₁, z_pi, U ). in(cj, senc(hy⁰, z1, z⁰_pi, V ). out(c_j, senc(hz_p, z⁰_p, z⁰i, K) FP =in(cf, senc(hx⁰⁰, y⁰⁰, z⁰⁰i, K). in(cf, senc(hx⁰⁰, z2, ⊥Ui, U ). in(c_f, senc(hy⁰⁰, z₂, ⊥_Vi, V ). out(cf, a)

FQ=in(cf, senc(hx⁰⁰, y⁰⁰, z⁰⁰i, K). in(cf, senc(hx⁰⁰, z2, ⊥Ui, U ). in(cf, senc(hy⁰⁰, z2, ⊥Vi, V ). out(c_f, b)

Nous considérons les protocoles P et Q suivants :

P ={B, FP, ! new c⁰₁.out(c1, c⁰₁).P1(c₁⁰), . . . , ! new c⁰_n.out(cn, c⁰_n).Pn(c⁰_n), ! new c⁰_n+1.out(cn+1, c⁰_n+1).C(c⁰_n+1), ! new c⁰_n+2.out(cn+2, c⁰_n+2).V0(c⁰_n+2), ! new c⁰_n+3.out(cn+3, c⁰_n+3).V1(c⁰_n+3)}

Q ={B, FQ, ! new c⁰₁.out(c1, c⁰₁).P1(c₁⁰), . . . , ! new c⁰_n.out(cn, c⁰_n).Pn(c⁰_n), ! new c⁰_n+1.out(c_n+1, c⁰_n+1).C(c⁰_n+1), ! new c⁰_n+2.out(c_n+2, c⁰_n+2).V₀(c⁰_n+2), ! new c⁰_n+3.out(cn+3, c⁰_n+3).V1(c⁰_n+3)}

Il est clair que P et Q sont conformes au système de type (T , δ). Concernant les ensembles de constantes, nous avons Σ_P = Σ_Q= {⊥V, ⊥U, ⊥nc}.

Proposition 3.2. Il existe un témoin quasiment typé de non-inclusion P 6vat Q par rapport à Σⁿ] (Σ_P∪ Σ_Q) si, et seulement si, l’instance de PCP considérée admet une solution de longueur au plus n.

Démonstration informelle. Si l’instance de PCP admet une solution de longueur au plus n, il est facile de construire un témoin quasiment typé, en utilisant les constantes différentes pour obtenir une liste chaînée (par les nonces) de constantes.

Réciproquement, supposons qu’il existe un témoin quasiment typé de P 6v_at Q par rapport à Σn] {⊥_V, ⊥_U, ⊥_nc}. Nous admettons, comme pour la proposition 3.1, qu’il existe une solution de l’instance de PCP. Il reste à montrer que cette solution est de longueur au plus n.

La solution a été construite à travers les processus Pi et donc pour chaque tuile, l’attaquant a dû fournir senc(hyp, y0, y_p⁰i, D) avec yp0 un pointeur vers une constante précédente. De plus, comme le témoin est quasiment typé, la variable y0 a dû être instanciée par un terme t tel que δ(t) 4 δ(y0) = τc : nécessairement t est une donnée. Comme l’attaquant ne connaît aucune autre donnée que les constantes de Σn] {⊥V, ⊥U, ⊥nc}, il a utilisé chaque fois l’une de ces constantes. D’après le lemme 3.3, les constantes utilisées sont deux à deux distinctes. Nécessairement, l’attaquant dispose de plus de constantes de type τ^? qu’il n’y a de tuiles dans la solution, donc n > ` où ` est la longueur de la solution.