Основы работы с John the Ripper

Январь 2009
Пн	Вт	Ср	Чт	Пт	Сб	Вс
	1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

Posted by j3qx на 8 января, 2009

Основы работы с John the Ripper

Автор: 1dt.w0lf

Что-то в последнее время мне на почту стали очень часто приходить письма с вопросами про John the Ripper, чтож пора разобраься с этой полезной програмкой. Эта статья конечно предназначена для самых, так сказать, маленьких (не в смысле возраста, а в смысле уровня знаний) и не претендует на роль всеобьемлющего описания программы, но начальные навыки общения с программой надеюсь вам даст. Итак для начала хотелось бы рассказать про файл паролей который вы потом будете запихивать в прогу так как судя по моим наблюдениям больше всего траблов случается именно на этом этапе. Главное в файле паролей это его формат дабы прога поняла что перед ней именно пароли а не отрывок из кулинарной книги =)
Итак обычный файл паролей имеет строки следующего вида:
ig425:DOSTc9unv4FDc:29602:100:fc mvandale:/usr/home/fcmva:/bin/csh
ig425 — имя пользователя (логин)
DOSTc9unv4FDc — пароль зашифрованный в des
29602:100 — номер юзера и рабочей группы в системе
fc mvandale — инфа о пользователе (имя, адрес и т.п.)
/usr/home/fcmva — каталог пользователя
/bin/csh — шелл
Ну вот и разобрались с тем как должен выглядеть файл паролей…
Пример:

michael:rFPoVNWr6Kv6E:408:408:Michael Dillon:/b/michael:/bin/bash
jan:bHUvOYUd8RSHE:504:100:Jan Dicaire:/b/GOLDEN/jan:/bin/bash habbott:*Q6inT7TJCPus2:511:100:Harold R. Abbott:/b/GOLDEN/abbott:/ bin/false jaddison:o77ITMIPlQQXw:513:100:John Addison:/b/addison:/bin/ bash fcarl:!BJwGg36EkJtGQ:515:100:Fred Carlson:/b/carlson:/bin/bash dchamber:*lF8utB4VobAOM:519:100:Dennis Chamberlain:/b/ chamberlain:/bin/false

Теперь запихиваем это дело в какой-нибудь файл типа passwd.txt (вообще можно обозвать файл как душа пожелает) и именно его мы и будем скармливать программе.
Итак наш файл паролей готов, пришло время запускать программу =)
Все действия производим из командной строки. Переходим в папку с программой и запускаем JTR. Запускать можно с разными опциями и параметрами о них я сейчас расскажу:

С самого начала хотелось бы рассказать о том, что с помощью jtr можно подбирать пароли зашифрованные не только в des. Вот список алгоритмов шифрования поддерживаемых программой: DES, BSDI, MD5, BF, AFS, LM. Для того чтобы указать программе на то какой метод следует использовать служит опция format. Например: john -format:DES passwd.txt Но так как наиболее часто прога используется для взлома des то останавливаться подробнее на других методах я не буду.

1. Brute force.
john passwd.txt
Этот способ является самым простым, но он не очень эффективен так как прога начинает перебирать все символы от балды, что естественно очень долго.
2. Перебор по словарю.
john -w:wordlist passwd.txt
wordlist — имя файла словаря со словами для перебора
3. incremental mode
john -i passwd.txt
Самый сильный способ перебора, 95 символов
john -i:alpha passwd.txt
Перебор с использованием 26 символов от ‘a’ до ‘z’
4. Single mode
john -single passwd.txt
Слабенький способ перебора. Быстро подберёт пароли похожие либо совпадающие с логином пользователя. Рекомендую сначала всегда использовать данный способ т.к. он быстрее чем перебор по словарю.

Ну вот запускать немного научились теперь расскажу про опции:
1. Включаем правила:
Перебор для конкретного пользователя
john -w:wordlist -rules -users:0 passwd.txt
0 — uid пользователя в системе
Перебор для пользователей имеющих шелл
john -w:wordlist -rules -shells:sh,bash passwd.txt
После двоеточия перечисляем интересующие нас шеллы.
2. Просмотр подобранных паролей
john -show passwd.txt

Ну вот в принципе немного рассказал. Да ещё во время перебора если нажать на любую кнопку можно посмотреть сколько времени уже прошло, какие пароли перебираются и т.п.
Пример:

E:\>cd jtr
E:\jtr>john passwd.txt
Loaded 604 passwords with 427 different salts (Standard DES [24/32 4K])
guesses: 0 time: 0:00:00:10 32% (1) c/s: 210963 trying: Fcmv4ge0 — 1mfc
guesses: 0 time: 0:00:00:14 37% (1) c/s: 211094 trying: Jfmvanda — Mmvandal
guesses: 0 time: 0:00:00:18 43% (1) c/s: 211032 trying: TheMvand — amyIgnat
guesses: 0 time: 0:00:00:21 49% (1) c/s: 211139 trying: MFCMVA — cff
guesses: 0 time: 0:00:00:33 78% (1) c/s: 211091 trying: raf83 — fcmva87
guesses: 0 time: 0:00:00:39 0% (2) c/s: 205577 trying: xxx — gandalf
guesses: 0 time: 0:00:00:45 2% (2) c/s: 211153 trying: lizard — hawkeye
guesses: 0 time: 0:00:00:50 5% (2) c/s: 212256 trying: Nick — Tigre

Ну а когда перебор закончится можно и посмотреть что там интересного удалось найти =)

E:\>cd jtr
E:\jtr>john -show passwd.txt
panteon:panteon:29602:100:fc mvandale:/usr/home/fcmva:mail,10
jamax:jamax:29602:100:fc mvandale:/usr/home/fcmva:mail,10
quantum:marat:29602:100:fc mvandale:/usr/home/fcmva:mail,10
mitek:mitek:29602:100:fc mvandale:/usr/home/fcmva:mail,10
dilmur:dilmur:29602:100:fc mvandale:/usr/home/fcmva:mail,10
astmot:astmot:29602:100:fc mvandale:/usr/home/fcmva:mail,10
krav520:krav520:29602:100:fc mvandale:/usr/home/fcmva:mail,10
712 passwords cracked, 1008 left

Ну вот на этом и поставим точку. Удачи…

(С) 1dt.w0lf

Вот нашел на одном форуме хороший мануал для новичков
Руководство прилагается в первую очередь для новичков.
JTR — программа для восстановления паролей для UNIX/Win95/NT/DOS систем, но в народе как то повелось использоватьJTR в основном для взлома *nix паролей (для чего он и предназначался в ранних версиях). На NT, большинство юзает l0pht, а на pwl, PWL-tool.
Прежде чем начнем разбираться с самим JTR, давайте остановимся на самих паролях в *nix системах.

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

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

/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, и никаких паролей здесь нет! А то бывали кадры, которые мне говорили, что типа пароли почему то JTR не берет А вот если видим такую ситуацию:

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.

Теперь ты свободно можешь разобрать passwd файл . Но сразу хотелось бы отметить, что на файл в котором находятся пароли в DES (будь то shadow или passwd), права в большинстве случаев дают r——— или r—r——, это значит, что права на чтения есть у root’а и зарегистрированных пользователей (во втором случае r—r——). Так что, через какой-нибудь htmlscript, вряд ли удастся просмотреть, но все таки иногда везет, и получается просмотреть все содержимое .
В Free BSD пароли хранятся в файле /etc/master.passwd , а в остальном технология такая же как и в LINUX, хотя используется более стойкий алгоритм шифрования MD5. В Open BSD, для шифрования используется алгоритм Blowfish.
Ну а теперь о самом JTR и как его заюзать.

Подготовка.

Вопреки о том, что файлом с паролями является чем то жутким и не понятным, можно сказать, что пароли можно засунуть в обычный txt файл . Главное чтобы конструкция была правильная (см. выше). И так, у вас есть что-нибудь типа этого:

root:6xp8Tw7//32×2:0:0:root:/:/bin/bash
michael:Mrd4OyzXJi/.o:500:500::/home/g.giraud:/bin/bash
nick:lreHgxVKYfqiU:501:501::/home/pages_web:/bin/bash
melisa:sDci0pnsqhhE6:502:502::/home/informix:/bin/bash
johnsonX9gnmqBDSQ/o:506:/home/pages_web:/bin/bash
dacosta:rGTGPVqn/AhuU:507:/home/pages_web:/bin/bash
…

Сохраняем все это дело в каком-нибудь файле типа passwd.txt, или просто passwd. Этот файл как раз и будет то, что надо сунуть JTR. Далее переходим в папку с JTR, и находим там файл john.exe, в эту же папку ложем наш passwd файл. Далее идем в «DOS Prompt» («Режим DOS», не просто по john.exe щелкаем 2 раза, а именно идем в «Режим DOS», далее командой:

cd c:\jtr\

заходим в папку где лежит JTR. Теперь можно запускать JTR . Запускаться все может в разных режимах и с разными параметрами о которых я сейчас и постараюсь рассказать. Данные примеры рассматриваются для пользователей с системами win95/95/NT, для *nix в принципе все опции и параметры идентичны.

Режимы.

1. Самый простой способ, это запустить JTR в режиме «Brute force»:
john passwd
(Я в дальнейшем буду использовать passwd как имя файла с паролями, но как я уже и сказал, имя и формат файла может быть практически любым)
Данный способ является самым простым, и не очень эффективным, так как JTR начинает перебирать все символы от фонаря, что конечно очень долго… хотя многое зависит от мощности вашего компьютера и от сложности пароля. Пароль типа «dk9LDs)p1» еще твои правнуки будут доламывать

2. Перебор по словарю:
john -w:wordlist passwd
где wordfile — имя файла со словарем. Также можно и так:
john -w:wordlist -rules passwd
-rules, включает правила синтаксиса для словаря. С вариантом по словарю, пароли подбираются на много быстрее чем в варианте с «Brute force». По-моему, самый лучший и эффективный способ.

3. incremental mode
john -i passwd
Авторы JTR говорят, что это самый сильный способ перебора, 95 символов. А вот таким способом:
john -i:alpha passwd
JTR перепробует 26 символов, от «a», до «zzzzzzzz». Если с wordlist не получилось, советую запускать данный способ.

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

Опции.

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

1. Перебор для конкретного пользователя:
john -w:wordlist -rules -users:0 passwd
Перебирает пароль к конкретному пользователю (в нашем случае root). Что бы указать пользователя, надо после «:» указать UID (номер пользователя в системе).

2. Смотрим подобранные пароли.
john -show passwd
Показывает уже подобранные пароли, в указанном файле.

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

4. Люблю shells .
john -w:wordlist -rules -shells:sh,csh,tcsh,bash passwd
В данном случае, будут перебираться только те пользователи, которые имеют указанные в вышеприведенном примере shell’ы.

5. Несколько passwd файлов.
Если у вас есть несколько файлов с паролями в DES, то их можно всех вместе поставить на расшифровку данным способом:
john -single passwd passwd1 passwd2
Количество файлов по-моему не ограничено . Способ с несколькими файлами, работает на всех режимах и опциях, просто укажите имена файлов в конце (как в примере).

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

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

========================================
[]acid[] [GiN]

—

вот еще нашел поэтой же теме сосотоит из нескольких частей щас выложу первую часть..если интересно…будет вам то постите тут свои ответы выложу..дальше если нет..то закроем эту тему…хотя я думаю это интересно должно быть тому сообществу что тусуется здесь
1. Сам JohnTheRipper. Лучше взять последнюю версию 1.6.31 с http://www.openwall.com/john/
Откомпилировать ее с помощью CYGWin для Win32 платформы или DjGPP для DOS.
Практика показала что новая версия работает быстрее «классики» 1.6
2. Хороший компьютер, а лучше несколько. Речь идет минимум о 800МГц. К примеру,
PentiumIII 500 перебирает все комбинации из прописных букв длиной 7-8 символов
в течении 150 дней. И все еще никак не переберет =) Athlon’ы, кстати, демонстриуют
великолепные результаты.
3. Хороший wordlist и инструмент для его преобразования. У меня это Perl. Он может
сделать все что нам необходимо.

Теперь немного теории. Перебрать все варианты паролей в приемлимое время
практически невозможно. Значит, надо найти наибольшее число паролей за минимальное
время. Я хочу донести до вас свой опыт как это сделать наиболее оптимально и получить
в итоге примерно такой результат.
31667 passwords cracked, 5652 left

Итак.

Часть первая. Single

Первый и самый быстрый способ перебора это
john -single pass.txt
И тому есть несколько причин. Самая веская это та, что john при переборе использует
в качестве словаря логины. И их очень мало по сравнению с количеством слов в вордлисте.
Значит к ним можно применить более сложные и ресурсоемкие правила. С них то мы
и начнем. Для этого нам потребуется отредактировать файл настроек john.ini
Найдем секцию [List.Rules:Single]
Откорректируем некоторые правила по отношении к оригинальному конфигу.
Было Стало
<*l$[1-9!0a-z»-/:-@\[-`{-~] <*l$[0-9a-z]
<*(?ac$[1-9!0a-z»-/:-@\[-`{-~] <*(?ac$[0-90a-z]
<*lr$[1-9!] <*lr$[0-9]
<*/?au$[1-9!] <*/?au$[0-9]
l^[1a-z2-90A-Z»-/:-@\[-`{-~] l^[1a-z0-9A-Z]
<-!?Alp^[240-9] <-!?Alp^[0-9]
>3(?a[lc]i[12]. удалить
<-l^!$! удалить
….. удалить
<-l^»$» удалить

После строчки
# Uncomment the following lines if you’re really crazy
раскомментировать «тяжелые» правила.

Теперь можно добавить несколько новых правил.
1.Правила вращения(сдвига)
}
]
]}
]]
]]}
]]]
]]]}
]]]]
#Сдвиги, более 7 имеет смысл делать только при наличии логинов длинее 8 символов
]]]]}
]]]]]
]]]]]}
]]]]]]
]]]]]]}

{
[
[{
[[
[[{
[[[
[[[{
[[[[

[[[[{
[[[[[
[[[[[{
[[[[[[
[[[[[[{

2.Правила замены
Выглядят как
sAB
sAC
sAD
sAE
..
sZX
sZY

sab
sac
..
szx
szy

s01
s02
..
s97
s98
s90

sa0
s0a
sa1
s1a
..
sz8
s8z
sz9
s9z

sA0
s0A
sA1
s1A
..
sZ9
s9Z

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

Код:

open(F,'>single'); 
for($a=ord('A');$a<=ord('Z');$a++) 
{ 
for($a1=ord('A');$a1<=ord('Z');$a1++) 
{ 
if($a ne $a1) 
{ 
print F "s",chr($a),chr($a1),"\n"; 
} 
} 
} 
for($a=ord('a');$a<=ord('z');$a++) 
{ 
for($a1=ord('a');$a1<=ord('z');$a1++) 
{ 
if($a ne $a1) 
{ 
print F "s",chr($a),chr($a1),"\n"; 
} 
} 
} 
for($a=ord('0');$a<=ord('9');$a++) 
{ 
for($a1=ord('0');$a1<=ord('9');$a1++) 
{ 
if($a ne $a1) 
{ 
print F "s",chr($a),chr($a1),"\n"; 
} 
} 
} 
for($i=ord('a');$i<=ord('z');$i++) 
{ 
for($j=0;$j<10;$j++) 
{ 
print F "s",chr($i),$j,"\n"; 
print F "s",$j,chr($i),"\n"; 
} 
} 
for($i=ord('A');$i<=ord('Z');$i++) 
{ 
for($j=0;$j<10;$j++) 
{ 
print F "s",chr($i),$j,"\n"; 
print F "s",$j,chr($i),"\n"; 
} 
} 
close F;

Теперь, вставим получившийся файл в секцию[List.Rules:Single] и запустим
john -single pass.txt

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

Часть вторая MyVeryBigWordList

Прежде чем приступить к
john -w:wordlist.txt pass.txt
надо создать сам wordlist.txt. Причем, лучше всего собрать все доступные вам
ворд и комбо-листы и сделать из них один вордлист без дубликатов. Наверняка для
этого можно использовать какие-то программы, но я опять все делаю на перле.
Вот пример, как объединить два листа в один ворд-лист без дублей.

open(F,»list1.lst»;
while (defined($a=<F> ))
{
chomp($a);
$k{$a}=1;
}
close F;

open(F,»list2.lst»;
while (defined($a=<F> ))
{
chomp($a);
$k{$a}=2;
}
close F;

open(F,»>full.lst»;
foreach (sort keys(%k))
{
print F $_,»\n»;
}
close F;

К примеру, у меня вордлист содержит ~770.000 слов и занимает около 7Мб.

Теперь можно смело запускать
john -w:wordlist.txt pass.txt
и ждать результатов. Если режим single у меня отработал за 2 минуты, то режим
wordlist уже около 2-х часов. Правда это сильно зависит от количества salt’ов,
но об этом позже.

Если это кому-то интересно, то дальше последуют:
-rules (Какие правила самые рульные)
-external mode (Пишем свои переборщики)
-salt (Солить все или частями)
-makechars (Сделаем свои собственные наборы символов)
-stat (Статистка — сильная штука)
-combo (Комбинируем популярности)

*******************************
Автор статей про JTR vvv476 по материалам сайта http://www.pass.mirroz.com/

—

ок продолжаем
Теперь поговорим о salt (в переводе соль). Что это такое? Разработчики кодирования
паролей применили простую, и в тоже время эффективную, систему, усложняющую перебор.
Каждый пароль кодируется функцией в набор символов, и каждому паролю соответствует
свой набор. Но тогда возможно создание базы данных готовых закодированных паролей.
К примеру, если слово «password» превращается в fB0JwUA7Csg , то можно было бы
заранее это просчитать и когда потребовалось бы применить перебор, он заключался
бы в простом сравнении строчек. Без использования сложной функции crypt().
Тогда разработчики ввели понятие salt. В жизни, это первые 2 символа закодированного
пароля 14idcMbSCy2Bs — здесь это «14». Эти символы при кодировании пароля устанавливаются
случайным образом. И они являются дополнительным крипто-ключом. То есть, сначала
пароль кодируется в fB0JwUA7Csg. Потом выбирается случайный salt. После, на его
основе, пароль опять кодируется в нечто MMQ/V0/jwofG. А это уже не то, что можно
было бы предвычислить. Потому как на одно слово «password» мы должны будем
предрасчитать все возможные кодировки при различных salt. А их очень много.
Если взять только буквы(большие и маленькие) и цифры, то (26+26+10)^2=3844 варианта
того, как пароль «password» может быть закодирован.

Какой следует сделать вывод?
Такой, что чем больше различных salts имеется в файле паролей, тем дольше и тяжелее
будет идти перебор. JTR говорит о количестве salts при загрузке.
Loaded 13018 passwords with 3491 different salts
В данном случае перебор идет значительно дольше, чем мог бы.

Мог бы? Да, если окажется, что в файле паролей есть много паролей с одинаковым
salt. Некоторые администраторы устанавливают значение salt не случайным образом,
а константой, тем самым облегчая нам задачу.
Кстати, замечено, что все CCBill.log’овские пароли кодируются с количеством разных
salts равным 91. Они используют только цифры и не начинают с 0. Такое количество
salts весьма приемлимо для сложных подборов.

А теперь маленький скрипт, который поможет подсчитать количество salts в вашем файле
и вывести самые популярные в отдельный файл.
Насчет того, что некоторые перл не знают, скажу следующее. Его знать почти и не надо.
Установите его себе на машину, сделайте так, что бы файлы с расширением *.pl
обрабатывались как c:\perl\bin\perl !.! И все. Скопировали скрипт в файл.
Изменили очевидные имена файлов на свои. Ентер в фаре на нем и он работает!

#Здесь укажите имя файла с паролями
open(F,’htpasswd.txt’);
while(defined($a=<F> ))
{
if($a=~/^(.+?).+)/)
{
$b=$2;
$b=substr($b,0,2);
$k{$b}++;
}
}
close F;

#Файл saltstat.txt будет содержать статистику по salts
open(O,’>saltstat.txt’);
foreach (reverse sort{$k{$a}<=>$k{$b] (keys %k))
{
print O $_,» — «,$k{$_},»\n»;
}
close O;

#В файл salt.txt попадут пароли с наиболее популярными salts
open(O,’>salt.txt’);

#Здесь укажите имя файла с паролями
open(F,’htpasswd.txt’);
while(defined($a=<F> ))
{
if($a=~/^(.+?).+)/)
{
$b=$2;
$b=substr($b,0,2);
#Здесь указывается какие именно salt’ы нас интересуют
#В примере это ‘aa’,’Md’,’TR’,’ma’
if($b eq ‘aa’ || $b eq ‘Md’ || $b eq ‘TR’ || $b eq ‘ma’)
{
print O $a;
}
}
}
close F;
close O;

Запустите скрипт. Посмотрите статистику. Исправьте скрипт так, что бы он выделил
в отдельный salt.txt необходимые вам пароли.

Все это нужно, для того, что бы как можно быстрее провести перебор. Если не на
полной базе паролей, то хотя бы на ее части.
Статистика — без нее никуда. Часть четвертая.

Прежде чем двигаться дальше, надо понять какие пароли используются чаще всего
и как нам сузить диапазон полного перебора.
Предположим, что мы работаем с паролями длиной от 6 до 8 символов, содержащих
символы от a до z, от A до Z, от 0 до 9.
Пароли меньшей длины вполне реально перебрать и так.

В таблице первая колонка I — относительная эффективность перебора
Вторая IIa — маска перебора + IIb — число паролей такого типа уже найденные
Последняя III — мощность перебора в миллионах вариантов.

Колонка I = III*1.000.000 / IIa и означает сколько пустых переборов
приходится на один найденный пароль.

IIa — или маска состоит из условных обозначений
a = любой символ от a до z
0 = любой символ от 0 до 9
A = любой символ от A до Z

Вот какая картина нам представляется.

И это очень многое проясняет. Например, теперь понятно каким должен быть наш
собственный пароль, чтоб его не подобрали такие же ушлые как мы =)

Но самое главное, теперь можно приступать к изучению и применению правил (-rules)
и своих переборщиков (-external)

продолжение следует )

Часть пятая — последовательные переборы.

Согласно статистике из 4-й части можно приступать к целевым переборам.
Первое место по плотности паролей занимают пароли из 6-ти цифр
|663 | 000000-1508 | 1
Миллион вариантов. Очень удобно засечь время исполнения перебора этого миллиона
что бы представлять себе сложность других методов.

Заглянем в файл настроек JTR и найдем секцию последовательных переборов цифр
[Incrementaligits]
File = digits.chr
MinLen = 1
MaxLen = 8
CharCount = 10

Здесь написано
имя файла *.chr, скомпилированого специальным образом и содержащего только цифры
Минимальная и максимальная длина подбираемого пароля
Количество уникальных символов. У арабов их 10 =)

Давайте подправим MinLen = 6 и MaxLen = 6 и запустим
john -i:digits pass.txt
Пошел перебор. Нажатием Enter’a можно видеть какие именно пароли пытаются быть
подобранными. Это очень удобно проверять себя, правильно ли мы все написали.

Если перебор длится долго или не приносит результатов(неэффективный метод),
его можно прервать что бы продолжить позже. Я делаю это так.
Ctrl+C прервет программу. Появится файл restore. Если я прервался что бы
продолжить дальше этим же способом, то просто позже я запущу john -restore
Если я буду менять метод, то файл restore переименую в что-то типа r6digital,
а когда понадобится вернуться к этому методу, то переименую его обратно в restore
И снова john -restore.
Только не забудьте вот что. Если вы начали перебор 6 цифр, прервали, сохранили
restore, изменили MinLen = MaxLen = 7, начали перебор 7-ми цифр, прервали,
захотелось вернуться к 6-ти, вернули старый 6-ти циферный restore, не забудьте
исправить MinLen = MaxLen = 6. А то JTR сам этого делать не умеет.

Смотрим статистику дальше. Перебор из 7-ми цифр на 4 месте по оптимальности, но
уже в 10 раз дольше. Вспоминаем сколько было времени затрачено на 6-ти цифрах и
прикидываем, реально ли нам сейчас перебирать 7 или пора идти обходными путями?

Предположим, что бы закрыть тему окончательно, у нас все «летает», мы обсчитываем
всего пару salt’ов, поэтому можем себе позволить немного по Incremental’ить.

А что там у нас с буквами?
| 70432 | aaaaaa-4386 | 308
Полный перебор из 6-ти за 308 миллионов, какой ужас! Но здесь один плюс. Дело в
том что спец файлы *.chr создавались на основе реальных паролей. Мы, кстати,
тоже будем создавать свой, но позже. Так вот, при их создании учитывается частота
появления каждого символа в паролях, и эти символы сортируются соответствующим
образом. Значит, JTR будет перебирать символы, начиная с самых популярных и это
очень эффективно. Буквально в первые же минуты JTR найдет несколько паролей если
мы напишем в его конфиге
[Incremental:Alpha]
File = alpha.chr
MinLen = 6
MaxLen = 6
CharCount = 26

и запустим
john -i:alpha pass.txt
Правда, потом скорость нахождения будет падать, и когда совсем станет скучно —
прерывайте этот метод.

Я думаю к этому моменту всем понятно как работают последовательные переборы.
Но есть один нюанс. В поставке JTR идет еще all.chr — перебор всех возможных
символов. Дело в том, что в этом наборе есть символы $#%@! и прочие, которые
реально почти никогда не используются. И к тому же, не плохо было бы иметь более
короткие наборы символов. Например, огромная масса паролей состоит только из символов
[a-z 0-9]. Также, хотелось бы иметь набор, состоящий только из больших букв A-Z
или их же, но с цифрами. Вообщем, мы вплотную подошли к теме создания своих
собственных наборов.

Часть шестая (makechars)

Прежде чем создать свой набор надо в файле конфигурации настроить фильтр.
Находим такую секцию
[List.External:Filter_Alpha]
void filter()
{
int i, c;

i = 0;
while (c = word[i++])
if (c < ‘a’ || c > ‘z’) {
word = 0; return;
}
}
На Си-подобном языке здесь описывается создание фильтра, который отсекает все
символы невходящие в диапазон a-z, а пропускает только буквы. Преобразуем это
таким образом, что бы он пропускал еще и цифры.
[List.External:Filter_AD]
void filter()
{
int i, c;

i = 0;
while (c = word[i++])
if ( !((c>=’a’ && c<=’z’) || (c>=’0′ && c<=’9′) ) )
{
word = 0; return;
}
}

Теперь возьмем самый большой pass.txt с наибольшим количеством раскодированных
паролей и дадим такую команду
john.exe -makechars:aldi.chr -e:Filter_AD bigpass.txt

В результате получим

Loaded 30248 plaintexts
Generating charsets… 1 2 3 4 5 6 7 8 DONE
Generating cracking order… DONE
Successfully written charset file: aldi.chr (36 characters)

Обратите внимание на строчку «(36 characters)». JTR нашел через фильтр 36 символов.
Это правильно, так как 26 символов алфавита + 10 цифр. Но может так случится, что
JTR не найдет какой-нибудь редкий символ (у меня так случилось с буквой «Q».
Об этом можно узнать увидев что финальное число символов меньше предполагаемого.

Итак, мы получили файл aldi.chr, содержащий 36 символов (маленькие буквы и цифры)
Теперь надо в файл конфигурации добавить его описание

[Incremental:AlDi]
File = aldi.chr
MinLen = 1
MaxLen = 5
CharCount = 36

И его уже можно использовать как
john -i:aldi pass.txt

Его можно вполне эффективно использовать для подбора. И конечно он гораздо лучше
чем all.chr

Таким же образом можно создать наборы для [A-Z], [a-zA-Z], [A-Z0-9], [a-zA-Z0-9]
Но я считаю что aldi.chr самый эффективный.

*********************************************
эту статью я взял у vvv476 …….

Вернемся к нашей любимой статистике и посмотрим кто стоит на втором месте по
оптимальности
| 22837 aa0000-296 6
Две буквы + 4 цифры, 6 миллионов комбинаций.
Как же нам сделать такой перебор? В JTR все предусмотрено.
Только придется немножко попрограммировать. Кого тошнит от этого, могут
воспользоваться ниже приведенным куском, корректируя его под свои потребности.

Итак, пишем это в файле конфигурации JTR. Знак # — комментарии

#После слов List.External: идет название метода, я использую здесь маску перебора [List.External:aa0000]

#Инициализационная часть, выполняется только один раз при старте
void init()
{
#Идет начальное определение массива word = «aa0000», в конце символ окончания
#строки = 0
word[0] = ‘a’;
word[1] = ‘a’;
word[2] = ‘0’;
word[3] = ‘0’;
word[4] = ‘0’;
word[5] = ‘0’;
word[6] = 0;
}

#Функция генерации
void generate()
{
#Инициализация индекса, начинаем перебор с последнего символа word[5]
int i;
i = 5;
#До тех пор, пока значение символа по текущему индексу превышает предел ‘9’
#То есть, если не превышает, выход из функции для того чтобы JTR попробовал
#получившуюся комбинацию.
#А если превышает, значит надо увеличивать следующий разряд
while (++word>’9′)
{
#Если индекс еще «работает» с цифрами, то сбросить переполненный разряд и перейти к следующему
if (i>2) word[i—] = ‘0’;
#Иначе, уже пошли буквы
else
{
#Сбросим все-таки последнюю старшую цифру
word[2] = ‘0’;
#Попробуем увеличить первую букву
if (++word[1]>’z’)
{
#Если она достигла предела, то сбросим ее и займемся второй буквой
word[1] = ‘a’;
#Если и вторая буква подошла к концу, закончим перебор сбросив все слово
if(++word[0]>’z’) word = 0;
}
#Возврат из функции, что бы не крутится в первом цикле while не попробовав
#новую комбинацию
return;
}
}
}

Теперь пишем команду
john -e:aa0000 pass.txt
и ждем. Неплохо также понажимать на Enter что бы убедиться что перебор мы
написали правильно и генерятся нужные комбинации.

Сложно? На первый взгляд — да. А что делать? Если не хотите сами все придумывать,
я приведу пример для другой маски «0000aa». Эти две маски, являются наиболее
популярными, используйте их, а про остальное — забудьте =)
Те же, кто все понял, наверняка теперь будут способны написать свой переборщик.
[List.External:0000aa]

void init()
{
word[0] = ‘0’;
word[1] = ‘0’;
word[2] = ‘0’;
word[3] = ‘0’;
word[4] = ‘a’;
word[5] = ‘a’;
word[6] = 0;
}

void generate()
{
int i;
i = 3;
while (++word>’9′)
{
if (i) word[i—] = ‘0’;
else
{
word[0] = ‘0’;
if (++word[5]>’z’)
{
word[5] = ‘a’;
if(++word[4]>’z’) word = 0;
}
return;
}
}
}
Несмотря на вышеописанные методики и статистики, опыты показывают, что работа
с вордлистом дает очень хорошие результаты. И помогают нам в это правила
преобразования слов, заложенные в самом JTR. Впрочем, иногда их не хватает, и тогда
к нам на помощь придет перл. Правил очень много и когда перебор длится слишком
долго хотелось бы отобрать среди них только лучшие. Вот о них то я и поведаю.

Для начала, попробуем в фале конфигурации написать примерно следующее [List.Rules:Wordlist]
#Нижеследующая команда «:» говорит об отсутствии преобразования над словом
#То есть если вы уже запускали john -w:wordlist pass.txt, то ее надо
#закоментировать, что б одно и тоже не гонять.
:
#CraCk -> crack
-c >3!?XlQ
#Crack -> CRACK
-c >2!?XuQ
#crack -> Crack
-c >2(?a!?XcQ
#fred -> fredfred
<7>1!?Ald

Теперь можно запустить john -w:wordlist.txt -rules pass.txt

Обратите внимание что секция[List.Rules:Wordlist] в файле должна быть только
одна. Я, например, делаю так
[List.Rules:Wordlist0]
какие-то правила [List.Rules:Wordlist1]
какие-то правила [List.Rules:Wordlist2]
какие-то правила [List.Rules:Wordlist3]
какие-то правила

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

Как ни странно, самыми эффективными оказываются очень простые правила.
Например
[List.Rules:Wordlist]
#После слова добавить символ из диапазона 0-9, то есть сначала 0, потом 1 и т.д.
$[0-9]
#То же, но букву
$[a-z]
#Перед словом добавить символ из диапазона 0-9
^[0-9]
#То же, но букву
^[a-z]

Теперь займемся оптимизацией. Написанный таким образом перебор отработает
(10+26+10+26)*(число слов в словаре) раз. Это может быть немало по времени.
Практика показывает что если расположить правила в другом порядке, то пароли
будут находиться быстрее
$[0-9]
$[a-z]
^[a-z]
^[0-9]
А все ли цифры и буквы одинаковы по своей популярности? Нет. Опять же статистика
подсказывает что частота появления символов сильно различается.
Вот так выглядят цифры, лучшие — раньше
1928037645
Вот так буквы, если они в конце слова
seadirmfholztgxynbjkpuvcwq
И вот так буквы, если они идут сначала
smcdtphfkweobarjglnivyzuxq

Итого, правильным было бы записать наш перебор как
$[1928037645]
$[seadirmfholztgxynbjkpuvcwq]
^[smcdtphfkweobarjglnivyzuxq]
^[1928037645]

Но и это еще не все. Если мы перебираем слова из вордлиста, то там могут оказаться
заведомо несуществующие комбинации. Как критерий — по длине. Пароль не может быть длинее
8 символов, а в случае какого-нибудь CCBill’a — короче 6. Значит надо ограничить
выборку.
Команда «<число» заставляет брать только те слова, длина которых менее «число» символов.
Команда «>число» соответственно только более.
Значит нам нужна команда, отбирающая слова из диапазона от 5 до 7 символов.
Потому что мы к слову будем прибавлять по одному символу и в результате будем иметь
длину от 6 до 8.
Вот эта команда «<8>4»

Итого

<8>4$[1928037645]
<8>4$[seadirmfholztgxynbjkpuvcwq]
<8>4^[smcdtphfkweobarjglnivyzuxq]
<8>4^[1928037645]

Идем дальше

Хорошие результаты получаются при следующих переборах

#Любимые 2 цифры [List.Rules:Wordlist1]
$6$9
$1$2
$1$1

#Сдвиг [List.Rules:Wordlist2]
}
]
]}
]]
]]}
]]]
]]]}
]]]]

#Любимые три цифры [List.Rules:Wordlist3]
$1$2$3
$1$0$0
$0$0$7
$6$6$6
$1$0$1
$0$0$1
^7^0^0
$1$1$1
$9$9$9

#Любимые 4 цифры или мой год рожденья [List.Rules:Wordlist4]
$1$2$3$4
$2$0$0$[0-2]
$1$9$9$[0-9]
$1$9$8$[0-9]
$1$9$7$[0-9]
$1$9$6$[0-9]
$1$9$5$[0-9]
$1$9$4$[0-9]

#А нам все равно какие 2 цифры у вас в конце
#Перебор соптимизирован по частоте появления таких комбинаций
#Кратко он записывается как $[0-9]$[0-9] [List.Rules:Wordlist6]
$0$[01234689]
$1$[01234689]
$7$[02345678]
$6$[345689]
$2$[01234]
$5$[0452]
$3$[1379]
$9$[1359]
$4$[359]
$8$[81]

$0$[57]
$7$[19]
$1$[57]
$6$[0127]
$2$[56789]
$5$[136789]
$3$[024568]
$9$[024678]
$4$[0124678]
$8$[02345679]
[List.Rules:Wordlist5]
$[a-z]$[0-9]
^[a-z]$[0-9]
^[0-9]$[a-z]
^[0-9]^[a-z]

#А нам все равно какие 2 буквы у вас в конце [List.Rules:Wordlist7]
$[seadirmfholztgxynbjkpuvcwq]$s
$[seadirmfholztgxynbjkpuvcwq]$e
$[seadirmfholztgxynbjkpuvcwq]$a
$[seadirmfholztgxynbjkpuvcwq]$d
$[seadirmfholztgxynbjkpuvcwq]$i
$[seadirmfholztgxynbjkpuvcwq]$r
$[seadirmfholztgxynbjkpuvcwq]$m
$[seadirmfholztgxynbjkpuvcwq]$f
$[seadirmfholztgxynbjkpuvcwq]$h
$[seadirmfholztgxynbjkpuvcwq]$o
$[seadirmfholztgxynbjkpuvcwq]$l
$[seadirmfholztgxynbjkpuvcwq]$z
$[seadirmfholztgxynbjkpuvcwq]$t
$[seadirmfholztgxynbjkpuvcwq]$g
$[seadirmfholztgxynbjkpuvcwq]$x
$[seadirmfholztgxynbjkpuvcwq]$y
$[seadirmfholztgxynbjkpuvcwq]$n
$[seadirmfholztgxynbjkpuvcwq]$b
$[seadirmfholztgxynbjkpuvcwq]$j
$[seadirmfholztgxynbjkpuvcwq]$k
$[seadirmfholztgxynbjkpuvcwq]$p
$[seadirmfholztgxynbjkpuvcwq]$u
$[seadirmfholztgxynbjkpuvcwq]$v
$[seadirmfholztgxynbjkpuvcwq]$c
$[seadirmfholztgxynbjkpuvcwq]$w
$[seadirmfholztgxynbjkpuvcwq]$q

#А нам все равно какие 2 буквы в начале [List.Rules:Wordlist8]

^[smcdtphfkweobarjglnivyzuxq]^s
^[smcdtphfkweobarjglnivyzuxq]^m
^[smcdtphfkweobarjglnivyzuxq]^c
^[smcdtphfkweobarjglnivyzuxq]^d
^[smcdtphfkweobarjglnivyzuxq]^t
^[smcdtphfkweobarjglnivyzuxq]^p
^[smcdtphfkweobarjglnivyzuxq]^h
^[smcdtphfkweobarjglnivyzuxq]^f
^[smcdtphfkweobarjglnivyzuxq]^k
^[smcdtphfkweobarjglnivyzuxq]^w
^[smcdtphfkweobarjglnivyzuxq]^e
^[smcdtphfkweobarjglnivyzuxq]^o
^[smcdtphfkweobarjglnivyzuxq]^b
^[smcdtphfkweobarjglnivyzuxq]^a
^[smcdtphfkweobarjglnivyzuxq]^r
^[smcdtphfkweobarjglnivyzuxq]^j
^[smcdtphfkweobarjglnivyzuxq]^g
^[smcdtphfkweobarjglnivyzuxq]^l
^[smcdtphfkweobarjglnivyzuxq]^n
^[smcdtphfkweobarjglnivyzuxq]^i
^[smcdtphfkweobarjglnivyzuxq]^v
^[smcdtphfkweobarjglnivyzuxq]^y
^[smcdtphfkweobarjglnivyzuxq]^z
^[smcdtphfkweobarjglnivyzuxq]^u
^[smcdtphfkweobarjglnivyzuxq]^x
^[smcdtphfkweobarjglnivyzuxq]^q

Вот примерно с чем можно работать и весьма продуктивно.
Но есть одна пробема, например в вордлисте есть такие слова-пароли
passwd1
passwd3
passwd9
Значит слово passwd с цифрой на конце весьма популярно.
Но нашими вышеописанными переборами мы не сможем перебрать все passwd[0-9]
У нас получатся passwd1[0-9] passwd3[0-9], что тоже не плохо но не покрывает
всего спектра.
Как решить задачу отсечения чисел от слова, что бы попробовать использовать
другие числа.

Пусть слово будет «passwd1» и нам надо перебрать «passwd» плюс числа от 0 до 9

Тогда, в правилах мы напишем нечто
[List.Rules:Wordlist]
@?Al$[0-9]

Эта абракадабра расшифровывается согласно файлу DOC\rules из поставки JTR как
@?A — удалить все символы принадлежащие определенному классу символов
Класс символов «a» — означает все символы из диапазона a-z
Класс символов «A» — означает все символы кроме диапазона a-z
То есть удаляем все не a-z символы
Команда l заставляет перевести слово в нижний регистр (CraCk->crack)
И после добавляем цифры $[0-9]

Недостатком такого подхода является излишний перебор при наличии в исходном
ворд-листе таких слов как «passwd1″,»Passwd2». После применения к нему правила
получится одно и тоже базовое слово «passwd». Таким образом JTR будет делать 2
раза одно и тоже.

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

Часть девятая. Лучшие из лучших.

Зададимся целью составить набор слов (или их обрывков) отсортированных в
порядке убывания частоты встречаемости.

Я поступил следующим образом.
В директорию single положил все имеющиеся у меня листы со словами,
в директорию combos — все комбо-листы и запустил следующий скрипт.

@files=(
‘combo1.txt’,
‘combo2.txt’,
‘combo3.txt’,
# и так далее
);

@f=(
‘SINGLE_0.TXT’,
‘SINGLE_1.TXT’,
‘SINGLE_2.TXT’,
# и так далее
);

open(L,’>total.log’);
foreach (@files)
{
print ;
print L $_;
open(F,’combos\’.$_);
open(O,’>bad\’.$_.’.bad’);
my $count=0,$pass=0;
while(defined($a=<F> ))
{
chomp($a);
$a=~s/ //g;
$a=~s/\t//g;
while($a=~s/::/:/g) {}
if($a=~/^(.+?).+)/)
{
$l=$1;
$p=$2;
if(length($l)<2 || $l=~/\@/ || length($l)==13) {}
else
{
if(length($l)>8) {$l=substr($l,0,8);}
$k{$l}++;
$pass++;
}

if(length($p)<2 || $p=~/\@/ || length($p)==13) {}
else
{
if(length($p)>8) {$p=substr($p,0,8);}
$k{$p}++;
$pass++;
}
}
else
{
if(length($a)) {print O $a,»\n»;}
}
$count++;
}
close O;
close F;
print ‘…words:’,$pass,’ lines:’,$count,»\n»;
print L ‘…words:’,$pass,’ lines:’,$count,»\n»;
}

foreach (@f)
{
print ;
print L $_;
open(F,’single\’.$_);
open(O,’>bad\’.$_.’.bad’);
my $count=0,$pass=0;
while(defined($a=<F> ))
{
chomp($a);
$a=~s/ //g;
$a=~s/\t//g;
$a=~s/^\-//;
if($a=~/^(.+?)/)
{
$l=$a;
if(length($l)<2 || length($l)==13) {#if(length($l)>=2) {print O $l,»\n»;}
}
else
{
if(length($l)>8) {$l=substr($l,0,8);}
$k{$l}++;
$pass++;
}
}
else
{
if(length($a)) {print O $a,»\n»;}
}
$count++;
}
close O;
close F;
print ‘…words:’,$pass,’ lines:’,$count,»\n»;
print L ‘…words:’,$pass,’ lines:’,$count,»\n»;
}
close L;

print «Dumping…\n»;
open (O,»>total.lst»;
open (O0,»>total0.lst»;
open (B,»>bad.lst»;
foreach (reverse sort{$k{$a}<=>$k{$b] keys %k)
{
$a=$_;
if($a=~/[\!\»\#\$\%\&’\*\+\,\-\.\/\;\<\=\>\?\[\\\]\^\_\{\|\}\~\`\:]/)
{
print B $_,»\n»;
}
else
{
print O $k{$a},’ ‘,$a,»\n»;
print O0 $a,»\n»;
}
}
close B;
close O;

В результате получим файлы
total.log — контроль за обработанными файлами
bad.lst — лист с паролями, включающие в себя редкие символы
total.lst — лист с паролями и частотой их встречаемости

Вот его начало к примеру

10688 123456
10232 1234
9761 password
8420 pussy
6142 qwerty
5609 sex
5464 fuck
5333 12345678
5305 master
5262 test
4872 12345
4539 john
4522 love
4455 dick

И total0.lst — тоже самое, только без частоты.

Теперь запустим еще один скрипт best.pl с двумя параметрами.
Первый определяет длину отбираемых слов, второй — нижний порог частоты встречаемости
Например так
perl bestfull.pl 3 100

==============
my $lf=$ARGV[0];
my $limit=$ARGV[1];
my %bestword;
my $pass=0;

open(F,’total.lst’);
while(defined($a=<F> ))
{
chomp($a);
$a=~/(\d+) (.+)/;
$kf=$1;
$a=$2;
my $l=length($a);
if($l>2)
{
$a=lc($a);
{
$pass++;
if($pass%10000==0) {print $pass.»\n»;}

if($a=~/[a-z]/)
{
my $b=$a;
$b=~s/\d//g;
my $lb=length($b);
my $i;
for($i=0;$i<$lb-1;$i++)
{
my $c=substr($b,$i,$lf);
my $lc=length($c);
if($lc==$lf) {$bestword{$c}+=$kf;}
}
}
}
}
}
close F;

print «Done\n»;

open(F,»>bestword$lf.lst»;
open(O,»>bestword$lf».»stat.lst»;
open(P,»>poorword$lf.lst»;
foreach (reverse sort{$bestword{$a}<=>$bestword{$b] keys %bestword)
{
if($bestword{$_}>$limit)
{
print O sprintf(«%-9s»,$_),’ : ‘,$bestword{$_},»\n»;
print F $_,»\n»;
}
else
{
print P $_,»\n»;
}
}
close F;
close P;
close O;

=============
Получим следующие файлы.
bestword3.lst — слова, длиной 3 символа, самые частые вверху
bestword3stat.lst — тоже + частота
Пример
ter : 129507
ing : 127876
man : 124859
and : 92970
ste : 92259
ill : 82739
mar : 74172
per : 69933
ick : 69850
ell : 69701
all : 69195
ers : 68295
est : 64949
lin : 62811
ass : 62627
poorword3.lst — слова, частота встречаемости которых ниже 100

Сделаем так для всех длин
perl bestfull.pl 3 100
perl bestfull.pl 4 100
perl bestfull.pl 5 100
perl bestfull.pl 6 100
perl bestfull.pl 7 100
perl bestfull.pl 8 100

Получим много файлов, с популярными словами или обрывками слов.
С ними можно работать как с оптимизированными ворд-листами, добавляя символы
в конец или начало.
Вот доказательство того, что это работает.
Условные обозначения
best — словарь из 4 символьных популярных слов
bestw — из 5
bestwo — 6
bestwor — 7
poor — из 4 непопулярных
poorw — 5
poorwo — 6
poorwor — 7

best00 — перебор из 4 символьных популярных слов + две любые цифры в конце
aabestwo — перебор из 6 символьных популярных слов + две любые буквы в начале

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

Метод — количество найденых паролей
best00 — 40
poor00 — 2
00best — 4
bestw00 — 30
00bestw — 5
poorw00 — 2
bestwo00 — 31
poorwo00 — 5
00bestwo — 7
bestwoaa — 30
aabestwo — 19
aabestw — 19
bestwaa — 7

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

Что еще можно придумать? Ну вот например
=========
open(F,»total0.lst»;
while(defined($a=<F> ))
{
chomp($a);
$a=~s/\d//g;
$b=substr(lc($a),-3);
if($b=~/[a-z][a-z][a-z]/)
{
$k{$b}++;
}
}
close F;
open(O,»>best3last.lst»;
foreach (reverse sort{$k{$a}<=>$k{$b] (keys (%k)))
{
print O $k{$_},» $_\n»;
}
close O;
=========
На выходе best3last.lst содержит популярные окончания слов
9782 ing
9088 man
5660 ers
5069 ter

Пишем в john.ini [List.Rules:Wordlist]
$m$a$n

Запускаем
john -w:bestword3.lst -rules pass.txt
john -w:bestword4.lst -rules pass.txt
john -w:bestword5.lst -rules pass.txt
Радуемся и открываем для себя новые слова.

Можно также добавить [List.Rules:Wordlist]
$m$a$n$[0-9]

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

[s](Добавление от 15:07 — 28 Авг., 2002.)[/s]

ну вроде все расжевано и лежит по полочкам…так что читайте и дерзайте
*********************************
спасибо vvv476

Компиляция John The Ripper v1.6.31
о чем это
как правильно скомпилировать John The Ripper v1.6.31 (далее — JTR) для win32-платформы.

для чего все это
на форуме появились отзывы что эта версия более быстрая чем старая чуть ли не в 2 раза.
и рекомендация скомпилировать ее, т.к. она существует только в виде исходников.
я подумал, что это просто издевательство над теми, кто вообще ни разу не компилил юникс-приложения
под виндоуз. поэтому помучавшись сам (неделю-другую) решил поделиться что из этого может получиться.

что нам потребуется
1- John the Ripper 1.6.31-dev (sources only) — http://www.openwall.com/john/john-1.6.31-dev.tar.gz
2- Cygwin for Windows — http://www.cygwin.com/setup.exe

установка Cygwin и запуск
что это такое? как написано на офф-сайте:
The Cygwin tools are ports of the popular GNU development tools
for Microsoft Windows. They run thanks to the Cygwin library which provides
the UNIX system calls and environment these programs expect.
другими словами — это как раз то что нам нужно для того чтобы скомпилировать
исходники JTR. Подходит для всех Windows 95/98/ME/NT/2000/XP.
итак, скачиваем setup.exe и запускаем его.
выбираем последовательно:
«Install from Internet»;
root-директорию: c:\cygwin;
зеркало,
с которого будет качаться дистрибутив
и ждем пока появится выбор компонентов.
оставляем все дефолтные и добавляем те, которые нам нужны для компиляции.
вот с самими компонентами, которые нужны выходит накладка, т.к. я точно не знаю,
какие нужны а какие не нужны для компиляции. поэтому просто перечислю, что у меня установлено:

Base — default
Devel — binutils, gcc, make, mingw-runtime
Doc — default
Editors — default
Interpreters — default
Libs — libiconv2, libintl1-2, libncurses5-6, libpopt0, mingw-runtime, ncurses, tempcap, w32api
Shells — default
Text — default
Utils — cygutils

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

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

$pwd
/home/user

user — это то имя пользователя, которое вводится при логине виндоуз.
на самом деле это путь c:\cygwin\home\user
теперь копируем исходники джона в эту директорию как они есть, т.е. doc/, run/, src/ через Проводник.
идем в консоли cygwin в директорию src/ (cd src) и даем команду

$make
To build John the Ripper, type:
make SYSTEM
where SYSTEM can be one of the following:
(список систем)

из этого списка нас интересуют только
win32-cygwin-x86-any Win32, Cygwin, x86
win32-cygwin-x86-mmx Win32, Cygwin, x86 with MMX
поэтому набираем команду

$make win32-cygwin-x86-mmx

и пошел процесс компиляции.
если все прошло без ошибок, то будет написано, что созданы exe-файлы в директории run/
можно поздравить себя с победой и глотнуть чего-нибудь бодрящего
но это еще не все. для работы файла john.exe требуется еще cygwin1.dll
берем его отсюда: c:\cygwin\bin\ и переписываем к джону.
вот теперь все. можно смело запускать.
кстати, dll от старой версии джона не будет работать с новым.

что имеем в результате
а в результате получаем новую версию JTR почти что в 2 раза быстрее старой!
по-моему это стоит, чтобы немного помучиться

*******************************************

This entry was posted on 8 января, 2009 в 02:58 and is filed under Undeground. Отмечено: hack, Undeground. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, или trackback from your own site.

Оставьте комментарий

« Фальсификация cookie

Немного и безопасности »

J3qx

information archive

Страницы

Архивы

Мета

Статистика

Рубрики