4 ## Author......: Jens Steube <jens.steube@gmail.com>
10 use Digest
::MD4 qw
(md4 md4_hex
);
11 use Digest
::MD5 qw
(md5 md5_hex
);
12 use Digest
::SHA qw
(sha1 sha256 sha384 sha512 sha1_hex sha256_hex sha384_hex sha512_hex
);
13 use Digest
::HMAC qw
(hmac hmac_hex
);
14 use Digest
::Keccak qw
(keccak_256_hex
);
15 use Crypt
::MySQL qw
(password41
);
16 use Digest
::GOST qw
(gost gost_hex
);
17 use Digest
::HMAC_MD5 qw
(hmac_md5
);
18 use Digest
::CRC qw
(crc32
);
21 use Crypt
::ECB qw
(encrypt
);
23 use Crypt
::Eksblowfish
::Bcrypt qw
(bcrypt en_base64
);
24 use Crypt
::Digest
::RIPEMD160 qw
(ripemd160_hex
);
25 use Crypt
::Digest
::Whirlpool qw
(whirlpool_hex
);
27 use Crypt
::ScryptKDF qw
(scrypt_hash scrypt_b64
);
31 use Crypt
::UnixCrypt_XS qw
(crypt_rounds fold_password base64_to_int24 block_to_base64 int24_to_base64
);
33 use Authen
::Passphrase
::NTHash
;
34 use Authen
::Passphrase
::MySQL323
;
35 use Authen
::Passphrase
::PHPass
;
36 use Authen
::Passphrase
::LANManager
;
38 use POSIX qw
(strftime
);
40 use Net
::DNS
::RR
::NSEC3
;
41 use Convert
::EBCDIC qw
(ascii2ebcdic
);
42 use Digest
::SipHash qw
/siphash/;
44 my $hashcat = "./hashcat";
48 my @modes = (0, 10, 11, 12, 20, 21, 22, 23, 30, 40, 50, 60, 100, 101, 110, 111, 112, 120, 121, 122, 125, 130, 131, 132, 133, 140, 141, 150, 160, 200, 300, 400, 500, 900, 1000, 1100, 1400, 1410, 1420, 1430, 1440, 1441, 1450, 1460, 1500, 1600, 1700, 1710, 1711, 1720, 1730, 1740, 1722, 1731, 1750, 1760, 1800, 2100, 2400, 2410, 2500, 2600, 2611, 2612, 2711, 2811, 3000, 3100, 3200, 3710, 3711, 3300, 3500, 3610, 3720, 3800, 3910, 4010, 4110, 4210, 4300, 4400, 4500, 4600, 4700, 4800, 4900, 5000, 5100, 5300, 5400, 5500, 5600, 5700, 5800, 6000, 6100, 6300, 6400, 6500, 6600, 6700, 6800, 6900, 7100, 7200, 7300, 7400, 7500, 7600, 7700, 7800, 7900, 8000, 8100, 8200, 8300, 8400, 8500, 8600, 8700, 8900, 9100, 9200, 9300, 9400, 9500, 9600, 9700, 9800, 9900, 10000, 10100, 10200, 10300, 10400, 10500, 10600, 10700, 10800, 10900, 11000, 11100, 11200, 11300, 11400, 11500, 11600, 11900, 12000, 12100, 12200, 12300, 12400, 12600, 12700, 12800, 12900, 13000, 13100, 13200, 13300, 13400, 13500, 13600, 13800);
50 my %is_unicode = map { $_ => 1 } qw(30 40 130 131 132 133 140 141 1000 1100 1430 1440 1441 1730 1740 1731 5500 5600 8000 9400 9500 9600 9700 9800 11600 13500 13800);
51 my %less_fifteen = map { $_ => 1 } qw(500 1600 1800 2400 2410 3200 6300 7400 10500 10700);
52 my %allow_long_salt = map { $_ => 1 } qw(2500 5500 5600 7100 7200 7300 9400 9500 9600 9700 9800 10400 10500 10600 10700 1100 11000 11200 11300 11400 11600 12600 13500 13800);
54 my @lotus_magic_table =
56 0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a,
57 0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0,
58 0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b,
59 0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a,
60 0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda,
61 0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36,
62 0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8,
63 0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c,
64 0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17,
65 0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60,
66 0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72,
67 0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa,
68 0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd,
69 0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e,
70 0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b,
71 0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf,
72 0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77,
73 0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6,
74 0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3,
75 0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3,
76 0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e,
77 0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c,
78 0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d,
79 0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2,
80 0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46,
81 0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5,
82 0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97,
83 0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5,
84 0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef,
85 0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f,
86 0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf,
87 0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab
92 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
93 0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
94 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
95 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
98 my $CISCO_BASE64_MAPPING = {'A', '.', 'B', '/', 'C', '0', 'D', '1', 'E', '2', 'F', '3', 'G', '4', 'H', '5', 'I', '6', 'J', '7', 'K', '8', 'L', '9', 'M', 'A', 'N', 'B', 'O', 'C', 'P', 'D', 'Q', 'E', 'R', 'F', 'S', 'G', 'T', 'H', 'U', 'I', 'V', 'J', 'W', 'K', 'X', 'L', 'Y', 'M', 'Z', 'N', 'a', 'O', 'b', 'P', 'c', 'Q', 'd', 'R', 'e', 'S', 'f', 'T', 'g', 'U', 'h', 'V', 'i', 'W', 'j', 'X', 'k', 'Y', 'l', 'Z', 'm', 'a', 'n', 'b', 'o', 'c', 'p', 'd', 'q', 'e', 'r', 'f', 's', 'g', 't', 'h', 'u', 'i', 'v', 'j', 'w', 'k', 'x', 'l', 'y', 'm', 'z', 'n', '0', 'o', '1', 'p', '2', 'q', '3', 'r', '4', 's', '5', 't', '6', 'u', '7', 'v', '8', 'w', '9', 'x', '+', 'y', '/', 'z'};
100 if (scalar @ARGV < 1)
111 if ($type ne "verify")
113 if (scalar @ARGV > 1)
118 elsif (scalar @ARGV == 1)
128 if ($type eq "single")
132 elsif ($type eq "passthrough")
143 if (scalar @ARGV != 4)
148 my $mode = shift @ARGV;
149 my $hash_file = shift @ARGV;
150 my $in_file = shift @ARGV;
151 my $out_file = shift @ARGV;
155 open (IN
, "<", $hash_file) or die ("$hash_file: $!\n");
157 # clever ? the resulting database could be huge
158 # but we need some way to map lines in hashfile w/ cracks
159 # maybe rli2 way would be more clever (needs sorted input)
161 while (my $line = <IN
>)
163 $line =~ s/[\n\r]*$//;
165 $db->{$line} = undef;
170 verify
($mode, $db, $in_file, $out_file);
178 my $out_file = shift;
197 open (IN
, "<", $in_file) or die ("$in_file: $!\n");
198 open (OUT
, ">", $out_file) or die ("$out_file: $!\n");
202 my $base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
203 my $itoa64_1 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
204 my $itoa64_2 = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
206 while (my $line = <IN
>)
213 # remember always do "exists ($db->{$hash_in})" checks as soon as possible and don't forget it
216 if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 133 || $mode == 200 || $mode == 300 || $mode == 900 || $mode == 1000 || $mode == 1400 || $mode == 1700 || $mode == 2400 || $mode == 2600 || $mode == 3000 || $mode == 3500 || $mode == 4300 || $mode == 4400 || $mode == 4500 || $mode == 4600 || $mode == 4700 || $mode == 5000 || $mode == 5100 || $mode == 5700 || $mode == 6000 || $mode == 6100 || $mode == 6900 || $mode == 8600 || $mode == 9900 || $mode == 10800 || $mode == 11500)
218 my $index = index ($line, ":");
222 $hash_in = substr ($line, 0, $index);
224 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
226 $word = substr ($line, $index + 1);
229 elsif ($mode == 10 || $mode == 11 || $mode == 12 || $mode == 20 || $mode == 21 || $mode == 22 || $mode == 23 || $mode == 30 || $mode == 40 || $mode == 50 || $mode == 60 || $mode == 110 || $mode == 112 || $mode == 120 || $mode == 121 || $mode == 130 || $mode == 140 || $mode == 150 || $mode == 160 || $mode == 1100 || $mode == 1410 || $mode == 1420 || $mode == 1430 || $mode == 1440 || $mode == 1450 || $mode == 1460 || $mode == 1710 || $mode == 1720 || $mode == 1730 || $mode == 1740 || $mode == 1750 || $mode == 1760 || $mode == 2410 || $mode == 2611 || $mode == 2711 || $mode == 2811 || $mode == 3100 || $mode == 3610 || $mode == 3710 || $mode == 3720 || $mode == 3800 || $mode == 3910 || $mode == 4010 || $mode == 4110 || $mode == 4210 || $mode == 4900 || $mode == 5800 || $mode == 7600 || $mode == 8400 || $mode == 11000 || $mode == 12600 || $mode == 13500 || $mode == 13800)
232 my $index1 = index ($line, ":");
236 $hash_in = substr ($line, 0, $index1);
238 # identify lenghts of both salt and plain
240 my $salt_plain = substr ($line, $index1 + 1);
242 my $num_cols = () = $salt_plain =~ /:/g;
251 foreach (my $i = 0; $i < $num_cols; $i++)
253 $index2 = index ($salt_plain, ":", $start);
257 $start = $index2 + 1;
259 $salt = substr ($salt_plain, 0, $index2);
260 $word = substr ($salt_plain, $index2 + 1);
262 # can't be true w/ wrong $hash:$salt, otherwise the
263 # algo must have many collisions
265 if (exists ($db->{$hash_in . ":" . $salt}))
267 $hash_in = $hash_in . ":" . $salt;
273 next unless ($matched); # therefore: true == exists ($db->{$hash_in}
274 next unless (! defined ($db->{$hash_in}));
277 elsif ($mode == 2100)
280 my $index1 = index ($line, "\$DCC2\$");
282 next if $index1 != 0;
285 my $index2 = index ($line, "#", $index1 + 1);
289 $iter = substr ($line, $index1 + 6, $index2 - $index1 - 6);
292 $index1 = index ($line, "#");
296 $hash_in = substr ($line, 0, $index1 + 1);
298 # identify lenghts of both salt and plain
300 my $salt_plain = substr ($line, $index2 + 1);
302 my $num_cols = () = $salt_plain =~ /:/g;
312 foreach (my $i = 0; $i < $num_cols; $i++)
314 $index2 = index ($salt_plain, ":", $start);
318 $start = $index2 + 1;
320 $index3 = rindex ($salt_plain, "#", $index2);
322 $raw_hash = substr ($salt_plain, $index3 + 1, $index2 - $index3 - 1);
323 $salt = substr ($salt_plain, 0, $index3);
324 $word = substr ($salt_plain, $index2 + 1);
326 if (exists ($db->{$hash_in . $salt . "#" .$raw_hash}))
328 $hash_in = $hash_in . $salt . "#" . $raw_hash;
334 next unless ($matched); # therefore: true == exists ($db->{$hash_in}
335 next unless (! defined ($db->{$hash_in}));
337 # salt:hash guaranteed only : because of hex salt
338 elsif ($mode == 7300)
340 # split hash and plain
341 my $index1 = index ($line, ":");
345 $salt = substr ($line, 0, $index1);
347 $salt = pack ("H*", $salt);
349 my $rest = substr ($line, $index1 + 1);
351 my $index2 = index ($rest, ":");
355 $hash_in = substr ($rest, 0, $index2);
357 $word = substr ($rest, $index2 + 1);
359 next unless (exists ($db->{$salt . ":" . $hash_in}) and (! defined ($db->{$hash_in})));
362 elsif ($mode == 8100)
364 # split hash and plain
365 $salt = substr ($line, 1, 8);
367 my $rest = substr ($line, 1 + 8);
369 my $index2 = index ($rest, ":");
373 $hash_in = substr ($rest, 0, $index2);
375 $word = substr ($rest, $index2 + 1);
377 next unless (exists ($db->{"1" . $salt . $hash_in}) and (! defined ($db->{$hash_in})));
379 # base64 and salt embedded SSHA1, salt length = total lenght - 20
382 # split hash and plain
383 my $index = index ($line, ":");
387 $hash_in = substr ($line, 0, $index);
388 $word = substr ($line, $index + 1);
390 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
393 my $plain_base64 = substr ($hash_in, 6);
395 # base64 decode to extract salt
396 my $decoded = decode_base64
($plain_base64);
398 $salt = substr ($decoded, 20);
400 # base64 and salt embedded SSHA512, salt length = total length - 64
401 elsif ($mode == 1711)
403 # split hash and plain
404 my $index = index ($line, ":");
408 $hash_in = substr ($line, 0, $index);
409 $word = substr ($line, $index + 1);
411 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
414 my $plain_base64 = substr ($hash_in, 9);
416 # base64 decode to extract salt
417 my $decoded = decode_base64
($plain_base64);
419 $salt = substr ($decoded, 64);
421 # OSX (first 8 hex chars is salt)
422 # ArubaOS (the signature gets added in gen_hash)
423 elsif ($mode == 122 || $mode == 1722 || $mode == 125)
425 my $index = index ($line, ":");
429 $hash_in = substr ($line, 0, $index);
430 $word = substr ($line, $index + 1);
432 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
434 $salt = substr ($hash_in, 0, 8);
436 # MSSQL (2000, 2005 AND 2012), salt after version number
437 elsif ($mode == 131 || $mode == 132 || $mode == 1731)
439 my $index = index ($line, ":");
443 $hash_in = substr ($line, 0, $index);
444 $word = substr ($line, $index + 1);
446 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
448 $salt = substr ($hash_in, 6, 8);
451 elsif ($mode == 8000)
453 my $index = index ($line, ":");
457 $hash_in = substr ($line, 0, $index);
458 $word = substr ($line, $index + 1);
460 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
462 $salt = substr ($hash_in, 6, 16);
465 elsif ($mode == 141 || $mode == 1441)
467 my $index1 = index ($line, ":");
471 $hash_in = substr ($line, 0, $index1);
472 $word = substr ($line, $index1 + 1);
474 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
476 my $index2 = index ($line, "*", 14);
478 #extract salt from base64
479 my $plain_base64 = substr ($hash_in, 14, $index2 - 14);
481 $salt = decode_base64
($plain_base64);
483 # phpass (first 8 after $P$/$H$ -- or $S$ with drupal7)
484 elsif ($mode == 400 || $mode == 7900)
486 my $index = index ($line, ":");
490 $hash_in = substr ($line, 0, $index);
491 $word = substr ($line, $index + 1);
493 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
495 $salt = substr ($hash_in, 4, 8);
497 # iterations = 2 ^ cost (where cost == $iter)
498 $iter = index ($itoa64_1, substr ($hash_in, 3, 1));
500 # $something$[rounds=iter$]salt$ (get last $, then check iter)
501 elsif ($mode == 500 || $mode == 1600 || $mode == 1800 || $mode == 3300 || $mode == 7400)
503 my $index1 = index ($line, ":", 30);
507 $hash_in = substr ($line, 0, $index1);
508 $word = substr ($line, $index1 + 1);
510 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
512 $index1 = index ($hash_in, ",", 1);
513 my $index2 = index ($hash_in, "\$", 1);
517 if ($index1 < $index2)
523 $param = substr ($hash_in, $index2, 1);
527 # rounds= if available
530 if (substr ($hash_in, $index2, 7) eq "rounds=")
532 my $old_index = $index2;
534 $index2 = index ($hash_in, "\$", $index2 + 1);
538 $iter = substr ($hash_in, $old_index + 7, $index2 - $old_index - 7);
544 my $index3 = rindex ($hash_in, "\$");
548 $salt = substr ($hash_in, $index2, $index3 - $index2);
550 # descrypt (salt in first 2 char)
551 elsif ($mode == 1500)
553 my $index = index ($line, ":");
557 $hash_in = substr ($line, 0, $index);
558 $word = substr ($line, $index + 1);
560 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
562 $salt = substr ($hash_in, 0, 2);
564 # bcrypt $something$something$salt.hash
565 elsif ($mode == 3200)
567 my $index1 = index ($line, ":", 33);
571 $hash_in = substr ($line, 0, $index1);
572 $word = substr ($line, $index1 + 1);
574 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
576 my $index2 = index ($hash_in, "\$", 4);
578 $iter = substr ($hash_in, 4, $index2 - 4);
580 my $plain_base64 = substr ($hash_in, $index2 + 1, 22);
585 for (my $i = 0; $i < length ($plain_base64); $i++)
587 my $char = substr ($plain_base64, $i, 1);
588 $encoded .= substr ($base64, index ($itoa64_2, $char), 1);
591 $salt = decode_base64
($encoded);
594 elsif ($mode == 4800)
596 my $index1 = index ($line, ":");
600 my $index2 = index ($line, ":", $index1 + 1);
604 my $index3 = index ($line, ":", $index2 + 1);
608 $salt = substr ($line, $index1 + 1, $index3 - $index1 - 1);
610 $word = substr ($line, $index3 + 1);
612 $hash_in = substr ($line, 0, $index3);
615 elsif ($mode == 5300 || $mode == 5400)
617 my $num_cols = () = $line =~ /:/g;
619 next unless ($num_cols >= 9);
624 for (my $j = 0; $j < 9; $j++)
626 $index1 = index ($line, ":", $index1 + 1);
637 $word = substr ($line, $index1 + 1);
639 $hash_in = substr ($line, 0, $index1);
641 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
643 my $index2 = rindex ($line, ":", $index1 - 1);
645 $salt = substr ($line, 0, $index2);
648 elsif ($mode == 5500)
650 my $index1 = index ($line, "::");
654 my $index2 = index ($line, ":", $index1 + 2);
658 $index2 = index ($line, ":", $index2 + 1);
662 $salt = substr ($line, 0, $index2);
664 $index2 = index ($line, ":", $index2 + 1);
668 $salt .= substr ($line, $index2 + 1, 16);
670 $index2 = index ($line, ":", $index2 + 1);
674 $hash_in = substr ($line, 0, $index2);
676 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
678 $word = substr ($line, $index2 + 1);
681 elsif ($mode == 5600)
683 my $index1 = index ($line, "::");
687 my $index2 = index ($line, ":", $index1 + 2);
691 $index2 = index ($line, ":", $index2 + 1);
695 $salt = substr ($line, 0, $index2);
697 $index1 = index ($line, ":", $index2 + 1);
701 $index2 = index ($line, ":", $index1 + 1);
705 $salt .= substr ($line, $index1 + 1, $index2 - $index1 - 1);
707 $hash_in = substr ($line, 0, $index2);
709 # do it later on for this hash mode:
710 # next unless ((exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))) or (exists ($db->{$mod}) and (! defined ($db->{$mod}))));
712 $word = substr ($line, $index2 + 1);
714 # AIX smd5 something BRACE salt$
715 elsif ($mode == 6300)
717 my $index1 = index ($line, ":");
721 $hash_in = substr ($line, 0, $index1);
722 $word = substr ($line, $index1 + 1);
724 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
726 my $index2 = index ($hash_in, "}");
727 my $index3 = rindex ($hash_in, "\$");
729 $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
731 # AIX: something$salt$ (no $ at position 1)
732 elsif ($mode == 6400 || $mode == 6500 || $mode == 6700)
734 my $index1 = index ($line, ":");
738 $hash_in = substr ($line, 0, $index1);
739 $word = substr ($line, $index1 + 1);
741 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
743 my $index2 = index ($hash_in, "}");
744 my $index3 = index ($hash_in, "\$");
745 my $index4 = rindex ($hash_in, "\$");
747 $salt = substr ($hash_in, $index3 + 1, $index4 - $index3 - 1);
749 $iter = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
751 # 1Password, agilekeychain
752 elsif ($mode == 6600)
754 my $num_cols = () = $line =~ /:/g;
756 next unless ($num_cols > 2);
758 my $index1 = index ($line, ":");
762 $iter = substr ($line, 0, $index1);
764 my $index2 = index ($line, ":", $index1 + 1);
768 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
770 $index1 = index ($line, ":", $index2 + 1);
774 $salt .= substr ($line, $index2 + 1, $index1 - $index2 - 33);
776 $hash_in = substr ($line, 0, $index1);
778 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
780 $word = substr ($line, $index1 + 1);
782 # 1Password, cloudkeychain
783 elsif ($mode == 8200)
785 my @datas = split (":", $line);
787 next if scalar @datas < 4;
789 my $hash = shift @datas;
790 $salt = shift @datas;
791 $iter = shift @datas;
792 my $data = shift @datas;
794 $hash_in = $hash . ":" . $salt . ":" . $iter . ":" . $data;
798 $word = join (":", @datas);
800 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
802 # lastpass (hash:iter:salt)
803 elsif ($mode == 6800)
805 my $index1 = index ($line, ":", 34);
809 $hash_in = substr ($line, 0, $index1);
811 # identify lenghts of both salt and plain
813 my $salt_plain = substr ($line, $index1 + 1);
815 my $num_cols = () = $salt_plain =~ /:/g;
824 foreach (my $i = 0; $i < $num_cols; $i++)
826 $index2 = index ($salt_plain, ":", $start);
830 $start = $index2 + 1;
832 $salt = substr ($salt_plain, 0, $index2);
833 $word = substr ($salt_plain, $index2 + 1);
835 # can't be true w/ wrong $hash:$salt, otherwise the
836 # algo must have many collisions
838 if (exists ($db->{$hash_in . ":" . $salt}))
840 $hash_in = $hash_in . ":" . $salt;
846 next unless ($matched); # therefore: true == exists ($db->{$hash_in}
847 next unless (! defined ($db->{$hash_in}));
849 $index1 = index ($hash_in, ":");
850 $index2 = index ($hash_in, ":", $index1 + 1);
852 $iter = substr ($hash_in, $index1 + 1, $index2 - $index1 - 1);
853 $salt = substr ($hash_in, $index2 + 1);
855 # OSX 10.* : $something$iter$salt$
856 elsif ($mode == 7100)
858 my $index1 = index ($line, ":");
862 $hash_in = substr ($line, 0, $index1);
863 $word = substr ($line, $index1 + 1);
865 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
867 my $index2 = index ($hash_in, "\$", 5);
871 my $index3 = index ($hash_in, "\$", $index2 + 1);
873 $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
875 $iter = substr ($hash_in, 4, $index2 - 4);
877 next if (int ($iter) < 1);
879 # grub: something1.something2.something3.iter.salt.
880 elsif ($mode == 7200)
882 my $index1 = index ($line, ":");
886 $hash_in = substr ($line, 0, $index1);
887 $word = substr ($line, $index1 + 1);
889 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
891 my $index2 = index ($hash_in, ".", 19);
895 my $index3 = index ($hash_in, ".", $index2 + 1);
897 $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
899 $iter = substr ($hash_in, 19, $index2 - 19);
901 next if (int ($iter) < 1);
903 # $something1$something2$something3$something4$salt$
904 elsif ($mode == 7500 )
906 my $index1 = index ($line, "\$", 11);
910 my $index2 = index ($line, "\$", $index1 + 1);
914 my $index3 = index ($line, "\$", $index2 + 1);
918 $index2 = index ($line, ":", $index3 + 1);
922 $hash_in = substr ($line, 0, $index2);
923 $word = substr ($line, $index2 + 1);
925 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
927 $salt = substr ($hash_in, 11, $index3 - 10);
928 $salt .= substr ($hash_in, $index2 - 32) . "\$\$";
929 $salt .= substr ($hash_in, $index3 + 1, $index2 - $index3 - 32 - 1);
932 elsif ($mode == 7700 || $mode == 7800)
934 my $index1 = index ($line, ":");
938 my @split1 = split (":", $line);
940 my @split2 = split ('\$', $split1[0]);
942 next unless scalar @split2 == 2;
944 $hash_in = $split1[0];
946 if (scalar @split1 > 1)
955 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
960 elsif ($mode == 8300)
962 my @datas = split (":", $line);
964 next if scalar @datas != 5;
969 ($hash, $domain, $salt, $iter, $word) = @datas;
971 $hash_in = $hash . ":" . $domain . ":" . $salt . ":" . $iter;
973 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
975 $salt = $domain . ":" . $salt;
978 elsif ($mode == 8500)
980 my @line_elements = split (":", $line);
982 next if scalar @line_elements < 2;
986 $hash_in = shift @line_elements;
988 $word = join (":", @line_elements);
992 my @hash_elements = split ('\*', $hash_in);
994 next unless ($hash_elements[0] eq '$racf$');
996 $salt = $hash_elements[1];
998 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1001 elsif ($mode == 8700)
1003 # split hash and plain
1004 my $index = index ($line, ":");
1008 $hash_in = substr ($line, 0, $index);
1009 $word = substr ($line, $index + 1);
1011 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1013 my $plain_base64 = substr ($hash_in, 2, -1);
1015 ($_, $salt, $param) = domino_decode
($plain_base64);
1018 elsif ($mode == 2612)
1020 next unless (substr ($line, 0, 6) eq '$PHPS$');
1023 my $index1 = index ($line, "\$", 6);
1025 next if $index1 < 1;
1027 $salt = substr ($line, 6, $index1 - 6);
1029 $salt = pack ("H*", $salt);
1031 my $index2 = index ($line, "\:", $index1 + 1);
1033 next if $index2 < 1;
1035 $word = substr ($line, $index2 + 1);
1037 $hash_in = substr ($line, 0, $index2);
1039 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1042 elsif ($mode == 3711)
1044 next unless (substr ($line, 0, 3) eq '$B$');
1047 my $index1 = index ($line, "\$", 3);
1049 next if $index1 < 1;
1051 $salt = substr ($line, 3, $index1 - 3);
1053 my $index2 = index ($line, ":", $index1 + 1);
1055 next if $index2 < 1;
1057 $word = substr ($line, $index2 + 1);
1059 $hash_in = substr ($line, 0, $index2);
1061 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1064 elsif ($mode == 8900)
1066 next unless (substr ($line, 0, 7) eq 'SCRYPT:');
1069 my $index1 = index ($line, ":", 7);
1071 next if $index1 < 1;
1074 my $N = substr ($line, 7, $index1 - 7);
1076 my $index2 = index ($line, ":", $index1 + 1);
1078 next if $index2 < 1;
1081 my $r = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1083 $index1 = index ($line, ":", $index2 + 1);
1085 next if $index1 < 1;
1088 my $p = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1094 $index2 = index ($line, ":", $index1 + 1);
1096 next if $index2 < 1;
1099 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1101 $salt = decode_base64
($salt);
1103 $index1 = index ($line, ":", $index2 + 1);
1105 next if $index1 < 1;
1109 $word = substr ($line, $index1 + 1);
1110 $hash_in = substr ($line, 0, $index1);
1112 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1115 elsif ($mode == 9100)
1117 # split hash and plain
1118 my $index = index ($line, ":");
1122 $hash_in = substr ($line, 0, $index);
1123 $word = substr ($line, $index + 1);
1125 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1127 my $base64_part = substr ($hash_in, 2, -1);
1129 ($_, $salt, $iter, $param) = domino_85x_decode
($base64_part);
1131 next if ($iter < 1);
1133 # Cisco $8$ - PBKDF2-HMAC-SHA256
1134 elsif ($mode == 9200)
1136 next unless (substr ($line, 0, 3) eq '$8$');
1139 my $index1 = index ($line, "\$", 3);
1141 next if $index1 != 17;
1143 my $index2 = index ($line, "\$", $index1 + 1);
1146 $salt = substr ($line, 3, $index1 - 3);
1148 $index1 = index ($line, ":", $index1 + 1);
1150 next if $index1 < 1;
1154 $word = substr ($line, $index1 + 1);
1155 $hash_in = substr ($line, 0, $index1);
1157 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1159 # Cisco $9$ - scrypt
1160 elsif ($mode == 9300)
1162 next unless (substr ($line, 0, 3) eq '$9$');
1165 my $index1 = index ($line, "\$", 3);
1167 next if $index1 != 17;
1169 my $index2 = index ($line, "\$", $index1 + 1);
1172 $salt = substr ($line, 3, $index1 - 3);
1174 $index1 = index ($line, ":", $index1 + 1);
1176 next if $index1 < 1;
1180 $word = substr ($line, $index1 + 1);
1181 $hash_in = substr ($line, 0, $index1);
1183 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1186 elsif ($mode == 9400)
1188 ($hash_in, $word) = split ":", $line;
1190 next unless defined $hash_in;
1191 next unless defined $word;
1193 my @data = split /\*/, $hash_in;
1195 next unless scalar @data == 8;
1197 next unless (shift @data eq '$office$');
1198 next unless (shift @data eq '2007');
1199 next unless (shift @data eq '20');
1201 my $aes_key_size = shift @data;
1203 next unless (($aes_key_size eq '128') || ($aes_key_size eq '256'));
1204 next unless (shift @data eq '16');
1206 next unless (length $data[0] == 32);
1207 next unless (length $data[1] == 32);
1208 next unless (length $data[2] == 40);
1210 $salt = shift @data;
1211 $param = shift @data;
1212 $param2 = $aes_key_size;
1214 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1217 elsif ($mode == 9500)
1219 ($hash_in, $word) = split ":", $line;
1221 next unless defined $hash_in;
1222 next unless defined $word;
1224 my @data = split /\*/, $hash_in;
1226 next unless scalar @data == 8;
1228 next unless (shift @data eq '$office$');
1229 next unless (shift @data eq '2010');
1230 next unless (shift @data eq '100000');
1231 next unless (shift @data eq '128');
1232 next unless (shift @data eq '16');
1234 next unless (length $data[0] == 32);
1235 next unless (length $data[1] == 32);
1236 next unless (length $data[2] == 64);
1238 $salt = shift @data;
1239 $param = shift @data;
1241 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1244 elsif ($mode == 9600)
1246 ($hash_in, $word) = split ":", $line;
1248 next unless defined $hash_in;
1249 next unless defined $word;
1251 my @data = split /\*/, $hash_in;
1253 next unless scalar @data == 8;
1255 next unless (shift @data eq '$office$');
1256 next unless (shift @data eq '2013');
1257 next unless (shift @data eq '100000');
1258 next unless (shift @data eq '256');
1259 next unless (shift @data eq '16');
1261 next unless (length $data[0] == 32);
1262 next unless (length $data[1] == 32);
1263 next unless (length $data[2] == 64);
1265 $salt = shift @data;
1266 $param = shift @data;
1268 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1271 elsif ($mode == 9700)
1273 ($hash_in, $word) = split ":", $line;
1275 next unless defined $hash_in;
1276 next unless defined $word;
1278 my @data = split /\*/, $hash_in;
1280 next unless scalar @data == 4;
1282 my $signature = shift @data;
1284 next unless (($signature eq '$oldoffice$0') || ($signature eq '$oldoffice$1'));
1286 next unless (length $data[0] == 32);
1287 next unless (length $data[1] == 32);
1288 next unless (length $data[2] == 32);
1290 $salt = shift @data;
1291 $param = shift @data;
1292 $param2 = substr ($signature, 11, 1);
1294 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1297 elsif ($mode == 9800)
1299 ($hash_in, $word) = split ":", $line;
1301 next unless defined $hash_in;
1302 next unless defined $word;
1304 my @data = split /\*/, $hash_in;
1306 next unless scalar @data == 4;
1308 my $signature = shift @data;
1310 next unless (($signature eq '$oldoffice$3') || ($signature eq '$oldoffice$4'));
1312 next unless (length $data[0] == 32);
1313 next unless (length $data[1] == 32);
1314 next unless (length $data[2] == 40);
1316 $salt = shift @data;
1317 $param = shift @data;
1318 $param2 = substr ($signature, 11, 1);
1320 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1322 # Django (PBKDF2-SHA256)
1323 elsif ($mode == 10000)
1325 next unless (substr ($line, 0, 14) eq 'pbkdf2_sha256$');
1328 my $index1 = index ($line, "\$", 14);
1330 next if $index1 < 1;
1332 my $index2 = index ($line, "\$", $index1 + 1);
1336 $iter = substr ($line, 14, $index1 - 14);
1340 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1344 $index1 = index ($line, ":", $index2 + 1);
1346 next if $index1 < 1;
1348 $word = substr ($line, $index1 + 1);
1349 $hash_in = substr ($line, 0, $index1);
1351 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1354 elsif ($mode == 10100)
1358 ($hash, undef, undef, $salt, $word) = split ":", $line;
1360 next unless defined $hash;
1361 next unless defined $salt;
1362 next unless defined $word;
1364 next unless (length $hash == 16);
1365 next unless (length $salt == 32);
1367 my $hash_in = sprintf ("%s:2:4:%s", $hash, $salt);
1369 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1372 elsif ($mode == 10200)
1374 next unless (substr ($line, 0, 10) eq '$cram_md5$');
1377 my $index1 = index ($line, "\$", 10);
1379 next if $index1 < 1;
1383 my $challengeb64 = substr ($line, 10, $index1 - 10);
1384 $salt = decode_base64
($challengeb64);
1388 my $index2 = index ($line, ":", $index1 + 1);
1390 next if $index2 < 1;
1392 my $responseb64 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1393 my $response = decode_base64
($responseb64);
1395 $param = substr ($response, 0, length ($response) - 32 - 1); # -1 is for space
1397 $word = substr ($line, $index2 + 1);
1398 $hash_in = substr ($line, 0, $index2);
1400 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1402 # SAP CODVN H (PWDSALTEDHASH) iSSHA-1
1403 elsif ($mode == 10300)
1405 next unless (substr ($line, 0, 10) eq '{x-issha, ');
1409 my $index1 = index ($line, "}", 10);
1411 next if $index1 < 1;
1413 $iter = substr ($line, 10, $index1 - 10);
1415 $iter = int ($iter);
1419 my $base64_encoded = substr ($line, $index1 + 1);
1420 my $base64_decoded = decode_base64
($base64_encoded);
1422 $salt = substr ($base64_decoded, 20);
1424 my $index2 = index ($line, ":", $index1 + 1);
1426 next if $index2 < 1;
1428 $word = substr ($line, $index2 + 1);
1429 $hash_in = substr ($line, 0, $index2);
1431 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1433 # PDF 1.1 - 1.3 (Acrobat 2 - 4)
1434 elsif ($mode == 10400)
1436 ($hash_in, $word) = split ":", $line;
1438 next unless defined $hash_in;
1439 next unless defined $word;
1441 my @data = split /\*/, $hash_in;
1443 next unless scalar @data == 11;
1445 next unless (shift @data eq '$pdf$1');
1446 next unless (shift @data eq '2');
1447 next unless (shift @data eq '40');
1448 my $P = shift @data;
1449 next unless (shift @data eq '0');
1450 next unless (shift @data eq '16');
1451 my $id = shift @data;
1452 next unless (shift @data eq '32');
1453 my $u = shift @data;
1454 next unless (shift @data eq '32');
1455 my $o = shift @data;
1462 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1464 # PDF 1.4 - 1.6 (Acrobat 5 - 8)
1465 elsif ($mode == 10500)
1467 ($hash_in, $word) = split ":", $line;
1469 next unless defined $hash_in;
1470 next unless defined $word;
1472 my @data = split /\*/, $hash_in;
1474 next unless scalar @data == 11;
1476 my $V = shift @data; $V = substr ($V, 5, 1);
1477 my $R = shift @data;
1478 next unless (shift @data eq '128');
1479 my $P = shift @data;
1480 my $enc = shift @data;
1481 next unless (shift @data eq '16');
1482 my $id = shift @data;
1483 next unless (shift @data eq '32');
1484 my $u = shift @data;
1485 next unless (shift @data eq '32');
1486 my $o = shift @data;
1496 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1498 # PDF 1.7 Level 3 (Acrobat 9)
1499 elsif ($mode == 10600)
1501 ($hash_in, $word) = split ":", $line;
1503 next unless defined $hash_in;
1504 next unless defined $word;
1506 my @data = split /\*/, $hash_in;
1508 next unless scalar @data >= 11;
1510 next unless (shift @data eq '$pdf$5');
1511 next unless (shift @data eq '5');
1512 next unless (shift @data eq '256');
1513 next unless (shift @data eq '-1028');
1514 next unless (shift @data eq '1');
1515 next unless (shift @data eq '16');
1516 my $id = shift @data;
1517 my $rest = join "*", @data;
1522 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1524 # PDF 1.7 Level 8 (Acrobat 10 - 11)
1525 elsif ($mode == 10700)
1527 ($hash_in, $word) = split ":", $line;
1529 next unless defined $hash_in;
1530 next unless defined $word;
1532 my @data = split /\*/, $hash_in;
1534 next unless scalar @data >= 11;
1536 next unless (shift @data eq '$pdf$5');
1537 next unless (shift @data eq '6');
1538 next unless (shift @data eq '256');
1539 next unless (shift @data eq '-1028');
1540 next unless (shift @data eq '1');
1541 next unless (shift @data eq '16');
1542 my $id = shift @data;
1543 my $rest = join "*", @data;
1548 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1550 # PBKDF2-HMAC-SHA256
1551 elsif ($mode == 10900)
1553 next unless (substr ($line, 0, 7) eq 'sha256:');
1556 my $index1 = index ($line, ":", 7);
1558 next if $index1 < 1;
1560 $iter = substr ($line, 7, $index1 - 7);
1564 my $index2 = index ($line, ":", $index1 + 1);
1566 next if $index2 < 1;
1568 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1570 $salt = decode_base64
($salt);
1574 $index1 = index ($line, ":", $index2 + 1);
1576 next if $index1 < 1;
1578 # additional param = output len of pbkdf2
1580 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1582 my $digest = decode_base64
($digest64_encoded);
1584 $param = length ($digest);
1588 $word = substr ($line, $index1 + 1);
1589 $hash_in = substr ($line, 0, $index1);
1591 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1593 # PostgreSQL MD5 Authentication
1594 elsif ($mode == 11100)
1596 next unless (substr ($line, 0, 10) eq '$postgres$');
1598 my $index1 = index ($line, "*", 10);
1600 next if $index1 < 1;
1604 $param = substr ($line, 10, $index1 - 10);
1606 # get the 4 byte salt
1608 my $index2 = index ($line, "*", $index1 + 1);
1610 next if $index2 < 1;
1612 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1616 $index1 = index ($line, ":", $index2 + 1);
1618 next if $index1 < 1;
1620 $word = substr ($line, $index1 + 1);
1621 $hash_in = substr ($line, 0, $index1);
1623 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1625 # MySQL MD5 Authentication
1626 elsif ($mode == 11200)
1628 next unless (substr ($line, 0, 9) eq '$mysqlna$');
1630 my $index1 = index ($line, "*", 9);
1632 next if $index1 < 1;
1636 $salt = substr ($line, 9, $index1 - 9);
1640 $index1 = index ($line, ":", $index1 + 1);
1642 next if $index1 < 1;
1644 $word = substr ($line, $index1 + 1);
1645 $hash_in = substr ($line, 0, $index1);
1647 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1650 elsif ($mode == 2500)
1652 print "ERROR: verify currently not supported for WPA/WPA2 (because of hashcat's output format)\n";
1656 # Bitcoin/Litecoin wallet.dat
1657 elsif ($mode == 11300)
1659 print "ERROR: verify currently not supported for Bitcoin/Litecoin wallet.dat because of unknown crypt data\n";
1663 # SIP digest authentication (MD5)
1664 elsif ($mode == 11400)
1666 next unless (substr ($line, 0, 6) eq '$sip$*');
1670 my $index1 = index ($line, "*", 6);
1672 next if $index1 < 0;
1674 $param10 = substr ($line, 6, $index1 - 6);
1676 next if (length ($param10) > 32);
1680 my $index2 = index ($line, "*", $index1 + 1);
1682 next if $index2 < 0;
1684 $param11 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1686 next if (length ($param11) > 32);
1690 $index1 = index ($line, "*", $index2 + 1);
1692 next if $index1 < 0;
1694 $param = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1696 next if (length ($param) > 12);
1700 $index2 = index ($line, "*", $index1 + 1);
1702 next if $index2 < 0;
1704 $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1706 next if (length ($param2) > 20);
1710 $index1 = index ($line, "*", $index2 + 1);
1712 next if $index1 < 0;
1714 $param6 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1716 next if (length ($param6) > 24);
1720 $index2 = index ($line, "*", $index1 + 1);
1722 next if $index2 < 0;
1724 $param7 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1726 next if (length ($param7) > 10);
1730 $index1 = index ($line, "*", $index2 + 1);
1732 next if $index1 < 0;
1734 $param8 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1736 next if (length ($param8) > 32);
1740 $index2 = index ($line, "*", $index1 + 1);
1742 next if $index2 < 0;
1744 $param9 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1746 next if (length ($param9) > 32);
1750 $index1 = index ($line, "*", $index2 + 1);
1752 next if $index1 < 0;
1754 $salt = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1756 next if (length ($salt) > 34);
1760 $index2 = index ($line, "*", $index1 + 1);
1762 next if $index2 < 0;
1764 $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1766 next if (length ($param4) > 12);
1770 $index1 = index ($line, "*", $index2 + 1);
1772 next if $index1 < 0;
1774 $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1776 next if (length ($param3) > 10);
1780 $index2 = index ($line, "*", $index1 + 1);
1782 next if $index2 < 0;
1784 $param5 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1786 next if (length ($param5) > 8);
1790 $index1 = index ($line, "*", $index2 + 1);
1792 next if $index1 < 0;
1794 my $directive = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1796 next unless ($directive eq "MD5");
1800 $index2 = index ($line, ":", $index1 + 1);
1802 next if $index2 < 0;
1804 my $hex_digest = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1806 next unless (length ($hex_digest) == 32);
1808 $word = substr ($line, $index2 + 1);
1809 $hash_in = substr ($line, 0, $index2);
1811 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1814 elsif ($mode == 11600)
1816 next unless (substr ($line, 0, 4) eq '$7z$');
1820 my $index1 = index ($line, '$', 4);
1822 next if $index1 < 0;
1824 my $p = substr ($line, 4, $index1 - 4);
1826 next unless ($p eq "0");
1830 my $index2 = index ($line, '$', $index1 + 1);
1832 next if $index2 < 0;
1834 $iter = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1836 # seven zip salt length
1838 $index1 = index ($line, '$', $index2 + 1);
1840 next if $index1 < 0;
1842 $param = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1846 $index2 = index ($line, '$', $index1 + 1);
1848 next if $index2 < 0;
1850 $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1854 $index1 = index ($line, '$', $index2 + 1);
1856 next if $index1 < 0;
1858 $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1862 $index2 = index ($line, '$', $index1 + 1);
1864 next if $index2 < 0;
1866 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1868 $salt = pack ("H*", $salt);
1872 $index1 = index ($line, '$', $index2 + 1);
1874 next if $index1 < 0;
1876 my $crc = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1878 # ignore this crc, we don't need to pass it to gen_hash ()
1882 $index2 = index ($line, '$', $index1 + 1);
1884 next if $index2 < 0;
1886 $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1890 $index1 = index ($line, '$', $index2 + 1);
1892 next if $index1 < 0;
1894 $param5 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1898 $index2 = index ($line, ':', $index1 + 1);
1900 next if $index2 < 0;
1902 $param6 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1903 $param6 = pack ("H*", $param6);
1905 $word = substr ($line, $index2 + 1);
1906 $hash_in = substr ($line, 0, $index2);
1908 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1911 elsif ($mode == 11900)
1913 next unless (substr ($line, 0, 4) eq 'md5:');
1916 my $index1 = index ($line, ":", 4);
1918 next if $index1 < 1;
1920 $iter = substr ($line, 4, $index1 - 4);
1924 my $index2 = index ($line, ":", $index1 + 1);
1926 next if $index2 < 1;
1928 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1930 $salt = decode_base64
($salt);
1934 $index1 = index ($line, ":", $index2 + 1);
1936 next if $index1 < 1;
1938 # additional param = output len of pbkdf2
1940 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1942 my $digest = decode_base64
($digest64_encoded);
1944 $param = length ($digest);
1948 $word = substr ($line, $index1 + 1);
1949 $hash_in = substr ($line, 0, $index1);
1951 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1954 elsif ($mode == 12000)
1956 next unless (substr ($line, 0, 5) eq 'sha1:');
1959 my $index1 = index ($line, ":", 5);
1961 next if $index1 < 1;
1963 $iter = substr ($line, 5, $index1 - 5);
1967 my $index2 = index ($line, ":", $index1 + 1);
1969 next if $index2 < 1;
1971 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1973 $salt = decode_base64
($salt);
1977 $index1 = index ($line, ":", $index2 + 1);
1979 next if $index1 < 1;
1981 # additional param = output len of pbkdf2
1983 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1985 my $digest = decode_base64
($digest64_encoded);
1987 $param = length ($digest);
1991 $word = substr ($line, $index1 + 1);
1992 $hash_in = substr ($line, 0, $index1);
1994 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1996 # PBKDF2-HMAC-SHA512
1997 elsif ($mode == 12100)
1999 next unless (substr ($line, 0, 7) eq 'sha512:');
2002 my $index1 = index ($line, ":", 7);
2004 next if $index1 < 1;
2006 $iter = substr ($line, 7, $index1 - 7);
2010 my $index2 = index ($line, ":", $index1 + 1);
2012 next if $index2 < 1;
2014 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
2016 $salt = decode_base64
($salt);
2020 $index1 = index ($line, ":", $index2 + 1);
2022 next if $index1 < 1;
2024 # additional param = output len of pbkdf2
2026 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
2028 my $digest = decode_base64
($digest64_encoded);
2030 $param = length ($digest);
2034 $word = substr ($line, $index1 + 1);
2035 $hash_in = substr ($line, 0, $index1);
2037 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2040 elsif ($mode == 12200)
2042 next unless (substr ($line, 0, 12) eq '$ecryptfs$0$');
2044 # check if default salt
2048 $param = 0 if (substr ($line, 12, 2) eq '1$');
2056 if ($param == 0) # we need to extract the salt
2058 $index1 = index ($line, '$', $index1);
2060 next if $index1 < 1;
2062 my $index2 = index ($line, '$', $index1 + 1);
2064 next if $index2 < 1;
2066 $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
2071 $index1 = index ($line, ':', $index1 + 1);
2073 next if $index1 < 1;
2077 $word = substr ($line, $index1 + 1);
2078 $hash_in = substr ($line, 0, $index1);
2080 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2082 # Oracle T: Type (Oracle 12+)
2083 elsif ($mode == 12300)
2085 my $index1 = index ($line, ':');
2087 next if ($index1 != 160);
2091 $salt = substr ($line, 128, 32);
2095 $word = substr ($line, $index1 + 1);
2096 $hash_in = substr ($line, 0, $index1);
2098 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2100 # BSDiCrypt, Extended DES
2101 elsif ($mode == 12400)
2103 next unless (substr ($line, 0, 1) eq '_');
2105 my $index1 = index ($line, ':', 20);
2107 next if ($index1 != 20);
2111 $iter = substr ($line, 1, 4);
2113 $iter = base64_to_int24
($iter);
2117 $salt = substr ($line, 5, 4);
2121 $word = substr ($line, $index1 + 1);
2122 $hash_in = substr ($line, 0, $index1);
2124 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2126 # Blockchain, My Wallet
2127 elsif ($mode == 12700)
2129 my $index1 = index ($line, ':');
2131 next if ($index1 < 0);
2133 $hash_in = substr ($line, 0, $index1);
2134 $word = substr ($line, $index1 + 1);
2136 my (undef, $signature, $data_len, $data_buf) = split '\$', $hash_in;
2138 next unless ($signature eq "blockchain");
2140 next unless (($data_len * 2) == length $data_buf);
2142 $salt = substr ($data_buf, 0, 32);
2143 $param = substr ($data_buf, 32);
2145 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2147 elsif ($mode == 12800)
2149 ($hash_in, $word) = split ":", $line;
2151 next unless defined $hash_in;
2152 next unless defined $word;
2154 my @data = split /\,/, $hash_in;
2156 next unless scalar @data == 4;
2158 next unless (shift @data eq 'v1;PPH1_MD4');
2160 $salt = shift @data;
2161 $iter = shift @data;
2163 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2165 elsif ($mode == 12900)
2167 ($hash_in, $word) = split ":", $line;
2169 next unless defined $hash_in;
2170 next unless defined $word;
2172 next unless length $hash_in == 160;
2174 $param = substr ($hash_in, 0, 64);
2175 $salt = substr ($hash_in, 128, 32);
2178 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2180 elsif ($mode == 13000)
2184 ($hash_line, $word) = split ":", $line;
2186 next unless defined $hash_line;
2187 next unless defined $word;
2189 my @data = split ('\$', $hash_line);
2191 next unless scalar @data == 8;
2195 my $signature = shift @data;
2196 my $salt_len = shift @data;
2197 my $salt_buf = shift @data;
2198 my $iterations = shift @data;
2199 my $iv = shift @data;
2200 my $pswcheck_len = shift @data;
2201 my $pswcheck = shift @data;
2203 next unless ($signature eq "rar5");
2204 next unless ($salt_len == 16);
2205 next unless ($pswcheck_len == 8);
2208 $iter = $iterations;
2209 $hash_in = $pswcheck;
2212 next unless (exists ($db->{$hash_line}) and (! defined ($db->{$hash_line})));
2214 elsif ($mode == 13100 )
2216 ($hash_in, $word) = split ":", $line;
2218 next unless defined $hash_in;
2219 next unless defined $word;
2221 my @data = split ('\$', $hash_in);
2223 next unless scalar @data == 8;
2227 my $signature = shift @data;
2228 my $algorithm = shift @data;
2229 my $user = shift @data;
2230 $user = substr ($user, 1);
2231 my $realm = shift @data;
2232 my $spn = shift @data;
2233 $spn = substr ($spn, 0, length ($spn) - 1);
2234 my $checksum = shift @data;
2235 my $edata2 = shift @data;
2237 next unless ($signature eq "krb5tgs");
2238 next unless (length ($checksum) == 32);
2239 next unless (length ($edata2) >= 64);
2241 $salt = $user . '$' . $realm . '$' . $spn . '$' . substr ($edata2, 0, 16);
2243 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2245 elsif ($mode == 13200)
2247 ($hash_in, $word) = split ":", $line;
2249 next unless defined $hash_in;
2250 next unless defined $word;
2252 my @data = split ('\*', $hash_in);
2254 next unless scalar @data == 5;
2258 my $signature = shift @data;
2259 my $version = shift @data;
2260 my $iteration = shift @data;
2261 my $mysalt = shift @data;
2262 my $digest = shift @data;
2264 next unless ($signature eq '$axcrypt$');
2265 next unless (length ($mysalt) == 32);
2266 next unless (length ($digest) == 48);
2268 $salt = $iteration . '*' . $mysalt;
2270 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2272 elsif ($mode == 13300)
2274 ($hash_in, $word) = split ":", $line;
2276 next unless defined $hash_in;
2277 next unless defined $word;
2279 my @data = split ('\$', $hash_in);
2281 next unless scalar @data == 2;
2285 my $signature = shift @data;
2286 my $digest = shift @data;
2288 next unless ($signature eq '$axcrypt_sha1');
2289 next unless (length ($digest) == 32 || length ($digest) == 40);
2291 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2293 elsif ($mode == 13400)
2295 ($hash_in, $word) = split ":", $line;
2297 next unless defined $hash_in;
2298 next unless defined $word;
2300 my @data = split ('\*', $hash_in);
2302 next unless (scalar @data == 9
2303 || scalar @data == 11
2304 || scalar @data == 12
2305 || scalar @data == 14);
2307 my $signature = shift @data;
2308 next unless ($signature eq '$keepass$');
2310 my $version = shift @data;
2311 next unless ($version == 1 || $version == 2);
2313 my $iteration = shift @data;
2315 my $algorithm = shift @data;
2317 my $final_random_seed = shift @data;
2321 next unless (length ($final_random_seed) == 32);
2323 elsif ($version == 2)
2325 next unless (length ($final_random_seed) == 64);
2328 my $transf_random_seed = shift @data;
2329 next unless (length ($transf_random_seed) == 64);
2331 my $enc_iv = shift @data;
2332 next unless (length ($enc_iv) == 32);
2336 my $contents_hash = shift @data;
2337 next unless (length ($contents_hash) == 64);
2339 my $inline_flags = shift @data;
2340 next unless ($inline_flags == 1);
2342 my $contents_len = shift @data;
2344 my $contents = shift @data;
2345 next unless (length ($contents) == $contents_len * 2);
2347 elsif ($version == 2)
2349 my $expected_bytes = shift @data;
2350 next unless (length ($expected_bytes) == 64);
2352 my $contents_hash = shift @data;
2353 next unless (length ($contents_hash) == 64);
2356 if (scalar @data == 12 || scalar @data == 14)
2358 my $inline_flags = shift @data;
2359 next unless ($inline_flags == 1);
2361 my $keyfile_len = shift @data;
2362 next unless ($keyfile_len == 64);
2364 my $keyfile = shift @data;
2365 next unless (length ($keyfile) == $keyfile_len);
2368 $salt = substr ($hash_in, length ("*keepass*") + 1, length ($hash_in));
2370 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2372 elsif ($mode == 13600)
2374 ($hash_in, $word) = split ":", $line;
2376 next unless defined $hash_in;
2377 next unless defined $word;
2379 my @data = split ('\*', $hash_in);
2381 next unless scalar @data == 10;
2383 my $tag_start = shift @data;
2384 my $type = shift @data;
2385 my $mode = shift @data;
2386 my $magic = shift @data;
2387 my $salt = shift @data;
2388 my $verify_bytes = shift @data;
2389 my $length = shift @data;
2390 my $data = shift @data;
2391 my $auth = shift @data;
2392 my $tag_end = shift @data;
2394 next unless ($tag_start eq '$zip2$');
2395 next unless ($tag_end eq '$/zip2$');
2404 next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2408 print "ERROR: hash mode is not supported\n";
2413 if ($word =~ m/^\$HEX\[[0-9a-fA-F]*\]$/)
2415 $word = pack ("H*", substr ($word, 5, -1));
2418 # finally generate the hash
2423 # check both variations
2424 $hash_out = gen_hash
($mode, $word, $salt, $iter, 1);
2426 $len = length $hash_out; # == length $alternative
2428 if (substr ($line, 0, $len) ne $hash_out)
2430 my $alternative = gen_hash
($mode, $word, $salt, $iter, 2);
2432 return unless (substr ($line, 0, $len) eq $alternative);
2435 elsif ($mode == 8700)
2437 $hash_out = gen_hash
($mode, $word, $salt, 0, $param);
2439 $len = length $hash_out;
2441 return unless (substr ($line, 0, $len) eq $hash_out);
2443 elsif ($mode == 8900)
2445 $hash_out = gen_hash
($mode, $word, $salt, 0, $param, $param2, $param3);
2447 $len = length $hash_out;
2449 return unless (substr ($line, 0, $len) eq $hash_out);
2451 elsif ($mode == 9100)
2453 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2455 $len = length $hash_out;
2457 return unless (substr ($line, 0, $len) eq $hash_out);
2459 elsif ($mode == 3300)
2461 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2463 $len = length $hash_out;
2465 return unless (substr ($line, 0, $len) eq $hash_out);
2467 elsif ($mode == 5100)
2469 # check 3 variants (start, middle, end)
2473 $hash_out = gen_hash
($mode, $word, $salt, $iter, $idx++);
2475 $len = length $hash_out; # == length $alternative
2477 if (substr ($line, 0, $len) ne $hash_out)
2479 my $alternative = gen_hash
($mode, $word, $salt, $iter, $idx++);
2481 if (substr ($line, 0, $len) ne $alternative)
2483 my $alternative = gen_hash
($mode, $word, $salt, $iter, $idx++);
2485 return unless (substr ($line, 0, $len) eq $alternative);
2489 elsif ($mode == 9400)
2491 $hash_out = gen_hash
($mode, $word, $salt, 50000, $param, $param2);
2493 $len = length $hash_out;
2495 return unless (substr ($line, 0, $len) eq $hash_out);
2497 elsif ($mode == 9500)
2499 $hash_out = gen_hash
($mode, $word, $salt, 100000, $param);
2501 $len = length $hash_out;
2503 return unless (substr ($line, 0, $len) eq $hash_out);
2505 elsif ($mode == 9600)
2507 $hash_out = gen_hash
($mode, $word, $salt, 100000, $param);
2509 $len = length $hash_out;
2511 return unless (substr ($line, 0, $len) eq $hash_out);
2513 elsif ($mode == 9700)
2515 $hash_out = gen_hash
($mode, $word, $salt, 0, $param, $param2);
2517 $len = length $hash_out;
2519 return unless (substr ($line, 0, $len) eq $hash_out);
2521 elsif ($mode == 9800)
2523 $hash_out = gen_hash
($mode, $word, $salt, 0, $param, $param2);
2525 $len = length $hash_out;
2527 return unless (substr ($line, 0, $len) eq $hash_out);
2529 elsif ($mode == 10400)
2531 $hash_out = gen_hash
($mode, $word, $salt, 0, $param, $param2, $param3);
2533 $len = length $hash_out;
2535 return unless (substr ($line, 0, $len) eq $hash_out);
2537 elsif ($mode == 10500)
2539 $hash_out = gen_hash
($mode, $word, $salt, 0, $param, $param2, $param3, $param4, $param5, $param6);
2541 $len = length $hash_out;
2543 return unless (substr ($line, 0, $len) eq $hash_out);
2545 elsif ($mode == 10600)
2547 $hash_out = gen_hash
($mode, $word, $salt, 0, $param);
2549 $len = length $hash_out;
2551 return unless (substr ($line, 0, $len) eq $hash_out);
2553 elsif ($mode == 10700)
2555 $hash_out = gen_hash
($mode, $word, $salt, 0, $param);
2557 $len = length $hash_out;
2559 return unless (substr ($line, 0, $len) eq $hash_out);
2561 elsif ($mode == 10900)
2563 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2565 $len = length $hash_out;
2567 return unless (substr ($line, 0, $len) eq $hash_out);
2569 elsif ($mode == 11100)
2571 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2573 $len = length $hash_out;
2575 return unless (substr ($line, 0, $len) eq $hash_out);
2577 elsif ($mode == 11400)
2579 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6, $param7, $param8, $param9, $param10, $param11);
2581 $len = length $hash_out;
2583 return unless (substr ($line, 0, $len) eq $hash_out);
2585 elsif ($mode == 11600)
2587 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6);
2589 $len = length $hash_out;
2591 return unless (substr ($line, 0, $len) eq $hash_out);
2593 elsif ($mode == 11900)
2595 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2597 $len = length $hash_out;
2599 return unless (substr ($line, 0, $len) eq $hash_out);
2601 elsif ($mode == 12000)
2603 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2605 $len = length $hash_out;
2607 return unless (substr ($line, 0, $len) eq $hash_out);
2609 elsif ($mode == 12100)
2611 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2613 $len = length $hash_out;
2615 return unless (substr ($line, 0, $len) eq $hash_out);
2617 elsif ($mode == 12200)
2619 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2621 $len = length $hash_out;
2623 return unless (substr ($line, 0, $len) eq $hash_out);
2625 elsif ($mode == 12700)
2627 # this is very special, we can't call gen_hash () because the param part is not always the same
2628 # we only know that it should contain the letters "guid" at the beginning of the decryted string
2630 my $pbkdf2 = Crypt
::PBKDF2
->new (
2631 hash_class
=> 'HMACSHA1',
2636 my $salt_bin = pack ("H*", $salt);
2638 my $key = $pbkdf2->PBKDF2 ($salt_bin, $word);
2640 my $cipher = Crypt
::CBC
->new ({
2642 cipher
=> "Crypt::Rijndael",
2649 my $param_bin = pack ("H*", $param);
2651 my $decrypted = $cipher->decrypt ($param_bin);
2653 my $decrypted_part = substr ($decrypted, 1, 16);
2655 return unless ($decrypted_part =~ /"guid"/);
2657 $hash_out = $hash_in;
2659 elsif ($mode == 12900)
2661 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2663 $len = length $hash_out;
2665 return unless (substr ($line, 0, $len) eq $hash_out);
2667 elsif ($mode == 13000)
2669 $hash_out = gen_hash
($mode, $word, $salt, $iter, $param);
2671 $len = length $hash_out;
2673 return unless (substr ($line, 0, $len) eq $hash_out);
2675 elsif ($mode == 13100)
2677 $hash_out = gen_hash
($mode, $word, $salt);
2679 $len = length $hash_out;
2681 return unless (substr ($line, 0, $len) eq $hash_out);
2683 elsif ($mode == 13200)
2685 $hash_out = gen_hash
($mode, $word, $salt);
2687 $len = length $hash_out;
2689 return unless (substr ($line, 0, $len) eq $hash_out);
2691 elsif ($mode == 13400)
2693 $hash_out = gen_hash
($mode, $word, $salt);
2695 $len = length $hash_out;
2697 return unless (substr ($line, 0, $len) eq $hash_out);
2699 elsif ($mode == 13600)
2701 $hash_out = gen_hash
($mode, $word, undef, undef, $param, $param2, $param3, $param4, $param5, $param6);
2703 $len = length $hash_out;
2705 return unless (substr ($line, 0, $len) eq $hash_out);
2709 $hash_out = gen_hash
($mode, $word, $salt, $iter);
2711 $len = length $hash_out;
2716 # allow $P$ and $H$ for -m 400
2717 next unless (substr ($line, 3, $len - 3) eq substr ($hash_out, 3));
2719 elsif ($mode == 5600)
2721 # hashcat outputs the user name always upper-case, we need
2722 next unless (substr ($line, 0, $len) eq $hash_out);
2726 my $hash_out_lower = lc ($hash_out);
2728 for my $key (keys %{$db})
2730 if (lc ($key) eq $hash_out_lower)
2742 next unless (substr ($line, 0, $len) eq $hash_out);
2746 # do not forget "exists ($db->$hash_out)" should be done above!
2747 $db->{$hash_out} = $word;
2748 print OUT
$line . "\n";
2757 my $mode = shift || 0;
2759 while (my $word_buf = <>)
2763 next if length ($word_buf) > 31;
2771 for (my $i = 0; $i < 256; $i++)
2773 my $c = get_random_chr
(0x30, 0x39);
2775 push (@salt_arr, $c);
2778 my $salt_buf = join ("", @salt_arr);
2786 if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 133 || $mode == 200 || $mode == 300 || $mode == 600 || $mode == 900 || $mode == 1000 || $mode == 1400 || $mode == 1700 || $mode == 2400 || $mode == 2600 || $mode == 3500 || $mode == 4300 || $mode == 4400 || $mode == 4500 || $mode == 4600 || $mode == 4700 || $mode == 5000 || $mode == 5100 || $mode == 6000 || $mode == 6100 || $mode == 6900 || $mode == 5700 || $mode == 9900 || $mode == 10800 || $mode == 11500 || $mode == 13300)
2788 $tmp_hash = gen_hash
($mode, $word_buf, "");
2790 elsif ($mode == 10 || $mode == 20 || $mode == 23 || $mode == 30 || $mode == 40 || $mode == 50 || $mode == 60 || $mode == 110 || $mode == 120 || $mode == 130 || $mode == 140 || $mode == 150 || $mode == 160 || $mode == 1410 || $mode == 1420 || $mode == 1430 || $mode == 1440 || $mode == 1450 || $mode == 1460 || $mode == 1710 || $mode == 1711 || $mode == 1720 || $mode == 1730 || $mode == 1740 || $mode == 1750 || $mode == 1760 || $mode == 3610 || $mode == 3710 || $mode == 3711 || $mode == 3720 || $mode == 3800 || $mode == 3910 || $mode == 4010 || $mode == 4110 || $mode == 4210 || $mode == 4900 || $mode == 8900 || $mode == 10000 || $mode == 10200 || $mode == 10900 || $mode == 11900 || $mode == 12000 || $mode == 12100)
2792 my $salt_len = get_random_num
(1, 15);
2794 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2796 elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
2798 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
2802 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 2));
2806 my $salt_len = get_random_num
(1, 11);
2808 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2810 elsif ($mode == 111 || $mode == 122 || $mode == 131 || $mode == 132 || $mode == 400 || $mode == 500 || $mode == 1600 || $mode == 1722 || $mode == 1731 || $mode == 1800 || $mode == 6300 || $mode == 7900 || $mode == 8100 || $mode == 11100)
2812 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 8));
2814 elsif ($mode == 112)
2816 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 20));
2818 elsif ($mode == 121)
2820 my $salt_len = get_random_num
(1, 9);
2822 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2824 elsif ($mode == 125)
2826 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 8));
2828 elsif ($mode == 141 || $mode == 1441)
2830 my $salt_len = get_random_num
(1, 15);
2832 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2834 elsif ($mode == 1100)
2836 my $salt_len = get_random_num
(1, 19);
2838 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2840 elsif ($mode == 1500)
2842 next if length ($word_buf) > 8;
2844 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 2));
2846 elsif ($mode == 2100)
2848 next if length ($word_buf) > 13;
2850 my $salt_len = get_random_num
(1, 19);
2852 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2854 elsif ($mode == 2410)
2856 next if length ($word_buf) > 15;
2858 my $salt_len = get_random_num
(1, 15);
2860 my $word_len = length ($word_buf);
2862 $salt_len = min
($salt_len, 15 - $word_len);
2864 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2866 elsif ($mode == 2500)
2868 next if length ($word_buf) < 8;
2870 my $salt_len = get_random_num
(0, 32);
2872 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2874 elsif ($mode == 2611)
2876 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 3));
2878 elsif ($mode == 2612)
2880 my $salt_len = get_random_num
(1, 22);
2882 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2884 elsif ($mode == 2711)
2886 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 30));
2888 elsif ($mode == 2811)
2890 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 5));
2892 elsif ($mode == 3000)
2894 next if length ($word_buf) > 7;
2896 $tmp_hash = gen_hash
($mode, $word_buf, "");
2898 elsif ($mode == 3100)
2900 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 10));
2902 elsif ($mode == 3200 || $mode == 5800 || $mode == 6400 || $mode == 6500 || $mode == 6700 || $mode == 7400 || $mode == 3300 || $mode == 8000 || $mode == 9100 || $mode == 12200)
2904 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 16));
2906 elsif ($mode == 3800 || $mode == 4900)
2908 my $salt_len = get_random_num
(1, 11);
2910 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2912 elsif ($mode == 4800)
2914 $salt_buf = get_random_md5chap_salt
(substr ($salt_buf, 0, 16));
2916 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2918 elsif ($mode == 5300 || $mode == 5400)
2920 $salt_buf = get_random_ike_salt
();
2922 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2924 elsif ($mode == 5500)
2926 my $user_len = get_random_num
(0, 15);
2927 my $domain_len = get_random_num
(0, 15);
2929 $salt_buf = get_random_netntlmv1_salt
($user_len, $domain_len);
2931 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2933 elsif ($mode == 5600)
2935 my $user_len = get_random_num
(0, 15);
2936 my $domain_len = get_random_num
(0, 15);
2938 $salt_buf = get_random_netntlmv2_salt
($user_len, $domain_len);
2940 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2942 elsif ($mode == 6600)
2944 $salt_buf = get_random_agilekeychain_salt
();
2946 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2948 elsif ($mode == 6800)
2950 my $email_len = get_random_num
(1, 15);
2954 for (my $i = 0; $i < $email_len; $i++)
2956 $email .= get_random_chr
(0x61, 0x7a);
2959 $email .= '@trash-mail.com';
2961 $tmp_hash = gen_hash
($mode, $word_buf, $email);
2963 elsif ($mode == 7100)
2965 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 64));
2967 elsif ($mode == 7200)
2969 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 128));
2971 elsif ($mode == 7300)
2973 my $salt_len = get_random_num
(32, 256);
2975 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2977 elsif ($mode == 7500)
2979 $salt_buf = get_random_kerberos5_salt
(substr ($salt_buf, 0, 16));
2981 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2983 elsif ($mode == 7700)
2985 next if length ($word_buf) > 8;
2987 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 12));
2989 elsif ($mode == 7800)
2991 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 12));
2993 elsif ($mode == 8200)
2995 $salt_buf = get_random_cloudkeychain_salt
();
2997 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
2999 elsif ($mode == 8300)
3001 $salt_buf = get_random_dnssec_salt
();
3003 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
3005 elsif ($mode == 8400 || $mode == 11200)
3007 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 40));
3009 elsif ($mode == 8500)
3011 next if length ($word_buf) > 8;
3013 my $salt_len = get_random_num
(1, 9);
3015 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3017 elsif ($mode == 8600)
3019 next if length ($word_buf) > 16;
3021 $tmp_hash = gen_hash
($mode, $word_buf, "");
3023 elsif ($mode == 8700)
3025 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 5));
3027 elsif ($mode == 9200 || $mode == 9300)
3031 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3033 elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
3035 next if length ($word_buf) > 19;
3039 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3041 elsif ($mode == 10100)
3043 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
3045 elsif ($mode == 10300)
3047 my $salt_len = get_random_num
(4, 15);
3049 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3051 elsif ($mode == 10400)
3053 next if length ($word_buf) > 31;
3057 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3059 elsif ($mode == 10500)
3061 next if length ($word_buf) > 15;
3065 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3067 elsif ($mode == 10600)
3069 next if length ($word_buf) > 31;
3073 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3075 elsif ($mode == 10700)
3077 next if length ($word_buf) > 15;
3081 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3083 elsif ($mode == 11000)
3085 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 56));
3087 elsif ($mode == 11300)
3089 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 16));
3091 elsif ($mode == 11400)
3093 next if length ($word_buf) > 24;
3095 my $salt_len = get_random_num
(1, 15);
3097 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3099 elsif ($mode == 11600)
3101 my $salt_len = get_random_num
(0, 16);
3103 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
3105 elsif ($mode == 12400)
3107 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 4));
3109 elsif ($mode == 12600)
3111 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 64));
3113 elsif ($mode == 12700)
3115 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
3117 elsif ($mode == 12800)
3119 next if length ($word_buf) > 24;
3121 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 20));
3123 elsif ($mode == 12900)
3125 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
3127 elsif ($mode == 13000)
3129 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
3131 elsif ($mode == 13100)
3133 $salt_buf = get_random_kerberos5_tgs_salt
();
3135 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
3137 elsif ($mode == 13200)
3139 $salt_buf = get_random_axcrypt_salt
();
3141 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
3143 elsif ($mode == 13400)
3145 $salt_buf = get_random_keepass_salt
();
3147 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
3149 elsif ($mode == 13500)
3151 $salt_buf = get_pstoken_salt
();
3153 $tmp_hash = gen_hash
($mode, $word_buf, $salt_buf);
3155 elsif ($mode == 13600)
3157 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 32));
3159 elsif ($mode == 13800)
3161 $tmp_hash = gen_hash
($mode, $word_buf, substr ($salt_buf, 0, 256));
3165 print "ERROR: Unsupported hash type\n";
3170 print $tmp_hash, "\n";
3183 for (my $j = 0; $j < scalar @modes; $j++)
3185 my $mode = $modes[$j];
3187 if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 133 || $mode == 200 || $mode == 300 || $mode == 600 || $mode == 900 || $mode == 1000 || $mode == 1400 || $mode == 1700 || $mode == 2400 || $mode == 2600 || $mode == 3500 || $mode == 4300 || $mode == 4400 || $mode == 4500 || $mode == 4600 || $mode == 4700 || $mode == 5000 || $mode == 5100 || $mode == 5300 || $mode == 5400 || $mode == 6000 || $mode == 6100 || $mode == 6600 || $mode == 6900 || $mode == 5700 || $mode == 8200 || $mode == 8300 || $mode == 9900 || $mode == 10800 || $mode == 11500 || $mode == 13300)
3189 for (my $i = 1; $i < 32; $i++)
3193 rnd
($mode, $len, 0);
3201 elsif ($mode == 10 || $mode == 20 || $mode == 23 || $mode == 30 || $mode == 40 || $mode == 50 || $mode == 60 || $mode == 110 || $mode == 120 || $mode == 121 || $mode == 130 || $mode == 140 || $mode == 150 || $mode == 160 || $mode == 1410 || $mode == 1420 || $mode == 1430 || $mode == 1440 || $mode == 1450 || $mode == 1460 || $mode == 1710 || $mode == 1711 || $mode == 1720 || $mode == 1730 || $mode == 1740 || $mode == 1750 || $mode == 1760 || $mode == 2410 || $mode == 3610 || $mode == 3710 || $mode == 3711 || $mode == 3720 || $mode == 3910 || $mode == 4010 || $mode == 4110 || $mode == 4210 || $mode == 8900 || $mode == 10000 || $mode == 10200 || $mode == 10900 || $mode == 11900 || $mode == 12000 || $mode == 12100)
3203 my $salt_len = get_random_num
(1, 15);
3205 for (my $i = 1; $i < 32; $i++)
3209 rnd
($mode, $len, $salt_len);
3213 rnd
($mode, $i, $salt_len);
3217 elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
3219 for (my $i = 1; $i < 32; $i++)
3223 rnd
($mode, $len, 32);
3227 rnd
($mode, $i, 32);
3231 elsif ($mode == 21 || $mode == 22)
3233 for (my $i = 1; $i < 32; $i++)
3237 rnd
($mode, $len, 2);
3245 elsif ($mode == 111 || $mode == 122 || $mode == 125 || $mode == 131 || $mode == 132 || $mode == 400 || $mode == 500 || $mode == 1600 || $mode == 1722 || $mode == 1731 || $mode == 6300 || $mode == 7900 || $mode == 8100 || $mode == 11100)
3247 for (my $i = 1; $i < 32; $i++)
3251 rnd
($mode, $len, 8);
3259 elsif ($mode == 112)
3261 for (my $i = 1; $i < 32; $i++)
3265 rnd
($mode, $len, 20);
3269 rnd
($mode, $i, 20);
3273 elsif ($mode == 141 || $mode == 3300 || $mode == 1441 || $mode == 1800 || $mode == 3200 || $mode == 4800 || $mode == 6400 || $mode == 6500 || $mode == 6700 || $mode == 7400 || $mode == 8000 || $mode == 9100 || $mode == 12200)
3275 for (my $i = 1; $i < 32; $i++)
3279 rnd
($mode, $len, 16);
3283 rnd
($mode, $i, 16);
3289 my $salt_len = get_random_num
(1, 19);
3291 for (my $i = 1; $i < 32; $i++)
3295 rnd
($mode, $len, $salt_len);
3299 rnd
($mode, $i, $salt_len);
3303 elsif ($mode == 1500)
3305 for (my $i = 1; $i < 9; $i++)
3309 rnd
($mode, $len, 2);
3317 elsif ($mode == 2100)
3319 my $salt_len = get_random_num
(1, 19);
3321 for (my $i = 1; $i < 13; $i++)
3325 rnd
($mode, $len, $salt_len);
3329 rnd
($mode, $i, $salt_len);
3333 elsif ($mode == 2500)
3335 my $salt_len = get_random_num
(0, 32);
3337 for (my $i = 8; $i < 16; $i++)
3339 my $generate_from_len = 0;
3348 rnd
($mode, $len, $salt_len);
3352 rnd
($mode, $i, $salt_len);
3356 elsif ($mode == 2611)
3358 for (my $i = 1; $i < 32; $i++)
3362 rnd
($mode, $len, 3);
3370 elsif ($mode == 2612)
3372 my $salt_len = get_random_num
(1, 22);
3374 for (my $i = 1; $i < 32; $i++)
3378 rnd
($mode, $len, $salt_len);
3382 rnd
($mode, $i, $salt_len);
3386 elsif ($mode == 2711)
3388 for (my $i = 1; $i < 32; $i++)
3392 rnd
($mode, $len, 30);
3396 rnd
($mode, $i, 30);
3400 elsif ($mode == 2811)
3402 for (my $i = 1; $i < 32; $i++)
3406 rnd
($mode, $len, 5);
3414 elsif ($mode == 3000)
3416 for (my $i = 1; $i < 8; $i++)
3420 rnd
($mode, $len, 0);
3428 elsif ($mode == 3100)
3430 for (my $i = 1; $i < 32; $i++)
3434 rnd
($mode, $len, 10);
3438 rnd
($mode, $i, 10);
3442 elsif ($mode == 3800 || $mode == 4900)
3444 my $salt_len = get_random_num
(1, 11);
3446 for (my $i = 1; $i < 32; $i++)
3450 rnd
($mode, $len, $salt_len);
3454 rnd
($mode, $i, $salt_len);
3458 elsif ($mode == 5500 || $mode == 5600)
3462 for (my $i = 1; $i < 27; $i++)
3464 $salt_len = get_random_num
(1, 15);
3468 rnd
($mode, $len, $salt_len);
3472 rnd
($mode, $i, $salt_len);
3476 elsif ($mode == 5800)
3478 for (my $i = 1; $i < 14; $i++)
3482 rnd
($mode, $len, 16);
3486 rnd
($mode, $i, 16);
3490 elsif ($mode == 6800)
3492 my $salt_len = get_random_num
(8, 25);
3494 for (my $i = 1; $i < 32; $i++)
3498 rnd
($mode, $len, $salt_len);
3502 rnd
($mode, $i, $salt_len);
3506 elsif ($mode == 7100)
3508 for (my $i = 1; $i < 32; $i++)
3512 rnd
($mode, $len, 64);
3516 rnd
($mode, $i, 64);
3520 elsif ($mode == 7200)
3522 for (my $i = 1; $i < 32; $i++)
3526 rnd
($mode, $len, 128);
3530 rnd
($mode, $i, 128);
3534 elsif ($mode == 7300)
3536 my $salt_len = get_random_num
(32, 255);
3538 for (my $i = 1; $i < 32; $i++)
3542 rnd
($mode, $len, $salt_len);
3546 rnd
($mode, $i, $salt_len);
3550 elsif ($mode == 7500)
3552 for (my $i = 1; $i < 27; $i++)
3556 rnd
($mode, $len, 16);
3560 rnd
($mode, $i, 16);
3564 elsif ($mode == 7700)
3566 my $salt_len = get_random_num
(1, 12);
3568 for (my $i = 1; $i < 9; $i++)
3572 rnd
($mode, $len, $salt_len);
3576 rnd
($mode, $i, $salt_len);
3580 elsif ($mode == 7800)
3582 my $salt_len = get_random_num
(1, 12);
3584 for (my $i = 1; $i < 32; $i++)
3588 rnd
($mode, $len, $salt_len);
3592 rnd
($mode, $i, $salt_len);
3596 elsif ($mode == 8400 || $mode == 11200)
3598 for (my $i = 1; $i < 32; $i++)
3602 rnd
($mode, $len, 40);
3606 rnd
($mode, $i, 40);
3610 elsif ($mode == 8500)
3612 my $salt_len = get_random_num
(1, 8);
3614 for (my $i = 1; $i < 9; $i++)
3618 rnd
($mode, $len, $salt_len);
3622 rnd
($mode, $i, $salt_len);
3626 elsif ($mode == 8600)
3628 for (my $i = 1; $i < 17; $i++)
3632 rnd
($mode, $len, 0);
3640 elsif ($mode == 8700)
3642 for (my $i = 1; $i < 32; $i++)
3646 rnd
($mode, $len, 5);
3654 elsif ($mode == 9200 || $mode == 9300)
3658 for (my $i = 1; $i < 32; $i++)
3662 rnd
($mode, $len, $salt_len);
3666 rnd
($mode, $i, $salt_len);
3670 elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
3674 for (my $i = 1; $i < 20; $i++)
3678 rnd
($mode, $len, $salt_len);
3682 rnd
($mode, $i, $salt_len);
3686 elsif ($mode == 10100)
3688 for (my $i = 1; $i < 32; $i++)
3692 rnd
($mode, $len, 32);
3696 rnd
($mode, $i, 32);
3700 elsif ($mode == 10300)
3702 my $salt_len = get_random_num
(4, 15);
3704 for (my $i = 1; $i < 32; $i++)
3708 rnd
($mode, $len, $salt_len);
3712 rnd
($mode, $i, $salt_len);
3716 elsif ($mode == 10400 || $mode == 10600)
3720 for (my $i = 1; $i < 32; $i++)
3724 rnd
($mode, $len, $salt_len);
3728 rnd
($mode, $i, $salt_len);
3732 elsif ($mode == 10500 || $mode == 10700)
3736 for (my $i = 1; $i < 16; $i++)
3740 rnd
($mode, $len, $salt_len);
3744 rnd
($mode, $i, $salt_len);
3748 elsif ($mode == 11000)
3750 for (my $i = 1; $i < 32; $i++)
3754 rnd
($mode, $len, 56);
3758 rnd
($mode, $i, 56);
3762 elsif ($mode == 11300)
3764 for (my $i = 1; $i < 32; $i++)
3768 rnd
($mode, $len, 16);
3772 rnd
($mode, $i, 16);
3776 elsif ($mode == 11400)
3778 for (my $i = 1; $i < 24; $i++)
3782 rnd
($mode, $len, 16);
3786 rnd
($mode, $i, 16);
3790 elsif ($mode == 11600)
3792 my $salt_len = get_random_num
(0, 16);
3794 for (my $i = 1; $i < 32; $i++)
3798 rnd
($mode, $len, $salt_len);
3802 rnd
($mode, $i, $salt_len);
3806 elsif ($mode == 12400)
3808 for (my $i = 1; $i < 32; $i++)
3812 rnd
($mode, $len, 4);
3820 elsif ($mode == 12600)
3822 for (my $i = 1; $i < 32; $i++)
3826 rnd
($mode, $len, 64);
3830 rnd
($mode, $i, 64);
3834 elsif ($mode == 12700)
3836 for (my $i = 1; $i < 32; $i++)
3840 rnd
($mode, $len, 32);
3844 rnd
($mode, $i, 32);
3848 elsif ($mode == 12800)
3850 for (my $i = 1; $i < 25; $i++)
3854 rnd
($mode, $len, 20);
3858 rnd
($mode, $i, 20);
3862 elsif ($mode == 12900)
3864 for (my $i = 1; $i < 32; $i++)
3868 rnd
($mode, $len, 32);
3872 rnd
($mode, $i, 32);
3876 elsif ($mode == 13000)
3878 for (my $i = 1; $i < 32; $i++)
3882 rnd
($mode, $len, 32);
3886 rnd
($mode, $i, 32);
3890 elsif ($mode == 13100)
3892 for (my $i = 1; $i < 27; $i++)
3896 rnd
($mode, $len, 16);
3900 rnd
($mode, $i, 16);
3904 elsif ($mode == 13200)
3906 for (my $i = 1; $i < 32; $i++)
3910 rnd
($mode, $len, 32);
3914 rnd
($mode, $i, 32);
3918 elsif ($mode == 13400)
3920 for (my $i = 1; $i < 16; $i++)
3924 rnd
($mode, $len, 16);
3928 rnd
($mode, $i, 16);
3932 elsif ($mode == 13500)
3934 for (my $i = 1; $i < 16; $i++)
3938 rnd
($mode, $len, 16);
3942 rnd
($mode, $i, 16);
3946 elsif ($mode == 13600)
3948 for (my $i = 1; $i < 16; $i++)
3952 rnd
($mode, $len, 32);
3956 rnd
($mode, $i, 32);
3960 elsif ($mode == 13800)
3962 for (my $i = 1; $i < 32; $i++)
3966 rnd
($mode, $len, 256);
3970 rnd
($mode, $i, 256);
3983 my $word_buf = shift;
3985 my $salt_buf = shift;
3989 my $additional_param = shift;
3991 my $additional_param2 = shift;
3993 my $additional_param3 = shift;
3995 my $additional_param4 = shift;
3997 my $additional_param5 = shift;
3999 my $additional_param6 = shift;
4001 my $additional_param7 = shift;
4003 my $additional_param8 = shift;
4005 my $additional_param9 = shift;
4007 my $additional_param10 = shift;
4009 my $additional_param11 = shift;
4021 $hash_buf = md5_hex
($word_buf);
4023 $tmp_hash = sprintf ("%s", $hash_buf);
4027 $hash_buf = md5_hex
($word_buf . $salt_buf);
4029 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4033 $hash_buf = md5_hex
($word_buf . $salt_buf);
4035 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4039 $hash_buf = md5_hex
($word_buf . $salt_buf);
4041 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4045 $hash_buf = md5_hex
($salt_buf . $word_buf);
4047 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4051 $hash_buf = md5_hex
($salt_buf . $word_buf);
4053 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4057 my $itoa64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4058 my $salt_suffix = "Administration Tools";
4060 my $pass = sprintf ("%s:%s:%s", $salt_buf, $salt_suffix, $word_buf);
4062 $hash_buf = md5
($pass);
4066 for (my $pos = 0; $pos < 16; $pos += 2)
4068 my $octet1 = ord (substr ($hash_buf, $pos + 0, 1));
4069 my $octet2 = ord (substr ($hash_buf, $pos + 1, 1));
4071 my $num = ($octet1 <<8 & 0xff00) | ($octet2 & 0xff);
4073 my $idx1 = $num >> 12 & 0x0f;
4074 my $idx2 = $num >> 6 & 0x3f;
4075 my $idx3 = $num & 0x3f;
4077 $res = $res . substr ($itoa64, $idx1, 1) . substr ($itoa64, $idx2, 1) . substr ($itoa64, $idx3, 1);
4080 my $obfuscate_str = "nrcstn";
4081 my @obfuscate_pos = (0, 6, 12, 17, 23, 29);
4083 foreach my $pos (keys @obfuscate_pos)
4085 my $idx = $obfuscate_pos[$pos];
4086 my $before = substr ($res, 0, $idx);
4087 my $char = substr ($obfuscate_str, $pos, 1);
4088 my $after = substr ($res, $idx);
4090 $res = sprintf ("%s%s%s", $before, $char, $after);
4093 $tmp_hash = sprintf ("%s:%s", $res, $salt_buf);
4097 $hash_buf = md5_hex
($salt_buf . "\nskyper\n" . $word_buf);
4099 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4103 $hash_buf = md5_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf);
4105 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4109 $hash_buf = md5_hex
($salt_buf . encode
("UTF-16LE", $word_buf));
4111 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4115 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&md5
, 64);
4117 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4121 $hash_buf = hmac_hex
($word_buf, $salt_buf, \
&md5
, 64);
4123 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4125 elsif ($mode == 100)
4127 $hash_buf = sha1_hex
($word_buf);
4129 $tmp_hash = sprintf ("%s", $hash_buf);
4131 elsif ($mode == 101)
4133 $hash_buf = sha1
($word_buf);
4135 my $base64_buf = encode_base64
($hash_buf);
4137 chomp ($base64_buf);
4139 $tmp_hash = sprintf ("{SHA}%s", $base64_buf);
4141 elsif ($mode == 110)
4143 $hash_buf = sha1_hex
($word_buf . $salt_buf);
4145 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4147 elsif ($mode == 111)
4149 $hash_buf = sha1
($word_buf . $salt_buf);
4151 my $base64_buf = encode_base64
($hash_buf . $salt_buf);
4153 chomp ($base64_buf);
4155 $tmp_hash = sprintf ("{SSHA}%s", $base64_buf);
4157 elsif ($mode == 112)
4159 my $salt_buf_bin = pack ("H*", $salt_buf);
4161 $hash_buf = sha1_hex
($word_buf . $salt_buf_bin);
4163 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4165 elsif ($mode == 120)
4167 $hash_buf = sha1_hex
($salt_buf . $word_buf);
4169 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4171 elsif ($mode == 121)
4173 $hash_buf = sha1_hex
(lc ($salt_buf) . $word_buf);
4175 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4177 elsif ($mode == 122)
4179 my $salt_buf_bin = pack ("H*", $salt_buf);
4181 $hash_buf = sha1_hex
($salt_buf_bin . $word_buf);
4183 $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
4185 elsif ($mode == 125)
4187 my $signature = "01";
4189 my $salt_buf_bin = pack ("H*", $salt_buf . $signature);
4191 $hash_buf = sha1_hex
($salt_buf_bin . $word_buf);
4193 $tmp_hash = sprintf ("%s%s%s", $salt_buf, $signature, $hash_buf);
4195 elsif ($mode == 130)
4197 $hash_buf = sha1_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf);
4199 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4201 elsif ($mode == 131)
4203 my $salt_buf_bin = pack ("H*", $salt_buf);
4205 $hash_buf = sha1_hex
(encode
("UTF-16LE", uc ($word_buf)) . $salt_buf_bin);
4207 $tmp_hash = sprintf ("0x0100%s%s%s", $salt_buf, "0" x
40, $hash_buf);
4209 elsif ($mode == 132)
4211 my $salt_buf_bin = pack ("H*", $salt_buf);
4213 $hash_buf = sha1_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf_bin);
4215 $tmp_hash = sprintf ("0x0100%s%s", $salt_buf, $hash_buf);
4217 elsif ($mode == 133)
4219 $hash_buf = sha1
(encode
("UTF-16LE", $word_buf));
4221 $hash_buf = encode_base64
($hash_buf);
4222 $hash_buf =~ s/[\r\n]//g;
4224 $tmp_hash = sprintf ("%s", $hash_buf);
4226 elsif ($mode == 140)
4228 $hash_buf = sha1_hex
($salt_buf . encode
("UTF-16LE", $word_buf));
4230 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4232 elsif ($mode == 141)
4234 $hash_buf = sha1
($salt_buf . encode
("UTF-16LE", $word_buf));
4236 my $base64_salt_buf = encode_base64
($salt_buf);
4238 chomp ($base64_salt_buf);
4240 my $base64_hash_buf = encode_base64
($hash_buf);
4242 $base64_hash_buf = substr ($base64_hash_buf, 0, 27);
4244 $tmp_hash = sprintf ("\$episerver\$*0*%s*%s", $base64_salt_buf, $base64_hash_buf);
4246 elsif ($mode == 150)
4248 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&sha1
, 64);
4250 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4252 elsif ($mode == 160)
4254 $hash_buf = hmac_hex
($word_buf, $salt_buf, \
&sha1
, 64);
4256 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4258 elsif ($mode == 200)
4260 my $ppr = Authen
::Passphrase
::MySQL323
->new (passphrase
=> $word_buf);
4262 $hash_buf = $ppr->hash_hex;
4264 $tmp_hash = sprintf ("%s", $hash_buf);
4266 elsif ($mode == 300)
4268 $hash_buf = substr (password41
($word_buf), 1);
4270 $hash_buf = lc ($hash_buf); # useful for 'not matched' check only
4272 $tmp_hash = sprintf ("%s", $hash_buf);
4274 elsif ($mode == 400)
4283 my $ppr = Authen
::Passphrase
::PHPass
->new
4287 passphrase
=> $word_buf,
4290 $hash_buf = $ppr->as_rfc2307;
4292 $tmp_hash = sprintf ("%s", substr ($hash_buf, 7));
4294 elsif ($mode == 500)
4296 my $iterations = 1000;
4298 if (defined ($iter))
4302 $iterations = int ($iter);
4306 $hash_buf = md5_crypt
('$1$', $iterations, $word_buf, $salt_buf);
4308 $tmp_hash = sprintf ("%s", $hash_buf);
4310 elsif ($mode == 900)
4312 $hash_buf = md4_hex
($word_buf);
4314 $tmp_hash = sprintf ("%s", $hash_buf);
4316 elsif ($mode == 1000)
4318 $hash_buf = md4_hex
(encode
("UTF-16LE", $word_buf));
4320 $tmp_hash = sprintf ("%s", $hash_buf);
4322 elsif ($mode == 1100)
4324 $hash_buf = md4_hex
(md4
(encode
("UTF-16LE", $word_buf)) . encode
("UTF-16LE", lc ($salt_buf)));
4326 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4328 elsif ($mode == 1400)
4330 $hash_buf = sha256_hex
($word_buf);
4332 $tmp_hash = sprintf ("%s", $hash_buf);
4334 elsif ($mode == 1410)
4336 $hash_buf = sha256_hex
($word_buf . $salt_buf);
4338 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4340 elsif ($mode == 1420)
4342 $hash_buf = sha256_hex
($salt_buf . $word_buf);
4344 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4346 elsif ($mode == 1430)
4348 $hash_buf = sha256_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf);
4350 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4352 elsif ($mode == 1440)
4354 $hash_buf = sha256_hex
($salt_buf . encode
("UTF-16LE", $word_buf));
4356 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4358 elsif ($mode == 1441)
4360 $hash_buf = sha256
($salt_buf . encode
("UTF-16LE", $word_buf));
4362 my $base64_salt_buf = encode_base64
($salt_buf);
4364 chomp ($base64_salt_buf);
4366 my $base64_hash_buf = encode_base64
($hash_buf);
4368 chomp ($base64_hash_buf);
4370 $base64_hash_buf = substr ($base64_hash_buf, 0, 43);
4372 $tmp_hash = sprintf ("\$episerver\$*1*%s*%s", $base64_salt_buf, $base64_hash_buf);
4374 elsif ($mode == 1450)
4376 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&sha256
, 64);
4378 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4380 elsif ($mode == 1460)
4382 $hash_buf = hmac_hex
($word_buf, $salt_buf, \
&sha256
, 64);
4384 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4386 elsif ($mode == 1500)
4388 $hash_buf = crypt ($word_buf, $salt_buf);
4390 $tmp_hash = sprintf ("%s", $hash_buf);
4392 elsif ($mode == 1600)
4394 my $iterations = 1000;
4396 if (defined ($iter))
4400 $iterations = int ($iter);
4404 $hash_buf = md5_crypt
('$apr1$', $iterations, $word_buf, $salt_buf);
4406 $tmp_hash = sprintf ("%s", $hash_buf);
4408 elsif ($mode == 1700)
4410 $hash_buf = sha512_hex
($word_buf);
4412 $tmp_hash = sprintf ("%s", $hash_buf);
4414 elsif ($mode == 1710)
4416 $hash_buf = sha512_hex
($word_buf . $salt_buf);
4418 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4420 elsif ($mode == 1711)
4422 $hash_buf = sha512_hex
($word_buf . $salt_buf);
4424 my $base64_buf = encode_base64
(pack ("H*", $hash_buf) . $salt_buf);
4426 $base64_buf =~ s/[ \n]//g;
4428 $tmp_hash = sprintf ("{SSHA512}%s", $base64_buf);
4430 elsif ($mode == 1720)
4432 $hash_buf = sha512_hex
($salt_buf . $word_buf);
4434 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4436 elsif ($mode == 1730)
4438 $hash_buf = sha512_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf);
4440 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4442 elsif ($mode == 1740)
4444 $hash_buf = sha512_hex
($salt_buf . encode
("UTF-16LE", $word_buf));
4446 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4448 elsif ($mode == 1722)
4450 my $salt_buf_bin = pack ("H*", $salt_buf);
4452 $hash_buf = sha512_hex
($salt_buf_bin . $word_buf);
4454 $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
4456 elsif ($mode == 1731)
4458 my $salt_buf_bin = pack ("H*", $salt_buf);
4460 $hash_buf = sha512_hex
(encode
("UTF-16LE", $word_buf) . $salt_buf_bin);
4462 $tmp_hash = sprintf ("0x0200%s%s", $salt_buf, $hash_buf);
4464 elsif ($mode == 1750)
4466 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&sha512
, 128);
4468 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4470 elsif ($mode == 1760)
4472 $hash_buf = hmac_hex
($word_buf, $salt_buf, \
&sha512
, 128);
4474 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4476 elsif ($mode == 1800)
4478 my $iterations = 5000;
4480 if (defined ($iter))
4484 $iterations = int ($iter);
4488 $hash_buf = sha512_crypt
($iterations, $word_buf, $salt_buf);
4490 $tmp_hash = sprintf ("%s", $hash_buf);
4492 elsif ($mode == 2100)
4494 my $iterations = 10240;
4498 $iterations = int ($iter);
4501 my $salt = encode
("UTF-16LE", lc ($salt_buf));
4503 my $pbkdf2 = Crypt
::PBKDF2
->new
4505 hash_class
=> 'HMACSHA1',
4506 iterations
=> $iterations,
4508 salt_len
=> length ($salt),
4511 $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 ($salt, md4
(md4
(encode
("UTF-16LE", $word_buf)) . $salt)));
4513 $tmp_hash = sprintf ("\$DCC2\$%i#%s#%s", $iterations, $salt_buf, $hash_buf);
4515 elsif ($mode == 2400)
4517 $tmp_hash = sprintf ("%s", pseudo_base64
(Digest
::MD5
::md5
($word_buf . "\0" x
(16 - length ($word_buf)))));
4519 elsif ($mode == 2410)
4521 my $salt_len = length ($salt_buf);
4523 my $salt_len_max4 = ($salt_len < 4) ?
$salt_len : 4;
4525 my $hash_buf = pseudo_base64
(Digest
::MD5
::md5
($word_buf . substr ($salt_buf, 0, $salt_len_max4) . "\0" x
(16 - length ($word_buf) - $salt_len_max4)));
4527 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4529 elsif ($mode == 2500)
4531 my ($bssid, $stmac, $snonce, $anonce, $eapol, $keyver, $eapol_size);
4533 if (! defined ($additional_param))
4537 $bssid = randbytes
(6);
4538 $stmac = randbytes
(6);
4539 $snonce = randbytes
(32);
4540 $anonce = randbytes
(32);
4542 $keyver = get_random_num
(1, 3); # 1 or 2
4545 # should be "validly" generated, but in theory could be anything for us also:
4546 # $eapol = "\x00" x 121; # works too, but let's generate it correctly
4548 $eapol = gen_random_wpa_eapol
($keyver, $snonce);
4552 $bssid = $additional_param;
4553 $stmac = $additional_param2;
4554 $snonce = $additional_param3;
4555 $anonce = $additional_param4;
4556 $keyver = $additional_param5;
4557 $eapol = $additional_param6;
4560 $eapol_size = length ($eapol);
4564 my $iterations = 4096;
4570 # generate the Pairwise Master Key (PMK)
4572 my $pbkdf2 = Crypt
::PBKDF2
->new
4574 hash_class
=> 'HMACSHA1',
4575 iterations
=> $iterations,
4579 my $pmk = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
4581 # Pairwise Transient Key (PTK) transformation
4583 my $ptk = wpa_prf_512
($pmk, $stmac, $bssid, $snonce, $anonce);
4585 # generate the Message Integrity Code (MIC)
4589 if ($keyver == 1) # WPA1 => MD5
4591 $mic = hmac
($eapol, $ptk, \
&md5
);
4595 $mic = hmac
($eapol, $ptk, \
&sha1
);
4598 $mic = substr ($mic, 0, 16);
4601 # format the binary output
4606 # first the essid (NULL-padded up to the first 36 bytes)
4608 $hash_buf .= $salt_buf;
4609 $hash_buf .= "\x00" x
(36 - length ($salt_buf));
4611 # the 2 MAC addresses
4613 $hash_buf .= $bssid;
4614 $hash_buf .= $stmac;
4618 $hash_buf .= $snonce;
4619 $hash_buf .= $anonce;
4623 $hash_buf .= $eapol;
4624 $hash_buf .= "\x00" x
(256 - $eapol_size);
4628 $hash_buf .= pack ("L*", $eapol_size);
4632 $hash_buf .= pack ("L*", $keyver);
4634 # and finally: the key mic
4638 # base64 encode the output
4640 $tmp_hash = encode_base64
($hash_buf, '');
4642 elsif ($mode == 2600)
4644 $hash_buf = md5_hex
(md5_hex
($word_buf));
4646 $tmp_hash = sprintf ("%s", $hash_buf);
4648 elsif ($mode == 2611)
4650 $hash_buf = md5_hex
(md5_hex
($word_buf) . $salt_buf);
4652 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4654 elsif ($mode == 2612)
4656 my $salt_buf_hex = unpack ("H*", $salt_buf);
4658 $hash_buf = md5_hex
(md5_hex
($word_buf) . $salt_buf);
4660 $tmp_hash = sprintf ("\$PHPS\$%s\$%s", $salt_buf_hex, $hash_buf);
4662 elsif ($mode == 2711)
4664 $hash_buf = md5_hex
(md5_hex
($word_buf) . $salt_buf);
4666 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4668 elsif ($mode == 2811)
4670 $hash_buf = md5_hex
(md5_hex
($salt_buf) . md5_hex
($word_buf));
4672 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4674 elsif ($mode == 3000)
4676 my $ppr = Authen
::Passphrase
::LANManager
->new ("passphrase" => $word_buf);
4678 $hash_buf = $ppr->hash_hex;
4680 $tmp_hash = sprintf ("%s", substr ($hash_buf, 0, 16));
4682 elsif ($mode == 3100)
4684 $hash_buf = oracle_hash
($salt_buf, $word_buf);
4686 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4688 elsif ($mode == 3200)
4697 $tmp_hash = bcrypt
($word_buf, sprintf ('$2a$%s$%s$', $cost, en_base64
($salt_buf)));
4699 elsif ($mode == 3300)
4701 my $iterations = 904;
4705 $iterations = int ($iter);
4710 if (defined ($additional_param))
4712 $variant = $additional_param;
4715 my $prefix = sprintf ("\$md5%srounds=%i\$%s", $variant, $iterations, $salt_buf);
4717 $iterations += 4096;
4719 $hash_buf = sun_md5
($word_buf, $prefix, $iterations);
4721 $tmp_hash = sprintf ("%s\$%s", $prefix, $hash_buf);
4723 elsif ($mode == 3500)
4725 $hash_buf = md5_hex
(md5_hex
(md5_hex
($word_buf)));
4727 $tmp_hash = sprintf ("%s", $hash_buf);
4729 elsif ($mode == 3610)
4731 $hash_buf = md5_hex
(md5_hex
($salt_buf) . $word_buf);
4733 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4735 elsif ($mode == 3710)
4737 $hash_buf = md5_hex
($salt_buf . md5_hex
($word_buf));
4739 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4741 elsif ($mode == 3711)
4743 $hash_buf = md5_hex
($salt_buf . "-" . md5_hex
($word_buf));
4745 $tmp_hash = sprintf ("\$B\$%s\$%s", $salt_buf, $hash_buf);
4747 elsif ($mode == 3720)
4749 $hash_buf = md5_hex
($word_buf . md5_hex
($salt_buf));
4751 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4753 elsif ($mode == 3800)
4755 $hash_buf = md5_hex
($salt_buf . $word_buf . $salt_buf);
4757 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4759 elsif ($mode == 3910)
4761 $hash_buf = md5_hex
(md5_hex
($word_buf) . md5_hex
($salt_buf));
4763 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4765 elsif ($mode == 4010)
4767 $hash_buf = md5_hex
($salt_buf . md5_hex
($salt_buf . $word_buf));
4769 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4771 elsif ($mode == 4110)
4773 $hash_buf = md5_hex
($salt_buf . md5_hex
($word_buf . $salt_buf));
4775 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4777 elsif ($mode == 4210)
4779 $hash_buf = md5_hex
($salt_buf . "\x00" . $word_buf);
4781 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4783 elsif ($mode == 4300)
4785 $hash_buf = md5_hex
(uc (md5_hex
($word_buf)));
4787 $tmp_hash = sprintf ("%s", $hash_buf);
4789 elsif ($mode == 4400)
4791 $hash_buf = md5_hex
(sha1_hex
($word_buf));
4793 $tmp_hash = sprintf ("%s", $hash_buf);
4795 elsif ($mode == 4500)
4797 $hash_buf = sha1_hex
(sha1_hex
($word_buf));
4799 $tmp_hash = sprintf ("%s", $hash_buf);
4801 elsif ($mode == 4600)
4803 $hash_buf = sha1_hex
(sha1_hex
(sha1_hex
($word_buf)));
4805 $tmp_hash = sprintf ("%s", $hash_buf);
4807 elsif ($mode == 4700)
4809 $hash_buf = sha1_hex
(md5_hex
($word_buf));
4811 $tmp_hash = sprintf ("%s", $hash_buf);
4813 elsif ($mode == 4800)
4815 my $index = rindex ($salt_buf, ":");
4817 my $salt = substr ($salt_buf, 0, $index);
4818 my $salt_bin = pack ("H*", $salt);
4819 my $chap_sign = substr ($salt_buf, $index + 1);
4820 my $chap_sign_bin = pack ("H*", $chap_sign);
4822 $hash_buf = md5_hex
($chap_sign_bin . $word_buf . $salt_bin);
4824 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4826 elsif ($mode == 4900)
4828 $hash_buf = sha1_hex
($salt_buf . $word_buf . $salt_buf);
4830 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4832 elsif ($mode == 5000)
4834 $hash_buf = keccak_256_hex
($word_buf);
4836 $tmp_hash = sprintf ("%s", $hash_buf);
4838 elsif ($mode == 5100)
4842 if (! defined ($additional_param))
4848 $pos = $additional_param * 8 unless ($additional_param > 2);
4851 $hash_buf = md5_hex
($word_buf);
4853 $tmp_hash = sprintf ("%s", substr ($hash_buf, $pos, 16));
4855 elsif ($mode == 5300)
4857 my @salt_arr = split (":", $salt_buf);
4859 my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4860 my $nr_buf = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4862 my $hash_buf = hmac
($nr_buf , $word_buf, \
&md5
, 64);
4863 $hash_buf = hmac_hex
($msg_buf, $hash_buf, \
&md5
, 64);
4865 $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4867 elsif ($mode == 5400)
4869 my @salt_arr = split (":", $salt_buf);
4871 my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4872 my $nr_buf = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4874 my $hash_buf = hmac
($nr_buf , $word_buf, \
&sha1
, 64);
4875 $hash_buf = hmac_hex
($msg_buf, $hash_buf, \
&sha1
, 64);
4877 $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4879 elsif ($mode == 5500)
4881 my $index1 = index ($salt_buf, "::");
4882 my $user = substr ($salt_buf, 0, $index1);
4884 my $index2 = index ($salt_buf, ":", $index1 + 2);
4885 my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4887 my $len = length (substr ($salt_buf, $index2 + 1));
4889 my $c_challenge_hex;
4893 $c_challenge_hex = substr ($salt_buf, $index2 + 1, 48);
4898 $c_challenge_hex = substr ($salt_buf, $index2 + 1, 16);
4899 $c_challenge_hex .= 00 x
32;
4902 my $c_challenge = pack ("H*", substr ($c_challenge_hex, 0, 16));
4903 my $s_challenge_hex = substr ($salt_buf, $index2 + 17, 16);
4904 my $s_challenge = pack ("H*", $s_challenge_hex);
4906 my $challenge = substr (md5
($s_challenge . $c_challenge), 0, 8);
4910 my $nthash = Authen
::Passphrase
::NTHash
->new (passphrase
=> $word_buf)->hash . "\x00" x
5;
4912 $ntresp .= Crypt
::ECB
::encrypt
(setup_des_key
(substr ($nthash, 0, 7)), "DES", $challenge, "none");
4913 $ntresp .= Crypt
::ECB
::encrypt
(setup_des_key
(substr ($nthash, 7, 7)), "DES", $challenge, "none");
4914 $ntresp .= Crypt
::ECB
::encrypt
(setup_des_key
(substr ($nthash, 14, 7)), "DES", $challenge, "none");
4916 $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $c_challenge_hex, unpack ("H*", $ntresp), $s_challenge_hex);
4918 elsif ($mode == 5600)
4920 my $index1 = index ($salt_buf, "::");
4921 my $user = substr ($salt_buf, 0, $index1);
4923 my $index2 = index ($salt_buf, ":", $index1 + 2);
4924 my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4926 my $s_challenge_hex = substr ($salt_buf, $index2 + 1, 16);
4927 my $s_challenge = pack ("H*", $s_challenge_hex);
4929 my $temp_hex = substr ($salt_buf, $index2 + 17);
4930 my $temp = pack ("H*", $temp_hex);
4932 my $nthash = Authen
::Passphrase
::NTHash
->new (passphrase
=> $word_buf)->hash;
4933 my $identity = Encode
::encode
("UTF-16LE", uc ($user) . $domain);
4935 $hash_buf = hmac_hex
($s_challenge . $temp, hmac
($identity, $nthash, \
&md5
, 64), \
&md5
, 64);
4937 $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $s_challenge_hex, $hash_buf, $temp_hex);
4939 elsif ($mode == 5700)
4941 $hash_buf = sha256
($word_buf);
4943 my $base64_buf = encode_base64
($hash_buf);
4947 for (my $i = 0; $i < 43; $i++)
4949 $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($base64_buf, $i, 1)};
4952 elsif ($mode == 5800)
4954 $hash_buf = androidpin_hash
($word_buf, $salt_buf);
4956 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4958 elsif ($mode == 6000)
4960 $hash_buf = ripemd160_hex
($word_buf);
4962 $tmp_hash = sprintf ("%s", $hash_buf);
4964 elsif ($mode == 6100)
4966 $hash_buf = whirlpool_hex
($word_buf);
4968 $tmp_hash = sprintf ("%s", $hash_buf);
4970 elsif ($mode == 6300)
4972 my $iterations = 1000; # hard coded by the AIX format
4974 $hash_buf = md5_crypt
('', $iterations, $word_buf, $salt_buf);
4976 $tmp_hash = sprintf ("{smd5}%s", $hash_buf);
4978 elsif ($mode == 6400)
4980 my $iterations = 64;
4984 $iterations = 1 << int ($iter);
4987 $hash_buf = aix_ssha256_pbkdf2
($word_buf, $salt_buf, $iterations);
4989 $tmp_hash = sprintf ("{ssha256}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4991 elsif ($mode == 6500)
4993 my $iterations = 64;
4997 $iterations = 1 << int ($iter);
5000 $hash_buf = aix_ssha512_pbkdf2
($word_buf, $salt_buf, $iterations);
5002 $tmp_hash = sprintf ("{ssha512}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
5004 elsif ($mode == 6600)
5006 my $iterations = 1000;
5010 $iterations = int ($iter);
5013 my $salt_hex = substr ($salt_buf, 0, 16);
5014 my $salt = pack ("H*", $salt_hex);
5016 my $prefix = substr ($salt_buf, 16, 2016);
5018 my $iv_hex = substr ($salt_buf, 2032);
5019 my $iv = pack ("H*", $iv_hex);
5021 my $data = pack ("H*", "10101010101010101010101010101010");
5023 my $hasher = Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA1');
5025 my $pbkdf2 = Crypt
::PBKDF2
->new (
5027 iterations
=> $iterations,
5031 my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
5033 my $cipher = Crypt
::CBC
->new ({
5035 cipher
=> "Crypt::Rijndael",
5042 my $encrypted = unpack ("H*", $cipher->encrypt ($data));
5044 $hash_buf = substr ($encrypted, 0, 32);
5046 $tmp_hash = sprintf ("%i:%s:%s%s%s", $iterations, $salt_hex, $prefix, $iv_hex, $hash_buf);
5048 elsif ($mode == 6700)
5050 my $iterations = 64;
5054 $iterations = 1 << int ($iter);
5057 $hash_buf = aix_ssha1_pbkdf2
($word_buf, $salt_buf, $iterations);
5059 $tmp_hash = sprintf ("{ssha1}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
5061 elsif ($mode == 6800)
5063 my $variant = $additional_param;
5065 if (! defined ($variant))
5067 $variant = int (rand (2));
5070 my $iterations = 500;
5074 $iterations = int ($iter);
5077 my $iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
5079 my $hasher = Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 256);
5081 my $pbkdf2 = Crypt
::PBKDF2
->new (
5083 iterations
=> $iterations,
5087 my $key = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
5089 my $cipher = Crypt
::CBC
->new ({
5091 cipher
=> "Crypt::Rijndael",
5100 my $encrypt = $cipher->encrypt (substr ($salt_buf, 0, 16));
5102 $hash_buf = substr (unpack ("H*", $encrypt), 0, 32);
5106 my $verifier = "lastpass rocks\x02\x02";
5108 $hash_buf = unpack ("H*", substr ($cipher->encrypt ($verifier), 0, 16));
5111 $tmp_hash = sprintf ("%s:%i:%s", $hash_buf, $iterations, $salt_buf);
5113 elsif ($mode == 6900)
5115 $hash_buf = gost_hex
($word_buf);
5117 $tmp_hash = sprintf ("%s", $hash_buf);
5119 elsif ($mode == 7100)
5121 my $iterations = 1024;
5125 $iterations = int ($iter);
5128 my $pbkdf2 = Crypt
::PBKDF2
->new
5130 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 512),
5131 iterations
=> $iterations
5134 $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
5136 $tmp_hash = sprintf ("\$ml\$%i\$%s\$%0128s", $iterations, $salt_buf, $hash_buf);
5138 elsif ($mode == 7200)
5140 my $iterations = 1024;
5144 $iterations = int ($iter);
5147 my $pbkdf2 = Crypt
::PBKDF2
->new (
5148 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 512),
5149 iterations
=> $iterations
5152 $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
5154 $tmp_hash = sprintf ("grub.pbkdf2.sha512.%i.%s.%0128s", $iterations, $salt_buf, $hash_buf);
5156 elsif ($mode == 7300)
5158 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&sha1
);
5160 $tmp_hash = sprintf ("%s:%s", unpack ("H*", $salt_buf), $hash_buf);
5162 elsif ($mode == 7400)
5164 my $iterations = 5000;
5166 if (defined ($iter))
5170 $iterations = int ($iter);
5174 $hash_buf = sha256_crypt
($iterations, $word_buf, $salt_buf);
5176 $tmp_hash = sprintf ("%s", $hash_buf);
5178 elsif ($mode == 7500)
5180 my @salt_arr = split ("\\\$", $salt_buf);
5182 my $user = $salt_arr[0];
5184 my $realm = $salt_arr[1];
5186 my $salt = $salt_arr[2];
5188 my $hmac_salt = $salt_arr[3];
5189 my $hmac_salt_bin = pack ("H*", $hmac_salt);
5191 my $clear_data = $salt_arr[4];
5193 my $k = md4
(encode
("UTF-16LE", $word_buf));
5195 my $k1 = hmac_md5
("\x01\x00\x00\x00", $k);
5197 my $k3 = hmac_md5
($hmac_salt_bin, $k1);
5199 if (length ($clear_data) > 1)
5201 my $clear_data_bin = pack ("H*", $clear_data);
5203 $hash_buf = RC4
($k3, $clear_data_bin);
5207 my $hash = $salt_arr[5];
5209 my $hash_bin = pack ("H*", $hash);
5211 my $clear_data = RC4
($k3, $hash_bin);
5213 my $timestamp = substr ($clear_data, 14, 14);
5218 if ($timestamp !~ /^[[:digit:]]{14}$/)
5225 $hash_buf = "\x00" x
36;
5227 if ($hash_buf eq $hash_bin)
5229 $hash_buf = "\x01" x
36;
5234 $hash_buf = $hash_bin;
5238 $tmp_hash = sprintf ("\$krb5pa\$23\$%s\$%s\$%s\$%s%s", $user, $realm, $salt, unpack ("H*", $hash_buf), $hmac_salt);
5240 elsif ($mode == 7600)
5242 $hash_buf = sha1_hex
($salt_buf . sha1_hex
($word_buf));
5244 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5246 elsif ($mode == 7700)
5248 $word_buf = uc $word_buf;
5249 $salt_buf = uc $salt_buf;
5251 my $word_buf_t = sapb_transcode
($word_buf);
5252 my $salt_buf_t = sapb_transcode
($salt_buf);
5254 my $digest1 = md5
($word_buf_t . $salt_buf_t);
5256 my $data = sapb_waldorf
($digest1, $word_buf_t, $salt_buf_t);
5258 my $digest2 = md5
($data);
5260 my ($a, $b, $c, $d) = unpack ("N4", $digest2);
5265 $tmp_hash = sprintf ("%s\$%08X%08X", $salt_buf, $a, $b);
5267 elsif ($mode == 7800)
5269 my $theMagicArray_s =
5270 "\x91\xac\x51\x14\x9f\x67\x54\x43\x24\xe7\x3b\xe0\x28\x74\x7b\xc2" .
5271 "\x86\x33\x13\xeb\x5a\x4f\xcb\x5c\x08\x0a\x73\x37\x0e\x5d\x1c\x2f" .
5272 "\x33\x8f\xe6\xe5\xf8\x9b\xae\xdd\x16\xf2\x4b\x8d\x2c\xe1\xd4\xdc" .
5273 "\xb0\xcb\xdf\x9d\xd4\x70\x6d\x17\xf9\x4d\x42\x3f\x9b\x1b\x11\x94" .
5274 "\x9f\x5b\xc1\x9b\x06\x05\x9d\x03\x9d\x5e\x13\x8a\x1e\x9a\x6a\xe8" .
5275 "\xd9\x7c\x14\x17\x58\xc7\x2a\xf6\xa1\x99\x63\x0a\xd7\xfd\x70\xc3" .
5276 "\xf6\x5e\x74\x13\x03\xc9\x0b\x04\x26\x98\xf7\x26\x8a\x92\x93\x25" .
5277 "\xb0\xa2\x0d\x23\xed\x63\x79\x6d\x13\x32\xfa\x3c\x35\x02\x9a\xa3" .
5278 "\xb3\xdd\x8e\x0a\x24\xbf\x51\xc3\x7c\xcd\x55\x9f\x37\xaf\x94\x4c" .
5279 "\x29\x08\x52\x82\xb2\x3b\x4e\x37\x9f\x17\x07\x91\x11\x3b\xfd\xcd";
5281 $salt_buf = uc $salt_buf;
5283 my $digest = sha1
($word_buf . $salt_buf);
5285 my ($a, $b, $c, $d, $e) = unpack ("I*", $digest);
5287 my $lengthMagicArray = 0x20;
5288 my $offsetMagicArray = 0;
5290 $lengthMagicArray += (($a >> 0) & 0xff) % 6;
5291 $lengthMagicArray += (($a >> 8) & 0xff) % 6;
5292 $lengthMagicArray += (($a >> 16) & 0xff) % 6;
5293 $lengthMagicArray += (($a >> 24) & 0xff) % 6;
5294 $lengthMagicArray += (($b >> 0) & 0xff) % 6;
5295 $lengthMagicArray += (($b >> 8) & 0xff) % 6;
5296 $lengthMagicArray += (($b >> 16) & 0xff) % 6;
5297 $lengthMagicArray += (($b >> 24) & 0xff) % 6;
5298 $lengthMagicArray += (($c >> 0) & 0xff) % 6;
5299 $lengthMagicArray += (($c >> 8) & 0xff) % 6;
5300 $offsetMagicArray += (($c >> 16) & 0xff) % 8;
5301 $offsetMagicArray += (($c >> 24) & 0xff) % 8;
5302 $offsetMagicArray += (($d >> 0) & 0xff) % 8;
5303 $offsetMagicArray += (($d >> 8) & 0xff) % 8;
5304 $offsetMagicArray += (($d >> 16) & 0xff) % 8;
5305 $offsetMagicArray += (($d >> 24) & 0xff) % 8;
5306 $offsetMagicArray += (($e >> 0) & 0xff) % 8;
5307 $offsetMagicArray += (($e >> 8) & 0xff) % 8;
5308 $offsetMagicArray += (($e >> 16) & 0xff) % 8;
5309 $offsetMagicArray += (($e >> 24) & 0xff) % 8;
5311 my $hash_buf = sha1_hex
($word_buf . substr ($theMagicArray_s, $offsetMagicArray, $lengthMagicArray) . $salt_buf);
5313 $tmp_hash = sprintf ("%s\$%s", $salt_buf, uc $hash_buf);
5315 elsif ($mode == 7900)
5324 my $phpass_it = 1 << $cost;
5326 $hash_buf = sha512
($salt_buf . $word_buf);
5328 for (my $i = 0; $i < $phpass_it; $i++)
5330 $hash_buf = sha512
($hash_buf . $word_buf);
5333 my $base64_buf = substr (Authen
::Passphrase
::PHPass
::_en_base64
($hash_buf), 0, 43);
5335 my $base64_digits = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
5337 my $cost_str = substr ($base64_digits , $cost, 1);
5339 $tmp_hash = sprintf ('$S$%s%s%s', $cost_str, $salt_buf, $base64_buf);
5341 elsif ($mode == 8000)
5343 my $salt_buf_bin = pack ("H*", $salt_buf);
5345 my $word_buf_utf = encode
("UTF-16BE", $word_buf);
5347 $hash_buf = sha256_hex
($word_buf_utf . "\x00" x
(510 - (length ($word_buf) * 2)) . $salt_buf_bin);
5349 $tmp_hash = sprintf ("0xc007%s%s", $salt_buf, $hash_buf);
5351 elsif ($mode == 8100)
5353 $hash_buf = sha1_hex
($salt_buf . $word_buf . "\x00");
5355 $tmp_hash = sprintf ("1%s%s", $salt_buf, $hash_buf);
5357 elsif ($mode == 8200)
5359 my $iterations = 40000;
5361 if (defined ($iter))
5363 $iterations = $iter;
5366 my $salt_hex = substr ($salt_buf, 0, 32);
5367 my $salt = pack ("H*", $salt_hex);
5369 my $data_hex = substr ($salt_buf, 32);
5370 my $data = pack ("H*", $data_hex);
5372 my $pbkdf2 = Crypt
::PBKDF2
->new
5374 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 512),
5375 iterations
=> int $iterations
5378 my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
5380 $hash_buf = hmac_hex
($data, substr ($key, 32, 32), \
&sha256
, 64);
5382 $tmp_hash = sprintf ("%s:%s:%d:%s", $hash_buf, $salt_hex, $iterations, $data_hex);
5384 elsif ($mode == 8300)
5386 my ($domain, $salt_hex) = split (":", $salt_buf);
5388 my $hashalg = Net
::DNS
::SEC
->digtype ("SHA1");
5390 my $salt = pack ("H*", $salt_hex);
5394 if (defined ($iter))
5396 $iterations = $iter;
5399 my $name = lc ($word_buf . $domain);
5401 my $hash_buf = Net
::DNS
::RR
::NSEC3
::name2hash
($hashalg, $name, $iterations, $salt);
5403 $tmp_hash = sprintf ("%s:%s:%s:%d", $hash_buf, $domain, $salt_hex, $iterations);
5405 elsif ($mode == 8400)
5407 $hash_buf = sha1_hex
($salt_buf . sha1_hex
($salt_buf . sha1_hex
($word_buf)));
5409 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5411 elsif ($mode == 8500)
5413 $hash_buf = racf_hash
(uc $salt_buf, $word_buf);
5415 $tmp_hash = sprintf ('$racf$*%s*%s', uc $salt_buf, uc $hash_buf);
5417 elsif ($mode == 8600)
5419 my @saved_key = map { ord $_; } split "", $word_buf;
5421 my $len = scalar @saved_key;
5423 my @state = domino_big_md
(\
@saved_key, $len);
5425 $tmp_hash = sprintf ('%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x',
5444 elsif ($mode == 8700)
5446 my $domino_char = undef;
5448 if (defined ($additional_param))
5450 $domino_char = $additional_param;
5453 my @saved_key = map { ord $_; } split "", $word_buf;
5455 my $len = scalar @saved_key;
5457 my @state = domino_big_md
(\
@saved_key, $len);
5459 my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5461 @saved_key = map { ord $_; } split "", $salt_buf . uc $str;
5463 @state = domino_big_md
(\
@saved_key, 34);
5465 $hash_buf = join ("", (map { chr $_; } @state));
5467 $tmp_hash = sprintf ('(G%s)', domino_encode
($salt_buf . $hash_buf, $domino_char));
5469 elsif ($mode == 8900)
5475 if (defined ($additional_param))
5477 $N = $additional_param;
5478 $r = $additional_param2;
5479 $p = $additional_param3;
5482 $hash_buf = scrypt_hash
($word_buf, $salt_buf, $N, $r, $p, 32);
5484 $tmp_hash = sprintf ('%s', $hash_buf);
5486 elsif ($mode == 9100)
5488 my $iterations = 5000;
5490 if (defined ($iter))
5492 $iterations = $iter;
5495 my $domino_char = undef;
5497 # domino 5 hash - SEC_pwddigest_V1 - -m 8600
5499 my @saved_key = map { ord $_; } split "", $word_buf;
5501 my $len = scalar @saved_key;
5503 my @state = domino_big_md
(\
@saved_key, $len);
5506 # domino 6 hash - SEC_pwddigest_V2 - -m 8700
5508 my $salt_part = substr ($salt_buf, 0, 5);
5510 my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5512 @saved_key = map { ord $_; } split "", $salt_part . uc $str;
5514 @state = domino_big_md
(\
@saved_key, 34);
5516 $hash_buf = join ("", (map { chr $_; } @state));
5518 $tmp_hash = sprintf ('(G%s)', domino_encode
($salt_part . $hash_buf, $domino_char));
5521 # domino 8(.5.x) hash - SEC_pwddigest_V3 - -m 9100
5523 my $pbkdf2 = Crypt
::PBKDF2
->new
5525 hash_class
=> 'HMACSHA1',
5526 iterations
=> $iterations,
5533 if (defined ($additional_param))
5535 $chars = $additional_param;
5538 my $digest_new = $pbkdf2->PBKDF2 ($salt_buf, $tmp_hash);
5540 my $iteration_str = "" . $iterations;
5542 for (my $i = length ($iterations); $i < 10; $i++)
5544 $iterations = "0" . $iterations;
5547 $tmp_hash = sprintf ('(H%s)', domino_85x_encode
($salt_buf . $iterations . $chars . $digest_new, $domino_char));
5549 elsif ($mode == 9200)
5551 my $iterations = 20000;
5553 my $pbkdf2 = Crypt
::PBKDF2
->new
5555 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 256),
5556 iterations
=> $iterations
5559 $hash_buf = encode_base64
($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5563 for (my $i = 0; $i < 43; $i++)
5565 $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5568 $tmp_hash = sprintf ("\$8\$%s\$%s", $salt_buf, $tmp_hash);
5570 elsif ($mode == 9300)
5576 $hash_buf = scrypt_b64
($word_buf, $salt_buf, $N, $r, $p, 32);
5580 for (my $i = 0; $i < 43; $i++)
5582 $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5585 $tmp_hash = sprintf ('$9$%s$%s', $salt_buf, $tmp_hash);
5587 elsif ($mode == 9400)
5589 my $iterations = 50000;
5593 $iterations = int ($iter);
5596 my $aes_key_size = 128; # or 256
5598 if (defined ($additional_param2))
5600 $aes_key_size = $additional_param2;
5603 $salt_buf = pack ("H*", $salt_buf);
5605 my $tmp = sha1
($salt_buf . encode
("UTF-16LE", $word_buf));
5607 for (my $i = 0; $i < $iterations; $i++)
5609 my $num32 = pack ("L", $i);
5611 $tmp = sha1
($num32 . $tmp);
5614 my $zero32 = pack ("L", 0x00);
5616 my $derivation_array1 = pack ("C", 0x36) x
64;
5617 my $derivation_array2 = pack ("C", 0x5C) x
64;
5619 $tmp = sha1
($tmp . $zero32);
5621 my $tmp2 = sha1
($derivation_array1 ^ $tmp);
5622 my $tmp3 = sha1
($derivation_array2 ^ $tmp);
5624 my $key = substr ($tmp2 . $tmp3, 0, $aes_key_size / 8);
5626 my $m = Crypt
::Mode
::ECB
->new ('AES', 0);
5630 if (defined $additional_param)
5632 $encdata = $m->decrypt (pack ("H*", $additional_param), $key);
5636 $encdata = "A" x
16; ## can be anything
5639 my $data1_buf = $encdata;
5640 my $data2_buf = sha1
(substr ($data1_buf, 0, 16));
5642 $data1_buf = substr ($data1_buf . ("\x00" x
16), 0, 16);
5643 $data2_buf = substr ($data2_buf . ("\x00" x
16), 0, 32);
5645 my $encrypted1 = unpack ("H*", $m->encrypt ($data1_buf, $key));
5646 my $encrypted2 = unpack ("H*", $m->encrypt ($data2_buf, $key));
5648 $encrypted1 = substr ($encrypted1, 0, 32);
5649 $encrypted2 = substr ($encrypted2, 0, 40);
5651 $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2007, 20, $aes_key_size, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5653 elsif ($mode == 9500)
5655 my $iterations = 100000;
5659 $iterations = int ($iter);
5662 $salt_buf = pack ("H*", $salt_buf);
5664 my $tmp = sha1
($salt_buf . encode
("UTF-16LE", $word_buf));
5666 for (my $i = 0; $i < $iterations; $i++)
5668 my $num32 = pack ("L", $i);
5670 $tmp = sha1
($num32 . $tmp);
5673 my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5674 my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5676 my $final1 = sha1
($tmp . $encryptedVerifierHashInputBlockKey);
5677 my $final2 = sha1
($tmp . $encryptedVerifierHashValueBlockKey);
5679 my $key1 = substr ($final1, 0, 16);
5680 my $key2 = substr ($final2, 0, 16);
5682 my $cipher1 = Crypt
::CBC
->new ({
5684 cipher
=> "Crypt::Rijndael",
5692 my $cipher2 = Crypt
::CBC
->new ({
5694 cipher
=> "Crypt::Rijndael",
5704 if (defined $additional_param)
5706 $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5710 $encdata = "A" x
16; ## can be anything
5713 my $data1_buf = $encdata;
5714 my $data2_buf = sha1
(substr ($data1_buf, 0, 16));
5716 my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5717 my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5719 $encrypted2 = substr ($encrypted2, 0, 64);
5721 $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2010, 100000, 128, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5723 elsif ($mode == 9600)
5725 my $iterations = 100000;
5729 $iterations = int ($iter);
5732 $salt_buf = pack ("H*", $salt_buf);
5734 my $tmp = sha512
($salt_buf . encode
("UTF-16LE", $word_buf));
5736 for (my $i = 0; $i < $iterations; $i++)
5738 my $num32 = pack ("L", $i);
5740 $tmp = sha512
($num32 . $tmp);
5743 my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5744 my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5746 my $final1 = sha512
($tmp . $encryptedVerifierHashInputBlockKey);
5747 my $final2 = sha512
($tmp . $encryptedVerifierHashValueBlockKey);
5749 my $key1 = substr ($final1, 0, 32);
5750 my $key2 = substr ($final2, 0, 32);
5752 my $cipher1 = Crypt
::CBC
->new ({
5754 cipher
=> "Crypt::Rijndael",
5762 my $cipher2 = Crypt
::CBC
->new ({
5764 cipher
=> "Crypt::Rijndael",
5774 if (defined $additional_param)
5776 $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5780 $encdata = "A" x
16; ## can be anything
5783 my $data1_buf = $encdata;
5784 my $data2_buf = sha512
(substr ($data1_buf, 0, 16));
5786 my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5787 my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5789 $encrypted2 = substr ($encrypted2, 0, 64);
5791 $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2013, 100000, 256, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5793 elsif ($mode == 9700)
5795 $salt_buf = pack ("H*", $salt_buf);
5797 my $tmp = md5
(encode
("UTF-16LE", $word_buf));
5799 $tmp = substr ($tmp, 0, 5);
5803 for (my $i = 0; $i < 16; $i++)
5811 $tmp = substr ($tmp, 0, 5);
5815 if (defined $additional_param2)
5817 $version = $additional_param2;
5821 $version = (unpack ("L", $tmp) & 1) ?
0 : 1;
5824 my $rc4_key = md5
($tmp . "\x00\x00\x00\x00");
5826 my $m = Crypt
::RC4
->new (substr ($rc4_key, 0, 16));
5830 if (defined $additional_param)
5832 $encdata = $m->RC4 (pack ("H*", $additional_param));
5836 $encdata = "A" x
16; ## can be anything
5839 my $data1_buf = $encdata;
5840 my $data2_buf = md5
(substr ($data1_buf, 0, 16));
5842 $m = Crypt
::RC4
->new (substr ($rc4_key, 0, 16));
5844 my $encrypted1 = $m->RC4 ($data1_buf);
5845 my $encrypted2 = $m->RC4 ($data2_buf);
5847 $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5849 elsif ($mode == 9800)
5851 $salt_buf = pack ("H*", $salt_buf);
5853 my $tmp = sha1
($salt_buf. encode
("UTF-16LE", $word_buf));
5857 if (defined $additional_param2)
5859 $version = $additional_param2;
5863 $version = (unpack ("L", $tmp) & 1) ?
3 : 4;
5866 my $rc4_key = sha1
($tmp . "\x00\x00\x00\x00");
5870 $rc4_key = substr ($rc4_key, 0, 5) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
5873 my $m = Crypt
::RC4
->new (substr ($rc4_key, 0, 16));
5877 if (defined $additional_param)
5879 $encdata = $m->RC4 (pack ("H*", $additional_param));
5883 $encdata = "A" x
16; ## can be anything
5886 my $data1_buf = $encdata;
5887 my $data2_buf = sha1
(substr ($data1_buf, 0, 16));
5889 $m = Crypt
::RC4
->new (substr ($rc4_key, 0, 16));
5891 my $encrypted1 = $m->RC4 ($data1_buf);
5892 my $encrypted2 = $m->RC4 ($data2_buf);
5894 $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5896 elsif ($mode == 9900)
5898 $tmp_hash = sprintf ("%s", md5_hex
($word_buf . "\0" x
(100 - length ($word_buf))));
5900 elsif ($mode == 10000)
5902 my $iterations = 10000;
5906 $iterations = int ($iter);
5909 my $pbkdf2 = Crypt
::PBKDF2
->new
5911 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 256),
5912 iterations
=> $iterations
5915 $hash_buf = encode_base64
($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5916 $hash_buf =~ s/[\r\n]//g;
5918 $tmp_hash = sprintf ("pbkdf2_sha256\$%i\$%s\$%s", $iterations, $salt_buf, $hash_buf);
5920 elsif ($mode == 10100)
5922 my $seed = pack ("H*", $salt_buf);
5924 my ($hi, $lo) = siphash
($word_buf, $seed);
5926 my $hi_s = sprintf ("%08x", $hi);
5927 my $lo_s = sprintf ("%08x", $lo);
5929 $hi_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5930 $lo_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5932 $tmp_hash = sprintf ("%s%s:2:4:%s", $hi_s, $lo_s, $salt_buf);
5934 elsif ($mode == 10200)
5936 my $challengeb64 = encode_base64
($salt_buf);
5937 $challengeb64 =~ s/[\r\n]//g;
5941 if (defined $additional_param)
5943 $username = $additional_param;
5950 $hash_buf = hmac_hex
($salt_buf, $word_buf, \
&md5
);
5952 my $responseb64 = encode_base64
($username . " " . $hash_buf);
5953 $responseb64 =~ s/[\r\n]//g;
5955 $tmp_hash = sprintf ('$cram_md5$%s$%s', $challengeb64, $responseb64);
5957 elsif ($mode == 10300)
5959 my $iterations = 1024;
5963 $iterations = int ($iter);
5966 my $hash_buf = $salt_buf;
5968 for (my $pos = 0; $pos < $iterations; $pos++)
5970 $hash_buf = sha1
($word_buf . $hash_buf);
5973 $hash_buf = encode_base64
($hash_buf . $salt_buf);
5974 $hash_buf =~ s/[\r\n]//g;
5976 $tmp_hash = sprintf ("{x-issha, %i}%s", $iterations, $hash_buf);
5978 elsif ($mode == 10400)
5981 my $u = $additional_param;
5982 my $o = $additional_param2;
5983 my $P = $additional_param3;
5985 if (defined $u == 0)
5990 if (defined $o == 0)
5995 if (defined $P == 0)
6002 for (my $i = 0; $i < 32; $i++)
6004 $padding .= pack ("C", $pdf_padding[$i]);
6007 my $res = pdf_compute_encryption_key
($word_buf, $padding, $id, $u, $o, $P, 1, 2, 0);
6009 my $m = Crypt
::RC4
->new (substr ($res, 0, 5));
6011 $u = $m->RC4 ($padding);
6013 $tmp_hash = sprintf ('$pdf$%d*%d*40*%d*%d*16*%s*32*%s*32*%s', 1, 2, $P, 0, $id, unpack ("H*", $u), $o);
6015 elsif ($mode == 10500)
6018 my $u = $additional_param;
6019 my $o = $additional_param2;
6020 my $P = $additional_param3;
6021 my $V = $additional_param4;
6022 my $R = $additional_param5;
6023 my $enc = $additional_param6;
6025 if (defined $u == 0)
6032 if (defined $o == 0)
6037 if (defined $R == 0)
6039 $R = get_random_num
(3, 5);
6042 if (defined $V == 0)
6044 $V = ($R == 3) ?
2 : 4;
6047 if (defined $P == 0)
6049 $P = ($R == 3) ?
-4 : -1028;
6052 if (defined $enc == 0)
6054 $enc = ($R == 3) ?
1 : get_random_num
(0, 2);
6059 for (my $i = 0; $i < 32; $i++)
6061 $padding .= pack ("C", $pdf_padding[$i]);
6064 my $res = pdf_compute_encryption_key
($word_buf, $padding, $id, $u, $o, $P, $V, $R, $enc);
6066 my $digest = md5
($padding . pack ("H*", $id));
6068 my $m = Crypt
::RC4
->new ($res);
6070 $u = $m->RC4 ($digest);
6072 my @ress = split "", $res;
6074 for (my $x = 1; $x <= 19; $x++)
6078 for (my $i = 0; $i < 16; $i++)
6080 $xor[$i] = chr (ord ($ress[$i]) ^ $x);
6083 my $s = join ("", @xor);
6085 my $m2 = Crypt
::RC4
->new ($s);
6090 $u .= substr (pack ("H*", $u_save), 16, 16);
6092 $tmp_hash = sprintf ('$pdf$%d*%d*128*%d*%d*16*%s*32*%s*32*%s', $V, $R, $P, $enc, $id, unpack ("H*", $u), $o);
6094 elsif ($mode == 10600)
6097 my $rest = $additional_param;
6099 if (defined $id == 0)
6104 if (defined $rest == 0)
6110 $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
6113 my @data = split /\*/, $rest;
6115 my $u = pack ("H*", $data[1]);
6117 my $h = sha256
($word_buf . substr ($u, 32, 8));
6119 $data[1] = unpack ("H*", $h . substr ($u, 32));
6121 $rest = join ("*", @data);
6123 $tmp_hash = sprintf ('$pdf$5*5*256*-1028*1*16*%s*%s', $id, $rest);
6125 elsif ($mode == 10700)
6128 my $rest = $additional_param;
6130 if (defined $id == 0)
6135 if (defined $rest == 0)
6141 $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
6144 my @datax = split /\*/, $rest;
6146 my $u = pack ("H*", $datax[1]);
6148 my $block = sha256
($word_buf . substr ($u, 32, 8));
6150 my $block_size = 32;
6152 my $data = 0x00 x
64;
6158 for (my $i = 0; $i < 64 || $i < $data63 + 32; $i++)
6160 $data = $word_buf . $block;
6162 $data_len = length ($data);
6164 for (my $k = 1; $k < 64; $k++)
6166 $data .= $word_buf . $block;
6169 my $aes = Crypt
::CBC
->new ({
6170 key
=> substr ($block, 0, 16),
6171 cipher
=> "Crypt::Rijndael",
6172 iv
=> substr ($block, 16, 16),
6179 my $data = $aes->encrypt ($data);
6183 for (my $j = 0; $j < 16; $j++)
6185 $sum += ord (substr ($data, $j, 1));
6188 $block_size = 32 + ($sum % 3) * 16;
6190 if ($block_size == 32)
6192 $block = sha256
(substr ($data, 0, $data_len * 64));
6194 elsif ($block_size == 48)
6196 $block = sha384
(substr ($data, 0, $data_len * 64));
6198 elsif ($block_size == 64)
6200 $block = sha512
(substr ($data, 0, $data_len * 64));
6203 $data63 = ord (substr ($data, $data_len * 64 - 1, 1));
6206 $datax[1] = unpack ("H*", substr ($block, 0, 32) . substr ($u, 32));
6208 $rest = join ("*", @datax);
6210 $tmp_hash = sprintf ('$pdf$5*6*256*-1028*1*16*%s*%s', $id, $rest);
6212 elsif ($mode == 10800)
6214 $hash_buf = sha384_hex
($word_buf);
6216 $tmp_hash = sprintf ("%s", $hash_buf);
6218 elsif ($mode == 10900)
6220 my $iterations = 1000;
6224 $iterations = int ($iter);
6229 if (defined $additional_param)
6231 $out_len = $additional_param;
6234 my $pbkdf2 = Crypt
::PBKDF2
->new
6236 hasher
=> Crypt
::PBKDF2
->hasher_from_algorithm ('HMACSHA2', 256),
6237 iterations
=> $iterations,
6238 output_len
=> $out_len
6241 $hash_buf = encode_base64
($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6242 $hash_buf =~ s/[\r\n]//g;
6244 my $base64_salt_buf = encode_base64
($salt_buf);
6246 chomp ($base64_salt_buf);
6248 $tmp_hash = sprintf ("sha256:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6250 elsif ($mode == 11000)
6252 $hash_buf = md5_hex
($salt_buf . $word_buf);
6254 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
6256 elsif ($mode == 11100)
6258 my $user = "postgres";
6260 if (defined $additional_param)
6262 $user = $additional_param;
6265 $hash_buf = md5_hex
(md5_hex
($word_buf . $user) . pack ("H*", $salt_buf));
6267 $tmp_hash = sprintf ("\$postgres\$%s*%s*%s", $user, $salt_buf, $hash_buf);
6269 elsif ($mode == 11200)
6271 my $sha1_pass = sha1
($word_buf);
6272 my $double_sha1 = sha1
($sha1_pass);
6274 my $xor_part1 = $sha1_pass;
6275 my $xor_part2 = sha1
(pack ("H*", $salt_buf) . $double_sha1);
6279 for (my $i = 0; $i < 20; $i++)
6281 my $first_byte = substr ($xor_part1, $i, 1);
6282 my $second_byte = substr ($xor_part2, $i, 1);
6284 my $xor_result = $first_byte ^ $second_byte;
6286 $hash_buf .= unpack ("H*", $xor_result);
6289 $tmp_hash = sprintf ("\$mysqlna\$%s*%s", $salt_buf, $hash_buf);
6291 elsif ($mode == 11300)
6293 my $ckey_buf = get_random_string
(96);
6295 if (length ($additional_param))
6297 $ckey_buf = $additional_param;
6300 my $public_key_buf = get_random_string
(66);
6302 if (length ($additional_param2))
6304 $public_key_buf = $additional_param2;
6307 my $salt_iter = get_random_num
(150000, 250000);
6311 $salt_iter = int ($iter);
6314 my $hash_buf = sha512
($word_buf . pack ("H*", $salt_buf));
6316 for (my $i = 1; $i < $salt_iter; $i++)
6318 $hash_buf = sha512
($hash_buf);
6321 my $data = get_random_string
(32);
6323 my $aes = Crypt
::CBC
->new ({
6324 key
=> substr ($hash_buf, 0, 32),
6325 cipher
=> "Crypt::Rijndael",
6326 iv
=> substr ($hash_buf, 32, 16),
6330 padding
=> "standard",
6333 my $cry_master_buf = (unpack ("H*", $aes->encrypt ($data)));
6335 $tmp_hash = sprintf ('$bitcoin$%d$%s$%d$%s$%d$%d$%s$%d$%s',
6336 length ($cry_master_buf),
6343 length ($public_key_buf),
6346 elsif ($mode == 11400)
6348 my ($directive, $URI_server, $URI_client, $user, $realm, $nonce, $nonce_count, $nonce_client, $qop, $method, $URI, $URI_prefix, $URI_resource, $URI_suffix);
6350 $directive = "MD5"; # only directive currently supported
6352 if (defined ($additional_param))
6354 $user = $additional_param;
6355 $realm = $additional_param2;
6357 $nonce_count = $additional_param3;
6358 $nonce_client = $additional_param4;
6359 $qop = $additional_param5;
6360 $method = $additional_param6;
6362 $URI_prefix = $additional_param7;
6363 $URI_resource = $additional_param8;
6364 $URI_suffix = $additional_param9;
6366 # not needed information
6368 $URI_server = $additional_param10;
6369 $URI_client = $additional_param11;
6373 $user = get_random_string
(get_random_num
(0, 12 + 1));
6375 # special limit: (user_len + 1 + realm_len + 1 + word_buf_len) < 56
6376 my $realm_max_len = 55 - length ($user) - 1 - length ($word_buf) - 1;
6378 if ($realm_max_len < 1) # should never happen
6383 $realm_max_len = min
(20, $realm_max_len);
6385 $realm = get_random_string
(get_random_num
(0, $realm_max_len + 1));
6389 if (get_random_num
(0, 1 + 1) == 1)
6393 $nonce_count = get_random_string
(get_random_num
(0, 10 + 1));
6394 $nonce_client = get_random_string
(get_random_num
(0, 12 + 1));
6404 $method = get_random_string
(get_random_num
(0, 24 + 1));
6406 $URI_prefix = get_random_string
(get_random_num
(0, 10 + 1));
6407 $URI_resource = get_random_string
(get_random_num
(1, 32 + 1));
6408 $URI_suffix = get_random_string
(get_random_num
(0, 32 + 1));
6410 # not needed information
6412 $URI_server = get_random_string
(get_random_num
(0, 32 + 1));
6413 $URI_client = $URI_resource; # simplification
6420 if (length ($URI_prefix) > 0)
6422 $URI = $URI_prefix . ":";
6425 $URI .= $URI_resource;
6427 if (length ($URI_suffix) > 0)
6429 $URI .= ":" . $URI_suffix;
6432 my $HA2 = md5_hex
($method . ":" . $URI);
6434 my $HA1 = md5_hex
($user . ":" . $realm . ":" . $word_buf);
6438 if (($qop eq "auth") || ($qop eq "auth-int"))
6440 $tmp_buf = $nonce . ":" . $nonce_count . ":" . $nonce_client . ":" . $qop;
6447 my $hash_buf = md5_hex
($HA1 . ":" . $tmp_buf . ":" . $HA2);
6449 $tmp_hash = sprintf ("\$sip\$*%s*%s*%s*%s*%s*%s*%s*%s*%s*%s*%s*%s*%s*%s", $URI_server, $URI_resource, $user, $realm, $method, $URI_prefix, $URI_resource, $URI_suffix, $nonce, $nonce_client, $nonce_count, $qop, $directive, $hash_buf);
6451 elsif ($mode == 11500)
6453 $hash_buf = crc32
($word_buf);
6455 $tmp_hash = sprintf ("%08x:00000000", $hash_buf);
6457 elsif ($mode == 11600)
6459 my ($p, $num_cycle_power, $seven_zip_salt_len, $seven_zip_salt_buf, $salt_len, $data_len, $unpack_size, $data_buf);
6463 my $validation_only = 0;
6465 $validation_only = 1 if (defined ($additional_param));
6467 if ($validation_only == 1)
6469 $num_cycle_power = int ($iter);
6470 $seven_zip_salt_len = $additional_param;
6471 $seven_zip_salt_buf = $additional_param2;
6472 $salt_len = $additional_param3;
6473 # $salt_buf set in parser
6474 # $hash_buf (resulting crc)
6475 $data_len = $additional_param4;
6476 $unpack_size = $additional_param5;
6477 $data_buf = $additional_param6;
6481 $num_cycle_power = 14; # by default it is 19
6482 $seven_zip_salt_len = 0;
6483 $seven_zip_salt_buf = "";
6484 $salt_len = length ($salt_buf);
6485 # $salt_buf set automatically
6486 # $hash_buf (resulting crc)
6487 # $data_len will be set when encrypting
6488 $unpack_size = get_random_num
(1, 32 + 1);
6489 $data_buf = get_random_string
($unpack_size);
6493 # 2 ^ NumCyclesPower "iterations" of SHA256 (only one final SHA256)
6496 $word_buf = encode
("UTF-16LE", $word_buf);
6498 my $rounds = 1 << $num_cycle_power;
6502 for (my $i = 0; $i < $rounds; $i++)
6506 $num_buf .= pack ("V", $i);
6507 $num_buf .= "\x00" x
4;
6509 # this would be better but only works on 64-bit systems:
6510 # $num_buf = pack ("q", $i);
6512 $pass_buf .= sprintf ("%s%s", $word_buf, $num_buf);
6515 my $key = sha256
($pass_buf);
6517 # the salt_buf is our IV for AES CBC
6520 my $salt_buf_len = length ($salt_buf);
6521 my $salt_padding_len = 0;
6523 if ($salt_buf_len < 16)
6525 $salt_padding_len = 16 - $salt_buf_len;
6528 $salt_buf .= "\x00" x
$salt_padding_len;
6530 my $aes = Crypt
::CBC
->new ({
6531 cipher
=> "Crypt::Rijndael",
6539 if ($validation_only == 1)
6543 my $decrypted_data = $aes->decrypt ($data_buf);
6545 $decrypted_data = substr ($decrypted_data, 0, $unpack_size);
6547 $hash_buf = crc32
($decrypted_data);
6553 $hash_buf = crc32
($data_buf);
6555 $data_buf = $aes->encrypt ($data_buf);
6557 $data_len = length ($data_buf);
6560 $tmp_hash = sprintf ("\$7z\$%i\$%i\$%i\$%s\$%i\$%08s\$%u\$%u\$%u\$%s", $p, $num_cycle_power, $seven_zip_salt_len, $seven_zip_salt_buf, $salt_len, unpack ("H*", $salt_buf), $hash_buf, $data_len, $unpack_size, unpack ("H*", $data_buf));
6562 elsif ($mode == 11900)
6564 my $iterations = 1000;
6568 $iterations = int ($iter);
6573 if (defined $additional_param)
6575 $out_len = $additional_param;
6579 # call PHP here - WTF
6582 # sanitize $word_buf and $salt_buf:
6584 my $word_buf_base64 = encode_base64
($word_buf);
6585 $word_buf_base64 =~ s/[\r\n]//g;
6587 my $salt_buf_base64 = encode_base64
($salt_buf);
6588 $salt_buf_base64 =~ s/[\r\n]//g;
6592 $out_len = int ($out_len);
6594 # output is in hex encoding, otherwise it could be screwed (but shouldn't)
6596 my $php_code = <<'END_CODE';
6598 function pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
6600 $algorithm = strtolower ($algorithm);
6602 if (! in_array ($algorithm, hash_algos (), true))
6604 trigger_error ("PBKDF2 ERROR: Invalid hash algorithm.", E_USER_ERROR);
6607 if ($count <= 0 || $key_length <= 0)
6609 trigger_error ("PBKDF2 ERROR: Invalid parameters.", E_USER_ERROR);
6612 if (function_exists ("hash_pbkdf2"))
6616 $key_length = $key_length * 2;
6619 return hash_pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output);
6622 $hash_length = strlen (hash ($algorithm, "", true));
6623 $block_count = ceil ($key_length / $hash_length);
6627 for ($i = 1; $i <= $block_count; $i++)
6629 $last = $salt . pack ("N", $i);
6631 $last = $xorsum = hash_hmac ($algorithm, $last, $password, true);
6633 for ($j = 1; $j < $count; $j++)
6635 $xorsum ^= ($last = hash_hmac ($algorithm, $last, $password, true));
6643 return substr ($output, 0, $key_length);
6647 return bin2hex (substr ($output, 0, $key_length));
6651 print pbkdf2 ("md5", base64_decode ("$word_buf_base64"), base64_decode ("$salt_buf_base64"), $iterations, $out_len, False);
6655 # replace with these command line arguments
6657 $php_code =~ s/\$word_buf_base64/$word_buf_base64/;
6658 $php_code =~ s/\$salt_buf_base64/$salt_buf_base64/;
6659 $php_code =~ s/\$iterations/$iterations/;
6660 $php_code =~ s/\$out_len/$out_len/;
6662 my $php_output = `php -r '$php_code'`;
6664 $hash_buf = pack ("H*", $php_output);
6666 $hash_buf = encode_base64 ($hash_buf);
6667 $hash_buf =~ s/[\r\n]//g;
6669 my $base64_salt_buf = encode_base64 ($salt_buf);
6671 chomp ($base64_salt_buf);
6673 $tmp_hash = sprintf ("md5:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6675 elsif ($mode == 12000)
6677 my $iterations = 1000;
6681 $iterations = int ($iter);
6686 if (defined $additional_param)
6688 $out_len = $additional_param;
6691 my $pbkdf2 = Crypt::PBKDF2->new
6693 hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'),
6694 iterations => $iterations,
6695 output_len => $out_len
6698 $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6699 $hash_buf =~ s/[\r\n]//g;
6701 my $base64_salt_buf = encode_base64 ($salt_buf);
6703 chomp ($base64_salt_buf);
6705 $tmp_hash = sprintf ("sha1:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6707 elsif ($mode == 12100)
6709 my $iterations = 1000;
6713 $iterations = int ($iter);
6718 if (defined $additional_param)
6720 $out_len = $additional_param;
6723 my $pbkdf2 = Crypt::PBKDF2->new
6725 hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
6726 iterations => $iterations,
6727 output_len => $out_len
6730 $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6731 $hash_buf =~ s/[\r\n]//g;
6733 my $base64_salt_buf = encode_base64 ($salt_buf);
6735 chomp ($base64_salt_buf);
6737 $tmp_hash = sprintf ("sha512:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6739 elsif ($mode == 12200)
6741 my $iterations = 65536;
6743 my $default_salt = 0;
6745 if (defined $additional_param)
6747 $default_salt = int ($additional_param);
6750 if ($default_salt == 1)
6752 $salt_buf = "0011223344556677";
6755 $hash_buf = sha512 (pack ("H*", $salt_buf) . $word_buf);
6757 for (my $i = 0; $i < $iterations; $i++)
6759 $hash_buf = sha512 ($hash_buf);
6762 $hash_buf = unpack ("H*", $hash_buf);
6763 $hash_buf = substr ($hash_buf, 0, 16);
6765 if ($default_salt == 0)
6767 $tmp_hash = sprintf ("\$ecryptfs\$0\$1\$%s\$%s", $salt_buf, $hash_buf);
6771 $tmp_hash = sprintf ("\$ecryptfs\$0\$%s", $hash_buf);
6774 elsif ($mode == 12300)
6776 my $iterations = 4096;
6778 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
6780 my $pbkdf2 = Crypt::PBKDF2->new (
6782 iterations => $iterations,
6786 my $salt_bin = pack ("H*", $salt_buf);
6788 my $key = $pbkdf2->PBKDF2 ($salt_bin. "AUTH_PBKDF2_SPEEDY_KEY", $word_buf);
6790 $hash_buf = sha512_hex ($key . $salt_bin);
6792 $tmp_hash = sprintf ("%s%s", uc ($hash_buf), uc ($salt_buf));
6794 elsif ($mode == 12400)
6800 $iterations = int ($iter);
6804 $iterations = get_random_num (1, 5001 + 1);
6807 my $key_value = fold_password ($word_buf);
6809 my $data = "\x00\x00\x00\x00\x00\x00\x00\x00";
6810 my $salt_value = base64_to_int24 ($salt_buf);
6812 $hash_buf = crypt_rounds ($key_value, $iterations, $salt_value, $data);
6814 $tmp_hash = sprintf ("_%s%s%s", int24_to_base64 ($iterations), $salt_buf, block_to_base64 ($hash_buf));
6816 elsif ($mode == 12600)
6818 $hash_buf = sha1_hex ($word_buf);
6820 $hash_buf = sha256_hex ($salt_buf . uc $hash_buf);
6822 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
6824 elsif ($mode == 12700)
6826 my $iterations = 10;
6829 "guid" : "00000000-0000-0000-0000-000000000000",
6830 "sharedKey" : "00000000-0000-0000-0000-000000000000",
6831 "options" : {"pbkdf2_iterations":10,"fee_policy":0,"html5_notifications":false,"logout_time":600000,"tx_display":0,"always_keep_local_backup":false}|;
6833 my $salt_buf_bin = pack ("H*", $salt_buf);
6835 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
6837 my $pbkdf2 = Crypt::PBKDF2->new (
6839 iterations => $iterations,
6843 my $key = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6845 my $cipher = Crypt::CBC->new ({
6847 cipher => "Crypt::Rijndael",
6848 iv => $salt_buf_bin,
6854 my $encrypted = unpack ("H*", $cipher->encrypt ($data));
6856 $tmp_hash = sprintf ("\$blockchain\$%s\$%s", length ($salt_buf . $encrypted) / 2, $salt_buf . $encrypted);
6858 elsif ($mode == 12800)
6860 my $iterations = 100;
6864 $iterations = int ($iter);
6867 my $nt = md4_hex (encode ("UTF-16LE", $word_buf));
6869 my $pbkdf2 = Crypt::PBKDF2->new
6871 hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6872 iterations => $iterations,
6876 my $salt_buf_bin = pack ("H*", $salt_buf);
6878 my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, uc (encode ("UTF-16LE", $nt)));
6880 $tmp_hash = sprintf ("v1;PPH1_MD4,%s,%d,%s", $salt_buf, $iterations, unpack ("H*", $hash));
6882 elsif ($mode == 12900)
6884 my $iterations = 4096;
6888 $iterations = int ($iter);
6891 my $salt2 = $salt_buf . $salt_buf;
6893 if (defined $additional_param)
6895 $salt2 = $additional_param;
6898 my $pbkdf2 = Crypt::PBKDF2->new
6900 hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6901 iterations => $iterations,
6905 my $salt_buf_bin = pack ("H*", $salt_buf);
6907 my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6909 my $salt2_bin = pack ("H*", $salt2);
6911 my $hash_hmac = hmac_hex ($salt2_bin, $hash, \&sha256, 64);
6913 $tmp_hash = sprintf ("%s%s%s", $salt2, $hash_hmac, $salt_buf);
6915 elsif ($mode == 13000)
6917 my $iterations = 15;
6921 $iterations = int ($iter);
6926 if (defined $additional_param)
6928 $iv = $additional_param;
6931 my $pbkdf2 = Crypt::PBKDF2->new
6933 hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6934 iterations => (1 << $iterations) + 32,
6938 my $salt_buf_bin = pack ("H*", $salt_buf);
6940 my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6942 my $hash_final = substr ($hash, 0, 8)
6943 ^ substr ($hash, 8, 8)
6944 ^ substr ($hash, 16, 8)
6945 ^ substr ($hash, 24, 8);
6947 $tmp_hash = sprintf ('$rar5$16$%s$%d$%s$8$%s', $salt_buf, $iterations, $iv, unpack ("H*", $hash_final));
6949 elsif ($mode == 13100)
6951 my @salt_arr = split ('\$', $salt_buf);
6953 my $user = $salt_arr[0];
6955 my $realm = $salt_arr[1];
6957 my $spn = $salt_arr[2];
6959 my $nonce = $salt_arr[3];
6961 my $cleartext_ticket = '6381b03081ada00703050050a00000a11b3019a003020117a1'.
6962 '12041058e0d77776e8b8e03991f2966939222aa2171b154d594b5242544553542e434f4e5'.
6963 '44f534f2e434f4da3133011a003020102a10a30081b067472616e6365a40b3009a0030201'.
6964 '01a1020400a511180f32303136303231353134343735305aa611180f32303136303231353'.
6965 '134343735305aa711180f32303136303231363030343735305aa811180f32303136303232'.
6968 $cleartext_ticket = $nonce . $cleartext_ticket;
6970 my $k = md4 (encode ("UTF-16LE", $word_buf));
6972 my $k1 = hmac_md5 ("\x02\x00\x00\x00", $k);
6974 my $checksum = hmac_md5 (pack ("H*", $cleartext_ticket), $k1);
6976 my $k3 = hmac_md5 ($checksum, $k1);
6978 my $cipher = Crypt::RC4->new ($k3);
6980 my $edata2 = $cipher->RC4 (pack ("H*", $cleartext_ticket));
6982 $tmp_hash = sprintf ('$krb5tgs$23$*%s$%s$%s*$%s$%s', $user, $realm, $spn, unpack ("H*", $checksum), unpack ("H*", $edata2));
6984 elsif ($mode == 13200)
6986 my @salt_arr = split ('\*', $salt_buf);
6988 my $iteration = $salt_arr[0];
6990 my $mysalt = $salt_arr[1];
6992 $mysalt = pack ("H*", $mysalt);
6994 my $DEK = randbytes (16);
6996 my $iv = "a6a6a6a6a6a6a6a6";
6998 my $KEK = sha1($word_buf);
7000 $KEK = substr ($KEK ^ $mysalt, 0, 16);
7002 my $aes = Crypt::Mode::ECB->new ('AES');
7004 my @R = ('', substr(pack ("H*",$DEK),0,8), substr(pack ("H*",$DEK),8,16));
7008 my $A = pack ("H*", $iv);
7010 for (my $j = 0; $j < $iteration; $j++)
7012 $B = $aes->encrypt ($A . $R[1], $KEK);
7014 $A = substr ($B, 0, 8) ^ pack ("q", (2 * $j + 1));
7016 $R[1] = substr ($B, 8, 16);
7018 $B = $aes->encrypt ($A . $R[2], $KEK);
7020 $A = substr ($B, 0, 8) ^ pack ("q", (2 * $j + 2));
7022 $R[2] = substr ($B, 8, 16);
7025 my $wrapped_key = unpack ("H*", $A . substr ($R[1], 0 ,8) . substr ($R[2], 0 ,8));
7027 $mysalt = unpack ("H*", $mysalt);
7029 $tmp_hash = sprintf ('$axcrypt$*1*%s*%s*%s', $iteration, $mysalt, $wrapped_key);
7031 elsif ($mode == 13300)
7033 $hash_buf = sha1_hex ($word_buf);
7035 $tmp_hash = sprintf ('$axcrypt_sha1$%s', substr ($hash_buf, 0, 32));
7037 elsif ($mode == 13400)
7039 my @salt_arr = split ('\*', $salt_buf);
7041 my $version = $salt_arr[0];
7043 my $iteration = $salt_arr[1];
7045 my $algorithm = $salt_arr[2];
7047 my $final_random_seed = $salt_arr[3];
7049 my $transf_random_seed = $salt_arr[4];
7051 my $enc_iv = $salt_arr[5];
7055 # specific to version 1
7060 # specific to version 2
7063 # specific to keyfile handling
7064 my $inline_keyfile_flag;
7066 my $keyfile_content;
7067 my $keyfile_attributes = "";
7069 $final_random_seed = pack ("H*", $final_random_seed);
7071 $transf_random_seed = pack ("H*", $transf_random_seed);
7073 $enc_iv = pack ("H*", $enc_iv);
7075 my $intermediate_hash = sha256 ($word_buf);
7079 $contents_hash = $salt_arr[6];
7080 $contents_hash = pack ("H*", $contents_hash);
7082 $inline_flag = $salt_arr[7];
7084 $contents_len = $salt_arr[8];
7086 $contents = $salt_arr[9];
7087 $contents = pack ("H*", $contents);
7090 if (scalar @salt_arr == 13)
7092 $inline_keyfile_flag = $salt_arr[10];
7094 $keyfile_len = $salt_arr[11];
7096 $keyfile_content = $salt_arr[12];
7098 $keyfile_attributes = $keyfile_attributes
7099 . "*" . $inline_keyfile_flag
7100 . "*" . $keyfile_len
7101 . "*" . $keyfile_content;
7103 $intermediate_hash = $intermediate_hash . pack ("H*", $keyfile_content);
7104 $intermediate_hash = sha256 ($intermediate_hash);
7107 elsif ($version == 2)
7110 if (scalar @salt_arr == 11)
7112 $inline_keyfile_flag = $salt_arr[8];
7114 $keyfile_len = $salt_arr[9];
7116 $keyfile_content = $salt_arr[10];
7118 $intermediate_hash = $intermediate_hash . pack ("H*", $keyfile_content);
7120 $keyfile_attributes = $keyfile_attributes
7121 . "*" . $inline_keyfile_flag
7122 . "*" . $keyfile_len
7123 . "*" . $keyfile_content;
7126 $intermediate_hash = sha256 ($intermediate_hash);
7129 my $aes = Crypt::Mode::ECB->new ('AES', 1);
7131 for (my $j = 0; $j < $iteration; $j++)
7133 $intermediate_hash = $aes->encrypt ($intermediate_hash, $transf_random_seed);
7135 $intermediate_hash = substr ($intermediate_hash, 0, 32);
7138 $intermediate_hash = sha256 ($intermediate_hash);
7140 my $final_key = sha256 ($final_random_seed . $intermediate_hash);
7142 my $final_algorithm;
7144 if ($version == 1 && $algorithm == 1)
7146 $final_algorithm = "Crypt::Twofish";
7150 $final_algorithm = "Crypt::Rijndael";
7153 my $cipher = Crypt::CBC->new ({
7155 cipher => $final_algorithm,
7164 $contents_hash = sha256 ($contents);
7166 $contents = $cipher->encrypt($contents);
7168 $tmp_hash = sprintf ('$keepass$*%d*%d*%d*%s*%s*%s*%s*%d*%d*%s%s',
7172 unpack ("H*", $final_random_seed),
7173 unpack ("H*", $transf_random_seed),
7174 unpack ("H*", $enc_iv),
7175 unpack ("H*", $contents_hash),
7178 unpack ("H*", $contents),
7179 $keyfile_attributes);
7183 $expected_bytes = $salt_arr[6];
7185 $contents_hash = $salt_arr[7];
7186 $contents_hash = pack ("H*", $contents_hash);
7188 $expected_bytes = $cipher->decrypt($contents_hash);
7190 $tmp_hash = sprintf ('$keepass$*%d*%d*%d*%s*%s*%s*%s*%s%s',
7194 unpack ("H*", $final_random_seed),
7195 unpack ("H*", $transf_random_seed),
7196 unpack ("H*", $enc_iv),
7197 unpack ("H*", $expected_bytes),
7198 unpack ("H*", $contents_hash),
7199 $keyfile_attributes);
7202 elsif ($mode == 13500)
7204 $hash_buf = sha1_hex (pack ("H*", $salt_buf) . encode ("UTF-16LE", $word_buf));
7206 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
7208 elsif ($mode == 13600)
7210 my $iterations = 1000;
7214 if (defined $additional_param)
7216 $type = $additional_param;
7219 my $mode = 1 + int rand (3);
7221 if (defined $additional_param2)
7223 $mode = $additional_param2;
7228 if (defined $additional_param3)
7230 $magic = $additional_param3;
7233 if (defined $additional_param4)
7235 $salt_buf = $additional_param4;
7238 $salt_buf = substr ($salt_buf, 0, 8 + ($mode * 8));
7240 my $compress_length = 0;
7242 if (defined $additional_param5)
7244 $compress_length = $additional_param5;
7249 if (defined $additional_param6)
7251 $data = $additional_param6;
7254 my $key_len = (8 * ($mode & 3) + 8) * 2;
7256 my $out_len = $key_len + 2;
7258 my $salt_buf_bin = pack ("H*", $salt_buf);
7260 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
7262 my $pbkdf2 = Crypt::PBKDF2->new
7265 iterations => $iterations,
7266 output_len => $out_len
7269 my $key = $pbkdf2->PBKDF2_hex ($salt_buf_bin, $word_buf);
7271 my $verify_bytes = substr ($key, -4); $verify_bytes =~ s/^0+//; #lol
7273 $key = substr ($key, $key_len, $key_len);
7275 my $key_bin = pack ("H*", $key);
7277 my $auth = hmac_hex ($data, $key_bin, \&sha1, 64);
7279 $tmp_hash = sprintf ('$zip2$*%u*%u*%u*%s*%s*%u*%s*%s*$/zip2$', $type, $mode, $magic, $salt_buf, $verify_bytes, $compress_length, $data, substr ($auth, 0, 20));
7281 elsif ($mode == 13800)
7283 my $word_buf_unicode = encode ("UTF-16LE", $word_buf);
7285 my $salt_buf_bin = pack ("H*", $salt_buf);
7287 $hash_buf = sha256_hex ($word_buf_unicode . $salt_buf_bin);
7289 $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
7299 my $word_len = shift;
7301 my $salt_len = shift;
7305 $max = 15 if ($mode == 2410);
7307 if ($is_unicode{$mode})
7309 if (! $allow_long_salt{$mode})
7311 $word_len = min ($word_len, int ($max / 2) - $salt_len);
7315 $word_len = min ($word_len, int ($max / 2));
7318 elsif ($less_fifteen{$mode})
7320 $word_len = min ($word_len, 15);
7324 $salt_len = min ($salt_len, 15 - $word_len);
7329 if (! $allow_long_salt{$mode})
7331 $word_len = min ($word_len, $max - $salt_len);
7350 for (my $i = 0; $i < $salt_len; $i++)
7352 my $c = get_random_chr (0x30, 0x39);
7354 push (@salt_arr, $c);
7357 $salt_buf = join ("", @salt_arr);
7359 $salt_buf = get_random_md5chap_salt ($salt_buf);
7361 elsif ($mode == 5300 || $mode == 5400)
7363 $salt_buf = get_random_ike_salt ();
7365 elsif ($mode == 5500)
7367 $salt_buf = get_random_netntlmv1_salt ($salt_len, $salt_len);
7369 elsif ($mode == 5600)
7371 $salt_buf = get_random_netntlmv2_salt ($salt_len, $salt_len);
7373 elsif ($mode == 6600)
7375 $salt_buf = get_random_agilekeychain_salt ();
7377 elsif ($mode == 8200)
7379 $salt_buf = get_random_cloudkeychain_salt ();
7381 elsif ($mode == 8300)
7383 $salt_buf = get_random_dnssec_salt ();
7385 elsif ($mode == 13100)
7387 $salt_buf = get_random_kerberos5_tgs_salt ();
7389 elsif ($mode == 13200)
7391 $salt_buf = get_random_axcrypt_salt ();
7393 elsif ($mode == 13400)
7395 $salt_buf = get_random_keepass_salt ();
7397 elsif ($mode == 13500)
7399 $salt_buf = get_pstoken_salt ();
7405 for (my $i = 0; $i < $salt_len; $i++)
7407 my $c = get_random_chr (0x30, 0x39);
7409 push (@salt_arr, $c);
7412 $salt_buf = join ("", @salt_arr);
7416 $salt_buf = get_random_kerberos5_salt ($salt_buf);
7426 for (my $i = 0; $i < $word_len; $i++)
7428 my $c = get_random_chr (0x30, 0x39);
7430 push (@word_arr, $c);
7433 my $word_buf = join ("", @word_arr);
7439 my $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
7452 print sprintf ("echo -n %-20s | %s \${OPTS} %s %4d '%s'\n", $word_buf, @cmd);
7464 sub get_random_string
7470 for (my $i = 0; $i < $len; $i++)
7472 my $c = get_random_chr (0x30, 0x39);
7477 my $buf = join ("", @arr);
7487 return int ((rand ($max - $min)) + $min);
7492 return chr get_random_num (@_);
7501 for (my $i = 0; $i < length ($str); $i += 4)
7503 my $num = domino_base64_decode (substr ($str, $i, 4), 4);
7505 $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
7512 $salt = substr ($decoded, 0, 5);
7514 my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
7518 $byte10 = 256 + $byte10;
7521 substr ($salt, 3, 1) = chr ($byte10);
7523 $digest = substr ($decoded, 5, 9);
7524 $char = substr ($str, 18, 1);
7526 return ($digest, $salt, $char);
7529 sub domino_85x_decode
7535 for (my $i = 0; $i < length ($str); $i += 4)
7537 my $num = domino_base64_decode (substr ($str, $i, 4), 4);
7539 $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
7544 my $iterations = -1;
7547 $salt = substr ($decoded, 0, 16); # longer than -m 8700 (5 vs 16 <- new)
7549 my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
7553 $byte10 = 256 + $byte10;
7556 substr ($salt, 3, 1) = chr ($byte10);
7558 $iterations = substr ($decoded, 16, 10);
7560 if ($iterations =~ /^?d*$/)
7564 $iterations = $iterations + 0; # hack: make sure it is an int now (atoi ())
7565 $chars = substr ($decoded, 26, 2); # in my example it is "02"
7566 $digest = substr ($decoded, 28, 8); # only of length of 8 vs 20 SHA1 bytes
7569 return ($digest, $salt, $iterations, $chars);
7572 sub domino_base64_decode
7577 my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
7585 my $idx = (index ($itoa64, substr ($v, $n - $i, 1))) & 0x3f;
7587 $ret += ($idx << (6 * ($i - 1)));
7600 my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7604 $byte10 = $byte10 - 256;
7607 substr ($final, 3, 1) = chr ($byte10);
7611 $passwd .= domino_base64_encode ((int (ord (substr ($final, 0, 1))) << 16) | (int (ord (substr ($final, 1, 1))) << 8) | (int (ord (substr ($final, 2, 1)))), 4);
7612 $passwd .= domino_base64_encode ((int (ord (substr ($final, 3, 1))) << 16) | (int (ord (substr ($final, 4, 1))) << 8) | (int (ord (substr ($final, 5, 1)))), 4);
7613 $passwd .= domino_base64_encode ((int (ord (substr ($final, 6, 1))) << 16) | (int (ord (substr ($final, 7, 1))) << 8) | (int (ord (substr ($final, 8, 1)))), 4);
7614 $passwd .= domino_base64_encode ((int (ord (substr ($final, 9, 1))) << 16) | (int (ord (substr ($final, 10, 1))) << 8) | (int (ord (substr ($final, 11, 1)))), 4);
7615 $passwd .= domino_base64_encode ((int (ord (substr ($final, 12, 1))) << 16) | (int (ord (substr ($final, 13, 1))) << 8) | (int (ord (substr ($final, 14, 1)))), 4);
7617 if (defined ($char))
7619 substr ($passwd, 18, 1) = $char;
7621 substr ($passwd, 19, 1) = "";
7626 sub domino_85x_encode
7631 my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7635 $byte10 = $byte10 - 256;
7638 substr ($final, 3, 1) = chr ($byte10);
7642 $passwd .= domino_base64_encode ((int (ord (substr ($final, 0, 1))) << 16) | (int (ord (substr ($final, 1, 1))) << 8) | (int (ord (substr ($final, 2, 1)))), 4);
7643 $passwd .= domino_base64_encode ((int (ord (substr ($final, 3, 1))) << 16) | (int (ord (substr ($final, 4, 1))) << 8) | (int (ord (substr ($final, 5, 1)))), 4);
7644 $passwd .= domino_base64_encode ((int (ord (substr ($final, 6, 1))) << 16) | (int (ord (substr ($final, 7, 1))) << 8) | (int (ord (substr ($final, 8, 1)))), 4);
7645 $passwd .= domino_base64_encode ((int (ord (substr ($final, 9, 1))) << 16) | (int (ord (substr ($final, 10, 1))) << 8) | (int (ord (substr ($final, 11, 1)))), 4);
7646 $passwd .= domino_base64_encode ((int (ord (substr ($final, 12, 1))) << 16) | (int (ord (substr ($final, 13, 1))) << 8) | (int (ord (substr ($final, 14, 1)))), 4);
7647 $passwd .= domino_base64_encode ((int (ord (substr ($final, 15, 1))) << 16) | (int (ord (substr ($final, 16, 1))) << 8) | (int (ord (substr ($final, 17, 1)))), 4);
7648 $passwd .= domino_base64_encode ((int (ord (substr ($final, 18, 1))) << 16) | (int (ord (substr ($final, 19, 1))) << 8) | (int (ord (substr ($final, 20, 1)))), 4);
7649 $passwd .= domino_base64_encode ((int (ord (substr ($final, 21, 1))) << 16) | (int (ord (substr ($final, 22, 1))) << 8) | (int (ord (substr ($final, 23, 1)))), 4);
7650 $passwd .= domino_base64_encode ((int (ord (substr ($final, 24, 1))) << 16) | (int (ord (substr ($final, 25, 1))) << 8) | (int (ord (substr ($final, 26, 1)))), 4);
7651 $passwd .= domino_base64_encode ((int (ord (substr ($final, 27, 1))) << 16) | (int (ord (substr ($final, 28, 1))) << 8) | (int (ord (substr ($final, 29, 1)))), 4);
7652 $passwd .= domino_base64_encode ((int (ord (substr ($final, 30, 1))) << 16) | (int (ord (substr ($final, 31, 1))) << 8) | (int (ord (substr ($final, 32, 1)))), 4);
7653 $passwd .= domino_base64_encode ((int (ord (substr ($final, 33, 1))) << 16) | (int (ord (substr ($final, 34, 1))) << 8) | (int (ord (substr ($final, 35, 1)))), 4);
7655 if (defined ($char))
7657 substr ($passwd, 18, 1) = $char;
7663 sub domino_base64_encode
7668 my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
7672 while (($n - 1) >= 0)
7676 $ret = substr ($itoa64, $v & 0x3f, 1) . $ret;
7686 my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7691 my $v = unpack "V", substr($md5, $i*4, 4);
7693 $s64 .= substr($itoa64, $v & 0x3f, 1);
7702 my ($username, $password) = @_;
7704 $username = substr ($username . " " x 8, 0, 8);
7705 $password = substr ($password . " " x 8, 0, 8);
7707 my $username_ebc = ascii2ebcdic ($username);
7708 my $password_ebc = ascii2ebcdic ($password);
7710 my @pw = split ("", $password_ebc);
7712 for (my $i = 0; $i < 8; $i++)
7714 $pw[$i] = unpack ("C", $pw[$i]);
7717 $pw[$i] = pack ("C", $pw[$i] & 0xff);
7720 my $key = join ("", @pw);
7722 my $cipher = new Crypt::DES $key;
7724 my $ciphertext = $cipher->encrypt ($username_ebc);
7726 my $ct = unpack ("H16", $ciphertext);
7733 my ($username, $password) = @_;
7735 my $userpass = pack('n*', unpack('C*', uc($username.$password)));
7736 $userpass .= pack('C', 0) while (length($userpass) % 8);
7738 my $key = pack('H*', "0123456789ABCDEF");
7739 my $iv = pack('H*', "0000000000000000");
7741 my $c = new Crypt::CBC(
7748 my $key2 = substr($c->encrypt($userpass), length($userpass)-8, 8);
7750 my $c2 = new Crypt::CBC(
7757 my $hash = substr($c2->encrypt($userpass), length($userpass)-8, 8);
7759 return uc(unpack('H*', $hash));
7764 my $word_buf = shift;
7766 my $salt_buf = shift;
7768 my $w = sprintf ("%d%s%s", 0, $word_buf, $salt_buf);
7770 my $digest = sha1 ($w);
7772 for (my $i = 1; $i < 1024; $i++)
7774 $w = $digest . sprintf ("%d%s%s", $i, $word_buf, $salt_buf);
7776 $digest = sha1 ($w);
7779 my ($A, $B, $C, $D, $E) = unpack ("N5", $digest);
7781 return sprintf ("%08x%08x%08x%08x%08x", $A, $B, $C, $D, $E);
7789 my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7793 while (($n - 1) >= 0)
7797 $ret .= substr ($itoa64, $v & 0x3f, 1);
7813 my $hash = ""; # hash to be returned by this function
7815 my $final = md5 ($pass . $salt . $pass);
7817 $salt = substr ($salt, 0, 8);
7819 my $tmp = $pass . $magic . $salt;
7821 my $pass_len = length ($pass);
7825 for ($i = $pass_len; $i > 0; $i -= 16)
7834 $tmp .= substr ($final, 0, $len);
7847 $tmp .= substr ($pass, 0, 1);
7853 $final = md5 ($tmp);
7855 for ($i = 0; $i < $iter; $i++)
7887 $final = md5 ($tmp);
7891 # now format the output sting ("hash")
7895 $hash = to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 6, 1)) << 8) | (ord (substr ($final, 12, 1))), 4);
7896 $hash .= to64 ((ord (substr ($final, 1, 1)) << 16) | (ord (substr ($final, 7, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
7897 $hash .= to64 ((ord (substr ($final, 2, 1)) << 16) | (ord (substr ($final, 8, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
7898 $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 9, 1)) << 8) | (ord (substr ($final, 15, 1))), 4);
7899 $hash .= to64 ((ord (substr ($final, 4, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 5, 1))), 4);
7900 $hash .= to64 (ord (substr ($final, 11, 1)), 2);
7902 if ($iter == 1000) # default
7904 $hash_buf = sprintf ("%s%s\$%s", $magic , $salt , $hash);
7908 $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7920 my $hash = ""; # hash to be returned by this function
7922 my $final = sha512 ($pass . $salt . $pass);
7924 $salt = substr ($salt, 0, 16);
7926 my $tmp = $pass . $salt;
7928 my $pass_len = length ($pass);
7929 my $salt_len = length ($salt);
7933 for ($i = $pass_len; $i > 0; $i -= 16)
7942 $tmp .= substr ($final, 0, $len);
7961 $final = sha512 ($tmp);
7967 for ($i = 0; $i < $pass_len; $i++)
7972 $p_bytes = sha512 ($p_bytes);
7973 $p_bytes = substr ($p_bytes, 0, $pass_len);
7977 my $final_first_byte = ord (substr ($final, 0, 1));
7981 for ($i = 0; $i < (16 + $final_first_byte); $i++)
7986 $s_bytes = sha512 ($s_bytes);
7987 $s_bytes = substr ($s_bytes, 0, $salt_len);
7989 for ($i = 0; $i < $iter; $i++)
8021 $final = sha512 ($tmp);
8025 # now format the output string ("hash")
8029 $hash .= to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 21, 1)) << 8) | (ord (substr ($final, 42, 1))), 4);
8030 $hash .= to64 ((ord (substr ($final, 22, 1)) << 16) | (ord (substr ($final, 43, 1)) << 8) | (ord (substr ($final, 1, 1))), 4);
8031 $hash .= to64 ((ord (substr ($final, 44, 1)) << 16) | (ord (substr ($final, 2, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
8032 $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 24, 1)) << 8) | (ord (substr ($final, 45, 1))), 4);
8033 $hash .= to64 ((ord (substr ($final, 25, 1)) << 16) | (ord (substr ($final, 46, 1)) << 8) | (ord (substr ($final, 4, 1))), 4);
8034 $hash .= to64 ((ord (substr ($final, 47, 1)) << 16) | (ord (substr ($final, 5, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
8035 $hash .= to64 ((ord (substr ($final, 6, 1)) << 16) | (ord (substr ($final, 27, 1)) << 8) | (ord (substr ($final, 48, 1))), 4);
8036 $hash .= to64 ((ord (substr ($final, 28, 1)) << 16) | (ord (substr ($final, 49, 1)) << 8) | (ord (substr ($final, 7, 1))), 4);
8037 $hash .= to64 ((ord (substr ($final, 50, 1)) << 16) | (ord (substr ($final, 8, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
8038 $hash .= to64 ((ord (substr ($final, 9, 1)) << 16) | (ord (substr ($final, 30, 1)) << 8) | (ord (substr ($final, 51, 1))), 4);
8039 $hash .= to64 ((ord (substr ($final, 31, 1)) << 16) | (ord (substr ($final, 52, 1)) << 8) | (ord (substr ($final, 10, 1))), 4);
8040 $hash .= to64 ((ord (substr ($final, 53, 1)) << 16) | (ord (substr ($final, 11, 1)) << 8) | (ord (substr ($final, 32, 1))), 4);
8041 $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 33, 1)) << 8) | (ord (substr ($final, 54, 1))), 4);
8042 $hash .= to64 ((ord (substr ($final, 34, 1)) << 16) | (ord (substr ($final, 55, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
8043 $hash .= to64 ((ord (substr ($final, 56, 1)) << 16) | (ord (substr ($final, 14, 1)) << 8) | (ord (substr ($final, 35, 1))), 4);
8044 $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 36, 1)) << 8) | (ord (substr ($final, 57, 1))), 4);
8045 $hash .= to64 ((ord (substr ($final, 37, 1)) << 16) | (ord (substr ($final, 58, 1)) << 8) | (ord (substr ($final, 16, 1))), 4);
8046 $hash .= to64 ((ord (substr ($final, 59, 1)) << 16) | (ord (substr ($final, 17, 1)) << 8) | (ord (substr ($final, 38, 1))), 4);
8047 $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 39, 1)) << 8) | (ord (substr ($final, 60, 1))), 4);
8048 $hash .= to64 ((ord (substr ($final, 40, 1)) << 16) | (ord (substr ($final, 61, 1)) << 8) | (ord (substr ($final, 19, 1))), 4);
8049 $hash .= to64 ((ord (substr ($final, 62, 1)) << 16) | (ord (substr ($final, 20, 1)) << 8) | (ord (substr ($final, 41, 1))), 4);
8050 $hash .= to64 (ord (substr ($final, 63, 1)), 2);
8054 if ($iter == 5000) # default
8056 $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
8060 $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
8072 my $hash = ""; # hash to be returned by this function
8074 my $final = sha256 ($pass . $salt . $pass);
8076 $salt = substr ($salt, 0, 16);
8078 my $tmp = $pass . $salt;
8080 my $pass_len = length ($pass);
8081 my $salt_len = length ($salt);
8085 for ($i = $pass_len; $i > 0; $i -= 16)
8094 $tmp .= substr ($final, 0, $len);
8113 $final = sha256 ($tmp);
8119 for ($i = 0; $i < $pass_len; $i++)
8124 $p_bytes = sha256 ($p_bytes);
8125 $p_bytes = substr ($p_bytes, 0, $pass_len);
8129 my $final_first_byte = ord (substr ($final, 0, 1));
8133 for ($i = 0; $i < (16 + $final_first_byte); $i++)
8138 $s_bytes = sha256 ($s_bytes);
8139 $s_bytes = substr ($s_bytes, 0, $salt_len);
8141 for ($i = 0; $i < $iter; $i++)
8173 $final = sha256 ($tmp);
8177 # now format the output string ("hash")
8181 $hash .= to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 20, 1))), 4);
8182 $hash .= to64 ((ord (substr ($final, 21, 1)) << 16) | (ord (substr ($final, 1, 1)) << 8) | (ord (substr ($final, 11, 1))), 4);
8183 $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 22, 1)) << 8) | (ord (substr ($final, 2, 1))), 4);
8184 $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 13, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
8185 $hash .= to64 ((ord (substr ($final, 24, 1)) << 16) | (ord (substr ($final, 4, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
8186 $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 25, 1)) << 8) | (ord (substr ($final, 5, 1))), 4);
8187 $hash .= to64 ((ord (substr ($final, 6, 1)) << 16) | (ord (substr ($final, 16, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
8188 $hash .= to64 ((ord (substr ($final, 27, 1)) << 16) | (ord (substr ($final, 7, 1)) << 8) | (ord (substr ($final, 17, 1))), 4);
8189 $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 28, 1)) << 8) | (ord (substr ($final, 8, 1))), 4);
8190 $hash .= to64 ((ord (substr ($final, 9, 1)) << 16) | (ord (substr ($final, 19, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
8191 $hash .= to64 ((ord (substr ($final, 31, 1)) << 8) | (ord (substr ($final, 30, 1))), 3);
8195 if ($iter == 5000) # default
8197 $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
8201 $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
8207 sub aix_ssha256_pbkdf2
8209 my $word_buf = shift;
8210 my $salt_buf = shift;
8211 my $iterations = shift;
8213 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256);
8215 my $pbkdf2 = Crypt::PBKDF2->new (
8217 iterations => $iterations,
8221 my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
8225 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 0, 1))) << 16) | (int (ord (substr ($hash_buf, 1, 1))) << 8) | (int (ord (substr ($hash_buf, 2, 1)))), 4);
8226 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 3, 1))) << 16) | (int (ord (substr ($hash_buf, 4, 1))) << 8) | (int (ord (substr ($hash_buf, 5, 1)))), 4);
8227 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 6, 1))) << 16) | (int (ord (substr ($hash_buf, 7, 1))) << 8) | (int (ord (substr ($hash_buf, 8, 1)))), 4);
8228 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 9, 1))) << 16) | (int (ord (substr ($hash_buf, 10, 1))) << 8) | (int (ord (substr ($hash_buf, 11, 1)))), 4);
8229 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 12, 1))) << 16) | (int (ord (substr ($hash_buf, 13, 1))) << 8) | (int (ord (substr ($hash_buf, 14, 1)))), 4);
8230 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 15, 1))) << 16) | (int (ord (substr ($hash_buf, 16, 1))) << 8) | (int (ord (substr ($hash_buf, 17, 1)))), 4);
8231 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8) | (int (ord (substr ($hash_buf, 20, 1)))), 4);
8232 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 21, 1))) << 16) | (int (ord (substr ($hash_buf, 22, 1))) << 8) | (int (ord (substr ($hash_buf, 23, 1)))), 4);
8233 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 24, 1))) << 16) | (int (ord (substr ($hash_buf, 25, 1))) << 8) | (int (ord (substr ($hash_buf, 26, 1)))), 4);
8234 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 27, 1))) << 16) | (int (ord (substr ($hash_buf, 28, 1))) << 8) | (int (ord (substr ($hash_buf, 29, 1)))), 4);
8235 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 30, 1))) << 16) | (int (ord (substr ($hash_buf, 31, 1))) << 8) , 3);
8240 sub aix_ssha512_pbkdf2
8242 my $word_buf = shift;
8243 my $salt_buf = shift;
8244 my $iterations = shift;
8246 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
8248 my $pbkdf2 = Crypt::PBKDF2->new (
8250 iterations => $iterations,
8253 my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
8257 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 0, 1))) << 16) | (int (ord (substr ($hash_buf, 1, 1))) << 8) | (int (ord (substr ($hash_buf, 2, 1)))), 4);
8258 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 3, 1))) << 16) | (int (ord (substr ($hash_buf, 4, 1))) << 8) | (int (ord (substr ($hash_buf, 5, 1)))), 4);
8259 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 6, 1))) << 16) | (int (ord (substr ($hash_buf, 7, 1))) << 8) | (int (ord (substr ($hash_buf, 8, 1)))), 4);
8260 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 9, 1))) << 16) | (int (ord (substr ($hash_buf, 10, 1))) << 8) | (int (ord (substr ($hash_buf, 11, 1)))), 4);
8261 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 12, 1))) << 16) | (int (ord (substr ($hash_buf, 13, 1))) << 8) | (int (ord (substr ($hash_buf, 14, 1)))), 4);
8262 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 15, 1))) << 16) | (int (ord (substr ($hash_buf, 16, 1))) << 8) | (int (ord (substr ($hash_buf, 17, 1)))), 4);
8263 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8) | (int (ord (substr ($hash_buf, 20, 1)))), 4);
8264 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 21, 1))) << 16) | (int (ord (substr ($hash_buf, 22, 1))) << 8) | (int (ord (substr ($hash_buf, 23, 1)))), 4);
8265 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 24, 1))) << 16) | (int (ord (substr ($hash_buf, 25, 1))) << 8) | (int (ord (substr ($hash_buf, 26, 1)))), 4);
8266 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 27, 1))) << 16) | (int (ord (substr ($hash_buf, 28, 1))) << 8) | (int (ord (substr ($hash_buf, 29, 1)))), 4);
8267 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 30, 1))) << 16) | (int (ord (substr ($hash_buf, 31, 1))) << 8) | (int (ord (substr ($hash_buf, 32, 1)))), 4);
8268 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 33, 1))) << 16) | (int (ord (substr ($hash_buf, 34, 1))) << 8) | (int (ord (substr ($hash_buf, 35, 1)))), 4);
8269 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 36, 1))) << 16) | (int (ord (substr ($hash_buf, 37, 1))) << 8) | (int (ord (substr ($hash_buf, 38, 1)))), 4);
8270 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 39, 1))) << 16) | (int (ord (substr ($hash_buf, 40, 1))) << 8) | (int (ord (substr ($hash_buf, 41, 1)))), 4);
8271 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 42, 1))) << 16) | (int (ord (substr ($hash_buf, 43, 1))) << 8) | (int (ord (substr ($hash_buf, 44, 1)))), 4);
8272 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 45, 1))) << 16) | (int (ord (substr ($hash_buf, 46, 1))) << 8) | (int (ord (substr ($hash_buf, 47, 1)))), 4);
8273 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 48, 1))) << 16) | (int (ord (substr ($hash_buf, 49, 1))) << 8) | (int (ord (substr ($hash_buf, 50, 1)))), 4);
8274 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 51, 1))) << 16) | (int (ord (substr ($hash_buf, 52, 1))) << 8) | (int (ord (substr ($hash_buf, 53, 1)))), 4);
8275 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 54, 1))) << 16) | (int (ord (substr ($hash_buf, 55, 1))) << 8) | (int (ord (substr ($hash_buf, 56, 1)))), 4);
8276 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 57, 1))) << 16) | (int (ord (substr ($hash_buf, 58, 1))) << 8) | (int (ord (substr ($hash_buf, 59, 1)))), 4);
8277 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 60, 1))) << 16) | (int (ord (substr ($hash_buf, 61, 1))) << 8) | (int (ord (substr ($hash_buf, 62, 1)))), 4);
8278 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 63, 1))) << 16) , 2);
8283 sub aix_ssha1_pbkdf2
8285 my $word_buf = shift;
8286 my $salt_buf = shift;
8287 my $iterations = shift;
8289 my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
8291 my $pbkdf2 = Crypt::PBKDF2->new (
8293 iterations => $iterations,
8296 my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
8300 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 0, 1))) << 16) | (int (ord (substr ($hash_buf, 1, 1))) << 8) | (int (ord (substr ($hash_buf, 2, 1)))), 4);
8301 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 3, 1))) << 16) | (int (ord (substr ($hash_buf, 4, 1))) << 8) | (int (ord (substr ($hash_buf, 5, 1)))), 4);
8302 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 6, 1))) << 16) | (int (ord (substr ($hash_buf, 7, 1))) << 8) | (int (ord (substr ($hash_buf, 8, 1)))), 4);
8303 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 9, 1))) << 16) | (int (ord (substr ($hash_buf, 10, 1))) << 8) | (int (ord (substr ($hash_buf, 11, 1)))), 4);
8304 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 12, 1))) << 16) | (int (ord (substr ($hash_buf, 13, 1))) << 8) | (int (ord (substr ($hash_buf, 14, 1)))), 4);
8305 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 15, 1))) << 16) | (int (ord (substr ($hash_buf, 16, 1))) << 8) | (int (ord (substr ($hash_buf, 17, 1)))), 4);
8306 $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8) , 3);
8315 my @data = split "", $data_s;
8318 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8319 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8320 "\x3f\x40\x41\x50\x43\x44\x45\x4b\x47\x48\x4d\x4e\x54\x51\x53\x46" .
8321 "\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x56\x55\x5c\x49\x5d\x4a" .
8322 "\x42\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
8323 "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x58\x5b\x59\xff\x52" .
8324 "\x4c\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
8325 "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x57\x5e\x5a\x4f\xff" .
8326 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8327 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8328 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8329 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8330 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8331 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8332 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
8333 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
8335 my @transTable = unpack ("C256", $transTable_s);
8339 for (my $i = 0; $i < scalar @data; $i++)
8341 $out[$i] = $transTable[int (ord ($data[$i]))];
8344 return pack ("C*", @out);
8349 my $digest_s = shift;
8354 my @w = unpack "C*", $w_s;
8355 my @s = unpack "C*", $s_s;
8358 "\x14\x77\xf3\xd4\xbb\x71\x23\xd0\x03\xff\x47\x93\x55\xaa\x66\x91" .
8359 "\xf2\x88\x6b\x99\xbf\xcb\x32\x1a\x19\xd9\xa7\x82\x22\x49\xa2\x51" .
8360 "\xe2\xb7\x33\x71\x8b\x9f\x5d\x01\x44\x70\xae\x11\xef\x28\xf0\x0d";
8362 my @bcodeTable = unpack ("C48", $bcodeTable_s);
8364 my @abcd = unpack ("C16", $digest_s);
8366 my $sum20 = ($abcd[0] & 3)
8376 for (my $i2 = 0; $i2 < $sum20; $i2++)
8381 for (my $i1 = 0, my $i2 = 0, my $i3 = 0; $i2 < $sum20; $i2++, $i2++)
8383 if ($i1 < length $w_s)
8385 if ($abcd[15 - $i1] & 1)
8387 $out[$i2] = $bcodeTable[48 - 1 - $i1];
8392 $out[$i2] = $w[$i1];
8398 if ($i3 < length $s_s)
8400 $out[$i2] = $s[$i3];
8406 $out[$i2] = $bcodeTable[$i2 - $i1 - $i3];
8409 return substr (pack ("C*", @out), 0, $sum20);
8414 my @key_56 = split (//, shift);
8420 $key .= chr(((ord($key_56[0]) << 7) | (ord($key_56[1]) >> 1)) & 255);
8421 $key .= chr(((ord($key_56[1]) << 6) | (ord($key_56[2]) >> 2)) & 255);
8422 $key .= chr(((ord($key_56[2]) << 5) | (ord($key_56[3]) >> 3)) & 255);
8423 $key .= chr(((ord($key_56[3]) << 4) | (ord($key_56[4]) >> 4)) & 255);
8424 $key .= chr(((ord($key_56[4]) << 3) | (ord($key_56[5]) >> 5)) & 255);
8425 $key .= chr(((ord($key_56[5]) << 2) | (ord($key_56[6]) >> 6)) & 255);
8426 $key .= chr(( ord($key_56[6]) << 1) & 255);
8437 for (my $i = 0; $i < $len; $i++)
8439 my $c = get_random_chr (0, 255);
8444 return join ("", @arr);
8447 sub get_random_netntlmv1_salt
8449 my $len_user = shift;
8450 my $len_domain = shift;
8456 for (my $i = 0; $i < $len_user; $i++)
8458 $type = get_random_num (1, 3);
8462 $char = get_random_chr (0x30, 0x39);
8466 $char = get_random_chr (0x41, 0x5A);
8470 $char = get_random_chr (0x61, 0x7A);
8478 for (my $i = 0; $i < $len_domain; $i++)
8480 $type = get_random_num (1, 3);
8484 $char = get_random_chr (0x30, 0x39);
8488 $char = get_random_chr (0x41, 0x5A);
8492 $char = get_random_chr (0x61, 0x7A);
8498 my $c_challenge = randbytes (8);
8499 my $s_challenge = randbytes (8);
8501 my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $c_challenge) . unpack ("H*", $s_challenge);
8506 sub get_random_netntlmv2_salt
8508 my $len_user = shift;
8509 my $len_domain = shift;
8515 if ($len_user + $len_domain > 27)
8517 if ($len_user > $len_domain)
8519 $len_user = 27 - $len_domain;
8523 $len_domain = 27 - $len_user;
8527 for (my $i = 0; $i < $len_user; $i++)
8529 $type = get_random_num (1, 3);
8533 $char = get_random_chr (0x30, 0x39);
8537 $char = get_random_chr (0x41, 0x5A);
8541 $char = get_random_chr (0x61, 0x7A);
8549 for (my $i = 0; $i < $len_domain; $i++)
8551 $type = get_random_num (1, 3);
8555 $char = get_random_chr (0x30, 0x39);
8559 $char = get_random_chr (0x41, 0x5A);
8563 $char = get_random_chr (0x61, 0x7A);
8569 my $c_challenge = randbytes (8);
8570 my $s_challenge = randbytes (8);
8572 my $temp = "\x01\x01" .
8577 randbytes (20 * rand () + 1) .
8580 my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $s_challenge) . unpack ("H*", $temp);
8585 sub get_random_ike_salt
8589 for (my $i = 0; $i < 40; $i++)
8591 $nr_buf .= get_random_chr (0, 0xff);
8596 for (my $i = 0; $i < 440; $i++)
8598 $msg_buf .= get_random_chr (0, 0xff);
8601 my $nr_buf_hex = unpack ("H*", $nr_buf);
8602 my $msg_buf_hex = unpack ("H*", $msg_buf);
8604 my $salt_buf = sprintf ("%s:%s:%s:%s:%s:%s:%s:%s", substr ($msg_buf_hex, 0, 256), substr ($msg_buf_hex, 256, 256), substr ($msg_buf_hex, 512, 16), substr ($msg_buf_hex, 528, 16), substr ($msg_buf_hex, 544, 320), substr ($msg_buf_hex, 864, 16), substr ($nr_buf_hex, 0, 40), substr ($nr_buf_hex, 40, 40));
8609 sub get_random_agilekeychain_salt
8613 for (my $i = 0; $i < 8; $i++)
8615 $salt_buf .= get_random_chr (0x0, 0xff);
8620 for (my $i = 0; $i < 16; $i++)
8622 $iv .= get_random_chr (0x0, 0xff);
8625 my $prefix = "\x00" x 1008;
8627 my $ret = unpack ("H*", $salt_buf . $prefix . $iv);
8632 sub get_random_cloudkeychain_salt
8636 for (my $i = 0; $i < 16; $i++)
8638 $salt_buf .= get_random_chr (0x0, 0xff);
8641 for (my $i = 0; $i < 304; $i++)
8643 $salt_buf .= get_random_chr (0x0, 0xff);
8646 my $ret = unpack ("H*", $salt_buf);
8651 sub get_random_kerberos5_salt
8653 my $custom_salt = shift;
8655 my $clear_data = randbytes (14) .
8656 strftime ("%Y%m%d%H%M%S", localtime) .
8660 my $realm = "realm";
8663 my $salt_buf = $user . "\$" . $realm . "\$" . $salt . "\$" . unpack ("H*", $custom_salt) . "\$" . unpack ("H*", $clear_data) . "\$";
8668 sub get_random_kerberos5_tgs_salt
8670 my $nonce = randbytes (8);
8673 my $realm = "realm";
8674 my $spn = "test/spn";
8676 my $salt_buf = $user . "\$" . $realm . "\$" . $spn . "\$" . unpack ("H*",$nonce);
8681 sub get_random_axcrypt_salt
8683 my $mysalt = randbytes (16);
8685 $mysalt = unpack ("H*", $mysalt);
8687 my $iteration = get_random_num (6, 100000);
8689 my $salt_buf = $iteration . '*' . $mysalt;
8694 sub get_random_keepass_salt
8696 my $version = get_random_num (1, 3);
8702 my $final_random_seed;
8706 $algorithm = get_random_num (0, 2);
8708 $iteration = get_random_num (50000, 100000);
8710 $final_random_seed = randbytes (16);
8711 $final_random_seed = unpack ("H*", $final_random_seed);
8713 elsif ($version == 2)
8717 $iteration = get_random_num (6000, 100000);
8719 $final_random_seed = randbytes (32);
8720 $final_random_seed = unpack ("H*", $final_random_seed);
8723 my $transf_random_seed = randbytes (32);
8724 $transf_random_seed = unpack ("H*", $transf_random_seed);
8726 my $enc_iv = randbytes (16);
8727 $enc_iv = unpack ("H*", $enc_iv);
8729 my $contents_hash = randbytes (32);
8730 $contents_hash = unpack ("H*", $contents_hash);
8732 my $inline_flag = 1;
8734 my $contents_len = get_random_num (128, 500);
8736 my $contents = randbytes ($contents_len);
8738 $contents_len += 16 - $contents_len % 16;
8740 $contents = unpack ("H*", $contents);
8744 my $is_keyfile = get_random_num (0, 2);
8746 my $keyfile_attributes = "";
8748 if ($is_keyfile == 1)
8750 $keyfile_attributes = $keyfile_attributes
8752 . unpack ("H*", randbytes (32));
8757 $salt_buf = $version . '*' .
8760 $final_random_seed . '*' .
8761 $transf_random_seed . '*' .
8763 $contents_hash . '*' .
8764 $inline_flag . '*' .
8765 $contents_len . '*' .
8767 $keyfile_attributes;
8769 elsif ($version == 2)
8771 $contents = randbytes (32);
8772 $contents = unpack ("H*", $contents);
8774 $salt_buf = $version . '*' .
8777 $final_random_seed . '*' .
8778 $transf_random_seed . '*' .
8780 $contents_hash . '*' .
8782 $keyfile_attributes;
8788 sub get_pstoken_salt
8790 my $pstoken_length = get_random_num (16, 256);
8792 ## not a valid pstoken but a better test
8793 ## because of random length
8795 my $pstoken_const = randbytes ($pstoken_length);
8797 return unpack ("H*", $pstoken_const);
8800 sub get_random_md5chap_salt
8802 my $salt_buf = shift;
8804 my $salt = unpack ("H*", $salt_buf);
8808 $salt .= unpack ("H*", randbytes (1));
8813 sub get_random_dnssec_salt
8819 for (my $i = 0; $i < 8; $i++)
8821 $salt_buf .= get_random_chr (0x61, 0x7a);
8824 $salt_buf .= ".net";
8828 for (my $i = 0; $i < 8; $i++)
8830 $salt_buf .= get_random_chr (0x30, 0x39);
8843 my $byte_off = int ($bit / 8);
8844 my $bit_off = int ($bit % 8);
8846 my $char = substr ($digest, $byte_off, 1);
8847 my $num = ord ($char);
8849 return (($num & (1 << $bit_off)) ? 1 : 0);
8858 my $constant_phrase =
8859 "To be, or not to be,--that is the question:--\n" .
8860 "Whether 'tis nobler in the mind to suffer\n" .
8861 "The slings and arrows of outrageous fortune\n" .
8862 "Or to take arms against a sea of troubles,\n" .
8863 "And by opposing end them?--To die,--to sleep,--\n" .
8864 "No more; and by a sleep to say we end\n" .
8865 "The heartache, and the thousand natural shocks\n" .
8866 "That flesh is heir to,--'tis a consummation\n" .
8867 "Devoutly to be wish'd. To die,--to sleep;--\n" .
8868 "To sleep! perchance to dream:--ay, there's the rub;\n" .
8869 "For in that sleep of death what dreams may come,\n" .
8870 "When we have shuffled off this mortal coil,\n" .
8871 "Must give us pause: there's the respect\n" .
8872 "That makes calamity of so long life;\n" .
8873 "For who would bear the whips and scorns of time,\n" .
8874 "The oppressor's wrong, the proud man's contumely,\n" .
8875 "The pangs of despis'd love, the law's delay,\n" .
8876 "The insolence of office, and the spurns\n" .
8877 "That patient merit of the unworthy takes,\n" .
8878 "When he himself might his quietus make\n" .
8879 "With a bare bodkin? who would these fardels bear,\n" .
8880 "To grunt and sweat under a weary life,\n" .
8881 "But that the dread of something after death,--\n" .
8882 "The undiscover'd country, from whose bourn\n" .
8883 "No traveller returns,--puzzles the will,\n" .
8884 "And makes us rather bear those ills we have\n" .
8885 "Than fly to others that we know not of?\n" .
8886 "Thus conscience does make cowards of us all;\n" .
8887 "And thus the native hue of resolution\n" .
8888 "Is sicklied o'er with the pale cast of thought;\n" .
8889 "And enterprises of great pith and moment,\n" .
8890 "With this regard, their currents turn awry,\n" .
8891 "And lose the name of action.--Soft you now!\n" .
8892 "The fair Ophelia!--Nymph, in thy orisons\n" .
8893 "Be all my sins remember'd.\n\x00";
8895 my $constant_len = length ($constant_phrase);
8897 my $hash_buf = md5 ($pw . $salt);
8903 for (my $round = 0; $round < $iter; $round++)
8905 my $shift_a = md5bit ($hash_buf, $round + 0);
8906 my $shift_b = md5bit ($hash_buf, $round + 64);
8911 for (my $k = 0; $k < 16; $k++)
8913 my $s7shift = ord (substr ($hash_buf, $k, 1)) % 8;
8915 my $l = ($k + 3) % 16;
8917 my $num = ord (substr ($hash_buf, $l, 1));
8919 $shift_4[$k] = $num % 5;
8921 $shift_7[$k] = ($num >> $s7shift) & 1;
8926 for (my $k = 0; $k < 16; $k++)
8928 $indirect_4[$k] = (ord (substr ($hash_buf, $k, 1)) >> $shift_4[$k]) & 0xf;
8933 for (my $k = 0; $k < 16; $k++)
8935 $indirect_7[$k] = (ord (substr ($hash_buf, $indirect_4[$k], 1)) >> $shift_7[$k]) & 0x7f;
8941 for (my $k = 0; $k < 8; $k++)
8943 $indirect_a |= md5bit ($hash_buf, $indirect_7[$k + 0]) << $k;
8945 $indirect_b |= md5bit ($hash_buf, $indirect_7[$k + 8]) << $k;
8948 $indirect_a = ($indirect_a >> $shift_a) & 0x7f;
8949 $indirect_b = ($indirect_b >> $shift_b) & 0x7f;
8951 my $bit_a = md5bit ($hash_buf, $indirect_a);
8952 my $bit_b = md5bit ($hash_buf, $indirect_b);
8962 if ($bit_a ^ $bit_b)
8964 substr ($W, 16, 48) = substr ($constant_phrase, 0, 48);
8968 $to_hash .= substr ($W, 0, 64);
8972 for ($constant_off = 48; $constant_off < $constant_len - 64; $constant_off += 64)
8974 substr ($W, 0, 64) = substr ($constant_phrase, $constant_off, 64);
8978 $to_hash .= substr ($W, 0, 64);
8981 $pos = $constant_len - $constant_off;
8985 substr ($W, 0, $pos) = substr ($constant_phrase, $constant_off, $pos);
9000 my $round_div = int ($tmp / 10);
9001 my $round_mod = int ($tmp % 10);
9005 $a_buf[int ($a_len / 4)] = (($round_mod + 0x30) | ($a_buf[int ($a_len / 4)] << 8));
9015 for ($g = 0; $g < $a_len; $g++)
9017 my $remainder = $a_buf[$g];
9023 while ($remainder > 0)
9025 $sub = $remainder >> (8 * $factor);
9027 if ($started != 1 || $sub > 0)
9031 $tmp_str = chr ($sub) . $tmp_str;
9033 $remainder -= ($sub << (8 * $factor));
9041 substr ($W, $pos, $a_len) = $tmp_str;
9047 $to_hash .= substr ($W, 0, $pos);
9049 $to_hash = substr ($to_hash, 0, $total);
9051 $hash_buf = md5 ($to_hash);
9056 $passwd .= to64 ((int (ord (substr ($hash_buf, 0, 1))) << 16) | (int (ord (substr ($hash_buf, 6, 1))) << 8) | (int (ord (substr ($hash_buf, 12, 1)))), 4);
9057 $passwd .= to64 ((int (ord (substr ($hash_buf, 1, 1))) << 16) | (int (ord (substr ($hash_buf, 7, 1))) << 8) | (int (ord (substr ($hash_buf, 13, 1)))), 4);
9058 $passwd .= to64 ((int (ord (substr ($hash_buf, 2, 1))) << 16) | (int (ord (substr ($hash_buf, 8, 1))) << 8) | (int (ord (substr ($hash_buf, 14, 1)))), 4);
9059 $passwd .= to64 ((int (ord (substr ($hash_buf, 3, 1))) << 16) | (int (ord (substr ($hash_buf, 9, 1))) << 8) | (int (ord (substr ($hash_buf, 15, 1)))), 4);
9060 $passwd .= to64 ((int (ord (substr ($hash_buf, 4, 1))) << 16) | (int (ord (substr ($hash_buf, 10, 1))) << 8) | (int (ord (substr ($hash_buf, 5, 1)))), 4);
9061 $passwd .= to64 ((int (ord (substr ($hash_buf, 11, 1)))), 2);
9068 die ("usage: $0 single|passthrough| [mode] [len]\n" .
9070 " $0 verify [mode] [hashfile] [cracks] [outfile]\n");
9075 my $block_ref = shift;
9079 my $value = 16 - $offset;
9081 for (my $i = $offset; $i < 16; $i++)
9083 push @{$block_ref}, $value;
9093 for (my $i = 0; $i < 18; $i++)
9095 for (my $j = 0; $j < 48; $j++)
9097 $p = ($p + 48 - $j) & 0xff;
9099 my $c = $lotus_magic_table[$p];
9101 $p = $in_ref->[$j] ^ $c;
9108 sub lotus_transform_password
9111 my $out_ref = shift;
9113 my $t = $out_ref->[15];
9115 for (my $i = 0; $i < 16; $i++)
9117 $t ^= $in_ref->[$i];
9119 my $c = $lotus_magic_table[$t];
9121 $out_ref->[$i] ^= $c;
9123 $t = $out_ref->[$i];
9127 sub mdtransform_norecalc
9129 my $state_ref = shift;
9130 my $block_ref = shift;
9134 push (@x, @{$state_ref});
9135 push (@x, @{$block_ref});
9137 for (my $i = 0; $i < 16; $i++)
9139 push (@x, $x[0 + $i] ^ $x[16 + $i]);
9144 for (my $i = 0; $i < 16; $i++)
9146 $state_ref->[$i] = $x[$i];
9152 my $state_ref = shift;
9153 my $checksum_ref = shift;
9154 my $block_ref = shift;
9156 mdtransform_norecalc ($state_ref, $block_ref);
9158 lotus_transform_password ($block_ref, $checksum_ref);
9163 my $saved_key_ref = shift;
9167 @{$saved_key_ref} = splice (@{$saved_key_ref}, 0, $size);
9169 my @state = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
9175 for ($curpos = 0; $curpos + 16 < $size; $curpos += 16)
9177 my $curpos16 = $curpos + 16;
9179 my @block = splice (@{$saved_key_ref}, 0, 16);
9181 mdtransform (\@state, \@checksum, \@block);
9184 my $left = $size - $curpos;
9186 my @block = splice (@{$saved_key_ref}, 0, 16);
9188 pad16 (\@block, $left);
9190 mdtransform (\@state, \@checksum, \@block);
9192 mdtransform_norecalc (\@state, \@checksum);
9197 sub pdf_compute_encryption_key
9199 my $word_buf = shift;
9200 my $padding = shift;
9215 $data .= substr ($padding, 0, 32 - length $word_buf);
9217 $data .= pack ("H*", $o);
9219 $data .= pack ("I", $P);
9221 $data .= pack ("H*", $id);
9227 $data .= pack ("I", -1);
9231 my $res = md5 ($data);
9235 for (my $i = 0; $i < 50; $i++)
9244 sub gen_random_wpa_eapol
9253 my $version = 1; # 802.1X-2001
9255 $ret .= pack ("C*", $version);
9257 my $type = 3; # means that this EAPOL frame is used to transfer key information
9259 $ret .= pack ("C*", $type);
9261 my $length; # length of remaining data
9272 $ret .= pack ("n*", $length);
9274 my $descriptor_type;
9278 $descriptor_type = 254; # EAPOL WPA key
9282 $descriptor_type = 1; # EAPOL RSN key
9285 $ret .= pack ("C*", $descriptor_type);
9287 # key_info is a bit vector:
9288 # generated from these 13 bits: encrypted key data, request, error, secure, key mic, key ack, install, key index (2), key type, key descriptor (3)
9292 $key_info |= 1 << 8; # set key MIC
9293 $key_info |= 1 << 3; # set if it is a pairwise key
9297 $key_info |= 1 << 0; # RC4 Cipher, HMAC-MD5 MIC
9301 $key_info |= 1 << 1; # AES Cipher, HMAC-SHA1 MIC
9304 $ret .= pack ("n*", $key_info);
9317 $ret .= pack ("n*", $key_length);
9319 my $replay_counter = 1;
9321 $ret .= pack ("Q>*", $replay_counter);
9325 my $key_iv = "\x00" x 16;
9329 my $key_rsc = "\x00" x 8;
9333 my $key_id = "\x00" x 8;
9337 my $key_mic = "\x00" x 16;
9345 $key_data_len = 24; # length of the key_data (== WPA info)
9349 $key_data_len = 22; # length of the key_data (== RSN info)
9352 $ret .= pack ("n*", $key_data_len);
9362 my $vendor_specific_data = "";
9364 my $tag_number = 221; # means it is a vendor specific tag
9366 $vendor_specific_data .= pack ("C*", $tag_number);
9368 my $tag_len = 22; # length of the remaining "tag data"
9370 $vendor_specific_data .= pack ("C*", $tag_len);
9372 my $vendor_specific_oui = pack ("H*", "0050f2"); # microsoft
9374 $vendor_specific_data .= $vendor_specific_oui;
9376 my $vendor_specific_oui_type = 1; # WPA Information Element
9378 $vendor_specific_data .= pack ("C*", $vendor_specific_oui_type);
9380 my $vendor_specific_wpa_version = 1;
9382 $vendor_specific_data .= pack ("v*", $vendor_specific_wpa_version);
9386 my $vendor_specific_multicast_oui = pack ("H*", "0050f2");
9388 $vendor_specific_data .= $vendor_specific_multicast_oui;
9390 my $vendor_specific_multicast_type = 2; # TKIP
9392 $vendor_specific_data .= pack ("C*", $vendor_specific_multicast_type);
9396 my $vendor_specific_unicast_count = 1;
9398 $vendor_specific_data .= pack ("v*", $vendor_specific_unicast_count);
9400 my $vendor_specific_unicast_oui = pack ("H*", "0050f2");
9402 $vendor_specific_data .= $vendor_specific_multicast_oui;
9404 my $vendor_specific_unicast_type = 2; # TKIP
9406 $vendor_specific_data .= pack ("C*", $vendor_specific_unicast_type);
9408 # Auth Key Management (AKM)
9410 my $auth_key_management_count = 1;
9412 $vendor_specific_data .= pack ("v*", $auth_key_management_count);
9414 my $auth_key_management_oui = pack ("H*", "0050f2");
9416 $vendor_specific_data .= $auth_key_management_oui;
9418 my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
9420 $vendor_specific_data .= pack ("C*", $auth_key_management_type);
9422 $wpa_info = $vendor_specific_data;
9424 $key_data = $wpa_info;
9432 my $tag_number = 48; # RSN info
9434 $rsn_info .= pack ("C*", $tag_number);
9436 my $tag_len = 20; # length of the remaining "tag_data"
9438 $rsn_info .= pack ("C*", $tag_len);
9440 my $rsn_version = 1;
9442 $rsn_info .= pack ("v*", $rsn_version);
9444 # group cipher suite
9446 my $group_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
9448 $rsn_info .= $group_cipher_suite_oui;
9450 my $group_cipher_suite_type = 4; # AES (CCM)
9452 $rsn_info .= pack ("C*", $group_cipher_suite_type);
9454 # pairwise cipher suite
9456 my $pairwise_cipher_suite_count = 1;
9458 $rsn_info .= pack ("v*", $pairwise_cipher_suite_count);
9460 my $pairwise_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
9462 $rsn_info .= $pairwise_cipher_suite_oui;
9464 my $pairwise_cipher_suite_type = 4; # AES (CCM)
9466 $rsn_info .= pack ("C*", $pairwise_cipher_suite_type);
9468 # Auth Key Management (AKM)
9470 my $auth_key_management_count = 1;
9472 $rsn_info .= pack ("v*", $auth_key_management_count);
9474 my $auth_key_management_oui = pack ("H*", "000fac"); # Ieee8021
9476 $rsn_info .= $auth_key_management_oui;
9478 my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
9480 $rsn_info .= pack ("C*", $auth_key_management_type);
9484 # bit vector of these 9 bits: peerkey enabled, management frame protection (MFP) capable, MFP required,
9485 # RSN GTKSA Capabilities (2), RSN PTKSA Capabilities (2), no pairwise Capabilities, Pre-Auth Capabilities
9487 my $rsn_capabilities = pack ("H*", "0000");
9489 $rsn_info .= $rsn_capabilities;
9491 $key_data = $rsn_info;
9507 my $data = "Pairwise key expansion";
9512 # Min(AA, SPA) || Max(AA, SPA)
9515 # compare if greater: Min()/Max() on the MACs (6 bytes)
9517 if (memcmp ($stmac, $bssid, 6) < 0)
9529 # Min(ANonce,SNonce) || Max(ANonce,SNonce)
9532 # compare if greater: Min()/Max() on the nonces (32 bytes)
9534 if (memcmp ($snonce, $anonce, 32) < 0)
9547 my $prf_buf = hmac ($data, $pmk, \&sha1);
9549 $prf_buf = substr ($prf_buf, 0, 16);
9560 my $len_str1 = length ($str1);
9561 my $len_str2 = length ($str2);
9563 if (($len > $len_str1) || ($len > $len_str2))
9565 print "ERROR: memcmp () lengths wrong";
9570 for (my $i = 0; $i < $len; $i++)
9572 my $c_1 = ord (substr ($str1, $i, 1));
9573 my $c_2 = ord (substr ($str2, $i, 1));
9575 return -1 if ($c_1 < $c_2);
9576 return 1 if ($c_1 > $c_2);