Implémentation du jeton Web JSON (JWT) à l'aide de Node.js

Les JWT offrent un moyen de gérer les problèmes de sécurité. Dans cet article, découvrez comment générer un JWT en quatre étapes.

Les serveurs Web doivent gérer les problèmes de sécurité en possédant la capacité d'accorder ou de refuser l'accès à n'importe quelle entité sur ses ressources.

Cela peut être fait en utilisant plusieurs méthodes. , dont l'une est les sessions, où le serveur utilise un identifiant de session, qui est attaché à un cookie dans une demande d'authentification d'un utilisateur. Les sessions fonctionnent bien avec quelques problèmes, tels que la nécessité de conserver les identifiants de session dans la base de données.

Une autre option populaire que nous explorerons et implémenterons dans cet article est avec JSON Web Token (JWT). Pour plus d'informations sur les JWT, consultez mon article précédent ici.

Sans plus tarder, commençons par générer un jeton Web JSON à l'aide de Node.js.

Prérequis

Pour obtenir le meilleur à partir de cet article, je suppose que vous avez une connaissance de base des éléments suivants :

Comment générer un JWT

Dans cette section, nous allons apprendre comment les JWT sont créés à partir de zéro.

Remarque : Autre des packages tiers existent qui résument les complexités de la création de JWT, mais nous les implémenterons à partir de zéro pour plus de clarté.

Configuration de l'espace de travail

Ouvrez votre terminal et insérez ce qui suit :[19659013]mkdir nœud-jwt
cd nœud-jwt
toucher index.js

Le code ci-dessus crée un répertoire appelé node-jwtpuis crée un fichier appelé index.js à l'intérieur du répertoire.

Générer un JWT implique de faire le suivant :

1. Génération d'un en-tête codé en Base64
2. Génération d'une charge utile codée en Base64
3. Génération d'une signature à l'aide d'un secret et des résultats des étapes 1 et 2
4. Combinaison des résultats générés aux étapes 1, 2 et 3[19659020]Avant de passer par chaque étape ci-dessus, insérez les méthodes d'assistance suivantes dans votre fichier index.js pour nous aider à réaliser ce qui suit :
   1. Convertir une chaîne en Base64 :

   const[19659023]toBase64 = obj => {
      
      const str = JSON.stringify ( obj);
      
      retourner Buffer.de(str).àString[19659025]('base64');
   };
   

   Ici, nous définissons une fonction qui attend un objet. Il est d'abord converti en chaîne, puis en tampon codé en Base64 et renvoyé.

   2. Remplacez les symboles spéciaux dans une chaîne Base64 :

   const replaceSpecialChars = b64string =>[19659025]{
   
     return b64string.replace (/[=+/]/g, charToBeReplaced => {[19659053]switch (charToBeReplaced) {
         case '=':
           return '';
         case  '+':
           retour '-';
         cas '/':
           retour '_'[19659029];
       }
     });
   };
   

   Vous vous demandez peut-être pourquoi nous avons besoin d'une autre méthode pour remplacer certains symboles dans une chaîne Base64. La raison en est que les chaînes Base64 contiennent des symboles qui sont mal interprétés lorsqu'ils sont utilisés dans une URL.

   C'est-à-dire que ces symboles ne sont pas compatibles avec les URL lorsque vous travaillez avec des JWT. Vous trouverez ci-dessous un tableau répertoriant tous les éléments et leurs remplacements pour plus de clarté.

   Caractère	Replacement
   “=”	“”
   “+”	“–”
   “/”	“_”

   Ensuite, continuez en créant un exemple d'en-tête pour le jeton à l'aide d'un objet.

   
   const header = {
     alg: 'HS256',
     typ: 'JWT',
   };
   const b64Header = toBase64 (header );
   const jwtB64Header = replaceSpecialChars(b64Header);
   console.log ("l'en-tête est : ",jwtB64Header);
   
   

   Il ne se passe pas grand-chose ici. Nous avons commencé par créer un exemple d'objet pour être l'en-tête d'un JWT et l'encoder dans une URL Base64.

   Étape 2 : Générer la charge utile

   Comme l'en-tête, nous créons la charge utile d'un jeton à partir d'un objet.

   
    charge utile const = {
     iss: 'a_random_server_name',
     exp: 872990,
     
     nom : 'John Bobo',
     email: 'monemail@test.com',
     isHuman: true,
   };
   
   const b64Payload = toBase64 (payload)[19659029];
   const jwtB64Payload = replaceSpecialChars (b64Payload);
   console.log ("la charge utile est : ",jwtB64Payload);
   
   

   De même, nous avons créé et encodé un objet représentant le jeton vers une URL Base64.

   Étape 3 : Génération de la signature

   La ​​signature est ce qui rend un JWT digne de confiance. Pour en générer un, nous utilisons l'un des modules de base de Node appelé crypto. Le module crypto fournit des fonctionnalités cryptographiques qui incluent un ensemble de wrappers pour les fonctions de hachage, HMAC, chiffrement, déchiffrement, signature et vérification d'OpenSSL.

   Ajoutez ce qui suit à votre fichier index.js :

   
   const crypto = require ('crypto');
   const createSignature =(jwtB64Header,jwtB64Payload,secret)=>{
   
       let siginature = crypto.createHmac  ('sha256', secret);
   
   
   
       signature.update (jwtB64Header + '.' + jwtB64Payload);
   
   
       signature = signature.digest ('base64');
   
   
       signature = replaceSpecialChars (signature);
       return signature
   }
   
   const secret = 'super_secret_society';
   const signature= createSignature([19459604]jwtB ,jwtB64Payload,secret);
   console.log ("la signature est :",signature);
   
   

   Nous avons défini une fonction qui crée une signature en concaténant l'en-tête codé en Base64, un point et la charge utile obtenue à partir des étapes 1 et 2 ci-dessus. Ensuite, à l'aide d'un secret, la fonction génère un code d'authentification de message de hachage (HMAC) à l'aide d'un algorithme de hachage (sha256 dans ce cas), qui est ensuite codé en une URL Base64 et est renvoyé.

   Étape 4 : Combiner les résultats dans Étapes 1, 2 et 3

   
   const jsonWebToken = jwtB64Header + '.' + jwtB64Payload + '.'  + signature;
   console.log ("le JWT est :",jsonWebToken);
   
   
   

   Exécution du code

   Enregistrer l'index .js et ouvrez votre terminal et exécutez ce qui suit :

   node index.js
   

   Conclusion

   J'espère que vous vous êtes bien amusé. en apprendre davantage sur les JWT et toutes les choses intéressantes entourant leur structure et leur mise en œuvre. Bien que les JWT fournissent un moyen flexible d'authentifier les utilisateurs, ils souffrent toujours de différents types d'attaques telles que CSRF et XSS s'ils ne sont pas utilisés correctement. Une compréhension claire de ce guide vous donne un avantage pour commencer à les utiliser et à les explorer en profondeur dans vos futurs projets.