Générateur de Jetons JWT

Créez et signez des JSON Web Tokens RFC 7519 dans votre navigateur via Web Crypto HMAC (HS256, HS384, HS512) avec claims standards et personnalisés.

Aucun téléversementSans inscriptionRésultats instantanés
HS256 · HS384 · HS512 · noneRevendications rapides (iat / exp / jti)100% Local • Zéro Envoi
Créer et signer le JWT
Moteur hors ligne prêtEspace 100% privé dans le navigateur • Aucun transfert cloud
100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Générateur de Jetons JWT gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Signature HMAC Web Crypto dans le Navigateur

Calcule les signatures JWS HS256, HS384 et HS512 localement via SubtleCrypto afin que vos secrets de test et payloads de claims ne quittent jamais votre machine.

Claims Enregistrés RFC 7519 et Personnalisés

Configurez les champs standards iss, sub, aud, exp, nbf, iat et jti ainsi que des claims JSON imbriqués, des tableaux de rôles RBAC et des scopes OAuth2.

Sérialisation Base64URL Stricte sans Padding

Sérialise les en-têtes JSON UTF-8, les payloads et les tags MAC binaires avec l'alphabet URL-safe RFC 4648 sans les caractères de remplissage finaux selon la RFC 7515.

Fixtures d'Authentification et Cas Limites Déterministes

Générez à la demande des jetons actifs, antidatés, expirés ou à date d'effet future (nbf) pour tester vos middlewares d'API gateway, la tolérance de dérive d'horloge et les règles d'autorisation.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Signature HMAC Web Crypto dans le Navigateur Calcule les signatures JWS HS256, HS384 et HS512 localement via SubtleCrypto afin que vos secrets de test et payloads de claims ne quittent jamais votre machine. Options limitées sans personnalisation avancée
Claims Enregistrés RFC 7519 et Personnalisés Configurez les champs standards iss, sub, aud, exp, nbf, iat et jti ainsi que des claims JSON imbriqués, des tableaux de rôles RBAC et des scopes OAuth2. Nécessite des outils externes ou un traitement manuel
Confidentialité et Traitement 100 % local dans le navigateur (zéro envoi serveur) Envoie les données vers des serveurs cloud tiers
Tarif et Inscription 100 % gratuit à vie, sans compte ni filigrane Inscription obligatoire ou abonnement payant
Comment ça marche

Comment utiliser Générateur de Jetons JWT en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Sélectionner l'Algorithme HMAC et l'En-tête JOSE

Choisissez HS256, HS384 ou HS512 pour renseigner l'en-tête protégé JOSE (alg et typ: JWT), ainsi que tout paramètre d'en-tête optionnel tel que kid.

2

Configurer les Claims Enregistrés et Personnalisés

Définissez les horodatages Unix NumericDate (iat, nbf, exp) et les champs d'identité standards (iss, sub, aud, jti), ou collez et importez des claims JSON personnalisés.

3

Signer avec la Clé Secrète et Copier le Jeton

Saisissez votre secret HMAC partagé pour générer la signature cryptographique dans le navigateur et copiez le JWT compact pour vos en-têtes Authorization Bearer.

Comment Construire et Signer un JSON Web Token RFC 7519

Réponse rapide: Sérialisez l'en-tête JOSE et le payload de claims JSON sous forme de chaînes UTF-8 minifiées, encodez chaque segment en Base64URL sans padding, joignez-les par un point pour former l'entrée de signature ASCII, calculez l'empreinte HMAC-SHA2 à l'aide de votre clé secrète et ajoutez la signature encodée en Base64URL.

La génération d'un JWT conforme aux standards en sérialisation compacte JWS (RFC 7515 section 3.1) transforme un en-tête JOSE, un ensemble de claims JSON et une clé secrète symétrique en une chaîne à trois segments formatée sous la forme <header>.<payload>.<signature>.

1. Construire l'En-tête JOSE et le Payload de Claims API

Commencez par un en-tête protégé HS256 et un payload JSON combinant des claims enregistrés RFC 7519 (iss, sub, aud, iat, exp) avec des claims applicatifs personnalisés (role) :

{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "aud": "api.example.com",
  "iat": 1767225600,
  "exp": 1767229200,
  "role": "admin"
}

Ici, 1767225600 représente 2026-01-01T00:00:00Z et 1767229200 représente 2026-01-01T01:00:00Z (une durée de vie de jeton d'une heure).

2. Construire l'Entrée de Signature Base64URL sans Padding

Chaque objet JSON est minifié en octets UTF-8 sans espaces superflus, encodé en Base64URL (alphabet - et _, padding = supprimé) et joint par un point ASCII (.) :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Vecteur de Signature HMAC-SHA256 Reproductible

Web Crypto importe les octets de votre secret via crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) et signe les octets ASCII exacts <base64url-header>.<base64url-payload>. Vous pouvez vérifier la parité déterministe entre OpenSSL, le module crypto de Node.js, PyJWT en Python et ce générateur en utilisant le vecteur de test canonique HS256 avec le secret UTF-8 your-256-bit-secret :

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

La signature de l'en-tête {"alg":"HS256","typ":"JWT"} et du payload ci-dessus avec your-256-bit-secret produit toujours exactement ce jeton de 147 caractères, prêt pour un en-tête HTTP Authorization: Bearer <token> ou une vérification croisée dans le Décodeur et Inspecteur JWT :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Pipeline de Signature HMAC JWS, Sémantique des Claims et Règles d'Entropie des Clés

Réponse rapide: La RFC 7518 impose que la taille des clés de signature HMAC soit supérieure ou égale à la longueur de sortie du hachage : au moins 256 bits (32 octets) pour HS256, 384 bits (48 octets) pour HS384 et 512 bits (64 octets) pour HS512. Les phrases secrètes ASCII faibles exposent les JWT symétriques aux attaques par dictionnaire hors ligne.

L'implémentation ou le test de l'émission de JWT exige un respect strict des règles au niveau de l'octet des normes RFC 7515 (JWS), RFC 7518 (JWA) et RFC 7519 (JWT).

Entrée de Signature JWS Exacte et Encodage du Condensat Binaire

Selon la section 5.1 de la RFC 7515, la signature JWS est calculée sur les octets ASCII des segments encodés en Base64URL, et jamais sur les chaînes JSON brutes :

SigningInput = ASCII(BASE64URL(UTF8(Header))) || '.' || ASCII(BASE64URL(UTF8(Payload)))
Signature    = BASE64URL(HMAC_SHA2(SecretKeyBytes, SigningInput))

Deux subtilités de sérialisation affectent l'interopérabilité entre langages :

  1. Condensat binaire vs chaîne hexadécimale : HMAC_SHA2 génère des octets binaires bruts (32 octets pour HS256, 48 octets pour HS384, 64 octets pour HS512). Vous devez encoder directement ces octets bruts en Base64URL (ce qui donne respectivement 43, 64 ou 86 caractères), et non une chaîne hexadécimale minuscule intermédiaire.
  2. Déterminisme de la sérialisation JSON : Bien que les objets JSON RFC 8259 soient des tables clé-valeur non ordonnées, JWS signe la séquence exacte d'octets UTF-8 sérialisée lors de la création. Réordonner les clés ou formater le JSON avec des espaces modifie le payload Base64URL et produit une signature totalement différente.

Dimensionnement des Algorithmes HMAC et Résistance à la Force Brute (RFC 7518 Section 3.2)

  • HS256 (SHA-256, bloc interne de 512 bits) : condensat de 256 bits (32 octets), signature Base64URL de 43 caractères. Secret CSPRNG de 32 octets minimum.
  • HS384 (SHA-384, bloc interne de 1024 bits) : condensat de 384 bits (48 octets), signature Base64URL de 64 caractères. Secret CSPRNG de 48 octets minimum.
  • HS512 (SHA-512, bloc interne de 1024 bits) : condensat de 512 bits (64 octets), signature Base64URL de 86 caractères. Secret CSPRNG de 64 octets minimum.

Étant donné que chaque client détenant un JWT possède à la fois l'entrée de signature en clair (<header>.<payload>) et le tag MAC résultant, un attaquant peut tester des secrets candidats entièrement hors ligne à raison de millions de hachages par seconde sans déclencher de limitation de débit (rate limit) sur l'API. Générez toujours vos secrets à partir d'un générateur de nombres aléatoires cryptographiquement sûr plutôt qu'à partir de mots mémorisables.

Types de Claims Enregistrés (RFC 7519 Section 4.1)

  • iss (Issuer) et sub (Subject) : valeurs StringOrURI sensibles à la casse identifiant l'autorité qui a émis le jeton et le principal (identifiant utilisateur ou compte de service) qu'il représente.
  • aud (Audience) : valeur StringOrURI sensible à la casse ou tableau JSON de valeurs StringOrURI identifiant les destinataires prévus. Selon la RFC 8725, les serveurs de ressources doivent valider aud pour empêcher qu'un jeton valide émis pour le Service A ne soit rejoué contre le Service B.
  • exp (Expiration), nbf (Not Before) et iat (Issued At) : valeurs NumericDate exprimées en secondes epoch Unix (Math.floor(Date.now() / 1000)).
  • jti (JWT ID) : identifiant unique de jeton sensible à la casse (tel qu'un UUIDv4) utilisé pour les listes de révocation et la prévention des attaques par rejeu.

Générateur de JWT vs Décodeur JWT vs Générateur HMAC : Choisir le Bon Outil

Réponse rapide: Utilisez le Générateur de Jetons JWT pour construire et signer de nouveaux jetons Bearer RFC 7519 à trois segments à partir de claims JSON. Utilisez le Décodeur et Inspecteur JWT pour analyser et vérifier des JWT existants, ou le Générateur HMAC lorsque vous avez besoin de signatures de hachage à clé brutes en hexadécimal ou Base64 pour des payloads de webhooks comme Stripe ou GitHub.

Bien que ces trois utilitaires s'appuient sur le hachage Web Crypto natif du navigateur, chacun cible un format de protocole et une étape d'ingénierie API bien distincts.

Fonctionnalité Générateur de Jetons JWT (Cet Outil) Décodeur et Inspecteur JWT Générateur et Vérificateur HMAC
Objectif Principal Rédiger des claims JSON et émettre un JWT signé Décoder, inspecter les horodatages et vérifier un JWT existant Calculer un MAC autonome sur une entrée arbitraire
Entrée Requise En-tête alg + claims JSON + clé secrète JWT compact à trois segments + clé secrète optionnelle Texte brut ou message JSON + clé secrète
Format de Sortie JWT Base64URL à trois segments (<header>.<payload>.<signature>) En-tête/payload JSON décodés, statut d'expiration, contrôle de validité Chaîne de condensat autonome en hexadécimal ou Base64
Spécification de Référence RFC 7519 (JWT) et RFC 7515 (JWS) RFC 7519 (JWT) et RFC 7515 (JWS) RFC 2104 (HMAC) et FIPS 198-1
Cas d'Usage Idéal Création de jetons Bearer pour les tests locaux d'API et de middlewares Diagnostic des erreurs 401, des jetons ID OIDC et des TTL Vérification d'en-têtes webhook X-Hub-Signature-256 ou de MAC de requêtes API

Après avoir généré un jeton de test ici, vous pouvez le coller dans le Décodeur et Inspecteur JWT pour simuler la vérification en aval et inspecter le comportement de ses comptes à rebours exp et nbf.

FAQ

FAQ et guide technique sur Générateur de Jetons JWT

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de générateur jwt en ligne.

Quelle est la longueur minimale de clé secrète requise pour HS256, HS384 et HS512 ?

La section 3.2 de la RFC 7518 impose qu'une clé HMAC ait une taille supérieure ou égale à la longueur de sortie du hachage : au moins 32 octets (256 bits) pour HS256, 48 octets (384 bits) pour HS384 et 64 octets (512 bits) pour HS512. Les bibliothèques backend strictes telles que Nimbus JOSE+JWT, jjwt et PyJWT lèvent des exceptions ou des avertissements de clé faible si vous fournissez des chaînes ASCII plus courtes.

Pourquoi mon code HS256 personnalisé produit-il une signature de 86 caractères au lieu de 43 caractères ?

Une signature HS256 de 86 caractères se produit lorsque le code convertit d'abord le condensat HMAC-SHA256 de 32 octets en une chaîne hexadécimale de 64 caractères, puis encode ces 64 caractères ASCII en Base64URL. La RFC 7515 exige d'encoder directement les 32 octets binaires bruts en Base64URL, ce qui produit toujours exactement 43 caractères Base64URL sans padding.

Quand dois-je choisir un HMAC symétrique (HS256) plutôt qu'un algorithme asymétrique RSA ou ECDSA (RS256 ou ES256) ?

Utilisez les algorithmes symétriques HS256, HS384 ou HS512 lorsque le même service backend de confiance (ou banc d'essai local) signe et vérifie le jeton, car les deux opérations partagent une clé secrète unique et s'exécutent avec une surcharge CPU minimale. Lorsque plusieurs microservices en aval ou des clients tiers doivent vérifier des jetons sans pouvoir en émettre de nouveaux, utilisez des algorithmes asymétriques ES256, RS256 ou EdDSA où seul le fournisseur d'identité détient la clé privée de signature.

Comment dois-je formater les horodatages exp, nbf et iat lors de la génération d'un JWT ?

Formatez exp, nbf et iat sous forme d'entiers numériques représentant des secondes epoch Unix (par exemple, 1767225600), jamais sous forme de chaînes de date ISO 8601 entre guillemets ni sous forme de millisecondes JavaScript à 13 chiffres. Pour un jeton d'accès de 15 minutes, définissez iat sur le temps epoch actuel en secondes et exp sur iat + 900.

Puis-je générer des JWT expirés ou postdatés pour tester la gestion des erreurs de mon API ?

Oui. Contrairement aux serveurs OAuth2 de production qui n'émettent que des jetons actuellement valides, ce générateur côté client vous permet de définir délibérément exp dans le passé ou nbf dans le futur. Cela facilite l'écriture de tests d'intégration déterministes confirmant que votre middleware d'authentification rejette les jetons expirés ou prématurés avec une erreur 401 Unauthorized tout en respectant la tolérance de dérive d'horloge configurée.