JWT (JSON Web Token)

Le JSON Web Token (JWT) est un standard ouvert (RFC 7519) qui définit une manière compacte et autonome de transmettre des informations de façon sécurisée entre différentes parties sous forme d'objet JSON. Ces informations peuvent être vérifiées et approuvées car elles sont signées numériquement, généralement avec HMAC ou RSA. Les JWT sont largement utilisés pour l'authentification et l'échange sécurisé d'informations dans les architectures modernes.

Fondements

• Structure en trois parties encodées en Base64URL : Header (algorithme et type), Payload (claims/données), Signature (vérification d'intégrité)
• Mécanisme stateless : le serveur n'a pas besoin de stocker les sessions, toutes les informations sont dans le token
• Signature cryptographique garantissant l'intégrité et l'authenticité du token sans le chiffrer complètement
• Format compact transmissible facilement via URL, en-tête HTTP ou dans le corps d'une requête POST

Avantages

• Scalabilité : absence de stockage côté serveur, idéal pour les architectures distribuées et microservices
• Portabilité : utilisable sur mobile, web, API, et entre domaines différents (CORS-friendly)
• Performance : validation rapide sans requête base de données, réduction de la latence
• Standardisation : format largement adopté avec bibliothèques disponibles dans tous les langages
• Flexibilité : transmission de données personnalisées (claims) directement dans le token

Exemple concret

import jwt from 'jsonwebtoken';

// Génération d'un JWT
const generateToken = (userId: string, role: string) => {
  const payload = {
    sub: userId,
    role: role,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + (60 * 60) // 1h
  };
  
  return jwt.sign(payload, process.env.JWT_SECRET!, {
    algorithm: 'HS256'
  });
};

// Vérification d'un JWT
const verifyToken = (token: string) => {
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
    return { valid: true, data: decoded };
  } catch (error) {
    return { valid: false, error: 'Token invalide ou expiré' };
  }
};

// Middleware Express
const authMiddleware = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: 'Token manquant' });
  }
  
  const result = verifyToken(token);
  if (!result.valid) {
    return res.status(403).json({ error: result.error });
  }
  
  req.user = result.data;
  next();
};

Structure d'un JWT décodé : eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 (header) . eyJzdWIiOiIxMjM0IiwibmFtZSI6IkpvaG4iLCJpYXQiOjE1MTYyMzkwMjJ9 (payload) . SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c (signature)

Mise en œuvre

1. Choisir l'algorithme de signature approprié (HS256 pour secret partagé, RS256 pour paire de clés publique/privée)
2. Générer une clé secrète forte (minimum 256 bits) et la stocker de manière sécurisée (variables d'environnement, gestionnaire de secrets)
3. Définir les claims nécessaires : standards (iss, sub, aud, exp, iat) et personnalisés selon le contexte métier
4. Implémenter la logique de génération de token lors de l'authentification réussie
5. Créer un middleware de validation qui vérifie la signature et l'expiration avant d'autoriser l'accès aux ressources
6. Mettre en place une stratégie de refresh token pour renouveler les accès sans redemander les credentials
7. Implémenter une blacklist ou rotation de secrets pour révoquer les tokens compromis si nécessaire

Outils associés

• jsonwebtoken (Node.js) : bibliothèque complète pour créer et vérifier des JWT
• jose (JavaScript/TypeScript) : implémentation moderne et sécurisée des standards JOSE
• Auth0, Firebase Auth, AWS Cognito : services d'authentification managés utilisant JWT
• jwt.io : outil en ligne pour décoder, vérifier et débugger les JWT
• Passport.js avec passport-jwt : intégration JWT dans les applications Express
• Keycloak : serveur d'authentification open-source avec support JWT/OAuth2

Les JWT représentent une solution moderne et efficace pour l'authentification dans les applications distribuées, réduisant la charge serveur tout en offrant une expérience utilisateur fluide. Leur adoption massive en fait un standard incontournable pour sécuriser les API REST et les architectures microservices, avec un ROI immédiat en termes de scalabilité et de simplification de l'infrastructure.