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