ToolActToolAct

Ferramenta de Verificação de Hash de Arquivo

Calcule hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512 para arquivos

Upload de Arquivo

Arraste e solte arquivo aqui

Suporta qualquer tipo e tamanho de arquivo

Selecione Algoritmo de Hash
MD5
128 bits
SHA-1
160 bits
SHA-256
256 bits
SHA-384
384 bits
SHA-512
512 bits
Verificar Checksum

O que é Hash de Arquivo?

Um hash de arquivo transforma o conteúdo de um arquivo em uma assinatura de tamanho fixo usando um algoritmo escolhido. O mesmo arquivo gera sempre o mesmo valor, enquanto uma mudança de apenas um byte pode produzir um resultado totalmente diferente. Hashes são úteis para verificar downloads, comparar backups, detectar duplicados, checar integridade após transferência e confrontar checksums publicados em releases ou alertas de segurança. A ferramenta suporta MD5, SHA-1, SHA-256, SHA-384 e SHA-512. MD5 e SHA-1 ainda aparecem em fluxos antigos, mas não são adequados para garantias modernas de segurança; para integridade, SHA-256 ou superior costuma ser melhor. Um hash não pode ser revertido para o arquivo original.

Como Usar

Como usar

  1. Arraste um arquivo para a área de upload ou clique no botão 'Selecionar Arquivo'
  2. Marque os algoritmos de hash que deseja calcular (seleção múltipla)
  3. Clique no botão 'Calcular Hash' para começar
  4. Após o cálculo, copie os valores de hash individualmente ou todos de uma vez
  5. Para verificação, insira um valor de hash conhecido no campo de comparação

Fluxo de Verificação

  • Calcule o hash após o arquivo ser totalmente baixado ou copiado; arquivos parciais e interrupções na transferência geram valores diferentes.
  • Ao comparar com um checksum publicado, copie-o da fonte oficial e use exatamente o mesmo algoritmo.

Casos de uso

Calcular vários resumos de arquivo a partir de um único uploadSolte um arquivo e escolha MD5 (128 bits), SHA-1 (160 bits), SHA-256 (256 bits), SHA-384 (384 bits) e SHA-512 (512 bits) em qualquer combinação para gerar hashes localmente com feedback de progresso. O arquivo é lido na memória e passado para crypto.subtle.digest (família SHA) ou para uma rotina MD5 em JavaScript dentro do navegador, então o conteúdo binário nunca sai do dispositivo e é adequado para firmware proprietário, builds internos ou artefatos não publicados.
Verificar um checksum publicado contra os algoritmos selecionadosCole um hash esperado antes ou depois do cálculo e a página identificará um algoritmo correspondente quando um dos valores gerados for igual à string de comparação. A correspondência é feita em hex normalizado minúsculo, então um digest maiúsculo do editor e um digest minúsculo gerado localmente se alinham sem necessidade de redigitar manualmente.
Usar hashes mais fortes para decisões de confiançaMD5 e SHA-1 são úteis para verificações legadas e detecção de duplicados (ambos têm ataques de colisão publicados), mas SHA-256 ou superior é a escolha mais segura para verificação de downloads e evidência de adulteração. SHA-256 produz um digest hex de 64 caracteres sem colisões conhecidas, e SHA-384/512 elevam ainda mais o nível para pipelines de release de alta confiança. Para artefatos de release muito grandes, BLAKE3 é cada vez mais comum por ser cerca de três a quatro vezes mais rápido que SHA-256 em CPUs modernas (vazão sustentada na faixa de GB/s), mantendo um design de árvore Merkle que suporta leituras em streaming verificadas, embora os seletores por algoritmo desta ferramenta ainda cubram a família SHA que a maioria dos editores publica.
Gerar hash de cada parte de um arquivo dividido separadamenteDownloads grandes muitas vezes chegam como pedaços .001, .002 ou .zipx com um hash por parte (geralmente SHA-1 ou SHA-256). Faça o hash de cada parte contra a lista publicada pelo fornecedor antes de unir, porque uma única peça incompatível quebra o arquivo remontado — esta página permite rodar o mesmo algoritmo em todas as partes sem enviá-las. Cada parte é lida na memória do navegador antes do hash, então o teto prático é o que a heap da aba consegue conter; para partes que excedam esse limite, recorra a uma ferramenta de desktop (sha256sum, certutil -hashfile, Get-FileHash) que faça streaming a partir do disco.
Usar o campo de comparação para correspondências sem diferenciar maiúsculasAlguns editores publicam hex em maiúsculas, outros em minúsculas. Cole o valor esperado uma vez e a página faz a correspondência por identidade de algoritmo e caso normalizado, então não é necessário redigitar manualmente cada maiúscula e minúscula para uma verificação limpa — o mesmo digest em 'A591A6...' e 'a591a6...' produz uma correspondência bem-sucedida.

Princípio técnico

Todos os digests SHA da página passam pela W3C Web Cryptography API, exposta no navegador como crypto.subtle. A chamada é await crypto.subtle.digest(algorithm, buffer), onde algorithm é 'SHA-1', 'SHA-256', 'SHA-384' ou 'SHA-512' (sensível a maiúsculas) e buffer é um ArrayBuffer ou qualquer TypedArray. A função retorna uma Promise que resolve em um ArrayBuffer com os bytes do digest, que a página converte para hex minúsculo percorrendo-o como Uint8Array e mapeando cada byte para byte.toString(16).padStart(2, '0'). SubtleCrypto só está disponível em contextos seguros (HTTPS ou localhost); SHA-1 permanece disponível para verificação legada, embora a spec já o classifique como quebrado em resistência a colisões. MD5 não está na especificação Web Crypto (o W3C omitiu de propósito por causa dos ataques de colisão), então o MD5 desta página é calculado por uma implementação em JavaScript puro que roda inteiramente no navegador. Para todos os algoritmos — MD5 e a família SHA — o arquivo é lido como ArrayBuffer de uma vez via FileReader.readAsArrayBuffer e entregue à rotina MD5 em JavaScript ou ao crypto.subtle.digest. Esta ferramenta não oferece API incremental .append nem fallback para Web Worker, então a memória precisa caber o arquivo inteiro de uma só vez: tudo bem para downloads típicos, mas não ideal para cargas de vários GB; nesses casos uma ferramenta de desktop que faça streaming a partir do disco (sha256sum, certutil -hashfile, Get-FileHash) é mais adequada. Tamanhos de digest e postura de segurança: MD5 = 128 bits / 32 caracteres hex (RFC 1321, resistência a colisões quebrada desde Wang Xiaoyun em 2004, explorado em produção pelo malware Flame em 2012); SHA-1 = 160 bits / 40 caracteres hex (FIPS 180-4, colisão demonstrada pelo SHAttered da Google em 2017 com ~9,2 × 10^18 cálculos SHA-1, NIST planeja descontinuação formal após 2030); SHA-256 = 256 bits / 64 caracteres hex (FIPS 180-4, sem colisões conhecidas, baseline recomendada); SHA-384 e SHA-512 = 384 / 512 bits, saída truncada e completa da família SHA-512 (FIPS 180-4). O efeito avalanche dos hashes criptográficos faz com que inverter um único bit de entrada mude cerca de metade dos bits de saída em média, por isso editar um byte produz um digest completamente diferente.

  • crypto.subtle.digest(algorithm, buffer) aceita 'SHA-1', 'SHA-256', 'SHA-384', 'SHA-512' (diferencia maiúsculas) e rejeita 'MD5'; requer um contexto seguro (HTTPS ou localhost) e retorna uma Promise<ArrayBuffer>.
  • Codificação hex: percorra o resultado como new Uint8Array(digestBuffer) e mapeie cada byte para byte.toString(16).padStart(2, '0'); compare resumos sem diferenciar maiúsculas (normalize via .toLowerCase()).
  • MD5 está propositadamente ausente do Web Crypto; esta ferramenta calcula MD5 em JavaScript puro, lendo o arquivo como um único ArrayBuffer via FileReader.readAsArrayBuffer e produzindo um digest hex minúsculo de 32 caracteres em uma só passagem.
  • Perfil de memória: a página lê o arquivo inteiro em um único ArrayBuffer (sem API incremental .append e sem descarga para Web Worker) e passa o buffer em uma única chamada para o MD5 em JavaScript ou para crypto.subtle.digest. Para arquivos que excedem a heap disponível da aba, mude para uma ferramenta de desktop (sha256sum, certutil -hashfile, Get-FileHash) que faça streaming a partir do disco.
  • Tamanhos dos resumos (FIPS 180-4): MD5 128-bit, SHA-1 160-bit, SHA-256 256-bit, SHA-384 384-bit, SHA-512 512-bit; a contagem de caracteres hex é o dobro da contagem de bytes.
  • Ataques de colisão conhecidos: MD5 quebrado por Wang 2004, explorado pelo Flame 2012; SHA-1 quebrado pelo SHAttered do Google 2017 (~9,2 × 10^18 ops, ~110 GPU-anos); SHA-256 e acima não possuem colisões práticas conhecidas.
  • Efeito avalanche: uma mudança de um único bit de entrada inverte ~50% dos bits de saída em média; é por isso que a edição de um único byte produz um digest hex completamente diferente e por que correspondências parciais de arquivo não existem.

Exemplos

Verificar um arquivo baixado contra um checksum publicado

Arquivo: sample.bin (3 bytes, conteúdo: abc)

SHA-256 (calculado):
  ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Linha SHA256SUMS publicada pelo fornecedor:
  ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad  sample.bin

Corresponde -> download íntegro, sem adulteração

(Ambos os valores são o vetor de referência SHA-256 do FIPS 180-2 para
a entrada de 3 bytes 'abc'. Substitua a entrada pelo arquivo real na
prática; a saída do algoritmo é determinística.)

Comparação de múltiplos algoritmos sobre a mesma entrada

Arquivo: sample.txt (3 bytes, conteúdo: abc)

MD5:     900150983cd24fb0d6963f7d28e17f72
SHA-1:   a9993e364706816aba3e25717850c26c9cd0d89d
SHA-256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-512: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f

Algoritmos diferentes, mesma entrada -> use SHA-256 ou superior para verificações de segurança

(MD5 é o vetor de referência da RFC 1321; os outros são vetores
de referência do FIPS 180-2, todos para a entrada de 3 bytes 'abc'.)

Detectar uma mudança de 1 byte (efeito avalanche)

Entrada A: abc  (3 bytes)
Entrada B: abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq  (56 bytes)

SHA-256 de A: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-256 de B: 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1

Uma pequena mudança na entrada produz um digest completamente
diferente -> esse é o efeito avalanche em ação.

(Ambos os valores são vetores de referência SHA-256 do FIPS 180-2.)

Referência no console do navegador para verificação

// Reproduzir no Node.js para comparação
$ printf 'abc' | shasum -a 256
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

// PowerShell no Windows
PS> 'abc' | Get-FileHash -Algorithm SHA256 | Select-Object -ExpandProperty Hash
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

// No console do navegador, usando a Web Crypto API:
// const buf = new TextEncoder().encode('abc');
// const hash = await crypto.subtle.digest('SHA-256', buf);
// -> ArrayBuffer do SHA-256 de 'abc' (vetor de referência FIPS 180-2)

Os arquivos permanecem no seu navegador, nada é enviado.

Perguntas frequentes

Quais algoritmos de hash posso gerar?

As opções comuns são MD5, SHA-1, SHA-224, SHA-256, SHA-384 e SHA-512. A página os calcula via Web Crypto API do navegador (família SHA) e JS embutido para MD5. Hoje, SHA-256 é a escolha geral recomendada.

O arquivo é enviado para algum lugar?

Não. O hash acontece inteiramente no seu navegador usando a File API e a Web Crypto. Os bytes são lidos para a memória em pedaços e o hash é calculado localmente — o arquivo não trafega pela rede. Você pode confirmar olhando a aba Network enquanto gera o hash.

Por que o MD5 ainda está disponível se ele está quebrado?

MD5 está quebrado para fins de segurança (colisões são fáceis de construir), mas continua sendo o checksum de fato para verificar se um download é idêntico bit a bit ao original — muitos fornecedores ainda publicam MD5 ao lado de SHA-256. Use MD5 só para isso, nunca para hashing de senhas ou assinaturas.

Por que meus hashes SHA-256 são diferentes para o mesmo arquivo aparente?

O hash inclui todos os bytes, então uma única quebra de linha no final, um BOM, ou uma quebra de linha diferente (CRLF vs LF) muda o hash por completo. Baixe o original de novo em vez de copiar e colar, ou use um visualizador binário para confirmar que os dois arquivos têm bytes idênticos.

Existe um limite de tamanho de arquivo?

O navegador precisa ter memória suficiente para ler o arquivo. Desktops modernos lidam com arquivos de vários GB, mas navegadores em celular podem ficar sem memória por volta de algumas centenas de MB. Para arquivos muito grandes, use uma ferramenta de desktop (sha256sum, certutil, Get-FileHash) — ela faz streaming do disco e é mais rápida.

Dois arquivos diferentes podem ter o mesmo hash?

Em teoria sim (princípio da casa dos pombos), mas para SHA-256 a chance é astronomicamente baixa. MD5 e SHA-1 têm ataques de colisão conhecidos, então dois arquivos com o mesmo MD5 ou SHA-1 não provam que são o mesmo arquivo. Colisões em SHA-256 não são viáveis com os ataques conhecidos.

Por que meus hashes são diferentes do hash publicado no site?

Na maioria das vezes: você baixou uma versão localizada, assinada ou reempacotada; a página lista o hash de uma versão diferente; ou o download foi truncado. Baixe de novo com uma ferramenta nova e gere o hash novamente. Se a divergência continuar, não confie no arquivo.