Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Passport et les stratégies (local, jwt)

Cette leçon remplace le guard écrit à la main par Passport, la bibliothèque d'authentification la plus utilisée avec Node.js, intégrée par @nestjs/passport. Elle écrit une stratégie local qui vérifie ...

0 chapitres 0 QCM Accès gratuit
Passport et les stratégies (local, jwt)

À propos de ce cours

Cette leçon remplace le guard écrit à la main par Passport, la bibliothèque d'authentification la plus utilisée avec Node.js, intégrée par @nestjs/passport. Elle écrit une stratégie local qui vérifie e-mail et mot de passe, et une stratégie jwt qui vérifie le jeton puis relit l'utilisateur en base. L'exécution montre la connexion, l'accès au profil, les refus et un point important : un compte désactivé est refusé même avec un jeton encore valide. La leçon explique le rôle de validate, les options de la stratégie JWT et les avantages de Passport. Activités corrigées.

Objectifs de la leçon

  • Comprendre le fonctionnement de Passport et de ses stratégies.
  • Écrire une stratégie local (e-mail + mot de passe).
  • Écrire une stratégie jwt qui relit l'utilisateur.
  • Utiliser AuthGuard('local') et AuthGuard('jwt').
Pourquoi Passport ?

Passport propose plus de 500 stratégies d'authentification : identifiant et mot de passe (passport-local), JWT (passport-jwt), Google, GitHub, Microsoft, clés API… Toutes s'utilisent de la même façon. @nestjs/passport les transforme en guards NestJS. Notre guard de la leçon 13.4 fonctionnait ; Passport apporte une structure standard et la possibilité d'ajouter d'autres modes de connexion sans réécrire le reste.

npm install @nestjs/passport passport passport-local passport-jwt
npm install -D @types/passport-local @types/passport-jwt

Stratégies Passport local et jwt

Chaque stratégie a sa méthode validate, dont le résultat devient req.user.

La stratégie local

📄 src/auth/local.strategy.ts

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-local';
import { AuthService } from './auth.service';

// Stratégie « local » : e-mail + mot de passe envoyés dans le corps
@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {          // nom par défaut : 'local'
  constructor(private readonly authService: AuthService) {
    super({ usernameField: 'email', passwordField: 'motDePasse' });
  }

  // Appelée par Passport ; ce qui est renvoyé devient req.user
  validate(email: string, motDePasse: string) {
    return this.authService.verifierIdentifiants({ email, motDePasse });    // lève 401 si incorrect
  }
}
La stratégie jwt

📄 src/auth/jwt.strategy.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { UtilisateursService } from '../utilisateurs/utilisateurs.service';

export interface ChargeJwt {
  sub: number;
  email: string;
  role: string;
}

// Stratégie « jwt » : jeton dans l'en-tête Authorization: Bearer …
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {            // nom par défaut : 'jwt'
  constructor(
    config: ConfigService,
    private readonly utilisateurs: UtilisateursService,
  ) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: config.getOrThrow<string>('JWT_SECRET'),
      ignoreExpiration: false,
    });
  }

  // Appelée APRÈS la vérification de la signature et de l'expiration
  async validate(charge: ChargeJwt) {
    const utilisateur = await this.utilisateurs.findById(charge.sub);
    if (!utilisateur || !utilisateur.actif) throw new UnauthorizedException('Compte désactivé ou supprimé');
    return { id: utilisateur.id, email: utilisateur.email, nom: utilisateur.nom, role: utilisateur.role };
  }
}
  • jwtFromRequest: où trouver le jeton (ici l'en-tête Bearer ; il existe aussi fromExtractors pour lire un cookie).
  • secretOrKey: le même secret que celui qui signe les jetons.
  • validate(charge) n'est appelée que si le jeton est valide et non expiré. On y relit l'utilisateur: une requête SQL par appel, mais un compte désactivé ou supprimé est refusé immédiatement, et le rôle est toujours à jour.
Le contrôleur et le module

📄 src/auth/auth.controller.ts

import { Body, Controller, Get, HttpCode, Post, Req, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { Request } from 'express';
import { InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';

type Utilisateur = { id: number; email: string; nom: string; role: string };

@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)
  @UseGuards(AuthGuard('local'))                 // Passport vérifie e-mail + mot de passe AVANT le handler
  connecter(@Req() req: Request & { user: Utilisateur }) {
    return this.authService.genererJeton(req.user);
  }

  @Get('profil')
  @UseGuards(AuthGuard('jwt'))                   // Passport vérifie le jeton
  profil(@Req() req: Request & { user: Utilisateur }) {
    return req.user;
  }
}

📄 src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { UtilisateursModule } from '../utilisateurs/utilisateurs.module';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';
import { LocalStrategy } from './local.strategy';

@Module({
  imports: [
    UtilisateursModule,
    PassportModule,
    JwtModule.registerAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        secret: config.getOrThrow<string>('JWT_SECRET'),
        signOptions: { expiresIn: config.get('JWT_DUREE', '15m') },
      }),
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy, JwtStrategy],
})
export class AuthModule {}

Dans AuthService, la méthode connecter devient genererJeton(utilisateur): la vérification du mot de passe est faite par la stratégie avant le handler.

  const b = '/api/auth';
  const port = app.getHttpServer().address().port;
  await appel('POST', `${b}/inscription`, { corps: { email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' } });
  await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn', motDePasse: 'mauvais' } });
  await appel('POST', `${b}/connexion`, { corps: { email: 'sami@exemple.tn' } });
  const r = await fetch(`http://localhost:${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, '(jeton reçu)');
  await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token}` } });
  await appel('GET', `${b}/profil`, { entetes: { authorization: 'Bearer abc.def.ghi' } });
  await appel('GET', `${b}/profil`);
  await app.get(DataSource).query("UPDATE utilisateurs SET actif = 0 WHERE email = 'sami@exemple.tn'");
  console.log('(compte de Sami désactivé en base, jeton toujours valide)');
  await appel('GET', `${b}/profil`, { entetes: { authorization: `Bearer ${access_token}` } });

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 → 401 {"message":"E-mail ou mot de passe incorrect","error":"Unauthorized","statusCode":401}
POST /api/auth/connexion → 401 {"message":"Unauthorized","statusCode":401}
POST /api/auth/connexion → 200 (jeton reçu)
GET /api/auth/profil → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
GET /api/auth/profil → 401 {"message":"Unauthorized","statusCode":401}
GET /api/auth/profil → 401 {"message":"Unauthorized","statusCode":401}
(compte de Sami désactivé en base, jeton toujours valide)
GET /api/auth/profil → 401 {"message":"Compte désactivé ou supprimé","error":"Unauthorized","statusCode":401}
Lecture
  • Mauvais mot de passe : notre UnauthorizedException (levée par verifierIdentifiants dans validate) est transmise telle quelle.
  • Mot de passe absent : passport-local refuse avant d'appeler validate, avec le message standard « Unauthorized ». Le guard s'exécutant avant les pipes (leçon 9.4), le ValidationPipe n'a pas pu valider le corps.
  • Jeton faux ou absent : « Unauthorized » de passport-jwt.
  • Compte désactivé en base : le jeton est toujours valide, mais validate relit l'utilisateur et le refuse.

Relire ou non l'utilisateur ? Sans relecture, validate peut simplement renvoyer la charge : aucune requête SQL, mais un compte désactivé garde l'accès jusqu'à l'expiration du jeton. Avec relecture, une requête par appel (rapide sur une clé primaire). Pour une API de gestion, la relecture est généralement préférable.

Activités

Activité 1 Des messages plus clairs

Créez LocalAuthGuard extends AuthGuard('local') et redéfinissez handleRequest(err, user, info) pour renvoyer « E-mail et mot de passe obligatoires » quand info indique des identifiants manquants.

Voir le corrigé
@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {
  handleRequest<T>(err: unknown, user: T, info?: { message?: string }): T {
    if (err) throw err;                                         // notre UnauthorizedException
    if (!user) {
      throw new UnauthorizedException(info?.message === 'Missing credentials' ? 'E-mail et mot de passe obligatoires' : 'Authentification refusée');
    }
    return user;
  }
}

Activité 2 Lire le jeton dans un cookie

Modifiez JwtStrategy pour accepter le jeton dans l'en-tête ou dans un cookie access_token (avec cookie-parser).

Voir le corrigé
// main.ts : app.use(cookieParser());
super({
  jwtFromRequest: ExtractJwt.fromExtractors([
    ExtractJwt.fromAuthHeaderAsBearerToken(),
    (req: Request) => req?.cookies?.access_token ?? null,
  ]),
  secretOrKey: config.getOrThrow<string>('JWT_SECRET'),
});

Activité 3 Sans relecture

Écrivez une variante de validate qui ne relit pas la base. Mesurez avec logging: true le nombre de requêtes SQL pour 10 appels à /auth/profil dans les deux versions. Quand préférer chaque version ?

Voir le corrigé

Sans relecture : 0 requête ; avec : 10 SELECT … WHERE id = ?. Sans relecture convient aux jetons très courts et aux microservices où l'utilisateur n'est pas dans la base locale ; avec relecture convient quand il faut pouvoir bloquer un compte immédiatement. Un cache de quelques secondes (chapitre 15) peut combiner les deux.

Activité 4 Une seconde stratégie

Ajoutez une stratégie cle-api (paquet passport-headerapikey ou stratégie personnalisée avec passport-custom) pour les applications partenaires, et protégez une route avec AuthGuard(['jwt', 'cle-api']). Que signifie ce tableau ?

Voir le corrigé

Un tableau de stratégies signifie « l'une ou l'autre » : Passport essaie la première, puis la suivante en cas d'échec. La route accepte donc un utilisateur connecté (JWT) ou une application partenaire (clé API). Chaque stratégie a son nom (second argument de PassportStrategy(Strategy, 'cle-api')).

À retenir

  • @nestjs/passport transforme les stratégies Passport en guards : AuthGuard('local'), AuthGuard('jwt').
  • LocalStrategy : usernameField/passwordField, validate(email, mdp) → utilisateur ou 401.
  • JwtStrategy : jwtFromRequest, secretOrKey ; validate(charge) appelée après vérification du jeton.
  • Ce que renvoie validate devient req.user.
  • Relire l'utilisateur dans validate : compte désactivé refusé immédiatement, rôle à jour.

Cet article vous a-t-il aidé ?