Некоторые базовые техники расшифровки хешей

Введение

Хеш представляет собой пароль, преобразованный при помощи необратимой или односторонней функции. Так, например, алгоритм ROT-13, сдвигающий каждый символ алфавита на 13 позиций, был бы очень, очень плохим примером хеширования и выдавал бы очевидные результаты навроде «Cnffjbeq123!». Термин «односторонняя» означает, что создание обратимой функции и восстановление первоначального пароля практически невозможно. В качестве примера функций, удовлетворяющий конкретно этому критерию, можно привести MD5 или SHA1. Итеративное шифрование наподобие DES тоже использовалось (например, при создании хешей в LAN Manager), но, кажется, вышло из моды. Существует множество технических и криптографических деталей, которые ни вам ни мне знать не нужно, но, по сути, мы пытается подобрать множество паролей, используем ту же самую одностороннюю функцию и в конце проверяем, получился ли правильный результат.

Теперь если бы мы хотели оптимизировать процесс подбора, то могли бы создать огромную таблицу со всеми возможными паролями и всеми возможными соответствующими хешами (кстати, в случае с хешами, созданными при помощи алгоритмов навроде MD5, этот метод медленнее по сравнению с вычислениями в режиме реального времени, поскольку операции доступа к диску медленнее, чем выполнение простых операций в процессоре). В какой-то момент много лет назад к хешам паролей в системах UNIX была добавлена «соль», представляющая собой случайное число, которое хранится вместе с хешем и используется при вычислении хеша. В этом случае мы получаем сразу два преимущества:

1. Если соль достаточно длинная и достаточно случайная, создание таблицы для поиска теряет смысл, поскольку размер этой таблицы становится слишком большим.

2. Нужно подбирать каждый хеш индивидуально, то есть запускать процесс вычисления для каждой пары «соль-возможный пароль».

Таким образом, мы приходим к функции навроде sha512crypt, представляющей собой множество итераций алгоритма SHA512 с большой и случайной солью. Соответственно, каждая попытка вычисления замедляется, что осложняет задачу расшифровки. Например, возьмем следующий хеш:

```
$6$52450745$k5ka2p8bFuSmoVT1tzOyyuaREkkKBcCNqoDKzYiJL9RaE8yMnPgh2XzzF0NDrUhgrcLwg78xs1w5pJiypEdFX/

```

Мы можем подобрать пароль к этому хешу, например, при помощи John the Ripper (https://www.openwall.com/john/):

```
D:\john\run> john.exe sha512crypt.txt

```

или при помощи hashcat (https://hashcat.net/hashcat/):

```
; hashcat.exe -a0 -m 1800 D:\hashcrack\john\run\sha512crypt.txt D:\hashcrack\dict\Top95Thousand-probable.txt -r D:\hashcrack\rules\best1222.rule -O -w3

```

Соответственно, проблема сводится к «простому» выбору всех магических параметров, указываемых явным образом в hashcat и неявным в John the Ripper. Поскольку мне не нравится писать каждый раз одно и то же, я написал скрипт «hashcrack» (https://github.com/blacktraffic/hashcrack).

Если коротко, этот скрипт пытается выяснить тип хеша, а затем запускает несколько подходящих сценариев перебора на основе скорости вычисления хеша при помощи hashcat, John the Ripper и других инструментов преобразования/извлечения хешей, идущих в комплекте с John the Ripper и иногда с impacket или SQLite. Например, возьмем файл Responder.db (из тестового набора) и выполним следующую команду:

```
D:\hashcrack>python hashcrack.py -i tests\Responder.db
Running under win32
Reading file: D:\hashcrack\tests\Responder.db
Couldn't parse first line of file - trying as latin1
[at this point it pulls out the NetNTLMv1 and v2 hashes into .tmp files - "SELECT fullhash FROM responder where type like 'NTLMv2%'" ]
RUN: hashcat.exe -a0 -m 5600 D:\hashcrack\tests\Responder.db.tmp D:\hashcrack\dict\\\Top95Thousand-probable.txt -r D:\hashcrack\rules\\\best22405.rule --loopback -O --bitmap-max=26 -w3 --session hc
...

IEUSER::IEWIN7:ed9cc20456c23e34:939e00dfea66e08e8b...03100000000000000000000000000:Passw0rd!

```

Вышеуказанный скрипт - очень достойный помощник, и, как минимум, сообщает, какую команду нужно запустить на случай, если вы захотите выполнить перебор в дальнейшем. Кроме того, hashcrack старается распаковать все хеши в формат hashcat.

Получение хеша

Получение и последующее преобразование хеша в корректный формат, используемый в John the Ripper или hashcat, - не всегда тривиальная задача. Как минимум, у нас есть следующие типы хешей.

Windows

• Сохраненные пароли (например, NTLM) рассматриваются в статье, посвященной выгрузке учетных записей из базы данных в Active Directory (https://adsecurity.org/?p=2398)
• Хеши NetLMv1/v2 можно получить при помощи утилиты Responder или из различных приложений, если вы сможете заставить подключиться эти приложения к поддельному совместно используемому SMB-ресурсу.
• Хеши Kerberos можно получить при помощи Invoke-Kerberoast, Rubeus или других схожих утилит, позволяющих выполнить атаку Kerberoasting на домен Active Directory.
• Учетные записи, закешированые в домене можно получить при помощи утилит для выгрузки паролей на локальной машине или через ветви реестра (security, system и SAM) с последующей распаковкой, используя secretsdump из библиотеки impacket (https://github.com/SecureAuthCorp/impacket)

UNIX

В Линуксе хеши обычно хранятся в файле /etc/shadow в формате sha512crypt или bcrypt в современных операционных системах, начиная с последовательностей навроде «$2$» или «$6$». Для ОС AIX хеши в формате DEScrypt можно найти в файле /etc/security/passwd. Функция шифрования crypt описывается в документации https://www.man7.org/linux/man-pages/man3/crypt.3.html.

Базы данных

При помощи запросов вы можете извлечь хеши паролей из баз данных PostgreSQL, MySQL, Oracle, MSSQL и так далее.

Документы

Хеши паролей для файлов ZIP, Word, Excel, PDF можно извлечь при помощи различных скриптов, идущих в комплекте с John the Ripper.

Веб-приложения

Хеши веб-приложений можно получить через прямое подключение к базе данных бэкэнда или при помощи SQL инъекции. Форматы могут быть различными, в зависимости от выбора разработчика, начиная от MD5 и заканчивая bcrypt. Например, хеши в формате phpass будут выглядеть примерно так «$P$984478476IagS59wHZvyQMArzfx58u».

Сценарий перебора зависит от формата хеша

Таким образом, откуда и какие вы получите хеши зависит последующий сценарий. Все хеши, используемые в Windows, должны удовлетворять политике паролей домена – если только администраторы не выдали особого разрешения. Пароли из баз данных или веб-приложений в теории могут быть любой длины. WPA2 пароли должны быть не менее 8 символов, согласно стандарту.

В случае с несолеными хешами, как, например, обычный MD5, NTLM или SHA1 можно подбирать тысячи паролей по скорости перебора одного. Соответственно, можно загрузить все хеши одновременно. В противном случае нужно выбрать отдельные хеши, представляющие интерес.

Повторюсь еще раз. Быстро перебираемые хеши можно загрузить сразу же и посмотреть на результаты. Используемый подход всегда можно поменять в зависимости от цели перебора. В случае с более медленными хешами следует подумать и возможно найти наиболее вероятные потенциальные пароли или части паролей где-либо в системе.

Преимущества и ограничения при использовании GPU

Конечно, подбирать пароль вы можете при помощи CPU, однако большинство типов хешей GPU обрабатывает намного быстрее. С другой стороны, bcrypt может быть быстрее на CPU из-за схемы реализации. В этой статье я не буду затрагивать тему FPGA. Если интересно, можете ознакомиться со статьей https://www.usenix.org/system/files/conference/woot14/woot14-malvoni.pdf.

Поскольку многие любят играть в игры с хорошей графикой параллельные процессоры довольно дешевы и доступны. Однако есть определенные ограничения при использовании и распределении рабочей нагрузки. Если говорить о hashcat и John the Ripper, двух наиболее популярных программ для подбора паролей, речь идет о пространстве поиска по словарю или набору правил (или трансформациях) или по маске, представляющее собой набор возможных значений. Для более быстрых хешей навроде NTLM и SHA1 нужно указать список правил или достаточно большой словарь, чтобы GPU работал на полную мощность. Насколько я понимаю, всё сводится к тому, насколько быстро вы можете посылать данные по шине, но какова бы ни была причина, небольшой словарь и отсутствие правил – не лучший вариант при использовании GPU (в этом случае hashcat выдаст предупреждение).

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

В hashcat маски указываются немного странным образом. ?a означает все значения ASCII, ?d – цифры, ?l и ?u – символы в нижнем и верхнем регистре соответственно, ?s – специальные символы, ?b – любой байт.

Таким образом, к примеру маска `?u?l?l?l?l?l?l?l?s` затрагивает не только последовательность Password!, но и все остальное, начиная от `Aaaaaaaa!` и заканчивая `Zzzzzzzzz}`.

Схожим образом язык правил описывает схему трансформации базового слова в финальный вариант (удаление, замена, добавление в начало или конец слова). Как и в случае с CPU, нам доступен конечный набор операций, и мы должны пользоваться тем, что есть. Если предположить, что слово «password» является базовым, тогда:

Маска `$1$2$3` означает «добавить в конец слова 123». В итоге мы получаем последовательность password123.

Маска `^3^2^1` означает «добавить в начало 123» (потому что сначала мы добавляем в начало 3, потом к полученной последовательности «3password» добавляем 2 и так далее).

Маска so0 означает поменять ВСЕ символы 'o' на '0' (нули). В итоге мы получаем фразу «passw0rd».

Одно из ограничений hashcat – мы не можем заменить часть символов 'o' на нули. Только всё или ничего. (Исследования показывают, что люди склонны добавлять сложность в конец паролей, и суффиксы более полезны, чем префиксы).

Словарь и правила

Во время «обычного» запуска hashcat у нас есть словарь с наиболее часто встречающимися паролями в порядке убывания частоты повторения и файл с набором правил. Я запускаю команду с использованием hashcrack.py, а в секции RUN: указана команда, как hashcat запускается на самом деле.

Файл, по которому я подбираю пароли, - последние пару миллионов записей из набора Have I Been Pwned NTLM (https://www.troyhunt.com/pwned-passwords-now-as-ntlm-hashes/). Я писал другую статью о взломе первых 500 миллионов, но сейчас у нас просто удобный набор тестовых данных.

```

./hashcrack.py -i hashes.txt -t ntlm -d /root/dict/Top2Billion_probable.txt -r rules/InsidePro-PasswordsPro.rule
RUN: ./hashcat64.bin -a0 -m 1000 hashes.txt /root/dict/Top2Billion_probable.txt -r /root/hashcrack/rules/InsidePro-PasswordsPro.rule --loopback -O -w4
```

Если посмотреть на отладочный файл, создаваемый при указании опции --debug-mode=4 --debug-file=dbg.log, то слева будет видно слово из словаря, в центре – применяемое правило, и справа – конечный результат.

```
stellarfinance:u $1 $1:STELLARFINANCE11 (upper case all, append '1' append '1')

sstechinc:i11:s1stechinc (insert '1' at position 1)

ssgalactic:i2.:ss.galactic (insert '.' at position 2)
```

В качестве аргумента словаря мы можем указать директорию. В этом случае hashcat будет использовать все файлы из этой папки. Кроме того, можно указать два параметра с правилами. В этом случае каждое правило из первого списка будет комбинироваться со всеми правилами из второго списка. С одной стороны, список начнет быстро разрастаться, но может оказаться полезным, если у вас ортогональные наборы правил (например, один для парольных фраз, второй – для окончаний навроде «123», «123!» и так далее). Сочетая файл insertions.rule и обычный набор правил, я получил последовательность `t++19882008`, когда t приходит из стандартного набора, а ++ из файла insertions.rule.

```
19882008:^t i1+ i1+:t++19882008
```

Маски и файлы с масками

Вы также можете указать набор для поиска при помощи масок. Например, маска ниже охватывает все ASCII-пароли длинной от 1 до 5 символов.

```
./hashcrack.py -i hashes.txt -t ntlm --mask ?a?a?a?a?a?a

RUN: ./hashcat64.bin -a3 -m 1000 hashes.txt ?a?a?a?a?a?a -i -O -w4
```

Маски можно поместить в файл, где вы указывается классы символов ?1, ?2, ?3, ?4 и используйте эти классы в последнем поле строки. Список ниже охватывает стандартные пароли и варианты:

```
Pp,@aA4,s5$,o0,?1?2?3?3w?4rd
sS5,oO0,?1upp?2rt
Ll,3eE,1iI,?1?2tm?2?3n
Ll,3eE,1iI,?a,?1?2tm?2?3n?4
Cc,3eE,aA4@,?1h?3ng?2m?2
Cc,3eE,aA4@,?1h?3ng?2it
...

```

Затем каждый вариант будет опробован с указанными символами:

```
$ ./hashcrack.py -i hashes.txt -t ntlm --mask maskfiles/defaultpass.hcmask
RUN: ./hashcat64.bin -a3 -m 1000 hashes.txt /root/hashcrack/maskfiles/defaultpass.hcmask -O -w4 --session hc
```

В итоге будут опробованы следующе последовательности: P@ssword, p@ssword, Password, password и так далее.

Комбинированные списки

Если мы хотим собрать всё воедино, то можем воспользоваться параметром -a1, combinator и combinator3 из набора hashcat-utils (https://github.com/hashcat/hashcat-utils), а также препроцессором PRINCE (https://github.com/hashcat/princeprocessor).

В команде ниже файл last1-5.txt содержит наиболее встречающиеся суффиксы из моих данных, но вы также можете использоваться два словаря с паролями совместно. Найденные пароли будут являться сочетанием одного пароля из первого словаря и одного пароля из второго. В этом случае слово «samtron» из файла Top95Thousand-probable.txt, слово «_r89» из файла last1-5.txt.

```
$ ./hashcrack.py -i hashes.txt -d /root/dict/Top95Thousand-probable.txt -e /root/dict/last1-5.txt -t ntlm
RUN: ./hashcat64.bin -a1 -m 1000 hashes.txt /root/dict/Top95Thousand-probable.txt /root/dict/last1-5.txt -O -w4 --session hc

8dd1b62216b2703737ad28b59b1bad1d:samtron_r89
8bdc261caed3145d2a9f4f9de8ab31e2:greentreejkvl
9e3e0d23ddb9be5a9498b4c9b4366336:ruby@bds
244e2d25960ca0b8747efd0a1ab3c2f6:shashank.n87
8c9df56a1769a1d8ed3a43989d25cd6f:conway7o4s
b35f0b7e18945d4f1e79b6338a51d519:GarfieldH170
1ff1fdb36d4b3c79cdc5a6d4d01230cb:canuckh2oz
```

Фразы

В качестве эксперимента я взял перечень коротких фраз из перечня n-грамм Гугла (http://storage.googleapis.com/books/ngrams/books/datasetsv3.html), но есть публично доступные списки и в других местах. Вам понадобятся немного другие правила, поскольку возможно потребуются заглавные символы после пробелов, замена пробелов на нижнее подчеркивание и тому подобное. Попробуйте правила из следующего списка https://github.com/initstring/passphrase-wordlist/tree/master/hashcat-rules

```
$ python hashcrack.py -i hashes.txt -t ntlm -d c:\Users\jamie\Desktop\words\1-4grams.txt -r rules\passphrases.rule
RUN: hashcat.exe -a0 -m 1000 D:\hashcrack\hashes.txt c:\Users\jamie\Desktop\words\1-4grams.txt -r D:\hashcrack\rules\passphrases.rule --loopback -O --bitmap-max=26 -w3 --session hc
25d9bebab099e8ef6e0ee0c496a2c917:ambitiouspeople
f08eacad22f93cf1ad34ad34aaa119e6:industrialwelding
a820d36ec57c4ef2c4426c242f50248e:simplysatisfied
5dcbdc8902e458f07bc06eebd8273a6e:WarmFlame
241d1c802fd187f35b3e2b9789b81b6e:JohnBelfield
76cdc9d7543af6effda11f8ccef75669:EyeCannot
17c9ea43a66e21f14a1ed106d06755d4:perhaps_forget
4c2ba3c55cbdcaf1bc83f94777a3b6dd:imaginative_mind
```

Модели Маркова

Как и в случае со всеми подходами, связанными с машинным обучением и статистикой, вы получите наилучшие результаты, если ваши данные на основе обучения коррелируют с паролями, которые вы пытаетесь подобрать. Однако эти пароли не известны, поскольку еще не подобраны. Но можно предположить, что потенциальные пароли во многом совпадают фрагментами из англоязычных текстов. Трэвис Палмер (travco) написал прекрасную программу для решения этой задачи (https://github.com/travco/rephraser).

Файл «corpus.txt» должен содержать множество англоязычных приложений (или того языка, который вы собираетесь использовать).

```
$ python3 ../rephraser/rephraser.py --corpus corpus.txt --model ./wiki1M_model.keyvi | ./hashcat64.bin -a0 -m 1000 hashes.txt -r /root/hashcrack/rules/passphrase.rule -r ../rules/best1222.rule --loopback -O -w4

57871172a2cd8ada7c7794fcb4a1820b:ToStayAtHome07
def7c2415d3d240ff0c4821858b26402:ToBeReset
affbfba14f0b54b5f2ff5db1873d3401:AnABootCamp
33398e1f2542b9b973b5b9a726caf347:TOUNTHEBIG
50d1e344e7d32c5c354ab8a97119c8c5:Abbyishard
7efe3e0e20145e33a35d83e07d69e7bc:Andistillmay
```

Литификация (Leetification)

Этот термин используется в контексте замены символов o->0, s->5, e->3 и так далее, что иногда встречается в паролях (например, «Pa55w0rd»). Вы можете использовать соответствующие правила для замены всех вхождений, но я подозреваю, что большинство пользователей не всегда прибегают к этому приему. В hashcrack есть флаг -3:

```
$ ./hashcrack.py -i hashes.txt -3 -t ntlm

```

Команда выше эквивалентна следующей:

```
$ python3 ../scripts/leetify.py /root/dict/Top2Billion_probable.txt | ./hashcat64.bin -a0 -m 1000 hashes.txt -r /root/hashcrack/rules/best22405.rule --loopback -O -w4 --session hc

```

Этот скрипт выполняет рекурсивную литификацию:

```
$ echo foo > foo
$ python3 scripts/leetify.py foo
foo
fo0
f0o
f00
```

В итоге мы получаем результат, когда происходит замена не всех, а только некоторых символов:

```
46d31b126dec3444a31ebaa8c5aae69e:S3LECt1ON
```

Оценка качества правила

Вы можете добавить опцию --debug-mode=4 --debug-file=foo, чтобы увидеть, как часто применяется правило. Затем по результатам оценки частоты использования каждого правила можно построить красивый график.

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

Оценка качества пароля

Еще один метод для визуализации, насколько быстро подбираются пароли при помощи определенного метода, - использование статусов в hashcat и подсчет общего количества паролей для каждого «тика».

```
hashcat64.exe -a0 -m 1000 C:\Users\jamie\Desktop\hashcrack\defcon2010-ntlm.txt C:\Users\jamie\Desktop\hashcrack\dict\\\Top32Million-probable.txt -r C:\Users\jamie\Desktop\hashcrack\rules\\\l33tpasspro.rule --loopback -O --bitmap-max=26 -w3 --session hc --status >> graphme

d:\hashcrack>python graph-by-quality.py hashcat-5.1.0\graphme
```

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

Представление и символы, не входящие в набор ASCII

Если во время перебора используются символы, не входящие в набор ASCII, нужно знать, как устроен механизм кодирования и хранения этих символов. Например, если вы пытаетесь взломать хеш NTLM для пароля «Gü»:

```
python hashcrack.py -i tst.txt --mask ?b?b?b?b?b?b?b?b -t 900 (MD4)
f343fdedf1447a61694603de4e0d132e:$HEX[4700fc00]

python hashcrack.py -i tst.txt --mask ?b?b?b?b?b?b?b?b -t 1000 (NTLM)
f343fdedf1447a61694603de4e0d132e:$HEX[47fc]
```

Код символа ''ü'' в кодировке CP-1252 можно найти по ссылке https://en.wikipedia.org/wiki/Windows-1252

```
$ echo -n Motörhead > motorhead.txt
$ echo -n Motörhead | sha1sum.exe | cut -f 1 -d' ' > mhash.txt
$ od -t x1 motorhead.txt
0000000 4d 6f 74 c3 b6 72 68 65 61 64
```

Однако если мы будем подбирать при помощи этого метода, то получим следующий результат:

```
python hashcrack.py -i mhash.txt -d motorhead.txt
```

Кажется, у меня кодировка UTF-8 отображается по-другому:

```
ac05c7c87e3514e7f36a482c65c419e5fe58c6cb:Mot├Ârhead
```

Однако в файл potfile сохранение происходит корректно, и в редакторе, поддерживающим нужную кодировку, отображается правильно:

```
ac05c7c87e3514e7f36a482c65c419e5fe58c6cb:Motörhead
```

Более подробная информация доступна по ссылке https://www.nixu.com/blog/cracking-non-english-character-passwords-using-hashcat

Медленные хеши

Рассмотрим три типа хешей с очень разным алгоритмом кодирования: NTLM, WordPress (phpass) и bcrypt. Хеш NTLM – несоленый, и мы можем параллельно подбирать множество хешей, что является плохой новостью для тех, кто отвечает за защиту. В двух других типах соление используется, и каждый хеш должен подбираться отдельно. Соответственно, взлом миллиона хешей будет в миллион раз сложнее.

Еще одно основное отличие - относительная скорость перебора. К примеру, на платформе 1080 Ti скорость перебора примерно 50 миллиардов попыток в секунду для NTLM хешей, 8 миллионов для WordPress и около 20 тысяч для bcrypt. Однако у bcrypt есть параметр cost, позволяющий замедлить вычисление. Пример с hashcat достаточно удачный, когда значение параметра cost равно 5. В большинстве современных реализаций значение этого параметра равно 10 или 12, и мы сможем выполнять лишь 1000 попыток в секунду.

Цель этого параметра – замедлить вычисления настолько, насколько возможно, но без раздражения пользователей. В идеале – около 100 миллисекунд на одно вычисление. Поскольку компьютеры становятся всё быстрее, мы увеличиваем фактор стоимости и сильно затрудняем задачу злоумышленникам. Естественно, при условии, что пользователи не будут использовать пароли навроде «Summer2020».

Если вы подбираете хеши навроде bcrypt, нужно начинать с наиболее вероятных паролей и атаковать только хеши, которые могут оказаться наиболее полезными, поскольку подбор этого типа хешей в 50 миллионов раз медленнее, чем вычисление хешей NTLM. Соответственно, вычисление 1000 хешей в 50 миллиардов раз медленнее, чем перебор тысячи NTLM-паролей.

Чтобы вы могли увидеть различия между типами хешей, ниже приводится пример подбора пароля «hashcat» для WordPress, где используется тип хеша phpass:

```
D:\hashcrack>python hashcrack.py --hash "$P$984478476IagS59wHZvyQMArzfx58u." -d hashcat.txt
Running under win32
Reading file: C:\Users\jamie\AppData\Local\Temp\\zc2lxx1b.hash.tmp
Autodetected phpass
Cracking hash type 400
RUN: hashcat.exe -a0 -m 400 C:\Users\jamie\AppData\Local\Temp\\zc2lxx1b.hash.tmp D:\hashcrack\hashcat.txt --loopback -O --bitmap-max=26 -w3 --session hc
...
$P$984478476IagS59wHZvyQMArzfx58u.:hashcat
```

Подбор пароля «hashcat», если используется хеш bcrypt:

```
D:\hashcrack>python hashcrack.py --hash "$2a$05$LhayLxezLhK1LhWvKxCyLOj0j1u.Kj0jZ0pEmm134uzrQlFvQJLF6" -d hashcat.txt
Reading file: C:\Users\jamie\AppData\Local\Temp\\_kwbmbla.hash.tmp
Autodetected bcrypt
Cracking hash type 3200
Selected rules: best1222.rule, dict Top95Thousand-probable.txt, inc 0
Using dict and rules
CWD: D:\hashcrack\hashcat-5.1.0
RUN: hashcat.exe -a0 -m 3200 C:\Users\jamie\AppData\Local\Temp\\_kwbmbla.hash.tmp D:\hashcrack\hashcat.txt -r D:\hashcrack\rules\\\best1222.rule --loopback -O --bitmap-max=26 -w3 --session hc
$2a$05$LhayLxezLhK1LhWvKxCyLOj0j1u.Kj0jZ0pEmm134uzrQlFvQJLF6:hashcat
```

Более реалистичный пример с bcrypt, когда скорость вычисления более медленная:

```
Hash.Target......: $2y$10$WRTjKNVhj..Le.aoy1EZTufJP.5Q1V319sDL7v3cvgvd...sYKrQK
Speed.#1.........: 1021 H/s (327.25ms) @ Accel:16 Loops:32 Thr:12 Vec:1
```

Заключение

В этой статье мы рассмотрели базовые возможности hashcat вместе с различными надстройками. В качестве дальнейшего напутствия я бы хотел сказать следующее:

• NVIDIA 1080/2080 сейчас можно приобрести по разумной цене.
• Изучите основные режимы и протестируйте эти режимы для подбора паролей, которые вам нужны.
• Выдвигайте различные гипотезы о том, как может выглядеть потенциальный пароль, и тестируйте эти гипотезы.
• Попробуйте использовать имена компаний, адреса офисов, текущий сезон, текущий код и так далее.
• Охлаждайте сборку, используемую для перебора.

Всего наилучшего.

Ссылки

• Example hashcat hashes for each type: https://hashcat.net/wiki/doku.php?id=example_hashes
• Description of hashcat rules: https://hashcat.net/wiki/doku.php?id=rule_based_attack
• Hashcat: https://hashcat.net/hashcat/
• Hashcat help forum: https://hashcat.net/forum/
• John the Ripper: https://www.openwall.com/john/
• Hashcrack, my helper script: https://github.com/blacktraffic/hashcrack
• which has an accidental name clash with the amazing book:
• Hashcrack, 3rd edition: https://www.amazon.co.uk/Hash-Crack-Password-Cracking-Manual/dp/1793458618
• Terahash, makers of shiny hardware: https://terahash.com/#appliances