Gerador de Hash SHA-1

O que é o Hashing SHA-1?

SHA-1 (Secure Hash Algorithm 1) é uma função de hash criptográfica que produz um resumo fixo de 160 bits (20 bytes) a partir de qualquer entrada. Publicado pela NSA e padronizado pelo NIST em 1995 como FIPS PUB 180-1 e posteriormente documentado na RFC 3174, o SHA-1 foi desenvolvido como um sucessor mais robusto do SHA-0 e do MD5. O algoritmo processa a entrada em blocos de 512 bits por 80 rodadas de operações bit a bit, gerando uma impressão digital hexadecimal de 40 caracteres que serviu de base para SSL/TLS, PGP, SSH e IPsec por mais de uma década.

Como toda função de hash criptográfica, o SHA-1 é uma transformação unidirecional: calcular o hash a partir de uma entrada é rápido, mas recuperar a entrada original a partir do hash é computacionalmente inviável. Uma mudança de um único bit na entrada produz um resumo de 160 bits completamente diferente — propriedade chamada de efeito avalanche. O SHA-1 mapeia um espaço de entrada arbitrariamente grande para uma saída fixa de 160 bits, o que significa que colisões (duas entradas diferentes gerando o mesmo hash) existem matematicamente. A premissa de segurança de uma função de hash é que encontrar essas colisões deve exigir aproximadamente 2^80 operações — metade do comprimento em bits da saída.

Em 2017, o Google e o CWI Amsterdam publicaram o ataque SHAttered, demonstrando a primeira colisão SHA-1 prática ao produzir dois arquivos PDF diferentes com o mesmo resumo. O ataque exigiu aproximadamente 2^63,1 computações SHA-1 — muito abaixo do limite teórico de 2^80. Em 2020, Gaetan Leurent e Thomas Peyrin reduziram ainda mais o custo com um ataque de colisão de prefixo escolhido que exigiu cerca de 2^63,4 operações. Em consequência, todos os principais navegadores, autoridades certificadoras e órgãos de padronização depreciaram o SHA-1 para assinaturas digitais e certificados TLS. Entretanto, o SHA-1 ainda é usado ativamente para fins não relacionados a segurança: IDs de objetos Git (embora o Git esteja migrando para SHA-256), construções HMAC legadas e checksums de integridade de arquivos onde a resistência a colisões adversariais não é necessária.

Por que usar este gerador de SHA-1?

Gere hashes SHA-1 instantaneamente sem instalar nada ou escrever código. Cole o texto e obtenha o resumo hexadecimal de 40 caracteres em tempo real — útil para verificar checksums legados, depurar componentes internos do Git ou testar fluxos de trabalho baseados em hash.

Casos de Uso do SHA-1

SHA-1 vs Outros Algoritmos de Hash

O SHA-1 produz um resumo de 160 bits — mais longo que o MD5 (128 bits), mas significativamente mais curto que os algoritmos da família SHA-2. A tabela abaixo compara tamanhos de resumo, padrões e casos de uso adequados para cada algoritmo.

Como o SHA-1 Funciona

O SHA-1 segue a construção de Merkle-Damgard: a mensagem é preenchida, dividida em blocos de 512 bits, e cada bloco é processado por 80 rodadas de operações bit a bit que combinam a entrada com um escalonamento de mensagem derivado do bloco. Cinco palavras de estado de 32 bits (H0 a H4) carregam o estado de hash em execução, e a concatenação final dessas palavras produz o resumo de 160 bits.

A principal diferença entre SHA-1 e MD5 é o número de palavras de estado (5 vs. 4), o número de rodadas por bloco (80 vs. 64) e o uso de um escalonamento de mensagem com retroalimentação de rotação à esquerda. Essas diferenças conferem ao SHA-1 uma saída maior (160 vs. 128 bits) e originalmente forneciam uma margem de segurança mais alta, embora ambos os algoritmos sejam hoje considerados vulneráveis quanto à resistência a colisões.

Exemplos de Código

Como gerar hashes SHA-1 nas linguagens e ambientes mais populares. Ao contrário do MD5, o SHA-1 está disponível na Web Crypto API do navegador, tornando-o utilizável sem bibliotecas externas tanto no navegador quanto em ambientes Node.js.

// SHA-1 is available in the Web Crypto API
async function sha1(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-1', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha1('hello world')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha1').update('hello world').digest('hex')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

import hashlib

# Basic SHA-1 hash
result = hashlib.sha1(b'hello world').hexdigest()
print(result)  # → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a string (encode to bytes first)
text = 'hello world'
hashlib.sha1(text.encode('utf-8')).hexdigest()
# → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a file in chunks
with open('file.bin', 'rb') as f:
    sha1 = hashlib.sha1()
    for chunk in iter(lambda: f.read(8192), b''):
        sha1.update(chunk)
    print(sha1.hexdigest())

package main

import (
    "crypto/sha1"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha1.Sum(data)
    fmt.Printf("%x\n", hash)
    // → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
}

# Using sha1sum (Linux) or shasum (macOS)
echo -n "hello world" | sha1sum
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# macOS
echo -n "hello world" | shasum -a 1
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# Hash a file
sha1sum package.json
# → a1b2c3d4e5f6...  package.json

# Using openssl (cross-platform)
echo -n "hello world" | openssl sha1
# → SHA1(stdin)= 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

Perguntas Frequentes