À propos de ce cours
Objectifs de la leçon
- Configurer JwtModule avec la configuration de l'application.
- Émettre un jeton d'accès à la connexion.
- Écrire un guard qui vérifie le jeton et identifie l'utilisateur.
- Envoyer le jeton depuis un client (fichier .http, Angular).
Le jeton émis à la connexion accompagne chaque requête suivante.
Configuration
📄 .env
# .env
JWT_SECRET=4f8c2e9a7d1b6f3e0c5a8d2b7e4f1a9c6d3b0e8f5a2c7d4b1e9f6a3c0d8b5e2f
JWT_DUREE=15m
# générer un secret : node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
📄 src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { JwtModule } from '@nestjs/jwt';
import { UtilisateursModule } from '../utilisateurs/utilisateurs.module';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { JwtAuthGuard } from './jwt-auth.guard';
@Module({
imports: [
UtilisateursModule,
JwtModule.registerAsync({
inject: [ConfigService],
useFactory: (config: ConfigService) => ({
secret: config.getOrThrow<string>('JWT_SECRET'),
signOptions: { expiresIn: config.get('JWT_DUREE', '15m') },
}),
}),
],
controllers: [AuthController],
providers: [AuthService, JwtAuthGuard],
})
export class AuthModule {}
registerAsync lit le secret avec getOrThrow: sans secret, l'application refuse de démarrer, ce qui est voulu. expiresIn accepte une durée ('15m', '1h', '7d') ou un nombre de secondes.
Émettre le jeton
📄 src/auth/auth.service.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcrypt';
import { UtilisateursService } from '../utilisateurs/utilisateurs.service';
import { ConnexionDto, InscriptionDto } from './auth.dto';
const COUT_BCRYPT = 10;
@Injectable()
export class AuthService {
constructor(
private readonly utilisateurs: UtilisateursService,
private readonly jwt: JwtService,
) {}
async inscrire(dto: InscriptionDto) {
const motDePasse = await bcrypt.hash(dto.motDePasse, COUT_BCRYPT);
return this.utilisateurs.create({ ...dto, motDePasse }); // le rôle n'est PAS choisi par le client
}
async verifierIdentifiants({ email, motDePasse }: ConnexionDto) {
const utilisateur = await this.utilisateurs.findAvecMotDePasse(email);
const valide = utilisateur !== null && (await bcrypt.compare(motDePasse, utilisateur.motDePasse));
if (!utilisateur || !valide || !utilisateur.actif) {
throw new UnauthorizedException('E-mail ou mot de passe incorrect'); // même message dans tous les cas
}
const { motDePasse: _, ...publicUtilisateur } = utilisateur;
return publicUtilisateur;
}
async connecter(dto: ConnexionDto) {
const utilisateur = await this.verifierIdentifiants(dto);
const charge = { sub: utilisateur.id, email: utilisateur.email, role: utilisateur.role }; // pas de donnée sensible
return {
access_token: await this.jwt.signAsync(charge),
token_type: 'Bearer',
expires_in: 900,
};
}
}
La réponse suit les conventions d'OAuth 2 : access_token, token_type: "Bearer" et expires_in en secondes. La charge ne contient que l'identifiant (sub), l'e-mail et le rôle.
Vérifier le jeton : un guard
📄 src/auth/jwt-auth.guard.ts
import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Request } from 'express';
export interface ChargeJwt {
sub: number;
email: string;
role: string;
}
@Injectable()
export class JwtAuthGuard implements CanActivate {
constructor(private readonly jwt: JwtService) {}
async canActivate(context: ExecutionContext): Promise<boolean> {
const req = context.switchToHttp().getRequest<Request & { user?: ChargeJwt }>();
const [type, jeton] = req.headers.authorization?.split(' ') ?? [];
if (type !== 'Bearer' || !jeton) throw new UnauthorizedException('Jeton manquant');
try {
req.user = await this.jwt.verifyAsync<ChargeJwt>(jeton); // vérifie la signature ET l'expiration
} catch (e) {
throw new UnauthorizedException((e as Error).name === 'TokenExpiredError' ? 'Jeton expiré' : 'Jeton invalide');
}
return true;
}
}
📄 src/auth/auth.controller.ts
import { Body, Controller, Get, HttpCode, Post, Req, UseGuards } from '@nestjs/common';
import { Request } from 'express';
import { ConnexionDto, InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';
import { ChargeJwt, JwtAuthGuard } from './jwt-auth.guard';
@Controller('auth')
export class AuthController {
constructor(private readonly authService: AuthService) {}
@Post('inscription')
inscrire(@Body() dto: InscriptionDto) {
return this.authService.inscrire(dto);
}
@Post('connexion')
@HttpCode(200)
connecter(@Body() dto: ConnexionDto) {
return this.authService.connecter(dto);
}
@Get('profil')
@UseGuards(JwtAuthGuard)
profil(@Req() req: Request & { user: ChargeJwt }) {
return req.user; // placé par le guard
}
}
const b = '/api/auth';
await appel('POST', `${b}/inscription`, { corps: { email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' } });
const r = await fetch(`http://localhost:${app.getHttpServer().address().port}${b}/connexion`, {
method: 'POST', headers: { 'content-type': 'application/json' },
body: JSON.stringify({ email: 'sami@exemple.tn', motDePasse: 'Formation2026' }),
});
const { access_token } = await r.json();
console.log('POST /api/auth/connexion →', r.status, '{ access_token: "' + access_token.slice(0, 36) + '…", token_type: "Bearer", expires_in: 900 }');
await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token}` } });
await appel('GET', `${b}/profil`);
await appel('GET', `${b}/profil`, { entetes: { authorization: access_token } });
await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token.slice(0, -3)}abc` } });
const expire = await app.get(JwtService).signAsync({ sub: 1, email: 'sami@exemple.tn', role: 'stagiaire' }, { expiresIn: '1s' });
await new Promise((ok) => setTimeout(ok, 1500));
await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${expire}` } });
Résultat réellement obtenu :
POST /api/auth/inscription → 201 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire","actif":true,"creeLe":"…"}
POST /api/auth/connexion → 200 { access_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9…", token_type: "Bearer", expires_in: 900 }
GET /api/auth/profil → 200 {"sub":1,"email":"sami@exemple.tn","role":"stagiaire","iat":1794731062,"exp":1794731962}
GET /api/auth/profil → 401 {"message":"Jeton manquant","error":"Unauthorized","statusCode":401}
GET /api/auth/profil → 401 {"message":"Jeton manquant","error":"Unauthorized","statusCode":401}
GET /api/auth/profil → 401 {"message":"Jeton invalide","error":"Unauthorized","statusCode":401}
GET /api/auth/profil → 401 {"message":"Jeton expiré","error":"Unauthorized","statusCode":401}
Lecture
- Le client envoie le jeton dans l'en-tête
Authorization: Bearer <jeton>(« porteur » : celui qui présente le jeton est considéré comme son propriétaire). - Le guard (leçon 9.4) place la charge vérifiée dans
req.user, que le handler lit ensuite. - Jeton absent, ou envoyé sans le mot
Bearer→ « Jeton manquant ». Jeton modifié → « Jeton invalide ». Jeton expiré → « Jeton expiré » : le client sait qu'il doit se reconnecter (ou rafraîchir, leçon 13.8). - Aucune requête SQL n'a été nécessaire pour vérifier le jeton : c'est l'intérêt d'un jeton sans état. La contrepartie : un compte désactivé reste utilisable jusqu'à l'expiration (leçon 13.5).
Envoyer le jeton depuis un client
### Se connecter et récupérer le jeton (extension REST Client de VS Code)
# @name connexion
POST http://localhost:3000/api/auth/connexion
Content-Type: application/json
{ "email": "sami@exemple.tn", "motDePasse": "Formation2026" }
### Utiliser le jeton de la réponse précédente
GET http://localhost:3000/api/auth/profil
Authorization: Bearer {{connexion.response.body.access_token}}
// Angular (chapitre 18) : un intercepteur HTTP ajoute l'en-tête à chaque requête
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const jeton = inject(AuthService).jeton();
return next(jeton ? req.clone({ setHeaders: { Authorization: `Bearer ${jeton}` } }) : req);
};
Pour que le navigateur puisse envoyer l'en-tête Authorization depuis une autre origine (Angular sur le port 4200), CORS doit l'autoriser : app.enableCors({ origin: 'http://localhost:4200' }) autorise par défaut les en-têtes demandés par le navigateur.
Activités
Activité 1 Ajouter des claims
Ajoutez à la charge le nom de l'utilisateur et un claim iss (émetteur) valant api-formation. Modifiez la vérification pour refuser un jeton dont l'émetteur est différent. Où configurer cela une seule fois ?
Voir le corrigé
JwtModule.registerAsync({
inject: [ConfigService],
useFactory: (config: ConfigService) => ({
secret: config.getOrThrow('JWT_SECRET'),
signOptions: { expiresIn: '15m', issuer: 'api-formation' },
verifyOptions: { issuer: 'api-formation' }, // verifyAsync refusera un autre émetteur
}),
}),
Activité 2 Durée de vie
Passez JWT_DUREE à 30s, connectez-vous, attendez 35 secondes et appelez /auth/profil. Quel message obtenez-vous ? Quelle durée choisir en production, et pourquoi pas 30 jours ?
Voir le corrigé
« Jeton expiré » (401). En production, entre 5 et 30 minutes pour un jeton d'accès : un jeton volé n'est utilisable que peu de temps, et un changement de rôle est pris en compte rapidement. 30 jours rendraient le vol d'un jeton très grave, sans moyen de l'annuler. Le confort (ne pas se reconnecter souvent) est apporté par le refresh token (leçon 13.8).
Activité 3 Sécuriser le secret
Ajoutez JWT_SECRET au schéma de validation de la configuration (chapitre 10) : chaîne obligatoire d'au moins 32 caractères. Testez avec JWT_SECRET=secret.
Voir le corrigé
JWT_SECRET: Joi.string().min(32).required(),
JWT_DUREE: Joi.string().pattern(/^\d+[smhd]$/).default('15m'),
Avec secret, l'application refuse de démarrer (« JWT_SECRET length must be at least 32 characters long ») : un secret trop court est découvert par force brute.
Activité 4 Un décorateur pour req.user
Remplacez @Req() req dans profil() par un décorateur @Utilisateur() (leçon 9.6) qui renvoie req.user ou l'un de ses champs.
Voir le corrigé
export const Utilisateur = createParamDecorator((champ: keyof ChargeJwt | undefined, ctx: ExecutionContext) => {
const user = ctx.switchToHttp().getRequest().user as ChargeJwt;
return champ ? user?.[champ] : user;
});
@Get('profil')
@UseGuards(JwtAuthGuard)
profil(@Utilisateur() u: ChargeJwt) { return u; }
À retenir
- JwtModule.registerAsync : secret et durée lus dans la configuration (getOrThrow pour le secret).
- Connexion : jwt.signAsync({ sub, email, role }) → { access_token, token_type, expires_in }.
- Le client envoie Authorization: Bearer <jeton> à chaque requête.
- Un guard vérifie avec verifyAsync (signature + expiration) et place la charge dans req.user ; sinon 401.
- Vérification sans base de données : rapide, mais pas de révocation immédiate.
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 !