Применение правил к спискам слов для продвинутого взлома

Введение

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

Понимание синтаксиса правил John the Ripper

На этом шаге вы изучите базовый синтаксис правил John the Ripper (JtR). Правила JtR определяются в конфигурационном файле, обычно john.conf, или могут быть переданы непосредственно через командную строку для простых случаев. Каждое правило представляет собой последовательность односимвольных команд, которые изменяют слово.

Общие команды правил включают:

• c: Сделать первую букву заглавной.
• C: Сделать все буквы заглавными.
• l: Сделать первую букву строчной.
• L: Сделать все буквы строчными.
• t: Инвертировать регистр первой буквы.
• T: Инвертировать регистр всех букв.
• p<N>: Добавить символ <N> в начало.
• a<N>: Добавить символ <N> в конец.
• s<old><new>: Заменить первое вхождение <old> на <new>.
• S<old><new>: Заменить все вхождения <old> на <new>.
• x<N>: Извлечь подстроку длиной N с начала.
• z<N>: Извлечь подстроку длиной N с конца.
• D: Удалить первый символ.
• M: Удалить последний символ.
• r: Перевернуть слово.

Для начала давайте посмотрим на файл john.conf по умолчанию, чтобы увидеть примеры встроенных правил.

Откройте файл john.conf с помощью nano:

nano /etc/john/john.conf

Прокрутите файл, чтобы найти раздел [List.Rules:Wordlist]. Там вы увидите различные наборы правил. Например, вы можете увидеть правила вроде c (сделать первую букву заглавной) или a[0-9] (добавить цифру в конец).

Нажмите Ctrl+X, чтобы выйти из nano.

Теперь давайте попробуем простое правило непосредственно из командной строки, используя опцию JtR --stdout, которая применяет правила к списку слов и выводит результаты на стандартный вывод, не пытаясь взломать хеши. Это полезно для тестирования правил.

Выполните следующую команду, чтобы применить правило c (сделать первую букву заглавной) к вашему файлу wordlist.txt:

john --wordlist=~/project/wordlist.txt --rules=single --stdout

Вы должны увидеть слова из вашего wordlist.txt с первой заглавной буквой. Например, "password" станет "Password".

Password
Secret
Labex
Test

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

Создание простого правила для капитализации

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

Сначала создайте новый файл с именем my_rules.rule в вашем каталоге ~/project. Этот файл будет содержать ваши пользовательские правила.

nano ~/project/my_rules.rule

Добавьте следующие строки в файл my_rules.rule. Эти правила будут:

• c: Сделать первую букву заглавной.
• C: Сделать все буквы заглавными.
• t: Инвертировать регистр первой буквы (например, "password" -> "Password", "Password" -> "password").

c
C
t

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

Теперь примените эти пользовательские правила к вашему файлу wordlist.txt, используя опцию --rules, указав ваш новый файл правил.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout

Наблюдайте за выводом. Вы должны увидеть, как каждое слово из вашего wordlist.txt трансформируется каждым из определенных вами правил. Например, "password" появится как "Password", "PASSWORD" и "Password" (из-за правила t, примененного к исходному "password").

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test

Это демонстрирует, как определять и использовать пользовательский файл правил. Каждое правило в файле последовательно применяется к каждому слову в списке слов.

Применение правил для добавления чисел

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

Команда a<N> добавляет символ <N>. Чтобы добавить цифры, вы можете использовать диапазоны символов, такие как a[0-9], чтобы добавить одну цифру от 0 до 9. Вы также можете комбинировать это с другими правилами.

Давайте добавим правила в my_rules.rule для добавления чисел. Снова откройте ваш файл правил:

nano ~/project/my_rules.rule

Добавьте следующие строки в конец файла. Эти правила будут:

• a[0-9]: Добавить одну цифру (0-9) к слову.
• a[0-9][0-9]: Добавить две цифры (00-99) к слову. Это правило сгенерирует 100 вариаций для каждого слова.

a[0-9]
a[0-9][0-9]

Сохраните файл (Ctrl+O, Enter) и выйдите из nano (Ctrl+X).

Теперь примените эти обновленные правила к вашему файлу wordlist.txt. Поскольку a[0-9][0-9] генерирует много вариаций, мы ограничим вывод с помощью head для демонстрационных целей.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Вы увидите слова вроде "password0", "password1", ..., "password00", "password01" и так далее. Команда head -n 50 ограничивает вывод первыми 50 строками, так как полный вывод был бы очень длинным.

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

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

Объединение нескольких правил для сложных преобразований

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

Давайте создадим правило, которое делает первую букву заглавной, а затем добавляет одну цифру.

Снова откройте ваш файл my_rules.rule:

nano ~/project/my_rules.rule

Добавьте следующее правило в конец файла. Это правило ca[0-9] означает:

1. c: Сделать первую букву заглавной.
2. a[0-9]: Добавить одну цифру (0-9).

ca[0-9]

Сохраните файл (Ctrl+O, Enter) и выйдите из nano (Ctrl+X).

Теперь примените эти обновленные правила к вашему файлу wordlist.txt и наблюдайте за выводом. Опять же, мы будем использовать head для ограничения вывода.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Вы должны увидеть вариации вроде "Password0", "Password1", "Secret0", "Secret1" и так далее.

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

Это демонстрирует мощь объединения правил. Вы можете создавать очень специфичные и эффективные наборы правил, объединяя команды. Например, s@a!ca[0-9] заменит '@' на '!', сделает первую букву заглавной, а затем добавит цифру.

Тестирование пользовательских правил на списке слов

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

Напомним, что при настройке хэш для слова "password" был создан и сохранен в файле ~/project/hashes.txt. Хэш: user1:5f4dcc3b5aa765d61d8327deb882cf99 (MD5 хэш от "password").

Сначала убедитесь, что ваш файл my_rules.rule содержит правило, которое сгенерирует "password" или его вариацию, соответствующую хэшу. Для этого примера мы предположим, что хэш относится к исходному слову "password". Если бы у вас был хэш для "Password0", ваше правило ca[0-9] было бы полезным.

Для этой демонстрации мы будем использовать исходный файл wordlist.txt и ваш файл my_rules.rule, чтобы попытаться взломать хэш.

Запустите John the Ripper с вашим файлом хэшей, списком слов и пользовательскими правилами:

john ~/project/hashes.txt --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule

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

Вы должны увидеть вывод, похожий на этот, указывающий на то, что пароль был взломан:

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.

Чтобы снова просмотреть взломанный пароль, вы можете использовать опцию --show:

john --show ~/project/hashes.txt

Эта команда отобразит все пароли, которые JtR успешно взломал и сохранил в своем файле pot.

user1:password

1 password hash cracked, 0 left

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

Резюме

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