thèse de doctorat

Département de formation doctorale en informatique École doctorale IAEM Lorraine
UFR STMIA
Résolution de problèmes d’accessibilité

pour la compilation et la validation de
protocoles cryptographiques
THÈSE
présentée et soutenue publiquement le 9 décembre 2003
pour l’obtention du
Doctorat de l’université Henri Poincaré – Nancy 1

(spécialité informatique)
par
Yannick Chevalier
Composition du jury
Rapporteurs : Ahmed Bouajjani Professeur à l’Université Paris VII
Denis Lugiez Professeur à l’Université de Provence Marseille
Examinateurs : Nacer Boudjlida Professeur à l’Université Henri Poincaré Nancy 1
Michael Rusinowitch Directeur de Recherche INRIA, Nancy
Peter Ryan Professeur à l’Université de Newcastle upon Tyne
Laurent Vigneron Maı̂tre de Conférences à l’Université Nancy 2
Laboratoire Lorrain de Recherche en Informatique et ses Applications — UMR 7503

Mis en page avec la classe thloria.
Résumé
La généralisation de transactions commerciales et des services sur des supports non-sécurisés a
rendu nécessaire l’utilisation de protocoles permettant de garantir aux participants la confidentialité
des données aussi bien que l’identification des correspondants. De nombreux protocoles proposés se
sont révélés incorrects. Leur importance économique a motivé l’introduction de méthodes formelles
pour la détection d’erreurs.
Dans cette thèse, nous nous intéressons aux problèmes liés à l’analyse automatique de ces
protocoles. Nous donnons une sémantique opérationnelle aux spécifications de haut niveau habi-
tuellement utilisées, étendons le cadre standard de l’analyse pour prendre en compte les propriétés
des opérateurs algébriques pour la recherche de failles et considérons le problème de la vérification
de protocoles. Nous réduisons ces problèmes à des problèmes d’accessibilité pour des systèmes de
transitions définis par des règles de réécriture sur des ensembles. Cette réduction permet de don-
ner la complexité de ces problèmes, et est une première étape vers une résolution par des outils
entièrement automatiques.
Mots-clés: Protocole cryptographique, problème d’accessibilité, procédure de décision, complexité,

validation symbolique de modèles, sémantique opérationnelle.
Abstract
Commercial transactions and services over insecure networks have lead to the use of security
protocols. These protocols ought to provide both data confidentiality and participants authenti-
cation, but many of those proposed up to date have turned out to be flawed. Their economical
importance has motivated the introduction of formal verification.
In this dissertation, we investigate the problems raised by the automatic analysis of such proto-
cols. We give an operationnal semantics to high-level protocol specifications, extend the standard
Dolev-Yao framework to algebraic operators and finally consider the problem of protocol verifica-
tion. We reduce these problems to reachability problems. This reduction is a first step toward the
implementation of an automatic analysis tool.
Keywords: Cryptographic protocol, reachability problem, decision procedure, complexity, sym-

bolic model-checking, operationnal semantics.
iii
Remerciements
Je tiens tout d’abord à remercier mes deux directeurs de Thèse, Laurent Vigneron et Mi-
chael Rusinowitch, qui m’ont accueilli dans l’équipe Protheo, puis Cassis. À Michael d’abord, pour
m’avoir accepté en thèse. Mais surtout à tous les deux pour m’avoir pendant quatre ans guidé, lu,
corrigé, aidé. Pour faire court, je les remercie pour m’avoir fait découvrir la recherche, pour leur
humour et pour leur disponibilité.
Je remercie aussi Denis Lugiez et Ahmed Bouajjani pour avoir accepté d’être rapporteurs de
ma thèse, et pour le temps consacré à ce travail.
Je suis aussi très honoré que Peter Y. Ryan ait accepté de faire partie du jury et de lire avec
sérieux ce document dans une langue qui n’est pas la sienne. Je remercie aussi Nacer Boudjlida qui
m’a fait l’honneur de présider ce jury.
Je remercie aussi les les personnes avec lesquelles j’ai collaboré au cours de ces presques quatre
années. Mathieu Turuani, tout d’abord, avec qui j’ai échangé des points de vue pendant plus de
trois ans. Je remercie aussi Ralf Küsters, avec qui les discussions ont été parfois longues, mais
très fructueuses, Medhi Bouallagui, dont l’aide a été très précieuse pendant les phases de codage,
Sophie à la patience inégalée, Silvio, Tarek, Judson, Imine, Huy, Alakesh et Véronique.
Je remercie aussi les membres des projets AVISS et AVISPA, et tout particulièrement Luca
Viganò, qui a souvent su trouver les mots justes pour me motiver dans le long travail impliqué par
ces projets.
Je tiens aussi à remercier les membres de l’Université Henri Poincaré et de l’Université Nancy
2, et en premier lieu Jean-Pierre Jacquot qui n’a pas hésité à soutenir ma candidature sur un poste
d’ATER, me permettant ainsi de faire ma thèse à Nancy. Je remercie aussi Jeanine Souquières,
Marie-Jo Vigneron, Claude Millot qui m’ont suffisamment fait confiance pour me laisser la res-
ponsabilité de modules. Je remercie aussi les personnes avec lesquelles j’ai travaillé, en particulier
Jean Lieber et Didier Gemmerlé qui m’ont beaucoup apporté dans la préparation de mes cours et
TDs, et Noelle Carbonell et Didier Galmiche pour m’avoir permis de faire des enseignements très
intéressants en maı̂trise et en DEA.
Je remercie aussi Marie-France Mailhos, à l’IUFM de Rennes, pour m’avoir permis de découvrir
la pédagogie en Allemagne. Je remercie aussi Yvonne Kanzo, et plus généralement l’équipe pédagogique
du collège des ormeaux, pour son indulgence et tous les conseils pédagogiques qu’elle m’a donnés
et qui m’ont été indispensables par la suite.
Je remercie aussi tous ceux avec qui je partage régulièrement un café ou un thé et qui n’ont
jamais hésité à me donner une macro LATEX, à me remplacer en TD, à me faire confiance pour
des enseignements, à partager des repas au Perfection sous la protection de Sri Chinmoy, et j’en
oublie... Je parle bien sûr d’Olivier et Johanne. Je n’oublie pas Miki
Je n’oublie pas de remercier tous les dinoistes sans lesquels ma thèse aurait certainement pro-
gressée à une vitesse différente :Alfred, qui a su préserver la pureté de sa vocation scientifique
malgré les tentations multiples de sa vie londonienne, Nahamuf et son approche toute particulière
du tennis, Cabud (et Juliette, mais ça n’a plus rien à voir), Rrose, et lapin qui apportent leur
antique sagesse à ce forum, et en vrac Vince, Lory, Alvin, pignolo, VV, Tom-Tom, jolow, et à tous
ceux sans qui dino pourrait être un forum à la fois public et inintéressant.
Je remercie aussi ceux que j’ai rencontré, que je vois et que je rencontrerai un jour quelque part
pour tout ce qu’ils m’ont apporté et m’apporteront. Ceux du SCI, Hannes, Ursula, Sayaka, ceux
de ATPUB, Rémi en particulier, ... Je n’oublie surtout pas de remercier ceux qui m’ont supporté
pendant... Ouah ! tant que ça !, Bertrand, Christophe et Marie-Caroline et aux bonnes soirées qu’on
a passé ensemble. Und Thomas, Sandra und Ralf, die Bremen eine schöne Stadt machen.
Je remercie enfin ma maman en particulier, Christelle, Olivier, Honorine et Roman, Pierre et
Virginie, et toute ma famille en général pour ce qu’ils m’ont apporté et que je ne compte plus.
iv
v
« ...das ist ein zu weites Feld. »1

Theodor Fontane,
Effi Briest (1895).
1 Le sujet est trop riche (traduction libre).

vi
Table des matières
Résumé i
Abstract i
1 Analyse de protocoles cryptographiques 1

1.1 Protocoles cryptographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Quelques primitives cryptographiques et leur utilisation pour assurer la
sécurité des communications . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1.i Un exemple historique . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1.ii Algorithmes de chiffrement . . . . . . . . . . . . . . . . . . . 2
1.1.1.iii L’hypothèse de chiffrement parfait et au-delà . . . . . . . . . 3
1.1.2 Communication par échange de messages . . . . . . . . . . . . . . . . . 3
Messages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Rôles et acteurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Un acteur malhonnête, l’intrus . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.3.i Contrôle du réseau . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.3.ii Capacités de déduction . . . . . . . . . . . . . . . . . . . . . . 4
1.1.4 Propriétés de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.4.i Confidentialité des données échangées . . . . . . . . . . . . . 4
1.1.4.ii Identification de l’interlocuteur . . . . . . . . . . . . . . . . . 5
1.2 Méthodes pour l’analyse de protocoles . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Compilation de protocoles cryptographiques . . . . . . . . . . . . . . . 5
1.2.2 Méthodes interactives . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
L’analyseur NRL. . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Application du prouveur Isabelle à la vérification de protocoles
cryptographiques. . . . . . . . . . . . . . . . . . . . . 6
Algèbre de processus et équivalence observationnelle. . . . . . . 7
1.2.3 Méthodes automatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3.i But de nos travaux . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3.ii La recherche de failles comme problème d’accessibilité . . . . 7
Méthodes approchées. . . . . . . . . . . . . . . . . . . . . . . . . 8
Méthodes exactes dans un cadre restreint. . . . . . . . . . . . . 8
1.2.3.iii Traitement de la correction de protocoles . . . . . . . . . . . 8
Méthodes semi-automatiques. . . . . . . . . . . . . . . . . . . . 8
vii
viii Table des matières
Méthodes dont la terminaison est assurée. . . . . . . . . . . . . 9

1.3 Contenu de la thèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1 Apports du travail présenté . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1.i Compilation de protocoles . . . . . . . . . . . . . . . . . . . . 9
Expressivité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Fondations théoriques. . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1.ii Recherche de failles . . . . . . . . . . . . . . . . . . . . . . . . 10
Recherche efficace de failles. . . . . . . . . . . . . . . . . . . . . 10
Recherche de failles lorsque des opérateurs algébriques sont considérés. 10
1.3.1.iii Vérification de protocoles cryptographiques . . . . . . . . . . 10
Vérification pratique de protocoles. . . . . . . . . . . . . . . . . 10
Preuve dans un cadre théorique. . . . . . . . . . . . . . . . . . . 10
1.3.2 Plan de la thèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.2.i Fondations (chapitres 2, 3 et 4) . . . . . . . . . . . . . . . . . 10
1.3.2.ii Compilation (chapitre 5) . . . . . . . . . . . . . . . . . . . . . 11
1.3.2.iii Recherche de failles (chapitres 6 et 7) . . . . . . . . . . . . . . 11
1.3.2.iv Vérification de protocoles (chapitre 8) . . . . . . . . . . . . . 11
I Fondements 13
2 Primitives cryptographiques 15
2.1 Modes de chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1 Chiffrement parfait . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.2 Chiffrement par blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.2.i Chiffrement par blocs sans chaı̂nage des blocs . . . . . . . . . 16
2.1.2.ii Chiffrement par blocs avec chaı̂nage . . . . . . . . . . . . . . 16
Chiffrement par blocs en mode chaı̂né (mode CBC). . . . . . . . 16
Chiffrement à rétroaction, sur le texte codé. . . . . . . . . . . . 16
Propriétés du mode chaı̂né. . . . . . . . . . . . . . . . . . . . . . 17
2.2 Opérations de chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 Chiffrement par clefs asymétriques . . . . . . . . . . . . . . . . . . . . 18
2.2.1.i Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1.ii Problème du sac-à-dos . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1.iii Factorisation de grands entiers . . . . . . . . . . . . . . . . . 19
2.2.1.iv Calcul du logarithme discret . . . . . . . . . . . . . . . . . . . 19
2.2.1.v Cas du chiffrement commutatif . . . . . . . . . . . . . . . . . 20
2.2.1.vi Algorithmes de signature . . . . . . . . . . . . . . . . . . . . . 20
2.2.2 Chiffrement par clefs symétriques . . . . . . . . . . . . . . . . . . . . . 20
2.2.2.i Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.2.ii Un exemple, l’algorithme DES . . . . . . . . . . . . . . . . . . 21
2.2.2.iii Le protocole de W. Diffie et M. Hellman pour une construction
distribuée de clefs symétriques . . . . . . . . . . . . . . . . . . 21
2.2.3 Un chiffrement asymétrique faible : le ou exclusif bit à bit . . . . . . . 21
ix
2.3 Fonctions à adressage dispersé . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3.1 Résistance à la collision . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.1.i Attaques d’anniversaire . . . . . . . . . . . . . . . . . . . . . 22
2.3.1.ii Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.2 Exemples de fonctions à adressage dispersé . . . . . . . . . . . . . . . . 23
MD5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
SHA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Termes, classes d’équivalence et représentations 25

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Multi-ensembles et multi-ensembles généralisés . . . . . . . . . . . . . . . . . . 26
3.2.1 Support d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.2 Opérations sur les ensembles . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.3 Multi-ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.4 Multi-ensembles généralisés . . . . . . . . . . . . . . . . . . . . . . . . 27
3.3 Termes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.3.1.i Les messages comme suite d’opérations . . . . . . . . . . . . . 27
3.3.1.ii Les messages comme valeur . . . . . . . . . . . . . . . . . . . 28
3.3.2 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3.2.i Signature et termes standards . . . . . . . . . . . . . . . . . . 28
3.3.2.ii Sous-terme d’un terme . . . . . . . . . . . . . . . . . . . . . . 29
3.3.2.iii Position dans un terme . . . . . . . . . . . . . . . . . . . . . . 29
3.3.2.iv Remplacement, variable et substitution . . . . . . . . . . . . . 29
0 0
3.3.3 Termes opérations, Fproto et T0 ( Fproto ) . . . . . . . . . . . . . . . . . 30
3.3.3.i Signature 0 Fproto décrivant les opérations permises . . . . . . 30
3.3.3.ii Termes opérations . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.4 Théorie équationnelle sur les messages . . . . . . . . . . . . . . . . . . 30
3.3.4.i Théorie du ou exclusif bit à bit . . . . . . . . . . . . . . . . . 31
3.3.4.ii Théorie du chiffrement de type RSA . . . . . . . . . . . . . . 31
3.3.4.iii Théorie de l’exponentiation . . . . . . . . . . . . . . . . . . . 31
3.3.4.iv Relation d’équivalence sur les termes . . . . . . . . . . . . . . 32
3.3.5 Ensemble des termes valeurs, Fproto et T(Fproto ) . . . . . . . . . . . . 32
3.3.5.i Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.5.ii Opérateurs libres Fl . . . . . . . . . . . . . . . . . . . . . . . 33
p,rsa
3.3.5.iii Opérateur { } . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3.5.iv Opérateur Exp( , ) . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.5.v Opérateur ⊕({ }) . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.5.vi Définition de Fproto et T(Fproto ) . . . . . . . . . . . . . . . . 35
3.4 Normalisation des termes valeurs . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4.1 Fonction de normalisation sur les termes opérations et les termes valeurs 35
3.4.1.i Normalisation des constantes . . . . . . . . . . . . . . . . . . 35
3.4.1.ii Normalisation des constructeurs libres . . . . . . . . . . . . . 36
x Table des matières
3.4.1.iii Normalisation pour l’opérateur ⊕({ }) . . . . . . . . . . . . . 36

3.4.1.iv Normalisation pour l’opérateur Exp( , ) . . . . . . . . . . . . 36
p,rsa
3.4.1.v Normalisation pour l’opérateur { } . . . . . . . . . . . . . 37
Addition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Opposé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.1.vi Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4.2 Unicité de la forme normale pour une classe de termes opérations . . . 38
3.4.2.i Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4.2.ii Unicité de la classe représentée par une forme normale . . . . 39
3.4.2.iii Cas de deux termes égaux modulo Θproto . . . . . . . . . . . 40
3.4.2.iv Cas général . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4.2.v Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5 Représentation des termes valeurs et opérations de base . . . . . . . . . . . . . 41
3.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5.2 Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5.3 Représentations et taille des problèmes . . . . . . . . . . . . . . . . . . 42
3.5.3.i Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.5.3.ii Relations sur l’ensemble des sous-termes d’un terme valeur . . 43
Les ensembles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Multi-ensembles et multi-ensembles généralisés. . . . . . . . . . 43
Taille dag d’un terme valeur. . . . . . . . . . . . . . . . . . . . . 44
3.5.4 Opérations sur les termes et complexité . . . . . . . . . . . . . . . . . . 44
3.5.4.i Ordre total sur les termes valeurs et représentation canonique 44
Sur L0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Li → Li+1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.5.5 Insertion d’un terme dans un graphe orienté acyclique . . . . . . . . . 45
3.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4 Accessibilité dans le cas clos 47

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
−1
Traitement de l’opérateur . . . . . . . . . . . . . . . . . . . 47
4.2 Règles de réécriture sur des ensembles de termes . . . . . . . . . . . . . . . . . 48
4.3 Systèmes locaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.3.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.3.3 Combinaison de systèmes canoniques . . . . . . . . . . . . . . . . . . . 51
4.4 Problème d’accessibilité close . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.4.1 Problèmes de décision . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Taille de problèmes en entrée. . . . . . . . . . . . . . . . . . . . 53
4.4.2 Complexité relative de ces problèmes . . . . . . . . . . . . . . . . . . . 53
4.5 Symboles et systèmes dans le cadre de l’étude de protocoles . . . . . . . . . . 54
4.5.1 Opérateur h , i . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
s s,ebc s,cbc
4.5.2 Opérateurs { } , { } et { } . . . . . . . . . . . . . . . . . . . . 55
xi
s
4.5.2.i Cas du chiffrement parfait, opérateur { } . . . . . . . . . . . 55
s,ebc
4.5.2.ii Cas du chiffrement par blocs, opérateur { } . . . . . . . . 55
Cas ρ = Ld,{ }s,ebc . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Cas ρ = Lc,{ }s,ebc . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Test de l’application d’une règle de décomposition. . . . . . . . 57
Test de l’application d’une règle de composition. . . . . . . . . . 57
s,cbc
4.5.2.iii Cas du chiffrement par blocs en mode chaı̂né, opérateur { } 57
p p,rsa
4.5.3 Opérateurs { } et { } . . . . . . . . . . . . . . . . . . . . . . . . . 58
p
4.5.3.i Cas du chiffrement parfait, opérateur { } . . . . . . . . . . . 58
p,rsa
4.5.3.ii Cas du chiffrement commutatif, opérateur { } . . . . . . . 59
4.5.4 Opérateur H( , ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.5.5 Opérateur Exp( , ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.5.6 Opérateur ⊕({ }) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6 Problème d’accessibilité close dans le cadre des protocoles . . . . . . . . . . . 63
4.7 Règles d’oracle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.8 Travaux reliés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
II Compilation 67
5 Compilation de protocoles cryptographiques 69

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1.1 Analyse formelle de protocoles cryptographiques . . . . . . . . . . . . . 69
5.1.2 Cadre de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1.3 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2 Langage Haut Niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2.1 Description par un scénario et hypothèses . . . . . . . . . . . . . . . . 70
5.2.1.i Indépendance de contrôle. . . . . . . . . . . . . . . . . . . . . 71
Indépendance des acteurs entre eux. . . . . . . . . . . . . . . . . 71
Indépendance de contrôle des rôles par rapport aux acteurs. . . 71
5.2.1.ii Indépendance de données. . . . . . . . . . . . . . . . . . . . . 71
Indépendance de données des acteurs entre eux. . . . . . . . . . 71
Indépendance des données dans des rôles joués par un même acteur. 71
5.2.1.iii Compilation des rôles et intrus. . . . . . . . . . . . . . . . . . 71
5.2.1.iv Scénario séquentiel . . . . . . . . . . . . . . . . . . . . . . . . 71
5.2.1.v Compilation d’un protocole . . . . . . . . . . . . . . . . . . . 71
5.2.2 Spécification de la connaissance des rôles . . . . . . . . . . . . . . . . . 72
5.2.3 Description des messages échangés . . . . . . . . . . . . . . . . . . . . . 73
5.2.4 Description des instances des rôles . . . . . . . . . . . . . . . . . . . . . 73
5.2.5 Description de l’intrus . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2.5.i Capacités de l’intrus . . . . . . . . . . . . . . . . . . . . . . . 73
5.2.5.ii Connaissances initiales de l’intrus . . . . . . . . . . . . . . . . 74
5.2.6 Spécification des propriétés du protocole . . . . . . . . . . . . . . . . . 74
xii Table des matières
5.3 Sémantique Opérationnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.3.1 Description du système de transition final . . . . . . . . . . . . . . . . 75
5.3.2 Description des états du système (Σ, T ) . . . . . . . . . . . . . . . . . 75
5.3.2.i Description des termes . . . . . . . . . . . . . . . . . . . . . . 75
Les m-termes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Les w-termes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Les i-termes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.3.2.ii L’état initial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.3.2.iii États critiques . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.3.3 Sémantique opérationnelle en sortie du compilateur . . . . . . . . . . . 76
5.3.3.i Traitement des actions des acteurs honnêtes . . . . . . . . . . 76
5.3.3.ii Traitement des actions de l’intrus . . . . . . . . . . . . . . . . 77
Interception d’un message. . . . . . . . . . . . . . . . . . . . . . 77
Écoute d’un message. . . . . . . . . . . . . . . . . . . . . . . . . 77
Composition de messages et décomposition des connaissances, le
modèle statique. . . . . . . . . . . . . . . . . . . . . 77
Une autre voie, le modèle paresseux. . . . . . . . . . . . . . . . . 78
5.3.4 Règles optimisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.4 Exécutabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.4.1 Problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.4.2 Traitement des nonces . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.4.3 Définition de l’exécutabilité . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4.4 Définition et complexité du problème Executabilite(P ) . . . . . . . 80
5.5 Gestion des Connaissances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.5.1 Modèle pour la gestion des connaissances . . . . . . . . . . . . . . . . . 81
5.5.2 Construction d’une représentation des connaissances . . . . . . . . . . 81
5.5.2.i Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Hypothèse d’analyse complète. . . . . . . . . . . . . . . . . . . . 81
Construction des relations entre les termes de Cloture(E). . . . 82
5.5.2.ii Problème de la construction d’une relation et opérateurs non
syntaxiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Exemple introductif. . . . . . . . . . . . . . . . . . . . . . . . . 82
Construction de la représentation pour les ⊕-termes. . . . . . . 82
Construction de la représentation pour les Exp( , )-termes. . . . 82
p,rsa
Construction de la représentation pour les { } termes. . . . 83
5.5.2.iii Construction de la représentation des termes syntaxiques. . . 83
5.5.2.iv Représentation d’un ensemble E à partir d’un ensemble F . . 84
Hypothèse de monotonie. . . . . . . . . . . . . . . . . . . . . . . 86
5.5.3 Construction des Règles . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.5.3.i Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Sur les émetteurs de messages attendus et destinataires de mes-
sages envoyés. . . . . . . . . . . . . . . . . . . . . . . 87
5.5.4 Règles de réception/envoi de message . . . . . . . . . . . . . . . . . . . 87
xiii
5.5.4.i Exemple de compilation d’un protocole . . . . . . . . . . . . . 87

Connaissances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Messages attendus. . . . . . . . . . . . . . . . . . . . . . . . . . 88
Messages envoyés. . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.5.4.ii Règles produites par le compilateur. . . . . . . . . . . . . . . 88
Remarques sur les règles générales. . . . . . . . . . . . . . . . . 89
5.5.4.iii Règles spécialisées pour l’intrus de D. Dolev et A. Yao . . . . 90
5.5.5 Hypothèses sur les protocoles étudiés . . . . . . . . . . . . . . . . . . . 90
5.5.5.i Décomposition de connaissances antérieures . . . . . . . . . . 90
5.5.5.ii Ordre de décomposition des messages attendus . . . . . . . . 91
5.5.6 Variables dans les règles de messages . . . . . . . . . . . . . . . . . . . 94
5.5.6.i Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.5.6.ii Cas des opérateurs de chiffrement . . . . . . . . . . . . . . . . 94
5.5.6.iii Cas du ou exclusif bit à bit . . . . . . . . . . . . . . . . . . . 94
5.6 Travaux Reliés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.6.1 Le compilateur CasRul . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.6.2 Autres compilateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
III Recherche d’attaques 97
6 Recherche efficace d’attaques 99

6.1 Motivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.2 Cadre de l’étude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6.3 Modélisation de l’intrus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6.4 Préfixe d’une substitution, ensemble complet de préfixes . . . . . . . . . . . . 101
6.5 Problèmes de construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.5.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.5.2 Problèmes liés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.5.3 Transformation de problèmes de construction simultanée . . . . . . . . 103
6.5.3.i Système de transformation de problèmes de construction si-
multanée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Description des règles. . . . . . . . . . . . . . . . . . . . . . . . 104
Restrictions à l’application des règles de L. . . . . . . . . . . . . 104
6.5.3.ii Correction du système L . . . . . . . . . . . . . . . . . . . . . 104
6.6 Équivalences sur les équations de constructions . . . . . . . . . . . . . . . . . . 104
6.6.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.6.2 Ordre sur les problèmes de construction simultanée . . . . . . . . . . . 106
6.6.3 Normalisation d’un problème de construction simultanée . . . . . . . . 106
6.6.3.i Élimination des couples . . . . . . . . . . . . . . . . . . . . . 107
6.6.3.ii Élimination des variables . . . . . . . . . . . . . . . . . . . . . 107
6.6.3.iii Simplification pour le chiffrement symétrique . . . . . . . . . 108
6.6.3.iv Simplification pour le chiffrement asymétrique . . . . . . . . . 109
6.6.3.v Normalisation de problèmes de construction simultanée . . . 110
xiv Table des matières
6.7 Complétude de L . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

6.7.1 Cas sans décomposition des connaissances . . . . . . . . . . . . . . . . 110
6.7.2 Cas avec décomposition des connaissances . . . . . . . . . . . . . . . . 111
6.7.3 Cas général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
6.8 Recherche d’attaques sur un protocole . . . . . . . . . . . . . . . . . . . . . . 112
6.8.1 Modèle de protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
6.8.2 Codage des attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
6.8.2.i Attaques de secret . . . . . . . . . . . . . . . . . . . . . . . . 113
6.8.2.ii Attaques d’authentification . . . . . . . . . . . . . . . . . . . 113
6.8.3 Recherche paresseuse d’un ordre d’exécution . . . . . . . . . . . . . . . 114
6.8.4 Algorithme de recherche d’attaques . . . . . . . . . . . . . . . . . . . . 114
6.8.4.i Notations et Algorithme . . . . . . . . . . . . . . . . . . . . . 114
6.8.4.ii Correction et complétude de cet algorithme pour la recherche
d’attaques pour un nombre fini de sessions . . . . . . . . . . . 115
Tous les ordre d’exécutions possibles sont explorés. . . . . . . . 115
Pour un ordre d’exécution π, toutes les substitutions satisfaisant
Cπ sont prises en compte. . . . . . . . . . . . . . . . 115
Les attaques trouvées sont réelles. . . . . . . . . . . . . . . . . . 115
6.8.4.iii Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.9 Résultats obtenus avec le prouveur de théorèmes daTac . . . . . . . . . . . . . 115
6.9.1 Introduction - Corpus de protocoles étudiés . . . . . . . . . . . . . . . 115
6.9.2 Résultats obtenus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.9.2.i Protocole expérimental . . . . . . . . . . . . . . . . . . . . . . 115
6.9.2.ii Explication du tableau 6.3 . . . . . . . . . . . . . . . . . . . . 116
6.9.3 Cas du protocole de D. Denning et G. Sacco . . . . . . . . . . . . . . 117
6.9.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.10 Travaux reliés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
6.10.1 Complétude de la stratégie de résolution de contraintes . . . . . . . . . 119
6.10.2 Implantation de la stratégie paresseuse de l’intrus . . . . . . . . . . . . 119
7 Problèmes d’accessibilité non clos 121

7.1 Motivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.2 Définition du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.2.2 Protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
7.2.3 Problème de la recherche d’attaques . . . . . . . . . . . . . . . . . . . . 122
7.2.4 Cas du ou exclusif bit à bit . . . . . . . . . . . . . . . . . . . . . . . . . 123
7.2.5 Cas de l’exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
7.2.6 Cas du chiffrement asymétrique de type RSA . . . . . . . . . . . . . . 123
7.3 Théorème de complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
7.4 Borne sur le nombre de sous-termes d’une attaque normale . . . . . . . . . . . 125
7.4.1 Mise en place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
7.4.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
xv
7.4.3 Les signatures F⊕ , Fexp et Frsa sont régulières . . . . . . . . . . . . . . 126

7.4.4 Les signatures F⊕ , Fexp et Frsa permettent le remplacement . . . . . . 128
7.4.4.i Cas des signatures Fexp et Frsa . . . . . . . . . . . . . . . . . 128
7.4.4.ii Cas de la signature F⊕ . . . . . . . . . . . . . . . . . . . . . . 129
7.4.5 Termes liés dans une attaque minimale . . . . . . . . . . . . . . . . . . 129
Terme décomposé par une règle. . . . . . . . . . . . . . . . . . . 130
7.4.6 Borne sur la taille de la représentation des sous-termes d’une substitution
dans une attaque normale . . . . . . . . . . . . . . . . . . . . . . . . . 131
Affirmation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
7.4.7 Complexité du problème de décision Attaque(P, R⊕ ) . . . . . . . . . 133
7.5 Borne sur la taille des coefficients dans une attaque normale . . . . . . . . . . 133
7.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
7.5.2 Relation d’équivalence modulo les coefficients . . . . . . . . . . . . . . 134
7.5.3 Termes équivalents et dérivations . . . . . . . . . . . . . . . . . . . . . 134
7.5.4 Généralisation d’une attaque . . . . . . . . . . . . . . . . . . . . . . . . 135
7.5.4.i Recherche de substitutions équivalentes . . . . . . . . . . . . 135
Première condition. . . . . . . . . . . . . . . . . . . . . . . . . . 136
Deuxième condition. . . . . . . . . . . . . . . . . . . . . . . . . . 136
Troisième condition. . . . . . . . . . . . . . . . . . . . . . . . . . 137
7.5.4.ii Termes équivalents et accessibilité . . . . . . . . . . . . . . . 137
IV Vérification 139
8 Cas non-borné 141

8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
8.2 Cadre de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
8.2.1 Termes et capacités de l’intrus . . . . . . . . . . . . . . . . . . . . . . . 142
8.2.2 Protocoles considérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
8.2.3 Modèle d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
8.2.4 Le problème de décision Attaque Parallele(Pnb , t, L) . . . . . . . . 144
8.3 Ajout de règles d’Oracle à Rproto . . . . . . . . . . . . . . . . . . . . . . . . . 144
8.3.1 Résultat principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
8.3.2 Définition de Lo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
8.3.3 Problème d’accessibilité close . . . . . . . . . . . . . . . . . . . . . . . 146
8.3.4 Borne sur les attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
8.4 Règles parallèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
8.4.1 Situation de la preuve . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
8.4.2 Règles agrégées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
8.4.3 Règles d’Oracle pour les acteurs . . . . . . . . . . . . . . . . . . . . . . 150
8.4.4 Les règles de AoD sont des règles d’Oracle . . . . . . . . . . . . . . . . . 152
8.5 Implantation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.5.1 Une procédure inefficace . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.5.2 Déclaration des acteurs de AD . . . . . . . . . . . . . . . . . . . . . . . 153
xvi Table des matières
8.5.3 Compilation des acteurs de AD : construction des règles d’Oracle . . . 154

8.5.3.i Construction des règles agrégées. . . . . . . . . . . . . . . . . 154
8.5.3.ii Construction de règles étendues. . . . . . . . . . . . . . . . . 154
8.5.3.iii Phase de décomposition. . . . . . . . . . . . . . . . . . . . . . 154
8.5.3.iv Calcul des règles d’Oracle. . . . . . . . . . . . . . . . . . . . . 154
8.5.4 Phase de décomposition . . . . . . . . . . . . . . . . . . . . . . . . . . 155
8.5.4.i Explication de cette phase. . . . . . . . . . . . . . . . . . . . 155
8.5.4.ii Règles pour la décomposition . . . . . . . . . . . . . . . . . . 155
8.5.5 Calcul des règles d’Oracle . . . . . . . . . . . . . . . . . . . . . . . . . 156
8.5.6 Combinaison des règles d’Oracle et de la stratégie de recherche d’attaque
par résolution de contraintes . . . . . . . . . . . . . . . . . . . . . . . . 157
8.6 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
8.6.1 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
8.6.2 Accélération pour la recherche d’attaques . . . . . . . . . . . . . . . . . 158
8.6.2.i Un exemple, le protocole d’échange de clefs Encrypted Key
Exchange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Spécification en LHNSP. . . . . . . . . . . . . . . . . . . . . . 158
Règles d’Oracle en sortie du compilateur. . . . . . . . . . . . . . 158
Trace de la recherche d’attaque. . . . . . . . . . . . . . . . . . . 158
8.6.2.ii Résultats obtenus . . . . . . . . . . . . . . . . . . . . . . . . . 160
Notes sur les expériences. . . . . . . . . . . . . . . . . . . . . . . 160
8.6.3 Vérification de protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . 161
8.6.3.i Description des tests . . . . . . . . . . . . . . . . . . . . . . . 161
8.6.3.ii Commentaires sur le tableau 8.2 . . . . . . . . . . . . . . . . 161
Carlsen Secret Key Initiator Protocol. . . . . . . . . . . . . . . . 161
Amended Needham-Schroeder Protocol. . . . . . . . . . . . . . . 161
8.6.3.iii Conclusion sur la vérification de protocoles . . . . . . . . . . 162
9 Bilan et Perspectives 163

Compilation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Recherche d’attaques. . . . . . . . . . . . . . . . . . . . . . . . . 163
Vérification. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Bibliographie 165
Table des figures
1.1 Messages échangés dans le protocole à clefs publiques de R. Needham et M. Schroeder 3
2.1 Chiffrement par blocs sans chaı̂nage . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2 Chiffrement par blocs en mode chaı̂né (mode CBC) . . . . . . . . . . . . . . . . . . 17
2.3 Chiffrement par blocs par rétroaction (mode CFB) . . . . . . . . . . . . . . . . . . 17
3.1 Relation entre termes opérations, termes valeurs et fonction de normalisation . . . 38

p
3.2 Représentation du terme {ha, ha, bii}c par un arbre . . . . . . . . . . . . . . . . . . 42
p
3.3 Représentation du terme {ha, ha, bii}c par un graphe orienté acyclique (DAG) . . . 42
3.4 Algorithme d’insertion d’un terme dans un ensemble. . . . . . . . . . . . . . . . . . 46
4.1 Propriété de Church-Rosser pour les systèmes de réécriture sur des ensembles de
termes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.1 Protocole de R. Needham et M. Schroeder à clefs publiques (Needham-Schroeder

Public Key) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2 Exemple de spécification LHNSP : le protocole de R. Needham et M. Schroeder
(Needham-Schroeder Public Key) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.3 Exemple de décomposition de connaissances antérieures . . . . . . . . . . . . . . . 79
5.4 Algorithme de construction de la fonction δ pour les ⊕-termes. . . . . . . . . . . . 83
5.5 Algorithme de construction de la fonction δ pour les Exp-termes. . . . . . . . . . . 84
p,rsa
5.6 Algorithme de construction de la fonction δ pour les { } -termes. . . . . . . . . 85
5.7 Algorithme de construction de la fonction δ pour les opérateurs syntaxiques. . . . . 85
5.8 Protocole jouet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.9 Règles en sortie du compilateur CasRul . . . . . . . . . . . . . . . . . . . . . . . . 89
6.1 Algorithme de recherche d’attaque sur un protocole . . . . . . . . . . . . . . . . . . 114

6.3 Protocole de D. Denning et G. Sacco (Denning-Sacco (symmetric)) . . . . . . . . . 117
6.2 Protocole de R. Needham et M. Schroeder à clefs symétriques (Needham-Schroeder
Conventional Key) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

8.2 Spécification du protocole Encrypted Key Exchange en LHNSP. . . . . . . . . . . 159
8.3 Les deux derniers messages du protocole de Carlsen. . . . . . . . . . . . . . . . . . 161
xvii
xviii Table des figures
1
Analyse de protocoles
cryptographiques
Chapitre
Sécurisation des échanges

Une scène classique des films d’espionnage est l’échange de deux personnes au checkpoint Char-
lie. Le protocole est bien établi : de chaque côté du pont (embrumé), les représentants de chaque
partie, et sous leurs yeux les personnes échangées, dont l’identité est vérifiée au moyen de jumelles,
se croisent au milieu du pont. Ce protocole bien établi est suffisant pour un échange dans lequel
les deux parties peuvent contrôler à tout moment le déroulement. Entre autres, les actions des
participants sont synchronisées les unes sur les autres. Ce protocole, ou celui suivi lors de l’achat
d’un objet dans un magasin, reflète l’idée qu’on se fait d’un échange sécurisé : l’interlocuteur est
bien identifié, et il n’y a pas d’intermédiaire entre les participants pouvant changer le contenu
du matériel échangé. L’échange de données sur un réseau comme Internet est d’une toute autre
nature. Des personnes situées sur deux points distants du réseau doivent s’accorder sur l’iden-
tité l’une de l’autre, échanger des informations qu’elles désirent être les seules à connaı̂tre, et cela
médiatement un réseau dont le protocole de transport de messages ne permet pas l’authentification
de l’émetteur du message, et donne la possibilité à tous les intermédiaires, légitimes ou non, de
connaı̂tre le contenu du message. Le challenge à relever consiste à construire des protocoles per-
mettant l’identification de l’interlocuteur et la transmission de données confidentielles sur un tel
média.
La solution au second problème remonte, selon la légende, à Jules César. Si un message conte-
nant des données secrètes doit être transmis, il faut le chiffrer, c’est-à-dire l’altérer d’une façon
prédéterminée avec le receveur prévu pour que seul ce dernier puisse retrouver le message ini-
tial. De manière plus générale, une primitive cryptographique est une opération permettant une
altération, réversible ou non, d’un message. Le premier point peut être résolu grâce à une suite
de messages de type challenge réponse : chaque participant envoie un ou plusieurs messages, et
suppose que la réponse ne peut être donnée que par son interlocuteur. Cette suite de messages
déterminée par avance est un protocole, et lorsque ce protocole dépend de primitives cryptogra-
phiques pour assurer l’intégrité des messages, leur origine ou leur secret, nous parlons de protocole
cryptographique. La possibilité pour une tierce personne d’altérer et de copier les messages, et le
fait qu’une personne ne soit pas au courant d’un échange auquel elle ne participe pas rendent ces
protocoles d’apparence simple complexes à analyser et à spécifier.
La mise en œuvre de mécanismes assurant l’échange sécurisé de données est pourtant une condi-
tion indispensable pour le commerce électronique, et plus généralement pour permettre au réseau
Internet de devenir un support sûr pour le développement d’activités professionnelles, commerciales
ou administratives. Ces erreurs ont abouti à l’emploi de méthodes formelles dans le but d’assurer la
sécurité des protocoles mis en œuvre ou en cours d’élaboration. Notre travail se situe dans ce cadre
de recherche de failles ou, au contraire, de preuve de sécurité de protocoles élaborés par ailleurs.
1
2 Chapitre 1. Analyse de protocoles cryptographiques
1.1 Protocoles cryptographiques

L’existence même de l’existence de protocoles permettant la sécurisation des échanges repose
sur la possibilité de gérer l’information divulguée sur le média. Si toutes les données échangées
peuvent être connues de tous, il est impossible de préserver la confidentialité de quelque manière
que ce soit. Cette gestion est basée sur des primitives cryptographiques qui permettent d’assurer
que seules certaines personnes seront en mesure d’extraire l’information utile d’un message.
1.1.1 Quelques primitives cryptographiques et leur utilisation pour as-

surer la sécurité des communications
1.1.1.i Un exemple historique
La condition nécessaire de l’existence de protocoles cryptographiques est l’existence de primi-

tives cryptographiques, c’est-à-dire de procédures permettant l’émission de messages ne pouvant
pas être construits ou déchiffrés par une personne autre que l’émetteur ou le récepteur attendu du
message. Le code utilisé par Jules César, par exemple, consistait en un décalage de trois lettres
dans l’ordre alphabétique. La suite de lettres :
Fg wgawg gvw gq fodlu
est la traduction chiffrée de :
Ce texte est en clair
Si ce code permet de tromper un adversaire n’ayant aucune connaissance en chiffrement, il ne peut

pas être raisonnablement utilisé pour protéger une donnée quelconque.
1.1.1.ii Algorithmes de chiffrement
Nous appelons algorithme de chiffrement une primitive cryptographique réversible. Le code

utilisé par Jules César est donc un algorithme de chiffrement : il est possible d’obtenir le texte en
clair à partir du texte chiffré en appliquant un décalage de trois lettres vers le début de l’alphabet. La
sécurité de cet algorithme repose largement sur le secret de la méthode utilisée. Pour une personne
connaissant la méthode mais pas le décalage utilisé, c’est un jeu d’enfant que de retrouver le texte
clair à partir du texte chiffré. Une proposition de bon sens, très largement acceptée, est que ce
type d’algorithme de chiffrement ne devrait pas être utilisé. Il est préférable d’utiliser une méthode
générale dont le résultat dépend d’un paramètre, la clef.
Les algorithmes de chiffrement sont classés en deux grandes familles, suivant que les clefs servant
au chiffrement et déchiffrement d’un messages sont facilement calculables l’une à partir de l’autre
ou non. Dans le premier cas, nous parlerons d’algorithme de chiffrement à clefs symétriques, et
dans le second d’algorithme de chiffrement à clefs asymétriques. Dans la première catégorie sont
classées les méthodes pour lesquelles les clefs de chiffrement et de déchiffrement sont identiques,
par exemple. Dans la seconde catégorie, la clef permettant de déchiffrer un message chiffré par
une clef a est appelée la clef inverse de a. Notons que la notion d’inverse est à prendre ici au sens
algébrique du terme dès que les algorithmes de chiffrement et de déchiffrement sont identiques, ce
qui est le cas le plus courant.
Si la primitive cryptographique utilisée n’est pas réversible, nous parlons de fonction à adressage
dispersé. Ce type de fonctions peut servir à assurer l’intégrité d’un message ou à témoigner de la
connaissance d’une certaine valeur. Par exemple, en France, les deux derniers chiffres du numéro
de sécurité sociale sont égaux au complément à 97 (entre 1 et 97) du reste de la division des 13
premiers chiffres par 97 [32]. Ces deux derniers chiffres permettent de vérifier qu’il n’y a pas eu
d’erreur lors d’une transmission, mais l’algorithme utilisé ne permet pas d’éviter qu’une personne
malintentionnée crée un faux numéro de sécurité sociale, car aucune donnée nécessaire pour le
calcul de la clef est secrète. Nous verrons au chapitre 2 d’autres fonctions à adressage dispersé.
1.1. Protocoles cryptographiques 3
1.1.1.iii L’hypothèse de chiffrement parfait et au-delà

L’exemple du code de César montre que l’analyse d’un protocole doit prendre en compte les
propriétés du chiffrement. Une hypothèse usuelle, pour l’étude de protocoles cryptographiques, est
celle du tout ou rien : soit une primitive de chiffrement est sûre et il n’est pas possible d’extraire
d’information d’un ou plusieurs messages chiffrés, soit il est possible de faire abstraction du chiffre-
ment et de considérer que le message est envoyé en clair. Sous cette hypothèse, il n’est pas possible
d’extraire d’information d’un message chiffré sans posséder la clef permettant de le déchiffrer, ce
qui a donné le nom d’hypothèse de chiffrement parfait.
Dans notre travail, nous essayons de pousser les limites de l’analyse de protocoles au-delà de
cette hypothèse. Il y a plusieurs raisons à cela. La première raison est un problème d’expressivité.
Certains protocoles sont basés sur les propriétés d’algorithmes de chiffrement, et en faire abstraction
nous empêche de raisonner sur ces protocoles. La seconde raison est que les failles de certains
protocoles sont basées sur l’utilisation par un adversaire de propriétés spécifiques des primitives
cryptographiques utilisées ou pouvant l’être. Un cas symptomatique est celui du protocole de
gestion de clefs dans un groupe défini par Bull et Ottway [16]. L. Paulson montre [81] que ce
protocole est correct sous l’hypothèse de chiffrement parfait, alors que P. Ryan et S. Schneider
montrent [92] que l’implantation de ce protocole utilisant le ou exclusif bit à bit n’est pas correcte.
Les propriétés à prendre en compte dépendent a priori de la puissance de calcul supposée de
l’adversaire. Il serait donc souhaitable de mesurer la sécurité offerte par un protocole en fonction
de la puissance de calcul qui serait requise pour le mettre en faute. Notre approche est différente,
et beaucoup plus simple. Nous prenons en compte uniquement les propriétés de primitives crypto-
graphiques pouvant être utilisées par un adversaire ayant une puissance de calcul faible.
1.1.2 Communication par échange de messages

Un protocole cryptographique est défini par une suite de messages envoyés et reçus par deux
(ou plus) points d’un réseau. Afin d’en simplifier la lecture, cette suite de message est souvent
organisée en un scénario linéaire représentant l’exécution attendue du protocole. Par exemple, l’un
des protocoles les plus connus est celui de R. Needham et M. Schroeder dans [77] :
1. A → B : {N a, A}Kb
2. B → A : {N b, N a}Ka
3. A → B : {N b}Kb
Fig. 1.1 – Messages échangés dans le protocole à clefs publiques de R. Needham et M. Schroeder
Nous expliquons cette spécification dans la suite de cette section.
Messages. Les messages échangés, dans la figure 1.1, sont déclarés sur chaque ligne à droite des
deux-points. Ils sont construits par concaténation (Na, A) ou par chiffrement ({Na, A}Kb) d’autres
messages, ou sont des messages atomiques (A ou Na, par exemple). Le message utilisé pour le
chiffrement (Kb, dans le cas du message {Na, A}Kb) est appelé une clef. Le type du chiffrement,
symétrique ou asymétrique, est déterminé par le type de la clef. Dans le cas du protocole de la
figure 1.1, toutes les clefs utilisées sont les clefs publiques de couples de clefs asymétriques.
Rôles et acteurs. Un scénario d’échange de messages peut être pris soit de manière déclarative,
soit de manière opératoire. Dans le premier cas, l’échange décrit se fait entre deux personnes
abstraites se distinguant uniquement par le rôle qu’elles jouent dans le scénario. Dans le second
cas, le scénario décrit une suite d’échanges de messages entre des personnes déterminées, chacune
jouant un (ou plusieurs) des rôles du scénario. Pour distinguer ces deux niveaux, nous parlons
de rôle pour désigner un participant à l’identité non précisée, et d’acteurs pour des participants
effectifs au protocole. Les premiers sont désignés par des lettres majuscules, généralement A, B,...
ou S pour un serveur, tandis que nous donnons des prénoms aux seconds (alice, bob,...). Un acteur
joue un rôle spécial, l’intrus. Nous le notons par la lettre I, et il représente un adversaire essayant
de profiter d’une éventuelle faille du protocole. Notons que prendre en compte un seul intrus n’est
pas restrictif vis-à-vis de la recherche d’attaques [101].
1.1.3 Un acteur malhonnête, l’intrus

Afin de tester la sécurité qu’offre un protocole, nous considérons les exécutions possibles de ce
protocole en présence d’un intrus essayant de le mettre en faute.
1.1.3.i Contrôle du réseau

Nous exprimons le pouvoir de l’intrus en fonction du contrôle qu’il possède sur le réseau par
lequel passent les messages échangés par les acteurs honnêtes. Les capacités de contrôle que nous
considérons sont les trois suivantes :
– interception : permet à l’intrus d’intercepter tous les messages. Il peut ainsi empêcher un
message envoyé d’arriver à destination et connaı̂tre le contenu de ce message. Cette pro-
priété doit être envisagée dès que des personnes inconnues ont un accès physique à un réseau
par câble. C’est le cas, par exemple, pour des communications via internet entre deux sites
distants ;
– écoute : n’autorise pas l’intrus à empêcher un message d’arriver à destination, mais lui
permet de prendre connaissance du contenu des messages envoyés. Il faut noter que n’importe
qui peut écouter tous les messages envoyés sur des réseaux Wifi, mais qu’il est impossible
d’empêcher un message d’arriver à destination ;
– déguisement : est une propriété d’intrus dans tous les réseaux où il n’y a pas de mécanisme
implicite d’authentification. Dans le cas d’envoi de messages sur internet, par exemple, il est
possible de falsifier l’en-tête d’un message pour lui donner une adresse d’origine différente de
l’adresse réelle d’envoi. La difficulté pour l’intrus, dans ce cas, est de parvenir à récupérer
la réponse qui ne lui est plus envoyée directement. Lorsque l’intrus envoie un message en
falsifiant l’en-tête pour faire croire que ce message vient d’un acteur a, on note l’envoyeur
I(a) : il s’agit de l’intrus I, mais avec l’identité a.
1.1.3.ii Capacités de déduction

Avant de faire l’étude d’un protocole, nous fixons un certain nombre d’opérations disponibles
pour la construction des messages. Nous supposons que l’intrus maı̂trise toujours parfaitement ces
opérations, et qu’il peut éventuellement utiliser les propriétés algébriques de ces opérations afin de
façonner de nouveaux messages soit par composition à partir de messages déjà connus, soit par
décomposition, en extrayant un sous-message d’un message déjà connu. Nous n’imposons aucune
limite – telle qu’une taille de message maximale, par exemple – aux capacités de déduction de
l’intrus à l’intérieur de ce cadre.
1.1.4 Propriétés de sécurité

Nous présentons maintenant les deux propriétés de sécurités que nous étudierons dans le reste
de ce document.
1.1.4.i Confidentialité des données échangées

Une propriété souvent demandée à un protocole est de protéger la confidentialité de données
transmises. Nous parlons alors de propriété de secret, et nous formalisons cette propriété sous la
forme d’un problème d’accessibilité. Soit (Σ, T ) un système de transition tel que Σ modélise tous
les états possibles des acteurs honnêtes et de l’intrus, T une relation de transition entre les états
de Σ représentant les actions possibles des acteurs honnêtes et de l’intrus, et Σinit un état initial.
Nous disons qu’il y a une faille de secret s’il existe une suite d’états (Σi )i∈{0,...,n} telle que :

Σ0 = Σinit
Σi T Σi+1 pour tout i ∈ {0, . . . , n − 1}
et Σn représente un état dans lequel l’intrus connait le secret.
1.2. Méthodes pour l’analyse de protocoles 5
1.1.4.ii Identification de l’interlocuteur

Une autre condition demandée aux protocoles cryptographiques est de permettre la vérification
de l’identité de l’interlocuteur. Nous traitons le problème plus particulier de l’authentification en
fonction des données échangées. Un rôle A authentifie un rôle B sur un message M si, pour tout
acteur a jouant le rôle A et tout acteur b jouant le rôle B, chaque fois que a reçoit la valeur m d’un
acteur prétendant être b, l’acteur b a effectivement envoyé une valeur m à l’acteur a, et le message
contenant m n’a pas été reçu par un autre acteur jouant le rôle A.
Cette propriété correspond à l’authentification forte définie par G. Lowe [62]. Nous la modélisation
en imposant des égalités sur les messages envoyés et reçus par les acteurs jouant les rôles A et B.
Il y a une faille d’authentification dans l’exemple précédent si à la fin d’une session de a, il n’y a
pas de messages envoyés par b pouvant être mis en correspondance avec le message reçu par a.
1.2 Méthodes pour l’analyse de protocoles

Le développement d’un protocole cryptographique, ou plus généralement d’un programme, peut
être grossièrement divisé en trois étapes :
1. tout d’abord, il est nécessaire de définir ce que doit assurer le protocole ;
2. cette première étape est suivie d’une étape durant laquelle un protocole vérifiant ces critères
est recherché ;
3. à la fin de cette seconde étape, un ou plusieurs candidats possibles sont dégagés, et leur
implantation est ensuite formellement validée.
La troisième étape de validation repose sur des outils généraux d’analyse de programmes, et est hors
du cadre que nous nous sommes fixés. Nous nous intéressons à l’étape de recherche d’un protocole.
Nous supposons qu’à ce stade, les utilisateurs des méthodes formelles n’ont pas de compétence
technique particulière dans ce domaine. La première difficulté consiste donc à proposer un ensemble
d’hypothèses par défaut acceptables, et à permettre une analyse complète sous ces hypothèses.
Pour qu’un tel outil puisse être accepté dans la communauté industrielle, la spécification et
l’analyse d’un protocole doit pouvoir être terminée rapidement. Il faut donc proposer un langage
de spécification de haut niveau à la syntaxe simple et concise, et à la sémantique claire. Dans la sous-
section 1.2.1, nous décrivons des langages de ce type ayant déjà été proposés, ainsi que le compilateur
leur associant une sémantique opérationnelle via un système de transitions de bas niveau. Les deux
sous-sections suivantes seront respectivement consacrées à la description de méthodes de validation
interactives (sous-section 1.2.2) ou automatiques (sous-section 1.2.3) basées sur un tel système de
transition.
1.2.1 Compilation de protocoles cryptographiques

Une étape nécessaire, pour l’adoption des méthodes formelles par une large communauté, est
de permettre des spécifications en un langage de haut niveau ayant une syntaxe simple et une
sémantique clairement définie [103]. Cependant, les outils existants demandent encore souvent une
bonne connaissance d’un langage de spécification complexe, tel que CSP [15, 94] ou autre (langage
de spécification des outils de validation de modèle ASTRAL [31], SPIN [4], . . . ). Le défaut majeur de
telles spécifications est qu’il est possible d’introduire des erreurs lors du processus de spécification.
Les auteurs de CVS motivent ainsi la création d’un compilateur de protocoles [43] :
« [SPA] has been used to define non-interference-like security properties whose ve-
rification has been automatized by means of the tool CoSeC. [...] Even if it has been
useful in analyzing small security protocols, this method has shown to be error-prone
as it requires the description by hand of the protocol and of the environment in which
it will execute. »
Parmi les compilateurs de protocoles, on peut citer Casper [63], qui a été utilisé par G. Lo-
we [42] sur la bibliothèque de protocoles donnée par J. Clark et J. Jacob [26]. Ce compilateur
transforme une suite d’envoi et de réception de messages, pour chaque acteur, en un processus CSP.
Le processus CSP peut ensuite être vérifié par un vérificateur de modèles comme FDR [88, 61, 42].
L’analyse des connaissances des rôles est réduite, et se résume à un message d’erreur lorsqu’un
rôle n’a pas les connaissances nécessaires pour décrypter immédiatement un message reçu. Il nous
semble que cette analyse réduite des connaissances des rôles confine cet outil à l’étude de protocoles
simples.
Un autre langage de description de protocoles, Capsl [35], a été défini au SRI. Les descrip-
tions en Capsl sont compilées dans un format intermédiaire, CIL [36]. Le but est de permettre
l’interfaçage d’un plus grand nombre possible d’outils de vérification, tel que l’outil de validation
de modèles Maude [34], par exemple. Capsl, dans son évolution µCAPSL [37], permet aussi la
description de protocoles de groupes.
Un troisième compilateur, CVS [43, 44], a été implanté pour permettre la spécification de
protocoles dans un langage plus compréhensible que SPA (CSPA, dans [50]). La spécification est
ensuite traduite en SPA, et analysée par CoSeC. Le langage de haut niveau reste encore complexe,
mais semble plus précis que Capsl, par exemple.
Contrairement aux trois outils précédents, pour lesquels les étapes de compilation et de vérification
sont distinctes, Murϕ [74] intègre un compilateur et un vérificateur de modèles. Le langage haut
niveau de définition est comparable au langage Unity [18]. La suite de messages est spécifiée par un
ensemble de commandes gardées, et permet l’emploi de types structurés. Ce langage est beaucoup
plus expressif que les langages précédemment décrits. Il est par exemple possible d’exprimer des
protocoles de groupes tels que Enclaves. Son désavantage majeur est qu’il n’est pas spécialisé pour la
spécification de protocoles cryptographiques, ce qui laisse à l’utilisateur un travail de modélisation
long et source d’erreurs.
1.2.2 Méthodes interactives

Le problème de la vérification de protocoles peut s’énoncer comme suit : soit P un protocole et
A un ensemble de propriétés que le protocole doit garantir. Est-ce que A est effectivement garanti
quelque soit l’utilisation qui est faite de P ? Si la réponse à cette question est oui, le protocole est
déclaré correct. Sinon, nous disons qu’il a une faille ou qu’il est fautif.
Ce problème, une fois formalisé, est connu comme étant indécidable : pour une large classe de
protocoles, il n’existe pas d’algorithme permettant de savoir si un protocole est correct ou non.
L’indécidabilité de ce problème a conduit à l’introduction de méthodes semi-automatiques : une
personne qualifiée contrôle le déroulement d’un algorithme tentant de valider un protocole, et l’aide
à mesure de sa compétence. Ces méthodes ont l’avantage d’être plus simples et plus rapides à mettre
en œuvre, leur principal inconvénient étant que le jugement de la personne qualifiée est biaisé vers
la recherche d’erreurs déjà trouvées sur de précédents protocoles, et l’introduction de propriétés
non prouvées pouvant être fausses. Dans cette catégorie, il est possible de classer des outils tels
que NRL [69], Isabelle [80, 82, 84], en utilisant la logique BAN [17] ou des notions d’équivalence,
voir [30] par exemple pour une vue d’ensemble sur ce dernier sujet. Leur principal avantage est qu’il
est possible de prouver la correction de protocoles complexes, l’inconvénient étant que le processus
de vérification, en dehors de la modélisation du protocole dans un formalisme ad hoc, est long,
complexe et parfois lui-même source d’erreurs.
L’analyseur NRL. Cet outil, développé par C. Meadows, est un outil de recherche en arrière
d’attaques. L’ensemble des états critiques est initialisé à une représentation de l’ensemble des états
fautifs par un ensemble fini d’états symboliques. Durant l’analyse, si une transition mène d’un état
s à un état critique, alors s est ajouté à l’ensemble des états critiques. L’utilisateur guide l’analyse
choisissant les transitions à considérer, et un protocole a une faille si au bout d’un nombre fini
d’étapes, il existe un état initial du protocole représenté par un état symbolique de l’ensemble des
états critiques [69, 68, 67]. L’avantage de la recherche en arrière est que le nombre d’acteurs n’est
pas limité. Si la recherche en arrière converge en un temps fini vers un ensemble d’états critiques C
ne représentant pas d’état initial, il est théoriquement possible de valider un protocole. Cependant,
le nombre de transitions possibles est très important à chaque étape. L’utilisation de cet outil exige
donc un utilisateur connaissant déjà des failles possibles du protocole.
Application du prouveur Isabelle à la vérification de protocoles cryptographiques.

L’outil Isabelle [80] est un prouveur de théorèmes par induction. Il a été utilisé à plusieurs reprises
1.2. Méthodes pour l’analyse de protocoles 7
pour l’analyse de protocoles cryptographiques [82, 83, 79]. C’est par l’utilisation de cet outil qu’il a
été possible de prouver la sécurité du protocole SET [9, 7, 8]. Il s’agit de l’exemple le plus complexe,
à notre connaissance, de protocole ayant pu être traité par des méthodes formelles. Cependant,
d’après les auteurs, le processus de spécification fut long (en partie par la faute des spécification
déjà existantes qui étaient parfois contradictoires). Et on peut remarquer que certaines erreurs
possibles n’ont pas été traitées, comme l’existence d’une faille permettant de monter une attaque
de type déni de service dans le sous-protocole Cardholder Registration. L’existence possible d’une
telle faille avait été admise par les auteurs dans [9] :
« While stressing that each authority certifies a specific key for a single cardholder,
the theorem does not prevent different authorities to certify the same key for the same
cardholder. »
mais elle a été mise en évidence par les outils développés dans le cadre du projet AVISS2 , en se
basant sur la spécification donnée dans [9]. Notons que la faille trouvée consiste à faire certifier une
même clef plusieurs fois par la même autorité de certification.
Algèbre de processus et équivalence observationnelle. Les méthodes reposant sur l’équivalence

observationnelle peuvent essentiellement se décrire de la manière suivante. On considère deux
systèmes de transitions Π1 et Π2 . La propriété à montrer est exprimée comme une relation entre
ces deux systèmes. Elle est prouvée si elle est une congruence. Le rôle d’un outil est donc de vérifier
que la relation est une relation d’équivalence qui est préservée par les transitions des systèmes. Par
exemple, le secret d’un message s peut être exprimé par l’équivalence entre deux exécutions du
protocole, l’une où l’adversaire n’agit pas, et l’autre où l’adversaire tente de modifier les messages.
L’avantage de l’équivalence observationnelle est qu’il est possible d’exprimer un grand nombre
de propriétés. La difficulté, dans l’utilisation de ces méthodes, est que la propriété à prouver dépend
de la relation d’équivalence choisie, qui n’est pas toujours décidable. Des travaux sont en cours [30]
pour automatiser cette approche, qui reste cependant pour l’instant essentiellement limitée à des
« preuves à la main ».
1.2.3 Méthodes automatiques

1.2.3.i But de nos travaux
Notre but est de construire un outil pouvant être utilisé dans la phase d’élaboration d’un pro-
tocole. Il est donc nécessaire qu’il soit utilisable simplement, et qu’un résultat soit rapidement
disponible. Pour ces raisons, nous nous sommes orientés vers des méthodes automatiques d’ana-
lyse de protocoles. À terme, nous visons le développement d’un système complet partant d’une
spécification de protocole dans un langage aisément compréhensible et le moins ambiguë possible,
et indiquant si le protocole spécifié est valide, incorrect ou s’il y a un risque d’existence d’erreur.
Nous présentons maintenant divers travaux d’analyse automatique de protocoles, en commençant
par les méthodes de recherche de failles, et en décrivant ensuite des méthodes de validation exis-
tantes.
1.2.3.ii La recherche de failles comme problème d’accessibilité

Le problème de la vérification de protocoles est indécidable, donc rechercher s’il y a une faille
sur un protocole est aussi indécidable. Ce deuxième problème est cependant plus simple, dans le
sens où s’il y a une faille sur un protocole P , elle n’implique qu’un nombre fini de participants. La
plupart des systèmes de recherche de failles se basent sur cette remarque, et se bornent à étudier
le cas d’un nombre fini de participants.
L’un des articles fondateurs de l’analyse des protocoles cryptographiques est celui de D. Do-
lev et A. Yao [41], dans lequel les auteurs considèrent une classe très restreinte de protocoles, et
donnent un algorithme permettant la recherche de failles ou la preuve de correction. Dans cet article
sont aussi définies les capacités de l’adversaire qui sont maintenant considérées comme standard.
Singulièrement, dans ce modèle, et pour un nombre fini de participants, il y a un nombre infini de
2 Automated Verification of Infinite State Systems, FET Open Assessment Project IST 2000-26410, (AVISS)
suites de transitions possibles. Deux voies ont depuis été suivies pour la recherche de failles. D’un
côté, il est recherché une sur-approximation des capacités de l’adversaire qui permet de se ramener
à un cas fini. De l’autre, le cadre défini dans [41] est restreint pour se ramener au cas de l’étude
d’un système fini.
Méthodes approchées. Une première approche a été de modéliser l’ensemble des états par des
automates d’arbres. Cette approche, initiée dans la cadre d’un nombre non-borné de sessions par
T. Genet et F. Klay dans [51], a été reprise et améliorée dans le cadre d’un nombre borné de
sessions par D. Monniaux d’abord [75], et ensuite par J. Goubault-Larrecq dans [53]. Dans ces
deux derniers cas, des automates d’arbres permettent de représenter les ensembles de messages
acceptables par les participants.
Méthodes exactes dans un cadre restreint. P. Ryan, S. Schneider, M. Goldsmith, G. Lowe

et B. Roscoe décrivent [93] comment il est possible de borner le système à étudier en typant les
messages. Ce typage permet d’assurer que l’ensemble des messages que l’adversaire a à prendre
en compte est fini, et peut être calculé. La description est reprise par B. Roscoe [88] sous le nom
de lazy intruder technique. Elle est appliquée avec succès pour l’étude [42] des protocoles décrits
dans [26] et peut être considérée comme étant l’état de l’art au début du travail présenté dans cette
thèse. D’autres travaux ont ouvert la voie vers une résolution symbolique exacte de la recherche
d’attaques dans le cadre d’un nombre borné de sessions, tels que ceux de R. Amadio et D. Lugiez [1]
ou de M. Boreale [13]. Ces travaux seront présentés en détail dans le chapitre 6.
1.2.3.iii Traitement de la correction de protocoles
Le handicap majeur des méthodes basées sur les problèmes d’accessibilité est que la question
posée concerne l’existence d’une suite de transitions, alors que la correction d’un protocole est une
propriété dépendante de toutes les suites de transitions. Pour que le résultat de l’analyse ait un
sens, il est raisonnable de demander, au moins, que si un outil déclare un protocole comme correct,
ce protocole le soit. L’indécidabilité du problème de la vérification de protocoles cryptographiques
implique alors que si les protocoles déclarés corrects par l’outil le sont bien, des protocoles corrects
pourront être déclarés comme fautif ou aucune réponse ne sera donnée pour certains protocoles.
Méthodes semi-automatiques. Une méthode dont toutes les réponses sont exactes ne peut
pas toujours rendre de réponse en un temps fini. Dans cette catégorie, il est possible de citer les
travaux de M. Debbabi et al. [33]. Un outil reposant sur la résolution symbolique de contraintes
est donné. Un protocole est transformé en un système de règles d’inférence ne terminant pas, et
un algorithme générique permet de transformer ce système en un système de règles terminant. La
terminaison de l’algorithme de transformation n’est pas assurée. Le handicap de cette méthode est
que même en cas de terminaison de l’algorithme de transformation, seul un certain type de failles
peut être analysé.
Une méthode très similaire est implantée dans l’outil Athena [98, 99]. Cet outil construit
récursivement des ensembles d’exécutions possibles du protocole tout en considérant un nombre
infini de participants. Le nombre de suites de transitions est infini. Le principal avantage de cet
outil est que l’utilisateur peut spécifier des conditions d’arrêt, qui sont à prouver par ailleurs. Il
semble de plus, d’après [98, 99], que les performances de l’outil, sur les protocoles étudiés, dépend
fortement de la stratégie d’exploration de l’ensemble des suites de transitions, qui doit être spécifiée
par l’utilisateur.
Certains auteurs ont proposé l’utilisation de systèmes semi-automatiques, c’est-à-dire dont la
terminaison, n’est pas assurée, et déclarant parfois comme fautif un protocole correct. La princi-
pale motivation est la recherche d’outils efficaces. Dans [10], par exemple, B. Blanchet décrit la
construction d’un système de règles Prolog décrivant toutes les actions possibles d’un adversaire en
présence d’un nombre infini de participants. Si cette construction termine, il est possible de vérifier
un protocole. Cette construction a été raffinée dans [11, 12] pour prendre en compte les propriétés
d’authentification.
1.3. Contenu de la thèse 9
Méthodes dont la terminaison est assurée. Pour assurer la terminaison dans le cas d’un
nombre non-borné de participants, il est nécessaire de pouvoir représenter le nombre infini de suites
de transitions possibles par un nombre fini de transitions symboliques. Plusieurs approches sont
possibles dans ce cadre.
Le premier type d’approche consiste à calculer un sur-ensemble de l’ensemble des connais-
sances possibles de l’adversaire. Par exemple, T. Genet et F. Klay sur-approchent les connaissances
de l’intrus à travers une représentation des déductions possibles de l’intrus par des automates
d’arbres [51]. L’avantage de cette méthode est de permettre la preuve de la correction de certains
protocoles. J. Goubault-Larrecq affine l’utilisation des automates d’arbre en considérant des ∨PTA
automates [53]. Les résultats donnés ne prennent actuellement en compte que des cas où c’est un
participant spécial qui participe à un nombre non-borné de sessions.
Le second type d’approche consiste à projeter l’ensemble des états (infini) d’une exécution de
protocole ayant un nombre non-borné de participants sur un ensemble d’états fini. Si la projection
respecte la relation de transition, on parle alors d’abstraction. Une telle projection respecte les
attaques de secrets [27]. L. Bozga, Y. Lakhnech et M. Perin [59], par exemple, fusionnent les
données échangées lors de différentes sessions du protocole et à ne considérent qu’un nombre fini
de participants pour se ramener au cas d’un nombre fini de données atomiques. Les auteurs traitent
également le cas de messages de taille non-bornée en éliminant les possibilités de divergence grâce
à une notion de chapeaux. C’est à notre connaissance l’un des rares travaux sur la vérification de
protocoles où un outil terminant permet de vérifier des protocoles dont les messages sont de taille
non-bornée.
1.3 Contenu de la thèse

1.3.1 Apports du travail présenté
Le travail présenté dans ce document vise à l’implantation d’un outil automatique d’analyse
d’une spécification de protocoles donnée dans un langage de haut niveau. Le travail d’implantation
réalisé ne satisfait que très partiellement ce but. Pour cette raison, une grande partie des travaux
exposés ici sont encore de nature théorique, et portent sur la complexité des algorithmes à mettre
en œuvre pour atteindre ce but. Il est possible de classer les apports de ce travail selon trois axes
principaux.
1.3.1.i Compilation de protocoles

Il existe actuellement peu d’outils qui permettent de spécifier un protocole dans un langage de
haut niveau accessible à un non-spécialiste et malgré tout expressif. Nous présentons le compilateur
de protocoles CasRul qui répond à ces deux critères. Par rapport à la présentation faite dans [56],
notre contribution au développement du processus de compilation suit deux axes.
Expressivité. Nous avons, en collaboration avec M. Bouallagui, étendu l’ensemble des opérations
disponibles pour spécifier un protocole. Nous avons aussi changé la gestion des connaissances des
participants pour tenir compte de l’utilisation de clefs non atomiques.
Fondations théoriques. Le deuxième axe de travail sur le compilateur CasRul a été de fonder
le processus de compilation sur des bases théoriques solides. Nous avons défini formellement la
notion d’exécutabilité d’un protocole. Le résultat sur les problèmes d’accessibilité clos permet de
montrer qu’il est possible de savoir si un protocole est exécutable ou non en temps polynomial.
Nous définissons ensuite la représentation de ses connaissances par un participant cherchant à les
analyser au maximum. Cette représentation se base sur un ensemble minimal de connaissances
qu’il n’est pas possible d’inférer les unes à partir des autres, et tel que tous les autres messages
ou parties de messages connus peuvent être exprimés comme des termes sur cet ensemble. Cette
représentation minimale permet de prouver certaines propriétés sur les règles de réception/envoi
de messages par les participants qui sont utilisées dans la suite de ce document, ainsi que dans
plusieurs articles [19, 20].
1.3.1.ii Recherche de failles
Recherche efficace de failles. Nous avons, dès novembre 2000 [24], réalisé l’implantation d’une
stratégie de déduction par résolution de contraintes. Cette stratégie est aussi appelée lazy intruder
strategy, bien qu’elle soit indépendante des techniques présentées dans [88, 93]. La complexité (le
problème est NPTIME-complet pour la recherche de failles) de cette stratégie a ensuite été prouvée
dans [90]. Nous donnons une preuve de complétude et de correction pour la recherche d’attaques
qui nous semble plus simple que celles présentées à ce jour.
Recherche de failles lorsque des opérateurs algébriques sont considérés. Nous avons
étendu la recherche de failles dans le cadre d’un nombre borné de sessions aux cas où des opérateurs
algébriques, tels que le ou exclusif bit à bit [19] ou l’exponentiation [20], sont considérés. Nous
avons tenté, dans ce document, de simplifier les preuves des algorithmes donnés. Le lecteur pourra
se référer aux rapports de recherche correspondants pour comparaison.
1.3.1.iii Vérification de protocoles cryptographiques
Vérification pratique de protocoles. Le dernier apport de cette thèse concerne la vérification

de protocoles cryptographiques. Nous avons commencé par montrer comment un nombre non-
borné de participants pouvait être pris en compte dans le cadre de la stratégie paresseuse de
l’intrus via une abstraction sur les constantes échangées au cours d’une session et en bornant la
taille des messages acceptés par les participants à un nombre non-borné de session [25], et [23] pour
l’implantation préliminaire.
Preuve dans un cadre théorique. Nous avons ensuite montré que l’algorithme implanté est
EXPTIME-complet dans [22]. Là encore, nous espérons que la présentation de la preuve de correc-
tion et de complétude dans ce document est plus simple que celle du rapport de recherche.
1.3.2 Plan de la thèse

1.3.2.i Fondations (chapitres 2, 3 et 4)
Nous commençons par décrire dans le chapitre 2 les protocoles cryptographiques que nous
considérons. Nous donnons les définitions des termes relatifs utilisés dans le reste de ce document.
Nous précisons aussi les primitives cryptographiques que nous considérons comme importantes, et
décrivons leurs propriétés. Enfin, nous décrivons les différents types de failles que nous recherchons,
ainsi que l’adversaire visant à exploiter ces failles.
Nous considérons, tout au long de ce document, des constructeurs de messages vérifiant certaines
propriétés algébriques. Nous définissons dans le chapitre 3 des termes opérations représentant les
messages pouvant être construits avec ces opérateurs, et des termes valeurs représentant les valeurs
de ces messages, ainsi qu’une fonction de normalisation sur les termes valeurs. Nous montrons qu’il
existe un isomorphisme entre les classes d’équivalences des termes opérations et les formes normales
des termes valeurs. Cette forme normale sera utilisée dans le reste de ce document pour décrire les
messages échangés par les participants ou connus de l’adversaire.
Tous les problèmes que nous avons présentés peuvent se formuler comme des problèmes d’acces-
sibilité pour un système de transitions défini par des règles de réécritures sur des ensembles. Dans
le chapitre 4, nous définissons ces systèmes de réécritures, et donnons une propriété de combinaison
permettant de construire des systèmes de réécritures sur des ensembles locaux. Nous montrons que
les règles de réécritures sur les ensembles associées aux opérateurs que nous considérons peuvent
toujours être combinées pour former un système local. Ce résultat permet de montrer que pour
tout système de réécriture L formé par combinaison de règles associées aux opérateurs, savoir si
un terme peut être obtenu à partir d’un ensemble de termes en utilisant les règles de L peut être
résolu en temps polynomial.
1.3. Contenu de la thèse 11
1.3.2.ii Compilation (chapitre 5)

Ce chapitre traite du traitement que font les rôles de leurs connaissances, ainsi que de la
possibilité ou non, pour un protocole, d’être implanté (notion d’exécutabilité). Nous donnons aussi
quelques propriétés sur les occurrences des variables dans les règles d’envoi/réception de messages
par les rôles.
1.3.2.iii Recherche de failles (chapitres 6 et 7)

Dans les deux chapitres suivants, nous présentons des méthodes de recherche de failles.
Dans le chapitre 6, nous décrivons la recherche de failles par une stratégie de résolution de
contraintes. Une preuve élémentaire, se basant sur les résultats des problèmes d’accessibilité clos,
de la correction, de la complétude et de la terminaison est donnée. Nous présentons aussi les
résultats pratiques obtenus au moyen de cette stratégie avec le prouveur daTac.
Dans le chapitre 7, nous nous intéressons de manière théorique au problème de la recherche
d’attaques lorsque des opérateurs algébriques sont impliqués. Nous montrons que ce problème
est NPTIME-complet lorsque les opérateurs algébriques présentés au chapitre 3 sont considérés
indépendamment les uns des autres. La technique utilisée ne nous a pas permis de traiter les cas
où plusieurs de ces opérateurs sont considérés simultanément.
1.3.2.iv Vérification de protocoles (chapitre 8)

Enfin, nous présentons dans le chapitre 8 les résultats théoriques aussi bien que pratiques
obtenus lorsqu’un nombre non-borné de participants est considéré. Ce chapitre est scindé en deux
parties, la première reprenant le résultat de complexité, et la seconde traitant de l’implantation de
l’Oracle dans CasRul.
Première partie
Fondements
13
2
Primitives cryptographiques
Ce chapitre, très largement inspiré de [95], décrit des modes de chiffrement et des
primitives cryptographiques utilisés en pratique. Si sa lecture, nous l’espérons, permet
de mieux décrire les systèmes étudiés, il n’y a pas ici de contenu technique relatif au
reste de ce document.
2.1 Modes de chiffrement

Dans cette section, nous décrivons les possibilités, étant donné un algorithme de chiffrement et
un message, de calculer l’image de ce message par cet algorithme.
2.1.1 Chiffrement parfait

Le chiffrement parfait est réalisable à condition supposer que les parties communiquant entre
elles connaissent déjà une clef de longueur infinie. Chaque fois qu’une des parties enverra un message
de n bits, les n premiers bits de la clef seront utilisés pour le chiffrement (ou le déchiffrement, à
la réception du message), et seront ensuite jetés. En pratique, un tel système est couplé à une
méthode physique de transfert de la clef secrète par morceaux de taille finie.
Dans le cadre de ce document, le chiffrement parfait sera plutôt une hypothèse de travail. Nous
supposerons que le chiffrement est parfait lorsque nous ne chercherons pas à exploiter les propriétés
d’homomorphisme ou de préfixe des algorithmes de chiffrement utilisés en pratique.
Chiffrement parfait :
Le chiffrement est dit parfait si :
– pour deux messages M et M 0 et deux clefs K et K 0 , le chiffrement de M par
K est égal au chiffrement de M 0 par K 0 si, et seulement si, M est égal à M 0
et K est égale à K 0 ;
– il n’est pas possible de composer le chiffrement d’un message M par une clef
K sans connaı̂tre M et K ;
– pour connaı̂tre un message M à partir du chiffrement de M par une clef K,
il est nécessaire de connaı̂tre la clef K 0 permettant de déchiffrer les messages
chiffrés par K ;
2.1.2 Chiffrement par blocs

La plupart des algorithmes de chiffrement communément utilisés opèrent par blocs. Le message
à chiffrer est scindé en blocs de taille fixée. L’algorithme de chiffrement est appliqué une fois pour
chaque bloc.
15
16 Chapitre 2. Primitives cryptographiques
2.1.2.i Chiffrement par blocs sans chaı̂nage des blocs

Dans le chiffrement par blocs sans chaı̂nage, les blocs ne sont pas reliés entre eux au cours du
chiffrement (voir figure 2.1).
message ...
en clair
chiffrement f f f
message
chiffré ...
Fig. 2.1 – Chiffrement par blocs sans chaı̂nage
Ce type de chiffrement n’offre pas de garanties sur l’ordre des blocs. Il est de plus possible
d’extraire des blocs de différents messages chiffrés par une même clef K et de composer un nouveau
message chiffré par K.
Propriété d’homomorphisme :
Un message C1 · . . . · Cn est le résultat du chiffrement d’un message M1 · . . . · Mn
par une clef K si et seulement si Ci est le résultat du chiffrement de Mi par
cette clef K, pour i ∈ {1, . . . , n}.
Dans la suite de ce document, nous ne considérerons la propriété d’homomorphisme que dans

le cas d’algorithmes de chiffrement à clef symétrique. Le but de cette restriction est d’éviter la
redondance, les techniques utilisées pour prendre en compte ce cas se généralisant sans difficulté
au cas du chiffrement asymétrique.
2.1.2.ii Chiffrement par blocs avec chaı̂nage

Un algorithme de chiffrement est appliqué avec chaı̂nage si le résultat du chiffrement d’un
bloc dépend des blocs précédents. Cette relation est exprimée par une fonction de chaı̂nage qui
est généralement le ou exclusif bit à bit (noté ⊕). Formellement, il existe deux possibilités pour
réaliser un chaı̂nage. Notons f (M ) le résultat de l’application de l’algorithme de chiffrement pour
un bloc M . Le chaı̂nage peut se faire soit sur le texte en clair, soit sur le texte codé. Dans les deux
cas que nous allons considérer, il est nécessaire d’initialiser le chaı̂nage par un bloc arbitraire. Ce
bloc, appelé vecteur d’initialisation, sera la valeur de C0 .
Chiffrement par blocs en mode chaı̂né (mode CBC). Dans ce mode de chiffrement, le
chaı̂nage se fait sur les blocs du message en clair. Notons M1 , . . . , Mn les blocs à chiffrer. Les blocs
du message chiffré seront C1 , . . . , Cn , avec :
Ci = f (Ci−1 ⊕ Mi ))
pour i ∈ {1, . . . , n}. Graphiquement, l’opération de chiffrement d’un message est représentée dans
la figure 2.2.
Chiffrement à rétroaction, sur le texte codé. L’un des inconvénients du chiffrement par
blocs en mode chaı̂né est qu’il est nécessaire de disposer d’un bloc entier avant d’émettre un
2.1. Modes de chiffrement 17
message
en clair ...
f f f
message
chiffré ...
Fig. 2.2 – Chiffrement par blocs en mode chaı̂né (mode CBC)
message. Le chiffrement à rétroaction se fait sur le texte chiffré, à partir d’un bloc initial aléatoire.
Notons M1 , . . . , Mn les blocs à chiffrer. Les blocs du message chiffré seront C1 , . . . , Cn , avec :
Ci = Mi ⊕ f (Ci−1 )
pour i ∈ {1, . . . , n}. Graphiquement, l’opération de chiffrement d’un message est représentée dans
la figure 2.3. Ce chiffrement est utilisé lorsque la taille des messages à envoyer est petite. Cela peut
être la transmission sécurisée d’un caractère d’un terminal vers un serveur, par exemple.
message
...
en clair
f f f
message
chiffré ...
Fig. 2.3 – Chiffrement par blocs par rétroaction (mode CFB)
Propriétés du mode chaı̂né. Un vecteur d’initialisation est utilisé pour le premier bloc. Si le
chaı̂nage empêche une reconstitution arbitraire d’un message à partir de blocs, il permet toutefois
l’extraction de préfixes. En effet, dans les deux modes (chaı̂né et à rétroaction), le préfixe d’un
message chiffré est un message chiffré. Dans la suite de ce document, nous prendrons en compte
cette propriété de préfixe :
1. uniquement sur le chiffrement en bloc chaı̂né. L’autre mode de chiffrement, ayant des pro-
priétés identiques, n’est pas considéré ;
2. uniquement pour le chiffrement symétrique.
Les techniques utilisées permettraient cependant d’élargir sans difficulté l’analyse à tout opérateur
de chiffrement symétrique ou asymétrique ayant la propriété de préfixe, c’est-à-dire :
Propriété de préfixe :
Si C1 · . . . · Cn est un message chiffrant M1 · . . . · Mn par une clef K, alors pour
tout i ∈ {1, . . . , n}, le message C1 · . . . · Ci est égal au chiffrement du message
M1 · . . . · Mi par la même clef K.
2.2 Opérations de chiffrement

2.2.1 Chiffrement par clefs asymétriques
2.2.1.i Définition
Le principe du chiffrement avec clefs asymétriques a été pour la première fois énoncé par W. Dif-
fie et M. Hellman [40] et Merkle [70]. Pour reprendre leur définition, un système de chiffrement à
clefs publiques est un couple de familles {EK }K∈K et {DK }K∈K de fonctions :
EK : M → M
DK : M → M
sur un ensemble fini de messages M tel que :

1. pour tout K ∈ K, EK est l’inverse de DK ;
2. pour tout K ∈ K et M ∈ M, les valeurs EK (M ) et DK (M ) sont facilement calculables à
partir de la connaissance de EK , de DK et de M ;
3. pour tout K ∈ K, il est difficile de trouver un calcul facile de DK à partir de la connaissance
de EK ;
4. pour tout K ∈ K, il est facile de calculer les fonctions EK et DK .
Un système de chiffrement à clefs publiques ne repose donc pas sur la possibilité théorique ou
non d’un calcul, mais sur le rapport en termes de temps de calcul entre deux opérations inverses
l’une de l’autre. Plusieurs algorithmes ont été proposés en ce sens, que nous classons selon le
problème difficile à résoudre.
2.2.1.ii Problème du sac-à-dos

L’asymétrie demandée par un système de chiffrement à clefs publiques est naturellement présente
pour tous les problèmes dont la complexité est non-déterministe. La classe des calculs faciles peut
être définie comme étant la classe des calculs pouvant être menés en temps polynomial en la taille
de leur entrée (classe PTIME). Avec cette définition, la classe des calculs difficiles recherchée est la
classe NPTIME des problèmes dont, intuitivement, il est possible de vérifier une solution en temps
polynomial. Cette approche est suggérée par W. Diffie et M. Hellman dans leur article fondateur du
chiffrement asymétrique [40], mais ils remarquent aussi que la difficulté d’un problème est celle de
ses instances les plus complexes, alors que le point 3. demande une difficulté uniforme sur presque
toutes les instances.
M. Hellman et R. Merkle ont proposé [71] d’utiliser des instances particulières du problème
du sac à dos. Ce problème peut se résumer de la manière suivante. Soient E = {M1 , . . . , Mn } un
ensemble de n valeurs entières différentes, et S un nombre. Trouver s’il existe un sous-ensembe F
de E tel que :
S = Σm∈F m
Ce problème est NP-complet, ce qui signifie que tout problème dans NPTIME peut être ramené à
ce problème et que ce problème est lui-même dans NPTIME. L’intérêt est qu’il existe une méthode
2.2. Opérations de chiffrement 19
de construction de l’ensemble E telle que, en connaissant la construction d’une instance E, et étant

donné un nombre S, le problème puisse se résoudre en temps polynomial. Cette méthode consiste à
construire une instance E 0 pour laquelle le problème est solvable en temps polynomial, et à choisir
une instance E ayant les mêmes solutions que E 0 . La clef publique est l’ensemble E, et la clef privée
est l’ensemble E 0 .
Cette méthode n’est pas utilisée en pratique car il a été montré [96] qu’il est possible, pour une
clef publique E construite à partir de E 0 , de retrouver E 0 .
2.2.1.iii Factorisation de grands entiers

L’un des algorithmes de chiffrement asymétrique les plus populaires est sans conteste celui
proposé par R. Rivest, A. Shamir et L. Adleman [87] (voir aussi [89]). Cet algorithme, appelé
algorithme de chiffrement RSA en référence aux auteurs, repose sur le calcul pour un entier n du
nombre ϕ(n) de nombres entiers plus petits que n et premiers avec n. Calculer ϕ(n) est très simple
si la décomposition de n en facteurs premiers est connue, et il n’y a pas de meilleure méthode
connue pour effectuer ce calcul. L’asymétrie réside donc ici dans la connaissance ou non de la
factorisation de n.
Par le petit théorème de Fermat, le nombre ϕ(n) vérifie la propriété suivante. Pour tout entier
m premier avec n, on a :
mϕ(n)+1 ≡ m mod n
Au contraire du cas du problème du sac-à-dos, les clefs publiques et privées sont ici équivalentes
lors de la construction. Connaissant ϕ(n), on choisit deux entiers e et d tels que :
d·e≡1 mod ϕ(n)
Le calcul de d en fonction de e (et réciproquement) est très facile dès que ϕ(n) est connnu. L’un
de ces entiers, e par exemple, est choisi comme étant la clef publique, l’autre étant la clef privée.
L’entier n est mis à la disposition de tous en même temps que e. Un message M à chiffrer est
d’abord scindé en blocs représentant des entiers mi inférieurs à n. Le chiffrement de chaque bloc
m est l’entier :
c = me mod n
Pour déchiffrer, en utilisant le petit théorème de Fermat, il suffit de calculer :
m = cd mod n
Il n’existe pas actuellement de résultat de complexité donnant une borne inférieure difficile
sur le temps de calcul de la factorisation d’un entier n. Le meilleur algorithme connu permet la
1
factorisation d’un entier n en environ n 3 étapes. Autrement dit, pour un nombre premier de 1024
bits, il faut compter sur environ 2341 étapes de calcul.
2.2.1.iv Calcul du logarithme discret

L’algorithme de chiffrement proposé par T. El Gamal [47] est basé sur la difficulté du calcul
du logarithme discret, déjà utilisée dans [40]. Le calcul du logarithme discret consiste à calculer un
entier x en fonction de g, g x mod n et n. Le schéma est ici plus simple que pour l’algorithme de
chiffrement RSA. Deux entiers n et g sont mis à la disposition de tous, et peuvent être partagés par
un groupe d’utilisateurs. Chaque utilisateur dans ce groupe choisit un entier x, et pose g x comme
étant sa clef publique. Cette clef est elle aussi mise à disposition de tous. L’asymétrie est donc,
dans ce cas, uniquement dans la connaissance ou non de la clef privée x, et dans le fait que cette
clef est difficile à calculer en fonction de g, g x et n.
Un message M à chiffrer est d’abord scindé en blocs représentant des entiers inférieurs à n.
Pour chaque bloc,
soit m le nombre entier représenté.
L’émetteur choisit un entier k aléatoire, et
envoie la paire g k mod n, (g x )k · m mod n . Connaissant x et g k , le receveur peut calculer g xk
mod n. Connaissant g xk mod n, (g x )k · m mod n et n, il peut alors calculer m.
Notons que les choix de x et k ne sont pas totalement aléatoires. Pour assurer une bonne
sécurité, il est nécessaire que le sous-groupe multiplicatif de ( n )∗ engendré par g x (resp. g k ) soit
« grand ». Une possibilité, pour assurer cette condition, est de choisir un entier x (resp. k) tel que
g x (resp. g k ) soit générateur de ( n )∗ , c’est-à-dire x (resp. k) premier avec ϕ(n).
De même que dans le cas du chiffrement RSA, il n’existe pas actuellement de borne inférieure
difficile connue à la complexité du calcul du logarithme discret. Pour des clefs de même longueur,
ce second est toutefois considéré comme étant plus sûr. Le meilleur algorithme connu permet en
1
effet de trouver le résultat en environ n 2 étapes. Pour un entier n à 1024 bits, celà signifie que
le temps de calcul pour trouver la clef privée en fonction des paramètres publiques sera 2171 (en
notation décimale, un 1 suivi d’une cinquantaine de 0) fois plus lent dans le cas du chiffrement El
Gamal que dans le cas du chiffrement RSA.
2.2.1.v Cas du chiffrement commutatif

L’utilisation de clefs publiques nécessite en général une infrastructure permettant de relier une
clef publique à son possesseur légitime, la personne l’ayant créée et connaissant la clef privée.
Une autre possibilité a été proposée par A. Shamir, et consiste à supposer que les opérations de
chiffrement sont commutatives. Notons provisoirement {M }K le chiffrement d’un message M par
une clef asymétrique K. La commutativité
signifie
dans
ce cas
que pour deux clefs asymétriques
K1 et K2 quelconques, les messages {M }K1 K et {M }K2 K sont égaux.
2 1
La première implantation proposée fut une variante du chiffrement RSA dans laquelle n est
un nombre premier (et non le produit de deux nombres premiers). Dans cette implantation, les
chiffrements par une clef publique K puis par son inverse K −1 s’annulent. Pour cette raison, nous
parlerons d’algorithmes de chiffrement de type RSA pour désigner les algorithmes de chiffrement
asymétrique commutatifs où les clefs s’annulent.
Commutation de clefs :
Nous appelons chiffrement de type RSA un algorithme de chiffrement à clefs
asymétriques tel que, pour tout couple (K1 , K2 ) de clefs, et pour tout message
M : (
{M }K1 K = {M }K2 K
2 1
{M }K1 K −1 = M
1
2.2.1.vi Algorithmes de signature

Les clefs asymétrique ne sont pas limitées au chiffrement de messages. Elles permettent aussi
de signer des messages. Dans le cas de l’algorithme de signature de El Gamal, par exemple, la
signature se fait à travers l’utilisation du théorème de Bezout. Le mécanisme de signature est dans
ce cas différent du mécanisme de chiffrement. Au contraire, la signature par des clefs RSA se déroule
exactement de la même manière que le chiffrement, la clef privée de l’émetteur étant utilisée dans
l’exposant à la place de la clef publique du récipiendaire. Afin de simplifier les notations, nous nous
placerons dans le cas d’un même algorithme pour le chiffrement et la signature.
Signature :
Nous utilisons les mêmes opérateurs pour décrire les opérations de signature et
de chiffrement. La différence entre ces deux opérations réside dans l’utilisation
de la clef privée dans le premier cas, et de la clef publique dans le second.
2.2.2 Chiffrement par clefs symétriques

2.2.2.i Utilisation
Le chiffrement par clefs symétriques a été historiquement le premier utilisé. Son principal défaut
est que les parties communiquant entre elles doivent partager un secret, la clef, avant que les
communications ne commencent. Le chiffrement symétrique est préféré au chiffrement asymétrique
2.2. Opérations de chiffrement 21
dès que les deux parties partagent un secret, la clef. Il est en effet beaucoup plus rapide que le
chiffrement asymétrique, et certains algorithmes tels que DES peuvent même faire l’objet d’une
implantation sur circuits imprimés.
2.2.2.ii Un exemple, l’algorithme DES

L’algorithme DES est une version révisée par la NSA3 d’un algorithme initialement proposé
par les chercheurs d’IBM. Cet algorithme de chiffrement a été étudié pendant deux décennies sans
qu’une faille sérieuse n’ait été découverte. Étonnamment, il était même résistant à des techniques
d’analyses apparues une dizaine d’années après sa conception. Il est cependant aujourd’hui remplacé
par AES, qui entre autres a l’avantage de permettre l’utilisation de clefs de tailles variables.
DES est un algorithme de chiffrement par blocs. La taille utile des clefs est fixée et est de 56 bits.
L’algorithme de chiffrement repose sur un enchaı̂nement de permutations expensives, d’application
de fonctions et de ou exclusif bit à bit entre des parties de la clef et des parties de messages. Cet
enchaı̂nement a été étudié pour que l’ensemble des clefs ne forme pas un groupe, que le chiffrement
par différentes clefs ne soit pas commutatif et pour qu’il n’y ait pas de meilleur algorithme, pour
trouver une clef, que d’essayer toutes les clefs possibles.
2.2.2.iii Le protocole de W. Diffie et M. Hellman pour une construction distribuée

de clefs symétriques
Dans le cas de personnes communiquant entre elles à travers un réseau, il se peut que les acteurs
communiquant n’aient pas confiance les uns en les autres pour garder un secret. Dans leur article
fondateur [40], W. Diffie et M. Hellman proposent une méthode reposant sur la difficulté du calcul
du logarithme discret pour que chaque partie contribue au calcul de la clef.
Soient deux rôles A et B, qui se sont entendus sur un entier n et une base g. Le rôle A choisit
un entier x, sa clef privée, et envoie g x mod n à B. À la réception du message, B choisit une clef
privée y, et renvoie g y mod n. À la fin de cet échange, A et B peuvent calculer g x·y mod n, mais
des témoins de l’échange ne le peuvent pas, sauf à calculer x à partir de g x mod n, g et n (ou y à
partir de g y mod n, g et n).
À la différence de l’algorithme de chiffrement asymétrique proposé par T. El Gamal où les
propriétés de l’exponentielle discrète peuvent être abstraites via l’utilisation de clefs publiques et
privées, ce protocole nécessite la modélisation des propriétés de l’exponentielle pour exprimer qu’à
la fin de l’échange A et B connaissent la clef (g x )y mod n. C. Meadows et P. Narendran ont
montré [76], que prendre en compte toutes les propriétés de l’exponentielle rend le problème de
l’unification indécidable. Pour cette raison, nous nous limitons aux propriétés suivantes, suffisantes
pour exprimer l’égalité finale dans le protocole de W. Diffie et M. Hellman.
Exponentielle discrète :
nous modélisons les propriétés suivantes de l’exponentielle modulaire, pour tous
les messages g, x et y considérés comme des entiers :
(g x )y ≡ (g y )x mod n
−1
(g x )x ≡ g mod n
Dans la suite de ce document, l’opérateur −1 dénotera la clef privée associée à une clef publique.
Afin d’éviter toute confusion, nous noterons l’inverse de x en notation additive, c’est-à-dire −x.
2.2.3 Un chiffrement asymétrique faible : le ou exclusif bit à bit

Que ce soit pour des raisons de rapidité ou pour utiliser directement ses propriétés algébriques,
le ou exclusif bit à bit est parfois utilisé pour réaliser un chiffrement symétrique associatif et
commutatif. Pour chiffrer un message M par une clef K, on met en correspondance les bits mi de
3 National Security Agency, une agence fédérale des États-Unis dont le rôle est de rassembler des renseignements
à travers l’écoute de communications dans le monde.

M et ki de K. Le i-ème bit ci du message chiffré C sera égal à 1 si mi et ki sont différents, et à 0

sinon. Nous notons :
C =M ⊕K
On vérifie facilement que l’opération ⊕ est bien associative et commutative, et que :

M ⊕0 = M
M ⊕M = 0
La première équation correspond à l’existence d’un élément neutre pour l’opérateur ⊕, et la seconde
à la nilpotence de l’opérateur ⊕.
2.3 Fonctions à adressage dispersé

Une fonction à adressage dispersé (fonction de hachage, dans [95]), est une fonction h dont
l’application sur un message M possède les deux propriétés suivantes :
– connaissant M et h, il est très facile de calculer h(M ) ;
– étant donné M , il est très difficile de trouver un message M 0 6= M tel que h(M ) = h(M 0 ).
Notons que la seconde propriété implique qu’il est très difficile de calculer M connaissant h(M ) et
h.
Les fonctions à adressage dispersé permettent de pouvoir « prouver » qu’un message M est
connu sans avoir à l’envoyer. Il est possible de les comparer à des témoins qui assurent du contenu
d’une transaction ou d’une connaissance, mais ne révèlent pas cette transaction ou cette connais-
sance.
Ces fonctions peuvent être bijectives, mais leur image est le plus souvent un message de longueur
fixe. Nous parlons alors d’empreintes à N bits.
2.3.1 Résistance à la collision

Pour servir de témoins fiables, il est nécessaire qu’il n’y ait pas deux messages « proches » de
même image. Si ce n’est pas le cas, il est possible de monter une attaque d’anniversaire.
2.3.1.i Attaques d’anniversaire
On se place dans le cas d’un ensemble fini à n éléments, et on tire k éléments parmi les n au
hasard et avec remise. Nous notons ωk,n l’événement :
Les k éléments tirés sont distincts.
Si on suppose que chaque élément est choisi avec la même probabilité, alors un calcul facile montre
que la probabilité de ωk+1,n , notée pk+1,n , est :
n!
pk+1,n =
(n − k)! · nk
Pour k de l’ordre de grandeur de la racine carrée de n et n grand, cette probabilité est non-
négligeable (proche de 1e ).
L’attaque d’anniversaire consiste à choisir des messages au hasard, à en calculer l’empreinte par
toutes les clefs possibles, et à s’arrêter lorsque deux messsages distincts ont la même empreinte. Si
les messages chiffrés sont longs de n bits, on peut espérer trouver deux messages de même empreinte
n
au bout de 2 2 essais. Le nom de cette attaque tient son origine de l’utilisation qui peut en être
faite dans une salle d’une vingtaine de personne : il y a environ une chance sur deux que deux
personnes aient la même date anniversaire.
2.3. Fonctions à adressage dispersé 23
2.3.1.ii Exemple
L’exemple suivant est tiré de [95]. Supposons que deux personnes, Alice et Bob, désirent signer
un contrat. Alice peut monter une attaque d’anniversaire pour duper Bob de la manière suivante.
1. Alice commence par préparer deux versions du contrat, une en sa faveur, et l’autre favorable
à Bob ;
2. ensuite, elle apporte des modifications aux deux contrats, dans le but d’obtenir deux versions
différentes ayant la même empreinte.
Si les rôles d’Alice et Bob sont symétriques, le contrat sera probablement nul, car chacun possédera
un témoin de sa version. Mais si Alice est une notaire et garde seule le témoin, Bob n’a plus aucun
moyen de prouver que sa version du contrat est celle qu’il a accepté de signer.
L’utilisation de fonctions à adressage dispersé rend inévitables les attaques d’anniversaire. La
bonne nouvelle est que pour avoir une bonne chance de trouver deux contrats de même image, et
si le témoin est de longueur n, l’espérance du nombre de modifications qu’Alice doit essayer est de
n
l’ordre de 2 2 . On considère à l’heure actuelle que choisir des témoins de longueur supérieure ou
égale à 128 bits est suffisant pour éviter de telles attaques en pratique.
2.3.2 Exemples de fonctions à adressage dispersé

Deux fonctions à adressage dispersé sont régulièrement utilisées, les fonctions MD5 et SHA.
MD5. La fonction MD5 est une version sécurisée d’une version précédente, MD4. Elle produit
des empreintes de 128 bits de long pour des messages de taille quelconque. Le principe adopté est
de commencer par scinder le message en blocs de 512 bits, de traiter chaque bloc en fonction du
résultat sur le bloc précédent. La longueur totale du message est codée dans le dernier bloc, ce qui
empêche a priori toute relation entre la valeur pour un message M et un préfixe de M .
Une étape préliminaire de l’algorithme MD5 est l’étape de compression. Une constante de 128
bits de long est concaténée à un bloc de 512 bits, et le message de 640 bits est réduit à un message
de longueur 128 bits. La fonction permettant de passer des messages de 640 bits à ceux de 128 est
appelée fonction de compression. Une attaque a été montée [14] permettant de trouver des collisions
sur cette fonction. Cette attaque ne permet cependant pas de créer des collisions au niveau des
empreintes à cause de la constante de 128 bits concaténée. Bien qu’aucune attaque réelle n’ait été
trouvée, cette faiblesse conduit [95] à conseiller de lui préférer l’algorithme SHA.
SHA. Il s’agit d’une autre évolution de l’algorithme MD5. Les empreintes produites sont longues
de 160 bits, et cette fonction à adressage dispersé semble plus sûre que MD5. Aucune faiblesse n’a
été trouvée jusqu’ici. On peut donc provisoirement considérer que cet algorithme est une fonction
à adressage dispersé parfaite.
3
Termes, classes d’équivalence et

représentations
3.1 Introduction
Dans ce chapitre, nous donnons un cadre formel pour l’étude des messages. Après avoir rappelé
des notions de base sur les ensembles et les multi-ensembles dans le reste de cette introduction,
nous allons traiter le problème des égalités entre messages. Dans le cadre classique d’étude de
protocoles cryptographiques, le chiffrement est supposé parfait, et des opérations telles que le
ou exclusif bit à bit ne sont pas considérées. Ces hypothèses permettent de traiter les messages
échangés comme des termes sur une signature comprenant les constantes et les opérations de
chiffrement, concaténation,. . . Cette représentation des messages sera définie à la section 3.3.3.
Nous nommons ces termes des termes opérations pour souligner qu’ils représentent la suite des
opérations aboutissant à un message.
Pour prendre en compte les égalités possibles entre messages construits différemment, deux
possibilités s’offrent à nous. La première, utilisée classiquement en déduction automatique, est
d’utiliser des règles de déduction modulo la théorie décrivant les égalités possibles. Ce raisonnement
modulo peut être fait soit de manière syntaxique, en ajoutant des règles de déduction pour modéliser
les égalités, soit de manière sémantique, en testant l’égalité modulo lors de l’application d’une règle
de déduction. L’inconvénient de cette solution est qu’elle se prête mal à l’analyse de complexité,
et qu’il est difficile de raisonner sur les suites de déductions. Cela nous amène à la deuxième
possibilité, qui est de considérer des représentants des classes d’équivalences des termes opérations.
Afin de simplifier l’écriture, pour les constructeurs associatifs et commutatifs, nous utiliserons des
ensembles ou des multi-ensembles dans l’écriture de ces termes. Afin de bien les différencier des
termes opérations, nous les nommons termes valeurs. Ils sont définis dans la section 3.3.5. Une
fonction de normalisation est définie sur ces termes valeurs (section 3.4), et nous montrons que les
termes valeurs en forme normale représentent de manière unique les classes d’équivalence sur les
termes opérations. Dans la suite de ce document, nous utiliserons toujours des règles de déduction
sur des termes valeurs en forme normale, qui seront plus simplement appelés termes.
Enfin, nous donnons dans la section 3.5 une représentation possible des termes valeurs, et
donnons la complexité d’opérations usuelles sur les termes (égalité, sous-terme,...) Cette section
sera utilisée implicitement dans le reste de ce document pour donner la complexité de problèmes
de décisions liés à l’étude de protocoles cryptographiques.
25
26 Chapitre 3. Termes, classes d’équivalence et représentations
3.2 Multi-ensembles et multi-ensembles généralisés

Pour la suite de cette section, on se donne un ensemble T . L’ensemble des parties de T est noté
P(T ). L’ensemble des parties finies de T est noté Pfini (T ).
Nous supposons que les opérations d’union (∪), d’intersection (∩), de complémentaire (T \ E)
sont connues du lecteur. Il en va de même pour les relations d’appartenance (∈) et d’inclusion (⊆).
Nous notons E ⊂ T pour E ⊆ T et E 6= T , E 6⊆ T pour dire que E n’est pas un sous-ensemble de
T . Nous notons |E| le cardinal de l’ensemble E, et nous écrivons E ⊂fini T pour dire que E ⊂ T et
|E| < ∞.
3.2.1 Support d’une fonction

Soit A = {α : T → T 0 } l’ensemble des fonctions de T vers T 0 , et × une loi sur A telle que
(A, ×, e) soit un monoı̈de d’élément neutre e ∈ A. Le support d’une fonction α ∈ A, noté (α),
est le sous-ensemble de T suivant :
(α) = {t ∈ T | α(t) 6= e(t)}
Dans ce document, nous considérerons deux cas d’ensembles de fonctions :

1. les fonctions de termes vers des termes, avec la loi de composition de fonctions et comme
élément neutre l’identité ;
2. les fonctions vers , , etc., avec comme loi l’addition de fonctions, et comme élément neutre
la fonction d’image partout égale à 0.
Définition 1 (Support d’une fonction à valeur dans ou )

Soit α : T → T 0 une fonction, avec T 0 ∈ { , }. Le support de α, noté (α), est défini par :
(α) = { t ∈ T | α(t) 6= 0}
Définition 2 (Support d’une fonction à image dans un ensemble de termes)

Soit α : T → T 0 une fonction, avec T ⊆ T 0 un ensemble de termes. Le support de α, noté (α),
est défini par :
(α) = { t ∈ T | α(t) 6= t}
Dans la suite, pour deux ensembles A et B, nous notons B A l’ensemble des fonctions de A vers
B, et BA l’ensemble des fonctions de A vers B dont le support est dans Pfini (A).
3.2.2 Opérations sur les ensembles

Soient E et F deux sous-ensembles de T .
Définition 3
La différence symétrique de deux ensembles E et F , notée E∆F , est l’ensemble défini par :
E∆F = (E ∪ F ) \ (E ∩ F )
Proposition 1
Il existe un isomorphisme de groupe ψ entre (Pfini (T ), ∆, ∅) et (( /2 )T , +, 0).
Preuve. Soit E ∈ Pfini (T ). La fonction indicatrice de E est la fonction 1E : T → {0, 1} définie

par :
1 si t ∈ E
1E (t) =
0 sinon
Par définition, on a (1E ) = E et E ∈ Pfini (T ), donc 1E ∈ /2 T . Soit ψ : Pfini (T ) →
( /2 )T qui associe à E la fonction 1E . Il est immédiat que ψ est un isomorphisme de groupe de
(Pfini (T ), ∆, ∅) vers (( /2 )T , +, 0).
3.3. Termes 27
3.2.3 Multi-ensembles
Définition 4 (Multi-ensemble)
Un multi-ensemble M sur T est une fonction de T vers . Le support de M, noté (M), est
l’ensemble :
(M) = { t ∈ T | M(t) > 0}
Un multi-ensemble est fini si son support est de cardinal fini.
Définition 5 (Opérations sur les multi-ensembles)

Si M et N sont deux multi-ensembles, on définit :
– l’addition de M et N :
∀t ∈ T, (M + N )(t) = M(t) + N (t)
– la soustraction de N à M :

M(t) − N (t) si M(t) ≥ N (t)
∀t ∈ T, (M − N )(t) =
0 sinon
Nous utilisons les multi-ensembles pour modéliser le chiffrement de type RSA. La soustraction
de multi-ensembles sera définie dans ce cadre sera définie en fonction de l’opérateur −1 .
3.2.4 Multi-ensembles généralisés

Définition 6 (Multi-ensemble généralisé)
Un multi-ensemble généralisé M sur T est une fonction de T vers . Le support de M, noté
(M), est l’ensemble :
(M) = { t ∈ T | M(t) 6= 0}
Un multi-ensemble généralisé est fini si son support est de cardinal fini.
Définition 7 (Opérations sur les multi-ensembles généralisés)

Si M et N sont deux multi-ensembles généralisés, on définit :
– l’addition de M et N :
∀t ∈ T, (M + N )(t) = M(t) + N (t)
– la soustraction de N à M :
∀t ∈ T, (M − N )(t) = M(t) − N (t)
Les multi-ensembles généralisés seront utilisés pour modéliser les exposants d’une exponentielle.
3.3 Termes
3.3.1 Introduction
3.3.1.i Les messages comme suite d’opérations
Le but de cette section est de parvenir à décrire les messages échangés durant l’exécution d’un
protocole cryptographique. Ces messages sont construits à partir de valeurs de base (une adresse, un
nom, une date,...) en utilisant les opérations (concaténation, chiffrement,...) décrites au chapitre 2,
section 2.2. La possibilité la plus simple, pour représenter ces messages, serait de les définir par la
suite d’opérations aboutissant à leur création. Par exemple, un message construit en faisant le ou
exclusif bit à bit de deux sous-messages a et b, puis en faisant un ou exclusif bit à bit du résultat
avec un sous message c, pourrait être décrit par l’expression :
⊕(⊕(a, b), c)
En nommant signature F l’ensemble des opérations autorisées et des messages élémentaires,

cette représentation est un terme sur F au sens défini dans la sous-section 3.3.2. La définition 9
est cependant trop générale. En utilisant le symbole −1 pour représenter la clef privée associée à
−1
une clef publique, elle autorise des messages de la forme t−1 , qui pourraient être compris comme
« la clef privée associée à la clef privée associée à la clef publique t ». Ce cas est explicitement
exclu dans la définition des termes opérations, c’est-à-dire de la représentation de messages par des
termes décrivant la suite d’opérations permettant de les construire. Les termes opérations sur une
signature F sont donc les termes de cette signature représentant des messages valides.
3.3.1.ii Les messages comme valeur

La représentation d’un message comme une suite d’opérations est simple et uniforme, mais ne
prend pas en compte directement le fait que deux messages construits différemment peuvent ne
pas pouvoir être distingués. Par exemple, par définition de l’opération de ou exclusif bit à bit, il
n’est pas possible de distinguer les messages ⊕(⊕(a, b), c) et ⊕(a, ⊕(b, c)). Outre le fait que certains
protocoles sont basés sur ce type d’égalité (protocole RSA d’échange de secret, protocole W. Dif-
fie-M. Hellman de construction de clef,...), il est nécessaire, dans le cadre de la recherche de faille,
de supposer qu’un individu hostile tentera d’utiliser ces propriétés pour acquérir un secret ou se
faire passer pour un autre.
Une manière classique de traiter ce problème est de raisonner modulo une théorie équationnelle.
Une théorie équationnelle définit des classes d’équivalence sur des termes, deux termes dans la même
classe étant supposés être de même valeur. Le raisonnement se fait alors non plus sur un terme
t, mais sur l’ensemble des termes dans la même classe que t. La théorie équationnelle considérée
dans ce travail est définie dans la sous-section 3.3.4. Dans cette théorie, les classes sont de cardinal
infini, donc il n’est pas question de considérer explicitement tous les termes opérations équivalents.
Raisonner sur les termes opérations impose donc de prévoir un mécanisme pour prendre en compte
toutes les déductions possibles sur les membres d’une classe.
L’approche choisie, dans le cadre de cette thèse, est de considérer un représentant d’une classe de
terme. Afin de simplifier l’écriture, nous autoriserons les arguments d’un tel représentant à ne plus
être uniquement des termes, mais à pouvoir être des ensembles ou des multi-ensembles de termes.
Ces termes, définis en 3.3.5, représentent une classe modulo une théorie équationnelle, et sont
appelés des termes valeurs. Nous définissons sur ces termes valeurs une fonction de normalisation
permettant d’assurer l’unicité d’un représentant d’une classe de termes opérations.
3.3.2 Généralités
3.3.2.i Signature et termes standards
Rappelons la définition d’un signature.
Définition 8 (Signature)
Une signature est un couple (A, α) avec A un ensemble de symboles, et α : A → ∪ {∗} une
fonction d’arité.
Un symbole a ∈ A est une constante si α(a) = 0. Un symbole a est d’arité variable si α(a) = ∗.
Si a est un symbole d’arité non nulle, on note aussi :
a( , . . . , )
| {z }
α(a) fois
où α(a) n’est pas précisé pour les symboles d’arité variable. Cette notation permet d’écrire de
manière concise une signature comme un ensemble de symboles. Par exemple, l’ensemble {a( , ), b}
désigne la signature ({a, b} , {a 7→ 2, b 7→ 0}). Les signatures sont notées par le symbole F accom-
pagné des décorations habituelles.
Définition 9 ( Termes standards sur une signature) Soit F = (A, α) une signature. L’ensemble
T (F) des termes standards sur la signature F est le plus petit ensemble contenant {a ∈ A | α(a) = 0}
et tel que
3.3. Termes 29
Si t1 , . . . , tn ∈ T (F) et si α(a) = n ou α(n) = ∗, alors a(t1 , . . . , tn ) appartient

à T (F).
L’ensemble T (F) des termes standards sur une signature F est aussi appelé Univers de Her-
brand de cette signature. Cet ensemble contient cependant des termes ne représentant pas de
messages. Aussi, après avoir défini la notion de sous-terme (en 3.3.2.ii), nous définirons la signature
0
Fproto contenant les symboles d’arité non nulle utilisés pour construire les messages, et le sous-
ensemble T0 ( 0Fproto ) de T ( 0Fproto ) contenant les termes représentant les messages d’après leur
construction.
3.3.2.ii Sous-terme d’un terme

Définition 10 (Ensemble des sous-termes)
Soit F une signature, et t ∈ T (F). L’ensemble des sous-termes de t, noté (t), est défini pour
t = f (t1 , . . . , tn ) par :
n
[
(t) = {t} ∪ (ti )
i=1
Un sous-terme de t est un élément de (t). Si n = 0, t est une constante, et (t) = {t}.

Sinon, par exemple, l’ensemble des sous-termes de f (a, f (a, b)) est :
(f (a, f (a, b))) = {f (a, f (a, b)), a, f (a, b), b}
3.3.2.iii Position dans un terme

Pour exprimer plus efficacement les sous-termes et les substitutions, nous définissons une notion
de position dans un terme. Un terme peut être représenté graphiquement par un arbre. Une position
indique un nœud d’un tel arbre. Elle est définie par une suite (éventuellement vide) d’entiers
naturels i1 · . . . · in où, partant de la racine du terme (à la position , la suite vide) chaque ij
représente la branche à emprunter pour passer du j-ème sommet au j + 1-ème sommet.
Soit p une position ; nous notons t|p le sous-terme de t en position p. Plus précisément, t| = t
et f (t1 , . . . , tn )|i·p = ti|p . Soient u et t deux termes. Nous notons Pos(u, t) l’ensemble des positions
p de t telles que t|p = u. Enfin, si a est un sous-terme de t, nous notons t = t0 [a].
Un terme t est un f -terme si le symbole à la racine de t est f . C’est un f -terme pur si, pour
chaque position p dans t, t|p est soit un f -terme, soit une constante. Nous dirons que wf [t1 , . . . , tn ]
est une f -partition de t si :
a) wf [a, . . . , a] est un f -terme pur, avec a constante ;
b) pour tout i ∈ {1, . . . , n}, ti n’est pas un f -terme.
3.3.2.iv Remplacement, variable et substitution

Soient a et b deux termes. Nous notons [a ← b] la fonction de remplacement de a par b, et son
application à un terme t est notée t[a ← b]. Si a est sous-terme de t, t[a ← b] est le terme dans
lequel toutes les occurrences du terme a ont été remplacées par le terme b.
Nous notons X un sous-ensemble des constantes appelé ensemble des variables. Une substitution
est définie par la composition des remplacements [a1 ← b1 ], . . . , [an ← bn ] sous les conditions :
∀i ∈ {1, . . . , n} , ai ∈ X (3.1)
∀i, j ∈ {1, . . . , n} , ai = bi ∨ ai ∈
/ (bj ) (3.2)
La première condition indique qu’une substitution est une fonction des variables X vers les
termes, égale à l’identité sur X \ {a1 , . . . , an }. La seconde condition implique :
a) si σ est une substitution et t un terme, alors (tσ)σ = tσ ;
b) l’ordre d’application des remplacements [ai ← bi ] n’affecte pas la valeur du résultat.
Le support d’une substitution σ est l’ensemble {x ∈ X | xσ 6= x}. Une substitution σ = ([ai ←
bi ])i∈{1,...,n} est close si (∪ni=1 (bi )) ∩ X = ∅.
3.3.3 Termes opérations, 0 Fproto et T0 (0 Fproto )

3.3.3.i Signature 0 Fproto décrivant les opérations permises
Dans le cadre de l’étude des protocoles cryptographiques, nous considérons une signature
0
Fproto dont l’ensemble des symboles d’arité non nulle est :
s s,ebc s,cbc p
{ 0h , i, 0{ } , 0 { , . . . , } , 0{ ,..., } , 0{ } ,
0 p,rsa 0 0 + 0 − 0
{} , H( , ), Exp ( , ), Exp ( , ), ⊕ ( , ), −1 }
Ces différents symboles correspondent aux opérations suivantes :
0
h , i : concaténation de deux messages ;
0 s
{ } : création d’un nouveau message par un algorithme de chiffrement symétrique parfait à
partir du premier argument par la clef donnée en deuxième argument ;
0 s,ebc
{} : idem, en supposant cette fois que le chiffrement est fait par bloc (voir chapitre 2,
paragraphe 2.1.2.i pour plus de détail). Nous supposons qu’il y a toujours au moins n ≥ 2
arguments. Le dernier est la clef utilisée pour le chiffrement, et les n−1 premiers correspondent
aux blocs ;
0 s,cbc
{} : idem, en supposant cette fois que le chiffrement est fait par bloc en mode chaı̂né
(voir chapitre 2, paragraphe 2.1.2.ii pour plus de détail) ;
0 p
{ } : création d’un nouveau message par un algorithme de chiffrement asymétrique parfait à
partir du premier argument par la clef donnée en deuxième argument ;
0 p,rsa
{} : idem, en supposant cette fois que le chiffrement est de type RSA (voir chapitre 2,
paragraphe 2.2.1.v pour plus de détail) ;
−1
: clef privée associée à la clef publique donnée en premier argument ;
0
H( , ) : création d’un nouveau message comme valeur par la fonction d’adressage dispersé
donnée en premier argument du message donné en second argument. La fonction est a priori
un terme quelconque ;
0
Exp+ ( , ), 0Exp− ( , ) : création d’un nouveau message en calculant, après interprétation en
tant qu’entier, le premier argument à la puissance le deuxième pour 0Exp+ ( , ), ou le pre-
mier argument à la puissance de l’inverse du deuxième pour 0Exp− ( , ) (voir le chapitre 2,
paragraphe 2.2.2.iii pour plus de détails). Si le contexte ne justifie pas de faire la distinction
entre 0Exp− ( , ) et 0Exp+ ( , ), nous noterons l’opérateur simplement 0Exp( , ) ;
0
⊕ ( , ) : création d’un nouveau message en calculant le ou exclusif bit à bit des deux messages
donnés en argument.
L’exposant 0 permet de différencier un symbole de 0Fproto , utilisé pour construire des termes
opérations, du symbole correspondant de Fproto , utilisé pour construire des termes valeurs. La
distinction s’impose car les symboles n’ont pas la même arité.
3.3.3.ii Termes opérations

Nous définissons dans cette partie un ensemble T0 ( 0Fproto ) de termes opérations qui modélise
tous les messages pouvant être obtenus en un nombre fini d’opérations à partir d’un certain nombre
de messages de base, les constantes.
Définition 11 (Terme opération)

Soit S ⊆ 0Fproto . L’ensemble des termes opérations sur S, noté T0 (S), est l’ensemble :
n −1
o
t ∈ T (S) | ∀u, v ∈ (t), u 6= v −1
3.3.4 Théorie équationnelle sur les messages

Parmi les opérations permettant de construire des messages, quatre permettent d’obtenir des
messages de même valeur à partir de suites d’opérations différentes. Ce sont la concaténation, le
ou exclusif, l’exponentiation et le chiffrement de type RSA. Dans le cadre de cette thèse, nous
ne prenons pas en compte les propriétés de la concaténation, car celles-ci soulèvent de nombreux
et difficiles problèmes théoriques. Nous considérons donc, sur les termes opérations, une théorie
équationnelle Θproto formée de l’union des théories pour le ou exclusif (Θxor ), l’exponentielle (Θexp )
3.3. Termes 31
et le chiffrement de type RSA (ΘRSA ). Ces théories sont définies par des relations d’équivalences
entre termes opérations, notées ≡Θproto (resp. ≡Θxor , ≡Θexp et ≡ΘRSA ).
Remarque : un opérateur associatif aurait forcé à résoudre des équations sur des mots
lors de la recherche d’attaques sur un protocole. Ces équations ont en général un nombre
infini de solutions plus générales, et s’il est conjecturé que trouver la solution la plus
courte d’une équation de mots est dans NPTIME par W. Plandowski et W. Rytter [86],
et montré que le problème de la satisfaisabilité est dans PSPACE par Plandowski [85],
l’algorithme proposé ne semble pas raisonnable à utiliser. Pour une équation a = b,
il consiste essentiellement à deviner une représentation compressée z (resp. z 0 ) d’une
instance de a (resp. de b), et à chercher si z et z 0 représentent le même mot.
3.3.4.i Théorie du ou exclusif bit à bit

Le résultat d’applications successives du ou exclusif bit à bit (ou xor ) ne dépend ni de l’ordre
d’application, ni de la décomposition en applications deux à deux. La première propriété est tra-
duite en disant que c’est un opérateur commutatif, et la seconde en disant que c’est un opérateur
associatif. Formellement, pour tous les termes opérations a, b et c :
0 0
⊕ (a, b) =Θxor ⊕ (b, a) (3.3)
0 0 0
⊕ (a, ⊕ (b, c)) =Θxor ⊕ ( 0 ⊕ (a, b), c) (3.4)
De plus, il existe une constante 0 telle que, pour tous les termes opérations a, on a :
0
⊕ (a, a) =Θxor 0 (3.5)
0
⊕ (a, 0) =Θxor a (3.6)
Pour deux termes opérations a et b, on note a ↔Θxor b s’il existe un sous-terme a1 de a et b1
de b tels que :
– a1 =Θxor b1 ;
– a = t[a1 ] et b = t[b1 ].
Il est évident que ↔Θxor est une relation réflexive et symétrique.
3.3.4.ii Théorie du chiffrement de type RSA

Rappelons (voir chapitre 2, paragraphe 2.2.1.v) que dans le chiffrement de type RSA :
– le chiffrement est commutatif ;
– chiffrer par une clef puis par la clef inverse revient à ne pas chiffrer.
Les équations de cette théorie, pour tous les termes opérations a, b et c, sont :
0
0 p,rsa p,rsa 0
0 p,rsa p,rsa
{a}b c
=ΘRSA {a}c b
(3.7)
0 0
p,rsa p,rsa
{a}b b−1
=ΘRSA a (3.8)
Pour deux termes opérations a et b, nous notons a ↔ΘRSA b s’il existe un sous-terme a1 de a et
b1 de b tels que :
– a1 =ΘRSA b1 ;
– on a a = t[a1 ] et b = t[b1 ].
Il est évident que ↔ΘRSA est une relation réflexive et symétrique.
3.3.4.iii Théorie de l’exponentiation

Les propriétés de l’exponentiation sont bien connues, mais il n’est pas possible de toutes les
considérer. En effet, dans une théorie complète de l’exponentielle, le problème de la recherche
d’attaques sur un protocole, même avec un nombre fini de participants, deviendrait indécidable.
Les sous-théories permettant de pouvoir décider l’égalité entre deux termes sont décrites dans [76].
Dans le cadre de cette thèse, nous considérons uniquement les propriétés suivantes :
– l’exponentiation est commutative ;

– l’exponentiation par un terme puis par son inverse revient à ne pas exponentier.
Les équations de cette théorie, pour tous les termes opérations a, b et c, sont :
0
Exp( 0 Exp(a, b), c) =Θexp 0
Exp( 0 Exp(a, c), b) (3.9)
0 − 0 +
Exp ( Exp (a, b), b) =Θexp a (3.10)
Les opérateurs 0Exp− ( , ) et 0Exp+ ( , ) ne sont pas distingués dans la première équation.
Pour deux termes opérations a et b, nous notons a ↔Θexp b s’il existe un sous-terme a1 de a et b1
de b tels que :
– a1 =Θexp b1 ;
– en remplaçant a1 par b1 dans a, on obtient b.
Il est évident que ↔Θexp est une relation réflexive et symétrique.
3.3.4.iv Relation d’équivalence sur les termes
Nous notons ↔proto =(↔Θxor ∪ ↔ΘRSA ∪ ↔Θexp ) la relation entre termes opérations telle que
pour tous les termes a et b, on a a ↔proto b si, et seulement si, on a a ↔Θxor b ou a ↔ΘRSA b ou
a ↔Θexp b.
Enfin, nous notons ≡Θproto (resp. ≡Θxor , ≡ΘRSA , ≡Θexp ) la clôture transitive de ↔proto (resp.
↔Θxor , ↔ΘRSA , ↔Θexp ).
3.3.5 Ensemble des termes valeurs, Fproto et T(Fproto )

En section 3.3.3, nous avons défini une représentation des messages associant à chaque message
son algorithme de construction sous la forme d’un terme opération. Cette représentation n’est pas
satisfaisante, car des messages construits différemment pouvent avoir la même valeur. Par exemple,
pour un algorithme de chiffrement de type RSA (voir chapitre 2, paragraphe 2.2.1.v) on a, pour
des constantes ka, kb et m :
n op,rsa n op,rsa
0 0 0 p,rsa p,rsa 0 0 0 p,rsa p,rsa
{m}kb ka
↔ΘRSA {m}kb kb−1
kb−1 ka
0 p,rsa
↔ΘRSA {m}ka
Cette égalité est utilisée dans la définition du protocole RSA d’échange de secret, et doit donc
être prise en compte. Dans cette section, on définit inductivement un ensemble T(Fproto ) de termes
valeurs, ainsi qu’une relation Rψ entre termes opérations et termes valeurs. Pour décrire ces termes
valeurs, on utilise les mêmes symboles qu’en section 3.3.3, l’indice 0 en moins, et on ne différencie
pas Exp− ( , ) et Exp+ ( , ). Nous montrons par induction que le terme valeur tv associé à un terme
opération to est défini de manière non ambiguë. La relation Rψ sera donc une fonction ψ. Nous
prouverons enfin, dans la section 3.4.2.ii, que deux termes opérations ayant la même image par ψ
sont dans la même classe d’équivalence.
3.3.5.i Constantes
Tout symbole d’arité 0 est une valeur. Deux constantes différentes correspondent à 2 valeurs
différentes. Suppose qu’en plus des constantes définies dans la signature, il y ait deux constantes 0
et 1 dont la valeur est fixée. Ces valeurs seront représentées par un ensemble vide (cas du 0 pour
l’opérateur ⊕({ })) ou un multi-ensemble généralisé de support vide (cas du 1 pour l’opérateur
Exp( , )). Nous définissons Rψ , sur les constantes, comme égale à la fonction identité.
3.3. Termes 33
3.3.5.ii Opérateurs libres Fl

Posons : n o
p −1 s s,ebc s,cbc
Fl = h , i , { } , ,{ } ,{ } ,{ } , H( , )
Ces symboles sont dits libres car, pour des termes valeurs a, a0 , b, b0 , on a :
f (a1 , ..., an ) ≡Θproto f 0 (b1 , . . . , bm ) implique n = m, pour tout i ∈ {1, . . . , n} , ai ≡Θproto
bi , et f = f 0 , pour f, f 0 ∈ Fl \ −1

Enfin, pour l’opérateur −1 , on impose que t−1 est un terme valeur si, et seulement si, il n’existe
pas de terme valeur u tel que t = u−1 .
Soit 0 f (a1 , . . . , an ) un terme opération, avec 0f ∈ 0Fl . Par induction, supposons que Rψ soit
une fonction ψ sur a1 , . . . , an . Rψ est alors étendue sur 0 f (a1 , . . . , an ) par :
0
f (a1 , . . . , an ) Rψ f (ψ(a1 ), . . . , ψ(an ))
Le symbole 0f étant donné, f est unique, donc :
ψ( 0 f (a1 , . . . , an )) = f (ψ(a1 ), . . . , ψ(an ))
p,rsa
3.3.5.iii Opérateur { }
Nous cherchons à modéliser l’égalité des valeurs ≡ΘRSA pour un algorithme de chiffrement
asymétrique commutatif et pour lequel les algorithmes de chiffrement et de déchiffrement sont
p,rsa
identiques. Soit m un terme qui n’est pas de la forme {a}b 0 , et soit :
n p,rsa o
p,rsa
E(m) = t ∈ T0 (F0 ) | ∃t1 , . . . , tn ∈ T0 (F0 ), t = . . . {m}t1 . . . t
n
Proposition 2
Soit T 0 = T0 (F0 ) \ t−1 | t ∈ T(F0 ) . Il existe une bijection ψ entre E(m)/≡ΘRSA et

T0.
Preuve. Pour cela, pour t ∈ T 0 , soit ϕt : T0 (F0 ) → définie par :


 1 si u = t
ϕt (u) = −1 si u = t−1
0 sinon

Le support de ϕt est t, t−1 , donc ϕt est dans pour tout t ∈ T 0 .

T0
ψ: E(m)/≡ΘRSA → T0
p,rsa p,rsa
. . . {m}t1 . . . t 7→ Σni=1 ϕti
n
Pour que ψ soit bien définie, il faut que les images des éléments d’une classe coı̈ncident. Suppo-
sons que m, t1 , . . . , tn , t01 , . . . , t0m sont des représentants canoniques de classes d’équivalences pour
≡Θproto , et que :
p,rsa n op,rsa
0 p,rsa p,rsa
. . . 0 {m}t1 0
. . . 0 {m}t0 . . . 0

... t ↔ΘRSA
n 1 tm
Soient M et M0 les multi-ensembles {t1 , . . . , tn } et {t1 , . . . , tm }. Par définition de =ΘRSA , et pour

tout terme opération t 6= u−1 :
M(t) − M(t−1 ) = M0 (t) − M0 (t−1 )

Cette définition posée, il est possible de vérifier que deux éléments de T0 (F0 ) sont dans la même
classe si et seulement si leur image par ψ est égale, et donc que ψ est une bijection.
Cette proposition servira à montrer que ψ respecte les classes d’équivalence.

La fonction ψ de la proposition 2 servira à définir la représentation d’une classe d’équivalence
pour ≡ΘRSA par un terme valeur.
Une possibilité de modélisation des valeurs obtenues par un chiffrement par un opérateur de
p,rsa
chiffrement de type RSA serait un opérateur { } ayant comme premier argument le message
à chiffrer, et comme deuxième argument le multi-ensemble généralisé des clefs utilisées pour le
chiffrement. Cependant, pour garder la notation k −1 pour la clef privée liée à la clef publique k,
p,rsa
nous modélisons un algorithme de chiffrement de type RSA par un opérateur { } dont :
– le premier argument est un terme valeur ;
– le second argument est un multi-ensemble M de termes valeurs.
p,rsa
Montrons maintenant que pour un 0{ } -terme to , il existe un seul terme valeur tv tel que
to Rψ tv . Soit :
0 p,rsa p,rsa
. . . 0 {m}t1

to = ... t
n
Par induction, il existe une fonction ψ telle que :

∀i ∈ {1, . . . , n} , ti Rψ ψ(ti )
mRψ ψ(m)
Le multi-ensemble des ψ(ti ), i ∈ {1, . . . , n} comptés avec multiplicité est unique, et ψ(m) est
unique. Donc tv est unique, et on peut noter tv = ψ(to ).
3.3.5.iv Opérateur Exp( , )

Les propriétés algébriques de l’exponentielle sont exactement les mêmes que celles d’un algo-
rithme de chiffrement de type RSA. L’opérateur −1 ne joue pas de rôle particulier dans l’exposant.
Nous modélisons donc les propriétés de l’exponentielle directement par un opérateur Exp( , ) dont :
– le premier argument est un terme valeur, servant de base à l’exponentielle ;
– le second argument est un multi-ensemble généralisé de termes valeurs.
Dans le cas de l’opérateur 0Exp( , ), la constante 1 est l’élément neutre dans l’exposant. Pour
tout m, on a :
0
Exp(m, 1) =Θexp m
p,rsa
L’unicité de l’image se montre de la même manière que pour l’opérateur 0{ } .
3.3.5.v Opérateur ⊕({ })

Soit t un 0 ⊕ -terme, et w0 ⊕ [t1 , . . . , tn ] une 0 ⊕ -partition de t. Sans perte de généralité, on
suppose que les ti (i ∈ {1, . . . , n}) sont donnés avec multiplicité : si |Pos(t1 , t)| = k, t1 apparaı̂t k
fois dans la suite t1 , . . . , tn . Avec ces notations, on a :
Proposition 3 a) w0 ⊕ [t1 , t2 , . . . , tn ] ≡Θxor w0 ⊕ [t2 , t1 , . . . , tn ] ;

b) w0 ⊕ [t1 , . . . , tn−1 , tn ] ≡Θxor w0 ⊕ [tn , t1 , . . . , tn−1 ].
0
Preuve. a) il suffit d’utiliser la commutativité sur le sous-terme ⊕ le plus à gauche dans
w0 ⊕ ;
b) en utilisant l’associativité, il est possible de trouver un 0
⊕ -terme pur w00 ⊕ tel que :
w0 ⊕ [t1 , t2 , . . . , tn ] ≡Θxor 0
⊕ (w00 ⊕ [t1 , . . . , tn−1 ], tn )
=Θxor 0
⊕ (tn , w00 ⊕ [t1 , . . . , tn−1 ])
En utilisant l’associativité, il est possible de faire descendre tn , et ainsi de montrer le point

b.

3.4. Normalisation des termes valeurs 35
La proposition 3 implique que pour toute permutation σ de {1, . . . , n},
w0 ⊕ [t1 , . . . , tn ] ≡Θxor w0 ⊕ [tσ(1) , . . . , tσ(n) ]
En reprenant les mêmes notations, notons Gt le multi-ensemble des termes t1 , . . . , tn d’une

partition de t. Pour deux 0 ⊕ -termes r et s, on a Gr = Gs implique r ≡Θxor s. D’autre part, d’après
les équations 3.5, la condition plus faible Gr = Gs mod 2 implique r ≡Θxor s. Il suffit donc
de représenter t1 , . . . , tn par le sous-ensemble du support du multi-ensemble {t1 , . . . , tn } formé des
termes t 6= 0 dont le nombre d’occurrences est impair. La proposition 1 donne alors un isomorphisme
entre l’addition de multi-ensembles modulo 2 et la différence symétrique d’ensembles. Elle implique
donc, entre autres, ⊕({⊕(E), ⊕(F )}) ≡Θxor ⊕ (E∆F ).
Soit to un 0⊕-terme opération. Pour modéliser les valeurs obtenues par l’opération de ou exclusif
bit à bit, nous utilisons un opérateur ⊕({ }) prenant comme argument un ensemble de termes
valeurs. L’unicité se montre d’abord avec le multi-ensemble des t1 , . . . , tn de la même manière que
p,rsa
pour l’opérateur 0{ } . L’unicité de ce multi-ensemble implique alors l’unicité de l’ensemble M
tel que to Rψ ⊕ (M ) .
3.3.5.vi Définition de Fproto et T(Fproto )
Nous notons Fproto une signature dont l’ensemble des symboles d’arité non nulle est :
n o
s s,ebc s,cbc p p,rsa −1
h , i,{ } ,{ } ,{ } ,{ } ,{ } , H( , ), Exp( , ), ⊕({ }),
s,ebc s,cbc
Les constructeurs { } et { } sont d’arité variables et ont toujours au moins deux arguments.
Le dernier argument est la clef, et est noté à l’extérieur des accolades.
Définition 12 (termes valeurs)

L’ensemble des termes valeurs sur Fproto , noté T(Fproto ), est l’ensemble des termes qu’il est possible
de construire à partir des règles données dans les sous-sections 3.3.5.i à 3.3.5.v.
3.4 Normalisation des termes valeurs

3.4.1 Fonction de normalisation sur les termes opérations et les termes
valeurs
Nous rappelons que le but de la section 3.3 est de parvenir à associer à chaque valeur pou-
vant être définie dans un protocole cryptographique une représentation basée sur la construction
de cette valeur. L’ensemble des termes valeurs répond partiellement seulement à ce problème,
car la représentation d’une classe de termes opérations n’est pas forcément unique. Par exemple,
p,rsa
les termes valeurs ⊕({m, ⊕({m}), ⊕({m, 0})}), {m}{k,k−1 } , . . .. représentent la même classe de la
relation d’équivalence ≡Θproto .
Dans la suite de cette section, et pour chaque constructeur f ∈ Fproto , nous définissons une
fonction de normalisation p qf dont le support est inclus dans l’ensemble des f -termes. La composée
de ces fonctions de normalisation est notée p q. Un terme t est en forme normale si ptq = t.
3.4.1.i Normalisation des constantes
Les constantes représentent des valeurs de base à partir desquelles les messages sont composés.
Les fonctions de normalisation sont donc définies comme égales à l’identité sur les constantes. Si
c ∈ Fproto est une constante, on a, pour tout f ∈ Fproto :
pcq = pcqf = c
3.4.1.ii Normalisation des constructeurs libres

Nous commençons par définir une première fonction de normalisation p qf sur T(Fproto ). Cette
fonction sert à propager la normalisation aux sous-termes d’un f -terme, avec f constructeur libre
(la liste des constructeurs libres est donnée dans la sous-section 3.3.5, paragraphe 3.3.5.ii.)
– si t = f (a, b), avec f ∈ S ∩ Fl , ptqf = f (paq, pbq) ;
−1
– si t = a−1 , alors ptq = ptq = paq −1 ;
f
– sinon, ptq = t.
3.4.1.iii Normalisation pour l’opérateur ⊕({ })

En vue de définir p qxor sur T(Fproto ), nous définissons les ⊕-facteurs d’un terme t.
Définition 13 (⊕-facteurs)
– Si t = ⊕({t1 , . . . , tn }), alors l’ensemble des ⊕-facteurs de t est :
Facteur⊕ (t) = (∆ni=1 Facteur⊕ (pti q)) \ {0}
– sinon
Facteur⊕ (t) = {ptq}
La notation ∆ni=1 Ei est bien définie, car ∆ est associative et commutative. Nous définissons
maintenant p q sur T(Fproto ).
Définition 14 (p qxor )
Si t ∈ T(Fproto ), alors :
– si t = ⊕({t1 , . . . , tn }),

 ⊕({Facteur⊕ (t)}) si |Facteur⊕ (t)| ≥ 2
ptqxor = u si Facteur⊕ (t) = {u}
0 si Facteur⊕ (t) = ∅

– sinon, ptqxor = t.
3.4.1.iv Normalisation pour l’opérateur Exp( , )

Pour définir p qexp sur T(Fproto ), nous commençons par définir les Exp-facteurs et la Exp-base
d’un terme t.
Définition 15 (Exp-facteurs et Exp-base)

– Exp-facteurs :
– Si t = Exp(b, M), alors l’ensemble des Exp-facteurs de t est :
FacteurExp (t) = pMq + FacteurExp (pbq)
– sinon
FacteurExp (t) = ∅
– Exp-base :
– Si t = Exp(b, M), alors la Exp-base de t est :
BaseExp (t) = BaseExp (pbq)
– sinon
BaseExp (t) = t
Cette définition implique que s’il existe t et u normalisés tels que u = BaseExp (t), alors u n’est
pas un Exp-terme. Un équivalent de la proposition 2 pour l’exponentielle pourra donc être appliqué.
Mais d’abord, choisissons comme fonction de normalisation celle qui envoie un terme t sur le terme
Exp(BaseExp (t), FacteurExp (t)).
Définition 16 (p qexp )
Si t ∈ T(Fproto ), alors :
– si t = Exp(b, M),

exp Exp(BaseExp (t), FacteurExp (t)) si (FacteurExp (t)) 6= ∅
ptq =
BaseExp (t) si (FacteurExp (t)) = ∅
– sinon, ptqexp = t.
p,rsa
3.4.1.v Normalisation pour l’opérateur { }
p,rsa
La fonction de normalisation pour l’opérateur { } est similaire à celle de l’opérateur Exp( , ),
p,rsa p,rsa
et utilise aussi les notions de { } -facteurs et la { } -base d’un terme t.
Addition. L’utilisation de multi-ensembles à la place de multi-ensembles généralisés contraint à

utiliser une fonction spéciale, Add, pour l’addition des multi-ensembles de facteurs. Posons, pour
des multi-ensembles M1 , M2 et M3 :
Add(M1 , M2 ) = M3
si pour tout terme en forme normale t qui n’est pas de la forme u−1 : :
a)
M1 (t) + M2 (t) − (M1 (t−1 ) + M2 (t−1 )) = M3 (t) − M3 (t−1 )
b) soit M3 (t) = 0, soit M3 (t−1 ) = 0.
Opposé. Nous définissons aussi l’opposé d’un multi-ensemble M comme étant le multi-ensemble
M0 tel que Add(M, M0 ) = 0. Nous notons Opp(M) l’opposé d’un multi-ensemble M.
Nous définissons maintenant les facteurs et la base pour un opérateur de chiffrement de type
RSA.
p,rsa p,rsa
Définition 17 ({ } -facteurs et { } -base)
p,rsa
– {} -facteurs :
p,rsa p,rsa
– Si t = {b}M , alors l’ensemble des { } -facteurs de t est :
Facteurrsa (t) = Add(pMq, Facteurrsa (pbq))
– sinon
Facteurrsa (t) = ∅
p,rsa
– {} -base :
p,rsa p,rsa
– Si t = {b}M , alors la { } -base de t est :
Basersa (t) = Basersa (pbq)
– sinon
Basersa (t) = t
Cette définition implique que s’il existe t et u normalisés tels que u = Basersa (t), alors u n’est pas
p,rsa
un { } -terme. La proposition 2 pourra donc être appliquée. Mais d’abord, choisissons comme
p,rsa
fonction de normalisation celle qui envoie un terme t sur le terme {Basersa (t)}Facteurrsa (t) .
Définition 18 (p qrsa )
Si t ∈ T(S), alors :
p,rsa
– si t = {b}M ,
p,rsa
{Basersa (t)}Facteurrsa (t) si (Facteurrsa (t)) 6= ∅
ptqrsa =
Basersa (t) si (Facteurrsa (t)) = ∅
– sinon, ptqrsa = t.
3.4.1.vi Exemple
Prenons comme exemple le terme :
⊕({a, Exp(Exp(⊕({a, c}), {a}), {−a}), c})
et calculons sa forme normale. Tout d’abord, a, c, ⊕({a, c}) et Exp(⊕({a, c}), a) sont en forme
normale. Calculons la forme normale de Exp(Exp(⊕({a, c}), {a}), {−a}). On a :
– BaseExp (Exp(Exp(⊕({a, c}), {a}), {−a})) = ⊕({a, c}) ;
– FacteurExp (Exp(Exp(⊕({a, c}), {a}), {−a})) = {a} + {−a} = 0 ;
On en conclut :
exp
pExp(Exp(⊕({a, c}), {a}), {−a})q = ⊕({a, c})
Les facteurs du terme à normaliser sont donc :
Facteur⊕ (⊕({a, Exp(Exp(⊕({a, c}), {a}), {−a}), c})) = {a} ∆Facteur⊕ (⊕({a, c}))∆ {c}
= {a} ∆ {a, c} ∆ {c}
= ∅
Les sous-termes du terme à normaliser sont tous en forme normale, et l’ensemble des ⊕-facteurs
est vide, donc :
xor
p⊕({a, Exp(Exp(⊕({a, c}), {a}), {−a}), c})q = p⊕({a, Exp(Exp(⊕({a, c}), {a}), {−a}), c})q
= 0
3.4.2 Unicité de la forme normale pour une classe de termes opérations

3.4.2.i Introduction
Pour le reste de cette sous-section, nous notons ψ la fonction qui associe à un terme opération
t un terme valeur tv tel que défini en section 3.3.5.
Nous rappelons que les messages composés à partir des opérations décrites dans le chapitre 2,
section 2.2, et formalisées dans la section 3.3.3 de ce chapitre, peuvent avoir une même valeur.
La notion de valeur identique est formalisée par une relation d’équivalence ≡Θproto sur les termes
opérations. Dans la section 3.3.5 de ce chapitre, nous avons donné une représentation d’une classe
d’équivalence de la relation ≡Θproto . Cette représentation n’est pas unique, et nous avons affirmé
que la fonction de normalisation permettait d’assurer que deux termes opérations t et t0 sont dans
la même classe (t ≡Θproto t0 ) si et seulement si, pψ(t)q = pψ(t0 )q. La situation peut être résumée
par le diagramme 3.1.
ψ p q
t ψ(t) pψ(t)q
≡Θproto =
ψ p q
t0 ψ(t0 ) pψ(t0 )q
Fig. 3.1 – Relation entre termes opérations, termes valeurs et fonction de normalisation
Dans la sous-section 3.4.2.ii, nous montrons que la flèche verticale de droite implique celle de
gauche, et dans la sous-section 3.4.2.iii, nous montrons que la flèche verticale de gauche implique
celle de droite.
3.4.2.ii Unicité de la classe représentée par une forme normale

Lemme 1
ψ(t) = ψ(t0 ) implique t ≡Θproto t0
Preuve. Par construction, ψ(t) = ψ(t0 ) et t f -terme implique t0 f -terme. Montrons par induction
sur les sous-termes que, pour chaque constructeur f et pour tous f -termes t et t0 , ψ(t) = ψ(t0 )
implique t ≡Θproto t0 .
– si f est un constructeur libre ou une constante, t ≡Θproto t0 par définition de ≡Θproto et par
induction sur les sous-termes ;
p,rsa
– si f = 0{ } , soit :
p,rsa p,rsa
t = 0 . . . {m}t1 . . . t

n onp,rsa
0 0 0 p,rsa
t = . . . {m }t0 . . . 0
1 tl
Par définition de ϕ, en notant M1 (resp. M2 ) le multi-ensemble des t1 , . . . , tn (resp. t01 , . . . , t0l )

comptés avec multiplicités, on a :
Add(M1 , −M2 ) = 0
et m = m0 . Par la proposition 2, on a donc t ≡Θproto t0 ;

– le cas de l’opérateur 0Exp( , ) se traite de la même manière, en utilisant l’équivalent de la
proposition 2 pour traiter la simplification 0Exp− ( 0Exp+ (m, a), a) = m ;
– De même, le cas de l’opérateur 0⊕ se traite en utilisant la proposition 3 et une induction sur
les sous-termes.

Lemme 2
Pour tout terme opération t, il existe un terme opération t0 tel que pψ(t)q = ψ(t0 ). On a alors
t ≡Θproto t0 .
Preuve. Tout d’abord, montrons l’existence de t0 par induction sur les sous-termes de ptq. L’exis-
tence est triviale pour les constantes, et est déduite par induction pour les constructeurs libres.
L’utilisation d’ensembles ou de multi-ensembles ne pose pas de problème.
L’implication est alors prouvée en montrant que chaque étape de normalisation préserve l’ap-
partenance à une classe de ≡Θproto , par induction sur les sous-termes de ψ(t).
La proposition suivante se déduit alors du diagramme 3.1 et des lemmes 1 et 2.

Soient deux termes opérations t1 et t2 tels que
pψ(t1 )q = pψ(t2 )q
D’après le lemme 2, il existe un terme opération t0 tel que :
ψ(t0 )

 pψ(t1 )q =
pψ(t0 )q

pψ(t2 )q =

0
 t ≡Θproto t1
t0 ≡Θproto t2


Donc, par transitivité, nous avons la proposition suivante.
Proposition 4
pψ(t)q = pψ(t0 )q implique t ≡Θproto t0
Dans le reste de cette section, nous montrons la réciproque de cette proposition, c’est-à-dire :
t ≡Θproto t0 ⇒ pψ(t)q = pψ(t0 )q

3.4.2.iii Cas de deux termes égaux modulo Θproto
Notons t =Θproto t0 si t = t0 ou t =ΘRSA t0 ou t =exp t0 ou t =Θxor t0 . Le lemme suivant montre

que t =Θproto t0 implique ψ(t) = ψ(t0 ), et donc pψ(t)q = pψ(t0 )q.
Lemme 3
Pour tout t, t0 dans T0 (0 Fproto ), t =Θproto t0 implique ψ(t) = ψ(t0 )
Preuve. La preuve consiste à considérer tous les cas possibles d’égalité, et à montrer que pour
chaque cas, l’égalité de droite est vérifiée.
3.4.2.iv Cas général
Pour montrer que ψ est constante sur chaque classe d’équivalence, la proposition suivante
ramène le problème à celui de deux termes égaux modulo Θproto .
Proposition 5
Pour tout t, t0 dans T0 (0 Fproto ), t ≡Θproto t0 implique pψ(t)q = pψ(t0 )q
Preuve. Par contradiction, supposons qu’il existe deux termes t et t0 de T0 (0 Fproto ) tels que :
t0

t ≡Θproto
pψ(t)q 6= pψ(t0 )q
Par définition, il existe une suite (ti )i∈{0,...,n} de termes telle que :
a) t0 = t et tn = t0 ;
b) ∀i ∈ {1, . . . , n} , ti−1 ↔Θproto ti .
Soit i ∈ {1, . . . , n} minimal tel que :
pψ(ti−1 )q 6= pψ(ti )q
Par minimalité de i, pψ(ti−1 )q = pψ(t0 )q, donc l’hypothèse t ≡Θproto t0 et pψ(t)q 6= pψ(t0 )q
implique qu’il existe deux termes u et v tels que :

u ↔Θproto v
pψ(u)q 6= pψ(v)q
Par définition de ↔Θproto , il existe deux termes a et b tels que :


 u = w0 [a]
v = w0 [b]
a =Θproto b

La fonction de normalisation p q est définie inductivement, donc pψ(u)q 6= pψ(v)q implique

pψ(a)q 6= pψ(b)q. Pour résumer, l’hypothèse initiale implique qu’il existe deux termes a et b
tels que :

a =Θproto b
pψ(a)q 6= pψ(b)q
Cela est impossible par le lemme 3, ce qui prouve la proposition.

3.5. Représentation des termes valeurs et opérations de base 41
3.4.2.v Conclusion
Nous venons de démontrer le théorème suivant :
Théorème 1
pψ(t)q = pψ(t0 )q si, et seulement si, t ≡Θproto t0 .
En d’autres termes, il existe une bijection ϕ = p q ◦ ψ de T0 ( 0Fproto )/ ≡Θproto vers l’ensemble

des termes en forme normale de T(Fproto ). Donc raisonner modulo la théorie Θproto sur les termes
de T0 ( 0Fproto ) est équivalent à raisonner sur les termes en forme normale de T(Fproto ). Nous
utilisons ce résultat de la façon suivante :
Dans la suite de ce document, nous considérerons toujours des

termes valeurs en forme normale.
3.5 Représentation des termes valeurs et opérations de base

3.5.1 Introduction
Nous nous intéressons à la complexité de problèmes liés à l’étude de protocoles cryptographiques.
Ces problèmes s’énoncent et se résolvent souvent en considérant des termes valeurs ou des ensembles
de termes valeurs. Pour connaı̂tre la complexité d’un tel problème, il est donc nécessaire de connaı̂tre
la complexité d’opérations de base, telles que savoir si deux termes valeurs en forme normale sont
égaux, savoir si un terme appartient à un ensemble de termes, etc.
Dans cette section, nous décrivons une représentation possible des termes et ensembles de termes
(sous-section) 3.5.3). Nous nous intéressons aussi, dans cette section, à la taille d’une représentation
d’un terme ou d’un ensemble de termes. Cette taille servira de paramètre pour exprimer la com-
plexité des opérations sur les termes et ensembles de termes (sous-section 3.5.4).
3.5.2 Graphes
Nous considérons que les termes valeurs sont représentés par des graphes finis.
Définition 19 (Graphes)
Un graphe G est un couple (V, E) où V est un ensemble fini, et E une relation sur V . Les éléments
de E sont nommés des sommets. Pour v et v 0 dans V , si vEv 0 , nous disons que le couple (v, v 0 )
est une arête de G.
Si dans un graphe (V, E) la relation E est symétrique, nous disons que le graphe est non-orienté.
Sinon, le graphe est dit orienté. Dans un graphe orienté, un sommet v est le fils d’un sommet s0
s’il existe une arête (v 0 , v). Un graphe (V, E) est un arbre s’il existe un sommet de V qui n’est le
fils d’aucun autre, et si tous les autres sommets v sont fils d’exactement un sommet.
Définition 20 (Graphes avec labels)

Un triplet G = (V, E, ϕ) est un graphe avec labels dans A si G0 = (V, E) est un graphe et si ϕ est
une fonction de l’ensemble des arêtes de G0 vers A.
Une classe particulièrement importante de graphes pour représenter les termes est celle des
graphes orientés acyclique (dag, acronyme anglais de Directed Acyclic Graph).
Définition 21 (Graphes acycliques)

Un graphe G = (V, E) est acyclique s’il n’existe pas de suite v1 , . . . , vn d’éléments de V telle que :
– pour tout i ∈ {1, . . . , n − 1}, le couple (vi , vi+1 ) est une arête de G ;
– vn = v1 .
Pour représenter des termes valeurs, nous utilisons des graphes orientés acycliques avec labels
dans . Étant donné un terme valeur t, nous construisons le graphe ( (t), E), où E est la relation
de sous-terme strict maximal. Les labels servent à coder soit la position d’un sous-terme dans les
arguments d’un opérateur, soit la valeur d’un terme par un multi-ensemble ou un multi-ensemble
généralisé. Nous détaillons dans la sous-section 3.5.3 cette représentation, et donnons la complexité
d’opérations simples sur les termes dans la sous-section 3.5.4.
3.5.3 Représentations et taille des problèmes

3.5.3.i Introduction
Les termes sont souvent représentés par des arbres dont les feuilles sont des constantes et les
p
sommets des constructeurs. Par exemple, le terme {ha, ha, bii}c peut être représenté par l’arbre
de la figure 3.2. Dans cette représentation, on suppose implicitement qu’il existe un mécanisme
permettant de distinguer les deux arêtes sortantes.
p
{}
h, i c
a h, i
a b
p
Fig. 3.2 – Représentation du terme {ha, ha, bii}c par un arbre
L’inconvénient de cette représentation est que de l’information est dupliquée : dans la figure 3.2,
la constante a est dupliquée. Afin d’éviter cette duplication, une représentation alternative du terme
est d’utiliser un graphe orienté acyclique (DAG). Cette représentation permet d’associer à chaque
sous-terme d’un terme un seul sommet d’un graphe. En reprenant l’exemple précédent, le terme
p
{ha, ha, bii}c peut être représenté par le DAG de la figure 3.3.
p
{}
h, i c
h, i
a b
p
Fig. 3.3 – Représentation du terme {ha, ha, bii}c par un graphe orienté acyclique (DAG)
Pour un terme opération t, un graphe acyclique orienté Gt est une représentation graphique de
la relation Rsub de sous-terme direct sur (t) :
Et = {(s, s0 ) ∈ (t) | s Rsub s0 }

avec, pour tout s, s0 ∈ (t),

0 0 0 0 s = f (a1 , . . . , an )
s Risub s ⇐⇒ ∃ f ∈ Fproto , ∃ a1 , . . . , an ∈ T0 ( Fproto ),
s0 = ai
[
Rsub = Rnsub
n∈ \{0}
Remarquons que la taille d’une telle représentation n’est pas linéaire en le nombre de sous-
termes distincts. Par exemple, considérons le terme :
s,cbc
{}
a a k
n copies de a
Le nombre des sous-termes de ce terme est 3, et est indépendant de n. Cependant, la taille

de la représentation varie en fonction de n. En utilisant une liste de sommets fils, la taille de la
représentation est en O(n). L’espace nécessaire pour représenter un terme est donc différent du
nombre de ses sous-termes.
Définition 22 (Taille dag d’un terme)

Soit t un terme, et Gt la représentation de ce terme par un graphe orienté acyclique. La taille dag
de t, notée |t|dag , est la taille de Gt .
En représentant les fils d’un sommet d’un graphe par une liste de sommets, on a la proposition
suivante.
Proposition 6
Soit t un terme opération, n1 , . . . , nk les arités des opérateurs et constantes de t. Sous ces nota-
tions :
|t|dag = O((k + Σki=1 ni ) · log k)
Preuve. On représente le graphe Gt par une liste de couples (s, l) où s est un sommet, et l la liste
des sommets fils de s. Il y a k sommets dans le graphe, donc chaque sommet peut être représenté
en log k. Donc le sommet i est représenté en O((1 + ni ) · log k).
3.5.3.ii Relations sur l’ensemble des sous-termes d’un terme valeur

La représentation des termes valeurs est plus délicate à mettre en œuvre, car il faut pouvoir
représenter efficacement des ensembles et des multi-ensembles de termes.
Les ensembles. La représentation d’un ensemble peut se faire par une liste de sommets. Sans
perte de généralité, il est possible de supposer que cette liste est de cardinal inférieur ou égal au
nombre total de sommets du graphe.
Multi-ensembles et multi-ensembles généralisés. L’utilisation de listes, pour les multi-

ensembles, n’est pas efficace. Par exemple, le terme :
p,rsa
{}
a ka ka ka ka
est représenté de manière plus succincte par le graphe orienté acyclique avec labels :
0 p,rsa
{}
4
a ka
Il est donc possible de représenter un multi-ensemble (généralisé) M par une liste de couples (s, n),
avec s ∈ (M) et n = M(s).
Taille dag d’un terme valeur. Soit t un terme valeur, k le nombre de sous-termes distincts de
t, m la valeur absolue maximale de l’image d’un terme par un multi-ensemble (généralisé) de t, et
a l’arité maximale d’un opérateur. D’après ce qui précède, on a la proposition suivante.
Proposition 7
Avec les notations précédentes, t peut être représenté en espace O(k 3 · (a + log m)).
Preuve. Un multi-ensemble peut être représenté en O(k · (1 + log m + log k)), un ensemble peut
être représenté en O(k · log k) et une liste peut être représentée en O(a · log k). En utilisant des
marqueurs pour distinguer les ensembles des multi-ensembles et des listes, un terme peut être
représenté en :
O(k 2 · (1 + log m + log k) + k · a · log k)
Soit, pour prendre une écriture plus simple mais moins précise :
O(k 3 · (a + log m))
Un ensemble ou multi-ensemble est considéré comme étant un seul argument. Par exemple,
p,rsa
l’opérateur ⊕({ }) est d’arité 1, et l’opérateur { } est d’arité 2.
3.5.4 Opérations sur les termes et complexité

Un ensemble E de termes peut être représenté par un couple (g, l), où g est un graphe et l est
la liste des sommets du graphe appartenant à E.
3.5.4.i Ordre total sur les termes valeurs et représentation canonique

La représentation d’un terme valeur par un graphe n’est pas unique, car dans le cas d’ensembles
ou de multi-ensembles, l’ordre dans la liste des fils d’un sommet n’affecte pas le terme représenté
par ce sommet. Afin de ne pas avoir à considérer tous les ordres possibles des sommets, nous allons
trier les sommets apparaissant dans les listes représentant des ensembles ou des multi-ensembles.
De cette manière, deux termes seront égaux si, et seulement si, les graphes les représentant sont
identiques.
Pour trier les sommets, nous avons besoin d’une relation d’ordre totale sur les termes valeurs.
Pour cela, on se donne une relation d’ordre >Fproto sur Fproto , arbitraire sur les constantes et sur
les constructeurs d’arité non nulle, et telle que, en notant α(f ) l’arité du symbole f ∈ Fproto , alors
pour tout f, f 0 constructeurs de Fproto , si α(f ) = 0 et α(f 0 ) 6= 0, alors f 0 >Fproto f
D’autre part, la relation Rsub est une relation d’ordre partiel sur les sommets du graphe. Il est
donc possible d’organiser les sommets d’un graphe représentant un terme t en niveaux L0 , . . . , Lk ,
tels que :
a)
∀i ∈ {1, . . . , k} , ∀x ∈ Li , ∃y ∈ Li−1 , xRsub y
b)
∀i ∈ {0, . . . , k} , ∀x, y ∈ Li , ¬(xRsub y ∨ yRsub x)
La première propriété exprime que si un sommet s est au niveau Li , il existe un sommet s0 au

niveau Li−1 tel que s0 représente un sous-terme strict de s. Elle implique que toutes les constantes
sont dans le niveau L0 . La seconde propriété signifie que deux sommets au même niveau sont
incomparables pour Rsub . Elle implique que le niveau L0 ne contient que des constantes.
Il est maintenant possible d’étendre Rsub en un ordre total Fproto sur les sommets, en utilisant
>Fproto et par récurrence sur les niveaux.
Sur L0 . Par la contrainte d’ordonnancement entre les termes et leurs sous-termes, un terme
est dans L0 si et seulement si c’est une constante. Posons O comme étant l’ordre total sur les
constantes. Cet ordre étend bien l’ordre induit par la relation de sous-terme.
Li → Li+1 Supposons qu’il existe un ordre total i sur ∪ij=0 Lj , et étendons le en i+1 sur
∪i+1
j=0 Lj . Tout d’abord, les sommets de Li+1 peuvent être triés en temps O(|Li+1 |) en fonction de
l’ordre >Fproto sur les constructeurs. Le problème se réduit alors au tri de sommets ayant le même
constructeur de tête f . Deux cas sont possibles :
a) si f ∈ Fproto l , l’ordre i est étendu en un ordre total (lexicographique, par exemple) sur les
suites finies de sommets. Cet ordre permet d’ordonner totalement tous les f -termes ;
b) sinon, afin de simplifier le propos, on commence par considérer les ensembles et les multi-
ensembles comme des cas particuliers de multi-ensembles généralisés. En utilisant si nécessaire
un ordre lexicographique sur les arguments, nous nous ramenons au problème de trouver un
ordre total sur des multi-ensembles généralisés. Les éléments de ces multi-ensembles sont
totalement ordonnés par i . Les multi-ensembles peuvent donc être ordonnés par M N
si :
∀x ∈ ∪ij=0 Lj , N (x) > M(x) ⇒ ∃y ∈ ∪ij=0 Lj , y i x et M(y) > N (y)
avec, pour tout n, m ∈ , n > m si |n| > |m| ou |n| = |m| et n > 0 > m. Les ordres > et
i sont totaux, donc l’ordre est total sur les multi-ensembles généralisés, ce qui permet
de conclure.
L’algorithme utilisé pour ordonner totalement les sommets est déterministe et son résultat ne
dépend que de la relation de sous-terme et de l’ordre sur les symboles. Donc son résultat ne dépend
que du terme ou de l’ensemble de termes représenté, et pas du graphe initial. On a donc une
représentation canonique d’un terme ou d’un ensemble de termes. L’algorithme est en PTIME du
nombre d’arêtes.
3.5.5 Insertion d’un terme dans un graphe orienté acyclique

Beaucoup de problèmes qui se posent à nous se ramènent à celui de l’insertion d’un terme t
représenté par un graphe orienté acyclique dans un graphe représentant un ensemble de termes
valeurs V . Par exemple, tester si t0 est un sous-terme de t peut être fait en deux étapes :
1. construire le graphe canonique représentant t, et en déduire une représentation Gt de {t} ;
2. insérer t0 dans Gt . Si un sommet doit être ajouté, alors t0 n’est pas sous-terme de t.
Cette opération est polynomiale. La procédure Insertion, décrite dans la figure 3.4, consiste
à insérer les sous-termes de t les uns après les autres dans l’ordre défini dans la section 3.5.4.i. Si
le terme à insérer n’est pas dans le graphe, alors il faut ajouter un sommet le représentant, et des
arêtes pointant vers ses fils (qui ont déjà été insérés).
La procédure insérer insère dans un graphe G un terme dont tous les sous-termes stricts sont
déjà représentés dans G. Cette procédure est polynomiale, donc le problème d’insertion d’un terme
dans un ensemble peut être résolue en temps polynomiale en la taille de la représentation du terme
et de l’ensemble. D’autre part, l’unicité de la représentation par un graphe implique que le test
d’égalité de deux graphes peut se faire en temps polynomial en la taille de ces graphes.
Les problèmes suivants peuvent être donc être résolus en temps polynomial en la taille des
données en entrée :
– Est-ce que deux termes t et t0 sont égaux ?
– Est-ce que le terme t appartient à l’ensemble E ?
Insertion(Gt , GV ) :
Soit Gt = ((ti )i∈{1,...,n} , At ) et GV = ((vi )i∈{1,...,m} , AE ) les graphes
représentant t et E avec les listes de sommets triées pour l’ordre Fproto
G = GE
Pour i de 1 à n faire
G=insérer(ti , G)
finfaire
Fig. 3.4 – Algorithme d’insertion d’un terme dans un ensemble.
– Est-ce que le terme t est dans (E) ?

La représentation des termes par des graphes orientés acycliques permet d’obtenir une com-
plexité polynomiale en la taille du graphe pour les opérations que nous considérerons dans la suite
de ce document. Nous n’avons pas traité l’unification parmi ces opérations. Lorsque des termes
opérations sont considérés sans théorie équationnelle, la représentation de termes par des graphes
orientés acycliques permet d’obtenir un algorithme polynomial en la taille de la représentation par
un dag de ce terme. Ce résultat sera utilisé dans le chapitre 6.
3.6 Conclusion
Lors de l’analyse d’un protocole, seule la valeur des messages échangés doit être prise en compte
pour définir les actions possibles des acteurs et de l’intrus. Ces valeurs sont définies par une relation
d’équivalence sur les termes. Nous avons donné dans ce chapitre une représentation simple des
classes d’équivalences par des termes valeurs. Cette représentation est non ambiguë si ces termes
valeurs sont en forme normale.
L’écriture de ces termes repose sur l’utilisation d’ensembles et de multi-ensembles. Les opérations
sont donc plus coûteuses que sur des termes opérations, mais nous retiendrons que toutes les
opérations que nous considérerons dans la suite de ce document peuvent être effectuées en un
temps polynomiale en la taille de la représentation d’un terme valeur ou d’un ensemble de termes.
4
Accessibilité dans le cas clos
4.1 Introduction
Ce chapitre peut être divisé en trois parties distinctes. Une première partie générale, tout
d’abord, dans laquelle est introduite la notion de déduction par des règles de réécriture. Une
seconde partie, où nous présentons les règles de réécritures utilisées dans le cadre de l’étude de
protocoles cryptographiques. Enfin, nous présentons d’autres approches possibles.
Tout d’abord, donc, nous considérons des termes sur une signature quelconque, et définissons
des systèmes de réécritures sur des ensembles de termes dans la section 4.2. Une particularité de
ces systèmes est qu’ils n’enlèvent jamais un terme d’un ensemble, ce qui permet de prouver facile-
ment diverses propriétés. Nous considérons ensuite, dans la section 4.3, des systèmes de réécritures
particuliers, que nous appelons canoniques, et dont toute combinaison permet d’avoir un système
de réécriture local. Nous définissons ensuite les problèmes d’accessibilité close dans la section 4.4.
Informellement, un problème d’accessibilité close pour un ensemble de termes E et un terme t
consiste à chercher si il est possible, partant de E, de déduire un ensemble F contenant le terme
t. Nous donnons la complexité de ce problème, dans le cas de systèmes locaux, en fonction de la
complexité du problème consistant à savoir si, étant donnés deux ensembles E et F , il est possible
de passer en faisant une seule déduction de l’un à l’autre.
Ensuite, nous présentons un système de règles de déductions dans le cadre des protocoles cryp-
tographiques dans la section 4.5. Ce système est uniquement basé sur les propriétés des opérations
décrites dans le chapitre 3. Nous montrons, opérateur par opérateur, que le système de déduction
associé à un constructeur f est canonique. Nous en concluons, dans la section 4.6, que les problèmes
d’accessibilité close, dans le cadre des protocoles cryptographiques, sont polynomiaux pour toute
combinaison des systèmes de règles associés aux constructeurs présentés dans le chapitre 3.
Enfin, nous présentons d’autres approches permettant de traiter les problèmes d’accessibilité
close. Nous commençons par présenter le formalisme des règles d’Oracle, qui est le précurseur des
systèmes canoniques, dans la section 4.7. Nous avons utilisé ce formalisme avec beaucoup de succès
pour ajouter un opérateur en sus des opérateurs de chiffrement parfait. Nous expliquons aussi
pourquoi, bien que les systèmes canoniques sont plus restrictifs, nous avons préféré les présenter
dans ce document. Nous présentons enfin, dans la section 4.8, les travaux d’autres auteurs s’étant
intéressés aux problèmes d’accessibilité close.
Dans le cadre de ce chapitre, nous désignons par terme les termes valeurs en forme normale, et
nous notons T(F) = pT(Fproto )q.
Traitement de l’opérateur −1 Lorsque la signature F contient l’opérateur unaire −1 dont le

rôle sera décrit dans la sous-section 4.5.3, on définit une relation d’équivalence ≡ −1 sur les termes
de T(F) :
−1
∀t, t0 ∈ T(F), t ≡ −1 t0 ⇐⇒ (t = t0 ∨ t0 = t−1 ∨ t = t0 )
Nous notons ∈≡ −1 (resp. ⊂≡ −1 ) l’appartenance à un ensemble (resp. l’inclusion dans un
ensemble) dans T(F)/≡ −1 . Par exemple, on a :
−1
a , b ⊂≡ −1 a, b−1 , c

47
48 Chapitre 4. Accessibilité dans le cas clos
4.2 Règles de réécriture sur des ensembles de termes

Soit F une signature, T(F) l’ensemble des termes sur F. Pour E ⊆ T(F) et t ∈ T(F), on note
E, t l’ensemble E ∪ {t} et E \ t l’ensemble E \ {t}.
Définition 23 (Règles de réécriture sur des ensembles)

Une règle de réécriture sur des ensembles est un couple (l, r) avec l ⊂fini T(F) et r ∈ T(F) \ l,
notée l → r.
Dans la suite, les ensembles de règles de réécriture sur des ensembles seront notés R avec les
décorations usuelles. Par abus de langage, on parlera parfois simplement de systèmes de réécriture.
Pour désigner des systèmes utilisés dans le cadre de l’étude de protocoles cryptographiques, nous
emploierons aussi L et les décorations usuelles. Les règles elles-mêmes seront notées R, avec les
décorations habituelles.
Définition 24 (Relation de transition)

Soient E et F deux sous-ensembles finis de T(F), et R un ensemble de règles de réécriture sur des
ensembles. Nous notons E →R F si il existe l → r ∈ R telle que :
1. l ⊆ E
2. F = E, r
La définition de la relation de transition implique que ces règles ne peuvent qu’augmenter la

taille de l’ensemble sur lequel elles sont appliquées. Dans la suite, on utilisera ce type de règles
pour modéliser les déductions possibles à partir d’un ensemble de connaissances. La croissance
pour l’inclusion des ensembles correspond alors au fait que les connaissances déduites ne sont
jamais oubliées.
Étant donné un système R, on note aussi E ↔R F si E →R F ou E ←R F , et →∗R (respective-
ment ≡R ) la clôture réflexive et transitive de →R (respectivement ↔R ). Si R = {R}, nous notons
E →R F (resp. E ↔R F et E ←R F ) la relation E →{R} F (resp. E ↔{R} F et E ←{R} F ).
Proposition 8 (Confluence)
E
∗ ∗
E1 E2
∗∗
F
Dans ce schéma, les flèches continues représentent les hypothèses, et les flèches discontinues
représentent la conclusion.
Preuve. Si D1 : E →d1 . . . →dk E1 et D2 : E →d01 . . . →d0l E2 , on remarque que les concaténations
D = D1 D2 et D0 = D2 D1 sont aussi des suites de transitions par croissance des ensembles, et
qu’elles aboutissent au même ensemble F .
Proposition 9 (Church-Rosser)
Pour tout système de réécriture sur des ensembles R, si E ≡R F , alors il existe E 0 tel que E →∗R E 0
et F →∗R E 0 .
Il s’agit de l’analogue de la propriété de Church-Rosser pour les systèmes de réécriture sur des
termes. Elle peut être décrite par la figure 4.1 :
La preuve est basée sur la proposition 8.
Preuve. Par hypothèse, on a :
E = E0 ←∗R E1 →∗R E2 . . . →∗R En = F
et par la proposition 8, on peut remplacer E0 ←∗R E1 →∗R E2 par E0 →∗R E10 ←∗R E2 . En itérant,
on obtient le résultat annoncé.
4.3. Systèmes locaux 49
E E1 En−1 F
R R
∗ ∗
R E0 R
Fig. 4.1 – Propriété de Church-Rosser pour les systèmes de réécriture sur des ensembles de termes.
Définition 25 (clôture par R) Soit E ⊆ T(F) et R un système de réécriture sur des ensembles.
R
La clôture de E par R, notée E , est définie par :
R
E = {t | ∃F ⊆ T(F), t ∈ F et E →∗R F }
Proposition 10 (Équivalence de ≡R et de la clôture)

R R
Pour tous les ensembles E et F , on a E = F si, et seulement si, E ≡R F
R
Preuve. Dans le sens direct, comme E ⊆ E pour tout ensemble E et tout système de réécriture
R R R R
sur des ensembles de termes R, E = F implique E ⊆ F et F ⊆ E .
donc : ∃F 0 , F →∗R F, E, F 0
et : ∃E 0 , E →∗R F, E, E 0
donc : F →∗R F, E, F 0 , E 0
et : E →∗R F, E, F 0 , E 0
soit : F ≡R E
La réciproque correspond à l’utilisation de la proposition 9 et à la remarque, que la clôture est
une fonction croissante des ensembles de termes vers les ensembles de termes : il existe E 0 tel que
R R R
E →∗R E 0 et F →∗R E 0 . L’inclusion E ⊆ E 0 implique E ⊆ E 0 . D’autre part, E 0 ⊆ F , donc
R R R R
E 0 ⊆ F , et donc E ⊆ F . L’inclusion inverse se montre de la même façon, ce qui conclut la
preuve.
Définition 26 (Dérivation)
Une dérivation D dans un système de réécriture R est une suite d’ensembles (Ei )i∈{0,...,n} telle
que :
1. ∀i ∈ {1, . . . , n} , ∃ti ∈ T(F), Ei \ Ei−1 = ti
2. ∀i ∈ {1, . . . , n} , Ei−1 →R Ei
Dans ce cas, nous disons que D part de E0 , arrive en En , et a pour but tn .
Lorsque le système de réécriture sur les ensembles R est clairement spécifié par le contexte, nous
parlerons plus simplement de dérivation. Dans cette définition, la première condition exprime que
les ensembles de termes sont strictement croissants, la seconde permet d’avoir, pour une dérivation
R
(Ei )i∈{0,...,n} , En ⊆ E0 . Par définition, si (Ei )i∈{0,...,n} est une dérivation de but t, alors t ∈
/ Ej
R
pour j ∈ {0, . . . , n − 1} et t ∈ E0 .
Définition 27 (Dérivation bien formée)

Une dérivation (Ei )i∈{0,...,n} partant de E de but t est bien formée si :
∀i ∈ {1, . . . , n} , Ei \ Ei−1 ∈ (E, t)
4.3 Systèmes locaux

Nous introduisons maintenant des systèmes de réécriture sur des ensembles de termes ayant de
bonnes propriétés permettant de décider efficacement si un terme est dans la clôture d’un ensemble
de termes.
4.3.1 Introduction
On considère des termes sur une signature F, un constructeur f ∈ F d’arité non nulle et des
fonctions α : → servant à réindicer des termes. Dans cette section, l’égalité des termes est
l’égalité syntaxique. Pour simplifier les notations, nous notons f (t1 , . . . , tn ) un f -terme dont les
sous-termes stricts maximaux pour la relation de sous-terme sont t1 , . . . , tn . Par exemple, si un
constructeur f a comme premier argument un terme t1 et comme second argument un ensemble
{t2 , . . . , tn } ou un multi-ensemble (généralisé ou non) de support {t2 , . . . , tn }, nous le notons sim-
plement f (t1 , . . . , tn ).
4.3.2 Définitions
Définition 28 (Règles de f -composition pures)
Une règle de réécriture sur des ensembles de termes est une règle de f -composition si elle est de
la forme :
∃f 0 ∈ F,
∀i ∈ {1, . . . , n} , ∀ti ∈ Fi ,
f (t1 , . . . , tk1 ), . . . , f (tkl−1 +1 , . . . , tkl ), tkl +1 , . . . , tn → f (tα(1) , . . . , tα(m) )
avec :
0
– F i = T(F) ou F i = T(F) \ {t | t f -terme}
– tα(1) , . . . , tα(m) ⊆ {t1 , . . . , tn }
– {tkl +1 , . . . , tn } ⊆ {t1 , . . . , tkl } ∪ tα(1) , . . . , tα(m) .
La quantification sur tkl +1 , . . . , tn implique qu’un de ces terme peut être un f -terme. Dans une
f -règle pure, un f -terme u est dit être utilisé en tant que f -terme si il est égal à un des termes
f (tj , . . . , tj 0 ). La condition sur les Fi sera utilisée pour l’application aux règles de réécriture de
Fproto , qui sont définies sur des ensembles de termes en forme normale. Elle indique que ti est un
g-terme en forme normale avec g 6= f 0 . La quantification est utilisée pour avoir des règles uniformes
par rapport aux termes et permettra de remplacer des termes par d’autres.
Définition 29 (Règles de f -décomposition pures)

Une règle de réécriture sur des ensembles de termes est une règle de f -décomposition pure si elle
est de la forme :
∃f 0 ∈ F,
∀i ∈ {1, . . . , n} , ∀ti ∈ Fi ,
f (t1 , . . . , tk1 ), . . . , f (tkl−1 +1 , . . . , tkl ), tkl +1 , . . . , tn → t
avec :
– Fi = T(F) ou Fi = T(F) \ {t | t f 0 -terme}
– {tkl +1 , . . . , tn } ⊆≡ −1 {t1 , . . . , tkl } et t ∈ {t1 , . . . , tkl }.
Dans une telle règle, le terme f (t1 , . . . , tk1 ) (choisi arbitrairement parmi ceux ayant t comme
sous-terme strict maximal) est le terme décomposé.
Soit R un système de règles de réécriture. Pour deux ensembles de termes E et F et pour un
terme t, on note E →R(t) F pour abréger E →R F et F = E, t.
Définition 30 (f -système canonique)

Soit f ∈ F un constructeur, Rf = Rc,f ∪ Rd,f un système de règles de f -composition et de f -
décomposition tels que Rc,f ∩Rd,f = ∅ et ρ ∈ {Rc,f , Rd,f }. Rf est canonique si pour tout ensemble
de termes E ⊆ T(F), et pour tous termes u, t ∈ T(F) \ E, tels que :
E →Rc,f E, t →ρ E, t, u
on a E →ρ E, u ou t ∈≡ −1 (E, u).
La condition de cette définition porte sur les règles de composition. Elle indique que si un terme
t produit à partir de E est utilisé pour produire ensuite un terme u (la première alternative est
fausse), alors ce terme est dans l’ensemble (E, u).
4.3. Systèmes locaux 51
Définition 31 (Système local)

Un système R de réécriture sur des ensembles est dit local si pour tout ensemble de termes E et
R
pour tout terme t ∈ E , il existe dans R une dérivation bien formée partant de E et de but t.
Dans la sous-section suivante, nous allons montrer que toute combinaison de systèmes cano-
niques est un système local.
4.3.3 Combinaison de systèmes canoniques

Dans la suite de cette section, soit F une signature arbitraire, f1 , . . . , fk des constructeurs tous
distincts d’arité non nulle dans F, et Rf1 , . . . , Rfk tels que Rfi soit un fi -système canonique. Soit
R = ∪i∈{1,...,k} Rfi . Nous notons Rc = ∪i∈{1,...,k} Rc,fi et Rd = ∪i∈{1,...,k} Rd,fi .
Soit enfin une dérivation D = (Ei )i∈{0,...,n} partant d’un ensemble E de but b. Les résultats
suivants sont énoncés avec ces notations.
Lemme 4
Si F →R(t) F 0 et (F 0 ) 6= (F ), alors :
– F →Rc (t) F 0
– (F 0 ) = (F ) ∪ {t}
Preuve. Par définition d’un règle de décomposition, si F →Rd F 0 , alors (F 0 ) = (F ). Donc
l’hypothèse implique que la transition est faite par une règle de composition. Le deuxième point
est alors une conséquence de la définition des règles de composition.
Lemme 5
Si F →Rd F, t est dans D, alors t est sous-terme de E.
Preuve. Soit i l’indice minimal tel que t soit sous-terme de Ei . Si i 6= 0, alors (Ei−1 ) 6=
(Ei ), donc, par le lemme 4, t ∈ Ei et Ei−1 →Rc Ei−1 , t. L’hypothèse F →Rd F, t contredit
alors la définition d’une dérivation.
Lemme 6
Supposons qu’il n’y ait pas de règle F →Rc t−1 dans R.
Si D est de longueur minimale parmi les dérivations partant de E de but b et Ei →Rc t, Ei est
dans D, alors t ∈ (E, b).
Preuve. L’hypothèse implique que pour tout terme t, si il y a une transition F →R F, t−1 dans
D, c’est une décomposition, et par le lemme 5, t−1 est un sous-terme de E, et donc t−1 et t sont
dans (E).
Soit :
Ω = {Ei−1 →Ri Ei−1 , ti ∈ D | ∃f, Ri ∈ Rc,f et ti 6∈ (E, b)}
Montrons par contradiction que Ω = ∅. Si Ω 6= ∅, soit :
k = max(i | Ei−1 →Ri Ei−1 , ti ∈ Ω)
Par la remarque préliminaire, tk n’est pas un −1 -terme. Par définition de Ω, on a k < n. Soit f
tel que Rk ∈ Rc,f . Par minimalité de D, l’ensemble :
Θ = {j | Ej−1 →l→r Ej−1 , tj et tk ∈ l}
est non vide. Soit j le minimum de Θ. Par définition d’une dérivation, on a k < j. Par minimalité
de j, tk n’est dans le membre gauche d’aucune règle entre Ri+1 et Rj−1 (inclus), donc il existe une
dérivation :
E0 →R1 . . . →Ri−1 Ei−1 →Ri+1 Ei+1 \ tk → . . . →Rj−1 Ej−1 \ tk
Posons F = Ej−1 \ tk . On a donc :
F →Rc,f F, tk →R F, tk , tj
Affirmation 1. tk ∈
/ (F ).
Preuve. Par définition de tk , on a tk ∈/ (E0 ). Il n’y a pas de règle ajoutant tk dans la

dérivation partant de E0 et arrivant en F . Par le lemme 4, on a donc tk ∈ / (F ).
Affirmation 2. tk ∈
/ (tj ).
Preuve. Par contradiction, si tk ∈ (tj ), alors l’affirmation 1. implique tj ∈

/ (F, tk ).
Par le lemme 4, la règle appliquée est donc une règle de composition. Mais alors tk ∈ (tj )
implique, par définition de tk , que tj ∈
/ (E0 , b), ce qui contredit la maximalité de k.
Affirmation 3. tk ∈ (F, tj ).
Preuve. Par minimalité de D, supposons que F 6→R F, tj . Par la définition d’un système
canonique et par les affirmations 1. et 2., on a alors R ∈
/ Rf . Mais alors, par définition des
règles de composition et de décomposition, tk ∈≡ −1 (F, tj ). Par la remarque préliminaire,
tk n’est pas un −1 -terme, donc tk ∈ (F, tj ).
Pour une dérivation de longueur minimale, supposer Ω non vide entraı̂ne Θ non vide, ce qui
implique les affirmations contradictoires 1., 2. et 3. Donc par contradiction, Ω est nécessairement
vide, et donc D est bien formée.
Avec les notations précédentes, nous pouvons maintenant énoncer le théorème de combinaison
suivant :
Théorème 2 (Théorème de combinaison)

S’il n’y a pas de règle F →Rc t−1 dans R, alors R est un système local.
R
Preuve. Soit E un ensemble de termes sur la signature F, t ∈ E et D une dérivation de longueur
minimale partant de E de but t. Par les lemmes 5 et 6, D est une dérivation bien formée, donc R
est un système local.
Ce théorème est très important, car il permet de combiner des règles de déductions portant
sur des constructeurs différents. Dans la section 4.5, nous donnons les règles de réécritures sur
les formes normales de termes valeurs pour les constructeurs de Fproto . Nous montrons que les
systèmes de réécriture de chacun de ces constructeurs sont canoniques. Cela implique que tout
système de réécriture obtenu par combinaison des règles de déduction de ces différents opérateurs
est local.
4.4 Problème d’accessibilité close

Dans cette section, nous considérons le cadre plus général d’une signature F, dont les construc-
teurs peuvent avoir des termes, des ensembles de termes et des multi-ensembles (généralisés ou
non) de termes comme argument. Cela permet d’utiliser les résultats du chapitre 3, section 3.5 sur
les tailles de représentation des termes et ensembles de termes.
Soient E, F, F 0 ⊂fini T(F) et t ∈ T(F), et un système de réécriture sur les ensembles R.
4.4.1 Problèmes de décision

Soit le problème de décision suivant :
Accessibilite Close(E, t, R) : Est-ce que t ∈ E R ?

Pour trouver la complexité d’un problème Accessibilite Close(E, t, R), il est possible de
commencer par borner la complexité du problème de décision suivant :
Transition(E, F, R) : Est-ce que E →R F ?

4.4. Problème d’accessibilité close 53
Taille de problèmes en entrée. Nous prenons comme taille d’un problème en entrée la taille
de la représentation par des graphes (voir chapitre 3, section 3.5) :
– pour le problème Transition (F, F 0 , R), la taille de l’entrée est la somme des tailles des
représentations des ensembles F et F 0 ;
– pour le problème Accessibilite Close (E, t, R), la taille de l’entrée du problème est la
somme des tailles des graphes représentant E et t.
4.4.2 Complexité relative de ces problèmes

Dans le théorème suivant, nous considérons une classe de complexité C avec :
C ∈ {PTIME, NPTIME, EXPTIME}
Théorème 3 (Complexité du problème Accessibilite Close (E, t, R))
Si R est un système local et Transition(F, F 0 , R) est dans la classe de complexité C, alors
Accessibilite Close (E, t, R) est dans la classe C.
R
Preuve. Nous allons donner un algorithme en max (PTIME, C) calculant E ∩ (E, t). R local
implique que cet algorithme est correct et complet. Une fois ce calcul effectué, on peut trouver, en
R R R
temps O(n2 ), si t ∈ E ∩ (E, t). D’autre part, t ∈ E si et seulement si t ∈ E ∩ (E, t),
ce qui prouve le théorème.
Algorithme décidant Accessibilite Close
(E, t, R) :
(E, F ) ∪ t−1 | t ∈ (E, F ) ∪ t | t−1 ∈

G := (E, F )
K := E
faire
H := K
pour tout t ∈ G
si Transition (H, (H, t), R)
K := K, t
refaire tant que H 6= K
si F ⊆ H
répondre oui
sinon
répondre non
On a |G| ≤ 2| (E, t)| ≤ n d’après le chapitre 3, section 3.5. La boucle faire...refaire sera
exécutée au plus |G| fois. La boucle pour tout est à chaque fois exécutée |G| fois. Le problème
Transition (H, (H, t), R) est donc testé O(n2 ) fois. Le graphe représentant H et t a une taille
bornée par 2n, ce qui implique le théorème.
Ce théorème sera surtout utilisé, dans la suite, avec un problème Transition(E, F, R) dans
PTIME ou dans EXPTIME.
Le théorème sera utilisé dans le cadre de la combinaison de différents systèmes de réécriture
sur des ensembles. Nous énonçons tout de suite la proposition suivante, qui permet de trouver la
complexité du problème Transition (E, F, R) lorsque R est une union finie (non nécessairement
disjointe) de systèmes de réécritures sur des ensembles.
Proposition 11
Soient R1 , . . . , Rk des systèmes de réécriture sur les ensembles de T(F), C1 , . . . , Ck les classes
de complexité (dans {PTIME, NPTIME, EXPTIME}) des problèmes Transition (E, F, Ri ), i ∈
{1, . . . , n} et soit :
[n
R= Ri
i=1
Alors
Transition(E, F, R) est dans i∈{1,...,n}
max (Ci )
Preuve. La réponse au problème Transition(E, F, R) est la disjonction des réponses aux problèmes
Transition(E, F, Ri ).
4.5 Symboles et systèmes dans le cadre de l’étude de pro-

tocoles
Dans la cadre de l’étude de protocoles cryptographiques, nous considérons une signature F dont
les symboles d’arité non nulle sont parmi Fproto (voir chapitre 3, section 3.3.5 pour une description
de Fproto ).
Dans la suite de cette section, nous donnons les règles de déduction associées à chacun de
ces opérateurs, montrons que chaque système est canonique et prouvons, pour chaque opérateur
f ∈ Fproto , que Transition (E, F, Rf ) est dans PTIME. Dans les systèmes de règles que nous
donnons, la condition Rc,f ∩ Rd,f = ∅ sera toujours vraie.
4.5.1 Opérateur h , i
Informellement, l’opérateur h , i est utilisé pour faire la concaténation de deux messages. Les
règles de h , i-composition sont de la forme :
Lc,h , i :
∀a, b ∈ T(F), a, b → ha, bi
D’autre part, étant donné un message ha, bi, il est possible d’en déduire les valeurs de a et de
b, ce qu’on modélise par les règles de h , i-décomposition suivantes :
Ld,h , i :
∀a, b ∈ T(F), ha, bi → a
∀a, b ∈ T(F), ha, bi → b
Proposition 12
– Lc,h , i est un ensemble de règles de composition ;
– Ld,h , i est un ensemble de règles de décomposition.
Preuve. La proposition est vraie par définition pour les règles de composition. Il n’y a pas de
h , i-fonction de normalisation, donc a et b sont des sous-termes de ha, bi. Donc Ld,h , i est bien un
ensemble de règles de décomposition.
D’autre part, la condition sur les système canoniques de la définition 30 est satisfaite.
Proposition 13
En posant Lh , i = Ld,h , i ∪ Lc,h , i, Lh , i est canonique.
Preuve. Soient E ⊂ T(F) et t, u deux termes de T(F) \ E tels que :
E →R1 E, t →R2 E, t, u
avec R1 ∈ Lc,h , i et R2 ∈ Lh , i . Soit R1 : a, b → ha, bi et R2 : E2 → u. Si t ∈ / E2 , le résultat est

immédiat. Supposons t ∈ E2 . Si R2 ∈ Ld,h , i , alors E2 = ha, bi, et u ∈ {a, b} ⊆ E, ce qui contredit
/ E. Donc R2 ∈ Lc,h , i et on a : R2 : t, t0 → ht, t0 i ou R2 : t, t0 → ht0 , ti. Donc
l’hypothèse u ∈
t∈ (u).
Malgré le nombre infini de règles à considérer, il est possible de décider le problème :
Transition(E, F, RL h , i
)
en temps polynomial.
Proposition 14 (Complexité du problème (E, F, LhTransition , i ))

Le problème Transition
(E, F, Lh , i ) est dans PTIME.
4.5. Symboles et systèmes dans le cadre de l’étude de protocoles 55
Preuve. Soit n la taille du problème d’entrée.

D’abord, on peut vérifier en temps O(n3 ) que F = E, t avec t ∈ / E. Si cette égalité n’est pas
vérifiée, la réponse au problèmeTransition (E, F, RLh , i ) est non
.
Si cette égalité est vraie, il faut tester si une règle de composition ou de décomposition peut être
appliquée pour « construire » t à partir de E. Si t = ht1 , t2 i, on peut tester en temps O(n2 ) si t1 et
t2 appartiennent à E (application d’une règle de composition). Enfin, l’existence d’un terme ht, t0 i
ou ht0 , ti dans E peut être testée en temps O(n2 ) (application d’une règle de décomposition).
Enfin, si une règle l → r ∈ Rh , i est appliquée sur un ensemble E de termes en forme normale,
soit E →l→r E, r, alors E, r est aussi un ensemble de termes en forme normale.
4.5.2 Opérateurs { }s , { }s,ebc et { }s,cbc

s
L’opérateur { } est utilisé pour simuler le chiffrement symétrique. Le premier argument est le
texte clair du message, et le second est la clef symétrique. On ne restreint pas les clefs symétriques
aux clefs atomiques, donc la clef peut être n’importe quel message.
s
4.5.2.i Cas du chiffrement parfait, opérateur { }
s
Les règles de { } -composition sont de la forme :
Lc,{ }s :
s
∀a, b ∈ T(F), a, b → {a}b
Pour décomposer un message chiffré par une clef symétrique b, et sous l’hypothèse de chiffrement
parfait, il faut connaı̂tre la clef b. Toujours sous cette hypothèse, il n’est pas possible de déduire la
s s
clef b d’un message {a}b . Les règles de { } -décomposition sont donc de la forme :
Ld,{ }s :
s
∀a, b ∈ T(F), {a}b , b → a
Là encore, toutes les conditions sur les règles de composition et de décomposition des définitions 28
et 29 sont vérifiées, et on vérifie sans peine que l’ensemble L{ }s = Lc,{ }s ∪ Ld,{ }s des règles est
un système canonique. Soit :
Proposition 15
Le système L{ }s est canonique.
De même que dans le cas de l’opérateur h , i, et malgré le nombre infini de règles à considérer,
le problème Transition (E, F, RL{ }s ) peut être décidé en temps polynomial. La preuve est omise,
car très similaire à celle de la proposition 14.
Proposition 16 (Complexité du problème Transition

(E, F, L{ }s ))
(E, F, L{ }s ) est dans PTIME.
Enfin, si E →R{ }s F et E est un ensemble de termes en forme normale, alors F est aussi un
ensemble de termes en forme normale.
s,ebc
4.5.2.ii Cas du chiffrement par blocs, opérateur { }
Si un algorithme de chiffrement par bloc est utilisé, il est possible d’extraire individuellement
chaque bloc chiffré d’un message chiffré. On parle alors de propriété d’homomorphisme (voir le
chapitre 2, section 2.1.2.i) du chiffrement par rapport aux blocs, qui peut être modélisée par
l’égalité :
D E
s,ebc s,ebc s,ebc
{a, b}k = {a}k , {b}k
Le message représentant le chiffrement de la concaténation des blocs t1 , . . . , tn par une clef

s,ebc s,ebc
K est représenté par le terme {t1 , . . . , tn }K . Les règles de compositions de l’opérateur { }
peuvent être divisées en deux types :
– des règles de composition correspondant au chiffrement d’un texte clair par une clef ;
– des règles de composition utilisant la propriété d’homomorphisme pour créer un nouveau
message chiffré à partir de messages chiffrés par une même clef.
Le problème est que le système de réécriture sur les ensembles ayant ces règles pour règles de
composition n’est pas canonique. Nous ajoutons donc un troisième type de règles, dont les deux
s,ebc
premiers sont des cas spéciaux. Le système des { } -règles de composition que nous considérons
est :
Lc,{ }s,ebc :
• ∀n ∈ ∗ , ∀t1 , . . . , tn ∈ T(F), ∀K ∈ T(F),
s,ebc
t1 , . . . , tn , K → {t1 , . . . , tn }K
∗ 0 0
• ∀l, kl , m ∈ , ∀t1 , . . . , tkl ∈ T(F), ∀t1 , . . . , tm ∈ T(F),
s,ebc s,ebc s,ebc
{t1 , . . . , tk1 }K , . . . , tkl−1 +1 , . . . , tkl K → {t01 , . . . , t0m }K

avec {t1 , . . . , t0m } ⊆ {t1 , . . . , tkl }

0
∗
• ∀l, kl , n, m ∈ , ∀t1 , . . . , tn ∈ T(F), ∀t1 , . . . , t0m ∈ T(F),
0
s,ebc s,ebc s,ebc
{t1 , . . . , tk1 }K , . . . , tkl−1 +1 , . . . , tkl K , tkl +1 , . . . , tn , K → {t01 , . . . , t0m }K

avec {t01 , . . . , t0m } ⊆ {t1 , . . . , tn }

et {tkl +1 , . . . , tn } ⊆ {t01 , . . . , t0m }
Pour ne pas avoir à utiliser l’opérateur de couple dans les opérations de décryption, nous
s,ebc
changeons les règles de déchiffrement par rapport à celles de l’opérateur { } afin de déduire
indépendamment chaque bloc du message chiffré.
Ld,{ }s,ebc :
∗
∀n ∈ , ∀i ∈ {1, . . . , n} , ∀t1 , . . . , tn ∈ T 0 , ∀K ∈ T(F),
s,ebc
{t1 , . . . , tn }K , K → ti
Notons que le troisième type de règles de composition est inutile vis-à-vis de la clôture d’un
ensemble E : si K est dans E, alors il est toujours possible d’appliquer des règles de décompositions,
puis de composer le terme désiré par une règle de composition du premier type. Cette dérivation
serait bien formée, mais ne serait pas de longueur minimale. Plus précisément, le système L{ }s,ebc
ne serait pas canonique.
La proposition suivante est une conséquence directe de la définition des règles de composition
et de décomposition.
Proposition 17
s,ebc
– Lc,{ }s,ebc est un ensemble de règles de { } -composition ;
s,ebc
– Ld,{ }s,ebc est un ensemble de règles de { } -décomposition ;
Il est légèrement plus délicat de montrer que L{ }s,ebc est un système canonique.
Proposition 18
L{ }s,ebc est un système canonique.
n o
Preuve. Soit ρ ∈ Lc,{ }s,ebc , Ld,{ }s,ebc , et E →Lc,{ }s,ebc E, t →ρ E, t, u avec t, u ∈ / E. Tout
d’abord, remarquons qu’il est possible d’associer à chaque règle de composition ou de décomposition
une clef K. Nous parlerons de clef d’une règle l → r.
Cas ρ = Ld,{ }s,ebc . Soit K la clef de la deuxième règle, et supposons que E 6→ρ u. L’alternative
s,ebc
est alors soit t = K, soit t est un { } -terme dont la clef de chiffrement est K. Dans le premier
cas, t ∈ (E) par définition des règles de Ld,{ }s,ebc . Dans le second, u ∈ / E implique qu’une
règle de composition du deuxième ou du troisième type a été utilisée. Et u ∈ / E implique alors
s,ebc
qu’il existe un terme {t1 , . . . , tn }K et i ∈ {1, . . . , n} tel que ti = u. En utilisant t 6= K, on peut
déduire que K ∈ E, et donc E →Ld,{ }s,ebc u, ce qui contredit l’hypothèse. Donc dans tous les cas,
soit t ∈ (E), soit E →Ld,{ }s,ebc E, u.
Cas ρ = Lc,{ }s,ebc . Si la deuxième règle est une règle de composition du premier type, alors soit
t∈ (u), soit E →Lc,{ }s,ebc u. Sinon, soit K1 la clef de la première règle, et K2 la clef de la
seconde. Si K1 = K2 , alors par définition des règles de composition de deuxième (cas pour deux
règles du deuxième type) ou troisième (autres cas) type, on a E →Lc,{ }s,ebc u. Sinon, alors soit
E →Lc,{ }s,ebc u, soit la deuxième règle est du troisième type, et t ∈ (u).
Il nous reste à donner la complexité du problème Transition(E, F, L{ } s,ebc ).
Proposition 19
Transition (E, F, L{ }s,ebc ) est dans PTIME.
Preuve. Comme dans le cas h , i, commençons par vérifier F \ E = t.
Test de l’application d’une règle de décomposition. Une règle de décomposition peut être
s,ebc
appliquée pour obtenir t si, et seulement si, il existe un terme {t1 , . . . , tn }K dans E tel qu’il existe
s,ebc
i ∈ {1, . . . , n} avec ti = t et K ∈ E. La recherche des termes {t1 , . . . , tn }K peut être conduite en
temps polynomial, et il y en a un nombre inférieur ou égal à la taille de l’entrée, et il est possible
pour chaque terme de tester en temps polynomial si la clef est dans E.
Test de l’application d’une règle de composition. Si t est le résultat de l’application d’une

s,ebc
règle de composition, alors t = {t1 , . . . , tn }K . Pour une règle de composition du premier type, il
suffit de tester t1 , . . . , tn , K ∈ E, ce qui peut être fait en temps polynomial.
Pour une règle de composition du deuxième type, soit :
n o
s,ebc
P = ui | ∃ {u1 , . . . , um }K ∈ E
Le terme t est le résultat de l’application d’une règle du deuxième type si {t1 , . . . , tn } ⊆ P . L’inclu-
sion peut se tester en temps polynomial, donc l’application d’une règle de composition du deuxième
type peut être testée en temps polynomial.
Avec les mêmes notations, tester l’application d’une règle de composition du troisième type revient
à tester K ∈ E et {t1 , . . . , tn } ⊆ E ∪ P .
s,ebc
Pour conclure le cas de l’opérateur { } , remarquons que si une règle de L{ }s,ebc est appliquée
sur un ensemble de termes en forme normale, alors le résultat sera aussi un ensemble de termes en
forme normale.
s,cbc
4.5.2.iii Cas du chiffrement par blocs en mode chaı̂né, opérateur { }
Nous renvoyons au chapitre 2, paragraphe 2.1.2.ii pour la description des propriétés du chiffre-
ment par bloc, et au chapitre 3, paragraphe 3.3.3.i pour une description de l’opérateur. Les règles
sont les suivantes :
Lc,{ }s,cbc :
∀n ∈ ∗ , ∀t1 , . . . , tn ∈ T 0 , ∀K ∈ T(F),
s,cbc
t1 , . . . , tn , K → {t1 , . . . , tn }K
∗
∀n ∈ , ∀i ∈ {1, . . . , n − 1} , ∀t1 , . . . , tn ∈ T 0 , ∀K ∈ T(F),
s,cbc s,cbc
{t1 , . . . , tn }K → {t1 , . . . , ti }K
s,ebc
De la même manière que pour l’opérateur { } , nous modélisons le déchiffrage en permettant
de déchiffrer indépendamment chaque bloc du message chiffré.
Ld,{ }s,cbc :
∀n ∈ ∗ , ∀i ∈ {1, . . . , n} , ∀t1 , . . . , tn ∈ T 0 , ∀K ∈ T(F),
s,cbc
{t1 , . . . , tn }K , K → ti
Ces règles sont des règles de composition et de décomposition. La proposition suivante se prouve
en remarquant que :
s,cbc s,cbc s,cbc
{t1 , . . . , tn }K → {t1 , . . . , ti }K → {t1 , . . . , tj }K
avec j < i < n peut se faire en une étape :
s,cbc s,cbc
{t1 , . . . , tn }K → {t1 , . . . , tj }K
Proposition 20
En notant L{ }s,cbc = Ld,{ }s,cbc ∪ Lc,{ }s,cbc , le système L{ }s,cbc est un système canonique.
En s’inspirant de la preuve pour l’opérateur h , i, nous montrons que l’application du premier

type de règles de composition ou d’une règle de décomposition peut être testée en temps polynomial.
s,cbc
Pour tester si un terme {t1 , . . . , tn }K est le résultat d’une règle de composition du deuxième type,
s,cbc
il suffit de considérer tous les termes {u1 , . . . , um }K de E (il y en a au plus un nombre linéaire
en la taille de l’entrée) et de tester si ui = ti . Le nombre de tests à faire est au plus linéaire en la
taille de l’entrée, ce qui prouve la proposition suivante
Proposition 21
Le problème Transition(E, F, L{ } s,cbc ) est dans PTIME.
Enfin, par définition, si une règle de L{ }s,cbc est appliquée sur un ensemble de termes en forme
normale, le résultat sera un ensemble de termes en forme normale.
4.5.3 Opérateurs { }p et { }p,rsa

p
4.5.3.i Cas du chiffrement parfait, opérateur { }
p
L’opérateur { } est utilisé pour modéliser le chiffrement par clefs publiques/privées. Les règles
de composition sont similaires à celles du couple ou du chiffrement par clef symétrique sans règle
préfixe :
Lc,{ }p :
p
∀a, b ∈ T(F), a, b → {a}b
Pour décomposer un message chiffré par une clef symétrique b, et sous l’hypothèse du chiffrement
parfait, il faut connaı̂tre la clef inverse b−1 . Si l’opérateur −1 n’est pas dans la signature, on
p
n’autorise pas de règles de décomposition. Sinon, les règles de { } -décomposition sont de la forme :
Ld,{ }p :
p
∀a, b ∈ T(F), {a}b , b−1 → a
p
∀a, b ∈ T(F), {a}b−1 , b → a
Les règles de Lc,{ }p sont des règles de composition par définition. Pour montrer que les règles
Ld,{ }p sont des règles de décomposition, il faut utiliser que dans la définition de ces règles, l’in-
clusion des ensembles de termes est définie modulo la relation d’équivalence ≡ −1 . On vérifie alors
facilement que les règles de Ld,{ }p sont des règles de décomposition.
Enfin, l’ensemble L{ }p = Lc,{ }p ∪ Ld,{ }p des règles est un système canonique. La preuve est
omise car très proche de celle de la proposition équivalente pour l’opérateur h , i.
Proposition 22
L{ }p est canonique.
Le problème Transition (E, F, RL{ }p ) peut être décidé en temps polynomial. Là encore, la
preuve est omise, car très similaire à celle de la proposition 14.
Proposition 23
Le problème Transition(E, F, L{ } ) est dans PTIME.
p
Enfin, il est évident que si une règle R de L{ }p est appliquée sur un ensemble E de termes en
forme normale, soit E →R F , alors F est aussi un ensemble de termes en forme normale.
p,rsa
4.5.3.ii Cas du chiffrement commutatif, opérateur { }
Dans le but de simplifier la présentation, nous supposons que le symbole −1 , d’arité 1, est aussi
dans la signature. Nous utilisons les opérations standards sur les multi-ensembles et multi-ensembles
généralisés telles qu’elles sont définies dans le chapitre 3, section 3.2.
Nous rappelons que pour modéliser les propriétés d’un opérateur de chiffrement asymétrique de
p,rsa
type RSA, nous avons défini un opérateur { } (voir chapitre 3, section 3.3.5) dont le deuxième
argument est le multi-ensemble des clefs chiffrant le message.
p,rsa
Nous rappelons aussi (voir chapitre 3, section 3.4) que si les { } -termes sont en forme
p,rsa
normale, alors pour t = {t0 }K , on a :
p,rsa
– t0 n’est pas un { } -terme ;
– pour tout k ∈ T(F), K(k) = 0 ou K(k −1 ) = 0.
Le premier point vient directement de la définition de la fonction de normalisation, et le second
indique que si t est normalisé, il n’est pas chiffré à la fois par une clef K et son inverse.
p,rsa
Notons T 0 = T(F) \ {t | t { } -terme}. Les règles de L{ }p,rsa sont de la forme :
L{ }p,rsa :
∗ p,rsa rsa
∀n ∈ , ∀t, t1 , . . . , tn ∈ T(F), t, t1 , . . . , tn → p{t} tc1 ,...,tcn q
{1 n }
avec ∀i ∈ {1, . . . , n} , ci ≥ 1
Ces règles sont définies sur les termes valeurs en forme normale. En notant :
p,rsa rsa
e = p{t} tx1 ,...,txn q
{1 n }
p,rsa
une telle règle est dans Lc,{ }p,rsa si e est un { } -terme, et dans Ld,{ }p,rsa sinon. Commençons
par montrer que les règles ainsi définies sont bien des règles de composition et de décomposition.
Proposition 24
p,rsa
– Lc,{ }p,rsa est un ensemble de règles de { } -composition ;
p,rsa
– Ld,{ }p,rsa est un ensemble de règles de { } -décomposition.
p,rsa
Preuve. Soit une { } règle :
∗ p,rsa rsa
∀n ∈ , ∀t, t1 , . . . , tn ∈ T(F), t, t1 , . . . , tn → p{t} q
{tc11 ,...,tcnn }
avec ∀i ∈ {1, . . . , n} , ci ≥ 1
p,rsa rsa
et notons e = p{t} tc1 ,...,tcn q son résultat.
{1 n }
Pour les règles de Ld,{ }p,rsa , on remarque que la condition ∀i ∈ {1, . . . , n} , ci > 0 et e non
p,rsa p,rsa p,rsa
-terme de la forme {e}Kt , et t1 −1 , . . . , tn −1 =

{} -terme impliquent t { } (Kt ) par
définition de la fonction de normalisation. L’opérateur −1 est dans la signature, donc la règle est
bien une règle de décomposition.
p,rsa
Pour les règles de Lc,{ }p,rsa , les deux cas t { } -terme ou non se traitent sans difficulté, ce
qui conclut la preuve de la proposition.
Il faut maintenant prouver que L{ }p,rsa est un système canonique.
Proposition 25
L{ }p,rsa est un système canonique.

Preuve. Soit ρ ∈ Lc,{ }p,rsa , Ld,{ }p,rsa . Considérons les règles utilisées pour construire t et u à
partir d’un ensemble E de termes en forme normale :
p,rsa rsa
a, s1 , . . . , sm →Lc,{ }p,rsa t = p{a} q
{sc11 ,...,scnm }
b, t1 , . . . , tn →ρ u = p{b} n
p,rsa
d
o rsa
dn
q
t1 1 ,...,tn
Supposons t ∈ {b, t1 , . . . , tn }, le résultat étant immédiat sinon. Il y a deux cas :

– si t = b, alors la règle :
a, s1 , . . . , sm , t1 , . . . , tn → u = p{a}
p,rsa n d1 o qrsa
{sc11 ,...,scnm }+ t1 ,...,td
n
n
est aussi une règle de ρ, car l’appartenance à Lc,{ }p,rsa ou Ld,{ }p,rsa ne dépend que de u. Elle
peut être appliquée sur E ;
– sinon, soit t = t1 sans perte de généralité. Par définition de p qrsa , par la condition c1 > 0, et le
membre gauche étant en forme normale, on a t ∈ (b, u). On a b ∈ E, donc t ∈ (E, u).
Ce qui prouve la proposition.

(E, F, L{ }p,rsa ))
(E, F, L{ }p,rsa ) est dans PTIME.

Tout d’abord, F = E, t avec t ∈ / E peut être vérifié en temps O(n3 ). Si cette égalité n’est pas
vérifiée, la réponse au problème Transition
(E, F, RL{ }p,rsa ) est . non
Supposons que la règle appliquée soit la suivante :
b, t1 , . . . , tn → t
Avec les fonctions Add et Opp définies dans le chapitre 3, section 3.4, la définition des règles de
L{ }p,rsa implique Basersa (t) = Basersa (b) et :
(Add(Facteurrsa (t), Opp(Facteurrsa (b)))) = {t1 , . . . , tn }
Pour tester si une telle règle a pu être appliquée, nous considérons l’ensemble des termes de E
qui ont la même base que t, et pour chaque terme b de cet ensemble testons si le support de la
différence des facteurs de t et b est inclus dans E. Cet algorithme est exécuté en temps polynomial
en la taille des entrées.
Enfin, il est évident qu’appliquer sur un ensemble E de termes en forme normale, le résultat
d’une règle de L{ }p,rsa sera un terme en forme normale.
4.5.4 Opérateur H( , )
Cet opérateur représente l’image par une fonction d’adressage dispersé, donnée comme premier
argument, du message donné en second argument. On pose Ld,H( , ) = ∅ et les règles de Lc,H( , )
sont de la forme :
Lc,H( , ) :
∀a, b ∈ T(F), a, b → H(a, b)
Ces règles satisfont les conditions des règles de composition de la définition 28. D’autre part, la
condition sur les système canoniques est trivialement satisfaite. On a donc la proposition suivante :
Proposition 27
En posant Lh , i = Lc,H( , ), LH( , ) est canonique.
Là encore, le problème de transition peut être décidé en temps polynomial. La preuve est omise,
car similaire à celle de la proposition 14.

(E, F, LH( , ) ))
(E, F, LH( , ) ) est dans PTIME.
4.5.5 Opérateur Exp( , )

Ce cas se traite de la même manière que le cas d’un opérateur de chiffrement asymétrique
commutatif. La seule différence est dans la définition des règles LExp( , ) où les coefficients des
exposants peuvent être positifs ou négatifs :
LExp( , ) :
∗ exp
∀n ∈ , ∀t, t1 , . . . , tn ∈ T(F), t, t1 , . . . , tn → pExp(t, {tc11 , . . . , tcnn })q
avec ∀i ∈ {1, . . . , n} , ci 6= 0
Les règles de composition et de décomposition LExp( , ) système canonique sont définies de la

p,rsa
même manière que pour l’opérateur { } .

(E, F, LExp( , ) ))
(E, F, LExp( , ) ) est dans PTIME.

D’abord, on peut vérifier en temps O(n3 ) que F = E, t avec t ∈ / E. Si cette égalité n’est pas
vérifiée, la réponse au problème Transition
(E, F, LExp( , ) ) est . non
Supposons que la règle appliquée soit la suivante :
b, t1 , . . . , tn → t
La définition des règles de LExp( , ) implique BaseExp (t) = BaseExp (b) et :
(FacteurExp (t) − FacteurExp (b)) = {t1 , . . . , tn }
Pour tester si une telle règle a pu être appliquée, nous considérons l’ensemble des termes de E qui
ont la même base que t, et pour chaque terme b de cet ensemble testons si le support de la différence
des facteurs de t et b est inclus dans E. Cet algorithme permet de tester en temps polynomial si
une règle a pu être appliquée pour construire t.
4.5.6 Opérateur ⊕({ })

Nous considérons dans cette section le symbole ⊕({ }) représentant le ou exclusif bit à bit
(voir le chapitre 3, section 3.3 pour une description plus précise). Rappelons seulement que ce
constructeur est associatif et commutatif, et qu’il suffit de considérer des termes en forme normale.
Par exemple :
p⊕({e, ⊕({⊕({a, ⊕({b, c}), ⊕({a, b, d})})})})q = ⊕({c, d, e})

Les règles sont définies sur des termes valeurs en forme normale, donc aucun terme t dans un
ensemble argument d’un ⊕({ })-terme n’est un ⊕({ })-terme.
L’ensemble L⊕({ }) des règles de réécriture sur l’opérateur ⊕({ }) est l’ensemble des règles de
la forme :
L⊕({ }) :
∗ xor
∀n ∈ , ∀t1 , . . . , tn ∈ T(F), t1 , . . . , tn → p⊕({t1 , . . . , tn })q
xor
et p⊕({t1 , . . . , tn })q ∈ / {t1 , . . . , tn }
De la même manière que pour les règles de L{ }p,rsa ou LExp( , ) , on définit les règles de compo-
xor
sitions et de décomposition en fonction du résultat e = p⊕({t, t1 , . . . , tn })q d’une règle :
xor
L: t1 , . . . , tn → p⊕({t1 , . . . , tn })q
– si e est un ⊕({ })-terme, la règle L est dans Lc,⊕({ }) ;

– sinon, L est dans Ld,⊕({ }) .
La proposition suivante énonce que les règles de Lc,⊕({ }) (resp. Ld,⊕({ }) ) sont bien des règles
de composition (resp. décomposition).
Proposition 30
Soit L une règle de L⊕({ }) . On a :
– L ∈ Lc,⊕({ }) implique L est une règle de ⊕({ })-composition ;
– L ∈ Ld,⊕({ }) implique L est une règle de ⊕({ })-décomposition.
Preuve. Soit L une règle de L⊕({ }) . Le membre gauche est en forme normale, donc il existe t1 , . . . ,
tn des termes qui ne sont pas des ⊕({ })-termes et I1 , . . . , Ik des sous-ensembles de {1, . . . , n} de
cardinal ≥ 2, et α : {1, . . . , l} → {1, . . . , n} une fonction injective. Une règle L est de la forme :
⊕({∪i∈I1 {ti }}), . . . , ⊕({∪i∈Ik {ti }}), tα(1) , . . . , tα(l) → e
On a :
xor
e = p⊕(⊕({I1 }), . .
. , ⊕({Ik }), ⊕( tα(1) , . . . , tα(l) ) )q (définition de L⊕({ }) )
xor
= p⊕( (∆ki=1 Ii )∆ tα(1) , . . . , tα(l) )q (définition de p qxor )
Par définition des règles L⊕({ }) , i 6= j implique tα(i) 6=α(j) , donc tα(i) ∈ / ∪ki=1 Ii , implique tα(i) ∈
(e).
D’autre part, si e = ⊕({u1 , . . . , um }), alors toujours par définition de la fonction de normali-
sation, pour tout i ∈ {1, . . . , m}, on a ui ∈ {t1 , . . . , tn }. Donc si L ∈ Lc,⊕({ }) , L est une règle de
composition.
Enfin, si L est dans Ld,⊕({ }) , d’après la deuxième condition sur les règles de L⊕({ }) , et pour tout
i ∈ {1, . . . , k}, on a e 6= tα(i) . Donc, par définition de la fonction de normalisation, e ∈ ∪ki=1 ∪j∈Ik tj .
Donc L est bien une règle de décomposition.
Le système L⊕({ }) est canonique par conséquence de la proposition suivante.
Proposition 31
Si E →L⊕({ }) E, t →L⊕({ }) E, t, u, alors E →L⊕({ }) u.
Preuve. Considérons les deux règles utilisées :
Et → t
Eu → u
/ Eu , la proposition est triviale. Sinon, on vérifie facilement, en notant Eu0 = Et ∆(Eu \ {t}),
Si t ∈
que la règle suivante :
Eu0 → u
est une règle de L⊕({ }) , et que Eu0 ⊆ E.
Transition(E, F, L⊕({ }) ) est dans PTIME.

Enfin, il reste à montrer que le problème
Proposition 32 (Complexité du problème Transition(E, F, L⊕({ }) ))

Le problème Transition(E, F, L⊕({ }) ) est dans PTIME.
Preuve. Soit n la taille du problème d’entrée. On a toujours n ≥ | (E, t)|.

Comme pour les cas précédents, nous nous ramenons au cas F = E, t avec t ∈/ E. Soit :
B = {b | ∃u ∈ E, t avec b ∈ Facteur⊕ (u)}
B peut se construire en temps polynomial. Soit m = |B|. On a nécessairement m ≤ n. Posons

B = {b1 , . . . , bm }, et (ei )i∈{1,...,m} la base canonique de IF m2 , IF 2 étant le corps à deux éléments.
On définit une fonction ψ : E, t ∪ B → IF m 2 de la manière suivante :
– si x ∈ B, soit x = bi , on pose ψ(x) = ei ;
– si x est un ⊕({ })-terme, soit x = ⊕({t1 , . . . , tl }), on pose :
ψ(x) = Σli=1 ψ(ti )

4.6. Problème d’accessibilité close dans le cadre des protocoles 63
Cette fonction est bien définie par définition des facteurs. On note A la matrice |E| × m définie
par les images des termes de E, b l’image du terme t. Par définition de l’addition sur IF 2 , il existe
une ⊕({ })-transition de E vers E, t si et seulement si le système linéaire
A.X = b
|E|
a une solution X ∈ IF 2 . Résoudre un tel système linéaire peut se faire en un nombre polynomial
d’opérations. Les coefficients sont 0 ou 1, donc chaque opération a un coût constant. On a |E| ≤ n,
donc la taille de ce système est polynomiale en fonction de n, et ce système peut se résoudre en
temps polynomial en fonction de la taille n du problème d’entrée.
Donc le problème Transition (E, F, L⊕({ }) ) est dans PTIME.
4.6 Problème d’accessibilité close dans le cadre des proto-

coles
Rappelons que T(F) est l’ensemble des termes valeur en forme normale sur la signature Fproto .
Soient E ⊂fini T(F) et t ∈ T(F) et soit le système de réécriture sur des ensembles de termes :
[
Rproto = Lf
f ∈Fproto
Les résultats de la section 4.5 et le théorème 2 impliquent le théorème suivant.
Théorème 4 (Complexité du problème Accessibilite Close(E, t, R))

Avec les notations précédentes, Accessibilite Close(E, t, Rproto ) est dans PTIME.
Preuve. Dans R, il n’y a pas de règles de composition ayant un terme t−1 en membre droit, donc
la première hypothèse du théorème 2 est vérifiée.
D’après le théorème 2 et les propositions de la section 4.5, R est donc un système local. D’après
la proposition 11 et les propositions de la section 4.5, le problème Transition (E, F, R) est dans
PTIME.
Transition
R est local et (E, F, R) est dans PTIME, donc d’après le théorème 3, le problème
Accessibilite Close (E, t, R) est dans PTIME.
Ce résultat étend divers résultats obtenus en ajoutant un seul opérateur aux opérateurs
p s
{h , i , { } , { } }
voir par exemple [28, 19, 20].
4.7 Règles d’oracle

Les protocoles cryptographiques sont en général étudiés dans le cadre du chiffrement parfait,
dit cadre de D. Dolev-A. Yao en référence aux auteurs l’ayant défini. Le système de réécriture sur
des ensembles considéré est alors le système :
R = Lh , i ∪ L{ }p ∪ L{ }s
Les outils et systèmes sont souvent présentés dans ce cadre, que ce soit au niveau du processus
de compilation [63, 72] ou au niveau de l’analyse [88, 75, 4], les auteurs indiquant que leur travail
peut être étendu pour prendre en compte les fonctions d’adressage dispersé. La notion de système
canonique permet de formaliser cette extension. Une autre approche, l’utilisation de règles d’oracle
a été développée durant cette thèse.
Dans cette approche, des règles de déductions sont ajoutées à celles du système R . Elles ont
été introduites lors d’un travail publié dans [25] pour permettre l’étude d’un nombre non borné
de sessions d’un protocole. Elles ont ensuite été reprises formellement pour permettre l’étude d’un
protocole au-delà de l’hypothèse de chiffrement parfait. Le premier travail portait sur l’ajout d’un
opérateur ⊕({ }) [19]. Il a été suivi par d’autres travaux donnant la complexité de l’étude de
protocoles cryptographiques dans différents cas (ajout d’un opérateur exponentiel [20], complexité
de la validation de protocoles [22] dans le modèle présenté l’année précédente [25]).
La définition des règle d’Oracle repose sur une notion de dérivation bien formée semblable à
celle définie en section 4.2. Des règles E → a, avec E et a en forme normale, sont ajoutées au
système R . Une règle est dite de décomposition si a est un sous-terme de E, et de composition
sinon.
Les conditions sur les règles ajoutées au système R pour que ces règles soient des règles
d’oracles sont données par la définition suivante :
Définition 32 (Règles d’oracle)

Soit Lo = Loc ∪ Lod un ensemble (fini ou infini) de règles de déduction, où Loc et Lod désignent
des ensembles disjoints de règles de composition et de décomposition. Lo est un ensemble de règles
d’oracle (par rapport à R ) si et seulement si il existe une fonction des termes vers les termes
telle que :
R ∪Lo
1. pour tout terme t et tout ensemble de termes E, t ∈ E implique qu’il existe une
dérivation bien formée partant de E de but t ;
2. si F →Loc F, t et F, t →Ld F, t, a, alors il existe une dérivation D partant de F de but a telle
que Ld (t) 6∈ D.
3. pour toute règle F → s ∈ Loc , tout sous-terme propre de s est un sous-terme de F ;
4. pour tout terme non atomique u, il existe un terme en forme normale ; (u) avec
| ((u))| < | (puq)|
tel que :
Pour tout ensemble fini de termes F avec I, u ∈ F , si F \u →Lc (u)
F , i.e., u peut être composé à partir de F en une étape, alors
R
F →Lo F, t implique pt[u ← (u)]q ∈ pF [u ← (u)]q et (u) ∈
R
F pour tout message t.
Les conditions 2. et 3. sont très proches de celles données pour avoir un système canonique.
La condition 1. est moins restrictive, puisque des règles d’une forme arbitraire sont autorisées.
L’inconvénient de cette définition est que les conditions 1. et 4. ne sont pas locales aux règles
ajoutées. Il faut refaire toutes les preuves pour ajouter un nouvel opérateur. Par exemple, dans
s,cbc
[19], les opérateurs ⊕({ }) et { } sont considérés, mais indépendamment l’un de l’autre. De
même, dans [28], H. Comon-Lundh et V. Shmatikov considèrent les opérateurs ×({ }) (un opérateur
de groupe abélien, utilisé pour l’exponentiation et le chiffrement de type RSA) et ⊕({ }) sont
considérés, mais là encore indépendamment les uns des autres.
En conclusion, les systèmes canoniques permettent a priori de traiter moins de cas, car les
conditions imposées aux règles impliquent celles portant sur les règles d’oracle. Cependant, le gain
en modularité justifie, à nos yeux, leur introduction et leur utilisation.
4.8 Travaux reliés

Le résultat principal de ce chapitre est que, sous une hypothèse relativement faible (l’impossi-
bilité de construire l’inverse d’un terme), il est possible de combiner des systèmes de réécriture sur
des ensembles canoniques pour obtenir un système local. La notion de localité a été introduite par
D. McAllester [66] pour l’étude de problèmes d’accessibilité close en généralisant des techniques
de raisonnement modulo pour des théories ayant un nombre fini d’équations closes considérées par
D. Kozen [58] et R. Shostack [97]. McAllester donne, dans cet article, une procédure permettant
de décider, pour une classe particulière de systèmes de réécritures et un paramètre donnés, si un
système est local ou non. Notre démarche est différente. Nous cherchons des propriétés sur des
systèmes de réécritures sur des ensembles assurant que leur combinaison est un système local.
4.9. Conclusion 65
Cette notion de système local a été reprise pour l’étude de problèmes d’accessibilité par H. Comon-
Lundh et V. Shmatikov [28]. Dans cet article, il est montré, entre autres, que le problème d’acces-
sibilité close pour le système :
Lh , i ∪ L{ }s ∪ L{ }p ∪ L⊕({ })
est dans NPTIME. Nous avons amélioré une première fois ce résultat dans [19], où nous montrons
que ce problème est dans PTIME. Les techniques utilisées dans cet article permettent d’étendre le
système de règles :
Lh , i ∪ L{ }s ∪ L{ }p
par un système de règles lié à un autre opérateur. Nous avons ainsi montré que les problèmes
d’accessibilité close sont décidables en temps polynomial lorsque :
s,cbc
– l’opérateur { } est ajouté [19] ;
– l’opérateur Exp( , ) est ajouté [20] ;
p,rsa
– l’opérateur { } est ajouté (non publié).
4.9 Conclusion
Les ensembles de messages jouent un rôle central dans l’étude des protocoles cryptographiques.
D’une part, ils permettent de savoir si un protocole peut être implanté, en analysant les connais-
sances des rôles pour savoir si la suite d’envois de messages définie par le protocole peut être
réalisée. D’autre part, ils sont utilisés pour modéliser les connaissances d’un intrus essayant de
faire échouer un protocole.
Dans ce chapitre, nous avons défini les règles de déduction sur les ensembles de messages. Ces
règles peuvent être utilisées par l’intrus ou par un principal jouant un rôle, suivant le problème
considéré. Nous avons montré que dans le cas clos, c’est-à-dire dans le cas où aucune substitution
n’est appliquée, il est possible de décider en temps polynomial si un terme t peut être déduit à
partir de l’ensemble de connaissances E (théorème 4).
Ce résultat améliore ceux présentés dans [28] et, pour la partie sur le cas clos, ceux de [19,
20] en considérant toute combinaison d’opérateurs en plus des opérateurs habituels du cadre du
chiffrement parfait.
Deuxième partie
Compilation
67
5
Compilation de protocoles
cryptographiques
5.1 Introduction
5.1.1 Analyse formelle de protocoles cryptographiques
Nous avons vu dans le chapitre 1, section 1.1.2 une spécification de protocole par un scénario
d’exécution. Ce type de spécification en notation Alice et Bob est facilement compréhensible pour
un lecteur humain, mais n’est pas opératoire, car d’importantes questions n’ont pas de réponse
dans cette spécification : Quels sont les ordres de réception/envoi de messages possibles ? Quels
messages peuvent être acceptés par les acteurs ?
L’analyse des protocoles passe par une première étape de compilation d’une description déclarative
du protocole vers un système de transitions (Σ, T ), où Σ est un ensemble (infini) d’états, et T une
relation de transitions entre états. Deux états E et E 0 sont en relation par T , ce qui est noté
T (E, E 0 ), s’il existe une transition de E vers E 0 , avec E, E 0 ∈ Σ. Les systèmes de transitions
considérés sont très variés, et vont des processus CSP [88, 64], aux automates d’arbres [75, 53], en
passant par des règles de réécriture [38]. Notre travail est dans cette dernière ligne. Nous exprimons
les actions des acteurs honnêtes et de l’intrus dans le formalisme des règles de réécriture.
Dans ce chapitre, nous décrivons la réponse que nous apportons au deux précédentes questions.
La réponse à la première des deux questions, largement acceptée, est de considérer que chaque rôle
est un processus qui attend et envoie des messages dans l’ordre prévu par le scénario. La seconde
question est plus problématique, car elle en soulève d’autres :
– existe-t-il un mécanisme sous-jacent de contrôle des champs d’un message ? G. Lowe a pro-
posé [54] un mécanisme de marquage des messages pour assurer que des messages différents
ne soient pas confondus. Cependant, il nous semble préférable d’avoir un mécanisme explicite,
et d’éviter de donner à un message une structure plus complexe que celle d’une suite de bits ;
– quelles parties d’un message reçu sont analysées par un rôle ? Il est tentant, dans le cadre
de l’implantation d’un protocole, de chercher à économiser du temps de calcul en ne faisant
pas toutes les vérifications possibles. Dans le cadre de la recherche d’attaques, il nous semble
cependant préférable de supposer que toutes les vérifications possibles seront faites.
5.1.2 Cadre de travail

Contrairement aux chapitre précédents, nous ne considérons pas, dans ce chapitre, tous les
opérateurs possibles. Les opérateurs de chiffrement symétrique par blocs posent en effet des problèmes
d’interprétation. Par exemple, considérons le protocole suivant :
s
1. A → B : {Na, A, B }K
s
2. B → A : {B , A, Na}K
dans lequel le rôle B n’est pas sensé connaı̂tre la clef K. Ce protocole est parfaitement implantable si
le chiffrement utilisé est un chiffrement par bloc sans chaı̂nage : le rôle B répond en réordonnant des
69
70 Chapitre 5. Compilation de protocoles cryptographiques
parties du message qu’il a reçu. Le problème est que cela signifie qu’un acteur jouant le rôle B peut
connaı̂tre (partiellement) la structure d’un message chiffré qu’il attend alors qu’il n’en connaı̂t pas
s,cbc
la clef. Nous avons préféré éviter ces cas spéciaux, ainsi que le cas similaire avec l’opérateur { } ,
en supposant que le chiffrement symétrique était, du point de vue des rôles, parfait. Dans le reste
de ce chapitre, nous considérons donc une signature F contenant tous les constructeurs de Fproto
s,ebc s,cbc
desquels nous avons enlevé les constructeurs { } et { } . Nous notons Rproto le système de
règles de déductions défini à partir de ces constructeurs. Avec les notations du chapitre 4 :
[
Rproto = Lf
f ∈F
De même, nous notons :

S
Rc,proto = f ∈F Lc,f
S
Rd,proto = f ∈F Ld,f
5.1.3 Plan du chapitre

Ce chapitre est centré sur le processus de compilation d’un protocole cryptographique, c’est-à-
dire sur le passage d’une spécification déclarative à un système de transitions décrivant toutes les
actions des participants. Nous essayons de mettre en évidence, à chaque étape, les hypothèses et
les choix faits pour permettre la compilation.
Nous présentons le langage de haut niveau de description de protocoles dans la section 5.2. Nous
décrivons ensuite les systèmes de transition sur lesquels les protocoles sont étudiés en section 5.3.
Le premier, dit général, est celui utilisé dans le cadre du projet AVISS. Il est basé sur la sémantique
intrinsèque des règles de réécritures. En dehors de ce chapitre, nous raisonnons sur un système de
transitions optimisé pour le cas d’un intrus ayant le contrôle des communications. Ce système est
décrit dans la sous-section 5.3.4. La notion d’exécutabilité d’un protocole est introduite et traitée
en section 5.4.
Nous décrivons aussi en détail la compilation d’une spécification déclarative d’un protocole en
un système de transitions. En section 5.5, nous donnons un modèle de gestion des connaissances
des rôles. Ce modèle est directement mis en œuvre pour la création des règles de réception et envoi
de messages par les rôles, création décrite dans la sous-section 5.5.3. Dans cette même section, nous
donnerons des propriétés de ces règles relatives à l’occurrence des variables. Enfin, nous présentons
d’autres compilateurs de protocoles en section 5.6.
5.2 Langage haut niveau de description de protocoles

5.2.1 Description par un scénario et hypothèses
Nous nous intéressons aux spécifications de haut niveau de type Alice et Bob. Dans une telle
spécification, un protocole est défini par un scénario type décrivant une exécution correcte. Par
exemple, prenons le cas du protocole proposé par R. Needham et M. Schroeder de la figure 5.1.
p
1. A → B : {Na, A}Kb
p
2. B → A : {Nb, Na}Ka
p
3. A → B : {Nb}Kb
Fig. 5.1 – Protocole de R. Needham et M. Schroeder à clefs publiques (Needham-Schroeder Public

Key)
Plusieurs hypothèses sont implicites dans ce scénario. Soient a et b deux acteurs honnêtes, et I
un acteur malhonnête.
5.2. Langage Haut Niveau 71
5.2.1.i Indépendance de contrôle.

Indépendance des acteurs entre eux. Si les rôles A et B sont joués par deux acteurs a et b,
nous supposerons que les actions de a sont indépendantes des actions de b. Plus précisément, les
actions de a jouant le rôle A dépendront des messages qu’il pense provenir d’un acteur b jouant le
rôle B, mais pas de l’état de l’acteur b. Ainsi, un acteur jouant le rôle B peut recevoir le premier
message sans que a l’ait envoyé, par exemple.
Indépendance de contrôle des rôles par rapport aux acteurs. Supposons qu’un même
acteur a joue les rôles A et B de ce protocole. Nous supposons que les actions de cet acteur jouant
le rôle A sont indépendantes de celles qu’il effectue en jouant le rôle B.
Les actions du rôle A n’affectent pas les actions du rôle B. Donc, dans une sémantique opérationnelle
de ce protocole, les transitions liées au rôle B, par exemple, ne doivent dépendre ni de l’état du
rôle A avec qui il communique, ni de l’instance (acteur et connaissances initiales) de ce rôle.
5.2.1.ii Indépendance de données.

Indépendance de données des acteurs entre eux. Une autre hypothèse est qu’il n’y a pas
de mécanisme implicite de partage de connaissances entre les acteurs. Le nonce Na envoyé par un
acteur a jouant le rôle A dans le premier message n’a pas nécessairement la même valeur que le
nonce reçu par un acteur b jouant le rôle B. Donc les connaissances d’un acteur, à un moment
donné, ne dépendent que de ses connaissances initiales et des messages qu’il a reçus et envoyés.
Indépendance des données dans des rôles joués par un même acteur. Nous faisons
l’hypothèse que les connaissances d’un acteur ne sont pas partagées entre les différents rôles qu’il
joue. Donc si un acteur a joue les rôles A et B du protocole de la figure 5.1, il ne vérifiera pas si
le nonce Na qu’il a envoyé a la même valeur que celui reçu en jouant le rôle B.
5.2.1.iii Compilation des rôles et intrus.

Nous supposons que si a est un acteur honnête jouant un rôle A ou B, il suivra la même
suite d’actions, dépendante de ses connaissances initiales et des messages reçus, selon que son
interlocuteur soit un acteur honnête b ou malhonnête I. Par contre, pour l’intrus, jouer un rôle
A ou B signifie uniquement avoir les connaissances initiales de ce rôle et pouvoir communiquer
sous son vrai nom avec les acteurs honnêtes. Ses actions ne dépendent pas de celles prévues par le
protocole, et ses connaissances initiales peuvent être plus importantes que celles prévues pour jouer
un rôle. Il n’est pas astreint, par exemple, à créer une nouvelle valeur si le protocole prévoit qu’il
envoie un nonce ou à émettre un message suivant le schéma prévu par la spécification du protocole.
5.2.1.iv Scénario séquentiel

Nous supposons enfin que pour un protocole donné dans la notation Alice et Bob, chaque
message (sauf le premier) est une réponse à un message reçu. Autrement dit, en notant Ri le
receveur du message i et Si l’émetteur du message i (avec i ∈ {1, . . . , n}, pour un protocole à n
messages), on suppose que pour i ≥ 2, Si est égal à Ri−1 . La classe des protocoles vérifiant cette
hypothèse est très large. Elle ne contient cependant pas des protocoles dans lesquels, par exemple,
un rôle doit attendre deux messages (dans un ordre non spécifié) de deux rôles différents.
5.2.1.v Compilation d’un protocole

Sous ces hypothèses, il est possible de compiler (donner une sémantique opérationnelle à) un
protocole en considérant la suite de messages échangés indépendamment de l’état initial ou des
caractéristiques de l’intrus. Dans la suite de cette section, nous allons d’abord voir la spécification
des rôles à travers les connaissances initiales qu’il doit avoir (sous-section 5.2.2) et la description des
messages échangés (sous-section 5.2.3). Nous décrivons la spécification d’une exécution du protocole
en commençant par la spécification des acteurs jouant les différents rôles (sous-section 5.2.4),
description complétée par la spécification de l’intrus (sous-section 5.2.5) et de l’état initial du

protocole. Enfin, les propriétés que doit assurer ce protocole sont décrites en sous-section 5.2.6.
Afin de guider le lecteur dans ces différentes partie, nous donnons en figure 5.2 comme exemple
de spécification complète en LHNSP celle du protocole à clefs publiques proposé par R. Needham
et M. Schroeder [78]. La suite des messages de ce protocole est celle de la figure 5.1.
NSPK ;
A, B : ;
Na, Nb : ;
Ka, Kb : ;
A : B , Ka, Ka0 , Kb ;
B : A, Ka, Kb, Kb0 ;
1 . A → B : {Na, A}Kb
2 . B → A : {Nb, Na}Ka
3 . A → B : {Nb}Kb
:
B [A : a, B : b, Ka : ka, Kb : kb],
B [A : a, B : I , Ka : ka, Kb : ki ],
A [A : a, B : I , Ka : ka, Kb : ki ] ;
divert, impersonate ;
b, kb ;
B authenticates A on N a ;
Fig. 5.2 – Exemple de spécification LHNSP : le protocole de R. Needham et M. Schroeder (Need-

ham-Schroeder Public Key)
5.2.2 Spécification de la connaissance des rôles

La connaissance des rôles est spécifiée par des termes opérations sur des variables de rôle. Nous
notons V (avec les décorations usuelles) l’ensemble de ces variables. Les termes opérations sont
construits, par défaut, avec les mêmes symboles que ceux décrits dans le chapitre 3, section 3.3. Ils
sont directement traduits, par le compilateur, en termes valeurs sur T(F, X ).
Les variables de rôle sont des identificateurs permettant d’exprimer à la fois des connaissances
des rôles et les messages que les rôles échangent entre eux. Afin de faciliter la détection d’erreurs
dans la spécification, ces variables sont typées. Les types accessibles dans l’implantation actuelle
du compilateur CasRul sont :
: les variables de ce type décrivent des rôles ;
: ce type est le plus général. Les variables de type n’ont aucune propriété
spéciale, et peuvent représenter un texte à chiffrer, le préambule d’un message, un numéro
de compte bancaire, cette liste n’étant pas exhaustive ;
: les variables de ce type sont des clefs publiques. Afin de simplifier la spécification,
l’opérateur −1 est noté 0 dans la syntaxe du langage de haut niveau ;
: les variables de ce type sont des clefs symétriques. Il faut noter que dans ce
cas et dans le cas de clefs publiques, le nom d’une variable est indépendant, pour le processus
de compilation, des rôles connaissant cette variable. Appeler Kab la clef symétrique partagée
par les rôles A et B, ou Ka la clef publique de A est une convention destinée à rendre la
spécification plus lisible ;
: les variables de ce type sont des fonctions à adressage dispersé. Dans la syntaxe de
haut niveau, le terme opération H(F, M ) est noté F (M ).
Dans la figure 5.2, la déclaration des variables de rôle est faite dans la section :
5.2. Langage Haut Niveau 73
A, B : ;
N a, N b : ;
Ka, Kb : ;
Ces variables sont ensuite utilisées pour déclarer les connaissances initiales des rôles. Tout terme
opération construit à partir des variables est une connaissance initiale valide. La déclaration se fait
rôle par rôle. Pour le protocole de la figure 5.2, les connaissances déclarées sont :
A : B, Ka, Ka0 , Kb ;
B : A, Ka, Kb, Kb0 ;
Notons que les variables de rôle Na et Nb ne sont dans les connaissances initiales d’aucun rôle.
Cela permet, dans le cadre des règles génériques, d’autoriser un acteur à participer à un nombre non
borné de sessions. Dans ce cadre, les connaissances initiales sont les mêmes d’une session à l’autre.
Les nonces de deux sessions d’un acteur devant être différents, le compilateur devra retrouver les
variables correspondant à des nonces, et les traiter à part.
5.2.3 Description des messages échangés

La description des messages échangés par les rôles lors d’une session normale du protocole est
spécifiée dans la notation Alice et Bob habituelle. Il n’est pas nécessaire de spécifier, pour un
opérateur de chiffrement, si il correspond à un chiffrement par clef symétrique ou asymétrique. Le
compilateur infère le type du chiffrement en fonction de la clef utilisée : chiffrement asymétrique
pour une clef publique ou privée, chiffrement symétrique pour une clef symétrique ou un message.
Pour le protocole de la figure 5.2, la suite des messages est spécifiée dans la section :
1. A → B : {N a, A}Kb
2. B → A : {N a, N b}Ka
3. A → B : {N b}Kb
5.2.4 Description des instances des rôles

L’état initial d’une instance du protocole occupe le reste de la spécification. Dans le cas de la
figure 5.2, les instances des rôles sont :
:
B [A : a, B : b, Ka : ka, Kb : kb],
B [A : a, B : I, Ka : ka, Kb : ki],
A [A : a, B : I, Ka : ka, Kb : ki] ;
Un acteur différent de I est supposé être honnête. Dans cet état initial du protocole, il y a donc
deux acteurs honnêtes, l’acteur b jouant le rôle B (première ligne), et l’acteur a jouant le rôle A
(troisième ligne). L’acteur b s’attend à une session avec l’acteur a jouant le rôle de A, tandis que
l’acteur a est prêt à initier une session avec l’intrus.
La seconde ligne spécifie que l’intrus doit être prêt à jouer le rôle B en réponse à l’acteur
a. Contrairement aux autres lignes, aucun terme n’indiquera cette instance dans l’état initial du
protocole. Le seul effet de cette déclaration est de verser les connaissances instanciées du rôle B,
dans ce cas :
a, I , ka, ki , ki 0
dans les connaissances initiales de l’intrus.
5.2.5 Description de l’intrus

5.2.5.i Capacités de l’intrus
Informellement, les capacités de déduction de l’intrus, étant donné un ensemble de connaissances
E, sont toujours les mêmes. La seule partie de l’intrus que l’utilisateur peut spécifier est le contrôle
qu’un attaquant peut avoir sur le système de communication. Trois capacités sont définies, et
l’utilisateur peut en donner à l’intrus de zéros à trois parmi les suivantes :
– divert permet à l’intrus d’intercepter tous les messages. Il peut ainsi empêcher un message
envoyé d’arriver à destination et connaı̂tre le contenu de ce message. Cette propriété doit
être envisagée dès que des personnes inconnues ont un accès physique à un réseau par câble.
C’est le cas, par exemple, pour des communications via internet entre deux sites distants ;
– eaves dropping n’autorise pas l’intrus à empêcher un message d’arriver à destination, mais
lui permet de prendre connaissance du contenu des messages envoyés. Il faut noter que n’im-
porte qui peut écouter tous les messages envoyés sur des réseaux Wifi, mais qu’il est impos-
sible d’empêcher un message d’arriver à destination. Pour ce type de réseaux, la propriété
d’eaves dropping sera préférée à divert ;
– impersonate est une propriété d’intrus dans tous les réseaux où il n’y a pas de mécanisme
implicite d’authentification. Dans le cas d’envoi de messages sur internet, par exemple, il est
possible de falsifier l’en-tête d’un message pour lui donner une adresse IP d’origine différente
de l’adresse réelle d’envoi. La difficulté pour l’intrus, dans ce cas, est de parvenir à récupérer
la réponse, qui ne lui est plus envoyée directement. Pour cela, il a besoin soit de la propriété
divert, soit, à défaut, de la propriété eaves dropping. Lorsque l’intrus envoie un message
en falsifiant l’en-tête pour faire croire que ce message vient d’un acteur a, l’envoyeur est noté
I(a) : il s’agit de l’intrus I, mais avec l’identité a.
Nous remarquons, sans le prouver formellement, qu’un intrus possédant les capacités divert et im-
personate a aussi la capacité eaves dropping : il peut toujours intercepter un message, mettre
le contenu de ce message dans ses connaissances (propriété divert) et le renvoyer sous l’identité
de l’émetteur initial.
Dans le cas de la figure 5.2, l’intrus a les capacités d’interception et d’envoi sous une fausse
identité :
D. Dolev et A. Yao ont formalisé, dans [41], la notion d’un intrus ayant un contrôle total sur le
réseau, ainsi que ses capacités de déduction dans le cadre du chiffrement parfait. Un attaquant de
ce type sera dit de D. Dolev-A. Yao, en référence à ces deux auteurs.
5.2.5.ii Connaissances initiales de l’intrus

Les connaissances initiales de l’intrus viennent de deux sources :
a) des instances des rôles qu’il joue de manière légitime, tel que spécifié dans la partie sur les
instances initiales des rôles ;
b) d’une liste d’identificateurs à la discrétion de l’utilisateur.
Les identificateurs de cette liste doivent avoir été déjà définis dans la partie d’instanciation des
rôles. Sans cela, il serait impossible, pour le compilateur, de déterminer leur type. Dans l’exemple
de la figure 5.2, les connaissances supplémentaires de l’intrus sont le nom de l’acteur b ainsi que sa
clef publique :
b, kb ;
5.2.6 Spécification des propriétés du protocole

Le but de l’intrus est de parvenir à violer au moins une des propriétés de sécurité du protocole.
Actuellement, deux propriétés peuvent être déclarées :
– secrecy of M1 , . . . , Mn signifie que les messages M1 , . . . , Mn doivent rester ignorés de l’in-
trus. Une variante, Short Term Secret, donne le terme secret à l’intrus à la fin de l’exécution
du protocole. Ce but sert pour les protocoles d’échanges de clefs, lorsqu’on veut garantir
qu’une clef de session n’est pas réutilisée. Dans la version actuelle, les propriétés de secret ne
portent que sur des messages atomiques. L’extension à des messages non atomiques n’a pas
été jugée utile ;
5.3. Sémantique Opérationnelle 75
– A authenticates B on M1 , . . . , Mn signifie que B va réussir à authentifier son interlocuteur

A en se basant sur les messages M1 , . . . , Mn . Là encore, et pour les mêmes raisons, seuls des
messages atomiques sont acceptés. Plusieurs types d’authentification sont donnés par G. Lo-
we [62]. Pour faciliter la spécification du protocole, nous n’en avons retenu qu’une seule. Ainsi,
lorsqu’un acteur b jouant le rôle de B envoie une valeur ti pour Mi , i ∈ {1, . . . , n} à un acteur
a jouant le rôle A, un événement (b, a, Mi , ti ) est mémorisé. Dès qu’un acteur a0 jouant le rôle
A termine une session en pensant : a) avoir communiqué avec b0 jouant le rôle B ; b) avoir reçu
de b0 les valeurs ui pour les messages Mi , i ∈ {1, . . . , n}, tous les événements (b0 , a0 , Mi , ui )
doivent s’être produits. Avec cette définition, une authentification réussie exclut les attaques
par répétition (où B participe à moins d’exécutions du protocole que A). Cela a permis, par
exemple, de trouver une attaque sur une partie du protocole SET .
Seules ces deux propriétés de protocoles peuvent être définies dans le langage LHNSP. Dans
la spécification de la figure 5.2, seule l’authentification est demandée :
B authenticates A on N a ;
5.3 Sémantique opérationnelle pour les protocoles crypto-

graphiques
5.3.1 Description du système de transition final
Nous rappelons que le but de la compilation est d’associer à la spécification déclarative d’un
protocole dans le langage LHNSP un système de transitions (Σ, T ), où Σ est un ensemble (infini)
d’états, et T une relation, dite relation de transition, entre les états.
Les états de Σ sont des multi-ensembles de termes représentant, à un moment donné, l’ensemble
du réseau, les agents honnêtes participant et l’intrus. Nous distinguons les termes suivant le symbole
de tête. Il y a principalement :
– Les m-termes représentent les messages qui ont été envoyés par un acteur ou l’intrus, et qui
n’ont pas encore été reçus ;
– les w-termes représentent des acteurs en attente d’un message ;
– les i-termes représentent des connaissances de l’intrus.
Des termes auxiliaires seront introduits au moment de leur utilisation. Afin de simplifier la présentation,
[t1 , . . . , tn ] dénote une liste de termes, ht1 , t2 i le constructeur de couples, et on garde les notations
des messages pour les autres constructeurs. Le constructeur de multi-ensembles est noté · : t1 · t2 · t2
est le multi-ensemble M tel que M (t1 ) = 1, M (t2 ) = 2 et M (t) = 0 si t 6= t1 , t2 . Les termes sont
construits à partir de variables et de constantes. Parmi ces dernières, la constante I a la signification
spéciale de représenter l’intrus.
5.3.2 Description des états du système (Σ, T )

5.3.2.i Description des termes
Les m-termes. Les termes de messages sont d’arité 4. Les arguments sont, dans l’ordre :
– l’envoyeur réel du message. Il s’agit de l’agent honnête ou de l’intrus ayant envoyé ce message ;
– l’envoyeur officiel, dont le nom peut être déduit d’un message par son receveur ;
– le receveur attendu du message ;
– le message lui-même.
Ainsi, par exemple, le terme m(I, a, b, {N b}Kb) représente le message {N b}Kb envoyé par l’intrus
à l’acteur b en prétendant être l’acteur a.
Les w-termes. Les termes des participants, acteurs dans un état ou rôle dans une transition,
sont d’arité 2. Leurs arguments sont :
– le numéro du message que le participant attend. Étant donné un protocole, ce numéro identifie
aussi le rôle joué par cet agent [56]. Un acteur prêt à initier un protocole est marqué comme
étant à l’étape 0 ;
– la liste des connaissances de l’acteur attendant le message. Dans cette liste se trouvent entre
autres le nom de l’acteur.
Par exemple, le terme w(0, [a, I , ka, ka 0 , ki ]) représente l’acteur a jouant le rôle A dans la figure 5.2.
Ces termes sont dévolus aux agent honnêtes. Lorsque l’intrus joue officiellement un rôle, les connais-
sances initiales de ce rôle sont versées dans les connaissances initiales de l’intrus.
Les i-termes. Les termes de l’intrus sont d’arité 1. Un terme i(t) signifie que l’intrus connaı̂t t.
5.3.2.ii L’état initial

Le compilateur déduit l’état initial du protocole en fonction de l’instance du protocole. Par
exemple, l’état initial de la spécification 5.2 est :
w(0, [a, I , ka, ka 0 , ki ]) · w(1, [b, a, kb, kb 0 , ka])

·i(I) · i(a) · i(b) · i(ka) · i(kb) · i(ki) · i(ki0 )
5.3.2.iii États critiques

Lorsqu’un terme t supposé rester secret est envoyé par un agent honnête et n’est pas supposé
être reçu par l’intrus, un terme secret(t) est ajouté à l’état courant du protocole. Un état viole la
propriété de secret s’il contient les deux termes secret(xs ) et i(xs ) pour une valeur de xs .
Pour la propriété A authenticates B on N a, un terme :
witness(xB , xA , N a, xN a )
est ajouté à l’état du protocole dès qu’un acteur xB jouant le rôle B envoie à un acteur xA jouant
le rôle A la valeur xN a pour N a pour la première fois de sa session. Avec les mêmes notations,
lorsque xA termine sa partie du protocole, un terme :
request(xA , xB , N a, xN a )
est ajouté avec les valeurs que xA attribue à xB et xN b . Un mécanisme de simplification enlève de
l’état les deux termes witness et request si les valeurs correspondent. Un état du protocole violant
la propriété d’authentification est un état contenant un terme request après simplification.
5.3.3 Sémantique opérationnelle en sortie du compilateur

Nous décrivons, dans cette section, le système de transitions (Σ, T ) donnant une sémantique
opérationnelle au protocole. Les règles décrites dans cette section sont, sauf pour le dernier pa-
ragraphe, directement issue d’un travail antérieur au nôtre et sont décrites avec précision dans
[56].
5.3.3.i Traitement des actions des acteurs honnêtes

Tout d’abord, nous considérons un ensemble de variables X indexé par les termes de T(F, V),
ainsi que les termes construits sur ces variables et sur les constantes T(F, X ). Les états de Σ
sont des ensembles de termes de T(F, X ). Nous décrivons maintenant la relation de transition
T entre deux états E et E 0 de Σ lors d’une action d’un acteur. Un état E contient des termes
m correspondant à des messages envoyés et pas encore reçus, des termes w correspondant à des
acteurs dans un certain état, et des termes i représentant les connaissances de l’intrus.
La séparation entre rôles et acteurs permet d’associer à chaque étape d’un rôle une règle de
transition correspond à une réception de message et à l’envoi immédiat de la réponse. Ces règles
sont de la forme :
m(xReal , xOff , xRecv , R) · w(j, K) → m(xSend , xSend , xRecv 2 , S) · w(j 0 , K 0 )
Dans cette règle, j est l’étape de réception du message courant et j 0 est l’étape de réception du
message suivant. R, S, K et K 0 sont des termes représentant respectivement le message attendu
par le rôle à l’étape j, le message envoyé en réponse, les connaissances du rôle à l’étape j, et les
5.3. Sémantique Opérationnelle 77
connaissances du rôle après l’envoi de la réponse. Nous décrirons dans la suite de ce chapitre la
construction de ces termes.
Pour le système de transition (Σ, T ), et pour E, E 0 ∈ Σ, on a T (E, E 0 ) s’il existe une règle
l → r et une substitution σ telles que lσ ⊆ E et E 0 = E \ lσ ∪ rσ. Par exemple, en se basant sur la
p
spécification de protocole de la figure 5.2, supposons que l’intrus ait envoyé le message {I, a}kb en
prétendant être l’acteur a jouant le rôle A à un acteur b jouant le rôle B. L’état du protocole est
alors :
p
m(I, a, b, {I, a}kb ) ·
w(0, [a, I , ka, ka 0 , ki , na]) · w(1, [b, a, kb, kb 0 , ka, nb])
·i(I) · i(a) · i(b) · i(ka) · i(kb) · i(ki) · i(ki0 )
La règle de réception du premier message pour le rôle B est :
p
m(xinc , xA , xB , {xNa , xA }xKb ) · w(1 , [xB , xA , xKb , xKb
0
, xKa , xNb ])
⇒
p
m(xB , xB , xA , {xNb , xNa }xKa ) · w(3 , [xB , xA , xKb , xKb
0
, xKa , xNb , xNa ])
Elle peut être appliquée sur l’état courant du protocole avec la substitution σ suivante :
- xinc σ = I - xA σ = a - xB σ = b
- xN a σ = I - xKb σ = kb - xKa σ = ka
- xN b σ = nb
Le nouvel état E 0 obtenu est alors :

p
m(b, b, a, {nb, I }ka ) · w(0, [a, I , ka, ka0 , ki , na])
· w(3, [b, a, kb, kb0 , ka, nb, na])·i(I ) · i(a) · i(b) · i(ka) · i(kb) · i(ki ) · i(ki 0 )
5.3.3.ii Traitement des actions de l’intrus

Interception d’un message. L’interception d’un message quelconque se code très simplement
dans notre formalisme :
m(x1 , x2 , x3 , x4 ) → i(x2 ) · i(x3 ) · i(x4 )
L’intrus a toujours la possibilité d’intercepter les messages qui lui sont adressés, donc la sortie du
compilateur contient une règle de ce type dans laquelle la variable x3 est remplacée par I. Si l’intrus
possède la propriété divert, nous supposons qu’il n’intercepte pas les messages qu’il a envoyés. Il y
a donc, en sortie du compilateur, une règle de ce type pour chaque acteur honnête a du protocole,
dans laquelle la variable x1 est remplacée par a.
Écoute d’un message. Lorsque l’intrus possède la capacité eaves dropping, il a la possibilité
d’écouter les messages en transit. L’écoute d’un message quelconque est modélisée par la règle :
m(x1 , x2 , x3 , x4 ) → m(x1 , x2 , x3 , x4 ) · i(x2 ) · i(x3 ) · i(x4 )
Dans l’implantation effective du compilateur, un marqueur est ajouté dans les arguments du
constructeur m pour assurer que l’intrus n’écoute pas plusieurs fois le même message [56]. Les
messages envoyés par l’intrus sont marqués comme ayant déjà été écoutés.
Composition de messages et décomposition des connaissances, le modèle statique.

L’intrus, dans le modèle de D. Dolev-A. Yao, peut créer un nombre infini de messages. Dans le
but de pouvoir étudier des protocoles dans le cadre de la validation de modèle, il est habituel de
restreindre les protocoles pour se ramener au cas d’un nombre fini d’états. L’hypothèse usuelle,
décrite dans [88], consiste à borner la taille des messages échangés en utilisant un mécanisme de
typage. Ce mécanisme assure qu’une variable, dans les règles produites, ne pourra être instanciée
que par une constante. Sous cette hypothèse de typage, il est possible de calculer, connaissant les
messages du protocole, toutes les possibilités que peut avoir l’intrus pour composer un message. Des
règles de simplification sont générées pour permettre à l’intrus de décomposer ses connaissances.
Dans la version actuelle de CasRul, ces règles sont :
(h , i) i(hx1 , x2 i) → i(x1 ) · i(x2 )
s s
({ } ) i({x1 }x2 ) · i(x2 ) → i(x1 ) · i(x2 )
p p p
({ } ) i({x1 }x2 ) · i(x02 ) → i(x1 ) · i({x1 }x2 ) · i(x02 )
p p p
({ } ) i({x1 }x0 ) · i(x2 ) → i(x1 ) · i({x1 }x0 ) · i(x2 )
2 2
Ces règles, décrites dans [56], présentent cependant l’inconvénient de ne pas permettre le traitement
de clefs composées.
Une autre voie, le modèle paresseux. Nous avons introduit dans [24] un modèle paresseux
de l’intrus reposant sur la résolution de contraintes. Ce système, décrit au chapitre 6, permet une
analyse à la fois plus performante et plus complète d’un protocole. Il n’est plus nécessaire de pré-
calculer les différentes manières possibles de composer ou décomposer un message, ce qui a rendu
obsolètes les calculs présentés au paragraphe précédent.
5.3.4 Règles optimisées

Les termes des principaux combinent plusieurs aspects par ailleurs indépendants :
– l’ordre d’application des règles est sous-tendu par les règles de réception/envoi de messages.
Le contenu d’un terme w détermine quel message est attendu par un principal dans son état
actuel ;
– les principaux se « souviennent » des messages qu’ils ont reçu en stockant leur valeur dans le
terme w. Cette valeur est mémorisée pour être comparée aux messages reçus et utilisée dans
les messages envoyés.
Dans ces deux cas, le terme w peut être qualifié de « détail d’implantation » du système de transition
(Σ, T ).
Nous utilisons, en dehors de ce chapitre, un modèle plus direct pour exprimer l’ordre d’ap-
plication des règles et le partage des connaissances. Pour cela, nous supposons que l’intrus a les
capacités du modèle de D. Dolev et A. Yao, c’est-à-dire qu’il peut intercepter les messages et en
envoyer sous une fausse identité. Dans ce cadre, nous supposons en plus que l’intrus intercepte tous
les messages, et donc que tous les messages reçus par les principaux honnêtes ont été envoyés par
l’intrus.
Pour chaque rôle X, nous considérons un ensemble de règles :
{Rι ⇒ Sι }ι∈I
où I est un ensemble fini ordonné. Nous imposons que l’ordre sur I soit total. Cela correspond
au fait que les actions d’un rôle sont séquentielles et effectuées dans un ordre déterminé par le
protocole. Le partage des connaissances est simulé par un partage des variables entre toutes les
règles du rôle.
Une instance du rôle X par un acteur honnête x est modélisée par une substitution σ sur les
variables de {Rι ⇒ Sι }ι∈I . Cette substitution envoie les variables correspondant aux connaissances
initiales sur les termes clos donnés par la spécification de l’instance, et les autres variables sur un
sous-ensemble Xσ des variables. Les connaissances ne sont pas partagées d’une instance d’un rôle à
une autre, donc nous imposons aux substitutions σ1 , . . . , σk utilisées pour instancier un protocole
de vérifier :
∀i, j ∈ {1, . . . , k} , i 6= j ⇒ Xσi ∩ Xσj = ∅
Une instance d’un protocole est définie par une union d’instances de rôles et par les connaissances
initiales de l’intrus, donc en dehors de ce chapitre, et à moins qu’il en soit précisé autrement, nous
appelons protocole un triplet
({Rι ⇒ Sι }i∈I , <I , S0 )
avec I un ensemble fini, <I un ordre sur I, et S0 un ensemble de termes représentant les connais-
sances initiales de l’intrus.
5.4. Exécutabilité 79
5.4 Exécutabilité d’un protocole

5.4.1 Problème
Le protocole de R. Needham et M. Schroeder, présenté dans la figure 5.2, ne pose pas de
problème d’implantation. Dans cette section, nous considérerons donc un protocole jouet, plus
simple, et des variations autour de ce protocole. Considérons l’échange de messages de la figure 5.3,
et supposons qu’initialement, le rôle B ne connaisse ni la clef symétrique K, ni le message M .
1. A → B : {M }K
...
n. A → B : K
n + 1. B → A : M
Fig. 5.3 – Exemple de décomposition de connaissances antérieures
Après avoir reçu le premier message, et en considérant le chiffrement comme parfait, B ne connaı̂t
ni la valeur de M , ni celle de K. Et pourtant, il a reçu B et M ! Supposons maintenant qu’un
acteur jouant le rôle B doive répondre en émettant le message M :
1. A → B : {M }K
2. B → A : M
Un tel protocole ne peut pas être exécuté. Il ne pourra pas être exécuté non plus si M désigne un
rôle (est de type ). Enfin, nous remarquons que si M n’est pas envoyé dans le premier message :
1. A → B : {A}K
2. B → A : M
le protocole devient exécutable : M est une nouvelle valeur créée par l’acteur jouant le rôle B.
Dans la suite de cette section, nous allons voir comment retrouver les nonces à partir d’une
spécification de protocoles en sous-section 5.4.2. Ensuite, disposant des nonces créés par un rôle,
de ses connaissances initiales et de la suite des messages du protocole, nous étudierons le problème
de l’exécutabilité d’un protocole.
5.4.2 Traitement des nonces

Soit V l’ensemble des variables de rôle apparaissant dans la suite de messages d’un protocole,
Vinit l’ensemble des variables de rôles dans les connaissances initiales des rôles, et Vnonce l’ensemble
des variables de rôles qui sont des nonces. Pour que la spécification du protocole soit correcte, il
est nécessaire d’avoir :
V = Vinit ∪ Vnonce
Vinit ∩ Vnonce = ∅
Si une variable de rôle N apparaı̂t dans les connaissances initiales d’un rôle, elle ne sera pas
traitée comme un nonce. Il suffit donc de vérifier que si une variable de rôle N n’apparaı̂t pas dans
les connaissances initiales des rôles, alors c’est un nonce.
Il y a pour cela deux contraintes à vérifier. En l’absence de mécanisme de communication autre
que l’envoi de messages, un nonce ne peut être créé que par un seul rôle. Donc une variable qui
n’est dans les connaissances initiales d’aucun rôle est un nonce si :
– elle a été créée par le rôle l’envoyant en premier ;
– elle n’est créée par aucun autre rôle lors d’une exécution normale du protocole.
Pour les clefs publiques/privées, nous supposons aussi qu’un rôle créant une clef publique (ou
privée) crée en même temps la clef privée (publique) correspondante. Il faudra alors vérifier que
le protocole est exécutable sous ces hypothèses. Pour la suite de cette section, notons Nonce(A)
l’ensemble des nonces qu’on pense être créés par le rôle A.
5.4.3 Définition de l’exécutabilité

Dans cette partie, un protocole est donné par un ensemble de rôles, par des connaissances
initiales pour chaque rôle, et par une suite de messages en notation Alice et Bob. Notons Si
l’envoyeur du message i, et Ri le receveur de ce message, pour i ∈ {1, . . . , n}. Pour simplifier
les notations, supposons que les nonces créés par un rôle le sont avant le début des échanges de
messages, et pour un rôle A, notons Init(A) l’ensemble des connaissances initiales de A.
Définition 33 (Connaissance d’un rôle)

Dans un protocole dont la suite de messages est (i. Si → Ri : Mi )i∈{1,...,n} , La connaissance d’un
rôle A après la réception du message i, notée Mem(A, i), est :

 Init(A) ∪ Nonce(A) si i = 0
Mem(A, i) = Mem(A, i − 1) si A 6= Ri
Mem(A, i − 1) ∪ {Si } ∪ {Mi } si A = Ri

Par définition, Mem(A, i) est un sous-ensemble de T(F, V). Il est maintenant possible de définir
ce que signifie, pour un protocole, être exécutable.
Définition 34 (Protocole exécutable)

Un protocole P dont la suite de messages est (i. Si → Ri : Mi )i∈{1,...,n} est exécutable si :
Rproto
∀i ∈ {1, . . . , n} , Mi ∈ Mem(Si , i − 1)
5.4.4 Définition et complexité du problème Executabilite(P )

Soit P un protocole donné par une liste de variables de rôles V, un ensemble de connaissances
initiales pour chaque rôle, un ensemble de connaissances initiales :
Init : VR ⊆ V → P( 0T( 0F, V))
et une liste de messages dans la notation Alice et Bob {(i. Si → Ri : Mi )}i∈{1,...,n} .

Considérons le problème de décision :
Executabilite(P ) : Le protocole P est-il exécutable ?

Tout d’abord, remarquons qu’il est possible de construire en temps polynomial en la taille de P ,
pour chaque rôle A, la liste de nonces devant être créés par A : il suffit de lire la liste des messages
Mi . Si une variable apparaı̂t dans Mi mais pas dans Mj , 1 ≤ j < i ni dans les connaissances
initiales, alors cette variable doit être un nonce créé par Si .
Pour tout i, l’ensemble Mem(Si , i−1) peut être calculé en temps polynomial, donc par définition,
le problème Executabilite (P ) se réduit en n problèmes :
Accessibilite Close(Mem(Si , i − 1), Mi , Rproto ), i ∈ {1, . . . , n}
Le théorème suivant est alors une conséquence du théorème 4 du chapitre 4.
Théorème 5 (Complexité du problème d’exécutabilité)

Pour un protocole P en notation Alice et Bob, le problème de décision
Executabilite(P )
est dans PTIME.
5.5. Gestion des Connaissances 81
5.5 Gestion des connaissances

5.5.1 Modèle pour la gestion des connaissances
Pour tester l’exécutabilité d’un protocole, nous avons considéré une exécution du protocole
suivant le scénario donné par la notation Alice et Bob. Pour étudier les différentes exécutions
possibles d’un protocole en présence de l’intrus, il est nécessaire d’analyser plus précisément les
connaissances des rôles. Rappelons l’exemple de protocole de la figure 5.3, en supposant que B ne
connaisse pas la clef symétrique K :
1. A → B : {M }K
...
n. A → B : K
n + 1. B → A : M
À la réception du premier message, un acteur jouant le rôle B, ne connaissant pas K, ne peut pas
vérifier la structure du premier message. L’intrus peut donc substituer n’importe quelle valeur au
message envoyé par A, ce message sera toujours accepté par un acteur jouant le rôle B.
Dans le but de modéliser les substitutions que l’intrus peut appliquer sur un message attendu
par un rôle B, nous allons :
a) donner, pour chaque rôle, une représentation des connaissances par un ensemble de termes
valeurs ;
b) exprimer les messages attendus et envoyés par un rôle par des filtres sur les termes valeurs.
Pour cela, nous avons besoin de deux opérations sur les ensembles de termes. La première,
Rproto
Cloture(E), donne les sous-termes de E qui sont dans E .
Définition 35 (Cloture(E)))
Soit E un ensemble de termes. Nous notons :
Rproto
Cloture(E) = (E) ∩ E
Nous définissons aussi, pour un ensemble de termes valeurs E, les termes dont la valeur ne peut
pas être inférée à partir d’autres termes de E.
Définition 36 (termes testables dans E)

Soit E un ensemble de termes valeurs, et t ∈ (E). Le terme t est dit testable dans E si
t ∈≡ −1 Cloture(E). L’ensemble des termes testables dans E est noté Test(E).
Les sous-termes t testables d’un ensemble E sont donc ceux qui peuvent ou dont l’inverse peut
être déduit de E. Cette deuxième condition peut être remplie en chiffrant une constante a par t
puis en déchiffrant le résultat en utilisant l’inverse supposé s de t. Si cette procédure permet de
retrouver a, alors s est bien l’inverse de t.
5.5.2 Construction d’une représentation des connaissances

5.5.2.i Motivation
Hypothèse d’analyse complète. Le traitement des connaissances par un rôle n’est pas spécifiée
par un scénario de réception/envoi de messages. Il nous faut donc faire des hypothèses sur la
manière dont les rôles relient les connaissances qu’ils ont apprises au cours d’une exécution. Nous
supposons que les rôles essayent toujours d’analyser au maximum les connaissances. Autrement
dit, nous considérons qu’un rôle connaissant un ensemble E de termes calcule toujours Cloture(E)
et vérifie autant que possible les relations possibles entre les termes de Cloture(E).
Construction des relations entre les termes de Cloture(E). Nous allons construire un en-
semble de relations liant les termes de Cloture(E) par le biais d’une procédure non déterministe.
Schématiquement, cette procédure consiste à partir d’un ensemble vide de relation, et à construire,
pour chaque terme t de Cloture(E), une relation non triviale avec les autres termes de Cloture(E).
Nous donnons quatre sous-procédures, une pour chacun des constructeurs ⊕({ }),Exp( , ) et
p,rsa
{} , et la quatrième pour les constructeurs libres. Chaque procédure ne modifie la relation
que pour les f -termes de Cloture(E). Soit X E un ensemble de variables indexées par les éléments
testables dans E. L’absence de relation entre les termes de Cloture(E) est modélisée par une
fonction :
δ0 : Test(E) → X E
t 7→ xt
La fonction δ construisant un ensemble de relations entre les termes est construite au moyen de
l’algorithme des figures 5.4 à 5.7.
5.5.2.ii Problème de la construction d’une relation et opérateurs non syntaxiques

Exemple introductif. Les opérateurs dont la théorie est non vide, par exemple le ⊕({ }),
posent un problème lors de la construction d’une relation entre les données, qui est l’absence
de représentation canonique a priori des valeurs possibles. Considérons l’exemple :
E = Cloture(E) = {a, b, c, d, ⊕({a, b}), ⊕({c, d}), ⊕({a, c}), ⊕({b, d}), ⊕({b, c, d}), ⊕({a, b, c, d})}
La représentation la plus simple de cet ensemble est :
δE (E) = {xa , xb , xc , xd , ⊕({xa , xb }), ⊕({xc , xd }),

⊕({xa , xc }), ⊕({xb , xd }), ⊕({xb , xc , xd }), ⊕({xa , xb , xc , xd })}
Cependant, le résultat de la première boucle de l’algorithme de la figure 5.7 appliquée aux ⊕-termes
pourrait être :
δE (E) = {xa , xb , xc , xd , ⊕({xa , xb }), ⊕({xc , xd }),

x⊕({a,c}) , x⊕({b,d}) , ⊕( xc , x⊕({b,d}) ), ⊕( x⊕({a,c}) , x⊕({b,d}) )}
Dans cette représentation, par exemple, nous avons perdu qu’il était possible d’obtenir a à partir
de ⊕({b, c, d}) et ⊕({a, b, c, d}). Le même type de problème se pose pour les opérateurs Exp( , ) et
p,rsa
{} . Dans la suite, nous donnons quatre algorithmes permettant de représenter des f -termes de
p,rsa
Cloture(E ∪F ), un pour f constructeur libre, et un pour chaque cas g ∈ {⊕({ }), Exp( , ), { } }.
Le cas des termes testables est traité dans l’algorithme 5.7 via la traitement de l’opérateur −1 .
Construction de la représentation pour les ⊕-termes. L’ensemble E est fini. Dans l’algo-
rithme de la figure 5.4, nous simplifions les notations en assimilant un terme t à sa représentation
dans l’espace vectoriel IF F
2.
La base B peut être construite en utilisant le théorème de la base incomplète à partir de Mb .
L’inclusion B ⊆ M est possible car M est un ensemble générateur de hM i par construction. Elle
implique que tout élément de la base B est dans Cloture(E), et est donc un sous-terme de E.
Notons enfin que δ⊕ (t) 6= δ0 (t) implique que t est un ⊕-terme par le choix de la base.
Construction de la représentation pour les Exp( , )-termes. Nous avons vu dans le cha-
pitre 3 que les Exp( , )-termes d’une même base ont une structure de module sur . La difficulté
réside ici dans le fait que les facteurs des Exp( , )-termes (l’équivalent de M⊕ dans le cas de
l’opérateur ⊕) et les termes de Cloture(E) servant à les simplifier (les termes de Mb dans le cas
de l’opérateur ⊕) ne jouent pas les mêmes rôles. Il n’est pas possible de faire la somme de deux
facteurs, par exemple.
Pour chaque terme u qui est base d’un Exp( , )-terme t, nous considérons :
[
soit F = Facteur⊕ (t)
 t ⊕−terme de Cloture(E)
 M⊕ = {t ∈ Cloture(E) | t ⊕ −terme}
soit Mb = {t ∈ Cloture(E) | t ∈ F }
M = M ⊕ ∪ Mb

soit hM i le sous-espace vectoriel de IF F 2 engendré par M .
soit B une base de hM i avec Mb ⊆ B ⊆ M .
pour tout t ∈ M⊕ faire
si t ∈ B, alors
δ⊕ (t) = δ0 (t)
sinon, soit t = p⊕({b1 , . . . , bk })q l’écriture de t dans la base B
(k > 1) alors
δ⊕ (t) = ⊕({δ0 (b1 ), . . . , δ0 (bk )})
finsi
finfaire
Fig. 5.4 – Algorithme de construction de la fonction δ pour les ⊕-termes.
– l’ensemble Fu des facteurs (multi-ensembles généralisés) des termes de Cloture(E) de base

u. Par convention, si u ∈ Cloture(E), Fu contient le multi-ensemble généralisé O de support
vide ;
– l’ensemble :
Mu = {t ∈ Cloture(E) | ∃M ∈ Fu , t ∈ (M)}
et la relation d’équivalence ≡Mu sur Fu :
M ≡Mu M0 si et seulement si (M − M0 ) ⊆ Mu
L’algorithme de représentation des Exp( , ) termes est exposé dans la figure 5.5. Il est plus
complexe que dans le cas de l’opérateur ⊕ car les facteurs peuvent aussi être des Exp( , )-termes.
Notons que δExp (t) 6= δ0 (t) implique, là encore, que t est un Exp( , )-terme.
p,rsa
Construction de la représentation pour les { } termes. La construction de la représentation
p,rsa
des connaissances dans le cas de l’opérateur { } est très proche de celle dans le cas de l’opérateur
Exp( , ). Les deux seules différences sont :
– les termes de Mu sont choisis modulo la relation d’équivalence ≡ −1 ;
– pour les termes de base u, la relation ≡Mu n’est pas, en général, une relation d’équivalence.
Elle est réflexive et transitive, mais pas symétrique, car seules des combinaisons linéaires
positives peuvent être prises en compte.
p,rsa
Soit u une base de { } -termes fixée. Nous considérons donc, pour un facteur M de Fu , l’ensemble
H(M) des facteurs M’ de Mu tels que le support de Add(M0 , Opp(M)) soit inclus dans Mu . Nous
disons qu’un multi-ensemble M est maximal si M ∈ H(M0 ) implique M0 ∈ H(M). Nous notons
enfin Hu,max un ensemble de cardinal minimal de maximaux parmi Fu tel que, pour tout M0 dans
Mu , il existe M dans Hu,max tel que M0 ∈ H(M). L’algorithme de construction de la représentation
p,rsa
pour les { } -termes est donné dans la figure 5.6.
Notons que δRsa (t) 6= δ0 (t) implique, là encore, que t est un Exp( , )-terme.
5.5.2.iii Construction de la représentation des termes syntaxiques.

La représentation des termes dont l’opérateur de tête est syntaxique est beaucoup plus simple
et déterministe. Nous ordonnons arbitrairement les f -termes de Cloture(E), avec :
p,rsa
/ {⊕({ }), Exp( , ), { }
f∈ }
La procédure est donnée dans la figure 5.7.

soit δ0 la fonction de représentation des connaissances avant le trai-

tement des Exp( , )-termes.
soit B = ∅
pour tout t Exp( , )-terme dans Cloture(E ∪ F ) faire
B = B ∪ BaseExp( , ) (t)
finfaire
pour tout u ∈ B faire
Calculer Fu , Mu et les classes d’équivalences de ≡Mu .
finfaire
pour tout R classe d’équivalence faire
si 0 ∈ R alors
pour tout M ∈ R faire
σ = [xExp(u,M) ← Exp(δi (u), M ◦ δi )]
δi+1 = δi σ
i=i+1
finfaire
sinon
choisir M ∈ R.
soit x = xExp(u,M) .
pour tout M0 ∈ R faire
M00 = M0 − M
σ = [xExp(u,M0 ) ← Exp(x, M00 δi )]
δi+1 = δi σ
i=i+1
finfaire
finsi
finfaire
δExp = δi
Fig. 5.5 – Algorithme de construction de la fonction δ pour les Exp-termes.
5.5.2.iv Représentation d’un ensemble E à partir d’un ensemble F

Pour un ensemble E, la fonction définie sur Test(E) obtenue en composant les fonctions δ⊕ ,
δExp , δRsa et δLibre calculées par les algorithmes des figures 5.4, 5.5, 5.6 et 5.7 est notée δE .
Notons les propriétés suivantes :
– le système de règles a été limité pour que les règles de composition aient la forme demandée ;
– s’il n’y a pas de règles de composition permettant de construire un terme ti , et si ti est
p
décomposable, alors ti est nécessairement un { } -terme ;
Définition 37 (Représentation)
Soient E et F deux ensembles de termes. Avec les notations précédentes, la représentation de E
à partir de F , notée Repres(E, F ), est l’ensemble :
Repres(E, F ) = δE∪F (E)
Les deux lemmes suivants permettent de caractériser les variables dans les représentations.
Lemme 7
Rproto
Soient E et F deux ensembles de termes, δE∪F , et soit t ∈ Cloture(E ∪ F ) tel que t ∈ F .
Alors :
Var(δE∪F (t)) ⊆ Var(δE∪F (F ))
Preuve. Soit D une dérivation bien formée partant de F de but t :
D : F = F0 → . . . → Fn 3 t
soit δ0 la fonction de représentation des connaissances avant le trai-

p,rsa
tement des { } -termes.
soit B = ∅
p,rsa
pour tout t { } -terme dans Cloture(E ∪ F )
faire
B = B ∪ Base{ }p,rsa (t)
finfaire
pour tout u ∈ B faire
Calculer Fu , Mu et Hu,max
finfaire
pour tout M ∈ Hu,max faire
si 0 ∈ H(M) alors
pour tout M0 ∈ H(M) faire
p,rsa
σ = [x{u}p,rsa
M
← {δi (u)}M◦δi ]
δi+1 = δi σ
i=i+1
finfaire
sinon
soit x = x{u}p,rsa
M
.
pour tout M0 ∈ H(M) \ {M} faire
M00 = M0 − M
p,rsa
σ = [x{u}p,rsa ← {x}M00 δi ]
M0
δi+1 = δi σ
i=i+1
finfaire
finsi
finfaire
δRsa = δi
p,rsa
Fig. 5.6 – Algorithme de construction de la fonction δ pour les { } -termes.
soit t1 , . . . , tn les termes de Cloture(E) dont le symbole de tête est

syntaxique.
pour i de 1 à n faire
cas pour ti
−1
– si ti = t0 :
−1
σi = [xti ← δi−1 (t0 ) ]
– s’il existe Fi → Rc,proto ti avec Fi ⊆ Cloture(E) :
on a Fi = u1 , . . . , uk et t = f (u1 , . . . , uk )
σi = [xti ← f (δi−1 (u1 ), . . . , δi−1 (uk ))]
p
– sinon, et si ti = {a}b et ti décomposable :
p
σi = [xti ← {δi−1 (a)}δi−1 (b) ]
fincas
pour tout t ∈ Cloture(E) : δi (t) = pδi−1 (t)σi q
finfaire
δLibre = δn
Fig. 5.7 – Algorithme de construction de la fonction δ pour les opérateurs syntaxiques.
Montrons par récurrence sur i que pour tout i ∈ {0, . . . , n} :
Var(δE∪F (Fi )) = Var(δE∪F (F ))
C’est vrai par définition pour i = 0. Supposons que Var(δE∪F (Fi )) = Var(δE∪F (F )), et soit
ti+1 = Fi+1 \ Fi . Soit f le constructeur tel que la transition Li → ti+1 appliquée est une f -règle.
Il suffit de montrer :
(A) Var(δE∪F (ti+1 )) ⊆ Var(δE∪F (Li ))
Raisonnons par cas sur f :

– si f est un constructeur libre, alors si la règle est une règle de composition, le résultat vient
de la construction de δE∪F (ti+1 ), et si c’est une règle de décomposition, alors :
– si le terme décomposé di peut être composé, δE∪F (ti+1 ) est un sous-terme de δE∪F (di ),
p
– sinon, alors nécessairement f = { } , et le résultat vient de la construction de δE∪F (di ) ;
– si f = ⊕, la construction à partir d’une base implique que les facteurs de δE∪F (ti+1 ) sont
inclus dans l’union des facteurs de δE∪F (Li ), ce qui implique (A) ;
– si f = Exp( , ), et que la règle est une règle de composition, alors soit la base di de ti+1 est
dans Li , soit il existe dans Li un terme di dans la même classe que ti+1 . Dans les deux cas,
l’inclusion (A) est bien vérifiée. Si la règle est une règle de décomposition, alors ti+1 est la
base du terme di = Exp(ti+1 , Mi ) de Li et dans ce cas la règle s’écrit :
di , (Mi ) → ti+1
L’inclusion (A) est alors vraie par définition de δE∪F (di ) dans ce cas ;
p,rsa
– le même raisonnement vaut pour f = { } .
Donc (A) est vraie pour tout i, ce qui prouve le lemme.
Le lemme suivant est une conséquence directe du lemme 7.
Lemme 8
Soient E et F deux ensembles de termes, δE∪F , et soit t ∈ Cloture(E ∪ F ) tel que :
xt ∈ Var(δE∪F (E)) \ Var(δE∪F (F ))

Rproto
Alors, t ∈
/F .
Rproto
Preuve. Si t ∈ F , alors le lemme 7 peut être appliqué : xt ∈ Var(δE∪F (F )).
Rproto
Hypothèse de monotonie. Soient E un ensemble et t un terme. Si t ∈ E , nous supposons
toujours que :
δE∪{t} (E) = δE (E)
Notons que par le lemme 7, cette hypothèse ne perd pas en généralité.
5.5.3 Construction des règles de réception/envoi

5.5.3.i Définition
Dans cette section, nous considérons un protocole P écrit en notation Alice et Bob, avec une
suite de messages (i. Si → Ri : Mi )i∈{1,...,n} . Tout d’abord, définissons la représentation de ses
connaissances par un rôle à l’étape i. Cette représentation correspond
Définition 38 (Mémoire d’un rôle)

Soit P un protocole, et A un rôle de P . L’état de la mémoire de A à l’étape i, noté Conn(A, i), est
défini par :
Repres(Mem(A, i − 1), {Si , Mi }) si A = Ri
Conn(A, i) =
Repres(Mem(A, i), ∅) sinon
Le filtre pour accepter le message Attendu(i) attendu par le rôle Ri à l’étape i s’écrit alors :
Définition 39 (Filtre pour le message attendu)

Nous définissons le message attendu par le rôle Ri à l’étape i par :
Attendu(i) = Repres(Mi , Mem(A, i − 1))

Remarquons que, par définition, pour toute étape i :
Var(Conn(Si , i)) = Var(Conn(Si , i − 1)) ∪ Var(Attendu(i − 1))
Le message envoyé par le rôle Si à l’étape i est défini de la façon suivante.
Définition 40 (Filtre pour le message envoyé)

Nous définissons le message émis par le rôle Si à l’étape i par :
Composer(i) = Repres(Mi , Mem(Si , i))
Le lemme suivant porte sur les résultats de deux calculs indépendants, et repose donc sur
l’hypothèse de monotonie. Il permet de caractériser les occurrences des variables dans les règles de
réception/envoi de messages.
Lemme 9
Avec les notations précédentes, si P est exécutable, alors pour tout i ∈ {1, . . . , n} :
Var(Composer(i)) ⊆ Var(Conn(Si , i))

Preuve. P est exécutable, donc pour tout i ∈ {1, . . . , n} :
Rproto
Mi ∈ Mem(Si , i)
Par contradiction, soit xt ∈ Var(Composer(i)) \ Var(Conn(Si , i)). Par l’hypothèse de monotonie,

xt ∈
/ Var(Conn(Si , i)) implique :
xt ∈
/ Var(δMem(Si ,i)∪{Mi } (Mem(Si , i)))
et donc :
Var(δM emoire(Si ,i)∪{Mi } (Mi )) 6⊆ Var(δM emoire(Si ,i)∪{Mi } (Mem(Si , i)))
Rproto
Le lemme 7 implique alors Mi ∈
/ M emoire(Si , i) , ce qui contredit l’exécutabilité du protocole.

Sur les émetteurs de messages attendus et destinataires de messages envoyés. Formel-

lement, les émetteurs des messages devraient aussi être pris en compte dans le calcul de la fonction
Attendu, et le destinataire devrait l’être dans celui de la fonction Composer. Nous ne les avons
pas définies ainsi uniquement dans le but de simplifier la présentation, les noms des émetteurs
et destinataires pouvant être ajoutés dans le corps des messages. Notons que ne pas prendre en
compte ces noms peut aboutir à la « découverte » d’erreurs artificielles, par exemple celle sur la
correction du protocole de R. Needham et M. Schroeder par G. Lowe [67].
5.5.4 Règles de réception/envoi de message

5.5.4.i Exemple de compilation d’un protocole
Prenons l’exemple du protocole suivant :
1. A → B : {M }K
2. B → C : Exp(B, {N b})
3. C → B : {K}(Exp(B, {N b, C}))
4. B → A : M
Fig. 5.8 – Protocole jouet

Connaissances. Les ensembles de connaissances des rôles, à chaque étape, sont les suivants :
a) Conn(A, i) = {xM , xK , xA , xB } pour i ∈ {0, . . . , 4} ;
b) – Conn(B, 0) = Conn(B,
1) = {xB , xA , xC , xNb } ,
– Conn(B, 2) = xB , xA , xC , xNb , x{M }K
s
– Conn(B, 3) = xB , xA , xC , xNb , {xM }xK ,
n o
s s
– Conn(B, 4) = xB , xA , xC , xNb , {xM }xK , {xK }Exp(xB ,{xN b ,xC }) ;
c) – Conn(C, 0) = Conn(C, 1) =Conn(C2 ) = {xC , xB , xK },
– Conn(C, 3) = Conn(C4 ) = xC , xB , xK , xExp(B,{N b}) .
Messages attendus. Les messages attendus sont déduit de la liste des connaissances de chaque
rôle :
1. Attendu(1) = x{M }K ;
2. Attendu(2) = xExp(B,{N b}) ;
s
3. Attendu(3) = {xK }Exp(xB ,{xN b ,xC }) ;
4. Attendu(4) = xM .
Messages envoyés. Enfin, les valeurs de la fonction Composer sont :

s
1. Composer(1) = {xM }xK ;
2. Composer(2) = Exp(xB , {xNb }) ;
s
3. Composer(3) = {xK }Exp(xExp(B,{N b}) ,{xC }) ;
4. Composer(4) = xM .
5.5.4.ii Règles produites par le compilateur.

Nous appelons règles générales les règles en sortie du compilateur CasRul. Ces règles modélisent
les actions de réception et d’envoi de messages des acteurs participant au protocole indépendamment
de l’environnement d’exécution, c’est-à-dire du modèle de l’intrus. Les hypothèses d’indépendance
de contrôle impliquent que ces règles ne dépendent que des connaissances symboliques des rôles et
de l’étape courante.
Ces règles générales sont basées sur les fonctions Attendu, Composer et Conn. Nous rappelons
que ce sont les règles générées par le compilateur CasRul. Elles sont de la forme :
m(xinc , xSi , xRi , Attendu(i)) · w(i, [Conn(Ri , i)]) ⇒

m(xRi , xRi , xRi+1 , Composer(i)) · w(i0 , [Conn(Ri , i + 1)])
pour les règles de réception/envoi de message. Si la règle est celle initiant une session, il n’y a pas
de m-terme dans le membre gauche, et si il s’agit de celle concluant une session, il n’y a pas de
m-terme dans le membre droit. La constante i0 correspond à l’étape suivante de réception d’un
message pour ce rôle si elle existe, et à l’étape de première réception d’un message sinon. Par
convention, l’étape de première réception d’un message est, pour le rôle initiateur du protocole,
l’étape 0.
La liste [Conn(Ri , i)] contient les termes de l’ensemble Conn(Ri , i).
En rassemblant le résultat du lemme 9 et la remarque suivant la définition de Attendu, nous
avons la proposition suivante.
Proposition 33 Pour toute règle générale R ⇒ S, on a Var(S) ⊆ Var(R)
Plus précisément, l’égalité est vérifiée au sein d’une exécution du protocole, et est en général
stricte lors du passage d’une session à la suivante à cause de l’oubli des connaissances de la session
courante.
Pour le protocole de la figure 5.8, les règles des rôles en sortie du compilateur CasRul sont
données dans la figure 5.9.
Message 0 :
w(0, [xM , xK , xA , xB ]) ⇒
s
m(xA , xA , xB , {xM }xK ) · w(4, [xM , xK , xA , xB ])
Message 1 :
m(xinc , xA , xB , x{M }K ) · w(1, [xB , xA , xC , xNb ]) ⇒
m(xB , xB , xC , Exp(xB , {xNb })) · w(3, [xB , xA , xC , xNb , x{M }K ])
Message 2 :
m(xB , xB , xC , xExp(B,{N b}) ) · w(2, [xinc , xB , xK ]) ⇒
s
m(xC , xC , xB , {xK }Exp(xExp(B,{N b}) ,{xC }) ) · w(2, [xC , xB , xK ])
Message 3 :
s s
m(xinc , xC , xB , {xK }Exp(xB ,{xN b ,xC }) ) · w(3, [xB , xA , xC , xNb , {xM }xK ]) ⇒
m(xB , xB , xA , xM ) · w(1, [xB , xA , x0Nb ])
Message 4 :
m(xinc , xB , xA , xM ) · w(4, [xM , xK , xA , xB ]) ⇒
w(0, [x0M , xK , xA , xB ])
Fig. 5.9 – Règles en sortie du compilateur CasRul
Remarques sur les règles générales.
a) Tout d’abord, les termes w en partie droite de la règle du message 1. et en partie gauche
du message 3. sont différents. Lorsque la première est utilisée, un acteur jouant le rôle B
accepte n’importe quel message m tel qu’il existe une substitution σ1 avec x{M }K σ1 = m,
c’est-à-dire n’importe quel message. Le message reçu est « stocké » dans les connaissances de
B. La règle du message 3. ne pourra être appliquée que s’il existe une substitution σ2 telle
que m = ({xM }xK )σ2 ;
b) la valeur de la variable xinc dépend des capacités de l’intrus. Si celui-ci a la capacité ea-
ves dropping, c’est une variable ayant une seule occurrence dans la règle. Sinon, il s’agit
d’une nouvelle occurrence de la variable en deuxième position du terme m : le receveur peut
vérifier que l’émetteur officiel est l’émetteur réel du message ;
c) il y a des différences mineures entre les règles données plus haut et celles en sortie du com-
pilateur CasRul :
– la première est la présence, dans le terme w, d’un argument supplémentaire représentant
un numéro de session. Cet identifiant sert à différencier des exécutions différentes d’un
même rôle par un même acteur,
– une autre différence est l’ajout d’un terme permettant d’assurer la fraı̂cheur des nonces
utilisés par les principaux. Lorsqu’un acteur se prépare à commencer une nouvelle session,
nous avons noté dans ses connaissances x0 une variable prenant une valeur différente de
toutes celles apparues jusque là dans l’exécution du protocole,
– enfin, les nonces ne sont pas présents dans l’état d’un rôle se préparant à exécuter une
session du protocole ; ils sont ajoutés au fur et à mesure de leur utilisation. Le lecteur peut
se référer à [56] et [23] pour une description plus précise de ces règles ;
5.5.4.iii Règles spécialisées pour l’intrus de D. Dolev et A. Yao

Soit (Xi , σi )i∈{1,...,k},Xi ∈{A,B,C} une instance du protocole. Les règles optimisées pour l’intrus
de D. Dolev et A. Yao, pour le receveur Xi du message j, sont de la forme :
Attendu(j)σi ⇒ Composer(j)σi
Ces règles ne permettent pas d’exprimer la décomposition de connaissances acquises antérieurement,

pour la variable x{M }K , par exemple. En effet, rien ne relie, a priori, cette variable aux variables
xM et xK . Il est donc nécessaire soit de supposer qu’un mécanisme, lors de l’application de ces
règles, va permettre de faire cette connexion, soit qu’un autre mécanisme permet de se passer de la
décomposition des connaissances acquises avant le dernier message. Cette deuxième solution, plus
simple à nos yeux, a été choisie, et est détaillée dans la partie 5.5.5.ii. de la sous-section suivante.
5.5.5 Hypothèses sur les protocoles étudiés

En dehors de ce chapitre, nous étudions des instances de protocoles spécifiées par un ensemble
de règles spécialisées. Afin de simplifier l’étude de ces protocoles, nous allons faire des hypothèses
sur la spécification haut niveau d’un protocole pour assurer que les ensembles de règles que nous
étudierons auront de « bonnes » propriétés. Nous donnons ces hypothèses dans le reste de cette
sous-section, en indiquant pourquoi elles conservent les exécutions d’un protocole et les attaques
en présence d’un intrus ayant les capacités d’un intrus de D. Dolev et A. Yao.
5.5.5.i Décomposition de connaissances antérieures

Reprenons l’exemple, en le complétant, du protocole de la figure 5.3.
1. A → B : {M }K
2. B → A : B
3. A → B : K
4. B → A : M
En supposant que les connaissances initiales de B sont A et B, la représentation de ses connaissances
par ce rôle est :
– Conn(B, 1) = Conn(B, 0) = {x A , xB }
– Conn(B, 3) = Conn(B, 2) = xA , xB , x{M }sK
– Conn(B, 4) = {xA , xB , xM , xK }
Remarquons que dans ce protocole, la propriété :
∀i, j ∈ {1, . . . , n} , i < j ⇒ Var(Conn(B, i)) ⊆ Var(Conn(B, j))
n’est pas vérifiée. En effet, à chaque étape, un rôle redécompose toutes ses anciennes connais-
sances. Cependant, quitte à transformer le protocole, il est possible de supposer que les anciennes
connaissances ne sont pas décomposées par le rôle. Pour cela, considérons une nouvelle version de
ce protocole, dans laquelle une clef symétrique Kd est ajoutée dans les connaissances initiales du
rôle B :
1. A → B : {M }K
2. B → A : B, {{M }K}Kd
3. A → B : {{M }K}Kd , K
4. B → A : M
Si le rôle B ne décompose pas ses anciennes connaissances on a, dans ce protocole :
– Conn(B, 1) = Conn(B, 0) = {x A , xB , xKd }
– Conn(B, 3) = Conn(B, 2) = xA , xB , x{M }sK , xKd

– Conn(B, 4) = xA , xB , xM , xK , x{M }sK , {{xM }xK }xKd , xKd
L’ensemble des variables dans les ensembles de connaissances devient donc croissant. Dans le cas
de règles générales, la décomposition de connaissances antérieures ne pose pas de problèmes : si
le message envoyé par l’intrus à l’étape 1. n’est pas de la forme {xM }xK , il ne sera pas possible
d’appliquer la règle de réception du message 4. Dans le cas des règles spécialisées pour l’intrus de
D. Dolev et A. Yao, la décomposition des messages antérieurs pose problème car il faudra alors
prévoir plusieurs règles, exclusives les unes des autres, pour le cas où l’intrus envoie le message 1.
puis le message 4., ou uniquement le message 1. Afin de ne pas avoir à considérer ces différents cas,
nous supposons que les règles du protocole sont telles qu’un rôle n’a jamais besoin de décomposer
ses connaissances antérieures :
Hypothèse de non décomposition :

À toute étape du protocole, les connaissances d’un rôle sont formées de ses
connaissances antérieures et de la décomposition maximale du message qu’il
vient de recevoir.
Sous cette hypothèse, l’ensemble des connaissances d’un rôle est défini par :
Conn(A, i)
=
Conn(A, i − 1) si A 6= Si
Conn(A, i − 1) ∪ Repres({Si−1 , Mi−1 } , Mem(A, i − 1)) si A = Si
Avec cette définition, et par définition de Attendu(i) :
Var(Conn(A, i)) = Var(Conn(A, i − 1)) ∪ Var(Attendu(i − 1))
Cette hypothèse permet donc d’« importer » une propriété des règles générales dans les règles
optimisées, ce qu’indique la proposition suivante. Elle joue le même rôle vis-à-vis de la fonction
Attendu que l’hypothèse de monotonie vis-à-vis de la fonction Composer. Remarquons enfin que
cette hypothèse ne perd pas en généralité vis-à-vis des protocoles étudiés tant qu’il est accepté
d’ajouter de nouvelles règles permettant la décomposition de connaissances antérieures.
Proposition 34
Soit ({Rι ⇒ Sι }ι∈I , <I , S0 ) une instance d’un protocole. Alors pour tout ι ∈ I, pour toute variable
x ∈ Var(Sι ), il existe ι0 ≤I ι tel que x ∈ Var(R0ι ).
Preuve. Soit ι ∈ I et x ∈ Var(Sι ). Soit B un rôle et σ une substitution tels que Rι ⇒ Sι soit dans
l’instance σ du rôle B. Par le lemme 9 et par induction, x ∈ Var(Sι ) implique soit x ∈ Var(Rι0 )
pour un ι0 ≤ I ι, soit x est dans Conn(B, 0). On en conclut Var(Conn(B, 0)σ) = ∅, ce qui prouve le
lemme.
5.5.5.ii Ordre de décomposition des messages attendus

Informellement, le calcul par un rôle de Cloture(E) à partir d’un ensemble E peut se modéliser
par une dérivation bien formée partant de E et arrivant en Cloture(E). Cette dérivation induit
un ordre sur les termes appris et donc, dans la représentation des connaissances δE (E), sur les
variables. Pour prendre en compte cet ordre, l’approche directe serait de choisir une dérivation D
parmi celles possibles, et de donner, en même temps que les règles de réception/composition de
messages, un ordre total sur les variables. Cette approche est techniquement sûre, mais lourde à
mettre en œuvre. Nous décrivons maintenant une autre manière d’ordonner les variables, qui est
d’ajouter de nouveaux messages de type :
Ri ⇒ Si
à la spécification du protocole, et de prendre comme ordre sur les variables l’ordre de première
« apparition » d’une variable dans le membre gauche d’une règle. Notre but est de transformer les
règles d’un protocole pour que la restriction suivante soit vraie :
Hypothèse de bon ordre de décomposition :

Soit Gi = Mem(Ri , i) ∪ {Mi }, la fonction de représentation δ = δGi et
F ∪ {d, t} ⊆ Test(Gi ).
Pour toute règle de décomposition δ(d), δ(F ) → δ(t) décomposant
un terme δ(d) qui n’est pas une ⊕({ })-règle ou telle que Var(ti ) 6⊆
Var(Conn(Ri , i)) :
Var(δMem(Ri ,i)∪Mi (F )) ⊆ Var(Conn(Ri , i))
Nous indiquons une méthode pour construire une version d’un protocole ayant des règles de
cette forme en partant de la spécification du protocole. Pour un rôle ayant les connaissances K,
recevant un message M et dont la fonction de représentation des connaissances est δ :
– soit d1 , . . . , dn les sous-termes de δ(M ) qui sont décomposés par une règle di , Fi → ti avec
Var(δ(Fi )) 6⊆ Var(δ(K)) ;
– choisir de nouvelles variables z1 , . . . , zn et de nouvelles clefs symétriques K1 , . . . , Kn ;
– Soit m le message δ(M ) dans lequel les di sont remplacés par des zi et, pour i ∈ {1, . . . , n},
soit d0i le terme di dans lequel les termes di+1 , . . . , dn sont remplacés par les variables
zi+1 , . . . , zn . En utilisant ces notations, nous remplaçons la règle :
δ(M ) ⇒ S
par les règles :

s s
m ⇒ {z1 }xK , . . . , {zn }xK
1 n
s
{d01 }xK ⇒ ∅
1
...
s
{d0n }xK ⇒ S
n
L’opérateur ⊕({ }) est traité à part, car dès qu’un ⊕({ })-terme t contient une variable nouvelle,
le terme ne vérifie plus l’hypothèse standard. Cela implique que le remplacement progressif n’est
plus possible. Considérons par exemple un rôle connaissant A et recevant A ⊕ B. Après calcul, le
message attendu est :
⊕({xA , xB })
et il existe une règle de décomposition :
⊕({A, B}), B → A
Essayons d’appliquer la construction précédente. Après calcul, on trouve :

s
xX1 ⇒ {xX1 }xK
1
s
{⊕({xA , xB })}xK & ⇒ ...
1
Le deuxième message ne vérifie toujours pas l’hypothèse de bon ordre de décomposition. Le

problème vient du fait que le résultat d’une règle de décomposition peut toujours servir de clef. Le
relâchement sur l’hypothèse dans le cas de l’opérateur ⊕({ }) a été choisi car il est suffisant pour
qu’un protocole vérifiant l’hypothèse de bon ordre de décomposition puisse être construit.
Donnons un exemple de cette construction sur le protocole suivant, avec comme connaissances
initiales de A et B leur nom respectif, et X un nonce créé par A :
s
1. A → B : ⊕({hX, Bi , A}), {X}⊕({hX,Bi,A})
2. B → A : B
3. A → B : A
Les connaissances de B sont :

– initialement :
F0 = {A, B}
– au moment de la réception du premier message :
n o
s
F1 = A, B, ⊕({hX, Bi , A}), {X}⊕({hX,Bi,A})
Après calcul, la clôture de F1 est :

n o
s
Cloture(F1 ) = A, B, ⊕({hX, Bi , A}), {X}⊕({hX,Bi,A}) , hX, Bi , X
Les règles de décomposition applicables sont :

⊕({hX, Bi , A}), hX, Bi → A
⊕({hX, Bi , A}), A → hX, Bi
s
{X}⊕({hX,Bi,A}) , ⊕({hX, Bi , A}) → X
hX, Bi → X
hX, Bi → B
Calculons maintenant la représentation de ses connaissances et du message attendu par B :

(
Conn(B, 1)n= δF1 (F0 ) = {xA , xB } o
s
δF1 (F1 ) = xA , xB , ⊕({hxX , xB i , xA }), {xX }⊕({hxX ,xB i,xA })
Parmi ces règles de décompositions, celles ne vérifiant pas l’hypothèse de bon ordre de décomposition
sont :
⊕({hX, Bi , A}), hX, Bi → A
s
{X}⊕({hX,Bi,A}) , ⊕({hX, Bi , A}) → X
Posons alors :
X1 = ⊕({hX, Bi , A})
s
X2 = {X}⊕({hX,Bi,A})
S’il est décidé que X1 doit être envoyé avant X2 , les règles du protocole deviennent :
s s
xX1 , xX2 ⇒ {xX1 }xK , {xX1 }xK
1 2
s
{⊕({hxX , xB i , xA })}xK ⇒ ∅
n os 1
s
{xX }⊕({hxX ,xB i,xA }) ⇒ xB
xK2
xA ⇒ ∅
Si au contraire il est décidé que X2 doit être envoyé avant X1 , le protocole devient :
s s
xX1 , xX2 ⇒ {xX1 }xK , {xX1 }xK
1 2
s s
{xX }X1 x ⇒ ∅
K2
s
{⊕({hxX , xB i , xA })}xK ⇒ xB
1
xA ⇒ ∅
Intuitivement, l’hypothèse de bon ordre de composition consiste à révéler au rôle le message

qu’il attend morceau par morceau. Nous ne le montrons pas (les attaques ne sont pas encore
formellement définies), mais la construction donnée permet d’assurer que les messages que peut
recevoir le rôle ne dépendent pas de cette hypothèse.
5.5.6 Variables dans les règles de messages

5.5.6.i Motivation
Pour une instance de protocole ({Rι ⇒ Sι }ι∈I , <I , S0 ), nous avons déjà vu (proposition 34)
que les occurrences des variables, dans les règles, étaient ordonnées. Une variable apparaı̂t toujours
dans le membre gauche d’une règle avant d’apparaı̂tre dans le membre droit. Dans cette section,
nous donnons d’autres propriétés, liées aux opérations de chiffrement et déchiffrement. Pour obtenir
ces propriétés, nous supposons qu’il n’y a pas de décomposition des connaissances antérieures à
la réception d’un message (voir la section 5.5.5) et que les ensembles de termes F permettant de
décomposer un terme d peuvent être composés à partir des connaissances antérieures à la réception
du message (voir la section 5.5.5, hypothèse de bon ordre de décomposition).
5.5.6.ii Cas des opérateurs de chiffrement

Nous commençons par nous intéresser au cas des constructeurs de chiffrement :
s s,cbc s,ebc p
{ } ,{ } ,{ } ,{ }
pour lesquels une seule clef est utilisée. La proposition suivante indique qu’une variable nouvelle
dans un message M ne peut pas être dans un sous-terme de la clef d’un sous-terme chiffré de M .
Proposition 35
p s
Si f (u1 , u2 ) ∈ (Attendu(i)) et f ∈ {{ } , { } }, alors :
Var(u2 ) ⊆ Var(Conn(Ri , i))
Preuve. Soit G = Mem(Ri , i−1)∪{Mi }, et soit f (t1 , t2 ) le sous-terme de Mi tel que δG (f (t1 , t2 )) =
f (u1 , u2 ). Par construction de δG :
t1 , t2 ∈ Cloture(G)
s
Si f = { } , il existe une règle de décomposition de f (t1 , t2 ), donc Var(u2 ) ⊆ Var(Conn(Ri , i)) par
p −1
l’hypothèse de bon ordre de décomposition. Si f = { } , alors t2 ∈ Cloture(G), et donc t2 = t02
0 −1 0
ou t2 = t2 , t2 est testable dans G. Là encore, par l’hypothèse de bon ordre de décomposition,
l’inclusion Var(u2 ) ⊆ Var(Conn(Ri , i − 1)) est vérifiée.
Cette proposition se généralise immédiatement aux opérateurs de chiffrement de type RSA et

d’exponentiation en remarquant que par construction, il existe toujours une règle décomposant un
de ces termes. La preuve, étant identique, est omise.
Proposition 36
p,rsa
Si f (u1 , M) ∈ (Attendu(i)), f ∈ {{ } , Exp( , )}, et M multi-ensemble ou multi-ensemble
généralisé de termes en forme normale, alors pour tout u2 ∈ (M) :
Var(u2 ) ⊆ Var(Conn(Ri , i))
5.5.6.iii Cas du ou exclusif bit à bit

Le cas du ou exclusif bit à bit se traite de manière similaire. La principale différence est que,
dans le cas d’un terme ⊕({t1 , . . . , tn }), les termes utilisés pour le déchiffrement ne sont pas connus
a priori.
Proposition 37
Soit Mi le message attendu à l’étape i. Si ⊕({u1 , . . . , un }) ∈ (Attendu(i)), alors il existe au
plus un j ∈ {1, . . . , n} tel que Var(uj ) 6⊆ Var(Conn(Ri , i)). De plus, il existe un Facteur⊕ t de Mi
tel que :
uj = δCloture({Mi }∪Mem(Ri ,i−1)) (t)
5.6. Travaux Reliés 95
Preuve. Afin d’alléger les notations, commençons par poser :
Gi = Cloture({Mi } ∪ Mem(Ri , i − 1))
Soient t1 , . . . , tn les termes de Gi tels que, pour tout j ∈ {1, . . . , n}, δGi (tj ) = uj , et soit Ik ⊆
{1, . . . , n} l’ensemble des indices j tels que Var(δGi (tj )) 6⊆ Var(Conn(Ri , i − 1)). Supposons Ik 6= ∅.
Tout d’abord, notons que par construction de δi , pour tout j ∈ {1, . . . , n}, on a tj ∈ Gi .
Supposons sans perte de généralité que t1 ∈ Ik . Il existe donc une règle :
p⊕({t1 , . . . , tk })q, t2 , . . . , tk → t1
Lors de la construction de δGi , si l’image d’un ⊕-terme n’est pas une variable, il s’agit d’une
combinaison d’éléments de la base choisie. Par construction, les éléments de cette base ne peuvent
pas être des ⊕-termes, et donc δGi (t1 ) n’est pas un ⊕-terme. Donc la règle :
p⊕({δGi (t1 ), . . . , δGi (tk )})q, δGi (t2 ), . . . , δGi (tk ) → δGi (t1 )
est une règle de décomposition, donc par l’hypothèse de bon ordre de décomposition :
Var(δGi (t2 ), . . . , δGi (tk )) ⊆ Var(Conn(Ri , i − 1))
et donc Ik = {t1 }.

5.6.1 Le compilateur CasRul
Le processus de compilation décrit dans ce chapitre et dans [56] est partiellement implanté dans
le compilateur CasRul. L’implantation a été faite par l’auteur, en collaboration avec M. Bouallagui,
sur la base d’une première version développée dans l’équipe CASSIS. L’analyse des connaissances
des rôles est faite au travers de fonctions de composition et de décomposition. Une description
détaillée et proche de l’implantation peut être trouvée dans [23] pour la gestion des connaissances
ou dans [56] pour la définition des termes w et m.
Ce compilateur, utilisé dans le cadre du projet AVISS, n’est plus actuellement en cours de
développement. Suite à son succès, le projet AVISS a été reconduit en un projet de 30 mois
par l’Union Européenne, le projet AVISPA4 . Dans le cadre de ce nouveau projet, un nouveau
langage de haut niveau, plus expressif, est utilisé. Le compilateur pour ce langage est en cours de
développement, et une première version stable devrait être disponible en décembre 2003.
5.6.2 Autres compilateurs

Parmi les compilateurs de protocoles, on peut citer Casper [63], qui a été utilisé par G. Lo-
we [42] pour l’analyse de la bibliothèque de protocoles donnée par J. Clark et J. Jacob [26]. Ce
compilateur transforme une suite d’envoi et de réception de messages, pour chaque acteur, en un
processus CSP. Le processus CSP peut ensuite être vérifié par un vérificateur de modèles comme
FDR. L’analyse des connaissances des rôles est réduite, et se résume à un message d’erreur lorsqu’un
rôle n’a pas les connaissances nécessaires pour déchiffrer immédiatement un message reçu.
Un autre langage de description de protocoles, Capsl [35], a été défini au (SRI). Les descriptions
en Capsl sont compilées dans un format intermédiaire, CIL [36]. Le but, comme dans le cas du
compilateur CasRul, est de permettre l’interfaçage d’un plus grand nombre possible d’outils de
vérification. Bien qu’antérieur, le compilateur fourni semble cependant moins avancé que CasRul,
puisqu’il ne gère pas :
1. le typage possible du protocole ;
2. le chiffrement par xor ;
4 http ://www.avispa-project.org/
3. les connaissances des rôles ;

4. les clefs composées.
Cependant, Capsl, dans son évolution µCAPSL [37], permet la description de protocoles de
groupes, ce qui n’est pas encore possible avec CasRul.
Contrairement aux deux outils précédents, pour lesquels les étapes de compilation et de vérification
sont distinctes, Murϕ [74] intègre un compilateur et un vérificateur de modèles. Le langage haut
niveau de définition est comparable au langage Unity [18]. La suite de messages est spécifiée par un
ensemble de commandes gardées, et permet l’emploi de types structurés. Ce langage est beaucoup
plus expressif que les langages précédemment décrits. Il est par exemple possible d’exprimer des
protocoles de groupes tels que Enclaves [52] et de vérifier des propriétés complexes [60].
Troisième partie
Recherche d’attaques
97
6
Stratégie paresseuse de l’intrus

pour la recherche d’attaques sur
un protocole
6.1 Motivations
Dans le cadre de nos travaux, nous avons implanté un algorithme de recherche d’attaques sur les
protocoles cryptographiques qui s’est révélé très efficace en comparaison des autres outils existant.
Contrairement aux outils classiques de validation de modèle, il s’appuie sur une représentation
symbolique des connaissances de l’intrus et des messages que celui-ci a à envoyer.
Dans ce modèle, des contraintes représentant les messages attendus par les principaux sont
construites dynamiquement, et doivent être résolues par l’intrus. Cette résolution à la demande
nous a conduit à qualifier cette stratégie de paresseuse [24]. Elle est beaucoup plus efficace, dans ce
cadre, que la validation de modèle classique car les parties de messages attendus qui peuvent être
remplacées par n’importe quel terme ne sont pas touchées. Les outils de validation de modèle clas-
siques, tels FDR [42], cherchent, dans ce cas, tous les termes acceptables. Considérons le protocole
suivant :
1 . A → B : Na
Un acteur jouant le rôle B accepte a priori n’importe quel message. Un outil comme FDR rem-
placera donc N a par tous les messages que peut composer l’intrus. Comme il y en a un nombre
infini, un typage assure que B peut vérifier, par exemple, qu’il a reçu une constante. Dans ce cas,
Na sera remplacé par toutes les constantes que connaı̂t l’intrus. Le branchement que cette stratégie
implique dans l’algorithme d’exploration des états oblige l’utilisateur à d’abord simplifier le proto-
cole étudié. Ce processus de simplification est long et laborieux, avec le risque de commettre des
erreurs.
Dans notre stratégie paresseuse, le message attendu par B est une variable. Tant qu’un message
attendu est une variable, nous considérons que l’intrus a pu l’envoyer avec succès. Si, au cours de
l’exécution du protocole, une contrainte implique que cette variable doit être, par exemple, le nom
a d’un acteur, il faudra vérifier qu’au moment de l’envoi du message à l’acteur jouant le rôle B,
l’intrus connait déjà ce nom.
Dans ce chapitre, nous montrons que cette résolution retardée des contraintes est complète
vis-à-vis de la recherche d’attaques sur une instance d’un protocole P. Nous montrons aussi qu’elle
permet de construire, pour toute attaque sur le protocole, une attaque plus générale. Cette dernière
propriété permet de chercher de manière paresseuse un ordre d’exécution du protocole pour lequel
il y a une attaque.
Après avoir décrit le cadre de cette étude, restreint par rapport au cas clos, dans les sections 6.2
et 6.3, nous définissons une notion de substitution plus générale (substitution préfixe), et celui
d’ensemble complet de préfixes dans la section 6.4. Nous définissons ensuite un système pour la
représentation symbolique des connaissances de l’intrus et pour les messages qu’il doit envoyer.
99
100 Chapitre 6. Recherche efficace d’attaques
L’intrus devant gérer ses connaissances pour pouvoir effectivement envoyer tous les messages que
l’ordre d’exécution lui impose d’avoir émis, nous appelons ces systèmes des problème de construction
simultanée. Ils sont définis dans la section 6.5.
Ensuite, nous commençons par montrer des équivalences sur les problèmes de constructions
simultanées dans la section 6.6. Celles-ci permettent de définir une fonction de normalisation et de
réduire le non déterminisme des choix de l’intrus. En particulier, il est montré que sous certaines
hypothèses, il est toujours possible de supposer qu’un ensemble de connaissances ne contient pas de
variables. Cette propriété est utilisée pour montrer la terminaison de notre algorithme de résolution
de contraintes dans la section 6.7. Nous montrons ensuite dans la section 6.8 comment ces systèmes
peuvent être utilisés en pratique pour la recherche d’attaques de secret ou d’authentification sur
un protocole. Les expériences que nous avons menées avec le prouveur de théorèmes daTac sont
décrites et discutées dans la section 6.9. Enfin, avant de conclure, nous présentons d’autres travaux
reliés au problème de la résolution de contraintes symboliques dans le cadre de l’étude de protocoles
cryptographiques en section 6.10.
6.2 Cadre de l’étude

Nous nous plaçons dans le cadre de la recherche d’attaques sous l’hypothèse de chiffrement
parfait, et supposons qu’il n’y a qu’un nombre fini de sessions du protocole. Les symboles d’arité
non nulle de la signature F considérée sont dans l’ensemble :
p s
{h , i , { } , { } , H( , )}
Les substitutions jouent un grand rôle dans ce chapitre. Rappelons qu’elles sont des remplace-
ments dont le support est inclus dans le sous-ensemble des variables X de l’ensemble des symboles
de F d’arité nulle. Afin de distinguer les termes contenant des variables de ceux n’en contenant
pas, nous appelons :
– T(F) l’ensemble des termes t sur la signature F tels que (t) ∩ X = ∅ ;
– T(F, X ) l’ensemble des termes t sur la signature F ;
Pour un terme t (resp. un ensemble de termes E), on note Var(t) (resp. Var(E)) l’ensemble (t)∩
X (resp. l’ensemble (E) ∩ X ).
Sur cette signature, les termes opérations sont égaux (modulo un renommage des symboles)
aux termes valeurs. Prenons le point de vue de l’intrus. Ses connaissances sont modélisées par
un sous-ensemble fini E ⊂fini T(F, X ). Il peut déduire de nouveaux faits de ses connaissances en
utilisant le système de règles de réécriture sur des ensembles :
LDY = Lh , i ∪ L{ }s ∪ L{ }p ∪ LH( , )
Nous distinguons les règles de composition des règles de décomposition en posant :

Lc,DY = Lc,h , i ∪ Lc,{ }s ∪ Lc,{ }p ∪ Lc,H( , )
Ld,DY = Ld,h , i ∪ Ld,{ }s ∪ Ld,{ }p
Par le théorème 2 et les propositions, pour chaque opérateur, du chapitre 4, LDY est un système
LDY
local, et donc que pour tout terme t et tout ensemble de connaissances E, t ∈ E implique qu’il
existe une dérivation bien formée partant de E et de but t. Cela est aussi vrai si seul le système
Lc,DY est considéré.
6.3 Modélisation de l’intrus

Suivant le modèle de Dolev et Yao [41], l’intrus peut intercepter les messages envoyés par les
acteurs honnêtes du protocole, et leur envoyer des messages sous une fausse identité. À partir de
ses connaissances, il peut en déduire de nouvelles en composant ou décomposant des messages.
L’intrus augmente ses capacités de déduction en interceptant des messages et, pour envoyer un
message, doit pouvoir le composer à partir des connaissances acquises au moment de l’envoi du
message. Cette situation est modélisée par des ensembles de termes représentant les connaissances
6.4. Préfixe d’une substitution, ensemble complet de préfixes 101
Règle de déduction Résultat

a, b → ha, bi ha, bi
s s
a, b → {a}b {a}b
p p
a, b → {a}b {a}b
a, b → H(a, b) H(a, b)
Tab. 6.1 – Règles de composition
Règle de déduction Résultat Terme décomposé Condition

ha, bi → a a ha, bi ∅
ha, bi → b b ha, bi ∅
s s
{a}b , b → a a {a}b b
p p
{a}b , b−1 → a a {a}b b−1
p p
{a}b−1 , b → a a {a}b−1 b
Tab. 6.2 – Règles de décomposition
de l’intrus, et par des contraintes représentant les messages que l’intrus doit pouvoir composer
à partir de ses connaissances. Étant donné un ordre de réception/envoi de messages par les ac-
teurs honnêtes, ce système de contraintes est appelé un problème de construction simultanée. Ces
problèmes sont définis formellement en section 6.5.
Afin d’éviter les périphrases et de simplifier le propos, nous définissons pour le système de
réécriture le résultat d’une règle. Pour les règles de décomposition (celles de Ld,DY ), nous définissons
aussi le terme décomposé par une règle, et la condition de cette règle. Les termes désignés par ces
notations sont décrits dans les tableaux 6.1 et 6.2
Une règle R ∈ Lc,DY de résultat t est notée Lc,DY (t). Une règle R ∈ Ld,DY décomposant un
terme t est notée Ld,DY (t). Pour un terme t, nous notons Res(t) le résultat de la règle (unique)
décomposant t si t n’est pas un couple, et {t1 , t2 } si t = ht1 , t2 i. Nous notons aussi Cond(t) la
condition d’une règle décomposant t.
6.4 Préfixe d’une substitution, ensemble complet de préfixes

Soient r et s deux termes unifiables syntaxiquement, c’est-à-dire pour lesquels il existe une
substitution σ telle que rσ = sσ. Dans le cas de l’unification syntaxique, il existe une substitution
στ , appelée unificateur le plus général de r et s, ce qu’on note στ = mgu(r, s), telle que :
– rστ = sστ ;
– il existe une substitution τ telle que σ = στ τ .
Cet unificateur le plus général peut être calculé en temps linéaire [65, 46]. L’unificateur le plus
général entre deux termes est unique modulo le renommage des variables.
Cette notion se généralise à certaines théories équationnelles Θ pour lesquelles il existe un
ensemble fini (modulo renommage) de substitutions plus générales Σ vérifiant rσ ≡Θ sσ. Elle est
cependant trop contraignante pour l’étude de protocoles. La définition d’unificateur plus général
impose en effet que si στ est un unificateur plus général, alors pour toute substitution τ , στ τ est un
unificateur. Nous introduisons dans cette section une notion de préfixe, similaire à celle d’unificateur
plus général, mais sans cette contrainte. Nous renvoyons le lecteur à [5] pour un exposé clair et
complet sur l’unification dans les théories équationnelles.
Définition 41 (Préfixe d’une substitution)

Soit στ , σ deux substitutions. Une substitution στ est un préfixe de σ si il existe une substitution
τ telle que σ = στ τ .
Il est maintenant possible de définir la notion d’un ensemble préfixe d’un ensemble de substi-
tutions.
Définition 42 (Ensemble complet de préfixes)

Soit Θ un ensemble de substitutions. Un ensemble Σ de substitutions est un ensemble complet de
préfixes de Θ si :
∀σ ∈ Θ, ∃στ ∈ Σ, ∃τ, σ = στ τ
L’existence d’un ensemble préfixe est triviale : Θ est un ensemble préfixe de Θ. Cette notion
est utile si, étant donné un ensemble Θ de substitutions, il existe un ensemble de substitutions Σ
de cardinal fini qui est aussi un ensemble complet de préfixes de Θ.
6.5 Problèmes de construction

6.5.1 Définition
Dans la suite, les termes considérés sont dans T(F, X ), et nous considérons des sous-ensembles
finis E de T(F, X ). Les substitutions sont notées σ, τ avec les décorations habituelles. Une substi-
tution σ est close si :
∪x∈ (σ) Var(xσ) = ∅
Rappelons qu’un terme t est clos si Var(t) = ∅.

La notion d’équation de constructibilité est similaire à un problème d’unification modulo le
système de réécriture sur les ensembles LDY .
Définition 43 (Équation de constructibilité)

Une équation de constructibilité est un couple (E, t), avec E ⊂fini T(F, X ) et t ∈ T(F, X ). Elles
LDY
sont notées E BLDY t. Une substitution σ satisfait une équation de constructibilité si tσ ∈ Eσ .
On note alors σ |= E BLDY t.
Dans la suite de ce chapitre, nous noterons σ |= E B Lc,DY t la propriété σ |= E B LDY t et

Lc,DY
tσ ∈ Eσ . Cette notation permet donc d’imposer qu’une équation E B t soit résoluble avec
uniquement les règles de composition.
Définition 44 (Problèmes de construction simultanée)

On appelle problème de construction simultanée une suite
(Eqi )i∈{1,...,n}
d’équations de constructibilité telle que, avec Eqi : Ei BLDY ti :

– ∀i ∈ {1, . . . , n} , ∀x ∈ Var(Ei ), ∃j < i, x ∈ Var(tj )
LDY LDY
– ∀i, j ∈ {1, . . . , n} , i < j ⇒ ∃Fj ⊆ Ej , Ei = Fj
Un problème de construction simultanée C est σ-satisfaisable si :
∀Eq ∈ C, σ |= Eq
et il est dit satisfaisable si il existe σ telle que C soit σ-satisfaisable.
Par définition, on a toujours Var(E1 ) = ∅. On note C (avec les décorations usuelles) les problèmes
de construction simultanée.
Les équations de constructions peuvent être vues comme des problèmes d’unification modulo
la théorie de l’intrus et une règle extrayant un élément d’un ensemble. Montrons que ce problème
d’unification peut admettre une infinité de solutions plus générales.
Proposition 38 Le problème {a} B x a une infinité de solutions plus générales qui sont toutes
closes.
Preuve. Remarquons tout d’abord que pour tout problème de construction simultanée, les so-
lutions plus générales sont toujours closes : supposons qu’une substitution σ non close soit une
solution plus générale d’un problème de construction simultanée C. Soit E B t la première équation
de Cσ telle que E soit clos, mais pas t. Soit enfin x ∈ Var(t), et une constante a telle que a ∈
/ (E),
6.5. Problèmes de construction 103
et τ la substitution [x ← a]. D’après le lemme 4 du chapitre 4, a ∈ / (E) implique que a est le

résultat d’une règle de composition, ce qui contredit a est une constante. Donc toutes les solutions
les plus générales d’un problème de construction simultanée sont des substitutions closes.
D’après ce qui précède, le problème {a} B x a une infinité de solutions closes, donc il a une
infinité de solutions plus générales.
Notre stratégie ne sera donc pas de chercher toutes les solutions, mais de rechercher un ensemble
fini de substitutions Σ qui sont les préfixes des solutions du système.
6.5.2 Problèmes liés

Soit C = (Ei BLi ti )i∈{1,...,n} un problème de construction simultanée. Deux types de questions
peuvent se poser :
a) un problème de décision, qui consiste à savoir si C est satisfaisable :
Accessibilite(C) : Existe-t-il σ telle que σ |= C ?
b) soit Θ l’ensemble des substitutions satisfaisant C :
∀σ ∈ Θ, σ |= C
Lors de la recherche d’attaques sur les protocoles cryptographiques, il est naturel de chercher
à représenter Θ. Le problème d’énumération qui se pose est alors :
Prefixe(C) : Si Θ est l’ensemble des substitutions σ telles que σ |= C,
trouver un ensemble fini et complet de préfixes de Θ.
Définition 45 (Forme résolue) Un problème de construction simultanée C est en forme résolue si
pour toute équation E BR t de C, t est une variable.
Le théorème suivant implique qu’il suffit de pouvoir transformer un problème de construction

simultanée C en un problème C 0 sous forme résolue ayant le même ensemble de solutions closes
pour trouver une substitution σ solution de C. La preuve, simple, consiste à unifier chaque variable
dans le membre droit d’une équation de constructibilité avec un terme clos du membre gauche de
cette équation.
Théorème 6 Un problème de construction simultanée en forme résolue est satisfaisable.
6.5.3 Transformation de problèmes de construction simultanée

Une technique classique, dans le cadre des problèmes d’unification, est de transformer un
système d’équations jusqu’à obtenir un système d’équations en forme résolue. Nous allons adapter
cette technique au cadre des problèmes de construction simultanée. Nous allons transformer un
problème général en un problème en forme résolue.
On considère dans cette section l’ensemble LDY de règles de déductions défini en section 4.5.
En vue de l’implantation d’un outil de recherche d’attaques sur un protocole, nous nous intéressons
plus particulièrement au problème Prefixe , car il permet une recherche incrémentale vis-à-vis de
l’ordre d’exécution et permet l’étude de problèmes d’authentification. La notion d’ordre d’exécution
est formalisée dans la section 6.8.
6.5.3.i Système de transformation de problèmes de construction simultanée

On pose le système L de transformation de problèmes de construction simultanée.
Cα , E ∪ {u} B t, Cβ σ=mgu(u,t) Cα , E B f (t1 , t2 ), Cβ

Unif : Comp :
(Cα , Cβ )σ u, t ∈
/X Cα , E B t1 , E B t2 , Cβ
Cα , E B t, Cβ
Dec : u∈E
Cα , E B Cond(u), E ∪ Res(u) B t, Cβ
Description des règles. La règle Comp permet de réduire le problème de la construction d’un
terme t au problème de la construction de ses deux sous-termes maximaux. La règle Dec permet de
décomposer un terme dans les connaissances de l’intrus. La règle Unif permet enfin de simplifier
une contrainte lorsque le terme à construire est dans les connaissances de l’intrus. Dans ce dernier
cas, un unificateur plus général est calculé entre une des connaissances de l’intrus et le terme à
construire. Cet unificateur est appliqué sur l’ensemble du problème de construction simultanée. Il
peut bien sûr être égal à l’identité.
Restrictions à l’application des règles de L. Nous imposons les restrictions suivantes à

l’application des règles de L :
1. Cα doit être en forme résolue ;
2. La règle n’est jamais appliquée sur E B Cond(u) ou sur une équation déduite de E B
Cond(u), et n’est pas appliquée sur le terme u de E ∪ Res(u) B t
On verra dans la section 6.7 que le système reste complet malgré la restriction 1. Intuitivement,
la restriction 2 ne perd pas de généralité : si une règle interdite est appliquée sur E ∪ Res(u) B t,
elle n’augmente les connaissances dont dispose l’intrus pour résoudre la constrainte initiale. La
première restriction, sur E B Cond(u) est moins évidente. On verra cependant, dans le lemme 20,
qu’elle permet d’avoir un système complet.
Nous notons C C 0 si il y a une transformation de C vers C 0 dans L, et C n C 0 une suite
∗
de transformations de longueur n, et C C 0 une suite de transformations de longueur quel-
∗ 0
conque. Si C C , la substitution σ qui est la composée des substitutions appliquées est notée
Subst(C ∗ C 0 ).
6.5.3.ii Correction du système L

Il est tout de suite possible d’énoncer et de prouver la correction du système L de transforma-
tions.
Théorème 7 (Correction de L)
Si C ∗ C 0 , τ = Subst(C ∗ C 0 ) et σ |= C 0 , alors τ σ |= C.
Preuve. Par contradiction, soit n ≥ 0 minimal tel qu’il existe C, C 0 , σ et τ avec C n

C0,
∗ 0
τ = Subst(C C), σ |= C et τ σ 6|= C.
On a nécessairement n ≥ 1. Soit C 00 C 0 la dernière inférence. Par minimalité de n, en posant
0 ∗ 00
τ = Subst(C C ), on a :
∀σ 0 , σ 0 |= C 00 ⇒ τ 0 σ 0 |= C
Raisonnons par cas sur la dernière règle appliquée.
: soit σ 00 la substitution appliquée et σ 0 telle que σ 0 |= C 0 . On a donc :
00 0
σ σ |= Cα , Cβ
tσ 00 σ 0 ∈ Eσ 00 σ 0
donc, par définition d’une équation de construction :
σ 00 σ 0 |= Cα , E B t, Cβ
Soit τ 0 σ 00 σ 0 |= C. Or, τ = τ 0 σ 00 , ce qui contredit le choix de C, C 0 ;

: correction évidente par définition d’une équation de construction ;
: on a E B t implique E ∪ Res(u) B t, donc la correction est évidente.

6.6 Équivalences sur les équations de constructions

Dans cette section, nous considérons un système de réécriture sur les ensembles R avec R ∈
{Lc,DY , LDY }, des sous-ensembles finis E, F et T de T(F, X ), et des termes t et u de T(F, X ).
6.6. Équivalences sur les équations de constructions 105
6.6.1 Généralités
Proposition 39
Pour tous les ensembles finis E et F , on a :
R R R R
(E = F ) ⇔ (∀σ, Eσ = Fσ )
R R
Preuve. Par les propositions 10 et 9 du chapitre 4, et sous l’hypothèse E = F , il existe un
ensemble fini de termes G tel que :
E →∗R G

(1)
F →∗R G (2)
Par (1) et (2), par la quantification sur les termes dans les règles de composition et de décomposition,
et pour toute substitution σ, on a :
Eσ →∗R Gσ

F σ →∗R Gσ
et donc :
Eσ ≡R F σ
Soit, par la proposition 10 du chapitre 4 :
R R
Eσ = Fσ
La réciproque est triviale en considérant la substitution identité.

La proposition 39 et la définition des problèmes de construction simultanée impliquent la pro-
position suivante.
Proposition 40
Pour tous les ensembles finis E et F , pour tout terme t, pour tout problème de construction simul-
tanée Cα , E BR t, Cβ et pour toute substitution σ, l’égalité :
R R
(E =F )
implique :
σ |= Cα , E BR t, Cβ si et seulement si σ |= Cα , F BR t, Cβ
La proposition suivante énonce que deux ensembles équivalents ont le même ensemble de va-
riables. La preuve s’applique pour tous les symboles d’arité nulle.
Proposition 41
R R
Pour tous les ensembles E et F , E = F implique Var(E) = Var(F ).
Preuve. Par contradiction, et sans perte de généralité, soit x ∈ Var(E) \ Var(F ). Par hypothèse,
R
on a E ⊆ F . Soit :
D : F →R F1 →R . . . →R Fn
avec E ⊆ Fn , et soit i ∈ {1, . . . , n} minimal tel que x ∈ Var(Fi ). Par le lemme 4 appliqué sur R, x
est obtenu par une règle de composition, donc x est un f -terme, avec f symbole d’arité non nulle,
ce qui contredit l’hypothèse que x est une variable.
Enfin, cette dernière proposition permet de construire des ensembles équivalents.
Proposition 42
Soient E et F deux ensembles de termes, et T ⊆ E tel que :
– F ⊆E\T ;
R
– T ⊆F .
alors E ≡R E \ T .
R
Preuve. On a, par hypothèse, F ⊆ E \ T et T ⊆ F , donc
R R
T ⊆F ⊆E\T
R
D’autre part, E \ T ⊆ E \ T , donc :
R
E ⊆E\T
Soit, en calculant la clôture de ces deux ensembles :
R R
E ⊆E\T
L’inclusion réciproque est triviale, et on conclut avec la proposition 10, page 49 : deux ensembles
équivalents pour un système de réécriture L ont la même clôture.
6.6.2 Ordre sur les problèmes de construction simultanée

Nous commençons par ordonner les problèmes de construction simultanée afin d’introduire une
notion de problème plus simple. Pour cela, nous considérons un ordre ≺ total sur les termes, respec-
tant la relation de sous-terme et bien-fondé (voir le chapitre 3, section 3.5 pour un exemple d’un tel
ordre.) Cet ordre peut être étendu en un ordre ≺M bien fondé sur les multi-ensembles de termes.
Associons à un problème de construction simultanée C un quadruplet Π(C) = (v, Md , Mc , e) avec :
– v est le nombre de variables dans C ;
– Md est le multi-ensemble des sous-termes (avec multiplicité) sur lesquels il est possible d’ap-
pliquer ;
– Mc est le multi-ensemble des membres droits des équations de constructibilité de C ;
– e est le nombre d’équations dans C.
Soit pcs l’ordre lexicographique sur ces quadruplets. C’est un ordre bien-fondé par construction.
Définition 46 (Problème plus simple)
Soient C et C 0 deux problèmes de construction simultanée. Nous dirons que C est plus simple que
C 0 si :
Π(C) ≺pcs Π(C 0 )
Proposition 43 (Terminaison du système L)
Soit C un problème de construction simultanée. Il n’y a qu’un nombre fini de suites de transforma-
tions partant de C.
Preuve. L’ordre pcs est bien fondé. Pour montrer la terminaison du système L, il suffit donc de
montrer que chaque règle de L est décroissante pour pcs . Montrons que chaque application d’une
règle , ou est décroissante pour cet ordre.
: si la substitution appliquée est l’identité, la règle réduit le nombre d’équations et n’aug-
mente ni le nombre de variables, ni les multi-ensembles Md et Mc . Sinon, la règle fait
diminuer le nombre total de variables ;
: cette règle fait décroı̂tre le multi-ensemble Md des termes décomposables, et n’augmente
pas le nombre des variables ;
: cette règle fait décroı̂tre le multi-ensemble Mc . Par la restriction sur les règles de
décomposition, elle n’augmente pas Md ni le nombre des variables.

6.6.3 Normalisation d’un problème de construction simultanée

La résolution de problèmes de construction simultanée est intrinsèquement non déterministe :
l’intrus doit faire des choix en fonction d’une exécution qui n’est pas totalement spécifiée tant qu’il
reste des variables. Une technique classique de limitation du non déterminisme est l’utilisation de
simplifications. Un problème de construction simultanée est remplacé par un autre plus simple.
Nous décrivons dans cette section une fonction de normalisation Norm(), c’est-à-dire appliquant
toutes les simplifications possibles et telle que, pour tout problème de construction simultanée C,
pour toute substitution σ, on a :
σ |= C si et seulement si σ |= Norm(C)
6.6.3.i Élimination des couples

Lemme 10
LDY LDY
Pour tout E ⊂fini T(F, X ), pour tout t = ht1 , t2 i, on a E, t = E, t1 , t2 .
Preuve. On a E, t →∗Ld,DY E, t1 , t2 , t et E, t1 , t2 →Lc,DY E, t1 , t2 , t, donc :
E, t ≡LDY E, t1 , t2
et on conclut avec la proposition 10 du chapitre 4.

Définissons une fonction Simplif h , i sur les termes :

Simplif h , i (t1 ) ∪ Simplif h , i (t2 ) si t = ht1 , t2 i
Simplif h , i (t) =
{t} sinon
On étend la fonction Simplif h , i sur les ensembles de termes en définissant, pour un ensemble de
termes E :
Simplif h , i (E) = ∪t∈E Simplif h , i (t)
En utilisant le lemme 10, il vient immédiatement :
Lemme 11
Pour tout ensemble fini E,
LDY LDY
E = Simplif h , i (E)
Le lemme suivant est trivial.
Lemme 12
Pour tout terme t = ht1 , t2 i, pour tout ensemble E, pour toute substitution σ, on a :
LDY LDY LDY
tσ ∈ Eσ si et seulement si t1 σ ∈ Eσ et t2 σ ∈ Eσ
En combinant les lemmes 11 et 12, et en utilisant la proposition 40, nous obtenons le lemme
suivant :
Lemme 13
Pour toute équation de constructibilité E BLDY t, pour toute substitution σ, on a σ |= E BLDY t si,
et seulement si,
∀u ∈ Simplif h , i (t), σ |= Simplif h , i (E) BLDY u
6.6.3.ii Élimination des variables

L’élimination des variables est très importante en vue d’une implantation d’un algorithme de
recherche d’attaques sur un protocole. En effet, une variable est unifiable avec tout terme ne la
contenant pas.
Lemme 14
Soit
C = Cα , Ex B x, Cβ , E ∪ {x} B t, Cγ
C 0 = Cα , Ex B x, Cβ , E B t, Cγ
Si x ∈
/ Var(Ex ), alors pour toute substitution σ,
(σ |= C) ⇔ (σ |= C 0 )
LDY
Preuve. Par hypothèse, σ |= C, donc xσ ∈ Ex σ . Par définition, il existe F ⊆ E tel que
LDY LDY Lc,DY
Ex =F . Donc xσ ∈ F σ . Par la proposition 41 et par l’hypothèse x ∈ / Var(Ex ), on a
x∈/ Var(F ) et donc x ∈
/ F . Par la proposition 42, E \x ≡LDY E, et on conclut avec la proposition 40.
La réciproque est immédiate.
Ce lemme pourra être appliqué à travers le corollaire suivant.

Corollaire 1
Soit Cα = (Ei B ti )i∈{1,...,n} , et soit C = Cα , E B t un problème de construction simultanée avec Cα
en forme résolue. Alors pour toute substitution σ,
(σ |= C) ⇔ (σ |= Cα , (E \ X ) B t)
Preuve. Le sens réciproque est trivial. Montrons le sens direct. Soit x ∈ E ∩ X . Par définition des
ensembles de construction simultanée, x ∈ Var(Cα ). Soit i minimal tel que x ∈ Var(Ei B ti ). Par
minimalité de i et par définition des ensembles de constructions simultanées, x ∈ Var(ti ) \ Var(Ei ).
Cα est en forme résolue, donc ti = x, et on conclut par le lemme 14.
On note Simplif var la fonction qui, dans un problème de construction simultanée, élimine toutes
les variables inutiles d’après le lemme 14.
On a bien sûr, pour tout problème de construction simultanée C et toute substitution σ :
(σ |= C) ⇔ (σ |= Simplif var (C))
6.6.3.iii Simplification pour le chiffrement symétrique

Les deux lemmes suivants expriment que si, à partir d’un ensemble de connaissances E, il est
possible de construire un terme t2 servant de clef symétrique, alors il n’est pas nécessaire de se
souvenir des messages chiffrés par cette clef, il suffit de garder le texte clair.
Lemme 15 (Normalisation du chiffrement symétrique dans les connaissances)
s Rproto s
Si t2 ∈ E, {t1 }t2 , alors E, {t1 }t2 ≡Θproto E, t1 , t2 .
s Rproto
Preuve. Par hypothèse, E, t1 , t2 ⊆ E, {t1 }t2 . Donc :
Rproto s Rproto
E, t1 , t2 ⊆ E, {t1 }t2
s Rproto
D’autre part, on a toujours E, {t1 }t2 ⊆ E, t1 , t2 , et donc :
s Rproto Rproto
E, {t1 }t2 ⊆ E, t1 , t2

Lemme 16 (Normalisation du chiffrement symétrique dans les contraintes)
Rproto s Rproto Rproto
Si t2 ∈ E , alors {t1 }t2 ∈ E si, et seulement si, t1 ∈ E .
s Rproto Rproto
Preuve. Par définition, t2 , {t1 }t2 ∈ E implique t1 ∈ E par une règle de décomposition,
Rproto s Rproto
et t1 , t2 ∈ E implique {t1 }t2 ∈ E par une règle de composition.
s
Soit Simplif { }s ,t la fonction qui à un terme u associe v si u = {v}t , et u sinon. On la prolonge
sur les ensembles de termes :
[
Simplif { }s ,t (E) = Simplif { }s ,t (u)
u∈E
De ces deux lemmes, nous tirons le corollaire suivant.

Corollaire 2
en forme résolue. Supposons enfin :
Rproto
u ∈ E, Var(Cα )
Alors pour toute substitution σ,
(σ |= C) ⇔ (σ |= Cα , Simplif { }s ,u (E) ∪ {u} B Simplif { }s ,u (t))
Preuve. Par hypothèse, pour toute substitution σ, on a :
Rproto Rproto
(σ |= Cα ) implique ((E, Var(Cα ))σ = Eσ )
Rproto Rproto
donc, sous cette hypothèse, u ∈ E, Var(Cα ) est équivalent à uσ ∈ Eσ . L’équivalence
résulte alors des équivalences dans les lemmes 15 et 16.
6.6.3.iv Simplification pour le chiffrement asymétrique
Les deux lemmes suivants expriment que si, à partir d’un ensemble de connaissances E, il est
possible de construire les clefs publiques et privées t2 et t2 −1 , alors il n’est pas nécessaire de se
souvenir des messages chiffrés par ces clefs, il suffit de garder le texte clair.
Lemme 17 (Normalisation du chiffrement asymétrique dans les connaissances)

p Rproto p
Si t2 , t2 −1 ∈ E, {t1 }t2 , alors E, {t1 }t2 ≡Θproto E, t1 , t2 , t2 −1 .
p Rproto
Preuve. Par hypothèse, E, t1 , t2 , t2 −1 ⊆ E, {t1 }t2 . Donc :
Rproto p Rproto
E, t1 , t2 , t2 −1 ⊆ E, {t1 }t2
p Rproto
D’autre part, on a toujours E, {t1 }t2 ⊆ E, t1 , t2 , t2 −1 , et donc :
s Rproto Rproto
E, {t1 }t2 ⊆ E, t1 , t2 , t2 −1

p
Le même lemme vaut, évidement, si {t1 }t2 −1 est dans les connaissances. Le lemme suivant aussi
p p
est valide si {t1 }t2 est remplacé, dans l’énoncé, par {t1 }t2 −1 .
Lemme 18 (Normalisation du chiffrement asymétrique dans les contraintes)

Rproto p Rproto Rproto
Si t2 , t2 −1 ∈ E , alors {t1 }t2 ∈ E si, et seulement si, t1 ∈ E .
p Rproto Rproto
Preuve. Par définition, t2 −1 , {t1 }t2 ∈ E implique t1 ∈ E par une règle de décomposition,
Rproto p Rproto
et t1 , t2 ∈ E implique {t1 }t2 ∈E par une règle de composition.
p p
Soit Simplif { }p ,t la fonction qui à un terme u associe v si u = {v}t ou u = {v}t−1 , et u sinon.
On la prolonge sur les ensembles de termes :
[
Simplif { }p ,t (E) = Simplif { }p ,t (u)
u∈E
Des deux lemmes précédents, nous tirons le corollaire suivant.
Corollaire 3
en forme résolue. Supposons enfin :
Rproto
u, u−1 ∈ E, Var(Cα )
Alors pour toute substitution σ,
(σ |= C) ⇔ (σ |= Cα , Simplif { }p ,u (E) ∪ {u} B Simplif { }p ,u (t))
Preuve. Par hypothèse, pour toute substitution σ, on a :

Rproto Rproto
(σ |= Cα ) ⇒ ((E, Var(Cα ))σ = Eσ )
Rproto Rproto
donc, sous cette hypothèse, u, u−1 ∈ E, Var(Cα ) est équivalent à uσ, u−1 σ ∈ Eσ .
L’équivalence résulte alors des équivalences dans les lemmes 17 et 18.
6.6.3.v Normalisation de problèmes de construction simultanée

Remarquons que par définition de l’ordre pcs , toutes les fonctions de simplification sont
décroissantes pour cet ordre. Il est bien fondé, donc partant d’un problème de construction si-
multanée C, les fonctions de simplification ne pourront être appliquées qu’un nombre fini de fois.
Soit (Ci )i∈{0,...,n} une suite finie de problèmes de construction simultanée telle que C0 = C, et pour
tout i ∈ {1, . . . , n}, le problème Ci est obtenu à partir de Ci−1 par application d’une fonction de
simplification.
Définition 47 (Normalisation de problèmes de construction simultanée)

Avec les notations précédentes, nous disons que Cn est la forme normale de C, et nous le notons
Norm(C), si toute fonction de simplification appliquée sur Cn a pour image Cn .
Le théorème suivant est une conséquence directe des lemmes des sous-sections précédentes et
de la définition de Norm(C).
Théorème 8 (Normalisation de problèmes de construction simultanée)

Soit C un problème de construction simultanée. Alors, pour toute substitution σ,
(σ |= C) ⇔ (σ |= Norm(C))
6.7 Complétude de L
Dans cette section, nous montrons que pour un problème de construction simultanée C et une
substitution σ, si σ |= C, alors il existe un problème de construction simultanée C 0 en forme résolue
tel que C ∗ C 0 et Subst(C ∗ C 0 ) est un préfixe de σ. D’après le théorème 8, nous supposerons
que les problèmes de construction simultanée sur lesquels les règles de L sont appliquées sont en
forme normale. La restriction 1 de la définition de L et l’hypothèse C en forme normale impliquent
que pour toute équation E B t de C sur laquelle une règle est appliquée, on a E ∩ X = ∅.
6.7.1 Cas sans décomposition des connaissances

Dans cette sous-section, nous considérons un problème de construction simultanée
C = (Ei BLc,DY ti )i∈{1,...,n}
On appelle ce type particulier de problème des problèmes de construction simultanée par compo-
sition. On cherche à ramener, par transformations successives, un tel problème à un problème de
construction simultanée en forme résolue.
Lemme 19
/ X . Il existe C 0 tel que C
Soit C = Cα , E BLc,DY t, Cβ σ-satisfaisable tel que t ∈ C 0 par application
d’une règle ou avec une substitution στ préfixe de σ, telle que σ = στ τ et τ |= C 0
Preuve. Par hypothèse, σ |= E BLc,DY t, donc soit tσ ∈ Eσ, soit il existe une dérivation D partant
de Eσ de but tσ utilisant uniquement les règles de Lc,DY .
Si tσ ∈ Eσ, il existe u ∈ E tel que uσ = tσ. Soit σu l’unificateur le plus général entre u et t, et
τu tel que σ = σu τu . On est alors dans le cas d’une règle .
Lc,DY
Sinon, soit F →Lc,DY F, t la dernière transition dans D. D est une dérivation, donc F ⊆ Eσ .
La dernière transition est une règle de composition, donc avec les notations de l’énoncé, t1 σ et t2 σ
sont dans F . On est alors dans le cas d’une règle .
Dans les deux cas, l’ensemble de contraintes obtenu est encore un problème de construction
simultanée par composition.
Par la proposition 43, il n’y a qu’un nombre fini de suites de transformations partant de C.
Soient C1 , . . . , Cn les problèmes de construction simultanée par composition obtenus par des suites
de transformation de longueur maximale, et σ1 , . . . , σn les substitutions appliquées pour passer de
C à ces problèmes. La suite de transformations est de longueur maximale, donc il n’est plus possible
6.7. Complétude de L 111
d’appliquer la règle Comp. Donc si E B t est une équation de Ci , alors t est un symbole d’arité 0.
Si t n’est pas une variable, alors par maximalité, il n’est pas possible d’appliquer la règle Unif, et
donc t ∈ / E. C est un problème de construction simultanée par composition, E ne contient pas de
variables, donc pour toute substitution τ , t ∈ / Eτ . Donc un problème Ci obtenu par une suite de
transformations de longueur maximale est satisfaisable si, et seulement si, il est en forme résolue.
S’il existe une substitution σ telle que σ |= C, alors par le lemme 19 et par récurrence, il existe
au moins un i tel que σi soit préfixe de σ, et en posant σi τ = σ, toujours par le lemme 19, τ |= Ci
et donc Ci est en forme résolue. On a donc la proposition suivante.
Proposition 44
Soit C un problème de construction simultanée par composition σ-satisfaisable. Alors il existe C 0
en forme résolue, et deux substitutions τ et στ , tels que :
– C ∗ C 0 avec les règles et ;
– σ = στ τ avec στ = Subst(C ∗ C 0 ) et τ |= C 0 .
6.7.2 Cas avec décomposition des connaissances

Avant de traiter le cas général, nous nous intéressons à un autre cas particulier, celui de
problèmes C = Cα , E BLDY t avec Cα = E1 BLc,DY t1 , . . . , En BLc,DY tn en forme résolue et C
σ-satisfaisable. Si l’équation de constructibilité E BLDY t est satisfaisable uniquement avec des
règles de composition, la proposition 44 permet de ramener C à un problème de construction si-
multanée en forme résolue. Sinon, le lemme 20 permettra de faire le lien entre les problèmes de
construction simultanée généraux et ceux par composition.
Avec les notations de ce lemme, on remarque que la règle de L permet de passer du
problème C au problème en conclusion du lemme.
Lemme 20
Avec les notations précédentes, et si σ 6|= E BLc,DY t, il existe u = f (u1 , u2 ) dans E tel que :
σ |= Cα , E BLc,DY Cond(u), E ∪ Res(u) BLDY t
Preuve. Par définition des problèmes de construction simultanée, il existe une dérivation bien
formée sur LDY partant de Eσ et de but tσ. Soit :
D : Eσ = F0 →R0 F1 →R1 . . . →Rn−1 Fn
avec tσ ∈ Fn . L’hypothèse σ 6|= E BLc,DY t implique Ld,DY ∩ D 6= ∅. Soit i l’indice minimal tel que
Fi →Ri Fi , ri+1 avec Ri ∈ Ld,DY et soit di ∈ Fi le terme décomposé par Ri . Par définition d’une
dérivation, Lc,DY (di ) ∈
/ D. Par minimalité de i, on a donc di ∈ Eσ. Donc il existe u ∈ E tel que
uσ = di . Par le lemme 14, on peut supposer que u ∈ / X . Soient v = Cond(u) et r = Res(u) les
termes (déduits des sous-termes de u) tels que vσ soit la condition de Ri et rσ soit le résultat de
Ri . Alors :
σ |= Cα , E BLc v, E ∪ r BL t

Ce lemme justifie formellement la première partie de la restriction 2 de la définition de L. Si le

choix (non déterministe) du terme u à décomposer est le bon, il n’est pas nécessaire d’utiliser une
transformation de type pour composer Cond(u).
Le lemme suivant permet de passer d’un problème de construction simultanée ayant au plus une
équation de constructibilité (la dernière) qui peut ne pas être résoluble dans Lc,DY à un problème
de construction simultanée par composition.
Lemme 21
Avec les notations précédentes, il existe un problème de construction simultanée par composition
C (c) en forme résolue et τ -satisfaisable tels que :
– C ∗ C (c) et στ = Subst(C ∗ C (c) ) ;
– στ τ = σ.
Preuve. D’après le lemme 20, il existe u ∈ E et des termes v, r déduits des sous-termes de u tels
que :
σ |= C1 avec C1 = Cα , E BLc v, E ∪ {r} BL t
On a : C C1 .
Par la proposition 44, il existe un problème de construction par composition en forme résolue
(1)
C2 et στ , τ (1) tels que : n o
τ (1) |= C2 , Eστ(1) ∪ rστ(1) BL tστ(1)
(1)
avec C1 ∗ C2 et στ préfixe de σ.
Itérons cette construction. Par la proposition 43, cette itération termine. Soit C (c) le problème
finalement obtenu. Par récurrence, il existe τ et στ deux substitutions telles que τ |= C (c) , στ τ = σ
et στ = Subst(C C (c) ).
Il n’est pas possible d’appliquer le lemme 20 sur C (c) , donc C (c) est un problème de construction
simultanée par composition. Il n’est pas possible d’appliquer une règle ou , donc il est
en forme résolue.
Le cas général peut maintenant facilement se déduire du lemme 21.
6.7.3 Cas général

Nous nous plaçons maintenant dans le cas d’un problème de construction simultanée général :
C = (Ei BLDY ti )i∈{1,...,n}
Théorème 9
Pour tout problème de construction simultanée C, pour toute substitution σ telle que σ |= C, il existe
un problème de construction simultanée par composition en forme résolue C (c) et deux substitutions
στ et τ telles que C ∗ C (c) , στ = Subst(C ∗ C (c) ), σ = στ τ et τ |= C (c) .
Preuve. Pour C et un indice i ∈ {1, . . . , n}, on note :
(pre)
Ci = E1 BLDY t1 , . . . , Ei−1 BLDY ti−1
Par contradiction, soient C un problème de construction simultanée et σ une substitution tels que
(pre) (pre)
σ |= C et soit i minimal tel que Ci vérifie le théorème, mais pas Ci+1 .
Par hypothèse, il existe un problème de construction simultanée par composition C 0 en forme
résolue et στ tel que :
– στ est un préfixe de σ, et στ τ = σ ;
– Var(C 0 ) = Var(Cτ ) ⊆ Var(C) ;
– τ |= C 0 , Ei τ BL ti τ .
Ce qui entraı̂ne une contradiction par le lemme 21.
6.8 Recherche d’attaques sur un protocole

6.8.1 Modèle de protocole
Soit P = ({Rι ⇒ Sι }I , <I , S0 ) une instance de protocole, avec {Rι ⇒ Sι }ι∈I un ensemble de
règles de réception/envoi de messages par les principaux honnêtes, <I un ordre partiel sur I et
S0 les connaissances initiales de l’intrus. Nous imposons sur l’ensemble des règles la restriction
suivante :
∀ι ∈ I, ∀x ∈ Var(Sι ), ∃ι0 ∈ I, x ∈ Var(Rι0 ) et ι0 ≤I ι
La condition sur les règles du protocole est un cas particulier de la propriété énoncée dans le
chapitre 5, section 5.5.
Un ordre d’exécution du protocole est une fonction bijective et croissante de I 0 ⊆ I dans
{1, . . . , |I 0 |} avec I 0 tel que
∀ι, ι0 ∈ I, ι0 <I ι et ι ∈ I 0 implique ι0 ∈ I 0

6.8. Recherche d’attaques sur un protocole 113
Étant donné un ordre d’exécution π, notons Ri ⇒ Si la règle Rπ−1 (i) ⇒ Sπ−1 (i) , et définissons
les ensembles (Ei )i∈{0,...,k} par :

S0 si i = 0
Ei =
Ei−1 , Si sinon
Un ordre d’exécution π est satisfaisable si le problème de construction simultanée :
Cπ = E0 B R1 , . . . , Ek−1 B Rk
est satisfaisable. Par abus de langage, nous dirons que π est σ-satisfaisable si σ |= Cπ .
Dans la suite de cette section, nous commençons par montrer qu’il est possible de réduire la
recherche d’attaque de secret ou d’authentification au problème de savoir si une exécution est
satisfaisable.
6.8.2 Codage des attaques

6.8.2.i Attaques de secret
Soit le problème de décision :
Secret(P, t) : Existe-t-il
L
π et σ tels que π soit σ-satisfaisable et tσ ∈
DY
Ek σ ?
Soit t le terme devant rester secret dans toute exécution du protocole. Nous codons cette
propriété en ajoutant une règle :
t⇒t
incomparable aux autres pour l’ordre <I . Pour un protocole P, notons Psec le protocole augmenté
de cette règle. Pour un ordre d’exécution π, posons :
Cπ = E0 BLDY R1 , . . . , Ek−1 B LDY Rk
Par définition des problèmes de construction simultanée, le problème de décision Secret(P, t) est
équivalent au problème :
Existe-t-il π tel que Accessibilite(Cπ ) soit satisfaisable avec Rk = t ?

On sait déjà résoudre les problèmes de construction simultanée, donc le problème de recherche
d’attaques de secret se réduit au problème de la recherche d’un ordre d’exécution. Le problème est
donc décidable (il y a un nombre fini d’ordres d’exécution possibles).
6.8.2.ii Attaques d’authentification

Soit le problème de décision
Authentification(P, t1 , t2 ) : Existe-t-il π et σ tels que π soit σ-satisfaisable et t1 σ 6= t2 σ ?

Soit Σ un ensemble complet de préfixe des substitutions satisfaisant Cπ . L’intrus peut composer
une infinité de termes à partir de ses connaissances, donc le problème se réduit à :
Authentification(P, t1 , t2 ) : Existe-t-il π et σ ∈ Σ tels que π soit σ-satisfaisable et t1 σ 6=

t2 σ ?
Par les théorèmes 9 et 7, il est possible de construire un ensemble complet de préfixes des
solutions de Cπ . Par la proposition 43, cet ensemble complet de préfixes des solutions de Cπ est fini.
Donc le problème Authentification (P, t1 , t2 ) est décidable.
6.8.3 Recherche paresseuse d’un ordre d’exécution

Soit P un protocole. Il y a un nombre fini d’exécutions possibles de P, donc les problèmes
Secret(P, t) et Authentification(P, t1 , t2 ) sont décidables. Cependant, commencer par deviner
un ordre d’exécution et chercher ensuite s’il correspond à une attaque n’est pas efficace. Dans cette
sous-section, nous montrons qu’il est possible de chercher les ordres d’exécution incrémentalement.
Soit C = Cα , E BLDY t un problème de construction simultanée. Notons Σ(C) (resp. Σ(Cα ))
l’ensemble complet de préfixes trouvé en utilisant le système L.
Proposition 45
Pour toute substitution σ ∈ Σ(C), il existe une substitution σ 0 dans Σ(Cα ) qui est un préfixe de σ.
Preuve. Par définition, il existe un problème de construction simultanée en forme résolue C 0 tel
que C ∗ C 0 et σ = Subst(C ∗ C 0 ). D’après la restriction 1 sur l’application des règles de L, il
existe un problème de construction simultanée Cα0 en forme résolue tel que :
∗
C Cα0 , E BLDY t ∗
C0
Soit σ 0 = Subst(C ∗
Cα0 , E BLDY t). Par définition, on a σ 0 ∈ Σ(Cα ).
6.8.4 Algorithme de recherche d’attaques

6.8.4.i Notations et Algorithme
Soit P = ({Rι ⇒ Sι }ι∈I , <I , S0 ) une instance d’un protocole avec un nombre fini de sessions.
Une exécution du protocole est un triplet (π, C, E) tel que :
– π est un ordre d’exécution du protocole ;
– C est un problème de construction simultanée ;
– E est un ensemble fini de termes représentant les connaissances de l’intrus.
Pour un problème de construction simultanée C, notons C ∗ l’ensemble des problèmes de cons-
truction C 0 en forme résolue tels que C ∗
C 0 . Enfin, supposons qu’une fonction attaque(C)
répond si le problème de construction simultanée C correspond à une attaque sur le protocole.
L’algorithme de recherche d’attaques implanté par des règles de réécriture dans le prouveur de
théorèmes daTac est énoncé dans la figure 6.1.
recherche attaque ({Rι ⇒ Sι }ι∈I , <I , S0 )

correct =
Exec = (, ∅, S0 , {Rι ⇒ Sι }ι∈I )

tant que correct et Exec 6= ∅ faire

choisir (π, C, E, P ) ∈ Exec
choisir ι minimal tel que Rι ⇒ Sι ∈ P
∗
Calculer (C, E B Rι )
0 ∗
Pour tout C ∈ (C, E B Rι )
0
Si attaque(C ) alors
correct =
Sinon
Si P 6= ∅
σ = Subst((C, E B Rι ) ∗ C 0 )
Exec = Exec ∪ {(π · ι, Norm(C 0 ), (E, Sι )σ, P σ)}
finsi
finsi
finsi
finfaire
Répondre correct
Fig. 6.1 – Algorithme de recherche d’attaque sur un protocole

6.9. Résultats obtenus avec le prouveur de théorèmes daTac 115
6.8.4.ii Correction et complétude de cet algorithme pour la recherche d’attaques

pour un nombre fini de sessions
Tous les ordre d’exécutions possibles sont explorés. Soient π et π 0 deux ordres d’exécution
tels que π 0 soit une extension de π. D’après la proposition 45 et par induction, si pour un ordre
d’exécution π, le problème de construction simultanée Cπ n’est pas satisfaisable, et si π 0 est une
extension de l’ordre d’exécution π 0 , alors Cπ0 n’est pas satisfaisable. Il suffit donc, comme le fait cet
algorithme, de n’explorer que les ordres d’exécution π 0 qui n’étendent que des ordres d’exécution
π satisfaisables.
Pour un ordre d’exécution π, toutes les substitutions satisfaisant Cπ sont prises en

compte. Il s’agit de la propriété de complétude du système L énoncée dans le théorème 9. La
prise en compte de l’ensemble des substitutions satisfaisant Cπ est symbolique, et se fait à travers
un ensemble complet de préfixes.
Les attaques trouvées sont réelles. Par « réelles », nous entendons que si une attaque avec un
ordre d’exécution π et une substitution σ est trouvée, alors le problème de construction simultanée
Cπ est satisfaisable : la substitution σ est préfixe d’une substitution close τ telle que τ |= Cπ . Il
s’agit d’une conséquence du théorème 7.
6.8.4.iii Conclusion
On remarque que l’algorithme présenté dans la figure 6.1 est aussi une procédure de semi-
décision pour la recherche d’attaques si les acteurs ne sont pas limités dans le nombre de sessions
auxquelles ils peuvent participer les unes à la suite des autres. L’implantation dans daTac suit ce
modèle : dès qu’un acteur a terminé une session, il peut en recommencer une nouvelle. L’ensemble
I des règles est infini, mais n’a à chaque étape qu’un nombre fini d’éléments minimaux. Il est donc
possible de faire une exploration en largeur et paresseuse de tous les ordres d’exécution possibles.
Dans le cadre du projet AVISS, les protocoles sont compilés pour qu’à la fin d’une session, un
principal puisse toujours en commencer une nouvelle. Les résultats que nous présentons dans la
section 6.9 ne sont donc jamais des résultats de correction : en l’absence de faille sur un protocole,
notre outil continue indéfiniment.
6.9 Résultats obtenus avec le prouveur de théorèmes daTac

6.9.1 Introduction - Corpus de protocoles étudiés
J. Clark et J. Jacob ont rassemblé, dans un rapport datant de 1997 [26], un grand nombre de
protocoles cryptographiques qui avaient été proposés au cours du temps par divers auteurs. Bien
que ce rapport ne contienne pas de protocoles récent, la liste des protocoles recensés a fini par faire
office de banc de test non officiel de la plupart des outils d’analyse de protocoles.
Nous avons vu que l’algorithme 6.1 ne termine pas si un protocole étudié est correct. Aussi,
nous nous sommes focalisés sur les protocoles qui étaient déjà rapportés comme erronés dans de
précédents articles. C’est lors d’expériences sur la validation de protocoles (voir le chapitre 8) que
nous nous sommes intéressés à des protocoles simples et présumés corrects. L’étude du protocole
proposé par D. Denning et G. Sacco [39] a indiqué qu’il pouvait être erroné. La faille possible a
été confirmée par l’analyse d’un nombre fini de sessions. Cette attaque n’ayant pas été rapportée,
à notre connaissance, avant notre travail, nous la décrivons plus précisément, et discutons des
conditions dans lesquelles elle peut se produire dans la sous-section 6.9.3.
6.9.2 Résultats obtenus

6.9.2.i Protocole expérimental
Nous n’avons pas mené directement les expériences décrites dans cette section. Elles ont été
réalisées par les participants du groupe gênois du projet AVISS [3] dans le but de comparer les
différents outils d’analyses de protocoles. Certains des outils ne pouvant pas prendre en compte
l’instanciation de protocoles rôle par rôle, les états initiaux des protocoles considérés dans cette série
de tests ne sont pas minimaux, en terme de nombre d’acteurs, pour trouver une faille. Nous avons
déjà signalé que le nombre de participants différents était, plus que la complexité des messages, la
principale limitation de notre stratégie.
Le fait d’utiliser ou non des états initiaux minimaux en terme de nombre de participants
explique la différence entre les résultats présentés dans cette section et ceux, par exemple, de [23].
L’implantation n’a pas changé depuis novembre 2000, sauf pour l’ajout de nouveaux opérateurs
(table d’adressage dispersé, ou exclusif bit à bit).
L’ordinateur utilisé était un Pentium III sous le système d’exploitation Linux, ayant une
fréquence d’horloge de 1.4 GHz, et disposant de 512 Mo de mémoire vive.
6.9.2.ii Explication du tableau 6.3

L’ordre et le nom des protocoles du tableau 6.3 sont ceux qui peuvent être trouvés dans le
rapport de J. Clark et J. Jacob [26]. La deuxième colonne contient l’attaque trouvée par notre
outil. La plupart des attaques étant des failles d’authentification, nous avons jugé utile de décrire
plus précisément l’erreur.
Re-jeu : dans une attaque de Re-jeu, l’intrus envoie sans le modifier un message qui avait déjà
été envoyé par un principal honnête et déjà reçu par un autre principal honnête ;
Erreur de typage : les attaques reposant sur des erreurs de typage sont toutes des attaques
d’authentification, celle sur le protocole Shamir Rivest Adelman Three Pass Protocol mise à
part ;
Re-jeu : dans ce type d’attaque, si l’intrus parvient à casser une clef qui a été échangée, il
peut la faire ré-accepter par des acteurs honnêtes lorsque ceux-ci cherchent à la renouveler ;
Authentification : une attaque est dite Authentification si l’intrus parvient à faire un même
message (une clef ou un nonce) dans deux sessions se déroulant en parallèle ;
intermédiaire : dans les attaques « intermédiaire », l’intrus est considéré comme un parte-
naire honnête par un acteur a. Il utilise alors cet acteur pour se faire passer pour a vis-à-vis
d’un autre acteur b. Pour qu’il y ait erreur, il ne faut pas que a pense communiquer avec b.
6.9. Résultats obtenus avec le prouveur de théorèmes daTac 117
Protocole Attaque Temps (s)

ISO symmetric key 1-pass unilateral authentication Re-jeu 1.98
ISO symmetric key 2-pass mutual authentication Re-jeu 3.86
Andrew Secure RPC Protocol Erreur de typage 4.26
Re-jeu 32.74
ISO CCF 1-pass unilateral authentication Re-jeu 2.23
ISO CCF 2-pass mutual authentication Re-jeu 4.55
Needham-Schroeder Conventional Key Re-jeu 63.43
Denning-Sacco (symmetric) Erreur de typage 15.98
Otway-Rees Erreur de typage 10.71
Otway-Rees simplified Erreur de typage 111.55
Yahalom with Lowe’s alteration Erreur de typage 44.08
Woo-Lam Π1 Erreur de typage 0.81
Woo-Lam Π Authentification 1074.95
Woo-Lam Mutual Authentication Authentification 245.56
Needham-Schroeder Signature protocol intermédiaire 53.88
Neuman Stubblebine initial part Erreur de typage 6.19
Neuman Stubblebine repeated part Re-jeu 3.54
Neuman Stubblebine (complete) Erreur de typage 46.78
Kehne Langendorfer Schoenwalder (repeated part) Authentification 199.43
Kao Chow Repeated Authentication, 1 Re-jeu 76.82
ISO public key 1-pass unilateral authentication Re-jeu 4.23
ISO public key 2-pass mutual authentication Re-jeu 11.06
Needham-Schroeder Public Key intermédiaire 12.91
Needham-Schroeder with Lowe’s fix Erreur de typage 31.12
SPLICE/AS Authentication Protocol Re-jeu 352.42
Hwang and Chen’s modified SPLICE intermédiaire 13.10
Denning Sacco Key Distribution with Public Key intermédiaire 936.90
Shamir Rivest Adelman Three Pass Protocol Erreur de typage 0.70
Encrypted Key Exchange Authentification 240.77
Davis Swick Private Key Certificates, protocol 1 Erreur de typage 106.15
Davis Swick Private Key Certificates, protocol 2 Erreur de typage 348.49
Davis Swick Private Key Certificates, protocol 3 Re-jeu 2.68
Davis Swick Private Key Certificates, protocol 4 Re-jeu 35.97
Tab. 6.3 – Résultats des expériences menées dans le cadre du projet AVISS.
1. A → S : A, B
s s
2. S → A : {B , Kab, T , {A, Kab, T }Kbs }Kas
s
3. A → B : {A, Kab, T }Kbs
Fig. 6.3 – Protocole de D. Denning et G. Sacco (Denning-Sacco (symmetric))
6.9.3 Cas du protocole de D. Denning et G. Sacco

Dans un article datant de 1981, D. Denning et G. Sacco analysent le protocole proposé par
R. Needham et M. Schroeder et reposant sur des clefs symétriques (protocole 6.3.1 de [26], « Need-
ham-Schroeder Conventional Key » dans la table 6.3). En utilisant une notation de haut niveau,
les messages échangés dans ce protocole sont décrits dans la figure 6.2.
1. A → S : A, B , Na
s s
2. S → A : {Na, B , Kab, {Kab, A}Kbs }Kas
s
3. A → B : {Kab, A}Kbs
s
4. B → A : {Nb}Kab
s
5. A → B : {Nb − 1 }Kab
Fig. 6.2 – Protocole de R. Needham et M. Schroeder à clefs symétriques (Needham-Schroeder

Conventional Key)
Les auteurs analysent que ce protocole souffre d’une attaque de répétition si la clef Kab est
compromise : un acteur jouant le rôle de B, au message 3, n’a pas les moyens de savoir si la clef Kab
est fraı̂che. Ils proposent, dans le même article, une correction à cette faille. La suite des messages
du protocole amendé est décrite dans la figure 6.3.
Dans la figure 6.3, T est une date permettant à B de s’assurer que la clef Kab a été créée
récemment. Notre outil a permis de trouver une attaque sur ce protocole en dépit de cette correction.
Notons par une minuscule correspondante un acteur jouant un rôle A, B ou S. L’attaque trouvée
correspond à la suite de messages :
4. I → s : b, a
s s
5. s → I : {a, kab, t, {b, kab, t}kas }kbs
s s
6. I → b : {a, kab, t, {b, kab, t}kas }kbs
L’acteur b accepte ce dernier message, car il le compare au message attendu :
s
{a, xkab , xt }kbs
et que dans l’implantation dans daTac, l’opérateur de couple est associatif à gauche. Donc la
s
variable xt est unifiée avec le message t, {b, kab, t}kas .
Cette attaque a peu de chance de pouvoir être reproduite dans une implantation du protocole
avec des primitives cryptographiques parfaites. Cependant, si le chiffrement est fait par bloc, par
s,cbc s,ebc s
un opérateur de type { } ou { } , l’intrus peut déduire exactement le message {a, kab, t}kbs
attendu par b.
Cette attaque, si elle est réalisable sur une implantation du protocole, la rend inutilisable : un
individu malhonnête disposant de peu de moyens peut distribuer des clefs différentes à tous les
acteurs, les empêchant ainsi de communiquer entre eux. Notons cependant que l’intrus ne parvient
pas à récupérer la clef kab elle-même. Il parvient donc à bloquer les communications entre les
acteurs, mais ne parvient pas à décoder les messages envoyés.
6.9.4 Conclusion
Le prouveur de théorème daTac est spécialisé pour la déduction dans les théories associatives et
commutatives (AC). Plusieurs types de règles d’inférences utilisent l’unification modulo AC. Cette
caractéristique en fait un outil très souple, mais aussi relativement peu performant. De fait, des
implantations ultérieures de l’algorithme 6.1 en Prolog ou dans un programme Haskell (Ofmc, un
autre outil développé dans le cadre du projet AVISS) sont beaucoup plus performantes (d’un facteur
entre 100 et 1000) que celle que nous avons réalisée. Mis à part la dernière version d’Ofmc [6], il s’agit
cependant essentiellement d’optimisation de l’implantation, et pas d’amélioration de l’algorithme
présenté.
Au passage, notons que sous les mêmes hypothèses sur le chiffrement, le protocole original de
R. Needham et M. Schroeder a aussi une faille de ce type. Elle n’a pas été détectée dans ce premier
s,ebc s,cbc
cas par notre outil car les opérateurs { } et { } ne sont pas complètement pris en compte
par notre outil. Cet exemple nous pousse donc à étendre l’implantation actuelle pour prendre en
compte de manière complète les propriétés du chiffrement par blocs.
6.10. Travaux reliés 119

6.10.1 Complétude de la stratégie de résolution de contraintes
À notre connaissance, la modélisation des actions de l’intrus par un système de résolution de
contraintes a été introduite par R. Amadio et D. Lugiez [1], dans un cadre plus restreint que celui
que nous avons considéré. Ils considèrent le cas où les variables ne peuvent être remplacées que
par des constantes, avec uniquement le chiffrement par clefs symétriques atomiques. Les acteurs
honnêtes sont modélisés par des processus CSP, et l’intrus par un environnement contenant, pour
chaque message reçu par un acteur honnête, ses connaissances au moment de la réception de
ce message et le message reçu comme contrainte sur ces connaissances. Les auteurs associent, à
chaque action d’un des processus CSP, une substitution qui affecte l’ensemble des contraintes par
le biais de substitutions explicites. Ces contraintes sont simplifiées au fur et à mesure. Un ordre
sur les variables permet de montrer la complétude de la résolution de contraintes symboliques sur
la recherche d’attaques. Ce cadre a ensuite été étendu par les mêmes auteurs et V. Vanackère pour
prendre en compte le chiffrement asymétrique [2]. Dans notre système, l’ordre sur les variables se
réduit à la condition Var(Ei ) ⊆ ∪ij=1 Var(tj ). De plus, l’intrus ne suit pas exactement les actions de
décodage d’un message des acteurs honnêtes, ce qui permet de traiter les erreurs de typage. Enfin,
notre modèle permet de traiter le cas de clefs composées, ce qui serait plus délicat en utilisant des
substitutions explicites.
La preuve de complétude, dans le cadre traité dans ce chapitre, de la stratégie paresseuse de
l’intrus pour la recherche d’attaques a été l’objet de plusieurs articles. M. Fiore et M. Abadi d’une
part [49], et M. Boreale d’autre part [13], ont présenté dans le formalisme des strand-space des
algorithmes pour calculer des traces symboliques d’exécutions. Dans le premier de ces articles, seul
le cas des clefs atomiques est traité. De plus, les algorithmes présentés sont complexes. J. Millen et
V. Shmatikov ont clarifié certaines notions liées aux problèmes de construction simultanée [73]. Ils
commencent aussi par montrer qu’il est possible d’éliminer les variables des ensembles de connais-
sances. Mais la preuve présentée diverge rapidement de celle proposée dans ce chapitre. En effet,
comme dans tous les systèmes de résolution de contraintes symboliques dont nous avons connais-
sance, les mêmes règles servent à exprimer les possibilités de déduction de l’intrus (le système LDY
dans ce chapitre), et la résolution de contraintes (le système L de ce chapitre). Il en résulte une
preuve qui semble plus complexe que celle présentée dans ce chapitre, et un système de résolution
de contraintes plus complexe.
6.10.2 Implantation de la stratégie paresseuse de l’intrus

La plupart des nouveaux outils présentés depuis 2001 intègrent une forme de stratégie pares-
seuse de résolution de contraintes pour modéliser l’intrus. La stratégie présentée dans [1] a été
raffinée [2] pour prendre en compte les clefs publiques et privées. Enfin, les mêmes auteurs ont
présenté un résultat de réduction d’ordre permettant de ne pas avoir à prendre en compte tous les
entrelacements des actions des acteurs honnêtes [2].
D’autres articles se sont basés sur ces travaux pour implanter un algorithme efficace de recherche
d’attaques sur les protocoles. R. Corin et S. Etalle présentent une amélioration du système proposé
par J. Millen et V. Shmatikov prenant en compte des sessions partielles [29] : ils proposent de faire
une recherche paresseuse de l’ordre d’exécution. D. Basin, S. Mödersheim et L. Viganò présentent [6]
une amélioration plus substantielle. Les auteurs se proposent d’étendre le système de résolution de
contraintes pour pouvoir considérer de manière semi-indépendante des principaux différents. Cette
technique permet de réduire grandement le temps de calcul pris par l’exploration paresseuse de
tous les ordres d’exécution satisfaisables.
7
Problèmes d’accessibilité non clos
7.1 Motivations
Dans ce chapitre, nous nous intéressons au problème de la complexité de la recherche d’attaques
sur des instances de protocoles ayant un nombre fini de participants, chaque participant ne pouvant
jouer qu’une session. Notre but est d’étendre le cadre pour la recherche d’attaques mis en place par
D. Dolev et A. Yao au-delà de l’hypothèse de chiffrement parfait. Autrement dit, nous considérons le
problème de la recherche d’attaques sur une instance d’un protocole lorsque les messages échangés
sont construits sur une signature Fproto comprenant certains des constructeurs suivants :
s,cbc s,ebc p,rsa
{} ,{ } , ⊕({ }), { } , Exp( , )
en plus des constructeurs standards :
p s
h , i , { } , { } , H( , )
Les messages sont donc, dans tous les cas, des termes valeurs. Nous rappelons que ces termes,
lorsqu’ils sont en forme normale, représentent les classes d’équivalences des termes qu’il est possible
de construire, voir le chapitre 3, section 3.4 pour plus de détails.
La méthode générale que nous utiliserons, pour la recherche d’attaque, peut s’énoncer ainsi :
1. considérer des attaques minimales dans un sens qui sera défini en 7.3 ;
2. montrer que la représentation d’une attaque minimale est bornée polynomialement en la taille
de l’instance du protocole considérée ;
3. en déduire un algorithme de recherche d’attaque minimale.
7.2 Définition du problème

7.2.1 Introduction
Dans ce chapitre, nous considérons différents systèmes de règles de déduction pour l’intrus
indépendamment les uns des autres. La raison est que la fonction de normalisation fait « dis-
paraı̂tre » des sous-termes lors de son application. Nous cherchons à limiter le nombre de sous-
termes d’une substitution σ susceptibles de ne pas apparaı̂tre dans ptσq, avec t un terme va-
leur. Pour cela, la solution adoptée est de ne considérer les opérateurs pouvant être normalisés
qu’indépendamment les uns des autres.
Dans le reste de cette section, nous commençons, en sous-section 7.2.2, par rappeler la des-
cription d’une instance de protocole, que nous appellerons ensuite simplement protocole, par un
ensemble ordonné de règles optimisées (voir le chapitre 5, section 5.3.4 pour plus de détails). Nous
énonçons ensuite le problème de décision que nous considérons, qui est dans ce chapitre celui de
la recherche d’attaques de secret, et le formulons comme un problème d’accessibilité. Enfin, dans
les trois dernières sous-sections 7.2.4, 7.2.5 et 7.2.6, nous donnons les trois algèbres de termes que
nous considérons, et les systèmes de déductions de l’intrus respectifs.
121
122 Chapitre 7. Problèmes d’accessibilité non clos
7.2.2 Protocole
Soit F une signature ayant un nombre fini de constantes, et dont l’ensemble des constructeurs
(symboles d’arité non nulle) est inclus dans Fproto . Soit aussi X un ensemble (fini) de variables.
Nous notons T(F) l’ensemble des termes valeur sur la signature F, et T(F, X ) l’ensemble des termes
valeur sur la signature F ∪ X . Nous appelons protocole un triplet P = ({Rι ⇒ Sι }ι∈I , <I , S0 ),
dans lequel :
– I est un ensemble fini, ordonné par <I ;
– pour tout ι ∈ I, Rι et Sι sont des termes de T(F, X ) ;
– les règles Rι ⇒ Sι sont des règles de protocoles optimisées pour le modèle de Dolev et Yao
de l’intrus. En utilisant les résultats du chapitre 5, cela implique :
a) les termes Rι , Sι sont en forme normale ;
b) pour tout x ∈ Var(Sι ), il existe ι0 ≤ ι tel que x ∈ Var(Rι0 ) ;
c) enfin, nous supposons que le protocole vérifie l’hypothèse de bon ordre de décomposition
et de non décomposition des connaissances antérieures, formulées dans la section 5.5.5
du chapitre 5. Les hypothèses des propositions de la sous-section 5.5.6 sont vraies. En
notant, pour tout ι ∈ I : [
Xι = Var(Rι0 )
ι0 <I ι
on a les propriétés suivantes :

1. pour tout sous-terme ⊕({t1 , . . . , tn }) d’un Rι , pour tout i, j ∈ {1, . . . , n}, si i 6= j
et si Var(ti ) 6⊆ Xι , alors Var(tj ) ⊆ Xι ;
p,rsa
2. pour tout sous-terme {t} tα1 ,...,tαn ou Exp(t, {tα αn
1 , . . . , tn }) de Rι , on a :
1
{1 n }
∀i ∈ {1, . . . , n} , Var(ti ) ⊆ Xι
La première propriété indique que dans un sous-terme ⊕({t1 , . . . , tn }) du protocole, il existe

au plus un indice i tel que les variables de ti n’apparaissent pas dans un message reçu
p,rsa
précédemment. Informellement, la seconde indique que si un sous-terme Exp(t, M) ou {t}M
est attendu par un acteur, alors cet acteur connaı̂t tous les termes de (M) avant la
réception du message. Plus formellement, toutes les variables des termes de (M) appa-
raissent dans les messages précédemment reçus.
Dans le cadre proposé dans [20], un opérateur spécial de multiplication avait été préféré aux
multi-ensembles généralisés, et la condition suivante avait été imposée aux termes : l’opérateur
de produit doit nécessairement être sous-terme d’un autre opérateur de produit ou le second ar-
gument du constructeur de l’exponentielle. Cette restriction est implicite dans notre formalisme,
car l’utilisation de multi-ensembles de termes est restreinte au second argument d’un opérateur
p,rsa
{} ou Exp( , ). Par ailleurs, cette restriction est justifiée par la définition de l’exponentielle :
les opérations de produit n’ont de sens que dans le groupe multiplicatif donné par la base de l’ex-
ponentielle. Nous invitons le lecteur à se reporter au chapitre 2 pour une description plus précise
des opérations de chiffrement par un algorithme à clefs publiques/privées commutatif (dit de type
RSA) et de l’exponentiation.
7.2.3 Problème de la recherche d’attaques

Nous définissons une attaque par un ordre d’exécution π et une substitution σ. Un ordre
d’exécution est une bijection croissante entre une section inférieure I 0 de I (pour tout ι, ι0 ∈ I, on
a ι ∈ I 0 et ι0 <I ι implique ι0 ∈ I 0 ) et {1, . . . , k}, avec k = |I 0 |. Pour un ordre d’exécution π fixé,
nous notons Ri (resp. Si ) le terme Rπ−1 (i) (resp. Sπ−1 (i) ).
Une exécution π est σ-satisfaisable pour le système de réécriture sur des ensembles L si, en
notant :
S0 si i = 0
Ei =
Ei−1 ∪ pSi σq sinon
on a, pour tout i ∈ {1, . . . , k} :
L
pRi σq ∈ Ei−1
7.2. Définition du problème 123
Soit L un système de réécriture sur les ensembles utilisé par l’intrus pour ses déductions. Nous
disons qu’un couple (π, σ) est une attaque pour L, avec π un ordre d’exécution et σ une substitution,
L
si π est σ-satisfaisable pour L et si la constante spéciale Secret est dans Ek .
Dans le cadre de l’étude de la sécurité de protocoles cryptographiques, nous nous intéressons
au problème de décision suivant.
Attaque(P, L) : Existe-t-il une attaque (π, σ) pour L sur P ?

7.2.4 Cas du ou exclusif bit à bit
Nous commençons par considérer des protocoles sur une signature F dont les constructeurs
sont : n o
s,cbc s,ebc p s
F⊕ = h , i , { } ,{ } , { } , −1 , { } , H( , ), ⊕({ })
Le système de déduction de l’intrus R⊕ , dans ce cas, est donné comme l’union des systèmes de règles
de composition et décomposition donnés pour chaque constructeur dans le chapitre 4, section 4.5.
On définit :  S
 Rc,⊕ = Sf ∈F⊕ Lc,f
Rd,⊕ = f ∈F⊕ Ld,f
R⊕ = Rc,⊕ ∪ Rd,⊕

Par le théorème 2 du chapitre 4, R⊕ est un système local. Par le théorème 3 du chapitre 4,

pour tout ensemble E et pour tout terme t, le problème :
Accessibilite Close(E, t, R⊕ )
est décidable en temps polynomial en la somme des tailles de représentation de E et de t.
7.2.5 Cas de l’exponentielle

Dans un deuxième temps, nous considérons des protocoles sur une signature F dont les construc-
teurs sont : n o
s,cbc s,ebc p s
Fexp = h , i , { } ,{ } , { } , −1 , { } , H( , ), Exp( , )
De la même manière, nous définissons le système Rexp de règles de déduction de l’intrus en com-
binant les systèmes de règles de composition et décomposition pour chaque symbole de Fexp .
S
 Rc,exp

= L
Sf ∈Fexp c,f
Rd,exp = f ∈Fexp Ld,f
Rexp = Rc,exp ∪ Rd,exp

Les théorèmes 2 et 3 du chapitre 4 peuvent être appliqués. On montre ainsi que Rexp est un
système local, et que les problèmes d’accessibilité close :
Accessibilite Close(E, t, Rexp )

pour un ensemble de termes E et un terme t sont décidables en temps polynomial en la somme des
tailles des représentations de E et de t.
7.2.6 Cas du chiffrement asymétrique de type RSA

Enfin, nous traitons le cas du chiffrement asymétrique commutatif de type RSA en considérant
des protocoles sur une signature F dont les constructeurs sont :
n o
s,cbc s,ebc p s p,rsa
Frsa = h , i , { } ,{ } , { } , −1 , { } , H( , ), { }
De la même manière, nous définissons le système Rrsa de règles de déduction de l’intrus en combi-
nant les systèmes de règles de composition et décomposition pour chaque symbole de Frsa .
 S
 Rc,rsa = Sf ∈Frsa Lc,f
Rd,rsa = f ∈Frsa Ld,f
Rrsa = Rc,rsa ∪ Rd,rsa

Les théorèmes 2 et 3 du chapitre 4 peuvent toujours être appliqués. On montre ainsi que Rrsa
est un système local, et que les problèmes d’accessibilité close :
Accessibilite Close(E, t, Rrsa )

pour un ensemble de termes E et un terme t sont décidables en temps polynomial en la somme des
tailles des représentations de E et de t.
7.3 Théorème de complexité

La suite de ce chapitre est consacrée à la démonstration du théorème 10 énoncé ci-dessous. À
noter que la taille d’une substitution σ, notée |σ|, est la somme des tailles des termes |xσ|dag , pour
x∈ (σ). La taille d’un protocole P, notée |P|, est la somme des tailles des représentations
des règles de P et des connaissances initiales de l’intrus.
Théorème 10 (Complexité de la recherche d’attaques sur un protocole) Soit L un système de

règles de réécriture tel que :
– pour tout ensemble de termes E et pour tout terme t, Accessibilite Close (E, t, L) est dans
PTIME ;
– il existe un polynôme pL tel que pour tout protocole P, il existe une attaque (π, σ) sur P pour
L si et seulement si il en existe une avec |σ| ≤ pL (|P|).
Sous ces conditions, le problème Attaque (P, L) est dans NPTIME.
La preuve de ce théorème réside dans l’algorithme de la figure 7.1. Si les hypothèses sont
satisfaites, il suffit de rechercher une attaque (π, σ) avec |σ| ≤ pL (|P|). On a, par définition d’un
ordre d’exécution, |π| ≤ |P|. Donc deviner une attaque (π, σ) peut se faire en temps polynomial
en la taille de P. La taille de σ est bornée polynomialement en fonction de la taille de P, donc les
tailles des représentations des termes Ri σ, Si σ sont elles aussi bornées polynomialement en fonction
de la taille de P. Pour tout terme t, on a |ptq|dag ≤ |t|dag , donc d’après la seconde hypothèse, les
problèmes d’accessibilité close :
Accessibilite Close(pS0 σ, . . . , Si−1 σq, pRi σq, L)

sont résolubles en temps polynomial en la taille de P, donc l’algorithme non déterministe de la
figure 7.1 a un temps d’exécution polynomial. Cela prouve donc le théorème.
Algorithme résolvant le problème Attaque(P, L)

Soit P = ({Rι ⇒ Sι }ι∈I , <I , S0 )
Soit p le polynôme associé à L
Choisir (π, σ) avec |σ| ≤ p(|P|)
Soit k le nombre de règles dans π
Pour 1 ≤ i ≤ k, vérifier :
Accessibilite Close(pS0 σ, . . . , Si−1 σq, pRi σq, L)
Répondre Accessibilite Close(pS0 σ, . . . , Sk σq, Secret, L)
Nous savons déjà (voir le chapitre 4, théorème 3) que pour les systèmes R⊕ , Rexp et Rrsa ,
la première condition du théorème 10 sur les problèmes d’accessibilité close est satisfaite. Afin de
montrer que ce théorème s’applique à ces systèmes pour la recherche d’attaques, il suffit donc de
7.4. Borne sur le nombre de sous-termes d’une attaque normale 125
montrer que, pour ces systèmes, la seconde condition est vérifiée. Nous allons le faire en deux temps.
Tout d’abord, en section 7.4, nous montrons qu’il existe un polynôme p1 tel que, s’il existe une
attaque (π, σ) sur un protocole P, alors il en existe une (π, σ 0 ) telle que la taille de la représentation
des sous-termes de σ 0 soit inférieure ou égale à p1 (|P|). Ensuite, nous montrerons dans la section 7.5
que s’il existe une attaque (π, σ) sur P, il en existe une dont les valeurs des multi-ensembles (les
coefficients) sont descriptibles en un espace polynomial en la taille du protocole d’entrée. Notons
que cette seconde étape n’est pas nécessaire pour le cas des règles R⊕ .
Dans la suite de ce chapitre, nous utilisons la notion d’attaque normale. Soit :
ΘP = {(π, σ) | (π, σ) attaque sur P}
Une attaque (π, σ) est normale si :

(π, σ) ∈ ΘP
|σ| = min(π0 ,σ0 )∈ΘP (|σ 0 |)
7.4 Borne sur le nombre de sous-termes d’une attaque nor-

male
7.4.1 Mise en place
Soit un protocole P = ({Rι ⇒ Sι }ι∈I , <I , S0 ), dont les messages sont des termes en forme
normale et soit (π, σ) une attaque sur ce protocole. Nous désignons par X l’ensemble des variables
de P. Nous notons Ri = Rπ(−1) (i) , Si = Sπ(−1) (i) , k le cardinal du domaine de π, et :
SP = (S0 ) ∪ (∪ki=1 ( (Ri ) ∪ (Si ))) ∪ Secret
Afin d’avoir S0 6= ∅, nous supposons que la constante I désignant le nom de l’intrus est toujours
dans S0 . Nous notons :
S0 si i = 0
Ei =
Ei−1 ∪ pSi σq sinon
Si les constructeurs de F sont F⊕ , Fexp , ou Frsa , nous désignons simplement par Facteur la
fonction qui à un terme t associe ses Facteur⊕ , Facteurexp ou Facteurrsa . Si s ∈ Facteur(t), nous
dirons simplement que s est un facteur de t. De même, nous définissons, dans les cas Fexp et Frsa ,
la fonction Base qui associe à un terme sa base comme étant la fonction Baseexp ou la fonction
Basersa . Nous renvoyons le lecteur au chapitre 3, section 3.4 pour la description complète de la
base et des facteurs d’un terme et du lien avec la fonction de normalisation p q.
Afin d’harmoniser les notations, et suivant les cas, nous notons f (t1 , . . . , tn ) soit un terme
p,rsa
⊕({t1 , . . . , tn }), soit un terme Exp(t1 , M) ou {t1 }M avec (M) = {t2 , . . . , tn }. Pour deux
multi-ensembles M1 et M2 , nous notons simplement M1 + M2 et −M1 les résultats respectifs
des fonctions Add(M1 , M2 ) et Opp(M1 ) définies dans le chapitre 3, section 3.4.
Enfin, nous définissons les termes filtrants : étant donné une substitution σ, un terme t est un
σ-filtre d’un terme s si t n’est pas une variable et ptσq = s. Nous notons t vσ s si t est un σ-filtre
de s.
7.4.2 Définitions
Dans la définition suivante, si la fonction Basef n’est pas définie, l’union est à prendre unique-
ment sur les facteurs.
Définition 48 (Terme régulier)

Soient P un protocole sur une signature F, f un constructeur de F, (π, σ) une attaque sur ce
protocole. Un terme s est dit f -régulier si :
1. pour tout x ∈ Var(P), si xσ = s, alors s n’est pas un f -terme ;
2. il existe x ∈ Var(P) tel que s soit dans l’ensemble :
Facteurf (xσ) ∪ {Basef (xσ)}

Définition 49 (Terme libre)

Soient P un protocole et (π, σ) une attaque sur ce protocole. Un terme s est dit libre si, pour tout
terme t, on a t vσ s implique t ∈/ (SP \ X ).
Un terme s qui n’est pas libre est dit lié.
Définition 50 (Signature permettant le remplacement)

Soient F ∈ {F⊕ , Fexp , Frsa }, P un protocole sur F et soit (π, σ) une attaque sur P. Pour un terme
s, notons δs le remplacement [s ← I], et soit σs = σδs .
Si pour tout terme libre et régulier s on a, pour tout terme t ∈ SP :
pptσqδs q = ptσs q
nous disons que F permet le remplacement.
Définition 51 (Signature régulière)

Une signature F ⊆ Fproto est régulière si pour tout protocole P défini sur T(F, X ), pour toute
attaque (π, σ) sur P, on a :
Pour tout s régulier et libre, pour toute variable x, on a s ∈ (xσ) et x ∈
Var(Ri ) implique qu’il existe j ≤ i tel que s ∈ (pRj σq).
7.4.3 Les signatures F⊕ , Fexp et Frsa sont régulières

Montrons que les signatures F⊕ , Fexp et Frsa sont régulières. Fixons
p,rsa
(f, F, L) ∈ {(⊕({ }), F⊕ , R⊕ ), (Exp( , ), Fexp , Rexp ), ({ } , Frsa , Rrsa ), }
Si la fonction Base est définie et s’il existe t tel que s = Base(t), alors s n’est pas un f -terme. Nous
utilisons cette remarque pour montrer le lemme 23.
Lemme 22
Si f = ⊕({ }), alors l’ensemble des termes réguliers est :
[
Facteur(xσ)
x∈Var(P)
Preuve. Par définition, l’ensemble des termes réguliers est inclus dans :
[
F = Facteur(xσ)
x∈Var(P)
Montrons qu’il y a égalité. Soit s ∈ F . Par définition de la fonction de normalisation pour l’opérateur
⊕, s n’est pas un ⊕-terme. Donc s est régulier.
Lemme 23
Soient s un terme f -régulier, y ∈ X tel que s ∈ (yσ) et :
Sy = {t ∈ SP | y ∈ Var(t) et s ∈ (ptσq)}
Pour tout r ∈ Sy , soit s est un sous-terme strict de prσq, soit s n’est pas un f -terme.
Preuve. Il s’agit d’une conséquence de s régulier et du lemme 22 pour le cas F = F⊕ .
Sinon, supposons que s soit un f -terme. L’hypothèse s régulier implique s 6= yσ. Donc yσ
normalisé et s 6= yσ implique s 6= Base(yσ). Donc par définition de la fonction de normalisation et
de la base, pour tout r ∈ Sy , s 6= Base(prσq). Ce qui implique, entre autres, s 6= prσq.
Lemme 24
Soient s et t deux termes, et σ une substitution telle que s ∈ (ptσq). Alors :
1. soit il existe x ∈ Var(t) telle que s ∈ (xσ) ;
2. soit s est lié.
Preuve. Supposons 1. faux. Soit :

Θ = {r ∈ (t) | s ∈ (prσq)}
Θ n’est pas vide car cet ensemble contient t. Soit t0 ∈ Θ minimal pour la relation de sous-terme. Si
t0 est une constante, on a t0 = pt0 σq = s et t0 ∈ SP, ce qui prouve le lemme. Le premier cas faux
implique que t0 n’est pas une variable.
Si t0 = g(t1 , . . . , tn ), avec g 6= f , on a directement pt0 σq = s par minimalité de t0 .
Si t = f (t1 , . . . , tn ), alors :

0 f (Base(pbσq), Facteur(pbσq) + pMσq) si Facteur(pbσq) + pMσq 6= 0
pt σq =
Base(pbσq) sinon
donc s 6= pt0 σq implique soit s ∈ (pbσq), soit il existe t00 ∈ (M ) tel que pt00 σq = s. Ces
deux cas contredisent la minimalité de t0 , donc pt0 σq = s.
Notons que si s n’est pas un f -terme, il existe un terme ts ∈ (SP \ X ) tel que pts σq = s et tel
que ts ne soit pas un f -terme.
Lemme 25
Soit s régulier et x ∈ Var(Rk ) tel que :
s ∈ Facteur(xσ) ∪ {Base(xσ)}
Alors soit il existe j ≤ i tel que soit s ∈ (pRj σq), soit s est lié.
Preuve. Si s est une constante, alors s ∈ SP, ce qui prouve le lemme. Supposons dans la suite
que s n’est pas une constante. Soit :
Xs = {x ∈ Var(P) | s ∈ (xσ)}
Et soit i minimal tel que Vi = Var(Ri ) ∩ Xs 6= ∅. Pour y ∈ Vi , soit :
Sy = {t ∈ (Ri ) | y ∈ Var(t) et s ∈ (ptσq)}
et soit ry maximal dans Sy pour la relation de sous-terme. S’il existe y ∈ Vi tel que ry = Ri , par
minimalité de i, le lemme est vrai pour toute variable x telle que s ∈ (xσ) et pour tout j tel
que x ∈ Var(Rj ). Sinon, fixons un y parmi ceux possibles, soit :
Θy = {t ∈ (Ri ) | ry ∈ (t) \ {t}}
Soit t minimal pour la relation de sous-terme dans Θy . Par maximalité de r, on a s ∈ / (ptσq),
et donc t = f (t1 , . . . , tn ). Si f = ⊕, et s’il existe i tel que Var(ti ) 6⊆ Var(R1 , . . . , Ri−1 ), alors quitte
à réordonner les termes, supposons i = 1. Par hypothèse sur les protocole, on a donc dans tous les
cas Var(t2 , . . . , tn ) ⊆ Var(R1 , . . . , Ri−1 ), donc par minimalité de i, on a nécessairement ry = t1 .
D’après le lemme 23, si pt1 σq = s, alors s régulier implique que s n’est pas un f -terme, et donc s
p,rsa
est un sous-terme de pt1 σq, ce qui contredit la maximalité de r. Dans les cas f ∈ {Exp( , ), { } },
on ne peut pas avoir s ∈ (Base(pt1 σq)), car alors, par définition des fonctions de normalisation,
on aurait s ∈ (ptσq). Donc, dans tous les cas :
s∈ (Facteur(pt1 σq))
Soit ts le facteur contenant s. Par définition des fonctions de normalisation, s ∈ / (ptσq) implique
qu’il existe t0 ∈ {t2 , . . . , tn } tel que pt0 σq = ts . On a Var(t0 ) ⊆ Var(R1 , . . . , Ri−1 ), le terme s est
dans (pt0 σq) et pour tout z ∈ Var(t0 ), le terme s n’est pas sous-terme de zσ par minimalité de
i.
Par le lemme 24, il existe t00 ∈ ( (t) \ X ) tel que t00 vσ s. Ce qu’il fallait démontrer.
Remarquons que dans le cas de la signature F⊕ , s est régulier implique s n’est pas un ⊕-terme.
Donc par définition de la fonction de normalisation, dans la preuve du lemme précédent, v minimal
pour la relation de sous-terme implique que v n’est pas un ⊕-terme.
Corollaire 4
Les signatures F⊕ , Fexp et Frsa sont régulières.
7.4.4 Les signatures F⊕ , Fexp et Frsa permettent le remplacement

Le fait, pour une signature, de permettre le remplacement est dépendant de la fonction de
normalisation associée à cette signature. Les différences entre les propriétés de la fonction de
normalisation pour la signature F⊕ d’un côté, et des fonctions de normalisation pour les signatures
Fexp et Frsa de l’autre justifient, à nos yeux, un traitement séparé. Nous commençons par traiter
le cas des signatures Fexp et Frsa et traitons ensuite, et séparément, du cas de la signature F⊕ .
Énonçons tout de suite la proposition suivante, qui est une conséquence directe des lemmes 26
et 27.
Proposition 46
Les signatures F⊕ , Fexp et Frsa permettent le remplacement.
7.4.4.i Cas des signatures Fexp et Frsa

p,rsa
Pour le reste de cette sous-section, fixons f ∈ {Exp( , ), { } }. La fonction Base est donc
bien définie, et on note que dans ces deux cas, s’il existe t tel que s = Base(t), alors s n’est pas un
f -terme. Nous utilisons cette remarque pour montrer le lemme suivant.
Lemme 26
Si F ∈ {Fexp , Frsa }, alors F permet le remplacement.
Preuve. Soit s libre et régulier et δs , σs comme dans la définition 50. Le terme s est libre et en
forme normale, donc :
(tσ)δs = tσs
et donc ptσs q = p(tσ)δq. Montrons par induction que pour tout t :
pptσqδs q = p(tσ)δs q
Si t est une constante, alors t ∈ SP, donc t 6= s, et donc t = tσ = (tσ)δ. Si t est une variable,
alors tσ = ptσq, et donc tσs = p(tσ)δq.
Si t = g(t1 , . . . , tn ), avec g constructeur libre, alors par définition de la normalisation, on a :
ptσq = g(pt1 σq, . . . , ptn σq)
On a s libre, donc s 6= ptσq et donc, par induction :
ptσs q = g(pt1 σs q, . . . , ptn σs q)

= g(ppt1 σqδq, . . . , pptn σs qδq)
= pg(pt1 σq, . . . , ptn σq)δq
= pptσqδq
Si t = f (u, M). Notons tout d’abord que s libre implique ptσq 6= s. De plus, s est en forme
normale, donc f (puσq, pMσq) 6= s. Enfin, par récurrence, on a ppuσqδq = puσs q et ppMσqδq =
pMσs q. Donc :
ptσs q = pf (uσs , Mσs )q

= pf (puσs q, pMσs q)q
= pf (ppuσqδq, ppMσqδq)q
= pf (puσqδ, pMσqδ)q
= pf (puσq, pMσq)δq
Si puσq n’est pas un f -terme, ou si s ∈

/ ({puσq} ∪ (pMσq)), on peut conclure immédiatement :
ptσs q = ppf (uσ, Mσ)qδq

Sinon, s libre implique qu’il existe y ∈ Var(t) tel que s ∈ (yσ). Par le lemme 23, et par s
libre et régulier, si s est un f -terme, alors s est soit un sous-terme strict de Base(puσq), soit un
sous-terme de t0 ∈ (pMσq) ∪ Facteur(puσq). Donc, que s soit un f -terme ou non, on a :
f (puσq, pMσq)δ = pf (uσ, Mσ)qδ
Dans tous les cas, on a donc :

ptσs q = pptσqδq
ce qu’il fallait démontrer.
7.4.4.ii Cas de la signature F⊕

Il est possible de montrer directement que la signature F⊕ permet le remplacement.
Lemme 27 Soit un terme s libre et régulier et δs , σs comme dans la définition 50. Pour tout
t dans SP, on a :
pptσqδs q = ptσs q
Preuve. Le terme s est libre, donc pour tout t ∈ SP, on a
(tσ)δs = t(σδs )
et donc ptσs q = p(tσ)δs q.

Montrons par induction sur la structure des termes que pour tout t ∈ SP, on a ptσs q =
pptσqδs q.
– Si t est une constante, alors t 6= s par hypothèse, et donc pptσqδq = t = ptσs q ;
– si t ∈ X , alors ptσq = tσ, et donc
ptσs q = p(tσ)δq
= pptσqδq
– si t = g(t1 , . . . , tn ) avec g 6= ⊕, on a s libre et ptσq = g(pt1 σq, . . . , ptn σq) impliquent

s 6= g(pt1 σq, . . . , ptn σq). Par induction, on a donc ptσs q = g(ppt1 σqδq, . . . , pptn σqδq), et
par conséquent :
ptσs q = ppg(t1 σ, . . . , tn σ)qδq

= pptσqδq
car s 6= ptσq ;
– si t = ⊕({t1 , . . . , tn }), nous remarquons que s régulier implique s n’est pas un ⊕-terme, et
donc ptσq = s implique qu’il existe i tel que pti σq = s.
Le terme s est libre, donc pour tout i ∈ {1, . . . , n}, on a pti σq 6= s et ptσq 6= s. On a donc :
ptσs q = p⊕({t1 σs , . . . , tn σs })q

= p⊕({pt1 σs q, . . . , ptn σs q})q
= p⊕({ppt1 σqδq, . . . , pptn σqδq})q (Par induction)
= p⊕({pt1 σqδ, . . . , ptn σqδ})q
= p⊕({pt1 σq, . . . , ptn σq})δq (car ⊕ ({pt1 σq, . . . , ptn σq}) 6= s)
= pptσqδq
Ce qui conclut la preuve du lemme.
7.4.5 Termes liés dans une attaque minimale

Dans cette sous-section, nous considérons une signature régulière F égale à F⊕ , Fexp ou Frsa ,
et le système de règles de réécritures sur les ensembles L égal à R⊕ , Rexp ou Rrsa .
Terme décomposé par une règle. Nous appelons une g-règle une règle de g-composition ou
de g-décomposition. Pour une g-règle de réécriture sur les ensembles R :
l1 , . . . , l n → r
nous disons que l1 est le terme décomposé par R si l1 est un g-terme et r est un sous-terme de l1
maximal pour la relation de sous-terme dans (l1 ) \ {l1 }.
Lemme 28
L
Soient E et F deux ensembles avec I ∈ E. Soient s et t deux termes avec s ∈ E \ (E), et
L
t ∈ E ∪ F . Soit enfin δ le remplacement de [s ← I]. Alors on a :
L
ptδs q ∈ p(E ∪ F )δs q
Preuve. Pour commencer, si s ∈ / (F, t), le résultat est trivial : δs est égal à l’identité sur
(E, F, t). Supposons maintenant s ∈ (F, t). Tous les systèmes de réécriture considérés sont
locaux, ce qui assure l’existence de dérivations bien formées.
L
Par hypothèse, on a s ∈ E . Donc par le lemme 4, la dernière étape d’une dérivation bien
formée partant de E de but s est une règle de composition. Soit s1 , . . . , sn →Lc s cette règle,
L
avec {s1 , . . . , sn } ⊆ E et {s1 , . . . , sn } ⊆ (E ∪ {s}). Soit f un constructeur tel que cette règle
soit une f -règle de composition. Par la proposition 9, il existe des dérivations D1 , . . . , Dn et Dt ,
éventuellement de longueur 0, telles que :
E, F →∗D1 F, E1 →∗ . . . →∗Dn F, En →∗Dt G
avec Di bien formée de but si , pour i ∈ {1, . . . , n}, et Dt bien formée de but t. Par l’hypothèse
s∈ (F, t), la concaténation de ces dérivations est une dérivation bien formée. Notons-la D :
D : G0 = E, F → G0 , t1 = G1 → . . . → G0 , t1 , . . . , tm = Gm
Considérons la suite d’ensembles (pGi δs q)i∈{0,...,m} et montrons qu’il existe une dérivation :
Dδs : pG0 δs q → . . . → pGm δs q
Tout d’abord, quitte à raccourcir la suite d’ensembles, supposons pGi δs q 6= pGi+1 δs q.

Affirmation 1. Si s ∈
/ l ∪ {r} et l → r est une g-règle, alors plδs q → prδs q est encore une
g-règle.
Preuve. La quantification dans la définition des règles de composition et de décomposition

implique que si l → r est une g-règle de L et si s ∈
/ l ∪ {r}, alors plδs q → prδs q est encore une
g-règle.
Notons encore que si r = s, alors rδs = I. Par l’hypothèse I ∈ E, on a I ∈ pG0 δs q, et donc la

transition est éliminée.
Pour montrer le lemme, il suffit donc de montrer que pour toute g-règle l → r avec s ∈ l et
s 6= r, plδs q → prδs q est encore une g-règle. Le terme s n’est sous-terme d’aucun si ni de E, donc
si cette règle est appliquée sur un ensemble Gj , on a si ∈ Gj pour tout i ∈ {1, . . . , n}.
Affirmation 2. Si g 6= f , alors plδs q → prδs q est encore une g-règle.
Preuve. Par définition des règles de composition, s n’est pas un g-terme. La constante I
n’est jamais exclue par les quantifications dans la définition des règles de composition et de
décomposition. Il est donc possible de remplacer s par I dans le membre gauche d’une g-règle.
Le résultat sera alors prδs q.
Affirmation 3. Si g = f , alors plδs q → prδs q est encore une g-règle.

Preuve. Si f est un constructeur libre, la dérivation est bien formée, donc l → r n’est pas
une règle décomposant s. L’affirmation est alors facilement vérifiée.
Soit G l’ensemble sur lequel l → r est appliqué, et G0 = G \ {s}. On a :
G0 →Lc,f G0 , s →l→r G0 , s, r
Si G0 → G0 , r, alors le résultat est une conséquence de l’affirmation 1. Le système Lf est

canonique, donc s ∈ (G0 , r). Plus précisément (voir le chapitre 4), on peut supposer que
p,rsa
f 6= ⊕ et que pour f ∈ {{ } , Exp( , )}, la règle est de la forme :
b, l1 , . . . , lk → pf (b, M)q
avec b 6= s, (M) = {l1 , . . . , lk } et s ∈ (M). On vérifie alors que plδs q → prδs q est
encore une f -règle.
Les affirmations 2. et 3. entraı̂nent que pour toute règle l → r de L avec s dans l ∪ {r},
plδs q → prδs q est encore une règle de L. Par l’affirmation 1., c’est vrai pour toute règle, donc par
récurrence, la suite (pGi δs q)i∈{1,...,m} forme une dérivation. Quitte à la tronquer, on peut supposer
qu’elle est de but ptδs q.
Le lemme suivant est le lemme fondamental permettant de borner le nombre de sous-termes
d’une substitution.
Lemme 29
Tout terme s régulier est lié.
Preuve. Par contradiction, supposons :
(*) il existe s régulier et libre
Les constantes sont dans SP, donc s n’est pas une constante. Par (*) et F régulière, l’ensemble
des j tel que s ∈ (pRj σq) est non vide. Soit Ns le minimum de cet ensemble. D’après (*), il
existe y ∈ Var(RNs ) tel que s soit un sous-terme de yσ.
Commençons par montrer qu’il n’existe pas i < Ns tel que s ∈ (pSi σq). Si s ∈ (pSi σq),
alors par (*) et F régulière, il existe z ∈ Var(Si ) tel que s ∈ (zσ). Donc par hypothèse sur les
protocoles, il existe i0 ≤ i tel que z ∈ Var(Ri0 ). Par minimalité de Ns , on a donc i > Ns .
Posons Ej = pS0 σ, . . . , Sj σq, et résumons la situation : le terme s est dans (pRNs σq) \
(ENs −1 ), et n’est dans aucun (Ej ) pour j ≤ Ns − 1. Soit δ = [s ← I], L le système de
réécriture associé à la signature F, et considérons les problèmes d’accessibilité close :
Accessibilite Close(pEj−1 δq, ppRj σqδq, L)
– si j < Ns , alors s n’est sous-terme ni de l’ensemble de départ ni du but, donc pEj−1 δq = Ej−1
et ppRj σqδq = pRj σq. Par hypothèse, (π, σ) est une attaque, donc ces problèmes ont une
solution affirmative ;
– si j ≥ Ns , alors par le lemme 26 et (π, σ) attaque, ces problèmes ont une solution affirmative.
La signature F permet le remplacement, s est supposé libre et régulier, donc en posant σ 0 = σδ,
on vient de montrer que (π, σ 0 ) est aussi une attaque sur P. Le terme s n’est pas atomique, donc
l’existence de cette attaque contredit la minimalité de (π, σ).
7.4.6 Borne sur la taille de la représentation des sous-termes d’une sub-

stitution dans une attaque normale
D’après le lemme 29, dans ce cadre, tous les sous-termes réguliers sont liés. Montrons que cela
suffit pour borner la taille de la représentation des sous-termes dans σ en fonction de la taille de
la représentation de SP.
L’attaque (π, σ) permet de définir un ordre <σ sur SP en posant, pour t, t0 ∈ SP :
t <σ t0 si et seulement si ptσq ∈ (pt0 σq) \ {pt0 σq}
Le lemme 30, basé sur le lemme 29, exprime que la substitution d’une attaque (π, σ) est
construite de manière « rigide ». Il est énoncé avec les notations précédentes.
Lemme 30
Pour tout t ∈ SP, il existe un symbole g et des termes t1 , . . . , tn dans SP, avec n ≥ 0, tels que :

Preuve. Soit :
Θ = {t ∈ SP | ∀g ∈ F, ∀n ∈ , ∀t1 , . . . , tn ∈ SP, ptσq 6= g(pt1 σq, . . . , ptn σq)}
Par contradiction, supposons Θ non vide, et soit t ∈ Θ.

Affirmation 1. t n’est pas une constante.
Preuve. Si t est une constante, prendre g = t et n = 0.
Affirmation 2. Si t est un g-terme, alors g = f .
Preuve. Sinon, soit t = g(t1 , . . . , tn ). Par définition de la fonction de normalisation, on a :
ce qui contredit t ∈ Θ.
Affirmation 3. t n’est pas une variable.
Preuve. Supposons t ∈ X . Le cas ptσq g-terme, avec g 6= f , est exclu par le lemme 29.
Donc t ∈ Θ implique ptσq = tσ = f (s1 , . . . , sn ). Par le lemme 29, pour tout i ∈ {1, . . . , n}, si
régulier implique qu’il existe ti ∈ SP tel que pti σq = si . Sinon, il existe une variable xi dans
SP telle que xi σ = si . Donc on peut écrire :
ptσq = f (pt1 σq, . . . , ptn σq)
ce qui implique que Θ ne peut pas contenir de variables.

Affirmation 4. t n’est pas un f -terme.
Preuve. Supposons t = f (t1 , . . . , tn ). Si aucun des ti n’est une variable telle que pti σq
soit un f -terme, et quitte à réordonner les termes, alors t en forme normale implique soit
ptσq = pt1 σq, soit ptσq = f (pt1 σq, . . . , pti σq) avec i ≤ n. Le second cas implique t ∈ / Θ par
définition de Θ. Pour le premier cas, t en forme normale implique t1 n’est pas un f -terme, et
donc t ∈ Θ contredit l’affirmation 2. pour t1 .
p,rsa
Si f ∈ {Exp( , ), { } }, le seul cas problématique est celui t1 variable et t1 σ f -terme. Dans
ce cas, par l’affirmation 3., on a t1 σ = f (pu1 σq, . . . , puk σq) avec uj ∈ SP pour j ∈ {1, . . . , k}.
On en conclut :
ptσq = f (pu1 σq, pv1 σq, . . . , pvl σq)
avec {v1 , . . . , vl } ⊆ {t2 , . . . , tn } ∪ {u2 , . . . , uk }.
Donc t est nécessairement un ⊕-terme. Il est possible de remplacer toute variable ti par les
facteurs de pti σq et de faire une différence symétrique. Par l’affirmation 3., tous les facteurs
de pti σq sont liés, et donc tous les facteurs restant dans ptσq sont liés.
Les affirmations 1., 2., 3. et 4. impliquent que Θ est vide, ce qui prouve le lemme.
Soit ψ une fonction qui associe à chaque terme t ∈ SP un terme g(t1 , . . . , tn ) tel que ptσq =
g(pt1 σq, . . . , ptn σq) et t1 , . . . , tn ∈ SP.
Le lemme précédent donne une structure pour les substitutions σ dans les attaques normales.
Nous allons maintenant utiliser cette structure pour montrer que le nombre de sous-termes d’une
attaque normale est borné linéairement en le nombre de sous-termes du protocole, et surtout que
la taille de la représentation des sous-termes est bornée de manière quadratique en fonction de la
taille de la représentation de SP comme graphe acyclique dirigé. La fonction ψ n’introduit pas de
s,ebc s,cbc
nouveaux termes { } ou { } , donc il suffit de montrer :
[
| ( {xσ})| ≤ |SP|
x∈X
7.5. Borne sur la taille des coefficients dans une attaque normale 133
Théorème 11
Si (π, σ) est une attaque normale, alors :
[
| ( {xσ})| ≤ |SP|
S x∈X
Preuve. Soit S = ( x∈X {xσ}).
Affirmation. Soit t ∈ SP tel que ψ(t) = g(t1 , . . . , tn ). On a :

n
[
(ptσq) = {ptσq} ∪ (pti σq)
i=1
Preuve. Il s’agit d’une conséquence triviale du lemme 30.

Montrons qu’on a l’inégalité annoncée en construisant explicitement une fonction injective de S
vers SP. Pour cela, considérons une suite de couples {(Ri , Ti )}i∈{0,...,n} , avec R0 = X et T0 = SP.
Le couple (Ri+1 , Ti+1 ) est construit à partir du couple (Ri , Ti ) de la manière suivante. On choisit
r ∈ Ri tel que prσq soit maximal pour la relation de sous-terme dans pRi σq. Par induction, il
existe t ∈ SP tel que ptσq = prσq. On pose alors :

Ri+1 = Ri \ {r} ∪ {r1 , . . . , rn } si ψ(r) = g(r1 , . . . , rn )
Ti+1 = Ti \ {t}
Le terme t est dans Ti par maximalité des choix précédents, et n’est plus susceptible d’être choisi
par la suite par maximalité dans le choix de r. Par l’affirmation, on a n = | (S)|. On a donc
bien | (S)| ≤ |SP|.
Notons que la taille de la représentation de l’ensemble {xσ | x ∈ X }, sans compter la place
nécessaire pour coder les coefficients dans les multi-ensembles de termes, est quadratique en la
taille de la représentation de SP sans compter les coefficients : à chaque fois qu’une exponentielle,
un ou exclusif ou un chiffrement de type RSA est choisi pour une variable, il peut y avoir O(|SP|)
sous-termes directs.
7.4.7 Complexité du problème de décision Attaque(P, R⊕)

Dans la signature F⊕ , il n’y a pas de coefficients, donc il est possible d’énoncer le théorème
suivant.
Théorème 12
Le problème de décision Attaque(P, R⊕ ) est dans NPTIME.
Preuve. D’après le théorème 10, il suffit de montrer :
a) pour tout ensemble de termes E et pour tout terme t, Accessibilite Close
(E, t, R⊕ )
est dans PTIME ;
b) il existe un polynôme p tel que pour tout protocole P, il existe une attaque (π, σ) sur P
pour R⊕ si et seulement si il en existe une avec |σ| ≤ p(|P|).
Le premier point est déjà prouvé dans le chapitre 4. Le second point est une conséquence directe
du théorème 11.
7.5 Borne sur la taille des coefficients dans une attaque nor-
male
Montrons maintenant que les problèmes de décision Attaque
(P, Rrsa ) et Attaque (P, Rexp )
sont dans NPTIME. D’après les théorèmes 10 et 11, il suffit de montrer qu’étant donné une attaque
(π, σ) sur un protocole P, il existe une attaque (π, σ 0 ) avec σ = σ 0 aux coefficients des multi-
ensembles près et avec la taille de l’espace utilisé pour représenter les coefficients de σ 0 bornée
polynomialement en la taille de la représentation du protocole.
7.5.1 Introduction
Pour la suite de cette section, nous supposons que (π, σ) est une attaque normale sur P défini
sur une signature F ∈ {Fexp , Frsa }. La définition d’une attaque implique, pour tout i ∈ {1, . . . , k} :
L
pRi σq ∈ Ei−1
Pour i ∈ {1, . . . , k}, soit Di une dérivation bien formée partant de Ei−1 et de but pRi σq, et posons :
0 ni
Di : Ei−1 = E(i−1) → . . . → E(i−1) 3 pRi σq
Dans le cadre de la signature Fexp (resp. Frsa ), nous désignons par le symbole f l’opérateur
p,rsa
Exp( , ) (resp. { } ). L’écriture f (t1 , . . . , tn ) désigne un terme f (u, M) avec u = t1 et M un
multi-ensemble généralisé (resp. un multi-ensemble) de support {t2 , . . . , tn }. Enfin, nous considérons
un ensemble Xent de variables qu’il est possible de substituer par des entiers relatifs (resp. naturels).
Soient T1 et T2 deux ensembles de termes sur la même signature, et h : p (T1 )q → p (T2 )q
une fonction. Nous disons que h est un homomorphisme de p (T1 )q vers p (T2 )q si, pour tout
g(t1 , . . . , tn ) ∈ p (T1 )q, on a :
h(g(t1 , . . . , tn )) = g(h(t1 ), . . . , h(tn ))
La fonction h est un isomorphisme si h est un homomorphisme bijectif. Plus simplement, nous

disons que h est un homomorphisme (resp. un isomorphisme) de T1 vers T2 si h est un homomor-
phisme de p (T1 )q vers p (T2 )q.
7.5.2 Relation d’équivalence modulo les coefficients

Nous commençons par introduire une relation d’équivalence ≡coef correspondant à la notion
d’égalité sur les termes modulo les coefficients.
Définition 52 (relation ≡coef )

La relation ≡coef sur les termes de T(F, X ) est définie par t ≡coef t0 si, et seulement si, il existe
un isomorphisme ϕ entre p (t)q et p (t0 )q.
Proposition 47
La relation ≡coef est une relation d’équivalence.
Preuve. En considérant la fonction identité, la relation ≡coef est réflexive. Elle est symétrique en
considérant la fonction inverse, et transitive par composition des fonctions.
Notons que par définition d’un isomorphisme, si ϕ est un isomorphisme entre deux termes t et
t0 , on a ϕ(ptq) = pt0 q.
7.5.3 Termes équivalents et dérivations

Soit E, E 0 deux ensembles normalisés de termes, t, t0 deux termes en forme normale et D une
dérivation bien formée partant de E de but t. Supposons qu’il existe un isomorphisme ϕ entre
E ∪ {t} et E 0 ∪ {t0 } tel que :
– ϕ(E) = E 0 ;
– ϕ(t) = t0 .
Proposition 48
Sous les hypothèses précédentes, et si pour toute f -règle F → u dans D il existe une f -règle
ϕ(F ) → ϕ(u), alors il existe une dérivation bien formée D0 partant de E 0 et de but t0 .
Preuve. Posons D : E = E0 → . . . → En 3 t, et montrons la proposition en montrant, par

récurrence sur i, qu’il existe une dérivation :
D0 : E 0 = E00 → . . . → En0 3 ϕ(t)

telle que pour tout i ∈ {0, . . . , n}, la fonction ϕ est une bijection de p (Ei )q vers p (Ei0 )q qui
0
envoie Ei sur Ei .
C’est vrai par hypothèse pour i = 0 Supposons donc i > 0 et qu’il existe une bijection entre
0
(Ei−1 ) et (Ei−1 ) qui est une bijection entre Ei et Ei0 . Soit F → u la règle appliquée pour
passer de Ei−1 à Ei . La dérivation est bien formée et tous les termes sont normalisés, donc la
fonction ϕ est définie sur (Ei ), et en posant Ei0 = Ei−1
0
∪ {ϕ(u)}, elle est une bijection entre
0
Ei et Ei . Il suffit donc de montrer que ϕ(F ) → ϕ(u) est une règle du système Lf .
– si F → u est une f -règle, c’est vrai par hypothèse ;
– sinon, par définition de ϕ, l’image d’un g-terme est un g-terme et deux sous-termes égaux
ont la même image. En examinant les différents cas possibles, on conclut que si F → u est
une g-règles, alors ϕ(F ) → ϕ(u) est aussi une g-règle.

7.5.4 Généralisation d’une attaque

Étant donnée (π, σ), nous considérons une substitution σ ∗ dans laquelle les coefficients des
multi-ensembles (resp. multi-ensembles généralisés) sont les éléments d’un ensemble fini Xent de
variables pouvant être substituées par des valeur de (resp. ). Une valuation est une fonction de
Xent dans (ou ). L’application d’une valuation β à un terme t est notée β(t). Le résultat est le
terme t dans lequel toutes les variables x de Xent ont été remplacées par β(x). L’application d’une
valuation à un multi-ensemble (généralisé) M est notée β(M). Les multi-ensembles généralisés M
et β(M) sont reliés par :
X
∀t ∈ T(F), β(M)(β(t)) = β(M(u))
u,β(u)=β(t)
Nous recherchons un ensemble de valuations β telles que (π, β(σ ∗ )) soit une attaque et telles que
les images de β soient « petites ». Arbitrairement, nous limitons notre recherche à des valuations
β telles que, pour tous termes t, t0 ∈ SP, on a :
SPσ ≡coef β(SPσ ∗ )
Dans la sous-section suivante, nous décrivons l’ensemble des valuations β vérifiant cette pro-
priété comme un ensemble de solutions d’un système d’équations et d’inéquations affines. Dans la
sous-section 7.5.4.ii, nous donnerons des conditions supplémentaires permettant d’assurer que le
couple (π, β(σ ∗ )) est une attaque.
7.5.4.i Recherche de substitutions équivalentes

Soit E un système d’équations et d’inéquations. Nous notons D(E) l’ensembe des valuations β
qui sont solution de E. Nous cherchons un système E dépendant du protocole tel que, pour toute
valuation β ∈ D(E), il existe un isomorphime ϕ entre pSPσq et pβ(SPσ ∗ )q.
Soit βσ la valuation telle que βσ (σ ∗ ) = σ. Cette valuation permet de définir une fonction
surjective ψ0 :
ψ0 : (SPσ ∗ ) → p (SPσ)q
t 7→ pβσ (t)q
Pour tout t ∈ (SPσ ∗ ), pour toute valuation β, la définition des fonctions de normalisation
implique :
pβ(t)q = pβ(ptq)q
Donc il existe une fonction surjective ψ :
ψ:p (SPσ ∗ )q → p (SPσ)q

t 7 → pβσ (t)q
Pour t ∈ p (SPσ)q, soit Tt l’ensemble :
Tt = {u ∈ p (SPσ ∗ )q | pβσ (u)q = t}
Soient u, v ∈ p (SPσ ∗ )q, et Tt1 , Tt2 telles que u ∈ Tt1 et v ∈ Tt2 . Nous cherchons les
valuations β telles qu’il existe un isomorphisme ϕ de p (β(SPσ ∗ ))q vers p (SPσ)q avec
−1 −1
ϕ (t) = pβ(ψ (t))q. Pour assurer l’existence d’un tel isomorphisme ϕ, il suffit que :
Condition 1. si t1 = t2 , alors pβ(u)q = pβ(v)q ;
Condition 2. si t1 6= t2 , alors pβ(u)q 6= pβ(v)q ;
Condition 3. si pβ(u)q = g(u1 , . . . , un ), alors ϕ(pβ(u)q) = g(ϕ(u1 ), . . . , ϕ(un )).
Par définition de la fonction de normalisation, on a :

Base(pβ(u)q) = Base(pβ(v)q)
pβ(u)q = pβ(v)q ⇐⇒
Facteur(pβ(u)q) = Facteur(pβ(v)q)
Par définition de β, on a :

Base(pβ(u)q) = pβ(Base(u))q
Facteur(pβ(u)q) = pβ(Facteur(v))q
Posons : 

 Mu = Facteur(u)
Mσu = Facteur(βσ (u))




 Mv = Facteur(v)


Mσv = Facteur(βσ (v))
F = (Mu ) ∪ (Mv )



0

F = {pβ (s)q | s ∈ F }

σ



 σ
Fu = (Mσu )
Nous pouvons maintenant donner les équations et inéquations que doit vérifier β pour que les deux
premières conditions soient vraies.
Première condition. Pour tout t ∈ p (SPσ)q et pour tout u, v ∈ Tt et pour tout r ∈ F 0 :

X X
Mu (s) = Mv (s)
s∈Tr s∈Tr
Notons E1 l’ensemble des équations ci-dessus. Rappelons que si u (resp. v) n’est pas un f -terme, le
multi-ensemble (généralisé) Mu (resp. Mv ) est pris égal à la fonction partout nulle. Notons que
la base de pβσ (u)q est aussi dans p (SPσ)q, et donc que l’égalité des bases de deux termes de
Tt est vérifiée par induction pour toute valuation β vérifiant E1 .
Deuxième condition. Il suffit d’assurer que si pβ(u)q et pβ(v)q ont la même base, et si pβσ (u)q
et pβσ (v)q sont différents, alors on doit avoir :
pβ(Facteur(u))q 6= pβ(Facteur(v))q
Par la première condition, si pβ(Base(u))q = pβ(Base(v))q, alors pβσ (Base(u))q = pβσ (Base(v))q.
Il existe donc r tel que :
pβσ (Facteur(u))q(r) 6= pβσ (Facteur(v))q(r)
Pour assurer pβ(u)q 6= pβ(v)q, il suffit donc de poser :

X X
Mu (s) 6= Mv (s)
s∈Tr s∈Tr
Soit E2 l’ensemble de ces inéquations.

Troisième condition. Soit β une valuation vérifiant les deux premières conditions. L’ensemble
p (β(SPσ ∗ ))q est en bijection avec l’ensemble {Tt | t ∈ p (SPσ)q}, et donc avec p (SPσ)q.
Soit ϕ cette bijection. Pour que ϕ soit un isomorphisme, il faut et il suffit d’assurer que pour
g(t1 , . . . , tn ) ∈ p (SPσ)q, on a :
ϕ−1 (g(t1 , . . . , tn )) = g(ϕ−1 (t1 ), . . . , ϕ−1 (tn ))
Si g 6= f , cette égalité est vraie par la définition de ϕ en fonction de ψ et par définition de la

fonction de normalisation. Si g = f , pour tout u ∈ p (SPσ ∗ )q, il suffit d’assurer :
ϕ( (Facteur(β(u)))) = (Facteur(ϕ(βσ (u))))
Autrement dit, pour tout r ∈ F 0 , on pose :

σ
P
Ps∈Tr Mu (s) = 0 si Mσu (r) = 0
s∈Tr Mu (s) 6= 0 si Mu (r) 6= 0
Soit E3 l’ensemble de ces équations et inéquations, et posons finalement :
E = E1 ∪ E2 ∪ E3
Par construction du système E, pour toute valuation β solution de E, il existe un isomorphisme ϕ

de p (β(SPσ ∗ ))q vers p (SPσ)q. Notons :
0
Ei = pβ((S0 , . . . , Si )σ ∗ )q pour i ∈ {1, . . . , n}
Ri0 = pβ((Ri )σ ∗ )q pour i ∈ {1, . . . , n}
Par définition, pour tout i ∈ {1, . . . , n} et pour toute valuation β solution de E, on a :

0
Ei ≡coef Ei Ri0 ≡coef Ri
7.5.4.ii Termes équivalents et accessibilité

D’après la proposition 48, il reste à exprimer l’existence des règles ϕ(F ) → ϕ(t) pour toute
f -règle dans une des dérivations Di . Soit
t1 , . . . , tn → pf (t1 , M)q
une telle règle. On a :

(Facteur(pf (t1 , M)q) − Facteur(t1 )) = {t2 , . . . , tn }
Base(pf (t1 , M)q) = Base(t1 )
L’égalité entre ϕ−1 (Base(pf (t1 , M)q)) et ϕ−1 (Base(t1 )) est assurée par ϕ isomorphisme. Soient
u, u1 , . . . , un tels que pβσ (ui )q = ti et pβσ (u)q = t, M1 = Facteur(u1 ) et M = Facteur(u). Pour
assurer l’égalité sur le support de la différence, il suffit que la valuation β vérifie :
– si r ∈ {t2 , . . . , tn } : X X
Mu (s) 6= M(s)
s∈Tr s∈Tr
– sinon : X X
Mu (s) = M(s)
s∈Tr s∈Tr
Soit E4 l’ensemble de ces équations et inéquations pour toutes les règles des dérivations Di . Par
construction, si une valuation β est solution de E ∪ E4 , alors (π, β(σ ∗ )) est une attaque sur P. Le
nombre de sous-termes de σ, et donc de σ ∗ , est linéaire en le nombre de sous-termes de SP par
le théorème 11, donc le nombre de sous-termes de pSPσ ∗ q est linéaire en la taille du protocole P.
Le nombre d’équations et d’inéquations dans E ∪ E4 est donc polynomial en la taille de P. Quitte
à ne pas factoriser, chaque membre d’une équation ou d’une inéquation à un nombre de termes
au maximum linéaire en la taille de P, et chaque terme de cette somme est soit une variable, soit
une constante apparaissant dans P. On en conclut que la taille totale de E ∪ E4 est polynomiale
en la taille de P. La recherche de solutions de E ∪ E4 se ramène au problème
, donc il existe des solutions de taille polynomiale en la taille de E ∪ E4 , et donc
polynomiale en la taille de P. La taille de la représentation la substitution σ hors coefficients est
elle-même polynomiale en la taille de P, ce qui justifie la limite polynomiale sur la taille totale
de la représentation de la substitution σ dans l’agorithme de la figure 7.1. On a donc le théorème
suivant.
Théorème 13
Les problèmes de décision Attaque(P, Rexp ) et Attaque(P, Rrsa ) sont dans NPTIME.
Une preuve plus technique du théorème 13 est donnée dans le rapport technique [21].
Quatrième partie
Vérification
139
8
Analyse dans le cas d’un nombre

non-borné de sessions
8.1 Motivation
Nous avons vu, dans le chapitre 6, qu’il était possible de faire une recherche d’attaque efficace
sur un protocole dans le cas d’un nombre borné de sessions. Le principal défaut de cet algorithme
est la dépendance (exponentielle) en le nombre de participants. Une première motivation pour
étudier le cas d’un nombre non-borné de sessions d’acteurs, est de chercher à abstraire le nombre
de participants au protocole pour ne plus avoir cette dépendance exponentielle. Il s’agit donc d’un
problème d’efficacité de la recherche d’attaques. La seconde motivation vient du problème étudié :
Existe-t-il une attaque avec n exécutions du protocole ?
141
142 Chapitre 8. Cas non-borné
Si la réponse est affirmative, il est possible de considérer l’étude du protocole comme close.
Sinon, le problème de l’existence d’une attaque reste ouvert. Dans le cadre d’un nombre non borné
de sessions, il existe une classe de protocoles pour lesquels le problème de la recherche d’attaques
est indécidable dès que la taille des messages n’est pas bornée, ce qui est montré en réduisant un
problème de correspondance de Post quelconque au problème de la recherche d’attaques, voir [55]
par exemple, ou dès qu’un nombre non borné de nonces sont considérés [45]. L’alternative, pour
une étude de protocoles dans le cadre d’un nombre non borné de sessions, est donc soit de se limiter
à des sous-classes plus ou moins expressives, soit de poser une limite à la précision de l’étude.
Le cas des protocoles ping-pong, examiné par D. Dolev et A. Yao dans leur article fondateur [41],
forme une classe de protocoles décidables. Il s’agit cependant d’un résultat purement théoriqe,
les rôles de ces protocoles n’ayant aucune mémoire et les opérateurs de concaténation n’étant
pas autorisés. L’approche suivie par Stoller est dans la même ligne [100]. Il donne un ensemble
de restrictions statiques (un texte chiffré n’est pas un sous-message d’un message qui est à son
tour chiffré) et dynamiques. Ces dernières sont vérifiées au cours de l’exécution d’un algorithme
calculant, pour un protocole donné, un nombre n de sessions tel que, s’il y a une attaque sur le
protocole, alors il y en a une en n sessions ou moins. Les restrictions imposées aux protocoles sont
cependant trop fortes, et le résultat ne semble pas applicable à une large classe. L’approche suivi
par G. Lowe [64] est similaire, mais semble plus pertinente. L’auteur part de principes portant
sur l’écriture de protocoles, et montre que si un protocole P est écrit selon ces principes et vérifie
certaines hypothèses supplémentaires, alors il existe un nombre n, calculé par un algorithme donné
par l’auteur, tel que si ce protocole a une attaque, il en a une en moins de n sessions. Parmi les
hypothèses supplémentaires, il est imposé qu’un secret n’est jamais envoyé dans un message, même
chiffré. Cette restriction permet de prendre en compte un grand nombre de protocoles d’échange
de clefs, mais ne s’applique plus pour les protocoles permettant une transaction.
Une partie de notre travail dans le cadre du projet AVISS, et plus encore dans le cadre du
projet AVISPA, consiste en l’étude de protocoles déjà définis et le plus souvent complexes. De tels
protocoles ne rentrent que rarement dans le cadre des sous-classes décidables considérées dans le
paragraphe précédent. Ne considérant pas le fait de savoir qu’un protocole n’a pas de failles dans
un cadre limité comme une réponse satisfaisante, l’utilisation de méthodes automatiques implique
donc de limiter la précision de l’étude. Afin de se ramener à un cadre décidable, les deux résultats
d’indécidabilité énoncés plus haut impliquent que les acteurs participant à un nombre non borné
de sessions doivent :
– accepter des messages dont les composantes inconnues ne peuvent être remplacées que par
des constantes ou, dans le meilleur des cas, par des termes de taille bornée ;
– réutiliser les mêmes nonces d’une session sur l’autre.
Dans ce chapitre, nous verrons que ces deux conditions sont suffisantes. Dans une première
partie, nous verrons que la recherche d’attaques dans la cadre d’un nombre non borné de sessions
est dans EXPTIME. Ce résultat a été publié dans [22], et repose sur l’existence de règles d’Oracle.
La notion de règles d’Oracle pour étendre le pouvoir de déduction de l’intrus à initialement été
introduite dans [25] pour décrire une implantation de cet algorithme dans laquelle les règles d’Oracle
peuvent être calculées une fois pour toute au moment de la compilation du protocole, et non à
chaque application. Cette implantation est décrite dans la deuxième partie de ce chapitre, dans la
section 8.5.
8.2 Cadre de travail

8.2.1 Termes et capacités de l’intrus
Dans ce chapitre, nous considérons un intrus ayant un contrôle total sur les communications
(intrus défini par D. Dolev et A. Yao, voir [41] et le chapitre 2). Les protocoles sont donnés sous la
forme de règles optimisées (voir le chapitre 5 pour la construction de ces règles). Afin de simplifier
le cadre d’étude, nous faisons l’hypothèse de chiffrement parfait des messages. Cela signifie que,
parmi les constructeurs définis au chapitre 3, seuls sont considérés :
s p −1
h , i,{ } ,{ } ,
8.2. Cadre de travail 143
Pour ces constructeurs, les termes valeurs et les termes opérations coı̈ncident à un isomorphisme
de signature près. Pour un ensemble C de constantes et X de variables, nous notons :
s p
F = C ∪ h , i , { } , { } , −1

la signature, T(F) l’ensemble des termes clos, et T(F, X ) l’ensemble des termes sur la signature
F ∪ X . Nous notons :
Rproto = Lh , i ∪ L{ }s ∪ L{ }p
Rc,proto = Lc,h , i ∪ Lc,{ }s ∪ Lc,{ }p
l’ensemble des règles de déduction de l’intrus. Le lecteur se reportera au chapitre 4, section 4.5
pour une description précise de ces systèmes de réécriture sur des ensembles. D’après le théorème 2
du chapitre 4, le système Rproto est local.
On remarque que pour cette signature, la taille de la représentation d’un terme par un graphe
acyclique est proportionnelle au nombre de ses sous-termes. On définit donc la taille |t| (resp.
|E|) d’un terme t (resp. d’un ensemble de termes E) comme étant le cardinal de l’ensemble des
sous-termes de t (resp. de E) :
|t| = | (t)|
8.2.2 Protocoles considérés

Un acteur est une instance d’un rôle, et est spécifié par un couple ({Rι ⇒ Sι }ι∈I , <I ) où
{Rι ⇒ Sι }ι∈I est un ensemble de règles optimisées (voir le chapitre 5, section 5.3.4) indexé par un
ensemble I, et <I est un ordre total sur I. Sans perte de généralité (voir le chapitre 5, section 5.5),
nous supposons que pour toute variable x, et pour tout ι ∈ I :
x ∈ Var(Sι ) ⇒ ∃ι0 ≤ ι, x ∈ Var(Rι0 )
L’union d’un nombre fini d’acteurs est définie par l’union des ensembles de règles indexée par
l’union des ensembles d’indices, ordonnée par l’union des ordres sur chaque ensemble d’indices.
Dans ce chapitre, nous considérons des protocoles non-bornés qui sont définis à partir des acteurs.
Définition 53 (Protocole non-borné)

Un protocole non-borné Pnb est un quadruplet (Aqcq , AD , S0 , D) avec Aqcq et AD des unions finies
d’acteurs, S0 un ensemble de termes clos représentant les connaissances initiales de l’intrus et D
la représentation d’un nombre fini de messages tels que la taille d’un message représenté par D est
bornée linéairement en la taille de D.
Étant donné un protocole Pnb , nous notons C (resp. Var(Pnb )) l’ensemble des constantes (resp.
variables) apparaissant dans l’écriture de Pnb . La taille de Pnb , notée |Pnb |, est la taille de la
représentation de Aqcq , AD et S0 par des graphes acycliques (voir le chapitre 3, section 3.5) plus
la taille de la représentation de D. D peut être, par exemple, le codage d’un entier n en unaire
désignant l’ensemble des termes de T(F, C) dont la représentation est de taille inférieure ou égale à
n. On remarque que la borne sur les messages représentés par D et un nombre fini de constantes C
pour construire les termes implique que la taille totale de l’ensemble des messages représentés par
D est au plus exponentielle en la taille de la représentation de D, et donc au plus exponentielle en
la taille |Pnb | du protocole.
Dans la définition d’un protocole non-borné, contrairement à la définition habituelle d’un proto-
cole par des règles optimisées, nous différencions deux types d’acteurs. Le premier, Aqcq , correspond
aux acteurs d’un protocole tels que définis précédemment. Ces acteurs acceptent des messages quel-
conques, et ne peuvent participer qu’à un nombre fini de sessions. Le second type, AD , correspond
à des acteurs qui peuvent être impliqués dans un nombre non-borné de sessions. Sans restriction
supplémentaire, il est bien connu que le problème de la recherche d’attaques sur un protocole ayant
un nombre fini de constantes mais un nombre non-borné de sessions est indécidable [48, 55]. Cela
se prouve, par exemple, par une réduction du problème de correspondance de Post au problème
de recherche d’attaques. Pour cela, nous restreignons les termes que l’intrus peut substituer aux
variables des acteurs dans AD aux termes représentés par D. Ils sont en nombre fini, et cela permet,
comme nous allons le montrer, de ramener le problème de recherche d’attaque à une exploration
d’un ensemble fini d’états.
8.2.3 Modèle d’exécution

Soit Pnb = (Aqcq , AD , S0 , D) un problème non-borné. Pour définir une exécution de Pnb , nous
commençons par choisir un nombre d’exécutions des acteurs pour se ramener au cas d’un protocole
habituel :
– pour chaque acteur A(D),i dans AD , choisir le nombre ni d’exécutions de cet acteur ;
– soit P = ({Rι ⇒ Sι }ι∈I , <I ) le protocole composé de l’union des acteurs de Aqcq et des
acteurs de AD (après renommage des variables pour assurer le non partage des connaissances
entre différentes sessions d’un acteur).
Une exécution (π, σ) de P est définie de la manière suivante : soit I 0 un sous-ensemble de I tel
que a ∈ I 0 et b <I a implique b ∈ I 0 . L’ordre d’exécution π est une bijection croissante de I 0 vers
{1, . . . , |I 0 |}. En notant Ri ⇒ Si la règle Rπ−1 (i) ⇒ Sπ−1 (i) et k = |I 0 |, les ensembles de termes
représentant les connaissances de l’intrus (Ei )i∈{0,...,k} sont définis par :

S0 si i = 0
Ei =
Ei−1 , Si sinon
Un ordre d’exécution π est σ-satisfaisable pour L si, pour un système de réécriture sur les ensembles
L et pour tout i ∈ {1, . . . , k}, on a :
L
Ri σ ∈ Ei−1 σ
Si π est σ-satisfaisable pour L, nous disons que l’exécution (π, σ) est valide pour L.
Avec ces notations, une exécution valide de Pnb pour L est un triplet (M, π, σ), avec M un
multi-ensemble de support contenu dans AD , et (π, σ) est une exécution exécution valide pour L
du protocole P défini par M et Pnb telle que, pour toute variable x d’un acteur de AD dans P, on
a xσ ∈ D.
8.2.4 Le problème de décision Attaque Parallele(Pnb, t, L)

Nous nous restreignons, pour l’étude théorique, au cas de la recherche d’attaques de secret.
Pour un protocole Pnb et un terme t, ce type d’attaques peut se définir de la manière suivante.
Définition 54 (Attaque sur un protocole non-borné)
Soit Pnb = (Aqcq , AD , S0 , D) un protocole non-borné, t un terme et L un système de réécriture sur
les ensembles. Une attaque sur Pnb pour le secret t et pour L est une exécution valide (M, π, σ)
de k étapes (Ri ⇒ Si )i∈{1,...,k} avec :
L
k
[
tσ ∈ Si σ
i=0
Le problème de décision que nous considérons dans la partie théorique de ce chapitre est le
suivant :
Attaque Parallele(Pnb , t, Rproto ) : Existe-t-il une attaque de secret
pour t dans Pnb ?
La taille du problème d’entrée est la taille de la représentation de Pnb et t. La taille de Rproto
n’est pas comptée, mais les règles de L seront bornées par définition en fonction de la taille de la
représentation de Pnb . On note qu’il y a un nombre infini de multi-ensembles M possibles, donc
l’ensemble des états à explorer est a priori infini. Nous allons cependant montrer que le problème
Attaque Parallele (Pnb , t, Rproto ) est décidable en temps exponentiel en ajoutant un nombre
fini de règles à Rproto . Ces règles supplémentaires permettent de simuler toutes les possibilités
d’interaction entre l’intrus et les acteurs de AD .
8.3 Ajout de règles d’Oracle à Rproto

8.3.1 Résultat principal
Le résultat théorique principal de ce chapitre, que nous prouvons dans cette section et dans la
section 8.4, est le théorème suivant.
8.3. Ajout de règles d’Oracle à Rproto 145
Théorème 14 (Complexité du problème Attaque Parallele (Pnb , t, Rproto ))

Pour un protocole non-borné Pnb = (Aqcq , AD , S0 , D) et un terme t, le problème :
Attaque Parallele(Pnb , t, Rproto )

est EXPTIME-complet.
Pour résoudre le problème Attaque Parallele (Pnb , t, Rproto ), nous utilisons l’algorithme de
la figure 8.1. Nous déduisons d’un protocole non-borné Pnb donné en entrée de l’algorithme un
0
protocole borné Pnb et un ensemble L0 de règles de déductions supplémentaires pour l’intrus. Nous
posons ensuite Ro,proto = Rproto ∪ Lo . Si pour tout ensemble de termes E et pour tout terme t le
problème Accessibilite Close (E, t, Ro,proto ) est dans EXPTIME, alors cet algorithme est dans
EXPTIME. Il reste à en montrer la correction.
Soit Pnb = (Aqcq , AD , S0 , D), n = |Pnb | et X = Var(Aqcq ).
Soit Lo = Regles Oracle(Pnb ).
0
Soit Pnb = (Aqcq , ∅, S0 , D).
Soit Π l’ensemble des ordres d’exécution possibles, et Σ l’ensemble
des substitutions closes σ de support X et telles que :
∀x ∈ (σ), |xσ| ≤ n3 + n
Pour tout (π, σ) ∈ Π × Σ,
1. tester que (π, σ) est une exécution valide pour Ro,proto du pro-
tocole (Aqcq , ∅, S0 , t) ;
2. si l’ordre d’exécution a k étapes, et en notant Ri = Rπ−1 (i)
(resp. Si = Sπ−1 (i) ), tester si :
Ro,proto
tσ ∈ (S0 , . . . , Sk )σ
La preuve se déroule de la manière suivante. Tout d’abord, nous montrons que le problème :

est équivalent au problème :
Attaque Parallele(Pnb0 , t, Rproto ∪ Lo )

Ensuite, nous montrons que pour un système Lo de règles de réécriture sur les ensembles, défini et
0
borné en fonction de Pnb , le problème de la recherche d’attaque sur le protocole Pnb = (Aqcq , ∅, S0 , D)
est dans EXPTIME si, pour deux ensembles de termes E et F , le problème :
Transition(E, F, Lo )
est dans EXPTIME. Nous appelons les règles de Lo des règles d’Oracle, en référence au fait qu’elles
« indiquent » si, à partir d’un ensemble de connaissances E, l’intrus peut obtenir un terme u en
utilisant ses capacités et en interagissant uniquement avec les acteurs de AD .
8.3.2 Définition de Lo
Dans le chapitre 4, nous avons défini des systèmes canoniques dont la combinaison permet
d’obtenir un système local, c’est-à-dire un système L tel que pour tout terme t et pour tout
L
ensemble E, si t ∈ E , alors il existe une dérivation bien formée de but t partant de E. Les
systèmes canoniques ont deux propriétés qui permettent cette combinaison :
a) ils sont transitifs. Si deux règles d’un système canonique sont appliquées à la suite, soit on
a, localement, une dérivation bien formée, soit les deux transitions peuvent se réduire en une
seule ;
b) ils sont homogènes. Chaque système traite un constructeur spécifiquement, et la différence

entre opérateurs permet de combiner les dérivations bien formées locales pour construire une
dérivation bien formée partant d’un ensemble E et de but t.
Dans le système de règles d’Oracle Lo que nous allons ajouter à Rproto , les termes dans les
règles de réécriture sont quelconques. Il n’est donc pas possible d’utiliser un lemme semblable aux
lemmes 5 et 6 du chapitre 4 pour combiner Lo et Rproto pour obtenir un système local. Nous allons
donc directement imposer dans la définition des règles d’Oracle que leur ajout à Rproto permet
d’obtenir un système Ro,proto dans lequel, pour tout ensemble de termes E et pour tout terme
Ro,proto
t∈E , il existe une dérivation bien formée partant de E de but t. Nous imposons aussi une
contrainte en fonction de la taille du protocole non-borné Pnb . Cette limitation permet de prendre
en compte la taille de la représentation de AD . La définition des règles d’Oracle que nous proposons
est donc la suivante.
Définition 55 (Ensemble Lo des règles d’Oracle pour un protocole non-borné Pnb )

Soit Pnb un protocole non-borné, Lo un ensemble de règles de réécriture sur des ensembles. Le
système Lo est un système de règles d’Oracle pour Pnb si :
Rproto ∪Lo
1. pour tout terme t et tout ensemble de termes E, si t ∈ E , alors il existe une
dérivation bien formée partant de E de but t ;
2
2. pour toute règle F → t dans Lo et pour tout t0 ∈ E ∪ {t}, on a | (t0 )| ≤ | (Pnb )| .
Le lemme 4 du chapitre 4 peut être immédiatement adapté au cadre de systèmes de réécriture

sur des ensembles avec règles d’Oracle.
Lemme 31
Pour toute transition E →Rproto F , si (E) 6= (F ), alors soit la transition est faite par une
règle d’Oracle, soit il existe s tel que :
– F = E ∪ {s} et (F ) = (E) ∪ {s} ;
– la transition est une règle de composition.
8.3.3 Problème d’accessibilité close

La proposition 11 du chapitre 4 permet tout de suite d’affirmer que pour deux ensembles de
termes E et F , si le problème Transition
(E, F, Lo ) est dans EXPTIME, alors le problème :
Transition(E, F, Ro,proto )
est lui aussi dans EXPTIME. D’autre part, la correction de l’algorithme donné dans la preuve
du théorème 3 du chapitre 4 utilise uniquement que dans le système de transitions considéré,
l’existence d’une dérivation partant de E et de but t implique l’existence d’une dérivation bien
formée partant de E et de but t. Donc en reprenant verbatim cette preuve, le point 1 implique la
proposition suivante.
Proposition 49
Pour tout ensemble de termes E et pour tout terme t, si le problème
est dans EXPTIME, alors le problème :
Accessibilite Close(E, t, Ro,proto )

est dans EXPTIME.
8.3. Ajout de règles d’Oracle à Rproto 147
8.3.4 Borne sur les attaques

Nous montrons dans cette sous-section qu’il suffit, pour répondre au problème :

de considérer les substitutions dont la taille est inférieure ou égale à la borne de |Pnb |3 + 1 donnée
dans l’algorithme. Pour cela, nous définissons une notion d’attaques normales. La taille d’une
substitution σ, notée |σ|, est définie par :
Σx∈X |xσ|
Si l’ensemble des attaques sur un protocole non-borné Pnb est non vide, alors il existe au moins une
attaque (π, σ) telle que |σ| soit minimal. Une attaque normale est une attaque dont la substitution
est minimale. Par définition, il existe une attaque sur le protocole si, et seulement si, il existe une
attaque normale. Pour justifier la restriction sur le choix des substitutions, il suffit donc de montrer
qu’une attaque normale (π, σ) est dans Π × Σ.
Utilisons les notations de la figure 8.1 pour Pnb , n, (π, σ), Ri , Si , X et k. Soit :
SP = ({S0 } ∪ ∪ki=1 {Ri , Si })
et C l’ensemble des constantes dans SP.

Dans le lemme suivant, nous notons I le nom de l’intrus. Nous supposons que I ∈ S0 et nous
montrons qu’un terme libre s qui est de taille supérieure à n2 peut être remplacé par I.
Lemme 32
Ro,proto Ro,proto
Soient E et F deux ensembles de messages avec I ∈ E, et soit t ∈ E ∪ F . Soit s ∈ E \
2 R o,proto
(E) tel que |s| > n , et δ le remplacement [s ← I]. Alors tδ ∈ Eδ ∪ F δ .
Preuve. Pour commencer, si s ∈ / (F, t), le résultat est trivial : δ est égal à l’identité sur
(E, F, t). Supposons maintenant s ∈ (F, t). La définition des règles d’Oracle assure l’exis-
tence de dérivations bien formées.
Ro,proto
Par hypothèse, on a s ∈ E et |s| > n2 . Donc par le lemme 31, la dernière étape d’une
dérivation bien formée partant de E de but s est une règle de composition. Donc s = f (s1 , s2 ) et
Rproto
s1 , s2 ∈ E . Par la proposition 9 du chapitre 4, on a :
E, F →∗D1 F, E1 →∗D2 F, E2 →∗D3 G
avec D1 bien formée de but s1 , D2 bien formée de but s2 et D3 bien formée de but t. Par l’hypothèse
s∈ (F, t), la concaténation de ces dérivations est une dérivation bien formée. Notons-la D :
D : G0 = E, F → G0 , t1 = G1 → . . . → G0 , t1 , . . . , tm = Gm
et considérons la suite d’ensembles (Gi δ)i∈{0,...,m} et montrons qu’il existe une dérivation :
Dδ : G0 δ → . . . → Gm δ
Tout d’abord, quitte à raccourcir la suite d’ensembles, on suppose Gi δ 6= Gi+1 δ. On note :

a) pour une règle de composition l → r, la règle lδ → rδ est encore une règle de décomposition
si r 6= s ;
b) pour une règle de décomposition l → r, la règle lδ → rδ est encore une règle de décompo-
sition si s n’est pas le terme décomposé ;
c) pour une règle d’Oracle l → r, la condition sur la taille de s implique lδ = l et rδ = r.
Par définition d’une dérivation, le cas b) ne peut pas se produire dans D. Le cas a) ne peut
pas se produire dans Dδ car I ∈ G0 et donc I ∈ G0 δ. Donc, par récurrence, Dδ est une dérivation.
Rproto
Quitte à la tronquer, on peut supposer qu’elle est de but tδ. Donc on a bien tδ ∈ Eδ ∪ F δ .
Le lemme suivant permet de borner la taille de la substitution σ pour une attaque normale.
Lemme 33
Si (π, σ) est une attaque normale, alors pour toute variable x ∈ X , on a |xσ| > n2 implique que
xσ est lié.
Preuve. Par contradiction, supposons |xσ| > n2 et que pour tout terme t, t vσ xσ implique
t∈
/ SP. Notons :
i
[
∀i ∈ {0, . . . , k} , Ei = Sj σ
j=0
Les constantes sont toutes dans SP, donc xσ n’en est pas une. Considérons l’ensemble :
Θ = {i | xσ ∈ (Si σ)}
On a (S0 ) ⊆ (SP), donc 0 ∈ / Θ. Soit N0 minimal dans Θ, et t minimal pour la relation de

sous-terme dans (SN0 ) tel que xσ ∈ (tσ). Si t n’est pas une variable, par minimalité, on a
tσ = xσ, ce qui contredit l’hypothèse xσ libre. Donc il existe une variable y telle que xσ ∈ (yσ).
L’ensemble :
Θ0 = {i | y ∈ Var(Ri )}
n’est pas vide d’après l’hypothèse sur les variables dans les règles du protocole. Soit Nx minimal
dans Θ0 . Toujours par cette hypothèse, Nx ≤ N0 , donc xσ ∈ / (ENx −1 ). Par le lemme 31 et
Ro,proto
l’hypothèse sur la taille de xσ, on a xσ ∈ ENx −1 . Donc pour tout i ≥ Nx , on peut appliquer
le lemme 32, et montrer :
Ro,proto
(Ri σ)[xσ ← I] ∈ Ei−1 [xσ ← I]
D’autre part, par minimalité de Nx , l’inégalité i < Nx implique xσ ∈
/ (Ri σ, Ei−1 ), et donc :
Ro,proto
(Ri σ)[xσ ← I] ∈ Ei−1 [xσ ← I]
L’hypothèse t vσ xσ implique enfin qu’il existe une substitution σ 0 = σ[xσ ← I] telle que :
∀i ∈ {1, k} , (Ri σ)[xσ ← I] = Ri σ 0 et (Si σ)[xσ ← I] = Si σ 0
On a donc construit une substitution σ 0 telle que (π, σ 0 ) soit une attaque et |σ 0 | ≤ |σ|, ce qui
contredit (π, σ) attaque normale.
On peut maintenant montrer que la restriction sur le choix des substitutions, dans l’algorithme
de la figure 8.1, n’écarte pas les attaques normales.
Théorème 15 (Borne sur les substitutions dans les attaques normales)

Soit Pnb un protocole et (π, σ) une attaque normale sur Pnb . Alors, pour tout x ∈ Var(Pnb ), on a :
|xσ| ≤ n3 + n
Preuve. Soit :
Θ = x ∈ X | |xσ| ≤ n2

et soit X 0 = X \ Θ. Si X 0 = ∅, le théorème est prouvé. Sinon, par le lemme 33, si x ∈ X 0 , alors il

existe tx ∈ SP tel que tx vσ xσ. Considérons le problème d’unification syntaxique :
{x = tx }x∈X 0
Il a une solution σ, donc il a une solution plus générale unique σ 0 . Par construction de cette solution,
on a :
∀x ∈ X 0 , |xσ 0 | ≤ | ∪x∈X 0 tx |
≤ |SP|
et, par définition d’une substitution :
∀x ∈ X 0 , Var(xσ 0 ) ∩ X 0 = ∅
8.4. Règles parallèles 149
On en conclut alors facilement :
∀x ∈ X 0 , |xσ| ≤ |SP| + |Θ| · n2

≤ n3 + n
Ce qu’il fallait démontrer.

On remarque incidemment que la borne donnée permet de borner, avec exactement la même
construction, | {xσ | x ∈ X } |.
8.4 Règles parallèles

8.4.1 Situation de la preuve
Soit Pnb = (Aqcq , AD , S0 , D) un protocole non-borné. Nous venons de prouver que pour un
ensemble de règles d’Oracles Lo , si le protocole P défini par les acteurs de Aqcq et un intrus ayant
les connaissances initiales S0 a une attaque (π, σ) dans Ro,proto , alors la substitution σ était bornée
en fonction de la taille de Pnb .
Il reste donc à montrer que le protocole Pnb a une attaque dans Rproto si et seulement si le
protocole P a une attaque dans Ro,proto . Pour cela, nous allons construire explicitement l’ensemble
des règles de Lo indirectement en montrant que le problème :
est décidable en temps exponentiel. Nous prouverons ensuite que les règles construites vérifient le
définition des règles d’Oracle.
8.4.2 Règles agrégées

On considère un protocole non-bornée Pnb = (Aqcq , AD , S0 , D) Soit SD l’ensemble des termes
décrits par D. Par hypothèse sur D, l’ensemble SD est de cardinal fini. Donc l’ensemble des instances
possibles des acteurs de AD par des termes de SD est fini. Soit ADD cet ensemble. Un acteur instancié
A de AD D est décrit par une suite finie de règles closes :
R1 ⇒ S1 , . . . , R m ⇒ Sm
L’ensemble des règles agrégées de cet acteur est l’ensemble de règles de déduction de l’intrus :
m
[
{R1 , . . . , Ri → Si }
i=1
On appelle AaggD l’ensemble des règles agrégées et instanciées des acteurs de AD . Notons tout
de suite que les règles de Aagg
D permettent de se passer des acteurs de AD . Notons Ragg,proto =
Rproto ∪ Aagg
D .
Lemme 34
Le problème de décision :
Attaque Parallele((Aqcq , AD , S0 , D), t, Rproto )

est équivalent au problème de décision
Attaque Parallele((Aqcq , ∅, S0 , ∅), t, Ragg,proto )

Preuve. Montrons d’abord :

implique :
Supposons qu’il y ait une attaque (M, π, σ) sur (Aqcq , AD , S0 , D). Par définition, il existe un
ordre d’exécution π respectant l’ordre sur les règles des acteurs, une substitution σ respectant la
restriction sur les instances des variables des acteurs de Aqcq et des des règles d’acteurs Ri ⇒ Si
telles que :
Rproto
R 1 σ ∈ S0
...
Rproto
Rk σ ∈ (S0 , . . . , Sk−1 )σ
Rproto
tσ ∈ (S0 , . . . , Sk )σ
Soit A un acteur de AD et α une permutation telle que
Rα(1) σ ⇒ Sα(1) σ, . . . , Rα(l) σ ⇒ Sα(l) σ
soient les règles d’une des sessions de A. Par croissance des ensembles de connaissances, on a, pour
tout i ∈ {1, . . . , l}
Rproto
∀j ∈ {1, . . . , i} , Rα(j) σ ∈ (S0 , . . . , Si−1 )σ
D’autre part, pour tout i ∈ {1, . . . , l}, pour tout x ∈ Var(Ri ), on a xσ ∈ D. Donc on peut remplacer
les règles de cette session de cet acteur par des règles agrégées de l’intrus. En répétant l’opération
pour tous les acteurs et AD et pour toutes leurs exécutions, on obtient une solution au problème :

La réciproque se montre de la même manière, en remplaçant chaque règle agrégée par une exécution
partielle d’un acteur de AD .
Les règles agrégées ne sont qu’une solution partielle du problème. Elles vérifient le point 2 de
la définition de règles d’Oracle. Cependant, elles ne vérifient pas, en général, le point 1.
8.4.3 Règles d’Oracle pour les acteurs

Tout d’abord, notons Hr l’ensemble des sous-termes des membres droits des règles agrégées, et
H l’ensemble des sous-termes de ces règles. Ces deux ensembles sont finis et, d’après la restriction
sur la taille des termes représentés par D, de taille exponentielle en la taille n du protocole Pnb .
Notons aussi que chaque terme de ces ensembles est un sous-terme du protocole non-borné Pnb
dont les variables sont instanciées par des termes de D. Sa taille peut donc être bornée par :
|Pnb | + |X | × |D|
On a |Pnb | ≥ |X | + |D|, donc cette inégalité implique :
∀t ∈ H, |t| ≤ n2
Il est maintenant possible de définir les règles d’Oracle pour les acteurs.
Définition 56 (Règles d’Oracle pour les acteurs)

Une règle de réécriture E → t est une règle d’Oracle pour les acteurs de Pnb si :
2
 ∀u ∈ E, |u| ≤ n

t ∈ Hr
Ragg,proto
t∈E

On note AoD l’ensemble des règles d’Oracle pour les acteurs de Pnb .
Nous montrons en sous-section 8.4.4 que ces règles sont des règles d’Oracle au sens de la
définition 55. Mais d’abord, commençons par montrer que le problème de transition est exponentiel.
8.4. Règles parallèles 151
Proposition 50
Pour tout ensemble de termes E et pour tout terme t, le problème :
Transition(E, E ∪ {t} , AoD )

peut être décidé en temps exponentiel en la taille de E, t et Pnb .
Preuve. Par définition, ce problème est équivalent au problème :
Accessibilite Close(E, t, Ragg,proto )

Ragg,proto
Supposons t ∈ E , et soit D une dérivation partant de E de but t de longueur minimale.
Affirmation. Pour toute règle F → u appliquée dans D, on a u ∈ (E, t) ∪ H.
Preuve. Par contradiction, supposons que l’ensemble des règles
Θ = {Fi → ui | ui ∈
/ (E, t) ∪ H}
soit non vide. Par définition de H, il ne contient pas de règles de AaggD .

Supposons Θ ∩ Rc,proto 6= ∅. Soit F → u la dernière règle de Θ ∩ Rc,proto appliquée. Par
définition, u 6= t. Par minimalité de D, u doit être dans le membre gauche d’une autre règle
F 0 , u → r. Ce n’est pas une règle de Rc,proto par maximalité dans Θ ∩ Rc,proto et par définition
des règles de Rc,proto . Ce n’est pas une règle de AoD par définition. Ce n’est pas une règle de
décomposition par définition des dérivations et de Rd,proto . Donc Θ ∩ Rc,proto = ∅. Donc
nécessairement, Θ ∩ Rd,proto 6= ∅.
Soit alors F → u une règle de Θ ∩ Rd,proto , et soit v le terme décomposé par cette règle.
u∈ / (E, t) ∪ H implique v ∈ / (E, t) ∪ H. Notons :
D : E → E1 → . . . → E l
et soit i minimal tel que v ∈ (Fi ). On a i > 0 par hypothèse. Par le lemme 31, la transition
Fi−1 → Fi est soit dans Rc,proto , soit dans Aagg
D . Le premier cas est impossible par définition
d’une dérivation, le second par hypothèse sur u.
On aboutit à une contradiction, donc Θ = ∅.
L’ensemble (E, t) ∪ H est de taille exponentielle en la taille du protocole. Le calcul de

Ragg,proto
(E, t) ∪ H ∩ E peut donc se faire en temps exponentiel en la taille de (E, t) ∪ H.
Comme corollaire trivial, le problème de décision :
Transition(E, F, AoD )
peut être décidé en temps exponentiel. Par construction et par le lemme 34, on a aussi la proposition
suivante :
Proposition 51
Le problème de décision :

est équivalent au problème de décision
Attaque Parallele((Aqcq , ∅, S0 , ∅), t, Rproto ∪ AoD )

Pour conclure, il reste à montrer que les règles de AoD sont des règles d’Oracle.
8.4.4 Les règles de AoD sont des règles d’Oracle

Le point 2 de la définition 55 est trivialement satisfait. Il reste donc à montrer que pour tout
Ro,proto
ensemble E et tout terme t, on a t ∈ E implique qu’il existe une dérivation bien formée
partant de E de but t.
Proposition 52 (Les règles d’Oracle des acteurs sont des règles d’Oracle)
Ro,proto
Pour tout ensemble E et tout terme t, on a t ∈ E implique qu’il existe une dérivation bien
formée partant de E de but t.
Preuve. Tout d’abord, commençons par clarifier les liens entre les différents types de règles.
Affirmation 1. Si E →AoD E, t →Rd,proto E, t, u, alors soit E →Rd,proto u, soit E →AoD u, soit
t ∈≡ −1 (E).
Preuve. Si t n’est pas dans le membre gauche de la règle de décomposition, on est dans le
premier cas, si t est le terme décomposé, on a |u| ≤ |t|, donc on est dans le deuxième cas.
Enfin, si t est la condition de la règle, on est dans le troisième cas.
Affirmation 2. Si E →Rc,proto E, t →AoD E, t, u, alors E →AoD E, u.
Preuve. Par définition des règles d’Oracle d’acteurs. La condition sur la taille du membre
gauche est vérifiée par E, t implique qu’elle est vérifiée par E.
Affirmation 3. Si E →AoD E, t →AoD E, t, u, alors E →AoD E, u.
Preuve. Trivial, par définition des règles d’Oracle des acteurs.
Ro,proto
Soit t ∈ E et soit D une dérivation minimale partant de E et de but t, soit :
D : E = E0 → E1 → . . . → En
avec t ∈ En . Quitte à changer D, par l’affirmation 1., supposons qu’aucun terme résultat d’une
règle d’Oracle ne soit décomposé. Définissons :

Θ = Fi → u i ∈ D | u ∈ / (E, t) et Ei−1 →{Fi →ui } Ei
et soit : 
 Θd = Θ ∩ Rd,proto
Θc = Θ ∩ Rc,proto
Θo = Θ ∩ AoD

Nous allons montrer par contradiction que les trois ensembles Θd , Θc et Θo sont vides en utilisant
la minimalité de D.
Θd : par contradiction, soit Fi → ui ∈ Θd d’indice minimal, et soit v le terme décomposé. Par
définition d’une dérivation, v n’est pas le résultat d’une règle de composition. Par minimalité
dans Θd , ce n’est pas une règle de décomposition. Par minimalité par le choix de D, ce n’est
pas une règle d’Oracle. Donc v ∈ E, ce qui contredit ui ∈ / (E) ;
Θc : par contradiction, soit Fi → ui ∈ Θc d’indice maximal. Par hypothèse, ui 6= t. Par
minimalité de D, ui est dans le membre gauche d’une autre règle F 0 → v. Ce n’est pas
une règle de composition par maximalité dans Θd , et ce n’est pas une règle d’Oracle par
l’Affirmation 2. Si c’est une règle de décomposition, ui n’est pas le terme décomposé par
définition d’une dérivation. Soit v le terme décomposé par cette règle. Ce terme n’est pas
créé par une règle de AoD par l’affirmation 1. et le choix de D, il n’est pas créé par une règle
de Rc,proto par définition d’une dérivation. Donc il est créé par une règle de Rd,proto , mais
alors Θd = ∅ implique qu’il est sous-terme de E, t. Donc u ∈≡ −1 (E, t). Il n’y a pas de
règles de composition F 00 → w−1 , donc u ∈ (E, t) ;
Θo : par contradiction, soit Fi → ui ∈ Θo d’indice maximal. Par hypothèse, ui 6= t. Par
minimalité de D, ui est dans le membre gauche d’une autre règle F 0 → v. L’affirmation 1.
et ui ∈ / (E), on peut supposer que ce n’est pas une règle de décomposition. Par Θc = ∅
et par définition des règles de composition, ce n’est pas une règle de composition. Donc c’est
alors une règle de AoD , mais alors l’Affirmation 3. contredit la minimalité de D. Donc Θo = ∅.
On en conclut que Θ = ∅, et donc qu’une dérivation partant de E et de but t de longueur minimale
est bien formée.
8.5. Implantation 153
8.5 Implantation dans le cadre de la stratégie paresseuse de

recherche d’attaques
8.5.1 Une procédure inefficace
Les règles d’Oracle, telles qu’elle sont décrites dans la section précédente, sont incompatibles
avec la stratégie de recherche d’attaques par résolution de contraintes. Or, cette stratégie est à
l’origine de spectaculaires progrès tant pour la vitesse d’analyse des protocoles que pour le spectre
des protocoles analysables automatiquement. Nous cherchons donc à adapter les règles d’Oracle à
cette stratégie, et non l’inverse. La principale contrainte est que la stratégie paresseuse de recherche
d’attaques repose sur une représentation symbolique des ensembles de connaissances de l’intrus,
alors que les règles d’Oracle sont définies dans la section 8.4 par un calcul de point fixe à partir de
toutes les connaissances de l’intrus. Une contrainte secondaire est pouvoir pré-calculer ces règles
pour permettre une analyse plus rapide.
Pour répondre à ces deux contraintes, nous avons présenté dans [25] une implantation possible de
ces règles. Cette implantation, antérieure à la formalisation présentée dans les sections précédentes,
permet une analyse efficace des protocoles cryptographiques (voir la section 8.6). Dans la suite de
cette section, nous présentons :
a) les déclarations, dans le langage de haut niveau de description de protocoles, associées aux
acteurs de AD en sous-section 8.5.2 ;
b) la compilation de ces acteurs par CasRul en sous-section 8.5.3.
Nous ne montrons qu’informellement la correction, la complétude et la terminaison de l’implanta-
tion des règles d’Oracle pour la recherche d’attaques sur un protocole :
(Aqcq , AD , S0 , D)
La raison en est que cette preuve recoupe amplement les preuves de correction, complétude et
terminaison de la recherche d’attaques par résolution de contraintes pour le système d’inférence
utilisé, et la preuve de la première partie de ce chapitre pour ce qui concerne le passage des règles
de rôles à celles d’Oracle.
8.5.2 Déclaration des acteurs de AD

Dans le cadre de l’implantation des règles d’Oracle dans le compilateur CasRul, nous choi-
sissons D pour que seules des constantes puissent être substituées à des variables. La déclaration
des acteurs pouvant participer à un nombre non-borné de sessions se fait donc uniquement avec la
déclaration des instances des rôles. Par exemple, pour reprendre le cas du protocole de R. Needham
et M. Schroeder :
:
B [A : a, B : b, Ka : ka, Kb : kb, Nb : nb1 ],
B [A : a, B : b, Ka : ka, Kb : kb, Nb : nb2 ],
A [A : a, B : I , Ka : ka, Kb : ki ] ;
Par défaut, les nonces créés par un acteur jouant un nombre non-borné de sessions sont identiques
d’une exécution à l’autre du protocole. Dans les déclarations de ces acteurs, il est possible de
nommer les nonces qu’ils créent. Cela présente deux avantages :
a) il est possible de spécifier deux instances d’un acteur utilisant des nonces différents ;
b) il est possible de nommer des nonces pour une utilisation ultérieure.
Le premier avantage est limité pour la recherche d’attaques. Il est évident, via une abstraction,
que s’il y a une attaque dans une instance où un même acteur utilise deux nonces différents, il en
existe une dans une instance similaire où cet acteur utilise deux fois le même nonce. L’instance
d’un nonce peut être précisée dans le but de spécifier qu’elle est connue de l’intrus ou, au contraire,
qu’elle devrait rester secrète.
Pour spécifier qu’un nonce est connu de l’intrus, il suffit de le mettre dans ses connaissances
initiales. Pour spécifier qu’il doit rester secret, une déclaration spécifique est utilisée :
: nb1 ;
Cette déclaration diffère de celle de but de l’intrus, car il est utilisé, durant la construction des
règles d’Oracle, que l’intrus ne connaı̂tra jamais ces termes. En contrepartie, la spécification du
protocole est fautive si l’intrus venait à connaı̂tre un de ces termes.
8.5.3 Compilation des acteurs de AD : construction des règles d’Oracle

La construction des règles d’Oracle se fait en cinq étapes. Nous détaillerons les étapes 4. et 5.
dans les sous-sections 8.5.4 et 8.5.3.iv.
8.5.3.i Construction des règles agrégées.
À partir de ces règles, noud construisons les règles agrégées. Les messages attendus jusqu’à
l’étape i sont concaténés pour former le message attendu de la i-règle agrégée. Ce message est
ensuite analysé en fonction des connaissances du rôle à l’étape i de manière similaire à celle décrite
dans le chapitre 5. De même, le message envoyé en réponse est analysé. À la différence de la
construction présentée dans le chapitre 5, les termes qui ne peuvent pas être complètement analysés
ne sont pas remplacés par des variables. Toutes les positions de ces termes correspondant à des
variables du protocole sont remplacées de manière unique par une nouvelle variable. Par exemple,
s s
un rôle devant recevoir les messages {hN a, N ai}K et {N a}K et ne connaissant pas K filtrera les
s s
messages attendus avec les termes {hxN a,1 , xN a,2 i}xK,1 et {xN a,3 }xK,2 . Cette construction permet
d’obtenir des règles agrégées l → r telles que :
Var(r) ⊆ Var(l)
8.5.3.ii Construction de règles étendues.
À partir des règles agrégées, construction de règles étendues de la forme :
G:l→r
La signification informelle des différents champs est la suivante :

– G contient les termes witness et request correspondant à chaque règle. Seuls les termes witness
seront finalement utilisés dans les règles d’Oracle, mais les termes request servent à connaı̂tre
si un message a déjà été reçu ou non par un acteur ;
– l → r est initialement une règle agrégée d’acteur.
Notons C les connaissances initiales de l’intrus.
8.5.3.iii Phase de décomposition.
Toutes les décompositions possibles de l et de r sont pré-calculées. Ce pré-calcul est possible car
une variable ne pourra être ensuite instanciée que par une constante. Le nombre de décompositions
possibles est donc borné par le nombre de sous-termes (avec multiplicité). Ce calcul sert à assurer
que les règles l → r générées n’auront à être décomposées ni à droite, ni à gauche.
8.5.3.iv Calcul des règles d’Oracle.
Les règles d’Oracle sont ensuite calculées à partir des règles décomposées. Ce calcul sert à
assurer qu’il sera inutile pour l’intrus, lors de la phase de recherche d’attaque, d’utiliser le résultat
d’une règle décomposée pour simplifier le membre gauche d’une autre règle. Un ordre sur les règles
permet de ne garder que les plus avantageuses pour l’intrus. Par exemple, pour deux règles G : l → r
et G0 : l0 → r0 , si r = r0 et G = G0 , alors si l ⊂ l0 , il est inutile de garder la règle G0 : l0 → r0 .
8.5.4 Phase de décomposition

8.5.4.i Explication de cette phase.
Dans le modèle théorique, lorsqu’une règle d’Oracle est appliquée, les connaissances de l’intrus
au moment de l’application sont entièrement connues. Il est donc possible de savoir quels termes
peuvent être décomposés, lesquels doivent se trouver dans les connaissances, etc. Dans le modèle
implanté, les connaissances de l’intrus sont indéterminées. Il faut donc choisir de manière non-
s
déterministe si un terme, {t1 }t2 par exemple, va être présent dans les connaissances de l’intrus, ou
s
si l’intrus pourra, au moment de l’application de la règle, composer t1 et t2 , et donc {t1 }t2 .
Initialement, ce qu’on sait sur l’état des connaissances de l’intrus au moment de l’application
de la règle se résume à :
– l’intrus connaı̂t encore toutes ses connaissances initiales ;
– on peut supposer qu’il ne connaı̂t aucun secret, car sinon une erreur aurait déjà été trouvée
dans le protocole ;
– il peut composer tous les termes du membre gauche de la règle.
Dans la phase de décomposition, nous allons utiliser ces trois propriétés, ainsi que les lemmes
de normalisation de la sous-section 6.6.3 du chapitre 6 pour minimiser les choix non-déterministes.
Par exemple, si on a choisi que l’intrus pouvait, au moment de l’application de la règle, composer
p
t2 et t2 −1 , alors il est inutile de garder, dans le membre gauche de la règle, le terme {t1 }t2 . Par le
lemme 17 du chapitre 6, il suffit de garder le terme t1 . Inversement, s’il est possible d’assurer que
le terme t2 ne sera pas connu au moment de l’application de la règle, il est inutile de décomposer
p
{t1 }t2 .
8.5.4.ii Règles pour la décomposition

Les ensembles sur lesquels sont appliquées les règles vérifient certaines contraintes. Notons C
les connaissances initiales de l’intrus, et S l’ensemble des termes devant rester secret. Afin d’alléger
les notations, nous disons qu’un ensemble E de termes clos est régulier si :
– il contient les connaissances initiales de l’intrus au sens :
Rproto
C⊆E
– il ne permet pas d’obtenir un secret :

Rproto
S∩E =∅
Soient E et F deux ensembles. Nous appelons :

– Normg la composition des fonctions Simplif h , i , Simplif { }s et Simplif { }p définies dans le
chapitre 6, section 6.6.3 ;
– et nous définissons :
N(E : F ) = Norm(E ∪ F ) \ Norm(E)
Norm(l → r) = N(C : l) → N(C : r)
Proposition 53 Soit E un ensemble régulier, l → r une règle agrégée, σ une substitution et :
l0 → r0 = Norm(l → r)
Sous ces conditions :

Rproto Rproto
1. l0 σ ⊆ E si, et seulement si, lσ ⊆ E ;
2. si l’une des inclusions du premier point est vraie, alors
Rproto Rproto
E ∪ rσ = E ∪ r0 σ
Rproto Rproto
Preuve. Commençons par montrer le premier point. E est régulier, donc E = E∪C .
Rproto Rproto
On a donc F ∪ C ⊆ E si, et seulement si, F ⊆ E . Donc il suffit de montrer que pour tout
Rproto Rproto
ensemble de terme l, on a : lσ ⊆ E si, et seulement si, N(l)σ ⊆ E . Par les lemmes 11,
Rproto
15 et 17, et par C ⊆ E , on a :
Rproto Rproto
C ∪ lσ = C ∪ N(l)σ
Rproto Rproto Rproto
On a donc C ∪ lσ ⊆ C ∪ N(l)σ , et donc C ∪ N(l)σ ⊆ E implique C ∪ lσ ⊆ E .
L’autre implication est montrée en suivant le même raisonnement.
Montrons maintenant le second point. Par construction et par les lemmes 11, 15 et 17 :
Rproto Rproto
C ∪ rσ = C ∪ r0 σ
Donc l’hypothèse E régulier et le premier point entraı̂nent le second point.
Les règles agrégées sont d’abord mises en forme normale par application de la fonction N( ),
puis décomposées au moyen du système d’inférence suivant :
– décomposition dans le membre gauche :
G : f (t1 , t2 ), l → r Rproto
G : Norm(t1 , t2 , l → r) si S ∩ t1 , t2 , l =∅
– décomposition dans le membre droit :
G : l → f (t1 , t2 ), r Rproto
G : Norm(Cond(f (t1 , t2 )), l → r, f (t1 , t2 ), t1 ) si S ∩ Cond(f (t1 , t2 )), l =∅
Toutes les décompositions possibles sont testées. Pour assurer la terminaison, la décomposition
dans le membre droit n’est pas appliquée plusieurs fois sur le même terme. Si Lagg est l’ensemble
des règles agrégées après normalisation, nous notons L0dec l’ensemble des règles que ce système
permet d’engendrer à partir de Lagg .
L’ensemble Ldec des règles décomposées est défini à partir de L0dec de la manière suivante :
[ n
[
Ldec = {G : l → ri }
G:l→r1 ,...,rn ∈L0dec i=1
8.5.5 Calcul des règles d’Oracle

Le résultat d’une règle de Ldec peut être utilisé soit pour simplifier le membre gauche d’une
autre règle de Ldec , soit pour résoudre les contraintes résultant de l’interaction entre l’intrus et les
acteurs exécutant un nombre borné de sessions. En considérant par exemple une règle décomposée :
s s
∅ : {hx1 , Nai}K → {hNa, Nai}K
il est facile de voir que le premier cas peut entraı̂ner une boucle. Le but du calcul que nous présentons
maintenant est d’éliminer ce cas en pré-calculant les interactions possibles entre le membre gauche
d’une règle et son membre droit.
Soit E un ensemble clos, et G1 : l1 → r1 et G2 : l2 → r2 deux règles décomposées. Nous
considérons les transitions :
E →l1 σ1 →r1 σ1 E, r1 σ1 →LDY . . . →LDY F →l2 σ2 →r2 σ2 F, r2 σ

LDY
et supposons que l2 σ2 6⊆ E . L’application de la deuxième règle implique alors que r1 σ est
utilisé pour décomposer E ou pour composer lσ. Supposons qu’on ne soit pas dans le premier
cas. L’application des règles d’inférences entraı̂ne qu’il existe deux règles décomposées l10 → r10 et
l20 → r20 avec :
Rproto
– l10 σ1 ⊆ E ;
Rproto Rproto
– E ∪ {r1 σ, r2 σ2 } = E ∪ {r10 σ, r20 σ2 } ;
– et surtout :
r10 σ1 ∩ l20 σ2 6= ∅
Nous allons maintenant combiner les règles décomposées pour obtenir des règles d’Oracle pour
lesquelles nous pouvons assurer qu’il n’est pas nécessaire d’utiliser le membre droit d’une règle
d’Oracle pour simplifier le membre gauche d’une autre règle.
La règle de combinaison est la suivante :
G0 : l 0 → r 0 G : l ∪ {t} → r
si σ = mgu(r0 , t)
Uni(G, G ) : N ([l, l0 → r]σ)
0
La partie Uni(G, G0 ) est définie de la manière suivante pour des événements e. Soit E l’ensemble
des événements e tels que
– witness(e) est dans G0 ;
– request(e) est dans G.
Nous définissons alors :
Uni(G, G0 ) = {request(e) | request(e) ∈ G ∪ G0 }
/ E et witness(e) ∈ G0 }
∪ {witness(e) | e ∈
∪ {witness(e) | witness(e) ∈ G}
La règle de combinaison permet d’engendrer un nombre infini de règles d’Oracle. Afin d’assurer
la terminaison, nous ordonnons les règles créées par un ordre <L tel que G0 : l0 → r0 <L G : l → r
s’il existe une substitution σ telle que :
– lσ ⊆ l0 ;
– rσ = r0 ;
– l’ensemble des termes witness de Gσ est inclus dans l’ensemble des termes request de G0 , et
l’ensemble des termes request de G0 est inclus dans l’ensemble des termes witness de Gσ.
Ces trois conditions permettent d’assurer que s’il y a une attaque sur un protocole utilisant la règle
G0 : l0 → r0 , il est possible de la remplacer par la règle G : l → r.
Soit Σ l’ensemble des unificateurs entre le membre droit d’une règle décomposée et un terme
du membre gauche d’une règle décomposée. Chaque variable ne peut être remplacée que par une
constante, et il n’y a qu’un nombre fini de constantes, donc l’ensemble Σ est fini. Les règles ins-
tanciées sont les règles [G : l → r]σ, avec G : l → r une règle décomposée et σ ∈ Σ. L’ensemble
des règles instanciées est fini.
Montrons qu’il existe un ensemble fini de règles minimales pour l’ordre <L . Pour cela, soit
G : l → r une règle d’Oracle obtenue par l’application de la règle de combinaison. Il est possible
de représenter G : l → r par un arbre A dont la racine est r, chaque nœud r0 a pour fils les nœuds
l1 , . . . , lm avec G0 : l1 , . . . , lm → r0 une instance d’une règle décomposée. Utilisons la notion de
position sur cet arbre telle que définie pour les termes. Le membre gauche l est l’ensemble des
feuilles de cet arbre. Si la même règle instanciée est utilisée deux fois, aux positions p et p.p0 , alors
il est possible d’obtenir une règle G0 : l0 → r plus petite pour <L que G : l → r en remplaçant A|p
par A|p.p0 .
Si les règles d’Oracle sont engendrées de manière équitable, l’ensemble des règles minimales
sera atteint en un temps fini. Une fois cette ensemble atteint, toute règle ajoutée sera plus grande
qu’une des règles déjà présente, et peut donc être éliminée tout en gardant un ensemble de règles
d’Oracle préservant les attaques. En conclusion, il est possible d’engendrer un ensemble fini de
règles d’Oracle préservant les attaques.
8.5.6 Combinaison des règles d’Oracle et de la stratégie de recherche

d’attaque par résolution de contraintes
Nous considérons des problèmes de construction simultanée (Ei B ri )i∈{1,...,n} . Pour chaque
règle d’Oracle G : l1 , . . . , lm → r construite, nous ajoutons une règle d’inférence :
Cα , Ei B ri , Cβ
σ = mgu(r, ri )
Oracle(r) (Cα , Ei B l1 , . . . , Ei B lm , Cβ )σ
applicable si Cα est un problème de construction simultanée en par composition en forme résolue

et si ri n’est pas issu du membre gauche d’une règle d’Oracle.
La preuve de la terminaison de la recherche d’attaques par résolution de contraintes se fait
de la même manière avec ou sans règles d’Oracle en considérant celles-ci comme des règles de
décomposition. Seules des règles de composition peuvent être utilisées pour résoudre les contraintes
introduites par les règles d’Oracle, ce qui assure la terminaison. Pour la complétude, il suffit de
considérer une attaque dans laquelle un nombre minimal de règles agrégées sont utilisées.
8.6 Résultats expérimentaux

8.6.1 Outils
L’algorithme de construction des règles d’Oracle présenté dans la section 8.5 a été implanté
dans le compilateur de protocoles CasRul. L’outil de référence pour l’utilisation du compilateur
CasRul est le prouveur de théorèmes daTac. Ce programme a été développé par L. Vigneron
et est décrit dans [91, 102]. Il permet les preuves par réfutation dans les théories associatives et
commutatives en utilisant différentes techniques, comme la résolution ou la paramodulation. Dans
le cadre de l’analyse de protocoles, nous utilisons uniquement la résolution combinée avec des règles
de simplification et de subsomption. La déduction modulo AC est le principal inconvénient de cet
outil, mais est aussi sa principale qualité. Inconvénient, tout d’abord, car l’algorithme d’unification
modulo AC est intrinsèquement très complexe [57], ce qui rend difficile une mise en œuvre efficace.
Mais nous retiendrons surtout l’avantage de la déduction modulo AC. Elle permet d’interpréter les
règles en sortie du compilateur CasRul dans le formalisme naturel de ces règles, et donc de ne pas
changer la sémantique entre la sortie du compilateur et l’analyse. Un autre avantage est qu’il est
très facile de développer de nouvelles stratégies d’analyse de protocole. Actuellement, daTac est le
seul outil prenant en compte les règles d’Oracle en sortie du compilateur CasRul.
8.6.2 Accélération pour la recherche d’attaques

8.6.2.i Un exemple, le protocole d’échange de clefs Encrypted Key Exchange
Nous décrivons d’abord la spécification en LHNSP du protocole Encrypted Key Exchange,
puis donnons les règles d’Oracle en sortie du compilateur CasRul, et enfin décrivons pas à pas la
recherche d’attaque par daTac.
Spécification en LHNSP. Nous commençons par donner comme exemple l’étude du protocole
Encrypted Key Exchange, connu pour avoir une erreur d’authentification lorsque plusieurs sessions
se déroulent concurremment [26]. La spécification de ce protocole est donnée dans la figure 8.2.
Règles d’Oracle en sortie du compilateur. Le cas de ce protocole est très simple, et il n’y
a pas de composition possible entre les règles du rôle B. Les deux règles en sortie du compilateur
sont :
s p s
i({xKa11}p ) ⇒ i({{re}xKa11 }p )
s s s
i({xN a22}re ) · i({xKa22}p ) · witness(a, b, N b, xN b22) ⇒ i({hxN a22, N bi}re )
La durée totale de la phase de compilation est inférieure à 0.01s.
Trace de la recherche d’attaque. Nous notons a(seq) l’acteur a jouant un nombre borné
de sessions et a(seq) l’acteur a jouant un nombre non borné de sessions. Nous allons suivre en
parallèle la recherche d’attaque incrémentale par daTac et sa traduction en terme de problème de
construction simultanée. Dans la suite de résolutions menant à la faille, la première règle appliquée
est celle d’envoi de message par a(seq) :
s
a(seq) → : {Ka}p
8.6. Résultats expérimentaux 159
Encrypted Key Exchange ;
A, B : ;
Na, Nb : ;
Ka : ;
P, R : ;
A : B, P ;
B : P;
1. A → B : {Ka}P
2. B → A : {{R} Ka}P
3. A → B : {Na} R
4. B → A : {Na, Nb} R
5. A → B : {Nb} R
B[A : b; B : a; P : p; Re : re] ;
p, re ;
A[A : a; B : b; P : p] ;
a, b ;
A authenticates B on N a ;
Fig. 8.2 – Spécification du protocole Encrypted Key Exchange en LHNSP.
Aucune contrainte ne repose sur les connaissances de l’intrus. La règle suivante est la réception
du message de l’étape 2. par a(seq) :
s
a(seq) → : {Ka}p
p s
→ a(seq) : {{x1 }Ka }p
s
a(seq) → : {N a}x1
L’intrus doit maintenant composer un message de la forme {{x1 } Ka} p. Le problème de cons-
truction simultanée est, à ce moment :
s p s
a, b, {Ka}p B {{x1 }Ka }p
Dans daTac, la résolution suivante est l’application de la première règle d’Oracle. Dans le problème
de construction simultanée, cette inférence se traduit par l’application de la règle :
Cα , Ei B ri , Cβ p s
p s s σ = mgu({{re}xKa11 }p , ri )
Oracle({{re}xKa11 }p ) (Cα , Ei B {xKa11}p , Cβ )σ
Le problème de construction simultanée devient alors :

s s
a, b, {Ka}p B {Ka}p
et la suite de messages échangés, telle que trouvée par daTac, est :

s
a(seq) → : {Ka}p
s
→ a(//) : {Ka}p
p s
a(//) → : {{re}Ka }p
p s
→ a(seq) : {{re}Ka }p
s
a(seq) → : {N a}re
Le protocole se poursuit jusqu’à aboutir à la suite de messages :
s
a(seq) → : {Ka}p
s
→ a(//) : {Ka}p
p s
a(//) → : {{re}Ka }p
p s
→ a(seq) : {{re}Ka }p
s
a(seq) → : {N a}re
s
→ a(//) : {N a}re
s
a(//) → : {hN a, N bi}re
s
→ a(seq) : {hN a, N bi}re
s
a(seq) → : {N b}re
À ce moment, l’acteur a(seq) ajoute un terme request(a, b, N b, B) à l’état du protocole. Le seul

terme witness dans l’état est, à ce moment, le terme ajouté lors de l’utilisation de la seconde règle
d’Oracle, soit witness(a, b, N a, N a). La règle de simplification :
request(x1 , x2 , x3 , x4 ) · witness(x2 , x1 , x3 , x4 ) ⇒ ∅
ne peut pas être appliquée, donc le terme request(a, b, N b, B) n’est pas simplifié : il y a une attaque.
En faisant une recherche en largeur dans l’ensemble des clauses pouvant être atteintes à partir de
la clause décrivant l’état initial du protocole, daTac trouve l’erreur en quelques secondes, après
avoir exploré 7 clauses. Il n’y a aucune heuristique de recherche d’attaque mise en œuvre autre que
celles décrites dans ce chapitre et celles du chapitre 6.
8.6.2.ii Résultats obtenus

Parmi les protocoles de la table 6.3, nous avons repris dans la table 8.1 ceux dont les temps
d’études étaient les plus longs (supérieurs à une minute) et dans les failles desquels des acteurs de
plusieurs sessions sont impliqués.
Temps (s)
Protocole Attaque sans avec
Oracle Oracle
Woo-Lam Π Authentification 20 0.5
Woo-Lam Mutual Authentication Authentification 1024 81
Needham-Schroeder Public Key intermédiaire 1230 234
Kao Chow Repeated Authentication, 1 Re-jeu 77 1.5
SPLICE/AS Authentication Protocol Re-jeu 352.42 AF
Denning Sacco Key Distribution with Public Key intermédiaire 937 32
Encrypted Key Exchange Authentification 241 24
Davis Swick Private Key Certificates, protocol 1 Erreur de typage 106 AF
Davis Swick Private Key Certificates, protocol 2 Erreur de typage 348 AF
Tab. 8.1 – Comparaison des résultats avec et sans utilisation de d’acteurs pouvant participer à un
nombre non borné de sessions.
Notes sur les expériences.

– la version du protocole Needham-Schroeder Public Key testée est la version complète dans
laquelle un serveur de clefs intervient ;
– l’erreur trouvée dans le protocole Woo-Lam Π est différente de celle présentée au chapitre 6.
Il s’agit dans ce tableau d’une erreur de typage. Le temps mis pour l’étude sans règle d’Oracle
correspond au temps nécessaire pour trouver la même erreur ;
– l’état initial pour l’étude du protocole Encrypted Key Exchange n’est pas minimal. Il est
possible de trouver une attaque en 6 s ;
8.6. Résultats expérimentaux 161
8.6.3 Vérification de protocoles

L’abstraction sur les nonces permet de vérifier des protocoles dans le cadre restreint des tailles
de messages bornés. Nous avons cherché à vérifier les protocoles décrits par J. Clark et J. Jacob [26]
et qui ne sont pas considérés comme fautifs par G. Lowe [42].
8.6.3.i Description des tests

Nous avons recherché, pour les protocoles du tableau 8.2, s’ils étaient corrects lorsque des
sessions impliquant des acteurs honnêtes étaient considérées. Pour cela, nous prenons pour Aqcq
une session dans laquelle chaque rôle est instancié par un acteur honnête, et dupliquons cette
session dans AD . Nous avons limité le nombre de sessions auxquelles pouvaient prendre part les
acteurs de Aqcq à une seule. Cette restriction permet d’assurer la terminaison de la vérification. Le
temps donné dans le tableau 8.2 correspond au temps d’exécution du système sur un Pentium IV
à 2.4 GHz sous Linux.
Protocole Vérifié Temps (s)
Amended Needham-Schroeder Protocol NA
Bilateral Key Exchange oui 21
Carlsen’s Secret Key Initiator non 6
ISO 2 Pass Parallel Mutual Authentication oui 4
ISO 4 pass oui 8
ISO 5 pass oui 25
ISO 2 pass Unilateral Authentication with Asymmetric keys oui 1
ISO 3 pass Mutual Authentication with Asymmetric keys oui 2
ISO 2 pass Unilateral Authentication with CCFs oui 1
ISO 3 pass Mutual Authentication with CCFs oui 2
ISO 2 pass Unilateral Authentication with Symmetric Keys oui 1
ISO 3 pass Mutual Authentication with Symmetric keys oui 1
Using Non-reversible Functions oui 5
WooLam-pi (final) oui 887
Yahalom oui 10
Tab. 8.2 – Protocoles vérifiés.
8.6.3.ii Commentaires sur le tableau 8.2

Carlsen Secret Key Initiator Protocol. Le problème, dans ce protocole, réside dans les deux
derniers messages échangés :
s s
1. B → A : {Na, B , Kab}Kas , {Na}Kab , Nc
s
2. A → B : {Nc }Kab
Fig. 8.3 – Les deux derniers messages du protocole de Carlsen.
L’intrus profite de la réutilisation des nonces d’une session sur l’autre pour créer une fausse
attaque en envoyant à B une valeur pour Na égale à la valeur du nonce qu’envoie B à l’avant-dernier
s
message. L’intrus peut alors répondre directement à B en utilisant le sous-message {N a}Kab =
s
{N c}Kab .
Amended Needham-Schroeder Protocol. Dans ce protocole, il existe un message qui est

reçu par un rôle et est renvoyé sans analyse. Le problème, dans le cas de ce protocole, est que
contrairement au cas de protocole Π de Woo et Lam, le message inconnu est reçu chiffré et envoyé
en clair. Cela entraı̂ne un manque d’information sur les parties de ce message que l’intrus connaı̂t
ou, au contraire, ne parvient pas à décomposer, et conduit à la création d’un grand nombre de
règles. Nous avons arrêté le processus de vérification à ce stade.
8.6.3.iii Conclusion sur la vérification de protocoles

Nous considérons que la méthode développée dans ce chapitre est un succès partiel pour ce qui
est de la vérification de protocoles. En comparaison de l’analyse faite par B. Donovan, G. Lowe
et P. Norris [42], nous avons réussi à analyser avec succès 12 des 14 protocoles pour lesquels
aucune attaque n’avait été trouvée5 . Parmi les deux derniers protocoles, la réponse erronée pour
le protocole de Carlsen ne nous semble pas trop gênante car la trace de l’attaque trouvée peut
être analysée. Même si ce processus est long, le fait de pouvoir écarter d’emblée environ 85 %
des protocoles nous semble justifier l’utilisation de notre méthode. Le cas du protocole Amended
Needham-Schroeder Protocol est plus problématique car il semble courant, pour des protocoles de
commerce électronique, d’envoyer à un destinataire un message qu’il ne peut pas déchiffrer et qu’il
devra envoyer à une troisième personne. L’analyse de ce type de protocole est prévue dans le cadre
du projet AVISPA. Il nous semble que la technique présentée devra être raffinée pour permettre
l’analyse de ces protocoles « industriels ».
5 Le cas du protocole de Denning et Sacco étant à part, une erreur, décrite dans le chapitre 6 et dans [25] ayant
été trouvée.
9
Bilan et Perspectives
L’analyse des protocoles cryptographiques soulève trois grands problèmes :

– le problème de la compilation, pour lequel nous cherchons à donner une sémantique opérationnelle
à une spécification déclarative d’un protocole ;
– le problème de la recherche d’attaques, pour lequel nous cherchons à éliminer le plus rapide-
ment possible les protocoles mal spécifiés ;
– et finalement le problème de la vérification, pour lequel nous recherchons si un protocole est
correctement spécifié et peut être utilisé en pratique.
Nous tentons de faire une synthèse de nos contributions, d’en cerner les limites mais aussi de
dégager des pistes de travail, selon ces trois grands axes.
Compilation. Sur le plan théorique, la modélisation de l’exécution d’une instance d’un proto-
cole par des systèmes de réécriture était acquise avant le début de notre travail. Les problèmes
d’exécutabilité d’une spécification et de gestion des connaissances étaient résolus dans le cas des
opérateurs libres. Nous avons étendu ces deux derniers résultats à certains opérateurs algébriques.
Il nous semble que les méthodes utilisées sont très générales, et permettent une extension rapide
à tout opérateur susceptible d’être utilisé. Nous avons proposé un modèle « prudent » des rôles :
ceux-ci cherchent toujours à extraire le maximum d’information des connaissances qu’ils possèdent
et en vérifient la cohérence.
Parmi les challenges encore à relever, l’un des plus importants nous semble être la prise en
compte du coût des ressources d’une exécution d’un protocole pour un rôle. Le but est double.
Tout d’abord, il doit nous permettre d’analyser la vulnérabilité d’un protocole à une attaque de
type déni de service. Ensuite, une partie des protocoles cryptographiques en cours de développement
seront à terme implantés dans des réseaux où les postes auront une faible puissance de calcul, des
téléphones portables, par exemple. Une direction d’étude qui nous semble intéressante serait de
rechercher une représentation des connaissances minimisant l’espace mémoire utilisé et/ou le temps
de calcul pour la composition d’un message et telle qu’un protocole reste sûr.
Une autre possibilité, qui peut être explorée de conserve, est l’implantation automatique d’un
protocole à partir de sa spécification. Nous avons donné dans le chapitre 5 une représentation des
connaissances, des messages attendus et envoyés par un rôle.
Enfin, et plus concrètement, nous aurons à implanter le processus de compilation dans les mois
à venir dans la nouvelle version du compilateur CasRul au sein du projet AVISPA. Nous aurons
alors à montrer la correction de la compilation par rapport à une sémantique du langage de haut
niveau donnée dans un langage proche de TLA.
Recherche d’attaques. Nous considérons que le problème de la recherche d’attaques dans le cas
d’un intrus passif est en grande partie clos par le chapitre 4. Nous avons montré que ce problème est
polynomial pour toute combinaison des opérateurs que nous avons considérés dans ce document.
De plus, pour étendre ce résultat à un système ayant en plus un opérateur, il suffit de montrer
que le système de règles de déductions pour cet opérateur est canonique et que le problème de
l’existence d’une transition entre deux ensembles peut être résolu en temps polynomial.
163
164 Chapitre 9. Bilan et Perspectives
Le travail présenté sur la recherche d’attaques dans le cas d’un intrus actif peut être poursuivi
selon deux directions. La première consiste à proposer une implantation efficace des algorithmes
de recherche d’attaques présentés dans le chapitre 7 ou, selon le point de vue, étendre l’algorithme
présenté dans le chapitre 6 pour la prise en compte des opérateurs algébriques. La deuxième direc-
tion consiste à rechercher un résultat de combinaison analogue à celui que nous avons donné pour
le cas clos.
Vérification. Nous avons montré dans le chapitre 8 que le problème de la vérification était de
complexité exponentielle dans le cas où seuls des opérateurs libres sont considérés. Nous conjectu-
rons que ce résultat s’étend verbatim à toute signature régulière et permettant le remplacement.
Les résultats de l’agorithme de calcul des règles d’Oracle présenté nous semblent très encou-
rageants. La principale difficulté est de réussir à éliminer le plus de règles redondantes possibles
tout en gardant un système correct pour la vérification de protocoles. Nous avons déjà progressé
par rapport à l’algorithme présenté dans [25], mais avant de nous attaquer à des protocoles plus
complexes, il nous faudra notamment réussir à mieux prendre en compte les cas où des données
sont transmises sans être analysées.
Bibliographie
[1] R. Amadio and D. Lugiez. On the reachability problem in cryptographic protocols. In

CONCUR00, number 1877 in LNCS. Springer, 2000. Also available as INRIA Research
Report 3915, Marseille (France) (2000).
[2] R. Amadio, D. Lugiez, and V. Vanackère. On the symbolic reduction of processes with
cryptographic functions. TCS, 1(290) :695–740, 2003. Also available as Technical Report
4147, INRIA, March 2001.
[3] A. Armando, D. Basin, M. Bouallagui, Y. Chevalier, L. Compagna, S. Mödersheim, M. Ru-
sinowitch, M. Turuani, L. Vigano, and L. Vigneron. The AVISS Security Protocol Analysis
Tool. In 14th International Conference on Computer Aided Verification, CAV’2002, LNCS
2404, pages 349–353, Copenhaguen (Denmark), 2002. Springer.
[4] J. Audun. Security Protocol Verification using SPIN, 1995.
[5] F. Baader and W. Snyder. Handbook of Automated Reasoning, chapter Chapter 8 : Unification
Theory. Springer, 1999.
[6] D. Basin, S. Mödersheim, and L. Viganò. An On-The-Fly Model-Checker for Security Pro-
tocol Analysis. In Proceedings of the 8th European Symposium On Research In Computer
Security (ESORICS’03), LNCS. springer, 2003. (To appear).
[7] G. Bella, F. Massacci, and L. Paulson. The Verification of an Industrial Payment Protocol :
The SET Purchase Phase. In Proceedings of the 9th ACM Conference on Computer and
Communications Security, pages 12–20. ACM Press, 2002.
[8] G. Bella, F. Massacci, and L. Paulson. Verifying the SET Registration Protocols. IEEE
Journal on Selected Areas in Communications, 1(21) :77–87, 2003.
[9] G. Bella, F. Massacci, L. Paulson, and P. Tramontano. Formal Verification of Cardholder Re-
gistration in SET. In Proceedings of the Sixth European Symposium on Research in Computer
Security (ESORICS), LNCS 1895, pages 159–174. Springer, 2000.
[10] B. Blanchet. An Efficient Cryptographic Protocol Verifier Based on Prolog Rules. In Procee-
dings of the 14th IEEE Computer Security Foundations Workshop (CSFW-14), pages 82–96.
IEEE Computer Society, june 2001.
[11] B. Blanchet. From Secrecy to Authenticity in Security Protocols. Lecture Notes on Computer
Science, 2477 :342–359, September 2002.
[12] B. Blanchet and A. Podelski. Verification of Cryptographic Protocols : Tagging Enforces
Termination. Lecture Notes on Computer Science, 2620 :136–152, April 2003.
[13] M. Boreale. Symbolic analysis of cryptographic protocols in the spi-calculus. In Fernando
Orejas, Paul G. Spirakis, and Jan van Leeuwen, editors, Proceedings of the 28th International
Colloqium on Automata, Languages and Programming, volume 2076 of Lecture Notes in
Computer Science. Springer, july 2001.
[14] A. Bosselaers and B. Den Boer. Collisions for the Compression Function of MD-5. In
Proceedings of EUROCRYPT ’93 : Workshop on the Theory and Application of Cryptographic
Techniques, volume 765 of LNCS. Springer, May 1993.
[15] J. Bryans and S. Schneider. CSP, PVS, and a Recursive Authentication Protocol. In DIMACS
Workshop on Design and Verification of Security Protocols, 1997.
165
166 Bibliographie
[16] J. Bull and D. Otway. The Authentication Protocol. Technical Report CIS3/PROJ/CORBA/
SC/1/CSM/436-04/03, Defense Research Agency (DRA), Feb 1997.
[17] M. Burrows, M. Abadi, and R. Needham. A Logic of Authentication. ACM Transactions on
Computer Systems, 8(1) :18–36, 1990.
[18] K. M. Chandy and J. Misra. Parallel Program Design. Addison-Wesley, 1988.
[19] Y. Chevalier, R. Kuesters, M. Rusinowitch, and M. Turuani. An NP Decision Procedure for
Protocol Insecurity with XOR. In Proceedings of the Logic In Computer Science Conference
LICS’03, June 2003. Long version available as Technical Report RR-4697, INRIA, France.
[20] Y. Chevalier, R. Kuesters, M. Rusinowitch, and M. Turuani. Deciding the Security of Pro-
tocols with Diffie-Hellman Exponentiation and Products in Exponents. In Proceedings of the
Foundations of Software Technology and Theoretical Computer Science FSTTCS’03, Decem-
ber 2003. Long version soon available as Christian-Albrecht Universität IFI-Report 0305,
Kiel (Germany).
[21] Y. Chevalier, R. Kuesters, M. Rusinowitch, and M. Turuani. Deciding the Security of Pro-
tocols with Diffie-Hellman Exponentiation and Products in Exponents. Technical Report
IFI-Report 0305, Christian-Albrecht Universität, Kiel (Germany), Apr 2003.
[22] Y. Chevalier, R. Kuesters, M. Rusinowitch, and M. Turuani. Extending the Dolev-Yao
Intruder for Analyzing an Unbounded Number of Sessions. In Proceedings of the Computer
Science Logic Conference CSL’03, August 2003. Long version soon available as Technical
Report RR-4869, INRIA, France.
[23] Y. Chevalier and L. Vigneron. A Tool for Lazy Verification of Security Protocols. In Procee-
dings of the Automated Software Engineering Conference (ASE’01). IEEE Computer Society
Press, 2001. Long version available as INRIA Research Report RR-4368, January 2002.
[24] Y. Chevalier and L. Vigneron. Towards Efficient Automated Verification of Security Pro-
tocols. In Proceedings of the Verification Workshop (VERIFY’01) (in connection with IJ-
CAR’01), Università degli studi di Siena, TR DII 08/01, pages 19–33, June 2001.
[25] Y. Chevalier and L. Vigneron. Automated Unbounded Verification of Security Protocols.
In 14th International Conference on Computer Aided Verification, CAV’2002, LNCS 2404,
pages 324–337, Copenhaguen (Denmark), 2002. Springer. Long version available as INRIA
Research Report 4369, January 2002.
[26] J. Clark and J. Jacob. A Survey of Authentication Protocol Literature : Version 1.0,
17. Nov. 1997. http://www.cs.york.ac.uk/~jac/papers/drareview.ps.gz.
[27] H. Comon-Lundh and V. Cortier. Security properties : two agents are sufficient. In In Proc.
12th European Symposium on Programming (ESOP’2003), volume 2618 of Lecture Notes in
Computer Science, pages 99–113. Springer, Apr 2003.
[28] H. Comon-Lundh and V. Shmatikov. Intruder deductions, constraint solving and insecurity
decision in presence of exclusive or. In Proceedings of The Symposium on Logic in Computer
science (LICS’03) Conference. IEEE, June 2003.
[29] R. Corin and S. Etalle. An Improved Constraint-Based System for the Verification of Security
Protocols. In M. V. Hermenegildo and G. Puebla, editors, 9th Int. Static Analysis Symposium
(SAS), LNCS 2477, pages 326–341, Madrid (Spain), 2002. Springer.
[30] V. Cortier. Vérification automatique des protocoles cryptographiques. PhD thesis, École
Normale Supérieure de Cachan, march 2003. http://www.lsv.ens-cachan.fr/~cortier.
[31] Z. Dang and R. Kemmerer. Using the ASTRAL Model Checker for Cryptographic Protocol
Analysis. In Proceedings of the DIMACS Workshop on Design and Formal Verification of
Security Protocols, September 1997.
[32] Centre National de Transfert de Données Sociales. Structure du numéro de sécurité sociale.
http://www.dads.cnav.fr/tds/Stru0103.htm.
[33] M. Debbabi, M. Mejri, M. Tawbi, and I. Yahmadi. Formal Automatic Verification of Authen-
tication Cryptographic Protocols. In Proceedings of the First IEEE International Conference
on Formal Engineering Methods, ICFEM’97, November 1997.
167
[34] G. Denker. Design of a CIL connector to Maude. In H. Veith, N. Heintze, and E. Clarke,
editors, Workshop on Formal Methods and Comuter Security. Carnegie Mellon University,
July 2000.
[35] G. Denker and J. Millen. CAPSL and CIL language design. Technical Report SRI-CSL-99-02,
SRI International Computer Science Laboratory, 1999.
[36] G. Denker and J. Millen. CAPSL Intermediate Language. In N. Heintze and E. Clarke, edi-
tors, Proceedings of Workshop on Formal Methods and Security Protocols (FMSP’99). Avai-
lable at http://cm.bell-labs.com/cm/cs/who/nch/fmsp99/. URL for CAPSL and CIL :
http://www.csl.sri.com/$\sim$millen/capsl/,, 1999.
[37] G. Denker and J. Millen. CAPSL and MuCAPSL. Journal of Telecommunications and
Information Technology, 4 :16–27, 2002.
[38] G. Denker, J. Millen, and H. Ruess. The CAPSL integrated protocol environment. Technical
Report SRI-CSL-2000-02, SRI International, 2000.
[39] D. Denning and G. Sacco. Timestamps in Key Distribution Protocols. Communications of
the ACM, 24(8), August 1981.
[40] W. Diffie and M. Hellman. New directions in cryptography. IEEE Transactions on Informa-
tion Theory, IT-22(6) :644–654, 1976.
[41] D. Dolev and A. Yao. On the Security of Public Key Protocols. IEEE Transactions on
Information Theory, 29(2) :198–208, march 1983.
[42] B. Donovan, G. Lowe, and P. Norris. Analyzing a Library of Security Protocols using Casper
and FDR. In Proceedings of the Workshop on Formal Methods and Security Protocols, 1999.
[43] A. Durante, R. Focardi, and R. Gorrieri. CVS : A compiler for the analysis of cryptogra-
phic protocols. In Proceedings of the 12th Computer Security Foundations Workshop. IEEE
Computer Society Press, 1999.
[44] A. Durante, R. Focardi, and R. Gorrieri. A Compiler for Analysing Cryptographic Proto-
cols Using Non-Interference. ACM Transactions on Software Engineering and Methodology,
9(4) :489–530, 2000.
[45] N. Durgin, P. Lincoln, J. Mitchell, and A. Scedrov. Undecidability of bounded security
protocols. In N. Heintze and E. Clarke, editors, Proceedings of the FLOC’99 Workshop on
Formal Methods and Security Protocols (FMSP’99), Trento, Italy, July 1999. Available at
http://www.cs.bell-labs.com/who/nch/fmsp99/program.html.
[46] C. Dwork, P. Kanellakis, and J. Mitchell. On the Sequential Nature of Unification. Journal
of Logic Programming, 1 :35–50, 1984.
[47] T. El-Gamal. A Public-Key Cryptosystem and a Signature Scheme based on Discrete Loga-
rithms. IEEE transactions on Information Theory, IT-31(4) :469–472, 1985.
[48] S. Even and O. Goldreich. On the Security of Multi-party Ping-pong Protocols. In 24th
IEEE Symposium on Foundations of Computer Science, 1983.
[49] M. Fiore and M. Abadi. Computing Symbolic Models for Verifying Cryptographic Protocols.
In 14th IEEE Computer Security Foundations Workshop, pages 160–173. IEEE Computer
Society, 2001.
[50] R. Focardi and F. Martinelli. A Uniform Approach for the Definition of Security Properties.
In World Congress on Formal Methods (1), pages 794–813, 1999.
[51] T. Genet and F. Klay. Rewriting for Cryptographic Protocol Verification. In 17th Inter-
national Conference on Automated Deduction, LNCS 1831, pages 271–290, Pittsburgh (PA,
USA), 2000. Springer.
[52] L. Gong. Enclaves : Enabling Secure Collaboration over the Internet. IEEE J. of Selected
Areas in Communications, 15(3) :567–575, April 1997.
[53] J. Goubault-Larrecq. A Method for Automatic Cryptographic Protocol Verification. In Proc.
15 IPDPS 2000 Workshops, Cancun, Mexico, LNCS 1800, pages 977–984. Springer, 2000.
[54] J. Heather, G. Lowe, and S. Schneider. How to Prevent Type Flaw Attacks on Security
Protocols. In 13th IEEE Computer Security Foundations Workshop, pages 255–268. IEEE
Computer Society, 2000.
168 Bibliographie
[55] N. Heintze and J. Tygar. A Model for Secure Protocols and Their Compositions. IEEE
Transactions on Software Engineering, 22(1) :16–30, January 1996.
[56] F. Jacquemard, M. Rusinowitch, and L. Vigneron. Compiling and Verifying Security Proto-
cols. In M. Parigot and A. Voronkov, editors, Proceedings of LPAR 2000, LNCS 1955, pages
131–160. Springer-Verlag, Heidelberg, 2000.
[57] D. Kapur and P. Narendran. Double-Exponential Complexity of Computing a Complete
Set of AC-Unifiers. In Proceedings of the Seventh Symposium on Logic in Computer Science
(LICS’92), pages 11–21, Santa Cruz, CA, 1992.
[58] D. Kozen. On the Complexity of Finitely Presented Algebras. In Proc. 9th Ann. ACM
Symposium Theory Computation, pages 164–177, 1977.
[59] Y. Lakhnech L. Bozga and M. Perin. Pattern-based Abstraction for verifying Secrecy in
Protocols. In H. Garavel and J. Hatcliff, editors, Proceedings of the 9th International Confe-
rence on Tools and Algorithms for the Construction and Analysis of Systems, volume 2619
of Lecture Notes in Computer Science. Springer, april 2003.
[60] M. Layouni, J. Hooman, , and S. Tahar. On the Correctness of an Intrusion-Tolerant Group
Communication Protocol. In Proceedings of the 12th Advanced Research Working Conference
on Correct Hardware Design and Verification Methods (CHARME’03). Springer, October
2003.
[61] G. Lowe. Breaking and fixing the Needham-Schroeder public-key protocol using FDR. In
T. Margaria and B. Steffen, editors, Proceedings of TACAS’96, LNCS 1055, pages 147–166.
Springer, Berlin, 1996.
[62] G. Lowe. A Hierarchy of Authentication Specifications. In Proceedings of the IEEE Sympo-
sium on Security and Privacy, pages 31–43, 1997.
[63] G. Lowe. Casper : a Compiler for the Analysis of Security Protocols. Journal of Computer
Security, 6(1) :53–84, 1998. http://www.mcs.le.ac.uk/~gl7/Security/Casper/.
[64] G. Lowe. Towards a Completeness Result for Model Checking of Security Protocols. In 11th
IEEE Computer Security Foundations Workshop, pages 96–105. IEEE Computer Society,
1998.
[65] A. Martelli and U. Montanari. An Efficient Unification Algorithm. ACM Journal of Language,
4(23) :733–742, October 1976.
[66] D. McAllester. New Results on Local Inference Relations. In Proceedings of the 3rd Interna-
tional Conference on Principles of Knowledge Representation and Reasoning (KR’92), pages
403–412, 1992.
[67] C. Meadows. Analyzing the Needham-Schroeder Public-Key Protocol : A Comparison of
Two Approaches. In ESORICS : European Symposium on Research in Computer Security.
LNCS 1146, Springer-Verlag, 1996.
[68] C. Meadows. Language Generation and Verification in the NRL Protocol Analyzer. In
9th IEEE Computer Security Foundations Workshop, pages 48–61. IEEE Computer Society,
1996.
[69] C. Meadows. The NRL Protocol Analyzer : an Overview. Journal of Logic Programming,
26(2) :113–131, 1996.
[70] R. Merkle. Secure Communications Over Insecure Channels. Communications of the ACM,
21(4) :294–299, 1978.
[71] R. Merkle and M. Hellman. Hiding and Signatures in Trapdoor Knapsacks. IEEE transactions
on Information Theory, 24(5) :525–530, september 1978.
[72] J. Millen. CAPSL : Common Authentication Protocol Specification Language. Technical
Report MP 97B48, The MITRE Corporation, 1997.
[73] J. Millen and V. Shmatikov. Constraint Solving for Bounded-process Cryptographic Protocol
Analysis. In 8th ACM Conference on Computer and Communication Security, pages 166–175.
ACM SIGSAC, 2001.
169
[74] J.C. Mitchell, M. Mitchell, and U. Stern. Automated Analysis of Cryptographic Protocols
Using Murϕ. In Proceedings of IEEE Symposium on Security and Privacy, pages 141–153,
1997.
[75] D. Monniaux. Abstracting Cryptographic Protocols with Tree Automata. In Sixth Inter-
national Static Analysis Symposium (SAS’99), number 1694 in Lecture Notes in Computer
Science, pages 149–163. Springer, 1999.
[76] P. Narendran and C. Meadows. A Unification Algorithm for the Group Diffie-Hellman Pro-
tocol. In Proceedings of WITS’02, January 2002.
[77] R. Needham and M. Schroeder. Using Encryption for Authentication in Large Networks of
Computers. Communications of the ACM, 21(12) :993–998, December 1978.
[78] R. Needham and M. Schroeder. Using Encryption for Authentication in Large Networks of
Computers. Technical Report CSL-78-4, Xerox Palo Alto Research Center, Palo Alto, CA,
USA, 1978. Reprinted June 1982.
[79] L. Paulson. Verifying security protocols using isabelle. http://www.cl.cam.ac.uk/users/
lcp/papers/protocols.html.
[80] L. Paulson. Isabelle : a generic theorem prover ; with contributions by T. Nipkow. LNCS 828.
Springer, Berlin, 1994.
[81] L. Paulson. Mechanized Proofs for a Recursive Authentication Protocol. In 10th Computer
Security Foundations Workshop, pages 84–95. IEEE Computer Society Press, 1997.
[82] L. Paulson. The Inductive Approach to Verifying Cryptographic Protocols. Journal of
Computer Security, 6(1) :85–128, 1998.
[83] L. Paulson. Inductive Analysis of the Internet Protocol TLS. ACM Transactions on Infor-
mation and System Security, 2(3) :332–351, 1999.
[84] L. Paulson. Proving Security Protocols Correct. In Proceedings of the IEEE Symposium on
Logic in Computer Science, 1999.
[85] W. Plandowski. On the Satisfiability Problem for Word Equations. Technical Report TUCS-
TR-304, Turku Center for Computer Science, 17, 1999.
[86] W. Plandowski and W. Rytter. Application of Lempel-Ziv Encodings to the Solution of Word
Equations. Lecture Notes in Computer Science, 1443 :731–742, 1998.
[87] R. Rivest, A. Shamir, and L. Adleman. A Method for Obtaining Digital Signatures and
Public Key Cryptosystems. Communications of the ACM, 21(2) :120–126, february 1978.
[88] A. W. Roscoe. Modelling and Verifying Key-exchange Protocols using CSP and FDR. In
8th IEEE Computer Security Foundations Workshop, pages 98–107. IEEE Computer Society,
1995.
[89] PKCS 1 : RSA Encryption 1.5. http://www.ietf.org/rfc/rfc2313.txt.
[90] M. Rusinowitch and M. Turuani. Protocol Insecurity with Finite Number of Sessions is NP-
complete. In Proceedings of the 14th IEEE Computer Security Foundations Workshop. IEEE,
2001.
[91] M. Rusinowitch and L. Vigneron. Automated Deduction with Associative-Commutative
Operators. Applicable Algebra in Engineering, Communication and Computation, 6(1) :23–
56, 1995.
[92] P. Ryan and S. Schneider. An Attack on a Recursive Authentication Protocol. Information
Processing Letters 65, 1998.
[93] P. Ryan, S. Schneider, M. Goldsmith, G. Lowe, and B. Roscoe. Modelling and Analysis of
Security Protocols, 2001.
[94] S. Schneider. Using CSP for Protocol Analysis : the Needham-Schroeder Public Key Protocol.
Technical Report CSD-TR-96-14, Royal Holloway, 1996.
[95] B. Schneier. Applied Cryptography. John Wiley & sons, New York, 1996. (Cryptographie
Appliquée, traduction par L Viennot).
170 Bibliographie
[96] A. Shamir. A Polynomial Time Algorithm for Breaking the Basic Merkle-Hellman Crypto-
system. In Proceedings of 23rd Symposium on Fondations Of Computer Science (FOCS),
pages 145–152. IEEE, 1982.
[97] R. Shostack. An Algorithm for Reasoning About Equality. Commmunications of the ACM,
21(7) :583–585, July 1978.
[98] D. Song. Athena : a new Efficient Automatic Checker for Security Protocol Analysis. In 12th
IEEE Computer Security Foundations Workshop, pages 192–202. IEEE Computer Society,
1999.
[99] D. Song, S. Berezin, and A. Perrig. Athena, a Novel Approach to Efficient Automatic Security
Protocol Analysis. Journal of Computer Security, 9((1,2)) :47–74, 2001.
[100] S. Stoller. A Bound on Attacks on Payment Protocols. In Proccedings of the Symposium on
Logic in Computer Science, pages 61–70, 2001.
[101] P. Syverson, C. Meadows, and I. Cervesato. Dolev-Yao is no Better than Machiavelli. In
Proceedings of WITS 2000, 2000.
[102] L. Vigneron. Positive Deduction modulo Regular Theories. In H. Kleine-Büning, editor,
Proceedings of Computer Science Logic, LNCS 1092, pages 468–485. Springer-Verlag, 1995.
URL : http://www.loria.fr/equipes/cassis/softwares/daTac/.
[103] A. Yasinsac and W. Wulf. A Formal Semantics for Evaluating Cryptographic Protocols.
Technical Report CS-93-53, U. Virginia, 1993.

Langue

Bienvenue sur Scribd !

thèse de doctorat

Transféré par

Informations du document

Description :

Date du transfert

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

thèse de doctorat

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

Département de formation doctorale en informatique École doctorale IAEM Lorraine

Résolution de problèmes d’accessibilité

présentée et soutenue publiquement le 9 décembre 2003

Doctorat de l’université Henri Poincaré – Nancy 1

Laboratoire Lorrain de Recherche en Informatique et ses Applications — UMR 7503

Mots-clés: Protocole cryptographique, problème d’accessibilité, procédure de décision, complexité,

Keywords: Cryptographic protocol, reachability problem, decision procedure, complexity, sym-

« ...das ist ein zu weites Feld. »1

1 Le sujet est trop riche (traduction libre).

1 Analyse de protocoles cryptographiques 1

Méthodes dont la terminaison est assurée. . . . . . . . . . . . . 9

2.3 Fonctions à adressage dispersé . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3 Termes, classes d’équivalence et représentations 25

3.4.1.iii Normalisation pour l’opérateur ⊕({ }) . . . . . . . . . . . . . 36

4 Accessibilité dans le cas clos 47

5 Compilation de protocoles cryptographiques 69

5.3 Sémantique Opérationnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.5.4.i Exemple de compilation d’un protocole . . . . . . . . . . . . . 87

III Recherche d’attaques 97

6 Recherche efficace d’attaques 99

6.7 Complétude de L . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

7 Problèmes d’accessibilité non clos 121

7.4.3 Les signatures F⊕ , Fexp et Frsa sont régulières . . . . . . . . . . . . . . 126

8 Cas non-borné 141

8.5.3 Compilation des acteurs de AD : construction des règles d’Oracle . . . 154

9 Bilan et Perspectives 163

1.1 Messages échangés dans le protocole à clefs publiques de R. Needham et M. Schroeder 3

2.1 Chiffrement par blocs sans chaı̂nage . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.1 Relation entre termes opérations, termes valeurs et fonction de normalisation . . . 38

5.1 Protocole de R. Needham et M. Schroeder à clefs publiques (Needham-Schroeder

6.1 Algorithme de recherche d’attaque sur un protocole . . . . . . . . . . . . . . . . . . 114

7.1 Algorithme de recherche d’attaque sur un protocole . . . . . . . . . . . . . . . . . . 124

8.1 Algorithme de recherche d’attaque sur un protocole . . . . . . . . . . . . . . . . . . 145

Sécurisation des échanges

1.1 Protocoles cryptographiques

1.1.1 Quelques primitives cryptographiques et leur utilisation pour as-

La condition nécessaire de l’existence de protocoles cryptographiques est l’existence de primi-

Fg wgawg gvw gq fodlu

est la traduction chiffrée de :

Ce texte est en clair

Si ce code permet de tromper un adversaire n’ayant aucune connaissance en chiffrement, il ne peut

1.1.1.ii Algorithmes de chiffrement

Nous appelons algorithme de chiffrement une primitive cryptographique réversible. Le code

1.1.1.iii L’hypothèse de chiffrement parfait et au-delà

1.1.2 Communication par échange de messages

Nous expliquons cette spécification dans la suite de cette section.

1.1.3 Un acteur malhonnête, l’intrus

1.1.3.i Contrôle du réseau

1.1.3.ii Capacités de déduction

1.1.4 Propriétés de sécurité

1.1.4.i Confidentialité des données échangées

1.1.4.ii Identification de l’interlocuteur

1.2 Méthodes pour l’analyse de protocoles

1.2.1 Compilation de protocoles cryptographiques

1.2.2 Méthodes interactives

Application du prouveur Isabelle à la vérification de protocoles cryptographiques.

Algèbre de processus et équivalence observationnelle. Les méthodes reposant sur l’équivalence