Создание расширенных правил для John the Ripper

Введение

В этой лабораторной работе вы углубитесь в расширенные возможности движка правил John the Ripper. John the Ripper — это мощный инструмент для взлома паролей, а его движок правил позволяет проводить высоконастраиваемые и эффективные атаки. Понимание того, как создавать эффективные правила, имеет решающее значение для максимального использования его потенциала. Вы узнаете о цепочке правил, создании правил для распространенных преобразований, таких как Leet Speak, разработке правил для типичных шаблонов паролей, тестировании сложных наборов правил и оптимизации производительности правил. К концу этой лабораторной работы вы получите твердое понимание того, как использовать движок правил John the Ripper для более сложных сценариев взлома паролей.

Понимание цепочки правил

На этом этапе вы узнаете о цепочке правил в John the Ripper. Цепочка правил позволяет комбинировать несколько правил для создания более сложных преобразований. Это особенно полезно, когда вам нужно применить последовательность модификаций к записи в списке слов.

Сначала убедитесь, что John the Ripper установлен. Если нет, вы можете установить его с помощью apt.

sudo apt update
sudo apt install -y john

Далее мы создадим простой файл списка слов с именем wordlist.txt в вашем каталоге ~/project.

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

Теперь давайте создадим файл правил с именем chain_rules.rule в ~/project, который демонстрирует базовую цепочку правил. Это правило сначала добавит "123" к слову, а затем сделает первую букву заглавной.

nano ~/project/chain_rules.rule

Добавьте следующее содержимое в файл chain_rules.rule:

: A123 c

• : (двоеточие) обозначает начало правила.
• A123 добавляет "123" в конец слова.
• c делает первую букву слова заглавной.

Сохраните файл, нажав Ctrl+X, затем Y, затем Enter.

Теперь давайте используем John the Ripper с этим файлом правил. Мы будем использовать опцию --stdout, чтобы увидеть преобразованные слова, не выполняя фактический взлом паролей.

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

Вы должны увидеть вывод, похожий на этот:

Password123
Secret123

Это демонстрирует, как правила объединяются в цепочку: сначала применяется A123, а затем к результату применяется c.

Создание правил для преобразований Leet Speak

На этом шаге вы создадите правила для выполнения преобразований Leet Speak. Leet Speak (или "1337 Speak") — это распространенная практика, при которой буквы заменяются похожими на них цифрами или символами (например, 'a' становится '4', 'e' становится '3', 's' становится '5'). Это частая техника, используемая в паролях.

Мы создадим новый файл правил с именем leet_rules.rule в вашем каталоге ~/project. Этот файл будет содержать правила для преобразования распространенных букв в их эквиваленты Leet Speak.

nano ~/project/leet_rules.rule

Добавьте следующее содержимое в файл leet_rules.rule:

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

• s/old/new — это правило подстановки. Оно заменяет первое вхождение old на new.
• Мы объединяем несколько правил подстановки для применения нескольких преобразований Leet Speak.

Сохраните файл, нажав Ctrl+X, затем Y, затем Enter.

Теперь давайте протестируем эти правила с нашим wordlist.txt.

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

Вы должны увидеть вывод, похожий на этот:

p4ssw0rd
s3cr3t

Это демонстрирует, как вы можете создавать правила для обработки распространенных вариаций Leet Speak, что может значительно повысить эффективность ваших усилий по взлому паролей против пользователей, которые используют эти подстановки.

Разработка правил для распространенных шаблонов паролей

На этом шаге вы разработаете правила, нацеленные на распространенные шаблоны паролей, такие как добавление годов или распространенных чисел, или преобразование первой буквы в верхний регистр. Эти шаблоны часто используются пользователями, чтобы сделать свои пароли "более надежными", не увеличивая при этом их энтропию.

Давайте создадим новый файл правил с именем pattern_rules.rule в вашем каталоге ~/project. Этот файл будет объединять несколько распространенных преобразований.

nano ~/project/pattern_rules.rule

Добавьте следующее содержимое в файл pattern_rules.rule:

: c A2023
: c A!
: c A@

• c преобразует первую букву в верхний регистр.
• A2023 добавляет год "2023".
• A! добавляет восклицательный знак.
• A@ добавляет символ "@".

Каждая строка представляет собой отдельное правило. John the Ripper будет применять каждое правило к каждому слову в списке слов независимо.

Сохраните файл, нажав Ctrl+X, затем Y, затем Enter.

Теперь давайте протестируем эти правила с нашим wordlist.txt.

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

Вы должны увидеть вывод, похожий на этот:

Password2023
Secret2023
Password!
Secret!
Password@
Secret@

Это демонстрирует, как вы можете создать набор правил для охвата распространенных шаблонов паролей, значительно расширяя поверхность атаки за пределы простых словарных слов.

Тестирование сложных наборов правил

На этом шаге вы объедините изученные концепции для тестирования более сложного набора правил. Это включает создание файла правил, который включает как преобразования Leet Speak, так и добавление распространенных шаблонов, демонстрируя, как различные типы правил могут использоваться вместе.

Давайте создадим комплексный файл правил с именем complex_rules.rule в вашем каталоге ~/project. Этот файл будет включать подстановки Leet Speak, а затем добавлять распространенные числа или символы.

nano ~/project/complex_rules.rule

Добавьте следующее содержимое в файл 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!

• Первое правило применяет Leet Speak, а затем добавляет "123".
• Второе правило применяет Leet Speak, а затем добавляет "!".

Сохраните файл, нажав Ctrl+X, затем Y, затем Enter.

Теперь давайте протестируем эти сложные правила с нашим wordlist.txt.

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

Вы должны увидеть вывод, похожий на этот:

p4ssw0rd123
s3cr3t123
p4ssw0rd!
s3cr3t!

Это демонстрирует мощь комбинирования различных типов правил для генерации широкого спектра потенциальных кандидатов в пароли, что крайне важно для эффективного взлома паролей.

Оптимизация производительности правил

На этом шаге вы узнаете об оптимизации производительности правил. Хотя сложные правила мощны, они также могут быть вычислительно затратными. John the Ripper предоставляет механизмы для оптимизации применения правил, в основном за счет понимания порядка операций и избегания избыточных правил.

Один из способов оптимизации — сделать ваши правила максимально специфичными и избегать генерации ненужных кандидатов. Например, если вы знаете, что пароль всегда будет начинаться с заглавной буквы, применение правила, которое преобразует каждую букву в верхний регистр, неэффективно.

Рассмотрим complex_rules.rule из предыдущего шага. Каждое правило применяет все подстановки Leet Speak перед добавлением. Если бы у вас было много таких правил, повторное применение подстановок могло бы быть менее эффективным, чем их однократное применение с последующим ветвлением. Однако для простых случаев цепочка в рамках одного правила часто достаточно эффективна.

Для очень больших наборов правил или специфических сценариев John the Ripper допускает более продвинутый синтаксис правил и использование внешних файлов правил. В этой лабораторной работе мы сосредоточимся на концептуальном понимании оптимизации.

Распространенной техникой оптимизации является фильтрация вашего списка слов или нацеливание на конкретные шаблоны с помощью отдельных, меньших наборов правил, а не одного массивного, всеобъемлющего набора правил.

Давайте продемонстрируем простую концепцию оптимизации, создав правило, которое применяется только в том случае, если длина слова меньше определенного значения, используя правило l (length). Это может предотвратить применение сложных правил к словам, которые уже слишком длинные, чтобы быть распространенными паролями.

Создайте новый файл правил с именем optimized_rules.rule в вашем каталоге ~/project.

nano ~/project/optimized_rules.rule

Добавьте следующее содержимое в файл optimized_rules.rule:

: l<10 s/e/3 A!

• l<10 означает "применять это правило только в том случае, если длина слова меньше 10 символов".
• s/e/3 заменяет 'e' на '3'.
• A! добавляет восклицательный знак.

Сохраните файл, нажав Ctrl+X, затем Y, затем Enter.

Теперь давайте протестируем это правило с нашим wordlist.txt.

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

Вы должны увидеть вывод, похожий на этот:

s3cr3t!
p4ssw0rd!

Оба слова "password" (8 символов) и "secret" (6 символов) короче 10 символов, поэтому правило применяется. Если бы у вас было слово вроде "superlongpassword" (17 символов), это правило к нему бы не применялось, экономя вычислительные ресурсы.

Понимание того, как выборочно применять правила на основе таких условий, как длина, может значительно повысить производительность ваших попыток взлома, сократив количество ненужных сгенерированных кандидатов.

Резюме

В этой лабораторной работе вы получили всестороннее понимание создания расширенных правил для John the Ripper. Вы начали с изучения цепочек правил (rule chaining), которые позволяют выполнять последовательные преобразования. Затем вы научились создавать специфические правила для распространенных преобразований Leet Speak и разработали правила для нацеливания на распространенные шаблоны паролей. Кроме того, вы попрактиковались в тестировании сложных наборов правил, комбинируя различные типы правил. Наконец, вы были ознакомлены с концепциями оптимизации производительности правил, такими как использование условных правил для сокращения ненужных вычислений. Эти навыки являются основополагающими для эффективного использования John the Ripper в реальных сценариях аудита и взлома паролей.