MD5, SHA-256, SHA-512: gerador de hash gratuito e quando usar cada um

Toda vez que você baixa uma versão de software, verifica a autenticidade de um arquivo, assina um token JWT ou armazena a senha de um usuário, uma função de hash criptográfico está trabalhando nos bastidores. As funções de hash são uma das primitivas fundamentais da segurança computacional moderna — e, ainda assim, as diferenças entre MD5, SHA-1, SHA-256 e SHA-512 são amplamente mal compreendidas, levando a erros de segurança reais em sistemas de produção.

Este guia explica o que são as funções de hash, como cada algoritmo principal funciona, quando cada um é apropriado (e quando é perigosamente inapropriado) e como usar o Gerador de Hash do BrowseryTools para calcular hashes instantaneamente no seu navegador com total privacidade.

O que é uma função de hash criptográfico?

Uma função de hash criptográfico recebe uma entrada de comprimento arbitrário e produz uma saída de comprimento fixo chamada de digest ou hash. Quatro propriedades definem uma boa função de hash criptográfico:

• Determinística: A mesma entrada sempre produz exatamente a mesma saída. As funções de hash não têm estado interno — dados os mesmos bytes, você sempre obtém o mesmo digest.
• De mão única (resistência à pré-imagem): Dada uma saída de hash, deve ser computacionalmente inviável recuperar a entrada original. As funções de hash são projetadas para serem fáceis de calcular em uma direção e efetivamente impossíveis de reverter.
• Comprimento de saída fixo: Independentemente de a entrada ter um byte ou um gigabyte, a saída tem sempre o mesmo comprimento. O SHA-256 sempre produz um digest de 256 bits (32 bytes).
• Efeito avalanche: Uma mudança de um único bit na entrada transforma completamente a saída. O hash de hello não se parece em nada com o hash de hello! — eles compartilham zero estrutura previsível. Isso torna os hashes úteis como impressões digitais.

Uma quinta propriedade — a resistência a colisões — separa os hashes criptograficamente fortes dos quebrados: deve ser computacionalmente inviável encontrar duas entradas diferentes que produzam a mesma saída. É aqui que o MD5 e o SHA-1 falharam.

MD5: rápido, onipresente e quebrado para segurança

O MD5 (Message Digest 5) foi projetado por Ron Rivest e publicado em 1991. Ele produz um digest de 128 bits (16 bytes), tipicamente representado como uma string hexadecimal de 32 caracteres, como 5d41402abc4b2a76b9719d911017c592. Por mais de uma década, foi o algoritmo de hash dominante para tudo, de checksums de arquivos a armazenamento de senhas.

Em 2004, criptógrafos demonstraram ataques de colisão práticos contra o MD5. Em 2008, pesquisadores haviam usado ataques de colisão para forjar um certificado de autoridade certificadora falso, confiável por todos os principais navegadores. O MD5 está agora definitivamente quebrado para qualquer propósito de segurança em que a resistência a colisões importe.

Onde o MD5 ainda é aceitável:

• Verificações de integridade de arquivos sem fins de segurança, em que você controla tanto a geração quanto a verificação (confirmar que um arquivo não foi corrompido em trânsito, não que ele não foi adulterado).
• Checksums em sistemas internos em que um agente mal-intencionado não está no modelo de ameaças.
• Compatibilidade com sistemas legados, onde você não tem escolha a não ser corresponder a uma implementação existente.
• Chaves de cache e mapas de hash, em que a segurança é irrelevante e a velocidade importa.

Onde o MD5 nunca deve ser usado: certificados TLS, assinaturas digitais, assinatura de código ou qualquer coisa em que um atacante possa se beneficiar de encontrar uma colisão.

SHA-1: 160 bits, descontinuado, ainda em toda parte

O SHA-1 (Secure Hash Algorithm 1) foi publicado pelo NIST em 1995 e produz um digest de 160 bits. Foi o padrão para certificados TLS, assinaturas digitais e assinatura de software ao longo dos anos 2000. O Project Zero do Google demonstrou uma colisão prática de SHA-1 em 2017 (o ataque SHAttered), produzindo dois arquivos PDF diferentes com hashes SHA-1 idênticos. Isso encerrou o uso do SHA-1 em TLS — todos os principais fornecedores de navegadores pararam de aceitar certificados SHA-1 naquele mesmo ano.

O SHA-1 ainda é encontrado em alguns lugares notáveis:

• Git: O Git historicamente usou o SHA-1 para identificar cada objeto em um repositório — commits, blobs, trees e tags. O Git está migrando ativamente para o SHA-256 (veja abaixo), mas repositórios Git em SHA-1 continuam extremamente comuns. Para esse caso de uso, a resistência a colisões importa menos porque um atacante precisaria de acesso ao sistema de arquivos para explorar uma colisão.
• Sistemas de autenticação legados e implementações de HMAC mais antigas.
• Alguns softwares corporativos mais antigos que não foram atualizados.

Para qualquer trabalho novo: evite o SHA-1. Use SHA-256 ou SHA-512.

SHA-256: o padrão atual

O SHA-256 faz parte da família SHA-2, publicada pelo NIST em 2001. Ele produz um digest de 256 bits (32 bytes) — o dobro do comprimento de saída do MD5 e 60% maior que o SHA-1. Nenhum ataque prático de colisão ou de pré-imagem contra o SHA-256 foi demonstrado. Ele continua sendo o padrão para hashing sensível à segurança em 2026.

O SHA-256 é usado em toda parte:

• Certificados TLS: O CA/Browser Forum determinou o SHA-256 como o mínimo para assinaturas de certificados. Toda conexão HTTPS que você faz é ancorada pelo SHA-256.
• Assinatura de código: O macOS, o Windows Authenticode e os gerenciadores de pacotes do Linux (APT, RPM) usam SHA-256 para verificar a integridade do software.
• Tokens JWT: O algoritmo HS256 nos JSON Web Tokens é HMAC-SHA-256. É de longe o algoritmo de assinatura de JWT mais comum em sistemas implantados.
• Bitcoin: O algoritmo de prova de trabalho do Bitcoin é o SHA-256 duplo (SHA-256 aplicado duas vezes).
• Git (próxima geração): O formato de objeto SHA-256 do Git (ativado com --object-format=sha256) usa SHA-256 para todos os IDs de objeto.
• Verificação de integridade de arquivos publicada junto aos downloads de software.

Se você precisa escolher uma função de hash e não tem restrições específicas, o SHA-256 é a escolha padrão correta em 2026.

SHA-512: saída maior, às vezes mais rápida

O SHA-512 também faz parte da família SHA-2 e produz um digest de 512 bits (64 bytes). Ele oferece uma margem de segurança maior do que o SHA-256 — 512 bits de saída significam que o espaço teórico do ataque de força bruta é 2²⁵⁶ vezes maior. Na prática, essa margem adicional é irrelevante para a maioria das aplicações, já que o SHA-256 já é computacionalmente inviável de quebrar.

A característica de desempenho contraintuitiva: o SHA-512 é mais rápido do que o SHA-256 em CPUs modernas de 64 bits ao gerar hash de grandes volumes de dados. O SHA-512 processa dados em blocos de 1024 bits com operações de palavra de 64 bits, enquanto o SHA-256 usa blocos de 512 bits com operações de 32 bits. Em um processador de 64 bits, as operações de 64 bits mapeiam de forma mais eficiente para o hardware. Isso torna o SHA-512 a escolha preferida para aplicações que geram hash de arquivos grandes em servidores de 64 bits.

Use o SHA-512 quando:

• Você está gerando hash de grandes volumes de dados em hardware de 64 bits e quer máxima taxa de transferência.
• Seu sistema exige a margem de segurança adicional por motivos regulatórios ou de conformidade.
• Você está implementando HMAC-SHA-512 (usado em algumas implementações de JWT com HS512).

Tabela de comparação de algoritmos

Verificação de integridade de arquivos: um exemplo prático

Um dos usos mais comuns e legítimos dos hashes criptográficos é verificar que um arquivo baixado é exatamente o que o publicador pretendia — não corrompido em trânsito e não adulterado por terceiros. A maioria dos grandes projetos de software publica checksums SHA-256 junto aos seus downloads.

O fluxo de trabalho se parece com isto:

• Baixe o arquivo da fonte oficial.
• Baixe o checksum publicado da mesma fonte oficial (idealmente assinado com PGP).
• Calcule o hash SHA-256 do arquivo baixado.
• Compare o hash que você calculou com o hash publicado, caractere por caractere. Qualquer diferença significa que o arquivo não é o que o publicador distribuiu.

O Gerador de Hash do BrowseryTools suporta hash de arquivos — arraste um arquivo e ele calculará o hash localmente no seu navegador sem enviar nada. Compare o resultado diretamente com o checksum publicado.

Armazenamento de senhas: a única coisa que os hashes não conseguem fazer com segurança

Como o Git usa o SHA-1 (e está migrando para o SHA-256)

O Git usa uma função de hash para identificar cada objeto em um repositório. Cada commit, arquivo (blob), listagem de diretório (tree) e tag é armazenado no banco de dados de objetos sob seu hash SHA-1. Quando você executa git log, as longas strings hexadecimais que você vê — como c206f4b3a9d72bc0e53a0e1a6e4bdf8c7f9d2e51 — são hashes SHA-1 dos objetos de commit.

O Git escolheu o SHA-1 em 2005 por velocidade e porque, na época, o SHA-1 não estava quebrado. O papel dos hashes no Git é ligeiramente diferente do uso tradicional de segurança: o Git os usa como chaves de armazenamento endereçáveis por conteúdo, não como provas de autenticação. O conteúdo em si é o que você confia — o hash é apenas uma forma eficiente de localizá-lo e detectar corrupção acidental.

Após a colisão SHAttered de SHA-1 em 2017, o projeto Git começou a trabalhar na transição para o SHA-256. O novo formato de objeto (--object-format=sha256) está disponível no Git 2.29+ e é usado por padrão em alguns novos provedores de hospedagem de repositórios. Repositórios existentes podem ser migrados, embora a transição seja complexa porque cada ID de objeto muda.

HMAC: autenticação de mensagens baseada em hash

Um hash simples verifica a integridade dos dados (os dados não mudaram), mas não a autenticidade (os dados vieram de quem você acha que vieram). Se um atacante puder interceptar uma mensagem e recalcular o hash após modificá-la, um hash simples não oferece proteção alguma.

O HMAC (Hash-based Message Authentication Code) resolve isso incorporando uma chave secreta ao cálculo do hash. O resultado só pode ser produzido por alguém que conheça a chave. Verificar um HMAC prova tanto que os dados estão intactos quanto que foram produzidos por uma parte com acesso ao segredo compartilhado.

O HMAC-SHA256 está em toda parte:

• Tokens JWT (HS256): O servidor assina o cabeçalho e o payload do token com HMAC-SHA256 usando uma chave secreta. Os clientes não conseguem forjar tokens válidos sem a chave.
• Assinatura de requisições de API: O AWS Signature Version 4 usa HMAC-SHA256 para autenticar requisições de API. Os detalhes da requisição e uma chave de assinatura derivada são processados em hash juntos, de modo que nenhum deles pode ser modificado sem invalidar a assinatura.
• Integridade de cookies: Muitos frameworks web usam HMAC para assinar cookies de sessão, impedindo que os usuários adulterem seus próprios dados de sessão.

Como usar o Gerador de Hash do BrowseryTools

O Gerador de Hash suporta a geração de hash tanto de entrada de texto quanto de uploads de arquivos inteiramente no seu navegador. Veja como funciona:

• Hash de texto: Cole qualquer texto no campo de entrada. A ferramenta calcula imediatamente e exibe o hash para cada algoritmo suportado simultaneamente — MD5, SHA-1, SHA-256 e SHA-512 — para que você possa compará-los lado a lado e escolher o que precisa.
• Hash de arquivos: Clique na entrada de arquivo ou arraste e solte qualquer arquivo. O arquivo é lido pela File API do seu navegador e tem o hash calculado localmente. Arquivos grandes são processados em pedaços para evitar pressão de memória. Nenhum byte do seu arquivo sai do seu dispositivo.
• Escolha o algoritmo: Selecione o algoritmo específico em que se concentrar para o seu caso de uso. O digest hexadecimal completo é exibido e pode ser copiado com um clique.
• Baixar como arquivo: Para fins de documentação ou distribuição, exporte o digest do hash como um arquivo de texto — útil para publicar checksums junto às suas próprias versões de software.

Privacidade: a Web Crypto API

Escolhendo o algoritmo certo: um guia de decisão

• Integridade de arquivos / checksums (sem fins de segurança): MD5 ou SHA-256. O SHA-256 é preferido para qualquer coisa voltada ao público, mesmo que o modelo de ameaças seja apenas a corrupção acidental, já que usar um algoritmo quebrado por escolha é difícil de justificar a auditores.
• TLS, assinatura de código, operações com certificados: SHA-256 (obrigatório — o SHA-1 é rejeitado).
• Assinatura de JWT: HMAC-SHA-256 (HS256) para simétrico, ou RS256/ES256 para assimétrico. Nunca MD5 ou SHA-1.
• Armazenamento de senhas: Argon2id, bcrypt ou scrypt. Nenhuma variante de SHA.
• Hash de arquivos grandes em servidores de 64 bits: SHA-512 para a melhor taxa de transferência.
• Margem máxima de segurança: SHA-512 ou SHA-3 (SHA3-256, SHA3-512).
• Compatibilidade com sistemas legados: O que o sistema legado exigir — mas planeje a migração para longe do MD5 e do SHA-1.