Opções Avançadas de Linha de Comando do John the Ripper

Introdução

John the Ripper é um cracker de senhas rápido, disponível para diversas variantes do Unix, macOS, Windows e DOS. Seu propósito principal é detectar senhas fracas do Unix. Além de vários tipos de hash de senha crypt(3) mais comumente encontrados em vários sistemas Unix, suportados nativamente estão Kerberos AFS e hashes LM do Windows, além de centenas de outros tipos de hash e cifra na versão aprimorada pela comunidade.

Neste laboratório, você se aprofundará nas capacidades do John the Ripper explorando algumas de suas opções avançadas de linha de comando. Compreender essas opções permitirá que você ajuste suas tentativas de quebra de senha, gerencie sessões de longa duração e redirecione a saída para análise posterior. Você aprenderá como especificar formatos de hash, aplicar regras personalizadas, gerenciar sessões de cracking e usar a opção --stdout para gerar listas de palavras (wordlists).

Explorar a Opção --format em Detalhe

Nesta etapa, você aprenderá a usar a opção --format no John the Ripper. Esta opção é crucial ao lidar com vários tipos de hashes de senha, pois informa ao John qual tipo de hash esperar e como processá-lo. O John the Ripper suporta uma ampla gama de formatos de hash, desde hashes crypt tradicionais do Unix até hashes modernos específicos de aplicativos.

Primeiro, vamos listar os formatos de hash disponíveis que o John the Ripper suporta. Isso lhe dará uma ideia da versatilidade da ferramenta.

john --list=formats

Você verá uma longa lista de formatos. Por exemplo, crypt para hashes Unix tradicionais, raw-md5 para hashes MD5 simples, nt para hashes do Windows NT e muitos outros.

Agora, vamos tentar quebrar uma senha do nosso arquivo passwords.txt, visando especificamente um formato conhecido. Temos um usuário user1 com um hash SHA512 crypt. Podemos dizer explicitamente ao John para usar o formato sha512crypt.

john --format=sha512crypt /home/labex/project/passwords.txt --wordlist=/home/labex/project/wordlist.txt

Se a senha para user1 (que é password123 em nossa configuração) estiver na lista de palavras (wordlist), o John a quebrará.

Em seguida, vamos tentar quebrar um hash LM (user5) e um hash NT (user6) do arquivo passwords.txt. O John geralmente pode auto-detectar formatos, mas especificá-los explicitamente com --format pode ser mais rápido e confiável, especialmente ao lidar com tipos de hash mistos ou formatos menos comuns.

john --format=lm /home/labex/project/passwords.txt --wordlist=/home/labex/project/wordlist.txt
john --format=nt /home/labex/project/passwords.txt --wordlist=/home/labex/project/wordlist.txt

Você pode ver uma saída semelhante a esta, indicando o processo de cracking:

Using default input encoding: UTF-8
Loaded 1 password hash (sha512crypt, crypt(3) $6$ [SHA512 256/256 AVX2])
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (user1)
1g 0:00:00:00 DONE (2023-10-27 10:00) 100% (ETA: 10:00) 1.000g/s 1.000p/s 1.000c/s 1.000C/s password123
Session completed

Esta etapa demonstra a importância da opção --format para um cracking de senha eficiente e preciso.

Utilizar a Opção --rules com Regras Personalizadas

Nesta etapa, você explorará a opção --rules, que permite ao John the Ripper aplicar um conjunto de regras predefinidas ou personalizadas a palavras de uma lista de palavras (wordlist). Regras são transformações poderosas que podem ser aplicadas a palavras, como anexar números, alterar maiúsculas/minúsculas ou duplicar caracteres, aumentando significativamente as chances de quebrar senhas que são variações de palavras comuns.

O John vem com vários conjuntos de regras integrados, como Wordlist (padrão), Single e Jumbo. Você pode listar os conjuntos de regras disponíveis usando:

john --list=rules

Este comando exibirá uma lista de conjuntos de regras.

Agora, vamos usar um arquivo de regras personalizado. Criamos um arquivo de regras personalizado simples chamado custom_rules.txt na configuração, que contém regras como :$[0-9] (anexar um dígito) e Az (capitalizar a primeira letra).

Vamos tentar quebrar user1 novamente, mas desta vez usando nossas regras personalizadas. Suponha que a senha de user1 fosse Password123 (P maiúsculo, depois 123). Nossa lista de palavras (wordlist) contém apenas password. A regra Az capitalizará a primeira letra e :$[0-9] anexará um dígito.

john --wordlist=/home/labex/project/wordlist.txt --rules=/home/labex/project/custom_rules.txt /home/labex/project/passwords.txt --format=sha512crypt

Este comando aplicará as regras de custom_rules.txt a cada palavra em wordlist.txt antes de tentar combiná-las com os hashes. Por exemplo, password pode se tornar Password, password0, password1, etc., e então Password0, Password1, etc.

Você também pode combinar regras com a opção --stdout (que abordaremos na próxima etapa) para ver quais palavras são geradas por suas regras:

john --wordlist=/home/labex/project/wordlist.txt --rules=/home/labex/project/custom_rules.txt --stdout

Este comando imprimirá todas as palavras geradas pela aplicação de custom_rules.txt a wordlist.txt em seu terminal. Isso é útil para depurar seus conjuntos de regras.

A opção --rules é um recurso poderoso para estender a eficácia dos ataques de lista de palavras (wordlist attacks) gerando variações comuns de senhas.

Compreender as Opções --session e --restore

Nesta etapa, você aprenderá sobre as opções --session e --restore, que são vitais para gerenciar tarefas de cracking de senha de longa duração. Quebrar senhas complexas pode levar horas, dias ou até semanas. Essas opções permitem salvar o estado atual de uma sessão de cracking e retomá-la mais tarde sem perder o progresso.

Quando o John the Ripper é executado, ele cria automaticamente um arquivo de sessão (geralmente john.rec no diretório de execução) para salvar seu estado. No entanto, usar a opção --session permite especificar um nome personalizado para este arquivo de sessão, o que é útil ao executar várias tarefas de cracking simultaneamente ou quando você deseja manter logs de sessão específicos.

Vamos iniciar uma sessão de cracking para user1 e especificar um nome de sessão:

john --session=my_cracking_session /home/labex/project/passwords.txt --wordlist=/home/labex/project/wordlist.txt --format=sha512crypt

Deixe o cracking rodar por alguns segundos, depois pressione Ctrl+C para interrompê-lo. Você verá uma mensagem indicando que a sessão foi salva.

Agora, liste os arquivos em seu diretório atual para ver o arquivo de sessão:

ls -l /home/labex/project/

Você deverá ver um arquivo chamado my_cracking_session.rec (ou similar, dependendo da versão e configuração do John).

Para retomar a sessão interrompida, use a opção --restore com o nome da sessão:

john --restore=my_cracking_session

O John continuará exatamente de onde parou. Isso é incrivelmente útil para gerenciar operações de cracking em larga escala ou quando seu sistema precisa ser reiniciado.

Se você não especificar um nome de sessão com --session, o John usará um arquivo de sessão padrão. Usar --restore sem um nome de sessão tentará restaurar a sessão padrão.

john --restore

Esta etapa destaca como gerenciar e retomar efetivamente seus esforços de cracking de senha, garantindo que nenhum progresso seja perdido.

Experimentar com --stdout para Redirecionamento de Saída

Nesta etapa, você aprenderá sobre a opção --stdout, que é extremamente útil para gerar listas de palavras (wordlists) ou testar conjuntos de regras sem realizar uma tentativa de cracking real. Quando usada com --stdout, o John the Ripper emitirá as senhas candidatas geradas para a saída padrão (standard output), que pode então ser redirecionada para um arquivo ou canalizada (piped) para outra ferramenta.

Isso é particularmente poderoso quando combinado com listas de palavras (wordlists) e regras. Você pode usar o John para criar listas de palavras altamente personalizadas com base em listas existentes e regras específicas.

Vamos gerar uma lista de palavras aplicando nosso custom_rules.txt ao wordlist.txt e redirecionar a saída para um novo arquivo chamado generated_wordlist.txt:

john --wordlist=/home/labex/project/wordlist.txt --rules=/home/labex/project/custom_rules.txt --stdout > /home/labex/project/generated_wordlist.txt

Após executar o comando, verifique o conteúdo do arquivo recém-criado:

cat /home/labex/project/generated_wordlist.txt

Você deverá ver palavras como password, Password, password0, password1, etc., geradas pelas regras.

Você também pode usar --stdout para gerar permutações de uma única palavra. Por exemplo, para gerar variações da palavra "test":

echo "test" | john --pipe --rules=/home/labex/project/custom_rules.txt --stdout

Aqui, echo "test" | john --pipe canaliza a palavra "test" para a entrada padrão do John, e --pipe instrui o John a ler da entrada padrão. O --stdout então emite as variações aplicadas pelas regras.

A opção --stdout é um recurso versátil para pré-processar listas de palavras (wordlists), criar dicionários personalizados para outras ferramentas de cracking ou simplesmente entender como suas regras transformam palavras.

Descobrir Outras Flags Úteis de Linha de Comando

Nesta etapa final, você explorará brevemente algumas outras flags úteis de linha de comando que podem aprimorar seu uso do John the Ripper. Embora não entremos em detalhes para cada uma, saber que elas existem pode ajudá-lo em vários cenários.

1. --show: Esta opção exibe as senhas quebradas de uma sessão anterior. Após quebrar senhas, o John as armazena em seu arquivo john.pot. Você pode visualizá-las usando:

   john --show /home/labex/project/passwords.txt

   Isso mostrará quaisquer senhas que o John quebrou com sucesso do arquivo passwords.txt.

2. --incremental: Este é um modo poderoso para ataques de força bruta (brute-force). O John gerará senhas com base em conjuntos de caracteres e comprimentos. Você pode especificar um modo (por exemplo, alnum, digits, all).

   ## Este comando rodará por muito tempo, então apenas demonstraremos seu uso.
   ## NÃO o deixe rodar por muito tempo. Pressione Ctrl+C para pará-lo após alguns segundos.
   john --incremental=digits /home/labex/project/passwords.txt --format=raw-md5

   Este comando tenta quebrar senhas gerando combinações de dígitos.

3. --fork=<N>: Esta opção permite que o John use múltiplos núcleos de CPU ou threads para cracking, onde <N> é o número de forks (processos) a serem usados. Isso pode acelerar significativamente o cracking em sistemas multi-core.

   john --fork=2 /home/labex/project/passwords.txt --wordlist=/home/labex/project/wordlist.txt --format=sha512crypt

   Isso tentará quebrar senhas usando 2 núcleos de CPU.

4. --mask: Esta opção permite realizar ataques de máscara (mask attacks), onde você define um padrão específico para a senha. Por exemplo, ?l?l?l?d?d tentaria todas as combinações de 3 letras e 2 dígitos.

   ## Este comando rodará por muito tempo, então apenas demonstraremos seu uso.
   ## NÃO o deixe rodar por muito tempo. Pressione Ctrl+C para pará-lo após alguns segundos.
   john --mask=?l?l?l?d?d /home/labex/project/passwords.txt --format=raw-md5

   Este comando tenta quebrar senhas que se encaixam na máscara especificada.

Estas são apenas algumas das muitas opções avançadas disponíveis no John the Ripper. Explorar a página man john ou john --help revelará ainda mais possibilidades para tarefas especializadas de auditoria e cracking de senhas.

Resumo

Neste laboratório, você adquiriu experiência prática com várias opções avançadas de linha de comando para o John the Ripper. Você aprendeu como especificar precisamente formatos de hash usando --format, aplicar transformações poderosas a listas de palavras (wordlists) com --rules e arquivos de regras personalizados, e gerenciar sessões de cracking de longa duração usando --session e --restore. Além disso, você explorou a versatilidade do --stdout para gerar listas de palavras (wordlists) personalizadas e abordou brevemente outras flags úteis como --show, --incremental, --fork e --mask.

Dominar essas opções aumentará significativamente sua capacidade de realizar auditoria e cracking de senhas eficazes, tornando-o mais proficiente no uso do John the Ripper para diversas tarefas de segurança. Continue explorando a extensa documentação do John para descobrir ainda mais recursos e técnicas avançadas.