PBKDF2 Gerador de Hash
Ferramenta gratuita de PBKDF2 Gerador de Hash online. Processamento 100% local — seus dados nunca saem do seu dispositivo.
O resultado será exibido aqui...
Entrada → Calcular Hash
Usage Guide
Sobre o PBKDF2
O PBKDF2 (Função de Derivação de Chave Baseada em Senha 2) é uma função de derivação de chave padronizada no RFC 8018 (PKCS#5) e no NIST SP 800-132. Diferente de uma simples função de hash, o PBKDF2 foi especialmente projetado para derivar uma chave criptográfica de uma senha, aplicando uma função pseudo-aleatória (HMAC-SHA256 ou HMAC-SHA512) centenas de milhares de vezes. Isso torna os ataques de força bruta computacionalmente caros. O PBKDF2 é compatível com FIPS 140-2 e amplamente utilizado em criptografia de disco LUKS, Wi-Fi WPA2/WPA3, armazenamento seguro iOS/Android e gerenciadores de senhas.
Passos de uso
Esta ferramenta suporta duas operações: derivar uma chave (modo Criptografar) e verificar uma senha (modo Descriptografar):
Guia de parâmetros
O PBKDF2 tem quatro parâmetros principais que controlam a segurança e a saída da chave derivada:
PBKDF2 vs. Argon2 / bcrypt
Entendendo quando escolher PBKDF2 em vez de outros algoritmos de hash de senhas:
FAQ
Q: Qual é o formato de saída do PBKDF2?
A: Esta ferramenta gera uma string de hash autocontida: {iterações}:{algoritmo}:{sal_base64}:{chave_derivada_hex}.
Por exemplo: 600000:sha256:abc123...==:d4e5f6....
Componentes:iterações: Número de rounds HMAC utilizados (ex.: 600000).algoritmo: Função de hash (sha256 ou sha512).sal_base64: Sal aleatório codificado em Base64.chave_derivada_hex: Chave derivada codificada em hexadecimal.
Para verificar, insira no modo Descriptografar: senha|{string de hash completa}.
Q: Por que o PBKDF2 precisa de 600.000 iterações?
A: O PBKDF2 não é resistente à memória — pode ser paralelizado em GPUs de forma barata. Uma GPU moderna pode calcular aproximadamente 1–2 bilhões de iterações PBKDF2-SHA256 por segundo. Com 600.000 iterações por hash, isso ainda permite ~1.600 tentativas de hash por segundo por GPU. O alto número de iterações é o mecanismo de defesa principal — multiplica diretamente o custo do atacante. O OWASP 2023 define 600.000 como mínimo para SHA-256; use 210.000 para SHA-512. Aumente esses valores com o tempo.
Q: Como o PBKDF2 difere do bcrypt ou Argon2?
A: PBKDF2: Apenas resistente a cálculo, não à memória. Paralelizável com GPU. Aprovado pelo FIPS 140-2. Requer iterações muito altas. Ideal para ambientes regulados pelo FIPS. bcrypt: Resistente a cálculo, ~4KB de memória, resistência GPU moderada. Limite de 72 bytes para senha. Não pode derivar chaves de comprimento arbitrário. Argon2id: Resistente à memória, resistente a GPU/ASIC, preferência moderna do OWASP. Não aprovado pelo FIPS. Desempenho em segurança equivalente: O Argon2 é significativamente mais rápido que o PBKDF2 no mesmo nível de segurança efetiva graças à resistência à memória.
Q: O PBKDF2 é compatível com FIPS 140-2?
A: Sim. O PBKDF2 é explicitamente definido no NIST SP 800-132 e aprovado sob o FIPS 140-2. Isso o torna a escolha obrigatória para agências federais dos EUA, contratantes, sistemas de saúde sujeitos ao HIPAA e aplicações financeiras com requisitos PCI-DSS. Argon2 e scrypt não são aprovados pelo FIPS. Se a conformidade FIPS for necessária, o PBKDF2 é atualmente a única opção amplamente disponível. Verifique se sua implementação PBKDF2 usa um módulo criptográfico validado pelo FIPS.
Q: Por que o sal é importante e precisa ser armazenado?
A: O sal é um valor aleatório adicionado à senha antes do hash para garantir que duas senhas idênticas produzam chaves derivadas diferentes. Sem sal, os atacantes podem usar tabelas rainbow pré-calculadas para quebrar vários hashes simultaneamente. O sal não precisa ser secreto — apenas precisa ser único por senha. O sal está incluído na string de saída e deve ser armazenado com a chave derivada para reproduzir o mesmo hash durante a verificação. Nunca reutilize sais entre senhas.
Q: Como usar PBKDF2 para derivação de chave AES?
A: Defina o comprimento da chave para 32 bytes (256 bits) para derivar diretamente uma chave AES-256. Use 600.000 iterações com SHA-256. Armazene o sal com seus dados criptografados. Durante a descriptografia, derive novamente a chave com a mesma senha, sal, iterações e algoritmo, depois use-a para descriptografar com AES-256-GCM. É exatamente assim que funcionam a criptografia de disco LUKS, a proteção de dados do iOS e muitos gerenciadores de senhas. A chave derivada é determinística — as mesmas entradas sempre produzem a mesma chave.
Use Cases
Recomendado: Armazenamento de senhas com conformidade FIPS
Organizações sujeitas ao FIPS 140-2, NIST SP 800-131A, HIPAA ou PCI-DSS devem usar algoritmos criptográficos aprovados. O PBKDF2 com HMAC-SHA256 ou HMAC-SHA512 é a única KDF de senhas amplamente disponível que atende a esses requisitos. Use pelo menos 600.000 iterações para SHA-256 e armazene a string de saída completa. Esta é a principal razão para escolher PBKDF2 em vez de Argon2id em ambientes regulados.
- ✅ PBKDF2-HMAC-SHA256 (≥600.000 iterações) — compatível com FIPS
- ✅ PBKDF2-HMAC-SHA512 (≥210.000 iterações) — compatível com FIPS
- ❌ Argon2 / scrypt — não aprovados pelo FIPS 140-2
- ❌ bcrypt — não aprovado pelo FIPS 140-2
Recomendado: Derivação de chave para criptografia de disco (LUKS)
O LUKS (Linux Unified Key Setup) usa PBKDF2 por padrão (LUKS1) e PBKDF2/Argon2 (LUKS2) para derivar a chave de criptografia do volume de uma frase de acesso. O PBKDF2 deriva uma chave de comprimento fixo (32 bytes para AES-256) da senha do usuário, que é então usada para criptografar a chave mestra armazenada no cabeçalho LUKS. A segurança Wi-Fi WPA2/WPA3 também usa PBKDF2 para derivar a Chave Mestra de Par (PMK) da senha Wi-Fi.
- ✅ PBKDF2-HMAC-SHA512 (padrão LUKS1)
- ✅ Argon2id (preferido LUKS2 — melhor resistência à memória)
- 💡 Configure iterações suficientemente altas para que a derivação leve 0,5–2 segundos no hardware alvo
- 💡 Armazene o sal nos metadados do disco/cabeçalho, nunca separadamente
Aceitável: Verificação de senhas em sistemas legados
Muitos sistemas existentes (versões antigas do Django, .NET Membership, Java PBKDF2WithHmacSHA1) já armazenam hashes PBKDF2. Continue usando PBKDF2 para esses sistemas e aumente gradualmente a contagem de iterações conforme o hardware melhora. Use a contagem de iterações armazenada para verificação (incorporada na string de hash) e atualize para as recomendações atuais do OWASP para novos registros e alterações de senha. Isso evita redefinições forçadas de senha enquanto melhora a segurança ao longo do tempo.
- ✅ PBKDF2 (manter para hashes existentes — sem necessidade de migração)
- ✅ Aumentar iterações para novos hashes ao mínimo atual do OWASP
- 💡 Atualizar transparentemente a contagem de iterações no próximo login
- 💡 Considerar migrar para Argon2id em novos projetos sem requisito FIPS
Aceitável: Derivar várias chaves de uma senha
O PBKDF2 pode derivar chaves de comprimento arbitrário, tornando-o útil quando várias chaves são necessárias de uma senha mestra (ex.: uma para criptografia, outra para autenticação MAC). Use sais diferentes ou sufixos de índice para derivar chaves independentes. Defina o comprimento da chave para 64 bytes e divida a saída em duas chaves de 32 bytes, ou execute PBKDF2 duas vezes com sais diferentes. Esse padrão é usado em algumas arquiteturas de gerenciadores de senhas.
- ✅ Usar sais diferentes por propósito de chave derivada
- ✅ Usar HKDF para expansão de chave após a derivação PBKDF2 inicial
- ❌ Nunca reutilizar o mesmo sal para diferentes propósitos de chave
- 💡 Combinar com AES-256-GCM para criptografia autenticada
Não recomendado: Substituir Argon2 em novos projetos
Se você está iniciando um novo projeto sem requisitos FIPS, o PBKDF2 é a escolha mais fraca em comparação com Argon2id. O PBKDF2 não é resistente à memória, o que significa que GPUs podem paralelizar ataques de forma barata. Mesmo com 600.000 iterações, uma GPU de alta performance pode tentar milhares de adivinhações PBKDF2 por segundo. O Argon2id com parâmetros padrão (47MB de memória, 1 iteração) atinge tempo de execução comparável enquanto o requisito de memória previne completamente a paralelização com GPU.
- ❌ Evitar PBKDF2 para novos projetos quando Argon2id estiver disponível
- ✅ Argon2id (resistente à memória, preferência OWASP)
- ✅ scrypt (resistente à memória, amplamente disponível)
- 💡 PBKDF2 só é preferido quando a conformidade FIPS é obrigatória
Não recomendado: Hash de dados geral
O PBKDF2 é uma função de derivação de chave, não uma função de hash de propósito geral. É intencionalmente lento e nunca deve ser usado para fazer hash de conteúdo de arquivos, somas de verificação, autenticação de mensagens ou deduplicação. Para integridade de dados, use SHA-256 ou SHA-512. Para autenticação de mensagens, use HMAC-SHA256. Usar a saída PBKDF2 como hash geral desperdiçaria ciclos de CPU significativos sem nenhum benefício de segurança.
- ❌ Não usar PBKDF2 para somas de verificação de arquivo ou integridade de dados
- ❌ Não usar PBKDF2 para autenticação de mensagens (usar HMAC-SHA256)
- ✅ SHA-256 / SHA-512 para hash de dados geral
- ✅ HMAC-SHA256 para integridade de mensagens autenticada
Resumo das melhores práticas
- Use PBKDF2-HMAC-SHA256 (≥600.000 iterações) ou HMAC-SHA512 (≥210.000) para ambientes com conformidade FIPS. Armazene a string de hash completa incluindo iterações, algoritmo e sal.
- Para novos projetos sem requisitos FIPS, prefira Argon2id — é resistente à memória e significativamente mais resistente a ataques GPU com desempenho comparável.
- Sempre use um sal aleatório único por senha (gerado automaticamente por esta ferramenta). Nunca reutilize sais nem os codifique no código da aplicação.
- Aumente as contagens de iterações com o tempo conforme o hardware melhora. A contagem de iterações é armazenada na string de hash, portanto, valores antigos e novos podem coexistir.
- Use PBKDF2 apenas no login ou configuração de chave — nunca em cada requisição. Emita tokens (JWT, sessão) após a autenticação para operações de alta frequência.