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