Funções de hash explicadas: verificar a integridade de ficheiros

Uma função de hash recebe qualquer entrada e produz uma saída de tamanho fixo — o SHA-256 produz sempre exatamente 256 bits (32 bytes) independentemente de a entrada ser um tweet ou um vídeo de 10 GB. Altere um bit da entrada, e aproximadamente metade dos bits de saída mudam. Esta propriedade unidirecional e determinística torna os hashes a ferramenta padrão para verificar a integridade de ficheiros: calcule SHA-256(ficheiro) antes de enviar, calcule-o novamente após receber, e se os hashes coincidirem, o ficheiro chegou intacto. É assim que as distribuições Linux verificam descarregamentos de ISO, como o Git identifica commits, e como serviços como o HexaTransfer confirmam que carregamentos de vários gigabytes estão completos sem corrupção.

O que uma função de hash garante

Três propriedades definem uma função de hash criptográfica:

Determinística. A mesma entrada produz sempre a mesma saída. SHA-256("ola") é sempre o mesmo valor.
Resistência à pré-imagem. Dado um hash, não consegue encontrar eficientemente uma entrada que o produza.
Resistência a colisões. Não consegue encontrar eficientemente duas entradas diferentes que produzam o mesmo hash.

Mais dois comportamentos úteis:

Efeito avalanche. Alterar um bit de entrada muda aproximadamente 50% dos bits de saída. Torna os hashes inúteis para pesquisa mas excelentes para identificação.
Saída de tamanho fixo. SHA-256 tem 32 bytes, SHA-512 tem 64 bytes, BLAKE2b tem 64 bytes, independentemente do tamanho da entrada.

Os hashes não são encriptação. São unidirecionais — não consegue recuperar a entrada a partir da saída. É esse o objetivo.

A família SHA

A família de Algoritmos de Hash Seguro, padronizada pelo NIST em FIPS 180-4 e FIPS 202:

SHA-1 — 160 bits, quebrado pelo ataque SHAttered do Google em 2017. Não use para segurança.
SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512). O motor de trabalho dos sistemas modernos. O SHA-256 domina.
SHA-3 (Keccak). Construção diferente (esponja, não Merkle-Damgård), padronizado em 2015 como proteção contra fraquezas do SHA-2 que não se materializaram.

O SHA-256 é o que os certificados TLS assinam, o que o Bitcoin minera, o que o Git usa (com uma transição planeada para SHA-256 ainda em curso), e o que os serviços de transferência de ficheiros calculam para verificações de integridade. Débito em CPUs modernos com extensões SHA: 2–4 GB/s por núcleo.

Por que o MD5 e o SHA-1 estão mortos para segurança

O MD5 (1991) produz hashes de 128 bits e foi o padrão até colisões serem demonstradas em 2004. Em 2012, o malware Flame falsificou certificados de assinatura de código da Microsoft usando um ataque de colisão MD5. Hoje pode gerar colisões MD5 em segundos num portátil.

O SHA-1 durou mais mas caiu ao ataque SHAttered do Google em 2017, que produziu dois PDFs com hashes SHA-1 idênticos após 110 anos-GPU de computação — agora reproduzível por menos de 100 000 $ em GPUs de nuvem.

Ambos ainda são adequados para usos não relacionados com segurança: detetar corrupção acidental, deduplicar armazenamento, identificar chaves de cache. Não são adequados para assinaturas digitais, verificação de palavras-passe, ou qualquer situação onde um atacante beneficie de forjar uma correspondência.

BLAKE2 e BLAKE3: velocidade com segurança

O BLAKE2 (2012) e o BLAKE3 (2020) oferecem segurança ao nível do SHA-3 com 2–10x a velocidade do SHA-256. O BLAKE3 atinge cerca de 6 GB/s em execução sequencial e paraleliza linearmente entre núcleos — uma máquina de 16 núcleos pode atingir mais de 100 GB/s.

A adoção está a crescer: o WireGuard usa BLAKE2s para autenticação, o Zcash usa BLAKE2b, e o b3sum está a tornar-se um substituto comum do sha256sum nas ferramentas de desenvolvimento. Os serviços de transferência de ficheiros que processam carregamentos de vários gigabytes usam cada vez mais BLAKE3 para evitar que o cálculo do hash se torne o bottleneck.

Os navegadores ainda não expõem o BLAKE3 através da Web Crypto API, pelo que as implementações JavaScript recorrem a código de referência compilado em WASM a cerca de 500 MB/s no navegador.

Hashes em fluxos de trabalho de transferência de ficheiros

Vários contextos onde os hashes são indispensáveis:

Verificação de integridade pós-carregamento. O cliente calcula o SHA-256 durante o carregamento, o servidor calcula na chegada, e as discrepâncias acionam o recarregamento. O S3 usa MD5 para isto uma vez que a velocidade importa mais do que a resistência a colisões contra corrupção passiva.
Verificação de carregamento por blocos. Ficheiros grandes divididos em blocos de 4 MB ou 5 MB; cada bloco recebe um hash, e uma árvore de hashes (árvore de Merkle) produz um único hash raiz para o ficheiro completo.
Deduplicação. Se dois utilizadores carregarem o mesmo ficheiro, os hashes coincidem e o armazenamento guarda apenas uma cópia. Usado pela deduplicação ao nível de blocos do Dropbox e pelo caching de CDN.
Verificação de descarregamento. Alguns serviços apresentam o SHA-256 na página de descarregamento para que os destinatários possam verificar.
Identificação de versões. O Git usa SHA-1 (a migrar para SHA-256) para IDs de commit — o conteúdo de um ficheiro determina a sua identidade.

A extensão HMAC

Hashes simples podem verificar integridade mas não autenticidade — qualquer pessoa pode calcular SHA-256(ficheiro). Adicionar uma chave secreta transforma um hash num Message Authentication Code (MAC): apenas quem tiver a chave consegue produzir ou verificar o MAC.

O HMAC (RFC 2104) é a construção padrão: HMAC(chave, msg) = SHA-256(chave' ⊕ opad || SHA-256(chave' ⊕ ipad || msg)). Usado no TLS 1.2, JWTs assinados com HS256, assinatura de pedidos AWS, e muitos esquemas de cookies de sessão.

Na transferência de ficheiros, o HMAC aparece na tag de autenticação do AES-GCM (que usa GHASH, não HMAC, mas cumpre o mesmo papel) e na assinatura de pedidos de API de alguns serviços.

Árvores de Merkle: hash à escala

Para ficheiros muito grandes ou coleções de ficheiros, fazer hash de tudo de cada vez é dispendioso. Uma árvore de Merkle organiza os hashes numa árvore binária: as folhas são hashes de blocos, os nós internos são hashes dos seus filhos, e o hash raiz representa todo o conjunto de dados.

Benefícios:

Atualizações eficientes. Alterar um bloco requer apenas refazer o hash de log(n) nós.
Prova de inclusão. Pode provar que um bloco específico faz parte da raiz com apenas log(n) hashes irmãos.
Computação paralela. Os ramos fazem hash independentemente.

Usado pelo BitTorrent (pós-v2), endereçamento de conteúdo IPFS, objetos de árvore do Git, registos de transparência de certificados, e raízes de transações de blockchain. Os serviços de transferência de ficheiros usam árvores de Merkle para carregamentos retomáveis onde os carregamentos parciais precisam de ser verificados contra o original.

Palavras-passe e hashes

Uma aplicação dos hashes: transformar palavras-passe em valores seguros para armazenamento. O simples SHA-256(palavra-passe) é insuficiente — as fazendas de GPU calculam mil milhões de SHA-256 por segundo, pelo que qualquer palavra-passe comum cai instantaneamente.

Os hashes específicos para palavras-passe adicionam custo computacional:

PBKDF2-HMAC-SHA-256 com 600 000 iterações (OWASP 2023).
bcrypt com fator de custo 12 (cerca de 250 ms por hash).
scrypt com resistência à memória para resistir a GPUs.
Argon2id — melhor prática atual, resistente à memória e ao paralelismo.

O objetivo não é a segurança através do próprio hash — é tornar cada tentativa suficientemente cara para que a força bruta offline seja impraticável para qualquer coisa que não seja uma palavra-passe fraca.

Verificar um descarregamento manualmente

Qualquer ficheiro que lhe importe pode ser verificado com ferramentas de linha de comandos. No macOS ou Linux:

shasum -a 256 ubuntu-24.04.iso

No Windows PowerShell:

Get-FileHash ubuntu-24.04.iso -Algorithm SHA256

Compare a saída com o hash publicado em ubuntu.com. Se coincidirem, o ficheiro foi descarregado intacto e corresponde ao que a Canonical assinou. Se diferirem, o descarregamento corrompeu-se ou alguém substituiu o ficheiro.

Para máxima confiança, verifique a assinatura no próprio ficheiro de hash usando GPG e a chave de assinatura da Canonical. A cadeia em múltiplos passos — ficheiro de hash assinado → hash do ficheiro → ficheiro — é como as distribuições Linux mantêm confiança há décadas.

Verificar o tratamento de integridade de um serviço de transferência

Quatro perguntas que vale a pena fazer a qualquer fornecedor de transferência de ficheiros:

Que algoritmo de hash usa para verificar os carregamentos? (SHA-256 ou BLAKE3 são adequados; MD5 é tolerável apenas para verificações de corrupção; o silêncio é sinal de alerta.)
Apresenta o hash ao destinatário? (Nem todos fazem, mas é útil.)
Para carregamentos por blocos, usa árvores de Merkle?
Existe forma de comparar hashes entre endpoints?

O SwissTransfer, Tresorit, Proton Drive, e HexaTransfer calculam todos SHA-256 durante a transferência e verificam na chegada. As falhas de integridade acionam o recarregamento automático dos blocos afetados em vez de falhar toda a transferência.

Colocar em prática

Para a sua próxima transferência sensível: calcule shasum -a 256 ficheiro.pdf antes do carregamento, guarde o hash, e peça ao destinatário que faça o mesmo após o descarregamento. Hashes correspondentes provam integridade byte a byte. São 30 segundos de trabalho que detetam corrupção, adulteração, e a ocasional CDN mal configurada.

Experimente em hexatransfer.com — gratuito, sem conta, até 10 GB.