Виды атак oclHashcat (Hashcat)

Источник: https://hashcat.net/wiki/

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

• Атака брут-форсом (перебором)
• Комбинаторная атака
• Атака по словарю
• Атака по отпечаткам
• Гибридная атака
• Атака по Маске
• Перестановочная атака
• Атака основанная на правиле
• Табличная атака
• Атака с переключением регистра

Атака по Маске (Брут-Форс)

Описание Атаки по Маске (Брут-Форса)

При Атаке по маске пробуются все комбинации из заданного пространства ключей — в точности как атака Брут-Форс, но имеются особенности.

Преимущества по сравнению с Брут-Форсом

Причина использовать атаку по маске и не зацикливаться на Брут-Форсе в том, что мы хотим уменьшить количество кандидатов в пароли в пространстве ключей до самых вероятных.

Вот один пример. Мы хотим взломать пароль: Julia1984

В традиционной атаке Брут-Форс нам требуется набор символов, который включает все заглавные буквы, все строчные буквы и все цифры (aka “mixalpha-numeric”). Длина пароля — 9, поэтому нам нужно пройти через 62^9 (13.537.086.546.263.552) комбинаций. Допустим мы взламываем на скорости 100M/s, это потребует более 4 лет для завершения.

В атаке по Маске мы имеем представление о людях и о том, как они делают пароли. Вышеприведённый пароль соответствует простому, но распространённому паттерну (образцу). В нём имеется имя и год. Вы можем также настроить атаку - пробовать буквы верхнего регистра только в первой позиции. Очень нечасто можно увидеть буквы верхнего регистра только во второй или в третей позиции. Мы делаем пространство ключей короче, с атакой по Маске мы можем уменьшить его до 52*26*26*26*26*10*10*10*10 (237.627.520.000) комбинаций. С такой же скоростью взлома 100M/s, это потребует всего 40 минут до завершения.

Недостатки по сравнению с Брут-Форсом

А их нет. Кто-то может возразить, что приведённый пример очень специфичен, но это не имеет значения. Даже в атаке по маске мы можем настроить атаку таким образом, что её поведение будет в точности как у атаки Брут-Форс. А в обратную сторону это не работает.

Маски

Для каждой позиции генерируемого кандидата в пароли нам нужно настроить заполнитель. Если пароль, который мы хотим взламывать, имеет длину 8, наша маска должна содержать 8 заполнителей.

• Маска — это простая строка, которая, используя заполнители, настраивает пространство ключей для движка кандидатов в пароли.
• Заполнитель может быть как: пользовательским набором символов, встроенным набором символов или статичным символом.
• Переменные помечаются символом ?, после которого следует встроенный набор символов (l, u, d, s, a) или одно из имён пользовательских наборов символов (1, 2, 3, 4).
• Статический символы не помечаются каким-либо образом. Исключения для символа ?, если мы хотим именно знак вопроса, то нужно записать так - ??.

Выход

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

aaaaaaaa
aaaabaaa
aaaacaaa
.
.
.
aaaaxzzz
aaaayzzz
aaaazzzz
baaaaaaa
baaabaaa
baaacaaa
.
.
.
baaaxzzz
baaayzzz
baaazzzz
.
.
.
zzzzzzzz

ПРИМЕЧАНИЕ: Здесь показано, что первые четыре символа увеличиваются первыми и наиболее часто. При этом точные значения могут разниться, особенно с уменьшением пространства ключей, но факт в том, что пространство ключа будет выбрано до последнего.

ПРИМЕЧАНИЕ: если вы используете oclHashcat вы можете нажать “s” чтобы увидеть прогресс взлома.

Встроенные наборы символов

• ?l = abcdefghijklmnopqrstuvwxyz
• ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ
• ?d = 0123456789
• ?s = «пробел»!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
• ?a = ?l?u?d?s
• ?b = 0x00 - 0xff

Пользовательские наборы символов

Все производные hashcat имеют четыре параметра командной строки для настройки четырёх пользовательских наборов символов.

--custom-charset1=CS
--custom-charset2=CS
--custom-charset3=CS
--custom-charset4=CS

Эти параметры командной строки имеют четыре сокращённых названия -1, -2, -3 и -4. Вы можете задать символы непосредственно в командной строке или использовать так называемые файлы наборов символов hashcat (обычные текстовые файлы с расширением .hcchr, в которых в первой строке файла содержаться символы для использования. Смотрите примеры ниже:

Примеры пользовательских наборов символов:

Следующие все команды определяют один и тот же пользовательский набор символов, который состоит из “abcdefghijklmnopqrstuvwxyz0123456789” (aka “lalpha-numeric”):

-1 abcdefghijklmnopqrstuvwxyz0123456789
-1 abcdefghijklmnopqrstuvwxyz?d
-1 ?l0123456789
-1 ?l?d
-1 loweralpha_numeric.hcchr # file that contains all digits + chars (abcdefghijklmnopqrstuvwxyz0123456789)

Следующая команда определяет набор символов, который состоит из “0123456789abcdef”:

-1 ?dabcdef

Следующая команда определяет полный набор 7-битных символов (aka “mixalpha-numeric-all-space”):

-1 ?l?d?s?u

Следующая команда устанавливает для первого набора символов (-1) содержать все символы русского алфавита:

-1 charsets/special/Russian/ru_ISO-8859-5-special.hcchr

Пример пространства ключей по маске

Следующие команды создают такие кандидаты в пароли как:

команда: -a 3 ?l?l?l?l?l?l?l?l
пространство ключей: aaaaaaaa - zzzzzzzz

команда: -a 3 -1 ?l?d ?1?1?1?1?1
пространство ключей: aaaaa - 99999

команда: -a 3 password?d
пространство ключей: password0 - password9

команда: -a 3 -1 ?l?u ?1?l?l?l?l?l19?d?d
пространство ключей: aaaaaa1900 - Zzzzzz1999

команда: -a 3 -1 ?dabcdef -2 ?l?u ?1?1?2?2?2?2?2
пространство ключей: 00aaaaa - ffZZZZZ

команда: -a 3 -1 efghijklmnop ?1?1?1
пространство ключей: eee - ppp

Увеличение длины пароля

Атака по Маске всегда специфична к длине пароля. Например, если мы используем маску “?l?l?l?l?l?l?l?l”, то мы можем только взламать пароль длинной 8 символов. Но если пароль, который мы пытаемся взломать имеет длину 7 символов, мы его не найдём. Поэтому нам требуется повторять атаку несколько раз, и при каждом новом запуске добавлять в маску один заполнитель. Это делается на полном автомате с флагом “--increment”.

?l
?l?l
?l?l?l
?l?l?l?l
?l?l?l?l?l
?l?l?l?l?l?l
?l?l?l?l?l?l?l
?l?l?l?l?l?l?l?l

Файлы Hashcat с наборами символов

Файлы Hashcat с наборами символов (расширение файлов .hcchr) — это удобный способ повторно использовать наборы символов, указывайте пользовательский наборы символов и используйте поставляемые с hashcat наборы для определённых языков.

Эти файлы могут использоваться совместно с параметром –custom-charset=N (или -1, -2, -3 и -4). Вместо указания всех символов непосредственно в командной строке, можно указать путь до файла .hcchr:

-1 charsets/standard/German/de_cp1252.hcchr

Важно то, что файлы .hcchr создаются со специфичной для языка кодировкой (например, cp1252, ISO-8859-15 и т.д.). Для примеров содержимого и кодировки файлов .hcchr смотрите примеры, поставляющиеся с hashcat (например [HASHCATROOT]/charsets/standard/Italian/).

Совет: используйте iconv и подобные инструменты для конвертации файлов в специфические файловые кодировки (если, например, создали файл в UTF-8).

Файлы Hashcat с масками

Файлы Hashcat с масками (расширение файла .hcmask) — это файлы, которые построчно содержат пользовательские наборы символов (опционально) и маски (например, ?1?1?1?1?d?d). Преимущество использования файлов .hcmask, которые представляют собой обычный текст, в том, что эти файлы позволяют пользователям hashcat иметь предопределённые и хорошо работающие маски, сохранённые в файле (или нескольких, например, файлах под конкретные политики паролей), где строки, содержащиеся в файле hcmask, могут, например, быть отсортированы по увеличению времени работы и/или по вероятности совпадения*.

Обычным форматом является одна единственная строка в файле .hcmask вроде следующей:

[?1,][?2,][?3,][?4,]mask

где заполнителями являются следующие:

• [?1] первый набор символов (–custom-charset1 или -1) будет установлен в эту величину, опционально
• [?2] второй набор символов (–custom-charset2 or -2) будет установлен в эту величину, опционально
• [?3] третий набор символов (–custom-charset3 or -3) будет установлен в эту величину, опционально
• [?4] четвёртый набор символов (–custom-charset4 or -4) будет установлен в эту величину, опционально
• [mask] маска, которая может (но не обязательно) использовать пользовательские наборы символов, определённые в [?1], [?2], [?3] или [?4] и может использовать любые дополнительные предопределённые наборы символов (?d, ?l, ?u, ?s, ?a, ?b) и может также содержать фиксированные символы (пример маски: pass?1?d?d?2?l?l

* смотрите ПАКЕТ программы и несколько примеров файлов hcmask поставляемых с hashcat (в каталоги masks/).

В конмадной строке вы указываете ссылку на файл .hcmask в том месте, где разместили бы одиночную маску. Примерно так:

-a 3 hash.txt mask_file.hcmask

Другой не такой важный, но доступный синтаксис файлов .hcmask:

• с # вы можете закомментировать строку (она не будет использоваться), с \# вы можете использовать # в пользовательском наборе символов или маске
• \, означает, что запятая должна использоваться буквально (а не как разделитель между ?1, ?2, ?3, ?4 или маской)

Примечание: файлы .hcmask могут использоваться совместно с параметром -i (приращение) для режима брут-форса. Если [маска] содержит ссылки ?1,?2,?3 или ?4, а сами [?1], [?2], [?3], [?4] не установлены, то могут быть неожиданные результаты. Следовательно, этого следует по возможности избегать.

Если, к примеру, [?2] не был установлен поскольку не нужен, запятая, которая в другом случае следовала бы за [?2], должна быть пропущена. Смотрите примеры ниже:

Примеры файлов масок

Следующий файл example.hcmask содержит несколько примеров валидных строк, которые показывают как использовать эту функцию:

?d?l,test?1?1?1
abcdef,0123,ABC,789,?3?3?3?1?1?1?1?2?2?4?4?4?4
company?d?d?d?d?d
?l?l?l?l?d?d?d?d?d?d

Наборы символов в шестнадцатеричном формате

Это может быть сделано некоторыми инструментами hashcat с использованием флага “--hex-charset”.

• hashcat: Поддерживает.
• oclHashcat: Поддерживает.
• maskprocessor: Поддерживает.

Поддержка наборов символов в шестнадцатеричном формате

Эта атака в настоящий момент поддерживается в:

• hashcat
• oclHashcat
• maskprocessor

Примечание: файлы масок в настоящий момент поддерживаются только в oclHashcat.

Комбинаторная атака

Описание комбинаторной атаки

Каждое слово в словаре добавляется к каждому слову в словаре.

Ввод

Если наш словарь содержит слова:

pass
12345
omg
Test

Вывод

Hashcat создаст следующие кандидаты в пароли:

passpass
pass12345
passomg
passTest
12345pass
1234512345
12345omg
12345Test
omgpass
omg12345
omgomg
omgTest
Testpass
Test12345
Testomg
TestTest

Комбинаторная атака в oclhashcat

Внимание: для (cpu) hashcat (hashcat-cli*) смотрите параграф ниже «Комбинаторная атака в (cpu) hashcat» (есть небольшие, но важные различия).

Использование комбинаторной атаки в oclhashcat (это не отдельная версия Комбинаторной атаки).

Команда для Комбинаторной атаки в oclhashcat это -a 1

Вам нужно указать ровно 2 словаря в вашей командной строке, например:

./oclHashcat64.bin -m 0 -a 1 hash.txt dict1.txt dict2.txt

Если вам хочется добавить правила к левому или правому словарю или к обоим одновременно, тогда вы можете использовать ключи -j или -k.

  -j,  --rule-left=ПРАВИЛО              Одно правило, применяемое к каждому слову в левом словаре
  -k,  --rule-right=ПРАВИЛО             Одно правило, применяемое к каждому слову в правом словаре

Пример.

Словарь 1

yellow
green
black
blue

Словарь 2

car
bike

Команды

-j $-

-k $!

Вывод должен быть таким…

yellow-car!
green-car!
black-car!
blue-car!
yellow-bike!
green-bike!
black-bike!
blue-bike!

Комбинаторная атака в (cpu) hashcat

Hashcat (или cpu hashcat, hashcat-cli*) также поддерживает режим комбинаторной атаки.

Единственным (но важным) различием между комбинаторными атаками в oclHashcat и hashcat является то, что cpu hashcat делает комбинации из слов, данных в одном файле словаря (списке слов), в то время как для oclHashcat вам нужно указать ровно 2 файла.

Это означает, что нужно указать только и ровно 1 (словарь) файл внутри командной строки для hashcat (кроме файла хеша).

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

Пример:

hashcat-cli64 -m 0 -a 1 hash.txt dict.txt

Поддержка комбинаторной атаки

В настоящий момент эта атака поддерживается в:

• hashcat
• oclHashcat
• hashcat-utils

Атака по словарю

Описание атаки по словарю

Атака по словарю или «прямой режим» - это очень простой вид атаки. Она также известна как «Атака по списку слов»,

Всё, что требуется, это прочитать построчно текстовый файла (также известных как «словарь» или «список слов») и попробовать каждую строчку в качестве кандидата в пароли.

Поддержка атаки по словарю

Эта атака в настоящее время поддерживается в:

• hashcat
• oclHashcat

Атака по отпечаткам

 

 

 

Гибридная атака

Описание гибридной атаки

В принципе, Гибридная атака — это всего лишь Комбинаторная атака. Одна сторона — это просто словарь, другая сторона — результат атаки Брут-Форс. Другими словами, полное пространство ключей Брут-Форса добавляется или предваряется к каждому слову в словаре. Поэтому она называется «гибридной».

В качестве альтернативы вы можете использовать Атаку по маске или Атаку основанную на правиле для замены Брут-Форсной стороны.

Примеры

Если ваш example.dict содержит:

password
hello

Настройка:

$ ... -a 6 example.dict ?d?d?d?d

генерирует следующие кандидаты в пароли:

password0000
password0001
password0002
.
.
.
password9999
hello0000
hello0001
hello0002
.
.
.
hello9999

Это работает и в противоположную сторону!

Настройка:

$ ... -a 7 ?d?d?d?d example.dict

генерирует следующие кандидаты в пароли:

0000password
0001password
0002password
.
.
.
9999password
0000hello
0001hello
0002hello
.
.
.
9999hello

Поддержка Гибридной атаки

В настоящий момент эта атака поддерживается в:

• oclHashcat

Использование правил для создания Гибридной атаки

Мы можем использовать движок правил в hashcat для эмуляции Гибридной атаки.

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

Это полезно, если вы хотите выполнить Гибридную атаку hashcat. Всё, что вам нужно, это добавить “-r bf.rule”.

Пример 1, добавление к словарю

Это добавит 0000 - 9999 к каждому слову из вашего словаря:

$ ./mp64.bin -o bf.rule '$?d $?d $?d $?d'

Пример 2, предваряя словарь

Это поставит aa - zz перед каждым словом из вашего словаря:

$ ./mp64.bin -o bf.rule '^?l ^?l'

Перестановочная атака

Описание перестановочной атаки

Каждое слово в словаре генерирует перестановки из себя (используются буквы слова для создания новых слов).

Ввод

Если наш словарь содержит слова:

ABC

Вывод

Hashcat и oclHashcat создадут следующие кандидаты в пароли:

ABC
ACB
BAC
BCA
CAB
CBA

Оптимизация перестановочной атаки

Эта атака может быть оптимизирована если вы подготовите ваши словари. Смотрите секцию по утилите prepare на странице Hashcat-utils.

Поддержка перестановочной атаки

Эта атака в настоящее время поддерживается в:

• hashcat
• oclHashcat
• hashcat-utils

Атака основанная на правиле

Описание Атаки основанной на правиле

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

Почему бы не остановиться на регулярных выражениях

Зачем изобретать колесо? Ответ прост: регулярные выражения слишком медленны. Обычно мы хотим сгенерировать 1.000.000.000 (или более) новых кандидатов в пароли за менее чем 10 миллисекунд перед тем как алгоритм хеширования начнёт простаивать, а затем снова и снова, секунду за секундой. Просто взгляните на отображение скорости вашего GPU, чтобы получить представление об этом.

Совместимость с другими движками правил

Движок правил Hashcat написан так, чтобы все функции, которые делят одинаковое буквенное имя, были на 100% совместимы с правилами John the Ripper и PasswordsPro и наоборот. Позже были представлены некоторые собственные функции, которые несовместимы. Но эти функции получили их собственные буквенные имена во избежание конфликтов.

Реализация совместимых функций

Следующие функции на 100% совместимы с John the Ripper и PasswordsPro:

Имя	Функция	Описание	Пример правила	Слово на входе	Слово на выходе	Примечание
Ничего	:	ничего не делать	:	p@ssW0rd	p@ssW0rd
Нижний регистр	l	Сделать строчными все буквы	l	p@ssW0rd	p@ssw0rd
Верхний регистр	u	Сделать заглавными все буквы	u	p@ssW0rd	P@SSW0RD
Капитализация	c	Сделать заглавной первую букву, а остальные маленькими	c	p@ssW0rd	P@ssw0rd
Обратная капитализация	C	Сделать маленькой первую букву, а остальныме заглавными	C	p@ssW0rd	p@SSW0RD
Переключить регистр	t	Изменить на противоположный регистр всех символов в слове	t	p@ssW0rd	P@SSw0RD
Переключить @	TN	Переключить регистр символа в позиции N	T3	p@ssW0rd	p@sSW0rd	*
Обратить	r	Обратить всё слово	r	p@ssW0rd	dr0Wss@p
Дублицировать	d	Продублировать всё слово	d	p@ssW0rd	p@ssW0rdp@ssW0rd
Дублицировать N	pN	Добавить дубликаты слова N раз	p2	p@ssW0rd	p@ssW0rdp@ssW0rdp@ssW0rd
Отразить	f	Дублицировать обратное слово	f	p@ssW0rd	p@ssW0rddr0Wss@p
Повернуть влево	{	Повернуть слово влево	{	p@ssW0rd	@ssW0rdp
Повернуть вправо	}	Повернуть слово вправо	}	p@ssW0rd	dp@ssW0r
Добавить символ	$X	Добавить символ X в конец	$1	p@ssW0rd	p@ssW0rd1
Предварить символом	^X	Добавить символ X в начало	^1	p@ssW0rd	1p@ssW0rd
Обрезать слева	[	Удалить первый символ	[	p@ssW0rd	@ssW0rd
Обрезать справа	]	Удалить последний символ	]	p@ssW0rd	p@assW0r
Удалить @ N	DN	Удаляет символ в позиции N	D3	p@ssW0rd	p@sW0rd	*
Извлечь диапазон	xNM	Извлекает M символов, начиная с позиции N	x04	p@ssW0rd	p@ss	* #
Пропустить диапазон	ONM	Удаляет M символов, начиная с позиции N	O12	p@ssW0rd	psW0rd	*
Вставить @ N	iNX	Вставляет символ X в позицию N	i4!	p@ssW0rd	p@ss!W0rd	*
Переписать @ N	oNX	Перезаписывает символ в позиции N на X	o3$	p@ssW0rd	p@s$W0rd	*
Обрезать @ N	'N	Обрезает слово на позиции N	'6	p@ssW0rd	p@ssW0
Заменить	sXY	Заменяет все вхождения X на Y	ss$	p@ssW0rd	p@$$W0rd
Стереть	@X	Стирает все вхождения X	@s	p@ssW0rd	p@W0rd	+
Дублицировать первый N	zN	Дублицирует первый символ N раз	z2	p@ssW0rd	ppp@ssW0rd
Дублицировать последний N	ZN	Дублицирует первый символ N раз	Z2	p@ssW0rd	p@ssW0rddd
Дублицировать всё	q	Дублицирует каждый символ	q	p@ssW0rd	pp@@ssssWW00rrdd
Извлечь память	XNMI	Вставляет подстроку длиной M начиная с позиции N слова, сохранённого в памяти, на позиции I	lMX428	p@ssW0rd	p@ssw0rdw0	+
Добавить память	4	Добавляет слово, сохранённое в памяти, к текущему слову	uMl4	p@ssW0rd	p@ssw0rdP@SSW0RD	+
Предварить памятью	6	Слово, сохранённое в памяти, ставит перед текущим словом	rMr6	p@ssW0rd	dr0Wss@pp@ssW0rd	+
Запомнить	M	Запоминает текущее слово	lMuX084	p@ssW0rd	P@SSp@ssw0rdW0RD	+

• * Показывает, что N начинается на 0. Для позиций символов отличных от 0-9 используйте A-Z (A=11)
• + Показывает что это правило реализовано только в hashcat.
• # Изменена в oclHashcat v1.37 → v1.38 и hashcat v0.51 → v0.52

Правила, используемые для отклонения паролей

Имя	Функция	Описание	Пример правила	Примечание
Отклонить менее	<N	Отклонить пароли длиной более чем N	<16
Отклонить более	>N	Отклонить пароли длиной менее чем N	>7
Отклонить содержащего	!X	Отклонить пароли содержащие символ X	!z
Отклонить не содержащего	/X	Отклонить пароли, которые не содержат символ X	/e
Отклонить равный первому	(X	Отклонить пароли, которые не начинаются с X	(h
Отклонить равный последний	)X	Отклонить пароли, которые не оканчиваются на X	)t
Отклонить равный на	=NX	Отклонить пароли, которые не имеют символа X в позиции N	=1a
Отклонить содержащий	%NX	Отклонить пароли, которые содержат символ X менее чем N раз	%2a
Отклонить содержащий	Q	Отклонить пароли, где сохранённая память соответствует текущему слову	rMrQ	пример для палиндромов

Все правила отклонения должны работать с цэпэушной hashcat и «медленными алгоритмами» когда используется oclHashcat.

Реализация специфичных функций

Следующие функции недоступны в John the Ripper и PasswordsPro:

Имя	Функция	Описание	Пример правила	Слово на входе	Слово на выходе	Примечание
Поменнять перёд	k	Поменять местами первые два символа	k	p@ssW0rd	@pssW0rd
Поменять окончание	K	Поменять местами последние два символа	K	p@ssW0rd	p@ssW0dr
Поменятьт @ N	*XY	Поменять символ X на Y	*34	p@ssW0rd	p@sWs0rd	*
Побитовый сдвиг влево	LN	Побитовый сдвиг влево символа @ [на позиции] N	L2	p@ssW0rd	p@æsW0rd	*
Побитовый сдвиг вправо	RN	Побитовый сдвиг вправо символа @ N	R2	p@ssW0rd	p@9sW0rd	*
Приращение Ascii	+N	Приращение символа @ N на 1 ascii величину	+2	p@ssW0rd	p@tsW0rd	*
Уменьшение Ascii	-N	Уменьшение символа @ N на 1 ascii величину	-1	p@ssW0rd	p?ssW0rd	*
Заменить N + 1	.N	Заменить символ @ N на величину @ N плюс 1	.1	p@ssW0rd	psssW0rd	*
Заменить N - 1	,N	Заменить символ @ N на величину @ N минус 1	,1	p@ssW0rd	ppssW0rd	*
Дублицировать передний блок	yN	Дублицировать первые N символов	y2	p@ssW0rd	p@p@ssW0rd	*
Дублицировать конечный блок	YN	Дублицировать последние N символов	Y2	p@ssW0rd	p@ssW0rdrd	*
Заголовок	E	Перевести всю строку в маленькие буквы, затем сделать большими первую букву и каждую букву после пробела	E	p@ssW0rd w0rld	P@ssw0rd W0rld

• * Показывает, что N начинается с 0. Для позиций символов отличных от 0-9 используйте A-Z (A=10)

Запись правил

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

• Мы хотим что-то добавить.
• Величина, которую мы хотим добавить, - это цифра.

Если мы взглянем на обзор функций, мы увидим возможность что-то добавить используя функцию '$'. Поэтому, например, если мы хотим добавить к нашему паролю “1”, мы записываем правило, которое выглядит вроде этого.

$1

Достаточно просто. Но что если мы хотим сделать это со всеми цифрами 1 — 9? Это то, что мы называем Гибридной атакой, просто взгляните на этот раздел.

Также помните:

• Белые пробелы игнорируются тех пор, пока они не используются в качестве параметра. Это позволяет немного форматировать наш «исходный код».
• Чтобы закомментировать текст его нужно начать с символа “#”.

Генерация правил

Есть два способа автоматической «генерации» правил.

• Используя maskprocessor.
• Используя случайные правила.

Использование maskprocessor для генерации правил

maskprocessor — это мощный инструмент и использоваться он может разными способами, в этом случае: для создания правил, работающих с hashcat или oclHashcat.

Создание правил

Давайте предположим, вы хотите создать правило, которое добавляет по 3 цифры после каждого слова в вашем словаре и сохранить как “append_3_digits.rule”.

Вручную

$ vim append_3_digits.rule
$0 $0 $0
$0 $0 $1
$0 $0 $2
$0 $0 $3
$0 $0 $4
$0 $0 $5
$0 $0 $6
$0 $0 $7
$0 $0 $8
$0 $0 $9
$0 $1 $0
$0 $1 $1
и т.д....

Как вы можете увидеть, создание правил руками может быть очень скучным и затратным по времени :p

Используя maskprocessor

./mp64.bin -o append_3_digits.rule '$?d $?d $?d'

maskprocessor позволяет вам легко и быстро сгенерировать файл с правилами

Синтаксис:

• $ - это функция для добавления символа
• ?d — это набор символов из цифр

Примеры команды

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

Скопируйте подходящий набор команд в вашу операционную систему (32/64) bit.

32 Bit

mp32.exe -1 0123456789 "^?1^?1^?1" -o Prefix-0-999.rule
mp32.exe -1 0123456789 "l^?1^?1^?1" -o Lower-All-Prefix-0-999.rule
mp32.exe -1 0123456789 "c^?1^?1^?1" -o Upper-First-Prefix-0-999.rule
mp32.exe -1 0123456789 "u^?1^?1^?1" -o Upper-All-Prefix-0-999.rule
mp32.exe -1 0123456789 "d^?1^?1^?1" -o Double-Word-Prefix-0-999.rule

mp32.exe -1 0123456789 "$?1$?1$?1" -o Suffix-0-999.rule
mp32.exe -1 0123456789 "l$?1$?1$?1" -o Lower-All-Suffix-0-999.rule
mp32.exe -1 0123456789 "c$?1$?1$?1" -o Upper-First-Suffix-0-999.rule
mp32.exe -1 0123456789 "u$?1$?1$?1" -o Upper-All-Suffix-0-999.rule
mp32.exe -1 0123456789 "d$?1$?1$?1" -o Double-Word-Suffix-0-999.rule

mp32.exe -1 0123456789 "^?1^?1^?1^?1" -o Prefix-0-9999.rule
mp32.exe -1 0123456789 "l^?1^?1^?1^?1" -o Lower-All-Prefix-0-9999.rule
mp32.exe -1 0123456789 "c^?1^?1^?1^?1" -o Upper-First-Prefix-0-9999.rule
mp32.exe -1 0123456789 "u^?1^?1^?1^?1" -o Upper-All-Prefix-0-9999.rule
mp32.exe -1 0123456789 "d^?1^?1^?1^?1" -o Double-Word-Prefix-0-9999.rule

mp32.exe -1 0123456789 "$?1$?1$?1$?1" -o Suffix-0-9999.rule
mp32.exe -1 0123456789 "l$?1$?1$?1$?1" -o Lower-All-Suffix-0-9999.rule
mp32.exe -1 0123456789 "c$?1$?1$?1$?1" -o Upper-First-Suffix-0-9999.rule
mp32.exe -1 0123456789 "u$?1$?1$?1$?1" -o Upper-All-Suffix-0-9999.rule
mp32.exe -1 0123456789 "d$?1$?1$?1$?1" -o Double-Word-Suffix-0-9999.rule



64 Bit

mp64.exe -1 0123456789 "^?1^?1^?1" -o Prefix-0-999.rule
mp64.exe -1 0123456789 "l^?1^?1^?1" -o Lower-All-Prefix-0-999.rule
mp64.exe -1 0123456789 "c^?1^?1^?1" -o Upper-First-Prefix-0-999.rule
mp64.exe -1 0123456789 "u^?1^?1^?1" -o Upper-All-Prefix-0-999.rule
mp64.exe -1 0123456789 "d^?1^?1^?1" -o Double-Word-Prefix-0-999.rule

mp64.exe -1 0123456789 "$?1$?1$?1" -o Suffix-0-999.rule
mp64.exe -1 0123456789 "l$?1$?1$?1" -o Lower-All-Suffix-0-999.rule
mp64.exe -1 0123456789 "c$?1$?1$?1" -o Upper-First-Suffix-0-999.rule
mp64.exe -1 0123456789 "u$?1$?1$?1" -o Upper-All-Suffix-0-999.rule
mp64.exe -1 0123456789 "d$?1$?1$?1" -o Double-Word-Suffix-0-999.rule

mp64.exe -1 0123456789 "^?1^?1^?1^?1" -o Prefix-0-9999.rule
mp64.exe -1 0123456789 "l^?1^?1^?1^?1" -o Lower-All-Prefix-0-9999.rule
mp64.exe -1 0123456789 "c^?1^?1^?1^?1" -o Upper-First-Prefix-0-9999.rule
mp64.exe -1 0123456789 "u^?1^?1^?1^?1" -o Upper-All-Prefix-0-9999.rule
mp64.exe -1 0123456789 "d^?1^?1^?1^?1" -o Double-Word-Prefix-0-9999.rule

mp64.exe -1 0123456789 "$?1$?1$?1$?1" -o Suffix-0-9999.rule
mp64.exe -1 0123456789 "l$?1$?1$?1$?1" -o Lower-All-Suffix-0-9999.rule
mp64.exe -1 0123456789 "c$?1$?1$?1$?1" -o Upper-First-Suffix-0-9999.rule
mp64.exe -1 0123456789 "u$?1$?1$?1$?1" -o Upper-All-Suffix-0-9999.rule
mp64.exe -1 0123456789 "d$?1$?1$?1$?1" -o Double-Word-Suffix-0-9999.rule

• Скопируйте их в текстовый файл и назовите его “Hashcat Rule Generator.cmd”.
• Разместите новый файл в ту же директорию где и mask-processor и дважды кликните на него.

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

Ограничения

Когда вы пытаетесь вставить символ ^ заключите его в кавычки, поскольку это экранирующий символ в командной строке Widnows, и поэтому он не будет напечатан если не обнесён кавычками.

Примеры.

mp32.exe -1 0123456789 "^"?1"^"?1"^"?1 -o "Prefix 0-999.rule"

НЕТ

mp32.exe -1 0123456789 ^?1^?1^?1 -o "Prefix 0-999.rule"

Случайный правила

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

• Говорит hashcat сгенерировать ЧИСЛО правил для применения к каждой попытке:

--generate-rules=ЧИСЛО

• Указывает ЧИСЛО функций которые нужно использовать (диапазон от минимума до максимума):

--generate-rules-func-min=ЧИСЛО
--generate-rules-func-max=ЧИСЛО

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

Например, программа может случайно сгенерировать правила “l r”, “l ^f” и “sa@”, это валидные для использования правила. Тем не менее комбинация “l ^f sa@ r $3” будет проигнорирована, поскольку она содержит 5 функций. По умолчанию: минимум=1, максимум=4.

Вы можете смешивать ваши правила из файла с правилами со случайно сгенерированными правилами. Например, если ваш файл с правилами содержит 200 правил и вы используете -g 500, то будет сгенерировано 300 дополнительных правил.

Сохранение подходящих правил

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

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

--debug-mode=1 --debug-file=matched.rule

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

Отладка правил

С hashcat мы можем с лёгкостью отлаживать наши правила. Это означает, что мы можем убедиться что правило, которое мы написали, делает именно то, что мы хотели бы чтобы оно делало. Всё, что вам нужно, это использовать переключатель --stdout и пропустить список хешей.

Вот пример:

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

$ echo WORd > word

Генерируем простое правило. Правило “c” делает заглавной первую букву и маленькими остальные.

$ echo c > rule

И теперь мы видем сгенерированный вывод оттладки:

$ ./hashcat-cli64.bin -r rule --stdout word
Word

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

Примеры Атаки основанной на правилах

Смотрите каталог rules/ в hashcat или oclHashcat для примеров.

Множественные правила

С выходом старенькой oclHashcat-plus v0.07 в мир взлома с использованием правил добавилась новая возможность.

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

Они не выполняются последовательно!

Каждое правило каждого файла с правилами комбинируется с каждым правилом каждого файла с правилами. Таким путём вы можете легко приготовить ваш собственный режим атаки.

Поддержка Атаки основанной на правилах

Эта атака в настоящее время поддерживается в:

• hashcat
• oclHashcat

Ограничения Атаки основанной на правилах

С oclhashcat в настоящее время число функций в одной строке правила или коллективных множественных правил в одной строке ограничено 15 функциями.

Это ограничение вред ли будет изменено, из-за жёстких ограничений GPU.

Табличная атака

Описание Табличной атаки

С каждым словом из нашего словаря автоматически генерируются маски как в пакетном режиме Атаки по маске.

Табличную атаку не нужно путать с Радужными Таблицами.

Ввод

Если наш словарь содержит слово

word1

Оно расщепляется на отдельные символы.

1. w
2. o
3. r
4. d
5. 1

Следующий шаг это «поиск» каждого из этих символов в «Таблице». Просто продолжайте читать…

Обязательная настройка

--table-file

Следующий бокс показывает, что мы зовём «Таблицей». То, что мы настроили здесь, это задания. Как обычно в заданиях, мы имеем левую и правую стороны.

o=o
o=O
o=0
o=.
w=w
1=1
1=2
1=3
1=9

Необязательная настройка

Hashcat имеет два параметра командной строки для тонкой настройки этой атаки. Но почему вообще эта простая атака требует настройки? Причина этого в том, что создаётся так много комбинаций, что они никогда не закончатся.

Например, если у нас в нашем словаре есть длинное слово вроде “111111111111111”, которое имеет длину 15, а таблица содержит…

1=0
1=1
1=2
1=3
1=4
1=5
1=6
1=7
1=8
1=9

…hashcat должна сгенерировать 10^15 (1.000.000.000.000.000) комбинаций.

Следующие команды дают возможность пользователю задать длину пароля, который они хотят модифицировать.

--table-min=ЧИСЛО

По умолчанию установлено в: 2

--table-max=ЧИСЛО

По умолчанию установлено в: 15

И слова за пределами указанной длины будут пропущены.

Вывод

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

word1
wOrd1
w0rd1
w.rd1
word2
wOrd2
w0rd2
w.rd2
word3
wOrd3
w0rd3
w.rd3
word9
wOrd9
w0rd9
w.rd9

Когда использоваться Табличную атаку

Эта атака крайне эффективно в отношении паролей в стиле лит если мы выберем таблицу вроде этой:

a=a
a=@
a=4
c=c
c=<
c=[
c={
e=e
e=3
i=i
i=I
i=!
i=|
i=.

т.д..

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

a=a
a=A
b=b
b=B
c=c
c=C
d=d
d=D

т.д..

Ну лучше всего то, что мы можем делать эти две вещи за один раз.

a=a
a=A
a=@
a=4
b=b
b=B
c=c
c=C
c=<
c=[
c={
d=d
d=D
e=e
e=E
e=3

т.д.

Другая хорошая идея — это заполнить дыры в наших словарях. Например, если наш словарь содержит:

pass0
pass1
pass2
pass3
pass5

Мы можем увидеть, что отсутствуют pass4, pass6 и т. д. Единственная строка в таблице может заполнить пропуски:

0=0
0=1
0=2
0=3
0=4
0=5
0=6
0=7
0=8
0=9

Совет: Для избежания дублей, замените все цифры на 0 и уникализируйте то что слева.

sed -e 's/[0123456789]/0/g' < passes.dict | sort -u > passes_table_optimized.dict

Смотрите каталог table/ для дополнительного вдохновения.

Поддержка Табличной атаки

В настоящий момент эта атака поддерживается в:

• hashcat (v0.36 или выше)

Альтернативная поддержка

Мы можем использовать параметр стандартного вывода в hashcat для передачи по трубе (|) сгенерированных кандидатов в пароли в oclHashcat.

Атака с переключением регистра

Описание атаки с переключением раскладки

Для каждого слова в словаре генерируются все возможные комбинации с буквами верхнего и нижнего регистра.

Эта атака была реализована в качестве отдельной атаки в hashcat. Новая Табличная атака незаметно заменила её в текущих версиях.

Ввод

Если наш словарь содержит слово

pass1234

Вывод

Hashcat создаст следующие кандидаты в пароли

pass1234
Pass1234
pAss1234
PAss1234
paSs1234
PaSs1234
pASs1234
PASs1234
pasS1234
PasS1234
pAsS1234
PAsS1234
paSS1234
PaSS1234
pASS1234
PASS1234

Опциональная настройка

Hashcat имеет два параметра командной строки для тонкой настройки этой атаки. Но почему эта простая атака вообще требует настройки? Причина этого в том, что она может создать так много комбинаций, что они никогда не закончаться. Например, если у нас в нашем словаре есть длинное слово вроде “ThisLongWordInYourDictionaryCreatesLotsOfCombinations”, которое имеет длину 53, hashcat должен сгенерировать 2^53 (9.007.199.254.740.992) комбинации. Можно сократить время работы отбросив значения, которые выходят за рамки требований.

--toggle-min=ЧИСЛО

По умолчанию установлена в: 1

--toggle-max=ЧИСЛО

По умолчанию установлена в: 16

Любое слово за пределами определённой длины будет пропущено.

Оптимизации. Использование правил для эмуляции атаки с переключением раскладки

Большинство всех паролей написано в нижнем регистре. Это тупо. Мощный и простой способ сделать ваш пароль более трудным для взлома — это использовать буквы верхнего регистра. Это означает писать хотя бы два символа вашего пароля в верхнем регистре. Но пометка: не делайте пароли целиком из больших букв. Пробуйте найти баланс между длинной пароля и числом символов в верхнем регистре.

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

Спасибо legion из команды hashcat, который первый нашёл это.

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

Смотрите rules/toggle[12345].rule

В зависимости от имени правила, они включают все возможные переключатели регистра позиций от 1 до 15 или же 1, 2, 3, 4 или 5 символов за раз.

Пример содержимого

На случай если вам ещё нужны подсказки как это работает вот пример содержимого toggle2.rule:

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

Это означает, например, не имеет смысла делать “T1T1”, поскольку это означает отсутствие изменений вовсе.

Другой пример, который лишён смысла, это “T2T4” если мы также делаем “T4T2”, поскольку это дважды одно и то же изменение.

T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
TA
TB
TC
TD
TE
T0T1
T0T2
T0T3
T0T4
T0T5
T0T6
T0T7
T0T8
T0T9
T0TA
T0TB
T0TC
T0TD
T0TE
T1T2
T1T3
T1T4
T1T5
T1T6
T1T7
T1T8
T1T9
T1TA
T1TB
T1TC
T1TD
T1TE
T2T3
T2T4
T2T5
T2T6
T2T7
T2T8
T2T9
T2TA
T2TB
T2TC
T2TD
T2TE
T3T4
T3T5
T3T6
T3T7
T3T8
T3T9
T3TA
T3TB
T3TC
T3TD
T3TE
T4T5
T4T6
T4T7
T4T8
T4T9
T4TA
T4TB
T4TC
T4TD
T4TE
T5T6
T5T7
T5T8
T5T9
T5TA
T5TB
T5TC
T5TD
T5TE
T6T7
T6T8
T6T9
T6TA
T6TB
T6TC
T6TD
T6TE
T7T8
T7T9
T7TA
T7TB
T7TC
T7TD
T7TE
T8T9
T8TA
T8TB
T8TC
T8TD
T8TE
T9TA
T9TB
T9TC
T9TD
T9TE
TATB
TATC
TATD
TATE
TBTC
TBTD
TBTE
TCTD
TCTE
TDTE

Поддержка Атаки с переключением раскладки

Эта атака в настоящее время поддерживается в:

• hashcat

Альтернативная поддержка

Мы можем использовать параметр стандартного вывода в hashcat для передачи по трубе (|) сгенерированных кандидатов в пароли в oclHashcat.