Introdução
Neste laboratório, você explorará as poderosas capacidades de cracking baseadas em regras do John the Ripper (JtR). Embora ataques simples de dicionário sejam eficazes, senhas do mundo real frequentemente envolvem variações como capitalização, números anexados ou caracteres especiais. O motor de regras do JtR permite definir transformações complexas para aplicar a palavras em uma wordlist, aumentando significativamente as chances de quebrar senhas que não estão diretamente presentes no dicionário. Você aprenderá a sintaxe básica das regras do JtR, criará suas próprias regras personalizadas e as aplicará a uma wordlist para observar seu efeito.
Compreender a Sintaxe de Regras do John the Ripper
Nesta etapa, você aprenderá a sintaxe básica das regras do John the Ripper (JtR). As regras do JtR são definidas em um arquivo de configuração, tipicamente john.conf, ou podem ser passadas diretamente pela linha de comando para casos simples. Cada regra é uma sequência de comandos de um único caractere que modificam uma palavra.
Comandos de regra comuns incluem:
c: Capitaliza a primeira letra.C: Capitaliza todas as letras.l: Transforma a primeira letra em minúscula.L: Transforma todas as letras em minúsculas.t: Alterna a capitalização da primeira letra.T: Alterna a capitalização de todas as letras.p<N>: Adiciona o caractere<N>no início.a<N>: Adiciona o caractere<N>no final.s<old><new>: Substitui a primeira ocorrência de<old>por<new>.S<old><new>: Substitui todas as ocorrências de<old>por<new>.x<N>: Extrai uma subcadeia de comprimentoNdo início.z<N>: Extrai uma subcadeia de comprimentoNdo final.D: Exclui o primeiro caractere.M: Exclui o último caractere.r: Inverte a palavra.
Vamos começar visualizando o arquivo padrão john.conf para ver alguns exemplos de regras integradas.
Abra o arquivo john.conf usando nano:
nano /etc/john.conf
Percorra o arquivo para encontrar a seção [List.Rules:Wordlist]. Você verá vários conjuntos de regras definidos lá. Por exemplo, você pode ver regras como c (capitalizar a primeira letra) ou a[0-9] (adicionar um dígito no final).
Pressione Ctrl+X para sair do nano.
Agora, vamos tentar uma regra simples diretamente da linha de comando usando a opção --stdout do JtR, que aplica regras a uma wordlist e imprime os resultados na saída padrão sem tentar quebrar hashes. Isso é útil para testar regras.
Execute o seguinte comando para aplicar a regra c (capitalizar a primeira letra) à sua wordlist.txt:
john --wordlist=~/project/wordlist.txt --rules=single --stdout
Você deverá ver as palavras da sua wordlist.txt com a primeira letra capitalizada. Por exemplo, "password" se torna "Password".
Password
Secret
Labex
Test
Isso demonstra como uma regra simples pode transformar palavras. Nas próximas etapas, você criará e combinará regras mais complexas.
Criar uma Regra Simples para Capitalização
Nesta etapa, você criará um arquivo de regras personalizado para aplicar regras de capitalização. Embora o conjunto de regras single no JtR inclua capitalização básica, a criação do seu próprio arquivo de regras lhe dá mais controle e permite transformações mais específicas.
Primeiro, crie um novo arquivo chamado my_rules.rule no seu diretório ~/project. Este arquivo conterá suas regras personalizadas.
nano ~/project/my_rules.rule
Adicione as seguintes linhas ao arquivo my_rules.rule. Estas regras irão:
c: Capitalizar a primeira letra.C: Capitalizar todas as letras.t: Alternar a capitalização da primeira letra (por exemplo, "password" -> "Password", "Password" -> "password").
c
C
t
Salve o arquivo pressionando Ctrl+O, depois Enter, e saia do nano pressionando Ctrl+X.
Agora, aplique estas regras personalizadas à sua wordlist.txt usando a opção --rules, especificando seu novo arquivo de regras.
john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout
Observe a saída. Você deverá ver cada palavra da sua wordlist.txt transformada por cada uma das regras que você definiu. Por exemplo, "password" aparecerá como "Password", "PASSWORD", e "Password" (devido à regra t aplicada à "password" original).
Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
Isso demonstra como definir e usar um arquivo de regras personalizado. Cada regra no arquivo é aplicada sequencialmente a cada palavra na wordlist.
Aplicar Regras para Anexar Números
Nesta etapa, você aprenderá como anexar números a palavras usando regras do JtR. Anexar números é uma variação de senha muito comum, e o JtR fornece comandos poderosos para gerar essas variações de forma eficiente.
O comando a<N> anexa um caractere <N>. Para anexar dígitos, você pode usar intervalos de caracteres como a[0-9] para anexar um único dígito de 0 a 9. Você também pode combinar isso com outras regras.
Vamos adicionar regras ao my_rules.rule para anexar números. Abra seu arquivo de regras novamente:
nano ~/project/my_rules.rule
Adicione as seguintes linhas ao final do arquivo. Estas regras irão:
a[0-9]: Anexar um único dígito (0-9) à palavra.a[0-9][0-9]: Anexar dois dígitos (00-99) à palavra. Esta regra gerará 100 variações para cada palavra.
a[0-9]
a[0-9][0-9]
Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X).
Agora, aplique estas regras atualizadas à sua wordlist.txt. Como a[0-9][0-9] gera muitas variações, limitaremos a saída usando head para fins de demonstração.
john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50
Você verá palavras como "password0", "password1", ..., "password00", "password01", etc. O comando head -n 50 limita a saída às primeiras 50 linhas, pois a saída completa seria muito longa.
Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labex7
labex8
labex9
test0
test1
test2
test3
test4
test5
Isso mostra como gerar efetivamente variações com números anexados, que são cruciais para quebrar padrões comuns de senhas.
Combinar Múltiplas Regras para Transformações Complexas
Nesta etapa, você combinará múltiplos comandos de regras para criar transformações de senha mais complexas. O JtR permite encadear comandos de regras em uma única linha, aplicando-os sequencialmente a cada palavra.
Vamos criar uma regra que capitaliza a primeira letra e, em seguida, anexa um único dígito.
Abra seu arquivo my_rules.rule novamente:
nano ~/project/my_rules.rule
Adicione a seguinte regra ao final do arquivo. Esta regra ca[0-9] significa:
c: Capitalizar a primeira letra.a[0-9]: Anexar um único dígito (0-9).
ca[0-9]
Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X).
Agora, aplique estas regras atualizadas à sua wordlist.txt e observe a saída. Novamente, usaremos head para limitar a saída.
john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50
Você deverá ver variações como "Password0", "Password1", "Secret0", "Secret1", etc.
Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labexex7
labex8
labex9
test0
test1
test2
test3
test4
test5
Password0
Password1
Password2
Password3
Password4
Password5
Password6
Password7
Password8
Password9
Isso demonstra o poder de combinar regras. Você pode criar conjuntos de regras muito específicos e eficazes encadeando comandos. Por exemplo, s@a!ca[0-9] substituiria '@' por '!', capitalizaria a primeira letra e, em seguida, anexaria um dígito.
Testar Regras Personalizadas em uma Wordlist
Nesta etapa final, você usará suas regras personalizadas para tentar quebrar um hash fictício. Isso simulará um cenário de quebra de senha do mundo real.
Lembre-se de que na configuração, um hash para a palavra "password" foi criado e salvo em ~/project/hashes.txt. O hash é user1:5f4dcc3b5aa765d61d8327deb882cf99 (hash MD5 de "password").
Primeiro, vamos garantir que seu arquivo my_rules.rule contenha uma regra que geraria "password" ou uma variação dela que corresponda ao hash. Para este exemplo, assumiremos que o hash é para a palavra original "password". Se você tivesse um hash para "Password0", sua regra ca[0-9] seria útil.
Para esta demonstração, usaremos a wordlist.txt original e sua my_rules.rule para tentar quebrar o hash.
Execute o John the Ripper com seu arquivo de hashes, wordlist e regras personalizadas:
john ~/project/hashes.txt --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule
O John the Ripper começará a processar a wordlist, aplicando suas regras e comparando as palavras geradas com o hash. Se encontrar uma correspondência, exibirá a senha quebrada.
Você deverá ver uma saída semelhante a esta, indicando que a senha foi quebrada:
Using default input encoding: UTF-8
Loaded 1 password hash (md5crypt, crypt(3) $1$ [MD5 SSSP])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password (user1)
1g 0:00:00:00 DONE (2023-10-27 10:30) 100% (ETA: 00:00:00)
Session completed.
Para visualizar a senha quebrada novamente, você pode usar a opção --show:
john --show ~/project/hashes.txt
Este comando exibirá quaisquer senhas que o JtR quebrou com sucesso e armazenou em seu arquivo pot.
user1:password
1 password hash cracked, 0 left
Esta etapa final demonstra a aplicação prática de regras personalizadas na quebra de senhas. Ao criar regras de forma inteligente, você pode aumentar significativamente a eficácia de seus ataques de dicionário contra vários padrões de senha.
Resumo
Neste laboratório, você aprendeu com sucesso como alavancar o poderoso motor de regras do John the Ripper para quebra de senhas avançada. Você começou entendendo a sintaxe básica das regras do JtR, incluindo comandos para capitalização e alternância de maiúsculas/minúsculas. Em seguida, você criou seu próprio arquivo de regras personalizado e adicionou regras para anexar números, uma variação comum de senha. Finalmente, você combinou múltiplos comandos de regras para criar transformações mais complexas e aplicou suas regras personalizadas para quebrar um hash fictício, simulando um cenário do mundo real. Esta experiência prática o equipou com o conhecimento para definir e aplicar conjuntos de regras sofisticados, aumentando significativamente sua capacidade de quebrar senhas que não estão diretamente presentes em uma wordlist padrão.
