Ce tutoriel de Passport.js vous guide à travers les étapes de mise en place d'une stratégie d'authentification Node.js utilisation locale Redis. Vous apprendrez à créer une interface d'authentification avec Passport.js, où les utilisateurs fourniront leurs noms d'utilisateur et mots de passe. Malgré sa complexité, les mécanismes d'authentification peuvent être facilement implémentés dans Node.js.
Technologies à utiliser
Avant de passer la tête la première à notre didacticiel d'authentification Passport.js, jetons un coup d'œil aux technologies que nous allons utiliser dans ce chapitre.
Qu'est-ce que Passport.js?
- Passport.js est un middleware d'authentification Node.js simple et discret pour Node.js
- Passport.js peut être placé dans n'importe quelle application Web Express.js.
- Passeport c'est un middleware authentification pour Node.js que nous allons utiliser pour la gestion de session.
Qu'est-ce que Redis?
Redis est un magasin de structure de données en mémoire open source (sous licence BSD), utilisé comme base de données, cache et courtier de messages.
Redis est conçu pour prendre en charge différents types de structures de données abstraites, telles que des chaînes, des hachages, des listes, des ensembles, des ensembles ordonnés avec des requêtes de plage, des bitmaps, des hyperliens et des index géospatiaux avec des requêtes radio.
Nous stockerons les informations de la session de notre utilisateur dans Redis, et pas dans la mémoire du processus. De cette façon, notre application sera beaucoup plus facile à mettre à l'échelle.
L'application de démonstration qui nécessite une authentification
À des fins de démonstration, construisons une application qui ne fait que ce qui suit:
- exposer un formulaire de connexion,
- exposer deux pages protégées:
- une page de profil,
- notes sécurisées
La structure du projet
Nous allons utiliser la structure suivante:
├── app | ├── authentification | ├── note | ├── utilisateur | ├── index.js | └── layout.hbs ├── config | └── index.js ├── index.js └── package.json
Comme vous pouvez le voir, nous organiserons les fichiers et répertoires autour des caractéristiques. Nous aurons une page utilisateur, une page de notes et quelques fonctions liées à l'authentification.
Le flux d'authentification Node.js
Notre objectif est d'implémenter le flux d'authentification suivant dans notre application en utilisant Passport.js:
- L'utilisateur entre le nom d'utilisateur et le mot de passe
- L'application vérifie si elles correspondent.
- S'ils correspondent, envoyez un en-tête Set-Cookie à utiliser pour authentifier d'autres pages.
- Lorsque l'utilisateur visite des pages du même domaine, le cookie précédemment configuré sera ajouté à toutes les demandes
- Authentifiez les pages restreintes avec ce cookie.
Pour configurer une stratégie d'authentification comme celle-ci dans une application Node.js à l'aide de Passport.js, procédez comme suit:
Étape 1: Configuration express
Nous allons utiliser Express pour le cadre de serveur.
// fichier: app / index.js const express = require ('express') const passeport = require ('passeport') const session = require ('express-session') const RedisStore = require ('connect-redis') ( session) const app = express () app.use (session ({store: new RedisStore ({url: config.redisStore.url}), secret: config.redisStore.secret, resave: false, saveUninitialized: false})) app .use (passeport.initialiser ()) app.use (passeport.session ())
Qu'avons-nous fait ici?
Tout d'abord, nous avons besoin de toutes les dépendances dont la gestion de session a besoin. Après cela, nous avons créé une nouvelle instance du module session express, qui stockera nos sessions.
Pour le magasin de sauvegarde, nous utilisons Redis, mais vous pouvez utiliser n'importe quel autre, comme MySQL ou MongoDB.
Étape 2: Configuration de Passport.js pour Node.js
Passport.js est un excellent exemple de bibliothèque qui utilise des plugins. Dans ce tutoriel de passeport.js, nous ajoutons le module passeport local qui permet une intégration facile d'une stratégie d'authentification locale simple à l'aide de noms d'utilisateur et de mots de passe.
Par souci de simplicité, dans cet exemple, nous n'utilisons pas un deuxième magasin de stockage, mais uniquement une instance utilisateur en mémoire. Dans les applications réelles, findUser il rechercherait un utilisateur dans une base de données.
// fichier: app / authenticate / init.js const passeport = require ('passeport') const bcrypt = require ('bcrypt') const LocalStrategy = require ('passport-local'). Stratégie const user = {username: 'test -user ', passwordHash:' bcrypt-hashed-password ', id: 1} passeport.use (new LocalStrategy ((username, password, done) => {findUser (username, (err, user) => {if (err )) {return done (err)} // Utilisateur introuvable if (! user) {return done (null, false)} // Toujours utiliser des mots de passe hachés et des comparaisons à temps fixe bcrypt.compare (password, user.passwordHash, ( err, isValid) => {if (err) {return done (err)} if (! isValid) {return done (null, false)} return done (null, user)})})}))
Une fois les retours de findUser avec notre objet utilisateur, il ne reste plus qu'à comparer le mot de passe de hachage de l'utilisateur et le mot de passe réel pour voir s'il y a une correspondance. Stockez toujours les mots de passe hachés et utilisez la comparaison de temps fixe pour éviter les attaques de temps.
S'il s'agit d'une correspondance, nous autorisons l'utilisateur à saisir: return done (null, utilisateur) (renvoyer à l'utilisateur le passeport), sinon nous renvoyons une erreur non autorisée (ne renvoyant rien au passeport- retour terminé (nul)).
Étape 3: Ajouter des points de terminaison protégés
Pour ajouter des points de terminaison protégés, nous exploitons le modèle de middleware Qu'est ce que tu utilises Express. Pour cela, nous allons créer le middleware authentification d'abord:
// fichier: app / authentication / middleware.js function authenticationMiddleware () {return function (req, res, next) {if (req.isAuthenticated ()) {return next ()} res.redirect ('/')}}
Il n'a un rôle que si l'utilisateur est authentifié (a les bons cookies); appelle juste le suivant middleware. Sinon, il redirige vers la page sur laquelle l'utilisateur peut se connecter.
Son utilisation est aussi simple que l'ajout d'un nouveau middleware à la définition de la route.
// fichier: app / user / init.js const passeport = require ('passeport') app.get ('/ profil', passeport.authenticationMiddleware (), renderProfile)
Résumé - Authentification avec Passport.js
Dans ce didacticiel Passport.js, vous avez appris à ajouter une authentification de base à votre application Node.js. Plus tard, vous pouvez l'étendre avec différentes stratégies d'authentification, telles que Facebook ou Twitter Vous pouvez trouver plus de stratégies sur http://passportjs.org/.
