X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=test%2Fevp_extra_test.c;h=d7f63f0247f5cb9e711a32cf699fb75ab5350566;hp=eac0c43ba10db3a504c7ef0bf8ca0745187336a5;hb=9a071fef00a6d58cfbce4dab4848eda12f1c7dcf;hpb=5dc40a83c74be579575a512b30d9c1e0364e6a7b diff --git a/test/evp_extra_test.c b/test/evp_extra_test.c index eac0c43ba1..d7f63f0247 100644 --- a/test/evp_extra_test.c +++ b/test/evp_extra_test.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -18,9 +19,12 @@ #include #include #include +#include +#include +#include #include "testutil.h" #include "internal/nelem.h" -#include "internal/evp_int.h" +#include "crypto/evp.h" /* * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you @@ -300,7 +304,7 @@ static const unsigned char kExampleECPubKeyDER[] = { }; /* - * kExampleBadECKeyDER is a sample EC public key with a wrong OID + * kExampleBadECPubKeyDER is a sample EC public key with a wrong OID * 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key */ static const unsigned char kExampleBadECPubKeyDER[] = { @@ -509,6 +513,66 @@ static int test_d2i_AutoPrivateKey(int i) } #ifndef OPENSSL_NO_EC + +static const unsigned char ec_public_sect163k1_validxy[] = { + 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, + 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04, + 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69, + 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b, + 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3, + 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f +}; + +static const unsigned char ec_public_sect163k1_badx[] = { + 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, + 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04, + 0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69, + 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b, + 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3, + 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f +}; + +static const unsigned char ec_public_sect163k1_bady[] = { + 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, + 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04, + 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69, + 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b, + 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3, + 0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6 +}; + +static struct ec_der_pub_keys_st { + const unsigned char *der; + size_t len; + int valid; +} ec_der_pub_keys[] = { + { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 }, + { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 }, + { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 }, +}; + +/* + * Tests the range of the decoded EC char2 public point. + * See ec_GF2m_simple_oct2point(). + */ +static int test_invalide_ec_char2_pub_range_decode(int id) +{ + int ret = 0; + BIO *bio = NULL; + EC_KEY *eckey = NULL; + + if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der, + ec_der_pub_keys[id].len))) + goto err; + eckey = d2i_EC_PUBKEY_bio(bio, NULL); + ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey)) + || TEST_ptr_null(eckey); +err: + EC_KEY_free(eckey); + BIO_free(bio); + return ret; +} + /* Tests loading a bad key in PKCS8 format */ static int test_EVP_PKCS82PKEY(void) { @@ -538,7 +602,7 @@ static int test_EVP_PKCS82PKEY(void) } #endif -#ifndef OPENSSL_NO_SM2 +#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODE) static int test_EVP_SM2_verify(void) { @@ -1007,6 +1071,151 @@ done: X509_PUBKEY_free(xp); return ret; } +#endif /* OPENSSL_NO_EC */ + +#ifndef OPENSSL_NO_DSA +/* Test getting and setting parameters on an EVP_PKEY_CTX */ +static int test_EVP_PKEY_CTX_get_set_params(void) +{ + EVP_MD_CTX *mdctx = NULL; + EVP_PKEY_CTX *ctx = NULL; + EVP_SIGNATURE *dsaimpl = NULL; + const OSSL_PARAM *params; + OSSL_PARAM ourparams[2], *param = ourparams; + DSA *dsa = NULL; + BIGNUM *p = NULL, *q = NULL, *g = NULL; + EVP_PKEY *pkey = NULL; + int ret = 0; + const EVP_MD *md; + size_t mdsize = SHA512_DIGEST_LENGTH; + char ssl3ms[48]; + + /* + * Setup the parameters for our DSA object. For our purposes they don't have + * to actually be *valid* parameters. We just need to set something. We + * don't even need a pub_key/priv_key. + */ + dsa = DSA_new(); + p = BN_new(); + q = BN_new(); + g = BN_new(); + if (!TEST_ptr(dsa) + || !TEST_ptr(p) + || !TEST_ptr(q) + || !TEST_ptr(g) + || !DSA_set0_pqg(dsa, p, q, g)) + goto err; + p = q = g = NULL; + + pkey = EVP_PKEY_new(); + if (!TEST_ptr(pkey) + || !TEST_true(EVP_PKEY_assign_DSA(pkey, dsa))) + goto err; + + dsa = NULL; + + /* Initialise a sign operation */ + ctx = EVP_PKEY_CTX_new(pkey, NULL); + dsaimpl = EVP_SIGNATURE_fetch(NULL, "DSA", NULL); + if (!TEST_ptr(ctx) + || !TEST_ptr(dsaimpl) + || !TEST_int_gt(EVP_PKEY_sign_init_ex(ctx, dsaimpl), 0)) + goto err; + + /* + * We should be able to query the parameters now. The default DSA + * implementation supports exactly one parameter - so we expect to see that + * returned and no more. + */ + params = EVP_PKEY_CTX_settable_params(ctx); + if (!TEST_ptr(params) + || !TEST_int_eq(strcmp(params[0].key, + OSSL_SIGNATURE_PARAM_DIGEST_SIZE), 0) + || !TEST_int_eq(strcmp(params[1].key, OSSL_SIGNATURE_PARAM_DIGEST), + 0) + /* The final key should be NULL */ + || !TEST_ptr_null(params[2].key)) + goto err; + + /* Gettable params are the same as the settable ones */ + params = EVP_PKEY_CTX_gettable_params(ctx); + if (!TEST_ptr(params) + || !TEST_int_eq(strcmp(params[0].key, + OSSL_SIGNATURE_PARAM_DIGEST_SIZE), 0) + || !TEST_int_eq(strcmp(params[1].key, OSSL_SIGNATURE_PARAM_DIGEST), + 0) + /* The final key should be NULL */ + || !TEST_ptr_null(params[2].key)) + goto err; + + /* + * Test getting and setting params via EVP_PKEY_CTX_set_params() and + * EVP_PKEY_CTX_get_params() + */ + *param++ = OSSL_PARAM_construct_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, + &mdsize); + *param++ = OSSL_PARAM_construct_end(); + + if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams))) + goto err; + + mdsize = 0; + if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams)) + || !TEST_size_t_eq(mdsize, SHA512_DIGEST_LENGTH)) + goto err; + + /* + * Test the TEST_PKEY_CTX_set_signature_md() and + * TEST_PKEY_CTX_get_signature_md() functions + */ + if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0) + || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0) + || !TEST_ptr_eq(md, EVP_sha256())) + goto err; + + /* + * Test getting MD parameters via an associated EVP_PKEY_CTX + */ + mdctx = EVP_MD_CTX_new(); + if (!TEST_ptr(mdctx) + || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, + pkey, dsaimpl))) + goto err; + + /* + * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be + * able to obtain the digest's settable parameters from the provider. + */ + params = EVP_MD_CTX_settable_params(mdctx); + if (!TEST_ptr(params) + || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0) + /* The final key should be NULL */ + || !TEST_ptr_null(params[1].key)) + goto err; + + param = ourparams; + memset(ssl3ms, 0, sizeof(ssl3ms)); + *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS, + ssl3ms, sizeof(ssl3ms)); + *param++ = OSSL_PARAM_construct_end(); + + if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams))) + goto err; + + ret = 1; + + err: + EVP_MD_CTX_free(mdctx); + EVP_PKEY_CTX_free(ctx); + EVP_SIGNATURE_free(dsaimpl); + EVP_PKEY_free(pkey); + DSA_free(dsa); + BN_free(p); + BN_free(q); + BN_free(g); + + return ret; +} #endif int setup_tests(void) @@ -1018,7 +1227,7 @@ int setup_tests(void) #ifndef OPENSSL_NO_EC ADD_TEST(test_EVP_PKCS82PKEY); #endif -#ifndef OPENSSL_NO_SM2 +#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODE) ADD_TEST(test_EVP_SM2); ADD_TEST(test_EVP_SM2_verify); #endif @@ -1035,6 +1244,11 @@ int setup_tests(void) ADD_TEST(test_HKDF); #ifndef OPENSSL_NO_EC ADD_TEST(test_X509_PUBKEY_inplace); + ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode, + OSSL_NELEM(ec_der_pub_keys)); +#endif +#ifndef OPENSSL_NO_DSA + ADD_TEST(test_EVP_PKEY_CTX_get_set_params); #endif return 1; }