Gerador de Hash SHA-1 - SHA-1 Criptografar

Ferramenta gratuita geradora de hash SHA-1 e criptografia SHA-1 online. Gere hash SHA-1 a partir de texto instantaneamente. Crie checksums SHA-1 de 160 bits para verificação de integridade de dados e desenvolvimento. Hash SHA-1 rápido no lado do cliente.

Tem feedback? Reporte bugs, sugira recursos ou compartilhe suas ideias — lemos todos

Gerador de Hash SHA-1 - Gerar Checksums SHA-1 Online

Um gerador de hash SHA-1 online gratuito que cria checksums SHA-1 de 160 bits a partir de qualquer entrada de texto. Perfeito para desenvolvedores e administradores de sistema que precisam de hashes SHA-1 para sistemas legados, commits do Git, e testes de desenvolvimento. Processamento rápido no lado do cliente com resultados instantâneos.

O que é SHA-1 e como funciona?

SHA-1 (Secure Hash Algorithm 1) é uma função hash criptográfica projetada pela NSA e publicada pelo NIST em 1995 como FIPS PUB 180-1. Produz um hash de 160 bits (20 bytes), tipicamente representado como string hexadecimal de 40 caracteres. SHA-1 processa a entrada em blocos de 512 bits através de 80 rodadas de operações bit a bit, somas modulares e rotações. A entrada é preenchida até um múltiplo de 512 bits com o comprimento codificado nos últimos 64 bits. A saída é determinística — a mesma entrada sempre produz o mesmo hash. SHA-1 foi muito usado em TLS, Git e assinaturas digitais antes de ser descontinuado para usos de segurança.

SHA-1 ainda é seguro de usar?

Não — SHA-1 está criptograficamente quebrado quanto à resistência a colisões. Em fevereiro de 2017 Google e CWI Amsterdam publicaram o 'SHAttered', o primeiro ataque prático de colisão, produzindo dois arquivos PDF distintos com hashes SHA-1 idênticos (artigo: shattered.io). O custo do ataque foi cerca de 110.000 USD em computação em nuvem. O NIST descontinuou formalmente o SHA-1 em 2011 (SP 800-131A) e proibiu para assinaturas digitais em 2014. Navegadores modernos (Chrome 56+, Firefox 51+, Safari 11+) rejeitam certificados TLS assinados com SHA-1. Use SHA-256, SHA-3 ou BLAKE3 para qualquer nova aplicação criptográfica. SHA-1 só permanece aceitável para usos não relacionados a segurança, como checksums de conteúdo ou identificadores de commit Git.

Por que o Git ainda usa SHA-1?

O Git usa SHA-1 para gerar o ID de commit, o hash de tree e o hash de blob. Linus Torvalds escolheu SHA-1 em 2005 por sua velocidade e unicidade adequada para uso não adversarial. O Git está migrando para SHA-256 — o Git 2.29 (outubro de 2020) adicionou suporte experimental a repositórios SHA-256. Ataques de colisão estilo SHAttered não são práticos no Git porque criar conteúdo malicioso que combine com o SHA-1 de um commit existente é muito mais difícil que produzir dois arquivos arbitrários colidindo. O projeto Git documentou medidas de endurecimento em 2018 para detectar ataques estilo SHAttered no nível de protocolo. Novos repositórios devem optar por `git init --object-format=sha256` para se preparar para o futuro, embora a compatibilidade com SHA-1 ainda seja o padrão atual.

Em que SHA-1 difere de MD5 e SHA-256?

MD5 produz 128 bits (32 chars hex), SHA-1 produz 160 bits (40 chars hex), SHA-256 produz 256 bits (64 chars hex). MD5 foi quebrado em 2004 (ataque de colisão Wang et al.); SHA-1 foi quebrado em 2017 (SHAttered). SHA-256 (parte da família SHA-2, FIPS PUB 180-4) permanece seguro em 2025 sem ataques práticos conhecidos. SHA-256 é cerca de 50 por cento mais lento que SHA-1 em CPUs modernas, mas tem aceleração por hardware via Intel SHA extensions e ARMv8 Crypto extensions. Para aplicações novas use SHA-256 ou SHA-3; nunca use MD5 ou SHA-1 para fins criptográficos.

Gerador de Hash SHA-1 - SHA-1 Criptografar — Ferramenta gratuita geradora de hash SHA-1 e criptografia SHA-1 online. Gere hash SHA-1 a partir de texto instantaneamen — **Gerador de Hash SHA-1 - SHA-1 Criptografar**

É possível reverter SHA-1 para encontrar a entrada original?

Não — SHA-1 é uma função de mão única por design. Dado um hash, não existe operação matemática para recuperar a entrada original. Porém, para entradas curtas ou de baixa entropia (senhas, palavras comuns), atacantes podem usar rainbow tables (mapeamentos pré-computados hash → entrada) ou ataques de força bruta/dicionário. Para uma senha de 8 caracteres alfanuméricos minúsculos, GPUs modernas conseguem computar todos os 2,8 trilhões de hashes SHA-1 possíveis em menos de um dia. É por isso que SHA-1 (e SHA-256) nunca devem ser usados para armazenar senhas diretamente — use bcrypt, Argon2id, scrypt ou PBKDF2 com salt adequado e muitas iterações. A NIST SP 800-63B exige Argon2 ou bcrypt para armazenamento de senhas.

Como gero um hash SHA-1 em código?

Python: `import hashlib; hashlib.sha1(b'hello').hexdigest()` retorna 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d'. JavaScript (navegador): `await crypto.subtle.digest('SHA-1', new TextEncoder().encode('hello')).then(b => Array.from(new Uint8Array(b)).map(b => b.toString(16).padStart(2, '0')).join(''))`. Node.js: `crypto.createHash('sha1').update('hello').digest('hex')`. Bash/Unix: `echo -n 'hello' | sha1sum`. Todos produzem a mesma string hexadecimal de 40 caracteres. A distinção byte-string vs text-string importa: `'hello'.encode()` em Python dá bytes; passar uma string regular pode dar TypeError. Sempre especifique a codificação de entrada (tipicamente UTF-8) explicitamente para conteúdo não-ASCII.

O que é HMAC-SHA1 e onde ainda é aceitável?

HMAC-SHA1 (RFC 2104) combina uma chave secreta com SHA-1 para produzir um código de autenticação de mensagem de 160 bits. Mesmo com a resistência a colisões do SHA-1 quebrada, HMAC-SHA1 permanece seguro porque o HMAC depende da propriedade de função pseudo-aleatória da função hash subjacente, não da resistência a colisões. O AWS Signature Version 2 historicamente usou HMAC-SHA1 (agora descontinuado em favor do Signature Version 4 com HMAC-SHA256). O OAuth 1.0a (RFC 5849) especificou HMAC-SHA1 como método de assinatura. Aplicações modernas ainda devem migrar para HMAC-SHA256 (RFC 4868) ou HMAC-SHA3 porque futuras fraquezas no SHA-1 podem afetar o HMAC adiante, e o hardware moderno acelera o SHA-256 igualmente.

Para que o checksum SHA-1 de arquivo é usado?

Checksums SHA-1 ainda são amplamente usados para verificar a integridade de arquivos em contextos não adversariais: downloads de distribuições Linux (Debian, Ubuntu fornecem SHA1SUMS e SHA256SUMS), manifestos de imagens Docker, IDs de commit do GitHub, hashes de peças BitTorrent e sistemas de armazenamento endereçáveis por conteúdo. Eles detectam corrupção acidental por erros de disco ou downloads parciais, mas não podem se defender contra adulteração maliciosa. Prefira sempre checksums SHA-256 quando disponíveis — a maioria das distribuições agora publica ambos. Para verificar: `sha1sum arquivo.iso` e comparar com o valor publicado. A demonstração shattered.io mostrou dois PDFs forjados com mesmo SHA-1 mas conteúdo diferente, então confie no SHA-1 apenas para integridade não adversarial.