À propos de ce cours
Objectifs de la leçon
- Comprendre le rôle de l'access token et du refresh token.
- Émettre et vérifier deux jetons avec des secrets différents.
- Stocker une empreinte du refresh token et appliquer la rotation.
- Détecter la réutilisation d'un refresh token et se déconnecter.
Le dilemme
Un jeton d'accès de 15 minutes limite les dégâts en cas de vol, mais l'utilisateur devrait se reconnecter toutes les 15 minutes. Un jeton de 30 jours est confortable, mais impossible à annuler. La solution utilisée par la plupart des applications :
- un access token court (5 à 15 min), envoyé à chaque requête, vérifié sans base ;
- un refresh token long (7 à 30 jours), envoyé uniquement à la route
/auth/rafraichirpour obtenir une nouvelle paire, et enregistré côté serveur, donc révocable.
Chaque rafraîchissement remplace le refresh token ; une réutilisation révèle un vol.
📄 .env (ajouts)
JWT_REFRESH_SECRET=9e1d7c4a2f8b5e3d0a6c9f2b8e5d1a7c4f0b3e9d6a2c8f5b1e7d4a0c3f9b6e2d
JWT_REFRESH_DUREE=7d
Le service
📄 src/auth/auth.service.ts
import { ForbiddenException, Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { JwtService } from '@nestjs/jwt';
import { InjectRepository } from '@nestjs/typeorm';
import * as bcrypt from 'bcrypt';
import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
import { Repository } from 'typeorm';
import { Utilisateur } from '../utilisateurs/utilisateur.entity';
import { UtilisateursService } from '../utilisateurs/utilisateurs.service';
import { ConnexionDto, InscriptionDto } from './auth.dto';
const sha256 = (t: string) => createHash('sha256').update(t).digest('hex');
@Injectable()
export class AuthService {
constructor(
private readonly utilisateurs: UtilisateursService,
@InjectRepository(Utilisateur) private readonly depot: Repository<Utilisateur>,
private readonly jwt: JwtService,
private readonly config: ConfigService,
) {}
async inscrire(dto: InscriptionDto) {
return this.utilisateurs.create({ ...dto, motDePasse: await bcrypt.hash(dto.motDePasse, 10) });
}
async verifierIdentifiants({ email, motDePasse }: ConnexionDto) {
const u = await this.utilisateurs.findAvecMotDePasse(email);
if (!u || !u.actif || !(await bcrypt.compare(motDePasse, u.motDePasse))) {
throw new UnauthorizedException('E-mail ou mot de passe incorrect');
}
return { id: u.id, email: u.email, role: u.role };
}
// Une paire de jetons : courte durée pour l'accès, longue durée pour le renouvellement
private async emettre(u: { id: number; email: string; role: string }) {
const [accessToken, refreshToken] = await Promise.all([
this.jwt.signAsync({ sub: u.id, email: u.email, role: u.role }), // secret et durée par défaut (15 min)
this.jwt.signAsync({ sub: u.id, jti: randomUUID() }, { // jti : rend chaque jeton unique
secret: this.config.getOrThrow('JWT_REFRESH_SECRET'),
expiresIn: this.config.get('JWT_REFRESH_DUREE', '7d'),
}),
]);
// On ne stocke qu'une EMPREINTE du refresh token (SHA-256 : jeton long et aléatoire, inutile de le ralentir)
await this.depot.update({ id: u.id }, { refreshHache: sha256(refreshToken) });
return { access_token: accessToken, refresh_token: refreshToken };
}
async connecter(dto: ConnexionDto) {
return this.emettre(await this.verifierIdentifiants(dto));
}
async rafraichir(refreshToken: string) {
let charge: { sub: number };
try {
charge = await this.jwt.verifyAsync(refreshToken, { secret: this.config.getOrThrow('JWT_REFRESH_SECRET') });
} catch {
throw new UnauthorizedException('Refresh token invalide ou expiré');
}
const u = await this.depot.findOne({
where: { id: charge.sub },
select: { id: true, email: true, role: true, actif: true, refreshHache: true },
});
if (!u || !u.actif || !u.refreshHache) throw new UnauthorizedException('Session terminée');
const attendu = Buffer.from(u.refreshHache, 'hex');
const recu = Buffer.from(sha256(refreshToken), 'hex');
if (!timingSafeEqual(attendu, recu)) {
// Un ancien refresh token est réutilisé : vol probable → on ferme la session
await this.depot.update({ id: u.id }, { refreshHache: null });
throw new ForbiddenException('Refresh token déjà utilisé : session révoquée, reconnectez-vous');
}
return this.emettre(u); // ROTATION : nouvelle paire
}
async deconnecter(id: number) {
await this.depot.update({ id }, { refreshHache: null });
}
}
📄 src/auth/auth.controller.ts
import { Body, Controller, Get, HttpCode, Post } from '@nestjs/common';
import { IsJWT } from 'class-validator';
import { Public, Utilisateur, UtilisateurConnecte } from './auth.decorators';
import { ConnexionDto, InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';
class RafraichirDto {
@IsJWT()
refreshToken: string;
}
@Controller('auth')
export class AuthController {
constructor(private readonly authService: AuthService) {}
@Public() @Post('inscription')
inscrire(@Body() dto: InscriptionDto) {
return this.authService.inscrire(dto);
}
@Public() @Post('connexion') @HttpCode(200)
connecter(@Body() dto: ConnexionDto) {
return this.authService.connecter(dto);
}
@Public() @Post('rafraichir') @HttpCode(200) // public : l'access token est peut-être expiré
rafraichir(@Body() dto: RafraichirDto) {
return this.authService.rafraichir(dto.refreshToken);
}
@Post('deconnexion') @HttpCode(204)
deconnecter(@Utilisateur('id') id: number) {
return this.authService.deconnecter(id);
}
@Get('profil')
profil(@Utilisateur() u: UtilisateurConnecte) {
return u;
}
}
Les points clés du code
- Deux secrets: un access token ne peut pas servir de refresh token, et réciproquement.
jti(identifiant unique) : sans lui, deux refresh tokens émis dans la même seconde pour le même utilisateur seraient identiques.- Empreinte en base: on ne stocke pas le jeton lui-même (une fuite de la base donnerait des sessions utilisables), mais son SHA-256. Un seul refresh token valide par utilisateur (une session) ; pour plusieurs appareils, on utiliserait une table
sessions. - Rotation: chaque rafraîchissement renvoie une nouvelle paire et remplace l'empreinte. L'ancien refresh token devient inutilisable.
- Détection de vol: si un ancien refresh token est présenté, quelqu'un l'a copié. On révoque la session : le voleur et l'utilisateur légitime devront se reconnecter.
timingSafeEqualcompare en temps constant (pas de fuite par chronométrage).
const port = app.getHttpServer().address().port;
const post = async (url: string, corps: unknown, entetes: Record<string, string> = {}) => {
const r = await fetch(`http://localhost:${port}${url}`, { method: 'POST', headers: { 'content-type': 'application/json', ...entetes }, body: JSON.stringify(corps) });
const t = await r.text();
return { statut: r.status, corps: t ? JSON.parse(t) : null };
};
const court = (j: string) => j.slice(0, 12) + '…' + j.slice(-8);
await post('/api/auth/inscription', { email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' });
const c = await post('/api/auth/connexion', { email: 'sami@exemple.tn', motDePasse: 'Formation2026' });
const r0 = c.corps.refresh_token;
console.log('1. connexion →', c.statut, '| access', court(c.corps.access_token), '| refresh', court(r0));
const r1 = await post('/api/auth/rafraichir', { refreshToken: r0 });
console.log('2. rafraîchir avec R0 →', r1.statut, '| nouvelle paire, refresh', court(r1.corps.refresh_token));
await appel('GET', '/api/auth/profil', { entetes: { authorization: `Bearer ${r1.corps.access_token}` } });
const vol = await post('/api/auth/rafraichir', { refreshToken: r0 });
console.log('3. réutiliser R0 (ancien) →', vol.statut, JSON.stringify(vol.corps));
const apres = await post('/api/auth/rafraichir', { refreshToken: r1.corps.refresh_token });
console.log('4. le refresh R1, pourtant récent →', apres.statut, JSON.stringify(apres.corps), '(session révoquée)');
const c2 = await post('/api/auth/connexion', { email: 'sami@exemple.tn', motDePasse: 'Formation2026' });
const acces = { authorization: `Bearer ${c2.corps.access_token}` };
console.log('5. nouvelle connexion →', c2.statut);
console.log('6. access token utilisé comme refresh →', (await post('/api/auth/rafraichir', { refreshToken: c2.corps.access_token })).statut);
const d = await post('/api/auth/deconnexion', {}, acces);
console.log('7. déconnexion →', d.statut);
const r3 = await post('/api/auth/rafraichir', { refreshToken: c2.corps.refresh_token });
console.log('8. rafraîchir après déconnexion →', r3.statut, JSON.stringify(r3.corps));
await appel('GET', '/api/auth/profil', { entetes: acces });
console.log(' ↑ l\'access token reste valide jusqu\'à son expiration (15 min) : c\'est pourquoi il doit être court');
Résultat réellement obtenu :
1. connexion → 200 | access eyJhbGciOiJI…nJgMlz8c | refresh eyJhbGciOiJI…NP8awshY
2. rafraîchir avec R0 → 200 | nouvelle paire, refresh eyJhbGciOiJI…MJoerfWc
GET /api/auth/profil → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
3. réutiliser R0 (ancien) → 403 {"message":"Refresh token déjà utilisé : session révoquée, reconnectez-vous","error":"Forbidden","statusCode":403}
4. le refresh R1, pourtant récent → 401 {"message":"Session terminée","error":"Unauthorized","statusCode":401} (session révoquée)
5. nouvelle connexion → 200
6. access token utilisé comme refresh → 401
7. déconnexion → 204
8. rafraîchir après déconnexion → 401 {"message":"Session terminée","error":"Unauthorized","statusCode":401}
GET /api/auth/profil → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
↑ l'access token reste valide jusqu'à son expiration (15 min) : c'est pourquoi il doit être court
9. deux refresh tokens émis à 1 s d'intervalle : différents ? true | mêmes 72 premiers caractères ? true
bcrypt.compare(jeton B, bcrypt(jeton A)) = true ← bcrypt ignore la suite : faille
Lecture
- 1 et 2: la connexion renvoie la paire ; le rafraîchissement avec R0 donne une nouvelle paire (R1), et le nouvel access token fonctionne.
- 3: R0 présenté à nouveau → 403, la session est révoquée…
- 4: … si bien que R1, pourtant le plus récent, est refusé : l'utilisateur doit se reconnecter. C'est le prix de la sécurité en cas de vol.
- 5 à 8: un access token n'est pas accepté comme refresh token (secret différent) ; après déconnexion, le refresh token est refusé.
- Mais l'access token, lui, fonctionne toujours après la déconnexion : il reste valide jusqu'à son expiration. C'est pourquoi il doit être court.
Pourquoi SHA-256 et pas bcrypt ?
La dernière partie de l'exécution le démontre : deux refresh tokens différents, émis à une seconde d'intervalle pour le même utilisateur, ont les mêmes 72 premiers caractères (l'en-tête et le début de la charge sont identiques). bcrypt ignorant tout ce qui dépasse 72 octets (leçon 13.2), bcrypt.compare accepte un jeton à la place de l'autre : un ancien jeton volé serait accepté. De nombreux tutoriels font cette erreur. Un refresh token est long et aléatoire (signature, jti) : une empreinte rapide comme SHA-256 suffit, la lenteur de bcrypt ne sert qu'aux mots de passe humains, faciles à deviner.
Côté client: l'access token en mémoire ; le refresh token dans un cookie HttpOnly, Secure, SameSite=Strict, limité au chemin /api/auth/rafraichir. Un intercepteur Angular (chapitre 18) détecte les 401, appelle /auth/rafraichir, puis rejoue la requête initiale.
Activités
Activité 1 Plusieurs appareils
Remplacez la colonne refresh_hache par une entité Session (utilisateur, empreinte, appareil, dernière utilisation, expiration), pour qu'un utilisateur puisse être connecté sur son téléphone et son ordinateur. Comment se déconnecter d'un seul appareil ? De tous ?
Voir le corrigé
Le refresh token contient l'identifiant de session (sid) au lieu de jti. Rafraîchir : retrouver la session par sid, comparer l'empreinte, la remplacer. Déconnexion d'un appareil : supprimer sa session ; de tous : supprimer toutes les sessions de l'utilisateur (utile après un changement de mot de passe). En cas de réutilisation détectée, on supprime la session concernée.
Activité 2 Le refresh token en cookie
Modifiez la connexion pour placer le refresh token dans un cookie HttpOnly (avec @Res({ passthrough: true })) et la route /auth/rafraichir pour le lire depuis ce cookie (cookie-parser).
Voir le corrigé
@Public() @Post('connexion') @HttpCode(200)
async connecter(@Body() dto: ConnexionDto, @Res({ passthrough: true }) res: Response) {
const { access_token, refresh_token } = await this.authService.connecter(dto);
res.cookie('refresh_token', refresh_token, {
httpOnly: true, secure: true, sameSite: 'strict',
path: '/api/auth/rafraichir', maxAge: 7 * 24 * 3600 * 1000,
});
return { access_token }; // le refresh token n'apparaît plus dans le corps
}
@Public() @Post('rafraichir') @HttpCode(200)
rafraichir(@Req() req: Request) {
return this.authService.rafraichir(req.cookies?.refresh_token ?? '');
}
Activité 3 Révoquer au changement de mot de passe
Ajoutez PATCH /auth/mot-de-passe (ancien et nouveau mot de passe). Après le changement, toutes les sessions doivent être fermées. Vérifiez qu'un refresh token obtenu avant est refusé.
Voir le corrigé
Vérifier l'ancien mot de passe avec bcrypt.compare, hacher le nouveau, et mettre refreshHache à null dans la même mise à jour. L'ancien refresh token est alors refusé (« Session terminée »). C'est le comportement attendu si le compte a été compromis. Le TP 8 implémente cette route.
Activité 4 Vérifier la faille bcrypt
Dans un service de test, stockez l'empreinte d'un refresh token avec bcrypt.hash, faites une rotation, puis présentez l'ancien jeton. Est-il accepté ? Refaites l'essai avec SHA-256.
Voir le corrigé
Avec bcrypt, l'ancien jeton est accepté dès que ses 72 premiers caractères coïncident avec ceux du nouveau, ce qui est le cas pour deux jetons du même utilisateur (même en-tête, même début de charge) : la rotation ne protège plus de rien. Avec SHA-256, toute la chaîne compte : l'ancien jeton est refusé.
À retenir
- Access token court (15 min, chaque requête) + refresh token long (7 j, seulement /auth/rafraichir).
- Deux secrets différents ; jti pour rendre chaque refresh token unique.
- Stocker l'empreinte SHA-256 du refresh token (pas bcrypt : limite des 72 octets), comparer avec timingSafeEqual.
- Rotation à chaque rafraîchissement ; un ancien jeton réutilisé → session révoquée.
- Déconnexion = effacer l'empreinte ; l'access token reste valide jusqu'à son expiration.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !