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_ex(md_ctx, NULL, digest_name, NULL,
  96                                               pkey, libctx), 1)
  97         || !TEST_int_gt(EVP_DigestSign(md_ctx, sig, &sig_len, msg, msg_len), 0))
  98         goto err;
  99     *sig_out = sig;
 100     *sig_out_len = sig_len;
 101     sig = NULL;
 102     ret = 1;
 103 err:
 104     OPENSSL_free(sig);
 105     EVP_MD_CTX_free(md_ctx);
 106     return ret;
 107 }
 108 #endif
 109
 110 #ifndef OPENSSL_NO_EC
 111 static int ecdsa_keygen_test(int id)
 112 {
 113     int ret = 0;
 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];
 120
 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_group_name(ctx, tst->curve_name))
 124         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
 125         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &priv,
 126                                         &priv_len))
 127         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &pubx,
 128                                         &pubx_len))
 129         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &puby,
 130                                         &puby_len)))
 131         goto err;
 132
 133     test_output_memory("qy", puby, puby_len);
 134     test_output_memory("qx", pubx, pubx_len);
 135     test_output_memory("d", priv, priv_len);
 136     ret = 1;
 137 err:
 138     OPENSSL_clear_free(priv, priv_len);
 139     OPENSSL_free(pubx);
 140     OPENSSL_free(puby);
 141     EVP_PKEY_free(pkey);
 142     EVP_PKEY_CTX_free(ctx);
 143     return ret;
 144 }
 145
 146 static int ecdsa_create_pkey(EVP_PKEY **pkey, const char *curve_name,
 147                              const unsigned char *pub, size_t pub_len,
 148                              int expected)
 149 {
 150     int ret = 0;
 151     EVP_PKEY_CTX *ctx = NULL;
 152     OSSL_PARAM_BLD *bld = NULL;
 153     OSSL_PARAM *params = NULL;
 154
 155     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 156         || (curve_name != NULL
 157             && !TEST_true(OSSL_PARAM_BLD_push_utf8_string(
 158                               bld, OSSL_PKEY_PARAM_GROUP_NAME, curve_name, 0) > 0))
 159         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 160                                                        OSSL_PKEY_PARAM_PUB_KEY,
 161                                                        pub, pub_len) > 0)
 162         || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 163         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
 164         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
 165         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), expected))
 166     goto err;
 167
 168     ret = 1;
 169 err:
 170     OSSL_PARAM_BLD_free_params(params);
 171     OSSL_PARAM_BLD_free(bld);
 172     EVP_PKEY_CTX_free(ctx);
 173     return ret;
 174 }
 175
 176 static int ecdsa_pub_verify_test(int id)
 177 {
 178     const struct ecdsa_pub_verify_st *tst = &ecdsa_pv_data[id];
 179
 180     int ret = 0;
 181     EVP_PKEY_CTX *key_ctx = NULL;
 182     EVP_PKEY *pkey = NULL;
 183
 184     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
 185                                      tst->pub, tst->pub_len, tst->pass)))
 186         goto err;
 187
 188     if (tst->pass) {
 189         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
 190             || !TEST_int_eq(EVP_PKEY_public_check(key_ctx), tst->pass))
 191             goto err;
 192     }
 193     ret = 1;
 194 err:
 195     EVP_PKEY_free(pkey);
 196     EVP_PKEY_CTX_free(key_ctx);
 197     return ret;
 198 }
 199
 200 /* Extract r and s  from a ecdsa signature */
 201 static int get_ecdsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
 202                                   unsigned char **r, unsigned char **s,
 203                                   size_t *rlen, size_t *slen)
 204 {
 205     int ret = 0;
 206     unsigned char *rbuf = NULL, *sbuf = NULL;
 207     size_t r1_len, s1_len;
 208     const BIGNUM *r1, *s1;
 209     ECDSA_SIG *sign = d2i_ECDSA_SIG(NULL, &sig, sig_len);
 210
 211     if (sign == NULL)
 212         return 0;
 213     r1 = ECDSA_SIG_get0_r(sign);
 214     s1 = ECDSA_SIG_get0_s(sign);
 215     if (r1 == NULL || s1 == NULL)
 216         return 0;
 217
 218     r1_len = BN_num_bytes(r1);
 219     s1_len = BN_num_bytes(s1);
 220     rbuf = OPENSSL_zalloc(r1_len);
 221     sbuf = OPENSSL_zalloc(s1_len);
 222     if (rbuf == NULL || sbuf == NULL)
 223         goto err;
 224     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
 225         goto err;
 226     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
 227         goto err;
 228     *r = rbuf;
 229     *s = sbuf;
 230     *rlen = r1_len;
 231     *slen = s1_len;
 232     ret = 1;
 233 err:
 234     if (ret == 0) {
 235         OPENSSL_free(rbuf);
 236         OPENSSL_free(sbuf);
 237     }
 238     ECDSA_SIG_free(sign);
 239     return ret;
 240 }
 241
 242 static int ecdsa_siggen_test(int id)
 243 {
 244     int ret = 0;
 245     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 246     EVP_PKEY *pkey = NULL;
 247     size_t sig_len = 0, rlen = 0, slen = 0;
 248     unsigned char *sig = NULL;
 249     unsigned char *r = NULL, *s = NULL;
 250     const struct ecdsa_siggen_st *tst = &ecdsa_siggen_data[id];
 251
 252     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
 253         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
 254         || !TEST_true(EVP_PKEY_CTX_set_group_name(ctx, tst->curve_name))
 255         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
 256         goto err;
 257
 258     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
 259                            &sig, &sig_len))
 260         || !TEST_true(get_ecdsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
 261         goto err;
 262     test_output_memory("r", r, rlen);
 263     test_output_memory("s", s, slen);
 264     ret = 1;
 265 err:
 266     OPENSSL_free(r);
 267     OPENSSL_free(s);
 268     OPENSSL_free(sig);
 269     EVP_PKEY_free(pkey);
 270     EVP_PKEY_CTX_free(key_ctx);
 271     EVP_PKEY_CTX_free(ctx);
 272     return ret;
 273 }
 274
 275 static int ecdsa_sigver_test(int id)
 276 {
 277     int ret = 0;
 278     EVP_MD_CTX *md_ctx = NULL;
 279     EVP_PKEY *pkey = NULL;
 280     ECDSA_SIG *sign = NULL;
 281     size_t sig_len;
 282     unsigned char *sig = NULL;
 283     BIGNUM *rbn = NULL, *sbn = NULL;
 284     const struct ecdsa_sigver_st *tst = &ecdsa_sigver_data[id];
 285
 286     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
 287                                      tst->pub, tst->pub_len, 1)))
 288         goto err;
 289
 290     if (!TEST_ptr(sign = ECDSA_SIG_new())
 291         || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
 292         || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
 293         || !TEST_true(ECDSA_SIG_set0(sign, rbn, sbn)))
 294         goto err;
 295     rbn = sbn = NULL;
 296
 297     ret = TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0)
 298           && TEST_ptr(md_ctx = EVP_MD_CTX_new())
 299           && TEST_true(EVP_DigestVerifyInit_ex(md_ctx, NULL, tst->digest_alg,
 300                                                NULL, pkey, libctx)
 301           && TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len,
 302                                           tst->msg, tst->msg_len), tst->pass));
 303 err:
 304     BN_free(rbn);
 305     BN_free(sbn);
 306     OPENSSL_free(sig);
 307     ECDSA_SIG_free(sign);
 308     EVP_PKEY_free(pkey);
 309     EVP_MD_CTX_free(md_ctx);
 310     return ret;
 311
 312 }
 313 #endif /* OPENSSL_NO_EC */
 314
 315 #ifndef OPENSSL_NO_DSA
 316 static int pkey_get_octet_bytes(EVP_PKEY *pkey, const char *name,
 317                                 unsigned char **out, size_t *out_len)
 318 {
 319     size_t len = 0;
 320     unsigned char *buf = NULL;
 321
 322     if (!EVP_PKEY_get_octet_string_param(pkey, name, NULL, 0, &len))
 323         goto err;
 324
 325     buf = OPENSSL_zalloc(len);
 326     if (buf == NULL)
 327         goto err;
 328
 329     if (!EVP_PKEY_get_octet_string_param(pkey, name, buf, len, out_len))
 330         goto err;
 331     *out = buf;
 332     return 1;
 333 err:
 334     OPENSSL_free(buf);
 335     return 0;
 336 }
 337
 338 static EVP_PKEY *dsa_paramgen(int L, int N)
 339 {
 340     EVP_PKEY_CTX *paramgen_ctx = NULL;
 341     EVP_PKEY *param_key = NULL;
 342
 343     if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
 344         || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
 345         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, L))
 346         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, N))
 347         || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, &param_key)))
 348         return NULL;
 349     EVP_PKEY_CTX_free(paramgen_ctx);
 350     return param_key;
 351 }
 352
 353 static EVP_PKEY *dsa_keygen(int L, int N)
 354 {
 355     EVP_PKEY *param_key = NULL, *key = NULL;
 356     EVP_PKEY_CTX *keygen_ctx = NULL;
 357
 358     if (!TEST_ptr(param_key = dsa_paramgen(L, N))
 359         || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
 360                                                              NULL))
 361         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
 362         || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
 363         goto err;
 364 err:
 365     EVP_PKEY_free(param_key);
 366     EVP_PKEY_CTX_free(keygen_ctx);
 367     return key;
 368 }
 369
 370 static int dsa_keygen_test(int id)
 371 {
 372     int ret = 0, i;
 373     EVP_PKEY_CTX *paramgen_ctx = NULL, *keygen_ctx = NULL;
 374     EVP_PKEY *param_key = NULL, *key = NULL;
 375     unsigned char *priv = NULL, *pub = NULL;
 376     size_t priv_len = 0, pub_len = 0;
 377     const struct dsa_paramgen_st *tst = &dsa_keygen_data[id];
 378
 379     if (!TEST_ptr(param_key = dsa_paramgen(tst->L, tst->N))
 380         || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
 381                                                              NULL))
 382         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0))
 383         goto err;
 384     for (i = 0; i < 2; ++i) {
 385         if (!TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0)
 386             || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PRIV_KEY,
 387                                             &priv, &priv_len))
 388             || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PUB_KEY,
 389                                             &pub, &pub_len)))
 390             goto err;
 391         test_output_memory("y", pub, pub_len);
 392         test_output_memory("x", priv, priv_len);
 393         EVP_PKEY_free(key);
 394         OPENSSL_clear_free(priv, priv_len);
 395         OPENSSL_free(pub);
 396         key = NULL;
 397         pub = priv = NULL;
 398     }
 399     ret = 1;
 400 err:
 401     OPENSSL_clear_free(priv, priv_len);
 402     OPENSSL_free(pub);
 403     EVP_PKEY_free(param_key);
 404     EVP_PKEY_free(key);
 405     EVP_PKEY_CTX_free(keygen_ctx);
 406     EVP_PKEY_CTX_free(paramgen_ctx);
 407     return ret;
 408 }
 409
 410 static int dsa_paramgen_test(int id)
 411 {
 412     int ret = 0, counter = 0;
 413     EVP_PKEY_CTX *paramgen_ctx = NULL;
 414     EVP_PKEY *param_key = NULL;
 415     unsigned char *p = NULL, *q = NULL, *seed = NULL;
 416     size_t plen = 0, qlen = 0, seedlen = 0;
 417     const struct dsa_paramgen_st *tst = &dsa_paramgen_data[id];
 418
 419     if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
 420         || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
 421         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, tst->L))
 422         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, tst->N))
 423         || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, &param_key))
 424         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P,
 425                                         &p, &plen))
 426         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q,
 427                                         &q, &qlen))
 428         || !TEST_true(pkey_get_octet_bytes(param_key, OSSL_PKEY_PARAM_FFC_SEED,
 429                                            &seed, &seedlen))
 430         || !TEST_true(EVP_PKEY_get_int_param(param_key,
 431                                              OSSL_PKEY_PARAM_FFC_PCOUNTER,
 432                                              &counter)))
 433         goto err;
 434
 435     test_output_memory("p", p, plen);
 436     test_output_memory("q", q, qlen);
 437     test_output_memory("domainSeed", seed, seedlen);
 438     test_printf_stderr("%s: %d\n", "counter", counter);
 439     ret = 1;
 440 err:
 441     OPENSSL_free(p);
 442     OPENSSL_free(q);
 443     OPENSSL_free(seed);
 444     EVP_PKEY_free(param_key);
 445     EVP_PKEY_CTX_free(paramgen_ctx);
 446     return ret;
 447 }
 448
 449 static int dsa_create_pkey(EVP_PKEY **pkey,
 450                            const unsigned char *p, size_t p_len,
 451                            const unsigned char *q, size_t q_len,
 452                            const unsigned char *g, size_t g_len,
 453                            const unsigned char *seed, size_t seed_len,
 454                            int counter,
 455                            const char *validate_type,
 456                            const unsigned char *pub, size_t pub_len,
 457                            BN_CTX *bn_ctx)
 458 {
 459     int ret = 0;
 460     EVP_PKEY_CTX *ctx = NULL;
 461     OSSL_PARAM_BLD *bld = NULL;
 462     OSSL_PARAM *params = NULL;
 463     BIGNUM *p_bn = NULL, *q_bn = NULL, *g_bn = NULL, *pub_bn = NULL;
 464
 465     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 466         || !TEST_ptr(p_bn = BN_CTX_get(bn_ctx))
 467         || !TEST_ptr(BN_bin2bn(p, p_len, p_bn))
 468         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 469                          OSSL_PKEY_PARAM_FFC_VALIDATE_TYPE,
 470                          validate_type, 0))
 471         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p_bn))
 472         || !TEST_ptr(q_bn = BN_CTX_get(bn_ctx))
 473         || !TEST_ptr(BN_bin2bn(q, q_len, q_bn))
 474         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q_bn)))
 475         goto err;
 476
 477      if (g != NULL) {
 478          if (!TEST_ptr(g_bn = BN_CTX_get(bn_ctx))
 479              || !TEST_ptr(BN_bin2bn(g, g_len, g_bn))
 480              || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
 481                                                   OSSL_PKEY_PARAM_FFC_G, g_bn)))
 482              goto err;
 483      }
 484      if (seed != NULL) {
 485          if (!TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 486                             OSSL_PKEY_PARAM_FFC_SEED, seed, seed_len)))
 487              goto err;
 488      }
 489      if (counter != -1) {
 490          if (!TEST_true(OSSL_PARAM_BLD_push_int(bld,
 491                                                 OSSL_PKEY_PARAM_FFC_PCOUNTER,
 492                                                 counter)))
 493              goto err;
 494      }
 495      if (pub != NULL) {
 496          if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
 497              || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
 498              || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
 499                                                   OSSL_PKEY_PARAM_PUB_KEY,
 500                                                   pub_bn)))
 501              goto err;
 502      }
 503      if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 504          || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
 505          || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
 506          || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
 507          goto err;
 508
 509     ret = 1;
 510 err:
 511     OSSL_PARAM_BLD_free_params(params);
 512     OSSL_PARAM_BLD_free(bld);
 513     EVP_PKEY_CTX_free(ctx);
 514     return ret;
 515 }
 516
 517 static int dsa_pqver_test(int id)
 518 {
 519     int ret = 0;
 520     BN_CTX *bn_ctx = NULL;
 521     EVP_PKEY_CTX *key_ctx = NULL;
 522     EVP_PKEY *param_key = NULL;
 523     const struct dsa_pqver_st *tst = &dsa_pqver_data[id];
 524
 525     if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
 526         || !TEST_true(dsa_create_pkey(&param_key, tst->p, tst->p_len,
 527                                       tst->q, tst->q_len, NULL, 0,
 528                                       tst->seed, tst->seed_len, tst->counter,
 529                                       OSSL_FFC_PARAM_VALIDATE_PQ,
 530                                       NULL, 0,
 531                                       bn_ctx))
 532         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
 533                                                           NULL))
 534         || !TEST_int_eq(EVP_PKEY_param_check(key_ctx), tst->pass))
 535         goto err;
 536
 537     ret = 1;
 538 err:
 539     BN_CTX_free(bn_ctx);
 540     EVP_PKEY_free(param_key);
 541     EVP_PKEY_CTX_free(key_ctx);
 542     return ret;
 543 }
 544
 545 /* Extract r and s from a dsa signature */
 546 static int get_dsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
 547                                 unsigned char **r, unsigned char **s,
 548                                 size_t *r_len, size_t *s_len)
 549 {
 550     int ret = 0;
 551     unsigned char *rbuf = NULL, *sbuf = NULL;
 552     size_t r1_len, s1_len;
 553     const BIGNUM *r1, *s1;
 554     DSA_SIG *sign = d2i_DSA_SIG(NULL, &sig, sig_len);
 555
 556     if (sign == NULL)
 557         return 0;
 558     DSA_SIG_get0(sign, &r1, &s1);
 559     if (r1 == NULL || s1 == NULL)
 560         return 0;
 561
 562     r1_len = BN_num_bytes(r1);
 563     s1_len = BN_num_bytes(s1);
 564     rbuf = OPENSSL_zalloc(r1_len);
 565     sbuf = OPENSSL_zalloc(s1_len);
 566     if (rbuf == NULL || sbuf == NULL)
 567         goto err;
 568     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
 569         goto err;
 570     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
 571         goto err;
 572     *r = rbuf;
 573     *s = sbuf;
 574     *r_len = r1_len;
 575     *s_len = s1_len;
 576     ret = 1;
 577 err:
 578     if (ret == 0) {
 579         OPENSSL_free(rbuf);
 580         OPENSSL_free(sbuf);
 581     }
 582     DSA_SIG_free(sign);
 583     return ret;
 584 }
 585
 586 static int dsa_siggen_test(int id)
 587 {
 588     int ret = 0;
 589     EVP_PKEY *pkey = NULL;
 590     unsigned char *sig = NULL, *r = NULL, *s = NULL;
 591     size_t sig_len = 0, rlen = 0, slen = 0;
 592     const struct dsa_siggen_st *tst = &dsa_siggen_data[id];
 593
 594     if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N)))
 595         goto err;
 596
 597     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
 598                            &sig, &sig_len))
 599         || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
 600         goto err;
 601     test_output_memory("r", r, rlen);
 602     test_output_memory("s", s, slen);
 603     ret = 1;
 604 err:
 605     OPENSSL_free(r);
 606     OPENSSL_free(s);
 607     OPENSSL_free(sig);
 608     EVP_PKEY_free(pkey);
 609     return ret;
 610 }
 611
 612 static int dsa_sigver_test(int id)
 613 {
 614     int ret = 0;
 615     EVP_PKEY_CTX *ctx = NULL;
 616     EVP_PKEY *pkey = NULL;
 617     DSA_SIG *sign = NULL;
 618     size_t sig_len;
 619     unsigned char *sig = NULL;
 620     BIGNUM *rbn = NULL, *sbn = NULL;
 621     EVP_MD *md = NULL;
 622     unsigned char digest[EVP_MAX_MD_SIZE];
 623     unsigned int digest_len;
 624     BN_CTX *bn_ctx = NULL;
 625     const struct dsa_sigver_st *tst  = &dsa_sigver_data[id];
 626
 627     if (!TEST_ptr(bn_ctx = BN_CTX_new())
 628         || !TEST_true(dsa_create_pkey(&pkey, tst->p, tst->p_len,
 629                                       tst->q, tst->q_len, tst->g, tst->g_len,
 630                                       NULL, 0, 0, "", tst->pub, tst->pub_len,
 631                                       bn_ctx)))
 632         goto err;
 633
 634     if (!TEST_ptr(sign = DSA_SIG_new())
 635         || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
 636         || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
 637         || !TEST_true(DSA_SIG_set0(sign, rbn, sbn)))
 638         goto err;
 639     rbn = sbn = NULL;
 640
 641     if (!TEST_ptr(md = EVP_MD_fetch(libctx, tst->digest_alg, ""))
 642         || !TEST_true(EVP_Digest(tst->msg, tst->msg_len,
 643                                  digest, &digest_len, md, NULL)))
 644         goto err;
 645
 646     if (!TEST_int_gt((sig_len = i2d_DSA_SIG(sign, &sig)), 0)
 647         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
 648         || !TEST_int_gt(EVP_PKEY_verify_init(ctx), 0)
 649         || !TEST_int_eq(EVP_PKEY_verify(ctx, sig, sig_len, digest, digest_len),
 650                         tst->pass))
 651         goto err;
 652     ret = 1;
 653 err:
 654     EVP_PKEY_CTX_free(ctx);
 655     OPENSSL_free(sig);
 656     EVP_MD_free(md);
 657     DSA_SIG_free(sign);
 658     EVP_PKEY_free(pkey);
 659     BN_free(rbn);
 660     BN_free(sbn);
 661     BN_CTX_free(bn_ctx);
 662     return ret;
 663 }
 664 #endif /* OPENSSL_NO_DSA */
 665
 666
 667 /* cipher encrypt/decrypt */
 668 static int cipher_enc(const char *alg,
 669                       const unsigned char *pt, size_t pt_len,
 670                       const unsigned char *key, size_t key_len,
 671                       const unsigned char *iv, size_t iv_len,
 672                       const unsigned char *ct, size_t ct_len,
 673                       int enc)
 674 {
 675     int ret = 0, out_len = 0, len = 0;
 676     EVP_CIPHER_CTX *ctx = NULL;
 677     EVP_CIPHER *cipher = NULL;
 678     unsigned char out[256] = { 0 };
 679
 680     TEST_note("%s : %s", alg, enc ? "encrypt" : "decrypt");
 681     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 682         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
 683         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc))
 684         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
 685         || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len))
 686         || !TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
 687         goto err;
 688     out_len += len;
 689     if (!TEST_mem_eq(out, out_len, ct, ct_len))
 690         goto err;
 691     ret = 1;
 692 err:
 693     EVP_CIPHER_free(cipher);
 694     EVP_CIPHER_CTX_free(ctx);
 695     return ret;
 696 }
 697
 698 static int cipher_enc_dec_test(int id)
 699 {
 700     const struct cipher_st *tst = &cipher_enc_data[id];
 701     const int enc = 1;
 702
 703     return TEST_true(cipher_enc(tst->alg, tst->pt, tst->pt_len,
 704                                 tst->key, tst->key_len,
 705                                 tst->iv, tst->iv_len,
 706                                 tst->ct, tst->ct_len, enc))
 707            && TEST_true(cipher_enc(tst->alg, tst->ct, tst->ct_len,
 708                                    tst->key, tst->key_len,
 709                                    tst->iv, tst->iv_len,
 710                                    tst->pt, tst->pt_len, !enc));
 711 }
 712
 713 static int aes_ccm_enc_dec(const char *alg,
 714                            const unsigned char *pt, size_t pt_len,
 715                            const unsigned char *key, size_t key_len,
 716                            const unsigned char *iv, size_t iv_len,
 717                            const unsigned char *aad, size_t aad_len,
 718                            const unsigned char *ct, size_t ct_len,
 719                            const unsigned char *tag, size_t tag_len,
 720                            int enc, int pass)
 721 {
 722     int ret = 0;
 723     EVP_CIPHER_CTX *ctx;
 724     EVP_CIPHER *cipher = NULL;
 725     int out_len, len;
 726     unsigned char out[1024];
 727
 728     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
 729               pass ? "pass" : "fail");
 730
 731     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 732         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
 733         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
 734         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
 735                                           NULL))
 736         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
 737                                           enc ? NULL : (void *)tag))
 738         || !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
 739         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
 740         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, NULL, pt_len))
 741         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
 742         || !TEST_int_eq(EVP_CipherUpdate(ctx, out, &len, pt, pt_len), pass))
 743         goto err;
 744
 745     if (!pass) {
 746         ret = 1;
 747         goto err;
 748     }
 749     if (!TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
 750         goto err;
 751     if (enc) {
 752         out_len += len;
 753         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
 754                                            tag_len, out + out_len))
 755             || !TEST_mem_eq(out, out_len, ct, ct_len)
 756             || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
 757             goto err;
 758     } else {
 759         if (!TEST_mem_eq(out, out_len + len, ct, ct_len))
 760             goto err;
 761     }
 762
 763     ret = 1;
 764 err:
 765     EVP_CIPHER_free(cipher);
 766     EVP_CIPHER_CTX_free(ctx);
 767     return ret;
 768 }
 769
 770 static int aes_ccm_enc_dec_test(int id)
 771 {
 772     const struct cipher_ccm_st *tst = &aes_ccm_enc_data[id];
 773
 774     /* The tag is on the end of the cipher text */
 775     const size_t tag_len = tst->ct_len - tst->pt_len;
 776     const size_t ct_len = tst->ct_len - tag_len;
 777     const unsigned char *tag = tst->ct + ct_len;
 778     const int enc = 1;
 779     const int pass = 1;
 780
 781     if (ct_len < 1)
 782         return 0;
 783
 784     return aes_ccm_enc_dec(tst->alg, tst->pt, tst->pt_len,
 785                            tst->key, tst->key_len,
 786                            tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 787                            tst->ct, ct_len, tag, tag_len, enc, pass)
 788             && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
 789                                tst->key, tst->key_len,
 790                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 791                                tst->pt, tst->pt_len, tag, tag_len, !enc, pass)
 792             /* test that it fails if the tag is incorrect */
 793             && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
 794                                tst->key, tst->key_len,
 795                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 796                                tst->pt, tst->pt_len,
 797                                tag - 1, tag_len, !enc, !pass);
 798 }
 799
 800 static int aes_gcm_enc_dec(const char *alg,
 801                            const unsigned char *pt, size_t pt_len,
 802                            const unsigned char *key, size_t key_len,
 803                            const unsigned char *iv, size_t iv_len,
 804                            const unsigned char *aad, size_t aad_len,
 805                            const unsigned char *ct, size_t ct_len,
 806                            const unsigned char *tag, size_t tag_len,
 807                            int enc, int pass)
 808 {
 809     int ret = 0;
 810     EVP_CIPHER_CTX *ctx;
 811     EVP_CIPHER *cipher = NULL;
 812     int out_len, len;
 813     unsigned char out[1024];
 814
 815     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
 816               pass ? "pass" : "fail");
 817
 818     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 819         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
 820         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
 821         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
 822                                           NULL)))
 823         goto err;
 824
 825     if (!enc) {
 826         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
 827                                            (void *)tag)))
 828             goto err;
 829     }
 830     /*
 831      * TODO(3.0): The IV should not be set outside the boundary as it is now.
 832      * It needs to be fed in via a dummy entropy source for this test.
 833      */
 834     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
 835         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
 836         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
 837         || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len)))
 838         goto err;
 839
 840     if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &out_len), pass))
 841         goto err;
 842     if (!pass) {
 843         ret = 1;
 844         goto err;
 845     }
 846     out_len += len;
 847     if (enc) {
 848         if (!TEST_mem_eq(out, out_len, ct, ct_len)
 849             || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
 850                                               tag_len, out + out_len))
 851             || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
 852                     goto err;
 853     } else {
 854         if (!TEST_mem_eq(out, out_len, ct, ct_len))
 855             goto err;
 856     }
 857
 858     ret = 1;
 859 err:
 860     EVP_CIPHER_free(cipher);
 861     EVP_CIPHER_CTX_free(ctx);
 862     return ret;
 863 }
 864
 865 static int aes_gcm_enc_dec_test(int id)
 866 {
 867     const struct cipher_gcm_st *tst = &aes_gcm_enc_data[id];
 868     int enc = 1;
 869     int pass = 1;
 870
 871     return aes_gcm_enc_dec(tst->alg, tst->pt, tst->pt_len,
 872                            tst->key, tst->key_len,
 873                            tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 874                            tst->ct, tst->ct_len, tst->tag, tst->tag_len,
 875                            enc, pass)
 876             && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
 877                                tst->key, tst->key_len,
 878                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 879                                tst->pt, tst->pt_len, tst->tag, tst->tag_len,
 880                                !enc, pass)
 881             /* Fail if incorrect tag passed to decrypt */
 882             && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
 883                                tst->key, tst->key_len,
 884                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
 885                                tst->pt, tst->pt_len, tst->aad, tst->tag_len,
 886                                !enc, !pass);
 887 }
 888
 889 #ifndef OPENSSL_NO_DH
 890 static int dh_create_pkey(EVP_PKEY **pkey, const char *group_name,
 891                           const unsigned char *pub, size_t pub_len,
 892                           const unsigned char *priv, size_t priv_len,
 893                           BN_CTX *bn_ctx, int pass)
 894 {
 895     int ret = 0;
 896     EVP_PKEY_CTX *ctx = NULL;
 897     OSSL_PARAM_BLD *bld = NULL;
 898     OSSL_PARAM *params = NULL;
 899     BIGNUM *pub_bn = NULL, *priv_bn = NULL;
 900
 901     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 902         || (group_name != NULL
 903             && !TEST_int_gt(OSSL_PARAM_BLD_push_utf8_string(
 904                               bld, OSSL_PKEY_PARAM_GROUP_NAME,
 905                               group_name, 0), 0)))
 906         goto err;
 907
 908     if (pub != NULL) {
 909         if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
 910             || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
 911             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
 912                                                  pub_bn)))
 913             goto err;
 914     }
 915     if (priv != NULL) {
 916         if (!TEST_ptr(priv_bn = BN_CTX_get(bn_ctx))
 917             || !TEST_ptr(BN_bin2bn(priv, priv_len, priv_bn))
 918             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
 919                                                  priv_bn)))
 920             goto err;
 921     }
 922
 923     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 924         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
 925         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
 926         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), pass))
 927     goto err;
 928
 929     ret = 1;
 930 err:
 931     OSSL_PARAM_BLD_free_params(params);
 932     OSSL_PARAM_BLD_free(bld);
 933     EVP_PKEY_CTX_free(ctx);
 934     return ret;
 935 }
 936
 937 static int dh_safe_prime_keygen_test(int id)
 938 {
 939     int ret = 0;
 940     EVP_PKEY_CTX *ctx = NULL;
 941     EVP_PKEY *pkey = NULL;
 942     unsigned char *priv = NULL;
 943     unsigned char *pub = NULL;
 944     size_t priv_len = 0, pub_len = 0;
 945     OSSL_PARAM params[2];
 946     const struct dh_safe_prime_keygen_st *tst = &dh_safe_prime_keygen_data[id];
 947
 948     params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
 949                                                  (char *)tst->group_name, 0);
 950     params[1] = OSSL_PARAM_construct_end();
 951
 952     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
 953         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
 954         || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
 955         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
 956         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
 957                                         &priv, &priv_len))
 958         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PUB_KEY,
 959                                         &pub, &pub_len)))
 960         goto err;
 961
 962     test_output_memory("x", priv, priv_len);
 963     test_output_memory("y", pub, pub_len);
 964     ret = 1;
 965 err:
 966     OPENSSL_clear_free(priv, priv_len);
 967     OPENSSL_free(pub);
 968     EVP_PKEY_free(pkey);
 969     EVP_PKEY_CTX_free(ctx);
 970     return ret;
 971 }
 972
 973 static int dh_safe_prime_keyver_test(int id)
 974 {
 975     int ret = 0;
 976     BN_CTX *bn_ctx = NULL;
 977     EVP_PKEY_CTX *key_ctx = NULL;
 978     EVP_PKEY *pkey = NULL;
 979     const struct dh_safe_prime_keyver_st *tst = &dh_safe_prime_keyver_data[id];
 980
 981     if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
 982         || !TEST_true(dh_create_pkey(&pkey, tst->group_name,
 983                                      tst->pub, tst->pub_len,
 984                                      tst->priv, tst->priv_len, bn_ctx, 1))
 985         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
 986         || !TEST_int_eq(EVP_PKEY_check(key_ctx), tst->pass))
 987         goto err;
 988
 989     ret = 1;
 990 err:
 991     EVP_PKEY_free(pkey);
 992     EVP_PKEY_CTX_free(key_ctx);
 993     BN_CTX_free(bn_ctx);
 994     return ret;
 995 }
 996 #endif /* OPENSSL_NO_DH */
 997
 998
 999 #ifndef OPENSSL_NO_RSA
1000 static EVP_PKEY *rsa_keygen(int bits)
1001 {
1002     EVP_PKEY *key = NULL;
1003     EVP_PKEY_CTX *keygen_ctx = NULL;
1004
1005     if (!TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1006         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
1007         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(keygen_ctx, bits))
1008         || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
1009         goto err;
1010 err:
1011     EVP_PKEY_CTX_free(keygen_ctx);
1012     return key;
1013 }
1014
1015 static int rsa_create_pkey(EVP_PKEY **pkey,
1016                            const unsigned char *n, size_t n_len,
1017                            const unsigned char *e, size_t e_len,
1018                            const unsigned char *d, size_t d_len,
1019                            BN_CTX *bn_ctx)
1020 {
1021     int ret = 0;
1022     EVP_PKEY_CTX *ctx = NULL;
1023     OSSL_PARAM_BLD *bld = NULL;
1024     OSSL_PARAM *params = NULL;
1025     BIGNUM *e_bn = NULL, *d_bn = NULL, *n_bn = NULL;
1026
1027     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1028         || !TEST_ptr(n_bn = BN_CTX_get(bn_ctx))
1029         || !TEST_ptr(BN_bin2bn(n, n_len, n_bn))
1030         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n_bn)))
1031         goto err;
1032
1033     if (e != NULL) {
1034         if (!TEST_ptr(e_bn = BN_CTX_get(bn_ctx))
1035             || !TEST_ptr(BN_bin2bn(e, e_len, e_bn))
1036             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E,
1037                           e_bn)))
1038             goto err;
1039     }
1040     if (d != NULL) {
1041         if (!TEST_ptr(d_bn = BN_CTX_get(bn_ctx))
1042             || !TEST_ptr(BN_bin2bn(d, d_len, d_bn))
1043             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D,
1044                           d_bn)))
1045             goto err;
1046     }
1047     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
1048         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1049         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
1050         || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
1051         goto err;
1052
1053     ret = 1;
1054 err:
1055     OSSL_PARAM_BLD_free_params(params);
1056     OSSL_PARAM_BLD_free(bld);
1057     EVP_PKEY_CTX_free(ctx);
1058     return ret;
1059 }
1060
1061 static int rsa_keygen_test(int id)
1062 {
1063     int ret = 0;
1064     EVP_PKEY_CTX *ctx = NULL;
1065     EVP_PKEY *pkey = NULL;
1066     BIGNUM *e_bn = NULL;
1067     BIGNUM *xp1_bn = NULL, *xp2_bn = NULL, *xp_bn = NULL;
1068     BIGNUM *xq1_bn = NULL, *xq2_bn = NULL, *xq_bn = NULL;
1069     unsigned char *n = NULL, *d = NULL;
1070     unsigned char *p = NULL, *p1 = NULL, *p2 = NULL;
1071     unsigned char *q = NULL, *q1 = NULL, *q2 = NULL;
1072     size_t n_len = 0, d_len = 0;
1073     size_t p_len = 0, p1_len = 0, p2_len = 0;
1074     size_t q_len = 0, q1_len = 0, q2_len = 0;
1075     OSSL_PARAM_BLD *bld = NULL;
1076     OSSL_PARAM *params = NULL;
1077     const struct rsa_keygen_st *tst = &rsa_keygen_data[id];
1078
1079     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1080         || !TEST_ptr(xp1_bn = BN_bin2bn(tst->xp1, tst->xp1_len, NULL))
1081         || !TEST_ptr(xp2_bn = BN_bin2bn(tst->xp2, tst->xp2_len, NULL))
1082         || !TEST_ptr(xp_bn = BN_bin2bn(tst->xp, tst->xp_len, NULL))
1083         || !TEST_ptr(xq1_bn = BN_bin2bn(tst->xq1, tst->xq1_len, NULL))
1084         || !TEST_ptr(xq2_bn = BN_bin2bn(tst->xq2, tst->xq2_len, NULL))
1085         || !TEST_ptr(xq_bn = BN_bin2bn(tst->xq, tst->xq_len, NULL))
1086         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP1,
1087                                              xp1_bn))
1088         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP2,
1089                                              xp2_bn))
1090         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP,
1091                                              xp_bn))
1092         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ1,
1093                                              xq1_bn))
1094         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ2,
1095                                              xq2_bn))
1096         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ,
1097                                              xq_bn))
1098         || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
1099         goto err;
1100
1101     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1102         || !TEST_ptr(e_bn = BN_bin2bn(tst->e, tst->e_len, NULL))
1103         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1104         || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
1105         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, tst->mod))
1106         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, e_bn))
1107         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
1108         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P1,
1109                                         &p1, &p1_len))
1110         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P2,
1111                                         &p2, &p2_len))
1112         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q1,
1113                                         &q1, &q1_len))
1114         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q2,
1115                                         &q2, &q2_len))
1116         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR1,
1117                                         &p, &p_len))
1118         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR2,
1119                                         &q, &q_len))
1120         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N,
1121                                         &n, &n_len))
1122         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_D,
1123                                         &d, &d_len)))
1124         goto err;
1125
1126     if (!TEST_mem_eq(tst->p1, tst->p1_len, p1, p1_len)
1127         || !TEST_mem_eq(tst->p2, tst->p2_len, p2, p2_len)
1128         || !TEST_mem_eq(tst->p, tst->p_len, p, p_len)
1129         || !TEST_mem_eq(tst->q1, tst->q1_len, q1, q1_len)
1130         || !TEST_mem_eq(tst->q2, tst->q2_len, q2, q2_len)
1131         || !TEST_mem_eq(tst->q, tst->q_len, q, q_len)
1132         || !TEST_mem_eq(tst->n, tst->n_len, n, n_len)
1133         || !TEST_mem_eq(tst->d, tst->d_len, d, d_len))
1134         goto err;
1135
1136     test_output_memory("p1", p1, p1_len);
1137     test_output_memory("p2", p2, p2_len);
1138     test_output_memory("p", p, p_len);
1139     test_output_memory("q1", q1, q1_len);
1140     test_output_memory("q2", q2, q2_len);
1141     test_output_memory("q", q, q_len);
1142     test_output_memory("n", n, n_len);
1143     test_output_memory("d", d, d_len);
1144     ret = 1;
1145 err:
1146     BN_free(xp1_bn);
1147     BN_free(xp2_bn);
1148     BN_free(xp_bn);
1149     BN_free(xq1_bn);
1150     BN_free(xq2_bn);
1151     BN_free(xq_bn);
1152     BN_free(e_bn);
1153     OPENSSL_free(p1);
1154     OPENSSL_free(p2);
1155     OPENSSL_free(q1);
1156     OPENSSL_free(q2);
1157     OPENSSL_free(p);
1158     OPENSSL_free(q);
1159     OPENSSL_free(n);
1160     OPENSSL_free(d);
1161     EVP_PKEY_free(pkey);
1162     EVP_PKEY_CTX_free(ctx);
1163     OSSL_PARAM_BLD_free_params(params);
1164     OSSL_PARAM_BLD_free(bld);
1165     return ret;
1166 }
1167
1168 static int rsa_siggen_test(int id)
1169 {
1170     int ret = 0;
1171     EVP_PKEY *pkey = NULL;
1172     unsigned char *sig = NULL, *n = NULL, *e = NULL;
1173     size_t sig_len = 0, n_len = 0, e_len = 0;
1174     OSSL_PARAM params[4], *p;
1175     const struct rsa_siggen_st *tst = &rsa_siggen_data[id];
1176
1177     TEST_note("RSA %s signature generation", tst->sig_pad_mode);
1178
1179     p = params;
1180     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1181                                             (char *)tst->sig_pad_mode, 0);
1182     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1183                                             (char *)tst->digest_alg, 0);
1184     if (tst->pss_salt_len >= 0) {
1185         int salt_len = tst->pss_salt_len;
1186
1187         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1188                                         &salt_len);
1189     }
1190     *p++ = OSSL_PARAM_construct_end();
1191
1192     if (!TEST_ptr(pkey = rsa_keygen(tst->mod))
1193        || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1194        || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1195        || !TEST_true(sig_gen(pkey, params, tst->digest_alg,
1196                              tst->msg, tst->msg_len,
1197                              &sig, &sig_len)))
1198         goto err;
1199     test_output_memory("n", n, n_len);
1200     test_output_memory("e", e, e_len);
1201     test_output_memory("sig", sig, sig_len);
1202     ret = 1;
1203 err:
1204     OPENSSL_free(n);
1205     OPENSSL_free(e);
1206     OPENSSL_free(sig);
1207     EVP_PKEY_free(pkey);
1208     return ret;
1209 }
1210
1211 static int rsa_sigver_test(int id)
1212 {
1213     int ret = 0;
1214     EVP_PKEY_CTX *pkey_ctx = NULL;
1215     EVP_PKEY *pkey = NULL;
1216     EVP_MD_CTX *md_ctx = NULL;
1217     BN_CTX *bn_ctx = NULL;
1218     OSSL_PARAM params[4], *p;
1219     const struct rsa_sigver_st *tst  = &rsa_sigver_data[id];
1220
1221     TEST_note("RSA %s Signature Verify : expected to %s ", tst->sig_pad_mode,
1222                tst->pass == PASS ? "pass" : "fail");
1223
1224     p = params;
1225     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1226                                             (char *)tst->sig_pad_mode, 0);
1227     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1228                                             (char *)tst->digest_alg, 0);
1229     if (tst->pss_salt_len >= 0) {
1230         int salt_len = tst->pss_salt_len;
1231
1232         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1233                                         &salt_len);
1234     }
1235     *p++ = OSSL_PARAM_construct_end();
1236
1237     if (!TEST_ptr(bn_ctx = BN_CTX_new())
1238         || !TEST_true(rsa_create_pkey(&pkey, tst->n, tst->n_len,
1239                                       tst->e, tst->e_len, NULL, 0, bn_ctx))
1240         || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
1241         || !TEST_true(EVP_DigestVerifyInit_ex(md_ctx, &pkey_ctx, tst->digest_alg,
1242                                               NULL, pkey, libctx)
1243         || !TEST_true(EVP_PKEY_CTX_set_params(pkey_ctx, params))
1244         || !TEST_int_eq(EVP_DigestVerify(md_ctx, tst->sig, tst->sig_len,
1245                                          tst->msg, tst->msg_len), tst->pass)))
1246         goto err;
1247     ret = 1;
1248 err:
1249     EVP_PKEY_free(pkey);
1250     BN_CTX_free(bn_ctx);
1251     EVP_MD_CTX_free(md_ctx);
1252     return ret;
1253 }
1254
1255 static int rsa_decryption_primitive_test(int id)
1256 {
1257     int ret = 0;
1258     EVP_PKEY_CTX *ctx = NULL;
1259     EVP_PKEY *pkey = NULL;
1260     unsigned char pt[2048];
1261     size_t pt_len = sizeof(pt);
1262     unsigned char *n = NULL, *e = NULL;
1263     size_t n_len = 0, e_len = 0;
1264     BN_CTX *bn_ctx = NULL;
1265     const struct rsa_decrypt_prim_st *tst  = &rsa_decrypt_prim_data[id];
1266
1267     if (!TEST_ptr(pkey = rsa_keygen(2048))
1268         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1269         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1270         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
1271         || !TEST_int_gt(EVP_PKEY_decrypt_init(ctx), 0)
1272         || !TEST_int_gt(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING), 0))
1273         goto err;
1274
1275     test_output_memory("n", n, n_len);
1276     test_output_memory("e", e, e_len);
1277     if (!EVP_PKEY_decrypt(ctx, pt, &pt_len, tst->ct, tst->ct_len))
1278         TEST_note("Decryption Failed");
1279     else
1280         test_output_memory("pt", pt, pt_len);
1281     ret = 1;
1282 err:
1283     OPENSSL_free(n);
1284     OPENSSL_free(e);
1285     EVP_PKEY_CTX_free(ctx);
1286     EVP_PKEY_free(pkey);
1287     BN_CTX_free(bn_ctx);
1288     return ret;
1289 }
1290 #endif /* OPENSSL_NO_RSA */
1291
1292
1293 int setup_tests(void)
1294 {
1295     char *config_file = NULL;
1296
1297     OPTION_CHOICE o;
1298
1299     while ((o = opt_next()) != OPT_EOF) {
1300         switch (o) {
1301         case OPT_CONFIG_FILE:
1302             config_file = opt_arg();
1303             break;
1304         case OPT_TEST_CASES:
1305            break;
1306         default:
1307         case OPT_ERR:
1308             return 0;
1309         }
1310     }
1311
1312     prov_null = OSSL_PROVIDER_load(NULL, "null");
1313     if (prov_null == NULL) {
1314         opt_printf_stderr("Failed to load null provider into default libctx\n");
1315         return 0;
1316     }
1317
1318     libctx = OPENSSL_CTX_new();
1319     if (libctx == NULL
1320         || !OPENSSL_CTX_load_config(libctx, config_file)) {
1321         opt_printf_stderr("Failed to load config\n");
1322         return 0;
1323     }
1324
1325     ADD_ALL_TESTS(cipher_enc_dec_test, OSSL_NELEM(cipher_enc_data));
1326     ADD_ALL_TESTS(aes_ccm_enc_dec_test, OSSL_NELEM(aes_ccm_enc_data));
1327     ADD_ALL_TESTS(aes_gcm_enc_dec_test, OSSL_NELEM(aes_gcm_enc_data));
1328
1329 #ifndef OPENSSL_NO_RSA
1330     ADD_ALL_TESTS(rsa_keygen_test, OSSL_NELEM(rsa_keygen_data));
1331     ADD_ALL_TESTS(rsa_siggen_test, OSSL_NELEM(rsa_siggen_data));
1332     ADD_ALL_TESTS(rsa_sigver_test, OSSL_NELEM(rsa_sigver_data));
1333     ADD_ALL_TESTS(rsa_decryption_primitive_test,
1334                   OSSL_NELEM(rsa_decrypt_prim_data));
1335 #endif /* OPENSSL_NO_RSA */
1336
1337 #ifndef OPENSSL_NO_DH
1338     ADD_ALL_TESTS(dh_safe_prime_keygen_test,
1339                   OSSL_NELEM(dh_safe_prime_keygen_data));
1340     ADD_ALL_TESTS(dh_safe_prime_keyver_test,
1341                   OSSL_NELEM(dh_safe_prime_keyver_data));
1342 #endif /* OPENSSL_NO_DH */
1343
1344 #ifndef OPENSSL_NO_DSA
1345     ADD_ALL_TESTS(dsa_keygen_test, OSSL_NELEM(dsa_keygen_data));
1346     ADD_ALL_TESTS(dsa_paramgen_test, OSSL_NELEM(dsa_paramgen_data));
1347     ADD_ALL_TESTS(dsa_pqver_test, OSSL_NELEM(dsa_pqver_data));
1348     ADD_ALL_TESTS(dsa_siggen_test, OSSL_NELEM(dsa_siggen_data));
1349     ADD_ALL_TESTS(dsa_sigver_test, OSSL_NELEM(dsa_sigver_data));
1350 #endif /* OPENSSL_NO_DSA */
1351
1352 #ifndef OPENSSL_NO_EC
1353     ADD_ALL_TESTS(ecdsa_keygen_test, OSSL_NELEM(ecdsa_keygen_data));
1354     ADD_ALL_TESTS(ecdsa_pub_verify_test, OSSL_NELEM(ecdsa_pv_data));
1355     ADD_ALL_TESTS(ecdsa_siggen_test, OSSL_NELEM(ecdsa_siggen_data));
1356     ADD_ALL_TESTS(ecdsa_sigver_test, OSSL_NELEM(ecdsa_sigver_data));
1357 #endif /* OPENSSL_NO_EC */
1358     return 1;
1359 }
1360
1361 void cleanup_tests(void)
1362 {
1363     OSSL_PROVIDER_unload(prov_null);
1364     OPENSSL_CTX_free(libctx);
1365 }