diff --git a/test/evp_fetch_prov_test.c b/test/evp_fetch_prov_test.c index a644390917..9cb4c4d4c7 100644 --- a/test/evp_fetch_prov_test.c +++ b/test/evp_fetch_prov_test.c @@ -18,6 +18,7 @@ #include #include #include +#include "internal/sizes.h" #include "testutil.h" static char *config_file = NULL; @@ -105,15 +106,39 @@ err: return ret; } +static void unload_providers(OSSL_LIB_CTX **libctx, OSSL_PROVIDER *prov[]) +{ + if (prov[0] != NULL) + OSSL_PROVIDER_unload(prov[0]); + if (prov[1] != NULL) + OSSL_PROVIDER_unload(prov[1]); + /* Not normally needed, but we would like to test that + * OPENSSL_thread_stop_ex() behaves as expected. + */ + if (libctx != NULL && *libctx != NULL) { + OPENSSL_thread_stop_ex(*libctx); + OSSL_LIB_CTX_free(*libctx); + } +} + +static X509_ALGOR *make_algor(int nid) +{ + X509_ALGOR *algor; + + if (!TEST_ptr(algor = X509_ALGOR_new()) + || !TEST_true(X509_ALGOR_set0(algor, OBJ_nid2obj(nid), + V_ASN1_UNDEF, NULL))) { + X509_ALGOR_free(algor); + return NULL; + } + return algor; +} + /* * Test EVP_MD_fetch() */ -static int test_EVP_MD_fetch(void) +static int test_md(const EVP_MD *md) { - OSSL_LIB_CTX *ctx = NULL; - EVP_MD *md = NULL; - OSSL_PROVIDER *prov[2] = {NULL, NULL}; - int ret = 0; const char testmsg[] = "Hello world"; const unsigned char exptd[] = { 0x27, 0x51, 0x8b, 0xa9, 0x68, 0x30, 0x11, 0xf6, 0xb3, 0x96, 0x07, 0x2c, @@ -121,25 +146,40 @@ static int test_EVP_MD_fetch(void) 0x90, 0xec, 0x60, 0x6e, 0x50, 0x92, 0xe3, 0x26 }; + return TEST_ptr(md) + && TEST_true(EVP_MD_is_a(md, "SHA256")) + && TEST_true(calculate_digest(md, testmsg, sizeof(testmsg), exptd)) + && TEST_int_eq(EVP_MD_size(md), SHA256_DIGEST_LENGTH) + && TEST_int_eq(EVP_MD_block_size(md), SHA256_CBLOCK); +} + +static int test_implicit_EVP_MD_fetch(void) +{ + OSSL_LIB_CTX *ctx = NULL; + OSSL_PROVIDER *prov[2] = {NULL, NULL}; + int ret = 0; + + ret = (use_default_ctx == 0 || load_providers(&ctx, prov)) + && test_md(EVP_sha256()); + + unload_providers(&ctx, prov); + return ret; +} + +static int test_explicit_EVP_MD_fetch(const char *id) +{ + OSSL_LIB_CTX *ctx = NULL; + EVP_MD *md = NULL; + OSSL_PROVIDER *prov[2] = {NULL, NULL}; + int ret = 0; + if (use_default_ctx == 0 && !load_providers(&ctx, prov)) goto err; - /* Implicit fetching of the MD should produce the expected result */ - if (!TEST_true(calculate_digest(EVP_sha256(), testmsg, sizeof(testmsg), - exptd)) - || !TEST_int_eq(EVP_MD_size(EVP_sha256()), SHA256_DIGEST_LENGTH) - || !TEST_int_eq(EVP_MD_block_size(EVP_sha256()), SHA256_CBLOCK)) - goto err; - - /* Fetch the digest from a provider using properties. */ - md = EVP_MD_fetch(ctx, "SHA256", fetch_property); + md = EVP_MD_fetch(ctx, id, fetch_property); if (expected_fetch_result != 0) { - if (!TEST_ptr(md) - || !TEST_int_eq(EVP_MD_nid(md), NID_sha256) - || !TEST_true(calculate_digest(md, testmsg, sizeof(testmsg), exptd)) - || !TEST_int_eq(EVP_MD_size(md), SHA256_DIGEST_LENGTH) - || !TEST_int_eq(EVP_MD_block_size(md), SHA256_CBLOCK)) - goto err; + if (!test_md(md)) + goto err; /* Also test EVP_MD_up_ref() while we're doing this */ if (!TEST_true(EVP_MD_up_ref(md))) @@ -152,20 +192,52 @@ static int test_EVP_MD_fetch(void) } ret = 1; -err: + err: EVP_MD_free(md); - OSSL_PROVIDER_unload(prov[0]); - OSSL_PROVIDER_unload(prov[1]); - /* Not normally needed, but we would like to test that - * OPENSSL_thread_stop_ex() behaves as expected. - */ - if (ctx != NULL) { - OPENSSL_thread_stop_ex(ctx); - OSSL_LIB_CTX_free(ctx); - } + unload_providers(&ctx, prov); return ret; } +static int test_explicit_EVP_MD_fetch_by_name(void) +{ + return test_explicit_EVP_MD_fetch("SHA256"); +} + +/* + * idx 0: Allow names from OBJ_obj2txt() + * idx 1: Force an OID in text form from OBJ_obj2txt() + */ +static int test_explicit_EVP_MD_fetch_by_X509_ALGOR(int idx) +{ + int ret = 0; + X509_ALGOR *algor = make_algor(NID_sha256); + const ASN1_OBJECT *obj; + char id[OSSL_MAX_NAME_SIZE]; + + if (algor == NULL) + return 0; + + X509_ALGOR_get0(&obj, NULL, NULL, algor); + switch (idx) { + case 0: + if (!TEST_true(OBJ_obj2txt(id, sizeof(id), obj, 0))) + goto end; + break; + case 1: + if (!TEST_true(OBJ_obj2txt(id, sizeof(id), obj, 1))) + goto end; + break; + } + + ret = test_explicit_EVP_MD_fetch(id); + end: + X509_ALGOR_free(algor); + return ret; +} + +/* + * Test EVP_CIPHER_fetch() + */ static int encrypt_decrypt(const EVP_CIPHER *cipher, const unsigned char *msg, size_t len) { @@ -191,34 +263,46 @@ err: return ret; } -/* - * Test EVP_CIPHER_fetch() - */ -static int test_EVP_CIPHER_fetch(void) +static int test_cipher(const EVP_CIPHER *cipher) +{ + const unsigned char testmsg[] = "Hello world"; + + return TEST_ptr(cipher) + && TEST_true(encrypt_decrypt(cipher, testmsg, sizeof(testmsg))); +} + +static int test_implicit_EVP_CIPHER_fetch(void) +{ + OSSL_LIB_CTX *ctx = NULL; + OSSL_PROVIDER *prov[2] = {NULL, NULL}; + int ret = 0; + + ret = (use_default_ctx == 0 || load_providers(&ctx, prov)) + && test_cipher(EVP_aes_128_cbc()); + + unload_providers(&ctx, prov); + return ret; +} + +static int test_explicit_EVP_CIPHER_fetch(const char *id) { OSSL_LIB_CTX *ctx = NULL; EVP_CIPHER *cipher = NULL; OSSL_PROVIDER *prov[2] = {NULL, NULL}; int ret = 0; - const unsigned char testmsg[] = "Hello world"; if (use_default_ctx == 0 && !load_providers(&ctx, prov)) goto err; - /* Implicit fetching of the cipher should produce the expected result */ - if (!TEST_true(encrypt_decrypt(EVP_aes_128_cbc(), testmsg, sizeof(testmsg)))) - goto err; - - /* Fetch the cipher from a provider using properties. */ - cipher = EVP_CIPHER_fetch(ctx, "AES-128-CBC", fetch_property); + cipher = EVP_CIPHER_fetch(ctx, id, fetch_property); if (expected_fetch_result != 0) { - if (!TEST_ptr(cipher) - || !TEST_true(encrypt_decrypt(cipher, testmsg, sizeof(testmsg)))) { - if (!TEST_true(EVP_CIPHER_up_ref(cipher))) - goto err; - /* Ref count should now be 2. Release first one here */ - EVP_CIPHER_free(cipher); - } + if (!test_cipher(cipher)) + goto err; + + if (!TEST_true(EVP_CIPHER_up_ref(cipher))) + goto err; + /* Ref count should now be 2. Release first one here */ + EVP_CIPHER_free(cipher); } else { if (!TEST_ptr_null(cipher)) goto err; @@ -226,9 +310,44 @@ static int test_EVP_CIPHER_fetch(void) ret = 1; err: EVP_CIPHER_free(cipher); - OSSL_PROVIDER_unload(prov[0]); - OSSL_PROVIDER_unload(prov[1]); - OSSL_LIB_CTX_free(ctx); + unload_providers(&ctx, prov); + return ret; +} + +static int test_explicit_EVP_CIPHER_fetch_by_name(void) +{ + return test_explicit_EVP_CIPHER_fetch("AES-128-CBC"); +} + +/* + * idx 0: Allow names from OBJ_obj2txt() + * idx 1: Force an OID in text form from OBJ_obj2txt() + */ +static int test_explicit_EVP_CIPHER_fetch_by_X509_ALGOR(int idx) +{ + int ret = 0; + X509_ALGOR *algor = make_algor(NID_aes_128_cbc); + const ASN1_OBJECT *obj; + char id[OSSL_MAX_NAME_SIZE]; + + if (algor == NULL) + return 0; + + X509_ALGOR_get0(&obj, NULL, NULL, algor); + switch (idx) { + case 0: + if (!TEST_true(OBJ_obj2txt(id, sizeof(id), obj, 0))) + goto end; + break; + case 1: + if (!TEST_true(OBJ_obj2txt(id, sizeof(id), obj, 1))) + goto end; + break; + } + + ret = test_explicit_EVP_CIPHER_fetch(id); + end: + X509_ALGOR_free(algor); return ret; } @@ -260,9 +379,14 @@ int setup_tests(void) return 0; } } - if (strcmp(alg, "digest") == 0) - ADD_TEST(test_EVP_MD_fetch); - else - ADD_TEST(test_EVP_CIPHER_fetch); + if (strcmp(alg, "digest") == 0) { + ADD_TEST(test_implicit_EVP_MD_fetch); + ADD_TEST(test_explicit_EVP_MD_fetch_by_name); + ADD_ALL_TESTS_NOSUBTEST(test_explicit_EVP_MD_fetch_by_X509_ALGOR, 2); + } else { + ADD_TEST(test_implicit_EVP_CIPHER_fetch); + ADD_TEST(test_explicit_EVP_CIPHER_fetch_by_name); + ADD_ALL_TESTS_NOSUBTEST(test_explicit_EVP_CIPHER_fetch_by_X509_ALGOR, 2); + } return 1; }