Bootcode — Node.js / Express
Proteger des routes · Service d'auth · 401 vs 403
Utilisez les fleches, cliquez ou glissez pour naviguer
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 ?)
Rappel : signup/signin donnent un token
Aujourd'hui : proteger des routes avec ce token
L'auth est un SERVICE separe
Le controller ne verifie pas le token lui-meme
Le middleware d'authentification
Extraire le token, verifier, attacher l'identite
Routes publiques vs routes protegees
Appliquer le middleware ou non
Authentification (401) vs Autorisation (403)
Deux concepts distincts
Resume de la semaine : tout est connecte
Architecture complete signup -> signin -> middleware -> routes
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
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
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 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
Requete arrive
Header Authorization avec Bearer token
Middleware auth
Extrait le token, appelle AuthService.verify()
AuthService
jwt.verify() -- retourne le payload decode
req.identity = payload
Le middleware attache l'identite a la requete
Controller / Route
Utilise req.identity -- ne verifie PAS le token
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 !
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
// 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
// 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
// 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',
});
}
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)
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
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
);
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
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
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',
});
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
Middleware auth
Check token
Middleware autorisation
Check role / permissions
Controller / Route
Logique metier
D'abord l'authentification, ensuite l'autorisation -- deux middlewares distincts
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
// 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)
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
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);
}
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
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
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