MD5, SHA-256, SHA-512: qual hash usar quando (guia técnico)

O que é hash criptográfico (e o que não é)

Função hash criptográfica recebe entrada de qualquer tamanho (texto, arquivo, número) e produz saída de tamanho fixo (digest). Propriedades essenciais:

• Determinístico: mesma entrada SEMPRE produz mesmo hash.
• Irreversível (one-way): não dá para 'desfazer' o hash para recuperar a entrada.
• Pequena mudança = grande mudança no hash (avalanche effect).
• Resistente a colisão: difícil encontrar duas entradas diferentes com mesmo hash.
• Resistente a pré-imagem: dado um hash, difícil encontrar alguma entrada que produz ele.

MD5 — quebrado para segurança, ainda útil para checksum não-crítico

Tamanho de saída: 128 bits (32 caracteres hex).

Status: QUEBRADO para uso de segurança. Em 2004 foram publicadas colisões viáveis. Em 2008, demonstrada criação de certificados SSL falsos. Em 2026, MD5 é tecnicamente trivial de quebrar.

Onde NUNCA usar: assinaturas digitais, certificados SSL, hash de senhas, qualquer aplicação que dependa de resistência a colisão.

Onde ainda é OK: checksum não-crítico (verificar se download corrompeu), cache key (deduplicação), git internamente usa SHA-1 mas MD5 serve para casos similares onde colisão maliciosa não é vetor.

SHA-1 — também quebrado, evite

Tamanho de saída: 160 bits (40 caracteres hex).

Status: QUEBRADO. Google demonstrou colisão viável em 2017 (SHAttered attack). Microsoft, Mozilla, Apple, Google removeram suporte SHA-1 em SSL/TLS desde 2017.

Onde ainda aparece: Git ainda usa SHA-1 internamente (em transição para SHA-256 em 2025+). Sistemas legados de assinatura. Migração obrigatória para SHA-256+.

Onde NUNCA usar em projeto novo: qualquer coisa que envolva segurança.

SHA-256 — padrão moderno seguro

Tamanho de saída: 256 bits (64 caracteres hex).

Status: SEGURO para 2026 e próxima década. Não há ataque viável conhecido.

Performance: rápido (~500 MB/s em CPU comum, ~10 GB/s com aceleração SHA-NI).

Onde usar: assinaturas digitais (PKI), certificados SSL/TLS, blockchain (Bitcoin), JWT (HS256/RS256), checksum de software (downloads de Linux, releases GitHub).

Padrão recomendado: SHA-256 é a escolha default para 95% dos casos onde você precisa de hash criptográfico em 2026.

SHA-512 — quando precisa do extra

Tamanho de saída: 512 bits (128 caracteres hex).

Status: SEGURO. Tecnicamente mais forte que SHA-256 mas a diferença prática é marginal.

Performance: em CPUs 64-bit, similar ou mais rápido que SHA-256 (operações nativas em 64-bit). Em CPUs 32-bit (raras hoje), mais lento.

Onde usar: aplicações que tipicamente exigem digest maior (alguns padrões militares, applications high-security), JWT com algoritmo RS512, casos onde você quer 'aposentadoria' do algoritmo mais distante (256 já é seguro por décadas, 512 é seguro por mais).

Não use 'só por garantia': SHA-256 é suficiente. Use SHA-512 se há requisito específico ou se a saída maior tem uso (chave derivada).

SHA-3 (Keccak) — alternativa moderna se você quer diversidade de algoritmos

Status: SEGURO. Padrão NIST 2015. Construção interna diferente de SHA-2 (sponge function vs Merkle-Damgård).

Onde usar: aplicações de alta-segurança que querem dois algoritmos diferentes (SHA-256 + SHA-3-256) para defesa em profundidade. Adoção cresceu mas SHA-2 ainda domina por compatibilidade.

Para 99% dos casos: SHA-256 (SHA-2) é suficiente.

Hash de SENHAS: NUNCA use SHA puro

Erro #1 mais comum em segurança: 'Eu uso SHA-256 para senha, é seguro né?'. NÃO É.

Por quê: SHA é projetado para SER RÁPIDO. GPUs modernas calculam bilhões de SHA-256 por segundo. Atacante com banco de senhas vazado roda dictionary attack em horas.

Use sempre algoritmos lentos por design para senha:

• bcrypt: padrão estabelecido desde 1999. Custo configurável. Suficiente para 99% dos casos.
• scrypt: mais resistente a ataques com hardware especializado (ASIC, FPGA).
• Argon2: vencedor da Password Hashing Competition 2015. Recomendado para projetos novos. Variantes: Argon2d (resistente a GPU), Argon2i (resistente a side-channel), Argon2id (combinado, default).

Como gerar hash com segurança

Para integridade de arquivos, checksum, deduplicação: use o Hash Generator do Quorify — calcula MD5, SHA-1, SHA-256, SHA-512 de qualquer texto ou arquivo (até 200MB) localmente no navegador (zero upload). Útil para verificar integridade de download, comparar arquivos, gerar fingerprint para cache.

Para senhas, NÃO use ferramentas web em geral — implemente bcrypt/argon2 no SEU backend com a chave/salt sob seu controle. Bibliotecas: `bcryptjs` (Node), `passlib` (Python), `golang.org/x/crypto/bcrypt` (Go).

Cenários de uso por algoritmo

Verificar integridade de download Linux ISO: SHA-256 (padrão das distros).

Cache key em CDN: MD5 ou SHA-1 (rápido, colisão maliciosa não é vetor).

Assinatura digital de PDF: SHA-256 com RSA ou ECDSA.

JWT: HS256 (HMAC com SHA-256), RS256 (RSA com SHA-256), ES256 (ECDSA).

Blockchain Bitcoin: SHA-256 (duas vezes — SHA-256(SHA-256(data))).

Hash de senha: NUNCA SHA puro. Use bcrypt/scrypt/argon2.

Git internals (em 2026): SHA-1 ainda padrão, transição para SHA-256 em curso.

Ethereum: KECCAK-256 (variante de SHA-3).

Conclusão

Para 99% dos casos em 2026, SHA-256 é a escolha default. MD5 e SHA-1 servem apenas para checksum não-crítico (deduplicação, cache). SHA-512 quando há requisito específico. Para SENHAS, NUNCA use SHA puro — use bcrypt, scrypt ou argon2. O Hash Generator do Quorify gera todos os hashes (MD5, SHA-1, SHA-256, SHA-512) de qualquer arquivo localmente, útil para verificação de integridade. Para senhas em produção, implemente bcrypt no SEU backend (use Password Generator só para gerar a senha forte que será HASHED no backend).