diff options
Diffstat (limited to 'test/acvp_test.c')
| -rw-r--r-- | test/acvp_test.c | 389 |
1 files changed, 329 insertions, 60 deletions
diff --git a/test/acvp_test.c b/test/acvp_test.c index eccf9d90a021..2bcc886fd290 100644 --- a/test/acvp_test.c +++ b/test/acvp_test.c @@ -1,5 +1,5 @@ /* - * Copyright 2020-2022 The OpenSSL Project Authors. All Rights Reserved. + * Copyright 2020-2024 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy @@ -46,6 +46,14 @@ static OSSL_PROVIDER *prov_null = NULL; static OSSL_LIB_CTX *libctx = NULL; static SELF_TEST_ARGS self_test_args = { 0 }; static OSSL_CALLBACK self_test_events; +static int pass_sig_gen_params = 1; +static int rsa_sign_x931_pad_allowed = 1; +#ifndef OPENSSL_NO_DSA +static int dsasign_allowed = 1; +#endif +#ifndef OPENSSL_NO_EC +static int ec_cofactors = 1; +#endif const OPTIONS *test_get_options(void) { @@ -93,12 +101,13 @@ static int sig_gen(EVP_PKEY *pkey, OSSL_PARAM *params, const char *digest_name, unsigned char *sig = NULL; size_t sig_len; size_t sz = EVP_PKEY_get_size(pkey); + OSSL_PARAM *p = pass_sig_gen_params ? params : NULL; sig_len = sz; if (!TEST_ptr(sig = OPENSSL_malloc(sz)) || !TEST_ptr(md_ctx = EVP_MD_CTX_new()) || !TEST_int_eq(EVP_DigestSignInit_ex(md_ctx, NULL, digest_name, libctx, - NULL, pkey, NULL), 1) + NULL, pkey, p), 1) || !TEST_int_gt(EVP_DigestSign(md_ctx, sig, &sig_len, msg, msg_len), 0)) goto err; *sig_out = sig; @@ -111,6 +120,25 @@ err: return ret; } +static int check_verify_message(EVP_PKEY_CTX *pkey_ctx, int expected) +{ + OSSL_PARAM params[2], *p = params; + int verify_message = -1; + + if (!OSSL_PROVIDER_available(libctx, "fips") + || fips_provider_version_match(libctx, "<3.4.0")) + return 1; + + *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE, + &verify_message); + *p = OSSL_PARAM_construct_end(); + + if (!TEST_true(EVP_PKEY_CTX_get_params(pkey_ctx, params)) + || !TEST_int_eq(verify_message, expected)) + return 0; + return 1; +} + #ifndef OPENSSL_NO_EC static int ecdsa_keygen_test(int id) { @@ -276,6 +304,7 @@ static int ecdsa_sigver_test(int id) int ret = 0; EVP_MD_CTX *md_ctx = NULL; EVP_PKEY *pkey = NULL; + EVP_PKEY_CTX *pkey_ctx; ECDSA_SIG *sign = NULL; size_t sig_len; unsigned char *sig = NULL; @@ -293,12 +322,20 @@ static int ecdsa_sigver_test(int id) goto err; rbn = sbn = NULL; - ret = TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0) - && TEST_ptr(md_ctx = EVP_MD_CTX_new()) - && TEST_true(EVP_DigestVerifyInit_ex(md_ctx, NULL, tst->digest_alg, - libctx, NULL, pkey, NULL) - && TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len, - tst->msg, tst->msg_len), tst->pass)); + if (!TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0) + || !TEST_ptr(md_ctx = EVP_MD_CTX_new()) + || !TEST_true(EVP_DigestVerifyInit_ex(md_ctx, NULL, tst->digest_alg, + libctx, NULL, pkey, NULL)) + || !TEST_ptr(pkey_ctx = EVP_MD_CTX_get_pkey_ctx(md_ctx)) + || !check_verify_message(pkey_ctx, 1) + || !TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len, + tst->msg, tst->msg_len), tst->pass) + || !check_verify_message(pkey_ctx, 1) + || !TEST_true(EVP_PKEY_verify_init(pkey_ctx)) + || !check_verify_message(pkey_ctx, 0)) + goto err; + + ret = 1; err: BN_free(rbn); BN_free(sbn); @@ -309,9 +346,71 @@ err: return ret; } + +static int ecdh_cofactor_derive_test(int tstid) +{ + int ret = 0; + const struct ecdh_cofactor_derive_st *t = &ecdh_cofactor_derive_data[tstid]; + unsigned char secret1[16]; + size_t secret1_len = sizeof(secret1); + const char *curve = "K-283"; /* A curve that has a cofactor that it not 1 */ + EVP_PKEY *peer1 = NULL, *peer2 = NULL; + EVP_PKEY_CTX *p1ctx = NULL; + OSSL_PARAM params[2], *prms = NULL; + int use_cofactordh = t->key_cofactor; + int cofactor_mode = t->derive_cofactor_mode; + + if (!ec_cofactors) + return TEST_skip("not supported by FIPS provider version"); + + if (!TEST_ptr(peer1 = EVP_PKEY_Q_keygen(libctx, NULL, "EC", curve))) + return TEST_skip("Curve %s not supported by the FIPS provider", curve); + + if (!TEST_ptr(peer2 = EVP_PKEY_Q_keygen(libctx, NULL, "EC", curve))) + goto err; + + params[1] = OSSL_PARAM_construct_end(); + + prms = NULL; + if (t->key_cofactor != COFACTOR_NOT_SET) { + params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_USE_COFACTOR_ECDH, + &use_cofactordh); + prms = params; + } + if (!TEST_int_eq(EVP_PKEY_set_params(peer1, prms), 1) + || !TEST_ptr(p1ctx = EVP_PKEY_CTX_new_from_pkey(libctx, peer1, NULL))) + goto err; + + prms = NULL; + if (t->derive_cofactor_mode != COFACTOR_NOT_SET) { + params[0] = OSSL_PARAM_construct_int(OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE, + &cofactor_mode); + prms = params; + } + if (!TEST_int_eq(EVP_PKEY_derive_init_ex(p1ctx, prms), 1) + || !TEST_int_eq(EVP_PKEY_derive_set_peer(p1ctx, peer2), 1) + || !TEST_int_eq(EVP_PKEY_derive(p1ctx, secret1, &secret1_len), + t->expected)) + goto err; + + ret = 1; +err: + if (ret == 0) { + static const char *state[] = { "unset", "-1", "disabled", "enabled" }; + + TEST_note("ECDH derive() was expected to %s if key cofactor is" + "%s and derive mode is %s", t->expected ? "Pass" : "Fail", + state[2 + t->key_cofactor], state[2 + t->derive_cofactor_mode]); + } + EVP_PKEY_free(peer1); + EVP_PKEY_free(peer2); + EVP_PKEY_CTX_free(p1ctx); + return ret; +} + #endif /* OPENSSL_NO_EC */ -#ifndef OPENSSL_NO_DSA +#if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECX) static int pkey_get_octet_bytes(EVP_PKEY *pkey, const char *name, unsigned char **out, size_t *out_len) { @@ -333,6 +432,91 @@ err: OPENSSL_free(buf); return 0; } +#endif /* !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECX) */ + +#ifndef OPENSSL_NO_ECX +static int eddsa_create_pkey(EVP_PKEY **pkey, const char *algname, + const unsigned char *pub, size_t pub_len, + int expected) +{ + int ret = 0; + EVP_PKEY_CTX *ctx = NULL; + OSSL_PARAM_BLD *bld = NULL; + OSSL_PARAM *params = NULL; + + if (!TEST_ptr(bld = OSSL_PARAM_BLD_new()) + || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld, + OSSL_PKEY_PARAM_PUB_KEY, + pub, pub_len) > 0) + || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)) + || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, algname, NULL)) + || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1) + || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, EVP_PKEY_PUBLIC_KEY, + params), expected)) + goto err; + + ret = 1; +err: + OSSL_PARAM_free(params); + OSSL_PARAM_BLD_free(bld); + EVP_PKEY_CTX_free(ctx); + return ret; +} + +static int eddsa_pub_verify_test(int id) +{ + const struct ecdsa_pub_verify_st *tst = &eddsa_pv_data[id]; + int ret = 0; + EVP_PKEY_CTX *key_ctx = NULL; + EVP_PKEY *pkey = NULL; + + if (!TEST_true(eddsa_create_pkey(&pkey, tst->curve_name, + tst->pub, tst->pub_len, 1))) + goto err; + + if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, "")) + || !TEST_int_eq(EVP_PKEY_public_check(key_ctx), tst->pass)) + goto err; + ret = 1; +err: + EVP_PKEY_free(pkey); + EVP_PKEY_CTX_free(key_ctx); + return ret; +} + +static int eddsa_keygen_test(int id) +{ + int ret = 0; + EVP_PKEY *pkey = NULL; + unsigned char *priv = NULL, *pub = NULL; + size_t priv_len = 0, pub_len = 0; + const struct ecdsa_pub_verify_st *tst = &eddsa_pv_data[id]; + + self_test_args.called = 0; + self_test_args.enable = 1; + if (!TEST_ptr(pkey = EVP_PKEY_Q_keygen(libctx, NULL, tst->curve_name)) + || !TEST_int_ge(self_test_args.called, 3) + || !TEST_true(pkey_get_octet_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY, + &priv, &priv_len)) + || !TEST_true(pkey_get_octet_bytes(pkey, OSSL_PKEY_PARAM_PUB_KEY, &pub, + &pub_len))) + goto err; + + test_output_memory("q", pub, pub_len); + test_output_memory("d", priv, priv_len); + ret = 1; +err: + self_test_args.enable = 0; + self_test_args.called = 0; + OPENSSL_clear_free(priv, priv_len); + OPENSSL_free(pub); + EVP_PKEY_free(pkey); + return ret; +} + +#endif /* OPENSSL_NO_ECX */ + +#ifndef OPENSSL_NO_DSA static EVP_PKEY *dsa_paramgen(int L, int N) { @@ -344,7 +528,7 @@ static EVP_PKEY *dsa_paramgen(int L, int N) || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, L)) || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, N)) || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key))) - return NULL; + TEST_info("dsa_paramgen failed"); EVP_PKEY_CTX_free(paramgen_ctx); return param_key; } @@ -375,6 +559,8 @@ static int dsa_keygen_test(int id) size_t priv_len = 0, pub_len = 0; const struct dsa_paramgen_st *tst = &dsa_keygen_data[id]; + if (!dsasign_allowed) + return TEST_skip("DSA signing is not allowed"); if (!TEST_ptr(param_key = dsa_paramgen(tst->L, tst->N)) || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key, NULL)) @@ -418,23 +604,31 @@ static int dsa_paramgen_test(int id) if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL)) || !TEST_int_gt(EVP_PKEY_paramgen_init(paramgen_ctx), 0) || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, tst->L)) - || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, tst->N)) - || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key)) - || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P, - &p, &plen)) - || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q, - &q, &qlen)) - || !TEST_true(pkey_get_octet_bytes(param_key, OSSL_PKEY_PARAM_FFC_SEED, - &seed, &seedlen)) - || !TEST_true(EVP_PKEY_get_int_param(param_key, - OSSL_PKEY_PARAM_FFC_PCOUNTER, - &counter))) - goto err; - - test_output_memory("p", p, plen); - test_output_memory("q", q, qlen); - test_output_memory("domainSeed", seed, seedlen); - test_printf_stderr("%s: %d\n", "counter", counter); + || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, + tst->N))) + goto err; + + if (!dsasign_allowed) { + if (!TEST_false(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key))) + goto err; + } else { + if (!TEST_true(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key)) + || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P, + &p, &plen)) + || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q, + &q, &qlen)) + || !TEST_true(pkey_get_octet_bytes(param_key, + OSSL_PKEY_PARAM_FFC_SEED, + &seed, &seedlen)) + || !TEST_true(EVP_PKEY_get_int_param(param_key, + OSSL_PKEY_PARAM_FFC_PCOUNTER, + &counter))) + goto err; + test_output_memory("p", p, plen); + test_output_memory("q", q, qlen); + test_output_memory("domainSeed", seed, seedlen); + test_printf_stderr("%s: %d\n", "counter", counter); + } ret = 1; err: OPENSSL_free(p); @@ -594,15 +788,19 @@ static int dsa_siggen_test(int id) size_t sig_len = 0, rlen = 0, slen = 0; const struct dsa_siggen_st *tst = &dsa_siggen_data[id]; - if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N))) - goto err; - - if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len, - &sig, &sig_len)) - || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen))) - goto err; - test_output_memory("r", r, rlen); - test_output_memory("s", s, slen); + if (!dsasign_allowed) { + if (!TEST_ptr_null(pkey = dsa_keygen(tst->L, tst->N))) + goto err; + } else { + if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N))) + goto err; + if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len, + &sig, &sig_len)) + || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen))) + goto err; + test_output_memory("r", r, rlen); + test_output_memory("s", s, slen); + } ret = 1; err: OPENSSL_free(r); @@ -807,13 +1005,14 @@ static int aes_gcm_enc_dec(const char *alg, const unsigned char *aad, size_t aad_len, const unsigned char *ct, size_t ct_len, const unsigned char *tag, size_t tag_len, - int enc, int pass) + int enc, int pass, + unsigned char *out, int *out_len, + unsigned char *outiv) { int ret = 0; EVP_CIPHER_CTX *ctx; EVP_CIPHER *cipher = NULL; - int out_len, len; - unsigned char out[1024]; + int olen, len; TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt", pass ? "pass" : "fail"); @@ -831,9 +1030,9 @@ static int aes_gcm_enc_dec(const char *alg, goto err; } /* - * For testing purposes the IV it being set here. In a compliant application - * the IV would be generated internally. A fake entropy source could also - * be used to feed in the random IV bytes (see fake_random.c) + * For testing purposes the IV may be passed in here. In a compliant + * application the IV would be generated internally. A fake entropy source + * could also be used to feed in the random IV bytes (see fake_random.c) */ if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc)) || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0)) @@ -841,23 +1040,46 @@ static int aes_gcm_enc_dec(const char *alg, || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len))) goto err; - if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &out_len), pass)) + if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &olen), pass)) goto err; if (!pass) { ret = 1; goto err; } - out_len += len; + olen += len; if (enc) { - if (!TEST_mem_eq(out, out_len, ct, ct_len) - || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, - tag_len, out + out_len), 0) - || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len)) - goto err; + if ((ct != NULL && !TEST_mem_eq(out, olen, ct, ct_len)) + || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, + tag_len, out + olen), 0) + || (tag != NULL + && !TEST_mem_eq(out + olen, tag_len, tag, tag_len))) + goto err; } else { - if (!TEST_mem_eq(out, out_len, ct, ct_len)) + if (ct != NULL && !TEST_mem_eq(out, olen, ct, ct_len)) + goto err; + } + + { + OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END }; + OSSL_PARAM *p = params; + unsigned int iv_generated = -1; + const OSSL_PARAM *gettables = EVP_CIPHER_CTX_gettable_params(ctx); + const char *ivgenkey = OSSL_CIPHER_PARAM_AEAD_IV_GENERATED; + int ivgen = (OSSL_PARAM_locate_const(gettables, ivgenkey) != NULL); + + if (ivgen != 0) + *p++ = OSSL_PARAM_construct_uint(ivgenkey, &iv_generated); + if (outiv != NULL) + *p = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_IV, + outiv, iv_len); + if (!TEST_true(EVP_CIPHER_CTX_get_params(ctx, params))) + goto err; + if (ivgen != 0 + && !TEST_uint_eq(iv_generated, (enc == 0 || iv != NULL ? 0 : 1))) goto err; } + if (out_len != NULL) + *out_len = olen; ret = 1; err: @@ -871,23 +1093,45 @@ static int aes_gcm_enc_dec_test(int id) const struct cipher_gcm_st *tst = &aes_gcm_enc_data[id]; int enc = 1; int pass = 1; + unsigned char out[1024]; return aes_gcm_enc_dec(tst->alg, tst->pt, tst->pt_len, tst->key, tst->key_len, tst->iv, tst->iv_len, tst->aad, tst->aad_len, tst->ct, tst->ct_len, tst->tag, tst->tag_len, - enc, pass) + enc, pass, out, NULL, NULL) && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len, tst->key, tst->key_len, tst->iv, tst->iv_len, tst->aad, tst->aad_len, tst->pt, tst->pt_len, tst->tag, tst->tag_len, - !enc, pass) + !enc, pass, out, NULL, NULL) /* Fail if incorrect tag passed to decrypt */ && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len, tst->key, tst->key_len, tst->iv, tst->iv_len, tst->aad, tst->aad_len, tst->pt, tst->pt_len, tst->aad, tst->tag_len, - !enc, !pass); + !enc, !pass, out, NULL, NULL); +} + +static int aes_gcm_gen_iv_internal_test(void) +{ + const struct cipher_gcm_st *tst = &aes_gcm_enc_data[0]; + int enc = 1; + int pass = 1; + int out_len = 0; + unsigned char out[1024]; + unsigned char iv[16]; + + return aes_gcm_enc_dec(tst->alg, tst->pt, tst->pt_len, + tst->key, tst->key_len, + NULL, tst->iv_len, tst->aad, tst->aad_len, + NULL, tst->ct_len, NULL, tst->tag_len, + enc, pass, out, &out_len, iv) + && aes_gcm_enc_dec(tst->alg, out, out_len, + tst->key, tst->key_len, + iv, tst->iv_len, tst->aad, tst->aad_len, + tst->pt, tst->pt_len, out + out_len, tst->tag_len, + !enc, pass, out, NULL, NULL); } #ifndef OPENSSL_NO_DH @@ -1165,6 +1409,10 @@ static int rsa_siggen_test(int id) const struct rsa_siggen_st *tst = &rsa_siggen_data[id]; int salt_len = tst->pss_salt_len; + if (!rsa_sign_x931_pad_allowed + && (strcmp(tst->sig_pad_mode, OSSL_PKEY_RSA_PAD_MODE_X931) == 0)) + return TEST_skip("x931 signing is not allowed"); + TEST_note("RSA %s signature generation", tst->sig_pad_mode); p = params; @@ -1178,11 +1426,11 @@ static int rsa_siggen_test(int id) *p++ = OSSL_PARAM_construct_end(); if (!TEST_ptr(pkey = EVP_PKEY_Q_keygen(libctx, NULL, "RSA", tst->mod)) - || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len)) - || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len)) - || !TEST_true(sig_gen(pkey, params, tst->digest_alg, - tst->msg, tst->msg_len, - &sig, &sig_len))) + || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len)) + || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len)) + || !TEST_true(sig_gen(pkey, params, tst->digest_alg, + tst->msg, tst->msg_len, + &sig, &sig_len))) goto err; test_output_memory("n", n, n_len); test_output_memory("e", e, e_len); @@ -1218,7 +1466,7 @@ static int rsa_sigver_test(int id) if (salt_len >= 0) *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN, &salt_len); - *p++ = OSSL_PARAM_construct_end(); + *p = OSSL_PARAM_construct_end(); if (!TEST_ptr(bn_ctx = BN_CTX_new()) || !TEST_true(rsa_create_pkey(&pkey, tst->n, tst->n_len, @@ -1227,10 +1475,15 @@ static int rsa_sigver_test(int id) || !TEST_true(EVP_DigestVerifyInit_ex(md_ctx, &pkey_ctx, tst->digest_alg, libctx, NULL, pkey, NULL)) + || !check_verify_message(pkey_ctx, 1) || !TEST_true(EVP_PKEY_CTX_set_params(pkey_ctx, params)) || !TEST_int_eq(EVP_DigestVerify(md_ctx, tst->sig, tst->sig_len, - tst->msg, tst->msg_len), tst->pass)) + tst->msg, tst->msg_len), tst->pass) + || !check_verify_message(pkey_ctx, 1) + || !TEST_true(EVP_PKEY_verify_init(pkey_ctx)) + || !check_verify_message(pkey_ctx, 0)) goto err; + ret = 1; err: EVP_PKEY_free(pkey); @@ -1381,6 +1634,8 @@ static int drbg_test(int id) res = 1; err: EVP_RAND_CTX_free(ctx); + /* Coverity is confused by the upref/free in EVP_RAND_CTX_new() subdue it */ + /* coverity[pass_freed_arg] */ EVP_RAND_CTX_free(parent); EVP_RAND_free(rand); return res; @@ -1462,7 +1717,11 @@ int setup_tests(void) ADD_ALL_TESTS(cipher_enc_dec_test, OSSL_NELEM(cipher_enc_data)); ADD_ALL_TESTS(aes_ccm_enc_dec_test, OSSL_NELEM(aes_ccm_enc_data)); ADD_ALL_TESTS(aes_gcm_enc_dec_test, OSSL_NELEM(aes_gcm_enc_data)); + if (fips_provider_version_ge(libctx, 3, 4, 0)) + ADD_TEST(aes_gcm_gen_iv_internal_test); + pass_sig_gen_params = fips_provider_version_ge(libctx, 3, 4, 0); + rsa_sign_x931_pad_allowed = fips_provider_version_lt(libctx, 3, 4, 0); ADD_ALL_TESTS(rsa_keygen_test, OSSL_NELEM(rsa_keygen_data)); ADD_ALL_TESTS(rsa_siggen_test, OSSL_NELEM(rsa_siggen_data)); ADD_ALL_TESTS(rsa_sigver_test, OSSL_NELEM(rsa_sigver_data)); @@ -1477,6 +1736,7 @@ int setup_tests(void) #endif /* OPENSSL_NO_DH */ #ifndef OPENSSL_NO_DSA + dsasign_allowed = fips_provider_version_lt(libctx, 3, 4, 0); ADD_ALL_TESTS(dsa_keygen_test, OSSL_NELEM(dsa_keygen_data)); ADD_ALL_TESTS(dsa_paramgen_test, OSSL_NELEM(dsa_paramgen_data)); ADD_ALL_TESTS(dsa_pqver_test, OSSL_NELEM(dsa_pqver_data)); @@ -1485,12 +1745,21 @@ int setup_tests(void) #endif /* OPENSSL_NO_DSA */ #ifndef OPENSSL_NO_EC + ec_cofactors = fips_provider_version_ge(libctx, 3, 4, 0); ADD_ALL_TESTS(ecdsa_keygen_test, OSSL_NELEM(ecdsa_keygen_data)); ADD_ALL_TESTS(ecdsa_pub_verify_test, OSSL_NELEM(ecdsa_pv_data)); ADD_ALL_TESTS(ecdsa_siggen_test, OSSL_NELEM(ecdsa_siggen_data)); ADD_ALL_TESTS(ecdsa_sigver_test, OSSL_NELEM(ecdsa_sigver_data)); + ADD_ALL_TESTS(ecdh_cofactor_derive_test, + OSSL_NELEM(ecdh_cofactor_derive_data)); #endif /* OPENSSL_NO_EC */ +#ifndef OPENSSL_NO_ECX + if (fips_provider_version_ge(libctx, 3, 4, 0)) { + ADD_ALL_TESTS(eddsa_keygen_test, OSSL_NELEM(eddsa_pv_data)); + ADD_ALL_TESTS(eddsa_pub_verify_test, OSSL_NELEM(eddsa_pv_data)); + } +#endif ADD_ALL_TESTS(drbg_test, OSSL_NELEM(drbg_data)); return 1; } |