Autorisation et authentification dans Node.js : JWT, Passport.js, bcrypt

Autorisation et authentification dans Node.js : Guide complet

Dans le développement web moderne, la sécurité des données utilisateur est une priorité absolue. Dans ce guide, nous allons passer en revue les outils et bibliothèques clés pour implémenter l'authentification (vérification de l'identité de l'utilisateur) et l'autorisation (vérification des droits d'accès) dans les applications Node.js. Vous apprendrez à configurer la protection des routes, à hacher les mots de passe et à travailler avec des jetons d'accès.

1. Concepts de base

• Authentification — processus de vérification qu'un utilisateur est bien celui qu'il prétend être (généralement via un identifiant et un mot de passe).
• Autorisation — détermination des ressources et actions accessibles à un utilisateur authentifié.
• JWT (JSON Web Token) — méthode compacte et autonome de transmission de données sous forme d'objet JSON. Utilisé pour créer des jetons d'accès.
• Sessions — méthode traditionnelle de stockage des données utilisateur sur le serveur (généralement avec express-session).

2. Bibliothèques clés pour Node.js

2.1. bcrypt — hachage des mots de passe

Ne stockez jamais les mots de passe en clair. bcrypt est une bibliothèque pour le hachage sécurisé avec ajout de sel.

const bcrypt = require('bcrypt');const saltRounds = 10;

// Hachage du mot de passeasync function hashPassword(password) {  const salt = await bcrypt.genSalt(saltRounds);  const hash = await bcrypt.hash(password, salt);  return hash;}

// Vérification du mot de passeasync function checkPassword(password, hash) {  const match = await bcrypt.compare(password, hash);  return match; // true ou false}

2.2. jsonwebtoken — travail avec JWT

La bibliothèque jsonwebtoken permet de créer et de vérifier des jetons JWT. Les jetons sont généralement composés d'un en-tête, d'une charge utile (payload) et d'une signature.

const jwt = require('jsonwebtoken');const secretKey = 'votre-clé-secrète';

// Création du jetonfunction generateToken(userId, role) {  const payload = { userId, role };  const token = jwt.sign(payload, secretKey, { expiresIn: '1h' });  return token;}

// Vérification du jeton (middleware)function verifyToken(req, res, next) {  const authHeader = req.headers['authorization'];  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN    if (!token) return res.status(401).json({ error: 'Jeton non fourni' });

  jwt.verify(token, secretKey, (err, decoded) => {    if (err) return res.status(403).json({ error: 'Jeton invalide' });    req.user = decoded;    next();  });}

2.3. Passport.js — authentification universelle

Passport.js est un middleware pour Express, prenant en charge plus de 500 stratégies (locale, OAuth, JWT, Google, Facebook, etc.). Exemple de stratégie locale :

const passport = require('passport');const LocalStrategy = require('passport-local').Strategy;const User = require('./models/User');

passport.use(new LocalStrategy(  async (username, password, done) => {    try {      const user = await User.findOne({ username });      if (!user) return done(null, false, { message: 'Utilisateur non trouvé' });            const isValid = await bcrypt.compare(password, user.password);      if (!isValid) return done(null, false, { message: 'Mot de passe incorrect' });            return done(null, user);    } catch (err) {      return done(err);    }  }));

// Sérialisation et désérialisation (pour les sessions)passport.serializeUser((user, done) => done(null, user.id));passport.deserializeUser(async (id, done) => {  const user = await User.findById(id);  done(null, user);});

3. Exemple complet : inscription et connexion

Assemblons le tout dans une simple application Express.

const express =