iphelix/packPACK (Набор для анализа и взлома паролей)
PACK (Password Analysis and Cracking Toolkit) — это набор утилит, разработанных для анализа списков паролей с целью повышения эффективности их взлома за счёт обнаружения закономерностей в масках, правилах, наборах символов и других характеристиках паролей. Инструментарий генерирует корректные входные файлы для семейства программ для взлома паролей Hashcat.
ПРИМЕЧАНИЕ: Сам инструментарий не умеет взламывать пароли, а предназначен для повышения эффективности работы программ взлома.
Прежде чем мы сможем начать работу с инструментарием, необходимо установить критерии выбора списков паролей. Поскольку мы стремимся проанализировать, как люди создают свои пароли, мы должны получить как можно большую выборку утёкших паролей. Одним из таких отличных списков является список, основанный на утечке RockYou.com. Этот список предоставляет достаточно большую и разнообразную коллекцию, дающую хорошие результаты для распространённых паролей, используемых на подобных сайтах (например, социальных сетях). Анализ, полученный из этого списка, может не подойти для организаций со специфическими политиками паролей. Поэтому выбор входной выборки должен быть максимально близок к вашей цели. Кроме того, старайтесь избегать получения списков, основанных на уже взломанных паролях, так как это создаст статистическое смещение в сторону правил и масок, использованных лицом(ами), взломавшим(и) список, а не actual пользователей.
Самый простой анализ, который вы можете выполнить — это просто получение наиболее распространённой длины, набора символов и других характеристик паролей в предоставленном списке. В примере ниже мы будем использовать 'rockyou.txt', содержащий около 14 миллионов паролей. Запустите statsgen.py со следующей командой:
$ python statsgen.py rockyou.txt
Ниже представлен вывод указанной команды:
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Анализ паролей в [rockyou.txt]
[+] Проанализировано 100% (14344390/14344390) паролей
ПРИМЕЧАНИЕ: Статистика ниже приведена относительно количества проанализированных паролей, а не общего количества паролей
[*] Длина:
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] Набор символов:
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] Сложность пароля:
[+] digit: min(0) max(255)
[+] lower: min(0) max(255)
[+] upper: min(0) max(187)
[+] special: min(0) max(255)
[*] Простые маски:
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] Расширенные маски:
[+] ?l?l?l?l?l?l?l?l: 04% (687991)
[+] ?l?l?l?l?l?l: 04% (601152)
[+] ?l?l?l?l?l?l?l: 04% (585013)
[+] ?l?l?l?l?l?l?l?l?l: 03% (516830)
[+] ?d?d?d?d?d?d?d: 03% (487429)
...
ПРИМЕЧАНИЕ: Вы можете уменьшить количество отображаемых выбросов, включив флаг --hiderare, который не будет показывать элементы с частотой встречаемости менее 1%.
Вот что мы можем сразу узнать из приведённого списка:
Последний раздел, "Расширенные маски", содержит наиболее часто встречающиеся маски в формате Hashcat. Отдельные символы можно интерпретировать следующим образом:
?l - один символ в нижнем регистре
?u - один символ в верхнем регистре
?d - одна цифра
?s - один специальный символ
Например, самая первая маска, "?l?l?l?l?l?l?l?l", будет соответствовать всем паролям из строчных букв. Учитывая размер выборки, вы сможете взломать примерно 4% паролей. Однако после генерации первоначального вывода вам может быть интересно использовать фильтры для сужения данных о паролях.
Давайте посмотрим, как пользователи RockYou склонны выбирать свои пароли, используя простую маску "stringdigit" (строка, за которой следуют цифры):
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] Анализ паролей в [rockyou.txt]
[+] Проанализировано 37% (5339556/14344390) паролей
ПРИМЕЧАНИЕ: Статистика ниже приведена относительно количества проанализированных паролей, а не общего количества паролей
[*] Длина:
[+] 8: 23% (1267260)
[+] 7: 18% (981432)
[+] 9: 17% (939971)
[+] 10: 14% (750938)
[+] 6: 11% (618983)
[+] 11: 05% (294869)
[+] 12: 03% (175875)
[+] 13: 01% (103047)
[+] 14: 01% (65958)
[*] Набор символов:
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] Сложность пароля:
[+] digit: min(1) max(252)
[+] lower: min(0) max(46)
[+] upper: min(0) max(31)
[+] special: min(0) max(0)
[*] Простые маски:
[+] stringdigit: 100% (5339556)
[*] Расширенные маски:
[+] ?l?l?l?l?l?l?d?d: 07% (420318)
[+] ?l?l?l?l?l?d?d: 05% (292306)
[+] ?l?l?l?l?l?l?l?d?d: 05% (273624)
[+] ?l?l?l?l?d?d?d?d: 04% (235360)
[+] ?l?l?l?l?d?d: 04% (215074)
...
В самом верху вывода указано, какой процент от общего числа паролей был проанализирован. В данном случае, взламывая только пароли, соответствующие маске "stringdigit", можно восстановить лишь около 37% от общего набора, как и было показано в первоначальном выводе. Далее видно, что только 11% паролей этого типа содержат символы, отличные от строчных. Поэтому было бы разумно сосредоточиться только на строках из строчных букв, соответствующих этой маске. Наконец, в разделе "Расширенные маски" мы видим, что большинство паролей "stringdigit" состоят из строки, после которой следуют две или четыре цифры. Используя информацию, полученную из приведённого вывода, мы можем начать создавать мысленный образ шаблонов генерации паролей целевых пользователей.
Существует несколько других фильтров для длины пароля, маски и набора символов:
Length: --minlength и/или --maxlength
Simple Mask: --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum и т.д.]
Character sets: --charset [digit, string, stringdigit, digitstring, digitstringdigit и т.д.]
ПРИМЕЧАНИЕ: Можно указать более одного фильтра одного класса, перечислив их через запятую:
--simplemask="stringdigit,digitstring"
Хотя раздел "Расширенные маски" отображает только шаблоны, соответствующие более чем 1% всех паролей, вы можете получить и сохранить полный список масок паролей, соответствующих заданному словарю, с помощью следующей команды:
$ python statsgen.py rockyou.txt -o rockyou.masks
Все маски паролей и их частоты будут сохранены в указанный файл в формате CSV. Разумеется, вы можете указать фильтры для генерации файла масок только с заданными параметрами. Полученный файл может быть использован как входные данные для инструмента MaskGen, который рассматривается в следующем разделе.
MaskGen позволяет создавать маскированные атаки на основе шаблонов для ввода в семейство программ для взлома паролей Hashcat. Инструмент использует выходные данные, полученные с помощью statsgen выше с флагом '-o', для создания наиболее оптимальной маскированной атаки, отсортированной по сложности маски, частоте встречаемости или соотношению этих двух параметров (оптимальный индекс).
Давайте запустим MaskGen, используя только вывод StatGen в качестве аргумента:
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[*] Генерация масок завершена:
Сгенерировано масок: 146578
Покрытие масок: 100% (14344390/14344390)
Время выполнения масок: >1 года
Здесь следует обратить внимание на несколько моментов:
Поскольку у вас обычно ограничено время на выполнение и создание атак, maskgen позволяет указать, сколько времени у вас есть на выполнение маскированных атак, и сгенерирует наиболее оптимальный набор масок на основе режима сортировки. Давайте немного поиграем с различными режимами сортировки и целевым временем:
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 779
Покрытие масок: 56% (8116195/14344390)
Время выполнения масок: 0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [complexity].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 5163
Покрытие масок: 31% (4572346/14344390)
Время выполнения масок: 0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [occurrence].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 4
Покрытие масок: 16% (2390986/14344390)
Время выполнения масок: 1:34:05
Все указанные выше запуски имеют целевое время 600 секунд (или 10 минут) с разными режимами сортировки. По результатам наших экспериментов маски, сгенерированные с использованием режима сортировки OptIndex, могут взломать 56% паролей RockYou примерно за 10 минут. В то же время маски, сгенерированные с использованием режима сортировки Occurrence, не только имеют довольно слабое покрытие (всего 16%), но и превышают заданное целевое время более чем на час.
ПРИМЕЧАНИЕ: Маски, отсортированные по сложности, могут быть очень эффективны при атаке на политики паролей.
Давайте посмотрим на некоторые маски, сгенерированные maskgen в режиме optindex, с помощью флага --showmasks:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[L:] Mask: [ Occ: ] [ Time: ]
...
[ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00]
[ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36]
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
[ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04]
[ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11]
[ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01]
[ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00]
[10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02]
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 3970
Покрытие масок: 74% (10620959/14344390)
Время выполнения масок: 16:10:38
Отображаемые маски имеют довольно интуитивный формат:
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ сгенерированная маска \ _ время выполнения маски
\
_ длина маски _ частота встречаемости маски
В приведённом примере можно увидеть логику, заложенную в генерацию масок. Например, хотя маска '?s?l?l?l?l?l?l?s' имеет одно из самых долгих времён выполнения в примере (5 минут), она всё равно имеет более высокий приоритет из-за своей относительно более высокой частоты встречаемости по сравнению с '?l?l?l?l?d?d?d?d?s'. В то же время, хотя '?l?d?s?l?l?d?d' имеет довольно низкое покрытие, она всё равно получает более высокий приоритет, чем другие маски, поскольку, будучи маской длиной всего в шесть символов, выполняется очень быстро.
Вы можете дополнительно оптимизировать сгенерированные маскированные атаки с помощью фильтров. Например, у вас может быть достаточно мощное оборудование, чтобы просто перебирать все пароли длиной до 8 символов. В этом случае вы можете генерировать маски только длиннее 8 символов, используя флаг --minlength следующим образом:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] Анализ масок в [rockyou.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 585
Покрытие масок: 41% (5905182/14344390)
Время выполнения масок: 15:50:36
Естественно, покрытие сгенерированных масок уменьшилось, но эти фильтры становятся полезными при подготовке набора масок для атаки на списки паролей, отличные от того, на основе которого они были сгенерированы.
Ниже приведён список дополнительных фильтров, которые можно использовать:
Параметры фильтрации отдельных масок:
--minlength=8 Минимальная длина пароля
--maxlength=8 Максимальная длина пароля
--mintime=3600 Минимальное время выполнения маски (секунды)
--maxtime=3600 Максимальное время выполнения маски (секунды)
--mincomplexity=1 Минимальная сложность
--maxcomplexity=100
Максимальная сложность
--minoccurrence=1 Минимальная частота встречаемости
--maxoccurrence=100
Максимальная частота встречаемости
Флаги occurrence и complexity могут быть особенно эффективны для точной настройки сгенерированных масок с использованием различных режимов сортировки.
Когда полученные маски вас устраивают, вы можете сохранить их с помощью флага -o:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] Анализ масок в [rockyou.masks]
[*] Сохранение сгенерированных масок в [rockyou.hcmask]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 3970
Покрытие масок: 74% (10620959/14344390)
Время выполнения масок: 16:10:38
Это создаст файл 'rockyou.hcmask', который можно напрямую использовать с набором инструментов Hashcat или в составе пользовательского скрипта, перебирающего их.
Часто бывает полезно увидеть, насколько хорошо сгенерированные маски работают против уже взломанных списков. Maskgen может сравнить набор масок с другими, чтобы увидеть, насколько хорошо они будут работать, если маски из одного списка паролей будут применены к другому. Давайте сравним, насколько хорошо маски, сгенерированные из списка RockYou, будут работать против другого скомпрометированного списка, такого как Gawker:
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] Анализ масок в [gawker.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Проверка покрытия масок из [rockyou.hcmask]
[*] Сопоставление масок завершено:
Совпадений масок: 1775
Покрытие масок: 96% (1048889/1084394)
Время выполнения масок: 16:25:44
Используя параметр '--checkmasksfile', мы попытались выполнить маски из файла 'rockyou.hcmask', созданного ранее, против масок из образца утёкшего списка 'gawker.masks'. Это даёт хорошее покрытие в 96%, при этом 1775 из 3970 сгенерированных масок на основе RockYou совпали с масками в списке Gawker.
Также можно увидеть покрытие одной или нескольких масок, указав их непосредственно в командной строке следующим образом:
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] Анализ масок в [gawker.masks]
[*] Используется 1,000,000,000 ключей/сек для расчётов.
[*] Проверка покрытия следующих масок [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] Сопоставление масок завершено:
Совпадений масок: 2
Покрытие масок: 1% (18144/1084394)
Время выполнения масок: 0:00:04
Обе указанные маски совпали с покрытием всего 1%.
В зависимости от ваших конкретных характеристик оборудования и целевого хэша вы можете увеличить или уменьшить скорость перебора ключей в секунду, используемую в расчётах, с помощью параметра '--pps':
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] Анализ масок в [rockyou.masks]
[*] Используется 50,000,000 ключей/сек для расчётов.
[*] Сортировка масок по их [optindex].
[!] Целевое время превышено.
[*] Генерация масок завершена:
Сгенерировано масок: 1192
Покрытие масок: 61% (8754548/14344390)
Время выполнения масок: 12:17:31
Использование параметра '--pps' для соответствия вашей реальной производительности делает целевое время более осмысленным.
Многие атаки с использованием масок и словарей терпят неудачу в корпоративной среде с минимальными требованиями к сложности паролей. Вместо того чтобы прибегать к атаке полным перебором, мы можем использовать известные или предполагаемые правила сложности паролей, чтобы избегать перебора кандидатов паролей, не соответствующих политике, или, наоборот, проверять только несоответствующие пароли. С помощью PolicyGen вы сможете сгенерировать набор масок, соответствующих требованиям сложности паролей, что значительно сократит время взлома.
Ниже приведён пример сеанса, в котором мы генерируем все допустимые маски паролей для среды, требующей как минимум одну цифру, один символ верхнего регистра и один специальный символ.
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask
_
PolicyGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected][*] Saving generated masks to [complexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 40824 Time: 35 days, 0:33:09
Из приведённого вывода видно, что мы сгенерировали 40824 масок, соответствующих указанной сложности, которые займут около 35 дней при скорости 1 000 000 000 ключей/сек.
Если вы просто проводите аудит паролей и ваша задача — найти только несоответствующие политике пароли, вы можете указать флаг --noncompliant, чтобы инвертировать сгенерированные маски:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
Давайте посмотрим на некоторые несоответствующие маски, сгенерированные выше, с помощью флага --showmasks:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00]
...
[ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06]
[ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26]
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
Как видите, все эти маски не соответствуют как минимум одному требованию сложности пароля. Интересно, что при меньшем количестве сгенерированных масок атака занимает больше времени из-за длительных масок, таких как ?s?s?s?s?s?s?s?s.
Также можно указать максимальную сложность пароля с помощью флагов --maxlower, --maxupper, --maxdigit и --maxspecial, чтобы точнее настроить атаку. Например, ниже приведен пример сайта, который требует соблюдения политики паролей, но не допускает специальных символов:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q
[*] Saving generated masks to [maxcomplexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:None
Max strength: l:None u:None d:None s:0
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 5796 Time: 1 day, 20:20:55
rulegen.py реализует анализ паролей и генерацию правил для инструмента взлома паролей Hashcat, как описано в статье Automatic Password Rule Analysis and Generation. Пожалуйста, ознакомьтесь с этим документом для подробного обсуждения теории анализа и генерации правил.
Обратное восстановление исходных слов и правил модификации слов на основе уже взломанных паролей может быть очень эффективным при атаках на ещё не расшифрованные хеши. Постоянно перерабатывая и расширяя сгенерированные правила и слова, вы можете взломать большее количество паролей.
Для эффективного использования rulegen.py необходимо выполнить несколько предварительных условий. Инструмент использует библиотеку проверки орфографии Enchant для взаимодействия с рядом механизмов проверки орфографии, таких как Aspell, MySpell и т.д. Вы должны установить эти инструменты перед использованием. Также крайне важно установить словари для того механизма проверки орфографии, который вы в итоге будете использовать (альтернативно можно использовать собственный список слов). Наконец, для удобства я приложил PyEnchant, который должен напрямую взаимодействовать с общими библиотеками Enchant; однако, если возникнут проблемы, просто удалите вложенную директорию 'enchant' и установите PyEnchant для вашего дистрибутива.
Дополнительные сведения о синтаксисе правил Hashcat см. в Hashcat Rule Based Attack.
Самое базовое использование rulegen.py включает анализ одного пароля для автоматического обнаружения правил. Давайте определим правила и потенциальное исходное слово, использованное для генерации тестового пароля P@55w0rd123:
$ python rulegen.py --verbose --password P@55w0rd123
_
RuleGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: P@55w0rd123
[-] Pas sword => {edit distance suboptimal: 8 (7)} => P@55w0rd123
[+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123
В этом примере мы использовали несколько флагов:
Обработка файлов паролей рассматривается в разделе ниже; однако давайте сначала обсудим некоторые доступные параметры тонкой настройки на примере одного пароля.
Обратите внимание, что мы используем модуль Enchant aspell для обнаружения исходного слова. Точный механизм проверки орфографии можно изменить с помощью флага --provider следующим образом:
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Using Enchant 'myspell' module. For best results please install
'myspell' module language dictionaries.
...
ПРИМЕЧАНИЕ: Приоритет движка-провайдера можно задать с помощью списка, разделённого запятыми (например, --provider aspell,myspell).
Использование механизма обнаружения исходного слова можно полностью отключить, указав исходное слово с помощью флага --word:
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] Analyzing password: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
Указывая разные исходные слова, вы можете получить много удовольствия, экспериментируя с механизмом генерации правил.
Рано или поздно вы столкнётесь с ситуацией, когда генерация правил с использованием стандартного списка слов орфографического движка станет недостаточной. Вы можете указать собственный список слов с помощью флага --wordlist. Это особенно полезно при повторном использовании исходных слов из предыдущего сеанса анализа:
$ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1
[*] Using Enchant 'Personal Wordlist' module. For best results please install
'Personal Wordlist' module language dictionaries.
[*] Analyzing password: 1pa55w0rd1
[+] password => ^1 ss5 so0 $1 => 1pa55w0rd1
Собственный список слов может быть особенно полезен при использовании слов, которые обычно не встречаются, таких как сленг, а также уже взломанных паролей.
Хотя rulegen.py пытается генерировать и записывать только наилучшие исходные слова и пароли, могут быть случаи, когда вас интересует больше результатов. Используйте флаги --morewords и --morerules, чтобы генерировать слова и правила, которые могут превышать оптимальное расстояние редактирования:
$ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[+] money => ^$ so0 se3 $$ => $m0n3y$
[+] moneys => ^$ so0 se3 o6$ => $m0n3y$
[+] mingy => ^$ si0 sg3 $$ => $m0n3y$
[+] many => ^$ sa0 i43 $$ => $m0n3y$
[+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$
Можно ещё больше расширить сгенерированные слова с помощью флагов --maxworddist и --maxwords. Аналогично, можно получить больше правил с помощью флагов --maxrulelen и --maxrules.
rulegen.py включает ряд расширенных движков для генерации более качественных слов и правил. Их можно отключить, чтобы увидеть разницу (или если они вызывают проблемы), используя флаги --simplewords и --simplerules. Давайте посмотрим, как изменятся как исходные слова, так и правила при включении этих флагов:
$ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[-] Meany => {edit distance suboptimal: 5 (4)} => $m0n3y$
[+] many => i0$ o20 i43 i6$ => $m0n3y$
[+] mingy => i0$ o20 o43 i6$ => $m0n3y$
[+] money => i0$ o20 o43 i6$ => $m0n3y$
[+] mangy => i0$ o20 o43 i6$ => $m0n3y$
[+] manky => i0$ o20 o43 i6$ => $m0n3y$
Обратите внимание, что качество сгенерированных слов и правил значительно снизилось: такие слова, как 'manky', имеют меньше отношения к исходному слову 'money'. В то же время сгенерированные правила свелись к простым вставкам, удалениям и заменам.
Теперь, когда вы освоили все различные флаги и переключатели, мы можем попытаться сгенерировать слова и правила для набора паролей. Давайте сгенерируем текстовый файл korelogic.txt, содержащий следующие достаточно сложные тестовые пароли:
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
Теперь давайте посмотрим на анализ rulegen.py, просто указав файл паролей в качестве первого аргумента:
$ python rulegen.py korelogic.txt -q
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to analysis.rule
[*] Saving words to analysis.word
[*] Finished processing 16 passwords in 1.00 seconds at the rate of 15.94 p/sec
[*] Generating statistics for [analysis] rules and words.
[-] Skipped 0 all numeric passwords (0.00%)
[-] Skipped 2 passwords with less than 25% alpha characters (12.50%)
[-] Skipped 0 passwords with non ascii characters (0.00%)
[*] Top 10 rules
[+] ^3 ^1 o4r - 3 (2.00%)
[+] i61 i79 i86 i98 oA1 - 2 (1.00%)
[+] ^- ^0 ^1 i4' o5A - 2 (1.00%)
[+] sS1 i13 T2 - 1 (0.00%)
[+] i61 se9 i86 i98 oA1 - 1 (0.00%)
[+] o61 i79 i86 i98 oA1 - 1 (0.00%)
[+] ^- ^0 ^1 so' i5A - 1 (0.00%)
[+] D3 si0 i55 $e - 1 (0.00%)
[+] i61 i79 se6 i98 oA1 - 1 (0.00%)
[+] i3a o5y o6a i7% o8] - 1 (0.00%)
[*] Top 10 words
[+] Analyze - 1 (0.00%)
[+] defcon - 1 (0.00%)
[+] Kristen - 1 (0.00%)
[+] Bailey - 1 (0.00%)
[+] Augusts - 1 (0.00%)
[+] Annelid - 1 (0.00%)
[+] Hack's - 1 (0.00%)
[+] antlers - 1 (0.00%)
[+] antelope - 1 (0.00%)
[+] xxxv - 1 (0.00%)
Используя все настройки по умолчанию, мы смогли получить несколько высококачественных правил. Приложение отображает базовую статистику по топ-10 правил и слов. Все сгенерированные правила и слова сохраняются с базовым именем 'analysis' по умолчанию:
Обратите внимание, что несколько паролей, такие как '#(4)\ и '&a123456, были пропущены, поскольку они не обладают достаточными характеристиками для обработки. Помимо количества буквенных символов, программа пропускает все числовые пароли и пароли, содержащие не-ASCII символы. Последнее связано с ошибкой в движке Enchant, которую я надеюсь исправить в будущем, чтобы обеспечить обработку слов на многих языках.
Как упоминалось ранее, rulegen.py сохраняет выходные файлы с базовым именем 'analysis' по умолчанию. Вы можете изменить базовое имя файла с помощью флага --basename или -b следующим образом:
$ python rulegen.py korelogic.txt -q -b korelogic
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to korelogic.rule
[*] Saving words to korelogic.word
Могут возникнуть ситуации, когда у вас возникают проблемы с генерацией правил для инструмента взлома паролей Hashcat. rulegen.py включает флаг --hashcat для проверки сгенерированных слов и правил с помощью самого hashcat, работающего в режиме --stdout. Чтобы этот режим работал правильно, необходимо загрузить последнюю версию hashcat-cli и отредактировать переменную HASHCAT_PATH в исходном коде. Например, на момент написания этого руководства я поместил папку hashcat-0.## в каталог PACK и определил HASHCAT_PATH как 'hashcat-0.##/'.
Вы также можете наблюдать внутреннюю работу механизма генерации правил с помощью флага --debug. Не обращайте внимания на сообщения об определённых сбоях правил: это результат работы решателя проблемы останова, пытающегося найти оптимальное и корректное решение.
Хотя это руководство знакомит с рядом методов анализа паролей, обратного восстановления правил и генерации масок, существует множество других трюков, которые ждут вашего открытия. Я был бы рад, если бы вы рассказали мне о каком-нибудь необычном использовании или предложениях по любому из описанных инструментов.
Удачного взлома!
-Питер