Authentification : JWT et bcrypt 🔐

Les bases de l'authentification

L'authentification consiste à vérifier l'identité d'un utilisateur. Le flux typique :

1. L'utilisateur s'inscrit (email + mot de passe)
2. Le mot de passe est haché et stocké en base
3. À la connexion, on vérifie le mot de passe
4. On génère un token JWT pour les requêtes suivantes

---

Hacher les mots de passe avec bcrypt

npm install bcrypt

import bcrypt from 'bcrypt';

// Hacher un mot de passe
const motDePasse = 'monSecret123';
const salt = await bcrypt.genSalt(10);
const hash = await bcrypt.hash(motDePasse, salt);
console.log(hash); // "$2b$10$..."

// Vérifier un mot de passe
const estValide = await bcrypt.compare('monSecret123', hash);
console.log(estValide); // true

const estFaux = await bcrypt.compare('mauvais', hash);
console.log(estFaux); // false

💡 Ne JAMAIS stocker les mots de passe en clair. bcrypt les hache avec un algorithme unidirectionnel.

---

Générer des tokens JWT

npm install jsonwebtoken

import jwt from 'jsonwebtoken';

const SECRET = process.env.JWT_SECRET || 'ma-cle-secrete';

// Générer un token
const token = jwt.sign(
  { userId: '123', role: 'admin' },
  SECRET,
  { expiresIn: '24h' }
);

console.log(token); // "eyJhbGciOiJIUzI1NiIs..."

// Vérifier un token
const decoded = jwt.verify(token, SECRET);
console.log(decoded); // { userId: '123', role: 'admin', iat: ..., exp: ... }

---

Middleware d'authentification

import jwt from 'jsonwebtoken';

export function authMiddleware(req, res, next) {
  const header = req.headers.authorization;
  if (!header || !header.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Token manquant' });
  }

  const token = header.split(' ')[1];
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Token invalide' });
  }
}

---

Routes d'inscription et connexion

import { Router } from 'express';
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';

const router = Router();
const SECRET = process.env.JWT_SECRET;

// POST /api/auth/register
router.post('/register', async (req, res) => {
  const { email, motDePasse } = req.body;
  const hash = await bcrypt.hash(motDePasse, 10);
  const user = { id: Date.now().toString(), email, hash };
  res.status(201).json({ message: 'Compte créé', userId: user.id });
});

// POST /api/auth/login
router.post('/login', async (req, res) => {
  const { email, motDePasse } = req.body;
  const user = { id: '1', email, hash: '$2b$10$...' };

  if (!user) return res.status(401).json({ error: 'Identifiants incorrects' });

  const estValide = await bcrypt.compare(motDePasse, user.hash);
  if (!estValide) return res.status(401).json({ error: 'Identifiants incorrects' });

  const token = jwt.sign({ userId: user.id }, SECRET, { expiresIn: '24h' });
  res.json({ token });
});

export default router;

---

Utilisation dans les routes protégées

import { authMiddleware } from './middleware/auth.js';

router.get('/profile', authMiddleware, (req, res) => {
  res.json({ message: `Bienvenue user ${req.user.userId}` });
});

---

Résumé

---

Exercices 🎯

1. Implémente un système complet inscription/connexion avec Prisma et bcrypt
2. Ajoute un endpoint GET /profile qui retourne les infos de l'utilisateur connecté
3. Implémente un système de rôles (admin/user) avec un middleware requireRole('admin')