summaryrefslogtreecommitdiff
path: root/extra/yassl/taocrypt/test/test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'extra/yassl/taocrypt/test/test.cpp')
-rw-r--r--extra/yassl/taocrypt/test/test.cpp947
1 files changed, 947 insertions, 0 deletions
diff --git a/extra/yassl/taocrypt/test/test.cpp b/extra/yassl/taocrypt/test/test.cpp
new file mode 100644
index 00000000000..c1f07cd4795
--- /dev/null
+++ b/extra/yassl/taocrypt/test/test.cpp
@@ -0,0 +1,947 @@
+// test.cpp
+// test taocrypt functionality
+
+#include <string.h>
+#include <stdio.h>
+
+#include "runtime.hpp"
+#include "sha.hpp"
+#include "md5.hpp"
+#include "md2.hpp"
+#include "ripemd.hpp"
+#include "hmac.hpp"
+#include "arc4.hpp"
+#include "des.hpp"
+#include "rsa.hpp"
+#include "dsa.hpp"
+#include "aes.hpp"
+#include "twofish.hpp"
+#include "blowfish.hpp"
+#include "asn.hpp"
+#include "dh.hpp"
+#include "coding.hpp"
+#include "random.hpp"
+#include "pwdbased.hpp"
+
+
+
+using TaoCrypt::byte;
+using TaoCrypt::word32;
+using TaoCrypt::SHA;
+using TaoCrypt::MD5;
+using TaoCrypt::MD2;
+using TaoCrypt::RIPEMD160;
+using TaoCrypt::HMAC;
+using TaoCrypt::ARC4;
+using TaoCrypt::DES_EDE3_CBC_Encryption;
+using TaoCrypt::DES_EDE3_CBC_Decryption;
+using TaoCrypt::DES_CBC_Encryption;
+using TaoCrypt::DES_CBC_Decryption;
+using TaoCrypt::DES_ECB_Encryption;
+using TaoCrypt::DES_ECB_Decryption;
+using TaoCrypt::AES_CBC_Encryption;
+using TaoCrypt::AES_CBC_Decryption;
+using TaoCrypt::AES_ECB_Encryption;
+using TaoCrypt::AES_ECB_Decryption;
+using TaoCrypt::Twofish_CBC_Encryption;
+using TaoCrypt::Twofish_CBC_Decryption;
+using TaoCrypt::Twofish_ECB_Encryption;
+using TaoCrypt::Twofish_ECB_Decryption;
+using TaoCrypt::Blowfish_CBC_Encryption;
+using TaoCrypt::Blowfish_CBC_Decryption;
+using TaoCrypt::Blowfish_ECB_Encryption;
+using TaoCrypt::Blowfish_ECB_Decryption;
+using TaoCrypt::RSA_PrivateKey;
+using TaoCrypt::RSA_PublicKey;
+using TaoCrypt::DSA_PrivateKey;
+using TaoCrypt::DSA_PublicKey;
+using TaoCrypt::DSA_Signer;
+using TaoCrypt::DSA_Verifier;
+using TaoCrypt::RSAES_Encryptor;
+using TaoCrypt::RSAES_Decryptor;
+using TaoCrypt::Source;
+using TaoCrypt::FileSource;
+using TaoCrypt::FileSource;
+using TaoCrypt::HexDecoder;
+using TaoCrypt::HexEncoder;
+using TaoCrypt::Base64Decoder;
+using TaoCrypt::Base64Encoder;
+using TaoCrypt::CertDecoder;
+using TaoCrypt::DH;
+using TaoCrypt::EncodeDSA_Signature;
+using TaoCrypt::DecodeDSA_Signature;
+using TaoCrypt::PBKDF2_HMAC;
+
+
+
+struct testVector {
+ byte* input_;
+ byte* output_;
+ size_t inLen_;
+ size_t outLen_;
+
+ testVector(const char* in, const char* out) : input_((byte*)in),
+ output_((byte*)out), inLen_(strlen(in)), outLen_(strlen(out)) {}
+};
+
+void file_test(int, char**);
+int sha_test();
+int md5_test();
+int md2_test();
+int ripemd_test();
+int hmac_test();
+int arc4_test();
+int des_test();
+int aes_test();
+int twofish_test();
+int blowfish_test();
+int rsa_test();
+int dsa_test();
+int dh_test();
+int pwdbased_test();
+
+TaoCrypt::RandomNumberGenerator rng;
+
+
+void err_sys(const char* msg, int es)
+{
+ printf("%s", msg);
+ exit(es);
+}
+
+// func_args from test.hpp, so don't have to pull in other junk
+struct func_args {
+ int argc;
+ char** argv;
+ int return_code;
+};
+
+
+void taocrypt_test(void* args)
+{
+ ((func_args*)args)->return_code = -1; // error state
+
+
+ int ret = 0;
+ if ( (ret = sha_test()) )
+ err_sys("SHA test failed!\n", ret);
+ else
+ printf( "SHA test passed!\n");
+
+ if ( (ret = md5_test()) )
+ err_sys("MD5 test failed!\n", ret);
+ else
+ printf( "MD5 test passed!\n");
+
+ if ( (ret = md2_test()) )
+ err_sys("MD2 test failed!\n", ret);
+ else
+ printf( "MD2 test passed!\n");
+
+ if ( (ret = ripemd_test()) )
+ err_sys("RIPEMD test failed!\n", ret);
+ else
+ printf( "RIPEMD test passed!\n");
+
+ if ( ( ret = hmac_test()) )
+ err_sys("HMAC test failed!\n", ret);
+ else
+ printf( "HMAC test passed!\n");
+
+ if ( (ret = arc4_test()) )
+ err_sys("ARC4 test failed!\n", ret);
+ else
+ printf( "ARC4 test passed!\n");
+
+ if ( (ret = des_test()) )
+ err_sys("DES test failed!\n", ret);
+ else
+ printf( "DES test passed!\n");
+
+ if ( (ret = aes_test()) )
+ err_sys("AES test failed!\n", ret);
+ else
+ printf( "AES test passed!\n");
+
+ if ( (ret = twofish_test()) )
+ err_sys("Twofish test failed!\n", ret);
+ else
+ printf( "Twofish test passed!\n");
+
+ if ( (ret = blowfish_test()) )
+ err_sys("Blowfish test failed!\n", ret);
+ else
+ printf( "Blowfish test passed!\n");
+
+ if ( (ret = rsa_test()) )
+ err_sys("RSA test failed!\n", ret);
+ else
+ printf( "RSA test passed!\n");
+
+ if ( (ret = dh_test()) )
+ err_sys("DH test failed!\n", ret);
+ else
+ printf( "DH test passed!\n");
+
+ if ( (ret = dsa_test()) )
+ err_sys("DSA test failed!\n", ret);
+ else
+ printf( "DSA test passed!\n");
+
+ if ( (ret = pwdbased_test()) )
+ err_sys("PBKDF2 test failed!\n", ret);
+ else
+ printf( "PBKDF2 test passed!\n");
+
+
+ ((func_args*)args)->return_code = ret;
+}
+
+
+// so overall tests can pull in test function
+#ifndef NO_MAIN_DRIVER
+
+ int main(int argc, char** argv)
+ {
+ func_args args;
+
+ args.argc = argc;
+ args.argv = argv;
+
+ taocrypt_test(&args);
+ return args.return_code;
+ }
+
+#endif // NO_MAIN_DRIVER
+
+
+void file_test(char* file, byte* check)
+{
+ FILE* f;
+ int i(0);
+ MD5 md5;
+ byte buf[1024];
+ byte md5sum[MD5::DIGEST_SIZE];
+
+ if( !( f = fopen( file, "rb" ) )) {
+ printf("Can't open %s\n", file);
+ return;
+ }
+ while( ( i = fread(buf, 1, sizeof(buf), f )) > 0 )
+ md5.Update(buf, i);
+
+ md5.Final(md5sum);
+ memcpy(check, md5sum, sizeof(md5sum));
+
+ for(int j = 0; j < MD5::DIGEST_SIZE; ++j )
+ printf( "%02x", md5sum[j] );
+
+ printf(" %s\n", file);
+
+ fclose(f);
+}
+
+
+int sha_test()
+{
+ SHA sha;
+ byte hash[SHA::DIGEST_SIZE];
+
+ testVector test_sha[] =
+ {
+ testVector("abc",
+ "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2"
+ "\x6C\x9C\xD0\xD8\x9D"),
+ testVector("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+ "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29"
+ "\xE5\xE5\x46\x70\xF1"),
+ testVector("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaa",
+ "\x00\x98\xBA\x82\x4B\x5C\x16\x42\x7B\xD7\xA1\x12\x2A\x5A\x44"
+ "\x2A\x25\xEC\x64\x4D"),
+ testVector("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaa",
+ "\xAD\x5B\x3F\xDB\xCB\x52\x67\x78\xC2\x83\x9D\x2F\x15\x1E\xA7"
+ "\x53\x99\x5E\x26\xA0")
+ };
+
+ int times( sizeof(test_sha) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ sha.Update(test_sha[i].input_, test_sha[i].inLen_);
+ sha.Final(hash);
+
+ if (memcmp(hash, test_sha[i].output_, SHA::DIGEST_SIZE) != 0)
+ return -1 - i;
+ }
+
+ return 0;
+}
+
+
+int md5_test()
+{
+ MD5 md5;
+ byte hash[MD5::DIGEST_SIZE];
+
+ testVector test_md5[] =
+ {
+ testVector("abc",
+ "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f"
+ "\x72"),
+ testVector("message digest",
+ "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d\x52\x5a\x2f\x31\xaa\xf1\x61"
+ "\xd0"),
+ testVector("abcdefghijklmnopqrstuvwxyz",
+ "\xc3\xfc\xd3\xd7\x61\x92\xe4\x00\x7d\xfb\x49\x6c\xca\x67\xe1"
+ "\x3b"),
+ testVector("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345"
+ "6789",
+ "\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d"
+ "\x9f"),
+ testVector("1234567890123456789012345678901234567890123456789012345678"
+ "9012345678901234567890",
+ "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55\xac\x49\xda\x2e\x21\x07\xb6"
+ "\x7a")
+ };
+
+ int times( sizeof(test_md5) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ md5.Update(test_md5[i].input_, test_md5[i].inLen_);
+ md5.Final(hash);
+
+ if (memcmp(hash, test_md5[i].output_, MD5::DIGEST_SIZE) != 0)
+ return -5 - i;
+ }
+
+ return 0;
+}
+
+
+int md2_test()
+{
+ MD2 md5;
+ byte hash[MD2::DIGEST_SIZE];
+
+ testVector test_md2[] =
+ {
+ testVector("",
+ "\x83\x50\xe5\xa3\xe2\x4c\x15\x3d\xf2\x27\x5c\x9f\x80\x69"
+ "\x27\x73"),
+ testVector("a",
+ "\x32\xec\x01\xec\x4a\x6d\xac\x72\xc0\xab\x96\xfb\x34\xc0"
+ "\xb5\xd1"),
+ testVector("abc",
+ "\xda\x85\x3b\x0d\x3f\x88\xd9\x9b\x30\x28\x3a\x69\xe6\xde"
+ "\xd6\xbb"),
+ testVector("message digest",
+ "\xab\x4f\x49\x6b\xfb\x2a\x53\x0b\x21\x9f\xf3\x30\x31\xfe"
+ "\x06\xb0"),
+ testVector("abcdefghijklmnopqrstuvwxyz",
+ "\x4e\x8d\xdf\xf3\x65\x02\x92\xab\x5a\x41\x08\xc3\xaa\x47"
+ "\x94\x0b"),
+ testVector("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+ "0123456789",
+ "\xda\x33\xde\xf2\xa4\x2d\xf1\x39\x75\x35\x28\x46\xc3\x03"
+ "\x38\xcd"),
+ testVector("12345678901234567890123456789012345678901234567890123456"
+ "789012345678901234567890",
+ "\xd5\x97\x6f\x79\xd8\x3d\x3a\x0d\xc9\x80\x6c\x3c\x66\xf3"
+ "\xef\xd8")
+ };
+
+ int times( sizeof(test_md2) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ md5.Update(test_md2[i].input_, test_md2[i].inLen_);
+ md5.Final(hash);
+
+ if (memcmp(hash, test_md2[i].output_, MD2::DIGEST_SIZE) != 0)
+ return -10 - i;
+ }
+
+ return 0;
+}
+
+
+int ripemd_test()
+{
+ RIPEMD160 ripe160;
+ byte hash[RIPEMD160::DIGEST_SIZE];
+
+ testVector test_ripemd[] =
+ {
+ testVector("",
+ "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28\x08\x97\x7e\xe8"
+ "\xf5\x48\xb2\x25\x8d\x31"),
+ testVector("a",
+ "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae\x34\x7b\xe6\xf4"
+ "\xdc\x83\x5a\x46\x7f\xfe"),
+ testVector("abc",
+ "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6"
+ "\xb0\x87\xf1\x5a\x0b\xfc"),
+ testVector("message digest",
+ "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8\x81\xb1\x23\xa8"
+ "\x5f\xfa\x21\x59\x5f\x36"),
+ testVector("abcdefghijklmnopqrstuvwxyz",
+ "\xf7\x1c\x27\x10\x9c\x69\x2c\x1b\x56\xbb\xdc\xeb\x5b\x9d"
+ "\x28\x65\xb3\x70\x8d\xbc"),
+ testVector("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+ "\x12\xa0\x53\x38\x4a\x9c\x0c\x88\xe4\x05\xa0\x6c\x27\xdc"
+ "\xf4\x9a\xda\x62\xeb\x2b"),
+ testVector("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123"
+ "456789",
+ "\xb0\xe2\x0b\x6e\x31\x16\x64\x02\x86\xed\x3a\x87\xa5\x71"
+ "\x30\x79\xb2\x1f\x51\x89"),
+ testVector("12345678901234567890123456789012345678901234567890123456"
+ "789012345678901234567890",
+ "\x9b\x75\x2e\x45\x57\x3d\x4b\x39\xf4\xdb\xd3\x32\x3c\xab"
+ "\x82\xbf\x63\x32\x6b\xfb"),
+ };
+
+ int times( sizeof(test_ripemd) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ ripe160.Update(test_ripemd[i].input_, test_ripemd[i].inLen_);
+ ripe160.Final(hash);
+
+ if (memcmp(hash, test_ripemd[i].output_, RIPEMD160::DIGEST_SIZE) != 0)
+ return -100 - i;
+ }
+
+ return 0;
+}
+
+
+int hmac_test()
+{
+ HMAC<MD5> hmacMD5;
+ byte hash[MD5::DIGEST_SIZE];
+
+ const char* keys[]=
+ {
+ "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
+ "Jefe",
+ "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
+ };
+
+ testVector test_hmacMD5[] =
+ {
+ testVector("Hi There",
+ "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc"
+ "\x9d"),
+ testVector("what do ya want for nothing?",
+ "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7"
+ "\x38"),
+ testVector("\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD",
+ "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3"
+ "\xf6")
+ };
+
+ int times( sizeof(test_hmacMD5) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ hmacMD5.SetKey((byte*)keys[i], strlen(keys[i]));
+ hmacMD5.Update(test_hmacMD5[i].input_, test_hmacMD5[i].inLen_);
+ hmacMD5.Final(hash);
+
+ if (memcmp(hash, test_hmacMD5[i].output_, MD5::DIGEST_SIZE) != 0)
+ return -20 - i;
+ }
+
+ return 0;
+}
+
+
+int arc4_test()
+{
+ byte cipher[16];
+ byte plain[16];
+
+ const char* keys[] =
+ {
+ "\x01\x23\x45\x67\x89\xab\xcd\xef",
+ "\x01\x23\x45\x67\x89\xab\xcd\xef",
+ "\x00\x00\x00\x00\x00\x00\x00\x00",
+ "\xef\x01\x23\x45"
+ };
+
+ testVector test_arc4[] =
+ {
+ testVector("\x01\x23\x45\x67\x89\xab\xcd\xef",
+ "\x75\xb7\x87\x80\x99\xe0\xc5\x96"),
+ testVector("\x00\x00\x00\x00\x00\x00\x00\x00",
+ "\x74\x94\xc2\xe7\x10\x4b\x08\x79"),
+ testVector("\x00\x00\x00\x00\x00\x00\x00\x00",
+ "\xde\x18\x89\x41\xa3\x37\x5d\x3a"),
+ testVector("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+ "\xd6\xa1\x41\xa7\xec\x3c\x38\xdf\xbd\x61")
+ };
+
+
+ int times( sizeof(test_arc4) / sizeof(testVector) );
+ for (int i = 0; i < times; ++i) {
+ ARC4::Encryption enc;
+ ARC4::Decryption dec;
+
+ enc.SetKey((byte*)keys[i], strlen(keys[i]));
+ dec.SetKey((byte*)keys[i], strlen(keys[i]));
+
+ enc.Process(cipher, test_arc4[i].input_, test_arc4[i].outLen_);
+ dec.Process(plain, cipher, test_arc4[i].outLen_);
+
+ if (memcmp(plain, test_arc4[i].input_, test_arc4[i].outLen_))
+ return -30 - i;
+
+ if (memcmp(cipher, test_arc4[i].output_, test_arc4[i].outLen_))
+ return -40 - i;
+ }
+
+ return 0;
+}
+
+
+int des_test()
+{
+ //ECB mode
+ DES_ECB_Encryption enc;
+ DES_ECB_Decryption dec;
+
+
+ const byte key[] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
+ const byte iv[] = { 0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef };
+
+ const byte vector[] = { // "Now is the time for all " w/o trailing 0
+ 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
+ 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
+ 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
+ };
+
+ byte plain[24];
+ byte cipher[24];
+
+ enc.SetKey(key, sizeof(key));
+ enc.Process(cipher, vector, sizeof(vector));
+ dec.SetKey(key, sizeof(key));
+ dec.Process(plain, cipher, sizeof(cipher));
+
+ if (memcmp(plain, vector, sizeof(plain)))
+ return -50;
+
+ const byte verify1[] =
+ {
+ 0x3f,0xa4,0x0e,0x8a,0x98,0x4d,0x48,0x15,
+ 0x6a,0x27,0x17,0x87,0xab,0x88,0x83,0xf9,
+ 0x89,0x3d,0x51,0xec,0x4b,0x56,0x3b,0x53
+ };
+
+ if (memcmp(cipher, verify1, sizeof(cipher)))
+ return -51;
+
+ // CBC mode
+ DES_CBC_Encryption enc2;
+ DES_CBC_Decryption dec2;
+
+ enc2.SetKey(key, sizeof(key), iv);
+ enc2.Process(cipher, vector, sizeof(vector));
+ dec2.SetKey(key, sizeof(key), iv);
+ dec2.Process(plain, cipher, sizeof(cipher));
+
+ if (memcmp(plain, vector, sizeof(plain)))
+ return -52;
+
+ const byte verify2[] =
+ {
+ 0xe5,0xc7,0xcd,0xde,0x87,0x2b,0xf2,0x7c,
+ 0x43,0xe9,0x34,0x00,0x8c,0x38,0x9c,0x0f,
+ 0x68,0x37,0x88,0x49,0x9a,0x7c,0x05,0xf6
+ };
+
+ if (memcmp(cipher, verify2, sizeof(cipher)))
+ return -53;
+
+ // EDE3 CBC mode
+ DES_EDE3_CBC_Encryption enc3;
+ DES_EDE3_CBC_Decryption dec3;
+
+ const byte key3[] =
+ {
+ 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
+ 0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
+ 0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
+ };
+ const byte iv3[] =
+ {
+ 0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
+ 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+ 0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
+
+ };
+
+ enc3.SetKey(key3, sizeof(key3), iv3);
+ enc3.Process(cipher, vector, sizeof(vector));
+ dec3.SetKey(key3, sizeof(key3), iv3);
+ dec3.Process(plain, cipher, sizeof(cipher));
+
+ if (memcmp(plain, vector, sizeof(plain)))
+ return -54;
+
+ const byte verify3[] =
+ {
+ 0x43,0xa0,0x29,0x7e,0xd1,0x84,0xf8,0x0e,
+ 0x89,0x64,0x84,0x32,0x12,0xd5,0x08,0x98,
+ 0x18,0x94,0x15,0x74,0x87,0x12,0x7d,0xb0
+ };
+
+ if (memcmp(cipher, verify3, sizeof(cipher)))
+ return -55;
+
+ return 0;
+}
+
+
+int aes_test()
+{
+ AES_CBC_Encryption enc;
+ AES_CBC_Decryption dec;
+ const int bs(TaoCrypt::AES::BLOCK_SIZE);
+
+ const byte msg[] = { // "Now is the time for all " w/o trailing 0
+ 0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
+ 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
+ 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
+ };
+
+ byte key[] = "0123456789abcdef "; // align
+ byte iv[] = "1234567890abcdef "; // align
+
+ byte cipher[bs];
+ byte plain [bs];
+
+ enc.SetKey(key, bs, iv);
+ dec.SetKey(key, bs, iv);
+
+ enc.Process(cipher, msg, bs);
+ dec.Process(plain, cipher, bs);
+
+ if (memcmp(plain, msg, bs))
+ return -60;
+
+ const byte verify[] =
+ {
+ 0x95,0x94,0x92,0x57,0x5f,0x42,0x81,0x53,
+ 0x2c,0xcc,0x9d,0x46,0x77,0xa2,0x33,0xcb
+ };
+
+ if (memcmp(cipher, verify, bs))
+ return -61;
+
+ AES_ECB_Encryption enc2;
+ AES_ECB_Decryption dec2;
+
+ enc2.SetKey(key, bs, iv);
+ dec2.SetKey(key, bs, iv);
+
+ enc2.Process(cipher, msg, bs);
+ dec2.Process(plain, cipher, bs);
+
+ if (memcmp(plain, msg, bs))
+ return -62;
+
+ const byte verify2[] =
+ {
+ 0xd0,0xc9,0xd9,0xc9,0x40,0xe8,0x97,0xb6,
+ 0xc8,0x8c,0x33,0x3b,0xb5,0x8f,0x85,0xd1
+ };
+
+ if (memcmp(cipher, verify2, bs))
+ return -63;
+
+ return 0;
+}
+
+
+int twofish_test()
+{
+ Twofish_CBC_Encryption enc;
+ Twofish_CBC_Decryption dec;
+ const int bs(TaoCrypt::Twofish::BLOCK_SIZE);
+
+ const byte msg[] = { // "Now is the time for all " w/o trailing 0
+ 0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
+ 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
+ 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
+ };
+
+ byte key[] = "0123456789abcdef "; // align
+ byte iv[] = "1234567890abcdef "; // align
+
+ byte cipher[bs];
+ byte plain [bs];
+
+ enc.SetKey(key, bs, iv);
+ dec.SetKey(key, bs, iv);
+
+ enc.Process(cipher, msg, bs);
+ dec.Process(plain, cipher, bs);
+
+ if (memcmp(plain, msg, bs))
+ return -60;
+
+ const byte verify[] =
+ {
+ 0xD2,0xD7,0x47,0x47,0x4A,0x65,0x4E,0x16,
+ 0x21,0x03,0x58,0x79,0x5F,0x02,0x27,0x2C
+ };
+
+ if (memcmp(cipher, verify, bs))
+ return -61;
+
+ Twofish_ECB_Encryption enc2;
+ Twofish_ECB_Decryption dec2;
+
+ enc2.SetKey(key, bs, iv);
+ dec2.SetKey(key, bs, iv);
+
+ enc2.Process(cipher, msg, bs);
+ dec2.Process(plain, cipher, bs);
+
+ if (memcmp(plain, msg, bs))
+ return -62;
+
+ const byte verify2[] =
+ {
+ 0x3B,0x6C,0x63,0x10,0x34,0xAB,0xB2,0x87,
+ 0xC4,0xCD,0x6B,0x91,0x14,0xC5,0x3A,0x09
+ };
+
+ if (memcmp(cipher, verify2, bs))
+ return -63;
+
+ return 0;
+}
+
+
+int blowfish_test()
+{
+ Blowfish_CBC_Encryption enc;
+ Blowfish_CBC_Decryption dec;
+ const int bs(TaoCrypt::Blowfish::BLOCK_SIZE);
+
+ const byte msg[] = { // "Now is the time for all " w/o trailing 0
+ 0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
+ 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
+ 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
+ };
+
+ byte key[] = "0123456789abcdef "; // align
+ byte iv[] = "1234567890abcdef "; // align
+
+ byte cipher[bs * 2];
+ byte plain [bs * 2];
+
+ enc.SetKey(key, 16, iv);
+ dec.SetKey(key, 16, iv);
+
+ enc.Process(cipher, msg, bs * 2);
+ dec.Process(plain, cipher, bs * 2);
+
+ if (memcmp(plain, msg, bs))
+ return -60;
+
+ const byte verify[] =
+ {
+ 0x0E,0x26,0xAA,0x29,0x11,0x25,0xAB,0xB5,
+ 0xBC,0xD9,0x08,0xC4,0x94,0x6C,0x89,0xA3
+ };
+
+ if (memcmp(cipher, verify, bs))
+ return -61;
+
+ Blowfish_ECB_Encryption enc2;
+ Blowfish_ECB_Decryption dec2;
+
+ enc2.SetKey(key, 16, iv);
+ dec2.SetKey(key, 16, iv);
+
+ enc2.Process(cipher, msg, bs * 2);
+ dec2.Process(plain, cipher, bs * 2);
+
+ if (memcmp(plain, msg, bs))
+ return -62;
+
+ const byte verify2[] =
+ {
+ 0xE7,0x42,0xB9,0x37,0xC8,0x7D,0x93,0xCA,
+ 0x8F,0xCE,0x39,0x32,0xDE,0xD7,0xBC,0x5B
+ };
+
+ if (memcmp(cipher, verify2, bs))
+ return -63;
+
+ return 0;
+}
+
+
+int rsa_test()
+{
+ Source source;
+ FileSource("../certs/client-key.der", source);
+ if (source.size() == 0) {
+ FileSource("../../certs/client-key.der", source); // for testsuite
+ if (source.size() == 0) {
+ FileSource("../../../certs/client-key.der", source); // Debug dir
+ if (source.size() == 0)
+ err_sys("where's your certs dir?", -79);
+ }
+ }
+ RSA_PrivateKey priv(source);
+
+ RSAES_Encryptor enc(priv);
+ byte message[] = "Everyone gets Friday off.";
+ const int len(strlen((char*)message));
+ byte cipher[64];
+ enc.Encrypt(message, len, cipher, rng);
+
+ RSAES_Decryptor dec(priv);
+ byte plain[64];
+ dec.Decrypt(cipher, sizeof(cipher), plain, rng);
+
+ if (memcmp(plain, message, len))
+ return -70;
+
+ dec.SSL_Sign(message, len, cipher, rng);
+ if (!enc.SSL_Verify(message, len, cipher))
+ return -71;
+
+
+ // test decode
+ Source source2;
+ FileSource("../certs/client-cert.der", source2);
+ if (source2.size() == 0) {
+ FileSource("../../certs/client-cert.der", source2); // for testsuite
+ if (source2.size() == 0) {
+ FileSource("../../../certs/client-cert.der", source2); // Debug dir
+ if (source2.size() == 0)
+ err_sys("where's your certs dir?", -79);
+ }
+ }
+ CertDecoder cd(source2, true, 0, false, CertDecoder::CA);
+ Source source3(cd.GetPublicKey().GetKey(), cd.GetPublicKey().size());
+ RSA_PublicKey pub(source3);
+
+ return 0;
+}
+
+
+int dh_test()
+{
+ Source source;
+ FileSource("../certs/dh1024.dat", source);
+ if (source.size() == 0) {
+ FileSource("../../certs/dh1024.dat", source); // for testsuite
+ if (source.size() == 0) {
+ FileSource("../../../certs/dh1024.dat", source); // win32 Debug dir
+ if (source.size() == 0)
+ err_sys("where's your certs dir?", -79);
+ }
+ }
+ HexDecoder hDec(source);
+
+ DH dh(source);
+
+ byte pub[128];
+ byte priv[128];
+ byte agree[128];
+ byte pub2[128];
+ byte priv2[128];
+ byte agree2[128];
+
+ DH dh2(dh);
+
+ dh.GenerateKeyPair(rng, priv, pub);
+ dh2.GenerateKeyPair(rng, priv2, pub2);
+ dh.Agree(agree, priv, pub2);
+ dh2.Agree(agree2, priv2, pub);
+
+
+ if ( memcmp(agree, agree2, dh.GetByteLength()) )
+ return -80;
+
+ return 0;
+}
+
+
+int dsa_test()
+{
+ Source source;
+ FileSource("../certs/dsa512.der", source);
+ if (source.size() == 0) {
+ FileSource("../../certs/dsa512.der", source); // for testsuite
+ if (source.size() == 0) {
+ FileSource("../../../certs/dsa512.der", source); // win32 Debug dir
+ if (source.size() == 0)
+ err_sys("where's your certs dir?", -89);
+ }
+ }
+
+ const char msg[] = "this is the message";
+ byte signature[40];
+
+ DSA_PrivateKey priv(source);
+ DSA_Signer signer(priv);
+
+ SHA sha;
+ byte digest[SHA::DIGEST_SIZE];
+ sha.Update((byte*)msg, sizeof(msg));
+ sha.Final(digest);
+
+ signer.Sign(digest, signature, rng);
+
+ byte encoded[sizeof(signature) + 6];
+ byte decoded[40];
+
+ word32 encSz = EncodeDSA_Signature(signer.GetR(), signer.GetS(), encoded);
+ DecodeDSA_Signature(decoded, encoded, encSz);
+
+ DSA_PublicKey pub(priv);
+ DSA_Verifier verifier(pub);
+
+ if (!verifier.Verify(digest, decoded))
+ return -90;
+
+ return 0;
+}
+
+
+int pwdbased_test()
+{
+ PBKDF2_HMAC<SHA> pb;
+
+ byte derived[32];
+ const byte pwd1[] = "password "; // align
+ const byte salt[] = { 0x12, 0x34, 0x56, 0x78, 0x78, 0x56, 0x34, 0x12 };
+
+ pb.DeriveKey(derived, 8, pwd1, 8, salt, sizeof(salt), 5);
+
+ const byte verify1[] = { 0xD1, 0xDA, 0xA7, 0x86, 0x15, 0xF2, 0x87, 0xE6 };
+
+ if ( memcmp(derived, verify1, sizeof(verify1)) )
+ return -101;
+
+
+ const byte pwd2[] = "All n-entities must communicate with other n-entities"
+ " via n-1 entiteeheehees "; // align
+
+ pb.DeriveKey(derived, 24, pwd2, 76, salt, sizeof(salt), 500);
+
+ const byte verify2[] = { 0x6A, 0x89, 0x70, 0xBF, 0x68, 0xC9, 0x2C, 0xAE,
+ 0xA8, 0x4A, 0x8D, 0xF2, 0x85, 0x10, 0x85, 0x86,
+ 0x07, 0x12, 0x63, 0x80, 0xCC, 0x47, 0xAB, 0x2D
+ };
+
+ if ( memcmp(derived, verify2, sizeof(verify2)) )
+ return -102;
+
+ return 0;
+}
View Lorry Controller Status