| /* 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 <eetypes.h> |
| #include <eeregs.h> |
| #include "timer.h" |
| #endif |
| |
| #include <mycrypt.h> |
| |
| int errnum; |
| |
| |
| 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"); |
| exit (-1); |
| } |
| 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"); |
| exit (-1); |
| } |
| |
| L = 0x12345678UL; |
| STORE32H (L, &buf[0]); |
| L = 0; |
| LOAD32H (L, &buf[0]); |
| if (L != 0x12345678UL) { |
| printf ("LOAD/STORE32 High don't work, %08lx\n", L); |
| exit (-1); |
| } |
| 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"); |
| exit (-1); |
| } |
| } |
| |
| 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: %4d to %4d, Block Size: %3d, Default # of rounds: %2d\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 ((errnum = cipher_descriptor[x].test ()) != CRYPT_OK) { |
| printf (" **failed** Reason: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } 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 ((errnum = |
| cbc_start (find_cipher ("blowfish"), IV, key, 16, 0, |
| &cbc)) != CRYPT_OK) { |
| printf ("CBC Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets encode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = cbc_encrypt (blk + 8 * x, ct + 8 * x, &cbc)) != CRYPT_OK) { |
| printf ("CBC encrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| 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 ((errnum = |
| cbc_start (find_cipher ("blowfish"), IV, key, 16, 0, |
| &cbc)) != CRYPT_OK) { |
| printf ("CBC Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets decode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = cbc_decrypt (ct + 8 * x, blk + 8 * x, &cbc)) != CRYPT_OK) { |
| printf ("CBC decrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| |
| /* 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"); |
| exit (-1); |
| } 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 ((errnum = |
| ofb_start (find_cipher ("cast5"), IV, key, 16, 0, &ofb)) != CRYPT_OK) { |
| printf ("OFB Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets encode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = ofb_encrypt (blk + 8 * x, ct + 8 * x, 8, &ofb)) != CRYPT_OK) { |
| printf ("OFB encrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| 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 ((errnum = |
| ofb_start (find_cipher ("cast5"), IV, key, 16, 0, &ofb)) != CRYPT_OK) { |
| printf ("OFB setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets decode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = ofb_decrypt (ct + 8 * x, blk + 8 * x, 8, &ofb)) != CRYPT_OK) { |
| printf ("OFB decrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| /* print output */ |
| for (x = y = 0; x < 32; x++) |
| if (blk[x] != x) |
| y = 1; |
| printf (" %s\n", y ? "failed" : "passed"); |
| if (y) |
| exit (-1); |
| } |
| #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 ((errnum = |
| cfb_start (find_cipher ("blowfish"), IV, key, 16, 0, |
| &cfb)) != CRYPT_OK) { |
| printf ("CFB setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets encode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = cfb_encrypt (blk + 8 * x, ct + 8 * x, 8, &cfb)) != CRYPT_OK) { |
| printf ("CFB encrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| 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 ((errnum = |
| cfb_start (find_cipher ("blowfish"), IV, key, 16, 0, |
| &cfb)) != CRYPT_OK) { |
| printf ("CFB Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets decode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = cfb_decrypt (ct + 8 * x, blk + 8 * x, 8, &cfb)) != CRYPT_OK) { |
| printf ("CFB decrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| /* print output */ |
| for (x = y = 0; x < 32; x++) |
| if (blk[x] != x) |
| y = 1; |
| printf (" %s\n", y ? "failed" : "passed"); |
| if (y) |
| exit (-1); |
| } |
| #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 ((errnum = |
| ctr_start (find_cipher ("xtea"), count, key, 16, 0, |
| &ctr)) != CRYPT_OK) { |
| printf ("CTR Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets encode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = ctr_encrypt (blk + 8 * x, ct + 8 * x, 8, &ctr)) != CRYPT_OK) { |
| printf ("CTR encrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| 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 ((errnum = |
| ctr_start (find_cipher ("xtea"), count, key, 16, 0, |
| &ctr)) != CRYPT_OK) { |
| printf ("CTR Setup: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* now lets decode 32 bytes */ |
| for (x = 0; x < 4; x++) { |
| if ((errnum = ctr_decrypt (ct + 8 * x, blk + 8 * x, 8, &ctr)) != CRYPT_OK) { |
| printf ("CTR decrypt: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| |
| /* print output */ |
| for (x = y = 0; x < 32; x++) |
| if (blk[x] != x) |
| y = 1; |
| printf (" %s\n", y ? "failed" : "passed"); |
| if (y) |
| exit (-1); |
| |
| /* 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 ((errnum = hash_descriptor[x].test ()) != CRYPT_OK) { |
| printf ("**failed** Reason: %s\n", error_to_string (errnum)); |
| exit(-1); |
| } 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 ((errnum = |
| rsa_pad (in, 16, out, &y, find_prng ("yarrow"), &prng)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* depad the message to get the original content */ |
| memset (in, 0, sizeof (in)); |
| x = 100; |
| if ((errnum = rsa_depad (out, y, in, &x)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* check outcome */ |
| printf ("rsa_pad: "); |
| if (x != 16) { |
| printf ("Failed. Wrong size.\n"); |
| exit (-1); |
| } |
| for (x = 0; x < 16; x++) |
| if (in[x] != x) { |
| printf ("Failed. Expected %02lx and got %02x.\n", x, in[x]); |
| exit (-1); |
| } |
| printf ("passed.\n"); |
| } |
| void |
| rsa_test (void) |
| { |
| unsigned char in[520], out[520]; |
| unsigned long x, y, z, limit; |
| int stat; |
| rsa_key key; |
| clock_t t; |
| |
| /* ---- SINGLE ENCRYPT ---- */ |
| /* encrypt a short 8 byte string */ |
| if ((errnum = |
| rsa_make_key (&prng, find_prng ("yarrow"), 1024 / 8, 65537, |
| &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| for (x = 0; x < 8; x++) |
| in[x] = (unsigned char) (x + 1); |
| y = sizeof (in); |
| if ((errnum = rsa_exptmod (in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* decrypt it */ |
| zeromem (in, sizeof (in)); |
| x = sizeof (out); |
| if ((errnum = rsa_exptmod (out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* 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]); |
| exit (-1); |
| } |
| printf ("passed.\n"); |
| |
| /* test the rsa_encrypt_key functions */ |
| for (x = 0; x < 16; x++) |
| in[x] = x; |
| y = sizeof (out); |
| if ((errnum = |
| rsa_encrypt_key (in, 16, out, &y, &prng, find_prng ("yarrow"), |
| &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| zeromem (in, sizeof (in)); |
| x = sizeof (in); |
| if ((errnum = rsa_decrypt_key (out, y, in, &x, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("RSA en/de crypt key routines: "); |
| if (x != 16) { |
| printf ("Failed (length)\n"); |
| exit (-1); |
| } |
| for (x = 0; x < 16; x++) |
| if (in[x] != x) { |
| printf ("Failed (contents)\n"); |
| exit (-1); |
| } |
| printf ("Passed\n"); |
| |
| /* test sign_hash functions */ |
| for (x = 0; x < 16; x++) |
| in[x] = x; |
| x = sizeof (in); |
| if ((errnum = rsa_sign_hash (in, 16, out, &x, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("RSA signed hash: %lu bytes\n", x); |
| if ((errnum = rsa_verify_hash (out, x, in, &stat, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("Verify hash: %s, ", stat ? "passed" : "failed"); |
| in[0] ^= 1; |
| if ((errnum = rsa_verify_hash (out, x, in, &stat, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("%s\n", (!stat) ? "passed" : "failed"); |
| if (stat) |
| exit (-1); |
| rsa_free (&key); |
| |
| /* make a RSA key */ |
| #ifdef SONY_PS2_NOPE |
| limit = 1024; |
| #else |
| limit = 2048; |
| #endif |
| |
| { |
| int tt; |
| |
| for (z = 1024; z <= limit; z += 512) { |
| t = XCLOCK (); |
| for (tt = 0; tt < 3; tt++) { |
| if ((errnum = rsa_make_key (&prng, find_prng ("yarrow"), z / 8, 65537, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* check modulus size */ |
| if (mp_unsigned_bin_size(&key.N) != (int)(z/8)) { |
| printf("\nRSA key supposed to be %lu bits but was %d bits\n", z, mp_count_bits(&key.N)); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (tt < 2) { |
| rsa_free (&key); |
| } |
| } |
| t = XCLOCK () - t; |
| printf ("Took %.0f ms to make a %ld-bit RSA key.\n", 1000.0 * (((double) t / 3.0) / (double) XCLOCKS_PER_SEC), z); |
| |
| /* time encryption */ |
| t = XCLOCK (); |
| |
| for (tt = 0; tt < 20; tt++) { |
| y = sizeof (in); |
| if ((errnum = rsa_exptmod (in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| t = XCLOCK () - t; |
| printf ("Took %.0f ms to encrypt with a %ld-bit RSA key.\n", |
| 1000.0 * (((double) t / 20.0) / (double) XCLOCKS_PER_SEC), z); |
| |
| /* time decryption */ |
| t = XCLOCK (); |
| for (tt = 0; tt < 20; tt++) { |
| x = sizeof (out); |
| if ((errnum = rsa_exptmod (out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| } |
| t = XCLOCK () - t; |
| printf ("Took %.0f ms to decrypt with a %ld-bit RSA key.\n", |
| 1000.0 * (((double) t / 20.0) / (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 (errnum)); |
| exit (-1); |
| } |
| 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 (errnum)); |
| exit (-1); |
| } |
| printf (" decoded %ld bytes to %ld bytes\n", x, y); |
| for (x = 0; x < 16; x++) |
| if (buf[0][x] != x) { |
| printf (" **failed**\n"); |
| exit (-1); |
| } |
| 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 < (5 * 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); |
| 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 += 32; |
| } |
| 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 < 3 * XCLOCKS_PER_SEC) { |
| DO256; |
| y1 += 256; |
| } |
| t1 = XCLOCK () - t1; |
| |
| func = cipher_descriptor[x].ecb_decrypt; |
| y2 = 0; |
| t2 = XCLOCK (); |
| while (XCLOCK () - t2 < 3 * 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; |
| |
| printf("Testing builting DH parameters...."); fflush(stdout); |
| if ((errnum = dh_test()) != CRYPT_OK) { |
| printf("DH Error: %s\n", error_to_string(errnum)); |
| exit(-1); |
| } |
| printf("Passed.\n"); |
| |
| dh_sizes (&low, &high); |
| printf ("DH Keys from %d to %d supported.\n", low * 8, high * 8); |
| |
| /* make up two keys */ |
| if ((errnum = |
| dh_make_key (&prng, find_prng ("yarrow"), 96, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| if ((errnum = |
| dh_make_key (&prng, find_prng ("yarrow"), 96, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* make the shared secret */ |
| x = 4096; |
| if ((errnum = dh_shared_secret (&usera, &userb, buf[0], &x)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| y = 4096; |
| if ((errnum = dh_shared_secret (&userb, &usera, buf[1], &y)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| if (y != x) { |
| printf ("DH Shared keys are not same size.\n"); |
| exit (-1); |
| } |
| if (memcmp (buf[0], buf[1], x)) { |
| printf ("DH Shared keys not same contents.\n"); |
| exit (-1); |
| } |
| |
| /* now export userb */ |
| y = 4096; |
| if ((errnum = dh_export (buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| dh_free (&userb); |
| |
| /* import and make the shared secret again */ |
| if ((errnum = dh_import (buf[1], y, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| z = 4096; |
| if ((errnum = dh_shared_secret (&usera, &userb, buf[2], &z)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| printf ("DH routines: "); |
| if (z != x) { |
| printf ("failed. Size don't match?\n"); |
| exit (-1); |
| } |
| if (memcmp (buf[0], buf[2], x)) { |
| printf ("Failed. Content didn't match.\n"); |
| exit (-1); |
| } |
| printf ("Passed\n"); |
| dh_free (&usera); |
| dh_free (&userb); |
| |
| /* time stuff */ |
| { |
| static int sizes[] = { 96, 128, 160, 192, 224, 256, 320, 384, 512 }; |
| int ii, tt; |
| |
| for (ii = 0; ii < (int) (sizeof (sizes) / sizeof (sizes[0])); ii++) { |
| t1 = XCLOCK (); |
| for (tt = 0; tt < 25; tt++) { |
| dh_make_key (&prng, find_prng ("yarrow"), sizes[ii], &usera); |
| dh_free (&usera); |
| } |
| t1 = XCLOCK () - t1; |
| printf ("Make dh-%d key took %f msec\n", sizes[ii] * 8, |
| 1000.0 * (((double) t1 / 25.0) / (double) XCLOCKS_PER_SEC)); |
| } |
| } |
| |
| /* test encrypt_key */ |
| dh_make_key (&prng, find_prng ("yarrow"), 128, &usera); |
| for (x = 0; x < 16; x++) |
| buf[0][x] = x; |
| y = sizeof (buf[1]); |
| if ((errnum = |
| 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 (errnum)); |
| exit (-1); |
| } |
| zeromem (buf[0], sizeof (buf[0])); |
| x = sizeof (buf[0]); |
| if ((errnum = dh_decrypt_key (buf[1], y, buf[0], &x, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("DH en/de crypt key routines: "); |
| if (x != 16) { |
| printf ("Failed (length)\n"); |
| exit (-1); |
| } |
| for (x = 0; x < 16; x++) |
| if (buf[0][x] != x) { |
| printf ("Failed (contents)\n"); |
| exit (-1); |
| } |
| printf ("Passed (size %lu)\n", y); |
| |
| /* test sign_hash */ |
| for (x = 0; x < 16; x++) |
| buf[0][x] = x; |
| x = sizeof (buf[1]); |
| if ((errnum = |
| dh_sign_hash (buf[0], 16, buf[1], &x, &prng, find_prng ("yarrow"), |
| &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| if ((errnum = dh_verify_hash (buf[1], x, buf[0], 16, &stat, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| buf[0][0] ^= 1; |
| if ((errnum = dh_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("dh_sign/verify_hash: %s (%d,%d), %lu\n", |
| ((stat == 1) |
| && (stat2 == 0)) ? "passed" : "failed", stat, stat2, x); |
| 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 ((errnum = |
| rng_make_prng (128, find_prng ("yarrow"), &prng, |
| &callback)) != CRYPT_OK) { |
| printf (" starting yarrow error: %s\n", error_to_string (errnum)); |
| 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 ((errnum = ecc_test ()) != CRYPT_OK) { |
| printf ("ecc Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| ecc_sizes (&low, &high); |
| printf ("ecc Keys from %d to %d supported.\n", low * 8, high * 8); |
| |
| /* make up two keys */ |
| if ((errnum = |
| ecc_make_key (&prng, find_prng ("yarrow"), 24, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| if ((errnum = |
| ecc_make_key (&prng, find_prng ("yarrow"), 24, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| /* make the shared secret */ |
| x = 4096; |
| if ((errnum = ecc_shared_secret (&usera, &userb, buf[0], &x)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| y = 4096; |
| if ((errnum = ecc_shared_secret (&userb, &usera, buf[1], &y)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| if (y != x) { |
| printf ("ecc Shared keys are not same size.\n"); |
| exit (-1); |
| } |
| |
| if (memcmp (buf[0], buf[1], x)) { |
| printf ("ecc Shared keys not same contents.\n"); |
| exit (-1); |
| } |
| |
| /* now export userb */ |
| y = 4096; |
| if ((errnum = ecc_export (buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| ecc_free (&userb); |
| printf ("ECC-192 export took %ld bytes\n", y); |
| |
| /* import and make the shared secret again */ |
| if ((errnum = ecc_import (buf[1], y, &userb)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| z = 4096; |
| if ((errnum = ecc_shared_secret (&usera, &userb, buf[2], &z)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| |
| printf ("ecc routines: "); |
| if (z != x) { |
| printf ("failed. Size don't match?\n"); |
| exit (-1); |
| } |
| if (memcmp (buf[0], buf[2], x)) { |
| printf ("Failed. Content didn't match.\n"); |
| exit (-1); |
| } |
| printf ("Passed\n"); |
| ecc_free (&usera); |
| ecc_free (&userb); |
| |
| /* time stuff */ |
| { |
| static int sizes[] = { 20, 24, 28, 32, 48, 65 }; |
| int ii, tt; |
| |
| for (ii = 0; ii < (int) (sizeof (sizes) / sizeof (sizes[0])); ii++) { |
| t1 = XCLOCK (); |
| for (tt = 0; tt < 10; tt++) { |
| if ((errnum = |
| ecc_make_key (&prng, find_prng ("yarrow"), sizes[ii], |
| &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| ecc_free (&usera); |
| } |
| t1 = XCLOCK () - t1; |
| printf ("Make ECC-%d key took %f msec\n", sizes[ii] * 8, |
| 1000.0 * (((double) t1 / 10.0) / (double) XCLOCKS_PER_SEC)); |
| } |
| } |
| |
| /* test encrypt_key */ |
| ecc_make_key (&prng, find_prng ("yarrow"), 20, &usera); |
| for (x = 0; x < 32; x++) |
| buf[0][x] = x; |
| y = sizeof (buf[1]); |
| if ((errnum = |
| ecc_encrypt_key (buf[0], 32, buf[1], &y, &prng, find_prng ("yarrow"), |
| find_hash ("sha256"), &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| zeromem (buf[0], sizeof (buf[0])); |
| x = sizeof (buf[0]); |
| if ((errnum = ecc_decrypt_key (buf[1], y, buf[0], &x, &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf ("ECC en/de crypt key routines: "); |
| if (x != 32) { |
| printf ("Failed (length)\n"); |
| exit (-1); |
| } |
| for (x = 0; x < 32; x++) |
| if (buf[0][x] != x) { |
| printf ("Failed (contents)\n"); |
| exit (-1); |
| } |
| printf ("Passed (size: %lu)\n", y); |
| /* test sign_hash */ |
| for (x = 0; x < 16; x++) |
| buf[0][x] = x; |
| x = sizeof (buf[1]); |
| if ((errnum = |
| ecc_sign_hash (buf[0], 16, buf[1], &x, &prng, find_prng ("yarrow"), |
| &usera)) != CRYPT_OK) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| printf("Signature size: %lu\n", x); |
| if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat, &usera)) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| buf[0][0] ^= 1; |
| if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera)) { |
| printf ("Error: %s\n", error_to_string (errnum)); |
| exit (-1); |
| } |
| 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 MPI |
| void |
| test_prime (void) |
| { |
| char buf[1024]; |
| mp_int a; |
| int x; |
| |
| /* make a 1024 bit prime */ |
| mp_init (&a); |
| rand_prime (&a, 128*8, &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 RIJNDAEL |
| register_cipher (&aes_desc); |
| #endif |
| #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 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 |
| #ifdef NOEKEON |
| register_cipher (&noekeon_desc); |
| #endif |
| #ifdef SKIPJACK |
| register_cipher (&skipjack_desc); |
| #endif |
| register_cipher (&null_desc); |
| |
| #ifdef TIGER |
| register_hash (&tiger_desc); |
| #endif |
| #ifdef MD2 |
| register_hash (&md2_desc); |
| #endif |
| #ifdef MD4 |
| register_hash (&md4_desc); |
| #endif |
| #ifdef MD5 |
| register_hash (&md5_desc); |
| #endif |
| #ifdef SHA1 |
| register_hash (&sha1_desc); |
| #endif |
| #ifdef SHA256 |
| register_hash (&sha256_desc); |
| #endif |
| #ifdef SHA224 |
| register_hash (&sha224_desc); |
| #endif |
| #ifdef SHA384 |
| register_hash (&sha384_desc); |
| #endif |
| #ifdef SHA512 |
| register_hash (&sha512_desc); |
| #endif |
| #ifdef RIPEMD128 |
| register_hash (&rmd128_desc); |
| #endif |
| #ifdef RIPEMD160 |
| register_hash (&rmd160_desc); |
| #endif |
| #ifdef WHIRLPOOL |
| register_hash (&whirlpool_desc); |
| #endif |
| |
| #ifdef YARROW |
| register_prng (&yarrow_desc); |
| #endif |
| #ifdef SPRNG |
| register_prng (&sprng_desc); |
| #endif |
| } |
| |
| 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_FILE_NOTFOUND); |
| |
| 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); |
| } |
| |
| |
| void dsa_tests(void) |
| { |
| unsigned char msg[16], out[1024], out2[1024]; |
| unsigned long x, y; |
| int err, stat1, stat2; |
| dsa_key key, key2; |
| |
| /* make a random key */ |
| if ((err = dsa_make_key(&prng, find_prng("yarrow"), 20, 128, &key)) != CRYPT_OK) { |
| printf("Error making DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("DSA Key Made\n"); |
| |
| /* verify it */ |
| if ((err = dsa_verify_key(&key, &stat1)) != CRYPT_OK) { |
| printf("Error verifying DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("DSA key verification: %s\n", stat1 == 1 ? "passed" : "failed"); |
| if (stat1 == 0) exit(-1); |
| |
| /* sign the message */ |
| x = sizeof(out); |
| if ((err = dsa_sign_hash(msg, sizeof(msg), out, &x, &prng, find_prng("yarrow"), &key)) != CRYPT_OK) { |
| printf("Error signing with DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("DSA 160/1024 signature is %lu bytes long\n", x); |
| |
| /* verify it once */ |
| if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key)) != CRYPT_OK) { |
| printf("Error verifying with DSA key 1: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| /* Modify and verify again */ |
| msg[0] ^= 1; |
| if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat2, &key)) != CRYPT_OK) { |
| printf("Error verifying with DSA key 2: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| msg[0] ^= 1; |
| printf("DSA Verification: %d, %d, %s\n", stat1, stat2, (stat1 == 1 && stat2 == 0) ? "passed" : "failed"); |
| if (!(stat1 == 1 && stat2 == 0)) exit(-1); |
| |
| /* test exporting it */ |
| x = sizeof(out2); |
| if ((err = dsa_export(out2, &x, PK_PRIVATE, &key)) != CRYPT_OK) { |
| printf("Error export PK_PRIVATE DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("Exported PK_PRIVATE DSA key in %lu bytes\n", x); |
| if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) { |
| printf("Error importing PK_PRIVATE DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| /* verify a signature with it */ |
| if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) { |
| printf("Error verifying with DSA key 3: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("PRIVATE Import Test: %s\n", stat1 == 1 ? "passed" : "failed"); |
| if (stat1 == 0) exit(-1); |
| dsa_free(&key2); |
| |
| /* export as public now */ |
| x = sizeof(out2); |
| if ((err = dsa_export(out2, &x, PK_PUBLIC, &key)) != CRYPT_OK) { |
| printf("Error export PK_PUBLIC DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("Exported PK_PUBLIC DSA key in %lu bytes\n", x); |
| if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) { |
| printf("Error importing PK_PUBLIC DSA key: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| /* verify a signature with it */ |
| if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) { |
| printf("Error verifying with DSA key 4: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| printf("PUBLIC Import Test: %s\n", stat1 == 1 ? "passed" : "failed"); |
| if (stat1 == 0) exit(-1); |
| |
| dsa_free(&key2); |
| dsa_free(&key); |
| } |
| |
| #ifdef PKCS_1 |
| void pkcs1_test(void) |
| { |
| unsigned char buf[3][128]; |
| int err, res1, res2, res3, prng_idx, hash_idx; |
| unsigned long x, y, l1, l2, l3, i1, i2; |
| |
| /* get hash/prng */ |
| hash_idx = find_hash("sha1"); |
| prng_idx = find_prng("yarrow"); |
| |
| /* do many tests */ |
| for (x = 0; x < 10000; x++) { |
| zeromem(buf, sizeof(buf)); |
| |
| /* make a dummy message (of random length) */ |
| l3 = (rand() & 31) + 8; |
| for (y = 0; y < l3; y++) buf[0][y] = rand() & 255; |
| |
| /* encode it */ |
| l1 = sizeof(buf[1]); |
| if ((err = pkcs_1_oaep_encode(buf[0], l3, NULL, 0, 1024, hash_idx, prng_idx, &prng, buf[1], &l1)) != CRYPT_OK) { |
| printf("OAEP encode: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| /* decode it */ |
| l2 = sizeof(buf[2]); |
| if ((err = pkcs_1_oaep_decode(buf[1], l1, NULL, 0, 1024, hash_idx, buf[2], &l2, &res1)) != CRYPT_OK) { |
| printf("OAEP decode: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| if (res1 != 1 || l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) { |
| printf("res == %d, Outsize == %lu, should have been %lu, msg contents follow.\n", res1, l2, l3); |
| printf("ORIGINAL:\n"); |
| for (x = 0; x < l3; x++) { |
| printf("%02x ", buf[0][x]); |
| } |
| printf("\nRESULT:\n"); |
| for (x = 0; x < l2; x++) { |
| printf("%02x ", buf[2][x]); |
| } |
| printf("\n\n"); |
| exit(-1); |
| } |
| |
| /* test PSS */ |
| l1 = sizeof(buf[1]); |
| if ((err = pkcs_1_pss_encode(buf[0], l3, l3>>2, hash_idx, prng_idx, &prng, 1024, buf[1], &l1)) != CRYPT_OK) { |
| printf("PSS encode: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res1)) != CRYPT_OK) { |
| printf("PSS decode1: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| buf[0][i1 = abs(rand()) % l3] ^= 1; |
| if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res2)) != CRYPT_OK) { |
| printf("PSS decode2: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| buf[0][i1] ^= 1; |
| buf[1][i2 = abs(rand()) % l1] ^= 1; |
| if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res3)) != CRYPT_OK) { |
| printf("PSS decode3: %s\n", error_to_string(err)); |
| exit(-1); |
| } |
| |
| if (!(res1 == 1 && res2 == 0 && res3 == 0)) { |
| printf("PSS failed: %d, %d, %d, %lu\n", res1, res2, res3, l3); |
| exit(-1); |
| } |
| } |
| printf("PKCS #1: Passed\n"); |
| } |
| |
| #endif /* PKCS_1 */ |
| |
| int |
| main (void) |
| { |
| #ifdef SONY_PS2 |
| TIMER_Init (); |
| #endif |
| srand(time(NULL)); |
| |
| register_all_algs (); |
| |
| if ((errnum = yarrow_start (&prng)) != CRYPT_OK) { |
| printf ("yarrow_start: %s\n", error_to_string (errnum)); |
| } |
| if ((errnum = yarrow_add_entropy ((unsigned char *)"hello", 5, &prng)) != CRYPT_OK) { |
| printf ("yarrow_add_entropy: %s\n", error_to_string (errnum)); |
| } |
| if ((errnum = yarrow_ready (&prng)) != CRYPT_OK) { |
| printf ("yarrow_ready: %s\n", error_to_string (errnum)); |
| } |
| |
| printf (crypt_build_settings); |
| test_errs (); |
| |
| #ifdef HMAC |
| printf ("HMAC: %s\n", hmac_test () == CRYPT_OK ? "passed" : "failed"); |
| if (hmac_test() != CRYPT_OK) exit(EXIT_FAILURE); |
| #endif |
| |
| #ifdef OMAC |
| printf ("OMAC: %s\n", omac_test () == CRYPT_OK ? "passed" : "failed"); |
| if (omac_test() != CRYPT_OK) exit(EXIT_FAILURE); |
| #endif |
| |
| #ifdef PMAC |
| printf ("PMAC: %s\n", pmac_test () == CRYPT_OK ? "passed" : "failed"); |
| if (pmac_test() != CRYPT_OK) exit(EXIT_FAILURE); |
| #endif |
| |
| #ifdef EAX_MODE |
| printf ("EAX : %s\n", eax_test () == CRYPT_OK ? "passed" : "failed"); |
| if (eax_test() != CRYPT_OK) exit(EXIT_FAILURE); |
| #endif |
| |
| #ifdef OCB_MODE |
| printf ("OCB : %s\n", ocb_test () == CRYPT_OK ? "passed" : "failed"); |
| if (ocb_test() != CRYPT_OK) exit(EXIT_FAILURE); |
| #endif |
| |
| store_tests (); |
| cipher_tests (); |
| hash_tests (); |
| |
| #ifdef PKCS_1 |
| pkcs1_test(); |
| #endif |
| |
| ecb_tests (); |
| cbc_tests (); |
| ctr_tests (); |
| ofb_tests (); |
| cfb_tests (); |
| |
| rng_tests (); |
| test_prime(); |
| |
| dsa_tests(); |
| rsa_test (); |
| pad_test (); |
| ecc_tests (); |
| dh_tests (); |
| |
| base64_test (); |
| |
| time_ecb (); |
| time_hash (); |
| |
| #ifdef SONY_PS2 |
| TIMER_Shutdown (); |
| #endif |
| |
| return 0; |
| } |