Gerador de Hash MD5, SHA-1, SHA-256 e SHA-512

O que é uma função hash?

Uma função hash criptográfica é um algoritmo determinístico que recebe qualquer quantidade de dados (texto, arquivo, vídeo) e retorna uma string de tamanho fixo — chamada digest ou checksum. A mesma entrada sempre produz o mesmo hash, mas a partir do hash não é possível recuperar a entrada.

Boas funções hash têm 4 propriedades essenciais:

• Determinística: mesma entrada → mesmo hash, sempre.
• Rápida de calcular: milhões de operações por segundo.
• Pré-imagem resistente: dado um hash, é computacionalmente impossível encontrar uma entrada que o gera.
• Resistente a colisões: é impossível encontrar duas entradas diferentes que geram o mesmo hash.

MD5: histórico e onde ainda é útil

O MD5 (Message Digest 5) foi criado por Ronald Rivest em 1991 e produz hashes de 128 bits (32 caracteres hexadecimais). Por mais de uma década foi o padrão em verificação de integridade e armazenamento de senhas.

Em 2004, pesquisadores chineses publicaram a primeira colisão prática. Em 2008, foi possível forjar certificados SSL usando colisão MD5. Desde então, é considerado quebrado para qualquer aplicação que dependa de resistência a colisões — como assinaturas digitais, certificados ou armazenamento de senhas.

Mas o MD5 ainda é amplamente usado para:

• Checksums de download: verificar que um arquivo baixado não corrompeu.
• Deduplicação de arquivos: arquivos com mesmo MD5 são tratados como duplicatas.
• Indexação em bancos de dados: chave única curta pra textos longos.
• Cache busting: identificar versões de assets (CSS, JS) por hash do conteúdo.

Para todos esses casos, colisões intencionais não são uma preocupação — o ganho de performance compensa.

A família SHA: SHA-1, SHA-256, SHA-512

A família SHA (Secure Hash Algorithm) foi criada pela NSA dos EUA. As gerações:

• SHA-1 (1995, 160 bits): sucessor do MD5. Foi padrão em certificados SSL e Git por anos. Em 2017, Google demonstrou a primeira colisão prática (ataque "SHAttered"). Hoje é desencorajado.
• SHA-256 (2001, 256 bits): parte da família SHA-2. Padrão atual para certificados, assinaturas digitais, Bitcoin, integridade. Sem colisões conhecidas em 23 anos.
• SHA-384 e SHA-512 (256-bit security): versões com tamanho maior, usadas onde se quer margem extra de segurança contra ataques quânticos futuros.
• SHA-3 (2015): baseado em algoritmo diferente (Keccak), criado como alternativa caso vulnerabilidades sejam descobertas no SHA-2. Pouco usado na prática ainda.

Hash para senhas: por que NUNCA usar MD5 ou SHA puro

Hashes rápidos (MD5, SHA-1, SHA-256) foram projetados para serem rápidos. Isso é ótimo para checksums e integridade — e péssimo para senhas. Uma GPU moderna calcula 10 bilhões de SHA-256 por segundo.

Isso significa que uma senha "Senha123" hashada com SHA-256 é quebrada em milissegundos com um dicionário comum. Mesmo senhas aleatórias de 8 caracteres caem em horas.

Para senhas, use sempre algoritmos lentos projetados especificamente para essa finalidade:

• bcrypt: padrão desde 1999. Fator de custo configurável. Inclui salt automaticamente.
• scrypt: além de lento, exige muita RAM — dificulta ataque com GPU.
• Argon2 (id): vencedor do Password Hashing Competition em 2015. Recomendação atual.
• PBKDF2: ainda aceitável (FIPS-compliant), mas use 600.000+ iterações em 2026.

Verificação de integridade: o uso mais comum de hash

Quando você baixa um arquivo grande (uma ISO do Linux, um instalador, um banco de dados de backup), o site costuma publicar o hash MD5/SHA-256 esperado ao lado do link de download. Após baixar, você calcula o hash localmente e compara.

Se bater: o arquivo chegou intacto, sem corrupção e sem adulteração no caminho. Se não bater: alguém ou algo modificou o arquivo — pode ser corrupção de rede, disco com defeito, ou ataque man-in-the-middle.

Nossa ferramenta resolve isso com a aba "Hash de arquivo": arraste o arquivo baixado, copie o SHA-256, compare com o publicado pela origem. Confirmação em segundos.

HMAC: hash com chave secreta

HMAC (Hash-based Message Authentication Code) combina um hash com uma chave secreta para autenticar mensagens. É como assinar uma mensagem: quem tem a chave pode gerar o HMAC; quem tem só a mensagem e o HMAC pode verificar autenticidade, mas não pode forjar uma mensagem nova.

Usado em:

• APIs REST autenticadas: AWS, Stripe e muitos outros usam HMAC-SHA256 pra assinar requisições.
• JWT (JSON Web Tokens): com algoritmo HS256 que é HMAC-SHA256.
• Webhooks: verificar que a chamada veio realmente da origem esperada.
• Cookies de sessão: evitar adulteração.

Hash em SEO e desenvolvimento web

Hashes também aparecem no dia a dia de quem faz web:

• Cache busting: style.a8f5b2.css — o hash no nome força o browser a baixar a versão nova.
• ETags HTTP: o servidor envia um hash do recurso pra browser checar se cache local ainda é válido.
• Subresource Integrity (SRI): integrity="sha384-..." em CDN garante que o JS/CSS não foi alterado.
• Gravatar: avatares são identificados por MD5 do e-mail do usuário.
• Git: commits são identificados por SHA-1 do conteúdo.
• Content Hashing em SEO: identificar conteúdo duplicado entre páginas.

Hash hexadecimal vs base64

Hashes são bytes brutos. Para exibir, é preciso codificar. As duas formas comuns:

• Hexadecimal: cada byte vira 2 caracteres (0–9, a–f). MD5 → 32 chars, SHA-256 → 64 chars. Mais legível, fácil de copiar, padrão na maioria das ferramentas.
• Base64: cada 3 bytes viram 4 caracteres (a–z, A–Z, 0–9, +, /). Mais compacto. MD5 em base64 tem 24 chars; SHA-256 tem 44 chars. Usado em SRI e tokens.

Nossa ferramenta exibe em hexadecimal (lowercase por padrão, opção pra uppercase).

Por que usar a Web Crypto API?

A Web Crypto API é uma especificação W3C disponível em todos os navegadores modernos. Para SHA, ela chama implementações nativas otimizadas do navegador (escritas em C++), centenas de vezes mais rápidas que implementações puras em JavaScript. Para arquivos de 100 MB, a diferença é entre ~1 segundo (Web Crypto) e ~30 segundos (JS puro).

O MD5 não é oferecido pela Web Crypto API (foi excluído por questão de segurança), então usamos uma implementação JavaScript local. Para arquivos muito grandes, isso pode demorar mais — considere usar SHA-256 sempre que possível.