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 = "pkcs8";
 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 = "pkcs8";
 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;
 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         || !TEST_int_eq(EVP_PKEY_bits(pk), 32)
 346         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 8)
 347         || !TEST_int_eq(EVP_PKEY_size(pk), 4)
 348         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 349         goto err;
 350
 351     if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 352         goto err;
 353
 354     if (!TEST_true(EVP_PKEY_check(key_ctx))
 355         || !TEST_true(EVP_PKEY_public_check(key_ctx))
 356         || !TEST_true(EVP_PKEY_private_check(key_ctx))
 357         || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 358         goto err;
 359
 360     /* EVP_PKEY_copy_parameters() should fail for RSA */
 361     if (!TEST_ptr(copy_pk = EVP_PKEY_new())
 362         || !TEST_false(EVP_PKEY_copy_parameters(copy_pk, pk)))
 363         goto err;
 364
 365     ret = test_print_key_using_pem("RSA", pk)
 366           && test_print_key_using_encoder("RSA", pk);
 367  err:
 368     /* for better diagnostics always compare key params */
 369     for (i = 0; fromdata_params[i].key != NULL; ++i) {
 370         if (!TEST_true(BN_set_word(bn_from, key_numbers[i]))
 371             || !TEST_true(EVP_PKEY_get_bn_param(pk, fromdata_params[i].key, &bn))
 372             || !TEST_BN_eq(bn, bn_from))
 373             ret = 0;
 374     }
 375     BN_free(bn_from);
 376     BN_free(bn);
 377     EVP_PKEY_free(pk);
 378     EVP_PKEY_free(copy_pk);
 379     EVP_PKEY_CTX_free(key_ctx);
 380     EVP_PKEY_CTX_free(ctx);
 381
 382     return ret;
 383 }
 384
 385 static int test_evp_pkey_get_bn_param_large(void)
 386 {
 387     int ret = 0;
 388     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 389     EVP_PKEY *pk = NULL;
 390     OSSL_PARAM_BLD *bld = NULL;
 391     OSSL_PARAM *fromdata_params = NULL;
 392     BIGNUM *n = NULL, *e = NULL, *d = NULL, *n_out = NULL;
 393     /*
 394      * The buffer size chosen here for n_data larger than the buffer used
 395      * internally in EVP_PKEY_get_bn_param.
 396      */
 397     static unsigned char n_data[2050];
 398     static const unsigned char e_data[] = {
 399         0x1, 0x00, 0x01
 400     };
 401     static const unsigned char d_data[]= {
 402        0x99, 0x33, 0x13, 0x7b
 403     };
 404
 405     /* N is a large buffer */
 406     memset(n_data, 0xCE, sizeof(n_data));
 407
 408     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 409         || !TEST_ptr(n = BN_bin2bn(n_data, sizeof(n_data), NULL))
 410         || !TEST_ptr(e = BN_bin2bn(e_data, sizeof(e_data), NULL))
 411         || !TEST_ptr(d = BN_bin2bn(d_data, sizeof(d_data), NULL))
 412         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
 413         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
 414         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d))
 415         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld))
 416         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL))
 417         || !TEST_true(EVP_PKEY_fromdata_init(ctx))
 418         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 419                                         fromdata_params))
 420         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, ""))
 421         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_RSA_N, &n_out))
 422         || !TEST_BN_eq(n, n_out))
 423         goto err;
 424     ret = 1;
 425  err:
 426     BN_free(n_out);
 427     BN_free(n);
 428     BN_free(e);
 429     BN_free(d);
 430     EVP_PKEY_free(pk);
 431     EVP_PKEY_CTX_free(key_ctx);
 432     EVP_PKEY_CTX_free(ctx);
 433     OSSL_PARAM_BLD_free_params(fromdata_params);
 434     OSSL_PARAM_BLD_free(bld);
 435     return ret;
 436 }
 437
 438
 439 #ifndef OPENSSL_NO_DH
 440 static int test_fromdata_dh_named_group(void)
 441 {
 442     int ret = 0;
 443     int gindex = 0, pcounter = 0, hindex = 0;
 444     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 445     EVP_PKEY *pk = NULL, *copy_pk = NULL;
 446     size_t len;
 447     BIGNUM *pub = NULL, *priv = NULL;
 448     BIGNUM *pub_out = NULL, *priv_out = NULL;
 449     BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
 450     OSSL_PARAM *fromdata_params = NULL;
 451     OSSL_PARAM_BLD *bld = NULL;
 452     char name_out[80];
 453     unsigned char seed_out[32];
 454
 455     /*
 456      * DH key data was generated using the following:
 457      * openssl genpkey -algorithm DH -pkeyopt group:ffdhe2048
 458      *                 -pkeyopt priv_len:224 -text
 459      */
 460     static const unsigned char priv_data[] = {
 461         0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf, 0x63, 0x5d,
 462         0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21, 0x2b, 0xfa, 0x55, 0xfa,
 463         0x87, 0xe8, 0xa9, 0x7b,
 464     };
 465     static const unsigned char pub_data[] = {
 466         0x00, 0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1,
 467         0x82, 0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd,
 468         0x33, 0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c,
 469         0x64, 0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6,
 470         0xf9, 0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5,
 471         0xfa, 0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03,
 472         0x9d, 0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9,
 473         0x7e, 0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a,
 474         0x57, 0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa,
 475         0xe5, 0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef,
 476         0x9a, 0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1,
 477         0xdb, 0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7,
 478         0x22, 0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f,
 479         0x7c, 0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20,
 480         0x82, 0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77,
 481         0x14, 0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2,
 482         0x6e, 0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12,
 483         0xbc, 0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0,
 484         0xf1, 0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67,
 485         0xa1, 0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc,
 486         0xa8, 0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab,
 487         0xcf, 0x33, 0x42, 0x83, 0x42
 488     };
 489     static const char group_name[] = "ffdhe2048";
 490     static const long priv_len = 224;
 491
 492     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 493         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
 494         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
 495         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 496                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 497                                                       group_name, 0))
 498         || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
 499                                                priv_len))
 500         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
 501         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
 502         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
 503         goto err;
 504
 505     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
 506         goto err;
 507
 508     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 509         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 510                                         fromdata_params))
 511         || !TEST_int_eq(EVP_PKEY_bits(pk), 2048)
 512         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 112)
 513         || !TEST_int_eq(EVP_PKEY_size(pk), 256)
 514         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 515         goto err;
 516
 517     if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
 518                                                   name_out, sizeof(name_out),
 519                                                   &len))
 520         || !TEST_str_eq(name_out, group_name)
 521         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
 522                                             &pub_out))
 523
 524         || !TEST_BN_eq(pub, pub_out)
 525         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
 526                                             &priv_out))
 527         || !TEST_BN_eq(priv, priv_out)
 528         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
 529         || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
 530         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
 531         || !TEST_ptr(q)
 532         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
 533         || !TEST_BN_eq(&ossl_bignum_const_2, g)
 534         || !TEST_false(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_COFACTOR,
 535                                              &j))
 536         || !TEST_ptr_null(j)
 537         || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
 538                                                        OSSL_PKEY_PARAM_FFC_SEED,
 539                                                        seed_out,
 540                                                        sizeof(seed_out), &len))
 541         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_GINDEX,
 542                                              &gindex))
 543         || !TEST_int_eq(gindex, -1)
 544         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H, &hindex))
 545         || !TEST_int_eq(hindex, 0)
 546         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_PCOUNTER,
 547                                              &pcounter))
 548         || !TEST_int_eq(pcounter, -1))
 549         goto err;
 550
 551     if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 552         goto err;
 553
 554     if (!TEST_true(EVP_PKEY_check(key_ctx))
 555         || !TEST_true(EVP_PKEY_public_check(key_ctx))
 556         || !TEST_true(EVP_PKEY_private_check(key_ctx))
 557         || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 558         goto err;
 559
 560     if (!TEST_ptr(copy_pk = EVP_PKEY_new())
 561         || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
 562         goto err;
 563
 564     ret = test_print_key_using_pem("DH", pk)
 565           && test_print_key_using_encoder("DH", pk);
 566 err:
 567     BN_free(p);
 568     BN_free(q);
 569     BN_free(g);
 570     BN_free(j);
 571     BN_free(pub);
 572     BN_free(priv);
 573     BN_free(pub_out);
 574     BN_free(priv_out);
 575     EVP_PKEY_free(copy_pk);
 576     EVP_PKEY_free(pk);
 577     EVP_PKEY_CTX_free(ctx);
 578     EVP_PKEY_CTX_free(key_ctx);
 579     OSSL_PARAM_BLD_free_params(fromdata_params);
 580     OSSL_PARAM_BLD_free(bld);
 581
 582     return ret;
 583 }
 584
 585 static int test_fromdata_dh_fips186_4(void)
 586 {
 587     int ret = 0;
 588     int gindex = 0, pcounter = 0, hindex = 0;
 589     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
 590     EVP_PKEY *pk = NULL;
 591     size_t len;
 592     BIGNUM *pub = NULL, *priv = NULL;
 593     BIGNUM *pub_out = NULL, *priv_out = NULL;
 594     BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
 595     OSSL_PARAM_BLD *bld = NULL;
 596     OSSL_PARAM *fromdata_params = NULL;
 597     char name_out[80];
 598     unsigned char seed_out[32];
 599
 600     /*
 601      * DH key data was generated using the following:
 602      * openssl genpkey -algorithm DH
 603      *                 -pkeyopt group:ffdhe2048 -pkeyopt priv_len:224 -text
 604      */
 605     static const unsigned char priv_data[] = {
 606        0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf, 0x63, 0x5d,
 607        0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21, 0x2b, 0xfa, 0x55, 0xfa,
 608        0x87, 0xe8, 0xa9, 0x7b,
 609     };
 610     static const unsigned char pub_data[] = {
 611        0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1, 0x82,
 612        0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd, 0x33,
 613        0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c, 0x64,
 614        0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6, 0xf9,
 615        0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5, 0xfa,
 616        0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03, 0x9d,
 617        0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9, 0x7e,
 618        0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a, 0x57,
 619        0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa, 0xe5,
 620        0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef, 0x9a,
 621        0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1, 0xdb,
 622        0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7, 0x22,
 623        0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f, 0x7c,
 624        0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20, 0x82,
 625        0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77, 0x14,
 626        0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2, 0x6e,
 627        0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12, 0xbc,
 628        0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0, 0xf1,
 629        0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67, 0xa1,
 630        0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc, 0xa8,
 631        0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab, 0xcf,
 632        0x33, 0x42, 0x83, 0x42
 633     };
 634     static const char group_name[] = "ffdhe2048";
 635     static const long priv_len = 224;
 636
 637
 638     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 639         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
 640         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
 641         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 642                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 643                                                       group_name, 0))
 644         || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
 645                                                priv_len))
 646         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
 647         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
 648         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
 649         goto err;
 650
 651     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
 652         goto err;
 653
 654     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 655         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 656                                         fromdata_params))
 657         || !TEST_int_eq(EVP_PKEY_bits(pk), 2048)
 658         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 112)
 659         || !TEST_int_eq(EVP_PKEY_size(pk), 256)
 660         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 661         goto err;
 662
 663     if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
 664                                                   name_out, sizeof(name_out),
 665                                                   &len))
 666         || !TEST_str_eq(name_out, group_name)
 667         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
 668                                             &pub_out))
 669         || !TEST_BN_eq(pub, pub_out)
 670         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
 671                                             &priv_out))
 672         || !TEST_BN_eq(priv, priv_out)
 673         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
 674         || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
 675         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
 676         || !TEST_ptr(q)
 677         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
 678         || !TEST_BN_eq(&ossl_bignum_const_2, g)
 679         || !TEST_false(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_COFACTOR,
 680                                              &j))
 681         || !TEST_ptr_null(j)
 682         || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
 683                                                        OSSL_PKEY_PARAM_FFC_SEED,
 684                                                        seed_out,
 685                                                        sizeof(seed_out), &len))
 686         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_GINDEX,
 687                                              &gindex))
 688         || !TEST_int_eq(gindex, -1)
 689         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H, &hindex))
 690         || !TEST_int_eq(hindex, 0)
 691         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_PCOUNTER,
 692                                              &pcounter))
 693         || !TEST_int_eq(pcounter, -1))
 694         goto err;
 695
 696     if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
 697         goto err;
 698
 699     if (!TEST_true(EVP_PKEY_check(key_ctx))
 700         || !TEST_true(EVP_PKEY_public_check(key_ctx))
 701         || !TEST_true(EVP_PKEY_private_check(key_ctx))
 702         || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
 703         goto err;
 704
 705     ret = test_print_key_using_pem("DH", pk)
 706           && test_print_key_using_encoder("DH", pk);
 707 err:
 708     BN_free(p);
 709     BN_free(q);
 710     BN_free(g);
 711     BN_free(j);
 712     BN_free(pub);
 713     BN_free(priv);
 714     BN_free(pub_out);
 715     BN_free(priv_out);
 716     EVP_PKEY_free(pk);
 717     EVP_PKEY_CTX_free(ctx);
 718     EVP_PKEY_CTX_free(key_ctx);
 719     OSSL_PARAM_BLD_free_params(fromdata_params);
 720     OSSL_PARAM_BLD_free(bld);
 721
 722     return ret;
 723 }
 724
 725 #endif
 726
 727
 728
 729 #ifndef OPENSSL_NO_EC
 730 /* Array indexes used in test_fromdata_ecx */
 731 # define PRIV_KEY        0
 732 # define PUB_KEY         1
 733
 734 # define X25519_IDX      0
 735 # define X448_IDX        1
 736 # define ED25519_IDX     2
 737 # define ED448_IDX       3
 738
 739 /*
 740  * tst uses indexes 0 ... (3 * 4 - 1)
 741  * For the 4 ECX key types (X25519_IDX..ED448_IDX)
 742  * 0..3  = public + private key.
 743  * 4..7  = private key (This will generate the public key from the private key)
 744  * 8..11 = public key
 745  */
 746 static int test_fromdata_ecx(int tst)
 747 {
 748     int ret = 0;
 749     EVP_PKEY_CTX *ctx = NULL, *ctx2 = NULL;
 750     EVP_PKEY *pk = NULL, *copy_pk = NULL;
 751     const char *alg = NULL;
 752     size_t len;
 753     unsigned char out_pub[ED448_KEYLEN];
 754     unsigned char out_priv[ED448_KEYLEN];
 755     OSSL_PARAM params[3] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
 756
 757     /* ED448_KEYLEN > X448_KEYLEN > X25519_KEYLEN == ED25519_KEYLEN */
 758     static unsigned char key_numbers[4][2][ED448_KEYLEN] = {
 759         /* X25519: Keys from RFC 7748 6.1 */
 760         {
 761             /* Private Key */
 762             {
 763                 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
 764                 0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
 765                 0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
 766                 0x2c, 0x2a
 767             },
 768             /* Public Key */
 769             {
 770                 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
 771                 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
 772                 0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
 773                 0x4e, 0x6a
 774             }
 775         },
 776         /* X448: Keys from RFC 7748 6.2 */
 777         {
 778             /* Private Key */
 779             {
 780                 0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
 781                 0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
 782                 0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
 783                 0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
 784                 0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
 785                 0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
 786             },
 787             /* Public Key */
 788             {
 789                 0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
 790                 0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
 791                 0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
 792                 0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
 793                 0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
 794                 0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
 795             }
 796         },
 797         /* ED25519: Keys from RFC 8032 */
 798         {
 799             /* Private Key */
 800             {
 801                 0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84,
 802                 0x4a, 0xf4, 0x92, 0xec, 0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69,
 803                 0x7b, 0x32, 0x69, 0x19, 0x70, 0x3b, 0xac, 0x03, 0x1c, 0xae,
 804                 0x7f, 0x60
 805             },
 806             /* Public Key */
 807             {
 808                 0xd7, 0x5a, 0x98, 0x01, 0x82, 0xb1, 0x0a, 0xb7, 0xd5, 0x4b,
 809                 0xfe, 0xd3, 0xc9, 0x64, 0x07, 0x3a, 0x0e, 0xe1, 0x72, 0xf3,
 810                 0xda, 0xa6, 0x23, 0x25, 0xaf, 0x02, 0x1a, 0x68, 0xf7, 0x07,
 811                 0x51, 0x1a
 812             }
 813         },
 814         /* ED448: Keys from RFC 8032 */
 815         {
 816             /* Private Key */
 817             {
 818                 0x6c, 0x82, 0xa5, 0x62, 0xcb, 0x80, 0x8d, 0x10, 0xd6, 0x32,
 819                 0xbe, 0x89, 0xc8, 0x51, 0x3e, 0xbf, 0x6c, 0x92, 0x9f, 0x34,
 820                 0xdd, 0xfa, 0x8c, 0x9f, 0x63, 0xc9, 0x96, 0x0e, 0xf6, 0xe3,
 821                 0x48, 0xa3, 0x52, 0x8c, 0x8a, 0x3f, 0xcc, 0x2f, 0x04, 0x4e,
 822                 0x39, 0xa3, 0xfc, 0x5b, 0x94, 0x49, 0x2f, 0x8f, 0x03, 0x2e,
 823                 0x75, 0x49, 0xa2, 0x00, 0x98, 0xf9, 0x5b
 824             },
 825             /* Public Key */
 826             {
 827                 0x5f, 0xd7, 0x44, 0x9b, 0x59, 0xb4, 0x61, 0xfd, 0x2c, 0xe7,
 828                 0x87, 0xec, 0x61, 0x6a, 0xd4, 0x6a, 0x1d, 0xa1, 0x34, 0x24,
 829                 0x85, 0xa7, 0x0e, 0x1f, 0x8a, 0x0e, 0xa7, 0x5d, 0x80, 0xe9,
 830                 0x67, 0x78, 0xed, 0xf1, 0x24, 0x76, 0x9b, 0x46, 0xc7, 0x06,
 831                 0x1b, 0xd6, 0x78, 0x3d, 0xf1, 0xe5, 0x0f, 0x6c, 0xd1, 0xfa,
 832                 0x1a, 0xbe, 0xaf, 0xe8, 0x25, 0x61, 0x80
 833             }
 834         }
 835     };
 836     OSSL_PARAM x25519_fromdata_params[] = {
 837         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 838                                 key_numbers[X25519_IDX][PRIV_KEY],
 839                                 X25519_KEYLEN),
 840         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 841                                 key_numbers[X25519_IDX][PUB_KEY],
 842                                 X25519_KEYLEN),
 843         OSSL_PARAM_END
 844     };
 845     OSSL_PARAM x448_fromdata_params[] = {
 846         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 847                                 key_numbers[X448_IDX][PRIV_KEY],
 848                                 X448_KEYLEN),
 849         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 850                                 key_numbers[X448_IDX][PUB_KEY],
 851                                 X448_KEYLEN),
 852         OSSL_PARAM_END
 853     };
 854     OSSL_PARAM ed25519_fromdata_params[] = {
 855         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 856                                 key_numbers[ED25519_IDX][PRIV_KEY],
 857                                 ED25519_KEYLEN),
 858         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 859                                 key_numbers[ED25519_IDX][PUB_KEY],
 860                                 ED25519_KEYLEN),
 861         OSSL_PARAM_END
 862     };
 863     OSSL_PARAM ed448_fromdata_params[] = {
 864         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 865                                 key_numbers[ED448_IDX][PRIV_KEY],
 866                                 ED448_KEYLEN),
 867         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 868                                 key_numbers[ED448_IDX][PUB_KEY],
 869                                 ED448_KEYLEN),
 870         OSSL_PARAM_END
 871     };
 872     OSSL_PARAM *fromdata_params = NULL;
 873     int bits = 0, security_bits = 0, size = 0;
 874     OSSL_PARAM *orig_fromdata_params = NULL;
 875
 876     switch (tst & 3) {
 877     case X25519_IDX:
 878         fromdata_params = x25519_fromdata_params;
 879         bits = X25519_BITS;
 880         security_bits = X25519_SECURITY_BITS;
 881         size = X25519_KEYLEN;
 882         alg = "X25519";
 883         break;
 884
 885     case X448_IDX:
 886         fromdata_params = x448_fromdata_params;
 887         bits = X448_BITS;
 888         security_bits = X448_SECURITY_BITS;
 889         size = X448_KEYLEN;
 890         alg = "X448";
 891         break;
 892
 893     case ED25519_IDX:
 894         fromdata_params = ed25519_fromdata_params;
 895         bits = ED25519_BITS;
 896         security_bits = ED25519_SECURITY_BITS;
 897         size = ED25519_KEYLEN;
 898         alg = "ED25519";
 899         break;
 900
 901     case ED448_IDX:
 902         fromdata_params = ed448_fromdata_params;
 903         bits = ED448_BITS;
 904         security_bits = ED448_SECURITY_BITS;
 905         size = ED448_KEYLEN;
 906         alg = "ED448";
 907         break;
 908     default:
 909         goto err;
 910     }
 911
 912     ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
 913     if (!TEST_ptr(ctx))
 914         goto err;
 915
 916     orig_fromdata_params = fromdata_params;
 917     if (tst > 7) {
 918         /* public key only */
 919         fromdata_params++;
 920     } else if (tst > 3) {
 921         /* private key only */
 922         params[0] = fromdata_params[0];
 923         params[1] = fromdata_params[2];
 924         fromdata_params = params;
 925     }
 926
 927     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
 928         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
 929                                         fromdata_params))
 930         || !TEST_int_eq(EVP_PKEY_bits(pk), bits)
 931         || !TEST_int_eq(EVP_PKEY_security_bits(pk), security_bits)
 932         || !TEST_int_eq(EVP_PKEY_size(pk), size)
 933         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
 934         goto err;
 935
 936     if (!TEST_ptr(ctx2 = EVP_PKEY_CTX_new_from_pkey(NULL, pk, NULL)))
 937         goto err;
 938     if (tst <= 7) {
 939         if (!TEST_true(EVP_PKEY_check(ctx2)))
 940             goto err;
 941         if (!TEST_true(EVP_PKEY_get_octet_string_param(
 942                            pk, orig_fromdata_params[PRIV_KEY].key,
 943                            out_priv, sizeof(out_priv), &len))
 944             || !TEST_mem_eq(out_priv, len,
 945                             orig_fromdata_params[PRIV_KEY].data,
 946                             orig_fromdata_params[PRIV_KEY].data_size)
 947             || !TEST_true(EVP_PKEY_get_octet_string_param(
 948                               pk, orig_fromdata_params[PUB_KEY].key,
 949                               out_pub, sizeof(out_pub), &len))
 950             || !TEST_mem_eq(out_pub, len,
 951                             orig_fromdata_params[PUB_KEY].data,
 952                             orig_fromdata_params[PUB_KEY].data_size))
 953             goto err;
 954     } else {
 955         /* The private key check should fail if there is only a public key */
 956         if (!TEST_true(EVP_PKEY_public_check(ctx2))
 957             || !TEST_false(EVP_PKEY_private_check(ctx2))
 958             || !TEST_false(EVP_PKEY_check(ctx2)))
 959             goto err;
 960     }
 961
 962     if (!TEST_ptr(copy_pk = EVP_PKEY_new())
 963            /* This should succeed because there are no parameters to copy */
 964         || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
 965         goto err;
 966
 967     if (tst > 7)
 968         ret = test_print_key_using_encoder_public(alg, pk);
 969     else
 970         ret = test_print_key_using_pem(alg, pk)
 971               && test_print_key_using_encoder(alg, pk);
 972
 973 err:
 974     EVP_PKEY_free(pk);
 975     EVP_PKEY_free(copy_pk);
 976     EVP_PKEY_CTX_free(ctx);
 977     EVP_PKEY_CTX_free(ctx2);
 978
 979     return ret;
 980 }
 981
 982 #define CURVE_NAME 2
 983
 984 static int test_fromdata_ec(void)
 985 {
 986     int ret = 0;
 987     EVP_PKEY_CTX *ctx = NULL;
 988     EVP_PKEY *pk = NULL, *copy_pk = NULL;
 989     OSSL_PARAM_BLD *bld = NULL;
 990     BIGNUM *ec_priv_bn = NULL;
 991     BIGNUM *bn_priv = NULL;
 992     OSSL_PARAM *fromdata_params = NULL;
 993     const char *alg = "EC";
 994     const char *curve = "prime256v1";
 995     /* UNCOMPRESSED FORMAT */
 996     static const unsigned char ec_pub_keydata[] = {
 997        POINT_CONVERSION_UNCOMPRESSED,
 998        0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
 999        0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
1000        0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
1001        0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
1002        0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
1003        0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
1004        0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
1005        0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
1006     };
1007     static const unsigned char ec_priv_keydata[] = {
1008         0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
1009         0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
1010         0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
1011         0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
1012     };
1013     const int compressed_sz = 1 + (sizeof(ec_pub_keydata) - 1) / 2;
1014     unsigned char out_pub[sizeof(ec_pub_keydata)];
1015     char out_curve_name[80];
1016     const OSSL_PARAM *gettable = NULL;
1017     size_t len;
1018
1019
1020     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new()))
1021         goto err;
1022     if (!TEST_ptr(ec_priv_bn = BN_bin2bn(ec_priv_keydata,
1023                                          sizeof(ec_priv_keydata), NULL)))
1024         goto err;
1025
1026     if (OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME,
1027                                         curve, 0) <= 0)
1028         goto err;
1029     if (OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY,
1030                                          ec_pub_keydata,
1031                                          sizeof(ec_pub_keydata)) <= 0)
1032         goto err;
1033     if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, ec_priv_bn) <= 0)
1034         goto err;
1035     if (!TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1036         goto err;
1037     ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
1038     if (!TEST_ptr(ctx))
1039         goto err;
1040
1041     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
1042         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1043                                         fromdata_params))
1044         || !TEST_int_eq(EVP_PKEY_bits(pk), 256)
1045         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 128)
1046         || !TEST_int_eq(EVP_PKEY_size(pk), 2 + 35 * 2)
1047         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1048         goto err;
1049
1050     if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1051         || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1052         goto err;
1053
1054     if (!TEST_ptr(gettable = EVP_PKEY_gettable_params(pk))
1055         || !TEST_ptr(OSSL_PARAM_locate_const(gettable, OSSL_PKEY_PARAM_GROUP_NAME))
1056         || !TEST_ptr(OSSL_PARAM_locate_const(gettable, OSSL_PKEY_PARAM_PUB_KEY))
1057         || !TEST_ptr(OSSL_PARAM_locate_const(gettable, OSSL_PKEY_PARAM_PRIV_KEY)))
1058         goto err;
1059
1060     if (!EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
1061                                         out_curve_name, sizeof(out_curve_name),
1062                                         &len)
1063         || !TEST_str_eq(out_curve_name, curve)
1064         || !EVP_PKEY_get_octet_string_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1065                                             out_pub, sizeof(out_pub), &len)
1066         || !TEST_true(out_pub[0] == (POINT_CONVERSION_COMPRESSED + 1))
1067         || !TEST_mem_eq(out_pub + 1, len - 1,
1068                         ec_pub_keydata + 1, compressed_sz - 1)
1069         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1070                                             &bn_priv))
1071         || !TEST_BN_eq(ec_priv_bn, bn_priv))
1072         goto err;
1073
1074     ret = test_print_key_using_pem(alg, pk)
1075           && test_print_key_using_encoder(alg, pk);
1076 err:
1077     BN_free(bn_priv);
1078     BN_free(ec_priv_bn);
1079     OSSL_PARAM_BLD_free_params(fromdata_params);
1080     OSSL_PARAM_BLD_free(bld);
1081     EVP_PKEY_free(pk);
1082     EVP_PKEY_free(copy_pk);
1083     EVP_PKEY_CTX_free(ctx);
1084     return ret;
1085 }
1086
1087 static int test_ec_dup_no_operation(void)
1088 {
1089     int ret = 0;
1090     EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1091     EVP_PKEY *param = NULL, *pkey = NULL;
1092
1093     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1094         || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1095         || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1096                         NID_X9_62_prime256v1), 0)
1097         || !TEST_int_gt(EVP_PKEY_paramgen(pctx, &param), 0)
1098         || !TEST_ptr(param))
1099         goto err;
1100
1101     EVP_PKEY_CTX_free(pctx);
1102     pctx = NULL;
1103
1104     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1105         || !TEST_ptr(kctx = EVP_PKEY_CTX_dup(ctx))
1106         || !TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1107         || !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0))
1108         goto err;
1109     ret = 1;
1110 err:
1111     EVP_PKEY_free(pkey);
1112     EVP_PKEY_free(param);
1113     EVP_PKEY_CTX_free(ctx);
1114     EVP_PKEY_CTX_free(kctx);
1115     EVP_PKEY_CTX_free(pctx);
1116     return ret;
1117 }
1118
1119 /* Test that keygen doesn't support EVP_PKEY_CTX_dup */
1120 static int test_ec_dup_keygen_operation(void)
1121 {
1122     int ret = 0;
1123     EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1124     EVP_PKEY *param = NULL, *pkey = NULL;
1125
1126     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1127         || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1128         || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1129                         NID_X9_62_prime256v1), 0)
1130         || !TEST_int_gt(EVP_PKEY_paramgen(pctx, &param), 0)
1131         || !TEST_ptr(param))
1132         goto err;
1133
1134     EVP_PKEY_CTX_free(pctx);
1135     pctx = NULL;
1136
1137     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1138         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1139         || !TEST_ptr_null(kctx = EVP_PKEY_CTX_dup(ctx)))
1140         goto err;
1141     ret = 1;
1142 err:
1143     EVP_PKEY_free(pkey);
1144     EVP_PKEY_free(param);
1145     EVP_PKEY_CTX_free(ctx);
1146     EVP_PKEY_CTX_free(kctx);
1147     EVP_PKEY_CTX_free(pctx);
1148     return ret;
1149 }
1150
1151 #endif /* OPENSSL_NO_EC */
1152
1153 #ifndef OPENSSL_NO_DSA
1154 static int test_fromdata_dsa_fips186_4(void)
1155 {
1156     int ret = 0;
1157     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
1158     EVP_PKEY *pk = NULL, *copy_pk = NULL;
1159     BIGNUM *pub = NULL, *priv = NULL;
1160     BIGNUM *p = NULL, *q = NULL, *g = NULL;
1161     BIGNUM *pub_out = NULL, *priv_out = NULL;
1162     BIGNUM *p_out = NULL, *q_out = NULL, *g_out = NULL, *j_out = NULL;
1163     int gindex_out = 0, pcounter_out = 0, hindex_out = 0;
1164     char name_out[80];
1165     unsigned char seed_out[32];
1166     size_t len;
1167     OSSL_PARAM_BLD *bld = NULL;
1168     OSSL_PARAM *fromdata_params = NULL;
1169
1170     /*
1171      * DSA parameter data was generated using the following:
1172      * openssl genpkey -genparam -algorithm DSA -pkeyopt pbits:2048 \
1173      *                 -pkeyopt qbits:256 -pkeyopt type:0 \
1174      *                 -pkeyopt gindex:1 -out dsa_params.pem -text
1175      */
1176     static const unsigned char p_data[] = {
1177         0x00, 0xa0, 0xb7, 0x02, 0xc4, 0xac, 0xa6, 0x42, 0xab, 0xf2, 0x34, 0x0b,
1178         0x22, 0x47, 0x1f, 0x33, 0xcf, 0xd5, 0x04, 0xe4, 0x3e, 0xec, 0xa1, 0x21,
1179         0xc8, 0x41, 0x2b, 0xef, 0xb8, 0x1f, 0x0b, 0x5b, 0x88, 0x8b, 0x67, 0xf8,
1180         0x68, 0x6d, 0x7c, 0x4d, 0x96, 0x5f, 0x3c, 0x66, 0xef, 0x58, 0x34, 0xd7,
1181         0xf6, 0xa2, 0x1b, 0xad, 0xc8, 0x12, 0x52, 0xb8, 0xe8, 0x2a, 0x63, 0xcc,
1182         0xea, 0xe7, 0x4e, 0xc8, 0x34, 0x4c, 0x58, 0x59, 0x0a, 0xc2, 0x4a, 0xe4,
1183         0xb4, 0x64, 0x20, 0xf4, 0xf6, 0x0a, 0xcf, 0x86, 0x01, 0x6c, 0x7f, 0x23,
1184         0x4a, 0x51, 0x07, 0x99, 0x42, 0x28, 0x7a, 0xff, 0x18, 0x67, 0x52, 0x64,
1185         0xf2, 0x9a, 0x62, 0x30, 0xc3, 0x00, 0xde, 0x23, 0xe9, 0x11, 0x95, 0x7e,
1186         0xd1, 0x3d, 0x8d, 0xb4, 0x0e, 0x9f, 0x9e, 0xb1, 0x30, 0x03, 0xf0, 0x73,
1187         0xa8, 0x40, 0x48, 0x42, 0x7b, 0x60, 0xa0, 0xc4, 0xf2, 0x3b, 0x2d, 0x0a,
1188         0x0c, 0xb8, 0x19, 0xfb, 0xb4, 0xf8, 0xe0, 0x2a, 0xc7, 0xf1, 0xc0, 0xc6,
1189         0x86, 0x14, 0x60, 0x12, 0x0f, 0xc0, 0xde, 0x4a, 0x67, 0xec, 0xc7, 0xde,
1190         0x76, 0x21, 0x1a, 0x55, 0x7f, 0x86, 0xc3, 0x97, 0x98, 0xce, 0xf5, 0xcd,
1191         0xf0, 0xe7, 0x12, 0xd6, 0x93, 0xee, 0x1b, 0x9b, 0x61, 0xef, 0x05, 0x8c,
1192         0x45, 0x46, 0xd9, 0x64, 0x6f, 0xbe, 0x27, 0xaa, 0x67, 0x01, 0xcc, 0x71,
1193         0xb1, 0x60, 0xce, 0x21, 0xd8, 0x51, 0x17, 0x27, 0x0d, 0x90, 0x3d, 0x18,
1194         0x7c, 0x87, 0x15, 0x8e, 0x48, 0x4c, 0x6c, 0xc5, 0x72, 0xeb, 0xb7, 0x56,
1195         0xf5, 0x6b, 0x60, 0x8f, 0xc2, 0xfd, 0x3f, 0x46, 0x5c, 0x00, 0x91, 0x85,
1196         0x79, 0x45, 0x5b, 0x1c, 0x82, 0xc4, 0x87, 0x50, 0x79, 0xba, 0xcc, 0x1c,
1197         0x32, 0x7e, 0x2e, 0xb8, 0x2e, 0xc5, 0x4e, 0xd1, 0x9b, 0xdb, 0x66, 0x79,
1198         0x7c, 0xfe, 0xaf, 0x6a, 0x05
1199     };
1200     static const unsigned char q_data[] = {
1201         0xa8, 0xcd, 0xf4, 0x33, 0x7b, 0x13, 0x0a, 0x24, 0xc1, 0xde, 0x4a, 0x04,
1202         0x7b, 0x4b, 0x71, 0x51, 0x32, 0xe9, 0x47, 0x74, 0xbd, 0x0c, 0x21, 0x40,
1203         0x84, 0x12, 0x0a, 0x17, 0x73, 0xdb, 0x29, 0xc7
1204     };
1205     static const unsigned char g_data[] = {
1206         0x6c, 0xc6, 0xa4, 0x3e, 0x61, 0x84, 0xc1, 0xff, 0x6f, 0x4a, 0x1a, 0x6b,
1207         0xb0, 0x24, 0x4b, 0xd2, 0x92, 0x5b, 0x29, 0x5c, 0x61, 0xb8, 0xc9, 0x2b,
1208         0xd6, 0xf7, 0x59, 0xfd, 0xd8, 0x70, 0x66, 0x77, 0xfc, 0xc1, 0xa4, 0xd4,
1209         0xb0, 0x1e, 0xd5, 0xbf, 0x59, 0x98, 0xb3, 0x66, 0x8b, 0xf4, 0x2e, 0xe6,
1210         0x12, 0x3e, 0xcc, 0xf8, 0x02, 0xb8, 0xc6, 0xc3, 0x47, 0xd2, 0xf5, 0xaa,
1211         0x0c, 0x5f, 0x51, 0xf5, 0xd0, 0x4c, 0x55, 0x3d, 0x07, 0x73, 0xa6, 0x57,
1212         0xce, 0x5a, 0xad, 0x42, 0x0c, 0x13, 0x0f, 0xe2, 0x31, 0x25, 0x8e, 0x72,
1213         0x12, 0x73, 0x10, 0xdb, 0x7f, 0x79, 0xeb, 0x59, 0xfc, 0xfe, 0xf7, 0x0c,
1214         0x1a, 0x81, 0x53, 0x96, 0x22, 0xb8, 0xe7, 0x58, 0xd8, 0x67, 0x80, 0x60,
1215         0xad, 0x8b, 0x55, 0x1c, 0x91, 0xf0, 0x72, 0x9a, 0x7e, 0xad, 0x37, 0xf1,
1216         0x77, 0x18, 0x96, 0x8a, 0x68, 0x70, 0xfc, 0x71, 0xa9, 0xa2, 0xe8, 0x35,
1217         0x27, 0x78, 0xf2, 0xef, 0x59, 0x36, 0x6d, 0x7c, 0xb6, 0x98, 0xd8, 0x1e,
1218         0xfa, 0x25, 0x73, 0x97, 0x45, 0x58, 0xe3, 0xae, 0xbd, 0x52, 0x54, 0x05,
1219         0xd8, 0x26, 0x26, 0xba, 0xba, 0x05, 0xb5, 0xe9, 0xe5, 0x76, 0xae, 0x25,
1220         0xdd, 0xfc, 0x10, 0x89, 0x5a, 0xa9, 0xee, 0x59, 0xc5, 0x79, 0x8b, 0xeb,
1221         0x1e, 0x2c, 0x61, 0xab, 0x0d, 0xd1, 0x10, 0x04, 0x91, 0x32, 0x77, 0x4a,
1222         0xa6, 0x64, 0x53, 0xda, 0x4c, 0xd7, 0x3a, 0x29, 0xd4, 0xf3, 0x82, 0x25,
1223         0x1d, 0x6f, 0x4a, 0x7f, 0xd3, 0x08, 0x3b, 0x42, 0x30, 0x10, 0xd8, 0xd0,
1224         0x97, 0x3a, 0xeb, 0x92, 0x63, 0xec, 0x93, 0x2b, 0x6f, 0x32, 0xd8, 0xcd,
1225         0x80, 0xd3, 0xc0, 0x4c, 0x03, 0xd5, 0xca, 0xbc, 0x8f, 0xc7, 0x43, 0x53,
1226         0x64, 0x66, 0x1c, 0x82, 0x2d, 0xfb, 0xff, 0x39, 0xba, 0xd6, 0x42, 0x62,
1227         0x02, 0x6f, 0x96, 0x36
1228     };
1229     static const unsigned char seed_data[] = {
1230         0x64, 0x46, 0x07, 0x32, 0x8d, 0x70, 0x9c, 0xb3, 0x8a, 0x35, 0xde, 0x62,
1231         0x00, 0xf2, 0x6d, 0x52, 0x37, 0x4d, 0xb3, 0x84, 0xe1, 0x9d, 0x41, 0x04,
1232         0xda, 0x7b, 0xdc, 0x0d, 0x8b, 0x5e, 0xe0, 0x84
1233     };
1234     const int gindex = 1;
1235     const int pcounter = 53;
1236     /*
1237      * The keypair was generated using
1238      * openssl genpkey -paramfile dsa_params.pem --pkeyopt pcounter:53 \
1239      *                 -pkeyopt gindex:1 \
1240      *                 -pkeyopt hexseed:644607328d709cb38a35de6200f26d -text
1241      */
1242     static const unsigned char priv_data[] = {
1243         0x00, 0x8f, 0xc5, 0x9e, 0xd0, 0xf7, 0x2a, 0x0b, 0x66, 0xf1, 0x32, 0x73,
1244         0xae, 0xf6, 0xd9, 0xd4, 0xdb, 0x2d, 0x96, 0x55, 0x89, 0xff, 0xef, 0xa8,
1245         0x5f, 0x47, 0x8f, 0xca, 0x02, 0x8a, 0xe1, 0x35, 0x90
1246     };
1247     static const unsigned char pub_data[] = {
1248         0x44, 0x19, 0xc9, 0x46, 0x45, 0x57, 0xc1, 0xa9, 0xd8, 0x30, 0x99, 0x29,
1249         0x6a, 0x4b, 0x63, 0x71, 0x69, 0x96, 0x35, 0x17, 0xb2, 0x62, 0x9b, 0x80,
1250         0x0a, 0x95, 0x9d, 0x6a, 0xc0, 0x32, 0x0d, 0x07, 0x5f, 0x19, 0x44, 0x02,
1251         0xf1, 0xbd, 0xce, 0xdf, 0x10, 0xf8, 0x02, 0x5d, 0x7d, 0x98, 0x8a, 0x73,
1252         0x89, 0x00, 0xb6, 0x24, 0xd6, 0x33, 0xe7, 0xcf, 0x8b, 0x49, 0x2a, 0xaf,
1253         0x13, 0x1c, 0xb2, 0x52, 0x15, 0xfd, 0x9b, 0xd5, 0x40, 0x4a, 0x1a, 0xda,
1254         0x29, 0x4c, 0x92, 0x7e, 0x66, 0x06, 0xdb, 0x61, 0x86, 0xac, 0xb5, 0xda,
1255         0x3c, 0x7d, 0x73, 0x7e, 0x54, 0x32, 0x68, 0xa5, 0x02, 0xbc, 0x59, 0x47,
1256         0x84, 0xd3, 0x87, 0x71, 0x5f, 0xeb, 0x43, 0x45, 0x24, 0xd3, 0xec, 0x08,
1257         0x52, 0xc2, 0x89, 0x2d, 0x9c, 0x1a, 0xcc, 0x91, 0x65, 0x5d, 0xa3, 0xa1,
1258         0x35, 0x31, 0x10, 0x1c, 0x3a, 0xa8, 0x4d, 0x18, 0xd5, 0x06, 0xaf, 0xb2,
1259         0xec, 0x5c, 0x89, 0x9e, 0x90, 0x86, 0x10, 0x01, 0xeb, 0x51, 0xd5, 0x1b,
1260         0x9c, 0xcb, 0x66, 0x07, 0x3f, 0xc4, 0x6e, 0x0a, 0x1b, 0x73, 0xa0, 0x4b,
1261         0x5f, 0x4d, 0xab, 0x35, 0x28, 0xfa, 0xda, 0x3a, 0x0c, 0x08, 0xe8, 0xf3,
1262         0xef, 0x42, 0x67, 0xbc, 0x21, 0xf2, 0xc2, 0xb8, 0xff, 0x1a, 0x81, 0x05,
1263         0x68, 0x73, 0x62, 0xdf, 0xd7, 0xab, 0x0f, 0x22, 0x89, 0x57, 0x96, 0xd4,
1264         0x93, 0xaf, 0xa1, 0x21, 0xa3, 0x48, 0xe9, 0xf0, 0x97, 0x47, 0xa0, 0x27,
1265         0xba, 0x87, 0xb8, 0x15, 0x5f, 0xff, 0x2c, 0x50, 0x41, 0xf1, 0x7e, 0xc6,
1266         0x81, 0xc4, 0x51, 0xf1, 0xfd, 0xd6, 0x86, 0xf7, 0x69, 0x97, 0xf1, 0x49,
1267         0xc9, 0xf9, 0xf4, 0x9b, 0xf4, 0xe8, 0x85, 0xa7, 0xbd, 0x36, 0x55, 0x4a,
1268         0x3d, 0xe8, 0x65, 0x09, 0x7b, 0xb7, 0x12, 0x64, 0xd2, 0x0a, 0x53, 0x60,
1269         0x48, 0xd1, 0x8a, 0xbd
1270     };
1271
1272     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1273         || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
1274         || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
1275         || !TEST_ptr(p = BN_bin2bn(p_data, sizeof(p_data), NULL))
1276         || !TEST_ptr(q = BN_bin2bn(q_data, sizeof(q_data), NULL))
1277         || !TEST_ptr(g = BN_bin2bn(g_data, sizeof(g_data), NULL))
1278
1279         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
1280         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
1281         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
1282         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1283                                                        OSSL_PKEY_PARAM_FFC_SEED,
1284                                                        seed_data,
1285                                                        sizeof(seed_data)))
1286         || !TEST_true(OSSL_PARAM_BLD_push_int(bld, OSSL_PKEY_PARAM_FFC_GINDEX,
1287                                               gindex))
1288         || !TEST_true(OSSL_PARAM_BLD_push_int(bld,
1289                                               OSSL_PKEY_PARAM_FFC_PCOUNTER,
1290                                               pcounter))
1291         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
1292                                              pub))
1293         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
1294                                              priv))
1295         || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1296         goto err;
1297
1298     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL)))
1299         goto err;
1300
1301     if (!TEST_true(EVP_PKEY_fromdata_init(ctx))
1302         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1303                                         fromdata_params))
1304         || !TEST_int_eq(EVP_PKEY_bits(pk), 2048)
1305         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 112)
1306         || !TEST_int_eq(EVP_PKEY_size(pk), 2 + 2 * (3 + sizeof(q_data)))
1307         || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1308         goto err;
1309
1310     if (!TEST_false(EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
1311                                                    name_out, sizeof(name_out),
1312                                                    &len))
1313         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1314                                             &pub_out))
1315         || !TEST_BN_eq(pub, pub_out)
1316         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1317                                             &priv_out))
1318         || !TEST_BN_eq(priv, priv_out)
1319         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p_out))
1320         || !TEST_BN_eq(p, p_out)
1321         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q_out))
1322         || !TEST_BN_eq(q, q_out)
1323         || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g_out))
1324         || !TEST_BN_eq(g, g_out)
1325         || !TEST_false(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_COFACTOR,
1326                                              &j_out))
1327         || !TEST_ptr_null(j_out)
1328         || !TEST_true(EVP_PKEY_get_octet_string_param(pk,
1329                                                       OSSL_PKEY_PARAM_FFC_SEED,
1330                                                       seed_out, sizeof(seed_out),
1331                                                       &len))
1332         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_GINDEX,
1333                                              &gindex_out))
1334         || !TEST_int_eq(gindex, gindex_out)
1335         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
1336                                              &hindex_out))
1337         || !TEST_int_eq(hindex_out, 0)
1338         || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_PCOUNTER,
1339                                              &pcounter_out))
1340         || !TEST_int_eq(pcounter, pcounter_out))
1341         goto err;
1342
1343     if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
1344         goto err;
1345
1346     if (!TEST_true(EVP_PKEY_check(key_ctx))
1347         || !TEST_true(EVP_PKEY_public_check(key_ctx))
1348         || !TEST_true(EVP_PKEY_private_check(key_ctx))
1349         || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
1350         goto err;
1351
1352     if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1353         || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1354         goto err;
1355
1356     ret = test_print_key_using_pem("DSA", pk)
1357           && test_print_key_using_encoder("DSA", pk);
1358  err:
1359     OSSL_PARAM_BLD_free_params(fromdata_params);
1360     OSSL_PARAM_BLD_free(bld);
1361     BN_free(p);
1362     BN_free(q);
1363     BN_free(g);
1364     BN_free(pub);
1365     BN_free(priv);
1366     BN_free(p_out);
1367     BN_free(q_out);
1368     BN_free(g_out);
1369     BN_free(pub_out);
1370     BN_free(priv_out);
1371     BN_free(j_out);
1372     EVP_PKEY_free(pk);
1373     EVP_PKEY_free(copy_pk);
1374     EVP_PKEY_CTX_free(ctx);
1375     EVP_PKEY_CTX_free(key_ctx);
1376
1377     return ret;
1378 }
1379
1380 static int test_check_dsa(void)
1381 {
1382     int ret = 0;
1383     EVP_PKEY_CTX *ctx = NULL;
1384
1385     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL))
1386         || !TEST_false(EVP_PKEY_check(ctx))
1387         || !TEST_false(EVP_PKEY_public_check(ctx))
1388         || !TEST_false(EVP_PKEY_private_check(ctx))
1389         || !TEST_false(EVP_PKEY_pairwise_check(ctx)))
1390        goto err;
1391
1392     ret = 1;
1393  err:
1394     EVP_PKEY_CTX_free(ctx);
1395
1396     return ret;
1397 }
1398 #endif /* OPENSSL_NO_DSA */
1399
1400
1401 int setup_tests(void)
1402 {
1403     if (!test_skip_common_options()) {
1404         TEST_error("Error parsing test options\n");
1405         return 0;
1406     }
1407
1408     if (!TEST_ptr(datadir = test_get_argument(0)))
1409         return 0;
1410
1411     ADD_TEST(test_evp_pkey_get_bn_param_large);
1412     ADD_TEST(test_fromdata_rsa);
1413 #ifndef OPENSSL_NO_DH
1414     ADD_TEST(test_fromdata_dh_fips186_4);
1415     ADD_TEST(test_fromdata_dh_named_group);
1416 #endif
1417 #ifndef OPENSSL_NO_DSA
1418     ADD_TEST(test_check_dsa);
1419     ADD_TEST(test_fromdata_dsa_fips186_4);
1420 #endif
1421 #ifndef OPENSSL_NO_EC
1422     ADD_ALL_TESTS(test_fromdata_ecx, 4 * 3);
1423     ADD_TEST(test_fromdata_ec);
1424     ADD_TEST(test_ec_dup_no_operation);
1425     ADD_TEST(test_ec_dup_keygen_operation);
1426 #endif
1427     return 1;
1428 }