Форум АНТИЧАТ

Форум АНТИЧАТ (https://forum.antichat.xyz/index.php)
-   Расшифровка хешей (https://forum.antichat.xyz/forumdisplay.php?f=76)
-   -   Патчи, модификации, скрипты для John the Ripper (https://forum.antichat.xyz/showthread.php?t=43156)

Thanat0z 27.06.2007 00:30
Патчи, модификации, скрипты для John the Ripper и подбора паролей в целом
 
В данной теме я буду выкладывать различные сборки джона, интересные патчи и скрипты облегчающие работу с JTR которые найду в инете или сам додумаюсь :)

Просьба: вопросы задавать в теме [Задай Вопрос - Получи Ответ]

+ полезные скрипты в общем плане для дешифровки (updated 04.08.2007)
================================================== ==============

Лично я, постонно работаю с патченной сборкой джона версии 1.7 с оптимазиацией под разные процы.

Скачать можно отсюда - __http://rapidshare.com/files/39513349/_john_mod_by_Maxx.rar

Модификации сделаны человеком по имени Maxx c www.wapbbs.com.

Из отличительных особенностей с официальной версией:
1) работа с хешами Mysql 3.23, sha-1, rawMD5
2) режим -mask - режим перебора по маске
К примеру
Код:
john -mask:\d\d\d\d\
, где \d - digits
3) режим -builtin - режим перебора по встроенному набору
4) ключик -uncracked (противоположный -show)
5) ехе'шники под разные типы процов

Стоит заметить что данная модификация джона быстрее официальной

Thanat0z 27.06.2007 00:46
Измерение и сравнение скорости работы
 
Возьмем сборку JRT и внимательно посмотрим на содержимое. В папке run вы можете наблюдать много ехе файлов. Вы их уже могли видеть, если читали мою статью про того какой софт выбрать для брута хешей :) Так вот, сейчас еще раз посчитаем скорость работы их.

ЗЫ кстати в папке лежит два файлика
john.conf_default
john.conf.
Тот что не default мой личный, пока что отложите его в сторону, он нам пригодится после :)


Для подсчета скорости нам понадобятся скрипты.
Первый скрипт мы назовем script_test_speed.pl:
Код:
#(c) Maxx
#!/usr/bin/perl
use strict;
my %result;

for my $john (sort <run\\john.*.exe>)
{
        next unless $john =~ /john\.(.+)\.exe/;
        my $arch = $1;
       
        print STDERR "testing $arch...\n";
        print "arch: $arch\n";
        system("$john -test");
}
как видите из кода это Perl ;), и скрипт будет запускать из папки run ехе'шники джона в режиме -test. Скрипт должен запускаться из главной папки джона, не из папки run:

Код:
26.06.2007  22:20    <DIR>          doc
26.06.2007  22:55    <DIR>          run
26.06.2007  22:52            1*062 script_parse_result.pl
26.06.2007  22:55              237 script_test_speed.pl
запускать будем как
Код:
perl script_test_speed.pl > result1.txt
После запустим второй скрипт script_parse_result.pl:
Код:
#(c) Maxx
#!/usr/bin/perl
use strict;
my @result;
undef $/;
my $text = <>;

for my $archset (split /arch:\s*/is, $text)
{
        next unless $archset =~ s/^(\S+)\s//s;
        my $arch = $1;

        for my $algset (split /Benchmarking:\s*/is, $archset)
        {
                next unless $algset =~ s/^(.+?)\s*[\(\[][^\n]+\n//s;
                my $alg = $1;
               
                for my $typeset (split /\n/, $algset)
                {
                        if ($typeset =~ m/^([^\:]+):\s*(\d+(\w)?)/)
                        {
                                my ($type, $speed) = ($1, $2);
                                $speed =~ s/K/000/;
                                $speed =~ s/M/000000/;
                            push @result, [$alg, $type, $speed, $arch];
                        }
                }
    }
}

my ($prevalg, $prevtype);
for (sort
        {
                my $r;
                return $r unless ($r = @{$a}[0] cmp @{$b}[0]) == 0;
                return $r unless ($r = @{$a}[1] cmp @{$b}[1]) == 0;
                return $r unless ($r = @{$b}[2] <=> @{$a}[2]) == 0;
                @{$a}[3] cmp @{$b}[3];
        }
        @result)
{
        my ($alg, $type, $speed, $arch) = @{$_};
        if ($prevalg ne $alg || $prevtype ne $type)
        {
                $prevalg  = $alg;
                $prevtype = $type;
                print "\n";
        }
    printf("%s (%s): %9d (%s)\n", $alg, $type, $speed, $arch);
}
запускать будем так
Код:
perl script_parse_result.pl < result1.txt > result2.txt
Получим в итоге результаты

Код:
BSDI DES (Many salts):    29120 (athlon-4)
BSDI DES (Many salts):    29120 (athlon-xp)
BSDI DES (Many salts):    29071 (athlon-tbird)
BSDI DES (Many salts):    29071 (k6-3)
BSDI DES (Many salts):    29071 (pentium-mmx)
BSDI DES (Many salts):    29068 (athlon)
BSDI DES (Many salts):    29068 (athlon-mp)
BSDI DES (Many salts):    29068 (i386)
BSDI DES (Many salts):    29068 (k6)
BSDI DES (Many salts):    29068 (pentium4)
BSDI DES (Many salts):    29020 (k6-2)
BSDI DES (Many salts):    29020 (pentium2)
BSDI DES (Many salts):    29020 (pentium3)
BSDI DES (Many salts):    29020 (pentiumpro)
BSDI DES (Many salts):    29016 (pentium)
BSDI DES (Many salts):    28971 (i486)
BSDI DES (Many salts):    28968 (i686)
BSDI DES (Many salts):    28920 (i586)

BSDI DES (Only one salt):    28822 (pentium2)
BSDI DES (Only one salt):    28768 (athlon-4)
BSDI DES (Only one salt):    28768 (athlon-mp)
BSDI DES (Only one salt):    28768 (athlon-xp)
BSDI DES (Only one salt):    28721 (athlon)
BSDI DES (Only one salt):    28721 (i686)
BSDI DES (Only one salt):    28721 (pentium)
BSDI DES (Only one salt):    28721 (pentium-mmx)
BSDI DES (Only one salt):    28721 (pentium4)
BSDI DES (Only one salt):    28673 (pentium3)
BSDI DES (Only one salt):    28673 (pentiumpro)
BSDI DES (Only one salt):    28670 (athlon-tbird)
BSDI DES (Only one salt):    28670 (i386)
BSDI DES (Only one salt):    28670 (k6)
BSDI DES (Only one salt):    28670 (k6-3)
BSDI DES (Only one salt):    28573 (k6-2)
BSDI DES (Only one salt):    28527 (i486)
BSDI DES (Only one salt):    28524 (i586)

FreeBSD MD5 (Raw):      5841 (i386)
FreeBSD MD5 (Raw):      5841 (k6)
FreeBSD MD5 (Raw):      5841 (k6-2)
FreeBSD MD5 (Raw):      5841 (k6-3)
FreeBSD MD5 (Raw):      5840 (i486)
FreeBSD MD5 (Raw):      5825 (pentium)
FreeBSD MD5 (Raw):      5808 (i586)
FreeBSD MD5 (Raw):      5793 (i686)
FreeBSD MD5 (Raw):      5793 (pentium-mmx)
FreeBSD MD5 (Raw):      5777 (athlon-mp)
FreeBSD MD5 (Raw):      5777 (athlon-tbird)
FreeBSD MD5 (Raw):      5776 (athlon-4)
FreeBSD MD5 (Raw):      5776 (pentium2)
FreeBSD MD5 (Raw):      5776 (pentium3)
FreeBSD MD5 (Raw):      5776 (pentiumpro)
FreeBSD MD5 (Raw):      5761 (athlon-xp)
FreeBSD MD5 (Raw):      5760 (athlon)
FreeBSD MD5 (Raw):      5760 (pentium4)

Kerberos AFS DES (Long):    745608 (athlon-4)
Kerberos AFS DES (Long):    743493 (athlon-mp)
Kerberos AFS DES (Long):    743493 (athlon-xp)
Kerberos AFS DES (Long):    731307 (pentium2)
Kerberos AFS DES (Long):    731307 (pentium3)
Kerberos AFS DES (Long):    729399 (athlon-tbird)
Kerberos AFS DES (Long):    729399 (i386)
Kerberos AFS DES (Long):    729399 (pentiumpro)
Kerberos AFS DES (Long):    727501 (athlon)
Kerberos AFS DES (Long):    727375 (i686)
Kerberos AFS DES (Long):    721618 (pentium4)
Kerberos AFS DES (Long):    719637 (pentium)
Kerberos AFS DES (Long):    717667 (pentium-mmx)
Kerberos AFS DES (Long):    713880 (i586)
Kerberos AFS DES (Long):    712062 (i486)
Kerberos AFS DES (Long):    712062 (k6)
Kerberos AFS DES (Long):    710133 (k6-3)
Kerberos AFS DES (Long):    708214 (k6-2)

Kerberos AFS DES (Short):    279586 (athlon-4)
Kerberos AFS DES (Short):    279586 (athlon-mp)
Kerberos AFS DES (Short):    279586 (athlon-xp)
Kerberos AFS DES (Short):    279586 (i386)
Kerberos AFS DES (Short):    279586 (i686)
Kerberos AFS DES (Short):    279028 (pentium2)
Kerberos AFS DES (Short):    278435 (athlon)
Kerberos AFS DES (Short):    278398 (athlon-tbird)
Kerberos AFS DES (Short):    278398 (k6)
Kerberos AFS DES (Short):    277844 (pentium4)
Kerberos AFS DES (Short):    277844 (pentiumpro)
Kerberos AFS DES (Short):    277293 (k6-2)
Kerberos AFS DES (Short):    277293 (pentium3)
Kerberos AFS DES (Short):    277257 (pentium)
Kerberos AFS DES (Short):    276708 (i486)
Kerberos AFS DES (Short):    276708 (k6-3)
Kerberos AFS DES (Short):    276708 (pentium-mmx)
Kerberos AFS DES (Short):    276125 (i586)

MySQL 3.23 (Raw):  17367000 (i386)
MySQL 3.23 (Raw):  17048000 (i486)
MySQL 3.23 (Raw):  17015000 (k6)
MySQL 3.23 (Raw):  16912000 (k6-2)
MySQL 3.23 (Raw):  16877000 (k6-3)
MySQL 3.23 (Raw):  15947000 (pentium4)
MySQL 3.23 (Raw):  15170000 (athlon)
MySQL 3.23 (Raw):  15170000 (athlon-tbird)
MySQL 3.23 (Raw):  14690000 (pentiumpro)
MySQL 3.23 (Raw):  14666000 (i686)
MySQL 3.23 (Raw):  14587000 (pentium3)
MySQL 3.23 (Raw):  14313000 (athlon-mp)
MySQL 3.23 (Raw):  14290000 (athlon-4)
MySQL 3.23 (Raw):  14242000 (athlon-xp)
MySQL 3.23 (Raw):  14242000 (pentium2)
MySQL 3.23 (Raw):  13707000 (pentium)
MySQL 3.23 (Raw):  13661000 (i586)
MySQL 3.23 (Raw):  13661000 (pentium-mmx)

NT LM DES (Raw):  8356000 (pentiumpro)
NT LM DES (Raw):  8339000 (i686)
NT LM DES (Raw):  8012000 (athlon-mp)
NT LM DES (Raw):  7998000 (athlon-tbird)
NT LM DES (Raw):  7983000 (athlon-xp)
NT LM DES (Raw):  7982000 (athlon)
NT LM DES (Raw):  7982000 (athlon-4)
NT LM DES (Raw):  7895000 (pentium3)
NT LM DES (Raw):  7866000 (pentium2)
NT LM DES (Raw):  7794000 (i386)
NT LM DES (Raw):  7780000 (pentium4)
NT LM DES (Raw):  7752000 (pentium)
NT LM DES (Raw):  7683000 (i586)
NT LM DES (Raw):  7683000 (pentium-mmx)
NT LM DES (Raw):  7547000 (k6-3)
NT LM DES (Raw):  7534000 (k6)
NT LM DES (Raw):  7494000 (i486)
NT LM DES (Raw):  7443000 (k6-2)

OpenBSD Blowfish (Raw):      356 (i686)
OpenBSD Blowfish (Raw):      356 (pentium2)
OpenBSD Blowfish (Raw):      355 (athlon)
OpenBSD Blowfish (Raw):      355 (k6)
OpenBSD Blowfish (Raw):      355 (pentiumpro)
OpenBSD Blowfish (Raw):      354 (athlon-4)
OpenBSD Blowfish (Raw):      354 (athlon-mp)
OpenBSD Blowfish (Raw):      354 (athlon-tbird)
OpenBSD Blowfish (Raw):      354 (athlon-xp)
OpenBSD Blowfish (Raw):      354 (i586)
OpenBSD Blowfish (Raw):      354 (pentium)
OpenBSD Blowfish (Raw):      354 (pentium-mmx)
OpenBSD Blowfish (Raw):      354 (pentium4)
OpenBSD Blowfish (Raw):      353 (pentium3)
OpenBSD Blowfish (Raw):      352 (i386)
OpenBSD Blowfish (Raw):      352 (i486)
OpenBSD Blowfish (Raw):      352 (k6-2)
OpenBSD Blowfish (Raw):      352 (k6-3)

Raw MD5 (Raw):  3339000 (i386)
Raw MD5 (Raw):  3329000 (pentium4)
Raw MD5 (Raw):  3302000 (i486)
Raw MD5 (Raw):  3297000 (k6)
Raw MD5 (Raw):  3276000 (athlon)
Raw MD5 (Raw):  3276000 (athlon-mp)
Raw MD5 (Raw):  3276000 (athlon-tbird)
Raw MD5 (Raw):  3276000 (k6-2)
Raw MD5 (Raw):  3276000 (k6-3)
Raw MD5 (Raw):  3276000 (pentium)
Raw MD5 (Raw):  3266000 (athlon-4)
Raw MD5 (Raw):  3266000 (athlon-xp)
Raw MD5 (Raw):  3256000 (i586)
Raw MD5 (Raw):  3246000 (pentium-mmx)
Raw MD5 (Raw):  3226000 (pentium3)
Raw MD5 (Raw):  3216000 (i686)
Raw MD5 (Raw):  3216000 (pentium2)
Raw MD5 (Raw):  3206000 (pentiumpro)

SHA1 (Raw):  2849000 (pentium4)
SHA1 (Raw):  2818000 (pentium)
SHA1 (Raw):  2803000 (pentium-mmx)
SHA1 (Raw):  2796000 (i486)
SHA1 (Raw):  2795000 (i586)
SHA1 (Raw):  2788000 (i386)
SHA1 (Raw):  2788000 (k6)
SHA1 (Raw):  2788000 (k6-3)
SHA1 (Raw):  2781000 (athlon)
SHA1 (Raw):  2781000 (athlon-tbird)
SHA1 (Raw):  2781000 (k6-2)
SHA1 (Raw):  2774000 (pentium2)
SHA1 (Raw):  2767000 (athlon-mp)
SHA1 (Raw):  2766000 (pentium3)
SHA1 (Raw):  2759000 (athlon-4)
SHA1 (Raw):  2759000 (athlon-xp)
SHA1 (Raw):  2745000 (pentiumpro)
SHA1 (Raw):  2744000 (i686)

Traditional DES (Many salts):    894778 (athlon)
Traditional DES (Many salts):    894778 (athlon-4)
Traditional DES (Many salts):    894778 (athlon-mp)
Traditional DES (Many salts):    894778 (athlon-tbird)
Traditional DES (Many salts):    894778 (athlon-xp)
Traditional DES (Many salts):    894778 (k6)
Traditional DES (Many salts):    894778 (pentium)
Traditional DES (Many salts):    894778 (pentium-mmx)
Traditional DES (Many salts):    894778 (pentium2)
Traditional DES (Many salts):    894778 (pentium3)
Traditional DES (Many salts):    894778 (pentium4)
Traditional DES (Many salts):    893348 (i386)
Traditional DES (Many salts):    893253 (k6-3)
Traditional DES (Many salts):    891829 (i486)
Traditional DES (Many salts):    891734 (pentiumpro)
Traditional DES (Many salts):    890314 (i586)
Traditional DES (Many salts):    890314 (i686)
Traditional DES (Many salts):    888899 (k6-2)

Traditional DES (Only one salt):    838848 (athlon)
Traditional DES (Only one salt):    836338 (athlon-tbird)
Traditional DES (Only one salt):    836338 (k6-3)
Traditional DES (Only one salt):    836172 (athlon-4)
Traditional DES (Only one salt):    836172 (athlon-mp)
Traditional DES (Only one salt):    836172 (athlon-xp)
Traditional DES (Only one salt):    836172 (i386)
Traditional DES (Only one salt):    836172 (k6)
Traditional DES (Only one salt):    836172 (pentium4)
Traditional DES (Only one salt):    833679 (k6-2)
Traditional DES (Only one salt):    833679 (pentium)
Traditional DES (Only one salt):    833679 (pentium3)
Traditional DES (Only one salt):    833679 (pentiumpro)
Traditional DES (Only one salt):    831200 (i686)
Traditional DES (Only one salt):    831200 (pentium-mmx)
Traditional DES (Only one salt):    831036 (pentium2)
Traditional DES (Only one salt):    825962 (i486)
Traditional DES (Only one salt):    825962 (i586)
Получив эти данные, вы можете выбрать для повторного тестирования более понравившиеся для вас сборки. Вот допустим я для повторного тестирования скорости могу выбрать сборки i386, athlon-4, athlon. Повторное тестирование нужно для того, чтоб учитывать погрешности связанные с тем, что вы можете во время тестирования занимать память и проц другими задачами. Грубо говоря, режим -test не совсем точен. Самая лучшая проверка это практика. Кстати имея результаты сравнения скорости, имет смысл переименовать некоторые ехе'шники по типам хешей. Вот для примера, сборку pentium можно переименовать в john-sha1, и после вы не забудете, что именно эта сборка более подходит для брута sha-1 хешей.

Thanat0z 04.08.2007 01:54
Генератор Keyboard_nospec для секции внешних переборщиков. Позволяет находить пароли состоящие из последовательностей буков и цифр, типа:

tgfghg
tgfghj
tgfghy
we3edfgh
we3edfgt
we3edfgb

Код:
[List.External:Keyboard_nospec]
int maxlength, length; // Maximum passwords length to try, current length
int fuzz; // The desired "fuzz factor", either 0 or 1
int id[15]; // Current character indices for each position
int m[0x400], mc[0x80]; // The keys matrix, counts of adjacent keys
int f[0x40], fc; // Characters for the first position, their count

void init()
{
int minlength;
int i, j, c, p;
int k[0x40];

minlength = 5; // Initial passwords length to try
maxlength = 9; // Maximum passwords length to try, up to 15
fuzz = 0; // "Fuzz factor", set to 0 for much quicker runs

/*
* This defines the keyboard layout, by default for a QWERTY keyboard.
* Please note that the sizes of m[] and mc[] arrays assume 7-bit
* characters and will need to be doubled for 8-bit characters such as
* umlauts.
*/
i = 0; while (i < 0x40) k[i++] = 0;
i = 0; while (++i <= 9) k[i] = '0' + i;
k[10] = '0';
k[0x11] = 'q'; k[0x12] = 'w'; k[0x13] = 'e'; k[0x14] = 'r';
k[0x15] = 't'; k[0x16] = 'y'; k[0x17] = 'u'; k[0x18] = 'i';
k[0x19] = 'o'; k[0x1a] = 'p';
k[0x21] = 'a'; k[0x22] = 's'; k[0x23] = 'd'; k[0x24] = 'f';
k[0x25] = 'g'; k[0x26] = 'h'; k[0x27] = 'j'; k[0x28] = 'k';
k[0x29] = 'l';
k[0x31] = 'z'; k[0x32] = 'x'; k[0x33] = 'c'; k[0x34] = 'v';
k[0x35] = 'b'; k[0x36] = 'n'; k[0x37] = 'm';

i = 0; while (i < 0x80) mc[i++] = 0;
fc = 0;

/* rows */
c = 0;
i = 0;
while (i < 0x40) {
p = c;
c = k[i++];
if (!c) continue;
f[fc++] = c;
if (!p) continue;
m[(c << 3) + mc[c]++] = p;
m[(p << 3) + mc[p]++] = c;
}
f[fc] = 0;

/* columns */
i = 0;
while (i < 0x30) {
p = k[i++];
if (!p) continue;
j = 1 - fuzz;
while (j <= 1 + fuzz) {
c = k[i + 0x10 - j++];
if (!c) continue;
m[(c << 3) + mc[c]++] = p;
m[(p << 3) + mc[p]++] = c;
}
}

id[0] = 0;
length = minlength;
}

void generate()
{
int i, p, maxcount;

word[i = 0] = p = f[id[0]];
while (++i < length)
word[i] = p = m[(p << 3) + id[i]];
word[i--] = 0;

if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
while (++id[i] >= maxcount) {
if (!i) {
if (length < maxlength) {
id[0] = 0;
id[length++] = 0;
}
return;
}
id[i--] = 0;
if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
}
}

void restore()
{
int i;

/* Calculate the length */
length = 0;
while (word[length]) length++;

/* Infer the first character index */
i = -1;
while (++i < fc) {
if (f[i] == word[0]) {
id[0] = i;
break;
}
}

Thanat0z 04.08.2007 02:00
Генератор Keyboard для секции внешних переборщиков. Позволяет находить пароли состоящие из последовательностей символов (включая спецсимволы), типа:

6ujij,.
6ujij,j
6ujij,k
6ujij,l
6ujijmn
p[-[p[;
p[-[p98
p[-[p90
p[-[p9p

Код:
[List.External:Keyboard]
int maxlength, length;        // Maximum passwords length to try, current length
int fuzz;                // The desired "fuzz factor", either 0 or 1
int id[15];                // Current character indices for each position
int m[0x400], mc[0x80];        // The keys matrix, counts of adjacent keys
int f[0x40], fc;        // Characters for the first position, their count

void init()
{
        int minlength;
        int i, j, c, p;
        int k[0x40];

        minlength = 7;        // Initial passwords length to try
        maxlength = 9;        // Maximum passwords length to try, up to 15
        fuzz = 1;        // "Fuzz factor", set to 0 for much quicker runs

/*
 * This defines the keyboard layout, by default for a QWERTY keyboard.
 * Please note that the sizes of m[] and mc[] arrays assume 7-bit
 * characters and will need to be doubled for 8-bit characters such as
 * umlauts.
 */
        i = 0; while (i < 0x40) k[i++] = 0;
        k[0] = '`';
        i = 0; while (++i <= 9) k[i] = '0' + i;
        k[10] = '0'; k[11] = '-'; k[12] = '=';
        k[0x11] = 'q'; k[0x12] = 'w'; k[0x13] = 'e'; k[0x14] = 'r';
        k[0x15] = 't'; k[0x16] = 'y'; k[0x17] = 'u'; k[0x18] = 'i';
        k[0x19] = 'o'; k[0x1a] = 'p'; k[0x1b] = '['; k[0x1c] = ']';
        k[0x1d] = '\\';
        k[0x21] = 'a'; k[0x22] = 's'; k[0x23] = 'd'; k[0x24] = 'f';
        k[0x25] = 'g'; k[0x26] = 'h'; k[0x27] = 'j'; k[0x28] = 'k';
        k[0x29] = 'l'; k[0x2a] = ';'; k[0x2b] = '\'';
        k[0x31] = 'z'; k[0x32] = 'x'; k[0x33] = 'c'; k[0x34] = 'v';
        k[0x35] = 'b'; k[0x36] = 'n'; k[0x37] = 'm'; k[0x38] = ',';
        k[0x39] = '.'; k[0x3a] = '/';

        i = 0; while (i < 0x80) mc[i++] = 0;
        fc = 0;

        /* rows */
        c = 0;
        i = 0;
        while (i < 0x40) {
                p = c;
                c = k[i++];
                if (!c) continue;
                f[fc++] = c;
                if (!p) continue;
                m[(c << 3) + mc[c]++] = p;
                m[(p << 3) + mc[p]++] = c;
        }
        f[fc] = 0;

        /* columns */
        i = 0;
        while (i < 0x30) {
                p = k[i++];
                if (!p) continue;
                j = 1 - fuzz;
                while (j <= 1 + fuzz) {
                        c = k[i + 0x10 - j++];
                        if (!c) continue;
                        m[(c << 3) + mc[c]++] = p;
                        m[(p << 3) + mc[p]++] = c;
                }
        }

        id[0] = 0;
        length = minlength;
}

void generate()
{
        int i, p, maxcount;

        word[i = 0] = p = f[id[0]];
        while (++i < length)
                word[i] = p = m[(p << 3) + id[i]];
        word[i--] = 0;

        if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
        while (++id[i] >= maxcount) {
                if (!i) {
                        if (length < maxlength) {
                                id[0] = 0;
                                id[length++] = 0;
                        }
                        return;
                }
                id[i--] = 0;
                if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
        }
}

void restore()
{
        int i;

        /* Calculate the length */
        length = 0;
        while (word[length]) length++;

        /* Infer the first character index */
        i = -1;
        while (++i < fc) {
                if (f[i] == word[0]) {
                        id[0] = i;
                        break;
                }
        }

        /* This sample can be enhanced to infer the rest of the indices here */
}

Thanat0z 16.08.2007 19:58
Скрипт перевода русского текста в набор на англ раскладке
Код:
#!/usr/bin/perl

if (@ARGV < 1)
{
    print "Usage: transkey.pl source\r\n";
    exit();
}

$sour = $ARGV[0];

if (@ARGV = 1){
    $dest = $sour . '_trans';
}
else{
    $dest = $ARGV[1];
};

$alphabet = "f,dult;pbqrkvyjghcnea[wxio]sm'.z";
$alphabet2 = 'F<DULT:PBQRKVYJGHCNEA{WXIO}SM">Z';

open (SR, "<$sour") || die "Could not open source file";
open (DS, ">$dest") || die "Could not create destination file";

while (<SR>){
    chomp;
    @bukvy = split(//);
        foreach $bk (@bukvy) {
            $num = ord($bk);
            if ($num < 256){
                if ($num > 223){
                    $bk = substr($alphabet,$num-224,1);
                }else{
                    if ($num > 191){
                        $bk = substr($alphabet2,$num-192,1);
                    };
                };
            };
        }
    print DS join("",@bukvy) . "\n";
};

close (SR);
close (DS);

gisTy 24.06.2008 01:35
а есть ли JTR_mod_by_Maxx под *nix системы? исходники например

aquam 07.07.2008 18:03
Ещё было бы неплохо про MPI написать
http://www.bindshell.net/tools/johntheripper
Позволяет распараллеливать работу John-a на несколько процессоров.
Например на 4xXeon 3.2GHz скорость перебора RawMD5 составит 40 000 000 в секуду.

Distributed John
http://freshmeat.net/projects/djohn/
Для организации перебора на разных машинах.
В связке с openMPI может неплохо получиться.

Сам использую только openMPI.

Thanat0z 15.09.2008 05:54
2 gisTy: вообще есть, но у меня нет :)
2 aquam: про MPI я, кажется, писал в другой теме
============

Последняя сборка Джона от Макса. Для некоторых алгоритмов скорость под определенные процы значительно поднялась

__http://rapidshare.com/files/143484764/john-20080222.rar


Время: 02:45