Gerador de hash

O que uma função de hash faz realmente

Uma função de hash criptográfica recebe uma entrada de qualquer tamanho e produz uma cadeia de bytes de comprimento fixo — um digest, ou «hash». Dê-lhe uma única letra ou um romance inteiro: o MD5 devolve sempre 16 bytes e o SHA-256 sempre 32. A mesma entrada produz sempre o mesmo digest, e mudar um único bit em qualquer ponto da entrada altera cerca de metade dos bits de saída — por isso dois arquivos quase idênticos têm hashes completamente desligados um do outro.

A propriedade crucial é que a função só funciona num sentido. Calcular o hash de um arquivo é rápido; recuperar o arquivo a partir do hash não é apenas lento, é impossível por princípio, porque uma saída de comprimento fixo não consegue codificar uma entrada ilimitada. Um hash é uma impressão digital, não uma cópia cifrada — não há nada para decifrar.

Para que servem realmente os hashes

• Verificar transferências: um projeto publica o SHA-256 de uma versão, você calcula o hash do arquivo recebido e digests iguais significam que os bytes chegaram intactos.
• Detectar alterações: sistemas de controle de versão, backup e desduplicação comparam hashes em vez de arquivos inteiros, porque comparar 32 bytes é muito mais barato do que comparar gigabytes.
• Subresource Integrity: uma página fixa o hash em Base64 de um script que carrega de uma CDN, e o navegador recusa-se a executá-lo se não corresponder.
• Armazenar senhas — mas com uma função lenta feita para isso, nunca com um hash simples. Ver abaixo.

Repare no que têm em comum: o hash é um substituto compacto de algo maior, usado para responder à pergunta «isto é a mesma coisa que eu esperava?» sem transmitir nem armazenar a coisa em si.

MD5 e SHA-1 estão quebrados — o que isso significa na prática

Uma função de hash é considerada quebrada assim que alguém consegue construir uma colisão: duas entradas diferentes que produzem o mesmo digest. As colisões de MD5 calculam-se em hardware comum desde 2004, e em 2017 o ataque SHAttered produziu dois arquivos PDF diferentes com um hash SHA-1 idêntico. É por isso que ambos os algoritmos aparecem assinalados nesta ferramenta.

A consequência prática é mais estreita do que «nunca os use». Uma colisão significa que um atacante que controle os dois arquivos pode fazer um arquivo malicioso coincidir com o digest de um inofensivo, portanto MD5 e SHA-1 já não conseguem provar que um arquivo não foi adulterado por alguém hostil. Continuam perfeitamente úteis para detectar corrupção acidental — uma transferência truncada, um bit trocado num disco — e vai continuar a encontrá-los em sistemas antigos, em cabeçalhos ETag e em manifestos de pacotes antigos que ninguém vai reescrever.

A regra prática: se a pergunta é «isto danificou-se em trânsito?», o MD5 chega. Se a pergunta é «alguém substituiu isto de propósito?», use SHA-256 ou melhor.

Nunca gere o hash de uma senha com estes

MD5, SHA-1 e até SHA-256 são concebidos para serem rápidos, e a rapidez é exatamente a propriedade errada para armazenar senhas. Uma GPU moderna calcula milhares de milhões de hashes SHA-256 por segundo, por isso um banco de dados roubado de senhas simplesmente hasheadas pode ser atacado a uma escala enorme — e como a mesma senha produz sempre o mesmo digest, as tabelas pré-calculadas tornam o ataque ainda mais barato.

Armazenar senhas exige uma função deliberadamente lenta, com salt e exigente em memória: Argon2id, scrypt ou bcrypt. Acrescentam um salt aleatório único por senha, de modo que senhas iguais não compartilham digest, e o seu custo é ajustável, de modo que cada tentativa custa ao atacante tempo e memória reais. Esta ferramenta serve para somas de verificação e impressões digitais, não para gerar hashes de senhas.

Ler e comparar digests

O mesmo digest pode ser escrito de mais do que uma maneira. O hexadecimal em minúsculas é o que as ferramentas padrão de linha de comando imprimem, e é normalmente aquilo com que vai comparar:

md5sum file.iso                  # Linux
sha256sum file.iso               # Linux
shasum -a 256 file.iso           # macOS
Get-FileHash file.iso -Algorithm SHA256   # PowerShell (imprime em maiúsculas)
certutil -hashfile file.iso SHA256        # Windows (imprime em maiúsculas)

Em hexadecimal, maiúsculas ou minúsculas não têm significado nenhum — o PowerShell e o certutil imprimem em maiúsculas, as ferramentas Unix em minúsculas, e é exatamente o mesmo valor. É por isso que a caixa de comparação desta ferramenta ignora as maiúsculas em hexadecimal. Com o Base64 é outra história: é uma codificação mais densa dos mesmos bytes, usada pelo Subresource Integrity e por várias APIs, e aí as maiúsculas contam — por isso a comparação é exata.

Um último hábito que vale a pena criar: nunca compare dois digests longos a olho para decidir se coincidem. O olho humano é muito bom a ver aquilo que espera ver, e o fato de os primeiros e os últimos caracteres coincidirem não quer dizer nada. Cole o valor esperado e deixe a comparação ser exata.