MD5 vs SHA-256 vs SHA-512 — Funções de Hash Explicadas

Funções de hash estão em todo lugar no desenvolvimento de software: verificação de integridade de arquivos, armazenamento de senhas, assinaturas digitais, autenticação de API, chaves de cache, deduplicação. Mesmo assim, a maioria dos devs as usa como caixas pretas — você passa uma string, recebe de volta um digest hexadecimal de tamanho fixo. Os detalhes de qual função de hash usar, e qual evitar, acabam sendo muito importantes.

O MD5 está comprometido. O SHA-1 foi descontinuado. O SHA-256 e o SHA-512 são atualmente seguros. O SHA-3 existe para quem quer proteção futura. Mas "comprometido" não significa a mesma coisa em todos os contextos — o MD5 é adequado para alguns casos de uso e catastroficamente errado para outros. Este guia explica as propriedades que importam, como cada função se saí em relação a elas e oferece um framework de decisão claro para escolher o hash certo em 2026.

O Que uma Função de Hash Realmente Faz

Uma função de hash criptográfica mapeia uma entrada de comprimento arbitrário para uma saída de comprimento fixo (o digest ou hash). Três propriedades definem uma função de hash criptograficamente segura:

• Resistência a pré-imagem — dado um hash h, deve ser computacionalmente inviável encontrar qualquer entrada m tal que hash(m) = h. Esta é a propriedade "unidirecional".
• Resistência a segunda pré-imagem — dada uma entrada m1, deve ser inviável encontrar uma entrada diferente m2 tal que hash(m1) = hash(m2).
• Resistência a colisão — deve ser inviável encontrar quaisquer duas entradas distintas m1 e m2 tal que hash(m1) = hash(m2).

Uma função que falha em qualquer uma dessas propriedades é considerada comprometida para uso criptográfico. Note que "inviável" tem um significado específico aqui: não quer dizer matematicamente impossível, mas sim que requer mais computação do que é prático com hardware atual ou previsível.

Além disso, funções de hash criptográficas exibem o efeito avalanche: mudar um único bit na entrada produz uma saída que difere em aproximadamente metade dos seus bits. Isso garante que entradas similares produzam digests completamente diferentes.

Entrada: "hello"
MD5:     5d41402abc4b2a76b9719d911017c592  (128 bits / 32 chars hex)

Entrada: "Hello"
MD5:     8b1a9953c4611296a827abf8c47804d7  (mudança de 1 caractere = saída completamente diferente)

MD5 — Rápido, Ubíquo e Comprometido

Histórico e design

O MD5 (Message Digest 5) foi projetado por Ron Rivest em 1991 e produz um digest de 128 bits (16 bytes). Durante a maior parte dos anos 1990, foi a escolha padrão para verificação de integridade de arquivos, assinatura de certificados e hash de senhas. É extremamente rápido — uma CPU moderna pode calcular dezenas de milhões de hashes MD5 por segundo, e uma GPU pode calcular bilhões.

Por que o MD5 está comprometido

Em 2004, Xiaoyun Wang e colegas demonstraram um ataque prático de colisão contra o MD5 — dois arquivos diferentes que produzem o mesmo hash MD5. O ataque executa em minutos em hardware doméstico. Em 2008, pesquisadores criaram um certificado CA desonesto usando uma colisão MD5, demonstrando que a infraestrutura PKI do mundo real era vulnerável. Em 2012, o malware Flame usou uma colisão MD5 para forjar um certificado de assinatura de código da Microsoft.

O NIST descontinuou oficialmente o MD5 para a maioria dos usos criptográficos. As autoridades certificadoras pararam de emitir certificados assinados com MD5 em 2009. Os fabricantes de browsers removeram o suporte para assinaturas de certificado MD5 por volta de 2011.

Quando o MD5 ainda é aceitável

O MD5 não é universalmente inútil. Para checksums não relacionados à segurança — detectar corrupção acidental de dados em transferências de arquivos, endereçamento baseado em conteúdo em um sistema de cache onde o atacante não pode influenciar as entradas, ou gerar identificadores únicos em um sistema interno fechado — o MD5 continua adequado. O teste chave: se um atacante pode se beneficiar de criar uma colisão, não use MD5. Se apenas a corrupção acidental é uma preocupação, o MD5 é adequado.

• Seguro: deduplicação interna, chaves de cache, detecção de alteração de arquivos não relacionada à segurança
• Inseguro: certificados, assinaturas digitais, hash de senhas, verificação de autenticidade de arquivos, tokens de segurança

SHA-1 — Descontinuado, Mas Ainda Presente

O SHA-1 produz um digest de 160 bits e foi o sucessor do MD5. Permaneceu como padrão para assinatura de certificados e assinatura de código durante a maior parte dos anos 2000. Em 2017, o ataque SHAttered demonstrou a primeira colisão SHA-1 prática, produzindo dois arquivos PDF diferentes com hashes SHA-1 idênticos usando aproximadamente 110 GPU-anos de computação — caro, mas dentro do orçamento de estados-nação e cada vez mais acessível.

O SHA-1 foi descontinuado pelo NIST e por todas as principais autoridades certificadoras. Não deve ser usado para certificados, assinatura de código ou qualquer nova aplicação sensível à segurança. Alguns sistemas legados ainda usam SHA-1 internamente, mas a migração para SHA-256 é fortemente recomendada. O Git ainda usa SHA-1 para endereçamento de objetos (embora a transição para SHA-256 esteja em andamento), mas isso está sendo eliminado gradualmente.

SHA-256 — O Padrão Atual

O SHA-256 faz parte da família SHA-2, projetada pela NSA e padronizada pelo NIST no FIPS 180-4. Produz um digest de 256 bits (32 bytes). O SHA-256 foi intensivamente analisado desde sua publicação em 2001 e nenhum ataque prático foi encontrado. É o padrão de facto para:

• Certificados TLS (essencialmente todos os certificados emitidos hoje usam SHA-256)
• Assinatura de código (Windows Authenticode, notarização da Apple, JARs)
• HMAC-SHA256 para autenticação de API (AWS Signature v4, verificação de webhooks do GitHub)
• Assinaturas de tokens JWT (HS256 e RS256 usam SHA-256 internamente)
• IDs de transações em blockchain (o Bitcoin usa SHA-256 duplo)
• Verificação de integridade de arquivos em gerenciadores de pacotes (npm, pip, apt)

Entrada:  "hello"
SHA-256: 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
         (256 bits / 64 chars hex)

SHA-512: 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d
         99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
         (512 bits / 128 chars hex)

Desempenho do SHA-256

O SHA-256 usa operações de palavra de 32 bits internamente. Em hardware de 32 bits ou CPUs mais antigas sem aceleração por hardware, é visivelmente mais lento que o MD5. Em CPUs modernas de 64 bits com extensões SHA (Intel Goldmont+, AMD Zen+, Apple Silicon, ARM Cortex-A57+), o SHA-256 tem aceleração por hardware e é extremamente rápido — muitas vezes se aproximando das velocidades do MD5. A maioria dos ambientes de servidor tem aceleração por hardware, então na prática o SHA-256 é rápido o suficiente para praticamente todas as aplicações.

SHA-512 — Mais Amplo, Às Vezes Mais Rápido

O SHA-512 produz um digest de 512 bits (64 bytes) usando operações de palavra de 64 bits internamente. Em hardware de 64 bits sem extensões SHA, o SHA-512 pode ser mais rápido que o SHA-256 porque suas operações de 64 bits fazem melhor uso das larguras de registrador modernas. Em hardware com extensões SHA, o SHA-256 é normalmente mais rápido porque as extensões são especificamente otimizadas para ele.

O SHA-512 fornece uma margem de segurança maior — resistência a colisão de 256 bits versus 128 bits do SHA-256. Para a maioria dos modelos de ameaça atuais, a resistência a colisão de 128 bits do SHA-256 é mais que suficiente (quebrá-la exigiria aproximadamente 2^128 operações). O SHA-512 é adequado quando:

• Você está visando servidores de 64 bits e quer máxima taxa de transferência sem extensões de hardware
• Você precisa de digests mais longos como material de chave para outras operações criptográficas
• Você quer margem de segurança adicional para dados que devem permanecer protegidos por décadas
• Você está implementando protocolos que especificamente exigem SHA-512 (ex: alguns conjuntos de cifras TLS)

SHA-384 e SHA-512/256

O SHA-384 é uma versão truncada do SHA-512 que produz 384 bits — útil quando você quer as operações internas de 64 bits do SHA-512 mas precisa de saída mais curta. O SHA-512/256 é outra variante truncada que produz saída de 256 bits usando a computação interna do SHA-512. O SHA-512/256 é resistente a ataques de extensão de comprimento que afetam o SHA-256, tornando-o útil em contextos onde a extensão de comprimento é uma preocupação (embora o HMAC já mitigue isso na maioria dos cenários práticos).

SHA-3 — Arquitetura Diferente, À Prova do Futuro

O SHA-3 (padronizado no NIST FIPS 202, 2015) usa a construção de esponja Keccak — um design fundamentalmente diferente da estrutura Merkle-Damgard do SHA-2. Isso é importante porque qualquer fraqueza futura descoberta no design Merkle-Damgard afetaria MD5, SHA-1 e SHA-2 simultaneamente, enquanto o SHA-3 permaneceria sem ser afetado.

O SHA-3 é atualmente seguro e é a escolha certa para novos sistemas que precisam de garantia de longo prazo ou que querem se proteger contra futuras fraquezas do SHA-2. É mais lento que o SHA-256 em implementações de software puro. Onde o SHA-3 brilha é em implementações de hardware — seu design é muito eficiente em silício. O SHA-3-256 e o SHA-3-512 produzem os mesmos tamanhos de digest que seus equivalentes SHA-2.

Tabela Comparativa

Hash de Senhas: Um Problema Completamente Diferente

Este tópico merece sua própria seção porque é um dos erros mais comuns que devs cometem. O SHA-256 é a ferramenta certa para verificações de integridade de arquivos, assinatura de API e verificação de certificados. É a ferramenta errada para fazer hash de senhas, e usá-lo para essa finalidade causa incidentes de segurança reais.

O problema é a velocidade. O SHA-256 é projetado para ser rápido — uma GPU moderna pode calcular bilhões de hashes SHA-256 por segundo. Um atacante que obtém seu banco de dados de senhas com hash pode tentar bilhões de tentativas de senha por segundo. Mesmo uma senha longa e aleatória pode ser descoberta rapidamente se o hash for rápido.

// NUNCA faça isso para senhas
const hash = crypto.createHash('sha256').update(password).digest('hex');

// Use bcrypt, scrypt ou Argon2 para senhas
const bcrypt = require('bcrypt');
const hash = await bcrypt.hash(password, 12);  // fator de custo 12

A ferramenta Bcrypt Test permite que você faça hash e verifique senhas bcrypt no browser. Para entender os fatores de custo do bcrypt e seus tempos de computação, é uma referência útil ao configurar o fator de trabalho da sua aplicação.

HMAC: Adicionando Autenticação a um Hash

Um hash simples não prova nada sobre quem o calculou — qualquer pessoa que tenha os dados pode calcular o mesmo hash SHA-256. O HMAC (Hash-based Message Authentication Code) adiciona uma chave secreta à computação, produzindo uma tag que só pode ser reproduzida por alguém que conhece a chave. O HMAC-SHA256 é o padrão para:

• Verificação de assinatura de webhook (GitHub, Stripe, Shopify usam HMAC-SHA256)
• AWS Signature Version 4 (assinatura de requisições)
• Tokens JWT HS256 (HMAC-SHA256 de header + payload)
• Integridade de cookies (assinatura de cookies de sessão para prevenir adulteração)

const crypto = require('crypto');

// Assinar uma mensagem com HMAC-SHA256
const mac = crypto
  .createHmac('sha256', secretKey)
  .update(message)
  .digest('hex');

// Verificar: comparar em tempo constante (previne timing attacks)
const isValid = crypto.timingSafeEqual(
  Buffer.from(mac, 'hex'),
  Buffer.from(received, 'hex')
);

Observe o uso de timingSafeEqual para comparação. Comparar valores MAC com uma verificação de igualdade de string comum vaza informações de temporização que podem ser exploradas em um timing attack. Sempre use uma função de comparação em tempo constante ao verificar MACs. Use o HMAC Generator para calcular valores HMAC-SHA256 para testes e depuração sem escrever código.

Recomendações do Mundo Real

Integridade geral de arquivos (checksums)

Use SHA-256. É o padrão para verificação de pacotes (lockfiles do npm, hashes de requisitos do pip, camadas de imagem Docker). A ferramenta SHA-256 Hash calcula digests SHA-256 no seu browser para entrada de texto ou valores de string. Para checksums rápidos não relacionados à segurança onde a velocidade é crítica e você confia na fonte, o MD5 continua aceitável, mas o SHA-256 é preferível em qualquer contexto compartilhado ou automatizado.

Certificados TLS e assinatura de código

O SHA-256 é o padrão exigido. Todas as autoridades certificadoras emitem certificados SHA-256. Nunca use MD5 ou SHA-1 para novos certificados — eles serão rejeitados por browsers e sistemas operacionais modernos.

Autenticação de API

Use HMAC-SHA256. É o padrão estabelecido, bem suportado em todas as linguagens e o algoritmo esperado pela maioria da documentação de segurança de API. Calcule digests com a ferramenta MD5 Hash ou SHA-256 Hash para comparações rápidas, e gere assinaturas HMAC com o HMAC Generator.

Hash de senhas

Use bcrypt (fator de custo 12+), scrypt ou Argon2id. Nunca use MD5, SHA-1, SHA-256 ou SHA-512 diretamente para senhas, mesmo com salt. A ferramenta Bcrypt Test pode ajudar a verificar hashes bcrypt durante o desenvolvimento.

Dados de longa duração que requerem décadas de segurança

Prefira SHA-512 ou SHA-3-256. O tamanho maior do digest fornece margem adicional contra avanços em criptoanálise. O NIST recomenda SHA-512 e SHA-3 para aplicações que requerem segurança de longo prazo. Veja a orientação oficial no NIST FIPS 180-4 para a especificação autoritativa dos algoritmos SHA-2.

Novos sistemas sem restrições legadas

SHA-256 para uso geral. Argon2id para senhas. HMAC-SHA256 para códigos de autenticação. Se você quer proteção futura e pode aceitar desempenho ligeiramente menor, o SHA-3-256 é uma alternativa sólida ao SHA-256 para hash de uso geral.