Validation des JWT Auth0 : RS256 vs HS256, JWKS et pièges communs

Valider un JWT incorrectement est l'une des failles de sécurité les plus répandues. Guide complet : RS256, JWKS endpoint, vérification des claims et bibliothèques recommandées.

Par Auth0.Expert · 2025-02-15 · 10 min de lecture

JWT Sécurité JWKS

Validation des JWT Auth0 : guide complet

TL;DR

Un JWT non validé correctement peut permettre à n'importe qui d'usurper l'identité d'un utilisateur. Les erreurs critiques : ne pas vérifier la signature, ne pas vérifier l'audience (aud), accepter l'algorithme none.

---

Les 5 erreurs fatales de validation JWT

Voici les principales erreurs à éviter lors de la mise en place de la validation des tokens JWT Auth0.

  1. alg: none accepté : un attaquant supprime la signature → token accepté
  2. Audience non vérifiée : un token émis pour l'app A est accepté par l'app B
  3. Issuer non vérifié : un token d'un autre IdP est accepté
  4. Expiration ignorée : des tokens expirés restent valides indéfiniment
  5. JWKS non mis en cache : appel JWKS à chaque requête → DDoS sur Auth0

---

RS256 vs HS256 : lequel choisir ?

Voici un récapitulatif pour comparer les algorithmes de signature JWT les plus courants et comprendre lequel est recommandé selon l'usage.

| Aspect | RS256 | HS256 | |--------|-------|-------| | Type | Asymétrique (RSA) | Symétrique (HMAC) | | Signature | Clé privée Auth0 | Secret partagé | | Vérification | Clé publique (JWKS) | Secret (tous les serveurs le partagent) | | Sécurité si secret fuite | N/A | Catastrophique | | Recommandé production | ✅ | ⚠️ API internes uniquement |

Conclusion : utilisez toujours RS256 pour vos APIs exposées.

---

Implémentation correcte : Node.js

Ce script montre comment valider un JWT Auth0 en Node.js avec la bibliothèque jose, en se basant sur le JWKS distant et en mettant les clés en cache pour éviter de surcharger Auth0.

const { createRemoteJWKSet, jwtVerify } = require('jose');

const JWKS = createRemoteJWKSet(
  new URL(`https://YOUR_DOMAIN.auth0.com/.well-known/jwks.json`),
  { cacheMaxAge: 10 * 60 * 1000 } // cache 10 minutes
);

async function verifyToken(token) {
  const { payload } = await jwtVerify(token, JWKS, {
    issuer: `https://YOUR_DOMAIN.auth0.com/`,
    audience: 'https://api.example.com',
    algorithms: ['RS256'],
  });
  return payload;
}

Ce code valide la signature, l'audience et l'émetteur du JWT selon les bonnes pratiques recommandées.

---

Implémentation correcte : Python (FastAPI)

Ce code utilise FastAPI et python-jose pour valider un JWT Auth0 côté backend. Les JWKS sont également mis en cache pour la performance.

from fastapi import Depends, HTTPException, Security
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import httpx
from jose import jwt, JWTError
from functools import lru_cache

AUTH0_DOMAIN = "YOUR_DOMAIN.auth0.com"
API_AUDIENCE = "https://api.example.com"
ALGORITHMS = ["RS256"]

security = HTTPBearer()

@lru_cache(maxsize=1)
def get_jwks():
    """Cache les clés publiques Auth0 (10 min)."""
    response = httpx.get(f"https://{AUTH0_DOMAIN}/.well-known/jwks.json")
    return response.json()

async def get_current_user(
    credentials: HTTPAuthorizationCredentials = Security(security)
):
    token = credentials.credentials
    try:
        jwks = get_jwks()
        header = jwt.get_unverified_header(token)
        key = next(k for k in jwks["keys"] if k["kid"] == header["kid"])

        payload = jwt.decode(
            token,
            key,
            algorithms=ALGORITHMS,
            audience=API_AUDIENCE,
            issuer=f"https://{AUTH0_DOMAIN}/"
        )
        return payload
    except (JWTError, StopIteration) as e:
        raise HTTPException(status_code=401, detail=f"Token invalide: {str(e)}")

Cette fonction checke tous les paramètres critiques du JWT, vérifie la signature via le JWKS Auth0 et protège contre les tokens mal formés ou falsifiés.

---

JWKS : rotation des clés

Auth0 renouvelle automatiquement ses clés de signature. Il est donc primordial de gérer dynamiquement les updates du JWKS pour ne pas rejeter à tort des tokens valides après une rotation.

// Stratégie : retry si le kid est inconnu (nouvelle clé)
async function verifyWithRetry(token, attempt = 0) {
  try {
    return await jwtVerify(token, JWKS);
  } catch (err) {
    if (err.code === 'ERR_JWKS_NO_MATCHING_KEY' && attempt === 0) {
      // Forcer le rafraîchissement du cache JWKS
      await JWKS.reload?.();
      return verifyWithRetry(token, 1);
    }
    throw err;
  }
}

Ce code tente de revérifier le JWT après rafraîchissement du cache si une nouvelle clé apparaît côté Auth0, ce qui évite des échecs lors des rotations.

---

Bibliothèques recommandées par langage

Pour valider efficacement vos tokens JWT Auth0, voici les bibliothèques les plus robustes et maintenues à privilégier selon votre stack technique.

| Langage | Bibliothèque | Étoiles | Notes | |---------|-------------|---------|-------| | JavaScript | jose | 5.2k | Supporte toutes les spécifications | | Python | python-jose | 1.4k | Simple, bien maintenu | | Python | PyJWT | 5.1k | Plus populaire, bien documenté | | Java | java-jwt (Auth0) | 4.5k | Officiel Auth0 | | Go | golang-jwt/jwt | 6.5k | Référence Go | | .NET | Microsoft.IdentityModel | 1.7k | Recommandé pour .NET |

---

> 🔒 Audit de sécurité JWT : nos experts vérifient votre implémentation de validation JWT en 24h et vous fournissent un rapport de remédiation.

📧 [email protected]

Autres articles