#!/usr/bin/env perl ## ## Author......: Jens Steube ## License.....: MIT ## use strict; use warnings; use Digest::MD4 qw (md4 md4_hex); use Digest::MD5 qw (md5 md5_hex); use Digest::SHA qw (sha1 sha256 sha384 sha512 sha1_hex sha256_hex sha384_hex sha512_hex); use Digest::HMAC qw (hmac hmac_hex); use Digest::Keccak qw (keccak_256_hex); use Crypt::MySQL qw (password41); use Digest::GOST qw (gost gost_hex); use Digest::HMAC_MD5 qw (hmac_md5); use Digest::CRC qw (crc32); use Crypt::PBKDF2; use Crypt::DES; use Crypt::ECB qw (encrypt PADDING_AUTO PADDING_NONE); use Crypt::CBC; use Crypt::Eksblowfish::Bcrypt qw (bcrypt en_base64); use Crypt::Digest::RIPEMD160 qw (ripemd160_hex); use Crypt::Digest::Whirlpool qw (whirlpool_hex); use Crypt::RC4; use Crypt::ScryptKDF qw (scrypt_hash scrypt_b64); use Crypt::Rijndael; use Crypt::Mode::ECB; use Crypt::UnixCrypt_XS qw (crypt_rounds fold_password base64_to_int24 block_to_base64 int24_to_base64); use MIME::Base64; use Authen::Passphrase::NTHash; use Authen::Passphrase::MySQL323; use Authen::Passphrase::PHPass; use Authen::Passphrase::LANManager; use Encode; use POSIX qw (strftime); use Net::DNS::SEC; use Net::DNS::RR::NSEC3; use Convert::EBCDIC qw (ascii2ebcdic); use Digest::SipHash qw/siphash/; my $hashcat = "./oclHashcat64.bin"; my $MAX_LEN = 55; 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); 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); my %less_fifteen = map { $_ => 1 } qw(500 1600 1800 2400 2410 3200 6300 7400 10500 10700); 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); my @lotus_magic_table = ( 0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a, 0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0, 0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b, 0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a, 0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda, 0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36, 0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8, 0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c, 0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17, 0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60, 0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72, 0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa, 0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd, 0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e, 0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b, 0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf, 0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77, 0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6, 0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3, 0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3, 0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e, 0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c, 0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d, 0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2, 0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46, 0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5, 0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97, 0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5, 0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef, 0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f, 0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf, 0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab ); my @pdf_padding = ( 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ); 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'}; if (scalar @ARGV < 1) { usage_die (); } my $type; my $mode; my $len; $type = shift @ARGV; if ($type ne "verify") { if (scalar @ARGV > 1) { $mode = shift @ARGV; $len = shift @ARGV; } elsif (scalar @ARGV == 1) { $mode = shift @ARGV; $len = 0; } else { $len = 0; } if ($type eq "single") { single ($mode); } elsif ($type eq "passthrough") { passthrough ($mode); } else { usage_die (); } } else { if (scalar @ARGV != 4) { usage_die (); } my $mode = shift @ARGV; my $hash_file = shift @ARGV; my $in_file = shift @ARGV; my $out_file = shift @ARGV; my $db; open (IN, "<", $hash_file) or die ("$hash_file: $!\n"); # clever ? the resulting database could be huge # but we need some way to map lines in hashfile w/ cracks # maybe rli2 way would be more clever (needs sorted input) while (my $line = ) { $line =~ s/[\n\r]*$//; $db->{$line} = undef; } close (IN); verify ($mode, $db, $in_file, $out_file); } sub verify { my $mode = shift; my $db = shift; my $in_file = shift; my $out_file = shift; my $hash_in; my $hash_out; my $iter; my $salt; my $word; my $param; my $param2; my $param3; my $param4; my $param5; my $param6; my $param7; my $param8; my $param9; my $param10; my $param11; open (IN, "<", $in_file) or die ("$in_file: $!\n"); open (OUT, ">", $out_file) or die ("$out_file: $!\n"); my $len; my $base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; my $itoa64_1 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; my $itoa64_2 = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; while (my $line = ) { chomp ($line); $line =~ s/\n$//; $line =~ s/\r$//; # remember always do "exists ($db->{$hash_in})" checks as soon as possible and don't forget it # unsalted 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) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $word = substr ($line, $index + 1); } # hash:salt 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) { # get hash my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); # identify lenghts of both salt and plain my $salt_plain = substr ($line, $index1 + 1); my $num_cols = () = $salt_plain =~ /:/g; my $index2; my $matched = 0; my $start = 0; $word = undef; # fuzzy foreach (my $i = 0; $i < $num_cols; $i++) { $index2 = index ($salt_plain, ":", $start); next if $index2 < 0; $start = $index2 + 1; $salt = substr ($salt_plain, 0, $index2); $word = substr ($salt_plain, $index2 + 1); # can't be true w/ wrong $hash:$salt, otherwise the # algo must have many collisions if (exists ($db->{$hash_in . ":" . $salt})) { $hash_in = $hash_in . ":" . $salt; $matched = 1; last; } } next unless ($matched); # therefore: true == exists ($db->{$hash_in} next unless (! defined ($db->{$hash_in})); } # dcc2 elsif ($mode == 2100) { # get hash my $index1 = index ($line, "\$DCC2\$"); next if $index1 != 0; # iterations my $index2 = index ($line, "#", $index1 + 1); next if $index2 < 1; $iter = substr ($line, $index1 + 6, $index2 - $index1 - 6); # get hash $index1 = index ($line, "#"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1 + 1); # identify lenghts of both salt and plain my $salt_plain = substr ($line, $index2 + 1); my $num_cols = () = $salt_plain =~ /:/g; my $matched = 0; my $start = 0; my $index3 = 0; my $raw_hash; $word = undef; # fuzzy foreach (my $i = 0; $i < $num_cols; $i++) { $index2 = index ($salt_plain, ":", $start); next if $index2 < 0; $start = $index2 + 1; $index3 = rindex ($salt_plain, "#", $index2); $raw_hash = substr ($salt_plain, $index3 + 1, $index2 - $index3 - 1); $salt = substr ($salt_plain, 0, $index3); $word = substr ($salt_plain, $index2 + 1); if (exists ($db->{$hash_in . $salt . "#" .$raw_hash})) { $hash_in = $hash_in . $salt . "#" . $raw_hash; $matched = 1; last; } } next unless ($matched); # therefore: true == exists ($db->{$hash_in} next unless (! defined ($db->{$hash_in})); } # salt:hash guaranteed only : because of hex salt elsif ($mode == 7300) { # split hash and plain my $index1 = index ($line, ":"); next if $index1 < 1; $salt = substr ($line, 0, $index1); $salt = pack ("H*", $salt); my $rest = substr ($line, $index1 + 1); my $index2 = index ($rest, ":"); next if $index2 < 1; $hash_in = substr ($rest, 0, $index2); $word = substr ($rest, $index2 + 1); next unless (exists ($db->{$salt . ":" . $hash_in}) and (! defined ($db->{$hash_in}))); } # 1salthash fixed elsif ($mode == 8100) { # split hash and plain $salt = substr ($line, 1, 8); my $rest = substr ($line, 1 + 8); my $index2 = index ($rest, ":"); next if $index2 < 1; $hash_in = substr ($rest, 0, $index2); $word = substr ($rest, $index2 + 1); next unless (exists ($db->{"1" . $salt . $hash_in}) and (! defined ($db->{$hash_in}))); } # base64 and salt embedded SSHA1, salt length = total lenght - 20 elsif ($mode == 111) { # split hash and plain my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); # remove signature my $plain_base64 = substr ($hash_in, 6); # base64 decode to extract salt my $decoded = decode_base64 ($plain_base64); $salt = substr ($decoded, 20); } # base64 and salt embedded SSHA512, salt length = total length - 64 elsif ($mode == 1711) { # split hash and plain my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); # remove signature my $plain_base64 = substr ($hash_in, 9); # base64 decode to extract salt my $decoded = decode_base64 ($plain_base64); $salt = substr ($decoded, 64); } # OSX (first 8 hex chars is salt) elsif ($mode == 122 || $mode == 1722) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 0, 8); } # MSSQL (2000, 2005 AND 2012), salt after version number elsif ($mode == 131 || $mode == 132 || $mode == 1731) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 6, 8); } # Sybase ASE elsif ($mode == 8000) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 6, 16); } # episerver salts elsif ($mode == 141 || $mode == 1441) { my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($line, "*", 14); #extract salt from base64 my $plain_base64 = substr ($hash_in, 14, $index2 - 14); $salt = decode_base64 ($plain_base64); } # phpass (first 8 after $P$/$H$ -- or $S$ with drupal7) elsif ($mode == 400 || $mode == 7900) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 4, 8); # iterations = 2 ^ cost (where cost == $iter) $iter = index ($itoa64_1, substr ($hash_in, 3, 1)); } # $something$[rounds=iter$]salt$ (get last $, then check iter) elsif ($mode == 500 || $mode == 1600 || $mode == 1800 || $mode == 3300 || $mode == 7400) { my $index1 = index ($line, ":", 30); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $index1 = index ($hash_in, ",", 1); my $index2 = index ($hash_in, "\$", 1); if ($index1 != -1) { if ($index1 < $index2) { $index2 = $index1; } } $param = substr ($hash_in, $index2, 1); $index2++; # rounds= if available $iter = 0; if (substr ($hash_in, $index2, 7) eq "rounds=") { my $old_index = $index2; $index2 = index ($hash_in, "\$", $index2 + 1); next if $index2 < 1; $iter = substr ($hash_in, $old_index + 7, $index2 - $old_index - 7); $index2++; } # get salt my $index3 = rindex ($hash_in, "\$"); next if $index3 < 1; $salt = substr ($hash_in, $index2, $index3 - $index2); } # descrypt (salt in first 2 char) elsif ($mode == 1500) { my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 0, 2); } # bcrypt $something$something$salt.hash elsif ($mode == 3200) { my $index1 = index ($line, ":", 33); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($hash_in, "\$", 4); $iter = substr ($hash_in, 4, $index2 - 4); my $plain_base64 = substr ($hash_in, $index2 + 1, 22); # base64 mapping my $encoded = ""; for (my $i = 0; $i < length ($plain_base64); $i++) { my $char = substr ($plain_base64, $i, 1); $encoded .= substr ($base64, index ($itoa64_2, $char), 1); } $salt = decode_base64 ($encoded); } # md5 (chap) elsif ($mode == 4800) { my $index1 = index ($line, ":"); next if $index1 < 1; my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; my $index3 = index ($line, ":", $index2 + 1); next if $index3 < 1; $salt = substr ($line, $index1 + 1, $index3 - $index1 - 1); $word = substr ($line, $index3 + 1); $hash_in = substr ($line, 0, $index3); } # IKE (md5 and sha1) elsif ($mode == 5300 || $mode == 5400) { my $num_cols = () = $line =~ /:/g; next unless ($num_cols >= 9); my $index1 = -1; my $failed = 0; for (my $j = 0; $j < 9; $j++) { $index1 = index ($line, ":", $index1 + 1); if ($index1 < 1) { $failed = 1; last; } } next if ($failed); $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = rindex ($line, ":", $index1 - 1); $salt = substr ($line, 0, $index2); } # NetNTLMv1 elsif ($mode == 5500) { my $index1 = index ($line, "::"); next if $index1 < 1; my $index2 = index ($line, ":", $index1 + 2); next if $index2 < 1; $index2 = index ($line, ":", $index2 + 1); next if $index2 < 1; $salt = substr ($line, 0, $index2); $index2 = index ($line, ":", $index2 + 1); next if $index2 < 1; $salt .= substr ($line, $index2 + 1, 16); $index2 = index ($line, ":", $index2 + 1); next if $index2 < 1; $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $word = substr ($line, $index2 + 1); } # NetNTLMv2 elsif ($mode == 5600) { my $index1 = index ($line, "::"); next if $index1 < 1; my $index2 = index ($line, ":", $index1 + 2); next if $index2 < 1; $index2 = index ($line, ":", $index2 + 1); next if $index2 < 1; $salt = substr ($line, 0, $index2); $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt .= substr ($line, $index1 + 1, $index2 - $index1 - 1); $hash_in = substr ($line, 0, $index2); # do it later on for this hash mode: # next unless ((exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))) or (exists ($db->{$mod}) and (! defined ($db->{$mod})))); $word = substr ($line, $index2 + 1); } # AIX smd5 something BRACE salt$ elsif ($mode == 6300) { my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($hash_in, "}"); my $index3 = rindex ($hash_in, "\$"); $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1); } # AIX: something$salt$ (no $ at position 1) elsif ($mode == 6400 || $mode == 6500 || $mode == 6700) { my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($hash_in, "}"); my $index3 = index ($hash_in, "\$"); my $index4 = rindex ($hash_in, "\$"); $salt = substr ($hash_in, $index3 + 1, $index4 - $index3 - 1); $iter = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1); } # 1Password, agilekeychain elsif ($mode == 6600) { my $num_cols = () = $line =~ /:/g; next unless ($num_cols > 2); my $index1 = index ($line, ":"); next if $index1 < 1; $iter = substr ($line, 0, $index1); my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; $salt .= substr ($line, $index2 + 1, $index1 - $index2 - 33); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $word = substr ($line, $index1 + 1); } # 1Password, cloudkeychain elsif ($mode == 8200) { my @datas = split (":", $line); next if scalar @datas < 4; my $hash = shift @datas; $salt = shift @datas; $iter = shift @datas; my $data = shift @datas; $hash_in = $hash . ":" . $salt . ":" . $iter . ":" . $data; $salt .= $data; $word = join (":", @datas); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # lastpass (hash:iter:salt) elsif ($mode == 6800) { my $index1 = index ($line, ":", 34); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); # identify lenghts of both salt and plain my $salt_plain = substr ($line, $index1 + 1); my $num_cols = () = $salt_plain =~ /:/g; my $index2; my $matched = 0; my $start = 0; $word = undef; # fuzzy foreach (my $i = 0; $i < $num_cols; $i++) { $index2 = index ($salt_plain, ":", $start); next if $index2 < 1; $start = $index2 + 1; $salt = substr ($salt_plain, 0, $index2); $word = substr ($salt_plain, $index2 + 1); # can't be true w/ wrong $hash:$salt, otherwise the # algo must have many collisions if (exists ($db->{$hash_in . ":" . $salt})) { $hash_in = $hash_in . ":" . $salt; $matched = 1; last; } } next unless ($matched); # therefore: true == exists ($db->{$hash_in} next unless (! defined ($db->{$hash_in})); $index1 = index ($hash_in, ":"); $index2 = index ($hash_in, ":", $index1 + 1); $iter = substr ($hash_in, $index1 + 1, $index2 - $index1 - 1); $salt = substr ($hash_in, $index2 + 1); } # OSX 10.* : $something$iter$salt$ elsif ($mode == 7100) { my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($hash_in, "\$", 5); next if $index2 < 1; my $index3 = index ($hash_in, "\$", $index2 + 1); $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1); $iter = substr ($hash_in, 4, $index2 - 4); next if (int ($iter) < 1); } # grub: something1.something2.something3.iter.salt. elsif ($mode == 7200) { my $index1 = index ($line, ":"); next if $index1 < 1; $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $index2 = index ($hash_in, ".", 19); next if $index2 < 1; my $index3 = index ($hash_in, ".", $index2 + 1); $salt = substr ($hash_in, $index2 + 1, $index3 - $index2 - 1); $iter = substr ($hash_in, 19, $index2 - 19); next if (int ($iter) < 1); } # $something1$something2$something3$something4$salt$ elsif ($mode == 7500 ) { my $index1 = index ($line, "\$", 11); next if $index1 < 1; my $index2 = index ($line, "\$", $index1 + 1); next if $index2 < 1; my $index3 = index ($line, "\$", $index2 + 1); next if $index3 < 1; $index2 = index ($line, ":", $index3 + 1); next if $index2 < 1; $hash_in = substr ($line, 0, $index2); $word = substr ($line, $index2 + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = substr ($hash_in, 11, $index3 - 10); $salt .= substr ($hash_in, $index2 - 32) . "\$\$"; $salt .= substr ($hash_in, $index3 + 1, $index2 - $index3 - 32 - 1); } # $salt$$hash elsif ($mode == 7700 || $mode == 7800) { my @split1 = split (":", $line); next unless scalar @split1 == 2; my @split2 = split ('\$', $split1[0]); next unless scalar @split2 == 2; $hash_in = $split1[0]; $word = $split1[1]; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = $split2[0]; } # DNSSEC elsif ($mode == 8300) { my @datas = split (":", $line); next if scalar @datas != 5; my $hash; my $domain; ($hash, $domain, $salt, $iter, $word) = @datas; $hash_in = $hash . ":" . $domain . ":" . $salt . ":" . $iter; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); $salt = $domain . ":" . $salt; } # RACF elsif ($mode == 8500) { my @line_elements = split (":", $line); next if scalar @line_elements < 2; # get hash and word $hash_in = shift @line_elements; $word = join (":", @line_elements); # get signature my @hash_elements = split ('\*', $hash_in); next unless ($hash_elements[0] eq '$racf$'); $salt = $hash_elements[1]; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # DOMINO 6 elsif ($mode == 8700) { # split hash and plain my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $plain_base64 = substr ($hash_in, 2, -1); ($_, $salt, $param) = domino_decode ($plain_base64); } # PHPS elsif ($mode == 2612) { next unless (substr ($line, 0, 6) eq '$PHPS$'); # get hash my $index1 = index ($line, "\$", 6); next if $index1 < 1; $salt = substr ($line, 6, $index1 - 6); $salt = pack ("H*", $salt); my $index2 = index ($line, "\:", $index1 + 1); next if $index2 < 1; $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Mediawiki B type elsif ($mode == 3711) { next unless (substr ($line, 0, 3) eq '$B$'); # get hash my $index1 = index ($line, "\$", 3); next if $index1 < 1; $salt = substr ($line, 3, $index1 - 3); my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # scrypt elsif ($mode == 8900) { next unless (substr ($line, 0, 7) eq 'SCRYPT:'); # get hash my $index1 = index ($line, ":", 7); next if $index1 < 1; # N my $N = substr ($line, 7, $index1 - 7); my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; # r my $r = substr ($line, $index1 + 1, $index2 - $index1 - 1); $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # p my $p = substr ($line, $index2 + 1, $index1 - $index2 - 1); $param = $N; $param2 = $r; $param3 = $p; $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; # salt $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = decode_base64 ($salt); $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # digest $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # LOTUS 8 elsif ($mode == 9100) { # split hash and plain my $index = index ($line, ":"); next if $index < 1; $hash_in = substr ($line, 0, $index); $word = substr ($line, $index + 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); my $base64_part = substr ($hash_in, 2, -1); ($_, $salt, $iter, $param) = domino_85x_decode ($base64_part); next if ($iter < 1); } # Cisco $8$ - PBKDF2-HMAC-SHA256 elsif ($mode == 9200) { next unless (substr ($line, 0, 3) eq '$8$'); # get hash my $index1 = index ($line, "\$", 3); next if $index1 != 17; my $index2 = index ($line, "\$", $index1 + 1); # salt $salt = substr ($line, 3, $index1 - 3); $index1 = index ($line, ":", $index1 + 1); next if $index1 < 1; # digest $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Cisco $9$ - scrypt elsif ($mode == 9300) { next unless (substr ($line, 0, 3) eq '$9$'); # get hash my $index1 = index ($line, "\$", 3); next if $index1 != 17; my $index2 = index ($line, "\$", $index1 + 1); # salt $salt = substr ($line, 3, $index1 - 3); $index1 = index ($line, ":", $index1 + 1); next if $index1 < 1; # digest $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Office 2007 elsif ($mode == 9400) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 8; next unless (shift @data eq '$office$'); next unless (shift @data eq '2007'); next unless (shift @data eq '20'); my $aes_key_size = shift @data; next unless (($aes_key_size eq '128') || ($aes_key_size eq '256')); next unless (shift @data eq '16'); next unless (length $data[0] == 32); next unless (length $data[1] == 32); next unless (length $data[2] == 40); $salt = shift @data; $param = shift @data; $param2 = $aes_key_size; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Office 2010 elsif ($mode == 9500) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 8; next unless (shift @data eq '$office$'); next unless (shift @data eq '2010'); next unless (shift @data eq '100000'); next unless (shift @data eq '128'); next unless (shift @data eq '16'); next unless (length $data[0] == 32); next unless (length $data[1] == 32); next unless (length $data[2] == 64); $salt = shift @data; $param = shift @data; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Office 2013 elsif ($mode == 9600) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 8; next unless (shift @data eq '$office$'); next unless (shift @data eq '2013'); next unless (shift @data eq '100000'); next unless (shift @data eq '256'); next unless (shift @data eq '16'); next unless (length $data[0] == 32); next unless (length $data[1] == 32); next unless (length $data[2] == 64); $salt = shift @data; $param = shift @data; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Office Old $1 $2 elsif ($mode == 9700) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 4; my $signature = shift @data; next unless (($signature eq '$oldoffice$0') || ($signature eq '$oldoffice$1')); next unless (length $data[0] == 32); next unless (length $data[1] == 32); next unless (length $data[2] == 32); $salt = shift @data; $param = shift @data; $param2 = substr ($signature, 11, 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Office Old $3 $4 elsif ($mode == 9800) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 4; my $signature = shift @data; next unless (($signature eq '$oldoffice$3') || ($signature eq '$oldoffice$4')); next unless (length $data[0] == 32); next unless (length $data[1] == 32); next unless (length $data[2] == 40); $salt = shift @data; $param = shift @data; $param2 = substr ($signature, 11, 1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Django (PBKDF2-SHA256) elsif ($mode == 10000) { next unless (substr ($line, 0, 14) eq 'pbkdf2_sha256$'); # get hash my $index1 = index ($line, "\$", 14); next if $index1 < 1; my $index2 = index ($line, "\$", $index1 + 1); # iter $iter = substr ($line, 14, $index1 - 14); # salt $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); # digest $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # SipHash elsif ($mode == 10100) { my $hash; ($hash, undef, undef, $salt, $word) = split ":", $line; next unless defined $hash; next unless defined $salt; next unless defined $word; next unless (length $hash == 16); next unless (length $salt == 32); my $hash_in = sprintf ("%s:2:4:%s", $hash, $salt); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Cram MD5 elsif ($mode == 10200) { next unless (substr ($line, 0, 10) eq '$cram_md5$'); # get hash my $index1 = index ($line, "\$", 10); next if $index1 < 1; # challenge my $challengeb64 = substr ($line, 10, $index1 - 10); $salt = decode_base64 ($challengeb64); # response my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; my $responseb64 = substr ($line, $index1 + 1, $index2 - $index1 - 1); my $response = decode_base64 ($responseb64); $param = substr ($response, 0, length ($response) - 32 - 1); # -1 is for space $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # SAP CODVN H (PWDSALTEDHASH) iSSHA-1 elsif ($mode == 10300) { next unless (substr ($line, 0, 10) eq '{x-issha, '); # get iterations my $index1 = index ($line, "}", 10); next if $index1 < 1; $iter = substr ($line, 10, $index1 - 10); $iter = int ($iter); # base64 substring my $base64_encoded = substr ($line, $index1 + 1); my $base64_decoded = decode_base64 ($base64_encoded); $salt = substr ($base64_decoded, 20); my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PDF 1.1 - 1.3 (Acrobat 2 - 4) elsif ($mode == 10400) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 11; next unless (shift @data eq '$pdf$1'); next unless (shift @data eq '2'); next unless (shift @data eq '40'); my $P = shift @data; next unless (shift @data eq '0'); next unless (shift @data eq '16'); my $id = shift @data; next unless (shift @data eq '32'); my $u = shift @data; next unless (shift @data eq '32'); my $o = shift @data; $salt = $id; $param = $u; $param2 = $o; $param3 = $P; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PDF 1.4 - 1.6 (Acrobat 5 - 8) elsif ($mode == 10500) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data == 11; my $V = shift @data; $V = substr ($V, 5, 1); my $R = shift @data; next unless (shift @data eq '128'); my $P = shift @data; my $enc = shift @data; next unless (shift @data eq '16'); my $id = shift @data; next unless (shift @data eq '32'); my $u = shift @data; next unless (shift @data eq '32'); my $o = shift @data; $salt = $id; $param = $u; $param2 = $o; $param3 = $P; $param4 = $V; $param5 = $R; $param6 = $enc; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PDF 1.7 Level 3 (Acrobat 9) elsif ($mode == 10600) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data >= 11; next unless (shift @data eq '$pdf$5'); next unless (shift @data eq '5'); next unless (shift @data eq '256'); next unless (shift @data eq '-1028'); next unless (shift @data eq '1'); next unless (shift @data eq '16'); my $id = shift @data; my $rest = join "*", @data; $salt = $id; $param = $rest; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PDF 1.7 Level 8 (Acrobat 10 - 11) elsif ($mode == 10700) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\*/, $hash_in; next unless scalar @data >= 11; next unless (shift @data eq '$pdf$5'); next unless (shift @data eq '6'); next unless (shift @data eq '256'); next unless (shift @data eq '-1028'); next unless (shift @data eq '1'); next unless (shift @data eq '16'); my $id = shift @data; my $rest = join "*", @data; $salt = $id; $param = $rest; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PBKDF2-HMAC-SHA256 elsif ($mode == 10900) { next unless (substr ($line, 0, 7) eq 'sha256:'); # iterations my $index1 = index ($line, ":", 7); next if $index1 < 1; $iter = substr ($line, 7, $index1 - 7); # salt my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = decode_base64 ($salt); # end of digest $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # additional param = output len of pbkdf2 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1); my $digest = decode_base64 ($digest64_encoded); $param = length ($digest); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PostgreSQL MD5 Authentication elsif ($mode == 11100) { next unless (substr ($line, 0, 10) eq '$postgres$'); my $index1 = index ($line, "*", 10); next if $index1 < 1; # the user name $param = substr ($line, 10, $index1 - 10); # get the 4 byte salt my $index2 = index ($line, "*", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); # word / hash $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # MySQL MD5 Authentication elsif ($mode == 11200) { next unless (substr ($line, 0, 9) eq '$mysqlna$'); my $index1 = index ($line, "*", 9); next if $index1 < 1; # salt $salt = substr ($line, 9, $index1 - 9); # word / hash $index1 = index ($line, ":", $index1 + 1); next if $index1 < 1; $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # WPA/WPA2 elsif ($mode == 2500) { print "ERROR: verify currently not supported for WPA/WPA2 (because of oclHashcat's output format)\n"; exit (1); } # Bitcoin/Litecoin wallet.dat elsif ($mode == 11300) { print "ERROR: verify currently not supported for Bitcoin/Litecoin wallet.dat because of unknown crypt data\n"; exit (1); } # SIP digest authentication (MD5) elsif ($mode == 11400) { next unless (substr ($line, 0, 6) eq '$sip$*'); # URI_server: my $index1 = index ($line, "*", 6); next if $index1 < 0; $param10 = substr ($line, 6, $index1 - 6); next if (length ($param10) > 32); # URI_client: my $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param11 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param11) > 32); # user: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; $param = substr ($line, $index2 + 1, $index1 - $index2 - 1); next if (length ($param) > 12); # realm: $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param2) > 20); # method: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; $param6 = substr ($line, $index2 + 1, $index1 - $index2 - 1); next if (length ($param6) > 24); # URI_prefix: $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param7 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param7) > 10); # URI_resource: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; $param8 = substr ($line, $index2 + 1, $index1 - $index2 - 1); next if (length ($param8) > 32); # URI_suffix: $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param9 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param9) > 32); # nonce: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; $salt = substr ($line, $index2 + 1, $index1 - $index2 - 1); next if (length ($salt) > 34); # nonce_client: $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param4) > 12); # nonce_count: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1); next if (length ($param3) > 10); # qop: $index2 = index ($line, "*", $index1 + 1); next if $index2 < 0; $param5 = substr ($line, $index1 + 1, $index2 - $index1 - 1); next if (length ($param5) > 8); # directive: $index1 = index ($line, "*", $index2 + 1); next if $index1 < 0; my $directive = substr ($line, $index2 + 1, $index1 - $index2 - 1); next unless ($directive eq "MD5"); # hash_buf: $index2 = index ($line, ":", $index1 + 1); next if $index2 < 0; my $hex_digest = substr ($line, $index1 + 1, $index2 - $index1 - 1); next unless (length ($hex_digest) == 32); $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # 7-Zip elsif ($mode == 11600) { next unless (substr ($line, 0, 4) eq '$7z$'); # p my $index1 = index ($line, '$', 4); next if $index1 < 0; my $p = substr ($line, 4, $index1 - 4); next unless ($p eq "0"); # num cycle power my $index2 = index ($line, '$', $index1 + 1); next if $index2 < 0; $iter = substr ($line, $index1 + 1, $index2 - $index1 - 1); # seven zip salt length $index1 = index ($line, '$', $index2 + 1); next if $index1 < 0; $param = substr ($line, $index2 + 1, $index1 - $index2 - 1); # seven zip salt $index2 = index ($line, '$', $index1 + 1); next if $index2 < 0; $param2 = substr ($line, $index1 + 1, $index2 - $index1 - 1); # salt len $index1 = index ($line, '$', $index2 + 1); next if $index1 < 0; $param3 = substr ($line, $index2 + 1, $index1 - $index2 - 1); # salt $index2 = index ($line, '$', $index1 + 1); next if $index2 < 0; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = pack ("H*", $salt); # crc / hash $index1 = index ($line, '$', $index2 + 1); next if $index1 < 0; my $crc = substr ($line, $index2 + 1, $index1 - $index2 - 1); # ignore this crc, we don't need to pass it to gen_hash () # data len $index2 = index ($line, '$', $index1 + 1); next if $index2 < 0; $param4 = substr ($line, $index1 + 1, $index2 - $index1 - 1); # unpack size $index1 = index ($line, '$', $index2 + 1); next if $index1 < 0; $param5 = substr ($line, $index2 + 1, $index1 - $index2 - 1); # data $index2 = index ($line, ':', $index1 + 1); next if $index2 < 0; $param6 = substr ($line, $index1 + 1, $index2 - $index1 - 1); $param6 = pack ("H*", $param6); $word = substr ($line, $index2 + 1); $hash_in = substr ($line, 0, $index2); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PBKDF2-HMAC-MD5 elsif ($mode == 11900) { next unless (substr ($line, 0, 4) eq 'md5:'); # iterations my $index1 = index ($line, ":", 4); next if $index1 < 1; $iter = substr ($line, 4, $index1 - 4); # salt my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = decode_base64 ($salt); # end of digest $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # additional param = output len of pbkdf2 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1); my $digest = decode_base64 ($digest64_encoded); $param = length ($digest); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PBKDF2-HMAC-SHA1 elsif ($mode == 12000) { next unless (substr ($line, 0, 5) eq 'sha1:'); # iterations my $index1 = index ($line, ":", 5); next if $index1 < 1; $iter = substr ($line, 5, $index1 - 5); # salt my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = decode_base64 ($salt); # end of digest $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # additional param = output len of pbkdf2 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1); my $digest = decode_base64 ($digest64_encoded); $param = length ($digest); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # PBKDF2-HMAC-SHA512 elsif ($mode == 12100) { next unless (substr ($line, 0, 7) eq 'sha512:'); # iterations my $index1 = index ($line, ":", 7); next if $index1 < 1; $iter = substr ($line, 7, $index1 - 7); # salt my $index2 = index ($line, ":", $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $salt = decode_base64 ($salt); # end of digest $index1 = index ($line, ":", $index2 + 1); next if $index1 < 1; # additional param = output len of pbkdf2 my $digest64_encoded = substr ($line, $index2 + 1, $index1 - $index2 - 1); my $digest = decode_base64 ($digest64_encoded); $param = length ($digest); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # ecryptfs elsif ($mode == 12200) { next unless (substr ($line, 0, 12) eq '$ecryptfs$0$'); # check if default salt $param = 1; $param = 0 if (substr ($line, 12, 2) eq '1$'); # salt $salt = ""; my $index1 = 12; if ($param == 0) # we need to extract the salt { $index1 = index ($line, '$', $index1); next if $index1 < 1; my $index2 = index ($line, '$', $index1 + 1); next if $index2 < 1; $salt = substr ($line, $index1 + 1, $index2 - $index1 - 1); $index1 = $index2; } $index1 = index ($line, ':', $index1 + 1); next if $index1 < 1; # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Oracle T: Type (Oracle 12+) elsif ($mode == 12300) { my $index1 = index ($line, ':'); next if ($index1 != 160); # salt $salt = substr ($line, 128, 32); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # BSDiCrypt, Extended DES elsif ($mode == 12400) { next unless (substr ($line, 0, 1) eq '_'); my $index1 = index ($line, ':', 20); next if ($index1 != 20); # iter $iter = substr ($line, 1, 4); $iter = base64_to_int24 ($iter); # salt $salt = substr ($line, 5, 4); # word / hash $word = substr ($line, $index1 + 1); $hash_in = substr ($line, 0, $index1); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } # Blockchain, My Wallet elsif ($mode == 12700) { my $index1 = index ($line, ':'); next if ($index1 < 0); $hash_in = substr ($line, 0, $index1); $word = substr ($line, $index1 + 1); my (undef, $signature, $data_len, $data_buf) = split '\$', $hash_in; next unless ($signature eq "blockchain"); next unless (($data_len * 2) == length $data_buf); $salt = substr ($data_buf, 0, 32); $param = substr ($data_buf, 32); next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } elsif ($mode == 12800) { ($hash_in, $word) = split ":", $line; next unless defined $hash_in; next unless defined $word; my @data = split /\,/, $hash_in; next unless scalar @data == 4; next unless (shift @data eq 'v1;PPH1_MD4'); $salt = shift @data; $iter = shift @data; next unless (exists ($db->{$hash_in}) and (! defined ($db->{$hash_in}))); } else { print "ERROR: hash mode is not supported\n"; exit (1); } if ($word =~ m/^\$HEX\[[0-9a-fA-F]*\]$/) { $word = pack ("H*", substr ($word, 5, -1)); } # finally generate the hash # special case: if ($mode == 6800) { # check both variations $hash_out = gen_hash ($mode, $word, $salt, $iter, 1); $len = length $hash_out; # == length $alternative if (substr ($line, 0, $len) ne $hash_out) { my $alternative = gen_hash ($mode, $word, $salt, $iter, 2); return unless (substr ($line, 0, $len) eq $alternative); } } elsif ($mode == 8700) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 8900) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 9100) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 190) { $hash_out = gen_hash ($mode, $word, $salt, $iter, 0); $len = length $hash_out; # == length $alternative if (substr ($line, 0, $len) ne $hash_out) { my $alternative = gen_hash ($mode, $word, $salt, $iter, 1); return unless (substr ($line, 0, $len) eq $alternative); } } elsif ($mode == 3300) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 5100) { # check 3 variants (start, middle, end) my $idx = 0; $hash_out = gen_hash ($mode, $word, $salt, $iter, $idx++); $len = length $hash_out; # == length $alternative if (substr ($line, 0, $len) ne $hash_out) { my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++); if (substr ($line, 0, $len) ne $alternative) { my $alternative = gen_hash ($mode, $word, $salt, $iter, $idx++); return unless (substr ($line, 0, $len) eq $alternative); } } } elsif ($mode == 9400) { $hash_out = gen_hash ($mode, $word, $salt, 50000, $param, $param2); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 9500) { $hash_out = gen_hash ($mode, $word, $salt, 100000, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 9600) { $hash_out = gen_hash ($mode, $word, $salt, 100000, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 9700) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 9800) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 10400) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 10500) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param, $param2, $param3, $param4, $param5, $param6); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 10600) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 10700) { $hash_out = gen_hash ($mode, $word, $salt, 0, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 10900) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 11100) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 11400) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6, $param7, $param8, $param9, $param10, $param11); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 11600) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param, $param2, $param3, $param4, $param5, $param6); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 11900) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 12000) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 12100) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 12200) { $hash_out = gen_hash ($mode, $word, $salt, $iter, $param); $len = length $hash_out; return unless (substr ($line, 0, $len) eq $hash_out); } elsif ($mode == 12700) { # this is very special, we can't call gen_hash () because the param part is not always the same # we only know that it should contain the letters "guid" at the beginning of the decryted string my $pbkdf2 = Crypt::PBKDF2->new ( hash_class => 'HMACSHA1', iterations => 10, output_len => 32 ); my $salt_bin = pack ("H*", $salt); my $key = $pbkdf2->PBKDF2 ($salt_bin, $word); my $cipher = Crypt::CBC->new({ key => $key, cipher => "Crypt::Rijndael", iv => $salt_bin, literal_key => 1, header => "none", keysize => 32 }); my $param_bin = pack ("H*", $param); my $decrypted = $cipher->decrypt ($param_bin); my $decrypted_part = substr ($decrypted, 1, 16); return unless ($decrypted_part =~ /"guid"/); $hash_out = $hash_in; } else { $hash_out = gen_hash ($mode, $word, $salt, $iter); $len = length $hash_out; # special cases: if ($mode == 400) { # allow $P$ and $H$ for -m 400 next unless (substr ($line, 3, $len - 3) eq substr ($hash_out, 3)); } elsif ($mode == 5600) { # oclHashcat outputs the user name always upper-case, we need next unless (substr ($line, 0, $len) eq $hash_out); my $found = 0; my $hash_out_lower = lc ($hash_out); for my $key (keys %{$db}) { if (lc ($key) eq $hash_out_lower) { $found = 1; last; } } next unless $found; } else { next unless (substr ($line, 0, $len) eq $hash_out); } } # do not forget "exists ($db->$hash_out)" should be done above! $db->{$hash_out} = $word; print OUT $line . "\n"; } close (IN); close (OUT); } sub passthrough { my $mode = shift || 0; while (my $word_buf = <>) { chomp ($word_buf); next if length ($word_buf) > 31; ## ## gen salt ## my @salt_arr; for (my $i = 0; $i < 256; $i++) { my $c = get_random_chr (0x30, 0x39); push (@salt_arr, $c); } my $salt_buf = join ("", @salt_arr); ## ## gen hash ## my $tmp_hash; 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) { $tmp_hash = gen_hash ($mode, $word_buf, ""); } 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) { my $salt_len = get_random_num (1, 15); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32)); } elsif ($mode == 21) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2)); } elsif ($mode == 22) { my $salt_len = get_random_num (1, 15); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } 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) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 8)); } elsif ($mode == 112) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20)); } elsif ($mode == 121) { my $salt_len = get_random_num (1, 9); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 141 || $mode == 1441) { my $salt_len = get_random_num (1, 15); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 1100) { my $salt_len = get_random_num (1, 19); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 1500) { next if length ($word_buf) > 8; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 2)); } elsif ($mode == 2100) { next if length ($word_buf) > 13; my $salt_len = get_random_num (1, 19); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 2410) { next if length ($word_buf) > 15; my $salt_len = get_random_num (1, 15); my $word_len = length ($word_buf); $salt_len = min ($salt_len, 15 - $word_len); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 2500) { next if length ($word_buf) < 8; my $salt_len = get_random_num (0, 32); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 2611) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 3)); } elsif ($mode == 2612) { my $salt_len = get_random_num (1, 22); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 2711) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 30)); } elsif ($mode == 2811) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5)); } elsif ($mode == 3000) { next if length ($word_buf) > 7; $tmp_hash = gen_hash ($mode, $word_buf, ""); } elsif ($mode == 3100) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 10)); } elsif ($mode == 3200 || $mode == 5800 || $mode == 6400 || $mode == 6500 || $mode == 6700 || $mode == 7400 || $mode == 3300 || $mode == 8000 || $mode == 9100 || $mode == 12200) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16)); } elsif ($mode == 3800 || $mode == 4900) { my $salt_len = get_random_num (1, 11); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 4800) { $salt_buf = get_random_md5chap_salt (substr ($salt_buf, 0, 16)); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 5300 || $mode == 5400) { $salt_buf = get_random_ike_salt (); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 5500) { my $user_len = get_random_num (0, 15); my $domain_len = get_random_num (0, 15); $salt_buf = get_random_netntlmv1_salt ($user_len, $domain_len); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 5600) { my $user_len = get_random_num (0, 15); my $domain_len = get_random_num (0, 15); $salt_buf = get_random_netntlmv2_salt ($user_len, $domain_len); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 6600) { $salt_buf = get_random_agilekeychain_salt (); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 6800) { my $email_len = get_random_num (1, 15); my $email = ""; for (my $i = 0; $i < $email_len; $i++) { $email .= get_random_chr (0x61, 0x7a); } $email .= '@trash-mail.com'; $tmp_hash = gen_hash ($mode, $word_buf, $email); } elsif ($mode == 7100) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64)); } elsif ($mode == 7200) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 128)); } elsif ($mode == 7300) { my $salt_len = get_random_num (32, 256); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 7500) { $salt_buf = get_random_kerberos5_salt (substr ($salt_buf, 0, 16)); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 7700) { next if length ($word_buf) > 8; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12)); } elsif ($mode == 7800) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 12)); } elsif ($mode == 8200) { $salt_buf = get_random_cloudkeychain_salt (); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 8300) { $salt_buf = get_random_dnssec_salt (); $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); } elsif ($mode == 8400 || $mode == 11200) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 40)); } elsif ($mode == 8500) { next if length ($word_buf) > 8; my $salt_len = get_random_num (1, 9); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 8600) { next if length ($word_buf) > 16; $tmp_hash = gen_hash ($mode, $word_buf, ""); } elsif ($mode == 8700) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 5)); } elsif ($mode == 9200 || $mode == 9300) { my $salt_len = 14; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800) { next if length ($word_buf) > 19; my $salt_len = 32; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 10100) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32)); } elsif ($mode == 10300) { my $salt_len = get_random_num (4, 15); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 10400) { next if length ($word_buf) > 31; my $salt_len = 32; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 10500) { next if length ($word_buf) > 15; my $salt_len = 32; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 10600) { next if length ($word_buf) > 31; my $salt_len = 32; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 10700) { next if length ($word_buf) > 15; my $salt_len = 32; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 11000) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 56)); } elsif ($mode == 11300) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 16)); } elsif ($mode == 11400) { next if length ($word_buf) > 24; my $salt_len = get_random_num (1, 15); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 11600) { my $salt_len = get_random_num (0, 16); $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, $salt_len)); } elsif ($mode == 12400) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 4)); } elsif ($mode == 12600) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 64)); } elsif ($mode == 12700) { $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 32)); } elsif ($mode == 12800) { next if length ($word_buf) > 24; $tmp_hash = gen_hash ($mode, $word_buf, substr ($salt_buf, 0, 20)); } else { print "ERROR: Unsupported hash type\n"; exit (1); } print $tmp_hash, "\n"; } } sub single { my $mode = shift; if (defined $mode) { @modes = ($mode); } for (my $j = 0; $j < scalar @modes; $j++) { my $mode = $modes[$j]; 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) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 0); } else { rnd ($mode, $i, 0); } } } 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) { my $salt_len = get_random_num (1, 15); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 11 || $mode == 12 || $mode == 7600 || $mode == 12300) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 32); } else { rnd ($mode, $i, 32); } } } elsif ($mode == 21 || $mode == 22) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 2); } else { rnd ($mode, $i, 2); } } } 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) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 8); } else { rnd ($mode, $i, 8); } } } elsif ($mode == 112) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 20); } else { rnd ($mode, $i, 20); } } } 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) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 16); } else { rnd ($mode, $i, 16); } } } if ($mode == 1100) { my $salt_len = get_random_num (1, 19); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 1500) { for (my $i = 1; $i < 9; $i++) { if ($len != 0) { rnd ($mode, $len, 2); } else { rnd ($mode, $i, 2); } } } elsif ($mode == 2100) { my $salt_len = get_random_num (1, 19); for (my $i = 1; $i < 13; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 2500) { my $salt_len = get_random_num (0, 32); for (my $i = 8; $i < 16; $i++) { my $generate_from_len = 0; if ($len != 0) { if ($len < 8) { $len += 7; } rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 2611) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 3); } else { rnd ($mode, $i, 3); } } } elsif ($mode == 2612) { my $salt_len = get_random_num (1, 22); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 2711) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 30); } else { rnd ($mode, $i, 30); } } } elsif ($mode == 2811) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 5); } else { rnd ($mode, $i, 5); } } } elsif ($mode == 3000) { for (my $i = 1; $i < 8; $i++) { if ($len != 0) { rnd ($mode, $len, 0); } else { rnd ($mode, $i, 0); } } } elsif ($mode == 3100) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 10); } else { rnd ($mode, $i, 10); } } } elsif ($mode == 3800 || $mode == 4900) { my $salt_len = get_random_num (1, 11); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 5500 || $mode == 5600) { my $salt_len; for (my $i = 1; $i < 27; $i++) { $salt_len = get_random_num (1, 15); if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 5800) { for (my $i = 1; $i < 14; $i++) { if ($len != 0) { rnd ($mode, $len, 16); } else { rnd ($mode, $i, 16); } } } elsif ($mode == 6800) { my $salt_len = get_random_num (8, 25); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 7100) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 64); } else { rnd ($mode, $i, 64); } } } elsif ($mode == 7200) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 128); } else { rnd ($mode, $i, 128); } } } elsif ($mode == 7300) { my $salt_len = get_random_num (32, 255); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 7500) { for (my $i = 1; $i < 27; $i++) { if ($len != 0) { rnd ($mode, $len, 16); } else { rnd ($mode, $i, 16); } } } elsif ($mode == 7700) { my $salt_len = get_random_num (1, 12); for (my $i = 1; $i < 9; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 7800) { my $salt_len = get_random_num (1, 12); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 8400 || $mode == 11200) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 40); } else { rnd ($mode, $i, 40); } } } elsif ($mode == 8500) { my $salt_len = get_random_num (1, 8); for (my $i = 1; $i < 9; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 8600) { for (my $i = 1; $i < 17; $i++) { if ($len != 0) { rnd ($mode, $len, 0); } else { rnd ($mode, $i, 0); } } } elsif ($mode == 8700) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 5); } else { rnd ($mode, $i, 5); } } } elsif ($mode == 9200 || $mode == 9300) { my $salt_len = 14; for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 9400 || $mode == 9500 || $mode == 9600 || $mode == 9700 || $mode == 9800) { my $salt_len = 32; for (my $i = 1; $i < 20; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 10100) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 32); } else { rnd ($mode, $i, 32); } } } elsif ($mode == 10300) { my $salt_len = get_random_num (4, 15); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 10400 || $mode == 10600) { my $salt_len = 32; for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 10500 || $mode == 10700) { my $salt_len = 32; for (my $i = 1; $i < 16; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 11000) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 56); } else { rnd ($mode, $i, 56); } } } elsif ($mode == 11300) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 16); } else { rnd ($mode, $i, 16); } } } elsif ($mode == 11400) { for (my $i = 1; $i < 24; $i++) { if ($len != 0) { rnd ($mode, $len, 16); } else { rnd ($mode, $i, 16); } } } elsif ($mode == 11600) { my $salt_len = get_random_num (0, 16); for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, $salt_len); } else { rnd ($mode, $i, $salt_len); } } } elsif ($mode == 12400) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 4); } else { rnd ($mode, $i, 4); } } } elsif ($mode == 12600) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 64); } else { rnd ($mode, $i, 64); } } } elsif ($mode == 12700) { for (my $i = 1; $i < 32; $i++) { if ($len != 0) { rnd ($mode, $len, 32); } else { rnd ($mode, $i, 32); } } } elsif ($mode == 12800) { for (my $i = 1; $i < 25; $i++) { if ($len != 0) { rnd ($mode, $len, 20); } else { rnd ($mode, $i, 20); } } } } } exit; sub gen_hash { my $mode = shift; my $word_buf = shift; my $salt_buf = shift; my $iter = shift; my $additional_param = shift; my $additional_param2 = shift; my $additional_param3 = shift; my $additional_param4 = shift; my $additional_param5 = shift; my $additional_param6 = shift; my $additional_param7 = shift; my $additional_param8 = shift; my $additional_param9 = shift; my $additional_param10 = shift; my $additional_param11 = shift; ## ## gen hash ## my $tmp_hash; my $hash_buf; if ($mode == 0) { $hash_buf = md5_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 10) { $hash_buf = md5_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 11) { $hash_buf = md5_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 12) { $hash_buf = md5_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 20) { $hash_buf = md5_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 21) { $hash_buf = md5_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 22) { my $itoa64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; my $salt_suffix = "Administration Tools"; my $pass = sprintf ("%s:%s:%s", $salt_buf, $salt_suffix, $word_buf); $hash_buf = md5 ($pass); my $res = ""; for (my $pos = 0; $pos < 16; $pos += 2) { my $octet1 = ord (substr ($hash_buf, $pos + 0, 1)); my $octet2 = ord (substr ($hash_buf, $pos + 1, 1)); my $num = ($octet1 <<8 & 0xff00) | ($octet2 & 0xff); my $idx1 = $num >> 12 & 0x0f; my $idx2 = $num >> 6 & 0x3f; my $idx3 = $num & 0x3f; $res = $res . substr ($itoa64, $idx1, 1) . substr ($itoa64, $idx2, 1) . substr ($itoa64, $idx3, 1); } my $obfuscate_str = "nrcstn"; my @obfuscate_pos = (0, 6, 12, 17, 23, 29); foreach my $pos (keys @obfuscate_pos) { my $idx = $obfuscate_pos[$pos]; my $before = substr ($res, 0, $idx); my $char = substr ($obfuscate_str, $pos, 1); my $after = substr ($res, $idx); $res = sprintf ("%s%s%s", $before, $char, $after); } $tmp_hash = sprintf ("%s:%s", $res, $salt_buf); } elsif ($mode == 23) { $hash_buf = md5_hex ($salt_buf . "\nskyper\n" . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 30) { $hash_buf = md5_hex (encode ("UTF-16LE", $word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 40) { $hash_buf = md5_hex ($salt_buf . encode ("UTF-16LE", $word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 50) { $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 60) { $hash_buf = hmac_hex ($word_buf, $salt_buf, \&md5, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 100) { $hash_buf = sha1_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 101) { $hash_buf = sha1 ($word_buf); my $base64_buf = encode_base64 ($hash_buf); chomp ($base64_buf); $tmp_hash = sprintf ("{SHA}%s", $base64_buf); } elsif ($mode == 110) { $hash_buf = sha1_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 111) { $hash_buf = sha1 ($word_buf . $salt_buf); my $base64_buf = encode_base64 ($hash_buf . $salt_buf); chomp ($base64_buf); $tmp_hash = sprintf ("{SSHA}%s", $base64_buf); } elsif ($mode == 112) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha1_hex ($word_buf . $salt_buf_bin); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 120) { $hash_buf = sha1_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 121) { $hash_buf = sha1_hex (lc ($salt_buf) . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 122) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha1_hex ($salt_buf_bin . $word_buf); $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf); } elsif ($mode == 130) { $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 131) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha1_hex (encode ("UTF-16LE", uc ($word_buf)) . $salt_buf_bin); $tmp_hash = sprintf ("0x0100%s%s%s", $salt_buf, "0" x 40, $hash_buf); } elsif ($mode == 132) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha1_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin); $tmp_hash = sprintf ("0x0100%s%s", $salt_buf, $hash_buf); } elsif ($mode == 140) { $hash_buf = sha1_hex ($salt_buf . encode ("UTF-16LE", $word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 141) { $hash_buf = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf)); my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); my $base64_hash_buf = encode_base64 ($hash_buf); $base64_hash_buf = substr ($base64_hash_buf, 0, 27); $tmp_hash = sprintf ("\$episerver\$*0*%s*%s", $base64_salt_buf, $base64_hash_buf); } elsif ($mode == 150) { $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 160) { $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha1, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 190) { $hash_buf = sha1_hex ($word_buf); my $variant = int (rand (2)); if (defined ($additional_param)) { $variant = $additional_param; } if ($variant == 1) { substr ($hash_buf, 0, 5) = "00000"; } $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 200) { my $ppr = Authen::Passphrase::MySQL323->new (passphrase => $word_buf); $hash_buf = $ppr->hash_hex; $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 300) { $hash_buf = substr (password41 ($word_buf), 1); $hash_buf = lc ($hash_buf); # useful for 'not matched' check only $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 400) { my $cost = 11; if (length ($iter)) { $cost = $iter; } my $ppr = Authen::Passphrase::PHPass->new ( cost => $cost, salt => $salt_buf, passphrase => $word_buf, ); $hash_buf = $ppr->as_rfc2307; $tmp_hash = sprintf ("%s", substr ($hash_buf, 7)); } elsif ($mode == 500) { my $iterations = 1000; if (defined ($iter)) { if ($iter > 0) { $iterations = int ($iter); } } $hash_buf = md5_crypt ('$1$', $iterations, $word_buf, $salt_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 900) { $hash_buf = md4_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1000) { $hash_buf = md4_hex (encode ("UTF-16LE", $word_buf)); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1100) { $hash_buf = md4_hex (md4 (encode ("UTF-16LE", $word_buf)) . encode ("UTF-16LE", lc ($salt_buf))); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1400) { $hash_buf = sha256_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1410) { $hash_buf = sha256_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1420) { $hash_buf = sha256_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1430) { $hash_buf = sha256_hex (encode ("UTF-16LE", $word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1440) { $hash_buf = sha256_hex ($salt_buf . encode ("UTF-16LE", $word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1441) { $hash_buf = sha256 ($salt_buf . encode ("UTF-16LE", $word_buf)); my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); my $base64_hash_buf = encode_base64 ($hash_buf); chomp ($base64_hash_buf); $base64_hash_buf = substr ($base64_hash_buf, 0, 43); $tmp_hash = sprintf ("\$episerver\$*1*%s*%s", $base64_salt_buf, $base64_hash_buf); } elsif ($mode == 1450) { $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha256, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1460) { $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha256, 64); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1500) { $hash_buf = crypt ($word_buf, $salt_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1600) { my $iterations = 1000; if (defined ($iter)) { if ($iter > 0) { $iterations = int ($iter); } } $hash_buf = md5_crypt ('$apr1$', $iterations, $word_buf, $salt_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1700) { $hash_buf = sha512_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 1710) { $hash_buf = sha512_hex ($word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1711) { $hash_buf = sha512_hex ($word_buf . $salt_buf); my $base64_buf = encode_base64 (pack ("H*", $hash_buf) . $salt_buf); $base64_buf =~ s/[ \n]//g; $tmp_hash = sprintf ("{SSHA512}%s", $base64_buf); } elsif ($mode == 1720) { $hash_buf = sha512_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1730) { $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1740) { $hash_buf = sha512_hex ($salt_buf . encode ("UTF-16LE", $word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1722) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha512_hex ($salt_buf_bin . $word_buf); $tmp_hash = sprintf ("%s%s", $salt_buf, $hash_buf); } elsif ($mode == 1731) { my $salt_buf_bin = pack ("H*", $salt_buf); $hash_buf = sha512_hex (encode ("UTF-16LE", $word_buf) . $salt_buf_bin); $tmp_hash = sprintf ("0x0200%s%s", $salt_buf, $hash_buf); } elsif ($mode == 1750) { $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha512, 128); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1760) { $hash_buf = hmac_hex ($word_buf, $salt_buf, \&sha512, 128); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 1800) { my $iterations = 5000; if (defined ($iter)) { if ($iter > 0) { $iterations = int ($iter); } } $hash_buf = sha512_crypt ($iterations, $word_buf, $salt_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 2100) { my $iterations = 10240; if (length ($iter)) { $iterations = int ($iter); } my $salt = encode ("UTF-16LE", lc ($salt_buf)); my $pbkdf2 = Crypt::PBKDF2->new ( hash_class => 'HMACSHA1', iterations => $iterations, output_len => 16, salt_len => length ($salt), ); $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 ($salt, md4 (md4 (encode ("UTF-16LE", $word_buf)) . $salt))); $tmp_hash = sprintf ("\$DCC2\$%i#%s#%s", $iterations, $salt_buf, $hash_buf); } elsif ($mode == 2400) { $tmp_hash = sprintf ("%s", pseudo_base64 (Digest::MD5::md5 ($word_buf . "\0" x (16 - length ($word_buf))))); } elsif ($mode == 2410) { my $salt_len = length ($salt_buf); my $salt_len_max4 = ($salt_len < 4) ? $salt_len : 4; 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))); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 2500) { my ($bssid, $stmac, $snonce, $anonce, $eapol, $keyver, $eapol_size); if (! defined ($additional_param)) { # random stuff $bssid = randbytes (6); $stmac = randbytes (6); $snonce = randbytes (32); $anonce = randbytes (32); $keyver = get_random_num (1, 3); # 1 or 2 # eapol: # should be "validly" generated, but in theory could be anything for us also: # $eapol = "\x00" x 121; # works too, but let's generate it correctly $eapol = gen_random_wpa_eapol ($keyver, $snonce); } else { $bssid = $additional_param; $stmac = $additional_param2; $snonce = $additional_param3; $anonce = $additional_param4; $keyver = $additional_param5; $eapol = $additional_param6; } $eapol_size = length ($eapol); # constants my $iterations = 4096; # # START # # generate the Pairwise Master Key (PMK) my $pbkdf2 = Crypt::PBKDF2->new ( hash_class => 'HMACSHA1', iterations => $iterations, output_len => 32, ); my $pmk = $pbkdf2->PBKDF2 ($salt_buf, $word_buf); # Pairwise Transient Key (PTK) transformation my $ptk = wpa_prf_512 ($pmk, $stmac, $bssid, $snonce, $anonce); # generate the Message Integrity Code (MIC) my $mic = ""; if ($keyver == 1) # WPA1 => MD5 { $mic = hmac ($eapol, $ptk, \&md5); } else # WPA2 => SHA1 { $mic = hmac ($eapol, $ptk, \&sha1); } $mic = substr ($mic, 0, 16); # # format the binary output # $hash_buf = ""; # first the essid (NULL-padded up to the first 36 bytes) $hash_buf .= $salt_buf; $hash_buf .= "\x00" x (36 - length ($salt_buf)); # the 2 MAC addresses $hash_buf .= $bssid; $hash_buf .= $stmac; # nonces $hash_buf .= $snonce; $hash_buf .= $anonce; # eapol $hash_buf .= $eapol; $hash_buf .= "\x00" x (256 - $eapol_size); # eapol size $hash_buf .= pack ("L*", $eapol_size); # key version $hash_buf .= pack ("L*", $keyver); # and finally: the key mic $hash_buf .= $mic; # base64 encode the output $tmp_hash = encode_base64 ($hash_buf, ''); } elsif ($mode == 2600) { $hash_buf = md5_hex (md5_hex ($word_buf)); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 2611) { $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 2612) { my $salt_buf_hex = unpack ("H*", $salt_buf); $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf); $tmp_hash = sprintf ("\$PHPS\$%s\$%s", $salt_buf_hex, $hash_buf); } elsif ($mode == 2711) { $hash_buf = md5_hex (md5_hex ($word_buf) . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 2811) { $hash_buf = md5_hex (md5_hex ($salt_buf) . md5_hex ($word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3000) { my $ppr = Authen::Passphrase::LANManager->new ("passphrase" => $word_buf); $hash_buf = $ppr->hash_hex; $tmp_hash = sprintf ("%s", substr ($hash_buf, 0, 16)); } elsif ($mode == 3100) { $hash_buf = oracle_hash ($salt_buf, $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3200) { my $cost = "05"; if (length ($iter)) { $cost = $iter; } $tmp_hash = bcrypt ($word_buf, sprintf ('$2a$%s$%s$', $cost, en_base64 ($salt_buf))); } elsif ($mode == 3300) { my $iterations = 904; if (length ($iter)) { $iterations = int ($iter); } my $variant = "\$"; if (defined ($additional_param)) { $variant = $additional_param; } my $prefix = sprintf ("\$md5%srounds=%i\$%s", $variant, $iterations, $salt_buf); $iterations += 4096; $hash_buf = sun_md5 ($word_buf, $prefix, $iterations); $tmp_hash = sprintf ("%s\$%s", $prefix, $hash_buf); } elsif ($mode == 3500) { $hash_buf = md5_hex (md5_hex (md5_hex ($word_buf))); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 3610) { $hash_buf = md5_hex (md5_hex ($salt_buf) . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3710) { $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3711) { $hash_buf = md5_hex ($salt_buf . "-" . md5_hex ($word_buf)); $tmp_hash = sprintf ("\$B\$%s\$%s", $salt_buf, $hash_buf); } elsif ($mode == 3720) { $hash_buf = md5_hex ($word_buf . md5_hex ($salt_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3800) { $hash_buf = md5_hex ($salt_buf . $word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 3910) { $hash_buf = md5_hex (md5_hex ($word_buf) . md5_hex ($salt_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 4010) { $hash_buf = md5_hex ($salt_buf . md5_hex ($salt_buf . $word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 4110) { $hash_buf = md5_hex ($salt_buf . md5_hex ($word_buf . $salt_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 4210) { $hash_buf = md5_hex ($salt_buf . "\x00" . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 4300) { $hash_buf = md5_hex (uc (md5_hex ($word_buf))); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 4400) { $hash_buf = md5_hex (sha1_hex ($word_buf)); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 4500) { $hash_buf = sha1_hex (sha1_hex ($word_buf)); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 4600) { $hash_buf = sha1_hex (sha1_hex (sha1_hex ($word_buf))); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 4700) { $hash_buf = sha1_hex (md5_hex ($word_buf)); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 4800) { my $index = rindex ($salt_buf, ":"); my $salt = substr ($salt_buf, 0, $index); my $salt_bin = pack ("H*", $salt); my $chap_sign = substr ($salt_buf, $index + 1); my $chap_sign_bin = pack ("H*", $chap_sign); $hash_buf = md5_hex ($chap_sign_bin . $word_buf . $salt_bin); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 4900) { $hash_buf = sha1_hex ($salt_buf . $word_buf . $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 5000) { $hash_buf = keccak_256_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 5100) { my $pos; if (! defined ($additional_param)) { $pos = 0; } else { $pos = $additional_param * 8 unless ($additional_param > 2); } $hash_buf = md5_hex ($word_buf); $tmp_hash = sprintf ("%s", substr ($hash_buf, $pos, 16)); } elsif ($mode == 5300) { my @salt_arr = split (":", $salt_buf); my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]); my $nr_buf = pack ("H*", $salt_arr[6] . $salt_arr[7]); my $hash_buf = hmac ($nr_buf , $word_buf, \&md5, 64); $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&md5, 64); $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf); } elsif ($mode == 5400) { my @salt_arr = split (":", $salt_buf); my $msg_buf = pack ("H*", $salt_arr[0] . $salt_arr[1] . $salt_arr[2] . $salt_arr[3] . $salt_arr[4] . $salt_arr[5]); my $nr_buf = pack ("H*", $salt_arr[6] . $salt_arr[7]); my $hash_buf = hmac ($nr_buf , $word_buf, \&sha1, 64); $hash_buf = hmac_hex ($msg_buf, $hash_buf, \&sha1, 64); $tmp_hash = sprintf ("%s:%s", $salt_buf, $hash_buf); } elsif ($mode == 5500) { my $index1 = index ($salt_buf, "::"); my $user = substr ($salt_buf, 0, $index1); my $index2 = index ($salt_buf, ":", $index1 + 2); my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2); my $len = length (substr ($salt_buf, $index2 + 1)); my $c_challenge_hex; if ($len > 32) { $c_challenge_hex = substr ($salt_buf, $index2 + 1, 48); $index2 += 32; } else { $c_challenge_hex = substr ($salt_buf, $index2 + 1, 16); $c_challenge_hex .= 00 x 32; } my $c_challenge = pack ("H*", substr ($c_challenge_hex, 0, 16)); my $s_challenge_hex = substr ($salt_buf, $index2 + 17, 16); my $s_challenge = pack ("H*", $s_challenge_hex); my $challenge = substr (md5 ($s_challenge . $c_challenge), 0, 8); my $ntresp; my $nthash = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash . "\x00" x 5; $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash, 0, 7)), "DES", $challenge, PADDING_NONE); $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash, 7, 7)), "DES", $challenge, PADDING_NONE); $ntresp .= Crypt::ECB::encrypt (setup_des_key (substr ($nthash, 14, 7)), "DES", $challenge, PADDING_NONE); $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $c_challenge_hex, unpack ("H*", $ntresp), $s_challenge_hex); } elsif ($mode == 5600) { my $index1 = index ($salt_buf, "::"); my $user = substr ($salt_buf, 0, $index1); my $index2 = index ($salt_buf, ":", $index1 + 2); my $domain = substr ($salt_buf, $index1 + 2, $index2 - $index1 - 2); my $s_challenge_hex = substr ($salt_buf, $index2 + 1, 16); my $s_challenge = pack ("H*", $s_challenge_hex); my $temp_hex = substr ($salt_buf, $index2 + 17); my $temp = pack ("H*", $temp_hex); my $nthash = Authen::Passphrase::NTHash->new (passphrase => $word_buf)->hash; my $identity = Encode::encode ("UTF-16LE", uc ($user) . $domain); $hash_buf = hmac_hex ($s_challenge . $temp, hmac ($identity, $nthash, \&md5, 64), \&md5, 64); $tmp_hash = sprintf ("%s::%s:%s:%s:%s", $user, $domain, $s_challenge_hex, $hash_buf, $temp_hex); } elsif ($mode == 5700) { $hash_buf = sha256 ($word_buf); my $base64_buf = encode_base64 ($hash_buf); $tmp_hash = ""; for (my $i = 0; $i < 43; $i++) { $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($base64_buf, $i, 1)}; } } elsif ($mode == 5800) { $hash_buf = androidpin_hash ($word_buf, $salt_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 6000) { $hash_buf = ripemd160_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 6100) { $hash_buf = whirlpool_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 6300) { my $iterations = 1000; # hard coded by the AIX format $hash_buf = md5_crypt ('', $iterations, $word_buf, $salt_buf); $tmp_hash = sprintf ("{smd5}%s", $hash_buf); } elsif ($mode == 6400) { my $iterations = 64; if (length ($iter)) { $iterations = 1 << int ($iter); } $hash_buf = aix_ssha256_pbkdf2 ($word_buf, $salt_buf, $iterations); $tmp_hash = sprintf ("{ssha256}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf); } elsif ($mode == 6500) { my $iterations = 64; if (length ($iter)) { $iterations = 1 << int ($iter); } $hash_buf = aix_ssha512_pbkdf2 ($word_buf, $salt_buf, $iterations); $tmp_hash = sprintf ("{ssha512}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf); } elsif ($mode == 6600) { my $iterations = 1000; if (length ($iter)) { $iterations = int ($iter); } my $salt_hex = substr ($salt_buf, 0, 16); my $salt = pack ("H*", $salt_hex); my $prefix = substr ($salt_buf, 16, 2016); my $iv_hex = substr ($salt_buf, 2032); my $iv = pack ("H*", $iv_hex); my $data = pack ("H*", "10101010101010101010101010101010"); my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, output_len => 16 ); my $key = $pbkdf2->PBKDF2 ($salt, $word_buf); my $cipher = Crypt::CBC->new({ key => $key, cipher => "Crypt::Rijndael", iv => $iv, literal_key => 1, header => "none", keysize => 16 }); my $encrypted = unpack ("H*", $cipher->encrypt ($data)); $hash_buf = substr ($encrypted, 0, 32); $tmp_hash = sprintf ("%i:%s:%s%s%s", $iterations, $salt_hex, $prefix, $iv_hex, $hash_buf); } elsif ($mode == 6700) { my $iterations = 64; if (length ($iter)) { $iterations = 1 << int ($iter); } $hash_buf = aix_ssha1_pbkdf2 ($word_buf, $salt_buf, $iterations); $tmp_hash = sprintf ("{ssha1}%02i\$%s\$%s", log ($iterations) / log (2), $salt_buf, $hash_buf); } elsif ($mode == 6800) { my $variant = $additional_param; if (! defined ($variant)) { $variant = int (rand (2)); } my $iterations = 500; if (length ($iter)) { $iterations = int ($iter); } my $iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, output_len => 32 ); my $key = $pbkdf2->PBKDF2 ($salt_buf, $word_buf); my $cipher = Crypt::CBC->new({ key => $key, cipher => "Crypt::Rijndael", iv => $iv, literal_key => 1, header => "none", keysize => 32 }); if ($variant == 1) { my $encrypt = $cipher->encrypt (substr ($salt_buf, 0, 16)); $hash_buf = substr (unpack ("H*", $encrypt), 0, 32); } else { my $verifier = "lastpass rocks\x02\x02"; $hash_buf = unpack ("H*", substr ($cipher->encrypt ($verifier), 0, 16)); } $tmp_hash = sprintf ("%s:%i:%s", $hash_buf, $iterations, $salt_buf); } elsif ($mode == 6900) { $hash_buf = gost_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 7100) { my $iterations = 1024; if (length ($iter)) { $iterations = int ($iter); } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), iterations => $iterations ); $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf)); $tmp_hash = sprintf ("\$ml\$%i\$%s\$%0128s", $iterations, $salt_buf, $hash_buf); } elsif ($mode == 7200) { my $iterations = 1024; if (length ($iter)) { $iterations = int ($iter); } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), iterations => $iterations ); $hash_buf = unpack ("H*", $pbkdf2->PBKDF2 (pack ("H*", $salt_buf), $word_buf)); $tmp_hash = sprintf ("grub.pbkdf2.sha512.%i.%s.%0128s", $iterations, $salt_buf, $hash_buf); } elsif ($mode == 7300) { $hash_buf = hmac_hex ($salt_buf, $word_buf, \&sha1); $tmp_hash = sprintf ("%s:%s", unpack ("H*", $salt_buf), $hash_buf); } elsif ($mode == 7400) { my $iterations = 5000; if (defined ($iter)) { if ($iter > 0) { $iterations = int ($iter); } } $hash_buf = sha256_crypt ($iterations, $word_buf, $salt_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 7500) { my @salt_arr = split ("\\\$", $salt_buf); my $user = $salt_arr[0]; my $realm = $salt_arr[1]; my $salt = $salt_arr[2]; my $hmac_salt = $salt_arr[3]; my $hmac_salt_bin = pack ("H*", $hmac_salt); my $clear_data = $salt_arr[4]; my $k = md4 (encode ("UTF-16LE", $word_buf)); my $k1 = hmac_md5 ("\x01\x00\x00\x00", $k); my $k3 = hmac_md5 ($hmac_salt_bin, $k1); if (length ($clear_data) > 1) { my $clear_data_bin = pack ("H*", $clear_data); $hash_buf = RC4 ($k3, $clear_data_bin); } else { my $hash = $salt_arr[5]; my $hash_bin = pack ("H*", $hash); my $clear_data = RC4 ($k3, $hash_bin); my $timestamp = substr ($clear_data, 14, 14); my $is_numeric = 1; my $num; if ($timestamp !~ /^[[:digit:]]{14}$/) { $is_numeric = 0; } if (! $is_numeric) { $hash_buf = "\x00" x 36; if ($hash_buf eq $hash_bin) { $hash_buf = "\x01" x 36; } } else { $hash_buf = $hash_bin; } } $tmp_hash = sprintf ("\$krb5pa\$23\$%s\$%s\$%s\$%s%s", $user, $realm, $salt, unpack ("H*", $hash_buf), $hmac_salt); } elsif ($mode == 7600) { $hash_buf = sha1_hex ($salt_buf . sha1_hex ($word_buf)); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 7700) { $word_buf = uc $word_buf; $salt_buf = uc $salt_buf; my $word_buf_t = sapb_transcode ($word_buf); my $salt_buf_t = sapb_transcode ($salt_buf); my $digest1 = md5 ($word_buf_t . $salt_buf_t); my $data = sapb_waldorf ($digest1, $word_buf_t, $salt_buf_t); my $digest2 = md5 ($data); my ($a, $b, $c, $d) = unpack ("N4", $digest2); $a ^= $c; $b ^= $d; $tmp_hash = sprintf ("%s\$%08X%08X", $salt_buf, $a, $b); } elsif ($mode == 7800) { my $theMagicArray_s = "\x91\xac\x51\x14\x9f\x67\x54\x43\x24\xe7\x3b\xe0\x28\x74\x7b\xc2" . "\x86\x33\x13\xeb\x5a\x4f\xcb\x5c\x08\x0a\x73\x37\x0e\x5d\x1c\x2f" . "\x33\x8f\xe6\xe5\xf8\x9b\xae\xdd\x16\xf2\x4b\x8d\x2c\xe1\xd4\xdc" . "\xb0\xcb\xdf\x9d\xd4\x70\x6d\x17\xf9\x4d\x42\x3f\x9b\x1b\x11\x94" . "\x9f\x5b\xc1\x9b\x06\x05\x9d\x03\x9d\x5e\x13\x8a\x1e\x9a\x6a\xe8" . "\xd9\x7c\x14\x17\x58\xc7\x2a\xf6\xa1\x99\x63\x0a\xd7\xfd\x70\xc3" . "\xf6\x5e\x74\x13\x03\xc9\x0b\x04\x26\x98\xf7\x26\x8a\x92\x93\x25" . "\xb0\xa2\x0d\x23\xed\x63\x79\x6d\x13\x32\xfa\x3c\x35\x02\x9a\xa3" . "\xb3\xdd\x8e\x0a\x24\xbf\x51\xc3\x7c\xcd\x55\x9f\x37\xaf\x94\x4c" . "\x29\x08\x52\x82\xb2\x3b\x4e\x37\x9f\x17\x07\x91\x11\x3b\xfd\xcd"; $salt_buf = uc $salt_buf; my $digest = sha1 ($word_buf . $salt_buf); my ($a, $b, $c, $d, $e) = unpack ("I*", $digest); my $lengthMagicArray = 0x20; my $offsetMagicArray = 0; $lengthMagicArray += (($a >> 0) & 0xff) % 6; $lengthMagicArray += (($a >> 8) & 0xff) % 6; $lengthMagicArray += (($a >> 16) & 0xff) % 6; $lengthMagicArray += (($a >> 24) & 0xff) % 6; $lengthMagicArray += (($b >> 0) & 0xff) % 6; $lengthMagicArray += (($b >> 8) & 0xff) % 6; $lengthMagicArray += (($b >> 16) & 0xff) % 6; $lengthMagicArray += (($b >> 24) & 0xff) % 6; $lengthMagicArray += (($c >> 0) & 0xff) % 6; $lengthMagicArray += (($c >> 8) & 0xff) % 6; $offsetMagicArray += (($c >> 16) & 0xff) % 8; $offsetMagicArray += (($c >> 24) & 0xff) % 8; $offsetMagicArray += (($d >> 0) & 0xff) % 8; $offsetMagicArray += (($d >> 8) & 0xff) % 8; $offsetMagicArray += (($d >> 16) & 0xff) % 8; $offsetMagicArray += (($d >> 24) & 0xff) % 8; $offsetMagicArray += (($e >> 0) & 0xff) % 8; $offsetMagicArray += (($e >> 8) & 0xff) % 8; $offsetMagicArray += (($e >> 16) & 0xff) % 8; $offsetMagicArray += (($e >> 24) & 0xff) % 8; my $hash_buf = sha1_hex ($word_buf . substr ($theMagicArray_s, $offsetMagicArray, $lengthMagicArray) . $salt_buf); $tmp_hash = sprintf ("%s\$%s", $salt_buf, uc $hash_buf); } elsif ($mode == 7900) { my $cost = 14; if (length ($iter)) { $cost = $iter; } my $phpass_it = 1 << $cost; $hash_buf = sha512 ($salt_buf . $word_buf); for (my $i = 0; $i < $phpass_it; $i++) { $hash_buf = sha512 ($hash_buf . $word_buf); } my $base64_buf = substr (Authen::Passphrase::PHPass::_en_base64 ($hash_buf), 0, 43); my $base64_digits = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; my $cost_str = substr ($base64_digits , $cost, 1); $tmp_hash = sprintf ('$S$%s%s%s', $cost_str, $salt_buf, $base64_buf); } elsif ($mode == 8000) { my $salt_buf_bin = pack ("H*", $salt_buf); my $word_buf_utf = encode ("UTF-16BE", $word_buf); $hash_buf = sha256_hex ($word_buf_utf . "\x00" x (510 - (length ($word_buf) * 2)) . $salt_buf_bin); $tmp_hash = sprintf ("0xc007%s%s", $salt_buf, $hash_buf); } elsif ($mode == 8100) { $hash_buf = sha1_hex ($salt_buf . $word_buf . "\x00"); $tmp_hash = sprintf ("1%s%s", $salt_buf, $hash_buf); } elsif ($mode == 8200) { my $iterations = 40000; if (defined ($iter)) { $iterations = $iter; } my $salt_hex = substr ($salt_buf, 0, 32); my $salt = pack ("H*", $salt_hex); my $data_hex = substr ($salt_buf, 32); my $data = pack ("H*", $data_hex); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), iterations => int $iterations ); my $key = $pbkdf2->PBKDF2 ($salt, $word_buf); $hash_buf = hmac_hex ($data, substr ($key, 32, 32), \&sha256, 64); $tmp_hash = sprintf ("%s:%s:%d:%s", $hash_buf, $salt_hex, $iterations, $data_hex); } elsif ($mode == 8300) { my ($domain, $salt_hex) = split (":", $salt_buf); my $hashalg = Net::DNS::SEC->digtype ("SHA1"); my $salt = pack ("H*", $salt_hex); my $iterations = 1; if (defined ($iter)) { $iterations = $iter; } my $name = lc ($word_buf . $domain); my $hash_buf = Net::DNS::RR::NSEC3::name2hash ($hashalg, $name, $iterations, $salt); $tmp_hash = sprintf ("%s:%s:%s:%d", $hash_buf, $domain, $salt_hex, $iterations); } elsif ($mode == 8400) { $hash_buf = sha1_hex ($salt_buf . sha1_hex ($salt_buf . sha1_hex ($word_buf))); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 8500) { $hash_buf = racf_hash (uc $salt_buf, $word_buf); $tmp_hash = sprintf ('$racf$*%s*%s', uc $salt_buf, uc $hash_buf); } elsif ($mode == 8600) { my @saved_key = map { ord $_; } split "", $word_buf; my $len = scalar @saved_key; my @state = domino_big_md (\@saved_key, $len); $tmp_hash = sprintf ('%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x', $state[ 0], $state[ 1], $state[ 2], $state[ 3], $state[ 4], $state[ 5], $state[ 6], $state[ 7], $state[ 8], $state[ 9], $state[10], $state[11], $state[12], $state[13], $state[14], $state[15], ); } elsif ($mode == 8700) { my $domino_char = undef; if (defined ($additional_param)) { $domino_char = $additional_param; } my @saved_key = map { ord $_; } split "", $word_buf; my $len = scalar @saved_key; my @state = domino_big_md (\@saved_key, $len); my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")"; @saved_key = map { ord $_; } split "", $salt_buf . uc $str; @state = domino_big_md (\@saved_key, 34); $hash_buf = join ("", (map { chr $_; } @state)); $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_buf . $hash_buf, $domino_char)); } elsif ($mode == 8900) { my $N = 1024; my $r = 1; my $p = 1; if (defined ($additional_param)) { $N = $additional_param; $r = $additional_param2; $p = $additional_param3; } $hash_buf = scrypt_hash ($word_buf, $salt_buf, $N, $r, $p, 32); $tmp_hash = sprintf ('%s', $hash_buf); } elsif ($mode == 9100) { my $iterations = 5000; if (defined ($iter)) { $iterations = $iter; } my $domino_char = undef; # domino 5 hash - SEC_pwddigest_V1 - -m 8600 my @saved_key = map { ord $_; } split "", $word_buf; my $len = scalar @saved_key; my @state = domino_big_md (\@saved_key, $len); # domino 6 hash - SEC_pwddigest_V2 - -m 8700 my $salt_part = substr ($salt_buf, 0, 5); my $str = "(" . unpack ("H*", join ("", (map { chr $_; } @state))) . ")"; @saved_key = map { ord $_; } split "", $salt_part . uc $str; @state = domino_big_md (\@saved_key, 34); $hash_buf = join ("", (map { chr $_; } @state)); $tmp_hash = sprintf ('(G%s)', domino_encode ($salt_part . $hash_buf, $domino_char)); # domino 8(.5.x) hash - SEC_pwddigest_V3 - -m 9100 my $pbkdf2 = Crypt::PBKDF2->new ( hash_class => 'HMACSHA1', iterations => $iterations, output_len => 8, salt_len => 16, ); my $chars = "02"; if (defined ($additional_param)) { $chars = $additional_param; } my $digest_new = $pbkdf2->PBKDF2 ($salt_buf, $tmp_hash); my $iteration_str = "" . $iterations; for (my $i = length ($iterations); $i < 10; $i++) { $iterations = "0" . $iterations; } $tmp_hash = sprintf ('(H%s)', domino_85x_encode ($salt_buf . $iterations . $chars . $digest_new, $domino_char)); } elsif ($mode == 9200) { my $iterations = 20000; my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256), iterations => $iterations ); $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf)); $tmp_hash = ""; for (my $i = 0; $i < 43; $i++) { $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)}; } $tmp_hash = sprintf ("\$8\$%s\$%s", $salt_buf, $tmp_hash); } elsif ($mode == 9300) { my $N = 16384; my $r = 1; my $p = 1; $hash_buf = scrypt_b64 ($word_buf, $salt_buf, $N, $r, $p, 32); $tmp_hash = ""; for (my $i = 0; $i < 43; $i++) { $tmp_hash .= $CISCO_BASE64_MAPPING->{substr ($hash_buf, $i, 1)}; } $tmp_hash = sprintf ('$9$%s$%s', $salt_buf, $tmp_hash); } elsif ($mode == 9400) { my $iterations = 50000; if (length ($iter)) { $iterations = int ($iter); } my $aes_key_size = 128; # or 256 if (defined ($additional_param2)) { $aes_key_size = $additional_param2; } $salt_buf = pack ("H*", $salt_buf); my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf)); for (my $i = 0; $i < $iterations; $i++) { my $num32 = pack ("L", $i); $tmp = sha1 ($num32 . $tmp); } my $zero32 = pack ("L", 0x00); my $derivation_array1 = pack ("C", 0x36) x 64; my $derivation_array2 = pack ("C", 0x5C) x 64; $tmp = sha1 ($tmp . $zero32); my $tmp2 = sha1 ($derivation_array1 ^ $tmp); my $tmp3 = sha1 ($derivation_array2 ^ $tmp); my $key = substr ($tmp2 . $tmp3, 0, $aes_key_size / 8); my $m = Crypt::Mode::ECB->new ('AES', 0); my $encdata; if (defined $additional_param) { $encdata = $m->decrypt (pack ("H*", $additional_param), $key); } else { $encdata = "A" x 16; ## can be anything } my $data1_buf = $encdata; my $data2_buf = sha1 (substr ($data1_buf, 0, 16)); $data1_buf = substr ($data1_buf . ("\x00" x 16), 0, 16); $data2_buf = substr ($data2_buf . ("\x00" x 16), 0, 32); my $encrypted1 = unpack ("H*", $m->encrypt ($data1_buf, $key)); my $encrypted2 = unpack ("H*", $m->encrypt ($data2_buf, $key)); $encrypted1 = substr ($encrypted1, 0, 32); $encrypted2 = substr ($encrypted2, 0, 40); $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2007, 20, $aes_key_size, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2); } elsif ($mode == 9500) { my $iterations = 100000; if (length ($iter)) { $iterations = int ($iter); } $salt_buf = pack ("H*", $salt_buf); my $tmp = sha1 ($salt_buf . encode ("UTF-16LE", $word_buf)); for (my $i = 0; $i < $iterations; $i++) { my $num32 = pack ("L", $i); $tmp = sha1 ($num32 . $tmp); } my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79"; my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e"; my $final1 = sha1 ($tmp . $encryptedVerifierHashInputBlockKey); my $final2 = sha1 ($tmp . $encryptedVerifierHashValueBlockKey); my $key1 = substr ($final1, 0, 16); my $key2 = substr ($final2, 0, 16); my $cipher1 = Crypt::CBC->new({ key => $key1, cipher => "Crypt::Rijndael", iv => $salt_buf, literal_key => 1, header => "none", keysize => 16, padding => "null", }); my $cipher2 = Crypt::CBC->new({ key => $key2, cipher => "Crypt::Rijndael", iv => $salt_buf, literal_key => 1, header => "none", keysize => 16, padding => "null", }); my $encdata; if (defined $additional_param) { $encdata = $cipher1->decrypt (pack ("H*", $additional_param)); } else { $encdata = "A" x 16; ## can be anything } my $data1_buf = $encdata; my $data2_buf = sha1 (substr ($data1_buf, 0, 16)); my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf)); my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf)); $encrypted2 = substr ($encrypted2, 0, 64); $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2010, 100000, 128, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2); } elsif ($mode == 9600) { my $iterations = 100000; if (length ($iter)) { $iterations = int ($iter); } $salt_buf = pack ("H*", $salt_buf); my $tmp = sha512 ($salt_buf . encode ("UTF-16LE", $word_buf)); for (my $i = 0; $i < $iterations; $i++) { my $num32 = pack ("L", $i); $tmp = sha512 ($num32 . $tmp); } my $encryptedVerifierHashInputBlockKey = "\xfe\xa7\xd2\x76\x3b\x4b\x9e\x79"; my $encryptedVerifierHashValueBlockKey = "\xd7\xaa\x0f\x6d\x30\x61\x34\x4e"; my $final1 = sha512 ($tmp . $encryptedVerifierHashInputBlockKey); my $final2 = sha512 ($tmp . $encryptedVerifierHashValueBlockKey); my $key1 = substr ($final1, 0, 32); my $key2 = substr ($final2, 0, 32); my $cipher1 = Crypt::CBC->new({ key => $key1, cipher => "Crypt::Rijndael", iv => $salt_buf, literal_key => 1, header => "none", keysize => 32, padding => "null", }); my $cipher2 = Crypt::CBC->new({ key => $key2, cipher => "Crypt::Rijndael", iv => $salt_buf, literal_key => 1, header => "none", keysize => 32, padding => "null", }); my $encdata; if (defined $additional_param) { $encdata = $cipher1->decrypt (pack ("H*", $additional_param)); } else { $encdata = "A" x 16; ## can be anything } my $data1_buf = $encdata; my $data2_buf = sha512 (substr ($data1_buf, 0, 16)); my $encrypted1 = unpack ("H*", $cipher1->encrypt ($data1_buf)); my $encrypted2 = unpack ("H*", $cipher2->encrypt ($data2_buf)); $encrypted2 = substr ($encrypted2, 0, 64); $tmp_hash = sprintf ("\$office\$*%d*%d*%d*%d*%s*%s*%s", 2013, 100000, 256, 16, unpack ("H*", $salt_buf), $encrypted1, $encrypted2); } elsif ($mode == 9700) { $salt_buf = pack ("H*", $salt_buf); my $tmp = md5 (encode ("UTF-16LE", $word_buf)); $tmp = substr ($tmp, 0, 5); my $data; for (my $i = 0; $i < 16; $i++) { $data .= $tmp; $data .= $salt_buf; } $tmp = md5 ($data); $tmp = substr ($tmp, 0, 5); my $version; if (defined $additional_param2) { $version = $additional_param2; } else { $version = (unpack ("L", $tmp) & 1) ? 0 : 1; } my $rc4_key = md5 ($tmp . "\x00\x00\x00\x00"); my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16)); my $encdata; if (defined $additional_param) { $encdata = $m->RC4 (pack ("H*", $additional_param)); } else { $encdata = "A" x 16; ## can be anything } my $data1_buf = $encdata; my $data2_buf = md5 (substr ($data1_buf, 0, 16)); $m = Crypt::RC4->new (substr ($rc4_key, 0, 16)); my $encrypted1 = $m->RC4 ($data1_buf); my $encrypted2 = $m->RC4 ($data2_buf); $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2)); } elsif ($mode == 9800) { $salt_buf = pack ("H*", $salt_buf); my $tmp = sha1 ($salt_buf. encode ("UTF-16LE", $word_buf)); my $version; if (defined $additional_param2) { $version = $additional_param2; } else { $version = (unpack ("L", $tmp) & 1) ? 3 : 4; } my $rc4_key = sha1 ($tmp . "\x00\x00\x00\x00"); if ($version == 3) { $rc4_key = substr ($rc4_key, 0, 5) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; } my $m = Crypt::RC4->new (substr ($rc4_key, 0, 16)); my $encdata; if (defined $additional_param) { $encdata = $m->RC4 (pack ("H*", $additional_param)); } else { $encdata = "A" x 16; ## can be anything } my $data1_buf = $encdata; my $data2_buf = sha1 (substr ($data1_buf, 0, 16)); $m = Crypt::RC4->new (substr ($rc4_key, 0, 16)); my $encrypted1 = $m->RC4 ($data1_buf); my $encrypted2 = $m->RC4 ($data2_buf); $tmp_hash = sprintf ("\$oldoffice\$%d*%s*%s*%s", $version, unpack ("H*", $salt_buf), unpack ("H*", $encrypted1), unpack ("H*", $encrypted2)); } elsif ($mode == 9900) { $tmp_hash = sprintf ("%s", md5_hex ($word_buf . "\0" x (100 - length ($word_buf)))); } elsif ($mode == 10000) { my $iterations = 10000; if (length ($iter)) { $iterations = int ($iter); } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256), iterations => $iterations ); $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf)); $hash_buf =~ s/[\r\n]//g; $tmp_hash = sprintf ("pbkdf2_sha256\$%i\$%s\$%s", $iterations, $salt_buf, $hash_buf); } elsif ($mode == 10100) { my $seed = pack ("H*", $salt_buf); my ($hi, $lo) = siphash ($word_buf, $seed); my $hi_s = sprintf ("%08x", $hi); my $lo_s = sprintf ("%08x", $lo); $hi_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/; $lo_s =~ s/^(..)(..)(..)(..)$/$4$3$2$1/; $tmp_hash = sprintf ("%s%s:2:4:%s", $hi_s, $lo_s, $salt_buf); } elsif ($mode == 10200) { my $challengeb64 = encode_base64 ($salt_buf); $challengeb64 =~ s/[\r\n]//g; my $username; if (defined $additional_param) { $username = $additional_param; } else { $username = "user"; } $hash_buf = hmac_hex ($salt_buf, $word_buf, \&md5); my $responseb64 = encode_base64 ($username . " " . $hash_buf); $responseb64 =~ s/[\r\n]//g; $tmp_hash = sprintf ('$cram_md5$%s$%s', $challengeb64, $responseb64); } elsif ($mode == 10300) { my $iterations = 1024; if (length ($iter)) { $iterations = int ($iter); } my $hash_buf = $salt_buf; for (my $pos = 0; $pos < $iterations; $pos++) { $hash_buf = sha1 ($word_buf . $hash_buf); } $hash_buf = encode_base64 ($hash_buf . $salt_buf); $hash_buf =~ s/[\r\n]//g; $tmp_hash = sprintf ("{x-issha, %i}%s", $iterations, $hash_buf); } elsif ($mode == 10400) { my $id = $salt_buf; my $u = $additional_param; my $o = $additional_param2; my $P = $additional_param3; if (defined $u == 0) { $u = "0" x 64; } if (defined $o == 0) { $o = "0" x 64; } if (defined $P == 0) { $P = -1; } my $padding; for (my $i = 0; $i < 32; $i++) { $padding .= pack ("C", $pdf_padding[$i]); } my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, 1, 2, 0); my $m = Crypt::RC4->new (substr ($res, 0, 5)); $u = $m->RC4 ($padding); $tmp_hash = sprintf ('$pdf$%d*%d*40*%d*%d*16*%s*32*%s*32*%s', 1, 2, $P, 0, $id, unpack ("H*", $u), $o); } elsif ($mode == 10500) { my $id = $salt_buf; my $u = $additional_param; my $o = $additional_param2; my $P = $additional_param3; my $V = $additional_param4; my $R = $additional_param5; my $enc = $additional_param6; if (defined $u == 0) { $u = "0" x 64; } my $u_save = $u; if (defined $o == 0) { $o = "0" x 64; } if (defined $R == 0) { $R = get_random_num (3, 5); } if (defined $V == 0) { $V = ($R == 3) ? 2 : 4; } if (defined $P == 0) { $P = ($R == 3) ? -4 : -1028; } if (defined $enc == 0) { $enc = ($R == 3) ? 1 : get_random_num (0, 2); } my $padding; for (my $i = 0; $i < 32; $i++) { $padding .= pack ("C", $pdf_padding[$i]); } my $res = pdf_compute_encryption_key ($word_buf, $padding, $id, $u, $o, $P, $V, $R, $enc); my $digest = md5 ($padding . pack ("H*", $id)); my $m = Crypt::RC4->new ($res); $u = $m->RC4 ($digest); my @ress = split "", $res; for (my $x = 1; $x <= 19; $x++) { my @xor; for (my $i = 0; $i < 16; $i++) { $xor[$i] = chr (ord ($ress[$i]) ^ $x); } my $s = join ("", @xor); my $m2 = Crypt::RC4->new ($s); $u = $m2->RC4 ($u); } $u .= substr (pack ("H*", $u_save), 16, 16); $tmp_hash = sprintf ('$pdf$%d*%d*128*%d*%d*16*%s*32*%s*32*%s', $V, $R, $P, $enc, $id, unpack ("H*", $u), $o); } elsif ($mode == 10600) { my $id = $salt_buf; my $rest = $additional_param; if (defined $id == 0) { $id = "0" x 32; } if (defined $rest == 0) { $rest = "127*"; $rest .= "0" x 64; $rest .= $id; $rest .= "0" x 158; $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000"; } my @data = split /\*/, $rest; my $u = pack ("H*", $data[1]); my $h = sha256 ($word_buf . substr ($u, 32, 8)); $data[1] = unpack ("H*", $h . substr ($u, 32)); $rest = join ("*", @data); $tmp_hash = sprintf ('$pdf$5*5*256*-1028*1*16*%s*%s', $id, $rest); } elsif ($mode == 10700) { my $id = $salt_buf; my $rest = $additional_param; if (defined $id == 0) { $id = "0" x 32; } if (defined $rest == 0) { $rest = "127*"; $rest .= "0" x 64; $rest .= $id; $rest .= "0" x 158; $rest .= "*127*00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000*32*0000000000000000000000000000000000000000000000000000000000000000"; } my @datax = split /\*/, $rest; my $u = pack ("H*", $datax[1]); my $block = sha256 ($word_buf . substr ($u, 32, 8)); my $block_size = 32; my $data = 0x00 x 64; my $data_len = 1; my $data63 = 0; for (my $i = 0; $i < 64 || $i < $data63 + 32; $i++) { $data = $word_buf . $block; $data_len = length ($data); for (my $k = 1; $k < 64; $k++) { $data .= $word_buf . $block; } my $aes = Crypt::CBC->new({ key => substr ($block, 0, 16), cipher => "Crypt::Rijndael", iv => substr ($block, 16, 16), literal_key => 1, header => "none", keysize => 16, padding => "null", }); my $data = $aes->encrypt ($data); my $sum = 0; for (my $j = 0; $j < 16; $j++) { $sum += ord (substr ($data, $j, 1)); } $block_size = 32 + ($sum % 3) * 16; if ($block_size == 32) { $block = sha256 (substr ($data, 0, $data_len * 64)); } elsif ($block_size == 48) { $block = sha384 (substr ($data, 0, $data_len * 64)); } elsif ($block_size == 64) { $block = sha512 (substr ($data, 0, $data_len * 64)); } $data63 = ord (substr ($data, $data_len * 64 - 1, 1)); } $datax[1] = unpack ("H*", substr ($block, 0, 32) . substr ($u, 32)); $rest = join ("*", @datax); $tmp_hash = sprintf ('$pdf$5*6*256*-1028*1*16*%s*%s', $id, $rest); } elsif ($mode == 10800) { $hash_buf = sha384_hex ($word_buf); $tmp_hash = sprintf ("%s", $hash_buf); } elsif ($mode == 10900) { my $iterations = 1000; if (length ($iter)) { $iterations = int ($iter); } my $out_len = 24; if (defined $additional_param) { $out_len = $additional_param; } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256), iterations => $iterations, output_len => $out_len ); $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf)); $hash_buf =~ s/[\r\n]//g; my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); $tmp_hash = sprintf ("sha256:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf); } elsif ($mode == 11000) { $hash_buf = md5_hex ($salt_buf . $word_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 11100) { my $user = "postgres"; if (defined $additional_param) { $user = $additional_param; } $hash_buf = md5_hex (md5_hex ($word_buf . $user) . pack ("H*", $salt_buf)); $tmp_hash = sprintf ("\$postgres\$%s*%s*%s", $user, $salt_buf, $hash_buf); } elsif ($mode == 11200) { my $sha1_pass = sha1 ($word_buf); my $double_sha1 = sha1 ($sha1_pass); my $xor_part1 = $sha1_pass; my $xor_part2 = sha1 (pack ("H*", $salt_buf) . $double_sha1); my $hash_buf = ""; for (my $i = 0; $i < 20; $i++) { my $first_byte = substr ($xor_part1, $i, 1); my $second_byte = substr ($xor_part2, $i, 1); my $xor_result = $first_byte ^ $second_byte; $hash_buf .= unpack ("H*", $xor_result); } $tmp_hash = sprintf ("\$mysqlna\$%s*%s", $salt_buf, $hash_buf); } elsif ($mode == 11300) { my $ckey_buf = get_random_string (96); if (length ($additional_param)) { $ckey_buf = $additional_param; } my $public_key_buf = get_random_string (66); if (length ($additional_param2)) { $public_key_buf = $additional_param2; } my $salt_iter = get_random_num (150000, 250000); if (length ($iter)) { $salt_iter = int ($iter); } my $hash_buf = sha512 ($word_buf . pack ("H*", $salt_buf)); for (my $i = 1; $i < $salt_iter; $i++) { $hash_buf = sha512 ($hash_buf); } my $data = get_random_string (32); my $aes = Crypt::CBC->new({ key => substr ($hash_buf, 0, 32), cipher => "Crypt::Rijndael", iv => substr ($hash_buf, 32, 16), literal_key => 1, header => "none", keysize => 32, padding => "standard", }); my $cry_master_buf = (unpack ("H*", $aes->encrypt ($data))); $tmp_hash = sprintf ('$bitcoin$%d$%s$%d$%s$%d$%d$%s$%d$%s', length ($cry_master_buf), $cry_master_buf, length ($salt_buf), $salt_buf, $salt_iter, length ($ckey_buf), $ckey_buf, length ($public_key_buf), $public_key_buf); } elsif ($mode == 11400) { my ($directive, $URI_server, $URI_client, $user, $realm, $nonce, $nonce_count, $nonce_client, $qop, $method, $URI, $URI_prefix, $URI_resource, $URI_suffix); $directive = "MD5"; # only directive currently supported if (defined ($additional_param)) { $user = $additional_param; $realm = $additional_param2; $nonce = $salt_buf; $nonce_count = $additional_param3; $nonce_client = $additional_param4; $qop = $additional_param5; $method = $additional_param6; $URI_prefix = $additional_param7; $URI_resource = $additional_param8; $URI_suffix = $additional_param9; # not needed information $URI_server = $additional_param10; $URI_client = $additional_param11; } else { $user = get_random_string (get_random_num (0, 12 + 1)); # special limit: (user_len + 1 + realm_len + 1 + word_buf_len) < 56 my $realm_max_len = 55 - length ($user) - 1 - length ($word_buf) - 1; if ($realm_max_len < 1) # should never happen { $realm_max_len = 1; } $realm_max_len = min (20, $realm_max_len); $realm = get_random_string (get_random_num (0, $realm_max_len + 1)); $nonce = $salt_buf; if (get_random_num (0, 1 + 1) == 1) { $qop = "auth"; $nonce_count = get_random_string (get_random_num (0, 10 + 1)); $nonce_client = get_random_string (get_random_num (0, 12 + 1)); } else { $qop = ""; $nonce_count = ""; $nonce_client = ""; } $method = get_random_string (get_random_num (0, 24 + 1)); $URI_prefix = get_random_string (get_random_num (0, 10 + 1)); $URI_resource = get_random_string (get_random_num (1, 32 + 1)); $URI_suffix = get_random_string (get_random_num (0, 32 + 1)); # not needed information $URI_server = get_random_string (get_random_num (0, 32 + 1)); $URI_client = $URI_resource; # simplification } # start $URI = ""; if (length ($URI_prefix) > 0) { $URI = $URI_prefix . ":"; } $URI .= $URI_resource; if (length ($URI_suffix) > 0) { $URI .= ":" . $URI_suffix; } my $HA2 = md5_hex ($method . ":" . $URI); my $HA1 = md5_hex ($user . ":" . $realm . ":" . $word_buf); my $tmp_buf; if (($qop eq "auth") || ($qop eq "auth-int")) { $tmp_buf = $nonce . ":" . $nonce_count . ":" . $nonce_client . ":" . $qop; } else { $tmp_buf = $nonce; } my $hash_buf = md5_hex ($HA1 . ":" . $tmp_buf . ":" . $HA2); $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); } elsif ($mode == 11500) { $hash_buf = crc32 ($word_buf); $tmp_hash = sprintf ("%08x:00000000", $hash_buf); } elsif ($mode == 11600) { my ($p, $num_cycle_power, $seven_zip_salt_len, $seven_zip_salt_buf, $salt_len, $data_len, $unpack_size, $data_buf); $p = 0; # is fixed my $validation_only = 0; $validation_only = 1 if (defined ($additional_param)); if ($validation_only == 1) { $num_cycle_power = int ($iter); $seven_zip_salt_len = $additional_param; $seven_zip_salt_buf = $additional_param2; $salt_len = $additional_param3; # $salt_buf set in parser # $hash_buf (resulting crc) $data_len = $additional_param4; $unpack_size = $additional_param5; $data_buf = $additional_param6; } else { $num_cycle_power = 14; # by default it is 19 $seven_zip_salt_len = 0; $seven_zip_salt_buf = ""; $salt_len = length ($salt_buf); # $salt_buf set automatically # $hash_buf (resulting crc) # $data_len will be set when encrypting $unpack_size = get_random_num (1, 32 + 1); $data_buf = get_random_string ($unpack_size); } # # 2 ^ NumCyclesPower "iterations" of SHA256 (only one final SHA256) # $word_buf = encode ("UTF-16LE", $word_buf); my $rounds = 1 << $num_cycle_power; my $pass_buf = ""; for (my $i = 0; $i < $rounds; $i++) { my $num_buf = ""; $num_buf .= pack ("V", $i); $num_buf .= "\x00" x 4; # this would be better but only works on 64-bit systems: # $num_buf = pack ("q", $i); $pass_buf .= sprintf ("%s%s", $word_buf, $num_buf); } my $key = sha256 ($pass_buf); # the salt_buf is our IV for AES CBC # pad the salt_buf my $salt_buf_len = length ($salt_buf); my $salt_padding_len = 0; if ($salt_buf_len < 16) { $salt_padding_len = 16 - $salt_buf_len; } $salt_buf .= "\x00" x $salt_padding_len; my $aes = Crypt::CBC->new({ cipher => "Crypt::Rijndael", key => $key, keysize => 32, literal_key => 1, iv => $salt_buf, header => "none", }); if ($validation_only == 1) { # decrypt my $decrypted_data = $aes->decrypt ($data_buf); $decrypted_data = substr ($decrypted_data, 0, $unpack_size); $hash_buf = crc32 ($decrypted_data); } else { # encrypt $hash_buf = crc32 ($data_buf); $data_buf = $aes->encrypt ($data_buf); $data_len = length ($data_buf); } $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)); } elsif ($mode == 11900) { my $iterations = 1000; if (length ($iter)) { $iterations = int ($iter); } my $out_len = 32; if (defined $additional_param) { $out_len = $additional_param; } # # call PHP here - WTF # # sanitize $word_buf and $salt_buf: my $word_buf_base64 = encode_base64 ($word_buf); $word_buf_base64 =~ s/[\r\n]//g; my $salt_buf_base64 = encode_base64 ($salt_buf); $salt_buf_base64 =~ s/[\r\n]//g; # sanitize lenghs $out_len = int ($out_len); # output is in hex encoding, otherwise it could be screwed (but shouldn't) my $php_code = <<'END_CODE'; function pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output = false) { $algorithm = strtolower ($algorithm); if(! in_array ($algorithm, hash_algos (), true)) { trigger_error ("PBKDF2 ERROR: Invalid hash algorithm.", E_USER_ERROR); } if ($count <= 0 || $key_length <= 0) { trigger_error ("PBKDF2 ERROR: Invalid parameters.", E_USER_ERROR); } if (function_exists ("hash_pbkdf2")) { if (!$raw_output) { $key_length = $key_length * 2; } return hash_pbkdf2 ($algorithm, $password, $salt, $count, $key_length, $raw_output); } $hash_length = strlen (hash ($algorithm, "", true)); $block_count = ceil ($key_length / $hash_length); $output = ""; for ($i = 1; $i <= $block_count; $i++) { $last = $salt . pack ("N", $i); $last = $xorsum = hash_hmac ($algorithm, $last, $password, true); for ($j = 1; $j < $count; $j++) { $xorsum ^= ($last = hash_hmac ($algorithm, $last, $password, true)); } $output .= $xorsum; } if($raw_output) { return substr ($output, 0, $key_length); } else { return bin2hex (substr ($output, 0, $key_length)); } } print pbkdf2 ("md5", base64_decode ("$word_buf_base64"), base64_decode ("$salt_buf_base64"), $iterations, $out_len, False); END_CODE # replace with these command line arguments $php_code =~ s/\$word_buf_base64/$word_buf_base64/; $php_code =~ s/\$salt_buf_base64/$salt_buf_base64/; $php_code =~ s/\$iterations/$iterations/; $php_code =~ s/\$out_len/$out_len/; my $php_output = `php -r '$php_code'`; $hash_buf = pack ("H*", $php_output); $hash_buf = encode_base64 ($hash_buf); $hash_buf =~ s/[\r\n]//g; my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); $tmp_hash = sprintf ("md5:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf); } elsif ($mode == 12000) { my $iterations = 1000; if (length ($iter)) { $iterations = int ($iter); } my $out_len = 16; if (defined $additional_param) { $out_len = $additional_param; } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'), iterations => $iterations, output_len => $out_len ); $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf)); $hash_buf =~ s/[\r\n]//g; my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); $tmp_hash = sprintf ("sha1:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf); } elsif ($mode == 12100) { my $iterations = 1000; if (length ($iter)) { $iterations = int ($iter); } my $out_len = 16; if (defined $additional_param) { $out_len = $additional_param; } my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), iterations => $iterations, output_len => $out_len ); $hash_buf = encode_base64 ($pbkdf2->PBKDF2 ($salt_buf, $word_buf)); $hash_buf =~ s/[\r\n]//g; my $base64_salt_buf = encode_base64 ($salt_buf); chomp ($base64_salt_buf); $tmp_hash = sprintf ("sha512:%i:%s:%s", $iterations, $base64_salt_buf, $hash_buf); } elsif ($mode == 12200) { my $iterations = 65536; my $default_salt = 0; if (defined $additional_param) { $default_salt = int ($additional_param); } if ($default_salt == 1) { $salt_buf = "0011223344556677"; } $hash_buf = sha512 (pack ("H*", $salt_buf) . $word_buf); for (my $i = 0; $i < $iterations; $i++) { $hash_buf = sha512 ($hash_buf); } $hash_buf = unpack ("H*", $hash_buf); $hash_buf = substr ($hash_buf, 0, 16); if ($default_salt == 0) { $tmp_hash = sprintf ("\$ecryptfs\$0\$1\$%s\$%s", $salt_buf, $hash_buf); } else { $tmp_hash = sprintf ("\$ecryptfs\$0\$%s", $hash_buf); } } elsif ($mode == 12300) { my $iterations = 4096; my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, output_len => 64 ); my $salt_bin = pack ("H*", $salt_buf); my $key = $pbkdf2->PBKDF2 ($salt_bin. "AUTH_PBKDF2_SPEEDY_KEY", $word_buf); $hash_buf = sha512_hex ($key . $salt_bin); $tmp_hash = sprintf ("%s%s", uc ($hash_buf), uc ($salt_buf)); } elsif ($mode == 12400) { my $iterations; if (length ($iter)) { $iterations = int ($iter); } else { $iterations = get_random_num (1, 5001 + 1); } my $key_value = fold_password ($word_buf); my $data = "\x00\x00\x00\x00\x00\x00\x00\x00"; my $salt_value = base64_to_int24 ($salt_buf); $hash_buf = crypt_rounds ($key_value, $iterations, $salt_value, $data); $tmp_hash = sprintf ("_%s%s%s", int24_to_base64 ($iterations), $salt_buf, block_to_base64 ($hash_buf)); } elsif ($mode == 12600) { $hash_buf = sha1_hex ($word_buf); $hash_buf = sha256_hex ($salt_buf . uc $hash_buf); $tmp_hash = sprintf ("%s:%s", $hash_buf, $salt_buf); } elsif ($mode == 12700) { my $iterations = 10; my $data = qq|{ "guid" : "00000000-0000-0000-0000-000000000000", "sharedKey" : "00000000-0000-0000-0000-000000000000", "options" : {"pbkdf2_iterations":10,"fee_policy":0,"html5_notifications":false,"logout_time":600000,"tx_display":0,"always_keep_local_backup":false}|; my $salt_buf_bin = pack ("H*", $salt_buf); my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, output_len => 32 ); my $key = $pbkdf2->PBKDF2 ($salt_buf_bin, $word_buf); my $cipher = Crypt::CBC->new({ key => $key, cipher => "Crypt::Rijndael", iv => $salt_buf_bin, literal_key => 1, header => "none", keysize => 32 }); my $encrypted = unpack ("H*", $cipher->encrypt ($data)); $tmp_hash = sprintf ("\$blockchain\$%s\$%s", length ($salt_buf . $encrypted) / 2, $salt_buf . $encrypted); } elsif ($mode == 12800) { my $iterations = 100; if (length ($iter)) { $iterations = int ($iter); } my $nt = md4_hex (encode ("UTF-16LE", $word_buf)); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256), iterations => $iterations, output_len => 32 ); my $salt_buf_bin = pack ("H*", $salt_buf); my $hash = $pbkdf2->PBKDF2 ($salt_buf_bin, uc (encode ("UTF-16LE", $nt))); $tmp_hash = sprintf ("v1;PPH1_MD4,%s,%d,%s", $salt_buf, $iterations, unpack ("H*", $hash)); } return ($tmp_hash); } sub rnd { my $mode = shift; my $word_len = shift; my $salt_len = shift; my $max = $MAX_LEN; $max = 15 if ($mode == 2410); if ($is_unicode{$mode}) { if (! $allow_long_salt{$mode}) { $word_len = min ($word_len, int ($max / 2) - $salt_len); } else { $word_len = min ($word_len, int ($max / 2)); } } elsif ($less_fifteen{$mode}) { $word_len = min ($word_len, 15); if ($mode == 2410) { $salt_len = min ($salt_len, 15 - $word_len); } } else { if (! $allow_long_salt{$mode}) { $word_len = min ($word_len, $max - $salt_len); } } if ($word_len < 1) { $word_len = 1; } ## ## gen salt ## my $salt_buf; if ($mode == 4800) { my @salt_arr; for (my $i = 0; $i < $salt_len; $i++) { my $c = get_random_chr (0x30, 0x39); push (@salt_arr, $c); } $salt_buf = join ("", @salt_arr); $salt_buf = get_random_md5chap_salt ($salt_buf); } elsif ($mode == 5300 || $mode == 5400) { $salt_buf = get_random_ike_salt (); } elsif ($mode == 5500) { $salt_buf = get_random_netntlmv1_salt ($salt_len, $salt_len); } elsif ($mode == 5600) { $salt_buf = get_random_netntlmv2_salt ($salt_len, $salt_len); } elsif ($mode == 6600) { $salt_buf = get_random_agilekeychain_salt (); } elsif ($mode == 8200) { $salt_buf = get_random_cloudkeychain_salt (); } elsif ($mode == 8300) { $salt_buf = get_random_dnssec_salt (); } else { my @salt_arr; for (my $i = 0; $i < $salt_len; $i++) { my $c = get_random_chr (0x30, 0x39); push (@salt_arr, $c); } $salt_buf = join ("", @salt_arr); if ($mode == 7500) { $salt_buf = get_random_kerberos5_salt ($salt_buf); } } ## ## gen plain ## my @word_arr; for (my $i = 0; $i < $word_len; $i++) { my $c = get_random_chr (0x30, 0x39); push (@word_arr, $c); } my $word_buf = join ("", @word_arr); ## ## gen hash ## my $tmp_hash = gen_hash ($mode, $word_buf, $salt_buf); ## ## run ## my @cmd = ( $hashcat, "-a 0 -m", $mode, $tmp_hash ); print sprintf ("echo -n %-20s | %s \${OPTS} %s %4d '%s'\n", $word_buf, @cmd); } ## ## subs ## sub min { $_[$_[0] > $_[1]]; } sub get_random_string { my $len = shift; my @arr; for (my $i = 0; $i < $len; $i++) { my $c = get_random_chr (0x30, 0x39); push (@arr, $c); } my $buf = join ("", @arr); return $buf; } sub get_random_num { my $min = shift; my $max = shift; return int ((rand ($max - $min)) + $min); } sub get_random_chr { return chr get_random_num (@_); } sub domino_decode { my $str = shift; my $decoded = ""; for (my $i = 0; $i < length ($str); $i += 4) { my $num = domino_base64_decode (substr ($str, $i, 4), 4); $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff); } my $salt; my $digest; my $char; $salt = substr ($decoded, 0, 5); my $byte10 = (ord (substr ($salt, 3, 1)) - 4); if ($byte10 < 0) { $byte10 = 256 + $byte10; } substr ($salt, 3, 1) = chr ($byte10); $digest = substr ($decoded, 5, 9); $char = substr ($str, 18, 1); return ($digest, $salt, $char); } sub domino_85x_decode { my $str = shift; my $decoded = ""; for (my $i = 0; $i < length ($str); $i += 4) { my $num = domino_base64_decode (substr ($str, $i, 4), 4); $decoded .= chr (($num >> 16) & 0xff) . chr (($num >> 8) & 0xff) . chr ($num & 0xff); } my $digest; my $salt; my $iterations = -1; my $chars; $salt = substr ($decoded, 0, 16); # longer than -m 8700 (5 vs 16 <- new) my $byte10 = (ord (substr ($salt, 3, 1)) - 4); if ($byte10 < 0) { $byte10 = 256 + $byte10; } substr ($salt, 3, 1) = chr ($byte10); $iterations = substr ($decoded, 16, 10); if ($iterations =~ /^?d*$/) { # continue $iterations = $iterations + 0; # hack: make sure it is an int now (atoi ()) $chars = substr ($decoded, 26, 2); # in my example it is "02" $digest = substr ($decoded, 28, 8); # only of length of 8 vs 20 SHA1 bytes } return ($digest, $salt, $iterations, $chars); } sub domino_base64_decode { my $v = shift; my $n = shift; my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; my $ret = 0; my $i = 1; while ($i <= $n) { my $idx = (index ($itoa64, substr ($v, $n - $i, 1))) & 0x3f; $ret += ($idx << (6 * ($i - 1))); $i = $i + 1; } return $ret } sub domino_encode { my $final = shift; my $char = shift; my $byte10 = (ord (substr ($final, 3, 1)) + 4); if ($byte10 > 255) { $byte10 = $byte10 - 256; } substr ($final, 3, 1) = chr ($byte10); my $passwd = ""; $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); $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); $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); $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); $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); if (defined ($char)) { substr ($passwd, 18, 1) = $char; } substr ($passwd, 19, 1) = ""; return $passwd; } sub domino_85x_encode { my $final = shift; my $char = shift; my $byte10 = (ord (substr ($final, 3, 1)) + 4); if ($byte10 > 255) { $byte10 = $byte10 - 256; } substr ($final, 3, 1) = chr ($byte10); my $passwd = ""; $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); if (defined ($char)) { substr ($passwd, 18, 1) = $char; } return $passwd; } sub domino_base64_encode { my $v = shift; my $n = shift; my $itoa64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; my $ret = ""; while (($n - 1) >= 0) { $n = $n - 1; $ret = substr ($itoa64, $v & 0x3f, 1) . $ret; $v = $v >> 6; } return $ret } sub pseudo_base64 { my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; my $md5 = shift; my $s64 = ""; for my $i (0..3) { my $v = unpack "V", substr($md5, $i*4, 4); for (1..4) { $s64 .= substr($itoa64, $v & 0x3f, 1); $v >>= 6; } } return $s64; } sub racf_hash { my ($username, $password) = @_; $username = substr ($username . " " x 8, 0, 8); $password = substr ($password . " " x 8, 0, 8); my $username_ebc = ascii2ebcdic ($username); my $password_ebc = ascii2ebcdic ($password); my @pw = split ("", $password_ebc); for (my $i = 0; $i < 8; $i++) { $pw[$i] = unpack ("C", $pw[$i]); $pw[$i] ^= 0x55; $pw[$i] <<= 1; $pw[$i] = pack ("C", $pw[$i] & 0xff); } my $key = join ("", @pw); my $cipher = new Crypt::DES $key; my $ciphertext = $cipher->encrypt ($username_ebc); my $ct = unpack ("H16", $ciphertext); return $ct; } sub oracle_hash { my ($username, $password) = @_; my $userpass = pack('n*', unpack('C*', uc($username.$password))); $userpass .= pack('C', 0) while (length($userpass) % 8); my $key = pack('H*', "0123456789ABCDEF"); my $iv = pack('H*', "0000000000000000"); my $c = new Crypt::CBC( -literal_key => 1, -cipher => "DES", -key => $key, -iv => $iv, -header => "none" ); my $key2 = substr($c->encrypt($userpass), length($userpass)-8, 8); my $c2 = new Crypt::CBC( -literal_key => 1, -cipher => "DES", -key => $key2, -iv => $iv, -header => "none" ); my $hash = substr($c2->encrypt($userpass), length($userpass)-8, 8); return uc(unpack('H*', $hash)); } sub androidpin_hash { my $word_buf = shift; my $salt_buf = shift; my $w = sprintf ("%d%s%s", 0, $word_buf, $salt_buf); my $digest = sha1 ($w); for (my $i = 1; $i < 1024; $i++) { $w = $digest . sprintf ("%d%s%s", $i, $word_buf, $salt_buf); $digest = sha1 ($w); } my ($A, $B, $C, $D, $E) = unpack ("N5", $digest); return sprintf ("%08x%08x%08x%08x%08x", $A, $B, $C, $D, $E); } sub to64 { my $v = shift; my $n = shift; my $itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; my $ret = ""; while (($n - 1) >= 0) { $n = $n - 1; $ret .= substr ($itoa64, $v & 0x3f, 1); $v = $v >> 6; } return $ret } sub md5_crypt { my $magic = shift; my $iter = shift; my $pass = shift; my $salt = shift; my $hash = ""; # hash to be returned by this function my $final = md5 ($pass . $salt . $pass); $salt = substr ($salt, 0, 8); my $tmp = $pass . $magic . $salt; my $pass_len = length ($pass); my $i; for ($i = $pass_len; $i > 0; $i -= 16) { my $len = 16; if ($i < $len) { $len = $i; } $tmp .= substr ($final, 0, $len); } $i = $pass_len; while ($i > 0) { if ($i & 1) { $tmp .= chr (0); } else { $tmp .= substr ($pass, 0, 1); } $i >>= 1; } $final = md5 ($tmp); for ($i = 0; $i < $iter; $i++) { $tmp = ""; if ($i & 1) { $tmp .= $pass; } else { $tmp .= $final; } if ($i % 3) { $tmp .= $salt; } if ($i % 7) { $tmp .= $pass; } if ($i & 1) { $tmp .= $final; } else { $tmp .= $pass; } $final = md5 ($tmp); } # done # now format the output sting ("hash") my $hash_buf; $hash = to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 6, 1)) << 8) | (ord (substr ($final, 12, 1))), 4); $hash .= to64 ((ord (substr ($final, 1, 1)) << 16) | (ord (substr ($final, 7, 1)) << 8) | (ord (substr ($final, 13, 1))), 4); $hash .= to64 ((ord (substr ($final, 2, 1)) << 16) | (ord (substr ($final, 8, 1)) << 8) | (ord (substr ($final, 14, 1))), 4); $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 9, 1)) << 8) | (ord (substr ($final, 15, 1))), 4); $hash .= to64 ((ord (substr ($final, 4, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 5, 1))), 4); $hash .= to64 (ord (substr ($final, 11, 1)), 2); if ($iter == 1000) # default { $hash_buf = sprintf ("%s%s\$%s", $magic , $salt , $hash); } else { $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash); } return $hash_buf; } sub sha512_crypt { my $iter = shift; my $pass = shift; my $salt = shift; my $hash = ""; # hash to be returned by this function my $final = sha512 ($pass . $salt . $pass); $salt = substr ($salt, 0, 16); my $tmp = $pass . $salt; my $pass_len = length ($pass); my $salt_len = length ($salt); my $i; for ($i = $pass_len; $i > 0; $i -= 16) { my $len = 16; if ($i < $len) { $len = $i; } $tmp .= substr ($final, 0, $len); } $i = $pass_len; while ($i > 0) { if ($i & 1) { $tmp .= $final; } else { $tmp .= $pass; } $i >>= 1; } $final = sha512 ($tmp); # p_bytes my $p_bytes = ""; for ($i = 0; $i < $pass_len; $i++) { $p_bytes .= $pass; } $p_bytes = sha512 ($p_bytes); $p_bytes = substr ($p_bytes, 0, $pass_len); # s_bytes my $final_first_byte = ord (substr ($final, 0, 1)); my $s_bytes = ""; for ($i = 0; $i < (16 + $final_first_byte); $i++) { $s_bytes .= $salt; } $s_bytes = sha512 ($s_bytes); $s_bytes = substr ($s_bytes, 0, $salt_len); for ($i = 0; $i < $iter; $i++) { $tmp = ""; if ($i & 1) { $tmp .= $p_bytes; } else { $tmp .= $final; } if ($i % 3) { $tmp .= $s_bytes; } if ($i % 7) { $tmp .= $p_bytes; } if ($i & 1) { $tmp .= $final; } else { $tmp .= $p_bytes; } $final = sha512 ($tmp); } # done # now format the output string ("hash") my $hash_buf; $hash .= to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 21, 1)) << 8) | (ord (substr ($final, 42, 1))), 4); $hash .= to64 ((ord (substr ($final, 22, 1)) << 16) | (ord (substr ($final, 43, 1)) << 8) | (ord (substr ($final, 1, 1))), 4); $hash .= to64 ((ord (substr ($final, 44, 1)) << 16) | (ord (substr ($final, 2, 1)) << 8) | (ord (substr ($final, 23, 1))), 4); $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 24, 1)) << 8) | (ord (substr ($final, 45, 1))), 4); $hash .= to64 ((ord (substr ($final, 25, 1)) << 16) | (ord (substr ($final, 46, 1)) << 8) | (ord (substr ($final, 4, 1))), 4); $hash .= to64 ((ord (substr ($final, 47, 1)) << 16) | (ord (substr ($final, 5, 1)) << 8) | (ord (substr ($final, 26, 1))), 4); $hash .= to64 ((ord (substr ($final, 6, 1)) << 16) | (ord (substr ($final, 27, 1)) << 8) | (ord (substr ($final, 48, 1))), 4); $hash .= to64 ((ord (substr ($final, 28, 1)) << 16) | (ord (substr ($final, 49, 1)) << 8) | (ord (substr ($final, 7, 1))), 4); $hash .= to64 ((ord (substr ($final, 50, 1)) << 16) | (ord (substr ($final, 8, 1)) << 8) | (ord (substr ($final, 29, 1))), 4); $hash .= to64 ((ord (substr ($final, 9, 1)) << 16) | (ord (substr ($final, 30, 1)) << 8) | (ord (substr ($final, 51, 1))), 4); $hash .= to64 ((ord (substr ($final, 31, 1)) << 16) | (ord (substr ($final, 52, 1)) << 8) | (ord (substr ($final, 10, 1))), 4); $hash .= to64 ((ord (substr ($final, 53, 1)) << 16) | (ord (substr ($final, 11, 1)) << 8) | (ord (substr ($final, 32, 1))), 4); $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 33, 1)) << 8) | (ord (substr ($final, 54, 1))), 4); $hash .= to64 ((ord (substr ($final, 34, 1)) << 16) | (ord (substr ($final, 55, 1)) << 8) | (ord (substr ($final, 13, 1))), 4); $hash .= to64 ((ord (substr ($final, 56, 1)) << 16) | (ord (substr ($final, 14, 1)) << 8) | (ord (substr ($final, 35, 1))), 4); $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 36, 1)) << 8) | (ord (substr ($final, 57, 1))), 4); $hash .= to64 ((ord (substr ($final, 37, 1)) << 16) | (ord (substr ($final, 58, 1)) << 8) | (ord (substr ($final, 16, 1))), 4); $hash .= to64 ((ord (substr ($final, 59, 1)) << 16) | (ord (substr ($final, 17, 1)) << 8) | (ord (substr ($final, 38, 1))), 4); $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 39, 1)) << 8) | (ord (substr ($final, 60, 1))), 4); $hash .= to64 ((ord (substr ($final, 40, 1)) << 16) | (ord (substr ($final, 61, 1)) << 8) | (ord (substr ($final, 19, 1))), 4); $hash .= to64 ((ord (substr ($final, 62, 1)) << 16) | (ord (substr ($final, 20, 1)) << 8) | (ord (substr ($final, 41, 1))), 4); $hash .= to64 (ord (substr ($final, 63, 1)), 2); my $magic = '$6$'; if ($iter == 5000) # default { $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash); } else { $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash); } return $hash_buf; } sub sha256_crypt { my $iter = shift; my $pass = shift; my $salt = shift; my $hash = ""; # hash to be returned by this function my $final = sha256 ($pass . $salt . $pass); $salt = substr ($salt, 0, 16); my $tmp = $pass . $salt; my $pass_len = length ($pass); my $salt_len = length ($salt); my $i; for ($i = $pass_len; $i > 0; $i -= 16) { my $len = 16; if ($i < $len) { $len = $i; } $tmp .= substr ($final, 0, $len); } $i = $pass_len; while ($i > 0) { if ($i & 1) { $tmp .= $final; } else { $tmp .= $pass; } $i >>= 1; } $final = sha256 ($tmp); # p_bytes my $p_bytes = ""; for ($i = 0; $i < $pass_len; $i++) { $p_bytes .= $pass; } $p_bytes = sha256 ($p_bytes); $p_bytes = substr ($p_bytes, 0, $pass_len); # s_bytes my $final_first_byte = ord (substr ($final, 0, 1)); my $s_bytes = ""; for ($i = 0; $i < (16 + $final_first_byte); $i++) { $s_bytes .= $salt; } $s_bytes = sha256 ($s_bytes); $s_bytes = substr ($s_bytes, 0, $salt_len); for ($i = 0; $i < $iter; $i++) { $tmp = ""; if ($i & 1) { $tmp .= $p_bytes; } else { $tmp .= $final; } if ($i % 3) { $tmp .= $s_bytes; } if ($i % 7) { $tmp .= $p_bytes; } if ($i & 1) { $tmp .= $final; } else { $tmp .= $p_bytes; } $final = sha256 ($tmp); } # done # now format the output string ("hash") my $hash_buf; $hash .= to64 ((ord (substr ($final, 0, 1)) << 16) | (ord (substr ($final, 10, 1)) << 8) | (ord (substr ($final, 20, 1))), 4); $hash .= to64 ((ord (substr ($final, 21, 1)) << 16) | (ord (substr ($final, 1, 1)) << 8) | (ord (substr ($final, 11, 1))), 4); $hash .= to64 ((ord (substr ($final, 12, 1)) << 16) | (ord (substr ($final, 22, 1)) << 8) | (ord (substr ($final, 2, 1))), 4); $hash .= to64 ((ord (substr ($final, 3, 1)) << 16) | (ord (substr ($final, 13, 1)) << 8) | (ord (substr ($final, 23, 1))), 4); $hash .= to64 ((ord (substr ($final, 24, 1)) << 16) | (ord (substr ($final, 4, 1)) << 8) | (ord (substr ($final, 14, 1))), 4); $hash .= to64 ((ord (substr ($final, 15, 1)) << 16) | (ord (substr ($final, 25, 1)) << 8) | (ord (substr ($final, 5, 1))), 4); $hash .= to64 ((ord (substr ($final, 6, 1)) << 16) | (ord (substr ($final, 16, 1)) << 8) | (ord (substr ($final, 26, 1))), 4); $hash .= to64 ((ord (substr ($final, 27, 1)) << 16) | (ord (substr ($final, 7, 1)) << 8) | (ord (substr ($final, 17, 1))), 4); $hash .= to64 ((ord (substr ($final, 18, 1)) << 16) | (ord (substr ($final, 28, 1)) << 8) | (ord (substr ($final, 8, 1))), 4); $hash .= to64 ((ord (substr ($final, 9, 1)) << 16) | (ord (substr ($final, 19, 1)) << 8) | (ord (substr ($final, 29, 1))), 4); $hash .= to64 ((ord (substr ($final, 31, 1)) << 8) | (ord (substr ($final, 30, 1))), 3); my $magic = '$5$'; if ($iter == 5000) # default { $hash_buf = sprintf ("%s%s\$%s", $magic, $salt , $hash); } else { $hash_buf = sprintf ("%srounds=%i\$%s\$%s", $magic, $iter, $salt , $hash); } return $hash_buf; } sub aix_ssha256_pbkdf2 { my $word_buf = shift; my $salt_buf = shift; my $iterations = shift; my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, output_len => 32 ); my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf); my $tmp_hash = ""; $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 30, 1))) << 16) | (int (ord (substr ($hash_buf, 31, 1))) << 8) , 3); return $tmp_hash; } sub aix_ssha512_pbkdf2 { my $word_buf = shift; my $salt_buf = shift; my $iterations = shift; my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, ); my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf); my $tmp_hash = ""; $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $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); $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 63, 1))) << 16) , 2); return $tmp_hash; } sub aix_ssha1_pbkdf2 { my $word_buf = shift; my $salt_buf = shift; my $iterations = shift; my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'); my $pbkdf2 = Crypt::PBKDF2->new ( hasher => $hasher, iterations => $iterations, ); my $hash_buf = $pbkdf2->PBKDF2 ($salt_buf, $word_buf); my $tmp_hash = ""; $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); $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); $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); $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); $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); $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); $tmp_hash .= to64 ((int (ord (substr ($hash_buf, 18, 1))) << 16) | (int (ord (substr ($hash_buf, 19, 1))) << 8) , 3); return $tmp_hash; } sub sapb_transcode { my $data_s = shift; my @data = split "", $data_s; my $transTable_s = "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\x3f\x40\x41\x50\x43\x44\x45\x4b\x47\x48\x4d\x4e\x54\x51\x53\x46" . "\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x56\x55\x5c\x49\x5d\x4a" . "\x42\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" . "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x58\x5b\x59\xff\x52" . "\x4c\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" . "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x57\x5e\x5a\x4f\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" . "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"; my @transTable = unpack ("C256", $transTable_s); my @out; for (my $i = 0; $i < scalar @data; $i++) { $out[$i] = $transTable[int (ord ($data[$i]))]; } return pack ("C*", @out); } sub sapb_waldorf { my $digest_s = shift; my $w_s = shift; my $s_s = shift; my @w = unpack "C*", $w_s; my @s = unpack "C*", $s_s; my $bcodeTable_s = "\x14\x77\xf3\xd4\xbb\x71\x23\xd0\x03\xff\x47\x93\x55\xaa\x66\x91" . "\xf2\x88\x6b\x99\xbf\xcb\x32\x1a\x19\xd9\xa7\x82\x22\x49\xa2\x51" . "\xe2\xb7\x33\x71\x8b\x9f\x5d\x01\x44\x70\xae\x11\xef\x28\xf0\x0d"; my @bcodeTable = unpack ("C48", $bcodeTable_s); my @abcd = unpack ("C16", $digest_s); my $sum20 = ($abcd[0] & 3) + ($abcd[1] & 3) + ($abcd[2] & 3) + ($abcd[3] & 3) + ($abcd[5] & 3); $sum20 |= 0x20; my @out; for (my $i2 = 0; $i2 < $sum20; $i2++) { $out[$i2] = 0; } for (my $i1 = 0, my $i2 = 0, my $i3 = 0; $i2 < $sum20; $i2++, $i2++) { if ($i1 < length $w_s) { if ($abcd[15 - $i1] & 1) { $out[$i2] = $bcodeTable[48 - 1 - $i1]; $i2++; } $out[$i2] = $w[$i1]; $i1++; $i2++; } if ($i3 < length $s_s) { $out[$i2] = $s[$i3]; $i2++; $i3++; } $out[$i2] = $bcodeTable[$i2 - $i1 - $i3]; } return substr (pack ("C*", @out), 0, $sum20); } sub setup_des_key { my @key_56 = split (//, shift); my $key = ""; $key = $key_56[0]; $key .= chr(((ord($key_56[0]) << 7) | (ord($key_56[1]) >> 1)) & 255); $key .= chr(((ord($key_56[1]) << 6) | (ord($key_56[2]) >> 2)) & 255); $key .= chr(((ord($key_56[2]) << 5) | (ord($key_56[3]) >> 3)) & 255); $key .= chr(((ord($key_56[3]) << 4) | (ord($key_56[4]) >> 4)) & 255); $key .= chr(((ord($key_56[4]) << 3) | (ord($key_56[5]) >> 5)) & 255); $key .= chr(((ord($key_56[5]) << 2) | (ord($key_56[6]) >> 6)) & 255); $key .= chr(( ord($key_56[6]) << 1) & 255); return $key; } sub randbytes { my $len = shift; my @arr; for (my $i = 0; $i < $len; $i++) { my $c = get_random_chr (0, 255); push (@arr, $c); } return join ("", @arr); } sub get_random_netntlmv1_salt { my $len_user = shift; my $len_domain = shift; my $char; my $type; my $user = ""; for (my $i = 0; $i < $len_user; $i++) { $type = get_random_num (1, 3); if ($type == 1) { $char = get_random_chr (0x30, 0x39); } elsif ($type == 2) { $char = get_random_chr (0x41, 0x5A); } else { $char = get_random_chr (0x61, 0x7A); } $user .= $char; } my $domain = ""; for (my $i = 0; $i < $len_domain; $i++) { $type = get_random_num (1, 3); if ($type == 1) { $char = get_random_chr (0x30, 0x39); } elsif ($type == 2) { $char = get_random_chr (0x41, 0x5A); } else { $char = get_random_chr (0x61, 0x7A); } $domain .= $char; } my $c_challenge = randbytes (8); my $s_challenge = randbytes (8); my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $c_challenge) . unpack ("H*", $s_challenge); return $salt_buf; } sub get_random_netntlmv2_salt { my $len_user = shift; my $len_domain = shift; my $char; my $type; my $user = ""; if ($len_user + $len_domain > 27) { if ($len_user > $len_domain) { $len_user = 27 - $len_domain; } else { $len_domain = 27 - $len_user; } } for (my $i = 0; $i < $len_user; $i++) { $type = get_random_num (1, 3); if ($type == 1) { $char = get_random_chr (0x30, 0x39); } elsif ($type == 2) { $char = get_random_chr (0x41, 0x5A); } else { $char = get_random_chr (0x61, 0x7A); } $user .= $char; } my $domain = ""; for (my $i = 0; $i < $len_domain; $i++) { $type = get_random_num (1, 3); if ($type == 1) { $char = get_random_chr (0x30, 0x39); } elsif ($type == 2) { $char = get_random_chr (0x41, 0x5A); } else { $char = get_random_chr (0x61, 0x7A); } $domain .= $char; } my $c_challenge = randbytes (8); my $s_challenge = randbytes (8); my $temp = "\x01\x01" . "\x00" x 6 . randbytes (8) . $c_challenge . "\x00" x 4 . randbytes (20 * rand () + 1) . "\x00"; my $salt_buf = $user . "::" . $domain . ":" . unpack ("H*", $s_challenge) . unpack ("H*", $temp); return $salt_buf; } sub get_random_ike_salt { my $nr_buf = ""; for (my $i = 0; $i < 40; $i++) { $nr_buf .= get_random_chr (0, 0xff); } my $msg_buf = ""; for (my $i = 0; $i < 440; $i++) { $msg_buf .= get_random_chr (0, 0xff); } my $nr_buf_hex = unpack ("H*", $nr_buf); my $msg_buf_hex = unpack ("H*", $msg_buf); 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)); return $salt_buf; } sub get_random_agilekeychain_salt { my $salt_buf = ""; for (my $i = 0; $i < 8; $i++) { $salt_buf .= get_random_chr (0x0, 0xff); } my $iv = ""; for (my $i = 0; $i < 16; $i++) { $iv .= get_random_chr (0x0, 0xff); } my $prefix = "\x00" x 1008; my $ret = unpack ("H*", $salt_buf . $prefix . $iv); return $ret; } sub get_random_cloudkeychain_salt { my $salt_buf = ""; for (my $i = 0; $i < 16; $i++) { $salt_buf .= get_random_chr (0x0, 0xff); } for (my $i = 0; $i < 304; $i++) { $salt_buf .= get_random_chr (0x0, 0xff); } my $ret = unpack ("H*", $salt_buf); return $ret; } sub get_random_kerberos5_salt { my $custom_salt = shift; my $clear_data = randbytes (14) . strftime ("%Y%m%d%H%M%S", localtime) . randbytes (8); my $user = "user"; my $realm = "realm"; my $salt = "salt"; my $salt_buf = $user . "\$" . $realm . "\$" . $salt . "\$" . unpack ("H*", $custom_salt) . "\$" . unpack ("H*", $clear_data) . "\$"; return $salt_buf; } sub get_random_md5chap_salt { my $salt_buf = shift; my $salt = unpack ("H*", $salt_buf); $salt .= ":"; $salt .= unpack ("H*", randbytes (1)); return $salt; } sub get_random_dnssec_salt { my $salt_buf = ""; $salt_buf .= "."; for (my $i = 0; $i < 8; $i++) { $salt_buf .= get_random_chr (0x61, 0x7a); } $salt_buf .= ".net"; $salt_buf .= ":"; for (my $i = 0; $i < 8; $i++) { $salt_buf .= get_random_chr (0x30, 0x39); } return $salt_buf; } sub md5bit { my $digest = shift; my $bit = shift; $bit %= 128; my $byte_off = int ($bit / 8); my $bit_off = int ($bit % 8); my $char = substr ($digest, $byte_off, 1); my $num = ord ($char); return (($num & (1 << $bit_off)) ? 1 : 0); } sub sun_md5 { my $pw = shift; my $salt = shift; my $iter = shift; my $constant_phrase = "To be, or not to be,--that is the question:--\n" . "Whether 'tis nobler in the mind to suffer\n" . "The slings and arrows of outrageous fortune\n" . "Or to take arms against a sea of troubles,\n" . "And by opposing end them?--To die,--to sleep,--\n" . "No more; and by a sleep to say we end\n" . "The heartache, and the thousand natural shocks\n" . "That flesh is heir to,--'tis a consummation\n" . "Devoutly to be wish'd. To die,--to sleep;--\n" . "To sleep! perchance to dream:--ay, there's the rub;\n" . "For in that sleep of death what dreams may come,\n" . "When we have shuffled off this mortal coil,\n" . "Must give us pause: there's the respect\n" . "That makes calamity of so long life;\n" . "For who would bear the whips and scorns of time,\n" . "The oppressor's wrong, the proud man's contumely,\n" . "The pangs of despis'd love, the law's delay,\n" . "The insolence of office, and the spurns\n" . "That patient merit of the unworthy takes,\n" . "When he himself might his quietus make\n" . "With a bare bodkin? who would these fardels bear,\n" . "To grunt and sweat under a weary life,\n" . "But that the dread of something after death,--\n" . "The undiscover'd country, from whose bourn\n" . "No traveller returns,--puzzles the will,\n" . "And makes us rather bear those ills we have\n" . "Than fly to others that we know not of?\n" . "Thus conscience does make cowards of us all;\n" . "And thus the native hue of resolution\n" . "Is sicklied o'er with the pale cast of thought;\n" . "And enterprises of great pith and moment,\n" . "With this regard, their currents turn awry,\n" . "And lose the name of action.--Soft you now!\n" . "The fair Ophelia!--Nymph, in thy orisons\n" . "Be all my sins remember'd.\n\x00"; my $constant_len = length ($constant_phrase); my $hash_buf = md5 ($pw . $salt); my $W; my $to_hash; for (my $round = 0; $round < $iter; $round++) { my $shift_a = md5bit ($hash_buf, $round + 0); my $shift_b = md5bit ($hash_buf, $round + 64); my @shift_4; my @shift_7; for (my $k = 0; $k < 16; $k++) { my $s7shift = ord (substr ($hash_buf, $k, 1)) % 8; my $l = ($k + 3) % 16; my $num = ord (substr ($hash_buf, $l, 1)); $shift_4[$k] = $num % 5; $shift_7[$k] = ($num >> $s7shift) & 1; } my @indirect_4; for (my $k = 0; $k < 16; $k++) { $indirect_4[$k] = (ord (substr ($hash_buf, $k, 1)) >> $shift_4[$k]) & 0xf; } my @indirect_7; for (my $k = 0; $k < 16; $k++) { $indirect_7[$k] = (ord (substr ($hash_buf, $indirect_4[$k], 1)) >> $shift_7[$k]) & 0x7f; } my $indirect_a = 0; my $indirect_b = 0; for (my $k = 0; $k < 8; $k++) { $indirect_a |= md5bit ($hash_buf, $indirect_7[$k + 0]) << $k; $indirect_b |= md5bit ($hash_buf, $indirect_7[$k + 8]) << $k; } $indirect_a = ($indirect_a >> $shift_a) & 0x7f; $indirect_b = ($indirect_b >> $shift_b) & 0x7f; my $bit_a = md5bit ($hash_buf, $indirect_a); my $bit_b = md5bit ($hash_buf, $indirect_b); $W = $hash_buf; my $pos = 16; my $total = $pos; $to_hash = ""; if ($bit_a ^ $bit_b) { substr ($W, 16, 48) = substr ($constant_phrase, 0, 48); $total += 48; $to_hash .= substr ($W, 0, 64); my $constant_off; for ($constant_off = 48; $constant_off < $constant_len - 64; $constant_off += 64) { substr ($W, 0, 64) = substr ($constant_phrase, $constant_off, 64); $total += 64; $to_hash .= substr ($W, 0, 64); } $pos = $constant_len - $constant_off; $total += $pos; substr ($W, 0, $pos) = substr ($constant_phrase, $constant_off, $pos); } my $a_len = 0; my @a_buf; $a_buf[0] = 0; $a_buf[1] = 0; $a_buf[2] = 0; $a_buf[3] = 0; my $tmp = $round; do { my $round_div = int ($tmp / 10); my $round_mod = int ($tmp % 10); $tmp = $round_div; $a_buf[int ($a_len / 4)] = (($round_mod + 0x30) | ($a_buf[int ($a_len / 4)] << 8)); $a_len++; } while ($tmp); my $tmp_str = ""; my $g; for ($g = 0; $g < $a_len; $g++) { my $remainder = $a_buf[$g]; my $factor = 7; my $started = 1; my $sub; while ($remainder > 0) { $sub = $remainder >> (8 * $factor); if ($started != 1 || $sub > 0) { $started = 0; $tmp_str = chr ($sub) . $tmp_str; $remainder -= ($sub << (8 * $factor)); } $factor--; } } substr ($W, $pos, $a_len) = $tmp_str; $pos += $a_len; $total += $a_len; $to_hash .= substr ($W, 0, $pos); $to_hash = substr ($to_hash, 0, $total); $hash_buf = md5 ($to_hash); } my $passwd = ""; $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); $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); $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); $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); $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); $passwd .= to64 ((int (ord (substr ($hash_buf, 11, 1)))), 2); return $passwd; } sub usage_die { die ("usage: $0 single|passthrough| [mode] [len]\n" . " or\n" . " $0 verify [mode] [hashfile] [cracks] [outfile]\n"); } sub pad16 { my $block_ref = shift; my $offset = shift; my $value = 16 - $offset; for (my $i = $offset; $i < 16; $i++) { push @{$block_ref}, $value; } } sub lotus_mix { my $in_ref = shift; my $p = 0; for (my $i = 0; $i < 18; $i++) { for (my $j = 0; $j < 48; $j++) { $p = ($p + 48 - $j) & 0xff; my $c = $lotus_magic_table[$p]; $p = $in_ref->[$j] ^ $c; $in_ref->[$j] = $p; } } } sub lotus_transform_password { my $in_ref = shift; my $out_ref = shift; my $t = $out_ref->[15]; for (my $i = 0; $i < 16; $i++) { $t ^= $in_ref->[$i]; my $c = $lotus_magic_table[$t]; $out_ref->[$i] ^= $c; $t = $out_ref->[$i]; } } sub mdtransform_norecalc { my $state_ref = shift; my $block_ref = shift; my @x; push (@x, @{$state_ref}); push (@x, @{$block_ref}); for (my $i = 0; $i < 16; $i++) { push (@x, $x[0 + $i] ^ $x[16 + $i]); } lotus_mix (\@x); for (my $i = 0; $i < 16; $i++) { $state_ref->[$i] = $x[$i]; } } sub mdtransform { my $state_ref = shift; my $checksum_ref = shift; my $block_ref = shift; mdtransform_norecalc ($state_ref, $block_ref); lotus_transform_password ($block_ref, $checksum_ref); } sub domino_big_md { my $saved_key_ref = shift; my $size = shift; @{$saved_key_ref} = splice (@{$saved_key_ref}, 0, $size); my @state = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); my @checksum; my $curpos; for ($curpos = 0; $curpos + 16 < $size; $curpos += 16) { my $curpos16 = $curpos + 16; my @block = splice (@{$saved_key_ref}, 0, 16); mdtransform (\@state, \@checksum, \@block); } my $left = $size - $curpos; my @block = splice (@{$saved_key_ref}, 0, 16); pad16 (\@block, $left); mdtransform (\@state, \@checksum, \@block); mdtransform_norecalc (\@state, \@checksum); return @state; } sub pdf_compute_encryption_key { my $word_buf = shift; my $padding = shift; my $id = shift; my $u = shift; my $o = shift; my $P = shift; my $V = shift; my $R = shift; my $enc = shift; ## start my $data; $data .= $word_buf; $data .= substr ($padding, 0, 32 - length $word_buf); $data .= pack ("H*", $o); $data .= pack ("I", $P); $data .= pack ("H*", $id); if ($R >= 4) { if (!$enc) { $data .= pack ("I", -1); } } my $res = md5 ($data); if ($R >= 3) { for (my $i = 0; $i < 50; $i++) { $res = md5 ($res); } } return $res; } sub gen_random_wpa_eapol { my $keyver = shift; my $snonce = shift; my $ret = ""; # version my $version = 1; # 802.1X-2001 $ret .= pack ("C*", $version); my $type = 3; # means that this EAPOL frame is used to transfer key information $ret .= pack ("C*", $type); my $length; # length of remaining data if ($keyver == 1) { $length = 119; } else { $length = 117; } $ret .= pack ("n*", $length); my $descriptor_type; if ($keyver == 1) { $descriptor_type = 254; # EAPOL WPA key } else { $descriptor_type = 1; # EAPOL RSN key } $ret .= pack ("C*", $descriptor_type); # key_info is a bit vector: # generated from these 13 bits: encrypted key data, request, error, secure, key mic, key ack, install, key index (2), key type, key descriptor (3) my $key_info = 0; $key_info |= 1 << 8; # set key MIC $key_info |= 1 << 3; # set if it is a pairwise key if ($keyver == 1) { $key_info |= 1 << 0; # RC4 Cipher, HMAC-MD5 MIC } else { $key_info |= 1 << 1; # AES Cipher, HMAC-SHA1 MIC } $ret .= pack ("n*", $key_info); my $key_length; if ($keyver == 1) { $key_length = 32; } else { $key_length = 0; } $ret .= pack ("n*", $key_length); my $replay_counter = 1; $ret .= pack ("Q>*", $replay_counter); $ret .= $snonce; my $key_iv = "\x00" x 16; $ret .= $key_iv; my $key_rsc = "\x00" x 8; $ret .= $key_rsc; my $key_id = "\x00" x 8; $ret .= $key_id; my $key_mic = "\x00" x 16; $ret .= $key_mic; my $key_data_len; if ($keyver == 1) { $key_data_len = 24; # length of the key_data (== WPA info) } else { $key_data_len = 22; # length of the key_data (== RSN info) } $ret .= pack ("n*", $key_data_len); my $key_data = ""; if ($keyver == 1) { # wpa info my $wpa_info = ""; my $vendor_specific_data = ""; my $tag_number = 221; # means it is a vendor specific tag $vendor_specific_data .= pack ("C*", $tag_number); my $tag_len = 22; # length of the remaining "tag data" $vendor_specific_data .= pack ("C*", $tag_len); my $vendor_specific_oui = pack ("H*", "0050f2"); # microsoft $vendor_specific_data .= $vendor_specific_oui; my $vendor_specific_oui_type = 1; # WPA Information Element $vendor_specific_data .= pack ("C*", $vendor_specific_oui_type); my $vendor_specific_wpa_version = 1; $vendor_specific_data .= pack ("v*", $vendor_specific_wpa_version); # multicast my $vendor_specific_multicast_oui = pack ("H*", "0050f2"); $vendor_specific_data .= $vendor_specific_multicast_oui; my $vendor_specific_multicast_type = 2; # TKIP $vendor_specific_data .= pack ("C*", $vendor_specific_multicast_type); # unicast my $vendor_specific_unicast_count = 1; $vendor_specific_data .= pack ("v*", $vendor_specific_unicast_count); my $vendor_specific_unicast_oui = pack ("H*", "0050f2"); $vendor_specific_data .= $vendor_specific_multicast_oui; my $vendor_specific_unicast_type = 2; # TKIP $vendor_specific_data .= pack ("C*", $vendor_specific_unicast_type); # Auth Key Management (AKM) my $auth_key_management_count = 1; $vendor_specific_data .= pack ("v*", $auth_key_management_count); my $auth_key_management_oui = pack ("H*", "0050f2"); $vendor_specific_data .= $auth_key_management_oui; my $auth_key_management_type = 2; # Pre-Shared Key (PSK) $vendor_specific_data .= pack ("C*", $auth_key_management_type); $wpa_info = $vendor_specific_data; $key_data = $wpa_info; } else { # rsn info my $rsn_info = ""; my $tag_number = 48; # RSN info $rsn_info .= pack ("C*", $tag_number); my $tag_len = 20; # length of the remaining "tag_data" $rsn_info .= pack ("C*", $tag_len); my $rsn_version = 1; $rsn_info .= pack ("v*", $rsn_version); # group cipher suite my $group_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021 $rsn_info .= $group_cipher_suite_oui; my $group_cipher_suite_type = 4; # AES (CCM) $rsn_info .= pack ("C*", $group_cipher_suite_type); # pairwise cipher suite my $pairwise_cipher_suite_count = 1; $rsn_info .= pack ("v*", $pairwise_cipher_suite_count); my $pairwise_cipher_suite_oui = pack ("H*", "000fac"); # Ieee8021 $rsn_info .= $pairwise_cipher_suite_oui; my $pairwise_cipher_suite_type = 4; # AES (CCM) $rsn_info .= pack ("C*", $pairwise_cipher_suite_type); # Auth Key Management (AKM) my $auth_key_management_count = 1; $rsn_info .= pack ("v*", $auth_key_management_count); my $auth_key_management_oui = pack ("H*", "000fac"); # Ieee8021 $rsn_info .= $auth_key_management_oui; my $auth_key_management_type = 2; # Pre-Shared Key (PSK) $rsn_info .= pack ("C*", $auth_key_management_type); # RSN Capabilities # bit vector of these 9 bits: peerkey enabled, management frame protection (MFP) capable, MFP required, # RSN GTKSA Capabilities (2), RSN PTKSA Capabilities (2), no pairwise Capabilities, Pre-Auth Capabilities my $rsn_capabilities = pack ("H*", "0000"); $rsn_info .= $rsn_capabilities; $key_data = $rsn_info; } $ret .= $key_data; return $ret; } sub wpa_prf_512 { my $pmk = shift; my $stmac = shift; my $bssid = shift; my $snonce = shift; my $anonce = shift; my $data = "Pairwise key expansion"; $data .= "\x00"; # # Min(AA, SPA) || Max(AA, SPA) # # compare if greater: Min()/Max() on the MACs (6 bytes) if (memcmp ($stmac, $bssid, 6) < 0) { $data .= $stmac; $data .= $bssid; } else { $data .= $bssid; $data .= $stmac; } # # Min(ANonce,SNonce) || Max(ANonce,SNonce) # # compare if greater: Min()/Max() on the nonces (32 bytes) if (memcmp ($snonce, $anonce, 32) < 0) { $data .= $snonce; $data .= $anonce; } else { $data .= $anonce; $data .= $snonce; } $data .= "\x00"; my $prf_buf = hmac ($data, $pmk, \&sha1); $prf_buf = substr ($prf_buf, 0, 16); return $prf_buf; } sub memcmp { my $str1 = shift; my $str2 = shift; my $len = shift; my $len_str1 = length ($str1); my $len_str2 = length ($str2); if (($len > $len_str1) || ($len > $len_str2)) { print "ERROR: memcmp () lengths wrong"; exit (1); } for (my $i = 0; $i < $len; $i++) { my $c_1 = ord (substr ($str1, $i, 1)); my $c_2 = ord (substr ($str2, $i, 1)); return -1 if ($c_1 < $c_2); return 1 if ($c_1 > $c_2); } return 0; }