lib: Harden crypto unit tests

Stop the non-OpenSSL runners from masking a real failure as SKIP by
only downgrading to SKIP if they passed.

Fix a stray call that ran test_kex_dhe_wrong_algo in the skip branch.

Fix double free + free of an uninitialised pointer in test_store_add.

Test that a KDF- less derive must fail.

Signed-off-by: Dimitri Staessens <dimitri@ouroboros.rocks>
Signed-off-by: Sander Vrijders <sander@ouroboros.rocks>

3 files changed, 103 insertions, 5 deletions

diff --git a/src/lib/tests/auth_test.c b/src/lib/tests/auth_test.c
index af7cf81c..61f97683 100644
--- a/src/lib/tests/auth_test.c
+++ b/src/lib/tests/auth_test.c
@@ -304,7 +304,7 @@ static int test_store_add(void)
  fail_add:
         crypt_free_crt(_root_ca_crt);
  fail_load:
-        crypt_free_crt(_root_ca_crt);
+        auth_destroy_ctx(ctx);
  fail_create:
         TEST_FAIL();
         return TEST_RC_FAIL;
@@ -737,7 +737,8 @@ int auth_test(int     argc,
         (void) test_auth_bad_signature;
         (void) test_crt_str;
 
-        ret = TEST_RC_SKIP;
+        if (ret == 0)
+                ret = TEST_RC_SKIP;
 #endif
         return ret;
 }
diff --git a/src/lib/tests/crypt_test.c b/src/lib/tests/crypt_test.c
index 2d752238..f00618d8 100644
--- a/src/lib/tests/crypt_test.c
+++ b/src/lib/tests/crypt_test.c
@@ -528,6 +528,47 @@ static int test_crypt_headsz(void)
         return TEST_RC_FAIL;
 }
 
+static int test_crypt_ct_cmp(void)
+{
+        uint8_t a[64];
+        uint8_t b[64];
+        size_t  i;
+
+        TEST_START();
+
+        for (i = 0; i < sizeof(a); i++)
+                a[i] = (uint8_t) i;
+
+        memcpy(b, a, sizeof(a));
+
+        if (crypt_ct_cmp(a, b, sizeof(a)) != 0) {
+                printf("Equal buffers should compare equal.\n");
+                goto fail;
+        }
+
+        if (crypt_ct_cmp(a, b, 0) != 0) {
+                printf("Zero length should compare equal.\n");
+                goto fail;
+        }
+
+        for (i = 0; i < sizeof(a); i++) {
+                b[i] ^= 0x01;
+                if (crypt_ct_cmp(a, b, sizeof(a)) == 0) {
+                        printf("Difference at byte %zu not detected.\n", i);
+                        goto fail;
+                }
+
+                b[i] ^= 0x01;
+        }
+
+        TEST_SUCCESS();
+
+        return TEST_RC_SUCCESS;
+ fail:
+        TEST_FAIL();
+        return TEST_RC_FAIL;
+}
+
 int crypt_test(int     argc,
                char ** argv)
 {
@@ -538,6 +579,7 @@ int crypt_test(int     argc,
 
         ret |= test_crypt_create_destroy();
         ret |= test_encrypt_decrypt_all();
+        ret |= test_crypt_ct_cmp();
 #ifdef HAVE_OPENSSL
         ret |= test_cipher_nid_values();
         ret |= test_md_nid_values();
@@ -549,7 +591,8 @@ int crypt_test(int     argc,
         (void) test_aad_tamper_all;
         (void) test_crypt_headsz;
 
-        return TEST_RC_SKIP;
+        if (ret == 0)
+                ret = TEST_RC_SKIP;
 #endif
         return ret;
 }
diff --git a/src/lib/tests/kex_test.c b/src/lib/tests/kex_test.c
index 61383be0..5b2ccfc2 100644
--- a/src/lib/tests/kex_test.c
+++ b/src/lib/tests/kex_test.c
@@ -443,6 +443,57 @@ static int test_kex_dhe_wrong_algo(void)
         return TEST_RC_FAIL;
 }
 
+static int test_kex_dhe_no_kdf(void)
+{
+        struct sec_config kex;
+        void *            pkp1;
+        void *            pkp2;
+        buffer_t          pk2;
+        ssize_t           len;
+        uint8_t           buf1[CRYPT_KEY_BUFSZ];
+        uint8_t           buf2[CRYPT_KEY_BUFSZ];
+        uint8_t           s[SYMMKEYSZ];
+
+        TEST_START();
+
+        memset(&kex, 0, sizeof(kex));
+        SET_KEX_ALGO(&kex, "X25519");
+
+        if (kex_pkp_create(&kex, &pkp1, buf1) < 0) {
+                printf("Failed to create first key pair.\n");
+                goto fail;
+        }
+
+        len = kex_pkp_create(&kex, &pkp2, buf2);
+        if (len < 0) {
+                printf("Failed to create second key pair.\n");
+                goto fail_pkp1;
+        }
+
+        pk2.len  = (size_t) len;
+        pk2.data = buf2;
+
+        /* No KDF configured: derive must fail, not fall back. */
+        if (kex_dhe_derive(&kex, pkp1, pk2, s) == 0) {
+                printf("Derive succeeded without a KDF.\n");
+                goto fail_pkp2;
+        }
+
+        kex_pkp_destroy(pkp2);
+        kex_pkp_destroy(pkp1);
+
+        TEST_SUCCESS();
+
+        return TEST_RC_SUCCESS;
+ fail_pkp2:
+        kex_pkp_destroy(pkp2);
+ fail_pkp1:
+        kex_pkp_destroy(pkp1);
+ fail:
+        TEST_FAIL();
+        return TEST_RC_FAIL;
+}
+
 static int test_kex_load_dhe_privkey(void)
 {
         void * key;
@@ -1171,6 +1222,7 @@ int kex_test(int     argc,
         ret |= test_kex_validate_algo();
         ret |= test_kex_get_algo_from_pk_all();
         ret |= test_kex_dhe_wrong_algo();
+        ret |= test_kex_dhe_no_kdf();
         ret |= test_kex_dhe_corrupted_pubkey_all();
         ret |= test_kex_load_dhe_privkey();
         ret |= test_kex_load_dhe_pubkey();
@@ -1183,12 +1235,14 @@ int kex_test(int     argc,
         (void) test_kex_all;
         (void) test_kex_validate_algo;
         (void) test_kex_get_algo_from_pk_all;
-        (void) test_kex_dhe_wrong_algo();
+        (void) test_kex_dhe_wrong_algo;
+        (void) test_kex_dhe_no_kdf;
         (void) test_kex_dhe_corrupted_pubkey_all;
         (void) test_kex_load_dhe_privkey;
         (void) test_kex_load_dhe_pubkey;
 
-        ret = TEST_RC_SKIP;
+        if (ret == 0)
+                ret = TEST_RC_SKIP;
 #endif
         return ret;
 }