MD5 vs SHA-256: Diferenças, segurança e quando usar cada um

As funções de hash estão entre os blocos de construção mais utilizados no software. Verificam downloads, deduplicam arquivos, assinam solicitações de API, alimentam Git e blockchains e protegem senhas armazenadas. MD5 e SHA-256 são os dois nomes que os desenvolvedores encontram com mais frequência, e a pergunta "eu ainda posso usar MD5?" surge constantemente. A resposta curta: para qualquer coisa que envolva segurança, não; para detectar corrupção acidental, ainda funciona. A resposta mais longa explica o porquê e o que usar em vez disso.

O que uma função hash criptográfica faz

Uma função hash toma entrada de qualquer comprimento e produz uma saída de comprimento fixo chamada digest. O MD5 produz 128 bits (32 caracteres hexadecimais); o SHA-256 produz 256 bits (64 caracteres hexadecimais).

MD5("hello world")     = 5eb63bbbe01eeed093cb22bb8f5acdc3
SHA-256("hello world") = b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Um bom hash criptográfico tem três propriedades de segurança:

1. ** Resistência à pré-imagem:** dada uma digestão, é impossível encontrar qualquer entrada que a produza.
2. Resistência à segunda pré-imagem: dada uma entrada, é impossível encontrar uma entrada diferente com o mesmo digest.
3. Resistência a colisões: é impossível encontrar duas entradas diferentes com o mesmo digest.

Também deve mostrar o efeito de avalanche: alterar um único bit de entrada muda cerca de metade dos bits de saída, de modo que entradas semelhantes têm digestões completamente não relacionadas. Tente em um gerador de hash: "olá mundo" e "olá mundo!" produzem digestões sem nada em comum.

Uma breve história do MD5

Ron Rivest desenvolveu o MD5 em 1991. Era rápido e tornou-se onipresente: somas de verificação de ficheiros, armazenamento de senhas, certificados digitais. As fraquezas apareceram em poucos anos, e em 2004 os pesquisadores demonstraram colisões práticas. Em 2008, uma equipe criou um certificado de autoridade de certificado desonesto explorando colisões MD5, e em 2012, o malware Flame usou uma colisão MD5 para falsificar certificados de assinatura de código da Microsoft. Hoje, gerar uma colisão MD5 leva segundos num portátil.

Ataques de pré-imagem no MD5 permanecem teóricos, mas a resistência à colisão está completamente quebrada, e isso é suficiente para descartá-lo para assinaturas, certificados e verificações de integridade onde um atacante pode estar envolvido.

SHA-1: também aposentado

O SHA-1, com saída de 160 bits, seguiu um caminho semelhante. As fraquezas teóricas foram publicadas em 2005, e em 2017 o Google e o CWI Amsterdam produziram a primeira colisão real ("SHAttered"): dois arquivos PDF diferentes com o mesmo hash SHA-1. Os navegadores pararam de aceitar certificados SHA-1, e o Git está migrando para o SHA-256. Trate o SHA-1 como o MD5.

SHA-256 e a família SHA-2

SHA-2, publicado pelo NIST em 2001, inclui SHA-224, SHA-256, SHA-384 e SHA-512. O SHA-256 é o mais amplamente implantado: certificados TLS, assinatura de código, Bitcoin, gerenciadores de pacotes, integridade de subrecursos, assinaturas JWT (HS256 e RS256) e muito mais. Após mais de duas décadas de análise, não existem ataques práticos contra a sua colisão ou resistência de pré-imagem.

SHA-512 usa operações de 64 bits e é muitas vezes mais rápido que o SHA-256 em CPUs de 64 bits sem aceleração de hardware. SHA-384 é um SHA-512 truncado que também resiste a ataques de extensão de comprimento.

SHA-3

O SHA-3 (Keccak), padronizado em 2015, usa um design interno completamente diferente uma construção de esponja para que um avanço contra o SHA-2 não o afete automaticamente. Não é um substituto para o SHA-2 tanto quanto um backup com propriedades diferentes. Use-o quando uma especificação o exigir; caso contrário, o SHA-256 permanece o padrão pragmático.

Comparação lado a lado

Algoritmo	Tamanho de saída	Resistência à colisão	Situação
MD5	128 bits	Rompido (segundos)	Não é por segurança.
SHA-1	160 bits	Quebrado (2017)	Não é por segurança.
SHA-256	256 bits	Segurança	Recomendação por defeito
SHA-512	512 bits	Segurança	Recomendado
SHA3-256 / SHA3-512	256 / 512 bits	Segurança	Alternativa recomendada
BLAKE3	256 bits (extensiveis)	Segurança	Adopção muito rápida e crescente

Velocidade

O MD5 é mais rápido que o SHA-256 em software puro, mas a diferença é menos importante do que as pessoas pensam. Os processadores x86 e ARM modernos incluem instruções de hardware SHA-256, que fazem com que o SHA-256 seja executado a gigabytes por segundo. Na prática, a leitura de um arquivo a partir do disco ou da rede é geralmente o gargalo, não o hash. Se a velocidade bruta for crítica para usos não de segurança, BLAKE3 ou hashes não criptográficos como xxHash superam ambos.

Quando o MD5 ainda é aceitável

A fraqueza de colisão do MD5 só importa quando alguém pode deliberadamente criar entradas. Continua a ser aceitável para:

• ** Detecção de corrupção acidental** nas transferências ou armazenamento quando nenhum atacante está envolvido.
• Chaves de cache e deduplicação de dados de confiança, por exemplo, colocando os seus próprios ficheiros em buckets.
• ** Compatibilidade legada**, como sistemas que publicam somas de verificação MD5 ou protocolos que o exigem.

Mesmo nesses casos, escolher o SHA-256 custa pouco e elimina a necessidade de argumentar que nenhum atacante poderia estar envolvido. Muitos incidentes começaram com uma soma de verificação que era "apenas para corrupção" sendo confiada para segurança mais tarde.

Verificação de downloads corretos

Quando um projeto publica uma soma de verificação SHA-256, calcule o hash do seu download e compare cada caractere:

sha256sum ubuntu.iso          # Linux
shasum -a 256 ubuntu.iso      # macOS
Get-FileHash ubuntu.iso       # Windows PowerShell

Uma soma de verificação de correspondência prova que o ficheiro corresponde ao que o editor hashou. Não prova que o editor é legítimo: se um invasor controla o site, ele pode substituir tanto o arquivo quanto a soma de verificação. As somas de verificação assinadas (GPG ou Sigstore) preenchem essa lacuna.

HMAC: hashing com uma chave

Um hash simples prova integridade mas não autenticidade qualquer um pode calcula-lo. O HMAC combina uma chave secreta com a mensagem, para que apenas as partes com a chave possam produzir ou verificar o resultado. Webhooks de Stripe, GitHub e Slack usam assinaturas HMAC-SHA256, e JWTs assinados com HS256 são HMAC-SHA256 sob o capô.

Não construa seu próprio hash de chave concatenando secret + message e hashando-o. Com MD5, SHA-1 e SHA-256, isso é vulnerável a ataques de extensão de comprimento. Use a construção HMAC padrão, que cada linguagem fornece. Ao comparar assinaturas, use uma função de comparação de tempo constante para evitar ataques de tempo.

As senhas precisam de uma ferramenta completamente diferente.

Nem o MD5 nem o SHA-256 devem ser utilizados diretamente para armazenar senhas. Os hashes rápidos são uma desvantagem aqui: uma GPU moderna calcula bilhões de hashes SHA-256 por segundo, de modo que um atacante que rouba o seu banco de dados pode testar enormes listas de senhas prováveis rapidamente. Os hashes sem sal são piores, porque as tabelas pré-computadas decifram senhas comuns instantaneamente.

Use uma função de hash de senha projetada para ser lenta e difícil de memorizar:

• Argon2id o vencedor do Concurso de Hashing de Senha e a atual primeira escolha.
• scrypt difícil de memorizar e amplamente disponível.
• bcrypt mais antigo, mas ainda aceitável, com um limite de entrada de 72 bytes.
• PBKDF2 com uma alta contagem de iterações quando a conformidade requer primitivas aprovadas pelo NIST.

Essas funções adicionam um sal único por senha e um fator de custo configurável que você pode aumentar à medida que o hardware se torna mais rápido. As bibliotecas tratam dos pormenores: você liga para hash(password) e verify(password, stored).

Digestões de codificação

Digest são bytes brutos, geralmente exibidos como hexadecimais (dois caracteres por byte) ou Base64 (mais compacto). O mesmo SHA-256 digest é 64 caracteres hex ou 44 caracteres Base64. Os atributos de integridade de subrecursos usam Base64 (sha384-...), enquanto os arquivos de checksums usam hex. Para mais informações sobre o lado de codificação, veja [Base64 explicado] ((/blog/base64-explicado).

Guia de decisão

• ** Verificação de integridade, assinaturas, certificados, qualquer coisa relacionada à segurança:** SHA-256 (ou SHA-512, SHA-3, BLAKE3).
• Autenticação de mensagens com um segredo partilhado: HMAC-SHA256.
• ** Armazenamento de senhas:** Argon2id, scrypt ou bcrypt nunca um hash simples.
• ** Somas de verificação não adversárias ou chaves de cache:** MD5 funciona, mas SHA-256 é o hábito mais seguro.
• Hashing não de segurança de alta velocidade (tablas de hash, sharding): xxHash ou hashes não criptográficos similares.

Resumo

MD5 e SHA-1 são quebrados para resistência a colisões e não devem ser usados quando um atacante pode se beneficiar de entradas de criação. O SHA-256 é seguro, rápido com suporte de hardware e o padrão certo para integridade e assinaturas. Use o HMAC para autenticação com chave e funções lentas dedicadas, como o Argon2id para senhas. Quando em dúvida, escolha SHA-256 nunca é a resposta errada para a integridade, e MD5 cada vez mais é.