Gerador de Hash
Suporta algoritmos de hash MD5, SHA-1, SHA-256, SHA-384, SHA-512
O que é Hash?
Hash é um algoritmo que mapeia dados de comprimento arbitrário para um resumo de comprimento fixo. A mesma entrada sempre produz a mesma saída, enquanto uma pequena mudança na entrada produz uma saída completamente diferente, e é impossível reverter o valor hash para os dados originais. Os algoritmos de hash comuns incluem MD5, SHA-1, SHA-256, SHA-384, SHA-512, amplamente usados para verificação de integridade de dados, armazenamento de senhas, assinaturas digitais e outros cenários. Funções hash devem ser entendidas conforme o objetivo: verificação de integridade, identificação rápida ou segurança. MD5 e SHA-1 ainda aparecem em checksums antigos, mas são fracos para decisões modernas de confiança; SHA-256 ou algoritmos mais fortes costumam ser preferidos. Hash não é criptografia: não pode ser descriptografado, mas entradas fracas ou previsíveis ainda podem ser adivinhadas por dicionários ou ataques pré-computados.
Como Usar
Como usar
- Selecione o modo de entrada: Entrada de texto ou Upload de arquivo
- Insira o conteúdo do texto ou arraste e solte um arquivo
- Marque os algoritmos de hash que deseja gerar (seleção múltipla)
- Clique no botão 'Gerar Hash' para calcular
- Clique em 'Copiar' para copiar um hash individual ou em 'Copiar Todos' para todos os resultados
Observações sobre Hash
- Valores de hash são impressões digitais determinísticas; alterar mesmo um único byte na entrada produz um resultado diferente.
- Use SHA-256 ou algoritmos mais fortes para verificações de integridade quando a segurança for importante, e evite MD5/SHA-1 em novos fluxos de trabalho de segurança.
Casos de uso
Princípio técnico
Uma função hash criptográfica mapeia entrada de comprimento arbitrário para um resumo de comprimento fixo, com três propriedades de segurança: resistência a pré-imagem (difícil de inverter), resistência a segunda pré-imagem (difícil de encontrar uma entrada diferente com o mesmo resumo) e resistência a colisão (difícil de encontrar duas entradas quaisquer com o mesmo resumo). MD5 (Rivest 1991, RFC 1321), SHA-1 (NIST FIPS 180-1, 1995) e a família SHA-2 (FIPS 180-4, 2012) são todas construções Merkle-Damgård: a entrada é preenchida para um múltiplo do tamanho do bloco, depois iterada por uma função de compressão unidirecional. O tamanho do bloco é 512 bits para MD5, SHA-1, SHA-256, e 1024 bits para SHA-512. Tamanhos dos resumos: 128 / 160 / 256 / 384 / 512 bits respectivamente. MD5 (Rivest 1991) é um hash de 128 bits, 64 rodadas de um quarter-round com quatro palavras de encadeamento de 32 bits (A, B, C, D), constantes derivadas da função seno (sem significado de segurança, apenas para quebrar simetria). Ataques de colisão: Wang et al. 2004 reduziu a busca de colisão MD5 para 2⁴⁰ avaliações de hash (caminhos diferenciais calculados à mão); Stevens 2009 escreveu uma ferramenta de colisão de prefixo escolhido; o malware Flame 2012 usou um ataque de prefixo escolhido inovador para forjar um certificado de assinatura de código da Microsoft, marcando o primeiro exploit de colisão MD5 conhecido em produção. Hoje, uma colisão MD5 custa menos de um dólar em uma CPU e milissegundos em uma GPU. Use SHA-256 para qualquer novo protocolo. SHA-1 (FIPS 180-1, depreciado pelo NIST em 2011 após FIPS 180-4) é um hash de 160 bits com 80 rodadas e cinco palavras de encadeamento de 32 bits. O ataque SHAttered (Stevens et al., fevereiro de 2017) produziu a primeira colisão SHA-1 prática, custando ~6.500 anos-CPU e 110 anos-GPU. Em 2020, colisões de prefixo escolhido eram práticas por ~$45.000 de tempo de GPU, e em 2025 o custo de colisão em hardware comum está bem abaixo de $10.000. O Git migrou de SHA-1 para SHA-256 em 2020; certificados HTTPS não são permitidos usar SHA-1 desde 2017. A saída de colisão de prefixo escolhido SHAttered ('SHAttered.pdf' e 'SHAttered2.pdf') é o vetor de teste padrão: seus resumos SHA-1 coincidem mas os conteúdos diferem. SHA-2 (FIPS 180-4, 2012) abrange seis hashes: os sucessores do SHA-1 SHA-224, SHA-256, SHA-384, SHA-512 além de duas variantes truncadas SHA-512/256 e SHA-512/224. Internamente SHA-256 usa seis funções lógicas (Ch, Maj, Σ0, Σ1, σ0, σ1) com 64 constantes de rodada K[t] = ⌊∛(primeiros 32 bits da parte fracional do t-ésimo primo)⌋ — a construção de raiz cúbica do primo é puramente estética, sem papel de segurança. SHA-256 tem sido o cavalo de trabalho desde ~2010 e é o padrão de facto para TLS 1.3 (RFC 8446), proof-of-work do Bitcoin (até as discussões de mudança de 2025), e a maioria dos armazenamentos endereçáveis por conteúdo. SHA-512/256 é mais rápido em hardware de 64 bits porque usa palavras de 64 bits e roda a compressão do SHA-512, depois trunca. SHA-3 (FIPS 202, 2014) e Keccak (a submissão original) usam uma estrutura fundamentalmente diferente: a construção de esponja Keccak-f[1600] com um estado de 1600 bits, alternando fases de absorção/compressão. SHA-3 tem os mesmos tamanhos de resumo que SHA-2 mas resiste ao ataque de extensão de comprimento que afeta hashes Merkle-Damgård — uma propriedade útil ao hashear um MAC de prefixo secreto. BLAKE2 (RFC 7693) é mais rápido que SHA-256 em software e é usado pelo WireGuard, Argon2 e vários protocolos modernos. Esta página executa SHA-1, SHA-256, SHA-384 e SHA-512 no navegador via SubtleCrypto.digest (que chama o código nativo da plataforma — OpenSSL/BoringSSL no Chromium, NSS no Firefox, o equivalente no Safari), e recua para uma implementação pura em JS de MD5 porque o SubtleCrypto não expõe MD5 (de acordo com a W3C Web Crypto API, MD5 está em status 'recommend-only'). Para um arquivo de 10 MB, SHA-256 no V8 roda a ~400 MB/s em um laptop moderno, enquanto o MD5 em JS puro roda a ~100-150 MB/s — a família SHA via Web Crypto é 3-4× mais rápida que qualquer implementação pura em JS, é por isso que a página roteia SHA-1+ pela interface nativa.
- MD5 (Rivest 1991, RFC 1321): resumo de 128 bits, bloco de 512 bits, 64 rodadas, Merkle-Damgård. Colisão quebrada desde Wang 2004 (2⁴⁰ de trabalho) e prefixo escolhido quebrado no Flame 2012 — nunca use para código novo, mas ainda serve para checksums sem segurança, ETags, impressão digital de conteúdo ou chaves de cache.
- SHA-1 (FIPS 180-1, 1995; depreciado pelo FIPS 180-4, 2011): resumo de 160 bits. A colisão SHAttered (Stevens et al., fev. 2017) custou ~6.500 anos-CPU; colisões de prefixo escolhido agora custam menos de $10K. O Git migrou para SHA-256 em 2020; o CA/Browser Forum proibiu SHA-1 em certificados HTTPS em 2017.
- SHA-256 (FIPS 180-4): resumo de 256 bits, 64 rodadas de Ch/Maj/Σ0/Σ1/σ0/σ1, 64 constantes de rodada K[t] derivadas das partes fracionárias de ∛(primo). Cavalo de trabalho para TLS 1.3 (RFC 8446), maioria dos armazenamentos endereçáveis por conteúdo e mineração de Bitcoin. O nível de segurança de 256 bits oferece ~128 bits de resistência a colisão.
- SHA-384/SHA-512 (FIPS 180-4): SHA-512 usa palavras de 64 bits, 80 rodadas, bloco de 1024 bits. Aproximadamente 1,5-2× mais rápido que SHA-256 em hardware de 64 bits. SHA-384 é apenas SHA-512 truncado para 384 bits; SHA-512/256 é SHA-512 truncado para 256 bits e oferece melhor resistência a extensão de comprimento que SHA-256.
- SHA-3 (FIPS 202, 2014) / Keccak: construção de esponja com a permutação Keccak-f[1600], taxas de 1088/832/576 bits para SHA3-256/384/512. Resiste a ataques de extensão de comprimento que afetam hashes Merkle-Damgård — útil para MACs de prefixo secreto.
- BLAKE2 (RFC 7693) e BLAKE3 são hashes rápidos modernos; BLAKE2s é a derivação típica de chave MAC, BLAKE2b é usado pelo WireGuard e muitos protocolos, e BLAKE3 adiciona uma árvore Merkle para hashing paralelo. Não estão no Web Crypto até 2025, então esta página não os expõe.
- Web Crypto API (W3C): SubtleCrypto.digest('SHA-256', data) retorna uma Promise<ArrayBuffer> calculada pelo código nativo da plataforma. ~400 MB/s no V8 para SHA-256, ~100-150 MB/s para MD5 em JS puro — a diferença de 3-4× é o motivo pelo qual a página roteia SHA-1+ pelo SubtleCrypto.
- Ressalva de extensão de comprimento: H(secret || message) é falsificável para qualquer hash Merkle-Damgård (MD5, SHA-1, SHA-2) se o atacante conhecer o resumo e o comprimento da mensagem. HMAC (RFC 2104) e SHA-3 evitam isso. Para MACs use HMAC-SHA-256 ou KMAC; para hashes de entrada não confiável, o resumo bruto é suficiente.
Exemplos
Vetor de teste FIPS 180-2: string vazia e 'abc'
Entrada: '' (vazia, 0 bytes)
MD5: d41d8cd98f00b204e9800998ecf8427e (32 caracteres hex)
SHA-1: da39a3ee5e6b4b0d3255bfef95601890afd80709 (40 caracteres hex)
SHA-256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 (64 caracteres hex)
SHA-512: cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
Entrada: 'abc' (3 bytes, o vetor de teste canônico do FIPS)
MD5: 900150983cd24fb0d6963f7d28e17f72
SHA-1: a9993e364706816aba3e25717850c26c9cd0d89d
SHA-256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-512: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
O comprimento de cada saída é fixo, definido pelo algoritmo (MD5 128 bits, SHA-1 160 bits,
SHA-256 256 bits, SHA-512 512 bits), independentemente do tamanho da entrada.Vetor de teste FIPS 180-2 de 56 bytes (multi-bloco)
Entrada: 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq' (56 bytes)
SHA-256: 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1
SHA-512: 8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018
50d1c9ef3504cabb287a00833cf81a7e (128 caracteres hex - exibidos os primeiros 64,
o digest tem 64 bytes / 1024 bits)
Esse vetor de 56 bytes abrange dois blocos de 512 bits do SHA-256 e exercita
o message schedule (expansão sigma_0 / sigma_1 das palavras 16..63).
É a entrada de referência do NIST CAVP para SHA-256 e a forma canônica
de confirmar que o loop do message schedule está implementado corretamente.
Se corresponder, padding de bloco, append do comprimento e adição de estado final
estão todos funcionando. SHA-512 usa a mesma estrutura Merkle-Damgard com
palavras de 64 bits e schedule de 80 passos, então a mesma entrada de 56 bytes
produz um digest de 128 caracteres hex.Efeito avalanche e armadilha de codificação
Entrada: '' (vazia) MD5: d41d8cd98f00b204e9800998ecf8427e
Entrada: 'a' (um byte) MD5: 0cc175b9c0f1b6a831c399e269772661
Adicionar um único byte muda todos os bits da saída — essa é a propriedade
da avalanche. O mesmo vale para caixa (a -> A muda 0x61 para 0x41, um bit
na posição 0x20) e para espaços ao final. Note também que o mesmo texto
visível com e sem um '\n' final ou um BOM UTF-8
(0xEF 0xBB 0xBF) gera digests diferentes, e por isso comparar com um
checksum publicado exige reproduzir exatamente a mesma sequência de bytes,
não os caracteres visíveis. Navegadores e Node passam strings pelo TextEncoder
antes para deixar os bytes de entrada determinísticos; um MD5 em JS que recebe
a string diretamente produz hashes errados para entradas não-ASCII.Verificação de integridade de arquivos com sha256sum
$ sha256sum ubuntu-24.04-desktop-amd64.iso
4d0c238817f7d74c93cfbe7939f8f7a4f9a0d0c7c0e8a6c4f9a0d0c7c0e8a6c4 *ubuntu-24.04-desktop-amd64.iso
1. Solte o mesmo .iso no modo arquivo desta página e escolha SHA-256.
2. Copie o digest de 64 caracteres para o campo de comparação.
3. Se os digests coincidirem, o download é byte a byte idêntico ao do publicador.
Uma divergência indica que o arquivo está corrompido, baixado parcialmente
ou em uma versão diferente da listada no manifesto.
Para o mesmo arquivo, MD5 e SHA-1 produzem digests de 32 e 40 caracteres respectivamente;
SHA-256 e SHA-512 produzem 64 e 128. Confirme se o checksum do publicador usa
o mesmo algoritmo antes de comparar.Perguntas frequentes
Quais algoritmos esta ferramenta suporta?
Normalmente MD5, SHA-1, SHA-256, SHA-384, SHA-512 e às vezes SHA-3 / RIPEMD-160. SHA-256 é a escolha moderna padrão; MD5 e SHA-1 só devem ser usados para checksums não relacionados à segurança.
Hashing é a mesma coisa que criptografia?
Não. Hashing é unidirecional — dado o hash, não existe algoritmo para recuperar a entrada original (fora força bruta sobre um espaço pequeno de entradas). A criptografia é reversível com uma chave. Use hashing para impressões digitais e checagens de integridade, criptografia para confidencialidade.
Onde a entrada é hasheada?
Todo o hashing roda no seu navegador, via Web Crypto API ou implementações em JS puro. Nada é enviado a um servidor. Você pode confirmar olhando a aba Network enquanto cola a entrada.
Por que a mesma entrada produz um hash diferente em outro site?
As diferenças geralmente vêm de pré-processamento da entrada: quebras de linha (CRLF vs LF), espaço em branco no final, codificação de caracteres (UTF-8 vs UTF-16), ou uma ferramenta que adiciona automaticamente uma quebra de linha. Os algoritmos de hash em si são determinísticos entre as implementações.
Posso reverter um hash?
Matematicamente não. Na prática, entradas curtas vindas de um conjunto pequeno (senhas comuns, palavras de dicionário, números curtos) podem ser consultadas em rainbow tables pré-computadas. Para qualquer coisa sensível, esse é justamente o motivo de usar salt e um hash lento como bcrypt ou Argon2 — esta ferramenta não substitui isso.
Devo gerar hash de senhas com esta ferramenta?
Não. SHA-256 sozinho é rápido demais para armazenamento de senhas. Use bcrypt, scrypt ou Argon2 com um salt por usuário e um fator de trabalho ajustado. Hashes da família SHA são adequados para integridade de arquivos, endereçamento por conteúdo e entradas de assinatura — não para senhas.
Por que os hashes têm tamanhos diferentes?
Cada algoritmo tem um tamanho de digest fixo: MD5 tem 128 bits (32 caracteres hex), SHA-1 tem 160 bits (40 caracteres hex), SHA-256 tem 256 bits (64 caracteres hex), SHA-512 tem 512 bits (128 caracteres hex). Maior é mais resistente a colisões, mas o próprio hash ocupa mais espaço.