Authentification sécurisée et gestion des utilisateur·ices

La surface d'attaque est énorme

• Credential stuffing (réutilisation de mots de passe leakés)
• Brute force sur le login
• Vol de session (XSS, CSRF, session fixation)
• Énumération de comptes (différentes réponses selon que l'email existe)
• Attaques sur le password reset (token réutilisable, devinable)
• Race conditions sur les MFA

Libs et services à considérer

• Lucia : lib auth open source, contrôle total, code dans ton repo
• Auth.js (ex NextAuth) : standard de l'écosystème Next.js, multi-providers
• Clerk / WorkOS / Supabase Auth : services managés, prêts à l'emploi
• Keycloak / ZITADEL : auth self-hosted entreprise

Les algos recommandés en 2025

• argon2id : recommandé OWASP, résistant aux attaques GPU/ASIC, paramètres modernes
• bcrypt : éprouvé, présent partout, cost factor 12+ en 2025
• scrypt : aussi bon, moins répandu côté JS

argon2id en Node.js

import argon2 from 'argon2';

// Hash à l'inscription
const hash = await argon2.hash(password, {
  type: argon2.argon2id,
  memoryCost: 19456,    // 19 MiB (recommandation OWASP)
  timeCost: 2,
  parallelism: 1,
});

// Vérification au login
const ok = await argon2.verify(hash, passwordSaisi);

bcrypt en Node.js

import bcrypt from 'bcrypt';

// Cost factor 12 = ~250ms par hash (acceptable)
const hash = await bcrypt.hash(password, 12);
const ok = await bcrypt.compare(passwordSaisi, hash);

Sessions serveur

• ID de session aléatoire (32 bytes) en cookie
• État (userId, expiration, données) stocké côté serveur (DB ou Redis)
• Révocation instantanée : tu supprimes la session, l'utilisateur·ice est déconnecté·e
• Plus simple à mettre en place, plus sûr par défaut

JWT (JSON Web Tokens)

• Stateless : tout est dans le token signé
• Pratique en microservices ou architectures distribuées
• Plus dur à révoquer : le token est valide jusqu'à expiration, sauf à maintenir une blacklist côté serveur
• Risque de vol si mal stocké

Le cookie de session sécurisé

import crypto from 'crypto';

// 1. Générer un ID de session aléatoire et imprévisible
const sessionId = crypto.randomBytes(32).toString('base64url');

// 2. Stocker la session côté serveur
await db.session.create({
  data: {
    id: sessionId,
    userId: user.id,
    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
  },
});

// 3. Poser le cookie avec TOUS les flags
res.cookie('sid', sessionId, {
  httpOnly: true,                  // inaccessible en JS (mitige XSS)
  secure: true,                    // HTTPS uniquement
  sameSite: 'lax',                 // mitige CSRF (lax suffit pour la plupart)
  maxAge: 7 * 24 * 60 * 60 * 1000, // 7 jours
});

Recommandation par défaut : sessions serveur. JWT uniquement si tu sais pourquoi tu en as besoin (multi-services, mobile sans backend session).

OAuth2 vs OIDC

• OAuth2 : autorisation. Permet à une app A d'agir au nom de l'utilisateur·ice sur une app B
• OIDC (OpenID Connect) : couche identité par-dessus OAuth2. Te donne qui est l'utilisateur·ice (id, email, profil)
• Pour Sign in with..., on utilise toujours OIDC

Le flow recommandé : Authorization Code + PKCE

1. Ton app génère un code_verifier (aléatoire) et son code_challenge (hash). Stocke state et nonce en session.
2. Redirige l'utilisateur·ice vers le provider avec code_challenge, state, nonce.
3. L'utilisateur·ice s'authentifie chez le provider et donne son consentement.
4. Le provider redirige vers ton callback avec un code.
5. Tu vérifies que le state reçu correspond à celui en session.
6. Tu échanges le code contre un id_token et access_token, en envoyant le code_verifier.
7. Tu valides le id_token (signature, nonce, iss, aud, exp).
8. Tu crées la session locale, tu poses ton cookie.

Libs recommandées

• openid-client : référence Node.js, certifié OpenID
• arctic : minimaliste, multi-providers (Google, GitHub, Discord, etc.)
• Auth.js : full-featured, intégration Next.js native

Le principe

• L'utilisateur·ice saisit son email
• Tu génères un token aléatoire (32 bytes minimum), tu en stockes le hash en base
• Tu envoies le token (en clair) dans un lien par email
• Au clic, tu vérifies le hash, tu invalides le token, tu connectes

Sécurité du token

• Aléatoire cryptographique : crypto.randomBytes, pas Math.random
• 32 bytes minimum (256 bits d'entropie)
• Stocké hashé en base (un attaquant qui dump la DB ne peut pas se logger)
• Single-use : invalidé dès la première utilisation
• TTL court : 10 à 15 minutes maximum
• Nouveau lien généré : invalide l'ancien

import crypto from 'crypto';
import argon2 from 'argon2';

// Génération
const token = crypto.randomBytes(32).toString('base64url');
const tokenHash = await argon2.hash(token);

await db.magicLink.create({
  data: {
    tokenHash,
    userId,
    expiresAt: new Date(Date.now() + 15 * 60 * 1000),  // 15 min
  },
});

// Envoyer l'email avec le token (en clair) dans l'URL
const url = `https://app.fr/magic?token=${token}`;
await sendEmail({ to: user.email, subject: 'Ton lien de connexion', html: `<a href="${url}">Se connecter</a>` });

Pourquoi c'est révolutionnaire

• Résistant au phishing par design : la clé est liée au domaine, impossible à utiliser sur un site pirate
• Pas de secret partagé côté serveur : seule une clé publique est stockée. Un dump de DB ne donne rien à l'attaquant
• UX simple : Touch ID ou Face ID, c'est tout
• Synchronisé entre appareils via iCloud Keychain, Google Password Manager...

Le flux en 2 phases

1. Registration : l'utilisateur·ice crée une passkey, le navigateur génère une paire de clés, envoie la clé publique au serveur
2. Authentification : le serveur envoie un challenge, l'appareil signe avec la clé privée, le serveur vérifie avec la clé publique

Lib recommandée

// Côté serveur : @simplewebauthn/server
import {
  generateRegistrationOptions,
  verifyRegistrationResponse,
  generateAuthenticationOptions,
  verifyAuthenticationResponse,
} from '@simplewebauthn/server';

// Côté client : @simplewebauthn/browser
import { startRegistration, startAuthentication } from '@simplewebauthn/browser';

TOTP avec une app authenticator

• Standard RFC 6238
• Compatible Google Authenticator, Authy, 1Password, Bitwarden
• Code à 6 chiffres qui change toutes les 30 secondes
• Tu génères un secret au moment de l'activation, encodé en QR code

import { authenticator } from 'otplib';
import QRCode from 'qrcode';

// 1. Génération du secret à l'activation
const secret = authenticator.generateSecret();
await db.user.update({
  where: { id: user.id },
  data: { totpSecret: secret, totpEnabled: false },
});

// 2. Affichage QR code à scanner
const otpauth = authenticator.keyuri(user.email, 'MonApp', secret);
const qrDataUrl = await QRCode.toDataURL(otpauth);

// 3. Vérification du code à la connexion
const valid = authenticator.verify({ token, secret });

Recovery codes

• Génère 8 à 10 codes au moment de l'activation TOTP
• Affiche-les une seule fois, demande à l'utilisateur·ice de les sauvegarder
• Stocke-les hashés en base (comme des mots de passe)
• Single-use : chaque code n'est utilisable qu'une fois
• Permets de regénérer la liste (invalide tous les anciens)

Password reset sans faille

• Token aléatoire 32 bytes minimum, stocké hashé
• Usage unique et TTL court (15 minutes max)
• Réponse identique que l'email existe ou non (anti-énumération)
• Invalider toutes les sessions actives après reset (sécurité en cas de compte compromis)
• Logger la demande de reset (IP, timestamp)

app.post('/forgot-password', async (req, res) => {
  const { email } = req.body;

  const user = await db.user.findUnique({ where: { email } });

  // Réponse identique même si user n'existe pas (anti-énumération)
  if (user) {
    const token = crypto.randomBytes(32).toString('base64url');
    const tokenHash = await argon2.hash(token);

    await db.passwordReset.create({
      data: {
        tokenHash,
        userId: user.id,
        expiresAt: new Date(Date.now() + 15 * 60 * 1000),
      },
    });

    await sendResetEmail(user.email, token);
  }

  // Réponse identique dans les deux cas
  res.json({ message: 'Si cet email existe, un lien a été envoyé.' });
});

Rate limiting sur les endpoints sensibles

import rateLimit from 'express-rate-limit';

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,    // 15 min
  max: 5,                       // 5 tentatives par IP
  standardHeaders: true,
  legacyHeaders: false,
  message: 'Trop de tentatives, réessaie dans 15 minutes.',
});

app.post('/login', loginLimiter, handler);
app.post('/forgot-password', rateLimit({ windowMs: 60*60_000, max: 3 }), handler);

Logout et déconnexion globale

• Logout = supprime la session côté serveur, pas seulement le cookie. Sinon, un attaquant qui a volé le cookie reste connecté
• Déconnexion globale = supprime toutes les sessions de l'utilisateur·ice (sur tous les appareils). À proposer dans les paramètres
• Invalider toutes les sessions après changement de mot de passe ou email