Introduction aux blockchains Cours électif transversal ...

Introduction aux blockchains

Cours électif transversal

2ème annéeÉcole des Mines de Nancy

Xavier Goaoc

2020-2021

Préambule

Une chaîne de blocs, ou blockchaine, est un système permettant d'établir et de maintenirun registre de manière infalsiable (une donnée, une fois enregistrée, n'est plus modiable) etdistribuée (aucune autorité centralisée n'est nécessaire). Ce type de système a été largementpopularisé via les cryptomonnaies telles que Bitcoin. L'objectif de ce cours est de donner lesconcepts théoriques permettant d'en comprendre les principes, les enjeux et les limites.

Les blockchaines sont construites en combinant des idées provenant de deux domaines del'informatique : la cryptographie et l'algorithmique distribuée. La première partie de ce cours(séances 1 à 3) est consacrée à l'étude de deux primitives cryptographiques (fonction de hachageet protocole de signature). La séance 4 présente le système Bitcoin, qui construit une monnaiedécentralisée au moyen de ces primitives cryptographiques ; une partie de la séance est consacréeà une analyse de cycle de vie du système Bitcoin mettant en lumière son impact écologiquetotalement déconnecté du service rendu. Le coût écologique duBitcoin s'explique par la manièreoriginale dont il résout deux problèmes fondamentaux de calcul distribué que pose la miseen ÷uvre d'une blockchaine : l'élection et le consensus. Les séances 4 à 7 seront consacréesà ces problèmes. Nous y esquisserons les dicultés fondamentales que posent ces problèmespar plusieurs théorèmes d'impossibilité, et présenterons quelques exemples d'algorithmes (dontPaxos sur lequel sont basées de nombreuses solutions industrielles).

Ce polycopié couvre le contenu de ces quatre séances. Il est rédigé pour vous servir deréférence lorsque vous souhaitez revenir sur un point évoqué en cours. Cela peut tout autantconcerner une notion générale ( les paroles s'envolent et les écrits restent ) qu'un détail (parexemple lors d'un travail sur un exercice de TD similaire à ce que l'on a vu en CM) ou unepreuve technique qui n'a pas été développée en cours.

La diculté des exercices de TD est mesurée par l'échelle (approximative) suivante :

FNe demande aucune connaissance préalable ou simple véricationde la compréhension d'une dénition.

FFApplication directe d'une idée supposée acquise ou expliquée encours.

FFF

Demande une idée originale, ou une application originale d'uneidée supposée acquise ou expliquée en cours, ou une applicationcombinée de plusieurs idées supposées acquises ou expliquées encours.

FFFF Dicile.

Pour l'évaluation de ce module, je vous soumettrai quelques documents techniques (enanglais) décrivant la mise en ÷uvre d'une blockchaine et vous demanderai d'en faire une analyse.

3

Cette analyse sera à faire par binôme et à rendre, sous la forme d'un document de synthèse,quelques semaines après la n du cours.

Je tiens à remercier Pierrick Gaudry, Eve-Angéline Lambert, Olivier Mirgaux et BogdanWarinschi, dont les conseils, suggestions et explications m'ont beaucoup aidé à préparer ce cours.Inutile de dire que les erreurs, coquilles et autres approximations sont entièrement de mon fait.

4

Table des matières

1 Hachage cryptographique et applications1 Hachage cryptographique et applications 91.1 Fonctions de hachage et grands espaces1.1 Fonctions de hachage et grands espaces . . . . . . . . . . . . . . . . . . . . . . . . 9

1.1.1 Fonction de hachage1.1.1 Fonction de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.1.2 Collisions et grands espaces1.1.2 Collisions et grands espaces . . . . . . . . . . . . . . . . . . . . . . . . . . 101.1.3 Quelques exercices1.1.3 Quelques exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2 Fonctions de hachage cryptographique1.2 Fonctions de hachage cryptographique . . . . . . . . . . . . . . . . . . . . . . . . 121.2.1 Exemple : mots de passe et /etc/shadow1.2.1 Exemple : mots de passe et /etc/shadow . . . . . . . . . . . . . . . . . . . 121.2.2 Hypothèses cryptographiques1.2.2 Hypothèses cryptographiques . . . . . . . . . . . . . . . . . . . . . . . . . 121.2.3 Pourquoi ne sait-on pas prouver... ?1.2.3 Pourquoi ne sait-on pas prouver... ? . . . . . . . . . . . . . . . . . . . . . . 131.2.4 Pour résumer1.2.4 Pour résumer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.2.5 Quelques exercices1.2.5 Quelques exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.3 Quelques compléments1.3 Quelques compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.3.1 Le reader's digest1.3.1 Le reader's digest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.3.2 L' engagement1.3.2 L' engagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.3.3 L'anti-spam par preuve de travail1.3.3 L'anti-spam par preuve de travail . . . . . . . . . . . . . . . . . . . . . . . 151.3.4 L'audit1.3.4 L'audit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.4 Ci-git SHA-11.4 Ci-git SHA-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.5 Et pour quelques exercices de plus...1.5 Et pour quelques exercices de plus... . . . . . . . . . . . . . . . . . . . . . . . . . 16

2 Étude d'une fonction de hachage & structures de données hachées2 Étude d'une fonction de hachage & structures de données hachées 192.1 Construction de Merkle-Darmgård2.1 Construction de Merkle-Darmgård . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.1.1 Dénition2.1.1 Dénition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.1.2 Propriété MD2.1.2 Propriété MD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.1.3 Exercices2.1.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2 SHA-2562.2 SHA-256 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.2.1 Notations et opérations binaires2.2.1 Notations et opérations binaires . . . . . . . . . . . . . . . . . . . . . . . . 212.2.2 Constantes2.2.2 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.2.3 Chargement du chainage et du bloc2.2.3 Chargement du chainage et du bloc . . . . . . . . . . . . . . . . . . . . . . 222.2.4 La fonction de calcul2.2.4 La fonction de calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.2.5 Exercice2.2.5 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.2.6 À propos de la cryptanalyse de Sha-2562.2.6 À propos de la cryptanalyse de Sha-256 . . . . . . . . . . . . . . . . . . . 23

2.3 Attaque par extension de longueur2.3 Attaque par extension de longueur . . . . . . . . . . . . . . . . . . . . . . . . . . 232.3.1 L'idée2.3.1 L'idée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.3.2 Le comment2.3.2 Le comment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.3.3 Le pourquoi : protocole MAC2.3.3 Le pourquoi : protocole MAC . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4 Structures de données à pointeurs hachés2.4 Structures de données à pointeurs hachés . . . . . . . . . . . . . . . . . . . . . . . 252.4.1 Pointeur haché2.4.1 Pointeur haché . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.4.2 Liste chaînée hachée (= blockchain)2.4.2 Liste chaînée hachée (= blockchain) . . . . . . . . . . . . . . . . . . . . . 262.4.3 Arbre de Merkle2.4.3 Arbre de Merkle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

5

2.4.4 Exercices2.4.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3 Signature digitale, principe de monnaie digitale3 Signature digitale, principe de monnaie digitale 293.1 Notion de signature3.1 Notion de signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.2 Un premier système de signature numérique3.2 Un premier système de signature numérique . . . . . . . . . . . . . . . . . . . . . 29

3.2.1 Principe3.2.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.2.2 Logarithme discret3.2.2 Logarithme discret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.2.3 Signature de Schnorr3.2.3 Signature de Schnorr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.2.4 Exercices3.2.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3 De la signature à l'identité digitale3.3 De la signature à l'identité digitale . . . . . . . . . . . . . . . . . . . . . . . . . . 313.4 Application : une ébauche de cryptomonnaie3.4 Application : une ébauche de cryptomonnaie . . . . . . . . . . . . . . . . . . . . . 32

3.4.1 Une première tentative ratée3.4.1 Une première tentative ratée . . . . . . . . . . . . . . . . . . . . . . . . . 323.4.2 Une seconde tentative (avec registre)3.4.2 Une seconde tentative (avec registre) . . . . . . . . . . . . . . . . . . . . . 32

3.5 Signatures DSA et ECDSA3.5 Signatures DSA et ECDSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.5.1 Le système DSA3.5.1 Le système DSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.5.2 Groupe associé à une courbe elliptique et ECDSA3.5.2 Groupe associé à une courbe elliptique et ECDSA . . . . . . . . . . . . . . 34

3.6 Preuve à divulgation nulle de connaissance3.6 Preuve à divulgation nulle de connaissance . . . . . . . . . . . . . . . . . . . . . . 353.7 Exercices supplémentaires3.7 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

4 Un exemple concret de blockchain : Bitcoin4 Un exemple concret de blockchain : Bitcoin 374.1 Problématique : que veut dire créer une monnaie ?4.1 Problématique : que veut dire créer une monnaie ? . . . . . . . . . . . . . . . . . 37

4.1.1 Lexique monétaire4.1.1 Lexique monétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.1.2 Création, appropriation et double dépense4.1.2 Création, appropriation et double dépense . . . . . . . . . . . . . . . . . . 38

4.2 Principes de Bitcoin (et de nombreuses cryptomonnaies)4.2 Principes de Bitcoin (et de nombreuses cryptomonnaies) . . . . . . . . . . . . . 384.2.1 Comptes et transactions4.2.1 Comptes et transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384.2.2 Registre4.2.2 Registre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394.2.3 Ajout de transactions au registre4.2.3 Ajout de transactions au registre . . . . . . . . . . . . . . . . . . . . . . . 394.2.4 Création monétaire4.2.4 Création monétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4.3 Exercices4.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404.4 Principe de l'élection et du consensus dans Bitcoin4.4 Principe de l'élection et du consensus dans Bitcoin . . . . . . . . . . . . . . . . 41

4.4.1 Preuve de travail4.4.1 Preuve de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.4.2 Diusion dans le réseau4.4.2 Diusion dans le réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.4.3 Un équilibre délicat4.4.3 Un équilibre délicat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.4.4 Exercices4.4.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

4.5 Commentaire : techniques de minage4.5 Commentaire : techniques de minage . . . . . . . . . . . . . . . . . . . . . . . . . 444.6 Commentaire : impact environnemental de Bitcoin4.6 Commentaire : impact environnemental de Bitcoin . . . . . . . . . . . . . . . . 45

4.6.1 Type d'ACV et unité fonctionnelle4.6.1 Type d'ACV et unité fonctionnelle . . . . . . . . . . . . . . . . . . . . . . 454.6.2 Inventaire4.6.2 Inventaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.6.3 Traduction4.6.3 Traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.6.4 Quelques éléments d'appréciation4.6.4 Quelques éléments d'appréciation . . . . . . . . . . . . . . . . . . . . . . . 46

4.7 Commentaire : conance en le système Bitcoin4.7 Commentaire : conance en le système Bitcoin . . . . . . . . . . . . . . . . . . . 474.8 Ouvertures4.8 Ouvertures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4.8.1 Dynamique d'une cryptomonnaie4.8.1 Dynamique d'une cryptomonnaie . . . . . . . . . . . . . . . . . . . . . . . 474.8.2 Les preuves de travail, un pis-aller4.8.2 Les preuves de travail, un pis-aller . . . . . . . . . . . . . . . . . . . . . . 484.8.3 Gouvernance4.8.3 Gouvernance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

4.9 Et encore un exercice4.9 Et encore un exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6

5 Consensus et élection en calcul distribué synchrone5 Consensus et élection en calcul distribué synchrone 515.1 Modèle de système distribué à réseau5.1 Modèle de système distribué à réseau . . . . . . . . . . . . . . . . . . . . . . . . . 51

5.1.1 Machines et rupture de symétrie5.1.1 Machines et rupture de symétrie . . . . . . . . . . . . . . . . . . . . . . . 515.1.2 Communication par réseau5.1.2 Communication par réseau . . . . . . . . . . . . . . . . . . . . . . . . . . 515.1.3 Algorithme et synchronisation5.1.3 Algorithme et synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . 525.1.4 Retards, pannes et dysfonctionnements5.1.4 Retards, pannes et dysfonctionnements . . . . . . . . . . . . . . . . . . . . 525.1.5 Dénition d'un modèle5.1.5 Dénition d'un modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

5.2 Élection dans un système synchrone sans panne5.2 Élection dans un système synchrone sans panne . . . . . . . . . . . . . . . . . . . 535.2.1 Avec identiants uniques dans un réseau complet5.2.1 Avec identiants uniques dans un réseau complet . . . . . . . . . . . . . . 535.2.2 Sans identiant unique, à deux machines5.2.2 Sans identiant unique, à deux machines . . . . . . . . . . . . . . . . . . . 545.2.3 Exercices5.2.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

5.3 Consensus dans un système synchrone sans panne5.3 Consensus dans un système synchrone sans panne . . . . . . . . . . . . . . . . . . 555.4 Consensus synchrone avec pannes non Byzantines5.4 Consensus synchrone avec pannes non Byzantines . . . . . . . . . . . . . . . . . . 56

5.4.1 L'unanimité échoue5.4.1 L'unanimité échoue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.4.2 Une solution5.4.2 Une solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.4.3 Exercices5.4.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

5.5 Et pour quelques exercices de plus5.5 Et pour quelques exercices de plus . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6 Consensus et élection en calcul distribué asynchrone6 Consensus et élection en calcul distribué asynchrone 596.1 Modèle asynchrone à réseau6.1 Modèle asynchrone à réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.2 Élection asynchrone dans un réseau en anneau sans panne6.2 Élection asynchrone dans un réseau en anneau sans panne . . . . . . . . . . . . . 596.3 Consensus asynchrone, Paxos et théorème FLP6.3 Consensus asynchrone, Paxos et théorème FLP . . . . . . . . . . . . . . . . . . . 616.4 L'algorithme Paxos6.4 L'algorithme Paxos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

6.4.1 Rôles, dates et choix6.4.1 Rôles, dates et choix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.4.2 L'algorithme, en résumé6.4.2 L'algorithme, en résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626.4.3 Exercices6.4.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.4.4 Variantes et améliorations6.4.4 Variantes et améliorations . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6.5 Impossibilité du consensus asynchrone avec une panne6.5 Impossibilité du consensus asynchrone avec une panne . . . . . . . . . . . . . . . 646.5.1 Le vocabulaire6.5.1 Le vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.5.2 Exercices6.5.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.5.3 Une panne peut provoquer de la bivalence, qui se propage6.5.3 Une panne peut provoquer de la bivalence, qui se propage . . . . . . . . . 666.5.4 Un théorème c'est bien, une preuve c'est encore mieux6.5.4 Un théorème c'est bien, une preuve c'est encore mieux . . . . . . . . . . . 68

7 Pannes Byzantines7 Pannes Byzantines 697.1 Notion de panne Byzantine7.1 Notion de panne Byzantine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697.2 Consensus distribué Byzantin et cohérence interactive7.2 Consensus distribué Byzantin et cohérence interactive . . . . . . . . . . . . . . . 707.3 Exercices7.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727.4 Un algorithme pour la cohérence interactive7.4 Un algorithme pour la cohérence interactive . . . . . . . . . . . . . . . . . . . . . 72

7.4.1 Exercices7.4.1 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737.5 Théorème d'impossibilité et le seuil d'un tiers7.5 Théorème d'impossibilité et le seuil d'un tiers . . . . . . . . . . . . . . . . . . . . 74

7.5.1 Formalisation des algorithmes de cohérence interactive7.5.1 Formalisation des algorithmes de cohérence interactive . . . . . . . . . . . 747.5.2 Exercices7.5.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

7.6 Énoncé et preuve du théorème d'impossibilité7.6 Énoncé et preuve du théorème d'impossibilité . . . . . . . . . . . . . . . . . . . . 757.6.1 Trois scénarii7.6.1 Trois scénarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757.6.2 Propriétés des scénarii7.6.2 Propriétés des scénarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767.6.3 Cohérence7.6.3 Cohérence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767.6.4 Aboutissement7.6.4 Aboutissement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

8 En guise de conclusion8 En guise de conclusion 79

7

A Quelques repères en complexitéA Quelques repères en complexité 83

B Quelques rappels d'arithmétiqueB Quelques rappels d'arithmétique 85

C Formalisation des preuves à divulgation nulle de connaissanceC Formalisation des preuves à divulgation nulle de connaissance 87

D Principe d'une analyse de cycle de vieD Principe d'une analyse de cycle de vie 89

8

Chapitre 1

Hachage cryptographique etapplications

Ce premier chapitre introduit un couteau suisse de la cryptographie, les fonctions de

hachage cryptographiques, et montre comment il permet de rendre un ensemble de données in-formatiques résistant à la modication, ou plus précisément de donner des garanties raisonnablesque toute modication sera détectable.

1.1 Fonctions de hachage et grands espaces

On appelle mot binaire un élément de⋃

n∈N∗0, 1n, c'est à dire une suite nie de chires,chacun valant 0 ou 1. Si w est un mot binaire, on note |w| son nombre de chires (le n tel quew ∈ 0, 1n) et bin(w) le nombre entier ayant w comme écriture binaire. Ainsi, bin(100) = 4 =bin(0100). Dans la suite, on identiera occasionnellement un nombre entier n avec le mot binaireformé par son écriture binaire (c'est à dire, le plus petit mot binaire w tel que bin(w) = n).

1.1.1 Fonction de hachage

Une fonction de hachage est une fonction qui associe à tout mot binaire un mot binairede taille xée ` ; l'entier ` est xé librement et est appelé taille de la fonction de hachage.Autrement dit, une fonction de hachage de taille ` est une fonction

⋃n∈N∗0, 1n → 0, 1`.

Voici trois exemples (deux triviaux, un utile) de fonctions de hachage :

• La fonction qui à un mot w associe 1 si w contient un nombre pair de 1 et 0 sinon est unefonction de hachage de taille 1.

• La fonction qui à un mot w associe le mot u ∈ 0, 1` tel que bin(u) = bin(w) mod 2` estune fonction de hachage de taille `.

• La fonction qui associe à un mot w le mot u ∈ 0, 1` tel que bin(u) = (a∗bin(w) mod p)mod 2`, où p > 2` est un entier premier et 1 ≤ a < p est un autre entier, est une fonctionde hachage de taille `. Oui, c'est celle-ci qui peut être utile 11 22, mais pas dans le cadre dece cours.

1. On peut montrer que pour tous mots binaires w, w′, si l'on choisit a aléatoirement uniformément dans2, 3, . . . , p−1, la probabilité que w et w′ ait la même image par cette fonction de hachage est O(2−`). Autrementdit, une table de hachage basée sur une telle fonction de hachage (choisie aléatoirement une fois pour toute à lacréation de la table) garantit eectivement un temps d'accès moyen en O(1) pour une séquence raisonnablementpetite d'objets quelconques. Et non, une table de hachage ne permet pas de ranger n objets en garantissant unaccès de complexité O(1) : cette complexité s'entendant comme le pire-cas, elle est O(n) quel que soit la fonctionde hachage.

2. Cf http://jeffe.cs.illinois.edu/teaching/algorithms/notes/05-hashing.pdfhttp://jeffe.cs.illinois.edu/teaching/algorithms/notes/05-hashing.pdf pour plus de plus

9

http://jeffe.cs.illinois.edu/teaching/algorithms/notes/05-hashing.pdf

Rappelons que dans les ordinateurs tels qu'on les connaît aujourd'hui 33, toute informationou suite d'informations (texte, image, son, vidéo, programme informatique, etc.) est représentéepar un mot binaire. Une fonction de hachage est donc une manière d'associer à toute suited'information une empreinte de taille xée. L'image d'un mot binaire par une fonction dehachage est appelé le haché de ce mot (par cette fonction).

Une première propriété que l'on souhaite pour les fonctions de hachage est d'être facilementcalculable. On entend par là qu'il doit exister un algorithme qui, étant donné w, calcule H(w)en un nombre d'étapes de calcul élémentaires polynomial (mieux, linéaire) en |w|. (Formellement,on souhaite un algorithme en modèle RAM de complexité polynomiale, voire linéaire.)

1.1.2 Collisions et grands espaces

Le principe des tiroirs assure que pour toute fonction de hachage H, il existe des paires demots (w,w′) tels que w 6= w′ et H(w) = H(w′). On appelle une telle paire une collision pourH. Pour qu'une fonction de hachage soit intéressante d'un point de vue cryptographique, il fautqu'il soit dicile d'en trouver des collisions.

Cette idée peut apparaître surprenante, car il est facile de proposer un algorithme qui calculeune collision (w,w′) pour une fonction de hachage H donnée en entrée. En voici une en pseudo-code, en syntaxe proche de Python.

def enum(H):

vu, i, h = [(0,H(0))], 1, H(1)

while True:

for (a,b) in vu:

if b == h:

return (i,a)

vu.insert((i,h))

i = i+1

h = H(i)

(Rappel : on identie un entier et le mot binaire formé par son écriture binaire, ainsi H(42) vautH(101010).) Il se trouve que dès que la taille de la fonction de hachage est susamment grande,cette solution par énumération est inecace en pratique. Pour cela, il peut être utile d'avoir àl'esprit les ordres de grandeur suivants :

210 ' 1 000, et donc 2k ' 10k/3

260 ≥ le nombre de secondes restant avant que le Soleil d'absorbe la Terre280 ≥ le nombre d'opérations en virgule ottante réalisées par l'IBM Summit en 1 siècle2240 ≥ le nombre estimé d'atomes dans l'univers observable

Ainsi, simplement compter jusqu'à 280 s'avère une tâche calculatoirement titanesque. On supposedorénavant que les fonctions de hachage ont une taille d'au moins 256 bits de manière à assurerque l'espace de tous les hachés est raisonnablement grand, et que tout algorithme procédantpar simple énumération ne donne aucune garantie d'ecacité.

amples détails (mais ceci sort du cadre de ce cours).3. Autrement dit, non quantiques.

10

1.1.3 Quelques exercices

Exercice 1 F Voici ci-dessous, en hexadécimal 44, les hachés de bonjour par plu-sieurs fonctions de hachage classiques :

MD2 91c6f440d8fc32de5f2c2687de605272MD4 91a9c95865d6a15d4c21275fa7a793aeSHA1 1f71e0f4ac9b47cd93bf269e4017abaab9d3bd63

SHA3- ? ? ? 841737fcddb84662bcab6785ba253ed7f790b50aa07b01a3d5606c

Donnez la taille de chacune de ces fonctions de hachage.

Exercice 2 FF Le hashrate du système Bitcoin indique le nombre d'évaluationsd'une certaine fonction de hachage qui ont été réalisées collectivement par l'ensembledes machines du système. Cette grandeur est généralement mesurée en nombre d'éva-luations par seconde ou par jour.

a. Déterminez (approximativement) le hashrate (par seconde) de Bitcoin de nosjours. S'il faut xer une référence précise, on utilisera le 1er février 2021.

b. À ce rythme, combien de temps faut-il au système Bitcoin pour calculer 280

fonctions de hachage ?

Exercice 3 FF (Probabilités discrètes)

Examinons une variante probabiliste de l'algorithme de recherche de collision parénumération. Supposons que H soit une fonction de hachage de taille 256 bits, ettelle que les hachés des chaînes de 1024 bits se répartissent uniformément sur leschaînes de 256 bits.

a. Supposons que l'on tire un ensemble E de k chaînes 1024 distinctes, unifor-mément au hasard. Quelle est la probabilité pk que E contienne deux chaînesdistinctes de même haché par H ?

b. À partir de quelle valeur de k a-t-on pk ≥ 0.5 ? Idem pour pk ≥ 0.01 ?

c. Supposons que Summit calcule un haché en une opération à virgule ottante.Combien de temps faut-il à cette machine pour tester un ensemble E suf-samment grand pour que la probabilité de trouver une collision soit d'aumoins 50% ? 1% ?

4. L'hexadécimal est un système numérique en base 16 qui utilise comme chires0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f. La base 16 est aussi (en fait, plus) compacte que l'écriture décimaleet a l'avantage que ses chires sont en correspondance avec les chires binaires : chaque chire hexadécimalcorrespond à 4 chires binaires (car 16 = 24).

11

1.2 Fonctions de hachage cryptographique

Les fonctions de hachage ont de nombreuses applications en sécurité informatique. Ces ap-plications ne sont généralement pas liées à une fonction de hachage spéciques, mais peuventutiliser n'importe quelle fonction de hachage satisfaisant certaines hypothèses. Illustrons cela surun premier exemple, avant de discuter ces hypothèses plus systématiquement.

1.2.1 Exemple : mots de passe et /etc/shadow

Comment un système informatique peut-il faire pour être capable de vérier le mot de passed'un utilisateur sans pour autant le stocker de manière trop accessible ? Supposons que l'ondispose d'une fonction de hachage H satisfaisant l'hypothèse suivante :

Résistance à la première pré-image. Étant donné un haché h, il est infai-sable en pratique de calculer un mot binaire w tel que H(w) = h.

On peut alors se dispenser de stocker les mots de passe, et ne stocker que leurs hachés parH. Lorsque quelqu'un prétend s'authentier en tant qu'Alice au moyen d'un mot de passe m,on calcule H(m) et on le compare au haché h du mot de passe d'Alice (que l'on a stocké). SiH(m) égale h alors on accepte le mot de passe, sinon on le refuse.

Remarquons que dans ce système (mis en ÷uvre par exemple par le système passwd sur unix),tant qu'il est dicile de calculer une pré-image pour H, il est dicile à quelqu'un ayant accèsaux données stockées (les hachés des mots de passe) d'usurper une identité. Autrement dit, lapropriété de sécurité du système ne pas pouvoir usurper une identité quand on a accès à la listedes hachés repose sur l'hypothèse H est résistante à la première pré-image . Remarquonsque si un jour, la cryptanalyse progresse et H cesse d'être résistante à la première pré-image lesystème perd sa propriété de sécurité ; on peut cependant la restaurer en remplaçant H par unenouvelle fonction de hachage, elle résistante. 55

1.2.2 Hypothèses cryptographiques

Une fonction de hachage H est dite cryptographique si elle satisfait les hypothèses sui-vantes :

Résistance à la collision. Il est infaisable en pratique de calculer deux motsbinaires w et w′ tels que H(w) = H(w′).

Résistance à la première pré-image. Étant donné un haché h, il est infai-sable en pratique de calculer un mot binaire w tel que H(w) = h.

Résistance à la seconde pré-image. Étant donné un mot binaire w, il estinfaisable en pratique de calculer un mot binaire w′ 6= w tel que H(w′) = H(w).

5. Ne pas oublier de demander à tous les utilisateurs de réinitialiser leur mot de passe avec un outil intégrantcette nouvelle fonction.

12

Autrement dit, la fonction est dicile à inverser , même de manière limitée. Remarquonsqu'en théorie, chacune de ces tâches peut être menée à bien par une exploration systématique,déterministe ou probabiliste. Comme on l'a vu, cette approche s'avère inecace en pratique dèsque la taille de la fonction de hachage est susamment grande (par exemple ≥ 256 bits). Ici, onconsidère une tâche comme infaisable en pratique si aucune méthode connue ne permet defaire substantiellement mieux.

Il est, en principe, facile d'établir qu'une fonction de hachage n'est pas cryptographique :il sut de donner une solution pratiquement ecace à l'un des problèmes ci-dessus. On nesait, en revanche, pas prouver que ces problèmes sont diciles pour une seule fonction. Parconséquent, le fait qu'une fonction de hachage soit considérée comme cryptographique reposesur un consensus de la communauté des cryptographes sur l'état des méthodes connues. Ceconsensus évolue au l du temps et de l'avancée de la recherche. D'un côté, la découverte d'unenouvelle méthode peut amener à déchoir une fonction de son statut cryptographique. De l'autre,la formation d'un consensus sur le fait que les méthodes connues échouent à inverser unefonction nouvellement proposée lui confère le statut de cryptographique.

1.2.3 Pourquoi ne sait-on pas prouver... ?

Il peut sembler pour le moins inconfortable de construire des systèmes dont la sécuritérepose sur des hypothèses non-prouvées et susceptibles d'évoluer, ne serait-ce que pour la veilletechnologique que cela impose.

On dit qu'une fonction f : E → S est à sens unique ( one-way ) s'il existe un algorithmequi, étant donné x ∈ E calcule f(x) en temps polynomial en la taille de x, mais qu'il n'existepas d'algorithme qui, étant donné y ∈ S, calcule un x tel que y = f(x) en temps polynomial enla taille de y. Cette notion propose une formalisation raisonable, dans le cadre de la théorie de

la complexité, de propriétés minimales attendues d'une fonction de hachage cryptographique. 66

Il se trouve qu'à ce jour, l'existence même d'une fonction à sens unique est un problèmeouvert important. En fait, s'il existe une fonction à sens unique alors P 6= NP , et c'est unproblème majeur en informatique théorique qui serait ainsi résolu 77.

Remarquons par ailleurs que pour toute fonction de hachage H, il existe un algorithme decomplexité O(1) qui retourne une collision ! Un tel algorithme est de la forme

def retourne_collision():

return (a,b)

Bien évidemment, on ne connaît pas les valeurs a et b qui font que cet algorithme retourneeectivement une collision. Mais l'existence d'un tel algorithme rend la formalisation théoriquede la résistance aux collisions délicate.

1.2.4 Pour résumer

Les hypothèses cryptographiques sur les fonctions de hachage sont à comprendre commeune interface entre le domaine de la conception et l'analyse des fonctions de hachage, et les do-maines qui les utilisent. Ces derniers construisent des systèmes basés sur des fonctions de hachage

6. En théorie de la complexité, on considère généralement qu'un problème algorithmique peut être ecacementrésolu si et seulement si il admet un algorithme de complexité polynomiale.

7. Cf. https://www.claymath.org/millennium-problemshttps://www.claymath.org/millennium-problems

13

https://www.claymath.org/millennium-problems

génériques satisfaisant certaines hypothèses. Lorsqu'un système est implanté, on choisit une fonc-tion concrète qui satisfait actuellement aux hypothèses. Si cette fonction s'avère, ultérieurementdéfaillante, il sura de la remplacer pour restaurer les propriétés (sécurité, performance, etc.)du système.

1.2.5 Quelques exercices

Exercice 4 FF On a présenté trois hypothèses cryptographiques (résistance auxcollisions, résistance à la première/seconde préimage). Est-ce que l'une de ces hypo-thèses en implique une autre ? Justiez votre réponse.

Exercice 5 FF Supposons que H1 et H2 soient deux fonctions de hachage. Onnote H1 H2 la composition et H1‖H2 la fonction obtenue par concaténation, c'està dire que H1‖H2(x) = H1(x)H2(x). Donner des conditions aussi minimales quepossible sur H1 et H2 pour que...

a. H1 H2 soit résistante aux collisions,

b. H1‖H2 soit résistante aux collisions,

c. H1 H2 soit résistante à la 2ème pré-image.

Exercice 6 F (Avec machine) L'application en ligne

https://emn178.github.io/online-tools/https://emn178.github.io/online-tools/

permet de calculer les images d'un texte par diverses fonctions de hachage classiques.

a. Déterminez une chaîne de caractères qui commence par café et dont le hachépar SHA-256 commence par l'octet '0'. Même question avec les octets '00'.

b. Calculer les hachés par SHA-256 des encodages de `étaler et étamer. Combiende bits sont diérents dans ces deux hachés ? Combien de bits sont diérentsdans les encodages ASCII des deux chaînes ?

1.3 Quelques compléments

Concluons ce chapitre par quelques compléments : d'autres exemples d'applications de fonc-tions de hachage et un exemple de gloire et déclin d'une fonction de hachage anciennementcryptographique.

1.3.1 Le reader's digest

Supposons que l'on dispose d'une liste A1, A2, . . . d'objets et que l'on souhaite déterminer siun nouvel objet A que l'on nous présente fait déjà partie de la liste. Ce problème, fondamentalen gestion de données, est connu sous le nom de problème du dictionnaire. Dans certains cas,simplement comparer A à chacun des Ai peut s'avérer gourmand en ressources, par exemple sichaque objet est une image de résolution 1 mégapixel en truecolor (soit ' 24 106 bits par Ai).

Supposons que l'on dispose d'une fonction de hachage H résistante aux collisions. On peutalors utiliser cette fonction H comme empreinte de nos objets : on précalcule H(A1), H(A2),

14

https://emn178.github.io/online-tools/

. . . et on les stocke. Ensuite, à chaque objet A présenté, on calcule H(A) et on le compare auxH(A1), H(A2), . . . , ce qui ne demande que de travailler sur des résumés de la taille de H. Pouréviter les faux positifs, il sut, en cas de correspondance entre deux hachés, de vérier que lesimages sont eectivement les mêmes. 88

On retrouve cette idée dans les tables de hachage, mais avec une diérence importante. Unetable de hachage utilise une fonction de hachage de taille ` faible, de façon à pouvoir créer untableau de taille 2` en mémoire. Cette fonction ne peut donc être résistante aux collisions, et lesfaux positifs sont inévitables. (C'est pourquoi une table de hachage ne garantit pas un accès entemps O(1) dans le pire-cas. 99)

1.3.2 L' engagement

Lors d'une enchère secrète (par exemple au premier prix), on doit s'engager sur une décision(par exemple une proposition de prix) tout en la gardant secrète. Dans le monde physique, celapeut se faire par exemple par enveloppes cachetées. Dans le monde numérique, cela peut se faireau moyen d'une fonction de hachage cryptographique H.

De telles enchères sont réalisées en deux phases. Dans la première phase, chaque participantchoisit un ore, disons wi pour le i-ème participant, et annonce H(wi) à tous les participants.Une fois que tous les participants ont annoncé leur H(wi), chacun d'entre eux annonce son wi. Lapremière phase a pour objectif d'engager chaque participant (changer son choix tout en restantcohérent avec la valeur H(wi) annoncée demande de calculer une seconde pré-image) tout engardant son information secrète (pour les autres participants, déduire wi de H(wi) nécessite auminimum de calculer une première pré-image).

Pour mettre en ÷uvre ce principe élégant de manière sûre, il convient d'examiner certainesvulnérabilités indépendantes de la fonction de hachage. Par exemple, si les choix à faire sontdans un espace trop petit (par exemple un prix en euros payable par une municipalité), onpeut deviner wi à partir de H(wi) en calculant simplement H(n) pour tous les nombres n de1 à 109. Bien entendu, cela peut être résolu en demandant à chaque participant d'ajouter à sapropositions un mot binaire arbitraire de taille 1 000 qui sera ignoré au moment du décodage.Mais cela n'est qu'un exemple de vulnérabilité...

1.3.3 L'anti-spam par preuve de travail

Une attaque par déni de service consiste à saturer une machine assurant un service en lesaturant de demandes (inutiles) an de le rendre indisponible aux utilisateurs légitimes. Unemanière de résister à ces attaques consiste à ce que la machine fournissant un service exige,avant de traiter une demande, à ce que le requiérant eectue un travail. Si la diculté du travailest bien dosée, l'eort qu'il demande sera négligeable pour un utilisateur normal et écrasantpour un utilisateur eectuant un nombre pathologique de requêtes.

Une manière pratique de construire des puzzle ne pouvant, en principe, être résolusque par exploration brutale consiste à xer une fonction de hachage cryptographique H, età demander à l'utilisateur de calculer une pré-image d'un haché h donné. Ces puzzles sontcependant bien trop durs. On peut cependant facilement en moduler la diculté en procédant

8. En cas de faux positif avéré, on prévient les autorités que l'on a trouvé une collision pour H an de la dedéchoir de son statut cryptographique .

9. Autrement dit : dites-moi quelle fonction vous utilisez et je me fais fort de trouver une suite d'entréesd'objets qui seront tous rangés dans la même case de votre table...

15

comme suit. On commence par tirer au hasard un w (par exemple 256 bits) et on calcule sonhaché y = H(w). On transmet à l'utilisateur ce y et une partie de w, la taille de la partie étantchoisie pour que le nombre de bits restant à trouver corresponde à la diculté souhaitée.

Une variante de ce principe, que l'on retrouvera dans Bitcoin, consiste à ne pas xer un yprécis, mais à mettre une condition (par exemple voici w, trouvez-moi un w′ tel que H(ww′)commence par 25 zéros).

1.3.4 L'audit

Supposons que l'on ait vérié un ensemble de documents (par exemple la comptabilité d'uneentreprise) et que l'on souhaite la certier. Dans le monde physique, on pourrait signer chaquepage du livre de compte, et compter sur le fait qu'une modication ultérieure serait détectable(rature, usure du papier, etc.). Dans le monde numérique, comment empêcher que quelqu'un nemodie le document que l'on a certié ?

Une idée simple consiste à transformer le document certié en un long mot binaire w, et àpublierH(w) pour une fonction de hachage cryptographiqueH de taille susamment petite pourque ce mot soit vériable à la main. Ainsi, modier la comptabilité tout en restant compatibleavec le haché publié par l'auditeur demande de calculer une seconde pré-image de la fonction dehachage.

1.4 Ci-git SHA-1

La fonction de hachage SHA-1 a été conçue par la NSA et rendue publique en 1995. Sa tailleest de 160 bits, aussi une recherche de collision par recherche exhaustive devrait demander lecalcul de ∼ 280 hachés. Elle a été largement déployée.

En 2005, SHA-1 a été déclarée peu sûre contre des adversaires dotés de gros moyens suiteà la publication d'une attaque améliorée (∼ 269 calculs), puis d'une seconde (∼ 263). En février2017, une collision a été exhibée. En janvier 2020, une paires de clefs PGP/GnuPG distincteset de même haché SHA-1 ont été produites. 1010 Encore récemment, SHA-1 était utilisée pour desraisons de rétro-compatibilité ; en toute logique, cela devrait cesser rapidement.

1.5 Et pour quelques exercices de plus...

Exercice 7 FF Vous participez à un jury en distanciel. Pour assurer que chaquejuré se prononce sans être inuencé par les autres jurés, le président du jury a mis enplace une procédure d'engagement : dans une première phase, chaque juré rédige unephrase d'avis et en transmet le haché à tout le jury. Ensuite, et ensuite seulement, lesjurés lisent leur avis. Cette idée vous semble admirable, mais vous trouvez regrettableque le président ait choisi une fonction de hachage qui ne prend que 1024 valeurs enarguant du fait que cela sura bien ici.

Comment vous y prendriez-vous pour rédiger susamment de phrases non-suspectespour pouvoir trouver une collision ?

10. Cocorico : Gaëtan Leurent, un des deux chercheurs à l'origine de cette découverte, travaille à l'INRIA àParis.

16

Exercice 8 FFF Dans l'algorithme enum de recherche de collision par énumé-ration, tout comme dans l'exercice 3, le facteur limitant s'avère être la mémoire.Pouvez-vous montrer que la variante suivante, bien plus économe en mémoire, nitaussi par trouver une collision ?

def enum_smart(H):

choisir x au hasard et poser y = x

xx, yy = H(x), H(H(y))

if xx == yy:

return x, H(x)

while xx != yy

x, y = xx,yy

xx,yy = H(x), H(H(y))

return x,H(y)

17

Chapitre 2

Étude d'une fonction de hachage &structures de données hachées

Cette seconde séance continue l'étude des fonctions de hachage cryptographiques. On com-mence par introduire la construction de Merkle-Darmgård, sur laquelle sont basées plusieursfonctions de hachage cryptographiques standard. On poursuit par une présentation en détailde la fonction Sha-256, basée sur cette construction. On examine ensuite une faille de sécu-rité auxquelles sont vulnérables certaines utilisations de fonctions de hachages obtenues par laconstruction de Merkle-Darmgård. On conclut par une description des structures de données ha-

chées et de certaines de leurs propriétés ; cette nouvelle application du hachage cryptographiqueforme la base du stockage d'information dans les blockchaines.

2.1 Construction de Merkle-Darmgård

La construction de Merkle-Darmgård dénit une fonction de hachage à partir d'une fonctionopérant sur des mots binaires de longueur xée. Elle a la propriété de transférer la résistanceaux collisions de la seconde vers la première.

2.1.1 Dénition

Fixons deux entiers ` et m, appelés, respectivement, longueur de chaînage et longueur de

bloc. Fixons aussi une fonction f : 0, 1` × 0, 1m → 0, 1`, appelée fonction de compression

puisqu'elle transforme un mot binaire de longueur m+ ` en un mot binaire de longueur `.

La construction de Merkle-Darmgård dénit une fonction de hachage g à partir de f et d'unmot `-bits h_init, appelé vecteur d'initialisation. L'image g(w) d'un mot binaire w ni, mais delongueur arbitraire, est dénie en deux étapes.

La première étape est la complétion ( padding ) du mot w en un mot w dont la taille estmultiple de m. La manière de réaliser cette complétion est laissée libre dans la mesure où ellesatisfait les propriétés suivantes :

(c1) w est un préxe de w (autrement dit : on complète par la n),

(c2) si |w1| = |w2| alors |w1| = |w2|, et(c3) si |w1| 6= |w2| alors les derniers m bits de w1 sont diérents des derniers m bits de w2.

Nous verrons à l'exercice 1 un exemple de fonction de complétion, shapad.

19

Notons w le complété de w et décomposons le en w = w[0]‖w[1]‖ . . . ‖w[n] où chaque w[i]est un mot sur m bits. On itère ensuite f par

h0def

= h_init et pour 0 ≤ i ≤ n, hi+1def

= f(hi, w[i]),

et la valeur hn+1 est ce que l'on dénit comme g(w). En pseudo-code, cela donne :

def g(w):

h = h_init

for i in range(n+1):

h = f(h,w[i])

return h

Le choix de la règle de complétion, du mot initial et de la fonction de compression constituentdes paramètres de la construction MD, que l'on retrouve par exemple dans l'ancienne fonctionSha-1 mais aussi dans l'actuelle fonction de hachage cryptographique Sha-256.

2.1.2 Propriété MD

L'intérêt de la construction MD est la propriété suivante (que l'on prouve à l'exercice 2) :

Théorème 1. Si f est résistante aux collisions, alors g est résistante aux collisions.

Autrement dit, pour construire une fonction de hachage résistant aux collisions sur des motsde taille arbitraire, il sut d'en construire une qui résiste aux collisions sur des mots de taillexée. Inversement, pour mettre à l'épreuve la résistance aux collisions d'une fonction de hachageproduite par la construction MD, on peut se concentrer sur la fonction de compression sous-jacente.

2.1.3 Exercices

Exercice 1 F Fixons m = 512 et ` = 256, et dénissons la fonction de complétionshapad comme suit. Cette fonction prend en entrée un mot binaire w de longueurinférieure 11 à 264. Soit k le plus petit entier solution de |w|+ 1 + k = 448 mod 512.Pour tout entier 0 ≤ x < 264, notons bin64(x) l'encodage binaire de x sur 64 bits.On dénit

shapad(w)def

= w‖10k‖bin64(|w|)où ‖ désigne la concaténation. Remarquons que |shapad(w)| est un multiple de 512.

a. Montrez que shapad satisfait les propriétés (c1), (c2) et (c3).

b. Peut-on déduire le mot w du mot shapad(w) ?

c. Peut-on déduire la longueur |shapad(w)| de la longueur |w| ?

Exercice 2 FF Nous allons maintenant prouver le théorème 11. Considérons unefonction de hachage g obtenue par la construction MD à partir d'une fonction decompression f . Supposons que l'on connaisse w1 6= w2 tels que g(w1) = g(w2).

a. Montrez qu'il est facile de construire une collision pour f si |w1| 6= |w2|.b. Montrez qu'il est facile de construire une collision pour f si |w1| = |w2|.

1. On s'éloigne ici légèrement de la dénition que l'on a donné au chapitre 1, mais la nuance a peu d'importanceen pratique : on se limite aux mots binaires occupant au plus 100 millions de téraoctets.

20

2.2 SHA-256

Sha-256 (aussi appelée SHA2-256) est une fonction de hachage considérée comme cryptogra-phique obtenue par la construction de Merkle-Darmgård. Elle utilise m = 512 comme longueurde bloc et ` = 256 comme longueur de chainage. Elle utilise shapad, vue à l'exercice 1, commefonction de complétion ; en particulier, Sha-256 ne peut s'appliquer qu'à des mots binairesde taille inférieure strictement à 264.

On présente ci-dessous de manière explicite le vecteur d'initialisation et la fonction de com-pression utilisées par Sha-256. C'est une tâche assez laborieuse, sans grand intérêt conceptuel,qu'il s'agit d'aborder comme une opération de démontage d'un moteur en mécanique : mêmequand on connaît les principes de fonctionnement, il est parfois utile pour notre propre édicationd'examiner un exemple réel de près.

2.2.1 Notations et opérations binaires

La fonction Sha-256 opère sur les mots binaires de longueur 256 ou 512 bits au travers devariables contenant chacune un mot binaire 32 bits. Sur ces mots 32 bits, on dénit plusieursopérations. La plus simple est +, qui désigne l'addition modulo 232. Les opérateurs booléensclassiques (et, ou, non, ou exclusif) sont étendus aux mots binaires par les deux conventionssuivantes :

• 0↔ faux et 1↔ vrai, et

• les opérations sont réalisées bit à bit.

On note les opérateurs ainsi obtenus par ∧ (pour et), ∨ (pour ou), ¬ (pour non) et ⊕ (pour ouexclusif). Ainsi,

1001 ∧ 1100 = 1000, 1001 ∨ 1100 = 1101, ¬1001 = 0110, et 1001⊕ 1100 = 0101.

On note aussi Sn l'opération consistant à décaler un mot binaire n fois vers la droite (à chaquedécalage, un 0 est ajouté à gauche pour garder une longueur constante). On note enn Rn

l'opération consistant à décaler un mot binaire circulairement n fois vers la droite. Ainsi,

S2(1001) = 0010 et R2(1001) = 0110.

2.2.2 Constantes

Le vecteur d'initialisation h_init est xé à

h_init = 6a09e667bb67ae853c6ef372a54ff53a510e527f9b05688c1f83d9ab5be0cd19

Par ailleurs, la fonction de compression de Sha-256 utilise 64 constantes 32 bits, notées K0 àK63, xés (dans l'ordre) à

0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,

0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,

0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,

0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,

0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,

0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,

0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,

0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

21

2.2.3 Chargement du chainage et du bloc

Le premier argument de f est un mot de taille ` = 256 bits. Il est chargé dans 8 variables32 bits, notées de a à h, a représentant la partie de poids fort. Ainsi, par exemple, au premierappel de f dans la construction MD, ces variables sont initialisées à :

h_init = 6a09e667︸︷︷︸a

bb67ae85︸︷︷︸b

3c6ef372︸︷︷︸c

a54ff53a︸︷︷︸d

510e527f︸︷︷︸e

9b05688c︸︷︷︸f

1f83d9ab︸︷︷︸g

5be0cd19︸︷︷︸h

.

On crée 8 variables a′ à h′, que l'on initialise par des copies des valeurs ainsi chargées dans a àh. Ces copies nous servirons à la dernière étape du calcul de la fonction de compression (qui vamodier les variables a à h).

Le second argument de f est un mot w′ de taille m = 512 bits. Il est chargé dans 16 variables32 bits W0 à w15, de sorte que

w′ = W0‖W1‖ . . . ‖W15

(‖ étant l'opération de concaténation). Une fois W0 à w15 ainsi initialisés, on dénit 48 autresvariables, nommées W16 à W63, par

Wjdef

= σ1 (Wj−2) +Wj−7 + σ0 (Wj−15) +Wj−16

oùσ0(x)

def

= S7(x)⊕ S18(x)⊕R3(x) et σ1(x)def

= S17(x)⊕ S19(x)⊕R10(x).

2.2.4 La fonction de calcul

Une fois le chainage et le bloc chargés, la fonction de compression itère les opérations suivantespour j allant de 0 à 63 :

• Calculer αdef

= (e∧ f)⊕ (¬e∧ g), βdef

= (a∧ b)⊕ (a∧ c)⊕ (b∧ c), γ def

= S2(a)⊕S13(a)⊕S22(a)

et δdef

= S6(e)⊕ S11(e)⊕ S25(e).

• Calculer T1def

= h+ α+ δ +Kj +Wj et T2def

= β + γ.

• Mettre à jour, dans l'ordre,

h← g, g ← f, f ← e, e← d+ T1, d← c, c← b, b← a, a← T1 + T2.

À l'issu de ces 64 itérations, on retourne le mot 256 bits

(a+ a′)‖(b+ b′)‖(c+ c′)‖(d+ d′)‖(e+ e′)‖(f + f ′)‖(g + g′)‖(h+ h′).

2.2.5 Exercice

Exercice 3 F On suppose que l'on charge les registres a à h par le vecteur d'initia-lisation h_init. Que vaut α

def

= (e ∧ f)⊕ (¬e ∧ g) ? Vous pouvez par exemple utiliserles bitwise operators de python :

https://wiki.python.org/moin/BitwiseOperatorshttps://wiki.python.org/moin/BitwiseOperators

22

https://wiki.python.org/moin/BitwiseOperators

2.2.6 À propos de la cryptanalyse de Sha-256

Une première question est de savoir si Sha-256 satisfait bien aux exigences que le calculde collision, de première préimage et de seconde préimage sont diciles en pratique. Commediscuté au chapitre 1, il n'existe aucune fonction de hachage pour lesquelles on sait prouver

ces propriétés (en ces termes). La conance dans le fait qu'une fonction de hachage résiste en

pratique se base donc sur des éléments indirects :

• Sha-256 est largement utilisée, aussi des ressources importantes (temps de recherche despécialistes, moyens de calcul, etc.) sont consacrées à la recherche d'une collision. Un aperçudes résultats de ces recherches est visible à

https://en.wikipedia.org/wiki/SHA-2#Cryptanalysis_and_validationhttps://en.wikipedia.org/wiki/SHA-2#Cryptanalysis_and_validation

• On peut dénir et tester des critères indicatifs d'une diculté statistique à prédire unefonction de hachage. Notons T l'ensemble des paires de mots (`+m)-bits (w,w′) qui dif-ferent en exactement un bit. On dit que f satisfait le critère d'avalanche strict si pourtout 0 ≤ i < `, lorsque l'on choisit (w,w′) aléatoirement uniformément dans T , la pro-babilité que les ième bits de f(w) et de f(w′) soient égaux est 1

2 . Il s'agit là d'un critèrethéorique que l'on ne sait pas vérier exactement pour Sha-256, mais on peut le testerpar échantillonnage de T ; ces tests sont encourageants.

2.3 Attaque par extension de longueur

Certains systèmes informatiques utilisent des fonctions de hachage cryptographique pourassurer certaines propriétés de la sécurité. L'idée sous-jacente est de conditionner 22 certainespropriétés exprimant la sécurité du système (par exemple le fait que l'on ne puisse pas usurperl'identité d'un utilisateur) aux propriétés de résistance aux collision, à la première préimage ou àla seconde préimage de la fonction de hachage. Il s'avère parfois que la sécurité du système peutêtre compromise sans que l'on n'ait à compromettre la nature cryptographique de la fonction.Un exemple bien connu est la vulnérabilité des utilisations de fonctions de hachages obtenuespar la construction MD aux attaques par extension de longueur.

2.3.1 L'idée

Notons f la fonction de compression de Sha-256. Supposons que l'on connaisse g(w1) etla longueur |w1| pour un mot binaire w1 qui nous est, lui, inconnu. Fixons un mot binaire w2

arbitraire, et posonsw′2

def

= shapad(w1)‖w2.

Remarquons que si l'on savait calculer w′2, on pourrait en déduire w1 (cf exercice 1) et on auraitdonc réussi à calculer une première préimage pour g. L'attaque par extension de longueur permetde calculer facilement g(w′2) sans avoir à calculer w′2.

2.3.2 Le comment

Notons w3def

= shapad(w′2). Comme chaque mot est préxe de son complété (propriété c1),w3 s'écrit

w3 = w′2‖s = shapad(w1)‖w2‖s

2. Un tel conditionnement peut parfois se prouver formellement. C'est un des champs d'application du domainede recherche des méthodes formelles.

23

https://en.wikipedia.org/wiki/SHA-2#Cryptanalysis_and_validation

pour un certain mot binaire s (un suxe). Remarquons que pour calculer s, la fonction shapad

ne requiert que la connaissance de la longueur |w′2| = |shapad(w1)| + |w2|. On connaît |w2|puisqu'on a choisi ce mot, et on peut facilement déduire la longueur |shapad(w1)| de la longueur|w1| (cf exercice 1). On peut donc facilement calculer s.

Notons maintenant w3 = w[0]‖w[1]‖ . . . ‖w[n] une décomposition de w3 en blocs de lon-gueur 512. Comme shapad(w1) est un préxe de m3 et est de longueur un multiple de 512, ilexiste un indice 0 ≤ t ≤ n tels que shapad(w1) = w[0]‖w[1]‖ . . . ‖w[t]. On ne connaît pas cesblocs, mais on peut en revanche facilement calculer les suivants :

w[t+ 1]‖w[t+ 2]‖ . . . ‖w[n] = w2‖s.

Rappelons que la construction MD dénit g(w′2) comme le terme hn+1 de la suite

h0def

= h_init et pour 0 ≤ i ≤ n, hi+1def

= f(hi, w[i]),

On connaît h0 mais pas w[0], aussi on ne sait pas calculer h1, h2, etc. En revanche, remarquonsque ht+1 n'est autre que g(w1). On peut donc commencer à calculer les termes de cette suite en chemin et atteindre ainsi hn+1 = g(w′2) :

def ext():

h = g(w1)

for i= t+1 to n

h = f(h,w[i])

return h

2.3.3 Le pourquoi : protocole MAC

Les Message Authentication Codes (MAC) sont des systèmes visant à permettre à deuxinterlocuteurs échangeant des messages sur un canal ouvert de vérier que le message qu'ilsreçoivent a bien été envoyé par l'autre interlocuteur, et non pas dû à une interférence d'unetroisième personne (présumée mal-intentionnée). L'enjeu ici n'est pas d'empêcher quelqu'und'avoir connaissance du message transmis, mais bien de certier que le message reçu a bien étéémis tel quel par l'autre interlocuteur.

Un système MAC simple consiste à ce que les interlocuteurs se mettent d'accord sur unefonction de hachage cryptographique h (par exemple Sha-256) et un secret commun. Ce secretcommun est un mot binaire s qu'ils connaissent tous les deux et ne divulguent à personned'autre. Lorsque l'un des interlocuteurs souhaite envoyer un mot binaire w à l'autre, il lui ajouteune signature qui est facile à calculer quand on connaît s, mais dicile sinon ; par exemple, iltransmet (w, h(w‖s)). À la réception d'une paire (w′, t), l'interlocuteur calcule h(w′‖s) et acceptew′ comme authentique si et seulement si t = h(s‖w′).

Ce système a été utilisé, par exemple, dans les API web de services comme Flikr. Sansentrer dans les détails, un utilisateur souhaitant faire certaines opérations sur son album photodéclenchait un échange de message authentiés ainsi entre son navigateur et un serveur Flikr.Outre l'authentication, ces messages contenait des commandes à exécuter et leurs arguments.

Ce système de MAC par hachage d'un secret partagé permet beaucoup de souplesse. Onpeut, par exemple, convenir que l'on hachera non pas w‖s mais s‖w. Ces choix semblent équi-valent, mais ce simple détail entrouvre une faille de sécurité lorsque la fonction de hachage

24

utilisée est basée sur la construction de MD (et, pour simplier ici, shapad). En eet, remar-quons que l'on dispose du mot w et du haché h(s‖w). Si l'on connaît la longueur de s (et peude tentatives devraient sure), on peut en déduire la longueur |s‖w| et ainsi calculer, par ex-tension de longueur, le haché h(shapad(s‖w)‖w′) pour n'importe quel mot w′. Remarquons queshapad(s‖w) = s‖w‖u pour un certain mot binaire u, que l'on peut calculer à partir de |s‖w|.

Comment serait interprété un message (w‖u‖w′, h(shapad(s‖w)‖w′) ? D'une part, il seraitreconnu comme authentique et donc ne serait pas rejetté. D'autre part, la commande w‖u‖w′a de grandes chances de contenir des arguments aberrants de par la présence du terme u, noncontrôlé ; certains analyseurs syntaxiques traitent de telles valeurs aberrantes en les ignorantelles seules, et en exécutant le reste de la commande. Dans une telle situation, les argumentspassés par le mot w′ que l'on a choisi sont de facto pris en compte.

Cela peut sembler beaucoup de conditions... mais il s'est trouvé un certain nombre de servicesweb pour y être vulnérables, dont Flikr. Vous trouverez plus de détails sur les failles de sécuritésouvertes par cette attaque par extension de longueur par exemple dans la notication devulnérabilité :

http://netifera.com/research/flickr_api_signature_forgery.pdfhttp://netifera.com/research/flickr_api_signature_forgery.pdf

2.4 Structures de données à pointeurs hachés

Nous allons maintenant examiner des structures de données informatiques qui utilisent desfonctions de hachage cryptographiques pour assurer des propriété de traçabilité et d'auditabilité.

2.4.1 Pointeur haché

Pour rééchir à la manière de manipuler des données sur ordinateur, il est pratique des'abstraire de leur représentation explicite. On continue donc à travailler avec des mots binaires

arbitraires. En pratique, un tel mot binaire est stocké em mémoire sous la forme d'une suited'octets, que l'on appelle bloc de données. Si la longueur du bloc n'est pas un multiple de 8, onconsidère que le dernier octet est complété par une convention quelconque. Un pointeur sur unbloc de données est un entier qui vaut l'adresse en mémoire de son premier octet.

It was the best of times,it was the worst of times,it was the age of wisdom,it was the age of foolish-ness, it was the epoch ofbelief, it was the epoch ofincredulity, it was the sea-son of Light, it was theseason of Darkness, ...

pointeur

pointeur hache

H()

Il est assez naturel de représenter un bloc de données par un simple pointeur, puisque celasut pour y accéder. On peut aussi représenter un bloc de données par un pointeur haché :on xe une fonction de hachage H et on représente le bloc b par la paire (H(b), p), où p est unpointeur sur b. On dit qu'un pointeur haché (H(b), p) est valide si le bloc pointé par p a bienpour haché H(b).

Un pointeur permet de localiser un bloc de données en mémoire. On peut voir un pointeurhaché comme un pointeur assorti d'un checksum, une somme de contrôle permettant de détecter

25

http://netifera.com/research/flickr_api_signature_forgery.pdf

les modications grossières telles que les pertes de données. Lorsqu'un pointeur haché est basésur une fonction de hachage cryptographique, ce détecteur devient dicile à tromper : commepour l'exemple jouet de l'audit vu au chapitre 1, il est dicile de modier un bloc de donnéessans invalider un pointeur haché cryptographiquement sur ce bloc. Nous allons voir commentles structures de données classiques basées sur les pointeurs peuvent être revisitées à l'aune despointeurs hachés.

2.4.2 Liste chaînée hachée (= blockchain)

Une liste chainée est une suite ordonnée de blocs de données. Une liste chaînée est repré-sentée par un pointeur sur son premier bloc, que l'on appele ici pointeur global. Chaque bloccontient en outre un pointeur sur son successeur dans l'ordre. Par exemple :


I heartily accept themotto, That governmentis best which governsleast; and I should like tosee it acted up to morerapidly and systemat-ically. Carried out, itfinally amounts to this,which also I believe ...

To Sherlock Holmes she isalways the woman. I haveseldom heard him men-tion her under any othername. In his eyes sheeclipses and predominatesthe whole of her sex. Itwas not that he felt anyemotion akin to love for ...

0

L'ordre des blocs dans la liste chaînée est donc indépendante de leur placement en mémoire.Une liste chaînée permet les opérations suivantes :

• L'accès au nième élément se fait en temps O(n), en parcourant la liste depuis le début.

• L'ajout ou la suppression d'un bloc, une fois connu le bloc précédent, se fait en temps O(1)puisqu'il sut de modier un ou deux pointeurs.

Une liste chaînée hachée remplace les pointeurs par des pointeurs hachés. Pour expliquer cela,considérons la liste chaînée suivante :




H() H() H() 00

D'une part, le pointeur global est un pointeur haché sur le premier bloc. D'autre part, pourtout n, le nième bloc contient un pointeur haché sur le (n + 1)ième bloc. La seule exceptionest le dernier bloc, dont le pointeur haché est nul. Une liste chaînée hachée est valide si chaquepointeur haché est valide.

Proposition 2. Soit H une fonction de hachage. Soient L et L′ deux instances d'un même type

de liste chaînée hachée basée sur H. Si L et L′ sont de même pointeur global et que L 6= L′,alors il est facile de calculer une collision pour H.

Démonstration. Notons bi et b′i respectivement les ième blocs de L et L′. Soit j∗ le plus petitindice j tel que bj 6= b′j . Un tel indice existe car L 6= L′. Remarquons que H(b1) = H(b′1) puisquece sont les pointeurs globaux de L et L′, supposés égaux. De plus, comme H(bi+1) apparaît dansbi au même endroit que H(b′i+1) dans b

′i, on a

bi = b′i ⇒ H(bi+1) = H(b′i+1).

26

Par récurrence, on a donc H(bi+1) = H(b′i+1) pour tout i < j∗. En particulier, H(bj∗) = H(b′j∗).Comme bj∗ 6= b′j∗ , on tient là notre collision.

2.4.3 Arbre de Merkle

On peut adapter d'autres structures de données au moyen de pointeurs hachés. La structureobtenue pour les arbres binaires, plus précisément les arbres dans lesquels tout n÷ud a 0 ou 2descendants, s'appelle arbre de Merkle.

Dans un arbre de Merkle, les feuilles sont les blocs de données que l'on souhaite stocker etchaque n÷ud interne est une paire de pointeurs hachés sur les deux descendants de ce n÷ud.Ces descendants (et leurs pointeurs hachés) sont ordonnés.




Morning-room in Alger-non’s flat in Half-MoonStreet. The room is lux-uriously and artisticallyfurnished. The sound of apiano is heard in the ad-joining room.[Lane is arranging after-noon tea on the table, ...

Buck did not read thenewspapers, or he wouldhave known that troublewas brewing, not alonefor himself, but for ev-ery tide-water dog, strongof muscle and with warm,long hair, from PugetSound to San Diego...

I went down yesterday tothe Piraeus with Glauconthe son of Ariston, that Imight offer up my prayersto the goddess (Bendis,the Thracian Artemis.);and also because I wantedto see in what mannerthey would celebrate...

H() H()H() H()

H() H() H() H()

H() H() H() H()

Le pointeur global d'un arbre de Merkle est la paire de pointeurs hachés de sa racine. On établirace qui suit en exercice :

Proposition 3. Soit H une fonction de hachage. Soient A et A′ deux instances d'un même type

d'arbre de Merkle haché basée sur H. Si A et A′ sont de même pointeur global et que A 6= A′,alors il est facile de calculer une collision pour H.

2.4.4 Exercices

Exercice 4 FF Donnez une preuve formelle rigoureuse de la Proposition 33 sur lemodèle de la preuve de la Proposition 22.

Exercice 5FF On souhaite vérier l'intégrité d'un bloc de donnée stockée dans unestructure à pointeurs hachés S. On n'a pas conance dans l'intégrité de la structuremais on est sûr du pointeur global, dont on avait gardé une copie en sécurité.

a. Comment fait-on la vérication dans le cas où S est une liste chaînée hachée ?

b. Comment fait-on la vérication dans le cas où S est un arbre de Merkle ?

c. On suppose que les structures sont optimisée : la liste ne contient pas de maillonvide et l'arbre de Merkle est complet. Quelle quantité de calcul faut-il faireau maximum (pire cas) si S contient n blocs de données ?

27

Exercice 6 FFF À l'exercice précédent, on a vu qu'on peut vérier par le calculd'un petit nombre de hachés qu'un bloc de donnée est un bloc d'un arbre de Merklevalide dont on connaît le pointeur global. Pour un arbre de Merkle complet équilibré,notons vn le nombre maximum de hachés susants.

Proposez une variante des arbres de Merkle qui permette de vérier par le calculde O(vn) hachés qu'un bloc de données n'appartient pas à un arbre de Merklevalide dont on connaît le pointeur global.

28

Chapitre 3

Signature digitale, principe de monnaiedigitale

Cette troisième séance introduit un second outil cryptographique : la signature digitale. Nousen expliquons les principes, en décrivons un exemple et présentons quelques applications.

3.1 Notion de signature

Dans l'usage courant, une signature est une marque apposée par une personne (le signa-

taire) sur un document. Une signature sert à engager : elle établit que le signataire approuve ledocument. Pour cela, une signature doit, idéalement, satisfaire les principes suivants :

• Vériabilité : tout le monde peut facilement vérier que la signature correspond au signa-taire,

• Inforgeabilité : seul le signataire peut apposer sa signature sur un document donné.

Notons, en particulier, qu'une fois une signature apposée sur un document, elle ne peut pas êtrecopiée et collée sur un autre document (une signature est spécique au document qu'elle signe).

Les sceaux, tampons et signatures manuscrites ont pour objectif de réaliser cela. Nous allonsajouter à ces méthodes un autre type de signature, digitale cette fois, qui permet de signer desmots binaires (et donc des textes, des images, des bases de données, . . . ). Les propriétés de cettesignature (vériabilité et inforgeabilité) seront assurées par des primitives cryptographiques.

3.2 Un premier système de signature numérique

Plusieurs systèmes de signature numérique sont actuellement utilisés. S'ils varient sur uncertain nombre d'aspects techniques (importants !), les principes de ces systèmes sont assezsimilaires. Nous examinons tout d'abord le protocole de signature de Schnorr et esquisseronsensuite deux de ses variantes (DSA et ECDSA).

3.2.1 Principe

Les trois systèmes que l'on va examiner reposent sur l'utilisation d'une clef, c'est à direune paire (cp,cs) formée de deux mots binaires. La clef publique cp est librement diusée etpermet à ceux qui la connaissent de vérier une signature. La clef secrète cs permet à toutepersonne la connaissant de signer un mot binaire ; sa connaissance doit donc être limitée auxseules personnes supposées disposer de la signature (généralement, un seul individu).

29

Le système de signature xe généralement les tailles de cp et cs à des constantes. Le systèmedénit aussi quels sont les paires de mots binaires qui forment un clef ; deux mots mots cp et csqui forment une clef sont dites compatibles. Le système de signature est généralement constituéde trois fonctions :

• genere_clef ne prend pas d'argument et retourne une clef (cp,cs). La clef retournéeest choisie par la fonction de manière pseudo-aléatoire dans l'ensemble des paires de motscompatibles.

• signe prend en arguments un message (sous la forme d'un mot binaire) et une clef secrète,et retourne un mot binaire que l'on appelle la signature du message par la clef.

• verifie prend en arguments un message, une signature et une clexf publique, et décidesi la clef publique donnée est compatible avec la clef secrète ayant produit la signature àpartir du message.

Une large diusion de la clef publique garantit la vériabilité du système. En revanche, soninforgeabilité repose sur le fait qu'il est dicile, étant donné une clef publique, de déterminer la(ou une) clef privée compatible.

3.2.2 Logarithme discret

Les systèmes de signature que l'on va voir mettent en jeu quelques notions d'arithmétiqueélémentaire. On renvoit à l'annexe BB pour quelques rappels de base (supposés ici connus).

Fixons un groupe multiplicatif ni (G, ·) d'élément neutre 1. Pour tout g ∈ G \ 1 et n ∈ Z,on note

gn = g · g · . . . · g︸︷︷︸n fois

avec la convention que g0 = 1. Si y = gx, on dit que y est l'exponentielle de x (de base g, dansG) et x est un logarithme discret de y (de base g, dans G).

Par exemple, dans Gdef

= Z/7Z on a 25 = 4. Ainsi, 4 est l'exponentielle de 5 (et 5 un logarithmede 4) de base 2 dans Z/7Z.

3.2.3 Signature de Schnorr

Le système de signature de Schnorr xe quatre paramètres (q,H,G, g) connus de tous lesutilisateurs : un entier q premier, une fonction de hachage H à valeurs dans Z/qZ, un groupe Gd'ordre q, et un élément g ∈ G qui engendre G. Le groupe G est choisi de sorte qu'il soit faciled'y calculer l'exponentielle mais dicile d'y calculer le logarithme.

La fonction genere_clef choisit un entier x aléatoire uniformément dans 1, 2, . . . , q− 1 etcalcule y

def

= gx dans G. La paire (y, x) est la clef, x étant secret et y étant public. Comme x estun logarithme discret de y, calculer la clef secrète à partir de la clef publique exige de résoudreune instance d'un problème considéré comme dicile.

Pour signer un mot binaire m par x, on commence par choisir un entier k aléatoire unifor-mément dans 1, 2, . . . , q − 1. On calcule ensuite r

def

= gk, edef

= H(bin(r)‖m) et sdef

= k − xe. Lasignature est la paire (s, e).

Pour vérier que (s, e) est une signature valide d'un mot binaire m par une clef de partiepublique y, on calcule rv

def

= gsye puis evdef

= H(bin(rv)‖m). On accepte la signature comme validesi et seulement si ev = e.

30

3.2.4 Exercices

Exercice 1 FF Justiez que dans le protocole de Schnorr, une signature valideest toujours acceptée.

Exercice 2 FF Supposons que l'on dispose de m, y, s et e, où m est un motbinaire, y une clef publique et (s, e) la signature de m par une clef de clef publiquey selon le protocole de Schnorr.

a. Supposons aussi que m′ 6= m soit un mot binaire tel que (s, e) est aussi acceptécomme signature de m′ par une clef de clef publique y. Peut-on construire unecollision pour H ?

b. Supposons que l'on arrive à déterminer l'entier k aléatoire utilisé pour signerm. Que peut-on en déduire ?

Exercice 3 F Cet exercice fait manipuler le système de signature DSA que nousn'introduirons qu'en section 3.53.5 ; pour cet exercice, il sut de savoir qu'il fonctionne,comme le protocole de Schnorr, sur les principes décrits section 3.2.13.2.1.

Sur la page arche du cours, vous trouverez une archive signature.zip contenantles chiers 1.pdf, 2.pdf, cp.txt et signature.sig. On va examiner ces chiers aumoyen du bac à sable disponible à

https://8gwifi.org/dsafunctions.jsphttps://8gwifi.org/dsafunctions.jsp

a. Le chier cp.txt contient une clef publique produite par ce site. Déterminer sataille (512, 1024 ou 2048 bits).

b. L'un (et un seul) des chiers 1.pdf, 2.pdf a été signé par une clef dont cp.txtest la clef publique. Vériez cela.

c. Faites générer une clef 1024 bits et copiez-la. Utilisez cette clef pour signer unchier (pas trop gros) de votre choix. Transmettez le chier signé, la signatureet la clef publique à un.e de vos camarades pour vérication. Attention à ne pasdivulguer votre clef privée.

3.3 De la signature à l'identité digitale

Un protocole de signature numérique peut servir de système décentralisé d'identiants nu-

mériques sécurisés.

Dès lors que les paramètres du système 11 ont été xés, n'importe qui peut créer une clef(x, y). La clef publique, y, peut servir d'identité publique et la clef secrète, x, permet d'empêcherl'usurpation d'identité. Dans le détail, lorsque y diuse un contenu numérique (déclaration, uxvidéo, chier de données, . . . ) il peut l'authentier au moyen d'une signature. Toute personnerecevant le contenu numérique peut vérier la signature, et ainsi que cela provient bien dequelqu'un connaissant x, c'est-à-dire y.

Ce système est décentralisé car il n'y a pas besoin de stocker en un quelconque endroit laliste des identiants existants. Chaque utilisateur crée, puis stocke et gère ses identiants entoute autonomie.

1. Dans le cas du système de Schnorr, ce sont les quatre paramètres (q,H,G, g).

31

https://8gwifi.org/dsafunctions.jsp

3.4 Application : une ébauche de cryptomonnaie

Il est assez facile de construire une monnaie dématérialisée une fois que l'on dispose d'unsystème d'identiants numériques sécurisés. Cette monnaie dématérialisée est insatisfaisanteà bien des égards mais va nous permettre d'introduire certaines des idées utiles à l'applicationBitcoin, que l'on détaillera au chapitre suivant.

3.4.1 Une première tentative ratée

Alice, sous son identiant yA, lance une nouvelle monnaie dématérialisée selon les principessuivants. Chaque élément monétaire, appelons le billet, est modélisé par une liste chaînée hachée.Chaque bloc de cette liste chaînée hachée enregistre une opération eectuée sur le billet. Onautorise deux opérations :

• création, opération initiale qui donne naissance au billet. Un bloc création contient deuxsous-parties. La partie (I) comporte l'identiant du billet (un numéro), son montant (tousles billets ne se valent pas nécessairement), et l'identiant du propriétaire. La partie (II)comporte la signature de (I) par (yA, xA).

• transfert, opération qui change le propriétaire du billet. Un bloc transfert contient deuxsous-parties. La partie (I) comporte l'identiant du nouveau propriétaire et un pointeurhaché sur le bloc de l'opération précédente sur ce billet. La partie (II) comporte la signaturede (I) par l'ancien propriétaire.

Dans ce système, chaque propriétaire est identié par une clef publique et cette clef lui permetd'authentier ses décisions. N'importe qui peut facilement vérier, étant donné un billet, que lessignatures et les pointeurs hachés sont valides dans toute la liste chaînée hachée.

L'opération de transfert a pour but de permettre de dépenser un billet (en échange debiens ou services). La première diculté posée par la création d'une monnaie dématérialiséeconsiste à empêcher la double dépense : il est impératif qu'une fois que le propriétaire d'unbillet l'a transféré à un nouveau propriétaire, il ne puisse pas à nouveau le tranférer à un autrepropriétaire.

Notre système sommaire ci-dessus ne résout aucunement le problème de double dépense :rien n'empêche le propriétaire d'un billet de faire 2 copies du mot binaire stockant la liste chaînéehachée d'un billet, puis d'étendre ces deux copies par deux blocs transfert diérents, de manièreà le donner deux fois.

3.4.2 Une seconde tentative (avec registre)

On peut empêcher la double dépense en opérant deux changements.

D'une part, on garde l'opération de création mais on remplace l'opération de transfert par :

• dépense/re-création. Cette opération consomme des billets et en crée de nouveaux. Untel bloc contient deux sous-parties. La partie (I) comporte les identiants d'un ou plusieursbillets à consommer, ainsi que les identiants et valeurs d'un ou plusieurs billets à créeret, pour chacun, l'identiant de leur propriétaire. La partie (II) comporte la signature de(I) par chaque propriétaire d'un billet consommé.

La valeur d'un billet est inchangeable et un billet ne peut se dépenser que totalement. Rienn'empêche, cependant, que parmi les nouveaux billets il en soit un attribué à l'ancien propriétaire(pour rendre la monnaie).

32

D'autre part, on établit un registre public des transactions passées. Formellement, ce registreest une liste chaînée hachée dont les blocs contiennent les transactions décrites ci-dessus (créationet transfert). Le pointeur chaîné sur le dernier bloc en cours est fourni par Alice, qui le certieen le signant par (yA, xA). Les nouveaux blocs sont ajoutés par Alice, qui vérie leur correction :

• le total des montants des billets détruits doit est supérieur ou égal au total des billetscréés,

• chacun des billets détruits doit avoir été créé et jamais détruit,

• chacun des propriétaires d'un billet détruit doit avoir signé le bloc.

Le système monétaire d'Alice est a priori ecace mais plutôt dictatorial : Alice controle lacréation de monnaie, garantit la bonne tenue des comptes, valide les nouvelles transactions...Remarquons qu'il s'agit là d'un problème plus large que la conception d'une cryptomonnaie :comment peut-on tenir un registre public de manière à s'accorder sur son contenu, à le rendrerésistant à la falsication, le tout sans disposer d'une autorité mettant tout le monde d'accord...

3.5 Signatures DSA et ECDSA

Le protocole de signature de Schnorr étant breveté, d'autres systèmes de signature similairesont été développés dans le but d'orir des alternatives librement utilisables. Ces variantes sontun peu plus compliqués que le système de Schnorr, mais ont néanmoins été plus largementdéployés. 22 On présente ici rapidement deux de ces variantes : DSA et ECDSA.

3.5.1 Le système DSA

Un premier paramètre du système DSA est la taille de clef, que l'on note ici `. Un choixcourant est ` = 2048 mais pour des clefs dont on souhaite qu'elles restent sûres au-delà de 2030,le NIST recommande de prendre ` = 3072.

Le système de signature DSA xe quatre paramètres (p, q,H, g) connus de tous les utilisa-teurs. Il y a tout d'abord deux entiers premiers p et q tels que p est sur ` bits, q est sur 256 bitset q divise p− 1. Ensuite vient une fonction de hachage H de taille 256 bits (typiquement Sha-256). Enn, g est un générateur du groupe multiplicatif (Z/pZ)∗ dans lequel on travaille, calculécomme suit : on choisit un entier aléatoire h uniformément au hasard dans 2, 3, . . . , p−2, et oncalcule g

def

= hp−1q mod p ; dans l'éventualité (peu probable, mais possible) où g = 1, on répète

l'opération.

La fonction genere_clef choisit un entier x aléatoire uniformément dans 1, 2, . . . , q− 1 etcalcule y

def

= gx mod p. La paire (y, x) est la clef, x étant secret et y étant public. Comme x estle logarithme discret de y, calculer la clef secrète à partir de la clef publique exige de résoudreune instance d'un problème considéré comme dicile.

Pour signer un mot binaire m par x, on commence par choisir un entier k aléatoire unifor-mément dans 1, 2, . . . , q − 1 et on calcule deux nombres :

rdef

= (gk mod p) mod q et sdef

=(k−1 (H(m) + xr)

)mod q.

La signature de m par x est la paire (r, s).

2. Le brevet aux USA sur le protocole de Schnorr n'a expiré qu'en 2008.

33

Pour vérier que (r, s) est une signature valide d'un mot binaire m par une clef de partiepublique y dans un système de paramètres (p, q, g), on procède aux vérications suivantes :

• on doit avoir 0 < r < q et 0 < s < q,

• on calcule

u0def

= s−1 mod q, u1def

= H(m) · u0 mod q, u2def

= r · w mod q.

• on calcule vdef

= (gu1 · yu2) mod q et on accepte la signature si v = r.

3.5.2 Groupe associé à une courbe elliptique et ECDSA

Une courbe algébrique est un ensemble de points déni comme le lieu d'annulation d'unpolynôme. Le cercle d'équation X2 +Y 2 = 2 dans le plan ane R2 est un exemple familier, maisce polynôme dénit aussi une courbe algébrique sur d'autre corps. Ainsi,

(1, 1), (1, 2), (2, 1), (2, 2)

est l'ensemble des points de Z/3Z × Z/3Z qui annulent ce polynôme ; c'est aussi une courbealgébrique. Plus généralement, on peut s'intéresser au lieu d'annulation d'un polynôme k-variésur Fk, où F est un corps ni.

Le système de signature utilisé par Bitcoin repose sur une courbe précise. Notons p =2256−232−29−28−27−26−24−1. Il s'avère que p est premier, aussi Fp

def

= Z/pZ est un corps.L'ensemble des points de Fp × Fp satisfaisant

Y 2 = X3 + 7 (3.1)

est une courbe appelée secp256k1. Comme (presque) toute équation de la forme Y 2 = X3+aX+b où a et b sont des constantes, c'est une courbe elliptique. Cette courbe est, comme l'exemplereprésenté en gure 3.13.1, un ensemble ni de points.

Figure 3.1 Exemple de courbe elliptique : Y 2 = X3 − X, sur le corps Z/89Z. (Source :Wikipédia.)

On dénit une droite sur F × F, où F est un corps ni, comme le lieu d'annulation d'unpolynôme multivarié de degré 1. Les axiomes d'Euclide gouvernent cette géométrie comme lemonde ane ; en particulier, par deux points d'un corps ni passent une et une seule droite, etdeux droites non parallèles se coupent en un et un seul point. Les courbes elliptiques (sur descorps nis) ont deux propriété remarquables :

34

a. une droite qui contient au moins deux points de la courbe en contient exactement trois, et

b. la courbe admet une symmétrie par rapport à l'axe des X.

On peut se servir de ces propriétés pour dénir une loi de groupe sur la courbe : étant donnédeux points P et Q de la courbe, on dénit P Q comme le symmétrique du troisième point dela courbe sur la droite PQ.

L'algorithme ECDSA réalise une signature cryptographique similaire à DSA, mais elle s'ap-puie pour cela sur l'opération de logarithme discret dans le groupe déni par une courbe ellip-tique. Faute de temps, on ne détaille pas cet algorithme ici et on renvoit à :

https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithmhttps://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm

3.6 Preuve à divulgation nulle de connaissance

Le protocole de signature de Schnorr peut s'envisager comme une preuve à divulgation nulle

de connaissance : la signature d'un document par une clef compatible avec y établit que l'onconnaît le logarithme de y (dans le groupe considéré) sans donner d'autre information sur celogarithme. Cette idée trouve d'autres applications dans les systèmes à base de blockchaines,aussi on la présente rapidement.

Commençons par un premier exemple éclairant. Il est possible de prouver à quelqu'un quel'on sait résoudre un sudoku sans lui donner aucun indice sur comment le résoudre. Cet énoncé, apriori surprenant, cache une très jolie idée : on peut créer de la conance entre des inconnus surla seule base de la conance que chacun d'entre eux a dans les lois du hasard. Une démonstrationfort bien illustrée sur le jeu de sudoku est disponible ici :

http://www.wisdom.weizmann.ac.il/~naor/PAPERS/SUDOKU_DEMO/http://www.wisdom.weizmann.ac.il/~naor/PAPERS/SUDOKU_DEMO/

La preuve de résolution de sudoku présentée ci-dessus est un exemple de preuve à divulgation

nulle de connaissances (zero knowledge proof ). On esquisse en annexe CC de quelle manière cespreuves se formalisent en théorie de la complexité.

3.7 Exercices supplémentaires

Les exercices suivants peuvent être abordés dans un ordre quelconque.

Exercice 4 F (Examen d'un document technique) L'agence nationale (Fran-çaise) de la sécurité des systèmes d'informations (ANSSI) fait des préconisations enmatière de cryptographie dans son rapport RGS B1 :

https://www.ssi.gouv.fr/uploads/2014/11/RGS_v-2-0_B1.pdfhttps://www.ssi.gouv.fr/uploads/2014/11/RGS_v-2-0_B1.pdf

a. Lequel des trois systèmes de signature digitale que l'on a présenté (Schnorr,DSA et ECDSA) approuvé par l'ANSSI ?

b. Quelle est la condition de cette approbation ?

35

https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm

http://www.wisdom.weizmann.ac.il/~naor/PAPERS/SUDOKU_DEMO/

https://www.ssi.gouv.fr/uploads/2014/11/RGS_v-2-0_B1.pdf

Exercice 5 FF (Logarithme discret) Soit G un groupe multiplicatif ni, g ungénérateur de G et ` l'ordre de g, c'est à dire le plus petit entier tel que g` = 1.Montrer que pour tout y ∈ G il existe un entier k tel que

n est un logarithme de y de base g ⇔ n = k mod `.

Exercice 6 FFF (Preuve ZK)) Comment pourrait-on procéder pour prouver,sans divulgation de connaissance, que l'on sait 3-colorier un graphe donné ? Donnezl'idée du protocole et esquissez le calcul de la probabilité qu'un menteur soit indétecté(en fonction des nombres n de sommets et e d'arêtes du graphe considéré.)

36

Chapitre 4

Un exemple concret de blockchain :Bitcoin

Cette séance met en application les concepts de cryptographie étudiés jusqu'ici pour décrirela blockchain du système Bitcoin. Cette séance a trois objectifs :

a. présenter l'application (monnaie, cryptomonnaie basée sur une blockchaine),

b. présenter des aspects techniques spéciques à Bitcoin,

c. discuter l'impact environnemental et sociétal de ce système.

Cette étude de cas nous permettra en outre de mettre en lumière deux questions fondamentalesen calcul distribué (l'élection et le consensus), objet des trois derniers chapitres.

4.1 Problématique : que veut dire créer une monnaie ?

Commençons par préciser les problèmes qu'il s'agit de résoudre lorsque l'on crée une monnaie.On en prote, au passage, pour clarier la terminologie.

4.1.1 Lexique monétaire

Une monnaie est un système qui remplit trois fonctions. C'est une unité de compte pourla richesse, c'est à dire que c'est une unité permettant de mesurer toute richesse. C'est unintermédiaire des échanges, c'est à dire que tout ce qui s'achete ou se vend peut l'être contreune quantité de monnaie. C'est une réserve de valeur, c'est à dire que c'est une richesse en soi.

Un instrument monétaire est le support d'une unité de monnaie. Un instrument monétairesert d'intermédiaire d'échange. Pièces et billets sont des instruments monétaires. Chèques, re-connaissances de dettes, bons de réduction, actions d'entreprise, . . .n'en sont pas. Ce sont desmarchandises portant sur de l'argent, mais n'ayant pas fonction d'argent.

Une transaction est un acte transférant la propriété d'un instrument monétaire d'une per-sonne à une autre. On dit que cet instrument a été dépensé par son ancien propriétaire.

La valeur nominale d'un instrument monétaire est la quantité de monnaie qu'il représente.Sa valeur intrinsèque est la quantité de monnaie équivalent à sa fabrication. Si ces deux quantitéscoincident, on parle de monnaie de commodité, sinon on parle de monnaie duciaire.

La création monétaire est l'acte de créer des instruments monétaires. Dans le cas d'unemonnaie de commodité, la création de nouveaux instruments monétaires est limitée par la dis-ponibilité de l'objet physique la réalisant : pour faire des Louis d'or, il faut de l'or.

37

Une monnaie est dite numérique (ou digitale) si ses instruments monétaires sont dématériali-sés informatiquement. Les dépots bancaires et comptes courants dans les banques commercialessont considérées comme une monnaie, dite scripturale, et elle est aujourd'hui numérique.

4.1.2 Création, appropriation et double dépense

Toute monnaie doit résoudre les problèmes suivants :

• L'appropriation. Comment établir la possession d'un instrument monétaire ? Lorsqu'uninstrument monétaire est un objet physique, la possession de l'objet physique vaut pos-session de l'unité de monnaie correspondante. Lorsqu'un instrument monétaire est déma-térialisé, et donc très facilement reproductible, cette question est moins triviale.

• La double dépense. Comment assurer que quelqu'un perde la possession d'un instrumentmonétaire qu'il a dépensé ? Autrement dit, comment empêcher que quelqu'un ne dépensedeux fois un même instrument ? Lorsqu'un instrument monétaire est un objet physique, onéchange de la monnaie en échangeant les objets et ce problème est trivial. Pour la monnaiescripturale, cela est réglé par la tenue, par la banque, d'un registre.

• La création monétaire. Quels mécanismes permettent et limitent la création de nou-veaux instruments monétaires ? Dans le cas des instruments monétaires physiques d'unemonnaie comme l'Euro, cela est réalisé par une combinaison de diculté techniques (li-grane, encres visibles aux infrarouges ou ultraviolets, hologrammes, etc.) et de dissuasion 11.

Une cryptomonnaie est une monnaie numérique pour laquelle la résolution de ces problèmesrepose sur des méthodes cryptographiques décentralisées. Elles sont nombreuses :

https://en.wikipedia.org/wiki/List_of_cryptocurrencieshttps://en.wikipedia.org/wiki/List_of_cryptocurrencies

4.2 Principes de Bitcoin (et de nombreuses cryptomonnaies)

Examinons de quelle manière le système Bitcoin résout les problèmes listés ci-dessus. Ondétaille à chaque fois un principe général, retrouvé dans d'autres cryptomonnaies, et, en encadré,des détails spéciques au système Bitcoin.

4.2.1 Comptes et transactions

Chaque instrument monétaire est la propriété d'un compte. Concrètement, un compte est uneclef de signature cryptographique (cp,cs) du type de DSA vu en séance 3. La partie publique,cp, sert d'identiant publique au compte. La partie privée sert à signer les ordres de dépensedes instruments nanciers possédés par le compte.

Le système Bitcoin utilise une signature ECDSA de courbe elliptiquesecp256k1. Un compte est généralement identié non pas par sa clef publique,mais par le haché Sha-256 de cette clef publique.

1. Citons l'article 442-1 du code pénal Français : La contrefaçon ou la falsication des pièces de monnaieou des billets de banque ayant cours légal en France ou émis par les institutions étrangères ou internationaleshabilitées à cette n est punie de trente ans de réclusion criminelle et de 450 000 euros d'amende. . À titre decomparaison, l'artice 222-24 stipule que Le viol est puni de vingt ans de réclusion criminelle (1) Lorsqu'il aentraîné une mutilation ou une inrmité permanente, (2) Lorsqu'il est commis sur un mineur de quinze ans,. . . .

38

https://en.wikipedia.org/wiki/List_of_cryptocurrencies

Une transaction est un message énonçant le transfert de la propriété d'un instrument moné-taire d'un compte A vers un autre compte, voire plusieurs si l'instrument monétaire est fractio-nable. Pour être valide, une transaction doit être signée cryptographiquement par A, le proprié-taire de l'instrument avant la transaction.

Dans le système Bitcoin, une transaction en bitcoin détruit et crée un ouplusieurs instruments monétaires, en veillant à ce que les sommes des valeursnominales des instruments détruits et crées soient égales (pas de création demonnaie). Ainsi, la validité d'un instrument monétaire peut être prouvée en (1)exhibant la transaction où il a été créé, et (2) en attestant qu'il n'existe aucunetransaction où il a été détruit.

4.2.2 Registre

Un registre liste toutes les transactions valides ayant eu lieu sur le système depuis sa création.Ce registre est :

• public : il est librement disponible sur internet, et n'importe qui peut le télécharger etconsulter l'intégralité des transactions qui ont eu lieu dans la monnaie.

• distribué : le registre est maintenu par un système distribué dont chaque machine en stockeune copie. Pour un bon fonctionnement, ce système distribué doit garantir une forme deconsensus : lorsqu'une nouvelle transaction est ajoutée au registre, elle doit l'être sur toutescopies (honnêtes).

• ouvert : chaque machine du réseau exécute un algorithme public. Toute machine connectéeà internet et exécutant cet algorithme est considérée comme appartenant au réseau. Enpratique, plusieurs implémentations de l'algorithme peuvent exister.

Le registre du système Bitcoin est consultable en installant un client lourdbitcoin, ou par exemple via l'interface webhttps://www.blockchain.com/explorer?view=btc_blockshttps://www.blockchain.com/explorer?view=btc_blocks

4.2.3 Ajout de transactions au registre

Toute transaction est créée par le propriétaire d'une machine et transmise à ses voisines surle réseau ; la propagation peut être incomplète. Chaque machine dispose d'une réserve, qu'ellealimente par les transactions à valider dont elle prend connaissance. Les transactions en réservene sont pas encore dans le registre.

L'ajout de transactions au registre se fait par phases successives. Chaque phase commence parl'élection d'une machine. L'élue constitue alors un bloc, formé de transactions tirée de sa réserve.Une fois le bloc constitué, l'élue le transmet au système, qui forme un consensus sur l'acceptationou le rejet de ce bloc. Ce consensus doit n'accepter que les blocs satisfaisant certaines conditionsde validité : chaque transaction doit être correctement signée, doit concerner des instrumentsmonétaires existants et dont ¨e compte signataire est propriétaire, ne doit pas comporter de

39

https://www.blockchain.com/explorer?view=btc_blocks

double dépense, etc. Si le bloc est accepté par le système, chaque machine enlève de sa réserveles transactions du bloc si il y en a, ainsi que des transactions qui seraient incompatibles aveccelles qui viennent d'être ajoutées au registre (par exemple parce qu'elles dépenseraient uninstrument dont le compte propriétaire vient de changer). Que le bloc soit accepté ou refusé, oncommence une nouvelle phase.

Les manières dont le système Bitcoin réalise l'élection et obtient le consensussont deux points essentiels, sur lesquels on revient en détail à la section 4.44.4.

4.2.4 Création monétaire

Chaque bloc ajouté au registre contient, en plus des transactions qu'il ajoute à l'historique,une opération de création d'une certaine quantité de nouvelle monnaie, crédités à un comptelibrement choisi par la machine (élue) qui propose le bloc.

Dans le système Bitcoin, la quantité de monnaie créée à chaque nouveau blocest déterminé a priori. C'était initialement 50 bitcoins. Ce montant est révisé àla baisse et deviendra nul dans quelques décennies. Autrement dit, la quantitéde bitcoin existant est actuellement en augmentation mais nira par être xée.

4.3 Exercices

Exercice 1 F Supposons que plusieurs cryptomonnaies utilisent comme comptesles signatures cryptographiques DSA.

a. Qui dispose de l'autorité pour créer un compte valide pour l'une ou l'autre descryptomonnaies ?

b. Une identité créée pour une cryptomonnaie peut-elle être utilisée pour une autrecryptomonnaie ?

c. Où est stockée l'identité du détenteur d'un compte sur une des cryptomonnaies ?

d. Est-ce possible qu'un même compte soit créé plusieurs fois ? Si oui, quelles enseraient les conséquences ? Si non, qu'est-ce qui garantit cette impossibilité ?

Exercice 2 F Supposons que je dispose d'une signature DSA (cp,cs) et quele compte cp est proriétaire de quelques brouzoufs (cryptomonnaie méconnue maissupposée suivre les principes ci-dessus).

a. Suite à un incendie, j'ai irrémédiablement perdu le chier contenant cs et jen'en avais pas fait de copie. Y-a-t'il un moyen de tranférer ou faire transférer lesbrouzoufs de cp dans un autre de mes comptes dont j'ai gardé la clef secrète ?

b. De peur d'un nouvel incendie, j'ai demandé à des amis de garder chez eux descopies du chier contenant cs. Je m'aperçoit que quelqu'un d'autre que moia dépensé mes brouzoufs. M'est-il possible de me faire reconnaître comme lepropriétaire originel de ce compte et d'annuler cette transaction ?

40

Exercice 3 F Puisque l'algorithme à exécuter pour faire partie d'un système detype Bitcoin est public, il est tout à fait possible d'en exécuter une version modiée.Supposons qu'une de mes machine soit élue pour proposer un bloc et que j'en aimodié le programme pour tricher. Puis-je...

a. ... faire accepter une transaction à partir d'un compte source dont je ne connaispas la clef secrète ?

b. ... décider laquelle de deux transaction en réserve utilisant le même bitcoin (casde double dépense) sera acceptée ?

c. ... retarder ou annuler une transaction en réserve qui ne me plaît pas ?

Exercice 4 FFF Quels sont les mécanismes de création de la monnaie Euro ?

4.4 Principe de l'élection et du consensus dans Bitcoin

Selon les principes décrits ci-dessus, la tenue d'un registre distribué suppose de résoudredeux problèmes de calcul distribué : l'élection et le consensus. Comme nous le verrons auxchapitres suivants, ces deux problèmes posent des dicultés fondamentales. Une des prouessesde Bitcoin est d'avoir réussi non pas à résoudre ces dicultés, mais à les esquiver.

4.4.1 Preuve de travail

Le système Bitcoin inverse le processus d'élection : il autorise toute machine à proposer unbloc à inclure dans le registre. En revanche, le système ajoute aux conditions de validité déjàévoquées la condition que le bloc doit avoir un haché par Sha-256 inférieur à une certaine valeurcible (en anglais : target ).

Explicitons cette condition supplémentaire. Pour cela, notons w le mot binaire formé par unepage et w′ = Sha-256(w). Puisque w′ est un mot 256 bits, il existe un unique entier n, comprisentre 0 et 2256 − 1, tel que l'écriture binaire de n sur 256 bits soit w′. La condition est que ndoit être inférieur à la cible. Voici, pour être concret, quelques unes des valeurs (en hexadécimal)prises par cette cible au l du temps (on revient en Section 4.4.34.4.3 sur cette évolution) :

n de bloc cible30 000 00000000ffff0000000000000000000000000000000000000000000000000000

50 000 000000002a111500000000000000000000000000000000000000000000000000

100 000 000000000004864c000000000000000000000000000000000000000000000000

200 000 00000000000005db8b0000000000000000000000000000000000000000000000

300 000 0000000000000000896c00000000000000000000000000000000000000000000

400 000 000000000000000006b99f000000000000000000000000000000000000000000

500 000 0000000000000000009645000000000000000000000000000000000000000000

600 000 00000000000000000015a35c0000000000000000000000000000000000000000

671 000 0000000000000000000cf4e30000000000000000000000000000000000000000

Remarquons que pour être inférieur à la valeur cible autour du bloc n 600 000, le haché doitnécessairement commencer par 18 × 4 + 3 = 75 zéros. Si l'on considère que les valeurs hachéespar Sha-256 sont distribuées uniformément dans les mots 256 bits, la probabilité qu'un blocassemblé sans plus de soin satisfasse ce critère est inférieure à 2−75.

41

La dénition d'un bloc dans la blockchaine de Bitcoin est très précise, et ne laisse de libertéqu'en deux points : le choix des transactions à inclure et le choix de la valeur d'un compteur32 bits appelé nonce. Assigner telle ou telle valeur au nonce n'a qu'un seul eet : modier lehaché du bloc. L'objectif est de permettre, par ce paramètre, qu'un choix donné de transactionsà inclure puisse donner lieu à 232 blocs possibles, qui sont autant de chances d'avoir un hachéinférieur à la cible.

Il est communément supposé que les propriétés cryptographiques de Sha-256 assurent quel'on ne peut produire un bloc qu'en testant les valeurs possibles de nonce une par une. Enschématisant (fortement), la recherche d'un bloc de haché susamment petit ressemble donc à :

1 def solve():

2 B[0] = hash du dernier bloc connu

3 B[1] = ensemble de transactions choisies

4 B[2] = 0

5 while (hash(B) > cible):

6 B[2]++

C'est un puzzle fort laborieux à résoudre : ce système d'élection est appelé preuve de travail.Les machines du système qui cherchent à résoudre un tel puzzle sont appelés des mineurs. Dèsqu'un mineur a résolu un tel puzzle, il transmet le bloc obtenu (on dit miné) au réseau.

4.4.2 Diusion dans le réseau

Lorsqu'une machine réussit une opération de minage, elle diuse le nouveau bloc produitaux autres machines du système Bitcoin. Chaque autre machine vérie que le bloc est correctet décide, localement, de l'accepter ou de le refuser. S'il est accepté, le bloc est ajouté commeprolongement du bloc pré-existant qu'il annonce étendre (c.f. B[0] ci-dessus).

Si on suppose que la diusion et l'acceptation/rejet d'un bloc par le système est instantanée,cette méthode produit une chaîne de blocs. En eet, lorsqu'un mineur accepte un nouveau bloc,il recommence son minage à partir de ce bloc. (Il met aussi à jour sa réserve en supprimant lestransactions contenues dans et incompatible avec le bloc récemment ajouté.) Dans ce cas idéal,il faudrait que deux mineurs réussissent simultanément à miner un bloc pour que l'on ait unproblème : le réseau dans son ensemble devrait choisir l'un ou l'autre nouveau bloc.

La propagation d'un bloc dans le réseau n'étant pas instantanée, la possibilité qu'à un mo-ment donné deux nouveaux blocs propagés étendent le même bloc préexistant est réelle. Il sutpour cela que l'intervalle de temps séparant deux minages réussis soit inférieure au temps dediusion entre ces deux mineurs sur le réseau.

L'approche du système Bitcoin pour obtenir un consensus peut être résumé par que leplus long gagne ! . En détail :

a. Chaque machine accepte tout bloc correct. Ainsi, si deux blocs étendent correctement unbloc pré-existant, les deux sont mémorisés. Chaque machine maintient donc non pas unechaîne, mais un arbre.

42

b. La chaîne principale d'un arbre est le chemin le plus long dans cet arbre, partant de laracine. Plus précisément, la longueur du chemin est calculée en pondérant chaque blocpar sa diculté de minage (le 2k où k est le préxe visé lors du minage de ce bloc). Lesautres chemins maximaux pour l'inclusion et partant de la racine sont appelés chaînes

secondaires.

c. Chaque machine dénit le registre comme la suite des transactions enregistrées dans lachaîne principale de son arbre.

d. Le système Bitcoin est en état de consensus si toutes les machines ont la même chaîneprincipale, et donc même état du registre.

Lorsque le système Bitcoin n'est pas en état de consensus, diérentes machines ont des idéesdiérentes sur qui possède quoi. Lorsque cette divergence se résout, certaines machines changentde chaîne principale et donc de registre. Du point de vue de ces machines, certaines transactionssortent du registre pour retourner en réserve : elles sont dévalidées .

4.4.3 Un équilibre délicat

La fréquence à laquelle un nouveau bloc est miné est un paramètre critique pour le fonc-tionnement du système Bitcoin. Si cette fréquence est trop faible, les transactions peinent àêtre validées et le système s'engorge. Si cette fréquence est trop forte, les chaînes secondaires semultiplient et le système passera une grande partie du temps hors état de consensus.

Le système Bitcoin vise que la fréquence de minage soit autour d'un nouveau bloc toutesles 10 minutes ; ce choix correspond à un régime où l'état de consensus est fréquent. En pratique,la fréquence moyenne de minage est déterminée par deux paramètres : la puissance de calculde l'ensemble des mineurs et la diculté du minage, c'est à dire la valeur cible. Tous les 2016blocs, le système compare le temps réellement pris pour miner ces blocs à la moyenne théoriquevisée (ici, 14 jours) et ajuste la cible en conséquence : si les blocs sont minés trop vite, on abaisseencore la cible (ce qui augmente la diculté), sinon on la réhausse.

Dans le système Bitcoin, les problèmes de l'élection et du consensus sont traitéspar une preuve de travail dont la diculté réalise un équilibre entre vitesse devalidation des transactions et durée hors-consensus du système.

Cet équilibre s'avère aussi déterminant pour plusieurs aspects macroscopiques du systèmetels que son impact environnemental, sa sécurité, et sa gouvernance.

4.4.4 Exercices

Exercice 5 F Notons c0 la valeur cible requise au bloc 30 000. Existe-t-il, pourtous B[0] et B[1] xés, une valeur du nonce B[2] qui assure que hash(B) ≤ c0 ?

Exercice 6 F

a. Déterminer l'ordre de grandeur du nombre de transactions validées par bloc enexaminant quelques blocs récents surhttps://www.blockchain.com/explorer?view=btc_blockshttps://www.blockchain.com/explorer?view=btc_blocks

43

https://www.blockchain.com/explorer?view=btc_blocks

b. En déduire une estimation du nombre de transaction que le système Bit-coin peut enregistrer par minute.

Exercice 7 FF Notons c0 la valeur cible courante du système Bitcoin. Considé-rons des variables aléatoires x1, x2, . . . , xn choisies indépendamment et uniformémentdans 0, 1256. Ici, xi modélise le haché obtenu lorsqu'à B[0] et B[1] xé on xe B[2]=iet on hache B.

a. On note p la probabilité que x1 ≤ c0. Que vaut p ?b. Notons sn le nombre de xi, 1 ≤ i ≤ n qui sont inférieur ou égal à c0. Quelle est

la loi de probabilité de la variable aléatoire sn ?

c. Que peut-on en déduire sur P[sn = 0] en fonction de n et c0 ?

4.5 Commentaire : techniques de minage

À ce jour, le caractère cryptographique de Sha-256 n'a pas été compromis. La recherched'un bloc de haché inférieur à la cible se fait donc en essayant des blocs les uns après les autres.Une manière pratique d'appréhender la puissance de calcul dédiée au système Bitcoin estd'examiner le nombre de hachés calculés par seconde :

Figure 4.1 Évolution du nombre de hachés calculés par seconde (1 PHash/s = 1015

hash/seconde). L'échelle est semi-logarithmique. (Source : http://bitcoin.sipa.be/http://bitcoin.sipa.be/.)

La gure 4.14.1 révèle que l'évolution de la puissance dédiée au minage de bitcoin n'est pasrégulière. Notons en particulier que cette diculté a été multipliée par un million entre début2010 et mi-2011, puis à nouveau par dix mille entre début 2013 et mi-2014. Ces deux phasescoïncident avec des changements technologiques : le minage sur GPU se développe à partir de2010, et le minage sur ASIC se développe à partir de 2013.

Pour comprendre ces évolutions, il est utile de faire un (très bref) point d'architecture. Unprocesseur classique (CPU) est un assemblage de portes logiques (AND, OR, NOT, . . . ) qui

44

http://bitcoin.sipa.be/

forment des circuits réalisant des opérations élémentaires : addition de deux nombre, comparai-son entre deux nombres, mémorisation d'un nombre. Chaque processeur dispose d'un langagenatif, appelé assembleur, dont les instructions manipulent essentiellement des variables natives,appelées registres. Pour faire exécuter une tâche à un processeur, il est nécessaire de la décom-poser en opérations assembleur ; un langage dit haut-niveau comme python ne fait qu'assurerla traduction en assembleur d'un programme décrit en termes plus pratiques pour le program-meur. Un GPU est un processeur vectoriel : ses registres stockent un vecteur d'entier (et nonpas un seul entier comme pour un CPU), et chaque instruction élémentaire s'applique simulta-

nément à toutes les coordonnées du vecteur. Ainsi, pour être exécutable ecacement sur GPU,un programme informatique doit pouvoir être reformulé en terme de calcul sur des vecteurs. Ils'avère que Sha-256 peut être ecacement évaluée en parallèle par une tel calcul vectoriel, d'oùle succès de son déploiement sur GPU. On peut imaginer que d'autres fonctions soient moinsadaptées au calcul sur GPU.

Un processeur, CPU ou GPU, est un système très complexe et pensé pour traiter très ef-cacement un large éventail de tâches. Il se trouve que le calcul, en boucle, de fonctions Sha-256 sous-utilise très largement ces capacités, et peut se faire sur un circuit intégré dédié bienplus simple. C'est ce que l'on appelle un ASIC. Comme pour le passage sur GPU, le passagesur ASIC ne va pas de soi, et doit se faire pour chaque fonction de hachage spéciquement. Ils'avère aussi que Sha-256 est facilement calculable sur ASIC. On peut imaginer que d'autresfonctions le soient moins.

4.6 Commentaire : impact environnemental de Bitcoin

L'impact environnemental du système Bitcoin est une question importante. Pour l'examineravec un peu de soin 22, nous allons examiner les résultats d'une analyse de cycle de vie (ACV),méthode établie d'analyse multicritère de l'impact environnemental d'un système, présentée dansl'article

Köhler, S. and Pizzol, M., 2019. Life Cycle Assessment of Bitcoin Mining. Environ-mental science & technology, 53(23), pp.13598-13606.

On donne en Annexe DD une très rapide introduction à l'ACV.

4.6.1 Type d'ACV et unité fonctionnelle

Köhler et Pizzol proposent une ACV-A (attributive) rétrospective portant sur l'année 2018et une ACV-C (conséquentielle) prospective portant sur la croissance du système au-delà de2019 (année de l'étude). L'ACV-C comporte trois scénarii.

L'unité fonctionnelle de l'ACV est le calcul d'1 TH de Sha-256. Un TH est un Terahash,c'est à dire de 1012 valeurs hachées ; l'étude estime, sur la base de l'évolution de la diculté deminage, qu'il a été calculé de l'ordre d'un milliard de TH en 2018. Plus précisément, l'ACV-Adétermine le coût moyen de calcul d'1 TH en 2018 et les ACV-C déterminent le coût moyen,dans divers scénarii, de calcul d'1 TH post-2019 (année de publication de l'étude).

2. Une simple recherche sur internet permet de trouver facilement des sources à ce sujet, mais les donnéesqu'elles fournissent peuvent s'avèrer discutables (analyse tronquée, approximations ou extrapolations grossières,etc).

45

4.6.2 Inventaire

La phase d'inventaire porte sur les machines et sur l'énergie alimentant ces machines.

L'inventaire des machines combine un recensement des grands types de machines et l'ACVd'un ordinateur-type, au prorata du poids. Pour l'ACV-A, le recensement est fait sur la base desblocs ayant été minés en 2018, et distingue trois types de machines qui représentent ensemble95% des minages. Pour l'ACV-C, les trois scénarii prolongent la répartition de 2018 (Businessas usual et Localisation) ou l'améliore (Technologie).

L'inventaire de l'énergie s'appuie sur un recensement de la répartition géographique desmineurs et une modélisation des mix énergétiques locaux. Ce recensement est fait au niveau degranularité d'une région : les 53.5% des mineurs localisés en Chine ne sont pas supposés utiliserle mix énergétique national, mais sont traités par région (soit 30.5% dans le Sichuan, 12.3% enMongolie intérieur, et 10,7% dans le Xinjiang). Pour l'ACV-C, les trois scénarii prolongent larépartition de 2018 (Business as usual et Technologie) ou l'améliore en favorisant les sites oùle mix est moins carbonné (Localisation).

4.6.3 Traduction

Köhler et Pizzol traduisent l'impact environnemental en une douzaine d'indicateurs (c.f.Table 2 de l'article et début de la section results and discussion). Pour la discussion, nous allonsici retenir deux résultats de l'ACV-A :

a. Le coût énergétique est estimé à 27 mWh par TH.

b. Le potentiel de réchaument climatique selon la méthode IPCC (GWP IPCC) est de 15 mgCO2-équivalents par TH.

Au cours de l'année 2018, la fréquence de hachage du système Bitcoin a varié entre 15 106

TH/s et 60 106 TH/s, pour une moyenne de 36.5 106 TH/s. Cela représente un total d'environ1.15 1015 TH pour l'année. Pour l'ensemble de l'année 2018, les résultats indiquent donc :

a. Le coût énergétique est estimé à 31.3 TWh.

b. Le potentiel de réchaument climatique selon la méthode IPCC (GWP IPCC) est estimé à17. 106 tonnes de CO2-équivalent.

4.6.4 Quelques éléments d'appréciation

Il peut être utile, pour situer les ordres de grandeur dont on parle, de rappeler que le potentielde réchaument climatique émis par le secteur du transport, au niveau mondial, en 2010 est de6.7 109 tonnes de CO2-équivalent. (Source : 5ème rapport du GIEC, résumé des contributionsdu GT 3.)

Une recherche rapide sur internet (non opposable, donc !) révèle que le parc des centralesnucléaires d'EDF compte 4 réacteurs de 1450 MW, 20 réacteurs de 1300 MW et 20 réacteursde 900 MW, et qu'un réacteur nucléaire de 900 MW produit en moyenne 6 TWh par an. Laconsommation mondiale du réseau Bitcoin en 2018 équivaudrait donc à la production électriquede 5 petits réacteurs nucléaires.

46

4.7 Commentaire : conance en le système Bitcoin

La question de la conance dans le bitcoin peut se comprendre de diérentes manières.Ce que nous discutons ici est plus précisément :

Quelle conance peut-on avoir dans la résistance du registre du système Bit-coin à la fraude ?

Précisons trois points. D'une, on suppose que les propriétés cryptographiques de Sha-256 etde la version d'ECDSA utilisée par le système Bitcoin ne sont pas compromises. Si cela devaitêtre le cas, le système perdrait largement en abilité. De deux, on ne parle pas de la conance enl'utilisation de Bitcoin comme monnaie. Cette question est intéressante mais déborde largementdu cadre de ce cours (ne serait-ce qu'en raison du caractère largement spéculatif de l'utilisationde cette monnaie). De trois, on ne parle pas des risques d'usurpation de compte par vol de clefprivée, problématique de cybersécurité.

Ces trois points précisés, un des principaux risques restant est lié à la nature probabilistedu consensus dans le système Bitcoin : un groupe d'individus agissant de concert et controlantune fraction signicative de la puissance de calcul du système serait en mesure d'annuler unetransaction (récente). En eet, statistiquement, une fraction signicative des blocs ajoutés à lablockchaine devrait être produite par des machines contrôlées par ce groupe. Ce groupe pourraitpar exemple choisir à quelle branche s'ajoutent leurs blocs, et par là exclure le dernier bloc miné(en cherchant à miner un bloc faisant suite à l'avant-dernier bloc miné).

La non-réversibilité des transactions repose donc en partie sur le fait que la communautédes mineurs soit faiblement concentrée. Dans un système économique, le taux de concentrationest inuencé par l'intensité capitalistique de l'activité. En eet, s'il faut immobiliser un capitalconséquent pour être compétitif, les dynamiques classiques de marché peuvent conduire à uneconcentration des ressources de minage entre quelques mains.

Le passage du minage du CPU au GPU puis aux ASIC a induit une augmen-tation de l'intensité capitalistique, et a donc contribué à augmenter le risque deconcentration d'une forte part du minage entre quelques mains.

Ainsi, un paramètre purement technique comme le choix de la fonction de hachage cryptogra-phique utilisée dans le système de preuve de travail peut avoir une inuence déterminante surl'intensité capitalistique du minage et, in ne, la conance que la blockchaine inspire. À titre decomparaison, la cryptomonnaie Ethereum utilise une preuve de travail basée sur une fonction dehachage pour laquelle la conception d'ASIC se révèle peu rentable (on la dit ASIC-résistante).

4.8 Ouvertures

On conclue ce chapitre par quelques pistes d'approfondissement.

4.8.1 Dynamique d'une cryptomonnaie

Il est utile d'expliciter une dynamique importante sous-jacente au bon fonctionnement dusystème Bitcoin, valide pour d'autres cryptomonnaies.

L'adoption du Bitcoin comme monnaie par des acteurs économiques repose sur la conancequ'ils accordent à sa abilité (par exemple la non-réversibilité des transactions). La abilité du

47

Bitcoin repose en partie sur le fait que les mineurs sont diversiés (un individu réussissantà miner une fraction importante des blocs pourrait annuler une transaction). Une large diver-sication des mineurs repose sur le fait que l'opération de minage est, pour eux, rentable. Lecoût du minage est certain (achat d'une machine, alimentation en énergie, connection au réseau,refroidissement, entretient, . . . ) et en monnaie reconnue, sa récompense est incertaine (seule laréussite est rémunérée) et en bitcoin. Ainsi, la rentabilité du minage pour une personne reposesur l'adoption du Bitcoin comme monnaie par des acteurs économiques et sur une fréquencede réussite raisonnable.

Soulignons la circularité de ces implications : l'adoption duBitcoin comme monnaie dépendsde conditions qui dépendent, à leur tour, de l'adoption du Bitcoin comme monnaie. Il y a làune boucle de rétroaction. Faisons une première observation :

Le système Bitcoin a connu au moins deux types d'équilibres diérents. En2009, il n'était pas adopté comme monnaie et personne ne le minait. En 2020,il est en partie adopté comme monnaie et le minage peut être rentabilisé etprofessionalisé.

Le passage d'un type d'équilibre à l'autre n'a rien d'évident (examiner, par exemple, l'histoirede l'Auroracoin).

4.8.2 Les preuves de travail, un pis-aller

Revenons sur la forte consommation énergétique du système Bitcoin. On peut la com-prendre comme suit :

a. La consommation énergétique est pour l'essentiel à attribuer au système de minage.

b. Réduire la puissance de minage (et donc la consommation énergétique) n'aurait aucuneconséquence sur le nombre de transactions validées, puisque le système Bitcoin ajuste ladiculté du minage à la puissance qui y est consacrée.

c. Réduire la puissance de minage remettrait, en revanche, en question la pérennité du ca-ractère distribué du système Bitcoin. En eet, cela faciliterait l'irruption d'un mineur

hégémonique, qui minerait une large part des blocs. Un mineur hégémonique aurait la ca-pacité d'annuler des transactions. Cela ferait reposer la conance en le système Bitcoin enla conance en cet acteur hégémonique. Autrement dit, cela recentraliserait Bitcoin.

Si le système Bitcoin encourage une forte dépense énergétique, c'est donc simplement pourassurer que le système reste décentralisé malgrès les enjeux : c'est une sorte d'équilibre par fuiteen avant.

La preuve de travail utilisée par le système Bitcoin n'est qu'une réponse possible auproblème d'élection équitable que pose la conception d'une blockchaine ouverte. Les séances 5à 7 sur le calcul distribué devraient cependant établir que ce problème est dicile et que sepasser des preuves de travail, et de la colossale dépense énergétique induite, est un réel déscientique et technique. Mentionnons deux pistes :

a. Des besoins en puissance de calcul ne manquent pas : simulation de systèmes complexes,traitement de signaux massifs, exploration d'espaces de congurations colossaux. Certainsde ces calculs se font sur des systèmes distributés ouverts tels que SETI@home ou encorefolding@home. Il serait intéressant de développer un système de preuve de travail utile,où l'élection se ferait au prorata de la participation à de tels calculs. Il n'est cependantpas simple de concevoir un puzzle à la fois utile et cryptographiquement résistant.

48

b. Il est plus facile d'organiser une élection distribuée au sein d'un système fermé. Les sys-tèmes à preuve d'enjeu visent à distinguer, au sein du système ouvert maintenant lablockchaine, un sous-système fermé de machines éligibles qui ont établi qu'elles ont unenjeu fort à la abilité du système. On peut envisager qu'une preuve d'enjeu prenne laforme d'une caution (contrepartie matérielle immobilisée), d'une preuve de travail réussie(permettant d'être éligible un certain temps), etc.

Ce sont des sujets de recherche et de développement aujourd'hui très actifs.

4.8.3 Gouvernance

Il est souvent mis en avant que le système Bitcoin a la vertu d'être décentralisé. Si lesystème Bitcoin est conçu comme un système décentralisé et ouvert on peut remarquer lespoints suivants :

a. Comme signalé, l'évaluation de la fonction Sha-256 a donné lieu à une course technologique(CPU, puis GPU, puis ASIC), augmentant l'intensité capitalistique du secteur économique.Il s'en suit une concentration du minage en un faible nombre d'acteurs.

b. Un système tel que Bitcoin est occasionnellement amené à faire évoluer certaines de sescaractéristiques. On peut consulter les bitcoin improvement proposals à

https://github.com/bitcoin/bipshttps://github.com/bitcoin/bips

Ces évolutions s'incarnent au travers de modications du code des clients utilisés sur leréseau. (Cela peut, dans certains cas, conduire à une séparation du réseau en deux ; voirpar exemple Bitcoin Cash.) Ainsi, dans une certaine mesure, eectivement proposerdes évolutions demande une compétence technique amenant à une restriction du nombred'acteurs.

Ainsi, une conception décentralisée n'implique ni fonctionnement ni gouvernance décentralisés.

4.9 Et encore un exercice

Exercice 8 FFF Supposons que l'on souhaite étudier la possibilité que le systèmeBitcoin reste hors état de consensus pendant une durée t, en fonction de t.

a. Comment pourrait-on aborder la construction d'un modèle probabiliste décri-vant cela ? Quelles informations faudrait-il sur le réseau ? Quels types de calculsfaudrait-il faire ?

b. Sans construire un tel modèle, peut-on anticiper la dépendance en t de la proba-bilité que le système Bitcoin reste hors état de consensus pendant une durée t ?Quel type de loi est-ce que cette probabilité semble suivre ?

49

https://github.com/bitcoin/bips

Chapitre 5

Consensus et élection en calculdistribué synchrone

Dans cette seconde partie du cours, nous abordons le second pilier du déploiement des chaînesde blocs, le calcul distribué. Il s'agit d'étudier les manières de faire réaliser conjointement, etsans orchestration, une tâche à plusieurs acteurs (ordinateurs, processeurs, . . . ) de manière ableet ce, malgrès les retards ou erreurs de communication, les pannes, les dysfonctionnements.

5.1 Modèle de système distribué à réseau

Commençons par décrire le modèle de calcul distribué qui va nous intéresser tout au long deces 3 séances.

5.1.1 Machines et rupture de symétrie

On suppose données un ensemble de machines (processeurs, ordinateurs, . . . ) capables decalculer et de communiquer entre elles. On appelle système distribué l'ensemble formé desmachines et de leurs moyens de communications. On souhaite faire résoudre un problème à unsystème distribué en installant sur chaque machine le même programme, puis en exécutant ceprogramme sur toutes les machines à la fois.

Chaque machine est un système de calcul classique (automate ni, machine de Turing, . . . )augmenté d'un système de communication : le système de calcul peut déclencher l'envoi d'un ouplusieurs messages, et il peut recevoir des messages et y réagir. L'exécution du programme peutêtre diérent sur chaque machine car il peut réagir aux messages que cette machine reçoit.

A priori, les machines d'un système distribué sont symétriques, c'est à dire indistinguables.Il est courant de casser cette symétrie en supposant que chaque machine s'est vu attribuer unidentiant unique. Une alternative courante consiste à supposer que chaque machine a accèsà une source d'aléa qui lui est propre. L'un ou l'autre cas sont spéciés par le modèle de calcul.

5.1.2 Communication par réseau

Nous allons travailler dans le modèle à réseau. Dans ce modèle, certaines paires de machinessont connectées par des canaux de communication qui permettent d'envoyer et de recevoir desmessages. On modélise ce réseau par un graphe G = (V,E) dont les sommets V sont les machineset les arêtes E sont les paires de machines connectées. Les machines connectées à une machineu sont appelées les voisines de u. Le nombre de voisines de u est le degré de u, noté deg u.

51

Chaque machine u connaît son nombre deg u de voisines, et sait les distinguer entre elles.Chaque machine u dispose de canaux d'émission (numérotés de 1 à deg u) et de canaux de récep-tion (numérotés de 1 à deg u). Ces numérotations sont cohérentes entre émission et réception,mais ne sont pas a priori cohérentes d'une machine à l'autre. En particulier, chaque machine neconnaît le réseau que localement.

Pour les besoin de la présentation des algorithmes, nous ajoutons un sommet au réseau,appelé R pour Résultat, connecté à toutes les machines : R n'est pas une machine (il ne cal-cule pas) mais il peut recevoir des messages. Cela nous permettra de concrétiser simplement laformulation du résultat d'un calcul.

5.1.3 Algorithme et synchronisation

On décrit chaque programme par un pseudo-code de type python augmenté des fonctionssuivantes :

emettre(I,m) prend en entrée un ensemble I d'entiers et une chaîne binaire m, et envoie m

sur les canaux d'index dans I. On s'autorise à écrire, pour un entier i, emet(i,m) pouremet(i,m) et emet(tous,m) pour émettre sur tous les canaux sauf R : autrement dit,le message sera envoyé à tous les voisins.

recevoir collecte les messages transmis par les voisins.

terminer conclut l'exécution du programme sur cette machine. Une machine est active dudébut du calcul jusqu'au moment où elle exécute l'instruction terminer. Elle devient alorsinactive.

Nous travaillerons dans deux modèles de calcul distribué distincts. Le premier modèle estsynchrone, c'est à dire que les machines commencent à exécuter leurs programmes en mêmetemps, et avancent au même rythme (ou, disons, peuvent s'attendre pour rester synchronisées).Le second modèle est asynchrone, c'est à dire qu'on n'y fait aucune hypothèse sur les vitessesrelatives d'exécution des programmes sur les diérentes machines : une machine peut avoir letemps de faire 10 ou 1000 pas de calcul le temps qu'une autre en fasse 1.

Pour la présentation d'algorithmes dans les modèles synchrones, on autorisera de plus l'ins-truction suivante :

synchro attend que l'ensemble des machines du système distribué at-teignent ce point de l'algorithme avant de continuer.

On appelera phase un intervalle de temps entre deux synchronisations successives.

5.1.4 Retards, pannes et dysfonctionnements

L'étude des algorithmes distribués attache une grande importance à leur capacité à supportercertains imprévus.

Une machine dans un système distribué a un comportement Byzantin si elle ne se comportepas conformément à l'algorithme. Cela peut être dû à un problème technique (défaillance d'undes ports de communication par exemple) ou à un comportement malicieux (prise de contrôlede la machine et modication du programme par un tiers malveillant). Lorsque l'on modélise unsystème où des comportements Byzantins sont possibles, on dit qu'une machine est able si ellese comporte conformément à l'algorithme.

52

Dans un système distribué, une panne désigne le fait qu'une des machines du système arrêtede fonctionner : elle ne reçoit plus les messages, n'eectue plus aucun calcul interne et n'émetplus de messages. Une panne est un problème moins général qu'un comportement Byzantin maissut déjà à modéliser la possibilité de plantage, de coupure d'électricité, d'incendie, . . . Unemachine qui n'est pas en panne est appelée fonctionnelle.

5.1.5 Dénition d'un modèle

Lorsqu'on étudie d'un problème de calcul distribué, il convient de spécier le système surlequel on travaille :

• Est-il synchrone ou asynchrone ?

• Les machines disposent-elles d'un identiant unique ? d'une source personnelle d'aléa ? nil'un ni l'autre ?

• La topologie du réseau est elle complète ? circulaire ? arbitraire ?

• Peut-il y avoir des pannes ? non-malicieuses ou Byzantines ? combien ?

5.2 Élection dans un système synchrone sans panne

Considérons pour commencer le problème suivant, que l'on souhaite résoudre dans un systèmesynchrone sans panne :

Élection (synchrone) sans panne

Entrée : Rien

Sortie :Chaque machine envoie 0 ou 1 à R.Exactement une machine doit envoyer 1.

Rappelons qu'un système distribué ne dispose pas de chef d'orchestre à même de partager letravail entre les machines. Le problème de l'élection peut servir à désigner une machine chargéed'organiser une partie d'un calcul ultérieur.

5.2.1 Avec identiants uniques dans un réseau complet

Supposons pour commencer que le réseau est complet et que chaque machine dispose d'unevariable identiant ∈ N qui est unique, au sens où il n'existe pas deux machines pour lesquelleidentiant a la même valeur. On peut alors résoudre le problème de l'élection par l'algorithmesuivant :

1 emettre(tous, identifiant)

2 synchro

3 recevoir

4 m = identifiant max reçu

5 si identifiant == m

6 emettre(R, 1)

7 sinon

8 emettre(R, 0)

9 terminer

Remarquons qu'une machine envoie 1 à R si et seulement si son identiant est le plus grandparmi les identiants des machines du système. Comme les identiants sont uniques, cela assurequ'exactement une machine envoie 1 à R, toutes les autres lui envoyant 0.

53

5.2.2 Sans identiant unique, à deux machines

Dans le cas où on ne dispose pas de manière de casser la symmétrie entre les machines, ils'avère qu'il est impossible d'élire un meneur. On illustre d'abord l'idée de la preuve sur uncas simple, avant de la prolonger en exercice :

Proposition 4. Il n'existe pas d'algorithme déterministe qui résout le problème de l'élection

dans le modèle synchrone à réseau complet pour deux machines indistinguables.

Démonstration. Supposons que l'on ait un algorithme déterministe qui résout le problème del'élection dans le modèle synchrone à réseau complet et 2 machines indistinguables. Chaquemachine a un canal de communication sortant (on ignore R, qui n'intervient pas dans le calcul)et un canal de communication entrant. La première idée de la preuve est que tant que les deuxmachines reçoivent les mêmes messages aux mêmes moments, elles évoluent en restant dans desétats identiques. Cela se prouve par récurrence :

• Les deux machines commencent l'exécution de l'algorithme dans le même état, par hypo-thèse.

• L'algorithme est déterministe. Le pas de calcul suivant ne dépend que de l'état courant etdes messages reçus.

Or, tant que les deux machines sont dans le même état, à chaque fois qu'une machine envoieun message à l'autre, cette autre fait de même. Autrement dit, à chaque fois qu'une machinefait recevoir un message m à l'autre machine, elle reçoit elle-même m. Par conséquent, tout aulong de l'algorithme, les deux machines évoluent en restant dans des états identiques et émettentdonc le même message vers R. Qu'il s'agisse de deux 0 ou de deux 1, ce n'est pas une réponsecorrecte au problème de l'élection.

Une autre manière de comprendre la preuve de la Proposition 44 est que le système se comportecomme si chaque machine était en boucle, c'est à dire recevait ses propres messages. Ce systèmemodié est composé de 2 machines identiques, sans interaction extérieure, qui exécutent le mêmeprogramme. Si elles émettent un résultat vers R, ce résultat devra être identique et ne pourrapas être une réponse correcte au problème de l'élection.

5.2.3 Exercices

Exercice 1 FF On considère un système distribué à n machines à identiantsuniques et à réseau en anneau. On suppose que l'anneau est orienté : chaquemachine a un voisin nommé gauche et un voisin nommé droite, et chaque machineest le voisin gauche de son voisin droite (et réciproquement).

a. On suppose que chaque machine connaît le nombre n de machines du réseau.Donnez un algorithme pour le problème de l'élection.

b. On suppose toujours que l'anneau est orienté, mais maintenant les machinesignorent la taille du réseau. Donnez un algorithme pour le problème de l'élection.

c. Estimez le nombre maximum de phases, en fonction de n, que prend l'exécutionde l'algorithme que vous avez proposé au (b). Une estimation asymptotique(c'est-à-dire un O()) sut.

d. Estimez le nombre maximum de messages échangés en fonction de n lors del'exécution de l'algorithme que vous avez proposé au (b). Une estimation asymp-totique (c'est-à-dire un O()) sut.

54

Exercice 2 FF On considère maintenant un système distribué à n machines àréseau complet. Les machines ne disposent pas d'identiant unique, mais chacunedispose d'une source d'aléa qui lui est propre : elle peut eectuer des tirages équi-probables indépendants d'une variable aléatoire à valeurs dans 0, 1.a. Proposez un algorithme pour le problème de l'élection.

b. Donnez une estimation du nombre moyen de de phases, en fonction de n, queprend l'exécution de votre algorithme.

Exercice 3 FF On reprend le système de l'exercice 1, mais on suppose cette foisque les machines n'ont ni identiant unique, ni accès à une source d'aléa. Prouvezque pour tout n ≥ 2, il n'existe pas d'algorithme qui résout le problème de l'élection.

5.3 Consensus dans un système synchrone sans panne

Dans un système synchrone sans panne, le second problème qui nous intéresse se formuleainsi :

Consensus (synchrone) sans panne

Entrée : Chaque machine a un vote initial valant 0 ou 1.

Sortie :

Chaque machine émet un vote nal valant 0 ou 1. Cesvotes doivent satisfaire les conditions suivantes :

a. Toutes les machines ont le même vote nal.

b. Le vote nal égale l'un des votes initiaux.

Ce problème modélise, par exemple, l'acceptation d'une nouvelle écriture dans une base dedonnée ou un dépôt logiciel. Remarquons que sans la condition que le vote nal égale l'un desvotes initiaux , il surait de décider que toutes les machines votent 0, mais un tel algorithmene serait pas très utile.

Remarquons tout d'abord que si l'on peut résoudre le problème de l'élection dans un systèmedistribué, alors on devrait aussi pouvoir y résoudre le problème du consensus. En eet, il sutd'élire une machine, puis que la machine élue diuse son vote initial à toutes les autres machines,qui l'adoptent comme vote nal. (Dans le détail, il faudrait expliciter la méthode de diusion,qui dépend a priori de la topologie du réseau.)

Notons ensuite qu'il n'est pas nécessaire qu'il existe un algorithme d'élection pour qu'il enexiste un qui résolve le consensus. Voici par exemple un algorithme qui résout le consensus dansle cas d'un système synchrone à réseau complet sans identiant unique ni aléa :

1 emettre(tous, vote initial)

2 synchro

3 recevoir

4 v = min(vote initial, votes recus)

5 emettre(R, v)

6 terminer

55

5.4 Consensus synchrone avec pannes non Byzantines

Pour clore ce chapitre, examinons le problème du consensus en présence de pannes (quel'on suppose ici non-Byzantines). On reste ici dans le modèle synchrone et on suppose le réseaucomplet et les machines à identiants uniques. Dans ce cadre, le problème de consensus doit êtrereformulé ainsi :

Consensus tolérant aux pannes


Sortie :

Chaque machine émet un vote nal valant 0 ou 1. Ces votes doiventsatisfaire les conditions de cohérence globale suivantes :

a. Toutes les machines fonctionnelles ont le même vote nal.


Notons bien que l'on ne demande pas à ce que le vote nal égale le vote initiale d'une machinefonctionnelle.

Un algorithme distribué résout le consensus en tolérant k pannes si toute exécution de cetalgorithme au cours de laquelle au plus k machines tombent en panne aboutit, pour les machinesrestant fonctionnelles, à une solution. Soulignons que chaque machine qui tombe en panne peutle faire à n'importe quel moment lors de l'exécution de son programme.

5.4.1 L'unanimité échoue

Commençons par clarier que l'algorithme d'unanimité donné en section 5.35.3 ne résoutpas le consensus en tolérant ne serait-ce qu'une panne. Pour voir cela, il est utile de le reformulercomme suit :

1 pour j = 1 .. nombre de voisins

2 emettre(j, vote initial)

3 synchro

4 recevoir

5 v = min(vote initial, votes recus)

6 emettre(R, v)

7 terminer

Considérons la situation où le système est constitué de 3 machines, où 2 des machines ont unvote initial de 1 et l'autre a un vote initial de 0. Supposons que la machine de vote initial 0 tombeen panne après avoir émis son vote initial exactement une fois. Sur les deux autres machines,toutes deux fonctionnelles à la n de l'algorithme, l'une aura reçu deux votes initiaux (0 et 1)et votera donc 0, l'autre aura reçu un seul vote (à 1) et votera donc 1.

5.4.2 Une solution

Considérons l'algorithme suivant, dont certaines opérations sont clariées après l'algorithme.

56

1 V[0] =

2 V[1] = (identifiant, vote initial)

3 pour j = 1 .. f+1:

4 N = V[j] - V[j-1]

5 pour k = 1 .. nombre de voisins

6 emettre(k,N)

7 synchro

8 recevoir

9 V[j+1] = V[j]

10 pour chaque V reçu:

11 V[j+1] = V[j+1] union V

12 vote = calcul(V[f+1])

13 emettre(R, vote)

L'entier f est un paramètre xé avant le déploiement de l'algorithme. On considère chaqueV[j] comme un ensemble (sans répétition, donc) et l'opération - de la ligne 4 correspond à ladiérence entre les deux ensembles. La fonction calcul de la ligne 12 applique n'importe quellerègle déterministe qui choisit une valeur parmi celles de l'ensemble fourni en argument (parunanimité, majorité, ...). Nous allons établir en exercice que cet algorithme résout le consensusdistribué en tolérant f pannes.

5.4.3 Exercices

Exercice 4 FF Revenons sur l'algorithme unanimité discuté en section 5.4.15.4.1.

a. Décrire une panne qui fait échouer l'algorithme unanimité dans un systèmede 1001 machines.

b. Est-ce possible de faire en sorte que la panne produise des votes naux équilib¯esentre 0 et 1 ? (Autrement dit, sur les 1000 machines fonctionnelles à la n,exactement 500 votent 0 et 500 votent 1.)

c. Même question qu'au (a) si on remplace la ligne 5 par une règle de majorité.

d. Même question qu'au (a) si chaque machine émet son vote initial et son iden-tiant, et que l'on choisisse le vote de la machine d'identiant maximal.

Exercice 5 F Examinons le fonctionnement de l'algorithme de la section 5.4.25.4.2pour 3 machines d'identiants 1, 2 et 3 et de votes initiaux 0, 1 et 0, respectivement.

a. Supposons que l'algorithme soit exécuté sans panne avec f= 0. Que vaut V [2]sur chacune de ces machines ? Est-ce qu'un consensus est trouvé quel que soitcalcul ?

b. Supposons maintenant que l'algorithme soit exécuté avec f= 0 et que la machine3 tombe en panne à la ligne 6 pour j = 1 entre les valeurs de k = 1 et k = 2(c'est-à-dire qu'elle transmet son N uniquement à la machine 1). Que vautV [2] pour les machines 1 et 2 ? Proposez une règle de calcul pour laquelle leconsensus échoue.

c. Supposons maintenant que l'algorithme soit exécuté avec f= 1 et que la machine3 tombe en panne au même point qu'à la question (b). Que vaut V [3] pour lesmachines 1 et 2 ? Est-ce qu'un consensus est trouvé quel que soit calcul ?

57

Exercice 6 FF Prouvons maintenant que l'algorithme de la section 5.4.25.4.2 résoutle consensus distribué en tolérant f pannes. On écrit V 1[i], V 2[i], . . . pour la valeurde V [i] dans la machine 1, 2, . . .

a. Supposons qu'il y ait un élément de la forme (3, ·) dans V 1[f+1] mais pas dansV 2[f + 1]. Montrer que la machine 3 a subi une panne. Peut-on préciser à quelpoint du programme cette panne a du se déclencher ?

b. Soit 2 ≤ t ≤ f + 1. Prouver que si aucune machine ne tombe en panne entreles lignes 4-7 pour j = t, alors à la n du programme, toutes les machinesfonctionnelles ont même ensemble V [t+ 1].

c. En déduire que pour t ≥ 1, si deux machines ont des valeurs diérentes deV [t+ 1], alors au moins t machines ont subi une panne.

d. En conclure que l'algorithme ci-dessus résout le consensus en tolèrant f pannes.

5.5 Et pour quelques exercices de plus

Exercice 7 FFF Montrez qu'il n'existe pas d'algorithme déterministe qui résoutle problème de l'élection dans le modèle synchrone à réseau complet, pour un nombrepair de machines indistinguables.

Indication. Un couplage parfait dans un graphe G = (V,E) est un ensemble d'arêtes

(c'est-à-dire un sous-ensemble de E) tel que tout sommet (c'est-à-dire élément de V )

appartient à exactement une arête. Un théorème de Zsolt Baranyai énonce que pour

tout n ≥ 2 pair, il est possible de décomposer le graphe complet à n sommets en une

union disjointe de couplages parfaits.

58

Chapitre 6

Consensus et élection en calculdistribué asynchrone

Cette sixième séance s'intéresse aux systèmes distribués asynchrone à réseau. Nous allons ànouveau nous intéresser aux problèmes d'élection et de consensus.

6.1 Modèle asynchrone à réseau

Commençons par préciser le modèle de calcul distribué asynchrone que l'on va utiliser. Lesprincipes généraux sont les mêmes que pour le modèle distribué synchrone étudié au chapitre 55.En particulier, chaque machine eectue un calcul prescrit par un programme, le même pourtoutes les machines, et peut communiquer avec ses voisines dans le graphe modélisant le réseau.

Une exécution d'un programme sur un système distribué asynchrone se décompose en uneséquence d'événements élémentaires, chaque événement étant soit la réalisation d'un pas decalcul par une des machines, soit le départ ou l'arrivée d'un message. Les pas de calcul réaliséspar une machine sont traités dans l'ordre prescrit par l'algorithme. En revanche, l'ordre danslequel se produisent des événements liés à deux machines est a priori arbitraire.

Le temps de livraison de chaque message est ni (les messages ne se perdent pas) mais n'estpas borné. En particulier, la livraison de deux messages envoyés d'une machine i à une machinej peuvent prendre des temps diérents. On va supposer ici que les messages sont reçus dansl'ordre dans lequel ils ont été émis. Autrement dit, chaque canal de communication d'unemachine vers une autre se comporte comme une structure FIFO (rst in, rst out).

Puisque l'ordre global dans lequel les événements élémentaires se produisent n'est pas xé,un algorithme peut avoir plusieurs exécutions possibles sur un système distribué asynchrone.Pour prouver qu'un algorithme résout correctement un problème, il faut montrer que toutes sesexécutions possibles résolvent ce problème. Pour cela, il est généralement utile d'analyser nonpas le comportement du système dans son ensemble, mais le comportement individuel d'unemachine (pour laquelle on contrôle en partie l'ordre des événements élémentaires).

6.2 Élection asynchrone dans un réseau en anneau sans panne

Pour nous familiariser avec le fonctionnement d'un système asynchrone, revenons brièvementsur la question de l'élection dans un anneau abordée au chapitre 55 : le système distribué estconstitué de n machines à identiants uniques et à réseau en anneau. On suppose que l'anneau

59

est orienté : chaque machine a un voisin nommé gauche et un voisin nommé droite, etchaque machine est le voisin gauche de son voisin droite (et réciproquement). La version duproblème de l'élection qui nous intéresse ici est :

Élection sans panne

Entrée : Rien

Sortie :Chaque machine envoie 0 ou 1 à R.Exactement une machine doit envoyer 1.

Une solution classique au problème d'Élection sans panne dans un anneau asynchroneest l'algorithme de Lelann-Chang-Robert (LCR). Chaque machine commence par transmettreune fois son identiant à sa (machine de) droite. La propagation des messages est régie parla règle suivante : lorsqu'une machine reçoit un identiant de sa gauche, elle le compare à sonpropre identiant :

• si l'identiant reçu est le plus grand, la machine le transmet une fois à sa droite,

• si l'identiant reçu est le plus petit, la machine ne fait rien,

• si les deux identiants (propre et reçu) sont égaux, la machine se considère comme élue.

Dès qu'une machine se considère comme élue, elle fait circuler un message STOP sur le réseauet envoie 1 à R, puis termine. Toute machine qui reçoit un message STOP de la gauche lefait suivre à droite, puis envoie 0 à R avant de terminer. On peut traduire cela en pseudo-codecomme suit :

1 transmettre(droite, identifiant)

2 best = identifiant

3 m = recevoir(gauche)

4 si m>best:

5 best = m

6 transmettre(droite, best)

7 si m == identifiant:

8 transmettre(droite, "STOP")

9 transmettre(R, 1) et terminer

10 si m == "STOP":



13 retourner à la ligne 3

Esquissons une preuve de la correction de l'algorithme LCR. Numérotons les machines de 1à n, de sorte que la voisine de droite de la machine i est de numéro i+ 1 mod n. Notons [a, b]l'ensemble [a, a+1, . . . , b] dans Z/nZ. (Ainsi, [2, 5] = 2, 3, 4, 5 et [5, 2] = 5, 6, . . . , n, 1, 2.) No-tons imax l'indice de la machine d'identiant maximum. La preuve de correction de l'algorithmeLCR découle des propriétés suivantes (qui se prouvent par récurrence) :

a. Pour tout i 6= imax, pour tout j ∈ [imax, i − 1], la variable best de la machine j ne vautjamais i.

b. Pour tout i 6= imax, au bout d'un temps ni, la variable best de la machine i vaut imax.

La propriété (a) permet d'établir qu'aucune machine à part celle d'identiant maximal ne peutenvoyer 1 à R. La propriété (b) permet d'établir qu'au bout d'un temps ni, la machine d'iden-tiant maximal enverra bien 1 à R.

60

6.3 Consensus asynchrone, Paxos et théorème FLP

Pour le reste de ce chapitre, nous allons nous concentrer sur le problème du consensus dis-tribué en présence de pannes :


Entrée : Chaque machine a un vote initial valant 0 ou 1

Sortie :




Nous avons étudié un algorithme qui résout ce problème dans le modèle synchrone en tolérantun nombre f de pannes xé a priori. Pour le modèle asynchrone il s'avère que cet algorithmeéchoue. Plus généralement, Fischer, Lynch et Paterson ont établi dans les années 1980 qu'aucunalgorithme ne peut résoudre ce problème.

Théorème 5 (Théorème FLP). Il n'existe pas d'algorithme asynchrone résolvant Consensustolérant aux pannes et tolérant une faute.

Dans la pratique, les instances de consensus distribué asynchrone à résoudre ne manquent pas(par exemple dans le secteur des bases de données). De nombreuses solutions industrielles 11

sont basées sur un algorithme appelé Paxos développé par Lamport à la n des années 1990.L'algorithme Paxos tolère des pannes et lorsqu'il termine le consensus qu'il propose est correct ;le hic est qu'il peut ne pas terminer, au sens où il existe un ordonnancement des pas de calculsqui le fait tourner indéniment .

6.4 L'algorithme Paxos

Commençons par étudier l'algorithme Paxos.

6.4.1 Rôles, dates et choix

Paxos est constitué de trois sous-algorithmes indépendants :

- Les proposeurs (proposers) peuvent proposer une valeur de consensus.

- Les accepteurs (acceptors) peuvent accepter une valeur de consensus.

- Les scribes (learners) peuvent prendre acte qu'un consensus a été trouvé.

Ces trois rôles échangent des messages entre eux. Chaque machine du système peut jouer un ouplusieurs rôles, on parle donc de processus. (En cas de confusion, on peut supposer que chaquemachine joue exactement un des rôles, c'est à dire exécute un seul processus.) L'algorithme estprévu pour un système fermé, donc on peut supposer connu le nombre de processus de chaquerôle.

La plupart des messages échangés contiennent un paramètre n, que l'on appelle proposal

number. Ce paramètre est à valeurs dans N et peut varier d'un message à l'autre. Intuitivement,ce paramètre sert à donner un semblant de mesure du temps , notion qui n'a pas de sens dansun système asynchrone (les machines n'ont pas d'horloge commune).

1. C.f. https://en.wikipedia.org/wiki/Paxos_(computer_science)#Production_use_of_Paxoshttps://en.wikipedia.org/wiki/Paxos_(computer_science)#Production_use_of_Paxos

61

https://en.wikipedia.org/wiki/Paxos_(computer_science)#Production_use_of_Paxos

Certains des messages échangés contiennent un paramètre v, que l'on appelle proposal va-

lue. Ce paramètre représente une proposition de vote nal et est donc, pour le problème deConsensus tolérant aux pannes qui nous intéresse, à valeurs dans 0, 1. Il se trouve quel'algorithme se généralise trivialement à un ensemble arbitraire de choix (par exemple pours'accorder sur un tarif du KW/h dans un réseau électrique local intelligent).

6.4.2 L'algorithme, en résumé

Dans Paxos made simple, Lamport résume l'idée de Paxos comme l'organisation d'échangesen deux temps entre un proposeur et des accepteurs :

Préparation.

1a. A proposer selects a proposal number n and sends a prepare request withnumber n to a majority of acceptors.

1b. If an acceptor receives a prepare request with number n greater than that ofany prepare request to which it has already responded, then it responds to therequest with a promise not to accept any more proposals numbered less thann and with the highest-numbered proposal (if any) that it has accepted.

Proposition.

2a. If the proposer receives a response to its prepare requests (numbered n) froma majority of acceptors, then it sends an accept request to each of those ac-ceptors for a proposal numbered n with a value v, where v is the value ofthe highest-numbered proposal among the responses, or is any value if theresponses reported no proposals.

2b. If an acceptor receives an accept request for a proposal numbered n, it acceptsthe proposal unless it has already responded to a prepare request having anumber greater than n. Whenever an acceptor accepts a proposal, it sends amessage to all learners, sending them the proposal.

Chaque proposeur travaille indépendamment des autres, et un accepteur peut donc recevoir desrequêtes indépendantes de diérents proposeurs. Précisons quelques points :

a. a majority of acceptors doit être compris comme strictement plus de la moitié desaccepteurs .

b. Si un proposeur ne reçoit pas de réponse de la part d'un accepteur dans un délai xé(appelé timeout), il considère que la réponse est négative.

c. Si un proposeur échoue à obtenir une majorité de réponses positives à une prepare request,il recommence en 1a avec un strictement n plus grand.

d. Un proposeur peut abandonner une proposition en cours, à n'importe quel moment. Pourcela, il sut qu'il initie une nouvelle proposition et d'ignorer toute réponse à la précédente.

e. Le comportement décrit ci-dessous pour un proposeur est en fait celui de chaque propo-seur. Autrement dit, les proposeurs sont en compétition pour obtenir les engagements desaccepteurs.

f. Un accepteur peut accepter plusieurs propositions de choix.

g. Le fait qu'il y ait plusieurs accepteurs n'est utile que pour résister aux pannes : en l'absencede pannes, Paxos fonctionne correctement avec un unique accepteur.

h. Lorsqu'un scribe apprend que plus de la moitié des accepteurs ont accepté une valeur v, ilreporte que cette valeur v comme résultat du consensus.

62

6.4.3 Exercices

Décortiquons le fonctionnement de Paxos au travers de quelques exercices.

Exercice 1 FFF La description de Lamport entremêle ce que font les diérentsrôles. Séparez cela en donnant pour chaque rôle l'algorithme qu'il doit exécuter. (Cecireprésente un travail substantiel et demande de bien comprendre l'algorithme.)

Exercice 2 FF Donnez un exemple d'exécution dans laquelle des messages sontéchangés mais les scribes n'enregistrent aucun progrès dans la formation d'un consen-sus.

Exercice 3 FFF On établit maintenant la propriété suivante pour tous n0 < n1 :

P (n0 → n1) : si une majorité d'accepteurs accepte une accept request deproposal number n0 et de valeur v0, alors toute accept request émise avecun proposal number n1 > n0 est aussi de valeur v0.

Notez que P (n0 → n1) ne fait aucune hypothèse sur l'ordre chronologique dans lequelles deux accept request sont émises.

a. Considérons un accepteur A qui accepte, à un instant T , une prepare request deproposal number n. Est-ce que le choix accepté par A de plus grand proposal

number < n peut changer après T ? Justiez votre réponse.

b. Prouvez P (n0 → n0 + 1).

c. Prouvez P (n0 → n1) pour tous n0 < n1.

Correction. La propriété P (n0 → n1) ci-dessus implique qu'à partir du moment où un pro-poseur a réussi à faire accepter à une majorité d'accepteur le choix d'une valeur v lors d'uneaccept request, deux propriétés sont vraies :

(i) Tout accepteur ayant choisi v ne change plus d'avis. (Notons, cependant, qu'il peut accepterde nouvelles accept request de proposal number plus grand, mais ces requêtes doivent avoirmême valeur v.)

(ii) Tout accepteur qui n'a pas choisi v ne reçoit plus de proposition de choisir autre choseque v.

Ainsi, si l'algorithme progresse au sens ou les accepteurs continuent à recevoir des accept request,alors il progresse forcément vers un consensus.

Exercice 4 FF

a. Supposons que l'on ait déployé Paxos sur un système formé de p + a + smachines distinctes, chaque machine remplissant un seul rôle : il y a p propo-seurs, a accepteurs et s scribes. Combien de pannes de chaque type de machinesPaxos supporte-t-il ?

b. Supposons maintenant que l'on ait déployé Paxos sur un système formé dem machines distinctes, chaque machine remplissant les trois rôles. Combien depannes Paxos supporte-t-il ?

c. Proposez un ensemble d'informations, aussi minimal que possible, dont l'archi-vage permet une panne avec redémarrage sans perturber l'exécution de Paxos.

63

6.4.4 Variantes et améliorations

Pour conclure cette présentation de Paxos, soulignons que nous n'avons fait qu'eeurer lapartie émergée d'un iceberg. La version de base étudiée ici a été largement améliorée, optimiséeet adaptée à diérents cadres applicatifs : accélération de la progression, réduction du nombrede messages échangés, prise en compte de pannes Byzantines, analyse des rôles optimisant unparc de machine inhomogène, etc. Pour cette raison, on parle plutôt de la famille d'algorithmes

Paxos (tout comme on parle de la méthode du simplexe).

6.5 Impossibilité du consensus asynchrone avec une panne

Nous allons maintenant esquisser la preuve du théorème 55 : il n'existe pas d'algorithmeasynchrone résolvant le consensus distribué et tolérant une faute. L'objectif est de saisir les idéesprincipales de la preuve et, dans une certaine mesure, leur portée. Pour la preuve complète, onrenvoit à la source :

Fischer, M.J., Lynch, N.A. and Paterson, M.S., 1985. Impossibility of distributedconsensus with one faulty process. Journal of the ACM (JACM), 32(2), pp.374-382.

Disponible librement en version rapport de recherche.

6.5.1 Le vocabulaire

Pour prouver le théorème FLP, il faut raisonner sur les déroulements possibles d'un calculdistribué asynchrone, ce qui requiert de formaliser précisément un tel calcul. Une telle formali-sation dépasse le cadre de ce cours, aussi on se contente d'identier les notions correspondanteset d'en donner uen intuition.

État d'une machine. On suppose déni la notion d'état d'une machine à un instant donnécomme un ensemble d'informations susant à décrire complètement sa situation interne. Parexemple, dans le cas d'une machine de Turing interactive, il s'agit de l'ensemble des règles detransition, de l'état courant dans l'automate, de la position des têtes de lecture/écriture sur lesdiérents rubans et du contenu de ces rubans s'ils ne sont pas aléatoires.

Conguration d'un système. Soit Σ un système distribué asynchrone à nmachines et réseaucomplet. On suppose que les machines sont numérotées, c'est à dire que chacune dispose d'unidentiant unique compris entre 1 et n. La conguration de Σ à un instant t∗ est la paire (e,m)où e = (e1, e2, . . . , en) avec ei l'état de la ième machine à l'instant t∗ et m est l'ensemble desmessages en transit dans Σ (c'est à dire envoyés mais pas encore reçus).

Exécution d'un algorithme. Une exécution d'un algorithme sur un système distribué asyn-chrone correspond à une suite de congurations du système qui correspond à certaines règles.En bref, si on note (e,m) et (e′,m′) deux congurations successives, on doit avoir :

- il existe 1 ≤ i ≤ n tel que ej = e′j pour j 6= i, et

- il existe un événement φ s'appliquant à ei tel que φ(ei) = e′i, et

- l'événement φ est cohérent avec le changement entre m et m′.

Un événement est un pas élémentaire de calcul du système Σ. Cela peut être la réceptiond'un message, le changement d'état, ou l'émission d'un message par une machine ; on dit quel'événement porte sur la machine réalisant l'action en question. On dit qu'un événement φ estapplicable à la conguration (e,m) si φ peut se produire lorsque le système est en conguration

64

(e,m). (Par exemple, l'événement réception du message M par la machine 1 suppose queM ∈ m.) Si un événement φ est appliquable à (e,m), on note φ(e,m) la conguration danslaquelle le système se trouve immédiatement après φ s'il était en (e,m) immédiatement avant.

Graphe d'accessibilité. Il est pratique de dénir un graphe orienté G dont les sommets sontles congurations possibles de Σ, et dont les arêtes sont les paires ((e,m), (e′,m′)) telles qu'ilexiste un événement φ avec φ(e,m) = (e′,m′). On dit alors qu'une conguration (e′,m′) estaccessible depuis (e,m) s'il existe un chemin de (e,m) à (e′,m′) dans G.

6.5.2 Exercices

Exercice 5 F On considère l'algorithme LCR vu à la section 6.26.2, qui résout leproblème de l'élection dans un anneau de machines à identiant unique

1 transmettre(droite, identifiant)

2 best = identifiant

3 m = recevoir(gauche)

4 si m>best:

5 best = m

6 transmettre(droite, best)

7 si m == identifiant:



10 si m == "STOP":



13 retourner à la ligne 3

a. Proposez une description de l'état d'une machine qui sut à décrire l'exécutionde cet algorithme.

b. Décrivez la conguration initiale du système.

c. Décrivez l'ensemble des événements pouvant être le premier événement d'uneexécution.

d. Quel est l'ordre de grandeur du nombre de sommets du graphe G induit par lanotion de conguration que vous avez proposé.

Exercice 6 FF Soit (e,m) l'état d'un système distribué Σ. Soient φi et φj deuxévénements qui s'appliquent à (e,m) et s'appliquent à des machines diérentes. Mon-trer que φi φj(e,m) = φj φi(e,m).

Exercice 7 FF On va maintenant mettre en place la base de la preuve du théorèmeFLP. Supposons, par l'absurde, qu'il existe un algorithme A qui résout le consensus,et plus spéciquement :

65



Sortie :




a. On suppose xées les notions d'état d'une machine et de conguration du sys-tème. Combien existe-t-il de congurations initiales du système ?

Deux congurations initiales sont voisines si elles dièrent dans l'état d'exactementune machine. On dénit un graphe auxiliaire H (distinct de G) comme suit : lessommets de H sont les congurations initiales et les arêtes de H sont les paires decongurations initiales voisines.

b. Dessinez H pour n = 2 et n = 3 machines.

c. Décrivez le graphe H pour n quelconque.

Une conguration de Σ est nale si elle est accessible depuis au moins une congu-ration initiale et si toutes les machines y ont émis leur vote nal. Dans une congu-ration nale, toutes les machines ont le même vote nal puisque l'algorithme résoutle consensus ; la conguration nale vaut 0 ou 1 selon la valeur de ce vote nal.Une conguration (e,m) est 0-valente si toutes les congurations nales accessiblesdepuis elle valent 0. On dénit de même les congurations 1-valentes.

d. Décrivez une conguration initiale 0-valente et une conguration initiale 1-valente.

Une conguration (e,m) est bivalente si elle n'est ni 0-valente, ni 1-valente.

e. Démontrez que si aucune conguration initiale n'est bivalente, alors il existedeux congurations initiales voisines, l'une 0-valente et l'autre 1-valente.

6.5.3 Une panne peut provoquer de la bivalence, qui se propage

Continuons l'analyse amorcée à l'exercice 7. Lorsqu'une panne survient sur la ième machine,cela a trois eets :

• L'ensemble des congurations change : on supprime des congurations l'état de la ièmemachine. On transforme la conguration courante au moment de la panne en supprimantl'état de la ième machine.

• Les congurations qui étaient non-nales car seul le vote nal de la ième machine manquaitsont désormais considérées comme nales.

• On ne peut plus appliquer au système aucun événement s'appliquant à la ième machine.(On peut toujours, en revanche, faire arriver des messages envoyés par la ième machineavant sa panne.)

Cela conduit naturellement à réviser les notions de 0-/1-/bivalence. La première idée clef de lapreuve de FLP est qu'une panne sut à produire une conguration bivalente.

66

Proposition 6. Pour tout algorithme, le système a une conguration initiale bivalente, éven-

tuellement après une panne.

Idée de preuve. Supposons que le système n'a pas de conguration initiale bivalente (sans quoil'énonc'est trivialement vrai). Comme on l'a vu à l'exercice 7e, il existe alors deux congurationsinitiales voisines, I et J , qui sont respectivement 0-valente et 1-valente. Puisqu'elles sont voisines,I et J dièrent par l'état d'exactement une machine, disons i. Une panne de la ième machinetombe en panne dès le début de l'algorithme, provoque l'identication des congurations initialesI et J en une nouvelle conguration initiale qui s'avère bivalente.

La seconde idée clef de la preuve de FLP est que la bivalence peut se perpétuer :

Proposition 7. Pour toute conguration bivalente (e,m), il existe toujours une autre congu-

ration bivalente (e′,m′) accessible depuis (e,m).

Le théorème 55 découle immédiatement des propositions 66 et 77 : pour tout algorithme, il existeune entrée bivalente (quitte à supposer une panne bien choisie) et une suite d'événements quimaintient le système dans une conguration bivalente et l'empêche donc d'atteindre une con-guration nale.

La preuve de la proposition 77 est un peu technique. Fixons φ un événement qui peut s'appli-quer à (e,m). Notons C l'ensemble des congurations accessibles depuis (e,m) sans appliquer φ.Le modèle asynchrone autorise à ce que tout message soit retardé arbitrairement longtemps. Celaassure que φ est applicable à toute conguration de C. Notons D

def

= φ(e′,m′) : (e′,m′) ∈ C.

Lemme 8. D contient une conguration bivalente.

Idée de preuve. On raisonne par l'absurde. Supposons que D ne contienne pas de congurationbivalente.

On commence par montrer que D contient à la fois des congurations 0-valentes et descongurations 1-valentes. Il existe deux congurations E0 et E1, respectivement 0-valente et 1-valente, accessibles depuis (e,m). Si Ei ∈ C alors on pose Fi

def

= e(Ei) ∈ D. Sinon, Ei est obtenuen appliquant φ et est donc soit dans D, auquel cas on pose Fi

def

= Ei, soit accessible depuis uneconguration Fi ∈ D. Dans les deux cas, Fi appartient à D et est i-valente (dans le second cas,la i-valence découle de l'hypothèse que D n'a pas de conguration bivalente).

On prouve ensuite que C contient deux congurations C0, C1 telles que (i) φ(Ci) est i-valentepour i = 0, 1 et (ii) on peut passer d'un Ci à l'autre par un seul événement φ′. Par symmétriedes rôles, supposons que φ′(C0) = C1.

Si φ et φ′ portent sur des machines diérentes, elles commutent. On a alors que

D1 = φ(C1) = φ(φ′(C0)) = φ φ′(C0) = φ′ φ(C0) = φ′(D0),

ce qui est impossible car appliquer un événement à une conguration 0-valente ne peut pasproduire une conguration 1-valente. Si φ et φ′ portent sur la même machine, une analysesimilaire (mais un peu plus délicate) permet de conclure.

Le lemme 88 sut à établir la proposition 77 puisque la conguration bivalente contenue dansD est accessible depuis (e,m) en au moins une étape de calcul.

67

6.5.4 Un théorème c'est bien, une preuve c'est encore mieux

La preuve du théorème FLP repose sur deux idées. D'une part, une panne sut à produirede la bivalence. D'autre part, si un état initial est bivalent alors il existe une séquence nie nonvide de pas de calcul qui mène à un autre état bivalent. On peut en tirer diverses conséquencesfaciles mais qui ne découlent pas du seul énoncé du théorème, par exemple :

• Le théorème FLP n'exclue pas l'existence d'un algorithme pour le consensus qui, en pré-sence de pannes, est correct quand il termine, mais risque de ne jamais terminer. C'est parexemple le cas de Paxos.

• Si un algorithme est correct sans panne et termine en temps ni, alors le résultat ne peut

pas dépendre de l'exécution. En eet, il faudrait pour cela qu'un état initial soit bivalent, etd'après la proposition 77, il existerait alors une exécution au cours de laquelle l'algorithmene termine pas.

D'où mon mot de la n :

On gagne beaucoup à ne pas accepter un théorème comme un fait, mais àcomprendre au moins l'idée générale de sa preuve.

Remarquons que comprendre l'idée d'une preuve peut se faire en laissant de côté certains détailstechniques. Ici, ne pas tout comprendre dans la preuve du lemme 88 ne nous a pas gêné.

68

Chapitre 7

Pannes Byzantines

Récapitulons les enseignements des chapitres 5 et 6 concernant le problème de consensus :

• d'une part (séance 5), pour tout f , il existe un algorithme distribué synchrone qui résoutle consensus et tolère jusqu'à f pannes,

• d'autre part (séance 6), il n'existe pas d'algorithme distribué asynchrone qui résout leconsensus et tolère ne serait-ce qu'une panne. L'algorithme Paxos est une méthode na-lement assez simple (si si !) pour chercher un consensus asynchrone et tolérer les pannes,mais il ne termine pas toujours.

Cette septième et dernière séance compléte ce panorama en abordant la question de l'obtentiondu consensus synchrone en présence de pannes Byzantines. Soulignons le : on se place tout aulong de cette séance dans un cadre synchrone. L'objectif de la séance est de comprendre lesidées derrière le résultat suivant :

Théorème. Il n'existe pas d'algorithme déterministe qui résout le problèmedu consensus dans un système distribué à réseau complet pour n machines dont aumoins n/3 sont Byzantines.

On utilise des guillements car tel quel, cet énoncé laisse implicite (i) ce que signie obtenir unconsensus lorsque certaines machines sont Byzantines, et (ii) le modèle d'algorithmes considérés.Nous préciserons ces points au fur et à mesure pour obtenir la version formelle de ce résultat, leThéorème ??.

7.1 Notion de panne Byzantine

Une machine dans un système distribué a un comportement Byzantin si elle ne se comportepas conformément à l'algorithme. Cela peut être dû à un problème technique (défaillance d'undes ports de communication par exemple) ou à un comportement malicieux (prise de contrôlede la machine et modication du programme par un tiers malveillant). Lorsque l'on modélise unsystème où des comportements Byzantins sont possibles, on dit qu'une machine est able si ellese comporte conformément à l'algorithme.

L'analyse d'algorithmes distribués en présence de comportements Byzantins a été originel-lement proposé via une métaphore poliorcétique dont voici une version. Une armée fait le sièged'une ville. L'armée est dirigée par un général et organisée en divisions, chacune dirigée par uncolonel. Les colonels peuvent communiquer entre eux et avec le général par l'intermédiaire demessagers. Parmi le général et les colonels, certains sont déloyaux (c'est à dire qu'ils sont passésà l'ennemi).

69

Le général envoie un ordre (attaquer ou se retirer) à chacun de ses colonels. Chaquecolonel doit décider si sa division attaque ou se retire. Les colonels loyaux doivent résoudre, demanière distribuée, le problème suivant :

a. Les colonels loyaux doivent prendre la même décision. En eet, si seule une partie d'entreeux attaque ils vont se faire tailler en pièces.

b. Si le général est loyal, alors les colonels loyaux doivent obéir à son ordre. On note qu'ungénéral loyal donnera le même ordre à tous ses colonels.

Chaque colonel doit prendre sa décision seul, mais peut communiquer avec les autres colonels.On souhaite un algorithme standard que chaque colonel loyal puisse suivre an d'atteindre cetobjectif.

Un réexe naturel lorsque l'on aborde le problème des généraux Byzantins est de chercherà démasquer les participants (général ou colonels) déloyaux. Pour voir que cela est dicile,supposons que le 1er colonel reçoive les messages suivants :

• Le général donne l'ordre d'attaquer.

• Le 2ème colonel dit que le général lui a donné l'ordre de se retirer.

Il y a manifestement de la déloyauté... mais sans plus d'information on ne sait dire si elle vientdu général (qui a donné des ordres contradictoires pour diviser ses forces) ou du 2ème colonel(qui a bien reçu l'ordre d'attaquer mais prétend le contraire). Sans plus d'information, il estimpossible de déterminer qui ment.

7.2 Consensus distribué Byzantin et cohérence interactive

Un algorithme distribué résout un problème en tolérant b pannes Byzantines si pour toutchoix de ≤ b machines, et pour tout choix d'un comportement Byzantin adopté par chacunede ces machines, le résultat du calcul est correct. (Précisons que les comportements Byzantinspeuvent être diérents.) Le problème de consensus étudié à la séance 5 avait été formalisé commesuit :



Sortie :




Soulignons que du point de vue du système, une machine non-able peut apparaître commefonctionnelle. Il s'avère qu'aucun algorithme ne peut résoudre ce problème en tolérant ne serait-

ce qu'une panne Byzantine. Voyons cela sur un exemple (le cas général sera traité en exercice).

Considérons l'algorithme d'unanimité discuté en séance 4. Le voici reformulé (à gauche)accompagné d'une version modiée (à droite) que pourrait, par exemple, exécuter une machineByzantine.

70


2 synchro

3 recevoir

4 si un des votes initiaux vaut 0

5 emettre(R, 0)

6 sinon

7 emettre(R, 1)

8 terminer


2 synchro

3 recevoir

4 si un des votes initiaux vaut 0

5 emettre(R, 1)

6 sinon

7 emettre(R, 0)

8 terminer

Remarquons que dans toute exécution, les votes naux sont diérents pour les machines ableset pour la machine Byzantine, faisant ainsi échouer le consensus classique.

Dans cet exemple, le comportement Byzantin utilisé n'empêche pas les machines ables derésoudre le problème entre elles. Ainsi, si le consensus avait pour but de décider ou non d'inclureun nouveau bloc dans une blockchaine, toutes les machines ables se retrouveront bien avec lemême résultat. C'est l'objectif que l'on va viser et on redénit donc le problème comme suit :

Consensus distribué Byzantin


Sortie :


a. Toutes les machines ables ont le même vote nal.

b. Si toutes les machines ables ont le même vote initial, leurvote nal égale leur vote initial.

Dans le cas où toutes les machines sont ables, on retrouve le problème formulé en séance 4.Notons que pour résoudre ce problème, il n'est pas nécessaire de déterminer quelles sont lesmachines non ables : on souhaite juste qu'elles ne puissent pas empêcher les machines ablesde se mettre d'accord.

Pour raisonner sur le consensus Byzantin, on va considérer le problème auxiliaire suivant. Onle formule à nouveau dans le cas d'un système distribué de n machines synchrones, à identiantunique et réseau complet.

Cohérence interactive

Entrée :

Chaque machine connaît le nombre n de machines du système et aun identiant unique dans 1, 2, . . . , n. Chaque machine a une valeurinitiale, choisie dans N et notée v[i] pour la ième machine.

Sortie :

Chaque machine émet un vecteur nal choisi dans Nn et tel que :

a. Les machines ables choisissent le même vecteur nal. Notons le c.

b. Si la machine d'identiant i est able, alors la ième composante dec doit valoir v[i].

Comme on va le voir (en exercice), les problèmes Consensus distribué Byzantin et Cohé-rence interactive sont essentiellement équivalents.

71

7.3 Exercices

Exercice 1FF Supposons que l'on ait 3 colonels et qu'il y ait au plus un participant(général ou colonel) déloyal. Est-ce possible de le démasquer ? Même question si ona 99 colonels et un participant déloyal.

Exercice 2 FF Donnez un exemple montrant qu'unanimité ne résoud pas leconsensus Byzantin pour 3 machines dont une Byzantine. On décrira le choix devotes initiaux des deux machines ables, la séquence de messages émis par la machineByzantine et les votes naux des deux machines ables.

Exercice 3 FF Prouvez qu'il n'existe pas d'algorithme qui résout Consensustolérant aux pannes en tolérant une panne Byzantine.

Exercice 4 FFF On considère la situation d'un système de 3 machines synchronesavec identiants uniques et réseau complet.

a. On suppose que l'on dispose d'un algorithme A qui résout Cohérence inter-active en tolérant une panne Byzantine. Donnez un algorithme B qui résoutConsensus distribué Byzantin en tolérant une panne Byzantine.

b. Réciproquement, on suppose que l'on dispose d'un algorithme B qui résoutConsensus distribué Byzantin en tolérant une panne Byzantine. Donnezun algorithme B qui résout Cohérence interactive en tolérant une panneByzantine.

7.4 Un algorithme pour la cohérence interactive

Considérons l'algorithme A1 de la Figure 7.17.1, décrit tel qu'il est déployé sur la machined'identiant i. Il devrait être clair que A1 résoud le problème de cohérence interactive en l'absencede panne. Il fait mieux :

Proposition 9. L'algorithme A1 résoud le problème de cohérence interactive pour 4 machines

en présence d'au plus une panne Byzantine.

Démonstration. Par symmétrie des rôles, on peut supposer que les machines 1, 2 et 3 sont ableset que 4 a un comportement Byzantin.

La machine 1 reçoit la valeur initiale de la machine 2 deux fois : une fois directement de 2et une fois via 3. Ainsi, l'entrée 2 du vecteur nal de la machine 1 est bien égale à la valeurinitiale de 2. Un raisonnement analogue montre que le vecteur nal de chaque machine ableaura comme entrées 1, 2 et 3 les valeurs initiales de ces machines.

À la seconde communication, les machines 1, 2 et 3 se transmettent les valeurs que leur aémis la machine 4 en première communication. Ces trois machines appliqueront donc la mêmerègle (valeur majoritaire s'il y en a une, sinon NUL) au même triplet de valeurs. Leurs vecteursnaux seront donc égaux.

72

a. Émettre (i, v[i]) à toutes les machines.

b. Constituer un tableau t[] de taille n :

• t[i] = v[i].

• pour j 6= i, t[j] est soit la valeur communiquée par la machine j, soit NUL sielle n'a rien communiqué.

c. Émettre (i, t[]) à toutes les machines.

d. Constituer un tableau f [] de taille n :

• f [i] = v[i].

• pour j 6= i, on dispose de n − 1 candidats reçus pour la valeur de v[j] : lavaleur transmise par j à la première communication et les valeurs de (k, t[j])transmises par les machines k /∈ i, j à la seconde communication. aa

Si une valeur v est majoritaire (seule valeur à ≥ 50% des candidats) on posef [j] = v, sinon on pose f [j] = NUL.

e. Choisir c[i] = f

a. Noter que pour déterminer f [j] avec j 6= i, on ne tient pas compte de la valeur (j, t[j]) transmisepar la machine j à la seconde communication (puisque l'on tient compte de la valeur transmise par j enpremière communication).

Figure 7.1 Algorithme A1, décrit tel qu'il est déployé sur la machine d'identiant i.

7.4.1 Exercices

Exercice 5 FF Prouvez que A1 ne résoud pas la cohérence interactive pour 3machines dont 1 Byzantine. On supposera que les machines 1 et 2 sont ables. Onpourra présenter la réponse sous forme d'un tableau :

Machine 1 2 3reçoit (1ère communication)vecteur t calculéreçoit (2ème communication)vecteur f calculé

Exercice 6 FF Prouver que A1 ne résoud pas la cohérence interactive pour 5machines dont 2 Byzantines. On supposera que les machines 1, 2 et 3 sont ables.

Machine 1 2 3 4 5reçoit (1ère comm.)

vecteur t calculé

reçoit (2ème comm.)

vecteur f calculé

73

7.5 Théorème d'impossibilité et le seuil d'un tiers

Dans la n de cette séance, nous allons prouver qu'aucun algorithme ne résout Cohérenceinteractive pour 3 machines en présence d'une panne Byzantine.

7.5.1 Formalisation des algorithmes de cohérence interactive

On souhaite établir que pour tout algorithme distribué, il existe un scénario d'exécution danslequel la cohérence interactive échoue. Notre première étape va être de formaliser les conceptsd'algorithme et de scénario dans ce contexte.

Notons M = 1, 2, . . . , n l'ensemble des machines et V l'ensemble des valeurs qu'ellespeuvent se communiquer (V = N par dénition, mais le résultat restera valide pour V = 0, 1).

Séquences de communications. On va modéliser les transmissions de messages avec inter-médiaires par les éléments de M∗, c'est à dire les mots sur l'alphabet M . Le mot m1m2 désigneune communication directe de m2 à m1. Le mot m1m2m3 désigne une communication de m3 àm1 via m2. Plus généralement, le mot m1m2 . . .mt de M∗ désigne une communication de mt àm1 en passant par les intermédiaires mt−1,mt−2, . . . ,m2.

Scénario. Un scénario de communication associe à chaque mot de M∗ le contenu du messageparvenant au destinataire. Formellement, un scénario est une application de M∗ dans V . Ainsi,dans un scénario α : M∗ → V , quand m2 communique directement à m1, m1 reçoit α(m1m2) etsi m3 communique à m1 ce que m2 lui a communiqué, m1 reçoit α(m1m3m2). Par convention,dans un scénario α, pour m ∈ M on interprète α(m) comme la valeur initiale que reçoit lamachine m.

Cohérence. Soit F ⊆M un sous-ensemble de machines. On dit qu'un scénario α est cohérentavec F si

∀q ∈ F,∀m ∈M,∀w ∈M∗, α (pqw) = α (qw) .

Algorithme et m-scénario. Il serait naturel de modéliser un algorithme comme une fonc-tion qui associe à tout scénario le choix nal auquel il conduit (c'est à dire le tableau c(i)lorsque l'algorithme est exécuté sur la machine i). Puisqu'une machine n'est aectée que par lescommunications dont elle est destinataire, la dénition suivante s'avèrera mieux adaptée.

Soit m ∈M . Rappelons que mM∗ est l'ensemble des mots sur l'alphabetM qui commencentpar m. Un m-scénario est une application de mM∗ dans V . Si α est un scénario, on note α|m lem-scénario obtenu en restreignant α à mM∗. Une m-exécution est une application qui associeune valeur de V à toute paire (αm,m

′) où αm est un m-scénario et m′ ∈ M . Intuitivement, siEm une m-exécution, alors Em(αm,m

′) est la valeur que m attribue à m′ dans son vecteur nalde choix si l'ensemble des communications qui parviennent à m est décrit par αm.

Cohérence interactive. Une famille Em : m ∈ M résoud la cohérence interactive avec bpannes Byzantines si pour tout F ⊆M avec |F | ≥ m− b, et chaque scénario α cohérent avec F ,

∀p, q ∈ F, Ep(α|p, q) = α(q). (7.1)

∀p, q ∈ F,∀r ∈M, Ep(α|p, r) = Eq(α|q, r) (7.2)

74

Autrement dit, si p et q sont des machines ables (dans F ), alors la valeur que p décide pour qégale la valeur initiale de q, et les valeurs que p et q décident pour toute machine r (able oupas, donc dans M) sont égales.

7.5.2 Exercices

Exercice 7 F Quels sont les mots deM∗ qui modélisent des communications ayantlieu au cours de l'algorithme A1 ?

Exercice 8 FF On cherche à traduire en scénario le déroulement de A1 pour troismachines. On ne dénira le scénario que sur les mots modélisant des communicationsayant lieu dans A1.

a. Donnez l'unique scénario possible quand les trois machines sont ables.

b. Donnez un scénario possible quand une des machines est Byzantine et où lacohérence interactive échoue.

c. Donnez le 1-scénario obtenu par la restriction du scénario que vous avez proposépour modéliser le comportement de A1.

d. Donnez la 1-exécution modélisant A1. On ne s'intéressera qu'aux mots modéli-sant des communications ayant lieu dans A1.

e. Prouvez que la famille Em : m ∈M correspondant à l'algorithme A1 ne résoudpas la cohérence interactive avec 1 panne Byzantine pour |M | = 3, au sens dénici-dessus.

7.6 Énoncé et preuve du théorème d'impossibilité

Nous pouvons enn énoncer précisément le théorème d'impossibilité, dû à Lamport, Peaseet Shostak.

Théorème 10. Pour |V | ≥ 2 et |M | ≤ 3b, il n'existe pas de famille Em : m ∈ M qui résoudla cohérence interactive avec b pannes Byzantines.

Le reste de cette section prouve le théorème 1010 pour |M | = 3 et b = 1. Notons M = a, b, c etnotons v, v′ deux éléments distincts de V .

7.6.1 Trois scénarii

On dénit trois scénarii α, β et γ comme suit.

a. Pour tout mot w ∈M∗ qui ne termine pas par c, on pose

α(w) = β(w) = γ(w)def

= v.

b. Pour w ∈M∗c, on dénit α(w), β(w) et γ(w) récursivement.

(a) On initialise la récursion en dénissant directement les scenarii sur les mots de lon-gueur 1 et 2 :

α(c) = α(ac) = α(bc) = α(cc)def

= v

β(c) = β(ac) = β(bc) = β(cc)def

= v′

γ(c) = γ(ac) = γ(cc)def

= v et γ(bc)def

= v′

75

(b) Pour tout p ∈M et w ∈M∗c, on pose

α(paw)def

= α(aw), α(pbw)def

= β(bw), α(pcw)def

= α(cw)

β(paw)def

= α(aw), β(pbw)def

= β(bw), β(pcw)def

= β(cw)

γ(paw)def

= γ(aw), γ(pbw)def

= γ(bw), γ(acw)def

= α(cw) et γ(bcw)def

= β(cw)

Exercice 9 F Calculer :

a. α(bac), β(bac) et γ(bac).

b. α(abc), β(abc) et γ(abc).

c. α(acb), β(acb) et γ(acb).

d. α(acc), β(acc) et γ(acc).

7.6.2 Propriétés des scénarii

Les dénitions assurent que γ|a = α|a et γ|b = β|b. Autrement dit, γ se comporte comme αdu point de vue de a et comme β du point de vue de b.

Exercice 10 FF Prouver que γ|a = α|a et γ|b = β|b, c'est-à-dire que

∀w ∈M∗, γ(aw) = α(aw) et γ(bw) = β(bw).

On pourra procéder par récurrence sur la longueur du mot w.

7.6.3 Cohérence

Rappelons qu'un scénario δ est cohérent avec F ⊆M si

∀q ∈ F,∀p ∈M, ∀w ∈M∗, α (pqw) = α (qw) .

Exercice 11 F Vérier que α est cohérent avec a, c, que β est cohérent avec b, cet que γ est cohérent avec a, b.

7.6.4 Aboutissement

Supposons que Ea, Eb, Ec résoud la cohérence interactive avec 1 pannes Byzantines. Ona donc, par dénition de résoudre..., que pour tout F ⊆ M avec |F | ≥ 2, et tout scénario δcohérent avec F ,

∀p, q ∈ F, Ep(δ|p, q) = δ(q). (7.3)

∀p, q ∈ F,∀r ∈M, Ep(δ|p, r) = Eq(δ|q, r) (7.4)

(Ici, on répète simplement la dénition.) Comme α est cohérent avec a, c, pour p = a et q = cla condition (7.37.3) donne

Ea(α|a, c) = α(c) = v.

76

Chapitre 8

En guise de conclusion

Récapitulons rapidement les grandes étapes de cette rapide introductions aux principes desblockchaines.

Les blockchaines sont des bases de données qui visent à être infalsiables et distribuées. Cesdeux propriétés mettent en jeu, respectivement, des outils de cryptographie et de calcul distribué.Pour bien apprécier les garanties oertes par les blockchaines et leurs limites, il est importantd'y regarder de plus près. Autrement dit :

Les propriétés macroscopiques d'un système à base de blockchaine (niveau deconance obtenu, niveau de service, impact environnemental) sont largementinuencées par des choix techniques dont la compréhension mobilise une largegamme de domaines scientiques et techniques. Un débat éclairé des enjeux deces systèmes suppose donc une bonne compréhension de ces questions techniqueset donc de ces domaines.

L'infalsiabilité repose principalement sur deux primitives cryptographiques :

• Les fonctions de hachage cryptographiques, fonctions illégalement injectives qui envoientun espace de taille gigantesque dans un espace de taille plus modeste (0, 1232 → 0, 1256pour Sha-256), et pour lesquelles bien qu'il existe des collisions (principe des tiroirs), maison est algorithmiquement incapable d'en exhiber une (d'où un comportement de typeinjectif ).

• Les signatures cryptographiques créent une notion d'identité à base de secret partagé :toute personne connaissant le secret peut de facto faire valoir l'identité, toute la dicultéétant de concevoir un système où l'on peut prouver connaître le secret sans le divulguer.Les exemples classiques reposent sur une opération dicilement réversible, notammentl'exponentiation dans un groupe multiplicatif bien choisi (l'inverse, dicile donc, consistantalors à calculer un certain logarithme discret).

On ne sait pas prouver formellement que ces primitives cryptographiques ont eectivementles propriétés d'inviolabilité souhaitée (résistance aux collisions pour les fonctions de hachage etintractabilité pour le logarithme discret). La meilleure assurance pratique dont on dispose estque des eorts substantiels continuent à être fournis pour trouver une collision et echouent. 11

Ces outils cryptographiques sont la couche basse sur laquelle s'appuient des protocoles plussophistiqués, dont la blockchaine. La sécurité de ces protocoles plus sophistiqué est généralement

1. Cela sert aussi à cela une recherche publique nancée correctement.

79

conditionnelle : au mieux, on sait montrer que l'existence d'une attaque sur le protocole impliquel'existence d'une attaque sur une des primitives qu'il utilise. Dans de nombreux cas, un manquede soin laisse des attaques béantes, comme on l'a vu avec l'exemple de l'attaque par extensionde longueur. On a souligné au passage l'importance d'une source d'aléa able (comme on l'a vu,même l'aléa utilisé pour appliquer une fois une signature de Schnorr est critique).

Le caractère distribué exige de savoir résoudre les problèmes de l'élection et du consensusdans le système envisagé (synchrone ou asynchrone, ouvert ou fermé, sur un réseau d'une certainetopologie, . . . ). L'univers de blockchaines a été bouleversé par l'irruption de la blockchainedu bitcoin (rapidement imitée par de nombreuses autres cryptomonnaies). Cette blockchaines'appuie de manière standard sur les outils cryptographiques classiques et se distingue par unesolution originale des problèmes de calcul distribué. D'une part, l'élection est résolue par uneméthode de preuve de travail dont l'élégance cache malheureusement un coût énergétique quelquepeu décorrellé du service rendu. D'autre part, le consensus est réalisé probabilistiquement, auprix d'une réversibilité partielle (d'autant moins probable que les décisions prises sont anciennes).

Le déploiement de blockchaines sans preuve de travail requiert d'apporter de nouvelles solu-tions aux problèmes de consensus et d'élection. Sans autre contrainte, les solutions envisageablesà ces problèmes sont déjà très limitées par plusieurs résultats forts d'impossibilité algorithmique(théorèmes FLP et des généraux Byzantins notamment). Des solutions algorithmiques existentnéanmoins, par exemple Paxos. Le contexte spécique des blockchaines peut ajouter des exi-gences supplémentaires, par exemple d'équité dans l'élection entre les diérentes machines dusystème, dont l'étude demanderait des développements spéciques. Faute de temps, on n'a pasnon plus abordé d'autres sujets importants comme les algorithmes de consensus dans un environ-nement avec identité, où les messages peuvent être signés. Tout cela forme la base des approchesvisant à dépasser les preuves de travail telles que les preuves d'enjeu.

80

Annexes

81

Annexe A

Quelques repères en complexité

Il va nous être utile de modéliser ce qu'il est possible de calculer sur un ordinateur. Clarionsdès à présent que certains problèmes qui semblent pourtant bien posés n'ont aucune solutionalgorithmique, par exemple :

10ème problème de Hilbert

Entrée :Un polynome P ∈ Z[x1, x2, . . . , xn] à n inconnues, de de-gré quelconque et à coecients entiers.

Sortie :Oui ou non, existe-t-il (x1, x2, . . . , xn) ∈ Zn tels queP (x1, x2, . . . , xn) = 0 ?

Un problème de décision (E,A) est une paire d'ensembles où A ⊆ E. Intuitivement, Eest l'ensemble des entrées possibles et A l'ensemble des entrées à accepter (i.e. pour lesquellesla décision est oui). Par exemple, dans le problème ci-dessus, l'ensemble des polynômes à

coecients entiers, n variables et degré total k est paramétrable par Z(k+nn ) ; on peut donc

prendre E =⋃

k,n∈N∗ Z(k+nn ) et A le sous-ensemble de ces entrées qui ont une racine entière.

Pour prouver des choses sur ce qui est calculable et ce qui ne l'est pas, il convient de modéliserformellement ce que signie calculer. Pour cela, un modèle largement établi et accepté est lamachine de Turing :

https://en.wikipedia.org/wiki/Turing_machinehttps://en.wikipedia.org/wiki/Turing_machine

Une machine de Turing T résout un problème de décision (E,A) si pour tout x ∈ E, lorsquel'on exécute T avec x sur le ruban initial, T termine après un nombre ni de pas de calcul, ettermine dans un état d'acceptation si et seulement si x ∈ A.

Une fois ce modèle posé, on peut étudier des questions de complexité : étant donné unproblème résoluble par machine de Turing, avec quelle ecacité peut-il être résolu ? 11 Précisonscomment est mesurée l'ecacité d'une machine de Turing sur un problème de décision (E,A)donné. On commence par associer à chaque entrée x ∈ E une taille |x|, généralement prisecomme la taille de sa représentation en mémoire. Pour toute machine de Turing T qui résout

1. On peut aussi se poser des questions de calculabilité : étant donné un problème, existe-t-il une machine deTuring qui le résout ? On ne s'intéressera que peu à cela dans ce cours.

83

https://en.wikipedia.org/wiki/Turing_machine

(E,A), et pour tout x ∈ E, on dénit CT (x) comme le nombre de pas de calculs faits par T surx avant de terminer . Ensuite on pose pour n entier CT (n)

def

= max|x|=nCT (x). C'est la fonction

de complexité de la machine de Turing. Un problème appartient à la classe P s'il existe unemachine de Turing qui le résout et dont la fonction de complexité est majorée par un polynôme.

Pour que cette complexité donne une image ne des performances d'ordinateurs modernes,il est nécessaire d'entrer dans certaines considérations techniques. Par exemple, le nombre derubans dont dispose la machine de Turing inue : on peut reconnaître les palindromes en tempsO(n) sur une machine à deux rubans, alors que sur une machine à un seul ruban la complexitéest toujours Ω(n2). En revanche, la seule appartenance à la classe P est, elle, étonnammentrobuste aux changements de détails techniques.

Une dénition possible de la classe NP (Non-deterministic Polynomial) est la suivante. Unproblème de décision (E,A) est dans NP s'il existe une machine de Turing T prenant deuxentrées (l'entrée du problème et une entrée auxiliaire) et deux polynomes a et b tels que :

• pour tous x, y, T termine sur l'entrée (x, y) en temps ≤ a(|x|),• pour tout x ∈ A, il existe y de taille ≤ b(|x|) tel que T accepte (x, y),

• pour tout x ∈ E \A, pour tout y de taille ≤ b(|x|), T refuse (x, y).

Autrement dit, toute entrée x ∈ A admet un certicat y de taille polynomial qui atteste que xdoit être accepté. Par exemple, si E représente l'ensemble des graphes nis et A le sous-ensemblesde graphes qui sont 3-coloriables, T peut être une machine de Turing qui vérie que y est bienun 3-coloriage propre de x.

On a naturellement P ⊂ NP, puisque la dénition de NP autorise la machine T à ignorer y.La question de savoir si P 6= NP est un problème fondamental en informatique théorique.

84

Annexe B

Quelques rappels d'arithmétique

Toute donnée informatique (texte, image, base de données, . . . ) peut s'écrire comme un motbinaire, et est donc interprétable comme le nombre entier dont ce mot est l'écriture binaire.Le système de signature que l'on va décrire au chapitre suivant traite les données (documents,signature, . . . ) au moyen de calcul arithmétique. Quelques rappels de calcul en nombres entierspeuvent être utiles.

Un entier a divise un entier b s'il existe un entier k tel que a = kb. Pour tous entiers a, b, onnote pgcd(a, b) le plus grand diviseur commun à a et b ; si pgcd(a, b) = 1 on dit que a et b sontpremiers entre eux. L'identité de Bézout énonce que pour tous entiers a, b il existe des entiersu, v tels que

au+ bv = pgcd(a, b).

Étant donnés a et b, on peut calculer u et v par une modication assez simple de l'algorithme

d'Euclide.

On note a mod b le reste de la division entière de a par b. Étant xé un entier n, on noteZ/nZ l'ensemble 0, 1, . . . , n− 1 muni des opérations suivantes :

a+ bdef

= (a+ b) mod n et a · b def

= (ab) mod n.

On peut vérier que c'est un anneau commutatif. Remarquons cependant que 0 peut y êtredivisible : 3 · 2 = 0 mod 6 par exemple. Les diviseurs de 0 n'admettent pas d'inverse, doncZ/nZ n'est pas un corps en général.

Un entier p est premier si ses seuls diviseurs sont 1 et lui-même. Fixons p premier et prenonsun entier 1 ≤ q ≤ p − 1. Les entiers p et q sont premiers entre eux, aussi l'identité de Bézoutassure qu'il existe des entiers u et v tels que qu+pv = 1, et ainsi q ·u = 1 mod p. Cela assure quetout élément non nul de Z/pZ a un inverse ; cet inverse peut se calculer au moyen de l'algorithmed'Euclide.

La taille d'un entier est dénie comme le nombre de chires de sa plus petite écriture bi-naire. Ainsi, l'entier cinq s'écrit 101 mais aussi 00101 ou encore 0000101 ; sa taille est 3. Plusgénéralement, tout entier n est de taille ≈ log2 n puisque 2blog2 nc ≤ n ≤ 2dlog2 ne.

Clarions la complexité du calcul de certaines opérations arithmétiques, qui s'exprime commeune fonction de la taille de ses entrées :

• On connait un algorithme de complexité polynomiale pour tester si un entier donné estpremier (autrement dit, ce problème est dans P).

85

• On ne connaît pas d'algorithme de complexité polynomiale pour factoriser un entier nonpremier donné. On n'a pas de preuve qu'il n'existe pas d'algorithme polynomial pour ceproblème.

• On ne connaît pas d'algorithme de complexité polynomiale pour calculer le logarithmediscret d'un entier x dans Z/pZ. (Ici, la taille de l'entrée est le nombre de bits de p.) Onn'a pas de preuve qu'il n'existe pas d'algorithme polynomial pour ce problème.

86

Annexe C

Formalisation des preuves à divulgationnulle de connaissance

Une Machine de Turing interactive est une machine de Turing qui dispose des rubans sui-vants : un ruban d'entrée (lecture seule), un ruban de travail, deux rubans de communication(un en lecture, un en écriture), et un ruban servant de source de bits aléatoires.

Un protocole interactif est une paire (P, V ) de machines de Turing interactives qui partagentle même ruban d'entrée, et telles que le ruban de communication en lecture de l'une est le rubande communication en écriture de l'autre. On appelle P le prouveur et V le véricateur.

Dans un protocole interactif, les machines P et V sont actives alternativement, P passantla main à V dès écriture d'un message sur le ruban rP→V (et inversement). À tout moment,P ou V peut interrompre le calcul, et lorsque V est actif il peut décider de terminer le calculen acceptant ou en refusant l'entrée. Le temps de calcul pris par (P, V ) sur une entrée x estle nombre total de pas de calcul eectués par le véricateur V au cours de toutes ses phasesd'activité.

Dans la dénition de NP, on adosse la décision d'accepter une entrée x à l'examen d'uncerticat y. L'idée d'un système de preuve interactif est de séparer les choses : P connaît y etdoit convaincre V d'accepter x. Cette connaissance de y par P n'est pas modélisée explicitement,mais remarquons que le temps de calcul pris par P n'est pas comptabilisé. On peut donc imaginerque P commence par tester préalablement tous les certicats possibles y jusqu'à en trouver unqui permette de faire accepter x.

On s'intéresse à un protocole interactif (P, V ) pour un problème de décision (E,A) qui, quandil termine sur une entrée x, le fait après un nombre de pas de calcul de V polynomial en |x|. Onmesure la qualité de (P, V ) par les critères suivants. Les probabilités sont ici prises relativementà l'aléa des sources de bits aléatoires des machines de Turing interactives concernées.

• La complétude de (P, V ) est la probabilité que P réussisse à convaincre V d'accepter xlorsque x ∈ A. On souhaite qu'elle soit forte. Formellement, on souhaite que pour tout k,pour tout x ∈ A assez grand, la probabilité que (P, V ) termine en temps polynomial en|x| et accepte x est au moins 1− |x|−k.• La abilité de (P, V ) est la probabilité qu'un prouveur P ′ (pas nécessairement P ) réussisseà convaincre V d'accepter x lorsque x /∈ A. On souhaite qu'elle soit faible. Formellement,on souhaite que pour tout k, pour tout x ∈ E\A assez grand, pour tout protocole interactif(P ′, V ), la probabilité que (P ′, V ) termine et accepte x est au plus |x|−k.

87

• La divulgation de (P, V ) est la quantité d'information qu'un véricateur V ′ (pas néces-sairement V ) peut déduire de son intéraction avec P dans un protocole (P, V ′). Cela seformalise en termes statistiques : le fonctionnement des machines de Turing étant aléatoire(puisqu'elles ont accès à une source de bits aléatoires), il s'agit de savoir si les distributiondes données sur les rubans de V ′ s'écarte substantiellement de toutes les distributions queV ′ peut calculer en temps polynomial en |x|. Nous ne formaliserons pas plus avant ; pourapprofondir, on pourra consulter :

Goldwasser, Sha, Silvio Micali, and Charles Racko. "The knowledge com-plexity of interactive proof systems." SIAM Journal on computing 18.1 (1989) :186-208.

88

Annexe D

Principe d'une analyse de cycle de vie

Une analyse de cycle de vie (ACV en abrégé, LCA en anglais pour life cycle assessment)établit un bilan quantitatif et multicritère des impacts d'un système (produit, entreprise, . . . )sur l'environnement. C'est un procédé normalisé (série ISO 14000). Nous donnons ici quelquesclefs utiles à la lecture d'une ACV, et renvoyons, pour une introduction plus détaillée et dequalité, à

https://fr.wikipedia.org/wiki/Analyse_du_cycle_de_viehttps://fr.wikipedia.org/wiki/Analyse_du_cycle_de_vie

Article scientique VS article de presse. Soulignons que contrairement à un article depresse, un article scientique doit, pour être publié, avoir été validé au travers d'un examencontradictoire indépendant et, généralement, dans une temporalité sereine. Dans le cas des ana-lyses d'impact environnemental, cette exigence est aussi valable pour les publications venantd'industriels. Cela donne à une telle source un caractère opposable.

Unité fonctionnelle. Une ACV commence par la dénition précise de l'objet d'étude. Cetobjet est ramené à une quantité de référence. Ainsi, l'ACV de la fabrication d'un tissu doitspécier sur quelle quantité de tissu l'étude porte : est-ce 1 m2, 1 m3, 1 kg, . . . ? Bien queles résultats soient convertibles, ce choix a une importance dès lors que l'on utilise l'ACV pourcomparer deux manières de remplir une fonction. Le choix de l'unité de référence est donc guidépar la fonction que l'on souhaite voir le système remplir. Dans notre exemple textile, si le tissusert à fabriquer des bâches l'unité de surface sera adaptée ; s'il sert à rembourrer des coussins,le volume est plus pertinent. Etc.

Étapes. Une ACV comporte trois étapes distinctes : l'inventaire des matières et énergies mis enjeu par le système, la traduction de cet inventaire en impact environnemental, et l'interprétationde ces résultats.

Pour établir l'inventaire, il convient de modéliser l'ensemble des ux de matière et d'énergiemis en jeux dans la production d'une unité fonctionnelle, de la collecte des matières premièresau traitement des déchets naux, en passant par les diérents usages. Le bilan est qualitatif etquantitatif.

La traduction de l'inventaire suppose de préciser la question posée. Soulignons que s'il estpossible de comparer, par exemple, les contributions à l'eet de serre du CO2 et du méthane,cette comparaison varie dans le temps, ne serait-ce qu'en raison de durées diérentes de séjourdans l'atmosphère. Ainsi, si 1 unité de méthane a le même impact que ∼ 80 unités de CO2 à

89

https://fr.wikipedia.org/wiki/Analyse_du_cycle_de_vie

horizon 20 ans, cette quantité tombe à ∼ 30 à horizon 100 ans. Les modèles utilisés pour cestraductions sont donc importants, et ils sont, sans surprise, normalisés.

Type d'analyse. Il existe deux principaux modèles d'ACV. L'ACV attributionnelle (ACV-A) examine un système installé, supposé en régime permanent et ne supposant pas de remiseen cause des chaines d'approvisionnement. L'objectif de l'ACV-A est de déterminer la part del'impact environnemental de l'existant qu'il convient d'attribuer au système étudié. Par exemple,en ACV-A, la traduction de l'énergie consommée par le système en impact environnemental peutse baser sur le mix énergétique local de la région.

L'ACV conséquentielle (AVC-C) examine un système dont la mise en place perturberaitles chaines d'approvisionnement auquel il s'adosserait, et vise à mesurer les conséquences decette installation. Par exemple, en ACV-C, la traduction de l'énergie consommée par le systèmeen impact environnemental ne se basera sur le mix énergétique local de la région que pour lesurplus d'énergie disponible, et mesurera en totalité les nouvelles sources d'énergie qu'il faudradévelopper. L'analyse conséquentielle opère à base de scénarii.

90

Introduction aux blockchains Cours électif transversal ...

Documents

Transcript of Introduction aux blockchains Cours électif transversal ...