Sécurisation d'un réseau bancaire avec la technologie blockchain

Partie 2 : Construire une blockchain

IV.7 Introduction

Dans le chapitre 2, nous avons appris ce qu'est une blockchain et comment elle fonctionne. Dans de plus, nous avons appris dans le chapitre 3 l'architecture d'un réseau. Dans ce chapitre, on va commencer à construire la blockchain et tous ses fonctionnalités. Commençons par crée notre projet ou nous allons taper notre code pour crée la blockchain, puis création de la structure de données blockchain utilisant un constructeur puis nous ajouterons beaucoup de différents types de fonction de notre blockchain par l'ajoute de différentes méthodes à son prototype. Telles que la création des blocs et les transactions,

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[111]

ainsi que la capacité de hachage des données et des blocs. Nous lui donnerons également la possibilité de faire une preuve de travail et de nombreuses autres fonctionnalités qu'une blockchain devrait être capable de faire. Nous nous assurons ensuite que la blockchain et entièrement fonctionnel en testant les fonctionnalités ajoutées au fur à mesure de notre progression. Donc en construisant blockchain étape par étape, pour nous gagne une meilleure compréhension de la façon de la blockchain fonctionne.

IV.8 Configuration du projet

Commençons par construire notre blockchain projet. La première chose que nous allons faire est ouvrir notre terminal et créer notre blockchain en tapant des commandes dans le répertoire terminal.

Etape 01 : commençons par crée un dossier appelé blokchchain2020, dans ce dossier créons un répertoire appelé programmation_BC. Ce répertoire est actuellement vide. À l'intérieur de ce répertoire programmation_BC se trouve ou nous allons faire tout notre programmation. Nous allons construire toute notre blockchain à l'intérieur de ce répertoire. Comme illustre la figure suivante :

Figure IV- 51: Créations de notre projet

Maintenant, notre répertoire programmation_BC est prêt, et la première chose que nous devons faire est d'ajouter un dossier et fichiers en elle. Le premier dossier nous voulons mettre sera appelée dev. En tapant les commandes suivantes :

Dans ce répertoire, nous allons construire nos données blockchain, nous allons créer deux fichiers blockchain.js et test.js. Pour faire cela, entrez les commandes suivantes :

Figure IV- 52: Créations des fichiers avec les extensions "js"

La commande « touch » permet d'ouvrir un fichier s'il existe ou de le crée s'il n'existe pas. On peut n'utilise pas cette commande « touch » voici une autre méthode. Dans ce dernier dossier on ouvre l'éditeur de texte en tapant les codes et les enregistres avec les extensions "js" (test.js et blockchain.js).

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[112]

Le fichier blockchain.js est l'endroit où nous allons taper notre code pour crée la blockchain et le test.js est l'endroit où nous allons écrire notre code pour tester la blockchain.

Ensuite, revenons à notre répertoire programmation_BC en tapant la commande suivante dans le terminal : cd..

Dans le répertoire programmation_BC, exécutons la commande suivante pour crée le npm projet :

Figure IV- 53: Création d'un fichier package.json.

Après avoir exécuté la commande précédente, on obtiendra quelques options sur notre terminal.

Figure IV- 54: Création de projet est prête

Ce fichier. json gardera une trace de notre projet toutes les dépendances dont nous avons besoin, permet nous pour exécuter des Scripts. Nous nous travaillons plus à l'intérieur de ce fichier package.json

IV.9 Programmation de la blockchain

IV.9.1 Introduction

Dans cette section ; nous couvrirons les points suivants :

§ Apprendre a créé une fonction de constructeur de la blockchain

§ Construire et tester les différentes méthodes

§ Comprendre la mise en oeuvre de la PoW

§ Crée et tester un genesis block

Alors, commençons !

[113]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

IV.9.2 Création de la blockchain

Exigences : J'ai construit cela dans Node.js, mais vous pouvez facilement le construire sur Repl.it si vous préférez. Nous utiliserons également le package sha256 npm pour hacher les blocs.

Si vous êtes nouveau sur Node.js, tout d'abord, vous devrez créer un nouveau répertoire, créer un index.js fichier, puis à partir de votre terminal, exécuter à npm init -y partir de votre nouveau répertoire. Cela crée un fichier package.json, qui nous permettra d'installer le package sha256. Exécutez npm i sha256 pour installer la bibliothèque sha256. Si vous êtes sur Repl.it, créez un nouveau replNodejs, installez le js-sha256package et exigez-le.

Commençons par construire notre blockchain Structure de données. Nous allons commencer par ouvrir tous les fichiers que nous avons dans notre blockchain en utilisant l'éditeur Sublime. Si vous êtes à l'aise avec n'importe quel autre éditeur, vous peut aussi l'utiliser. Ouvrez toute notre blockchain répertoire dans l'éditeur que vous préférez.

Nous allons construire notre structure de données blockchain dans le fichier dev /blockchain.js que nous avons créé dons la section précédente, Configuration du projet. Construisons cette structure de données blockchain en utilisant une fonction constructrice. Alors, commençons :

§ Maintenant que nous sommes configurés, il est temps de créer une nouvelle classe, nous avons donc un modèle que nous utiliserons pour construire chaque bloc. Chaque bloc de notre blockchain simple contiendra 3 éléments de données : l'index du bloc, la valeur de hachage du bloc qui le précède et un hachage de lui-même.

§ Pour créer notre bloc, j'utilise une classe JavaScript, mais une fonction constructeur fonctionnerait tout aussi bien car c'est vraiment tout ce qu'une classe est sous le capot. J'ai défini la fonction constructrice pour prendre toutes nos données à l'exception du hachage comme paramètres. Le bloc examinera alors l'index, l'horodatage, les données et le hachage précédent, et générera son propre hachage ou empreinte digitale.

§ Continuons à construire notre structure de données blockchain. Après avoir défini notre fonction constructeur dans la section précédente, la suivante chose que nous voulons faire avec notre fonction constructeur est de placer une méthode dans notre fonction Blockchain. Cette méthode que nous allons créer s'appellera createNewBlock. Comme son nom l'indique, cette méthode va créer un nouveau bloc pour nous. Suivons les étapes mentionnées ci-dessous pour construire notre blockchain :

[114]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

IV.9.2.1 La création d'ajoute un nouveau bloc

Figure IV- 55: Programmations d'ajoute d'un nouveau bloc

En ajoutant ces deux dernières lignes de code, notre méthode createNewBlock est prête. Fondamentalement, c'est qu'elle crée un nouveau bloc. À l'intérieur de ce bloc, nous avons nos transactions et les nouvelles transactions qui ont été créées depuis l'extraction de notre dernier bloc. Après avoir créé un nouveau bloc.

§ Test de la méthode constructeur de la blockchain :

La première chose que nous devons faire est d'exporter notre fonction constructeur Blockchain car nous allons utiliser cette fonction dans notre fichier test.js. Donc, pour exporter la fonction constructrice, nous allons aller au bas du fichier blockchain.js, taper la ligne de code suivante, puis enregistrer le fichier.

Figure IV- 56: Exportations de la fonction constructrice

Ensuite, accédez au fichier dev / test.js, car c'est ici que nous testerons notre méthode createNewBlock. Maintenant, la première chose que nous voulons faire dans notre fichier dev / test.js est d'importer notre fonction constructeur Blockchain, alors tapez ce qui suit :

Figure IV- 57: Configuration de projet bitcoin

Allez maintenant dans notre fenêtre de terminal. Ici, nous sommes actuellement dans le répertoire blockchain, et notre fichier test.js est dans notre dossier dev, alors tapez la commande suivante dans le terminal:node test.js

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[115]

Nous observerons la Blockchain dans la fenêtre du terminal, comme le montre la capture d'écran suivante :

Figure IV- 58: Création de projet bitcoin

Nous pouvons observer que Blockchain a une chaîne vide et un tableau de transactions vide. C'est exactement ce que nous attendions de la sortie.

§ Test d'ajoute des nouveaux blocs :

Nous ajouterons la ligne de code suivante : bitcoin.createNewBlock();

Ensuite, nous allons créer un hachage pour notre précédent BlockHash, suivi par un autre hachage pour notre paramètre de hachage, comme suit :

bitcoin.createNewBlock(1998,'KAWTER','BO14UD05GH19en98');

Donc, maintenant on a créé notre bitcoin. Enregistrez ce fichier et exécutez notre fichier test.js à nouveau dans le terminal. Nous aurons ensuite à observer la sortie suivante :

Figure IV- 59: Test d'ajoute un nouveau bloc

Dans la capture d'écran précédente, nous avons observé toute la structure de données de la chaîne de blocs dans la chaîne. Ce bloc a également le hachage, nonce et previous Block Hash paramètres que nous avions saisis. Il n'a aucune transaction parce que nous n'en avons pas créé transactions encore. Par conséquent, nous pouvons conclure que la méthode createNewBlockfonctionne très bien.

Maintenant, testons encore plus notre méthode en créant quelques blocs de plus dans notre chaîne. Comme elle montre la figure suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[116]

Figure IV- 60: Test de la méthode creatNewBlock

Maintenant, quand nous exécutez notre fichier test.js, nous devrions avoir trois blocs dans notre chaîne, comme le montre la capture d'écran suivante :

Figure IV- 61: Exécution de la méthode creatNewBlock

IV.9.2.2 Créations des nouvelles transactions

La prochaine méthode que nous allons ajouter notre fonction constructrice de blockchain est appelée createNewTransaction.

Cette méthode créera une nouvelle transaction pour nous. Suivons ce qui suit étapes mentionnées pour créer la méthode :

Figure IV- 62: Programmations des nouvelles transactions

§ Tester d'ajoute des nouvelles transactions :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[117]

Nous allons tester notre méthode createNewTransaction dans notre fichier test.js. Jetez un oeil à la capture d'écran suivante pour un test rapide :

Figure IV- 63: Test d'ajoute des nouvelles transactions

Nous pouvons observer la blockchain bitcoin sur la fenêtre du terminal, comme le montre la capture d'écran suivante :

Figure IV- 64: Test d'ajoute des nouvelles transactions

IV.9.2.3 Mining d'un bloc

On va créer un bloc, créé une transaction, puis miné le nouveau bloc. Maintenant, la transaction nous avons créé devrait apparaître dans notre deuxième bloc, car nous avons miné un bloc après avoir créé une transaction comme le montre la figure suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[118]

Figure IV- 65: Test de miner un bloc

§ Test de Mining un bloc :

Voyons ce que nous donne :

Figure IV- 66: Exécution de minerde deux blocs

Nous avons à nouveau toute notre blockchain, qui contient deux blocs parce que nous avons miné deux blocs. Notre premier bloc (index : 1), qui n'a aucune transaction et à notre deuxième bloc (index : 2), dans lequel, si vous regardez nos transactions, il est dit qu'il y a un tableau qui contient des éléments par rapport à un tableau de transactions d'un premier bloc, qui ne contient aucun élément. Nous devons nous attendre à voir la transaction que nous avions créée précédemment.

En faisons la modification suivante à notre test:console.log(bitcoin.chain[1]);

Dans la sortie, vous pouvez voir que, pour les transactions, il contient un tableau avec un objet. Découvrons la capture d'écran suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[119]

Figure IV- 67: Modifications sur les transactions

Ce que nous avons fait ici était simplement de créer une transaction, puis de miner en créant un nouveau bloc ou en extrayant un nouveau bloc, qui contient maintenant notre transaction. Maintenant, réalisons quelques autres exemples pour aider à clarifier ce qui se passe ici.

Figure IV- 68: Ajout des transactions successives

À ce stade, ces trois nouvelles transactions devraient se trouver dans notre tableau en attente de transactions, car nous ne créons pas de nouveau bloc après avoir créé ces trois transactions. Enfin, nous nous déconnectons à nouveau de notre blockchain bitcoin. Notre test devrait maintenant ressembler à ce qui suit :

Figure IV- 69: Transactions restantes en attente

Dans la capture d'écran précédente, vous pouvez observer que nous avons notre blockchain. Dans cette chaîne, nous avons deux blocs, comme nous nous y attendions, et dans notre tableau de transactions en attente, nous avons trois transactions, qui sont les trois transactions que nous avons créées dans notre fichier de test. Ce que nous devons faire ensuite, c'est intégrer ces transactions en attente dans notre chaîne. Pour cela, minons un autre bloc. Copiez et collez simplement la méthode creatNewBlock après les trois transactions que nous avons créées et apportons des modifications à ses paramètres comme nous souhaitons. Lorsque nous exécutons le test maintenant, les trois transactions en

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[120]

attente devraient apparaître dans notre nouveau bloc en faisant une petite modification de la dernière ligne de notre code de test, qui est console.log (bitcoin.chain [2]); la valeur 2 spécifie ici le troisième bloc du chaîne. Enregistrons le fichier et exécutons le test. Vous pourrez observer la sortie suivante :

Figure IV- 70: Minage réussi

Vous pouvez voir que nous avons les trois transactions que nous avons créées. C'est ainsi que comment nos méthodes createNewTransactionset createNewBlock fonctionnent ensemble.

IV.9.3 Hachage des données

IV.9.3.1 Création de la méthode hashBlock

Construisons notre méthode hashBlock. À l'intérieur de cette méthode, nous voulons utiliser le hachage SHA256 pour hacher nos données de bloc. Suivez les étapes mentionnées dans la figure ci-dessous :

Figure IV- 71: Construction de la méthode hashBlock

Nous créons notre propre fonction hashBlock utilisée pour donner à chaque bloc son propre hachage. Comme vous pouvez le voir avec la fonction, le hachage prend chaque morceau de l'objet bloc, le jette dans une fonction SHA256 et le convertit en chaîne. Dans ce projet, nous convertissons les données, nonce et le bloc hash précédent.

C'est ainsi que notre méthode hashBlock fonctionnera. Dans la section suivante, nous allons tester la méthode pour voir si cela fonctionne parfaitement.

Test de la méthode hashblock :

Testons notre méthode hashBlock dans le fichier test.js. Semblable à ce que nous avons fait dans les sections précédentes, dans notre fichier test.js, nous devrions importer notre structure de données blockchain, créons une nouvelle instance de notre blockchain et la nommons bitcoin. Maintenant, testons notre méthode hashBlock.

Pour cela, saisissons la ligne de code suivante dans notre fichier test.js :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[121]

Figure IV- 72: Test de la méthode hashBlock

Dans ce cas de test, nous appelons notre méthode hashBlock avec tous les paramètres corrects. Lorsque nous exécutons ce fichier, nous devons observer le hachage sur la fenêtre du terminal.

Maintenant, nous allons enregistrer ce fichier test.js et exécutons-le pour vérifier si nous obtenons ou non la sortie voulue. Nous allons accéder à la fenêtre de notre terminal et saisissons la commande node test.js, et observons les résultats obtenus. Nous pourrons observer le hachage résultant similaire en sortie de notre méthode hashBlock comme suit :

Figure IV- 73: Exécution de la méthode hashbBock

Nous avons oublié d'enregistrer la bibliothèque sha256. Nous devrons taper la commande suivante dans notre terminal : npm i sha256 --save

Nous verrons alors la sortie suivante :

Figure IV- 74: Enregistrement de la bibliothèque sha256

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[122]

Ne vous inquiétez pas de l'avertissement pour l'instant car cela ne nous affectera pas dans le cadre de ce projet. L'erreur existe car le dossier que nous avons créé est extrêmement dépouillé et ne contient pas de fichiers supplémentaires.

On va accédez à notre fenêtre de terminal et tapons la commande node test.js, et observons les résultats que nous obtenons. Normalement, maintenant, on pourra observer le hachage résultant en sortie :

Figure IV- 75: Résultat de hachage Il semble que notre méthode hashBlock fonctionne bien.

IV.9.4 Proof of Work

IV.9.4.1 Définition

La prochaine méthode que nous allons ajouter à notre structure de données blockchain est la méthode de preuve de travail. Cette méthode est très importante et essentielle à la technologie blockchain.

La méthode ProofOfWork prendra les deux paramètres : currentBlockData et previousBlockHash. À partir de ces données que nous fournissons, la méthode proofOfWork tentera 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.

Essayons maintenant de comprendre comment nous pouvons le faire. Comme nous l'avons appris dans les sections précédentes, le hachage généré à partir de SHA256 est à peu près 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 ? La seule façon de le faire est par essais et erreurs, ou en devinant et en vérifiant. Donc, cette fois, nous allons incrémenter notre valeur nonce de 1. Si nous n'obtenons pas à nouveau la valeur de hachage correcte, nous allons incrémenter la valeur nonce et réessayer. Si cela ne fonctionne pas, nous incrémentons à nouveau la valeur nonce et réessayons. Ensuite, nous exécuterons continuellement cette méthode hashBlock jusqu'à ce que nous trouvions un hachage qui commence par quatre zéros. C'est ainsi que notre méthode proofOfWork fonctionnera. 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 faudrait faire une tonne de calculs et utiliser beaucoup d'énergie pour créer le bon hacher. Dans la plupart des cas, il n'est pas possible de revenir en arrière et d'essayer de recréer un bloc déjà existant ou de réexploiter un bloc déjà existant avec vos propres faux donnés. En plus de cela, notre méthode hashBlock prend non seulement le currentBlockData, mais aussi le précédent BlockHash. Cela signifie que tous les blocs de la blockchain sont liés entre eux par leurs données. Cela peut sembler écrasant un peu pour le moment, mais ne vous inquiétez pas - nous allons construire la méthode ProofOfWork ci-dessous, puis nous allons la tester avec de nombreux types de données différents. Cela nous aidera à nous familiariser avec le fonctionnement de la méthode ProofOfWork et la manière dont elle sécurise la blockchain.

[123]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

IV.9.4.1 Création de la méthode Proof of Work

Alors, on commence par définir la méthode ProofOfWork :

Figure IV- 76: Configuration de la preuve de travail

C'est ainsi que notre méthode proofOfWork fonctionnera et validera le hachage.

Dans la section suivante, nous testerons notre méthode proofOfWork dans notre fichier test.jspour nous assurer qu'elle fonctionne correctement. Nous étudierons également pourquoi nous retournons une valeur nonce au lieu de renvoyer le hachage.

§ Teste de la méthode proofOfWork :

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

console.log(bitcoin.proofOfWork(previousBlockHash, currentBlockData));

Une fois le test exécuté, nous remarquerons qu'un nombre apparaît en sortie à l'écran :

Figure IV- 77: Obtention du nonce

Ce que signifie ce nombre, c'est qu'il a fallu 61989 itérations pour que notre méthode proofOfWork trouve un hachage qui commence par quatre zéros.

Nous devrons apporter des modifications mineures à notre boucle while, ce qui va se passer, c'est que nous devrions réellement voire plus de 61000 hachages différents affichés dans notre terminal. Aucun de ces hachages ne commencera par quatre zéros, à l'exception du dernier. Seul le dernier hachage affiché commence avec quatre zéros car après notre méthode, cela se terminera et renverra la valeur nonce pour laquelle le hachage valide a été obtenu.

Nous pouvons maintenant observer sur notre écran que nous avons toute une tonne de hachages différents enregistrés sur terminal :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[124]

Figure IV- 78: Exécution de PoW

Nous pouvons également observer que pour chaque hachage qui a été affiché, le début n'est jamais quatre zéros de suite jusqu'à ce que nous obtenions notre valeur finale.

Essayons maintenant d'utiliser notre méthode hashBlock. Dans notre fichier test.js, supprimons la méthode proofOfWork et ajoutons la ligne de code suivante :

console.log(bitcoin.hashBlock(previousBlockHash, currentBlockData, 61989));

En faisant cela, nous devons générer un hachage qui commence par quatre zéros au premier essai. Enregistrons-le et exécutons-le. Une fois le test exécuté, nous pourrons observer le hachage unique qui commence par quatre zéros, comme indiqué dans la capture d'écran suivante :

Figure IV- 79: Vérification du hash après l'obtention du nonce

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

IV.9.4 Création du bloc genesis :

Une autre chose que nous devrions ajouter à notre structure de données blockchain est le bloc genesis. Mais qu'est-ce qu'un bloc de genèse ? Eh bien, un bloc de genèse est simplement le premier bloc d'une chaîne de blocs.

À l'intérieur de la fonction constructeur blockchain tapons la ligne de code suivante : this.createNewBlock(1405, '0', '0');

Dans le code précédent, nous avons passé la valeur nonce à 1405, previousBlockHash à 0 et la valeur de hachage à 0. Ce ne sont que des valeurs arbitraires ; vous pouvez ajouter la

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

valeur que vous souhaitez ajouter. Maintenant, enregistrons le fichier et testons le bloc genesis dans le fichier test.js. Comme le montre la capture d'écran suivante :

Figure IV- 80: Créations du bloc genesis

Dans la capture d'écran précédente, pour le tableau de chaînes, on peut voir que nous avons un bloc à l'intérieur de la chaîne. Ce bloc est notre bloc de genèse et il a un nonce de 1405, un hachage de 0 et un précédent Blockhash de 0. Dorénavant, toutes nos chaînes de blocs auront un bloc de genèse.

IV.8.6 Création d'une API Express

Dans cette section, nous allons créer une API de liste de tâches RESTful (c'est-à-dire des points de terminaison qui créeront une tâche, obtiendront ou liront la liste de toutes les tâches, liront une tâche particulière, supprimeront une tâche et mettront à jour une tâche). À l'aide d'Express et couvrir quelques bonnes pratiques de développement. On découvre comment toutes les pièces fonctionnent ensemble lorsqu'on crée un projet.

IV.8.6.1 Configuration du serveur

Installons express et nodmon, express sera utilisé pour créer le serveur tandis que nodmon nous aidera à garder une trace des modifications de notre application en regardant les fichiers modifiés et redémarrer automatiquement le serveur.

IV.8.6.1.1 Installation d'express

Nous pouvons maintenant installer Express on exécute cette commande :

#npm i express

IV.8.6.1.2 Crée le fichier serveur.js

Au début du code est importé le express module et créé une app. Après avoir créé un itinéraire basé sur la méthode HTTP. Les objets reset req sont fournis par le noeud, ce qui équivaut à une requête HTTP et à une réponse. Pour terminer, je dis à l'instance créée d'écouter sur le port 3000

Figure IV- 81: Création de fichier serveur.js

[125]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[126]

IV.8.6.1.3 Démarrer le serveur express

Si tout s'est bien passé, rendez-vous sur localhost : 3000

Figure IV- 82: Démarrage du serveur express

Passons à chrome et allons au port localhost 3000, voici notre `Hello Word '

Figure IV- 83: Exécution du serveur

Ce fichier est aussi simple que possible lors de la définition d'une application Express. Nous avons créé un objet d'application et l'avons exporté pour utilisation.

IV.8.6.1.4 Configuration des itinéraires

Le routage consiste à déterminer comment une application répond à une demande client pour un point de terminaison spécifique, qui est un URI (ou chemin) et une méthode de demande HTTP spécifique (GET, POST, etc.).

§ L'URI (ou chemin) de la demande que nous voulons capturer.

§ Une fonction de gestionnaire (qui accepte un objet de demande et de réponse comme arguments).

IV.8.6.1.5 Quelle méthode HTTP devrions-nous utiliser ?

Lors de la construction d'une API REST, chaque méthode HTTP correspond à une action contre une ressource servie par l'API.

§ GET : récupérer l'objet d'une ressource particulière ou répertorier tous les objets

§ POST : créer un nouvel objet de ressource

§ PATCH : effectuer une mise à jour partielle de l'objet d'une ressource particulière

§ PUT : écrase complètement l'objet d'une ressource particulière

§ DELETE : supprime l'objet d'une ressource particulière

Nous pouvons commencer à définir notre API en spécifiant les itinéraires pour une seule ressource.

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[127]

IV.8.6.2 Construire les fondations d'API

Dans cette section, nous allons continuer à construire notre API blockchain. Puis nous allons commencer par construire les trois points de terminaison suivants dans notre API :

§ Le premier point de terminaison est / blockchain, ce qui nous permet d'aller chercher notre blockchain entière afin que nous puissions regarder les données qui s'y trouvent.

§ Le deuxième point de terminaison est / transaction, qui nous permet de créer une nouvelle transaction.

§ Le troisième critère est / le mine, qui nous permettent d'exploiter un nouveau bloc en utilisant la méthode ProofOfWork que nous avons faite dans la dernière section.

Dans le fichier api.js, définissons ces points de terminaison comme suit :

Figure IV- 84: Interface d'applications Blockchain

Maintenant, une autre chose que nous voulons faire est apportez quelques modifications à la méthode listen :

app.listen(3000, function(){console.log('listening on port 3000...') ;

À l'intérieur de cette fonction, nous allons simplement imprimer l'écoute sur la chaîne du port 3000. La raison pour laquelle nous faire est juste pour que lorsque notre port est en cours d'exécution, nous verrons ce texte. Allons allez sur notre terminal et on lance notre fichier api.js encore :

Comme nous pouvons le voir, la capture d'écran précédente nous montre que nous écoutons le port 3000. Chaque fois que nous voyons ce texte, nous savons que, nos serveurs fonctionnent.

IV.8.6.2.1 Installation de Postman et de l'analyseur de corps

La première chose qui nous va faire est d'installer un nouveau package appeler nodemon. Dans notre répertoire programmation_BC dans notre terminal, nous écrirons la commande suivante :

[128]

#npm i nodemon --save

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

Après cela, nous apportons une modification dans l'un de nos fichiers et l'enregistrons. Cette bibliothèque nodemon redémarrer automatiquement notre serveur pour nous, afin que nous ne devions pas aller et venir du terminal à notre code pour redémarrer le serveur chaque fois que nous faisons un changement.

Donc, nous allons ouvrir notre fichier package.json. Où il est écrit "scripts", nous allons ajouter un nouveau script :

Figure IV- 85: Automatisation de ce processus

Chaque fois que l'un de ces fichiers JS sont modifiés et enregistrés, nous voulons nodemon pour redémarrer notre fichier dev/api.js pour nous. Sauvegarder le fichier package.json. Maintenant, chaque fois que nous faisons un changement à l'intérieur de notre dossier de développement et l'enregistrer, le serveur se redémarrera tous seul. Testons cela.

Allons à notre terminal. Notre serveur devrait maintenant utiliser nodemon après cette commande

Figure IV- 86: Exécution de nodemon

Nous verrons que notre serveur redémarre tous seul, on va faire une petite modification sur le texte Hello world

app.get('/', function (req, res) {res.send('Hello World!!!'); });

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[129]

Ceci est juste un outil que nous utilisons pour rendre le développement un peu plus facile pour nous.

Maintenant, un autre outil que nous voulons utiliser est appelé Postman. L'outil Postman nous permet d'appeler n'importe quels points de terminaison, ainsi que d'envoyer des données à ces points de terminaison avec nos demandes.

IV.8.6.2.2 L'utilisation de Postman

Téléchargez l'application. Une fois que nous avons téléchargé l'application, nous pouvons effectuer un petit essai de la façon dont nous pouvons utiliser cette application Postman pour atteindre notre point de terminaison / transaction.

Pour tester que le point de terminaison / transaction est travailler, renvoyons quelque chose le résultat. Dans notre point de terminaison / transaction, nous avons ajouté la ligne suivante

app.post('/transaction', function(req,res) {res.send('It works!!!');

Et maintenant, quand nous atteignons ce point, nous devrions obtenir le texte It works!!! Cliquons sur Envoyer et nous obtiendrons la sortie, comme indiqué dans la capture d'écran suivante :

Figure IV- 87: Tester le point de terminaison / transaction

Maintenant, la plupart du temps, nous frappons un message dans notre API, nous allons vouloir lui envoyer des données. Par exemple, lorsque nous atteignons le endpoint / transaction, nous souhaitons créer une nouvelle transaction. Par conséquent, nous devons envoyer les données de transaction, telles que le montant de la transaction, l'expéditeur et le destinataire. Nous pouvons le faire en utilisant Postman, et c'est plus simple. Ce que nous allons faire ici, c'est envoyer des informations dans le corps de notre demande de publication. Vous pouvez le faire en cliquant sur l'onglet Corps comme le montre la figure suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[130]

Figure IV- 88: Envoi des données de transaction à partir du postman

Nous pouvons également voir que nous avons fait un JSON objet et y mettre des données. On a ajouté le montant comme 10 bitcoins, le l'adresse de l'expéditeur et l'adresse du destinataire.

Pour tester si nous recevons ou non toutes ces informations à l'intérieur de notre endpoint, nous allons écrire l'ensemble du corps de la demande. Le req.body est simplement l'information que nous avons créée dans l'objet JSON:

Figure IV- 89: Configuration de req.body

Maintenant, pour que $ {req.body.amount} fonctionne, nous besoin d'installer une autre bibliothèque afin de accéder à ces informations. Revenons en notre terminal ; nous allons quitter le processus et nous allons installer un package appeler body-parser :

Figure IV- 90: Installation de body-parser

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[131]

Maintenant, redémarrons notre serveur avec npm start. Lorsqu'il s'agit d'utiliser l'analyseur de corps, nous voulons simplement l'importer en haut de notre fichier après la ligne où nous application importée.

Figure IV- 91: Importation de fichier body-parser

Maintenant que nous utilisons l'analyseur corporel, nous devrait pouvoir accéder au montant. Enregistrons le fichier api.js et essayons d'envoyer la demande.

Figure IV- 92: Envoi de la demande

Ça a marché ! Nous avons renvoyé la chaîne, qui indique que le montant de la transaction est 10 bitcoins. Dans notre terminal, nous pouvons voir que l'ensemble informations concernant le montant, l'expéditeur, et le destinataire s'affiche :

Figure IV- 93: Réception de la chaine envoyée

IV.8.6.2.3 Construire le /blockchain endpoint

Dans cette section, nous allons interagir avec notre endpoint / blockchain. Cela signifie que nous devra importer notre blockchain de notre Fichier blockchain.js comme ça :

Figure IV- 94: Importation de fichier blockchain.js

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[132]

Tout ce que ce endpoint va faire est de renvoyer toute notre blockchain à celui qui a appelé ce point de terminaison. Pour ce faire, nous allons ajouter une ligne qui enverra la réponse :

Figure IV- 95: Renvoie de la blockchain

Croyez-le ou non, c'est tout ce que nous allons faire pour ce endpoint.

§ Test de /blockchain endpoint :

Maintenant, nous pouvons tester si ce endpoint fonctionne en l'utilisant dans notre navigateur :

Figure IV- 96: Récupération de la chaine blockchain Comme nous pouvons le voir, nous récupérons notre blockchain.

IV.8.6.2.4 Construire la /transaction endpoint

Dans notre / transaction endpoint, nous allons ajouter la ligne suivante :

Figure IV- 97: Créer un nouvel objet de ressource s'appelle transaction

Le résultat sera enregistré dans blockIndex, et c'est ce que nous allons renvoyer à celui qui appelle ce point de terminaison. Nous vous le renverrons sous forme de note : Le résultat sera enregistré dans blockIndex, et c'est ce que nous allons renvoyer à celui qui appelle ce point de terminaison. Nous vous le renverrons sous forme de note.

Comme vous pouvez le voir, la note nous indiquera à quel bloc la transaction sera ajoutée. Nous avons utilisé l'interpolation de chaîne pour passer le valeur blockIndex. Enregistrons ce fichier et testons ce point de terminaison à l'aide de Postman.

§ Test de /transaction endpoint :

Passons maintenant à Postman et appliquons des paramètres similaires à ceux que nous avons définis précédemment :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[133]

Figure IV- 98: Création des données Testons ce point de terminaison :

Figure IV- 99: Test du point de terminaison /transaction

Comme nous pouvons le voir, lorsque nous avons cliqué sur Envoyer bouton sur Postman, nous avons obtenu la sortie La transaction sera ajoutée dans le bloc 2. La raison pour laquelle nous avons le bloc 2 ici est qu'un bloc avait déjà été créé lorsque nous avons lancé notre blockchain, qui a créé la genèse bloquer. Par conséquent, cette transaction a ajouté au bloc 2.

Une autre façon que nous pouvons tester pour nous assurer que ce point de terminaison a fonctionné correctement est en appuyant sur notre / blockchain endpoint.

Figure IV- 100: Réception de la chaine dans le navigateur

Comme nous pouvons le voir, l'objet entier est notre tout blockchain - la première partie est notre chaîne qui a le bloc de genèse, et la deuxième partie est notre transaction en attente, que nous venons d'établi. Notre / transaction endpoint fonctionne à la perfection.

[134]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

IV.8.6.2.5 Construire /mine endpoint

Construisons le point final pour notre API blockchain : le point final de la mine, cela minez et créez un nouveau bloc :

Figure IV- 101: Construire /mine endpoint

Ce qui se passe ici est joli impressionnant. Comme nous pouvons le voir, il y a beaucoup de calculs différents qui entrent dans la création de ce nouveau bloc, et nous sommes en mesure de faire tous ces calculs en utilisant notre structure de données blockchain. Il s'agit d'une structure de données assez puissante, et notre blockchain peut désormais exploiter des nouveaux blocs en utilisant proofOfWork.

Nous allons également faire de notre récompense 12,5 bitcoins. En tant qu'adresse d'expéditeur, nous avons mis la valeur 00. De cette façon, chaque fois nous examinons les transactions sur notre réseau, nous savons que si une transaction est fabriquée à partir de l'adresse 00, c'est une récompense minière. Maintenant, tout ce dont nous avons besoin est l'adresse d'un destinataire, nodeAddress. Nous devons envoyer 12,5 bitcoins à celui qui a extrait un nouveau bloc - mais comment on trouve ça ? Eh bien, nous allons envoyer cette récompense au noeud actuel que nous sommes sur, qui est tout ce fichier API que nous sommes travaillé sur. Nous pouvons traiter cette API entière comme noeud de réseau dans la blockchain bitcoin.

Pour créer une adresse pour ce noeud, nous sommes va importer une nouvelle bibliothèque appelée uuid en utilisant notre terminal :

#npm i uuid

Importons maintenant notre nouvelle bibliothèque uuid aux sections supérieures de notre fichier api.js :

Figure IV- 102: Importation de la bibliothèque UUID

Cette bibliothèque crée une chaîne aléatoire pour nous, et nous allons utiliser cette chaîne comme adresse de ce noeud de réseau. NodeAddress que nous allons obtenir est aléatoire chaîne qui est garantie d'être unique, car nous ne voulons pas avoir deux noeuds avec la même adresse.

Nous testerons maintenant notre / mine endpoint, ainsi que notre / transaction et / blockchain, pour vous assurer qu'ils tous fonctionnent et interagissent correctement.

§ Chapitre IV Sécuriser un réseau bancaire avec la blockchain

Test de /mine endpoint :

Ouvrons un onglet et frappons notre / mine endpoint. Cela devrait exploiter et créer un nouveau bloqué pour nous :

[135]

Figure IV- 103: Test de /mine endpoint

Nous avons obtenu notre note qui dit que le nouveau bloc a été extrait avec succès. Nous avons également récupéré notre nouveau bloc et nous pouvons voir toutes les données qui se trouvent sur notre bloc. Il contient un hachage, et il a également le hachage du bloc précédent, qui est le bloc de genèse, et une transaction en elle. Vous pourriez penser, nous n'avons pas créé une transaction, alors d'où vient cette transaction viens d'où ? Cette transaction est en fait la récompense minière que nous mettons dans notre endpoint, qui a la récompense minière de 12,5 bitcoins transaction. Il ressemble à notre point d'extrémité minier a bien fonctionné.

§ Test de /blockchain endpoint :

Pour tester et nous assurer que nous avons créé ce nouveau bloc, nous pouvons retourner à notre / blockchain endpoint et actualisons la page :

Figure IV- 104: Test de /blockchain endpoint

Ça a marché. Nous avons maintenant deux blocs dans notre chaîne : l'un est le bloc de genèse et l'autre est celui que nous venons de créer. Le deuxième bloc a également la transaction en elle.

Minons des autres blocs pour tester cela à nouveau. Rendez-vous sur notre endpoint / mine et actualisez la page à nouveau :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[136]

Figure IV- 105: Miner plusieurs blocs

Comme nous le voyez, nous avons les trois blocs. Le bloc 3 est celui que nous venons de créer, et il contient notre transaction de récompense minière. Une plus de chose à noter est que notre précédent BlockHash s'aligne réellement avec le hachage de notre bloc 2. C'est aider à sécuriser notre blockchain.

§ Test de /transaction endpoint :

Créons maintenant quelques transactions avec notre / point de terminaison de transaction. Pour cela, rendez-vous sur Postman, assurez-vous que les paramètres sont les comme précédemment, et procédez comme suit changements :

Figure IV- 106: Test de /transaction endpoint

Cette transaction a été ajoutée à bloc 4 parce que nous avons déjà trois blocs dans notre chaîne. Maintenant, allons-y et récupérons notre toute la blockchain à nouveau. Cette fois, nous devrions attendre à obtenir la même blockchain et deux transactions en attente que nous venons d'établi. Rafraîchissons la page et voyons la production :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

Figure IV- 107: Exécution du Test de /transaction endpoint

On remarque que celui-ci comporte trois blocs et trois transactions en attente. Maintenant, si nous nous dirigeons vers notre point d'extrémité / mine et actualiser le page, ces trois transactions en attente seront ajoutées au bloc 4 :

Figure IV- 108: Minage réussi

Maintenant, si nous revenons à notre / endpoint blockchain et le rafraîchir, nous verrons que les deux transactions en attente ont disparu et qu'ils ont été ajoutés au bloc 4 :

Figure IV- 109: Fin de minage

[137]

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[138]

Comme nous pouvons le voir, le bloc 4 a les trois transactions, et on a une seule transaction en attente. Cela a bien fonctionné. Si on mine un autre bloc la transaction en attente disparu et qu'il a été ajouté au bloc 5.

IV.8.6.3 Création d'un réseau décentralisé

La façon dont notre blockchain fonctionne en ce moment est que nous avons une blockchain unique, et le seul moyen d'y accéder est via l'API. Ce serveur est très centralisé, ce qui n'est pas avantageux car l'API est en contrôle total de la blockchain et des données qui s'y ajoute. Toute la technologie blockchain est hébergée sur un réseau décentralisé.

Nous allons construire un réseau de blockchain décentralisé en créant diverses instances de l'API. Chacune de ces instances de l'API va être un noeud de réseau dans notre réseau de blockchain. Tous ces noeuds fonctionneront ensemble pour héberger notre blockchain. Dans cette partie de programmation, nous couvrirons les points suivants :

§ Apprendre à créer et tester plusieurs noeuds.

§ Ajout de currentNodeUrl à notre réseau.

§ Ajout des nouveaux noeuds finaux pour le réseau décentralisé.

§ Construction / node-and-broadcast-node endpoint.

§ Création et test / register-nodeendpoint.

§ Ajout et test du / register-nodes-bulk endpoint.

Donc, commençons par créer notre réseau décentralisé.

IV.8.6.3.1 Création de plusieurs noeuds et l'ajout du currentNodeUrl

La première chose que nous devrons faire pour créer notre réseau décentralisé est d'apporter des modifications à notre fichier api.js.

Etape01 : Pour configurer le réseau décentralisé, nous devrons exécuter le fichier api.js plusieurs fois. Chaque fois que nous exécutons le fichier, nous voulons qu'il agisse comme un noeud de réseau. Faisons-le en exécutant le fichier sur différents ports chaque fois que nous exécutons. Nous devons faire un port variable. Pour ce faire, nous ajoutons la ligne suivante au début du code dans notre dev / api.js :

#const port = process.argv[2];

Etape02 : Accédez au fichier package.json et apportez des modifications à la commande de démarrage. Ce que nous allons faire ici, c'est aller à la fin de notre commande et passer une variable pour le numéro de port sur lequel nous voulons exécuter le noeud de réseau. Dans notre exemple, nous voulons exécuter notre

#"start": "nodemon --watch dev -e js dev/networkNode.js 3001"

Noeud de réseau pour qu'il s'exécute sur le port numéro 3001. Par conséquent, passez 3001 comme variable à la fin de la commande de démarrage :

Quelle est la variable process.argv ? Cette variable fait simplement référence à la commande de démarrage que nous exécutons pour démarrer notre serveur. La première et

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[139]

le deuxième élément de la commande sont constitués de « nodemon --watch dev -e js dev/networkNode.js », et le troisième élément de la commande est la variable « 3001 ».

Etape03 : Nous voulons utiliser la variable de port. Par conséquent, dans le fichier dev / api.js, allons en bas, où nous avons mentionné le code d'écoute du port 3000 et faisons la modification suivante :

#app.listen(port, function() { console.log(`Listening on port ${port}...`); });

Etape04 : Exécutons le fichier api.js. Dans la fenêtre du terminal, saisissez npm start. En tapant cette commande, le serveur doit commencez à écouter le port 3001, comme nous pouvons l'observer dans la capture d'écran suivante :

Figure IV- 110: Exécution de npm start

IV.8.6.3.2 Exécution de multiples noeuds d'api.js

La prochaine chose que nous voudrons faire est d'exécuter plusieurs noeuds de api.js. Pour cela, nous allons ajouter quelques commandes supplémentaires au fichier package.json.

Etape01 : Pour commencer, dans le fichier package.json, nous devons changer la commande "start" en "node_1". Maintenant, lorsque nous exécutons cette commande, il va démarrer notre premier noeud, qui est sur le port 3001.

Etape02 : Au lieu de taper npm start, tapez npm run node_1. Avec l'aide de cette commande, exécutez notre node_1 sur le port 3001.

Etape03 : Dans notre package.json, en tant que troisième paramètre de chacune de nos commandes, nous allons ajouter l'URL du noeud. Par conséquent, notre premier noeud a L'URL http: // localhost: 3001. Il est probable que pour notre deuxième noeud, http: // localhost: 3002. De même, vous pouvez ajouter URL des noeuds restants, comme indiqué dans la capture d'écran suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[140]

Figure IV- 111: Exécution de multiples noeuds d'api.js

Etape04 : Pour notre réseau décentralisé, nous voulons exécuter deux ou trois de ces noeuds en même temps. Pour faire ça, dupliquons la commande "node_1" : "nodemon -watch dev -e js dev / api.js 3001 http://localhost:3001" quatre fois et ensuite modifions ces commandes comme montré dans la capture d'écran suivante :

Figure IV- 112: Modifications dans le fichier package.json

Nous avons maintenant un noeud de réseau en cours d'exécution sur le port 3001 et l'autre noeud de réseau en cours d'exécution sur le port 3002. Suivez un processus similaire pour exécuter les noeuds de réseau restants sur les ports restants.

IV.9.6.3.3 Test des multiples noeuds

Maintenant, nous pourrions avoir tous les cinq noeuds du réseau en cours d'exécution. Ce que nous avons actuellement cinq noeuds de notre API en cours d'exécution, mais elles ne sont pas connectées entre eux. Pour vérifier que ces noeuds de réseau ne sont pas connectés, nous pouvons effectuer quelques tests :

Etape01 : La première transaction que nous voulons faire va être à notre noeud de réseau, qui est hébergé sur le port 3001. Alors, allons-y dans le corps et tapons les données de transaction, comme indiqué dans la capture d'écran suivante :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[141]

Figure IV- 113: Configuration des données de la transaction

Maintenant que nous avons envoyé la transaction donnée aux noeuds du réseau, vérifions-le. Allez dans le navigateur et allez sur localhost : 3001 / blockchain, puis appuyez sur Entrée. On aura à observer un similaire réponse, comme indiqué dans la suite capture d'écran :

Figure IV- 114: Récupération de la chaine de bloc

De la capture d'écran précédente, nous pouvons observer que nous avons une seule transaction en attente pour 3001 bitcoins. C'est l'une des transactions que nous venons d'ajoutée.

Etape02 : Maintenant, dans l'autre onglet, si nous allons à localhost : 3002 / blockchain, nous verrons que aucune transaction en attente, car nous n'avons envoyé aucune transaction à ce noeud de réseau :

Figure IV- 115: Création d'une transaction en attente

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[142]

Etape03 : on fait les mêmes démarches de l'etape1 pour la création d'une transaction sur localhost :3003, Ensuite, si nous allons sur localhost: 3003 / blockchain, nous verrons que nous avons une transaction ici pour un montant de 3003 bitcoins

Si nous devions aller à localhost : 3004 / blockchain et localhost : 3005 / blockchain, il ne devrait pas y avoir les transactions là-bas que nous n'avons envoyé aucune transaction vers ces noeuds de réseau.

IV.8.6.3.4 L'ajoute d'un currentNodeUrl

Passons maintenant au fichier blockchain.js, et à la partie où nous définissons le const, nous allons taper ce qui suit :

#constcurrentNodeUrl = process.argv[3];

Avec cette commande, nous devrions avoir accès à l'URL du noeud actuel en utilisant la variable currentNodeUrl.

Maintenant, nous devons assigner le currentNodeUrl à notre structure de données de la blockchain. Nous le faisons en tapant la ligne de code suivante à l'intérieur de notre fonction Blockchain {} :

#this.networkNodes = [];

# this.currentNodeUrl = currentNodeUrl;

Dans les autres sections, nous remplirons ce tableau avec les URL des noeuds de tous les autres noeuds de notre réseau afin que chaque noeud soit au courant de tous les autres noeuds à l'intérieur de notre réseau blockchain.

IV.8.6.3.5 Aperçu des nouveaux endpoints

IV.8.6.3.5.1 Création de / register-and broadcast-nodeendpoint

Le / registre-node sera le prochain point de terminaison que nous ajouterons à notre réseau. Ceci est défini comme suit :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[143]

Figure IV- 116: Configuration du register node

Nous allons faire cette demande en important une nouvelle bibliothèque. Allons-y vers le terminal pour importer la bibliothèque. Dans le terminal, tapons la commande suivante :

Figure IV- 117: Importation de la bibliothèque request-promise

Jusqu'à présent, nous avons enregistré le nouveau noeud avec le noeud de réseau actuel sur lequel nous sommes et nous avons diffusé le nouveau noeud à tous les autres noeuds de notre réseau. La dernière étape que nous avons effectuée à l'intérieur de ce point de terminaison est de renvoyer une réponse à celui qui l'a appelé.

o Explication comment le registre et noeud de diffusion fonctions :

Nous voulons enregistrer un nouveau noeud avec notre réseau, le noeud final d'enregistrement et de diffusion est le premier point que nous voulons atteindre. La première chose qui nous faisons à l'intérieur de ce point de terminaison prend le newNodeUrl et l'enregistre avec le noeud actuel en le poussant dans notre tableau networkNodes.

La prochaine étape que nous devons faire est de diffuser ce newNodeUrl au reste des noeuds de notre réseau. Nous le faisons à l'intérieur de la boucle forEach. Tout ce qui se passe à l'intérieur de cette boucle est que nous faisons une demande à chacun des autres noeuds de notre réseau. Nous faisons cette demande au point d'extrémité de noeud de registre. Une fois toutes ces demandes terminées sans aucune erreur, nous pouvons supposer que le newNodeUrl a été enregistré avec succès avec tous nos autres noeuds de réseau.

IV.8.6.3.5.2 Construire et tester le / register-nodeendpoint

Maintenant que nous avons construit le / register-and -broadcast-node final, il est temps de passer à certaines choses qui sont un peu moins complexes. Dans cette section, commençons la construction du register-nodeendpoint. Ça va être très simple par rapport au point final que nous avons construit dans la partie précédente.

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[144]

Ce noeud final registre-node est l'endroit où chaque noeud dans le réseau va recevoir la diffusion qui est envoyée par le endpointregister-and-broadcast-node ; ce point registre-node doit faire s'inscrire le nouveau noeud avec le noeud qui reçoit la demande. Pour commencer à créer le endpointregister-node, procédons comme suit :

Figure IV- 118: Construit le / register-and -broadcast-node

§ Test de register-node

Testons-le / register-nodeendpoint pour s'assurer qu'il fonctionne correctement et pour mieux comprendre son fonctionnement.

§ Installation de la bibliothèque request

Maintenant, pour tester le endpoint que nous venons de créer, il est nécessaire d'installer la bibliothèque request selon la version de la bibliothèque de request-promise disponible. Pour installer la bibliothèque de requêtes, allons simplement sur notre terminal, et à l'intérieur nous exécutez la commande suivante :

Figure IV- 119: Installation de la bibliothèque request

§ Test

Pour commencer, nous allons taper http: // localhost: 3001 / register-node dans la barre d'adresse, comme illustre la capture d'écran ci-dessous :

Figure IV- 120: Test de register-node

Ensuite, à l'intérieur de la zone de texte, créons un objet et ajoutons le code suivant :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[145]

Figure IV- 121: Ajout de node url

Pour vérifier cela, allons à Postman et cliquons sur le bouton Envoyer. Nous obtiendrons la réponse Nouveau noeud enregistré avec succès. Maintenant, passons à notre navigateur et tapons localho st: 3001 / blockchain dans la barre d'adresse, puis appuyons nous sur Entrée. Nous verrons une sortie similaire à ce qui est montré dans la capture d'écran suivante :

Figure IV- 122: Obtention de la réponse Nouveau noeud enregistré avec succès

Puisque nous venions d'enregistrer notre deuxième noeud avec notre noeud actuel sur localhost: 3001, nous avons l'URL de notre deuxième noeud à l'intérieur de cet tableau.

IV.8.6.3.5.3 Construire le / register-nodes-bulk endpoint

Le prochain endpoint que nous allons construire s'appelle register-nodes-bulk. Ces trois points sur lesquels nous avons travaillé pour créer notre réseau de blockchain décentralisé.

Le register-nodes-bulk accepte des données contenant les URL de chaque noeud déjà présent dans le réseau. Ensuite, nous allons simplement enregistrer tous ces noeuds de réseau avec le nouveau noeud. Le nouveau noeud est le noeud sur lequel le register-nodes-bulk est atteint.

Pour créer le endpointregister-nodes-bulk, nous devrons faire l'hypothèse que toutes les URL de noeuds qui sont actuellement dans notre réseau sont transmises en tant que données et que nous pouvons les accéder via la propriété req.body.allNetworkNodes. C'est parce que nous envoyons les données allNetworkNodes lorsque nous appelons cela

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[146]

endpoint dans le bloc Promise.all (regNodesPromise). Ici, nous envoyons allNetworkNodes au endpointregister-nodes-bulk. Cela nous donnera accès aux données allNetworkNodes à l'intérieur du endpoint. Ajoutons la ligne de code suivante à notre endpointregister-nodes-bulk.

Figure IV- 123: Construire le / register-nodes-bulk endpoint

Fondamentalement, tout ce que nous déclarons dans la déclaration if est que pendant que nous parcourons chaque noeud de réseau que nous ajoutons, si ce noeud n'est pas déjà présent dans notre réseau de noeuds de réseau et si cela le noeud n'est pas l'URL de notre noeud actuel, alors nous voulons ajouter le networkNodeUrl à notre tableau networkNodes. Une fois que nous avons terminé la boucle forEach, nous aurons enregistré tous les noeuds du réseau qui sont déjà présents à l'intérieur de notre réseau blockchain. Tout ce que nous avons à faire à ce stade est de renvoyer une réponse, comme suit.

§ Test des / register-nodes-bulk :

Nous allons tester notre register-nodes-bulk endpoint pour nous assurer que cela fonctionne correctement. Cela nous permettra de comprendre comment cela fonctionne :

Etape01 : Nous allons diriger vers Postman. Ici, nous allons tapper le localhost: 3001 / register-nodes-bulk. Lorsque nous testons ce endpoint, nous nous attendons à recevoir des données, qui est le tableau allNetworkNodes.

Etape02 : dans l'onglet corps de Postman, avec l'option raw et JSON (application / json) format sélectionné pour le texte, nous ajoutons les lignes de code suivantes au corps :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[147]

Figure IV- 124: Test des / register-nodes-bulk

Lorsque nous exécutons cette demande maintenant, nous devrons enregistrer ces trois URL avec notre noeud qui s'exécute localhost: 3001. Voyons voir si ça marche. Cliquons sur le bouton Send et nous recevrons une réponse qui indique l'enregistrement en bulk réussi comme le montre la capture d'écran suivante :

Figure IV- 125: Recevoir une réponse qui indique l'enregistrement en bulk réussi

Maintenant, si nous nous dirigeons vers le navigateur, nous pouvons vérifier que cela a fonctionné. Dans la barre d'adresse, tapons localhost: 3001 / blockchain puis appuyons sur Entrée. Nous arriverons à observer les trois URL qui ont été ajoutées à l'intérieur du tableau networkNodes, car ce sont enregistrées en bulk :

Chapitre IV Sécuriser un réseau bancaire avec la blockchain

[148]

Figure IV- 126: Ajout réussie de trois url

Donc, il ressemble que notre endpointregister-node-bulk fonctionne comme il se doit.

IV.9 Conclusion

Dans ce chapitre, nous avons commencé par construire un réseau bancaire avec un routage amélioré, sécurisé et rendant le trafic plus efficace. Pour répondre à ce besoin de communication sécurisé, nous avons utilisé un réseau privé virtuel (VPN) avec ses différentes topologies ainsi que les détails sur le protocole IPsec, sans oublier le GRE tunnel qui est un des mécanismes de tunneling. Le trafic qui traverse ce tunnel doit être protégé lors de l'échange de la monnaie. Également dans ce chapitre, nous avons également appris à construire la fonction constructeur, puis nous sommes passés à la création de méthodes étonnantes telles que createNewBlock, creatNewTransaction, getLastBlock, etc. Nous avons ensuite découvert la méthode de hachage, le hachage SHA256, et créé une méthode pour générer un hachage pour nos données de bloc. Nous avons également appris ce qu'est une preuve de travail et comment cela fonctionne. Dans ce chapitre, nous avons également appris à tester les différentes méthodes que nous avons créées et vérifier si elles fonctionnent comme prévu. Dans la deuxième partie ; nous avons appris à configurer une blockchain. Puis, nous avons appris à configurer une blockchain Express.js dans notre projet, ainsi que comment utilisez-le pour construire notre API / serveur. Ensuite nous installé Postman et compris comment utilisez-le pour tester nos endpoints. Après cela, nous passé à construire divers points d'extrémité de notre serveur et testé ceux pour vérifier si ou non, ils fonctionnaient correctement. Dans la prochaine partie, nous allons créer un réseau de noeuds ou réseau décentralisé pour héberger notre blockchain, tout comme ceux qui sont hébergés dans le monde réel. Jusqu'à présent, vous avez accompli beaucoup de choses dans ce Projet Fin d'étude. Nous avons créé une blockchain décentralisée réseau qui fonctionne actuellement sur cinq noeuds, et nous avons créé la fonctionnalité pour synchroniser l'ensemble du réseau, afin que tous les noeuds ont exactement les mêmes données.

[149]