Cryptomonnaie

Sécurisation de la Blockchain avec preuve de travail – Packt_Pub – Medium

Sécurisation de la Blockchain avec preuve de travail - Packt_Pub - Medium


Découvrez comment la preuve de travail est essentielle pour la sécurisation de la blockchain dans cet article d'Eric Traub, ingénieur en logiciel basé à New York, possédant une vaste expérience en tant qu'enseignant et enseignant à des personnes dans une variété de sujets différents.

Qu'est-ce qu'une preuve de travail?

La méthode proofOfWork est très importante et essentielle pour la technologie des chaînes de blocs, car elle sécurise Bitcoin et de nombreuses autres chaînes de blocs.

Maintenant, vous devez être curieux de savoir quel Preuve de travail (PoW) est en fait. Regardez toutes les blockchain. chaque blockchain est à peu près une liste de blocs. Chaque bloc doit être créé et ajouté à la chaîne. Cependant, nous ne souhaitons pas qu’un bloc soit créé et ajouté à la chaîne. Nous voulons nous assurer que chaque bloc ajouté à la chaîne est légitime, contient les transactions correctes et contient les données correctes. C’est parce que s’il n’a pas les bonnes transactions ou les bonnes données, alors les gens peuvent simuler leur Bitcoin, provoquer la fraude et voler de l’argent à d’autres personnes. Ainsi, chaque fois qu'un nouveau bloc est créé, nous devons d'abord nous assurer qu'il s'agit d'un bloc légitime en l'explorant dans le programme de guerre.

Une méthode proofOfWork utilisera currentBlockData et previousBlockHash. À partir de ces données, la méthode proofOfWork essaiera de générer un hachage spécifique. Ce hachage spécifique dans notre exemple va être un hachage qui commence par quatre zéros. Ainsi, avec les données currentBlockData et previousBlockHash données, la méthode générera en quelque sorte un hachage résultant commençant par quatre zéros.

Maintenant, essayons de comprendre comment nous pouvons faire cela. Supposons que le hachage est aléatoire. Donc, si le hachage résultant est à peu près aléatoire, comment pouvons-nous générer un hachage à partir de notre bloc actuel qui commence par quatre zéros? Cela ne peut se faire que par essais et erreurs, ou par devinettes et vérifications. Donc, ce que nous devrons faire, c'est exécuter notre méthode hashBlock plusieurs fois jusqu'à ce que nous ayons de la chance une fois en générant un hachage qui a quatre zéros au début.

Maintenant, vous vous demandez peut-être que les entrées de notre méthode hashBlock sont les paramètres previousBlockHash, currentBlockData et nonce. Comment ces trois paramètres qui ont été passés une fois peuvent-ils générer plusieurs hachages différents alors qu’en réalité, nous transmettons toujours exactement les mêmes données?

Alors, comment pouvons-nous modifier ces données de manière à ne pas modifier notre currentBlockData ou le previousBlockHash, mais nous obtenons toujours un hachage résultant qui comporte quatre zéros au début? La réponse à cette question est que nous allons changer constamment la valeur de nonce. Cela peut sembler un peu déroutant en ce moment, alors essayons de le clarifier en sachant ce qui se passe réellement dans un proofOfWork en le décomposant un peu.

En gros, dans notre proofOfWork, nous allons hacher de façon répétée notre bloc jusqu'à ce que nous trouvions le hachage correct, qui correspond à tout hachage commençant par quatre zéros. Nous allons modifier l'entrée de notre méthode hashBlock en incrémentant constamment la valeur nonce. La première fois que nous exécutons notre méthode hashBlock; nous allons commencer avec une valeur de nonce de 0.

Ensuite, si le hachage résultant ne comporte pas quatre zéros au début, nous allons réexécuter notre méthode hashBlock, sauf que cette fois, nous allons incrémenter notre valeur de nonce de 1. Si nous n'obtenons pas la valeur de hachage correcte encore une fois, nous allons incrémenter la valeur de nonce et l'essayer à nouveau. Si cela ne fonctionne pas, nous incrémentons à nouveau la valeur nonce et essayons à nouveau. Ensuite, nous continuerons d’exécuter cette méthode hashBlock jusqu’à ce que nous trouvions un hachage commençant par quatre zéros. C'est ainsi que fonctionnera notre méthode proofOfWork.

Vous vous demandez peut-être comment cette méthode proofOfWork sécurise réellement la blockchain. La raison en est que, pour générer le hachage correct, nous devrons utiliser notre méthode hashBlock plusieurs fois, ce qui nécessitera beaucoup d’énergie et de puissance de calcul.

Donc, si quelqu'un voulait retourner dans la blockchain et essayer de changer un bloc ou les données de ce bloc - peut-être pour se donner plus de Bitcoin - il devrait faire une tonne de calculs et utiliser beaucoup d'énergie pour créer le bon hacher. Dans la plupart des cas, il est impossible de revenir en arrière et d'essayer de recréer un bloc déjà existant ou d'essayer de rediffuser un bloc déjà existant avec vos propres fausses données. Notre méthode hashBlock utilise non seulement le currentBlockData, mais également l'ancien BlockHash. Cela signifie que tous les blocs de la blockchain sont liés par leurs données.

Si quelqu'un essaye de remonter ou de recréer un bloc qui existe déjà, il devra également le repasser et recréer chaque bloc qui suit le premier recréé. Cela prendrait une quantité incroyable de calcul et d’énergie et n’est tout simplement pas réalisable pour une blockchain bien développée. Une personne devrait entrer, recréer un bloc en utilisant une preuve de travail, puis recréer chaque bloc après en faisant une nouvelle preuve de travail pour chaque bloc. Ce n'est tout simplement pas faisable pour une blockchain bien produite, et c'est la raison pour laquelle la technologie de blockchain est si sûre.

Cela peut sembler accablant et un peu déroutant à l’heure actuelle, mais ne vous inquiétez pas: nous allons construire la méthode proofOfWork dans la section suivante, puis la tester avec différents types de données.

Création de la méthode proofOfWork

Construisons la méthode proofOfWork:

  1. Après la méthode hashBlock, définissez la méthode proofOfWork comme suit:

2. Cette méthode prend en compte deux paramètres: previousBlockHash et currentBlockData:

3. La première chose que nous voulons faire dans notre méthode est de définir un nonce:

4. Ensuite, nous voulons hacher pour la première fois toutes nos données. Saisissez donc la ligne de code mise en surbrillance suivante:

Dans le code précédent, vous remarquerez peut-être que nous avons utilisé le terme let, car notre nonce et notre hash vont changer au fur et à mesure de notre progression dans la méthode.

5. L'étape suivante consiste à exécuter constamment la méthode hashBlock jusqu'à obtenir un hachage commençant par quatre zéros. Nous allons effectuer cette opération répétée à l’aide d’une boucle while:

6. Si le hachage que nous avons créé ne commence pas par quatre zéros, nous voudrons exécuter notre hachage à nouveau, sauf que cette fois avec la valeur différente de nonce. Par conséquent, dans la boucle while, ajoutez les lignes de code en surbrillance suivantes:

Dans la boucle while, nous exécutons à nouveau notre méthode hashBlock avec toutes les mêmes données, sauf que cette fois, notre nonce est incrémenté et égal à 1 au lieu de 0. Ce sera la première itération de notre boucle while.

Après la première itération, les quatre premiers caractères générés ne sont pas égaux à 0000 dans le nouveau hachage généré. Dans ce cas, nous souhaitons générer un nouveau hachage. Ainsi, notre boucle while sera exécutée à nouveau, la valeur de nonce sera incrémentée à 2 et un nouveau hachage sera créé. Si ce hachage ne commence pas non plus par quatre zéros, la boucle while sera exécutée à nouveau, la valeur de nonce sera incrémentée à nouveau et le hachage sera généré à nouveau.

Notre boucle continuera à le faire jusqu'à ce qu'elle se termine par un hash commençant par quatre zéros. Cela pourrait prendre plusieurs itérations. Cela pourrait se produire 10 fois, 10 000 fois ou 100 000 fois.

C'est dans cette boucle que se dérouleront tous les calculs et c'est la raison pour laquelle la méthode proofOfWork utilise autant d'énergie - de nombreux calculs sont en cours.

Nous allons continuer à parcourir la boucle while jusqu'à ce que nous générions un hachage approprié commençant par quatre zéros. Lorsque nous aurons enfin le hachage correct, notre boucle while cessera de fonctionner et, à la fin de notre proofOfWork, elle renverra simplement la valeur nonce qui nous a donné le hachage valide:

Voilà comment notre méthode proofOfWork fonctionnera et validera le hachage. Dans la section suivante, nous allons tester notre méthode proofOfWork pour nous assurer qu’elle fonctionne correctement. Nous étudierons également pourquoi nous renvoyons une valeur nonce au lieu de renvoyer le hachage.

Test de la méthode proofOfWork

Testons notre méthode proofOfWork pour s’assurer qu’elle fonctionne correctement. Nous allons tester la méthode dans notre fichier test.js. Vous pouvez trouver les fichiers de code pour cet article à l'adresse https://github.com/PacktPublishing/Learn-Blockchain-Programming-with-JavaScript/tree/master/dev. Alors, commençons:

  1. Ouvrez le fichier test.js.

2. Si vous ne trouvez aucune donnée dans le fichier test.js, ajoutez-la à votre fichier test.js, comme indiqué dans la capture d'écran précédente, et vous pourrez alors commencer à tester les données.

3. Pour tester notre méthode proofOfWork, nous avons besoin de previousBlockHash et de currentBlockData. Donc, dans notre cas de test, supprimez la valeur nonce et ajoutez les lignes de code suivantes à notre fichier:

1*g1vdHejjTYqltxBWiTyE w - Sécurisation de la Blockchain avec preuve de travail - Packt_Pub - Medium

Maintenant, ce que nous devrions obtenir comme résultat de cette méthode proofOfWork est une valeur nonce. En gros, notre méthode proofOfWork teste quelle est la valeur de nonce correcte à hacher avec nos données de bloc et notre previousBlockHash pour générer un hachage de bloc résultant qui commence par quatre zéros. ProofOfWork trouve ici le nonce correct pour nous.

4. Enregistrez ce fichier et lancez notre test en tapant la commande node dev / test.js dans notre fenêtre de terminal. Une fois le test exécuté, vous remarquerez qu’un nombre apparaît en sortie à l’écran:

Ce nombre signifie qu'il a fallu 27 470 itérations à notre méthode proofOfWork pour trouver un hachage commençant par quatre zéros.

5. Maintenant, pour comprendre tout ce processus en profondeur, nous pouvons, dans notre boucle while, vous déconnecter de chaque hachage que nous essayons. Nous devrons apporter des modifications mineures à notre boucle while:

Lorsque nous exécutons notre fichier de test maintenant, nous allons devoir voir 27 000 hachages différents déconnectés à l'intérieur de notre terminal. Aucun de ces hachages ne commencera par quatre zéros, à l'exception du dernier. Seul le dernier hachage déconnecté doit commencer par quatre zéros car, après notre méthode, cela se terminera et renverra la valeur de nonce pour laquelle le hachage valide a été obtenu.

Sauvegardons maintenant notre fichier test.js. Vous pouvez maintenant observer sur votre écran que de nombreux hachages différents sont actuellement connectés au terminal:

Vous pouvez également constater que, pour chaque hachage qui a été déconnecté, le début ne correspond jamais à quatre zéros jusqu'à ce que nous obtenions notre valeur finale.

Fondamentalement, ce qui se passe ici, c'est que nous générons le hachage à partir de notre currentBlockData, previousBlockHash et du nonce de valeur 0. Ensuite, pour le prochain hachage, nous incrémentons le nonce de 1. C'est donc la même donnée d'entrée, mais la valeur de nonce est incrémentée jusqu'à l'obtention du hachage valide. Enfin, à 27 470, avec la valeur d'un nonce, le hachage valide est obtenu.

Essayons maintenant d’utiliser notre méthode hashBlock. Dans notre fichier dev / test.js, supprimez la méthode proofOfWork et ajoutez la ligne de code suivante:

1*IH8AK70CcwneHz4NAncYSA - Sécurisation de la Blockchain avec preuve de travail - Packt_Pub - Medium

Dans le code précédent, pour le nonce, saisissons la valeur 27,470. Nous avons obtenu cette valeur avec notre méthode proofOfWork.

Ce que nous observons en sortie exécute le hachage simple avec la valeur de nonce correcte que nous avons obtenue en exécutant la méthode proofOfWork. En faisant cela, nous devrions générer un hachage qui commence par quatre zéros du premier coup. Sauvegardons-le et exécutons-le. Une fois le test exécuté, vous observerez le hachage simple qui commence par quatre zéros, comme illustré dans la capture d'écran suivante:

1*zDk 3B7UhWNGYA8vwKOt6Q - Sécurisation de la Blockchain avec preuve de travail - Packt_Pub - Medium

Le proofOfWork est une partie très importante de la technologie blockchain. Comme vous pouvez le constater d'après les résultats du test, le calcul est très difficile: il nous a fallu plus de 27 000 itérations pour générer le hachage correct. En conséquence, un proofOfWork consomme beaucoup d’énergie, effectue de nombreux calculs et est très difficile à calculer.

Une fois que nous avons la preuve correcte ou la valeur de nonce à laquelle le hachage souhaité est généré, il devrait être très facile pour nous de vérifier que nous avons la valeur de nonce correcte. Nous pouvons le vérifier en le passant simplement dans notre méthode hashBlock - nous obtiendrions le hash commençant par quatre zéros.

Générer une preuve de travail prend beaucoup de travail, mais il est très facile de vérifier son exactitude. Donc, si nous voulons un jour revenir dans notre blockchain et vérifier qu'un bloc est valide, il vous suffit de hacher les données de ce bloc avec le hachage du bloc précédent et le nonce généré à partir du proofOfWork lorsque ce bloc était miné. Si cela nous renvoie un hachage valide qui commence par quatre zéros, nous savons déjà que le bloc est valide.

Ainsi, à partir de notre test, nous pouvons conclure que la méthode proofOfWork fonctionne comme prévu.

Si vous avez trouvé cet article intéressant, vous pouvez regarder Apprendre la programmation Blockchain avec JavaScript explorer l'essentiel de la technologie de la blockchain avec JavaScript pour développer des applications hautement sécurisées, similaires à Bitcoin. Apprendre la programmation Blockchain avec JavaScript peut vous aider à comprendre le fonctionnement du réseau dans une chaîne de blocs décentralisée et à comprendre pourquoi la décentralisation est un élément aussi important pour la sécurisation d’une chaîne de blocs.

Show More

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Related Articles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close