MD5 vs SHA-256: qual algoritmo hash você deve usar?
O hashing é uma operação comum na computação, mas escolher o algoritmo errado pode expor seu sistema a ataques de colisão, corrupção de dados ou sobrecarga desnecessária de desempenho. Este guia compara os quatro algoritmos hash mais utilizados e oferece um framework de decisão claro.
O que é uma função hash?
Uma função hash criptográfica recebe dados de entrada arbitrários e produz uma saída de tamanho fixo (o “digest” ou “hash”). Boas funções hash têm três propriedades:
- Determinística: A mesma entrada sempre produz a mesma saída.
- Unidirecional: Não é possível inverter o hash para recuperar a entrada original.
- Resistente a colisões: Deve ser computacionalmente inviável encontrar duas entradas diferentes que produzam o mesmo hash.
Quando a propriedade #3 falha, o algoritmo é considerado “criptograficamente quebrado”. Foi exatamente o que aconteceu com o MD5 e o SHA-1.
Comparação rápida de algoritmos
| Propriedade | MD5 | SHA-1 | SHA-256 | SHA-512 |
|---|---|---|---|---|
| Tamanho da saída | 128 bits (32 caracteres hex) | 160 bits (40 caracteres hex) | 256 bits (64 caracteres hex) | 512 bits (128 caracteres hex) |
| Tamanho do bloco | 512 bits | 512 bits | 512 bits | 1024 bits |
| Ano de introdução | 1991 | 1995 | 2001 | 2001 |
| Projetista | Ron Rivest | NSA / NIST | NSA / NIST | NSA / NIST |
| Resistência a colisões | Quebrado (2004) | Quebrado (2017) | Seguro | Seguro |
| Velocidade (relativa) | Mais rápido | Rápido | Moderado | Moderado (mais rápido em 64 bits) |
| Status NIST | Obsoleto | Obsoleto | Recomendado | Recomendado |
MD5: rápido mas quebrado
O MD5 (Message-Digest Algorithm 5) foi projetado por Ronald Rivest em 1991 e se tornou o padrão de facto para checksums durante os anos 90 e início dos anos 2000. Produz um hash de 128 bits em 32 caracteres hexadecimais.
Por que o MD5 está quebrado
Em 2004, Xiaoyun Wang demonstrou ataques de colisão práticos contra o MD5. Em 2008, pesquisadores criaram um certificado SSL fraudulento usando colisões de MD5, demonstrando que o ataque não era apenas teórico. Hoje em dia, colisões de MD5 podem ser geradas em segundos em hardware de consumo.
// Gerar um hash MD5 (apenas para uso não relacionado à segurança)
// A Web Crypto API não está disponível para MD5 — use uma biblioteca
import { md5 } from 'hash-wasm';
const hash = await md5('Hello, World!');
console.log(hash);
// → 'bea8252ff4e80f41719ea13cdf007273' (32 caracteres hex)Quando o MD5 ainda é aceitável
Apesar de estar criptograficamente quebrado, o MD5 ainda é útil para aplicações não relacionadas à segurança:
- Deduplicação de arquivos: Detectar arquivos duplicados em sistemas de armazenamento
- Chaves de cache: Gerar chaves curtas e determinísticas para consultas em cache
- Checksums de integridade de dados: Verificação rápida de que os dados não foram corrompidos acidentalmente (não deliberadamente manipulados)
- Compatibilidade com sistemas legados: Interoperar com sistemas mais antigos que exigem MD5
A distinção chave: o MD5 protege contra a corrupção acidental, mas não contra a manipulação deliberada.
SHA-1: obsoleto mas persistente
O SHA-1 (Secure Hash Algorithm 1) foi projetado pela NSA e publicado pelo NIST em 1995. Produz um hash de 160 bits em 40 caracteres hexadecimais.
Em 2017, o Google e o CWI Amsterdam demonstraram a primeira colisão SHA-1 prática (o ataque “SHAttered”), gerando dois arquivos PDF diferentes com o mesmo hash SHA-1. Os principais navegadores e autoridades certificadoras já haviam começado a rejeitar os certificados SHA-1 em 2016.
Use o SHA-1 apenas para compatibilidade com sistemas que o exigem (por exemplo, o Git usa SHA-1 para os hashes de commits, embora esteja em transição para SHA-256). Para qualquer desenvolvimento novo, escolha SHA-256 ou superior.
SHA-256: o padrão atual
O SHA-256 faz parte da família SHA-2, projetada pela NSA e publicada pelo NIST em 2001. Produz um hash de 256 bits em 64 caracteres hexadecimais e é o algoritmo recomendado para praticamente todas as necessidades de hashing em 2026.
// Gerar um hash SHA-256 usando a Web Crypto API (nativa do navegador)
async function sha256(text) {
const data = new TextEncoder().encode(text);
const hash = await crypto.subtle.digest('SHA-256', data);
return Array.from(new Uint8Array(hash))
.map(b => b.toString(16).padStart(2, '0'))
.join('');
}
const hash = await sha256('Hello, World!');
console.log(hash);
// → 'dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f'Por que o SHA-256 é a opção padrão
- Sem ataques conhecidos: Até 2026, não existem ataques práticos de colisão ou pré-imagem
- Nativo do navegador: Disponível através da Web Crypto API em todos os navegadores modernos — sem necessidade de bibliotecas
- Padrão da indústria: Usado por certificados TLS, Bitcoin, gerenciadores de pacotes (npm, pip), digests de imagens Docker e a maioria dos sistemas de verificação de integridade
- Aprovado pelo NIST: Recomendado para todas as aplicações sensíveis à segurança
SHA-512: quando você precisa de mais
O SHA-512 produz um hash de 512 bits em 128 caracteres hexadecimais. Usa um tamanho de bloco de 1024 bits (contra os 512 bits do SHA-256), o que o torna mais rápido que o SHA-256 em processadores de 64 bits porque processa mais dados por ciclo.
# Python: SHA-512 é tão fácil quanto SHA-256
import hashlib
hash_256 = hashlib.sha256(b'Hello, World!').hexdigest()
hash_512 = hashlib.sha512(b'Hello, World!').hexdigest()
print(f"SHA-256: {hash_256}") # 64 caracteres
print(f"SHA-512: {hash_512}") # 128 caracteresUse o SHA-512 quando:
- Você precisa de uma margem de segurança maior (resistência a colisões de 256 bits contra 128 bits para o SHA-256)
- Sua plataforma é de 64 bits e o desempenho importa (o SHA-512 pode ser 1,5 vezes mais rápido que o SHA-256 em x86-64)
- O protocolo ou especificação exige (alguns esquemas de certificados, requisitos específicos de conformidade)
Para a maioria das aplicações, o SHA-256 é suficiente. O comprimento adicional dos hashes SHA-512 dobra o armazenamento e a largura de banda sem um benefício de segurança prático para os casos de uso típicos.
Framework de decisão: qual hash usar
Para integridade de arquivos e checksums
Use SHA-256. É o padrão para verificar downloads, comparar conteúdos de arquivos e garantir que os dados não foram corrompidos. Se você está substituindo um sistema baseado em MD5, o SHA-256 é a atualização direta.
# Verificar a integridade de um download
sha256sum arquivo-baixado.tar.gz
# Compare a saída com o hash publicadoPara armazenamento de senhas
Não use nem MD5 nem SHA-256 diretamente. As funções hash de propósito geral são rápidas demais para o hashing de senhas — um atacante pode testar bilhões de tentativas por segundo. Em vez disso, use um algoritmo dedicado de hashing de senhas:
| Algoritmo | Status | Notas |
|---|---|---|
| Argon2id | Recomendado | Vencedor da Password Hashing Competition de 2015; resistente a memória |
| bcrypt | Bom | Amplamente suportado; salt incorporado; fator de trabalho ajustável |
| scrypt | Bom | Resistente a memória; usado por alguns sistemas de criptomoedas |
| PBKDF2 | Aceitável | Aprovado pelo NIST mas não resistente a memória; use ≥600.000 iterações |
| SHA-256 | Inadequado | Rápido demais; sem salt incorporado; vulnerável a ataques GPU |
| MD5 | Perigoso | Quebrado + rápido demais; descriptografado trivialmente |
// ERRADO: Não faça hash de senhas com SHA-256
const hash = await sha256(password); // Descriptografável a bilhões/seg
// CORRETO: Use bcrypt (exemplo em Node.js)
import bcrypt from 'bcrypt';
const hash = await bcrypt.hash(password, 12); // 12 rodadas = ~250ms
const isValid = await bcrypt.compare(input, hash);Para HMAC e autenticação de mensagens
Use SHA-256 com HMAC. HMAC (Hash-based Message Authentication Code) combina uma função hash com uma chave secreta para verificar tanto a integridade quanto a autenticidade:
// HMAC-SHA256 para verificação de assinatura de webhook
async function verifyWebhook(payload, signature, secret) {
const key = await crypto.subtle.importKey(
'raw', new TextEncoder().encode(secret),
{ name: 'HMAC', hash: 'SHA-256' }, false, ['verify']
);
const sig = Uint8Array.from(atob(signature), c => c.charCodeAt(0));
return crypto.subtle.verify('HMAC', key, sig, new TextEncoder().encode(payload));
}Para armazenamento com endereçamento por conteúdo
Use SHA-256. Git, Docker e IPFS usam armazenamento com endereçamento por conteúdo onde o hash do conteúdo é seu endereço. O SHA-256 fornece resistência a colisões suficiente para garantir a unicidade em bilhões de objetos.
Benchmarks de Desempenho
Velocidade relativa de hashing em um processador x86-64 moderno (maior = mais rápido):
| Algoritmo | Throughput (MB/s) | Velocidade relativa |
|---|---|---|
| MD5 | ~3.200 | 1,0x (base) |
| SHA-1 | ~2.400 | 0,75x |
| SHA-256 | ~1.500 | 0,47x |
| SHA-512 | ~2.100 | 0,66x |
Nota: O SHA-512 é mais rápido que o SHA-256 em processadores de 64 bits devido ao seu estado interno mais amplo. Em sistemas de 32 bits, a situação se inverte. Para a maioria das aplicações, a diferença de velocidade é irrelevante — o hash de um arquivo de 1 MB leva menos de 1 ms com qualquer um desses algoritmos.
Erros comuns a evitar
1. Usar MD5 para segurança
As colisões de MD5 são triviais de gerar. Nunca use MD5 para assinaturas digitais, validação de certificados ou qualquer cenário onde um atacante possa criar entradas maliciosas.
2. Fazer hash de senhas com SHA-256
O SHA-256 não é um hash de senhas. É rápido demais, não tem salt incorporado e é vulnerável a ataques de tabelas arco-íris e força bruta acelerada por GPU. Use Argon2id ou bcrypt. Para entender por quê, consulte nosso guia sobre entropia de senhas — ele explica a matemática por trás da resistência à força bruta.
3. Assumir que o comprimento do hash equivale à segurança
Um hash de 512 bits não é automaticamente “mais seguro” que um de 256 bits em termos de resistência a colisões. A margem de segurança do SHA-256 (resistência a colisões de 128 bits) já está muito acima da capacidade de força bruta. Escolha com base nos seus requisitos reais, não no comprimento do hash.
4. Criar suas próprias combinações de hash
Padrões como SHA256(MD5(data)) ou MD5(data + salt) não consertam magicamente um algoritmo quebrado. Use um único algoritmo bem revisado (SHA-256) ou uma construção adequada (HMAC).
Experimente você mesmo
Gere e compare hashes MD5, SHA-1, SHA-256 e SHA-512 instantaneamente com nosso Gerador de Hash — cole texto ou arraste um arquivo e veja os quatro digests lado a lado. 100% no seu navegador, os dados nunca saem do seu dispositivo.
Para uma visão mais ampla da segurança web, incluindo autenticação, validação de entradas e cabeçalhos de segurança, leia nosso guia de Segurança Web Essencial. Você também pode explorar todas as nossas ferramentas essenciais para desenvolvedores de codificação, hashing e conversão de dados.
Perguntas frequentes
O MD5 ainda é seguro para checksums?
O MD5 é seguro para detectar a corrupção acidental de arquivos — se um arquivo for danificado durante o download, o hash MD5 quase certamente mudará. No entanto, o MD5 não é seguro contra a manipulação deliberada porque um atacante pode criar um arquivo modificado com o mesmo hash MD5. Para a verificação de integridade onde adversários são uma preocupação (por exemplo, distribuição de software), use SHA-256.
Quanto mais lento é o SHA-256 comparado ao MD5?
O SHA-256 é aproximadamente 2 vezes mais lento que o MD5 em throughput bruto. Em hardware moderno, o MD5 faz hash a cerca de 3.200 MB/s enquanto o SHA-256 faz a cerca de 1.500 MB/s. Na prática, essa diferença é insignificante para a maioria das aplicações — o hash de um arquivo de 100 MB leva cerca de 70 ms com SHA-256. A diferença de desempenho só importa em cenários de alto throughput como inspeção de pacotes de rede ou deduplicação de armazenamento em escala.
Devo usar SHA-256 ou SHA-512 para minha aplicação?
Use SHA-256 para a maioria das aplicações — ele fornece resistência a colisões de 128 bits, que está muito acima da capacidade de força bruta. Escolha SHA-512 se: (a) sua plataforma é de 64 bits e você precisa do máximo desempenho, (b) uma especificação ou requisito de conformidade exige, ou (c) você quer uma margem de segurança maior para a integridade de dados a longo prazo. O comprimento adicional do hash SHA-512 dobra o armazenamento e raramente é necessário.
O SHA-256 pode ser descriptografado ou invertido?
O SHA-256 não pode ser invertido — é uma função unidirecional. Até 2026, não existem ataques práticos de pré-imagem ou colisão contra o SHA-256. O melhor ataque conhecido requer 2^128 operações para colisões, o que é computacionalmente inviável com a tecnologia atual ou previsível. O SHA-256 é aprovado pelo NIST e é usado em infraestrutura crítica incluindo TLS, Bitcoin e sistemas federais.
Por que alguns sistemas ainda usam MD5 se está quebrado?
A compatibilidade com sistemas legados é a razão principal. Muitos sistemas, protocolos e formatos de arquivo existentes foram projetados em torno do MD5 antes que suas fraquezas fossem descobertas. Migrar requer mudanças coordenadas em todos os componentes. Para usos não relacionados à segurança como chaves de cache e deduplicação, a vantagem de velocidade do MD5 e sua saída mais curta o tornam uma escolha pragmática onde os ataques de colisão não são uma preocupação do modelo de ameaças.