test/endecode_test.c

   1 /*
   2  * Copyright 2020-2021 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 #include <string.h>
  11 #include <openssl/core_dispatch.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/pem.h>
  14 #include <openssl/rsa.h>
  15 #include <openssl/x509.h>
  16 #include <openssl/core_names.h>
  17 #include <openssl/params.h>
  18 #include <openssl/param_build.h>
  19 #include <openssl/encoder.h>
  20 #include <openssl/decoder.h>
  21
  22 #include "internal/cryptlib.h"   /* ossl_assert */
  23 #include "crypto/pem.h"          /* For PVK and "blob" PEM headers */
  24 #include "crypto/evp.h"          /* For evp_pkey_is_provided() */
  25
  26 #include "helpers/predefined_dhparams.h"
  27 #include "testutil.h"
  28
  29 /* Extended test macros to allow passing file & line number */
  30 #define TEST_FL_ptr(a)               test_ptr(file, line, #a, a)
  31 #define TEST_FL_mem_eq(a, m, b, n)   test_mem_eq(file, line, #a, #b, a, m, b, n)
  32 #define TEST_FL_strn_eq(a, b, n)     test_strn_eq(file, line, #a, #b, a, n, b, n)
  33 #define TEST_FL_strn2_eq(a, m, b, n) test_strn_eq(file, line, #a, #b, a, m, b, n)
  34 #define TEST_FL_int_eq(a, b)         test_int_eq(file, line, #a, #b, a, b)
  35 #define TEST_FL_int_ge(a, b)         test_int_ge(file, line, #a, #b, a, b)
  36 #define TEST_FL_int_gt(a, b)         test_int_gt(file, line, #a, #b, a, b)
  37 #define TEST_FL_long_gt(a, b)        test_long_gt(file, line, #a, #b, a, b)
  38 #define TEST_FL_true(a)              test_true(file, line, #a, (a) != 0)
  39
  40 #if defined(OPENSSL_NO_DH) && defined(OPENSSL_NO_DSA) && defined(OPENSSL_NO_EC)
  41 # define OPENSSL_NO_KEYPARAMS
  42 #endif
  43
  44 static int default_libctx = 1;
  45 static int is_fips = 0;
  46
  47 static OSSL_LIB_CTX *testctx = NULL;
  48 static OSSL_LIB_CTX *keyctx = NULL;
  49 static char *testpropq = NULL;
  50
  51 static OSSL_PROVIDER *nullprov = NULL;
  52 static OSSL_PROVIDER *deflprov = NULL;
  53 static OSSL_PROVIDER *keyprov = NULL;
  54
  55 #ifndef OPENSSL_NO_EC
  56 static BN_CTX *bnctx = NULL;
  57 static OSSL_PARAM_BLD *bld_prime_nc = NULL;
  58 static OSSL_PARAM_BLD *bld_prime = NULL;
  59 static OSSL_PARAM *ec_explicit_prime_params_nc = NULL;
  60 static OSSL_PARAM *ec_explicit_prime_params_explicit = NULL;
  61
  62 # ifndef OPENSSL_NO_EC2M
  63 static OSSL_PARAM_BLD *bld_tri_nc = NULL;
  64 static OSSL_PARAM_BLD *bld_tri = NULL;
  65 static OSSL_PARAM *ec_explicit_tri_params_nc = NULL;
  66 static OSSL_PARAM *ec_explicit_tri_params_explicit = NULL;
  67 # endif
  68 #endif
  69
  70 #ifndef OPENSSL_NO_KEYPARAMS
  71 static EVP_PKEY *make_template(const char *type, OSSL_PARAM *genparams)
  72 {
  73     EVP_PKEY *pkey = NULL;
  74     EVP_PKEY_CTX *ctx = NULL;
  75
  76 # ifndef OPENSSL_NO_DH
  77     /*
  78      * Use 512-bit DH(X) keys with predetermined parameters for efficiency,
  79      * for testing only. Use a minimum key size of 2048 for security purposes.
  80      */
  81     if (strcmp(type, "DH") == 0)
  82         return get_dh512(keyctx);
  83
  84     if (strcmp(type, "X9.42 DH") == 0)
  85         return get_dhx512(keyctx);
  86 # endif
  87
  88     /*
  89      * No real need to check the errors other than for the cascade
  90      * effect.  |pkey| will simply remain NULL if something goes wrong.
  91      */
  92     (void)((ctx = EVP_PKEY_CTX_new_from_name(keyctx, type, testpropq)) != NULL
  93            && EVP_PKEY_paramgen_init(ctx) > 0
  94            && (genparams == NULL
  95                || EVP_PKEY_CTX_set_params(ctx, genparams) > 0)
  96            && EVP_PKEY_generate(ctx, &pkey) > 0);
  97     EVP_PKEY_CTX_free(ctx);
  98
  99     return pkey;
 100 }
 101 #endif
 102
 103 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
 104 static EVP_PKEY *make_key(const char *type, EVP_PKEY *template,
 105                           OSSL_PARAM *genparams)
 106 {
 107     EVP_PKEY *pkey = NULL;
 108     EVP_PKEY_CTX *ctx =
 109         template != NULL
 110         ? EVP_PKEY_CTX_new_from_pkey(keyctx, template, testpropq)
 111         : EVP_PKEY_CTX_new_from_name(keyctx, type, testpropq);
 112
 113     /*
 114      * No real need to check the errors other than for the cascade
 115      * effect.  |pkey| will simply remain NULL if something goes wrong.
 116      */
 117     (void)(ctx != NULL
 118            && EVP_PKEY_keygen_init(ctx) > 0
 119            && (genparams == NULL
 120                || EVP_PKEY_CTX_set_params(ctx, genparams) > 0)
 121            && EVP_PKEY_keygen(ctx, &pkey) > 0);
 122     EVP_PKEY_CTX_free(ctx);
 123     return pkey;
 124 }
 125 #endif
 126
 127 /* Main test driver */
 128
 129 typedef int (encoder)(const char *file, const int line,
 130                       void **encoded, long *encoded_len,
 131                       void *object, int selection,
 132                       const char *output_type, const char *output_structure,
 133                       const char *pass, const char *pcipher);
 134 typedef int (decoder)(const char *file, const int line,
 135                       void **object, void *encoded, long encoded_len,
 136                       const char *input_type, const char *structure_type,
 137                       const char *keytype, int selection, const char *pass);
 138 typedef int (tester)(const char *file, const int line,
 139                      const void *data1, size_t data1_len,
 140                      const void *data2, size_t data2_len);
 141 typedef int (checker)(const char *file, const int line,
 142                       const char *type, const void *data, size_t data_len);
 143 typedef void (dumper)(const char *label, const void *data, size_t data_len);
 144
 145 #define FLAG_DECODE_WITH_TYPE   0x0001
 146
 147 static int test_encode_decode(const char *file, const int line,
 148                               const char *type, EVP_PKEY *pkey,
 149                               int selection, const char *output_type,
 150                               const char *output_structure,
 151                               const char *pass, const char *pcipher,
 152                               encoder *encode_cb, decoder *decode_cb,
 153                               tester *test_cb, checker *check_cb,
 154                               dumper *dump_cb, int flags)
 155 {
 156     void *encoded = NULL;
 157     long encoded_len = 0;
 158     EVP_PKEY *pkey2 = NULL;
 159     void *encoded2 = NULL;
 160     long encoded2_len = 0;
 161     int ok = 0;
 162
 163     /*
 164      * Encode |pkey|, decode the result into |pkey2|, and finish off by
 165      * encoding |pkey2| as well.  That last encoding is for checking and
 166      * dumping purposes.
 167      */
 168     if (!TEST_true(encode_cb(file, line, &encoded, &encoded_len, pkey, selection,
 169                              output_type, output_structure, pass, pcipher))
 170         || !TEST_true(check_cb(file, line, type, encoded, encoded_len))
 171         || !TEST_true(decode_cb(file, line, (void **)&pkey2, encoded, encoded_len,
 172                                 output_type, output_structure,
 173                                 (flags & FLAG_DECODE_WITH_TYPE ? type : NULL),
 174                                 selection, pass))
 175         || !TEST_true(encode_cb(file, line, &encoded2, &encoded2_len, pkey2, selection,
 176                                 output_type, output_structure, pass, pcipher)))
 177         goto end;
 178
 179     if (selection == OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) {
 180         if (!TEST_int_eq(EVP_PKEY_parameters_eq(pkey, pkey2), 1))
 181             goto end;
 182     } else {
 183         if (!TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 1))
 184             goto end;
 185     }
 186
 187     /*
 188      * Double check the encoding, but only for unprotected keys,
 189      * as protected keys have a random component, which makes the output
 190      * differ.
 191      */
 192     if ((pass == NULL && pcipher == NULL)
 193         && !test_cb(file, line, encoded, encoded_len, encoded2, encoded2_len))
 194         goto end;
 195
 196     ok = 1;
 197  end:
 198     if (!ok) {
 199         if (encoded != NULL && encoded_len != 0)
 200             dump_cb("|pkey| encoded", encoded, encoded_len);
 201         if (encoded2 != NULL && encoded2_len != 0)
 202             dump_cb("|pkey2| encoded", encoded2, encoded2_len);
 203     }
 204
 205     OPENSSL_free(encoded);
 206     OPENSSL_free(encoded2);
 207     EVP_PKEY_free(pkey2);
 208     return ok;
 209 }
 210
 211 /* Encoding and decoding methods */
 212
 213 static int encode_EVP_PKEY_prov(const char *file, const int line,
 214                                 void **encoded, long *encoded_len,
 215                                 void *object, int selection,
 216                                 const char *output_type,
 217                                 const char *output_structure,
 218                                 const char *pass, const char *pcipher)
 219 {
 220     EVP_PKEY *pkey = object;
 221     OSSL_ENCODER_CTX *ectx = NULL;
 222     BIO *mem_ser = NULL;
 223     BUF_MEM *mem_buf = NULL;
 224     const unsigned char *upass = (const unsigned char *)pass;
 225     int ok = 0;
 226
 227     if (!TEST_FL_ptr(ectx = OSSL_ENCODER_CTX_new_for_pkey(pkey, selection,
 228                                                        output_type,
 229                                                        output_structure,
 230                                                        testpropq))
 231         || !TEST_FL_int_gt(OSSL_ENCODER_CTX_get_num_encoders(ectx), 0)
 232         || (pass != NULL
 233             && !TEST_FL_true(OSSL_ENCODER_CTX_set_passphrase(ectx, upass,
 234                                                           strlen(pass))))
 235         || (pcipher != NULL
 236             && !TEST_FL_true(OSSL_ENCODER_CTX_set_cipher(ectx, pcipher, NULL)))
 237         || !TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
 238         || !TEST_FL_true(OSSL_ENCODER_to_bio(ectx, mem_ser))
 239         || !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
 240         || !TEST_FL_ptr(*encoded = mem_buf->data)
 241         || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
 242         goto end;
 243
 244     /* Detach the encoded output */
 245     mem_buf->data = NULL;
 246     mem_buf->length = 0;
 247     ok = 1;
 248  end:
 249     BIO_free(mem_ser);
 250     OSSL_ENCODER_CTX_free(ectx);
 251     return ok;
 252 }
 253
 254 static int decode_EVP_PKEY_prov(const char *file, const int line,
 255                                 void **object, void *encoded, long encoded_len,
 256                                 const char *input_type,
 257                                 const char *structure_type,
 258                                 const char *keytype, int selection,
 259                                 const char *pass)
 260 {
 261     EVP_PKEY *pkey = NULL, *testpkey = NULL;
 262     OSSL_DECODER_CTX *dctx = NULL;
 263     BIO *encoded_bio = NULL;
 264     const unsigned char *upass = (const unsigned char *)pass;
 265     int ok = 0;
 266     int i;
 267     const char *badtype;
 268
 269     if (strcmp(input_type, "DER") == 0)
 270         badtype = "PEM";
 271     else
 272         badtype = "DER";
 273
 274     if (!TEST_FL_ptr(encoded_bio = BIO_new_mem_buf(encoded, encoded_len)))
 275         goto end;
 276
 277     /*
 278      * We attempt the decode 3 times. The first time we provide the expected
 279      * starting input type. The second time we provide NULL for the starting
 280      * type. The third time we provide a bad starting input type.
 281      * The bad starting input type should fail. The other two should succeed
 282      * and produce the same result.
 283      */
 284     for (i = 0; i < 3; i++) {
 285         const char *testtype = (i == 0) ? input_type
 286                                         : ((i == 1) ? NULL : badtype);
 287
 288         if (!TEST_FL_ptr(dctx = OSSL_DECODER_CTX_new_for_pkey(&testpkey,
 289                                                            testtype,
 290                                                            structure_type,
 291                                                            keytype,
 292                                                            selection,
 293                                                            testctx, testpropq))
 294             || (pass != NULL
 295                 && !OSSL_DECODER_CTX_set_passphrase(dctx, upass, strlen(pass)))
 296             || !TEST_FL_int_gt(BIO_reset(encoded_bio), 0)
 297                /* We expect to fail when using a bad input type */
 298             || !TEST_FL_int_eq(OSSL_DECODER_from_bio(dctx, encoded_bio),
 299                             (i == 2) ? 0 : 1))
 300             goto end;
 301         OSSL_DECODER_CTX_free(dctx);
 302         dctx = NULL;
 303
 304         if (i == 0) {
 305             pkey = testpkey;
 306             testpkey = NULL;
 307         } else if (i == 1) {
 308             if (selection == OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) {
 309                 if (!TEST_FL_int_eq(EVP_PKEY_parameters_eq(pkey, testpkey), 1))
 310                     goto end;
 311             } else {
 312                 if (!TEST_FL_int_eq(EVP_PKEY_eq(pkey, testpkey), 1))
 313                     goto end;
 314             }
 315         }
 316     }
 317     ok = 1;
 318     *object = pkey;
 319     pkey = NULL;
 320
 321  end:
 322     EVP_PKEY_free(pkey);
 323     EVP_PKEY_free(testpkey);
 324     BIO_free(encoded_bio);
 325     OSSL_DECODER_CTX_free(dctx);
 326     return ok;
 327 }
 328
 329 static int encode_EVP_PKEY_legacy_PEM(const char *file, const int line,
 330                                       void **encoded, long *encoded_len,
 331                                       void *object, ossl_unused int selection,
 332                                       ossl_unused const char *output_type,
 333                                       ossl_unused const char *output_structure,
 334                                       const char *pass, const char *pcipher)
 335 {
 336     EVP_PKEY *pkey = object;
 337     EVP_CIPHER *cipher = NULL;
 338     BIO *mem_ser = NULL;
 339     BUF_MEM *mem_buf = NULL;
 340     const unsigned char *upass = (const unsigned char *)pass;
 341     size_t passlen = 0;
 342     int ok = 0;
 343
 344     if (pcipher != NULL && pass != NULL) {
 345         passlen = strlen(pass);
 346         if (!TEST_FL_ptr(cipher = EVP_CIPHER_fetch(testctx, pcipher, testpropq)))
 347             goto end;
 348     }
 349     if (!TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
 350         || !TEST_FL_true(PEM_write_bio_PrivateKey_traditional(mem_ser, pkey,
 351                                                            cipher,
 352                                                            upass, passlen,
 353                                                            NULL, NULL))
 354         || !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
 355         || !TEST_FL_ptr(*encoded = mem_buf->data)
 356         || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
 357         goto end;
 358
 359     /* Detach the encoded output */
 360     mem_buf->data = NULL;
 361     mem_buf->length = 0;
 362     ok = 1;
 363  end:
 364     BIO_free(mem_ser);
 365     EVP_CIPHER_free(cipher);
 366     return ok;
 367 }
 368
 369 static int encode_EVP_PKEY_MSBLOB(const char *file, const int line,
 370                                   void **encoded, long *encoded_len,
 371                                   void *object, int selection,
 372                                   ossl_unused const char *output_type,
 373                                   ossl_unused const char *output_structure,
 374                                   ossl_unused const char *pass,
 375                                   ossl_unused const char *pcipher)
 376 {
 377     EVP_PKEY *pkey = object;
 378     BIO *mem_ser = NULL;
 379     BUF_MEM *mem_buf = NULL;
 380     int ok = 0;
 381
 382     if (!TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem())))
 383         goto end;
 384
 385     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
 386         if (!TEST_FL_int_ge(i2b_PrivateKey_bio(mem_ser, pkey), 0))
 387             goto end;
 388     } else {
 389         if (!TEST_FL_int_ge(i2b_PublicKey_bio(mem_ser, pkey), 0))
 390             goto end;
 391     }
 392
 393     if (!TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
 394         || !TEST_FL_ptr(*encoded = mem_buf->data)
 395         || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
 396         goto end;
 397
 398     /* Detach the encoded output */
 399     mem_buf->data = NULL;
 400     mem_buf->length = 0;
 401     ok = 1;
 402  end:
 403     BIO_free(mem_ser);
 404     return ok;
 405 }
 406
 407 static pem_password_cb pass_pw;
 408 static int pass_pw(char *buf, int size, int rwflag, void *userdata)
 409 {
 410     OPENSSL_strlcpy(buf, userdata, size);
 411     return strlen(userdata);
 412 }
 413
 414 static int encode_EVP_PKEY_PVK(const char *file, const int line,
 415                                void **encoded, long *encoded_len,
 416                                void *object, int selection,
 417                                ossl_unused const char *output_type,
 418                                ossl_unused const char *output_structure,
 419                                const char *pass,
 420                                ossl_unused const char *pcipher)
 421 {
 422     EVP_PKEY *pkey = object;
 423     BIO *mem_ser = NULL;
 424     BUF_MEM *mem_buf = NULL;
 425     int enc = (pass != NULL);
 426     int ok = 0;
 427
 428     if (!TEST_FL_true(ossl_assert((selection
 429                                 & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0))
 430         || !TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
 431         || !TEST_FL_int_ge(i2b_PVK_bio_ex(mem_ser, pkey, enc,
 432                                           pass_pw, (void *)pass, testctx, testpropq), 0)
 433         || !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
 434         || !TEST_FL_ptr(*encoded = mem_buf->data)
 435         || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
 436         goto end;
 437
 438     /* Detach the encoded output */
 439     mem_buf->data = NULL;
 440     mem_buf->length = 0;
 441     ok = 1;
 442  end:
 443     BIO_free(mem_ser);
 444     return ok;
 445 }
 446
 447 static int test_text(const char *file, const int line,
 448                      const void *data1, size_t data1_len,
 449                      const void *data2, size_t data2_len)
 450 {
 451     return TEST_FL_strn2_eq(data1, data1_len, data2, data2_len);
 452 }
 453
 454 static int test_mem(const char *file, const int line,
 455                     const void *data1, size_t data1_len,
 456                     const void *data2, size_t data2_len)
 457 {
 458     return TEST_FL_mem_eq(data1, data1_len, data2, data2_len);
 459 }
 460
 461 /* Test cases and their dumpers / checkers */
 462
 463 static void collect_name(const char *name, void *arg)
 464 {
 465     char **namelist = arg;
 466     char *new_namelist;
 467     size_t space;
 468
 469     space = strlen(name);
 470     if (*namelist != NULL)
 471         space += strlen(*namelist) + 2 /* for comma and space */;
 472     space++; /* for terminating null byte */
 473
 474     new_namelist = OPENSSL_realloc(*namelist, space);
 475     if (new_namelist == NULL)
 476         return;
 477     if (*namelist != NULL) {
 478         strcat(new_namelist, ", ");
 479         strcat(new_namelist, name);
 480     } else {
 481         strcpy(new_namelist, name);
 482     }
 483     *namelist = new_namelist;
 484 }
 485
 486 static void dump_der(const char *label, const void *data, size_t data_len)
 487 {
 488     test_output_memory(label, data, data_len);
 489 }
 490
 491 static void dump_pem(const char *label, const void *data, size_t data_len)
 492 {
 493     test_output_string(label, data, data_len - 1);
 494 }
 495
 496 static int check_unprotected_PKCS8_DER(const char *file, const int line,
 497                                        const char *type,
 498                                        const void *data, size_t data_len)
 499 {
 500     const unsigned char *datap = data;
 501     PKCS8_PRIV_KEY_INFO *p8inf =
 502         d2i_PKCS8_PRIV_KEY_INFO(NULL, &datap, data_len);
 503     int ok = 0;
 504
 505     if (TEST_FL_ptr(p8inf)) {
 506         EVP_PKEY *pkey = EVP_PKCS82PKEY_ex(p8inf, testctx, testpropq);
 507         char *namelist = NULL;
 508
 509         if (TEST_FL_ptr(pkey)) {
 510             if (!(ok = TEST_FL_true(EVP_PKEY_is_a(pkey, type)))) {
 511                 EVP_PKEY_type_names_do_all(pkey, collect_name, &namelist);
 512                 if (namelist != NULL)
 513                     TEST_note("%s isn't any of %s", type, namelist);
 514                 OPENSSL_free(namelist);
 515             }
 516             ok = ok && TEST_FL_true(evp_pkey_is_provided(pkey));
 517             EVP_PKEY_free(pkey);
 518         }
 519     }
 520     PKCS8_PRIV_KEY_INFO_free(p8inf);
 521     return ok;
 522 }
 523
 524 static int test_unprotected_via_DER(const char *type, EVP_PKEY *key)
 525 {
 526     return test_encode_decode(__FILE__, __LINE__, type, key,
 527                               OSSL_KEYMGMT_SELECT_KEYPAIR
 528                               | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
 529                               "DER", "PrivateKeyInfo", NULL, NULL,
 530                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 531                               test_mem, check_unprotected_PKCS8_DER,
 532                               dump_der, 0);
 533 }
 534
 535 static int check_unprotected_PKCS8_PEM(const char *file, const int line,
 536                                        const char *type,
 537                                        const void *data, size_t data_len)
 538 {
 539     static const char expected_pem_header[] =
 540         "-----BEGIN " PEM_STRING_PKCS8INF "-----";
 541
 542     return TEST_FL_strn_eq(data, expected_pem_header,
 543                         sizeof(expected_pem_header) - 1);
 544 }
 545
 546 static int test_unprotected_via_PEM(const char *type, EVP_PKEY *key)
 547 {
 548     return test_encode_decode(__FILE__, __LINE__, type, key,
 549                               OSSL_KEYMGMT_SELECT_KEYPAIR
 550                               | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
 551                               "PEM", "PrivateKeyInfo", NULL, NULL,
 552                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 553                               test_text, check_unprotected_PKCS8_PEM,
 554                               dump_pem, 0);
 555 }
 556
 557 #ifndef OPENSSL_NO_KEYPARAMS
 558 static int check_params_DER(const char *file, const int line,
 559                             const char *type, const void *data, size_t data_len)
 560 {
 561     const unsigned char *datap = data;
 562     int ok = 0;
 563     int itype = NID_undef;
 564     EVP_PKEY *pkey = NULL;
 565
 566     if (strcmp(type, "DH") == 0)
 567         itype = EVP_PKEY_DH;
 568     else if (strcmp(type, "X9.42 DH") == 0)
 569         itype = EVP_PKEY_DHX;
 570     else if (strcmp(type, "DSA") ==  0)
 571         itype = EVP_PKEY_DSA;
 572     else if (strcmp(type, "EC") ==  0)
 573         itype = EVP_PKEY_EC;
 574
 575     if (itype != NID_undef) {
 576         pkey = d2i_KeyParams(itype, NULL, &datap, data_len);
 577         ok = (pkey != NULL);
 578         EVP_PKEY_free(pkey);
 579     }
 580
 581     return ok;
 582 }
 583
 584 static int check_params_PEM(const char *file, const int line,
 585                             const char *type,
 586                             const void *data, size_t data_len)
 587 {
 588     static char expected_pem_header[80];
 589
 590     return
 591         TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
 592                                  sizeof(expected_pem_header),
 593                                  "-----BEGIN %s PARAMETERS-----", type), 0)
 594         && TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header));
 595 }
 596
 597 static int test_params_via_DER(const char *type, EVP_PKEY *key)
 598 {
 599     return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 600                               "DER", "type-specific", NULL, NULL,
 601                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 602                               test_mem, check_params_DER,
 603                               dump_der, FLAG_DECODE_WITH_TYPE);
 604 }
 605
 606 static int test_params_via_PEM(const char *type, EVP_PKEY *key)
 607 {
 608     return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 609                               "PEM", "type-specific", NULL, NULL,
 610                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 611                               test_text, check_params_PEM,
 612                               dump_pem, 0);
 613 }
 614 #endif /* !OPENSSL_NO_KEYPARAMS */
 615
 616 static int check_unprotected_legacy_PEM(const char *file, const int line,
 617                                         const char *type,
 618                                         const void *data, size_t data_len)
 619 {
 620     static char expected_pem_header[80];
 621
 622     return
 623         TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
 624                                  sizeof(expected_pem_header),
 625                                  "-----BEGIN %s PRIVATE KEY-----", type), 0)
 626         && TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header));
 627 }
 628
 629 static int test_unprotected_via_legacy_PEM(const char *type, EVP_PKEY *key)
 630 {
 631     if (!default_libctx || is_fips)
 632         return TEST_skip("Test not available if using a non-default library context or FIPS provider");
 633
 634     return test_encode_decode(__FILE__, __LINE__, type, key,
 635                               OSSL_KEYMGMT_SELECT_KEYPAIR
 636                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 637                               "PEM", "type-specific", NULL, NULL,
 638                               encode_EVP_PKEY_legacy_PEM, decode_EVP_PKEY_prov,
 639                               test_text, check_unprotected_legacy_PEM,
 640                               dump_pem, 0);
 641 }
 642
 643 static int check_MSBLOB(const char *file, const int line,
 644                         const char *type, const void *data, size_t data_len)
 645 {
 646     const unsigned char *datap = data;
 647     EVP_PKEY *pkey = b2i_PrivateKey(&datap, data_len);
 648     int ok = TEST_FL_ptr(pkey);
 649
 650     EVP_PKEY_free(pkey);
 651     return ok;
 652 }
 653
 654 static int test_unprotected_via_MSBLOB(const char *type, EVP_PKEY *key)
 655 {
 656     return test_encode_decode(__FILE__, __LINE__, type, key,
 657                               OSSL_KEYMGMT_SELECT_KEYPAIR
 658                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 659                               "MSBLOB", NULL, NULL, NULL,
 660                               encode_EVP_PKEY_MSBLOB, decode_EVP_PKEY_prov,
 661                               test_mem, check_MSBLOB,
 662                               dump_der, 0);
 663 }
 664
 665 static int check_PVK(const char *file, const int line,
 666                      const char *type, const void *data, size_t data_len)
 667 {
 668     const unsigned char *in = data;
 669     unsigned int saltlen = 0, keylen = 0;
 670     int ok = ossl_do_PVK_header(&in, data_len, 0, &saltlen, &keylen);
 671
 672     return ok;
 673 }
 674
 675 static int test_unprotected_via_PVK(const char *type, EVP_PKEY *key)
 676 {
 677     return test_encode_decode(__FILE__, __LINE__, type, key,
 678                               OSSL_KEYMGMT_SELECT_KEYPAIR
 679                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 680                               "PVK", NULL, NULL, NULL,
 681                               encode_EVP_PKEY_PVK, decode_EVP_PKEY_prov,
 682                               test_mem, check_PVK,
 683                               dump_der, 0);
 684 }
 685
 686 static const char *pass_cipher = "AES-256-CBC";
 687 static const char *pass = "the holy handgrenade of antioch";
 688
 689 static int check_protected_PKCS8_DER(const char *file, const int line,
 690                                      const char *type,
 691                                      const void *data, size_t data_len)
 692 {
 693     const unsigned char *datap = data;
 694     X509_SIG *p8 = d2i_X509_SIG(NULL, &datap, data_len);
 695     int ok = TEST_FL_ptr(p8);
 696
 697     X509_SIG_free(p8);
 698     return ok;
 699 }
 700
 701 static int test_protected_via_DER(const char *type, EVP_PKEY *key)
 702 {
 703     return test_encode_decode(__FILE__, __LINE__, type, key,
 704                               OSSL_KEYMGMT_SELECT_KEYPAIR
 705                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 706                               "DER", "PrivateKeyInfo",
 707                               pass, pass_cipher,
 708                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 709                               test_mem, check_protected_PKCS8_DER,
 710                               dump_der, 0);
 711 }
 712
 713 static int check_protected_PKCS8_PEM(const char *file, const int line,
 714                                      const char *type,
 715                                      const void *data, size_t data_len)
 716 {
 717     static const char expected_pem_header[] =
 718         "-----BEGIN " PEM_STRING_PKCS8 "-----";
 719
 720     return TEST_FL_strn_eq(data, expected_pem_header,
 721                         sizeof(expected_pem_header) - 1);
 722 }
 723
 724 static int test_protected_via_PEM(const char *type, EVP_PKEY *key)
 725 {
 726     return test_encode_decode(__FILE__, __LINE__, type, key,
 727                               OSSL_KEYMGMT_SELECT_KEYPAIR
 728                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 729                               "PEM", "PrivateKeyInfo",
 730                               pass, pass_cipher,
 731                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 732                               test_text, check_protected_PKCS8_PEM,
 733                               dump_pem, 0);
 734 }
 735
 736 static int check_protected_legacy_PEM(const char *file, const int line,
 737                                       const char *type,
 738                                       const void *data, size_t data_len)
 739 {
 740     static char expected_pem_header[80];
 741
 742     return
 743         TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
 744                                  sizeof(expected_pem_header),
 745                                  "-----BEGIN %s PRIVATE KEY-----", type), 0)
 746         && TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header))
 747         && TEST_FL_ptr(strstr(data, "\nDEK-Info: "));
 748 }
 749
 750 static int test_protected_via_legacy_PEM(const char *type, EVP_PKEY *key)
 751 {
 752     if (!default_libctx || is_fips)
 753         return TEST_skip("Test not available if using a non-default library context or FIPS provider");
 754
 755     return test_encode_decode(__FILE__, __LINE__, type, key,
 756                               OSSL_KEYMGMT_SELECT_KEYPAIR
 757                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 758                               "PEM", "type-specific", pass, pass_cipher,
 759                               encode_EVP_PKEY_legacy_PEM, decode_EVP_PKEY_prov,
 760                               test_text, check_protected_legacy_PEM,
 761                               dump_pem, 0);
 762 }
 763
 764 #ifndef OPENSSL_NO_RC4
 765 static int test_protected_via_PVK(const char *type, EVP_PKEY *key)
 766 {
 767     int ret = 0;
 768     OSSL_PROVIDER *lgcyprov = OSSL_PROVIDER_load(testctx, "legacy");
 769     if (lgcyprov == NULL)
 770         return TEST_skip("Legacy provider not available");
 771
 772     ret = test_encode_decode(__FILE__, __LINE__, type, key,
 773                               OSSL_KEYMGMT_SELECT_KEYPAIR
 774                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 775                               "PVK", NULL, pass, NULL,
 776                               encode_EVP_PKEY_PVK, decode_EVP_PKEY_prov,
 777                               test_mem, check_PVK, dump_der, 0);
 778     OSSL_PROVIDER_unload(lgcyprov);
 779     return ret;
 780 }
 781 #endif
 782
 783 static int check_public_DER(const char *file, const int line,
 784                             const char *type, const void *data, size_t data_len)
 785 {
 786     const unsigned char *datap = data;
 787     EVP_PKEY *pkey = d2i_PUBKEY_ex(NULL, &datap, data_len, testctx, testpropq);
 788     int ok = (TEST_FL_ptr(pkey) && TEST_FL_true(EVP_PKEY_is_a(pkey, type)));
 789
 790     EVP_PKEY_free(pkey);
 791     return ok;
 792 }
 793
 794 static int test_public_via_DER(const char *type, EVP_PKEY *key)
 795 {
 796     return test_encode_decode(__FILE__, __LINE__, type, key,
 797                               OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 798                               | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
 799                               "DER", "SubjectPublicKeyInfo", NULL, NULL,
 800                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 801                               test_mem, check_public_DER, dump_der, 0);
 802 }
 803
 804 static int check_public_PEM(const char *file, const int line,
 805                             const char *type, const void *data, size_t data_len)
 806 {
 807     static const char expected_pem_header[] =
 808         "-----BEGIN " PEM_STRING_PUBLIC "-----";
 809
 810     return
 811         TEST_FL_strn_eq(data, expected_pem_header,
 812                      sizeof(expected_pem_header) - 1);
 813 }
 814
 815 static int test_public_via_PEM(const char *type, EVP_PKEY *key)
 816 {
 817     return test_encode_decode(__FILE__, __LINE__, type, key,
 818                               OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 819                               | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
 820                               "PEM", "SubjectPublicKeyInfo", NULL, NULL,
 821                               encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
 822                               test_text, check_public_PEM, dump_pem, 0);
 823 }
 824
 825 static int check_public_MSBLOB(const char *file, const int line,
 826                                const char *type,
 827                                const void *data, size_t data_len)
 828 {
 829     const unsigned char *datap = data;
 830     EVP_PKEY *pkey = b2i_PublicKey(&datap, data_len);
 831     int ok = TEST_FL_ptr(pkey);
 832
 833     EVP_PKEY_free(pkey);
 834     return ok;
 835 }
 836
 837 static int test_public_via_MSBLOB(const char *type, EVP_PKEY *key)
 838 {
 839     return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 840                               | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
 841                               "MSBLOB", NULL, NULL, NULL,
 842                               encode_EVP_PKEY_MSBLOB, decode_EVP_PKEY_prov,
 843                               test_mem, check_public_MSBLOB, dump_der, 0);
 844 }
 845
 846 #define KEYS(KEYTYPE)                           \
 847     static EVP_PKEY *key_##KEYTYPE = NULL
 848 #define MAKE_KEYS(KEYTYPE, KEYTYPEstr, params)                          \
 849     ok = ok                                                             \
 850         && TEST_ptr(key_##KEYTYPE = make_key(KEYTYPEstr, NULL, params))
 851 #define FREE_KEYS(KEYTYPE)                                              \
 852     EVP_PKEY_free(key_##KEYTYPE);                                       \
 853
 854 #define DOMAIN_KEYS(KEYTYPE)                    \
 855     static EVP_PKEY *template_##KEYTYPE = NULL; \
 856     static EVP_PKEY *key_##KEYTYPE = NULL
 857 #define MAKE_DOMAIN_KEYS(KEYTYPE, KEYTYPEstr, params)                   \
 858     ok = ok                                                             \
 859         && TEST_ptr(template_##KEYTYPE =                                \
 860                     make_template(KEYTYPEstr, params))                  \
 861         && TEST_ptr(key_##KEYTYPE =                                     \
 862                     make_key(KEYTYPEstr, template_##KEYTYPE, NULL))
 863 #define FREE_DOMAIN_KEYS(KEYTYPE)                                       \
 864     EVP_PKEY_free(template_##KEYTYPE);                                  \
 865     EVP_PKEY_free(key_##KEYTYPE)
 866
 867 #define IMPLEMENT_TEST_SUITE(KEYTYPE, KEYTYPEstr)                       \
 868     static int test_unprotected_##KEYTYPE##_via_DER(void)               \
 869     {                                                                   \
 870         return test_unprotected_via_DER(KEYTYPEstr, key_##KEYTYPE);     \
 871     }                                                                   \
 872     static int test_unprotected_##KEYTYPE##_via_PEM(void)               \
 873     {                                                                   \
 874         return test_unprotected_via_PEM(KEYTYPEstr, key_##KEYTYPE);     \
 875     }                                                                   \
 876     static int test_protected_##KEYTYPE##_via_DER(void)                 \
 877     {                                                                   \
 878         return test_protected_via_DER(KEYTYPEstr, key_##KEYTYPE);       \
 879     }                                                                   \
 880     static int test_protected_##KEYTYPE##_via_PEM(void)                 \
 881     {                                                                   \
 882         return test_protected_via_PEM(KEYTYPEstr, key_##KEYTYPE);       \
 883     }                                                                   \
 884     static int test_public_##KEYTYPE##_via_DER(void)                    \
 885     {                                                                   \
 886         return test_public_via_DER(KEYTYPEstr, key_##KEYTYPE);          \
 887     }                                                                   \
 888     static int test_public_##KEYTYPE##_via_PEM(void)                    \
 889     {                                                                   \
 890         return test_public_via_PEM(KEYTYPEstr, key_##KEYTYPE);          \
 891     }
 892
 893 #define ADD_TEST_SUITE(KEYTYPE)                                 \
 894     ADD_TEST(test_unprotected_##KEYTYPE##_via_DER);             \
 895     ADD_TEST(test_unprotected_##KEYTYPE##_via_PEM);             \
 896     ADD_TEST(test_protected_##KEYTYPE##_via_DER);               \
 897     ADD_TEST(test_protected_##KEYTYPE##_via_PEM);               \
 898     ADD_TEST(test_public_##KEYTYPE##_via_DER);                  \
 899     ADD_TEST(test_public_##KEYTYPE##_via_PEM)
 900
 901 #define IMPLEMENT_TEST_SUITE_PARAMS(KEYTYPE, KEYTYPEstr)           \
 902     static int test_params_##KEYTYPE##_via_DER(void)               \
 903     {                                                              \
 904         return test_params_via_DER(KEYTYPEstr, key_##KEYTYPE);     \
 905     }                                                              \
 906     static int test_params_##KEYTYPE##_via_PEM(void)               \
 907     {                                                              \
 908         return test_params_via_PEM(KEYTYPEstr, key_##KEYTYPE);     \
 909     }
 910
 911 #define ADD_TEST_SUITE_PARAMS(KEYTYPE)                          \
 912     ADD_TEST(test_params_##KEYTYPE##_via_DER);                  \
 913     ADD_TEST(test_params_##KEYTYPE##_via_PEM)
 914
 915 #define IMPLEMENT_TEST_SUITE_LEGACY(KEYTYPE, KEYTYPEstr)                \
 916     static int test_unprotected_##KEYTYPE##_via_legacy_PEM(void)        \
 917     {                                                                   \
 918         return                                                          \
 919             test_unprotected_via_legacy_PEM(KEYTYPEstr, key_##KEYTYPE); \
 920     }                                                                   \
 921     static int test_protected_##KEYTYPE##_via_legacy_PEM(void)          \
 922     {                                                                   \
 923         return                                                          \
 924             test_protected_via_legacy_PEM(KEYTYPEstr, key_##KEYTYPE);   \
 925     }
 926
 927 #define ADD_TEST_SUITE_LEGACY(KEYTYPE)                                  \
 928     ADD_TEST(test_unprotected_##KEYTYPE##_via_legacy_PEM);              \
 929     ADD_TEST(test_protected_##KEYTYPE##_via_legacy_PEM)
 930
 931 #define IMPLEMENT_TEST_SUITE_MSBLOB(KEYTYPE, KEYTYPEstr)                \
 932     static int test_unprotected_##KEYTYPE##_via_MSBLOB(void)            \
 933     {                                                                   \
 934         return test_unprotected_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE);  \
 935     }                                                                   \
 936     static int test_public_##KEYTYPE##_via_MSBLOB(void)                 \
 937     {                                                                   \
 938         return test_public_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE);       \
 939     }
 940
 941 #define ADD_TEST_SUITE_MSBLOB(KEYTYPE)                                  \
 942     ADD_TEST(test_unprotected_##KEYTYPE##_via_MSBLOB);                  \
 943     ADD_TEST(test_public_##KEYTYPE##_via_MSBLOB)
 944
 945 #define IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(KEYTYPE, KEYTYPEstr)       \
 946     static int test_unprotected_##KEYTYPE##_via_PVK(void)               \
 947     {                                                                   \
 948         return test_unprotected_via_PVK(KEYTYPEstr, key_##KEYTYPE);     \
 949     }
 950 # define ADD_TEST_SUITE_UNPROTECTED_PVK(KEYTYPE)                        \
 951     ADD_TEST(test_unprotected_##KEYTYPE##_via_PVK)
 952 #ifndef OPENSSL_NO_RC4
 953 # define IMPLEMENT_TEST_SUITE_PROTECTED_PVK(KEYTYPE, KEYTYPEstr)        \
 954     static int test_protected_##KEYTYPE##_via_PVK(void)                 \
 955     {                                                                   \
 956         return test_protected_via_PVK(KEYTYPEstr, key_##KEYTYPE);       \
 957     }
 958 # define ADD_TEST_SUITE_PROTECTED_PVK(KEYTYPE)                          \
 959     ADD_TEST(test_protected_##KEYTYPE##_via_PVK)
 960 #endif
 961
 962 #ifndef OPENSSL_NO_DH
 963 DOMAIN_KEYS(DH);
 964 IMPLEMENT_TEST_SUITE(DH, "DH")
 965 IMPLEMENT_TEST_SUITE_PARAMS(DH, "DH")
 966 DOMAIN_KEYS(DHX);
 967 IMPLEMENT_TEST_SUITE(DHX, "X9.42 DH")
 968 IMPLEMENT_TEST_SUITE_PARAMS(DHX, "X9.42 DH")
 969 /*
 970  * DH has no support for PEM_write_bio_PrivateKey_traditional(),
 971  * so no legacy tests.
 972  */
 973 #endif
 974 #ifndef OPENSSL_NO_DSA
 975 DOMAIN_KEYS(DSA);
 976 IMPLEMENT_TEST_SUITE(DSA, "DSA")
 977 IMPLEMENT_TEST_SUITE_PARAMS(DSA, "DSA")
 978 IMPLEMENT_TEST_SUITE_LEGACY(DSA, "DSA")
 979 IMPLEMENT_TEST_SUITE_MSBLOB(DSA, "DSA")
 980 IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(DSA, "DSA")
 981 # ifndef OPENSSL_NO_RC4
 982 IMPLEMENT_TEST_SUITE_PROTECTED_PVK(DSA, "DSA")
 983 # endif
 984 #endif
 985 #ifndef OPENSSL_NO_EC
 986 DOMAIN_KEYS(EC);
 987 IMPLEMENT_TEST_SUITE(EC, "EC")
 988 IMPLEMENT_TEST_SUITE_PARAMS(EC, "EC")
 989 IMPLEMENT_TEST_SUITE_LEGACY(EC, "EC")
 990 DOMAIN_KEYS(ECExplicitPrimeNamedCurve);
 991 IMPLEMENT_TEST_SUITE(ECExplicitPrimeNamedCurve, "EC")
 992 IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitPrimeNamedCurve, "EC")
 993 DOMAIN_KEYS(ECExplicitPrime2G);
 994 IMPLEMENT_TEST_SUITE(ECExplicitPrime2G, "EC")
 995 IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitPrime2G, "EC")
 996 # ifndef OPENSSL_NO_EC2M
 997 DOMAIN_KEYS(ECExplicitTriNamedCurve);
 998 IMPLEMENT_TEST_SUITE(ECExplicitTriNamedCurve, "EC")
 999 IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitTriNamedCurve, "EC")
1000 DOMAIN_KEYS(ECExplicitTri2G);
1001 IMPLEMENT_TEST_SUITE(ECExplicitTri2G, "EC")
1002 IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitTri2G, "EC")
1003 # endif
1004 KEYS(ED25519);
1005 IMPLEMENT_TEST_SUITE(ED25519, "ED25519")
1006 KEYS(ED448);
1007 IMPLEMENT_TEST_SUITE(ED448, "ED448")
1008 KEYS(X25519);
1009 IMPLEMENT_TEST_SUITE(X25519, "X25519")
1010 KEYS(X448);
1011 IMPLEMENT_TEST_SUITE(X448, "X448")
1012 /*
1013  * ED25519, ED448, X25519 and X448 have no support for
1014  * PEM_write_bio_PrivateKey_traditional(), so no legacy tests.
1015  */
1016 #endif
1017 KEYS(RSA);
1018 IMPLEMENT_TEST_SUITE(RSA, "RSA")
1019 IMPLEMENT_TEST_SUITE_LEGACY(RSA, "RSA")
1020 KEYS(RSA_PSS);
1021 IMPLEMENT_TEST_SUITE(RSA_PSS, "RSA-PSS")
1022 /*
1023  * RSA-PSS has no support for PEM_write_bio_PrivateKey_traditional(),
1024  * so no legacy tests.
1025  */
1026 IMPLEMENT_TEST_SUITE_MSBLOB(RSA, "RSA")
1027 IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(RSA, "RSA")
1028 #ifndef OPENSSL_NO_RC4
1029 IMPLEMENT_TEST_SUITE_PROTECTED_PVK(RSA, "RSA")
1030 #endif
1031
1032 #ifndef OPENSSL_NO_EC
1033 /* Explicit parameters that match a named curve */
1034 static int do_create_ec_explicit_prime_params(OSSL_PARAM_BLD *bld,
1035                                               const unsigned char *gen,
1036                                               size_t gen_len)
1037 {
1038     BIGNUM *a, *b, *prime, *order;
1039
1040     /* Curve prime256v1 */
1041     static const unsigned char prime_data[] = {
1042         0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1043         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1044         0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
1045         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1046         0xff
1047     };
1048     static const unsigned char a_data[] = {
1049         0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1050         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1051         0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
1052         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1053         0xfc
1054     };
1055     static const unsigned char b_data[] = {
1056         0x5a, 0xc6, 0x35, 0xd8, 0xaa, 0x3a, 0x93, 0xe7,
1057         0xb3, 0xeb, 0xbd, 0x55, 0x76, 0x98, 0x86, 0xbc,
1058         0x65, 0x1d, 0x06, 0xb0, 0xcc, 0x53, 0xb0, 0xf6,
1059         0x3b, 0xce, 0x3c, 0x3e, 0x27, 0xd2, 0x60, 0x4b
1060     };
1061     static const unsigned char seed[] = {
1062         0xc4, 0x9d, 0x36, 0x08, 0x86, 0xe7, 0x04, 0x93,
1063         0x6a, 0x66, 0x78, 0xe1, 0x13, 0x9d, 0x26, 0xb7,
1064         0x81, 0x9f, 0x7e, 0x90
1065     };
1066     static const unsigned char order_data[] = {
1067         0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1068         0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1069         0xff, 0xbc, 0xe6, 0xfa, 0xad, 0xa7, 0x17, 0x9e,
1070         0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x51
1071     };
1072     return TEST_ptr(a = BN_CTX_get(bnctx))
1073            && TEST_ptr(b = BN_CTX_get(bnctx))
1074            && TEST_ptr(prime = BN_CTX_get(bnctx))
1075            && TEST_ptr(order = BN_CTX_get(bnctx))
1076            && TEST_ptr(BN_bin2bn(prime_data, sizeof(prime_data), prime))
1077            && TEST_ptr(BN_bin2bn(a_data, sizeof(a_data), a))
1078            && TEST_ptr(BN_bin2bn(b_data, sizeof(b_data), b))
1079            && TEST_ptr(BN_bin2bn(order_data, sizeof(order_data), order))
1080            && TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
1081                             OSSL_PKEY_PARAM_EC_FIELD_TYPE, SN_X9_62_prime_field,
1082                             0))
1083            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_P, prime))
1084            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_A, a))
1085            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_B, b))
1086            && TEST_true(OSSL_PARAM_BLD_push_BN(bld,
1087                             OSSL_PKEY_PARAM_EC_ORDER, order))
1088            && TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1089                             OSSL_PKEY_PARAM_EC_GENERATOR, gen, gen_len))
1090            && TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1091                             OSSL_PKEY_PARAM_EC_SEED, seed, sizeof(seed)))
1092            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_COFACTOR,
1093                                                BN_value_one()));
1094 }
1095
1096 static int create_ec_explicit_prime_params_namedcurve(OSSL_PARAM_BLD *bld)
1097 {
1098     static const unsigned char prime256v1_gen[] = {
1099         0x04,
1100         0x6b, 0x17, 0xd1, 0xf2, 0xe1, 0x2c, 0x42, 0x47,
1101         0xf8, 0xbc, 0xe6, 0xe5, 0x63, 0xa4, 0x40, 0xf2,
1102         0x77, 0x03, 0x7d, 0x81, 0x2d, 0xeb, 0x33, 0xa0,
1103         0xf4, 0xa1, 0x39, 0x45, 0xd8, 0x98, 0xc2, 0x96,
1104         0x4f, 0xe3, 0x42, 0xe2, 0xfe, 0x1a, 0x7f, 0x9b,
1105         0x8e, 0xe7, 0xeb, 0x4a, 0x7c, 0x0f, 0x9e, 0x16,
1106         0x2b, 0xce, 0x33, 0x57, 0x6b, 0x31, 0x5e, 0xce,
1107         0xcb, 0xb6, 0x40, 0x68, 0x37, 0xbf, 0x51, 0xf5
1108     };
1109     return do_create_ec_explicit_prime_params(bld, prime256v1_gen,
1110                                               sizeof(prime256v1_gen));
1111 }
1112
1113 static int create_ec_explicit_prime_params(OSSL_PARAM_BLD *bld)
1114 {
1115     /* 2G */
1116     static const unsigned char prime256v1_gen2[] = {
1117         0x04,
1118         0xe4, 0x97, 0x08, 0xbe, 0x7d, 0xfa, 0xa2, 0x9a,
1119         0xa3, 0x12, 0x6f, 0xe4, 0xe7, 0xd0, 0x25, 0xe3,
1120         0x4a, 0xc1, 0x03, 0x15, 0x8c, 0xd9, 0x33, 0xc6,
1121         0x97, 0x42, 0xf5, 0xdc, 0x97, 0xb9, 0xd7, 0x31,
1122         0xe9, 0x7d, 0x74, 0x3d, 0x67, 0x6a, 0x3b, 0x21,
1123         0x08, 0x9c, 0x31, 0x73, 0xf8, 0xc1, 0x27, 0xc9,
1124         0xd2, 0xa0, 0xa0, 0x83, 0x66, 0xe0, 0xc9, 0xda,
1125         0xa8, 0xc6, 0x56, 0x2b, 0x94, 0xb1, 0xae, 0x55
1126     };
1127     return do_create_ec_explicit_prime_params(bld, prime256v1_gen2,
1128                                               sizeof(prime256v1_gen2));
1129 }
1130
1131 # ifndef OPENSSL_NO_EC2M
1132 static int do_create_ec_explicit_trinomial_params(OSSL_PARAM_BLD *bld,
1133                                                   const unsigned char *gen,
1134                                                   size_t gen_len)
1135 {
1136     BIGNUM *a, *b, *poly, *order, *cofactor;
1137     /* sect233k1 characteristic-two-field tpBasis */
1138     static const unsigned char poly_data[] = {
1139         0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1140         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1141         0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1142     };
1143     static const unsigned char a_data[] = {
1144         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1145         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1146         0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1147     };
1148     static const unsigned char b_data[] = {
1149         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1150         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1151         0x00, 0x00, 0x00, 0x00, 0x00, 0x01
1152     };
1153     static const unsigned char order_data[] = {
1154         0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1155         0x00, 0x00, 0x00, 0x06, 0x9D, 0x5B, 0xB9, 0x15, 0xBC, 0xD4, 0x6E, 0xFB,
1156         0x1A, 0xD5, 0xF1, 0x73, 0xAB, 0xDF
1157     };
1158     static const unsigned char cofactor_data[]= {
1159         0x4
1160     };
1161     return TEST_ptr(a = BN_CTX_get(bnctx))
1162            && TEST_ptr(b = BN_CTX_get(bnctx))
1163            && TEST_ptr(poly = BN_CTX_get(bnctx))
1164            && TEST_ptr(order = BN_CTX_get(bnctx))
1165            && TEST_ptr(cofactor = BN_CTX_get(bnctx))
1166            && TEST_ptr(BN_bin2bn(poly_data, sizeof(poly_data), poly))
1167            && TEST_ptr(BN_bin2bn(a_data, sizeof(a_data), a))
1168            && TEST_ptr(BN_bin2bn(b_data, sizeof(b_data), b))
1169            && TEST_ptr(BN_bin2bn(order_data, sizeof(order_data), order))
1170            && TEST_ptr(BN_bin2bn(cofactor_data, sizeof(cofactor_data), cofactor))
1171            && TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
1172                             OSSL_PKEY_PARAM_EC_FIELD_TYPE,
1173                             SN_X9_62_characteristic_two_field, 0))
1174            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_P, poly))
1175            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_A, a))
1176            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_B, b))
1177            && TEST_true(OSSL_PARAM_BLD_push_BN(bld,
1178                             OSSL_PKEY_PARAM_EC_ORDER, order))
1179            && TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1180                             OSSL_PKEY_PARAM_EC_GENERATOR, gen, gen_len))
1181            && TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_COFACTOR,
1182                                                cofactor));
1183 }
1184
1185 static int create_ec_explicit_trinomial_params_namedcurve(OSSL_PARAM_BLD *bld)
1186 {
1187     static const unsigned char gen[] = {
1188         0x04,
1189         0x01, 0x72, 0x32, 0xBA, 0x85, 0x3A, 0x7E, 0x73, 0x1A, 0xF1, 0x29, 0xF2,
1190         0x2F, 0xF4, 0x14, 0x95, 0x63, 0xA4, 0x19, 0xC2, 0x6B, 0xF5, 0x0A, 0x4C,
1191         0x9D, 0x6E, 0xEF, 0xAD, 0x61, 0x26,
1192         0x01, 0xDB, 0x53, 0x7D, 0xEC, 0xE8, 0x19, 0xB7, 0xF7, 0x0F, 0x55, 0x5A,
1193         0x67, 0xC4, 0x27, 0xA8, 0xCD, 0x9B, 0xF1, 0x8A, 0xEB, 0x9B, 0x56, 0xE0,
1194         0xC1, 0x10, 0x56, 0xFA, 0xE6, 0xA3
1195     };
1196     return do_create_ec_explicit_trinomial_params(bld, gen, sizeof(gen));
1197 }
1198
1199 static int create_ec_explicit_trinomial_params(OSSL_PARAM_BLD *bld)
1200 {
1201     static const unsigned char gen2[] = {
1202         0x04,
1203         0x00, 0xd7, 0xba, 0xd0, 0x26, 0x6c, 0x31, 0x6a, 0x78, 0x76, 0x01, 0xd1,
1204         0x32, 0x4b, 0x8f, 0x30, 0x29, 0x2d, 0x78, 0x30, 0xca, 0x43, 0xaa, 0xf0,
1205         0xa2, 0x5a, 0xd4, 0x0f, 0xb3, 0xf4,
1206         0x00, 0x85, 0x4b, 0x1b, 0x8d, 0x50, 0x10, 0xa5, 0x1c, 0x80, 0xf7, 0x86,
1207         0x40, 0x62, 0x4c, 0x87, 0xd1, 0x26, 0x7a, 0x9c, 0x5c, 0xe9, 0x82, 0x29,
1208         0xd1, 0x67, 0x70, 0x41, 0xea, 0xcb
1209     };
1210     return do_create_ec_explicit_trinomial_params(bld, gen2, sizeof(gen2));
1211 }
1212 # endif /* OPENSSL_NO_EC2M */
1213 #endif /* OPENSSL_NO_EC */
1214
1215 typedef enum OPTION_choice {
1216     OPT_ERR = -1,
1217     OPT_EOF = 0,
1218     OPT_CONTEXT,
1219     OPT_RSA_FILE,
1220     OPT_RSA_PSS_FILE,
1221     OPT_CONFIG_FILE,
1222     OPT_PROVIDER_NAME,
1223     OPT_TEST_ENUM
1224 } OPTION_CHOICE;
1225
1226 const OPTIONS *test_get_options(void)
1227 {
1228     static const OPTIONS options[] = {
1229         OPT_TEST_OPTIONS_DEFAULT_USAGE,
1230         { "context", OPT_CONTEXT, '-',
1231           "Explicitly use a non-default library context" },
1232         { "rsa", OPT_RSA_FILE, '<',
1233           "PEM format RSA key file to encode/decode" },
1234         { "pss", OPT_RSA_PSS_FILE, '<',
1235           "PEM format RSA-PSS key file to encode/decode" },
1236         { "config", OPT_CONFIG_FILE, '<',
1237           "The configuration file to use for the library context" },
1238         { "provider", OPT_PROVIDER_NAME, 's',
1239           "The provider to load (The default value is 'default')" },
1240         { NULL }
1241     };
1242     return options;
1243 }
1244
1245 int setup_tests(void)
1246 {
1247     const char *rsa_file = NULL;
1248     const char *rsa_pss_file = NULL;
1249     const char *prov_name = "default";
1250     char *config_file = NULL;
1251     int ok = 1;
1252
1253 #ifndef OPENSSL_NO_DSA
1254     static size_t qbits = 160;  /* PVK only tolerates 160 Q bits */
1255     static size_t pbits = 1024; /* With 160 Q bits, we MUST use 1024 P bits */
1256     OSSL_PARAM DSA_params[] = {
1257         OSSL_PARAM_size_t("pbits", &pbits),
1258         OSSL_PARAM_size_t("qbits", &qbits),
1259         OSSL_PARAM_END
1260     };
1261 #endif
1262
1263 #ifndef OPENSSL_NO_EC
1264     static char groupname[] = "prime256v1";
1265     OSSL_PARAM EC_params[] = {
1266         OSSL_PARAM_utf8_string("group", groupname, sizeof(groupname) - 1),
1267         OSSL_PARAM_END
1268     };
1269 #endif
1270
1271     OPTION_CHOICE o;
1272
1273     while ((o = opt_next()) != OPT_EOF) {
1274         switch (o) {
1275         case OPT_CONTEXT:
1276             default_libctx = 0;
1277             break;
1278         case OPT_PROVIDER_NAME:
1279             prov_name = opt_arg();
1280             break;
1281         case OPT_CONFIG_FILE:
1282             config_file = opt_arg();
1283             break;
1284         case OPT_RSA_FILE:
1285             rsa_file = opt_arg();
1286             break;
1287         case OPT_RSA_PSS_FILE:
1288             rsa_pss_file = opt_arg();
1289             break;
1290         case OPT_TEST_CASES:
1291             break;
1292         default:
1293             return 0;
1294         }
1295     }
1296
1297     if (strcmp(prov_name, "fips") == 0)
1298         is_fips = 1;
1299
1300     if (default_libctx) {
1301         if (!test_get_libctx(NULL, NULL, config_file, &deflprov, prov_name))
1302             return 0;
1303     } else {
1304         if (!test_get_libctx(&testctx, &nullprov, config_file, &deflprov, prov_name))
1305             return 0;
1306     }
1307
1308     /* Separate provider/ctx for generating the test data */
1309     if (!TEST_ptr(keyctx = OSSL_LIB_CTX_new()))
1310         return 0;
1311     if (!TEST_ptr(keyprov = OSSL_PROVIDER_load(keyctx, "default")))
1312         return 0;
1313
1314 #ifndef OPENSSL_NO_EC
1315     if (!TEST_ptr(bnctx = BN_CTX_new_ex(testctx))
1316         || !TEST_ptr(bld_prime_nc = OSSL_PARAM_BLD_new())
1317         || !TEST_ptr(bld_prime = OSSL_PARAM_BLD_new())
1318         || !create_ec_explicit_prime_params_namedcurve(bld_prime_nc)
1319         || !create_ec_explicit_prime_params(bld_prime)
1320         || !TEST_ptr(ec_explicit_prime_params_nc = OSSL_PARAM_BLD_to_param(bld_prime_nc))
1321         || !TEST_ptr(ec_explicit_prime_params_explicit = OSSL_PARAM_BLD_to_param(bld_prime))
1322 # ifndef OPENSSL_NO_EC2M
1323         || !TEST_ptr(bld_tri_nc = OSSL_PARAM_BLD_new())
1324         || !TEST_ptr(bld_tri = OSSL_PARAM_BLD_new())
1325         || !create_ec_explicit_trinomial_params_namedcurve(bld_tri_nc)
1326         || !create_ec_explicit_trinomial_params(bld_tri)
1327         || !TEST_ptr(ec_explicit_tri_params_nc = OSSL_PARAM_BLD_to_param(bld_tri_nc))
1328         || !TEST_ptr(ec_explicit_tri_params_explicit = OSSL_PARAM_BLD_to_param(bld_tri))
1329 # endif
1330         )
1331         return 0;
1332 #endif
1333
1334     TEST_info("Generating keys...");
1335
1336 #ifndef OPENSSL_NO_DH
1337     TEST_info("Generating DH keys...");
1338     MAKE_DOMAIN_KEYS(DH, "DH", NULL);
1339     MAKE_DOMAIN_KEYS(DHX, "X9.42 DH", NULL);
1340 #endif
1341 #ifndef OPENSSL_NO_DSA
1342     TEST_info("Generating DSA keys...");
1343     MAKE_DOMAIN_KEYS(DSA, "DSA", DSA_params);
1344 #endif
1345 #ifndef OPENSSL_NO_EC
1346     TEST_info("Generating EC keys...");
1347     MAKE_DOMAIN_KEYS(EC, "EC", EC_params);
1348     MAKE_DOMAIN_KEYS(ECExplicitPrimeNamedCurve, "EC", ec_explicit_prime_params_nc);
1349     MAKE_DOMAIN_KEYS(ECExplicitPrime2G, "EC", ec_explicit_prime_params_explicit);
1350 # ifndef OPENSSL_NO_EC2M
1351     MAKE_DOMAIN_KEYS(ECExplicitTriNamedCurve, "EC", ec_explicit_tri_params_nc);
1352     MAKE_DOMAIN_KEYS(ECExplicitTri2G, "EC", ec_explicit_tri_params_explicit);
1353 # endif
1354     MAKE_KEYS(ED25519, "ED25519", NULL);
1355     MAKE_KEYS(ED448, "ED448", NULL);
1356     MAKE_KEYS(X25519, "X25519", NULL);
1357     MAKE_KEYS(X448, "X448", NULL);
1358 #endif
1359     TEST_info("Loading RSA key...");
1360     ok = ok && TEST_ptr(key_RSA = load_pkey_pem(rsa_file, keyctx));
1361     TEST_info("Loading RSA_PSS key...");
1362     ok = ok && TEST_ptr(key_RSA_PSS = load_pkey_pem(rsa_pss_file, keyctx));
1363     TEST_info("Generating keys done");
1364
1365     if (ok) {
1366 #ifndef OPENSSL_NO_DH
1367         ADD_TEST_SUITE(DH);
1368         ADD_TEST_SUITE_PARAMS(DH);
1369         ADD_TEST_SUITE(DHX);
1370         ADD_TEST_SUITE_PARAMS(DHX);
1371         /*
1372          * DH has no support for PEM_write_bio_PrivateKey_traditional(),
1373          * so no legacy tests.
1374          */
1375 #endif
1376 #ifndef OPENSSL_NO_DSA
1377         ADD_TEST_SUITE(DSA);
1378         ADD_TEST_SUITE_PARAMS(DSA);
1379         ADD_TEST_SUITE_LEGACY(DSA);
1380         ADD_TEST_SUITE_MSBLOB(DSA);
1381         ADD_TEST_SUITE_UNPROTECTED_PVK(DSA);
1382 # ifndef OPENSSL_NO_RC4
1383         ADD_TEST_SUITE_PROTECTED_PVK(DSA);
1384 # endif
1385 #endif
1386 #ifndef OPENSSL_NO_EC
1387         ADD_TEST_SUITE(EC);
1388         ADD_TEST_SUITE_PARAMS(EC);
1389         ADD_TEST_SUITE_LEGACY(EC);
1390         ADD_TEST_SUITE(ECExplicitPrimeNamedCurve);
1391         ADD_TEST_SUITE_LEGACY(ECExplicitPrimeNamedCurve);
1392         ADD_TEST_SUITE(ECExplicitPrime2G);
1393         ADD_TEST_SUITE_LEGACY(ECExplicitPrime2G);
1394 # ifndef OPENSSL_NO_EC2M
1395         ADD_TEST_SUITE(ECExplicitTriNamedCurve);
1396         ADD_TEST_SUITE_LEGACY(ECExplicitTriNamedCurve);
1397         ADD_TEST_SUITE(ECExplicitTri2G);
1398         ADD_TEST_SUITE_LEGACY(ECExplicitTri2G);
1399 # endif
1400         ADD_TEST_SUITE(ED25519);
1401         ADD_TEST_SUITE(ED448);
1402         ADD_TEST_SUITE(X25519);
1403         ADD_TEST_SUITE(X448);
1404         /*
1405          * ED25519, ED448, X25519 and X448 have no support for
1406          * PEM_write_bio_PrivateKey_traditional(), so no legacy tests.
1407          */
1408 #endif
1409         ADD_TEST_SUITE(RSA);
1410         ADD_TEST_SUITE_LEGACY(RSA);
1411         ADD_TEST_SUITE(RSA_PSS);
1412         /*
1413          * RSA-PSS has no support for PEM_write_bio_PrivateKey_traditional(),
1414          * so no legacy tests.
1415          */
1416         ADD_TEST_SUITE_MSBLOB(RSA);
1417         ADD_TEST_SUITE_UNPROTECTED_PVK(RSA);
1418 # ifndef OPENSSL_NO_RC4
1419         ADD_TEST_SUITE_PROTECTED_PVK(RSA);
1420 # endif
1421     }
1422
1423     return 1;
1424 }
1425
1426 void cleanup_tests(void)
1427 {
1428 #ifndef OPENSSL_NO_EC
1429     OSSL_PARAM_free(ec_explicit_prime_params_nc);
1430     OSSL_PARAM_free(ec_explicit_prime_params_explicit);
1431     OSSL_PARAM_BLD_free(bld_prime_nc);
1432     OSSL_PARAM_BLD_free(bld_prime);
1433 # ifndef OPENSSL_NO_EC2M
1434     OSSL_PARAM_free(ec_explicit_tri_params_nc);
1435     OSSL_PARAM_free(ec_explicit_tri_params_explicit);
1436     OSSL_PARAM_BLD_free(bld_tri_nc);
1437     OSSL_PARAM_BLD_free(bld_tri);
1438 # endif
1439     BN_CTX_free(bnctx);
1440 #endif /* OPENSSL_NO_EC */
1441
1442 #ifndef OPENSSL_NO_DH
1443     FREE_DOMAIN_KEYS(DH);
1444     FREE_DOMAIN_KEYS(DHX);
1445 #endif
1446 #ifndef OPENSSL_NO_DSA
1447     FREE_DOMAIN_KEYS(DSA);
1448 #endif
1449 #ifndef OPENSSL_NO_EC
1450     FREE_DOMAIN_KEYS(EC);
1451     FREE_DOMAIN_KEYS(ECExplicitPrimeNamedCurve);
1452     FREE_DOMAIN_KEYS(ECExplicitPrime2G);
1453 # ifndef OPENSSL_NO_EC2M
1454     FREE_DOMAIN_KEYS(ECExplicitTriNamedCurve);
1455     FREE_DOMAIN_KEYS(ECExplicitTri2G);
1456 # endif
1457     FREE_KEYS(ED25519);
1458     FREE_KEYS(ED448);
1459     FREE_KEYS(X25519);
1460     FREE_KEYS(X448);
1461 #endif
1462     FREE_KEYS(RSA);
1463     FREE_KEYS(RSA_PSS);
1464
1465     OSSL_PROVIDER_unload(nullprov);
1466     OSSL_PROVIDER_unload(deflprov);
1467     OSSL_PROVIDER_unload(keyprov);
1468     OSSL_LIB_CTX_free(testctx);
1469     OSSL_LIB_CTX_free(keyctx);
1470 }