/* This is the worst code you have ever seen written on purpose.... this code is just a big hack to test out the functionality of the library */ #ifdef SONY_PS2 #include #include #include "timer.h" #endif #include "../mycrypt.h" int errno; int null_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey) { return CRYPT_OK; } void null_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *key) { memcpy(ct, pt, 8); } void null_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *key) { memcpy(pt, ct, 8); } int null_test(void) { return CRYPT_OK; } int null_keysize(int *desired_keysize) { return CRYPT_OK; } const struct _cipher_descriptor null_desc = { "memcpy()", 255, 8, 8, 8, 1, &null_setup, &null_ecb_encrypt, &null_ecb_decrypt, &null_test, &null_keysize }; prng_state prng; void store_tests(void) { unsigned char buf[8]; unsigned long L; ulong64 LL; printf("LOAD32/STORE32 tests\n"); L = 0x12345678UL; STORE32L(L, &buf[0]); L = 0; LOAD32L(L, &buf[0]); if (L != 0x12345678UL) printf("LOAD/STORE32 Little don't work\n"); LL = CONST64(0x01020304050607); STORE64L(LL, &buf[0]); LL = 0; LOAD64L(LL, &buf[0]) if (LL != CONST64(0x01020304050607)) printf("LOAD/STORE64 Little don't work\n"); L = 0x12345678UL; STORE32H(L, &buf[0]); L = 0; LOAD32H(L, &buf[0]); if (L != 0x12345678UL) printf("LOAD/STORE32 High don't work\n"); LL = CONST64(0x01020304050607); STORE64H(LL, &buf[0]); LL = 0; LOAD64H(LL, &buf[0]) if (LL != CONST64(0x01020304050607)) printf("LOAD/STORE64 High don't work\n"); } void cipher_tests(void) { int x; printf("Ciphers compiled in\n"); for (x = 0; cipher_descriptor[x].name != NULL; x++) { printf(" %12s (%2d) Key Size: %4ld to %4ld, Block Size: %3ld, Default # of rounds: %2ld\n", cipher_descriptor[x].name, cipher_descriptor[x].ID, cipher_descriptor[x].min_key_length*8,cipher_descriptor[x].max_key_length*8, cipher_descriptor[x].block_length*8, cipher_descriptor[x].default_rounds); } } void ecb_tests(void) { int x; printf("ECB tests\n"); for (x = 0; cipher_descriptor[x].name != NULL; x++) { printf(" %12s: ", cipher_descriptor[x].name); if ((errno = cipher_descriptor[x].test()) != CRYPT_OK) printf(" **failed** Reason: %s\n", error_to_string(errno)); else printf("passed\n"); } } #ifdef CBC void cbc_tests(void) { symmetric_CBC cbc; int x, y; unsigned char blk[32], ct[32], key[32], IV[32]; const unsigned char test[] = { 0XFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; printf("CBC tests\n"); /* ---- CBC ENCODING ---- */ /* make up a block and IV */ for (x = 0; x < 32; x++) blk[x] = IV[x] = x; /* now lets start a cbc session */ if ((errno = cbc_start(find_cipher("blowfish"), IV, key, 16, 0, &cbc)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets encode 32 bytes */ for (x = 0; x < 4; x++) cbc_encrypt(blk+8*x, ct+8*x, &cbc); zeromem(blk, sizeof(blk)); /* ---- CBC DECODING ---- */ /* make up a IV */ for (x = 0; x < 32; x++) IV[x] = x; /* now lets start a cbc session */ if ((errno = cbc_start(find_cipher("blowfish"), IV, key, 16, 0, &cbc)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets decode 32 bytes */ for (x = 0; x < 4; x++) cbc_decrypt(ct+8*x, blk+8*x, &cbc); /* print output */ for (x = y = 0; x < 32; x++) if (blk[x] != x) y = 1; printf(" %s\n", y?"failed":"passed"); /* lets actually check the bytes */ memset(IV, 0, 8); IV[0] = 0xFF; /* IV = FF 00 00 00 00 00 00 00 */ memset(blk, 0, 32); blk[8] = 0xFF; /* BLK = 00 00 00 00 00 00 00 00 FF 00 00 00 00 00 00 00 */ cbc_start(find_cipher("memcpy()"), IV, key, 8, 0, &cbc); cbc_encrypt(blk, ct, &cbc); /* expect: FF 00 00 00 00 00 00 00 */ cbc_encrypt(blk+8, ct+8, &cbc); /* expect: 00 00 00 00 00 00 00 00 */ if (memcmp(ct, test, 16)) { printf("CBC failed logical testing.\n"); for (x = 0; x < 16; x++) printf("%02x ", ct[x]); printf("\n"); } else { printf("CBC passed logical testing.\n"); } } #else void cbc_tests(void) { printf("CBC not compiled in\n"); } #endif #ifdef OFB void ofb_tests(void) { symmetric_OFB ofb; int x, y; unsigned char blk[32], ct[32], key[32], IV[32]; printf("OFB tests\n"); /* ---- ofb ENCODING ---- */ /* make up a block and IV */ for (x = 0; x < 32; x++) blk[x] = IV[x] = x; /* now lets start a ofb session */ if ((errno = ofb_start(find_cipher("blowfish"), IV, key, 16, 0, &ofb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets encode 32 bytes */ for (x = 0; x < 4; x++) ofb_encrypt(blk+8*x, ct+8*x, 8, &ofb); zeromem(blk, sizeof(blk)); /* ---- ofb DECODING ---- */ /* make up a IV */ for (x = 0; x < 32; x++) IV[x] = x; /* now lets start a ofb session */ if ((errno = ofb_start(find_cipher("blowfish"), IV, key, 16, 0, &ofb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets decode 32 bytes */ for (x = 0; x < 4; x++) ofb_decrypt(ct+8*x, blk+8*x, 8, &ofb); /* print output */ for (x = y = 0; x < 32; x++) if (blk[x] != x) y = 1; printf(" %s\n", y?"failed":"passed"); } #else void ofb_tests(void) { printf("OFB not compiled in\n"); } #endif #ifdef CFB void cfb_tests(void) { symmetric_CFB cfb; int x, y; unsigned char blk[32], ct[32], key[32], IV[32]; printf("CFB tests\n"); /* ---- cfb ENCODING ---- */ /* make up a block and IV */ for (x = 0; x < 32; x++) blk[x] = IV[x] = x; /* now lets start a cfb session */ if ((errno = cfb_start(find_cipher("blowfish"), IV, key, 16, 0, &cfb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets encode 32 bytes */ for (x = 0; x < 4; x++) cfb_encrypt(blk+8*x, ct+8*x, 8, &cfb); zeromem(blk, sizeof(blk)); /* ---- cfb DECODING ---- */ /* make up ahash_descriptor[prng->yarrow.hash].hashsize IV */ for (x = 0; x < 32; x++) IV[x] = x; /* now lets start a cfb session */ if ((errno = cfb_start(find_cipher("blowfish"), IV, key, 16, 0, &cfb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets decode 32 bytes */ for (x = 0; x < 4; x++) cfb_decrypt(ct+8*x, blk+8*x, 8, &cfb); /* print output */ for (x = y = 0; x < 32; x++) if (blk[x] != x) y = 1; printf(" %s\n", y?"failed":"passed"); } #else void cfb_tests(void) { printf("CFB not compiled in\n"); } #endif #ifdef CTR void ctr_tests(void) { symmetric_CTR ctr; int x, y; unsigned char blk[32], ct[32], key[32], count[32]; const unsigned char test[] = { 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0 }; printf("CTR tests\n"); /* ---- CTR ENCODING ---- */ /* make up a block and IV */ for (x = 0; x < 32; x++) blk[x] = count[x] = x; /* now lets start a ctr session */ if ((errno = ctr_start(find_cipher("rijndael"), count, key, 16, 0, &ctr)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets encode 32 bytes */ for (x = 0; x < 4; x++) ctr_encrypt(blk+8*x, ct+8*x, 8, &ctr); zeromem(blk, sizeof(blk)); /* ---- CTR DECODING ---- */ /* make up a IV */ for (x = 0; x < 32; x++) count[x] = x; /* now lets start a cbc session */ if ((errno = ctr_start(find_cipher("rijndael"), count, key, 16, 0, &ctr)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* now lets decode 32 bytes */ for (x = 0; x < 4; x++) ctr_decrypt(ct+8*x, blk+8*x, 8, &ctr); /* print output */ for (x = y = 0; x < 32; x++) if (blk[x] != x) y = 1; printf(" %s\n", y?"failed":"passed"); /* lets actually check the bytes */ memset(count, 0, 8); count[0] = 0xFF; /* IV = FF 00 00 00 00 00 00 00 */ memset(blk, 0, 32); blk[9] = 2; /* BLK = 00 00 00 00 00 00 00 00 00 02 00 00 00 00 00 00 */ ctr_start(find_cipher("memcpy()"), count, key, 8, 0, &ctr); ctr_encrypt(blk, ct, 8, &ctr); /* expect: FF 00 00 00 00 00 00 00 */ ctr_encrypt(blk+8, ct+8, 8, &ctr); /* expect: 00 03 00 00 00 00 00 00 */ if (memcmp(ct, test, 16)) { printf("CTR failed logical testing.\n"); for (x = 0; x < 16; x++) printf("%02x ", ct[x]); printf("\n"); } else { printf("CTR passed logical testing.\n"); } } #else void ctr_tests(void) { printf("CTR not compiled in\n"); } #endif void hash_tests(void) { int x; printf("Hash tests\n"); for (x = 0; hash_descriptor[x].name != NULL; x++) { printf(" %10s (%2d) ", hash_descriptor[x].name, hash_descriptor[x].ID); if ((errno = hash_descriptor[x].test()) != CRYPT_OK) printf("**failed** Reason: %s\n", error_to_string(errno)); else printf("passed\n"); } } #ifdef MRSA void pad_test(void) { unsigned char in[100], out[100]; unsigned long x, y; /* make a dummy message */ for (x = 0; x < 16; x++) in[x] = (unsigned char)x; /* pad the message so that random filler is placed before and after it */ y = 100; if ((errno = rsa_pad(in, 16, out, &y, find_prng("yarrow"), &prng)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* depad the message to get the original content */ memset(in, 0, sizeof(in)); x = 100; if ((errno = rsa_depad(out, y, in, &x)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* check outcome */ printf("rsa_pad: "); if (x != 16) { printf("Failed. Wrong size.\n"); return; } for (x = 0; x < 16; x++) if (in[x] != x) { printf("Failed. Expected %02lx and got %02x.\n", x, in[x]); return; } printf("passed.\n"); } void rsa_test(void) { unsigned char in[4096], out[4096]; unsigned long x, y, z, limit; int stat; rsa_key key; clock_t t; /* ---- SINGLE ENCRYPT ---- */ /* encrypt a short 8 byte string */ if ((errno = rsa_make_key(&prng, find_prng("yarrow"), 1024/8, 65537, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } for (x = 0; x < 8; x++) in[x] = (unsigned char)(x+1); y = sizeof(in); if ((errno = rsa_exptmod(in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* decrypt it */ zeromem(in, sizeof(in)); x = sizeof(out); if ((errno = rsa_exptmod(out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* compare */ printf("RSA : "); for (x = 0; x < 8; x++) if (in[x] != (x+1)) { printf("Failed. x==%02lx, in[%ld]==%02x\n", x, x, in[x]); } printf("passed.\n"); #ifdef PK_PACKET /* ---- BLOCK ENCRYPT ---- */ /* now lets test rsa_encrypt() */ for (x = 0; x < 8; x++) in[x] = (unsigned char)x; x = sizeof(out); if ((errno = rsa_encrypt(in, 8, out, &x, &prng, find_prng("yarrow"), find_cipher("rijndael"), &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* test rsa_decrypt() */ zeromem(in, sizeof(in)); y = sizeof(in); if ((errno = rsa_decrypt(out, x, in, &y, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("rsa_encrypt()/rsa_decrypt(): "); for (y = 0; y < 8; y++) if (in[y] != y) { printf("failed.\n"); return; } printf("Passed.\n"); /* ---- SIGNATURES ---- */ x = sizeof(in); if ((errno = rsa_sign("hello", 5, in, &x, find_hash("md5"), &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if ((errno = rsa_verify(in, "hello", 5, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("RSA Signatures: %s, ", (stat==1)?"pass":"fail"); if ((errno = rsa_verify(in, "abcde", 5, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("%s\n", (stat==0)?"pass":"fail"); /* ---- EXPORT/IMPORT ---- */ x = sizeof(out); if ((errno = rsa_export(out, &x, PK_PRIVATE_OPTIMIZED, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("RSA Export takes %lu bytes\n", x); rsa_free(&key); if ((errno = rsa_import(out, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("RSA Import: "); if ((errno = rsa_verify(in, "hello", 5, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("%s, ", (stat==1)?"pass":"fail"); if ((errno = rsa_verify(in, "abcde", 5, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("%s\n", (stat==0)?"pass":"fail"); #endif /* test the rsa_encrypt_key functions */ for (x = 0; x < 16; x++) in[x] = x; y = sizeof(out); if ((errno = rsa_encrypt_key(in, 16, out, &y, &prng, find_prng("yarrow"), &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } zeromem(in, sizeof(in)); x = sizeof(in); if ((errno = rsa_decrypt_key(out, in, &x, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("RSA en/de crypt key routines: "); if (x != 16) { printf("Failed (length)\n"); return; } for (x = 0; x < 16; x++) if (in[x] != x) { printf("Failed (contents)\n"); return; } printf("Passed\n"); /* test sign_hash functions */ for (x = 0; x < 16; x++) in[x] = x; x = sizeof(in); if ((errno = rsa_sign_hash(in, 16, out, &x, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("RSA signed hash: %lu bytes\n", x); if ((errno = rsa_verify_hash(out, in, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("Verify hash: %s, ", stat?"passed":"failed"); in[0] ^= 1; if ((errno = rsa_verify_hash(out, in, &stat, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("%s\n", (!stat)?"passed":"failed"); rsa_free(&key); /* make a RSA key */ #ifdef SONY_PS2 limit = 1024; #else limit = 2048; #endif for (z = 1024; z <= limit; z += 512) { t = XCLOCK(); if ((errno = rsa_make_key(&prng, find_prng("yarrow"), z/8, 65537, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } t = XCLOCK() - t; printf("Took %.0f ms to make a %ld-bit RSA key.\n", 1000.0 * ((double)t / (double)XCLOCKS_PER_SEC), z); /* time encryption */ y = sizeof(in); t = XCLOCK(); if ((errno = rsa_exptmod(in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } t = XCLOCK() - t; printf("Took %.0f ms to encrypt with a %ld-bit RSA key.\n", 1000.0 * ((double)t / (double)XCLOCKS_PER_SEC), z); /* time decryption */ x = sizeof(out); t = XCLOCK(); if ((errno = rsa_exptmod(out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } t = XCLOCK() - t; printf("Took %.0f ms to decrypt with a %ld-bit RSA key.\n", 1000.0 * ((double)t / (double)XCLOCKS_PER_SEC), z); rsa_free(&key); } } #else void pad_test(void) { printf("MRSA not compiled in\n"); } void rsa_test(void) { printf("MRSA not compiled in\n"); } #endif #ifdef BASE64 void base64_test(void) { unsigned char buf[2][100]; unsigned long x, y; printf("Base64 tests\n"); zeromem(buf, sizeof(buf)); for (x = 0; x < 16; x++) buf[0][x] = (unsigned char)x; x = 100; if (base64_encode(buf[0], 16, buf[1], &x) != CRYPT_OK) { printf(" error: %s\n", error_to_string(errno)); return; } printf(" encoded 16 bytes to %ld bytes...[%s]\n", x, buf[1]); memset(buf[0], 0, 100); y = 100; if (base64_decode(buf[1], x, buf[0], &y) != CRYPT_OK) { printf(" error: %s\n", error_to_string(errno)); return; } printf(" decoded %ld bytes to %ld bytes\n", x, y); for (x = 0; x < 16; x++) if (buf[0][x] != x) { printf(" **failed**\n"); return; } printf(" passed\n"); } #else void base64_test(void) { printf("Base64 not compiled in\n"); } #endif void time_hash(void) { clock_t t1; int x, y; unsigned long z; unsigned char input[4096], out[MAXBLOCKSIZE]; printf("Hash Time Trials (4KB blocks):\n"); for (x = 0; hash_descriptor[x].name != NULL; x++) { t1 = XCLOCK(); z = sizeof(out); y = 0; while (XCLOCK() - t1 < (3 * XCLOCKS_PER_SEC)) { hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); hash_memory(x, input, 4096, out, &z); y += 16; } t1 = XCLOCK() - t1; printf("%-20s: Hash at %5.2f Mbit/sec\n", hash_descriptor[x].name, ((8.0 * 4096.0) * ((double)y / ((double)t1 / (double)XCLOCKS_PER_SEC))) / 1000000.0); } } void time_ecb(void) { clock_t t1, t2; long x, y1, y2; unsigned char pt[32], key[32]; symmetric_key skey; void (*func)(const unsigned char *, unsigned char *, symmetric_key *); printf("ECB Time Trials for the Symmetric Ciphers:\n"); for (x = 0; cipher_descriptor[x].name != NULL; x++) { cipher_descriptor[x].setup(key, cipher_descriptor[x].min_key_length, 0, &skey); #define DO1 func(pt,pt,&skey); #define DO2 DO1 DO1 #define DO4 DO2 DO2 #define DO8 DO4 DO4 #define DO16 DO8 DO8 #define DO32 DO16 DO16 #define DO64 DO32 DO32 #define DO128 DO64 DO64 #define DO256 DO128 DO128 func = cipher_descriptor[x].ecb_encrypt; y1 = 0; t1 = XCLOCK(); while (XCLOCK() - t1 < 2*XCLOCKS_PER_SEC) { DO256; y1 += 256; } t1 = XCLOCK() - t1; func = cipher_descriptor[x].ecb_decrypt; y2 = 0; t2 = XCLOCK(); while (XCLOCK() - t2 < 2*XCLOCKS_PER_SEC) { DO256; y2 += 256; } t2 = XCLOCK() - t2; printf("%-20s: Encrypt at %5.2f Mbit/sec and Decrypt at %5.2f Mbit/sec\n", cipher_descriptor[x].name, ((8.0 * (double)cipher_descriptor[x].block_length) * ((double)y1 / ((double)t1 / (double)XCLOCKS_PER_SEC))) / 1000000.0, ((8.0 * (double)cipher_descriptor[x].block_length) * ((double)y2 / ((double)t2 / (double)XCLOCKS_PER_SEC))) / 1000000.0); #undef DO256 #undef DO128 #undef DO64 #undef DO32 #undef DO16 #undef DO8 #undef DO4 #undef DO2 #undef DO1 } } #ifdef MDH void dh_tests(void) { unsigned char buf[3][4096]; unsigned long x, y, z; int low, high, stat, stat2; dh_key usera, userb; clock_t t1; /* if ((errno = dh_test()) != CRYPT_OK) printf("DH Error: %s\n", error_to_string(errno)); */ dh_sizes(&low, &high); printf("DH Keys from %d to %d supported.\n", low*8, high*8); /* make up two keys */ if ((errno = dh_make_key(&prng, find_prng("yarrow"), 96, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if ((errno = dh_make_key(&prng, find_prng("yarrow"), 96, &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* make the shared secret */ x = 4096; if ((errno = dh_shared_secret(&usera, &userb, buf[0], &x)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } y = 4096; if ((errno = dh_shared_secret(&userb, &usera, buf[1], &y)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if (y != x) { printf("DH Shared keys are not same size.\n"); return; } if (memcmp(buf[0], buf[1], x)) { printf("DH Shared keys not same contents.\n"); return; } /* now export userb */ y = 4096; if ((errno = dh_export(buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } dh_free(&userb); /* import and make the shared secret again */ if ((errno = dh_import(buf[1], &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } z = 4096; if ((errno = dh_shared_secret(&usera, &userb, buf[2], &z)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("DH routines: "); if (z != x) { printf("failed. Size don't match?\n"); return; } if (memcmp(buf[0], buf[2], x)) { printf("Failed. Content didn't match.\n"); return; } printf("Passed\n"); dh_free(&usera); dh_free(&userb); /* time stuff */ t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 96, &usera); t1 = XCLOCK() - t1; printf("Make dh-768 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 128, &usera); t1 = XCLOCK() - t1; printf("Make dh-1024 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); #ifndef SONY_PS2 t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 160, &usera); t1 = XCLOCK() - t1; printf("Make dh-1280 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 192, &usera); t1 = XCLOCK() - t1; printf("Make dh-1536 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 224, &usera); t1 = XCLOCK() - t1; printf("Make dh-1792 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 256, &usera); t1 = XCLOCK() - t1; printf("Make dh-2048 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); t1 = XCLOCK(); dh_make_key(&prng, find_prng("yarrow"), 320, &usera); t1 = XCLOCK() - t1; printf("Make dh-2560 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); dh_free(&usera); #endif #ifdef PK_PACKET /* try dh packet stuff */ for (x = 0; x < 16; x++) buf[0][x] = (unsigned char)x; dh_make_key(&prng, find_prng("yarrow"), 24, &usera); x = 4096; if (dh_encrypt(buf[0], 16, buf[1], &x, &prng, find_prng("yarrow"), find_cipher("rijndael"), find_hash("sha1"), &usera) != CRYPT_OK) { printf("dh_encrypt says %s\n", error_to_string(errno)); return; } printf("dh encrypted 16 bytes into %ld bytes!\n", x); y = 4096; if ((errno = dh_decrypt(buf[1], x, buf[2], &y, &usera)) != CRYPT_OK) { printf("dh_decrypt says %s\n", error_to_string(errno)); return; } printf("dh packet: "); if (16 != y) { printf("Failed: Sizes different! 16 vs %ld\n", y); return; } if (memcmp(buf[0], buf[2], 16)) { printf("Failed; Content mismatch.\n"); return; } printf("Passed!\n"); dh_free(&usera); /* try dh signatures */ dh_make_key(&prng, find_prng("yarrow"), 96, &usera); x = 4096; if ((errno = dh_sign("hello", 5, buf[0], &x, find_hash("sha1"), &prng, find_prng("yarrow"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("dh-768 Signature took %ld bytes\n", x); if ((errno = dh_verify(buf[0], "hello", 5, &stat, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if ((errno = dh_verify(buf[0], "hellp", 5, &stat2, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("dh Signatures: %s (%d,%d)\n", ((stat==1)&&(stat2==0))?"passed":"failed", stat,stat2); dh_free(&usera); #endif /* test encrypt_key */ dh_make_key(&prng, find_prng("yarrow"), 96, &usera); for (x = 0; x < 16; x++) buf[0][x] = x; y = sizeof(buf[1]); if ((errno = dh_encrypt_key(buf[0], 16, buf[1], &y, &prng, find_prng("yarrow"), find_hash("md5"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } zeromem(buf[0], sizeof(buf[0])); x = sizeof(buf[0]); if ((errno = dh_decrypt_key(buf[1], buf[0], &x, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("DH en/de crypt key routines: "); if (x != 16) { printf("Failed (length)\n"); return; } for (x = 0; x < 16; x++) if (buf[0][x] != x) { printf("Failed (contents)\n"); return; } printf("Passed (size %lu)\n", y); /* test sign_hash */ for (x = 0; x < 16; x++) buf[0][x] = x; x = sizeof(buf[1]); if ((errno = dh_sign_hash(buf[0], 16, buf[1], &x, &prng, find_prng("yarrow"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if (dh_verify_hash(buf[1], buf[0], 16, &stat, &usera)) { printf("Error: %s\n", error_to_string(errno)); return; } buf[0][0] ^= 1; if (dh_verify_hash(buf[1], buf[0], 16, &stat2, &usera)) { printf("Error: %s\n", error_to_string(errno)); return; } printf("dh_sign/verify_hash: %s (%d,%d)\n", ((stat==1)&&(stat2==0))?"passed":"failed", stat,stat2); dh_free(&usera); } #else void dh_tests(void) { printf("MDH not compiled in\n"); } #endif int callback_x = 0; void callback(void) { printf("%c\x08", "-\\|/"[++callback_x & 3]); #ifndef SONY_PS2 fflush(stdout); #endif } void rng_tests(void) { unsigned char buf[16]; clock_t t1; int x, y; printf("RNG tests\n"); t1 = XCLOCK(); x = rng_get_bytes(buf, sizeof(buf), &callback); t1 = XCLOCK() - t1; printf(" %f bytes per second...", (double)x / ((double)t1 / (double)XCLOCKS_PER_SEC)); printf("read %d bytes.\n ", x); for (y = 0; y < x; y++) printf("%02x ", buf[y]); printf("\n"); #ifdef YARROW if ((errno = rng_make_prng(128, find_prng("yarrow"), &prng, &callback)) != CRYPT_OK) { printf(" starting yarrow error: %s\n", error_to_string(errno)); exit(-1); } #endif } #ifdef MECC void ecc_tests(void) { unsigned char buf[4][4096]; unsigned long x, y, z; int stat, stat2, low, high; ecc_key usera, userb; clock_t t1; if ((errno = ecc_test()) != CRYPT_OK) printf("ecc Error: %s\n", error_to_string(errno)); ecc_sizes(&low, &high); printf("ecc Keys from %d to %d supported.\n", low*8, high*8); /* make up two keys */ if ((errno = ecc_make_key(&prng, find_prng("yarrow"), 24, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if ((errno = ecc_make_key(&prng, find_prng("yarrow"), 24, &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } /* make the shared secret */ x = 4096; if ((errno = ecc_shared_secret(&usera, &userb, buf[0], &x)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } y = 4096; if ((errno = ecc_shared_secret(&userb, &usera, buf[1], &y)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if (y != x) { printf("ecc Shared keys are not same size.\n"); return; } if (memcmp(buf[0], buf[1], x)) { printf("ecc Shared keys not same contents.\n"); return; } /* now export userb */ y = 4096; if ((errno = ecc_export(buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } ecc_free(&userb); printf("ECC-192 export took %ld bytes\n", y); /* import and make the shared secret again */ if ((errno = ecc_import(buf[1], &userb)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } z = 4096; if ((errno = ecc_shared_secret(&usera, &userb, buf[2], &z)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("ecc routines: "); if (z != x) { printf("failed. Size don't match?\n"); return; } if (memcmp(buf[0], buf[2], x)) { printf("Failed. Content didn't match.\n"); return; } printf("Passed\n"); ecc_free(&usera); ecc_free(&userb); /* time stuff */ t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 20, &usera); t1 = XCLOCK() - t1; printf("Make ECC-160 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 24, &usera); t1 = XCLOCK() - t1; printf("Make ECC-192 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 28, &usera); t1 = XCLOCK() - t1; printf("Make ECC-224 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); #ifndef SONY_PS2 t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 32, &usera); t1 = XCLOCK() - t1; printf("Make ECC-256 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 48, &usera); t1 = XCLOCK() - t1; printf("Make ECC-384 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); t1 = XCLOCK(); ecc_make_key(&prng, find_prng("yarrow"), 65, &usera); t1 = XCLOCK() - t1; printf("Make ECC-521 key took %f msec\n", 1000.0 * ((double)t1 / (double)XCLOCKS_PER_SEC)); ecc_free(&usera); #endif #ifdef PK_PACKET /* try ECC packet stuff */ for (x = 0; x < 16; x++) buf[0][x] = (unsigned char)x; ecc_make_key(&prng, find_prng("yarrow"), 20, &usera); x = 4096; if (ecc_encrypt(buf[0], 16, buf[1], &x, &prng, find_prng("yarrow"), find_cipher("rijndael"), find_hash("tiger"), &usera) != CRYPT_OK) { printf("ecc_encrypt says %s\n", error_to_string(errno)); return; } printf("Ecc encrypted 16 bytes into %ld bytes!\n", x); y = 4096; if ((errno = ecc_decrypt(buf[1], x, buf[2], &y, &usera)) != CRYPT_OK) { printf("ecc_decrypt says %s\n", error_to_string(errno)); return; } printf("ECC packet: "); if (16 != y) { printf("Failed: Sizes different! 16 vs %ld\n", y); return; } if (memcmp(buf[0], buf[2], 16)) { printf("Failed; Content mismatch.\n"); return; } printf("Passed!\n"); ecc_free(&usera); /* try ECC signatures */ ecc_make_key(&prng, find_prng("yarrow"), 20, &usera); x = 4096; if ((errno = ecc_sign("hello", 5, buf[0], &x, find_hash("sha1"), &prng, find_prng("yarrow"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("ECC-160 Signature took %ld bytes\n", x); if ((errno = ecc_verify(buf[0], "hello", 5, &stat, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if ((errno = ecc_verify(buf[0], "hellp", 5, &stat2, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("ECC Signatures: %s (%d,%d)\n", ((stat==1)&&(stat2==0))?"passed":"failed", stat,stat2); ecc_free(&usera); #endif /* test encrypt_key */ ecc_make_key(&prng, find_prng("yarrow"), 32, &usera); for (x = 0; x < 16; x++) buf[0][x] = x; y = sizeof(buf[1]); if ((errno = ecc_encrypt_key(buf[0], 16, buf[1], &y, &prng, find_prng("yarrow"), find_hash("md5"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } zeromem(buf[0], sizeof(buf[0])); x = sizeof(buf[0]); if ((errno = ecc_decrypt_key(buf[1],buf[0], &x, &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } printf("ECC en/de crypt key routines: "); if (x != 16) { printf("Failed (length)\n"); return; } for (x = 0; x < 16; x++) if (buf[0][x] != x) { printf("Failed (contents)\n"); return; } printf("Passed (size: %lu)\n", y); /* test sign_hash */ for (x = 0; x < 16; x++) buf[0][x] = x; x = sizeof(buf[1]); if ((errno = ecc_sign_hash(buf[0], 16, buf[1], &x, &prng, find_prng("yarrow"), &usera)) != CRYPT_OK) { printf("Error: %s\n", error_to_string(errno)); return; } if (ecc_verify_hash(buf[1], buf[0], 16, &stat, &usera)) { printf("Error: %s\n", error_to_string(errno)); return; } buf[0][0] ^= 1; if (ecc_verify_hash(buf[1], buf[0], 16, &stat2, &usera)) { printf("Error: %s\n", error_to_string(errno)); return; } printf("ecc_sign/verify_hash: %s (%d,%d)\n", ((stat==1)&&(stat2==0))?"passed":"failed", stat,stat2); ecc_free(&usera); } #else void ecc_tests(void) { printf("MECC not compiled in\n"); } #endif #ifdef GF void gf_tests(void) { gf_int a, b, c, d; int n; unsigned char buf[1024]; printf("GF tests\n"); gf_zero(a);gf_zero(b);gf_zero(c);gf_zero(d); /* a == 0x18000000b */ a[1] = 1; a[0] = 0x8000000bUL; /* b == 0x012345678 */ b[0] = 0x012345678UL; /* find 1/b mod a */ gf_invmod(b,a,c); /* find 1/1/b mod a */ gf_invmod(c,a,d); /* display them */ printf(" %08lx %08lx\n", c[0], d[0]); /* store as binary string */ n = gf_size(a); printf(" a takes %d bytes\n", n); gf_toraw(a, buf); gf_readraw(a, buf, n); printf(" a == %08lx%08lx\n", a[1], a[0]); /* primality testing */ gf_zero(a); a[0] = 0x169; printf(" GF prime: %s, ", gf_is_prime(a)?"passed":"failed"); a[0] = 0x168; printf(" %s\n", gf_is_prime(a)?"failed":"passed"); /* test sqrt code */ gf_zero(a); a[1] = 0x00000001; a[0] = 0x8000000bUL; gf_zero(b); b[0] = 0x12345678UL; gf_sqrt(b, a, c); gf_mulmod(c, c, a, b); printf(" (%08lx)^2 = %08lx (mod %08lx%08lx) \n", c[0], b[0], a[1], a[0]); } #else void gf_tests(void) { printf("GF not compiled in\n"); } #endif #ifdef MPI void test_prime(void) { unsigned char buf[1024]; mp_int a; int x; /* make a 1024 bit prime */ mp_init(&a); rand_prime(&a, 128, &prng, find_prng("yarrow")); /* dump it */ mp_todecimal(&a, buf); printf("1024-bit prime:\n"); for (x = 0; x < (int)strlen(buf); ) { printf("%c", buf[x]); if (!(++x % 60)) printf("\\ \n"); } printf("\n\n"); mp_clear(&a); } #else void test_prime(void) { printf("MPI not compiled in\n"); } #endif void register_all_algs(void) { #ifdef BLOWFISH register_cipher(&blowfish_desc); #endif #ifdef XTEA register_cipher(&xtea_desc); #endif #ifdef RC5 register_cipher(&rc5_desc); #endif #ifdef RC6 register_cipher(&rc6_desc); #endif #ifdef SAFERP register_cipher(&saferp_desc); #endif #ifdef SERPENT register_cipher(&serpent_desc); #endif #ifdef RIJNDAEL register_cipher(&rijndael_desc); #endif #ifdef TWOFISH register_cipher(&twofish_desc); #endif #ifdef SAFER register_cipher(&safer_k64_desc); register_cipher(&safer_sk64_desc); register_cipher(&safer_k128_desc); register_cipher(&safer_sk128_desc); #endif #ifdef RC2 register_cipher(&rc2_desc); #endif #ifdef DES register_cipher(&des_desc); register_cipher(&des3_desc); #endif #ifdef CAST5 register_cipher(&cast5_desc); #endif register_cipher(&null_desc); #ifdef SHA256 register_hash(&sha256_desc); #endif #ifdef TIGER register_hash(&tiger_desc); #endif #ifdef SHA1 register_hash(&sha1_desc); #endif #ifdef MD5 register_hash(&md5_desc); #endif #ifdef SHA384 register_hash(&sha384_desc); #endif #ifdef SHA512 register_hash(&sha512_desc); #endif #ifdef MD4 register_hash(&md4_desc); #endif #ifdef MD2 register_hash(&md2_desc); #endif #ifdef YARROW register_prng(&yarrow_desc); #endif #ifdef SPRNG register_prng(&sprng_desc); #endif } void kr_display(pk_key *kr) { static const char *system[] = { "NON-KEY", "RSA", "DH", "ECC" }; static const char *type[] = { "PRIVATE", "PUBLIC", "PRIVATE_OPTIMIZED" }; while (kr->system != NON_KEY) { printf("CRC [%08lx], System [%10s], Type [%20s], %s, %s, %s\n", kr->ID, system[kr->system], type[kr->key_type], kr->name, kr->email, kr->description); kr = kr->next; } printf("\n"); } void kr_test_makekeys(pk_key **kr) { if ((errno = kr_init(kr)) != CRYPT_OK) { printf("KR init error %s\n", error_to_string(errno)); exit(-1); } /* make a DH key */ printf("KR: Making DH key...\n"); if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), DH_KEY, 128, "dhkey", "dh@dh.dh", "dhkey one")) != CRYPT_OK) { printf("Make key error: %s\n", error_to_string(errno)); exit(-1); } /* make a ECC key */ printf("KR: Making ECC key...\n"); if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), ECC_KEY, 20, "ecckey", "ecc@ecc.ecc", "ecckey one")) != CRYPT_OK) { printf("Make key error: %s\n", error_to_string(errno)); exit(-1); } /* make a RSA key */ printf("KR: Making RSA key...\n"); if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), RSA_KEY, 128, "rsakey", "rsa@rsa.rsa", "rsakey one")) != CRYPT_OK) { printf("Make key error: %s\n", error_to_string(errno)); exit(-1); } } void kr_test(void) { pk_key *kr, *_kr; unsigned char buf[8192], buf2[8192], buf3[8192]; unsigned long len; int i, j, stat; #ifndef NO_FILE FILE *f; #endif kr_test_makekeys(&kr); printf("The original list:\n"); kr_display(kr); for (i = 0; i < 3; i++) { len = sizeof(buf); if ((errno = kr_export(kr, kr->ID, kr->key_type, buf, &len)) != CRYPT_OK) { printf("Error exporting key %d, %s\n", i, error_to_string(errno)); exit(-1); } printf("Exported key was: %lu bytes\n", len); if ((errno = kr_del(&kr, kr->ID)) != CRYPT_OK) { printf("Error deleting key %d, %s\n", i, error_to_string(errno)); exit(-1); } kr_display(kr); if ((errno = kr_import(kr, buf)) != CRYPT_OK) { printf("Error importing key %d, %s\n", i, error_to_string(errno)); exit(-1); } kr_display(kr); } for (i = 0; i < 3; i++) { len = sizeof(buf); if ((errno = kr_export(kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) { printf("Error exporting key %d, %s\n", i, error_to_string(errno)); exit(-1); } printf("Exported key was: %lu bytes\n", len); if ((errno = kr_del(&kr, kr->ID)) != CRYPT_OK) { printf("Error deleting key %d, %s\n", i, error_to_string(errno)); exit(-1); } kr_display(kr); if ((errno = kr_import(kr, buf)) != CRYPT_OK) { printf("Error importing key %d, %s\n", i, error_to_string(errno)); exit(-1); } kr_display(kr); } if ((errno = kr_clear(&kr)) != CRYPT_OK) { printf("Error clearing ring: %s\n", error_to_string(errno)); exit(-1); } /* TEST output to file */ #ifndef NO_FILE if ((errno = kr_init(&kr)) != CRYPT_OK) { printf("KR init error %s\n", error_to_string(errno)); exit(-1); } kr_test_makekeys(&kr); /* save to file */ f = fopen("ring.dat", "wb"); if ((errno = kr_save(kr, f, NULL)) != CRYPT_OK) { printf("kr_save error %s\n", error_to_string(errno)); exit(-1); } fclose(f); /* delete and load */ if ((errno = kr_clear(&kr)) != CRYPT_OK) { printf("clear error: %s\n", error_to_string(errno)); exit(-1); } f = fopen("ring.dat", "rb"); if ((errno = kr_load(&kr, f, NULL)) != CRYPT_OK) { printf("kr_load error %s\n", error_to_string(errno)); exit(-1); } fclose(f); remove("ring.dat"); printf("After load and save...\n"); kr_display(kr); if ((errno = kr_clear(&kr)) != CRYPT_OK) { printf("clear error: %s\n", error_to_string(errno)); exit(-1); } #endif /* test the packet encryption/sign stuff */ for (i = 0; i < 32; i++) buf[i] = i; kr_test_makekeys(&kr); _kr = kr; for (i = 0; i < 3; i++) { printf("Testing a key with system %d, type %d:\t", _kr->system, _kr->key_type); len = sizeof(buf2); if ((errno = kr_encrypt_key(kr, _kr->ID, buf, 16, buf2, &len, &prng, find_prng("yarrow"), find_hash("md5"))) != CRYPT_OK) { printf("Encrypt error, %d, %s\n", i, error_to_string(errno)); exit(-1); } len = sizeof(buf3); if ((errno = kr_decrypt_key(kr, buf2, buf3, &len)) != CRYPT_OK) { printf("decrypt error, %d, %s\n", i, error_to_string(errno)); exit(-1); } if (len != 16 || memcmp(buf3, buf, 16)) { printf("kr_decrypt_key failed, %i, %lu\n", i, len); exit(-1); } printf("kr_encrypt_key passed, "); len = sizeof(buf2); if ((errno = kr_sign_hash(kr, _kr->ID, buf, 32, buf2, &len, &prng, find_prng("yarrow"))) != CRYPT_OK) { printf("kr_sign_hash failed, %i, %lu\n", i, len); exit(-1); } printf("kr_sign_hash: "); if ((errno = kr_verify_hash(kr, buf2, buf, 32, &stat)) != CRYPT_OK) { printf("kr_sign_hash failed, %i, %lu\n", i, len); exit(-1); } printf("%s, ", stat?"passed":"failed"); buf[15] ^= 1; if ((errno = kr_verify_hash(kr, buf2, buf, 32, &stat)) != CRYPT_OK) { printf("kr_sign_hash failed, %i, %lu\n", i, len); exit(-1); } printf("%s\n", (!stat)?"passed":"failed"); buf[15] ^= 1; len = sizeof(buf); if ((errno = kr_fingerprint(kr, _kr->ID, find_hash("sha1"), buf, &len)) != CRYPT_OK) { printf("kr_fingerprint failed, %i, %lu\n", i, len); exit(-1); } printf("Fingerprint: "); for (j = 0; j < 20; j++) { printf("%02x", buf[j]); if (j < 19) printf(":"); } printf("\n\n"); _kr = _kr->next; } /* Test encrypting/decrypting to a public key */ /* first dump the other two keys */ kr_del(&kr, kr->ID); kr_del(&kr, kr->ID); kr_display(kr); /* now export it as public and private */ len = sizeof(buf); if ((errno = kr_export(kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) { printf("Error exporting key %d, %s\n", i, error_to_string(errno)); exit(-1); } /* check boundaries */ memset(buf+len, 0, sizeof(buf)-len); len = sizeof(buf2); if ((errno = kr_export(kr, kr->ID, PK_PRIVATE, buf2, &len)) != CRYPT_OK) { printf("Error exporting key %s\n", error_to_string(errno)); exit(-1); } /* check boundaries */ memset(buf2+len, 0, sizeof(buf2)-len); /* delete the key and import the public */ kr_clear(&kr); kr_init(&kr); kr_display(kr); if ((errno = kr_import(kr, buf)) != CRYPT_OK) { printf("Error importing key %s\n", error_to_string(errno)); exit(-1); } kr_display(kr); /* now encrypt a buffer */ for (i = 0; i < 16; i++) buf[i] = i; len = sizeof(buf3); if ((errno = kr_encrypt_key(kr, kr->ID, buf, 16, buf3, &len, &prng, find_prng("yarrow"), find_hash("md5"))) != CRYPT_OK) { printf("Encrypt error, %d, %s\n", i, error_to_string(errno)); exit(-1); } /* now delete the key and import the private one */ kr_clear(&kr); kr_init(&kr); kr_display(kr); if ((errno = kr_import(kr, buf2)) != CRYPT_OK) { printf("Error importing key %s\n", error_to_string(errno)); exit(-1); } kr_display(kr); /* now decrypt */ len = sizeof(buf2); if ((errno = kr_decrypt_key(kr, buf3, buf2, &len)) != CRYPT_OK) { printf("decrypt error, %s\n", error_to_string(errno)); exit(-1); } printf("KR encrypt to public, decrypt with private: "); if (len == 16 && !memcmp(buf2, buf, 16)) { printf("passed\n"); } else { printf("failed\n"); } kr_clear(&kr); } void test_errs(void) { #define ERR(x) printf("%25s => %s\n", #x, error_to_string(x)); ERR(CRYPT_OK); ERR(CRYPT_ERROR); ERR(CRYPT_INVALID_KEYSIZE); ERR(CRYPT_INVALID_ROUNDS); ERR(CRYPT_FAIL_TESTVECTOR); ERR(CRYPT_BUFFER_OVERFLOW); ERR(CRYPT_INVALID_PACKET); ERR(CRYPT_INVALID_PRNGSIZE); ERR(CRYPT_ERROR_READPRNG); ERR(CRYPT_INVALID_CIPHER); ERR(CRYPT_INVALID_HASH); ERR(CRYPT_INVALID_PRNG); ERR(CRYPT_MEM); ERR(CRYPT_PK_TYPE_MISMATCH); ERR(CRYPT_PK_NOT_PRIVATE); ERR(CRYPT_INVALID_ARG); ERR(CRYPT_PK_INVALID_TYPE); ERR(CRYPT_PK_INVALID_SYSTEM); ERR(CRYPT_PK_DUP); ERR(CRYPT_PK_NOT_FOUND); ERR(CRYPT_PK_INVALID_SIZE); ERR(CRYPT_INVALID_PRIME_SIZE); } int main(void) { #ifdef SONY_PS2 TIMER_Init(); #endif register_all_algs(); if ((errno = yarrow_start(&prng)) != CRYPT_OK) { printf("yarrow_start: %s\n", error_to_string(errno)); } if ((errno = yarrow_add_entropy("hello", 5, &prng)) != CRYPT_OK) { printf("yarrow_add_entropy: %s\n", error_to_string(errno)); } if ((errno = yarrow_ready(&prng)) != CRYPT_OK) { printf("yarrow_ready: %s\n", error_to_string(errno)); } printf(crypt_build_settings); test_errs(); #ifdef HMAC printf("HMAC: %s\n", hmac_test() == CRYPT_OK ? "passed" : "failed"); #endif store_tests(); cipher_tests(); hash_tests(); ecb_tests(); cbc_tests(); ctr_tests(); ofb_tests(); cfb_tests(); rng_tests(); //test_prime(); kr_test(); rsa_test(); pad_test(); ecc_tests(); dh_tests(); gf_tests(); base64_test(); time_ecb(); time_hash(); #ifdef SONY_PS2 TIMER_Shutdown(); #endif return 0; }