Generatore di segreti JWT — HS256/384/512

Cos'è un generatore di segreti JWT?

// The secret you generate here goes straight into your signing code.
// Node.js with jsonwebtoken — the JWT_SECRET env var holds the key.
import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET; // e.g. base64url value from this tool

// Sign a token with HS256 (HMAC-SHA-256).
const token = jwt.sign({ sub: 'user-42', role: 'member' }, secret, {
  algorithm: 'HS256',
  expiresIn: '15m'
});

// Verify it — pin the algorithm to a whitelist; never trust the token's alg.
const payload = jwt.verify(token, secret, { algorithms: ['HS256'] });

// ---------------------------------------------------------------
// Python with PyJWT — same secret, same algorithm pinning.
// import jwt
// token = jwt.encode({"sub": "user-42"}, key, algorithm="HS256")
// payload = jwt.decode(token, key, algorithms=["HS256"])  # whitelist!

// ---------------------------------------------------------------
// Equivalent-strength CLI generation (32 bytes for HS256):
//   openssl rand -base64 32
//   node -e "console.log(require('crypto').randomBytes(32).toString('base64url'))"
//   python -c "import secrets; print(secrets.token_urlsafe(32))"

Caratteristiche principali

Esempi pratici

Algorithm: HS256 · Format: base64url

3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0

Algorithm: HS512 · Format: base64url

k2Lp9XqA0mNbVcZ7rT4wYsHfGjUe8RoIdPlNkBvM3xQ1aWtCyZuS6FhEgJ (86 chars)

Click "Copy for .env"

JWT_SECRET=3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0

Show the CLI command

openssl rand -base64 32

Toggle the eye icon

•••••••••••••••••••••••••••••••••••••••••••  ↔  3sJ9aFq2kP7m…

Come usare il generatore di segreti JWT

1. 1

   Scegli l'algoritmo di firma

   Seleziona HS256, HS384 o HS512. Il generatore applica all'istante la lunghezza minima della chiave della RFC 7518 §3.2 per quella variante HMAC — 32, 48 o 64 byte — così non devi mai cercare il numero né rischi una chiave sottodimensionata.

2. 2

   Scegli il formato di output

   base64url è il valore predefinito — la codifica nativa, URL-safe e senza padding di JWT. Passa a base64 standard se un loader lo richiede, o a hex quando un sistema accetta solo i caratteri 0–f. Tutti e tre codificano gli stessi byte casuali con entropia identica.

3. 3

   Rivela e copia il segreto

   Il segreto è mascherato per impostazione predefinita per tenerlo fuori dallo schermo durante una demo o una condivisione schermo. Fai clic sull'icona dell'occhio per rivelarlo, poi Copia per prendere il valore grezzo o Copia per .env per copiare una riga JWT_SECRET=… pronta per un file .env o una variabile CI.

4. 4

   Rigenera all'occorrenza

   Fai clic su Rigenera per un segreto nuovo e indipendente estratto da crypto.getRandomValues. Generane uno per ogni ambiente — non riutilizzare mai la stessa chiave di firma tra sviluppo, staging e produzione.

5. 5

   Usa l'equivalente CLI o passa alla firma

   Il pannello CLI mostra le corrispondenti one-liner openssl, Node e Python per il provisioning tramite script. Con il tuo segreto in mano, firma un token con il Codificatore JWT e conferma la firma con il Decodificatore JWT.

Errori comuni con i segreti JWT

JWT_SECRET=mySuperSecret123  →  low entropy, brute-forceable

JWT_SECRET=3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0  →  32 random bytes

16-byte key with HS256  →  below the 32-byte minimum

32-byte key with HS256  →  meets RFC 7518 §3.2

Math.random()-based key  →  predictable, unsafe

crypto.getRandomValues key  →  full entropy

Service A: raw string · Service B: base64-decoded  →  signatures never match

Both services use the identical stored string  →  signatures verify

Same JWT_SECRET in dev, staging, prod  →  one leak breaks all

A unique secret per environment  →  blast radius contained

jwt.verify(token, secret)  →  accepts the token's alg

jwt.verify(token, secret, { algorithms: ['HS256'] })  →  pinned

Chi usa questo strumento

Predisponi un JWT_SECRET per un nuovo servizio

Stai avviando un'API che emette token firmati tramite HMAC? Scegli l'algoritmo usato dalla tua libreria, copia il segreto come riga JWT_SECRET=… e inseriscilo nell'ambiente del servizio. Genera una chiave distinta per sviluppo, staging e produzione — non condividere mai un solo segreto tra gli ambienti.

Ruota un segreto compromesso o datato

Quando una chiave è sospettata trafugata o semplicemente da rinnovare, genera qui un nuovo segreto, assegnagli un nuovo kid e distribuiscilo con una finestra di sovrapposizione così i token attivi continuano a verificarsi finché non scadono. In caso di compromissione confermata, ruota immediatamente e rimuovi la vecchia chiave dall'insieme accettato.

Sostituisci una chiave debole o digitata a mano

Hai ereditato una codebase il cui JWT_SECRET è una frase breve o un valore di esempio copiato? Quella chiave è forzabile offline. Genera una sostituzione casuale di 32 byte a piena entropia, sostituiscila dietro una finestra di rotazione e chiudi la falla di forgiatura dei token prima che venga sfruttata.

Genera la chiave tramite script in una pipeline

Hai bisogno che la chiave venga creata in CI o in un Dockerfile anziché a mano? Usa la one-liner openssl, Node o Python del pannello CLI per coniare un segreto di pari robustezza all'interno del tuo script di provisioning, e usa questa pagina per capire le lunghezze in byte e le codifiche che ogni comando produce.

Insegna la firma JWT in sicurezza

Guida un team attraverso il funzionamento di HS256 senza mai esporre una vera chiave di produzione — genera un segreto usa e getta sullo schermo (mascherato finché non lo riveli), firma un token di esempio con il Codificatore JWT e verificalo con il Decodificatore JWT così l'intero ciclo di firma e verifica è visibile.

Confronta le dimensioni delle chiavi HS256, HS384 e HS512

Stai decidendo su quale variante HMAC standardizzarti? Passa tra gli algoritmi per vedere come crescono la lunghezza della chiave richiesta e la stringa codificata — 43, 64 e 86 caratteri base64url — e scegli il compromesso robustezza-dimensione del token che si adatta al tuo sistema prima di fissarlo nella configurazione.

Genera chiavi per lo sviluppo locale

Hai bisogno di un segreto rapido e valido per far funzionare un flusso di autenticazione locale? Generane uno con un clic, copialo per .env e sei sbloccato — con una vera chiave CSPRNG anziché un segnaposto che dimenticherai di sostituire prima del deploy.

Come funziona il generatore

crypto.getRandomValues (CSPRNG)

I segreti sono generati riempiendo un Uint8Array con crypto.getRandomValues, il generatore di numeri pseudo-casuali crittograficamente sicuro di Web Crypto. È la stessa fonte di entropia che sta dietro la generazione di chiavi di Web Crypto. Math.random non viene mai usato da nessuna parte — è statisticamente prevedibile e inadatto a qualsiasi chiave crittografica.

Dimensionamento delle chiavi RFC 7518 §3.2

Il conteggio dei byte per algoritmo segue il requisito di JSON Web Algorithms secondo cui una chiave HMAC sia almeno della dimensione dell'output di hash: 32 byte per HS256 (SHA-256), 48 per HS384 (SHA-384), 64 per HS512 (SHA-512). Selezionare l'algoritmo imposta il minimo; il generatore non emetterà una chiave sotto la soglia della specifica.

Codifiche RFC 4648 (base64url / base64 / hex)

I byte grezzi sono codificati con gli alfabeti RFC 4648. base64url usa l'alfabeto URL-safe senza padding (32 byte → 43 caratteri), base64 standard usa il padding +, / e = (→ 44 caratteri), e hex scrive due caratteri per byte (→ 64 caratteri). Cambiare formato ricodifica gli stessi byte — l'entropia sottostante è invariata.

Perché base64url è il valore predefinito

I componenti JWT sono essi stessi codificati in base64url, e l'alfabeto URL-safe senza padding significa che un segreto in base64url non ha mai bisogno di escaping in un header, in un URL o in un file di configurazione. Il +, il / e il = finale di base64 standard possono creare problemi in quei contesti, quindi base64url è il valore predefinito conservativo per un JWT_SECRET.

Formattazione di Copia per .env

Copia per .env emette JWT_SECRET= su una singola riga senza virgolette — la forma che i loader in stile dotenv analizzano senza modifiche. Il segreto grezzo non include mai caratteri che richiederebbero virgolette in un file .env, quindi la riga è sicura da incollare così com'è.

Comandi CLI di pari robustezza, non identici byte per byte

I comandi openssl rand -base64 N, Node randomBytes(N).toString('base64url') e Python secrets.token_urlsafe(N) del pannello CLI estraggono tutti N byte casuali sicuri per l'algoritmo scelto. Producono chiavi di pari robustezza, non la stessa stringa — openssl emette base64 standard con padding, quindi l'alfabeto e i caratteri finali differiscono dal valore predefinito base64url di questo strumento.

Buone pratiche per i segreti JWT

Adatta la lunghezza della chiave all'algoritmo

Usa almeno 32 byte per HS256, 48 per HS384 e 64 per HS512, come richiede la RFC 7518 §3.2. Questo generatore lo fa per te, ma se dimensioni una chiave a mano, non scendere mai sotto la lunghezza dell'output di hash — una chiave HMAC sottodimensionata indebolisce la firma e può essere rifiutata da librerie rigorose.

Genera sempre con un CSPRNG, mai una password

Un segreto JWT è una credenziale da macchina che nessuno deve memorizzare, quindi spendi l'intera entropia: usa una chiave casuale crittograficamente sicura, non una passphrase, una parola di dizionario o una stringa digitata a mano. I segreti scelti dagli esseri umani sono il bersaglio più facile per gli attacchi brute-force offline che gli strumenti di cracking JWT automatizzano.

Usa un segreto unico per ogni ambiente

Sviluppo, staging e produzione dovrebbero avere ciascuno il proprio JWT_SECRET. Condividere una sola chiave significa che una fuga in un ambiente a basso rischio forgia token ovunque, e rende la rotazione tutto-o-niente. Genera qui un segreto separato per ogni ambiente e conserva ciascuno nel proprio ambito del gestore di segreti.

Fissa l'algoritmo quando verifichi

Sul lato della verifica, passa sempre una whitelist esplicita di algoritmi — algorithms: ['HS256'] in jsonwebtoken, algorithms=["HS256"] in PyJWT — e non fidarti mai del campo alg all'interno del token. Accettare l'algoritmo auto-dichiarato dal token abilita i classici attacchi di forgiatura alg-confusion e alg:none, indipendentemente da quanto sia robusto il tuo segreto.

Ruota con un header kid e chiavi sovrapposte

Etichetta i token firmati con un identificatore di chiave (kid) e pubblica le chiavi attive tramite un endpoint JWKS così puoi ruotare senza downtime: firma i nuovi token con la nuova chiave continuando ad accettare la vecchia finché i suoi token non scadono. In caso di sospetta compromissione, salta la sovrapposizione e revoca immediatamente la vecchia chiave.

Domande frequenti