Bootcode — Node.js / Express

Authentification JWT

Comprendre la structure d'un JWT · sign() · verify() · signup & signin

Utilisez les flĂšches, cliquez ou glissez pour naviguer

Objectifs de la leçon

1. ProblĂšme de l'authentification

HTTP est stateless — comment savoir qui fait la requĂȘte ?

2. Anatomie d'un JWT

Header, payload, signature — dĂ©coder en live

3. jsonwebtoken : sign & verify

Créer et vérifier un token cÎté serveur

4. bcrypt pour les mots de passe

Hasher — JAMAIS stocker en clair

5. Signup & Signin — live coding

Implémentation complÚte avec Express

Plan du cours

1

Le problĂšme de l'authentification

HTTP est stateless — comment savoir qui fait la requĂȘte ?

2

Anatomie d'un JWT

Header, payload, signature — dĂ©coder en live

3

Le payload n'est PAS chiffré

Démonstration en décodant un token Base64

4

jsonwebtoken : sign() & verify()

Créer et vérifier un token

5

bcrypt — hasher les mots de passe

JAMAIS en clair, lent exprĂšs

6

Live coding : signup & signin

Implémentation complÚte des endpoints

MODULE 1

Le problĂšme de l'authentification

HTTP est stateless — comment savoir qui fait la requĂȘte ?

HTTP est stateless

Chaque requĂȘte HTTP est indĂ©pendante — le serveur ne sait pas qui tu es d'une requĂȘte Ă  l'autre.

❌ Sans auth

RequĂȘte 1 : GET /profil

RequĂȘte 2 : GET /profil

Le serveur ne peut pas faire la différence entre deux utilisateurs !

✅ Avec JWT

RequĂȘte 1 : Authorization: Bearer <token>

RequĂȘte 2 : Authorization: Bearer <token>

Le token prouve l'identité à chaque appel !

💡 Le navigateur n'a pas de mĂ©moire intĂ©grĂ©e — c'est nous qui devons attacher l'identitĂ© Ă  chaque requĂȘte via un token.

Le token Ă  la rescousse

Client

Navigateur / App

──

POST /login

{ email, password }

→

Serveur

Vérifie le password

← Renvoie

{ token: "eyJ..." }

──

Client stocke

Le token en mémoire

──

GET /profil

Authorization: Bearer <token>

🎯 Le token devient la "carte d'identitĂ©" du client

MODULE 2

Anatomie d'un JWT

Header · Payload · Signature — DĂ©coder en live

Structure d'un JWT

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJuYW1lIjoiQWxpY2UiLCJpYXQiOjE3MDAwMDAwMDB9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HEADER

Algorithme & type de token

HMAC-SHA256, RSA, etc.

PAYLOAD

Données (claims)

userId, role, exp, iat...

SIGNATURE

Preuve d'intégrité

header + payload + secret

🎯 Les trois parties sont sĂ©parĂ©es par des points et encodĂ©es en Base64URL

Header — Le "emballage"

// header décodé (JSON)

{

"alg": "HS256",

"typ": "JWT"

}

alg

Algorithme de signature utilisé

HS256 (HMAC-SHA256), RS256 (RSA), etc.

typ

Type de token

Presque toujours "JWT"

⚠ Si l'algo est none, le token n'est pas signĂ© — une attaque connue!

Payload — Les donnĂ©es

// payload décodé (JSON)

{

"sub": "123",

"name": "Alice",

"role": "admin",

"iat": 1700000000,

"exp": 1700003600

}

Claims standards (optionnels)

sub — sujet (userId)

iat — Ă©mis Ă  (timestamp)

exp — expire à (timestamp)

Claims personnalisés

name, email

role

Tout ce dont tu as besoin

Signature — La preuve d'intĂ©gritĂ©

// La signature est calculée ainsi :

HMACSHA256(

base64UrlEncode(header) + "." +

base64UrlEncode(payload),

secret

)

1

Prend header + payload

2

Ajoute le secret (connu du serveur seulement)

3

Hache le tout → signature unique

🔐 Si quelqu'un modifie le payload, la signature ne correspond plus → token invalide

Démonstration : jwt.io

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJuYW1lIjoiQWxpY2UiLCJpYXQiOjE3MDAwMDAwMDB9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HEADER décodé

{ "alg": "HS256", "typ": "JWT" }

PAYLOAD décodé

{ "sub": "123", "name": "Alice" }

SIGNATURE vérifiée

✓ HMACSHA256(..., secret)

🔗 Rendez-vous sur jwt.io — colle le token, regarde le debugger dĂ©coder chaque partie en direct !

MODULE 3

Le payload n'est PAS chiffré

Démonstration en décodant un token Base64

Décoder un JWT sans bibliothÚque

// decode.ts — JWT = header.payload.signature

const token: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJuYW1lIjoiQWxpY2UiLCJpYXQiOjE3MDAwMDAwMDB9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"

const payloadBase64: string = token.split('.')[1]

const payload: string = Buffer.from(payloadBase64, 'base64url').toString('utf-8')

// payload = {"sub":"123","name":"Alice","iat":1700000000}

console.log(JSON.parse(payload))

// { sub: '123', name: 'Alice', iat: 1700000000 }

⚠ Le payload est en CLAIR

N'importe qui peut dĂ©coder un JWT — c'est du Base64, pas du chiffrement !

→ Ne JAMAIS mettre un mot de passe ou des donnĂ©es sensibles dans le payload

Signature ≠ Chiffrement

🔏 Signature

‱ Prouve l'intĂ©gritĂ©

‱ Prouve l'origine (secret connu du serveur)

‱ N'empĂȘche PAS la lecture

‱ Garantit que le token n'a pas Ă©tĂ© modifiĂ©

🔒 Chiffrement

‱ Rend les donnĂ©es illisibles

‱ NĂ©cessite une clĂ© pour dĂ©chiffrer

‱ DiffĂ©rent — JWT ne chiffre PAS

‱ Utilisez JWE si vous avez besoin de chiffrer

🎯 Le JWT est signĂ©, pas chiffrĂ© — tout le monde peut lire le payload

MODULE 4

jsonwebtoken

sign() pour créer · verify() pour vérifier

Installation

npm install jsonwebtoken

npm install -D @types/jsonwebtoken

// auth.ts — types importĂ©s

import jwt, { JwtPayload } from 'jsonwebtoken'

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

💡 Le secret JWT doit ĂȘtre stockĂ© dans .env, jamais en dur dans le code

jwt.sign() — CrĂ©er un token

// jwt.sign(payload, secret, options)

const token: string = jwt.sign(

{

sub: user.id,

name: user.name,

role: user.role

},

process.env.JWT_SECRET as string,

{ expiresIn: '2h' }

)

// → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

payload

Les données à inclure (userId, role, etc.)

secret

La clĂ© secrĂšte — connue du serveur uniquement

expiresIn

Durée de validité : '2h', '7d'

algorithms

Par défaut HS256 (HMAC-SHA256)

jwt.verify() — VĂ©rifier un token

// jwt.verify(token, secret) → JwtPayload

try {

const decoded = jwt.verify(

token,

process.env.JWT_SECRET as string

) as JwtPayload & { sub: number; name: string; role: string }

console.log(decoded)

// { sub: 1, name: 'Alice', role: 'admin', iat: ..., exp: ... }

} catch (err) {

console.error("Token invalide :", (err as Error).message)

}

✅ Token valide

Retourne le payload décodé

expiration automatique vérifiée

❌ Token invalide

LÚve une erreur (expiré, mauvaise signature, malformé)

Middleware d'authentification

// auth.middleware.ts

export function authMiddleware(

req: Request,

res: Response,

next: NextFunction

): void {

const header: string | undefined = req.headers.authorization

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

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

return

}

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

try {

const decoded = jwt.verify(token, process.env.JWT_SECRET as string)

;(req as any).user = decoded

next()

} catch (err) {

res.status(401).json({ message: 'Token invalide ou expiré' })

}

}

🎯 req.user est maintenant disponible dans toutes les routes protĂ©gĂ©es

MODULE 5

bcrypt

Hasher les mots de passe — JAMAIS en clair

Pourquoi hasher les mots de passe ?

❌ Stockage en clair

Base de données :

email: alice@example.com
password: "monSuperMot2Passe123"

💀 Fuite de donnĂ©es → mots de passe exposĂ©s

✅ HashĂ© avec bcrypt

Base de données :

email: alice@example.com
password: "$2b$10$3euPcQlJ...Y5u"

✅ MĂȘme en cas de fuite, le password reste protĂ©gĂ©

bcrypt est lent exprĂšs

// installation

npm install bcrypt

npm install -D @types/bcrypt

⚡ MD5 / SHA-256

‱ Trùs rapides (conçus pour la vitesse)

‱ 1 milliard de hash/s avec un GPU

→ Attaque par force brute triviale

🐱 bcrypt

‱ Volontairement lent (cost factor)

‱ ~10 hash/s — trop lent pour brute force

✅ Conçu POUR les mots de passe

Le cost factor (salt rounds) contrîle la lenteur — 10-12 est un bon compromis

bcrypt en pratique

// Hasher un mot de passe (signup)

const hashedPassword: string = await bcrypt.hash(password, 10)

// → "$2b$10$3euPcQlJ...Y5u" (salt + hash + cost factor)

// Vérifier un mot de passe (signin)

const isValid: boolean = await bcrypt.compare(

password, // "monSuperMot2Passe123"

user.hashedPassword // "$2b$10$3euPcQlJ...Y5u"

)

// → true ou false

hash(password, saltRounds)

GénÚre un hash sécurisé + salt automatique

compare(password, hash)

Compare un mot de passe avec le hash stocké

MODULE 6

Live coding

Implémenter signup et signin

Architecture des fichiers

projet/

.env

package.json

src/

server.ts

routes/

auth.routes.ts

controllers/

auth.controller.ts

middleware/

auth.middleware.ts

models/

User.ts

Signup — Inscription

// auth.controller.ts — signup

import type { Request, Response } from 'express'

export const signup = async (

req: Request<{}, {}, { email: string; password: string; name: string }>,

res: Response

): Promise<void> => {

const { email, password, name } = req.body

// 1. Vérifier si l'utilisateur existe déjà

const existingUser = await User.findOne({ email })

if (existingUser) {

res.status(409).json({ message: 'Email déjà utilisé' })

return

}

// 2. Hasher le mot de passe

const hashedPassword: string = await bcrypt.hash(password, 10)

// 3. Créer l'utilisateur

const user = await User.create({ email, password: hashedPassword, name })

// 4. Générer le token JWT

const token: string = jwt.sign(

{ sub: user.id, name: user.name, role: user.role },

process.env.JWT_SECRET as string,

{ expiresIn: '2h' }

)

res.status(201).json({ token, user: { id: user.id, name, email } })

}

Signin — Connexion

// auth.controller.ts — signin

export const signin = async (

req: Request<{}, {}, { email: string; password: string }>,

res: Response

): Promise<void> => {

const { email, password } = req.body

// 1. Chercher l'utilisateur par email

const user = await User.findOne({ email })

// 2. Message vague pour la sécurité

if (!user) {

res.status(401).json({ message: 'Invalid credentials' })

return

}

// 3. Vérifier le mot de passe avec bcrypt

const isValid: boolean = await bcrypt.compare(password, user.password)

if (!isValid) {

res.status(401).json({ message: 'Invalid credentials' })

return

}

// 4. Générer le token

const token: string = jwt.sign(

{ sub: user.id, name: user.name, role: user.role },

process.env.JWT_SECRET as string,

{ expiresIn: '2h' }

)

res.json({ token, user: { id: user.id, name: user.email, role: user.role } })

}

Les routes

// auth.routes.ts

import { Router } from 'express'

import { signup, signin } from '../controllers/auth.controller'

const router = Router()

router.post('/auth/signup', signup)

router.post('/auth/signin', signin)

export default router

// server.ts (montage des routes)

import authRoutes from './routes/auth.routes'

app.use('/api', authRoutes)

POST /api/auth/signup

Body : { email, password, name }

→ 201 : { token, user }

POST /api/auth/signin

Body : { email, password }

→ 200 : { token, user }

Route protĂ©gĂ©e — test du JWT

// Un endpoint protégé qui utilise le middleware

router.get('/auth/me', authMiddleware, (req: Request, res: Response) => {

res.json({ user: (req as any).user })

})

🎯 Avec Postman ou Insomnia :

1. POST /api/auth/signup → rĂ©cupĂ©rer le token

2. GET /api/auth/me → ajouter Authorization: Bearer <token>

3. Vérifier que req.user contient les infos du payload

⚠ PiĂšges courants

Les erreurs Ă  ne pas commettre

PiĂšge 1 : Stocker le mot de passe en clair

❌ L'erreur

User.create({

email,

password // ← en clair !

})

💀 Une fuite de la DB expose tous les mots de passe

✅ La solution

const hashed: string = await bcrypt.hash(password, 10)

User.create({

email,

password: hashed // ← hashĂ© !

})

✅ MĂȘme en cas de fuite, les passwords sont protĂ©gĂ©s

PiÚge 2 : Données sensibles dans le payload

❌ L'erreur

jwt.sign({

password: user.password, // ← EN CLAIR !

carteBancaire: "4532..."

}, secret)

💀 N'importe qui dĂ©code le token et voit les donnĂ©es !

✅ La solution

jwt.sign({

sub: user.id,

name: user.name,

role: user.role // ← minimum nĂ©cessaire

}, secret)

✅ Jamais de donnĂ©es sensibles dans le payload !

PiÚge 3 : Révéler si un email existe

❌ L'erreur

// Email trouvĂ© → message diffĂ©rent

if (!user) return res.json({

message: "Email non trouvé"

})

if (wrongPass) return res.json({

message: "Mot de passe incorrect"

})

💀 Un attaquant peut dĂ©couvrir quels emails sont inscrits

✅ La solution

// MÊME message dans les deux cas

res.status(401).json({

message: "Invalid credentials"

})

✅ L'attaquant ne sait pas si l'email existe ou non

Points clés à retenir

🔓 Payload lisible

Le payload JWT est en Base64 — tout le monde peut le lire. Jamais de mot de passe dedans.

🔏 Signature = confiance

La signature prouve que le token vient de ton serveur et n'a pas été modifié.

🐱 bcrypt est lent

C'est voulu — pour empĂȘcher les attaques par force brute. Toujours hasher les mots de passe.

đŸ€« Messages vagues

Toujours "Invalid credentials" — ne rĂ©vĂšle pas si l'email existe ou non.

🎯 À retenir !

🔐

JWT = identité

Le token prouve qui tu es Ă  chaque requĂȘte

🧂

bcrypt = sécurité

Jamais un mot de passe en clair, toujours hashé + salt

đŸ›Ąïž

Middleware = gardien

ProtĂšge les routes avec verify() avant chaque accĂšs

📌 Le payload JWT est PUBLIC — ne mets rien de sensible dedans !