Ferramentas de Desenvolvimento

Gerador de Hash e Soma de Verificação

Obtenha MD5, SHA-1, SHA-256, SHA-384 e SHA-512 para texto e arquivos de uma vez. Verifique um arquivo baixado contra sua soma de verificação oficial para garantir que ele não foi adulterado. Tudo local, nada sai do seu navegador.

5 algoritmos de uma vez Soma de verificação para texto + arquivo Local, sem envio Resultados instantâneos

Algoritmos: MD5 · SHA-1/256/384/512
Motor: Web Crypto API
Privacidade: 100% local
Entrada: Texto · arquivo

Caracteres Bytes UTF-8

Resultados do hash

Cole a soma de verificação oficial para verificar

Aprovado: o arquivo corresponde exatamente à soma de verificação oficial. Seguro para usar.

Reprovado: o arquivo difere da soma de verificação oficial — pode estar corrompido ou adulterado. Não execute-o.

Uma soma de verificação só pode conter caracteres hexadecimais (0-9, a-f). Verifique o que você copiou.

O comprimento deve ser 32 (MD5), 40 (SHA-1), 64 (SHA-256), 96 (SHA-384) ou 128 (SHA-512) caracteres — certifique-se de que todo o valor foi copiado.

CARACTERÍSTICAS

Todos os cinco hashes em uma página

De impressões rápidas a assinaturas seguras — todos os hashes que desenvolvedores, equipes de operações e verificação de download precisam.

Cinco algoritmos

MD5, SHA-1, SHA-256, SHA-384 e SHA-512 exibidos juntos com o comprimento em bits da saída — sem mais alternar entre ferramentas.

Computação em tempo real

Hashes de texto conforme você digita, sem botão para pressionar. Resultados em espaçamento fixo — clique em uma linha para copiar.

Verificação de integridade de arquivo

Arraste um instalador, imagem de disco ou arquivo compactado e compare-o com a soma de verificação oficial para confirmar um download não adulterado.

Local, sem envio

A família SHA usa a Web Crypto API integrada do navegador. Texto e arquivos nunca saem da sua máquina — conteúdo sensível está seguro.

Consistente com UTF-8

O texto é transformado em hash como bytes UTF-8, portanto os resultados correspondem exatamente ao md5sum, à função md5() do PHP e ao hashlib do Python.

Copiar com um clique

Copie cada hash individualmente ou todos no formato de soma de verificação padrão, pronto para ser colado em um terminal.

O que você deve saber sobre hashes

A ideia é simples, mas usar o algoritmo errado para uma tarefa equivocada é um erro real de segurança.

O que exatamente são MD5 e SHA-1?

O MD5 (Message-Digest Algorithm 5) foi criado por Ronald Rivest no MIT e publicado em 1992 como RFC 1321, gerando um resumo de 128 bits fixo (32 caracteres hexadecimais) como sucessor do MD4. O SHA-1 foi desenvolvido pela Agência de Segurança Nacional dos EUA e publicado em 1995 como padrão federal FIPS 180-1, gerando 160 bits. Ambos se tornaram os algoritmos de hash mais amplamente implementados nas duas décadas seguintes — usados para somas de verificação de arquivos, armazenamento de senhas, assinaturas digitais e IDs de commit do Git. Observe que eles ainda geram resumos corretos hoje; "inseguro" significa que sua resistência a colisões foi comprometida, não que sua saída esteja errada.

Hashing, criptografia e codificação são a mesma coisa?

Não — eles resolvem problemas diferentes. A codificação (como Base64 ou codificação de URL) é uma transformação de formato reversível que qualquer pessoa pode reverter, sem oferecer segurança. A criptografia é reversível com uma chave: o texto simples se torna texto cifrado e a chave correta descriptografa-o. O hashing é unidirecional, não tem chave e o original não pode ser recuperado a partir do resumo — ele é usado para impressões digitais, verificações de integridade e assinaturas. Dois equívocos comuns: tratar o Base64 como "criptografia" e dizer que uma senha foi "criptografada com MD5" — isso é hashing, e ainda uma forma insegura de armazenar senhas.

Por que um hash não pode ser revertido para o original?

Um hash é uma função unidirecional: a entrada de qualquer tamanho é compactada em um resumo de comprimento fixo, eliminando a maior parte da informação. Assim como você não pode reconstruir uma frase a partir da contagem de suas palavras, o original não pode ser derivado do resumo. Algoritmos seguros são projetados especificamente para tornar essa reversão computacionalmente inviável.

MD5 e SHA-1 ainda são utilizáveis?

Para verificar se um arquivo foi corrompido acidentalmente durante o transporte — sim, qualquer alteração de byte aleatório praticamente sempre altera o MD5. Mas nunca para segurança: ataques de colisão práticos existem para ambos (pesquisadores podem criar dois arquivos diferentes com o mesmo MD5 sob seu controle). Use SHA-256 ou superior para senhas, assinaturas e certificados.

Por que meu hash difere de outra ferramenta para o mesmo texto?

Três causas comuns: ① codificação de caracteres diferente (esta ferramenta sempre usa UTF-8; ferramentas antigas podem usar GBK ou Latin-1); ② uma quebra de linha final — o comando echo adiciona uma por padrão (use echo -n); ③ um espaço aleatório ou caractere invisível ao copiar. Hashes são sensíveis a cada byte individual, portanto um byte a menos altera completamente o resultado.

Por que senhas não podem ser armazenadas como MD5/SHA-256 em texto simples?

Hashes comuns são rápidos. Com uma tabela hash vazada, os atacantes podem testar bilhões de suposições por segundo, e as tabelas arco-íris fazem consulta reversa de senhas comuns instantaneamente. Senhas precisam de algoritmos deliberadamente lentos que exigem muita memória (bcrypt, scrypt, Argon2) com um salt exclusivo por senha, tornando a força bruta proibitivamente cara.

Como eu verifico a integridade de um arquivo baixado?

Encontre o checksum publicado no site oficial (geralmente SHA-256), arraste o arquivo baixado para a aba "Checksum do arquivo" aqui e cole o valor oficial na caixa acima dos resultados. A ferramenta detecta o algoritmo pelo comprimento do valor e marca a linha correspondente de verde se os bytes do arquivo forem exatamente os divulgados pelo editor; vermelho significa corrupção ou substituição por meio de ataque man-in-the-middle — não execute o arquivo.

Qual dos cinco algoritmos usar

Escolha conforme o cenário. Algoritmos mais recentes produzem resumos mais longos, resistem melhor a ataques e têm custo de processamento ligeiramente maior.

Algoritmo	Introduzido	Comprimento da saída	Segurança	Uso típico
MD5	1992	128 bits (32 caracteres)	Quebrado; colisões são práticas	Impressões digitais não relacionadas à segurança, desduplicação, compatibilidade com sistemas legados
SHA-1	1995	160 bits (40 caracteres)	Colisões são práticas desde 2017	IDs de histórico do Git e outros sistemas legados; não para novos usos relacionados à segurança
SHA-256	2001	256 bits (64 caracteres)	Seguro hoje	Checksums de arquivo, assinaturas, certificados TLS, blockchains — o padrão universal
SHA-384	2001	384 bits (96 caracteres)	Seguro	SHA-512 truncado para regimes de conformidade que exigem 384 bits
SHA-512	2001	512 bits (128 caracteres)	Seguro	Assinaturas de alta confiabilidade; frequentemente mais rápido que o SHA-256 em CPUs de 64 bits

"Seguro" significa que não há ataque de colisão público prático até o momento. Para armazenamento de senhas, use bcrypt/Argon2 independentemente da escolha do hash.

Checksums: como verificar efetivamente um arquivo baixado

Para que serve aquela string MD5 ou SHA-256 em uma página de download, como compará-la e com o que compará-la — tudo em uma seção.

Por que verificar tudo

O arquivo no seu disco não é necessariamente o mesmo arquivo no servidor. Uma comparação de checksum de dez segundos protege contra três tipos de problemas:

Corrupção durante o tráfego

Arquivos grandes em downloads retomáveis e redes instáveis recebem bytes estranhos com surprequência; solucionar problemas de um instalador quebrado leva muito mais tempo do que dez segundos.

Espelhos desatualizados

Muitos downloads vêm na verdade de espelhos ou CDNs, onde atrasos de sincronização ou falhas de cache podem entregar uma versão desatualizada — ou um arquivo incompleto.

Manipulação deliberada

Quando uma fonte de download é invadida ou uma rede pública é sequestrada, arquivos podem ser incorporados com backdoors. Em 2016, o site do Linux Mint foi hackeado e seus links de download foram trocados por um ISO com backdoor — a primeira resposta do projeto foi pedir a todos para verificar o checksum.

O que é um checksum

O publicador aplica um hash ao arquivo no servidor e disponibiliza o resultado na página de download; após o download, você aplica o hash novamente localmente. Se as duas strings coincidirem caractere por caractere, os bytes do arquivo correspondem exatamente ao que o publicador disponibilizou — não há corrupção nem alteração indevida. A verificação é sensível a cada byte: altere um único byte e o valor muda completamente. De forma geral, checksums também incluem esquemas mais simples como o CRC32, que apenas capturam corrupções acidentais, enquanto hashes criptográficos como MD5/SHA resistem também à falsificação deliberada.

Verifique um arquivo em três passos

1

Obtenha o checksum oficial

Na página de download, localize o valor MD5 / SHA-256 publicado (geralmente rotulado como "checksum" ou fornecido como arquivo complementar .sha256) e copie a string completa.
2

Arraste o arquivo e cole

Mude para a aba "Checksum do arquivo" acima, arraste o arquivo baixado e cole o checksum na caixa acima dos resultados.
3

Leia o resultado pela cor

A ferramenta detecta o algoritmo pelo comprimento do valor: verde significa que o arquivo coincide exatamente com a versão oficial e é seguro para uso; vermelho significa que pode estar corrompido ou adulterado — não execute-o.

Lendo checksums em sites oficiais

Páginas de download apresentam checksums em vários formatos, mas todos se resumem a dois elementos: o valor do hash e o nome do arquivo. Estes três padrões são os mais comuns — ao colar, pegue apenas a parte do hash (esta ferramenta ignora espaços e quebras de linha automaticamente):

# 1. Linha única: apenas o valor
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

# 2. Formato sha256sum: valor + dois espaços + nome do arquivo (um manifesto SHA256SUMS contém várias linhas desse tipo)
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a  ubuntu-24.04.iso

# 3. Formato BSD: Algoritmo (nome do arquivo) = valor
SHA256 (ubuntu-24.04.iso) = a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

MD5 ou SHA-256

Verifique o que o site oficial disponibilizar, mas se tiver escolha: MD5 é totalmente adequado contra corrupções acidentais durante a transmissão (qualquer alteração aleatória quase sempre modifica o MD5). Contra adulteração deliberada — software de segurança, certificados, pacotes assinados — você precisa do SHA-256 ou mais forte, pois ataques de colisão práticos permitem que invasores criem dois arquivos diferentes com o mesmo MD5. Essa história está contada na "história de segurança" abaixo.

Verificando diretamente pela linha de comando

No Linux e no macOS, as ferramentas de checksum aceitam a opção -c para verificar um manifesto inteiro automaticamente — sem comparação manual. Os comandos nativos do Windows apenas calculam o valor, que você deve comparar depois com a string oficial.

Ambiente	Comando de verificação
Linux	`sha256sum -c SHA256SUMS (verifica cada arquivo listado no manifesto)`
macOS	`shasum -a 256 -c checksum.txt`
Verificação rápida de valor único	`echo "valor-oficial nome-do-arquivo" \| sha256sum -c - (exibe OK em caso de sucesso)`
Windows	`Calcule com Get-FileHash <arquivo> -Algorithm SHA256, depois compare com o valor oficial`

Breve história de segurança: como o MD5 foi quebrado

O MD5 não falhou de um dia para o outro — desde a primeira brecha na academia até certificados falsificados em produção, levaram duas décadas.

1992

MD5 é publicado

Ronald Rivest lançou o MD5 na RFC 1321. Rápido, simples de implementar e sempre produzindo um resumo de 128 bits, rapidamente tornou-se o padrão de fato para somas de verificação de arquivos e armazenamento de senhas — e era considerado criptograficamente seguro.
2004

Equipe de Wang Xiaoyun revela colisões completas do MD5

Na CRYPTO 2004, uma equipe liderada pela matemática chinesa Wang Xiaoyun demonstrou um ataque de colisão completo no MD5 — construindo dois arquivos com conteúdos diferentes, mas o mesmo hash (inicialmente em cerca de uma hora em um supercomputador IBM P690; melhorias posteriores reduziram isso a segundos em hardware comum). A resistência à colisão prometida pelo MD5 havia desaparecido; a ovação de pé que se seguiu tornou-se um dos momentos mais famosos da criptografia.
2008

Certificados falsos atingem a internet real

Marc Stevens, Alexander Sotirov e outros usaram uma colisão com prefixo escolhido para forjar um certificado de autoridade de certificação intermediária confiável por navegadores: certificados com prefixos diferentes carregavam a mesma assinatura. Um atacante agora poderia emitir certificados HTTPS "válidos" para qualquer site falso. As autoridades de certificação pararam de emitir certificados MD5 logo depois.
2012

Malware Flame ataca Windows via MD5

O malware Flame, patrocinado por estados, usou uma colisão MD5 para fazer com que a autoridade de licenciamento de terminal-server da Microsoft assinasse um certificado de código-signing falsificado, permitindo que ele se espalhasse pelo Oriente Médio disfarçado de uma atualização assinada pela Microsoft. Foi o primeiro ataque no mundo real usando uma colisão MD5; a Microsoft revogou o certificado em um patch de emergência.
2017

SHAttered: SHA-1 cai

O Google e o instituto holandês CWI (Marc Stevens et al.) publicaram dois arquivos PDF diferentes com o mesmo hash SHA-1 — a um custo de aproximadamente 6.500 anos de CPU e 110 anos de GPU. Os navegadores removeram a confiança nos certificados SHA-1 logo depois, e as plataformas Git aceleraram sua migração para longe dele. A era de 160 bits havia terminado.

Nuance importante: um ataque de colisão não "quebra" o hash de nenhum arquivo existente — ele constrói dois arquivos específicos que possuem o mesmo valor de hash. Mas para assinaturas e certificados, isso já é suficiente para uma falsificação fatal.

Hashing via linha de comando

Quando um navegador não está disponível, todo SO vem com um comando nativo (SHA-256 mostrado).

Ambiente	Comando
Linux / macOS	`sha256sum nome_do_arquivo (no macOS: shasum -a 256 nome_do_arquivo)`
Windows PowerShell	`Get-FileHash nome_do_arquivo -Algorithm SHA256`
Windows CMD	`certutil -hashfile nome_do_arquivo SHA256`

Hashing em código

Exemplos mínimos em quatro linguagens comuns ao escrever scripts ou integrar APIs.

JavaScript

async function sha256Hex(data) {
  const bytes = typeof data === "string"
    ? new TextEncoder().encode(data)
    : new Uint8Array(data);
  const digest = await crypto.subtle.digest("SHA-256", bytes);
  return [...new Uint8Array(digest)]
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("");
}

// Text
console.log(await sha256Hex("hello"));

// Files: digest accepts an ArrayBuffer directly
const buf = await file.arrayBuffer();
console.log(await sha256Hex(buf));

A Web Crypto nativa do navegador só suporta a família SHA e requer HTTPS ou localhost; o MD5 precisa de uma biblioteca terceirizada.

PHP

echo hash('sha256', 'hello');        // 64 hex characters
echo md5('hello');                   // same as hash('md5', 'hello')

// Streamed: hashes the file without loading it into memory
echo hash_file('sha256', 'setup.exe');

hash() e hash_file() suportam md5, sha1, sha256, sha512 e mais; o hash de arquivos é feito em fluxo, então usa pouca memória.

Python

import hashlib

print(hashlib.sha256(b"hello").hexdigest())
print(hashlib.md5(b"hello").hexdigest())

# Large files: streamed, low memory (Python 3.11+)
with open("setup.exe", "rb") as f:
    print(hashlib.file_digest(f, "sha256").hexdigest())

A biblioteca padrão hashlib não precisa de instalação; use file_digest() para hashes de fluxo de arquivos grandes (Python 3.11+).

Rust

use sha2::{Digest, Sha256};
use md5::Md5;

// Text
println!("{:x}", Sha256::digest(b"hello"));
println!("{:x}", Md5::digest(b"hello"));

// Large files: streamed, low memory
let mut file = std::fs::File::open("setup.exe")?;
let mut hasher = Sha256::new();
std::io::copy(&mut file, &mut hasher)?;
println!("{:x}", hasher.finalize());

Hashing não está na biblioteca padrão; adicione as crates RustCrypto sha2 e md-5 no Cargo.toml. Com o recurso std ativado, io::copy transfere arquivos para o hasher em fluxo.

FAQ

Meus textos e arquivos foram carregados?

Não. Tudo é calculado dentro do seu navegador: as funções da família SHA chamam a API Web Crypto integrada, e o MD5 é executado no JavaScript da página. A ferramenta continua funcionando mesmo sem rede — experimente com um arquivo sensível.

Por que o texto vazio ainda tem um hash?

Os algoritmos de hash definem uma saída fixa exclusiva mesmo para zero bytes. O MD5 de uma string vazia é d41d8cd98f00b204e9800998ecf8427e e seu SHA-256 começa com e3b0c442. Esta ferramenta simplesmente oculta os resultados quando a entrada está vazia para que você não os copie por engano.

Ele consegue gerar hashes para arquivos de qualquer tamanho?

Depende da memória disponível no navegador — instaladores e imagens de disco de algumas centenas de MB geralmente funcionam bem. Os arquivos são carregados na memória de uma só vez, então para arquivos de vários GB, prefira ferramentas de linha de comando (sha256sum, certutil).

Por que os hashes têm tamanhos diferentes?

O tamanho é determinado pelo algoritmo: MD5 tem 32 caracteres hexadecimais, SHA-1 tem 40, SHA-256 tem 64 e SHA-512 tem 128. Dois caracteres hexadecimais por byte — e o tamanho é independente do tamanho da entrada: um arquivo de um byte e um arquivo de vários GB geram 64 caracteres com SHA-256.

Posso usá-lo para criar assinaturas de API?

Sim. Muitas plataformas abertas assinam solicitações ao gerar hash de "parâmetros + segredo" com MD5 ou SHA-256. Esta ferramenta é ótima para verificar um valor de assinatura durante a depuração; em produção, calcule os hashes na biblioteca da sua linguagem do lado do servidor e nunca incorpore o segredo no código do frontend.

Como comparar um checksum com esta ferramenta?

Mude para a aba "Checksum de arquivo", arraste e solte o arquivo e cole o checksum do site oficial na caixa acima dos resultados. A ferramenta detecta automaticamente o algoritmo pelo tamanho (32 caracteres MD5, 40 SHA-1, 64 SHA-256, 96 SHA-384, 128 SHA-512): a linha correspondente fica verde com a nota "Passed" quando eles coincidem e vermelha quando não coincidem. Maiúsculas/minúsculas, espaços ao redor e quebras de linha são ignorados automaticamente.

Ferramentas relacionadas

Outras ferramentas de codificação, criptografia e senhas.

Codificar/Decodificar Base64

Converta entre binário e texto — útil para Data URIs e depuração de autenticação básica HTTP.

Gerador de senhas

Gere senhas fortes e aleatórias — senhas devem ser aleatórias e exclusivas, não "criptografadas" com um hash.

Verificador de força de senha

Verifica se uma senha é longa e aleatória o suficiente e se já apareceu em vazamentos conhecidos.

Arraste um arquivo aqui ou clique para procurar