John the ripper инструкция

Как-то у меня появилась необходимость подобрать пароль к пользовательской записи на linux системе, имя пользователя я знал, а вот пароль надо было восстановить старый. Хоть я и имел доступ с правами root’а и мог просто изменить пароль на данного пользователя, но мне стало интересно как можно этот пароль восстановить. После поисков и Интернете и на различных форумах я наткнулся на программку John the Ripper и решил воспользоваться ей.

Итак, согласно википедии:

John The Ripper (JTR)— свободная программа, предназначенная для восстановления паролей по их хешам. Основное назначение программы — аудит слабых паролей в UNIX системах. Программа также может выполнять аудит NTLM хешей, Kerberos, и др. Существуют реализации под различные ОС. Весьма популярна из-за поддержки большого количества хешей, автораспознавания хеша и настраиваемого взломщика. Также поддерживает модули, предоставляющие поддержку MD4 хешей, LDAP и MySQL паролей.

Однако, прежде чем начать разбираться с самим JTR, давайте остановимся на самих паролях в *nix системах.

Немного о паролях.

В Linux пароли шифруются в алгоритме «DES», также есть такая фишка как «salt», это 2е любые буквы, которые являются ключом к паролю, другими словами, с помощью «salt» и шифруется пароль. Подробнее об этом написано в статье «пароли в UNIXе».
Пароли в большинстве случаев хранятся в следующих файлах:

/etc/passwd
/etc/shadow

Хотя могут и лежать в каком-нибудь /etc/shadow.old или /etc/passwd.tmp. Сделав листинг директории /etc/, сразу можно все понять. Просто иногда хитрые админы меняют названия файлов :). passwd файл, это как раз то что нам надо, но в большинстве случаев пароли хранятся в shadow (в тени), в этом случае в passwd видим следующую ситуацию:

root:*:0:0:System Administrator:/root:/bin/csh
rfindd:*:66:1:Rfind Daemon and Fsdump:/var/rfindd:/bin/sh

Внимание! Это на самом деле fake, и никаких паролей здесь нет! А вот если видим такую ситуацию:

root:9IDv/CqdFuqWo:0:0:System Administrator:/root:/bin/csh
john:653MWdpUGN3BM:66:1:John Nikolsen, 2-nd west:/home/john:/bin/sh

То можно заметить, что данный пример более похож на правду. Давайте разберемся на примере с пользователем «john»:

john:653MWdpUGN3BM:66:1:John Nikolsen, 2-nd west:/home/john:/bin/sh

1. john — имя пользователя.
2. 653MWdpUGN3BM — пароль зашифрованный в DES.
3. 66:1 — номер пользователя в системе: номер рабочей группы (у root всегда 0:0).
4. John Nikolsen, 2-nd west — информация о пользователе (обычно Имя, Фамилия…).
5. /home/john — Домашний каталог.
6. /bin/csh — shell.

Во Free BSD пароли хранятся в файле /etc/master.passwd, а в остальном технология такая же как и в LINUX, хотя используется более стойкий алгоритм шифрования MD5. В Open BSD, для шифрования используется алгоритм Blowfish.

Ну а теперь о самом JTR и как им пользоваться.

Режимы.

JTR может работать в следующих режимах:

1. Brute force
2. Перебор по словарю (wordlist mode)
3. Incremental mode
4. Single mode (одиночный режим)

Рассмотрим каждый из режимов подробно.

Brute force:

john passwd

(Я в дальнейшем буду использовать passwd как имя файла с паролями, указанной выше структуры)
Данный способ является самым простым, и не очень эффективным, так как JTR начинает перебирать все символы от фонаря, что конечно очень долго… хотя многое зависит от мощности вашего компьютера и от сложности пароля.

Перебор по словарю (wordlist mode):

john -w:wordlist passwd

где wordfile — имя файла со словарем. Также можно и так:

john -w:wordlist -rules passwd

—rules, включает правила синтаксиса для словаря. С вариантом по словарю, пароли подбираются на много быстрее чем в варианте с «Brute force».

Incremental mode:

john -i passwd

Авторы JTR говорят, что это самый сильный способ перебора, 95 символов. А вот таким способом:

john -i:alpha passwd

JTR перепробует 26 символов, от «a», до «zzzzzzzz». Если с wordlist не получилось, советую запускать данный способ.

Single mode (одиночный режим):

john -single passwd

Рекомендуется начать перебирать пароль с данной опцией. Намного быстрее чем wordlist mode, но рассчитан на хиленькие пароли. При переборе нескольких файлов с данной опцией, возможно подобрать пароли быстрее чем просто 1 passwd файл

Опции.

Теперь давайте рассмотрим несколько полезных опции для JTR. Опции можно запускать в любых режимах:-w, -i, -single.

Перебор для конкретного пользователя:

john -w:wordlist -rules -users:0 passwd

Перебирает пароль к конкретному пользователю (в нашем случае root). Что бы указать пользователя, надо после «:» указать UID (номер пользователя в системе).

Смотрим подобранные пароли.

john -show passwd

Показывает уже подобранные пароли, в указанном файле.

Разбиваем файл на куски.

john -w:wordlist -salts:5 passwd
john -w:wordlist -salts:-5 passwd

Иногда бывает полезно (если есть 2 компьютера). Число «5» это количество «salts» (паролей). JTR будет отчитывать с самого верху. В первом примере (на 1ом компе), берется первые 5 пользователей, во втором примере «-5» (на 2ом компе), перебираются все, кроме 5и первых.

Люблю shells

.

john -w:wordlist -rules -shells:sh,csh,tcsh,bash passwd

В данном случае, будут перебираться только те пользователи, которые имеют указанные в вышеприведенном примере shell’ы(оболочки).

Несколько passwd файлов.

Если у вас есть несколько файлов с паролями в DES, то их можно всех вместе поставить на расшифровку данным способом:

john -single passwd passwd1 passwd2

Количество файлов по-моему не ограничено :). Способ с несколькими файлами, работает на всех режимах и опциях, просто укажите имена файлов в конце (как в примере).

Unshadow files.

unshadow passwd shadow

Если у вас пароли в shadow, то данной командой, их можно восстановить (требует shadow файл).

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

Оглавление

1. Знакомство и установка John the Ripper

2. Утилиты для извлечения хешей

3. Как запустить взлом паролей в John the Ripper (как указать маски, словари, хеши, форматы, режимы)

4. Практика и примеры использования John the Ripper

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

5.1 Что такое Атака на основе правил в John the Ripper

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

5.3 Правила John the Ripper, совместимые с Hashcat

5.4 Флаги отклонения правил

5.5 Команды управления длиной

5.6 Команды грамматики английского языка

5.7 Команды конверсии наборов символов

5.8 Команды доступа к памяти

5.9 Числовые команды

5.10 Класс символов и команды подобия

5.11 Классы символов

5.12 Числовые константы и переменные

5.13 Строковые команды

5.14 Команды с произвольными символами

5.15 Препроцессор правил

5.16 Практические примеры атаки на основе правил в John

5.16.1 Добавление произвольных символов в произвольные места

5.16.2 Добавление произвольных символов в произвольные места и замена символов в пароле на произвольные

5.16.3 Отбор паролей, соответствующих определённой политике

5.16.4 На клавиатуре пользователя сломана кнопка

5.16.5 Пользователь заменяет символы

5.17 Важно помнить

6. Брут-форс нестандартных хешей

7.

8.

Что такое Атака на основе правил в John the Ripper

Атака на основе правил — это модификация словарей на высоком уровне, когда они создаются и изменяются не только с помощью добавления новых символов, но и таких недоступным с помощью масок действий как:

• замена регистра всех или отдельных букв как в указанных позициях, так и в любых местах
• перевод всего слова в верхний или нижний регистр
• переключение регистра на противоположный
• удвоение и любое количество повторений слова
• обратный порядок слова
• обрезка слова
• удаление определённого диапазона символов
• замена определённых символов
• повторение, удаление или перезапись любых символов
• удаление слов, не удовлетворяющих указанным критериям (наличию или отсутствию символов или наборов символов; повторению символа или набора символов определённое количество раз, недостаточная или избыточная длина и прочее)

То есть правила позволяют изменять, создавать новые пароли, а также отклонять кандидаты в пароли по определённым многочисленным критериям.

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

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

Атака на основе правил есть и в Hashcat (будет статья!). Если вы уже освоили Атаку на основе правил в Hashcat, то там нужно создавать файлы с правилами и указывать их с помощью опций. У John the Ripper тоже есть опция —rules и инстинктивно можно попробовать подставить туда файл с правилами, но это не сработает. Все правила нужно указывать в конфигурационном файле. Большая статья по конфигурации и оставшимся опциям John уже на подходе, пока просто отмечу, что конфигурационный файл в операционной системе Linux называется john.conf. Если вы установили John the Ripper из исходного кода, то этот файл находится в той же папке, что и исполнимый файл john. Если вы установили из стандартного репозитория вашего дистрибутива, то этот файл находится в папке /etc/john/john.conf, а также продублирован в /usr/share/john/john.conf. Файл также может находиться в текущей рабочей директории или во всех местах сразу. Файлы не дополняют друг друга — последний загруженный файл перезаписывает предыдущие. В Windows файл называется john.ini.

Чтобы понять, что нет ничего страшного в этих правилах, начнём с быстрой демонстрации.

Итак, если у вас Linux, то откройте файл /usr/share/john/john.conf:

sudo gedit /usr/share/john/john.conf

Ближе к концу добавьте туда следующие строки:

[List.Rules:Toggle]
T0
T1
T2
T0T1
T1T2
T0T2
T0T1T2

[List.Rules:Double]
d
p5

[List.Rules:Reflect]
f

[List.Rules:Reverse]
r

В этих строках мы установили четыре набора правил, они называются Toggle (меняет регистр одной из трёх первых букв, затем двух из трёх первых, а затем всех трёх первых букв), Double (удваивает слово, а также записывает слово 5 раз подряд), Reflect (отражает содержимое слова и добавляет к имеющемуся), Reverse (перезаписывает слово задом наперёд). Значение всех букв и цифр мы ещё разберём, но вы могли уже и догадаться что они означают в правилах выше. Названия правил взяты произвольно, можно выбрать любые.

Сохраните конфигурационный файл.

Создайте файл passwords.txt с паролями для тестов, пример моего файла:

craig666
Craig688

Теперь john нужно запускать с опциями:

• —rules — после неё указывается название набора применяемых правил
• —wordlist — путь до словаря
• —stdout — просто означает выводить созданные пароли в стандартный вывод

Запускаем первую команду:

john --rules=Toggle --wordlist=passwords.txt --stdout

Получаем:

Craig666
craig688
cRaig666
CRaig688
crAig666
CrAig688
CRaig666
cRaig688
cRAig666
CRAig688
CrAig666
crAig688
CRAig666
cRAig688

Пробуем второй набор правил:

john --rules=Double --wordlist=passwords.txt --stdout

Получаем:

craig666craig666
Craig688Craig688
craig666craig666craig666craig666craig666craig666
Craig688Craig688Craig688Craig688Craig688Craig688

Третий набор:

john --rules=Reflect --wordlist=passwords.txt --stdout

Вывод:

craig666666giarc
Craig688886giarC

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

john --rules=Reverse --wordlist=passwords.txt --stdout

Получаем:

666giarc
886giarC

Картинка с сайта: web.archive.org

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

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

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

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

Например,

T0
T1
T2

Это три правила, они меняют регистр в первом, втором и третьем символах слова и затем сохранят все три варианта. То есть из одного слова получается ещё три модификации и каждая из них сохраняется.

А правило

T0T1T2

точно также меняет регистр в первом, втором и третьем символах слова, но сохраняет только одно результирующее слово.

Можно сочетать в одном наборе правил строки из одного правила и строки из множества правил.

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

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

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

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

Правила John the Ripper, совместимые с Hashcat

Следующие функции на 100% совместимы с Hashcat (кроме WN).

WN — это надмножество TN. В то время как TN переключает только регистр букв алфавита, например. «a» ↔ «A», команда WN также будет переключать с помощью Shift. Это похоже на использование Shift (или её отключение) на клавиатуре США, например. «1» ↔ «!».

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

Флаги отклонения правил

Команды управления длиной

Команды грамматики английского языка

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

ПРИМЕЧАНИЕ, из них только S и V поддерживают кодировки.

Команды доступа к памяти

Если «Q» или «X» используются без предшествующей «M», они читаются с начального «слова». Другими словами, вы можете предположить, что в начале каждого правила подразумевается «M», и нет необходимости когда-либо начинать правило с «M» («M» не несёт действия). Единственное разумное использование «M» — это середина правила, после того как некоторые команды, возможно, изменили слово.

Предполагаемое использование команды «Q» — помочь избежать дублирования паролей-кандидатов, которые могут возникнуть из-за нескольких схожих правил. Например, если у вас есть правило «l» (нижний регистр) где-то в вашем наборе правил, и вы хотите добавить правило «lr» (нижний регистр и обратный порядок символов), вы можете вместо этого записать последнее как «lMrQ», чтобы избежать дублирования возможных пароли для палиндромов.

Команда «X» извлекает подстроку из памяти (или из начального слова, если «M» никогда не использовалось), начиная с позиции N (в запомненном или начальном слове) и продолжая до M символов. Он вставляет подстроку в текущее слово в позиции I. Целевая позиция может быть «z» для добавления подстроки, «0» чтобы поставить её перед словом, или это может быть любая другая допустимая числовая константа или переменная. В некоторых примерах использования, предполагая, что мы находимся в начале правила или после буквы «M», будет «X011» (дублировать первый символ), «Xm1z» (дублировать последний символ), «dX0zz» (трижды повторить слово), «<4X011X113X215» (дублировать каждый символ в коротком слове), «>9x5zX05z» (повернуть длинные слова налево на 5 символов, аналогично «>9vam4Xa50’l» (повернуть вправо на 5 символов, то же самое, что и «>9}}}}}»).

Числовые команды

«l» устанавливается равным текущей длине слова, и его новое значение может использоваться этой же командой (если N или/и M также равно «l»).

V должен быть от «a» до «k». N и M могут быть любыми допустимыми числовыми константами или инициализированными переменными. Можно ссылаться на одну и ту же переменную в одной команде более одного раза, даже три раза. Например, «va00» и «vaaa» оба установят переменную «a» в ноль (но для последнего потребуется, чтобы «a» была предварительно инициализирована), тогда как «vil2» установит для переменной «i» текущее значение длины слова минус 2. Если «i» затем используется в качестве позиции символа перед дальнейшим изменением слова, оно будет относиться ко второму символу с конца. Нормально, чтобы промежуточные значения переменных становились отрицательными, но такие значения не должны использоваться напрямую как позиции или длины. Например, если мы последуем нашему «vil2» где-нибудь позже в том же правиле с «vj02vjij», мы установим «j» равным «i» плюс 2, или длину слова на момент обработки командой «vil2» ранее в правиле.

Класс символов и команды подобия

ПРИМЕЧАНИЕ. Смотрите правило «E» для hashcat, которое устанавливает общий регистр для заголовков с пробелами. Правило «е» также посвящено этому.

Обратите внимание, что U принимает простой ASCII. Он будет отклонять только слова, которые содержат 8-битные символы, но не могут быть проанализированы как UTF-8. Его можно использовать для отклонения неверных входных слов или для отклонения неверных выходных слов после применения других команд.

Классы символов

Дополнение к классу можно указать, набрав его имя в верхнем регистре. Например, «?D» соответствует всему, кроме цифр.

Если вы скомпилировали John с поддержкой кодировок, соответствующие национальные символы добавляются в соответствующие классы. Таким образом, в режиме ISO-8859-1 обозначение ?l будет включать àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþßÿ, тогда как в режиме ASCII это только a-z.

Числовые константы и переменные

Можно указывать числовые константы и ссылаться на переменные с помощью следующих символов:

Здесь min/max_length — это минимальная/максимальная длина пароля, поддерживаемая для текущего типа хэша (возможно, переопределена параметрами —min/max-len).

Они могут использоваться для указания позиций символов, длины подстроки и других числовых параметров для правил команд, соответствующих данной команде. Позиции символов нумеруются, начиная с 0. Так, например, начальное значение «m» (позиция последнего символа) на единицу меньше, чем «l» (длина).

Строковые команды

Чтобы добавить строку в конце слова, укажите позицию «z». Чтобы строку поставить перед словом, укажите в качестве позиции «0».

Хотя использование символа двойных кавычек удобно для чтения, вы можете использовать любой другой символ, не найденный в STR. Это особенно полезно, когда STR содержит символ двойной кавычки. Невозможно экранировать символ кавычки в строке (не позволяя ему закончить строку и команду), но вы можете добиться того же эффекта, указав несколько команд одну за другой. Например, если вы решили использовать косую черту в качестве символа кавычки, но, тем не менее, он встречается в строке, и вы не хотите пересматривать свой выбор, вы можете написать «Az/yes/$/Az/no/», который добавит строку «yes/no». Конечно, проще и эффективнее использовать, скажем, «Az,yes/no,» для того же эффекта.

Команды с произвольными символами

Можно использовать любой 8-битный символ внутри Ax»str», а $c или ^c или в настройках препроцессора $[c…] или ^[c…]. Метод, используемый в john, похож на создание произвольного символа в языке C. Это синтаксис \xhh, где hh — это 2 шестнадцатеричных символа. Итак, Az»\x1b[2J» добавит тогда escape-последовательность ansi, чтобы очистить экран до конца текущего пароля. Или что-то вроде $\x0a добавит символ новой строки в конец слова. Эти экранированные символы также правильно работают во всех командах классов символов.

Препроцессор правил

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

С препроцессором вы можете сделать это проще. Просто напишите одну исходную строку, содержащую общую часть этих правил, за которой следует список символов, которые вы бы поместили в отдельные правила, в квадратных скобках (как вы это делаете в регулярном выражении). Затем препроцессор сгенерирует для вас правила (при запуске John для проверки синтаксиса и ещё раз при взломе, но никогда не сохранит все расширенные правила в памяти). В приведённых выше примерах исходными строками будут «l$[0-9]» (нижний регистр и добавление цифры) и «l$[0-9]$[0-9]» (нижний регистр и добавление двух цифр). Эти исходные строки будут расширены до 10 и 100 правил соответственно. Между прочим, команды препроцессора обрабатываются справа налево, а списки символов обрабатываются слева направо, что приводит к естественному порядку чисел в приведённых выше примерах и в других типичных случаях. Обратите внимание, что допустимы произвольные комбинации диапазонов символов и списков символов. Например, «[aeiou]» будет использовать гласные, тогда как «[aeiou0-9]» будет использовать гласные и цифры. Если вам нужно, чтобы John попробовал гласные, за которыми следуют все другие буквы, вы можете использовать «[aeioua-z]» — препроцессор достаточно умён, чтобы не создавать повторяющиеся правила в таких случаях (хотя это поведение можно отключить с помощью «\r», магической escape-последовательности, описанная ниже).

В правилах есть некоторые специальные символы («[» запускает список символов препроцессора, «—» отмечает диапазон внутри списка и т. д.). Вы должны поставить перед ними обратную косую черту («\»), если вы хотите поместить их внутри правила без использования их особого значения. Конечно, то же самое относится и к самому символу «\«. Кроме того, если вам нужно запустить список символов препроцессора в самом начале строки, вам нужно будет поставить перед ним префикс «:» (команда правила no-op), иначе он будет рассматриваться как начало нового раздела.

Наконец, препроцессор поддерживает некоторые магические escape-последовательности. Они начинаются с обратной косой черты и используют символы, которые обычно не нужно экранировать. В следующем абзаце, описывающем экранирование, слово «диапазон» относится к одному экземпляру комбинации списков символов и/или диапазонов, помещённых в квадратные скобки, как показано выше.

В настоящее время поддерживаются обозначения от «\1» до «\9» для обратных ссылок на предыдущие диапазоны (с диапазонами, пронумерованными от 1, слева направо, они будут заменены тем же символом, который в настоящее время найден ссылающимся диапазоном), «\0» для обратной ссылки на непосредственно предшествующий диапазон, «\p» перед диапазоном, чтобы этот диапазон обрабатывался «параллельно» со всеми предыдущими диапазонами, от «\p1» до «\p9» для обработки диапазона «параллельно» с конкретным указанным диапазоном, «\p0», чтобы диапазон обрабатывался «параллельно» с непосредственно предшествующим диапазоном, и «\r», чтобы позволить диапазону воспроизводить повторяющиеся символы. Последовательность «\r» полезна только в том случае, если диапазон «параллелен» другому или если есть хотя бы один другой диапазон, «параллельный» этому, потому что вы не должны фактически создавать повторяющиеся правила. Также экранирование \xhh корректно работает в препроцессоре, чтобы разрешить любой символ. Правило предварительной обработки [\x01-\xff] будет заменено 255 символами (отсутствует нулевой байт, который не может быть обработан JtR).

Практические примеры атаки на основе правил в John

1. Добавление произвольных символов в произвольные места

Предположим, пользователь шифровал файлы одним и тем же паролем, допустим это «long_password», но в какой-то момент решил усложнить пароль и добавил в него несколько символов (от 1 до 3). Пользователь помнит, что это какие-то строчные буквы, но какие именно и в какие места пароля он их добавил — не помнит.

Задача: составить правила модификации пароля на основе указанных условий.

Воспользуемся функцией «iNX», которая вставляет символ X в позицию N.

Правило, которое добавляет маленькие буквы ([a-z]) в позиции от 0 до 13-ой:

i[0-9A-D][a-z]

Последней выбрана 13 позиция, поскольку в слове long_password всего 13 букв. Нулевая позиция — это перед словом, тринадцатая позиция — это после пароля.

В отличие от Hashcat, John the Ripper поддерживает диапазоны, поэтому символы для вставки указаны как диапазон — [a-z].

Позиции для вставки символов также указаны как диапазон — [0-9A-D]. В ней «0-9» означает вставить в позицию от 0 до 9. А «A-D» означает вставить в позицию от 10-ой до 13-ой.

Предыдущее правило вставляет только одну букву. Для вставки двух любых маленьких букв в любое место слова используется следующее правило:

i[0-9A-D][a-z] i[0-9A-D][a-z]

Оно получено из предыдущего простым удвоением записи.

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

i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z]

Итак, добавляем в файл /usr/share/john/john.conf

sudo gedit /usr/share/john/john.conf

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

[List.Rules:Add3SmallLet]
i[0-9A-D][a-z]
i[0-9A-D][a-z] i[0-9A-D][a-z]
i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z]

Сохраним исходный пароль «long_password» в файл passwords.txt.

Написанный набор правил назван Add3SmallLet, наш исходный пароль помещён в файл passwords.txt, тогда команда для просмотра сгенерированных на основе правил паролей следующая:

john --rules=Add3SmallLet --wordlist=passwords.txt --stdout

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

john --rules=Add3SmallLet --wordlist=passwords.txt --stdout | sort | uniq

2. Добавление произвольных символов в произвольные места и замена символов в пароле на произвольные

Предположим, пользователь шифровал файлы одним и тем же паролем, допустим это «long_password», но в какой-то момент решил усложнить пароль и добавил в него несколько символов (от 1 до 3), а также решил заменить некоторые символы на цифры. Пользователь помнит, что он добавил какие-то строчные буквы, но какие именно и в какие места пароля он их добавил — не помнит. Также пользователь помнит, что заменил на цифры в пароле не более двух символов, возможно, что ни одного символа.

Задача: составить правила модификации пароля на основе указанных условий.

Воспользуемся уже рассмотренной функцией «iNX», которая вставляет символ X в позицию N.

Также воспользуемся функцией «oNX», которая перезаписывает символ в позиции N на X.

Для выполнения первой части условия (добавление 1-3 маленьких букв в произвольные места), воспользуемся правилами, составленными в предыдущей части.

i[0-9A-D][a-z]
i[0-9A-D][a-z] i[0-9A-D][a-z]
i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z]

Правило, для замены одного символа в позициях от 0 до 13 на любую цифру следующее:

o[0-9A-D][0-9]

Для замены двух цифр, то есть для применения одного правила дважды, записываем полученное правило два раза:

o[0-9A-D][0-9] o[0-9A-D][0-9]

По условиям задачи, замена символов сопутствует добавлению символов или отсутствует вовсе.

Тогда набор правил для записи в файл /usr/share/john/john.conf следующий:

[List.Rules:AddAndReplace]
i[0-9A-D][a-z] # добавление одной буквы
i[0-9A-D][a-z] i[0-9A-D][a-z] # добавление двух букв
i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z] # добавление трёх букв
i[0-9A-D][a-z] o[0-9A-D][0-9] # добавление одной буквы и замена одного символа на цифру
i[0-9A-D][a-z] i[0-9A-D][a-z] o[0-9A-D][0-9] # добавление двух букв и замена одного символа на цифру
i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z] o[0-9A-D][0-9] # добавление трёх букв и замена одного символа на цифру
i[0-9A-D][a-z] o[0-9A-D][0-9] o[0-9A-D][0-9] # добавление одной буквы и замена двух символов на цифры
i[0-9A-D][a-z] i[0-9A-D][a-z] o[0-9A-D][0-9] o[0-9A-D][0-9] # добавление двух букв и замена двух символов на цифры
i[0-9A-D][a-z] i[0-9A-D][a-z] i[0-9A-D][a-z] o[0-9A-D][0-9] o[0-9A-D][0-9] # добавление трёх букв и замена двух символов на цифры

Сохраним исходный пароль «long_password» в файл passwords.txt.

Написанный набор правил назван AddAndReplace, наш исходный пароль помещён в файл passwords.txt, тогда команда для просмотра сгенерированных на основе правил паролей следующая:

john --rules=AddAndReplace --wordlist=passwords.txt --stdout

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

john --rules=AddAndReplace --wordlist=passwords.txt --stdout | sort | uniq

3. Отбор паролей, соответствующих определённой политике

Известно, что в организации установлена следующая политика требований к паролям: в пароле должны быть как минимум одна большая буква; как минимум одна маленькая буква; как минимум одна цифра и как минимум один специальный символ. Длина пароля не может быть меньше 8 символов.

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

Для этого нам понадобится два правила:

• /?C — означает отклонить слово, если оно не содержит символа в классе C.
• >N — означает отклонить слово, если оно не превышает N символов

Обратимся к таблице «Классы символов».

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

/?l /?u /?d /?p

Поскольку в паролях могут быть другие специальные символы, то нужно составить ещё один набор правил:

/?l /?u /?d /?s

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

Внутри одной строки действует логическое «И», то есть будут отбросаны все пароли, в которых отсутствует хотя бы один класс символов.

Но между строками действует логическое «ИЛИ», то есть будут пропущены все пароли, которые соответствует критериям первой строки или критериям второй строки.

Также добавим правило, удаляющее слова, короче восьми символов, получаем:

/?l /?u /?d /?p >7
/?l /?u /?d /?s >7

В файл /usr/share/john/john.conf добавим следующие строки (набор правил назван StrongPass):

[List.Rules:StrongPass]
/?l /?u /?d /?p >7
/?l /?u /?d /?s >7

Для проверки их работоспособности, скачаем словарь:

wget -U 'Chrome' https://kali.tools/files/passwords/leaked_passwords/rockyou.txt.bz2
7z e rockyou.txt.bz2

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

cat rockyou.txt | wc -l
14344391

То есть в файле 14.344.391 (четырнадцать миллионов) паролей.

А теперь проверим, сколько паролей будет отфильтровано:

john --rules=StrongPass --wordlist=rockyou.txt --stdout | wc -l

Вывод:

Using default input encoding: UTF-8
Press 'q' or Ctrl-C to abort, almost any other key for status
50785p 0:00:00:01 100,00% (2020-11-29 17:08) 35764p/s *7¡Vamos!
50785

Осталось всего 50785 кандидатов в пароли, подходящие под указанные условия! Это 50785÷14344391×100 = 0,35% от всего словаря!!! То есть если бы мы не использовали эту оптимизацию, 99,65% вычислений во время брут-форса были бы бессмысленными, поскольку проверяли бы заведомо неподходящие пароли.

4. На клавиатуре пользователя сломана кнопка

Известно, что от частой игры на компьютере у пользователя сломаны кнопки «a», «s», «d», «w». По этой причине пользователь при вводе паролей никогда не использует эти буквы.

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

Для выполнения указанного условия нам понадобится два правила:

• !X — означает отклонить слово, если оно содержит символ X
• @X — означает удалить все символы X из слова

Набор правил, который отклоняет все слова, если они содержат любой из указанных символов:

!a !s !d !w !A !S !D !W

Набор правил, который разрешает все слова, но удаляет из них указанные символы:

@a @s @d @w @A @S @D @W

Эти правила НЕ нужно использовать вместе, поскольку они создадут много дубликатов (подмножество кандидатов в пароли второго правила полностью включает в себя подмножество кандидатов в пароли первого правила).

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

5. Пользователь заменяет символы

Известно, что при вводе слов пользователь всегда заменяет символ I на 1, O на 0, а символ S на $.

Задача: изменить словарь таким образом, чтобы в нём была произведена замена указанных символов.

Для решения этой задачи нам понадобится одно правило:

• sXY — означает заменить все символы X в слове на Y

Набор правил, который делает замену трёх указанных символов:

sI1 sO0 sS$

В файл /usr/share/john/john.conf добавим следующие строки (набор правил назван Replace):

[List.Rules:Replace]
sI1 sO0 sS$

Теперь мы можем убедиться, что во всех новых словах отсутствуют буквы I, O и S (заменены на 1, 0 и $):

john --rules=Replace --wordlist=rockyou.txt --stdout | grep -E 'I|O|S'

Вывод будет пустым, поскольку не будет найдено ни одного слова с I, O и S.

Важно помнить

Правила, которые создают новые слова (за счёт изменение регистра букв, добавления символов), обычно склонны генерировать дубликаты, особенно если используется несколько однотипных правил. Если вы создаёте словарь, то используйте для фильтрации дубликатов конструкцию «ВЫВОД john | sort | uniq > СЛОВАРЬ.txt».

Perhaps you need a quick overview on how to use the password-cracking tool John the Ripper, or you may be a beginner and wondering why you haven’t been able to get it to work. If that’s you, you’ve come to the right place. We’ve prepared a straightforward tutorial on how to use John the Ripper for you.

A must-have in the pentester’s toolkit, John the Ripper cracks passwords using a rainbow table approach: comparing them with an inbuilt table of hashes. We’ll review John the Ripper’s three major password-cracking modes and several usage examples, with short exercises for those new to this ruthless tool.

But be warned: We don’t condone using John the Ripper for malicious purposes. With great power comes great responsibility.

Without further ado, let’s get cracking.

What Is John the Ripper?

Jack the Ripper was a murderer in 1888 in London, England. Just as people exposed to Jack the Ripper died, passwords exposed to John the Ripper are no longer secret.

You can deploy John the Ripper inside Kali Linux with the following terminal command instantly:

john

Hence, for simplicity, we’ll call John the Ripper “John” from this point onward. John’s various options help you customize your experience uncovering passwords:

john -h

Modes for Cracking Passwords

John the Ripper offers three main password-cracking modes: Single, Wordlist, and Incremental.

Single Crack Mode

Our example here is a username-password pair based on the 1986 Tom Cruise movie, which released its sequel in 2022.

In Single Crack Mode, John takes a string and generates variations of that string to generate a set of passwords. For example, you can use this Mode to generate password variations of the username “topgun” with the corresponding password “Topgun” (or TopGun, ToPgUn, tOpGuN, and so on).

Use the --format flag to specify the hash type and the --single (-si) flag to let John know we want to use the Single Crack Mode.

Afterward, we’ll crack more complex passwords with John’s Wordlist Mode.

Картинка с сайта: www.stationx.net

Try this exercise

1. Designate a short string (topgun) as a username and variations on its capitalization as the password (such as Topgun).
2. Show the output of the SHA-256-hashed password: echo -n 'Topgun' | sha256sum
3. Create a new text file (simple.txt) to store the username and the password hash value from prior steps: echo -n 'topgun:4558ce5abe3b1e70bbadc3b95f2ff84f54d0a5c30fb524ceebfd401f8233fda7' > simple.txt
4. Run simple.txt through John the Ripper’s Single Crack Mode (change the --format argument as you see fit): john --single --format=raw-sha256 simple.txt
5. Get results.

Картинка с сайта: www.stationx.net

A self-contained tutorial on generating a password for Single Crack Mode

Oops: If you hash your desired password with the following wrong command instead, you’ll hash an unintended line break at the end:

echo Topgun | sha256sum # wrong command

Wordlist Mode

In Wordlist Mode, we’ll provide John with a list of passwords. John will generate hashes for them in real-time and compare them with our password hash. In this example, we will use the well-known RockYou wordlist, which you can preview at

cat /usr/share/wordlists/rockyou.txt | less

Feel free to copy it to your current working directory to simplify the commands using the --wordlist (-w) flag:

cp /usr/share/wordlists/rockyou.txt rockyou

Now let’s pass text files containing password hashes through John:

Картинка с сайта: www.stationx.net

Try this exercise

1. Pipe a hash based on one or more dictionary words (optionally with numbers) to SHA-256: echo -n 'password1234' | sha256sum
2. Write your username, a colon (:), and the hash as a single long string into a new text file (crack.txt): echo user01:b9c950640e1b3740e98acb93e669c65766f6670dd1609ba91ff41052ba48c6f3>>crack.txt
3. Repeat Steps 1 and 2 to generate as many username-password pairs as desired and append them to crack.txt.
4. Run crack.txt through John the Ripper’s Wordlist Mode: john --wordlist=rockyou --format=raw-sha256 crack.txt
5. Get results.

Картинка с сайта: www.stationx.net

Left: John the Ripper Wordlist Mode in action

Right: Generating hashes for three simple passwords

John finds these three passwords rapidly. The weaker the password is, the faster John cracks them.

Let’s move on to John’s final Incremental Mode.

Incremental Mode

In Incremental Mode, John tries all possible character combinations as passwords. This process can be time-consuming if the password is too long or if alphanumeric characters and symbols comprise the password.

You won’t use this Mode unless you don’t have any other options. Typically, a combination of social engineering attacks and Wordlist Mode will help you uncover most passwords.

The syntax for Incremental Mode is:

Let’s break down each flag:

Картинка с сайта: www.stationx.net

Try this exercise

1. Pipe a hash on a simple alphanumeric password to SHA-256: echo -n 'passw0rd' | sha256sum
2. Write your username, a colon (:), and the hash as a single long string into a new text file (inc.txt): echo user02:8f0e2f76e22b43e2855189877e7dc1e1e7d98c226c95db247cd1d547928334a9>>inc.txt
3. Run inc.txt through John the Ripper’s Wordlist Mode: john --incremental --format=raw-sha256 inc.txt
4. Get results.

Картинка с сайта: www.stationx.net

Generated password hashes

Картинка с сайта: www.stationx.net

Cracking password hashes in Incremental Mode

Now that we know how to use John the Ripper, we shall move on to specific use cases.

Cracking Passwords With John the Ripper

Now that we know the different modes, let’s examine some real-world examples of when and how to crack passwords with John.

Choosing a Wordlist

John’s default Wordlist is a file located in /usr/share/john/password.lst in Kali Linux, but its power is finite compared with custom wordlists such as those found by John’s developer OpenWall https://www.openwall.com/wordlists/. 

Apart from RockYou, the Wordlists all.lst (downloadable as all.gz) and huge.lst are good candidates for the --wordlist flag.

Edit the Wordlist by amending the following line in /usr/share/john/john.conf:

Wordlist = $JOHN/password.lst

To make John work more efficiently, remove duplicate entries from and sort the contents of your chosen Wordlist file.

Cracking ZIP files

John has a utility called zip2john. zip2john helps us to get the hash from zip files. Other “2john” utilities exist, such as the rar2john utility for cracking a RAR file.

To crack a password-protected ZIP file, we first get the hash of the ZIP file’s password:

zip2john file.zip > zip.hashes

This command gets the hash from the ZIP file and stores it in the zip.hashes file.

Now you can crack the hash with John:

Картинка с сайта: www.stationx.net

Try this exercise

1. Create a password-protected ZIP archive (classified.zip) on Kali Linux: right click on a file/folder, select “Create Archive…”, choose “ZIP” as the compression method, expand “Other options” to give it a weak password, and click “Create.”
2. Export the ZIP hash to zip.hashes: zip2john classified.zip > zip.hashes
3. Run zip.hashes through John the Ripper: john zip.hashes
4. Get results.

Step 1: Create a password-protected ZIP archive on Kali Linux

Картинка с сайта: www.stationx.net

Steps 2 to 4: zip2john followed by John the Ripper usage

Картинка с сайта: www.stationx.net

Cracking SSH Keys

The ssh2john utility creates a hash from your private key file. If your private key file path is /home/kali/.ssh/id_rsa, and you want to store the hash as myHash.txt, the syntax is:

ssh2john /home/kali/.ssh/id_rsa > myHash.txt

Картинка с сайта: www.stationx.net

Картинка с сайта: www.stationx.net

Try this exercise

1. Use the following command to generate an RSA key pair with a passphrase: ssh-keygen
2. Export the hashed private key file to a new file (myHash.txt): ssh2john /home/kali/.ssh/id_rsa > myHash.txt
3. Run myHash.txt through John the Ripper: john --wordlist=rockyou myHash.txt
4. Get results

Step 1: Demo of ssh-keygen

Картинка с сайта: www.stationx.net

Cracking Linux Passwords

Linux stores password data in two files:

• /etc/passwd stores information such as username, user id, and login shell;
• /etc/shadow is the password file containing data such as hash and expiry date.

A utility bundled with John the Ripper called unshadow can combine both files for cracking. Here, we’ll name the combined file lin.txt:

unshadow /etc/passwd /etc/shadow > lin.txt

Картинка с сайта: www.stationx.net

Cracking Linux hashes is tricky; Kali Linux’s John the Ripper doesn’t readily detect the hash type of Linux (crypt), where the --wordlist flag is optional. If you omit the --format flag below, John won’t crack anything at all:

Once John has uncovered the passwords, you may view them using the command below:

john --show --format=crypt lin.txt

Картинка с сайта: www.stationx.net

Try this exercise

1. Create a new user on Kali Linux: sudo useradd user1
2. Give the new user a weak password: sudo passwd user1
3. Repeat steps 1 and 2 as desired to create two more new user accounts user2 and user3 with weak passwords.
4. Unshadow the Linux password hashes for all users: unshadow /etc/passwd /etc/shadow > lin.txt
5. Export only the usernames and passwords of the three new users to a new file (lin3.txt): tail -n -3 lin.txt > lin3.txt
6. Run it through John the Ripper: john --format=crypt --wordlist=rockyou lin3.txt
7. Get results.

Картинка с сайта: www.stationx.net

Cracking Windows Passwords

Windows stores hashed passwords in the SAM database. SAM uses the LM/NTLM hash format for passwords. As getting passwords from the SAM database is beyond the scope of this article, we suggest generating your own LM/NTLM hashes to test out this functionality and echo them to a text file, say win.txt, as shown in the demonstration:

The syntax for cracking this file containing the LM/NTLM hashes is the following, where the --wordlist flag is optional:

john --format=LM [--wordlist=rockyou] win.txt

Once John has uncovered the passwords, you may view them using the command below:

john --show --format=LM win.txt

Картинка с сайта: www.stationx.net

Try this exercise

1. Designate a short string (topgun) as a username and variations on its capitalization as the password (such as Topgun).
2. Pass the password from step 1 into an LM/NTLM hash function, such as via a website as shown below.
3. Create a new text file (ntlm.txt) to store the username and the password hash value from prior steps: echo -n 'topgun::0BA224CF1C751F31AAD3B435B51404EE:D66B0428599B168372A76C8AB73A76A2:::' > ntlm.txt
4. Run ntlm.txt through John the Ripper’s Single Crack Mode (change the --format argument as you see fit): john --format=LM --single ntlm.txt
5. Get results. The capitalization of the cracked password may differ from what you’ve intended.

Step 2:

Картинка с сайта: www.stationx.net

Step 3 and 4:

Картинка с сайта: www.stationx.net

Choosing Specific Hashes to Crack

If you want to override John’s behavior of discovering the hash independently, you may tell John which hash type you’re looking for using the --format=HASH_TYPE flag. Choices for HASH_TYPE include Raw-MD (MD5), Raw-SHA1 (SHA-1), Raw-SHA256 (SHA-256), SSH, RADIUS, TACACS-Plus (TACACS+), ZIP, and RAR.

You can find all hash formats John supports using the following commands:

Other Useful Commands

Here is a brief cheat sheet of John the Ripper commands:

Find the complete official documentation for John the Ripper here.

Conclusion

We hope learning how to use John the Ripper helps you, whether you’re exploring cyber security or aiming to become a professional hacker or penetration tester. For more resources, read our blog posts on hacking, join the StationX Master’s Program, and check out our courses below:

Frequently Asked Questions

Password crackers are essential tools in any pen tester’s toolbox. This step-by-step tutorial explains how to use John the Ripper, an open source offline password-cracking tool.