Usar John the Ripper para Quebrar Hashes NTLM

Introdução

Neste laboratório, você ganhará experiência prática em quebrar hashes NTLM (NT LAN Manager) usando John the Ripper, uma poderosa ferramenta de quebra de senhas. Os hashes NTLM são comumente usados em ambientes Windows para armazenar senhas de usuários. Compreender como esses hashes podem ser quebrados é crucial para entender as vulnerabilidades de segurança de senhas e implementar medidas de segurança mais fortes.

Você começará simulando a extração de hashes NTLM, depois aprenderá a formatá-los corretamente para o John the Ripper. Subsequentemente, você usará dois métodos principais de quebra: ataques de dicionário com uma lista de palavras (wordlist) e ataques de força bruta usando modo incremental. Finalmente, você refletirá sobre as implicações de segurança dos hashes NTLM e a importância de políticas de senhas fortes. Este laboratório oferece uma abordagem prática a um conceito fundamental em cibersegurança.

Extrair Hashes NTLM de um Sistema

Nesta etapa, você simulará a extração de hashes NTLM. Em um cenário do mundo real, os hashes NTLM podem ser extraídos de várias fontes, como o banco de dados Security Account Manager (SAM) em sistemas Windows, Active Directory ou tráfego de rede. Para este laboratório, já fornecemos um arquivo chamado hashes.txt em seu diretório ~/project, que contém hashes NTLM de exemplo.

Primeiro, vamos verificar a presença do arquivo hashes.txt e examinar seu conteúdo. Este arquivo contém várias linhas, cada uma representando uma entrada de usuário com seu hash NTLM. O formato geralmente inclui nome de usuário, ID do usuário, hash LM (geralmente vazio ou padrão), hash NTLM e outros campos. Focaremos na parte do hash NTLM.

Use o comando ls para listar os arquivos em seu diretório atual e, em seguida, use o comando cat para exibir o conteúdo de hashes.txt.

ls -l ~/project/hashes.txt
cat ~/project/hashes.txt

Você deverá ver uma saída semelhante a esta, mostrando os detalhes do arquivo e seu conteúdo:

-rw-r--r-- 1 labex labex 300 Mar 10 10:00 /home/labex/project/hashes.txt
user1:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
user2:501:aad3b435b51404eeaad3b435b51404ee:209c6174efb4b710:209c6174efb4b710:::
user3:502:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad065adec1000000:::
user4:503:aad3b435b51404eeaad3b435b51404ee:e52cac67419a9a224a30370a31323334:::
user5:504:aad3b435b51404eeaad3b435b51404ee:d41d8cd98f00b204e9800998ecf8427e:::

O hash NTLM é o quarto campo em cada linha, separado por dois pontos. Por exemplo, para user1, o hash NTLM é 31d6cfe0d16ae931b73c59d7e0c089c0.

Formatar Hashes NTLM para John the Ripper

Nesta etapa, você preparará os hashes NTLM para o John the Ripper. Embora o John the Ripper geralmente consiga lidar com vários formatos de hash automaticamente, é uma boa prática entender a entrada esperada. Para hashes NTLM, o John the Ripper tipicamente espera o formato nome_de_usuário:hash_NTLM.

Nosso arquivo hashes.txt contém campos adicionais. Precisamos extrair apenas o nome de usuário e o hash NTLM. Podemos usar o comando cut para conseguir isso. O comando cut pode extrair seções de cada linha de arquivos. Usaremos : como delimitador e selecionaremos o primeiro e o quarto campos.

Execute o seguinte comando para extrair e formatar os hashes, e então redirecione a saída para um novo arquivo chamado ntlm_hashes.txt em seu diretório ~/project.

cut -d ':' -f 1,4 ~/project/hashes.txt > ~/project/ntlm_hashes.txt
cat ~/project/ntlm_hashes.txt

Você deverá ver os hashes formatados, prontos para o John the Ripper:

user1:31d6cfe0d16ae931b73c59d7e0c089c0
user2:209c6174efb4b710
user3:8846f7eaee8fb117ad065adec1000000
user4:e52cac67419a9a224a30370a31323334
user5:d41d8cd98f00b204e9800998ecf8427e

Este arquivo ntlm_hashes.txt agora contém apenas o nome de usuário e o hash NTLM correspondente, que é o formato ideal para o John the Ripper.

Quebrar Hashes NTLM com uma Wordlist

Nesta etapa, você usará o John the Ripper para quebrar os hashes NTLM usando uma wordlist (também conhecida como ataque de dicionário). Uma wordlist é um arquivo que contém uma lista de senhas comuns, palavras de dicionário ou senhas vazadas anteriormente. Este é frequentemente o método mais eficaz para quebrar senhas fracas.

Nós fornecemos um arquivo de wordlist simples chamado wordlist.txt em seu diretório ~/project. Vamos primeiro inspecionar seu conteúdo.

cat ~/project/wordlist.txt

Você deverá ver o seguinte conteúdo:

password
123456
qwerty
admin
test

Agora, use o John the Ripper com o wordlist.txt para quebrar os hashes em ntlm_hashes.txt. O comando john --format=NT --wordlist=wordlist.txt ntlm_hashes.txt especifica o formato do hash como NTLM (NT), a wordlist a ser usada e o arquivo que contém os hashes.

john --format=NT --wordlist=~/project/wordlist.txt ~/project/ntlm_hashes.txt

O John the Ripper tentará quebrar os hashes. Você poderá ver uma saída semelhante a esta, indicando quais hashes foram quebrados:

Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (NT [MD4 HASHES])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
123456           (user4)
test             (user2)
password         (user1)
3g 0:00:00:00 DONE (2023-10-27 08:00) 100.0% (ETA: 08:00) 3.750g/s 11.25p/s 11.25c/s 11.25C/s 123456...test
Session completed.

Após o processo de quebra, você pode visualizar as senhas quebradas usando o comando john --show.

john --show ~/project/ntlm_hashes.txt

A saída listará os hashes quebrados e suas senhas de texto plano correspondentes:

user1:password
user2:test
user4:123456

3 password hashes cracked, 2 left

Isso mostra que a senha do user1 era password, a do user2 era test e a do user4 era 123456. Os outros dois hashes (user3 e user5) não foram quebrados por esta wordlist, indicando que suas senhas podem ser mais fortes ou não estão presentes em nossa wordlist simples.

Quebrar Hashes NTLM com Modo Incremental

Nesta etapa, você explorará o modo incremental do John the Ripper, que realiza um ataque de força bruta. Ao contrário dos ataques com wordlist, o modo incremental tenta combinações de caracteres sistematicamente, começando com combinações curtas e simples e aumentando gradualmente a complexidade. Este método é eficaz para quebrar senhas que não estão em uma wordlist, mas pode consumir muito tempo para senhas longas ou complexas.

O modo incremental do John the Ripper usa conjuntos de caracteres e regras para gerar senhas. Para hashes NTLM, podemos especificar o formato NT e usar a opção --incremental. O John the Ripper possui modos incrementais integrados (por exemplo, alnum, digits, all). Usaremos o modo incremental padrão, que tenta vários conjuntos de caracteres.

Antes de executar o modo incremental, é uma boa prática redefinir a sessão do John the Ripper para evitar conflitos com hashes previamente quebrados.

john --session=reset

Agora, execute o John the Ripper no modo incremental contra o arquivo ntlm_hashes.txt. Este processo pode levar alguns momentos, dependendo da complexidade dos hashes restantes não quebrados.

john --format=NT --incremental ~/project/ntlm_hashes.txt

Você poderá ver uma saída semelhante a esta enquanto o John the Ripper tenta quebrar os hashes restantes:

Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (NT [MD4 HASHES])
Remaining 2 password hashes to crack
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
(user5)
(user3)
2g 0:00:00:00 DONE (2023-10-27 08:05) 100.0% (ETA: 08:05) 2.500g/s 7.500p/s 7.500c/s 7.500C/s
Session completed.

Após a conclusão do processo, verifique as senhas quebradas novamente usando john --show.

john --show ~/project/ntlm_hashes.txt

Você deverá agora ver todos os hashes quebrados, incluindo user3 e user5. A senha para user3 é admin e para user5 é uma string vazia (que é representada como "" ou nada após os dois pontos).

user1:password
user2:test
user4:123456
user3:admin
user5:

5 password hashes cracked, 0 left

Isso demonstra a eficácia do modo incremental para quebrar senhas que podem não estar em uma wordlist, especialmente as curtas ou simples.

Compreender a Segurança de Hashes NTLM

Nesta etapa, você refletirá sobre as implicações de segurança dos hashes NTLM e a importância de práticas de senhas fortes. Você viu como senhas relativamente simples podem ser rapidamente quebradas usando wordlists e como até mesmo senhas curtas e não dicionárias podem ser encontradas com métodos de força bruta como o modo incremental.

Os hashes NTLM são conhecidos por serem vulneráveis devido a vários fatores:

• Falta de Salting (Sal): Ao contrário de algoritmos de hashing modernos (por exemplo, bcrypt, scrypt), os hashes NTLM não usam um "sal". Um sal é um dado aleatório adicionado a uma senha antes do hashing, tornando cada hash único mesmo para senhas idênticas. Sem salting, os atacantes podem usar tabelas pré-computadas (tabelas rainbow) para quebrar hashes rapidamente.
• Algoritmo de Hashing Fraco: O NTLM usa MD4, que é um algoritmo de hashing relativamente antigo e criptograficamente fraco.
• Insensibilidade a Maiúsculas/Minúsculas (para hash LM, embora NTLM seja sensível a maiúsculas/minúsculas): Embora o NTLM em si seja sensível a maiúsculas/minúsculas, seu predecessor, o hash LM, não era, levando a confusão e, às vezes, a práticas de senhas mais fracas.

Para mitigar os riscos associados à quebra de hashes NTLM, organizações e usuários devem:

• Impor Políticas de Senhas Fortes: Exigir senhas longas e complexas que combinem letras maiúsculas e minúsculas, números e caracteres especiais. Isso torna os ataques com wordlist e força bruta significativamente mais difíceis.
• Implementar Autenticação Multifator (MFA): A MFA adiciona uma camada extra de segurança além de apenas uma senha, tornando muito mais difícil para os atacantes obterem acesso não autorizado, mesmo que quebrem uma senha.
• Usar Algoritmos de Hashing Modernos: Para novos sistemas ou ao migrar, prefira algoritmos de hashing modernos, salgados e adaptativos como bcrypt, scrypt ou Argon2.
• Auditar e Monitorar Regularmente: Monitore continuamente tentativas de login suspeitas e audite a força das senhas.

Ao compreender as vulnerabilidades dos hashes NTLM e implementar medidas de segurança robustas, você pode melhorar significativamente a postura de segurança de sistemas e contas de usuário.

Resumo

Neste laboratório, você aprendeu com sucesso a usar o John the Ripper para quebrar hashes NTLM. Você começou entendendo como os hashes NTLM são estruturados e, em seguida, os formatou para uso ideal com o John the Ripper. Em seguida, aplicou duas técnicas comuns de quebra de senhas: ataques com wordlist e ataques incrementais (força bruta), demonstrando sua eficácia contra senhas fracas e simples.

Você também obteve insights sobre as fraquezas de segurança dos hashes NTLM, como a falta de salting e o uso de um algoritmo de hashing mais fraco. Essa compreensão é crucial para apreciar a importância de políticas de senhas fortes, autenticação multifator e a adoção de algoritmos de hashing modernos e robustos para proteger informações confidenciais. Esta experiência prática fornece uma compreensão fundamental da segurança de senhas e metodologias de quebra comuns.