Generatore di Token JWT

Crea e firma JSON Web Token RFC 7519 localmente nel browser usando Web Crypto HMAC (HS256, HS384, HS512) con claim JSON registrati e personalizzati.

Nessun caricamentoNessuna registrazioneRisultati istantanei
HS256 · HS384 · HS512 · noneClaim Rapidi (iat / exp / jti)100% Locale • Zero Upload
Crea e Firma JWT
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Generatore di Token JWT gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Firma HMAC Web Crypto nel Browser

Calcola firme JWS HS256, HS384 e HS512 localmente tramite SubtleCrypto, affinché i segreti di test e i payload dei claim non lascino mai la tua macchina.

Claim Registrati RFC 7519 e Personalizzati

Configura i campi standard iss, sub, aud, exp, nbf, iat e jti insieme a claim JSON nidificati, array di ruoli RBAC e scope OAuth2.

Serializzazione Base64URL Rigorosa senza Padding

Serializza header JSON UTF-8, payload e tag MAC binari usando l'alfabeto URL-safe RFC 4648 rimuovendo il padding finale secondo la specifica RFC 7515.

Fixture Deterministiche di Auth e Casi Limite

Genera all'istante token attivi, retrodatati, scaduti o con nbf futuro per testare middleware di API gateway, tolleranza di clock-skew e regole di autorizzazione.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Firma HMAC Web Crypto nel Browser Calcola firme JWS HS256, HS384 e HS512 localmente tramite SubtleCrypto, affinché i segreti di test e i payload dei claim non lascino mai la tua macchina. Opzioni limitate senza personalizzazione avanzata
Claim Registrati RFC 7519 e Personalizzati Configura i campi standard iss, sub, aud, exp, nbf, iat e jti insieme a claim JSON nidificati, array di ruoli RBAC e scope OAuth2. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Generatore di Token JWT in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Seleziona Algoritmo HMAC e Header JOSE

Scegli HS256, HS384 o HS512 per compilare l'header protetto JOSE (alg e typ: JWT), insieme a eventuali parametri opzionali come kid.

2

Configura Claim Registrati e Personalizzati

Imposta i timestamp Unix NumericDate (iat, nbf, exp) e i campi di identità standard (iss, sub, aud, jti), oppure incolla e carica claim JSON personalizzati.

3

Firma con Chiave Segreta e Copia il Token

Inserisci il segreto HMAC condiviso per generare la firma crittografica nel browser e copia il JWT compatto per gli header Authorization Bearer.

Come Creare e Firmare un JSON Web Token RFC 7519

Risposta Rapida: Serializza l'header JOSE e il payload dei claim JSON come stringhe UTF-8 minificate, codifica ciascun segmento usando Base64URL senza padding, uniscili con un punto per formare l'input di firma ASCII, calcola il digest HMAC-SHA2 con la tua chiave segreta e aggiungi la firma codificata in Base64URL.

La generazione di un JWT conforme agli standard nella JWS Compact Serialization (RFC 7515 Sezione 3.1) trasforma un header JOSE, un set di claim JSON e una chiave segreta simmetrica in una stringa composta da tre parti formattata come <header>.<payload>.<signature>.

1. Costruire l'Header JOSE e il Payload dei Claim API

Inizia con un header protetto HS256 e un payload JSON che combina i claim registrati RFC 7519 (iss, sub, aud, iat, exp) con i claim personalizzati dell'applicazione (role):

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

Qui 1767225600 rappresenta 2026-01-01T00:00:00Z e 1767229200 rappresenta 2026-01-01T01:00:00Z (una durata del token di 1 ora).

2. Costruire l'Input di Firma Base64URL senza Padding

Ogni oggetto JSON viene minificato in byte UTF-8 senza spazi superflui, codificato con Base64URL (alfabeto - e _, padding = rimosso) e unito con un punto ASCII (.):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Vettore di Firma HMAC-SHA256 Riproducibile

Web Crypto importa i byte del tuo segreto tramite crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) e firma gli esatti byte ASCII <base64url-header>.<base64url-payload>. Puoi verificare la parità deterministica tra OpenSSL, crypto di Node.js, PyJWT di Python e questo generatore utilizzando il vettore di test canonico HS256 con il segreto UTF-8 your-256-bit-secret:

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

La firma dell'header {"alg":"HS256","typ":"JWT"} e del payload soprastante con your-256-bit-secret produce sempre esattamente questo token di 147 caratteri, pronto per un header HTTP Authorization: Bearer <token> o per la verifica incrociata nel Decodificatore e Ispettore JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Pipeline di Firma HMAC JWS, Semantica dei Claim e Regole di Entropia della Chiave

Risposta Rapida: La specifica RFC 7518 impone che le chiavi di firma HMAC eguaglino o superino la lunghezza dell'output di hash: almeno 256 bit (32 byte) per HS256, 384 bit (48 byte) per HS384 e 512 bit (64 byte) per HS512. Passphrase ASCII deboli lasciano i JWT simmetrici vulnerabili ad attacchi a dizionario brute-force offline.

L'implementazione o il test dell'emissione di JWT richiede il rigoroso rispetto delle regole a livello di byte definite in RFC 7515 (JWS), RFC 7518 (JWA) e RFC 7519 (JWT).

Input di Firma JWS Esatto e Codifica del Digest Binario

Secondo RFC 7515 Sezione 5.1, la firma JWS viene calcolata sui byte ASCII dei segmenti codificati in Base64URL, mai sulle stringhe JSON grezze:

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

Due dettagli di serializzazione influenzano l'interoperabilità tra linguaggi diversi:

  1. Digest Binario vs Stringa Esadecimale: HMAC_SHA2 restituisce byte binari grezzi (32 byte per HS256, 48 byte per HS384, 64 byte per HS512). È necessario codificare in Base64URL direttamente tali byte grezzi (ottenendo rispettivamente 43, 64 o 86 caratteri), non una stringa esadecimale minuscola intermedia.
  2. Determinismo della Serializzazione JSON: Sebbene gli oggetti JSON RFC 8259 siano mappe chiave-valore non ordinate, JWS firma l'esatta sequenza di byte UTF-8 serializzata al momento della creazione. Riordinare le chiavi o formattare con spazi (pretty-printing) altera il payload Base64URL e produce una firma completamente diversa.

Dimensionamento dell'Algoritmo HMAC e Resistenza al Brute-Force (RFC 7518 Sezione 3.2)

  • HS256 (SHA-256, blocco interno a 512 bit): digest a 256 bit (32 byte), firma Base64URL di 43 caratteri. Segreto CSPRNG minimo di 32 byte.
  • HS384 (SHA-384, blocco interno a 1024 bit): digest a 384 bit (48 byte), firma Base64URL di 64 caratteri. Segreto CSPRNG minimo di 48 byte.
  • HS512 (SHA-512, blocco interno a 1024 bit): digest a 512 bit (64 byte), firma Base64URL di 86 caratteri. Segreto CSPRNG minimo di 64 byte.

Poiché ogni client in possesso di un JWT detiene sia l'input di firma in chiaro (<header>.<payload>) sia il relativo tag MAC, un attaccante può testare i segreti candidati completamente offline a milioni di hash al secondo senza attivare i rate limit delle API. Genera sempre i segreti da un generatore di numeri casuali crittograficamente sicuro (CSPRNG) anziché usare parole facili da ricordare.

Tipi di Claim Registrati RFC 7519 Sezione 4.1

  • iss (Issuer) e sub (Subject): valori StringOrURI case-sensitive che identificano l'autorità che ha emesso il token e il principal (ID utente o service account) che rappresenta.
  • aud (Audience): valore StringOrURI case-sensitive o array JSON di valori StringOrURI che identificano i destinatari previsti. Secondo RFC 8725, i resource server devono convalidare aud per impedire che un token valido emesso per il Servizio A venga riutilizzato (replay) contro il Servizio B.
  • exp (Expiration), nbf (Not Before) e iat (Issued At): valori NumericDate espressi in secondi Unix epoch (Math.floor(Date.now() / 1000)).
  • jti (JWT ID): identificatore univoco del token case-sensitive (come un UUIDv4) utilizzato per le liste di revoca (denylist) e la prevenzione del replay.

Generatore JWT vs Decodificatore JWT vs Generatore HMAC: Scegliere lo Strumento Giusto

Risposta Rapida: Usa il Generatore di Token JWT per costruire e firmare nuovi token Bearer RFC 7519 a tre parti partendo da claim JSON. Usa il Decodificatore e Ispettore JWT per analizzare e verificare JWT esistenti, oppure usa il Generatore e Verificatore HMAC quando hai bisogno di firme keyed-hash esadecimali o Base64 grezze per payload webhook come Stripe o GitHub.

Sebbene tutte e tre le utility si basino sull'hashing Web Crypto nativo del browser, ciascuna si rivolge a un formato di protocollo e a una fase distinta dell'ingegneria delle API.

Funzionalità Generatore di Token JWT (Questo Strumento) Decodificatore e Ispettore JWT Generatore e Verificatore HMAC
Obiettivo Principale Scrivere claim JSON ed emettere un JWT firmato Decodificare, ispezionare i timestamp e verificare un JWT esistente Calcolare un MAC keyed-hash autonomo su un input arbitrario
Input Richiesto Header alg + claim JSON + chiave segreta JWT compatto a tre parti + chiave segreta opzionale Testo grezzo o messaggio JSON + chiave segreta
Formato di Output JWT Base64URL a tre parti (<header>.<payload>.<signature>) Header/payload JSON decodificati, stato di scadenza, controllo validità Stringa di digest esadecimale o Base64 autonoma
Specifica di Riferimento RFC 7519 (JWT) e RFC 7515 (JWS) RFC 7519 (JWT) e RFC 7515 (JWS) RFC 2104 (HMAC) e FIPS 198-1
Caso d'Uso Ideale Creazione di token Bearer per test locali di API e middleware Risoluzione di errori 401, ID token OIDC e TTL Verifica di X-Hub-Signature-256 dei webhook o MAC di richieste API

Dopo aver generato qui una fixture di test, puoi incollare il token risultante nel Decodificatore e Ispettore JWT per simulare la verifica a valle e ispezionare il comportamento dei conti alla rovescia di exp e nbf.

Domande frequenti

FAQ e Guida Tecnica su Generatore di Token JWT

Tutto ciò che devi sapere sull'uso di generatore jwt online e gratuito di Utiliome.

Qual è la lunghezza minima della chiave segreta richiesta per HS256, HS384 e HS512?

La specifica RFC 7518 Sezione 3.2 impone che una chiave HMAC abbia una dimensione maggiore o uguale alla lunghezza dell'output dell'hash: almeno 32 byte (256 bit) per HS256, 48 byte (384 bit) per HS384 e 64 byte (512 bit) per HS512. Librerie backend rigorose come Nimbus JOSE+JWT, jjwt e PyJWT sollevano eccezioni di chiave debole o avvisi se fornisci stringhe ASCII più corte.

Perché il mio codice HS256 personalizzato produce una firma di 86 caratteri invece di 43?

Una firma HS256 di 86 caratteri si verifica quando il codice converte prima il digest HMAC-SHA256 di 32 byte in una stringa esadecimale di 64 caratteri e poi codifica in Base64URL quei 64 caratteri ASCII. La specifica RFC 7515 richiede di codificare in Base64URL direttamente i 32 byte binari grezzi, il che produce sempre esattamente 43 caratteri Base64URL senza padding.

Quando dovrei scegliere l'HMAC simmetrico (HS256) rispetto a RSA o ECDSA asimmetrici (RS256 o ES256)?

Usa gli algoritmi simmetrici HS256, HS384 o HS512 quando lo stesso servizio backend fidato (o ambiente di test locale) sia firma che verifica il token, poiché entrambe le operazioni condividono una singola chiave segreta e vengono eseguite con un overhead minimo della CPU. Quando più microservizi a valle o client di terze parti devono verificare i token senza ottenere la facoltà di emetterne di nuovi, usa gli algoritmi asimmetrici ES256, RS256 o EdDSA, dove solo l'identity provider detiene la chiave privata di firma.

Come devo formattare i timestamp exp, nbf e iat durante la generazione di un JWT?

Formatta exp, nbf e iat come secondi numerici Unix epoch (ad esempio, 1767225600), mai come stringhe di data ISO 8601 tra virgolette e mai come millisecondi JavaScript a 13 cifre. Per un access token di 15 minuti, imposta iat al tempo epoch corrente in secondi e imposta exp a iat + 900.

Posso generare JWT scaduti o con data futura per testare la gestione degli errori delle API?

Sì. A differenza dei server OAuth2 di produzione che emettono solo token attualmente validi, questo generatore client-side ti consente di impostare deliberatamente exp nel passato o nbf nel futuro. Ciò rende semplice scrivere test di integrazione deterministici per confermare che il tuo middleware di autenticazione rifiuti i token scaduti o prematuri con 401 Unauthorized rispettando al contempo la tolleranza di clock-skew configurata.