Meca Crypto

Révisions - Mécanismes cryptographiques
DUVERGER Kévin
25 janvier 2024
Table des matières
1 Introduction : 2
1.1 Généralités sur le cours : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Un historique de la cryptographie : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 LFSR : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Chiffrements par blocs : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 Fonctions de hachage : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.6 Chiffrement à clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Annale d’une année précédente : 4

2.1 Exercice 1 : Questions générales : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Exercice 2 : Cryptographie à clé secrète : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Exercice 3 : Cryptographie à clé secrète : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Exercice 4 : RSA : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 Exercice 5 : cryptographie à clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6 Exercice 6 : avant la clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.7 Exercice 7 : authentification : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.7.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3 TD 1 - Attaques algébriques : 9
3.1 LFSR et attaques algébriques : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 Un exemple sur un LFSR simple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3 Exemple d’attaque sur un registre filtré : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.4 Généralisation de l’attaque : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.5 Rendre l’inversion de matrice plus rapide : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.6 Le concept d’immunité algébrique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.7 Application de ce concept à l’attaque algébrique sur le LFSR : . . . . . . . . . . . . . . . . . . . . . . 16
3.8 Attaque sur TOYOCRYPT : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4 Authentification : 17
4.1 Quelques propriétés des blocs de base en cryptographie asymétrique : . . . . . . . . . . . . . . . . . . . 17
4.2 Authentification symétrique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3 Authentification asymétrique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Un exemple sur le schéma d’authentification Fiat-Shamir (1986) : . . . . . . . . . . . . . . . . . . . . . 18
1
DUVERGER Kévin Révisions - Mécanismes cryptographiques Université de Limoges
5 Magic crypto : 20
5.1 Définition du problème et une première solution : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Rappels sur la notion de résidu quadratique et carrés : . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.3 Un exemple : le chiffrement de Rabin : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.4 Le protocole d’Ostrovsky : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.5 Analyse de la complexité du protocole précédent : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.6 Chiffrement homomorphe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6 Protocoles Zero-Knowledge : 23
6.1 Exercice 18 page 40 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.2 Création d’algorithmes de signature : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7 Courbes elliptiques : 25
7.1 Introduction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2 Définition de l’addition : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.3 Courbes elliptiques sur des entiers : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.4 Trouvons les points de quelques courbes : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.5 Quelques exemples d’additions : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8 Courbes elliptiques partie 2 - structure des courbes elliptiques : 30

8.1 Rappels sur ce qu’est un groupe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.2 Morphismes : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.3 Groupes cycliques, ordre d’un élément et Zn1 ⊕ Zn2 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4 Structure de groupe des courbes elliptiques : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
8.5 Les courbes elliptiques en crypto : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.6 Quelques courbes elliptiques connues : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.7 Meilleure attaque sur les courbes elliptiques : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.8 Quelques petits bouts de code en Python : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9 Les lattices (cours de Gaborit) : 35

9.1 Cryptosystème de Merkle-Hellman (1978) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.2 Les lattices (j’ai une partie plus détaillée plus bas) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.3 Le cryptosystème NTRU : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.4 Le problème LWE et le cryptosystème LWE (pas le temps d’expliquer mieux) : . . . . . . . . . . . . . 37
9.5 Kyber (encore une fois pas le temps de développer) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.6 Dans le NIST : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10 Dernière séance de l’année avec Gaborit : 38

10.1 Signature sur les réseau : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10.2 La cryptographie à seuil : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.3 Les pairings : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
11 Les lattices (fait par moi) : 41

11.1 Quelques rappels sur les matrices : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
11.2 Espaces vectoriels : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
11.3 Introduction aux lattices : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
11.4 Matrices uni-modulaires et dépendance de la lattice au déterminant de la base : . . . . . . . . . . . . . 44
11.5 Réduction de la base d’une lattice avec 2 vecteurs dans sa base : . . . . . . . . . . . . . . . . . . . . . 45
11.6 Le problème du décodage : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.7 Quelques problèmes difficiles sur les lattices : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
11.7.1 Réduction d’une base : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
11.7.2 Décodage : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
11.8 Le cryptosystème GGH basé sur les lattices : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.8.1 Ratio de Hadamard : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.8.2 Génération de clé : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.8.3 Chiffrement : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
11.8.4 Déchiffrement : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
11.9 Le cryptosystème NTRU : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
11.9.1 Les polynômes dans le cadre de NTRU : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
11.9.2 Le cryptosystème : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
11.9.3 Un exemple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
11.9.4 Avec des lattices : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
11.10Quelques programmes : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11.10.1 Divers : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2 / 114 Année 2023 - 2024

11.10.2 GGH : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
11.10.3 NTRU : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
12 L’interpolation lagrangienne : 63
12.1 Le but : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.2 Cas particuliers : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.3 Une base de polynômes : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.4 Quelques exemples : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
13 Annale du 24 novembre 2021 : 65

13.1 Question de cours : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
13.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
13.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
13.2 Exercice 1 - Autour de RSA : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.3 Exercice 2 - LFSR : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.3.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.4 Exercice 3 - Un échange de clé léger... trop léger : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.5 Exercice 4 - Courbes elliptiques : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.5.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.6 Exercice 5 - Authentification : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
13.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
13.6.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

14.1 Questions de cours : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
14.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
14.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
14.2 Exercice 1 - Cryptographie à clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.3 Exercice 2 - Cryptographie à clé secrète : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.3.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.4 Exercice 3 - Calcul de la signature RSA avec le théorème des restes chinois : . . . . . . . . . . . . . . . 72
14.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14.5 Exercice 4 - Chiffrement : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
14.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
14.5.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
14.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
14.6.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
14.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
14.7.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.8 Exercice 7 - Changement de clé RSA : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.8.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.8.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.9 Exercice 8 - Pile ou face au téléphone : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
14.9.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
14.9.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3 / 114 Année 2023 - 2024


15.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
15.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
15.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
15.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
15.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
15.3.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
15.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
15.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
15.5 Exercice 4 - Signature El-Gamal : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.5.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.6 Exercice 5 - LFSR : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.6.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
15.7 Exercice 6 - Double encryption : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
15.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
15.7.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
15.8 Exercice 7 - Incremental hashing : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
15.8.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
15.8.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

16.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
16.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
16.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
16.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
16.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
16.3.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
16.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
16.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
16.5 Exercice 4 - avant la clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
16.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
16.5.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
16.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16.6.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16.7 Exercice 5’ - Autre authentification : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16.7.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16.8 Exercice 6 - Cryptographie basée sur l’identité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
16.8.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
16.8.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
16.9 Exercice 7 - Changement de clé RSA : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
16.9.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
16.9.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
17 Annale du 17 février 2020 : 93

17.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
17.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
17.2 Exercice 1 : Authentification : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
17.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
17.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
17.3 Exercice 2 : Partage de secret : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
4 / 114 Année 2023 - 2024

17.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
17.3.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
17.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
17.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
17.5 Exercice 4 : Fonction de hachage et signature : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
17.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
17.5.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
17.6 Exercice 5 : Un échange de clé léger, trop léger : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
17.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
17.6.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
17.7 Exercice 6 : authentification : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
17.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
17.7.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
17.8 Exercice 7 : Chiffrement : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
17.8.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
17.8.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

18.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
18.1.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
18.2 Exercice 1 - Cryptographie à clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
18.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
18.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
18.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
18.3.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
18.4 Exercice 3 - Calcul de la signature RSA avec le théorème des restes chinois : . . . . . . . . . . . . . . . 101
18.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
18.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
18.5 Exercice 4 : Chiffrement : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
18.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
18.5.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
18.6 Exercice 5 : Le schéma de signature de Lamport à usage unique : . . . . . . . . . . . . . . . . . . . . . 102
18.6.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
18.6.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
18.7 Exercice 6 : Cryptographie basée sur l’identité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
18.7.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
18.7.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

19.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
19.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
19.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
19.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
19.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
19.3.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
19.4.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
19.4.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
19.5 Exercice 4 - avant la clé publique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
19.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
19.5.2 Correction : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5 / 114 Année 2023 - 2024


20.1.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
20.1.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
20.2.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
20.2.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
20.3 Exercice 2 : Signatures : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
20.3.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
20.3.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
20.4.1 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
20.5.1 Sujet : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
20.5.2 Réponses : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
6 / 114 Année 2023 - 2024

1 Introduction :
1.1 Généralités sur le cours :
Il y aura un partiel vers fin novembre et un examen au début du mois de dévrier et également une note de projet (ce
dernier se faisant à au moins 2 personnes). Le projet se présentera sous une forme de liste de sujets : chaque sujets
donnera lieu à 1 / 2 papiers de recherche à lire et finalement une présentation sur ces derniers pour montrer que l’on
a compris, cette présentation se ferait dans le courant du mois de janvier.
Les CM du mercredi démarreront à 15 heures 30 pile et le second TD de la journée se finira au plus tard à 18 heures
30. Le cours sera mis sur internet (et apparemment c’est le même que l’année dernière ou sinon on peut le choper sur
discord), et pour le reste il n’y aura que des supports écrits.
1.2 Un historique de la cryptographie :

Nous avons eu la stéganographie au XIIe siècle (avec le tatouage au crane), ensuite la scytale grecque au Ve siècle
(définit la notion de permutation) et pour finir le chiffrement César au Ier siècle (définit la notion de substitution).
Si on prend 1 million d’ordinateurs en parallèle pendant un an : 220 × 365 × 24 × 3600 × 4 × 109 × 64 = 285 qui est le
paramètre de sécurité minimal aujourd’hui. La loi de Moore fait doubler la vitesse des puces (car elles se miniaturisent)
tous les 18 mois.
Pour être sûrs actuellement nous souhaitons 110 bits de sécurité (au lieu de 85) et en pratique c’est plus 128 bits qui
sont utilisés.
Au XVIe siècle, un mélange de l’approche par substitution et par permutation voit le jour : un peu plus tard par
exemple nous pouvons retrouver ADFGVX puis nous assistons à la mécanisation du chiffrement avec la machine
Enigma.
En 1917, un chiffrement très important apparaı̂t : le chiffrement de Vernam / OneTimePad / Masque jetable : il
constitue la plus grande sécurité possible du moment que la clé utilisée pour chiffrer est aléatoire : à chaque chiffré il
est possible d’associer n’importe quel clair.
Sur le chiffrement par substitution, une attaque par corréaltion est tout à fait possible (elle se base simplement sur
l’étude de la fréquence d’apparition des différentes lettres) et elle marche de mieux en mieux plus le texte chiffré est long.
1.3 LFSR :
La difficulté derrière le chiffrement de Vernam repose sur l’aléatoire de la clé : pour avoir ce flot de clé indistinguable
de l’aléatoire, la notion de LFSR a été créée. Un LFSR est tout simplement défini par un certain nombre de bits,
appellons ce dernier k, une seed et la chaine qui sera générée après (appelés si ) et pour finir un ensemble de connexions
Pk
que nous appellerons ai . La relation sur lequel ce LFSR va se baser sera si+1 = j=1 aj × si+1−j . Le polynôme de
rétroaction sera tout simplement définit par 1 + a1 × x + ... + ak × xk .
Ces derniers datent des années 1960 et ont beaucoup d’avantages : une très bonne propriété statistique, rapides et
”pas chers”. Notez qu’ils permettent de créer des suites de au plus 2k − 1 éléments (toutes les suites binaires de k bits
sauf 0).
Les attaques linéaires peuvent permettre de tout retrouver avec une attaque à clair connu, c’est pourquoi des variations
ont été nécessaires : les registres combinés, ... : nous les verrons dans la suite.
1.4 Chiffrements par blocs :

Les 2 exemples les plus connus sont DES et AES. Le prof a présenté une attaque par distingueur sur ces derniers que
je rajouterais plus tard. Cette attaque est très bien en théorique mais est plus complexe à réaliser en pratique.
Le DES a été standardisé en 1975 avec une taille de clés de 55 bits, dans les années 80 le triple DES a été proposé avec
une sécurité de 110 bits en théorie mais qui se révèlera plutôt être 80 bits en pratique (si vous ne voyez pas pourquoi
on peut pas faire de double DES vous pouvez reprendre la fiche de l’année précédente avec l’attaque par meet in the
middle).
En 1991, la cryptanalyse différentielle (Biham, Shamir) apparaı̂t sur FEAL, GOST et DES.
En 1993, nous avons une cryptanalyse linéaire du DES qui l’a fait diminuer à 41 bits de sécurité.
Et pour finir AES (Advanced Encryption Standard) est issu d’un concours organisé par le NIST, au début il y avait 12
candidats, il n’en restait plus que 5 pour le second tour (Marrs (IBM), Twofish, RC6, RijnDael et Sepert), RijnDael
après quelques modifications est devenu l’AES. L’AES de base se fait sur 128 bits de clés mais il est également possible
de lui donner des clés de 256 bits, ce dernier a été standardisé en 2001.
1.5 Fonctions de hachage :

Ces dernières prendront en entrée quelque chose de taille arbitraire et donneront en sortie un haché de taille fixe (par
exemple 128 bits pour MD5). Elles nécessitent donc une fonction de compression : le message sera divisé en blocs que
nous ferons passer dans la fonction f ce qui permettra de combiner les hachés.
7 / 114 Année 2023 - 2024

Les schémas utilisés à la base étaient : MD4 (128 bits, Message Direct 4) puis MD5 (128 bits aussi) ont été créées par
Rivest. Sur ces dernières, nous pouvons toujours faire une attaque par paradoxe des anniversaires qui donnera lieu à
une racine carrée : pour avoir une sécurité de 64 bits il faut 128 bits de haché.
En 1993, MD4 a été attaqué et en 1991 le NIST a introduit SHA (Secure Hash Algorithm) : SHA0 a montré une faille
de sécurité c’est pourquoi SHA1 a très vite vu le jour. En 1993, Antoine Joux et Chabaut ont proposé une attaque
en cascade qui ont amené à 2004 avec des chinois (Wang) qui ont proposé une attaque sur SHA1 en 271 . Une attaque
concrète a vu le jour sur ce dernier en 2017.
Ensuite, nous avons une nouvelle fois eu une compétition du NIST (en 2008) pour créer un nouveau standard : SHA-3
a donc été créé à partir de Keycchak qui est en ”structure éponge”.
1.6 Chiffrement à clé publique :

Le chiffrement à clé publique a vraiment commencé à partir des années 1970 : la clé publique peut être utilisée par
n’importe qui pour déchiffrer et la clé privée / secrète sera utilisée par tous ceux qui veulent déchiffrer.
En 1976, Diffie-Hellman invente le célèbre échange de clés :
En 1977, RSA est inventé et basé sur la factorisation, ce dernier permet de faire du chiffrement et de la signature.
En 1983, le chiffrement El Gamal voit le jour et ce dernier se base sur le problème du logarithme discret.
En 1984, ce problème du logarithme discret est généralisé sur les courbes elliptiques (par Koblitz et Miller).
Après nous avons les pairing (”accouplements”) : qui sont tout simplement des courbes elliptiques avec des propriétés
particulières (en particulier homomorphes) : c’est comme si nous avions un degré de liberté supplémentaire dans les
données (on peut faire plein de choses en plus) : c’est un chiffrement avancé, on peut faire du chiffrement basé sur
l’identité, des signatures de groupe, et plein de variations de ce type de chiffrement que l’on ne pouvait pas faire avant.
Les premières applications ont vu le jour en 2001 pour faire des attaques sur les courbes elliptiques.
Une petite ombre sur tout cela est l’apparition du chiffrement quantique : Peter Schor en 1994 a proposé un algorithme
quantique qui casse la factorisation en temps polynomial à condition d’avoir un ordinateur quantique suffisamment
puissant. L’idée générale est que les qbits peuvent être dans plusieurs états à la fois : si nous avons n qbits, il nous est
possible de tout parallélise et donc faire 2n opérations en même temps avec seulement n qbits : nous pouvons donc
gagner un facteur exponentiel.
ATTENTION : ça ne marche pas tout le temps, c’est ce qu’on peut gagner au mieux, en pratique, on les fait tous
travailler ensemble pour récupérer un résultat particulier et on peut y arriver uniquement dans certains cas particu-
liers : Schor pour calculer l’ordre d’un élément d’un groupe en temps polynomial (lié à la factorisation et aux courbes
elliptiques donc ça dégage), le second algorithme de Grover est beaucoup plus général et s’applique sur beaucoup plus
de situations (il permet de regarder plus vite si un élément
√ appartient à une liste) et il permet d’avoir un gain en
racine carrée (donc la complexité passe de O(n) à O( n)).
Actuellement on est à 100 qbits et on prévoit que l’on soit à plusieurs dizaines de milliers de qbits d’ici la fin de la
décennie. En 2015, la NSA a sorti un communiqué : vu l’anvacée des ordis quantiques, il faut passer au post quantique :
ce sont juste des algos qui sont résistants à l’ordinateur quantique. A priori un problème NP-dur en classique reste
NP-dur en quantique : il n’y aura donc pas d’attaque sur les problèmes les plus durs (codes, lattices, isogénies, ...).
Le NIST a organisé une nouvelle compétition en 2017 pour définir un standard qui serait post quantique : des schémas
de réseaux euclidiens, codes correcteurs, résolution de systèmes multivariés, signatures sur les fonctions de hachage
ont été proposés. Au premier tour il y avait 25 réseaux, 20 codes, 15 multivariés et 5 hash et quelques divers. Après
ce premier tour ils ont gardé 16 chiffrements et après un second tour plus que 9 (3 réseaux (NTRU / Kyber et 2
autres), 5 codes, 1 isogénie). Les isogénies sont des courbes elliptiques en beaucoup plus pourries. Ils ont également
fait un groupe de candidats alternatifs (3 codes : McEliece, Bike et HQC). Kyber a été standardisé, au 4ème tour il
faut choisir entre McEliece, Bike et HQC. Un nouvelle appel pour les signatures a été lancé.
8 / 114 Année 2023 - 2024

2 Annale d’une année précédente :

2.1 Exercice 1 : Questions générales :
2.1.1 Sujet :
Question a : Quels sont les avantages du chiffrement à clé secrète par rapport au chiffrement à clé publique, donner
des exemples d’algorithmes.
Question b : Comment doit-on procéder pour échanger de façon optimale en temps avec quelqu’un une grande
taille de données chiffrées, sans avoir de clé secrète partagée au préalable ?
Question c : Quelles sont les grandes propriétés qu’on attend d’une fonction de hachage ?
Question d : Quels sont les paramètres du DES et sur quoi repose sa sécurité ? Est-ce que le DES est un schéma de
chiffrement sûr ?
2.1.2 Correction :
Question a : L’avantage est la rapidité du chiffrement à clé secrète comparé au chiffrement à clé publique, on gagne
environ un facteur 1000 en temps avec du chiffrement à clé secrète. Quelques exemples d’algorithmes à clé secrète sont
AES et DES, pour les algorithmes à clé publique nous avons par exemple RSA, El-Gamal, Rabin, ...
Question b : Nous pouvons tout d’abord remarquer qu’utiliser du chiffrement à clé publique pour toutes ces données
va être extrêmement long. La méthode à utiliser consiste à d’abord réaliser un échange de clé (en utilisant de la cryp-
tographie asymétrique) puis échanger les données en chiffrement à clé secrète grâce à la clé échangée précédemment.
Question c : Il y a 2 points importants qu’une fonction de hachage doit respecter : elle doit être résistante aux
collisions (c’est à dire qu’il est extrêmement difficile de trouver 2 entrées tels que le hash de ces dernières est le même)
et compresser les données qui lui sont envoyées.
Question d : Pour DES, ce sont les S-Box qui permettent la sécurité car c’est la seule composante non linéaire
de ce chiffrement. Ce n’est plus un algorithme de chiffrement sûr car sa sécurité repose sur du 256 ce qui est bien en
dessous des capacités de calcul actuelles et de plus il a déjà été cassé : les premières attaques sur DES ont eu lieu en
1998 et cela s’est fait sur une puce spéciale dédiée à cela, elle a cassé DES en 39 jours. Actuellement sur nos ordinateurs
personnels, une journée permet de le casser.
2.2 Exercice 2 : Cryptographie à clé secrète :

2.2.1 Sujet :
On suppose qu’Alice et Bob partagent une clé aléatoire K dans {0, 1, 2}n et que Alice veut envoyer un message
M de {0, 1, 2}n . On suppose tout d’abord qu’elle procède en convertissant K et M en ensembles de deux bits
(0 = 00, 1 = 01, 2 = 10) puis qu’elle fait un XOR entre les deux représentations binaires (chiffrement de Vernam).
Question a : On suppose tout d’abord que Alice et Bob ont en commun la clé K = 102201, on suppose qu’Alice veut
envoyer le message M = 222222 chiffré par la clé K. Que vaut le chiffré de M par K ?
Question b : On suppose maintenant que Eve intercepte un chiffré C = 011101 (mais ne connait pas la clé secrète
utilisée), est-ce que le clair peut valoir M = 102 ?
Question c : Quels sont tous les clairs possibles qui peuvent donner le chiffré C = 011101 ?
Question d : A partir des questions précédentes, montrer qu’un tel schéma n’est pas bon, en ce sens qu’il y a
de l’information qui fuit et que ce schéma n’est pas parfaitement sûr. On pourra montrer que tous les chiffrés c1 , c2
(où c1 est un bit) n’ont pas la même probabilités d’exister.
Question e : Proposer un autre schéma à base de modulo qui serait parfaitement sûr.
2.2.2 Correction :
Question a : nous avons K = 102201 et M = 222222
Commençons par mettre K et M en binaire :
K : 01 00 10 10 00 01
M : 10 10 10 10 10 10
9 / 114 Année 2023 - 2024

Nous pouvons maintenant faire le xor entre la clé et le message :

C : 11 10 00 00 10 11
Comme vous pouvez le voir nous avons des 11 dans le chiffré qui ne pourront pas être convertirs en éléments de {0, 1, 2}
mais cela n’est pas grave car rien ne nous dit dans le sujet que le chiffré doit être re-converti dans la notation originale.
Question b : mettons nos 2 paramètres sur 2 lignes pour voir comment faire :
C : 01 11 01
M : 01 00 10
Comme vous pouvez le voir, il est impossible que le clair soit la valeur donnée car il faudrait que le second chiffre soit
11 = 3 pour que le XOR fonctionne et donne bien C ce qui est impossible.
Question c : pour ce faire, nous allons considérer chaque caractère du chiffré :

C[0] = 01 : 2 possibilités (M [0], K[0]) = (00, 01) et (M [0], K[0]) = (01, 00)
Comme vous pouvez le voir, nous avons donc 2 × 2 × 2 = 8 possibilités de couples (M, K) qui pourraient donner ce
chiffré :
M = 00 10 00, K = 01 01 01
M = 01 10 00, K = 00 01 01
M = 00 01 00, K = 01 10 01
M = 01 01 00, K = 00 10 01
M = 00 10 01, K = 01 01 00
M = 01 10 01, K = 00 01 00
M = 00 01 01, K = 01 10 00
M = 01 01 01, K = 00 10 00
Question d : nous allons tout simplement faire comme le prof le dit et lister pour chaque caractère toutes les
possibilités de message et clé qui donnent un certain chiffré :
Pour avoir 00 dans le chiffré : 3 couples (00, 00), (01, 01), (10, 10)
Pour avoir 01 dans le chiffré : 2 couples (01, 00), (00, 01)
Vous pouvez donc voir qu’il est plus probable d’obtenir 00 ce qui constitue donc une fuite d’informations.
Question e : un schéma qui est parfaitement sûr consiste tout simplement faire M +K (mod 3) pour chaque caractère
du messsage et de la clé.
Si nous reprenons le premier exemple :
K = 102201
M = 222222
Nous avons finalement comme chiffré C = 021120 (le premier 0 est obtenu en faisant 1 + 2 modulo 3).
Re-listons tous les couples possibles :
Pour avoir 0 dans le chiffré : 3 couples (0, 0), (1, 2), (2, 1) marchent.
Nous venons donc de confirmer qu’il s’agit bien d’un schéma de chiffrement sécurisé.
2.3 Exercice 3 : Cryptographie à clé secrète :

2.3.1 Sujet :
On intercepte un message chiffré avec un système de chiffrement à flot produit par une suite chiffrante récurrente de
type LFSR. Le message binaire intercepté est 10001110010101. On connaı̂t d’autre part 6 bits du clair (les bits 5 à
10) qui sont respectivement 101010. Nous admettrons que la complexité linéaire de la suite chiffrante du LFSR est au
plus 3 (polynome de rétroaction de degré 3). Déchiffrer le message en entier.
2.3.2 Correction :
Il faut tout d’abord se souvenir que pour un LFSR, nous avons C = M ⊕ K. K est tout simplement la suite de bits s
générée par le LFSR. Nous avons donc :
c = 10001110010101
m = ????101010????
Si nous faisons un XOR entre ces 2 valeurs, nous obtenons :
s = ????010011????
10 / 114 Année 2023 - 2024

L’étape suivante va consister à trouver les ai qui vont permettre le calcul de tous les termes de la suite des si . Il
nous est dit que la complexité linéaire est d’au plus 3, commençons donc par 3 valeurs de ai .
Nous allons nous baser sur les bits 5 à 7 : 010.
Grâce à la relation du LFSR nous pouvons créer le système suivant :
Bit 8 : a2 × s5 + a1 × s6 + a0 × s7 = s8 ⇔ a2 × 0 + a1 × 1 + a0 × 0 = 0
Bit 9 : a2 × s6 + a1 × s7 + a0 × s8 = s9 ⇔ a2 × 0 + a1 × 0 + a0 × 1 = 1
Bit 10 : a2 × s7 + a1 × s8 + a0 × s9 = s10 ⇔ a2 × 1 + a1 × 0 + a0 × 0 = 1
Nous pouvons déduire de ces équations que a2 = 1, a1 = 0, a0 = 1.
Nous pouvons maintenant passer au calcul des bits restants de s :

s4 : 1 × s4 + 0 × s5 + 1 × s6 = 0 ⇔ s4 = 1
s3 : 1 × s3 + 0 × s4 + 1 × s5 = 1 ⇔ s3 = 1
s2 : 1 × s2 + 0 × s3 + 1 × s4 = 0 ⇔ s2 = 1
s1 : 1 × s1 + 0 × s2 + 1 × s3 = 1 ⇔ s1 = 0
Il faut également calculer ceux qui viennent après :
s11 = 1 × s8 + 0 × s9 + 1 × s10 = 1
s12 = 1 × s9 + 0 × s10 + 1 × s11 = 0
s13 = 1 × s10 + 0 × s11 + 1 × s12 = 1
s14 = 1 × s11 + 0 × s12 + 1 × s13 = 0
Finalement, nous avons trouvé la valeur complète de s : 01110100111010, vous pouvez également remarquer que nous
avons une période de 7 = 23 − 1 ce qui conforte notre idée qu’il n’y a pas d’erreur dans ce raisonnement.
Pour terminer, il reste à calculer le message en clair :

c = 10001110010101
s = 01110100111010
m = 11111010101111 (il suffit de faire le xor entre c et s).
2.4 Exercice 4 : RSA :

2.4.1 Sujet :
Soit le cryptosystème RSA ayant pour paramètres (n, e) = (21, 5).
Question a : calculer φ(n)
Question b : sachant que 21 = 3 × 7 et que e = 5, montrer que l’exposant secret d vaut 5.
Question c : supposons qu’on veuille envoyer la lettre ’D’ que l’on écrira 4 sous forme numérique. Quel est alors
le chiffré de ’D’ sous forme numérique pour ces paramètres ?
Question d : déchiffrer la valeur numérique obtenue pour le chiffré de ’D’ et montrer qu’on retrouve la valeur
numérique associée à ’D’.
2.4.2 Correction :
Question a : φ(21) = φ(7) × φ(3) = 6 × 2 = 12
Question b : d = e−1 (mod φ(n)) = 5−1 (mod 12) = 5 (car 5 × 5 = 25 = 24 + 1).
Question c : c = me (mod n) = 45 (mod 21) : 40 = 1 (mod 21), 41 = 4 (mod 21), 42 = 16 (mod 21), 43 = 1
(mod 21), nous pouvons donc voir que l’ordre multiplicatif de 4 est 3 et donc que 45 = 43+2 = 43 × 42 = 1 × 16 = 16
(mod 21), le chiffré est donc 16.
Question d : d = cd (mod n) = 165 (mod 21) = 410 (mod 21) = 43×3+1 (mod 21) = 4 (mod 21) (43×3 = 1
(mod 21) car 3 est l’ordre multiplicatif de 4).
2.5 Exercice 5 : cryptographie à clé publique :

2.5.1 Sujet :
Question a : on suppose que A et B utilisent le même module RSA n avec deux clés publiques eA et eB premières
entre elles. On suppose que C envoie le même message chiffré meA et meB à A et B. Montrer que E qui écoute les
communications peut retrouver facilement le message m.
Question b : afin d’améliorer la sécurité des messages Bob choisit deux exposants e1 et e2 et demande à Alice
11 / 114 Année 2023 - 2024

de chiffrer d’abord son message par e1 , pour obtenir c1 = me1 puis de re-chiffrer par e2 pour obtenir c2 = ce12 . Alice
va ensuite envoyer c2 . Est-ce que ce double chiffrement améliore la sécurité ? Si oui pourquoi et sinon pourquoi ?
Question c : on suppose qu’on chiffre un message m en calculant m3 (mod 101). Comment peut-on déchiffrer ?
C’est à dire trouver d tel que cd = m (mod 101), on remarquera que 101 est premier.
Question d : les exposants e = 1 et e = 2 ne doivent pas être utilisés comme exposants publics pour RSA, pourquoi ?
Question e : on suppose qu’on sait que deux personnes utilisent deux modules RSA n1 et n2 qui ne sont pas
premiers entre eux. Expliquer alors comment on peut casser les deux systèmes.
2.5.2 Correction :
Question a : il nous faut déjà voir ce à quoi a accès l’adversaire : il connaı̂t n, eA , eB ainsi que les 2 messages qu’il voit
passer qui sont meA et meB . Il suffit donc à l’adversaire de trouver u et v tels que eA × u + eB × v = 1 (cela ne marche
que parce que pgcd(eA , eB ) = 1 vu qu’ils sont premiers entre eux). Une fois cela fait, il lui suffit tout simplement de
calculer (meA )u × (meB )v = meA ×u+eB ×v = m1 = m.
Question b : non, cela est identique à un chiffrement RSA ”normal” avec la clé publique e1 × e2 nous ne gagnons
donc pas en sécurité.
Question c : il nous faut trouver 3−1 (mod 100) ce qui vaut 67 car 3 × 67 = 201. Pour déchiffrer, il suffira donc de
calculer c67 (mod 101).
Question d : voici les raisons qui font que ces 2 exposants ne peuvent pas être utilisés :
e = 1 : à ne pas utiliser car le message n’est pas chiffré !
e = 2 : c’est également tout simple, il faut pouvoir trouver d = e−1 (mod φ(n)), ce dernier n’existe que si e et
φ(n) sont premiers entre eux, or φ(n) = (p − 1) × (q − 1) qui est un produit de nombres pairs et est donc pair :
du coup e et φ(n) ne sont pas premiers entre eux et on ne pourra pas trouver d.
Notez qu’il existe tout de même un cryptosystème qui permet d’utiliser e = 2 : le crytposystème de Rabin. Il se base
sur le résidu quadratique et à cause de cela chaque chiffré peut donner lieu à plusieurs messages ce qui peut être
compliqué à gérer.
Question e : vu que les 2 modules ne sont pas premiers entre eux, ils ont un facteur premier en commun, il suffit
donc de calculer pgcd(n1 , n2 ) = p et puis retrouver q1 = n1 /p et q2 = n2 /p.
2.6 Exercice 6 : avant la clé publique :

2.6.1 Sujet :
James H. Ellis (1924 - 1997) était un ingénieur et un mathématicien travaillant au GCHD (Government Communication
HeadQuarters), les grandes oreilles britanniques. Il raconte dans une note publiée juste après son décès (The Story of
Non-Secret Encryption), comment il a eu dès 1970 l’idée du principe de la communication à clés publiques et comment
deux de ses collèges, C. Cocks et M. Williamson, l’ont mise en oeuvre en découvrant les mécanismes du cryptage RSA
et du schéma de Diffie-Hellman plusieurs années avant leurs auteurs.
Il décrit en particulier un schéma de communication où S (l’émetteur) désire faire passer un message M à R (le
destinataire) que nous allons décrire en image :
L’idée derrière ce protocole est que le message ne passe jamais en clair (bien évidemment) et également que seul S
peut enlever le x qu’il a rajouté et seul R peut enlever le y qu’il a rajouté.
12 / 114 Année 2023 - 2024

Question a : pourquoi a-t-on M zx = M (mod P ) ? Soyez complet dans vos explications !
Question b : que se passe-t-il précisément du point de vue mathématique lorsque S élève M xy à la puissance z ?
Question c : quelles sont précisément les opérations mises en oeuvre par R pour enlever y et pourquoi lui permettent-
elels de retrouver M ?
Question d : expliquez en vous servant par exemple du théorème de Bezout, pourquoi x et y doivent être pre-
miers avec P − 1.
Question e : en définitive, à quel schéma à clés publiques vu en cours le procédé décrit par J. H ; Ellis se ramène-t-il ?
Justifiez votre réponse ?
Question f : S et R ont choisir de travailler avec P = 101. Les valeurs utilisées par S sont 3 et 67, celles utilisées par
R sont 13 et 77. Au total, combien de multiplications seront effectuées au cours de l’échange, si les exponentiations se
font par la méthode rapide ?
2.6.2 Correction :
Question a : M zx (mod P ) = M k×(P −1)+1 (mod P ) = (M P −1 )k × M (mod P ) = 1 × M (mod P ) = M (mod P ).
Question b : (M xy )z (mod P ) = M xyz (mod P ) = (M xz )y (mod P ) = M y (mod P )
Question c : R commence par trouver w tel que wy = 1 (mod P − 1) puis calcule M yw = M (mod P ).
Question d : supposons que x n’est pas premier avec P −1, la relation de Bézout nous dit qu’il sera possible de trouver
z et a tels que xz + a × (P − 1) = pgcd(x, P − 1), nous voyons donc qu’il sera impossible de trouver un inverse modu-
laire de x car ce dernier n’est pas premier avec P −1 : pgcd(x, P −1) ̸= 1. Le même raisonnement peut être appliqué à y.
Question e : ce schéma est très similaire à l’échange de clé diffie-hellman car les 2 parties génèrent une valeur
aléatoire, font une exponentiation modulaire puis arrivnet à dériver le même message en faisant des opérations sur les
exposants.
Question f : dans une exponentiation rapide, nous aurons 1 multiplication si le bit est à 0 et 2 multiplications
si le bit est à 1. Nous allons donc écrire les différents nombres en binaire et calculer le nombre de multiplications :
M x = M 3 : 3 = 11, 2 multiplications (on retire le premier 1)
M xy = (M x )13 : 13 = 1101, 5 multiplications.
M xyz = (M xy )67 : 67 = 1000011, 8 multiplications.
M wy = (M y )77 : 77 = 1001101, 9 multiplications.
2.7 Exercice 7 : authentification :

2.7.1 Sujet :
Alice et Bob partagent un secret k et ont décidé de l’utiliser dans le protocole suivant qui permet à Alice d’authentifier
Bob :
1. Alice choisit une suite de bits aléatoire r et l’envoie en tant que défi à Bob.
2. Bob répond en renvoyant r ⊕ k
L’analyse de Bob et Alice du protocole est celle-ci : le protocole permet d’obtenir l’authentification puisque Alice
peut vérifier que l’envoyeur du message 2. connaı̂t le secret partagé k. Il est aussi sécurisé car seul des suites de bits
aléatoires sont envoyées sur le canal de communication.
Question a : comment est-ce qu’Alice vérifie que l’envoyeur du message 2. connaı̂t k ?
Question b : êtes-vous d’accord avec Bob et Alice sur la sécurité du protocole ? Justifiez ?
2.7.2 Correction :
Question a : soit c = r ⊕ k, Alice va tout simplement calculer c ⊕ k et voir si c’est égal à r : si oui elle sait que c’est
bien Bob.
Question b : absolument pas, un attaquant qui voit passer le premier message contenant seulement r et le se-
cond message contenant r ⊕ k peut très bien calculer r ⊕ (r ⊕ k) = k et donc obtenir la clé secrète (ce qui est un peu
con).
13 / 114 Année 2023 - 2024

3 TD 1 - Attaques algébriques :
3.1 LFSR et attaques algébriques :
Le problème avec les LFSR ”normaux” est qu’ils sont linéaires : c’est cette propriété de linéarité qui rend l’attaque
par texte clair connu possible. Il existe 2 solutions :
Les registres filtrés où un LFSR ”normal” est utilisé mais toutes ses k sorties précédentes sont sauvegardées et
un sous-ensemble de ces sorties sont envoyées à une fonction booléenne non-linaire f .
Les registres combinés où k LFSR sont utilisés et leurs sorties sont envoyées dans une fonction booléenne f
encore une fois non-linéaire pour casser la linéarité.
Voici une première image vous montrant un LFSR ”conventionnel” avec un polynôme de rétroaction de degré 10 :
Et voici une seconde image pour montrer le fonctionnement d’un registre filtré :
Et une autre image pour voir à quoi ressemblerait un registre combiné :
Pour ce qui est des attaques algébriques, elles se divisent en 2 étapes :

La première partie consiste à réaliser la modélisation : nous allons écrire un système d’équations qui relient les
inconnues au chiffré. Une étape importante consiste à cerner ce qui est connu et ce qui n’est pas connu : d’après
le principe de Kerckhoffs la sécurité d’un protocole doit repose sur le secret de la clé et non pas de l’algorithme :
pour un LSFR nous pouvons supposer que nous connaissons les ai , en revanche la seed elle restera secrète.
La seconde étape consiste tout simplement à résoudre le système obtenu lors de la modélisation.
14 / 114 Année 2023 - 2024

3.2 Un exemple sur un LFSR simple :

Commençons par la partie modélisation : nous avons un LFSR de longueur k dont nous connaı̂trons la suite des ai .
Les différents bits seront les si avec s1 jusqu’à sk la graine. La seule chose que nous ne connaissons pas est la graine,
notre objectif sera donc de la retrouver grâce à un système. Une première idée de système pourraı̂t être la suivante :


 sk+1 = ak × s1 + ak−1 × s2 + ... + a2 × sk−1 + a1 × sk

k+2 = ak × s2 + ak−1 × s3 + ... + a2 × sk + a1 × sk+1
s


 ...
sk+k = ak × sk + ak−1 × sk+1 + ... + a2 × sk+k−2 + a1 × sk+k−1

Notez que ce dernier peut être remis sous la forme suivante :

     
sk+1 s1 s2 · · · sk−1 sk ak
 sk+2   s2
   s 3 ··· sk sk+1  ak−1 
 
 ..   .. . .. ..
 . = . .. . .. ×  .. 
  
   . .   . 
sk+k−1  sk−1 sk · · · s2k−3 s2k−2   a2 
sk+k sk sk+1 · · · s2k−2 s2k−1 a1
Mais vous pouvez remarquer que ce système ne nous permet pas de retrouver la graine, il peut à la limite permettre
de trouver les k bits après la graine ou encore de retrouver les k valeurs des ai (c’est même ce système qui nous justifie
qu’il faut au moins 2k bits de s pour pouvoir retrouver les ai sinon il nous manquerait des équations).
Ce que nous voulons trouver c’est une relation de la forme suivante :

   
sk+1 s1
 ...  = A ×  ... 
sk+k sk
De cette façon, si nous arrivons à trouver A, il nous suffira de l’inverser et de multiplier l’équation par ce résultat pour
trouver la graine. Notez de plus que la matrice donnée sera constituée des ai que nous connaissons également.
Mais trouver la matrice A de cette façon risque d’être très dur, voire impossible, une manière plus simple de la trouver
consiste à chercher :    
s2 s1
 ...  = A ×  ... 
sk+1 sk
Cette matrice est très simple à trouver, la voici :
  0 1 0 0 ··· 0 0 0 0
  
s2 s1
 s3   0 0 1 0 ··· 0 0 0 0   s2 
  . .. .. .. .. .. .. .. ..  ×  
 ...  = 
   .
. . . . . . . . .
 ... 
 
 sk     
sk−1 
0 0 0 0 ··· 0 0 0 1
sk+1 ak ak−1 ak−2 ak−3 ··· a4 a3 a2 a1 sk
Une fois que nous l’avons trouvée, nous pouvons tout simplement dire que :
   
sk+1 s1
 ...  = Ak ×  ... 
sk+k sk
Notez également pour finir que cette représentation matricielle n’est possible que parce que le LFSR ”standard” est
une primitive linéaire. Il est aussi important de voir que le calcul de Ak devra se faire modulo 2.
Finalement, pour retrouver la graine il nous suffira de calculer l’inverse de cette matrice :
   
s1 sk+1
k −1
 ...  = (A ) ×  ... 
sk sk+k
15 / 114 Année 2023 - 2024

3.3 Exemple d’attaque sur un registre filtré :

Faisons un exemple avec le registre filtré suivant :
Commençons par quelques notations : X0 , ..., X5 sera la graine (l’initialisation) donnée au LFSR, les Xi suivants seront
obtenus en passant à l’état suivant du LFSR. Le bit de sortie sera noté zi . Nous définirons également k = 4 dans
notre cas qui indiquera le nombre d’entrées de la fonction booléenne. Pour finir df = 2 sera le degré de notre fonction
booléenne (le degré de la fonction est tout simplement le degré du monome de plus haut degré).
Notre but sera tout simplement de trouver une relation entre les Xi initiaux et la sortie z.
Nous admettrons la connaissance d’autant de bits de la sortie z que nécessaire et notre but sera de retrouver l’initia-
lisation.
Tout d’abord, commençons par la relation nous permettant de trouver l’évolution du LFSR ”conventionnel” :
     
X1 0 1 0 0 0 0 X0
X2  0 0 1 0 0 0 X1 
     
X3  0 0 0 1 0 0
(1)  × X2  = A × X (0)
 
X = X4  = 0 0 0 0
 
   1 0 

X3 

X5  0 0 0 0 0 1 X4 
X6 1 1 0 0 1 0 X5
Calculons quelques uns des Xi suivants pour voir :

X6 = X0 + X1 + X4
X7 = X1 + X2 + X5
X8 = X2 + X3 + X6 = X0 + X1 + X2 + X3 + X4
X9 = X3 + X4 + X7 = X1 + X2 + X3 + X4 + X5
X10 = X4 + X5 + X8 = X0 + X1 + X2 + X3 + X5
X11 = X5 + X6 + X9 = X2 + X3 + X4
Remarquez une chose très importante et qui nous servira dans la suite : tous les Xi , i >= 6 sont des combinaisons
linéaires des Xi , i <= 5, cela est même logique car la fonction est représentable par une matrice.
Maintenant que nous avons fait cela, nous pouvons faire passer toutes ces entrées dans la fonction booléenne :
z0 = f ([X (0) ]4 ) = f (X1 , X2 , X3 , X5 ) = X1 X2 + X3 X5
z1 = f ([X (1) ]4 ) = f (X2 , X3 , X4 , X6 ) = X2 X3 + X4 (X0 + X1 + X4 ) = X2 X3 + X0 X4 + X1 X4 + X4 X4
z2 = f ([X (2) ]4 ) = f (X3 , X4 , X5 , X7 ) = X3 X4 + X5 (X1 + X2 + X5 ) = X3 X4 + X1 X5 + X2 X5 + X5 X5
z3 = f ([X (3) ]4 ) = f (X4 , X5 , X6 , X8 ) = X4 X5 + (X0 + X1 + X4 )(X0 + X1 + X2 + X3 + X4 ) = X4 X5 + ...
z4 = f ([X (4) ]4 ) = f (X5 , X6 , X7 , X9 ) = X5 X6 + X7 X9 = ...
Et ainsi de suite. C’est ici que la remarque précédente va nous servir : vu que les Xi , i >= 6 sont des combinaisons
linéaires des Xi , i <= 5, le degré du système sera le même degré que celui de la fonction ! Pour le voir prenez X6 × X8 ,
le résultat ne sera composé que de monomes de degré au plus 2. Notez également que vu que nous sommes en binaire
X4 X4 = X4 .
Nous allons donc obtenir un système multivarié où chaque monome sera de degré au plus 2. Résoudre un système
linéaire (où chaque monome est de degré exactement 1) est assez facile, il suffit de trouver la matrice du système,
l’inverser et faire une multiplication et c’est bon. En revanche pour un système multivarié comme celui que nous avons
actuellemment c’est plus compliqué : une façon de s’en sortir consiste à créer plein d’autres variables, appelons les
Yi,j qui seront égales à Xi Xj , cela nous permet en quelque sorte de ”linéariser” le système mais comme vous pouvez
vous en douter le nombre d’inconnues et donc le nombre d’équations nécessaires va croı̂tre. Une bonne question à se
poser est : combien de nouvelles variables aura-t-on ? La réponse à cette question est simple : il suffit tout simplement
16 / 114 Année 2023 - 2024

de prendre 2 indexs i et j (sachant que i peut être égal à j) ce qui nous ferait N 2 nouvelles inconnues. En revanche,
souvenez vous que la multiplication est commutative, nous pouvons donc enlever tous les doublons (c’est à dire les
1 2
Yi,j , Yj,i ) et notre nombre d’inconnues possibles passe donc à CN + CN = N + N (N − 1)/2 = N (N + 1)/2 (1 parmi
N pour tous les monomes du type Xi et 2 parmi N pour tous les monomes du type Xi Xj ).
Dans notre cas, voici un tableau représentant les différentes combinaisons de variables qu’il est possible d’avoir :
× X0 X1 X2 X3 X4 X5
X0 Y0,0 = X0 Y0,1 = X0 X1 Y0,2 = X0 X2 Y0,3 = X0 X3 Y0,4 = X0 X4 Y0,5 = X0 X5
X1 Y1,0 = Y0,1 Y1,1 = X1 Y1,2 = X1 X2 Y1,3 = X1 X3 Y1,4 = X1 X4 Y1,5 = X1 X5
X2 Y2,0 = Y0,2 Y2,1 = Y1,2 Y2,2 = X2 Y2,3 = X2 X3 Y2,4 = X2 X4 Y2,5 = X2 X5
X3 Y3,0 = Y0,3 Y3,1 = Y1,3 Y3,2 = Y2,3 Y3,3 = X3 Y3,4 = X3 X4 Y3,5 = X3 X5
X4 Y4,0 = Y0,4 Y4,1 = Y1,4 Y4,2 = Y2,4 Y4,3 = Y3,4 Y4,4 = X4 Y4,5 = X4 X5
X5 Y5,0 = Y0,5 Y5,1 = Y1,5 Y5,2 = Y2,5 Y5,3 = Y3,5 Y5,4 = Y4,5 Y5,5 = X5
Vous pouvez remarquer que nous avons 21 inconnues, il nous faudra donc 21 bits de la sortie zi pour obtenir 21
équations et pouvoir nous en sortir. Une fois ce système résolu nous aurons les bits de la graine et nous aurons gagné !
3.4 Généralisation de l’attaque :

Définissons donc les notations que nous allons utiliser pour cette généralisation :
ai seront les coefficients du polynôme de rétroaction (il y en a N ).
Xi est une des valeurs que prendra le LFSR.
L’ensemble des Xj , j >= i, j < i + N sera l’état j du LFSR et noté X (j) .
xi seront les positions qui mènent à la fonction f (il y en a k).
La fonction f verra son degré noté df
Le but sera de trouver une relation entre les Xi initiaux (la seed) et la sortie (ainsi que les autres informations connues).
La première étape consiste à trouver la matrice représentant l’évolution du LFSR :

   0 1 0 0 ··· 0 0 0 0
  
X1 X0
 X2   0 0 1 0 ··· 0 0 0 0   X1 
   . . . . .. . .. .. ..  ×  
  .. .. .. .. . ..
 ...  =   ... 
 . . .  
XN −1    
XN −2 
 0 0 0 0 ··· 0 0 0 1
XN aN −1 aN −2 aN −3 aN −4 · · · a3 a2 a1 a0 XN −1
Ce qui nous donne :

X (N ) = AN × X (0)
Il faut ensuite créer le système grâce à la fonction f :



 z0 = f ([I × X (0) ]k ) = f ([X (0) ]k ) = ...
z1 = f ([A × X (0) ]k ) = f ([X (1) ]k ) = ...



...

zα−2 = f ([Aα−2 × X (0) ]k ) = f ([X (α−2) ]k ) = ...




α−1
× X (0) ]k ) = f ([X (α−1) ]k ) = ...

z
α−1 = f ([A
Ce système aura des monômes de degré au plus df , cela veut dire que le nombre total d’équations qu’il faudra pour
1 2 df
pouvoir espérer résoudre le système est : α = CN + CN + ... + CN
Spoiler : par exemple pour N = 128, n = 64 et df = 64, nous avons que le nombre d’équations nécessaires est
1 2 64
C128 + C128 + ... + C128 ≃ 2128 /2 = 2127 valeurs de zi . La complexité serait (2127 )3 = 2381 : énorme !
3.5 Rendre l’inversion de matrice plus rapide :

Commençons par un exemple simple pour la multiplication. Une multiplication de 2 nombres binaires se réalise de la
manière suivante :
1 1 0 0 1 0 1
× 1 0 0 1 1
1 1 0 0 1 0 1
+ 1 1 0 0 1 0 1 -
+ 1 1 0 0 1 0 1 - - - -
= 1 1 1 0 1 1 1 1 1 1 1
17 / 114 Année 2023 - 2024

Nous ferons en moyenne k/2 additions (avec k le nombre de bits des 2 nombres) et chaque addition se fera sur au plus
2k chiffres ce qui nous donne une complexité en O((k/2) × 2k) = O(k 2 ).
Il est possible de faire mieux ! Soient x et y, 2 nombres sur k bits en binaire, nous pouvons les décomposer en
x = a × 2k + b et y = c × 2k + d. Dans un produit ”normal” nous ferions en quelque sorte 4 multiplications :
x × y = (a × 2k + b) × (c × 2k + d) = ac × 22k + (ad + bc) × 2k + bd
Grâce à l’algorithme de Karatsuba il est possible de faire descendre ce nombre de multiplications à 3 :
ac × 22k + (ad + bc) × 2k + bd = ac × 22k + (ac + bd − (a − b)(c − d)) × 2k + bd
Et du coup, en utilisant cette nouvelle méthode la complexité de l’opération passe de O(k 2 ) à O(k log2 (3) ) ≃ O(k 1.585 ).
Il existe une méthode très similaire pour améliorer le produit de matrices. Commençons par rappeler comment le
produit fonctionne :

a1,1 a1,2 b b a1,1 × b1,1 + a1,2 × b2,1 a1,1 × b1,2 + a1,2 × b2,2
× 1,1 1,2 =
a2,1 a2,2 b2,1 b2,2 a2,1 × b1,1 + a2,2 × b2,1 a2,1 × b1,2 + a2,2 × b2,2
La complexité est très simple à trouver : chaque élément de la matrice résultat peut se voir comme un produit scalaire
entre une ligne de la première matrice et une colonne de la seconde. Du coup le nombre d’opérations pour trouver une
valeur de la matrice résultat est O(n) multiplications (nous pouvons négliger le coût des additions) et donc le nombre
d’opérations pour trouver la totalité de la matrice résultat est O(n3 ).
La méthode pour accélérer la multiplication de matrices se réalise encore une fois en ”divide and conquer” (diviser
pour mieux régner) comme nous l’avons vu précédemment, il suffit de diviser chaque matrice en sous-blocs, voici donc
la nouvelle forme de la multiplication ”normale” :

A1,1 A1,2 B1,1 B1,2 A1,1 × B1,1 + A1,2 × B2,1 A1,1 × B1,2 + A1,2 × B2,2
× =
A2,1 A2,2 B2,1 B2,2 A2,1 × B1,1 + A2,2 × B2,1 A2,1 × B1,2 + A2,2 × B2,2
La méthode plus rapide qui se nomme algorithme de Strassen va faire en sorte de ne plus avoir que 7 multiplications
au lieu de 8. Il y aura quelques calculs intermédiaires (à gauche) et les coefficients de la matrice finale sont donnés à
droite : 

 M1 = (A1,1 + A2,2 ) × (B1,1 + B2,2 )
M2 = (A2,1 + A2,2 ) × B1,1


 
C1,1 = M1 + M4 − M5 + M7


M3 = A1,1 × (B1,2 − B2,2 )

 

 
C = M + M
1,2 3 5
M4 = A2,2 × (B2,1 − B1,1 ) ,
 C 2,1 = M 2 + M 4
M5 = (A1,1 + A1,2 ) × B2,2

 

C2,2 = M1 − M2 + M3 + M6

 




 M6 = (A2,1 − A1,1 ) × (B1,1 + B1,2 )
M7 = (A1,2 − A2,2 ) × (B2,1 + B2,2 )

Ici, il est possible de le prouver en utilisant le théorème du maı̂tre, mais la nouvelle complexité est O(n2.8 ).
Pour l’inversion de matrice il suffit de voir qu’elle peut se faire par bloc :
∆ = D − CA−1 B : Complément de Schur de A

−1
A−1 + A−1 × B × ∆−1 × C × A−1 −1 × A−1 × B × ∆−1

A B
=
C D −1 × ∆−1 × C × A−1 ∆−1
Comme vous pouvez le voir, il faut au total réaliser 13 multiplications et 2 inversions de matrice. Nous pourrons
ré-appliquer la méthode précédente pour avoir un peu moins de multiplications / inversions ce qui nous permettra
d’avoir une complexité inférieure à O(n3 ).
Liens utilisés :
https://tesla.pmf.ni.ac.rs/people/dexter/old/Papers/RapidLU.pdf
https://arxiv.org/pdf/1901.00904v1.pdf
Nous pouvons appliquer ce nouvel algorithme à notre cas ce qui nous donne 2127×2.8 ≃ 2355 !
Il existe d’autres méthodes d’inversion de matrice mais elles sont soit impraticables (exposant de l’algèbre linéaire
en n2.36 ) soit non adaptées au cas de figure étudié (matrices de Vandermonde / algorithme de Wideman pour un
système creux en n2 ).
18 / 114 Année 2023 - 2024

3.6 Le concept d’immunité algébrique :

L’immunité algébrique du polynôme f est le degré du polynôme de plus petit degré possible g tel que f (x) × g(x) = 0
pour toute valeur de x possible. Pour mieux voir comment cela marche commençons par un exemple : f (x1 , x2 ) =
x1 + x2 :
g(x1 , x2 ) = 1 : f (x1 , x2 ) × g(x1 , x2 ) = (x1 + x2 ) × 1 = x1 + x2 ̸= 0
g(x1 , x2 ) = 1 + x1 : f (x1 , x2 ) × g(x1 , x2 ) = (x1 + x2 ) × (1 + x1 ) = x1 + x2 + x21 + x1 x2 = x2 + x1 x2 ̸= 0
g(x1 , x2 ) = 1 + x2 : f (x1 , x2 ) × g(x1 , x2 ) = (x1 + x2 ) × (1 + x2 ) = x1 + x2 + x1 x2 + x22 = x1 + x1 x2 ̸= 0
g(x1 , x2 ) = 1 + x1 + x2 : f (x1 , x2 ) × g(x1 , x2 ) = x1 + x2 + x21 + x1 x2 + x22 + x1 x2 = 0
Nous pouvons prouver que IA(f ) <= df :

L’idée est tout simplement de voir que 0 × 0 = 0, 0 × 1 = 0, 1 × 0 = 0, 1 × 1 = 1. Notre but sera donc de faire en sorte
que dès que f (x) retourne 1, g(x) retourne 0 et inversement. Une idée pour faire cela est g(x) = 1 + f (x) qui vaudra
0 quand f (x) vaudra 1 et inversement. Une autre façon de confirmer que cette fonction est possible est de calculer
f (x) × g(x) = f (x) × (1 + f (x)) = f (x) + f 2 (x) = f (x) + f (x) = 0.
Nous venons ici de démontrer quelque chose de très important : la valeur de l’identité algébrique (et donc le degré de
f) est inférieur au degré de g. Cela sera utile dans la suite.
Calculons maintenant IA(x1 x2 x4 + x1 x4 ) :

La fonction g qui nous permettra d’annuler f sera tout simplement x2 car x2 ×(x1 x2 x4 +x1 x4 ) = x1 x2 x4 +x1 x2 x4 = 0.
Nous pouvons déduire de cela que IA(x1 x2 x4 + x1 x4 ) = 1.
Il existe d’autres fonctions g qui peuvent permettre d’annuler f telles que x1 x2 , x2 x4 ou encore x1 x2 x4 mais le degré
de ces dernières est plus grand que celui du monôme x2 .
Et le dernier exemple sera IA(x1 x2 x4 x5 x7 ) :

Ici, plusieurs fonctions g de même degré dg = 1 peuvent faire l’affaire :
g(x1 , ..., x7 ) = 1 + x1
g(x1 , ..., x7 ) = 1 + x2
g(x1 , ..., x7 ) = 1 + x4
g(x1 , ..., x7 ) = 1 + x5
g(x1 , ..., x7 ) = 1 + x7
g(x1 , ..., x7 ) = 1 + x1 + x2 + x4
g(x1 , ..., x7 ) = 1 + x1 + x2 + x5
Et il en existerait encore plein d’autres. Le but est en fait de faire apparaı̂tre un nombre pair de fois x1 x2 x4 x5 x7 de
façon à ce que les couples s’annulent et qu’il ne reste que 0 à la fin.
Nous pouvons donc conclure en disant que IA(x1 x2 x4 x5 x7 ) = 1.
Il est possible de trouver une valeur générale de l’identité algébrique.

L’idée est la suivante, commençons par lister toutes les valeurs possibles de tous les xi et toutes les valeurs de f
associées :
x1 0 1 0 1 0 1 ... 0 1
x2 0 0 1 1 0 0 ... 1 1
.. .. .. .. .. .. .. .. .. ..
. . . . . . . . . .
xn 0 0 0 0 0 0 ... 1 1
f 1 1 0 1 0 0 ... 1 0
L’autre point important est que nous cherchons une fonction g qui sera égale à 0 pour tout x tel que f (x) = 1, dans
le cas contraire si f (x) = 0 peu importe la valeur de g nous obtiendrons 0 donc on s’en fout de ces x là !
Ce problème peut donc se réduire à résoudre un système de 2n /2 équations (car en moyenne la sortie de f aura 50%
de chances de valoir 0 et 50% de chances de valoir 1 et nous avons 2n entrées possibles) pour lesquelles chacune doit
valoir 0. Pour pouvoir résoudre un tel système, il nous faudra 2n /2 variables (correspondant à des monomes de xi ).
Or, nous avions dit précédemment que le nombre de variables correspondant à un xi était 1 parmi n, le nombre de
variables pour 2 xi est 2 parmi n et ainsi de suite jusqu’au degré maximal du monôme. Il nous suffit donc de chercher
Pdg
dg tel que i=1 Cni >= 2n /2 ce qui se produit pour dg = n/2 + 1.
La conclusion de cela est que, en moyenne : IA(f ) = n/2 + 1.

Si la fonction booléenne sort tout le temps 0, bien sûr IA(f ) = 0
Si la fonction booléenne sort tout le temps 1, nous aurons IA(f ) = n (car il faudra 2n équations).
19 / 114 Année 2023 - 2024

Pour mieux comprendre comment cela fonctionne, faisons un exemple avec la fonction f suivante : f (x1 , x2 , x3 , x4 ) =
1 + x1 x2 + x1 x3 x4 + x3 . Voici le tableau décrivant les différentes valeurs de la fonction :
x1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
x2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
x3 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
x4 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
f 1 1 0 0 1 1 0 0 1 1 0 1 0 0 1 0
Vous pouvez remarquer qu’il y a 8 valeurs à 1, nous aurons donc besoin de 8 variables. Vous pouvez remarquer qu’en
prenant 1 parmi 4 + 2 parmi 4, nous pouvons obtenir 10 ce qui est suffisant : l’IA de cette fonction boolénne est 2.
Toutes ces informations vont nous permettre de trouver des conditions sur la fonction booléenne g (j’appellerais ci le
coefficient devant xi , ci,j celui devant xi xj et ainsi de suite) :
g(0, 0, 0, 0) = 0 : donc le terme constant de g est à 0 (car tous les monômes de xi sont déjà nuls).
g(0, 0, 0, 1) = 0 : seul x4 peut donner un résultat à 1, il faut donc que c4 = 0.
g(0, 1, 0, 0) = 0 : donc c2 est nul.
g(1, 0, 0, 0) = 0 : donc c1 est nul.
g(0, 1, 0, 1) = 0 : x2 , x4 , x2 x4 sont les variables qui peuvent mettre le résultat à 1, nous savons que c2 et c4 sont
nuls donc nécessairement c2,4 est nul aussi.
g(1, 0, 0, 1) = 0 : donc c1,4 est nul.
g(1, 0, 1, 1) = 0 : x3 , x1 x3 , x3 x4 , x1 x2 x4 sont possibles et n’ont pas encore de coefficient attribué, nous en
déduisons donc 0 parmi 4 + 2 parmi 4 + 4 parmi 4 = 8 possibilités.
g(1, 1, 1, 0) = 0 : x3 , x1 x2 , x1 x3 , x2 x3 , x1 x2 x3 sont possibles et n’ont pas encore de coefficient attributé, et il y
a ici 0 parmi 5 + 2 parmi 5 + 4 parmi 5 = 16 possibilités.
Nous savons que IA(f ) = 2, nous allons donc nous restreindre aux polynômes de degré 2. Il faut que c = 0,
c1 = c2 = c4 = 0, c1,4 = c2,4 = 0, un polynôme qui marche est x3 + x1 x3 car il vérifie également les 2 dernières
conditions. Comme vous pouvez vous en douter il en existe également plein d’autres qui marchent, il suffit juste qu’ils
passent les conditions données.
Il nous est possible de compter le nombre de fonctions ”qui marchent” :

Les variables c, c1 , c2 , c4 , c1,4 , c2,4 doivent être nulles, elles ne changeront pas le nombre de fonctions possibles.
Les variables c1,3,4 , c2,3,4 , c1,2,3,4 n’apparaissent pas, le nombre de possibilités sera donc multiplié par 23 .
Les variables x3 , x1 x3 sont communes aux 2 dernières conditions :
Si les 2 sont à 0 : il y a 2 possibilités pour la première condition et 4 pour la seconde : 8 au total.
Si l’un des 2 est à 1 : 2 possibilités pour la première, 4 possibilités pour la seconde : 8 au total (à multiplier par
2 car il y a 2 façons d’avoir l’une des 2 variables à 1).
Si les 2 sont à 1 : il s’agit du même cas que pour les 2 à 0 : 8 au total.
Le nombre total de solutions est donc 23 × (8 + 2 × 8 + 8) = 28 = 256. Notez que la fonction nulle ne doit pas être
comptée, nous avons donc réellement 256 − 1 = 255 solutions.
Voici un programme brute-forcant l’immunité algébrique d’une fonction booléenne :

1 # Un monome sera represente par la liste des variables dedans
2 n om br eV a ri ab le s = 4
3 f = [ [ ], [ 1, 2 ], [ 1, 3, 4 ], [ 3 ] ]
4
5 # La fonction pour calculer le resultat de la fonction booleenne a une liste de xi
6 def c a l c u l e r F o n c t i o n B o o l e e n n e (f , x_values ) :
7 resultatFinal = 0
8 for i in range (0 , len ( f ) ) :
9 resultat = 1
10 for j in range (0 , len ( f [ i ]) ) :
11 resultat *= x_values [ f [ i ][ j ] - 1]
12 resultatFinal = ( resultatFinal + resultat ) % 2
13 return resultatFinal
14
15 # Test du calcul des differentes valeurs de la fonction f
16 for i in range (0 , 2 ** no mb r eV ar ia b le s ) :
17 bits = ( " {:0 " + str ( n om br e Va ri ab l es ) + " b } " ) . format ( i )
18 x_values = [ int ( bits [ j ]) for j in range (0 , n om br eV a ri ab le s ) ]
19 resultat = c a l c u l e r F o n c t i o n B o o l e e n n e (f , x_values )
20 print ( " f ( " , end = " " )
21 for j in range (0 , n om br eV a ri ab le s ) :
22 print ( " x " + str ( j ) + " = " + str ( x_values [0]) , end = " " )
23 if j != n o mb re Va r ia bl es - 1 :
24 print ( " , " , end = " " )
25 print ( " ) = " + str ( resultat ) )
26
27
28
20 / 114 Année 2023 - 2024

29 # Creation de tous les monomes possibles

30 m o n o m e s P o s s i b le s = []
31 for i in range (0 , 2 ** no mb r eV ar ia b le s ) :
32 monomeCourant = []
33 bits = ( " {:0 " + str ( n om br e Va ri ab l es ) + " b } " ) . format ( i )
34 for j in range (0 , len ( bits ) ) :
35 if bits [ j ] == ’1 ’ :
36 monomeCourant . append ( j + 1)
37 m o n o m e s P o s s i b le s . append ( monomeCourant )
38 print ( m o n o m e s P os s i b l e s )
39
40 # Iteration sur toutes les fonctions possibles
41 i d e n t i t e A l g e b r i q u e = n om br eV a ri ab l es
42 fonctionIA = None
43 for i in range (1 , 2 ** (2 ** no mb re V ar ia ble s ) ) :
44 bits = ( " {:0 " + str (2 ** no m br eV ar i ab le s ) + " b } " ) . format ( i )
45 g = []
46 for j in range (0 , len ( bits ) ) :
47 if bits [ j ] == ’1 ’ :
48 g . append ( m o n o m e s P o ss i b l e s [ j ])
49
50 t r o u v e U n e B o n n e F o n c t i o n = True
51 for j in range (0 , 2 ** no mb r eV ar ia b le s ) :
52 bits = ( " {:0 " + str ( n om br e Va ri ab l es ) + " b } " ) . format ( j )
53 x_values = [ int ( bits [ k ]) for k in range (0 , n om br eV a ri ab le s ) ]
54 resultatF = c a l c u l e r F o n c t i o n B o o l e e n n e (f , x_values )
55 resultatG = c a l c u l e r F o n c t i o n B o o l e e n n e (g , x_values )
56 if resultatF * resultatG == 1 :
57 t r o u v e U n e B o n n e F o n c t i o n = False
58 break
59 if t r o u v e U n e B o n n e F o n c t i o n :
60 print ( g )
61 degreG = max ([ len ( g [ j ]) for j in range (0 , len ( g ) ) ])
62 if degreG < i d e n t i t e A l g e b r i q u e :
63 i d e n t i t e A l g e b r i q u e = degreG
64 fonctionIA = g
65 print ( " Identite algebrique : " + str ( i d e n t i t e A l g e b r i q u e ) )
66 print ( " Fonction : " + str ( fonctionIA ) )
3.7 Application de ce concept à l’attaque algébrique sur le LFSR :

Voyons maintenant comment nous pouvons appliquer ce concept à notre attaque algébrique sur LFSR précédente de
façon à la rendre plus efficace. Reprenons donc la fonction booléenne non-linéaire f que nous avions donnée à notre
LFSR, nous allons ensuite essayer de trouver la fonction g (dont le degré sera l’identité algébrique de f ) telle que
f × g = 0.
L’idée est ici de voir qu’en calculant zi × g(x), nous calculons en fait f (x) ∗ g(x) qui vaut toujours 0. Donc si nous
avons f (x) = zi = 1 nous savons que g(x) = 0 et vu que dg <= df : nous aurons donc besoin de 2 fois plus de bits
(car seuls les zi = 1 sont exploitables) mais ces équations sont avec la fonction g et elles auront peut être un degré
bien moindre qu’avec f et donc au final nous aurons besoin de moins d’équations.
Pour mieux comprendre ce fonctionnement, reprenons notre exemple : f (x0 , x1 , x2 , x3 ) = x0 x1 + x2 x3 , malheureuse-

ment l’IA de cette fonction est 2 ce qui ne diminue pas notre nombre d’équations.
Prenons plutôt f (x0 , x1 , x2 , x3 ) = x0 x2 x3 + x2 x3 : comme nous l’avons vu avant avec encore une fois 6 bits de seed
(X0 , X1 , ..., X5 ), l’IA de cette fonction est 1 et g(x0 , x1 , x2 , x3 ) = x0 . La méthode sans utilisation de l’IA nous donne-
rait 1 parmi 6 + 2 parmi 6 + 3 parmi 6 = 41 équations. En utilisant l’IA, nous chercherons à résoudre g(x) = 0 pour
tous les bits zi qui sont à 1, cela veut dire que nous aurons juste besoin de 6 × 2 = 12 équations (je considère qu’il y
a 50% de chances d’avoir un bit à 1) !
3.8 Attaque sur TOYOCRYPT :

La fonction utilisée est :
62
X 62
Y
f (x0 , ..., x127 ) = x127 + xi × xα(i) + x10 x23 x32 x42 + x1 x2 x9 ...x53 x59 + xi
i=0 i=0
Et ils arrivent à trouver une fonction g, apparemment IA(f) = 3 et du coup au lieu d’avoir 2350 équations, on en a 3
parmi 128 ≃ 218 ce qui nous donne un temps proporitionnel à 254 environ.
La solution implémentée en réalité est tout simplement de reprendre une nouvelle seed tous les 1000 bits générés
par exemple.
21 / 114 Année 2023 - 2024

4 Authentification :
4.1 Quelques propriétés des blocs de base en cryptographie asymétrique :
Les 4 blocs sur lesquelles nous allons nous pencher seront : le chiffrement, l’échange de clé, la signature ainsi que
l’authentification.
Le chiffrement :
Échange de clé : POSSIBLE, allez voir les mécanismes d’encapsulation de clé. L’idée est tout simplement de
prendre une clé symétrique K, la chiffrer avec la clé publique du serveur puis envoyer ce chiffré au serveur.
Signature : IMPOSSIBLE, sauf dans le cas particulier de RSA où le déchiffrement est ”la même opération” que
le chiffrement.
Authentification : POSSIBLE, en mode ”défi-réponse” (comme nous le verrons après). Le serveur envoie tout
simplement le chiffré d’une valeur aléatoire avec la clé publique du client, le client déchiffre et renvoie cette
valeur aléatoire, cela fait bien de l’authentification car seul le détenteur de la clé privée peut déchiffrer.
La signature :
Chiffrement : IMPOSSIBLE
Échange de clés : IMPOSSIBLE
Authentification : POSSIBLE, encore une fois en mode ”défi-réponse”, le client va signer une valeur aléatoire
avec sa clé privée et le serveur pourra la vérifier avec la clé publique du client.
L’échange de clés : ne permet ni le chiffrement, ni la signature, ni l’authentification.
L’authentification : ne permet ni le chiffrement, ni l’échange de clés ni la signature sauf lorsque nous serons en
présence d’authentification zero knowledge.
Notez que vu que par exemple le chiffrement implique l’authentification, en faisant de l’authentification toute seule
(standalone) il est possible de gagner peut-être un peu en efficacité (au lieu que d’utiliser un algorithme de chiffrement
pour la réaliser) mais nous verrons un exemple plus loin.
4.2 Authentification symétrique :

L’authentification symétrique la plus simple se réalise par mot de passe : le client envoie son mot de passe au serveur
qui va le comparer avec ce qui est stocké pour autoriser l’authentification. Le problème avec ce genre d’authentification
est qu’un attaquant peut tout simplement intercepter le message d’authentification et le rejouer plus tard. Il serait
possible d’imaginer une version où l’utilisateur envoie le hash de son mot de passe mais encore une fois cela est sensible
à une attaque par rejeu.
Il nous faudra considérer plusieurs cas en fonction du nombre de messages échangés : le nombre de ”passes”.
1 seule passe :
Ici, nous allons étudier le schéma de Lamport. Ce dernier est très simple : le client et le serveur gardent chacun un
compteur qui sera incrémenté de 1 à chaque nouvelle authentification réussie, le client va tout simpelemtn envoyer
H n−i (password) avec n une valeur fixée par les 2 parties et i le compteur. Prenons par exemple n = 100 et un compteur
initial i = 0, à la première connexion le client enverra H 100 (password) = H(H 99 (password)) et à la seconde il enverra
H 99 (password). Ce schéma est effectivement sécurisé contre les attaques par rejeu mais notez que si la fonction de
hachage n’est pas résistante à la pré-image (c’est à dire que l’attaquant peut retrouver x si on ne lui donne que H(x))
alors il pourra prévoir le second message envoyé et s’authentifier.
Voici un schéma résumant ce protocole :
22 / 114 Année 2023 - 2024

2 passes :
Avec 2 passes, nous verrons plutôt des schémas de type ”défi - réponse” : le serveur enverra un défi au client, le client
enverra une réponse qui lui permettra de prouver au serveur qu’il connaı̂t le mot de passe.
L’idée peut être représentée par le protocole suivant :
Une nouvelle fois, ce protocole permet de se protéger contre les attaques par rejeu et il est plus simple que le précédent
car il ne demande pas au 2 parties de synchroniser un compteur, il faut juste un nonce (Number used ONCE) généré
aléatoirement par le serveur. Notez que si la fonction de hachage n’est pas résistante à la pré-image, l’attaquant peut
encore une fois récupérer le mot de passe !
Le serveur pour autoriser l’authentification va tout simplement calculer H(password||NS ) et voir s’il est égal à la
valeur qu’il a reçue du client.
3 passes :
Pour finir, les schémas à 3 passes sont plus adaptés aux algorithmes de chiffrement asymétriques que nous verrons après.
4.3 Authentification asymétrique :

Les protocoles de ce genre seront constitués de 2 parties :
Le prouveur, noté P dont le but sera de s’authentifier.
Le vérifieur, noté V qui comme son nom l’indique aura pour but de vérifier l’authentification.
Le prouveur commencera par envoyer un engagement (en anglais ”commitment”) au vérifieur.
Le vérifieur enverra ensuite un défi au prouveur.
Pour finir, le prouveur renverra sa réponse au vérifieur qui pourra comme son nom l’indique vérifier.
Ces schémas ont 3 propriétés intéressantes :

Cohérence : pour tout défi, P est capable de donner une réponse.
Signifiance : la probabilité que l’adversaire se fasse passer pour P est faible.
Zero knowledge : un adversaire qui écoute ne peut tirer aucune information des échanges (c’est un peu la
propriété la plus importante).
4.4 Un exemple sur le schéma d’authentification Fiat-Shamir (1986) :

Voici une image résumant ce que fait le protocole :
Il est évident de voir que le prouveur peut toujours répondre au défi, il s’agit tout simplement d’une mise à la puissance
0 / 1.
23 / 114 Année 2023 - 2024

Voyons maintenant les 2 cas quand il nous est possible de nous faire passer pour le prouveur P . Il nous faut tout
d’abord définir ce que veut dire ”se faire passer pour P ” : il s’agit tout simplement de lancer une exécution du pro-
tocole en tant que P et le défi sera de faire en sorte que le dernier message soit vérifié (sans connaı̂tre la clé privée).
Voici les 2 cas :
Si r = 0 : nous avons juste à renvoyer la valeur de k que nous connaissons.
Si r = 1 : nous ne pouvons pas prendre k = 0 sinon le manque d’aléatoire serait détectable, l’idée va être
d’envoyer k 2 /A dans le premier message, puis k dans le second : y 2 = (k)2 = k 2 et K × A1 = (k 2 /A) × A = k 2 ,
les 2 valeurs sont donc égales !
Nous pouvons donc en déduire qu’en jouant toujours le cas r = 0, nous avons 1 chance sur 2 de gagner, ce sera la
même probabilité pour le cas r = 1. Mais, vu qu’on ne connaı̂t pas r à priori et que les 2 engagements sont différents
dans les 2 cas il nous est impossible de faire mieux.
Prouvons maintenant que nous ne pouvons pas faire mieux que 1/2 : le premier message sera modifié en α et le dernier
message sera modifié en βi , de plus V va vérifier que βi2 = α × Ar . En nous servant de cette formule, nous pouvons
voir que pour r = 0, β02 = α et dans le cas r = 1, β12 = α × A. Le but de l’attaquant pour toujours réussir serait de
trouver β0 et β1 pour le même α, trouver β0 est facile, pour trouver l’autre il nous faudrait une relation β1 = β0 + ...
ou β1 = β0 × ... :
Méthode additive : β02 − β12 = (β0 + β1 ) × (β0 − β1 ) = α × (A − 1) ce qui ne permet de rien faire.
Méthode multiplicative : β12 /β02 = (β1 /β0 )2 = (α × A)/α = A : le seul moyen pour l’attaquant de trouver ce
rapport est de connaı̂tre une racine de A : ce problème est équivalent à la factorisation car pour résoudre le
résidu quadratique dans les nombres modulo N il faut connaı̂tre sa factorisation.
Donc au final, à chaque exécution du protocole, un attaquant a une chance sur 2 de se faire passer pour le prouveur. Ce
protocole peut donc voir sa sécurité modulée en fonction du nombre tentatives : t répétitions du protocoles donneront
lieu à une probabilité de se faire passer pour le prouveur dans tous les tests de (1/2)t .
Pour finir, pour prouver la propriété de zero knowledge, la méthodologie est la suivante : il faut simuler les échanges
entre un vrai prouveur et un vérifieur et montrer que d’un point de vue théorie de l’information il n’est pas possible
de les distinguer avec une exécution sur le même ordinateur.
Conclusion :
Soit t le nombre de tous et b le nombre de bits de N .
Le premier tour va envoyer b données, le second un seul bit et le dernier b données également. Cela nous fait un coût
de communication de 2b × t ce qui est beaucoup plus élevé que RSA.
En revanche, pour le nombre de multiplications il est simplement de 2 × t. Par exemple, pour une authentification à
2−100 , nous faisons 100 tours et donc 200 multiplications alors qu’avec un RSA il aurait fallu faire 1000 multiplciations.
Ce protocole n’est pas utilisé dans la pratique mais il a ouvert les portes pour d’autres protocoles tels que celui de
Guillou et Quisquater en 1988.
24 / 114 Année 2023 - 2024

5 Magic crypto :
5.1 Définition du problème et une première solution :
Commençons par donner une définition de ce qu’est la magic crypto : c’est un problème qui à priori semble impossible
mais qui en réalité l’est.
Nous allons voir le problème du retrait d’information privé (ou ”Private Information Retrieval”) : supposons que
nous avons une base de données de films et un utilisateur qui veut télécharger un film depuis cette dernière sans que
la base de données sache quel film a été téléchargé : le but est d’avoir de la ”privacy”.
Une première méthode qui serait possible est de laisser l’utilisateur télécharge la totalité de la base de données et ce
dernier va ensuite choisir le film qu’il veut depuis ce qu’il a téléchargé.
Une autre méthode est d’utiliser un tiers de confiance, de cette manière la base de données ne sait pas qui a téléchargé
le film mais il faut avoir confiance en ce tiers de confiance.
Pour résoudre ce problème, il faudra forcément que la base de données soit lue en totalité (sinon il lui est possible de
gagner de l’information) mais nous avons un critère d’efficacité qui rentre en compte : la taille de la réponse est faible
(le mieux que l’on puisse espérer est la taille de l’élément voulu).
Un exemple de solution à ce problème est le protocole d’Ostrovsky et Kushilevitz que nous présenterons ci-dessous.
5.2 Rappels sur la notion de résidu quadratique et carrés :

Nous allons commencer par définir la notion de racine carrée ainsi que de résidu quadratique. Nous dirons que x est
la racine carrée de a modulo n si la relation suivante est vérifiée : x2 = a (mod n). D’ailleurs, nous dirons également
que a est un résidu quadratique modulo n (car il possède une racine carrée).
Prenons par exemple a = 4 modulo n = 7, a est un résidu quadratique et possède 2 racines carrées : x = 2 et x = 5.
Une autre propriété intéressante est que si x est une racine carrée de a, alors n − x l’est également : (n − x)2 ≡
n2 − 2nx + x2 ≡ x2 ≡ a (mod n).
Parlons maintenant de diviseurs de 0 : a et b seront des diviseurs de 0 si a ̸= 0, b ̸= 0 et a × b = 0. Par exemple,

modulo 8 les nombres a = 2 et b = 4 sont des diviseurs de 0 car 2 × 4 = 8 ≡ 0 (mod 8). Les diviseurs de 0 ne peuvent
existe que dans un anneau où tous les éléments ne sont pas inversibles par la relation multiplicative.
Nous pouvons prouver que modulo p un nombre premier, chaque√résidu quadratique√ a a exactement 2 racines : nous
voulons résoudre x2 ≡ a (mod n) ⇔ x2 − a ≡ 0 (mod n) ⇔ (x − a)(x + a) ≡ 0 : vu que (Z/pZ, √ +, ×) est un corps,
√
il n’y a pas
√ de diviseurs de 0, il ne peut√donc y avoir que 2 solutions à cette équation : soit x − a = 0 et donc x = a,
soit x + a = 0 ce qui donne x = p − a.
Prenons maintenant n = p × q, nous pouvons démontrer que chaque résidu quadratique a a exactement 4 racines.
La première chose à prouver est que tout résidure quadratique a modulo n est un résidu quadratique modululo p et
modulo q. La preuve est très simple, vu que x2 ≡ a (mod n), nous avons que ∃k ∈ Z, a = x2 + k × p × q qui donne
également x2 modulo p et modulo q.
Sachant cela, nous pouvons dire que a est un résidu quadratique modulo p et trouver les 2 racines que nous noterons
xp et p − xp . La même procédure peut être répétée pour le modulo q ce qui va nous donner xq et q − xq . Le problème
est que toute ces racines sont soit modulo p soit modulo q et nous les voulons modulo n : nous allons appliquer un
théorème chinois des restes à chaque paire de racines (une prise modulo p et une prise modulo q) ce qui nous donnera
nos 4 racines finales.
Prenons une paire de nombres et multiplions-les modulo p :

Si a et b sont des résidus quadratiques, alors ab = x2 × y 2 = (x × y)2 (mod p) est un résidu.
Si a est un résidu quadratique et b n’en est pas un (ou l’inverse) : l’idée est qu’il y a (p − 1)/2 résidus non-nuls
modulo p et donc que le produit de a avec tous les autres résidus forme ces (p − 1)/2 résidus ce qui ne laisse
plus de place pour que ab soit un résidu, c’est donc un non-résidu.
Si a et b ne sont pas des résidus quadratiques : un argument très similaire à précédemment peut être donné.
L’ensemble des produits de a avec un résidu forme l’ensemble des (p − 1)/2 non-résidus possibles, il ne reste
plus de place pour que ab soit un non-résidu, c’est donc un résidu.
Nous pouvons réaliser le même raisonnement modulo n = p × q :
Si a et b sont des résidus quadratiques, ab est un résidu quadratique (même démonstration que pour le cas p).
Si a est un résidu quadratique et b n’en est pas un (ou l’inverse) : ab n’est pas un résidu quadratique. C’est le
même argument qu’avant mais il y a ici (n + p + q − 3)/4 résidus.
Si a et b ne sont pas des résidus quadratiques : ab est un résidu quadratique (même argument qu’avant).
Notez pour finir que savoir si a (mod n) est un carré est équivalent à factoriser n (car il faut pouvoir récupérer les
racines modulo p et q pour trouver celles modulo n).
25 / 114 Année 2023 - 2024

Et un petit programme en python pour trouver tous les résidus quadratiques : Voici un programme en python pour
recuperer la liste de tous les résidus quadratiques :
1 n = 391
2 listeCarres = []
3 for i in range (0 , n ) :
4 carre = ( i * i ) % n
5 if carre not in listeCarres :
6 listeCarres . append ( carre )
7 listeCarres = sorted ( listeCarres )
8 print ( listeCarres )
5.3 Un exemple : le chiffrement de Rabin :

C’est un cryptosystème très similaire à RSA mais qui se base sur le problème du résidu quadratique modulo n.
Voici les 2 clés qui seront utilisées dans ce cryptosystème :

La clé publique est tout simplement le module RSA : pk = (n)
La clé privée est la factorisation de ce module : sk = (p, q)
Il faut 2 conditions sur p et q : ce sont des nombres premiers tels que p ≡ 3 (mod 4) et q ≡ 3 (mod 4) (vous compren-
drez pourquoi après).
Pour le chiffrement, nous calculerons c = m2 (mod n)
Pour le déchiffrement, en connaissant p et q, nous pouvons retrouver les 4 racines de c en utilisant le critère d’Euler.
Prenons l’exemple du modulo p, nous savons grâce au théorème de Fermat que ap−1 = 1 (mod p), nous pouvons donc
en déduire que a(p−1)/2 = ±1 (mod p) (car les 2 seules racines de l’unité sont 1 et -1 modulo p et p − 1 peut être
divisé par 2 car il est pair). Le critère d’Euler nous dit que a est un résidu quadratique si et seulement si a(p−1)/2 = 1
(mod p) (les a pour lesquels nous obtenons -1 sont donc les non-résidus). Chercher les racines de a revient donc à
trouver b2 = a(p−1)/2 × a = a(p+1)/2 = a (mod p), or nous savons que p ≡ 3 (mod 4), nous pouvons donc dire que
p + 1 est un multiple de 4 et prendre b = ±a(p+1)/4 !
5.4 Le protocole d’Ostrovsky :

La première chose à voir est comment nous allons représenter la base de données :
Film 1 Film 2 Film 3 Film 4 Film 5 Film 6 Film 7 Film N = 8
Bit 1 1 1 0 1 0 0 0 1
Bit 2 0 0 1 0 0 1 0 0
Bit 3 0 0 0 0 1 0 0 0
Bit 4 0 0 0 1 0 1 0 1
Bit 5 1 0 1 0 1 0 0 1
Bit 6 0 0 1 1 1 1 1 0
Bit 7 1 0 1 0 1 0 0 1
Bit 8 0 0 1 1 0 1 0 1
Bit 9 1 1 0 1 0 1 1 0
Bit 10 1 0 0 0 1 0 1 0
Dans la suite, i0 sera l’index du film à récupérer (entre 1 et N ), pour l’exemple, nous prendrons i0 = 5.
Nous allons également choisir p et q, 2 nombres premiers et calculer n = p × q (ces valeurs ne seront connues que de
l’utilisateur), encore une fois, pour l’exemple nous prendrons p = 17 et q = 23 ce qui nous donne n = 391.
Dans la requête, nous allons envoyer une liste de nombres aléatoires r1 , ..., rN ainsi que le module RSA n. Dans
cette liste, chaque ri sera un résidu quadratique (un carré) sauf pour ri0 qui sera un non carré. Nous pourrions par
exemple envoyer la liste (r1 = 82 = 64, r2 = 2362 = 174, r3 = 952 = 32, r4 = 3082 = 242, r5 = 7, r6 = 2812 = 370, r7 =
1462 = 202, r8 = 3612 = 118). Comme vous pouvez le voir, ici, le seul non carré est r5 qui vaut 7.
Le serveur, lorsqu’il va recevoir ces nombres va réaliser le calcul suivant pour chaque bit j :
b b b b b b b b
sj = r11,j × r22,j × r33,j × r44,j × r55,j × r66,j × r77,j × r88,j
bi,j
Notez que tous les ri avec i ̸= i0 seront des carrés (car si bi,j = 1 nous avons ri qui est un carré et si bi,j = 1 nous
avons 1 qui est également un carré). Nous savons également que ri00 = 1 sera un carré, alors que ri10 = ri0 sera un non
carré, or un produit avec que des carrés donnera un carré alors qu’un produit contenant un seul non carré donnera
un non-carré : nous pourrons donc utiliser cela pour distinguer entre les 2 valeurs de bit ! (si le nombre sj recu est un
carré nous savons que le bit j du film i0 était 0, sinon ce dernier était 1).
26 / 114 Année 2023 - 2024

Voici les calculs pour notre exemple :

s1 = 641 × 1741 × 320 × 2421 × 70 × 3700 × 2020 × 1181 = 64 × 174 × 242 × 118 = 98
s2 = 640 × 1740 × 321 × 2420 × 70 × 3701 × 2020 × 1180 = 32 × 370 = 110
s3 = 640 × 1740 × 320 × 2420 × 71 × 3700 × 2020 × 1180 = 7 = 7
s4 = 640 × 1740 × 320 × 2421 × 70 × 3701 × 2020 × 1181 = 242 × 370 × 118 = 118
s5 = 641 × 1740 × 321 × 2420 × 71 × 3700 × 2020 × 1181 = 64 × 32 × 7 × 118 = 182
s6 = 640 × 1740 × 321 × 2421 × 71 × 3701 × 2021 × 1180 = 32 × 242 × 7 × 370 × 202 = 283
s7 = 641 × 1740 × 321 × 2420 × 71 × 3700 × 2020 × 1181 = 64 × 32 × 7 × 118 = 182
s8 = 640 × 1740 × 321 × 2421 × 70 × 3701 × 2020 × 1181 = 32 × 242 × 370 × 118 = 257
s9 = 641 × 1741 × 320 × 2421 × 70 × 3701 × 2021 × 1180 = 64 × 174 × 242 × 370 × 202 = 49
s10 = 641 × 1740 × 320 × 2420 × 71 × 3700 × 2021 × 1180 = 64 × 7 × 202 = 175
La liste des carrés modulo 391 est la suivante :
1 [ 0 , 1 , 2 , 4 , 8 , 9 , 13 , 16 , 18 , 25 , 26 , 32 , 35 , 36 , 47 , 49 , 50 , 52 , 55 , 59 , 64 , 69 , 70 ,
2 72 , 77 , 81 , 85 , 87 , 93 , 94 , 98 , 100 , 101 , 104 , 110 , 115 , 117 , 118 , 119 , 121 , 123 , 127 ,
3 128 , 138 , 140 , 144 , 151 , 154 , 161 , 162 , 169 , 170 , 174 , 179 , 185 , 186 , 187 , 188 , 196 , 200 ,
4 202 , 208 , 213 , 219 , 220 , 223 , 225 , 230 , 234 , 236 , 238 , 239 , 242 , 246 , 253 , 254 , 255 , 256 ,
5 257 , 259 , 271 , 276 , 280 , 285 , 288 , 289 , 302 , 305 , 307 , 308 , 315 , 322 , 323 , 324 , 325 , 331 ,
6 338 , 340 , 348 , 349 , 353 , 357 , 358 , 361 , 370 , 372 , 374 , 376 ]
Vous pouvez voir grâce à cette liste que la liste des si que nous avons sont : [ carré, carré, non-carré, carré, non-carré,
non-carré, non-carré, non-carré, carré, carré, non-carré ] ce qui nous donne les bits du 5ème film qui sont : 0, 0, 1,
0, 1, 1, 1, 0, 0, 1.
La conclusion est que la base de données ne connaissant pas p et q, elle ne peut pas distinguer entre un carré et
un non carré. Aussi tous les bits de la base sont passés en revue. Nous avons donc une privacy totale !
5.5 Analyse de la complexité du protocole précédent :

Commençons par définir les différents paramètres :
N : le nombre de films.
B : le nombre de bits par film.
k : la taille en nombre de bits du module RSA.
Suivant ce principe, nous aurons en moyenne N/2 produits pour chaque bit : la complexité temporelle en terme de
nombre de multiplications est donné par O(B × (N/2)).
L’autre chose intéressante à voir est la complexité en espace : ici le retour du serveur sera composé de B nombres sur
k bits ce qui nous donne un total de B × k bits de réponse.
L’application qui est donnée en exemple est la suivante :

La base de données contient N = 10000 films.
Chaque film pèse 1Go, ce qui veut dire que B = 8 × 109
Le nombre de bits de sécurité du module RSA est k = 2048
Nous en déduisons donc qu’il y aura besoin de 8 × 109 × 5000 = 4 × 1014 multiplications (qui se font chacune en O(k 2 )).
Au niveau de la taille de la réponse du serveur, nous avons 8 × 109 × 2048 = 1.638 × 1013 bits de réponse, ce qui nous
donne environ 2 To de données à télécharger. Cela est tout de même mieux que ce que nous avions pour notre solution
naı̈ve qui aurait demandé 10 To de téléchargement.
La conclusion est : c’est nul ! Cette conclusion n’est valide que dans le cas de l’exemple d’une base de données
contenant des films. Si nous arrivons à maximiser la valeur de N (le nombre d’enregistrements), et minimiser la valeur
B (le nombre d’octets par enregistrement de la table), nous aurons quelque chose de plutôt efficace.
Ce protocole est donc plutôt adapté aux DNS, aux dossiers médicaux, aux empreintes ADN, ...
5.6 Chiffrement homomorphe :

Un chiffrement est dit homomorphe s’il vérifie la relation suivante : Enc(a) × Enc(b) = Enc(a + b) (ce qui a comme
conséquence que Enc(a)b = Enc(a × b)).
Nous pourrions envoyer ri = Enc(0) et ri0 = C(1) car le serveur ne saura pas distinguer les 2 vu qu’il ne connaı̂t pas
la clé. Ensuite, le serveur va nous calculer sj = Enc(r1 )b1,j × Enc(r2 )b2,j × ... × Enc(rN )bN,j . Grâce aux propriétés du
chiffrement homomorphe, nous obtenons que sj = Enc(0 × b1,j + 0 × b2,j + ... + 1 × bi0 ,j + ... + 0 × bN,j ) qui est soit
égal à C(0) soit égal à C(1) en fonction de la valeur de bi0 ,j ce qui va permettre à l’utilisateur de distinguer les bits.
Un exemple d’algorithme de chiffrement homomorphe est le chiffrement de Paillier (avec un module RSA n sur k bits)
où la taille du chiffré sera 2 × k : facteur d’expansion de 2 (la taille du chiffré est 2 fois la taille du clair).
Je ne vois pas trop ce que cela change / améliore dans la méthode précédente : il serait peut être possible de diviser
chaque colonne en blocs de k bits ce qui serait éventuellement plus efficace au niveau des multiplications ainsi que la
taille de la réponse.
27 / 114 Année 2023 - 2024

6 Protocoles Zero-Knowledge :
6.1 Exercice 18 page 40 :
Voici une variation du protocole d’authentification fiat-shamir sur du logarithme discret :
Clés : nous choisirons p et q 2 grands entiers tels que q divise p − 1, g un entier d’ordre q modulo p. La clé secrète est
tout simplement une valeur a aléatoire entre 0 et q − 1, la clé publique sera A = g −a (mod p).
Le protocole en 4 étapes entre le prouveur et le vérifieur est le suivant :
Alice choisit k aléatoire entre 0 et q − 1 et envoie K = g k (mod p)
Bob choisit un défi r aléatoire entre 0 et q − 1 et l’envoie à Alice.
Alice calcule la réponse y = k + a × r (mod q)
Pour finir, Bob calcule g y × Ar = g k+ar × g −ar = g k et vérifie que c’est bien égal à K (mod p).
Question 1 : faire un schéma :
Question 2 : montrez que le protocole est cohérent et que la probabilité de triche est 1/q.
Pour montrer que ce protocole est cohérent, il nous suffit de prouver que le prouveur (Alice) peut toujours donner une
réponse au troisième message peu importe le défi qu’elle a reçu plus tôt : c’est évident, il lui suffit de calculer k + a × r
(mod q) ce qui est toujours possible peu importe la valeur de r.
Une autre question est : pourquoi ça marche ? Nous l’avons déjà montré dans la définition du protocole que lors d’une
exécution honnête, nous aurons forcément g y × Ar = g k .
Pour trouver la probabilité de triche, il va falloir que nous modélisons ce que l’attaquant a le droit et pas le droit de
faire : ce dernier se fait passer pour le prouveur, il connaı̂t donc k mais aussi la clé publique et le défi, il lui manque juste
a. Le seul moyen pour cet attaquant de tricher est de deviner la valeur de a et il a une chance sur q de faire le bon guess.
Question 3 : quel rapport et intérêt par rapport à Fiat-Shamir :

Ce protocole est une variation basée sur du logarithme discret du protocole Fiat-Shamir (qui, lui, se basait sur le
problème du résidu quadratique modulo un produit de nombres premiers).
La probabilité de triche étant bien plus faible que Fiat-Shamir, au lieu d’avoir 80 itérations pour 80 bits de sécurité,
nous pourrions en avoir besoin de juste une seule (si la valeur de q est assez élevée).
6.2 Création d’algorithmes de signature :

Il faut déjà voir la différence fondamentale entre la signature et l’authentification : dans une signature, nous voulons
prouver à tout le monde notre identité alors que dans l’authentification nous voulons juste prouver à une seule personne
notre identité : dans une authentification, le vérifieur ne peut pas prouver à une tierce personne notre identité. La
différence fondamentale entre l’authentification et la signature est doncc que l’authentification est interactive alors que
la signature non.
L’idée pour transformer un algorithme d’authentification zero knowledge en signature consiste simplement à faire une
exécution du protocol avec soi-même et trouver un moyen de prouver aux autres que le défi est aléatoire.
Pour rappel, un protocole d’authentification à 3 passes est constitué des étapes suivantes : engagement, défi, réponse
(et une dernière phase de vérification mais qui ne correspond à aucun message).
Nous pouvons maintenant définir un algorithme de signature pour le message m grâce à un protocole d’authenti-
fication :
28 / 114 Année 2023 - 2024

Une constante t sera définie indiquant le nombre d’exécutions du protocole d’authentification, cela permettra de régler
le nombre de bits de sécurité (par exemple avec le protocole de Fiat-Shamir basé sur le résidu quadratique, nous
pouvons prendre t = 80 pour avoir une sécurité de 80 bits).
Les différents composants que nous allons utiliser dans la suite seront les suivants :
E = E1 ||E2 ||...||Et : les différents engagements choisis aléatoirement.
D = d1 , ..., dt = H(m||E) avec m le message et H une fonction de hachage.
R1 , ..., Rt les réponses au différents challenges calculées par le signataire.
La signature d’un message sera Sign(m) = (E, R).
Pour la vérification, il suffira de calculer D = H(m||E) et vérifier les t exécutions du protocole d’authentification.
Pour qu’une personne soit capable de forger une signature, il faudrait qu’elle arrive à calculer les bonnes réponses
sans connaı̂tre la clé privée du signataire : cela revient à casser toutes les exécutions du protocole d’authentification
zero knowledge pour les t exécutions en même temps (si nous faisions le protocole tour par tour, la sécurité serait
grandement impactée car il n’y aurait plus qu’à casser les tours indépendamment les uns des autres).
Par exemple, sur Fiat-Shamir nous aurons t = 128 tours, n = 2048 bits (pour chaque Ei et Ri ), la taille de la signature
sera donc de n × t = 2048 × 128 = 262144 bits ce qui équivaut à 65536 octets, la taille de la clé publique sera elle de
2 × 2048 = 4096 bits ce qui nous donne 512 octets pour la version Fiat-Shamir sur le résidu quadratique et 256 octets
pour la version Fiat-Shamir sur le logarithme discret.
Nous avons donc 2 types de signatures :

Le modèle ”hash and sign” : nous allons calculer Sign(m) = F −1 (hash(m)) et la vérification sera tout simple-
ment F (sign) = hash(m). Cela demande tout de même d’avoir une fonction à trappe F totalement inversible :
exemple de la signature RSA, mais du coup cela peut être beaucoup plus difficile à trouver. Pour ce premier
modèle, nous réalisons du masquage, sous forme de trapdoor : grosse clé publique et petite signature.
Le modèle ”proof of knowledge” : c’est l’exemple que nous avons vu avant avec Fiat-Shamir, nous allons tout
simplement prouver au vérifieur que nous connaissons x tel que y = F (x) ce qui est plus facile à faire qu’avant.
Ici, nous aurons de grosses signatures et de petites clés publiques.
Pour de la signature avec des codes : il y a une partie que l’on sait décoder et une partie qui n’est pas décodable, il
est donc difficile d’avoir le premier modèle.
29 / 114 Année 2023 - 2024

7 Courbes elliptiques :
7.1 Introduction :
Une courbe elliptique est tout simplement définie par la relation suivante :
y 2 = x3 + a × x + b
Voici, ci-dessous 2 exemples de courbes elliptiques pour certaines valeurs de a et b :
(a) y 2 = x3 − 10x + 10 (b) y 2 = x3 − 5x + 13
Il existe une formule plus générale pour les courbes elliptiques qui est l’équation de Weierstras :
y 2 + a1 × xy + a3 × y = x3 + a2 × x2 + a4 × x + a6
7.2 Définition de l’addition :

Les courbes elliptiques sur R permettent de définir l’addition de 2 points. Le cas de base est l’addition de 2 points
différents, P et Q : il suffit de tracer la droite entre ces 2 points et récupérer le 3ème point d’intersection avec la courbe
puis prendre son symétrique par rapport à l’axe x :
30 / 114 Année 2023 - 2024

2 autres cas particuliers peuvent se produire : si P = Q, à ce moment là nous ferons un doublement : 2P = P + P et
il faudra prendre la tangente à la courbe au point P , si Q = −P nous aurons comme résultat le point à l’infini (qui
est le neutre pour l’additions sur les courbes elliptiques) :
Nous pouvons maintenant calculer les additions dans les différents cas.
Le cas le plus simple est le cas où nous faisons P + −P ce qui nous permet d’obtenir le point à l’infini : 0.
Pour les autres cas nous chercherons les points qui vérifient à la fois y 2 = x3 + a × x + b et y = a′ × x + b′ . Nous
pouvons injecter la seconde relation dans la première pour obtenir :
(a′ × x + b′ )2 = x3 + a × x + b ⇔ x3 − a′2 × x2 + (a − 2 × a′ × b′ ) × x + b − b′2 = 0
Addition : P + Q : nous allons commencer par trouver l’équation de la droite passant par ces 2 points : le coeffi-
cient directeur de cette droite est donné par a′ = (Q.y − P.y)/(Q.x − P.x) et l’ordonnée à l’origine de cette droite
est b′ = P.y − a′ × P.x. Nous n’avons donc plus qu’à résoudre l’équation cubique qui a été donnée précédemment,
cela semble très dur à première vue, mais souvenez vous que nous avons 2 solutions à cette équation : P et Q qui
appartiennent à la fois à la droite et à la courbe elliptique. Donc :
x3 − a′2 × x2 + (a − 2 × a′ × b′ ) × x + b − b′2 = (x − P.x)(x − Q.x)(x − R.x)
⇔ x3 + k1 × x2 + k2 × x + k3 = x3 − (P.x + Q.x + R.x) × x2 + (P.x × Q.x + P.x × R.x + Q.x × R.x) × x − P.x × Q.x × R.x


 1=1
k = −a′2 = −(P.x + Q.x + R.x)

1
⇔


 k2 = a − 2 × a′ × b′ = P.x × Q.x + P.x × R.x + Q.x × R.x
k3 = b − b′2 = P.x × Q.x × R.x

Or nous n’avons besoin que d’une seule de ces équations pour trouver R.x, prenons donc la plus simple : a′2 =
P.x + Q.x + R.x et donc :
2
′2 Q.y − P.y
R.x = a − P.x − Q.x = − P.x − Q.x
Q.x − P.x
Pour trouver le R.y, il suffit d’appliquer la formule de la fonction affine à ce point :
R.y = a′ × R.x + b′ = a′ × R.x − a′ × P.x + P.y = a′ × (R.x − P.x) + P.y
√
Doublement
√ : 2P = P + P : nous pouvons dire que y = f (x) = x3 + a × x + b et donc f ′ (x) = (3x2 + a)/(2 ×
x3 + ax + b) = (3x2 + a)/2y qui est la formule du nombre dérivé et nous permettra de trouver le coefficient directeur
de la droite représentant la tangente. Nous savons donc que a′ = (3 × P.x2 + a)/(2 × P.y) et nous pouvons prendre
b′ = P.y − a′ × P.x.
En utilisant les mêmes techniques que précédemment, nous pouvons montrer que R.x = a′2 − 2 × P.x et R.y =
a′ × (R.x − P.x) + P.y.
31 / 114 Année 2023 - 2024

7.3 Courbes elliptiques sur des entiers :

Le principe est exactement le même qu’avant sauf que nous allons nous placer sur un corps fini, par exemple Z/pZ ou
Fq . La seule chose qui change est donc de rajouter un modulo :
y 2 = x3 + a × x + b (mod p)
a et b sont des nombres entre 0 et p − 1, et il faut rajouter des modulos dans toutes les équations pour calculer
l’addition / le doublement.
Vu que nous sommes sur les entiers, nous n’aurons plus une courbe mais plutôt un ensemble de points qui vérifient
l’équation donnée au départ. Voici un exemple avec y 2 = x3 − 6x + 7 (mod 113) :
Nous noterons E(K) = {(x, y) ∈ K2 |y 2 = x3 + a × x + b} ∪ {∞ = 0} l’ensemble des points de la courbe elliptique.
Nous allons également avoir besoin de parler de la caractéristique d’un corps : c’est le nombre de fois qu’il faut
ajouter l’élément neutre de la multiplication pour avoir celui de l’addition, il s’agit du plus petit c non nul tel que
pour tout k dans l’ensemble nous avons k × c = 0. Dans Z/pZ, nous avons que la caractéristique est égale à p. Un
autre exemple serait dans Z/(p × q)Z où la caractéristique est min(p, q).
Ensuite, le prof a parlé de la simplification de départ : y 2 + a1 × xy + a3 × y = x3 + a2 × x2 + a4 × x + a6 (mod p) :
Si Car(K) = 3 : on s’en fout.
Si Car(K) = 2 (cas GF (2q )) :
Si a1 ̸= 0, alors (x, y) → (a21 × x + a3 /a1 , a31 × y + (a21 × a4 + a23 )/a31 ) et l’équation devient de la forme
y 2 + xy = x3 + a × x2 + b (cas non super-singulier).
Si a1 = 0, alors (x, y) = (x + a2 , y) et l’équation devient de la forme y 2 + c × y = x3 + a × x + b (cas
super-singulier).
Si Car(K) ̸= 2 et Car(K) ̸= 3 : nous pouvons prendre (x, y) → ((x − 3 × a21 − 12 × a2 )/36, (y − 3 × a1 × x)/216 −
(a31 + 4 × a1 × a2 − 12 × a3 )/24). La forme simplifiée deviendra la forme usuelle : y 2 = x3 + a × x + b. En fait il
faut que la caractéristique soit différente de 2 et 3 car les constantes aux dénominateurs sont des multiples de
ces 2 nombres et donc nous pourrions diviser par 0.
En remarque finale, notez que le nombre de courbes elliptiques de la forme y 2 = x3 + a × x + b sur le corps Fq à q
éléments est q 2 car nous pouvons prendre tous les couples possibles pour les valeurs de a et b et ces dernières doivent
être des éléments de Fq .
32 / 114 Année 2023 - 2024

7.4 Trouvons les points de quelques courbes :

Dans la suite de cette partie, nous allons nous placer sur K = F5 = Z/5Z.
Les 4 équations à étudier (nous voudrons récupérer tous les points) seront les suivantes :
f1 : y 2 = x3 + x + 2
f2 : y 2 = x3 + x
f3 : y 2 = x3 + 2x
f4 : y 2 = x3 + 3x
Une première façon de trouver tous les points consiste à prendre tous les couples possibles et vérifier s’ils vérifient
l’équation, voici ce que cela donnerait pour la fonction f1 :
x\y 0 1 2 3 4
0 02 = 0 ̸= 2 = 03 + 0 + 2 : ∈
/ 1 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 1 ̸= 2 : ∈
/
1 02 = 0 ̸= 4 = 13 + 1 + 2 : ∈
/ 1 ̸= 4 : ∈
/ 4=4 : ∈ 4=4 : ∈ 1 ̸= 4 : ∈
/
2 3
2 0 = 0 ̸= 2 = 2 + 2 + 2 : ∈ / 1 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 1 ̸= 2 : ∈
/
3 02 = 0 ̸= 2 = 33 + 3 + 2 : ∈
/ 1 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 4 ̸= 2 : ∈
/ 1 ̸= 2 : ∈
/
4 02 = 0 = 0 = 43 + 4 + 2 : ∈ 1 ̸= 0 : ∈/ 4 ̸= 0 : ∈
/ 4 ̸= 0 : ∈
/ 1 ̸= 0 : ∈
/
Cette courbe possède donc 4 points : (1, 2), (1, 3), (4, 0) ainsi que le point à l’infini.
Il existe une méthode un peu plus rapide, elle pourrait être qualifiée de méthode par ”meet in the middle”, appliquons
là sur f2 . Nous allons commencer par voir les différentes valeurs que peut prendre y 2 :
y 0 1 2 3 4
y2 0 1 4 4 1
Et ensuite, nous allons également calculer toutes les différentes valeurs de x3 + a × x + b :
x 0 1 2 3 4
x3 + 1 × x + 0 0 2 0 0 3
Nous allons ensuite regarder les endroits où nous avons la même valeur : nous avons 3 valeurs de x qui donnent 0 et
une valeur de y qui donne 0 ce qui nous donne 3 points. Pour les valeurs de x où nous avons 2 et 3, elles n’apparaissent
pas dans les résultats de y 2 et donc elles ne donnent aucun point. Finalement, nous avons 4 points pour cette courbe
également : (0, 0), (2, 0), (3, 0) et encore une fois le point à l’infini.
Voici maintenant la fonction f3 :

y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + 2x 0 3 2 3 2
Nous pouvons cette fois-ci voir qu’il n’y aura que 2 points : (0, 0) et le point à l’infini.
Et terminons par la fonction f4 :

y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + 3x 0 4 4 1 1
Cette fois-ci, nous avons plus de possibilités :
0 : le point (0, 0) lui est associé.
1 : 4 points lui sont associés : (3, 1), (3, 4), (4, 1), (4, 4)
2 : aucun point ne lui est associé.
3 : aucun point ne lui est associé.
4 : 4 points lui seront associés : (1, 2), (1, 3), (2, 2), (2, 3)
Cette courbe sera donc composée de 10 points : (0, 0), (1, 2), (1, 3), (2, 2), (2, 3), (3, 1), (3, 4), (4, 1), (4, 4) ainsi que le
point à l’infini.
En remarque finale, nous pouvons essayer de trouver des bornes sur le nombre de points d’une courbe. Tout d’abord
une approximation naı̈ve : le nombre minimum de points est forcément 1 car toute courbe elliptique contient le point
à l’infini, le nombre maximum de points est lui donné par q 2 (si la courbe est sur un corps à q éléments) car x et y
peuvent chacun prendre q valeurs différentes.
Le théorème de Hasse donne des bornes bien meilleures : soit E(K) une courbe elliptique sur K = Fq , alors le
nombre de points de la courbe est compris entre les bornes suivantes :
√ √
q + 1 − 2 × q <= #E(Fq ) <= q + 1 + 2 × q
La valeur t = #E(Fq ) − q − 1 sera appelée la trace de la courbe.
Pour notre exemple, ce théorème prévoit que le nombre de points minimal est 1.54 (ce qui donne une borne min à 2)
et le nombre de points maximal est 10.46 (ce qui donne une borne max à 10) : tous les exemples que nous avons fait
sont confirmés par la théorie et nous avons même une courbe qui atteint le nombre minimal de points et une courbe
qui atteint le nombre maximal.
33 / 114 Année 2023 - 2024

7.5 Quelques exemples d’additions :

La relation d’addition que nous avons décrite plus haut permet de donner à l’ensemble des points de la courbe elliptique
une structure de groupe (dont l’élément neutre pour l’addition sera le point à l’infini).
Pour rappel, voici la formule d’addition de 2 points différents P et Q :
2 !
y2 − y1 y2 − y1
(x3 , y3 ) = − x1 − x2 , × (x1 − x3 ) − y1
x2 − x1 x2 − x1
Et maintenant la formule de doublement :

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
Calculons (4, 0) + (1, 2) pour la courbe f1 :

Ces 2 points sont différents, nous allons donc utiliser la formule de l’addition conventionelle :
Coefficient directeur : (y2 − y1 )/(x2 − x1 ) = (2 − 0)/(1 − 4) = 2/ − 3 = 2/2 = 1 (mod 5)
x3 = 12 − 4 − 1 = 1 − 5 = 1 (mod 5)
y3 = 1 × (4 − 1) − 0 = 3
Nous obtenons donc (4, 0) + (1, 2) = (1, 3) ce qui a de quoi nous rassurer car c’est un point de la courbe.
Calculons 2 × (4, 0) pour la courbe f1 : y 2 = x3 + 1 × x + 2 :

Coefficient : (3 × x21 + a)/(2 × y1 ) = (3 × 42 + 1)/(2 × 0) (mod 5) : on divise par 0 ! ! !
Vu que nous sommes en présence d’une division par 0, le nouveau point est le point à l’infini : 2 × (4, 0) = 0.
Terminons pour la courbe f1 par 2 × (1, 2) :

Coefficient : (3 × x21 + a)/(2 × y1 ) = (3 × 12 + 1)/(2 × 2) = 4/4 = 1 (mod 5)
x3 = 12 − 2 × 1 = −1 = 4 (mod 5)
y3 = 1 × (1 − 4) − 2 = −3 − 2 = −5 = 0 (mod 5)
Donc, finalement : 2 × (1, 2) = (4, 0).
Calculons (1, 2) + (2, 3) pour la courbe f4 :

Coefficient directeur = (y2 − y1 )/(x2 − x1 ) = (3 − 2)/(2 − 1) = 1/1 = 1 (mod 5)
x3 = 12 − 1 − 2 = −2 = 3 (mod 5)
y3 = 1 × (1 − 3) − 2 = −2 − 2 = −4 = 1 (mod 5)
Nous avons donc que (1, 2) + (2, 3) = (3, 1) : qui est encore un point de la courbe f4 , nous pouvons donc être confiants
de notre résultat.
Terminons pour f4 : y 2 = x3 + 3x par 2 × (2, 3) :

Coefficient : (3 × x21 + a)/(2 × y1 ) = (3 × 22 + 3)/(2 × 3) = 15/6 = 0/1 = 0 (mod 5)
x3 = 02 − 2 × 2 = −4 = 1 (mod 5)
y3 = 0 × (2 − 1) − 3 = −3 = 2 (mod 5)
Finalement, nous pouvons dire que 2 × (2, 3) = (1, 2).
34 / 114 Année 2023 - 2024

8 Courbes elliptiques partie 2 - structure des courbes elliptiques :

8.1 Rappels sur ce qu’est un groupe :
Un groupe est un ensemble auquel nous aurons ajouté une relation, par exemple (G, ⋆) et qui possède les propriétés
suivantes :
⋆ est une loi de composition interne (LCI) : cela veut dire qu’il faut que l’addition de 2 éléments de G donne
un élément de G.
⋆ est associative : ∀a, b, c ∈ G3 : (a ⋆ b) ⋆ c = a ⋆ (b ⋆ c)
Élément neutre : il existe un élément noté e tel que ∀a ∈ G, a ⋆ e = e ⋆ a = a (cet élément neutre est unique).
Symétrique : pour chaque élément a ∈ G, il existe b ∈ G tel que a ⋆ b = b ⋆ a = e (ce symétrique est unique).
Si en plus la relation ⋆ est commutative : ∀a, b ∈ G2 , a ⋆ b = b ⋆ a, nous dirons que le groupe est commutatif / abélien.
8.2 Morphismes :
Un morphisme est une application d’une structure algébrique vers une autre structure algébrique de même type.
Il en existe plusieurs types :
Endomorphisme : application dont la structure algébrique source et celle but sont identiques. Par exemple, un
endomorphisme d’ensembles serait f : E → E, un endomorphisme de groupes pourrait être f : (G, ⋆) → (G, ⋆).
Monomorphisme : associé à la notion de fonction injective dans les ensembles.
Épimorphisme : associé à la notion de fonction surjective dans les ensembles.
Isomorphisme : associé à la notion de fonction bijective, d’ailleurs lorsque 2 structures sont isomorphes nous
pouvons considérer qu’elles sont ”identiques”.
Automorphisme : il s’agit tout simplement de la combinaison d’un endomorphisme et d’un isomorphisme.
8.3 Groupes cycliques, ordre d’un élément et Zn1 ⊕ Zn2 :

Commençons par la notion de sous-groupe engendré par un élément x : dans un groupe additif / multiplicatif, le sous-
groupe engendré par un élément est l’ensemble des multiples / puissances de l’élément considéré, il sera noté < x >.
Par exemple, pour le groupe multiplicatif Z/7 × Z, le sous-groupe engendré par 2 sera < 2 >= {1 = 20 , 2 = 21 , 4 = 22 }
(notez que nous n’avons pas continué après puissance 2 car 23 = 8 = 1 (mod 7)).
L’ordre d’un élément x est le plus petit k tel que : dans un groupe additif k × x = 0 et dans un groupe multiplicatif
xk = 1. Nous pouvons reprendre l’exemple que nous avons donné précédemment : l’ordre de 2 est 3 (remarquez aussi
que c’est la taille du sous-groupe engendré). Comme remarque, notez aussi que l’ordre d’un élément est forcément un
diviseur du nombre d’éléments du groupe (et donc, la nombre d’éléments du sous-groupe engendré est également un
diviseur du nombre d’éléments du groupe de départ).
Un générateur est tout simplement un élément du groupe dont le sous-groupe engendré est égal à tout l’ensemble de
départ, en d’autres termes c’est un élément dont l’ordre est égal au nombre d’éléments du groupe. Un groupe cyclique
est tout simplement un groupe qui possède un générateur, si le groupe ne possède aucun générateur, il n’est pas cyclique.
Prenons l’exemple du groupe (Z/10Z, +) = (Z10 , +) qui possède 10 éléments :

Élément Groupe engendré Ordre
1 < 1 >= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 10 (générateur)
2 < 2 >= {0, 2, 4, 6, 8} 5
3 < 3 >= {0, 3, 6, 9, 2, 5, 8, 1, 4, 7} 10 (générateur)
4 < 4 >= {0, 4, 8, 2, 6} 5
5 < 5 >= {0, 5} 2
6 < 6 >= {0, 6, 2, 8, 4} 5
7 < 7 >= {0, 7, 4, 1, 8, 5, 2, 9, 6, 3} 10 (générateur)
8 < 8 >= {0, 8, 6, 4, 2} 5
9 < 9 >= {0, 9, 8, 7, 6, 5, 4, 3, 2, 1} 10 (générateur)
Nous pouvons également définir des produits cartésiens de l’ensemble précédent, par exemple (Z2 ⊕ Z2 , +) :
a+b (0, 0) (0, 1) (1, 0) (1, 1)
(0, 0) (0, 0) (0, 1) (1, 0) (1, 1)
(0, 1) (0, 1) (0, 0) (1, 1) (1, 0)
(1, 0) (1, 0) (1, 1) (0, 0) (0, 1)
(1, 1) (1, 1) (1, 0) (0, 1) (0, 0)
Ce genre de groupe sera particulièrement utile pour étudier la structure des courbes elliptiques, nous en reparlerons
plus loin. D’ailleurs notez que le groupe (Z1 ⊕ Zn , +) est isomorphe au groupe (Zn , +).
35 / 114 Année 2023 - 2024

8.4 Structure de groupe des courbes elliptiques :

Commençons par le théorème du groupe Courbe Elliptique : soit E une courbe elliptique sur Fq , alors E(Fq )
est isomorphe à Zn1 ⊕ Zn2 où n1 et n2 sont uniquement déterminés tels que n2 divise n1 et n2 divise q − 1.
Si n2 = 1, le groupe sera cyclique : le groupe de la courbe elliptique sera isomorphe à (Z1 ⊕Zn1 , +) ce qui est également
isomorphe à (Zn1 , +) qui possède forcément un générateur : 1. Le nombre de générateurs dans cet ensemble sera φ(n1 )
car tous les nombres premiers avec n1 ne deviendront des multiples de n1 que lorsqu’ils seront multipliés par ce dernier
(vous pouvez aller revoir le tableau de la sous-partie précédente pour mieux comprendre cette ligne).
Si 2 <= n2 <= 4, le groupe sera dit presque cyclique. Il n’est pas cyclique car l’ordre de chaque élément sera au plus
le maximum des ni , donc ici n1 < n2 × n1 .
L’intérêt de trouver ces isomorphismes est de simplifier l’étude des courbes elliptiques en disant qu’elles sont équivalentes
à des groupes plus simples dont nous connaissons les propriétés.
Imaginons une courbe à 4 points, les seules possibilités sont donc : 1 × 4 car 1 divise 4 et 1 divise 5 − 1 = 4 ainsi que
2 × 2 qui est également possible car 2 divise 2 et 2 divise 5 − 1 = 4.
Nous allons chercher à savoir auquel de ces 2 groupes cette courbe elliptique est isomorphe. Vu que dans le premier cas
nous savons que le groupe résultant est cyclique (possède un générateur) et dans le seond cas non, nous avons juste à
cherher un générateur : si nous en trouvons un nous serons dans le cas 1 × 4, et si nous n’en trouvons pas nous serons
dans le cas 2 × 2.
La seule façon de faire pour répondre à cette question est de tester tous les points. Nous avons 2 axes pour simplifier
cette recherche et avoir moins de points à chercher :
Nous savons que le nombre de générateurs s’il y en a sera φ(4) = 2 : cela veut dire que si nous avons déjà testé
3 points et qu’aucun n’est un générateur, pas besoin de tester le quatrième.
Nous savons que l’ordre de chaque élément est un diviseur du nombre d’éléments du groupe, nous n’aurons
donc qu’à tester les valeurs de 1P , 2P et 4P pour voir si l’une d’entre elles est le neutre (le point à l’infini).
D’ailleurs, nous pouvons encore simplifier : si ni 1P ni 2P ne sont le point à l’infini, alors nous sommes forcément
en présence d’un générateur car obligatoirement 4P sera le point à l’infini.
Nous allons donc ré-étudier les courbes pour lesquelles nous avions trouvé les points.
f1 : y 2 = x3 + x + 2 : 4 points : (1, 2), (1, 3), (4, 0), 0 :

Les 2 possibilités sont 1 × 4 et 2 × 2.
Le nombre de générateurs s’il y en a est φ(4) = 2, les multiples à tester sont 1P, 2P .
0 : le point à l’infini a pour ordre 1, ce n’est pas un générateur.
(4, 0) : 2 × (4, 0) = 0 car son Y est nul, son odre vaut donc 2 et ce n’est pas un générateur.
(1, 2) : 2 × (1, 2) = (4, 0) : nous avons donc un générateur !
Ce groupe est donc isomorphe à (Z1 ⊕Z4 , +) et donc isomorphe à (Z4 , +) dont nous savons qu’il possède 2 générateurs,
donc (1, 3) est forcément un générateur.
f2 : y 2 = x3 + x : 4 points : (0, 0), (2, 0), (3, 0), 0 : vous voyez tout de suite que ce groupe ne possède pas de générateur
car le doublement de chaque nombre donne le point à l’infini. La structure n’est donc pas Z1 ⊕ Z4 mais Z2 ⊕ Z2 qui
montre les mêmes caractéristiques : le doublement de chaque élément donne le neutre.
f3 : y 2 = x3 + 2x : 2 points, la seule possibilité est donc 1 × 2 qui possède bien un générateur.
f4 : y 2 = x3 + 3x : 10 points : (0, 0), (1, 2), (1, 3), (2, 2), (2, 3), (3, 1), (3, 4), (4, 1), (4, 4), 0 : la seule possibilité est 1 × 10,
2 × 5 n’est pas possible car 2 ne divise pas 5.
f1′ : y 2 = x3 + 4x : ici nous n’avons pas les points, il faut les re-calculer comme nous l’avions fait dans une par-
tie avant. Après ce calcul nous pouvons trouver 8 points : (0, 0), (1, 0), (2, 1), (2, 4), (3, 2), (3, 3), (4, 0), 0 :
Le nombre de générateurs s’il y en a est φ(8) = 4, les multiples à tester sont 1P, 2P, 4P .
0, (0, 0), (1, 0), (4, 0) ont tous soit un ordre de 1 soit de 2, ce ne sont donc forcément pas des générateurs.
(2, 1) : 2 × (2, 1) = (0, 0) : ce n’est donc pas un générateur car 4 × (2, 1) = 0.
Il devait y avoir 4 générateurs, parmi les 8 points 5 n’en sont pas, donc ce groupe est isomorphe à (Z2 ⊕ Z4 , +).
f2′ : y 2 = x3 +4x+1 : encore une fois il faut re-calculer les points qui sont également au nombre de 8 : (0, 1), (0, 4), (1, 1),
(1, 4), (3, 0), (4, 1), (4, 4), 0 :
Le nombre de générateurs s’il y en a est φ(8) = 4, les multiples à tester sont 1P, 2P, 4P .
0, (3, 0) ont soit un ordre de 1 soit de 2, ce ne sont donc forcément pas des générateurs.
(0, 1) : 2 × (0, 1) = (4, 1), 4 × (0, 1) = 2 × (4, 1) = (3, 0) : nous voyons que 1P ̸= 0, 2P ̸= 0 et 4P ̸= 0 donc
forcément 8P = 0 et nous avons un générateur.
Donc le groupe pour cette courbe elliptique est isomorphe à (Z1 ⊕ Z8 , +) et donc à (Z8 , +) et possède 4 générateurs.
36 / 114 Année 2023 - 2024

Nous allons cette fois-ci faire un exemple avec les 3 courbes suivantes (toutes modulo 37) :
y 2 = x3 + 21 ∗ x + 10 : (15, 0), (13, 1), (30, 1), (31, 1), (18, 2), (19, 4), (36, 5), (10, 6), (3, 10), (17, 10), (0, 11),
(4, 11), (33, 11), (29, 12), (27, 13), (9, 15), (35, 16), (25, 18), (25, 19), (35, 21), (9, 22), (27, 24), (29, 25), (0,
26), (4, 26), (33, 26), (3, 27), (17, 27), (10, 31), (36, 32), (19, 33), (18, 35), (13, 36), (30, 36), (31, 36), 0.
y 2 = x3 + 13 ∗ x + 32 : (4, 0), (5, 0), (28, 0), (26, 1), (20, 2), (1, 3), (27, 7), (9, 8), (32, 8), (33, 8), (16, 9), (11,
10), (34, 15), (19, 16), (24, 16), (31, 16), (6, 17), (13, 17), (18, 17), (6, 20), (13, 20), (18, 20), (19, 21), (24, 21),
(31, 21), (34, 22), (11, 27), (16, 28), (9, 29), (32, 29), (33, 29), (27, 30), (1, 34), (20, 35), (26, 36), 0.
y 2 = x3 + 36 ∗ x + 27 : (16, 0), (12, 2), (29, 2), (33, 2), (5, 6), (27, 6), (0, 8), (1, 8), (36, 8), (9, 9), (24, 10), (28,
11), (2, 12), (35, 13), (34, 15), (22, 16), (7, 17), (13, 18), (13, 19), (7, 20), (22, 21), (34, 22), (35, 24), (2, 25),
(28, 26), (24, 27), (9, 28), (0, 29), (1, 29), (36, 29), (5, 31), (27, 31), (12, 35), (29, 35), (33, 35), 0.
Ces 3 courbes possèdent chacune 36 points (il semble que ce soit le nombre de points minimum pour avoir plus de 2
possibilités), nous aurons donc à chaque fois 4 possibilités :
n2 × n1 = 1 × 36 (possède φ(36) = 12 générateurs)
n2 × n1 = 2 × 18 (ne possède aucun générateur)
Vu que le nombre d’éléments pour chaque courbe est 36, l’ordre de chaque élément peut être un des diviseurs de 36 :
1, 2, 3, 4, 6, 9, 12, 18, 36.
Calculons les ordres de chaque point de la première courbe :

0 et (15, 0) auront chacun un ordre de soit 1 soit 2.
(13, 1) :
- 2 × (13, 1) = (36, 32)
- 3 × (13, 1) = 2 × (13, 1) + (13, 1) = (36, 32) + (13, 1) = (35, 16)
- 4 × (13, 1) = 2 × (2 × (13, 1)) = 2 × (36, 32) = (27, 13)
- 6 × (13, 1) = 2 × (3 × (13, 1)) = 2 × (35, 16) = (15, 0)
- 9 × (13, 1) = 3 × (13, 1) + 6 × (13, 1) = (35, 16) + (15, 0) = (35, 21)
- 12 × (13, 1) = 2 × (6 × (13, 1)) = 2 × (15, 0) = 0 : ce n’est donc pas un générateur.
(30, 1) : 2×(30, 1) = (3, 10), 3×(30, 1) = (0, 26), 4×(30, 1) = (19, 33), 6×(30, 1) = (36, 5), 9×(30, 1) = (35, 16),
12 × (30, 1) = (27, 24), 18 × (30, 1) = (15, 0) : nous avons donc un générateur !
Vu que nous avons trouvé un générateur, le groupe associé à cette première courbe est donc isomorphe à (Z1 ⊕ Z36 , +)
qui est lui-même isomorphe à (Z36 , +).
Pour la seconde courbe, calculons également les ordres de chaque point :

Point Ordre Point Ordre Point Ordre Point Ordre Point Ordre Point Ordre
(4, 0) 2 (5, 0) 2 (28, 0) 2 (26, 1) 18 (20, 2) 6 (1, 3) 3
(27, 7) 18 (9, 8) 18 (32, 8) 9 (33, 8) 6 (16, 9) 9 (11, 10) 18
(34, 15) 18 (19, 16) 18 (24, 16) 6 (31, 16) 9 (6, 17) 18 (13, 17) 18
(18, 17) 18 (6, 20) 18 (13, 20) 18 (18, 20) 18 (19, 21) 18 (24, 21) 6
(31, 21) 9 (34, 22) 18 (11, 27) 18 (16, 28) 9 (9, 29) 18 (32, 29) 9
(33, 29) 6 (27, 30) 18 (1, 34) 3 (20, 35) 6 (26, 36) 18 0 1
Vous pouvez remarquer que l’ordre maximal d’un élément est 18, cela veut dire que le groupe de la courbe elliptique
actuelle est isomorphe à (Z2 ⊕ Z18 , +) !
Voici un dernier exemple avec la troisième courbe :

Point Ordre Point Ordre Point Ordre Point Ordre Point Ordre Point Ordre
(16, 0) 2 (12, 2) 3 (29, 2) 12 (33, 2) 12 (5, 6) 6 (27, 6) 3
(0, 8) 6 (1, 8) 12 (36, 8) 12 (9, 9) 6 (24, 10) 4 (28, 11) 3
(2, 12) 12 (35, 13) 12 (34, 15) 12 (22, 16) 12 (7, 17) 3 (13, 18) 6
(13, 19) 6 (7, 20) 3 (22, 21) 12 (34, 22) 12 (35, 24) 12 (2, 25) 12
(28, 26) 3 (24, 27) 4 (9, 28) 6 (0, 29) 6 (1, 29) 12 (36, 29) 12
(5, 31) 6 (27, 31) 3 (12, 35) 3 (29, 35) 12 (33, 35) 12 0 1
Cette fois-ci, l’ordre maximal d’un élément est 12 : le groupe est (Z3 ⊕ Z12 , +).
En fait, soit k l’ordre maximal d’un élément, le groupe de la courbe est isomorphe à (Zn/k ⊕ Zk , +).
8.5 Les courbes elliptiques en crypto :

Pour la cryptographique, nous utiliserons le corps Fq pour les éléments de chaque point : nous nous placerons doncc
dans E(Fq ). Aussi, ce groupe possède en général un GROS sous-groupe cyclique de taille de l’ordre de q ou q/2
(n2 = 2) ou q/3 (n2 = 3) voire q/4 (n2 = 4) avec une bonne probabilité. Comme vous pouvez vous en douter, nous
nous placerons dans ce gros sous-groupe cyclique de générateur p : < p >= {0×P, 1×P, ..., (#E(Fq )/n2 )×P = n1 ×P }
37 / 114 Année 2023 - 2024

Si l’on sait que le nombre d’éléments de la courbe, noté #E(Fq ) = p avec p un nombre premier, nous avons forcément
que n2 × n1 = 1 × p = p ce qui nous donnera forcément un groupe cyclique.
Elliptic Curve Discrete Logarithm problem (ECDLP) :

Le problème est très similaire au logarithme discret dans les entiers : étant donnée une courbe sur Fq , P un générateur
d’ordre n d’un gros sous-groupe de E(Fq ), sachant P et y = x × P il est difficile de retrouver x.
Dans un Diffie-Hellman sur des courbes elliptiques (ECDH), le secret commun ne sera plus g a×b mais a × b × P .
Sur les courbes elliptiques (et contrairement aux entiers modulo p) il n’y a que l’addition : nous n’ajoutons donc
√
pas de structure inutile et du coup les meilleures attaques sont en O( q) alors que pour le logarithme discret c’est
√
plutôt en 2α× n×log(n) . Voici un tableau pour comparer le nombre de bits de clé qu’il faut dans les 2 cas pour obtenir
un certain niveau de sécurité :
Sécurité Nombre de bits RSA Nombre de bits ECC
280 1024 160
2112 2048 224
128
2 3072 256
2196 7680 392
2256 15360 512
Comme vous pouvez le voir les tailles de clés sont plus petites sur les courbes elliptiques (dû au fait que la meilleure
√
attaque est en O( q)) mais le coût de calcul est plus grand : pour faire une addition sur les courbes elliptiques il faut
10 multiplications sur Fq alors que pour faire a × b sur Fq il n’y a qu’une seule multiplication à faire.
La question est d’où vient ce ”10 multiplications” : si nous nous intéressons à la formule pour faire l’addition de 2
points nous pouvons remarquer un inverse modulaire, dont nous considèrerons qu’il prendra 80 multiplications. Les
10 multiplications précédentes sont obtenues en changeant la façon de les additions de points sont réalisées.
La solution que nous avons évoquée juste avant se base sur un système de coordonnées modifié :
Affine : c’est la représentation que nous avons actuellement avec le point (x, y).
Projectives : nous associerons au point (x, y) le point (λ × x, λ × y, λ). Soit maintenant un point (x, y, z) pour
revenir en arrière il suffit de calculer (x/z, y/z) (il faut donc que z ne soit pas nul).
Jacobiennes : nous associerons au point (x, y) le point (λ2 × x, λ3 × y, λ). Soit le point (x, y, z), nous pourrons
revenir en arrière en calculant (x/z 2 , y/z 3 ).
De manière générale, nous associerons le point (x, y) au point (λc × x, λd × y, λ) et pour revenir en arrière il suffira de
calculer (x/z c , y/z d ). Ensuite, chaque couple (c, d) donne son nom a un certain système de coordonnées : pour (1, 1)
nous aurons les coordonnées projectives et pour (2, 3) nous aurons les coordonnées jacobiennes.
Pour les coordonnées projectives, il suffit de remplacer dans l’équation chaque x par X/Z 2 et chaque y par Y /Z 3 et
tout multiplier par z 6 ce qui nous donne comme nouvelle équation : Y 2 = X 3 + a × X × Z 4 + b × Z 6 .
L’intérêt est qu’il n’y a plus d’inverse modulaire, et il reste environ 10 multiplications.
8.6 Quelques courbes elliptiques connues :

La première est Curve25519 qui est beaucoup utilisée pour faire du ECDH. La courbe utilisée est y 2 = x3 +486662x2 +x
(qui est légèrement différente du type de courbe vu jusqu’à présent), le nombre premier pour le modulo est 2255 − 19
et le point de base est x = 9 (noté que seulement le x est donné car un type d’arithmétique a été développé utilisant
seulement la coordonnée x pour ce genre de courbe). Elle est beaucoup utilisée pour du ECDH.
Nous avons également la courbe NIST P-256 qui a été définie par la NSA. Elle montre de grandes constantes dont la
génération n’a pas été expliquée, il est donc possible de penser que les créateurs de cette courbe ont mis une backdoor
mathématique en choisissant bien ces nombres (ce qui en plus ne serait pas suprenant venant de la NSA).
secp256k1 est une autre courbe qui est utilisée dans le bitcoin.
Nous avons également des courbes sur des extensions, par exemple B 163, une courbe sur F2163 .
8.7 Meilleure attaque sur les courbes elliptiques :

Nous allons nous placer dans le cas d’une courbe elliptique, nous avons accès aux points P et Q avec Q = x × P . P
sera le générateur du groupe de la courbe : # < P >= n.
Nous supposerons que nous connaissons 2 couples : (c1 , d1 ) et (c2 , d2 ) tels que c1 × P + d1 × Q = c2 × P + d2 × Q.
Tout d’abord, nous allons montrer que si nous connaissons les 2 couples de valeurs, nous pouvons retrouver x :
c1 × P + d1 × Q = c2 × P + d2 × Q
c1 × P + d1 × x × P = c2 × P + d2 × x × P
((c1 − c2 ) − x × (d2 − d1 )) × P = 0
(c1 − c2 ) − x × (d2 − d1 ) = 0 (mod n) (rappel : n : l’ordre du groupe engendré par P )
x = (c1 − c2 )/(d2 − d1 ) (mod n)
38 / 114 Année 2023 - 2024

Nous allons générer plein de couples (ci , di√

) et nous cherchons tout simplement une collision avec le point généré.
√
La complexité de cette attaque est donc O( n) = O( q) en temps et en mémoire (pensez au paradoxe des anniver-
saires).
La méthode rho de Pollard permet de diminuer la complexité en mémoire.
8.8 Quelques petits bouts de code en Python :

Un programme pour trouver tous les points d’une courbe elliptique :
1 def trouverPoints (a , b , n ) :
2 listePoints = []
3 for y in range (0 , n ) :
4 for x in range (0 , n ) :
5 if ( y * y ) % n == ( x * x * x + a * x + b ) % n :
6 listePoints . append (( x , y ) )
7 listePoints . append (0)
8 return listePoints
Un autre programme pour trouver toutes les courbes elliptiques avec un certain nombre de points :
1 def trouverCourbe ( nombrePoints , n ) :
2 for a in range (0 , n ) :
3 for b in range (0 , n ) :
4 if len ( trouverPoints (a , b , n ) ) == nombrePoints :
5 print ( " y ^2 = x ^3 + " + str ( a ) + " * x + " + str ( b ) )
Voici un autre programme pour faire l’addition de 2 points et le doublement d’un point :
1 def addition ( point1 , point2 , mod ) :
2 try :
3 coefficient = ( point2 [1] - point1 [1]) * pow ( point2 [0] - point1 [0] , -1 , mod )
4 except :
5 return 0
6 x3 = ( coefficient * coefficient - point1 [0] - point2 [0]) % mod
7 y3 = ( coefficient * ( point1 [0] - x3 ) - point1 [1]) % mod
8 x3 = x3 + mod if x3 < 0 else x3
9 y3 = y3 + mod if y3 < 0 else y3
10 return ( x3 , y3 )
11
12 def doublement ( point , mod , a ) :
13 try :
14 coefficient = (3 * point [0] * point [0] + a ) * pow (2 * point [1] , -1 , mod )
15 except :
16 return 0
17 x3 = ( coefficient * coefficient - 2 * point [0]) % mod
18 y3 = ( coefficient * ( point [0] - x3 ) - point [1]) % mod
19 x3 = x3 + mod if x3 < 0 else x3
20 y3 = y3 + mod if y3 < 0 else y3
21 return ( x3 , y3 )
Et pour finir, une dernière fonction pour trouver l’ordre d’un point de la courbe :
1 def ordre ( point1 , mod , a ) :
2 if point1 == 0 :
3 return 1
4 ordre = 2
5 pointCourant = doublement ( point1 , mod , a )
6 while pointCourant != 0 :
7 pointCourant = addition ( pointCourant , point1 , mod )
8 ordre += 1
9 return ordre
39 / 114 Année 2023 - 2024

9 Les lattices (cours de Gaborit) :

9.1 Cryptosystème de Merkle-Hellman (1978) :
Ce cryptosystème est basé sur le problème du sac à dos : on nous donne k objets qui occuperont respectivement une
place si dans notre sac à dos qui est de taille totale N . Le but est de trouver quels objets nous allons mettre dans le
sac de façon à maximiser le poids emporté tout en restant inférieur à N .
En général, ce problème est NP-complet. Il y a tout de même des cas précis dans lesquels il est facile de le résoudre.
L’exemple de cas facile correspond au cas où les si forment une suite hypercroissante, c’est à dire une suite dans
laquelle le terme n est strictement supérieur à la somme de tous les précédents. Un exemple de suite hypercroissante
(et même il s’agit de la plus ”petite” possible) sont les puissances de 2 : nous savons que 2k −1 = 2k−1 +2k−2 +...+21 +20 ,
2k est donc strictement supérieur à la somme des puissances de 2 avant.
L’idée pour le résoudre dans ce cas là est très simple, pour en donner l’exemple on va se placer dans le cadre des
puissances de 2. Vous savez qu’étant donné un nombre en base 10, une possibilité pour le convertir en base 2 est de
prendre les puissances de 2 de la plus grande à la plus petite, voir si le nombre est supérieur ou égal à cette dernière,
si oui mettre un 1 et faire la soustraction, sinon mettre un 0. Par exemple pour 123 : nous allons commencer par
soustraire 64 (59), puis 32 (27), puis 16 (11), puis 8 (3), puis 2 (1), puis 1 (0). Eh bien cette stratégie est équivalente
à la résolution du problème avec si = 2i , et un objet sera pris si le bit associé est à 1 !
Donc la résolution pour une suite hypercroissante consiste à trier les si par ordre croissant, on part donc de sk s’il est
plus petit que N on le prend et on enlève sk à N sinon on ne le prend pas, et on continue ainsi de suite jusqu’à s1 .
Décrivons maintenant le cryptosystème associé à ce problème :

Génération de clé : on commence choisir une suite hypercroissante a0 , ..., an−1 , puis on prend un entier N
aléatoire et strictement plus grand que la somme des ai . Pour finir, on choisit un A premier avec N (pour
rappel tel que pgcd(A, N ) = 1) et on calcule bi = A × ai (mod N ). La clé publique sera l’ensemble des bi et la
clé secrètre le tuple (A, N, {a0 , ..., an−1 }).
Pn−1
Chiffrement : on va calculer c = i=0 mi × bi avec mi le i-ième bit du message.
Pn−1
Déchiffrement : on calcule c × A−1 = i=0 mi × ai = S et on résout le problème du sac à dos sur ce S.
Voici un exemple de clé : ai = {14, 18, 39, 76}, A = 199, N = 246, bi = {80, 138, 135, 118}.
Le chiffré du message 0110 serait 138 + 135 = 273.
Pour déchiffrer, on va chercher A−1 = 157 puis calculer c × A−1 (mod N ) = 157 × 273 (mod 246) = 57. Nous partons
ensuite de la plus grande valeur du tableau a, 76 est trop grand (bit à 0), 39 peut être retiré, 18 peut être retiré et il
reste 0. Le message déchiffré est donc 0110.
Une des recommandations est que 2i+n−1 <= ai < 2i+n (i démarrant à 0), 22n−1 <= N < 22n
Voici un code qui permet de générer des clés, faire du chiffrement et du déchiffrement :
1 import random
2 import math
3
4 def keyGeneration ( n ) :
5 a = []
6 sommeActuelle = 0
8 a . append ( random . randint ( max ( sommeActuelle + 1 , 2 ** ( n + i - 1) ) , 2 ** ( n + i ) - 1) )
9 sommeActuelle += a [ -1]
10 N = random . randint ( sommeActuelle , 2 ** (2 * n ) - 1)
11 A = 0
12 while A == 0 or math . gcd (A , N ) != 1 :
13 A = random . randint (2 , N - 2)
14
15 b = [ ( a [ i ] * A ) % N for i in range (0 , len ( a ) ) ]
16 return [ b , [ A , N , a ] ]
17
18 def encrypt ( messageBits , b ) :
19 result = 0
20 for i in range (0 , len ( messageBits ) ) :
21 if messageBits [ i ] == ’1 ’ :
22 result += b [ i ]
23 return result
24
25 def decrypt ( encryptedNumber , A , N , a ) :
26 # Find the inverse of A and getting the new number
27 Ainv = pow (A , -1 , N )
28 newNumber = ( e n cr yp te d Nu mb er * Ainv ) % N
29
30 # Getting the different bits
31 messageBits = []
32 for i in range (0 , len ( a ) ) :
33 if newNumber >= a [ len ( a ) - i - 1] :
40 / 114 Année 2023 - 2024

34 newNumber -= a [ len ( a ) - i - 1]
35 messageBits = [ " 1 " ] + messageBits
36 else :
37 messageBits = [ " 0 " ] + messageBits
38 return " " . join ( messageBits )
Une première idée d’attaque sur le protocole serait de tester toutes les possibilités de N et de A et ne garder que celles
qui lorsqu’elles sont utilisées avec les bi donnent une séquence hypercroissante. Voici le code qui implémenterait cette
attaque :
1 import math
2
3 b = ...
4 powsOf2 = []
5 for i in range (0 , 2 * len ( b ) + 1) :
6 powsOf2 . append (2 ** i )
7 longueurB = len ( b )
8 maxN = powsOf2 [2 * longueurB ]
9
10 listeCles = []
11 startN = max ( maxN // 2 , max ( b ) + 1) # Start at max ( b ) because b_i < N for any i
12 for N in range ( startN , maxN ) :
13 for Ainv in range (1 , N ) :
14 if math . gcd (N , Ainv ) != 1 :
15 continue
16 ok = True
17 sommeCourante = 0
18 for i in range (0 , longueurB ) :
19 borneMin = max ( sommeCourante + 1 , powsOf2 [ longueurB + i - 1])
20 borneMax = powsOf2 [ longueurB + i ]
21 ai = ( b [ i ] * Ainv ) % N
22 if ai < borneMin or ai >= borneMax :
23 ok = False
24 break
25 sommeCourante += ai
26 if ok :
27 listeCles . append ([ pow ( Ainv , -1 , N ) , N ])
28
29 print ( " Nombre de cles possibles : " + str ( len ( listeCles ) ) )
30 print ( " Cles possibles : " + str ( listeCles ) )
Prenons donc par exemple la clé consituée de a = {13, 24, 62, 108}, A = 61, N = 226, nous avons donc b =
{115, 108, 166, 34}. Nous allons maintenant supposer que nous ne connaissons ni a, ni A, ni N et nous allons tes-
ter plusieurs valeurs de A et de N pour voir si nous obtenons une suite hypercroissante :
A = 123, N = 212 : donc A−1 = 131 et nous avons a′i = {(115 × 131) (mod 212) = 13, 156, 122, 2} qui n’est
pas hypercroissante.
A = 140, N = 201 : donc A−1 = 56 et nous avons a′i = {8, 18, 50, 95} qui est hypercroissante c’est donc une clé
possible.
A = 61, N = 226 : donc A−1 = 63 et nous avons a′i = {13, 24, 62, 108} qui est une autre clé possible.
Pour déterminer quelle clé est la bonne, une attaque à texte clair connu pourra aider à éliminer des couples.
Pour n = 4, il reste en moyenne 5 clés et pour n = 5 c’est 6. Le seul problème est le temps d’exécution exponentiel
qui dépend d’environ 24n (22n−1 valeurs de N possibles et 22n valeurs de A possibles).
Une autre attaque en temps polynomial a été décrite par Shamir en 1984, je vais en faire une courte introduction ici
et je n’irais pas en profondeur car elle demande de connaı̂tre des concepts comme l’algorithme de Lenstra, ...
Imaginons dans un premier temps que nous connaissions la valeur de N , et que nous souhaitions trouver A (nous allons
plutôt trouver B = A−1 (mod N ). L’idée va être de dire que 2n−1 <= B × b0 (mod N ) = a0 < 2n , 2n <= B × b1
(mod N ) = b1 < 2n+1 , ... : nous obtenons donc de l’information sur A grâce à toutes ces équations.
Affichons maintenant la fonction B ′ × b0 (mod N ) et affichons également la condition sur b0 :
41 / 114 Année 2023 - 2024

Vous pouvez donc voir que B ′ n’est valide que dans certains intervalles et il est possible de combiner plusieurs
observations pour affiner la valeur de B ′ (c’est un peu le même principe qu’avant).
Leur idée pour enlever la valeur de N est de tout diviser par N , ce qui donne un nouveau graphe qui parcourira toutes
les valeurs de V = B ′ /N et donnera des intervalles de validité de V :
Dans la suite du document, ils semblent prendre une approche dans laquelle ils tracent les 4 fonctions associées aux 4
bi (car ils ont montré que dans notre cas, 4 valeurs sont suffisantes) et trouvent un point où les minimum de toutes
ces fonctions sont très proches.
Une idée simple (très mauvaise et qui ne change rien en temps) est de faire comme pour la méthode brute force :
prendre toutes les valeurs possibles de N , calculer tous les intervalles dans lesquels B ′ peut être et voir si l’un d’entre
eux contient un entier (qui sera une valeur de B ′ possible pour la valeur de N associée). L’efficacité sera au mieux la
même voire pire que la méthode brute force.
9.2 Les lattices (j’ai une partie plus détaillée plus bas) :
Un réseau est un sous-groupe additif de Zn de dimension n. Il est défini par une base de vecteurs éléments de Zn qui
seront placés dans une matrice à n lignes et n colonnes en ligne :
→
−

v1 
B = ···
−
v→

n
Le réseau est constitué de l’ensemble des combinaisons linéaires à coefficients entiers des vecteurs de la base.
Un code binaire lui sera défini par une matrice dans F2 .
Pour les codes, c’est la distance de Hamming qui nous donne le poids égal au nombre de coordonnées non-nulles mais
cette métrique n’est utile que lorsqu’on travaille sur F2 . Sur les lattices, on utilisera plutôt la norme euclidienne (qui
est la racine carrée de la somme des carrés des coordonnées).
Sur les lattices, on a également un problème de décodage : on envoie y = x × B + e avec e une erreur dont la distance
à un vecteur de la lattice n’excède pas une certaine distance maximale (le décodé sera le vecteur du réseau le plus
proche).
Il y a aussi un problème de réduction de la base que je présente plus en détail sur la partie que j’ai réalisée.
Tous ces problèmes demandent un factuer d’approximation, si ce dernier est plus qu’une certaine limite le problème
peut être résolu en temps polynomial dans le cas contraire la complexxité sera exponentielle.
9.3 Le cryptosystème NTRU :

Allez voir ma partie sur les lattices.
9.4 Le problème LWE et le cryptosystème LWE (pas le temps d’expliquer mieux) :

LWE : learning with errors, et nous allons voir tout de suite pourquoi.
L’idée est la même que résoudre un système d’équations linéaires sauf qu’au lieu d’avoir des égalités, on a des approxi-
mations dûes à l’ajour d’erreurs avant de nous envoyer les solutions.
Un ”sample” est calculé de la manière suivante :
r = (a1 , · · · , an ) · (s1 , · · · , sn ) + (e1 , · · · , en )
Dans cette équation r représente le sample, A est un vecteur dont les coefficients seront choisis aléatoirement et uni-
formément, s un vecteur inconnu et e une petite erreur prise d’une distribution aléatoire χ.
L’idée est qu’à partir d’un certain nombre de samples (constitués de (a, a · s + e), nous voulons retrouver s et on nous
donne un nombre polynomial de ces samples. Bien sûr, il faut au moins n samples pour arriver à résoudre ce problème.
Une variation : le RLWE (Ring-LWE) consiste à prendre des polynômes au lieu de vecteurs.
En 2008, il a été démontré qu’il était possible de résoudre le problème LWE en sachant résoudre le problème SVP.
Pour le cryptosystème LWE, nous aurons les paramètres suivants :
42 / 114 Année 2023 - 2024

(n, m, l) : des tailles de matrices.

(q, t) : 2 valeurs de modulo.
r : une borne pour un vecteur uniformément aléatoire.
La clé secrète sera une matrice S avec n lignes et l colonnes, dont chaque coefficient sera aléatoire et modulo q.
La clé publique sera constituée de 2 éléments : A une matrice aléatoire modulo q à m lignes et n colonnes, puis
P = AS + E avec E une matrice à m lignes et l colonnes aléatoire suivant la loi de probabilité χ.
Pour le chiffrement, nous convertirons notre message en v un vecteur à l éléments tous modulo t. Il suffira ensuite de
choisir un vecteur a aléatoire à n valeurs toutes générées aléatoirement et uniformément entre −r et r.
Nous avons également une fonction f de Zt vers Zq qui a i associe i × q/t.
La première partie du chiffré est u = At × a.
La seconde partie du chiffré est c = P t × a + f (v).
Pour le déchiffrement, on va calculer :

res = f −1 (c − S t × u)
res = f −1 (P t × a + f (v) − S t × At × a)
res = f −1 ((AS + E)t × a + f (v) − S t × At × a)
res = f −1 ((AS)t × a + E t × a + f (v) − S t × At × a)
res = f −1 (E t × a + f (v))
L’intérêt est que si l’erreur est contrôlée E t × a est petit, on pourra décoder et donc on pourra récupérer f (v) et
appliquer l’inverse de f pour récupérer le message.
La sécurité du cryptosystème repose sur l’indistinguabilité de quelque aléatoire. Si on casse McEliece, on aura cassé
un problème spécifique alors que si on casse LWE on aura cassé un problème général.
9.5 Kyber (encore une fois pas le temps de développer) :

Il est basé sur le cryptosystème précédent. A est une matrice 512 x 512 mais vu que c’est trop gros on va la prendre
cyclique par blocs. La taille de clé est donc d’environ 1.5KB ce qui nous fait environ 10 000 bits.
9.6 Dans le NIST :

Au 2ème tour, il restait : NTRU, SABER, KYBER et FRODO (vient du seigneur des anneaux), BEAR, NTRUprime.
Pour le 3ème tour, il ne restait que NTRU, SABER et KYBER.
A la fin, ils ont gardé KYBER.
Par contre FRODO est soutenu par l’ANSSI et le BDI (les allemands).
10 Dernière séance de l’année avec Gaborit :

10.1 Signature sur les réseau :
Le problème difficile dans les réseaux est le décodage par équivalence et par syndrome. La norme euclidienne sera
utilisée pour calculer les distances.
La base d’un réseau forme ce que l’on appellera le parallélotope fondamental (dans Z2 nous aurons soit un carré soit un
parallélogramme). Un parallélotope est une généralisation à des dimensions supérieures de la notion de parallélogramme
/ parallélépipède rectangle. Pour une même lattice, le volume de ce parallélotope est égal au déterminant et donc ne
change pas peu importe la base car une lattice est uniquement déterminée par son déterminant.
Comme nous l’avons dit avant, une bonne base c’est une base dans laquelle les vecteurs sont petits et à peu près
orthogonaux. Une base aléatoire est naturellement mauvaise et passer d’une mauvaise base à une bonne peut être dur
en fonction du facteur d’approximation.
Pour le chiffrement il existe NTRU et GGH que nous avons vu avant : ils sont McEliece like.
LWE et Ring-LWE ont donné KYBER.
La première approche pour faire de la signature est la suivante :

Soit on masque comme dans GGH et NTRU, l’idée est d’avoir une ”mauvaise” base comme clé publique et une bonne
base masquée. Pour signer, on va faire du hash and sign comme dans RSA : le hash du message sera un point de
l’espace, pour obtenir la signature on prendra un point de la bonne base et on ajoutera une petite erreur. Dans la
mauvaise base il sera beauccoup plus difficile de décodere. En revanche, plus on va donner d’éléments (plus on va faire
de signatures), plus on va donner la forme de notre parallélotope fondamental (et donc de la bonne base). Pour lutter
contre cela, on utilisera la signature GPV : on va envoyer un vecteur très gros random plus un petit vecteur, ce gros
vecteur va éccraser le petit.
Ce qui a été soumis au NIST est la version optimisée de GPV avec NTRU : Falcon.
43 / 114 Année 2023 - 2024

L’autre approche est représentée par le schéma dilithium à preuve de connaissance.

Il utilise le schéma de Lyabaskevski. Ici, on va voir l’avantage des réseaux sur les codes. Pour un facteur d’approxima-
tion en 2n , le problème est facile, et pour un facteur d’approximation petit, cela sera impossible.
Le secret sera un mot de très petit poids et la signature sera une combinaison linéaire de mots de très petit poids.
Pour dilithium :
La clé secrète sera S : une matrice de petit poids.
La clé publique sera A aléatoire et T = A × S
La signature de M : y aléatoire de petite taille, on calcule c = H(A × y, M ) et finalement la signature sera
z = y + C × S.
Vérification : vf (z, c, M ) : vérifier que z est petit et que c = Hash(Az − T c, M ) (Az − T c = Ay)
10.2 La cryptographie à seuil :

On veut répartir une information entre n personnes de telle sorte que si k personnes et plus collaborent, elles peuvent
retrouver le secret et si k − 1 ou moins collaborent, ils n’obtiennent aucune information sur le secret.
Il y a par exemple le schéma de Shamir qui date de 1979. L’idée est de prendre un polynôme P de degré k − 1 et que
chaque personne aura un point correspondant à un x aléatoire du polynôme (le secret de la personne sera (x, P (x))).
Si on arrive à connaı̂tre k points (donc que k personnes collaborent), il est possible de récupérer le polynôme (avec
de l’interpolation lagrangienne, une partie sur ça est détaillée plus loin) et donc d’obtenir le secret. Le secret sera le
terme constant du polynôme : P [0].
C’est une couche que l’on peut rajouter à n’importe quelle primitive cryptographique !
Shamir revient à utiliser les codes de reed-solomon ?
10.3 Les pairings :

Pour les courbes elliptiques (tout comment pour Diffie-Hellman), nous avons la notion de DDH (Decisional Diffie-
Hellman) : étant donné a × P et b × P il est impossible de faire la différence entre ab × P et c × P pour un c aléatoire.
Un pairing est une construction générale qui se base sur une application bilinéaire :
e : G1 × G1 → G2 .
Elle vérifie 2 propriétés :
Bilinéarité : pour tous P, Q ∈ G1 , pour tous a, b ∈ Z∗q , on a que e(aP, bQ) = ab × e(P, Q)
Non-dégénérescence : pour tout P ∈ G1 , si P ̸= 0, alors G2 =< e(P, P ) >
Du coup, 2 points d’une courbe elliptique peuvent intéragir pour donner un point d’une autre courbe avec la propriété
de bilinéarité.
C’est une notion qui a tout d’abord été utilisée pour les attaques sur les courbes elliptiques.
Concrètement, il existe plusieurs types de couplage : couplage de Weil et de Tate à base de courbes elliptiques, ce qui
ne marche qu’avec des courbes spécifiques.
Un théorème très important : le problème du logarithme discret sur G1 n’est pas plus dur que celui sur G2 (si je
sais résoudre le problème sur G2, je sais le résoudre sur G1).
Démonstartion : soit P1 le générateur de G1 et nous connaissons y = a × P1 mais nous voulons trouver a. L’idée est
de calculer e(aP, P ) = a × e(P, P ) = a × P2 : donc si on sait résoudre sur G2 on peut retrouver a et donc on peut
résoudre sur G1 .
Un autre théorème très important : le problème DDH est facile si nous avons un couplage :
Pour le problème DDH, on va nous donner soit ab × P ou c × P et on connaı̂t aP et bP .
e(aP, bP ) = e(P, P )ab
e(P, Q) = e(P, P )ab mais seulement si Q = ab × P , il vaudra autre chose si Q = cP : du coup on peut distinguer les 2
et casser le problème DDH !
Un premier exemple de protocole est un échange de clé tripartite par Antoine Joux en 2000 :
44 / 114 Année 2023 - 2024

L’idée est que A va connaı̂tre a et il aura reçu bP et cP , il va donc pouvoir calculer a × e(bP, cP ) = abc × e(P, P )
Bilinear Diffie-Hellman (BDH) :

Calculer e(P, P )abc connaissant P, aP, bP, cP c’est dur.
Sur une courbe elliptique, le problème DDH est facile mais le problème calculatoire (CDH) reste dur.
IBE : identity based encryption.

Le chiffrement basé sur l’identité est une notion introduite par Shamir en 1984. L’idée est tout simplement que la clé
publique d’un utilisateur sera un composant de son identité (comme son nom, son prénom, son numéro de sécurité
sociale, ...).
Bien que Shamir l’ait introduit en 1984, le premier protocole date de 2001 et a été inventé par Boneh et Franklin.
Elle repose sur une tierce partie : un PKG (Private Key Generator). Pour chiffrer un message, une personne utilisera
l’identité du destinataire ainsi que la clé publique du PKG. Pour déchiffrer, le destinataire va demander la clé privée
correspondant à son identité au PKG et l’utiliser pour récupérer le message.
Voyons maintenant comment le schéma de Boneh et Franklin fonctionne :

- Setup du PKG : il commence par choisir 2 groupes G1 et G2 , puis il créée le pairing e : G1 × G1 → G2 , il choisit
ensuite sa clé secrète s ∈ Z∗q et calcule sa clé publique Ppub = s × P (avec P un générateur de G1 ). Il dispose également
de 2 oracles aléatoires : H1 : {0, 1}∗ → G1 et H2 : G2 → {0, 1}∗ .
- Chiffrement pour Alice : on commence par récupérer la clé publique d’Alice à partir de son identité, ici pkA = H1 (A),
il faut aussi aller demander au PKG sa clé publique Ppub , on peut ensuite calculer gA = e(H1 (A), Ppub ) et pour finir
r
le chiffré sera (u, v) = (rP, M ⊕ H2 (gA )).
- Déchiffrement par Alice : elle va commencer par aller chercher sa clé privée auprès du PKG qui lui retourne
dA = s × QA , elle peut ensuite réaliser le déchiffrement en calculant : res = v ⊕ H2 (e(dA , u))
res = v ⊕ H2 (e(H1 (A), P )rs )
res = v ⊕ H2 (e(QA , sP )r )
res = v ⊕ H2 (e(QA , Ppub )r )
r
res = v ⊕ H2 (gA )
r r
res = M ⊕ H2 (gA ) ⊕ H2 (gA )
res = M
45 / 114 Année 2023 - 2024

11 Les lattices (fait par moi) :

11.1 Quelques rappels sur les matrices :
Une matrice est un tableau de nombres, par exemple la matrice A ci-dessous est une matrice 2 × 3 :

1 2 3
A=
4 5 6
Pour additionner (soustraire) 2 matrices, il faut additionner (soutraire) leurs coefficients terme à terme,cette opération
n’est donc possible que si les 2 matrices ont les mêmes dimensions. Voici la règle :
     
a1,1 a1,2 · · · a1,n b1,1 b1,2 · · · b1,n a1,1 + b1,1 a1,2 + b1,2 · · · a1,n + b1,n
 a2,1 a2,2 · · · a2,n   b2,1 b2,2 · · · b2,n   a2,1 + b2,1 a2,2 + b2,2 · · · a2,n + b2,n 
A+B = . + =
     
.. .. .. .. .. .. .. .. .. .. ..
 ..
    
. . .   . . . .   . . . . 
am,1 am,2 ··· am,n bm,1 bm,2 ··· bm,n am,1 + bm,1 am,2 + bm,2 ··· am,n + bm,n
Pour multiplier 2 matrices entre elles, il faudra réaliser le produit scalaire de toutes les lignes de la première par toutes
les colonnes de la seconde. L’opération n’est donc possible que si la seconde matrice a autant de lignes que la première
a de colonnes. Voici la règle :
  −→ −→ − −→ −−→ 
a1,. · b.,1 a→
1,. · b.,2 ··· − a→
1,. · b.,n2
  
a1,1 a1,2 · · · a1,n1 b1,1 b1,2 · · · b1,n2
 −→ −→ − −→ −−→ 
 a2,1 a2,2 · · · a2,n1    b2,1
 b2,2 · · · b2,n2    a2,. · b.,1 a→
2,. · b.,2 ··· − a→
2,. · b.,n2 
A×B =  . × =

.. .. ..   .. .. .. ..    .. .. .. .. 
 .. . . .   . . . .   . . . .


am1 ,1 am1 ,2 · · · am1 ,n1 bm2 ,1 bm2 ,2 · · · bm2 ,n2 −−−→ −→ −−−→ −→ −−−→ −−→
am ,. · b.,1 am ,. · b.,2 · · · am ,. · b.,n
2 2 2 2
Avant de passer à l’inverse d’une matrice, voyons comment calculer le déterminant de n’importe quelle matrice.
Il peut être défini par récurrence :
Le déterminant d’une matrice 1 x 1 sera le seul élément de cette matrice |a| = a
Soit A une matrice n × n, on pourra prendra n’importe quelle ligne i puis développer le déterminant sur cette
ligne en prenant tous les coefficients ai,j et en calculant le déterminant de A à laquelle on aura retiré la ligne i
et la colonne j (il est aussi possible de le faire en suivant une colonne).
Voici comment on pourrait noter la relation de récurrence :
a1,1 a1,2 ··· a1,n

a2,1 a2,2 ··· a2,n n
X
det(A) = . .. .. .. = (−1)i+j × ai,j × det(Ai,j )
.. . . . j=1
an,1 an,2 ··· an,n
Et voici maintenant un exemple en utilisant la seconde colonne d’une matrice 3 × 3 :
a b c
d f a c a c
d e f = −b × +e× −h×
g i g i d f
g h i
Pour finir, l’inverse de la matrice A de dimensions n × n sera donné par (AT est la transposée de A) :
T
(−1)1+1 det(A1,1 ) (−1)1+2 det(A1,2 ) (−1)1+n det(A1,n )

···
1 1 1  (−1)2+1 det(A2,1 ) (−1)2+2 det(A2,2 ) ··· (−1)2+n det(A2,n ) 
A−1 = ×adj(A) = T
×com(A) = ×
 
.. .. .. ..
det(A) det(A) det(A) 

. . . . 
(−1)n+1 det(An,1 ) (−1)n+2 det(An,2 ) · · · (−1)n+n det(An,n )
Terminons par la multiplication par un vecteur : si ce dernier est représenté en ligne, la multiplication se fera avec
le vecteur à gauche, en revanche s’il est représenté en colonne la multiplication se fera avec le vecteur à droite de la
matrice.
Une matrice peut également être représentée par une liste de vecteurs lignes ou une liste de vecteurs colonnes.
46 / 114 Année 2023 - 2024

11.2 Espaces vectoriels :

Bien qu’ils ne soient pas nécessaires à la compréhension des lattices, ils vont permettre de définir quelques termes de
base commme : une famille de vecteurs linéairement indépendants, une base, une matrice de changement de base, ...
Avant de passer à la suite, voici la définition d’une combinaison linéaire : c’est un élément construit en multipliant et
ajoutant d’autres éléments entre eux. Par exemple, une combinaison linéaire des vecteurs v1 , · · · , vn peut être décrite
par un ensemble de coefficients a1 , · · · , an et le résultat de cette combinaison linéaire sera v = a × v1 + · · · + a × vn .
Définition : un espace vectoriel est un ensemble dont les éléments se comportement comme des vecteurs, cela veut dire
que l’on peut les additionner (la condition est que le résultat de l’addition soit toujours un élément de l’EV) et les
multiplier par un scalaire (le résultat doit être un élément de l’EV). Vous pouvez les voir comme un groupe commutatif
avec une relation supplémentaire qui permet de réaliser des combinaisons linéaires de ses éléments.
Exemple 1 : l’ensemble des réels R forme un espace vectoriel.
Exemple 2 : l’ensemble R2 (toutes les paires d’éléments de R) forme un espace vectoriel.
Exemple 3 : l’ensemble E = {(x, y) ∈ R2 |x + y = 0} forme un sous-espace vectoriel de R2 :
(0, 0) est bien un élément de E.
Soient (x, y) ∈ E et (x′ , y ′ ) ∈ E, (x, y) + (x′ , y ′ ) = (x + x′ , y + y ′ ) pour lequel on a que x + x′ + y + y ′ =
x + y + x′ + y ′ = 0 + 0 = 0 ce qui montre que nous avons encore une fois un élément de l’ensemble.
Soit (x, y) ∈ E et k ∈ R, k × (x, y) = (k × x, k × y) pour lequel on a que k × x + k × y = k × (x + y) = k × 0 = 0
qui est encore un élément de l’ensemble.
Pour tester si un ensemble E est un espace vectoriel (sur les réels), il faudra toujours vérifier les 3 règles décrites.
Avant de parler de base, définissons ce qu’est une famille de vecteurs linéairement indépendants : il s’agit d’une
liste de vecteurs dont aucun ne peut être exprimé comme une combinaison linéaire de tous les autres.
Exemple 1 : B1 = {v1 , v2 } = {(1, 1), (1, 2)} est une famille de vecteurs linéairement indépendants.
Exemple 2 : B2 = {v1 , v2 } = {(1, 1), (2, 2)} n’est pas une famille de vecteurs indépendants (on dira donc qu’elle est
liée) car le vecteur v2 peut être exprimé comme une combinaison linéaire du seul vecteur v1 : v2 = 2 × v1 .
Exemple 3 : B3 = {v1 , v2 , v3 } = {(1, 3), (−6, 8), (27, −65)} n’est pas une famille de vecteurs indépendants, ce qui est
même impossible car le nombre de vecteurs est plus grand que le nombre de coordonnées des vecteurs. Ici, n’importe
quel vecteur est une combinaison linéaire des 2 autres :
−73 −13 −87 −13 −87 −73
(1, 3) = v2 + v3 , (−6, 8) = v1 + v3 , (27, −65) = v1 + v2
87 87 73 73 13 13
Exemple 4 : B4 = {v1 , v2 } = {(1, 2, 3), (4, 5, 6)} est une famille de vecteurs linéairement indépendants.
Une base d’un espace vectoriel E est une famille de vecteurs linéairement indépendants qui génèrent par combi-
naison linéaire cet espace vectoriel : il faut qu’ils soient linéairement indépendants car imaginons que nous ajoutions
un vecteur vn+1 n’étant pas linéairement indépendant aux {v1 , ..., vn } précédents, ce vn+1 est un élément de l’espace
généré par {v1 , ..., vn } et n’ajoute donc aucune information.
Prenons par exemple une base {v1 , v2 }, l’espace vectoriel généré par cette base sera {v = a × v1 + b × v2 , (a, b) ∈ R2 }.
IMPORTANT : un espace vectoriel peut avoir une infinité de bases !
Exemple 1 : une base de R2 peut être {(1, 0), (0, 1)} ou encore {(1, 123), (0, 1)}.
Exemple 2 : une base de {(x, y) ∈ R2 |x + y = 0} peut être {(1, −1)} ou tout autre élément de l’ensemble.
Exemple 3 : une base de {(x, y, z) ∈ R3 |x + y + z = 0} peut être {(−1, 1, 0), (−1, 0, 1)} ou toute autre paire d’éléments
de l’ensemble étant linéairement indépendants.
Une base d’un espace vectoriel peut être représentée sous forme de matrice où les vecteurs de la base seront mis en
colonne et la multiplication par un ensemble de valeurs se fera à droite (pour symboliser la combinaison linéaire). Voici
ce que cela donnerait pour l’exemple 4, où nous allons récupérer la forme des vecteurs vérifiant la condition :
   
−1 −1 −a − b
a
1 0 × = a 
b
0 1 b
Nous avions dit qu’un espace vectoriel pouvait avoir une infinité de bases, une matrice de changement de base va
permettre de changer l’expression d’un élément d’une base à une autre.
Imaginons que nous voulions passer d’un point 2D exprimé dans la base {v1 = (1, 123), v2 = (0, 1)} vers un point
exprimé dans la base {e1 = (1, 0), e2 = (0, 1)}. Elle devra au moins transformer le point 1v1 − 123v2 en le point
1e1 + 0e2 et le point 0v1 + 1v2 en le point 0e1 + 1e2 , cela nous donne la matrice de changement de base suivante (il
aurait également été possible de la trouver avec l’inverse de la matrice) :

1 0 1 0 1 0
= ×
0 1 −123 1 123 1
Est-ce que cette matrice de passage existe toujours ? La réponse est oui : soient 2 bases du même EV, X dont les
vecteurs seront notés →−
xi et Y dont les vecteurs seront appelés → −
yi , les →
−
yi sont des combinaisons linéaires de →
−
xi (car ce
sont des éléments de la lattice) et cette transformation linéaire peut être représentée par une matrice.
47 / 114 Année 2023 - 2024

11.3 Introduction aux lattices :

Il y a une très grande similarité entre la notion d’espace vectoriel et celle de lattice (c’est pourquoi j’ai préféré les
évoquer juste avant), une lattice peut tout simplement être vu comme un espace vectoriel sur les entiers : Z.
Donc, une lattice est un ensemble infini de points générés par une base de vecteurs d’entiers indépendants. Nous
noterons L(B) pour représenter la lattice générée par la matrice B. Nous prendrons la convention que les vecteurs de
la base seront mis en colonne dans la matrice (pour obtenir une combinaison linéaire en multipliant à droite).
L’ensemble des points de la lattice L(B) sera : L(B) = {B × a, a ∈ Zn } (l’ensemble des combinaisons linéaires
à coefficients entiers des vecteurs de la base). Par exemple, la lattice Z3 peut être représentée par la base B1 =
{(1, 0, 0), (0, 1, 0), (0, 0, 1)} ou encore B2 = {(1, 1, 1), (2, 1, 1), (0, 0, 1)} qui peuvent aussi s’écrire sous forme matricielle
de la façon suivante :    
1 0 0 1 2 0
B1 = 0 1 0 , B2 = 1 1 0
0 0 1 1 1 1
Le déterminant d’une lattice sera la valeur absolue du déterminant de la matrice génératrice : det(L(B)) = |det(B)|.
Un autre concept intéressant est la notion de sous-lattice : une sous-lattice de L = L(B) est un sous-ensemble L′ ⊆ L
qui est généré par une certaine lattice B ′ . Voici un exemple de sous-lattice de Z2 :

2 0 1 0
L(B ′ ) = L ⊆L = L(B) = Z2
0 1 0 1
La lattice de gauche ne génère que des paires d’entiers dont le premier est un nombre pair, alors que celle de droite
génère toutes les paires d’entiers possibles. Pour un espace vectoriel cela n’aurait pas été vrai et les 2 bases auraient
généré le même espace vectoriel pour le simple fait qu’il est possible d’utiliser des coefficients réels en plus des entiers.
Les minimums successifs d’une lattice :

Le minimum d’une lattice L, noté Λ1 (L) est la norme du vecteur non nul ayant la norme la plus petite parmi
tous les vecteurs de la lattice. Ce n’est pas obligatoirement la norme d’un des vecteurs de la base !
Le second minimum, noté Λ2 (L) est la valeur r pour laquelle il existe 2 vecteurs indépendants linéairement de
la lattice tels que |→
−
v1 | <= r ∧ |→
−
v2 | <= r (c’est en gros le prochain vecteur linéairement indépendant à →
−
v1 qui a
la norme la plus petite).
Et ainsi de suite.
Prenons l’exemple de la lattice suivante définie par la base B = {(5, 3, 3), (4, 5, 6)}, qui envoie des éléments de Z2 vers
Z3 et donc génère obligatoirement une sous-lattice de Z3 :
 
5 4
L(B) = L 3 5 ⊂ Z3
3 6
√
Le minimum est Λ1 (L(B)) = ||1→ −
e1 − 1→
−
e2 || = ||(1, −2, −3)|| = 14.√
Le second minimum est Λ2 (L(B)) = ||2→ −
e1 − 1→ −
e2 || = ||(6, 1, 0)|| = 37
Bien sûr, il n’y a pas de troisième minimum vu que cette lattice est générée par une base de 2 vecteurs (il sera donc
impossible de trouver un troisième vecteur indépendant aux 2 premiers qui ont été pris).
Ces 2 vecteurs étant indépendants et des éléments de L(B), ils nous permettent d’obtenir une autre base pour cette
lattice qui sera appelée la base la plus courte (”Shortest Basis”) :
 
1 6
L(B ′ ) = L −2 1
−3 0
Par contre attention, une liste de vecteurs contenant tous les minimums n’est pas forcément une base de la lattice
associée. Soit L la lattice telle qu’un vecteur (x1 , x2 , x3 , x4 ) ∈ L si la somme des 4 composantes donne un nombre pair.
Les 2 matrices ci-dessous sont constituées de minimums, or, la matrice de gauche est une base et celle de droite non :
        

 1 1 1 1 a 
 
 a+b+c+d   1 1 0 0
−1 1 0 0  ×  b  , (a, b, c, d) ∈ Z4 =  −a + b  , B2 = −1 1 0 0 
       
L(B1 ) = 


 0 0 1 0   c  
   c    0 0 1 −1
  
0 0 0 1 d d 0 0 1 1
  
Il est facile de voir que la B1 génère des vecteurs de L car a+b+c+d−a+b+c+d = 2×(b+c+d). Prenons maintenant
un vecteur (x, y, z, w) ∈ L, nous pouvons prendre c = z, d = w, a = (x − y − z − w)/2 = x − (x + y + z + w)/2 qui sera
entier, b = (x + y − z − w)/2 = x + y − (x + y + z + w)/2 qui sera également un entier. Du coup B1 est une base de L.
Il est également facile de voir que B2 génère des vecteurs de L car a + b − a + b + c + d − c + d = 2 × (b + d). Mais, il
est impossible de trouver une combinaison linéaire des vecteurs de la base donnant (1, 2, 3, 4) ∈ L : du coup B2 n’est
pas une base de L.
48 / 114 Année 2023 - 2024

11.4 Matrices uni-modulaires et dépendance de la lattice au déterminant de la base :

Une matrice unimodulaire est une matrice sur les entiers relatifs dont le déterminant sera ±1. La matrice identité est
un exemple de matrice unimodulaire. Aussi, un produit de matrices unimodulaires est également unimodulaire (car
det(A × B) = det(A) × det(B)).
La première opération sur les colonnes, l’opposé de la ligne i (notée IN V ERT (i)) qui s’obtient en prenant l’identité
et en multipliant la case (i, i) par -1 est une matrice unimodulaire (et son déterminant est -1).
La seconde opération sur les colonnes, l’ajout d’un multiple c de la colonne j à la colonne i (notée ADD(i, c, j)) qui
s’obtient en prenant l’identité et en ajoutant un c sur la case (j, i) est une matrice unimodulaire et son déterminant
est 1 (le déterminant d’une matrice triangulaire est le produit des éléments sur sa diagonale).
La dernière opération sur les colonnes, l’échange de la colonne i et de la colonne j (notée SW AP (i, j)) qui s’obtient en
échangeant les colonnes i et j de l’identité a également un déterminant de -1 (car échanger 2 colonnes d’une matrice
multiplie son déterminant par -1 et nous sommes partis de l’identité).
     
1 0 0 0 0 1 0 0 0 −15 1 0 0 0 0
0 −1 0 0 0 0 1 0 0 0  0 0 0 1 0
     
IN V ERT (2) = 0 0 1 0 0 , ADD(4, −15, 1) = 0 0 1 0
   0  , SW AP (2, 4) = 

0 0 1 0 0

0 0 0 1 0 0 0 0 1 0   0 1 0 0 0
0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
Il faudra réaliser la multiplication par ces matrices à droite pour qu’elles s’appliquent bien sur les colonnes. Ce sont
toutes des matrices unimodulaires, il est donc possible d’en multiplier autant que l’on veut et on aura toujours une
matrice unimodulaire.
Il est possible de montrer que si X et Y sont 2 bases de la même lattice si et seulement s’il existe une matrice
C unimodulaire telle que Y = XC.
Sens 1 : L(X) = L(Y ) → ∃C | det(C) = ±1 ∧ Y = XC :
C existe, son inverse C −1 existe et que les 2 matrices doivent être à coefficients entiers car Y et X sont elles-
mêmes à coefficients entiers. On a que det(C) × det(C −1 ) = 1, or les 2 déterminants sont des entiers vu que les
matrices sont à coefficients entiers, donc soit det(C) = det(C −1 ) = 1, soit det(C) = det(C −1 ) = −1.
Sens 2 : ∃C | det(C) = ±1 ∧ Y = XC → L(X) = L(Y ) :
Montrons que L(Y ) ⊆ L(X) : soit y dans L(Y ), il existe donc x dans Zn tel que y = Y × x, et donc y est un
élément de L(X) car il existe x′ = C × x dans Zn tel que y = X × x′ .
Montrons que L(X) ⊆ L(Y ) : soit y dans L(X), il existe donc x dans Zn tel que y = X × x, et donc y est un
élément de L(Y ) car il existe x′ = C −1 × x dans Zn tel que y = Y × x′ .
Nous avons donc fini de prouver que L(X) = L(Y ) ⇔ ∃C | det(C) = ±1 ∧ Y = XC.
Nous pouvons maintenant montrer très simplement quelque chose d’encore plus important. Soient donc X et Y , 2 bases
de la même lattice (c’est à dire telles que L(X) = L(Y )), nous savons donc qu’il existe une matrice unimodulaire C telle
que Y = XC. Si nous nous intéressons au déterminant, cela veut dire que |det(Y )| = |det(X) × det(C)| = |det(X)|.
La conclusion est très simple : L(X) = L(Y ) → |det(X)| = |det(Y )| : la lattice est uniquement définie par son
déterminant (mais l’inverse n’est pas forcément vrai car il est possible que la matrice C n’existe pas alors que
|det(X)| = |det(Y )|).
Aussi, grâce à ce que nous avons dit précédemment, vous remarquez que multiplier une base d’une lattice par une
matrice unimodulaire donne une autre base de la même lattice : on peut donc créer une infinité de bases pour la même
lattice ! Voici un exemple avec 10 étapes :
         
1 0 0 1 0 0 0 0 1 −1 0 0 1 0 0
A0 = 0 1 0 , A1 = 0 0 1 , A2 = 0 1 0 , A3 =  0 1 0 , A4 = 13 1 0
0 0 1 0 1 0 1 0 0 0 0 1 0 0 1
         
1 −78 0 1 0 0 1 0 0 1 93 0 0 1 0
A5 = 0 1 0 , A6 =  0 1 0 , A7 = 0 1 0 , A8 = 0 1 0 , A9 = 1 0 0
0 0 1 −93 0 1 0 0 1 0 0 1 0 0 1
   
Y9 1 0 0 −8649 −93 1
B2 = B1 × Ai = 0 3 1  × A0 × A1 × A2 × A3 × A4 × A5 × A6 × A7 × A8 × A9 =  151 10 0
i=0 0 0 −5 −980 −65 0
Grâce à ce que nous avons vu avant, nous savons que B2 est également une base de la même lattice que celle générée
par B1 (car le produit des Ai forme une matrice unimodulaire), mais si je ne vous donne que B2 il vous sera très
difficile de revenir vers la base B1 qui est plutôt simple (sans connaı̂tre cette dernière bien sûr).
L’avantage de la base B1 est que ses vecteurs sont quasiment orthogonaux (il est donc facile de résoudre le CVP avec
comme nous le verrons après) alors que pour B2 l’angle entre le premier et le dernier vecteur de la base est 6.
Cela peut être résolu en utilisant l’algorithme LLL dont la complexité dépendra de la taille des nombres dans la
”grande” base : d’où la volonté d’avoir de grands nombres.
49 / 114 Année 2023 - 2024

11.5 Réduction de la base d’une lattice avec 2 vecteurs dans sa base :

Commençons par nous rappeler de l’interprétation géométrique des différentes opération sur les vecteurs.
Tout d’abord, l’addition et la soustraction de 2 vecteurs, puis à droite la multiplication par un scalaire :
Voici maintenant les projections orthogonales et parallèles, puis l’orthogonale arrondie à l’entier :
L’opération de projection orthogonale arrondie à l’entier est extrêmement intéressante car elle peut se voir comme une
division de 2 vecteurs avec un quotient qui sera un entier et un vecteur pour le reste.
Voyons maintenant comment trouver une formule générale pour la projection orthogonale :
Pour rappel, l’algorithme d’Euclide permettant de trouver le PGCD fonctionne de la manière suivante :
1 Entr é e : a et b tels que a > b
2 r = a
3 r’ = b
4 Tant que r ’ != 0 :
5 Trouver q : r // r ’
6 Trouver r ’ ’ : r - qr ’ # On aurait aussi pu faire r mod r ’
7 r = r’
8 r’ = r’’
9 Retourner r
Pour la réduction d’une base {→

−
v1 , →
−
v2 } (algorithme de Gauss) :
1 Entr é e : v1 et v2 tels que || v1 || > || v2 ||
2 x = v1
3 y = v2
4 Tant que || x || > || y || :
5 Trouver q : q = round (( y . x ) / ( y . y ) ) # On a projete x sur y
6 NouveauY = x - q * y
7 x = y
8 y = nouveauY
9 Retourner y , x
Nous sommes sûrs que la base produite après chaque étape reste une base de la même lattice car nous n’effectuons
que des opérations élémentaires sur les colonnes : addition d’une colonne à une autre et échange de 2 colonnes.
On sait de plus que le nouveau Y a une norme inférieure au précédent car la projection orthogonale forme un triangle
dont l’hypothénuse sera x et les 2 autres côtés seront q × y et x − q × y. Le seul cas particulier qui va se produire sera
quand la base sera minimale : q sera égal à 0 et donc nous aurons une inversion des 2 vecteurs de la base ce qui fera
s’arrêter la boucle.
50 / 114 Année 2023 - 2024

11.6 Le problème du décodage :

L’idée est que nous aurons un point qui ne sera pas un point de la lattice mais sera proche d’un de ces derniers. Le
décodage dans une lattice se fera en trouvant le vecteur le plus proche de la lattice.
Souvenez vous que chacun des éléments p de la lattice est défini par :
   
p1 a1
→
−p =  ...  = → −
v1 · · · −v→
 ..  n
×  .  , (a1 , ..., an ) ∈ Z
 
n
pk an
Il est donc très facile de retrouver la combinaison linéaire de vecteurs de la base associée à un point, il suffit de
multiplier le point à droite par l’inverse de la base.
→
−
Du coup, un algorithme simple pour réaliser le décodage du point t quand les vecteurs de la base sont quasi-
ment orthogonaux (donc quand elle a été réduite) consiste à tout d’abord trouver a1 , ..., an des réels qui forment une
solution du système suivant :    
t1 a1
 ..  →
− −
→ .
 .  = v1 · · · vn ×  .. 
tk an
Ensuite, le vecteur le plus proche p sera celui obtenu en prenant l’arrondi de chaque ai et en multipliant par la base :
   
p1 round(a1 )
 ..  →
− −
→  ..
 .  = v1 · · · vn × 

. 
pk round(an )
En revanche, moins les vecteurs de la base sont orthogonaux entre eux, moins le décodage est efficace.
Prenons par exemple la lattice définie ci-dessous par les 2 bases suivantes : B1 = {→ −
v1 , →
−
v2 } = {(−1, −3), (3, −1)}
−
→ −
→
(à gauche) et B2 = {u1 , u2 } = {(4, 2), (7, 1)} (à droite). Le point (0, 0) est représenté en rouge et le point p = (4, 3.5)
(qui n’est pas dans la lattice) est en bleu :
Décodons donc ce vecteur dans la première base :

1 3

− 10 − 10 4 −1.45
B1−1 × p = 3 1 × =
10 − 10 3.5 0.85
Nous pouvons donc prendre a1 = −1 et a2 = 1, ce qui nous donne le point (4, 2) qui est effectivement le vecteur le
plus proche de p = (4, 3.5) (la distance entre les 2 points vaut 1.5).
Puis dans la seconde base :

1 7

− 10 4 2.05
B2−1 × p = 1
10 × =
5 − 25 3.5 −0.6
Nous pouvons donc prendre a1 = 2 et a2 = −1, ce qui nous donne le point 2 × (4, 2) − (7, 1) = (1, 3) qui n’est plus le
vecteur le plus proche de p = (4, 3.5) (la distance entre les 2 points vaut 3.041).
Pour finir, un point intéressant est d’étudier le décodage pour tous les points (x, y) ∈ R2 : nous allons définir une
couleur pour chaque point de la lattice et un (x, y) sera mis de la même couleur que ce point si le décodage donne
comme résultat ce point de la lattice.
51 / 114 Année 2023 - 2024

Voici ce que cette étude donnerait avec les 2 bases que nous avons vues précédemment (vous pouvez voir la qualité du
décodage dégradée avec la seconde base) :
11.7 Quelques problèmes difficiles sur les lattices :

11.7.1 Réduction d’une base :
Voici les 3 problèmes principaux (selon moi) associés à la réduction d’une base :
Shortest Vector Problem (SVP) : étant donnée une base B d’une lattice L et un facteur d’approximation γ, il
faut trouver y ∈ L tel que ||y|| <= γ × Λ1 (L).
Decisional Shortest Vector Problem (DSVP) : étant donnée une base B d’une lattice L et un rayon r, il faut
pouvoir dire s’il existe y ∈ L tel que ||y|| <= r (y peut rester inconnu).
Shortest Basis Problem (SBP) : étant donnée une base B d’une lattice L et un facteur d’approximation γ,
trouver B ′ de telle sorte que la longueur du plus court vecteur de la base est γ fois plus grande que la longueur
du plus long vecteur dans la base la plus courte.
Tous ces problèmes peuvent être résolus en utilisant l’algorithme LLL en temps polynomial si γ est (4/3)(n−1)/2 . La
complexité que j’ai pu trouver est O(n6 ×B 3 ) avec n la dimension de la lattice et B la nombre de bits des nombres dans
la lattice (du coup on peut moduler le nombre de bits des nombres de la lattice pour obtenir une certaine sécurité).
Donc la clé publique serait la ”grande base” car c’est elle qui va rendre le CVP difficile pour un certain mot, et la clé
privée sera la ”petite base” dont les vecteurs seront pratiquement orthogonaux et qui permettra de résoudre le CVP
très facilement.
11.7.2 Décodage :
Les problèmes de cette catégorie peuvent être décrits de la façon suivante (d(t, L) dénote la distance au vecteur de la
lattice le plus proche) :
Closest Vector Problem : étant donnée une base B d’une lattice L, un point t ∈ Zn et un facteur d’approximation
γ, trouver y ∈ L tel que ||t − y|| < γ × d(t, L).
Decision Closest Vector Problem (DCVP) : étant donnée une base B d’une lattice L, un point t ∈ Zn et un
rayon r, dire s’il existe y ∈ L tel que ||t − y|| <= r (y peut rester inconnu).
Bounded Distance Decoding (BDD) : étant donnée une base B d’une lattice L, un point t ∈ Zn et un paramètre
de distance α tel que d(t, L) < α × Λ1 (L), trouver y ∈ L tel que ||y − t|| < α × Λ1 (L).
Learning With Errors (LWE) : étant donné q, χ et des échantillons indépendants, trouver s. Il y a aussi la version
décisionelle où il faut distinguer sir les échantillons sont purement random (pas de solution) ou construits grâce
à la règle.
Pour résoudre le CVP, nous utiliserons l’algorithme de Babai qui peut être décrit de 2 façons :
On applique la méthode que nous avons vue précédemment en calculant l’inverse de la base, puis en réalisant la
multiplication et finalement en prenant le vecteur correspondant à l’arrondi de tous les ai obtenus. La complexité
de cette méthode est totalement dépendante à la complexité de l’inversion qui eset O(n3 ).
On prend le target t qui nous est donné, on le ”divise” (via projection orthogonale) par chacun des vecteurs de
la base et on retire l’arrondi du coefficient multiplié par le vecteur de la base associé. Ici, la complexité sera en
O(n2 ).
Le second algorithme peut être décrit de la façon suivante :
1 Appliquer LLL sur la base B
2 resteCourant = t
3 Pour i allant de 1 à n :
4 coefficient = round (( resteCourant . B [ i ]) / ( B [ i ] . B [ i ]) )
5 resteCourant -= coefficient * B [ i ]
6 Retourner t - resteCourant
52 / 114 Année 2023 - 2024

11.8 Le cryptosystème GGH basé sur les lattices :

11.8.1 Ratio de Hadamard :
Pour savoir si les vecteurs d’une base sont quasiment orthogonaux, on va calculer le ratio de Hadamard (plus il est
proche de 1 plus les vecteurs sont orthogonaux et c’est l’inverse plus il est proche de 0) :
!1/n
|det(L(B))|
→
− →
−
|| b1 || × · · · × || b2 ||
L’idée est que l’on compare l’hypervolume d’une base de vecteurs parfaitement orthogonaux (le calcul du déterminant)
à l’hypervolume formé par les longueurs des vecteurs de la base courante et on en prend la racine n-ième.
Si nous reprenons l’exemple de la partie sur le CVP, nous pouvons obtenir les résultats suivants :
1/2
10
B1 = {(−1, −3), (3, −1)} : √ √ =1
10 × 10
1/2
10
B2 = {(4, 2), (7, 1)} : √ √ ≈ 0.562
20 × 50
Vous vous souvenez que la première base est parfaitement orthogonale (d’où le ratio de 1) alors que la seconde l’est
beaucoup moins : on le voit, le ratio est plus proche de 0.
11.8.2 Génération de clé :

→
−
La première étape consiste à prendre une base aléatoire B de vecteurs bi dont ces derniers seront quasiment orthogo-
naux (l’idée est que cette base permettra le décodage facilement avec l’algorithme de Babai). Pour la vérification de
l’orthogonalité, il vous suffira de calculer le ratio d’Hadamard et vous assurer qu’il est suffisamment proche de 1.
Ensuite, nous allons créer une matrice unimodulaire U (en combinant plein d’opérations sur les colonnes comme nous
l’avons vu avant) et nous pourrons donc calculer B ′ = B × U et s’assurer que son ratio de Hadamard est suffisamment
proche de 0.
La clé privée sera (B, U ) et la clé publique B ′ et le code pour la génération des clés est donné plus bas.
Voici un premier exemple dans lequel le ratio de Hadamard de B devait être plus grand que 0.95 :
     
4 5 −3 −3 −56540 −5512462 15099 −688559 −74525215 ···
−3 −5 −1 −2  1492343 145499114 −397745 18174225  ′
−48332776 · · ·
B= −5 4 −3 4  U = 13466499
  B =  
1312944565 −3589182 163999280  21000939 · · ·
−3 5 4 −4 13787091 1344201237 −3674789 167903536 6348967 ···
L’angle entre les différents vecteurs de la base est :
b1 b2 b3 b4 b′1 b′2 b′3 b′4
b1 x 90.0° 82.4° 74.2° b′1 x 82.2° 0.00° 0.00°
b2 90.0° x 88.0° 81.9° b′2 82.2° x 82.2° 82.2°
b3 82.4° 88.0° x 64.6° b′3 0.00° 82.2° x 0.00°
b4 74.2° 81.9° 64.6° x b′4 0.00° 82.2° 0.00° x
Et pour finir, voici le calcul des ratios de Hadamard : H(B) = 0.951, H(B ′ ) = 0.000486.
Voici un seond exemple dans lequel le ratio de Hadamard de B devait être plus grand que 0.995 :
     
4 −1 4 2 807661 −4062130 80472 −80472 −55104698 ···
−3 −2 −3 4   111496 −560769 11109 −11109  ′  23463766 · · ·
B= U = 
−11784987 59272520 −1174208 1174203 B =  −6577526
  
4 −3 1 −1 · · ·
5 1 1 5 −2311305 11624694 −230289 230288 −19191711 ···
L’angle entre les différents vecteurs de la base est :
b1 b2 b3 b4 b′1 b′2 b′3 b′4
b1 x 84.5° 87.3° 89.0° b′1 x 0.00° 0.00° 0.00°
b2 84.5° x 90.0° 85.6° b′2 0.00° x 0.00° 0.00°
b3 87.3° 90.0° x 90.0° b′3 0.00° 0.00° x 0.00°
b4 89.0° 85.6° 90.0° x b′4 0.00° 0.00° 0.00° x
Et pour finir, voici le calcul des ratios de Hadamard : H(B) = 0.9978, H(B ′ ) = 1.926 × 10−7 .
53 / 114 Année 2023 - 2024

11.8.3 Chiffrement :
L’opération de chiffrement sera très simple : on commencera par mettre le message sous forme de vecteur (une idée
peut être de mettre les bits du message comme vecteur). Ensuite, nous ajouterons une erreur aléatoire qui ne devra
pas être trop grande sinon le décodage ne marchera pas, une idée est de la choisir aléatoirement suivant les mêmes
limites que B (et même moins) puis voir si le décodage marche (pour ne pas rendre la tâche trop facile à l’attaquant
et en même temps permettre le décodage).
Le chiffré peut donc s’exprimer en c = B ′ × m + e.
Prenons l’exemple du message m = (5, 7, 9, 3) (dans le second exemple de la partie d’avant) :

     
−55104698 277148757 −5490407 5490385 5 1631575301
 23463766 −118010856 2337834 −2337823 7 −694730125
v= × = 
 −6577526 33081613 −655358 655354  9  194751501 
−19191711 96524571 −1912184 1912174 3 568240308
Nous pouvons ensuite ajouter l’erreur, je propose 2 exemples (la première est assez petite et permet le décodage alors
que la seconde est trop grande et le fera échouer) :
       
1 1631575302 0 1631575301
2 −694730123 −2 −694730127
e1 = 
−2 , c1 =  194751501  , e2 = −1 , c2 =  194751500 
      
2 568240308 1 568240309
11.8.4 Déchiffrement :
La procédure pour le déchiffrement est un peu plus compliquée :
1. On commence par calculer B −1 × c, puis on arrondit les coefficients du vecteur résultat et on multiplie B par
ces nouveaux coefficients pour obtenir le vecteur le plus proche (algorithme de Babai) : la sortie sera appelée v.
2. On calcule (B × U )−1 × v pour retrouver la combinaison linéaire ayant donné le chiffré et donc le message.
Avec notre exemple précédent, nous avons :

   
−0.06369 −0.03821 0.070063 0.070063 −3470.354 −9876.249 −19533.74 4584.4056
−0.04822 −0.11464 −0.21838 0.067333 B ′−1 = −269.9989 −768.6746 −1519.141 356.11212 
B −1 = 
 

 0.152866 −0.10828 0.031847 0.031847  21506.509 61195.584 121073.46 −28428.66
0.042766 0.082802 −0.03275 0.110100 305.35420 873.91509 1706.5038 −393.1741
Nous pouvons ensuite calculer la combinaison linéaire des lignes de B donnant ci :
   
−23913773.140127 −23913772.923566
−3301248.7060964 −3301248.4849863
w1 = B −1 × c1 =   −1
 348937441.936305  , w2 = B × c2 =  348937442.216560 
 
68434596.4940855 68434595.9772520
En arrondissant les coefficients et en re-multipliant par B nous obtenons :
       
−23913773 1631575301 −23913773 1631575300
 −3301249  −694730125  −3301248  −694730127
v1 = B ×   348937442  =  194751501  , v2 = B ×  348937442  =  194751498 
      
68434596 568240308 68434596 568240309

Vous pouvez tout de suite voir que le décodage n’a pas fonctionné pour le second exemple.
La dernière étape consiste à calculer (B × U )−1 × vi , ce qui nous donne :

 
5
′−1
7
m1 = B × v1 = 
9

3
 
86413.5048828125
6727.883819580078
m2 = B ′−1 × v2 =   −535537.73046875 

−7562.8701171875
Et nous avons donc récupéré le message pour le premier et une mauvaise valeur pour le second (qui d’ailleurs à cause
d’erreurs d’arrondi en python ne donne pas exactement v2 lorsqu’on le re-multiplie par B ′ ).
54 / 114 Année 2023 - 2024

11.9 Le cryptosystème NTRU :

11.9.1 Les polynômes dans le cadre de NTRU :
Dans NTRU, nous nous placerons sur l’anneau R = Z[X]/(X N − 1) : il s’agit de l’ensemble des polynômes de degré
au plus N − 1 dont les coefficients sont des entiers. Par exemple :
Z[X]/(X 5 − 1) = {a0 + a1 × X + a2 × X 2 + a3 × X 3 + a4 × X4 }, (a0 , a1 , a2 , a3 , a4 ) ∈ Z5
Sur cela, nous ajouterons un modulo m qui sera appliqué à l’ensemble des coefficients.
L’addition de 2 polynômes est défini par l’addition des coefficients 1 à 1 :

a(x)+b(x) = ((a0 +b0 ) mod m)+((a1 +b1 ) mod m)×X +((a2 +b2 ) mod m)×X 2 +· · ·+((aN −1 +bN −1 ) mod m)×X N −1
La soustraction de 2 polynômes consiste à faire la soustraction des coefficients 1 à 1 :
a(x)−b(x) = ((a0 −b0 ) mod m)+((a1 −b1 ) mod m)×X +((a2 −b2 ) mod m)×X 2 +· · ·+((aN −1 −bN −1 ) mod m)×X N −1
Par exemple 3X 3 + 7X 2 + 4X + 1 − (4X 3 + 2X 2 + 9X + 3) = 9X 3 + 5X 2 + 5X + 8 (mod 10)
La multiplication elle est plus complexe, sans réduction par X N − 1 elle se définirait de la manière suivante :
NX−1 NX−1
a(x) × b(x) = (a0 b0 mod m) + ((a0 b1 + a1 b0 ) mod m) × X + · · · = ai × bj × X i+j
i=0 j=0
Il ne faudra pas oublier d’appliquer le modulo devant chaque coefficient du résultat.
Vu que l’on fait la réduction par X N − 1, soit aN le coefficient devant X N on va ajouter −aN × X N + aN à notre
polynôme (ce qui aura pour effet de rajouter aN au coefficient a0 ). La nouvelle formule devient :
N
X −1 N
X −1
a(x) × b(x) = ai × bj × X (i+j) mod N
i=0 j=0
Encore une fois il ne faudra pas oublier de faire le modulo devant chaque coefficient.
Par exemple :
a(x) × b(x) = (3X 3 + 7X 2 + 4X + 1) × (4X 3 + 2X 2 + 9X + 3)
a(x)×b(x) = 12X 6 +6X 5 +27X 4 +9X 3 +28X 5 +14X 4 +63X 3 +21X 2 +16X 4 +8X 3 +36X 2 +12X +4X 3 +2X 2 +9X +3
a(x) × b(x) = 12X 2 + 6X + 27 + 9X 3 + 28X + 14 + 63X 3 + 21X 2 + 16 + 8X 3 + 36X 2 + 12X + 4X 3 + 2X 2 + 9X + 3
a(x) × b(x) = 84X 3 + 71X 2 + 55X + 60
a(x) × b(x) = 4X 3 + X 2 + 5X (mod 10)
Avant de passer à l’inversion de polynôme, il nous faut voir comment réaliser la division Euclidienne de polynômes.
En voici un exemple sur a(x) = 3X 6 + 12X 5 + 7X 4 + X 3 + 5X 2 + 10X + 7 et b(x) = 4X 3 + X 2 + 5X modulo m = 13 :
3X 6 + 12X 5 + 7X 4 + X3 + 5X 2 + 10X + 7 4X 3 + X2 + 5X
6 5 4 3 2
- 16X - 4X - 20X 4X + 2X + 6X + 6
5 4 3 2
8X + 0X + X + 5X + 10X + 7
- 8X 5 - 2X 4 - 10X 3
11X 4 + 4X 3 + 5X 2 + 10X + 7
- 11X 4 - 6X 3 - 4X 2
11X 3 + 1X 2 + 10X + 7
3 2
- 11X - 6X - 4X
2
8X + 6X + 7
Pour calculer l’inverse d’un polynôme, on utilisera l’algorithme d’Euclide étendu dont le principe est le suivant :
1 r = s * P + t * p (P : polyIrreductible , p : polynome )
2 r2 = s2 * P + t2 * p
3 Trouvons r = r2 * q + r3 <= > r3 = r - r2 * q
4 Donc : r3 = s * P + t * p - s2 * q * P - t2 * q * p
5 Donc : r3 = ( s - s2 * q ) * P + ( t - t2 * q ) * p
Et voici l’algorithme associé :

1 fonction inverse (a , P , m ) :
2 r , r2 = P , a
3 s , t , s2 , t2 = 1 , 0 , 0 , 1
4
5 Tant que r2 != polynome nul :
6 q , r = d i v i s i o n E u c l i d i e n n e (r , r2 ) # Des polynomes
7 r , r2 = r2 , r3
8
55 / 114 Année 2023 - 2024

9 s3 = s - s2 * q # Avec des polynomes

10 t3 = t - t2 * q
11 s , t , s2 , t2 = s2 , t2 , s3 , t3
12
13 Si r2 est un polynome constant :
14 Si r2 n ’ est pas le polynome unitaire : #j ’ explique pourquoi apr è s
15 a = coefficient du terme constant
16 multiplier t par l ’ inverse de a modulo m
17 retourner t
18 Sinon :
19 Retourner non inversible
Tout d’abord faisons un exemple avec a(X) = 2X 10 + X 9 + X 6 + 2X 4 + X 2 + X + 2 avec P (X) = X 11 − 1 et m = 3 :
q r Égalité
11
X +2 r =1×P +0×a
2X 10 + X 9 + X 6 + 2X 4 + X 2 + X + 2 r =0×P +1×a
9 7 6 5 4 3 2
2X + 2 X + X + X + 2X + 2X + X + 2X + 1 r = 1 × P + (X + 1) × a
8 6 4 3 2
2X + 1 X + 2X + X + X + 2X + 2X + 1 r = (X + 2) × P + X 2 × a
X 2X 7 + X 6 + X 5 + X 4 + 2X 3 + 2X + 1 r = (2X 2 + X + 1) × P + (2X 3 + X + 1) × a
2X + 2 X 6 + 2X 5 + X 4 + X 2 + 2X + 2 r = 2X 3 × P + (2X 4 + 2X 3 + 2X 2 + 2X + 1) × a
2X 2X 5 + X 4 + 2X 2 + X + 1 r = · · · × P + (2X 5 + 2X 4 + X 3 + 2X 2 + 2X + 1) × a
4 3 2
2X X + 2X + 2X + 2 r = · · · × P + (2X 6 + 2X 5 + X 3 + X 2 + 1) × a
2X 2X 3 + 2X 2 + 1 r = · · · × P + (2X 7 + 2X 6 + 2X 5 + 2X 3 + 2X 2 + 1) × a
2X + 2 X2 + X r = · · · × P + (2X 8 + X 7 + X 5 + 2X 4 + 2X 3 + X + 2) × a
2X 1 1 = · · · + (2X 9 + X 8 + 2X 7 + X 5 + 2X 4 + 2X 3 + 2X + 1)a
Aucun problème, nous avons bien trouvé a−1 (X) = 2X 9 + X 8 + 2X 7 + X 5 + 2X 4 + 2X 3 + 2X + 1.
Voyons maintenant pourquoi il faut parfois diviser par le terme constant à la fin, nous allons prendre le polynôme
a(X) = 3X 6 + 4X 5 + 10X 4 + 8X 3 + X 2 + 10X + 9 avec P (X) = X 7 − 1 et m = 11 :
q r Égalité
7
X + 10 r =1×P +0×a
6 5 4 3 2
3X + 4X + 10X + 8X + X + 10X + 9 r =0×P +1×a
5 4 3 2
4X + 2 7X + 3X + 2X + 2X + 10X + 3 r = 1 × P + (7X + 9) × a
2X + 6 10X 4 + 3X 3 + 2X 2 + 10X + 2 r = (9X + 5) × P + (8X 2 + 6X + 2) × a
4X + 9 10X 2 + 7 r = (8X 2 + 9X) × P + (X 3 + 3X 2 + 2) × a
X 2 + 8X + 5 9X r = · · · × P + (10X 5 + 4X 3 + 2X 2 + X + 3) × a
6X 7 7 = · · · × P + (6X 6 + 9X 4 + 8X 2 + 4X + 2) × a
Nous avons donc l’égalité : 7 = · · · × P + (6X 6 + 9X 4 + 8X 2 + 4X + 2) × a, pour la transformer en 1 = · · · il suffit de

multiplier les 2 côtés par 7−1 = 8 (mod 11) !
Donc : 1 = · · · × P + (4X 6 + 6X 4 + 9X 2 + 10X + 5) × a et finalement a−1 (X) = 4X 6 + 6X 4 + 9X 2 + 10X + 5.
Et terminons maintenant par le dernier cas possible un modulo qui n’est pas premier : m = 16, l’inversion ne
machera souvent pas et il faudra donc utiliser une autre méthode que nous décrirons plus loin. Prenons a(X) =
5X 6 + 6X 5 + 15X 4 + 3X 3 + 2X 2 + 9X + 1 et P (X) = X 7 − 1 :
q r Égalité
7
X + 15 r =1×P +0×a
6 5 4 3 2
5X + 6X + 15X + 3X + 2X + 9X + 1 r =0×P +1×a
5 4 3 2
13X + 10 X + 3X + 8X + 7X + 9X + 5 r = 1 × P + (3X + 6) × a
4 3 2
5X + 7 2X + 8X + 4X + X + 14 r = (11X + 9) × P + (X 2 + 13X + 7) × a
Il est impossible de continuer plus loin car il est impossible de trouver l’inverse de 2 modulo 16 (pour pouvoir enlever
le X 5 ), donc on pourrait conclure qu’il n’y a pas d’inverse mais cela serait faux.
L’idée pour trouver l’inverse sera d’utiliser le ”lifting” de solutions : il suffit de trouver la solution au problème
modulo p par exemple et il est ensuite possible de la calculer modulo p2 .
56 / 114 Année 2023 - 2024

Essayons de résoudre x2 = 14 (mod 25) :

Résolution modulo 5 : x2 = 14 (mod 5) ⇔ x2 = 4 (mod 5) ⇔ x ∈ {2, 3} Prenons x2 = 2 + 5t : donc (2 + 5t)2 = 14
(mod 25) ⇔ 4 + 20t = 14 (mod 25) ⇔ 20t = 10 (mod 25) ⇔ 4t = 2 (mod 5) ⇔ t = 3 (mod 5). Finalement
x2 = 2 + 5 × 3 = 17 est une solution à x2 = 14 (mod 25).
Prenons x2 = 3 + 5t : donc (3 + 5t)2 = 14 (mod 25) ⇔ 9 + 30t = 14 (mod 25) ⇔ 30t = 5 (mod 25) ⇔ 5t = 5
(mod 5) ⇔ t = 1 (mod 5). Finalement x2 = 3 + 5 × 1 = 8 est une solution à x2 = 14 (mod 25).
L’idée va maintenant être de l’appliquer à l’inversion de polynome : soit p un nombre, nous sommes arrivés à trouver
a(x) × b1 (x) = 1 (mod p) c’est à dire l’inverse de a(x) modulo p (en utilisant l’algorithme d’Euclide étendu ou une
élévation précédente).
Nous avons les 3 relations suivantes :
a(x) × b1 (x) = 1 + k × p (mod p2 ) pour un certain k.
2 × a(x) × b1 (x) = 2 + 2 × k × p (mod p2 ) pour le même k.
(a(x) × b(x))2 = (1 + k × p) = 1 + 2 × k × p (mod p2 ) pour le même k.
Nous pouvons donc prendre a(x) × b2 (x) = 2 × a(x) × b1 (x) − (a(x) × b1 (x))2 = 1 (mod p2 ) ce qui nous donne donc
b2 (x) = 2 × b1 (x) − a(x) × b1 (x)2 = b1 (x) × (2 − a(x) × b1 (x)) comme solution à a(x) × b2 (x) = 1 (mod p2 ) : il est
donc possible de construire une solution modulo p2 à partir d’une solution modulo p.
Pour notre exemple précédent a(X) = 5X 6 + 6X 5 + 15X 4 + 3X 3 + 2X 2 + 9X + 1, modulo 16, voici la méthode :
b1 (x) = a−1 (x) (mod 2) = X 6 + X + 1
b2 (x) = 2 × b1 (x) − a(x) × b1 (x)2 (mod 4) = X 6 + 2X 5 + 2X 4 + 2X 3 + 2X 2 + X + 3
b3 (x) = 2 × b2 (x) − a(x) × b2 (x)2 (mod 16) = X 6 + 14X 5 + 10X 4 + 6X 3 + 14X 2 + 13X + 15
Et nous avons donc notre inverse : b3 (x) = a−1 (x) (mod 16).
Une autre question se pose si nous voulons l’inverse modulo 32 par exemple : l’idée va être de le trouver modulo
64, puis de prendre tous les coefficients modulo 32.
Supposons que nous avons b(x) = a−1 (x) (mod pn ) et que nous voulions b′ (x) = a−1 (x) (mod pm ) avec m < n, nous
avons donc que a(x) × b(x) = 1 + k × pn = 1 + (k × pn−m ) × pm = 1 (mod pm ) donc l’inverse modulo 32 est le même
que l’inverse modulo 64, il suffit de prendre chacun des coefficients modulo 32.
11.9.2 Le cryptosystème :
Tout d’abord, il y aura 6 paramètres importants :
N : le degré maximal (non atteint) de tous les polynômes, la réduction se fera via X N − 1
p : une première valeur de modulo petite.
q : une seconde valeur de modulo, première avec p et beaucoup plus grande.
df , dg et d : seront expliqués plus loin.
Pour la génération de la clé, il faudra commencer par générer 2 polynômes aléatoires dont les coefficients seront soit
−1, soit 0, soit 1. f aura df coefficients à 1 et df − 1 coefficients à -1, g aura dg coefficients à 1 et dg coefficients à -1.
Ces 2 polynômes seront appelés f et g et il faudra que f soit inversible modulo p et modulo q. f formera la clé privée.
Une fois cela fait, il faut calculer h = p × f −1 × g (mod q) qui formera la clé publique.
Pour le chiffrement c’est très simple :

m sera le message et il sera également centré autour de 0 : l’intervalle sera [−(p − 1)/2, (p − 1)/2].
r sera une valeur aléatoire aussi centrée autour de 0 (avec d coefficients à 1 et d à -1).
Pour finir, il ne vous restera plus qu’à calculer c = r × h + m (mod q).
Pour le déchiffrement, c’est un peu plus compliqué :

Il faut commencer par calculer a = f × c (mod q) = p × r × g + f × m (mod q). Ensuite, l’idée serait de faire un
modulo p pour récupérer f × m (mod p) et finir le déchiffrement. Malheureusement, si p × r × g >= q, alors vu que
gcd(p, q) = 1 le résultat modulo q pourrait ne plus être un multiple de p. Prenez l’exemple de 3 × 3 × 4 = 36 = 4
(mod 32) qui n’est plus un multiple de 3.
Donc l’idée est de dire que le déchiffrement ne fonctionnera que si p × r × g + f × m n’a pas besoin d’être réduit
modulo q (c’est à dire que tous ses coefficients sont entre 0 et q − 1). Le coefficient maximal du membre de gauche de
l’addition sera p × (d + dg ) × 1 et pour le membre de droite cela sera p × (df + N ) × 1 (si tous les coefficients de m
sont à 1), ce qui nous donne un coefficient maximal de p × (d + df + dg + N ).
Mais tous ces calculs ne fonctionnent que si a est centré, s’il ne l’était pas le coefficient maximal du membre de gauche
serait p × (d + dg ) × (q − 1)2 ce qui va totalement détruire le décodage.
Au final, si on veut que le décodage marche à coup sûr, il faut que q/2 = p × (d + df + dg + N ) + 0.5 (une bien meilleure
borne minimale pour q existe très probablement).
57 / 114 Année 2023 - 2024

11.9.3 Un exemple :
Nous allons reprendre l’exemple de Wikipédia qui utilise les paramètres suivants :
N, p, q, df , dg , d = 11, 3, 32, 3, 3, 3.
Les 2 polynômes f et g sont les suivants :

f (X) = −X 10 + X 9 + X 6 − X 4 + X 2 + X − 1 = 2X 10 + X 9 + X 6 + 2X 4 + X 2 + X + 2 (mod 3)
g(X) = −X 10 − X 8 + X 5 + X 3 + X 2 − 1 = 2X 10 + 2X 8 + X 5 + X 3 + X 2 + 2 (mod 3)
Voici maintenant les inverses de f modulo p et q :
fp (X) = 2X 9 + X 8 + 2X 7 + X 5 + 2X 4 + 2X 3 + 2X + 1 (mod 3)
fq (X) = 30X 10 + 18X 9 + 20X 8 + 22X 7 + 16X 6 + 15X 5 + 4X 4 + 16X 3 + 6X 2 + 9X + 5 (mod 32)
Pour finir, il ne reste plus qu’à calculer h = p × fq × g (mod 32), qui pour notre exemple vaut :
h(X) = 16X 10 + 19X 9 + 12X 8 + 19X 7 + 15X 6 + 24X 5 + 12X 4 + 20X 3 + 22X 2 + 25X + 8 (mod 32)
Pour le chiffrement, nous prendrons : r(X) = −X 7 − X 5 + X 4 + X 3 + X 2 − 1 = 31X 7 + 31X 5 + X 4 + X 3 + X 2 + 31

(mod 32).
m(X) = X 10 + X 9 − X 8 − X 4 + X 3 − 1 = X 10 + X 9 + 31X 8 + 31X 4 + X 3 + 31 (mod 32).
Il ne reste plus qu’à faire le calcul :
c = r × h + m = 19X 10 + 6X 9 + 25X 8 + 7X 7 + 30X 6 + 16X 5 + 14X 4 + 24X 3 + 26X 2 + 11X + 14 (mod 32)
Pour le déchiffrement, nous allons commencer par calculer a = f × c (mod q), ici :
a = 25X 10 + 29X 9 + 5X 8 + 7X 7 + 6X 6 + 7X 5 + 10X 4 + 21X 3 + 22X 2 + 25X + 3 (mod 32)
Pour la formule nous avons a = p × g × r + m × f (mod q).
Il faut ensuite re-centrer a, ce qui nous donne :
a = −7X 10 − 3X 9 + 5X 8 + 7X 7 + 6X 6 + 7X 5 + 10X 4 − 11X 3 − 10X 2 − 7X + 3 (mod 32)
Pour finir, vous pouvez appliquer un modulo p = 3 :
a = 2X 10 + 2X 8 + X 7 + X 5 + X 4 + X 3 + 2X 2 + 2X
Puis multiplier par fp et vous aurez le message :
m = a × fp (mod 3) = −X 7 − X 5 + X 4 + X 3 + X 2 − 1
Le taux de déchiffrement avec les paramètres donnés et en changeant juste le message est 99.91%.
11.9.4 Avec des lattices :

Tout d’abord, notez qu’en réalité, dans la spécification originale, h = g × fq (il n’y a pas la multiplication par p elle
est uniquement rajoutée lors du chiffrement). Les nouvelles clés seraient donc :
f (X) = −X 10 + X 9 + X 6 − X 4 + X 2 + X − 1 = 2X 10 + X 9 + X 6 + 2X 4 + X 2 + X + 2 (mod 3)
h(X) = 16X 10 + 17X 9 + 4X 8 + 17X 7 + 5X 6 + 8X 5 + 4X 4 + 28X 3 + 18X 2 + 19X + 24 (mod 32)
Une première attaque que l’on peut faire avec des lattices va consister à retrouver la clé privée à partir de la clé
publique et des paramètres. La lattice associée à l’instance NTRU sera définie par L = {(u, v) ∈ P, u × h = v (mod q)}
ce qui correspond à l’ensemble des couples de polynômes (u, v) tels que u × h = v (mod q).
Trouver une base est très simple, prenons u = 0 nous avons k × q à droite (si nous retirons le modulo), prenons u = 1
nous avons v = h, une base de cette lattice peut donc être :

0 1
B=
q h
Remarquez que h = p × g (mod q) et donc que g = h × f (mod q), donc :

f 0 1 x
= ×
g q h f
Sauf que les différentes variables sont des polynômes, il est donc possible de tout ré-écrire avec leurs coefficients :
     
f0 0 ··· 0 1 ··· 0 x0
 ..   .. . . . .. .. ..   .. 
 .  .
   . .. . . .   . 
 
fN −1  0 · · · 0 0 ··· 1  xN −1 
 
 g0  = q · · · 0
   × 
   h0 · · · hN −1 
  f0 

 .  . . . . . .   . 
 ..   .. . . .. .. .. ..   .. 
gN −1 0 · · · q hN −1 · · · h0 fN −1
Du coup nous savons que le couple (f, g) est dans L et c’est également probablement l’un des plus petits vecteurs de
cette lattice. Il est donc possible de casser NTRU en résolvant le problème SVP sur la lattice précédente.
58 / 114 Année 2023 - 2024

Il est possible de faire une analyse similaire sur la reconstruction d’un texte en clair à partir d’un texte chiffré :
       
0 0 ··· 0 1 ··· 0 x0 −r0
 ..   .. . . . .. .. ..   ..   .. 
 .  .
   . .. . . .   .   . 
    
 0  0 · · · 0 0 ··· 1  xN −1  −rN −1 
 = × + 
 c0  q · · · 0 p × h0 · · · p × hN −1 
  r0   m0 
   
  
 .  . . . . . .   .   . 
 ..   .. . . .. .. .. ..   ..   .. 
cN −1 0 · · · q p × hN −1 · · · p × h0 rN −1 mN −1
c est donc un point de la lattice définie par une base quasi-identique à avant auquel nous avons rajouté une petite er-
reur (représentée par le vecteur contenant −r et m). Donc, si on arrive à résoudre le CVP, on peut déchiffrer sans la clé !
En conclusion c’est uniquement parce que casser NTRU se base sur la résolution de problèmes sur les lattices qu’on
dit que c’est un cryptosystème basé sur les lattices.
11.10 Quelques programmes :

11.10.1 Divers :
Un premier programme pour trouver les angles entre toutes les paires de vecteurs de la base :
1 import math
2
3 """ vecteurs = [
4 [ 1, 0, 0 ],
5 [ 0, 3, 1 ],
6 [ 0 , 0 , -5 ]
7 ] """
8 vecteurs = [[ -8649 , -93 , 1] , [151 , 10 , 0] , [ -980 , -65 , 0]]
9
10 for i in range (0 , len ( vecteurs ) ) :
11 for j in range (0 , len ( vecteurs [0]) ) :
12 if i < j :
13 vecteurs [ i ][ j ] , vecteurs [ j ][ i ] = vecteurs [ j ][ i ] , vecteurs [ i ][ j ]
14
15 def p ro du i tS ca la i re ( v1 , v2 ) :
16 somme = 0
17 for i in range (0 , len ( v1 ) ) :
18 somme += v1 [ i ] * v2 [ i ]
19 return somme
20
21 def normSq ( v ) :
22 return p ro d ui tS ca l ai re (v , v )
23
24 def norm ( v ) :
25 return math . isqrt ( normSq ( v ) )
26
27 for i in range (0 , len ( vecteurs ) ) :
28 for j in range (0 , len ( vecteurs ) ) :
29 if i < j :
30 prod = pr od u it Sc al a ir e ( vecteurs [ i ] , vecteurs [ j ]) ** 2
31 norms = normSq ( vecteurs [ i ]) , normSq ( vecteurs [ j ])
32 cosValue = math . sqrt ( prod / ( norms [0] * norms [1]) )
33 print ( " cos : " , cosValue )
34 print (i , j , math . acos ( cosValue ) * (180 / math . pi ) )
Voici un autre programme pour trouver les points ayant les plus petites normes (donc les minimums seront contenus
dans la liste mais cette dernière contiendra également des valeurs qui ne sont pas des minimums) :
1 import math
2
3 # Function to compute the norm of a vector
4 def norm ( vector ) :
5 sumVal = 0
6 for i in range (0 , len ( vector ) ) :
7 sumVal += vector [ i ] * vector [ i ]
8 return math . sqrt ( sumVal )
9
10 def minimumsRec ( baseVectors , currentLinearComb , depth , maxDepth , limit , res ) :
11 if depth == maxDepth :
12 # We will get the norm of the current linear comb
13 normVal = norm ( c u r r e n t L i n e a r C o m b )
14
15 # Let ’s now put it in the res array
59 / 114 Année 2023 - 2024

16 if res [ -1][0] != -1 and normVal >= res [ -1][0] :

17 return
18
19 index = -1
20 for i in range ( len ( res ) - 1 , -1 , -1) :
21 if res [ i ][0] != -1 and normVal >= res [ i ][0] :
22 break
23 index = i
24
25 for i in range ( len ( res ) - 1 , index , -1) :
26 res [ i ] = res [ i - 1]
27 res [ index ] = [ normVal , [ c u r r e n t L i n e a r C o m b [ i ] for i in range (0 , len ( c u r r e n t L i n e a r C o m b ) ) ] ]
28 else :
29 for a in range ( - limit , limit + 1) :
30 # Computing the new linear combination
31 newLinComb = [ 0 ] * len ( c u r r e n t L i n e a r C o m b )
32 for i in range (0 , len ( c u r r e n t L i n e a r C o m b ) ) :
33 newLinComb [ i ] = c u r r e n t L i ne a r C o m b [ i ] + a * baseVectors [ depth ][ i ]
34 # It ’s not possible to break before if the norm is bigger than the biggest minimum
because the norm can decrease
35 minimumsRec ( baseVectors , newLinComb , depth + 1 , maxDepth , limit , res )
36
37 def minimums ( baseVectors , minimumCount , limit ) :
38 listeMins = [ [ -1 , [] ] for i in range (0 , minimumCount + 1) ]
39 c u r r e n t L i n e a r C o m b = [ 0 ] * len ( baseVectors [0])
40 minimumsRec ( baseVectors , currentLinearComb , 0 , len ( baseVectors ) , limit , listeMins )
41 return listeMins [1:]
42
43 # Les vecteurs de la base seront mis en ligne
44 matrix = [ [ 5 , 3 , 3 ] , [ 4 , 5 , 6 ] ]
45
46 print ( minimums ( matrix , 10 , 10) )
Et un autre programme en Python qui commence par une base d’une certaine lattice, puis lui applique k opérations
sur les colonnes pour obtenir une autre base de la même lattice :
1 import random
2
3 # Le programme suppose que toutes les matrices sont carrees
4 n = 3
5 base = [
6 [ 1, 0, 0 ],
7 [ 0, 3, 1 ],
8 [ 0 , 0 , -5 ]
9 ]
10
11 def multMatrices (A , B ) :
12 result = [ [ 0 for j in range (0 , n ) ] for i in range (0 , n ) ]
14 for j in range (0 , n ) :
15 prodScal = 0
16 for k in range (0 , n ) :
17 prodScal += A [ i ][ k ] * B [ k ][ j ]
18 result [ i ][ j ] = prodScal
19 return result
20
21 def invertMatrix ( l ) :
22 result = [ [ (1 if i == j else 0) for j in range (0 , n ) ] for i in range (0 , n ) ]
23 result [ l ][ l ] = -1
24 return result
25
26 def addMatrix ( l1 , c , l2 ) :
28 result [ l2 ][ l1 ] = c
29 return result
30
31 def swapMatrix ( l1 , l2 ) :
33 result [ l1 ][ l1 ] = 0
34 result [ l2 ][ l2 ] = 0
35 result [ l1 ][ l2 ] = 1
36 result [ l2 ][ l1 ] = 1
37 return result
38
39 def r a n d o m I n v e r t M a t r i x () :
40 ligne = random . randint (0 , n - 1)
41 return invertMatrix ( ligne )
42
43 def r an do m Ad dM at r ix ( r ) :
60 / 114 Année 2023 - 2024

44 ligne1 = random . randint (0 , n - 1)

46 while ligne2 == ligne1 : # IL FAUT QUE LES 2 LIGNES SOIENT DIFFERENTES ( sinon det (...) = c et pas 1
ou -1)
48 c = random . randint ( -r , r )
49 while c == 0 :
51 return addMatrix ( ligne1 , c , ligne2 )
52
53 def r a n d o m S w a p M a t r i x () : # Les 2 lignes peuvent etre les memes
56 return swapMatrix ( ligne1 , ligne2 )
57
58 k = 10
59 r = 100
60 for i in range (0 , k ) :
61 operation = random . randint (1 , 3)
62
63 m a t r i c e A U t i l i se r = None
64 if operation == 1 :
65 m a t r i c e A U t i l i s er = r a n d o m I n v e r t M a t r i x ()
66 elif operation == 2 :
67 m a t r i c e A U t i l i s er = r an d om Ad dM a tr ix ( r )
68 else :
69 m a t r i c e A U t i l i s er = r a n d o mS w a p M a t r i x ()
70 print ( m a t r i ce A U t i l i s e r )
71
72 base = multMatrices ( base , ma t r i c e A U t i l i s e r )
73 print ( base )
Et pour finir, voici l’algorithme pour réduire une base composée de 2 vecteurs :
1 import math
2
3 def nearestInt ( x ) :
4 if x <= x // 1 + 0.5 :
5 return x // 1
6 else :
7 return ( x // 1) + 1
8
9 def dot ( v1 , v2 ) :
10 result = 0
12 result += v1 [ i ] * v2 [ i ]
13 return result
14
15 def norm ( v ) :
16 return math . sqrt ( dot (v , v ) )
17
18 def reduce ( v1 , v2 ) :
19 if norm ( v1 ) < norm ( v2 ) :
20 return reduce ( v2 , v1 )
21
22 x , y = v1 , v2
23 while norm ( x ) > norm ( y ) :
24 q = nearestInt ( dot (y , x ) / dot (y , y ) )
25 newY = []
26 for i in range (0 , len ( y ) ) :
27 newY . append ( x [ i ] - q * y [ i ])
28 x , y = y , newY
29 return y , x
11.10.2 GGH :
Voici un programme qui génère une clé pour le cryptosystème GGH :
1 import math
2 import random
3 import numpy as np
4
5 def r a n d o m I n v e r t M a t r i x ( size ) :
6 l = random . randint (0 , size - 1)
7 result = [ [ (1 if i == j else 0) for j in range (0 , size ) ] for i in range (0 , size ) ]
8 result [ l ][ l ] = -1
9 return result
10
11 def r an do m Ad dM at r ix (r , size ) :
61 / 114 Année 2023 - 2024

12 l1 , l2 = random . randint (0 , size - 1) , random . randint (0 , size - 1)

13 while l2 == l1 :
14 l2 = random . randint (0 , size - 1)
16 while c == 0 :
19 result [ l2 ][ l1 ] = c
20 return result
21
22 def r a n d o m S w a p M a t r i x ( size ) : # Les 2 lignes peuvent etre les memes
23 l1 , l2 = random . randint (0 , size - 1) , random . randint (0 , size - 1)
25 result [ l1 ][ l1 ] = 0
26 result [ l2 ][ l2 ] = 0
27 result [ l1 ][ l2 ] = 1
28 result [ l2 ][ l1 ] = 1
29 return result
30
31 def dotProduct ( v1 , v2 ) :
32 somme = 0
34 somme += v1 [ i ] * v2 [ i ]
35 return somme
36
37 def norm ( v ) :
38 return math . sqrt ( dotProduct (v , v ) )
39
40 def hadamardRatio ( basis ) :
41 determinant = abs ( np . linalg . det ( basis ) )
42 normProduct = 1
43 for i in range (0 , len ( basis ) ) :
44 normProduct *= norm ([ basis [ j ][ i ] for j in range (0 , len ( basis ) ) ])
45 return math . pow ( determinant / normProduct , 1 / len ( basis ) )
46
47 def generateKey (n , limSmallBasis , limBigBasis ) :
48 # Generation de la cle publique
49 privB = None
50 while True :
51 # On commence par generer n vecteurs independants
52 # Ils seront mis en ligne puis la transposee sera retournee
53 privB = []
54 while len ( privB ) < n :
55 randomVector = []
57 value = random . randint ( -1 * limSmallBasis , limSmallBasis )
58 randomVector . append ( value )
59 privB . append ( randomVector )
60 # On calcule le rang pour savoir si la ligne ajoutee peut le rester
61 if np . linalg . matrix_rank ( privB ) < len ( privB ) :
62 privB . pop ()
63
64 # On fait la transposee
66 for j in range (0 , i ) :
67 privB [ i ][ j ] , privB [ j ][ i ] = privB [ j ][ i ] , privB [ i ][ j ]
68
69 # Maintenant , on calcule le ratio de Hadamard
70 if hadamardRatio ( privB ) >= 0.95 : # Une limite comme ca
71 break # On sort de la boucle
72
73 U , pubB = None , None
74 while True :
75 # On va generer la matrice unimodulaire U
76 U = [ [ 1 if i == j else 0 for j in range (0 , n ) ] for i in range (0 , n ) ]
77 while True :
78 operation = random . randint (0 , 2)
79 if operation == 0 :
80 U = np . matmul (U , r a n d o m I n v e r t M a t r i x ( n ) )
81 elif operation == 1 :
82 U = np . matmul (U , r a n d o m S w a p M a t r i x ( n ) )
83 else :
84 U = np . matmul (U , r an do mA d dM at ri x ( limBigBasis // 1000 , n ) )
85
86 good = True
88 for j in range (0 , n ) :
89 if abs ( U [ i ][ j ]) < limBigBasis :
90 good = False
62 / 114 Année 2023 - 2024

91 break
92 if good == False :
93 break
94 if good :
95 break
96 U = U . tolist ()
97
98 # pubB est le produit privB * U
99 pubB = np . matmul ( privB , U ) . tolist ()
100
101 # On calcule encore une fois le ratio de hadamard
102 if hadamardRatio ( pubB ) <= 0.01 : # Une autre limite comme ca
103 break
104
105 return (( privB , U ) , pubB )
106
107 (( privB , U ) , pubB ) = generateKey (4 , 5 , 10000)
108 print ( hadamardRatio ( privB ) )
109 print ( " Private B : " + str ( privB ) )
110 print ( " Private U : " + str ( U ) )
111 print ( " Public B : " + str ( pubB ) )
112 print ( hadamardRatio ( pubB ) )
Et voici un autre code pour faire le chiffrement et le déchiffrement dans GGH :

1 def GGHencrypt ( pubB , limSmallBasis , m ) :
2 # On calcule pubB * m
3 result = [ 0 ] * len ( m )
4 for i in range (0 , len ( m ) ) :
5 for j in range (0 , len ( m ) ) :
6 result [ i ] += pubB [ i ][ j ] * m [ j ]
7 print ( result )
8
9 # On ajoute l ’ erreur
11 result [ i ] += random . randint ( -( limSmallBasis - 1) // 2 , ( limSmallBasis - 1) // 2)
12 print ( result )
13
14 # On retourne le resultat
15 return result
16
17 def GGHdecrypt ( privB , U , c ) :
18 # On inverse B et B ’
19 inversePrivB = np . linalg . inv ( privB ) . tolist ()
20 pubB = np . matmul ( privB , U ) . tolist ()
21 inversePubB = np . linalg . inv ( pubB ) . tolist ()
22
23 # On calcule privB ^{ -1} * c
24 temp = [ 0 ] * len ( c )
25 for i in range (0 , len ( c ) ) :
26 for j in range (0 , len ( c ) ) :
27 temp [ i ] += inversePrivB [ i ][ j ] * c [ j ]
28
29 # On arrondit tous les coefficients
30 for i in range (0 , len ( temp ) ) :
31 temp [ i ] = round ( temp [ i ])
32
33 # On calcule v
34 v = [ 0 ] * len ( c )
37 v [ i ] += privB [ i ][ j ] * temp [ j ]
38
39 # On calcule inversePubB * v
40 m = [ 0 ] * len ( c )
43 m [ i ] += inversePubB [ i ][ j ] * v [ j ]
44
45 # On a besoin de round les coefficients pck l ’ inverse de pubB ne contient pas les valeurs " exactes "
47 m [ i ] = math . floor ( m [ i ])
48
49 return m
50
51 privB = [[ -4 , -1 , 4 , 2] , [ -3 , -2 , -3 , 4] , [4 , -3 , 1 , -1] , [5 , 1 , 1 , 5]]
52 U = [[807661 , -4062130 , 80472 , -80472] , [111496 , -560769 , 11109 , -11109] , [ -11784987 , 59272520 ,
-1174208 , 1174203] , [ -2311305 , 11624694 , -230289 , 230288]]
53 pubB = [[ -55104698 , 277148757 , -5490407 , 5490385] , [23463766 , -118010856 , 2337834 , -2337823] ,
63 / 114 Année 2023 - 2024

[ -6577526 , 33081613 , -655358 , 655354] , [ -19191711 , 96524571 , -1912184 , 1912174]]

54 c = GGHencrypt ( pubB , 5 , [ 5 , 7 , 9 , 3 ])
55 m = GGHdecrypt ( privB , U , c )
56 print ( m )
11.10.3 NTRU :
Voici un premier programme pour la gestion des polynômes :
1 import math
2 import random
3
4 # Un polynome est represente par un tableau
5 # Le 1 er element du tableau est le coefficient devant X ^0 , le suivant X ^1 , ...
6 # Exemple : 3 X ^3 - 4 X ^2 + 1 : [ 1 , 0 , -4 , 3 ]
7
8 # La fonction pour afficher un polynome
9 def a ff ic h eP ol yn o me ( polynome ) :
10 for i in range (0 , len ( polynome ) ) :
11 print ( str ( polynome [ i ]) , end = " " )
12 if i == 0 :
13 print ( " " , end = " " )
14 elif i == 1 :
15 print ( " X " , end = " " )
16 elif i >= 2 :
17 print ( " X ^ " + str ( i ) , end = " " )
18 if i != len ( polynome ) - 1 :
19 print ( " + " , end = " " )
20 print ()
21
22 # La fonction pour enlever les 0 a la fin d ’ un polynome
23 def f o r m a t G o o d P o l y n o m e ( polynome ) :
24 # On commence donc par compter le nombre de zeros a la fin
25 nomb reZerosF in = 0
26 for i in range ( len ( polynome ) - 1 , -1 , -1) :
27 if polynome [ i ] != 0 :
28 break
29 nombr eZerosF in += 1
30 # On prend ensuite la partie sans ces zeros
31 res = polynome [: len ( polynome ) - nombreZe rosFin ]
32 # Si le resultat ne contient aucune valeur on ajoute 0
33 if len ( res ) == 0 :
34 res . append (0)
35 # Retournons le resultat
36 return res
37
38 def a d d i t i o n n e r P o l y n o m e s ( polynome1 , polynome2 , N , modulo ) :
39 # On veut que le polynome de plus haut degre soit toujours le premier parametre
40 if len ( polynome1 ) < len ( polynome2 ) :
41 return a d d i t i o n n e r P o l y n o m e s ( polynome2 , polynome1 , N , modulo )
42 # Calcul du resultat ( on ajoute les coefficients de meme degre )
43 result = [ polynome1 [ i ] for i in range (0 , len ( polynome1 ) ) ]
44 for i in range (0 , len ( polynome2 ) ) :
45 result [ i ] = ( result [ i ] + polynome2 [ i ]) % modulo
46 # On retourne le resultat
47 return f o r m a t G o o d P o l y n o m e ( result )
48
49 def oppose ( polynome , N , modulo ) :
50 return [ ( modulo - polynome [ i ]) % modulo for i in range (0 , len ( polynome ) ) ]
51
52 def m u l t i p l i e r P o l y n o m e s ( polynome1 , polynome2 , N , modulo ) :
53 # On initialise le resultat avec des 0
54 result = [ 0 ] * ( len ( polynome1 ) + len ( polynome2 ) - 1)
55 # Calcul du resultat : le coefficient de X ^{ i + j } est la somme des coefficients de X ^ i * X ^ j
56 # On fait en meme temps la reduction modulo X ^ N - 1 ( c ’ est a ca que sert ( i + j ) % N ) : pour
enlever un X ^ N on fait -X ^ N + 1
57 for i in range (0 , len ( polynome1 ) ) :
58 for j in range (0 , len ( polynome2 ) ) :
59 result [( i + j ) % N ] += polynome1 [ i ] * polynome2 [ j ]
60 result [( i + j ) % N ] %= modulo
61 # S ’ occupe de renvoyer le polynome sans les 0 devant les termes de plus haut degre
63
64 def d i v i s i o n E u c l i d i e n n e ( polynome1 , polynome2 , modulo ) :
65 quotient = []
66 copi ePolynom e1 = [ polynome1 [ i ] for i in range (0 , len ( polynome1 ) ) ]
67
68 for i in range (0 , len ( polynome1 ) - len ( polynome2 ) + 1) :
69 # On recupere l ’ index en partant de la fin et on passe si besoin
64 / 114 Année 2023 - 2024

70 revIndex = len ( polynome1 ) - i - 1

71 if co piePolyn ome1 [ revIndex ] == 0 :
72 quotient = [ 0 ] + quotient
73 continue # On passe
74
75 if math . gcd ( polynome2 [ len ( polynome2 ) - 1] , modulo ) == 1 :
76 inverse = pow ( polynome2 [ len ( polynome2 ) - 1] , -1 , modulo ) # On sait qu ’ il existe ( car /
gcdValue donne un gcd de 1)
77 # On soustrait multP2 * polynome2 au polynome1
78 multP2 = ( copie Polynome 1 [ revIndex ] * inverse ) % modulo
79 for j in range (0 , len ( polynome2 ) ) :
80 revIndex2 = len ( polynome2 ) - j - 1
81 copi ePolynom e1 [ revIndex - j ] -= multP2 * polynome2 [ revIndex2 ]
82 copi ePolynom e1 [ revIndex - j ] %= modulo
83 # On ajoute au tableau
84 quotient = [ multP2 ] + quotient
85 else :
86 print ( " Pas inversible : " + str ( polynome2 ) )
87 return None
88
89 return f o r m a t G o o d P o l y n o m e ( quotient ) , f o r m a t G o o d P o l y n o m e ( copiePo lynome1 )
90
91 # Pour inverser un polynome modulo un nombre premier
92 def i n v e r s e P o l y n o m e M o d u l o P r e m i e r ( polynome , polyIrreductible , modulo ) :
93 N = len ( p o l y I r r e d u c t i b l e ) - 1
94
95 # In itialisa tion
96 r = [ p o l y I r r e d u c t i b l e [ i ] for i in range (0 , len ( p o l yI r r e d u c t i b l e ) ) ]
97 r2 = f o r m a t G o o d P o l y n o m e ([ polynome [ i ] % modulo for i in range (0 , len ( polynome ) ) ])
98 s, t = [ 1 ], [ 0 ]
99 s2 , t2 = [ 0 ] , [ 1 ]
100
101 while True :
102 r e s D i v i E u c l i d i e n n e = d i v i s i o n E u c l i d i e n n e (r , r2 , modulo )
103 if r e s D i v i E u c l i d i e n n e == None :
104 return None
105 quotient , reste = r e s D i v i E u c l i d i e nn e
106 r , r2 = r2 , reste
107
108 # Condition de sortie
109 if r2 == [ 0 ] :
110 if r != [ 1 ] :
111 if len ( r ) == 1 :
112 try : # Si pas inversible on retourne None
113 inverse = pow ( r [0] , -1 , modulo )
114 for i in range (0 , len ( t2 ) ) :
115 t2 [ i ] = ( t2 [ i ] * inverse ) % modulo
116 except Exception as e :
117 return None
118 else :
119 return None
120 break # and return t2
121
122 # Update des s
123 s3 = a d d i t i o n n e r P o l y n o m e s (s , oppose ( m u l t i p l i e r P o l y n o m e s ( s2 , quotient , N , modulo ) , N , modulo )
, N , modulo )
124 s , s2 = s2 , s3
125 # Update des t
126 t3 = a d d i t i o n n e r P o l y n o m e s (t , oppose ( m u l t i p l i e r P o l y n o m e s ( t2 , quotient , N , modulo ) , N , modulo )
, N , modulo )
127 t , t2 = t2 , t3
128
129 return f o r m a t G o o d P o l y n o m e ( t2 )
130
131 # La fonction pour inverser un polynome modulo une puissance de premier
132 def i n v e r s e P o l y n o m e M o d u l o P u i s s a n c e P r e m i e r ( polynome , polyIrreductible , premier , puissance ) :
133 N = len ( p o l y I r r e d u c t i b l e ) - 1
134
135 # In itialisa tion
136 modulo = premier ** puissance
137 p o l y I r r e d u c t i b le [0] = premier - 1
138 inverse = i n v e r s e P o l y n o m e M o d u l o P r e m i e r ( polynome , polyIrreductible , premier )
139 if inverse == None :
140 return None
141 p o l y I r r e d u c t i b le [0] = premier ** puissance - 1
142
143 # Iterations sucessives pour obtenir les inverses temporaires
144 temp = premier # La puissance courant du premier
145 while temp < modulo :
65 / 114 Année 2023 - 2024

146 temp = temp * temp

147 inverse = m u l t i p l i e r P o l y n o m e s ( inverse , a d d i t i o n n e r P o l y n o m e s ([ 2 ] , oppose (
m u l t i p l i e r P o l y n o m e s ( polynome , inverse , N , temp ) , N , temp ) , N , temp ) , N , temp )
148
149 for i in range (0 , len ( inverse ) ) :
150 inverse [ i ] %= modulo
151
152 return f o r m a t G o o d P o l y n o m e ( inverse )
Ensuite un programme en python pour générer une clé avec NTRU :

1 # La fonction pour generer un polynome aleatoire avec d1 bits a 1 et d2 bits a -1
2 def g e n e r a t e R a n d o m P o l y n o m i a l (N , d1 , d2 ) :
3 toReturn = [ 0 ] * N
4
5 for i in range (0 , d1 ) :
6 while True :
7 position = random . randint (0 , N - 1)
8 if toReturn [ position ] == 0 :
9 toReturn [ position ] = 1
10 break
11
12 for i in range (0 , d2 ) :
13 while True :
14 position = random . randint (0 , N - 1)
15 if toReturn [ position ] == 0 :
16 toReturn [ position ] = -1
17 break
18
19 return f o r m a t G o o d P o l y n o m e ( toReturn )
20
21 # La fonction pour la generation de cle avec NTRU
22 def g en er a te Ke yN T RU (N , baseP , puissP , baseQ , puissQ , df , dg ) :
23 # Creation du polynome irreductible
24 p o l y I r r e d u c t i b le = [ -1 ] + [ 0 ] * ( N - 1) + [ 1 ]
25
26 # Generation de f
27 f = None
28 while True :
29 f = g e n e r a t e R a n d o m P o l y n o m i a l (N , df , df - 1)
30 fp = i n v e r s e P o l y n o m e M o d u l o P u i s s a n c e P r e m i e r (f , polyIrreductible , baseP , puissP )
31 fq = i n v e r s e P o l y n o m e M o d u l o P u i s s a n c e P r e m i e r (f , polyIrreductible , baseQ , puissQ )
32 if fp != None and fq != None :
33 break
34
35 # Generation de g
36 g = g e n e r a t e R a n d o m P o l y n o m i a l (N , dg , dg )
37
38 # Generation de h
39 h = m u l t i p l i e r P o l y n o m e s ( fq , g , N , baseQ ** puissQ )
40
41 return (( f , fp , fq , g ) , h )
42
43 N = 11
44 baseP , puissP = 3 , 1
45 baseQ , puissQ = 2 , 5
46 df , dh , d = 3 , 3 , 3
47
48 (( f , fp , fq , g ) , h ) = g en e ra te Ke y NT RU (N , baseP , puissP , baseQ , puissQ , df , dh )
49 print ( " f : " , end = " " )
50 a ff ic he P ol yn om e ( f )
51 print ( " fp : " , end = " " )
52 a ff ic he P ol yn om e ( fp )
53 print ( " fq : " , end = " " )
54 a ff ic he P ol yn om e ( fq )
55 print ( " g : " , end = " " )
56 a ff ic he P ol yn om e ( g )
57 print ( " h : " , end = " " )
58 a ff ic he P ol yn om e ( h )
59 print ()
Et en voici un autre pour permettre de réaliser le chiffrement, le déchiffrement et tester l’efficacité :

1 # La fonction pour chiffrer un message avec NTRU
2 def encryptNTRU (N , baseP , puissP , baseQ , puissQ , d , h , m ) :
3 # Creation du polynome r
4 r = g e n e r a t e R a n d o m P o l y n o m i a l (N , d , d )
5
66 / 114 Année 2023 - 2024

6 # Calcul du resultat
7 result = m u l t i p l i e r P o l y n o m e s (r , h , N , baseQ ** puissQ )
8 for i in range (0 , len ( result ) ) :
9 result [ i ] = ( result [ i ] * ( baseP ** puissP ) ) % ( baseQ ** puissQ )
10 result = a d d i t i o n n e r P o l y n o m e s ( result , m , N , baseQ ** puissQ )
12
13 # La fonction pour dechiffrer un message avec NTRU
14 def decryptNTRU (N , baseP , puissP , baseQ , puissQ , f , fp , c ) :
15 q = baseQ ** puissQ
16
17 # Calcul de a
18 a = m u l t i p l i e r P o l y n o m e s (f , c , N , q )
19
20 # Centrage des coefficients de a
21 for i in range (0 , len ( a ) ) :
22 if a [ i ] > q // 2 :
23 a[i] = a[i] - q
24 # Modulo p
25 a = [ a [ i ] % ( baseP ** puissP ) for i in range (0 , len ( a ) ) ]
26
27 # Retrouvons le message
28 return m u l t i p l i e r P o l y n o m e s ( fp , a , N , baseP ** puissP )
29
30 # La fonction pour mesurer l ’ efficacite du decodage
31 def m e a s u r e E f f i c i e n c y (N , baseP , puissP , baseQ , puissQ , f , fp , h , testCount ) :
32 successCount = 0
33 for i in range (0 , testCount ) :
34 m = [ random . randint (0 , 2) for i in range (0 , N ) ]
35 m = [ -1 if m [ i ] == 2 else m [ i ] for i in range (0 , len ( m ) ) ]
36 m = formatGoodPolynome (m)
37
38 c = encryptNTRU (N , baseP , puissP , baseQ , puissQ , d , h , m )
39
40 mPrime = decryptNTRU (N , baseP , puissP , baseQ , puissQ , f , fp , c )
41 mPrime = [ -1 if mPrime [ i ] == 2 else mPrime [ i ] for i in range (0 , len ( mPrime ) ) ]
42
43 if m == mPrime :
44 successCount += 1
45
46 return successCount / testCount
47
48 m = g e n e r a t e R a n d o m P o l y n o m i a l (N , N // 3 , N // 3)
49 c = encryptNTRU (N , baseP , puissP , baseQ , puissQ , d , h , m )
50 mPrime = decryptNTRU (N , baseP , puissP , baseQ , puissQ , f , fp , c )
51 mPrime = [ -1 if mPrime [ i ] == 2 else mPrime [ i ] for i in range (0 , len ( mPrime ) ) ]
52
53 print ( " m : " , end = " " )
54 a ff ic he P ol yn om e ( m )
55 print ( " c : " , end = " " )
56 a ff ic he P ol yn om e ( c )
57 print ( " m ’ : " , end = " " )
58 a ff ic he P ol yn om e ( mPrime )
59 print ()
60
61 print ( " Pourcentage bon decodage : " + str ( m e a s u r e E f f i c i e n c y (N , baseP , puissP , baseQ , puissQ , f , fp ,
h , 10000) * 100) + " % " )
67 / 114 Année 2023 - 2024

12 L’interpolation lagrangienne :
12.1 Le but :
C’est une méthode très utile et très puissante qui permet de trouver un polynôme de degré k − 1 qui passe k points
que nous pourrons choisir. Ces points seront appelées ”points de contrôle” et seront notés (x1 , y1 ), ..., (xk , yk ), comme
vous vous en doutez ce seront les points par lesquels notre polynôme devra passer.
12.2 Cas particuliers :

Avant de voir comment l’interpolation de Lagrange fonctionne, nous allons étudier quelques cas particulier avec une
autre méthode. Cela nous permettra de voir à quel point l’interpolation de Lagrange est intéressante et simple.
Une droite passe par 2 points : (x1 , y1 ), (x2 , y2 ). Tout ce qu’il nous faut c’est trouver le coefficient directeur de cette
droite ainsi que son ordonnée à l’origine.
Le coefficient directeur est très facile à trouver, le voici :
y1 − y2
a=
x1 − x2
Pour l’ordonnée à l’origine nous savons que le point (x1 , y1 ) doit appartenir à la droite, il doit donc également être
une solution de l’équation y = ax + b, nous pourrons donc prendre b = y − ax.
Voici donc l’équation de la droite passant par les 2 points donnés :
y1 − y2 y1 − y2
y= x + y1 − x1 ×
x1 − x2 x1 − x2
Notez que si x1 = x2 , la fonction n’existe pas.
Pour 3 points, cela se complique un peu plus : il faudra trouver la fonction de degré 2 passant par les points
(x1 , y1 ), (x2 , y2 ), (x3 , y3 ). Nous allons donc chercher à trouver a, b, c dans ax2 + bx + c tels que les 3 points donnés
soient solutions de cette équation.
Cela peut se résoudre avec un système :

2
ax1 + bx1 + c = y1
 2     
 x1 x1 1 a y1
ax22 + bx2 + c = y2 ⇔ x22 x2 1 ×  b  = y2 
x23 x3 1 c y3

 2
ax3 + bx3 + c = y3
Avec cette équation, vous pouvez remarquer le lien très fort qu’il y a entre l’interpolation lagrangienne et les matrices
de Vandermonde. L’inverse d’une matrice de Vandermonde constituera une solution à l’interpolation lagrangienne et
avoir une solution à l’interpolation lagrangienne permettra d’inverser une matrice de Vandermonde !
Cette méthode pourrait être appliquée à n’importe quel nombre de points mais le problème est que l’inverse d’une
matrice ne peut être calculé qu’en un temps proportionnel à n3 , il nous faudra donc une solution plus efficace. De
plus, le faire à la main serait assez long.
12.3 Une base de polynômes :

Intéressons nous seulement aux abscisses des points de contrôle : x1 , ..., xk , il serait assez utile de pouvoir trouver un
ensemble de k polynômes tels que le polynôme final qui passera par les points donnés soit une combinaison linéaire
de nos polynômes de base (que nous appellerons f1 , ..., fk ). Avec 3 points, nous aimerions que la fonction f à obtenir
puisse s’écrire de la manière suivante : f = y1 × f1 + y2 × f2 + y3 × f3 .
Cette condition a un effet très intéressant, il est possible de calculer les polynômes de la base pour un certain n-uplet
de xi et ensuite modifier les yi librement sans avoir à re-calculer les polynômes de la base.
Pour accomplir cela, il faut que nos polynômes de base respectent les équations suivantes :
(
0 si i ̸= j
fi (xj ) =
1 si i = j
Par exemple, pour le premier polynôme, f1 (x1 ) = 1 et f1 (xj ) = 0 pour j >= 2 : cela permet de pouvoir choisir y1
juste en faisant : y1 × f1 sans modifier les autres ordonnées !
La manière la plus simple d’arriver à valider la première condition pour le polynôme f1 est la suivante : f1 (x) =
(x − x2 ) × ... × (x − xk ) : ce dernier vaudra 0 dès que nous prendrons x = x2 , x = x3 et ainsi de suite.
Pour obtenir la seconde condition, il faut tout d’abord remarquer que tous nos facteurs auront une valeur que nous
ne connaissons pas lorsque le calcul de f1 (x1 ) sera réalisé. Ce qu’il serait intéressant de faire est qu’ils deviennent
tous 1 quand nous voulons calculer f1 (x1 ) : nous allons diviser le facteur (x − xj ) par (x1 − xj ), de cette façon, nous
obtiendrons le comportement voulu.
Finalement, l’expression de fi est la suivante :
(x − x1 ) (x − xi−1 ) (x − xi+1 ) (x − xk )
fi (x) = × ··· × × × ··· ×
(xi − x1 ) (xi − xi−1 ) (xi − xi+1 ) (xi − xk )
68 / 114 Année 2023 - 2024

Tous les fi forment une base de l’ensemble des polynômes qui passent par les points (x1 , y1 ), ..., (xk , yk ).
Pour finir une remarque très importante : il faut que tous les xi soient différents pour que l’interpolation puisse être
réalisée (dans le cas contraire, il serait impossible de trouver une fonction).
12.4 Quelques exemples :

Pour manipuler la formule que nous venons tout juste de trouver nous allons faire quelques exemples.
Le premier sera avec 2 points (nous chercherons donc un polynôme de degré 1). Les points que nous prendrons
seront (2, y1 ), (5, y2 ). Commençons donc par le calcul des polynômes de la base :
f1 (x) = (x − x2 )/(x1 − x2 ) = (x − 5)/ − 3 = −1/3x + 5/3
f2 (x) = (x − x1 )/(x2 − x1 ) = (x − 2)/3 = 1/3x − 2/3
En conclusion tous les polynômes qui passent par les points (2, y1 ), (5, y2 ) peuvent s’écrire sous la forme d’une combi-
naison linéaire entre les 2 polynômes de la base trouvée : f = y1 × f1 + y2 × f2 .
Imaginons que nous ayons y1 = 2 et y2 = 5 (l’équation à trouver est évidente ici, c’est y = x), la fonction à prendre
sera 2 × f1 (x) + 5 × f2 (x) = −2/3x + 10/3 + 5/3x − 10/3 = x.
Notez que si nous n’avions pas donné de valeur précise à x1 et x2 , la formule générale de la fonction passant par
(x1 , y1 ), (x2 , y2 ) serait dans ce cas :
x − x2 x − x1
f (x) = y1 × + y2 ×
x1 − x2 x2 − x1
Enchaı̂nons avec un exemple un peu plus intéressant sur 4 points (nous chercherons un polynôme de degré 3). Les 4
points que nous prendrons seront les suivants : (4, 0), (6, 5), (8, −8), (10, 18).
Voici le détail du calcul du premier polynôme de la base :
x − 6 x − 8 x − 10 1 1 47
f1 (x) = × × = − × x3 + × x2 − × x + 10
4−6 4−8 4 − 10 48 2 12
Et voici maintenant la base au complet :
1
× x3 + 21 × x2 − 12 47


 f1 (x) = − 48 × x + 10
f (x) = 1 × x3 − 11 × x2 + 19 × x − 20

2 16 8 2
1 3 5 2 31


 f 3 (x) = − 16 × x + 4 × x − 4 × x + 15
1 3 3 2 13
f4 (x) = 48 × x − 8 × x + 6 × x − 4

Pour finir, le polynôme souhaité est donné par f (x) = 0 × f1 (x) + 5 × f2 (x) − 8 × f3 (x) + 18 × f4 (x) dont le résultat
du calcul est le suivant :
19 189 297
f (x) = × x3 − × x2 + × x − 292
16 8 2
69 / 114 Année 2023 - 2024

13 Annale du 24 novembre 2021 :

13.1 Question de cours :
13.1.1 Sujet :
Question a : quels sont les avantages et désavantages relatifs du chiffrement à flot sur le chiffrement par bloc. Donner
des exemples de tels algorithmes de chiffrement.
Question b : quelles sont les tailles de clé minimales qu’on doit prendre pour les algorithmes RSA ou El-Gamal ?
Quel est l’intérêt des systèmes basés sur les courbes elliptiques par rapport aux précédents ?
Question c : pour une fonction de hachage quelle taille de haché doit-on prendre au minimum et pourquoi ? Donner
des exemples de noms de fonctions de hachage.
Question d : expliquer pourquoi si on utilise du chiffrement à flot, réutiliser le même flot quasi-aléatoire sur différents
message est une mauvaise idée.
Question e : rappeler le schéma d’échange de clé de Diffie-Hellman ?
Question f : peut-on faire de l’échange de clé de manière générique à partir d’un algorithme de chiffrement à clé
publique. Si oui, décrire comment.
13.1.2 Réponses :
Question a : le chiffrement à flot est plus adapté à une transmission série car il va chiffrer bit par bit alors que le
chiffrement par blocs va demander d’avoir un certaine taille avant de pouvoir chiffrer. Les algorithmes de chiffrement
à flot sont du coup en général plus rapides que ceux par blocs. Le chiffrement par blocs permet la réutilisation de clé
pour chiffrer plusieurs messages alors que les conditions sur la clé sont beaucoup plus dures avec les chiffrements par
flot.
Exemples d’algorithmes de chiffrement par bloc : DES, AES, blowfish.
Exemples d’algorithmes de chiffrement à flot : RC4, A5/1.
Question b : actuellement, la taille de clé minimale pour ces 2 algorithmes est 1024 bits, même s’il faudrait passer à
2048 bits (pour avoir 112 bits de sécurité). L’intérêt de prendre les courbes elliptiques est que les tailles de clés sont
plus petites (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition de 2 points est
10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera donc qu’à partir
d’une certaine taille de clé.
Question c : pour avoir n bits de sécurité avec une fonction de hachage, il faudra prendre un haché √ de 2n bits
à cause du paradoxe des anniversaires qui montre qu’il y a 50% de chances d’obtenir une collision après 22n = 2n
éléments vus. Comme fonction de hachage, nous pouvons citer MD5 ainsi que la famille SHA : SHA 1, 2 et 3.
Question d : le chiffrement à flot fonctionne en xorant un flot de clé avec le message : c = m⊕k, si la même clé est uti-
lisée pour un autre message m′ , alors un attaquant qui voit passer c et c′ pourra calculer c⊕c′ = m⊕k⊕m′ ⊕k = m⊕m′ .
Imaginons ensuite que l’attaquant arrive à connaı̂tre un des clairs et le chiffré associé, il pourra déchiffrer n’importe
quel message.
Question e : il se produit en plusieurs phases :

1. Les 2 parties se mettent d’accord sur un groupe G de générateur g et d’ordre q.
2. Alice choisit un a aléatoire (inférieur à q) et envoie g a à Bob.
3. Bob choisit un b aléatoire (inférieur à q) et envoie g b à Alice.
Les 2 parties ont ensuite comme secret partagé g ab : Alice calcule (g b )a et Bob calcule (g a )b .
Question f : oui et c’est très facile, imaginons que Alice et Bob veulent échanger une clé symétrique :
1. Alice choisit une clé K.
2. Alice envoie la clé K chiffrée avec la clé publique de Bob.
3. Bob reçoit ce message et le déchiffre avec sa clé privée pour récupérer K
Une fois le protocole terminé, les 2 parties ont une clé commune K qu’aucun attaquant n’aura pu récupérer si le
chiffrement asymétrique utilisé est sûr.
70 / 114 Année 2023 - 2024

13.2 Exercice 1 - Autour de RSA :

13.2.1 Sujet :
Question a : montrer que pour le cryptosystème RSA, connaı̂tre n et φ(n) est équivalent à connaı̂tre la factorisation
de n.
Question b : calculer pour un module RSA n = 35 et un exposant public e = 5 l’exposant secret d associé à e.
Calculer le chiffré de 10 puis vérifier son déchiffrement.
Question c : on considère Alice qui utilise un schéma de chiffrement RSA (N, e) avec des paramètres de sécurité
classiques, pour un clair m elle calcule le chiffré de manière normale : c = me (mod N ). Comme elle trouve que faire
des calculs avec des gros nombres c’est long et compliqué, elle fait savoir à tout le monde qu’en ce qui la concerne elle
se ramènerait à chiffrer uniquement des messages m tels que m < 1000. Est-ce que cette façon de procéder change
la sécurité ? Est-ce que Eve qui voit passer des messages chiffrés d’Alice peut déchiffrer les chiffrés d’Alice ? Si oui,
comment ?
13.2.2 Réponses :
Question a :
n=p×q
φ(n) = (p − 1) × (q − 1) = n − p − q + 1
Nous connaissons donc :
p×q =n
p + q = n + 1 − φ(n) Mais, nous savons que (x − x1 )(x − x2 ) = x2 − (x1 + x2 ) × x + x1 × x2
Du coup, nous pouvons former le polynôme : x2 + (φ(n) − n − 1) × x + n et trouver ses racines qui seront p et q.
Question b :
La clé privée est l’inverse de e modulo φ(n). Ici, nous allons chercher l’inverse de 5 modulo φ(35) = 4 × 6 = 24 :
5−1 = 5 car 5 × 5 = 1 (mod 24).
Pour chiffrer, nous allons calculer me (mod n) = 105 (mod 35) = 100 × 100 × 10 = −5 × −5 × 10 = 250 = 5 (mod 35)
Pour déchiffrer, calculons md (mod n) = 55 (mod 35) = 25 × 25 × 5 = 500 = 150 = 10 (mod 35) : le déchiffrement
marche !
Question c :
Oui, cette façon de procéder diminue grandement la sécurité car il est maintenant possible de faire un brute force pour
trouver le texte en clair.
Eve commencerait par calculer une table des chiffrés de tous les messages entre 0 et 999 (car elle connaı̂t la clé publique
et peut donc chiffrer n’importe quel message de son choix). Ensuite, dès qu’elle verra passer le chiffré c, elle le cherchera
dans sa table et pourra récupérer le message associé.
13.3 Exercice 2 - LFSR :

13.3.1 Sujet :
type LFSR.
Le message binaire intercepté est C = 10001110010101
On connaı̂t d’autre part 6 bits du clair (les bits 5 à 10 - le bit numéro 1 étant le bit le plus à gauche) qui sont
respectivement 101010. On admet que la complexité linéaire de la suite chiffrante du LFSR est au plus 3 (polynôme
de rétroaction de degré 3).
13.3.2 Réponses :
On connaı̂t :
C = 10001110010101
M = ????101010????
K = ????010011???? : obtenue en faisant le XOR de ce que nous connaissons.
Trouvons les valeurs des ai :

- s8 = a2 × s5 + a1 × s6 + a0 × s7 ⇔ 0 = a2 × 0 + a1 × 1 + a0 × 0
- s9 = a2 × s6 + a1 × s7 + a0 × s8 ⇔ 1 = a2 × 1 + a1 × 0 + a0 × 0
- s10 = a2 × s7 + a1 × s8 + a0 × s9 ⇔ 1 = a2 × 0 + a1 × 0 + a0 × 1
De ces équations nous pouvons en déduire que a0 = 1, a1 = 0, a2 = 1.
71 / 114 Année 2023 - 2024

Nous pouvons ensuite trouver le restant des bits de la seed :

- s11 = a2 × s8 + a1 × s9 + a0 × s10 ⇔ 1 × 0 + 0 × 1 + 1 × 1 = 1
- s12 = a2 × s9 + a1 × s10 + a0 × s11 ⇔ 1 × 1 + 0 × 1 + 1 × 1 = 0
- s13 = a2 × s10 + a1 × s11 + a0 × s12 ⇔ 1 × 1 + 0 × 1 + 0 × 0 = 1
- s14 = a2 × s11 + a1 × s12 + a0 × s13 ⇔ 1 × 1 + 0 × 0 + 1 × 1 = 0
Et nous pouvons trouver les autres bits facilement car ce LFSR a une période de 7 : K = 01110100111010
Pour finir, il ne reste plus qu’à xorer le chiffré et la clé pour récupérer le texte en clair :
C = 10001110010101
K = 01110100111010
M = 11111010101111
13.4 Exercice 3 - Un échange de clé léger... trop léger :

13.4.1 Sujet :
Un protocole d’échange de clés pour les téléphones portable sa été proposé par Park, basé sur DH. Le système a un
module premier p et un générateur commun aux deux parties. Chaque partie i a une clé secrète xi et une clé publique
Xi = g xi (mod p). Pour faire une clé de session entre le client M (un téléphone) et la base B, on exécute le protocole
suivant :
1. B → M : g xB +NB
2. M → B : NM + xM
Avec NB et NM les nonces de B et M (nonce : number used once, un entier random).
B calcule sa clé de session de la manière suivante :

−1
NB
KM B = g xM +NM × XM
M calculé sa clé de session de la manière suivante :
−1
N M
KM B = g xB +NB × XB
Ils finissent le protocole en faisant un défi réponse utilisant KM B .
Question 1 : montrer que le protocole fonctionne et que c’est bien la même clé commune qui est calculée. Pour-
quoi ce protocole est potentiellement plus intéressant qu’un diffie-hellman classique pour un téléphone mobile par
exemple ?
Question 2 : montrer que si un attaquant connaı̂t une clé de session d’un tour précédent (il connaı̂t une clé commune
KM B ) pour lesquels il a enregistré des messages, alors il peut se faire passer pour B (indication : l’attaquant peut
rejouer des messages de la session précédente).
Question 3 : montrer qu’en fait un attaquant peut se faire passer pour B connaissant simplement les clés publiques
XB et XM . Qu’en concluez vous pour le protocole ?
13.4.2 Réponses :
Question 1 : nous allons tout simplement simplifier les expressions :
−1
N B N B N B N B
g xM +NM × XM = g xM +NM × g −xM = g xM +NM −xM = g NM = g NM ×NB
−1
NM NM NM NM
g xB +NB × XB = g xB +NB × g −xB = g xB +NB −xB = g NB = g NM ×NB
Ce protocole est plus intéressant qu’un diffie-hellman classique pour un téléphone mobile car le téléphone aura une
exponentiation modulaire à faire : il envoie juste NM + xM au lieu de g puissance ça. Du coup, cela demande moins
de ressources pour le téléphone.
Question 2 :
Connaı̂tre une clé de tour, cela veut dire que l’on connaı̂t KM B = g NM ×NB .
Vu que nous voulons nous faire passer pour la base, une première idée pourrait être d’arriver à dériver la même clé
que le téléphone.
L’idée sera de renvoyer g xB +NB comme premier message (nous ne connaissons ni xB ni NB ).
′
Ensuite, le téléphone va nous envoyer NM + xM
′
NB ×NM
La clé calculée par le téléphone sera : g .
′ ′
Nous savons que g NB ×NM /KM B = g NB ×(NM −NM ) . Nous pouvons calculer NM ′
− NM en faisant NM ′
+ x M − NM − x M
−1
(la différence des 2 message), pour g NB il suffit de calculer g xB +NB × XB . Finalement la clé sera donnée par :
′
(g NB )NM +xM −NM −xM × KM B .
72 / 114 Année 2023 - 2024

Question 3 :
L’attaquant va envoyer n’importe quel g xB +NB = XB × g NB : la clé dérivée par le téléphone sera g NB ×NM . Pour que
−1 NB ′ ′ ′
l’attaquant la calcule, il peut s’y prendre de la manière suivante : (g NB )NM +xM × (XM ) = g NB ×NM +xM ×NB ×
′ ′ ′
g −xM ×NB = g NB ×NM .
Ce protocole n’est donc absolument pas sécurisé.
13.5 Exercice 4 - Courbes elliptiques :

13.5.1 Sujet :
Question a : quel est l’intérêt des courbes elliptiques en cryptographie ? Rappeler le schéma de fonctionnement de
l’addition et du doublement pour le groupe des opints de la courbe.
Dans la suite, on considèrera la courbe y 2 = x3 + 4x + 4 (mod 5) définie sur K = Z/5Z.
Question b : combien y a-t-il de points sur la courbe et quels sont-ils ?
Question c : quelles sont sur le papier les différentes structures de groupes possibles ?
Question d : en calculant 2P et 4P pour suffisamment de points de la courbe, donner la structure du groupe

de la courbe.
Question e : existe-t-il un générateur pour le groupe (un point P tel que 0P, P, 2P, ... engendre le groupe) ? Si
oui, combien de générateurs existe-t-il ? En donner un le cas échéant.
Rappel de la formule de doublement du point P = (x1 , y1 ) :

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
13.5.2 Réponses :
Question a : l’intérêt de prendre les courbes elliptiques est que les tailles de clés sont plus petites par rapport à
du RSA ou du El-Gamal (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition
de 2 points est 10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera
donc qu’à partir d’une certaine taille de clé. Pour le schéma, refaire celui au début de la partie sur les courbes elliptiques.
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + 4x + 4 4 4 0 3 4
Cette courbe possède donc 8 points : (0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (4, 2), (4, 3), 0.
Question c : d’après le théorème de la courbe elliptique, nous avons 2 possibilités :

Isomorphisme avec Z/1Z ⊕ Z/8Z (n2 = 1, n1 = 8, n2 divise p − 1 = 4 et n1 = 8).
Question d :
Tout d’abord, si la structure de cette courbe elliptique est isomorphe à Z/1Z ⊕ Z/8Z qui est lui-même isomorphe
à Z/8Z, alors nous aurons φ(8) = 4 générateurs (si nous avons testé 5 points et que nous n’avons pas trouvé de
générateurs ce sera l’autre possibilité).
Il n’y qu’à tester 1P , 2P et 4P car l’ordre d’un point est un diviseur du nombre de points : ici 8.
(0, 2) :
- 2 × (0, 2) : coefficient : 4/(2 × 2) = 1 : (x3 , y3 ) = (1, 1 × −1 − 2) = (1, 2)
- 4 × (0, 2) = 2 × (1, 2) : coefficient : 2/4 = 1/2 = 3 : (x3 , y3 ) = (32 − 2 × 1, 3 × (1 − x3 ) − 2) = (2, 0)
Vu que 1P ̸= 0, 2P ̸= 0 et 4P ̸= 0, nous avons que (0, 2) est un générateur.
La structure de cette courbe elliptique est donc isomorphe à Z/1Z ⊕ Z/8Z.
Question e :
Oui, il y a un générateur, il y en a même φ(8) = 4.
P = (0, 2) est un exemple de générateur.
73 / 114 Année 2023 - 2024

13.6 Exercice 5 - Authentification :

13.6.1 Sujet :
Alice et Bob partagent un secret k eet ont décidé de l’utiliser dans le protocole suivant qui permet à Alice d’authentifier
Bob :
2. Bob répond en envoyant r ⊕ k.
L’analyse de Bob et Alice du protocole est la suivante : le protocole permet d’obtenir l’authentification puisque Alice
peut vérifier que l’envoyeur du message 2. connaı̂t le secret partagé k. Il est aussi séccurisé car seul des suites de bits
Question b : êtes-vous d’accord avec Bob et Alice sur la sécurité du protocole ? Justifiez.
13.6.2 Réponses :
Question a : lorsqu’elle reçoit c = r ⊕ k, elle va calculer k ⊕ c, récupérer le résultat et si ce dernier vaut r l’authenti-
fication aura réussi.
Question b : non, une personne qui voit passer les messages peut récupérer la clé : elle récupère r dans le pre-
mier message, puis elle peut obtenir k en interceptant le second message et en calculant k = r ⊕ (r ⊕ k).
74 / 114 Année 2023 - 2024


14.1 Questions de cours :
14.1.1 Sujet :
Question a : quels sont les avantages du chiffrement à clé secrète par rapport au chiffrement à clé publique, donner
Question b : expliquer pourquoi si on utilise du chiffrement à flot, réutiliser le même flot quasi-aléatoire sur différents
Question c : est-ce que la factorisation est un problème difficile à résoudre ? Comparer ce problème à la résolution
du problème du log discret sur un anneau de type Z/nZ ou sur des courbes elliptiques.
Question d : quelle est la complexité de la meilleure attaque connue sur le problème du logarithme discret sur
les courbes elliptiques sur un corps avec de l’ordre de 2n éléments en fonction de n et ce pour le cas d’un ordinateur
classique et aussi dans le cas d’un ordinateur quantique suffisamment puissant.
Question e : on utilise souvent la compression de données pour le stockage d’informations. Supposons qu’on veuille
compresser des données avec du chiffrement. Est-ce qu’il vaut mieux chiffrer et puis compresser ou le contraire.
Question f : qu’est ce que le schéma de partage de clés de Shamir ? donner un exemple d’utilisation de ce schéma.
14.1.2 Réponses :
Question b : le chiffrement à flot fonctionne en xorant un flot de clé avec le message : c = m⊕k, si la même clé est uti-
quel message.
Question c : oui c’est un problème difficile (il n’existe pas d’algorithme polynomial pour le résoudre sur un or-
dinateur ”conventionel” (non-quantique)). La complexité de la factorisation est L[1/3, (64/9)1/3 ] en utilisant le crible
algébrique. Pour la complexité du logarithme discret, elle est identique car c’est également la méthode du crible √
algébrique qui est utilisée pour le résoudre. En revanche, sur les courbes elliptiques, la meilleure attaque est en O( n)
(avec n le nombre de points de la courbe).
Question d : vu que le corps à 2n éléments, nous pouvons dire que la courbe a environ 2n points (d’après le théorème
de Hasse), et la meilleure attaque connue consiste à trouver 2 couples (c, d) et (c′ , d′ ) tels que cG + dQ = c′ G + d′ Q
(G étant le générateur et Q le point pour lequel on veut résoudre
√ le logarithme). Grâce au paradoxe des anniversaires,
nous savons que cette collision se produit en moyenne en 2n = 2n/2 couples√vus. Pour l’ordinateur quantique, le
meilleur algorithme connu est l’algorithme BHT qui trouver une collision en O( 3 2n = 2n/3 ).
Question e : chiffrer puis compresser ne fonctionnera pas car l’entropie des données après chiffrement sera très
élevée, or, une fonction de compression pourra le mieux compresser quand l’entropie est basse (qu’il y a des zones
prévisibles qui se répètent). Donc, il vaut mieux d’abord compresser et après chiffrer.
Question f : comme son nom l’indique c’est un schéma de partage de clés, donc chaque partie aura un ”morceau”
de la clé et il faudra que toutes les parties réunissent ces morceaux (via de l’interpolation lagrangienne dans le cas de
Shamir) pour pouvoir récupérer la clé et l’utiliser. Un exemple d’application réelle est dans une cérémonie des clés où
toutes les personnes doivent mettre leur carte dans le HSM (Hardware Security Module) pour l’initialiser : génération
des clés les plus importantes.
75 / 114 Année 2023 - 2024

14.2 Exercice 1 - Cryptographie à clé publique :

14.2.1 Sujet :
Question a : on souhaite faire signer un document par n personnes. Comment peut-on s’y prendre ? Donnez une
solution et analysez ses points forts/faibles en vous aidant des points suivants : longueur de la clé, longueur de la
signature, importance de l’ordre des signataires et si l’un des signataires triche ?
Question b : on suppose maintenant que lors de ses vacances (d’une durée fixe) un responsable souhaite déléguer
sa signature électronique à son adjoint (un peu comme une procuration). Comment peut-il s’y prendre ? Proposer un
cadre réaliste et proposer une solution. Bien sûr, l’adjoint doit pouvoir signer à la place du responsable mais sans que
le responsable donne sa clé secrète.
14.2.2 Réponses :
Question a : la solution la plus simple consiste à envoyer le document à tous les signataires, récupérer toutes leurs
signatures et les concaténer pour avoir la signature finale.
Le processus de signature serait le suivant : s = s1 ||s2 ||...||sk (avec k le nombre de parties) et si = Sign(ski , m).
Le processus de vérification étant donné le message et la signature serait le suivant : retourner 1 si V erif (pki , m, s) = 1
pour tout i ∈ [1, k].
La longueur de la clé sera k fois celle utilisée pour la signature : imaginons du RSA 1024 bits, les clés publiques et
privées auraient une taille de 1024 × k bits.
La longueur de la signature est k fois la longueur d’une seule signature.
Il n’y a pas d’importance dans l’ordre des signataires.
L’un de signataires triche : on peut dire que tricher correspond à signer à la place de quelqu’un d’autre, ici c’est
impossible à moins de connaı̂tre la clé secrète ou d’arriver à casser la signature sous-jacente.
Question b : nous allons nous placer dans le cas de la signature RSA : pour signer avec RSA, on calcule s = md
(mod n). Pour la vérification on va faire se (mod n) et on va voir si c’est égal au message m.
L’idée pour déléguer sa clé sera d’envoyer d + x × φ(n) pour une valeur de x aléatoire à l’employé : la signature donnera
la même chose car mφ(n) = 1 (mod n) et l’employé ne connaissant ni x ni φ(n) il ne pourra pas récupérer d. Pour la
vérification, on peut laisser se (mod n) (la même clé publique).
14.3 Exercice 2 - Cryptographie à clé secrète :

14.3.1 Sujet :
On suppose qu’Alice et Bob partagent uen clé aléatoire K dans {0, 1, 2}n et que Alice veut envoyer un message
14.3.2 Correction :
K : 01 00 10 10 00 01
M : 10 10 10 10 10 10
C : 11 10 00 00 10 11
76 / 114 Année 2023 - 2024

C : 01 11 01
M : 01 00 10

chiffré :
M = 00 10 00, K = 01 01 01
M = 01 10 00, K = 00 01 01
M = 00 01 00, K = 01 10 01
M = 01 01 00, K = 00 10 01
M = 00 10 01, K = 01 01 00
M = 01 10 01, K = 00 01 00
M = 00 01 01, K = 01 10 00
M = 01 01 01, K = 00 10 00
K = 102201
M = 222222
14.4 Exercice 3 - Calcul de la signature RSA avec le théorème des restes chinois :
14.4.1 Sujet :
On considère un module RSA : n = p × q et d l’exposant privé. Soit un message m à signer, on cherche à calculer Smd
(mod n). On note dp = d (mod p − 1), dq = d (mod q − 1) et iq = q −1 (mod p). Soient également Sp = mdp (mod p)
et Sq = mdq (mod q).
Question a : rappeler le théorème des restes chinois, montrer que S (mod p) = Sp et S (mod q) = Sq , expli-
quer alors pourquoion peut retrouver S à partir de Sp et Sq .
Question b : montrer que S = Sq + q × (iq × (Sp − Sq ) (mod p)).
Question c : expliquer l’intérêt (en terme de cout calculatoire) de calculer S par cette méthode plutôt que di-
rectement en calculant md (mod n).
14.4.2 Réponses :
Question a :
Le théorème des restes chinois permet de résoudre des systèmes d’équations modulaires : étant donnés k le nombre
d’équations, ni les modules et ai les restes nous pouvons retrouver la valeur de x (mod n1 × ... × nk ) (si tous les ni
77 / 114 Année 2023 - 2024

sont premiers entre eux) en calculant (via la méthode de Gauss) :
x = (a1 × N1 × (N1−1 (mod n1 )) + ... + ak × Nk × (Nk−1 (mod nk ))) (mod N )

S (mod p) = md (mod p) = mdq +k×(p−1) = mdq × (mp−1 )k = mdq (mod p)
C’est la même chose pour S (mod q).
Question b :
(Sq + q × (iq × (Sp − Sq ) (mod p))) (mod q) = Sq + 0 = Sq
(Sq + q × (iq × (Sp − Sq ) (mod p))) (mod p) = Sq + Sp − Sq = Sp
Question c :
Le coût d’une exponentiation modulaire si toutes les valeurs sont sur n bits est O(n3 ) : vu que l’exposant d est full-size
ce sera le coût de la signature.
Si elle est réalisée avec la seconde méthode, nous aurons 2 exponentiations modulaires sur des nombres de n/2 bits ce
qui nous donnera une complexité de (n/2)3 × 2 = n3 /4 : 4 fois plus rapide que précédemment (car les autres opérations
sont négligeables par rapport à l’exponentiation full-size).
14.5 Exercice 4 - Chiffrement :

14.5.1 Sujet :
Etant donnés deux protocoles pour lesquels l’envoyeur procède de la manière suivante : A : y = ek1 (x || H(k2 || x))
B : y = ek1 (x || sigkpr (H(x)))
Dans ces 2 protocoles : x est le message, H est une fonction de hachage, e un algorithme de chiffrement symétrique,
sig un algorithme de signature, k1 et k2 sont des clés secrètes connues uniquement par les 2 parties, kpr est la clé
privée de l’envoyeur.
Question a : donner une description étape par étape de ce que le receveur doit faire en recevant y pour retrou-
ver le message.
Question b : préciser en les justifiant si les propriétés suivantes sont vérifiées pour chacun des protocoles : confiden-
tialité, intégité, non répudiation.
14.5.2 Réponses :
Question a :
Pour le protocole A, on va d’abord commencer par déchiffrer y : dk1 (y) = x || H(k2 || x), à partir de cela on peut
ensuite retrouver x et vérifier son intégrité en calculant H(k2 || x) et en comparant avec la valeur recue.
Pour le protocole B, on va encore une fois commencer par déchiffrer y : dk1 (y) = x || sigkpr (H(x)) ce qui nous permet
une nouvelle fois de récupérer x et nous pouvons ensuite vérifier la signature mais cela ne permet pas de tester l’intégrité.
Question b :
Définition de non-répudiation : il s’agit de l’impossibilité de pouvoir nier avoir reçu / émis un message.
Protocole A :
Confidentialité : oui, car x est chiffré et n’apparaı̂t jamais en clair sur le réseau.
Intégrité : oui, la fonction de hachage va permettre de faire cette vérification et une collision semble difficile à
trouver ne connaissant pas k2 .
Non-répudiation : non, car vu que les 2 parties connaissent les clés k1 et k2 , on ne sait pas quelle partie aurait
pu envoyer le message et du coup les 2 peuvent nier avoir envoyé / reçu.
Protocole B :
Confidentialité : oui, car encore une fois, x est chiffré et n’apparaı̂t pas en clair sur le réseau.
Intégrité : non, il serait possible qu’un attaquant trouve une collision sur le message avec la fonction de hachage.
Non-répudiation : oui, car seul l’envoyer connaı̂t la clé privée kpr et il ne peut donc pas nier son envoi.
14.6.1 Sujet :
Dans la suite, on considèrera la courbe y 2 = x3 + x + 2 (mod 5) définie sur K = Z/5Z.
Question c : pour tous les points P de la courbe, calculer 2P et 4P .
78 / 114 Année 2023 - 2024


de la courbe.
Question e : donner un générateur du groupe (un point P tel que 0P, P, 2P, ... engendre le groupe) ? En déduire la
structure de groupe de la courbe.

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
14.6.2 Réponses :
Question a : l’intérêt de prendre les courbes elliptiques est que les tailles de clés sont plus petites par rapport à du
RSA ou du El-Gamal (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition de 2
points est 10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera donc
qu’à partir d’une certaine taille de clé. Pour rappeler le schéma de fonctionnement, reprenez les 2 schémas que nous
avons fait au début.
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + x + 2 2 4 2 2 0
Cette courbe possède donc 4 points : (1, 2), (1, 3), (4, 0), 0.
Question c :
Vu qu’il y a 4 points dans la courbe, nous aurons forcément que 4P = 0 pour tous les points.
2 × (1, 2) = (4, 0) : coeff = (3 × 1 + 1)/(2 × 2) = 1 : x3 = 1 − 2 = 4, y3 = 1 × (1 − 4) − 2 = 0.
2 × (1, 3) = (4, 0) : coeff = (3 × 1 + 1)/(2 × 3) = 2/3 = 4 : x3 = 42 − 2 = 4, y3 = 4 × (1 − 4) − 3 = 0.
2 × (4, 0) = 0 car y1 = 0
2×0=0
Question d :
Il y a 2 générateurs dans ce groupe : (1, 2) et (1, 3).
La structure du groupe est donc isomorphe à Z/1Z ⊕ Z/4Z qui est lui-même isomorphe à Z/4Z.

14.7.1 Sujet :
On considère le protocole de Schnorr. Soit p et q deux grands entiers tels que q divise p − 1 et soit g un entier d’ordre
q modulo p : notre groupe sera ⟨g⟩ qui possèdera q éléments.
Le secret détenu par Alice est un entier a ∈ [0, q − 1] et A = g −a (mod p).
Le protocole est ensuite le suivant :
1. Alice fournit un engagement aléatoire k dans l’intervalle [0, q − 1] et calcule K = g k (mod p) puis l’envoie à
Bob.
2. Bob choisit un défi r au hasard dans [0, q − 1] et le transmet à Alice.
3. Alice calcule la réponse y = (k + a × r) (mod q) et la transmet à Bob.
Pour finir, Bob vérifiera que g y × Ar = K (mod p).
Question a : faire un schéma de ce protocole.
Question b : montrer que le protocole fonctionne (en ce sens que si on connaı̂t le secret, on répond convenable-
ment quoiqu’il arrive).
Question c : donner un exemple où en anticipant un défi, un tricheur peut se faire passer pour Alice avec une
probabilité de 1/q. En déduire que la probabilité de tricher est supérieure à 1/q (on admet par la suite que cette
probabilité est exactement 1/q).
Question d : quel est l’intérêt de de protocole par rapport au protocole de Fiat-Shamir (en terme de nombre de
passes).
Question e : ce protocole vérifie-t-il la propriété de zero-knowledge ?
79 / 114 Année 2023 - 2024

14.7.2 Réponses :
Question a : voici le schéma :
Question b :
Il est possible de répondre à tout message vu qu’on envoie simplement (k + a × r) (mod q).
En connaissant la clé, si on envoie g k et y = (k + a × r) : Bob va calculer y × Ar = g y × g −a×r = g k+a×r−a×r = g k = K.
Question c :
Cela veut dire que l’attaquant connaı̂t la valeur du défi r (qui est une constante) mais il ne connaı̂t pas a.
L’attaquant peut commencer par envoyer K = Ar = g −a×r .
Ensuite, il va recevoir le défi r dont il a anticipé une valeur.
L’attaquant va ensuite envoyer y = 0 et du coup Bob va calculer g 0 × Ar = g −a×r qui est bien égal au K envoyé.
Vu qu’il y a q valeurs de r possibles, la probabilité de triche de l’attaquant est 1/q mais on ne peut pas exclure le
fait qu’il lui sera peut être possible de combiner les résultats pour plusieurs valeurs de r ce qui ferait augmenter sa
probabilité de triche.
Question d :
Dans le protocole de Shamir, la probabilité de triche est 1/2, du coup pour avoir une sécurité de n bits, il faut faire n
exécutions du protocole.
Dans le protocole au-dessus, la probabilité de triche est 1/q et q peut être choisi assez grand (par exemple avec un
premier de 1024 bits, on pourrait tout à fait avoir q sur 256 - 512 bits). Du coup avec de telles tailles, la sécurité
voulue peut être obtenue avec un tour de protocole.
Il faut tout de même noter que des exponentiations modulaires sont utilisées dans le second protocole et donc qu’il est
beaucoup plus long que celui de Shamir (pour un tour).
Question e :
La propriété de zero-knowledge est que ces échanges ne doivent rien dévoiler sur la clé : ici du point de vue d’un
adversaire r est aléatoire, la valeur de a est donc masquée totalement.
14.8 Exercice 7 - Changement de clé RSA :

14.8.1 Sujet :
Alice change sa clé RSA tous les 25 jours. Bob, lui, change sa clé tous les 31 jours. Sachant qu’Alice change sa clé
aujourd’hui et que Bob a changé sa clé il y a trois jours, déterminer quand sera la prochaine fois qu’Alice et Bob
changeront leur clé le même jour.
14.8.2 Réponses :
Il faut tout d’abord modéliser le problème sous forme de système d’équations modulaires :
(
x ≡ 0 (mod 25)
x ≡ −3 (mod 31)
80 / 114 Année 2023 - 2024

Une fois cela fait, il suffit d’appliquer le théorème des restes chinois pour trouver la solution :
( (
x ≡ 0 (mod 25) 31x ≡ 0 (mod 775)
⇔
x ≡ −3 (mod 31) 25x ≡ −75 (mod 775)
Nous pouvons ensuite additionner les 2 équations ce qui nous donne : 56x = −75 (mod 775).
Trouvons l’inverse modulaire de 56 modulo 775 :

775 = 56 × 13 + 47
56 = 47 × 1 + 9
47 = 9 × 5 + 2
9=4×2+1
Remontons maintenant la chaı̂ne :
1=9−4×2
1 = 9 − 4 × (47 − 9 × 5) = 9 × 21 − 47 × 4
1 = (56 − 47) × 21 − 47 × 4 = 56 × 21 − 47 × 25
1 = 56 × 21 − (775 − 56 × 13) × 25 = 56 × 346 − 775 × 25
Finalement : 1 = 56 × 346 − 775 × 25 et l’inverse modulaire de 56 est 346.
Donc : x = −75 × 346 = 400 (mod 775).

Ils changeront donc leur clé le même jour dans 400 jours.
14.9 Exercice 8 - Pile ou face au téléphone :

14.9.1 Sujet :
On souhaite trouver un protocole qui permet à deux personnes de tirer à pile ou face à distance (par téléphone) sans
possibilité de tricher pour aucun des deux.
Question a : rappeler les propriétés importantes des fonctions de hachage. Proposer un protocole simple utilisant
simplement une fonction de hachage permettant de jouer à pile ou face par téléphone.
Question b : pour éviter la possibilité qu’une des deux personnes puisse tricher, de quelles propriétés de la fonc-
tion de hachage a-t-on besoin ? Fonction à sens unique et/ou fonction sans collision ? Justifiez la réponse.
Question c : proposer maintenant un protocole qui utilise seulement le logaritmhe discret. Quels sont les avan-
tages et désavantages d’un tel protocole par rapport à celui d’avant ?
14.9.2 Réponses :
Question a : une fonction de hachage doit avoir 3 propriétés importantes :
Compression
Fonction à sens unique : étant donné y = f (x), il est difficile de retrouver x.
Fonction sans collision : il est difficile de trouver x ̸= x′ tels que H(x) = H(x′ ).
Voici le protocole que l’on pourrait réaliser pour les 2 parties :
81 / 114 Année 2023 - 2024

Question b :
Bob triche : s’il arrive à connaı̂tre le choix de Alice, il va répondre l’opposé de ce choix. On veut donc que Bob
ne puisse pas retrouver l’entrée de la fonction de hachage à partir du hash (sinon il pourra retrouver le choix
de Alice), du coup on a besoin de la propriété de fonction à sens unique.
Alice triche : elle se rend compte que le résultat n’est pas ce qu’elle veut (pour notre exemple ”face”), elle va
donc essayer de trouver une valeur de r que nous appellerons r′ telle que H(”face”||r′ ) = H(”pile”||r). Cela
revient à trouver une collision : nous voulons donc la propriété de fonction sans collision.
Question c :
Nous ne pouvons pas prendre vpile = 0 et vf ace = 1 sinon Alice pourra très facilement tricher : imaginons que le
résultat sorti soit face, elle va vouloir dire qu’elle avait donné face et pourra envoyer pour ce faire r − 1. Mais je vois
pas trop comment résoudre le problème.
Pour finir, ce protocole n’a que des désavantages par rapport à celui d’avant : il est plus long à cause des exponentia-
tions modulaires, plus difficile à implémenter, ...
82 / 114 Année 2023 - 2024


15.1.1 Sujet :
des exemples de tels algorithmes de chiffrement.
Question b : quelles sont les tailles de clé minimales qu’on doit prendre pour les algorithmes RSA ou El-Gamal ?
Quel est l’intérêt des systèmes basés sur les courbes elliptiques par rapport aux précédents ?
Question c : pour une fonction de hachage quelle taille de haché doit-on prendre au minimum et pourquoi ? Donner
des exemples de noms de fonctions de hachage.
Question d : les documents qui sont signés chez un notaire doivent être conservés 99 ans, décrivez de manière
sommaire une manière pour arriver à garder la validité d’une signature pour une période de 99 ans (sans prendre une
seule clé très importante). Quels sont les problèmes auxquels vous pensez pour votre proposition ?
Question e : montrer qu’une fonction de hachage résistante aux collisions n’est pas nécessairement résistante à
la pré-image.
15.1.2 Réponses :
flot.
Exemples d’algorithmes de chiffrement par bloc : DES, AES, blowfish.
Exemples d’algorithmes de chiffrement à flot : RC4, A5/1.
Question b : actuellement, la taille de clé minimale pour ces 2 algorithmes est 1024 bits, même s’il faudrait passer à
2048 bits (pour avoir 112 bits de sécurité). L’intérêt de prendre les courbes elliptiques est que les tailles de clés sont
plus petites (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition de 2 points est
10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera donc qu’à partir
d’une certaine taille de clé.
Question c : pour avoir n bits de sécurité avec une fonction de hachage, il faudra prendre un haché √ de 2n bits
à cause du paradoxe des anniversaires qui montre qu’il y a 50% de chances d’obtenir une collision après 22n = 2n
éléments vus. Comme fonction de hachage, nous pouvons citer MD5 ainsi que la famille SHA : SHA 1, 2 et 3.
Question d : une idée serait de signer le document de manière régulière avec une clé différente à chaque fois, cela
demande tout de même de savoir à quelle fréquence changer la signature et aussi plus on avance dans le temps plus il
faudra refaire la signature souvent pour éviter les attaques.
Question e : nous pouvons prendre la fonction de hachage H(x) = x qui prendra des entrées de 512 bits et donnera
512 bits en sortie : elle est résistante aux collisions car il n’y a aucune collision en revanche elle n’est pas du tout
résistante à la pré-image car c’est une fonction linéaire.

15.2.1 Sujet :
Bob.
83 / 114 Année 2023 - 2024

passes).
15.2.2 Réponses :
Question b :
Question c :
Question d :
Question e :
84 / 114 Année 2023 - 2024


15.3.1 Sujet :
15.3.2 Correction :
K : 01 00 10 10 00 01
M : 10 10 10 10 10 10
C : 11 10 00 00 10 11
C : 01 11 01
M : 01 00 10

chiffré :
M = 00 10 00, K = 01 01 01
M = 01 10 00, K = 00 01 01
M = 00 01 00, K = 01 10 01
M = 01 01 00, K = 00 10 01
M = 00 10 01, K = 01 01 00
M = 01 10 01, K = 00 01 00
M = 00 01 01, K = 01 10 00
M = 01 01 01, K = 00 10 00
85 / 114 Année 2023 - 2024


K = 102201
M = 222222

15.4.1 Sujet :
15.4.2 Réponses :
Compression
Question b :
86 / 114 Année 2023 - 2024

Question c :
15.5 Exercice 4 - Signature El-Gamal :

15.5.1 Sujet :
Question a : rappeler le schéma de signature El-Gamal, dans quel ensemble est choisi la clé secrète x ?
Question b : décrire une attaque dans le cas où le même aléa est utilisé pour signer 2 messages différents. Mon-
trer alors qu’on peut faire un cassage total et retrouver la clé secrète.
15.5.2 Correction :
Question a :
Génération des paramètres : on choisit un nombre premier p sur n bits, on choisit un générateur g d’un sous-groupe
d’ordre q de (Z/pZ)∗. La clé secrète est un nombre aléatoire x choisi entre 1 et p − 2 et la clé publique sera g x (mod p).
Signature d’un message : on va choisit k aléatoire entre 2 et p − 2, il faut que pgcd(k, p − 1) = 1, on pourra ensuite
calculer r = g k (mod p) ainsi que s = (H(m) − x × r) × k −1 (mod p − 1). Si jamais s = 0, refaire la signature avec un
k différent. La signature est le couple (r, s).
Vérification d’une signature : on va totu simplement vérifier que g H(m) = y r × rs (mod p).
Ca marche car H(m) = xr + sk (mod p − 1).
Question b :
Message 1 : r = g k (mod p) et s1 = (H(m1 ) − x × r) × k −1 (mod p − 1)
Message 2 : r = g k (mod p) et s2 = (H(m2 ) − x × r) × k −1 (mod p − 1)
L’attaque est simple, on va faire s1 −s2 = (H(m1 )−x×r−H(m2 )+x×r)×k −1 = (H(m1 )−H(m2 ))×k −1 (mod p−1) et
du coup on pourra récupérer la clé secrète en faisant k −1 = (s1 −s2 )×(H(m1 )−H(m2 ))−1 puis en prenant son inverse.
15.6 Exercice 5 - LFSR :

15.6.1 Sujet :
type LFSR. Le message binaire intercepté est 10001110010101. On connaı̂t d’autre part 6 bits du clair (les bits 5 à
10) qui sont respectivement 101010. Nous admettrons que la complexité linéaire de la suite chiffrante du LFSR est au
plus 3 (polynome de rétroaction de degré 3). Déchiffrer le message en entier.
15.6.2 Correction :
Il faut tout d’abord se souvenir que pour un LFSR, nous avons C = M ⊕ K. K est tout simplement la suite de bits s
générée par le LFSR. Nous avons donc :
c = 10001110010101
m = ????101010????
Si nous faisons un XOR entre ces 2 valeurs, nous obtenons :
s = ????010011????
87 / 114 Année 2023 - 2024

L’étape suivante va consister à trouver les ai qui vont permettre le calcul de tous les termes de la suite des si . Il
nous est dit que la complexité linéaire est d’au plus 3, commençons donc par 3 valeurs de ai .
Nous allons nous baser sur les bits 5 à 7 : 010.
Grâce à la relation du LFSR nous pouvons créer le système suivant :
Bit 8 : a2 × s5 + a1 × s6 + a0 × s7 = s8 ⇔ a2 × 0 + a1 × 1 + a0 × 0 = 0
Bit 9 : a2 × s6 + a1 × s7 + a0 × s8 = s9 ⇔ a2 × 0 + a1 × 0 + a0 × 1 = 1
Bit 10 : a2 × s7 + a1 × s8 + a0 × s9 = s10 ⇔ a2 × 1 + a1 × 0 + a0 × 0 = 1
Nous pouvons déduire de ces équations que a2 = 1, a1 = 0, a0 = 1.
Nous pouvons maintenant passer au calcul des bits restants de s :

s4 : 1 × s4 + 0 × s5 + 1 × s6 = 0 ⇔ s4 = 1
s3 : 1 × s3 + 0 × s4 + 1 × s5 = 1 ⇔ s3 = 1
s2 : 1 × s2 + 0 × s3 + 1 × s4 = 0 ⇔ s2 = 1
s1 : 1 × s1 + 0 × s2 + 1 × s3 = 1 ⇔ s1 = 0
Il faut également calculer ceux qui viennent après :
s11 = 1 × s8 + 0 × s9 + 1 × s10 = 1
s12 = 1 × s9 + 0 × s10 + 1 × s11 = 0
s13 = 1 × s10 + 0 × s11 + 1 × s12 = 1
s14 = 1 × s11 + 0 × s12 + 1 × s13 = 0
Finalement, nous avons trouvé la valeur complète de s : 01110100111010, vous pouvez également remarquer que nous
avons une période de 7 = 23 − 1 ce qui conforte notre idée qu’il n’y a pas d’erreur dans ce raisonnement.
Pour terminer, il reste à calculer le message en clair :

c = 10001110010101
s = 01110100111010
m = 11111010101111 (il suffit de faire le xor entre c et s).
15.7 Exercice 6 - Double encryption :

15.7.1 Sujet :
Supposons qu’Alice a la clé secrète k1 ∈ {0, 1}n et Bob a la clé secrète k2 prise du même ensemble. Ils veulent chiffrer
un message M de telle sorte que leurs 2 clés sont utilisées pour le déchiffrement. Ils considèrent l’utilisation d’un
algorithme de chiffrement par bloc E en utilisant l’une des 3 méthodes suivantes :
C ← Ek1 (Ek2 (M ))
C ← Ek1 ⊕k2 (M )
C ← (Ek1 (r), Ek2 (r ⊕ M )) avec r une chaı̂ne aléatoire fraı̂che de même taille que M .
Pour toutes ces méthodes, l’attaquant sera donné quelques couples clair/chiffré (M, C) et son but est de déchiffrer un
autre texte chiffré C ′ . On appellera (M, C, C ′ ) le challenge de l’attaquant. On peut supposer que le message M est
suffisamment long pour que la paire (M, C) définit uniquement les clés (k1 , k2 ) dans les méthodes 1. et 3.. Notez que
la reherche exhaustive du couple (k1 , k2 ) prend un temps en 22n .
Question a : pour toutes les méthodes le challenge (M, C, C ′ ) peut être cassé en approximativement 2n (en temps en
ignorant les facteurs logarithmes), expliquez comment vous casseriez le challenge pour haque méthode. Quelle méthode
est la plus facile à casser ?
Question b : supposons que la longueur de clé n est suffisamment large pour que les attaques de la partie a soit
infaisable, quelle est la méthode la plus efficace à utiliser ?
15.7.2 Correction :
Question a :
Le schéma le plus facile à casser est le premier : vu que le chiffrement est réalisé avec la clé k1 ⊕ k2 , c’est comme si on
chiffrait avec une seule clé k3 . Du coup, on peut faire une recherche exhaustive de la clé k3 ce qui se fera en temps 2n
vu qu’elle est de taille n.
Pour le premier schéma, le principe est le même que le double-DES : nous allons faire une attaque par Meet-In-The-
Middle. L’idée va être de diviser la chaı̂ne en M → r → C (pour le premier on utilisera Ek2 et pour le second Ek1 ).
L’attaque consiste ensuite à faire une table de toutes les valeurs de r possibles avec le message M et toutes les clés k2′
possibles (cette table devra être maintenue triée via un arbre binaire par exemple). Ensuite, on va faire un déchiffré
de C avec tous les k2′ possibles et pour chaque valeur r′ obtenue on ira la rechercher dans l’autre table. Obtenir une
correspondance entre la première table et une valeur de la seconde partie nous donne un couple possible (k1 , k2 ).
Pour le dernier schéma, l’idée sera similaire à celle d’avant. Nous allons faire une table des déchiffrés de Ek1 (r) xorées
avec M pour toutes les valeurs de k1 possibles, il y aura le r ⊕ M valide à un endroit de cette table, et il faudra
88 / 114 Année 2023 - 2024

la garder triée (pour que la recherche se fasse en log(n)). Une fois cela fait, nous allons pour chaque clé k2 faire un
déchiffrement de Ek2 (r ⊕ M ) et rechercher la valeur obtenue dans la table : chaque couple trouvé nous indiquera une
valeur de (k1 , k2 ) possible.
Question b :
Au niveau du temps, la solution la plus rapide sera le second algorithme de chiffrement car il ne demande qu’un seul
chiffrement.
15.8 Exercice 7 - Incremental hashing :

15.8.1 Sujet :
Soit p un nombre premier et g ∈ (Z/pZ)∗ un élément d’ordre premier q. Soit G le groupe généré par g et I l’ensemble
des entiers de 1 à q. Fixons n valeurs {g1 , ..., gn } ∈ G et définissons la fonction de hachage H : I n → G par :
H(x1 , ..., xn ) = g x1 × g x2 × ... × g xn
Question a : montrez que H est une fonction résisante aux collisions en supposant que le problème du logarithme dis-
cret dans G est difficile : montrez qu’un attaquant capable de trouver une collision pour H pour des valeurs aléatoires
g1 , ..., gn ∈ G peut être utilisé pour calculer le logarithme discret dans G. Indication : étant donné une paire g, h ∈ G,
votre but est de trouver un α tel que g α = h, choisissez g1 , ..., gn ∈ G de telle sorte qu’une collision sur le H résultant
révélera α.
Question b : soit M un message dans I n , supposons qu’Alice calcule le hash de M (H(M )), maintenant Alice
change une coordonnée de M pour obtenir un nouveau message M’. Montrez qu’Alice peut rapidement calculer H(M ′ )
depuis H(M ) en temps qui est dépendant sur la taille de M. Vous avez juste à montrer que après avoir fait un petit
change au message, il n’y a pas besoin de re-hasher le message entier. Les fonctions de hachage résistantes à ce type
de collisions supportent le ”incremental hashing”.
15.8.2 Correction :
Question a :
′
Trouver une collision pour H revient à trouver x et x′ tels que H(x) = g x1 × ... × g xn = gx′1 × ... × g xn = H(x′ ).
Pour faire cette collision, l’attaquant aura dû trouver de manière efficace x1 + ... + xn = x′1 + ... + x′n (mod q). Mais
la seule façon pour l’attaquant de trouver x1 + ... + xn de manière efficace est de résoudre le problème du logarithme
discret sur le haché H(x) : donc s’il arrive à casser la fonction de hachage, il arrivera à résoudre le problème du
logarithme discret.
Question b :
′
La solution est très simple, soit x′i la partie modifiée, on va tout simplement calculer H(x′ ) = (H(x)/g xi ) × g xi . La
′
division va enlever le facteur g xi et la multiplication va le remplacer par g xi .
89 / 114 Année 2023 - 2024


16.1.1 Sujet :
des exemples de tels algorithmes de chiffrement et leurs tailles de clé.
Question b : quel est l’intérêt des courbes elliptiques par rapport à un algo de type RSA ? Quelle est la taille
de clé souhaitable pour RSA, AES ou les protocoles basés sur les courbes elliptiques ?
Question c : qu’est-ce qu’un certificat ? Dans quel cas l’utilise-t-on ?
Question d : est-ce qu’en général le chiffrement permet de faire de la signature ? de l’échange de clés ? de l’au-
thentification ? Si oui comment ?
Question e : quelle est la différence entre une fonction de hachage et une signature ?
Question f : expliquer le type de procédure à mettre en place pour qu’une signature signée aujourd’hui soit en-
core valide dans 99 ans ?
16.1.2 Réponses :
flot.
Exemples d’algorithmes de chiffrement par bloc : DES (64 bits), AES (128, 192 ou 256 bits), blowfish.
Exemples d’algorithmes de chiffrement à flot : RC4 (entre 40 et 256 bits), A5/1.
Question b : l’intérêt de prendre les courbes elliptiques est que les tailles de clés sont plus petites par rapport à
du RSA ou du El-Gamal (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition de
2 points est 10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera donc
qu’à partir d’une certaine taille de clé. Pour le schéma, refaire celui au début de la partie sur les courbes elliptiques.
Pour RSA, la taille de clé minimale est 1024 bits, pour avoir 112 bits de sécurité il en faut plutôt 2048. Pour AES, on
peut choisir l’une des 3 tailles. Pour les courbes elliptiques, si on veut 128 bits de sécurité il faut une clé de taille 256 bits.
Question c : un certificat est un fichier qui contient des informations sur une personne / entité ainsi qu’une clé
publique et il est validé par une tierce partie (l’autorité de certification). Il peut être utilisé pour faire de l’authentifi-
cation serveur / client, ...
Question d :
Signature : cela marche seulement dans le cas de RSA (car le chiffrement et le déchiffrement sont ”les mêmes”) mais
en général non car on ne peut pas forcément chiffrer avec la clef privée.
Échange de clés : oui, Alice va choisir une clé K, elle va la chiffrer avec la clé publique de Bob qui pourra ensuite
déchiffrer avec sa clé privée pour récupérer K.
Authentification : oui, imaginons que Alice veut s’authentifier auprès de Bob, Bob va envoyer le chiffré avec la clé
publique d’Alice d’une valeur aléatoire, puis Alice sera la seule à pouvoir déchiffrer avec sa clef privée.
Question e : une fonction de hachage va permettre de vérifier l’intégrité d’un message / programme, une signa-
ture va permettre d’identifier une personne en particulier. La fonction de hachage peut être utilisée par tout le monde
sur n’importe quel message avec le même résultat, on ne pourra pas identifier la personne ayant calculé le hash.
Question f : une idée serait de signer le document de manière régulière avec une clé différente à chaque fois, cela
demande tout de même de savoir à quelle fréquence changer la signature et aussi plus on avance dans le temps plus
il faudra refaire la signature souvent pour éviter les attaques. Une autre solution est de choisir une clé de taille très
grande de façon à rester sécurisé contre l’augmentation en puissance des ordinateurs.
90 / 114 Année 2023 - 2024


16.2.1 Sujet :
Bob.
passes).
16.2.2 Réponses :
Question b :
Question c :
Question d :
91 / 114 Année 2023 - 2024

Question e :

16.3.1 Sujet :
16.3.2 Réponses :
Compression
Question b :
Question c :
92 / 114 Année 2023 - 2024



16.4.1 Sujet :
Dans la suite, on considèrera la courbe y 2 = x3 − x + 2 = x3 + 4 × x + 2 (mod 5) définie sur K = Z/5Z.
Question c : quelle est la structure du groupe de la courbe elliptique ?
Question d : y-a-t’il un élément générateur ? Si oui, en donner un.

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
16.4.2 Réponses :
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + x + 2 2 2 3 1 2
Cette courbe possède donc 3 points : (3, 1), (3, 4), 0.
Question c :
D’après le théorème de la courbe elliptique, la seule structure possible pour ce groupe est Z/1Z ⊕ Z/3Z qui possède 2
générateurs.
Question d :
Les 2 seuls générateurs possibles sont (3, 1) et (3, 4.
Nous pouvons calculer 1P , 2P dans chaque cas pour le vérifier :
(3, 1) :
0P = 0
1P = (3, 1)
2P = (3, 1) + (3, 1) = (3, 4) : coeff = 1/2 = 3, x3 = 32 − 2 × 3 = 3, y3 = 3 × (3 − 3) − 1 = 4
(3, 4) :
93 / 114 Année 2023 - 2024

0P = 0
1P = (3, 4)
2P = (3, 4) + (3, 4) = (3, 1) : coeff = 1/2 = 3, x3 = 32 − 2 × 3 = 3, y3 = 3 × (3 − 3) − 4 = 1
16.5 Exercice 4 - avant la clé publique :

16.5.1 Sujet :
miers avec P − 1.
16.5.2 Correction :
exposants.
94 / 114 Année 2023 - 2024


16.6.1 Sujet :
Alice et Bob partagent un secret k eet ont décidé de l’utiliser dans le protocole suivant qui permet à Alice d’authentifier
Bob :
2. Bob répond en envoyant r ⊕ k.
L’analyse de Bob et Alice du protocole est la suivante : le protocole permet d’obtenir l’authentification puisque Alice
peut vérifier que l’envoyeur du message 2. connaı̂t le secret partagé k. Il est aussi séccurisé car seul des suites de bits
Question b : êtes-vous d’accord avec Bob et Alice sur la sécurité du protocole ? Justifiez.
16.6.2 Réponses :
Question a : lorsqu’elle reçoit c = r ⊕ k, elle va calculer k ⊕ c, récupérer le résultat et si ce dernier vaut r l’authenti-
fication aura réussi.
Question b : non, une personne qui voit passer les messages peut récupérer la clé : elle récupère r dans le pre-
mier message, puis elle peut obtenir k en interceptant le second message et en calculant k = r ⊕ (r ⊕ k).
16.7 Exercice 5’ - Autre authentification :

16.7.1 Sujet :
On considère le schéma de signature suivant. On suppose qu’on a une fonction de hachage f qui renvoie des hachés
de longueur n. On va maintenant expliquer comment on peut signer un message m de longueur k : m = (m1 , ..., mk )
avec mi ∈ {0, 1} à partir de f . Pour chaque 1 <= i <= k et chaque j ∈ {0, 1} on prend une valeur aléatoire yi,j de
longueur k. On calcule ensuite zi,j = f (yi,j ). Les 2k yi,j forment la clé secrète et les 2k zi,j forment la clé publique.
Pour signer un message m = (m1 , ..., mk ) de k, on a :
Signature(m) = (y1,m0 , y2,m0 , ..., yk,m0 )
Question a : calculer pour n = 256 et k = 80 les tailles des clés publiques et privées. Comparer avec les tailles
de clés pour RSA et DSA.
Question b : expliquer comment de manière plus générale on pourrait signer des messages de taille quelconque
en utilisant la méthode précédente.
Question c : justifier que pour une seule signature, la sécurité du schéma repose sur la sécurité de la fonction
de hachage f .
Question d : peut-on prendre k petit pour le protocole, par exemple k = 1 ou k = 2 ?
Question e : montrer qu’avec une attaque à messages choisis, en 2 signatures pour 2 messages choisis on peut
récupérer la clé privée. Justifier du coup la notion d’usage unique pour ce protocole.
Question f : en fait ce protocole peut être couplé avec un algorithme (de Merkle) uniquement à base de fonc-
tion de hachage qui permet de signer un nombre quelconque de fois mais signé à l’avance. Quel est l’intérêt de ce
protocole par rapport à ceux de théorie des nombres cités plus haut.
16.7.2 Réponses :
Question a :
Taille de clé privée : nous avons 2k valeurs chacune de taille k, la taille de la clé privée est donc 2k 2 = 12800 dnas
95 / 114 Année 2023 - 2024

notre cas.
Taille de la clé publique : nous avons 2k valeurs chacune de taille n, la taille de la clé publique sera donc 2kn = 40960
dans notre cas.
Les tailles de clés pour cet algorithme d’authentification sont beaucoup plus grandes que pour RSA et DSA où on est
plus de l’ordre 1024 / 2048 bits.
Question b : il suffit de faier passer le message M à signer dans une fonction de hachage pour récupérer un m
de taille fixe qui pourra ensuite être utilisé dans le protocole de signature.
Question c : si un attaquant arrive à renverser la fonction de hachage, il pourra récupérer la clé secrète yi,j à
partir de la clé publique zi,j . Une fois ceettte clé secrète obtenue, on pourra signer ce que l’no veut.
Question d : prendre k petit est une très mauvaise idée car la taille de la clé privée sera également petite : pour k = 1
on aura 2 bits, pour k = 2 ça fera 8 et pour k = 3 nous en aurons 18, ce qui permettrait une attaque par brute force facile.
Question e : il suffit d’envoyer en premier un message tout à 0 pour récupérer tous les yi,0 et puis un second
message tout à 1 pour récupérer tous les yi,1 et ensuite on pourra créer la signature de n’importe quel message en
utilisant soit yi,0 soit yi,1 en fonction du bit. Il doit être à usage unique car dès lors que 2 messages avec au moins 2
bits de différence sont envoyés on peut créer des signatures pour d’autres messages.
Question f : on peut peut être dire que c’est plus rapide de faire le protocole à base de fonctions de hachage
au lieu de celui à base de théorie des nombres.
16.8 Exercice 6 - Cryptographie basée sur l’identité :

16.8.1 Sujet :
Question a : rappeler les grandes propriétés des couplages (pairings) utilisées pour la cryptographie. Donner 3 appli-
cations des couplages en cryptologie.
Question b : rappeler la définition d’un schéma de chiffrement basé sur l’identité.
Question c : définir en généralisant la définition du b) la notion de signature basée sur l’identité et d’authentifi-
cation basée sur l’identité.
Question d : alors que trouver des schémas de chiffrement basés sur l’identité est un problème difficile, montrer
qu’il est très facile de construire de manière générique (par exemple, à partir d’un schéma quelconque de signature)
des protocoles de signature et d’authentification basés sur l’identité.
16.8.2 Réponses :
Question a : un couplage est une application e : G1 × G1 → G2 avec les 2 propriétés suivantes :
Bilinéarité : ∀P, Q ∈ G1 , ∀a, b ∈ Z∗q , e(aP, bQ) = ab × e(P, Q).
Non-dégénérescence : ∀P ∈ G1 , P ̸= 0 → G2 =< e(P, P ) >
Ils ont tout d’abord été utilisés pour faire des attaques sur les courbes elliptiques (car avec ces couplages, si on sait
résoudre le problème du logarithme discret sur G2, on sait le résoudre sur G1).
Il est possible de l’utiliser pour faire un échange de clé tri-partite (A reçoit bP de B et cP de C et peut calculer abc × P
avec a × e(bP, cP )).
Une autre possibilité est le chiffrement basé sur l’identité.
Question b : un schéma de chiffrement basé sur l’identité est un algorithme de chiffrement asymétrique dans le-
quel la clé publique d’une personne sera un élément de son identité (prénom, nom, numéro de sécurité sociale, ...).
C’est une notion introduite en 1984 par Shamir mais les premiers protocoles n’ont vu le jour qu’en 2001 par Boneh et
Franklin en utilisant des pairings.
Cela repose sur une tierce partie : un PKG (Private Key Generator). Pour chiffrer un message, une personne utilisera
Question c : (je suis pas sûr, il me semble qu’on l’a pas fait en cours)
Pour une signature basée sur l’identité, il faut qu’un utilisateur soit capable de vérifier une signature juste en utilisant
l’identité de la personne ayant signé l’élément. Pour signer, une personne utilisera son identité ainsi que la clé privée
qui lui est donnée par le PKG.
Pour de l’authentification basée sur l’identité, l’idée serait d’envoyer un engagement ”normal”, puis on recevrait un
challenge généré sur la base de notre identité, et nous pourrons ensuite nous authentifier en donnant une réponse grâce
96 / 114 Année 2023 - 2024

à la clé privée donnée par le PKG.
Question d : (encore une fois, il me semble qu’on l’a pas fait en cours)
- Setup du PKG : on va d’abord générer pkm et skm à partir du même algorithme de génération de clés que pour la
signature, ce seront les clés du PKG. Ensuite, la clé skid sera le tuple (sk, pk, cert) avec cert = Sign(skm , pk||id), il
n’y aura rien dans pkid .
- Création de la signature : s = (Sign(sk, M ), pk, cert) avec (sk, pk, cert) récupérés depuis skid .
- Vérification de la signature : on récupère (pk, cert, s′ ) depuis la signature, puis on fait V erif (pk, M, s′ ) et V erif (pkm , pk||id, cert)
(on a juste eu besoin de récupérer pkm et l’identité).
Le principe général est le suivant : lorsqu’un utilisateur veut signer, on lui génère un couple de clés et on incorpore
dans la clé privée le certificat prouvant la validité de pk. Ce certificat est ensuite ajouté à la signature pour que tout
le monde puisse vérifier la clé à utiliser.
16.9 Exercice 7 - Changement de clé RSA :

16.9.1 Sujet :
Alice change sa clé RSA tous les 25 jours. Bob, lui, change sa clé tous les 31 jours. Sachant qu’Alice change sa clé
aujourd’hui et que Bob a changé sa clé il y a trois jours, déterminer quand sera la prochaine fois qu’Alice et Bob
changeront leur clé le même jour.
16.9.2 Réponses :
Il faut tout d’abord modéliser le problème sous forme de système d’équations modulaires :
(
x ≡ 0 (mod 25)
x ≡ −3 (mod 31)
Une fois cela fait, il suffit d’appliquer le théorème des restes chinois pour trouver la solution :
( (
x ≡ 0 (mod 25) 31x ≡ 0 (mod 775)
⇔
x ≡ −3 (mod 31) 25x ≡ −75 (mod 775)
Nous pouvons ensuite additionner les 2 équations ce qui nous donne : 56x = −75 (mod 775).
Trouvons l’inverse modulaire de 56 modulo 775 :

775 = 56 × 13 + 47
56 = 47 × 1 + 9
47 = 9 × 5 + 2
9=4×2+1
Remontons maintenant la chaı̂ne :
1=9−4×2
1 = 9 − 4 × (47 − 9 × 5) = 9 × 21 − 47 × 4
1 = (56 − 47) × 21 − 47 × 4 = 56 × 21 − 47 × 25
1 = 56 × 21 − (775 − 56 × 13) × 25 = 56 × 346 − 775 × 25
Finalement : 1 = 56 × 346 − 775 × 25 et l’inverse modulaire de 56 est 346.
Donc : x = −75 × 346 = 400 (mod 775).

Ils changeront donc leur clé le même jour dans 400 jours.
97 / 114 Année 2023 - 2024

17 Annale du 17 février 2020 :

17.1.1 Sujet :
Question a : qu’est-ce qu’un certificat, rappeler son utilisation.
Question b : qu’est-ce qu’une chaı̂ne de certificats ? Dans quel cas l’utilise-t-on ?
Question c : qu’est-ce qu’un tiers de confiance, donner des exemples de telles entités.
Question d : est-ce que le chiffrement permet de faire de la signature ? de l’échange de clés ? de l’authentifica-
tion ? Si oui, comment ?
Question e : à quoi sert un schéma de Retrait d’Information Privé (PIR en anglais) ? Donner des exemples d’appli-
cations.
Question f : donner des applications spécifiques des algorithmes de couplage sur les courbes elliptiques.
17.1.2 Réponses :
Question a : un certificat est un document numérique qui va contenir des informations sur une entité ainsi que la clé
publique de cette dernière. Cette clé publique sera signée par une autorité de degré supérieur.
Question b : une chaı̂ne de certificats contient le certificat de l’entité, puis le certificat utilisé pour signer le cer-
tificat de l’entité, puis le certificat utilisé pour signer ce certificat et ainsi de suite. Pour moi, on l’utilise pour vérifier
toute la chaı̂ne de confiance.
Question c : un tiers de confiance est comme son nom l’indique une entité tierce dont on va supposer qu’elle se
comporte de manière honête. Dans le cadre de la certification, un tiers de confiance entre un client et un serveur serait
l’autorité de certification qui est trusted par le client et qui lui permettra d’accepter le certificat du serveur.
Question d :
Question e : l’idée est que l’on veut laisser un utilisateur récupérer des informations d’une base de données sans
que la base de données sache quelle information nous avons retirée. Un exemple de protocole pour le résoudre est celui
d’Ostrovsky et Kushilevitz mais pour être efficace il faut avoir beaucoup de données de petite taille. C’est donc utile
dans le cadre des DNS, des données médicales, ...
Question f : ils ont tout d’abord été utilisés pour faire des attaques sur les courbes elliptiques (car avec ces couplages,
si on sait résoudre le problème du logarithme discret sur G2, on sait le résoudre sur G1).
17.2 Exercice 1 : Authentification :

17.2.1 Sujet :
Bob.
98 / 114 Année 2023 - 2024

passes).
17.2.2 Réponses :
Question b :
Question c :
Question d :
Question e :
99 / 114 Année 2023 - 2024

17.3 Exercice 2 : Partage de secret :

17.3.1 Sujet :
On rappelle qu’un schéma de partage de secret permet à plusieurs personnes qui ont en commun un (ou des) bouts
de secret de retrouver un secret donné.
Question a : quelle est la différence entre le partage de secret et l’échange de clé ? Donner un exemple d’appli-
cation du partage de secret.
Question b : rappeler le schéma de partage de secret de Shamir.
Question c : on suppose qu’un état major (composé de 2 généraux, 4 colonels et 16 capitaines) a la possibilité
de faire tirer un missile ultra-destructeur, le code du missile est un secret partagé, qui ne peut être activé que dans
certains cas :
1. Les généraux le souhaitent.
2. Les deux colonels le souhaitent et un seul général.
3. Les 16 capitaines le souhaitent.
4. 1 général et les 8 capitaines le souhaitent.
1) Proposer une solution en utilisant le schéma de partage de secret de Shamir qui permet de résoudre ce problème.
2) Dans votre solution, combien faudrait-il de colonels avec 12 capitaines pour retrouver le secret ?
3) Avec ce type d’approche, on aura toujours le cas ou un grand nombre de capitaine pourra toujours trouver le secret,
comment pourrait-on faire pour que quoiqu’il arrive, il y ait au moins un général qui collabore pour retrouver le secret ?
17.3.2 Réponses :
Question a : pour un échange de clé, on veut pouvoir créer une clé qui sera connue de 2 personnes sans connaı̂tre
un secret auparavant. Pour le partage de secret chaque personne aura des bouts de secret et ce dernier ne pourra être
re-constitué que si un certain nombre de bouts de secrets sont récupérés.
Un exemple d’application réelle est dans une cérémonie des clés où toutes les personnes doivent mettre leur carte dans
le HSM (Hardware Security Module) pour l’initialiser : génération des clés les plus importantes.
Question b : dans le schéma de partage de secret de Shamir, k sera le nombre de bouts de secret à rejoindre pour
obtenir le secret et n le nombre de bouts de secret total. L’idée est donc de créer un polynôme P de degré k − 1 dont
les coefficients seront aléatoires, puis de prendre n points aléatoires sur ce polynôme (on prendra un x aléatoire, on cal-
culera P (x) et le bout de secret sera la paire (x, f (x))). Le secret commun sera le coefficient constant du polynôme P [0].
Question c :
1) Une solution simple consiste à prendre 8 bouts de secrets par général, 4 bouts de secret par colonel et 1 bout de
secret par capitaine. Il faudra dans chacun des cas 16 bouts de secret pour reconstituer le secret, on choisira donc un
polynôme aléatoire de degré k = 15 puis on devra donner 48 bouts de secret au total.
2) Dans cette solution, il faudra juste un seul colonel avec les 12 capitaines pour retrouver le secret. Le colonel va
ajouter ses 4 secrets aux 12 des capitaines, ce qui en fait 16 et ce qui est suffisant pour obtenir le secret.
3) On pourrait peut être faire un partage de secret en plusieurs étapes : on donnerait 1 bout de secret à chaque
capitaine et si les 16 capitaines se mettent d’accord, ils peuvent retrouver un bout de secret d’une importance plus
grande. Ensuite, chaque capitaine aura un bout de secret et il faudra 2 de ces bouts de secret d’importance plus grande
pour retrouver le secret final.

17.4.1 Sujet :
Question c : pour tous les points P de la courbe, calculer 2P et 4P .

de la courbe.
Question e : donner un générateur du groupe (un point P tel que 0P, P, 2P, ... engendre le groupe) ? En déduire la
100 / 114 Année 2023 - 2024

structure de groupe de la courbe.

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
17.4.2 Réponses :
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + x + 2 2 4 2 2 0
Question c :
Vu qu’il y a 4 points dans la courbe, nous aurons forcément que 4P = 0 pour tous les points.
2 × (1, 2) = (4, 0) : coeff = (3 × 1 + 1)/(2 × 2) = 1 : x3 = 1 − 2 = 4, y3 = 1 × (1 − 4) − 2 = 0.
2 × (1, 3) = (4, 0) : coeff = (3 × 1 + 1)/(2 × 3) = 2/3 = 4 : x3 = 42 − 2 = 4, y3 = 4 × (1 − 4) − 3 = 0.
2 × (4, 0) = 0 car y1 = 0
2×0=0
Question d :
Il y a 2 générateurs dans ce groupe : (1, 2) et (1, 3).
La structure du groupe est donc isomorphe à Z/1Z ⊕ Z/4Z qui est lui-même isomorphe à Z/4Z.
17.5 Exercice 4 : Fonction de hachage et signature :

17.5.1 Sujet :
Soit h une fonction de hachage à valeur dans Fn2 . On considère le cas d’un attaquant qui pour abuser une signature
souhaite construire deux messages ayant le même haché mais des significateurs choisies différentes.
Question a : donner une attaque en O(2n/2 ) pour la fonction de hachage h qui permet de construire deux mes-
sages avec deux significations choisies différentes mais avec le même haché.
Question b : montrer comment l’attaque du a. peut être utilise pour abuser un vérificateur de signature (exemple :
”faites un virement de 10000 euros” au lieu de ”faites un virement de 100 euros”).
Question c : comment choisir n pour résister à cette attaque.
17.5.2 Réponses :
Questionpa : l’idée va être de se baser sur l’algorithme de détection du rho de Pollard dont la taille du cycle est en
moyenne π × N/8 avec N le nombre d’éléments de l’ensemble. Du coup pour notre fonction de hachage la complexité
sera de O(2n/2 ).
L’idée sera de partir de la signification choisie, de calculer son hash, de calculer une nouvelle signification similaire à
la première à partir de ce hash (pour une image, on pourrait partir de l’image de base et ajouter les bits du hash aux
bits de poids faible des pixels) et ainsi de suite.
Ensuite, il faudra trouver le point de départ du cycle et nous aurons 2 antécédents qui seront des images différentes
mais qui donneront le même hash :
101 / 114 Année 2023 - 2024

Question b : nous savons que la signature demande tout d’abord de calculer le hash du message et ensuite d’appli-
quer l’algorithme de signature. L’idée sera de prendre un message pour lequel nous avons la signature associée puis
générer un autre message avec une signification similaire qui aura le même hash (nous avons vu comment faire cela à
la question précédente) et ce dernier pourra donc être présenté avec la même signature que le premier !
Question c : pour résister à cette attaque, il faut choisir n de sorte à ce que la taille du cycle soit trop grande
en terme de temps de calcul. Pour avoir une sécurité de k bits, il faudrait prendre une fonction de hachage dont la
taille du hash serait n = 2k.
17.6 Exercice 5 : Un échange de clé léger, trop léger :

17.6.1 Sujet :
Un protocole d’échange de clés pour les téléphones portable sa été proposé par Park, basé sur DH. Le système a un
module premier p et un générateur commun aux deux parties. Chaque partie i a une clé secrète xi et une clé publique
Xi = g xi (mod p). Pour faire une clé de session entre le client M (un téléphone) et la base B, on exécute le protocole
suivant :
1. B → M : g xB +NB
2. M → B : NM + xM
Avec NB et NM les nonces de B et M (nonce : number used once, un entier random).
B calcule sa clé de session de la manière suivante :

−1
NB
KM B = g xM +NM × XM
M calculé sa clé de session de la manière suivante :
−1
NM
KM B = g xB +NB × XB
Ils finissent le protocole en faisant un défi réponse utilisant KM B .
Question 1 : montrer que le protocole fonctionne et que c’est bien la même clé commune qui est calculée. Pour-
quoi ce protocole est potentiellement plus intéressant qu’un diffie-hellman classique pour un téléphone mobile par
exemple ?
Question 2 : montrer que si un attaquant connaı̂t une clé de session d’un tour précédent (il connaı̂t une clé commune
KM B ) pour lesquels il a enregistré des messages, alors il peut se faire passer pour B (indication : l’attaquant peut
rejouer des messages de la session précédente).
Question 3 : montrer qu’en fait un attaquant peut se faire passer pour B connaissant simplement les clés publiques
XB et XM . Qu’en concluez vous pour le protocole ?
17.6.2 Réponses :
Question 1 : nous allons tout simplement simplifier les expressions :
−1
NB NB N B N B
g xM +NM × XM = g xM +NM × g −xM = g xM +NM −xM = g NM = g NM ×NB
−1
NM N M N M N M
g xB +NB × XB = g xB +NB × g −xB = g xB +NB −xB = g NB = g NM ×NB
Ce protocole est plus intéressant qu’un diffie-hellman classique pour un téléphone mobile car le téléphone aura une
exponentiation modulaire à faire : il envoie juste NM + xM au lieu de g puissance ça. Du coup, cela demande moins
de ressources pour le téléphone.
Question 2 :
Connaı̂tre une clé de tour, cela veut dire que l’on connaı̂t KM B = g NM ×NB .
Vu que nous voulons nous faire passer pour la base, une première idée pourrait être d’arriver à dériver la même clé
que le téléphone.
L’idée sera de renvoyer g xB +NB comme premier message (nous ne connaissons ni xB ni NB ).
′
Ensuite, le téléphone va nous envoyer NM + xM
′
NB ×NM
La clé calculée par le téléphone sera : g .
′ ′
Nous savons que g NB ×NM /KM B = g NB ×(NM −NM ) . Nous pouvons calculer NM ′
− NM en faisant NM′
+ xM − NM − xM
NB xB +NB −1
(la différence des 2 message), pour g il suffit de calculer g × XB . Finalement la clé sera donnée par :
′
(g NB )NM +xM −NM −xM × KM B .
Question 3 :
L’attaquant va envoyer n’importe quel g xB +NB = XB × g NB : la clé dérivée par le téléphone sera g NB ×NM . Pour que
102 / 114 Année 2023 - 2024

−1 NB ′ ′ ′
l’attaquant la calcule, il peut s’y prendre de la manière suivante : (g NB )NM +xM × (XM ) = g NB ×NM +xM ×NB ×
′ ′ ′
−xM ×NB NB ×NM
g =g .
Ce protocole n’est donc absolument pas sécurisé.
17.7 Exercice 6 : authentification :

17.7.1 Sujet :
Alice et Bob partagent un secret k et ont décidé de l’utiliser dans le protocole suivant qui permet à Alice d’authentifier
Bob :
2. Bob répond en renvoyant r ⊕ k
L’analyse de Bob et Alice du protocole est celle-ci : le protocole permet d’obtenir l’authentification puisque Alice
peut vérifier que l’envoyeur du message 2. connaı̂t le secret partagé k. Il est aussi sécurisé car seul des suites de bits
Question b : êtes-vous d’accord avec Bob et Alice sur la sécurité du protocole ? Justifiez ?
17.7.2 Correction :
Question a : soit c = r ⊕ k, Alice va tout simplement calculer c ⊕ k et voir si c’est égal à r : si oui elle sait que c’est
bien Bob.
Question b : absolument pas, un attaquant qui voit passer le premier message contenant seulement r et le se-
cond message contenant r ⊕ k peut très bien calculer r ⊕ (r ⊕ k) = k et donc obtenir la clé secrète (ce qui est un peu
con).
17.8 Exercice 7 : Chiffrement :

17.8.1 Sujet :
ver le message.
17.8.2 Réponses :
Question a :
Question b :
Protocole A :
Protocole B :
103 / 114 Année 2023 - 2024


18.1.1 Sujet :
Question a : Quels sont les avantages du chiffrement à clé secrète par rapport au chiffrement à clé publique, donner
Question b : expliquer pourquoi si on utilise du chiffrement à flot, réutiliser le même flot quasi-aléatoire sur différents
Question c : est-ce que la factorisation est un problème difficile à résoudre ? Comparer ce problème à la résolution
du problème du log discret sur un anneau de type Z/nZ ou sur des courbes elliptiques.
Question d : quelle est la complexité de la meilleure attaque connue sur le problème du logarithme discret sur
les courbes elliptiques sur un corps avec de l’ordre de 2n éléments en fonction de n et ce pour le cas d’un ordinateur
classique et aussi dans le cas d’un ordinateur quantique suffisamment puissant.
Question e : quelle est la différence entre signer et hacher ?
Question f : on utilise souvent la compression de données pour le stockage d’informations. Supposons qu’on veuille
compresser des données avec du chiffrement. Est-ce qu’il vaut mieux chiffrer et puis compresser ou le contraire.
18.1.2 Correction :
Question b : le chiffrement à flot fonctionne en xorant un flot de clé avec le message : c = m⊕k, si la même clé est uti-
quel message.
Question c : oui c’est un problème difficile (il n’existe pas d’algorithme polynomial pour le résoudre sur un or-
dinateur ”conventionel” (non-quantique)). La complexité de la factorisation est L[1/3, (64/9)1/3 ] en utilisant le crible
algébrique. Pour la complexité du logarithme discret, elle est identique car c’est également la méthode du crible √
algébrique qui est utilisée pour le résoudre. En revanche, sur les courbes elliptiques, la meilleure attaque est en O( n)
(avec n le nombre de points de la courbe).
Question d : vu que le corps à 2n éléments, nous pouvons dire que la courbe a environ 2n points (d’après le théorème
de Hasse), et la meilleure attaque connue consiste à trouver 2 couples (c, d) et (c′ , d′ ) tels que cG + dQ = c′ G + d′ Q
(G étant le générateur et Q le point pour lequel on veut résoudre
√ le logarithme). Grâce au paradoxe des anniversaires,
nous savons que cette collision se produit en moyenne en 2n = 2n/2 couples√vus. Pour l’ordinateur quantique, le
meilleur algorithme connu est l’algorithme BHT qui trouver une collision en O( 3 2n = 2n/3 ).
Question e : signer permet de garantir l’identité de la personne qui a réalisé la signature alors qu’un hash peut
être calculé par n’importe quelle personne.
Question f : chiffrer puis compresser ne fonctionnera pas car l’entropie des données après chiffrement sera très
élevée, or, une fonction de compression pourra le mieux compresser quand l’entropie est basse (qu’il y a des zones
prévisibles qui se répètent). Donc, il vaut mieux d’abord compresser et après chiffrer.
18.2 Exercice 1 - Cryptographie à clé publique :

18.2.1 Sujet :
Question a : on souhaite faire signer un document par n personnes. Comment peut-on s’y prendre ? Donnez une
solution et analysez ses points forts/faibles en vous aidant des points suivants : longueur de la clé, longueur de la
signature, importance de l’ordre des signataires et si l’un des signataires triche ?
Question b : on suppose maintenant que lors de ses vacances (d’une durée fixe) un responsable souhaite déléguer
sa signature électronique à son adjoint (un peu comme une procuration). Comment peut-il s’y prendre ? Proposer un
cadre réaliste et proposer une solution. Bien sûr, l’adjoint doit pouvoir signer à la place du responsable mais sans que
104 / 114 Année 2023 - 2024

le responsable donne sa clé secrète.
18.2.2 Réponses :
Question a : la solution la plus simple consiste à envoyer le document à tous les signataires, récupérer toutes leurs
signatures et les concaténer pour avoir la signature finale.
Le processus de signature serait le suivant : s = s1 ||s2 ||...||sk (avec k le nombre de parties) et si = Sign(ski , m).
Le processus de vérification étant donné le message et la signature serait le suivant : retourner 1 si V erif (pki , m, s) = 1
pour tout i ∈ [1, k].
La longueur de la clé sera k fois celle utilisée pour la signature : imaginons du RSA 1024 bits, les clés publiques et
privées auraient une taille de 1024 × k bits.
La longueur de la signature est k fois la longueur d’une seule signature.
Il n’y a pas d’importance dans l’ordre des signataires.
L’un de signataires triche : on peut dire que tricher correspond à signer à la place de quelqu’un d’autre, ici c’est
impossible à moins de connaı̂tre la clé secrète ou d’arriver à casser la signature sous-jacente.
Question b : nous allons nous placer dans le cas de la signature RSA : pour signer avec RSA, on calcule s = md
(mod n). Pour la vérification on va faire se (mod n) et on va voir si c’est égal au message m.
L’idée pour déléguer sa clé sera d’envoyer d + x × φ(n) pour une valeur de x aléatoire à l’employé : la signature donnera
la même chose car mφ(n) = 1 (mod n) et l’employé ne connaissant ni x ni φ(n) il ne pourra pas récupérer d. Pour la
vérification, on peut laisser se (mod n) (la même clé publique).

18.3.1 Sujet :
18.3.2 Correction :
K : 01 00 10 10 00 01
M : 10 10 10 10 10 10
C : 11 10 00 00 10 11
C : 01 11 01
M : 01 00 10

105 / 114 Année 2023 - 2024

chiffré :
M = 00 10 00, K = 01 01 01
M = 01 10 00, K = 00 01 01
M = 00 01 00, K = 01 10 01
M = 01 01 00, K = 00 10 01
M = 00 10 01, K = 01 01 00
M = 01 10 01, K = 00 01 00
M = 00 01 01, K = 01 10 00
M = 01 01 01, K = 00 10 00
K = 102201
M = 222222
18.4 Exercice 3 - Calcul de la signature RSA avec le théorème des restes chinois :
18.4.1 Sujet :
On considère un module RSA : n = p × q et d l’exposant privé. Soit un message m à signer, on cherche à calculer Smd
(mod n). On note dp = d (mod p − 1), dq = d (mod q − 1) et iq = q −1 (mod p). Soient également Sp = mdp (mod p)
et Sq = mdq (mod q).
Question a : rappeler le théorème des restes chinois, montrer que S (mod p) = Sp et S (mod q) = Sq , expli-
quer alors pourquoion peut retrouver S à partir de Sp et Sq .
Question b : montrer que S = Sq + q × (iq × (Sp − Sq ) (mod p)).
Question c : expliquer l’intérêt (en terme de cout calculatoire) de calculer S par cette méthode plutôt que di-
rectement en calculant md (mod n).
18.4.2 Réponses :
Question a :
Le théorème des restes chinois permet de résoudre des systèmes d’équations modulaires : étant donnés k le nombre
d’équations, ni les modules et ai les restes nous pouvons retrouver la valeur de x (mod n1 × ... × nk ) (si tous les ni
sont premiers entre eux) en calculant (via la méthode de Gauss) :
x = (a1 × N1 × (N1−1 (mod n1 )) + ... + ak × Nk × (Nk−1 (mod nk ))) (mod N )

S (mod p) = md (mod p) = mdq +k×(p−1) = mdq × (mp−1 )k = mdq (mod p)
C’est la même chose pour S (mod q).
Question b :
(Sq + q × (iq × (Sp − Sq ) (mod p))) (mod q) = Sq + 0 = Sq
(Sq + q × (iq × (Sp − Sq ) (mod p))) (mod p) = Sq + Sp − Sq = Sp
Question c :
106 / 114 Année 2023 - 2024

Le coût d’une exponentiation modulaire si toutes les valeurs sont sur n bits est O(n3 ) : vu que l’exposant d est full-size
ce sera le coût de la signature.
Si elle est réalisée avec la seconde méthode, nous aurons 2 exponentiations modulaires sur des nombres de n/2 bits ce
qui nous donnera une complexité de (n/2)3 × 2 = n3 /4 : 4 fois plus rapide que précédemment (car les autres opérations
sont négligeables par rapport à l’exponentiation full-size).
18.5 Exercice 4 : Chiffrement :

18.5.1 Sujet :
ver le message.
18.5.2 Réponses :
Question a :
Question b :
Protocole A :
Protocole B :
18.6 Exercice 5 : Le schéma de signature de Lamport à usage unique :

18.6.1 Sujet :
On considère le schéma de signature suivant. On suppose qu’on a une fonction de hachage f qui renvoie des hachés
de longueur n. On va maintenant expliquer comment on peut signer un message m de longueur k :
m = (m1 , m2 , ..., mk ) : les bits du message.
Pour chaque bit du message, on prendre 2 valeurs aléatoires ce qui nous fait un total de 2k valeurs aléatoires yi,j
chacune de ces valeurs alétoires ayant une longueur de k, ce sera notre clé secrète.
La clé publique sera obtenue en faisant passer chaque yi,j par la fonction de hachage f ce qui nous donnera une liste
de zi,j chacun de longueur n.
Pour signer le message, on a :
sign(m) = (y1,m1 , y2,m2 , · · · , yk,mk ) = (s1 , · · · , sk )

Pour la vérification, on utilisera la clé publique (donc les zi,j ) et comparera les hash des valeurs de la signature avec
ces derniers.
Question a : calculer pour n = 256 et k = 80 les tailles des clés publiques et privées. Comparer aux tailles des
clés pour RSA ou DSA.
Question b : expliquer comment de manière plus générale on pourrait signer des messages de taille quelconque
107 / 114 Année 2023 - 2024

en utilisant le protocole précédent.
Question c : justifier que pour 1 seule signature, la sécurité du schéma repose sur la sécurité de la fonction de
hachage f .
Question d : peut-on prendre k petit pour le protocole, par exemple k = 1 ou k = 2.
Question e : montrer qu’en prenant une attaque à message choisi en deux signatures pour 2 messages choisis on
peut récupérer toute la clé publique. Justifier du coup la notion d’usage unique pour ce protocole.
Question f : en fait, ce protocole peut être couplé avec un algorithme (de Merkle) uniquement à base de fonc-
tion de hachage qui permet de signer un nombre quelconque de fois mais fixé à l’avance. Quel est l’intérêt de ce type
de protocole par rapport aux protocoles classiques de la théorie des nombres cités plus haut.
18.6.2 Réponses :
Question a :
Pour la clé publique, nous avons 2k valeurs yi,j chacune sur k bits, du coup cela représente 2k 2 bits ce qui pour
l’exemple donné fait 2 × 802 = 12800 bits (ce qui nous donne 1600 octets).
Pour la clé privée, nous aurons 2k valeurs zi,j mais cette fois-ci de taille n bits, du coup la clé publique aura une taille
de 2k × n bits ce qui pour notre exemple donne 2 × 80 × 256 = 40960 bits (ce qui donne 5120 octets).
Ces tailles de clés sont beaucoup plus grandes qu’avec RSA et DSA où les clés auront une taille égale à 2048 bits.
Question b :
Pour signer des messages de taille arbitraire, il suffit de faire passer ces derniers par une fonction de hachage dont la
sortie fait k bits et ensuite de réaliser la signature sur ce hash.
Question c :
Imaginons qu’aucune signature n’ait été faite, le seul moyen de tricher est d’arriver à renverser la fonction de hachage
pour obtenir les yi,j correspondants aux zi,j de façon à pouvoir réaliser la signature (tous les yi,j n’ont pas besoin
d’être découverts, juste ceux correspondant aux bits de notre message).
Question d :
Si on prend k petit, la taille de la clé privée sera également petite. Pour k = 1 elle sera de 2 bits, pour k = 2 de 8 bits,
pour k = 3 de 18 bits et ainsi de suite. Cette petite taille de clé permet de réaliser une attaque par brute force c’est
pourquoi prendre k petit détruit la sécurité du protocole.
Question e : l’exemple le plus simple à imaginer est si on demande la signature du message contenant k bits à
0 puis la signature du message contenant k bits à 1. La première signature contiendra tous les yi,0 et la seconde
contiendra tous les yi,1 , nous aurons donc toute la clé privée et nous pourrons signer ce que nous voulons ! En réalité,
dès qu’on demandera la signature d’un second message qui a au moins 2 bits différents par rapport au premier, nous
pourrons forger des signatures. En l’utilisant une seule fois en revanche il n’y a pas de problème car il est impossible
de forger une signature (vu que nous ne connaissons que les yi correspondants aux bits du message).
Question f : le gros avantage de cet algorithme est qu’il ne fait intervenir aucun calcul complexe et il est donc
extrêmement rapide.
18.7 Exercice 6 : Cryptographie basée sur l’identité :

18.7.1 Sujet :
Question a : rappeler les grandes propriétés des couplages (pairings) utilisées pour la cryptographie. Donner 3 appli-
cations des couplages en cryptologie.
Question b : rappeler la définition d’un schéma de chiffrement basé sur l’identité.
Question c : définir en généralisant la définition du b) la notion de signature basée sur l’identité et d’authentifi-
cation basée sur l’identité.
Question d : alors que trouver des schémas de chiffrement basés sur l’identité est un problème difficile, montrer
qu’il est très facile de construire de manière générique (par exemple, à partir d’un schéma quelconque de signature)
des protocoles de signature et d’authentification basés sur l’identité.
108 / 114 Année 2023 - 2024

18.7.2 Réponses :
Question a : un couplage est une application e : G1 × G1 → G2 avec les 2 propriétés suivantes :
Bilinéarité : ∀P, Q ∈ G1 , ∀a, b ∈ Z∗q , e(aP, bQ) = ab × e(P, Q).
Non-dégénérescence : ∀P ∈ G1 , P ̸= 0 → G2 =< e(P, P ) >
Ils ont tout d’abord été utilisés pour faire des attaques sur les courbes elliptiques (car avec ces couplages, si on sait
résoudre le problème du logarithme discret sur G2, on sait le résoudre sur G1).
Question b : un schéma de chiffrement basé sur l’identité est un algorithme de chiffrement asymétrique dans le-
quel la clé publique d’une personne sera un élément de son identité (prénom, nom, numéro de sécurité sociale, ...).
C’est une notion introduite en 1984 par Shamir mais les premiers protocoles n’ont vu le jour qu’en 2001 par Boneh et
Franklin en utilisant des pairings.
Cela repose sur une tierce partie : un PKG (Private Key Generator). Pour chiffrer un message, une personne utilisera
Question c : (je suis pas sûr, il me semble qu’on l’a pas fait en cours)
Pour une signature basée sur l’identité, il faut qu’un utilisateur soit capable de vérifier une signature juste en utilisant
l’identité de la personne ayant signé l’élément. Pour signer, une personne utilisera son identité ainsi que la clé privée
qui lui est donnée par le PKG.
Pour de l’authentification basée sur l’identité, l’idée serait d’envoyer un engagement ”normal”, puis on recevrait un
challenge généré sur la base de notre identité, et nous pourrons ensuite nous authentifier en donnant une réponse grâce
à la clé privée donnée par le PKG.
Question d : (encore une fois, il me semble qu’on l’a pas fait en cours)
- Setup du PKG : on va d’abord générer pkm et skm à partir du même algorithme de génération de clés que pour la
signature, ce seront les clés du PKG. Ensuite, la clé skid sera le tuple (sk, pk, cert) avec cert = Sign(skm , pk||id), il
n’y aura rien dans pkid .
- Création de la signature : s = (Sign(sk, M ), pk, cert) avec (sk, pk, cert) récupérés depuis skid .
- Vérification de la signature : on récupère (pk, cert, s′ ) depuis la signature, puis on fait V erif (pk, M, s′ ) et V erif (pkm , pk||id, cert)
(on a juste eu besoin de récupérer pkm et l’identité).
Le principe général est le suivant : lorsqu’un utilisateur veut signer, on lui génère un couple de clés et on incorpore
dans la clé privée le certificat prouvant la validité de pk. Ce certificat est ensuite ajouté à la signature pour que tout
le monde puisse vérifier la clé à utiliser.
109 / 114 Année 2023 - 2024


19.1.1 Sujet :
Question a : quel est l’intérêt des courbes elliptiques par rapport à un algo de type RSA ?
Question b : qu’est-ce qu’un certificat ? Dans quel cas l’utilise-t-on ?
Question c : quelle est la différence entre anonymat et protection de la vie privée, donner des exemples de pro-
tocoles de protection de la vie privée.
Question d : est-ce que le chiffrement permet de faire de la signature ? de l’échange de clé ? de l’authentification ? Si
oui comment ?
Question e : qu’est-ce qu’un protocole PIR (Private Information Retrieval) ?
Question f : expliquer le type de procédure à mettre en place pour qu’une signature signée aujourd’hui soit en-
core valide dans 99 ans ?
19.1.2 Réponses :
qu’à partir d’une certaine taille de clé.
Question b : un certificat est un fichier qui contient des informations sur une personne / entité ainsi qu’une clé
publique et il est validé par une tierce partie (l’autorité de certification). Il peut être utilisé pour faire de l’authentifi-
cation serveur / client, ...
Question c : dans la protection de la vie privée on cherche à protéger les informations sensibles d’une personne
mais pas son identité alors que pour l’anonymat le focus est mis sur l’identité. Signal est un protocole de messagerie
qui fait en sorte que seules les 2 parties puissent déchiffrer les messages (même le serveur tiers ne peut pas déchiffrer),
on sait qui communique mais on ne sait pas quoi, cela protège donc la vie privée. TLS rentre aussi dans cette catégorie :
on sait qui communique avec le serveur mais encore une fois on ne sait pas quoi.
Question d :
Question f : une idée serait de signer le document de manière régulière avec une clé différente à chaque fois, cela
demande tout de même de savoir à quelle fréquence changer la signature et aussi plus on avance dans le temps plus
il faudra refaire la signature souvent pour éviter les attaques. Une autre solution est de choisir une clé de taille très
grande de façon à rester sécurisé contre l’augmentation en puissance des ordinateurs.

19.2.1 Sujet :
110 / 114 Année 2023 - 2024

Bob.
passes).
19.2.2 Réponses :
Question b :
Question c :
Question d :
111 / 114 Année 2023 - 2024

Question e :

19.3.1 Sujet :
On rappelle qu’un schéma de partage de secret permet à plusieurs personnes qui ont en commun un (ou des) bouts
de secret de retrouver un secret donné.
Question a : quelle est la différence entre le partage de secret et l’échange de clé ? Donner un exemple d’appli-
cation du partage de secret.
Question b : rappeler le schéma de partage de secret de Shamir.
Question c : on suppose qu’un état major (composé de 1 général, 2 colonels et 5 capitaines) a la possibilité de
faire tirer un missile ultra-destructeur, le code du missile est un secret partagé, qui ne peut être activé que dans
certains cas :
1. Le général le souhaite.
2. Les deux colonels le souhaitent.
3. Les 5 capitaines le souhaitent.
4. 1 colonel et 3 capitaines le souhaitent.
Proposer une solution en utilisant le schéma de partage de secret de Shamir qui permet de résoudre ce problème.
19.3.2 Réponses :
Question a : pour un échange de clé, on veut pouvoir créer une clé qui sera connue de 2 personnes sans connaı̂tre
Question b : dans le schéma de partage de secret de Shamir, k sera le nombre de bouts de secret à rejoindre pour
obtenir le secret et n le nombre de bouts de secret total. L’idée est donc de créer un polynôme P de degré k − 1 dont
les coefficients seront aléatoires, puis de prendre n points aléatoires sur ce polynôme (on prendra un x aléatoire, on cal-
culera P (x) et le bout de secret sera la paire (x, f (x))). Le secret commun sera le coefficient constant du polynôme P [0].
Question c :
1) Une solution simple consiste à prendre 10 bouts de secrets par général, 5 bouts de secret par colonel et 2 bouts de
secret par capitaine. Il faudra dans chacun des cas 10 bouts de secret pour le récupérer (le dernier produit 11 bouts
de secrets mais c’est pas grave, 1 capitaine de moins et il en reste que 9 ce qui n’est pas suffisant), on choisira donc
un polynôme aléatoire de degré k = 9 puis on devra donner 30 bouts de secret au total.

19.4.1 Sujet :
Dans la suite, on considèrera la courbe y 2 = x3 − x + 2 = x3 + 4 × x + 2 (mod 5) définie sur K = Z/5Z.
Question c : quelle est la structure du groupe de la courbe elliptique ?
Question d : y-a-t’il un élément générateur ? Si oui, en donner un.

2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
112 / 114 Année 2023 - 2024

19.4.2 Réponses :
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + x + 2 2 2 3 1 2
Cette courbe possède donc 3 points : (3, 1), (3, 4), 0.
Question c :
D’après le théorème de la courbe elliptique, la seule structure possible pour ce groupe est Z/1Z ⊕ Z/3Z qui possède 2
générateurs.
Question d :
Les 2 seuls générateurs possibles sont (3, 1) et (3, 4.
Nous pouvons calculer 1P , 2P dans chaque cas pour le vérifier :
(3, 1) :
0P = 0
1P = (3, 1)
2P = (3, 1) + (3, 1) = (3, 4) : coeff = 1/2 = 3, x3 = 32 − 2 × 3 = 3, y3 = 3 × (3 − 3) − 1 = 4
(3, 4) :
0P = 0
1P = (3, 4)
2P = (3, 4) + (3, 4) = (3, 1) : coeff = 1/2 = 3, x3 = 32 − 2 × 3 = 3, y3 = 3 × (3 − 3) − 4 = 1
19.5 Exercice 4 - avant la clé publique :

19.5.1 Sujet :
113 / 114 Année 2023 - 2024

miers avec P − 1.
19.5.2 Correction :
exposants.
114 / 114 Année 2023 - 2024


20.1.1 Sujet :
Question a : qu’est-ce qu’un certificat, rappeler son utilisation.
Question b : qu’est-ce qu’une chaı̂ne de certificats ? Dans quel cas l’utilise-t-on ?
Question c : qu’est-ce qu’un tiers de confiance, donner des exemples de telles entités.
Question d : est-ce que le chiffrement permet de faire de la signature ? de l’échange de clés ? de l’authentifica-
tion ? Si oui, comment ?
Question e : que permettent de fairer les schémas de Retrait d’Information Privé (PIR en anglais). Expliquer le
principe général. Donner des exemples d’utilisation concrète de ce type de protocole.
Question f : qu’est-ce qu’un chiffrement homomorphe ? Donner un exemple d’un tel protocole, et donner un exemple
d’application.
20.1.2 Réponses :
Question a : un certificat est un document numérique qui va contenir des informations sur une entité ainsi que la clé
publique de cette dernière. Cette clé publique sera signée par une autorité de degré supérieur.
Question b : une chaı̂ne de certificats contient le certificat de l’entité, puis le certificat utilisé pour signer le cer-
tificat de l’entité, puis le certificat utilisé pour signer ce certificat et ainsi de suite. Pour moi, on l’utilise pour vérifier
toute la chaı̂ne de confiance.
Question c : un tiers de confiance est comme son nom l’indique une entité tierce dont on va supposer qu’elle se
comporte de manière honête. Dans le cadre de la certification, un tiers de confiance entre un client et un serveur serait
l’autorité de certification qui est trusted par le client et qui lui permettra d’accepter le certificat du serveur.
Question d :
Question f : un chiffrement homomorphe est un algorithme de chiffrement asymétrique qui permet de faire des
opérations sur des textes chiffrés et ces opérations seront reflétées le texte en clair. Une propriété que l’on peut vouloir
est Enc(a) × Enc(b) = Enc(a + b) (ce qui a comme conséquence que Enc(a)b = Enc(a × b)).
Un exemple d’algorithme de chiffrement homomorphe est le chiffrement de Paillier (avec un module RSA n sur k bits)
où la taille du chiffré sera 2 × k.
Un exemple d’application est le vote électronique dans lequel chaque personne va envoyer le chiffré de son bulletin (0
s’il vote contre et 1 s’il vote pour) puis il suffira de multiplier tous ces chiffrés entre eux et de déchiffrer le résultat
pour avoir le nombre de voix. Une autre possibilité est dans le cadre d’un schéma PIR.

20.2.1 Sujet :
115 / 114 Année 2023 - 2024

Bob.
passes).
20.2.2 Réponses :
Question b :
Question c :
Question d :
116 / 114 Année 2023 - 2024

Question e :
20.3 Exercice 2 : Signatures :

20.3.1 Sujet :
Signature aveugle : on rappelle qu’un schéma de signature aveugle est un schéma où un Blinder B peut obtenir d’un
signataire S, une signature d’un message sans que S sache ce qu’il a signé.
Question a : donner un exemple d’application dans lequel une telle propriété pour la signature a vraiment un sens.
On considère une bi-clé de type RSA : clé publique (n, e) et clé privée (d, p, q) avec les notations habituelles.
Question b : soit m un message que l’on souhaite faire signer, sans que le signataire connaisse le contenu. Montrer
qu’on peut facilement adapter le schéma de signature RSA pour obtenir cette propriété (indice : il faut multiplier m
par quelque chose).
Question c : pourquoi un tel schéma est-il sûr et ne laisse-t-il pas passer d’information ?
Question d : la signature aveugle est un type de protocole utilisé pour garantir des propriétés de type anonymat,
connaissez-vous d’autres types de protocoles aussi utilisables dans un contexte d’anonymat.
Question e : délégation de signature : on suppose qu’Alice et Bob ont chacun une clé privée et une clé publique
permettant de fair ede la signature. Alice souhaite faire une délégation de signature à Bob pendant ses vacances, c’est
à dire que Bob doit pouvoir signer au nom d’Alice pendant une période de temps fixée, et ce bien sûr sans qu’Alice
soit obligée de donner sa clé privée. Comment peut-on faire cela ?
20.3.2 Réponses :
Question a : un exemple d’application est le vote électronique où l’on va vouloir signer notre bulletin pour pas que
le serveur ne triche mais cette signature ne peut être obtenue que par une entité tierce associée au serveur, du coup
on va vouloir cacher notre vote pour que l’entité tierce ne le connaisse pas.
Question b : On va envoyer m×re avec r une valeur aléatoire à l’oracle de signature qui va nous retourner s = (m×re )d
(mod n) = md × red = md × r (mod n).
Finalement, pour obtenir la signature associée au message m, il suffit de la multiplier par l’inverse de r modulo n !
Question c : a chaque étape, le message ou sa signature est toujours multiplié par une valeur r aléatoire que le
signataire ne connaı̂t pas et qui donc va agir comme un one time pad qui ne donne même pas un seul bit d’information
sur le message.
Question d : un VPN est un premier exemple d’obtention d’anonymat car notre IP est cachée et une personne
extérieure ne saura pas à qui est la session.

Partie 1 : coca-cola :
On rappelle qu’un schéma de partage de secret permet à plusieurs personnes qui ont en commun un (ou des) bout de
secret de retrouver un secret donné.
Question a : quelle est la différence entre le partage de secret et l’échange de clé ? Donner un exemple d’application
du partage de secret.
Question b : rappeler le schéma de partage de secret de Shamir. On se place dans un cas où le secret est la valeur
du polynôme en 0.
Question c : on suppose que la formule de coca-cola a été partagée entre trois personnes de telle sorte que 2 personnes
parmi les 3 puissent la retrouver. On se place dans Z/43Z et on récupère les parts donées à chacune des trois personnes
(une part est constituée de x et de P (x), le secret est la valeur de P en 0). Les parts : 1 = (2, 8), 2 = (5, 12), 3 = (10, 23).
Quel est donc le degré du polynôme recherché t quel est le secret partagé ?
Partie 2 : la bombe :
Question a : on suppose maintenant qu’on veut mettre en place un système qui permet à certains type de combinai-
sons de militaires de retrouver le secret du code nucléaire. On veut que les combinaisons suivantes puissent retrouver
le secret : 3 généraux, 4 colonels + 1 général, 3 colonels + 5 capitaines ou encore 20 capitaines. Comment faire ?
Question b : le problème de la solution précédente est qu’il est possible qu’un groupe formé uniquement de capitaines
117 / 114 Année 2023 - 2024

puisse retrouver le secret, ce qui pose problème. On souhaite donc mettre en place un système où pour retrouver le
secret il faille au moins : 1 général, 2 colonels, 4 capitaines qui collaborent. Cela signifie donc qu’un groupe formé
uniquement de capitaines ou de colonels (par exemple) ne pourra pas retrouver le secret. Comment faire ? (toujours
en utilisant un schéma basé sur le schéma de Shamir ou une variation).
20.4.1 Réponses :
1 - Question a : pour un échange de clé, on veut pouvoir créer une clé qui sera connue de 2 personnes sans connaı̂tre
1 - Question b : dans le schéma de partage de secret de Shamir, k sera le nombre de bouts de secret à rejoindre
pour obtenir le secret et n le nombre de bouts de secret total. L’idée est donc de créer un polynôme P de degré k − 1
dont les coefficients seront aléatoires, puis de prendre n points aléatoires sur ce polynôme (on prendra un x aléatoire,
on calculera P (x) et le bout de secret sera la paire (x, f (x))). Le secret commun sera P (0).
1 - Question c : vu que 2 personnes peuvent retrouver le secret, nous avons un polynôme de degré 1, donc de
la forme y = ax + b (mod 43).
Avec le premier point : 2a + b = 8 (mod 43)
Avec le second point : 5a + b = 12 (mod 43)
En soustrayant les 2 équations on peut obtenir 3a = 4 (mod 43) ⇔ a = 29 × 4 (mod 43) ⇔ a = 30 (mod 43)
En réutilisant la première équation nous avons 60 + b = 8 (mod 43) ⇔ b = 34 (mod 43).
Le point (10, 33) est également sur cette droite (je pense que Gaborit s’est gouré dans le sujet et il a mis 23 pour le y
au lieu de 33).
La solution est donc f (x) = 30x + 34 (mod 43) et donc le secret sera 34.
2 - Question a : l’idée va être de demander 60 bouts de secret avant de pouvoir récupérer le secret final, les
généraux auront 20 bouts de secrets, les colonnes en auront 5 et les capitaines en auront 3. Je pense encore une fois
que Gaborit s’est gouré dans le sujet, pour que ça soit possible il aurait fallu mettre 10 capitaines pour la dernière
condition, voici une démonstration de pourquoi :
3G = X pour la première équation.
1G + 4C = X ⇔ 3G + 12C = 3X ⇔ 12C = 2X ⇔ 6C = X
3C + 5c = X ⇔ 6C + 10c = 2X ⇔ 10c = X
20c = X
On a donc une grosse contradiction sur les 2 dernières équations.
2 - Question b : ne connaissant pas le nombre total de capitaines, on ne pourra pas donner un nombre infini
de bouts de secrets aux généraux. L’idée sera donc de procéder en 2 étapes : dans une première étape chaque colonel
aura un bout d’un secret C1 et chaque capitaine aura un bout d’un secret c1 qui pourront être reconstitués quand
respectivement 2 colonels et 4 capitaines se mettront d’accord. Ensuite le groupe de 1 général, de 2 colonels et de 4
capitaines mettront en commun les secrets dérivés à la première étape pour arriver à un secret final (via un second
partage de Shamir).

20.5.1 Sujet :
Question c : pour tous les points P différents du point à l’infini, calculer 2P et 4P .
Question d : donner un générateur du groupe (un point P tel que 0P, P, 2P, ... engendre le groupe). En déduire la
structure du groupe de la courbe.
118 / 114 Année 2023 - 2024


2 !
3 × x21 + a 3 × x21 + a

(x3 , y3 ) = − 2 × x1 , × (x1 − x3 ) − y1
2 × y1 2 × y1
20.5.2 Réponses :
Question a : l’intérêt de prendre les courbes elliptiques est que les tailles de clés sont plus petites par rapport à
du RSA ou du El-Gamal (car il n’y a pas d’opération de groupe non nécessaire). Mais, le temps pris pour l’addition
de 2 points est 10 fois supérieur au temps d’une multiplication modulaire, le choix des courbes elliptiques ne se fera
donc qu’à partir d’une certaine taille de clé. Pour le schéma, refaire celui au début de la partie sur les courbes elliptiques.
Question b :
y 0 1 2 3 4 x 0 1 2 3 4
y2 0 1 4 4 1 x3 + x + 3 3 0 3 3 1
Question c :
2 × (1, 0) = 0
2 × (4, 1) = (1, 0) et 4 × (4, 1) = 0
2 × (4, 4) = (1, 0) et 4 × (4, 4) = 0
Question e :
Oui, il y a un générateur, il y en a même φ(4) = 2.
P = (4, 1) est un exemple de générateur.
D’après le théorème de la courbe elliptique, nous avons 2 possibilités :
Vu qu’il y a un générateur, cette courbe est isomorphe à Z/1Z ⊕ Z/4Z.
119 / 114 Année 2023 - 2024

Meca Crypto

Transféré par

Informations du document

Titre original

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é ?

Droits d'auteur :

Formats disponibles

Meca Crypto

Transféré par

Droits d'auteur :

Formats disponibles

Révisions - Mécanismes cryptographiques

Table des matières

2 Annale d’une année précédente : 4

8 Courbes elliptiques partie 2 - structure des courbes elliptiques : 30

9 Les lattices (cours de Gaborit) : 35

10 Dernière séance de l’année avec Gaborit : 38

11 Les lattices (fait par moi) : 41

2 / 114 Année 2023 - 2024

13 Annale du 24 novembre 2021 : 65

14 Annale du 25 novembre 2020 : 70

3 / 114 Année 2023 - 2024

15 Annale du 20 novembre 2019 : 78

16 Annale du 28 novembre 2018 : 85

17 Annale du 17 février 2020 : 93

4 / 114 Année 2023 - 2024

18 Annale du 13 février 2018 : 99

19 Annale du 12 février 2015 : 105

5 / 114 Année 2023 - 2024

20 Annale du 7 février 2013 : 110

6 / 114 Année 2023 - 2024

1.2 Un historique de la cryptographie :

1.4 Chiffrements par blocs :

1.5 Fonctions de hachage :

7 / 114 Année 2023 - 2024

1.6 Chiffrement à clé publique :

8 / 114 Année 2023 - 2024

2 Annale d’une année précédente :

2.2 Exercice 2 : Cryptographie à clé secrète :

9 / 114 Année 2023 - 2024

Nous pouvons maintenant faire le xor entre la clé et le message :

Question c : pour ce faire, nous allons considérer chaque caractère du chiffré :

2.3 Exercice 3 : Cryptographie à clé secrète :

10 / 114 Année 2023 - 2024

Nous pouvons maintenant passer au calcul des bits restants de s :

Pour terminer, il reste à calculer le message en clair :

2.4 Exercice 4 : RSA :

Question a : calculer φ(n)

Question b : sachant que 21 = 3 × 7 et que e = 5, montrer que l’exposant secret d vaut 5.

Question b : d = e−1 (mod φ(n)) = 5−1 (mod 12) = 5 (car 5 × 5 = 25 = 24 + 1).

2.5 Exercice 5 : cryptographie à clé publique :

11 / 114 Année 2023 - 2024

2.6 Exercice 6 : avant la clé publique :

12 / 114 Année 2023 - 2024

Question a : pourquoi a-t-on M zx = M (mod P ) ? Soyez complet dans vos explications !

Question b : (M xy )z (mod P ) = M xyz (mod P ) = (M xz )y (mod P ) = M y (mod P )

2.7 Exercice 7 : authentification :

Question a : comment est-ce qu’Alice vérifie que l’envoyeur du message 2. connaı̂t k ?

13 / 114 Année 2023 - 2024

Et une autre image pour voir à quoi ressemblerait un registre combiné :

Pour ce qui est des attaques algébriques, elles se divisent en 2 étapes :

14 / 114 Année 2023 - 2024

3.2 Un exemple sur un LFSR simple :

Notez que ce dernier peut être remis sous la forme suivante :

Ce que nous voulons trouver c’est une relation de la forme suivante :

15 / 114 Année 2023 - 2024

3.3 Exemple d’attaque sur un registre filtré :

Calculons quelques uns des Xi suivants pour voir :

16 / 114 Année 2023 - 2024

3.4 Généralisation de l’attaque :

La première étape consiste à trouver la matrice représentant l’évolution du LFSR :

Ce qui nous donne :

3.5 Rendre l’inversion de matrice plus rapide :

17 / 114 Année 2023 - 2024