À propos de ce cours
Objectifs de la leçon
- Distinguer authentification et autorisation.
- Comparer sessions et jetons pour une API.
- Expliquer la structure et le fonctionnement d'un JWT.
- Connaître les limites et les bonnes pratiques des JWT.
Authentification et autorisation
| Authentification | Autorisation | |
|---|---|---|
| Question | Qui êtes-vous ? | Avez-vous le droit de faire cela ? |
| Moyen | mot de passe, puis jeton ou session | rôles, permissions, propriété des données |
| Échec | 401 Unauthorized | 403 Forbidden |
| Dans ce chapitre | leçons 13.2 à 13.6 | leçon 13.7 |
Au chapitre 09, nous avions simulé l'utilisateur avec des en-têtes (x-role) ou des clés API écrites dans le code. Ce chapitre met en place une vraie authentification : comptes en base, mots de passe hachés, jetons signés.
Deux approches : sessions et jetons
HTTP est sans mémoire : chaque requête est indépendante. Une fois l'utilisateur connecté, il faut qu'il prouve son identité à chaque requête suivante. Deux façons de faire :
La session est mémorisée par le serveur ; le jeton est porté par le client et vérifié par sa signature.
| Critère | Session + cookie | Jeton JWT |
|---|---|---|
| État côté serveur | oui (table, mémoire, Redis) | non : tout est dans le jeton |
| Clients | navigateurs (cookies) | navigateurs, applications mobiles, autres serveurs |
| Plusieurs serveurs | stockage de sessions partagé nécessaire | il suffit de partager le secret |
| Déconnexion immédiate | oui (on supprime la session) | difficile : un jeton reste valide jusqu'à son expiration |
| Usage typique | site web rendu côté serveur | API REST, applications Angular ou mobiles |
Pour une API consommée par une application Angular (chapitre 18) ou mobile, les jetons sont l'approche la plus courante. Leur défaut, la révocation, sera traité par les refresh tokens (leçon 13.8).
Anatomie d'un JWT
Un JWT (JSON Web Token, norme RFC 7519) est une chaîne en trois parties séparées par des points. Créons-en un et décortiquons-le :
npm install @nestjs/jwt
📄 src/anatomie-jwt.ts
import { JwtService } from '@nestjs/jwt';
const jwt = new JwtService({ secret: 'secret-de-demonstration-a-ne-pas-utiliser', signOptions: { expiresIn: '15m' } });
async function main() {
// 1. Le serveur crée (signe) un jeton à la connexion
const jeton = await jwt.signAsync({ sub: 7, email: 'sami@exemple.tn', role: 'stagiaire' });
console.log('Jeton :', jeton);
// 2. Un JWT = 3 parties en Base64URL séparées par des points
const [entete, charge, signature] = jeton.split('.');
const lire = (p: string) => JSON.parse(Buffer.from(p, 'base64url').toString());
console.log('En-tête :', lire(entete));
console.log('Charge :', lire(charge));
console.log('Signature :', signature);
console.log('→ la charge est LISIBLE par tous : elle est encodée, pas chiffrée');
// 3. Le serveur vérifie le jeton reçu
console.log('Vérification :', await jwt.verifyAsync(jeton));
// 4. Un attaquant modifie la charge (role: admin) sans connaître le secret
const falsifie = [entete, Buffer.from(JSON.stringify({ ...lire(charge), role: 'admin' })).toString('base64url'), signature].join('.');
await jwt.verifyAsync(falsifie).catch((e: Error) => console.log('Jeton falsifié →', e.name, ':', e.message));
// 5. Jeton signé avec un autre secret
const autre = await new JwtService({ secret: 'autre-secret' }).signAsync({ sub: 7, role: 'admin' });
await jwt.verifyAsync(autre).catch((e: Error) => console.log('Autre secret →', e.name, ':', e.message));
// 6. Jeton expiré
const court = await jwt.signAsync({ sub: 7 }, { expiresIn: '1s' });
await new Promise((r) => setTimeout(r, 1500));
await jwt.verifyAsync(court).catch((e: Error & { expiredAt?: Date }) => console.log('Jeton expiré →', e.name, ':', e.message));
}
main();
Résultat réellement obtenu :
Jeton : eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjcsImVtYWlsIjoic2FtaUBleGVtcGxlLnRuIiwicm9sZSI6InN0YWdpYWlyZSIsImlhdCI6MTc5NDczMTc0MiwiZXhwIjoxNzk0NzMyNjQyfQ.Gkj1iGsNGuoJAQ7YEXb_OgfC4g5zLpKGlmqk83aQl1M
En-tête : { alg: 'HS256', typ: 'JWT' }
Charge : {
sub: 7,
email: 'sami@exemple.tn',
role: 'stagiaire',
iat: 1794731742,
exp: 1794732642
}
Signature : Gkj1iGsNGuoJAQ7YEXb_OgfC4g5zLpKGlmqk83aQl1M
→ la charge est LISIBLE par tous : elle est encodée, pas chiffrée
Vérification : {
sub: 7,
email: 'sami@exemple.tn',
role: 'stagiaire',
iat: 1794731742,
exp: 1794732642
}
Jeton falsifié → JsonWebTokenError : invalid signature
Autre secret → JsonWebTokenError : invalid signature
Jeton expiré → TokenExpiredError : jwt expired
Ce qu'il faut retenir de l'exécution
- L'en-tête indique l'algorithme de signature (
HS256: HMAC avec SHA-256 et un secret partagé). - La charge (payload) contient les claims:
sub(sujet : l'identifiant de l'utilisateur), vos données (role), et deux dates ajoutées automatiquement :iat(émis le) etexp(expire le), en secondes depuis 1970. Ici,exp - iat = 900secondes : 15 minutes. - La charge est lisible par tout le monde: il suffit de décoder le Base64URL (essayez sur jwt.io). Un JWT est signé, pas chiffré. On n'y met jamais de mot de passe, de numéro de carte ni de donnée confidentielle.
- La signature est calculée à partir de l'en-tête, de la charge et du secret connu du seul serveur. Changer un seul caractère de la charge (passer de
stagiaireàadmin) rend la signature invalide : « invalid signature ». Sans le secret, impossible de fabriquer un jeton valide. - Un jeton expiré est refusé (« jwt expired ») : la vérification contrôle aussi
exp.
Le secret est la clé de tout le système: quiconque le connaît peut fabriquer un jeton « admin ». Il doit être long et aléatoire (32 octets ou plus), stocké dans .env (chapitre 10), différent pour chaque environnement, et jamais versionné.
Où le client garde-t-il le jeton ?
| Stockage | Avantage | Risque |
|---|---|---|
| Mémoire de l'application (variable) | inaccessible aux autres onglets et scripts | perdu au rechargement de la page |
localStorage | simple, persiste | lisible par tout script de la page : une faille XSS permet de le voler |
Cookie HttpOnly, Secure, SameSite | inaccessible au JavaScript | envoyé automatiquement : protection CSRF à prévoir |
Une combinaison fréquente : jeton d'accès court en mémoire, refresh token dans un cookie HttpOnly (leçon 13.8). Dans tous les cas : HTTPS obligatoire en production, sinon le jeton circule en clair.
Le plan du chapitre
- 13.2 : stocker les mots de passe de façon sûre (bcrypt) ;
- 13.3 : inscription et connexion ;
- 13.4 : émettre et vérifier des JWT ;
- 13.5 et 13.6 : Passport, guard global et routes publiques ;
- 13.7 : rôles et permissions ;
- 13.8 : jetons d'accès courts et refresh tokens.
Activités
Activité 1 Décoder un jeton
Copiez le jeton affiché dans la leçon et décodez sa charge, soit sur jwt.io, soit avec la commande node -e "console.log(JSON.parse(Buffer.from('…charge…', 'base64url')))". Convertissez iat et exp en dates lisibles.
Voir le corrigé
new Date(1794731742 * 1000).toISOString() // iat
new Date(1794732642 * 1000).toISOString() // exp : 15 minutes plus tard
Le simple fait de pouvoir lire la charge sans aucun secret montre pourquoi on n'y met jamais d'information sensible.
Activité 2 401 ou 403 ?
Donnez le statut : (a) jeton absent ; (b) jeton dont la signature est fausse ; (c) jeton valide d'un stagiaire qui veut supprimer un groupe ; (d) jeton expiré ; (e) jeton valide d'un formateur qui modifie la note d'un stagiaire d'un autre groupe.
Voir le corrigé
(a) 401. (b) 401. (c) 403. (d) 401 (le client doit se reconnecter ou rafraîchir son jeton). (e) 403 : identifié, mais pas autorisé sur cette ressource.
Activité 3 Que mettre dans la charge ?
Parmi ces informations, lesquelles peuvent figurer dans la charge d'un JWT ? Identifiant, e-mail, rôle, mot de passe haché, numéro de CIN, liste de 300 permissions, groupe du stagiaire, date de naissance.
Voir le corrigé
Oui : identifiant (sub), e-mail, rôle, éventuellement le groupe. Non : le mot de passe (même haché), le CIN, la date de naissance (données personnelles lisibles par tous). La liste de 300 permissions alourdirait chaque requête : on y met le rôle, et on déduit les permissions côté serveur. Plus la charge est petite, mieux c'est.
Activité 4 Le problème de la révocation
Un administrateur désactive un compte à 10 h 00. L'utilisateur a reçu un jeton valide jusqu'à 10 h 15. Que se passe-t-il entre 10 h 00 et 10 h 15 ? Proposez deux solutions.
Voir le corrigé
La signature reste valide : si le serveur se contente de vérifier le jeton, l'utilisateur garde l'accès 15 minutes. Solutions : (1) relire l'utilisateur en base à chaque requête pour vérifier qu'il est actif (c'est ce que fera la stratégie JWT de la leçon 13.5) ; (2) des jetons d'accès très courts associés à un refresh token révocable (leçon 13.8). On peut aussi tenir une liste noire de jetons révoqués.
À retenir
- Authentification : qui êtes-vous (401) ; autorisation : avez-vous le droit (403).
- Session : état côté serveur et cookie ; JWT : jeton signé porté par le client, vérifié sans base.
- JWT = en-tête.charge.signature en Base64URL ; la charge est lisible par tous : jamais de donnée sensible.
- La signature dépend d'un secret : jeton modifié, autre secret ou expiré → refusé.
- Secret long et aléatoire dans .env, HTTPS obligatoire, durée de vie courte.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !