test/acvp_test.c

   1 /*
   2  * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   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
   8  */
   9
  10 /*
  11  * A set of tests demonstrating uses cases for CAVS/ACVP testing.
  12  *
  13  * For examples of testing KDF's, Digests, KeyAgreement & DRBG's refer to
  14  * providers/fips/self_test_kats.c
  15  */
  16
  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>
  26 #include "testutil.h"
  27 #include "testutil/output.h"
  28 #include "acvp_test.inc"
  29 #include "internal/nelem.h"
  30
  31 static OSSL_PROVIDER *prov_null = NULL;
  32 static OPENSSL_CTX *libctx = NULL;
  33
  34 typedef enum OPTION_choice {
  35     OPT_ERR = -1,
  36     OPT_EOF = 0,
  37     OPT_CONFIG_FILE,
  38     OPT_TEST_ENUM
  39 } OPTION_CHOICE;
  40
  41 const OPTIONS *test_get_options(void)
  42 {
  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" },
  47         { NULL }
  48     };
  49     return test_options;
  50 }
  51
  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)
  56 {
  57     unsigned char *buf = NULL;
  58     BIGNUM *bn = NULL;
  59     int sz;
  60
  61     if (!EVP_PKEY_get_bn_param(pkey, name, &bn))
  62         goto err;
  63     sz = BN_num_bytes(bn);
  64     buf = OPENSSL_zalloc(sz);
  65     if (buf == NULL)
  66         goto err;
  67     if (!BN_bn2binpad(bn, buf, sz))
  68         goto err;
  69
  70     *out_len = sz;
  71     *out = buf;
  72     BN_free(bn);
  73     return 1;
  74 err:
  75     OPENSSL_free(buf);
  76     BN_free(bn);
  77     return 0;
  78 }
  79 #endif
  80
  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)
  86 {
  87     int ret = 0;
  88     EVP_MD_CTX *md_ctx = NULL;
  89     unsigned char *sig = NULL;
  90     size_t sig_len;
  91     size_t sz = EVP_PKEY_size(pkey);
  92
  93     if (!TEST_ptr(sig = OPENSSL_malloc(sz))
  94         || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
  95         || !TEST_int_eq(EVP_DigestSignInit_with_libctx(md_ctx, NULL,
  96                                                        digest_name, libctx, NULL,
  97                                                        pkey), 1)
  98         || !TEST_int_gt(EVP_DigestSign(md_ctx, sig, &sig_len, msg, msg_len), 0))
  99         goto err;
 100     *sig_out = sig;
 101     *sig_out_len = sig_len;
 102     sig = NULL;
 103     ret = 1;
 104 err:
 105     OPENSSL_free(sig);
 106     EVP_MD_CTX_free(md_ctx);
 107     return ret;
 108 }
 109 #endif
 110
 111 #ifndef OPENSSL_NO_EC
 112 static int ecdsa_keygen_test(int id)
 113 {
 114     int ret = 0;
 115     EVP_PKEY_CTX *ctx = NULL;
 116     EVP_PKEY *pkey = NULL;
 117     unsigned char *priv = NULL;
 118     unsigned char *pubx = NULL, *puby = NULL;
 119     size_t priv_len = 0, pubx_len = 0, puby_len = 0;
 120     const struct ecdsa_keygen_st *tst = &ecdsa_keygen_data[id];
 121
 122     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
 123         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
 124         || !TEST_true(EVP_PKEY_CTX_set_group_name(ctx, tst->curve_name))
 125         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
 126         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &priv,
 127                                         &priv_len))
 128         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &pubx,
 129                                         &pubx_len))
 130         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &puby,
 131                                         &puby_len)))
 132         goto err;
 133
 134     test_output_memory("qy", puby, puby_len);
 135     test_output_memory("qx", pubx, pubx_len);
 136     test_output_memory("d", priv, priv_len);
 137     ret = 1;
 138 err:
 139     OPENSSL_clear_free(priv, priv_len);
 140     OPENSSL_free(pubx);
 141     OPENSSL_free(puby);
 142     EVP_PKEY_free(pkey);
 143     EVP_PKEY_CTX_free(ctx);
 144     return ret;
 145 }
 146
 147 static int ecdsa_create_pkey(EVP_PKEY **pkey, const char *curve_name,
 148                              const unsigned char *pub, size_t pub_len,
 149                              int expected)
 150 {
 151     int ret = 0;
 152     EVP_PKEY_CTX *ctx = NULL;
 153     OSSL_PARAM_BLD *bld = NULL;
 154     OSSL_PARAM *params = NULL;
 155
 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_GROUP_NAME, curve_name, 0) > 0))
 160         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 161                                                        OSSL_PKEY_PARAM_PUB_KEY,
 162                                                        pub, pub_len) > 0)
 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))
 167     goto err;
 168
 169     ret = 1;
 170 err:
 171     OSSL_PARAM_BLD_free_params(params);
 172     OSSL_PARAM_BLD_free(bld);
 173     EVP_PKEY_CTX_free(ctx);
 174     return ret;
 175 }
 176
 177 static int ecdsa_pub_verify_test(int id)
 178 {
 179     const struct ecdsa_pub_verify_st *tst = &ecdsa_pv_data[id];
 180
 181     int ret = 0;
 182     EVP_PKEY_CTX *key_ctx = NULL;
 183     EVP_PKEY *pkey = NULL;
 184
 185     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
 186                                      tst->pub, tst->pub_len, tst->pass)))
 187         goto err;
 188
 189     if (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))
 192             goto err;
 193     }
 194     ret = 1;
 195 err:
 196     EVP_PKEY_free(pkey);
 197     EVP_PKEY_CTX_free(key_ctx);
 198     return ret;
 199 }
 200
 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)
 205 {
 206     int ret = 0;
 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);
 211
 212     if (sign == NULL)
 213         return 0;
 214     r1 = ECDSA_SIG_get0_r(sign);
 215     s1 = ECDSA_SIG_get0_s(sign);
 216     if (r1 == NULL || s1 == NULL)
 217         return 0;
 218
 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)
 224         goto err;
 225     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
 226         goto err;
 227     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
 228         goto err;
 229     *r = rbuf;
 230     *s = sbuf;
 231     *rlen = r1_len;
 232     *slen = s1_len;
 233     ret = 1;
 234 err:
 235     if (ret == 0) {
 236         OPENSSL_free(rbuf);
 237         OPENSSL_free(sbuf);
 238     }
 239     ECDSA_SIG_free(sign);
 240     return ret;
 241 }
 242
 243 static int ecdsa_siggen_test(int id)
 244 {
 245     int ret = 0;
 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];
 252
 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_group_name(ctx, tst->curve_name))
 256         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
 257         goto err;
 258
 259     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
 260                            &sig, &sig_len))
 261         || !TEST_true(get_ecdsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
 262         goto err;
 263     test_output_memory("r", r, rlen);
 264     test_output_memory("s", s, slen);
 265     ret = 1;
 266 err:
 267     OPENSSL_free(r);
 268     OPENSSL_free(s);
 269     OPENSSL_free(sig);
 270     EVP_PKEY_free(pkey);
 271     EVP_PKEY_CTX_free(key_ctx);
 272     EVP_PKEY_CTX_free(ctx);
 273     return ret;
 274 }
 275
 276 static int ecdsa_sigver_test(int id)
 277 {
 278     int ret = 0;
 279     EVP_MD_CTX *md_ctx = NULL;
 280     EVP_PKEY *pkey = NULL;
 281     ECDSA_SIG *sign = NULL;
 282     size_t sig_len;
 283     unsigned char *sig = NULL;
 284     BIGNUM *rbn = NULL, *sbn = NULL;
 285     const struct ecdsa_sigver_st *tst = &ecdsa_sigver_data[id];
 286
 287     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
 288                                      tst->pub, tst->pub_len, 1)))
 289         goto err;
 290
 291     if (!TEST_ptr(sign = ECDSA_SIG_new())
 292         || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
 293         || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
 294         || !TEST_true(ECDSA_SIG_set0(sign, rbn, sbn)))
 295         goto err;
 296     rbn = sbn = NULL;
 297
 298     ret = TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0)
 299           && TEST_ptr(md_ctx = EVP_MD_CTX_new())
 300           && TEST_true(EVP_DigestVerifyInit_with_libctx(md_ctx, NULL,
 301                                                         tst->digest_alg,
 302                                                         libctx, NULL, pkey)
 303           && TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len,
 304                                           tst->msg, tst->msg_len), tst->pass));
 305 err:
 306     BN_free(rbn);
 307     BN_free(sbn);
 308     OPENSSL_free(sig);
 309     ECDSA_SIG_free(sign);
 310     EVP_PKEY_free(pkey);
 311     EVP_MD_CTX_free(md_ctx);
 312     return ret;
 313
 314 }
 315 #endif /* OPENSSL_NO_EC */
 316
 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)
 320 {
 321     size_t len = 0;
 322     unsigned char *buf = NULL;
 323
 324     if (!EVP_PKEY_get_octet_string_param(pkey, name, NULL, 0, &len))
 325         goto err;
 326
 327     buf = OPENSSL_zalloc(len);
 328     if (buf == NULL)
 329         goto err;
 330
 331     if (!EVP_PKEY_get_octet_string_param(pkey, name, buf, len, out_len))
 332         goto err;
 333     *out = buf;
 334     return 1;
 335 err:
 336     OPENSSL_free(buf);
 337     return 0;
 338 }
 339
 340 static EVP_PKEY *dsa_paramgen(int L, int N)
 341 {
 342     EVP_PKEY_CTX *paramgen_ctx = NULL;
 343     EVP_PKEY *param_key = NULL;
 344
 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, &param_key)))
 350         return NULL;
 351     EVP_PKEY_CTX_free(paramgen_ctx);
 352     return param_key;
 353 }
 354
 355 static EVP_PKEY *dsa_keygen(int L, int N)
 356 {
 357     EVP_PKEY *param_key = NULL, *key = NULL;
 358     EVP_PKEY_CTX *keygen_ctx = NULL;
 359
 360     if (!TEST_ptr(param_key = dsa_paramgen(L, N))
 361         || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
 362                                                              NULL))
 363         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
 364         || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
 365         goto err;
 366 err:
 367     EVP_PKEY_free(param_key);
 368     EVP_PKEY_CTX_free(keygen_ctx);
 369     return key;
 370 }
 371
 372 static int dsa_keygen_test(int id)
 373 {
 374     int ret = 0, i;
 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];
 380
 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,
 383                                                              NULL))
 384         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0))
 385         goto err;
 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,
 389                                             &priv, &priv_len))
 390             || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PUB_KEY,
 391                                             &pub, &pub_len)))
 392             goto err;
 393         test_output_memory("y", pub, pub_len);
 394         test_output_memory("x", priv, priv_len);
 395         EVP_PKEY_free(key);
 396         OPENSSL_clear_free(priv, priv_len);
 397         OPENSSL_free(pub);
 398         key = NULL;
 399         pub = priv = NULL;
 400     }
 401     ret = 1;
 402 err:
 403     OPENSSL_clear_free(priv, priv_len);
 404     OPENSSL_free(pub);
 405     EVP_PKEY_free(param_key);
 406     EVP_PKEY_free(key);
 407     EVP_PKEY_CTX_free(keygen_ctx);
 408     EVP_PKEY_CTX_free(paramgen_ctx);
 409     return ret;
 410 }
 411
 412 static int dsa_paramgen_test(int id)
 413 {
 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];
 420
 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, &param_key))
 426         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P,
 427                                         &p, &plen))
 428         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q,
 429                                         &q, &qlen))
 430         || !TEST_true(pkey_get_octet_bytes(param_key, OSSL_PKEY_PARAM_FFC_SEED,
 431                                            &seed, &seedlen))
 432         || !TEST_true(EVP_PKEY_get_int_param(param_key,
 433                                              OSSL_PKEY_PARAM_FFC_PCOUNTER,
 434                                              &counter)))
 435         goto err;
 436
 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);
 441     ret = 1;
 442 err:
 443     OPENSSL_free(p);
 444     OPENSSL_free(q);
 445     OPENSSL_free(seed);
 446     EVP_PKEY_free(param_key);
 447     EVP_PKEY_CTX_free(paramgen_ctx);
 448     return ret;
 449 }
 450
 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,
 456                            int counter,
 457                            const char *validate_type,
 458                            const unsigned char *pub, size_t pub_len,
 459                            BN_CTX *bn_ctx)
 460 {
 461     int ret = 0;
 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;
 466
 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,
 472                          validate_type, 0))
 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)))
 477         goto err;
 478
 479      if (g != NULL) {
 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)))
 484              goto err;
 485      }
 486      if (seed != NULL) {
 487          if (!TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 488                             OSSL_PKEY_PARAM_FFC_SEED, seed, seed_len)))
 489              goto err;
 490      }
 491      if (counter != -1) {
 492          if (!TEST_true(OSSL_PARAM_BLD_push_int(bld,
 493                                                 OSSL_PKEY_PARAM_FFC_PCOUNTER,
 494                                                 counter)))
 495              goto err;
 496      }
 497      if (pub != NULL) {
 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,
 502                                                   pub_bn)))
 503              goto err;
 504      }
 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)))
 509          goto err;
 510
 511     ret = 1;
 512 err:
 513     OSSL_PARAM_BLD_free_params(params);
 514     OSSL_PARAM_BLD_free(bld);
 515     EVP_PKEY_CTX_free(ctx);
 516     return ret;
 517 }
 518
 519 static int dsa_pqver_test(int id)
 520 {
 521     int ret = 0;
 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];
 526
 527     if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
 528         || !TEST_true(dsa_create_pkey(&param_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,
 532                                       NULL, 0,
 533                                       bn_ctx))
 534         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
 535                                                           NULL))
 536         || !TEST_int_eq(EVP_PKEY_param_check(key_ctx), tst->pass))
 537         goto err;
 538
 539     ret = 1;
 540 err:
 541     BN_CTX_free(bn_ctx);
 542     EVP_PKEY_free(param_key);
 543     EVP_PKEY_CTX_free(key_ctx);
 544     return ret;
 545 }
 546
 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)
 551 {
 552     int ret = 0;
 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);
 557
 558     if (sign == NULL)
 559         return 0;
 560     DSA_SIG_get0(sign, &r1, &s1);
 561     if (r1 == NULL || s1 == NULL)
 562         return 0;
 563
 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)
 569         goto err;
 570     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
 571         goto err;
 572     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
 573         goto err;
 574     *r = rbuf;
 575     *s = sbuf;
 576     *r_len = r1_len;
 577     *s_len = s1_len;
 578     ret = 1;
 579 err:
 580     if (ret == 0) {
 581         OPENSSL_free(rbuf);
 582         OPENSSL_free(sbuf);
 583     }
 584     DSA_SIG_free(sign);
 585     return ret;
 586 }
 587
 588 static int dsa_siggen_test(int id)
 589 {
 590     int ret = 0;
 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];
 595
 596     if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N)))
 597         goto err;
 598
 599     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
 600                            &sig, &sig_len))
 601         || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
 602         goto err;
 603     test_output_memory("r", r, rlen);
 604     test_output_memory("s", s, slen);
 605     ret = 1;
 606 err:
 607     OPENSSL_free(r);
 608     OPENSSL_free(s);
 609     OPENSSL_free(sig);
 610     EVP_PKEY_free(pkey);
 611     return ret;
 612 }
 613
 614 static int dsa_sigver_test(int id)
 615 {
 616     int ret = 0;
 617     EVP_PKEY_CTX *ctx = NULL;
 618     EVP_PKEY *pkey = NULL;
 619     DSA_SIG *sign = NULL;
 620     size_t sig_len;
 621     unsigned char *sig = NULL;
 622     BIGNUM *rbn = NULL, *sbn = NULL;
 623     EVP_MD *md = 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];
 628
 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,
 633                                       bn_ctx)))
 634         goto err;
 635
 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)))
 640         goto err;
 641     rbn = sbn = NULL;
 642
 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)))
 646         goto err;
 647
 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),
 652                         tst->pass))
 653         goto err;
 654     ret = 1;
 655 err:
 656     EVP_PKEY_CTX_free(ctx);
 657     OPENSSL_free(sig);
 658     EVP_MD_free(md);
 659     DSA_SIG_free(sign);
 660     EVP_PKEY_free(pkey);
 661     BN_free(rbn);
 662     BN_free(sbn);
 663     BN_CTX_free(bn_ctx);
 664     return ret;
 665 }
 666 #endif /* OPENSSL_NO_DSA */
 667
 668
 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,
 675                       int enc)
 676 {
 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 };
 681
 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)))
 689         goto err;
 690     out_len += len;
 691     if (!TEST_mem_eq(out, out_len, ct, ct_len))
 692         goto err;
 693     ret = 1;
 694 err:
 695     EVP_CIPHER_free(cipher);
 696     EVP_CIPHER_CTX_free(ctx);
 697     return ret;
 698 }
 699
 700 static int cipher_enc_dec_test(int id)
 701 {
 702     const struct cipher_st *tst = &cipher_enc_data[id];
 703     const int enc = 1;
 704
 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));
 713 }
 714
 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,
 722                            int enc, int pass)
 723 {
 724     int ret = 0;
 725     EVP_CIPHER_CTX *ctx;
 726     EVP_CIPHER *cipher = NULL;
 727     int out_len, len;
 728     unsigned char out[1024];
 729
 730     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
 731               pass ? "pass" : "fail");
 732
 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,
 737                                           NULL))
 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))
 745         goto err;
 746
 747     if (!pass) {
 748         ret = 1;
 749         goto err;
 750     }
 751     if (!TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
 752         goto err;
 753     if (enc) {
 754         out_len += 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))
 759             goto err;
 760     } else {
 761         if (!TEST_mem_eq(out, out_len + len, ct, ct_len))
 762             goto err;
 763     }
 764
 765     ret = 1;
 766 err:
 767     EVP_CIPHER_free(cipher);
 768     EVP_CIPHER_CTX_free(ctx);
 769     return ret;
 770 }
 771
 772 static int aes_ccm_enc_dec_test(int id)
 773 {
 774     const struct cipher_ccm_st *tst = &aes_ccm_enc_data[id];
 775
 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;
 780     const int enc = 1;
 781     const int pass = 1;
 782
 783     if (ct_len < 1)
 784         return 0;
 785
 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);
 800 }
 801
 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,
 809                            int enc, int pass)
 810 {
 811     int ret = 0;
 812     EVP_CIPHER_CTX *ctx;
 813     EVP_CIPHER *cipher = NULL;
 814     int out_len, len;
 815     unsigned char out[1024];
 816
 817     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
 818               pass ? "pass" : "fail");
 819
 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,
 824                                           NULL)))
 825         goto err;
 826
 827     if (!enc) {
 828         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
 829                                            (void *)tag)))
 830             goto err;
 831     }
 832     /*
 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.
 835      */
 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)))
 840         goto err;
 841
 842     if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &out_len), pass))
 843         goto err;
 844     if (!pass) {
 845         ret = 1;
 846         goto err;
 847     }
 848     out_len += len;
 849     if (enc) {
 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))
 854                     goto err;
 855     } else {
 856         if (!TEST_mem_eq(out, out_len, ct, ct_len))
 857             goto err;
 858     }
 859
 860     ret = 1;
 861 err:
 862     EVP_CIPHER_free(cipher);
 863     EVP_CIPHER_CTX_free(ctx);
 864     return ret;
 865 }
 866
 867 static int aes_gcm_enc_dec_test(int id)
 868 {
 869     const struct cipher_gcm_st *tst = &aes_gcm_enc_data[id];
 870     int enc = 1;
 871     int pass = 1;
 872
 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,
 877                            enc, pass)
 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,
 882                                !enc, pass)
 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,
 888                                !enc, !pass);
 889 }
 890
 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)
 896 {
 897     int ret = 0;
 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;
 902
 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_GROUP_NAME,
 907                               group_name, 0), 0)))
 908         goto err;
 909
 910     if (pub != NULL) {
 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,
 914                                                  pub_bn)))
 915             goto err;
 916     }
 917     if (priv != NULL) {
 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,
 921                                                  priv_bn)))
 922             goto err;
 923     }
 924
 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))
 929     goto err;
 930
 931     ret = 1;
 932 err:
 933     OSSL_PARAM_BLD_free_params(params);
 934     OSSL_PARAM_BLD_free(bld);
 935     EVP_PKEY_CTX_free(ctx);
 936     return ret;
 937 }
 938
 939 static int dh_safe_prime_keygen_test(int id)
 940 {
 941     int ret = 0;
 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];
 949
 950     params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
 951                                                  (char *)tst->group_name, 0);
 952     params[1] = OSSL_PARAM_construct_end();
 953
 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,
 959                                         &priv, &priv_len))
 960         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PUB_KEY,
 961                                         &pub, &pub_len)))
 962         goto err;
 963
 964     test_output_memory("x", priv, priv_len);
 965     test_output_memory("y", pub, pub_len);
 966     ret = 1;
 967 err:
 968     OPENSSL_clear_free(priv, priv_len);
 969     OPENSSL_free(pub);
 970     EVP_PKEY_free(pkey);
 971     EVP_PKEY_CTX_free(ctx);
 972     return ret;
 973 }
 974
 975 static int dh_safe_prime_keyver_test(int id)
 976 {
 977     int ret = 0;
 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];
 982
 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))
 989         goto err;
 990
 991     ret = 1;
 992 err:
 993     EVP_PKEY_free(pkey);
 994     EVP_PKEY_CTX_free(key_ctx);
 995     BN_CTX_free(bn_ctx);
 996     return ret;
 997 }
 998 #endif /* OPENSSL_NO_DH */
 999
1000
1001 #ifndef OPENSSL_NO_RSA
1002 static EVP_PKEY *rsa_keygen(int bits)
1003 {
1004     EVP_PKEY *key = NULL;
1005     EVP_PKEY_CTX *keygen_ctx = NULL;
1006
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))
1011         goto err;
1012 err:
1013     EVP_PKEY_CTX_free(keygen_ctx);
1014     return key;
1015 }
1016
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,
1021                            BN_CTX *bn_ctx)
1022 {
1023     int ret = 0;
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;
1028
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)))
1033         goto err;
1034
1035     if (e != NULL) {
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,
1039                           e_bn)))
1040             goto err;
1041     }
1042     if (d != NULL) {
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,
1046                           d_bn)))
1047             goto err;
1048     }
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)))
1053         goto err;
1054
1055     ret = 1;
1056 err:
1057     OSSL_PARAM_BLD_free_params(params);
1058     OSSL_PARAM_BLD_free(bld);
1059     EVP_PKEY_CTX_free(ctx);
1060     return ret;
1061 }
1062
1063 static int rsa_keygen_test(int id)
1064 {
1065     int ret = 0;
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];
1080
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,
1089                                              xp1_bn))
1090         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP2,
1091                                              xp2_bn))
1092         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP,
1093                                              xp_bn))
1094         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ1,
1095                                              xq1_bn))
1096         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ2,
1097                                              xq2_bn))
1098         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ,
1099                                              xq_bn))
1100         || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
1101         goto err;
1102
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,
1111                                         &p1, &p1_len))
1112         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P2,
1113                                         &p2, &p2_len))
1114         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q1,
1115                                         &q1, &q1_len))
1116         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q2,
1117                                         &q2, &q2_len))
1118         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR1,
1119                                         &p, &p_len))
1120         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR2,
1121                                         &q, &q_len))
1122         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N,
1123                                         &n, &n_len))
1124         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_D,
1125                                         &d, &d_len)))
1126         goto err;
1127
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))
1136         goto err;
1137
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);
1146     ret = 1;
1147 err:
1148     BN_free(xp1_bn);
1149     BN_free(xp2_bn);
1150     BN_free(xp_bn);
1151     BN_free(xq1_bn);
1152     BN_free(xq2_bn);
1153     BN_free(xq_bn);
1154     BN_free(e_bn);
1155     OPENSSL_free(p1);
1156     OPENSSL_free(p2);
1157     OPENSSL_free(q1);
1158     OPENSSL_free(q2);
1159     OPENSSL_free(p);
1160     OPENSSL_free(q);
1161     OPENSSL_free(n);
1162     OPENSSL_free(d);
1163     EVP_PKEY_free(pkey);
1164     EVP_PKEY_CTX_free(ctx);
1165     OSSL_PARAM_BLD_free_params(params);
1166     OSSL_PARAM_BLD_free(bld);
1167     return ret;
1168 }
1169
1170 static int rsa_siggen_test(int id)
1171 {
1172     int ret = 0;
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];
1178
1179     TEST_note("RSA %s signature generation", tst->sig_pad_mode);
1180
1181     p = params;
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;
1188
1189         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1190                                         &salt_len);
1191     }
1192     *p++ = OSSL_PARAM_construct_end();
1193
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,
1199                              &sig, &sig_len)))
1200         goto err;
1201     test_output_memory("n", n, n_len);
1202     test_output_memory("e", e, e_len);
1203     test_output_memory("sig", sig, sig_len);
1204     ret = 1;
1205 err:
1206     OPENSSL_free(n);
1207     OPENSSL_free(e);
1208     OPENSSL_free(sig);
1209     EVP_PKEY_free(pkey);
1210     return ret;
1211 }
1212
1213 static int rsa_sigver_test(int id)
1214 {
1215     int ret = 0;
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];
1222
1223     TEST_note("RSA %s Signature Verify : expected to %s ", tst->sig_pad_mode,
1224                tst->pass == PASS ? "pass" : "fail");
1225
1226     p = params;
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;
1233
1234         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1235                                         &salt_len);
1236     }
1237     *p++ = OSSL_PARAM_construct_end();
1238
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_with_libctx(md_ctx, &pkey_ctx,
1244                                                        tst->digest_alg,
1245                                                        libctx, NULL, pkey)
1246         || !TEST_true(EVP_PKEY_CTX_set_params(pkey_ctx, params))
1247         || !TEST_int_eq(EVP_DigestVerify(md_ctx, tst->sig, tst->sig_len,
1248                                          tst->msg, tst->msg_len), tst->pass)))
1249         goto err;
1250     ret = 1;
1251 err:
1252     EVP_PKEY_free(pkey);
1253     BN_CTX_free(bn_ctx);
1254     EVP_MD_CTX_free(md_ctx);
1255     return ret;
1256 }
1257
1258 static int rsa_decryption_primitive_test(int id)
1259 {
1260     int ret = 0;
1261     EVP_PKEY_CTX *ctx = NULL;
1262     EVP_PKEY *pkey = NULL;
1263     unsigned char pt[2048];
1264     size_t pt_len = sizeof(pt);
1265     unsigned char *n = NULL, *e = NULL;
1266     size_t n_len = 0, e_len = 0;
1267     BN_CTX *bn_ctx = NULL;
1268     const struct rsa_decrypt_prim_st *tst  = &rsa_decrypt_prim_data[id];
1269
1270     if (!TEST_ptr(pkey = rsa_keygen(2048))
1271         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1272         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1273         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
1274         || !TEST_int_gt(EVP_PKEY_decrypt_init(ctx), 0)
1275         || !TEST_int_gt(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING), 0))
1276         goto err;
1277
1278     test_output_memory("n", n, n_len);
1279     test_output_memory("e", e, e_len);
1280     if (!EVP_PKEY_decrypt(ctx, pt, &pt_len, tst->ct, tst->ct_len))
1281         TEST_note("Decryption Failed");
1282     else
1283         test_output_memory("pt", pt, pt_len);
1284     ret = 1;
1285 err:
1286     OPENSSL_free(n);
1287     OPENSSL_free(e);
1288     EVP_PKEY_CTX_free(ctx);
1289     EVP_PKEY_free(pkey);
1290     BN_CTX_free(bn_ctx);
1291     return ret;
1292 }
1293 #endif /* OPENSSL_NO_RSA */
1294
1295
1296 int setup_tests(void)
1297 {
1298     char *config_file = NULL;
1299
1300     OPTION_CHOICE o;
1301
1302     while ((o = opt_next()) != OPT_EOF) {
1303         switch (o) {
1304         case OPT_CONFIG_FILE:
1305             config_file = opt_arg();
1306             break;
1307         case OPT_TEST_CASES:
1308            break;
1309         default:
1310         case OPT_ERR:
1311             return 0;
1312         }
1313     }
1314
1315     prov_null = OSSL_PROVIDER_load(NULL, "null");
1316     if (prov_null == NULL) {
1317         opt_printf_stderr("Failed to load null provider into default libctx\n");
1318         return 0;
1319     }
1320
1321     libctx = OPENSSL_CTX_new();
1322     if (libctx == NULL
1323         || !OPENSSL_CTX_load_config(libctx, config_file)) {
1324         opt_printf_stderr("Failed to load config\n");
1325         return 0;
1326     }
1327
1328     ADD_ALL_TESTS(cipher_enc_dec_test, OSSL_NELEM(cipher_enc_data));
1329     ADD_ALL_TESTS(aes_ccm_enc_dec_test, OSSL_NELEM(aes_ccm_enc_data));
1330     ADD_ALL_TESTS(aes_gcm_enc_dec_test, OSSL_NELEM(aes_gcm_enc_data));
1331
1332 #ifndef OPENSSL_NO_RSA
1333     ADD_ALL_TESTS(rsa_keygen_test, OSSL_NELEM(rsa_keygen_data));
1334     ADD_ALL_TESTS(rsa_siggen_test, OSSL_NELEM(rsa_siggen_data));
1335     ADD_ALL_TESTS(rsa_sigver_test, OSSL_NELEM(rsa_sigver_data));
1336     ADD_ALL_TESTS(rsa_decryption_primitive_test,
1337                   OSSL_NELEM(rsa_decrypt_prim_data));
1338 #endif /* OPENSSL_NO_RSA */
1339
1340 #ifndef OPENSSL_NO_DH
1341     ADD_ALL_TESTS(dh_safe_prime_keygen_test,
1342                   OSSL_NELEM(dh_safe_prime_keygen_data));
1343     ADD_ALL_TESTS(dh_safe_prime_keyver_test,
1344                   OSSL_NELEM(dh_safe_prime_keyver_data));
1345 #endif /* OPENSSL_NO_DH */
1346
1347 #ifndef OPENSSL_NO_DSA
1348     ADD_ALL_TESTS(dsa_keygen_test, OSSL_NELEM(dsa_keygen_data));
1349     ADD_ALL_TESTS(dsa_paramgen_test, OSSL_NELEM(dsa_paramgen_data));
1350     ADD_ALL_TESTS(dsa_pqver_test, OSSL_NELEM(dsa_pqver_data));
1351     ADD_ALL_TESTS(dsa_siggen_test, OSSL_NELEM(dsa_siggen_data));
1352     ADD_ALL_TESTS(dsa_sigver_test, OSSL_NELEM(dsa_sigver_data));
1353 #endif /* OPENSSL_NO_DSA */
1354
1355 #ifndef OPENSSL_NO_EC
1356     ADD_ALL_TESTS(ecdsa_keygen_test, OSSL_NELEM(ecdsa_keygen_data));
1357     ADD_ALL_TESTS(ecdsa_pub_verify_test, OSSL_NELEM(ecdsa_pv_data));
1358     ADD_ALL_TESTS(ecdsa_siggen_test, OSSL_NELEM(ecdsa_siggen_data));
1359     ADD_ALL_TESTS(ecdsa_sigver_test, OSSL_NELEM(ecdsa_sigver_data));
1360 #endif /* OPENSSL_NO_EC */
1361     return 1;
1362 }
1363
1364 void cleanup_tests(void)
1365 {
1366     OSSL_PROVIDER_unload(prov_null);
1367     OPENSSL_CTX_free(libctx);
1368 }