[or-cvs] [tor/master] Split crypto tests into a separate module.
Nick Mathewson
nickm at seul.org
Wed Sep 23 04:30:25 UTC 2009
Author: Nick Mathewson <nickm at torproject.org>
Date: Tue, 22 Sep 2009 13:06:47 -0400
Subject: Split crypto tests into a separate module.
Commit: cea12251995d49a63735beb4755eb2b779995835
---
src/test/Makefile.am | 2 +-
src/test/test.c | 762 +-----------------------------------------------
src/test/test.h | 8 +-
src/test/test_crypto.c | 768 ++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 783 insertions(+), 757 deletions(-)
create mode 100644 src/test/test_crypto.c
diff --git a/src/test/Makefile.am b/src/test/Makefile.am
index e09881c..4bfcd3b 100644
--- a/src/test/Makefile.am
+++ b/src/test/Makefile.am
@@ -12,7 +12,7 @@ AM_CFLAGS = -I../or
# This seems to matter nowhere but on windows, but I assure you that it
# matters a lot there, and is quite hard to debug if you forget to do it.
-test_SOURCES = test_data.c test.c tinytest.c
+test_SOURCES = test_data.c test.c test_crypto.c tinytest.c
test_LDFLAGS = @TOR_LDFLAGS_zlib@ @TOR_LDFLAGS_openssl@ \
@TOR_LDFLAGS_libevent@
diff --git a/src/test/test.c b/src/test/test.c
index 1af037e..5cf0339 100644
--- a/src/test/test.c
+++ b/src/test/test.c
@@ -31,7 +31,6 @@ const char tor_git_revision[] = "";
#define BUFFERS_PRIVATE
#define CONFIG_PRIVATE
#define CONTROL_PRIVATE
-#define CRYPTO_PRIVATE
#define DIRSERV_PRIVATE
#define DIRVOTE_PRIVATE
#define GEOIP_PRIVATE
@@ -94,7 +93,7 @@ setup_directory(void)
}
/** Return a filename relative to our testing temporary directory */
-static const char *
+const char *
get_fname(const char *name)
{
static char buf[1024];
@@ -134,7 +133,7 @@ static crypto_pk_env_t *pregen_keys[5] = {NULL, NULL, NULL, NULL, NULL};
* the key cache optimization, we might reuse keys: we only guarantee that
* keys made with distinct values for <b>idx</b> are different. The value of
* <b>idx</b> must be at least 0, and less than N_PREGEN_KEYS. */
-static crypto_pk_env_t *
+crypto_pk_env_t *
pk_generate(int idx)
{
#ifdef CACHE_GENERATED_KEYS
@@ -409,564 +408,6 @@ test_buffers(void)
buf_free(buf2);
}
-/** Run unit tests for Diffie-Hellman functionality. */
-static void
-test_crypto_dh(void)
-{
- crypto_dh_env_t *dh1 = crypto_dh_new();
- crypto_dh_env_t *dh2 = crypto_dh_new();
- char p1[DH_BYTES];
- char p2[DH_BYTES];
- char s1[DH_BYTES];
- char s2[DH_BYTES];
- ssize_t s1len, s2len;
-
- test_eq(crypto_dh_get_bytes(dh1), DH_BYTES);
- test_eq(crypto_dh_get_bytes(dh2), DH_BYTES);
-
- memset(p1, 0, DH_BYTES);
- memset(p2, 0, DH_BYTES);
- test_memeq(p1, p2, DH_BYTES);
- test_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
- test_memneq(p1, p2, DH_BYTES);
- test_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
- test_memneq(p1, p2, DH_BYTES);
-
- memset(s1, 0, DH_BYTES);
- memset(s2, 0xFF, DH_BYTES);
- s1len = crypto_dh_compute_secret(dh1, p2, DH_BYTES, s1, 50);
- s2len = crypto_dh_compute_secret(dh2, p1, DH_BYTES, s2, 50);
- test_assert(s1len > 0);
- test_eq(s1len, s2len);
- test_memeq(s1, s2, s1len);
-
- {
- /* XXXX Now fabricate some bad values and make sure they get caught,
- * Check 0, 1, N-1, >= N, etc.
- */
- }
-
- done:
- crypto_dh_free(dh1);
- crypto_dh_free(dh2);
-}
-
-/** Run unit tests for our random number generation function and its wrappers.
- */
-static void
-test_crypto_rng(void)
-{
- int i, j, allok;
- char data1[100], data2[100];
-
- /* Try out RNG. */
- test_assert(! crypto_seed_rng(0));
- crypto_rand(data1, 100);
- crypto_rand(data2, 100);
- test_memneq(data1,data2,100);
- allok = 1;
- for (i = 0; i < 100; ++i) {
- uint64_t big;
- char *host;
- j = crypto_rand_int(100);
- if (i < 0 || i >= 100)
- allok = 0;
- big = crypto_rand_uint64(U64_LITERAL(1)<<40);
- if (big >= (U64_LITERAL(1)<<40))
- allok = 0;
- big = crypto_rand_uint64(U64_LITERAL(5));
- if (big >= 5)
- allok = 0;
- host = crypto_random_hostname(3,8,"www.",".onion");
- if (strcmpstart(host,"www.") ||
- strcmpend(host,".onion") ||
- strlen(host) < 13 ||
- strlen(host) > 18)
- allok = 0;
- tor_free(host);
- }
- test_assert(allok);
- done:
- ;
-}
-
-/** Run unit tests for our AES functionality */
-static void
-test_crypto_aes(void)
-{
- char *data1 = NULL, *data2 = NULL, *data3 = NULL;
- crypto_cipher_env_t *env1 = NULL, *env2 = NULL;
- int i, j;
-
- data1 = tor_malloc(1024);
- data2 = tor_malloc(1024);
- data3 = tor_malloc(1024);
-
- /* Now, test encryption and decryption with stream cipher. */
- data1[0]='\0';
- for (i = 1023; i>0; i -= 35)
- strncat(data1, "Now is the time for all good onions", i);
-
- memset(data2, 0, 1024);
- memset(data3, 0, 1024);
- env1 = crypto_new_cipher_env();
- test_neq(env1, 0);
- env2 = crypto_new_cipher_env();
- test_neq(env2, 0);
- j = crypto_cipher_generate_key(env1);
- crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
- crypto_cipher_encrypt_init_cipher(env1);
- crypto_cipher_decrypt_init_cipher(env2);
-
- /* Try encrypting 512 chars. */
- crypto_cipher_encrypt(env1, data2, data1, 512);
- crypto_cipher_decrypt(env2, data3, data2, 512);
- test_memeq(data1, data3, 512);
- test_memneq(data1, data2, 512);
-
- /* Now encrypt 1 at a time, and get 1 at a time. */
- for (j = 512; j < 560; ++j) {
- crypto_cipher_encrypt(env1, data2+j, data1+j, 1);
- }
- for (j = 512; j < 560; ++j) {
- crypto_cipher_decrypt(env2, data3+j, data2+j, 1);
- }
- test_memeq(data1, data3, 560);
- /* Now encrypt 3 at a time, and get 5 at a time. */
- for (j = 560; j < 1024-5; j += 3) {
- crypto_cipher_encrypt(env1, data2+j, data1+j, 3);
- }
- for (j = 560; j < 1024-5; j += 5) {
- crypto_cipher_decrypt(env2, data3+j, data2+j, 5);
- }
- test_memeq(data1, data3, 1024-5);
- /* Now make sure that when we encrypt with different chunk sizes, we get
- the same results. */
- crypto_free_cipher_env(env2);
- env2 = NULL;
-
- memset(data3, 0, 1024);
- env2 = crypto_new_cipher_env();
- test_neq(env2, 0);
- crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
- crypto_cipher_encrypt_init_cipher(env2);
- for (j = 0; j < 1024-16; j += 17) {
- crypto_cipher_encrypt(env2, data3+j, data1+j, 17);
- }
- for (j= 0; j < 1024-16; ++j) {
- if (data2[j] != data3[j]) {
- printf("%d: %d\t%d\n", j, (int) data2[j], (int) data3[j]);
- }
- }
- test_memeq(data2, data3, 1024-16);
- crypto_free_cipher_env(env1);
- env1 = NULL;
- crypto_free_cipher_env(env2);
- env2 = NULL;
-
- /* NIST test vector for aes. */
- env1 = crypto_new_cipher_env(); /* IV starts at 0 */
- crypto_cipher_set_key(env1, "\x80\x00\x00\x00\x00\x00\x00\x00"
- "\x00\x00\x00\x00\x00\x00\x00\x00");
- crypto_cipher_encrypt_init_cipher(env1);
- crypto_cipher_encrypt(env1, data1,
- "\x00\x00\x00\x00\x00\x00\x00\x00"
- "\x00\x00\x00\x00\x00\x00\x00\x00", 16);
- test_memeq_hex(data1, "0EDD33D3C621E546455BD8BA1418BEC8");
-
- /* Now test rollover. All these values are originally from a python
- * script. */
- crypto_cipher_set_iv(env1, "\x00\x00\x00\x00\x00\x00\x00\x00"
- "\xff\xff\xff\xff\xff\xff\xff\xff");
- memset(data2, 0, 1024);
- crypto_cipher_encrypt(env1, data1, data2, 32);
- test_memeq_hex(data1, "335fe6da56f843199066c14a00a40231"
- "cdd0b917dbc7186908a6bfb5ffd574d3");
-
- crypto_cipher_set_iv(env1, "\x00\x00\x00\x00\xff\xff\xff\xff"
- "\xff\xff\xff\xff\xff\xff\xff\xff");
- memset(data2, 0, 1024);
- crypto_cipher_encrypt(env1, data1, data2, 32);
- test_memeq_hex(data1, "e627c6423fa2d77832a02b2794094b73"
- "3e63c721df790d2c6469cc1953a3ffac");
-
- crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
- "\xff\xff\xff\xff\xff\xff\xff\xff");
- memset(data2, 0, 1024);
- crypto_cipher_encrypt(env1, data1, data2, 32);
- test_memeq_hex(data1, "2aed2bff0de54f9328efd070bf48f70a"
- "0EDD33D3C621E546455BD8BA1418BEC8");
-
- /* Now check rollover on inplace cipher. */
- crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
- "\xff\xff\xff\xff\xff\xff\xff\xff");
- crypto_cipher_crypt_inplace(env1, data2, 64);
- test_memeq_hex(data2, "2aed2bff0de54f9328efd070bf48f70a"
- "0EDD33D3C621E546455BD8BA1418BEC8"
- "93e2c5243d6839eac58503919192f7ae"
- "1908e67cafa08d508816659c2e693191");
- crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
- "\xff\xff\xff\xff\xff\xff\xff\xff");
- crypto_cipher_crypt_inplace(env1, data2, 64);
- test_assert(tor_mem_is_zero(data2, 64));
-
- done:
- if (env1)
- crypto_free_cipher_env(env1);
- if (env2)
- crypto_free_cipher_env(env2);
- tor_free(data1);
- tor_free(data2);
- tor_free(data3);
-}
-
-/** Run unit tests for our SHA-1 functionality */
-static void
-test_crypto_sha(void)
-{
- crypto_digest_env_t *d1 = NULL, *d2 = NULL;
- int i;
- char key[80];
- char digest[32];
- char data[50];
- char d_out1[DIGEST_LEN], d_out2[DIGEST256_LEN];
-
- /* Test SHA-1 with a test vector from the specification. */
- i = crypto_digest(data, "abc", 3);
- test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
-
- /* Test SHA-256 with a test vector from the specification. */
- i = crypto_digest256(data, "abc", 3, DIGEST_SHA256);
- test_memeq_hex(data, "BA7816BF8F01CFEA414140DE5DAE2223B00361A3"
- "96177A9CB410FF61F20015AD");
-
- /* Test HMAC-SHA-1 with test cases from RFC2202. */
-
- /* Case 1. */
- memset(key, 0x0b, 20);
- crypto_hmac_sha1(digest, key, 20, "Hi There", 8);
- test_streq(hex_str(digest, 20),
- "B617318655057264E28BC0B6FB378C8EF146BE00");
- /* Case 2. */
- crypto_hmac_sha1(digest, "Jefe", 4, "what do ya want for nothing?", 28);
- test_streq(hex_str(digest, 20),
- "EFFCDF6AE5EB2FA2D27416D5F184DF9C259A7C79");
-
- /* Case 4. */
- base16_decode(key, 25,
- "0102030405060708090a0b0c0d0e0f10111213141516171819", 50);
- memset(data, 0xcd, 50);
- crypto_hmac_sha1(digest, key, 25, data, 50);
- test_streq(hex_str(digest, 20),
- "4C9007F4026250C6BC8414F9BF50C86C2D7235DA");
-
- /* Case 5. */
- memset(key, 0xaa, 80);
- crypto_hmac_sha1(digest, key, 80,
- "Test Using Larger Than Block-Size Key - Hash Key First",
- 54);
- test_streq(hex_str(digest, 20),
- "AA4AE5E15272D00E95705637CE8A3B55ED402112");
-
- /* Incremental digest code. */
- d1 = crypto_new_digest_env();
- test_assert(d1);
- crypto_digest_add_bytes(d1, "abcdef", 6);
- d2 = crypto_digest_dup(d1);
- test_assert(d2);
- crypto_digest_add_bytes(d2, "ghijkl", 6);
- crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
- crypto_digest(d_out2, "abcdefghijkl", 12);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
- crypto_digest_assign(d2, d1);
- crypto_digest_add_bytes(d2, "mno", 3);
- crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
- crypto_digest(d_out2, "abcdefmno", 9);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
- crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
- crypto_digest(d_out2, "abcdef", 6);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
- crypto_free_digest_env(d1);
- crypto_free_digest_env(d2);
-
- /* Incremental digest code with sha256 */
- d1 = crypto_new_digest256_env(DIGEST_SHA256);
- test_assert(d1);
- crypto_digest_add_bytes(d1, "abcdef", 6);
- d2 = crypto_digest_dup(d1);
- test_assert(d2);
- crypto_digest_add_bytes(d2, "ghijkl", 6);
- crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
- crypto_digest256(d_out2, "abcdefghijkl", 12, DIGEST_SHA256);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
- crypto_digest_assign(d2, d1);
- crypto_digest_add_bytes(d2, "mno", 3);
- crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
- crypto_digest256(d_out2, "abcdefmno", 9, DIGEST_SHA256);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
- crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
- crypto_digest256(d_out2, "abcdef", 6, DIGEST_SHA256);
- test_memeq(d_out1, d_out2, DIGEST_LEN);
-
- done:
- if (d1)
- crypto_free_digest_env(d1);
- if (d2)
- crypto_free_digest_env(d2);
-}
-
-/** Run unit tests for our public key crypto functions */
-static void
-test_crypto_pk(void)
-{
- crypto_pk_env_t *pk1 = NULL, *pk2 = NULL;
- char *encoded = NULL;
- char data1[1024], data2[1024], data3[1024];
- size_t size;
- int i, j, p, len;
-
- /* Public-key ciphers */
- pk1 = pk_generate(0);
- pk2 = crypto_new_pk_env();
- test_assert(pk1 && pk2);
- test_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size));
- test_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size));
- test_eq(0, crypto_pk_cmp_keys(pk1, pk2));
-
- test_eq(128, crypto_pk_keysize(pk1));
- test_eq(128, crypto_pk_keysize(pk2));
-
- test_eq(128, crypto_pk_public_encrypt(pk2, data1, "Hello whirled.", 15,
- PK_PKCS1_OAEP_PADDING));
- test_eq(128, crypto_pk_public_encrypt(pk1, data2, "Hello whirled.", 15,
- PK_PKCS1_OAEP_PADDING));
- /* oaep padding should make encryption not match */
- test_memneq(data1, data2, 128);
- test_eq(15, crypto_pk_private_decrypt(pk1, data3, data1, 128,
- PK_PKCS1_OAEP_PADDING,1));
- test_streq(data3, "Hello whirled.");
- memset(data3, 0, 1024);
- test_eq(15, crypto_pk_private_decrypt(pk1, data3, data2, 128,
- PK_PKCS1_OAEP_PADDING,1));
- test_streq(data3, "Hello whirled.");
- /* Can't decrypt with public key. */
- test_eq(-1, crypto_pk_private_decrypt(pk2, data3, data2, 128,
- PK_PKCS1_OAEP_PADDING,1));
- /* Try again with bad padding */
- memcpy(data2+1, "XYZZY", 5); /* This has fails ~ once-in-2^40 */
- test_eq(-1, crypto_pk_private_decrypt(pk1, data3, data2, 128,
- PK_PKCS1_OAEP_PADDING,1));
-
- /* File operations: save and load private key */
- test_assert(! crypto_pk_write_private_key_to_filename(pk1,
- get_fname("pkey1")));
- /* failing case for read: can't read. */
- test_assert(crypto_pk_read_private_key_from_filename(pk2,
- get_fname("xyzzy")) < 0);
- write_str_to_file(get_fname("xyzzy"), "foobar", 6);
- /* Failing case for read: no key. */
- test_assert(crypto_pk_read_private_key_from_filename(pk2,
- get_fname("xyzzy")) < 0);
- test_assert(! crypto_pk_read_private_key_from_filename(pk2,
- get_fname("pkey1")));
- test_eq(15, crypto_pk_private_decrypt(pk2, data3, data1, 128,
- PK_PKCS1_OAEP_PADDING,1));
-
- /* Now try signing. */
- strlcpy(data1, "Ossifrage", 1024);
- test_eq(128, crypto_pk_private_sign(pk1, data2, data1, 10));
- test_eq(10, crypto_pk_public_checksig(pk1, data3, data2, 128));
- test_streq(data3, "Ossifrage");
- /* Try signing digests. */
- test_eq(128, crypto_pk_private_sign_digest(pk1, data2, data1, 10));
- test_eq(20, crypto_pk_public_checksig(pk1, data3, data2, 128));
- test_eq(0, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
- test_eq(-1, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
- /*XXXX test failed signing*/
-
- /* Try encoding */
- crypto_free_pk_env(pk2);
- pk2 = NULL;
- i = crypto_pk_asn1_encode(pk1, data1, 1024);
- test_assert(i>0);
- pk2 = crypto_pk_asn1_decode(data1, i);
- test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
-
- /* Try with hybrid encryption wrappers. */
- crypto_rand(data1, 1024);
- for (i = 0; i < 3; ++i) {
- for (j = 85; j < 140; ++j) {
- memset(data2,0,1024);
- memset(data3,0,1024);
- if (i == 0 && j < 129)
- continue;
- p = (i==0)?PK_NO_PADDING:
- (i==1)?PK_PKCS1_PADDING:PK_PKCS1_OAEP_PADDING;
- len = crypto_pk_public_hybrid_encrypt(pk1,data2,data1,j,p,0);
- test_assert(len>=0);
- len = crypto_pk_private_hybrid_decrypt(pk1,data3,data2,len,p,1);
- test_eq(len,j);
- test_memeq(data1,data3,j);
- }
- }
-
- /* Try copy_full */
- crypto_free_pk_env(pk2);
- pk2 = crypto_pk_copy_full(pk1);
- test_assert(pk2 != NULL);
- test_neq_ptr(pk1, pk2);
- test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
-
- done:
- if (pk1)
- crypto_free_pk_env(pk1);
- if (pk2)
- crypto_free_pk_env(pk2);
- tor_free(encoded);
-}
-
-/** Run unit tests for misc crypto functionality. */
-static void
-test_crypto(void)
-{
- char *data1 = NULL, *data2 = NULL, *data3 = NULL;
- int i, j, idx;
-
- data1 = tor_malloc(1024);
- data2 = tor_malloc(1024);
- data3 = tor_malloc(1024);
- test_assert(data1 && data2 && data3);
-
- /* Base64 tests */
- memset(data1, 6, 1024);
- for (idx = 0; idx < 10; ++idx) {
- i = base64_encode(data2, 1024, data1, idx);
- test_assert(i >= 0);
- j = base64_decode(data3, 1024, data2, i);
- test_eq(j,idx);
- test_memeq(data3, data1, idx);
- }
-
- strlcpy(data1, "Test string that contains 35 chars.", 1024);
- strlcat(data1, " 2nd string that contains 35 chars.", 1024);
-
- i = base64_encode(data2, 1024, data1, 71);
- j = base64_decode(data3, 1024, data2, i);
- test_eq(j, 71);
- test_streq(data3, data1);
- test_assert(data2[i] == '\0');
-
- crypto_rand(data1, DIGEST_LEN);
- memset(data2, 100, 1024);
- digest_to_base64(data2, data1);
- test_eq(BASE64_DIGEST_LEN, strlen(data2));
- test_eq(100, data2[BASE64_DIGEST_LEN+2]);
- memset(data3, 99, 1024);
- test_eq(digest_from_base64(data3, data2), 0);
- test_memeq(data1, data3, DIGEST_LEN);
- test_eq(99, data3[DIGEST_LEN+1]);
-
- test_assert(digest_from_base64(data3, "###") < 0);
-
- /* Base32 tests */
- strlcpy(data1, "5chrs", 1024);
- /* bit pattern is: [35 63 68 72 73] ->
- * [00110101 01100011 01101000 01110010 01110011]
- * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
- */
- base32_encode(data2, 9, data1, 5);
- test_streq(data2, "gvrwq4tt");
-
- strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024);
- base32_encode(data2, 30, data1, 10);
- test_streq(data2, "772w2rfobvomsywe");
-
- /* Base16 tests */
- strlcpy(data1, "6chrs\xff", 1024);
- base16_encode(data2, 13, data1, 6);
- test_streq(data2, "3663687273FF");
-
- strlcpy(data1, "f0d678affc000100", 1024);
- i = base16_decode(data2, 8, data1, 16);
- test_eq(i,0);
- test_memeq(data2, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
-
- /* now try some failing base16 decodes */
- test_eq(-1, base16_decode(data2, 8, data1, 15)); /* odd input len */
- test_eq(-1, base16_decode(data2, 7, data1, 16)); /* dest too short */
- strlcpy(data1, "f0dz!8affc000100", 1024);
- test_eq(-1, base16_decode(data2, 8, data1, 16));
-
- tor_free(data1);
- tor_free(data2);
- tor_free(data3);
-
- /* Add spaces to fingerprint */
- {
- data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
- test_eq(strlen(data1), 40);
- data2 = tor_malloc(FINGERPRINT_LEN+1);
- add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
- test_streq(data2, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
- tor_free(data1);
- tor_free(data2);
- }
-
- /* Check fingerprint */
- {
- test_assert(crypto_pk_check_fingerprint_syntax(
- "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"));
- test_assert(!crypto_pk_check_fingerprint_syntax(
- "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 000"));
- test_assert(!crypto_pk_check_fingerprint_syntax(
- "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
- test_assert(!crypto_pk_check_fingerprint_syntax(
- "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 0000"));
- test_assert(!crypto_pk_check_fingerprint_syntax(
- "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 00000"));
- test_assert(!crypto_pk_check_fingerprint_syntax(
- "ACD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
- }
-
- done:
- tor_free(data1);
- tor_free(data2);
- tor_free(data3);
-}
-
-/** Run unit tests for our secret-to-key passphrase hashing functionality. */
-static void
-test_crypto_s2k(void)
-{
- char buf[29];
- char buf2[29];
- char *buf3 = NULL;
- int i;
-
- memset(buf, 0, sizeof(buf));
- memset(buf2, 0, sizeof(buf2));
- buf3 = tor_malloc(65536);
- memset(buf3, 0, 65536);
-
- secret_to_key(buf+9, 20, "", 0, buf);
- crypto_digest(buf2+9, buf3, 1024);
- test_memeq(buf, buf2, 29);
-
- memcpy(buf,"vrbacrda",8);
- memcpy(buf2,"vrbacrda",8);
- buf[8] = 96;
- buf2[8] = 96;
- secret_to_key(buf+9, 20, "12345678", 8, buf);
- for (i = 0; i < 65536; i += 16) {
- memcpy(buf3+i, "vrbacrda12345678", 16);
- }
- crypto_digest(buf2+9, buf3, 65536);
- test_memeq(buf, buf2, 29);
-
- done:
- tor_free(buf3);
-}
-
/** Helper: return a tristate based on comparing the strings in *<b>a</b> and
* *<b>b</b>. */
static int
@@ -4667,189 +4108,6 @@ test_util_strtok(void)
;
}
-/** Test AES-CTR encryption and decryption with IV. */
-static void
-test_crypto_aes_iv(void)
-{
- crypto_cipher_env_t *cipher;
- char *plain, *encrypted1, *encrypted2, *decrypted1, *decrypted2;
- char plain_1[1], plain_15[15], plain_16[16], plain_17[17];
- char key1[16], key2[16];
- ssize_t encrypted_size, decrypted_size;
-
- plain = tor_malloc(4095);
- encrypted1 = tor_malloc(4095 + 1 + 16);
- encrypted2 = tor_malloc(4095 + 1 + 16);
- decrypted1 = tor_malloc(4095 + 1);
- decrypted2 = tor_malloc(4095 + 1);
-
- crypto_rand(plain, 4095);
- crypto_rand(key1, 16);
- crypto_rand(key2, 16);
- crypto_rand(plain_1, 1);
- crypto_rand(plain_15, 15);
- crypto_rand(plain_16, 16);
- crypto_rand(plain_17, 17);
- key1[0] = key2[0] + 128; /* Make sure that contents are different. */
- /* Encrypt and decrypt with the same key. */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 4095,
- plain, 4095);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 4095);
- tor_assert(encrypted_size > 0); /* This is obviously true, since 4111 is
- * greater than 0, but its truth is not
- * obvious to all analysis tools. */
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 4095,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(decrypted_size, 4095);
- tor_assert(decrypted_size > 0);
- test_memeq(plain, decrypted1, 4095);
- /* Encrypt a second time (with a new random initialization vector). */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted2, 16 + 4095,
- plain, 4095);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 4095);
- tor_assert(encrypted_size > 0);
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted2, 4095,
- encrypted2, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(decrypted_size, 4095);
- tor_assert(decrypted_size > 0);
- test_memeq(plain, decrypted2, 4095);
- test_memneq(encrypted1, encrypted2, encrypted_size);
- /* Decrypt with the wrong key. */
- cipher = crypto_create_init_cipher(key2, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted2, 4095,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_memneq(plain, decrypted2, encrypted_size);
- /* Alter the initialization vector. */
- encrypted1[0] += 42;
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 4095,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_memneq(plain, decrypted2, 4095);
- /* Special length case: 1. */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 1,
- plain_1, 1);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 1);
- tor_assert(encrypted_size > 0);
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 1,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(decrypted_size, 1);
- tor_assert(decrypted_size > 0);
- test_memeq(plain_1, decrypted1, 1);
- /* Special length case: 15. */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 15,
- plain_15, 15);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 15);
- tor_assert(encrypted_size > 0);
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 15,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(decrypted_size, 15);
- tor_assert(decrypted_size > 0);
- test_memeq(plain_15, decrypted1, 15);
- /* Special length case: 16. */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 16,
- plain_16, 16);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 16);
- tor_assert(encrypted_size > 0);
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 16,
- encrypted1, encrypted_size);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(decrypted_size, 16);
- tor_assert(decrypted_size > 0);
- test_memeq(plain_16, decrypted1, 16);
- /* Special length case: 17. */
- cipher = crypto_create_init_cipher(key1, 1);
- encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 17,
- plain_17, 17);
- crypto_free_cipher_env(cipher);
- cipher = NULL;
- test_eq(encrypted_size, 16 + 17);
- tor_assert(encrypted_size > 0);
- cipher = crypto_create_init_cipher(key1, 0);
- decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 17,
- encrypted1, encrypted_size);
- test_eq(decrypted_size, 17);
- tor_assert(decrypted_size > 0);
- test_memeq(plain_17, decrypted1, 17);
-
- done:
- /* Free memory. */
- tor_free(plain);
- tor_free(encrypted1);
- tor_free(encrypted2);
- tor_free(decrypted1);
- tor_free(decrypted2);
- if (cipher)
- crypto_free_cipher_env(cipher);
-}
-
-/** Test base32 decoding. */
-static void
-test_crypto_base32_decode(void)
-{
- char plain[60], encoded[96 + 1], decoded[60];
- int res;
- crypto_rand(plain, 60);
- /* Encode and decode a random string. */
- base32_encode(encoded, 96 + 1, plain, 60);
- res = base32_decode(decoded, 60, encoded, 96);
- test_eq(res, 0);
- test_memeq(plain, decoded, 60);
- /* Encode, uppercase, and decode a random string. */
- base32_encode(encoded, 96 + 1, plain, 60);
- tor_strupper(encoded);
- res = base32_decode(decoded, 60, encoded, 96);
- test_eq(res, 0);
- test_memeq(plain, decoded, 60);
- /* Change encoded string and decode. */
- if (encoded[0] == 'A' || encoded[0] == 'a')
- encoded[0] = 'B';
- else
- encoded[0] = 'A';
- res = base32_decode(decoded, 60, encoded, 96);
- test_eq(res, 0);
- test_memneq(plain, decoded, 60);
- /* Bad encodings. */
- encoded[0] = '!';
- res = base32_decode(decoded, 60, encoded, 96);
- test_assert(res < 0);
-
- done:
- ;
-}
-
/** Test encoding and parsing of rendezvous service descriptors. */
static void
test_rend_fns(void)
@@ -5031,7 +4289,7 @@ legacy_test_setup(const struct testcase_t *testcase)
return testcase->setup_data;
}
-static void
+void
legacy_test_helper(void *data)
{
void (*fn)(void) = data;
@@ -5046,7 +4304,7 @@ legacy_test_cleanup(const struct testcase_t *testcase, void *ptr)
return 1;
}
-static const struct testcase_setup_t legacy_setup = {
+const struct testcase_setup_t legacy_setup = {
legacy_test_setup, legacy_test_cleanup
};
@@ -5060,15 +4318,6 @@ static const struct testcase_setup_t legacy_setup = {
static struct testcase_t test_array[] = {
ENT(buffers),
- ENT(crypto),
- SUBENT(crypto, rng),
- SUBENT(crypto, aes),
- SUBENT(crypto, sha),
- SUBENT(crypto, pk),
- SUBENT(crypto, dh),
- SUBENT(crypto, s2k),
- SUBENT(crypto, aes_iv),
- SUBENT(crypto, base32_decode),
ENT(util),
SUBENT(util, ip6_helpers),
SUBENT(util, gzip),
@@ -5106,8 +4355,11 @@ static struct testcase_t test_array[] = {
END_OF_TESTCASES
};
+extern struct testcase_t crypto_tests[];
+
static struct testgroup_t testgroups[] = {
{ "", test_array },
+ { "crypto/", crypto_tests },
END_OF_GROUPS
};
diff --git a/src/test/test.h b/src/test/test.h
index e4bae6d..b5076c0 100644
--- a/src/test/test.h
+++ b/src/test/test.h
@@ -8,7 +8,7 @@
/**
* \file test.h
- * \brief Macros used by unit tests.
+ * \brief Macros and functions used by unit tests.
*/
#include "compat.h"
@@ -62,5 +62,11 @@
#define test_memeq_hex(expr1, hex) test_mem_op_hex(expr1, ==, hex)
+const char *get_fname(const char *name);
+crypto_pk_env_t *pk_generate(int idx);
+
+void legacy_test_helper(void *data);
+extern const struct testcase_setup_t legacy_setup;
+
#endif
diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
new file mode 100644
index 0000000..d937d43
--- /dev/null
+++ b/src/test/test_crypto.c
@@ -0,0 +1,768 @@
+/* Copyright (c) 2001-2004, Roger Dingledine.
+ * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
+ * Copyright (c) 2007-2009, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+#include "orconfig.h"
+#define CRYPTO_PRIVATE
+#include "or.h"
+#include "test.h"
+
+/** Run unit tests for Diffie-Hellman functionality. */
+static void
+test_crypto_dh(void)
+{
+ crypto_dh_env_t *dh1 = crypto_dh_new();
+ crypto_dh_env_t *dh2 = crypto_dh_new();
+ char p1[DH_BYTES];
+ char p2[DH_BYTES];
+ char s1[DH_BYTES];
+ char s2[DH_BYTES];
+ ssize_t s1len, s2len;
+
+ test_eq(crypto_dh_get_bytes(dh1), DH_BYTES);
+ test_eq(crypto_dh_get_bytes(dh2), DH_BYTES);
+
+ memset(p1, 0, DH_BYTES);
+ memset(p2, 0, DH_BYTES);
+ test_memeq(p1, p2, DH_BYTES);
+ test_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
+ test_memneq(p1, p2, DH_BYTES);
+ test_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
+ test_memneq(p1, p2, DH_BYTES);
+
+ memset(s1, 0, DH_BYTES);
+ memset(s2, 0xFF, DH_BYTES);
+ s1len = crypto_dh_compute_secret(dh1, p2, DH_BYTES, s1, 50);
+ s2len = crypto_dh_compute_secret(dh2, p1, DH_BYTES, s2, 50);
+ test_assert(s1len > 0);
+ test_eq(s1len, s2len);
+ test_memeq(s1, s2, s1len);
+
+ {
+ /* XXXX Now fabricate some bad values and make sure they get caught,
+ * Check 0, 1, N-1, >= N, etc.
+ */
+ }
+
+ done:
+ crypto_dh_free(dh1);
+ crypto_dh_free(dh2);
+}
+
+/** Run unit tests for our random number generation function and its wrappers.
+ */
+static void
+test_crypto_rng(void)
+{
+ int i, j, allok;
+ char data1[100], data2[100];
+
+ /* Try out RNG. */
+ test_assert(! crypto_seed_rng(0));
+ crypto_rand(data1, 100);
+ crypto_rand(data2, 100);
+ test_memneq(data1,data2,100);
+ allok = 1;
+ for (i = 0; i < 100; ++i) {
+ uint64_t big;
+ char *host;
+ j = crypto_rand_int(100);
+ if (i < 0 || i >= 100)
+ allok = 0;
+ big = crypto_rand_uint64(U64_LITERAL(1)<<40);
+ if (big >= (U64_LITERAL(1)<<40))
+ allok = 0;
+ big = crypto_rand_uint64(U64_LITERAL(5));
+ if (big >= 5)
+ allok = 0;
+ host = crypto_random_hostname(3,8,"www.",".onion");
+ if (strcmpstart(host,"www.") ||
+ strcmpend(host,".onion") ||
+ strlen(host) < 13 ||
+ strlen(host) > 18)
+ allok = 0;
+ tor_free(host);
+ }
+ test_assert(allok);
+ done:
+ ;
+}
+
+/** Run unit tests for our AES functionality */
+static void
+test_crypto_aes(void)
+{
+ char *data1 = NULL, *data2 = NULL, *data3 = NULL;
+ crypto_cipher_env_t *env1 = NULL, *env2 = NULL;
+ int i, j;
+
+ data1 = tor_malloc(1024);
+ data2 = tor_malloc(1024);
+ data3 = tor_malloc(1024);
+
+ /* Now, test encryption and decryption with stream cipher. */
+ data1[0]='\0';
+ for (i = 1023; i>0; i -= 35)
+ strncat(data1, "Now is the time for all good onions", i);
+
+ memset(data2, 0, 1024);
+ memset(data3, 0, 1024);
+ env1 = crypto_new_cipher_env();
+ test_neq(env1, 0);
+ env2 = crypto_new_cipher_env();
+ test_neq(env2, 0);
+ j = crypto_cipher_generate_key(env1);
+ crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
+ crypto_cipher_encrypt_init_cipher(env1);
+ crypto_cipher_decrypt_init_cipher(env2);
+
+ /* Try encrypting 512 chars. */
+ crypto_cipher_encrypt(env1, data2, data1, 512);
+ crypto_cipher_decrypt(env2, data3, data2, 512);
+ test_memeq(data1, data3, 512);
+ test_memneq(data1, data2, 512);
+
+ /* Now encrypt 1 at a time, and get 1 at a time. */
+ for (j = 512; j < 560; ++j) {
+ crypto_cipher_encrypt(env1, data2+j, data1+j, 1);
+ }
+ for (j = 512; j < 560; ++j) {
+ crypto_cipher_decrypt(env2, data3+j, data2+j, 1);
+ }
+ test_memeq(data1, data3, 560);
+ /* Now encrypt 3 at a time, and get 5 at a time. */
+ for (j = 560; j < 1024-5; j += 3) {
+ crypto_cipher_encrypt(env1, data2+j, data1+j, 3);
+ }
+ for (j = 560; j < 1024-5; j += 5) {
+ crypto_cipher_decrypt(env2, data3+j, data2+j, 5);
+ }
+ test_memeq(data1, data3, 1024-5);
+ /* Now make sure that when we encrypt with different chunk sizes, we get
+ the same results. */
+ crypto_free_cipher_env(env2);
+ env2 = NULL;
+
+ memset(data3, 0, 1024);
+ env2 = crypto_new_cipher_env();
+ test_neq(env2, 0);
+ crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
+ crypto_cipher_encrypt_init_cipher(env2);
+ for (j = 0; j < 1024-16; j += 17) {
+ crypto_cipher_encrypt(env2, data3+j, data1+j, 17);
+ }
+ for (j= 0; j < 1024-16; ++j) {
+ if (data2[j] != data3[j]) {
+ printf("%d: %d\t%d\n", j, (int) data2[j], (int) data3[j]);
+ }
+ }
+ test_memeq(data2, data3, 1024-16);
+ crypto_free_cipher_env(env1);
+ env1 = NULL;
+ crypto_free_cipher_env(env2);
+ env2 = NULL;
+
+ /* NIST test vector for aes. */
+ env1 = crypto_new_cipher_env(); /* IV starts at 0 */
+ crypto_cipher_set_key(env1, "\x80\x00\x00\x00\x00\x00\x00\x00"
+ "\x00\x00\x00\x00\x00\x00\x00\x00");
+ crypto_cipher_encrypt_init_cipher(env1);
+ crypto_cipher_encrypt(env1, data1,
+ "\x00\x00\x00\x00\x00\x00\x00\x00"
+ "\x00\x00\x00\x00\x00\x00\x00\x00", 16);
+ test_memeq_hex(data1, "0EDD33D3C621E546455BD8BA1418BEC8");
+
+ /* Now test rollover. All these values are originally from a python
+ * script. */
+ crypto_cipher_set_iv(env1, "\x00\x00\x00\x00\x00\x00\x00\x00"
+ "\xff\xff\xff\xff\xff\xff\xff\xff");
+ memset(data2, 0, 1024);
+ crypto_cipher_encrypt(env1, data1, data2, 32);
+ test_memeq_hex(data1, "335fe6da56f843199066c14a00a40231"
+ "cdd0b917dbc7186908a6bfb5ffd574d3");
+
+ crypto_cipher_set_iv(env1, "\x00\x00\x00\x00\xff\xff\xff\xff"
+ "\xff\xff\xff\xff\xff\xff\xff\xff");
+ memset(data2, 0, 1024);
+ crypto_cipher_encrypt(env1, data1, data2, 32);
+ test_memeq_hex(data1, "e627c6423fa2d77832a02b2794094b73"
+ "3e63c721df790d2c6469cc1953a3ffac");
+
+ crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
+ "\xff\xff\xff\xff\xff\xff\xff\xff");
+ memset(data2, 0, 1024);
+ crypto_cipher_encrypt(env1, data1, data2, 32);
+ test_memeq_hex(data1, "2aed2bff0de54f9328efd070bf48f70a"
+ "0EDD33D3C621E546455BD8BA1418BEC8");
+
+ /* Now check rollover on inplace cipher. */
+ crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
+ "\xff\xff\xff\xff\xff\xff\xff\xff");
+ crypto_cipher_crypt_inplace(env1, data2, 64);
+ test_memeq_hex(data2, "2aed2bff0de54f9328efd070bf48f70a"
+ "0EDD33D3C621E546455BD8BA1418BEC8"
+ "93e2c5243d6839eac58503919192f7ae"
+ "1908e67cafa08d508816659c2e693191");
+ crypto_cipher_set_iv(env1, "\xff\xff\xff\xff\xff\xff\xff\xff"
+ "\xff\xff\xff\xff\xff\xff\xff\xff");
+ crypto_cipher_crypt_inplace(env1, data2, 64);
+ test_assert(tor_mem_is_zero(data2, 64));
+
+ done:
+ if (env1)
+ crypto_free_cipher_env(env1);
+ if (env2)
+ crypto_free_cipher_env(env2);
+ tor_free(data1);
+ tor_free(data2);
+ tor_free(data3);
+}
+
+/** Run unit tests for our SHA-1 functionality */
+static void
+test_crypto_sha(void)
+{
+ crypto_digest_env_t *d1 = NULL, *d2 = NULL;
+ int i;
+ char key[80];
+ char digest[32];
+ char data[50];
+ char d_out1[DIGEST_LEN], d_out2[DIGEST256_LEN];
+
+ /* Test SHA-1 with a test vector from the specification. */
+ i = crypto_digest(data, "abc", 3);
+ test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
+
+ /* Test SHA-256 with a test vector from the specification. */
+ i = crypto_digest256(data, "abc", 3, DIGEST_SHA256);
+ test_memeq_hex(data, "BA7816BF8F01CFEA414140DE5DAE2223B00361A3"
+ "96177A9CB410FF61F20015AD");
+
+ /* Test HMAC-SHA-1 with test cases from RFC2202. */
+
+ /* Case 1. */
+ memset(key, 0x0b, 20);
+ crypto_hmac_sha1(digest, key, 20, "Hi There", 8);
+ test_streq(hex_str(digest, 20),
+ "B617318655057264E28BC0B6FB378C8EF146BE00");
+ /* Case 2. */
+ crypto_hmac_sha1(digest, "Jefe", 4, "what do ya want for nothing?", 28);
+ test_streq(hex_str(digest, 20),
+ "EFFCDF6AE5EB2FA2D27416D5F184DF9C259A7C79");
+
+ /* Case 4. */
+ base16_decode(key, 25,
+ "0102030405060708090a0b0c0d0e0f10111213141516171819", 50);
+ memset(data, 0xcd, 50);
+ crypto_hmac_sha1(digest, key, 25, data, 50);
+ test_streq(hex_str(digest, 20),
+ "4C9007F4026250C6BC8414F9BF50C86C2D7235DA");
+
+ /* Case 5. */
+ memset(key, 0xaa, 80);
+ crypto_hmac_sha1(digest, key, 80,
+ "Test Using Larger Than Block-Size Key - Hash Key First",
+ 54);
+ test_streq(hex_str(digest, 20),
+ "AA4AE5E15272D00E95705637CE8A3B55ED402112");
+
+ /* Incremental digest code. */
+ d1 = crypto_new_digest_env();
+ test_assert(d1);
+ crypto_digest_add_bytes(d1, "abcdef", 6);
+ d2 = crypto_digest_dup(d1);
+ test_assert(d2);
+ crypto_digest_add_bytes(d2, "ghijkl", 6);
+ crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
+ crypto_digest(d_out2, "abcdefghijkl", 12);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+ crypto_digest_assign(d2, d1);
+ crypto_digest_add_bytes(d2, "mno", 3);
+ crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
+ crypto_digest(d_out2, "abcdefmno", 9);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+ crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
+ crypto_digest(d_out2, "abcdef", 6);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+ crypto_free_digest_env(d1);
+ crypto_free_digest_env(d2);
+
+ /* Incremental digest code with sha256 */
+ d1 = crypto_new_digest256_env(DIGEST_SHA256);
+ test_assert(d1);
+ crypto_digest_add_bytes(d1, "abcdef", 6);
+ d2 = crypto_digest_dup(d1);
+ test_assert(d2);
+ crypto_digest_add_bytes(d2, "ghijkl", 6);
+ crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
+ crypto_digest256(d_out2, "abcdefghijkl", 12, DIGEST_SHA256);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+ crypto_digest_assign(d2, d1);
+ crypto_digest_add_bytes(d2, "mno", 3);
+ crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
+ crypto_digest256(d_out2, "abcdefmno", 9, DIGEST_SHA256);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+ crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
+ crypto_digest256(d_out2, "abcdef", 6, DIGEST_SHA256);
+ test_memeq(d_out1, d_out2, DIGEST_LEN);
+
+ done:
+ if (d1)
+ crypto_free_digest_env(d1);
+ if (d2)
+ crypto_free_digest_env(d2);
+}
+
+/** Run unit tests for our public key crypto functions */
+static void
+test_crypto_pk(void)
+{
+ crypto_pk_env_t *pk1 = NULL, *pk2 = NULL;
+ char *encoded = NULL;
+ char data1[1024], data2[1024], data3[1024];
+ size_t size;
+ int i, j, p, len;
+
+ /* Public-key ciphers */
+ pk1 = pk_generate(0);
+ pk2 = crypto_new_pk_env();
+ test_assert(pk1 && pk2);
+ test_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size));
+ test_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size));
+ test_eq(0, crypto_pk_cmp_keys(pk1, pk2));
+
+ test_eq(128, crypto_pk_keysize(pk1));
+ test_eq(128, crypto_pk_keysize(pk2));
+
+ test_eq(128, crypto_pk_public_encrypt(pk2, data1, "Hello whirled.", 15,
+ PK_PKCS1_OAEP_PADDING));
+ test_eq(128, crypto_pk_public_encrypt(pk1, data2, "Hello whirled.", 15,
+ PK_PKCS1_OAEP_PADDING));
+ /* oaep padding should make encryption not match */
+ test_memneq(data1, data2, 128);
+ test_eq(15, crypto_pk_private_decrypt(pk1, data3, data1, 128,
+ PK_PKCS1_OAEP_PADDING,1));
+ test_streq(data3, "Hello whirled.");
+ memset(data3, 0, 1024);
+ test_eq(15, crypto_pk_private_decrypt(pk1, data3, data2, 128,
+ PK_PKCS1_OAEP_PADDING,1));
+ test_streq(data3, "Hello whirled.");
+ /* Can't decrypt with public key. */
+ test_eq(-1, crypto_pk_private_decrypt(pk2, data3, data2, 128,
+ PK_PKCS1_OAEP_PADDING,1));
+ /* Try again with bad padding */
+ memcpy(data2+1, "XYZZY", 5); /* This has fails ~ once-in-2^40 */
+ test_eq(-1, crypto_pk_private_decrypt(pk1, data3, data2, 128,
+ PK_PKCS1_OAEP_PADDING,1));
+
+ /* File operations: save and load private key */
+ test_assert(! crypto_pk_write_private_key_to_filename(pk1,
+ get_fname("pkey1")));
+ /* failing case for read: can't read. */
+ test_assert(crypto_pk_read_private_key_from_filename(pk2,
+ get_fname("xyzzy")) < 0);
+ write_str_to_file(get_fname("xyzzy"), "foobar", 6);
+ /* Failing case for read: no key. */
+ test_assert(crypto_pk_read_private_key_from_filename(pk2,
+ get_fname("xyzzy")) < 0);
+ test_assert(! crypto_pk_read_private_key_from_filename(pk2,
+ get_fname("pkey1")));
+ test_eq(15, crypto_pk_private_decrypt(pk2, data3, data1, 128,
+ PK_PKCS1_OAEP_PADDING,1));
+
+ /* Now try signing. */
+ strlcpy(data1, "Ossifrage", 1024);
+ test_eq(128, crypto_pk_private_sign(pk1, data2, data1, 10));
+ test_eq(10, crypto_pk_public_checksig(pk1, data3, data2, 128));
+ test_streq(data3, "Ossifrage");
+ /* Try signing digests. */
+ test_eq(128, crypto_pk_private_sign_digest(pk1, data2, data1, 10));
+ test_eq(20, crypto_pk_public_checksig(pk1, data3, data2, 128));
+ test_eq(0, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
+ test_eq(-1, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
+ /*XXXX test failed signing*/
+
+ /* Try encoding */
+ crypto_free_pk_env(pk2);
+ pk2 = NULL;
+ i = crypto_pk_asn1_encode(pk1, data1, 1024);
+ test_assert(i>0);
+ pk2 = crypto_pk_asn1_decode(data1, i);
+ test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
+
+ /* Try with hybrid encryption wrappers. */
+ crypto_rand(data1, 1024);
+ for (i = 0; i < 3; ++i) {
+ for (j = 85; j < 140; ++j) {
+ memset(data2,0,1024);
+ memset(data3,0,1024);
+ if (i == 0 && j < 129)
+ continue;
+ p = (i==0)?PK_NO_PADDING:
+ (i==1)?PK_PKCS1_PADDING:PK_PKCS1_OAEP_PADDING;
+ len = crypto_pk_public_hybrid_encrypt(pk1,data2,data1,j,p,0);
+ test_assert(len>=0);
+ len = crypto_pk_private_hybrid_decrypt(pk1,data3,data2,len,p,1);
+ test_eq(len,j);
+ test_memeq(data1,data3,j);
+ }
+ }
+
+ /* Try copy_full */
+ crypto_free_pk_env(pk2);
+ pk2 = crypto_pk_copy_full(pk1);
+ test_assert(pk2 != NULL);
+ test_neq_ptr(pk1, pk2);
+ test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
+
+ done:
+ if (pk1)
+ crypto_free_pk_env(pk1);
+ if (pk2)
+ crypto_free_pk_env(pk2);
+ tor_free(encoded);
+}
+
+/** Run unit tests for misc crypto formatting functionality (base64, base32,
+ * fingerprints, etc) */
+static void
+test_crypto_formats(void)
+{
+ char *data1 = NULL, *data2 = NULL, *data3 = NULL;
+ int i, j, idx;
+
+ data1 = tor_malloc(1024);
+ data2 = tor_malloc(1024);
+ data3 = tor_malloc(1024);
+ test_assert(data1 && data2 && data3);
+
+ /* Base64 tests */
+ memset(data1, 6, 1024);
+ for (idx = 0; idx < 10; ++idx) {
+ i = base64_encode(data2, 1024, data1, idx);
+ test_assert(i >= 0);
+ j = base64_decode(data3, 1024, data2, i);
+ test_eq(j,idx);
+ test_memeq(data3, data1, idx);
+ }
+
+ strlcpy(data1, "Test string that contains 35 chars.", 1024);
+ strlcat(data1, " 2nd string that contains 35 chars.", 1024);
+
+ i = base64_encode(data2, 1024, data1, 71);
+ j = base64_decode(data3, 1024, data2, i);
+ test_eq(j, 71);
+ test_streq(data3, data1);
+ test_assert(data2[i] == '\0');
+
+ crypto_rand(data1, DIGEST_LEN);
+ memset(data2, 100, 1024);
+ digest_to_base64(data2, data1);
+ test_eq(BASE64_DIGEST_LEN, strlen(data2));
+ test_eq(100, data2[BASE64_DIGEST_LEN+2]);
+ memset(data3, 99, 1024);
+ test_eq(digest_from_base64(data3, data2), 0);
+ test_memeq(data1, data3, DIGEST_LEN);
+ test_eq(99, data3[DIGEST_LEN+1]);
+
+ test_assert(digest_from_base64(data3, "###") < 0);
+
+ /* Base32 tests */
+ strlcpy(data1, "5chrs", 1024);
+ /* bit pattern is: [35 63 68 72 73] ->
+ * [00110101 01100011 01101000 01110010 01110011]
+ * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
+ */
+ base32_encode(data2, 9, data1, 5);
+ test_streq(data2, "gvrwq4tt");
+
+ strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024);
+ base32_encode(data2, 30, data1, 10);
+ test_streq(data2, "772w2rfobvomsywe");
+
+ /* Base16 tests */
+ strlcpy(data1, "6chrs\xff", 1024);
+ base16_encode(data2, 13, data1, 6);
+ test_streq(data2, "3663687273FF");
+
+ strlcpy(data1, "f0d678affc000100", 1024);
+ i = base16_decode(data2, 8, data1, 16);
+ test_eq(i,0);
+ test_memeq(data2, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
+
+ /* now try some failing base16 decodes */
+ test_eq(-1, base16_decode(data2, 8, data1, 15)); /* odd input len */
+ test_eq(-1, base16_decode(data2, 7, data1, 16)); /* dest too short */
+ strlcpy(data1, "f0dz!8affc000100", 1024);
+ test_eq(-1, base16_decode(data2, 8, data1, 16));
+
+ tor_free(data1);
+ tor_free(data2);
+ tor_free(data3);
+
+ /* Add spaces to fingerprint */
+ {
+ data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
+ test_eq(strlen(data1), 40);
+ data2 = tor_malloc(FINGERPRINT_LEN+1);
+ add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
+ test_streq(data2, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
+ tor_free(data1);
+ tor_free(data2);
+ }
+
+ /* Check fingerprint */
+ {
+ test_assert(crypto_pk_check_fingerprint_syntax(
+ "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"));
+ test_assert(!crypto_pk_check_fingerprint_syntax(
+ "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 000"));
+ test_assert(!crypto_pk_check_fingerprint_syntax(
+ "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
+ test_assert(!crypto_pk_check_fingerprint_syntax(
+ "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 0000"));
+ test_assert(!crypto_pk_check_fingerprint_syntax(
+ "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 00000"));
+ test_assert(!crypto_pk_check_fingerprint_syntax(
+ "ACD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
+ }
+
+ done:
+ tor_free(data1);
+ tor_free(data2);
+ tor_free(data3);
+}
+
+/** Run unit tests for our secret-to-key passphrase hashing functionality. */
+static void
+test_crypto_s2k(void)
+{
+ char buf[29];
+ char buf2[29];
+ char *buf3 = NULL;
+ int i;
+
+ memset(buf, 0, sizeof(buf));
+ memset(buf2, 0, sizeof(buf2));
+ buf3 = tor_malloc(65536);
+ memset(buf3, 0, 65536);
+
+ secret_to_key(buf+9, 20, "", 0, buf);
+ crypto_digest(buf2+9, buf3, 1024);
+ test_memeq(buf, buf2, 29);
+
+ memcpy(buf,"vrbacrda",8);
+ memcpy(buf2,"vrbacrda",8);
+ buf[8] = 96;
+ buf2[8] = 96;
+ secret_to_key(buf+9, 20, "12345678", 8, buf);
+ for (i = 0; i < 65536; i += 16) {
+ memcpy(buf3+i, "vrbacrda12345678", 16);
+ }
+ crypto_digest(buf2+9, buf3, 65536);
+ test_memeq(buf, buf2, 29);
+
+ done:
+ tor_free(buf3);
+}
+
+/** Test AES-CTR encryption and decryption with IV. */
+static void
+test_crypto_aes_iv(void)
+{
+ crypto_cipher_env_t *cipher;
+ char *plain, *encrypted1, *encrypted2, *decrypted1, *decrypted2;
+ char plain_1[1], plain_15[15], plain_16[16], plain_17[17];
+ char key1[16], key2[16];
+ ssize_t encrypted_size, decrypted_size;
+
+ plain = tor_malloc(4095);
+ encrypted1 = tor_malloc(4095 + 1 + 16);
+ encrypted2 = tor_malloc(4095 + 1 + 16);
+ decrypted1 = tor_malloc(4095 + 1);
+ decrypted2 = tor_malloc(4095 + 1);
+
+ crypto_rand(plain, 4095);
+ crypto_rand(key1, 16);
+ crypto_rand(key2, 16);
+ crypto_rand(plain_1, 1);
+ crypto_rand(plain_15, 15);
+ crypto_rand(plain_16, 16);
+ crypto_rand(plain_17, 17);
+ key1[0] = key2[0] + 128; /* Make sure that contents are different. */
+ /* Encrypt and decrypt with the same key. */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 4095,
+ plain, 4095);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 4095);
+ tor_assert(encrypted_size > 0); /* This is obviously true, since 4111 is
+ * greater than 0, but its truth is not
+ * obvious to all analysis tools. */
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 4095,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(decrypted_size, 4095);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain, decrypted1, 4095);
+ /* Encrypt a second time (with a new random initialization vector). */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted2, 16 + 4095,
+ plain, 4095);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 4095);
+ tor_assert(encrypted_size > 0);
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted2, 4095,
+ encrypted2, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(decrypted_size, 4095);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain, decrypted2, 4095);
+ test_memneq(encrypted1, encrypted2, encrypted_size);
+ /* Decrypt with the wrong key. */
+ cipher = crypto_create_init_cipher(key2, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted2, 4095,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_memneq(plain, decrypted2, encrypted_size);
+ /* Alter the initialization vector. */
+ encrypted1[0] += 42;
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 4095,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_memneq(plain, decrypted2, 4095);
+ /* Special length case: 1. */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 1,
+ plain_1, 1);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 1);
+ tor_assert(encrypted_size > 0);
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 1,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(decrypted_size, 1);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain_1, decrypted1, 1);
+ /* Special length case: 15. */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 15,
+ plain_15, 15);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 15);
+ tor_assert(encrypted_size > 0);
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 15,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(decrypted_size, 15);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain_15, decrypted1, 15);
+ /* Special length case: 16. */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 16,
+ plain_16, 16);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 16);
+ tor_assert(encrypted_size > 0);
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 16,
+ encrypted1, encrypted_size);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(decrypted_size, 16);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain_16, decrypted1, 16);
+ /* Special length case: 17. */
+ cipher = crypto_create_init_cipher(key1, 1);
+ encrypted_size = crypto_cipher_encrypt_with_iv(cipher, encrypted1, 16 + 17,
+ plain_17, 17);
+ crypto_free_cipher_env(cipher);
+ cipher = NULL;
+ test_eq(encrypted_size, 16 + 17);
+ tor_assert(encrypted_size > 0);
+ cipher = crypto_create_init_cipher(key1, 0);
+ decrypted_size = crypto_cipher_decrypt_with_iv(cipher, decrypted1, 17,
+ encrypted1, encrypted_size);
+ test_eq(decrypted_size, 17);
+ tor_assert(decrypted_size > 0);
+ test_memeq(plain_17, decrypted1, 17);
+
+ done:
+ /* Free memory. */
+ tor_free(plain);
+ tor_free(encrypted1);
+ tor_free(encrypted2);
+ tor_free(decrypted1);
+ tor_free(decrypted2);
+ if (cipher)
+ crypto_free_cipher_env(cipher);
+}
+
+/** Test base32 decoding. */
+static void
+test_crypto_base32_decode(void)
+{
+ char plain[60], encoded[96 + 1], decoded[60];
+ int res;
+ crypto_rand(plain, 60);
+ /* Encode and decode a random string. */
+ base32_encode(encoded, 96 + 1, plain, 60);
+ res = base32_decode(decoded, 60, encoded, 96);
+ test_eq(res, 0);
+ test_memeq(plain, decoded, 60);
+ /* Encode, uppercase, and decode a random string. */
+ base32_encode(encoded, 96 + 1, plain, 60);
+ tor_strupper(encoded);
+ res = base32_decode(decoded, 60, encoded, 96);
+ test_eq(res, 0);
+ test_memeq(plain, decoded, 60);
+ /* Change encoded string and decode. */
+ if (encoded[0] == 'A' || encoded[0] == 'a')
+ encoded[0] = 'B';
+ else
+ encoded[0] = 'A';
+ res = base32_decode(decoded, 60, encoded, 96);
+ test_eq(res, 0);
+ test_memneq(plain, decoded, 60);
+ /* Bad encodings. */
+ encoded[0] = '!';
+ res = base32_decode(decoded, 60, encoded, 96);
+ test_assert(res < 0);
+
+ done:
+ ;
+}
+
+#define CRYPTO_LEGACY(name) \
+ { #name, legacy_test_helper, 0, &legacy_setup, test_crypto_ ## name }
+
+struct testcase_t crypto_tests[] = {
+ CRYPTO_LEGACY(formats),
+ CRYPTO_LEGACY(rng),
+ CRYPTO_LEGACY(aes),
+ CRYPTO_LEGACY(sha),
+ CRYPTO_LEGACY(pk),
+ CRYPTO_LEGACY(dh),
+ CRYPTO_LEGACY(s2k),
+ CRYPTO_LEGACY(aes_iv),
+ CRYPTO_LEGACY(base32_decode),
+ END_OF_TESTCASES
+};
+
--
1.5.6.5
More information about the tor-commits
mailing list