Analyseur défensif de sécurité JWT
Effectuez un audit statique défensif de l’en-tête et du payload de vos jetons JWT localement dans votre navigateur, sans clé secrète requise. Détectez alg: none, les paramètres jku/x5u/jwk, les motifs de traversée dans kid, l’absence de exp/iss/aud ou la présence de champs sensibles.
Fonctionnement technique
Les failles JWT critiques résultent souvent d’erreurs de configuration plutôt que d’un défaut mathématique de hachage. Cet analyseur défensif décode uniquement l’en-tête et le payload Base64URL dans votre navigateur — sans clé secrète requise — afin d’évaluer la conformité aux bonnes pratiques RFC 7515/7519, sans aucune fonction offensive de cassage ni de falsification.
L’inspection statique détecte les en-têtes dangereux (alg: "none", alg absent, signature vide, URLs distantes jku/x5u, clés embarquées jwk/x5c, motifs de traversée ou d’injection dans kid), vérifie la présence des claims exp, nbf, iss, aud, sub et jti ainsi que les durées de vie excessives, repère les secrets ou données sensibles exposés en clair Base64URL et contrôle le dépassement des plafonds 4 Ko et 8 Ko.
Guide pas à pas avec exemple réel
Auditez n’importe quel jeton de développement ou de préproduction en quatre étapes locales pour corriger les défauts structurels.
1. Coller un JWT ou charger un modèle intégré
Insérez un jeton compact dans la zone dédiée ou comparez les exemples risqué et conforme fournis pour visualiser le score instantané.
2. Prioriser les alertes critiques et élevées
Traitez en premier lieu alg: "none", l’absence de signature ou les références dynamiques jku, x5u et jwk dans l’en-tête.
3. Contrôler kid, claims temporels et confidentialité
Assurez-vous que exp, iss et aud sont définis et qu’aucun mot de passe, clé d’API ou secret ne figure dans un payload Base64URL non chiffré.
4. Appliquer les correctifs guidés
Suivez les liens vers le vérificateur de signature ou le générateur RSA/EC pour valider vos jetons corrigés.
Exemple : Détection combinée d’en-tête et de payload risqués
Header: {"alg":"none","kid":"../../etc/passwd","jku":"https://untrusted.example/jwks.json"} | Payload: {"sub":"user-42","password":"demo-only-plaintext-secret"}Risque Critique · alg: "none" (Critique), traversée kid (Critique), jku (Élevé), exp/iss/aud absents, champ sensible password (Élevé).Rappel essentiel : le Base64URL d’un JWS n’est pas un chiffrement. Tout proxy ou utilisateur peut lire intégralement le payload.
Erreurs fréquentes et notes de sécurité
Injecter header.kid dans un chemin de fichier ou une requête SQL
Un paramètre kid contenant ../ ou des guillemets peut mener à la lecture de fichiers arbitraires. Validez kid contre une liste blanche ou `^[a-zA-Z0-9_-]+$`.
Télécharger dynamiquement les URLs jku ou x5u non approuvées
Récupérer un JWKS sur une URL fournie par un client non vérifié expose au SSRF et à l’injection d’une clé contrôlée par un attaquant.
Stocker des identifiants sensibles dans un payload JWS
Les revendications JWS restent lisibles par quiconque possède le jeton. Utilisez JWE ou conservez les secrets côté serveur.
Émettre des jetons sans expiration ou dépassant 4–8 Ko
Sans exp, un jeton fuité reste actif indéfiniment ; au-delà de 4 Ko ou 8 Ko, cookies et proxys HTTP renvoient des erreurs 431.
Décodeur JWT vs Analyseur de sécurité vs Vérificateur
| Fonctionnalité | Décodeur JWT | Analyseur de sécurité | Vérificateur de signature |
|---|---|---|---|
| Lecture JSON en-tête et claims | Oui | Oui | Oui |
| Clé secrète ou publique requise | Non | Non | Oui |
| Audit jku/x5u/kid/PII/taille | Basique | Score complet par gravité | Signature et délais exp/nbf |
| Preuve d’authenticité cryptographique | Non | Non (audit statique) | Oui (WebCrypto) |
Extraits de code (Node.js, Python, Java)
Appliquez les mêmes contrôles défensifs dans vos middlewares avant d’accepter tout jeton :
export function assertSafeJwtPolicy(hdr: Record<string, unknown>, pay: Record<string, unknown>) {
if (!hdr.alg || String(hdr.alg).toLowerCase() === 'none') throw new Error('alg none');
if ('jku' in hdr || 'x5u' in hdr || 'jwk' in hdr) throw new Error('Dynamic key header');
if (typeof hdr.kid === 'string' && !/^[a-zA-Z0-9_-]+$/.test(hdr.kid)) throw new Error('Bad kid');
if (typeof pay.exp !== 'number' || typeof pay.aud !== 'string') throw new Error('Missing claims');
}import re
SAFE_KID = re.compile(r"^[A-Za-z0-9_-]+$")
def check_jwt_hygiene(hdr: dict, pay: dict) -> list[str]:
issues = []
if str(hdr.get("alg", "")).lower() in ("", "none"): issues.append("Unsafe alg")
if any(k in hdr for k in ("jku", "x5u", "jwk")): issues.append("Header injection")
if isinstance(hdr.get("kid"), str) and not SAFE_KID.match(hdr["kid"]): issues.append("Unsafe kid")
if not all(c in pay for c in ("exp", "iss", "aud")): issues.append("Missing claims")
return issuesPattern SAFE_KID = Pattern.compile("^[A-Za-z0-9_-]+$");
if (alg == null || "none".equalsIgnoreCase(alg)) throw new SecurityException("alg none");
if (hasJkuOrX5u) throw new SecurityException("Remote key header");
if (kid != null && !SAFE_KID.matcher(kid).matches()) throw new SecurityException("Bad kid");Questions fréquentes
Un score de 100/100 garantit-il que la signature est authentique ?
Non. L’analyseur évalue uniquement l’hygiène statique des en-têtes et claims sans vérifier la signature cryptographique. Utilisez toujours le vérificateur avec votre clé de confiance.
Pourquoi jku, x5u et jwk en en-tête sont-ils classés à risque élevé ?
Parce qu’ils proviennent de données non encore vérifiées ; un serveur qui leur fait confiance risque le SSRF ou l’usage d’une clé forgée par un tiers.
Cet outil permet-il de casser un secret faible par force brute ?
Jamais. L’outil est purement défensif : aucune attaque par dictionnaire ni génération de jeton falsifié n’est implémentée.
Pourquoi signaler des champs email ou password dans le payload ?
Parce qu’un JWS est simplement encodé en Base64URL et non chiffré : les secrets n’y ont jamais leur place et les données personnelles doivent rester minimales.
Pourquoi vérifier la taille totale en octets du JWT ?
Au-delà de 4 096 octets, un cookie peut être tronqué ; au-delà de 8 192 octets, de nombreux proxys inverses rejettent la requête en HTTP 431.
Mes jetons inspectés sont-ils envoyés vers vos serveurs ?
Non. Toute l’analyse statique s’exécute localement en mémoire dans votre navigateur.
Outils associés
À propos de l’auteur
Avada Labs développe des outils gratuits pour développeurs, dont ce site, fort de six ans d’expérience en développement web et outils en ligne. Les projets et le code source sont disponibles sur GitHub.