Calculadora de hash de arquivo gratuita
Calcule os hashes SHA-1, SHA-256, SHA-384, SHA-512 e MD5 para qualquer arquivo. Verifique a integridade do arquivo e detecte mudanças instantaneamente.
O que são realmente os hashes de ficheiros
Um hash criptográfico é uma impressão digital de comprimento fixo calculada a partir de dados de entrada arbitrários (um ficheiro, uma string, um fluxo de bytes) usando uma função matemática determinista. Cada entrada distinta produz uma saída diferente (com probabilidade de colisão desprezível para funções hash modernas); inverter um único bit em qualquer ponto de um ficheiro de vários gigabytes muda essencialmente cada bit do hash resultante. A função funciona apenas numa direcção: a partir da entrada pode calcular o hash trivialmente, mas recuperar a entrada a partir do hash é computacionalmente inviável para qualquer função hash decente. A saída tem sempre o mesmo comprimento fixo independentemente do tamanho da entrada, SHA-256 produz 256 bits (32 bytes, exibidos como 64 caracteres hex) quer a entrada seja um byte ou um terabyte. Três propriedades importam: resistência a pré-imagem (não pode fazer engenharia reversa de um ficheiro a partir do seu hash), resistência a segunda pré-imagem (não pode construir um ficheiro diferente com o mesmo hash) e resistência a colisões (não pode encontrar dois ficheiros distintos com hashes correspondentes). Este editor calcula o hash de qualquer ficheiro que fornecer usando a Web Crypto API incorporada ao navegador, especificamente SubtleCrypto.digest(), que está implementada nativamente em todo navegador moderno e corre na CPU do dispositivo em vez de carregar o ficheiro para algum lado.
Os algoritmos, uma breve história
Cinco algoritmos nesta ferramenta, por ordem cronológica de lançamento. MD5 (Message Digest 5, Ronald Rivest no MIT, RFC 1321 publicada em Abril de 1992) produz um hash de 128 bits e foi o hash de uso geral dominante dos anos 1990 e início dos 2000. Fraquezas criptográficas começaram a aparecer em 1996 (pseudo-colisão de Dobbertin); um ataque de colisão prático foi demonstrado por Xiaoyun Wang e Hongbo Yu em Agosto de 2004 na CRYPTO 2004, completado em menos de uma hora numa única máquina. Marc Stevens publicou um ataque de colisão de prefixo escolhido em 2008 que permitiu forjar certificados X.509 em colisão. MD5 está agora quebrado para qualquer fim criptográfico, nunca o use onde a resistência a colisões importa (assinaturas digitais, impressões digitais de certificado, hashing de palavras-passe). Continua útil para verificações de integridade não criptográficas (detecção de corrupção acidental por discos maus ou transferências de rede ruidosas) e para identificadores endereçáveis por conteúdo onde confia que a fonte não é maliciosa.
SHA-1 (Secure Hash Algorithm 1, desenhado pela NSA, publicado como FIPS 180-1 em Abril de 1995) produz um hash de 160 bits e foi o hash criptográfico dominante do final dos anos 1990 ao início dos 2010. Ataques teóricos foram propostos em 2005 por Wang, Yin e Yu. A primeira colisão SHA-1 prática foi publicada a 23 de Fevereiro de 2017 por uma equipa Google + CWI Amsterdam liderada por Marc Stevens (o ataque «SHAttered») usando cerca de 9 quintilhões de cálculos SHA-1 para produzir dois ficheiros PDF com hashes SHA-1 idênticos mas conteúdo visivelmente diferente. Os navegadores já tinham começado a abandonar progressivamente os certificados TLS SHA-1 nessa altura; o Git moderno está a migrar de SHA-1 para SHA-256 para a identidade de objectos. Como o MD5, o SHA-1 está bem para integridade não criptográfica mas nunca deve ser usado onde a resistência a colisões importa em 2026.
SHA-2 (NSA, FIPS 180-2 publicado em Agosto de 2002) é a família hash de trabalho actual, um conjunto de funções relacionadas incluindo SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 e SHA-512/256. SHA-256 produz hashes de 256 bits, SHA-384 produz hashes de 384 bits, SHA-512 produz hashes de 512 bits; 384 é essencialmente SHA-512 com saída truncada e um IV diferente. Não existem ataques práticos contra a família SHA-2 a partir de 2026; SHA-256 é a escolha por defeito para novas aplicações e é a função hash por trás do Bitcoin (tanto para mineração como para derivação de endereços), impressões digitais de certificados TLS, a migração planeada de identidade de objectos do Git, o hash de transacções do Ethereum, as assinaturas JWT HS256 e a maioria das somas de verificação de distribuição de software. SHA-512 é preferido quando 256 bits de saída não são suficientes ou quando quer o desempenho ligeiramente mais rápido em CPUs de 64 bits (as operações internas do SHA-512 são de 64 bits, contra os 32 bits do SHA-256, por isso processa mais dados por ciclo de CPU em hardware de 64 bits apesar da saída maior).
SHA-3 (Keccak, desenhado por Guido Bertoni, Joan Daemen, Michaël Peeters e Gilles Van Assche, vencedor do Concurso NIST SHA-3 em Outubro de 2012, padronizado como FIPS 202 em Agosto de 2015) é a apólice de seguro criptográfica: estruturalmente diferente do SHA-2 (construção em esponja em vez de Merkle-Damgård), por isso qualquer avanço que partisse o SHA-2 não partiria necessariamente o SHA-3. SHA-3 não está actualmente na lista de algoritmos desta ferramenta porque a Web Crypto API não o incluiu na spec original, os navegadores modernos podem adicioná-lo no futuro. A família SHA-2 é o predefinido recomendado para hashing do lado do navegador hoje.
Alternativas modernas para além do SHA-2
Duas famílias hash não-NIST ganharam tracção por razões de desempenho. BLAKE2 (Aumasson, Neves, Wilcox-O'Hearn, Winnerlein, Janeiro de 2013) é mais rápido que o SHA-2 com segurança comparável e é amplamente usado em criptomoeda, hashing de palavras-passe Argon2 e aplicações de alto desempenho onde a velocidade do SHA-2 é um gargalo. BLAKE3 (O'Connor, Aumasson, Neves, Wilcox-O'Hearn, Janeiro de 2020) é uma redesenho que é paralelizável através de muitos núcleos de CPU e ainda mais rápido, particularmente atractivo para fazer hash de ficheiros muito grandes porque o trabalho se divide pelos núcleos limpamente. Nenhum está no padrão Web Crypto API, por isso esta ferramenta fica com a família SHA-2 + MD5 + SHA-1 para compatibilidade; para hashing BLAKE3 em linha de comandos a implementação canónica é a ferramenta b3sum do repositório de referência BLAKE3. A escolha para hashing de ficheiros do lado do navegador em 2026 continua a ser SHA-256 a menos que haja uma razão específica para usar outra coisa, ampla compatibilidade, sem problemas de patente, acelerado por hardware na maioria das CPUs modernas (Intel SHA Extensions desde Goldmont 2016, instruções ARMv8 SHA-2 em essencialmente cada smartphone) e velocidade aceitável mesmo em ficheiros de vários gigabytes no navegador.
Quando os hashes de ficheiro ganham o seu sustento
- Verificar que um ficheiro descarregado corresponde à soma de verificação do publicador. As distribuições Linux (Ubuntu, Debian, Fedora, Arch), os projectos open-source (Node.js, Python, Go) e os downloads sensíveis à segurança (o navegador Tor, imagens de firmware assinadas) publicam hashes SHA-256 ao lado dos seus downloads. Após o download, faça hash do ficheiro localmente, compare com o valor publicado caracter a caracter, se corresponderem, o ficheiro chegou intacto e não é uma cópia alterada ou interrompida.
- Encontrar ficheiros duplicados. Ficheiros idênticos produzem sempre hashes idênticos independentemente do nome do ficheiro, localização ou marca temporal de modificação. Um fluxo de trabalho de desduplicação simples: faça hash de cada ficheiro numa árvore de directórios, agrupe por hash, qualquer coisa com múltiplos ficheiros no mesmo grupo é um duplicado. Ferramentas como
fdupesem Linux fazem exactamente isto com MD5 (aceitável aqui porque a desduplicação não depende da resistência criptográfica a colisões). - Detectar modificação de ficheiro. Faça hash de um ficheiro hoje, guarde o hash, faça hash novamente mais tarde, compare, qualquer diferença significa que o ficheiro mudou mesmo que num só bit. Usado por ferramentas de monitorização de integridade de ficheiros (Tripwire foi a original, 1992; OSSEC e Wazuh são descendentes modernos), sistemas de verificação de cópias de segurança e sincronização incremental estilo rsync.
- Armazenamento endereçável por conteúdo. O Git identifica cada blob, árvore e commit pelo seu hash SHA-1 (a migrar para SHA-256 nas próximas versões). O IPFS usa multihash. As camadas Docker são endereçadas pelo seu hash de conteúdo. Qualquer sistema onde «isto é o mesmo conteúdo» precisa de ser respondido de forma barata e fiável usa o hashing de conteúdo como mecanismo subjacente.
- Cadeia de custódia em informática forense. Quando ficheiros de prova são imageados, o padrão forense é calcular SHA-256 da imagem do disco no momento da aquisição e em cada ponto posterior, qualquer divergência prova adulteração. A National Software Reference Library (NSRL) do NIST publica hashes de ficheiros conhecidos como bons e conhecidos como maus para triagem forense.
- Verificação da cadeia de fornecimento de software. Sigstore, in-toto, SLSA, integridade de pacotes npm (
integrity: sha512-...empackage-lock.json), a base de dados de checksums do proxy de módulos do Go, todos descansam sobre o hashing de ficheiros como primitiva de integridade. O hash de um artefacto publicado é a ponte entre «confio nesta assinatura» e «este é o artefacto que a assinatura atestou».
Como esta ferramenta funciona
Quando solta um ficheiro no editor, o navegador lê-o num ArrayBuffer via FileReader.readAsArrayBuffer() (ou, em navegadores modernos, o método mais eficiente File.arrayBuffer() que devolve uma Promise). O crypto.subtle.digest(algorithm, buffer) da Web Crypto API faz hash do buffer com código nativo, implementado em C++ dentro do motor do navegador, frequentemente usando aceleração por hardware (Intel SHA Extensions em x86-64 desde Goldmont, instruções ARMv8 SHA-2 em essencialmente cada smartphone). O ArrayBuffer devolvido é convertido numa string hex para exibição. Três hashes em JavaScript puro (MD5 e SHA-1, onde a Web Crypto API pode declinar ou onde está em uso um polyfill) correm via pequenas implementações dedicadas. Sem passo de upload, sem processamento no servidor, sem telemetria, verifique no separador Rede das DevTools enquanto solta um ficheiro (não dispara nenhum pedido), ou ponha a página offline (modo de avião) após o carregamento e o hasher continua a funcionar em ficheiros locais. O limite prático de tamanho de ficheiro é a memória do navegador: fazer hash de um ficheiro de 1 GB funciona mas consome ~1 GB de RAM durante a operação; ficheiros de vários gigabytes podem forçar o navegador a fazer swap ou falhar. Para ficheiros muito grandes, uma ferramenta de linha de comandos dedicada (shasum -a 256 em macOS/Linux, certutil -hashfile ... SHA256 em Windows) é a melhor escolha.
Privacidade: por que o apenas-no-navegador importa especialmente aqui
Os ficheiros que pode querer fazer hash incluem software descarregado (que está a verificar para integridade precisamente porque ainda não confia nele), documentos privados (cujo hash quer registar sem dá-los a ninguém), ficheiros de mídia não publicados, provas numa investigação forense, ou builds proprietários onde mesmo carregar o ficheiro para um serviço de hashing é inaceitável. Os hashers de ficheiros do lado do servidor, mesmo quando afirmam «não guardamos o ficheiro», recebem o conteúdo completo do ficheiro, quando ele está na sua memória, a garantia de privacidade desapareceu. Esta ferramenta corre inteiramente no seu navegador via a Web Crypto API; o ficheiro nunca atravessa a rede. Verifique no separador Rede das DevTools enquanto solta um ficheiro (a única actividade de rede deve ser o carregamento inicial da página). Ponha a página offline (modo de avião) após o carregamento (o hasher continua a funcionar, provando a arquitectura apenas-local. Para ficheiros que contenham qualquer coisa sensível) documentos confidenciais, software não publicado, registos financeiros, exames médicos, qualquer coisa coberta por NDA ou regulamentação de conformidade, o hashing do lado do navegador é a única opção segura.
Perguntas frequentes
Qual algoritmo de hash usar ?
SHA-256 é o predefinido correcto para qualquer novo uso em 2026, ampla compatibilidade, sem ataques práticos conhecidos, acelerado por hardware em cada CPU moderna. Use SHA-512 se quiser uma saída de 512 bits (ligeiramente mais rápido em CPUs de 64 bits, mais bits de resistência a colisões). Use MD5 ou SHA-1 apenas quando estiver a corresponder a uma soma de verificação publicada que use esses algoritmos (algumas distribuições Linux ainda publicam somas MD5 ao lado de SHA-256 para compatibilidade retroactiva), nunca use nenhum para qualquer novo fim criptográfico. Adapte-se a qualquer algoritmo que o publicador do ficheiro que está a verificar tenha escolhido.
É possível reverter um hash para recuperar o arquivo original ?
Não. As funções hash são deliberadamente unidireccionais, dado um hash, não há algoritmo eficiente para recuperar a entrada. A única via de ataque é a força bruta: fazer hash de entradas candidatas até uma produzir um hash correspondente. Para ficheiros de qualquer tamanho razoável (mais do que alguns bytes) isto é computacionalmente inviável, o número de ficheiros possíveis de mesmo 1 KB excede o número de átomos no universo observável muitas vezes. Esta propriedade unidireccional é o que torna os hashes úteis para armazenamento de palavras-passe (com sal e estiramento), assinaturas digitais e armazenamento endereçável por conteúdo.
MD5 é seguro para verificação de arquivo ?
Para verificações de integridade não-adversariais (apanhar corrupção acidental de uma rede instável ou disco mau), MD5 está bem, bit flips aleatórios produzirão um MD5 diferente com probabilidade esmagadora. Para verificação adversarial (apanhar um actor malicioso que substituiu um ficheiro), MD5 está partido: ataques de colisão são práticos desde 2004, e colisões de prefixo escolhido desde 2008. Prática de segurança moderna: use SHA-256 para qualquer coisa onde alguém possa estar a tentar enganá-lo, e MD5 apenas quando a fonte é de confiança e só precisa de uma soma de verificação rápida.
Existe um limite de tamanho de ficheiro?
Sem tecto rígido, mas os limites práticos dependem da memória do navegador. Os ficheiros até algumas centenas de MB são hash rapidamente em qualquer dispositivo moderno. Os ficheiros no intervalo 1-2 GB funcionam mas consomem RAM igual ao tamanho do ficheiro durante a passagem de hashing. Os ficheiros de vários gigabytes podem disparar swapping ou crashes OOM do navegador. Para ficheiros muito grandes, as ferramentas de linha de comandos (shasum -a 256 file em macOS/Linux, certutil -hashfile file SHA256 em Windows, Get-FileHash em PowerShell) lidam melhor com eles porque podem fazer streaming do ficheiro em vez de carregar tudo para a memória.
O que significa quando dois ficheiros têm o mesmo hash?
Para uma função hash saudável (SHA-256, SHA-512, ou qualquer uma na família SHA-2 em 2026), significa que os ficheiros são idênticos bit a bit, a probabilidade de dois ficheiros distintos produzirem o mesmo hash é desprezivelmente pequena. Para funções hash partidas (MD5, SHA-1), poderia significar ficheiros idênticos ou uma colisão deliberadamente construída. Regra prática: se calcular SHA-256 de dois ficheiros e obtiver o mesmo valor, os ficheiros são os mesmos. Se calcular MD5 e obtiver o mesmo valor, os ficheiros são provavelmente os mesmos mas um adversário determinado poderia tê-los engendrado para colidir.