Bootcode â Node.js / Express
Comprendre la structure d'un JWT · sign() · verify() · signup & signin
Utilisez les flĂšches, cliquez ou glissez pour naviguer
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
Le problĂšme de l'authentification
HTTP est stateless â comment savoir qui fait la requĂȘte ?
Anatomie d'un JWT
Header, payload, signature â dĂ©coder en live
Le payload n'est PAS chiffré
Démonstration en décodant un token Base64
jsonwebtoken : sign() & verify()
Créer et vérifier un token
bcrypt â hasher les mots de passe
JAMAIS en clair, lent exprĂšs
Live coding : signup & signin
Implémentation complÚte des endpoints
MODULE 1
HTTP est stateless â comment savoir qui fait la requĂȘte ?
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.
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
Header · Payload · Signature â DĂ©coder en live
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 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 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
// 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
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
Démonstration en décodant un token Base64
// 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
⹠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
sign() pour créer · verify() pour vérifier
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(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(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é)
// 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
Hasher les mots de passe â JAMAIS en clair
â 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Ă©
// 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
// 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
Implémenter signup et signin
projet/
.env
package.json
src/
server.ts
routes/
auth.routes.ts
controllers/
auth.controller.ts
middleware/
auth.middleware.ts
models/
User.ts
// 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 } })
}
// 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 } })
}
// 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 }
// 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
Les erreurs Ă ne pas commettre
â 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
â 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 !
â 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
đ 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.
đ
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 !