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, 13200, 13300);
  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     elsif ($mode == 13200)
2244     {
2245       ($hash_in, $word) = split ":", $line;
2246
2247       next unless defined $hash_in;
2248       next unless defined $word;
2249
2250       my @data = split ('\*', $hash_in);
2251
2252       next unless scalar @data == 5;
2253
2254       shift @data;
2255
2256       my $signature = shift @data;
2257       my $version   = shift @data;
2258       my $iteration = shift @data;
2259       my $mysalt    = shift @data;
2260       my $digest    = shift @data;
2261
2262       next unless ($signature eq '$axcrypt$');
2263       next unless (length ($mysalt) == 32);
2264       next unless (length ($digest) == 48);
2265
2266       $salt = $iteration . '*' . $mysalt;
2267
2268       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2269     }
2270     elsif ($mode == 13300)
2271     {
2272       ($hash_in, $word) = split ":", $line;
2273
2274       next unless defined $hash_in;
2275       next unless defined $word;
2276
2277       my @data = split ('\$', $hash_in);
2278
2279       next unless scalar @data == 2;
2280
2281       shift @data;
2282
2283       my $signature = shift @data;
2284       my $digest    = shift @data;
2285
2286       next unless ($signature eq '$axcrypt_sha1');
2287       next unless (length ($digest) == 32 || length ($digest) == 40);
2288
2289       next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in})));
2290     }
2291     else
2292     {
2293       print "ERROR: hash mode is not supported\n";
2294
2295       exit (1);
2296     }
2297
2298     if ($word =~ m/^\$HEX\[[0-9a-fA-F]*\]$/)
2299     {
2300       $word = pack ("H*", substr ($word, 5, -1));
2301     }
2302
2303     # finally generate the hash
2304
2305     # special case:
2306     if ($mode == 6800)
2307     {
2308       # check both variations
2309       $hash_out = gen_hash ($mode, $word, $salt, $iter, 1);
2310
2311       $len = length $hash_out; # == length $alternative
2312
2313       if (substr ($line, 0, $len) ne $hash_out)
2314       {
2315         my $alternative = gen_hash ($mode, $word, $salt, $iter, 2);
2316
2317         return unless (substr ($line, 0, $len) eq $alternative);
2318       }
2319     }
2320     elsif ($mode == 8700)
2321     {
2322       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2323
2324       $len = length $hash_out;
2325
2326       return unless (substr ($line, 0, $len) eq $hash_out);
2327     }
2328     elsif ($mode == 8900)
2329     {
2330       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3);
2331
2332       $len = length $hash_out;
2333
2334       return unless (substr ($line, 0, $len) eq $hash_out);
2335     }
2336     elsif ($mode == 9100)
2337     {
2338       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2339
2340       $len = length $hash_out;
2341
2342       return unless (substr ($line, 0, $len) eq $hash_out);
2343     }
2344     elsif ($mode == 190)
2345     {
2346       $hash_out = gen_hash ($mode, $word, $salt, $iter, 0);
2347
2348       $len = length $hash_out; # == length $alternative
2349
2350       if (substr ($line, 0, $len) ne $hash_out)
2351       {
2352         my $alternative = gen_hash ($mode, $word, $salt, $iter, 1);
2353
2354         return unless (substr ($line, 0, $len) eq $alternative);
2355       }
2356     }
2357     elsif ($mode == 3300)
2358     {
2359       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2360
2361       $len = length $hash_out;
2362
2363       return unless (substr ($line, 0, $len) eq $hash_out);
2364     }
2365     elsif ($mode == 5100)
2366     {
2367       # check 3 variants (start, middle, end)
2368
2369       my $idx = 0;
2370
2371       $hash_out = gen_hash ($mode, $word, $salt, $iter, $idx++);
2372
2373       $len = length $hash_out; # == length $alternative
2374
2375       if (substr ($line, 0, $len) ne $hash_out)
2376       {
2377         my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++);
2378
2379         if (substr ($line, 0, $len) ne $alternative)
2380         {
2381           my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++);
2382
2383           return unless (substr ($line, 0, $len) eq $alternative);
2384         }
2385       }
2386     }
2387     elsif ($mode == 9400)
2388     {
2389       $hash_out = gen_hash ($mode, $word, $salt, 50000, $param, $param2);
2390
2391       $len = length $hash_out;
2392
2393       return unless (substr ($line, 0, $len) eq $hash_out);
2394     }
2395     elsif ($mode == 9500)
2396     {
2397       $hash_out = gen_hash ($mode, $word, $salt, 100000, $param);
2398
2399       $len = length $hash_out;
2400
2401       return unless (substr ($line, 0, $len) eq $hash_out);
2402     }
2403     elsif ($mode == 9600)
2404     {
2405       $hash_out = gen_hash ($mode, $word, $salt, 100000, $param);
2406
2407       $len = length $hash_out;
2408
2409       return unless (substr ($line, 0, $len) eq $hash_out);
2410     }
2411     elsif ($mode == 9700)
2412     {
2413       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2);
2414
2415       $len = length $hash_out;
2416
2417       return unless (substr ($line, 0, $len) eq $hash_out);
2418     }
2419     elsif ($mode == 9800)
2420     {
2421       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2);
2422
2423       $len = length $hash_out;
2424
2425       return unless (substr ($line, 0, $len) eq $hash_out);
2426     }
2427     elsif ($mode == 10400)
2428     {
2429       $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3);
2430
2431       $len = length $hash_out;
2432
2433       return unless (substr ($line, 0, $len) eq $hash_out);
2434     }
2435     elsif ($mode == 10500)
2436     {
2437       $hash_out = gen_hash ($mode, $word, $salt, 0, $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 == 10600)
2444     {
2445       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2446
2447       $len = length $hash_out;
2448
2449       return unless (substr ($line, 0, $len) eq $hash_out);
2450     }
2451     elsif ($mode == 10700)
2452     {
2453       $hash_out = gen_hash ($mode, $word, $salt, 0, $param);
2454
2455       $len = length $hash_out;
2456
2457       return unless (substr ($line, 0, $len) eq $hash_out);
2458     }
2459     elsif ($mode == 10900)
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 == 11100)
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 == 11400)
2476     {
2477       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6, $param7, $param8, $param9, $param10, $param11);
2478
2479       $len = length $hash_out;
2480
2481       return unless (substr ($line, 0, $len) eq $hash_out);
2482     }
2483     elsif ($mode == 11600)
2484     {
2485       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6);
2486
2487       $len = length $hash_out;
2488
2489       return unless (substr ($line, 0, $len) eq $hash_out);
2490     }
2491     elsif ($mode == 11900)
2492     {
2493       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2494
2495       $len = length $hash_out;
2496
2497       return unless (substr ($line, 0, $len) eq $hash_out);
2498     }
2499     elsif ($mode == 12000)
2500     {
2501       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2502
2503       $len = length $hash_out;
2504
2505       return unless (substr ($line, 0, $len) eq $hash_out);
2506     }
2507     elsif ($mode == 12100)
2508     {
2509       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2510
2511       $len = length $hash_out;
2512
2513       return unless (substr ($line, 0, $len) eq $hash_out);
2514     }
2515     elsif ($mode == 12200)
2516     {
2517       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2518
2519       $len = length $hash_out;
2520
2521       return unless (substr ($line, 0, $len) eq $hash_out);
2522     }
2523     elsif ($mode == 12700)
2524     {
2525       # this is very special, we can't call gen_hash () because the param part is not always the same
2526       # we only know that it should contain the letters "guid" at the beginning of the decryted string
2527
2528       my $pbkdf2 = Crypt::PBKDF2->new (
2529         hash_class => 'HMACSHA1',
2530         iterations   => 10,
2531         output_len   => 32
2532       );
2533
2534       my $salt_bin = pack ("H*", $salt);
2535
2536       my $key = $pbkdf2->PBKDF2 ($salt_bin, $word);
2537
2538       my $cipher = Crypt::CBC->new ({
2539         key         => $key,
2540         cipher      => "Crypt::Rijndael",
2541         iv          => $salt_bin,
2542         literal_key => 1,
2543         header      => "none",
2544         keysize     => 32
2545       });
2546
2547       my $param_bin = pack ("H*", $param);
2548
2549       my $decrypted = $cipher->decrypt ($param_bin);
2550
2551       my $decrypted_part = substr ($decrypted, 1, 16);
2552
2553       return unless ($decrypted_part =~ /"guid"/);
2554
2555       $hash_out = $hash_in;
2556     }
2557     elsif ($mode == 12900)
2558     {
2559       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2560
2561       $len = length $hash_out;
2562
2563       return unless (substr ($line, 0, $len) eq $hash_out);
2564     }
2565     elsif ($mode == 13000)
2566     {
2567       $hash_out = gen_hash ($mode, $word, $salt, $iter, $param);
2568
2569       $len = length $hash_out;
2570
2571       return unless (substr ($line, 0, $len) eq $hash_out);
2572     }
2573     elsif ($mode == 13100)
2574     {
2575       $hash_out = gen_hash ($mode, $word, $salt);
2576
2577       $len = length $hash_out;
2578
2579       return unless (substr ($line, 0, $len) eq $hash_out);
2580     }
2581     elsif ($mode == 13200)
2582     {
2583       $hash_out = gen_hash ($mode, $word, $salt);
2584
2585       $len = length $hash_out;
2586
2587       return unless (substr ($line, 0, $len) eq $hash_out);
2588     }
2589     else
2590     {
2591       $hash_out = gen_hash ($mode, $word, $salt, $iter);
2592
2593       $len = length $hash_out;
2594
2595       # special cases:
2596       if ($mode == 400)
2597       {
2598         # allow $P$ and $H$ for -m 400
2599         next unless (substr ($line, 3, $len - 3) eq substr ($hash_out, 3));
2600       }
2601       elsif ($mode == 5600)
2602       {
2603         # oclHashcat outputs the user name always upper-case, we need
2604         next unless (substr ($line, 0, $len) eq $hash_out);
2605
2606         my $found = 0;
2607
2608         my $hash_out_lower = lc ($hash_out);
2609
2610         for my $key (keys %{$db})
2611         {
2612           if (lc ($key) eq $hash_out_lower)
2613           {
2614             $found = 1;
2615
2616             last;
2617           }
2618         }
2619
2620         next unless $found;
2621       }
2622       else
2623       {
2624         next unless (substr ($line, 0, $len) eq $hash_out);
2625       }
2626     }
2627
2628     # do not forget "exists ($db->$hash_out)" should be done above!
2629     $db->{$hash_out} = $word;
2630     print OUT $line . "\n";
2631   }
2632
2633   close (IN);
2634   close (OUT);
2635 }
2636
2637 sub passthrough
2638 {
2639   my $mode = shift || 0;
2640
2641   while (my $word_buf = <>)
2642   {
2643     chomp ($word_buf);
2644
2645     next if length ($word_buf) > 31;
2646
2647     ##
2648     ## gen salt
2649     ##
2650
2651     my @salt_arr;
2652
2653     for (my $i = 0; $i < 256; $i++)
2654     {
2655       my $c = get_random_chr (0x30, 0x39);
2656
2657       push (@salt_arr, $c);
2658     }
2659
2660     my $salt_buf = join ("", @salt_arr);
2661
2662     ##
2663     ## gen hash
2664     ##
2665
2666     my $tmp_hash;
2667
2668     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 || $mode == 13300)
2669     {
2670       $tmp_hash = gen_hash ($mode, $word_buf, "");
2671     }
2672     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)
2673     {
2674       my $salt_len = get_random_num (1, 15);
2675
2676       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2677     }
2678     elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
2679     {
2680       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2681     }
2682     elsif ($mode == 21)
2683     {
2684       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2));
2685     }
2686     elsif ($mode == 22)
2687     {
2688       my $salt_len = get_random_num (1, 11);
2689
2690       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2691     }
2692     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)
2693     {
2694       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 8));
2695     }
2696     elsif ($mode == 112)
2697     {
2698       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20));
2699     }
2700     elsif ($mode == 121)
2701     {
2702       my $salt_len = get_random_num (1, 9);
2703
2704       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2705     }
2706     elsif ($mode == 141 || $mode == 1441)
2707     {
2708       my $salt_len = get_random_num (1, 15);
2709
2710       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2711     }
2712     elsif ($mode == 1100)
2713     {
2714       my $salt_len = get_random_num (1, 19);
2715
2716       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2717     }
2718     elsif ($mode == 1500)
2719     {
2720       next if length ($word_buf) > 8;
2721
2722       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2));
2723     }
2724     elsif ($mode == 2100)
2725     {
2726       next if length ($word_buf) > 13;
2727
2728       my $salt_len = get_random_num (1, 19);
2729
2730       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2731     }
2732     elsif ($mode == 2410)
2733     {
2734       next if length ($word_buf) > 15;
2735
2736       my $salt_len = get_random_num (1, 15);
2737
2738       my $word_len = length ($word_buf);
2739
2740       $salt_len = min ($salt_len, 15 - $word_len);
2741
2742       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2743     }
2744     elsif ($mode == 2500)
2745     {
2746       next if length ($word_buf) < 8;
2747
2748       my $salt_len = get_random_num (0, 32);
2749
2750       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2751     }
2752     elsif ($mode == 2611)
2753     {
2754       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 3));
2755     }
2756     elsif ($mode == 2612)
2757     {
2758       my $salt_len = get_random_num (1, 22);
2759
2760       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2761     }
2762     elsif ($mode == 2711)
2763     {
2764       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 30));
2765     }
2766     elsif ($mode == 2811)
2767     {
2768       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5));
2769     }
2770     elsif ($mode == 3000)
2771     {
2772       next if length ($word_buf) > 7;
2773
2774       $tmp_hash = gen_hash ($mode, $word_buf, "");
2775     }
2776     elsif ($mode == 3100)
2777     {
2778       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 10));
2779     }
2780     elsif ($mode == 3200 || $mode == 5800 || $mode == 6400 || $mode == 6500 || $mode == 6700 || $mode == 7400 || $mode == 3300 || $mode == 8000 || $mode == 9100 || $mode == 12200)
2781     {
2782       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16));
2783     }
2784     elsif ($mode == 3800 || $mode == 4900)
2785     {
2786       my $salt_len = get_random_num (1, 11);
2787
2788       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2789     }
2790     elsif ($mode == 4800)
2791     {
2792       $salt_buf = get_random_md5chap_salt (substr ($salt_buf, 0, 16));
2793
2794       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2795     }
2796     elsif ($mode == 5300 || $mode == 5400)
2797     {
2798       $salt_buf = get_random_ike_salt ();
2799
2800       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2801     }
2802     elsif ($mode == 5500)
2803     {
2804       my $user_len   = get_random_num (0, 15);
2805       my $domain_len = get_random_num (0, 15);
2806
2807       $salt_buf = get_random_netntlmv1_salt ($user_len, $domain_len);
2808
2809       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2810     }
2811     elsif ($mode == 5600)
2812     {
2813       my $user_len   = get_random_num (0, 15);
2814       my $domain_len = get_random_num (0, 15);
2815
2816       $salt_buf = get_random_netntlmv2_salt ($user_len, $domain_len);
2817
2818       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2819     }
2820     elsif ($mode == 6600)
2821     {
2822       $salt_buf = get_random_agilekeychain_salt ();
2823
2824       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2825     }
2826     elsif ($mode == 6800)
2827     {
2828       my $email_len = get_random_num (1, 15);
2829
2830       my $email = "";
2831
2832       for (my $i = 0; $i < $email_len; $i++)
2833       {
2834         $email .= get_random_chr (0x61, 0x7a);
2835       }
2836
2837       $email .= '@trash-mail.com';
2838
2839       $tmp_hash = gen_hash ($mode, $word_buf, $email);
2840     }
2841     elsif ($mode == 7100)
2842     {
2843       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64));
2844     }
2845     elsif ($mode == 7200)
2846     {
2847       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 128));
2848     }
2849     elsif ($mode == 7300)
2850     {
2851       my $salt_len = get_random_num (32, 256);
2852
2853       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2854     }
2855     elsif ($mode == 7500)
2856     {
2857       $salt_buf = get_random_kerberos5_salt (substr ($salt_buf, 0, 16));
2858
2859       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2860     }
2861     elsif ($mode == 7700)
2862     {
2863       next if length ($word_buf) > 8;
2864
2865       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12));
2866     }
2867     elsif ($mode == 7800)
2868     {
2869       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12));
2870     }
2871     elsif ($mode == 8200)
2872     {
2873       $salt_buf = get_random_cloudkeychain_salt ();
2874
2875       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2876     }
2877     elsif ($mode == 8300)
2878     {
2879       $salt_buf = get_random_dnssec_salt ();
2880
2881       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
2882     }
2883     elsif ($mode == 8400 || $mode == 11200)
2884     {
2885       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 40));
2886     }
2887     elsif ($mode == 8500)
2888     {
2889       next if length ($word_buf) > 8;
2890
2891       my $salt_len = get_random_num (1, 9);
2892
2893       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2894     }
2895     elsif ($mode == 8600)
2896     {
2897       next if length ($word_buf) > 16;
2898
2899       $tmp_hash = gen_hash ($mode, $word_buf, "");
2900     }
2901     elsif ($mode == 8700)
2902     {
2903       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5));
2904     }
2905     elsif ($mode == 9200 || $mode == 9300)
2906     {
2907       my $salt_len = 14;
2908
2909       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2910     }
2911     elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
2912     {
2913       next if length ($word_buf) > 19;
2914
2915       my $salt_len = 32;
2916
2917       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2918     }
2919     elsif ($mode == 10100)
2920     {
2921       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2922     }
2923     elsif ($mode == 10300)
2924     {
2925       my $salt_len = get_random_num (4, 15);
2926
2927       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2928     }
2929     elsif ($mode == 10400)
2930     {
2931       next if length ($word_buf) > 31;
2932
2933       my $salt_len = 32;
2934
2935       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2936     }
2937     elsif ($mode == 10500)
2938     {
2939       next if length ($word_buf) > 15;
2940
2941       my $salt_len = 32;
2942
2943       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2944     }
2945     elsif ($mode == 10600)
2946     {
2947       next if length ($word_buf) > 31;
2948
2949       my $salt_len = 32;
2950
2951       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2952     }
2953     elsif ($mode == 10700)
2954     {
2955       next if length ($word_buf) > 15;
2956
2957       my $salt_len = 32;
2958
2959       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2960     }
2961     elsif ($mode == 11000)
2962     {
2963       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 56));
2964     }
2965     elsif ($mode == 11300)
2966     {
2967       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16));
2968     }
2969     elsif ($mode == 11400)
2970     {
2971       next if length ($word_buf) > 24;
2972
2973       my $salt_len = get_random_num (1, 15);
2974
2975       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2976     }
2977     elsif ($mode == 11600)
2978     {
2979       my $salt_len = get_random_num (0, 16);
2980
2981       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len));
2982     }
2983     elsif ($mode == 12400)
2984     {
2985       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 4));
2986     }
2987     elsif ($mode == 12600)
2988     {
2989       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64));
2990     }
2991     elsif ($mode == 12700)
2992     {
2993       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
2994     }
2995     elsif ($mode == 12800)
2996     {
2997       next if length ($word_buf) > 24;
2998
2999       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20));
3000     }
3001     elsif ($mode == 12900)
3002     {
3003       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
3004     }
3005     elsif ($mode == 13000)
3006     {
3007       $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32));
3008     }
3009     elsif ($mode == 13100)
3010     {
3011       $salt_buf = get_random_kerberos5_tgs_salt ();
3012
3013       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
3014     }
3015     elsif ($mode == 13200)
3016     {
3017       $salt_buf = get_random_axcrypt_salt ();
3018
3019       $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
3020     }
3021     else
3022     {
3023       print "ERROR: Unsupported hash type\n";
3024
3025       exit (1);
3026     }
3027
3028     print $tmp_hash, "\n";
3029   }
3030 }
3031
3032 sub single
3033 {
3034   my $mode = shift;
3035
3036   if (defined $mode)
3037   {
3038     @modes = ($mode);
3039   }
3040
3041   for (my $j = 0; $j < scalar @modes; $j++)
3042   {
3043     my $mode = $modes[$j];
3044
3045     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 || $mode == 13300)
3046     {
3047       for (my $i = 1; $i < 32; $i++)
3048       {
3049         if ($len != 0)
3050         {
3051           rnd ($mode, $len, 0);
3052         }
3053         else
3054         {
3055           rnd ($mode, $i, 0);
3056         }
3057       }
3058     }
3059     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)
3060     {
3061       my $salt_len = get_random_num (1, 15);
3062
3063       for (my $i = 1; $i < 32; $i++)
3064       {
3065         if ($len != 0)
3066         {
3067           rnd ($mode, $len, $salt_len);
3068         }
3069         else
3070         {
3071           rnd ($mode, $i, $salt_len);
3072         }
3073       }
3074     }
3075     elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300)
3076     {
3077       for (my $i = 1; $i < 32; $i++)
3078       {
3079         if ($len != 0)
3080         {
3081           rnd ($mode, $len, 32);
3082         }
3083         else
3084         {
3085           rnd ($mode, $i, 32);
3086         }
3087       }
3088     }
3089     elsif ($mode == 21 || $mode == 22)
3090     {
3091       for (my $i = 1; $i < 32; $i++)
3092       {
3093         if ($len != 0)
3094         {
3095           rnd ($mode, $len, 2);
3096         }
3097         else
3098         {
3099           rnd ($mode, $i, 2);
3100         }
3101       }
3102     }
3103     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)
3104     {
3105       for (my $i = 1; $i < 32; $i++)
3106       {
3107         if ($len != 0)
3108         {
3109           rnd ($mode, $len, 8);
3110         }
3111         else
3112         {
3113           rnd ($mode, $i, 8);
3114         }
3115       }
3116     }
3117     elsif ($mode == 112)
3118     {
3119       for (my $i = 1; $i < 32; $i++)
3120       {
3121         if ($len != 0)
3122         {
3123           rnd ($mode, $len, 20);
3124         }
3125         else
3126         {
3127           rnd ($mode, $i, 20);
3128         }
3129       }
3130     }
3131     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)
3132     {
3133       for (my $i = 1; $i < 32; $i++)
3134       {
3135         if ($len != 0)
3136         {
3137           rnd ($mode, $len, 16);
3138         }
3139         else
3140         {
3141           rnd ($mode, $i, 16);
3142         }
3143       }
3144     }
3145     if ($mode == 1100)
3146     {
3147       my $salt_len = get_random_num (1, 19);
3148
3149       for (my $i = 1; $i < 32; $i++)
3150       {
3151         if ($len != 0)
3152         {
3153           rnd ($mode, $len, $salt_len);
3154         }
3155         else
3156         {
3157           rnd ($mode, $i, $salt_len);
3158         }
3159       }
3160     }
3161     elsif ($mode == 1500)
3162     {
3163       for (my $i = 1; $i < 9; $i++)
3164       {
3165         if ($len != 0)
3166         {
3167           rnd ($mode, $len, 2);
3168         }
3169         else
3170         {
3171           rnd ($mode, $i, 2);
3172         }
3173       }
3174     }
3175     elsif ($mode == 2100)
3176     {
3177       my $salt_len = get_random_num (1, 19);
3178
3179       for (my $i = 1; $i < 13; $i++)
3180       {
3181         if ($len != 0)
3182         {
3183           rnd ($mode, $len, $salt_len);
3184         }
3185         else
3186         {
3187           rnd ($mode, $i, $salt_len);
3188         }
3189       }
3190     }
3191     elsif ($mode == 2500)
3192     {
3193       my $salt_len = get_random_num (0, 32);
3194
3195       for (my $i = 8; $i < 16; $i++)
3196       {
3197         my $generate_from_len = 0;
3198
3199         if ($len != 0)
3200         {
3201           if ($len < 8)
3202           {
3203             $len += 7;
3204           }
3205
3206           rnd ($mode, $len, $salt_len);
3207         }
3208         else
3209         {
3210           rnd ($mode, $i, $salt_len);
3211         }
3212       }
3213     }
3214     elsif ($mode == 2611)
3215     {
3216       for (my $i = 1; $i < 32; $i++)
3217       {
3218         if ($len != 0)
3219         {
3220           rnd ($mode, $len, 3);
3221         }
3222         else
3223         {
3224           rnd ($mode, $i, 3);
3225         }
3226       }
3227     }
3228     elsif ($mode == 2612)
3229     {
3230       my $salt_len = get_random_num (1, 22);
3231
3232       for (my $i = 1; $i < 32; $i++)
3233       {
3234         if ($len != 0)
3235         {
3236           rnd ($mode, $len, $salt_len);
3237         }
3238         else
3239         {
3240           rnd ($mode, $i, $salt_len);
3241         }
3242       }
3243     }
3244     elsif ($mode == 2711)
3245     {
3246       for (my $i = 1; $i < 32; $i++)
3247       {
3248         if ($len != 0)
3249         {
3250           rnd ($mode, $len, 30);
3251         }
3252         else
3253         {
3254           rnd ($mode, $i, 30);
3255         }
3256       }
3257     }
3258     elsif ($mode == 2811)
3259     {
3260       for (my $i = 1; $i < 32; $i++)
3261       {
3262         if ($len != 0)
3263         {
3264           rnd ($mode, $len, 5);
3265         }
3266         else
3267         {
3268           rnd ($mode, $i, 5);
3269         }
3270       }
3271     }
3272     elsif ($mode == 3000)
3273     {
3274       for (my $i = 1; $i < 8; $i++)
3275       {
3276         if ($len != 0)
3277         {
3278           rnd ($mode, $len, 0);
3279         }
3280         else
3281         {
3282           rnd ($mode, $i, 0);
3283         }
3284       }
3285     }
3286     elsif ($mode == 3100)
3287     {
3288       for (my $i = 1; $i < 32; $i++)
3289       {
3290         if ($len != 0)
3291         {
3292           rnd ($mode, $len, 10);
3293         }
3294         else
3295         {
3296           rnd ($mode, $i, 10);
3297         }
3298       }
3299     }
3300     elsif ($mode == 3800 || $mode == 4900)
3301     {
3302       my $salt_len = get_random_num (1, 11);
3303
3304       for (my $i = 1; $i < 32; $i++)
3305       {
3306         if ($len != 0)
3307         {
3308           rnd ($mode, $len, $salt_len);
3309         }
3310         else
3311         {
3312           rnd ($mode, $i, $salt_len);
3313         }
3314       }
3315     }
3316     elsif ($mode == 5500 || $mode == 5600)
3317     {
3318       my $salt_len;
3319
3320       for (my $i = 1; $i < 27; $i++)
3321       {
3322         $salt_len = get_random_num (1, 15);
3323
3324         if ($len != 0)
3325         {
3326           rnd ($mode, $len, $salt_len);
3327         }
3328         else
3329         {
3330           rnd ($mode, $i, $salt_len);
3331         }
3332       }
3333     }
3334     elsif ($mode == 5800)
3335     {
3336       for (my $i = 1; $i < 14; $i++)
3337       {
3338         if ($len != 0)
3339         {
3340           rnd ($mode, $len, 16);
3341         }
3342         else
3343         {
3344           rnd ($mode, $i, 16);
3345         }
3346       }
3347     }
3348     elsif ($mode == 6800)
3349     {
3350       my $salt_len = get_random_num (8, 25);
3351
3352       for (my $i = 1; $i < 32; $i++)
3353       {
3354         if ($len != 0)
3355         {
3356           rnd ($mode, $len, $salt_len);
3357         }
3358         else
3359         {
3360           rnd ($mode, $i, $salt_len);
3361         }
3362       }
3363     }
3364     elsif ($mode == 7100)
3365     {
3366       for (my $i = 1; $i < 32; $i++)
3367       {
3368         if ($len != 0)
3369         {
3370           rnd ($mode, $len, 64);
3371         }
3372         else
3373         {
3374           rnd ($mode, $i, 64);
3375         }
3376       }
3377     }
3378     elsif ($mode == 7200)
3379     {
3380       for (my $i = 1; $i < 32; $i++)
3381       {
3382         if ($len != 0)
3383         {
3384           rnd ($mode, $len, 128);
3385         }
3386         else
3387         {
3388           rnd ($mode, $i, 128);
3389         }
3390       }
3391     }
3392     elsif ($mode == 7300)
3393     {
3394       my $salt_len = get_random_num (32, 255);
3395
3396       for (my $i = 1; $i < 32; $i++)
3397       {
3398         if ($len != 0)
3399         {
3400           rnd ($mode, $len, $salt_len);
3401         }
3402         else
3403         {
3404           rnd ($mode, $i, $salt_len);
3405         }
3406       }
3407     }
3408     elsif ($mode == 7500)
3409     {
3410       for (my $i = 1; $i < 27; $i++)
3411       {
3412         if ($len != 0)
3413         {
3414           rnd ($mode, $len, 16);
3415         }
3416         else
3417         {
3418           rnd ($mode, $i, 16);
3419         }
3420       }
3421     }
3422     elsif ($mode == 7700)
3423     {
3424       my $salt_len = get_random_num (1, 12);
3425
3426       for (my $i = 1; $i < 9; $i++)
3427       {
3428         if ($len != 0)
3429         {
3430           rnd ($mode, $len, $salt_len);
3431         }
3432         else
3433         {
3434           rnd ($mode, $i, $salt_len);
3435         }
3436       }
3437     }
3438     elsif ($mode == 7800)
3439     {
3440       my $salt_len = get_random_num (1, 12);
3441
3442       for (my $i = 1; $i < 32; $i++)
3443       {
3444         if ($len != 0)
3445         {
3446           rnd ($mode, $len, $salt_len);
3447         }
3448         else
3449         {
3450           rnd ($mode, $i, $salt_len);
3451         }
3452       }
3453     }
3454     elsif ($mode == 8400 || $mode == 11200)
3455     {
3456       for (my $i = 1; $i < 32; $i++)
3457       {
3458         if ($len != 0)
3459         {
3460           rnd ($mode, $len, 40);
3461         }
3462         else
3463         {
3464           rnd ($mode, $i, 40);
3465         }
3466       }
3467     }
3468     elsif ($mode == 8500)
3469     {
3470       my $salt_len = get_random_num (1, 8);
3471
3472       for (my $i = 1; $i < 9; $i++)
3473       {
3474         if ($len != 0)
3475         {
3476           rnd ($mode, $len, $salt_len);
3477         }
3478         else
3479         {
3480           rnd ($mode, $i, $salt_len);
3481         }
3482       }
3483     }
3484     elsif ($mode == 8600)
3485     {
3486       for (my $i = 1; $i < 17; $i++)
3487       {
3488         if ($len != 0)
3489         {
3490           rnd ($mode, $len, 0);
3491         }
3492         else
3493         {
3494           rnd ($mode, $i, 0);
3495         }
3496       }
3497     }
3498     elsif ($mode == 8700)
3499     {
3500       for (my $i = 1; $i < 32; $i++)
3501       {
3502         if ($len != 0)
3503         {
3504           rnd ($mode, $len, 5);
3505         }
3506         else
3507         {
3508           rnd ($mode, $i, 5);
3509         }
3510       }
3511     }
3512     elsif ($mode == 9200 || $mode == 9300)
3513     {
3514       my $salt_len = 14;
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 == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800)
3529     {
3530       my $salt_len = 32;
3531
3532       for (my $i = 1; $i < 20; $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 == 10100)
3545     {
3546       for (my $i = 1; $i < 32; $i++)
3547       {
3548         if ($len != 0)
3549         {
3550           rnd ($mode, $len, 32);
3551         }
3552         else
3553         {
3554           rnd ($mode, $i, 32);
3555         }
3556       }
3557     }
3558     elsif ($mode == 10300)
3559     {
3560       my $salt_len = get_random_num (4, 15);
3561
3562       for (my $i = 1; $i < 32; $i++)
3563       {
3564         if ($len != 0)
3565         {
3566           rnd ($mode, $len, $salt_len);
3567         }
3568         else
3569         {
3570           rnd ($mode, $i, $salt_len);
3571         }
3572       }
3573     }
3574     elsif ($mode == 10400 || $mode == 10600)
3575     {
3576       my $salt_len = 32;
3577
3578       for (my $i = 1; $i < 32; $i++)
3579       {
3580         if ($len != 0)
3581         {
3582           rnd ($mode, $len, $salt_len);
3583         }
3584         else
3585         {
3586           rnd ($mode, $i, $salt_len);
3587         }
3588       }
3589     }
3590     elsif ($mode == 10500 || $mode == 10700)
3591     {
3592       my $salt_len = 32;
3593
3594       for (my $i = 1; $i < 16; $i++)
3595       {
3596         if ($len != 0)
3597         {
3598           rnd ($mode, $len, $salt_len);
3599         }
3600         else
3601         {
3602           rnd ($mode, $i, $salt_len);
3603         }
3604       }
3605     }
3606     elsif ($mode == 11000)
3607     {
3608       for (my $i = 1; $i < 32; $i++)
3609       {
3610         if ($len != 0)
3611         {
3612           rnd ($mode, $len, 56);
3613         }
3614         else
3615         {
3616           rnd ($mode, $i, 56);
3617         }
3618       }
3619     }
3620     elsif ($mode == 11300)
3621     {
3622       for (my $i = 1; $i < 32; $i++)
3623       {
3624         if ($len != 0)
3625         {
3626           rnd ($mode, $len, 16);
3627         }
3628         else
3629         {
3630           rnd ($mode, $i, 16);
3631         }
3632       }
3633     }
3634     elsif ($mode == 11400)
3635     {
3636       for (my $i = 1; $i < 24; $i++)
3637       {
3638         if ($len != 0)
3639         {
3640           rnd ($mode, $len, 16);
3641         }
3642         else
3643         {
3644           rnd ($mode, $i, 16);
3645         }
3646       }
3647     }
3648     elsif ($mode == 11600)
3649     {
3650       my $salt_len = get_random_num (0, 16);
3651
3652       for (my $i = 1; $i < 32; $i++)
3653       {
3654         if ($len != 0)
3655         {
3656           rnd ($mode, $len, $salt_len);
3657         }
3658         else
3659         {
3660           rnd ($mode, $i, $salt_len);
3661         }
3662       }
3663     }
3664     elsif ($mode == 12400)
3665     {
3666       for (my $i = 1; $i < 32; $i++)
3667       {
3668         if ($len != 0)
3669         {
3670           rnd ($mode, $len, 4);
3671         }
3672         else
3673         {
3674           rnd ($mode, $i, 4);
3675         }
3676       }
3677     }
3678     elsif ($mode == 12600)
3679     {
3680       for (my $i = 1; $i < 32; $i++)
3681       {
3682         if ($len != 0)
3683         {
3684           rnd ($mode, $len, 64);
3685         }
3686         else
3687         {
3688           rnd ($mode, $i, 64);
3689         }
3690       }
3691     }
3692     elsif ($mode == 12700)
3693     {
3694       for (my $i = 1; $i < 32; $i++)
3695       {
3696         if ($len != 0)
3697         {
3698           rnd ($mode, $len, 32);
3699         }
3700         else
3701         {
3702           rnd ($mode, $i, 32);
3703         }
3704       }
3705     }
3706     elsif ($mode == 12800)
3707     {
3708       for (my $i = 1; $i < 25; $i++)
3709       {
3710         if ($len != 0)
3711         {
3712           rnd ($mode, $len, 20);
3713         }
3714         else
3715         {
3716           rnd ($mode, $i, 20);
3717         }
3718       }
3719     }
3720     elsif ($mode == 12900)
3721     {
3722       for (my $i = 1; $i < 32; $i++)
3723       {
3724         if ($len != 0)
3725         {
3726           rnd ($mode, $len, 32);
3727         }
3728         else
3729         {
3730           rnd ($mode, $i, 32);
3731         }
3732       }
3733     }
3734     elsif ($mode == 13000)
3735     {
3736       for (my $i = 1; $i < 32; $i++)
3737       {
3738         if ($len != 0)
3739         {
3740           rnd ($mode, $len, 32);
3741         }
3742         else
3743         {
3744           rnd ($mode, $i, 32);
3745         }
3746       }
3747     }
3748     elsif ($mode == 13100)
3749     {
3750       for (my $i = 1; $i < 27; $i++)
3751       {
3752         if ($len != 0)
3753         {
3754           rnd ($mode, $len, 16);
3755         }
3756         else
3757         {
3758           rnd ($mode, $i, 16);
3759         }
3760       }
3761     }
3762     elsif ($mode == 13200)
3763     {
3764       for (my $i = 1; $i < 32; $i++)
3765       {
3766         if ($len != 0)
3767         {
3768           rnd ($mode, $len, 32);
3769         }
3770         else
3771         {
3772           rnd ($mode, $i, 32);
3773         }
3774       }
3775     }
3776   }
3777 }
3778
3779 exit;
3780
3781 sub gen_hash
3782 {
3783   my $mode = shift;
3784
3785   my $word_buf = shift;
3786
3787   my $salt_buf = shift;
3788
3789   my $iter = shift;
3790
3791   my $additional_param = shift;
3792
3793   my $additional_param2 = shift;
3794
3795   my $additional_param3 = shift;
3796
3797   my $additional_param4 = shift;
3798
3799   my $additional_param5 = shift;
3800
3801   my $additional_param6 = shift;
3802
3803   my $additional_param7 = shift;
3804
3805   my $additional_param8 = shift;
3806
3807   my $additional_param9 = shift;
3808
3809   my $additional_param10 = shift;
3810
3811   my $additional_param11 = shift;
3812
3813   ##
3814   ## gen hash
3815   ##
3816
3817   my $tmp_hash;
3818
3819   my $hash_buf;
3820
3821   if ($mode == 0)
3822   {
3823     $hash_buf = md5_hex ($word_buf);
3824
3825     $tmp_hash = sprintf ("%s", $hash_buf);
3826   }
3827   elsif ($mode == 10)
3828   {
3829     $hash_buf = md5_hex ($word_buf . $salt_buf);
3830
3831     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3832   }
3833   elsif ($mode == 11)
3834   {
3835     $hash_buf = md5_hex ($word_buf . $salt_buf);
3836
3837     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3838   }
3839   elsif ($mode == 12)
3840   {
3841     $hash_buf = md5_hex ($word_buf . $salt_buf);
3842
3843     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3844   }
3845   elsif ($mode == 20)
3846   {
3847     $hash_buf = md5_hex ($salt_buf . $word_buf);
3848
3849     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3850   }
3851   elsif ($mode == 21)
3852   {
3853     $hash_buf = md5_hex ($salt_buf . $word_buf);
3854
3855     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3856   }
3857   elsif ($mode == 22)
3858   {
3859     my $itoa64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
3860     my $salt_suffix = "Administration Tools";
3861
3862     my $pass = sprintf ("%s:%s:%s", $salt_buf, $salt_suffix, $word_buf);
3863
3864     $hash_buf = md5 ($pass);
3865
3866     my $res = "";
3867
3868     for (my $pos = 0; $pos < 16; $pos += 2)
3869     {
3870       my $octet1 = ord (substr ($hash_buf, $pos + 0, 1));
3871       my $octet2 = ord (substr ($hash_buf, $pos + 1, 1));
3872
3873       my $num = ($octet1 <<8 & 0xff00) | ($octet2 & 0xff);
3874
3875       my $idx1 = $num >> 12 & 0x0f;
3876       my $idx2 = $num >>  6 & 0x3f;
3877       my $idx3 = $num       & 0x3f;
3878
3879       $res = $res . substr ($itoa64, $idx1, 1) . substr ($itoa64, $idx2, 1) . substr ($itoa64, $idx3, 1);
3880     }
3881
3882     my $obfuscate_str = "nrcstn";
3883     my @obfuscate_pos = (0, 6, 12, 17, 23, 29);
3884
3885     foreach my $pos (keys @obfuscate_pos)
3886     {
3887       my $idx = $obfuscate_pos[$pos];
3888       my $before = substr ($res, 0, $idx);
3889       my $char   = substr ($obfuscate_str, $pos, 1);
3890       my $after  = substr ($res, $idx);
3891
3892       $res = sprintf ("%s%s%s", $before, $char, $after);
3893     }
3894
3895     $tmp_hash = sprintf ("%s:%s", $res, $salt_buf);
3896   }
3897   elsif ($mode == 23)
3898   {
3899     $hash_buf = md5_hex ($salt_buf . "\nskyper\n" . $word_buf);
3900
3901     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3902   }
3903   elsif ($mode == 30)
3904   {
3905     $hash_buf = md5_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
3906
3907     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3908   }
3909   elsif ($mode == 40)
3910   {
3911     $hash_buf = md5_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
3912
3913     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3914   }
3915   elsif ($mode == 50)
3916   {
3917     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5, 64);
3918
3919     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3920   }
3921   elsif ($mode == 60)
3922   {
3923     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&md5, 64);
3924
3925     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3926   }
3927   elsif ($mode == 100)
3928   {
3929     $hash_buf = sha1_hex ($word_buf);
3930
3931     $tmp_hash = sprintf ("%s", $hash_buf);
3932   }
3933   elsif ($mode == 101)
3934   {
3935     $hash_buf = sha1 ($word_buf);
3936
3937     my $base64_buf = encode_base64 ($hash_buf);
3938
3939     chomp ($base64_buf);
3940
3941     $tmp_hash = sprintf ("{SHA}%s", $base64_buf);
3942   }
3943   elsif ($mode == 110)
3944   {
3945     $hash_buf = sha1_hex ($word_buf . $salt_buf);
3946
3947     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3948   }
3949   elsif ($mode == 111)
3950   {
3951     $hash_buf = sha1 ($word_buf . $salt_buf);
3952
3953     my $base64_buf = encode_base64 ($hash_buf . $salt_buf);
3954
3955     chomp ($base64_buf);
3956
3957     $tmp_hash = sprintf ("{SSHA}%s", $base64_buf);
3958   }
3959   elsif ($mode == 112)
3960   {
3961     my $salt_buf_bin = pack ("H*", $salt_buf);
3962
3963     $hash_buf = sha1_hex ($word_buf . $salt_buf_bin);
3964
3965     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3966   }
3967   elsif ($mode == 120)
3968   {
3969     $hash_buf = sha1_hex ($salt_buf . $word_buf);
3970
3971     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3972   }
3973   elsif ($mode == 121)
3974   {
3975     $hash_buf = sha1_hex (lc ($salt_buf) . $word_buf);
3976
3977     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3978   }
3979   elsif ($mode == 122)
3980   {
3981     my $salt_buf_bin = pack ("H*", $salt_buf);
3982
3983     $hash_buf = sha1_hex ($salt_buf_bin . $word_buf);
3984
3985     $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
3986   }
3987   elsif ($mode == 130)
3988   {
3989     $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
3990
3991     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
3992   }
3993   elsif ($mode == 131)
3994   {
3995     my $salt_buf_bin = pack ("H*", $salt_buf);
3996
3997     $hash_buf = sha1_hex (encode ("UTF-16LE", uc ($word_buf)) . $salt_buf_bin);
3998
3999     $tmp_hash = sprintf ("0x0100%s%s%s", $salt_buf, "0" x 40, $hash_buf);
4000   }
4001   elsif ($mode == 132)
4002   {
4003     my $salt_buf_bin = pack ("H*", $salt_buf);
4004
4005     $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin);
4006
4007     $tmp_hash = sprintf ("0x0100%s%s", $salt_buf, $hash_buf);
4008   }
4009   elsif ($mode == 140)
4010   {
4011     $hash_buf = sha1_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
4012
4013     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4014   }
4015   elsif ($mode == 141)
4016   {
4017     $hash_buf = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
4018
4019     my $base64_salt_buf = encode_base64 ($salt_buf);
4020
4021     chomp ($base64_salt_buf);
4022
4023     my $base64_hash_buf = encode_base64 ($hash_buf);
4024
4025     $base64_hash_buf = substr ($base64_hash_buf, 0, 27);
4026
4027     $tmp_hash = sprintf ("\$episerver\$*0*%s*%s", $base64_salt_buf, $base64_hash_buf);
4028   }
4029   elsif ($mode == 150)
4030   {
4031     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1, 64);
4032
4033     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4034   }
4035   elsif ($mode == 160)
4036   {
4037     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha1, 64);
4038
4039     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4040   }
4041   elsif ($mode == 190)
4042   {
4043     $hash_buf = sha1_hex ($word_buf);
4044
4045     my $variant = int (rand (2));
4046
4047     if (defined ($additional_param))
4048     {
4049       $variant = $additional_param;
4050     }
4051
4052     if ($variant == 1)
4053     {
4054       substr ($hash_buf, 0, 5) = "00000";
4055     }
4056
4057     $tmp_hash = sprintf ("%s", $hash_buf);
4058   }
4059   elsif ($mode == 200)
4060   {
4061     my $ppr = Authen::Passphrase::MySQL323->new (passphrase => $word_buf);
4062
4063     $hash_buf = $ppr->hash_hex;
4064
4065     $tmp_hash = sprintf ("%s", $hash_buf);
4066   }
4067   elsif ($mode == 300)
4068   {
4069     $hash_buf = substr (password41 ($word_buf), 1);
4070
4071     $hash_buf = lc ($hash_buf); # useful for 'not matched' check only
4072
4073     $tmp_hash = sprintf ("%s", $hash_buf);
4074   }
4075   elsif ($mode == 400)
4076   {
4077     my $cost = 11;
4078
4079     if (length ($iter))
4080     {
4081       $cost = $iter;
4082     }
4083
4084     my $ppr = Authen::Passphrase::PHPass->new
4085     (
4086       cost => $cost,
4087       salt => $salt_buf,
4088       passphrase => $word_buf,
4089     );
4090
4091     $hash_buf = $ppr->as_rfc2307;
4092
4093     $tmp_hash = sprintf ("%s", substr ($hash_buf, 7));
4094   }
4095   elsif ($mode == 500)
4096   {
4097     my $iterations = 1000;
4098
4099     if (defined ($iter))
4100     {
4101       if ($iter > 0)
4102       {
4103         $iterations = int ($iter);
4104       }
4105     }
4106
4107     $hash_buf = md5_crypt ('$1$', $iterations, $word_buf, $salt_buf);
4108
4109     $tmp_hash = sprintf ("%s", $hash_buf);
4110   }
4111   elsif ($mode == 900)
4112   {
4113     $hash_buf = md4_hex ($word_buf);
4114
4115     $tmp_hash = sprintf ("%s", $hash_buf);
4116   }
4117   elsif ($mode == 1000)
4118   {
4119     $hash_buf = md4_hex (encode ("UTF-16LE", $word_buf));
4120
4121     $tmp_hash = sprintf ("%s", $hash_buf);
4122   }
4123   elsif ($mode == 1100)
4124   {
4125     $hash_buf = md4_hex (md4 (encode ("UTF-16LE", $word_buf)) . encode ("UTF-16LE", lc ($salt_buf)));
4126
4127     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4128   }
4129   elsif ($mode == 1400)
4130   {
4131     $hash_buf = sha256_hex ($word_buf);
4132
4133     $tmp_hash = sprintf ("%s", $hash_buf);
4134   }
4135   elsif ($mode == 1410)
4136   {
4137     $hash_buf = sha256_hex ($word_buf . $salt_buf);
4138
4139     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4140   }
4141   elsif ($mode == 1420)
4142   {
4143     $hash_buf = sha256_hex ($salt_buf . $word_buf);
4144
4145     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4146   }
4147   elsif ($mode == 1430)
4148   {
4149     $hash_buf = sha256_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
4150
4151     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4152   }
4153   elsif ($mode == 1440)
4154   {
4155     $hash_buf = sha256_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
4156
4157     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4158   }
4159   elsif ($mode == 1441)
4160   {
4161     $hash_buf = sha256 ($salt_buf . encode ("UTF-16LE", $word_buf));
4162
4163     my $base64_salt_buf = encode_base64 ($salt_buf);
4164
4165     chomp ($base64_salt_buf);
4166
4167     my $base64_hash_buf = encode_base64 ($hash_buf);
4168
4169     chomp ($base64_hash_buf);
4170
4171     $base64_hash_buf = substr ($base64_hash_buf, 0, 43);
4172
4173     $tmp_hash = sprintf ("\$episerver\$*1*%s*%s", $base64_salt_buf, $base64_hash_buf);
4174   }
4175   elsif ($mode == 1450)
4176   {
4177     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha256, 64);
4178
4179     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4180   }
4181   elsif ($mode == 1460)
4182   {
4183     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha256, 64);
4184
4185     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4186   }
4187   elsif ($mode == 1500)
4188   {
4189     $hash_buf = crypt ($word_buf, $salt_buf);
4190
4191     $tmp_hash = sprintf ("%s", $hash_buf);
4192   }
4193   elsif ($mode == 1600)
4194   {
4195     my $iterations = 1000;
4196
4197     if (defined ($iter))
4198     {
4199       if ($iter > 0)
4200       {
4201         $iterations = int ($iter);
4202       }
4203     }
4204
4205     $hash_buf = md5_crypt ('$apr1$', $iterations, $word_buf, $salt_buf);
4206
4207     $tmp_hash = sprintf ("%s", $hash_buf);
4208   }
4209   elsif ($mode == 1700)
4210   {
4211     $hash_buf = sha512_hex ($word_buf);
4212
4213     $tmp_hash = sprintf ("%s", $hash_buf);
4214   }
4215   elsif ($mode == 1710)
4216   {
4217     $hash_buf = sha512_hex ($word_buf . $salt_buf);
4218
4219     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4220   }
4221   elsif ($mode == 1711)
4222   {
4223     $hash_buf = sha512_hex ($word_buf . $salt_buf);
4224
4225     my $base64_buf = encode_base64 (pack ("H*", $hash_buf) . $salt_buf);
4226
4227     $base64_buf =~ s/[ \n]//g;
4228
4229     $tmp_hash = sprintf ("{SSHA512}%s", $base64_buf);
4230   }
4231   elsif ($mode == 1720)
4232   {
4233     $hash_buf = sha512_hex ($salt_buf . $word_buf);
4234
4235     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4236   }
4237   elsif ($mode == 1730)
4238   {
4239     $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf);
4240
4241     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4242   }
4243   elsif ($mode == 1740)
4244   {
4245     $hash_buf = sha512_hex ($salt_buf . encode ("UTF-16LE", $word_buf));
4246
4247     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4248   }
4249   elsif ($mode == 1722)
4250   {
4251     my $salt_buf_bin = pack ("H*", $salt_buf);
4252
4253     $hash_buf = sha512_hex ($salt_buf_bin . $word_buf);
4254
4255     $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf);
4256   }
4257   elsif ($mode == 1731)
4258   {
4259     my $salt_buf_bin = pack ("H*", $salt_buf);
4260
4261     $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin);
4262
4263     $tmp_hash = sprintf ("0x0200%s%s", $salt_buf, $hash_buf);
4264   }
4265   elsif ($mode == 1750)
4266   {
4267     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha512, 128);
4268
4269     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4270   }
4271   elsif ($mode == 1760)
4272   {
4273     $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha512, 128);
4274
4275     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4276   }
4277   elsif ($mode == 1800)
4278   {
4279     my $iterations = 5000;
4280
4281     if (defined ($iter))
4282     {
4283       if ($iter > 0)
4284       {
4285         $iterations = int ($iter);
4286       }
4287     }
4288
4289     $hash_buf = sha512_crypt ($iterations, $word_buf, $salt_buf);
4290
4291     $tmp_hash = sprintf ("%s", $hash_buf);
4292   }
4293   elsif ($mode == 2100)
4294   {
4295     my $iterations = 10240;
4296
4297     if (length ($iter))
4298     {
4299       $iterations = int ($iter);
4300     }
4301
4302     my $salt = encode ("UTF-16LE", lc ($salt_buf));
4303
4304     my $pbkdf2 = Crypt::PBKDF2->new
4305     (
4306       hash_class => 'HMACSHA1',
4307       iterations => $iterations,
4308       output_len => 16,
4309       salt_len   => length ($salt),
4310     );
4311
4312     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 ($salt, md4 (md4 (encode ("UTF-16LE", $word_buf)) . $salt)));
4313
4314     $tmp_hash = sprintf ("\$DCC2\$%i#%s#%s", $iterations, $salt_buf, $hash_buf);
4315   }
4316   elsif ($mode == 2400)
4317   {
4318     $tmp_hash = sprintf ("%s", pseudo_base64 (Digest::MD5::md5 ($word_buf . "\0" x (16 - length ($word_buf)))));
4319   }
4320   elsif ($mode == 2410)
4321   {
4322     my $salt_len = length ($salt_buf);
4323
4324     my $salt_len_max4 = ($salt_len < 4) ? $salt_len : 4;
4325
4326     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)));
4327
4328     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4329   }
4330   elsif ($mode == 2500)
4331   {
4332     my ($bssid, $stmac, $snonce, $anonce, $eapol, $keyver, $eapol_size);
4333
4334     if (! defined ($additional_param))
4335     {
4336       # random stuff
4337
4338       $bssid  = randbytes (6);
4339       $stmac  = randbytes (6);
4340       $snonce = randbytes (32);
4341       $anonce = randbytes (32);
4342
4343       $keyver = get_random_num (1, 3); # 1 or 2
4344
4345       # eapol:
4346       # should be "validly" generated, but in theory could be anything for us also:
4347       # $eapol = "\x00" x 121; # works too, but let's generate it correctly
4348
4349       $eapol = gen_random_wpa_eapol ($keyver, $snonce);
4350     }
4351     else
4352     {
4353       $bssid  = $additional_param;
4354       $stmac  = $additional_param2;
4355       $snonce = $additional_param3;
4356       $anonce = $additional_param4;
4357       $keyver = $additional_param5;
4358       $eapol  = $additional_param6;
4359     }
4360
4361     $eapol_size = length ($eapol);
4362
4363     # constants
4364
4365     my $iterations = 4096;
4366
4367     #
4368     # START
4369     #
4370
4371     # generate the Pairwise Master Key (PMK)
4372
4373     my $pbkdf2 = Crypt::PBKDF2->new
4374     (
4375       hash_class => 'HMACSHA1',
4376       iterations => $iterations,
4377       output_len => 32,
4378     );
4379
4380     my $pmk = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
4381
4382     # Pairwise Transient Key (PTK) transformation
4383
4384     my $ptk = wpa_prf_512 ($pmk, $stmac, $bssid, $snonce, $anonce);
4385
4386     # generate the Message Integrity Code (MIC)
4387
4388     my $mic = "";
4389
4390     if ($keyver == 1) # WPA1 => MD5
4391     {
4392       $mic = hmac ($eapol, $ptk, \&md5);
4393     }
4394     else # WPA2 => SHA1
4395     {
4396       $mic = hmac ($eapol, $ptk, \&sha1);
4397     }
4398
4399     $mic = substr ($mic, 0, 16);
4400
4401     #
4402     # format the binary output
4403     #
4404
4405     $hash_buf = "";
4406
4407     # first the essid (NULL-padded up to the first 36 bytes)
4408
4409     $hash_buf .= $salt_buf;
4410     $hash_buf .= "\x00" x (36 - length ($salt_buf));
4411
4412     # the 2 MAC addresses
4413
4414     $hash_buf .= $bssid;
4415     $hash_buf .= $stmac;
4416
4417     # nonces
4418
4419     $hash_buf .= $snonce;
4420     $hash_buf .= $anonce;
4421
4422     # eapol
4423
4424     $hash_buf .= $eapol;
4425     $hash_buf .= "\x00" x (256 - $eapol_size);
4426
4427     # eapol size
4428
4429     $hash_buf .= pack ("L*", $eapol_size);
4430
4431     # key version
4432
4433     $hash_buf .= pack ("L*", $keyver);
4434
4435     # and finally: the key mic
4436
4437     $hash_buf .= $mic;
4438
4439     # base64 encode the output
4440
4441     $tmp_hash = encode_base64 ($hash_buf, '');
4442   }
4443   elsif ($mode == 2600)
4444   {
4445     $hash_buf = md5_hex (md5_hex ($word_buf));
4446
4447     $tmp_hash = sprintf ("%s", $hash_buf);
4448   }
4449   elsif ($mode == 2611)
4450   {
4451     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4452
4453     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4454   }
4455   elsif ($mode == 2612)
4456   {
4457     my $salt_buf_hex = unpack ("H*", $salt_buf);
4458
4459     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4460
4461     $tmp_hash = sprintf ("\$PHPS\$%s\$%s", $salt_buf_hex, $hash_buf);
4462   }
4463   elsif ($mode == 2711)
4464   {
4465     $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf);
4466
4467     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4468   }
4469   elsif ($mode == 2811)
4470   {
4471     $hash_buf = md5_hex (md5_hex ($salt_buf) . md5_hex ($word_buf));
4472
4473     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4474   }
4475   elsif ($mode == 3000)
4476   {
4477     my $ppr = Authen::Passphrase::LANManager->new ("passphrase" => $word_buf);
4478
4479     $hash_buf = $ppr->hash_hex;
4480
4481     $tmp_hash = sprintf ("%s", substr ($hash_buf, 0, 16));
4482   }
4483   elsif ($mode == 3100)
4484   {
4485     $hash_buf = oracle_hash ($salt_buf, $word_buf);
4486
4487     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4488   }
4489   elsif ($mode == 3200)
4490   {
4491     my $cost = "05";
4492
4493     if (length ($iter))
4494     {
4495       $cost = $iter;
4496     }
4497
4498     $tmp_hash = bcrypt ($word_buf, sprintf ('$2a$%s$%s$', $cost, en_base64 ($salt_buf)));
4499   }
4500   elsif ($mode == 3300)
4501   {
4502     my $iterations = 904;
4503
4504     if (length ($iter))
4505     {
4506       $iterations = int ($iter);
4507     }
4508
4509     my $variant = "\$";
4510
4511     if (defined ($additional_param))
4512     {
4513       $variant = $additional_param;
4514     }
4515
4516     my $prefix = sprintf ("\$md5%srounds=%i\$%s", $variant, $iterations, $salt_buf);
4517
4518     $iterations += 4096;
4519
4520     $hash_buf = sun_md5 ($word_buf, $prefix, $iterations);
4521
4522     $tmp_hash = sprintf ("%s\$%s", $prefix, $hash_buf);
4523   }
4524   elsif ($mode == 3500)
4525   {
4526     $hash_buf = md5_hex (md5_hex (md5_hex ($word_buf)));
4527
4528     $tmp_hash = sprintf ("%s", $hash_buf);
4529   }
4530   elsif ($mode == 3610)
4531   {
4532     $hash_buf = md5_hex (md5_hex ($salt_buf) . $word_buf);
4533
4534     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4535   }
4536   elsif ($mode == 3710)
4537   {
4538     $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf));
4539
4540     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4541   }
4542   elsif ($mode == 3711)
4543   {
4544     $hash_buf = md5_hex ($salt_buf . "-" . md5_hex ($word_buf));
4545
4546     $tmp_hash = sprintf ("\$B\$%s\$%s", $salt_buf, $hash_buf);
4547   }
4548   elsif ($mode == 3720)
4549   {
4550     $hash_buf = md5_hex ($word_buf . md5_hex ($salt_buf));
4551
4552     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4553   }
4554   elsif ($mode == 3800)
4555   {
4556     $hash_buf = md5_hex ($salt_buf . $word_buf . $salt_buf);
4557
4558     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4559   }
4560   elsif ($mode == 3910)
4561   {
4562     $hash_buf = md5_hex (md5_hex ($word_buf) . md5_hex ($salt_buf));
4563
4564     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4565   }
4566   elsif ($mode == 4010)
4567   {
4568     $hash_buf = md5_hex ($salt_buf . md5_hex ($salt_buf . $word_buf));
4569
4570     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4571   }
4572   elsif ($mode == 4110)
4573   {
4574     $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf . $salt_buf));
4575
4576     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4577   }
4578   elsif ($mode == 4210)
4579   {
4580     $hash_buf = md5_hex ($salt_buf . "\x00" . $word_buf);
4581
4582     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4583   }
4584   elsif ($mode == 4300)
4585   {
4586     $hash_buf = md5_hex (uc (md5_hex ($word_buf)));
4587
4588     $tmp_hash = sprintf ("%s", $hash_buf);
4589   }
4590   elsif ($mode == 4400)
4591   {
4592     $hash_buf = md5_hex (sha1_hex ($word_buf));
4593
4594     $tmp_hash = sprintf ("%s", $hash_buf);
4595   }
4596   elsif ($mode == 4500)
4597   {
4598     $hash_buf = sha1_hex (sha1_hex ($word_buf));
4599
4600     $tmp_hash = sprintf ("%s", $hash_buf);
4601   }
4602   elsif ($mode == 4600)
4603   {
4604     $hash_buf = sha1_hex (sha1_hex (sha1_hex ($word_buf)));
4605
4606     $tmp_hash = sprintf ("%s", $hash_buf);
4607   }
4608   elsif ($mode == 4700)
4609   {
4610     $hash_buf = sha1_hex (md5_hex ($word_buf));
4611
4612     $tmp_hash = sprintf ("%s", $hash_buf);
4613   }
4614   elsif ($mode == 4800)
4615   {
4616     my $index = rindex ($salt_buf, ":");
4617
4618     my $salt  = substr ($salt_buf, 0, $index);
4619     my $salt_bin  = pack ("H*", $salt);
4620     my $chap_sign = substr ($salt_buf, $index + 1);
4621     my $chap_sign_bin = pack ("H*", $chap_sign);
4622
4623     $hash_buf = md5_hex ($chap_sign_bin . $word_buf . $salt_bin);
4624
4625     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4626   }
4627   elsif ($mode == 4900)
4628   {
4629     $hash_buf = sha1_hex ($salt_buf . $word_buf . $salt_buf);
4630
4631     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4632   }
4633   elsif ($mode == 5000)
4634   {
4635     $hash_buf = keccak_256_hex ($word_buf);
4636
4637     $tmp_hash = sprintf ("%s", $hash_buf);
4638   }
4639   elsif ($mode == 5100)
4640   {
4641     my $pos;
4642
4643     if (! defined ($additional_param))
4644     {
4645       $pos = 0;
4646     }
4647     else
4648     {
4649       $pos = $additional_param * 8 unless ($additional_param > 2);
4650     }
4651
4652     $hash_buf = md5_hex ($word_buf);
4653
4654     $tmp_hash = sprintf ("%s", substr ($hash_buf, $pos, 16));
4655   }
4656   elsif ($mode == 5300)
4657   {
4658     my @salt_arr = split (":", $salt_buf);
4659
4660     my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4661     my $nr_buf  = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4662
4663     my $hash_buf = hmac  ($nr_buf , $word_buf, \&md5, 64);
4664     $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&md5, 64);
4665
4666     $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4667   }
4668   elsif ($mode == 5400)
4669   {
4670     my @salt_arr = split (":", $salt_buf);
4671
4672     my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]);
4673     my $nr_buf  = pack ("H*", $salt_arr[6] . $salt_arr[7]);
4674
4675     my $hash_buf = hmac  ($nr_buf , $word_buf, \&sha1, 64);
4676     $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&sha1, 64);
4677
4678     $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf);
4679   }
4680   elsif ($mode == 5500)
4681   {
4682     my $index1 = index  ($salt_buf, "::");
4683     my $user   = substr ($salt_buf, 0, $index1);
4684
4685     my $index2 = index  ($salt_buf, ":", $index1 + 2);
4686     my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4687
4688     my $len = length (substr ($salt_buf, $index2 + 1));
4689
4690     my $c_challenge_hex;
4691
4692     if ($len > 32)
4693     {
4694       $c_challenge_hex = substr ($salt_buf, $index2 +  1, 48);
4695       $index2 += 32;
4696     }
4697     else
4698     {
4699       $c_challenge_hex  = substr ($salt_buf, $index2 +  1, 16);
4700       $c_challenge_hex .= 00 x 32;
4701     }
4702
4703     my $c_challenge     = pack   ("H*", substr ($c_challenge_hex, 0, 16));
4704     my $s_challenge_hex = substr ($salt_buf, $index2 + 17, 16);
4705     my $s_challenge     = pack   ("H*", $s_challenge_hex);
4706
4707     my $challenge = substr (md5 ($s_challenge . $c_challenge), 0, 8);
4708
4709     my $ntresp;
4710
4711     my $nthash = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash . "\x00" x 5;
4712
4713     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash,  0, 7)), "DES", $challenge, PADDING_NONE);
4714     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash,  7, 7)), "DES", $challenge, PADDING_NONE);
4715     $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash, 14, 7)), "DES", $challenge, PADDING_NONE);
4716
4717     $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $c_challenge_hex, unpack ("H*", $ntresp), $s_challenge_hex);
4718   }
4719   elsif ($mode == 5600)
4720   {
4721     my $index1 = index  ($salt_buf, "::");
4722     my $user   = substr ($salt_buf, 0, $index1);
4723
4724     my $index2 = index  ($salt_buf, ":", $index1 + 2);
4725     my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2);
4726
4727     my $s_challenge_hex = substr ($salt_buf, $index2 + 1, 16);
4728     my $s_challenge     = pack   ("H*", $s_challenge_hex);
4729
4730     my $temp_hex = substr ($salt_buf, $index2 + 17);
4731     my $temp     = pack   ("H*", $temp_hex);
4732
4733     my $nthash   = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash;
4734     my $identity = Encode::encode ("UTF-16LE", uc ($user) . $domain);
4735
4736     $hash_buf = hmac_hex ($s_challenge . $temp, hmac ($identity, $nthash, \&md5, 64), \&md5, 64);
4737
4738     $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $s_challenge_hex, $hash_buf, $temp_hex);
4739   }
4740   elsif ($mode == 5700)
4741   {
4742     $hash_buf = sha256 ($word_buf);
4743
4744     my $base64_buf = encode_base64 ($hash_buf);
4745
4746     $tmp_hash = "";
4747
4748     for (my $i = 0; $i < 43; $i++)
4749     {
4750       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($base64_buf, $i, 1)};
4751     }
4752   }
4753   elsif ($mode == 5800)
4754   {
4755     $hash_buf = androidpin_hash ($word_buf, $salt_buf);
4756
4757     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
4758   }
4759   elsif ($mode == 6000)
4760   {
4761     $hash_buf = ripemd160_hex ($word_buf);
4762
4763     $tmp_hash = sprintf ("%s", $hash_buf);
4764   }
4765   elsif ($mode == 6100)
4766   {
4767     $hash_buf = whirlpool_hex ($word_buf);
4768
4769     $tmp_hash = sprintf ("%s", $hash_buf);
4770   }
4771   elsif ($mode == 6300)
4772   {
4773     my $iterations = 1000; # hard coded by the AIX format
4774
4775     $hash_buf = md5_crypt ('', $iterations, $word_buf, $salt_buf);
4776
4777     $tmp_hash = sprintf ("{smd5}%s", $hash_buf);
4778   }
4779   elsif ($mode == 6400)
4780   {
4781     my $iterations = 64;
4782
4783     if (length ($iter))
4784     {
4785       $iterations = 1 << int ($iter);
4786     }
4787
4788     $hash_buf = aix_ssha256_pbkdf2 ($word_buf, $salt_buf, $iterations);
4789
4790     $tmp_hash = sprintf ("{ssha256}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4791   }
4792   elsif ($mode == 6500)
4793   {
4794     my $iterations = 64;
4795
4796     if (length ($iter))
4797     {
4798       $iterations = 1 << int ($iter);
4799     }
4800
4801     $hash_buf = aix_ssha512_pbkdf2 ($word_buf, $salt_buf, $iterations);
4802
4803     $tmp_hash = sprintf ("{ssha512}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4804   }
4805   elsif ($mode == 6600)
4806   {
4807     my $iterations = 1000;
4808
4809     if (length ($iter))
4810     {
4811       $iterations = int ($iter);
4812     }
4813
4814     my $salt_hex = substr ($salt_buf, 0, 16);
4815     my $salt     = pack   ("H*", $salt_hex);
4816
4817     my $prefix   = substr ($salt_buf, 16, 2016);
4818
4819     my $iv_hex   = substr ($salt_buf, 2032);
4820     my $iv       = pack ("H*", $iv_hex);
4821
4822     my $data = pack ("H*", "10101010101010101010101010101010");
4823
4824     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
4825
4826     my $pbkdf2 = Crypt::PBKDF2->new (
4827       hasher       => $hasher,
4828       iterations   => $iterations,
4829       output_len   => 16
4830     );
4831
4832     my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
4833
4834     my $cipher = Crypt::CBC->new ({
4835       key         => $key,
4836       cipher      => "Crypt::Rijndael",
4837       iv          => $iv,
4838       literal_key => 1,
4839       header      => "none",
4840       keysize     => 16
4841     });
4842
4843     my $encrypted = unpack ("H*", $cipher->encrypt ($data));
4844
4845     $hash_buf  = substr ($encrypted, 0, 32);
4846
4847     $tmp_hash = sprintf ("%i:%s:%s%s%s", $iterations, $salt_hex, $prefix, $iv_hex, $hash_buf);
4848   }
4849   elsif ($mode == 6700)
4850   {
4851     my $iterations = 64;
4852
4853     if (length ($iter))
4854     {
4855       $iterations = 1 << int ($iter);
4856     }
4857
4858     $hash_buf = aix_ssha1_pbkdf2 ($word_buf, $salt_buf, $iterations);
4859
4860     $tmp_hash = sprintf ("{ssha1}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf);
4861   }
4862   elsif ($mode == 6800)
4863   {
4864     my $variant = $additional_param;
4865
4866     if (! defined ($variant))
4867     {
4868       $variant = int (rand (2));
4869     }
4870
4871     my $iterations = 500;
4872
4873     if (length ($iter))
4874     {
4875       $iterations = int ($iter);
4876     }
4877
4878     my $iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4879
4880     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256);
4881
4882     my $pbkdf2 = Crypt::PBKDF2->new (
4883       hasher       => $hasher,
4884       iterations   => $iterations,
4885       output_len   => 32
4886     );
4887
4888     my $key = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
4889
4890     my $cipher = Crypt::CBC->new ({
4891       key         => $key,
4892       cipher      => "Crypt::Rijndael",
4893       iv          => $iv,
4894       literal_key => 1,
4895       header      => "none",
4896       keysize     => 32
4897     });
4898
4899     if ($variant == 1)
4900     {
4901       my $encrypt = $cipher->encrypt (substr ($salt_buf, 0, 16));
4902
4903       $hash_buf = substr (unpack ("H*", $encrypt), 0, 32);
4904     }
4905     else
4906     {
4907       my $verifier = "lastpass rocks\x02\x02";
4908
4909       $hash_buf = unpack ("H*", substr ($cipher->encrypt ($verifier), 0, 16));
4910     }
4911
4912     $tmp_hash = sprintf ("%s:%i:%s", $hash_buf, $iterations, $salt_buf);
4913   }
4914   elsif ($mode == 6900)
4915   {
4916     $hash_buf = gost_hex ($word_buf);
4917
4918     $tmp_hash = sprintf ("%s", $hash_buf);
4919   }
4920   elsif ($mode == 7100)
4921   {
4922     my $iterations = 1024;
4923
4924     if (length ($iter))
4925     {
4926       $iterations = int ($iter);
4927     }
4928
4929     my $pbkdf2 = Crypt::PBKDF2->new
4930     (
4931       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
4932       iterations => $iterations
4933     );
4934
4935     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
4936
4937     $tmp_hash = sprintf ("\$ml\$%i\$%s\$%0128s", $iterations, $salt_buf, $hash_buf);
4938   }
4939   elsif ($mode == 7200)
4940   {
4941     my $iterations = 1024;
4942
4943     if (length ($iter))
4944     {
4945       $iterations = int ($iter);
4946     }
4947
4948     my $pbkdf2 = Crypt::PBKDF2->new (
4949       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
4950       iterations => $iterations
4951     );
4952
4953     $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf));
4954
4955     $tmp_hash = sprintf ("grub.pbkdf2.sha512.%i.%s.%0128s", $iterations, $salt_buf, $hash_buf);
4956   }
4957   elsif ($mode == 7300)
4958   {
4959     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1);
4960
4961     $tmp_hash = sprintf ("%s:%s", unpack ("H*", $salt_buf), $hash_buf);
4962   }
4963   elsif ($mode == 7400)
4964   {
4965     my $iterations = 5000;
4966
4967     if (defined ($iter))
4968     {
4969       if ($iter > 0)
4970       {
4971         $iterations = int ($iter);
4972       }
4973     }
4974
4975     $hash_buf = sha256_crypt ($iterations, $word_buf, $salt_buf);
4976
4977     $tmp_hash = sprintf ("%s", $hash_buf);
4978   }
4979   elsif ($mode == 7500)
4980   {
4981     my @salt_arr = split ("\\\$", $salt_buf);
4982
4983     my $user = $salt_arr[0];
4984
4985     my $realm = $salt_arr[1];
4986
4987     my $salt = $salt_arr[2];
4988
4989     my $hmac_salt = $salt_arr[3];
4990     my $hmac_salt_bin = pack ("H*", $hmac_salt);
4991
4992     my $clear_data = $salt_arr[4];
4993
4994     my $k = md4 (encode ("UTF-16LE", $word_buf));
4995
4996     my $k1 = hmac_md5 ("\x01\x00\x00\x00", $k);
4997
4998     my $k3 = hmac_md5 ($hmac_salt_bin, $k1);
4999
5000     if (length ($clear_data) > 1)
5001     {
5002       my $clear_data_bin = pack ("H*", $clear_data);
5003
5004       $hash_buf = RC4 ($k3, $clear_data_bin);
5005     }
5006     else
5007     {
5008       my $hash = $salt_arr[5];
5009
5010       my $hash_bin = pack ("H*", $hash);
5011
5012       my $clear_data = RC4 ($k3, $hash_bin);
5013
5014       my $timestamp = substr ($clear_data, 14, 14);
5015
5016       my $is_numeric = 1;
5017       my $num;
5018
5019       if ($timestamp !~ /^[[:digit:]]{14}$/)
5020       {
5021         $is_numeric = 0;
5022       }
5023
5024       if (! $is_numeric)
5025       {
5026         $hash_buf = "\x00" x 36;
5027
5028         if ($hash_buf eq $hash_bin)
5029         {
5030           $hash_buf = "\x01" x 36;
5031         }
5032       }
5033       else
5034       {
5035         $hash_buf = $hash_bin;
5036       }
5037     }
5038
5039     $tmp_hash = sprintf ("\$krb5pa\$23\$%s\$%s\$%s\$%s%s", $user, $realm, $salt, unpack ("H*", $hash_buf), $hmac_salt);
5040   }
5041   elsif ($mode == 7600)
5042   {
5043     $hash_buf = sha1_hex ($salt_buf . sha1_hex ($word_buf));
5044
5045     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5046   }
5047   elsif ($mode == 7700)
5048   {
5049     $word_buf = uc $word_buf;
5050     $salt_buf = uc $salt_buf;
5051
5052     my $word_buf_t = sapb_transcode ($word_buf);
5053     my $salt_buf_t = sapb_transcode ($salt_buf);
5054
5055     my $digest1 = md5 ($word_buf_t . $salt_buf_t);
5056
5057     my $data = sapb_waldorf ($digest1, $word_buf_t, $salt_buf_t);
5058
5059     my $digest2 = md5 ($data);
5060
5061     my ($a, $b, $c, $d) = unpack ("N4", $digest2);
5062
5063     $a ^= $c;
5064     $b ^= $d;
5065
5066     $tmp_hash = sprintf ("%s\$%08X%08X", $salt_buf, $a, $b);
5067   }
5068   elsif ($mode == 7800)
5069   {
5070     my $theMagicArray_s =
5071       "\x91\xac\x51\x14\x9f\x67\x54\x43\x24\xe7\x3b\xe0\x28\x74\x7b\xc2" .
5072       "\x86\x33\x13\xeb\x5a\x4f\xcb\x5c\x08\x0a\x73\x37\x0e\x5d\x1c\x2f" .
5073       "\x33\x8f\xe6\xe5\xf8\x9b\xae\xdd\x16\xf2\x4b\x8d\x2c\xe1\xd4\xdc" .
5074       "\xb0\xcb\xdf\x9d\xd4\x70\x6d\x17\xf9\x4d\x42\x3f\x9b\x1b\x11\x94" .
5075       "\x9f\x5b\xc1\x9b\x06\x05\x9d\x03\x9d\x5e\x13\x8a\x1e\x9a\x6a\xe8" .
5076       "\xd9\x7c\x14\x17\x58\xc7\x2a\xf6\xa1\x99\x63\x0a\xd7\xfd\x70\xc3" .
5077       "\xf6\x5e\x74\x13\x03\xc9\x0b\x04\x26\x98\xf7\x26\x8a\x92\x93\x25" .
5078       "\xb0\xa2\x0d\x23\xed\x63\x79\x6d\x13\x32\xfa\x3c\x35\x02\x9a\xa3" .
5079       "\xb3\xdd\x8e\x0a\x24\xbf\x51\xc3\x7c\xcd\x55\x9f\x37\xaf\x94\x4c" .
5080       "\x29\x08\x52\x82\xb2\x3b\x4e\x37\x9f\x17\x07\x91\x11\x3b\xfd\xcd";
5081
5082     $salt_buf = uc $salt_buf;
5083
5084     my $digest = sha1 ($word_buf . $salt_buf);
5085
5086     my ($a, $b, $c, $d, $e) = unpack ("I*", $digest);
5087
5088     my $lengthMagicArray = 0x20;
5089     my $offsetMagicArray = 0;
5090
5091     $lengthMagicArray += (($a >>  0) & 0xff) % 6;
5092     $lengthMagicArray += (($a >>  8) & 0xff) % 6;
5093     $lengthMagicArray += (($a >> 16) & 0xff) % 6;
5094     $lengthMagicArray += (($a >> 24) & 0xff) % 6;
5095     $lengthMagicArray += (($b >>  0) & 0xff) % 6;
5096     $lengthMagicArray += (($b >>  8) & 0xff) % 6;
5097     $lengthMagicArray += (($b >> 16) & 0xff) % 6;
5098     $lengthMagicArray += (($b >> 24) & 0xff) % 6;
5099     $lengthMagicArray += (($c >>  0) & 0xff) % 6;
5100     $lengthMagicArray += (($c >>  8) & 0xff) % 6;
5101     $offsetMagicArray += (($c >> 16) & 0xff) % 8;
5102     $offsetMagicArray += (($c >> 24) & 0xff) % 8;
5103     $offsetMagicArray += (($d >>  0) & 0xff) % 8;
5104     $offsetMagicArray += (($d >>  8) & 0xff) % 8;
5105     $offsetMagicArray += (($d >> 16) & 0xff) % 8;
5106     $offsetMagicArray += (($d >> 24) & 0xff) % 8;
5107     $offsetMagicArray += (($e >>  0) & 0xff) % 8;
5108     $offsetMagicArray += (($e >>  8) & 0xff) % 8;
5109     $offsetMagicArray += (($e >> 16) & 0xff) % 8;
5110     $offsetMagicArray += (($e >> 24) & 0xff) % 8;
5111
5112     my $hash_buf = sha1_hex ($word_buf . substr ($theMagicArray_s, $offsetMagicArray, $lengthMagicArray) . $salt_buf);
5113
5114     $tmp_hash = sprintf ("%s\$%s", $salt_buf, uc $hash_buf);
5115   }
5116   elsif ($mode == 7900)
5117   {
5118     my $cost = 14;
5119
5120     if (length ($iter))
5121     {
5122       $cost = $iter;
5123     }
5124
5125     my $phpass_it = 1 << $cost;
5126
5127     $hash_buf = sha512 ($salt_buf . $word_buf);
5128
5129     for (my $i = 0; $i < $phpass_it; $i++)
5130     {
5131       $hash_buf = sha512 ($hash_buf . $word_buf);
5132     }
5133
5134     my $base64_buf = substr (Authen::Passphrase::PHPass::_en_base64 ($hash_buf), 0, 43);
5135
5136     my $base64_digits = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
5137
5138     my $cost_str = substr ($base64_digits , $cost, 1);
5139
5140     $tmp_hash = sprintf ('$S$%s%s%s', $cost_str, $salt_buf, $base64_buf);
5141   }
5142   elsif ($mode == 8000)
5143   {
5144     my $salt_buf_bin = pack ("H*", $salt_buf);
5145
5146     my $word_buf_utf = encode ("UTF-16BE", $word_buf);
5147
5148     $hash_buf = sha256_hex ($word_buf_utf . "\x00" x (510 - (length ($word_buf) * 2)) . $salt_buf_bin);
5149
5150     $tmp_hash = sprintf ("0xc007%s%s", $salt_buf, $hash_buf);
5151   }
5152   elsif ($mode == 8100)
5153   {
5154     $hash_buf = sha1_hex ($salt_buf . $word_buf . "\x00");
5155
5156     $tmp_hash = sprintf ("1%s%s", $salt_buf, $hash_buf);
5157   }
5158   elsif ($mode == 8200)
5159   {
5160     my $iterations = 40000;
5161
5162     if (defined ($iter))
5163     {
5164       $iterations = $iter;
5165     }
5166
5167     my $salt_hex = substr ($salt_buf, 0, 32);
5168     my $salt     = pack   ("H*", $salt_hex);
5169
5170     my $data_hex = substr ($salt_buf, 32);
5171     my $data     = pack   ("H*", $data_hex);
5172
5173     my $pbkdf2 = Crypt::PBKDF2->new
5174     (
5175       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
5176       iterations => int $iterations
5177     );
5178
5179     my $key = $pbkdf2->PBKDF2 ($salt, $word_buf);
5180
5181     $hash_buf = hmac_hex ($data, substr ($key, 32, 32), \&sha256, 64);
5182
5183     $tmp_hash = sprintf ("%s:%s:%d:%s", $hash_buf, $salt_hex, $iterations, $data_hex);
5184   }
5185   elsif ($mode == 8300)
5186   {
5187     my ($domain, $salt_hex) = split (":", $salt_buf);
5188
5189     my $hashalg = Net::DNS::SEC->digtype ("SHA1");
5190
5191     my $salt = pack ("H*", $salt_hex);
5192
5193     my $iterations = 1;
5194
5195     if (defined ($iter))
5196     {
5197       $iterations = $iter;
5198     }
5199
5200     my $name = lc ($word_buf . $domain);
5201
5202     my $hash_buf = Net::DNS::RR::NSEC3::name2hash ($hashalg, $name, $iterations, $salt);
5203
5204     $tmp_hash = sprintf ("%s:%s:%s:%d", $hash_buf, $domain, $salt_hex, $iterations);
5205   }
5206   elsif ($mode == 8400)
5207   {
5208     $hash_buf = sha1_hex ($salt_buf . sha1_hex ($salt_buf . sha1_hex ($word_buf)));
5209
5210     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
5211   }
5212   elsif ($mode == 8500)
5213   {
5214     $hash_buf = racf_hash (uc $salt_buf, $word_buf);
5215
5216     $tmp_hash = sprintf ('$racf$*%s*%s', uc $salt_buf, uc $hash_buf);
5217   }
5218   elsif ($mode == 8600)
5219   {
5220     my @saved_key = map { ord $_; } split "", $word_buf;
5221
5222     my $len = scalar @saved_key;
5223
5224     my @state = domino_big_md (\@saved_key, $len);
5225
5226     $tmp_hash = sprintf ('%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x',
5227       $state[ 0],
5228       $state[ 1],
5229       $state[ 2],
5230       $state[ 3],
5231       $state[ 4],
5232       $state[ 5],
5233       $state[ 6],
5234       $state[ 7],
5235       $state[ 8],
5236       $state[ 9],
5237       $state[10],
5238       $state[11],
5239       $state[12],
5240       $state[13],
5241       $state[14],
5242       $state[15],
5243     );
5244   }
5245   elsif ($mode == 8700)
5246   {
5247     my $domino_char = undef;
5248
5249     if (defined ($additional_param))
5250     {
5251       $domino_char = $additional_param;
5252     }
5253
5254     my @saved_key = map { ord $_; } split "", $word_buf;
5255
5256     my $len = scalar @saved_key;
5257
5258     my @state = domino_big_md (\@saved_key, $len);
5259
5260     my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5261
5262     @saved_key = map { ord $_; } split "", $salt_buf . uc $str;
5263
5264     @state = domino_big_md (\@saved_key, 34);
5265
5266     $hash_buf = join ("", (map { chr $_; } @state));
5267
5268     $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_buf . $hash_buf, $domino_char));
5269   }
5270   elsif ($mode == 8900)
5271   {
5272     my $N = 1024;
5273     my $r = 1;
5274     my $p = 1;
5275
5276     if (defined ($additional_param))
5277     {
5278       $N = $additional_param;
5279       $r = $additional_param2;
5280       $p = $additional_param3;
5281     }
5282
5283     $hash_buf = scrypt_hash ($word_buf, $salt_buf, $N, $r, $p, 32);
5284
5285     $tmp_hash = sprintf ('%s', $hash_buf);
5286   }
5287   elsif ($mode == 9100)
5288   {
5289     my $iterations = 5000;
5290
5291     if (defined ($iter))
5292     {
5293       $iterations = $iter;
5294     }
5295
5296     my $domino_char = undef;
5297
5298     # domino 5 hash - SEC_pwddigest_V1 - -m 8600
5299
5300     my @saved_key = map { ord $_; } split "", $word_buf;
5301
5302     my $len = scalar @saved_key;
5303
5304     my @state = domino_big_md (\@saved_key, $len);
5305
5306
5307     # domino 6 hash - SEC_pwddigest_V2 - -m 8700
5308
5309     my $salt_part = substr ($salt_buf, 0, 5);
5310
5311     my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")";
5312
5313     @saved_key = map { ord $_; } split "", $salt_part . uc $str;
5314
5315     @state = domino_big_md (\@saved_key, 34);
5316
5317     $hash_buf = join ("", (map { chr $_; } @state));
5318
5319     $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_part . $hash_buf, $domino_char));
5320
5321
5322     # domino 8(.5.x) hash - SEC_pwddigest_V3 - -m 9100
5323
5324     my $pbkdf2 = Crypt::PBKDF2->new
5325     (
5326       hash_class => 'HMACSHA1',
5327       iterations => $iterations,
5328       output_len =>  8,
5329       salt_len   => 16,
5330     );
5331
5332     my $chars = "02";
5333
5334     if (defined ($additional_param))
5335     {
5336       $chars = $additional_param;
5337     }
5338
5339     my $digest_new = $pbkdf2->PBKDF2 ($salt_buf, $tmp_hash);
5340
5341     my $iteration_str = "" . $iterations;
5342
5343     for (my $i = length ($iterations); $i < 10; $i++)
5344     {
5345       $iterations = "0" . $iterations;
5346     }
5347
5348     $tmp_hash = sprintf ('(H%s)', domino_85x_encode ($salt_buf . $iterations . $chars . $digest_new, $domino_char));
5349   }
5350   elsif ($mode == 9200)
5351   {
5352     my $iterations = 20000;
5353
5354     my $pbkdf2 = Crypt::PBKDF2->new
5355     (
5356       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
5357       iterations => $iterations
5358     );
5359
5360     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5361
5362     $tmp_hash = "";
5363
5364     for (my $i = 0; $i < 43; $i++)
5365     {
5366       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5367     }
5368
5369     $tmp_hash = sprintf ("\$8\$%s\$%s", $salt_buf, $tmp_hash);
5370   }
5371   elsif ($mode == 9300)
5372   {
5373     my $N = 16384;
5374     my $r = 1;
5375     my $p = 1;
5376
5377     $hash_buf = scrypt_b64 ($word_buf, $salt_buf, $N, $r, $p, 32);
5378
5379     $tmp_hash = "";
5380
5381     for (my $i = 0; $i < 43; $i++)
5382     {
5383       $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)};
5384     }
5385
5386     $tmp_hash = sprintf ('$9$%s$%s', $salt_buf, $tmp_hash);
5387   }
5388   elsif ($mode == 9400)
5389   {
5390     my $iterations = 50000;
5391
5392     if (length ($iter))
5393     {
5394       $iterations = int ($iter);
5395     }
5396
5397     my $aes_key_size = 128; # or 256
5398
5399     if (defined ($additional_param2))
5400     {
5401       $aes_key_size = $additional_param2;
5402     }
5403
5404     $salt_buf = pack ("H*", $salt_buf);
5405
5406     my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
5407
5408     for (my $i = 0; $i < $iterations; $i++)
5409     {
5410       my $num32 = pack ("L", $i);
5411
5412       $tmp = sha1 ($num32 . $tmp);
5413     }
5414
5415     my $zero32    = pack ("L", 0x00);
5416
5417     my $derivation_array1 = pack ("C", 0x36) x 64;
5418     my $derivation_array2 = pack ("C", 0x5C) x 64;
5419
5420     $tmp = sha1 ($tmp . $zero32);
5421
5422     my $tmp2 = sha1 ($derivation_array1 ^ $tmp);
5423     my $tmp3 = sha1 ($derivation_array2 ^ $tmp);
5424
5425     my $key = substr ($tmp2 . $tmp3, 0, $aes_key_size / 8);
5426
5427     my $m = Crypt::Mode::ECB->new ('AES', 0);
5428
5429     my $encdata;
5430
5431     if (defined $additional_param)
5432     {
5433       $encdata = $m->decrypt (pack ("H*", $additional_param), $key);
5434     }
5435     else
5436     {
5437       $encdata = "A" x 16; ## can be anything
5438     }
5439
5440     my $data1_buf = $encdata;
5441     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5442
5443     $data1_buf = substr ($data1_buf . ("\x00" x 16), 0, 16);
5444     $data2_buf = substr ($data2_buf . ("\x00" x 16), 0, 32);
5445
5446     my $encrypted1 = unpack ("H*", $m->encrypt ($data1_buf, $key));
5447     my $encrypted2 = unpack ("H*", $m->encrypt ($data2_buf, $key));
5448
5449     $encrypted1 = substr ($encrypted1, 0, 32);
5450     $encrypted2 = substr ($encrypted2, 0, 40);
5451
5452     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2007, 20, $aes_key_size, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5453   }
5454   elsif ($mode == 9500)
5455   {
5456     my $iterations = 100000;
5457
5458     if (length ($iter))
5459     {
5460       $iterations = int ($iter);
5461     }
5462
5463     $salt_buf = pack ("H*", $salt_buf);
5464
5465     my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf));
5466
5467     for (my $i = 0; $i < $iterations; $i++)
5468     {
5469       my $num32 = pack ("L", $i);
5470
5471       $tmp = sha1 ($num32 . $tmp);
5472     }
5473
5474     my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5475     my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5476
5477     my $final1 = sha1 ($tmp . $encryptedVerifierHashInputBlockKey);
5478     my $final2 = sha1 ($tmp . $encryptedVerifierHashValueBlockKey);
5479
5480     my $key1 = substr ($final1, 0, 16);
5481     my $key2 = substr ($final2, 0, 16);
5482
5483     my $cipher1 = Crypt::CBC->new ({
5484       key         => $key1,
5485       cipher      => "Crypt::Rijndael",
5486       iv          => $salt_buf,
5487       literal_key => 1,
5488       header      => "none",
5489       keysize     => 16,
5490       padding     => "null",
5491     });
5492
5493     my $cipher2 = Crypt::CBC->new ({
5494       key         => $key2,
5495       cipher      => "Crypt::Rijndael",
5496       iv          => $salt_buf,
5497       literal_key => 1,
5498       header      => "none",
5499       keysize     => 16,
5500       padding     => "null",
5501     });
5502
5503     my $encdata;
5504
5505     if (defined $additional_param)
5506     {
5507       $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5508     }
5509     else
5510     {
5511       $encdata = "A" x 16; ## can be anything
5512     }
5513
5514     my $data1_buf = $encdata;
5515     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5516
5517     my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5518     my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5519
5520     $encrypted2 = substr ($encrypted2, 0, 64);
5521
5522     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2010, 100000, 128, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5523   }
5524   elsif ($mode == 9600)
5525   {
5526     my $iterations = 100000;
5527
5528     if (length ($iter))
5529     {
5530       $iterations = int ($iter);
5531     }
5532
5533     $salt_buf = pack ("H*", $salt_buf);
5534
5535     my $tmp = sha512 ($salt_buf . encode ("UTF-16LE", $word_buf));
5536
5537     for (my $i = 0; $i < $iterations; $i++)
5538     {
5539       my $num32 = pack ("L", $i);
5540
5541       $tmp = sha512 ($num32 . $tmp);
5542     }
5543
5544     my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79";
5545     my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e";
5546
5547     my $final1 = sha512 ($tmp . $encryptedVerifierHashInputBlockKey);
5548     my $final2 = sha512 ($tmp . $encryptedVerifierHashValueBlockKey);
5549
5550     my $key1 = substr ($final1, 0, 32);
5551     my $key2 = substr ($final2, 0, 32);
5552
5553     my $cipher1 = Crypt::CBC->new ({
5554       key         => $key1,
5555       cipher      => "Crypt::Rijndael",
5556       iv          => $salt_buf,
5557       literal_key => 1,
5558       header      => "none",
5559       keysize     => 32,
5560       padding     => "null",
5561     });
5562
5563     my $cipher2 = Crypt::CBC->new ({
5564       key         => $key2,
5565       cipher      => "Crypt::Rijndael",
5566       iv          => $salt_buf,
5567       literal_key => 1,
5568       header      => "none",
5569       keysize     => 32,
5570       padding     => "null",
5571     });
5572
5573     my $encdata;
5574
5575     if (defined $additional_param)
5576     {
5577       $encdata = $cipher1->decrypt (pack ("H*", $additional_param));
5578     }
5579     else
5580     {
5581       $encdata = "A" x 16; ## can be anything
5582     }
5583
5584     my $data1_buf = $encdata;
5585     my $data2_buf = sha512 (substr ($data1_buf, 0, 16));
5586
5587     my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf));
5588     my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf));
5589
5590     $encrypted2 = substr ($encrypted2, 0, 64);
5591
5592     $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2013, 100000, 256, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2);
5593   }
5594   elsif ($mode == 9700)
5595   {
5596     $salt_buf = pack ("H*", $salt_buf);
5597
5598     my $tmp = md5 (encode ("UTF-16LE", $word_buf));
5599
5600     $tmp = substr ($tmp, 0, 5);
5601
5602     my $data;
5603
5604     for (my $i = 0; $i < 16; $i++)
5605     {
5606       $data .= $tmp;
5607       $data .= $salt_buf;
5608     }
5609
5610     $tmp = md5 ($data);
5611
5612     $tmp = substr ($tmp, 0, 5);
5613
5614     my $version;
5615
5616     if (defined $additional_param2)
5617     {
5618       $version = $additional_param2;
5619     }
5620     else
5621     {
5622       $version = (unpack ("L", $tmp) & 1) ? 0 : 1;
5623     }
5624
5625     my $rc4_key = md5 ($tmp . "\x00\x00\x00\x00");
5626
5627     my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5628
5629     my $encdata;
5630
5631     if (defined $additional_param)
5632     {
5633       $encdata = $m->RC4 (pack ("H*", $additional_param));
5634     }
5635     else
5636     {
5637       $encdata = "A" x 16; ## can be anything
5638     }
5639
5640     my $data1_buf = $encdata;
5641     my $data2_buf = md5 (substr ($data1_buf, 0, 16));
5642
5643     $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5644
5645     my $encrypted1 = $m->RC4 ($data1_buf);
5646     my $encrypted2 = $m->RC4 ($data2_buf);
5647
5648     $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5649   }
5650   elsif ($mode == 9800)
5651   {
5652     $salt_buf = pack ("H*", $salt_buf);
5653
5654     my $tmp = sha1 ($salt_buf. encode ("UTF-16LE", $word_buf));
5655
5656     my $version;
5657
5658     if (defined $additional_param2)
5659     {
5660       $version = $additional_param2;
5661     }
5662     else
5663     {
5664       $version = (unpack ("L", $tmp) & 1) ? 3 : 4;
5665     }
5666
5667     my $rc4_key = sha1 ($tmp . "\x00\x00\x00\x00");
5668
5669     if ($version == 3)
5670     {
5671       $rc4_key = substr ($rc4_key, 0, 5) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
5672     }
5673
5674     my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5675
5676     my $encdata;
5677
5678     if (defined $additional_param)
5679     {
5680       $encdata = $m->RC4 (pack ("H*", $additional_param));
5681     }
5682     else
5683     {
5684       $encdata = "A" x 16; ## can be anything
5685     }
5686
5687     my $data1_buf = $encdata;
5688     my $data2_buf = sha1 (substr ($data1_buf, 0, 16));
5689
5690     $m = Crypt::RC4->new (substr ($rc4_key, 0, 16));
5691
5692     my $encrypted1 = $m->RC4 ($data1_buf);
5693     my $encrypted2 = $m->RC4 ($data2_buf);
5694
5695     $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2));
5696   }
5697   elsif ($mode == 9900)
5698   {
5699     $tmp_hash = sprintf ("%s", md5_hex ($word_buf . "\0" x (100 - length ($word_buf))));
5700   }
5701   elsif ($mode == 10000)
5702   {
5703     my $iterations = 10000;
5704
5705     if (length ($iter))
5706     {
5707       $iterations = int ($iter);
5708     }
5709
5710     my $pbkdf2 = Crypt::PBKDF2->new
5711     (
5712       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
5713       iterations => $iterations
5714     );
5715
5716     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
5717     $hash_buf =~ s/[\r\n]//g;
5718
5719     $tmp_hash = sprintf ("pbkdf2_sha256\$%i\$%s\$%s", $iterations, $salt_buf, $hash_buf);
5720   }
5721   elsif ($mode == 10100)
5722   {
5723     my $seed = pack ("H*", $salt_buf);
5724
5725     my ($hi, $lo) = siphash ($word_buf, $seed);
5726
5727     my $hi_s = sprintf ("%08x", $hi);
5728     my $lo_s = sprintf ("%08x", $lo);
5729
5730     $hi_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5731     $lo_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/;
5732
5733     $tmp_hash = sprintf ("%s%s:2:4:%s", $hi_s, $lo_s, $salt_buf);
5734   }
5735   elsif ($mode == 10200)
5736   {
5737     my $challengeb64 = encode_base64 ($salt_buf);
5738     $challengeb64 =~ s/[\r\n]//g;
5739
5740     my $username;
5741
5742     if (defined $additional_param)
5743     {
5744       $username = $additional_param;
5745     }
5746     else
5747     {
5748       $username = "user";
5749     }
5750
5751     $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5);
5752
5753     my $responseb64 = encode_base64 ($username . " " . $hash_buf);
5754     $responseb64 =~ s/[\r\n]//g;
5755
5756     $tmp_hash = sprintf ('$cram_md5$%s$%s', $challengeb64, $responseb64);
5757   }
5758   elsif ($mode == 10300)
5759   {
5760     my $iterations = 1024;
5761
5762     if (length ($iter))
5763     {
5764       $iterations = int ($iter);
5765     }
5766
5767     my $hash_buf = $salt_buf;
5768
5769     for (my $pos = 0; $pos < $iterations; $pos++)
5770     {
5771       $hash_buf = sha1 ($word_buf . $hash_buf);
5772     }
5773
5774     $hash_buf = encode_base64 ($hash_buf . $salt_buf);
5775     $hash_buf =~ s/[\r\n]//g;
5776
5777     $tmp_hash = sprintf ("{x-issha, %i}%s", $iterations, $hash_buf);
5778   }
5779   elsif ($mode == 10400)
5780   {
5781     my $id  = $salt_buf;
5782     my $u   = $additional_param;
5783     my $o   = $additional_param2;
5784     my $P   = $additional_param3;
5785
5786     if (defined $u == 0)
5787     {
5788       $u = "0" x 64;
5789     }
5790
5791     if (defined $o == 0)
5792     {
5793       $o = "0" x 64;
5794     }
5795
5796     if (defined $P == 0)
5797     {
5798       $P = -1;
5799     }
5800
5801     my $padding;
5802
5803     for (my $i = 0; $i < 32; $i++)
5804     {
5805       $padding .= pack ("C", $pdf_padding[$i]);
5806     }
5807
5808     my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, 1, 2, 0);
5809
5810     my $m = Crypt::RC4->new (substr ($res, 0, 5));
5811
5812     $u = $m->RC4 ($padding);
5813
5814     $tmp_hash = sprintf ('$pdf$%d*%d*40*%d*%d*16*%s*32*%s*32*%s', 1, 2, $P, 0, $id, unpack ("H*", $u), $o);
5815   }
5816   elsif ($mode == 10500)
5817   {
5818     my $id  = $salt_buf;
5819     my $u   = $additional_param;
5820     my $o   = $additional_param2;
5821     my $P   = $additional_param3;
5822     my $V   = $additional_param4;
5823     my $R   = $additional_param5;
5824     my $enc = $additional_param6;
5825
5826     if (defined $u == 0)
5827     {
5828       $u = "0" x 64;
5829     }
5830
5831     my $u_save = $u;
5832
5833     if (defined $o == 0)
5834     {
5835       $o = "0" x 64;
5836     }
5837
5838     if (defined $R == 0)
5839     {
5840       $R = get_random_num (3, 5);
5841     }
5842
5843     if (defined $V == 0)
5844     {
5845       $V = ($R == 3) ? 2 : 4;
5846     }
5847
5848     if (defined $P == 0)
5849     {
5850       $P = ($R == 3) ? -4 : -1028;
5851     }
5852
5853     if (defined $enc == 0)
5854     {
5855       $enc = ($R == 3) ? 1 : get_random_num (0, 2);
5856     }
5857
5858     my $padding;
5859
5860     for (my $i = 0; $i < 32; $i++)
5861     {
5862       $padding .= pack ("C", $pdf_padding[$i]);
5863     }
5864
5865     my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, $V, $R, $enc);
5866
5867     my $digest = md5 ($padding . pack ("H*", $id));
5868
5869     my $m = Crypt::RC4->new ($res);
5870
5871     $u = $m->RC4 ($digest);
5872
5873     my @ress = split "", $res;
5874
5875     for (my $x = 1; $x <= 19; $x++)
5876     {
5877       my @xor;
5878
5879       for (my $i = 0; $i < 16; $i++)
5880       {
5881         $xor[$i] = chr (ord ($ress[$i]) ^ $x);
5882       }
5883
5884       my $s = join ("", @xor);
5885
5886       my $m2 = Crypt::RC4->new ($s);
5887
5888       $u = $m2->RC4 ($u);
5889     }
5890
5891     $u .= substr (pack ("H*", $u_save), 16, 16);
5892
5893     $tmp_hash = sprintf ('$pdf$%d*%d*128*%d*%d*16*%s*32*%s*32*%s', $V, $R, $P, $enc, $id, unpack ("H*", $u), $o);
5894   }
5895   elsif ($mode == 10600)
5896   {
5897     my $id   = $salt_buf;
5898     my $rest = $additional_param;
5899
5900     if (defined $id == 0)
5901     {
5902       $id = "0" x 32;
5903     }
5904
5905     if (defined $rest == 0)
5906     {
5907       $rest = "127*";
5908       $rest .= "0" x 64;
5909       $rest .= $id;
5910       $rest .= "0" x 158;
5911       $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
5912     }
5913
5914     my @data = split /\*/, $rest;
5915
5916     my $u = pack ("H*", $data[1]);
5917
5918     my $h = sha256 ($word_buf . substr ($u, 32, 8));
5919
5920     $data[1] = unpack ("H*", $h . substr ($u, 32));
5921
5922     $rest = join ("*", @data);
5923
5924     $tmp_hash = sprintf ('$pdf$5*5*256*-1028*1*16*%s*%s', $id, $rest);
5925   }
5926   elsif ($mode == 10700)
5927   {
5928     my $id   = $salt_buf;
5929     my $rest = $additional_param;
5930
5931     if (defined $id == 0)
5932     {
5933       $id = "0" x 32;
5934     }
5935
5936     if (defined $rest == 0)
5937     {
5938       $rest = "127*";
5939       $rest .= "0" x 64;
5940       $rest .= $id;
5941       $rest .= "0" x 158;
5942       $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000";
5943     }
5944
5945     my @datax = split /\*/, $rest;
5946
5947     my $u = pack ("H*", $datax[1]);
5948
5949     my $block = sha256 ($word_buf . substr ($u, 32, 8));
5950
5951     my $block_size = 32;
5952
5953     my $data = 0x00 x 64;
5954
5955     my $data_len = 1;
5956
5957     my $data63 = 0;
5958
5959     for (my $i = 0; $i < 64 || $i < $data63 + 32; $i++)
5960     {
5961       $data = $word_buf . $block;
5962
5963       $data_len = length ($data);
5964
5965       for (my $k = 1; $k < 64; $k++)
5966       {
5967         $data .= $word_buf . $block;
5968       }
5969
5970       my $aes = Crypt::CBC->new ({
5971         key         => substr ($block,  0, 16),
5972         cipher      => "Crypt::Rijndael",
5973         iv          => substr ($block, 16, 16),
5974         literal_key => 1,
5975         header      => "none",
5976         keysize     => 16,
5977         padding     => "null",
5978       });
5979
5980       my $data = $aes->encrypt ($data);
5981
5982       my $sum = 0;
5983
5984       for (my $j = 0; $j < 16; $j++)
5985       {
5986         $sum += ord (substr ($data, $j, 1));
5987       }
5988
5989       $block_size = 32 + ($sum % 3) * 16;
5990
5991       if ($block_size == 32)
5992       {
5993         $block = sha256 (substr ($data, 0, $data_len * 64));
5994       }
5995       elsif ($block_size == 48)
5996       {
5997         $block = sha384 (substr ($data, 0, $data_len * 64));
5998       }
5999       elsif ($block_size == 64)
6000       {
6001         $block = sha512 (substr ($data, 0, $data_len * 64));
6002       }
6003
6004       $data63 = ord (substr ($data, $data_len * 64 - 1, 1));
6005     }
6006
6007     $datax[1] = unpack ("H*", substr ($block, 0, 32) . substr ($u, 32));
6008
6009     $rest = join ("*", @datax);
6010
6011     $tmp_hash = sprintf ('$pdf$5*6*256*-1028*1*16*%s*%s', $id, $rest);
6012   }
6013   elsif ($mode == 10800)
6014   {
6015     $hash_buf = sha384_hex ($word_buf);
6016
6017     $tmp_hash = sprintf ("%s", $hash_buf);
6018   }
6019   elsif ($mode == 10900)
6020   {
6021     my $iterations = 1000;
6022
6023     if (length ($iter))
6024     {
6025       $iterations = int ($iter);
6026     }
6027
6028     my $out_len = 24;
6029
6030     if (defined $additional_param)
6031     {
6032       $out_len = $additional_param;
6033     }
6034
6035     my $pbkdf2 = Crypt::PBKDF2->new
6036     (
6037       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6038       iterations => $iterations,
6039       output_len => $out_len
6040     );
6041
6042     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6043     $hash_buf =~ s/[\r\n]//g;
6044
6045     my $base64_salt_buf = encode_base64 ($salt_buf);
6046
6047     chomp ($base64_salt_buf);
6048
6049     $tmp_hash = sprintf ("sha256:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6050   }
6051   elsif ($mode == 11000)
6052   {
6053     $hash_buf = md5_hex ($salt_buf . $word_buf);
6054
6055     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
6056   }
6057   elsif ($mode == 11100)
6058   {
6059     my $user = "postgres";
6060
6061     if (defined $additional_param)
6062     {
6063       $user = $additional_param;
6064     }
6065
6066     $hash_buf = md5_hex (md5_hex ($word_buf . $user) . pack ("H*", $salt_buf));
6067
6068     $tmp_hash = sprintf ("\$postgres\$%s*%s*%s", $user, $salt_buf, $hash_buf);
6069   }
6070   elsif ($mode == 11200)
6071   {
6072     my $sha1_pass   = sha1 ($word_buf);
6073     my $double_sha1 = sha1 ($sha1_pass);
6074
6075     my $xor_part1 = $sha1_pass;
6076     my $xor_part2 = sha1 (pack ("H*", $salt_buf) . $double_sha1);
6077
6078     my $hash_buf = "";
6079
6080     for (my $i = 0; $i < 20; $i++)
6081     {
6082       my $first_byte  = substr ($xor_part1, $i, 1);
6083       my $second_byte = substr ($xor_part2, $i, 1);
6084
6085       my $xor_result = $first_byte ^ $second_byte;
6086
6087       $hash_buf .= unpack ("H*", $xor_result);
6088     }
6089
6090     $tmp_hash = sprintf ("\$mysqlna\$%s*%s", $salt_buf, $hash_buf);
6091   }
6092   elsif ($mode == 11300)
6093   {
6094     my $ckey_buf = get_random_string (96);
6095
6096     if (length ($additional_param))
6097     {
6098       $ckey_buf = $additional_param;
6099     }
6100
6101     my $public_key_buf = get_random_string (66);
6102
6103     if (length ($additional_param2))
6104     {
6105       $public_key_buf = $additional_param2;
6106     }
6107
6108     my $salt_iter = get_random_num (150000, 250000);
6109
6110     if (length ($iter))
6111     {
6112       $salt_iter = int ($iter);
6113     }
6114
6115     my $hash_buf = sha512 ($word_buf . pack ("H*", $salt_buf));
6116
6117     for (my $i = 1; $i < $salt_iter; $i++)
6118     {
6119       $hash_buf = sha512 ($hash_buf);
6120     }
6121
6122     my $data = get_random_string (32);
6123
6124     my $aes = Crypt::CBC->new ({
6125       key         => substr ($hash_buf,  0, 32),
6126       cipher      => "Crypt::Rijndael",
6127       iv          => substr ($hash_buf, 32, 16),
6128       literal_key => 1,
6129       header      => "none",
6130       keysize     => 32,
6131       padding     => "standard",
6132     });
6133
6134     my $cry_master_buf = (unpack ("H*", $aes->encrypt ($data)));
6135
6136     $tmp_hash = sprintf ('$bitcoin$%d$%s$%d$%s$%d$%d$%s$%d$%s',
6137       length ($cry_master_buf),
6138       $cry_master_buf,
6139       length ($salt_buf),
6140       $salt_buf,
6141       $salt_iter,
6142       length ($ckey_buf),
6143       $ckey_buf,
6144       length ($public_key_buf),
6145       $public_key_buf);
6146   }
6147   elsif ($mode == 11400)
6148   {
6149     my ($directive, $URI_server, $URI_client, $user, $realm, $nonce, $nonce_count, $nonce_client, $qop, $method, $URI, $URI_prefix, $URI_resource, $URI_suffix);
6150
6151     $directive = "MD5"; # only directive currently supported
6152
6153     if (defined ($additional_param))
6154     {
6155       $user   = $additional_param;
6156       $realm  = $additional_param2;
6157       $nonce  = $salt_buf;
6158       $nonce_count  = $additional_param3;
6159       $nonce_client = $additional_param4;
6160       $qop = $additional_param5;
6161       $method = $additional_param6;
6162
6163       $URI_prefix   = $additional_param7;
6164       $URI_resource = $additional_param8;
6165       $URI_suffix   = $additional_param9;
6166
6167       # not needed information
6168
6169       $URI_server = $additional_param10;
6170       $URI_client = $additional_param11;
6171     }
6172     else
6173     {
6174       $user   = get_random_string (get_random_num (0, 12 + 1));
6175
6176       # special limit: (user_len + 1 + realm_len + 1 + word_buf_len) < 56
6177       my $realm_max_len = 55 - length ($user) - 1 - length ($word_buf) - 1;
6178
6179       if ($realm_max_len < 1) # should never happen
6180       {
6181         $realm_max_len = 1;
6182       }
6183
6184       $realm_max_len = min (20, $realm_max_len);
6185
6186       $realm  = get_random_string (get_random_num (0, $realm_max_len + 1));
6187
6188       $nonce  = $salt_buf;
6189
6190       if (get_random_num (0, 1 + 1) == 1)
6191       {
6192         $qop = "auth";
6193
6194         $nonce_count  = get_random_string (get_random_num (0, 10 + 1));
6195         $nonce_client = get_random_string (get_random_num (0, 12 + 1));
6196       }
6197       else
6198       {
6199         $qop = "";
6200
6201         $nonce_count  = "";
6202         $nonce_client = "";
6203       }
6204
6205       $method = get_random_string (get_random_num (0, 24 + 1));
6206
6207       $URI_prefix   = get_random_string (get_random_num (0, 10 + 1));
6208       $URI_resource = get_random_string (get_random_num (1, 32 + 1));
6209       $URI_suffix   = get_random_string (get_random_num (0, 32 + 1));
6210
6211       # not needed information
6212
6213       $URI_server = get_random_string (get_random_num (0, 32 + 1));
6214       $URI_client = $URI_resource; # simplification
6215     }
6216
6217     # start
6218
6219     $URI = "";
6220
6221     if (length ($URI_prefix) > 0)
6222     {
6223       $URI = $URI_prefix . ":";
6224     }
6225
6226     $URI .= $URI_resource;
6227
6228     if (length ($URI_suffix) > 0)
6229     {
6230       $URI .= ":" . $URI_suffix;
6231     }
6232
6233     my $HA2 = md5_hex ($method . ":" . $URI);
6234
6235     my $HA1 = md5_hex ($user . ":" . $realm . ":" . $word_buf);
6236
6237     my $tmp_buf;
6238
6239     if (($qop eq "auth") || ($qop eq "auth-int"))
6240     {
6241       $tmp_buf = $nonce . ":" . $nonce_count . ":" . $nonce_client . ":" . $qop;
6242     }
6243     else
6244     {
6245       $tmp_buf = $nonce;
6246     }
6247
6248     my $hash_buf = md5_hex ($HA1 . ":" . $tmp_buf . ":" . $HA2);
6249
6250     $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);
6251   }
6252   elsif ($mode == 11500)
6253   {
6254     $hash_buf = crc32 ($word_buf);
6255
6256     $tmp_hash = sprintf ("%08x:00000000", $hash_buf);
6257   }
6258   elsif ($mode == 11600)
6259   {
6260     my ($p, $num_cycle_power, $seven_zip_salt_len, $seven_zip_salt_buf, $salt_len, $data_len, $unpack_size, $data_buf);
6261
6262     $p = 0; # is fixed
6263
6264     my $validation_only = 0;
6265
6266     $validation_only = 1 if (defined ($additional_param));
6267
6268     if ($validation_only == 1)
6269     {
6270       $num_cycle_power = int ($iter);
6271       $seven_zip_salt_len = $additional_param;
6272       $seven_zip_salt_buf = $additional_param2;
6273       $salt_len = $additional_param3;
6274       # $salt_buf set in parser
6275       # $hash_buf (resulting crc)
6276       $data_len = $additional_param4;
6277       $unpack_size = $additional_param5;
6278       $data_buf = $additional_param6;
6279     }
6280     else
6281     {
6282       $num_cycle_power = 14; # by default it is 19
6283       $seven_zip_salt_len = 0;
6284       $seven_zip_salt_buf = "";
6285       $salt_len = length ($salt_buf);
6286       # $salt_buf set automatically
6287       # $hash_buf (resulting crc)
6288       # $data_len will be set when encrypting
6289       $unpack_size = get_random_num (1, 32 + 1);
6290       $data_buf = get_random_string ($unpack_size);
6291     }
6292
6293     #
6294     # 2 ^ NumCyclesPower "iterations" of SHA256 (only one final SHA256)
6295     #
6296
6297     $word_buf = encode ("UTF-16LE", $word_buf);
6298
6299     my $rounds = 1 << $num_cycle_power;
6300
6301     my $pass_buf = "";
6302
6303     for (my $i = 0; $i < $rounds; $i++)
6304     {
6305       my $num_buf = "";
6306
6307       $num_buf .= pack ("V", $i);
6308       $num_buf .= "\x00" x 4;
6309
6310       # this would be better but only works on 64-bit systems:
6311       # $num_buf = pack ("q", $i);
6312
6313       $pass_buf .= sprintf ("%s%s", $word_buf, $num_buf);
6314     }
6315
6316     my $key = sha256 ($pass_buf);
6317
6318     # the salt_buf is our IV for AES CBC
6319     # pad the salt_buf
6320
6321     my $salt_buf_len = length ($salt_buf);
6322     my $salt_padding_len = 0;
6323
6324     if ($salt_buf_len < 16)
6325     {
6326       $salt_padding_len = 16 - $salt_buf_len;
6327     }
6328
6329     $salt_buf .= "\x00" x $salt_padding_len;
6330
6331     my $aes = Crypt::CBC->new ({
6332       cipher      => "Crypt::Rijndael",
6333       key         => $key,
6334       keysize     => 32,
6335       literal_key => 1,
6336       iv          => $salt_buf,
6337       header      => "none",
6338     });
6339
6340     if ($validation_only == 1)
6341     {
6342       # decrypt
6343
6344       my $decrypted_data = $aes->decrypt ($data_buf);
6345
6346       $decrypted_data = substr ($decrypted_data, 0, $unpack_size);
6347
6348       $hash_buf = crc32 ($decrypted_data);
6349     }
6350     else
6351     {
6352       # encrypt
6353
6354       $hash_buf = crc32 ($data_buf);
6355
6356       $data_buf = $aes->encrypt ($data_buf);
6357
6358       $data_len = length ($data_buf);
6359     }
6360
6361     $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));
6362   }
6363   elsif ($mode == 11900)
6364   {
6365     my $iterations = 1000;
6366
6367     if (length ($iter))
6368     {
6369       $iterations = int ($iter);
6370     }
6371
6372     my $out_len = 32;
6373
6374     if (defined $additional_param)
6375     {
6376       $out_len = $additional_param;
6377     }
6378
6379     #
6380     # call PHP here - WTF
6381     #
6382
6383     # sanitize $word_buf and $salt_buf:
6384
6385     my $word_buf_base64 = encode_base64 ($word_buf);
6386     $word_buf_base64 =~ s/[\r\n]//g;
6387
6388     my $salt_buf_base64 = encode_base64 ($salt_buf);
6389     $salt_buf_base64 =~ s/[\r\n]//g;
6390
6391     # sanitize lenghs
6392
6393     $out_len = int ($out_len);
6394
6395     # output is in hex encoding, otherwise it could be screwed (but shouldn't)
6396
6397     my $php_code = <<'END_CODE';
6398
6399     function pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
6400     {
6401         $algorithm = strtolower ($algorithm);
6402
6403         if (! in_array ($algorithm, hash_algos (), true))
6404         {
6405           trigger_error ("PBKDF2 ERROR: Invalid hash algorithm.", E_USER_ERROR);
6406         }
6407
6408         if ($count <= 0 || $key_length <= 0)
6409         {
6410           trigger_error ("PBKDF2 ERROR: Invalid parameters.", E_USER_ERROR);
6411         }
6412
6413         if (function_exists ("hash_pbkdf2"))
6414         {
6415           if (!$raw_output)
6416           {
6417               $key_length = $key_length * 2;
6418           }
6419
6420           return hash_pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output);
6421         }
6422
6423         $hash_length = strlen (hash ($algorithm, "", true));
6424         $block_count = ceil ($key_length / $hash_length);
6425
6426         $output = "";
6427
6428         for ($i = 1; $i <= $block_count; $i++)
6429         {
6430           $last = $salt . pack ("N", $i);
6431
6432           $last = $xorsum = hash_hmac ($algorithm, $last, $password, true);
6433
6434           for ($j = 1; $j < $count; $j++)
6435           {
6436             $xorsum ^= ($last = hash_hmac ($algorithm, $last, $password, true));
6437           }
6438
6439           $output .= $xorsum;
6440         }
6441
6442         if ($raw_output)
6443         {
6444           return substr ($output, 0, $key_length);
6445         }
6446         else
6447         {
6448           return bin2hex (substr ($output, 0, $key_length));
6449         }
6450     }
6451
6452     print pbkdf2 ("md5", base64_decode ("$word_buf_base64"), base64_decode ("$salt_buf_base64"), $iterations, $out_len, False);
6453
6454 END_CODE
6455
6456     # replace with these command line arguments
6457
6458     $php_code =~ s/\$word_buf_base64/$word_buf_base64/;
6459     $php_code =~ s/\$salt_buf_base64/$salt_buf_base64/;
6460     $php_code =~ s/\$iterations/$iterations/;
6461     $php_code =~ s/\$out_len/$out_len/;
6462
6463     my $php_output = `php -r '$php_code'`;
6464
6465     $hash_buf = pack ("H*", $php_output);
6466
6467     $hash_buf = encode_base64 ($hash_buf);
6468     $hash_buf =~ s/[\r\n]//g;
6469
6470     my $base64_salt_buf = encode_base64 ($salt_buf);
6471
6472     chomp ($base64_salt_buf);
6473
6474     $tmp_hash = sprintf ("md5:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6475   }
6476   elsif ($mode == 12000)
6477   {
6478     my $iterations = 1000;
6479
6480     if (length ($iter))
6481     {
6482       $iterations = int ($iter);
6483     }
6484
6485     my $out_len = 16;
6486
6487     if (defined $additional_param)
6488     {
6489       $out_len = $additional_param;
6490     }
6491
6492     my $pbkdf2 = Crypt::PBKDF2->new
6493     (
6494       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'),
6495       iterations => $iterations,
6496       output_len => $out_len
6497     );
6498
6499     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6500     $hash_buf =~ s/[\r\n]//g;
6501
6502     my $base64_salt_buf = encode_base64 ($salt_buf);
6503
6504     chomp ($base64_salt_buf);
6505
6506     $tmp_hash = sprintf ("sha1:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6507   }
6508   elsif ($mode == 12100)
6509   {
6510     my $iterations = 1000;
6511
6512     if (length ($iter))
6513     {
6514       $iterations = int ($iter);
6515     }
6516
6517     my $out_len = 16;
6518
6519     if (defined $additional_param)
6520     {
6521       $out_len = $additional_param;
6522     }
6523
6524     my $pbkdf2 = Crypt::PBKDF2->new
6525     (
6526       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512),
6527       iterations => $iterations,
6528       output_len => $out_len
6529     );
6530
6531     $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf));
6532     $hash_buf =~ s/[\r\n]//g;
6533
6534     my $base64_salt_buf = encode_base64 ($salt_buf);
6535
6536     chomp ($base64_salt_buf);
6537
6538     $tmp_hash = sprintf ("sha512:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf);
6539   }
6540   elsif ($mode == 12200)
6541   {
6542     my $iterations = 65536;
6543
6544     my $default_salt = 0;
6545
6546     if (defined $additional_param)
6547     {
6548       $default_salt = int ($additional_param);
6549     }
6550
6551     if ($default_salt == 1)
6552     {
6553       $salt_buf = "0011223344556677";
6554     }
6555
6556     $hash_buf = sha512 (pack ("H*", $salt_buf) . $word_buf);
6557
6558     for (my $i = 0; $i < $iterations; $i++)
6559     {
6560       $hash_buf = sha512 ($hash_buf);
6561     }
6562
6563     $hash_buf = unpack ("H*", $hash_buf);
6564     $hash_buf = substr ($hash_buf, 0, 16);
6565
6566     if ($default_salt == 0)
6567     {
6568       $tmp_hash = sprintf ("\$ecryptfs\$0\$1\$%s\$%s", $salt_buf, $hash_buf);
6569     }
6570     else
6571     {
6572       $tmp_hash = sprintf ("\$ecryptfs\$0\$%s", $hash_buf);
6573     }
6574   }
6575   elsif ($mode == 12300)
6576   {
6577     my $iterations = 4096;
6578
6579     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
6580
6581     my $pbkdf2 = Crypt::PBKDF2->new (
6582       hasher       => $hasher,
6583       iterations   => $iterations,
6584       output_len   => 64
6585     );
6586
6587     my $salt_bin = pack ("H*", $salt_buf);
6588
6589     my $key = $pbkdf2->PBKDF2 ($salt_bin. "AUTH_PBKDF2_SPEEDY_KEY", $word_buf);
6590
6591     $hash_buf = sha512_hex ($key . $salt_bin);
6592
6593     $tmp_hash = sprintf ("%s%s", uc ($hash_buf), uc ($salt_buf));
6594   }
6595   elsif ($mode == 12400)
6596   {
6597     my $iterations;
6598
6599     if (length ($iter))
6600     {
6601       $iterations = int ($iter);
6602     }
6603     else
6604     {
6605       $iterations = get_random_num (1, 5001 + 1);
6606     }
6607
6608     my $key_value  = fold_password ($word_buf);
6609
6610     my $data = "\x00\x00\x00\x00\x00\x00\x00\x00";
6611     my $salt_value = base64_to_int24 ($salt_buf);
6612
6613     $hash_buf = crypt_rounds ($key_value, $iterations, $salt_value, $data);
6614
6615     $tmp_hash = sprintf ("_%s%s%s", int24_to_base64 ($iterations), $salt_buf, block_to_base64 ($hash_buf));
6616   }
6617   elsif ($mode == 12600)
6618   {
6619     $hash_buf = sha1_hex ($word_buf);
6620
6621     $hash_buf = sha256_hex ($salt_buf . uc $hash_buf);
6622
6623     $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf);
6624   }
6625   elsif ($mode == 12700)
6626   {
6627     my $iterations = 10;
6628
6629     my $data = qq|{
6630   "guid" : "00000000-0000-0000-0000-000000000000",
6631   "sharedKey" : "00000000-0000-0000-0000-000000000000",
6632   "options" : {"pbkdf2_iterations":10,"fee_policy":0,"html5_notifications":false,"logout_time":600000,"tx_display":0,"always_keep_local_backup":false}|;
6633
6634     my $salt_buf_bin = pack ("H*", $salt_buf);
6635
6636     my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
6637
6638     my $pbkdf2 = Crypt::PBKDF2->new (
6639       hasher       => $hasher,
6640       iterations   => $iterations,
6641       output_len   => 32
6642     );
6643
6644     my $key = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6645
6646     my $cipher = Crypt::CBC->new ({
6647       key         => $key,
6648       cipher      => "Crypt::Rijndael",
6649       iv          => $salt_buf_bin,
6650       literal_key => 1,
6651       header      => "none",
6652       keysize     => 32
6653     });
6654
6655     my $encrypted = unpack ("H*", $cipher->encrypt ($data));
6656
6657     $tmp_hash = sprintf ("\$blockchain\$%s\$%s", length ($salt_buf . $encrypted) / 2, $salt_buf . $encrypted);
6658   }
6659   elsif ($mode == 12800)
6660   {
6661     my $iterations = 100;
6662
6663     if (length ($iter))
6664     {
6665       $iterations = int ($iter);
6666     }
6667
6668     my $nt = md4_hex (encode ("UTF-16LE", $word_buf));
6669
6670     my $pbkdf2 = Crypt::PBKDF2->new
6671     (
6672       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6673       iterations => $iterations,
6674       output_len => 32
6675     );
6676
6677     my $salt_buf_bin = pack ("H*", $salt_buf);
6678
6679     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, uc (encode ("UTF-16LE", $nt)));
6680
6681     $tmp_hash = sprintf ("v1;PPH1_MD4,%s,%d,%s", $salt_buf, $iterations, unpack ("H*", $hash));
6682   }
6683   elsif ($mode == 12900)
6684   {
6685     my $iterations = 4096;
6686
6687     if (length ($iter))
6688     {
6689       $iterations = int ($iter);
6690     }
6691
6692     my $salt2 = $salt_buf . $salt_buf;
6693
6694     if (defined $additional_param)
6695     {
6696       $salt2 = $additional_param;
6697     }
6698
6699     my $pbkdf2 = Crypt::PBKDF2->new
6700     (
6701       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6702       iterations => $iterations,
6703       output_len => 32
6704     );
6705
6706     my $salt_buf_bin = pack ("H*", $salt_buf);
6707
6708     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6709
6710     my $salt2_bin = pack ("H*", $salt2);
6711
6712     my $hash_hmac = hmac_hex ($salt2_bin, $hash, \&sha256, 64);
6713
6714     $tmp_hash = sprintf ("%s%s%s", $salt2, $hash_hmac, $salt_buf);
6715   }
6716   elsif ($mode == 13000)
6717   {
6718     my $iterations = 15;
6719
6720     if (length ($iter))
6721     {
6722       $iterations = int ($iter);
6723     }
6724
6725     my $iv = "0" x 32;
6726
6727     if (defined $additional_param)
6728     {
6729       $iv = $additional_param;
6730     }
6731
6732     my $pbkdf2 = Crypt::PBKDF2->new
6733     (
6734       hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
6735       iterations => (1 << $iterations) + 32,
6736       output_len => 32
6737     );
6738
6739     my $salt_buf_bin = pack ("H*", $salt_buf);
6740
6741     my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf);
6742
6743     my $hash_final = substr ($hash,  0, 8)
6744                    ^ substr ($hash,  8, 8)
6745                    ^ substr ($hash, 16, 8)
6746                    ^ substr ($hash, 24, 8);
6747
6748     $tmp_hash = sprintf ('$rar5$16$%s$%d$%s$8$%s', $salt_buf, $iterations, $iv, unpack ("H*", $hash_final));
6749   }
6750   elsif ($mode == 13100)
6751   {
6752     my @salt_arr = split ('\$', $salt_buf);
6753
6754     my $user  = $salt_arr[0];
6755
6756     my $realm = $salt_arr[1];
6757
6758     my $spn   = $salt_arr[2];
6759
6760     my $nonce = $salt_arr[3];
6761
6762     my $cleartext_ticket = '6381b03081ada00703050050a00000a11b3019a003020117a1'.
6763     '12041058e0d77776e8b8e03991f2966939222aa2171b154d594b5242544553542e434f4e5'.
6764     '44f534f2e434f4da3133011a003020102a10a30081b067472616e6365a40b3009a0030201'.
6765     '01a1020400a511180f32303136303231353134343735305aa611180f32303136303231353'.
6766     '134343735305aa711180f32303136303231363030343735305aa811180f32303136303232'.
6767     '323134343735305a';
6768
6769     $cleartext_ticket = $nonce . $cleartext_ticket;
6770
6771     my $k = md4 (encode ("UTF-16LE", $word_buf));
6772
6773     my $k1 = hmac_md5 ("\x02\x00\x00\x00", $k);
6774
6775     my $checksum = hmac_md5 (pack ("H*", $cleartext_ticket), $k1);
6776
6777     my $k3 = hmac_md5 ($checksum, $k1);
6778
6779     my $cipher = Crypt::RC4->new ($k3);
6780
6781     my $edata2 = $cipher->RC4 (pack ("H*", $cleartext_ticket));
6782
6783     $tmp_hash = sprintf ('$krb5tgs$23$*%s$%s$%s*$%s$%s', $user, $realm, $spn, unpack ("H*", $checksum), unpack ("H*", $edata2));
6784   }
6785   elsif ($mode == 13200)
6786   {
6787     my @salt_arr = split ('\*', $salt_buf);
6788
6789     my $iteration  = $salt_arr[0];
6790
6791     my $mysalt = $salt_arr[1];
6792
6793     $mysalt = pack ("H*", $mysalt);
6794
6795     my $DEK = randbytes (16);
6796
6797     my $iv = "a6a6a6a6a6a6a6a6";
6798
6799     my $KEK = sha1($word_buf);
6800
6801     $KEK = substr ($KEK ^ $mysalt, 0, 16);
6802
6803     my $aes = Crypt::Mode::ECB->new ('AES');
6804
6805     my @R = ('', substr(pack ("H*",$DEK),0,8), substr(pack ("H*",$DEK),8,16));
6806
6807     my $B;
6808
6809     my $A = pack ("H*", $iv);
6810
6811     for (my $j = 0; $j < $iteration; $j++)
6812     {
6813       $B = $aes->encrypt ($A . $R[1], $KEK);
6814
6815       $A = substr ($B, 0, 8) ^ pack ("q", (2 * $j + 1));
6816
6817       $R[1] = substr ($B, 8, 16);
6818
6819       $B = $aes->encrypt ($A . $R[2], $KEK);
6820
6821       $A = substr ($B, 0, 8) ^ pack ("q", (2 * $j + 2));
6822
6823       $R[2] = substr ($B, 8, 16);
6824     }
6825
6826     my $wrapped_key = unpack ("H*", $A . substr ($R[1], 0 ,8) . substr ($R[2], 0 ,8));
6827
6828     $mysalt = unpack ("H*", $mysalt);
6829
6830     $tmp_hash = sprintf ('$axcrypt$*1*%s*%s*%s', $iteration, $mysalt, $wrapped_key);
6831   }
6832   elsif ($mode == 13300)
6833   {
6834     $hash_buf = sha1_hex ($word_buf);
6835
6836     $tmp_hash = sprintf ('$axcrypt_sha1$%s', substr ($hash_buf, 0, 32));
6837   }
6838
6839   return ($tmp_hash);
6840 }
6841
6842 sub rnd
6843 {
6844   my $mode = shift;
6845
6846   my $word_len = shift;
6847
6848   my $salt_len = shift;
6849
6850   my $max = $MAX_LEN;
6851
6852   $max = 15 if ($mode == 2410);
6853
6854   if ($is_unicode{$mode})
6855   {
6856     if (! $allow_long_salt{$mode})
6857     {
6858       $word_len = min ($word_len, int ($max / 2) - $salt_len);
6859     }
6860     else
6861     {
6862       $word_len = min ($word_len, int ($max / 2));
6863     }
6864   }
6865   elsif ($less_fifteen{$mode})
6866   {
6867     $word_len = min ($word_len, 15);
6868
6869     if ($mode == 2410)
6870     {
6871       $salt_len = min ($salt_len, 15 - $word_len);
6872     }
6873   }
6874   else
6875   {
6876     if (! $allow_long_salt{$mode})
6877     {
6878       $word_len = min ($word_len, $max - $salt_len);
6879     }
6880   }
6881
6882   if ($word_len < 1)
6883   {
6884     $word_len = 1;
6885   }
6886
6887   ##
6888   ## gen salt
6889   ##
6890
6891   my $salt_buf;
6892
6893   if ($mode == 4800)
6894   {
6895     my @salt_arr;
6896
6897     for (my $i = 0; $i < $salt_len; $i++)
6898     {
6899       my $c = get_random_chr (0x30, 0x39);
6900
6901       push (@salt_arr, $c);
6902     }
6903
6904     $salt_buf = join ("", @salt_arr);
6905
6906     $salt_buf = get_random_md5chap_salt ($salt_buf);
6907   }
6908   elsif ($mode == 5300 || $mode == 5400)
6909   {
6910     $salt_buf = get_random_ike_salt ();
6911   }
6912   elsif ($mode == 5500)
6913   {
6914     $salt_buf = get_random_netntlmv1_salt ($salt_len, $salt_len);
6915   }
6916   elsif ($mode == 5600)
6917   {
6918     $salt_buf = get_random_netntlmv2_salt ($salt_len, $salt_len);
6919   }
6920   elsif ($mode == 6600)
6921   {
6922     $salt_buf = get_random_agilekeychain_salt ();
6923   }
6924   elsif ($mode == 8200)
6925   {
6926     $salt_buf = get_random_cloudkeychain_salt ();
6927   }
6928   elsif ($mode == 8300)
6929   {
6930     $salt_buf = get_random_dnssec_salt ();
6931   }
6932   elsif ($mode == 13100)
6933   {
6934     $salt_buf = get_random_kerberos5_tgs_salt ();
6935   }
6936   elsif ($mode == 13200)
6937   {
6938     $salt_buf = get_random_axcrypt_salt ();
6939   }
6940   else
6941   {
6942     my @salt_arr;
6943
6944     for (my $i = 0; $i < $salt_len; $i++)
6945     {
6946       my $c = get_random_chr (0x30, 0x39);
6947
6948       push (@salt_arr, $c);
6949     }
6950
6951     $salt_buf = join ("", @salt_arr);
6952
6953     if ($mode == 7500)
6954     {
6955       $salt_buf = get_random_kerberos5_salt ($salt_buf);
6956     }
6957   }
6958
6959   ##
6960   ## gen plain
6961   ##
6962
6963   my @word_arr;
6964
6965   for (my $i = 0; $i < $word_len; $i++)
6966   {
6967     my $c = get_random_chr (0x30, 0x39);
6968
6969     push (@word_arr, $c);
6970   }
6971
6972   my $word_buf = join ("", @word_arr);
6973
6974   ##
6975   ## gen hash
6976   ##
6977
6978   my $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf);
6979
6980   ##
6981   ## run
6982   ##
6983
6984   my @cmd =
6985   (
6986     $hashcat,
6987     "-a 0 -m", $mode,
6988     $tmp_hash
6989   );
6990
6991   print sprintf ("echo -n %-20s | %s \${OPTS} %s %4d '%s'\n", $word_buf, @cmd);
6992 }
6993
6994 ##
6995 ## subs
6996 ##
6997
6998 sub min
6999 {
7000   $_[$_[0] > $_[1]];
7001 }
7002
7003 sub get_random_string
7004 {
7005   my $len = shift;
7006
7007   my @arr;
7008
7009   for (my $i = 0; $i < $len; $i++)
7010   {
7011     my $c = get_random_chr (0x30, 0x39);
7012
7013     push (@arr, $c);
7014   }
7015
7016   my $buf = join ("", @arr);
7017
7018   return $buf;
7019 }
7020
7021 sub get_random_num
7022 {
7023   my $min = shift;
7024   my $max = shift;
7025
7026   return int ((rand ($max - $min)) + $min);
7027 }
7028
7029 sub get_random_chr
7030 {
7031   return chr get_random_num (@_);
7032 }
7033
7034 sub domino_decode
7035 {
7036   my $str = shift;
7037
7038   my $decoded  = "";
7039
7040   for (my $i = 0; $i < length ($str); $i += 4)
7041   {
7042     my $num = domino_base64_decode (substr ($str, $i, 4), 4);
7043
7044     $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
7045   }
7046
7047   my $salt;
7048   my $digest;
7049   my $char;
7050
7051   $salt   = substr ($decoded,  0, 5);
7052
7053   my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
7054
7055   if ($byte10 < 0)
7056   {
7057     $byte10 = 256 + $byte10;
7058   }
7059
7060   substr ($salt, 3, 1) = chr ($byte10);
7061
7062   $digest = substr ($decoded,  5, 9);
7063   $char   = substr ($str,     18, 1);
7064
7065   return ($digest, $salt, $char);
7066 }
7067
7068 sub domino_85x_decode
7069 {
7070   my $str = shift;
7071
7072   my $decoded  = "";
7073
7074   for (my $i = 0; $i < length ($str); $i += 4)
7075   {
7076     my $num = domino_base64_decode (substr ($str, $i, 4), 4);
7077
7078     $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff);
7079   }
7080
7081   my $digest;
7082   my $salt;
7083   my $iterations = -1;
7084   my $chars;
7085
7086   $salt   = substr ($decoded,  0, 16);  # longer than -m 8700 (5 vs 16 <- new)
7087
7088   my $byte10 = (ord (substr ($salt, 3, 1)) - 4);
7089
7090   if ($byte10 < 0)
7091   {
7092     $byte10 = 256 + $byte10;
7093   }
7094
7095   substr ($salt, 3, 1) = chr ($byte10);
7096
7097   $iterations = substr ($decoded,  16, 10);
7098
7099   if ($iterations =~ /^?d*$/)
7100   {
7101     # continue
7102
7103     $iterations = $iterations + 0;            # hack: make sure it is an int now (atoi ())
7104     $chars = substr ($decoded, 26, 2);        # in my example it is "02"
7105     $digest = substr ($decoded, 28, 8);       # only of length of 8 vs 20 SHA1 bytes
7106   }
7107
7108   return ($digest, $salt, $iterations, $chars);
7109 }
7110
7111 sub domino_base64_decode
7112 {
7113   my $v = shift;
7114   my $n = shift;
7115
7116   my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
7117
7118   my $ret = 0;
7119
7120   my $i = 1;
7121
7122   while ($i <= $n)
7123   {
7124     my $idx = (index ($itoa64, substr ($v, $n - $i, 1))) & 0x3f;
7125
7126     $ret += ($idx << (6 * ($i - 1)));
7127
7128     $i = $i + 1;
7129   }
7130
7131   return $ret
7132 }
7133
7134 sub domino_encode
7135 {
7136   my $final = shift;
7137   my $char  = shift;
7138
7139   my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7140
7141   if ($byte10 > 255)
7142   {
7143     $byte10 = $byte10 - 256;
7144   }
7145
7146   substr ($final, 3, 1) = chr ($byte10);
7147
7148   my $passwd = "";
7149
7150   $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);
7151   $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);
7152   $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);
7153   $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);
7154   $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);
7155
7156   if (defined ($char))
7157   {
7158     substr ($passwd, 18, 1) = $char;
7159   }
7160   substr ($passwd, 19, 1) = "";
7161
7162   return $passwd;
7163 }
7164
7165 sub domino_85x_encode
7166 {
7167   my $final = shift;
7168   my $char  = shift;
7169
7170   my $byte10 = (ord (substr ($final, 3, 1)) + 4);
7171
7172   if ($byte10 > 255)
7173   {
7174     $byte10 = $byte10 - 256;
7175   }
7176
7177   substr ($final, 3, 1) = chr ($byte10);
7178
7179   my $passwd = "";
7180
7181   $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);
7182   $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);
7183   $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);
7184   $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);
7185   $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);
7186   $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);
7187   $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);
7188   $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);
7189   $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);
7190   $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);
7191   $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);
7192   $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);
7193
7194   if (defined ($char))
7195   {
7196     substr ($passwd, 18, 1) = $char;
7197   }
7198
7199   return $passwd;
7200 }
7201
7202 sub domino_base64_encode
7203 {
7204   my $v = shift;
7205   my $n = shift;
7206
7207   my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
7208
7209   my $ret = "";
7210
7211   while (($n - 1) >= 0)
7212   {
7213     $n = $n - 1;
7214
7215     $ret = substr ($itoa64, $v & 0x3f, 1) . $ret;
7216
7217     $v = $v >> 6;
7218   }
7219
7220   return $ret
7221 }
7222
7223 sub pseudo_base64
7224 {
7225   my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7226
7227   my $md5 = shift;
7228   my $s64 = "";
7229   for my $i (0..3) {
7230       my $v = unpack "V", substr($md5, $i*4, 4);
7231       for (1..4) {
7232           $s64 .= substr($itoa64, $v & 0x3f, 1);
7233           $v >>= 6;
7234       }
7235   }
7236   return $s64;
7237 }
7238
7239 sub racf_hash
7240 {
7241   my ($username, $password) = @_;
7242
7243   $username = substr ($username . " " x 8, 0, 8);
7244   $password = substr ($password . " " x 8, 0, 8);
7245
7246   my $username_ebc = ascii2ebcdic ($username);
7247   my $password_ebc = ascii2ebcdic ($password);
7248
7249   my @pw = split ("", $password_ebc);
7250
7251   for (my $i = 0; $i < 8; $i++)
7252   {
7253     $pw[$i] = unpack ("C", $pw[$i]);
7254     $pw[$i] ^= 0x55;
7255     $pw[$i] <<= 1;
7256     $pw[$i] = pack ("C", $pw[$i] & 0xff);
7257   }
7258
7259   my $key = join ("", @pw);
7260
7261   my $cipher = new Crypt::DES $key;
7262
7263   my $ciphertext = $cipher->encrypt ($username_ebc);
7264
7265   my $ct = unpack ("H16", $ciphertext);
7266
7267   return $ct;
7268 }
7269
7270 sub oracle_hash
7271 {
7272   my ($username, $password) = @_;
7273
7274   my $userpass = pack('n*', unpack('C*', uc($username.$password)));
7275   $userpass .= pack('C', 0) while (length($userpass) % 8);
7276
7277   my $key = pack('H*', "0123456789ABCDEF");
7278   my $iv = pack('H*', "0000000000000000");
7279
7280   my $c = new Crypt::CBC(
7281     -literal_key => 1,
7282     -cipher => "DES",
7283     -key => $key,
7284     -iv => $iv,
7285     -header => "none"
7286   );
7287   my $key2 = substr($c->encrypt($userpass), length($userpass)-8, 8);
7288
7289   my $c2 = new Crypt::CBC(
7290     -literal_key => 1,
7291     -cipher => "DES",
7292     -key => $key2,
7293     -iv => $iv,
7294     -header => "none"
7295   );
7296   my $hash = substr($c2->encrypt($userpass), length($userpass)-8, 8);
7297
7298   return uc(unpack('H*', $hash));
7299 }
7300
7301 sub androidpin_hash
7302 {
7303   my $word_buf = shift;
7304
7305   my $salt_buf = shift;
7306
7307   my $w = sprintf ("%d%s%s", 0, $word_buf, $salt_buf);
7308
7309   my $digest = sha1 ($w);
7310
7311   for (my $i = 1; $i < 1024; $i++)
7312   {
7313     $w = $digest . sprintf ("%d%s%s", $i, $word_buf, $salt_buf);
7314
7315     $digest = sha1 ($w);
7316   }
7317
7318   my ($A, $B, $C, $D, $E) = unpack ("N5", $digest);
7319
7320   return sprintf ("%08x%08x%08x%08x%08x", $A, $B, $C, $D, $E);
7321 }
7322
7323 sub to64
7324 {
7325   my $v = shift;
7326   my $n = shift;
7327
7328   my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
7329
7330   my $ret = "";
7331
7332   while (($n - 1) >= 0)
7333   {
7334     $n = $n - 1;
7335
7336     $ret .= substr ($itoa64, $v & 0x3f, 1);
7337
7338     $v = $v >> 6;
7339   }
7340
7341   return $ret
7342 }
7343
7344 sub md5_crypt
7345 {
7346   my $magic = shift;
7347
7348   my $iter = shift;
7349   my $pass = shift;
7350   my $salt = shift;
7351
7352   my $hash = ""; # hash to be returned by this function
7353
7354   my $final = md5 ($pass . $salt . $pass);
7355
7356   $salt = substr ($salt, 0, 8);
7357
7358   my $tmp = $pass . $magic . $salt;
7359
7360   my $pass_len = length ($pass);
7361
7362   my $i;
7363
7364   for ($i = $pass_len; $i > 0; $i -= 16)
7365   {
7366     my $len = 16;
7367
7368     if ($i < $len)
7369     {
7370       $len = $i;
7371     }
7372
7373     $tmp .= substr ($final, 0, $len);
7374   }
7375
7376   $i = $pass_len;
7377
7378   while ($i > 0)
7379   {
7380     if ($i & 1)
7381     {
7382       $tmp .= chr (0);
7383     }
7384     else
7385     {
7386       $tmp .= substr ($pass, 0, 1);
7387     }
7388
7389     $i >>= 1;
7390   }
7391
7392   $final = md5 ($tmp);
7393
7394   for ($i = 0; $i < $iter; $i++)
7395   {
7396     $tmp = "";
7397
7398     if ($i & 1)
7399     {
7400       $tmp .= $pass;
7401     }
7402     else
7403     {
7404       $tmp .= $final;
7405     }
7406
7407     if ($i % 3)
7408     {
7409       $tmp .= $salt;
7410     }
7411
7412     if ($i % 7)
7413     {
7414       $tmp .= $pass;
7415     }
7416
7417     if ($i & 1)
7418     {
7419       $tmp .= $final;
7420     }
7421     else
7422     {
7423       $tmp .= $pass;
7424     }
7425
7426     $final = md5 ($tmp);
7427   }
7428
7429   # done
7430   # now format the output sting ("hash")
7431
7432   my $hash_buf;
7433
7434   $hash  = to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final,  6, 1)) << 8) | (ord (substr ($final, 12, 1))), 4);
7435   $hash .= to64 ((ord (substr ($final, 1, 1)) << 16) | (ord (substr ($final,  7, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
7436   $hash .= to64 ((ord (substr ($final, 2, 1)) << 16) | (ord (substr ($final,  8, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
7437   $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final,  9, 1)) << 8) | (ord (substr ($final, 15, 1))), 4);
7438   $hash .= to64 ((ord (substr ($final, 4, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final,  5, 1))), 4);
7439   $hash .= to64 (ord (substr ($final, 11, 1)), 2);
7440
7441   if ($iter == 1000) # default
7442   {
7443     $hash_buf = sprintf ("%s%s\$%s", $magic , $salt , $hash);
7444   }
7445   else
7446   {
7447     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7448   }
7449
7450   return $hash_buf;
7451 }
7452
7453 sub sha512_crypt
7454 {
7455   my $iter = shift;
7456   my $pass = shift;
7457   my $salt = shift;
7458
7459   my $hash = ""; # hash to be returned by this function
7460
7461   my $final = sha512 ($pass . $salt . $pass);
7462
7463   $salt = substr ($salt, 0, 16);
7464
7465   my $tmp = $pass . $salt;
7466
7467   my $pass_len = length ($pass);
7468   my $salt_len = length ($salt);
7469
7470   my $i;
7471
7472   for ($i = $pass_len; $i > 0; $i -= 16)
7473   {
7474     my $len = 16;
7475
7476     if ($i < $len)
7477     {
7478       $len = $i;
7479     }
7480
7481     $tmp .= substr ($final, 0, $len);
7482   }
7483
7484   $i = $pass_len;
7485
7486   while ($i > 0)
7487   {
7488     if ($i & 1)
7489     {
7490       $tmp .= $final;
7491     }
7492     else
7493     {
7494       $tmp .= $pass;
7495     }
7496
7497     $i >>= 1;
7498   }
7499
7500   $final = sha512 ($tmp);
7501
7502   # p_bytes
7503
7504   my $p_bytes = "";
7505
7506   for ($i = 0; $i < $pass_len; $i++)
7507   {
7508     $p_bytes .= $pass;
7509   }
7510
7511   $p_bytes = sha512 ($p_bytes);
7512   $p_bytes = substr ($p_bytes, 0, $pass_len);
7513
7514   # s_bytes
7515
7516   my $final_first_byte = ord (substr ($final, 0, 1));
7517
7518   my $s_bytes = "";
7519
7520   for ($i = 0; $i < (16 + $final_first_byte); $i++)
7521   {
7522     $s_bytes .= $salt;
7523   }
7524
7525   $s_bytes = sha512 ($s_bytes);
7526   $s_bytes = substr ($s_bytes, 0, $salt_len);
7527
7528   for ($i = 0; $i < $iter; $i++)
7529   {
7530     $tmp = "";
7531
7532     if ($i & 1)
7533     {
7534       $tmp .= $p_bytes;
7535     }
7536     else
7537     {
7538       $tmp .= $final;
7539     }
7540
7541     if ($i % 3)
7542     {
7543       $tmp .= $s_bytes;
7544     }
7545
7546     if ($i % 7)
7547     {
7548       $tmp .= $p_bytes;
7549     }
7550
7551     if ($i & 1)
7552     {
7553       $tmp .= $final;
7554     }
7555     else
7556     {
7557       $tmp .= $p_bytes;
7558     }
7559
7560     $final = sha512 ($tmp);
7561   }
7562
7563   # done
7564   # now format the output string ("hash")
7565
7566   my $hash_buf;
7567
7568   $hash .= to64 ((ord (substr ($final,  0, 1)) << 16) | (ord (substr ($final, 21, 1)) << 8) | (ord (substr ($final, 42, 1))), 4);
7569   $hash .= to64 ((ord (substr ($final, 22, 1)) << 16) | (ord (substr ($final, 43, 1)) << 8) | (ord (substr ($final,  1, 1))), 4);
7570   $hash .= to64 ((ord (substr ($final, 44, 1)) << 16) | (ord (substr ($final,  2, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
7571   $hash .= to64 ((ord (substr ($final,  3, 1)) << 16) | (ord (substr ($final, 24, 1)) << 8) | (ord (substr ($final, 45, 1))), 4);
7572   $hash .= to64 ((ord (substr ($final, 25, 1)) << 16) | (ord (substr ($final, 46, 1)) << 8) | (ord (substr ($final,  4, 1))), 4);
7573   $hash .= to64 ((ord (substr ($final, 47, 1)) << 16) | (ord (substr ($final,  5, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
7574   $hash .= to64 ((ord (substr ($final,  6, 1)) << 16) | (ord (substr ($final, 27, 1)) << 8) | (ord (substr ($final, 48, 1))), 4);
7575   $hash .= to64 ((ord (substr ($final, 28, 1)) << 16) | (ord (substr ($final, 49, 1)) << 8) | (ord (substr ($final,  7, 1))), 4);
7576   $hash .= to64 ((ord (substr ($final, 50, 1)) << 16) | (ord (substr ($final,  8, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
7577   $hash .= to64 ((ord (substr ($final,  9, 1)) << 16) | (ord (substr ($final, 30, 1)) << 8) | (ord (substr ($final, 51, 1))), 4);
7578   $hash .= to64 ((ord (substr ($final, 31, 1)) << 16) | (ord (substr ($final, 52, 1)) << 8) | (ord (substr ($final, 10, 1))), 4);
7579   $hash .= to64 ((ord (substr ($final, 53, 1)) << 16) | (ord (substr ($final, 11, 1)) << 8) | (ord (substr ($final, 32, 1))), 4);
7580   $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 33, 1)) << 8) | (ord (substr ($final, 54, 1))), 4);
7581   $hash .= to64 ((ord (substr ($final, 34, 1)) << 16) | (ord (substr ($final, 55, 1)) << 8) | (ord (substr ($final, 13, 1))), 4);
7582   $hash .= to64 ((ord (substr ($final, 56, 1)) << 16) | (ord (substr ($final, 14, 1)) << 8) | (ord (substr ($final, 35, 1))), 4);
7583   $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 36, 1)) << 8) | (ord (substr ($final, 57, 1))), 4);
7584   $hash .= to64 ((ord (substr ($final, 37, 1)) << 16) | (ord (substr ($final, 58, 1)) << 8) | (ord (substr ($final, 16, 1))), 4);
7585   $hash .= to64 ((ord (substr ($final, 59, 1)) << 16) | (ord (substr ($final, 17, 1)) << 8) | (ord (substr ($final, 38, 1))), 4);
7586   $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 39, 1)) << 8) | (ord (substr ($final, 60, 1))), 4);
7587   $hash .= to64 ((ord (substr ($final, 40, 1)) << 16) | (ord (substr ($final, 61, 1)) << 8) | (ord (substr ($final, 19, 1))), 4);
7588   $hash .= to64 ((ord (substr ($final, 62, 1)) << 16) | (ord (substr ($final, 20, 1)) << 8) | (ord (substr ($final, 41, 1))), 4);
7589   $hash .= to64 (ord (substr ($final,  63, 1)), 2);
7590
7591   my $magic = '$6$';
7592
7593   if ($iter == 5000) # default
7594   {
7595     $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
7596   }
7597   else
7598   {
7599     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7600   }
7601
7602   return $hash_buf;
7603 }
7604
7605 sub sha256_crypt
7606 {
7607   my $iter = shift;
7608   my $pass = shift;
7609   my $salt = shift;
7610
7611   my $hash = ""; # hash to be returned by this function
7612
7613   my $final = sha256 ($pass . $salt . $pass);
7614
7615   $salt = substr ($salt, 0, 16);
7616
7617   my $tmp = $pass . $salt;
7618
7619   my $pass_len = length ($pass);
7620   my $salt_len = length ($salt);
7621
7622   my $i;
7623
7624   for ($i = $pass_len; $i > 0; $i -= 16)
7625   {
7626     my $len = 16;
7627
7628     if ($i < $len)
7629     {
7630       $len = $i;
7631     }
7632
7633     $tmp .= substr ($final, 0, $len);
7634   }
7635
7636   $i = $pass_len;
7637
7638   while ($i > 0)
7639   {
7640     if ($i & 1)
7641     {
7642       $tmp .= $final;
7643     }
7644     else
7645     {
7646       $tmp .= $pass;
7647     }
7648
7649     $i >>= 1;
7650   }
7651
7652   $final = sha256 ($tmp);
7653
7654   # p_bytes
7655
7656   my $p_bytes = "";
7657
7658   for ($i = 0; $i < $pass_len; $i++)
7659   {
7660     $p_bytes .= $pass;
7661   }
7662
7663   $p_bytes = sha256 ($p_bytes);
7664   $p_bytes = substr ($p_bytes, 0, $pass_len);
7665
7666   # s_bytes
7667
7668   my $final_first_byte = ord (substr ($final, 0, 1));
7669
7670   my $s_bytes = "";
7671
7672   for ($i = 0; $i < (16 + $final_first_byte); $i++)
7673   {
7674     $s_bytes .= $salt;
7675   }
7676
7677   $s_bytes = sha256 ($s_bytes);
7678   $s_bytes = substr ($s_bytes, 0, $salt_len);
7679
7680   for ($i = 0; $i < $iter; $i++)
7681   {
7682     $tmp = "";
7683
7684     if ($i & 1)
7685     {
7686       $tmp .= $p_bytes;
7687     }
7688     else
7689     {
7690       $tmp .= $final;
7691     }
7692
7693     if ($i % 3)
7694     {
7695       $tmp .= $s_bytes;
7696     }
7697
7698     if ($i % 7)
7699     {
7700       $tmp .= $p_bytes;
7701     }
7702
7703     if ($i & 1)
7704     {
7705       $tmp .= $final;
7706     }
7707     else
7708     {
7709       $tmp .= $p_bytes;
7710     }
7711
7712     $final = sha256 ($tmp);
7713   }
7714
7715   # done
7716   # now format the output string ("hash")
7717
7718   my $hash_buf;
7719
7720   $hash .= to64 ((ord (substr ($final,  0, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 20, 1))), 4);
7721   $hash .= to64 ((ord (substr ($final, 21, 1)) << 16) | (ord (substr ($final,  1, 1)) << 8) | (ord (substr ($final, 11, 1))), 4);
7722   $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 22, 1)) << 8) | (ord (substr ($final,  2, 1))), 4);
7723   $hash .= to64 ((ord (substr ($final,  3, 1)) << 16) | (ord (substr ($final, 13, 1)) << 8) | (ord (substr ($final, 23, 1))), 4);
7724   $hash .= to64 ((ord (substr ($final, 24, 1)) << 16) | (ord (substr ($final,  4, 1)) << 8) | (ord (substr ($final, 14, 1))), 4);
7725   $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 25, 1)) << 8) | (ord (substr ($final,  5, 1))), 4);
7726   $hash .= to64 ((ord (substr ($final,  6, 1)) << 16) | (ord (substr ($final, 16, 1)) << 8) | (ord (substr ($final, 26, 1))), 4);
7727   $hash .= to64 ((ord (substr ($final, 27, 1)) << 16) | (ord (substr ($final,  7, 1)) << 8) | (ord (substr ($final, 17, 1))), 4);
7728   $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 28, 1)) << 8) | (ord (substr ($final,  8, 1))), 4);
7729   $hash .= to64 ((ord (substr ($final,  9, 1)) << 16) | (ord (substr ($final, 19, 1)) << 8) | (ord (substr ($final, 29, 1))), 4);
7730   $hash .= to64 ((ord (substr ($final, 31, 1)) <<  8) | (ord (substr ($final, 30, 1))), 3);
7731
7732   my $magic = '$5$';
7733
7734   if ($iter == 5000) # default
7735   {
7736     $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash);
7737   }
7738   else
7739   {
7740     $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash);
7741   }
7742
7743   return $hash_buf;
7744 }
7745
7746 sub aix_ssha256_pbkdf2
7747 {
7748   my $word_buf   = shift;
7749   my $salt_buf   = shift;
7750   my $iterations = shift;
7751
7752   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256);
7753
7754   my $pbkdf2 = Crypt::PBKDF2->new (
7755     hasher       => $hasher,
7756     iterations   => $iterations,
7757     output_len   => 32
7758   );
7759
7760   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7761
7762   my $tmp_hash = "";
7763
7764   $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);
7765   $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);
7766   $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);
7767   $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);
7768   $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);
7769   $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);
7770   $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);
7771   $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);
7772   $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);
7773   $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);
7774   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 30, 1))) << 16) | (int (ord (substr ($hash_buf, 31, 1))) << 8)                                          , 3);
7775
7776   return $tmp_hash;
7777 }
7778
7779 sub aix_ssha512_pbkdf2
7780 {
7781   my $word_buf   = shift;
7782   my $salt_buf   = shift;
7783   my $iterations = shift;
7784
7785   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512);
7786
7787   my $pbkdf2 = Crypt::PBKDF2->new (
7788     hasher       => $hasher,
7789     iterations   => $iterations,
7790   );
7791
7792   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7793
7794   my $tmp_hash = "";
7795
7796   $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);
7797   $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);
7798   $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);
7799   $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);
7800   $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);
7801   $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);
7802   $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);
7803   $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);
7804   $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);
7805   $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);
7806   $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);
7807   $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);
7808   $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);
7809   $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);
7810   $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);
7811   $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);
7812   $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);
7813   $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);
7814   $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);
7815   $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);
7816   $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);
7817   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 63, 1))) << 16)                                                                                         , 2);
7818
7819   return $tmp_hash;
7820 }
7821
7822 sub aix_ssha1_pbkdf2
7823 {
7824   my $word_buf   = shift;
7825   my $salt_buf   = shift;
7826   my $iterations = shift;
7827
7828   my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1');
7829
7830   my $pbkdf2 = Crypt::PBKDF2->new (
7831     hasher       => $hasher,
7832     iterations   => $iterations,
7833   );
7834
7835   my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf);
7836
7837   my $tmp_hash = "";
7838
7839   $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);
7840   $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);
7841   $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);
7842   $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);
7843   $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);
7844   $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);
7845   $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8)                                          , 3);
7846
7847   return $tmp_hash;
7848 }
7849
7850 sub sapb_transcode
7851 {
7852   my $data_s = shift;
7853
7854   my @data = split "", $data_s;
7855
7856   my $transTable_s =
7857     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7858     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7859     "\x3f\x40\x41\x50\x43\x44\x45\x4b\x47\x48\x4d\x4e\x54\x51\x53\x46" .
7860     "\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x56\x55\x5c\x49\x5d\x4a" .
7861     "\x42\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
7862     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x58\x5b\x59\xff\x52" .
7863     "\x4c\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" .
7864     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x57\x5e\x5a\x4f\xff" .
7865     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7866     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7867     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7868     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7869     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7870     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7871     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" .
7872     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
7873
7874   my @transTable = unpack ("C256", $transTable_s);
7875
7876   my @out;
7877
7878   for (my $i = 0; $i < scalar @data; $i++)
7879   {
7880     $out[$i] = $transTable[int (ord ($data[$i]))];
7881   }
7882
7883   return pack ("C*", @out);
7884 }
7885
7886 sub sapb_waldorf
7887 {
7888   my $digest_s = shift;
7889
7890   my $w_s = shift;
7891   my $s_s = shift;
7892
7893   my @w = unpack "C*", $w_s;
7894   my @s = unpack "C*", $s_s;
7895
7896   my $bcodeTable_s =
7897     "\x14\x77\xf3\xd4\xbb\x71\x23\xd0\x03\xff\x47\x93\x55\xaa\x66\x91" .
7898     "\xf2\x88\x6b\x99\xbf\xcb\x32\x1a\x19\xd9\xa7\x82\x22\x49\xa2\x51" .
7899     "\xe2\xb7\x33\x71\x8b\x9f\x5d\x01\x44\x70\xae\x11\xef\x28\xf0\x0d";
7900
7901   my @bcodeTable = unpack ("C48", $bcodeTable_s);
7902
7903   my @abcd = unpack ("C16", $digest_s);
7904
7905   my $sum20 = ($abcd[0] & 3)
7906             + ($abcd[1] & 3)
7907             + ($abcd[2] & 3)
7908             + ($abcd[3] & 3)
7909             + ($abcd[5] & 3);
7910
7911   $sum20 |= 0x20;
7912
7913   my @out;
7914
7915   for (my $i2 = 0; $i2 < $sum20; $i2++)
7916   {
7917     $out[$i2] = 0;
7918   }
7919
7920   for (my $i1 = 0, my $i2 = 0, my $i3 = 0; $i2 < $sum20; $i2++, $i2++)
7921   {
7922     if ($i1 < length $w_s)
7923     {
7924       if ($abcd[15 - $i1] & 1)
7925       {
7926         $out[$i2] = $bcodeTable[48 - 1 - $i1];
7927
7928         $i2++;
7929       }
7930
7931       $out[$i2] = $w[$i1];
7932
7933       $i1++;
7934       $i2++;
7935     }
7936
7937     if ($i3 < length $s_s)
7938     {
7939       $out[$i2] = $s[$i3];
7940
7941       $i2++;
7942       $i3++;
7943     }
7944
7945     $out[$i2] = $bcodeTable[$i2 - $i1 - $i3];
7946   }
7947
7948   return substr (pack ("C*", @out), 0, $sum20);
7949 }
7950
7951 sub setup_des_key
7952 {
7953   my @key_56 = split (//, shift);
7954
7955   my $key = "";
7956
7957   $key = $key_56[0];
7958
7959   $key .= chr(((ord($key_56[0]) << 7) | (ord($key_56[1]) >> 1)) & 255);
7960   $key .= chr(((ord($key_56[1]) << 6) | (ord($key_56[2]) >> 2)) & 255);
7961   $key .= chr(((ord($key_56[2]) << 5) | (ord($key_56[3]) >> 3)) & 255);
7962   $key .= chr(((ord($key_56[3]) << 4) | (ord($key_56[4]) >> 4)) & 255);
7963   $key .= chr(((ord($key_56[4]) << 3) | (ord($key_56[5]) >> 5)) & 255);
7964   $key .= chr(((ord($key_56[5]) << 2) | (ord($key_56[6]) >> 6)) & 255);
7965   $key .= chr(( ord($key_56[6]) << 1) & 255);
7966
7967   return $key;
7968 }
7969
7970 sub randbytes
7971 {
7972   my $len = shift;
7973
7974   my @arr;
7975
7976   for (my $i = 0; $i < $len; $i++)
7977   {
7978     my $c = get_random_chr (0, 255);
7979
7980     push (@arr, $c);
7981   }
7982
7983   return join ("", @arr);
7984 }
7985
7986 sub get_random_netntlmv1_salt
7987 {
7988   my $len_user   = shift;
7989   my $len_domain = shift;
7990
7991   my $char;
7992   my $type;
7993   my $user = "";
7994
7995   for (my $i = 0; $i < $len_user; $i++)
7996   {
7997     $type = get_random_num (1, 3);
7998
7999     if ($type == 1)
8000     {
8001       $char = get_random_chr (0x30, 0x39);
8002     }
8003     elsif ($type == 2)
8004     {
8005       $char = get_random_chr (0x41, 0x5A);
8006     }
8007     else
8008     {
8009       $char = get_random_chr (0x61, 0x7A);
8010     }
8011
8012     $user .= $char;
8013   }
8014
8015   my $domain = "";
8016
8017   for (my $i = 0; $i < $len_domain; $i++)
8018   {
8019     $type = get_random_num (1, 3);
8020
8021     if ($type == 1)
8022     {
8023       $char = get_random_chr (0x30, 0x39);
8024     }
8025     elsif ($type == 2)
8026     {
8027       $char = get_random_chr (0x41, 0x5A);
8028     }
8029     else
8030     {
8031       $char = get_random_chr (0x61, 0x7A);
8032     }
8033
8034     $domain .= $char;
8035   }
8036
8037   my $c_challenge = randbytes (8);
8038   my $s_challenge = randbytes (8);
8039
8040   my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $c_challenge) . unpack ("H*", $s_challenge);
8041
8042   return $salt_buf;
8043 }
8044
8045 sub get_random_netntlmv2_salt
8046 {
8047   my $len_user   = shift;
8048   my $len_domain = shift;
8049
8050   my $char;
8051   my $type;
8052   my $user = "";
8053
8054   if ($len_user + $len_domain > 27)
8055   {
8056     if ($len_user > $len_domain)
8057     {
8058       $len_user = 27 - $len_domain;
8059     }
8060     else
8061     {
8062       $len_domain = 27 - $len_user;
8063     }
8064   }
8065
8066   for (my $i = 0; $i < $len_user; $i++)
8067   {
8068     $type = get_random_num (1, 3);
8069
8070     if ($type == 1)
8071     {
8072       $char = get_random_chr (0x30, 0x39);
8073     }
8074     elsif ($type == 2)
8075     {
8076       $char = get_random_chr (0x41, 0x5A);
8077     }
8078     else
8079     {
8080       $char = get_random_chr (0x61, 0x7A);
8081     }
8082
8083     $user .= $char;
8084   }
8085
8086   my $domain = "";
8087
8088   for (my $i = 0; $i < $len_domain; $i++)
8089   {
8090     $type = get_random_num (1, 3);
8091
8092     if ($type == 1)
8093     {
8094       $char = get_random_chr (0x30, 0x39);
8095     }
8096     elsif ($type == 2)
8097     {
8098       $char = get_random_chr (0x41, 0x5A);
8099     }
8100     else
8101     {
8102       $char = get_random_chr (0x61, 0x7A);
8103     }
8104
8105     $domain .= $char;
8106   }
8107
8108   my $c_challenge = randbytes (8);
8109   my $s_challenge = randbytes (8);
8110
8111   my $temp = "\x01\x01" .
8112              "\x00" x 6 .
8113              randbytes (8) .
8114              $c_challenge .
8115              "\x00" x 4 .
8116              randbytes (20 * rand () + 1) .
8117              "\x00";
8118
8119   my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $s_challenge) . unpack ("H*", $temp);
8120
8121   return $salt_buf;
8122 }
8123
8124 sub get_random_ike_salt
8125 {
8126   my $nr_buf = "";
8127
8128   for (my $i = 0; $i < 40; $i++)
8129   {
8130     $nr_buf .= get_random_chr (0, 0xff);
8131   }
8132
8133   my $msg_buf = "";
8134
8135   for (my $i = 0; $i < 440; $i++)
8136   {
8137     $msg_buf .= get_random_chr (0, 0xff);
8138   }
8139
8140   my $nr_buf_hex  = unpack ("H*", $nr_buf);
8141   my $msg_buf_hex = unpack ("H*", $msg_buf);
8142
8143   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));
8144
8145   return $salt_buf;
8146 }
8147
8148 sub get_random_agilekeychain_salt
8149 {
8150   my $salt_buf = "";
8151
8152   for (my $i = 0; $i < 8; $i++)
8153   {
8154     $salt_buf .= get_random_chr (0x0, 0xff);
8155   }
8156
8157   my $iv = "";
8158
8159   for (my $i = 0; $i < 16; $i++)
8160   {
8161     $iv .= get_random_chr (0x0, 0xff);
8162   }
8163
8164   my $prefix = "\x00" x 1008;
8165
8166   my $ret = unpack ("H*", $salt_buf . $prefix . $iv);
8167
8168   return $ret;
8169 }
8170
8171 sub get_random_cloudkeychain_salt
8172 {
8173   my $salt_buf = "";
8174
8175   for (my $i = 0; $i < 16; $i++)
8176   {
8177     $salt_buf .= get_random_chr (0x0, 0xff);
8178   }
8179
8180   for (my $i = 0; $i < 304; $i++)
8181   {
8182     $salt_buf .= get_random_chr (0x0, 0xff);
8183   }
8184
8185   my $ret = unpack ("H*", $salt_buf);
8186
8187   return $ret;
8188 }
8189
8190 sub get_random_kerberos5_salt
8191 {
8192   my $custom_salt = shift;
8193
8194   my $clear_data = randbytes (14) .
8195                    strftime ("%Y%m%d%H%M%S", localtime) .
8196                    randbytes (8);
8197
8198   my $user  = "user";
8199   my $realm = "realm";
8200   my $salt  = "salt";
8201
8202   my $salt_buf = $user . "\$" . $realm . "\$" . $salt . "\$" . unpack ("H*", $custom_salt) . "\$" . unpack ("H*", $clear_data) . "\$";
8203
8204   return $salt_buf;
8205 }
8206
8207 sub get_random_kerberos5_tgs_salt
8208 {
8209   my $nonce = randbytes (8);
8210
8211   my $user  = "user";
8212   my $realm = "realm";
8213   my $spn   = "test/spn";
8214
8215   my $salt_buf = $user . "\$" . $realm . "\$" . $spn . "\$" . unpack ("H*",$nonce);
8216
8217   return $salt_buf;
8218 }
8219
8220 sub get_random_axcrypt_salt
8221 {
8222   my $mysalt = randbytes (16);
8223
8224   $mysalt = unpack ("H*", $mysalt);
8225
8226   my $iteration = get_random_num (6, 100000);
8227
8228   my $salt_buf = $iteration . '*' . $mysalt;
8229
8230   return $salt_buf;
8231 }
8232
8233 sub get_random_md5chap_salt
8234 {
8235   my $salt_buf = shift;
8236
8237   my $salt = unpack ("H*", $salt_buf);
8238
8239   $salt .= ":";
8240
8241   $salt .= unpack ("H*", randbytes (1));
8242
8243   return $salt;
8244 }
8245
8246 sub get_random_dnssec_salt
8247 {
8248   my $salt_buf = "";
8249
8250   $salt_buf .= ".";
8251
8252   for (my $i = 0; $i < 8; $i++)
8253   {
8254     $salt_buf .= get_random_chr (0x61, 0x7a);
8255   }
8256
8257   $salt_buf .= ".net";
8258
8259   $salt_buf .= ":";
8260
8261   for (my $i = 0; $i < 8; $i++)
8262   {
8263     $salt_buf .= get_random_chr (0x30, 0x39);
8264   }
8265
8266   return $salt_buf;
8267 }
8268
8269 sub md5bit
8270 {
8271   my $digest = shift;
8272   my $bit = shift;
8273
8274   $bit %= 128;
8275
8276   my $byte_off = int ($bit / 8);
8277   my $bit_off  = int ($bit % 8);
8278
8279   my $char = substr ($digest, $byte_off, 1);
8280   my $num  = ord ($char);
8281
8282   return (($num & (1 << $bit_off)) ? 1 : 0);
8283 }
8284
8285 sub sun_md5
8286 {
8287   my $pw   = shift;
8288   my $salt = shift;
8289   my $iter = shift;
8290
8291   my $constant_phrase =
8292   "To be, or not to be,--that is the question:--\n"        .
8293   "Whether 'tis nobler in the mind to suffer\n"            .
8294   "The slings and arrows of outrageous fortune\n"          .
8295   "Or to take arms against a sea of troubles,\n"           .
8296   "And by opposing end them?--To die,--to sleep,--\n"      .
8297   "No more; and by a sleep to say we end\n"                .
8298   "The heartache, and the thousand natural shocks\n"       .
8299   "That flesh is heir to,--'tis a consummation\n"          .
8300   "Devoutly to be wish'd. To die,--to sleep;--\n"          .
8301   "To sleep! perchance to dream:--ay, there's the rub;\n"  .
8302   "For in that sleep of death what dreams may come,\n"     .
8303   "When we have shuffled off this mortal coil,\n"          .
8304   "Must give us pause: there's the respect\n"              .
8305   "That makes calamity of so long life;\n"                 .
8306   "For who would bear the whips and scorns of time,\n"     .
8307   "The oppressor's wrong, the proud man's contumely,\n"    .
8308   "The pangs of despis'd love, the law's delay,\n"         .
8309   "The insolence of office, and the spurns\n"              .
8310   "That patient merit of the unworthy takes,\n"            .
8311   "When he himself might his quietus make\n"               .
8312   "With a bare bodkin? who would these fardels bear,\n"    .
8313   "To grunt and sweat under a weary life,\n"               .
8314   "But that the dread of something after death,--\n"       .
8315   "The undiscover'd country, from whose bourn\n"           .
8316   "No traveller returns,--puzzles the will,\n"             .
8317   "And makes us rather bear those ills we have\n"          .
8318   "Than fly to others that we know not of?\n"              .
8319   "Thus conscience does make cowards of us all;\n"         .
8320   "And thus the native hue of resolution\n"                .
8321   "Is sicklied o'er with the pale cast of thought;\n"      .
8322   "And enterprises of great pith and moment,\n"            .
8323   "With this regard, their currents turn awry,\n"          .
8324   "And lose the name of action.--Soft you now!\n"          .
8325   "The fair Ophelia!--Nymph, in thy orisons\n"             .
8326   "Be all my sins remember'd.\n\x00";
8327
8328   my $constant_len = length ($constant_phrase);
8329
8330   my $hash_buf = md5 ($pw . $salt);
8331
8332   my $W;
8333
8334   my $to_hash;
8335
8336   for (my $round = 0; $round < $iter; $round++)
8337   {
8338     my $shift_a = md5bit ($hash_buf, $round +  0);
8339     my $shift_b = md5bit ($hash_buf, $round + 64);
8340
8341     my @shift_4;
8342     my @shift_7;
8343
8344     for (my $k = 0; $k < 16; $k++)
8345     {
8346        my $s7shift = ord (substr ($hash_buf, $k, 1)) % 8;
8347
8348        my $l = ($k + 3) % 16;
8349
8350        my $num = ord (substr ($hash_buf, $l, 1));
8351
8352        $shift_4[$k] = $num % 5;
8353
8354        $shift_7[$k] = ($num >> $s7shift) & 1;
8355     }
8356
8357     my @indirect_4;
8358
8359     for (my $k = 0; $k < 16; $k++)
8360     {
8361       $indirect_4[$k] = (ord (substr ($hash_buf, $k, 1)) >> $shift_4[$k]) & 0xf;
8362     }
8363
8364     my @indirect_7;
8365
8366     for (my $k = 0; $k < 16; $k++)
8367     {
8368       $indirect_7[$k] = (ord (substr ($hash_buf, $indirect_4[$k], 1)) >> $shift_7[$k]) & 0x7f;
8369     }
8370
8371     my $indirect_a = 0;
8372     my $indirect_b = 0;
8373
8374     for (my $k = 0; $k < 8; $k++)
8375     {
8376       $indirect_a |= md5bit ($hash_buf, $indirect_7[$k + 0]) << $k;
8377
8378       $indirect_b |= md5bit ($hash_buf, $indirect_7[$k + 8]) << $k;
8379     }
8380
8381     $indirect_a = ($indirect_a >> $shift_a) & 0x7f;
8382     $indirect_b = ($indirect_b >> $shift_b) & 0x7f;
8383
8384     my $bit_a = md5bit ($hash_buf, $indirect_a);
8385     my $bit_b = md5bit ($hash_buf, $indirect_b);
8386
8387     $W = $hash_buf;
8388
8389     my $pos = 16;
8390
8391     my $total = $pos;
8392
8393     $to_hash = "";
8394
8395     if ($bit_a ^ $bit_b)
8396     {
8397       substr ($W, 16, 48) = substr ($constant_phrase, 0, 48);
8398
8399       $total += 48;
8400
8401       $to_hash .= substr ($W, 0, 64);
8402
8403       my $constant_off;
8404
8405       for ($constant_off = 48; $constant_off < $constant_len - 64; $constant_off += 64)
8406       {
8407         substr ($W, 0, 64) = substr ($constant_phrase, $constant_off, 64);
8408
8409         $total += 64;
8410
8411         $to_hash .= substr ($W, 0, 64);
8412       }
8413
8414       $pos = $constant_len - $constant_off;
8415
8416       $total += $pos;
8417
8418       substr ($W, 0, $pos) = substr ($constant_phrase, $constant_off, $pos);
8419     }
8420
8421     my $a_len = 0;
8422
8423     my @a_buf;
8424     $a_buf[0] = 0;
8425     $a_buf[1] = 0;
8426     $a_buf[2] = 0;
8427     $a_buf[3] = 0;
8428
8429     my $tmp = $round;
8430
8431     do
8432     {
8433       my $round_div = int ($tmp / 10);
8434       my $round_mod = int ($tmp % 10);
8435
8436       $tmp = $round_div;
8437
8438       $a_buf[int ($a_len / 4)] = (($round_mod + 0x30) | ($a_buf[int ($a_len / 4)] << 8));
8439
8440       $a_len++;
8441
8442     } while ($tmp);
8443
8444     my $tmp_str = "";
8445
8446     my $g;
8447
8448     for ($g = 0; $g < $a_len; $g++)
8449     {
8450       my $remainder = $a_buf[$g];
8451       my $factor = 7;
8452       my $started = 1;
8453
8454       my $sub;
8455
8456       while ($remainder > 0)
8457       {
8458         $sub = $remainder >> (8 * $factor);
8459
8460         if ($started != 1 || $sub > 0)
8461         {
8462           $started = 0;
8463
8464           $tmp_str = chr ($sub) . $tmp_str;
8465
8466           $remainder -= ($sub << (8 * $factor));
8467         }
8468
8469         $factor--;
8470       }
8471
8472     }
8473
8474     substr ($W, $pos, $a_len) = $tmp_str;
8475
8476     $pos += $a_len;
8477
8478     $total += $a_len;
8479
8480     $to_hash .= substr ($W, 0, $pos);
8481
8482     $to_hash = substr ($to_hash, 0, $total);
8483
8484     $hash_buf = md5 ($to_hash);
8485   }
8486
8487   my $passwd = "";
8488
8489   $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);
8490   $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);
8491   $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);
8492   $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);
8493   $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);
8494   $passwd .= to64 ((int (ord (substr ($hash_buf, 11, 1)))), 2);
8495
8496   return $passwd;
8497 }
8498
8499 sub usage_die
8500 {
8501   die ("usage: $0 single|passthrough| [mode] [len]\n" .
8502        "       or\n" .
8503        "       $0 verify              [mode] [hashfile] [cracks] [outfile]\n");
8504 }
8505
8506 sub pad16
8507 {
8508   my $block_ref = shift;
8509
8510   my $offset = shift;
8511
8512   my $value = 16 - $offset;
8513
8514   for (my $i = $offset; $i < 16; $i++)
8515   {
8516     push @{$block_ref}, $value;
8517   }
8518 }
8519
8520 sub lotus_mix
8521 {
8522   my $in_ref = shift;
8523
8524   my $p = 0;
8525
8526   for (my $i = 0; $i < 18; $i++)
8527   {
8528     for (my $j = 0; $j < 48; $j++)
8529     {
8530       $p = ($p + 48 - $j) & 0xff;
8531
8532       my $c = $lotus_magic_table[$p];
8533
8534       $p = $in_ref->[$j] ^ $c;
8535
8536       $in_ref->[$j] = $p;
8537     }
8538   }
8539 }
8540
8541 sub lotus_transform_password
8542 {
8543   my $in_ref  = shift;
8544   my $out_ref = shift;
8545
8546   my $t = $out_ref->[15];
8547
8548   for (my $i = 0; $i < 16; $i++)
8549   {
8550     $t ^= $in_ref->[$i];
8551
8552     my $c = $lotus_magic_table[$t];
8553
8554     $out_ref->[$i] ^= $c;
8555
8556     $t = $out_ref->[$i];
8557   }
8558 }
8559
8560 sub mdtransform_norecalc
8561 {
8562   my $state_ref = shift;
8563   my $block_ref = shift;
8564
8565   my @x;
8566
8567   push (@x, @{$state_ref});
8568   push (@x, @{$block_ref});
8569
8570   for (my $i = 0; $i < 16; $i++)
8571   {
8572     push (@x, $x[0 + $i] ^ $x[16 + $i]);
8573   }
8574
8575   lotus_mix (\@x);
8576
8577   for (my $i = 0; $i < 16; $i++)
8578   {
8579     $state_ref->[$i] = $x[$i];
8580   }
8581 }
8582
8583 sub mdtransform
8584 {
8585   my $state_ref    = shift;
8586   my $checksum_ref = shift;
8587   my $block_ref    = shift;
8588
8589   mdtransform_norecalc ($state_ref, $block_ref);
8590
8591   lotus_transform_password ($block_ref, $checksum_ref);
8592 }
8593
8594 sub domino_big_md
8595 {
8596   my $saved_key_ref = shift;
8597
8598   my $size = shift;
8599
8600   @{$saved_key_ref} = splice (@{$saved_key_ref}, 0, $size);
8601
8602   my @state = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
8603
8604   my @checksum;
8605
8606   my $curpos;
8607
8608   for ($curpos = 0; $curpos + 16 < $size; $curpos += 16)
8609   {
8610     my $curpos16 = $curpos + 16;
8611
8612     my @block = splice (@{$saved_key_ref}, 0, 16);
8613
8614     mdtransform (\@state, \@checksum, \@block);
8615   }
8616
8617   my $left = $size - $curpos;
8618
8619   my @block = splice (@{$saved_key_ref}, 0, 16);
8620
8621   pad16 (\@block, $left);
8622
8623   mdtransform (\@state, \@checksum, \@block);
8624
8625   mdtransform_norecalc (\@state, \@checksum);
8626
8627   return @state;
8628 }
8629
8630 sub pdf_compute_encryption_key
8631 {
8632   my $word_buf  = shift;
8633   my $padding   = shift;
8634   my $id        = shift;
8635   my $u         = shift;
8636   my $o         = shift;
8637   my $P         = shift;
8638   my $V         = shift;
8639   my $R         = shift;
8640   my $enc       = shift;
8641
8642   ## start
8643
8644   my $data;
8645
8646   $data .= $word_buf;
8647
8648   $data .= substr ($padding, 0, 32 - length $word_buf);
8649
8650   $data .= pack ("H*", $o);
8651
8652   $data .= pack ("I", $P);
8653
8654   $data .= pack ("H*", $id);
8655
8656   if ($R >= 4)
8657   {
8658     if (!$enc)
8659     {
8660       $data .= pack ("I", -1);
8661     }
8662   }
8663
8664   my $res = md5 ($data);
8665
8666   if ($R >= 3)
8667   {
8668     for (my $i = 0; $i < 50; $i++)
8669     {
8670       $res = md5 ($res);
8671     }
8672   }
8673
8674   return $res;
8675 }
8676
8677 sub gen_random_wpa_eapol
8678 {
8679   my $keyver = shift;
8680   my $snonce = shift;
8681
8682   my $ret = "";
8683
8684   # version
8685
8686   my $version = 1; # 802.1X-2001
8687
8688   $ret .= pack ("C*", $version);
8689
8690   my $type = 3;    # means that this EAPOL frame is used to transfer key information
8691
8692   $ret .= pack ("C*", $type);
8693
8694   my $length; # length of remaining data
8695
8696   if ($keyver == 1)
8697   {
8698     $length = 119;
8699   }
8700   else
8701   {
8702     $length = 117;
8703   }
8704
8705   $ret .= pack ("n*", $length);
8706
8707   my $descriptor_type;
8708
8709   if ($keyver == 1)
8710   {
8711     $descriptor_type = 254; # EAPOL WPA key
8712   }
8713   else
8714   {
8715     $descriptor_type = 1; # EAPOL RSN key
8716   }
8717
8718   $ret .= pack ("C*", $descriptor_type);
8719
8720   # key_info is a bit vector:
8721   # generated from these 13 bits: encrypted key data, request, error, secure, key mic, key ack, install, key index (2), key type, key descriptor (3)
8722
8723   my $key_info = 0;
8724
8725   $key_info |= 1 << 8; # set key MIC
8726   $key_info |= 1 << 3; # set if it is a pairwise key
8727
8728   if ($keyver == 1)
8729   {
8730     $key_info |= 1 << 0; # RC4 Cipher, HMAC-MD5 MIC
8731   }
8732   else
8733   {
8734     $key_info |= 1 << 1; # AES Cipher, HMAC-SHA1 MIC
8735   }
8736
8737   $ret .= pack ("n*", $key_info);
8738
8739   my $key_length;
8740
8741   if ($keyver == 1)
8742   {
8743     $key_length = 32;
8744   }
8745   else
8746   {
8747     $key_length = 0;
8748   }
8749
8750   $ret .= pack ("n*", $key_length);
8751
8752   my $replay_counter = 1;
8753
8754   $ret .= pack ("Q>*", $replay_counter);
8755
8756   $ret .= $snonce;
8757
8758   my $key_iv = "\x00" x 16;
8759
8760   $ret .= $key_iv;
8761
8762   my $key_rsc = "\x00" x 8;
8763
8764   $ret .= $key_rsc;
8765
8766   my $key_id = "\x00" x 8;
8767
8768   $ret .= $key_id;
8769
8770   my $key_mic = "\x00" x 16;
8771
8772   $ret .= $key_mic;
8773
8774   my $key_data_len;
8775
8776   if ($keyver == 1)
8777   {
8778     $key_data_len = 24; # length of the key_data (== WPA info)
8779   }
8780   else
8781   {
8782     $key_data_len = 22; # length of the key_data (== RSN info)
8783   }
8784
8785   $ret .= pack ("n*", $key_data_len);
8786
8787   my $key_data = "";
8788
8789   if ($keyver == 1)
8790   {
8791     # wpa info
8792
8793     my $wpa_info = "";
8794
8795     my $vendor_specific_data = "";
8796
8797     my $tag_number = 221; # means it is a vendor specific tag
8798
8799     $vendor_specific_data .= pack ("C*", $tag_number);
8800
8801     my $tag_len = 22;     # length of the remaining "tag data"
8802
8803     $vendor_specific_data .= pack ("C*", $tag_len);
8804
8805     my $vendor_specific_oui = pack ("H*", "0050f2"); # microsoft
8806
8807     $vendor_specific_data .= $vendor_specific_oui;
8808
8809     my $vendor_specific_oui_type = 1; # WPA Information Element
8810
8811     $vendor_specific_data .= pack ("C*", $vendor_specific_oui_type);
8812
8813     my $vendor_specific_wpa_version = 1;
8814
8815     $vendor_specific_data .= pack ("v*", $vendor_specific_wpa_version);
8816
8817     # multicast
8818
8819     my $vendor_specific_multicast_oui = pack ("H*", "0050f2");
8820
8821     $vendor_specific_data .= $vendor_specific_multicast_oui;
8822
8823     my $vendor_specific_multicast_type = 2; # TKIP
8824
8825     $vendor_specific_data .= pack ("C*", $vendor_specific_multicast_type);
8826
8827     # unicast
8828
8829     my $vendor_specific_unicast_count = 1;
8830
8831     $vendor_specific_data .= pack ("v*", $vendor_specific_unicast_count);
8832
8833     my $vendor_specific_unicast_oui = pack ("H*", "0050f2");
8834
8835     $vendor_specific_data .= $vendor_specific_multicast_oui;
8836
8837     my $vendor_specific_unicast_type = 2; # TKIP
8838
8839     $vendor_specific_data .= pack ("C*", $vendor_specific_unicast_type);
8840
8841     # Auth Key Management (AKM)
8842
8843     my $auth_key_management_count = 1;
8844
8845     $vendor_specific_data .= pack ("v*", $auth_key_management_count);
8846
8847     my $auth_key_management_oui = pack ("H*", "0050f2");
8848
8849     $vendor_specific_data .= $auth_key_management_oui;
8850
8851     my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
8852
8853     $vendor_specific_data .= pack ("C*", $auth_key_management_type);
8854
8855     $wpa_info = $vendor_specific_data;
8856
8857     $key_data = $wpa_info;
8858   }
8859   else
8860   {
8861     # rsn info
8862
8863     my $rsn_info = "";
8864
8865     my $tag_number = 48; # RSN info
8866
8867     $rsn_info .= pack ("C*", $tag_number);
8868
8869     my $tag_len = 20;    # length of the remaining "tag_data"
8870
8871     $rsn_info .= pack ("C*", $tag_len);
8872
8873     my $rsn_version = 1;
8874
8875     $rsn_info .= pack ("v*", $rsn_version);
8876
8877     # group cipher suite
8878
8879     my $group_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
8880
8881     $rsn_info .= $group_cipher_suite_oui;
8882
8883     my $group_cipher_suite_type = 4; # AES (CCM)
8884
8885     $rsn_info .= pack ("C*", $group_cipher_suite_type);
8886
8887     # pairwise cipher suite
8888
8889     my $pairwise_cipher_suite_count = 1;
8890
8891     $rsn_info .= pack ("v*", $pairwise_cipher_suite_count);
8892
8893     my $pairwise_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021
8894
8895     $rsn_info .= $pairwise_cipher_suite_oui;
8896
8897     my $pairwise_cipher_suite_type = 4; # AES (CCM)
8898
8899     $rsn_info .= pack ("C*", $pairwise_cipher_suite_type);
8900
8901     # Auth Key Management (AKM)
8902
8903     my $auth_key_management_count = 1;
8904
8905     $rsn_info .= pack ("v*", $auth_key_management_count);
8906
8907     my $auth_key_management_oui = pack ("H*", "000fac"); # Ieee8021
8908
8909     $rsn_info .= $auth_key_management_oui;
8910
8911     my $auth_key_management_type = 2; # Pre-Shared Key (PSK)
8912
8913     $rsn_info .= pack ("C*", $auth_key_management_type);
8914
8915     # RSN Capabilities
8916
8917     # bit vector of these 9 bits: peerkey enabled, management frame protection (MFP) capable, MFP required,
8918     # RSN GTKSA Capabilities (2), RSN PTKSA Capabilities (2), no pairwise Capabilities, Pre-Auth Capabilities
8919
8920     my $rsn_capabilities = pack ("H*", "0000");
8921
8922     $rsn_info .= $rsn_capabilities;
8923
8924     $key_data = $rsn_info;
8925   }
8926
8927   $ret .= $key_data;
8928
8929   return $ret;
8930 }
8931
8932 sub wpa_prf_512
8933 {
8934   my $pmk    = shift;
8935   my $stmac  = shift;
8936   my $bssid  = shift;
8937   my $snonce = shift;
8938   my $anonce = shift;
8939
8940   my $data = "Pairwise key expansion";
8941
8942   $data .= "\x00";
8943
8944   #
8945   # Min(AA, SPA) || Max(AA, SPA)
8946   #
8947
8948   # compare if greater: Min()/Max() on the MACs (6 bytes)
8949
8950   if (memcmp ($stmac, $bssid, 6) < 0)
8951   {
8952     $data .= $stmac;
8953     $data .= $bssid;
8954   }
8955   else
8956   {
8957     $data .= $bssid;
8958     $data .= $stmac;
8959   }
8960
8961   #
8962   # Min(ANonce,SNonce) || Max(ANonce,SNonce)
8963   #
8964
8965   # compare if greater: Min()/Max() on the nonces (32 bytes)
8966
8967   if (memcmp ($snonce, $anonce, 32) < 0)
8968   {
8969     $data .= $snonce;
8970     $data .= $anonce;
8971   }
8972   else
8973   {
8974     $data .= $anonce;
8975     $data .= $snonce;
8976   }
8977
8978   $data .= "\x00";
8979
8980   my $prf_buf = hmac ($data, $pmk, \&sha1);
8981
8982   $prf_buf = substr ($prf_buf, 0, 16);
8983
8984   return $prf_buf;
8985 }
8986
8987 sub memcmp
8988 {
8989   my $str1 = shift;
8990   my $str2 = shift;
8991   my $len  = shift;
8992
8993   my $len_str1 = length ($str1);
8994   my $len_str2 = length ($str2);
8995
8996   if (($len > $len_str1) || ($len > $len_str2))
8997   {
8998     print "ERROR: memcmp () lengths wrong";
8999
9000     exit (1);
9001   }
9002
9003   for (my $i = 0; $i < $len; $i++)
9004   {
9005     my $c_1 = ord (substr ($str1, $i, 1));
9006     my $c_2 = ord (substr ($str2, $i, 1));
9007
9008     return -1 if ($c_1 < $c_2);
9009     return  1 if ($c_1 > $c_2);
9010   }
9011
9012   return 0;
9013 }