Bootcode — Node.js / Express

Middleware d'authentification

Proteger des routes · Service d'auth · 401 vs 403

Utilisez les fleches, cliquez ou glissez pour naviguer

Objectifs de la lecon

1. Creer un middleware d'auth Express

Extraire et verifier le token du header Authorization

2. Comprendre le service d'auth separe

Pourquoi le controller ne verifie pas le token lui-meme

3. Proteger des routes

Routes publiques vs routes protegees

4. Attacher l'identite a la requete

req.identity -- l'utilisateur verifie dans chaque route

5. Differencier 401 et 403

Authentification (qui es-tu ?) vs Autorisation (as-tu le droit ?)

Plan du cours

1

Rappel : signup/signin donnent un token

Aujourd'hui : proteger des routes avec ce token

2

L'auth est un SERVICE separe

Le controller ne verifie pas le token lui-meme

3

Le middleware d'authentification

Extraire le token, verifier, attacher l'identite

4

Routes publiques vs routes protegees

Appliquer le middleware ou non

5

Authentification (401) vs Autorisation (403)

Deux concepts distincts

6

Resume de la semaine : tout est connecte

Architecture complete signup -> signin -> middleware -> routes

Rappel : le flow d'authentification

Ce qu'on a deja vu la semaine derniere

Signup

L'utilisateur cree son compte -> recoit un JWT

// POST /api/auth/signup

{ email, password }

← { token: "eyJ..." }

Signin

L'utilisateur se connecte -> recoit un JWT

// POST /api/auth/signin

{ email, password }

← { token: "eyJ..." }

Aujourd'hui : utiliser ce token pour proteger des routes

Le client envoie le token dans chaque requete, le serveur le verifie avant d'autoriser l'acces

Le token voyage dans chaque requete

Header Authorization: Bearer <token>

// Exemple de requete depuis le frontend

const res = await fetch('/api/posts', {

headers: {

'Authorization': `Bearer ${token}`,

},

});

Client

Stocke le token (localStorage)

Header

Authorization: Bearer ...

Serveur

Verifie le token -> repond

Pourquoi separer l'auth du controller ?

Le controller ne connait PAS JWT

Il recoit l'identite deja verifiee via req.identity

Separation des responsabilites

Le controller gere la logique metier, pas la securite

Testabilite

On peut tester le controller sans JWT

Reutilisabilite

Le meme service d'auth pour toutes les routes

Evolutivite

Changer de systeme d'auth sans toucher aux controllers

Le AuthService : une interface propre

Le controller parle a une abstraction, pas a jsonwebtoken directement

import { AuthService } from './auth.service';

// Le controller recoit le service par injection

export class UserController {

constructor(private authService: AuthService) {}

async getProfile(req: Request, res: Response) {

// Le middleware a deja verifie le token

// req.identity existe deja

const user = await this.userService.findById(req.identity.userId);

res.json(user);

}

}

Le controller ne fait jamais jwt.verify() -- c'est le job du middleware + du service

Architecture : qui fait quoi ?

1

Requete arrive

Header Authorization avec Bearer token

→
2

Middleware auth

Extrait le token, appelle AuthService.verify()

→
3

AuthService

jwt.verify() -- retourne le payload decode

→
4

req.identity = payload

Le middleware attache l'identite a la requete

→
5

Controller / Route

Utilise req.identity -- ne verifie PAS le token

L'abstraction paie : changer de systeme

Aujourd'hui JWT, demain session, OAuth, Firebase... le controller ne change pas

Avec JWT directement dans le controller

// Controller cree avec JWT

jwt.verify(token, SECRET);

// 6 mois plus tard...

// On veut passer a Firebase Auth

// Il faut tout reecrire !

Avec AuthService abstrait

// Controller utilise l'interface

authService.verify(token);

// 6 mois plus tard...

// On implemente FirebaseAuthService

// Le controller ne change PAS !

Le middleware d'authentification

Un gardien qui se place avant les routes protegees

3 etapes :

1.

Extraire le token

Du header Authorization

2.

Verifier le token

Via AuthService.verify()

3.

Attacher l'identite

Dans req.identity

1. Extraire le token du header

// auth.middleware.ts

import { Request, Response, NextFunction } from 'express';

export function authMiddleware(

req: Request,

res: Response,

next: NextFunction

) {

const header = req.headers['authorization'];

if (!header || !header.startsWith('Bearer ')) {

return res.status(401).json({

message: 'Token manquant',

});

}

const token = header.split(' ')[1];

Le format est toujours Bearer <token> -- jamais juste le token nu

2. Verifier via le AuthService

// auth.service.ts

import jwt from 'jsonwebtoken';

export class AuthService {

private secret = process.env.JWT_SECRET !;

verify(token: string): JwtPayload {

return jwt.verify(token, this.secret) as JwtPayload;

}

sign(payload: object): string {

return jwt.sign(payload, this.secret, {

expiresIn: '24h',

});

}

}

Le AuthService encapsule jsonwebtoken -- si demain on utilise une autre librairie, un seul fichier change

3. Attacher l'identite a req.identity

// Extension du type Request pour TypeScript

declare module 'express' {

interface Request {

identity?: {

userId: string;

email: string;

role: string;

};

}

}

// Dans le middleware :

try {

const payload = authService.verify(token);

req.identity = { userId: payload.sub, email: payload.email, role: payload.role };

next(); // Passe a la route suivante

} catch (error) {

return res.status(401).json({

message: 'Token invalide ou expire',

});

}

Le middleware complet

export function authMiddleware(

authService: AuthService

) {

return (req: Request, res: Response, next: NextFunction) => {

const header = req.headers['authorization'];

if (!header || !header.startsWith('Bearer ')) {

return res.status(401).json({ message: 'Token manquant' });

}

const token = header.split(' ')[1];

try {

const payload = authService.verify(token);

req.identity = {

userId: payload.sub !,

email: payload.email !,

};

next();

} catch (error) {

return res.status(401).json({ message: 'Token invalide ou expire' });

}

};

}

Le middleware est une factory : il prend le AuthService en parametre (injection de dependances)

Routes publiques vs routes protegees

Publiques (pas de token)

POST /api/auth/signup

POST /api/auth/signin

GET /api/products

N'importe qui peut acceder

Protegees (token requis)

GET /api/users/me

PATCH /api/users/me

POST /api/posts

DELETE /api/posts/:id

Token obligatoire dans le header

Oublier de proteger les routes POST/PATCH/DELETE = faille de securite

Appliquer le middleware aux routes

Sur un groupe de routes

const userRouter = Router();

// Toutes les routes du groupe sont protegees

userRouter.use(authMiddleware(authService));

userRouter.get('/me', userController.getProfile);

userRouter.patch('/me', userController.updateProfile);

Route par route

const router = Router();

// Route publique

router.get('/products', productController.list);

// Route protegee

router.post('/products',

authMiddleware(authService),

productController.create

);

Demo : avant vs apres le middleware

Sans token

$ curl /api/users/me

401 Unauthorized

{ "message": "Token manquant" }

Avec token

$ curl /api/users/me

-H "Authorization: Bearer eyJ..."

200 OK

{ "id": 1, "email": "...", "name": "..." }

Le middleware est transparent pour le controller -- il reoit req.identity ou ne passe pas

Authentification vs Autorisation

Deux concepts distincts, deux codes HTTP differents

401

Authentification

"Qui es-tu ?"

Pas de token, token invalide ou expire

403

Autorisation

"As-tu le droit ?"

Token valide mais permissions insuffisantes

401 Unauthorized : pas authentifie

Le serveur ne sait pas qui tu es

// Dans le middleware d'auth -- 3 cas possibles

if

(!header)

return res.status(401).json({

message: 'Authorization header manquant',

});

if

(!header.startsWith('Bearer '))

return res.status(401).json({

message: 'Format invalide -- utiliser Bearer <token>',

});

catch (jwt.verify)

return res.status(401).json({

message: 'Token invalide ou expire',

});

403 Forbidden : pas autorise

Le serveur sait qui tu es, mais tu n'as pas le droit

// Exemple : middleware d'autorisation admin

export function requireRole(...roles: string[]) {

return (req: Request, res: Response, next: NextFunction) => {

if (!roles.includes(req.identity?.role !)) {

return res.status(403).json({

message: 'Acces interdit -- role insuffisant',

});

}

next();

};

}

403 arrive apres le middleware d'auth -- req.identity existe deja

Le parcours d'une requete

→

Middleware auth

Check token

401 si pas de token
→

Middleware autorisation

Check role / permissions

403 si pas le droit
→

Controller / Route

Logique metier

200 OK

D'abord l'authentification, ensuite l'autorisation -- deux middlewares distincts

Architecture complete de la semaine

Du signup a la route protegee, tout s'enchaine

1. Signup

POST /api/auth/signup -> hash bcrypt + cree l'utilisateur -> retourne JWT

2. Signin

POST /api/auth/signin -> verifie bcrypt -> retourne JWT

3. Client stocke le token

localStorage -> l'envoie dans chaque requete : Authorization: Bearer ...

4. Middleware auth

Recoit le token -> le passe a AuthService.verify() -> attache req.identity

5. Route protegee

Le controller utilise req.identity pour personnaliser la reponse

En une image : tout est connecte

// bootcode-hub-api/src/

src/

services/

auth.service.ts // sign(), verify() -- encapsule jsonwebtoken

user.service.ts // CRUD utilisateurs

middleware/

auth.middleware.ts // extrait token, appelle AuthService

require-role.ts // verifie le role (autorisation)

controllers/

user.controller.ts // recoit req.identity, utilisations

routes/

auth.routes.ts // publiques (signup, signin)

user.routes.ts // protegees (middleware auth)

Pieges courants a eviter

Verifier le token directement dans le controller

Le controller ne doit JAMAIS appeler jwt.verify() -- c'est le job du middleware + AuthService

Utiliser req.identity deja verifie

Confondre 401 et 403

401 = pas de token / invalide. 403 = token valide mais pas le droit

401 dans le middleware d'auth, 403 dans le middleware d'autorisation

Oublier de proteger les routes de modification

POST, PATCH, DELETE doivent TOUS etre proteges si necessaire

Faire un check systematique de chaque route

Anti-pattern : verifier dans le controller

L'erreur

// Controller qui verifie JWT

async

getProfile

(req, res) {

try {

jwt.verify(

req.headers.auth,

SECRET

);

} catch {

401 ...

}

}

La solution

// Controller utilise req.identity

async

getProfile

(req, res) {

const user =

await userService.

findById(

req.identity.userId

);

res.json(user);

}

Points cles a retenir

Le controller ne connait PAS JWT

Il recoit l'identite deja verifiee via req.identity

Le AuthService est une interface

On peut changer de systeme d'auth sans modifier le controller

401

Pas authentifie (pas de token ou invalide)

403

Authentifie mais pas autorise

Le middleware auth est ajoute UNIQUEMENT sur les routes qui necessitent une connexion

Resume de la semaine

JWT

sign() et verify()

Le token prouve l'identite

bcrypt

hachage des mots de passe

Jamais en clair

Middleware

garde les routes

AuthService + req.identity

AuthService

abstraction du JWT

Le controller ne le connait pas

401 vs 403

auth vs autorisation

Deux codes distincts

req.identity

utilisateur verifie

Pret a etre utilise

Des questions ?

Middleware, AuthService, 401 vs 403 -- tout est connecte

Prochaine etape : frontend avec contexte d'authentification

Garder le token, l'envoyer dans chaque requete, proteger les routes React