Criação Avançada de Regras para John the Ripper

Introdução

Neste laboratório, você irá explorar as capacidades avançadas do motor de regras do John the Ripper. John the Ripper é uma poderosa ferramenta de quebra de senhas, e seu motor de regras permite ataques altamente personalizados e eficientes. Compreender como criar regras eficazes é crucial para maximizar seu potencial. Você aprenderá sobre encadeamento de regras (rule chaining), criação de regras para transformações comuns como Leet Speak, desenvolvimento de regras para padrões de senha típicos, teste de conjuntos de regras complexos e otimização de desempenho de regras. Ao final deste laboratório, você terá uma compreensão sólida de como alavancar o motor de regras do John the Ripper para cenários de quebra de senhas mais sofisticados.

Compreender o Encadeamento de Regras

Nesta etapa, você aprenderá sobre o encadeamento de regras (rule chaining) no John the Ripper. O encadeamento de regras permite combinar múltiplas regras para criar transformações mais complexas. Isso é particularmente útil quando você precisa aplicar uma sequência de modificações a uma entrada da lista de palavras (wordlist).

Primeiro, vamos garantir que o John the Ripper esteja instalado. Se não estiver, você pode instalá-lo usando apt.

sudo apt update
sudo apt install -y john

Em seguida, criaremos um arquivo de lista de palavras simples chamado wordlist.txt no seu diretório ~/project.

echo "password" > ~/project/wordlist.txt
echo "secret" >> ~/project/wordlist.txt

Agora, vamos criar um arquivo de regras chamado chain_rules.rule em ~/project que demonstra o encadeamento básico de regras. Esta regra primeiro anexará "123" à palavra e depois capitalizará a primeira letra.

nano ~/project/chain_rules.rule

Adicione o seguinte conteúdo ao arquivo chain_rules.rule:

: A123 c

• : (dois pontos) indica o início de uma regra.
• A123 anexa "123" ao final da palavra.
• c capitaliza a primeira letra da palavra.

Salve o arquivo pressionando Ctrl+X, depois Y, e depois Enter.

Agora, vamos usar o John the Ripper com este arquivo de regras. Usaremos a opção --stdout para ver as palavras transformadas sem realmente quebrar senhas.

john --wordlist=~/project/wordlist.txt --rules=~/project/chain_rules.rule --stdout

Você deverá ver uma saída semelhante a esta:

Password123
Secret123

Isso demonstra como as regras são encadeadas: A123 é aplicado primeiro, e depois c é aplicado ao resultado.

Criar Regras para Transformações Leet Speak

Nesta etapa, você criará regras para realizar transformações Leet Speak. Leet Speak (ou "1337 Speak") é uma prática comum onde letras são substituídas por números ou símbolos que se assemelham a elas (por exemplo, 'a' se torna '4', 'e' se torna '3', 's' se torna '5'). Esta é uma técnica frequente usada em senhas.

Criaremos um novo arquivo de regras chamado leet_rules.rule no seu diretório ~/project. Este arquivo conterá regras para converter letras comuns em seus equivalentes Leet Speak.

nano ~/project/leet_rules.rule

Adicione o seguinte conteúdo ao arquivo leet_rules.rule:

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5

• s/old/new é uma regra de substituição. Ela substitui a primeira ocorrência de old por new.
• Estamos encadeando múltiplas regras de substituição para aplicar várias transformações Leet Speak.

Salve o arquivo pressionando Ctrl+X, depois Y, e depois Enter.

Agora, vamos testar essas regras com nosso wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/leet_rules.rule --stdout

Você deverá ver uma saída semelhante a esta:

p4ssw0rd
s3cr3t

Isso demonstra como você pode criar regras para lidar com variações comuns de Leet Speak, o que pode melhorar significativamente a eficácia de seus esforços de quebra de senhas contra usuários que empregam essas substituições.

Desenvolver Regras para Padrões Comuns de Senha

Nesta etapa, você desenvolverá regras que visam padrões comuns de senha, como anexar anos ou números comuns, ou capitalizar a primeira letra. Esses padrões são frequentemente usados por usuários para tornar suas senhas "mais fortes" sem realmente aumentar sua entropia.

Vamos criar um novo arquivo de regras chamado pattern_rules.rule no seu diretório ~/project. Este arquivo combinará várias transformações comuns.

nano ~/project/pattern_rules.rule

Adicione o seguinte conteúdo ao arquivo pattern_rules.rule:

: c A2023
: c A!
: c A@

• c capitaliza a primeira letra.
• A2023 anexa o ano "2023".
• A! anexa um ponto de exclamação.
• A@ anexa um símbolo de arroba.

Cada linha representa uma regra separada. O John the Ripper aplicará cada regra a cada palavra na lista de palavras independentemente.

Salve o arquivo pressionando Ctrl+X, depois Y, e depois Enter.

Agora, vamos testar essas regras com nosso wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/pattern_rules.rule --stdout

Você deverá ver uma saída semelhante a esta:

Password2023
Secret2023
Password!
Secret!
Password@
Secret@

Isso demonstra como você pode criar um conjunto de regras para cobrir padrões comuns de senha, expandindo significativamente sua superfície de ataque além de simples palavras de dicionário.

Testar Conjuntos de Regras Complexos

Nesta etapa, você combinará os conceitos aprendidos até agora para testar um conjunto de regras mais complexo. Isso envolve a criação de um arquivo de regras que incorpore transformações Leet Speak e adições de padrões comuns, demonstrando como vários tipos de regras podem ser usados em conjunto.

Vamos criar um arquivo de regras abrangente chamado complex_rules.rule no seu diretório ~/project. Este arquivo incluirá substituições Leet Speak e, em seguida, anexará números ou símbolos comuns.

nano ~/project/complex_rules.rule

Adicione o seguinte conteúdo ao arquivo complex_rules.rule:

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A123
: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A!

• A primeira regra aplica Leet Speak e, em seguida, anexa "123".
• A segunda regra aplica Leet Speak e, em seguida, anexa "!".

Salve o arquivo pressionando Ctrl+X, depois Y, e depois Enter.

Agora, vamos testar essas regras complexas com nosso wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/complex_rules.rule --stdout

Você deverá ver uma saída semelhante a esta:

p4ssw0rd123
s3cr3t123
p4ssw0rd!
s3cr3t!

Isso demonstra o poder de combinar diferentes tipos de regras para gerar uma ampla gama de candidatos a senhas potenciais, o que é essencial para uma quebra de senha eficaz.

Otimizar o Desempenho de Regras

Nesta etapa, você aprenderá sobre a otimização do desempenho de regras. Embora regras complexas sejam poderosas, elas também podem ser computacionalmente intensivas. O John the Ripper fornece mecanismos para otimizar a aplicação de regras, principalmente entendendo a ordem das operações e evitando regras redundantes.

Uma forma de otimizar é garantir que suas regras sejam o mais específicas possível e evitem gerar candidatos desnecessários. Por exemplo, se você sabe que uma senha sempre começará com uma letra maiúscula, aplicar uma regra que capitaliza todas as letras é ineficiente.

Considere o complex_rules.rule da etapa anterior. Cada regra aplica todas as substituições Leet Speak antes de anexar. Se você tivesse muitas regras desse tipo, repetir as substituições poderia ser menos eficiente do que aplicá-las uma vez e depois ramificar. No entanto, para casos simples, encadear dentro de uma única regra geralmente é eficiente o suficiente.

Para conjuntos de regras muito grandes ou cenários específicos, o John the Ripper permite sintaxe de regras mais avançada e arquivos de regras externos. Para este laboratório, focaremos em uma compreensão conceitual da otimização.

Uma técnica comum de otimização é filtrar sua lista de palavras ou direcionar padrões específicos com conjuntos de regras menores e separados, em vez de um único conjunto de regras massivo e abrangente.

Vamos demonstrar um conceito simples de otimização criando uma regra que só se aplica se a palavra for menor que um determinado comprimento, usando a regra l (length). Isso pode evitar a aplicação de regras complexas a palavras que já são muito longas para serem senhas comuns.

Crie um novo arquivo de regras chamado optimized_rules.rule no seu diretório ~/project.

nano ~/project/optimized_rules.rule

Adicione o seguinte conteúdo ao arquivo optimized_rules.rule:

: l<10 s/e/3 A!

• l<10 significa "aplique esta regra apenas se o comprimento da palavra for menor que 10 caracteres".
• s/e/3 substitui 'e' por '3'.
• A! anexa um ponto de exclamação.

Salve o arquivo pressionando Ctrl+X, depois Y, e depois Enter.

Agora, vamos testar esta regra com nosso wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/optimized_rules.rule --stdout

Você deverá ver uma saída semelhante a esta:

s3cr3t!
p4ssw0rd!

Tanto "password" (8 caracteres) quanto "secret" (6 caracteres) têm menos de 10 caracteres, portanto a regra se aplica. Se você tivesse uma palavra como "superlongpassword" (17 caracteres), esta regra não se aplicaria a ela, economizando assim computação.

Entender como aplicar regras seletivamente com base em condições como comprimento pode melhorar significativamente o desempenho de suas tentativas de quebra, reduzindo o número de candidatos desnecessários gerados.

Resumo

Neste laboratório, você obteve uma compreensão abrangente da criação de regras avançadas para o John the Ripper. Você começou explorando o encadeamento de regras (rule chaining), que permite transformações sequenciais. Em seguida, aprendeu a criar regras específicas para transformações comuns de Leet Speak e desenvolveu regras para direcionar padrões de senha prevalentes. Além disso, você praticou o teste de conjuntos de regras complexos combinando diferentes tipos de regras. Finalmente, você foi introduzido aos conceitos de otimização do desempenho de regras, como o uso de regras condicionais para reduzir computações desnecessárias. Essas habilidades são fundamentais para alavancar efetivamente o John the Ripper em cenários do mundo real de auditoria e quebra de senhas.