2 * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
11 * A set of tests demonstrating uses cases for CAVS/ACVP testing.
13 * For examples of testing KDF's, Digests, KeyAgreement & DRBG's refer to
14 * providers/fips/self_test_kats.c
17 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_EC is defined */
18 #include <openssl/core_names.h>
19 #include <openssl/evp.h>
20 #include <openssl/ec.h>
21 #include <openssl/dh.h>
22 #include <openssl/dsa.h>
23 #include <openssl/rsa.h>
24 #include <openssl/param_build.h>
25 #include <openssl/provider.h>
27 #include "testutil/output.h"
28 #include "acvp_test.inc"
29 #include "internal/nelem.h"
31 static OSSL_PROVIDER *prov_null = NULL;
32 static OPENSSL_CTX *libctx = NULL;
34 typedef enum OPTION_choice {
41 const OPTIONS *test_get_options(void)
43 static const OPTIONS test_options[] = {
44 OPT_TEST_OPTIONS_DEFAULT_USAGE,
45 { "config", OPT_CONFIG_FILE, '<',
46 "The configuration file to use for the libctx" },
52 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DSA) \
53 || !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA)
54 static int pkey_get_bn_bytes(EVP_PKEY *pkey, const char *name,
55 unsigned char **out, size_t *out_len)
57 unsigned char *buf = NULL;
61 if (!EVP_PKEY_get_bn_param(pkey, name, &bn))
63 sz = BN_num_bytes(bn);
64 buf = OPENSSL_zalloc(sz);
67 if (!BN_bn2binpad(bn, buf, sz))
81 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DSA) \
82 || !defined(OPENSSL_NO_RSA)
83 static int sig_gen(EVP_PKEY *pkey, OSSL_PARAM *params, const char *digest_name,
84 const unsigned char *msg, size_t msg_len,
85 unsigned char **sig_out, size_t *sig_out_len)
88 EVP_MD_CTX *md_ctx = NULL;
89 unsigned char *sig = NULL;
91 size_t sz = EVP_PKEY_size(pkey);
93 if (!TEST_ptr(sig = OPENSSL_malloc(sz))
94 || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
95 || !TEST_int_eq(EVP_DigestSignInit_ex(md_ctx, NULL, digest_name, NULL,
97 || !TEST_int_gt(EVP_DigestSign(md_ctx, sig, &sig_len, msg, msg_len), 0))
100 *sig_out_len = sig_len;
105 EVP_MD_CTX_free(md_ctx);
110 #ifndef OPENSSL_NO_EC
111 static int ecdsa_keygen_test(int id)
114 EVP_PKEY_CTX *ctx = NULL;
115 EVP_PKEY *pkey = NULL;
116 unsigned char *priv = NULL;
117 unsigned char *pubx = NULL, *puby = NULL;
118 size_t priv_len = 0, pubx_len = 0, puby_len = 0;
119 const struct ecdsa_keygen_st *tst = &ecdsa_keygen_data[id];
121 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
122 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
123 || !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_name(ctx,
125 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
126 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &priv,
128 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &pubx,
130 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &puby,
134 test_output_memory("qy", puby, puby_len);
135 test_output_memory("qx", pubx, pubx_len);
136 test_output_memory("d", priv, priv_len);
139 OPENSSL_clear_free(priv, priv_len);
143 EVP_PKEY_CTX_free(ctx);
147 static int ecdsa_create_pkey(EVP_PKEY **pkey, const char *curve_name,
148 const unsigned char *pub, size_t pub_len,
152 EVP_PKEY_CTX *ctx = NULL;
153 OSSL_PARAM_BLD *bld = NULL;
154 OSSL_PARAM *params = NULL;
156 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
157 || (curve_name != NULL
158 && !TEST_true(OSSL_PARAM_BLD_push_utf8_string(
159 bld, OSSL_PKEY_PARAM_EC_NAME, curve_name, 0) > 0))
160 || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
161 OSSL_PKEY_PARAM_PUB_KEY,
163 || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
164 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
165 || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
166 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), expected))
171 OSSL_PARAM_BLD_free_params(params);
172 OSSL_PARAM_BLD_free(bld);
173 EVP_PKEY_CTX_free(ctx);
177 static int ecdsa_pub_verify_test(int id)
179 const struct ecdsa_pub_verify_st *tst = &ecdsa_pv_data[id];
182 EVP_PKEY_CTX *key_ctx = NULL;
183 EVP_PKEY *pkey = NULL;
185 if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
186 tst->pub, tst->pub_len, tst->pass)))
190 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
191 || !TEST_int_eq(EVP_PKEY_public_check(key_ctx), tst->pass))
197 EVP_PKEY_CTX_free(key_ctx);
201 /* Extract r and s from a ecdsa signature */
202 static int get_ecdsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
203 unsigned char **r, unsigned char **s,
204 size_t *rlen, size_t *slen)
207 unsigned char *rbuf = NULL, *sbuf = NULL;
208 size_t r1_len, s1_len;
209 const BIGNUM *r1, *s1;
210 ECDSA_SIG *sign = d2i_ECDSA_SIG(NULL, &sig, sig_len);
214 r1 = ECDSA_SIG_get0_r(sign);
215 s1 = ECDSA_SIG_get0_s(sign);
216 if (r1 == NULL || s1 == NULL)
219 r1_len = BN_num_bytes(r1);
220 s1_len = BN_num_bytes(s1);
221 rbuf = OPENSSL_zalloc(r1_len);
222 sbuf = OPENSSL_zalloc(s1_len);
223 if (rbuf == NULL || sbuf == NULL)
225 if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
227 if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
239 ECDSA_SIG_free(sign);
243 static int ecdsa_siggen_test(int id)
246 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
247 EVP_PKEY *pkey = NULL;
248 size_t sig_len = 0, rlen = 0, slen = 0;
249 unsigned char *sig = NULL;
250 unsigned char *r = NULL, *s = NULL;
251 const struct ecdsa_siggen_st *tst = &ecdsa_siggen_data[id];
253 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
254 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
255 || !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_name(ctx,
257 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
260 if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
262 || !TEST_true(get_ecdsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
264 test_output_memory("r", r, rlen);
265 test_output_memory("s", s, slen);
272 EVP_PKEY_CTX_free(key_ctx);
273 EVP_PKEY_CTX_free(ctx);
277 static int ecdsa_sigver_test(int id)
280 EVP_MD_CTX *md_ctx = NULL;
281 EVP_PKEY *pkey = NULL;
282 ECDSA_SIG *sign = NULL;
284 unsigned char *sig = NULL;
285 BIGNUM *rbn = NULL, *sbn = NULL;
286 const struct ecdsa_sigver_st *tst = &ecdsa_sigver_data[id];
288 if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
289 tst->pub, tst->pub_len, 1)))
292 if (!TEST_ptr(sign = ECDSA_SIG_new())
293 || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
294 || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
295 || !TEST_true(ECDSA_SIG_set0(sign, rbn, sbn)))
299 ret = TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0)
300 && TEST_ptr(md_ctx = EVP_MD_CTX_new())
301 && TEST_true(EVP_DigestVerifyInit_ex(md_ctx, NULL, tst->digest_alg,
303 && TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len,
304 tst->msg, tst->msg_len), tst->pass));
309 ECDSA_SIG_free(sign);
311 EVP_MD_CTX_free(md_ctx);
315 #endif /* OPENSSL_NO_EC */
317 #ifndef OPENSSL_NO_DSA
318 static int pkey_get_octet_bytes(EVP_PKEY *pkey, const char *name,
319 unsigned char **out, size_t *out_len)
322 unsigned char *buf = NULL;
324 if (!EVP_PKEY_get_octet_string_param(pkey, name, NULL, 0, &len))
327 buf = OPENSSL_zalloc(len);
331 if (!EVP_PKEY_get_octet_string_param(pkey, name, buf, len, out_len))
340 static EVP_PKEY *dsa_paramgen(int L, int N)
342 EVP_PKEY_CTX *paramgen_ctx = NULL;
343 EVP_PKEY *param_key = NULL;
345 if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
346 || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
347 || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, L))
348 || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, N))
349 || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key)))
351 EVP_PKEY_CTX_free(paramgen_ctx);
355 static EVP_PKEY *dsa_keygen(int L, int N)
357 EVP_PKEY *param_key = NULL, *key = NULL;
358 EVP_PKEY_CTX *keygen_ctx = NULL;
360 if (!TEST_ptr(param_key = dsa_paramgen(L, N))
361 || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
363 || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
364 || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
367 EVP_PKEY_free(param_key);
368 EVP_PKEY_CTX_free(keygen_ctx);
372 static int dsa_keygen_test(int id)
375 EVP_PKEY_CTX *paramgen_ctx = NULL, *keygen_ctx = NULL;
376 EVP_PKEY *param_key = NULL, *key = NULL;
377 unsigned char *priv = NULL, *pub = NULL;
378 size_t priv_len = 0, pub_len = 0;
379 const struct dsa_paramgen_st *tst = &dsa_keygen_data[id];
381 if (!TEST_ptr(param_key = dsa_paramgen(tst->L, tst->N))
382 || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
384 || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0))
386 for (i = 0; i < 2; ++i) {
387 if (!TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0)
388 || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PRIV_KEY,
390 || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PUB_KEY,
393 test_output_memory("y", pub, pub_len);
394 test_output_memory("x", priv, priv_len);
396 OPENSSL_clear_free(priv, priv_len);
403 OPENSSL_clear_free(priv, priv_len);
405 EVP_PKEY_free(param_key);
407 EVP_PKEY_CTX_free(keygen_ctx);
408 EVP_PKEY_CTX_free(paramgen_ctx);
412 static int dsa_paramgen_test(int id)
414 int ret = 0, counter = 0;
415 EVP_PKEY_CTX *paramgen_ctx = NULL;
416 EVP_PKEY *param_key = NULL;
417 unsigned char *p = NULL, *q = NULL, *seed = NULL;
418 size_t plen = 0, qlen = 0, seedlen = 0;
419 const struct dsa_paramgen_st *tst = &dsa_paramgen_data[id];
421 if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
422 || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
423 || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, tst->L))
424 || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, tst->N))
425 || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, ¶m_key))
426 || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P,
428 || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q,
430 || !TEST_true(pkey_get_octet_bytes(param_key, OSSL_PKEY_PARAM_FFC_SEED,
432 || !TEST_true(EVP_PKEY_get_int_param(param_key,
433 OSSL_PKEY_PARAM_FFC_PCOUNTER,
437 test_output_memory("p", p, plen);
438 test_output_memory("q", q, qlen);
439 test_output_memory("domainSeed", seed, seedlen);
440 test_printf_stderr("%s: %d\n", "counter", counter);
446 EVP_PKEY_free(param_key);
447 EVP_PKEY_CTX_free(paramgen_ctx);
451 static int dsa_create_pkey(EVP_PKEY **pkey,
452 const unsigned char *p, size_t p_len,
453 const unsigned char *q, size_t q_len,
454 const unsigned char *g, size_t g_len,
455 const unsigned char *seed, size_t seed_len,
457 const char *validate_type,
458 const unsigned char *pub, size_t pub_len,
462 EVP_PKEY_CTX *ctx = NULL;
463 OSSL_PARAM_BLD *bld = NULL;
464 OSSL_PARAM *params = NULL;
465 BIGNUM *p_bn = NULL, *q_bn = NULL, *g_bn = NULL, *pub_bn = NULL;
467 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
468 || !TEST_ptr(p_bn = BN_CTX_get(bn_ctx))
469 || !TEST_ptr(BN_bin2bn(p, p_len, p_bn))
470 || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
471 OSSL_PKEY_PARAM_FFC_VALIDATE_TYPE,
473 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p_bn))
474 || !TEST_ptr(q_bn = BN_CTX_get(bn_ctx))
475 || !TEST_ptr(BN_bin2bn(q, q_len, q_bn))
476 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q_bn)))
480 if (!TEST_ptr(g_bn = BN_CTX_get(bn_ctx))
481 || !TEST_ptr(BN_bin2bn(g, g_len, g_bn))
482 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
483 OSSL_PKEY_PARAM_FFC_G, g_bn)))
487 if (!TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
488 OSSL_PKEY_PARAM_FFC_SEED, seed, seed_len)))
492 if (!TEST_true(OSSL_PARAM_BLD_push_int(bld,
493 OSSL_PKEY_PARAM_FFC_PCOUNTER,
498 if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
499 || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
500 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
501 OSSL_PKEY_PARAM_PUB_KEY,
505 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
506 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
507 || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
508 || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
513 OSSL_PARAM_BLD_free_params(params);
514 OSSL_PARAM_BLD_free(bld);
515 EVP_PKEY_CTX_free(ctx);
519 static int dsa_pqver_test(int id)
522 BN_CTX *bn_ctx = NULL;
523 EVP_PKEY_CTX *key_ctx = NULL;
524 EVP_PKEY *param_key = NULL;
525 const struct dsa_pqver_st *tst = &dsa_pqver_data[id];
527 if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
528 || !TEST_true(dsa_create_pkey(¶m_key, tst->p, tst->p_len,
529 tst->q, tst->q_len, NULL, 0,
530 tst->seed, tst->seed_len, tst->counter,
531 OSSL_FFC_PARAM_VALIDATE_PQ,
534 || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
536 || !TEST_int_eq(EVP_PKEY_param_check(key_ctx), tst->pass))
542 EVP_PKEY_free(param_key);
543 EVP_PKEY_CTX_free(key_ctx);
547 /* Extract r and s from a dsa signature */
548 static int get_dsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
549 unsigned char **r, unsigned char **s,
550 size_t *r_len, size_t *s_len)
553 unsigned char *rbuf = NULL, *sbuf = NULL;
554 size_t r1_len, s1_len;
555 const BIGNUM *r1, *s1;
556 DSA_SIG *sign = d2i_DSA_SIG(NULL, &sig, sig_len);
560 DSA_SIG_get0(sign, &r1, &s1);
561 if (r1 == NULL || s1 == NULL)
564 r1_len = BN_num_bytes(r1);
565 s1_len = BN_num_bytes(s1);
566 rbuf = OPENSSL_zalloc(r1_len);
567 sbuf = OPENSSL_zalloc(s1_len);
568 if (rbuf == NULL || sbuf == NULL)
570 if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
572 if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
588 static int dsa_siggen_test(int id)
591 EVP_PKEY *pkey = NULL;
592 unsigned char *sig = NULL, *r = NULL, *s = NULL;
593 size_t sig_len = 0, rlen = 0, slen = 0;
594 const struct dsa_siggen_st *tst = &dsa_siggen_data[id];
596 if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N)))
599 if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
601 || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
603 test_output_memory("r", r, rlen);
604 test_output_memory("s", s, slen);
614 static int dsa_sigver_test(int id)
617 EVP_PKEY_CTX *ctx = NULL;
618 EVP_PKEY *pkey = NULL;
619 DSA_SIG *sign = NULL;
621 unsigned char *sig = NULL;
622 BIGNUM *rbn = NULL, *sbn = NULL;
624 unsigned char digest[EVP_MAX_MD_SIZE];
625 unsigned int digest_len;
626 BN_CTX *bn_ctx = NULL;
627 const struct dsa_sigver_st *tst = &dsa_sigver_data[id];
629 if (!TEST_ptr(bn_ctx = BN_CTX_new())
630 || !TEST_true(dsa_create_pkey(&pkey, tst->p, tst->p_len,
631 tst->q, tst->q_len, tst->g, tst->g_len,
632 NULL, 0, 0, "", tst->pub, tst->pub_len,
636 if (!TEST_ptr(sign = DSA_SIG_new())
637 || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
638 || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
639 || !TEST_true(DSA_SIG_set0(sign, rbn, sbn)))
643 if (!TEST_ptr(md = EVP_MD_fetch(libctx, tst->digest_alg, ""))
644 || !TEST_true(EVP_Digest(tst->msg, tst->msg_len,
645 digest, &digest_len, md, NULL)))
648 if (!TEST_int_gt((sig_len = i2d_DSA_SIG(sign, &sig)), 0)
649 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
650 || !TEST_int_gt(EVP_PKEY_verify_init(ctx), 0)
651 || !TEST_int_eq(EVP_PKEY_verify(ctx, sig, sig_len, digest, digest_len),
656 EVP_PKEY_CTX_free(ctx);
666 #endif /* OPENSSL_NO_DSA */
669 /* cipher encrypt/decrypt */
670 static int cipher_enc(const char *alg,
671 const unsigned char *pt, size_t pt_len,
672 const unsigned char *key, size_t key_len,
673 const unsigned char *iv, size_t iv_len,
674 const unsigned char *ct, size_t ct_len,
677 int ret = 0, out_len = 0, len = 0;
678 EVP_CIPHER_CTX *ctx = NULL;
679 EVP_CIPHER *cipher = NULL;
680 unsigned char out[256] = { 0 };
682 TEST_note("%s : %s", alg, enc ? "encrypt" : "decrypt");
683 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
684 || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
685 || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc))
686 || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
687 || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len))
688 || !TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
691 if (!TEST_mem_eq(out, out_len, ct, ct_len))
695 EVP_CIPHER_free(cipher);
696 EVP_CIPHER_CTX_free(ctx);
700 static int cipher_enc_dec_test(int id)
702 const struct cipher_st *tst = &cipher_enc_data[id];
705 return TEST_true(cipher_enc(tst->alg, tst->pt, tst->pt_len,
706 tst->key, tst->key_len,
707 tst->iv, tst->iv_len,
708 tst->ct, tst->ct_len, enc))
709 && TEST_true(cipher_enc(tst->alg, tst->ct, tst->ct_len,
710 tst->key, tst->key_len,
711 tst->iv, tst->iv_len,
712 tst->pt, tst->pt_len, !enc));
715 static int aes_ccm_enc_dec(const char *alg,
716 const unsigned char *pt, size_t pt_len,
717 const unsigned char *key, size_t key_len,
718 const unsigned char *iv, size_t iv_len,
719 const unsigned char *aad, size_t aad_len,
720 const unsigned char *ct, size_t ct_len,
721 const unsigned char *tag, size_t tag_len,
726 EVP_CIPHER *cipher = NULL;
728 unsigned char out[1024];
730 TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
731 pass ? "pass" : "fail");
733 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
734 || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
735 || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
736 || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
738 || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
739 enc ? NULL : (void *)tag))
740 || !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
741 || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
742 || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, NULL, pt_len))
743 || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
744 || !TEST_int_eq(EVP_CipherUpdate(ctx, out, &len, pt, pt_len), pass))
751 if (!TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
755 if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
756 tag_len, out + out_len))
757 || !TEST_mem_eq(out, out_len, ct, ct_len)
758 || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
761 if (!TEST_mem_eq(out, out_len + len, ct, ct_len))
767 EVP_CIPHER_free(cipher);
768 EVP_CIPHER_CTX_free(ctx);
772 static int aes_ccm_enc_dec_test(int id)
774 const struct cipher_ccm_st *tst = &aes_ccm_enc_data[id];
776 /* The tag is on the end of the cipher text */
777 const size_t tag_len = tst->ct_len - tst->pt_len;
778 const size_t ct_len = tst->ct_len - tag_len;
779 const unsigned char *tag = tst->ct + ct_len;
786 return aes_ccm_enc_dec(tst->alg, tst->pt, tst->pt_len,
787 tst->key, tst->key_len,
788 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
789 tst->ct, ct_len, tag, tag_len, enc, pass)
790 && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
791 tst->key, tst->key_len,
792 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
793 tst->pt, tst->pt_len, tag, tag_len, !enc, pass)
794 /* test that it fails if the tag is incorrect */
795 && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
796 tst->key, tst->key_len,
797 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
798 tst->pt, tst->pt_len,
799 tag - 1, tag_len, !enc, !pass);
802 static int aes_gcm_enc_dec(const char *alg,
803 const unsigned char *pt, size_t pt_len,
804 const unsigned char *key, size_t key_len,
805 const unsigned char *iv, size_t iv_len,
806 const unsigned char *aad, size_t aad_len,
807 const unsigned char *ct, size_t ct_len,
808 const unsigned char *tag, size_t tag_len,
813 EVP_CIPHER *cipher = NULL;
815 unsigned char out[1024];
817 TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
818 pass ? "pass" : "fail");
820 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
821 || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
822 || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
823 || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
828 if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
833 * TODO(3.0): The IV should not be set outside the boundary as it is now.
834 * It needs to be fed in via a dummy entropy source for this test.
836 if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
837 || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
838 || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
839 || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len)))
842 if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &out_len), pass))
850 if (!TEST_mem_eq(out, out_len, ct, ct_len)
851 || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
852 tag_len, out + out_len))
853 || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
856 if (!TEST_mem_eq(out, out_len, ct, ct_len))
862 EVP_CIPHER_free(cipher);
863 EVP_CIPHER_CTX_free(ctx);
867 static int aes_gcm_enc_dec_test(int id)
869 const struct cipher_gcm_st *tst = &aes_gcm_enc_data[id];
873 return aes_gcm_enc_dec(tst->alg, tst->pt, tst->pt_len,
874 tst->key, tst->key_len,
875 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
876 tst->ct, tst->ct_len, tst->tag, tst->tag_len,
878 && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
879 tst->key, tst->key_len,
880 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
881 tst->pt, tst->pt_len, tst->tag, tst->tag_len,
883 /* Fail if incorrect tag passed to decrypt */
884 && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
885 tst->key, tst->key_len,
886 tst->iv, tst->iv_len, tst->aad, tst->aad_len,
887 tst->pt, tst->pt_len, tst->aad, tst->tag_len,
891 #ifndef OPENSSL_NO_DH
892 static int dh_create_pkey(EVP_PKEY **pkey, const char *group_name,
893 const unsigned char *pub, size_t pub_len,
894 const unsigned char *priv, size_t priv_len,
895 BN_CTX *bn_ctx, int pass)
898 EVP_PKEY_CTX *ctx = NULL;
899 OSSL_PARAM_BLD *bld = NULL;
900 OSSL_PARAM *params = NULL;
901 BIGNUM *pub_bn = NULL, *priv_bn = NULL;
903 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
904 || (group_name != NULL
905 && !TEST_int_gt(OSSL_PARAM_BLD_push_utf8_string(
906 bld, OSSL_PKEY_PARAM_DH_GROUP,
911 if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
912 || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
913 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
918 if (!TEST_ptr(priv_bn = BN_CTX_get(bn_ctx))
919 || !TEST_ptr(BN_bin2bn(priv, priv_len, priv_bn))
920 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
925 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
926 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
927 || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
928 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), pass))
933 OSSL_PARAM_BLD_free_params(params);
934 OSSL_PARAM_BLD_free(bld);
935 EVP_PKEY_CTX_free(ctx);
939 static int dh_safe_prime_keygen_test(int id)
942 EVP_PKEY_CTX *ctx = NULL;
943 EVP_PKEY *pkey = NULL;
944 unsigned char *priv = NULL;
945 unsigned char *pub = NULL;
946 size_t priv_len = 0, pub_len = 0;
947 OSSL_PARAM params[2];
948 const struct dh_safe_prime_keygen_st *tst = &dh_safe_prime_keygen_data[id];
950 params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_DH_GROUP,
951 (char *)tst->group_name, 0);
952 params[1] = OSSL_PARAM_construct_end();
954 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
955 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
956 || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
957 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
958 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
960 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PUB_KEY,
964 test_output_memory("x", priv, priv_len);
965 test_output_memory("y", pub, pub_len);
968 OPENSSL_clear_free(priv, priv_len);
971 EVP_PKEY_CTX_free(ctx);
975 static int dh_safe_prime_keyver_test(int id)
978 BN_CTX *bn_ctx = NULL;
979 EVP_PKEY_CTX *key_ctx = NULL;
980 EVP_PKEY *pkey = NULL;
981 const struct dh_safe_prime_keyver_st *tst = &dh_safe_prime_keyver_data[id];
983 if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
984 || !TEST_true(dh_create_pkey(&pkey, tst->group_name,
985 tst->pub, tst->pub_len,
986 tst->priv, tst->priv_len, bn_ctx, 1))
987 || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
988 || !TEST_int_eq(EVP_PKEY_check(key_ctx), tst->pass))
994 EVP_PKEY_CTX_free(key_ctx);
998 #endif /* OPENSSL_NO_DH */
1001 #ifndef OPENSSL_NO_RSA
1002 static EVP_PKEY *rsa_keygen(int bits)
1004 EVP_PKEY *key = NULL;
1005 EVP_PKEY_CTX *keygen_ctx = NULL;
1007 if (!TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1008 || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
1009 || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(keygen_ctx, bits))
1010 || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
1013 EVP_PKEY_CTX_free(keygen_ctx);
1017 static int rsa_create_pkey(EVP_PKEY **pkey,
1018 const unsigned char *n, size_t n_len,
1019 const unsigned char *e, size_t e_len,
1020 const unsigned char *d, size_t d_len,
1024 EVP_PKEY_CTX *ctx = NULL;
1025 OSSL_PARAM_BLD *bld = NULL;
1026 OSSL_PARAM *params = NULL;
1027 BIGNUM *e_bn = NULL, *d_bn = NULL, *n_bn = NULL;
1029 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1030 || !TEST_ptr(n_bn = BN_CTX_get(bn_ctx))
1031 || !TEST_ptr(BN_bin2bn(n, n_len, n_bn))
1032 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n_bn)))
1036 if (!TEST_ptr(e_bn = BN_CTX_get(bn_ctx))
1037 || !TEST_ptr(BN_bin2bn(e, e_len, e_bn))
1038 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E,
1043 if (!TEST_ptr(d_bn = BN_CTX_get(bn_ctx))
1044 || !TEST_ptr(BN_bin2bn(d, d_len, d_bn))
1045 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D,
1049 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
1050 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1051 || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
1052 || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
1057 OSSL_PARAM_BLD_free_params(params);
1058 OSSL_PARAM_BLD_free(bld);
1059 EVP_PKEY_CTX_free(ctx);
1063 static int rsa_keygen_test(int id)
1066 EVP_PKEY_CTX *ctx = NULL;
1067 EVP_PKEY *pkey = NULL;
1068 BIGNUM *e_bn = NULL;
1069 BIGNUM *xp1_bn = NULL, *xp2_bn = NULL, *xp_bn = NULL;
1070 BIGNUM *xq1_bn = NULL, *xq2_bn = NULL, *xq_bn = NULL;
1071 unsigned char *n = NULL, *d = NULL;
1072 unsigned char *p = NULL, *p1 = NULL, *p2 = NULL;
1073 unsigned char *q = NULL, *q1 = NULL, *q2 = NULL;
1074 size_t n_len = 0, d_len = 0;
1075 size_t p_len = 0, p1_len = 0, p2_len = 0;
1076 size_t q_len = 0, q1_len = 0, q2_len = 0;
1077 OSSL_PARAM_BLD *bld = NULL;
1078 OSSL_PARAM *params = NULL;
1079 const struct rsa_keygen_st *tst = &rsa_keygen_data[id];
1081 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1082 || !TEST_ptr(xp1_bn = BN_bin2bn(tst->xp1, tst->xp1_len, NULL))
1083 || !TEST_ptr(xp2_bn = BN_bin2bn(tst->xp2, tst->xp2_len, NULL))
1084 || !TEST_ptr(xp_bn = BN_bin2bn(tst->xp, tst->xp_len, NULL))
1085 || !TEST_ptr(xq1_bn = BN_bin2bn(tst->xq1, tst->xq1_len, NULL))
1086 || !TEST_ptr(xq2_bn = BN_bin2bn(tst->xq2, tst->xq2_len, NULL))
1087 || !TEST_ptr(xq_bn = BN_bin2bn(tst->xq, tst->xq_len, NULL))
1088 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP1,
1090 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP2,
1092 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP,
1094 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ1,
1096 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ2,
1098 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ,
1100 || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
1103 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1104 || !TEST_ptr(e_bn = BN_bin2bn(tst->e, tst->e_len, NULL))
1105 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1106 || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
1107 || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, tst->mod))
1108 || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, e_bn))
1109 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
1110 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P1,
1112 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P2,
1114 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q1,
1116 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q2,
1118 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR1,
1120 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR2,
1122 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N,
1124 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_D,
1128 if (!TEST_mem_eq(tst->p1, tst->p1_len, p1, p1_len)
1129 || !TEST_mem_eq(tst->p2, tst->p2_len, p2, p2_len)
1130 || !TEST_mem_eq(tst->p, tst->p_len, p, p_len)
1131 || !TEST_mem_eq(tst->q1, tst->q1_len, q1, q1_len)
1132 || !TEST_mem_eq(tst->q2, tst->q2_len, q2, q2_len)
1133 || !TEST_mem_eq(tst->q, tst->q_len, q, q_len)
1134 || !TEST_mem_eq(tst->n, tst->n_len, n, n_len)
1135 || !TEST_mem_eq(tst->d, tst->d_len, d, d_len))
1138 test_output_memory("p1", p1, p1_len);
1139 test_output_memory("p2", p2, p2_len);
1140 test_output_memory("p", p, p_len);
1141 test_output_memory("q1", q1, q1_len);
1142 test_output_memory("q2", q2, q2_len);
1143 test_output_memory("q", q, q_len);
1144 test_output_memory("n", n, n_len);
1145 test_output_memory("d", d, d_len);
1163 EVP_PKEY_free(pkey);
1164 EVP_PKEY_CTX_free(ctx);
1165 OSSL_PARAM_BLD_free_params(params);
1166 OSSL_PARAM_BLD_free(bld);
1170 static int rsa_siggen_test(int id)
1173 EVP_PKEY *pkey = NULL;
1174 unsigned char *sig = NULL, *n = NULL, *e = NULL;
1175 size_t sig_len = 0, n_len = 0, e_len = 0;
1176 OSSL_PARAM params[4], *p;
1177 const struct rsa_siggen_st *tst = &rsa_siggen_data[id];
1179 TEST_note("RSA %s signature generation", tst->sig_pad_mode);
1182 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1183 (char *)tst->sig_pad_mode, 0);
1184 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1185 (char *)tst->digest_alg, 0);
1186 if (tst->pss_salt_len >= 0) {
1187 int salt_len = tst->pss_salt_len;
1189 *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1192 *p++ = OSSL_PARAM_construct_end();
1194 if (!TEST_ptr(pkey = rsa_keygen(tst->mod))
1195 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1196 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1197 || !TEST_true(sig_gen(pkey, params, tst->digest_alg,
1198 tst->msg, tst->msg_len,
1201 test_output_memory("n", n, n_len);
1202 test_output_memory("e", e, e_len);
1203 test_output_memory("sig", sig, sig_len);
1209 EVP_PKEY_free(pkey);
1213 static int rsa_sigver_test(int id)
1216 EVP_PKEY_CTX *pkey_ctx = NULL;
1217 EVP_PKEY *pkey = NULL;
1218 EVP_MD_CTX *md_ctx = NULL;
1219 BN_CTX *bn_ctx = NULL;
1220 OSSL_PARAM params[4], *p;
1221 const struct rsa_sigver_st *tst = &rsa_sigver_data[id];
1223 TEST_note("RSA %s Signature Verify : expected to %s ", tst->sig_pad_mode,
1224 tst->pass == PASS ? "pass" : "fail");
1227 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1228 (char *)tst->sig_pad_mode, 0);
1229 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1230 (char *)tst->digest_alg, 0);
1231 if (tst->pss_salt_len >= 0) {
1232 int salt_len = tst->pss_salt_len;
1234 *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1237 *p++ = OSSL_PARAM_construct_end();
1239 if (!TEST_ptr(bn_ctx = BN_CTX_new())
1240 || !TEST_true(rsa_create_pkey(&pkey, tst->n, tst->n_len,
1241 tst->e, tst->e_len, NULL, 0, bn_ctx))
1242 || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
1243 || !TEST_true(EVP_DigestVerifyInit_ex(md_ctx, &pkey_ctx, tst->digest_alg,
1245 || !TEST_true(EVP_PKEY_CTX_set_params(pkey_ctx, params))
1246 || !TEST_int_eq(EVP_DigestVerify(md_ctx, tst->sig, tst->sig_len,
1247 tst->msg, tst->msg_len), tst->pass)))
1251 EVP_PKEY_free(pkey);
1252 BN_CTX_free(bn_ctx);
1253 EVP_MD_CTX_free(md_ctx);
1257 static int rsa_decryption_primitive_test(int id)
1260 EVP_PKEY_CTX *ctx = NULL;
1261 EVP_PKEY *pkey = NULL;
1262 unsigned char pt[2048];
1263 size_t pt_len = sizeof(pt);
1264 unsigned char *n = NULL, *e = NULL;
1265 size_t n_len = 0, e_len = 0;
1266 BN_CTX *bn_ctx = NULL;
1267 const struct rsa_decrypt_prim_st *tst = &rsa_decrypt_prim_data[id];
1269 if (!TEST_ptr(pkey = rsa_keygen(2048))
1270 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1271 || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1272 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
1273 || !TEST_int_gt(EVP_PKEY_decrypt_init(ctx), 0)
1274 || !TEST_int_gt(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING), 0))
1277 test_output_memory("n", n, n_len);
1278 test_output_memory("e", e, e_len);
1279 if (!EVP_PKEY_decrypt(ctx, pt, &pt_len, tst->ct, tst->ct_len))
1280 TEST_note("Decryption Failed");
1282 test_output_memory("pt", pt, pt_len);
1287 EVP_PKEY_CTX_free(ctx);
1288 EVP_PKEY_free(pkey);
1289 BN_CTX_free(bn_ctx);
1292 #endif /* OPENSSL_NO_RSA */
1295 int setup_tests(void)
1297 char *config_file = NULL;
1301 while ((o = opt_next()) != OPT_EOF) {
1303 case OPT_CONFIG_FILE:
1304 config_file = opt_arg();
1306 case OPT_TEST_CASES:
1314 prov_null = OSSL_PROVIDER_load(NULL, "null");
1315 if (prov_null == NULL) {
1316 opt_printf_stderr("Failed to load null provider into default libctx\n");
1320 libctx = OPENSSL_CTX_new();
1322 || !OPENSSL_CTX_load_config(libctx, config_file)) {
1323 opt_printf_stderr("Failed to load config\n");
1327 ADD_ALL_TESTS(cipher_enc_dec_test, OSSL_NELEM(cipher_enc_data));
1328 ADD_ALL_TESTS(aes_ccm_enc_dec_test, OSSL_NELEM(aes_ccm_enc_data));
1329 ADD_ALL_TESTS(aes_gcm_enc_dec_test, OSSL_NELEM(aes_gcm_enc_data));
1331 #ifndef OPENSSL_NO_RSA
1332 ADD_ALL_TESTS(rsa_keygen_test, OSSL_NELEM(rsa_keygen_data));
1333 ADD_ALL_TESTS(rsa_siggen_test, OSSL_NELEM(rsa_siggen_data));
1334 ADD_ALL_TESTS(rsa_sigver_test, OSSL_NELEM(rsa_sigver_data));
1335 ADD_ALL_TESTS(rsa_decryption_primitive_test,
1336 OSSL_NELEM(rsa_decrypt_prim_data));
1337 #endif /* OPENSSL_NO_RSA */
1339 #ifndef OPENSSL_NO_DH
1340 ADD_ALL_TESTS(dh_safe_prime_keygen_test,
1341 OSSL_NELEM(dh_safe_prime_keygen_data));
1342 ADD_ALL_TESTS(dh_safe_prime_keyver_test,
1343 OSSL_NELEM(dh_safe_prime_keyver_data));
1344 #endif /* OPENSSL_NO_DH */
1346 #ifndef OPENSSL_NO_DSA
1347 ADD_ALL_TESTS(dsa_keygen_test, OSSL_NELEM(dsa_keygen_data));
1348 ADD_ALL_TESTS(dsa_paramgen_test, OSSL_NELEM(dsa_paramgen_data));
1349 ADD_ALL_TESTS(dsa_pqver_test, OSSL_NELEM(dsa_pqver_data));
1350 ADD_ALL_TESTS(dsa_siggen_test, OSSL_NELEM(dsa_siggen_data));
1351 ADD_ALL_TESTS(dsa_sigver_test, OSSL_NELEM(dsa_sigver_data));
1352 #endif /* OPENSSL_NO_DSA */
1354 #ifndef OPENSSL_NO_EC
1355 ADD_ALL_TESTS(ecdsa_keygen_test, OSSL_NELEM(ecdsa_keygen_data));
1356 ADD_ALL_TESTS(ecdsa_pub_verify_test, OSSL_NELEM(ecdsa_pv_data));
1357 ADD_ALL_TESTS(ecdsa_siggen_test, OSSL_NELEM(ecdsa_siggen_data));
1358 ADD_ALL_TESTS(ecdsa_sigver_test, OSSL_NELEM(ecdsa_sigver_data));
1359 #endif /* OPENSSL_NO_EC */
1363 void cleanup_tests(void)
1365 OSSL_PROVIDER_unload(prov_null);
1366 OPENSSL_CTX_free(libctx);