Skip to content

Gerador grátis de pares de chaves RSA — ECDSA e Ed25519

Gere um par de chaves RSA online: a chave privada nunca sai do seu navegador. RSA 2048/4096, ECDSA, Ed25519, PEM PKCS#8 ou PKCS#1, JWK e impressão digital.

Sem rastreamento Roda no navegador Grátis
Os pares de chaves são gerados dentro do seu navegador com a API Web Crypto, e nenhuma requisição de rede é feita durante a geração. Desconecte-se e esta página continua funcionando.

PKCS#8 (BEGIN PRIVATE KEY) é o padrão moderno e o que o JDK espera. PKCS#1 (BEGIN RSA PRIVATE KEY) é a forma tradicional do OpenSSL, ainda exigida por alguns gateways. Alternar recodifica a mesma chave.

Mantenha em segredo. Quem tiver esta chave pode se passar por você.

Impressão digital da chave pública — SHA-256 do DER SPKI
JWK (JSON Web Key)
JWK privada — nunca publique esta 
 
 
 
 JWK pública  
 
 
 
 
  
 
Gere o mesmo tipo de par de chaves com OpenSSL
 
 
    
 
  
  
  
  Revisado quanto à conformidade com as RFC 5958/5208 (PKCS#8), RFC 8017 (PKCS#1), RFC 8410 (Ed25519) e a codificação PEM da RFC 7468, e quanto ao comportamento da API Web Crypto em RSA, ECDSA e Ed25519. — Equipe de Ferramentas de Segurança da Go Tools · Aug 10, 2026  
 Nossa equipe confere a conversão de PKCS#8 para PKCS#1 byte a byte contra a saída de referência do módulo crypto do Node, de modo que uma chave exportada aqui é idêntica à que o OpenSSL produziria para o mesmo material. 
 
 
      
 
O Que É um Gerador de Chaves RSA?
 
 
Um gerador de chaves RSA produz um par ligado matematicamente: uma chave privada que você guarda e uma chave pública que você distribui. Tudo o que é assinado com a metade privada pode ser verificado com a metade pública, e só a metade pública pode ser publicada com segurança. Essa assimetria é o ponto central: é ela que permite a quem verifica conferir suas assinaturas sem ganhar a capacidade de forjá-las, algo que um segredo compartilhado nunca oferece.
Este gerador roda dentro do seu navegador pela API Web Crypto, então a chave privada nasce na aba e a página não faz nenhuma requisição de rede enquanto gera. Além de RSA, ele também produz pares ECDSA e Ed25519, que cumprem o mesmo papel com chaves bem mais curtas: uma chave privada Ed25519 ocupa 48 bytes em PKCS#8, enquanto uma chave RSA de 2048 bits passa de 1,2 KB.
O que costuma derrubar as pessoas não é a matemática, é o empacotamento. A mesma chave pode ser escrita como PKCS#8, PKCS#1, SPKI ou JWK, e uma biblioteca que rejeita um formato muitas vezes aceita outro sem nenhuma mensagem mais clara que um erro de parsing. A tabela mais abaixo associa cada contêiner aos ecossistemas que o esperam.
 
 
// Verify a downloaded key pair matches, using OpenSSL:
openssl pkey -in rsa-2048-private.pem -pubout | diff - rsa-2048-public.pem
// No output means the public key really belongs to that private key.
 
  
 
Recursos Principais
 
 
 
Gerado no seu navegador
 
As chaves vêm da API Web Crypto na sua própria aba, e a página não faz nenhuma requisição de rede enquanto gera. Desligue a conexão e ela continua funcionando, o que mostra que a ferramenta não precisa de servidor algum para fazer seu trabalho.
 
 
RSA, ECDSA e Ed25519
 
RSA 2048, 3072 e 4096; ECDSA em P-256, P-384 e P-521; e Ed25519, tudo em uma única página com as mesmas opções de exportação.
 
 
Saída em PKCS#8 e PKCS#1
 
Alterne entre BEGIN PRIVATE KEY e a disposição tradicional BEGIN RSA PRIVATE KEY sem encostar no OpenSSL. O seletor recodifica a chave que já está na tela, ou seja, continua sendo a mesma chave.
 
 
Exportação para JWK
 
As duas metades ficam disponíveis como JSON Web Keys. A JWK pública é a que entra em um documento JWKS ou em um verificador JOSE; a JWK privada é só do seu assinador e nunca deve ser publicada.
 
 
Impressão digital SHA-256
 
Cada par vem com uma impressão digital da sua chave pública para você verificar por um canal separado que os dois lados têm a mesma chave.
 
 
Comandos OpenSSL correspondentes
 
Os comandos equivalentes para gerar o mesmo tipo de chave localmente aparecem abaixo da saída, para você migrar para a linha de comando quando preferir.
 
 
Downloads com nomes úteis
 
Os arquivos são salvos como rsa-2048-private.pem e rsa-2048-public.pem, e não com um nome genérico que você precisa renomear depois.
 
 
Sem conta e sem limite de uso
 
Nenhum servidor está envolvido, então não há cadastro a fazer nem cota para esgotar.
 
 
 
      
 
Exemplos Resolvidos
 
 
 
Par Ed25519, mostrado por inteiro
 
 
Algoritmo: Ed25519
 
-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIA2HJVU1qChbOJN8XksXVhyD0IjYVt0UU6Mwz814rOFf
-----END PRIVATE KEY-----

-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAV5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU=
-----END PUBLIC KEY-----
 
 
Uma chave privada Ed25519 ocupa 48 bytes em PKCS#8 e a chave pública 44 bytes, então cada PEM cabe em uma única linha de base64. Este par é uma demonstração descartável — gere o seu em vez de copiar este.
 
 
Os cabeçalhos PKCS#8 e PKCS#1 são diferentes
 
 
Algoritmo: RSA 2048, estrutura alternada
 
PKCS#8:  -----BEGIN PRIVATE KEY-----
PKCS#1:  -----BEGIN RSA PRIVATE KEY-----
 
 
A mesma chave em dois invólucros. PKCS#8 acrescenta um identificador de algoritmo em volta da estrutura RSA, e é por isso que ele serve para qualquer algoritmo enquanto PKCS#1 existe só para RSA. Acionar o seletor recodifica a chave que já está na tela, então a impressão digital não muda.
 
 
Chave pública RSA 2048
 
 
Algoritmo: RSA 2048
 
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk/fbpPCGDyh71m73oB9Bk8+fKVkSThXyWTtpgblB7pX
iQBtTvSWVZGHprkLgMGkU2Yw8Z43m1WpoRuYyXNFe92S5viIdVuKTj/VEUuEpzHd
ffWMIUw70LaUdTP04iQdkNVeS3M6VHkpTwsPSQfsFSwObtLVNy2Lf+ODwJRqCk2r
C749hgKqBdJqkcIj49R7UP4SMQ/9V3yy8DFMrIcgsjC4tHwlQSCGeXNxTNlapGSa
ke55LUR83FASryVJRbUs678SCZSFkyGcT0qLZ/olu/e7Jj2lB0Qy/SJawkrs9hPE
4QIDAQAB
-----END PUBLIC KEY-----
 
 
O prefixo MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A é o identificador do algoritmo rsaEncryption: é por ele que se reconhece uma chave SPKI de RSA de imediato.
 
 
Chave pública como JWK
 
 
Algoritmo: Ed25519, painel JWK
 
{
  "key_ops": [
    "verify"
  ],
  "ext": true,
  "alg": "Ed25519",
  "crv": "Ed25519",
  "x": "V5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU",
  "kty": "OKP"
}
 
 
Esta é a exportação literal, incluindo os membros key_ops e ext que o Web Crypto sempre acrescenta. Uma entrada de JWKS não os quer — remova os dois e acrescente kid e use no lugar, para que quem verifica consiga selecionar a chave certa durante uma rotação. Ed25519 cai no tipo de chave OKP; chaves RSA aparecem com kty RSA e os membros n e e.
 
 
Impressão digital SHA-256
 
 
Algoritmo: Ed25519
 
SHA256(SPKI) = KAXVxapxpG4zLsTVMpPafovT+X1NLWc8fsOXqtrb59o=
 
 
Um resumo SHA-256 da estrutura da chave pública, curto o bastante para ler ao telefone. Atenção: não é o valor que o ssh-keygen imprime — o OpenSSH aplica hash ao próprio formato de transporte, então os dois nunca coincidem para a mesma chave.
 
 
 
      
 
Como Usar o Gerador de Chaves RSA
 
     
  1.  1 
     
    Escolha o algoritmo
     
    RSA cobre a maior variedade de sistemas legados. ECDSA entrega força equivalente em chaves muito menores. Ed25519 é o padrão moderno para qualquer trabalho novo de assinatura.
     
     
  2.  2 
     
    Escolha o tamanho da chave
     
    RSA 2048 atende às recomendações atuais; 3072 e 4096 acrescentam margem para chaves de vida longa. ECDSA oferece P-256, P-384 e P-521. Ed25519 tem um único tamanho fixo.
     
     
  3.  3 
     
    Selecione a estrutura PEM
     
    PKCS#8 emite BEGIN PRIVATE KEY e funciona em praticamente todo lugar, inclusive no JDK. Mude para PKCS#1 apenas quando algo exigir especificamente BEGIN RSA PRIVATE KEY.
     
     
  4.  4 
     
    Copie ou baixe as duas metades
     
    A chave privada vai para o seu cofre de segredos. A chave pública vai para quem verifica suas assinaturas. Nunca envie a metade privada a lugar nenhum.
     
     
  5.  5 
     
    Confira a impressão digital
     
    Compare a impressão digital SHA-256 por um canal separado para confirmar que o outro lado instalou a chave pública que você realmente gerou.
     
     
    6.  
 
  
 
Erros Comuns de Formato de Chave
 
 
 
Colar a chave pública onde vai a privada
 
Assinar exige a metade privada. Uma biblioteca que recebe BEGIN PUBLIC KEY onde esperava uma chave privada geralmente devolve um erro de parsing pouco útil em vez de nomear o problema real.
 
 
 ✗ Incorreto 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Correto 
-----BEGIN PRIVATE KEY-----
 
 
 
 
Estrutura PEM errada para a biblioteca
 
Poucos ecossistemas leem apenas a disposição RSA tradicional — a própria saída -traditional do OpenSSL, alguns SDKs de gateway de pagamento, ferramentas antigas de Ruby e Perl. A maioria das bibliotecas modernas, e o JDK em particular, espera PKCS#8. Troque o seletor de estrutura PEM em vez de caçar um comando de conversão.
 
 
 ✗ Incorreto 
-----BEGIN RSA PRIVATE KEY-----
 
 
 ✓ Correto 
-----BEGIN PRIVATE KEY-----
 
 
 
 
Perder a quebra de linha final
 
Arquivos PEM terminam com uma quebra de linha depois do último delimitador. Copiar através de um campo de formulário que apara espaços produz um arquivo que alguns parsers rejeitam de cara — e, como o caractere que falta é invisível, o arquivo parece correto em um editor.
 
 
 ✗ Incorreto 
-----END PRIVATE KEY-----[EOF]
 
 
 ✓ Correto 
-----END PRIVATE KEY-----↵[EOF]
 
 
 
 
Um caractere perdido no caminho
 
O que quebra um PEM é um caractere perdido, inserido ou substituído, não a largura das linhas — a maioria dos parsers aceita qualquer quebra. Uma cópia que passa por um cliente de chat ou por um campo de formulário pode silenciosamente transformar uma quebra de linha em espaço, e o base64 não dá nenhuma pista de qual caractere saiu errado; a chave simplesmente não carrega. Use o botão de copiar em vez de selecionar à mão.
 
 
 ✗ Incorreto 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk
 
 
 ✓ Correto 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk
 
 
 
 
Usar um segredo HS256 onde RS256 está configurado
 
HS256 usa um único segredo compartilhado; RS256 usa um par de chaves. Entregar uma string aleatória a um assinador RS256 falha logo no parsing. Gere o par aqui, ou use nosso gerador de segredo JWT se a intenção era HS256.
 
 
 ✗ Incorreto 
alg: RS256, key: 8f3a9c2e1b7d
 
 
 ✓ Correto 
alg: RS256, key: -----BEGIN PRIVATE KEY-----
 
 
 
 
Colar um PEM no authorized_keys
 
Uma chave pública SSH está no formato de uma linha do OpenSSH, ssh-ed25519 AAAA…, e não em um bloco PEM, então colar a chave pública desta página no authorized_keys não vai funcionar. Para uma chave RSA você pode derivar a linha certa localmente com ssh-keygen -y; para acesso SSH em geral, gerar na máquina de destino ainda é melhor.
 
 
 ✗ Incorreto 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Correto 
ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub
 
 
 
 
 
  
 
Quem Usa Esta Ferramenta
 
 
 
Assinar JWTs com RS256 ou EdDSA
 
Os algoritmos JWT assimétricos precisam de um par de chaves em vez de um segredo compartilhado. Você assina com a chave privada, publica a chave pública e quem verifica nunca fica com algo que permita emitir tokens. Nosso codificador JWT aceita as chaves que esta página produz.
 
 
Assinar webhooks e releases
 
Publique a chave pública uma vez, assine cada payload com a chave privada e quem consome consegue verificar a autenticidade sem uma credencial compartilhada que possa vazar.
 
 
Desenvolvimento local e testes
 
Suítes de teste que exercitam verificação de assinatura precisam de um par descartável. Gerar um aqui é mais rápido do que lembrar a invocação do OpenSSL.
 
 
Entender como é um par de chaves
 
Alternar entre algoritmos e estruturas PEM lado a lado torna as diferenças concretas de um jeito que ler a especificação não consegue.
 
 
Preparar um endpoint JWKS
 
A JWK pública entra direto no array keys de um documento de descoberta do OpenID Connect. Acrescente um kid para que quem verifica consiga selecioná-la durante uma rotação, e mantenha a JWK privada fora desse arquivo.
 
 
Migrar para longe do RSA
 
Gere o substituto Ed25519 ao lado do original RSA e compare os tamanhos antes de assumir a mudança.
 
 
Resolver uma incompatibilidade de formato
 
Quando uma biblioteca rejeita uma chave com erro de parsing, reemiti-la na outra estrutura PEM costuma ser a correção inteira.
 
 
 
  
 
Formatos PEM e Como o Gerador Funciona
 
 
 
Qual contêiner vai em cada lugar
 
Uma chave, cinco empacotamentos. Escolher o errado é o motivo mais comum de uma chave ser rejeitada, e a mensagem de erro raramente é mais específica do que uma falha de parsing.


ContêinerCabeçalho PEMContémOnde você encontra
PKCS#8BEGIN PRIVATE KEYQualquer algoritmoWeb Crypto, o JDK, Go, .NET — a maioria das bibliotecas modernas
PKCS#1BEGIN RSA PRIVATE KEYSó RSASaída tradicional do OpenSSL, alguns gateways de pagamento, ferramentas antigas de Ruby e Perl
SPKI / X.509BEGIN PUBLIC KEYQualquer algoritmo, metade públicaA chave pública que quase toda biblioteca espera
PKCS#1 públicaBEGIN RSA PUBLIC KEYSó RSA, metade públicaFerramentas RSA legadas
JWKnenhum — é JSONQualquer algoritmoEndpoints JWKS, descoberta OIDC, bibliotecas JOSE


Para converter arquivos que você já tem, openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem faz a conversão em um sentido e openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem no outro.
 
 
A aleatoriedade vem do sistema operacional
 
O Web Crypto alimenta a geração de chaves a partir da fonte de entropia da plataforma — getrandom no Linux, e o CSPRNG do sistema no Windows e no macOS. É a mesma classe de fonte de onde o OpenSSL bebe, não um gerador pseudoaleatório de JavaScript.
 
 
A geração não congela a página
 
crypto.subtle.generateKey é assíncrona e, nos principais motores de navegador, a busca por primos acontece fora da thread principal, então a interface continua responsiva enquanto um módulo de 4096 bits é procurado. Ainda assim a página mostra um indicador de progresso, porque quanto essa busca demora depende da sorte do sorteio.
 
 
PKCS#8 envolve PKCS#1
 
Um PrivateKeyInfo de PKCS#8 é um número de versão, um identificador de algoritmo e um OCTET STRING. Em uma chave rsaEncryption sem criptografia, esse OCTET STRING contém uma RSAPrivateKey PKCS#1 completa, que é exatamente como esta página converte entre os dois sem rederivar nada.
 
 
Chaves públicas usam SubjectPublicKeyInfo
 
BEGIN PUBLIC KEY é um SubjectPublicKeyInfo do X.509: um identificador de algoritmo mais um BIT STRING. O que fica dentro desses bits depende do algoritmo — no RSA é uma RSAPublicKey do PKCS#1, e é por isso que BEGIN RSA PUBLIC KEY é mais curta; no ECDSA é o ponto de curva não comprimido, e no Ed25519 a chave bruta de 32 bytes.
 
 
O expoente público é 65537
 
Toda chave RSA aqui usa e = 65537, escrito 0x010001. É grande o bastante para evitar ataques de expoente pequeno e tem apenas dois bits ligados, então verificar custa 16 elevações ao quadrado e uma única multiplicação.
 
 
As impressões digitais resumem o DER, não o PEM
 
A impressão digital SHA-256 é calculada sobre o SubjectPublicKeyInfo binário. Resumir o texto base64 em vez disso faria o valor mudar sempre que a quebra de linha mudasse. O equivalente local é openssl pkey -in private.pem -pubout -outform DER | openssl dgst -sha256 -binary | openssl base64.
 
 
 
  
 
Boas Práticas de Gestão de Chaves
 
 
 
Gere as chaves onde elas serão usadas
 
Uma chave privada que atravessa uma rede ficou exposta em cada salto do caminho. Gerar no navegador mantém a chave em si fora da rede, embora o código da própria página chegue por ela; gerar no host de destino elimina até a etapa de cópia. Para uma chave que protege sistemas de produção, prefira o host.
 
 
Prefira Ed25519 a menos que algo exija RSA
 
Ed25519 entrega segurança forte em uma chave de 32 bytes, com assinatura rápida e nenhum parâmetro para errar. Recorra ao RSA quando uma contraparte ou uma biblioteca antiga não deixar alternativa.
 
 
Trate 2048 bits como o piso
 
A NIST SP 800-131A proíbe RSA abaixo de 2048 bits para geração de assinaturas desde 2013, e nenhuma autoridade certificadora pública emite contra uma chave menor. Escolha 3072 ou 4096 para chaves que devem permanecer em serviço por muitos anos.
 
 
Nunca faça commit de uma chave privada
 
Coloque chaves privadas em um gerenciador de segredos ou em uma variável de ambiente carregada em tempo de execução. Quando uma chave chega a um repositório, girá-la é a única resposta segura.
 
 
Gire por calendário, não só depois de um incidente
 
Publique as novas chaves públicas com um identificador de chave antes de aposentar as antigas, para que quem verifica aceite as duas durante a sobreposição. Rotação praticada como rotina é rotação que funciona sob pressão.
 
 
 
  
 
Perguntas Frequentes
 
 
 É seguro gerar uma chave privada em um site? 
 A chave é gerada pela API Web Crypto no seu próprio navegador, e esta página não faz nenhuma requisição de rede enquanto gera — você pode acompanhar o painel de Rede, ou desconectar e ver que a geração continua funcionando. Vale ser claro sobre o que isso mostra e o que não mostra: demonstra que a página não precisa de servidor, mas não é prova contra um script comprometido, já que o JavaScript é baixado de novo do nosso servidor a cada visita. Os riscos que restam são do navegador, não da rede — uma extensão maliciosa consegue ler a página e a sua área de transferência, e qualquer pessoa com acesso à máquina consegue ler o arquivo baixado. Para uma chave que protege sistemas de produção, gere-a no host que vai usá-la; os comandos OpenSSL abaixo fazem exatamente isso. Esta página é a ferramenta certa para desenvolvimento, testes, aprendizado e qualquer situação em que uma chave gerada no navegador seja aceitável. 
 
 Qual é a diferença entre PKCS#8 e PKCS#1? 
 São dois contêineres para a mesma chave RSA. PKCS#1, marcado como BEGIN RSA PRIVATE KEY, guarda os números do RSA diretamente e existe só para RSA. PKCS#8, marcado como BEGIN PRIVATE KEY, envolve esses mesmos números em um identificador de algoritmo, o que permite a um único formato carregar RSA, ECDSA e Ed25519 igualmente. A maioria das bibliotecas modernas espera PKCS#8 — o JDK, em particular, lê apenas PKCS#8 sem uma biblioteca extra — enquanto vários gateways de pagamento e ferramentas da era OpenSSL ainda exigem PKCS#1. Acionar o seletor desta página recodifica a chave que já está na tela, então nada é acrescentado ou perdido e a impressão digital permanece a mesma. 
 
 Como converto uma chave PKCS#1 para PKCS#8, ou o contrário? 
 Acione o seletor de estrutura PEM desta página e a mesma chave é reemitida no outro contêiner. Para um arquivo que você já tem, o OpenSSL converte localmente: openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem transforma um arquivo BEGIN RSA PRIVATE KEY em BEGIN PRIVATE KEY, e openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem faz o caminho inverso. Nenhuma das direções acrescenta ou remove material de chave; só o invólucro muda, e é por isso que os dois arquivos descrevem a mesma chave e produzem a mesma impressão digital. 
 
 Como obtenho a chave pública a partir de uma chave privada RSA? 
 A chave pública é derivável da chave privada, nunca o contrário. Esta página mostra as duas metades ao mesmo tempo, então não há nada a derivar. Para uma chave privada que você já tem em disco, openssl pkey -in private.pem -pubout -out public.pem escreve o arquivo BEGIN PUBLIC KEY correspondente. É também assim que você confere se um par pertence um ao outro: gere de novo a metade pública e compare com o arquivo que lhe entregaram. 
 
 Devo escolher RSA ou Ed25519? 
 Escolha Ed25519 quando nada forçar sua mão. Ele alcança segurança comparável ao RSA 3072 com uma chave de 32 bytes, assina mais rápido e não tem parâmetros para configurar errado. Escolha RSA quando uma contraparte, uma autoridade certificadora ou uma biblioteca antiga exigir, o que ainda é comum em sistemas corporativos e de pagamento. O ECDSA fica entre os dois e é amplamente suportado em TLS. 
 
 RSA de 2048 bits ainda é forte o bastante? 
 Sim, para a maioria dos usos de hoje. O NIST classifica o RSA de 2048 bits em 112 bits de força de segurança e o mantém até 2030 na SP 800-57; 3072 bits alcança 128 bits de força e é para onde o NIST aponta além disso. Ou seja: 2048 para qualquer coisa que você vá girar dentro de alguns anos, 3072 ou 4096 para uma chave que você espera ainda em serviço nos anos 2030 ou quando uma autoridade certificadora exigir. O custo da chave maior é assinatura mais lenta e assinaturas maiores, não segurança menor. 
 
 Posso usar estas chaves para assinar JWTs? 
 Pode. Chaves RSA funcionam com RS256, RS384 e RS512, além das variantes PSS; ECDSA P-256 combina com ES256; e Ed25519 é o algoritmo EdDSA. Assine com a chave privada e publique a chave pública para que quem verifica possa conferir assinaturas sem conseguir criá-las. Uma ressalva se você usar o painel JWK em vez do PEM: o Web Crypto carimba uma JWK de RSA com alg RS256, e bibliotecas rigorosas recusam carregá-la para PS256 ou RS512 — remova o membro alg, ou use o PEM. Nosso codificador JWT aceita essas chaves, e o decodificador mostra o que o token resultante contém. 
 
 Isto consegue gerar uma chave SSH? 
 Não diretamente. O arquivo de chave privada próprio do OpenSSH é outro contêiner, e esta página não o escreve. Uma chave RSA daqui ainda é utilizável: ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub deriva a linha do authorized_keys a partir do arquivo que você baixou. Chaves Ed25519 daqui não são, porque o OpenSSH rejeita a forma PKCS#8. Para acesso SSH a melhor resposta continua sendo ssh-keygen -t ed25519 na máquina que precisa da chave, o que evita mover uma chave privada. Para assinatura de JWT, assinatura de releases em CI e verificação de webhooks, a chave PKCS#8 que esta página produz é exatamente o que essas ferramentas querem. 
 
 Posso proteger a chave privada com uma senha? 
 Aqui não. O PKCS#8 criptografado exige uma etapa de derivação de chave que a API Web Crypto não expõe, então implementá-la significaria escrever criptografia artesanal em JavaScript. Adicione a senha localmente: openssl pkcs8 -topk8 -in private.pem -out encrypted.pem lê o arquivo que você baixou e pede a senha. 
 
 Para que serve a impressão digital? 
 É um resumo SHA-256 da estrutura da chave pública, curto o bastante para comparar por voz ou em uma mensagem de chat. Quando você envia uma chave pública a alguém, comparar as impressões digitais por um canal separado confirma que o que chegou é o que você enviou. Ela identifica apenas a chave pública e não revela nada sobre a metade privada. Note que não é o número que o ssh-keygen -l imprime: o OpenSSH aplica hash ao próprio formato de transporte em vez da estrutura SPKI, então os dois nunca coincidem para a mesma chave. 
 
 
 
 
   
  
 
 
Ferramentas relacionadas
  Ver todas as ferramentas →
 
 
  
 
  
  
  
 
 
Ferramenta de Descriptografia AES — OpenSSL e CryptoJS
 
 
Ferramentas de Segurança
 
Descriptografe AES online — GCM/CBC/CTR, frase-senha ou chave bruta, detecta automaticamente o formato "U2FsdGVkX1" do OpenSSL e CryptoJS. 100% no navegador, as chaves nunca saem da página.
 
 
   
  
 
  
  
  
 
 
Ferramenta de Criptografia AES — GCM, CBC e CTR
 
 
Ferramentas de Segurança
 
Criptografia AES online e gratuita — AES-128/192/256, GCM/CBC/CTR, frase-senha (PBKDF2) ou chave bruta. Roda 100% no navegador; nada é enviado a um servidor.
 
 
   
  
 
  
  
  
 
 
Gerador e Verificador de Hash Bcrypt
 
 
Ferramentas de Segurança
 
Gere e verifique hashes bcrypt de senha online — custo ajustável, prefixos $2b$/$2a$/$2y$. 100% no seu navegador; sua senha nunca é enviada.
 
 
   
  
 
  
  
  
 
 
Calculadora de soma de verificação CRC
 
 
Ferramentas de Segurança
 
Cole hex ou texto e veja de uma vez as 63 variantes de CRC-8, CRC-16 e CRC-32. Checksum que não bate? Digite o valor e a ferramenta diz qual é a variante — MODBUS, CCITT-FALSE, XMODEM, KERMIT. Tudo roda no seu navegador.
 
 
   
  
 
  
  
  
 
 
Gerador de HMAC e Verificador de Assinatura
 
 
Ferramentas de Segurança
 
Gerador e verificador de HMAC online e gratuito. Calcule HMAC-SHA256/SHA1/SHA384/SHA512 com chaves em Texto, Hex ou Base64 e saída Hex/Base64/Base64URL. 100% no seu navegador — as chaves nunca saem da página.
 
 
   
  
 
  
  
  
 
 
Decodificador JWT
 
 
Ferramentas de Segurança
 
Decodifique tokens JWT online com nosso decodificador JWT grátis. Inspecione cabeçalho, carga útil, assinatura, expiração e reivindicações. 100% navegador — seu token nunca sai do dispositivo. Sem cadastro, sem rastreio.