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

Protéger les routes avec un guard JWT et routes publiques

Cette leçon adopte la règle « tout est protégé, sauf ce qui est déclaré public ». Un JwtAuthGuard qui étend AuthGuard('jwt') est enregistré globalement avec APP_GUARD, et consulte un décorateur @Publi...

0 chapitres 0 QCM Accès gratuit
Protéger les routes avec un guard JWT et routes publiques

À propos de ce cours

Cette leçon adopte la règle « tout est protégé, sauf ce qui est déclaré public ». Un JwtAuthGuard qui étend AuthGuard('jwt') est enregistré globalement avec APP_GUARD, et consulte un décorateur @Public lu par Reflector pour laisser passer certaines routes. La connexion combine @Public et la stratégie local. Un décorateur @Utilisateur donne accès à l'utilisateur connecté. L'exécution montre un catalogue public, une action protégée refusée sans jeton puis acceptée, et le comportement des routes inexistantes. La leçon explique pourquoi « fermé par défaut » est plus sûr. Activités corrigées.

Objectifs de la leçon

  • Protéger toutes les routes avec un guard JWT global.
  • Déclarer des routes publiques avec @Public().
  • Récupérer l'utilisateur connecté avec @Utilisateur().
  • Combiner guard global et stratégie local pour la connexion.

Guard JWT global et routes publiques

Fermé par défaut : seules les routes @Public() sont accessibles sans jeton.

Les décorateurs

📄 src/auth/auth.decorators.ts

import { createParamDecorator, ExecutionContext, SetMetadata } from '@nestjs/common';

export const EST_PUBLIC = 'estPublic';
export const Public = () => SetMetadata(EST_PUBLIC, true);

export interface UtilisateurConnecte {
  id: number;
  email: string;
  nom: string;
  role: 'admin' | 'formateur' | 'stagiaire';
}

// @Utilisateur() → req.user complet ; @Utilisateur('id') → un seul champ
export const Utilisateur = createParamDecorator((champ: keyof UtilisateurConnecte | undefined, ctx: ExecutionContext) => {
  const user = ctx.switchToHttp().getRequest().user as UtilisateurConnecte;
  return champ ? user?.[champ] : user;
});
Le guard global

📄 src/auth/jwt-auth.guard.ts

import { ExecutionContext, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { EST_PUBLIC } from './auth.decorators';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  constructor(private readonly reflector: Reflector) {
    super();
  }

  canActivate(context: ExecutionContext) {
    const estPublic = this.reflector.getAllAndOverride<boolean>(EST_PUBLIC, [context.getHandler(), context.getClass()]);
    if (estPublic) return true;                          // route publique : pas de vérification
    return super.canActivate(context);                   // sinon : stratégie jwt de Passport
  }
}

📄 src/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from './auth/auth.module';
import { UtilisateursModule } from './utilisateurs/utilisateurs.module';
import { APP_GUARD } from '@nestjs/core';
import { JwtAuthGuard } from './auth/jwt-auth.guard';
import { FormationsController } from './formations/formations.controller';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'mysql',
        host: config.get('DB_HOTE'),
        port: Number(config.get('DB_PORT', 3306)),
        username: config.get('DB_UTILISATEUR'),
        password: config.get('DB_MOT_DE_PASSE'),
        database: config.get('DB_NOM'),
        autoLoadEntities: true,
        synchronize: true,
      }),
    }),
    UtilisateursModule,
    AuthModule,
  ],
  controllers: [FormationsController],
  providers: [{ provide: APP_GUARD, useClass: JwtAuthGuard }],      // toutes les routes protégées par défaut
})
export class AppModule {}

Le guard hérite de AuthGuard('jwt') et n'ajoute qu'une chose : si la route porte @Public(), il laisse passer sans rien vérifier. Enregistré avec APP_GUARD, il est créé par le conteneur et reçoit Reflector (leçon 9.4).

Utilisation

📄 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 { Public, Utilisateur, UtilisateurConnecte } from './auth.decorators';
import { InscriptionDto } from './auth.dto';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Public()
  @Post('inscription')
  inscrire(@Body() dto: InscriptionDto) {
    return this.authService.inscrire(dto);
  }

  @Public()                                          // le guard global ne s'applique pas…
  @UseGuards(AuthGuard('local'))                     // … mais la stratégie locale, oui
  @Post('connexion')
  @HttpCode(200)
  connecter(@Req() req: Request & { user: UtilisateurConnecte }) {
    return this.authService.genererJeton(req.user);
  }

  @Get('profil')                                     // protégée par défaut
  profil(@Utilisateur() utilisateur: UtilisateurConnecte) {
    return utilisateur;
  }
}

📄 src/formations/formations.controller.ts

import { Controller, Get, Post } from '@nestjs/common';
import { Public, Utilisateur } from '../auth/auth.decorators';

@Controller('formations')
export class FormationsController {
  @Public()
  @Get()
  catalogue() {
    return ['Développement web', 'Réseaux', 'Multimédia'];
  }

  @Post('inscriptions')
  sInscrire(@Utilisateur('nom') nom: string) {
    return { message: `${nom} est inscrit(e)` };
  }
}
  const port = app.getHttpServer().address().port;
  await appel('POST', '/api/auth/inscription', { corps: { email: 'sami@exemple.tn', nom: 'Sami Ben Ali', motDePasse: 'Formation2026' } });
  const r = await fetch(`http://localhost:${port}/api/auth/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)');
  const auth = { authorization: `Bearer ${access_token}` };
  await appel('GET', '/api/formations');
  await appel('POST', '/api/formations/inscriptions');
  await appel('POST', '/api/formations/inscriptions', { entetes: auth });
  await appel('GET', '/api/auth/profil', { entetes: auth });
  await appel('GET', '/api/route-inexistante');

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 (jeton reçu)
GET /api/formations → 200 ["Développement web","Réseaux","Multimédia"]
POST /api/formations/inscriptions → 401 {"message":"Unauthorized","statusCode":401}
POST /api/formations/inscriptions → 201 {"message":"Sami Ben Ali est inscrit(e)"}
GET /api/auth/profil → 200 {"id":1,"email":"sami@exemple.tn","nom":"Sami Ben Ali","role":"stagiaire"}
GET /api/route-inexistante → 404 {"message":"Cannot GET /api/route-inexistante","error":"Not Found","statusCode":404}
Lecture
  • Le catalogue (@Public()) est accessible sans jeton.
  • L'inscription à une formation, sans décorateur, est protégée automatiquement: 401 sans jeton, 201 avec, et @Utilisateur('nom') donne le nom de l'utilisateur.
  • La connexion est @Public() (pas de jeton à ce stade), mais protégée par AuthGuard('local'): le guard global laisse passer, puis le guard de méthode vérifie l'e-mail et le mot de passe.
  • Une route inexistante donne 404, pas 401 : le routeur répond avant les guards.

Pourquoi fermé par défaut ? Avec @UseGuards(JwtAuthGuard) sur chaque contrôleur, une nouvelle route oubliée est ouverte à tous, et personne ne s'en aperçoit. Avec le guard global, un oubli de @Public() donne un 401 immédiatement visible pendant les tests. L'erreur se fait dans le sens sûr.

Activités

Activité 1 Un contrôleur entièrement public

Placez @Public() sur la classe SanteController plutôt que sur chaque méthode. Vérifiez avec getAllAndOverride que cela fonctionne. Comment rendre privée une seule méthode d'un contrôleur public ?

Voir le corrigé

getAllAndOverride(EST_PUBLIC, [handler, classe]) lit d'abord la méthode, puis la classe : @Public() sur la classe suffit. Pour rendre une méthode privée, on place @SetMetadata(EST_PUBLIC, false) (ou un décorateur @Prive()) sur cette méthode : la valeur de la méthode l'emporte.

Activité 2 Un profil enrichi

Écrivez GET /api/moi/formations qui renvoie les formations auxquelles l'utilisateur connecté est inscrit, en utilisant @Utilisateur('id'). Pourquoi ne faut-il surtout pas lire l'identifiant dans l'URL (/utilisateurs/:id/formations) pour cette route ?

Voir le corrigé

Avec l'identifiant dans l'URL, un utilisateur pourrait le remplacer par celui d'un autre et lire ses données (faille IDOR, Insecure Direct Object Reference). L'identifiant venant du jeton vérifié ne peut pas être falsifié. Une route avec :id doit vérifier que l'utilisateur a le droit d'accéder à cette ressource (leçon 13.7).

Activité 3 Repérer l'erreur

Après avoir ajouté le guard global, la connexion renvoie systématiquement 401, même avec le bon mot de passe. Quelle est la cause ?

Voir le corrigé

@Public() a été oublié sur la route de connexion : le guard global exige un jeton… pour obtenir un jeton. Même chose pour l'inscription et le rafraîchissement (leçon 13.8).

Activité 4 Lister les routes publiques

Écrivez un petit test ou un script qui démarre l'application et liste toutes les routes publiques (indice : DiscoveryService et Reflector, ou testez chaque route sans jeton). Pourquoi est-ce utile dans une revue de sécurité ?

Voir le corrigé

La liste des routes accessibles sans authentification est la « surface d'attaque » de l'API : elle doit être courte et connue (santé, connexion, inscription, rafraîchissement, catalogue public). Un test automatisé qui échoue si une nouvelle route publique apparaît oblige à justifier chaque ouverture.

À retenir

  • JwtAuthGuard extends AuthGuard('jwt') + Reflector : laisse passer les routes @Public().
  • { provide: APP_GUARD, useClass: JwtAuthGuard } : toutes les routes protégées par défaut.
  • Connexion : @Public() + @UseGuards(AuthGuard('local')).
  • @Utilisateur() / @Utilisateur('id') : l'utilisateur vient du jeton, jamais de l'URL.
  • Fermé par défaut : un oubli donne un 401 visible, pas une faille silencieuse.

Cet article vous a-t-il aidé ?