diff --git a/tools/test_modules/m19811.pm b/tools/test_modules/m19811.pm index 90a785b88..2d69ffe91 100644 --- a/tools/test_modules/m19811.pm +++ b/tools/test_modules/m19811.pm @@ -14,107 +14,207 @@ use Encode; sub module_constraints { [[0, 256], [128, 128], [-1, -1], [-1, -1], [-1, -1]] } -sub module_generate_hash +sub aes_encrypt { - my $word = shift; - my $salt = shift; - my $data = shift // ""; + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; - my $iter = 1000; + my $data_base64 = encode_base64 ($data, ""); - my $pbkdf2 = Crypt::PBKDF2->new - ( - hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), - iterations => $iter - ); + my $python_code = <<'END_CODE'; - my $word_utf16le = encode ("UTF-16LE", $word); +from CryptoPlus.Cipher import AES +import base64 - my $salt_bin = pack ("H*", $salt); +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) - my $key = $pbkdf2->PBKDF2 ($salt_bin, $word_utf16le); +key = (key1, key2) - my $key_main = encode_base64 (substr ($key, 0, 32), ""); - my $key_tweak = encode_base64 (substr ($key, 32, 32), ""); +cipher = AES.new (key, AES.MODE_XTS) - my $diskcryptor_data = ""; +sequence = "01".decode ("hex") - $diskcryptor_data .= $salt_bin; +encrypted = cipher.encrypt (base64.b64decode (data), sequence) - if (length ($data) == 0) # normal case - { - $diskcryptor_data .= "DCRP"; +print encrypted.encode ("hex") - $diskcryptor_data .= random_bytes (4); +END_CODE - $diskcryptor_data .= (int (rand (2)) == 1) ? pack ("H*", "02000400") : pack ("H*", "02000500"); + # replace code with these values - $diskcryptor_data .= "\x00" x (2048 - length ($diskcryptor_data)); # fill it up to 2048 bytes - } - else # verify - { - # extract the data from the function parameter + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; - my $data_base64 = encode_base64 (pack ("H*", $data), ""); + $output_buf =~ s/[\r\n]//g; - # attention: this is the decryption (further down we have the reverse: encryption) + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) - my $python_code = <<'END_CODE'; + return $output_buf; +} + +sub aes_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; from CryptoPlus.Cipher import AES import base64 -aes_key1 = base64.b64decode (key_main) -aes_key2 = base64.b64decode (key_tweak) +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) -xts_key = (aes_key1, aes_key2) +key = (key1, key2) -cipher = AES.new (xts_key, AES.MODE_XTS) +cipher = AES.new (key, AES.MODE_XTS) sequence = "01".decode ("hex") -data_decrypted = cipher.decrypt (base64.b64decode (diskcryptor_data), sequence) +decrypted = cipher.decrypt (base64.b64decode (data), sequence) -print data_decrypted.encode ("hex") +print decrypted.encode ("hex") END_CODE - # replace code with these values + # replace code with these values - $python_code =~ s/key_main/"$key_main"/; - $python_code =~ s/key_tweak/"$key_tweak"/; - $python_code =~ s/diskcryptor_data/"$data_base64"/; + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; - my $output_buf = `python2 -c '$python_code'`; + my $output_buf = `python2 -c '$python_code'`; - $output_buf =~ s/[\r\n]//g; + $output_buf =~ s/[\r\n]//g; - $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) - $output_buf = pack ("H*", $output_buf); + $output_buf = pack ("H*", $output_buf); - $diskcryptor_data .= $output_buf; - } + return $output_buf; +} + +sub twofish_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; - $diskcryptor_data = encode_base64 ($diskcryptor_data, ""); + my $data_base64 = encode_base64 ($data, ""); my $python_code = <<'END_CODE'; -from CryptoPlus.Cipher import AES +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub twofish_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub serpent_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent import base64 -aes_key1 = base64.b64decode (key_main) -aes_key2 = base64.b64decode (key_tweak) +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) -xts_key = (aes_key1, aes_key2) +key = (key1, key2) -cipher = AES.new (xts_key, AES.MODE_XTS) +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) sequence = "01".decode ("hex") -data_encrypted = cipher.encrypt (base64.b64decode (diskcryptor_data), sequence) +encrypted = cipher.encrypt (base64.b64decode (data), sequence) -print data_encrypted.encode ("hex") +print encrypted.encode ("hex") END_CODE @@ -122,13 +222,183 @@ END_CODE $python_code =~ s/key_main/"$key_main"/; $python_code =~ s/key_tweak/"$key_tweak"/; - $python_code =~ s/diskcryptor_data/"$diskcryptor_data"/; + $python_code =~ s/data/"$data_base64"/; - my $hash_buf = `python2 -c '$python_code'`; + my $output_buf = `python2 -c '$python_code'`; - $hash_buf =~ s/[\r\n]//g; + $output_buf =~ s/[\r\n]//g; - $hash_buf = substr ($hash_buf, 128); # remove the "garbage" from the start (encrypted salt) + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub serpent_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub verify_data +{ + my $data = shift; + + if (length ($data) < 16) + { + return 0; + } + + if (substr ($data, 0, 4) ne "DCRP") + { + return 0; + } + + my $flags = unpack ("H*", substr ($data, 8, 6)); + + if (($flags ne "020004000000") && ($flags ne "020005000000") && ($flags ne "020008000000")) + { + return 0; + } + + return 1; +} + +sub module_generate_hash +{ + my $word = shift; + my $salt = shift; + my $data = shift // ""; + + my $iter = 1000; + + my $pbkdf2 = Crypt::PBKDF2->new + ( + hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), + iterations => $iter, + output_len => 64 + ); + + my $word_utf16le = encode ("UTF-16LE", $word); + + my $salt_bin = pack ("H*", $salt); + + my $key = $pbkdf2->PBKDF2 ($salt_bin, $word_utf16le); + + my $key1 = encode_base64 (substr ($key, 0, 32), ""); + my $key2 = encode_base64 (substr ($key, 32, 32), ""); + + my $algo = random_number (1, 3); + + my $diskcryptor_data = ""; + + $diskcryptor_data .= $salt_bin; + + if (length ($data) == 0) # normal case + { + $diskcryptor_data .= "DCRP"; + + $diskcryptor_data .= random_bytes (4); + + my $flags = random_number (1, 3); + + if ($flags == 1) + { + $diskcryptor_data .= pack ("H*", "02000400"); + } + elsif ($flags == 2) + { + $diskcryptor_data .= pack ("H*", "02000500"); + } + else + { + $diskcryptor_data .= pack ("H*", "02000800"); + } + + $diskcryptor_data .= "\x00" x (2048 - length ($diskcryptor_data)); # fill it up to 2048 bytes + } + else # verify + { + # decrypt the data and verify: + + $algo = 1; + + my $output_buf = aes_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 2; + + $output_buf = twofish_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 3; + + $output_buf = serpent_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + return; + } + } + } + + $diskcryptor_data .= $output_buf; + } + + my $hash_buf = ""; + + if ($algo == 1) + { + $hash_buf = aes_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 2) + { + $hash_buf = twofish_encrypt ($key1, $key2, $diskcryptor_data); + } + else + { + $hash_buf = serpent_encrypt ($key1, $key2, $diskcryptor_data); + } my $hash = sprintf ("\$diskcryptor\$0*%s%s", $salt, $hash_buf); @@ -167,6 +437,8 @@ sub module_verify_hash $word = pack_if_HEX_notation ($word); + $data = pack ("H*", $data); + my $new_hash = module_generate_hash ($word, $salt, $data); return ($new_hash, $word); diff --git a/tools/test_modules/m19812.pm b/tools/test_modules/m19812.pm new file mode 100644 index 000000000..0a945efd2 --- /dev/null +++ b/tools/test_modules/m19812.pm @@ -0,0 +1,488 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Crypt::PBKDF2; +use MIME::Base64 qw (encode_base64 decode_base64); +use Encode; + +sub module_constraints { [[0, 256], [128, 128], [-1, -1], [-1, -1], [-1, -1]] } + +sub aes_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import AES +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = AES.new (key, AES.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub aes_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import AES +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = AES.new (key, AES.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub twofish_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub twofish_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub serpent_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub serpent_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub verify_data +{ + my $data = shift; + + if (length ($data) < 16) + { + return 0; + } + + if (substr ($data, 0, 4) ne "DCRP") + { + return 0; + } + + my $flags = unpack ("H*", substr ($data, 8, 6)); + + if (($flags ne "020004000000") && ($flags ne "020005000000") && ($flags ne "020008000000")) + { + return 0; + } + + return 1; +} + +sub module_generate_hash +{ + my $word = shift; + my $salt = shift; + my $data = shift // ""; + + my $iter = 1000; + + my $pbkdf2 = Crypt::PBKDF2->new + ( + hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), + iterations => $iter, + output_len => 128 + ); + + my $word_utf16le = encode ("UTF-16LE", $word); + + my $salt_bin = pack ("H*", $salt); + + my $key = $pbkdf2->PBKDF2 ($salt_bin, $word_utf16le); + + my $key1 = encode_base64 (substr ($key, 0, 32), ""); + my $key2 = encode_base64 (substr ($key, 32, 32), ""); + my $key3 = encode_base64 (substr ($key, 64, 32), ""); + my $key4 = encode_base64 (substr ($key, 96, 32), ""); + + my $algo = random_number (1, 6); + + my $diskcryptor_data = ""; + + $diskcryptor_data .= $salt_bin; + + if (length ($data) == 0) # normal case + { + $diskcryptor_data .= "DCRP"; + + $diskcryptor_data .= random_bytes (4); + + my $flags = random_number (1, 3); + + if ($flags == 1) + { + $diskcryptor_data .= pack ("H*", "02000400"); + } + elsif ($flags == 2) + { + $diskcryptor_data .= pack ("H*", "02000500"); + } + else + { + $diskcryptor_data .= pack ("H*", "02000800"); + } + + $diskcryptor_data .= "\x00" x (2048 - length ($diskcryptor_data)); # fill it up to 2048 bytes + } + else # verify + { + # decrypt the data and verify: + + $algo = 1; + + my $output_buf = aes_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 2; + + $output_buf = twofish_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 3; + + $output_buf = serpent_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 4; + + $output_buf = aes_decrypt ($key2, $key4, $data); + $output_buf = twofish_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + $algo = 5; + + $output_buf = twofish_decrypt ($key2, $key4, $data); + $output_buf = serpent_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + $algo = 6; + + $output_buf = serpent_decrypt ($key2, $key4, $data); + $output_buf = aes_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + return; + } + } + } + } + } + } + + $diskcryptor_data .= $output_buf; + } + + my $hash_buf = ""; + + if ($algo == 1) + { + $hash_buf = aes_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 2) + { + $hash_buf = twofish_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 3) + { + $hash_buf = serpent_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 4) + { + $hash_buf = twofish_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = aes_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + elsif ($algo == 5) + { + $hash_buf = serpent_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = twofish_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + else + { + $hash_buf = aes_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = serpent_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + + my $hash = sprintf ("\$diskcryptor\$0*%s%s", $salt, $hash_buf); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my $index1 = index ($line, ":"); + + return if $index1 < 1; + + my $hash_in = substr ($line, 0, $index1); + + return unless (substr ($hash_in, 0, 13) eq "\$diskcryptor\$"); + + my $word = substr ($line, $index1 + 1); + + my $index2 = index ($hash_in, "\*", 13); + + return if $index2 < 1; + + my $version = substr ($hash_in, 13, $index2 - 13); + + return unless ($version eq "0"); + + my $data = substr ($hash_in, $index2 + 1); + + return unless (length ($data) == 4096); + + my $salt = substr ($data, 0, 128); + + return unless defined $word; + + $word = pack_if_HEX_notation ($word); + + $data = pack ("H*", $data); + + my $new_hash = module_generate_hash ($word, $salt, $data); + + return ($new_hash, $word); +} + +1; diff --git a/tools/test_modules/m19813.pm b/tools/test_modules/m19813.pm new file mode 100644 index 000000000..5f8c08dc9 --- /dev/null +++ b/tools/test_modules/m19813.pm @@ -0,0 +1,505 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Crypt::PBKDF2; +use MIME::Base64 qw (encode_base64 decode_base64); +use Encode; + +sub module_constraints { [[0, 256], [128, 128], [-1, -1], [-1, -1], [-1, -1]] } + +sub aes_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import AES +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = AES.new (key, AES.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub aes_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import AES +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = AES.new (key, AES.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub twofish_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub twofish_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Twofish +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Twofish.new (key, python_Twofish.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub serpent_encrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) + +sequence = "01".decode ("hex") + +encrypted = cipher.encrypt (base64.b64decode (data), sequence) + +print encrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + return $output_buf; +} + +sub serpent_decrypt +{ + my $key_main = shift; + my $key_tweak = shift; + my $data = shift; + + my $data_base64 = encode_base64 ($data, ""); + + my $python_code = <<'END_CODE'; + +from CryptoPlus.Cipher import python_Serpent +import base64 + +key1 = base64.b64decode (key_main) +key2 = base64.b64decode (key_tweak) + +key = (key1, key2) + +cipher = python_Serpent.new (key, python_Serpent.MODE_XTS) + +sequence = "01".decode ("hex") + +decrypted = cipher.decrypt (base64.b64decode (data), sequence) + +print decrypted.encode ("hex") + +END_CODE + + # replace code with these values + + $python_code =~ s/key_main/"$key_main"/; + $python_code =~ s/key_tweak/"$key_tweak"/; + $python_code =~ s/data/"$data_base64"/; + + my $output_buf = `python2 -c '$python_code'`; + + $output_buf =~ s/[\r\n]//g; + + $output_buf = substr ($output_buf, 128); # remove the "garbage" from the start (encrypted salt) + + $output_buf = pack ("H*", $output_buf); + + return $output_buf; +} + +sub verify_data +{ + my $data = shift; + + if (length ($data) < 16) + { + return 0; + } + + if (substr ($data, 0, 4) ne "DCRP") + { + return 0; + } + + my $flags = unpack ("H*", substr ($data, 8, 6)); + + if (($flags ne "020004000000") && ($flags ne "020005000000") && ($flags ne "020008000000")) + { + return 0; + } + + return 1; +} + +sub module_generate_hash +{ + my $word = shift; + my $salt = shift; + my $data = shift // ""; + + my $iter = 1000; + + my $pbkdf2 = Crypt::PBKDF2->new + ( + hasher => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 512), + iterations => $iter, + output_len => 192 + ); + + my $word_utf16le = encode ("UTF-16LE", $word); + + my $salt_bin = pack ("H*", $salt); + + my $key = $pbkdf2->PBKDF2 ($salt_bin, $word_utf16le); + + my $key1 = encode_base64 (substr ($key, 0, 32), ""); + my $key2 = encode_base64 (substr ($key, 32, 32), ""); + my $key3 = encode_base64 (substr ($key, 64, 32), ""); + my $key4 = encode_base64 (substr ($key, 96, 32), ""); + my $key5 = encode_base64 (substr ($key, 128, 32), ""); + my $key6 = encode_base64 (substr ($key, 160, 32), ""); + + my $algo = random_number (1, 7); + + my $diskcryptor_data = ""; + + $diskcryptor_data .= $salt_bin; + + if (length ($data) == 0) # normal case + { + $diskcryptor_data .= "DCRP"; + + $diskcryptor_data .= random_bytes (4); + + my $flags = random_number (1, 3); + + if ($flags == 1) + { + $diskcryptor_data .= pack ("H*", "02000400"); + } + elsif ($flags == 2) + { + $diskcryptor_data .= pack ("H*", "02000500"); + } + else + { + $diskcryptor_data .= pack ("H*", "02000800"); + } + + $diskcryptor_data .= "\x00" x (2048 - length ($diskcryptor_data)); # fill it up to 2048 bytes + } + else # verify + { + # decrypt the data and verify: + + $algo = 1; + + my $output_buf = aes_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 2; + + $output_buf = twofish_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 3; + + $output_buf = serpent_decrypt ($key1, $key2, $data); + + if (verify_data ($output_buf) == 0) + { + $algo = 4; + + $output_buf = aes_decrypt ($key2, $key4, $data); + $output_buf = twofish_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + $algo = 5; + + $output_buf = twofish_decrypt ($key2, $key4, $data); + $output_buf = serpent_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + $algo = 6; + + $output_buf = serpent_decrypt ($key2, $key4, $data); + $output_buf = aes_decrypt ($key1, $key3, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + $algo = 7; + + $output_buf = aes_decrypt ($key3, $key6, $data); + $output_buf = twofish_decrypt ($key2, $key5, $salt_bin . $output_buf); + $output_buf = serpent_decrypt ($key1, $key4, $salt_bin . $output_buf); + + if (verify_data ($output_buf) == 0) + { + return; + } + } + } + } + } + } + } + + $diskcryptor_data .= $output_buf; + } + + my $hash_buf = ""; + + if ($algo == 1) + { + $hash_buf = aes_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 2) + { + $hash_buf = twofish_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 3) + { + $hash_buf = serpent_encrypt ($key1, $key2, $diskcryptor_data); + } + elsif ($algo == 4) + { + $hash_buf = twofish_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = aes_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + elsif ($algo == 5) + { + $hash_buf = serpent_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = twofish_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + elsif ($algo == 6) + { + $hash_buf = aes_encrypt ($key1, $key3, $diskcryptor_data); + $hash_buf = serpent_encrypt ($key2, $key4, $salt_bin . pack ("H*", $hash_buf)); + } + else + { + $hash_buf = serpent_encrypt ($key1, $key4, $diskcryptor_data); + $hash_buf = twofish_encrypt ($key2, $key5, $salt_bin . pack ("H*", $hash_buf)); + $hash_buf = aes_encrypt ($key3, $key6, $salt_bin . pack ("H*", $hash_buf)); + } + + my $hash = sprintf ("\$diskcryptor\$0*%s%s", $salt, $hash_buf); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my $index1 = index ($line, ":"); + + return if $index1 < 1; + + my $hash_in = substr ($line, 0, $index1); + + return unless (substr ($hash_in, 0, 13) eq "\$diskcryptor\$"); + + my $word = substr ($line, $index1 + 1); + + my $index2 = index ($hash_in, "\*", 13); + + return if $index2 < 1; + + my $version = substr ($hash_in, 13, $index2 - 13); + + return unless ($version eq "0"); + + my $data = substr ($hash_in, $index2 + 1); + + return unless (length ($data) == 4096); + + my $salt = substr ($data, 0, 128); + + return unless defined $word; + + $word = pack_if_HEX_notation ($word); + + $data = pack ("H*", $data); + + my $new_hash = module_generate_hash ($word, $salt, $data); + + return ($new_hash, $word); +} + +1;