Comprendre les blockchains en en codant une en R

Tout le monde parle de cryptomonnaies en ce moment — merci le battage autour de Bitcoin. Plus intéressant que de savoir s’il existe ou non une bulle Bitcoin, c’est de comprendre comment cette technologie fonctionne réellement et ce qu’elle permet. L’histoire de Bitcoin commence avec un livre blanc intitulé "Bitcoin: A Peer-to-Peer Electronic Cash System" en 2008. Dans ce document, l’auteur sous le nom de Satoshi Nakamoto (l’identité réelle de Satoshi fait toujours débat) présente une technologie et une idée révolutionnaires : une monnaie électronique décentralisée reposant sur ce que l’on appelle la blockchain. Depuis, l’idée s’est diffusée et s’applique aujourd’hui à de nombreux autres domaines.

J’ai découvert les blockchains lors d’une rencontre de la BlockchainSociety à Oxford. Tout le monde semblait enthousiasmé par le potentiel de cette nouvelle technologie. Et il faut reconnaître que c’est intrigant : une base de données décentralisée et infalsifiable de transactions monétaires, de contrats ou de tout autre type d’information (par exemple, des machines à voter impossibles à pirater). La promesse de la blockchain pour la communauté crypto, c’est de bouleverser des pans entiers de l’économie en réinventant la confiance, au point de ne plus avoir besoin d’intermédiaires comme les banques ou les avocats — uniquement de la puissance de la cryptographie.

Si l’idée de base est assez intuitive, comprendre le fonctionnement technique d’une blockchain est plus ardu. La semaine dernière, je suis tombé sur cet article sur R-bloggers, où BigData Doc construit une blockchain entièrement en R. Une blockchain en R n’est peut-être pas la solution la plus efficace ni la plus pratique, mais c’est un excellent moyen de saisir les principes de programmation et de cryptographie sous-jacents. Je voulais, moi aussi, bien comprendre — j’ai donc implémenté une version plus petite de la blockchain en R : « Si vous pouvez la coder, vous la comprenez forcément ».

Qu’est-ce qu’une blockchain ?

Imaginons que votre objectif soit de stocker des données de manière sécurisée. Pour cela, vous placez d’abord les données dans un conteneur — que vous appelez un bloc. Dans le cas de Bitcoin, chaque bloc contient plusieurs transactions financières. Lorsqu’il y a de nouvelles transactions (ou de nouvelles données), un nouveau bloc est créé et ajouté aux blocs précédents pour former une chaîne — la blockchain.

Voyons comment les blockchains utilisent la cryptographie pour devenir virtuellement impossibles à pirater.

1. Blocs

    block_example <- list(index = 1,
                     timestamp = "2018-01-05 17.00 MST",
                     data = "some data",
                     previous_hash = 0,
                     proof = 9,
                     new_hash = NULL)

Avant de commencer à construire la blockchain — autrement dit à chaîner différents conteneurs de données — vous devez connaître deux notions supplémentaires : le hachage et les algorithmes de preuve de travail (Proof of Work).

2. Hachage

Un hachage permet d’assurer l’intégrité d’un bloc en le reliant aux autres blocs de la chaîne. Une fonction de hachage prend quelque chose en entrée et fournit en sortie une valeur chiffrée unique. Par exemple : vous posez à votre amie l’énigme « Quel est le meilleur logiciel de statistiques : Stata ou R ? » et vous lui donnez le hachage de la bonne réponse : "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86". Elle peut vérifier seule si sa réponse est correcte en la passant dans la fonction de hachage (ici, l’algorithme SHA256) :

    library("digest")

    digest("Stata" ,"sha256") # premier essai

    ## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"

    digest("R", "sha256") # deuxième essai

    ## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"

En quoi est-ce utile ?

Ici, vous ne passez pas seulement les informations du bloc (index, horodatage, données) à la fonction de hachage, mais aussi le hachage du bloc précédent. Vous ne pouvez donc calculer un hachage valide que si vous connaissez le hachage du bloc antérieur, lui-même calculé à partir du hachage du bloc encore avant, et ainsi de suite. Cela crée une chaîne de blocs séquentielle et immuable. Si vous modifiez un bloc a posteriori, vous devez recalculer tous les hachages des blocs suivants.

    #Function that creates a hashed "block"
    hash_block <- function(block){
      block$new_hash <- digest(c(block$index,
                                 block$timestamp,
                                 block$data,
                                 block$previous_hash), "sha256")
      return(block)
    }

3. Preuve de travail

Si beaucoup d’informations doivent être stockées dans la blockchain, vous devrez créer de nombreux nouveaux blocs. Dans bien des cas, vous souhaitez contrôler le rythme de création. Pour les cryptomonnaies par exemple, une pièce perdrait de la valeur si une quantité infinie pouvait être créée chaque seconde.

On ajoute donc un algorithme dit de « preuve de travail » (Proof of Work, PoW) qui régule la difficulté de création d’un nouveau bloc. La « preuve » signifie que l’ordinateur a effectué une certaine quantité de calculs. En pratique, il s’agit de créer un élément difficile à produire mais facile à vérifier. J’utiliserai la « tâche » suivante comme PoW : trouver le prochain nombre divisible par 99 et par le nombre de preuve du dernier bloc.

    ### Simple Proof of Work Alogrithm
    proof_of_work <- function(last_proof){
      proof <- last_proof + 1

      # Increment the proof number until a number is found that is divisable by 99 and by the proof of the previous block
      while (!(proof %% 99 == 0 & proof %% last_proof == 0 )){
        proof <- proof + 1
      }

      return(proof)
    }

Dans des blockchains comme Bitcoin ou Ethereum, la création de nouveaux blocs est réalisée par des « mineurs ». Lorsqu’un nouveau bloc doit être créé, un problème de calcul est diffusé au réseau. Le mineur qui résout le problème PoW en premier crée le nouveau bloc et est récompensé en Bitcoins (c’est ainsi que de nouveaux Bitcoins sont émis). Cette « lotterie » consistant à trouver la preuve correcte garantit la décentralisation du pouvoir de création des blocs. Lorsqu’un bloc est miné, il est diffusé à tous, afin que chaque nœud du réseau dispose d’une copie à jour de la blockchain. L’idée selon laquelle la plus longue chaîne du réseau (celle dans laquelle « le plus de travail a été investi ») est la version valable de la blockchain est appelée « consensus décentralisé ».

Dans le cas de Bitcoin, le PoW consiste à trouver des nombres produisant des hachages avec un certain nombre de zéros initiaux (la meilleure explication que j’ai trouvée est cette vidéo de Savjee). Pour tenir compte de l’augmentation de la puissance de calcul et du nombre de mineurs, la difficulté du PoW est ajustée afin de maintenir le temps de création d’un bloc à environ dix minutes.

4. Ajouter de nouveaux blocs

Vous savez maintenant à quoi ressemble un bloc, comment les blocs sont chaînés grâce aux hachages, et comment le rythme de création des blocs est régulé par les PoW. Assemblons tout cela dans une fonction :

    #A function that takes the previous block and normally some data (in our case the data is a string indicating which block in the chain it is)
    gen_new_block <- function(previous_block){

      #Proof-of-Work
      new_proof <- proof_of_work(previous_block$proof)

      #Create new Block
      new_block <- list(index = previous_block$index + 1,
                        timestamp = Sys.time(),
                        data = paste0("this is block ", previous_block$index +1),
                        previous_hash = previous_block$new_hash,
                        proof = new_proof)

      #Hash the new Block
      new_block_hashed <- hash_block(new_block)

      return(new_block_hashed)
    }

Avant de construire votre blockchain, il faut bien commencer la chaîne quelque part. On le fait avec le « bloc Genesis ». Il ne contient pas de données et des valeurs arbitraires pour la preuve et le hachage précédent (puisqu’il n’y a pas de bloc antérieur).

    # Define Genesis Block (index 1 and arbitrary previous hash)
    block_genesis <-  list(index = 1,
                           timestamp = Sys.time(),
                           data = "Genesis Block",
                           previous_hash = "0",
                           proof = 1)

5. Construire la blockchain

Vous pouvez maintenant commencer. Démarrez avec le bloc Genesis puis ajoutez quelques blocs via une boucle.

    blockchain <- list(block_genesis)
    previous_block <- blockchain[[1]]

      # How many blocks should we add to the chain after the genesis block
      num_of_blocks_to_add <- 5

      # Add blocks to the chain
      for (i in 1: num_of_blocks_to_add){
        block_to_add <- gen_new_block(previous_block) 
        blockchain[i+1] <- list(block_to_add)
        previous_block <- block_to_add

        print(cat(paste0("Block ", block_to_add$index, " has been added", "\n",
                   "\t", "Proof: ", block_to_add$proof, "\n",
                   "\t", "Hash: ", block_to_add$new_hash)))
      }

    ## Block 2 has been added
    ##  Proof: 99
    ##  Hash: 7d3dfbb58b410838769f6080dbc62a44a4c5d411a41048c4e597d26dccd1cd38NULL
    ## Block 3 has been added
    ##  Proof: 198
    ##  Hash: 4f8bdd79d751f9e9829c14c52a737f257285b61e54b29531dd59bf1a530f1097NULL
    ## Block 4 has been added
    ##  Proof: 396
    ##  Hash: 512b877c4ff92605d9fe10ac73ced20f748742964f306c211c4691f15425a26eNULL
    ## Block 5 has been added
    ##  Proof: 792
    ##  Hash: a3baaa025186c5bcb2238a888bc65e705ffe73c17dc5c8f26ee337fd62867993NULL
    ## Block 6 has been added
    ##  Proof: 1584
    ##  Hash: d12c3f54c14f3287a9f31ab542271197ba6a658cee561a9289819dd563fe4991NULL

Si vous souhaitez ajouter beaucoup plus de blocs, vous remarquerez que cela prend de plus en plus de temps. La raison : le nombre de preuve croît de façon exponentielle.

Pour des cryptomonnaies comme Bitcoin, ce serait problématique, car le temps de création d’un nouveau bloc devrait rester à peu près constant (environ 10 minutes pour Bitcoin). Il faut donc ajuster en continu la difficulté du PoW pour tenir compte de l’augmentation de la puissance de calcul et des variations du nombre de mineurs à un instant donné.

Voici enfin à quoi ressemble un bloc de votre chaîne :

    blockchain[[5]]

    ## $index
    ## [1] 5
    ## 
    ## $timestamp
    ## [1] "2018-02-08 12:02:56 GMT"
    ## 
    ## $data
    ## [1] "this is block 5"
    ## 
    ## $previous_hash
    ## [1] "26cdc16a4560df5fa2fd521dbca22670e2475c35d3dd90781872bee98a164eef"
    ## 
    ## $proof
    ## [1] 792
    ## 
    ## $new_hash
    ## [1] "2eef25bf0bc4ee81e8c7cd1dfda65855b4ba32aba218d8c525a03a72b3454d74"

En résumé

Dans ce court article, vous avez créé la plus petite des blockchains. L’objectif principal était de montrer à quoi ressemble une blockchain et de présenter certains de ses concepts clés. Comprendre l’application ingénieuse de la cryptographie éclaire l’enthousiasme suscité par les possibilités de la blockchain.

Pour mettre une blockchain en production, il faut aller beaucoup plus loin : mettre en place une API, créer des portefeuilles, gérer des signatures numériques avec des paires de clés publique/privée, etc. Je n’ai fait qu’effleurer la notion de consensus décentralisé, qui est au cœur d’un réseau blockchain.

Cette brève introduction s’inspire de l’article de Gerald Nash, qui a implémenté la « plus petite blockchain » en Python. Je l’ai réalisée en R et ai ajouté l’implémentation du PoW de Daniel van Flymen.

Pour aller plus loin sur les blockchains, je vous recommande l’excellent livre blanc original sur Bitcoin de Satoshi Nakamoto et l’article de blog de BigData Doc.

Si vous avez des remarques ou des réactions à cet article, n’hésitez pas à me contacter sur Twitter : retrouvez-moi sur @jj_mllr ou suivez @CorrelAid, un réseau de jeunes analystes de données qui veut changer le monde grâce à une approche plus inclusive, intégrée et innovante de l’analyse des données.