test/evp_pkey_provided_test.c

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