Usar John the Ripper para Quebrar Hashes SHA1

Introdução

Neste laboratório, você explorará o processo de quebra de hashes SHA1 usando o John the Ripper, uma poderosa ferramenta de código aberto para quebra de senhas. Compreender como os hashes são quebrados é crucial para entender as vulnerabilidades de segurança de senhas e implementar medidas de segurança mais robustas. Você aprenderá a gerar hashes SHA1 a partir de senhas em texto simples, preparar esses hashes para o John the Ripper e, em seguida, usar a ferramenta para recuperar as senhas originais. Essa experiência prática fornecerá insights sobre a eficácia dos algoritmos de hashing e a importância de senhas fortes e únicas.

Gerar Hashes SHA1 a partir de Senhas

Nesta etapa, você gerará hashes SHA1 a partir de algumas senhas de exemplo. SHA1 (Secure Hash Algorithm 1) é uma função de hash criptográfica que recebe uma entrada e produz um valor de hash de 160 bits (20 bytes), tipicamente representado como um número hexadecimal de 40 dígitos. Embora o SHA1 seja considerado criptograficamente quebrado para certas aplicações devido a vulnerabilidades, ele ainda é útil para demonstrar princípios de quebra de hash.

Primeiro, vamos criar um arquivo chamado passwords.txt que contém algumas senhas simples.

echo -e "password123\nlabexuser\nsecretpass" > passwords.txt

Agora, usaremos o comando sha1sum para gerar o hash SHA1 para cada senha no arquivo passwords.txt. A opção -t informa ao sha1sum para ler em modo texto, e a opção -b informa para ler em modo binário. Usaremos xargs para passar cada linha do arquivo como um argumento para sha1sum.

cat passwords.txt | xargs -I {} sh -c 'echo -n "{}" | sha1sum' > hashes.txt

Este comando lê cada senha de passwords.txt, a envia para o sha1sum (usando echo -n para evitar adicionar um caractere de nova linha que alteraria o hash) e, em seguida, redireciona a saída (o hash e a senha original) para um novo arquivo chamado hashes.txt.

Vamos visualizar o conteúdo de hashes.txt:

cat hashes.txt

Você deverá ver uma saída semelhante a esta, onde cada linha contém um hash SHA1 seguido pela senha original:

5d41402abc4b2a76b9719d911017c592070b4783  password123
1234567890abcdef1234567890abcdef12345678  labexuser
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8  secretpass

Nota: A segunda coluna (a senha original) é incluída pelo sha1sum por padrão. Para a quebra, o John the Ripper geralmente precisa apenas do hash em si. Prepararemos o arquivo para o John na próxima etapa.

Preparar um Arquivo de Hash para SHA1

Nesta etapa, você preparará o arquivo hashes.txt para que ele contenha apenas os hashes SHA1, que é o formato que o John the Ripper espera para a quebra. O arquivo hashes.txt atualmente contém tanto o hash quanto a senha original, o que não é ideal para a entrada no John.

Extrairemos apenas os valores de hash de hashes.txt e os salvaremos em um novo arquivo chamado sha1_hashes_for_john.txt. Podemos usar o comando awk para conseguir isso, pois ele nos permite selecionar facilmente colunas específicas de um arquivo.

awk '{print $1}' hashes.txt > sha1_hashes_for_john.txt

Este comando instrui o awk a imprimir o primeiro campo ($1) de cada linha em hashes.txt e redirecionar a saída para sha1_hashes_for_john.txt.

Agora, vamos inspecionar o conteúdo do novo arquivo para garantir que ele contenha apenas os hashes:

cat sha1_hashes_for_john.txt

Você deverá ver uma saída semelhante a esta, com apenas os hashes SHA1 listados:

5d41402abc4b2a76b9719d911017c592070b4783
1234567890abcdef1234567890abcdef12345678
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

Este arquivo está agora pronto para ser usado como entrada para o John the Ripper.

Quebrar Hashes SHA1 com John the Ripper

Nesta etapa, você usará o John the Ripper para quebrar os hashes SHA1 armazenados em sha1_hashes_for_john.txt. John the Ripper é um cracker de senhas rápido, disponível para muitos sistemas operacionais. Seu objetivo principal é detectar senhas fracas do Unix. Ele suporta vários tipos de hash, incluindo SHA1.

Usaremos o John the Ripper no "modo wordlist" para tentar quebrar os hashes. Este modo tenta senhas de uma lista predefinida (uma "wordlist"). Para este laboratório, criaremos uma wordlist simples contendo as senhas originais. Em um cenário do mundo real, você usaria uma wordlist muito maior e mais abrangente.

Primeiro, crie um arquivo de wordlist simples chamado wordlist.txt:

echo -e "password123\nlabexuser\nsecretpass\nwrongpass\notherpass" > wordlist.txt

Agora, execute o John the Ripper com o arquivo de hash preparado e a wordlist:

john --format=raw-sha1 --wordlist=wordlist.txt sha1_hashes_for_john.txt

Vamos detalhar o comando:

• john: O comando para invocar o John the Ripper.
• --format=raw-sha1: Especifica que os hashes de entrada são hashes SHA1 brutos. O John suporta muitos formatos, e especificar o correto o ajuda a quebrar eficientemente.
• --wordlist=wordlist.txt: Diz ao John para usar wordlist.txt como o dicionário para a quebra.
• sha1_hashes_for_john.txt: O arquivo contendo os hashes a serem quebrados.

Após executar o comando, o John tentará quebrar os hashes. Se for bem-sucedido, ele exibirá as senhas quebradas.

Você deverá ver uma saída semelhante a esta, indicando as senhas quebradas:

Using default input encoding: UTF-8
Loaded 3 password hashes with no different salts (Raw-SHA1 [SHA1])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (5d41402abc4b2a76b9719d911017c592070b4783)
labexuser        (1234567890abcdef1234567890abcdef12345678)
secretpass       (5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8)
3g 0:00:00:00 DONE (2023-10-27 10:30) 100.0% (ETA: 00:00:00) 3.000g/s 100.0p/s 100.0c/s 100.0C/s password123..secretpass
Session completed.

Para visualizar as senhas quebradas novamente, você pode usar a opção --show:

john --show sha1_hashes_for_john.txt

Este comando exibirá todos os hashes que o John quebrou com sucesso e armazenou em seu arquivo pot interno.

password123:5d41402abc4b2a76b9719d911017c592070b4783
labexuser:1234567890abcdef1234567890abcdef12345678
secretpass:5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

3 password hashes cracked, 0 left

Analisar o Desempenho de Quebra de SHA1

Nesta etapa, você analisará brevemente o desempenho do John the Ripper na quebra de hashes SHA1. Embora nosso exemplo use uma wordlist muito pequena e senhas simples, em um cenário do mundo real, o desempenho da quebra é um fator crítico.

O John the Ripper fornece algumas métricas de desempenho em sua saída, como "g/s" (guesses per second - tentativas por segundo) e "p/s" (passwords per second - senhas por segundo). Essas métricas indicam quantas tentativas de senha o John pode fazer por segundo.

Vamos executar novamente o comando de quebra e observar a saída cuidadosamente:

john --format=raw-sha1 --wordlist=wordlist.txt sha1_hashes_for_john.txt

Procure por linhas semelhantes a esta na saída:

3g 0:00:00:00 DONE (2023-10-27 10:30) 100.0% (ETA: 00:00:00) 3.000g/s 100.0p/s 100.0c/s 100.0C/s password123..secretpass

Aqui, 3.000g/s indica que o John processou 3 tentativas por segundo, e 100.0p/s indica 100 senhas por segundo. Para um conjunto tão pequeno de hashes e uma wordlist minúscula, a quebra é quase instantânea.

Fatores que afetam o desempenho da quebra:

• Complexidade da Senha: Senhas simples e comuns são quebradas muito mais rapidamente do que senhas complexas e únicas.
• Tamanho e Qualidade da Wordlist: Uma wordlist maior e mais relevante aumenta as chances de quebra, mas também aumenta o tempo necessário.
• Algoritmo de Hash: Alguns algoritmos de hash são projetados para serem computacionalmente intensivos (por exemplo, bcrypt, scrypt) para desacelerar as tentativas de quebra, enquanto outros como o SHA1 bruto são relativamente rápidos.
• Hardware: O poder de processamento (CPU/GPU) da máquina de quebra impacta significativamente o desempenho.

Esta breve análise destaca que, mesmo com uma ferramenta poderosa como o John the Ripper, a força da senha original e o algoritmo de hash desempenham um papel crucial no tempo necessário para quebrar um hash.

Compreender as Características do Hash SHA1

Nesta etapa, você obterá uma compreensão mais profunda das características do hash SHA1 e por que é importante usar algoritmos de hash mais fortes para o armazenamento de senhas.

Características Principais do SHA1:

1. Tamanho de Saída Fixo: O SHA1 sempre produz um valor de hash de 160 bits (20 bytes), independentemente do tamanho da entrada. É por isso que você vê uma string hexadecimal de 40 caracteres.
2. Função Unidirecional (One-Way Function): É computacionalmente inviável reverter o processo de hashing para obter a entrada original a partir do hash. É por isso que a quebra depende de ataques de força bruta (brute-force) ou de dicionário.
3. Determinístico: A mesma entrada sempre produzirá o mesmo hash SHA1. Essa propriedade é essencial para verificar a integridade dos dados.
4. Efeito Avalanche: Uma pequena alteração na entrada (mesmo um único bit) resulta em uma saída de hash drasticamente diferente. Isso torna difícil adivinhar entradas com base em semelhanças de hash.

Por que o SHA1 é considerado inseguro para armazenamento de senhas:

• Ataques de Colisão: Em 2017, um ataque de colisão prático contra o SHA1 foi demonstrado. Uma colisão ocorre quando duas entradas diferentes produzem a mesma saída de hash. Embora encontrar uma colisão não revele diretamente a senha original, ela compromete a integridade da função de hash e pode ser explorada em vários ataques.
• Velocidade: O SHA1 é relativamente rápido de computar. Essa velocidade, combinada com o poder de computação moderno, o torna vulnerável a ataques de força bruta e de dicionário, especialmente para senhas comuns ou fracas.
• Falta de Salting: Hashes SHA1 brutos, como demonstrado neste laboratório, não incluem inerentemente "salting" (adição de sal). O salting envolve adicionar uma string única e aleatória a cada senha antes do hashing. Isso impede que tabelas de arco-íris pré-computadas sejam eficazes e garante que senhas idênticas tenham hashes diferentes, mesmo que armazenadas no mesmo banco de dados.

Para o armazenamento seguro de senhas hoje, algoritmos de hash mais fortes, mais lentos e com salting, como bcrypt, scrypt ou Argon2, são recomendados. Esses algoritmos são projetados para serem computacionalmente intensivos, tornando os ataques de força bruta muito mais demorados e caros.

Este laboratório demonstrou os princípios fundamentais da quebra de hash usando SHA1. Serve como um lembrete da importância de usar algoritmos de hash robustos e senhas fortes e únicas para proteger informações confidenciais.

Resumo

Neste laboratório, você aprendeu com sucesso como gerar hashes SHA1 a partir de senhas em texto puro e prepará-las para quebra. Em seguida, você usou o John the Ripper no modo de wordlist para quebrar esses hashes SHA1, recuperando as senhas originais. Além disso, você obteve insights sobre os fatores que afetam o desempenho da quebra de hash e compreendeu as características principais do SHA1, incluindo por que ele não é mais considerado seguro para armazenamento de senhas devido à sua velocidade e suscetibilidade a ataques de colisão. Essa experiência prática reforça a importância de usar senhas fortes e únicas e algoritmos de hash modernos e robustos como bcrypt, scrypt ou Argon2 para gerenciamento seguro de senhas.