• Открыта запись на вторую часть курса по анонимности и безопасности в сети интернет "Paranoid II" от команды codeby. Анонимные роутеры, Подъём, настройка и администрирование Tor-ноды, Работа с железом ПК, Удаление аппаратных закладок, Минимизация рисков, Авторские разработки и многое другое. Подробнее ...

John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

Приступать ли мне к работе по масштабному пособию JTR-2019?

  • ДА!

  • Нет

  • Я сам разберусь с функционалом JTR, а история и "плюшки" мне не интересны

  • Ты опоздал парень, я берусь/взялся за данный материал

  • Делай руководство, только для премиум-раздела


Результаты видны после голосования.
A

am29f010b

John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)


В мае 2019г. произошло еще не одно знаменательное событие в области ИБ: выход в свет обновлённого Профессионального инструмента взломщика паролей под либеральной лицензией - John the Ripper 1.9.0-jumbo-1. Предыдущая версия легендарного ПО John the Ripper 1.8.0-jumbo-1 выходила в декабре 2014г.

В GNU/Kali/Parrot этот инструмент не обновлялся с 2015г. по заморозь 2018г. Осенью 2018г. я делал запрос на форумы обоих ОС: "почему профессиональный крэкерский инструмент не обновляется (так как "половину функций" работали некорректно в старых сборках)"? Спустя пару недель, JTR одновременно обновили в обоих ОС, да это был успех, но я не рекомендую пользоваться Джоном в этих ОС по следующим причинам: это просто пи....; ранее сборка была компилирована лишь под одно ядро CPU; часть подинструментов JTR растеряна (с помощью которых извлекался хэш из нужного формата для взлома), а некоторые подинструменты и функции JTR все еще имеют баги, например, wpapcap2john (извлекает неверный хэш из pcap файла для JTR препроцессора).
Конечно, здесь не везде вина разработчиков хакерских ОС, JTR имел/имеет огромное кучу багов, а на Гитхабе открываются каждый день запросы по улучшению или исправлению ошибок в JTR-е. Репозиторий JTR на Гитхабе развивается куда энергичнее своего брата Hashcat. при этом между этими инструментами существует честная конкуренция: команды разработчиков вносят друг у друга исправления и улучшения в свои инструменты, а так же согласовывают некоторые общепринятые правила по брутфорсу паролей, или "делят между собой" новые поддерживаемые форматы для взлома.
Вообще, история JTR-а и тех Крутых разработчиков (разработчик Ettercap в деле и не только...), кого привлекли к разработке софта очень даже занимательная.

Рекомендую не пользоваться JTR предустановленными в Kali/Parrot, а компилировать всегда свежую версию JTR с Гитхаба (хоть, каждую неделю), и для тех крекеров, которые так и делали, то John the Ripper 1.9.0-jumbo-1 ни чем не удивил из своих новшеств. Для тех, кто этот инструмент не обновлял, с предпоследней версии изменилось/добавилось огромное кол-во функций/форматов/улучшений и исправлений. Инструмент JTR на столько напичкан новыми взрывными функциями, что в документации ПО прямо говориться: "JTR инструмент сложный, в первую очередь рассчитан для сисадминов и мачо)", ну примерно такой посыл даётся.

Что изменилось в JTR с предпоследней версии на последнюю (напомню, промежуточные сборки JTR обновляются на Гитхабе каждый день):
  • Обновлено ядро самого JTR-а
  • Добавлена куча новых форматов для взлома, всего чуть > 400 (считая динамические форматы, например, SHA1(Md5(соль/пароль/соль), которые можно генерировать самому крэкеру без навыков программирования, и тут, и не только тут Hashcat может только позавидовать
  • Добавлено 6000+ коммитов (исправлений/дополнений)
  • Отказ от поддержки CUDA из-за отсутствия интереса и ориентирование на OpenCL, который является более портативным для Nvidia и AMD, а также отлично работает на картах NVIDIA (на самом деле, много круче, чем CUDA)
  • Добавлено множество новых опций (некоторые слабо задокументированные, а некоторые вообще не имеют документации и относятся к "фишкам").
Подробный официальный Changes-Jumbo .

Вот в чём дело: для ПРО-инструментов таких, как Burp/Metasploit/Wireshark.... бесконечное число руководств на разных языках, но в рунете, да и в целом интернете - НЕТ подробного tutorial-а по JTR-у, неплохое (на самом деле, IMHO, лучшее в свое время ru) руководство по JTR-у вышло . Но за это время изменения в Профессиональном ПО JTR произошли колоссальные, а 2007 года ru-пособие JTR-а морально устарело и не охватывает большую часть функционала на сегодняшний майский день 2019 года.

С инструментом JTR я знаком несколько лет, поэтому мог бы (думаю, что осилил бы) опубликовать современное/лучшее пособие/руководство/tutorial по John the Ripper 1.9.0-jumbo-1 специально для портала Codeby.net, которого нет в сети.
Но возможно, этот софт не очень интересен крэкерам, и это станет "таким себе занятием для меня", поэтому ввёл небольшой опрос для жителей портала Codeby, застолбив за собой данный Tutorial по John the Ripper 1.9.0-jumbo-1.

С примером, как пример моего руководства по полнодисковому шифрованию, можно ознакомиться , пособие по JTR-у To be, or not to be планируется не менее масштабное.
 
S

shinza

Happy New Year
28.08.2017
8
4

Есть такое. Будет что нового тогда пиши.
 
  • Нравится
Реакции: fuzzz
A

am29f010b


Есть такое. Будет что нового тогда пиши.
неплохое(на самом деле, IMHO, лучшее в свое время ru) руководство по JTR-у вышло . Но за это время изменения в Профессиональном ПО JTR произошли колоссальные,
разница между "что нового" и "колосальные" очевидная.
 
  • Не нравится
Реакции: fuzzz
fuzzz

fuzzz

Grey Team
03.02.2019
170
285
Новость. А не статья
 
A

am29f010b

Новость. А не статья
Для Вас новость для меня обратная связь, "свободное общение", а не "этичный хакинг".
Своей новостью я не вмещался сюда Какие статьи вы хотели бы почитать?
и такая новость (если присмотреться к статье - неслизанная новость) затерялась бы в топике, а не была бы опубликована в tg.

Если речь про "метку статья", частично согласен.
 
Последнее редактирование модератором:
  • Нравится
Реакции: ☠xrahitel☠ и Valkiria
fuzzz

fuzzz

Grey Team
03.02.2019
170
285
Для Вас новость для меня обратная связь, "свободное общение", а не "этичный хакинг".
Своей новостью я не вмещался сюда Какие статьи вы хотели бы почитать?
и такая новость (если присмотреться к статье - неслизанная новость) затерялась бы в топике, а не была бы опубликована в tg.

Если речь про "метку статья", частично согласен.
Подведем итог. Вывод. Что мы должны вынести из статьи? то что инструмент обновился?
 
A

am29f010b

Подведем итог. Вывод. Что мы должны вынести из статьи? то что инструмент обновился?
Итог рано подводить, "предпосылки к руководству 2019 еще не набраны"
* Не надо пользоваться JtR в Kali/Parrot (написал почему)
* Инструмент "обновился", только для тех, кто не пользовался "промежуточными сборками" 1.9.0- 1 - это очередная промежуточная сборка или технический PR (предыдущая сборка 1.8.0.1х - имело всё, что есть в 1.9.0-1, только чуть больше багов, от CUDA ушли еще 4г. назад (opencl) кучу опций добавлялось также со временем, а не раз и в 1.9. После выхода версии 1.9, на днях еще одну опцию добавили и тд.
* обратная связь: стоит ли мне делать подробный tutorial по JtR в рунете, так как в сети он неподробный (или пролететь, как с квестом).
* и да, какие невье.енные обновления по сравнению с тем JtR, чье пособие Вы лайкнули.
 
Последнее редактирование модератором:
V

Valkiria

Итог рано подводить, "предпосылки к руководству 2019 еще не набраны"
Набираю предпосылок к руководству ))


При расшифровке wifi рукопожатий рекомендуется посылать их на различные специально предназначенные для этих целей он-лайн ресурсы. Это правильно. Но у такого способа расшифровки имеется один ОГРОМНЫЙ недостаток: он не делает пользователя умнее, а злоумышленника более злым.
Меня интересует практическое использование JTR.
Как с помощью этой программы расшифровать:
  • 4-этапное рукопожатие EAPOL
  • неполное рукопожатие RSN PMKID , полученное от wifi точки доступа без клиентов

Но это ещё не всё.
В своих высказываниях вы неоднократно утверждали, что на Андроиде также можно вполне успешно запускать брутфорс рукопожатий. И несмотря на более скромные ресурсы гаджетов, благодаря каким-то сверхъестественным способностям софта, брутфорс handshake в android имеет место быть )) Что это за программы, откуда их установить и на какие кнопки нажимать ?

Хотелось бы услышать что-то о расшифровке wifi рукопожатий в Windows услышать от Вас ))
 
Последнее редактирование модератором:
A

am29f010b

1. JtR WPA-PSK

Как с помощью этой программы расшифровать:
  • 4-этапное рукопожатие EAPOL
  • неполное рукопожатие RSN PMKID , полученное от wifi точки доступа без клиентов

Итак, для восстановления паролей в JtR (для многих форматов) синтаксис прост:
  • А) вытягивание/вычисление хэша из файла для JtR препроцессора (не всегда/но почти, зависит от взламываемого формата) и
  • Б) брутфорс этого хэша.
В JtR для вытягивания хэшей существует подинструменты *2john
bitlocker2john.exe
dmg2john.exe
gpg2john.exe
hccap2john.exe
keepass2john.exe
putty2john.exe
racf2john.exe
rar2john.exe
uaf2john.exe
wpapcap2john.exe
zip2john.exe
mongodb2john.js
network2john.lua
README.7z2john.md
7z2john.pl
aix2john.pl
cisco2john.pl
itunes_backup2john.pl
ldif2john.pl
lion2john.pl
lion2john-alt.pl
pdf2john.pl
radius2john.pl
sap2john.pl
vdi2john.pl
1password2john.py
adxcsouf2john.py
aem2john.py
aix2john.py
andotp2john.py
androidbackup2john.py
androidfde2john.py
ansible2john.py
apex2john.py
applenotes2john.py
aruba2john.py
axcrypt2john.py
bestcrypt2john.py
bitcoin2john.py
bitshares2john.py
bitwarden2john.py
bks2john.py
blockchain2john.py
ccache2john.py
cracf2john.py
dashlane2john.py
deepsound2john.py
diskcryptor2john.py
dmg2john.py
DPAPImk2john.py
ecryptfs2john.py
ejabberd2john.py
electrum2john.py
encfs2john.py
enpass2john.py
ethereum2john.py
filezilla2john.py
geli2john.py
hccapx2john.py
htdigest2john.py
ibmiscanner2john.py
ikescan2john.py
iwork2john.py
kdcdump2john.py
keychain2john.py
keyring2john.py
keystore2john.py
kirbi2john.py
known_hosts2john.py
krb2john.py
kwallet2john.py
lastpass2john.py
libreoffice2john.py
lotus2john.py
luks2john.py
mac2john.py
mac2john-alt.py
mcafee_epo2john.py
monero2john.py
money2john.py
mozilla2john.py
multibit2john.py
neo2john.py
office2john.py
openbsd_softraid2john.py
openssl2john.py
padlock2john.py
pcap2john.py
pem2john.py
pfx2john.py
pgpdisk2john.py
pgpsda2john.py
pgpwde2john.py
prosody2john.py
ps_token2john.py
pse2john.py
pwsafe2john.py
radius2john.py
signal2john.py
sipdump2john.py
ssh2john.py
sspr2john.py
staroffice2john.py
strip2john.py
telegram2john.py
tezos2john.py
truecrypt2john.py
vmx2john.py
pcap2john.readme.txt
В JtR поддерживается еще добрая сотня динамических субформатов: например SHA1/2/MD5/пароль/соль и пд., с ними: динам.форматами нужно быть "нежнее".

WPA-PSK.

Вариант #1 (Правильный)

Как вытягивать хэш из Wifi? так же как и в PDF и X_Wallet и в <...>, синтаксис один и тот же:
$ ~/*2john* рукопожатие.cap > ~/хэш #извлекаем из рукопожатия "хэш" и перенаправляем вывод в файл хэш
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

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

Далее запускаем атаку на наш хэш рукопожатие/рукопожатия (если у нас куча "хэшей" в файле хэш)
Самый простой синтаксис и "бессмысленный"
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

john2 - alias.
Запуск атаки без опций на хэш рукопожатия (но! всегда надо добавлять кучу ключей/флагов) приведет к быстрой пробежке по внутреннему словарю JtR, режиму одиночного взлома и тупой бесконечный перебор - так никто никогда не брутит, и этот пример только для простого понимания: так составлена команда).

Многие форматы имеют самоопределение "хэшей" из файла "хэш", но иногда "хэш" необходимо указывать вручную (часто, тк., например md5 и NTLM имеют одинаковую длину: 32 символа в HEX), например, $ john --format=raw-md5 ~/хэш

Вариант #2 хмурый
Извлечение хэша из рукопожатия.cap для Джоновского препроцессора с помощью сторонних инструментов (aircrack-ng > Hashcat > JtR)
$ aircrack-ng ~/рукопожатие.cap -J ~/файл.cap && hccap2john ~/файл.cap > ~/хэш #Конвертируем cap в формат Hashcat-а и из Hashcat-а конвертируем в Джновский формат.

Вариант #3 современный/нерабочий
Для PMKID (~в это время первыми, а сейчас уже все умеют pmkid захватывать) вышли современные инструменты для захвата/конвертирования хэша "pmkid" для JtR или Hashcata. hcxtools/hcxdumptool.
И сторонний подинструмент извлечения хэша из кадров hcxtools/ для Джоновского препроцессора неправильно конвертировал форматы (для Hashcat-a правильно). Может сейчас поправили конвертер, но зачем он нужен, когда есть "Вариант #1".

Поддерживаемые форматы JTR CPU + OpenCL (брут на GPU, компилировать инструмент нужно по другому)
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

Поддержка форматов для брутфорс атаки в JtR - [1-CPU]; [2-GPU]

ну и поддержка
Format = dynamic_0 type = dynamic_0: md5($p) (raw-md5)
Format = dynamic_1 type = dynamic_1: md5($p.$s) (joomla)
Format = dynamic_2 type = dynamic_2: md5(md5($p)) (e107)
Format = dynamic_3 type = dynamic_3: md5(md5(md5($p)))
Format = dynamic_4 type = dynamic_4: md5($s.$p) (OSC)
Format = dynamic_5 type = dynamic_5: md5($s.$p.$s)
Format = dynamic_6 type = dynamic_6: md5(md5($p).$s)
Format = dynamic_8 type = dynamic_8: md5(md5($s).$p)
Format = dynamic_9 type = dynamic_9: md5($s.md5($p))
Format = dynamic_10 type = dynamic_10: md5($s.md5($s.$p))
Format = dynamic_11 type = dynamic_11: md5($s.md5($p.$s))
Format = dynamic_12 type = dynamic_12: md5(md5($s).md5($p)) (IPB)
Format = dynamic_13 type = dynamic_13: md5(md5($p).md5($s))
Format = dynamic_14 type = dynamic_14: md5($s.md5($p).$s)
Format = dynamic_15 type = dynamic_15: md5($u.md5($p).$s)
Format = dynamic_16 type = dynamic_16: md5(md5(md5($p).$s).$s2)
Format = dynamic_18 type = dynamic_18: md5($s.Y.$p.0xF7.$s) (Post.Office MD5)
Format = dynamic_19 type = dynamic_19: md5($p) (Cisco PIX)
Format = dynamic_20 type = dynamic_20: md5($p.$s) (Cisco ASA)
Format = dynamic_22 type = dynamic_22: md5(sha1($p))
Format = dynamic_23 type = dynamic_23: sha1(md5($p))
Format = dynamic_24 type = dynamic_24: sha1($p.$s)
Format = dynamic_25 type = dynamic_25: sha1($s.$p)
Format = dynamic_26 type = dynamic_26: sha1($p) raw-sha1
Format = dynamic_29 type = dynamic_29: md5(utf16($p))
Format = dynamic_30 type = dynamic_30: md4($p) (raw-md4)
Format = dynamic_31 type = dynamic_31: md4($s.$p)
Format = dynamic_32 type = dynamic_32: md4($p.$s)
Format = dynamic_33 type = dynamic_33: md4(utf16($p))
Format = dynamic_34 type = dynamic_34: md5(md4($p))
Format = dynamic_35 type = dynamic_35: sha1(uc($u).:.$p) (ManGOS)
Format = dynamic_36 type = dynamic_36: sha1($u.:.$p) (ManGOS2)
Format = dynamic_37 type = dynamic_37: sha1(lc($u).$p) (SMF)
Format = dynamic_38 type = dynamic_38: sha1($s.sha1($s.sha1($p))) (Wolt3BB)
Format = dynamic_39 type = dynamic_39: md5($s.pad16($p)) (net-md5)
Format = dynamic_40 type = dynamic_40: sha1($s.pad20($p)) (net-sha1)
Format = dynamic_50 type = dynamic_50: sha224($p)
Format = dynamic_51 type = dynamic_51: sha224($s.$p)
Format = dynamic_52 type = dynamic_52: sha224($p.$s)
Format = dynamic_53 type = dynamic_53: sha224(sha224($p))
Format = dynamic_54 type = dynamic_54: sha224(sha224_raw($p))
Format = dynamic_55 type = dynamic_55: sha224(sha224($p).$s)
Format = dynamic_56 type = dynamic_56: sha224($s.sha224($p))
Format = dynamic_57 type = dynamic_57: sha224(sha224($s).sha224($p))
Format = dynamic_58 type = dynamic_58: sha224(sha224($p).sha224($p))
Format = dynamic_60 type = dynamic_60: sha256($p)
Format = dynamic_61 type = dynamic_61: sha256($s.$p)
Format = dynamic_62 type = dynamic_62: sha256($p.$s)
Format = dynamic_63 type = dynamic_63: sha256(sha256($p))
Format = dynamic_64 type = dynamic_64: sha256(sha256_raw($p))
Format = dynamic_65 type = dynamic_65: sha256(sha256($p).$s)
Format = dynamic_66 type = dynamic_66: sha256($s.sha256($p))
Format = dynamic_67 type = dynamic_67: sha256(sha256($s).sha256($p))
Format = dynamic_68 type = dynamic_68: sha256(sha256($p).sha256($p))
Format = dynamic_70 type = dynamic_70: sha384($p)
Format = dynamic_71 type = dynamic_71: sha384($s.$p)
Format = dynamic_72 type = dynamic_72: sha384($p.$s)
Format = dynamic_73 type = dynamic_73: sha384(sha384($p))
Format = dynamic_74 type = dynamic_74: sha384(sha384_raw($p))
Format = dynamic_75 type = dynamic_75: sha384(sha384($p).$s)
Format = dynamic_76 type = dynamic_76: sha384($s.sha384($p))
Format = dynamic_77 type = dynamic_77: sha384(sha384($s).sha384($p))
Format = dynamic_78 type = dynamic_78: sha384(sha384($p).sha384($p))
Format = dynamic_80 type = dynamic_80: sha512($p)
Format = dynamic_81 type = dynamic_81: sha512($s.$p)
Format = dynamic_82 type = dynamic_82: sha512($p.$s)
Format = dynamic_83 type = dynamic_83: sha512(sha512($p))
Format = dynamic_84 type = dynamic_84: sha512(sha512_raw($p))
Format = dynamic_85 type = dynamic_85: sha512(sha512($p).$s)
Format = dynamic_86 type = dynamic_86: sha512($s.sha512($p))
Format = dynamic_90 type = dynamic_90: gost($p)
Format = dynamic_91 type = dynamic_91: gost($s.$p)
Format = dynamic_92 type = dynamic_92: gost($p.$s)
Format = dynamic_93 type = dynamic_93: gost(gost($p))
Format = dynamic_94 type = dynamic_94: gost(gost_raw($p))
Format = dynamic_95 type = dynamic_95: gost(gost($p).$s)
Format = dynamic_96 type = dynamic_96: gost($s.gost($p))
Format = dynamic_97 type = dynamic_97: gost(gost($s).gost($p))
Format = dynamic_98 type = dynamic_98: gost(gost($p).gost($p))
Format = dynamic_100 type = dynamic_100: whirlpool($p)
Format = dynamic_101 type = dynamic_101: whirlpool($s.$p)
Format = dynamic_102 type = dynamic_102: whirlpool($p.$s)
Format = dynamic_103 type = dynamic_103: whirlpool(whirlpool($p))
Format = dynamic_104 type = dynamic_104: whirlpool(whirlpool_raw($p))
Format = dynamic_105 type = dynamic_105: whirlpool(whirlpool($p).$s)
Format = dynamic_106 type = dynamic_106: whirlpool($s.whirlpool($p))
Format = dynamic_107 type = dynamic_107: whirlpool(whirlpool($s).whirlpool($p))
Format = dynamic_108 type = dynamic_108: whirlpool(whirlpool($p).whirlpool($p))
Format = dynamic_110 type = dynamic_110: tiger($p)
Format = dynamic_111 type = dynamic_111: tiger($s.$p)
Format = dynamic_112 type = dynamic_112: tiger($p.$s)
Format = dynamic_113 type = dynamic_113: tiger(tiger($p))
Format = dynamic_114 type = dynamic_114: tiger(tiger_raw($p))
Format = dynamic_115 type = dynamic_115: tiger(tiger($p).$s)
Format = dynamic_116 type = dynamic_116: tiger($s.tiger($p))
Format = dynamic_117 type = dynamic_117: tiger(tiger($s).tiger($p))
Format = dynamic_118 type = dynamic_118: tiger(tiger($p).tiger($p))
Format = dynamic_120 type = dynamic_120: ripemd128($p)
Format = dynamic_121 type = dynamic_121: ripemd128($s.$p)
Format = dynamic_122 type = dynamic_122: ripemd128($p.$s)
Format = dynamic_123 type = dynamic_123: ripemd128(ripemd128($p))
Format = dynamic_124 type = dynamic_124: ripemd128(ripemd128_raw($p))
Format = dynamic_125 type = dynamic_125: ripemd128(ripemd128($p).$s)
Format = dynamic_126 type = dynamic_126: ripemd128($s.ripemd128($p))
Format = dynamic_127 type = dynamic_127: ripemd128(ripemd128($s).ripemd128($p))
Format = dynamic_128 type = dynamic_128: ripemd128(ripemd128($p).ripemd128($p))
Format = dynamic_130 type = dynamic_130: ripemd160($p)
Format = dynamic_131 type = dynamic_131: ripemd160($s.$p)
Format = dynamic_132 type = dynamic_132: ripemd160($p.$s)
Format = dynamic_133 type = dynamic_133: ripemd160(ripemd160($p))
Format = dynamic_134 type = dynamic_134: ripemd160(ripemd160_raw($p))
Format = dynamic_135 type = dynamic_135: ripemd160(ripemd160($p).$s)
Format = dynamic_136 type = dynamic_136: ripemd160($s.ripemd160($p))
Format = dynamic_137 type = dynamic_137: ripemd160(ripemd160($s).ripemd160($p))
Format = dynamic_138 type = dynamic_138: ripemd160(ripemd160($p).ripemd160($p))
Format = dynamic_140 type = dynamic_140: ripemd256($p)
Format = dynamic_141 type = dynamic_141: ripemd256($s.$p)
Format = dynamic_142 type = dynamic_142: ripemd256($p.$s)
Format = dynamic_143 type = dynamic_143: ripemd256(ripemd256($p))
Format = dynamic_144 type = dynamic_144: ripemd256(ripemd256_raw($p))
Format = dynamic_145 type = dynamic_145: ripemd256(ripemd256($p).$s)
Format = dynamic_146 type = dynamic_146: ripemd256($s.ripemd256($p))
Format = dynamic_147 type = dynamic_147: ripemd256(ripemd256($s).ripemd256($p))
Format = dynamic_148 type = dynamic_148: ripemd256(ripemd256($p).ripemd256($p))
Format = dynamic_150 type = dynamic_150: ripemd320($p)
Format = dynamic_151 type = dynamic_151: ripemd320($s.$p)
Format = dynamic_152 type = dynamic_152: ripemd320($p.$s)
Format = dynamic_153 type = dynamic_153: ripemd320(ripemd320($p))
Format = dynamic_154 type = dynamic_154: ripemd320(ripemd320_raw($p))
Format = dynamic_155 type = dynamic_155: ripemd320(ripemd320($p).$s)
Format = dynamic_156 type = dynamic_156: ripemd320($s.ripemd320($p))
Format = dynamic_157 type = dynamic_157: ripemd320(ripemd320($s).ripemd320($p))
Format = dynamic_158 type = dynamic_158: ripemd320(ripemd320($p).ripemd320($p))
Format = dynamic_160 type = dynamic_160: haval128_3($p)
Format = dynamic_161 type = dynamic_161: haval128_3($s.$p)
Format = dynamic_162 type = dynamic_162: haval128_3($p.$s)
Format = dynamic_163 type = dynamic_163: haval128_3(haval128_3($p))
Format = dynamic_164 type = dynamic_164: haval128_3(haval128_3_raw($p))
Format = dynamic_165 type = dynamic_165: haval128_3(haval128_3($p).$s)
Format = dynamic_166 type = dynamic_166: haval128_3($s.haval128_3($p))
Format = dynamic_167 type = dynamic_167: haval128_3(haval128_3($s).haval128_3($p))
Format = dynamic_168 type = dynamic_168: haval128_3(haval128_3($p).haval128_3($p))
Format = dynamic_170 type = dynamic_170: haval128_4($p)
Format = dynamic_171 type = dynamic_171: haval128_4($s.$p)
Format = dynamic_172 type = dynamic_172: haval128_4($p.$s)
Format = dynamic_173 type = dynamic_173: haval128_4(haval128_4($p))
Format = dynamic_174 type = dynamic_174: haval128_4(haval128_4_raw($p))
Format = dynamic_175 type = dynamic_175: haval128_4(haval128_4($p).$s)
Format = dynamic_176 type = dynamic_176: haval128_4($s.haval128_4($p))
Format = dynamic_177 type = dynamic_177: haval128_4(haval128_4($s).haval128_4($p))
Format = dynamic_178 type = dynamic_178: haval128_4(haval128_4($p).haval128_4($p))
Format = dynamic_180 type = dynamic_180: haval128_5($p)
Format = dynamic_181 type = dynamic_181: haval128_5($s.$p)
Format = dynamic_182 type = dynamic_182: haval128_5($p.$s)
Format = dynamic_183 type = dynamic_183: haval128_5(haval128_5($p))
Format = dynamic_184 type = dynamic_184: haval128_5(haval128_5_raw($p))
Format = dynamic_185 type = dynamic_185: haval128_5(haval128_5($p).$s)
Format = dynamic_186 type = dynamic_186: haval128_5($s.haval128_5($p))
Format = dynamic_187 type = dynamic_187: haval128_5(haval128_5($s).haval128_5($p))
Format = dynamic_188 type = dynamic_188: haval128_5(haval128_5($p).haval128_5($p))
Format = dynamic_190 type = dynamic_190: haval160_3($p)
Format = dynamic_191 type = dynamic_191: haval160_3($s.$p)
Format = dynamic_192 type = dynamic_192: haval160_3($p.$s)
Format = dynamic_193 type = dynamic_193: haval160_3(haval160_3($p))
Format = dynamic_194 type = dynamic_194: haval160_3(haval160_3_raw($p))
Format = dynamic_195 type = dynamic_195: haval160_3(haval160_3($p).$s)
Format = dynamic_196 type = dynamic_196: haval160_3($s.haval160_3($p))
Format = dynamic_197 type = dynamic_197: haval160_3(haval160_3($s).haval160_3($p))
Format = dynamic_198 type = dynamic_198: haval160_3(haval160_3($p).haval160_3($p))
Format = dynamic_200 type = dynamic_200: haval160_4($p)
Format = dynamic_201 type = dynamic_201: haval160_4($s.$p)
Format = dynamic_202 type = dynamic_202: haval160_4($p.$s)
Format = dynamic_203 type = dynamic_203: haval160_4(haval160_4($p))
Format = dynamic_204 type = dynamic_204: haval160_4(haval160_4_raw($p))
Format = dynamic_205 type = dynamic_205: haval160_4(haval160_4($p).$s)
Format = dynamic_206 type = dynamic_206: haval160_4($s.haval160_4($p))
Format = dynamic_207 type = dynamic_207: haval160_4(haval160_4($s).haval160_4($p))
Format = dynamic_208 type = dynamic_208: haval160_4(haval160_4($p).haval160_4($p))
Format = dynamic_210 type = dynamic_210: haval160_5($p)
Format = dynamic_211 type = dynamic_211: haval160_5($s.$p)
Format = dynamic_212 type = dynamic_212: haval160_5($p.$s)
Format = dynamic_213 type = dynamic_213: haval160_5(haval160_5($p))
Format = dynamic_214 type = dynamic_214: haval160_5(haval160_5_raw($p))
Format = dynamic_215 type = dynamic_215: haval160_5(haval160_5($p).$s)
Format = dynamic_216 type = dynamic_216: haval160_5($s.haval160_5($p))
Format = dynamic_217 type = dynamic_217: haval160_5(haval160_5($s).haval160_5($p))
Format = dynamic_218 type = dynamic_218: haval160_5(haval160_5($p).haval160_5($p))
Format = dynamic_220 type = dynamic_220: haval192_3($p)
Format = dynamic_221 type = dynamic_221: haval192_3($s.$p)
Format = dynamic_222 type = dynamic_222: haval192_3($p.$s)
Format = dynamic_223 type = dynamic_223: haval192_3(haval192_3($p))
Format = dynamic_224 type = dynamic_224: haval192_3(haval192_3_raw($p))
Format = dynamic_225 type = dynamic_225: haval192_3(haval192_3($p).$s)
Format = dynamic_226 type = dynamic_226: haval192_3($s.haval192_3($p))
Format = dynamic_227 type = dynamic_227: haval192_3(haval192_3($s).haval192_3($p))
Format = dynamic_228 type = dynamic_228: haval192_3(haval192_3($p).haval192_3($p))
Format = dynamic_230 type = dynamic_230: haval192_4($p)
Format = dynamic_231 type = dynamic_231: haval192_4($s.$p)
Format = dynamic_232 type = dynamic_232: haval192_4($p.$s)
Format = dynamic_233 type = dynamic_233: haval192_4(haval192_4($p))
Format = dynamic_234 type = dynamic_234: haval192_4(haval192_4_raw($p))
Format = dynamic_235 type = dynamic_235: haval192_4(haval192_4($p).$s)
Format = dynamic_236 type = dynamic_236: haval192_4($s.haval192_4($p))
Format = dynamic_237 type = dynamic_237: haval192_4(haval192_4($s).haval192_4($p))
Format = dynamic_238 type = dynamic_238: haval192_4(haval192_4($p).haval192_4($p))
Format = dynamic_240 type = dynamic_240: haval192_5($p)
Format = dynamic_241 type = dynamic_241: haval192_5($s.$p)
Format = dynamic_242 type = dynamic_242: haval192_5($p.$s)
Format = dynamic_243 type = dynamic_243: haval192_5(haval192_5($p))
Format = dynamic_244 type = dynamic_244: haval192_5(haval192_5_raw($p))
Format = dynamic_245 type = dynamic_245: haval192_5(haval192_5($p).$s)
Format = dynamic_246 type = dynamic_246: haval192_5($s.haval192_5($p))
Format = dynamic_247 type = dynamic_247: haval192_5(haval192_5($s).haval192_5($p))
Format = dynamic_248 type = dynamic_248: haval192_5(haval192_5($p).haval192_5($p))
Format = dynamic_250 type = dynamic_250: haval224_3($p)
Format = dynamic_251 type = dynamic_251: haval224_3($s.$p)
Format = dynamic_252 type = dynamic_252: haval224_3($p.$s)
Format = dynamic_253 type = dynamic_253: haval224_3(haval224_3($p))
Format = dynamic_254 type = dynamic_254: haval224_3(haval224_3_raw($p))
Format = dynamic_255 type = dynamic_255: haval224_3(haval224_3($p).$s)
Format = dynamic_256 type = dynamic_256: haval224_3($s.haval224_3($p))
Format = dynamic_257 type = dynamic_257: haval224_3(haval224_3($s).haval224_3($p))
Format = dynamic_258 type = dynamic_258: haval224_3(haval224_3($p).haval224_3($p))
Format = dynamic_260 type = dynamic_260: haval224_4($p)
Format = dynamic_261 type = dynamic_261: haval224_4($s.$p)
Format = dynamic_262 type = dynamic_262: haval224_4($p.$s)
Format = dynamic_263 type = dynamic_263: haval224_4(haval224_4($p))
Format = dynamic_264 type = dynamic_264: haval224_4(haval224_4_raw($p))
Format = dynamic_265 type = dynamic_265: haval224_4(haval224_4($p).$s)
Format = dynamic_266 type = dynamic_266: haval224_4($s.haval224_4($p))
Format = dynamic_267 type = dynamic_267: haval224_4(haval224_4($s).haval224_4($p))
Format = dynamic_268 type = dynamic_268: haval224_4(haval224_4($p).haval224_4($p))
Format = dynamic_270 type = dynamic_270: haval224_5($p)
Format = dynamic_271 type = dynamic_271: haval224_5($s.$p)
Format = dynamic_272 type = dynamic_272: haval224_5($p.$s)
Format = dynamic_273 type = dynamic_273: haval224_5(haval224_5($p))
Format = dynamic_274 type = dynamic_274: haval224_5(haval224_5_raw($p))
Format = dynamic_275 type = dynamic_275: haval224_5(haval224_5($p).$s)
Format = dynamic_276 type = dynamic_276: haval224_5($s.haval224_5($p))
Format = dynamic_277 type = dynamic_277: haval224_5(haval224_5($s).haval224_5($p))
Format = dynamic_278 type = dynamic_278: haval224_5(haval224_5($p).haval224_5($p))
Format = dynamic_280 type = dynamic_280: haval256_3($p)
Format = dynamic_281 type = dynamic_281: haval256_3($s.$p)
Format = dynamic_282 type = dynamic_282: haval256_3($p.$s)
Format = dynamic_283 type = dynamic_283: haval256_3(haval256_3($p))
Format = dynamic_284 type = dynamic_284: haval256_3(haval256_3_raw($p))
Format = dynamic_285 type = dynamic_285: haval256_3(haval256_3($p).$s)
Format = dynamic_286 type = dynamic_286: haval256_3($s.haval256_3($p))
Format = dynamic_287 type = dynamic_287: haval256_3(haval256_3($s).haval256_3($p))
Format = dynamic_288 type = dynamic_288: haval256_3(haval256_3($p).haval256_3($p))
Format = dynamic_290 type = dynamic_290: haval256_4($p)
Format = dynamic_291 type = dynamic_291: haval256_4($s.$p)
Format = dynamic_292 type = dynamic_292: haval256_4($p.$s)
Format = dynamic_293 type = dynamic_293: haval256_4(haval256_4($p))
Format = dynamic_294 type = dynamic_294: haval256_4(haval256_4_raw($p))
Format = dynamic_295 type = dynamic_295: haval256_4(haval256_4($p).$s)
Format = dynamic_296 type = dynamic_296: haval256_4($s.haval256_4($p))
Format = dynamic_297 type = dynamic_297: haval256_4(haval256_4($s).haval256_4($p))
Format = dynamic_298 type = dynamic_298: haval256_4(haval256_4($p).haval256_4($p))
Format = dynamic_300 type = dynamic_300: haval256_5($p)
Format = dynamic_301 type = dynamic_301: haval256_5($s.$p)
Format = dynamic_302 type = dynamic_302: haval256_5($p.$s)
Format = dynamic_303 type = dynamic_303: haval256_5(haval256_5($p))
Format = dynamic_304 type = dynamic_304: haval256_5(haval256_5_raw($p))
Format = dynamic_305 type = dynamic_305: haval256_5(haval256_5($p).$s)
Format = dynamic_306 type = dynamic_306: haval256_5($s.haval256_5($p))
Format = dynamic_307 type = dynamic_307: haval256_5(haval256_5($s).haval256_5($p))
Format = dynamic_308 type = dynamic_308: haval256_5(haval256_5($p).haval256_5($p))
Format = dynamic_310 type = dynamic_310: md2($p)
Format = dynamic_311 type = dynamic_311: md2($s.$p)
Format = dynamic_312 type = dynamic_312: md2($p.$s)
Format = dynamic_313 type = dynamic_313: md2(md2($p))
Format = dynamic_314 type = dynamic_314: md2(md2_raw($p))
Format = dynamic_315 type = dynamic_315: md2(md2($p).$s)
Format = dynamic_316 type = dynamic_316: md2($s.md2($p))
Format = dynamic_317 type = dynamic_317: md2(md2($s).md2($p))
Format = dynamic_318 type = dynamic_318: md2(md2($p).md2($p))
Format = dynamic_320 type = dynamic_320: panama($p)
Format = dynamic_321 type = dynamic_321: panama($s.$p)
Format = dynamic_322 type = dynamic_322: panama($p.$s)
Format = dynamic_323 type = dynamic_323: panama(panama($p))
Format = dynamic_324 type = dynamic_324: panama(panama_raw($p))
Format = dynamic_325 type = dynamic_325: panama(panama($p).$s)
Format = dynamic_326 type = dynamic_326: panama($s.panama($p))
Format = dynamic_327 type = dynamic_327: panama(panama($s).panama($p))
Format = dynamic_328 type = dynamic_328: panama(panama($p).panama($p))
Format = dynamic_330 type = dynamic_330: skein224($p)
Format = dynamic_331 type = dynamic_331: skein224($s.$p)
Format = dynamic_332 type = dynamic_332: skein224($p.$s)
Format = dynamic_333 type = dynamic_333: skein224(skein224($p))
Format = dynamic_334 type = dynamic_334: skein224(skein224_raw($p))
Format = dynamic_335 type = dynamic_335: skein224(skein224($p).$s)
Format = dynamic_336 type = dynamic_336: skein224($s.skein224($p))
Format = dynamic_337 type = dynamic_337: skein224(skein224($s).skein224($p))
Format = dynamic_338 type = dynamic_338: skein224(skein224($p).skein224($p))
Format = dynamic_340 type = dynamic_340: skein256($p)
Format = dynamic_341 type = dynamic_341: skein256($s.$p)
Format = dynamic_342 type = dynamic_342: skein256($p.$s)
Format = dynamic_343 type = dynamic_343: skein256(skein256($p))
Format = dynamic_344 type = dynamic_344: skein256(skein256_raw($p))
Format = dynamic_345 type = dynamic_345: skein256(skein256($p).$s)
Format = dynamic_346 type = dynamic_346: skein256($s.skein256($p))
Format = dynamic_347 type = dynamic_347: skein256(skein256($s).skein256($p))
Format = dynamic_348 type = dynamic_348: skein256(skein256($p).skein256($p))
Format = dynamic_350 type = dynamic_350: skein384($p)
Format = dynamic_351 type = dynamic_351: skein384($s.$p)
Format = dynamic_352 type = dynamic_352: skein384($p.$s)
Format = dynamic_353 type = dynamic_353: skein384(skein384($p))
Format = dynamic_354 type = dynamic_354: skein384(skein384_raw($p))
Format = dynamic_355 type = dynamic_355: skein384(skein384($p).$s)
Format = dynamic_356 type = dynamic_356: skein384($s.skein384($p))
Format = dynamic_357 type = dynamic_357: skein384(skein384($s).skein384($p))
Format = dynamic_358 type = dynamic_358: skein384(skein384($p).skein384($p))
Format = dynamic_360 type = dynamic_360: skein512($p)
Format = dynamic_361 type = dynamic_361: skein512($s.$p)
Format = dynamic_362 type = dynamic_362: skein512($p.$s)
Format = dynamic_363 type = dynamic_363: skein512(skein512($p))
Format = dynamic_364 type = dynamic_364: skein512(skein512_raw($p))
Format = dynamic_365 type = dynamic_365: skein512(skein512($p).$s)
Format = dynamic_366 type = dynamic_366: skein512($s.skein512($p))
Format = dynamic_367 type = dynamic_367: skein512(skein512($s).skein512($p))
Format = dynamic_368 type = dynamic_368: skein512(skein512($p).skein512($p))
Format = dynamic_370 type = dynamic_370: sha3_224($p)
Format = dynamic_371 type = dynamic_371: sha3_224($s.$p)
Format = dynamic_372 type = dynamic_372: sha3_224($p.$s)
Format = dynamic_373 type = dynamic_373: sha3_224(sha3_224($p))
Format = dynamic_374 type = dynamic_374: sha3_224(sha3_224_raw($p))
Format = dynamic_375 type = dynamic_375: sha3_224(sha3_224($p).$s)
Format = dynamic_376 type = dynamic_376: sha3_224($s.sha3_224($p))
Format = dynamic_377 type = dynamic_377: sha3_224(sha3_224($s).sha3_224($p))
Format = dynamic_378 type = dynamic_378: sha3_224(sha3_224($p).sha3_224($p))
Format = dynamic_380 type = dynamic_380: sha3_256($p)
Format = dynamic_381 type = dynamic_381: sha3_256($s.$p)
Format = dynamic_382 type = dynamic_382: sha3_256($p.$s)
Format = dynamic_383 type = dynamic_383: sha3_256(sha3_256($p))
Format = dynamic_384 type = dynamic_384: sha3_256(sha3_256_raw($p))
Format = dynamic_385 type = dynamic_385: sha3_256(sha3_256($p).$s)
Format = dynamic_386 type = dynamic_386: sha3_256($s.sha3_256($p))
Format = dynamic_387 type = dynamic_387: sha3_256(sha3_256($s).sha3_256($p))
Format = dynamic_388 type = dynamic_388: sha3_256(sha3_256($p).sha3_256($p))
Format = dynamic_390 type = dynamic_390: sha3_384($p)
Format = dynamic_391 type = dynamic_391: sha3_384($s.$p)
Format = dynamic_392 type = dynamic_392: sha3_384($p.$s)
Format = dynamic_393 type = dynamic_393: sha3_384(sha3_384($p))
Format = dynamic_394 type = dynamic_394: sha3_384(sha3_384_raw($p))
Format = dynamic_395 type = dynamic_395: sha3_384(sha3_384($p).$s)
Format = dynamic_396 type = dynamic_396: sha3_384($s.sha3_384($p))
Format = dynamic_397 type = dynamic_397: sha3_384(sha3_384($s).sha3_384($p))
Format = dynamic_398 type = dynamic_398: sha3_384(sha3_384($p).sha3_384($p))
Format = dynamic_400 type = dynamic_400: sha3_512($p)
Format = dynamic_401 type = dynamic_401: sha3_512($s.$p)
Format = dynamic_402 type = dynamic_402: sha3_512($p.$s)
Format = dynamic_403 type = dynamic_403: sha3_512(sha3_512($p))
Format = dynamic_404 type = dynamic_404: sha3_512(sha3_512_raw($p))
Format = dynamic_405 type = dynamic_405: sha3_512(sha3_512($p).$s)
Format = dynamic_406 type = dynamic_406: sha3_512($s.sha3_512($p))
Format = dynamic_407 type = dynamic_407: sha3_512(sha3_512($s).sha3_512($p))
Format = dynamic_408 type = dynamic_408: sha3_512(sha3_512($p).sha3_512($p))
Format = dynamic_410 type = dynamic_410: keccak_256($p)
Format = dynamic_411 type = dynamic_411: keccak_256($s.$p)
Format = dynamic_412 type = dynamic_412: keccak_256($p.$s)
Format = dynamic_413 type = dynamic_413: keccak_256(keccak_256($p))
Format = dynamic_414 type = dynamic_414: keccak_256(keccak_256_raw($p))
Format = dynamic_415 type = dynamic_415: keccak_256(keccak_256($p).$s)
Format = dynamic_416 type = dynamic_416: keccak_256($s.keccak_256($p))
Format = dynamic_417 type = dynamic_417: keccak_256(keccak_256($s).keccak_256($p))
Format = dynamic_418 type = dynamic_418: keccak_256(keccak_256($p).keccak_256($p))
Format = dynamic_420 type = dynamic_420: keccak_512($p)
Format = dynamic_421 type = dynamic_421: keccak_512($s.$p)
Format = dynamic_422 type = dynamic_422: keccak_512($p.$s)
Format = dynamic_423 type = dynamic_423: keccak_512(keccak_512($p))
Format = dynamic_424 type = dynamic_424: keccak_512(keccak_512_raw($p))
Format = dynamic_425 type = dynamic_425: keccak_512(keccak_512($p).$s)
Format = dynamic_426 type = dynamic_426: keccak_512($s.keccak_512($p))
Format = dynamic_427 type = dynamic_427: keccak_512(keccak_512($s).keccak_512($p))
Format = dynamic_428 type = dynamic_428: keccak_512(keccak_512($p).keccak_512($p))
UserFormat = dynamic_1001 type = dynamic_1001: md5(md5(md5(md5($p))))
UserFormat = dynamic_1002 type = dynamic_1002: md5(md5(md5(md5(md5($p)))))
UserFormat = dynamic_1003 type = dynamic_1003: md5(md5($p).md5($p))
UserFormat = dynamic_1004 type = dynamic_1004: md5(md5(md5(md5(md5(md5($p))))))
UserFormat = dynamic_1005 type = dynamic_1005: md5(md5(md5(md5(md5(md5(md5($p)))))))
UserFormat = dynamic_1006 type = dynamic_1006: md5(md5(md5(md5(md5(md5(md5(md5($p))))))))
UserFormat = dynamic_1007 type = dynamic_1007: md5(md5($p).$s) (vBulletin)
UserFormat = dynamic_1008 type = dynamic_1008: md5($p.$s) (RADIUS User-Password)
UserFormat = dynamic_1009 type = dynamic_1009: md5($s.$p) (RADIUS Responses)
UserFormat = dynamic_1010 type = dynamic_1010: md5($p null_padded_to_len_100) RAdmin v2.x MD5
UserFormat = dynamic_1011 type = dynamic_1011: md5($p.md5($s)) (webEdition CMS)
UserFormat = dynamic_1012 type = dynamic_1012: md5($p.md5($s)) (webEdition CMS)
UserFormat = dynamic_1013 type = dynamic_1013: md5($p.PMD5(username)) (webEdition CMS)
UserFormat = dynamic_1014 type = dynamic_1014: md5($p.$s) (long salt)
UserFormat = dynamic_1015 type = dynamic_1015: md5(md5($p.$u).$s) (PostgreSQL 'pass the hash')
UserFormat = dynamic_1016 type = dynamic_1016: md5($p.$s) (long salt)
UserFormat = dynamic_1017 type = dynamic_1017: md5($s.$p) (long salt)
UserFormat = dynamic_1018 type = dynamic_1018: md5(sha1(sha1($p)))
UserFormat = dynamic_1019 type = dynamic_1019: md5(sha1(sha1(md5($p))))
UserFormat = dynamic_1020 type = dynamic_1020: md5(sha1(md5($p)))
UserFormat = dynamic_1021 type = dynamic_1021: md5(sha1(md5(sha1($p))))
UserFormat = dynamic_1022 type = dynamic_1022: md5(sha1(md5(sha1(md5($p)))))
UserFormat = dynamic_1023 type = dynamic_1023: sha1($p) (hash truncated to length 32)
UserFormat = dynamic_1024 type = dynamic_1024: sha1(md5($p)) (hash truncated to length 32)
UserFormat = dynamic_1025 type = dynamic_1025: sha1(md5(md5($p))) (hash truncated to length 32)
UserFormat = dynamic_1026 type = dynamic_1026: sha1(sha1($p)) (hash truncated to length 32)
UserFormat = dynamic_1027 type = dynamic_1027: sha1(sha1(sha1($p))) (hash truncated to length 32)
UserFormat = dynamic_1028 type = dynamic_1028: sha1(sha1_raw($p)) (hash truncated to length 32)
UserFormat = dynamic_1029 type = dynamic_1029: sha256($p) (hash truncated to length 32)
UserFormat = dynamic_1030 type = dynamic_1030: whirlpool($p) (hash truncated to length 32)
UserFormat = dynamic_1031 type = dynamic_1031: gost($p) (hash truncated to length 32)
UserFormat = dynamic_1032 type = dynamic_1032: sha1_64(utf16($p)) (PeopleSoft)
UserFormat = dynamic_1033 type = dynamic_1033: sha1_64(utf16($p).$s)
UserFormat = dynamic_1034 type = dynamic_1034: md5($p.$u) (PostgreSQL MD5)
UserFormat = dynamic_1300 type = dynamic_1300: md5(md5_raw($p))
UserFormat = dynamic_1350 type = dynamic_1350: md5(md5($s.$p):$s)
UserFormat = dynamic_1400 type = dynamic_1400: sha1(utf16($p)) (Microsoft CREDHIST)
UserFormat = dynamic_1401 type = dynamic_1401: md5($u.\nskyper\n.$p) (Skype MD5)
UserFormat = dynamic_1501 type = dynamic_1501: sha1($s.sha1($p)) (Redmine)
UserFormat = dynamic_1502 type = dynamic_1502: sha1(sha1($p).$s) (XenForo SHA-1)
UserFormat = dynamic_1503 type = dynamic_1503: sha256(sha256($p).$s) (XenForo SHA-256)
UserFormat = dynamic_1504 type = dynamic_1504: sha1($s.$p.$s)
UserFormat = dynamic_1505 type = dynamic_1505: md5($p.$s.md5($p.$s))
UserFormat = dynamic_1506 type = dynamic_1506: md5($u.:XDB:.$p) (Oracle 12c "H" hash)
UserFormat = dynamic_1507 type = dynamic_1507: sha1(utf16($const.$p)) (Mcafee master pass)
UserFormat = dynamic_1518 type = dynamic_1518: md5(sha1($p).md5($p).sha1($p))
UserFormat = dynamic_1528 type = dynamic_1528: sha256($s.$p.$s) (Telegram for Android)
UserFormat = dynamic_1529 type = dynamic_1529: sha1($p null_padded_to_len_32) (DeepSound)
UserFormat = dynamic_1550 type = dynamic_1550: md5($u.:mongo:.$p) (MONGODB-CR system hash)
UserFormat = dynamic_1551 type = dynamic_1551: md5($s.$u.(md5($u.:mongo:.$p)) (MONGODB-CR network hash)
UserFormat = dynamic_1552 type = dynamic_1552: md5($s.$u.(md5($u.:mongo:.$p)) (MONGODB-CR network hash)
UserFormat = dynamic_1560 type = dynamic_1560: md5($s.$p.$s2) (SocialEngine)
UserFormat = dynamic_1588 type = dynamic_1588: sha256($s.sha1($p)) (ColdFusion 11)
UserFormat = dynamic_1590 type = dynamic_1590: sha1(utf16be(space_pad_10(uc($s)).$p)) (IBM AS/400 SHA1)
UserFormat = dynamic_1592 type = dynamic_1592: sha1($s.sha1($s.sha1($p))) (wbb3)
UserFormat = dynamic_1600 type = dynamic_1600: sha1($s.utf16le($p)) (Oracle PeopleSoft PS_TOKEN)
UserFormat = dynamic_1602 type = dynamic_1602: sha256(#.$salt.-.$pass) (QAS vas_auth)
UserFormat = dynamic_1608 type = dynamic_1608: sha256(sha256_raw(sha256_raw($p))) (Neo Wallet)
UserFormat = dynamic_2000 type = dynamic_2000: md5($p) (PW > 55 bytes)
UserFormat = dynamic_2001 type = dynamic_2001: md5($p.$s) (joomla) (PW > 23 bytes)
UserFormat = dynamic_2002 type = dynamic_2002: md5(md5($p)) (e107) (PW > 55 bytes)
UserFormat = dynamic_2003 type = dynamic_2003: md5(md5(md5($p))) (PW > 55 bytes)
UserFormat = dynamic_2004 type = dynamic_2004: md5($s.$p) (OSC) (PW > 31 bytes)
UserFormat = dynamic_2005 type = dynamic_2005: md5($s.$p.$s) (PW > 31 bytes)
UserFormat = dynamic_2006 type = dynamic_2006: md5(md5($p).$s) (PW > 55 bytes)
UserFormat = dynamic_2008 type = dynamic_2008: md5(md5($s).$p) (PW > 23 bytes)
UserFormat = dynamic_2009 type = dynamic_2009: md5($s.md5($p)) (salt > 23 bytes)
UserFormat = dynamic_2010 type = dynamic_2010: md5($s.md5($s.$p)) (PW > 32 or salt > 23 bytes)
UserFormat = dynamic_2011 type = dynamic_2011: md5($s.md5($p.$s)) (PW > 32 or salt > 23 bytes)
UserFormat = dynamic_2014 type = dynamic_2014: md5($s.md5($p).$s) (PW > 55 or salt > 11 bytes)

И сравните с Hashcat-ом (последний курит в сторонке по кол-ву поддерживаемых динамических форматов, так же JtR даст прикурить и по другим причинам Hashcat-у, но иногда и наоборот, эти кровавые разборки в отдельной главе (JtR - на хак.сленге "кровотечение").

Придется поверить, что это "технический PR" у Hashcat, не более.
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

Но это ещё не всё.
В своих высказываниях вы неоднократно утверждали, что на Андроиде также можно вполне успешно запускать брутфорс рукопожатий. И несмотря на более скромные ресурсы гаджетов, благодаря каким-то сверхъестественным способностям софта, брутфорс handshake в android имеет место быть )) Что это за программы, откуда их установить и на какие кнопки нажимать ?
Да, успешно и "сверхъестественный" софт - это HSD (разработка от разработчика JtR), он и не требует описания, там GUI все в выпадающем списке есть. Я же "там" подробный скрин прикладывал. И все ссылки на HSD-приложение (+консольные грубые сборки Android) в статье см.
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)

1-е приложение по списку Мобильная лаборатория на Android для тестирования на проникновение

В центре бенчмарк WPA-PSK (без поддержки pmkid - писал почему)
Слева снизу сбрученный пароль от точки атакой по словарю с "коверканьем слов"

Кнопок там "кот наплакал" - немного, осваивать даже ничего не надо. Всё заводиться, как на планшете так и на смартфоне с полпинка.

Вот еще пример: "процесс взлома по цифре длина 8-8" на паршивом гаджете (гораздо слабее, чем "дружок" выше)

John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)


Троиточее в правом верх.углу на скрине "Import" выбираете рукопожатие.cap, выбираете параметры атаки и "play"
John the Ripper 1.9.0-jumbo-1 предпосылки к Tutorial JTR (2019г.)
ps/ Да, консольные сборки в Andrax/Termux не понравились (поддержка тех же 10-и форматов, но потеря производительности существенная по сравнению с HSD-Android).

Хотелось бы услышать что-то о расшифровке wifi рукопожатий в Windows услышать от Вас ))
В сборке для Windows, функционал урезан, что-то там, до нескольких форматов, но wpa-psk поддерживает/криво.
UPD: в сборке JTR 1-9 все норм с wpapcap2john (исправлен).

Прошу прощения за "скрины" у меня под рукой нет машины.
 
Последнее редактирование модератором:
  • Нравится
Реакции: fuzzz и Valkiria
fuzzz

fuzzz

Grey Team
03.02.2019
170
285
Это уже лучше. Однозначно лайк :)
 
R0ckNR0lla

R0ckNR0lla

Member
10.04.2017
7
0
Как раз столкнулся с проблемой, которую может решить только JTR. Ecть несколько запароленых архивов, от которых нужно знать пароль. Перепробовал кучу софта, но большинство из них не подходят по причине отсутствия поддержки нужного формата хеша, или работают крайне сомнительно. Остановился на hashcat и JTR. Hashcat в итоге тоже не подошел, так как работа с форматом pkzip только в тестовом варианте. А вот с JTR нет толкового мануала.
 
Мы в соцсетях:  ТелеграмВконтактеДзенФейсбукТвиттерЮтуб