Funções Hash Criptográficas: Guia Completo

As funções hash criptográficas são os cavalos de batalha silenciosos da segurança moderna. Cada vez que você faz login em um site, envia código para o Git, baixa um arquivo ou realiza uma transação de Bitcoin, as funções hash estão trabalhando nos bastidores. No entanto, a maioria dos desenvolvedores interage com elas diariamente sem realmente entender o que fazem — ou o que pode dar terrivelmente errado quando são usadas incorretamente.

Este guia cobre tudo: a matemática, a história, os algoritmos quebrados, os padrões modernos e o código prático necessário para usar funções hash corretamente.

1. O que São Funções Hash Criptográficas?

Uma função hash criptográfica recebe uma entrada de qualquer tamanho e produz uma saída de tamanho fixo, chamada de digest ou valor hash. Por exemplo, o SHA-256 sempre produz exatamente 256 bits (64 caracteres hexadecimais), independentemente de a entrada ser um único caractere ou um arquivo de filme completo.

Propriedades Fundamentais

Determinístico: A mesma entrada sempre produz a mesma saída. SHA-256("hello") sempre retornará 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824.

Cálculo rápido: Calcular um hash deve levar milissegundos. Essa eficiência é crítica para verificações de integridade de arquivos e assinaturas digitais, embora se torne um problema para hash de senhas (mais sobre isso adiante).

Resistência à pré-imagem (unidirecional): Dado um hash de saída H, deve ser computacionalmente inviável encontrar qualquer entrada m tal que hash(m) = H. Não é possível fazer engenharia reversa dos dados originais apenas a partir do hash.

Resistência à segunda pré-imagem: Dada uma entrada m1, deve ser inviável encontrar uma entrada diferente m2 tal que hash(m1) = hash(m2). Mesmo que um atacante conheça seus dados originais, ele não pode encontrar uma entrada diferente que produza o mesmo hash.

Resistência a colisões: Deve ser inviável encontrar qualquer par de entradas distintas m1 e m2 tal que hash(m1) = hash(m2). Este é um requisito mais forte do que a resistência à segunda pré-imagem.

Efeito avalanche: Uma pequena mudança na entrada — mesmo uma única inversão de bit — muda completamente a saída. Mudar "hello" para "hellp" produz um hash completamente diferente sem relação aparente com o original.

SHA-256("hello") = 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
SHA-256("hellp") = 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca7

Esses dois hashes não compartilham nenhuma relação previsível — esse é o efeito avalanche em ação.

2. Breve História dos Algoritmos Hash

MD5 (1991)

Ronald Rivest projetou o MD5 como uma melhoria em relação ao MD4. Ele produz um digest de 128 bits e foi amplamente adotado durante os anos 1990 para somas de verificação e armazenamento de senhas. Por mais de uma década, o MD5 foi a escolha padrão para muitas aplicações de segurança.

SHA-1 (1995)

A Agência de Segurança Nacional (NSA) projetou o SHA-1 (Secure Hash Algorithm 1) como parte do Digital Signature Standard. Ele produz um digest de 160 bits. O SHA-1 tornou-se o algoritmo hash dominante para certificados TLS/SSL, assinatura de código e armazenamento de objetos do Git.

Família SHA-2 (2001)

Também projetado pela NSA, o SHA-2 é na verdade uma família de seis funções: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 e SHA-512/256. SHA-256 e SHA-512 são os mais comumente usados. Eles produzem digests de 256 e 512 bits, respectivamente, e permanecem seguros atualmente.

SHA-3 / Keccak (2015)

Quando as fraquezas do SHA-1 se tornaram evidentes, o NIST realizou um concurso público (2007-2015) para encontrar um novo padrão hash completamente independente do design SHA-2 da NSA. O vencedor foi o Keccak, projetado por Guido Bertoni, Joan Daemen, Michaël Peeters e Gilles Van Assche. Ao contrário do SHA-2, que usa uma construção Merkle–Damgård, o SHA-3 usa uma construção esponja, oferecendo um perfil de segurança fundamentalmente diferente.

BLAKE2 (2012)

O BLAKE2 é uma função hash criptográfica mais rápida que o MD5, mas com a segurança do SHA-3. Foi projetado por Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O'Hearn e Christian Winnerlein como uma melhoria em relação ao BLAKE, que foi finalista na competição SHA-3. BLAKE2b é otimizado para plataformas de 64 bits; BLAKE2s para 32 bits.

3. Como o SHA-256 Funciona

O SHA-256 usa a construção Merkle–Damgård: a mensagem é dividida em blocos de tamanho fixo, e uma função de compressão é aplicada iterativamente, alimentando a saída de um bloco como entrada para o próximo.

Passo 1: Preenchimento

A mensagem de entrada é preenchida para que seu comprimento total seja um múltiplo de 512 bits. Um único bit 1 é adicionado, seguido de zeros, seguido do comprimento original da mensagem como um inteiro de 64 bits em formato big-endian.

Passo 2: Agenda de Mensagens

Cada bloco de 512 bits é expandido em 64 palavras de 32 bits usando uma agenda que mistura e rotaciona bits. As palavras W[0] a W[15] vêm diretamente do bloco de mensagem; as palavras W[16] a W[63] são calculadas como:

W[i] = σ1(W[i-2]) + W[i-7] + σ0(W[i-15]) + W[i-16]

Onde σ0 e σ1 são operações específicas de rotação e deslocamento de bits.

Passo 3: Compressão — 64 Rodadas

O SHA-256 mantém 8 variáveis de trabalho (a a h), inicializadas com as partes fracionárias das raízes quadradas dos primeiros 8 números primos. Para cada uma das 64 rodadas:

T1 = h + Σ1(e) + Ch(e,f,g) + K[i] + W[i]
T2 = Σ0(a) + Maj(a,b,c)
h = g; g = f; f = e; e = d + T1
d = c; c = b; b = a; a = T1 + T2

As constantes de rodada K[i] são as partes fracionárias das raízes cúbicas dos primeiros 64 primos — uma escolha de design que evita a crítica de "nada na manga" ao tornar as constantes publicamente verificáveis.

Passo 4: Saída

Após processar todos os blocos, as 8 variáveis de trabalho são adicionadas aos valores hash iniciais para produzir o digest final de 256 bits. Esse "feed-forward" garante que a saída de cada bloco depende de todos os blocos anteriores.

4. Por que MD5 e SHA-1 Estão Quebrados

Colisões no MD5 (2004)

Em 2004, Xiaoyun Wang e colegas demonstraram ataques de colisão práticos contra o MD5 — encontrando duas entradas diferentes que produzem o mesmo hash MD5. Em 2008, pesquisadores usaram colisões MD5 para forjar um certificado SSL fraudulento de uma CA real, demonstrando um ataque real contra a infraestrutura HTTPS.

O ataque usa criptoanálise diferencial sofisticada e pode gerar colisões MD5 em segundos em hardware moderno.

SHA-1 SHAttered (2017)

A equipe Project Zero do Google e o CWI Amsterdam produziram a primeira colisão SHA-1 prática em 2017, chamada de SHAttered. Eles geraram dois arquivos PDF diferentes com hashes SHA-1 idênticos. O ataque exigiu aproximadamente 9,2 × 10¹⁸ cálculos SHA-1 — equivalente a 6.500 anos de tempo de CPU único — mas apenas cerca de 110 anos de tempo de GPU, ao alcance de estados-nação e grandes organizações.

O que Isso Significa na Prática

MD5 e SHA-1 NÃO são seguros para:

Assinaturas digitais
Impressões digitais de certificados
Armazenamento de senhas
Qualquer aplicação sensível à segurança

Eles ainda são aceitáveis para:

Somas de verificação não criptográficas (verificação de integridade de download de arquivos por canal confiável)
Pesquisas em tabelas hash
Deduplicação não relacionada à segurança
Compatibilidade com sistemas legados (com ressalvas apropriadas)

5. Casos de Uso no Mundo Real

Armazenamento de Senhas

Nunca armazene senhas em texto simples — nem mesmo como hashes simples. Se seu banco de dados for vazado, um atacante pode quebrar hashes simples usando ataques de dicionário ou tabelas rainbow em horas ou dias.

A abordagem correta usa uma função hash lenta e com sal especificamente projetada para senhas: bcrypt, scrypt ou Argon2.

Verificação de Integridade de Arquivos

Quando você baixa software, o desenvolvedor fornece uma soma de verificação SHA-256. Após o download, você calcula o hash do arquivo e compara. Se coincidirem, o arquivo não foi corrompido ou adulterado em trânsito.

sha256sum downloaded-file.tar.gz
# Comparar com a soma de verificação publicada pelo desenvolvedor

Assinaturas Digitais

As funções hash são fundamentais para assinaturas digitais. Em vez de assinar um documento inteiro (que pode ser gigabytes), você faz o hash e assina apenas o hash. O receptor faz o hash do documento independentemente e verifica a assinatura em relação a esse hash.

Blockchain

O Bitcoin usa SHA-256 duas vezes (SHA-256d) para mineração por prova de trabalho e para fazer o hash de blocos de transações. Os mineradores devem encontrar uma entrada (nonce) que, quando submetida ao hash, produza uma saída com certo número de zeros iniciais — um processo que requer enorme esforço computacional e fornece as garantias de segurança da blockchain.

Armazenamento de Objetos Git

O Git usa SHA-1 para fazer o hash de cada objeto de commit, árvore e blob. O hash serve tanto como identificador do objeto quanto como verificação de integridade. O Git está migrando ativamente para SHA-256 devido às fraquezas do SHA-1.

Deduplicação em Sistemas de Armazenamento

Sistemas de backup e armazenamento endereçável por conteúdo (como o IPFS) usam hashes para identificar conteúdo duplicado. Se dois arquivos têm o mesmo hash, eles são armazenados apenas uma vez.

6. Calculando Hashes na Prática

JavaScript (Node.js)

const crypto = require('crypto');

// SHA-256
const sha256 = crypto.createHash('sha256')
  .update('Hello, World!')
  .digest('hex');
console.log(sha256);
// 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

// MD5 (usar apenas para fins não relacionados à segurança)
const md5 = crypto.createHash('md5')
  .update('Hello, World!')
  .digest('hex');
console.log(md5);
// 65a8e27d8879283831b664bd8b7f0ad4

// SHA-512
const sha512 = crypto.createHash('sha512')
  .update('Hello, World!')
  .digest('hex');
console.log(sha512);

Python

import hashlib

# SHA-256
h = hashlib.sha256(b"Hello, World!").hexdigest()
print(h)
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

# SHA-512
h512 = hashlib.sha512(b"Hello, World!").hexdigest()
print(h512)

# Múltiplos algoritmos
for algo in ['md5', 'sha1', 'sha256', 'sha512']:
    h = hashlib.new(algo, b"Hello, World!").hexdigest()
    print(f"{algo}: {h}")

Bash / Shell

# SHA-256
echo -n "Hello, World!" | sha256sum
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3  -

# MD5
echo -n "Hello, World!" | md5sum
# 65a8e27d8879283831b664bd8b7f0ad4  -

# SHA-1
echo -n "Hello, World!" | sha1sum

# Hash de um arquivo
sha256sum /path/to/file.iso

7. HMAC: Código de Autenticação de Mensagem Baseado em Hash

Um hash simples verifica a integridade dos dados — ele diz se os dados foram corrompidos. Mas não verifica a autenticidade — não prova quem criou os dados. Qualquer pessoa pode calcular um hash.

O HMAC (RFC 2104) resolve isso combinando uma chave secreta com a função hash:

HMAC(K, m) = hash((K' ⊕ opad) || hash((K' ⊕ ipad) || m))

Onde K' é a chave preenchida ao tamanho do bloco, e opad/ipad são constantes de preenchimento específicas. Esta construção é comprovadamente segura se a função hash subjacente for segura.

Usos Comuns

Autenticação de API: APIs REST usam HMAC-SHA256 para assinar requisições. O servidor e o cliente compartilham uma chave secreta. O cliente assina o corpo da requisição com a chave; o servidor verifica a assinatura.

Assinaturas JWT: JSON Web Tokens usam HMAC-SHA256 (HS256) para assinar o cabeçalho e o payload, garantindo que o token não foi adulterado.

Verificação de Webhooks: GitHub, Stripe e muitos outros serviços assinam payloads de webhooks com HMAC-SHA256 para que os receptores possam verificar a autenticidade do payload.

Calculando HMAC

// Node.js
const crypto = require('crypto');

const hmac = crypto.createHmac('sha256', 'minha-chave-secreta')
  .update('mensagem para autenticar')
  .digest('hex');
console.log(hmac);

import hmac
import hashlib

key = b'my-secret-key'
message = b'message to authenticate'
sig = hmac.new(key, message, hashlib.sha256).hexdigest()
print(sig)

8. Tabelas Rainbow e Salting

O que São Tabelas Rainbow?

Uma tabela rainbow é um banco de dados pré-calculado que mapeia valores hash conhecidos de volta às suas entradas em texto simples originais. Se um atacante obtiver seu banco de dados de hashes de senhas, ele não precisa quebrar cada hash individualmente — simplesmente pesquisa na tabela.

Para MD5 e SHA-1, tabelas rainbow cobrindo todas as senhas ASCII de até 8 caracteres estão disponíveis gratuitamente há anos. Sites como o CrackStation mantêm bancos de dados de bilhões de mapeamentos hash-senha.

Como o Salting Derrota as Tabelas Rainbow

Um sal é um valor aleatório adicionado à senha antes do hash:

hash(sal + senha) = hash_armazenado

O sal é armazenado junto com o hash (não precisa ser secreto). Como cada usuário recebe um sal aleatório único, o atacante não pode usar tabelas pré-calculadas — precisaria de uma tabela rainbow separada para cada valor de sal possível, o que é computacionalmente impossível.

bcrypt: Salting Automático e Lentidão Intencional

O bcrypt foi projetado em 1999 especificamente para hash de senhas. Ele gera e incorpora automaticamente um sal aleatório e inclui um fator de custo que controla a lentidão do cálculo do hash:

const bcrypt = require('bcrypt');

// Hash de uma senha (fator de custo 12 — leva ~250ms em hardware moderno)
const hash = await bcrypt.hash('senha-do-usuario', 12);

// Verificar
const isMatch = await bcrypt.compare('senha-do-usuario', hash);

O hash armazenado parece: $2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW

O prefixo $2b$12$ codifica a versão do algoritmo e o fator de custo — o bcrypt lida com tudo automaticamente.

9. Tabela Comparativa de Algoritmos

Algoritmo	Tamanho de Saída	Velocidade	Status de Segurança	Melhor Para
MD5	128 bits	Muito rápido	❌ Quebrado (colisões)	Apenas somas de verificação não seguras
SHA-1	160 bits	Rápido	❌ Quebrado (SHAttered)	Apenas sistemas legados
SHA-256	256 bits	Rápido	✅ Seguro	Uso geral, TLS, assinaturas
SHA-512	512 bits	Rápido em 64 bits	✅ Seguro	Aplicações de alta segurança
SHA-3/Keccak	Variável	Moderado	✅ Seguro	Alternativa ao SHA-2
BLAKE2b	Variável	Muito rápido	✅ Seguro	Hash crítico para desempenho
bcrypt	184 bits	Lento (intencional)	✅ Seguro	Armazenamento de senhas
Argon2id	Variável	Lento (intencional)	✅ Seguro	Armazenamento de senhas (recomendado)

10. Melhores Práticas para Hash de Senhas

Senhas merecem tratamento especial porque são as chaves para contas de usuários. Um banco de dados de senhas comprometido pode ser devastador. Siga estas regras sem exceção:

Regra 1: Nunca Armazene Senhas em Texto Simples

Isso deveria ser óbvio, mas ainda acontece. Em 2019, o Facebook foi descoberto armazenando internamente centenas de milhões de senhas em texto simples.

Regra 2: Nunca Use Hashes Rápidos para Senhas

MD5, SHA-1, SHA-256 e SHA-512 são todos rápidos demais para hash de senhas. Uma GPU moderna pode calcular bilhões de hashes SHA-256 por segundo, possibilitando ataques de força bruta em horas.

Regra 3: Use Algoritmos de Hash Projetados Especificamente para Senhas

bcrypt (mínimo recomendado): Use um fator de custo de 12 ou superior. Amplamente suportado, testado em batalha.

scrypt: Intensivo em memória, tornando-o resistente a ataques de GPU e ASIC. Custos de memória e CPU configuráveis.

Argon2id (recomendado atualmente): Vencedor da Competição de Hash de Senhas de 2015. O Argon2id é a variante recomendada pois fornece resistência tanto a ataques de canal lateral quanto a ataques de compromisso tempo-memória. Configure com no mínimo:

Memória: 64 MB
Iterações: 3
Paralelismo: 4

Regra 4: Use um Sal Único por Senha

Mesmo com bcrypt/scrypt/Argon2 (que incluem salting automático), entenda por que isso importa: senhas idênticas devem produzir hashes diferentes para que comprometer uma não revele as outras.

Regra 5: Ajuste os Fatores de Custo ao Longo do Tempo

À medida que o hardware fica mais rápido, aumente os fatores de custo. Mire em ~250-500ms para o bcrypt. Refaça o hash das senhas no próximo login.

Regra 6: Considere o Uso de Pepper

Um pepper é um segredo do lado do servidor (ao contrário do sal, não é armazenado no banco de dados). É adicionado à senha antes do hash: hash(pepper + sal + senha). Mesmo que um atacante roube seu banco de dados, ele não pode quebrar senhas sem o pepper.

Conclusão

As funções hash criptográficas são fundamentais para a segurança, integridade e confiança em toda a internet. Entendê-las — desde suas propriedades matemáticas até suas vulnerabilidades práticas — permite construir sistemas genuinamente seguros.

Os principais pontos:

SHA-256 e SHA-512 são seus hashes de uso geral
MD5 e SHA-1 estão quebrados para usos criptográficos
Para senhas, sempre use bcrypt, scrypt ou Argon2
Use HMAC quando precisar de autenticação, não apenas integridade
O salting derrota as tabelas rainbow; bcrypt e Argon2 fazem isso automaticamente

Use o Gerador de Hash Tool3M para calcular rapidamente hashes SHA-256, SHA-512, MD5 e outros diretamente no seu navegador — sem necessidade de instalação.