test/evp_pkey_provided_test.c

   1 /*
   2  * Copyright 2019-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> /* memset */
  11 #include <openssl/evp.h>
  12 #include <openssl/pem.h>
  13 #include <openssl/encoder.h>
  14 #include <openssl/provider.h>
  15 #include <openssl/param_build.h>
  16 #include <openssl/core_names.h>
  17 #include "crypto/ecx.h"
  18 #include "crypto/evp.h"          /* For the internal API */
  19 #include "crypto/bn_dh.h"        /* _bignum_ffdhe2048_p */
  20 #include "internal/nelem.h"
  21 #include "testutil.h"
  22
  23 static char *datadir = NULL;
  24
  25 /*
  26  * Do not change the order of the following defines unless you also
  27  * update the for loop bounds used inside test_print_key_using_encoder() and
  28  * test_print_key_using_encoder_public().
  29  */
  30 #define PRIV_TEXT    0
  31 #define PRIV_PEM     1
  32 #define PRIV_DER     2
  33 #define PUB_TEXT     3
  34 #define PUB_PEM      4
  35 #define PUB_DER      5
  36
  37 static void stripcr(char *buf, size_t *len)
  38 {
  39     size_t i;
  40     char *curr, *writ;
  41
  42     for (i = *len, curr = buf, writ = buf; i > 0; i--, curr++) {
  43         if (*curr == '\r') {
  44             (*len)--;
  45             continue;
  46         }
  47         if (curr != writ)
  48             *writ = *curr;
  49         writ++;
  50     }
  51 }
  52
  53 static int compare_with_file(const char *alg, int type, BIO *membio)
  54 {
  55     char filename[80];
  56     BIO *file = NULL;
  57     char buf[4096];
  58     char *memdata, *fullfile = NULL;
  59     const char *suffix;
  60     size_t readbytes;
  61     int ret = 0;
  62     int len;
  63     size_t slen;
  64
  65     switch (type) {
  66     case PRIV_TEXT:
  67         suffix = "priv.txt";
  68         break;
  69
  70     case PRIV_PEM:
  71         suffix = "priv.pem";
  72         break;
  73
  74     case PRIV_DER:
  75         suffix = "priv.der";
  76         break;
  77
  78     case PUB_TEXT:
  79         suffix = "pub.txt";
  80         break;
  81
  82     case PUB_PEM:
  83         suffix = "pub.pem";
  84         break;
  85
  86     case PUB_DER:
  87         suffix = "pub.der";
  88         break;
  89
  90     default:
  91         TEST_error("Invalid file type");
  92         goto err;
  93     }
  94
  95     BIO_snprintf(filename, sizeof(filename), "%s.%s", alg, suffix);
  96     fullfile = test_mk_file_path(datadir, filename);
  97     if (!TEST_ptr(fullfile))
  98         goto err;
  99
 100     file = BIO_new_file(fullfile, "rb");
 101     if (!TEST_ptr(file))
 102         goto err;
 103
 104     if (!TEST_true(BIO_read_ex(file, buf, sizeof(buf), &readbytes))
 105             || !TEST_true(BIO_eof(file))
 106             || !TEST_size_t_lt(readbytes, sizeof(buf)))
 107         goto err;
 108
 109     len = BIO_get_mem_data(membio, &memdata);
 110     if (!TEST_int_gt(len, 0))
 111         goto err;
 112
 113     slen = len;
 114     if (type != PRIV_DER && type != PUB_DER) {
 115         stripcr(memdata, &slen);
 116         stripcr(buf, &readbytes);
 117     }
 118
 119     if (!TEST_mem_eq(memdata, slen, buf, readbytes))
 120         goto err;
 121
 122     ret = 1;
 123  err:
 124     OPENSSL_free(fullfile);
 125     (void)BIO_reset(membio);
 126     BIO_free(file);
 127     return ret;
 128 }
 129
 130 static int test_print_key_using_pem(const char *alg, const EVP_PKEY *pk)
 131 {
 132     BIO *membio = BIO_new(BIO_s_mem());
 133     int ret = 0;
 134
 135     if (!TEST_ptr(membio))
 136         goto err;
 137
 138     if (/* Output Encrypted private key in PEM form */
 139         !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk, EVP_aes_256_cbc(),
 140                                             (unsigned char *)"pass", 4,
 141                                             NULL, NULL))
 142         /* Private key in text form */
 143         || !TEST_true(EVP_PKEY_print_private(membio, pk, 0, NULL))
 144         || !TEST_true(compare_with_file(alg, PRIV_TEXT, membio))
 145         /* Public key in PEM form */
 146         || !TEST_true(PEM_write_bio_PUBKEY(membio, pk))
 147         || !TEST_true(compare_with_file(alg, PUB_PEM, membio))
 148         /* Unencrypted private key in PEM form */
 149         || !TEST_true(PEM_write_bio_PrivateKey(membio, pk,
 150                                                NULL, NULL, 0, NULL, NULL))
 151         || !TEST_true(compare_with_file(alg, PRIV_PEM, membio)))
 152         goto err;
 153
 154     ret = 1;
 155  err:
 156     BIO_free(membio);
 157     return ret;
 158 }
 159
 160 static int test_print_key_type_using_encoder(const char *alg, int type,
 161                                              const EVP_PKEY *pk)
 162 {
 163     const char *output_type, *output_structure;
 164     int selection;
 165     OSSL_ENCODER_CTX *ctx = NULL;
 166     BIO *membio = BIO_new(BIO_s_mem());
 167     int ret = 0;
 168
 169     switch (type) {
 170     case PRIV_TEXT:
 171         output_type = "TEXT";
 172         output_structure = NULL;
 173         selection = OSSL_KEYMGMT_SELECT_KEYPAIR
 174             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 175         break;
 176
 177     case PRIV_PEM:
 178         output_type = "PEM";
 179         output_structure = "PrivateKeyInfo";
 180         selection = OSSL_KEYMGMT_SELECT_KEYPAIR
 181             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 182         break;
 183
 184     case PRIV_DER:
 185         output_type = "DER";
 186         output_structure = "PrivateKeyInfo";
 187         selection = OSSL_KEYMGMT_SELECT_KEYPAIR
 188             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 189         break;
 190
 191     case PUB_TEXT:
 192         output_type = "TEXT";
 193         output_structure = NULL;
 194         selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 195             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 196         break;
 197
 198     case PUB_PEM:
 199         output_type = "PEM";
 200         output_structure = "SubjectPublicKeyInfo";
 201         selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 202             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 203         break;
 204
 205     case PUB_DER:
 206         output_type = "DER";
 207         output_structure = "SubjectPublicKeyInfo";
 208         selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
 209             | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
 210         break;
 211
 212     default:
 213         TEST_error("Invalid encoding type");
 214         goto err;
 215     }
 216
 217     if (!TEST_ptr(membio))
 218         goto err;
 219
 220     /* Make a context, it's valid for several prints */
 221     TEST_note("Setting up a OSSL_ENCODER context with passphrase");
 222     if (!TEST_ptr(ctx = OSSL_ENCODER_CTX_new_for_pkey(pk, selection,
 223                                                       output_type,
 224                                                       output_structure,
 225                                                       NULL))
 226         /* Check that this operation is supported */
 227         || !TEST_int_ne(OSSL_ENCODER_CTX_get_num_encoders(ctx), 0))
 228         goto err;
 229
 230     /* Use no cipher.  This should give us an unencrypted PEM */
 231     TEST_note("Testing with no encryption");
 232     if (!TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
 233         || !TEST_true(compare_with_file(alg, type, membio)))
 234         goto err;
 235
 236     if (type == PRIV_PEM) {
 237         /* Set a passphrase to be used later */
 238         if (!TEST_true(OSSL_ENCODER_CTX_set_passphrase(ctx,
 239                                                           (unsigned char *)"pass",
 240                                                           4)))
 241             goto err;
 242
 243         /* Use a valid cipher name */
 244         TEST_note("Displaying PEM encrypted with AES-256-CBC");
 245         if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
 246             || !TEST_true(OSSL_ENCODER_to_bio(ctx, bio_out)))
 247             goto err;
 248
 249         /* Use an invalid cipher name, which should generate no output */
 250         TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
 251         if (!TEST_false(OSSL_ENCODER_CTX_set_cipher(ctx, "FOO", NULL))
 252             || !TEST_false(OSSL_ENCODER_to_bio(ctx, bio_out)))
 253             goto err;
 254
 255         /* Clear the cipher.  This should give us an unencrypted PEM again */
 256         TEST_note("Testing with encryption cleared (no encryption)");
 257         if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, NULL, NULL))
 258             || !TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
 259             || !TEST_true(compare_with_file(alg, type, membio)))
 260             goto err;
 261     }
 262     ret = 1;
 263 err:
 264     BIO_free(membio);
 265     OSSL_ENCODER_CTX_free(ctx);
 266     return ret;
 267 }
 268
 269 static int test_print_key_using_encoder(const char *alg, const EVP_PKEY *pk)
 270 {
 271     int i;
 272     int ret = 1;
 273
 274     for (i = PRIV_TEXT; i <= PUB_DER; i++)
 275         ret = ret && test_print_key_type_using_encoder(alg, i, pk);
 276
 277     return ret;
 278 }
 279
 280 #ifndef OPENSSL_NO_EC
 281 static int test_print_key_using_encoder_public(const char *alg,
 282                                                const EVP_PKEY *pk)
 283 {
 284     int i;
 285     int ret = 1;
 286
 287     for (i = PUB_TEXT; i <= PUB_DER; i++)
 288         ret = ret && test_print_key_type_using_encoder(alg, i, pk);
 289
 290     return ret;
 291 }
 292 #endif
 293
 294 /* Array indexes used in test_fromdata_rsa */
 295 #define N       0
 296 #define E       1
 297 #define D       2
 298 #define P       3
 299 #define Q       4
 300 #define DP      5
 301 #define DQ      6
 302 #define QINV    7
 303
 304 static int test_fromdata_rsa(void)
 305 {
 306     int ret = 0, i;
 307     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 308     EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
 309     /*
 310      * 32-bit RSA key, extracted from this command,
 311      * executed with OpenSSL 1.0.2:
 312      *
 313      * openssl genrsa 32 | openssl rsa -text
 314      */
 315     static unsigned long key_numbers[] = {
 316         0xbc747fc5,              /* N */
 317         0x10001,                 /* E */
 318         0x7b133399,              /* D */
 319         0xe963,                  /* P */
 320         0xceb7,                  /* Q */
 321         0x8599,                  /* DP */
 322         0xbd87,                  /* DQ */
 323         0xcc3b,                  /* QINV */
 324     };
 325     OSSL_PARAM fromdata_params[] = {
 326         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
 327         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
 328         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
 329         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR1, &key_numbers[P]),
 330         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR2, &key_numbers[Q]),
 331         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT1, &key_numbers[DP]),
 332         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT2, &key_numbers[DQ]),
 333         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, &key_numbers[QINV]),
 334         OSSL_PARAM_END
 335     };
 336     BIGNUM *bn = BN_new();
 337     BIGNUM *bn_from = BN_new();
 338
 339     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL)))
 340         goto err;
 341
 342     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 343         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 344                                         fromdata_params)))
 345         goto err;
 346
 347     while (dup_pk == NULL) {
 348         ret = 0;
 349         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 32)
 350             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 8)
 351             || !TEST_int_eq(EVP_PKEY_get_size(pk), 4)
 352             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 353             goto err;
 354
 355         EVP_PKEY_CTX_free(key_ctx);
 356         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 357             goto err;
 358
 359         if (!TEST_true(EVP_PKEY_check(key_ctx))
 360             || !TEST_true(EVP_PKEY_public_check(key_ctx))
 361             || !TEST_true(EVP_PKEY_private_check(key_ctx))
 362             || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 363             goto err;
 364
 365         /* EVP_PKEY_copy_parameters() should fail for RSA */
 366         if (!TEST_ptr(copy_pk = EVP_PKEY_new())
 367             || !TEST_false(EVP_PKEY_copy_parameters(copy_pk, pk)))
 368             goto err;
 369         EVP_PKEY_free(copy_pk);
 370         copy_pk = NULL;
 371
 372         ret = test_print_key_using_pem("RSA", pk)
 373               && test_print_key_using_encoder("RSA", pk);
 374
 375         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
 376             goto err;
 377         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
 378         EVP_PKEY_free(pk);
 379         pk = dup_pk;
 380         if (!ret)
 381             goto err;
 382     }
 383  err:
 384     /* for better diagnostics always compare key params */
 385     for (i = 0; fromdata_params[i].key != NULL; ++i) {
 386         if (!TEST_true(BN_set_word(bn_from, key_numbers[i]))
 387             || !TEST_true(EVP_PKEY_get_bn_param(pk, fromdata_params[i].key, &bn))
 388             || !TEST_BN_eq(bn, bn_from))
 389             ret = 0;
 390     }
 391     BN_free(bn_from);
 392     BN_free(bn);
 393     EVP_PKEY_free(pk);
 394     EVP_PKEY_free(copy_pk);
 395     EVP_PKEY_CTX_free(key_ctx);
 396     EVP_PKEY_CTX_free(ctx);
 397
 398     return ret;
 399 }
 400
 401 static int test_evp_pkey_get_bn_param_large(void)
 402 {
 403     int ret = 0;
 404     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 405     EVP_PKEY *pk = NULL;
 406     OSSL_PARAM_BLD *bld = NULL;
 407     OSSL_PARAM *fromdata_params = NULL;
 408     BIGNUM *n = NULL, *e = NULL, *d = NULL, *n_out = NULL;
 409     /*
 410      * The buffer size chosen here for n_data larger than the buffer used
 411      * internally in EVP_PKEY_get_bn_param.
 412      */
 413     static unsigned char n_data[2050];
 414     static const unsigned char e_data[] = {
 415         0x1, 0x00, 0x01
 416     };
 417     static const unsigned char d_data[]= {
 418        0x99, 0x33, 0x13, 0x7b
 419     };
 420
 421     /* N is a large buffer */
 422     memset(n_data, 0xCE, sizeof(n_data));
 423
 424     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 425         || !TEST_ptr(n = BN_bin2bn(n_data, sizeof(n_data), NULL))
 426         || !TEST_ptr(e = BN_bin2bn(e_data, sizeof(e_data), NULL))
 427         || !TEST_ptr(d = BN_bin2bn(d_data, sizeof(d_data), NULL))
 428         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
 429         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
 430         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d))
 431         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld))
 432         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL))
 433         || !TEST_true(EVP_PKEY_fromdata_init(ctx))
 434         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 435                                         fromdata_params))
 436         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, ""))
 437         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_RSA_N, &n_out))
 438         || !TEST_BN_eq(n, n_out))
 439         goto err;
 440     ret = 1;
 441  err:
 442     BN_free(n_out);
 443     BN_free(n);
 444     BN_free(e);
 445     BN_free(d);
 446     EVP_PKEY_free(pk);
 447     EVP_PKEY_CTX_free(key_ctx);
 448     EVP_PKEY_CTX_free(ctx);
 449     OSSL_PARAM_free(fromdata_params);
 450     OSSL_PARAM_BLD_free(bld);
 451     return ret;
 452 }
 453
 454
 455 #ifndef OPENSSL_NO_DH
 456 static int test_fromdata_dh_named_group(void)
 457 {
 458     int ret = 0;
 459     int gindex = 0, pcounter = 0, hindex = 0;
 460     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 461     EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
 462     size_t len;
 463     BIGNUM *pub = NULL, *priv = NULL;
 464     BIGNUM *pub_out = NULL, *priv_out = NULL;
 465     BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
 466     OSSL_PARAM *fromdata_params = NULL;
 467     OSSL_PARAM_BLD *bld = NULL;
 468     char name_out[80];
 469     unsigned char seed_out[32];
 470
 471     /*
 472      * DH key data was generated using the following:
 473      * openssl genpkey -algorithm DH -pkeyopt group:ffdhe2048
 474      *                 -pkeyopt priv_len:224 -text
 475      */
 476     static const unsigned char priv_data[] = {
 477         0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf, 0x63, 0x5d,
 478         0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21, 0x2b, 0xfa, 0x55, 0xfa,
 479         0x87, 0xe8, 0xa9, 0x7b,
 480     };
 481     static const unsigned char pub_data[] = {
 482         0x00, 0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1,
 483         0x82, 0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd,
 484         0x33, 0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c,
 485         0x64, 0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6,
 486         0xf9, 0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5,
 487         0xfa, 0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03,
 488         0x9d, 0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9,
 489         0x7e, 0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a,
 490         0x57, 0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa,
 491         0xe5, 0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef,
 492         0x9a, 0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1,
 493         0xdb, 0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7,
 494         0x22, 0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f,
 495         0x7c, 0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20,
 496         0x82, 0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77,
 497         0x14, 0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2,
 498         0x6e, 0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12,
 499         0xbc, 0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0,
 500         0xf1, 0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67,
 501         0xa1, 0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc,
 502         0xa8, 0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab,
 503         0xcf, 0x33, 0x42, 0x83, 0x42
 504     };
 505     static const char group_name[] = "ffdhe2048";
 506     static const long priv_len = 224;
 507
 508     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 509         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
 510         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
 511         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 512                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 513                                                       group_name, 0))
 514         || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
 515                                                priv_len))
 516         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
 517         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
 518         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
 519         goto err;
 520
 521     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
 522         goto err;
 523
 524     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 525         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 526                                         fromdata_params)))
 527         goto err;
 528
 529     /*
 530      * A few extra checks of EVP_PKEY_get_utf8_string_param() to see that
 531      * it behaves as expected with regards to string length and terminating
 532      * NUL byte.
 533      */
 534     if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
 535                                                   OSSL_PKEY_PARAM_GROUP_NAME,
 536                                                   NULL, sizeof(name_out),
 537                                                   &len))
 538         || !TEST_size_t_eq(len, sizeof(group_name) - 1)
 539         /* Just enough space to hold the group name and a terminating NUL */
 540         || !TEST_true(EVP_PKEY_get_utf8_string_param(pk,
 541                                                      OSSL_PKEY_PARAM_GROUP_NAME,
 542                                                      name_out,
 543                                                      sizeof(group_name),
 544                                                      &len))
 545         || !TEST_size_t_eq(len, sizeof(group_name) - 1)
 546         /* Too small buffer to hold the terminating NUL byte */
 547         || !TEST_false(EVP_PKEY_get_utf8_string_param(pk,
 548                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 549                                                       name_out,
 550                                                       sizeof(group_name) - 1,
 551                                                       &len))
 552         /* Too small buffer to hold the whole group name, even! */
 553         || !TEST_false(EVP_PKEY_get_utf8_string_param(pk,
 554                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 555                                                       name_out,
 556                                                       sizeof(group_name) - 2,
 557                                                       &len)))
 558         goto err;
 559
 560     while (dup_pk == NULL) {
 561         ret = 0;
 562         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
 563             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
 564             || !TEST_int_eq(EVP_PKEY_get_size(pk), 256)
 565             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 566             goto err;
 567
 568         if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
 569                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 570                                                       name_out,
 571                                                       sizeof(name_out),
 572                                                       &len))
 573             || !TEST_str_eq(name_out, group_name)
 574             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
 575                                                 &pub_out))
 576
 577             || !TEST_BN_eq(pub, pub_out)
 578             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
 579                                                 &priv_out))
 580             || !TEST_BN_eq(priv, priv_out)
 581             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
 582             || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
 583             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
 584             || !TEST_ptr(q)
 585             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
 586             || !TEST_BN_eq(&ossl_bignum_const_2, g)
 587             || !TEST_false(EVP_PKEY_get_bn_param(pk,
 588                                                  OSSL_PKEY_PARAM_FFC_COFACTOR,
 589                                                  &j))
 590             || !TEST_ptr_null(j)
 591             || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
 592                                                            OSSL_PKEY_PARAM_FFC_SEED,
 593                                                            seed_out,
 594                                                            sizeof(seed_out),
 595                                                            &len))
 596             || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_GINDEX,
 597                                                  &gindex))
 598             || !TEST_int_eq(gindex, -1)
 599             || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
 600                                                  &hindex))
 601             || !TEST_int_eq(hindex, 0)
 602             || !TEST_true(EVP_PKEY_get_int_param(pk,
 603                                                  OSSL_PKEY_PARAM_FFC_PCOUNTER,
 604                                                  &pcounter))
 605             || !TEST_int_eq(pcounter, -1))
 606             goto err;
 607         BN_free(p);
 608         p = NULL;
 609         BN_free(q);
 610         q = NULL;
 611         BN_free(g);
 612         g = NULL;
 613         BN_free(j);
 614         j = NULL;
 615         BN_free(pub_out);
 616         pub_out = NULL;
 617         BN_free(priv_out);
 618         priv_out = NULL;
 619
 620         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 621             goto err;
 622
 623         if (!TEST_true(EVP_PKEY_check(key_ctx))
 624             || !TEST_true(EVP_PKEY_public_check(key_ctx))
 625             || !TEST_true(EVP_PKEY_private_check(key_ctx))
 626             || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 627             goto err;
 628         EVP_PKEY_CTX_free(key_ctx);
 629         key_ctx = NULL;
 630
 631         if (!TEST_ptr(copy_pk = EVP_PKEY_new())
 632             || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
 633             goto err;
 634         EVP_PKEY_free(copy_pk);
 635         copy_pk = NULL;
 636
 637         ret = test_print_key_using_pem("DH", pk)
 638               && test_print_key_using_encoder("DH", pk);
 639
 640         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
 641             goto err;
 642         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
 643         EVP_PKEY_free(pk);
 644         pk = dup_pk;
 645         if (!ret)
 646             goto err;
 647     }
 648 err:
 649     BN_free(p);
 650     BN_free(q);
 651     BN_free(g);
 652     BN_free(j);
 653     BN_free(pub);
 654     BN_free(priv);
 655     BN_free(pub_out);
 656     BN_free(priv_out);
 657     EVP_PKEY_free(copy_pk);
 658     EVP_PKEY_free(pk);
 659     EVP_PKEY_CTX_free(ctx);
 660     EVP_PKEY_CTX_free(key_ctx);
 661     OSSL_PARAM_free(fromdata_params);
 662     OSSL_PARAM_BLD_free(bld);
 663
 664     return ret;
 665 }
 666
 667 static int test_fromdata_dh_fips186_4(void)
 668 {
 669     int ret = 0;
 670     int gindex = 0, pcounter = 0, hindex = 0;
 671     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 672     EVP_PKEY *pk = NULL, *dup_pk = NULL;
 673     size_t len;
 674     BIGNUM *pub = NULL, *priv = NULL;
 675     BIGNUM *pub_out = NULL, *priv_out = NULL;
 676     BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
 677     OSSL_PARAM_BLD *bld = NULL;
 678     OSSL_PARAM *fromdata_params = NULL;
 679     char name_out[80];
 680     unsigned char seed_out[32];
 681
 682     /*
 683      * DH key data was generated using the following:
 684      * openssl genpkey -algorithm DH
 685      *                 -pkeyopt group:ffdhe2048 -pkeyopt priv_len:224 -text
 686      */
 687     static const unsigned char priv_data[] = {
 688        0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf, 0x63, 0x5d,
 689        0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21, 0x2b, 0xfa, 0x55, 0xfa,
 690        0x87, 0xe8, 0xa9, 0x7b,
 691     };
 692     static const unsigned char pub_data[] = {
 693        0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1, 0x82,
 694        0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd, 0x33,
 695        0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c, 0x64,
 696        0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6, 0xf9,
 697        0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5, 0xfa,
 698        0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03, 0x9d,
 699        0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9, 0x7e,
 700        0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a, 0x57,
 701        0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa, 0xe5,
 702        0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef, 0x9a,
 703        0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1, 0xdb,
 704        0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7, 0x22,
 705        0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f, 0x7c,
 706        0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20, 0x82,
 707        0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77, 0x14,
 708        0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2, 0x6e,
 709        0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12, 0xbc,
 710        0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0, 0xf1,
 711        0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67, 0xa1,
 712        0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc, 0xa8,
 713        0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab, 0xcf,
 714        0x33, 0x42, 0x83, 0x42
 715     };
 716     static const char group_name[] = "ffdhe2048";
 717     static const long priv_len = 224;
 718
 719
 720     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 721         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
 722         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
 723         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 724                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 725                                                       group_name, 0))
 726         || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
 727                                                priv_len))
 728         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
 729         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
 730         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
 731         goto err;
 732
 733     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
 734         goto err;
 735
 736     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 737         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 738                                         fromdata_params)))
 739         goto err;
 740
 741     while (dup_pk == NULL) {
 742         ret = 0;
 743         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
 744             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
 745             || !TEST_int_eq(EVP_PKEY_get_size(pk), 256)
 746             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 747             goto err;
 748
 749         if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
 750                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 751                                                       name_out,
 752                                                       sizeof(name_out),
 753                                                       &len))
 754             || !TEST_str_eq(name_out, group_name)
 755             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
 756                                                 &pub_out))
 757             || !TEST_BN_eq(pub, pub_out)
 758             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
 759                                                 &priv_out))
 760             || !TEST_BN_eq(priv, priv_out)
 761             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
 762             || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
 763             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
 764             || !TEST_ptr(q)
 765             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
 766             || !TEST_BN_eq(&ossl_bignum_const_2, g)
 767             || !TEST_false(EVP_PKEY_get_bn_param(pk,
 768                                                  OSSL_PKEY_PARAM_FFC_COFACTOR,
 769                                                  &j))
 770             || !TEST_ptr_null(j)
 771             || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
 772                                                            OSSL_PKEY_PARAM_FFC_SEED,
 773                                                            seed_out,
 774                                                            sizeof(seed_out),
 775                                                            &len))
 776             || !TEST_true(EVP_PKEY_get_int_param(pk,
 777                                                  OSSL_PKEY_PARAM_FFC_GINDEX,
 778                                                  &gindex))
 779             || !TEST_int_eq(gindex, -1)
 780             || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
 781                                                  &hindex))
 782             || !TEST_int_eq(hindex, 0)
 783             || !TEST_true(EVP_PKEY_get_int_param(pk,
 784                                                  OSSL_PKEY_PARAM_FFC_PCOUNTER,
 785                                                  &pcounter))
 786             || !TEST_int_eq(pcounter, -1))
 787             goto err;
 788         BN_free(p);
 789         p = NULL;
 790         BN_free(q);
 791         q = NULL;
 792         BN_free(g);
 793         g = NULL;
 794         BN_free(j);
 795         j = NULL;
 796         BN_free(pub_out);
 797         pub_out = NULL;
 798         BN_free(priv_out);
 799         priv_out = NULL;
 800
 801         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 802             goto err;
 803
 804         if (!TEST_true(EVP_PKEY_check(key_ctx))
 805             || !TEST_true(EVP_PKEY_public_check(key_ctx))
 806             || !TEST_true(EVP_PKEY_private_check(key_ctx))
 807             || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 808             goto err;
 809         EVP_PKEY_CTX_free(key_ctx);
 810         key_ctx = NULL;
 811
 812         ret = test_print_key_using_pem("DH", pk)
 813               && test_print_key_using_encoder("DH", pk);
 814
 815         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
 816             goto err;
 817         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
 818         EVP_PKEY_free(pk);
 819         pk = dup_pk;
 820         if (!ret)
 821             goto err;
 822     }
 823 err:
 824     BN_free(p);
 825     BN_free(q);
 826     BN_free(g);
 827     BN_free(j);
 828     BN_free(pub);
 829     BN_free(priv);
 830     BN_free(pub_out);
 831     BN_free(priv_out);
 832     EVP_PKEY_free(pk);
 833     EVP_PKEY_CTX_free(ctx);
 834     EVP_PKEY_CTX_free(key_ctx);
 835     OSSL_PARAM_free(fromdata_params);
 836     OSSL_PARAM_BLD_free(bld);
 837
 838     return ret;
 839 }
 840
 841 #endif
 842
 843
 844
 845 #ifndef OPENSSL_NO_EC
 846 /* Array indexes used in test_fromdata_ecx */
 847 # define PRIV_KEY        0
 848 # define PUB_KEY         1
 849
 850 # define X25519_IDX      0
 851 # define X448_IDX        1
 852 # define ED25519_IDX     2
 853 # define ED448_IDX       3
 854
 855 /*
 856  * tst uses indexes 0 ... (3 * 4 - 1)
 857  * For the 4 ECX key types (X25519_IDX..ED448_IDX)
 858  * 0..3  = public + private key.
 859  * 4..7  = private key (This will generate the public key from the private key)
 860  * 8..11 = public key
 861  */
 862 static int test_fromdata_ecx(int tst)
 863 {
 864     int ret = 0;
 865     EVP_PKEY_CTX *ctx = NULL, *ctx2 = NULL;
 866     EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
 867     const char *alg = NULL;
 868     size_t len;
 869     unsigned char out_pub[ED448_KEYLEN];
 870     unsigned char out_priv[ED448_KEYLEN];
 871     OSSL_PARAM params[3] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
 872
 873     /* ED448_KEYLEN > X448_KEYLEN > X25519_KEYLEN == ED25519_KEYLEN */
 874     static unsigned char key_numbers[4][2][ED448_KEYLEN] = {
 875         /* X25519: Keys from RFC 7748 6.1 */
 876         {
 877             /* Private Key */
 878             {
 879                 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
 880                 0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
 881                 0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
 882                 0x2c, 0x2a
 883             },
 884             /* Public Key */
 885             {
 886                 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
 887                 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
 888                 0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
 889                 0x4e, 0x6a
 890             }
 891         },
 892         /* X448: Keys from RFC 7748 6.2 */
 893         {
 894             /* Private Key */
 895             {
 896                 0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
 897                 0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
 898                 0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
 899                 0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
 900                 0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
 901                 0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
 902             },
 903             /* Public Key */
 904             {
 905                 0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
 906                 0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
 907                 0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
 908                 0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
 909                 0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
 910                 0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
 911             }
 912         },
 913         /* ED25519: Keys from RFC 8032 */
 914         {
 915             /* Private Key */
 916             {
 917                 0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84,
 918                 0x4a, 0xf4, 0x92, 0xec, 0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69,
 919                 0x7b, 0x32, 0x69, 0x19, 0x70, 0x3b, 0xac, 0x03, 0x1c, 0xae,
 920                 0x7f, 0x60
 921             },
 922             /* Public Key */
 923             {
 924                 0xd7, 0x5a, 0x98, 0x01, 0x82, 0xb1, 0x0a, 0xb7, 0xd5, 0x4b,
 925                 0xfe, 0xd3, 0xc9, 0x64, 0x07, 0x3a, 0x0e, 0xe1, 0x72, 0xf3,
 926                 0xda, 0xa6, 0x23, 0x25, 0xaf, 0x02, 0x1a, 0x68, 0xf7, 0x07,
 927                 0x51, 0x1a
 928             }
 929         },
 930         /* ED448: Keys from RFC 8032 */
 931         {
 932             /* Private Key */
 933             {
 934                 0x6c, 0x82, 0xa5, 0x62, 0xcb, 0x80, 0x8d, 0x10, 0xd6, 0x32,
 935                 0xbe, 0x89, 0xc8, 0x51, 0x3e, 0xbf, 0x6c, 0x92, 0x9f, 0x34,
 936                 0xdd, 0xfa, 0x8c, 0x9f, 0x63, 0xc9, 0x96, 0x0e, 0xf6, 0xe3,
 937                 0x48, 0xa3, 0x52, 0x8c, 0x8a, 0x3f, 0xcc, 0x2f, 0x04, 0x4e,
 938                 0x39, 0xa3, 0xfc, 0x5b, 0x94, 0x49, 0x2f, 0x8f, 0x03, 0x2e,
 939                 0x75, 0x49, 0xa2, 0x00, 0x98, 0xf9, 0x5b
 940             },
 941             /* Public Key */
 942             {
 943                 0x5f, 0xd7, 0x44, 0x9b, 0x59, 0xb4, 0x61, 0xfd, 0x2c, 0xe7,
 944                 0x87, 0xec, 0x61, 0x6a, 0xd4, 0x6a, 0x1d, 0xa1, 0x34, 0x24,
 945                 0x85, 0xa7, 0x0e, 0x1f, 0x8a, 0x0e, 0xa7, 0x5d, 0x80, 0xe9,
 946                 0x67, 0x78, 0xed, 0xf1, 0x24, 0x76, 0x9b, 0x46, 0xc7, 0x06,
 947                 0x1b, 0xd6, 0x78, 0x3d, 0xf1, 0xe5, 0x0f, 0x6c, 0xd1, 0xfa,
 948                 0x1a, 0xbe, 0xaf, 0xe8, 0x25, 0x61, 0x80
 949             }
 950         }
 951     };
 952     OSSL_PARAM x25519_fromdata_params[] = {
 953         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 954                                 key_numbers[X25519_IDX][PRIV_KEY],
 955                                 X25519_KEYLEN),
 956         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 957                                 key_numbers[X25519_IDX][PUB_KEY],
 958                                 X25519_KEYLEN),
 959         OSSL_PARAM_END
 960     };
 961     OSSL_PARAM x448_fromdata_params[] = {
 962         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 963                                 key_numbers[X448_IDX][PRIV_KEY],
 964                                 X448_KEYLEN),
 965         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 966                                 key_numbers[X448_IDX][PUB_KEY],
 967                                 X448_KEYLEN),
 968         OSSL_PARAM_END
 969     };
 970     OSSL_PARAM ed25519_fromdata_params[] = {
 971         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 972                                 key_numbers[ED25519_IDX][PRIV_KEY],
 973                                 ED25519_KEYLEN),
 974         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 975                                 key_numbers[ED25519_IDX][PUB_KEY],
 976                                 ED25519_KEYLEN),
 977         OSSL_PARAM_END
 978     };
 979     OSSL_PARAM ed448_fromdata_params[] = {
 980         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 981                                 key_numbers[ED448_IDX][PRIV_KEY],
 982                                 ED448_KEYLEN),
 983         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 984                                 key_numbers[ED448_IDX][PUB_KEY],
 985                                 ED448_KEYLEN),
 986         OSSL_PARAM_END
 987     };
 988     OSSL_PARAM *fromdata_params = NULL;
 989     int bits = 0, security_bits = 0, size = 0;
 990     OSSL_PARAM *orig_fromdata_params = NULL;
 991
 992     switch (tst & 3) {
 993     case X25519_IDX:
 994         fromdata_params = x25519_fromdata_params;
 995         bits = X25519_BITS;
 996         security_bits = X25519_SECURITY_BITS;
 997         size = X25519_KEYLEN;
 998         alg = "X25519";
 999         break;
1000
1001     case X448_IDX:
1002         fromdata_params = x448_fromdata_params;
1003         bits = X448_BITS;
1004         security_bits = X448_SECURITY_BITS;
1005         size = X448_KEYLEN;
1006         alg = "X448";
1007         break;
1008
1009     case ED25519_IDX:
1010         fromdata_params = ed25519_fromdata_params;
1011         bits = ED25519_BITS;
1012         security_bits = ED25519_SECURITY_BITS;
1013         size = ED25519_SIGSIZE;
1014         alg = "ED25519";
1015         break;
1016
1017     case ED448_IDX:
1018         fromdata_params = ed448_fromdata_params;
1019         bits = ED448_BITS;
1020         security_bits = ED448_SECURITY_BITS;
1021         size = ED448_SIGSIZE;
1022         alg = "ED448";
1023         break;
1024     default:
1025         goto err;
1026     }
1027
1028     ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
1029     if (!TEST_ptr(ctx))
1030         goto err;
1031
1032     orig_fromdata_params = fromdata_params;
1033     if (tst > 7) {
1034         /* public key only */
1035         fromdata_params++;
1036     } else if (tst > 3) {
1037         /* private key only */
1038         params[0] = fromdata_params[0];
1039         params[1] = fromdata_params[2];
1040         fromdata_params = params;
1041     }
1042
1043     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
1044         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1045                                         fromdata_params)))
1046         goto err;
1047
1048     while (dup_pk == NULL) {
1049         ret = 0;
1050         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), bits)
1051             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), security_bits)
1052             || !TEST_int_eq(EVP_PKEY_get_size(pk), size)
1053             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1054             goto err;
1055
1056         if (!TEST_ptr(ctx2 = EVP_PKEY_CTX_new_from_pkey(NULL, pk, NULL)))
1057             goto err;
1058         if (tst <= 7) {
1059             if (!TEST_true(EVP_PKEY_check(ctx2)))
1060                 goto err;
1061             if (!TEST_true(EVP_PKEY_get_octet_string_param(
1062                                pk, orig_fromdata_params[PRIV_KEY].key,
1063                                out_priv, sizeof(out_priv), &len))
1064                 || !TEST_mem_eq(out_priv, len,
1065                                 orig_fromdata_params[PRIV_KEY].data,
1066                                 orig_fromdata_params[PRIV_KEY].data_size)
1067                 || !TEST_true(EVP_PKEY_get_octet_string_param(
1068                                   pk, orig_fromdata_params[PUB_KEY].key,
1069                                   out_pub, sizeof(out_pub), &len))
1070                 || !TEST_mem_eq(out_pub, len,
1071                                 orig_fromdata_params[PUB_KEY].data,
1072                                 orig_fromdata_params[PUB_KEY].data_size))
1073                 goto err;
1074         } else {
1075             /* The private key check should fail if there is only a public key */
1076             if (!TEST_true(EVP_PKEY_public_check(ctx2))
1077                 || !TEST_false(EVP_PKEY_private_check(ctx2))
1078                 || !TEST_false(EVP_PKEY_check(ctx2)))
1079                 goto err;
1080         }
1081         EVP_PKEY_CTX_free(ctx2);
1082         ctx2 = NULL;
1083
1084         if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1085                /* This should succeed because there are no parameters to copy */
1086             || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1087             goto err;
1088         EVP_PKEY_free(copy_pk);
1089         copy_pk = NULL;
1090
1091         if (tst > 7)
1092             ret = test_print_key_using_encoder_public(alg, pk);
1093         else
1094             ret = test_print_key_using_pem(alg, pk)
1095                   && test_print_key_using_encoder(alg, pk);
1096
1097         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1098             goto err;
1099         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1100         EVP_PKEY_free(pk);
1101         pk = dup_pk;
1102         if (!ret)
1103             goto err;
1104     }
1105
1106 err:
1107     EVP_PKEY_free(pk);
1108     EVP_PKEY_free(copy_pk);
1109     EVP_PKEY_CTX_free(ctx);
1110     EVP_PKEY_CTX_free(ctx2);
1111
1112     return ret;
1113 }
1114
1115 #define CURVE_NAME 2
1116
1117 static int test_fromdata_ec(void)
1118 {
1119     int ret = 0;
1120     EVP_PKEY_CTX *ctx = NULL;
1121     EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
1122     OSSL_PARAM_BLD *bld = NULL;
1123     BIGNUM *ec_priv_bn = NULL;
1124     BIGNUM *bn_priv = NULL;
1125     OSSL_PARAM *fromdata_params = NULL;
1126     const char *alg = "EC";
1127     const char *curve = "prime256v1";
1128     /* UNCOMPRESSED FORMAT */
1129     static const unsigned char ec_pub_keydata[] = {
1130        POINT_CONVERSION_UNCOMPRESSED,
1131        0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
1132        0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
1133        0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
1134        0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
1135        0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
1136        0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
1137        0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
1138        0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
1139     };
1140     static const unsigned char ec_priv_keydata[] = {
1141         0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
1142         0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
1143         0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
1144         0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
1145     };
1146     const int compressed_sz = 1 + (sizeof(ec_pub_keydata) - 1) / 2;
1147     unsigned char out_pub[sizeof(ec_pub_keydata)];
1148     char out_curve_name[80];
1149     const OSSL_PARAM *gettable = NULL;
1150     size_t len;
1151     EC_GROUP *group = NULL;
1152     BIGNUM *group_a = NULL;
1153     BIGNUM *group_b = NULL;
1154     BIGNUM *group_p = NULL;
1155     BIGNUM *a = NULL;
1156     BIGNUM *b = NULL;
1157     BIGNUM *p = NULL;
1158
1159
1160     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new()))
1161         goto err;
1162     if (!TEST_ptr(ec_priv_bn = BN_bin2bn(ec_priv_keydata,
1163                                          sizeof(ec_priv_keydata), NULL)))
1164         goto err;
1165
1166     if (OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME,
1167                                         curve, 0) <= 0)
1168         goto err;
1169     if (OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY,
1170                                          ec_pub_keydata,
1171                                          sizeof(ec_pub_keydata)) <= 0)
1172         goto err;
1173     if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, ec_priv_bn) <= 0)
1174         goto err;
1175     if (!TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1176         goto err;
1177     ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
1178     if (!TEST_ptr(ctx))
1179         goto err;
1180
1181     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
1182         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1183                                         fromdata_params)))
1184         goto err;
1185
1186     while (dup_pk == NULL) {
1187         ret = 0;
1188         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 256)
1189             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 128)
1190             || !TEST_int_eq(EVP_PKEY_get_size(pk), 2 + 35 * 2)
1191             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1192             goto err;
1193
1194         if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1195             || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1196             goto err;
1197         EVP_PKEY_free(copy_pk);
1198         copy_pk = NULL;
1199
1200         if (!TEST_ptr(gettable = EVP_PKEY_gettable_params(pk))
1201             || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1202                                                  OSSL_PKEY_PARAM_GROUP_NAME))
1203             || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1204                                                  OSSL_PKEY_PARAM_PUB_KEY))
1205             || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1206                                                  OSSL_PKEY_PARAM_PRIV_KEY)))
1207             goto err;
1208
1209         if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(OBJ_sn2nid(curve)))
1210             || !TEST_ptr(group_p = BN_new())
1211             || !TEST_ptr(group_a = BN_new())
1212             || !TEST_ptr(group_b = BN_new())
1213             || !TEST_true(EC_GROUP_get_curve(group, group_p, group_a, group_b, NULL)))
1214             goto err;
1215
1216         if (!TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_A, &a))
1217             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_B, &b))
1218             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_P, &p)))
1219             goto err;
1220
1221         if (!TEST_BN_eq(group_p, p) || !TEST_BN_eq(group_a, a)
1222             || !TEST_BN_eq(group_b, b))
1223             goto err;
1224
1225         if (!EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
1226                                             out_curve_name,
1227                                             sizeof(out_curve_name),
1228                                             &len)
1229             || !TEST_str_eq(out_curve_name, curve)
1230             || !EVP_PKEY_get_octet_string_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1231                                             out_pub, sizeof(out_pub), &len)
1232             || !TEST_true(out_pub[0] == (POINT_CONVERSION_COMPRESSED + 1))
1233             || !TEST_mem_eq(out_pub + 1, len - 1,
1234                             ec_pub_keydata + 1, compressed_sz - 1)
1235             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1236                                                 &bn_priv))
1237             || !TEST_BN_eq(ec_priv_bn, bn_priv))
1238             goto err;
1239         BN_free(bn_priv);
1240         bn_priv = NULL;
1241
1242         ret = test_print_key_using_pem(alg, pk)
1243               && test_print_key_using_encoder(alg, pk);
1244
1245         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1246             goto err;
1247         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1248         EVP_PKEY_free(pk);
1249         pk = dup_pk;
1250         if (!ret)
1251             goto err;
1252     }
1253
1254 err:
1255     EC_GROUP_free(group);
1256     BN_free(group_a);
1257     BN_free(group_b);
1258     BN_free(group_p);
1259     BN_free(a);
1260     BN_free(b);
1261     BN_free(p);
1262     BN_free(bn_priv);
1263     BN_free(ec_priv_bn);
1264     OSSL_PARAM_free(fromdata_params);
1265     OSSL_PARAM_BLD_free(bld);
1266     EVP_PKEY_free(pk);
1267     EVP_PKEY_free(copy_pk);
1268     EVP_PKEY_CTX_free(ctx);
1269     return ret;
1270 }
1271
1272 static int test_ec_dup_no_operation(void)
1273 {
1274     int ret = 0;
1275     EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1276     EVP_PKEY *param = NULL, *pkey = NULL;
1277
1278     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1279         || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1280         || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1281                         NID_X9_62_prime256v1), 0)
1282         || !TEST_int_gt(EVP_PKEY_paramgen(pctx, &param), 0)
1283         || !TEST_ptr(param))
1284         goto err;
1285
1286     EVP_PKEY_CTX_free(pctx);
1287     pctx = NULL;
1288
1289     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1290         || !TEST_ptr(kctx = EVP_PKEY_CTX_dup(ctx))
1291         || !TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1292         || !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0))
1293         goto err;
1294     ret = 1;
1295 err:
1296     EVP_PKEY_free(pkey);
1297     EVP_PKEY_free(param);
1298     EVP_PKEY_CTX_free(ctx);
1299     EVP_PKEY_CTX_free(kctx);
1300     EVP_PKEY_CTX_free(pctx);
1301     return ret;
1302 }
1303
1304 /* Test that keygen doesn't support EVP_PKEY_CTX_dup */
1305 static int test_ec_dup_keygen_operation(void)
1306 {
1307     int ret = 0;
1308     EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1309     EVP_PKEY *param = NULL, *pkey = NULL;
1310
1311     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1312         || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1313         || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1314                         NID_X9_62_prime256v1), 0)
1315         || !TEST_int_gt(EVP_PKEY_paramgen(pctx, &param), 0)
1316         || !TEST_ptr(param))
1317         goto err;
1318
1319     EVP_PKEY_CTX_free(pctx);
1320     pctx = NULL;
1321
1322     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1323         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1324         || !TEST_ptr_null(kctx = EVP_PKEY_CTX_dup(ctx)))
1325         goto err;
1326     ret = 1;
1327 err:
1328     EVP_PKEY_free(pkey);
1329     EVP_PKEY_free(param);
1330     EVP_PKEY_CTX_free(ctx);
1331     EVP_PKEY_CTX_free(kctx);
1332     EVP_PKEY_CTX_free(pctx);
1333     return ret;
1334 }
1335
1336 #endif /* OPENSSL_NO_EC */
1337
1338 #ifndef OPENSSL_NO_DSA
1339 static int test_fromdata_dsa_fips186_4(void)
1340 {
1341     int ret = 0;
1342     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
1343     EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
1344     BIGNUM *pub = NULL, *priv = NULL;
1345     BIGNUM *p = NULL, *q = NULL, *g = NULL;
1346     BIGNUM *pub_out = NULL, *priv_out = NULL;
1347     BIGNUM *p_out = NULL, *q_out = NULL, *g_out = NULL, *j_out = NULL;
1348     int gindex_out = 0, pcounter_out = 0, hindex_out = 0;
1349     char name_out[80];
1350     unsigned char seed_out[32];
1351     size_t len;
1352     OSSL_PARAM_BLD *bld = NULL;
1353     OSSL_PARAM *fromdata_params = NULL;
1354
1355     /*
1356      * DSA parameter data was generated using the following:
1357      * openssl genpkey -genparam -algorithm DSA -pkeyopt pbits:2048 \
1358      *                 -pkeyopt qbits:256 -pkeyopt type:0 \
1359      *                 -pkeyopt gindex:1 -out dsa_params.pem -text
1360      */
1361     static const unsigned char p_data[] = {
1362         0x00, 0xa0, 0xb7, 0x02, 0xc4, 0xac, 0xa6, 0x42, 0xab, 0xf2, 0x34, 0x0b,
1363         0x22, 0x47, 0x1f, 0x33, 0xcf, 0xd5, 0x04, 0xe4, 0x3e, 0xec, 0xa1, 0x21,
1364         0xc8, 0x41, 0x2b, 0xef, 0xb8, 0x1f, 0x0b, 0x5b, 0x88, 0x8b, 0x67, 0xf8,
1365         0x68, 0x6d, 0x7c, 0x4d, 0x96, 0x5f, 0x3c, 0x66, 0xef, 0x58, 0x34, 0xd7,
1366         0xf6, 0xa2, 0x1b, 0xad, 0xc8, 0x12, 0x52, 0xb8, 0xe8, 0x2a, 0x63, 0xcc,
1367         0xea, 0xe7, 0x4e, 0xc8, 0x34, 0x4c, 0x58, 0x59, 0x0a, 0xc2, 0x4a, 0xe4,
1368         0xb4, 0x64, 0x20, 0xf4, 0xf6, 0x0a, 0xcf, 0x86, 0x01, 0x6c, 0x7f, 0x23,
1369         0x4a, 0x51, 0x07, 0x99, 0x42, 0x28, 0x7a, 0xff, 0x18, 0x67, 0x52, 0x64,
1370         0xf2, 0x9a, 0x62, 0x30, 0xc3, 0x00, 0xde, 0x23, 0xe9, 0x11, 0x95, 0x7e,
1371         0xd1, 0x3d, 0x8d, 0xb4, 0x0e, 0x9f, 0x9e, 0xb1, 0x30, 0x03, 0xf0, 0x73,
1372         0xa8, 0x40, 0x48, 0x42, 0x7b, 0x60, 0xa0, 0xc4, 0xf2, 0x3b, 0x2d, 0x0a,
1373         0x0c, 0xb8, 0x19, 0xfb, 0xb4, 0xf8, 0xe0, 0x2a, 0xc7, 0xf1, 0xc0, 0xc6,
1374         0x86, 0x14, 0x60, 0x12, 0x0f, 0xc0, 0xde, 0x4a, 0x67, 0xec, 0xc7, 0xde,
1375         0x76, 0x21, 0x1a, 0x55, 0x7f, 0x86, 0xc3, 0x97, 0x98, 0xce, 0xf5, 0xcd,
1376         0xf0, 0xe7, 0x12, 0xd6, 0x93, 0xee, 0x1b, 0x9b, 0x61, 0xef, 0x05, 0x8c,
1377         0x45, 0x46, 0xd9, 0x64, 0x6f, 0xbe, 0x27, 0xaa, 0x67, 0x01, 0xcc, 0x71,
1378         0xb1, 0x60, 0xce, 0x21, 0xd8, 0x51, 0x17, 0x27, 0x0d, 0x90, 0x3d, 0x18,
1379         0x7c, 0x87, 0x15, 0x8e, 0x48, 0x4c, 0x6c, 0xc5, 0x72, 0xeb, 0xb7, 0x56,
1380         0xf5, 0x6b, 0x60, 0x8f, 0xc2, 0xfd, 0x3f, 0x46, 0x5c, 0x00, 0x91, 0x85,
1381         0x79, 0x45, 0x5b, 0x1c, 0x82, 0xc4, 0x87, 0x50, 0x79, 0xba, 0xcc, 0x1c,
1382         0x32, 0x7e, 0x2e, 0xb8, 0x2e, 0xc5, 0x4e, 0xd1, 0x9b, 0xdb, 0x66, 0x79,
1383         0x7c, 0xfe, 0xaf, 0x6a, 0x05
1384     };
1385     static const unsigned char q_data[] = {
1386         0xa8, 0xcd, 0xf4, 0x33, 0x7b, 0x13, 0x0a, 0x24, 0xc1, 0xde, 0x4a, 0x04,
1387         0x7b, 0x4b, 0x71, 0x51, 0x32, 0xe9, 0x47, 0x74, 0xbd, 0x0c, 0x21, 0x40,
1388         0x84, 0x12, 0x0a, 0x17, 0x73, 0xdb, 0x29, 0xc7
1389     };
1390     static const unsigned char g_data[] = {
1391         0x6c, 0xc6, 0xa4, 0x3e, 0x61, 0x84, 0xc1, 0xff, 0x6f, 0x4a, 0x1a, 0x6b,
1392         0xb0, 0x24, 0x4b, 0xd2, 0x92, 0x5b, 0x29, 0x5c, 0x61, 0xb8, 0xc9, 0x2b,
1393         0xd6, 0xf7, 0x59, 0xfd, 0xd8, 0x70, 0x66, 0x77, 0xfc, 0xc1, 0xa4, 0xd4,
1394         0xb0, 0x1e, 0xd5, 0xbf, 0x59, 0x98, 0xb3, 0x66, 0x8b, 0xf4, 0x2e, 0xe6,
1395         0x12, 0x3e, 0xcc, 0xf8, 0x02, 0xb8, 0xc6, 0xc3, 0x47, 0xd2, 0xf5, 0xaa,
1396         0x0c, 0x5f, 0x51, 0xf5, 0xd0, 0x4c, 0x55, 0x3d, 0x07, 0x73, 0xa6, 0x57,
1397         0xce, 0x5a, 0xad, 0x42, 0x0c, 0x13, 0x0f, 0xe2, 0x31, 0x25, 0x8e, 0x72,
1398         0x12, 0x73, 0x10, 0xdb, 0x7f, 0x79, 0xeb, 0x59, 0xfc, 0xfe, 0xf7, 0x0c,
1399         0x1a, 0x81, 0x53, 0x96, 0x22, 0xb8, 0xe7, 0x58, 0xd8, 0x67, 0x80, 0x60,
1400         0xad, 0x8b, 0x55, 0x1c, 0x91, 0xf0, 0x72, 0x9a, 0x7e, 0xad, 0x37, 0xf1,
1401         0x77, 0x18, 0x96, 0x8a, 0x68, 0x70, 0xfc, 0x71, 0xa9, 0xa2, 0xe8, 0x35,
1402         0x27, 0x78, 0xf2, 0xef, 0x59, 0x36, 0x6d, 0x7c, 0xb6, 0x98, 0xd8, 0x1e,
1403         0xfa, 0x25, 0x73, 0x97, 0x45, 0x58, 0xe3, 0xae, 0xbd, 0x52, 0x54, 0x05,
1404         0xd8, 0x26, 0x26, 0xba, 0xba, 0x05, 0xb5, 0xe9, 0xe5, 0x76, 0xae, 0x25,
1405         0xdd, 0xfc, 0x10, 0x89, 0x5a, 0xa9, 0xee, 0x59, 0xc5, 0x79, 0x8b, 0xeb,
1406         0x1e, 0x2c, 0x61, 0xab, 0x0d, 0xd1, 0x10, 0x04, 0x91, 0x32, 0x77, 0x4a,
1407         0xa6, 0x64, 0x53, 0xda, 0x4c, 0xd7, 0x3a, 0x29, 0xd4, 0xf3, 0x82, 0x25,
1408         0x1d, 0x6f, 0x4a, 0x7f, 0xd3, 0x08, 0x3b, 0x42, 0x30, 0x10, 0xd8, 0xd0,
1409         0x97, 0x3a, 0xeb, 0x92, 0x63, 0xec, 0x93, 0x2b, 0x6f, 0x32, 0xd8, 0xcd,
1410         0x80, 0xd3, 0xc0, 0x4c, 0x03, 0xd5, 0xca, 0xbc, 0x8f, 0xc7, 0x43, 0x53,
1411         0x64, 0x66, 0x1c, 0x82, 0x2d, 0xfb, 0xff, 0x39, 0xba, 0xd6, 0x42, 0x62,
1412         0x02, 0x6f, 0x96, 0x36
1413     };
1414     static const unsigned char seed_data[] = {
1415         0x64, 0x46, 0x07, 0x32, 0x8d, 0x70, 0x9c, 0xb3, 0x8a, 0x35, 0xde, 0x62,
1416         0x00, 0xf2, 0x6d, 0x52, 0x37, 0x4d, 0xb3, 0x84, 0xe1, 0x9d, 0x41, 0x04,
1417         0xda, 0x7b, 0xdc, 0x0d, 0x8b, 0x5e, 0xe0, 0x84
1418     };
1419     const int gindex = 1;
1420     const int pcounter = 53;
1421     /*
1422      * The keypair was generated using
1423      * openssl genpkey -paramfile dsa_params.pem --pkeyopt pcounter:53 \
1424      *                 -pkeyopt gindex:1 \
1425      *                 -pkeyopt hexseed:644607328d709cb38a35de6200f26d -text
1426      */
1427     static const unsigned char priv_data[] = {
1428         0x00, 0x8f, 0xc5, 0x9e, 0xd0, 0xf7, 0x2a, 0x0b, 0x66, 0xf1, 0x32, 0x73,
1429         0xae, 0xf6, 0xd9, 0xd4, 0xdb, 0x2d, 0x96, 0x55, 0x89, 0xff, 0xef, 0xa8,
1430         0x5f, 0x47, 0x8f, 0xca, 0x02, 0x8a, 0xe1, 0x35, 0x90
1431     };
1432     static const unsigned char pub_data[] = {
1433         0x44, 0x19, 0xc9, 0x46, 0x45, 0x57, 0xc1, 0xa9, 0xd8, 0x30, 0x99, 0x29,
1434         0x6a, 0x4b, 0x63, 0x71, 0x69, 0x96, 0x35, 0x17, 0xb2, 0x62, 0x9b, 0x80,
1435         0x0a, 0x95, 0x9d, 0x6a, 0xc0, 0x32, 0x0d, 0x07, 0x5f, 0x19, 0x44, 0x02,
1436         0xf1, 0xbd, 0xce, 0xdf, 0x10, 0xf8, 0x02, 0x5d, 0x7d, 0x98, 0x8a, 0x73,
1437         0x89, 0x00, 0xb6, 0x24, 0xd6, 0x33, 0xe7, 0xcf, 0x8b, 0x49, 0x2a, 0xaf,
1438         0x13, 0x1c, 0xb2, 0x52, 0x15, 0xfd, 0x9b, 0xd5, 0x40, 0x4a, 0x1a, 0xda,
1439         0x29, 0x4c, 0x92, 0x7e, 0x66, 0x06, 0xdb, 0x61, 0x86, 0xac, 0xb5, 0xda,
1440         0x3c, 0x7d, 0x73, 0x7e, 0x54, 0x32, 0x68, 0xa5, 0x02, 0xbc, 0x59, 0x47,
1441         0x84, 0xd3, 0x87, 0x71, 0x5f, 0xeb, 0x43, 0x45, 0x24, 0xd3, 0xec, 0x08,
1442         0x52, 0xc2, 0x89, 0x2d, 0x9c, 0x1a, 0xcc, 0x91, 0x65, 0x5d, 0xa3, 0xa1,
1443         0x35, 0x31, 0x10, 0x1c, 0x3a, 0xa8, 0x4d, 0x18, 0xd5, 0x06, 0xaf, 0xb2,
1444         0xec, 0x5c, 0x89, 0x9e, 0x90, 0x86, 0x10, 0x01, 0xeb, 0x51, 0xd5, 0x1b,
1445         0x9c, 0xcb, 0x66, 0x07, 0x3f, 0xc4, 0x6e, 0x0a, 0x1b, 0x73, 0xa0, 0x4b,
1446         0x5f, 0x4d, 0xab, 0x35, 0x28, 0xfa, 0xda, 0x3a, 0x0c, 0x08, 0xe8, 0xf3,
1447         0xef, 0x42, 0x67, 0xbc, 0x21, 0xf2, 0xc2, 0xb8, 0xff, 0x1a, 0x81, 0x05,
1448         0x68, 0x73, 0x62, 0xdf, 0xd7, 0xab, 0x0f, 0x22, 0x89, 0x57, 0x96, 0xd4,
1449         0x93, 0xaf, 0xa1, 0x21, 0xa3, 0x48, 0xe9, 0xf0, 0x97, 0x47, 0xa0, 0x27,
1450         0xba, 0x87, 0xb8, 0x15, 0x5f, 0xff, 0x2c, 0x50, 0x41, 0xf1, 0x7e, 0xc6,
1451         0x81, 0xc4, 0x51, 0xf1, 0xfd, 0xd6, 0x86, 0xf7, 0x69, 0x97, 0xf1, 0x49,
1452         0xc9, 0xf9, 0xf4, 0x9b, 0xf4, 0xe8, 0x85, 0xa7, 0xbd, 0x36, 0x55, 0x4a,
1453         0x3d, 0xe8, 0x65, 0x09, 0x7b, 0xb7, 0x12, 0x64, 0xd2, 0x0a, 0x53, 0x60,
1454         0x48, 0xd1, 0x8a, 0xbd
1455     };
1456
1457     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1458         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
1459         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
1460         || !TEST_ptr(p = BN_bin2bn(p_data, sizeof(p_data), NULL))
1461         || !TEST_ptr(q = BN_bin2bn(q_data, sizeof(q_data), NULL))
1462         || !TEST_ptr(g = BN_bin2bn(g_data, sizeof(g_data), NULL))
1463
1464         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
1465         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
1466         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
1467         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1468                                                        OSSL_PKEY_PARAM_FFC_SEED,
1469                                                        seed_data,
1470                                                        sizeof(seed_data)))
1471         || !TEST_true(OSSL_PARAM_BLD_push_int(bld, OSSL_PKEY_PARAM_FFC_GINDEX,
1472                                               gindex))
1473         || !TEST_true(OSSL_PARAM_BLD_push_int(bld,
1474                                               OSSL_PKEY_PARAM_FFC_PCOUNTER,
1475                                               pcounter))
1476         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
1477                                              pub))
1478         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
1479                                              priv))
1480         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1481         goto err;
1482
1483     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL)))
1484         goto err;
1485
1486     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
1487         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1488                                         fromdata_params)))
1489         goto err;
1490
1491     while (dup_pk == NULL) {
1492         ret = 0;
1493         if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
1494             || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
1495             || !TEST_int_eq(EVP_PKEY_get_size(pk), 2 + 2 * (3 + sizeof(q_data)))
1496             || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1497             goto err;
1498
1499         if (!TEST_false(EVP_PKEY_get_utf8_string_param(pk,
1500                                                        OSSL_PKEY_PARAM_GROUP_NAME,
1501                                                        name_out,
1502                                                        sizeof(name_out),
1503                                                        &len))
1504             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1505                                                 &pub_out))
1506             || !TEST_BN_eq(pub, pub_out)
1507             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1508                                                 &priv_out))
1509             || !TEST_BN_eq(priv, priv_out)
1510             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P,
1511                                                 &p_out))
1512             || !TEST_BN_eq(p, p_out)
1513             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q,
1514                                                 &q_out))
1515             || !TEST_BN_eq(q, q_out)
1516             || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G,
1517                                                 &g_out))
1518             || !TEST_BN_eq(g, g_out)
1519             || !TEST_false(EVP_PKEY_get_bn_param(pk,
1520                                                  OSSL_PKEY_PARAM_FFC_COFACTOR,
1521                                                  &j_out))
1522             || !TEST_ptr_null(j_out)
1523             || !TEST_true(EVP_PKEY_get_octet_string_param(pk,
1524                                                           OSSL_PKEY_PARAM_FFC_SEED,
1525                                                           seed_out,
1526                                                           sizeof(seed_out),
1527                                                           &len))
1528             || !TEST_true(EVP_PKEY_get_int_param(pk,
1529                                                  OSSL_PKEY_PARAM_FFC_GINDEX,
1530                                                  &gindex_out))
1531             || !TEST_int_eq(gindex, gindex_out)
1532             || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
1533                                                  &hindex_out))
1534             || !TEST_int_eq(hindex_out, 0)
1535             || !TEST_true(EVP_PKEY_get_int_param(pk,
1536                                                  OSSL_PKEY_PARAM_FFC_PCOUNTER,
1537                                                  &pcounter_out))
1538             || !TEST_int_eq(pcounter, pcounter_out))
1539             goto err;
1540         BN_free(p);
1541         p = NULL;
1542         BN_free(q);
1543         q = NULL;
1544         BN_free(g);
1545         g = NULL;
1546         BN_free(j_out);
1547         j_out = NULL;
1548         BN_free(pub_out);
1549         pub_out = NULL;
1550         BN_free(priv_out);
1551         priv_out = NULL;
1552
1553         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
1554             goto err;
1555
1556         if (!TEST_true(EVP_PKEY_check(key_ctx))
1557             || !TEST_true(EVP_PKEY_public_check(key_ctx))
1558             || !TEST_true(EVP_PKEY_private_check(key_ctx))
1559             || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
1560             goto err;
1561         EVP_PKEY_CTX_free(key_ctx);
1562         key_ctx = NULL;
1563
1564         if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1565             || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1566             goto err;
1567         EVP_PKEY_free(copy_pk);
1568         copy_pk = NULL;
1569
1570         ret = test_print_key_using_pem("DSA", pk)
1571               && test_print_key_using_encoder("DSA", pk);
1572
1573         if (!ret || !TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1574             goto err;
1575         ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1576         EVP_PKEY_free(pk);
1577         pk = dup_pk;
1578         if (!ret)
1579             goto err;
1580     }
1581
1582  err:
1583     OSSL_PARAM_free(fromdata_params);
1584     OSSL_PARAM_BLD_free(bld);
1585     BN_free(p);
1586     BN_free(q);
1587     BN_free(g);
1588     BN_free(pub);
1589     BN_free(priv);
1590     BN_free(p_out);
1591     BN_free(q_out);
1592     BN_free(g_out);
1593     BN_free(pub_out);
1594     BN_free(priv_out);
1595     BN_free(j_out);
1596     EVP_PKEY_free(pk);
1597     EVP_PKEY_free(copy_pk);
1598     EVP_PKEY_CTX_free(ctx);
1599     EVP_PKEY_CTX_free(key_ctx);
1600
1601     return ret;
1602 }
1603
1604 static int test_check_dsa(void)
1605 {
1606     int ret = 0;
1607     EVP_PKEY_CTX *ctx = NULL;
1608
1609     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL))
1610         || !TEST_false(EVP_PKEY_check(ctx))
1611         || !TEST_false(EVP_PKEY_public_check(ctx))
1612         || !TEST_false(EVP_PKEY_private_check(ctx))
1613         || !TEST_false(EVP_PKEY_pairwise_check(ctx)))
1614        goto err;
1615
1616     ret = 1;
1617  err:
1618     EVP_PKEY_CTX_free(ctx);
1619
1620     return ret;
1621 }
1622 #endif /* OPENSSL_NO_DSA */
1623
1624
1625 int setup_tests(void)
1626 {
1627     if (!test_skip_common_options()) {
1628         TEST_error("Error parsing test options\n");
1629         return 0;
1630     }
1631
1632     if (!TEST_ptr(datadir = test_get_argument(0)))
1633         return 0;
1634
1635     ADD_TEST(test_evp_pkey_get_bn_param_large);
1636     ADD_TEST(test_fromdata_rsa);
1637 #ifndef OPENSSL_NO_DH
1638     ADD_TEST(test_fromdata_dh_fips186_4);
1639     ADD_TEST(test_fromdata_dh_named_group);
1640 #endif
1641 #ifndef OPENSSL_NO_DSA
1642     ADD_TEST(test_check_dsa);
1643     ADD_TEST(test_fromdata_dsa_fips186_4);
1644 #endif
1645 #ifndef OPENSSL_NO_EC
1646     ADD_ALL_TESTS(test_fromdata_ecx, 4 * 3);
1647     ADD_TEST(test_fromdata_ec);
1648     ADD_TEST(test_ec_dup_no_operation);
1649     ADD_TEST(test_ec_dup_keygen_operation);
1650 #endif
1651     return 1;
1652 }