tools/test.pl

   1 #!/usr/bin/env perl
   2
   3 ##
   4 ## Author......: Jens Steube <jens.steube@gmail.com>
   5 ## License.....: MIT
   6 ##
   7
   8 use strict;
   9 use warnings;
  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);
  19 use Crypt::PBKDF2;
  20 use Crypt::DES;
  21 use Crypt::ECB       qw (encrypt PADDING_AUTO PADDING_NONE);
  22 use Crypt::CBC;
  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);
  26 use Crypt::RC4;
  27 use Crypt::ScryptKDF qw (scrypt_hash scrypt_b64);
  28 use Crypt::Rijndael;
  29 use Crypt::Mode::ECB;
  30 use Crypt::UnixCrypt_XS qw (crypt_rounds fold_password base64_to_int24 block_to_base64 int24_to_base64);
  31 use MIME::Base64;
  32 use Authen::Passphrase::NTHash;
  33 use Authen::Passphrase::MySQL323;
  34 use Authen::Passphrase::PHPass;
  35 use Authen::Passphrase::LANManager;
  36 use Encode;
  37 use POSIX qw (strftime);
  38 use Net::DNS::SEC;
  39 use Net::DNS::RR::NSEC3;
  40 use Convert::EBCDIC qw (ascii2ebcdic);
  41 use Digest::SipHash qw/siphash/;
  42
  43 my $hashcat = "./oclHashcat";
  44
  45 my $MAX_LEN = 55;
  46
  47 my @modes = (0, 10, 11, 12, 20, 21, 22, 23, 30, 40, 50, 60, 100, 101, 110, 111, 112, 120, 121, 122, 130, 131, 132, 140, 141, 150, 160, 190, 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);
  48
  49 my %is_unicode      = map { $_ => 1 } qw(30 40 130 131 132 140 141 1000 1100 1430 1440 1441 1730 1740 1731 5500 5600 8000 9400 9500 9600 9700 9800);
  50 my %less_fifteen    = map { $_ => 1 } qw(500 1600 1800 2400 2410 3200 6300 7400 10500 10700);
  51 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);
  52
  53 my @lotus_magic_table =
  54 (
  55   0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a,
  56   0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0,
  57   0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b,
  58   0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a,
  59   0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda,
  60   0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36,
  61   0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8,
  62   0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c,
  63   0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17,
  64   0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60,
  65   0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72,
  66   0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa,
  67   0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd,
  68   0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e,
  69   0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b,
  70   0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf,
  71   0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77,
  72   0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6,
  73   0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3,
  74   0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3,
  75   0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e,
  76   0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c,
  77   0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d,
  78   0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2,
  79   0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46,
  80   0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5,
  81   0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97,
  82   0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5,
  83   0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef,
  84   0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f,
  85   0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf,
  86   0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab
  87 );
  88
  89 my @pdf_padding =
  90 (
  91   0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
  92   0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
  93   0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
  94   0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
  95 );
  96
  97 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'};
  98
  99 if (scalar @ARGV < 1)
 100 {
 101   usage_die ();
 102 }
 103
 104 my $type;
 105 my $mode;
 106 my $len;
 107
 108 $type = shift @ARGV;
 109
 110 if ($type ne "verify")
 111 {
 112   if (scalar @ARGV > 1)
 113   {
 114     $mode = shift @ARGV;
 115     $len  = shift @ARGV;
 116   }
 117   elsif (scalar @ARGV == 1)
 118   {
 119     $mode = shift @ARGV;
 120     $len  = 0;
 121   }
 122   else
 123   {
 124     $len = 0;
 125   }
 126
 127   if ($type eq "single")
 128   {
 129     single ($mode);
 130   }
 131   elsif ($type eq "passthrough")
 132   {
 133     passthrough ($mode);
 134   }
 135   else
 136   {
 137     usage_die ();
 138   }
 139 }
 140 else
 141 {
 142   if (scalar @ARGV != 4)
 143   {
 144     usage_die ();
 145   }
 146
 147   my $mode      = shift @ARGV;
 148   my $hash_file = shift @ARGV;
 149   my $in_file   = shift @ARGV;
 150   my $out_file  = shift @ARGV;
 151
 152   my $db;
 153
 154   open (IN,  "<", $hash_file) or die ("$hash_file: $!\n");
 155
 156   # clever ? the resulting database could be huge
 157   # but we need some way to map lines in hashfile w/ cracks
 158   # maybe rli2 way would be more clever (needs sorted input)
 159
 160   while (my $line = <IN>)
 161   {
 162     $line =~ s/[\n\r]*$//;
 163
 164     $db->{$line} = undef;
 165   }
 166
 167   close (IN);
 168
 169   verify ($mode, $db, $in_file, $out_file);
 170 }
 171
 172 sub verify
 173 {
 174   my $mode     = shift;
 175   my $db       = shift;
 176   my $in_file  = shift;
 177   my $out_file = shift;
 178
 179   my $hash_in;
 180   my $hash_out;
 181   my $iter;
 182   my $salt;
 183   my $word;
 184   my $param;
 185   my $param2;
 186   my $param3;
 187   my $param4;
 188   my $param5;
 189   my $param6;
 190   my $param7;
 191   my $param8;
 192   my $param9;
 193   my $param10;
 194   my $param11;
 195
 196   open (IN,  "<", $in_file)  or die ("$in_file: $!\n");
 197   open (OUT, ">", $out_file) or die ("$out_file: $!\n");
 198
 199   my $len;
 200
 201   my $base64   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 202   my $itoa64_1 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 203   my $itoa64_2 = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 204
 205   while (my $line = <IN>)
 206   {
 207     chomp ($line);
 208
 209     $line =~ s/\n$//;
 210     $line =~ s/\r$//;
 211
 212     # remember always do "exists ($db->{$hash_in})" checks as soon as possible and don't forget it
 213
 214     # unsalted
 215     if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 190 || $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)
 216     {
 217       my $index = index ($line, ":");
 218
 219       next if $index < 1;
 220
 221       $hash_in = substr ($line, 0, $index);
 222
 223       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 224
 225       $word = substr ($line, $index + 1);
 226     }
 227     # hash:salt
 228     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)
 229     {
 230       # get hash
 231       my $index1 = index ($line, ":");
 232
 233       next if $index1 < 1;
 234
 235       $hash_in = substr ($line, 0, $index1);
 236
 237       # identify lenghts of both salt and plain
 238
 239       my $salt_plain = substr ($line, $index1 + 1);
 240
 241       my $num_cols = () = $salt_plain =~ /:/g;
 242
 243       my $index2;
 244       my $matched = 0;
 245       my $start = 0;
 246
 247       $word = undef;
 248
 249       # fuzzy
 250       foreach (my $i = 0; $i < $num_cols; $i++)
 251       {
 252         $index2 = index ($salt_plain, ":", $start);
 253
 254         next if $index2 < 0;
 255
 256         $start = $index2 + 1;
 257
 258         $salt = substr ($salt_plain, 0, $index2);
 259         $word = substr ($salt_plain, $index2 + 1);
 260
 261         # can't be true w/ wrong $hash:$salt, otherwise the
 262         # algo must have many collisions
 263
 264         if (exists ($db->{$hash_in . ":" . $salt}))
 265         {
 266           $hash_in = $hash_in . ":" . $salt;
 267           $matched = 1;
 268           last;
 269         }
 270       }
 271
 272       next unless ($matched); # therefore: true == exists ($db->{$hash_in}
 273       next unless (! defined ($db->{$hash_in}));
 274     }
 275     # dcc2
 276     elsif ($mode == 2100)
 277     {
 278       # get hash
 279       my $index1 = index ($line, "\$DCC2\$");
 280
 281       next if $index1 != 0;
 282
 283       # iterations
 284       my $index2 = index ($line, "#", $index1 + 1);
 285
 286       next if $index2 < 1;
 287
 288       $iter = substr ($line, $index1 + 6, $index2 - $index1 - 6);
 289
 290       # get hash
 291       $index1 = index ($line, "#");
 292
 293       next if $index1 < 1;
 294
 295       $hash_in = substr ($line, 0, $index1 + 1);
 296
 297       # identify lenghts of both salt and plain
 298
 299       my $salt_plain = substr ($line, $index2 + 1);
 300
 301       my $num_cols = () = $salt_plain =~ /:/g;
 302
 303       my $matched = 0;
 304       my $start   = 0;
 305       my $index3  = 0;
 306       my $raw_hash;
 307
 308       $word = undef;
 309
 310       # fuzzy
 311       foreach (my $i = 0; $i < $num_cols; $i++)
 312       {
 313         $index2 = index ($salt_plain, ":", $start);
 314
 315         next if $index2 < 0;
 316
 317         $start = $index2 + 1;
 318
 319         $index3 = rindex ($salt_plain, "#", $index2);
 320
 321         $raw_hash = substr ($salt_plain, $index3 + 1, $index2 - $index3 - 1);
 322         $salt = substr ($salt_plain, 0, $index3);
 323         $word = substr ($salt_plain, $index2 + 1);
 324
 325         if (exists ($db->{$hash_in . $salt . "#" .$raw_hash}))
 326         {
 327           $hash_in = $hash_in . $salt . "#" . $raw_hash;
 328           $matched = 1;
 329           last;
 330         }
 331       }
 332
 333       next unless ($matched); # therefore: true == exists ($db->{$hash_in}
 334       next unless (! defined ($db->{$hash_in}));
 335     }
 336     # salt:hash guaranteed only : because of hex salt
 337     elsif ($mode == 7300)
 338     {
 339       # split hash and plain
 340       my $index1 = index ($line, ":");
 341
 342       next if $index1 < 1;
 343
 344       $salt = substr ($line, 0, $index1);
 345
 346       $salt = pack ("H*", $salt);
 347
 348       my $rest = substr ($line, $index1 + 1);
 349
 350       my $index2 = index ($rest, ":");
 351
 352       next if $index2 < 1;
 353
 354       $hash_in = substr ($rest, 0, $index2);
 355
 356       $word = substr ($rest, $index2 + 1);
 357
 358       next unless (exists ($db->{$salt . ":" . $hash_in}) and (! defined ($db->{$hash_in})));
 359     }
 360     # 1salthash fixed
 361     elsif ($mode == 8100)
 362     {
 363       # split hash and plain
 364       $salt = substr ($line, 1, 8);
 365
 366       my $rest = substr ($line, 1 + 8);
 367
 368       my $index2 = index ($rest, ":");
 369
 370       next if $index2 < 1;
 371
 372       $hash_in = substr ($rest, 0, $index2);
 373
 374       $word = substr ($rest, $index2 + 1);
 375
 376       next unless (exists ($db->{"1" . $salt . $hash_in}) and (! defined ($db->{$hash_in})));
 377     }
 378     # base64 and salt embedded SSHA1, salt length = total lenght - 20
 379     elsif ($mode == 111)
 380     {
 381       # split hash and plain
 382       my $index = index ($line, ":");
 383
 384       next if $index < 1;
 385
 386       $hash_in = substr ($line, 0, $index);
 387       $word    = substr ($line, $index + 1);
 388
 389       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 390
 391       # remove signature
 392       my $plain_base64 = substr ($hash_in, 6);
 393
 394       # base64 decode to extract salt
 395       my $decoded = decode_base64 ($plain_base64);
 396
 397       $salt = substr ($decoded, 20);
 398     }
 399     # base64 and salt embedded SSHA512, salt length = total length - 64
 400     elsif ($mode == 1711)
 401     {
 402       # split hash and plain
 403       my $index = index ($line, ":");
 404
 405       next if $index < 1;
 406
 407       $hash_in = substr ($line, 0, $index);
 408       $word    = substr ($line, $index + 1);
 409
 410       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 411
 412       # remove signature
 413       my $plain_base64 = substr ($hash_in, 9);
 414
 415       # base64 decode to extract salt
 416       my $decoded = decode_base64 ($plain_base64);
 417
 418       $salt = substr ($decoded, 64);
 419     }
 420     # OSX (first 8 hex chars is salt)
 421     elsif ($mode == 122 || $mode == 1722)
 422     {
 423       my $index = index ($line, ":");
 424
 425       next if $index < 1;
 426
 427       $hash_in = substr ($line, 0, $index);
 428       $word    = substr ($line, $index + 1);
 429
 430       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 431
 432       $salt = substr ($hash_in, 0, 8);
 433     }
 434     # MSSQL (2000, 2005 AND 2012), salt after version number
 435     elsif ($mode == 131 || $mode == 132 || $mode == 1731)
 436     {
 437       my $index = index ($line, ":");
 438
 439       next if $index < 1;
 440
 441       $hash_in = substr ($line, 0, $index);
 442       $word    = substr ($line, $index + 1);
 443
 444       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 445
 446       $salt = substr ($hash_in, 6, 8);
 447     }
 448     # Sybase ASE
 449     elsif ($mode == 8000)
 450     {
 451       my $index = index ($line, ":");
 452
 453       next if $index < 1;
 454
 455       $hash_in = substr ($line, 0, $index);
 456       $word    = substr ($line, $index + 1);
 457
 458       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 459
 460       $salt = substr ($hash_in, 6, 16);
 461     }
 462     # episerver salts
 463     elsif ($mode == 141 || $mode == 1441)
 464     {
 465       my $index1 = index ($line, ":");
 466
 467       next if $index1 < 1;
 468
 469       $hash_in = substr ($line, 0, $index1);
 470       $word    = substr ($line, $index1 + 1);
 471
 472       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 473
 474       my $index2 = index ($line, "*", 14);
 475
 476       #extract salt from base64
 477       my $plain_base64 = substr ($hash_in, 14, $index2 - 14);
 478
 479       $salt = decode_base64 ($plain_base64);
 480     }
 481     # phpass (first 8 after $P$/$H$ -- or $S$ with drupal7)
 482     elsif ($mode == 400 || $mode == 7900)
 483     {
 484       my $index = index ($line, ":");
 485
 486       next if $index < 1;
 487
 488       $hash_in = substr ($line, 0, $index);
 489       $word    = substr ($line, $index + 1);
 490
 491       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 492
 493       $salt = substr ($hash_in, 4, 8);
 494
 495       # iterations = 2 ^ cost (where cost == $iter)
 496       $iter = index ($itoa64_1, substr ($hash_in, 3, 1));
 497     }
 498     # $something$[rounds=iter$]salt$     (get last $, then check iter)
 499     elsif ($mode == 500 || $mode == 1600 || $mode == 1800 || $mode == 3300 || $mode == 7400)
 500     {
 501       my $index1 = index ($line, ":", 30);
 502
 503       next if $index1 < 1;
 504
 505       $hash_in = substr ($line, 0, $index1);
 506       $word    = substr ($line, $index1 + 1);
 507
 508       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 509
 510       $index1 = index ($hash_in,  ",", 1);
 511       my $index2 = index ($hash_in, "\$", 1);
 512
 513       if ($index1 != -1)
 514       {
 515         if ($index1 < $index2)
 516         {
 517           $index2 = $index1;
 518         }
 519       }
 520
 521       $param = substr ($hash_in, $index2, 1);
 522
 523       $index2++;
 524
 525       # rounds= if available
 526       $iter = 0;
 527
 528       if (substr ($hash_in, $index2, 7) eq "rounds=")
 529       {
 530         my $old_index = $index2;
 531
 532         $index2 = index ($hash_in, "\$", $index2 + 1);
 533
 534         next if $index2 < 1;
 535
 536         $iter = substr ($hash_in, $old_index + 7, $index2 - $old_index - 7);
 537
 538         $index2++;
 539       }
 540
 541       # get salt
 542       my $index3 = rindex ($hash_in, "\$");
 543
 544       next if $index3 < 1;
 545
 546       $salt = substr ($hash_in, $index2, $index3 - $index2);
 547     }
 548     # descrypt (salt in first 2 char)
 549     elsif ($mode == 1500)
 550     {
 551       my $index = index ($line, ":");
 552
 553       next if $index < 1;
 554
 555       $hash_in = substr ($line, 0, $index);
 556       $word    = substr ($line, $index + 1);
 557
 558       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 559
 560       $salt = substr ($hash_in, 0, 2);
 561     }
 562     # bcrypt $something$something$salt.hash
 563     elsif ($mode == 3200)
 564     {
 565       my $index1 = index ($line, ":", 33);
 566
 567       next if $index1 < 1;
 568
 569       $hash_in = substr ($line, 0, $index1);
 570       $word    = substr ($line, $index1 + 1);
 571
 572       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 573
 574       my $index2 =  index ($hash_in, "\$", 4);
 575
 576       $iter = substr ($hash_in, 4, $index2 - 4);
 577
 578       my $plain_base64 = substr ($hash_in, $index2 + 1, 22);
 579
 580       # base64 mapping
 581       my $encoded = "";
 582
 583       for (my $i = 0; $i < length ($plain_base64); $i++)
 584       {
 585         my $char  = substr ($plain_base64, $i, 1);
 586         $encoded .= substr ($base64, index ($itoa64_2, $char), 1);
 587       }
 588
 589       $salt = decode_base64 ($encoded);
 590     }
 591     # md5 (chap)
 592     elsif ($mode == 4800)
 593     {
 594       my $index1 = index ($line, ":");
 595
 596       next if $index1 < 1;
 597
 598       my $index2 = index ($line, ":", $index1 + 1);
 599
 600       next if $index2 < 1;
 601
 602       my $index3 = index ($line, ":", $index2 + 1);
 603
 604       next if $index3 < 1;
 605
 606       $salt = substr ($line, $index1 + 1, $index3 - $index1 - 1);
 607
 608       $word = substr ($line, $index3 + 1);
 609
 610       $hash_in = substr ($line, 0, $index3);
 611     }
 612     # IKE (md5 and sha1)
 613     elsif ($mode == 5300 || $mode == 5400)
 614     {
 615       my $num_cols = () = $line =~ /:/g;
 616
 617       next unless ($num_cols >= 9);
 618
 619       my $index1 = -1;
 620       my $failed =  0;
 621
 622       for (my $j = 0; $j < 9; $j++)
 623       {
 624         $index1 = index ($line, ":", $index1 + 1);
 625
 626         if ($index1 < 1)
 627         {
 628           $failed = 1;
 629           last;
 630         }
 631       }
 632
 633       next if ($failed);
 634
 635       $word = substr ($line, $index1 + 1);
 636
 637       $hash_in = substr ($line, 0, $index1);
 638
 639       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 640
 641       my $index2 = rindex ($line, ":", $index1 - 1);
 642
 643       $salt = substr ($line, 0, $index2);
 644     }
 645     # NetNTLMv1
 646     elsif ($mode == 5500)
 647     {
 648       my $index1 = index ($line, "::");
 649
 650       next if $index1 < 1;
 651
 652       my $index2 = index ($line, ":", $index1 + 2);
 653
 654       next if $index2 < 1;
 655
 656       $index2 = index ($line, ":", $index2 + 1);
 657
 658       next if $index2 < 1;
 659
 660       $salt = substr ($line, 0, $index2);
 661
 662       $index2 = index ($line, ":", $index2 + 1);
 663
 664       next if $index2 < 1;
 665
 666       $salt .= substr ($line, $index2 + 1, 16);
 667
 668       $index2 = index ($line, ":", $index2 + 1);
 669
 670       next if $index2 < 1;
 671
 672       $hash_in = substr ($line, 0, $index2);
 673
 674       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 675
 676       $word = substr ($line, $index2 + 1);
 677     }
 678     # NetNTLMv2
 679     elsif ($mode == 5600)
 680     {
 681       my $index1 = index ($line, "::");
 682
 683       next if $index1 < 1;
 684
 685       my $index2 = index ($line, ":", $index1 + 2);
 686
 687       next if $index2 < 1;
 688
 689       $index2 = index ($line, ":", $index2 + 1);
 690
 691       next if $index2 < 1;
 692
 693       $salt = substr ($line, 0, $index2);
 694
 695       $index1 = index ($line, ":", $index2 + 1);
 696
 697       next if $index1 < 1;
 698
 699       $index2 = index ($line, ":", $index1 + 1);
 700
 701       next if $index2 < 1;
 702
 703       $salt .= substr ($line, $index1 + 1, $index2 - $index1 - 1);
 704
 705       $hash_in = substr ($line, 0, $index2);
 706
 707       # do it later on for this hash mode:
 708       # next unless ((exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))) or (exists ($db->{$mod}) and (! defined ($db->{$mod}))));
 709
 710       $word = substr ($line, $index2 + 1);
 711     }
 712     # AIX smd5 something BRACE salt$
 713     elsif ($mode == 6300)
 714     {
 715       my $index1 = index ($line, ":");
 716
 717       next if $index1 < 1;
 718
 719       $hash_in = substr ($line, 0, $index1);
 720       $word    = substr ($line, $index1 + 1);
 721
 722       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 723
 724       my $index2 =  index ($hash_in, "}");
 725       my $index3 = rindex ($hash_in, "\$");
 726
 727       $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
 728     }
 729     # AIX: something$salt$ (no $ at position 1)
 730     elsif ($mode == 6400 || $mode == 6500 || $mode == 6700)
 731     {
 732       my $index1 = index ($line, ":");
 733
 734       next if $index1 < 1;
 735
 736       $hash_in = substr ($line, 0, $index1);
 737       $word    = substr ($line, $index1 + 1);
 738
 739       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 740
 741       my $index2 =  index ($hash_in, "}");
 742       my $index3 =  index ($hash_in, "\$");
 743       my $index4 = rindex ($hash_in, "\$");
 744
 745       $salt = substr ($hash_in, $index3 + 1, $index4 - $index3 - 1);
 746
 747       $iter = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
 748     }
 749     # 1Password, agilekeychain
 750     elsif ($mode == 6600)
 751     {
 752       my $num_cols = () = $line =~ /:/g;
 753
 754       next unless ($num_cols > 2);
 755
 756       my $index1 = index ($line, ":");
 757
 758       next if $index1 < 1;
 759
 760       $iter = substr ($line, 0, $index1);
 761
 762       my $index2 = index ($line, ":", $index1 + 1);
 763
 764       next if $index2 < 1;
 765
 766       $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
 767
 768       $index1 = index ($line, ":", $index2 + 1);
 769
 770       next if $index1 < 1;
 771
 772       $salt .= substr ($line, $index2 + 1, $index1 - $index2 - 33);
 773
 774       $hash_in = substr ($line, 0, $index1);
 775
 776       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 777
 778       $word = substr ($line, $index1 + 1);
 779     }
 780     # 1Password, cloudkeychain
 781     elsif ($mode == 8200)
 782     {
 783       my @datas = split (":", $line);
 784
 785       next if scalar @datas < 4;
 786
 787       my $hash = shift @datas;
 788       $salt    = shift @datas;
 789       $iter    = shift @datas;
 790       my $data = shift @datas;
 791
 792       $hash_in = $hash . ":" . $salt . ":" . $iter . ":" . $data;
 793
 794       $salt .= $data;
 795
 796       $word = join (":", @datas);
 797
 798       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 799     }
 800     # lastpass (hash:iter:salt)
 801     elsif ($mode == 6800)
 802     {
 803       my $index1 = index ($line, ":", 34);
 804
 805       next if $index1 < 1;
 806
 807       $hash_in = substr ($line, 0, $index1);
 808
 809       # identify lenghts of both salt and plain
 810
 811       my $salt_plain = substr ($line, $index1 + 1);
 812
 813       my $num_cols = () = $salt_plain =~ /:/g;
 814
 815       my $index2;
 816       my $matched = 0;
 817       my $start = 0;
 818
 819       $word = undef;
 820
 821       # fuzzy
 822       foreach (my $i = 0; $i < $num_cols; $i++)
 823       {
 824         $index2 = index ($salt_plain, ":", $start);
 825
 826         next if $index2 < 1;
 827
 828         $start = $index2 + 1;
 829
 830         $salt = substr ($salt_plain, 0, $index2);
 831         $word = substr ($salt_plain, $index2 + 1);
 832
 833         # can't be true w/ wrong $hash:$salt, otherwise the
 834         # algo must have many collisions
 835
 836         if (exists ($db->{$hash_in . ":" . $salt}))
 837         {
 838           $hash_in = $hash_in . ":" . $salt;
 839           $matched = 1;
 840           last;
 841         }
 842       }
 843
 844       next unless ($matched); # therefore: true == exists ($db->{$hash_in}
 845       next unless (! defined ($db->{$hash_in}));
 846
 847       $index1 = index ($hash_in, ":");
 848       $index2 = index ($hash_in, ":", $index1 + 1);
 849
 850       $iter = substr ($hash_in, $index1 + 1, $index2 - $index1 - 1);
 851       $salt = substr ($hash_in, $index2 + 1);
 852     }
 853     # OSX 10.* : $something$iter$salt$
 854     elsif ($mode == 7100)
 855     {
 856       my $index1 = index ($line, ":");
 857
 858       next if $index1 < 1;
 859
 860       $hash_in = substr ($line, 0, $index1);
 861       $word    = substr ($line, $index1 + 1);
 862
 863       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 864
 865       my $index2 =  index ($hash_in, "\$", 5);
 866
 867       next if $index2 < 1;
 868
 869       my $index3 =  index ($hash_in, "\$", $index2 + 1);
 870
 871       $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
 872
 873       $iter = substr ($hash_in, 4, $index2 - 4);
 874
 875       next if (int ($iter) < 1);
 876     }
 877     # grub: something1.something2.something3.iter.salt.
 878     elsif ($mode == 7200)
 879     {
 880       my $index1 = index ($line, ":");
 881
 882       next if $index1 < 1;
 883
 884       $hash_in = substr ($line, 0, $index1);
 885       $word    = substr ($line, $index1 + 1);
 886
 887       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 888
 889       my $index2 =  index ($hash_in, ".", 19);
 890
 891       next if $index2 < 1;
 892
 893       my $index3 =  index ($hash_in, ".", $index2 + 1);
 894
 895       $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1);
 896
 897       $iter = substr ($hash_in, 19, $index2 - 19);
 898
 899       next if (int ($iter) < 1);
 900     }
 901     # $something1$something2$something3$something4$salt$
 902     elsif ($mode == 7500 )
 903     {
 904       my $index1 = index ($line, "\$", 11);
 905
 906       next if $index1 < 1;
 907
 908       my $index2 = index ($line, "\$", $index1 + 1);
 909
 910       next if $index2 < 1;
 911
 912       my $index3 = index ($line, "\$", $index2 + 1);
 913
 914       next if $index3 < 1;
 915
 916       $index2 = index ($line, ":", $index3 + 1);
 917
 918       next if $index2 < 1;
 919
 920       $hash_in = substr ($line, 0, $index2);
 921       $word    = substr ($line, $index2 + 1);
 922
 923       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 924
 925       $salt  = substr ($hash_in, 11, $index3 - 10);
 926       $salt .= substr ($hash_in, $index2 - 32) . "\$\$";
 927       $salt .= substr ($hash_in, $index3 + 1, $index2 - $index3 - 32 - 1);
 928     }
 929     # $salt$$hash
 930     elsif ($mode == 7700 || $mode == 7800)
 931     {
 932       my $index1 = index ($line, ":");
 933
 934       next if $index1 < 1;
 935
 936       my @split1 = split (":", $line);
 937
 938       my @split2 = split ('\$', $split1[0]);
 939
 940       next unless scalar @split2 == 2;
 941
 942       $hash_in = $split1[0];
 943
 944       if (scalar @split1 > 1)
 945       {
 946         $word = $split1[1];
 947       }
 948       else
 949       {
 950         $word = "";
 951       }
 952
 953       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 954
 955       $salt = $split2[0];
 956     }
 957     # DNSSEC
 958     elsif ($mode == 8300)
 959     {
 960       my @datas = split (":", $line);
 961
 962       next if scalar @datas != 5;
 963
 964       my $hash;
 965       my $domain;
 966
 967       ($hash, $domain, $salt, $iter, $word) = @datas;
 968
 969       $hash_in = $hash . ":" . $domain . ":" . $salt . ":" . $iter;
 970
 971       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 972
 973       $salt = $domain . ":" . $salt;
 974     }
 975     # RACF
 976     elsif ($mode == 8500)
 977     {
 978       my @line_elements = split (":", $line);
 979
 980       next if scalar @line_elements < 2;
 981
 982       # get hash and word
 983
 984       $hash_in = shift @line_elements;
 985
 986       $word = join (":", @line_elements);
 987
 988       # get signature
 989
 990       my @hash_elements = split ('\*', $hash_in);
 991
 992       next unless ($hash_elements[0] eq '$racf$');
 993
 994       $salt = $hash_elements[1];
 995
 996       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
 997     }
 998     # DOMINO 6
 999     elsif ($mode == 8700)
1000     {
1001       # split hash and plain
1002       my $index = index ($line, ":");
1003
1004       next if $index < 1;
1005
1006       $hash_in = substr ($line, 0, $index);
1007       $word    = substr ($line, $index + 1);
1008
1009       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1010
1011       my $plain_base64 = substr ($hash_in, 2, -1);
1012
1013       ($_, $salt, $param) = domino_decode ($plain_base64);
1014     }
1015     # PHPS
1016     elsif ($mode == 2612)
1017     {
1018       next unless (substr ($line, 0, 6) eq '$PHPS$');
1019
1020       # get hash
1021       my $index1 = index ($line, "\$", 6);
1022
1023       next if $index1 < 1;
1024
1025       $salt = substr ($line, 6, $index1 - 6);
1026
1027       $salt = pack ("H*", $salt);
1028
1029       my $index2 = index ($line, "\:", $index1 + 1);
1030
1031       next if $index2 < 1;
1032
1033       $word = substr ($line, $index2 + 1);
1034
1035       $hash_in = substr ($line, 0, $index2);
1036
1037       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1038     }
1039     # Mediawiki B type
1040     elsif ($mode == 3711)
1041     {
1042       next unless (substr ($line, 0, 3) eq '$B$');
1043
1044       # get hash
1045       my $index1 = index ($line, "\$", 3);
1046
1047       next if $index1 < 1;
1048
1049       $salt = substr ($line, 3, $index1 - 3);
1050
1051       my $index2 = index ($line, ":", $index1 + 1);
1052
1053       next if $index2 < 1;
1054
1055       $word = substr ($line, $index2 + 1);
1056
1057       $hash_in = substr ($line, 0, $index2);
1058
1059       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1060     }
1061     # scrypt
1062     elsif ($mode == 8900)
1063     {
1064       next unless (substr ($line, 0, 7) eq 'SCRYPT:');
1065
1066       # get hash
1067       my $index1 = index ($line, ":", 7);
1068
1069       next if $index1 < 1;
1070
1071       # N
1072       my $N = substr ($line, 7, $index1 - 7);
1073
1074       my $index2 = index ($line, ":", $index1 + 1);
1075
1076       next if $index2 < 1;
1077
1078       # r
1079       my $r = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1080
1081       $index1 = index ($line, ":", $index2 + 1);
1082
1083       next if $index1 < 1;
1084
1085       # p
1086       my $p = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1087
1088       $param  = $N;
1089       $param2 = $r;
1090       $param3 = $p;
1091
1092       $index2 = index ($line, ":", $index1 + 1);
1093
1094       next if $index2 < 1;
1095
1096       # salt
1097       $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1098
1099       $salt = decode_base64 ($salt);
1100
1101       $index1 = index ($line, ":", $index2 + 1);
1102
1103       next if $index1 < 1;
1104
1105       # digest
1106
1107       $word = substr ($line, $index1 + 1);
1108       $hash_in = substr ($line, 0, $index1);
1109
1110       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1111     }
1112     # LOTUS 8
1113     elsif ($mode == 9100)
1114     {
1115       # split hash and plain
1116       my $index = index ($line, ":");
1117
1118       next if $index < 1;
1119
1120       $hash_in = substr ($line, 0, $index);
1121       $word    = substr ($line, $index + 1);
1122
1123       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1124
1125       my $base64_part = substr ($hash_in, 2, -1);
1126
1127       ($_, $salt, $iter, $param) = domino_85x_decode ($base64_part);
1128
1129       next if ($iter < 1);
1130     }
1131     # Cisco $8$ - PBKDF2-HMAC-SHA256
1132     elsif ($mode == 9200)
1133     {
1134       next unless (substr ($line, 0, 3) eq '$8$');
1135
1136       # get hash
1137       my $index1 = index ($line, "\$", 3);
1138
1139       next if $index1 != 17;
1140
1141       my $index2 = index ($line, "\$", $index1 + 1);
1142
1143       # salt
1144       $salt = substr ($line, 3,  $index1 - 3);
1145
1146       $index1 = index ($line, ":", $index1 + 1);
1147
1148       next if $index1 < 1;
1149
1150       # digest
1151
1152       $word = substr ($line, $index1 + 1);
1153       $hash_in = substr ($line, 0, $index1);
1154
1155       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1156     }
1157     # Cisco $9$ - scrypt
1158     elsif ($mode == 9300)
1159     {
1160       next unless (substr ($line, 0, 3) eq '$9$');
1161
1162       # get hash
1163       my $index1 = index ($line, "\$", 3);
1164
1165       next if $index1 != 17;
1166
1167       my $index2 = index ($line, "\$", $index1 + 1);
1168
1169       # salt
1170       $salt = substr ($line, 3,  $index1 - 3);
1171
1172       $index1 = index ($line, ":", $index1 + 1);
1173
1174       next if $index1 < 1;
1175
1176       # digest
1177
1178       $word = substr ($line, $index1 + 1);
1179       $hash_in = substr ($line, 0, $index1);
1180
1181       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1182     }
1183     # Office 2007
1184     elsif ($mode == 9400)
1185     {
1186       ($hash_in, $word) = split ":", $line;
1187
1188       next unless defined $hash_in;
1189       next unless defined $word;
1190
1191       my @data = split /\*/, $hash_in;
1192
1193       next unless scalar @data == 8;
1194
1195       next unless (shift @data eq '$office$');
1196       next unless (shift @data eq '2007');
1197       next unless (shift @data eq '20');
1198
1199       my $aes_key_size = shift @data;
1200
1201       next unless (($aes_key_size eq '128') || ($aes_key_size eq '256'));
1202       next unless (shift @data eq '16');
1203
1204       next unless (length $data[0] == 32);
1205       next unless (length $data[1] == 32);
1206       next unless (length $data[2] == 40);
1207
1208       $salt   = shift @data;
1209       $param  = shift @data;
1210       $param2 = $aes_key_size;
1211
1212       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1213     }
1214     # Office 2010
1215     elsif ($mode == 9500)
1216     {
1217       ($hash_in, $word) = split ":", $line;
1218
1219       next unless defined $hash_in;
1220       next unless defined $word;
1221
1222       my @data = split /\*/, $hash_in;
1223
1224       next unless scalar @data == 8;
1225
1226       next unless (shift @data eq '$office$');
1227       next unless (shift @data eq '2010');
1228       next unless (shift @data eq '100000');
1229       next unless (shift @data eq '128');
1230       next unless (shift @data eq '16');
1231
1232       next unless (length $data[0] == 32);
1233       next unless (length $data[1] == 32);
1234       next unless (length $data[2] == 64);
1235
1236       $salt  = shift @data;
1237       $param = shift @data;
1238
1239       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1240     }
1241     # Office 2013
1242     elsif ($mode == 9600)
1243     {
1244       ($hash_in, $word) = split ":", $line;
1245
1246       next unless defined $hash_in;
1247       next unless defined $word;
1248
1249       my @data = split /\*/, $hash_in;
1250
1251       next unless scalar @data == 8;
1252
1253       next unless (shift @data eq '$office$');
1254       next unless (shift @data eq '2013');
1255       next unless (shift @data eq '100000');
1256       next unless (shift @data eq '256');
1257       next unless (shift @data eq '16');
1258
1259       next unless (length $data[0] == 32);
1260       next unless (length $data[1] == 32);
1261       next unless (length $data[2] == 64);
1262
1263       $salt  = shift @data;
1264       $param = shift @data;
1265
1266       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1267     }
1268     # Office Old $1 $2
1269     elsif ($mode == 9700)
1270     {
1271       ($hash_in, $word) = split ":", $line;
1272
1273       next unless defined $hash_in;
1274       next unless defined $word;
1275
1276       my @data = split /\*/, $hash_in;
1277
1278       next unless scalar @data == 4;
1279
1280       my $signature = shift @data;
1281
1282       next unless (($signature eq '$oldoffice$0') || ($signature eq '$oldoffice$1'));
1283
1284       next unless (length $data[0] == 32);
1285       next unless (length $data[1] == 32);
1286       next unless (length $data[2] == 32);
1287
1288       $salt  = shift @data;
1289       $param = shift @data;
1290       $param2 = substr ($signature, 11, 1);
1291
1292       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1293     }
1294     # Office Old $3 $4
1295     elsif ($mode == 9800)
1296     {
1297       ($hash_in, $word) = split ":", $line;
1298
1299       next unless defined $hash_in;
1300       next unless defined $word;
1301
1302       my @data = split /\*/, $hash_in;
1303
1304       next unless scalar @data == 4;
1305
1306       my $signature = shift @data;
1307
1308       next unless (($signature eq '$oldoffice$3') || ($signature eq '$oldoffice$4'));
1309
1310       next unless (length $data[0] == 32);
1311       next unless (length $data[1] == 32);
1312       next unless (length $data[2] == 40);
1313
1314       $salt  = shift @data;
1315       $param = shift @data;
1316       $param2 = substr ($signature, 11, 1);
1317
1318       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1319     }
1320     # Django (PBKDF2-SHA256)
1321     elsif ($mode == 10000)
1322     {
1323       next unless (substr ($line, 0, 14) eq 'pbkdf2_sha256$');
1324
1325       # get hash
1326       my $index1 = index ($line, "\$", 14);
1327
1328       next if $index1 < 1;
1329
1330       my $index2 = index ($line, "\$", $index1 + 1);
1331
1332       # iter
1333
1334       $iter = substr ($line, 14,  $index1 - 14);
1335
1336
1337       # salt
1338       $salt = substr ($line, $index1 + 1,  $index2 - $index1 - 1);
1339
1340       # digest
1341
1342       $index1 = index ($line, ":", $index2 + 1);
1343
1344       next if $index1 < 1;
1345
1346       $word = substr ($line, $index1 + 1);
1347       $hash_in = substr ($line, 0, $index1);
1348
1349       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1350     }
1351     # SipHash
1352     elsif ($mode == 10100)
1353     {
1354       my $hash;
1355
1356       ($hash, undef, undef, $salt, $word) = split ":", $line;
1357
1358       next unless defined $hash;
1359       next unless defined $salt;
1360       next unless defined $word;
1361
1362       next unless (length $hash == 16);
1363       next unless (length $salt == 32);
1364
1365       my $hash_in = sprintf ("%s:2:4:%s", $hash, $salt);
1366
1367       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1368     }
1369     # Cram MD5
1370     elsif ($mode == 10200)
1371     {
1372       next unless (substr ($line, 0, 10) eq '$cram_md5$');
1373
1374       # get hash
1375       my $index1 = index ($line, "\$", 10);
1376
1377       next if $index1 < 1;
1378
1379       # challenge
1380
1381       my $challengeb64 = substr ($line, 10,  $index1 - 10);
1382       $salt = decode_base64 ($challengeb64);
1383
1384       # response
1385
1386       my $index2 = index ($line, ":", $index1 + 1);
1387
1388       next if $index2 < 1;
1389
1390       my $responseb64 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1391       my $response = decode_base64 ($responseb64);
1392
1393       $param = substr ($response, 0, length ($response) - 32 - 1); # -1 is for space
1394
1395       $word = substr ($line, $index2 + 1);
1396       $hash_in = substr ($line, 0, $index2);
1397
1398       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1399     }
1400     # SAP CODVN H (PWDSALTEDHASH) iSSHA-1
1401     elsif ($mode == 10300)
1402     {
1403       next unless (substr ($line, 0, 10) eq '{x-issha, ');
1404
1405       # get iterations
1406
1407       my $index1 = index ($line, "}", 10);
1408
1409       next if $index1 < 1;
1410
1411       $iter = substr ($line, 10, $index1 - 10);
1412
1413       $iter = int ($iter);
1414
1415       # base64 substring
1416
1417       my $base64_encoded = substr ($line, $index1 + 1);
1418       my $base64_decoded = decode_base64 ($base64_encoded);
1419
1420       $salt = substr ($base64_decoded, 20);
1421
1422       my $index2 = index ($line, ":", $index1 + 1);
1423
1424       next if $index2 < 1;
1425
1426       $word = substr ($line, $index2 + 1);
1427       $hash_in = substr ($line, 0, $index2);
1428
1429       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1430     }
1431     # PDF 1.1 - 1.3 (Acrobat 2 - 4)
1432     elsif ($mode == 10400)
1433     {
1434       ($hash_in, $word) = split ":", $line;
1435
1436       next unless defined $hash_in;
1437       next unless defined $word;
1438
1439       my @data = split /\*/, $hash_in;
1440
1441       next unless scalar @data == 11;
1442
1443       next unless (shift @data eq '$pdf$1');
1444       next unless (shift @data eq '2');
1445       next unless (shift @data eq '40');
1446       my $P      = shift @data;
1447       next unless (shift @data eq '0');
1448       next unless (shift @data eq '16');
1449       my $id     = shift @data;
1450       next unless (shift @data eq '32');
1451       my $u      = shift @data;
1452       next unless (shift @data eq '32');
1453       my $o      = shift @data;
1454
1455       $salt   = $id;
1456       $param  = $u;
1457       $param2 = $o;
1458       $param3 = $P;
1459
1460       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1461     }
1462     # PDF 1.4 - 1.6 (Acrobat 5 - 8)
1463     elsif ($mode == 10500)
1464     {
1465       ($hash_in, $word) = split ":", $line;
1466
1467       next unless defined $hash_in;
1468       next unless defined $word;
1469
1470       my @data = split /\*/, $hash_in;
1471
1472       next unless scalar @data == 11;
1473
1474       my $V      = shift @data; $V = substr ($V, 5, 1);
1475       my $R      = shift @data;
1476       next unless (shift @data eq '128');
1477       my $P      = shift @data;
1478       my $enc    = shift @data;
1479       next unless (shift @data eq '16');
1480       my $id     = shift @data;
1481       next unless (shift @data eq '32');
1482       my $u      = shift @data;
1483       next unless (shift @data eq '32');
1484       my $o      = shift @data;
1485
1486       $salt   = $id;
1487       $param  = $u;
1488       $param2 = $o;
1489       $param3 = $P;
1490       $param4 = $V;
1491       $param5 = $R;
1492       $param6 = $enc;
1493
1494       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1495     }
1496     # PDF 1.7 Level 3 (Acrobat 9)
1497     elsif ($mode == 10600)
1498     {
1499       ($hash_in, $word) = split ":", $line;
1500
1501       next unless defined $hash_in;
1502       next unless defined $word;
1503
1504       my @data = split /\*/, $hash_in;
1505
1506       next unless scalar @data >= 11;
1507
1508       next unless (shift @data eq '$pdf$5');
1509       next unless (shift @data eq '5');
1510       next unless (shift @data eq '256');
1511       next unless (shift @data eq '-1028');
1512       next unless (shift @data eq '1');
1513       next unless (shift @data eq '16');
1514       my $id     = shift @data;
1515       my $rest   = join "*", @data;
1516
1517       $salt   = $id;
1518       $param  = $rest;
1519
1520       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1521     }
1522     # PDF 1.7 Level 8 (Acrobat 10 - 11)
1523     elsif ($mode == 10700)
1524     {
1525       ($hash_in, $word) = split ":", $line;
1526
1527       next unless defined $hash_in;
1528       next unless defined $word;
1529
1530       my @data = split /\*/, $hash_in;
1531
1532       next unless scalar @data >= 11;
1533
1534       next unless (shift @data eq '$pdf$5');
1535       next unless (shift @data eq '6');
1536       next unless (shift @data eq '256');
1537       next unless (shift @data eq '-1028');
1538       next unless (shift @data eq '1');
1539       next unless (shift @data eq '16');
1540       my $id     = shift @data;
1541       my $rest   = join "*", @data;
1542
1543       $salt   = $id;
1544       $param  = $rest;
1545
1546       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1547     }
1548     # PBKDF2-HMAC-SHA256
1549     elsif ($mode == 10900)
1550     {
1551       next unless (substr ($line, 0, 7) eq 'sha256:');
1552
1553       # iterations
1554       my $index1 = index ($line, ":", 7);
1555
1556       next if $index1 < 1;
1557
1558       $iter = substr ($line, 7, $index1 - 7);
1559
1560       # salt
1561
1562       my $index2 = index ($line, ":", $index1 + 1);
1563
1564       next if $index2 < 1;
1565
1566       $salt = substr ($line, $index1 + 1,  $index2 - $index1 - 1);
1567
1568       $salt = decode_base64 ($salt);
1569
1570       # end of digest
1571
1572       $index1 = index ($line, ":", $index2 + 1);
1573
1574       next if $index1 < 1;
1575
1576       # additional param = output len of pbkdf2
1577
1578       my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1579
1580       my $digest = decode_base64 ($digest64_encoded);
1581
1582       $param = length ($digest);
1583
1584       # word / hash
1585
1586       $word = substr ($line, $index1 + 1);
1587       $hash_in = substr ($line, 0, $index1);
1588
1589       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1590     }
1591     # PostgreSQL MD5 Authentication
1592     elsif ($mode == 11100)
1593     {
1594       next unless (substr ($line, 0, 10) eq '$postgres$');
1595
1596       my $index1 = index ($line, "*", 10);
1597
1598       next if $index1 < 1;
1599
1600       # the user name
1601
1602       $param = substr ($line, 10, $index1 - 10);
1603
1604       # get the 4 byte salt
1605
1606       my $index2 = index ($line, "*", $index1 + 1);
1607
1608       next if $index2 < 1;
1609
1610       $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1611
1612       # word / hash
1613
1614       $index1 = index ($line, ":", $index2 + 1);
1615
1616       next if $index1 < 1;
1617
1618       $word = substr ($line, $index1 + 1);
1619       $hash_in = substr ($line, 0, $index1);
1620
1621       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1622     }
1623     # MySQL MD5 Authentication
1624     elsif ($mode == 11200)
1625     {
1626       next unless (substr ($line, 0, 9) eq '$mysqlna$');
1627
1628       my $index1 = index ($line, "*", 9);
1629
1630       next if $index1 < 1;
1631
1632       # salt
1633
1634       $salt = substr ($line, 9, $index1 - 9);
1635
1636       # word / hash
1637
1638       $index1 = index ($line, ":", $index1 + 1);
1639
1640       next if $index1 < 1;
1641
1642       $word = substr ($line, $index1 + 1);
1643       $hash_in = substr ($line, 0, $index1);
1644
1645       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1646     }
1647     # WPA/WPA2
1648     elsif ($mode == 2500)
1649     {
1650       print "ERROR: verify currently not supported for WPA/WPA2 (because of oclHashcat's output format)\n";
1651
1652       exit (1);
1653     }
1654     # Bitcoin/Litecoin wallet.dat
1655     elsif ($mode == 11300)
1656     {
1657       print "ERROR: verify currently not supported for Bitcoin/Litecoin wallet.dat because of unknown crypt data\n";
1658
1659       exit (1);
1660     }
1661     # SIP digest authentication (MD5)
1662     elsif ($mode == 11400)
1663     {
1664       next unless (substr ($line, 0, 6) eq '$sip$*');
1665
1666       # URI_server:
1667
1668       my $index1 = index ($line, "*", 6);
1669
1670       next if $index1 < 0;
1671
1672       $param10 = substr ($line, 6, $index1 - 6);
1673
1674       next if (length ($param10) > 32);
1675
1676       # URI_client:
1677
1678       my $index2 = index ($line, "*", $index1 + 1);
1679
1680       next if $index2 < 0;
1681
1682       $param11 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1683
1684       next if (length ($param11) > 32);
1685
1686       # user:
1687
1688       $index1 = index ($line, "*", $index2 + 1);
1689
1690       next if $index1 < 0;
1691
1692       $param = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1693
1694       next if (length ($param) > 12);
1695
1696       # realm:
1697
1698       $index2 = index ($line, "*", $index1 + 1);
1699
1700       next if $index2 < 0;
1701
1702       $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1703
1704       next if (length ($param2) > 20);
1705
1706       # method:
1707
1708       $index1 = index ($line, "*", $index2 + 1);
1709
1710       next if $index1 < 0;
1711
1712       $param6 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1713
1714       next if (length ($param6) > 24);
1715
1716       # URI_prefix:
1717
1718       $index2 = index ($line, "*", $index1 + 1);
1719
1720       next if $index2 < 0;
1721
1722       $param7 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1723
1724       next if (length ($param7) > 10);
1725
1726       # URI_resource:
1727
1728       $index1 = index ($line, "*", $index2 + 1);
1729
1730       next if $index1 < 0;
1731
1732       $param8 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1733
1734       next if (length ($param8) > 32);
1735
1736       # URI_suffix:
1737
1738       $index2 = index ($line, "*", $index1 + 1);
1739
1740       next if $index2 < 0;
1741
1742       $param9 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1743
1744       next if (length ($param9) > 32);
1745
1746       # nonce:
1747
1748       $index1 = index ($line, "*", $index2 + 1);
1749
1750       next if $index1 < 0;
1751
1752       $salt = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1753
1754       next if (length ($salt) > 34);
1755
1756       # nonce_client:
1757
1758       $index2 = index ($line, "*", $index1 + 1);
1759
1760       next if $index2 < 0;
1761
1762       $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1763
1764       next if (length ($param4) > 12);
1765
1766       # nonce_count:
1767
1768       $index1 = index ($line, "*", $index2 + 1);
1769
1770       next if $index1 < 0;
1771
1772       $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1773
1774       next if (length ($param3) > 10);
1775
1776       # qop:
1777
1778       $index2 = index ($line, "*", $index1 + 1);
1779
1780       next if $index2 < 0;
1781
1782       $param5 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1783
1784       next if (length ($param5) > 8);
1785
1786       # directive:
1787
1788       $index1 = index ($line, "*", $index2 + 1);
1789
1790       next if $index1 < 0;
1791
1792       my $directive = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1793
1794       next unless ($directive eq "MD5");
1795
1796       # hash_buf:
1797
1798       $index2 = index ($line, ":", $index1 + 1);
1799
1800       next if $index2 < 0;
1801
1802       my $hex_digest = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1803
1804       next unless (length ($hex_digest) == 32);
1805
1806       $word = substr ($line, $index2 + 1);
1807       $hash_in = substr ($line, 0, $index2);
1808
1809       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1810     }
1811     # 7-Zip
1812     elsif ($mode == 11600)
1813     {
1814       next unless (substr ($line, 0, 4) eq '$7z$');
1815
1816       # p
1817
1818       my $index1 = index ($line, '$', 4);
1819
1820       next if $index1 < 0;
1821
1822       my $p = substr ($line, 4, $index1 - 4);
1823
1824       next unless ($p eq "0");
1825
1826       # num cycle power
1827
1828       my $index2 = index ($line, '$', $index1 + 1);
1829
1830       next if $index2 < 0;
1831
1832       $iter = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1833
1834       # seven zip salt length
1835
1836       $index1 = index ($line, '$', $index2 + 1);
1837
1838       next if $index1 < 0;
1839
1840       $param = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1841
1842       # seven zip salt
1843
1844       $index2 = index ($line, '$', $index1 + 1);
1845
1846       next if $index2 < 0;
1847
1848       $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1849
1850       # salt len
1851
1852       $index1 = index ($line, '$', $index2 + 1);
1853
1854       next if $index1 < 0;
1855
1856       $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1857
1858       # salt
1859
1860       $index2 = index ($line, '$', $index1 + 1);
1861
1862       next if $index2 < 0;
1863
1864       $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1865
1866       $salt = pack ("H*", $salt);
1867
1868       # crc / hash
1869
1870       $index1 = index ($line, '$', $index2 + 1);
1871
1872       next if $index1 < 0;
1873
1874       my $crc = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1875
1876       # ignore this crc, we don't need to pass it to gen_hash ()
1877
1878       # data len
1879
1880       $index2 = index ($line, '$', $index1 + 1);
1881
1882       next if $index2 < 0;
1883
1884       $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1885
1886       # unpack size
1887
1888       $index1 = index ($line, '$', $index2 + 1);
1889
1890       next if $index1 < 0;
1891
1892       $param5 = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1893
1894       # data
1895
1896       $index2 = index ($line, ':', $index1 + 1);
1897
1898       next if $index2 < 0;
1899
1900       $param6 = substr ($line, $index1 + 1, $index2 - $index1 - 1);
1901       $param6 = pack ("H*", $param6);
1902
1903       $word = substr ($line, $index2 + 1);
1904       $hash_in = substr ($line, 0, $index2);
1905
1906       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1907     }
1908     # PBKDF2-HMAC-MD5
1909     elsif ($mode == 11900)
1910     {
1911       next unless (substr ($line, 0, 4) eq 'md5:');
1912
1913       # iterations
1914       my $index1 = index ($line, ":", 4);
1915
1916       next if $index1 < 1;
1917
1918       $iter = substr ($line, 4, $index1 - 4);
1919
1920       # salt
1921
1922       my $index2 = index ($line, ":", $index1 + 1);
1923
1924       next if $index2 < 1;
1925
1926       $salt = substr ($line, $index1 + 1,  $index2 - $index1 - 1);
1927
1928       $salt = decode_base64 ($salt);
1929
1930       # end of digest
1931
1932       $index1 = index ($line, ":", $index2 + 1);
1933
1934       next if $index1 < 1;
1935
1936       # additional param = output len of pbkdf2
1937
1938       my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1939
1940       my $digest = decode_base64 ($digest64_encoded);
1941
1942       $param = length ($digest);
1943
1944       # word / hash
1945
1946       $word = substr ($line, $index1 + 1);
1947       $hash_in = substr ($line, 0, $index1);
1948
1949       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1950     }
1951     # PBKDF2-HMAC-SHA1
1952     elsif ($mode == 12000)
1953     {
1954       next unless (substr ($line, 0, 5) eq 'sha1:');
1955
1956       # iterations
1957       my $index1 = index ($line, ":", 5);
1958
1959       next if $index1 < 1;
1960
1961       $iter = substr ($line, 5, $index1 - 5);
1962
1963       # salt
1964
1965       my $index2 = index ($line, ":", $index1 + 1);
1966
1967       next if $index2 < 1;
1968
1969       $salt = substr ($line, $index1 + 1,  $index2 - $index1 - 1);
1970
1971       $salt = decode_base64 ($salt);
1972
1973       # end of digest
1974
1975       $index1 = index ($line, ":", $index2 + 1);
1976
1977       next if $index1 < 1;
1978
1979       # additional param = output len of pbkdf2
1980
1981       my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
1982
1983       my $digest = decode_base64 ($digest64_encoded);
1984
1985       $param = length ($digest);
1986
1987       # word / hash
1988
1989       $word = substr ($line, $index1 + 1);
1990       $hash_in = substr ($line, 0, $index1);
1991
1992       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
1993     }
1994     # PBKDF2-HMAC-SHA512
1995     elsif ($mode == 12100)
1996     {
1997       next unless (substr ($line, 0, 7) eq 'sha512:');
1998
1999       # iterations
2000       my $index1 = index ($line, ":", 7);
2001
2002       next if $index1 < 1;
2003
2004       $iter = substr ($line, 7, $index1 - 7);
2005
2006       # salt
2007
2008       my $index2 = index ($line, ":", $index1 + 1);
2009
2010       next if $index2 < 1;
2011
2012       $salt = substr ($line, $index1 + 1,  $index2 - $index1 - 1);
2013
2014       $salt = decode_base64 ($salt);
2015
2016       # end of digest
2017
2018       $index1 = index ($line, ":", $index2 + 1);
2019
2020       next if $index1 < 1;
2021
2022       # additional param = output len of pbkdf2
2023
2024       my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1);
2025
2026       my $digest = decode_base64 ($digest64_encoded);
2027
2028       $param = length ($digest);
2029
2030       # word / hash
2031
2032       $word = substr ($line, $index1 + 1);
2033       $hash_in = substr ($line, 0, $index1);
2034
2035       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2036     }
2037     # ecryptfs
2038     elsif ($mode == 12200)
2039     {
2040       next unless (substr ($line, 0, 12) eq '$ecryptfs$0$');
2041
2042       # check if default salt
2043
2044       $param = 1;
2045
2046       $param = 0 if (substr ($line, 12, 2) eq '1$');
2047
2048       # salt
2049
2050       $salt = "";
2051
2052       my $index1 = 12;
2053
2054       if ($param == 0) # we need to extract the salt
2055       {
2056         $index1 = index ($line, '$', $index1);
2057
2058         next if $index1 < 1;
2059
2060         my $index2 = index ($line, '$', $index1 + 1);
2061
2062         next if $index2 < 1;
2063
2064         $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1);
2065
2066         $index1 = $index2;
2067       }
2068
2069       $index1 = index ($line, ':', $index1 + 1);
2070
2071       next if $index1 < 1;
2072
2073       # word / hash
2074
2075       $word = substr ($line, $index1 + 1);
2076       $hash_in = substr ($line, 0, $index1);
2077
2078       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2079     }
2080     # Oracle T: Type (Oracle 12+)
2081     elsif ($mode == 12300)
2082     {
2083       my $index1 = index ($line, ':');
2084
2085       next if ($index1 != 160);
2086
2087       # salt
2088
2089       $salt = substr ($line, 128, 32);
2090
2091       # word / hash
2092
2093       $word = substr ($line, $index1 + 1);
2094       $hash_in = substr ($line, 0, $index1);
2095
2096       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2097     }
2098     # BSDiCrypt, Extended DES
2099     elsif ($mode == 12400)
2100     {
2101       next unless (substr ($line, 0, 1) eq '_');
2102
2103       my $index1 = index ($line, ':', 20);
2104
2105       next if ($index1 != 20);
2106
2107       # iter
2108
2109       $iter = substr ($line, 1, 4);
2110
2111       $iter = base64_to_int24 ($iter);
2112
2113       # salt
2114
2115       $salt = substr ($line, 5, 4);
2116
2117       # word / hash
2118
2119       $word = substr ($line, $index1 + 1);
2120       $hash_in = substr ($line, 0, $index1);
2121
2122       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2123     }
2124     # Blockchain, My Wallet
2125     elsif ($mode == 12700)
2126     {
2127       my $index1 = index ($line, ':');
2128
2129       next if ($index1 < 0);
2130
2131       $hash_in = substr ($line, 0, $index1);
2132       $word = substr ($line, $index1 + 1);
2133
2134       my (undef, $signature, $data_len, $data_buf) = split '\$', $hash_in;
2135
2136       next unless ($signature eq "blockchain");
2137
2138       next unless (($data_len * 2) == length $data_buf);
2139
2140       $salt  = substr ($data_buf, 0, 32);
2141       $param = substr ($data_buf, 32);
2142
2143       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2144     }
2145     elsif ($mode == 12800)
2146     {
2147       ($hash_in, $word) = split ":", $line;
2148
2149       next unless defined $hash_in;
2150       next unless defined $word;
2151
2152       my @data = split /\,/, $hash_in;
2153
2154       next unless scalar @data == 4;
2155
2156       next unless (shift @data eq 'v1;PPH1_MD4');
2157
2158       $salt = shift @data;
2159       $iter = shift @data;
2160
2161       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2162     }
2163     elsif ($mode == 12900)
2164     {
2165       ($hash_in, $word) = split ":", $line;
2166
2167       next unless defined $hash_in;
2168       next unless defined $word;
2169
2170       next unless length $hash_in == 160;
2171
2172       $param = substr ($hash_in, 0, 64);
2173       $salt  = substr ($hash_in, 128, 32);
2174       $iter  = 4096;
2175
2176       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2177     }
2178     elsif ($mode == 13000)
2179     {
2180       my $hash_line;
2181
2182       ($hash_line, $word) = split ":", $line;
2183
2184       next unless defined $hash_line;
2185       next unless defined $word;
2186
2187       my @data = split ('\$', $hash_line);
2188
2189       next unless scalar @data == 8;
2190
2191       shift @data;
2192
2193       my $signature    = shift @data;
2194       my $salt_len     = shift @data;
2195       my $salt_buf     = shift @data;
2196       my $iterations   = shift @data;
2197       my $iv           = shift @data;
2198       my $pswcheck_len = shift @data;
2199       my $pswcheck     = shift @data;
2200
2201       next unless ($signature eq "rar5");
2202       next unless ($salt_len == 16);
2203       next unless ($pswcheck_len == 8);
2204
2205       $salt    = $salt_buf;
2206       $iter    = $iterations;
2207       $hash_in = $pswcheck;
2208       $param   = $iv;
2209
2210       next unless (exists ($db->{$hash_line}) and (! defined ($db->{$hash_line})));
2211     }
2212     elsif ($mode == 13100 )
2213     {
2214       ($hash_in, $word) = split ":", $line;
2215
2216       next unless defined $hash_in;
2217       next unless defined $word;
2218
2219       my @data = split ('\$', $hash_in);
2220
2221       next unless scalar @data == 8;
2222
2223       shift @data;
2224
2225       my $signature = shift @data;
2226       my $algorithm = shift @data;
2227       my $user      = shift @data;
2228       $user         = substr ($user, 1);
2229       my $realm     = shift @data;
2230       my $spn       = shift @data;
2231       $spn          = substr ($spn, 0, length ($spn) - 1);
2232       my $checksum  = shift @data;
2233       my $edata2    = shift @data;
2234
2235       next unless ($signature eq "krb5tgs");
2236       next unless (length ($checksum) == 32);
2237       next unless (length ($edata2) == 64);
2238
2239       $salt = $user . '$' . $realm . '$' . $spn . '$' . substr ($edata2, 0, 16);
2240
2241       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2242     }
2243     else
2244     {
2245       print "ERROR: hash mode is not supported\n";
2246
2247       exit (1);
2248     }
2249
2250     if ($word =~ m/^\$HEX\[[0-9a-fA-F]*\]$/)
2251     {
2252       $word = pack ("H*", substr ($word, 5, -1));
2253     }
2254
2255     # finally generate the hash
2256
2257     # special case:
2258     if ($mode == 6800)
2259     {
2260       # check both variations
2261       $hash_out = gen_hash ($mode, $word, $salt, $iter, 1);
2262
2263       $len = length $hash_out; # == length $alternative
2264
2265       if (substr ($line, 0, $len) ne $hash_out)
2266       {
2267         my $alternative = gen_hash ($mode, $word, $salt, $iter, 2);
2268
2269         return unless (substr ($line, 0, $len) eq $alternative);
2270       }
2271     }
2272     elsif ($mode == 8700)
2273     {
2274       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2275
2276       $len = length $hash_out;
2277
2278       return unless (substr ($line, 0, $len) eq $hash_out);
2279     }
2280     elsif ($mode == 8900)
2281     {
2282       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3);
2283
2284       $len = length $hash_out;
2285
2286       return unless (substr ($line, 0, $len) eq $hash_out);
2287     }
2288     elsif ($mode == 9100)
2289     {
2290       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2291
2292       $len = length $hash_out;
2293
2294       return unless (substr ($line, 0, $len) eq $hash_out);
2295     }
2296     elsif ($mode == 190)
2297     {
2298       $hash_out = gen_hash ($mode, $word, $salt, $iter, 0);
2299
2300       $len = length $hash_out; # == length $alternative
2301
2302       if (substr ($line, 0, $len) ne $hash_out)
2303       {
2304         my $alternative = gen_hash ($mode, $word, $salt, $iter, 1);
2305
2306         return unless (substr ($line, 0, $len) eq $alternative);
2307       }
2308     }
2309     elsif ($mode == 3300)
2310     {
2311       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2312
2313       $len = length $hash_out;
2314
2315       return unless (substr ($line, 0, $len) eq $hash_out);
2316     }
2317     elsif ($mode == 5100)
2318     {
2319       # check 3 variants (start, middle, end)
2320
2321       my $idx = 0;
2322
2323       $hash_out = gen_hash ($mode, $word, $salt, $iter, $idx++);
2324
2325       $len = length $hash_out; # == length $alternative
2326
2327       if (substr ($line, 0, $len) ne $hash_out)
2328       {
2329         my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++);
2330
2331         if (substr ($line, 0, $len) ne $alternative)
2332         {
2333           my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++);
2334
2335           return unless (substr ($line, 0, $len) eq $alternative);
2336         }
2337       }
2338     }
2339     elsif ($mode == 9400)
2340     {
2341       $hash_out = gen_hash ($mode, $word, $salt, 50000, $param, $param2);
2342
2343       $len = length $hash_out;
2344
2345       return unless (substr ($line, 0, $len) eq $hash_out);
2346     }
2347     elsif ($mode == 9500)
2348     {
2349       $hash_out = gen_hash ($mode, $word, $salt, 100000, $param);
2350
2351       $len = length $hash_out;
2352
2353       return unless (substr ($line, 0, $len) eq $hash_out);
2354     }
2355     elsif ($mode == 9600)
2356     {
2357       $hash_out = gen_hash ($mode, $word, $salt, 100000, $param);
2358
2359       $len = length $hash_out;
2360
2361       return unless (substr ($line, 0, $len) eq $hash_out);
2362     }
2363     elsif ($mode == 9700)
2364     {
2365       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2);
2366
2367       $len = length $hash_out;
2368
2369       return unless (substr ($line, 0, $len) eq $hash_out);
2370     }
2371     elsif ($mode == 9800)
2372     {
2373       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2);
2374
2375       $len = length $hash_out;
2376
2377       return unless (substr ($line, 0, $len) eq $hash_out);
2378     }
2379     elsif ($mode == 10400)
2380     {
2381       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3);
2382
2383       $len = length $hash_out;
2384
2385       return unless (substr ($line, 0, $len) eq $hash_out);
2386     }
2387     elsif ($mode == 10500)
2388     {
2389       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3, $param4, $param5, $param6);
2390
2391       $len = length $hash_out;
2392
2393       return unless (substr ($line, 0, $len) eq $hash_out);
2394     }
2395     elsif ($mode == 10600)
2396     {
2397       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2398
2399       $len = length $hash_out;
2400
2401       return unless (substr ($line, 0, $len) eq $hash_out);
2402     }
2403     elsif ($mode == 10700)
2404     {
2405       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2406
2407       $len = length $hash_out;
2408
2409       return unless (substr ($line, 0, $len) eq $hash_out);
2410     }
2411     elsif ($mode == 10900)
2412     {
2413       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2414
2415       $len = length $hash_out;
2416
2417       return unless (substr ($line, 0, $len) eq $hash_out);
2418     }
2419     elsif ($mode == 11100)
2420     {
2421       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2422
2423       $len = length $hash_out;
2424
2425       return unless (substr ($line, 0, $len) eq $hash_out);
2426     }
2427     elsif ($mode == 11400)
2428     {
2429       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6, $param7, $param8, $param9, $param10, $param11);
2430
2431       $len = length $hash_out;
2432
2433       return unless (substr ($line, 0, $len) eq $hash_out);
2434     }
2435     elsif ($mode == 11600)
2436     {
2437       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6);
2438
2439       $len = length $hash_out;
2440
2441       return unless (substr ($line, 0, $len) eq $hash_out);
2442     }
2443     elsif ($mode == 11900)
2444     {
2445       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2446
2447       $len = length $hash_out;
2448
2449       return unless (substr ($line, 0, $len) eq $hash_out);
2450     }
2451     elsif ($mode == 12000)
2452     {
2453       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2454
2455       $len = length $hash_out;
2456
2457       return unless (substr ($line, 0, $len) eq $hash_out);
2458     }
2459     elsif ($mode == 12100)
2460     {
2461       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2462
2463       $len = length $hash_out;
2464
2465       return unless (substr ($line, 0, $len) eq $hash_out);
2466     }
2467     elsif ($mode == 12200)
2468     {
2469       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2470
2471       $len = length $hash_out;
2472
2473       return unless (substr ($line, 0, $len) eq $hash_out);
2474     }
2475     elsif ($mode == 12700)
2476     {
2477       # this is very special, we can't call gen_hash () because the param part is not always the same
2478       # we only know that it should contain the letters "guid" at the beginning of the decryted string
2479
2480       my $pbkdf2 = Crypt::PBKDF2->new (
2481         hash_class => 'HMACSHA1',
2482         iterations   => 10,
2483         output_len   => 32
2484       );
2485
2486       my $salt_bin = pack ("H*", $salt);
2487
2488       my $key = $pbkdf2->PBKDF2 ($salt_bin, $word);
2489
2490       my $cipher = Crypt::CBC->new ({
2491         key         => $key,
2492         cipher      => "Crypt::Rijndael",
2493         iv          => $salt_bin,
2494         literal_key => 1,
2495         header      => "none",
2496         keysize     => 32
2497       });
2498
2499       my $param_bin = pack ("H*", $param);
2500
2501       my $decrypted = $cipher->decrypt ($param_bin);
2502
2503       my $decrypted_part = substr ($decrypted, 1, 16);
2504
2505       return unless ($decrypted_part =~ /"guid"/);
2506
2507       $hash_out = $hash_in;
2508     }
2509     elsif ($mode == 12900)
2510     {
2511       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2512
2513       $len = length $hash_out;
2514
2515       return unless (substr ($line, 0, $len) eq $hash_out);
2516     }
2517     elsif ($mode == 13000)
2518     {
2519       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2520
2521       $len = length $hash_out;
2522
2523       return unless (substr ($line, 0, $len) eq $hash_out);
2524     }
2525     elsif ($mode == 13100)
2526     {
2527       $hash_out = gen_hash ($mode, $word, $salt);
2528
2529       $len = length $hash_out;
2530
2531       return unless (substr ($line, 0, $len) eq $hash_out);
2532     }
2533     else
2534     {
2535       $hash_out = gen_hash ($mode, $word, $salt, $iter);
2536
2537       $len = length $hash_out;
2538
2539       # special cases:
2540       if ($mode == 400)
2541       {
2542         # allow $P$ and $H$ for -m 400
2543         next unless (substr ($line, 3, $len - 3) eq substr ($hash_out, 3));
2544       }
2545       elsif ($mode == 5600)
2546       {
2547         # oclHashcat outputs the user name always upper-case, we need
2548         next unless (substr ($line, 0, $len) eq $hash_out);
2549
2550         my $found = 0;
2551
2552         my $hash_out_lower = lc ($hash_out);
2553
2554         for my $key (keys %{$db})
2555         {
2556           if (lc ($key) eq $hash_out_lower)
2557           {
2558             $found = 1;
2559
2560             last;
2561           }
2562         }
2563
2564         next unless $found;
2565       }
2566       else
2567       {
2568         next unless (substr ($line, 0, $len) eq $hash_out);
2569       }
2570     }
2571
2572     # do not forget "exists ($db->$hash_out)" should be done above!
2573     $db->{$hash_out} = $word;
2574     print OUT $line . "\n";
2575   }
2576
2577   close (IN);
2578   close (OUT);
2579 }
2580
2581 sub passthrough
2582 {
2583   my $mode = shift || 0;
2584
2585   while (my $word_buf = <>)
2586   {
2587     chomp ($word_buf);
2588
2589     next if length ($word_buf) > 31;
2590
2591     ##
2592     ## gen salt
2593     ##
2594
2595     my @salt_arr;
2596
2597     for (my $i = 0; $i < 256; $i++)
2598     {
2599       my $c = get_random_chr (0x30, 0x39);
2600
2601       push (@salt_arr, $c);
2602     }
2603
2604     my $salt_buf = join ("", @salt_arr);
2605
2606     ##
2607     ## gen hash
2608     ##
2609
2610     my $tmp_hash;
2611
2612     if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 190 || $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)
2613     {
2614       $tmp_hash = gen_hash ($mode, $word_buf, "");
2615     }
2616     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)
2617     {
2618       my $salt_len = get_random_num (1, 15);
2619
2620       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2621     }
2622     elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
2623     {
2624       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2625     }
2626     elsif ($mode == 21)
2627     {
2628       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2));
2629     }
2630     elsif ($mode == 22)
2631     {
2632       my $salt_len = get_random_num (1, 11);
2633
2634       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2635     }
2636     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)
2637     {
2638       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 8));
2639     }
2640     elsif ($mode == 112)
2641     {
2642       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20));
2643     }
2644     elsif ($mode == 121)
2645     {
2646       my $salt_len = get_random_num (1, 9);
2647
2648       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2649     }
2650     elsif ($mode == 141 || $mode == 1441)
2651     {
2652       my $salt_len = get_random_num (1, 15);
2653
2654       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2655     }
2656     elsif ($mode == 1100)
2657     {
2658       my $salt_len = get_random_num (1, 19);
2659
2660       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2661     }
2662     elsif ($mode == 1500)
2663     {
2664       next if length ($word_buf) > 8;
2665
2666       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2));
2667     }
2668     elsif ($mode == 2100)
2669     {
2670       next if length ($word_buf) > 13;
2671
2672       my $salt_len = get_random_num (1, 19);
2673
2674       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2675     }
2676     elsif ($mode == 2410)
2677     {
2678       next if length ($word_buf) > 15;
2679
2680       my $salt_len = get_random_num (1, 15);
2681
2682       my $word_len = length ($word_buf);
2683
2684       $salt_len = min ($salt_len, 15 - $word_len);
2685
2686       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2687     }
2688     elsif ($mode == 2500)
2689     {
2690       next if length ($word_buf) < 8;
2691
2692       my $salt_len = get_random_num (0, 32);
2693
2694       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2695     }
2696     elsif ($mode == 2611)
2697     {
2698       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 3));
2699     }
2700     elsif ($mode == 2612)
2701     {
2702       my $salt_len = get_random_num (1, 22);
2703
2704       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2705     }
2706     elsif ($mode == 2711)
2707     {
2708       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 30));
2709     }
2710     elsif ($mode == 2811)
2711     {
2712       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5));
2713     }
2714     elsif ($mode == 3000)
2715     {
2716       next if length ($word_buf) > 7;
2717
2718       $tmp_hash = gen_hash ($mode, $word_buf, "");
2719     }
2720     elsif ($mode == 3100)
2721     {
2722       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 10));
2723     }
2724     elsif ($mode == 3200 || $mode == 5800 || $mode == 6400 || $mode == 6500 || $mode == 6700 || $mode == 7400 || $mode == 3300 || $mode == 8000 || $mode == 9100 || $mode == 12200)
2725     {
2726       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16));
2727     }
2728     elsif ($mode == 3800 || $mode == 4900)
2729     {
2730       my $salt_len = get_random_num (1, 11);
2731
2732       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2733     }
2734     elsif ($mode == 4800)
2735     {
2736       $salt_buf = get_random_md5chap_salt (substr ($salt_buf, 0, 16));
2737
2738       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2739     }
2740     elsif ($mode == 5300 || $mode == 5400)
2741     {
2742       $salt_buf = get_random_ike_salt ();
2743
2744       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2745     }
2746     elsif ($mode == 5500)
2747     {
2748       my $user_len   = get_random_num (0, 15);
2749       my $domain_len = get_random_num (0, 15);
2750
2751       $salt_buf = get_random_netntlmv1_salt ($user_len, $domain_len);
2752
2753       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2754     }
2755     elsif ($mode == 5600)
2756     {
2757       my $user_len   = get_random_num (0, 15);
2758       my $domain_len = get_random_num (0, 15);
2759
2760       $salt_buf = get_random_netntlmv2_salt ($user_len, $domain_len);
2761
2762       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2763     }
2764     elsif ($mode == 6600)
2765     {
2766       $salt_buf = get_random_agilekeychain_salt ();
2767
2768       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2769     }
2770     elsif ($mode == 6800)
2771     {
2772       my $email_len = get_random_num (1, 15);
2773
2774       my $email = "";
2775
2776       for (my $i = 0; $i < $email_len; $i++)
2777       {
2778         $email .= get_random_chr (0x61, 0x7a);
2779       }
2780
2781       $email .= '@trash-mail.com';
2782
2783       $tmp_hash = gen_hash ($mode, $word_buf, $email);
2784     }
2785     elsif ($mode == 7100)
2786     {
2787       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64));
2788     }
2789     elsif ($mode == 7200)
2790     {
2791       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 128));
2792     }
2793     elsif ($mode == 7300)
2794     {
2795       my $salt_len = get_random_num (32, 256);
2796
2797       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2798     }
2799     elsif ($mode == 7500)
2800     {
2801       $salt_buf = get_random_kerberos5_salt (substr ($salt_buf, 0, 16));
2802
2803       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2804     }
2805     elsif ($mode == 7700)
2806     {
2807       next if length ($word_buf) > 8;
2808
2809       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12));
2810     }
2811     elsif ($mode == 7800)
2812     {
2813       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12));
2814     }
2815     elsif ($mode == 8200)
2816     {
2817       $salt_buf = get_random_cloudkeychain_salt ();
2818
2819       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2820     }
2821     elsif ($mode == 8300)
2822     {
2823       $salt_buf = get_random_dnssec_salt ();
2824
2825       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2826     }
2827     elsif ($mode == 8400 || $mode == 11200)
2828     {
2829       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 40));
2830     }
2831     elsif ($mode == 8500)
2832     {
2833       next if length ($word_buf) > 8;
2834
2835       my $salt_len = get_random_num (1, 9);
2836
2837       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2838     }
2839     elsif ($mode == 8600)
2840     {
2841       next if length ($word_buf) > 16;
2842
2843       $tmp_hash = gen_hash ($mode, $word_buf, "");
2844     }
2845     elsif ($mode == 8700)
2846     {
2847       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5));
2848     }
2849     elsif ($mode == 9200 || $mode == 9300)
2850     {
2851       my $salt_len = 14;
2852
2853       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2854     }
2855     elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
2856     {
2857       next if length ($word_buf) > 19;
2858
2859       my $salt_len = 32;
2860
2861       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2862     }
2863     elsif ($mode == 10100)
2864     {
2865       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2866     }
2867     elsif ($mode == 10300)
2868     {
2869       my $salt_len = get_random_num (4, 15);
2870
2871       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2872     }
2873     elsif ($mode == 10400)
2874     {
2875       next if length ($word_buf) > 31;
2876
2877       my $salt_len = 32;
2878
2879       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2880     }
2881     elsif ($mode == 10500)
2882     {
2883       next if length ($word_buf) > 15;
2884
2885       my $salt_len = 32;
2886
2887       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2888     }
2889     elsif ($mode == 10600)
2890     {
2891       next if length ($word_buf) > 31;
2892
2893       my $salt_len = 32;
2894
2895       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2896     }
2897     elsif ($mode == 10700)
2898     {
2899       next if length ($word_buf) > 15;
2900
2901       my $salt_len = 32;
2902
2903       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2904     }
2905     elsif ($mode == 11000)
2906     {
2907       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 56));
2908     }
2909     elsif ($mode == 11300)
2910     {
2911       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16));
2912     }
2913     elsif ($mode == 11400)
2914     {
2915       next if length ($word_buf) > 24;
2916
2917       my $salt_len = get_random_num (1, 15);
2918
2919       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2920     }
2921     elsif ($mode == 11600)
2922     {
2923       my $salt_len = get_random_num (0, 16);
2924
2925       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2926     }
2927     elsif ($mode == 12400)
2928     {
2929       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 4));
2930     }
2931     elsif ($mode == 12600)
2932     {
2933       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64));
2934     }
2935     elsif ($mode == 12700)
2936     {
2937       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2938     }
2939     elsif ($mode == 12800)
2940     {
2941       next if length ($word_buf) > 24;
2942
2943       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20));
2944     }
2945     elsif ($mode == 12900)
2946     {
2947       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2948     }
2949     elsif ($mode == 13000)
2950     {
2951       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2952     }
2953     elsif ($mode == 13100)
2954     {
2955       $salt_buf = get_random_kerberos5_tgs_salt ();
2956
2957       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2958     }
2959     else
2960     {
2961       print "ERROR: Unsupported hash type\n";
2962
2963       exit (1);
2964     }
2965
2966     print $tmp_hash, "\n";
2967   }
2968 }
2969
2970 sub single
2971 {
2972   my $mode = shift;
2973
2974   if (defined $mode)
2975   {
2976     @modes = ($mode);
2977   }
2978
2979   for (my $j = 0; $j < scalar @modes; $j++)
2980   {
2981     my $mode = $modes[$j];
2982
2983     if ($mode == 0 || $mode == 100 || $mode == 101 || $mode == 190 || $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)
2984     {
2985       for (my $i = 1; $i < 32; $i++)
2986       {
2987         if ($len != 0)
2988         {
2989           rnd ($mode, $len, 0);
2990         }
2991         else
2992         {
2993           rnd ($mode, $i, 0);
2994         }
2995       }
2996     }
2997     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)
2998     {
2999       my $salt_len = get_random_num (1, 15);
3000
3001       for (my $i = 1; $i < 32; $i++)
3002       {
3003         if ($len != 0)
3004         {
3005           rnd ($mode, $len, $salt_len);
3006         }
3007         else
3008         {
3009           rnd ($mode, $i, $salt_len);
3010         }
3011       }
3012     }
3013     elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
3014     {
3015       for (my $i = 1; $i < 32; $i++)
3016       {
3017         if ($len != 0)
3018         {
3019           rnd ($mode, $len, 32);
3020         }
3021         else
3022         {
3023           rnd ($mode, $i, 32);
3024         }
3025       }
3026     }
3027     elsif ($mode == 21 || $mode == 22)
3028     {
3029       for (my $i = 1; $i < 32; $i++)
3030       {
3031         if ($len != 0)
3032         {
3033           rnd ($mode, $len, 2);
3034         }
3035         else
3036         {
3037           rnd ($mode, $i, 2);
3038         }
3039       }
3040     }
3041     elsif ($mode == 111 || $mode == 122 || $mode == 131 || $mode == 132 || $mode == 400 || $mode == 500 || $mode == 1600 || $mode == 1722 || $mode == 1731 || $mode == 6300 || $mode == 7900 || $mode == 8100 || $mode == 11100)
3042     {
3043       for (my $i = 1; $i < 32; $i++)
3044       {
3045         if ($len != 0)
3046         {
3047           rnd ($mode, $len, 8);
3048         }
3049         else
3050         {
3051           rnd ($mode, $i, 8);
3052         }
3053       }
3054     }
3055     elsif ($mode == 112)
3056     {
3057       for (my $i = 1; $i < 32; $i++)
3058       {
3059         if ($len != 0)
3060         {
3061           rnd ($mode, $len, 20);
3062         }
3063         else
3064         {
3065           rnd ($mode, $i, 20);
3066         }
3067       }
3068     }
3069     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)
3070     {
3071       for (my $i = 1; $i < 32; $i++)
3072       {
3073         if ($len != 0)
3074         {
3075           rnd ($mode, $len, 16);
3076         }
3077         else
3078         {
3079           rnd ($mode, $i, 16);
3080         }
3081       }
3082     }
3083     if ($mode == 1100)
3084     {
3085       my $salt_len = get_random_num (1, 19);
3086
3087       for (my $i = 1; $i < 32; $i++)
3088       {
3089         if ($len != 0)
3090         {
3091           rnd ($mode, $len, $salt_len);
3092         }
3093         else
3094         {
3095           rnd ($mode, $i, $salt_len);
3096         }
3097       }
3098     }
3099     elsif ($mode == 1500)
3100     {
3101       for (my $i = 1; $i < 9; $i++)
3102       {
3103         if ($len != 0)
3104         {
3105           rnd ($mode, $len, 2);
3106         }
3107         else
3108         {
3109           rnd ($mode, $i, 2);
3110         }
3111       }
3112     }
3113     elsif ($mode == 2100)
3114     {
3115       my $salt_len = get_random_num (1, 19);
3116
3117       for (my $i = 1; $i < 13; $i++)
3118       {
3119         if ($len != 0)
3120         {
3121           rnd ($mode, $len, $salt_len);
3122         }
3123         else
3124         {
3125           rnd ($mode, $i, $salt_len);
3126         }
3127       }
3128     }
3129     elsif ($mode == 2500)
3130     {
3131       my $salt_len = get_random_num (0, 32);
3132
3133       for (my $i = 8; $i < 16; $i++)
3134       {
3135         my $generate_from_len = 0;
3136
3137         if ($len != 0)
3138         {
3139           if ($len < 8)
3140           {
3141             $len += 7;
3142           }
3143
3144           rnd ($mode, $len, $salt_len);
3145         }
3146         else
3147         {
3148           rnd ($mode, $i, $salt_len);
3149         }
3150       }
3151     }
3152     elsif ($mode == 2611)
3153     {
3154       for (my $i = 1; $i < 32; $i++)
3155       {
3156         if ($len != 0)
3157         {
3158           rnd ($mode, $len, 3);
3159         }
3160         else
3161         {
3162           rnd ($mode, $i, 3);
3163         }
3164       }
3165     }
3166     elsif ($mode == 2612)
3167     {
3168       my $salt_len = get_random_num (1, 22);
3169
3170       for (my $i = 1; $i < 32; $i++)
3171       {
3172         if ($len != 0)
3173         {
3174           rnd ($mode, $len, $salt_len);
3175         }
3176         else
3177         {
3178           rnd ($mode, $i, $salt_len);
3179         }
3180       }
3181     }
3182     elsif ($mode == 2711)
3183     {
3184       for (my $i = 1; $i < 32; $i++)
3185       {
3186         if ($len != 0)
3187         {
3188           rnd ($mode, $len, 30);
3189         }
3190         else
3191         {
3192           rnd ($mode, $i, 30);
3193         }
3194       }
3195     }
3196     elsif ($mode == 2811)
3197     {
3198       for (my $i = 1; $i < 32; $i++)
3199       {
3200         if ($len != 0)
3201         {
3202           rnd ($mode, $len, 5);
3203         }
3204         else
3205         {
3206           rnd ($mode, $i, 5);
3207         }
3208       }
3209     }
3210     elsif ($mode == 3000)
3211     {
3212       for (my $i = 1; $i < 8; $i++)
3213       {
3214         if ($len != 0)
3215         {
3216           rnd ($mode, $len, 0);
3217         }
3218         else
3219         {
3220           rnd ($mode, $i, 0);
3221         }
3222       }
3223     }
3224     elsif ($mode == 3100)
3225     {
3226       for (my $i = 1; $i < 32; $i++)
3227       {
3228         if ($len != 0)
3229         {
3230           rnd ($mode, $len, 10);
3231         }
3232         else
3233         {
3234           rnd ($mode, $i, 10);
3235         }
3236       }
3237     }
3238     elsif ($mode == 3800 || $mode == 4900)
3239     {
3240       my $salt_len = get_random_num (1, 11);
3241
3242       for (my $i = 1; $i < 32; $i++)
3243       {
3244         if ($len != 0)
3245         {
3246           rnd ($mode, $len, $salt_len);
3247         }
3248         else
3249         {
3250           rnd ($mode, $i, $salt_len);
3251         }
3252       }
3253     }
3254     elsif ($mode == 5500 || $mode == 5600)
3255     {
3256       my $salt_len;
3257
3258       for (my $i = 1; $i < 27; $i++)
3259       {
3260         $salt_len = get_random_num (1, 15);
3261
3262         if ($len != 0)
3263         {
3264           rnd ($mode, $len, $salt_len);
3265         }
3266         else
3267         {
3268           rnd ($mode, $i, $salt_len);
3269         }
3270       }
3271     }
3272     elsif ($mode == 5800)
3273     {
3274       for (my $i = 1; $i < 14; $i++)
3275       {
3276         if ($len != 0)
3277         {
3278           rnd ($mode, $len, 16);
3279         }
3280         else
3281         {
3282           rnd ($mode, $i, 16);
3283         }
3284       }
3285     }
3286     elsif ($mode == 6800)
3287     {
3288       my $salt_len = get_random_num (8, 25);
3289
3290       for (my $i = 1; $i < 32; $i++)
3291       {
3292         if ($len != 0)
3293         {
3294           rnd ($mode, $len, $salt_len);
3295         }
3296         else
3297         {
3298           rnd ($mode, $i, $salt_len);
3299         }
3300       }
3301     }
3302     elsif ($mode == 7100)
3303     {
3304       for (my $i = 1; $i < 32; $i++)
3305       {
3306         if ($len != 0)
3307         {
3308           rnd ($mode, $len, 64);
3309         }
3310         else
3311         {
3312           rnd ($mode, $i, 64);
3313         }
3314       }
3315     }
3316     elsif ($mode == 7200)
3317     {
3318       for (my $i = 1; $i < 32; $i++)
3319       {
3320         if ($len != 0)
3321         {
3322           rnd ($mode, $len, 128);
3323         }
3324         else
3325         {
3326           rnd ($mode, $i, 128);
3327         }
3328       }
3329     }
3330     elsif ($mode == 7300)
3331     {
3332       my $salt_len = get_random_num (32, 255);
3333
3334       for (my $i = 1; $i < 32; $i++)
3335       {
3336         if ($len != 0)
3337         {
3338           rnd ($mode, $len, $salt_len);
3339         }
3340         else
3341         {
3342           rnd ($mode, $i, $salt_len);
3343         }
3344       }
3345     }
3346     elsif ($mode == 7500)
3347     {
3348       for (my $i = 1; $i < 27; $i++)
3349       {
3350         if ($len != 0)
3351         {
3352           rnd ($mode, $len, 16);
3353         }
3354         else
3355         {
3356           rnd ($mode, $i, 16);
3357         }
3358       }
3359     }
3360     elsif ($mode == 7700)
3361     {
3362       my $salt_len = get_random_num (1, 12);
3363
3364       for (my $i = 1; $i < 9; $i++)
3365       {
3366         if ($len != 0)
3367         {
3368           rnd ($mode, $len, $salt_len);
3369         }
3370         else
3371         {
3372           rnd ($mode, $i, $salt_len);
3373         }
3374       }
3375     }
3376     elsif ($mode == 7800)
3377     {
3378       my $salt_len = get_random_num (1, 12);
3379
3380       for (my $i = 1; $i < 32; $i++)
3381       {
3382         if ($len != 0)
3383         {
3384           rnd ($mode, $len, $salt_len);
3385         }
3386         else
3387         {
3388           rnd ($mode, $i, $salt_len);
3389         }
3390       }
3391     }
3392     elsif ($mode == 8400 || $mode == 11200)
3393     {
3394       for (my $i = 1; $i < 32; $i++)
3395       {
3396         if ($len != 0)
3397         {
3398           rnd ($mode, $len, 40);
3399         }
3400         else
3401         {
3402           rnd ($mode, $i, 40);
3403         }
3404       }
3405     }
3406     elsif ($mode == 8500)
3407     {
3408       my $salt_len = get_random_num (1, 8);
3409
3410       for (my $i = 1; $i < 9; $i++)
3411       {
3412         if ($len != 0)
3413         {
3414           rnd ($mode, $len, $salt_len);
3415         }
3416         else
3417         {
3418           rnd ($mode, $i, $salt_len);
3419         }
3420       }
3421     }
3422     elsif ($mode == 8600)
3423     {
3424       for (my $i = 1; $i < 17; $i++)
3425       {
3426         if ($len != 0)
3427         {
3428           rnd ($mode, $len, 0);
3429         }
3430         else
3431         {
3432           rnd ($mode, $i, 0);
3433         }
3434       }
3435     }
3436     elsif ($mode == 8700)
3437     {
3438       for (my $i = 1; $i < 32; $i++)
3439       {
3440         if ($len != 0)
3441         {
3442           rnd ($mode, $len, 5);
3443         }
3444         else
3445         {
3446           rnd ($mode, $i, 5);
3447         }
3448       }
3449     }
3450     elsif ($mode == 9200 || $mode == 9300)
3451     {
3452       my $salt_len = 14;
3453
3454       for (my $i = 1; $i < 32; $i++)
3455       {
3456         if ($len != 0)
3457         {
3458           rnd ($mode, $len, $salt_len);
3459         }
3460         else
3461         {
3462           rnd ($mode, $i, $salt_len);
3463         }
3464       }
3465     }
3466     elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
3467     {
3468       my $salt_len = 32;
3469
3470       for (my $i = 1; $i < 20; $i++)
3471       {
3472         if ($len != 0)
3473         {
3474           rnd ($mode, $len, $salt_len);
3475         }
3476         else
3477         {
3478           rnd ($mode, $i, $salt_len);
3479         }
3480       }
3481     }
3482     elsif ($mode == 10100)
3483     {
3484       for (my $i = 1; $i < 32; $i++)
3485       {
3486         if ($len != 0)
3487         {
3488           rnd ($mode, $len, 32);
3489         }
3490         else
3491         {
3492           rnd ($mode, $i, 32);
3493         }
3494       }
3495     }
3496     elsif ($mode == 10300)
3497     {
3498       my $salt_len = get_random_num (4, 15);
3499
3500       for (my $i = 1; $i < 32; $i++)
3501       {
3502         if ($len != 0)
3503         {
3504           rnd ($mode, $len, $salt_len);
3505         }
3506         else
3507         {
3508           rnd ($mode, $i, $salt_len);
3509         }
3510       }
3511     }
3512     elsif ($mode == 10400 || $mode == 10600)
3513     {
3514       my $salt_len = 32;
3515
3516       for (my $i = 1; $i < 32; $i++)
3517       {
3518         if ($len != 0)
3519         {
3520           rnd ($mode, $len, $salt_len);
3521         }
3522         else
3523         {
3524           rnd ($mode, $i, $salt_len);
3525         }
3526       }
3527     }
3528     elsif ($mode == 10500 || $mode == 10700)
3529     {
3530       my $salt_len = 32;
3531
3532       for (my $i = 1; $i < 16; $i++)
3533       {
3534         if ($len != 0)
3535         {
3536           rnd ($mode, $len, $salt_len);
3537         }
3538         else
3539         {
3540           rnd ($mode, $i, $salt_len);
3541         }
3542       }
3543     }
3544     elsif ($mode == 11000)
3545     {
3546       for (my $i = 1; $i < 32; $i++)
3547       {
3548         if ($len != 0)
3549         {
3550           rnd ($mode, $len, 56);
3551         }
3552         else
3553         {
3554           rnd ($mode, $i, 56);
3555         }
3556       }
3557     }
3558     elsif ($mode == 11300)
3559     {
3560       for (my $i = 1; $i < 32; $i++)
3561       {
3562         if ($len != 0)
3563         {
3564           rnd ($mode, $len, 16);
3565         }
3566         else
3567         {
3568           rnd ($mode, $i, 16);
3569         }
3570       }
3571     }
3572     elsif ($mode == 11400)
3573     {
3574       for (my $i = 1; $i < 24; $i++)
3575       {
3576         if ($len != 0)
3577         {
3578           rnd ($mode, $len, 16);
3579         }
3580         else
3581         {
3582           rnd ($mode, $i, 16);
3583         }
3584       }
3585     }
3586     elsif ($mode == 11600)
3587     {
3588       my $salt_len = get_random_num (0, 16);
3589
3590       for (my $i = 1; $i < 32; $i++)
3591       {
3592         if ($len != 0)
3593         {
3594           rnd ($mode, $len, $salt_len);
3595         }
3596         else
3597         {
3598           rnd ($mode, $i, $salt_len);
3599         }
3600       }
3601     }
3602     elsif ($mode == 12400)
3603     {
3604       for (my $i = 1; $i < 32; $i++)
3605       {
3606         if ($len != 0)
3607         {
3608           rnd ($mode, $len, 4);
3609         }
3610         else
3611         {
3612           rnd ($mode, $i, 4);
3613         }
3614       }
3615     }
3616     elsif ($mode == 12600)
3617     {
3618       for (my $i = 1; $i < 32; $i++)
3619       {
3620         if ($len != 0)
3621         {
3622           rnd ($mode, $len, 64);
3623         }
3624         else
3625         {
3626           rnd ($mode, $i, 64);
3627         }
3628       }
3629     }
3630     elsif ($mode == 12700)
3631     {
3632       for (my $i = 1; $i < 32; $i++)
3633       {
3634         if ($len != 0)
3635         {
3636           rnd ($mode, $len, 32);
3637         }
3638         else
3639         {
3640           rnd ($mode, $i, 32);
3641         }
3642       }
3643     }
3644     elsif ($mode == 12800)
3645     {
3646       for (my $i = 1; $i < 25; $i++)
3647       {
3648         if ($len != 0)
3649         {
3650           rnd ($mode, $len, 20);
3651         }
3652         else
3653         {
3654           rnd ($mode, $i, 20);
3655         }
3656       }
3657     }
3658     elsif ($mode == 12900)
3659     {
3660       for (my $i = 1; $i < 32; $i++)
3661       {
3662         if ($len != 0)
3663         {
3664           rnd ($mode, $len, 32);
3665         }
3666         else
3667         {
3668           rnd ($mode, $i, 32);
3669         }
3670       }
3671     }
3672     elsif ($mode == 13000)
3673     {
3674       for (my $i = 1; $i < 32; $i++)
3675       {
3676         if ($len != 0)
3677         {
3678           rnd ($mode, $len, 32);
3679         }
3680         else
3681         {
3682           rnd ($mode, $i, 32);
3683         }
3684       }
3685     }
3686     elsif ($mode == 13100)
3687     {
3688       for (my $i = 1; $i < 27; $i++)
3689       {
3690         if ($len != 0)
3691         {
3692           rnd ($mode, $len, 16);
3693         }
3694         else
3695         {
3696           rnd ($mode, $i, 16);
3697         }
3698       }
3699     }
3700   }
3701 }
3702
3703 exit;
3704
3705 sub gen_hash
3706 {
3707   my $mode = shift;
3708
3709   my $word_buf = shift;
3710
3711   my $salt_buf = shift;
3712
3713   my $iter = shift;
3714
3715   my $additional_param = shift;
3716
3717   my $additional_param2 = shift;
3718
3719   my $additional_param3 = shift;
3720
3721   my $additional_param4 = shift;
3722
3723   my $additional_param5 = shift;
3724
3725   my $additional_param6 = shift;
3726
3727   my $additional_param7 = shift;
3728
3729   my $additional_param8 = shift;
3730
3731   my $additional_param9 = shift;
3732
3733   my $additional_param10 = shift;
3734
3735   my $additional_param11 = shift;
3736
3737   ##
3738   ## gen hash
3739   ##
3740
3741   my $tmp_hash;
3742
3743   my $hash_buf;
3744
3745   if ($mode == 0)
3746   {
3747     $hash_buf = md5_hex ($word_buf);
3748
3749     $tmp_hash = sprintf ("%s", $hash_buf);
3750   }
3751   elsif ($mode == 10)
3752   {
3753     $hash_buf = md5_hex ($word_buf . $salt_buf);
3754
3755     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3756   }
3757   elsif ($mode == 11)
3758   {
3759     $hash_buf = md5_hex ($word_buf . $salt_buf);
3760
3761     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3762   }
3763   elsif ($mode == 12)
3764   {
3765     $hash_buf = md5_hex ($word_buf . $salt_buf);
3766
3767     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3768   }
3769   elsif ($mode == 20)
3770   {
3771     $hash_buf = md5_hex ($salt_buf . $word_buf);
3772
3773     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3774   }
3775   elsif ($mode == 21)
3776   {
3777     $hash_buf = md5_hex ($salt_buf . $word_buf);
3778
3779     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3780   }
3781   elsif ($mode == 22)
3782   {
3783     my $itoa64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
3784     my $salt_suffix = "Administration Tools";
3785
3786     my $pass = sprintf ("%s:%s:%s", $salt_buf, $salt_suffix, $word_buf);
3787
3788     $hash_buf = md5 ($pass);
3789
3790     my $res = "";
3791
3792     for (my $pos = 0; $pos < 16; $pos += 2)
3793     {
3794       my $octet1 = ord (substr ($hash_buf, $pos + 0, 1));
3795       my $octet2 = ord (substr ($hash_buf, $pos + 1, 1));
3796
3797       my $num = ($octet1 <<8 & 0xff00) | ($octet2 & 0xff);
3798
3799       my $idx1 = $num >> 12 & 0x0f;
3800       my $idx2 = $num >>  6 & 0x3f;
3801       my $idx3 = $num       & 0x3f;
3802
3803       $res = $res . substr ($itoa64, $idx1, 1) . substr ($itoa64, $idx2, 1) . substr ($itoa64, $idx3, 1);
3804     }
3805
3806     my $obfuscate_str = "nrcstn";
3807     my @obfuscate_pos = (0, 6, 12, 17, 23, 29);
3808
3809     foreach my $pos (keys @obfuscate_pos)
3810     {
3811       my $idx = $obfuscate_pos[$pos];
3812       my $before = substr ($res, 0, $idx);
3813       my $char   = substr ($obfuscate_str, $pos, 1);
3814       my $after  = substr ($res, $idx);
3815
3816       $res = sprintf ("%s%s%s", $before, $char, $after);
3817     }
3818
3819     $tmp_hash = sprintf ("%s:%s", $res, $salt_buf);
3820   }
3821   elsif ($mode == 23)
3822   {
3823     $hash_buf = md5_hex ($salt_buf . "\nskyper\n" . $word_buf);
3824
3825     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3826   }
3827   elsif ($mode == 30)
3828   {
3829     $hash_buf = md5_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
3830
3831     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3832   }
3833   elsif ($mode == 40)
3834   {
3835     $hash_buf = md5_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
3836
3837     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3838   }
3839   elsif ($mode == 50)
3840   {
3841     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5, 64);
3842
3843     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3844   }
3845   elsif ($mode == 60)
3846   {
3847     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&md5, 64);
3848
3849     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3850   }
3851   elsif ($mode == 100)
3852   {
3853     $hash_buf = sha1_hex ($word_buf);
3854
3855     $tmp_hash = sprintf ("%s", $hash_buf);
3856   }
3857   elsif ($mode == 101)
3858   {
3859     $hash_buf = sha1 ($word_buf);
3860
3861     my $base64_buf = encode_base64 ($hash_buf);
3862
3863     chomp ($base64_buf);
3864
3865     $tmp_hash = sprintf ("{SHA}%s", $base64_buf);
3866   }
3867   elsif ($mode == 110)
3868   {
3869     $hash_buf = sha1_hex ($word_buf . $salt_buf);
3870
3871     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3872   }
3873   elsif ($mode == 111)
3874   {
3875     $hash_buf = sha1 ($word_buf . $salt_buf);
3876
3877     my $base64_buf = encode_base64 ($hash_buf . $salt_buf);
3878
3879     chomp ($base64_buf);
3880
3881     $tmp_hash = sprintf ("{SSHA}%s", $base64_buf);
3882   }
3883   elsif ($mode == 112)
3884   {
3885     my $salt_buf_bin = pack ("H*", $salt_buf);
3886
3887     $hash_buf = sha1_hex ($word_buf . $salt_buf_bin);
3888
3889     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3890   }
3891   elsif ($mode == 120)
3892   {
3893     $hash_buf = sha1_hex ($salt_buf . $word_buf);
3894
3895     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3896   }
3897   elsif ($mode == 121)
3898   {
3899     $hash_buf = sha1_hex (lc ($salt_buf) . $word_buf);
3900
3901     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3902   }
3903   elsif ($mode == 122)
3904   {
3905     my $salt_buf_bin = pack ("H*", $salt_buf);
3906
3907     $hash_buf = sha1_hex ($salt_buf_bin . $word_buf);
3908
3909     $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
3910   }
3911   elsif ($mode == 130)
3912   {
3913     $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
3914
3915     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3916   }
3917   elsif ($mode == 131)
3918   {
3919     my $salt_buf_bin = pack ("H*", $salt_buf);
3920
3921     $hash_buf = sha1_hex (encode ("UTF-16LE", uc ($word_buf)) . $salt_buf_bin);
3922
3923     $tmp_hash = sprintf ("0x0100%s%s%s", $salt_buf, "0" x 40, $hash_buf);
3924   }
3925   elsif ($mode == 132)
3926   {
3927     my $salt_buf_bin = pack ("H*", $salt_buf);
3928
3929     $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin);
3930
3931     $tmp_hash = sprintf ("0x0100%s%s", $salt_buf, $hash_buf);
3932   }
3933   elsif ($mode == 140)
3934   {
3935     $hash_buf = sha1_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
3936
3937     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3938   }
3939   elsif ($mode == 141)
3940   {
3941     $hash_buf = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
3942
3943     my $base64_salt_buf = encode_base64 ($salt_buf);
3944
3945     chomp ($base64_salt_buf);
3946
3947     my $base64_hash_buf = encode_base64 ($hash_buf);
3948
3949     $base64_hash_buf = substr ($base64_hash_buf, 0, 27);
3950
3951     $tmp_hash = sprintf ("\$episerver\$*0*%s*%s", $base64_salt_buf, $base64_hash_buf);
3952   }
3953   elsif ($mode == 150)
3954   {
3955     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1, 64);
3956
3957     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3958   }
3959   elsif ($mode == 160)
3960   {
3961     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha1, 64);
3962
3963     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3964   }
3965   elsif ($mode == 190)
3966   {
3967     $hash_buf = sha1_hex ($word_buf);
3968
3969     my $variant = int (rand (2));
3970
3971     if (defined ($additional_param))
3972     {
3973       $variant = $additional_param;
3974     }
3975
3976     if ($variant == 1)
3977     {
3978       substr ($hash_buf, 0, 5) = "00000";
3979     }
3980
3981     $tmp_hash = sprintf ("%s", $hash_buf);
3982   }
3983   elsif ($mode == 200)
3984   {
3985     my $ppr = Authen::Passphrase::MySQL323->new (passphrase => $word_buf);
3986
3987     $hash_buf = $ppr->hash_hex;
3988
3989     $tmp_hash = sprintf ("%s", $hash_buf);
3990   }
3991   elsif ($mode == 300)
3992   {
3993     $hash_buf = substr (password41 ($word_buf), 1);
3994
3995     $hash_buf = lc ($hash_buf); # useful for 'not matched' check only
3996
3997     $tmp_hash = sprintf ("%s", $hash_buf);
3998   }
3999   elsif ($mode == 400)
4000   {
4001     my $cost = 11;
4002
4003     if (length ($iter))
4004     {
4005       $cost = $iter;
4006     }
4007
4008     my $ppr = Authen::Passphrase::PHPass->new
4009     (
4010       cost => $cost,
4011       salt => $salt_buf,
4012       passphrase => $word_buf,
4013     );
4014
4015     $hash_buf = $ppr->as_rfc2307;
4016
4017     $tmp_hash = sprintf ("%s", substr ($hash_buf, 7));
4018   }
4019   elsif ($mode == 500)
4020   {
4021     my $iterations = 1000;
4022
4023     if (defined ($iter))
4024     {
4025       if ($iter > 0)
4026       {
4027         $iterations = int ($iter);
4028       }
4029     }
4030
4031     $hash_buf = md5_crypt ('$1$', $iterations, $word_buf, $salt_buf);
4032
4033     $tmp_hash = sprintf ("%s", $hash_buf);
4034   }
4035   elsif ($mode == 900)
4036   {
4037     $hash_buf = md4_hex ($word_buf);
4038
4039     $tmp_hash = sprintf ("%s", $hash_buf);
4040   }
4041   elsif ($mode == 1000)
4042   {
4043     $hash_buf = md4_hex (encode ("UTF-16LE", $word_buf));
4044
4045     $tmp_hash = sprintf ("%s", $hash_buf);
4046   }
4047   elsif ($mode == 1100)
4048   {
4049     $hash_buf = md4_hex (md4 (encode ("UTF-16LE", $word_buf)) . encode ("UTF-16LE", lc ($salt_buf)));
4050
4051     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4052   }
4053   elsif ($mode == 1400)
4054   {
4055     $hash_buf = sha256_hex ($word_buf);
4056
4057     $tmp_hash = sprintf ("%s", $hash_buf);
4058   }
4059   elsif ($mode == 1410)
4060   {
4061     $hash_buf = sha256_hex ($word_buf . $salt_buf);
4062
4063     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4064   }
4065   elsif ($mode == 1420)
4066   {
4067     $hash_buf = sha256_hex ($salt_buf . $word_buf);
4068
4069     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4070   }
4071   elsif ($mode == 1430)
4072   {
4073     $hash_buf = sha256_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
4074
4075     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4076   }
4077   elsif ($mode == 1440)
4078   {
4079     $hash_buf = sha256_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
4080
4081     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4082   }
4083   elsif ($mode == 1441)
4084   {
4085     $hash_buf = sha256 ($salt_buf . encode ("UTF-16LE", $word_buf));
4086
4087     my $base64_salt_buf = encode_base64 ($salt_buf);
4088
4089     chomp ($base64_salt_buf);
4090
4091     my $base64_hash_buf = encode_base64 ($hash_buf);
4092
4093     chomp ($base64_hash_buf);
4094
4095     $base64_hash_buf = substr ($base64_hash_buf, 0, 43);
4096
4097     $tmp_hash = sprintf ("\$episerver\$*1*%s*%s", $base64_salt_buf, $base64_hash_buf);
4098   }
4099   elsif ($mode == 1450)
4100   {
4101     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha256, 64);
4102
4103     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4104   }
4105   elsif ($mode == 1460)
4106   {
4107     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha256, 64);
4108
4109     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4110   }
4111   elsif ($mode == 1500)
4112   {
4113     $hash_buf = crypt ($word_buf, $salt_buf);
4114
4115     $tmp_hash = sprintf ("%s", $hash_buf);
4116   }
4117   elsif ($mode == 1600)
4118   {
4119     my $iterations = 1000;
4120
4121     if (defined ($iter))
4122     {
4123       if ($iter > 0)
4124       {
4125         $iterations = int ($iter);
4126       }
4127     }
4128
4129     $hash_buf = md5_crypt ('$apr1$', $iterations, $word_buf, $salt_buf);
4130
4131     $tmp_hash = sprintf ("%s", $hash_buf);
4132   }
4133   elsif ($mode == 1700)
4134   {
4135     $hash_buf = sha512_hex ($word_buf);
4136
4137     $tmp_hash = sprintf ("%s", $hash_buf);
4138   }
4139   elsif ($mode == 1710)
4140   {
4141     $hash_buf = sha512_hex ($word_buf . $salt_buf);
4142
4143     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4144   }
4145   elsif ($mode == 1711)
4146   {
4147     $hash_buf = sha512_hex ($word_buf . $salt_buf);
4148
4149     my $base64_buf = encode_base64 (pack ("H*", $hash_buf) . $salt_buf);
4150
4151     $base64_buf =~ s/[ \n]//g;
4152
4153     $tmp_hash = sprintf ("{SSHA512}%s", $base64_buf);
4154   }
4155   elsif ($mode == 1720)
4156   {
4157     $hash_buf = sha512_hex ($salt_buf . $word_buf);
4158
4159     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4160   }
4161   elsif ($mode == 1730)
4162   {
4163     $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
4164
4165     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4166   }
4167   elsif ($mode == 1740)
4168   {
4169     $hash_buf = sha512_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
4170
4171     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4172   }
4173   elsif ($mode == 1722)
4174   {
4175     my $salt_buf_bin = pack ("H*", $salt_buf);
4176
4177     $hash_buf = sha512_hex ($salt_buf_bin . $word_buf);
4178
4179     $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
4180   }
4181   elsif ($mode == 1731)
4182   {
4183     my $salt_buf_bin = pack ("H*", $salt_buf);
4184
4185     $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin);
4186
4187     $tmp_hash = sprintf ("0x0200%s%s", $salt_buf, $hash_buf);
4188   }
4189   elsif ($mode == 1750)
4190   {
4191     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha512, 128);
4192
4193     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4194   }
4195   elsif ($mode == 1760)
4196   {
4197     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha512, 128);
4198
4199     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4200   }
4201   elsif ($mode == 1800)
4202   {
4203     my $iterations = 5000;
4204
4205     if (defined ($iter))
4206     {
4207       if ($iter > 0)
4208       {
4209         $iterations = int ($iter);
4210       }
4211     }
4212
4213     $hash_buf = sha512_crypt ($iterations, $word_buf, $salt_buf);
4214
4215     $tmp_hash = sprintf ("%s", $hash_buf);
4216   }
4217   elsif ($mode == 2100)
4218   {
4219     my $iterations = 10240;
4220
4221     if (length ($iter))
4222     {
4223       $iterations = int ($iter);
4224     }
4225
4226     my $salt = encode ("UTF-16LE", lc ($salt_buf));
4227
4228     my $pbkdf2 = Crypt::PBKDF2->new
4229     (
4230       hash_class => 'HMACSHA1',
4231       iterations => $iterations,
4232       output_len => 16,
4233       salt_len   => length ($salt),
4234     );
4235
4236     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 ($salt, md4 (md4 (encode ("UTF-16LE", $word_buf)) . $salt)));
4237
4238     $tmp_hash = sprintf ("\$DCC2\$%i#%s#%s", $iterations, $salt_buf, $hash_buf);
4239   }
4240   elsif ($mode == 2400)
4241   {
4242     $tmp_hash = sprintf ("%s", pseudo_base64 (Digest::MD5::md5 ($word_buf . "\0" x (16 - length ($word_buf)))));
4243   }
4244   elsif ($mode == 2410)
4245   {
4246     my $salt_len = length ($salt_buf);
4247
4248     my $salt_len_max4 = ($salt_len < 4) ? $salt_len : 4;
4249
4250     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)));
4251
4252     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4253   }
4254   elsif ($mode == 2500)
4255   {
4256     my ($bssid, $stmac, $snonce, $anonce, $eapol, $keyver, $eapol_size);
4257
4258     if (! defined ($additional_param))
4259     {
4260       # random stuff
4261
4262       $bssid  = randbytes (6);
4263       $stmac  = randbytes (6);
4264       $snonce = randbytes (32);
4265       $anonce = randbytes (32);
4266
4267       $keyver = get_random_num (1, 3); # 1 or 2
4268
4269       # eapol:
4270       # should be "validly" generated, but in theory could be anything for us also:
4271       # $eapol = "\x00" x 121; # works too, but let's generate it correctly
4272
4273       $eapol = gen_random_wpa_eapol ($keyver, $snonce);
4274     }
4275     else
4276     {
4277       $bssid  = $additional_param;
4278       $stmac  = $additional_param2;
4279       $snonce = $additional_param3;
4280       $anonce = $additional_param4;
4281       $keyver = $additional_param5;
4282       $eapol  = $additional_param6;
4283     }
4284
4285     $eapol_size = length ($eapol);
4286
4287     # constants
4288
4289     my $iterations = 4096;
4290
4291     #
4292     # START
4293     #
4294
4295     # generate the Pairwise Master Key (PMK)
4296
4297     my $pbkdf2 = Crypt::PBKDF2->new
4298     (
4299       hash_class => 'HMACSHA1',
4300       iterations => $iterations,
4301       output_len => 32,
4302     );
4303
4304     my $pmk = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
4305
4306     # Pairwise Transient Key (PTK) transformation
4307
4308     my $ptk = wpa_prf_512 ($pmk, $stmac, $bssid, $snonce, $anonce);
4309
4310     # generate the Message Integrity Code (MIC)
4311
4312     my $mic = "";
4313
4314     if ($keyver == 1) # WPA1 => MD5
4315     {
4316       $mic = hmac ($eapol, $ptk, \&md5);
4317     }
4318     else # WPA2 => SHA1
4319     {
4320       $mic = hmac ($eapol, $ptk, \&sha1);
4321     }
4322
4323     $mic = substr ($mic, 0, 16);
4324
4325     #
4326     # format the binary output
4327     #
4328
4329     $hash_buf = "";
4330
4331     # first the essid (NULL-padded up to the first 36 bytes)
4332
4333     $hash_buf .= $salt_buf;
4334     $hash_buf .= "\x00" x (36 - length ($salt_buf));
4335
4336     # the 2 MAC addresses
4337
4338     $hash_buf .= $bssid;
4339     $hash_buf .= $stmac;
4340
4341     # nonces
4342
4343     $hash_buf .= $snonce;
4344     $hash_buf .= $anonce;
4345
4346     # eapol
4347
4348     $hash_buf .= $eapol;
4349     $hash_buf .= "\x00" x (256 - $eapol_size);
4350
4351     # eapol size
4352
4353     $hash_buf .= pack ("L*", $eapol_size);
4354
4355     # key version
4356
4357     $hash_buf .= pack ("L*", $keyver);
4358
4359     # and finally: the key mic
4360
4361     $hash_buf .= $mic;
4362
4363     # base64 encode the output
4364
4365     $tmp_hash = encode_base64 ($hash_buf, '');
4366   }
4367   elsif ($mode == 2600)
4368   {
4369     $hash_buf = md5_hex (md5_hex ($word_buf));
4370
4371     $tmp_hash = sprintf ("%s", $hash_buf);
4372   }
4373   elsif ($mode == 2611)
4374   {
4375     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4376
4377     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4378   }
4379   elsif ($mode == 2612)
4380   {
4381     my $salt_buf_hex = unpack ("H*", $salt_buf);
4382
4383     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4384
4385     $tmp_hash = sprintf ("\$PHPS\$%s\$%s", $salt_buf_hex, $hash_buf);
4386   }
4387   elsif ($mode == 2711)
4388   {
4389     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4390
4391     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4392   }
4393   elsif ($mode == 2811)
4394   {
4395     $hash_buf = md5_hex (md5_hex ($salt_buf) . md5_hex ($word_buf));
4396
4397     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4398   }
4399   elsif ($mode == 3000)
4400   {
4401     my $ppr = Authen::Passphrase::LANManager->new ("passphrase" => $word_buf);
4402
4403     $hash_buf = $ppr->hash_hex;
4404
4405     $tmp_hash = sprintf ("%s", substr ($hash_buf, 0, 16));
4406   }
4407   elsif ($mode == 3100)
4408   {
4409     $hash_buf = oracle_hash ($salt_buf, $word_buf);
4410
4411     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4412   }
4413   elsif ($mode == 3200)
4414   {
4415     my $cost = "05";
4416
4417     if (length ($iter))
4418     {
4419       $cost = $iter;
4420     }
4421
4422     $tmp_hash = bcrypt ($word_buf, sprintf ('$2a$%s$%s$', $cost, en_base64 ($salt_buf)));
4423   }
4424   elsif ($mode == 3300)
4425   {
4426     my $iterations = 904;
4427
4428     if (length ($iter))
4429     {
4430       $iterations = int ($iter);
4431     }
4432
4433     my $variant = "\$";
4434
4435     if (defined ($additional_param))
4436     {
4437       $variant = $additional_param;
4438     }
4439
4440     my $prefix = sprintf ("\$md5%srounds=%i\$%s", $variant, $iterations, $salt_buf);
4441
4442     $iterations += 4096;
4443
4444     $hash_buf = sun_md5 ($word_buf, $prefix, $iterations);
4445
4446     $tmp_hash = sprintf ("%s\$%s", $prefix, $hash_buf);
4447   }
4448   elsif ($mode == 3500)
4449   {
4450     $hash_buf = md5_hex (md5_hex (md5_hex ($word_buf)));
4451
4452     $tmp_hash = sprintf ("%s", $hash_buf);
4453   }
4454   elsif ($mode == 3610)
4455   {
4456     $hash_buf = md5_hex (md5_hex ($salt_buf) . $word_buf);
4457
4458     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4459   }
4460   elsif ($mode == 3710)
4461   {
4462     $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf));
4463
4464     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4465   }
4466   elsif ($mode == 3711)
4467   {
4468     $hash_buf = md5_hex ($salt_buf . "-" . md5_hex ($word_buf));
4469
4470     $tmp_hash = sprintf ("\$B\$%s\$%s", $salt_buf, $hash_buf);
4471   }
4472   elsif ($mode == 3720)
4473   {
4474     $hash_buf = md5_hex ($word_buf . md5_hex ($salt_buf));
4475
4476     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4477   }
4478   elsif ($mode == 3800)
4479   {
4480     $hash_buf = md5_hex ($salt_buf . $word_buf . $salt_buf);
4481
4482     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4483   }
4484   elsif ($mode == 3910)
4485   {
4486     $hash_buf = md5_hex (md5_hex ($word_buf) . md5_hex ($salt_buf));
4487
4488     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4489   }
4490   elsif ($mode == 4010)
4491   {
4492     $hash_buf = md5_hex ($salt_buf . md5_hex ($salt_buf . $word_buf));
4493
4494     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4495   }
4496   elsif ($mode == 4110)
4497   {
4498     $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf . $salt_buf));
4499
4500     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4501   }
4502   elsif ($mode == 4210)
4503   {
4504     $hash_buf = md5_hex ($salt_buf . "\x00" . $word_buf);
4505
4506     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4507   }
4508   elsif ($mode == 4300)
4509   {
4510     $hash_buf = md5_hex (uc (md5_hex ($word_buf)));
4511
4512     $tmp_hash = sprintf ("%s", $hash_buf);
4513   }
4514   elsif ($mode == 4400)
4515   {
4516     $hash_buf = md5_hex (sha1_hex ($word_buf));
4517
4518     $tmp_hash = sprintf ("%s", $hash_buf);
4519   }
4520   elsif ($mode == 4500)
4521   {
4522     $hash_buf = sha1_hex (sha1_hex ($word_buf));
4523
4524     $tmp_hash = sprintf ("%s", $hash_buf);
4525   }
4526   elsif ($mode == 4600)
4527   {
4528     $hash_buf = sha1_hex (sha1_hex (sha1_hex ($word_buf)));
4529
4530     $tmp_hash = sprintf ("%s", $hash_buf);
4531   }
4532   elsif ($mode == 4700)
4533   {
4534     $hash_buf = sha1_hex (md5_hex ($word_buf));
4535
4536     $tmp_hash = sprintf ("%s", $hash_buf);
4537   }
4538   elsif ($mode == 4800)
4539   {
4540     my $index = rindex ($salt_buf, ":");
4541
4542     my $salt  = substr ($salt_buf, 0, $index);
4543     my $salt_bin  = pack ("H*", $salt);
4544     my $chap_sign = substr ($salt_buf, $index + 1);
4545     my $chap_sign_bin = pack ("H*", $chap_sign);
4546
4547     $hash_buf = md5_hex ($chap_sign_bin . $word_buf . $salt_bin);
4548
4549     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4550   }
4551   elsif ($mode == 4900)
4552   {
4553     $hash_buf = sha1_hex ($salt_buf . $word_buf . $salt_buf);
4554
4555     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4556   }
4557   elsif ($mode == 5000)
4558   {
4559     $hash_buf = keccak_256_hex ($word_buf);
4560
4561     $tmp_hash = sprintf ("%s", $hash_buf);
4562   }
4563   elsif ($mode == 5100)
4564   {
4565     my $pos;
4566
4567     if (! defined ($additional_param))
4568     {
4569       $pos = 0;
4570     }
4571     else
4572     {
4573       $pos = $additional_param * 8 unless ($additional_param > 2);
4574     }
4575
4576     $hash_buf = md5_hex ($word_buf);
4577
4578     $tmp_hash = sprintf ("%s", substr ($hash_buf, $pos, 16));
4579   }
4580   elsif ($mode == 5300)
4581   {
4582     my @salt_arr = split (":", $salt_buf);
4583
4584     my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4585     my $nr_buf  = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4586
4587     my $hash_buf = hmac  ($nr_buf , $word_buf, \&md5, 64);
4588     $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&md5, 64);
4589
4590     $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4591   }
4592   elsif ($mode == 5400)
4593   {
4594     my @salt_arr = split (":", $salt_buf);
4595
4596     my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4597     my $nr_buf  = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4598
4599     my $hash_buf = hmac  ($nr_buf , $word_buf, \&sha1, 64);
4600     $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&sha1, 64);
4601
4602     $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4603   }
4604   elsif ($mode == 5500)
4605   {
4606     my $index1 = index  ($salt_buf, "::");
4607     my $user   = substr ($salt_buf, 0, $index1);
4608
4609     my $index2 = index  ($salt_buf, ":", $index1 + 2);
4610     my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4611
4612     my $len = length (substr ($salt_buf, $index2 + 1));
4613
4614     my $c_challenge_hex;
4615
4616     if ($len > 32)
4617     {
4618       $c_challenge_hex = substr ($salt_buf, $index2 +  1, 48);
4619       $index2 += 32;
4620     }
4621     else
4622     {
4623       $c_challenge_hex  = substr ($salt_buf, $index2 +  1, 16);
4624       $c_challenge_hex .= 00 x 32;
4625     }
4626
4627     my $c_challenge     = pack   ("H*", substr ($c_challenge_hex, 0, 16));
4628     my $s_challenge_hex = substr ($salt_buf, $index2 + 17, 16);
4629     my $s_challenge     = pack   ("H*", $s_challenge_hex);
4630
4631     my $challenge = substr (md5 ($s_challenge . $c_challenge), 0, 8);
4632
4633     my $ntresp;
4634
4635     my $nthash = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash . "\x00" x 5;
4636
4637     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash,  0, 7)), "DES", $challenge, PADDING_NONE);
4638     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash,  7, 7)), "DES", $challenge, PADDING_NONE);
4639     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash, 14, 7)), "DES", $challenge, PADDING_NONE);
4640
4641     $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $c_challenge_hex, unpack ("H*", $ntresp), $s_challenge_hex);
4642   }
4643   elsif ($mode == 5600)
4644   {
4645     my $index1 = index  ($salt_buf, "::");
4646     my $user   = substr ($salt_buf, 0, $index1);
4647
4648     my $index2 = index  ($salt_buf, ":", $index1 + 2);
4649     my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4650
4651     my $s_challenge_hex = substr ($salt_buf, $index2 + 1, 16);
4652     my $s_challenge     = pack   ("H*", $s_challenge_hex);
4653
4654     my $temp_hex = substr ($salt_buf, $index2 + 17);
4655     my $temp     = pack   ("H*", $temp_hex);
4656
4657     my $nthash   = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash;
4658     my $identity = Encode::encode ("UTF-16LE", uc ($user) . $domain);
4659
4660     $hash_buf = hmac_hex ($s_challenge . $temp, hmac ($identity, $nthash, \&md5, 64), \&md5, 64);
4661
4662     $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $s_challenge_hex, $hash_buf, $temp_hex);
4663   }
4664   elsif ($mode == 5700)
4665   {
4666     $hash_buf = sha256 ($word_buf);
4667
4668     my $base64_buf = encode_base64 ($hash_buf);
4669
4670     $tmp_hash = "";
4671
4672     for (my $i = 0; $i < 43; $i++)
4673     {
4674       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($base64_buf, $i, 1)};
4675     }
4676   }
4677   elsif ($mode == 5800)
4678   {
4679     $hash_buf = androidpin_hash ($word_buf, $salt_buf);
4680
4681     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4682   }
4683   elsif ($mode == 6000)
4684   {
4685     $hash_buf = ripemd160_hex ($word_buf);
4686
4687     $tmp_hash = sprintf ("%s", $hash_buf);
4688   }
4689   elsif ($mode == 6100)
4690   {
4691     $hash_buf = whirlpool_hex ($word_buf);
4692
4693     $tmp_hash = sprintf ("%s", $hash_buf);
4694   }
4695   elsif ($mode == 6300)
4696   {
4697     my $iterations = 1000; # hard coded by the AIX format
4698
4699     $hash_buf = md5_crypt ('', $iterations, $word_buf, $salt_buf);
4700
4701     $tmp_hash = sprintf ("{smd5}%s", $hash_buf);
4702   }
4703   elsif ($mode == 6400)
4704   {
4705     my $iterations = 64;
4706
4707     if (length ($iter))
4708     {
4709       $iterations = 1 << int ($iter);
4710     }
4711
4712     $hash_buf = aix_ssha256_pbkdf2 ($word_buf, $salt_buf, $iterations);
4713
4714     $tmp_hash = sprintf ("{ssha256}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4715   }
4716   elsif ($mode == 6500)
4717   {
4718     my $iterations = 64;
4719
4720     if (length ($iter))
4721     {
4722       $iterations = 1 << int ($iter);
4723     }
4724
4725     $hash_buf = aix_ssha512_pbkdf2 ($word_buf, $salt_buf, $iterations);
4726
4727     $tmp_hash = sprintf ("{ssha512}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4728   }
4729   elsif ($mode == 6600)
4730   {
4731     my $iterations = 1000;
4732
4733     if (length ($iter))
4734     {
4735       $iterations = int ($iter);
4736     }
4737
4738     my $salt_hex = substr ($salt_buf, 0, 16);
4739     my $salt     = pack   ("H*", $salt_hex);
4740
4741     my $prefix   = substr ($salt_buf, 16, 2016);
4742
4743     my $iv_hex   = substr ($salt_buf, 2032);
4744     my $iv       = pack ("H*", $iv_hex);
4745
4746     my $data = pack ("H*", "10101010101010101010101010101010");
4747
4748     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
4749
4750     my $pbkdf2 = Crypt::PBKDF2->new (
4751       hasher       => $hasher,
4752       iterations   => $iterations,
4753       output_len   => 16
4754     );
4755
4756     my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
4757
4758     my $cipher = Crypt::CBC->new ({
4759       key         => $key,
4760       cipher      => "Crypt::Rijndael",
4761       iv          => $iv,
4762       literal_key => 1,
4763       header      => "none",
4764       keysize     => 16
4765     });
4766
4767     my $encrypted = unpack ("H*", $cipher->encrypt ($data));
4768
4769     $hash_buf  = substr ($encrypted, 0, 32);
4770
4771     $tmp_hash = sprintf ("%i:%s:%s%s%s", $iterations, $salt_hex, $prefix, $iv_hex, $hash_buf);
4772   }
4773   elsif ($mode == 6700)
4774   {
4775     my $iterations = 64;
4776
4777     if (length ($iter))
4778     {
4779       $iterations = 1 << int ($iter);
4780     }
4781
4782     $hash_buf = aix_ssha1_pbkdf2 ($word_buf, $salt_buf, $iterations);
4783
4784     $tmp_hash = sprintf ("{ssha1}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4785   }
4786   elsif ($mode == 6800)
4787   {
4788     my $variant = $additional_param;
4789
4790     if (! defined ($variant))
4791     {
4792       $variant = int (rand (2));
4793     }
4794
4795     my $iterations = 500;
4796
4797     if (length ($iter))
4798     {
4799       $iterations = int ($iter);
4800     }
4801
4802     my $iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4803
4804     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256);
4805
4806     my $pbkdf2 = Crypt::PBKDF2->new (
4807       hasher       => $hasher,
4808       iterations   => $iterations,
4809       output_len   => 32
4810     );
4811
4812     my $key = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
4813
4814     my $cipher = Crypt::CBC->new ({
4815       key         => $key,
4816       cipher      => "Crypt::Rijndael",
4817       iv          => $iv,
4818       literal_key => 1,
4819       header      => "none",
4820       keysize     => 32
4821     });
4822
4823     if ($variant == 1)
4824     {
4825       my $encrypt = $cipher->encrypt (substr ($salt_buf, 0, 16));
4826
4827       $hash_buf = substr (unpack ("H*", $encrypt), 0, 32);
4828     }
4829     else
4830     {
4831       my $verifier = "lastpass rocks\x02\x02";
4832
4833       $hash_buf = unpack ("H*", substr ($cipher->encrypt ($verifier), 0, 16));
4834     }
4835
4836     $tmp_hash = sprintf ("%s:%i:%s", $hash_buf, $iterations, $salt_buf);
4837   }
4838   elsif ($mode == 6900)
4839   {
4840     $hash_buf = gost_hex ($word_buf);
4841
4842     $tmp_hash = sprintf ("%s", $hash_buf);
4843   }
4844   elsif ($mode == 7100)
4845   {
4846     my $iterations = 1024;
4847
4848     if (length ($iter))
4849     {
4850       $iterations = int ($iter);
4851     }
4852
4853     my $pbkdf2 = Crypt::PBKDF2->new
4854     (
4855       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
4856       iterations => $iterations
4857     );
4858
4859     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
4860
4861     $tmp_hash = sprintf ("\$ml\$%i\$%s\$%0128s", $iterations, $salt_buf, $hash_buf);
4862   }
4863   elsif ($mode == 7200)
4864   {
4865     my $iterations = 1024;
4866
4867     if (length ($iter))
4868     {
4869       $iterations = int ($iter);
4870     }
4871
4872     my $pbkdf2 = Crypt::PBKDF2->new (
4873       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
4874       iterations => $iterations
4875     );
4876
4877     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
4878
4879     $tmp_hash = sprintf ("grub.pbkdf2.sha512.%i.%s.%0128s", $iterations, $salt_buf, $hash_buf);
4880   }
4881   elsif ($mode == 7300)
4882   {
4883     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1);
4884
4885     $tmp_hash = sprintf ("%s:%s", unpack ("H*", $salt_buf), $hash_buf);
4886   }
4887   elsif ($mode == 7400)
4888   {
4889     my $iterations = 5000;
4890
4891     if (defined ($iter))
4892     {
4893       if ($iter > 0)
4894       {
4895         $iterations = int ($iter);
4896       }
4897     }
4898
4899     $hash_buf = sha256_crypt ($iterations, $word_buf, $salt_buf);
4900
4901     $tmp_hash = sprintf ("%s", $hash_buf);
4902   }
4903   elsif ($mode == 7500)
4904   {
4905     my @salt_arr = split ("\\\$", $salt_buf);
4906
4907     my $user = $salt_arr[0];
4908
4909     my $realm = $salt_arr[1];
4910
4911     my $salt = $salt_arr[2];
4912
4913     my $hmac_salt = $salt_arr[3];
4914     my $hmac_salt_bin = pack ("H*", $hmac_salt);
4915
4916     my $clear_data = $salt_arr[4];
4917
4918     my $k = md4 (encode ("UTF-16LE", $word_buf));
4919
4920     my $k1 = hmac_md5 ("\x01\x00\x00\x00", $k);
4921
4922     my $k3 = hmac_md5 ($hmac_salt_bin, $k1);
4923
4924     if (length ($clear_data) > 1)
4925     {
4926       my $clear_data_bin = pack ("H*", $clear_data);
4927
4928       $hash_buf = RC4 ($k3, $clear_data_bin);
4929     }
4930     else
4931     {
4932       my $hash = $salt_arr[5];
4933
4934       my $hash_bin = pack ("H*", $hash);
4935
4936       my $clear_data = RC4 ($k3, $hash_bin);
4937
4938       my $timestamp = substr ($clear_data, 14, 14);
4939
4940       my $is_numeric = 1;
4941       my $num;
4942
4943       if ($timestamp !~ /^[[:digit:]]{14}$/)
4944       {
4945         $is_numeric = 0;
4946       }
4947
4948       if (! $is_numeric)
4949       {
4950         $hash_buf = "\x00" x 36;
4951
4952         if ($hash_buf eq $hash_bin)
4953         {
4954           $hash_buf = "\x01" x 36;
4955         }
4956       }
4957       else
4958       {
4959         $hash_buf = $hash_bin;
4960       }
4961     }
4962
4963     $tmp_hash = sprintf ("\$krb5pa\$23\$%s\$%s\$%s\$%s%s", $user, $realm, $salt, unpack ("H*", $hash_buf), $hmac_salt);
4964   }
4965   elsif ($mode == 7600)
4966   {
4967     $hash_buf = sha1_hex ($salt_buf . sha1_hex ($word_buf));
4968
4969     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4970   }
4971   elsif ($mode == 7700)
4972   {
4973     $word_buf = uc $word_buf;
4974     $salt_buf = uc $salt_buf;
4975
4976     my $word_buf_t = sapb_transcode ($word_buf);
4977     my $salt_buf_t = sapb_transcode ($salt_buf);
4978
4979     my $digest1 = md5 ($word_buf_t . $salt_buf_t);
4980
4981     my $data = sapb_waldorf ($digest1, $word_buf_t, $salt_buf_t);
4982
4983     my $digest2 = md5 ($data);
4984
4985     my ($a, $b, $c, $d) = unpack ("N4", $digest2);
4986
4987     $a ^= $c;
4988     $b ^= $d;
4989
4990     $tmp_hash = sprintf ("%s\$%08X%08X", $salt_buf, $a, $b);
4991   }
4992   elsif ($mode == 7800)
4993   {
4994     my $theMagicArray_s =
4995       "\x91\xac\x51\x14\x9f\x67\x54\x43\x24\xe7\x3b\xe0\x28\x74\x7b\xc2" .
4996       "\x86\x33\x13\xeb\x5a\x4f\xcb\x5c\x08\x0a\x73\x37\x0e\x5d\x1c\x2f" .
4997       "\x33\x8f\xe6\xe5\xf8\x9b\xae\xdd\x16\xf2\x4b\x8d\x2c\xe1\xd4\xdc" .
4998       "\xb0\xcb\xdf\x9d\xd4\x70\x6d\x17\xf9\x4d\x42\x3f\x9b\x1b\x11\x94" .
4999       "\x9f\x5b\xc1\x9b\x06\x05\x9d\x03\x9d\x5e\x13\x8a\x1e\x9a\x6a\xe8" .
5000       "\xd9\x7c\x14\x17\x58\xc7\x2a\xf6\xa1\x99\x63\x0a\xd7\xfd\x70\xc3" .
5001       "\xf6\x5e\x74\x13\x03\xc9\x0b\x04\x26\x98\xf7\x26\x8a\x92\x93\x25" .
5002       "\xb0\xa2\x0d\x23\xed\x63\x79\x6d\x13\x32\xfa\x3c\x35\x02\x9a\xa3" .
5003       "\xb3\xdd\x8e\x0a\x24\xbf\x51\xc3\x7c\xcd\x55\x9f\x37\xaf\x94\x4c" .
5004       "\x29\x08\x52\x82\xb2\x3b\x4e\x37\x9f\x17\x07\x91\x11\x3b\xfd\xcd";
5005
5006     $salt_buf = uc $salt_buf;
5007
5008     my $digest = sha1 ($word_buf . $salt_buf);
5009
5010     my ($a, $b, $c, $d, $e) = unpack ("I*", $digest);
5011
5012     my $lengthMagicArray = 0x20;
5013     my $offsetMagicArray = 0;
5014
5015     $lengthMagicArray += (($a >>  0) & 0xff) % 6;
5016     $lengthMagicArray += (($a >>  8) & 0xff) % 6;
5017     $lengthMagicArray += (($a >> 16) & 0xff) % 6;
5018     $lengthMagicArray += (($a >> 24) & 0xff) % 6;
5019     $lengthMagicArray += (($b >>  0) & 0xff) % 6;
5020     $lengthMagicArray += (($b >>  8) & 0xff) % 6;
5021     $lengthMagicArray += (($b >> 16) & 0xff) % 6;
5022     $lengthMagicArray += (($b >> 24) & 0xff) % 6;
5023     $lengthMagicArray += (($c >>  0) & 0xff) % 6;
5024     $lengthMagicArray += (($c >>  8) & 0xff) % 6;
5025     $offsetMagicArray += (($c >> 16) & 0xff) % 8;
5026     $offsetMagicArray += (($c >> 24) & 0xff) % 8;
5027     $offsetMagicArray += (($d >>  0) & 0xff) % 8;
5028     $offsetMagicArray += (($d >>  8) & 0xff) % 8;
5029     $offsetMagicArray += (($d >> 16) & 0xff) % 8;
5030     $offsetMagicArray += (($d >> 24) & 0xff) % 8;
5031     $offsetMagicArray += (($e >>  0) & 0xff) % 8;
5032     $offsetMagicArray += (($e >>  8) & 0xff) % 8;
5033     $offsetMagicArray += (($e >> 16) & 0xff) % 8;
5034     $offsetMagicArray += (($e >> 24) & 0xff) % 8;
5035
5036     my $hash_buf = sha1_hex ($word_buf . substr ($theMagicArray_s, $offsetMagicArray, $lengthMagicArray) . $salt_buf);
5037
5038     $tmp_hash = sprintf ("%s\$%s", $salt_buf, uc $hash_buf);
5039   }
5040   elsif ($mode == 7900)
5041   {
5042     my $cost = 14;
5043
5044     if (length ($iter))
5045     {
5046       $cost = $iter;
5047     }
5048
5049     my $phpass_it = 1 << $cost;
5050
5051     $hash_buf = sha512 ($salt_buf . $word_buf);
5052
5053     for (my $i = 0; $i < $phpass_it; $i++)
5054     {
5055       $hash_buf = sha512 ($hash_buf . $word_buf);
5056     }
5057
5058     my $base64_buf = substr (Authen::Passphrase::PHPass::_en_base64 ($hash_buf), 0, 43);
5059
5060     my $base64_digits = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
5061
5062     my $cost_str = substr ($base64_digits , $cost, 1);
5063
5064     $tmp_hash = sprintf ('$S$%s%s%s', $cost_str, $salt_buf, $base64_buf);
5065   }
5066   elsif ($mode == 8000)
5067   {
5068     my $salt_buf_bin = pack ("H*", $salt_buf);
5069
5070     my $word_buf_utf = encode ("UTF-16BE", $word_buf);
5071
5072     $hash_buf = sha256_hex ($word_buf_utf . "\x00" x (510 - (length ($word_buf) * 2)) . $salt_buf_bin);
5073
5074     $tmp_hash = sprintf ("0xc007%s%s", $salt_buf, $hash_buf);
5075   }
5076   elsif ($mode == 8100)
5077   {
5078     $hash_buf = sha1_hex ($salt_buf . $word_buf . "\x00");
5079
5080     $tmp_hash = sprintf ("1%s%s", $salt_buf, $hash_buf);
5081   }
5082   elsif ($mode == 8200)
5083   {
5084     my $iterations = 40000;
5085
5086     if (defined ($iter))
5087     {
5088       $iterations = $iter;
5089     }
5090
5091     my $salt_hex = substr ($salt_buf, 0, 32);
5092     my $salt     = pack   ("H*", $salt_hex);
5093
5094     my $data_hex = substr ($salt_buf, 32);
5095     my $data     = pack   ("H*", $data_hex);
5096
5097     my $pbkdf2 = Crypt::PBKDF2->new
5098     (
5099       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
5100       iterations => int $iterations
5101     );
5102
5103     my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
5104
5105     $hash_buf = hmac_hex ($data, substr ($key, 32, 32), \&sha256, 64);
5106
5107     $tmp_hash = sprintf ("%s:%s:%d:%s", $hash_buf, $salt_hex, $iterations, $data_hex);
5108   }
5109   elsif ($mode == 8300)
5110   {
5111     my ($domain, $salt_hex) = split (":", $salt_buf);
5112
5113     my $hashalg = Net::DNS::SEC->digtype ("SHA1");
5114
5115     my $salt = pack ("H*", $salt_hex);
5116
5117     my $iterations = 1;
5118
5119     if (defined ($iter))
5120     {
5121       $iterations = $iter;
5122     }
5123
5124     my $name = lc ($word_buf . $domain);
5125
5126     my $hash_buf = Net::DNS::RR::NSEC3::name2hash ($hashalg, $name, $iterations, $salt);
5127
5128     $tmp_hash = sprintf ("%s:%s:%s:%d", $hash_buf, $domain, $salt_hex, $iterations);
5129   }
5130   elsif ($mode == 8400)
5131   {
5132     $hash_buf = sha1_hex ($salt_buf . sha1_hex ($salt_buf . sha1_hex ($word_buf)));
5133
5134     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5135   }
5136   elsif ($mode == 8500)
5137   {
5138     $hash_buf = racf_hash (uc $salt_buf, $word_buf);
5139
5140     $tmp_hash = sprintf ('$racf$*%s*%s', uc $salt_buf, uc $hash_buf);
5141   }
5142   elsif ($mode == 8600)
5143   {
5144     my @saved_key = map { ord $_; } split "", $word_buf;
5145
5146     my $len = scalar @saved_key;
5147
5148     my @state = domino_big_md (\@saved_key, $len);
5149
5150     $tmp_hash = sprintf ('%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x',
5151       $state[ 0],
5152       $state[ 1],
5153       $state[ 2],
5154       $state[ 3],
5155       $state[ 4],
5156       $state[ 5],
5157       $state[ 6],
5158       $state[ 7],
5159       $state[ 8],
5160       $state[ 9],
5161       $state[10],
5162       $state[11],
5163       $state[12],
5164       $state[13],
5165       $state[14],
5166       $state[15],
5167     );
5168   }
5169   elsif ($mode == 8700)
5170   {
5171     my $domino_char = undef;
5172
5173     if (defined ($additional_param))
5174     {
5175       $domino_char = $additional_param;
5176     }
5177
5178     my @saved_key = map { ord $_; } split "", $word_buf;
5179
5180     my $len = scalar @saved_key;
5181
5182     my @state = domino_big_md (\@saved_key, $len);
5183
5184     my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5185
5186     @saved_key = map { ord $_; } split "", $salt_buf . uc $str;
5187
5188     @state = domino_big_md (\@saved_key, 34);
5189
5190     $hash_buf = join ("", (map { chr $_; } @state));
5191
5192     $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_buf . $hash_buf, $domino_char));
5193   }
5194   elsif ($mode == 8900)
5195   {
5196     my $N = 1024;
5197     my $r = 1;
5198     my $p = 1;
5199
5200     if (defined ($additional_param))
5201     {
5202       $N = $additional_param;
5203       $r = $additional_param2;
5204       $p = $additional_param3;
5205     }
5206
5207     $hash_buf = scrypt_hash ($word_buf, $salt_buf, $N, $r, $p, 32);
5208
5209     $tmp_hash = sprintf ('%s', $hash_buf);
5210   }
5211   elsif ($mode == 9100)
5212   {
5213     my $iterations = 5000;
5214
5215     if (defined ($iter))
5216     {
5217       $iterations = $iter;
5218     }
5219
5220     my $domino_char = undef;
5221
5222     # domino 5 hash - SEC_pwddigest_V1 - -m 8600
5223
5224     my @saved_key = map { ord $_; } split "", $word_buf;
5225
5226     my $len = scalar @saved_key;
5227
5228     my @state = domino_big_md (\@saved_key, $len);
5229
5230
5231     # domino 6 hash - SEC_pwddigest_V2 - -m 8700
5232
5233     my $salt_part = substr ($salt_buf, 0, 5);
5234
5235     my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5236
5237     @saved_key = map { ord $_; } split "", $salt_part . uc $str;
5238
5239     @state = domino_big_md (\@saved_key, 34);
5240
5241     $hash_buf = join ("", (map { chr $_; } @state));
5242
5243     $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_part . $hash_buf, $domino_char));
5244
5245
5246     # domino 8(.5.x) hash - SEC_pwddigest_V3 - -m 9100
5247
5248     my $pbkdf2 = Crypt::PBKDF2->new
5249     (
5250       hash_class => 'HMACSHA1',
5251       iterations => $iterations,
5252       output_len =>  8,
5253       salt_len   => 16,
5254     );
5255
5256     my $chars = "02";
5257
5258     if (defined ($additional_param))
5259     {
5260       $chars = $additional_param;
5261     }
5262
5263     my $digest_new = $pbkdf2->PBKDF2 ($salt_buf, $tmp_hash);
5264
5265     my $iteration_str = "" . $iterations;
5266
5267     for (my $i = length ($iterations); $i < 10; $i++)
5268     {
5269       $iterations = "0" . $iterations;
5270     }
5271
5272     $tmp_hash = sprintf ('(H%s)', domino_85x_encode ($salt_buf . $iterations . $chars . $digest_new, $domino_char));
5273   }
5274   elsif ($mode == 9200)
5275   {
5276     my $iterations = 20000;
5277
5278     my $pbkdf2 = Crypt::PBKDF2->new
5279     (
5280       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
5281       iterations => $iterations
5282     );
5283
5284     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5285
5286     $tmp_hash = "";
5287
5288     for (my $i = 0; $i < 43; $i++)
5289     {
5290       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5291     }
5292
5293     $tmp_hash = sprintf ("\$8\$%s\$%s", $salt_buf, $tmp_hash);
5294   }
5295   elsif ($mode == 9300)
5296   {
5297     my $N = 16384;
5298     my $r = 1;
5299     my $p = 1;
5300
5301     $hash_buf = scrypt_b64 ($word_buf, $salt_buf, $N, $r, $p, 32);
5302
5303     $tmp_hash = "";
5304
5305     for (my $i = 0; $i < 43; $i++)
5306     {
5307       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5308     }
5309
5310     $tmp_hash = sprintf ('$9$%s$%s', $salt_buf, $tmp_hash);
5311   }
5312   elsif ($mode == 9400)
5313   {
5314     my $iterations = 50000;
5315
5316     if (length ($iter))
5317     {
5318       $iterations = int ($iter);
5319     }
5320
5321     my $aes_key_size = 128; # or 256
5322
5323     if (defined ($additional_param2))
5324     {
5325       $aes_key_size = $additional_param2;
5326     }
5327
5328     $salt_buf = pack ("H*", $salt_buf);
5329
5330     my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
5331
5332     for (my $i = 0; $i < $iterations; $i++)
5333     {
5334       my $num32 = pack ("L", $i);
5335
5336       $tmp = sha1 ($num32 . $tmp);
5337     }
5338
5339     my $zero32    = pack ("L", 0x00);
5340
5341     my $derivation_array1 = pack ("C", 0x36) x 64;
5342     my $derivation_array2 = pack ("C", 0x5C) x 64;
5343
5344     $tmp = sha1 ($tmp . $zero32);
5345
5346     my $tmp2 = sha1 ($derivation_array1 ^ $tmp);
5347     my $tmp3 = sha1 ($derivation_array2 ^ $tmp);
5348
5349     my $key = substr ($tmp2 . $tmp3, 0, $aes_key_size / 8);
5350
5351     my $m = Crypt::Mode::ECB->new ('AES', 0);
5352
5353     my $encdata;
5354
5355     if (defined $additional_param)
5356     {
5357       $encdata = $m->decrypt (pack ("H*", $additional_param), $key);
5358     }
5359     else
5360     {
5361       $encdata = "A" x 16; ## can be anything
5362     }
5363
5364     my $data1_buf = $encdata;
5365     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5366
5367     $data1_buf = substr ($data1_buf . ("\x00" x 16), 0, 16);
5368     $data2_buf = substr ($data2_buf . ("\x00" x 16), 0, 32);
5369
5370     my $encrypted1 = unpack ("H*", $m->encrypt ($data1_buf, $key));
5371     my $encrypted2 = unpack ("H*", $m->encrypt ($data2_buf, $key));
5372
5373     $encrypted1 = substr ($encrypted1, 0, 32);
5374     $encrypted2 = substr ($encrypted2, 0, 40);
5375
5376     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2007, 20, $aes_key_size, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5377   }
5378   elsif ($mode == 9500)
5379   {
5380     my $iterations = 100000;
5381
5382     if (length ($iter))
5383     {
5384       $iterations = int ($iter);
5385     }
5386
5387     $salt_buf = pack ("H*", $salt_buf);
5388
5389     my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
5390
5391     for (my $i = 0; $i < $iterations; $i++)
5392     {
5393       my $num32 = pack ("L", $i);
5394
5395       $tmp = sha1 ($num32 . $tmp);
5396     }
5397
5398     my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5399     my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5400
5401     my $final1 = sha1 ($tmp . $encryptedVerifierHashInputBlockKey);
5402     my $final2 = sha1 ($tmp . $encryptedVerifierHashValueBlockKey);
5403
5404     my $key1 = substr ($final1, 0, 16);
5405     my $key2 = substr ($final2, 0, 16);
5406
5407     my $cipher1 = Crypt::CBC->new ({
5408       key         => $key1,
5409       cipher      => "Crypt::Rijndael",
5410       iv          => $salt_buf,
5411       literal_key => 1,
5412       header      => "none",
5413       keysize     => 16,
5414       padding     => "null",
5415     });
5416
5417     my $cipher2 = Crypt::CBC->new ({
5418       key         => $key2,
5419       cipher      => "Crypt::Rijndael",
5420       iv          => $salt_buf,
5421       literal_key => 1,
5422       header      => "none",
5423       keysize     => 16,
5424       padding     => "null",
5425     });
5426
5427     my $encdata;
5428
5429     if (defined $additional_param)
5430     {
5431       $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5432     }
5433     else
5434     {
5435       $encdata = "A" x 16; ## can be anything
5436     }
5437
5438     my $data1_buf = $encdata;
5439     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5440
5441     my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5442     my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5443
5444     $encrypted2 = substr ($encrypted2, 0, 64);
5445
5446     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2010, 100000, 128, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5447   }
5448   elsif ($mode == 9600)
5449   {
5450     my $iterations = 100000;
5451
5452     if (length ($iter))
5453     {
5454       $iterations = int ($iter);
5455     }
5456
5457     $salt_buf = pack ("H*", $salt_buf);
5458
5459     my $tmp = sha512 ($salt_buf . encode ("UTF-16LE", $word_buf));
5460
5461     for (my $i = 0; $i < $iterations; $i++)
5462     {
5463       my $num32 = pack ("L", $i);
5464
5465       $tmp = sha512 ($num32 . $tmp);
5466     }
5467
5468     my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5469     my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5470
5471     my $final1 = sha512 ($tmp . $encryptedVerifierHashInputBlockKey);
5472     my $final2 = sha512 ($tmp . $encryptedVerifierHashValueBlockKey);
5473
5474     my $key1 = substr ($final1, 0, 32);
5475     my $key2 = substr ($final2, 0, 32);
5476
5477     my $cipher1 = Crypt::CBC->new ({
5478       key         => $key1,
5479       cipher      => "Crypt::Rijndael",
5480       iv          => $salt_buf,
5481       literal_key => 1,
5482       header      => "none",
5483       keysize     => 32,
5484       padding     => "null",
5485     });
5486
5487     my $cipher2 = Crypt::CBC->new ({
5488       key         => $key2,
5489       cipher      => "Crypt::Rijndael",
5490       iv          => $salt_buf,
5491       literal_key => 1,
5492       header      => "none",
5493       keysize     => 32,
5494       padding     => "null",
5495     });
5496
5497     my $encdata;
5498
5499     if (defined $additional_param)
5500     {
5501       $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5502     }
5503     else
5504     {
5505       $encdata = "A" x 16; ## can be anything
5506     }
5507
5508     my $data1_buf = $encdata;
5509     my $data2_buf = sha512 (substr ($data1_buf, 0, 16));
5510
5511     my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5512     my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5513
5514     $encrypted2 = substr ($encrypted2, 0, 64);
5515
5516     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2013, 100000, 256, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5517   }
5518   elsif ($mode == 9700)
5519   {
5520     $salt_buf = pack ("H*", $salt_buf);
5521
5522     my $tmp = md5 (encode ("UTF-16LE", $word_buf));
5523
5524     $tmp = substr ($tmp, 0, 5);
5525
5526     my $data;
5527
5528     for (my $i = 0; $i < 16; $i++)
5529     {
5530       $data .= $tmp;
5531       $data .= $salt_buf;
5532     }
5533
5534     $tmp = md5 ($data);
5535
5536     $tmp = substr ($tmp, 0, 5);
5537
5538     my $version;
5539
5540     if (defined $additional_param2)
5541     {
5542       $version = $additional_param2;
5543     }
5544     else
5545     {
5546       $version = (unpack ("L", $tmp) & 1) ? 0 : 1;
5547     }
5548
5549     my $rc4_key = md5 ($tmp . "\x00\x00\x00\x00");
5550
5551     my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5552
5553     my $encdata;
5554
5555     if (defined $additional_param)
5556     {
5557       $encdata = $m->RC4 (pack ("H*", $additional_param));
5558     }
5559     else
5560     {
5561       $encdata = "A" x 16; ## can be anything
5562     }
5563
5564     my $data1_buf = $encdata;
5565     my $data2_buf = md5 (substr ($data1_buf, 0, 16));
5566
5567     $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5568
5569     my $encrypted1 = $m->RC4 ($data1_buf);
5570     my $encrypted2 = $m->RC4 ($data2_buf);
5571
5572     $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5573   }
5574   elsif ($mode == 9800)
5575   {
5576     $salt_buf = pack ("H*", $salt_buf);
5577
5578     my $tmp = sha1 ($salt_buf. encode ("UTF-16LE", $word_buf));
5579
5580     my $version;
5581
5582     if (defined $additional_param2)
5583     {
5584       $version = $additional_param2;
5585     }
5586     else
5587     {
5588       $version = (unpack ("L", $tmp) & 1) ? 3 : 4;
5589     }
5590
5591     my $rc4_key = sha1 ($tmp . "\x00\x00\x00\x00");
5592
5593     if ($version == 3)
5594     {
5595       $rc4_key = substr ($rc4_key, 0, 5) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
5596     }
5597
5598     my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5599
5600     my $encdata;
5601
5602     if (defined $additional_param)
5603     {
5604       $encdata = $m->RC4 (pack ("H*", $additional_param));
5605     }
5606     else
5607     {
5608       $encdata = "A" x 16; ## can be anything
5609     }
5610
5611     my $data1_buf = $encdata;
5612     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5613
5614     $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5615
5616     my $encrypted1 = $m->RC4 ($data1_buf);
5617     my $encrypted2 = $m->RC4 ($data2_buf);
5618
5619     $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5620   }
5621   elsif ($mode == 9900)
5622   {
5623     $tmp_hash = sprintf ("%s", md5_hex ($word_buf . "\0" x (100 - length ($word_buf))));
5624   }
5625   elsif ($mode == 10000)
5626   {
5627     my $iterations = 10000;
5628
5629     if (length ($iter))
5630     {
5631       $iterations = int ($iter);
5632     }
5633
5634     my $pbkdf2 = Crypt::PBKDF2->new
5635     (
5636       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
5637       iterations => $iterations
5638     );
5639
5640     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5641     $hash_buf =~ s/[\r\n]//g;
5642
5643     $tmp_hash = sprintf ("pbkdf2_sha256\$%i\$%s\$%s", $iterations, $salt_buf, $hash_buf);
5644   }
5645   elsif ($mode == 10100)
5646   {
5647     my $seed = pack ("H*", $salt_buf);
5648
5649     my ($hi, $lo) = siphash ($word_buf, $seed);
5650
5651     my $hi_s = sprintf ("%08x", $hi);
5652     my $lo_s = sprintf ("%08x", $lo);
5653
5654     $hi_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5655     $lo_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5656
5657     $tmp_hash = sprintf ("%s%s:2:4:%s", $hi_s, $lo_s, $salt_buf);
5658   }
5659   elsif ($mode == 10200)
5660   {
5661     my $challengeb64 = encode_base64 ($salt_buf);
5662     $challengeb64 =~ s/[\r\n]//g;
5663
5664     my $username;
5665
5666     if (defined $additional_param)
5667     {
5668       $username = $additional_param;
5669     }
5670     else
5671     {
5672       $username = "user";
5673     }
5674
5675     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5);
5676
5677     my $responseb64 = encode_base64 ($username . " " . $hash_buf);
5678     $responseb64 =~ s/[\r\n]//g;
5679
5680     $tmp_hash = sprintf ('$cram_md5$%s$%s', $challengeb64, $responseb64);
5681   }
5682   elsif ($mode == 10300)
5683   {
5684     my $iterations = 1024;
5685
5686     if (length ($iter))
5687     {
5688       $iterations = int ($iter);
5689     }
5690
5691     my $hash_buf = $salt_buf;
5692
5693     for (my $pos = 0; $pos < $iterations; $pos++)
5694     {
5695       $hash_buf = sha1 ($word_buf . $hash_buf);
5696     }
5697
5698     $hash_buf = encode_base64 ($hash_buf . $salt_buf);
5699     $hash_buf =~ s/[\r\n]//g;
5700
5701     $tmp_hash = sprintf ("{x-issha, %i}%s", $iterations, $hash_buf);
5702   }
5703   elsif ($mode == 10400)
5704   {
5705     my $id  = $salt_buf;
5706     my $u   = $additional_param;
5707     my $o   = $additional_param2;
5708     my $P   = $additional_param3;
5709
5710     if (defined $u == 0)
5711     {
5712       $u = "0" x 64;
5713     }
5714
5715     if (defined $o == 0)
5716     {
5717       $o = "0" x 64;
5718     }
5719
5720     if (defined $P == 0)
5721     {
5722       $P = -1;
5723     }
5724
5725     my $padding;
5726
5727     for (my $i = 0; $i < 32; $i++)
5728     {
5729       $padding .= pack ("C", $pdf_padding[$i]);
5730     }
5731
5732     my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, 1, 2, 0);
5733
5734     my $m = Crypt::RC4->new (substr ($res, 0, 5));
5735
5736     $u = $m->RC4 ($padding);
5737
5738     $tmp_hash = sprintf ('$pdf$%d*%d*40*%d*%d*16*%s*32*%s*32*%s', 1, 2, $P, 0, $id, unpack ("H*", $u), $o);
5739   }
5740   elsif ($mode == 10500)
5741   {
5742     my $id  = $salt_buf;
5743     my $u   = $additional_param;
5744     my $o   = $additional_param2;
5745     my $P   = $additional_param3;
5746     my $V   = $additional_param4;
5747     my $R   = $additional_param5;
5748     my $enc = $additional_param6;
5749
5750     if (defined $u == 0)
5751     {
5752       $u = "0" x 64;
5753     }
5754
5755     my $u_save = $u;
5756
5757     if (defined $o == 0)
5758     {
5759       $o = "0" x 64;
5760     }
5761
5762     if (defined $R == 0)
5763     {
5764       $R = get_random_num (3, 5);
5765     }
5766
5767     if (defined $V == 0)
5768     {
5769       $V = ($R == 3) ? 2 : 4;
5770     }
5771
5772     if (defined $P == 0)
5773     {
5774       $P = ($R == 3) ? -4 : -1028;
5775     }
5776
5777     if (defined $enc == 0)
5778     {
5779       $enc = ($R == 3) ? 1 : get_random_num (0, 2);
5780     }
5781
5782     my $padding;
5783
5784     for (my $i = 0; $i < 32; $i++)
5785     {
5786       $padding .= pack ("C", $pdf_padding[$i]);
5787     }
5788
5789     my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, $V, $R, $enc);
5790
5791     my $digest = md5 ($padding . pack ("H*", $id));
5792
5793     my $m = Crypt::RC4->new ($res);
5794
5795     $u = $m->RC4 ($digest);
5796
5797     my @ress = split "", $res;
5798
5799     for (my $x = 1; $x <= 19; $x++)
5800     {
5801       my @xor;
5802
5803       for (my $i = 0; $i < 16; $i++)
5804       {
5805         $xor[$i] = chr (ord ($ress[$i]) ^ $x);
5806       }
5807
5808       my $s = join ("", @xor);
5809
5810       my $m2 = Crypt::RC4->new ($s);
5811
5812       $u = $m2->RC4 ($u);
5813     }
5814
5815     $u .= substr (pack ("H*", $u_save), 16, 16);
5816
5817     $tmp_hash = sprintf ('$pdf$%d*%d*128*%d*%d*16*%s*32*%s*32*%s', $V, $R, $P, $enc, $id, unpack ("H*", $u), $o);
5818   }
5819   elsif ($mode == 10600)
5820   {
5821     my $id   = $salt_buf;
5822     my $rest = $additional_param;
5823
5824     if (defined $id == 0)
5825     {
5826       $id = "0" x 32;
5827     }
5828
5829     if (defined $rest == 0)
5830     {
5831       $rest = "127*";
5832       $rest .= "0" x 64;
5833       $rest .= $id;
5834       $rest .= "0" x 158;
5835       $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
5836     }
5837
5838     my @data = split /\*/, $rest;
5839
5840     my $u = pack ("H*", $data[1]);
5841
5842     my $h = sha256 ($word_buf . substr ($u, 32, 8));
5843
5844     $data[1] = unpack ("H*", $h . substr ($u, 32));
5845
5846     $rest = join ("*", @data);
5847
5848     $tmp_hash = sprintf ('$pdf$5*5*256*-1028*1*16*%s*%s', $id, $rest);
5849   }
5850   elsif ($mode == 10700)
5851   {
5852     my $id   = $salt_buf;
5853     my $rest = $additional_param;
5854
5855     if (defined $id == 0)
5856     {
5857       $id = "0" x 32;
5858     }
5859
5860     if (defined $rest == 0)
5861     {
5862       $rest = "127*";
5863       $rest .= "0" x 64;
5864       $rest .= $id;
5865       $rest .= "0" x 158;
5866       $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
5867     }
5868
5869     my @datax = split /\*/, $rest;
5870
5871     my $u = pack ("H*", $datax[1]);
5872
5873     my $block = sha256 ($word_buf . substr ($u, 32, 8));
5874
5875     my $block_size = 32;
5876
5877     my $data = 0x00 x 64;
5878
5879     my $data_len = 1;
5880
5881     my $data63 = 0;
5882
5883     for (my $i = 0; $i < 64 || $i < $data63 + 32; $i++)
5884     {
5885       $data = $word_buf . $block;
5886
5887       $data_len = length ($data);
5888
5889       for (my $k = 1; $k < 64; $k++)
5890       {
5891         $data .= $word_buf . $block;
5892       }
5893
5894       my $aes = Crypt::CBC->new ({
5895         key         => substr ($block,  0, 16),
5896         cipher      => "Crypt::Rijndael",
5897         iv          => substr ($block, 16, 16),
5898         literal_key => 1,
5899         header      => "none",
5900         keysize     => 16,
5901         padding     => "null",
5902       });
5903
5904       my $data = $aes->encrypt ($data);
5905
5906       my $sum = 0;
5907
5908       for (my $j = 0; $j < 16; $j++)
5909       {
5910         $sum += ord (substr ($data, $j, 1));
5911       }
5912
5913       $block_size = 32 + ($sum % 3) * 16;
5914
5915       if ($block_size == 32)
5916       {
5917         $block = sha256 (substr ($data, 0, $data_len * 64));
5918       }
5919       elsif ($block_size == 48)
5920       {
5921         $block = sha384 (substr ($data, 0, $data_len * 64));
5922       }
5923       elsif ($block_size == 64)
5924       {
5925         $block = sha512 (substr ($data, 0, $data_len * 64));
5926       }
5927
5928       $data63 = ord (substr ($data, $data_len * 64 - 1, 1));
5929     }
5930
5931     $datax[1] = unpack ("H*", substr ($block, 0, 32) . substr ($u, 32));
5932
5933     $rest = join ("*", @datax);
5934
5935     $tmp_hash = sprintf ('$pdf$5*6*256*-1028*1*16*%s*%s', $id, $rest);
5936   }
5937   elsif ($mode == 10800)
5938   {
5939     $hash_buf = sha384_hex ($word_buf);
5940
5941     $tmp_hash = sprintf ("%s", $hash_buf);
5942   }
5943   elsif ($mode == 10900)
5944   {
5945     my $iterations = 1000;
5946
5947     if (length ($iter))
5948     {
5949       $iterations = int ($iter);
5950     }
5951
5952     my $out_len = 24;
5953
5954     if (defined $additional_param)
5955     {
5956       $out_len = $additional_param;
5957     }
5958
5959     my $pbkdf2 = Crypt::PBKDF2->new
5960     (
5961       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
5962       iterations => $iterations,
5963       output_len => $out_len
5964     );
5965
5966     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5967     $hash_buf =~ s/[\r\n]//g;
5968
5969     my $base64_salt_buf = encode_base64 ($salt_buf);
5970
5971     chomp ($base64_salt_buf);
5972
5973     $tmp_hash = sprintf ("sha256:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
5974   }
5975   elsif ($mode == 11000)
5976   {
5977     $hash_buf = md5_hex ($salt_buf . $word_buf);
5978
5979     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5980   }
5981   elsif ($mode == 11100)
5982   {
5983     my $user = "postgres";
5984
5985     if (defined $additional_param)
5986     {
5987       $user = $additional_param;
5988     }
5989
5990     $hash_buf = md5_hex (md5_hex ($word_buf . $user) . pack ("H*", $salt_buf));
5991
5992     $tmp_hash = sprintf ("\$postgres\$%s*%s*%s", $user, $salt_buf, $hash_buf);
5993   }
5994   elsif ($mode == 11200)
5995   {
5996     my $sha1_pass   = sha1 ($word_buf);
5997     my $double_sha1 = sha1 ($sha1_pass);
5998
5999     my $xor_part1 = $sha1_pass;
6000     my $xor_part2 = sha1 (pack ("H*", $salt_buf) . $double_sha1);
6001
6002     my $hash_buf = "";
6003
6004     for (my $i = 0; $i < 20; $i++)
6005     {
6006       my $first_byte  = substr ($xor_part1, $i, 1);
6007       my $second_byte = substr ($xor_part2, $i, 1);
6008
6009       my $xor_result = $first_byte ^ $second_byte;
6010
6011       $hash_buf .= unpack ("H*", $xor_result);
6012     }
6013
6014     $tmp_hash = sprintf ("\$mysqlna\$%s*%s", $salt_buf, $hash_buf);
6015   }
6016   elsif ($mode == 11300)
6017   {
6018     my $ckey_buf = get_random_string (96);
6019
6020     if (length ($additional_param))
6021     {
6022       $ckey_buf = $additional_param;
6023     }
6024
6025     my $public_key_buf = get_random_string (66);
6026
6027     if (length ($additional_param2))
6028     {
6029       $public_key_buf = $additional_param2;
6030     }
6031
6032     my $salt_iter = get_random_num (150000, 250000);
6033
6034     if (length ($iter))
6035     {
6036       $salt_iter = int ($iter);
6037     }
6038
6039     my $hash_buf = sha512 ($word_buf . pack ("H*", $salt_buf));
6040
6041     for (my $i = 1; $i < $salt_iter; $i++)
6042     {
6043       $hash_buf = sha512 ($hash_buf);
6044     }
6045
6046     my $data = get_random_string (32);
6047
6048     my $aes = Crypt::CBC->new ({
6049       key         => substr ($hash_buf,  0, 32),
6050       cipher      => "Crypt::Rijndael",
6051       iv          => substr ($hash_buf, 32, 16),
6052       literal_key => 1,
6053       header      => "none",
6054       keysize     => 32,
6055       padding     => "standard",
6056     });
6057
6058     my $cry_master_buf = (unpack ("H*", $aes->encrypt ($data)));
6059
6060     $tmp_hash = sprintf ('$bitcoin$%d$%s$%d$%s$%d$%d$%s$%d$%s',
6061       length ($cry_master_buf),
6062       $cry_master_buf,
6063       length ($salt_buf),
6064       $salt_buf,
6065       $salt_iter,
6066       length ($ckey_buf),
6067       $ckey_buf,
6068       length ($public_key_buf),
6069       $public_key_buf);
6070   }
6071   elsif ($mode == 11400)
6072   {
6073     my ($directive, $URI_server, $URI_client, $user, $realm, $nonce, $nonce_count, $nonce_client, $qop, $method, $URI, $URI_prefix, $URI_resource, $URI_suffix);
6074
6075     $directive = "MD5"; # only directive currently supported
6076
6077     if (defined ($additional_param))
6078     {
6079       $user   = $additional_param;
6080       $realm  = $additional_param2;
6081       $nonce  = $salt_buf;
6082       $nonce_count  = $additional_param3;
6083       $nonce_client = $additional_param4;
6084       $qop = $additional_param5;
6085       $method = $additional_param6;
6086
6087       $URI_prefix   = $additional_param7;
6088       $URI_resource = $additional_param8;
6089       $URI_suffix   = $additional_param9;
6090
6091       # not needed information
6092
6093       $URI_server = $additional_param10;
6094       $URI_client = $additional_param11;
6095     }
6096     else
6097     {
6098       $user   = get_random_string (get_random_num (0, 12 + 1));
6099
6100       # special limit: (user_len + 1 + realm_len + 1 + word_buf_len) < 56
6101       my $realm_max_len = 55 - length ($user) - 1 - length ($word_buf) - 1;
6102
6103       if ($realm_max_len < 1) # should never happen
6104       {
6105         $realm_max_len = 1;
6106       }
6107
6108       $realm_max_len = min (20, $realm_max_len);
6109
6110       $realm  = get_random_string (get_random_num (0, $realm_max_len + 1));
6111
6112       $nonce  = $salt_buf;
6113
6114       if (get_random_num (0, 1 + 1) == 1)
6115       {
6116         $qop = "auth";
6117
6118         $nonce_count  = get_random_string (get_random_num (0, 10 + 1));
6119         $nonce_client = get_random_string (get_random_num (0, 12 + 1));
6120       }
6121       else
6122       {
6123         $qop = "";
6124
6125         $nonce_count  = "";
6126         $nonce_client = "";
6127       }
6128
6129       $method = get_random_string (get_random_num (0, 24 + 1));
6130
6131       $URI_prefix   = get_random_string (get_random_num (0, 10 + 1));
6132       $URI_resource = get_random_string (get_random_num (1, 32 + 1));
6133       $URI_suffix   = get_random_string (get_random_num (0, 32 + 1));
6134
6135       # not needed information
6136
6137       $URI_server = get_random_string (get_random_num (0, 32 + 1));
6138       $URI_client = $URI_resource; # simplification
6139     }
6140
6141     # start
6142
6143     $URI = "";
6144
6145     if (length ($URI_prefix) > 0)
6146     {
6147       $URI = $URI_prefix . ":";
6148     }
6149
6150     $URI .= $URI_resource;
6151
6152     if (length ($URI_suffix) > 0)
6153     {
6154       $URI .= ":" . $URI_suffix;
6155     }
6156
6157     my $HA2 = md5_hex ($method . ":" . $URI);
6158
6159     my $HA1 = md5_hex ($user . ":" . $realm . ":" . $word_buf);
6160
6161     my $tmp_buf;
6162
6163     if (($qop eq "auth") || ($qop eq "auth-int"))
6164     {
6165       $tmp_buf = $nonce . ":" . $nonce_count . ":" . $nonce_client . ":" . $qop;
6166     }
6167     else
6168     {
6169       $tmp_buf = $nonce;
6170     }
6171
6172     my $hash_buf = md5_hex ($HA1 . ":" . $tmp_buf . ":" . $HA2);
6173
6174     $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);
6175   }
6176   elsif ($mode == 11500)
6177   {
6178     $hash_buf = crc32 ($word_buf);
6179
6180     $tmp_hash = sprintf ("%08x:00000000", $hash_buf);
6181   }
6182   elsif ($mode == 11600)
6183   {
6184     my ($p, $num_cycle_power, $seven_zip_salt_len, $seven_zip_salt_buf, $salt_len, $data_len, $unpack_size, $data_buf);
6185
6186     $p = 0; # is fixed
6187
6188     my $validation_only = 0;
6189
6190     $validation_only = 1 if (defined ($additional_param));
6191
6192     if ($validation_only == 1)
6193     {
6194       $num_cycle_power = int ($iter);
6195       $seven_zip_salt_len = $additional_param;
6196       $seven_zip_salt_buf = $additional_param2;
6197       $salt_len = $additional_param3;
6198       # $salt_buf set in parser
6199       # $hash_buf (resulting crc)
6200       $data_len = $additional_param4;
6201       $unpack_size = $additional_param5;
6202       $data_buf = $additional_param6;
6203     }
6204     else
6205     {
6206       $num_cycle_power = 14; # by default it is 19
6207       $seven_zip_salt_len = 0;
6208       $seven_zip_salt_buf = "";
6209       $salt_len = length ($salt_buf);
6210       # $salt_buf set automatically
6211       # $hash_buf (resulting crc)
6212       # $data_len will be set when encrypting
6213       $unpack_size = get_random_num (1, 32 + 1);
6214       $data_buf = get_random_string ($unpack_size);
6215     }
6216
6217     #
6218     # 2 ^ NumCyclesPower "iterations" of SHA256 (only one final SHA256)
6219     #
6220
6221     $word_buf = encode ("UTF-16LE", $word_buf);
6222
6223     my $rounds = 1 << $num_cycle_power;
6224
6225     my $pass_buf = "";
6226
6227     for (my $i = 0; $i < $rounds; $i++)
6228     {
6229       my $num_buf = "";
6230
6231       $num_buf .= pack ("V", $i);
6232       $num_buf .= "\x00" x 4;
6233
6234       # this would be better but only works on 64-bit systems:
6235       # $num_buf = pack ("q", $i);
6236
6237       $pass_buf .= sprintf ("%s%s", $word_buf, $num_buf);
6238     }
6239
6240     my $key = sha256 ($pass_buf);
6241
6242     # the salt_buf is our IV for AES CBC
6243     # pad the salt_buf
6244
6245     my $salt_buf_len = length ($salt_buf);
6246     my $salt_padding_len = 0;
6247
6248     if ($salt_buf_len < 16)
6249     {
6250       $salt_padding_len = 16 - $salt_buf_len;
6251     }
6252
6253     $salt_buf .= "\x00" x $salt_padding_len;
6254
6255     my $aes = Crypt::CBC->new ({
6256       cipher      => "Crypt::Rijndael",
6257       key         => $key,
6258       keysize     => 32,
6259       literal_key => 1,
6260       iv          => $salt_buf,
6261       header      => "none",
6262     });
6263
6264     if ($validation_only == 1)
6265     {
6266       # decrypt
6267
6268       my $decrypted_data = $aes->decrypt ($data_buf);
6269
6270       $decrypted_data = substr ($decrypted_data, 0, $unpack_size);
6271
6272       $hash_buf = crc32 ($decrypted_data);
6273     }
6274     else
6275     {
6276       # encrypt
6277
6278       $hash_buf = crc32 ($data_buf);
6279
6280       $data_buf = $aes->encrypt ($data_buf);
6281
6282       $data_len = length ($data_buf);
6283     }
6284
6285     $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));
6286   }
6287   elsif ($mode == 11900)
6288   {
6289     my $iterations = 1000;
6290
6291     if (length ($iter))
6292     {
6293       $iterations = int ($iter);
6294     }
6295
6296     my $out_len = 32;
6297
6298     if (defined $additional_param)
6299     {
6300       $out_len = $additional_param;
6301     }
6302
6303     #
6304     # call PHP here - WTF
6305     #
6306
6307     # sanitize $word_buf and $salt_buf:
6308
6309     my $word_buf_base64 = encode_base64 ($word_buf);
6310     $word_buf_base64 =~ s/[\r\n]//g;
6311
6312     my $salt_buf_base64 = encode_base64 ($salt_buf);
6313     $salt_buf_base64 =~ s/[\r\n]//g;
6314
6315     # sanitize lenghs
6316
6317     $out_len = int ($out_len);
6318
6319     # output is in hex encoding, otherwise it could be screwed (but shouldn't)
6320
6321     my $php_code = <<'END_CODE';
6322
6323     function pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
6324     {
6325         $algorithm = strtolower ($algorithm);
6326
6327         if (! in_array ($algorithm, hash_algos (), true))
6328         {
6329           trigger_error ("PBKDF2 ERROR: Invalid hash algorithm.", E_USER_ERROR);
6330         }
6331
6332         if ($count <= 0 || $key_length <= 0)
6333         {
6334           trigger_error ("PBKDF2 ERROR: Invalid parameters.", E_USER_ERROR);
6335         }
6336
6337         if (function_exists ("hash_pbkdf2"))
6338         {
6339           if (!$raw_output)
6340           {
6341               $key_length = $key_length * 2;
6342           }
6343
6344           return hash_pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output);
6345         }
6346
6347         $hash_length = strlen (hash ($algorithm, "", true));
6348         $block_count = ceil ($key_length / $hash_length);
6349
6350         $output = "";
6351
6352         for ($i = 1; $i <= $block_count; $i++)
6353         {
6354           $last = $salt . pack ("N", $i);
6355
6356           $last = $xorsum = hash_hmac ($algorithm, $last, $password, true);
6357
6358           for ($j = 1; $j < $count; $j++)
6359           {
6360             $xorsum ^= ($last = hash_hmac ($algorithm, $last, $password, true));
6361           }
6362
6363           $output .= $xorsum;
6364         }
6365
6366         if ($raw_output)
6367         {
6368           return substr ($output, 0, $key_length);
6369         }
6370         else
6371         {
6372           return bin2hex (substr ($output, 0, $key_length));
6373         }
6374     }
6375
6376     print pbkdf2 ("md5", base64_decode ("$word_buf_base64"), base64_decode ("$salt_buf_base64"), $iterations, $out_len, False);
6377
6378 END_CODE
6379
6380     # replace with these command line arguments
6381
6382     $php_code =~ s/\$word_buf_base64/$word_buf_base64/;
6383     $php_code =~ s/\$salt_buf_base64/$salt_buf_base64/;
6384     $php_code =~ s/\$iterations/$iterations/;
6385     $php_code =~ s/\$out_len/$out_len/;
6386
6387     my $php_output = `php -r '$php_code'`;
6388
6389     $hash_buf = pack ("H*", $php_output);
6390
6391     $hash_buf = encode_base64 ($hash_buf);
6392     $hash_buf =~ s/[\r\n]//g;
6393
6394     my $base64_salt_buf = encode_base64 ($salt_buf);
6395
6396     chomp ($base64_salt_buf);
6397
6398     $tmp_hash = sprintf ("md5:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6399   }
6400   elsif ($mode == 12000)
6401   {
6402     my $iterations = 1000;
6403
6404     if (length ($iter))
6405     {
6406       $iterations = int ($iter);
6407     }
6408
6409     my $out_len = 16;
6410
6411     if (defined $additional_param)
6412     {
6413       $out_len = $additional_param;
6414     }
6415
6416     my $pbkdf2 = Crypt::PBKDF2->new
6417     (
6418       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'),
6419       iterations => $iterations,
6420       output_len => $out_len
6421     );
6422
6423     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6424     $hash_buf =~ s/[\r\n]//g;
6425
6426     my $base64_salt_buf = encode_base64 ($salt_buf);
6427
6428     chomp ($base64_salt_buf);
6429
6430     $tmp_hash = sprintf ("sha1:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6431   }
6432   elsif ($mode == 12100)
6433   {
6434     my $iterations = 1000;
6435
6436     if (length ($iter))
6437     {
6438       $iterations = int ($iter);
6439     }
6440
6441     my $out_len = 16;
6442
6443     if (defined $additional_param)
6444     {
6445       $out_len = $additional_param;
6446     }
6447
6448     my $pbkdf2 = Crypt::PBKDF2->new
6449     (
6450       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
6451       iterations => $iterations,
6452       output_len => $out_len
6453     );
6454
6455     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6456     $hash_buf =~ s/[\r\n]//g;
6457
6458     my $base64_salt_buf = encode_base64 ($salt_buf);
6459
6460     chomp ($base64_salt_buf);
6461
6462     $tmp_hash = sprintf ("sha512:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6463   }
6464   elsif ($mode == 12200)
6465   {
6466     my $iterations = 65536;
6467
6468     my $default_salt = 0;
6469
6470     if (defined $additional_param)
6471     {
6472       $default_salt = int ($additional_param);
6473     }
6474
6475     if ($default_salt == 1)
6476     {
6477       $salt_buf = "0011223344556677";
6478     }
6479
6480     $hash_buf = sha512 (pack ("H*", $salt_buf) . $word_buf);
6481
6482     for (my $i = 0; $i < $iterations; $i++)
6483     {
6484       $hash_buf = sha512 ($hash_buf);
6485     }
6486
6487     $hash_buf = unpack ("H*", $hash_buf);
6488     $hash_buf = substr ($hash_buf, 0, 16);
6489
6490     if ($default_salt == 0)
6491     {
6492       $tmp_hash = sprintf ("\$ecryptfs\$0\$1\$%s\$%s", $salt_buf, $hash_buf);
6493     }
6494     else
6495     {
6496       $tmp_hash = sprintf ("\$ecryptfs\$0\$%s", $hash_buf);
6497     }
6498   }
6499   elsif ($mode == 12300)
6500   {
6501     my $iterations = 4096;
6502
6503     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
6504
6505     my $pbkdf2 = Crypt::PBKDF2->new (
6506       hasher       => $hasher,
6507       iterations   => $iterations,
6508       output_len   => 64
6509     );
6510
6511     my $salt_bin = pack ("H*", $salt_buf);
6512
6513     my $key = $pbkdf2->PBKDF2 ($salt_bin. "AUTH_PBKDF2_SPEEDY_KEY", $word_buf);
6514
6515     $hash_buf = sha512_hex ($key . $salt_bin);
6516
6517     $tmp_hash = sprintf ("%s%s", uc ($hash_buf), uc ($salt_buf));
6518   }
6519   elsif ($mode == 12400)
6520   {
6521     my $iterations;
6522
6523     if (length ($iter))
6524     {
6525       $iterations = int ($iter);
6526     }
6527     else
6528     {
6529       $iterations = get_random_num (1, 5001 + 1);
6530     }
6531
6532     my $key_value  = fold_password ($word_buf);
6533
6534     my $data = "\x00\x00\x00\x00\x00\x00\x00\x00";
6535     my $salt_value = base64_to_int24 ($salt_buf);
6536
6537     $hash_buf = crypt_rounds ($key_value, $iterations, $salt_value, $data);
6538
6539     $tmp_hash = sprintf ("_%s%s%s", int24_to_base64 ($iterations), $salt_buf, block_to_base64 ($hash_buf));
6540   }
6541   elsif ($mode == 12600)
6542   {
6543     $hash_buf = sha1_hex ($word_buf);
6544
6545     $hash_buf = sha256_hex ($salt_buf . uc $hash_buf);
6546
6547     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
6548   }
6549   elsif ($mode == 12700)
6550   {
6551     my $iterations = 10;
6552
6553     my $data = qq|{
6554   "guid" : "00000000-0000-0000-0000-000000000000",
6555   "sharedKey" : "00000000-0000-0000-0000-000000000000",
6556   "options" : {"pbkdf2_iterations":10,"fee_policy":0,"html5_notifications":false,"logout_time":600000,"tx_display":0,"always_keep_local_backup":false}|;
6557
6558     my $salt_buf_bin = pack ("H*", $salt_buf);
6559
6560     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
6561
6562     my $pbkdf2 = Crypt::PBKDF2->new (
6563       hasher       => $hasher,
6564       iterations   => $iterations,
6565       output_len   => 32
6566     );
6567
6568     my $key = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6569
6570     my $cipher = Crypt::CBC->new ({
6571       key         => $key,
6572       cipher      => "Crypt::Rijndael",
6573       iv          => $salt_buf_bin,
6574       literal_key => 1,
6575       header      => "none",
6576       keysize     => 32
6577     });
6578
6579     my $encrypted = unpack ("H*", $cipher->encrypt ($data));
6580
6581     $tmp_hash = sprintf ("\$blockchain\$%s\$%s", length ($salt_buf . $encrypted) / 2, $salt_buf . $encrypted);
6582   }
6583   elsif ($mode == 12800)
6584   {
6585     my $iterations = 100;
6586
6587     if (length ($iter))
6588     {
6589       $iterations = int ($iter);
6590     }
6591
6592     my $nt = md4_hex (encode ("UTF-16LE", $word_buf));
6593
6594     my $pbkdf2 = Crypt::PBKDF2->new
6595     (
6596       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6597       iterations => $iterations,
6598       output_len => 32
6599     );
6600
6601     my $salt_buf_bin = pack ("H*", $salt_buf);
6602
6603     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, uc (encode ("UTF-16LE", $nt)));
6604
6605     $tmp_hash = sprintf ("v1;PPH1_MD4,%s,%d,%s", $salt_buf, $iterations, unpack ("H*", $hash));
6606   }
6607   elsif ($mode == 12900)
6608   {
6609     my $iterations = 4096;
6610
6611     if (length ($iter))
6612     {
6613       $iterations = int ($iter);
6614     }
6615
6616     my $salt2 = $salt_buf . $salt_buf;
6617
6618     if (defined $additional_param)
6619     {
6620       $salt2 = $additional_param;
6621     }
6622
6623     my $pbkdf2 = Crypt::PBKDF2->new
6624     (
6625       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6626       iterations => $iterations,
6627       output_len => 32
6628     );
6629
6630     my $salt_buf_bin = pack ("H*", $salt_buf);
6631
6632     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6633
6634     my $salt2_bin = pack ("H*", $salt2);
6635
6636     my $hash_hmac = hmac_hex ($salt2_bin, $hash, \&sha256, 64);
6637
6638     $tmp_hash = sprintf ("%s%s%s", $salt2, $hash_hmac, $salt_buf);
6639   }
6640   elsif ($mode == 13000)
6641   {
6642     my $iterations = 15;
6643
6644     if (length ($iter))
6645     {
6646       $iterations = int ($iter);
6647     }
6648
6649     my $iv = "0" x 32;
6650
6651     if (defined $additional_param)
6652     {
6653       $iv = $additional_param;
6654     }
6655
6656     my $pbkdf2 = Crypt::PBKDF2->new
6657     (
6658       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6659       iterations => (1 << $iterations) + 32,
6660       output_len => 32
6661     );
6662
6663     my $salt_buf_bin = pack ("H*", $salt_buf);
6664
6665     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6666
6667     my $hash_final = substr ($hash,  0, 8)
6668                    ^ substr ($hash,  8, 8)
6669                    ^ substr ($hash, 16, 8)
6670                    ^ substr ($hash, 24, 8);
6671
6672     $tmp_hash = sprintf ('$rar5$16$%s$%d$%s$8$%s', $salt_buf, $iterations, $iv, unpack ("H*", $hash_final));
6673   }
6674   elsif ($mode == 13100)
6675   {
6676     my @salt_arr = split ('\$', $salt_buf);
6677
6678     my $user  = $salt_arr[0];
6679
6680     my $realm = $salt_arr[1];
6681
6682     my $spn   = $salt_arr[2];
6683
6684     my $nonce = $salt_arr[3];
6685
6686     my $cleartext_ticket = '6381b03081ada00703050050a00000a11b3019a003020117a1'.
6687     '12041058e0d77776e8b8e03991f2966939222aa2171b154d594b5242544553542e434f4e5'.
6688     '44f534f2e434f4da3133011a003020102a10a30081b067472616e6365a40b3009a0030201'.
6689     '01a1020400a511180f32303136303231353134343735305aa611180f32303136303231353'.
6690     '134343735305aa711180f32303136303231363030343735305aa811180f32303136303232'.
6691     '323134343735305a';
6692
6693     $cleartext_ticket = $nonce . $cleartext_ticket;
6694
6695     my $k = md4 (encode ("UTF-16LE", $word_buf));
6696
6697     my $k1 = hmac_md5 ("\x02\x00\x00\x00", $k);
6698
6699     my $checksum = hmac_md5 (pack ("H*", $cleartext_ticket), $k1);
6700
6701     my $k3 = hmac_md5 ($checksum, $k1);
6702
6703     my $cipher = Crypt::RC4->new ($k3);
6704
6705     my $edata2 = $cipher->RC4 (pack ("H*", $cleartext_ticket));
6706
6707     $tmp_hash = sprintf ('$krb5tgs$23$*%s$%s$%s*$%s$%s', $user, $realm, $spn, unpack ("H*", $checksum), unpack ("H*", $edata2));
6708   }
6709
6710   return ($tmp_hash);
6711 }
6712
6713 sub rnd
6714 {
6715   my $mode = shift;
6716
6717   my $word_len = shift;
6718
6719   my $salt_len = shift;
6720
6721   my $max = $MAX_LEN;
6722
6723   $max = 15 if ($mode == 2410);
6724
6725   if ($is_unicode{$mode})
6726   {
6727     if (! $allow_long_salt{$mode})
6728     {
6729       $word_len = min ($word_len, int ($max / 2) - $salt_len);
6730     }
6731     else
6732     {
6733       $word_len = min ($word_len, int ($max / 2));
6734     }
6735   }
6736   elsif ($less_fifteen{$mode})
6737   {
6738     $word_len = min ($word_len, 15);
6739
6740     if ($mode == 2410)
6741     {
6742       $salt_len = min ($salt_len, 15 - $word_len);
6743     }
6744   }
6745   else
6746   {
6747     if (! $allow_long_salt{$mode})
6748     {
6749       $word_len = min ($word_len, $max - $salt_len);
6750     }
6751   }
6752
6753   if ($word_len < 1)
6754   {
6755     $word_len = 1;
6756   }
6757
6758   ##
6759   ## gen salt
6760   ##
6761
6762   my $salt_buf;
6763
6764   if ($mode == 4800)
6765   {
6766     my @salt_arr;
6767
6768     for (my $i = 0; $i < $salt_len; $i++)
6769     {
6770       my $c = get_random_chr (0x30, 0x39);
6771
6772       push (@salt_arr, $c);
6773     }
6774
6775     $salt_buf = join ("", @salt_arr);
6776
6777     $salt_buf = get_random_md5chap_salt ($salt_buf);
6778   }
6779   elsif ($mode == 5300 || $mode == 5400)
6780   {
6781     $salt_buf = get_random_ike_salt ();
6782   }
6783   elsif ($mode == 5500)
6784   {
6785     $salt_buf = get_random_netntlmv1_salt ($salt_len, $salt_len);
6786   }
6787   elsif ($mode == 5600)
6788   {
6789     $salt_buf = get_random_netntlmv2_salt ($salt_len, $salt_len);
6790   }
6791   elsif ($mode == 6600)
6792   {
6793     $salt_buf = get_random_agilekeychain_salt ();
6794   }
6795   elsif ($mode == 8200)
6796   {
6797     $salt_buf = get_random_cloudkeychain_salt ();
6798   }
6799   elsif ($mode == 8300)
6800   {
6801     $salt_buf = get_random_dnssec_salt ();
6802   }
6803   elsif ($mode == 13100)
6804   {
6805     $salt_buf = get_random_kerberos5_tgs_salt ();
6806   }
6807   else
6808   {
6809     my @salt_arr;
6810
6811     for (my $i = 0; $i < $salt_len; $i++)
6812     {
6813       my $c = get_random_chr (0x30, 0x39);
6814
6815       push (@salt_arr, $c);
6816     }
6817
6818     $salt_buf = join ("", @salt_arr);
6819
6820     if ($mode == 7500)
6821     {
6822       $salt_buf = get_random_kerberos5_salt ($salt_buf);
6823     }
6824   }
6825
6826   ##
6827   ## gen plain
6828   ##
6829
6830   my @word_arr;
6831
6832   for (my $i = 0; $i < $word_len; $i++)
6833   {
6834     my $c = get_random_chr (0x30, 0x39);
6835
6836     push (@word_arr, $c);
6837   }
6838
6839   my $word_buf = join ("", @word_arr);
6840
6841   ##
6842   ## gen hash
6843   ##
6844
6845   my $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
6846
6847   ##
6848   ## run
6849   ##
6850
6851   my @cmd =
6852   (
6853     $hashcat,
6854     "-a 0 -m", $mode,
6855     $tmp_hash
6856   );
6857
6858   print sprintf ("echo -n %-20s | %s \${OPTS} %s %4d '%s'\n", $word_buf, @cmd);
6859 }
6860
6861 ##
6862 ## subs
6863 ##
6864
6865 sub min
6866 {
6867   $_[$_[0] > $_[1]];
6868 }
6869
6870 sub get_random_string
6871 {
6872   my $len = shift;
6873
6874   my @arr;
6875
6876   for (my $i = 0; $i < $len; $i++)
6877   {
6878     my $c = get_random_chr (0x30, 0x39);
6879
6880     push (@arr, $c);
6881   }
6882
6883   my $buf = join ("", @arr);
6884
6885   return $buf;
6886 }
6887
6888 sub get_random_num
6889 {
6890   my $min = shift;
6891   my $max = shift;
6892
6893   return int ((rand ($max - $min)) + $min);
6894 }
6895
6896 sub get_random_chr
6897 {
6898   return chr get_random_num (@_);
6899 }
6900
6901 sub domino_decode
6902 {
6903   my $str = shift;
6904
6905   my $decoded  = "";
6906
6907   for (my $i = 0; $i < length ($str); $i += 4)
6908   {
6909     my $num = domino_base64_decode (substr ($str, $i, 4), 4);
6910
6911     $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
6912   }
6913
6914   my $salt;
6915   my $digest;
6916   my $char;
6917
6918   $salt   = substr ($decoded,  0, 5);
6919
6920   my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
6921
6922   if ($byte10 < 0)
6923   {
6924     $byte10 = 256 + $byte10;
6925   }
6926
6927   substr ($salt, 3, 1) = chr ($byte10);
6928
6929   $digest = substr ($decoded,  5, 9);
6930   $char   = substr ($str,     18, 1);
6931
6932   return ($digest, $salt, $char);
6933 }
6934
6935 sub domino_85x_decode
6936 {
6937   my $str = shift;
6938
6939   my $decoded  = "";
6940
6941   for (my $i = 0; $i < length ($str); $i += 4)
6942   {
6943     my $num = domino_base64_decode (substr ($str, $i, 4), 4);
6944
6945     $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
6946   }
6947
6948   my $digest;
6949   my $salt;
6950   my $iterations = -1;
6951   my $chars;
6952
6953   $salt   = substr ($decoded,  0, 16);  # longer than -m 8700 (5 vs 16 <- new)
6954
6955   my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
6956
6957   if ($byte10 < 0)
6958   {
6959     $byte10 = 256 + $byte10;
6960   }
6961
6962   substr ($salt, 3, 1) = chr ($byte10);
6963
6964   $iterations = substr ($decoded,  16, 10);
6965
6966   if ($iterations =~ /^?d*$/)
6967   {
6968     # continue
6969
6970     $iterations = $iterations + 0;            # hack: make sure it is an int now (atoi ())
6971     $chars = substr ($decoded, 26, 2);        # in my example it is "02"
6972     $digest = substr ($decoded, 28, 8);       # only of length of 8 vs 20 SHA1 bytes
6973   }
6974
6975   return ($digest, $salt, $iterations, $chars);
6976 }
6977
6978 sub domino_base64_decode
6979 {
6980   my $v = shift;
6981   my $n = shift;
6982
6983   my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
6984
6985   my $ret = 0;
6986
6987   my $i = 1;
6988
6989   while ($i <= $n)
6990   {
6991     my $idx = (index ($itoa64, substr ($v, $n - $i, 1))) & 0x3f;
6992
6993     $ret += ($idx << (6 * ($i - 1)));
6994
6995     $i = $i + 1;
6996   }
6997
6998   return $ret
6999 }
7000
7001 sub domino_encode
7002 {
7003   my $final = shift;
7004   my $char  = shift;
7005
7006   my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7007
7008   if ($byte10 > 255)
7009   {
7010     $byte10 = $byte10 - 256;
7011   }
7012
7013   substr ($final, 3, 1) = chr ($byte10);
7014
7015   my $passwd = "";
7016
7017   $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);
7018   $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);
7019   $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);
7020   $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);
7021   $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);
7022
7023   if (defined ($char))
7024   {
7025     substr ($passwd, 18, 1) = $char;
7026   }
7027   substr ($passwd, 19, 1) = "";
7028
7029   return $passwd;
7030 }
7031
7032 sub domino_85x_encode
7033 {
7034   my $final = shift;
7035   my $char  = shift;
7036
7037   my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7038
7039   if ($byte10 > 255)
7040   {
7041     $byte10 = $byte10 - 256;
7042   }
7043
7044   substr ($final, 3, 1) = chr ($byte10);
7045
7046   my $passwd = "";
7047
7048   $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);
7049   $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);
7050   $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);
7051   $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);
7052   $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);
7053   $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);
7054   $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);
7055   $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);
7056   $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);
7057   $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);
7058   $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);
7059   $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);
7060
7061   if (defined ($char))
7062   {
7063     substr ($passwd, 18, 1) = $char;
7064   }
7065
7066   return $passwd;
7067 }
7068
7069 sub domino_base64_encode
7070 {
7071   my $v = shift;
7072   my $n = shift;
7073
7074   my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
7075
7076   my $ret = "";
7077
7078   while (($n - 1) >= 0)
7079   {
7080     $n = $n - 1;
7081
7082     $ret = substr ($itoa64, $v & 0x3f, 1) . $ret;
7083
7084     $v = $v >> 6;
7085   }
7086
7087   return $ret
7088 }
7089
7090 sub pseudo_base64
7091 {
7092   my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7093
7094   my $md5 = shift;
7095   my $s64 = "";
7096   for my $i (0..3) {
7097       my $v = unpack "V", substr($md5, $i*4, 4);
7098       for (1..4) {
7099           $s64 .= substr($itoa64, $v & 0x3f, 1);
7100           $v >>= 6;
7101       }
7102   }
7103   return $s64;
7104 }
7105
7106 sub racf_hash
7107 {
7108   my ($username, $password) = @_;
7109
7110   $username = substr ($username . " " x 8, 0, 8);
7111   $password = substr ($password . " " x 8, 0, 8);
7112
7113   my $username_ebc = ascii2ebcdic ($username);
7114   my $password_ebc = ascii2ebcdic ($password);
7115
7116   my @pw = split ("", $password_ebc);
7117
7118   for (my $i = 0; $i < 8; $i++)
7119   {
7120     $pw[$i] = unpack ("C", $pw[$i]);
7121     $pw[$i] ^= 0x55;
7122     $pw[$i] <<= 1;
7123     $pw[$i] = pack ("C", $pw[$i] & 0xff);
7124   }
7125
7126   my $key = join ("", @pw);
7127
7128   my $cipher = new Crypt::DES $key;
7129
7130   my $ciphertext = $cipher->encrypt ($username_ebc);
7131
7132   my $ct = unpack ("H16", $ciphertext);
7133
7134   return $ct;
7135 }
7136
7137 sub oracle_hash
7138 {
7139   my ($username, $password) = @_;
7140
7141   my $userpass = pack('n*', unpack('C*', uc($username.$password)));
7142   $userpass .= pack('C', 0) while (length($userpass) % 8);
7143
7144   my $key = pack('H*', "0123456789ABCDEF");
7145   my $iv = pack('H*', "0000000000000000");
7146
7147   my $c = new Crypt::CBC(
7148     -literal_key => 1,
7149     -cipher => "DES",
7150     -key => $key,
7151     -iv => $iv,
7152     -header => "none"
7153   );
7154   my $key2 = substr($c->encrypt($userpass), length($userpass)-8, 8);
7155
7156   my $c2 = new Crypt::CBC(
7157     -literal_key => 1,
7158     -cipher => "DES",
7159     -key => $key2,
7160     -iv => $iv,
7161     -header => "none"
7162   );
7163   my $hash = substr($c2->encrypt($userpass), length($userpass)-8, 8);
7164
7165   return uc(unpack('H*', $hash));
7166 }
7167
7168 sub androidpin_hash
7169 {
7170   my $word_buf = shift;
7171
7172   my $salt_buf = shift;
7173
7174   my $w = sprintf ("%d%s%s", 0, $word_buf, $salt_buf);
7175
7176   my $digest = sha1 ($w);
7177
7178   for (my $i = 1; $i < 1024; $i++)
7179   {
7180     $w = $digest . sprintf ("%d%s%s", $i, $word_buf, $salt_buf);
7181
7182     $digest = sha1 ($w);
7183   }
7184
7185   my ($A, $B, $C, $D, $E) = unpack ("N5", $digest);
7186
7187   return sprintf ("%08x%08x%08x%08x%08x", $A, $B, $C, $D, $E);
7188 }
7189
7190 sub to64
7191 {
7192   my $v = shift;
7193   my $n = shift;
7194
7195   my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7196
7197   my $ret = "";
7198
7199   while (($n - 1) >= 0)
7200   {
7201     $n = $n - 1;
7202
7203     $ret .= substr ($itoa64, $v & 0x3f, 1);
7204
7205     $v = $v >> 6;
7206   }
7207
7208   return $ret
7209 }
7210
7211 sub md5_crypt
7212 {
7213   my $magic = shift;
7214
7215   my $iter = shift;
7216   my $pass = shift;
7217   my $salt = shift;
7218
7219   my $hash = ""; # hash to be returned by this function
7220
7221   my $final = md5 ($pass . $salt . $pass);
7222
7223   $salt = substr ($salt, 0, 8);
7224
7225   my $tmp = $pass . $magic . $salt;
7226
7227   my $pass_len = length ($pass);
7228
7229   my $i;
7230
7231   for ($i = $pass_len; $i > 0; $i -= 16)
7232   {
7233     my $len = 16;
7234
7235     if ($i < $len)
7236     {
7237       $len = $i;
7238     }
7239
7240     $tmp .= substr ($final, 0, $len);
7241   }
7242
7243   $i = $pass_len;
7244
7245   while ($i > 0)
7246   {
7247     if ($i & 1)
7248     {
7249       $tmp .= chr (0);
7250     }
7251     else
7252     {
7253       $tmp .= substr ($pass, 0, 1);
7254     }
7255
7256     $i >>= 1;
7257   }
7258
7259   $final = md5 ($tmp);
7260
7261   for ($i = 0; $i < $iter; $i++)
7262   {
7263     $tmp = "";
7264
7265     if ($i & 1)
7266     {
7267       $tmp .= $pass;
7268     }
7269     else
7270     {
7271       $tmp .= $final;
7272     }
7273
7274     if ($i % 3)
7275     {
7276       $tmp .= $salt;
7277     }
7278
7279     if ($i % 7)
7280     {
7281       $tmp .= $pass;
7282     }
7283
7284     if ($i & 1)
7285     {
7286       $tmp .= $final;
7287     }
7288     else
7289     {
7290       $tmp .= $pass;
7291     }
7292
7293     $final = md5 ($tmp);
7294   }
7295
7296   # done
7297   # now format the output sting ("hash")
7298
7299   my $hash_buf;
7300
7301   $hash  = to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final,  6, 1)) << 8) | (ord (substr ($final, 12, 1))), 4);
7302   $hash .= to64 ((ord (substr ($final, 1, 1)) << 16) | (ord (substr ($final,  7, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
7303   $hash .= to64 ((ord (substr ($final, 2, 1)) << 16) | (ord (substr ($final,  8, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
7304   $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final,  9, 1)) << 8) | (ord (substr ($final, 15, 1))), 4);
7305   $hash .= to64 ((ord (substr ($final, 4, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final,  5, 1))), 4);
7306   $hash .= to64 (ord (substr ($final, 11, 1)), 2);
7307
7308   if ($iter == 1000) # default
7309   {
7310     $hash_buf = sprintf ("%s%s\$%s", $magic , $salt , $hash);
7311   }
7312   else
7313   {
7314     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7315   }
7316
7317   return $hash_buf;
7318 }
7319
7320 sub sha512_crypt
7321 {
7322   my $iter = shift;
7323   my $pass = shift;
7324   my $salt = shift;
7325
7326   my $hash = ""; # hash to be returned by this function
7327
7328   my $final = sha512 ($pass . $salt . $pass);
7329
7330   $salt = substr ($salt, 0, 16);
7331
7332   my $tmp = $pass . $salt;
7333
7334   my $pass_len = length ($pass);
7335   my $salt_len = length ($salt);
7336
7337   my $i;
7338
7339   for ($i = $pass_len; $i > 0; $i -= 16)
7340   {
7341     my $len = 16;
7342
7343     if ($i < $len)
7344     {
7345       $len = $i;
7346     }
7347
7348     $tmp .= substr ($final, 0, $len);
7349   }
7350
7351   $i = $pass_len;
7352
7353   while ($i > 0)
7354   {
7355     if ($i & 1)
7356     {
7357       $tmp .= $final;
7358     }
7359     else
7360     {
7361       $tmp .= $pass;
7362     }
7363
7364     $i >>= 1;
7365   }
7366
7367   $final = sha512 ($tmp);
7368
7369   # p_bytes
7370
7371   my $p_bytes = "";
7372
7373   for ($i = 0; $i < $pass_len; $i++)
7374   {
7375     $p_bytes .= $pass;
7376   }
7377
7378   $p_bytes = sha512 ($p_bytes);
7379   $p_bytes = substr ($p_bytes, 0, $pass_len);
7380
7381   # s_bytes
7382
7383   my $final_first_byte = ord (substr ($final, 0, 1));
7384
7385   my $s_bytes = "";
7386
7387   for ($i = 0; $i < (16 + $final_first_byte); $i++)
7388   {
7389     $s_bytes .= $salt;
7390   }
7391
7392   $s_bytes = sha512 ($s_bytes);
7393   $s_bytes = substr ($s_bytes, 0, $salt_len);
7394
7395   for ($i = 0; $i < $iter; $i++)
7396   {
7397     $tmp = "";
7398
7399     if ($i & 1)
7400     {
7401       $tmp .= $p_bytes;
7402     }
7403     else
7404     {
7405       $tmp .= $final;
7406     }
7407
7408     if ($i % 3)
7409     {
7410       $tmp .= $s_bytes;
7411     }
7412
7413     if ($i % 7)
7414     {
7415       $tmp .= $p_bytes;
7416     }
7417
7418     if ($i & 1)
7419     {
7420       $tmp .= $final;
7421     }
7422     else
7423     {
7424       $tmp .= $p_bytes;
7425     }
7426
7427     $final = sha512 ($tmp);
7428   }
7429
7430   # done
7431   # now format the output string ("hash")
7432
7433   my $hash_buf;
7434
7435   $hash .= to64 ((ord (substr ($final,  0, 1)) << 16) | (ord (substr ($final, 21, 1)) << 8) | (ord (substr ($final, 42, 1))), 4);
7436   $hash .= to64 ((ord (substr ($final, 22, 1)) << 16) | (ord (substr ($final, 43, 1)) << 8) | (ord (substr ($final,  1, 1))), 4);
7437   $hash .= to64 ((ord (substr ($final, 44, 1)) << 16) | (ord (substr ($final,  2, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
7438   $hash .= to64 ((ord (substr ($final,  3, 1)) << 16) | (ord (substr ($final, 24, 1)) << 8) | (ord (substr ($final, 45, 1))), 4);
7439   $hash .= to64 ((ord (substr ($final, 25, 1)) << 16) | (ord (substr ($final, 46, 1)) << 8) | (ord (substr ($final,  4, 1))), 4);
7440   $hash .= to64 ((ord (substr ($final, 47, 1)) << 16) | (ord (substr ($final,  5, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
7441   $hash .= to64 ((ord (substr ($final,  6, 1)) << 16) | (ord (substr ($final, 27, 1)) << 8) | (ord (substr ($final, 48, 1))), 4);
7442   $hash .= to64 ((ord (substr ($final, 28, 1)) << 16) | (ord (substr ($final, 49, 1)) << 8) | (ord (substr ($final,  7, 1))), 4);
7443   $hash .= to64 ((ord (substr ($final, 50, 1)) << 16) | (ord (substr ($final,  8, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
7444   $hash .= to64 ((ord (substr ($final,  9, 1)) << 16) | (ord (substr ($final, 30, 1)) << 8) | (ord (substr ($final, 51, 1))), 4);
7445   $hash .= to64 ((ord (substr ($final, 31, 1)) << 16) | (ord (substr ($final, 52, 1)) << 8) | (ord (substr ($final, 10, 1))), 4);
7446   $hash .= to64 ((ord (substr ($final, 53, 1)) << 16) | (ord (substr ($final, 11, 1)) << 8) | (ord (substr ($final, 32, 1))), 4);
7447   $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 33, 1)) << 8) | (ord (substr ($final, 54, 1))), 4);
7448   $hash .= to64 ((ord (substr ($final, 34, 1)) << 16) | (ord (substr ($final, 55, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
7449   $hash .= to64 ((ord (substr ($final, 56, 1)) << 16) | (ord (substr ($final, 14, 1)) << 8) | (ord (substr ($final, 35, 1))), 4);
7450   $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 36, 1)) << 8) | (ord (substr ($final, 57, 1))), 4);
7451   $hash .= to64 ((ord (substr ($final, 37, 1)) << 16) | (ord (substr ($final, 58, 1)) << 8) | (ord (substr ($final, 16, 1))), 4);
7452   $hash .= to64 ((ord (substr ($final, 59, 1)) << 16) | (ord (substr ($final, 17, 1)) << 8) | (ord (substr ($final, 38, 1))), 4);
7453   $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 39, 1)) << 8) | (ord (substr ($final, 60, 1))), 4);
7454   $hash .= to64 ((ord (substr ($final, 40, 1)) << 16) | (ord (substr ($final, 61, 1)) << 8) | (ord (substr ($final, 19, 1))), 4);
7455   $hash .= to64 ((ord (substr ($final, 62, 1)) << 16) | (ord (substr ($final, 20, 1)) << 8) | (ord (substr ($final, 41, 1))), 4);
7456   $hash .= to64 (ord (substr ($final,  63, 1)), 2);
7457
7458   my $magic = '$6$';
7459
7460   if ($iter == 5000) # default
7461   {
7462     $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
7463   }
7464   else
7465   {
7466     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7467   }
7468
7469   return $hash_buf;
7470 }
7471
7472 sub sha256_crypt
7473 {
7474   my $iter = shift;
7475   my $pass = shift;
7476   my $salt = shift;
7477
7478   my $hash = ""; # hash to be returned by this function
7479
7480   my $final = sha256 ($pass . $salt . $pass);
7481
7482   $salt = substr ($salt, 0, 16);
7483
7484   my $tmp = $pass . $salt;
7485
7486   my $pass_len = length ($pass);
7487   my $salt_len = length ($salt);
7488
7489   my $i;
7490
7491   for ($i = $pass_len; $i > 0; $i -= 16)
7492   {
7493     my $len = 16;
7494
7495     if ($i < $len)
7496     {
7497       $len = $i;
7498     }
7499
7500     $tmp .= substr ($final, 0, $len);
7501   }
7502
7503   $i = $pass_len;
7504
7505   while ($i > 0)
7506   {
7507     if ($i & 1)
7508     {
7509       $tmp .= $final;
7510     }
7511     else
7512     {
7513       $tmp .= $pass;
7514     }
7515
7516     $i >>= 1;
7517   }
7518
7519   $final = sha256 ($tmp);
7520
7521   # p_bytes
7522
7523   my $p_bytes = "";
7524
7525   for ($i = 0; $i < $pass_len; $i++)
7526   {
7527     $p_bytes .= $pass;
7528   }
7529
7530   $p_bytes = sha256 ($p_bytes);
7531   $p_bytes = substr ($p_bytes, 0, $pass_len);
7532
7533   # s_bytes
7534
7535   my $final_first_byte = ord (substr ($final, 0, 1));
7536
7537   my $s_bytes = "";
7538
7539   for ($i = 0; $i < (16 + $final_first_byte); $i++)
7540   {
7541     $s_bytes .= $salt;
7542   }
7543
7544   $s_bytes = sha256 ($s_bytes);
7545   $s_bytes = substr ($s_bytes, 0, $salt_len);
7546
7547   for ($i = 0; $i < $iter; $i++)
7548   {
7549     $tmp = "";
7550
7551     if ($i & 1)
7552     {
7553       $tmp .= $p_bytes;
7554     }
7555     else
7556     {
7557       $tmp .= $final;
7558     }
7559
7560     if ($i % 3)
7561     {
7562       $tmp .= $s_bytes;
7563     }
7564
7565     if ($i % 7)
7566     {
7567       $tmp .= $p_bytes;
7568     }
7569
7570     if ($i & 1)
7571     {
7572       $tmp .= $final;
7573     }
7574     else
7575     {
7576       $tmp .= $p_bytes;
7577     }
7578
7579     $final = sha256 ($tmp);
7580   }
7581
7582   # done
7583   # now format the output string ("hash")
7584
7585   my $hash_buf;
7586
7587   $hash .= to64 ((ord (substr ($final,  0, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 20, 1))), 4);
7588   $hash .= to64 ((ord (substr ($final, 21, 1)) << 16) | (ord (substr ($final,  1, 1)) << 8) | (ord (substr ($final, 11, 1))), 4);
7589   $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 22, 1)) << 8) | (ord (substr ($final,  2, 1))), 4);
7590   $hash .= to64 ((ord (substr ($final,  3, 1)) << 16) | (ord (substr ($final, 13, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
7591   $hash .= to64 ((ord (substr ($final, 24, 1)) << 16) | (ord (substr ($final,  4, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
7592   $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 25, 1)) << 8) | (ord (substr ($final,  5, 1))), 4);
7593   $hash .= to64 ((ord (substr ($final,  6, 1)) << 16) | (ord (substr ($final, 16, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
7594   $hash .= to64 ((ord (substr ($final, 27, 1)) << 16) | (ord (substr ($final,  7, 1)) << 8) | (ord (substr ($final, 17, 1))), 4);
7595   $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 28, 1)) << 8) | (ord (substr ($final,  8, 1))), 4);
7596   $hash .= to64 ((ord (substr ($final,  9, 1)) << 16) | (ord (substr ($final, 19, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
7597   $hash .= to64 ((ord (substr ($final, 31, 1)) <<  8) | (ord (substr ($final, 30, 1))), 3);
7598
7599   my $magic = '$5$';
7600
7601   if ($iter == 5000) # default
7602   {
7603     $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
7604   }
7605   else
7606   {
7607     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7608   }
7609
7610   return $hash_buf;
7611 }
7612
7613 sub aix_ssha256_pbkdf2
7614 {
7615   my $word_buf   = shift;
7616   my $salt_buf   = shift;
7617   my $iterations = shift;
7618
7619   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256);
7620
7621   my $pbkdf2 = Crypt::PBKDF2->new (
7622     hasher       => $hasher,
7623     iterations   => $iterations,
7624     output_len   => 32
7625   );
7626
7627   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7628
7629   my $tmp_hash = "";
7630
7631   $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);
7632   $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);
7633   $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);
7634   $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);
7635   $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);
7636   $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);
7637   $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);
7638   $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);
7639   $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);
7640   $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);
7641   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 30, 1))) << 16) | (int (ord (substr ($hash_buf, 31, 1))) << 8)                                          , 3);
7642
7643   return $tmp_hash;
7644 }
7645
7646 sub aix_ssha512_pbkdf2
7647 {
7648   my $word_buf   = shift;
7649   my $salt_buf   = shift;
7650   my $iterations = shift;
7651
7652   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
7653
7654   my $pbkdf2 = Crypt::PBKDF2->new (
7655     hasher       => $hasher,
7656     iterations   => $iterations,
7657   );
7658
7659   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7660
7661   my $tmp_hash = "";
7662
7663   $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);
7664   $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);
7665   $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);
7666   $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);
7667   $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);
7668   $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);
7669   $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);
7670   $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);
7671   $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);
7672   $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);
7673   $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);
7674   $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);
7675   $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);
7676   $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);
7677   $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);
7678   $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);
7679   $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);
7680   $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);
7681   $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);
7682   $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);
7683   $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);
7684   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 63, 1))) << 16)                                                                                         , 2);
7685
7686   return $tmp_hash;
7687 }
7688
7689 sub aix_ssha1_pbkdf2
7690 {
7691   my $word_buf   = shift;
7692   my $salt_buf   = shift;
7693   my $iterations = shift;
7694
7695   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
7696
7697   my $pbkdf2 = Crypt::PBKDF2->new (
7698     hasher       => $hasher,
7699     iterations   => $iterations,
7700   );
7701
7702   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7703
7704   my $tmp_hash = "";
7705
7706   $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);
7707   $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);
7708   $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);
7709   $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);
7710   $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);
7711   $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);
7712   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8)                                          , 3);
7713
7714   return $tmp_hash;
7715 }
7716
7717 sub sapb_transcode
7718 {
7719   my $data_s = shift;
7720
7721   my @data = split "", $data_s;
7722
7723   my $transTable_s =
7724     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7725     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7726     "\x3f\x40\x41\x50\x43\x44\x45\x4b\x47\x48\x4d\x4e\x54\x51\x53\x46" .
7727     "\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x56\x55\x5c\x49\x5d\x4a" .
7728     "\x42\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
7729     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x58\x5b\x59\xff\x52" .
7730     "\x4c\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
7731     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x57\x5e\x5a\x4f\xff" .
7732     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7733     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7734     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7735     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7736     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7737     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7738     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7739     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
7740
7741   my @transTable = unpack ("C256", $transTable_s);
7742
7743   my @out;
7744
7745   for (my $i = 0; $i < scalar @data; $i++)
7746   {
7747     $out[$i] = $transTable[int (ord ($data[$i]))];
7748   }
7749
7750   return pack ("C*", @out);
7751 }
7752
7753 sub sapb_waldorf
7754 {
7755   my $digest_s = shift;
7756
7757   my $w_s = shift;
7758   my $s_s = shift;
7759
7760   my @w = unpack "C*", $w_s;
7761   my @s = unpack "C*", $s_s;
7762
7763   my $bcodeTable_s =
7764     "\x14\x77\xf3\xd4\xbb\x71\x23\xd0\x03\xff\x47\x93\x55\xaa\x66\x91" .
7765     "\xf2\x88\x6b\x99\xbf\xcb\x32\x1a\x19\xd9\xa7\x82\x22\x49\xa2\x51" .
7766     "\xe2\xb7\x33\x71\x8b\x9f\x5d\x01\x44\x70\xae\x11\xef\x28\xf0\x0d";
7767
7768   my @bcodeTable = unpack ("C48", $bcodeTable_s);
7769
7770   my @abcd = unpack ("C16", $digest_s);
7771
7772   my $sum20 = ($abcd[0] & 3)
7773             + ($abcd[1] & 3)
7774             + ($abcd[2] & 3)
7775             + ($abcd[3] & 3)
7776             + ($abcd[5] & 3);
7777
7778   $sum20 |= 0x20;
7779
7780   my @out;
7781
7782   for (my $i2 = 0; $i2 < $sum20; $i2++)
7783   {
7784     $out[$i2] = 0;
7785   }
7786
7787   for (my $i1 = 0, my $i2 = 0, my $i3 = 0; $i2 < $sum20; $i2++, $i2++)
7788   {
7789     if ($i1 < length $w_s)
7790     {
7791       if ($abcd[15 - $i1] & 1)
7792       {
7793         $out[$i2] = $bcodeTable[48 - 1 - $i1];
7794
7795         $i2++;
7796       }
7797
7798       $out[$i2] = $w[$i1];
7799
7800       $i1++;
7801       $i2++;
7802     }
7803
7804     if ($i3 < length $s_s)
7805     {
7806       $out[$i2] = $s[$i3];
7807
7808       $i2++;
7809       $i3++;
7810     }
7811
7812     $out[$i2] = $bcodeTable[$i2 - $i1 - $i3];
7813   }
7814
7815   return substr (pack ("C*", @out), 0, $sum20);
7816 }
7817
7818 sub setup_des_key
7819 {
7820   my @key_56 = split (//, shift);
7821
7822   my $key = "";
7823
7824   $key = $key_56[0];
7825
7826   $key .= chr(((ord($key_56[0]) << 7) | (ord($key_56[1]) >> 1)) & 255);
7827   $key .= chr(((ord($key_56[1]) << 6) | (ord($key_56[2]) >> 2)) & 255);
7828   $key .= chr(((ord($key_56[2]) << 5) | (ord($key_56[3]) >> 3)) & 255);
7829   $key .= chr(((ord($key_56[3]) << 4) | (ord($key_56[4]) >> 4)) & 255);
7830   $key .= chr(((ord($key_56[4]) << 3) | (ord($key_56[5]) >> 5)) & 255);
7831   $key .= chr(((ord($key_56[5]) << 2) | (ord($key_56[6]) >> 6)) & 255);
7832   $key .= chr(( ord($key_56[6]) << 1) & 255);
7833
7834   return $key;
7835 }
7836
7837 sub randbytes
7838 {
7839   my $len = shift;
7840
7841   my @arr;
7842
7843   for (my $i = 0; $i < $len; $i++)
7844   {
7845     my $c = get_random_chr (0, 255);
7846
7847     push (@arr, $c);
7848   }
7849
7850   return join ("", @arr);
7851 }
7852
7853 sub get_random_netntlmv1_salt
7854 {
7855   my $len_user   = shift;
7856   my $len_domain = shift;
7857
7858   my $char;
7859   my $type;
7860   my $user = "";
7861
7862   for (my $i = 0; $i < $len_user; $i++)
7863   {
7864     $type = get_random_num (1, 3);
7865
7866     if ($type == 1)
7867     {
7868       $char = get_random_chr (0x30, 0x39);
7869     }
7870     elsif ($type == 2)
7871     {
7872       $char = get_random_chr (0x41, 0x5A);
7873     }
7874     else
7875     {
7876       $char = get_random_chr (0x61, 0x7A);
7877     }
7878
7879     $user .= $char;
7880   }
7881
7882   my $domain = "";
7883
7884   for (my $i = 0; $i < $len_domain; $i++)
7885   {
7886     $type = get_random_num (1, 3);
7887
7888     if ($type == 1)
7889     {
7890       $char = get_random_chr (0x30, 0x39);
7891     }
7892     elsif ($type == 2)
7893     {
7894       $char = get_random_chr (0x41, 0x5A);
7895     }
7896     else
7897     {
7898       $char = get_random_chr (0x61, 0x7A);
7899     }
7900
7901     $domain .= $char;
7902   }
7903
7904   my $c_challenge = randbytes (8);
7905   my $s_challenge = randbytes (8);
7906
7907   my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $c_challenge) . unpack ("H*", $s_challenge);
7908
7909   return $salt_buf;
7910 }
7911
7912 sub get_random_netntlmv2_salt
7913 {
7914   my $len_user   = shift;
7915   my $len_domain = shift;
7916
7917   my $char;
7918   my $type;
7919   my $user = "";
7920
7921   if ($len_user + $len_domain > 27)
7922   {
7923     if ($len_user > $len_domain)
7924     {
7925       $len_user = 27 - $len_domain;
7926     }
7927     else
7928     {
7929       $len_domain = 27 - $len_user;
7930     }
7931   }
7932
7933   for (my $i = 0; $i < $len_user; $i++)
7934   {
7935     $type = get_random_num (1, 3);
7936
7937     if ($type == 1)
7938     {
7939       $char = get_random_chr (0x30, 0x39);
7940     }
7941     elsif ($type == 2)
7942     {
7943       $char = get_random_chr (0x41, 0x5A);
7944     }
7945     else
7946     {
7947       $char = get_random_chr (0x61, 0x7A);
7948     }
7949
7950     $user .= $char;
7951   }
7952
7953   my $domain = "";
7954
7955   for (my $i = 0; $i < $len_domain; $i++)
7956   {
7957     $type = get_random_num (1, 3);
7958
7959     if ($type == 1)
7960     {
7961       $char = get_random_chr (0x30, 0x39);
7962     }
7963     elsif ($type == 2)
7964     {
7965       $char = get_random_chr (0x41, 0x5A);
7966     }
7967     else
7968     {
7969       $char = get_random_chr (0x61, 0x7A);
7970     }
7971
7972     $domain .= $char;
7973   }
7974
7975   my $c_challenge = randbytes (8);
7976   my $s_challenge = randbytes (8);
7977
7978   my $temp = "\x01\x01" .
7979              "\x00" x 6 .
7980              randbytes (8) .
7981              $c_challenge .
7982              "\x00" x 4 .
7983              randbytes (20 * rand () + 1) .
7984              "\x00";
7985
7986   my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $s_challenge) . unpack ("H*", $temp);
7987
7988   return $salt_buf;
7989 }
7990
7991 sub get_random_ike_salt
7992 {
7993   my $nr_buf = "";
7994
7995   for (my $i = 0; $i < 40; $i++)
7996   {
7997     $nr_buf .= get_random_chr (0, 0xff);
7998   }
7999
8000   my $msg_buf = "";
8001
8002   for (my $i = 0; $i < 440; $i++)
8003   {
8004     $msg_buf .= get_random_chr (0, 0xff);
8005   }
8006
8007   my $nr_buf_hex  = unpack ("H*", $nr_buf);
8008   my $msg_buf_hex = unpack ("H*", $msg_buf);
8009
8010   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));
8011
8012   return $salt_buf;
8013 }
8014
8015 sub get_random_agilekeychain_salt
8016 {
8017   my $salt_buf = "";
8018
8019   for (my $i = 0; $i < 8; $i++)
8020   {
8021     $salt_buf .= get_random_chr (0x0, 0xff);
8022   }
8023
8024   my $iv = "";
8025
8026   for (my $i = 0; $i < 16; $i++)
8027   {
8028     $iv .= get_random_chr (0x0, 0xff);
8029   }
8030
8031   my $prefix = "\x00" x 1008;
8032
8033   my $ret = unpack ("H*", $salt_buf . $prefix . $iv);
8034
8035   return $ret;
8036 }
8037
8038 sub get_random_cloudkeychain_salt
8039 {
8040   my $salt_buf = "";
8041
8042   for (my $i = 0; $i < 16; $i++)
8043   {
8044     $salt_buf .= get_random_chr (0x0, 0xff);
8045   }
8046
8047   for (my $i = 0; $i < 304; $i++)
8048   {
8049     $salt_buf .= get_random_chr (0x0, 0xff);
8050   }
8051
8052   my $ret = unpack ("H*", $salt_buf);
8053
8054   return $ret;
8055 }
8056
8057 sub get_random_kerberos5_salt
8058 {
8059   my $custom_salt = shift;
8060
8061   my $clear_data = randbytes (14) .
8062                    strftime ("%Y%m%d%H%M%S", localtime) .
8063                    randbytes (8);
8064
8065   my $user  = "user";
8066   my $realm = "realm";
8067   my $salt  = "salt";
8068
8069   my $salt_buf = $user . "\$" . $realm . "\$" . $salt . "\$" . unpack ("H*", $custom_salt) . "\$" . unpack ("H*", $clear_data) . "\$";
8070
8071   return $salt_buf;
8072 }
8073
8074 sub get_random_kerberos5_tgs_salt
8075 {
8076   my $nonce = randbytes (8);
8077
8078   my $user  = "user";
8079   my $realm = "realm";
8080   my $spn   = "test/spn";
8081
8082   my $salt_buf = $user . "\$" . $realm . "\$" . $spn . "\$" . unpack ("H*",$nonce);
8083
8084   return $salt_buf;
8085 }
8086
8087 sub get_random_md5chap_salt
8088 {
8089   my $salt_buf = shift;
8090
8091   my $salt = unpack ("H*", $salt_buf);
8092
8093   $salt .= ":";
8094
8095   $salt .= unpack ("H*", randbytes (1));
8096
8097   return $salt;
8098 }
8099
8100 sub get_random_dnssec_salt
8101 {
8102   my $salt_buf = "";
8103
8104   $salt_buf .= ".";
8105
8106   for (my $i = 0; $i < 8; $i++)
8107   {
8108     $salt_buf .= get_random_chr (0x61, 0x7a);
8109   }
8110
8111   $salt_buf .= ".net";
8112
8113   $salt_buf .= ":";
8114
8115   for (my $i = 0; $i < 8; $i++)
8116   {
8117     $salt_buf .= get_random_chr (0x30, 0x39);
8118   }
8119
8120   return $salt_buf;
8121 }
8122
8123 sub md5bit
8124 {
8125   my $digest = shift;
8126   my $bit = shift;
8127
8128   $bit %= 128;
8129
8130   my $byte_off = int ($bit / 8);
8131   my $bit_off  = int ($bit % 8);
8132
8133   my $char = substr ($digest, $byte_off, 1);
8134   my $num  = ord ($char);
8135
8136   return (($num & (1 << $bit_off)) ? 1 : 0);
8137 }
8138
8139 sub sun_md5
8140 {
8141   my $pw   = shift;
8142   my $salt = shift;
8143   my $iter = shift;
8144
8145   my $constant_phrase =
8146   "To be, or not to be,--that is the question:--\n"        .
8147   "Whether 'tis nobler in the mind to suffer\n"            .
8148   "The slings and arrows of outrageous fortune\n"          .
8149   "Or to take arms against a sea of troubles,\n"           .
8150   "And by opposing end them?--To die,--to sleep,--\n"      .
8151   "No more; and by a sleep to say we end\n"                .
8152   "The heartache, and the thousand natural shocks\n"       .
8153   "That flesh is heir to,--'tis a consummation\n"          .
8154   "Devoutly to be wish'd. To die,--to sleep;--\n"          .
8155   "To sleep! perchance to dream:--ay, there's the rub;\n"  .
8156   "For in that sleep of death what dreams may come,\n"     .
8157   "When we have shuffled off this mortal coil,\n"          .
8158   "Must give us pause: there's the respect\n"              .
8159   "That makes calamity of so long life;\n"                 .
8160   "For who would bear the whips and scorns of time,\n"     .
8161   "The oppressor's wrong, the proud man's contumely,\n"    .
8162   "The pangs of despis'd love, the law's delay,\n"         .
8163   "The insolence of office, and the spurns\n"              .
8164   "That patient merit of the unworthy takes,\n"            .
8165   "When he himself might his quietus make\n"               .
8166   "With a bare bodkin? who would these fardels bear,\n"    .
8167   "To grunt and sweat under a weary life,\n"               .
8168   "But that the dread of something after death,--\n"       .
8169   "The undiscover'd country, from whose bourn\n"           .
8170   "No traveller returns,--puzzles the will,\n"             .
8171   "And makes us rather bear those ills we have\n"          .
8172   "Than fly to others that we know not of?\n"              .
8173   "Thus conscience does make cowards of us all;\n"         .
8174   "And thus the native hue of resolution\n"                .
8175   "Is sicklied o'er with the pale cast of thought;\n"      .
8176   "And enterprises of great pith and moment,\n"            .
8177   "With this regard, their currents turn awry,\n"          .
8178   "And lose the name of action.--Soft you now!\n"          .
8179   "The fair Ophelia!--Nymph, in thy orisons\n"             .
8180   "Be all my sins remember'd.\n\x00";
8181
8182   my $constant_len = length ($constant_phrase);
8183
8184   my $hash_buf = md5 ($pw . $salt);
8185
8186   my $W;
8187
8188   my $to_hash;
8189
8190   for (my $round = 0; $round < $iter; $round++)
8191   {
8192     my $shift_a = md5bit ($hash_buf, $round +  0);
8193     my $shift_b = md5bit ($hash_buf, $round + 64);
8194
8195     my @shift_4;
8196     my @shift_7;
8197
8198     for (my $k = 0; $k < 16; $k++)
8199     {
8200        my $s7shift = ord (substr ($hash_buf, $k, 1)) % 8;
8201
8202        my $l = ($k + 3) % 16;
8203
8204        my $num = ord (substr ($hash_buf, $l, 1));
8205
8206        $shift_4[$k] = $num % 5;
8207
8208        $shift_7[$k] = ($num >> $s7shift) & 1;
8209     }
8210
8211     my @indirect_4;
8212
8213     for (my $k = 0; $k < 16; $k++)
8214     {
8215       $indirect_4[$k] = (ord (substr ($hash_buf, $k, 1)) >> $shift_4[$k]) & 0xf;
8216     }
8217
8218     my @indirect_7;
8219
8220     for (my $k = 0; $k < 16; $k++)
8221     {
8222       $indirect_7[$k] = (ord (substr ($hash_buf, $indirect_4[$k], 1)) >> $shift_7[$k]) & 0x7f;
8223     }
8224
8225     my $indirect_a = 0;
8226     my $indirect_b = 0;
8227
8228     for (my $k = 0; $k < 8; $k++)
8229     {
8230       $indirect_a |= md5bit ($hash_buf, $indirect_7[$k + 0]) << $k;
8231
8232       $indirect_b |= md5bit ($hash_buf, $indirect_7[$k + 8]) << $k;
8233     }
8234
8235     $indirect_a = ($indirect_a >> $shift_a) & 0x7f;
8236     $indirect_b = ($indirect_b >> $shift_b) & 0x7f;
8237
8238     my $bit_a = md5bit ($hash_buf, $indirect_a);
8239     my $bit_b = md5bit ($hash_buf, $indirect_b);
8240
8241     $W = $hash_buf;
8242
8243     my $pos = 16;
8244
8245     my $total = $pos;
8246
8247     $to_hash = "";
8248
8249     if ($bit_a ^ $bit_b)
8250     {
8251       substr ($W, 16, 48) = substr ($constant_phrase, 0, 48);
8252
8253       $total += 48;
8254
8255       $to_hash .= substr ($W, 0, 64);
8256
8257       my $constant_off;
8258
8259       for ($constant_off = 48; $constant_off < $constant_len - 64; $constant_off += 64)
8260       {
8261         substr ($W, 0, 64) = substr ($constant_phrase, $constant_off, 64);
8262
8263         $total += 64;
8264
8265         $to_hash .= substr ($W, 0, 64);
8266       }
8267
8268       $pos = $constant_len - $constant_off;
8269
8270       $total += $pos;
8271
8272       substr ($W, 0, $pos) = substr ($constant_phrase, $constant_off, $pos);
8273     }
8274
8275     my $a_len = 0;
8276
8277     my @a_buf;
8278     $a_buf[0] = 0;
8279     $a_buf[1] = 0;
8280     $a_buf[2] = 0;
8281     $a_buf[3] = 0;
8282
8283     my $tmp = $round;
8284
8285     do
8286     {
8287       my $round_div = int ($tmp / 10);
8288       my $round_mod = int ($tmp % 10);
8289
8290       $tmp = $round_div;
8291
8292       $a_buf[int ($a_len / 4)] = (($round_mod + 0x30) | ($a_buf[int ($a_len / 4)] << 8));
8293
8294       $a_len++;
8295
8296     } while ($tmp);
8297
8298     my $tmp_str = "";
8299
8300     my $g;
8301
8302     for ($g = 0; $g < $a_len; $g++)
8303     {
8304       my $remainder = $a_buf[$g];
8305       my $factor = 7;
8306       my $started = 1;
8307
8308       my $sub;
8309
8310       while ($remainder > 0)
8311       {
8312         $sub = $remainder >> (8 * $factor);
8313
8314         if ($started != 1 || $sub > 0)
8315         {
8316           $started = 0;
8317
8318           $tmp_str = chr ($sub) . $tmp_str;
8319
8320           $remainder -= ($sub << (8 * $factor));
8321         }
8322
8323         $factor--;
8324       }
8325
8326     }
8327
8328     substr ($W, $pos, $a_len) = $tmp_str;
8329
8330     $pos += $a_len;
8331
8332     $total += $a_len;
8333
8334     $to_hash .= substr ($W, 0, $pos);
8335
8336     $to_hash = substr ($to_hash, 0, $total);
8337
8338     $hash_buf = md5 ($to_hash);
8339   }
8340
8341   my $passwd = "";
8342
8343   $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);
8344   $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);
8345   $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);
8346   $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);
8347   $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);
8348   $passwd .= to64 ((int (ord (substr ($hash_buf, 11, 1)))), 2);
8349
8350   return $passwd;
8351 }
8352
8353 sub usage_die
8354 {
8355   die ("usage: $0 single|passthrough| [mode] [len]\n" .
8356        "       or\n" .
8357        "       $0 verify              [mode] [hashfile] [cracks] [outfile]\n");
8358 }
8359
8360 sub pad16
8361 {
8362   my $block_ref = shift;
8363
8364   my $offset = shift;
8365
8366   my $value = 16 - $offset;
8367
8368   for (my $i = $offset; $i < 16; $i++)
8369   {
8370     push @{$block_ref}, $value;
8371   }
8372 }
8373
8374 sub lotus_mix
8375 {
8376   my $in_ref = shift;
8377
8378   my $p = 0;
8379
8380   for (my $i = 0; $i < 18; $i++)
8381   {
8382     for (my $j = 0; $j < 48; $j++)
8383     {
8384       $p = ($p + 48 - $j) & 0xff;
8385
8386       my $c = $lotus_magic_table[$p];
8387
8388       $p = $in_ref->[$j] ^ $c;
8389
8390       $in_ref->[$j] = $p;
8391     }
8392   }
8393 }
8394
8395 sub lotus_transform_password
8396 {
8397   my $in_ref  = shift;
8398   my $out_ref = shift;
8399
8400   my $t = $out_ref->[15];
8401
8402   for (my $i = 0; $i < 16; $i++)
8403   {
8404     $t ^= $in_ref->[$i];
8405
8406     my $c = $lotus_magic_table[$t];
8407
8408     $out_ref->[$i] ^= $c;
8409
8410     $t = $out_ref->[$i];
8411   }
8412 }
8413
8414 sub mdtransform_norecalc
8415 {
8416   my $state_ref = shift;
8417   my $block_ref = shift;
8418
8419   my @x;
8420
8421   push (@x, @{$state_ref});
8422   push (@x, @{$block_ref});
8423
8424   for (my $i = 0; $i < 16; $i++)
8425   {
8426     push (@x, $x[0 + $i] ^ $x[16 + $i]);
8427   }
8428
8429   lotus_mix (\@x);
8430
8431   for (my $i = 0; $i < 16; $i++)
8432   {
8433     $state_ref->[$i] = $x[$i];
8434   }
8435 }
8436
8437 sub mdtransform
8438 {
8439   my $state_ref    = shift;
8440   my $checksum_ref = shift;
8441   my $block_ref    = shift;
8442
8443   mdtransform_norecalc ($state_ref, $block_ref);
8444
8445   lotus_transform_password ($block_ref, $checksum_ref);
8446 }
8447
8448 sub domino_big_md
8449 {
8450   my $saved_key_ref = shift;
8451
8452   my $size = shift;
8453
8454   @{$saved_key_ref} = splice (@{$saved_key_ref}, 0, $size);
8455
8456   my @state = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
8457
8458   my @checksum;
8459
8460   my $curpos;
8461
8462   for ($curpos = 0; $curpos + 16 < $size; $curpos += 16)
8463   {
8464     my $curpos16 = $curpos + 16;
8465
8466     my @block = splice (@{$saved_key_ref}, 0, 16);
8467
8468     mdtransform (\@state, \@checksum, \@block);
8469   }
8470
8471   my $left = $size - $curpos;
8472
8473   my @block = splice (@{$saved_key_ref}, 0, 16);
8474
8475   pad16 (\@block, $left);
8476
8477   mdtransform (\@state, \@checksum, \@block);
8478
8479   mdtransform_norecalc (\@state, \@checksum);
8480
8481   return @state;
8482 }
8483
8484 sub pdf_compute_encryption_key
8485 {
8486   my $word_buf  = shift;
8487   my $padding   = shift;
8488   my $id        = shift;
8489   my $u         = shift;
8490   my $o         = shift;
8491   my $P         = shift;
8492   my $V         = shift;
8493   my $R         = shift;
8494   my $enc       = shift;
8495
8496   ## start
8497
8498   my $data;
8499
8500   $data .= $word_buf;
8501
8502   $data .= substr ($padding, 0, 32 - length $word_buf);
8503
8504   $data .= pack ("H*", $o);
8505
8506   $data .= pack ("I", $P);
8507
8508   $data .= pack ("H*", $id);
8509
8510   if ($R >= 4)
8511   {
8512     if (!$enc)
8513     {
8514       $data .= pack ("I", -1);
8515     }
8516   }
8517
8518   my $res = md5 ($data);
8519
8520   if ($R >= 3)
8521   {
8522     for (my $i = 0; $i < 50; $i++)
8523     {
8524       $res = md5 ($res);
8525     }
8526   }
8527
8528   return $res;
8529 }
8530
8531 sub gen_random_wpa_eapol
8532 {
8533   my $keyver = shift;
8534   my $snonce = shift;
8535
8536   my $ret = "";
8537
8538   # version
8539
8540   my $version = 1; # 802.1X-2001
8541
8542   $ret .= pack ("C*", $version);
8543
8544   my $type = 3;    # means that this EAPOL frame is used to transfer key information
8545
8546   $ret .= pack ("C*", $type);
8547
8548   my $length; # length of remaining data
8549
8550   if ($keyver == 1)
8551   {
8552     $length = 119;
8553   }
8554   else
8555   {
8556     $length = 117;
8557   }
8558
8559   $ret .= pack ("n*", $length);
8560
8561   my $descriptor_type;
8562
8563   if ($keyver == 1)
8564   {
8565     $descriptor_type = 254; # EAPOL WPA key
8566   }
8567   else
8568   {
8569     $descriptor_type = 1; # EAPOL RSN key
8570   }
8571
8572   $ret .= pack ("C*", $descriptor_type);
8573
8574   # key_info is a bit vector:
8575   # generated from these 13 bits: encrypted key data, request, error, secure, key mic, key ack, install, key index (2), key type, key descriptor (3)
8576
8577   my $key_info = 0;
8578
8579   $key_info |= 1 << 8; # set key MIC
8580   $key_info |= 1 << 3; # set if it is a pairwise key
8581
8582   if ($keyver == 1)
8583   {
8584     $key_info |= 1 << 0; # RC4 Cipher, HMAC-MD5 MIC
8585   }
8586   else
8587   {
8588     $key_info |= 1 << 1; # AES Cipher, HMAC-SHA1 MIC
8589   }
8590
8591   $ret .= pack ("n*", $key_info);
8592
8593   my $key_length;
8594
8595   if ($keyver == 1)
8596   {
8597     $key_length = 32;
8598   }
8599   else
8600   {
8601     $key_length = 0;
8602   }
8603
8604   $ret .= pack ("n*", $key_length);
8605
8606   my $replay_counter = 1;
8607
8608   $ret .= pack ("Q>*", $replay_counter);
8609
8610   $ret .= $snonce;
8611
8612   my $key_iv = "\x00" x 16;
8613
8614   $ret .= $key_iv;
8615
8616   my $key_rsc = "\x00" x 8;
8617
8618   $ret .= $key_rsc;
8619
8620   my $key_id = "\x00" x 8;
8621
8622   $ret .= $key_id;
8623
8624   my $key_mic = "\x00" x 16;
8625
8626   $ret .= $key_mic;
8627
8628   my $key_data_len;
8629
8630   if ($keyver == 1)
8631   {
8632     $key_data_len = 24; # length of the key_data (== WPA info)
8633   }
8634   else
8635   {
8636     $key_data_len = 22; # length of the key_data (== RSN info)
8637   }
8638
8639   $ret .= pack ("n*", $key_data_len);
8640
8641   my $key_data = "";
8642
8643   if ($keyver == 1)
8644   {
8645     # wpa info
8646
8647     my $wpa_info = "";
8648
8649     my $vendor_specific_data = "";
8650
8651     my $tag_number = 221; # means it is a vendor specific tag
8652
8653     $vendor_specific_data .= pack ("C*", $tag_number);
8654
8655     my $tag_len = 22;     # length of the remaining "tag data"
8656
8657     $vendor_specific_data .= pack ("C*", $tag_len);
8658
8659     my $vendor_specific_oui = pack ("H*", "0050f2"); # microsoft
8660
8661     $vendor_specific_data .= $vendor_specific_oui;
8662
8663     my $vendor_specific_oui_type = 1; # WPA Information Element
8664
8665     $vendor_specific_data .= pack ("C*", $vendor_specific_oui_type);
8666
8667     my $vendor_specific_wpa_version = 1;
8668
8669     $vendor_specific_data .= pack ("v*", $vendor_specific_wpa_version);
8670
8671     # multicast
8672
8673     my $vendor_specific_multicast_oui = pack ("H*", "0050f2");
8674
8675     $vendor_specific_data .= $vendor_specific_multicast_oui;
8676
8677     my $vendor_specific_multicast_type = 2; # TKIP
8678
8679     $vendor_specific_data .= pack ("C*", $vendor_specific_multicast_type);
8680
8681     # unicast
8682
8683     my $vendor_specific_unicast_count = 1;
8684
8685     $vendor_specific_data .= pack ("v*", $vendor_specific_unicast_count);
8686
8687     my $vendor_specific_unicast_oui = pack ("H*", "0050f2");
8688
8689     $vendor_specific_data .= $vendor_specific_multicast_oui;
8690
8691     my $vendor_specific_unicast_type = 2; # TKIP
8692
8693     $vendor_specific_data .= pack ("C*", $vendor_specific_unicast_type);
8694
8695     # Auth Key Management (AKM)
8696
8697     my $auth_key_management_count = 1;
8698
8699     $vendor_specific_data .= pack ("v*", $auth_key_management_count);
8700
8701     my $auth_key_management_oui = pack ("H*", "0050f2");
8702
8703     $vendor_specific_data .= $auth_key_management_oui;
8704
8705     my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
8706
8707     $vendor_specific_data .= pack ("C*", $auth_key_management_type);
8708
8709     $wpa_info = $vendor_specific_data;
8710
8711     $key_data = $wpa_info;
8712   }
8713   else
8714   {
8715     # rsn info
8716
8717     my $rsn_info = "";
8718
8719     my $tag_number = 48; # RSN info
8720
8721     $rsn_info .= pack ("C*", $tag_number);
8722
8723     my $tag_len = 20;    # length of the remaining "tag_data"
8724
8725     $rsn_info .= pack ("C*", $tag_len);
8726
8727     my $rsn_version = 1;
8728
8729     $rsn_info .= pack ("v*", $rsn_version);
8730
8731     # group cipher suite
8732
8733     my $group_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
8734
8735     $rsn_info .= $group_cipher_suite_oui;
8736
8737     my $group_cipher_suite_type = 4; # AES (CCM)
8738
8739     $rsn_info .= pack ("C*", $group_cipher_suite_type);
8740
8741     # pairwise cipher suite
8742
8743     my $pairwise_cipher_suite_count = 1;
8744
8745     $rsn_info .= pack ("v*", $pairwise_cipher_suite_count);
8746
8747     my $pairwise_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
8748
8749     $rsn_info .= $pairwise_cipher_suite_oui;
8750
8751     my $pairwise_cipher_suite_type = 4; # AES (CCM)
8752
8753     $rsn_info .= pack ("C*", $pairwise_cipher_suite_type);
8754
8755     # Auth Key Management (AKM)
8756
8757     my $auth_key_management_count = 1;
8758
8759     $rsn_info .= pack ("v*", $auth_key_management_count);
8760
8761     my $auth_key_management_oui = pack ("H*", "000fac"); # Ieee8021
8762
8763     $rsn_info .= $auth_key_management_oui;
8764
8765     my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
8766
8767     $rsn_info .= pack ("C*", $auth_key_management_type);
8768
8769     # RSN Capabilities
8770
8771     # bit vector of these 9 bits: peerkey enabled, management frame protection (MFP) capable, MFP required,
8772     # RSN GTKSA Capabilities (2), RSN PTKSA Capabilities (2), no pairwise Capabilities, Pre-Auth Capabilities
8773
8774     my $rsn_capabilities = pack ("H*", "0000");
8775
8776     $rsn_info .= $rsn_capabilities;
8777
8778     $key_data = $rsn_info;
8779   }
8780
8781   $ret .= $key_data;
8782
8783   return $ret;
8784 }
8785
8786 sub wpa_prf_512
8787 {
8788   my $pmk    = shift;
8789   my $stmac  = shift;
8790   my $bssid  = shift;
8791   my $snonce = shift;
8792   my $anonce = shift;
8793
8794   my $data = "Pairwise key expansion";
8795
8796   $data .= "\x00";
8797
8798   #
8799   # Min(AA, SPA) || Max(AA, SPA)
8800   #
8801
8802   # compare if greater: Min()/Max() on the MACs (6 bytes)
8803
8804   if (memcmp ($stmac, $bssid, 6) < 0)
8805   {
8806     $data .= $stmac;
8807     $data .= $bssid;
8808   }
8809   else
8810   {
8811     $data .= $bssid;
8812     $data .= $stmac;
8813   }
8814
8815   #
8816   # Min(ANonce,SNonce) || Max(ANonce,SNonce)
8817   #
8818
8819   # compare if greater: Min()/Max() on the nonces (32 bytes)
8820
8821   if (memcmp ($snonce, $anonce, 32) < 0)
8822   {
8823     $data .= $snonce;
8824     $data .= $anonce;
8825   }
8826   else
8827   {
8828     $data .= $anonce;
8829     $data .= $snonce;
8830   }
8831
8832   $data .= "\x00";
8833
8834   my $prf_buf = hmac ($data, $pmk, \&sha1);
8835
8836   $prf_buf = substr ($prf_buf, 0, 16);
8837
8838   return $prf_buf;
8839 }
8840
8841 sub memcmp
8842 {
8843   my $str1 = shift;
8844   my $str2 = shift;
8845   my $len  = shift;
8846
8847   my $len_str1 = length ($str1);
8848   my $len_str2 = length ($str2);
8849
8850   if (($len > $len_str1) || ($len > $len_str2))
8851   {
8852     print "ERROR: memcmp () lengths wrong";
8853
8854     exit (1);
8855   }
8856
8857   for (my $i = 0; $i < $len; $i++)
8858   {
8859     my $c_1 = ord (substr ($str1, $i, 1));
8860     my $c_2 = ord (substr ($str2, $i, 1));
8861
8862     return -1 if ($c_1 < $c_2);
8863     return  1 if ($c_1 > $c_2);
8864   }
8865
8866   return 0;
8867 }