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

Authentification JWT de bout en bout : intercepteur HTTP et guards Angular

Cette leçon relie l'authentification JWT de l'API (chapitre 13) à l'application Angular. Un AuthService à base de signaux gère la session, enregistrée dans le localStorage avec sa date d'expiration. U...

0 chapitres 0 QCM Accès gratuit
Authentification JWT de bout en bout : intercepteur HTTP et guards Angular

À propos de ce cours

Cette leçon relie l'authentification JWT de l'API (chapitre 13) à l'application Angular. Un AuthService à base de signaux gère la session, enregistrée dans le localStorage avec sa date d'expiration. Un intercepteur fonctionnel ajoute Authorization: Bearer aux seules requêtes vers l'API et renvoie vers la connexion en cas de 401. Des guards fonctionnels protègent les routes par connexion et par rôle. Un parcours réel dans Chrome vérifie chaque cas, y compris un jeton falsifié, et montre que la vraie sécurité reste dans l'API. Activités corrigées.

Objectifs de la leçon

  • Gérer la session de l'utilisateur dans un service Angular à signaux.
  • Ajouter automatiquement le jeton aux requêtes avec un intercepteur.
  • Protéger des routes Angular par connexion et par rôle.
  • Réagir proprement à un jeton expiré ou refusé.

Authentification JWT côté Angular

Le service garde la session, l'intercepteur l'utilise, les guards orientent l'utilisateur.

Côté API

L'API est celle du chapitre 13, simplifiée : POST /api/auth/connexion renvoie le jeton et l'utilisateur (Angular en a besoin pour afficher le nom et le rôle sans décoder le jeton), et un guard global exige le jeton sauf sur les routes @Public().

📄 apps/api/src/auth/auth.guard.ts

import { CanActivate, ExecutionContext, ForbiddenException, Injectable, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';
import type { Role, Utilisateur } from '@formation/partage';

// Guard global : jeton obligatoire sauf @Public(), puis rôles si @Roles(…)
@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly jwt: JwtService, private readonly reflector: Reflector) {}

  async canActivate(ctx: ExecutionContext) {
    const cibles = [ctx.getHandler(), ctx.getClass()];
    if (this.reflector.getAllAndOverride<boolean>('public', cibles)) return true;

    const req = ctx.switchToHttp().getRequest();
    const [type, jeton] = (req.headers.authorization ?? '').split(' ');
    if (type !== 'Bearer' || !jeton) throw new UnauthorizedException('Jeton manquant');
    try {
      req.user = await this.jwt.verifyAsync<Utilisateur>(jeton);
    } catch {
      throw new UnauthorizedException('Jeton invalide ou expiré');
    }
    const roles = this.reflector.getAllAndOverride<Role[]>('roles', cibles);
    if (roles?.length && !roles.includes(req.user.role)) throw new ForbiddenException('Rôle insuffisant');
    return true;
  }
}

📄 apps/api/src/auth/auth.service.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcrypt';
import type { ReponseConnexion, Utilisateur } from '@formation/partage';

// Comptes de démonstration (chapitre 13 : en base, avec inscription)
const COMPTES = [
  { id: 1, email: 'admin@exemple.tn', nom: 'Administratrice', role: 'admin' as const, hachage: bcrypt.hashSync('Admin2026!', 10) },
  { id: 2, email: 'sami@exemple.tn', nom: 'Sami Ben Ali', role: 'stagiaire' as const, hachage: bcrypt.hashSync('Stagiaire2026', 10) },
];

@Injectable()
export class AuthService {
  constructor(private readonly jwt: JwtService) {}

  async connecter(email: string, motDePasse: string): Promise<ReponseConnexion> {
    const compte = COMPTES.find((c) => c.email === email.toLowerCase());
    if (!compte || !(await bcrypt.compare(motDePasse, compte.hachage))) {
      throw new UnauthorizedException('E-mail ou mot de passe incorrect');
    }
    const { hachage: _, ...utilisateur } = compte;
    const access_token = await this.jwt.signAsync(utilisateur);
    return { access_token, expires_in: 3600, utilisateur };
  }

  profil(u: Utilisateur): Utilisateur {
    const { id, email, nom, role } = u;
    return { id, email, nom, role };
  }
}
Le service d'authentification

📄 apps/web/src/app/core/auth.service.ts

import { HttpClient } from '@angular/common/http';
import { computed, inject, Injectable, signal } from '@angular/core';
import { Router } from '@angular/router';
import type { Connexion, ReponseConnexion, Utilisateur } from '@formation/partage';
import { tap } from 'rxjs';
import { environment } from '../../environments/environment';

const CLE = 'session';

interface Session { jeton: string; utilisateur: Utilisateur; expire: number }

@Injectable({ providedIn: 'root' })
export class AuthService {
  private readonly http = inject(HttpClient);
  private readonly router = inject(Router);
  private readonly session = signal<Session | null>(this.lire());

  readonly utilisateur = computed(() => this.session()?.utilisateur ?? null);
  readonly estConnecte = computed(() => this.session() !== null);
  readonly estAdmin = computed(() => this.utilisateur()?.role === 'admin');

  jeton(): string | null {
    const s = this.session();
    if (s && Date.now() > s.expire) {          // jeton expiré : on oublie la session
      this.deconnecter();
      return null;
    }
    return s?.jeton ?? null;
  }

  connecter(identifiants: Connexion) {
    return this.http.post<ReponseConnexion>(`${environment.apiUrl}/auth/connexion`, identifiants).pipe(
      tap((r) => {
        const session = { jeton: r.access_token, utilisateur: r.utilisateur, expire: Date.now() + r.expires_in * 1000 };
        localStorage.setItem(CLE, JSON.stringify(session));
        this.session.set(session);
      }),
    );
  }

  deconnecter(retour?: string) {
    localStorage.removeItem(CLE);
    this.session.set(null);
    this.router.navigate(['/connexion'], { queryParams: retour ? { retour } : {} });
  }

  private lire(): Session | null {
    try {
      const s = JSON.parse(localStorage.getItem(CLE) ?? 'null') as Session | null;
      return s && Date.now() < s.expire ? s : null;
    } catch {
      return null;
    }
  }
}
  • La session (jeton, utilisateur, date d'expiration) est un signal; utilisateur, estConnecte et estAdmin sont des computed: l'en-tête et les boutons se mettent à jour seuls.
  • Elle est enregistrée dans le localStorage pour survivre à un rechargement de la page, et relue au démarrage si elle n'a pas expiré.
  • jeton() oublie la session dès qu'elle a expiré, sans même attendre le 401 de l'API.

Où garder le jeton ? Le localStorage est simple mais lisible par tout script de la page : une faille XSS permettrait de le voler (leçon 13.1). Angular échappe les valeurs affichées dans les templates, ce qui limite ce risque ; n'utilisez jamais innerHTML avec des données de l'utilisateur. Pour une application sensible, on garde un jeton d'accès court en mémoire et un refresh token dans un cookie HttpOnly (leçon 13.8, activité 3 ci-dessous).

L'intercepteur

📄 apps/web/src/app/core/auth.interceptor.ts

import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { Router } from '@angular/router';
import { catchError, throwError } from 'rxjs';
import { environment } from '../../environments/environment';
import { AuthService } from './auth.service';

// Ajoute le jeton aux requêtes vers NOTRE API (jamais vers un autre domaine) et réagit aux 401
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const auth = inject(AuthService);
  const router = inject(Router);
  const jeton = auth.jeton();
  const versApi = req.url.startsWith(environment.apiUrl);

  const requete = jeton && versApi ? req.clone({ setHeaders: { Authorization: `Bearer ${jeton}` } }) : req;

  return next(requete).pipe(
    catchError((err: HttpErrorResponse) => {
      if (err.status === 401 && versApi && !req.url.endsWith('/auth/connexion')) {
        auth.deconnecter(router.url);          // session expirée ou jeton refusé : retour à la connexion
      }
      return throwError(() => err);
    }),
  );
};
  • Un intercepteur fonctionnel (HttpInterceptorFn) voit passer toutes les requêtes de HttpClient. Les requêtes sont immuables : on en crée une copie avec req.clone({ setHeaders }).
  • Le jeton n'est ajouté qu'aux requêtes vers notre API : envoyer le jeton à une API externe (météo, cartes) le donnerait à un tiers.
  • Un 401 (sauf sur la route de connexion elle-même) signifie que la session n'est plus valable : déconnexion et retour à la page de connexion, en mémorisant la page actuelle.
Les guards et les routes

📄 apps/web/src/app/core/auth.guard.ts

import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
import type { Role } from '@formation/partage';
import { AuthService } from './auth.service';

// Connecté ? Sinon, redirection vers /connexion en mémorisant la page demandée
export const authGuard: CanActivateFn = (_route, etat) => {
  const auth = inject(AuthService);
  return auth.jeton() ? true : inject(Router).createUrlTree(['/connexion'], { queryParams: { retour: etat.url } });
};

// Fabrique de guard : roleGuard('admin')
export const roleGuard = (...roles: Role[]): CanActivateFn => () => {
  const role = inject(AuthService).utilisateur()?.role;
  return role && roles.includes(role) ? true : inject(Router).createUrlTree(['/acces-refuse']);
};

📄 apps/web/src/app/app.routes.ts

import { Routes } from '@angular/router';
import { authGuard, roleGuard } from './core/auth.guard';

export const routes: Routes = [
  { path: '', loadComponent: () => import('./formations/liste').then((m) => m.ListeFormations) },
  { path: 'formations/:id', loadComponent: () => import('./formations/detail').then((m) => m.DetailFormation) },
  {
    path: 'admin/nouvelle',
    canActivate: [authGuard, roleGuard('admin')],
    loadComponent: () => import('./formations/formulaire').then((m) => m.FormulaireFormation),
  },
  { path: 'connexion', loadComponent: () => import('./connexion').then((m) => m.Connexion) },
  { path: 'acces-refuse', loadComponent: () => import('./acces-refuse').then((m) => m.AccesRefuse) },
  { path: '**', redirectTo: '' },
];

📄 apps/web/src/app/connexion.ts

import { Component, inject, input, signal } from '@angular/core';
import { NonNullableFormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
import { Router } from '@angular/router';
import { AuthService } from './core/auth.service';
import { messagesErreur } from './core/erreurs';

@Component({
  selector: 'app-connexion',
  imports: [ReactiveFormsModule],
  template: `
    <h1>Connexion</h1>
    <form class="formulaire etroit" [formGroup]="form" (ngSubmit)="connecter()">
      <label>E-mail <input type="email" formControlName="email" autocomplete="username" /></label>
      <label>Mot de passe <input type="password" formControlName="motDePasse" autocomplete="current-password" /></label>
      @if (erreur()) { <p class="erreur">{{ erreur() }}</p> }
      <button [disabled]="form.invalid">Se connecter</button>
    </form>
  `,
})
export class Connexion {
  readonly retour = input<string>('/');            // ?retour=… (paramètre de requête → input)
  private readonly auth = inject(AuthService);
  private readonly router = inject(Router);
  protected readonly erreur = signal('');
  protected readonly form = inject(NonNullableFormBuilder).group({
    email: ['', [Validators.required, Validators.email]],
    motDePasse: ['', Validators.required],
  });

  connecter() {
    this.auth.connecter(this.form.getRawValue()).subscribe({
      next: () => this.router.navigateByUrl(this.retour() || '/'),
      error: (e) => this.erreur.set(messagesErreur(e)[0]),
    });
  }
}

📄 apps/web/src/app/app.ts

import { Component, inject } from '@angular/core';
import { RouterLink, RouterOutlet } from '@angular/router';
import { AuthService } from './core/auth.service';

@Component({
  selector: 'app-root',
  imports: [RouterOutlet, RouterLink],
  template: `
    <header>
      <a routerLink="/" class="logo">🎓 Centre de formation</a>
      <span class="espace"></span>
      @if (auth.utilisateur(); as u) {
        <span>{{ u.nom }} ({{ u.role }})</span>
        <button class="lien" (click)="auth.deconnecter()">Déconnexion</button>
      } @else {
        <a routerLink="/connexion">Connexion</a>
      }
    </header>
    <main><router-outlet /></main>
  `,
})
export class App {
  protected readonly auth = inject(AuthService);
}

Un guard renvoie true pour laisser passer, ou un UrlTree pour rediriger. roleGuard('admin') est une fabrique: une fonction qui crée un guard pour les rôles donnés. Les guards sont exécutés dans l'ordre du tableau canActivate.

Le parcours complet dans Chrome

Résultat réellement obtenu (parcours dans Chrome, requêtes vers l'API observées) :

3. Page réservée sans être connecté : /admin/nouvelle
   URL obtenue : /connexion?retour=%2Fadmin%2Fnouvelle
4. Mauvais mot de passe
  → POST /api/auth/connexion  [sans jeton]
  ← 401 /api/auth/connexion
  [console] Failed to load resource: the server responded with a status of 401 (Unauthorized)
   message : E-mail ou mot de passe incorrect
5. Connexion admin
  → POST /api/auth/connexion  [sans jeton]
  ← 200 /api/auth/connexion
   URL obtenue : /admin/nouvelle
   localStorage.session : utilisateur=Administratrice (admin), jeton de 225 caractères
6. Formulaire refusé par la validation de NestJS (description trop courte, 0 place)
  → POST /api/formations  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 400 /api/formations
  [console] Failed to load resource: the server responded with a status of 400 (Bad Request)
   messages : description must be longer than or equal to 10 characters | places must not be less than 1
7. Formulaire corrigé
  → POST /api/formations  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 201 /api/formations
  → GET /api/formations/5  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 200 /api/formations/5
   URL obtenue : /formations/5 — titre : Docker pour les développeurs
8. Jeton falsifié dans localStorage, puis suppression
  → GET /api/formations/5  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 200 /api/formations/5
  → DELETE /api/formations/5  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 401 /api/formations/5
  [console] Failed to load resource: the server responded with a status of 401 (Unauthorized)
   URL obtenue : /connexion?retour=%2Fformations%2F5 — session : None
9. Connexion d'un stagiaire, puis /admin/nouvelle
  → POST /api/auth/connexion  [sans jeton]
  ← 200 /api/auth/connexion
  → GET /api/formations/5  [Authorization: Bearer eyJhbGciOiJIU…]
  ← 200 /api/formations/5
   URL obtenue : /acces-refuse
Lecture
  • 3. Sans session, authGuard redirige vers /connexion?retour=%2Fadmin%2Fnouvelle, sans aucune requête vers l'API.
  • 4 et 5. La connexion échoue proprement (message de l'API), puis réussit ; l'utilisateur revient sur la page demandée grâce à retour.
  • 6 et 7. L'intercepteur a ajouté Authorization: Bearer … à toutes les requêtes vers l'API, publiques comprises (l'API les accepte).
  • 8. Jeton falsifié dans le localStorage (ce que pourrait faire n'importe quel utilisateur dans la console) : le GET public passe (il ne vérifie pas le jeton), mais la suppression reçoit 401. L'intercepteur efface la session et renvoie vers la connexion avec retour=/formations/5.
  • 9. Connecté comme stagiaire, roleGuard redirige vers /acces-refuse.

Les guards Angular ne protègent rien: ils orientent l'utilisateur. N'importe qui peut modifier le code exécuté dans son navigateur, changer son rôle dans le localStorage ou appeler l'API directement. C'est le guard de NestJS qui a refusé le jeton falsifié de l'étape 8, et c'est lui qui refuserait (403) une création de formation demandée directement par un stagiaire. Le TP 12 le vérifie avec un appel direct à l'API.

Activités

Activité 1 Le profil au démarrage

Au démarrage, l'application fait confiance à l'utilisateur enregistré dans le localStorage. Ajoutez une vérification : si une session existe, appelez GET /api/auth/profil; en cas de 401, déconnectez. Où placer cet appel ?

Voir le corrigé
// app.config.ts : exécuté avant le premier affichage
provideAppInitializer(() => {
  const auth = inject(AuthService);
  return auth.jeton() ? auth.verifierProfil() : undefined;   // verifierProfil() renvoie un Observable ou une Promise
}),

// AuthService
verifierProfil() {
  return this.http.get<Utilisateur>(`${environment.apiUrl}/auth/profil`).pipe(
    tap((u) => this.session.update((s) => (s ? { ...s, utilisateur: u } : s))),
    catchError(() => of(null)),        // l'intercepteur a déjà déconnecté en cas de 401
  );
}

Le rôle affiché vient alors de l'API, à jour, et un compte désactivé (chapitre 13) est déconnecté dès l'ouverture de l'application.

Activité 2 Masquer selon le rôle

Dans la page de détail, le bouton « Supprimer » n'apparaît que pour un administrateur. Vérifiez-le, puis ouvrez la console du navigateur en étant stagiaire et appelez l'API directement : fetch('http://localhost:3000/api/formations/1', { method: 'DELETE', headers: { Authorization: 'Bearer ' + JSON.parse(localStorage.session).jeton } }).then(r => r.status). Quel statut obtenez-vous ?

Voir le corrigé

403: le guard NestJS vérifie le rôle contenu dans le jeton signé, qu'aucun utilisateur ne peut modifier sans le secret. Masquer le bouton n'était que du confort ; la sécurité est bien dans l'API.

Activité 3 Rafraîchir le jeton

Avec l'API du chapitre 13 (access token de 15 minutes et refresh token), modifiez l'intercepteur : sur un 401, appeler POST /api/auth/rafraichir, enregistrer la nouvelle paire et rejouer la requête initiale. Si le rafraîchissement échoue, déconnecter.

Voir le corrigé
return next(ajouterJeton(req, auth.jeton())).pipe(
  catchError((err: HttpErrorResponse) => {
    if (err.status !== 401 || req.url.includes('/auth/')) return throwError(() => err);
    return auth.rafraichir().pipe(                                   // POST /auth/rafraichir
      switchMap((nouveau) => next(ajouterJeton(req, nouveau))),      // on rejoue la requête
      catchError((e) => { auth.deconnecter(router.url); return throwError(() => e); }),
    );
  }),
);

Si plusieurs requêtes échouent en même temps, il faut éviter de rafraîchir plusieurs fois (la rotation du chapitre 13 révoquerait la session) : on partage un seul rafraîchissement en cours (shareReplay(1)).

Activité 4 Pourquoi pas dans l'URL ?

Un collègue propose de passer le jeton dans l'URL (/api/formations?jeton=…) « pour éviter l'intercepteur ». Donnez deux raisons de refuser.

Voir le corrigé

(1) Les URL sont enregistrées partout : historique du navigateur, journaux de nginx et de NestJS, en-tête Referer envoyé aux sites externes. Le jeton fuirait. (2) Les URL sont souvent copiées et partagées (capture d'écran, lien envoyé par message) : celui qui reçoit le lien reçoit la session. L'en-tête Authorization est fait pour cela.

À retenir

  • AuthService : session dans un signal (+ localStorage), computed pour utilisateur, connecté, rôle ; expiration vérifiée.
  • HttpInterceptorFn : req.clone({ setHeaders: { Authorization } }) vers notre API seulement ; 401 → déconnexion + retour.
  • CanActivateFn : true ou UrlTree ; authGuard (connexion) et roleGuard('admin') (fabrique).
  • Après connexion, revenir à la page demandée (?retour=…).
  • Les guards Angular orientent ; seuls les guards NestJS protègent.

Cet article vous a-t-il aidé ?