Jeton daccès nodejs

Authentification basée sur des jetons dans Node.js Utilisation de JWT : une vue d’ensemble

Dans ce tutoriel Nodejs, nous allons en savoir plus sur les jetons Web JSON (JWT) et comment créer un jeton à l’aide de JSON Web Tokens (JWT) sur l’authentification de l’utilisateur pour sécuriser l’API NodeJS. Nous allons créer un nouvel exemple d’application à l’aide d’Express-generator, puis modifier l’application pour créer un jeton à l’aide de JWT afin de vérifier l’accès de l’utilisateur à l’API. Commençons par obtenir une vue d’ensemble de l’authentification.

Authentification Simplement

, nous savons que l’authentification n’est rien d’autre que la vérification de l’identité de l’utilisateur à des fins de sécurité. Auparavant, (ancienne approche), nous utilisions l’authentification basée sur le serveur, où les informations enregistrées étaient stockées sur le serveur en créant une session pour une identification plus poussée. Pensez aux informations enregistrées stockées qui vont correspondre à l’utilisateur connecté pour l’identité sur chaque demande adressée au serveur pour la fourniture de données. Cela peut entraîner des problèmes de performances lors de la gestion de réponses plus authentifiées par le serveur.

Lire la suite - Questions d’entretien Node JS pour une authentification expérimentée

basée sur des jetons

Voici l’authentification basée sur les jetons, ce qui signifie que le serveur répondra avec un jeton généré lors de la connexion de l’utilisateur, qui sera enregistré dans le client au lieu d’être stocké dans le serveur pour être utilisé pour d’autres demandes. Sur chaque requête client, le jeton doit passer avec l’en-tête qui vérifiera dans le serveur pour servir les données. L’idée est beaucoup plus simple, une fois que vous vous connectez, il suffit de demander avec un jeton valide pour obtenir des données sur chaque demande. Différents types d’authentification basée sur des jetons NodeJS :

• Passport
• JSON Web Tokens (JWT)
• Bcrypt

Dans notre application, nous allons utiliser JWT pour sécuriser nos API.

JSON Web Tokens (JWT)

Selon le site Web JWT : « JSON Web Token (JWT) est une norme ouverte (RFC 7519) qui définit un moyen compact et autonome de transmettre en toute sécurité des informations entre les parties en tant qu’objet JSON. » Simply JSON Web Token (JWT) est une chaîne codée permettant de transmettre des informations entre les parties en toute sécurité.

Voici l’exemple de chaîne JWT :

« eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InNoYXNoYW5na2EiLCJwYXNzd29yZCI6IjEyMzQ1IiwiaWF0IjoxNTM2MjgwMjM1LCJleHAiOjE1MzYyODAyNjV9.iplar3jWiW8rh1gU1H6pYaPu6-njCfflrP8GLbx9Imw »

Il comporte trois parties séparées par « . », où la première partie de couleur violette est l’en-tête, puis la partie de couleur bleue est la charge utile, puis la signature est de couleur verte. Lorsqu’un utilisateur demande des données au serveur, cette chaîne JWT doit être transmise avec l’en-tête pour vérifier l’identification de l’utilisateur sur le serveur. L’écran suivant montre comment JWT va fonctionner à la demande d’un client.

Jusqu’à présent, nous avons appris l’authentification basée sur les jetons et nous nous sommes familiarisés avec JWT. Voyons maintenant comment générer le JWT à l’aide d’un exemple d’application en NodeJS, généré par Express-generator.

Comme

vous pouvez le voir sur l’écran ci-dessous, l’application générée avec quelques étapes simples à l’aide de Express-generator. Si vous avez besoin d’aide, veuillez suivre notre article précédent sur la prise en main d’Express et de Express-generator. Ouvrez l’application avec Visual Code comme l’écran ci-dessous.

Après l’installation des dépendances de package, il est temps d’exécuter l’application. Allez dans l’onglet terminal dans Visual Code puis tapez « npm start » pour démarrer l’application avec le port prédéfini 3000.

Ouvrez Postman pour tester l’application en entrant l’URL de la requête « localhost :3000 ». Comme vous pouvez le voir sur l’écran ci-dessous Notre application fonctionne correctement sur le port 3000.

Créons un nouvel itinéraire pour la connexion de l’utilisateur. Accédez à Visual Code Explorer pour ouvrir le fichier « users.js », puis ajoutez l’extrait de code ci-dessous.

Connexion de l’utilisateur

/* Poster la connexion des utilisateurs. */ router.post('/login', function (req, res, next) { let userdata = { nom d’utilisateur : req.body.nom d’utilisateur, mot de passe : req.body.password } ; //Aller au serveur pour varificarion utilisateur if (userdata.username == « shashangka » && userdata.password == « 12345 ») { res.status(200).json({ message : 'Connexion réussie' }) ; } else { res.status(401).json({ message : 'Échec de la connexion' }) ; } }) ; }) ; }) ;

C’est là que nous allons valider les utilisateurs pour l’émission du jeton qui va passer à chaque requête au serveur. Comme vous pouvez le voir sur l’écran ci-dessous, la connexion est réussie pendant que nous naviguons avec l’URL :.

Nous sommes prêts à passer à l’étape suivante avec le Installation du package « jsonwebtoken ». Tapez « npm install jsonwebtoken » puis appuyez sur Entrée pour installer le package dans l’application.

Ouvrez package.json pour voir le paquet installé.

Créons un objet JWT en incluant le module « jsonwebtoken » dans le fichier « users.js » à l’aide de la fonction require().

let jwt = require('jsonwebtoken') ;

Ici

, nous générons un jeton en utilisant la méthode « jwt.sign() », qui a une méthode surchargée comme définition suivante.

• jwt.sign(charge utile : chaîne | Zone tampon | object, secret : Secret, [options] : SignOptions)

• jwt.sign(charge utile : chaîne | Zone tampon | object, secret : Secret, [callback : SignCallback])

• jwt.sign(charge utile : chaîne | Zone tampon | object, secret : Secret, [options : Les

options et les fonctions de rappel sont facultatives. Créons un fichier de configuration pour stocker la clé secrète et l’algorithme de hachage pour une utilisation ultérieure dans la génération de jetons.

module.exports = { secretKey : « Shashangka Shekhar », algorithme : 'HS256', //default : HS256 } ;

Voici la liste de l’algorithme de signature

• HS256 : HMAC utilisant l’algorithme de hachage SHA-256 (par défaut)

• HS384 : HMAC utilisant l’algorithme de hachage SHA-384

• HS512 : HMAC utilisant l’algorithme de hachage SHA-512

• RS256 : RSASSA utilisant l’algorithme de hachage SHA-256

• RS384 : RSASSA utilisant l’algorithme de hachage SHA-384

• RS512 : RSASSA à l’aide de l’algorithme

• de hachage SHA-512 ES256 : ECDSA à l’aide de la courbe P-256 et de l’algorithme de hachage SHA-256

• ES384 : ECDSA à l’aide de la courbe P-384 et de l’algorithme de hachage SHA-384

• ES512 : ECDSA à l’aide de la courbe P-521 et de l’algorithme de hachage SHA-512

• Aucun : Aucune signature numérique ou valeur MAC n’est incluse

Enregistrez ensuite le module auprès de l’application dans app.js.

global.config = require('./config') ;

À partir de l’extrait de code suivant, vous remarquerez peut-être que le premier argument transmet les données de connexion de l’utilisateur appelées charge utile, puis le second transmet la clé secrète qui est configurée dans un fichier de configuration. Enfin, le paramètre facultatif permet de passer des objets avec des options de validité de jeton et de chiffrement.

let token = jwt.sign(userdata, global.config.secretKey, { algorithm : global.config.algorithm, expiresIn : '1m' }) ;

dans Réponse Ajoutez une nouvelle propriété « jwtoken » avec la valeur de retour de la chaîne de jeton.

res.status(200).json({ message : 'Connexion réussie', jwtoken : token }) ;

Enfin, les utilisateurs Module

var express = require('express') ; var router = express. Routeur() ; let jwt = require('jsonwebtoken') ; /* GET liste des utilisateurs. */ router.get('/', function (req, res, next) { res.send('répondre avec une ressource') ; }) ; /* Connexion des utilisateurs post-utilisateurs. */ router.post('/login', function (req, res, next) { let userdata = { nom d’utilisateur : req.body.nom d’utilisateur, mot de passe : req.body.password } ; //Aller au serveur pour varificarion d’utilisateur if (userdata.username == « shashangka » && userdata.password == « 12345 ») { let token = jwt.sign(userdata, global.config.secretKey, { algorithm : global.config.algorithm, expiresIn : '1m' }) ; res.status(200).json({ message : 'Connexion réussie', jwtoken : token }) ; } else { res.status(401).json({ message : 'Échec de la connexion' }) ; } }); module.exports = routeur;

En utilisant Postman browse avec l’URL :. À partir de l’écran suivant, comme nous pouvons le voir, le jeton est généré.

Le jeton généré est valide pendant une minute, vous pouvez le configurer sept jours par « 7d » pour augmenter la validité. Ensuite, nous allons créer un module client qui va gérer la demande du client en vérifiant le jeton porteur pour servir les données. Créez un fichier customers.js à l’aide de la capture d’écran suivante dans Visual Code Explorer.

Copiez-collez le code ci-dessous dans votre fichier js nouvellement créé.

var express = require('express') ; var router = express. Routeur() ; /* GET liste de clients. */ router.get('/', function (req, res, next) { res.send('répondre avec une ressource') ; }) ; module.exports = routeur ;

Incluez le module dans le fichier app.js avec la ligne de code ci-dessous.

var customersRouter = require('./routes/customers') ;

Activez l’itinéraire en app.js avec la ligne de code suivante.

app.use('/customers', customersRouter) ;

Allez dans Postman, puis entrez l’URL de la demande. L’itinéraire nouvellement créé fonctionne bien, comme vous pouvez le voir sur la capture d’écran ci-dessous.

Dans cette section, nous allons vérifier le jeton à l’aide d’un middleware au niveau du routeur. Créons un autre itinéraire pour répondre aux demandes des clients qui retournent avec une liste de données. Tout d’abord, accédons aux données sans aucune autorisation.

/* Obtenir des listes de clients sans protection. */ router.get('/data', function (req, res, next) { let customerdata = [ { customerid : 1, customername : 'Mahfuz Bappy' }, { customerid : 2, customername : 'Shamim Uddin' }, { customerid : 3, customername : 'Ishani Isha' } ] ; res.json(customerdata) ; }) ;

Comme vous pouvez le voir dans Postman pendant que nous naviguons en entrant l’URL :le serveur répond avec une liste de données sans aucune validation de sécurité, qui n’est pas sécurisée afin que tout le monde puisse facilement accéder aux données du serveur.

Voici le middleware pour vérifier l’autorisation d’accès aux données du serveur. Créons un middleware nommé « verifytoken » dans le dossier routes.

Accès au jeton

Ici, nous allons accéder au jeton à partir de l’en-tête de la demande par le nom de clé « x-access-token », qui est généré lors de la connexion de l’utilisateur.

var express = require('express') ; var router = express. Routeur() ; router.use(function (req, res, next) { var token = req.headers['x-access-token'] ; console.log(token) ; }) ; module.exports = routeur ;

Copiez-collez l’extrait de code dans le fichier nouvellement créé, puis incluez-le dans customer.js par la ligne de code ci-dessous.

let verifyToken = require('./verifytoken') ;

Transmettez le middleware en tant que paramètre comme la ligne ci-dessous avec le chemin d’itinéraire existant.

router.get('/data', verifyToken, function (req, res, next)

Vérifier le jeton

Dans cette partie, nous allons vérifier le jeton accédé pour l’autorisation de l’utilisateur à l’aide de la méthode « jwt.verify() ».

Définition de méthode

• jwt.verify(token : string, secret : Secret)
• jwt.verify(token : string, secret : Secret, [options] : VerifyOptions)
• jwt.verify(token : string, secret : Secret, [callback : VerifyCallback])
• jwt.verify(token : string, secret : Secret, [options : VerifyOptions, callback : VerifyCallback])

L’exemple de code suivant permet de vérifier le jeton. Le premier argument est la chaîne de jeton, l’argument suivant est la clé secrète et le dernier est l’algorithme utilisé pour décoder le jeton. jwt.verify(token, global.config.secretKey, { algorithm : global.config.algorithm }, function (err, decoded) { if (err) { let errordata = { message : err.message, expiredAt : err.expiredAt } ; console.log(errordata) ; return res.status(401).json({ message : 'Accès non autorisé' }) ; } req.decoded = décodé ; console.log(décodé) ; suivant() ; });

Enfin, le Middleware

var express = require('express') ; var router = express. Routeur() ; var jwt = require('jsonwebtoken') ; router.use(function (req, res, next) { var token = req.headers['x-access-token'] ; console.log(token) ; if (token) { jwt.verify(token, global.config.secretKey, { algorithm : global.config.algorithm }, function (err, decoded) { if (err) { let errordata = { message : err.message, expiredAt : err.expiredAt } ; console.log(errordata) ; return res.status(401).json({ message : ' Accès non autorisé' }) ; } req.decoded = decoded ; console.log(decoded) ; next() ; }) ; } else { return res.status(403).json({ message : 'Accès interdit' }) ; } }); module.exports = routeur ;

Allez sur Postman et naviguez avec l’URL : pour régénérer le jeton en utilisant des informations de connexion valides.

alors entrez l’URL : passez le token généré dans l’en-tête « x-access-token » en le copiant et en le collant dans la section valeur. Après cela, cliquez sur le bouton d’envoi pour envoyer la demande au serveur.

À partir de l’écran ci-dessus, comme vous pouvez le voir, le serveur a répondu avec le retour des données JSON après une vérification réussie du jeton. Voici le terminal de commande de connexion à la console du code visuel où les informations de jeton et de charge utile sont imprimées à la demande du client.

Si le jeton n’est pas valide ou a expiré, le serveur répondra par un message « Accès non autorisé » au lieu de servir les données.

Comme vous pouvez le voir sur l’écran ci-dessous, le message de jeton expiré est imprimé dans le terminal de commande avec le code d’état 401.

Ça y est, enfin, nous savons comment sécuriser les requêtes serveur par une authentification basée sur des jetons sans stocker d’informations

Résumé

Cet article examine l’utilisation de JSON Web Tokens (JWT) pour sécuriser Node.js API. Il décrit l’authentification basée sur des jetons comme une alternative au stockage de session côté serveur, en mettant l’accent sur des avantages tels que l’absence d’état et l’amélioration des performances. L’article examine ensuite les JWT, leur structure et comment les produire et les valider dans une application Node.js à l’aide du package « jsonwebtoken ». Enfin, il montre comment utiliser un middleware pour créer une autorisation basée sur un jeton afin de protéger les points de terminaison d’API.