Hashing Criptográfico Explicado: MD5, SHA-1, SHA-256, SHA-512

Um hash criptográfico é uma função que transforma entrada arbitrária em uma impressão digital de tamanho fixo. A palavra “criptográfico” faz trabalho real nessa frase: nem toda função hash se qualifica, e usar uma não criptográfica (ou a errada) é como sistemas se tornam inseguros silenciosamente.

O que é um hash criptográfico

Formalmente, uma função hash H recebe uma string de bytes arbitrária e retorna uma saída de comprimento fixo chamada digest. SHA-256 retorna 256 bits, SHA-512 retorna 512, MD5 retorna 128. A mesma entrada sempre produz a mesma saída; a mesma saída não revela nada sobre a entrada.

Qualquer pessoa pode verificar um hash; somente uma cópia da entrada original pode produzir um. Essa assimetria é o que torna os hashes úteis para verificações de integridade, deduplicação, endereçamento de conteúdo, assinaturas digitais e (com ressalvas que abordaremos) armazenamento de senhas.

As três propriedades que importam

Uma função é considerada criptograficamente segura quando fornece as três na prática:

1. Resistência ao preimage

Dado um digest d, deve ser computacionalmente inviável encontrar qualquer entrada mtal que H(m) = d. Isso é o que torna os hashes uma função unidirecional — você não pode reverter o digest de volta à mensagem. Para um hash de 256 bits, o custo de força bruta é aproximadamente 2^256 operações, o que é astronômico.

2. Resistência ao segundo preimage

Dada uma entrada específica m1, deve ser inviável encontrar uma entrada diferente m2 tal que H(m1) = H(m2). Esta é a propriedade que protege a integridade: um atacante que pode substituir seu arquivo mas não pode alterar seu hash publicado precisa forjar um segundo preimage de sua entrada exata, o que é muito mais difícil do que uma colisão genérica.

3. Resistência à colisão

Deve ser inviável encontrar quaisquer duas entradas distintas m1 != m2 com H(m1) = H(m2). Pelo paradoxo do aniversário, encontrar uma colisão genérica em um hash de N bits custa cerca de 2^(N/2)operações, não 2^N. É por isso que a saída de 160 bits do SHA-1 não é mais suficiente — 2^80está bem ao alcance de um adversário determinado em 2026.

O efeito avalanche

Uma propriedade não formal mas prática: uma mudança de um bit na entrada deve produzir um digest radicalmente diferente, com cerca de metade dos bits de saída invertidos. É isso que torna os hashes úteis para diff — você não pode dizer se duas entradas eram “quase iguais” a partir de seus digests, o que é exatamente o ponto.

Os obsoletos — e por quê

MD5 (1992)

Saída de 128 bits. Colisões foram publicadas pela primeira vez em 2004 por Xiaoyun Wang; em 2008, pesquisadores usaram colisões MD5 para forjar uma Autoridade Certificadora desonesta. Hoje você pode encontrar uma colisão MD5 em um laptop em minutos. O MD5 está morto para qualquer propósito de segurança — assinaturas, certificados, deduplicação onde entrada adversarial é possível, qualquer coisa que precise de resistência à colisão.

O MD5 ainda é aceitável como checksum não criptográfico para corrupção acidental — um download de ISO de CD-ROM, uma chave de cache interna — mas nunca o rotule como “seguro” em uma especificação.

SHA-1 (1995)

Saída de 160 bits. O ataque SHAttered de 2017 do Google e CWI produziu dois PDFs distintos com o mesmo hash SHA-1 a um custo de cerca de 2^63operações — caro mas viável. O NIST formalmente descontinuou SHA-1 para assinaturas digitais em 2011 e proibiu seu uso federal em 2030. Todos os principais navegadores pararam de confiar em certificados TLS SHA-1 até 2017.

O git é o holdout proeminente, com mitigações (detecção de SHAttered) compensando a fraqueza subjacente. Novos protocolos não devem usar SHA-1.

A família SHA-2

SHA-2 é uma família de hashes projetada pela NSA e publicada pelo NIST em 2001: SHA-224, SHA-256, SHA-384, SHA-512, mais as variantes truncadas SHA-512/224 e SHA-512/256. O número é o comprimento de saída em bits.

Apesar de compartilhar um nome, SHA-2 não tem relação estrutural com SHA-1; os ataques que quebraram SHA-1 não se propagam. Após vinte e cinco anos de criptoanálise, SHA-256 permanece sem quebras — os melhores ataques conhecidos afetam apenas versões de brinquedo com rodadas reduzidas.

• SHA-256 é o padrão prático em 2026. Digests de 256 bits, segurança de colisão de 128 bits, aceleração de hardware em cada CPU moderna.
• SHA-512 é mais rápido em máquinas de 64 bits e produz um digest mais longo. Use quando quiser uma margem maior do que 128 bits de segurança de colisão.
• SHA-224 e SHA-384 são SHA-256 e SHA-512 com a saída truncada. Existem para compatibilidade legada (correspondência de comprimento de chave com curvas elípticas); novos projetos devem usar as formas não truncadas.

Você pode verificar qualquer um desses em segundos em nosso gerador de hash no navegador — ele funciona localmente com a API Web Crypto, então nada sai do dispositivo.

SHA-3 e quando ele importa

O NIST realizou uma competição aberta de 2007 a 2012 para selecionar um backup estrutural para SHA-2. O vencedor foi o Keccak, padronizado como SHA-3 em 2015. SHA-3 usa uma construção fundamentalmente diferente (a função esponja), então uma quebra hipotética da estrutura Merkle-Damgård do SHA-2 não quebraria SHA-3.

SHA-3 é geralmente mais lento que SHA-2 em software, mas comparável ou mais rápido em hardware. É a escolha certa quando você quer especificamente diversidade algorítmica (por exemplo, assinar os mesmos dados com SHA-2 e SHA-3 para defesa em profundidade), ou quando está em uma plataforma com hardware SHA-3 dedicado. Para todo o resto, SHA-256 permanece o padrão prático.

Por que você não faz hash de senhas com SHA-256

Este é o erro mais comum em todo o assunto. SHA-256 é rápido — uma GPU moderna pode calcular bilhões por segundo. Para um atacante que roubou seu banco de dados de senhas, essa velocidade é exatamente a propriedade errada: cada tentativa que ele quer verificar custa nanossegundos.

Funções de hash de senhas são projetadas para serem deliberadamente lentas e intensivas em memória, para que escalar um ataque com hardware personalizado (ASICs, FPGAs) fique caro em vez de gratuito. Os três nomes que valem conhecer em 2026:

• bcrypt (1999). Fator de trabalho ajustável (parâmetro de custo). Ainda seguro; o limite é seu teto de entrada de 72 bytes. Escolha padrão ao integrar com bibliotecas existentes.
• scrypt (2009). Intensivo em memória, mais difícil de acelerar com ASICs do que bcrypt. Usado pelo Litecoin e alguns bancos de dados de senhas.
• Argon2(vencedor do PHC de 2015). A recomendação atual. Argon2id é a variante a usar — é resistente tanto a ataques de canal lateral quanto a ataques de GPU. Especificado em RFC 9106.

Os três aceitam um sal (um valor aleatório por usuário anexado à senha antes do hash). O sal elimina ataques de rainbow table e garante que dois usuários com a mesma senha obtenham hashes armazenados diferentes. Bibliotecas modernas gerenciam a geração de sal para você; não a pule.

HMAC: hashing com uma chave

Um hash responde “estes dados estão inalterados?”. Um HMAC responde “estes dados estão inalterados ealguém que conhece o segredo compartilhado produziu este MAC?”.

HMAC é construído sobre qualquer hash criptográfico — HMAC-SHA-256 é o comum — via uma construção específica definida na RFC 2104. A alternativa ingênua, H(chave || mensagem), é vulnerável a ataques de extensão de comprimento em hashes Merkle-Damgård (que inclui SHA-256). A construção aninhada do HMAC evita isso. Use sempre HMAC, não a forma ingênua.

HMAC é o elemento central da assinatura de API (AWS SigV4, assinaturas de webhook, HS256 do JWT), autenticação da camada de registro TLS e qualquer protocolo que precise de garantia de “isto veio de alguém com a chave”. O mesmo primitivo aparece no ecossistema de autenticação mais amplo — cookies de sessão, tokens de portador OAuth e tokens de duplo envio CSRF todos dependem de HMAC ou de um hash para vincular um valor a um segredo que o servidor detém.

Casos de uso reais

Verificação de integridade

Publique o SHA-256 de um download junto com o arquivo. Qualquer pessoa pode fazer hash de sua cópia e comparar. É assim que toda distribuição Linux distribui ISOs e como gerenciadores de pacotes verificam dependências. O hash em si deve ser entregue por um canal confiável (HTTPS para o site do projeto, assinado pela chave de assinatura do projeto) — um atacante que pode modificar o arquivo geralmente também pode modificar o hash se estiver no mesmo canal.

Endereçamento de conteúdo

Git, IPFS, camadas Docker e muitos outros sistemas endereçam objetos por seu hash. O hash é o nome. Isso fornece deduplicação gratuita (conteúdo idêntico tem hashes idênticos) e integridade gratuita (se o hash corresponder, os bytes correspondem).

Assinaturas digitais

Assinar um arquivo de múltiplos megabytes diretamente com uma chave RSA ou ECDSA seria lento. O padrão é fazer hash do arquivo e assinar o hash. A segurança da assinatura herda a resistência à colisão do hash — razão pela qual assinaturas SHA-1 não são mais confiadas pelos navegadores.

Prova de trabalho em blockchain

A prova de trabalho do Bitcoin pede que mineradores encontrem uma entrada cujo SHA-256 (duas vezes, na verdade) comece com um certo número de bits zero. Não há atalho, então a única forma de encontrar tal entrada é tentar muitos candidatos — que é o “trabalho” na prova de trabalho. O Ethereum mudou para prova de participação em 2022, mas o primitivo baseado em hash ainda é onipresente em criptomoedas.

Deduplicação

Dropbox, Backblaze e todo objeto de armazenamento moderno deduplicam no nível de bloco fazendo hash de cada bloco e mantendo uma cópia por hash único. SHA-256 é exagerado para dedup não adversarial; muitos sistemas usam um hash não criptográfico mais rápido (BLAKE3, xxHash) e aceitam a probabilidade astronomicamente pequena de colisão.

Referência rápida

A conclusão honesta

Para hash de uso geral em 2026, use SHA-256. Para senhas, use Argon2id. Para tokens de autenticação, use HMAC-SHA-256 (ou uma biblioteca JWT adequada que use um por baixo). Para integridade de downloads, publique digests SHA-256 via HTTPS.

As respostas erradas — MD5 em qualquer lugar que a segurança importa, SHA-1 para novas assinaturas, SHA-256 para senhas — são os erros mais comuns nos relatórios de violação. Escolher certo é principalmente sobre saber qual pergunta cada algoritmo foi projetado para responder.