Gerador de Segredo JWT — HS256/384/512

O Que É um Gerador de Segredo 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))"

Recursos Principais

Exemplos Resolvidos

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…

Como Usar o Gerador de Segredo JWT

1. 1

   Escolha o algoritmo de assinatura

   Selecione HS256, HS384 ou HS512. O gerador aplica instantaneamente o comprimento mínimo de chave da RFC 7518 §3.2 para aquela variante HMAC — 32, 48 ou 64 bytes — para que você nunca tenha que procurar o número nem arriscar uma chave subdimensionada.

2. 2

   Escolha o formato de saída

   base64url é o padrão — a codificação nativa, segura para URL e sem preenchimento do JWT. Mude para base64 padrão se um carregador esperar, ou hex quando um sistema só aceitar caracteres 0–f. Todos os três codificam os mesmos bytes aleatórios com entropia idêntica.

3. 3

   Revele e copie o segredo

   O segredo fica mascarado por padrão para mantê-lo fora da tela durante uma demonstração ou compartilhamento de tela. Clique no ícone de olho para revelá-lo, depois Copiar para pegar o valor bruto ou Copy for .env para copiar uma linha JWT_SECRET=… pronta para um arquivo .env ou variável de CI.

4. 4

   Gere novamente conforme necessário

   Clique em Gerar novamente para um segredo novo e independente extraído de crypto.getRandomValues. Gere um por ambiente — nunca reutilize a mesma chave de assinatura entre desenvolvimento, staging e produção.

5. 5

   Use o equivalente de CLI ou parta para a assinatura

   O painel de CLI mostra os one-liners correspondentes de openssl, Node e Python para provisionamento via script. Com seu segredo em mãos, assine um token com o Codificador JWT e confirme a assinatura com o Decodificador JWT.

Erros Comuns de Segredo 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

Quem Usa Esta Ferramenta

Provisionar um JWT_SECRET para um Novo Serviço

Subindo uma API que emite tokens assinados por HMAC? Escolha o algoritmo que sua biblioteca usa, copie o segredo como uma linha JWT_SECRET=… e solte-o no ambiente do serviço. Gere uma chave distinta para desenvolvimento, staging e produção — nunca compartilhe um segredo entre ambientes.

Girar um Segredo Comprometido ou Antigo

Quando uma chave é suspeita de vazamento ou simplesmente está na hora de rotação, gere um novo segredo aqui, atribua a ele um novo kid e implante-o com uma janela de sobreposição para que tokens ativos continuem verificando até expirarem. Em um comprometimento confirmado, gire imediatamente e remova a chave antiga do conjunto aceito.

Substituir uma Chave Fraca ou Digitada à Mão

Herdou uma base de código cujo JWT_SECRET é uma frase curta ou um valor de exemplo copiado? Essa chave é quebrável por força bruta offline. Gere uma substituição de 32 bytes com entropia completa, troque-a por trás de uma janela de rotação e feche a brecha de falsificação de token antes que seja explorada.

Gerar Chaves via Script em um Pipeline

Precisa da chave criada em CI ou em um Dockerfile em vez de à mão? Use o one-liner de openssl, Node ou Python do painel de CLI para cunhar um segredo de força equivalente dentro do seu script de provisionamento, e use esta página para entender os comprimentos de bytes e as codificações que cada comando produz.

Ensinar Assinatura JWT com Segurança

Guie uma equipe por como o HS256 funciona sem nunca expor uma chave real de produção — gere um segredo descartável na tela (mascarado até você revelá-lo), assine um token de exemplo com o Codificador JWT e verifique-o com o Decodificador JWT para que todo o ciclo de assinar e verificar fique visível.

Comparar Tamanhos de Chave HS256, HS384 e HS512

Decidindo qual variante HMAC padronizar? Alterne entre os algoritmos para ver como o comprimento de chave exigido e a string codificada crescem — 43, 64 e 86 caracteres base64url — e escolha o tradeoff entre força e tamanho de token que se encaixa no seu sistema antes de comprometê-lo na configuração.

Gerar Chaves para Desenvolvimento Local

Precisa de um segredo rápido e válido para colocar um fluxo de autenticação local em funcionamento? Gere um em um clique, copie-o para o .env e você está desbloqueado — com uma chave de CSPRNG real em vez de um placeholder que você esquecerá de substituir antes do deploy.

Como o Gerador Funciona

crypto.getRandomValues (CSPRNG)

Os segredos são gerados preenchendo um Uint8Array com crypto.getRandomValues, o gerador de números pseudoaleatórios criptograficamente seguro do Web Crypto. É a mesma fonte de entropia que sustenta a geração de chaves do Web Crypto. Math.random nunca é usado em lugar algum — ele é estatisticamente previsível e impróprio para qualquer chave criptográfica.

Dimensionamento de Chave da RFC 7518 §3.2

A contagem de bytes por algoritmo segue a exigência do JSON Web Algorithms de que uma chave HMAC seja pelo menos do tamanho da saída do hash: 32 bytes para HS256 (SHA-256), 48 para HS384 (SHA-384), 64 para HS512 (SHA-512). Selecionar o algoritmo define o mínimo; o gerador não emitirá uma chave abaixo do piso da especificação.

Codificações RFC 4648 (base64url / base64 / hex)

Os bytes brutos são codificados com os alfabetos da RFC 4648. base64url usa o alfabeto seguro para URL sem preenchimento (32 bytes → 43 chars), o base64 padrão usa preenchimento +, / e = (→ 44 chars), e hex escreve dois caracteres por byte (→ 64 chars). Trocar de formato recodifica os mesmos bytes — a entropia subjacente é inalterada.

Por que base64url É o Padrão

Os componentes do JWT são eles mesmos codificados em base64url, e o alfabeto seguro para URL e sem preenchimento significa que um segredo em base64url nunca precisa de escape em um cabeçalho, uma URL ou um arquivo de configuração. Os +, / e = finais do base64 padrão podem quebrar nesses contextos, então base64url é o padrão conservador para um JWT_SECRET.

Formatação do Copy-for-.env

Copy for .env emite JWT_SECRET= em uma única linha sem aspas ao redor — a forma que os carregadores no estilo dotenv analisam sem modificação. O segredo bruto nunca inclui caracteres que exigiriam aspas em um arquivo .env, então a linha é segura para colar como está.

Comandos de CLI de Força Equivalente, Não Byte a Byte Idênticos

Os comandos openssl rand -base64 N, Node randomBytes(N).toString('base64url') e Python secrets.token_urlsafe(N) do painel de CLI todos extraem N bytes aleatórios seguros para o algoritmo escolhido. Eles produzem chaves de força equivalente, não a mesma string — o openssl emite base64 padrão com preenchimento, então o alfabeto e os caracteres finais diferem do padrão base64url desta ferramenta.

Boas Práticas de Segredo JWT

Combine o Comprimento da Chave com o Algoritmo

Use pelo menos 32 bytes para HS256, 48 para HS384 e 64 para HS512, como exige a RFC 7518 §3.2. Este gerador faz isso por você, mas se você dimensionar uma chave à mão, nunca fique abaixo do comprimento da saída do hash — uma chave HMAC subdimensionada enfraquece a assinatura e pode ser rejeitada por bibliotecas estritas.

Sempre Gere com um CSPRNG, Nunca uma Senha

Um segredo JWT é uma credencial de máquina que ninguém precisa memorizar, então gaste a entropia completa: use uma chave aleatória criptograficamente segura, não uma frase-senha, uma palavra de dicionário ou uma string digitada à mão. Segredos escolhidos por humanos são o alvo mais fácil para os ataques offline de força bruta que as ferramentas de quebra de JWT automatizam.

Use um Segredo Único por Ambiente

Desenvolvimento, staging e produção devem cada um ter seu próprio JWT_SECRET. Compartilhar uma chave significa que um vazamento em um ambiente de baixo risco forja tokens em todos os lugares, e torna a rotação tudo ou nada. Gere um segredo separado aqui para cada ambiente e armazene cada um em seu próprio escopo de gerenciador de segredos.

Fixe o Algoritmo Quando Você Verifica

No lado verificador, sempre passe uma lista branca explícita de algoritmos — algorithms: ['HS256'] no jsonwebtoken, algorithms=["HS256"] no PyJWT — e nunca confie no campo alg dentro do token. Aceitar o algoritmo autodeclarado do token habilita os clássicos ataques de confusão de alg e falsificação alg:none, por mais forte que seja seu segredo.

Gire com um Cabeçalho kid e Chaves Sobrepostas

Marque os tokens assinados com um identificador de chave (kid) e publique as chaves ativas por meio de um endpoint JWKS para que você possa girar sem indisponibilidade: assine novos tokens com a nova chave enquanto ainda aceita a antiga até que seus tokens expirem. Em uma suspeita de comprometimento, pule a sobreposição e revogue a chave antiga imediatamente.

Perguntas Frequentes