Visualizador de hash de strings

Como funciona

1. Insira seu texto : digite ou cole qualquer string, senha, conteúdo de arquivo, identificador ou qualquer texto a ser hasheado.
2. Escolha um algoritmo : selecione MD5, SHA-1, SHA-256, SHA-384 ou SHA-512 de acordo com sua necessidade.
3. Copie o hash : o valor do hash aparece instantaneamente. Copie-o para armazenamento, comparação ou verificação.

Por que usar o gerador de hash de string ?

O hashing transforma qualquer string em uma impressão digital de tamanho fixo, específica do seu conteúdo. Um único caractere modificado produz um hash completamente diferente. É essencial para verificar a integridade dos dados, armazenar senhas com segurança, gerar chaves de cache, deduplicar registros e criar identificadores baseados no conteúdo. Como o hashing é de mão única, é impossível recuperar o texto original a partir do hash, o que o torna seguro para armazenar dados sensíveis.

Funcionalidades

• Vários algoritmos : MD5, SHA-1, SHA-256, SHA-384 e SHA-512, todos em uma única ferramenta.
• Hashing em tempo real : o hash é atualizado instantaneamente enquanto você digita, sem clicar em um botão.
• Sensível à caixa : « Hello » e « hello » produzem hashes diferentes, por design.
• Copiar para a área de transferência : cópia do hash em um clique.
• 100 % no navegador : as strings nunca saem do seu dispositivo, seguro para conteúdos sensíveis.

Perguntas frequentes

Qual algoritmo de hash escolher ?

Para usos sensíveis (senhas, assinaturas), use SHA-256 ou SHA-512. MD5 e SHA-1 estão obsoletos para segurança, mas continuam úteis para checksums e chaves de cache onde a robustez criptográfica não é necessária.

Posso usar esta ferramenta para hashear senhas para armazenamento ?

O hashing de string fornece um hash de mão única, mas para armazenar senhas é preciso usar uma função de derivação de chave como bcrypt, Argon2 ou PBKDF2 que integra salt e iterações. Hashes SHA simples são rápidos demais e vulneráveis a ataques de tabelas rainbow.

Os hashes são reversíveis ?

Não. As funções de hashing são de mão única, impossível recuperar a string original a partir do seu hash. Se duas strings produzem o mesmo hash (colisão), é uma falha do algoritmo. SHA-256 e SHA-512 não têm colisões práticas conhecidas.

Uma história de 35 anos de funções hash: de MD5 a BLAKE3

As funções hash criptográficas evoluíram através de uma longa sequência de ciclos quebrar-e-substituir. MD5 foi publicado por Ronald Rivest na RFC 1321 (abril de 1992) como sucessor do MD4. Sua saída de 128 bits foi considerada forte o suficiente por mais de uma década até que Wang e Yu publicassem a primeira colisão prática em 2004. Em 2008, pesquisadores usaram colisões MD5 para forjar uma autoridade de certificação SSL fraudulenta. SHA-1 foi projetado pela NSA e padronizado pelo NIST em FIPS 180-1 (1995). Sua saída de 160 bits resistiu até fevereiro de 2017, quando Google e CWI Amsterdam anunciaram o ataque SHAttered, produzindo dois PDFs com o mesmo hash SHA-1. Custos: cerca de 6.500 anos-CPU equivalentes em GPUs. SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512), também da NSA, foi publicado em FIPS 180-2 (agosto de 2002). Usa a mesma construção Merkle-Damgård que SHA-1 mas com estados maiores e mais rounds; não existe ataque prático nas versões completas hoje. SHA-3 (Keccak, por Bertoni et al.) foi selecionado pelo NIST após uma competição pública e padronizado em FIPS 202 (agosto de 2015). SHA-3 usa uma construção esponja completamente diferente, imune aos ataques de extensão de comprimento que afetam SHA-2. Fora da família NIST, BLAKE2 (Aumasson et al., 2012) e BLAKE3 (2020) oferecem segurança classe SHA-3 com a velocidade do MD5; BLAKE3 hash um arquivo de 1 GB em cerca de um segundo num laptop moderno.

Qual algoritmo escolher: uma tabela de decisão rápida

• MD5 (128 bits). Quebrado desde 2004. Aceitável para usos não-segurança: invalidação de cache, deduplicação de arquivos onde você controla ambos lados, checksums contra corrupção acidental. Nunca use para senhas, assinaturas ou qualquer contexto adversarial.
• SHA-1 (160 bits). Quebrado desde 2017 (SHAttered). Git ainda usa para hashes de commits, mas em março de 2017 Git começou a embutir detecção de colisão (SHA-1DC) para recusar padrões de ataque conhecidos. Evite SHA-1 para código novo.
• SHA-256 (256 bits). O cavalo de batalha atual. Usado pelo Bitcoin, certificados TLS, assinaturas de pacotes Linux, assinatura JWT (HMAC-SHA256) e a maioria das APIs modernas. Rápido em hardware (extensões Intel SHA, extensões criptográficas ARMv8). Escolha padrão para hash de propósito geral.
• SHA-512 (512 bits). Mesma família, saída maior. Ligeiramente mais rápido que SHA-256 em máquinas 64 bits porque seu estado interno é 64 bits. Use quando precisar de resistência extra a colisões ou quando 256 bits pareça restritivo (raro).
• SHA-3 / Keccak (224/256/384/512 bits). A alternativa esponja padronizada ao SHA-2. Resistente a ataques de extensão de comprimento que afetam SHA-2 (relevante ao construir hashes com chave sem HMAC). Mais lento em software que SHA-256 na maioria dos CPUs mas imune a uma classe diferente de ataques.
• BLAKE2 / BLAKE3. Alternativas modernas não-NIST. BLAKE3 é o hash criptográfico mais rápido amplamente disponível, fazendo hash a aproximadamente velocidade memcpy graças ao paralelismo. Usado em b3sum, IPFS e o protocolo VPN WireGuard. Ainda não em crypto.subtle, mas disponível via bibliotecas.

Onde hash é realmente usado

• Verificação de integridade de arquivos. Distribuições Linux publicam somas SHA-256 ao lado de downloads ISO para você verificar que o arquivo não foi corrompido em trânsito ou modificado por um atacante. sha256sum -c ubuntu.sha256 em 10 segundos.
• Armazenamento endereçado por conteúdo. Git usa SHA-1 (transitando para SHA-256) para identificar cada commit, árvore e blob. IPFS, imagens Docker (sha256:...) e caminhos do store Nix todos usam endereçamento por conteúdo. O hash É o identificador.
• Chaves de cache. Fazer hash de uma URL ou requisição serializada dá uma chave de comprimento fixo que se adapta a qualquer sistema de armazenamento. Stripe, GitHub, cada CDN usa isso para buscas de cache.
• Deduplicação. Sistemas de backup (Time Machine, Borg, Restic) fazem hash de blocos de arquivos e só armazenam os únicos. Dois blocos idênticos de 4 KB em arquivos diferentes mapeiam para um único pedaço armazenado.
• HTTP ETags. Servidores web enviam o hash de uma resposta como cabeçalho ETag. Navegadores enviam de volta com If-None-Match; o servidor retorna 304 se inalterado. Economiza downloads redundantes.
• Assinaturas JWT e webhook. JSON Web Tokens assinam seu payload com HMAC-SHA256 (HS256 na spec). Stripe, GitHub, webhooks Twilio todos assinam seus payloads para você verificar que não foram adulterados em trânsito.
• Blockchains. Bitcoin usa SHA-256 duplo para prova de trabalho e link de blocos. Ethereum usa Keccak-256 (uma variante SHA-3). Todo o conceito de blockchain repousa na propriedade de que encontrar duas entradas com o mesmo hash é computacionalmente inviável.

Erros de hash que perdem dinheiro ou quebram coisas

• Usar hashes SHA para armazenamento de senhas. SHA-256 é rápido: uma GPU moderna calcula ~10 bilhões de hashes SHA-256 por segundo. Com um banco de dados vazado, um atacante pode tentar cada palavra de um dicionário mais todas as transformações comuns em minutos. Use Argon2id (vencedor da Password Hashing Competition 2015), bcrypt ou scrypt. Eles são deliberadamente lentos e exigentes em memória.
• Esquecer de salgar. Mesmo com um hash lento, a mesma senha hasheada sem sal produz a mesma saída entre usuários, permitindo tabelas arco-íris e detecção por canal lateral de senhas duplicadas. Sempre armazene um sal aleatório por usuário ao lado do hash.
• Ataques de extensão de comprimento no SHA-2. hash(secret + message) com SHA-256 é vulnerável: um atacante que conhece o hash e o comprimento de secret pode adicionar dados arbitrários e calcular o hash resultante sem conhecer secret. Use HMAC-SHA256 em vez disso. SHA-3 e BLAKE2/3 são imunes.
• Comparação de strings em tempo constante. Comparar hashes (ou qualquer valor secreto) com == em JavaScript vaza informação através do timing: uma função que sai no primeiro mismatch de byte permite a atacantes aprender o hash correto byte por byte ao longo de muitas requisições. Use crypto.timingSafeEqual no Node, hmac.compare_digest em Python.
• Hashear strings sem especificar codificação. sha256("hello") em Python 3 dá erro (você precisa de bytes); no Node defaulta para UTF-8; em PHP e Java o padrão pode variar. Diferentes codificações produzem diferentes hashes. Sempre codifique como UTF-8 explicitamente antes de hashear.
• Truncar hashes para «IDs curtos». Um corte de 64 bits de SHA-256 é conveniente para IDs curtos mas o paradoxo do aniversário significa que colisões aparecem a ~2³² itens (cerca de 4 bilhões), não 2⁶⁴. Se truncar, planeje tratamento de colisões na escala esperada.
• Tratar saída de hash como string segura para URL. Bytes brutos de hash não são imprimíveis. Use hex (mais comum) ou base64url. O base64 padrão contém + e / que quebram em URLs e nomes de arquivo; base64url é a variante segura.

Mais perguntas frequentes

Por que MD5 e SHA-1 estão «quebrados» se ainda produzem hashes?

«Quebrado» significa que um atacante pode produzir colisões mais rápido que força bruta. Para MD5, encontrar duas entradas com o mesmo hash leva segundos num laptop hoje. Para SHA-1, levou 6.500 anos-CPU em 2017 e caiu dramaticamente desde então. Os hashes ainda funcionam mecanicamente; o que está quebrado é a garantia de segurança de que são «resistentes a colisões». Para usos não-adversariais (somar um arquivo em que confia contra corrupção acidental) MD5 ainda funciona bem. Para qualquer coisa envolvendo um adversário, ambos são inseguros.

Devo me preocupar com computadores quânticos quebrando SHA-256?

Menos do que pode pensar. O algoritmo de Grover acelera ataques de pré-imagem contra um hash de 256 bits de 2²⁵⁶ para 2¹²⁸ trabalho clássico-equivalente, que ainda é efetivamente impossível. Primitivas simétricas (hashes, AES) sobrevivem à computação quântica dobrando tamanhos de chave/saída. Criptografia de chave pública (RSA, ECDSA) é o que cai pesado em ataques quânticos, daí os padrões pós-quânticos NIST publicados em agosto de 2024 (ML-KEM, ML-DSA, SLH-DSA). Se você está usando SHA-256 hoje, SHA-512 na era pós-quântica será mais que suficiente.

Qual a diferença entre um hash e HMAC?

Um hash (SHA-256) é sem chave: qualquer um com a entrada pode calcular a mesma saída. Um HMAC (Hash-based Message Authentication Code) envolve o hash com uma chave secreta, então apenas alguém conhecendo a chave pode calcular ou verificar a tag. Definido em RFC 2104 (1997), HMAC é a forma padrão de «assinar» uma mensagem simetricamente (remetente e destinatário compartilham um segredo). Use HMAC-SHA256 para assinaturas de webhook, JWT HS256, assinatura de requisição API. SHA-256 simples em secret + message é inseguro devido à extensão de comprimento.

Por que diferentes bibliotecas dão diferentes hashes para a mesma string?

Três causas comuns. Primeira, codificação de caracteres: UTF-8 vs UTF-16 vs Latin-1 dão diferentes bytes para strings não-ASCII, portanto diferentes hashes. Sempre codifique explicitamente. Segunda, fins de linha: "hello\n" e "hello\r\n" hasheiam diferente; checksums Windows-vs-Unix frequentemente diferem por essa razão. Terceira, formato de saída: hex minúscula vs hex maiúscula vs base64 parece um valor diferente mas representa os mesmos bytes. Normalize formatos de entrada e saída antes de comparar.

Minha entrada é enviada para um servidor quando faço hash aqui?

Não. Todos os quatro hashes são calculados em seu navegador usando a API Web Crypto integrada (crypto.subtle.digest). Abra a aba Rede no DevTools e digite na entrada, você verá zero requisições de saída. Seguro para credenciais, tokens ou qualquer valor privado que você queira fazer hash sem que saia do seu dispositivo.