Argon2 Online - hashing de senhas

Gere ou verifique hashes Argon2id de senhas no navegador. Argon2 venceu a Password Hashing Competition de 2015, é padronizado pela RFC 9106 e recomendado pela OWASP para novos sistemas de armazenamento de senhas. Configure memória, iterações, paralelismo, tamanho da saída, salt e variante.

Salt (vazio — aleatório)
Senha
0 caract. · 0 bytes
Hash para verificar
Testar:
Resultado
✓ Processamento local no navegador ✓ A entrada não é enviada ao servidor
Exemplos
Senha comum
Variante: argon2id Memória (KiB): 19456 Iterações: 2 Paralelismo: 1 Comprimento da chave (bytes): 32
Entrada senha123

Uma senha típica. Clique em Compute para gerar um hash Argon2id com configurações básicas recomendadas.

Frase-senha
Variante: argon2id Memória (KiB): 19456 Iterações: 2 Paralelismo: 1 Comprimento da chave (bytes): 32
Entrada quatro palavras faceis de lembrar

Uma frase-senha longa costuma ser fácil de memorizar e oferece mais entropia que uma senha curta.

Perfil de alta memória
Variante: argon2id Memória (KiB): 47104 Iterações: 1 Paralelismo: 1 Comprimento da chave (bytes): 32
Entrada admin-login-verao-2026

Argon2id com 47 MiB de memória e uma iteração, útil para comparar um perfil de alta memória com o padrão.

Vetor de teste com salt fixo
Variante: argon2id Memória (KiB): 9216 Iterações: 4 Paralelismo: 1 Comprimento da chave (bytes): 32 Salt (vazio — aleatório): example-fixed-salt
Entrada senha demo

Usa um salt fixo de exemplo e o perfil 9 MiB / 4 iterações para facilitar a comparação entre execuções. Em produção, use salts aleatórios únicos.

O que é Argon2?

Argon2 é uma função de hashing de senhas e derivação de chaves criada por Alex Biryukov, Daniel Dinu e Dmitry Khovratovich. Ela venceu a Password Hashing Competition em 2015, foi padronizada na RFC 9106 e é recomendada pela OWASP para armazenamento moderno de senhas.

A família Argon2 tem três variantes: Argon2d usa acesso à memória dependente dos dados e é rápida, mas normalmente não é a melhor opção para senhas web; Argon2i usa acesso independente dos dados e resiste melhor a canais laterais; Argon2id combina as duas abordagens e é o padrão recomendado para logins, SaaS, painéis administrativos e outras aplicações com senhas de usuários.

Memory-hardness e parâmetros ajustáveis

O diferencial do Argon2 é a memory-hardness: cada tentativa de senha exige uma quantidade configurável de RAM, não apenas trabalho de CPU. Isso importa em ataques offline após vazamento de banco de dados, porque GPUs e ASICs não conseguem rodar milhões de tentativas paralelas de forma barata se cada tentativa precisa reservar memória.

Esta ferramenta Argon2 online expõe os parâmetros usados por desenvolvedores: memory em KiB, iterations como custo de tempo, parallelism como lanes, key length para o tamanho da saída, salt opcional e a variante Argon2. Os padrões usam Argon2id com 19.456 KiB de memória, 2 iterações, 1 lane e saída de 32 bytes.

Se a verificação no servidor de produção estiver rápida demais, aumente memória ou iterações; se estiver lenta demais, escolha um perfil aceito com menor latência e documente a troca. Meça em hardware equivalente ao de produção, não apenas em uma máquina de desenvolvimento.

Saída PHC, salts e verificação

Hashes Argon2 normalmente são armazenados como uma string PHC, por exemplo $argon2id$v=19$m=19456,t=2,p=1$.... Ela contém variante, versão, custo de memória, iterações, paralelismo, salt e hash derivado, então o verificador não precisa de colunas separadas para os parâmetros.

Use Generate para criar um novo hash Argon2 de senha para testes, documentação ou comparação de parâmetros. Use Verify quando você já tem uma string Argon2 armazenada e quer conferir se uma senha candidata combina. Para contas reais, gere um salt aleatório único por senha e armazene a saída codificada completa produzida pela biblioteca do servidor.

Usos comuns do Argon2

Use este gerador Argon2 online quando precisar rapidamente de um hash Argon2id para documentação, fixtures de teste, notas de migração ou comparação de parâmetros. Ele também funciona como verificador Argon2: cole uma senha candidata e um hash existente para confirmar se combinam.

Buscas comuns incluem Argon2id generator, Argon2 password hash generator, verify Argon2 hash, PHC encoded Argon2 e comparações de Argon2 vs bcrypt ou PBKDF2. A regra prática é a mesma: use Argon2id com salt único, armazene a string codificada completa e escolha custos de memória e tempo sustentáveis para o fluxo de login em produção.

FAQ

Use Argon2id na maioria dos casos. Ele combina acesso à memória dependente e independente dos dados, com a velocidade prática do Argon2d e melhor resistência a canais laterais como Argon2i. RFC 9106 e OWASP recomendam Argon2id como padrão. Argon2i faz sentido quando canais laterais são a principal preocupação; Argon2d apenas quando esses ataques não são relevantes.

A OWASP lista combinações aceitáveis como 19 MiB / 2 / 1, 47 MiB / 1 / 1 ou 9 MiB / 4 / 1. Escolha a que leva cerca de 100-500 ms no seu servidor. Se a memória é limitada, aumente iterações; se a CPU é limitada, aumente memória. Parallelism raramente precisa ser maior que 1 fora de cenários multi-core específicos.

Argon2 é memory-hard: um atacante com GPU ou ASIC não consegue reduzir muito o custo apenas paralelizando, porque cada tentativa ainda exige a memória configurada. bcrypt tem apenas 4 KiB de estado interno, e PBKDF2 praticamente não tem custo de memória. Com 19 MiB por tentativa, uma GPU de 24 GiB executa cerca de 1200 tentativas paralelas, não milhões como em PBKDF2.

Não. Argon2 é calculado inteiramente no navegador usando hash-wasm e WebAssembly. A senha não sai do seu dispositivo: não há processamento nem log no servidor. Para contas reais em produção, use uma biblioteca no lado do servidor.

Use para aprender, testar parâmetros, criar exemplos e verificar hashes existentes. Para contas reais, faça o hashing no servidor da aplicação com uma biblioteca mantida, aleatoriedade segura, limitação de taxa, monitoramento e um plano para atualizar parâmetros.

Sim. Uma string Argon2 codificada em PHC contém variante, versão, custo de memória, iterações, paralelismo, salt e hash em um único valor. Armazene a string completa exatamente como gerada, por exemplo um valor começando com $argon2id$v=19$..., para que a verificação use os mesmos parâmetros.

Não. O salt deve ser único e aleatório, mas não é segredo. Ele faz senhas iguais gerarem hashes diferentes e impede o uso eficaz de tabelas pré-computadas. Guarde o salt junto com o hash Argon2, normalmente dentro da string PHC.

Recalcule quando os parâmetros armazenados forem mais fracos que a política atual, quando migrar de Argon2i ou Argon2d para Argon2id, ou quando melhorias de hardware tornarem o custo antigo barato demais. Um padrão comum é verificar o hash antigo no login e salvar depois um novo hash com parâmetros atuais.
Ferramentas relacionadas

Gerador HMAC

Gere um HMAC com texto e uma chave secreta diretamente no navegador.