1 /*
2 * Copyright 2019-2026 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 <openssl/sha.h>
18 #include "crypto/ecx.h"
19 #include "crypto/evp.h" /* For the internal API */
20 #include "crypto/bn_dh.h" /* _bignum_ffdhe2048_p */
21 #include "internal/nelem.h"
22 #include "testutil.h"
23
24 static char *datadir = NULL;
25
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 */
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
stripcr(char * buf,size_t * len)38 static 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
compare_with_file(const char * alg,int type,BIO * membio)54 static int compare_with_file(const char *alg, int type, BIO *membio)
55 {
56 char filename[80];
57 BIO *file = NULL;
58 char buf[4096];
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
pass_cb(char * buf,int size,int rwflag,void * u)131 static int pass_cb(char *buf, int size, int rwflag, void *u)
132 {
133 return 0;
134 }
135
pass_cb_error(char * buf,int size,int rwflag,void * u)136 static int pass_cb_error(char *buf, int size, int rwflag, void *u)
137 {
138 return -1;
139 }
140
test_print_key_using_pem(const char * alg,const EVP_PKEY * pk)141 static int test_print_key_using_pem(const char *alg, const EVP_PKEY *pk)
142 {
143 BIO *membio = BIO_new(BIO_s_mem());
144 int ret = 0;
145
146 if (!TEST_ptr(membio))
147 goto err;
148
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))
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))
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
182 /* Private key in text form */
183 || !TEST_int_gt(EVP_PKEY_print_private(membio, pk, 0, NULL), 0)
184 || !TEST_true(compare_with_file(alg, PRIV_TEXT, membio))
185 /* Public key in PEM form */
186 || !TEST_true(PEM_write_bio_PUBKEY(membio, pk))
187 || !TEST_true(compare_with_file(alg, PUB_PEM, membio))
188 /* Unencrypted private key in PEM form */
189 || !TEST_true(PEM_write_bio_PrivateKey(membio, pk,
190 NULL, NULL, 0, NULL, NULL))
191 || !TEST_true(compare_with_file(alg, PRIV_PEM, membio))
192 /* NULL key */
193 || !TEST_false(PEM_write_bio_PrivateKey(membio, NULL,
194 NULL, NULL, 0, NULL, NULL))
195 || !TEST_false(PEM_write_bio_PrivateKey_traditional(membio, NULL,
196 NULL, NULL, 0, NULL, NULL)))
197 goto err;
198
199 ret = 1;
200 err:
201 BIO_free(membio);
202 return ret;
203 }
204
test_print_key_type_using_encoder(const char * alg,int type,const EVP_PKEY * pk)205 static int test_print_key_type_using_encoder(const char *alg, int type,
206 const EVP_PKEY *pk)
207 {
208 const char *output_type, *output_structure;
209 int selection;
210 OSSL_ENCODER_CTX *ctx = NULL;
211 BIO *membio = BIO_new(BIO_s_mem());
212 int ret = 0;
213
214 switch (type) {
215 case PRIV_TEXT:
216 output_type = "TEXT";
217 output_structure = NULL;
218 selection = OSSL_KEYMGMT_SELECT_KEYPAIR
219 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
220 break;
221
222 case PRIV_PEM:
223 output_type = "PEM";
224 output_structure = "PrivateKeyInfo";
225 selection = OSSL_KEYMGMT_SELECT_KEYPAIR
226 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
227 break;
228
229 case PRIV_DER:
230 output_type = "DER";
231 output_structure = "PrivateKeyInfo";
232 selection = OSSL_KEYMGMT_SELECT_KEYPAIR
233 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
234 break;
235
236 case PUB_TEXT:
237 output_type = "TEXT";
238 output_structure = NULL;
239 selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
240 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
241 break;
242
243 case PUB_PEM:
244 output_type = "PEM";
245 output_structure = "SubjectPublicKeyInfo";
246 selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
247 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
248 break;
249
250 case PUB_DER:
251 output_type = "DER";
252 output_structure = "SubjectPublicKeyInfo";
253 selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
254 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS;
255 break;
256
257 default:
258 TEST_error("Invalid encoding type");
259 goto err;
260 }
261
262 if (!TEST_ptr(membio))
263 goto err;
264
265 /* Make a context, it's valid for several prints */
266 TEST_note("Setting up a OSSL_ENCODER context with passphrase");
267 if (!TEST_ptr(ctx = OSSL_ENCODER_CTX_new_for_pkey(pk, selection,
268 output_type,
269 output_structure,
270 NULL))
271 /* Check that this operation is supported */
272 || !TEST_int_ne(OSSL_ENCODER_CTX_get_num_encoders(ctx), 0))
273 goto err;
274
275 /* Use no cipher. This should give us an unencrypted PEM */
276 TEST_note("Testing with no encryption");
277 if (!TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
278 || !TEST_true(compare_with_file(alg, type, membio)))
279 goto err;
280
281 if (type == PRIV_PEM) {
282 /* Set a passphrase to be used later */
283 if (!TEST_true(OSSL_ENCODER_CTX_set_passphrase(ctx,
284 (unsigned char *)"pass",
285 4)))
286 goto err;
287
288 /* Use a valid cipher name */
289 TEST_note("Displaying PEM encrypted with AES-256-CBC");
290 if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
291 || !TEST_true(OSSL_ENCODER_to_bio(ctx, bio_out)))
292 goto err;
293
294 /* Use an invalid cipher name, which should generate no output */
295 TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
296 if (!TEST_false(OSSL_ENCODER_CTX_set_cipher(ctx, "FOO", NULL))
297 || !TEST_false(OSSL_ENCODER_to_bio(ctx, bio_out)))
298 goto err;
299
300 /* Clear the cipher. This should give us an unencrypted PEM again */
301 TEST_note("Testing with encryption cleared (no encryption)");
302 if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, NULL, NULL))
303 || !TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
304 || !TEST_true(compare_with_file(alg, type, membio)))
305 goto err;
306 }
307 ret = 1;
308 err:
309 BIO_free(membio);
310 OSSL_ENCODER_CTX_free(ctx);
311 return ret;
312 }
313
test_print_key_using_encoder(const char * alg,const EVP_PKEY * pk)314 static int test_print_key_using_encoder(const char *alg, const EVP_PKEY *pk)
315 {
316 int i;
317 int ret = 1;
318
319 for (i = PRIV_TEXT; i <= PUB_DER; i++)
320 ret = ret && test_print_key_type_using_encoder(alg, i, pk);
321
322 return ret;
323 }
324
325 #ifndef OPENSSL_NO_ECX
test_print_key_using_encoder_public(const char * alg,const EVP_PKEY * pk)326 static int test_print_key_using_encoder_public(const char *alg,
327 const EVP_PKEY *pk)
328 {
329 int i;
330 int ret = 1;
331
332 for (i = PUB_TEXT; i <= PUB_DER; i++)
333 ret = ret && test_print_key_type_using_encoder(alg, i, pk);
334
335 return ret;
336 }
337 #endif
338
339 /* Array indexes used in test_fromdata_rsa */
340 #define N 0
341 #define E 1
342 #define D 2
343 #define P 3
344 #define Q 4
345 #define DP 5
346 #define DQ 6
347 #define QINV 7
348
test_fromdata_rsa(void)349 static int test_fromdata_rsa(void)
350 {
351 int ret = 0, i;
352 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
353 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
354 /*
355 * 32-bit RSA key, extracted from this command,
356 * executed with OpenSSL 1.0.2:
357 *
358 * openssl genrsa 32 | openssl rsa -text
359 */
360 static unsigned long key_numbers[] = {
361 0xbc747fc5, /* N */
362 0x10001, /* E */
363 0x7b133399, /* D */
364 0xe963, /* P */
365 0xceb7, /* Q */
366 0x8599, /* DP */
367 0xbd87, /* DQ */
368 0xcc3b, /* QINV */
369 };
370 OSSL_PARAM fromdata_params[] = {
371 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
372 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
373 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
374 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR1, &key_numbers[P]),
375 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR2, &key_numbers[Q]),
376 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT1, &key_numbers[DP]),
377 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT2, &key_numbers[DQ]),
378 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, &key_numbers[QINV]),
379 OSSL_PARAM_END
380 };
381 BIGNUM *bn = BN_new();
382 BIGNUM *bn_from = BN_new();
383
384 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL)))
385 goto err;
386
387 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
388 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
389 fromdata_params),
390 1))
391 goto err;
392
393 for (;;) {
394 ret = 0;
395 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 32)
396 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 8)
397 || !TEST_int_eq(EVP_PKEY_get_size(pk), 4)
398 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
399 goto err;
400
401 EVP_PKEY_CTX_free(key_ctx);
402 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
403 goto err;
404
405 if (!TEST_int_gt(EVP_PKEY_check(key_ctx), 0)
406 || !TEST_int_gt(EVP_PKEY_public_check(key_ctx), 0)
407 || !TEST_int_gt(EVP_PKEY_private_check(key_ctx), 0)
408 || !TEST_int_gt(EVP_PKEY_pairwise_check(key_ctx), 0))
409 goto err;
410
411 /* EVP_PKEY_copy_parameters() should fail for RSA */
412 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
413 || !TEST_false(EVP_PKEY_copy_parameters(copy_pk, pk)))
414 goto err;
415 EVP_PKEY_free(copy_pk);
416 copy_pk = NULL;
417
418 ret = test_print_key_using_pem("RSA", pk)
419 && test_print_key_using_encoder("RSA", pk);
420
421 if (!ret || dup_pk != NULL)
422 break;
423
424 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
425 goto err;
426 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
427 EVP_PKEY_free(pk);
428 pk = dup_pk;
429 if (!ret)
430 goto err;
431 }
432 err:
433 /* for better diagnostics always compare key params */
434 for (i = 0; fromdata_params[i].key != NULL; ++i) {
435 if (!TEST_true(BN_set_word(bn_from, key_numbers[i]))
436 || !TEST_true(EVP_PKEY_get_bn_param(pk, fromdata_params[i].key,
437 &bn))
438 || !TEST_BN_eq(bn, bn_from))
439 ret = 0;
440 }
441 BN_free(bn_from);
442 BN_free(bn);
443 EVP_PKEY_free(pk);
444 EVP_PKEY_free(copy_pk);
445 EVP_PKEY_CTX_free(key_ctx);
446 EVP_PKEY_CTX_free(ctx);
447
448 return ret;
449 }
450
451 struct check_data {
452 const char *pname;
453 BIGNUM *comparebn;
454 };
455
do_fromdata_rsa_derive(OSSL_PARAM * fromdata_params,struct check_data check[],int expected_nbits,int expected_sbits,int expected_ksize)456 static int do_fromdata_rsa_derive(OSSL_PARAM *fromdata_params,
457 struct check_data check[],
458 int expected_nbits, int expected_sbits,
459 int expected_ksize)
460 {
461 const OSSL_PARAM *check_param = NULL;
462 BIGNUM *check_bn = NULL;
463 OSSL_PARAM *todata_params = NULL;
464 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
465 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
466 int i;
467 int ret = 0;
468
469 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL))
470 || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
471 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
472 fromdata_params),
473 1))
474 goto err;
475
476 /*
477 * get the generated key parameters back and validate that the
478 * exponents/coeffs are correct
479 */
480 if (!TEST_int_eq(EVP_PKEY_todata(pk, EVP_PKEY_KEYPAIR, &todata_params), 1))
481 goto err;
482
483 for (i = 0; check[i].pname != NULL; i++) {
484 if (!TEST_ptr(check_param = OSSL_PARAM_locate_const(todata_params,
485 check[i].pname)))
486 goto err;
487 if (!TEST_int_eq(OSSL_PARAM_get_BN(check_param, &check_bn), 1))
488 goto err;
489 if (!TEST_BN_eq(check_bn, check[i].comparebn)) {
490 TEST_info("Data mismatch for parameter %s", check[i].pname);
491 goto err;
492 }
493 BN_free(check_bn);
494 check_bn = NULL;
495 }
496
497 for (;;) {
498 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), expected_nbits)
499 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), expected_sbits)
500 || !TEST_int_eq(EVP_PKEY_get_size(pk), expected_ksize)
501 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
502 goto err;
503
504 EVP_PKEY_CTX_free(key_ctx);
505 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
506 goto err;
507
508 if (!TEST_int_gt(EVP_PKEY_check(key_ctx), 0)
509 || !TEST_int_gt(EVP_PKEY_public_check(key_ctx), 0)
510 || !TEST_int_gt(EVP_PKEY_private_check(key_ctx), 0)
511 || !TEST_int_gt(EVP_PKEY_pairwise_check(key_ctx), 0))
512 goto err;
513
514 /* EVP_PKEY_copy_parameters() should fail for RSA */
515 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
516 || !TEST_false(EVP_PKEY_copy_parameters(copy_pk, pk)))
517 goto err;
518 EVP_PKEY_free(copy_pk);
519 copy_pk = NULL;
520
521 if (dup_pk != NULL)
522 break;
523
524 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
525 goto err;
526 if (!TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1)) {
527 EVP_PKEY_free(dup_pk);
528 goto err;
529 }
530 EVP_PKEY_free(pk);
531 pk = dup_pk;
532 }
533 ret = 1;
534 err:
535 BN_free(check_bn);
536 EVP_PKEY_free(pk);
537 EVP_PKEY_CTX_free(ctx);
538 EVP_PKEY_CTX_free(key_ctx);
539 OSSL_PARAM_free(fromdata_params);
540 OSSL_PARAM_free(todata_params);
541 return ret;
542 }
543
test_fromdata_rsa_derive_from_pq_sp800(void)544 static int test_fromdata_rsa_derive_from_pq_sp800(void)
545 {
546 OSSL_PARAM_BLD *bld = NULL;
547 BIGNUM *n = NULL, *e = NULL, *d = NULL, *p = NULL, *q = NULL;
548 BIGNUM *dmp1 = NULL, *dmq1 = NULL, *iqmp = NULL;
549 OSSL_PARAM *fromdata_params = NULL;
550 struct check_data cdata[4];
551 int ret = 0;
552 /*
553 * 512-bit RSA key, extracted from this command,
554 * openssl genrsa 512 | openssl rsa -text
555 * Note: When generating a key with EVP_PKEY_fromdata, and using
556 * crt derivation, openssl requires a minimum of 512 bits of n data,
557 * and 2048 bits in the FIPS case
558 */
559 static unsigned char n_data[] = { 0x00, 0xc7, 0x06, 0xd8, 0x6b, 0x3c, 0x4f, 0xb7, 0x95, 0x42, 0x44, 0x90,
560 0xbd, 0xef, 0xf3, 0xc4, 0xb5, 0xa8, 0x55, 0x9e, 0x33, 0xa3, 0x04, 0x3a,
561 0x90, 0xe5, 0x13, 0xff, 0x87, 0x69, 0x15, 0xa4, 0x8a, 0x17, 0x10, 0xcc,
562 0xdf, 0xf9, 0xc5, 0x0f, 0xf1, 0x12, 0xff, 0x12, 0x11, 0xe5, 0x6b, 0x5c,
563 0x83, 0xd9, 0x43, 0xd1, 0x8a, 0x7e, 0xa6, 0x60, 0x07, 0x2e, 0xbb, 0x03,
564 0x17, 0x2d, 0xec, 0x17, 0x87 };
565 static unsigned char e_data[] = { 0x01, 0x00, 0x01 };
566 static unsigned char d_data[] = { 0x1e, 0x5e, 0x5d, 0x07, 0x7f, 0xdc, 0x6a, 0x16, 0xcc, 0x55, 0xca, 0x00,
567 0x31, 0x6c, 0xf0, 0xc7, 0x07, 0x38, 0x89, 0x3b, 0x37, 0xd4, 0x9d, 0x5b,
568 0x1e, 0x99, 0x3e, 0x94, 0x5a, 0xe4, 0x82, 0x86, 0x8a, 0x78, 0x34, 0x09,
569 0x37, 0xd5, 0xe7, 0xb4, 0xef, 0x5f, 0x83, 0x94, 0xff, 0xe5, 0x36, 0x79,
570 0x10, 0x0c, 0x38, 0xc5, 0x3a, 0x33, 0xa6, 0x7c, 0x3c, 0xcc, 0x98, 0xe0,
571 0xf5, 0xdb, 0xe6, 0x81 };
572 static unsigned char p_data[] = { 0x00, 0xf6, 0x61, 0x38, 0x0e, 0x1f, 0x82, 0x7c, 0xb8, 0xba, 0x00, 0xd3,
573 0xac, 0xdc, 0x4e, 0x6b, 0x7e, 0xf7, 0x58, 0xf3, 0xd9, 0xd8, 0x21, 0xed,
574 0x54, 0xa3, 0x36, 0xd2, 0x2c, 0x5f, 0x06, 0x7d, 0xc5 };
575 static unsigned char q_data[] = { 0x00, 0xce, 0xcc, 0x4a, 0xa5, 0x4f, 0xd6, 0x73, 0xd0, 0x20, 0xc3, 0x98,
576 0x64, 0x20, 0x9b, 0xc1, 0x23, 0xd8, 0x5c, 0x82, 0x4f, 0xe8, 0xa5, 0x32,
577 0xcd, 0x7e, 0x97, 0xb4, 0xde, 0xf6, 0x4c, 0x80, 0xdb };
578 static unsigned char dmp1_data[] = { 0x00, 0xd1, 0x07, 0xb6, 0x79, 0x34, 0xfe, 0x8e, 0x36, 0x63, 0x88, 0xa4,
579 0x0e, 0x3a, 0x73, 0x45, 0xfc, 0x58, 0x7a, 0x5d, 0x98, 0xeb, 0x28, 0x0d,
580 0xa5, 0x0b, 0x3c, 0x4d, 0xa0, 0x5b, 0x96, 0xb4, 0x49 };
581 static unsigned char dmq1_data[] = { 0x5b, 0x47, 0x02, 0xdf, 0xaa, 0xb8, 0xae, 0x8f, 0xbc, 0x16, 0x79, 0x6a,
582 0x20, 0x96, 0x7f, 0x0e, 0x92, 0x4e, 0x6a, 0xda, 0x58, 0x86, 0xaa, 0x40,
583 0xd7, 0xd2, 0xa0, 0x6c, 0x15, 0x6c, 0xb9, 0x27 };
584 static unsigned char iqmp_data[] = { 0x00, 0xa0, 0xd6, 0xf0, 0xe8, 0x17, 0x9e, 0xe7, 0xe6, 0x99, 0x12, 0xd6,
585 0xd9, 0x43, 0xcf, 0xed, 0x37, 0x29, 0xf5, 0x6c, 0x3e, 0xc1, 0x7f, 0x2e,
586 0x31, 0x3f, 0x64, 0x34, 0x66, 0x68, 0x5c, 0x22, 0x08 };
587
588 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
589 || !TEST_ptr(n = BN_bin2bn(n_data, sizeof(n_data), NULL))
590 || !TEST_ptr(e = BN_bin2bn(e_data, sizeof(e_data), NULL))
591 || !TEST_ptr(d = BN_bin2bn(d_data, sizeof(d_data), NULL))
592 || !TEST_ptr(p = BN_bin2bn(p_data, sizeof(p_data), NULL))
593 || !TEST_ptr(q = BN_bin2bn(q_data, sizeof(q_data), NULL))
594 || !TEST_ptr(dmp1 = BN_bin2bn(dmp1_data, sizeof(dmp1_data), NULL))
595 || !TEST_ptr(dmq1 = BN_bin2bn(dmq1_data, sizeof(dmq1_data), NULL))
596 || !TEST_ptr(iqmp = BN_bin2bn(iqmp_data, sizeof(iqmp_data), NULL))
597 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
598 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
599 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d))
600 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_FACTOR1,
601 p))
602 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_FACTOR2,
603 q))
604 || !TEST_true(OSSL_PARAM_BLD_push_int(bld,
605 OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ, 1))
606 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
607 goto err;
608
609 cdata[0].pname = OSSL_PKEY_PARAM_RSA_EXPONENT1;
610 cdata[0].comparebn = dmp1;
611 cdata[1].pname = OSSL_PKEY_PARAM_RSA_EXPONENT2;
612 cdata[1].comparebn = dmq1;
613 cdata[2].pname = OSSL_PKEY_PARAM_RSA_COEFFICIENT1;
614 cdata[2].comparebn = iqmp;
615 cdata[3].pname = NULL;
616 cdata[3].comparebn = NULL;
617
618 ret = do_fromdata_rsa_derive(fromdata_params, cdata, 512, 56, 64);
619
620 err:
621 BN_free(n);
622 BN_free(e);
623 BN_free(d);
624 BN_free(p);
625 BN_free(q);
626 BN_free(dmp1);
627 BN_free(dmq1);
628 BN_free(iqmp);
629 OSSL_PARAM_BLD_free(bld);
630 return ret;
631 }
632
test_fromdata_rsa_derive_from_pq_multiprime(void)633 static int test_fromdata_rsa_derive_from_pq_multiprime(void)
634 {
635 OSSL_PARAM_BLD *bld = NULL;
636 BIGNUM *n = NULL, *e = NULL, *d = NULL;
637 BIGNUM *p = NULL, *q = NULL, *p2 = NULL;
638 BIGNUM *dmp1 = NULL, *dmq1 = NULL, *iqmp = NULL;
639 BIGNUM *exp3 = NULL, *coeff2 = NULL;
640 OSSL_PARAM *fromdata_params = NULL;
641 struct check_data cdata[12];
642 int ret = 0;
643 /*
644 * multiprime RSA key, extracted from this command,
645 * openssl genrsa -primes 3 | openssl rsa -text
646 * Note: When generating a key with EVP_PKEY_fromdata, and using
647 * crt derivation, openssl requires a minimum of 512 bits of n data,
648 * and 2048 bits in the FIPS case
649 */
650 static unsigned char n_data[] = { 0x00, 0x95, 0x78, 0x21, 0xe0, 0xca, 0x94, 0x6c, 0x0b, 0x86, 0x2a, 0x01,
651 0xde, 0xd9, 0xab, 0xee, 0x88, 0x4a, 0x27, 0x4f, 0xcc, 0x5f, 0xf1, 0x71,
652 0xe1, 0x0b, 0xc3, 0xd1, 0x88, 0x76, 0xf0, 0x83, 0x03, 0x93, 0x7e, 0x39,
653 0xfa, 0x47, 0x89, 0x34, 0x27, 0x18, 0x19, 0x97, 0xfc, 0xd4, 0xfe, 0xe5,
654 0x8a, 0xa9, 0x11, 0x83, 0xb5, 0x15, 0x4a, 0x29, 0xa6, 0xa6, 0xd0, 0x6e,
655 0x0c, 0x7f, 0x61, 0x8f, 0x7e, 0x7c, 0xfb, 0xfc, 0x04, 0x8b, 0xca, 0x44,
656 0xf8, 0x59, 0x0b, 0x22, 0x6f, 0x3f, 0x92, 0x23, 0x98, 0xb5, 0xc8, 0xf7,
657 0xff, 0xf7, 0xac, 0x6b, 0x36, 0xb3, 0xaf, 0x39, 0xde, 0x66, 0x38, 0x51,
658 0x9f, 0xbe, 0xe2, 0xfc, 0xe4, 0x6f, 0x1a, 0x0f, 0x7a, 0xde, 0x7f, 0x0f,
659 0x4e, 0xbc, 0xed, 0xa2, 0x99, 0xc5, 0xd1, 0xbf, 0x8f, 0xba, 0x92, 0x91,
660 0xe4, 0x00, 0x91, 0xbb, 0x67, 0x36, 0x7d, 0x00, 0x50, 0xda, 0x28, 0x38,
661 0xdc, 0x9f, 0xfe, 0x3f, 0x24, 0x5a, 0x0d, 0xe1, 0x8d, 0xe9, 0x45, 0x2c,
662 0xd7, 0xf2, 0x67, 0x8c, 0x0c, 0x6e, 0xdb, 0xc8, 0x8b, 0x6b, 0x38, 0x30,
663 0x21, 0x94, 0xc0, 0xe3, 0xd7, 0xe0, 0x23, 0xd3, 0xd4, 0xfa, 0xdb, 0xb9,
664 0xfe, 0x1a, 0xcc, 0xc9, 0x79, 0x19, 0x35, 0x18, 0x42, 0x30, 0xc4, 0xb5,
665 0x92, 0x33, 0x1e, 0xd4, 0xc4, 0xc0, 0x9d, 0x55, 0x37, 0xd4, 0xef, 0x54,
666 0x71, 0x81, 0x09, 0x15, 0xdb, 0x11, 0x38, 0x6b, 0x35, 0x93, 0x11, 0xdc,
667 0xb1, 0x6c, 0xd6, 0xa4, 0x37, 0x84, 0xf3, 0xb2, 0x2f, 0x1b, 0xd6, 0x05,
668 0x9f, 0x0e, 0x5c, 0x98, 0x29, 0x2f, 0x95, 0xb6, 0x55, 0xbd, 0x24, 0x44,
669 0xc5, 0xc8, 0xa2, 0x76, 0x1e, 0xf8, 0x82, 0x8a, 0xdf, 0x34, 0x72, 0x7e,
670 0xdd, 0x65, 0x4b, 0xfc, 0x6c, 0x1c, 0x96, 0x70, 0xe2, 0x69, 0xb5, 0x12,
671 0x1b, 0x59, 0x67, 0x14, 0x9d };
672 static unsigned char e_data[] = { 0x01, 0x00, 0x01 };
673 static unsigned char d_data[] = { 0x64, 0x57, 0x4d, 0x86, 0xf6, 0xf8, 0x44, 0xc0, 0x47, 0xc5, 0x13, 0x94,
674 0x63, 0x54, 0x84, 0xc1, 0x81, 0xe6, 0x7a, 0x2f, 0x9d, 0x89, 0x1d, 0x06,
675 0x13, 0x3b, 0xd6, 0x02, 0x62, 0xb6, 0x7b, 0x7d, 0x7f, 0x1a, 0x92, 0x19,
676 0x6e, 0xc4, 0xb0, 0xfa, 0x3d, 0xb7, 0x90, 0xcc, 0xee, 0xc0, 0x5f, 0xa0,
677 0x82, 0x77, 0x7b, 0x8f, 0xa9, 0x47, 0x2c, 0x46, 0xf0, 0x5d, 0xa4, 0x43,
678 0x47, 0x90, 0x5b, 0x20, 0x73, 0x0f, 0x46, 0xd4, 0x56, 0x73, 0xe7, 0x71,
679 0x41, 0x75, 0xb4, 0x1c, 0x32, 0xf5, 0x0c, 0x68, 0x8c, 0x40, 0xea, 0x1c,
680 0x30, 0x12, 0xa2, 0x65, 0x02, 0x27, 0x98, 0x4e, 0x0a, 0xbf, 0x2b, 0x72,
681 0xb2, 0x5c, 0xe3, 0xbe, 0x3e, 0xc7, 0xdb, 0x9b, 0xa2, 0x4a, 0x90, 0xc0,
682 0xa7, 0xb0, 0x00, 0xf1, 0x6a, 0xff, 0xa3, 0x77, 0xf7, 0x71, 0xa2, 0x41,
683 0xe9, 0x6e, 0x7c, 0x38, 0x24, 0x46, 0xd5, 0x5c, 0x49, 0x2a, 0xe6, 0xee,
684 0x27, 0x4b, 0x2e, 0x6f, 0x16, 0x54, 0x2d, 0x37, 0x36, 0x01, 0x39, 0x2b,
685 0x23, 0x4b, 0xb4, 0x65, 0x25, 0x4d, 0x7f, 0x72, 0x20, 0x7f, 0x5d, 0xec,
686 0x50, 0xba, 0xbb, 0xaa, 0x9c, 0x3c, 0x1d, 0xa1, 0x40, 0x2c, 0x6a, 0x8b,
687 0x5f, 0x2e, 0xe0, 0xa6, 0xf7, 0x9e, 0x03, 0xb5, 0x44, 0x5f, 0x74, 0xc7,
688 0x9f, 0x89, 0x2b, 0x71, 0x2f, 0x66, 0x9f, 0x03, 0x6c, 0x96, 0xd0, 0x23,
689 0x36, 0x4d, 0xa1, 0xf0, 0x82, 0xcc, 0x43, 0xe7, 0x08, 0x93, 0x40, 0x18,
690 0xc0, 0x39, 0x73, 0x83, 0xe2, 0xec, 0x9b, 0x81, 0x9d, 0x4c, 0x86, 0xaa,
691 0x59, 0xa8, 0x67, 0x1c, 0x80, 0xdc, 0x6f, 0x7f, 0x23, 0x6b, 0x7d, 0x2c,
692 0x56, 0x99, 0xa0, 0x89, 0x7e, 0xdb, 0x8b, 0x7a, 0xaa, 0x03, 0x8e, 0x8e,
693 0x8e, 0x3a, 0x58, 0xb4, 0x03, 0x6b, 0x65, 0xfa, 0x92, 0x0a, 0x96, 0x93,
694 0xa6, 0x07, 0x60, 0x01 };
695 static unsigned char p_data[] = { 0x06, 0x55, 0x7f, 0xbd, 0xfd, 0xa8, 0x4c, 0x94, 0x5e, 0x10, 0x8a, 0x54,
696 0x37, 0xf3, 0x64, 0x37, 0x3a, 0xca, 0x18, 0x1b, 0xdd, 0x71, 0xa5, 0x94,
697 0xc9, 0x31, 0x59, 0xa5, 0x89, 0xe9, 0xc4, 0xba, 0x55, 0x90, 0x6d, 0x9c,
698 0xcc, 0x52, 0x5d, 0x44, 0xa8, 0xbc, 0x2b, 0x3b, 0x8c, 0xbd, 0x96, 0xfa,
699 0xcd, 0x54, 0x63, 0xe3, 0xc8, 0xfe, 0x5e, 0xc6, 0x73, 0x98, 0x14, 0x7a,
700 0x54, 0x0e, 0xe7, 0x75, 0x49, 0x93, 0x20, 0x33, 0x17, 0xa9, 0x34, 0xa8,
701 0xee, 0xaf, 0x3a, 0xcc, 0xf5, 0x69, 0xfc, 0x30, 0x1a, 0xdf, 0x49, 0x61,
702 0xa4, 0xd1 };
703 static unsigned char p2_data[] = { 0x03, 0xe2, 0x41, 0x3d, 0xb1, 0xdd, 0xad, 0xd7, 0x3b, 0xf8, 0xab, 0x32,
704 0x27, 0x8b, 0xac, 0x95, 0xc0, 0x1a, 0x3f, 0x80, 0x8e, 0x21, 0xa9, 0xb8,
705 0xa2, 0xed, 0xcf, 0x97, 0x5c, 0x61, 0x10, 0x94, 0x1b, 0xd0, 0xbe, 0x88,
706 0xc2, 0xa7, 0x20, 0xe5, 0xa5, 0xc2, 0x7a, 0x7e, 0xf0, 0xd1, 0xe4, 0x13,
707 0x75, 0xb9, 0x62, 0x90, 0xf1, 0xc3, 0x5b, 0x8c, 0xe9, 0xa9, 0x5b, 0xb7,
708 0x6d, 0xdc, 0xcd, 0x12, 0xea, 0x97, 0x05, 0x04, 0x25, 0x2a, 0x93, 0xd1,
709 0x4e, 0x05, 0x1a, 0x50, 0xa2, 0x67, 0xb8, 0x4b, 0x09, 0x15, 0x65, 0x6c,
710 0x66, 0x2d };
711 static unsigned char q_data[] = { 0x06, 0x13, 0x74, 0x6e, 0xde, 0x7c, 0x33, 0xc2, 0xe7, 0x05, 0x2c, 0xeb,
712 0x25, 0x7d, 0x4a, 0x07, 0x7e, 0x03, 0xcf, 0x6a, 0x23, 0x36, 0x25, 0x23,
713 0xf6, 0x5d, 0xde, 0xa3, 0x0f, 0x82, 0xe6, 0x4b, 0xec, 0x39, 0xbf, 0x37,
714 0x1f, 0x4f, 0x56, 0x1e, 0xd8, 0x62, 0x32, 0x5c, 0xf5, 0x37, 0x75, 0x20,
715 0xe2, 0x7e, 0x56, 0x82, 0xc6, 0x35, 0xd3, 0x4d, 0xfa, 0x6c, 0xc3, 0x93,
716 0xf0, 0x60, 0x53, 0x78, 0x95, 0xee, 0xf9, 0x8b, 0x2c, 0xaf, 0xb1, 0x47,
717 0x5c, 0x29, 0x0d, 0x2a, 0x47, 0x7f, 0xd0, 0x7a, 0x4e, 0x26, 0x7b, 0x47,
718 0xfb, 0x61 };
719 static unsigned char dmp1_data[] = { 0x01, 0x13, 0x3a, 0x1f, 0x91, 0x92, 0xa3, 0x8c, 0xfb, 0x7a, 0x6b, 0x40,
720 0x68, 0x4e, 0xd3, 0xcf, 0xdc, 0x16, 0xb9, 0x88, 0xe1, 0x49, 0x8d, 0x05,
721 0x78, 0x30, 0xfc, 0x3a, 0x70, 0xf2, 0x51, 0x06, 0x1f, 0xc7, 0xe8, 0x13,
722 0x19, 0x4b, 0x51, 0xb1, 0x79, 0xc2, 0x96, 0xc4, 0x00, 0xdb, 0x9d, 0x68,
723 0xec, 0xb9, 0x4a, 0x4b, 0x3b, 0xae, 0x91, 0x7f, 0xb5, 0xd7, 0x36, 0x82,
724 0x9d, 0x09, 0xfa, 0x97, 0x99, 0xe9, 0x73, 0x29, 0xb8, 0xf6, 0x6b, 0x8d,
725 0xd1, 0x15, 0xc5, 0x31, 0x4c, 0xe6, 0xb4, 0x7b, 0xa5, 0xd4, 0x08, 0xac,
726 0x9e, 0x41 };
727 static unsigned char dmq1_data[] = { 0x05, 0xcd, 0x33, 0xc2, 0xdd, 0x3b, 0xb8, 0xec, 0xe4, 0x4c, 0x03, 0xcc,
728 0xef, 0xba, 0x07, 0x22, 0xca, 0x47, 0x77, 0x18, 0x40, 0x50, 0xe5, 0xfb,
729 0xc5, 0xb5, 0x71, 0xed, 0x3e, 0xd5, 0x5d, 0x72, 0xa7, 0x37, 0xa8, 0x86,
730 0x48, 0xa6, 0x27, 0x74, 0x42, 0x66, 0xd8, 0xf1, 0xfb, 0xcf, 0x1d, 0x4e,
731 0xee, 0x15, 0x76, 0x23, 0x5e, 0x81, 0x6c, 0xa7, 0x2b, 0x74, 0x08, 0xf7,
732 0x4c, 0x71, 0x9d, 0xa2, 0x29, 0x7f, 0xca, 0xd5, 0x02, 0x31, 0x2c, 0x54,
733 0x18, 0x02, 0xb6, 0xa8, 0x65, 0x26, 0xfc, 0xf8, 0x9b, 0x80, 0x90, 0xfc,
734 0x75, 0x61 };
735 static unsigned char iqmp_data[] = { 0x05, 0x78, 0xf8, 0xdd, 0x1c, 0x6f, 0x3d, 0xaf, 0x53, 0x84, 0x32, 0xa9,
736 0x35, 0x52, 0xf3, 0xd0, 0x4d, 0xf8, 0x09, 0x85, 0x3d, 0x72, 0x20, 0x8b,
737 0x47, 0xba, 0xc8, 0xce, 0xac, 0xd9, 0x76, 0x90, 0x05, 0x88, 0x63, 0x8a,
738 0x10, 0x2b, 0xcd, 0xd3, 0xbe, 0x8c, 0x16, 0x60, 0x6a, 0xfd, 0xce, 0xc7,
739 0x9f, 0xfa, 0xbb, 0xe3, 0xa6, 0xde, 0xc2, 0x8f, 0x1d, 0x25, 0xdc, 0x41,
740 0xcb, 0xa4, 0xeb, 0x76, 0xc9, 0xdc, 0x8e, 0x49, 0x0e, 0xe4, 0x7c, 0xd2,
741 0xd5, 0x6e, 0x26, 0x3c, 0x0b, 0xd3, 0xc5, 0x20, 0x4e, 0x4b, 0xb6, 0xf7,
742 0xae, 0xef };
743 static unsigned char exp3_data[] = { 0x02, 0x7d, 0x16, 0x24, 0xfc, 0x35, 0xf9, 0xd0, 0xb3, 0x02, 0xf2, 0x5f,
744 0xde, 0xeb, 0x27, 0x19, 0x85, 0xd0, 0xcb, 0xe4, 0x0a, 0x2f, 0x13, 0xdb,
745 0xd5, 0xba, 0xe0, 0x8c, 0x32, 0x8b, 0x97, 0xdd, 0xef, 0xbc, 0xe0, 0x7a,
746 0x2d, 0x90, 0x7e, 0x09, 0xe9, 0x1f, 0x26, 0xf2, 0xf4, 0x48, 0xea, 0x06,
747 0x76, 0x26, 0xe6, 0x3b, 0xce, 0x4e, 0xc9, 0xf9, 0x0f, 0x38, 0x90, 0x26,
748 0x87, 0x65, 0x36, 0x9a, 0xea, 0x6a, 0xfe, 0xb1, 0xdb, 0x46, 0xdf, 0x14,
749 0xfd, 0x13, 0x53, 0xfb, 0x5b, 0x35, 0x6e, 0xe7, 0xd5, 0xd8, 0x39, 0xf7,
750 0x2d, 0xb9 };
751 static unsigned char coeff2_data[] = { 0x01, 0xba, 0x66, 0x0a, 0xa2, 0x86, 0xc0, 0x57, 0x7f, 0x4e, 0x68, 0xb1,
752 0x86, 0x63, 0x23, 0x5b, 0x0e, 0xeb, 0x93, 0x42, 0xd1, 0xaa, 0x15, 0x13,
753 0xcc, 0x29, 0x71, 0x8a, 0xb0, 0xe0, 0xc9, 0x67, 0xde, 0x1a, 0x7c, 0x1a,
754 0xef, 0xa7, 0x08, 0x85, 0xb3, 0xae, 0x98, 0x99, 0xde, 0xaf, 0x09, 0x38,
755 0xfc, 0x46, 0x29, 0x5f, 0x4f, 0x7e, 0x01, 0x6c, 0x50, 0x13, 0x95, 0x91,
756 0x4c, 0x0f, 0x00, 0xba, 0xca, 0x40, 0xa3, 0xd0, 0x58, 0xb6, 0x62, 0x4c,
757 0xd1, 0xb6, 0xd3, 0x29, 0x5d, 0x82, 0xb3, 0x3d, 0x61, 0xbe, 0x5d, 0xf0,
758 0x4b, 0xf4 };
759
760 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
761 || !TEST_ptr(n = BN_bin2bn(n_data, sizeof(n_data), NULL))
762 || !TEST_ptr(e = BN_bin2bn(e_data, sizeof(e_data), NULL))
763 || !TEST_ptr(d = BN_bin2bn(d_data, sizeof(d_data), NULL))
764 || !TEST_ptr(p = BN_bin2bn(p_data, sizeof(p_data), NULL))
765 || !TEST_ptr(q = BN_bin2bn(q_data, sizeof(q_data), NULL))
766 || !TEST_ptr(p2 = BN_bin2bn(p2_data, sizeof(p2_data), NULL))
767 || !TEST_ptr(exp3 = BN_bin2bn(exp3_data, sizeof(exp3_data), NULL))
768 || !TEST_ptr(coeff2 = BN_bin2bn(coeff2_data, sizeof(coeff2_data), NULL))
769 || !TEST_ptr(dmp1 = BN_bin2bn(dmp1_data, sizeof(dmp1_data), NULL))
770 || !TEST_ptr(dmq1 = BN_bin2bn(dmq1_data, sizeof(dmq1_data), NULL))
771 || !TEST_ptr(iqmp = BN_bin2bn(iqmp_data, sizeof(iqmp_data), NULL))
772 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
773 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
774 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d))
775 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_FACTOR1,
776 p))
777 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_FACTOR2,
778 q))
779 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_FACTOR3,
780 p2))
781 || !TEST_true(OSSL_PARAM_BLD_push_int(bld,
782 OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ, 1))
783 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
784 goto err;
785
786 cdata[0].pname = OSSL_PKEY_PARAM_RSA_EXPONENT1;
787 cdata[0].comparebn = dmp1;
788 cdata[1].pname = OSSL_PKEY_PARAM_RSA_EXPONENT2;
789 cdata[1].comparebn = dmq1;
790 cdata[2].pname = OSSL_PKEY_PARAM_RSA_COEFFICIENT1;
791 cdata[2].comparebn = iqmp;
792 cdata[3].pname = OSSL_PKEY_PARAM_RSA_EXPONENT3;
793 cdata[3].comparebn = exp3;
794 cdata[4].pname = OSSL_PKEY_PARAM_RSA_COEFFICIENT2;
795 cdata[4].comparebn = coeff2;
796 cdata[5].pname = OSSL_PKEY_PARAM_RSA_N;
797 cdata[5].comparebn = n;
798 cdata[6].pname = OSSL_PKEY_PARAM_RSA_E;
799 cdata[6].comparebn = e;
800 cdata[7].pname = OSSL_PKEY_PARAM_RSA_D;
801 cdata[7].comparebn = d;
802 cdata[8].pname = OSSL_PKEY_PARAM_RSA_FACTOR1;
803 cdata[8].comparebn = p;
804 cdata[9].pname = OSSL_PKEY_PARAM_RSA_FACTOR2;
805 cdata[9].comparebn = q;
806 cdata[10].pname = OSSL_PKEY_PARAM_RSA_FACTOR3;
807 cdata[10].comparebn = p2;
808 cdata[11].pname = NULL;
809 cdata[11].comparebn = NULL;
810
811 ret = do_fromdata_rsa_derive(fromdata_params, cdata, 2048, 112, 256);
812
813 err:
814 BN_free(n);
815 BN_free(e);
816 BN_free(d);
817 BN_free(p);
818 BN_free(p2);
819 BN_free(q);
820 BN_free(dmp1);
821 BN_free(dmq1);
822 BN_free(iqmp);
823 BN_free(exp3);
824 BN_free(coeff2);
825 OSSL_PARAM_BLD_free(bld);
826 return ret;
827 }
828
test_evp_pkey_get_bn_param_large(void)829 static int test_evp_pkey_get_bn_param_large(void)
830 {
831 int ret = 0;
832 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
833 EVP_PKEY *pk = NULL;
834 OSSL_PARAM_BLD *bld = NULL;
835 OSSL_PARAM *fromdata_params = NULL;
836 BIGNUM *n = NULL, *e = NULL, *d = NULL, *n_out = NULL;
837 /*
838 * The buffer size chosen here for n_data larger than the buffer used
839 * internally in EVP_PKEY_get_bn_param.
840 */
841 static unsigned char n_data[2050];
842 static const unsigned char e_data[] = {
843 0x1, 0x00, 0x01
844 };
845 static const unsigned char d_data[] = {
846 0x99, 0x33, 0x13, 0x7b
847 };
848
849 /* N is a large buffer */
850 memset(n_data, 0xCE, sizeof(n_data));
851
852 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
853 || !TEST_ptr(n = BN_bin2bn(n_data, sizeof(n_data), NULL))
854 || !TEST_ptr(e = BN_bin2bn(e_data, sizeof(e_data), NULL))
855 || !TEST_ptr(d = BN_bin2bn(d_data, sizeof(d_data), NULL))
856 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
857 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
858 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d))
859 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld))
860 || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL))
861 || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
862 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
863 fromdata_params),
864 1)
865 || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, ""))
866 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_RSA_N, &n_out))
867 || !TEST_BN_eq(n, n_out))
868 goto err;
869 ret = 1;
870 err:
871 BN_free(n_out);
872 BN_free(n);
873 BN_free(e);
874 BN_free(d);
875 EVP_PKEY_free(pk);
876 EVP_PKEY_CTX_free(key_ctx);
877 EVP_PKEY_CTX_free(ctx);
878 OSSL_PARAM_free(fromdata_params);
879 OSSL_PARAM_BLD_free(bld);
880 return ret;
881 }
882
883 #ifndef OPENSSL_NO_DH
test_fromdata_dh_named_group(void)884 static int test_fromdata_dh_named_group(void)
885 {
886 int ret = 0;
887 int gindex = 0, pcounter = 0, hindex = 0;
888 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
889 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
890 size_t len;
891 BIGNUM *pub = NULL, *priv = NULL;
892 BIGNUM *pub_out = NULL, *priv_out = NULL;
893 BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
894 OSSL_PARAM *fromdata_params = NULL;
895 OSSL_PARAM_BLD *bld = NULL;
896 char name_out[80];
897 unsigned char seed_out[32];
898
899 /*
900 * DH key data was generated using the following:
901 * openssl genpkey -algorithm DH -pkeyopt group:ffdhe2048
902 * -pkeyopt priv_len:224 -text
903 */
904 static const unsigned char priv_data[] = {
905 0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf,
906 0x63, 0x5d, 0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21,
907 0x2b, 0xfa, 0x55, 0xfa, 0x87, 0xe8, 0xa9, 0x7b
908 };
909 static const unsigned char pub_data[] = {
910 0x00, 0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1,
911 0x82, 0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd,
912 0x33, 0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c,
913 0x64, 0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6,
914 0xf9, 0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5,
915 0xfa, 0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03,
916 0x9d, 0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9,
917 0x7e, 0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a,
918 0x57, 0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa,
919 0xe5, 0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef,
920 0x9a, 0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1,
921 0xdb, 0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7,
922 0x22, 0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f,
923 0x7c, 0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20,
924 0x82, 0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77,
925 0x14, 0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2,
926 0x6e, 0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12,
927 0xbc, 0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0,
928 0xf1, 0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67,
929 0xa1, 0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc,
930 0xa8, 0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab,
931 0xcf, 0x33, 0x42, 0x83, 0x42
932 };
933 static const char group_name[] = "ffdhe2048";
934 static const long priv_len = 224;
935
936 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
937 || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
938 || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
939 || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
940 OSSL_PKEY_PARAM_GROUP_NAME,
941 group_name, 0))
942 || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
943 priv_len))
944 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
945 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
946 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
947 goto err;
948
949 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
950 goto err;
951
952 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
953 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
954 fromdata_params),
955 1))
956 goto err;
957
958 /*
959 * A few extra checks of EVP_PKEY_get_utf8_string_param() to see that
960 * it behaves as expected with regards to string length and terminating
961 * NUL byte.
962 */
963 if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
964 OSSL_PKEY_PARAM_GROUP_NAME,
965 NULL, sizeof(name_out),
966 &len))
967 || !TEST_size_t_eq(len, sizeof(group_name) - 1)
968 /* Just enough space to hold the group name and a terminating NUL */
969 || !TEST_true(EVP_PKEY_get_utf8_string_param(pk,
970 OSSL_PKEY_PARAM_GROUP_NAME,
971 name_out,
972 sizeof(group_name),
973 &len))
974 || !TEST_size_t_eq(len, sizeof(group_name) - 1)
975 /* Too small buffer to hold the terminating NUL byte */
976 || !TEST_false(EVP_PKEY_get_utf8_string_param(pk,
977 OSSL_PKEY_PARAM_GROUP_NAME,
978 name_out,
979 sizeof(group_name) - 1,
980 &len))
981 /* Too small buffer to hold the whole group name, even! */
982 || !TEST_false(EVP_PKEY_get_utf8_string_param(pk,
983 OSSL_PKEY_PARAM_GROUP_NAME,
984 name_out,
985 sizeof(group_name) - 2,
986 &len)))
987 goto err;
988
989 for (;;) {
990 ret = 0;
991 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
992 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
993 || !TEST_int_eq(EVP_PKEY_get_size(pk), 256)
994 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
995 goto err;
996
997 if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
998 OSSL_PKEY_PARAM_GROUP_NAME,
999 name_out,
1000 sizeof(name_out),
1001 &len))
1002 || !TEST_str_eq(name_out, group_name)
1003 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1004 &pub_out))
1005
1006 || !TEST_BN_eq(pub, pub_out)
1007 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1008 &priv_out))
1009 || !TEST_BN_eq(priv, priv_out)
1010 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
1011 || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
1012 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
1013 || !TEST_ptr(q)
1014 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
1015 || !TEST_BN_eq(&ossl_bignum_const_2, g)
1016 || !TEST_false(EVP_PKEY_get_bn_param(pk,
1017 OSSL_PKEY_PARAM_FFC_COFACTOR,
1018 &j))
1019 || !TEST_ptr_null(j)
1020 || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
1021 OSSL_PKEY_PARAM_FFC_SEED,
1022 seed_out,
1023 sizeof(seed_out),
1024 &len))
1025 || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_GINDEX,
1026 &gindex))
1027 || !TEST_int_eq(gindex, -1)
1028 || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
1029 &hindex))
1030 || !TEST_int_eq(hindex, 0)
1031 || !TEST_true(EVP_PKEY_get_int_param(pk,
1032 OSSL_PKEY_PARAM_FFC_PCOUNTER,
1033 &pcounter))
1034 || !TEST_int_eq(pcounter, -1))
1035 goto err;
1036 BN_free(p);
1037 p = NULL;
1038 BN_free(q);
1039 q = NULL;
1040 BN_free(g);
1041 g = NULL;
1042 BN_free(j);
1043 j = NULL;
1044 BN_free(pub_out);
1045 pub_out = NULL;
1046 BN_free(priv_out);
1047 priv_out = NULL;
1048
1049 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
1050 goto err;
1051
1052 if (!TEST_int_gt(EVP_PKEY_check(key_ctx), 0)
1053 || !TEST_int_gt(EVP_PKEY_public_check(key_ctx), 0)
1054 || !TEST_int_gt(EVP_PKEY_private_check(key_ctx), 0)
1055 || !TEST_int_gt(EVP_PKEY_pairwise_check(key_ctx), 0))
1056 goto err;
1057 EVP_PKEY_CTX_free(key_ctx);
1058 key_ctx = NULL;
1059
1060 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1061 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1062 goto err;
1063 EVP_PKEY_free(copy_pk);
1064 copy_pk = NULL;
1065
1066 ret = test_print_key_using_pem("DH", pk)
1067 && test_print_key_using_encoder("DH", pk);
1068
1069 if (!ret || dup_pk != NULL)
1070 break;
1071
1072 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1073 goto err;
1074 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1075 EVP_PKEY_free(pk);
1076 pk = dup_pk;
1077 if (!ret)
1078 goto err;
1079 }
1080 err:
1081 BN_free(p);
1082 BN_free(q);
1083 BN_free(g);
1084 BN_free(j);
1085 BN_free(pub);
1086 BN_free(priv);
1087 BN_free(pub_out);
1088 BN_free(priv_out);
1089 EVP_PKEY_free(copy_pk);
1090 EVP_PKEY_free(pk);
1091 EVP_PKEY_CTX_free(ctx);
1092 EVP_PKEY_CTX_free(key_ctx);
1093 OSSL_PARAM_free(fromdata_params);
1094 OSSL_PARAM_BLD_free(bld);
1095
1096 return ret;
1097 }
1098
test_fromdata_dh_fips186_4(void)1099 static int test_fromdata_dh_fips186_4(void)
1100 {
1101 int ret = 0;
1102 int gindex = 0, pcounter = 0, hindex = 0;
1103 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
1104 EVP_PKEY *pk = NULL, *dup_pk = NULL;
1105 size_t len;
1106 BIGNUM *pub = NULL, *priv = NULL;
1107 BIGNUM *pub_out = NULL, *priv_out = NULL;
1108 BIGNUM *p = NULL, *q = NULL, *g = NULL, *j = NULL;
1109 OSSL_PARAM_BLD *bld = NULL;
1110 OSSL_PARAM *fromdata_params = NULL;
1111 char name_out[80];
1112 unsigned char seed_out[32];
1113
1114 /*
1115 * DH key data was generated using the following:
1116 * openssl genpkey -algorithm DH
1117 * -pkeyopt group:ffdhe2048 -pkeyopt priv_len:224 -text
1118 */
1119 static const unsigned char priv_data[] = {
1120 0x88, 0x85, 0xe7, 0x9f, 0xee, 0x6d, 0xc5, 0x7c, 0x78, 0xaf,
1121 0x63, 0x5d, 0x38, 0x2a, 0xd0, 0xed, 0x56, 0x4b, 0x47, 0x21,
1122 0x2b, 0xfa, 0x55, 0xfa, 0x87, 0xe8, 0xa9, 0x7b
1123 };
1124 static const unsigned char pub_data[] = {
1125 0xd6, 0x2d, 0x77, 0xe0, 0xd3, 0x7d, 0xf8, 0xeb, 0x98, 0x50, 0xa1, 0x82,
1126 0x22, 0x65, 0xd5, 0xd9, 0xfe, 0xc9, 0x3f, 0xbe, 0x16, 0x83, 0xbd, 0x33,
1127 0xe9, 0xc6, 0x93, 0xcf, 0x08, 0xaf, 0x83, 0xfa, 0x80, 0x8a, 0x6c, 0x64,
1128 0xdf, 0x70, 0x64, 0xd5, 0x0a, 0x7c, 0x5a, 0x72, 0xda, 0x66, 0xe6, 0xf9,
1129 0xf5, 0x31, 0x21, 0x92, 0xb0, 0x60, 0x1a, 0xb5, 0xd3, 0xf0, 0xa5, 0xfa,
1130 0x48, 0x95, 0x2e, 0x38, 0xd9, 0xc5, 0xe6, 0xda, 0xfb, 0x6c, 0x03, 0x9d,
1131 0x4b, 0x69, 0xb7, 0x95, 0xe4, 0x5c, 0xc0, 0x93, 0x4f, 0x48, 0xd9, 0x7e,
1132 0x06, 0x22, 0xb2, 0xde, 0xf3, 0x79, 0x24, 0xed, 0xe1, 0xd1, 0x4a, 0x57,
1133 0xf1, 0x40, 0x86, 0x70, 0x42, 0x25, 0xc5, 0x27, 0x68, 0xc9, 0xfa, 0xe5,
1134 0x8e, 0x62, 0x7e, 0xff, 0x49, 0x6c, 0x5b, 0xb5, 0xba, 0xf9, 0xef, 0x9a,
1135 0x1a, 0x10, 0xd4, 0x81, 0x53, 0xcf, 0x83, 0x04, 0x18, 0x1c, 0xe1, 0xdb,
1136 0xe1, 0x65, 0xa9, 0x7f, 0xe1, 0x33, 0xeb, 0xc3, 0x4f, 0xe3, 0xb7, 0x22,
1137 0xf7, 0x1c, 0x09, 0x4f, 0xed, 0xc6, 0x07, 0x8e, 0x78, 0x05, 0x8f, 0x7c,
1138 0x96, 0xd9, 0x12, 0xe0, 0x81, 0x74, 0x1a, 0xe9, 0x13, 0xc0, 0x20, 0x82,
1139 0x65, 0xbb, 0x42, 0x3b, 0xed, 0x08, 0x6a, 0x84, 0x4f, 0xea, 0x77, 0x14,
1140 0x32, 0xf9, 0xed, 0xc2, 0x12, 0xd6, 0xc5, 0xc6, 0xb3, 0xe5, 0xf2, 0x6e,
1141 0xf6, 0x16, 0x7f, 0x37, 0xde, 0xbc, 0x09, 0xc7, 0x06, 0x6b, 0x12, 0xbc,
1142 0xad, 0x2d, 0x49, 0x25, 0xd5, 0xdc, 0xf4, 0x18, 0x14, 0xd2, 0xf0, 0xf1,
1143 0x1d, 0x1f, 0x3a, 0xaa, 0x15, 0x55, 0xbb, 0x0d, 0x7f, 0xbe, 0x67, 0xa1,
1144 0xa7, 0xf0, 0xaa, 0xb3, 0xfb, 0x41, 0x82, 0x39, 0x49, 0x93, 0xbc, 0xa8,
1145 0xee, 0x72, 0x13, 0x45, 0x65, 0x15, 0x42, 0x17, 0xaa, 0xd8, 0xab, 0xcf,
1146 0x33, 0x42, 0x83, 0x42
1147 };
1148 static const char group_name[] = "ffdhe2048";
1149 static const long priv_len = 224;
1150
1151 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1152 || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
1153 || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
1154 || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
1155 OSSL_PKEY_PARAM_GROUP_NAME,
1156 group_name, 0))
1157 || !TEST_true(OSSL_PARAM_BLD_push_long(bld, OSSL_PKEY_PARAM_DH_PRIV_LEN,
1158 priv_len))
1159 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY, pub))
1160 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv))
1161 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1162 goto err;
1163
1164 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
1165 goto err;
1166
1167 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1168 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1169 fromdata_params),
1170 1))
1171 goto err;
1172
1173 for (;;) {
1174 ret = 0;
1175 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
1176 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
1177 || !TEST_int_eq(EVP_PKEY_get_size(pk), 256)
1178 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1179 goto err;
1180
1181 if (!TEST_true(EVP_PKEY_get_utf8_string_param(pk,
1182 OSSL_PKEY_PARAM_GROUP_NAME,
1183 name_out,
1184 sizeof(name_out),
1185 &len))
1186 || !TEST_str_eq(name_out, group_name)
1187 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1188 &pub_out))
1189 || !TEST_BN_eq(pub, pub_out)
1190 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1191 &priv_out))
1192 || !TEST_BN_eq(priv, priv_out)
1193 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P, &p))
1194 || !TEST_BN_eq(&ossl_bignum_ffdhe2048_p, p)
1195 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q, &q))
1196 || !TEST_ptr(q)
1197 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G, &g))
1198 || !TEST_BN_eq(&ossl_bignum_const_2, g)
1199 || !TEST_false(EVP_PKEY_get_bn_param(pk,
1200 OSSL_PKEY_PARAM_FFC_COFACTOR,
1201 &j))
1202 || !TEST_ptr_null(j)
1203 || !TEST_false(EVP_PKEY_get_octet_string_param(pk,
1204 OSSL_PKEY_PARAM_FFC_SEED,
1205 seed_out,
1206 sizeof(seed_out),
1207 &len))
1208 || !TEST_true(EVP_PKEY_get_int_param(pk,
1209 OSSL_PKEY_PARAM_FFC_GINDEX,
1210 &gindex))
1211 || !TEST_int_eq(gindex, -1)
1212 || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
1213 &hindex))
1214 || !TEST_int_eq(hindex, 0)
1215 || !TEST_true(EVP_PKEY_get_int_param(pk,
1216 OSSL_PKEY_PARAM_FFC_PCOUNTER,
1217 &pcounter))
1218 || !TEST_int_eq(pcounter, -1))
1219 goto err;
1220 BN_free(p);
1221 p = NULL;
1222 BN_free(q);
1223 q = NULL;
1224 BN_free(g);
1225 g = NULL;
1226 BN_free(j);
1227 j = NULL;
1228 BN_free(pub_out);
1229 pub_out = NULL;
1230 BN_free(priv_out);
1231 priv_out = NULL;
1232
1233 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
1234 goto err;
1235
1236 if (!TEST_int_gt(EVP_PKEY_check(key_ctx), 0)
1237 || !TEST_int_gt(EVP_PKEY_public_check(key_ctx), 0)
1238 || !TEST_int_gt(EVP_PKEY_private_check(key_ctx), 0)
1239 || !TEST_int_gt(EVP_PKEY_pairwise_check(key_ctx), 0))
1240 goto err;
1241 EVP_PKEY_CTX_free(key_ctx);
1242 key_ctx = NULL;
1243
1244 ret = test_print_key_using_pem("DH", pk)
1245 && test_print_key_using_encoder("DH", pk);
1246
1247 if (!ret || dup_pk != NULL)
1248 break;
1249
1250 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1251 goto err;
1252 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1253 EVP_PKEY_free(pk);
1254 pk = dup_pk;
1255 if (!ret)
1256 goto err;
1257 }
1258 err:
1259 BN_free(p);
1260 BN_free(q);
1261 BN_free(g);
1262 BN_free(j);
1263 BN_free(pub);
1264 BN_free(priv);
1265 BN_free(pub_out);
1266 BN_free(priv_out);
1267 EVP_PKEY_free(pk);
1268 EVP_PKEY_CTX_free(ctx);
1269 EVP_PKEY_CTX_free(key_ctx);
1270 OSSL_PARAM_free(fromdata_params);
1271 OSSL_PARAM_BLD_free(bld);
1272
1273 return ret;
1274 }
1275
1276 #endif
1277
1278 #ifndef OPENSSL_NO_EC
1279 #ifndef OPENSSL_NO_ECX
1280 /* Array indexes used in test_fromdata_ecx */
1281 #define PRIV_KEY 0
1282 #define PUB_KEY 1
1283
1284 #define X25519_IDX 0
1285 #define X448_IDX 1
1286 #define ED25519_IDX 2
1287 #define ED448_IDX 3
1288
1289 /*
1290 * tst uses indexes 0 ... (3 * 4 - 1)
1291 * For the 4 ECX key types (X25519_IDX..ED448_IDX)
1292 * 0..3 = public + private key.
1293 * 4..7 = private key (This will generate the public key from the private key)
1294 * 8..11 = public key
1295 */
test_fromdata_ecx(int tst)1296 static int test_fromdata_ecx(int tst)
1297 {
1298 int ret = 0;
1299 EVP_PKEY_CTX *ctx = NULL, *ctx2 = NULL;
1300 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
1301 const char *alg = NULL;
1302 size_t len;
1303 unsigned char out_pub[ED448_KEYLEN];
1304 unsigned char out_priv[ED448_KEYLEN];
1305 OSSL_PARAM params[3] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
1306
1307 /* ED448_KEYLEN > X448_KEYLEN > X25519_KEYLEN == ED25519_KEYLEN */
1308 static unsigned char key_numbers[4][2][ED448_KEYLEN] = {
1309 /* X25519: Keys from RFC 7748 6.1 */
1310 {
1311 /* Private Key */
1312 {
1313 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
1314 0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
1315 0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
1316 0x2c, 0x2a },
1317 /* Public Key */
1318 {
1319 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
1320 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
1321 0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
1322 0x4e, 0x6a } },
1323 /* X448: Keys from RFC 7748 6.2 */
1324 {
1325 /* Private Key */
1326 {
1327 0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
1328 0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
1329 0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
1330 0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
1331 0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
1332 0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b },
1333 /* Public Key */
1334 {
1335 0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
1336 0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
1337 0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
1338 0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
1339 0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
1340 0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0 } },
1341 /* ED25519: Keys from RFC 8032 */
1342 {
1343 /* Private Key */
1344 {
1345 0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84,
1346 0x4a, 0xf4, 0x92, 0xec, 0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69,
1347 0x7b, 0x32, 0x69, 0x19, 0x70, 0x3b, 0xac, 0x03, 0x1c, 0xae,
1348 0x7f, 0x60 },
1349 /* Public Key */
1350 {
1351 0xd7, 0x5a, 0x98, 0x01, 0x82, 0xb1, 0x0a, 0xb7, 0xd5, 0x4b,
1352 0xfe, 0xd3, 0xc9, 0x64, 0x07, 0x3a, 0x0e, 0xe1, 0x72, 0xf3,
1353 0xda, 0xa6, 0x23, 0x25, 0xaf, 0x02, 0x1a, 0x68, 0xf7, 0x07,
1354 0x51, 0x1a } },
1355 /* ED448: Keys from RFC 8032 */
1356 {
1357 /* Private Key */
1358 {
1359 0x6c, 0x82, 0xa5, 0x62, 0xcb, 0x80, 0x8d, 0x10, 0xd6, 0x32,
1360 0xbe, 0x89, 0xc8, 0x51, 0x3e, 0xbf, 0x6c, 0x92, 0x9f, 0x34,
1361 0xdd, 0xfa, 0x8c, 0x9f, 0x63, 0xc9, 0x96, 0x0e, 0xf6, 0xe3,
1362 0x48, 0xa3, 0x52, 0x8c, 0x8a, 0x3f, 0xcc, 0x2f, 0x04, 0x4e,
1363 0x39, 0xa3, 0xfc, 0x5b, 0x94, 0x49, 0x2f, 0x8f, 0x03, 0x2e,
1364 0x75, 0x49, 0xa2, 0x00, 0x98, 0xf9, 0x5b },
1365 /* Public Key */
1366 {
1367 0x5f, 0xd7, 0x44, 0x9b, 0x59, 0xb4, 0x61, 0xfd, 0x2c, 0xe7,
1368 0x87, 0xec, 0x61, 0x6a, 0xd4, 0x6a, 0x1d, 0xa1, 0x34, 0x24,
1369 0x85, 0xa7, 0x0e, 0x1f, 0x8a, 0x0e, 0xa7, 0x5d, 0x80, 0xe9,
1370 0x67, 0x78, 0xed, 0xf1, 0x24, 0x76, 0x9b, 0x46, 0xc7, 0x06,
1371 0x1b, 0xd6, 0x78, 0x3d, 0xf1, 0xe5, 0x0f, 0x6c, 0xd1, 0xfa,
1372 0x1a, 0xbe, 0xaf, 0xe8, 0x25, 0x61, 0x80 } }
1373 };
1374 OSSL_PARAM x25519_fromdata_params[] = {
1375 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1376 key_numbers[X25519_IDX][PRIV_KEY],
1377 X25519_KEYLEN),
1378 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1379 key_numbers[X25519_IDX][PUB_KEY],
1380 X25519_KEYLEN),
1381 OSSL_PARAM_END
1382 };
1383 OSSL_PARAM x448_fromdata_params[] = {
1384 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1385 key_numbers[X448_IDX][PRIV_KEY],
1386 X448_KEYLEN),
1387 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1388 key_numbers[X448_IDX][PUB_KEY],
1389 X448_KEYLEN),
1390 OSSL_PARAM_END
1391 };
1392 OSSL_PARAM ed25519_fromdata_params[] = {
1393 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1394 key_numbers[ED25519_IDX][PRIV_KEY],
1395 ED25519_KEYLEN),
1396 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1397 key_numbers[ED25519_IDX][PUB_KEY],
1398 ED25519_KEYLEN),
1399 OSSL_PARAM_END
1400 };
1401 OSSL_PARAM ed448_fromdata_params[] = {
1402 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1403 key_numbers[ED448_IDX][PRIV_KEY],
1404 ED448_KEYLEN),
1405 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1406 key_numbers[ED448_IDX][PUB_KEY],
1407 ED448_KEYLEN),
1408 OSSL_PARAM_END
1409 };
1410 OSSL_PARAM *fromdata_params = NULL;
1411 int bits = 0, security_bits = 0, size = 0;
1412 OSSL_PARAM *orig_fromdata_params = NULL;
1413
1414 switch (tst & 3) {
1415 case X25519_IDX:
1416 fromdata_params = x25519_fromdata_params;
1417 bits = X25519_BITS;
1418 security_bits = X25519_SECURITY_BITS;
1419 size = X25519_KEYLEN;
1420 alg = "X25519";
1421 break;
1422
1423 case X448_IDX:
1424 fromdata_params = x448_fromdata_params;
1425 bits = X448_BITS;
1426 security_bits = X448_SECURITY_BITS;
1427 size = X448_KEYLEN;
1428 alg = "X448";
1429 break;
1430
1431 case ED25519_IDX:
1432 fromdata_params = ed25519_fromdata_params;
1433 bits = ED25519_BITS;
1434 security_bits = ED25519_SECURITY_BITS;
1435 size = ED25519_SIGSIZE;
1436 alg = "ED25519";
1437 break;
1438
1439 case ED448_IDX:
1440 fromdata_params = ed448_fromdata_params;
1441 bits = ED448_BITS;
1442 security_bits = ED448_SECURITY_BITS;
1443 size = ED448_SIGSIZE;
1444 alg = "ED448";
1445 break;
1446 default:
1447 goto err;
1448 }
1449
1450 ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
1451 if (!TEST_ptr(ctx))
1452 goto err;
1453
1454 orig_fromdata_params = fromdata_params;
1455 if (tst > 7) {
1456 /* public key only */
1457 fromdata_params++;
1458 } else if (tst > 3) {
1459 /* private key only */
1460 params[0] = fromdata_params[0];
1461 params[1] = fromdata_params[2];
1462 fromdata_params = params;
1463 }
1464
1465 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1466 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1467 fromdata_params),
1468 1))
1469 goto err;
1470
1471 for (;;) {
1472 ret = 0;
1473 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), bits)
1474 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), security_bits)
1475 || !TEST_int_eq(EVP_PKEY_get_size(pk), size)
1476 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1477 goto err;
1478
1479 if (!TEST_ptr(ctx2 = EVP_PKEY_CTX_new_from_pkey(NULL, pk, NULL)))
1480 goto err;
1481 if (tst <= 7) {
1482 if (!TEST_int_gt(EVP_PKEY_check(ctx2), 0))
1483 goto err;
1484 if (!TEST_true(EVP_PKEY_get_octet_string_param(
1485 pk, orig_fromdata_params[PRIV_KEY].key,
1486 out_priv, sizeof(out_priv), &len))
1487 || !TEST_mem_eq(out_priv, len,
1488 orig_fromdata_params[PRIV_KEY].data,
1489 orig_fromdata_params[PRIV_KEY].data_size)
1490 || !TEST_true(EVP_PKEY_get_octet_string_param(
1491 pk, orig_fromdata_params[PUB_KEY].key,
1492 out_pub, sizeof(out_pub), &len))
1493 || !TEST_mem_eq(out_pub, len,
1494 orig_fromdata_params[PUB_KEY].data,
1495 orig_fromdata_params[PUB_KEY].data_size))
1496 goto err;
1497 } else {
1498 /* The private key check should fail if there is only a public key */
1499 if (!TEST_int_gt(EVP_PKEY_public_check(ctx2), 0)
1500 || !TEST_int_le(EVP_PKEY_private_check(ctx2), 0)
1501 || !TEST_int_le(EVP_PKEY_check(ctx2), 0))
1502 goto err;
1503 }
1504 EVP_PKEY_CTX_free(ctx2);
1505 ctx2 = NULL;
1506
1507 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1508 /* This should succeed because there are no parameters to copy */
1509 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1510 goto err;
1511 if (!TEST_ptr(ctx2 = EVP_PKEY_CTX_new_from_pkey(NULL, copy_pk, NULL))
1512 /* This should fail because copy_pk has no pubkey */
1513 || !TEST_int_le(EVP_PKEY_public_check(ctx2), 0))
1514 goto err;
1515 EVP_PKEY_CTX_free(ctx2);
1516 ctx2 = NULL;
1517 EVP_PKEY_free(copy_pk);
1518 copy_pk = NULL;
1519
1520 if (tst > 7)
1521 ret = test_print_key_using_encoder_public(alg, pk);
1522 else
1523 ret = test_print_key_using_pem(alg, pk)
1524 && test_print_key_using_encoder(alg, pk);
1525
1526 if (!ret || dup_pk != NULL)
1527 break;
1528
1529 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1530 goto err;
1531 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1532 EVP_PKEY_free(pk);
1533 pk = dup_pk;
1534 if (!ret)
1535 goto err;
1536 }
1537
1538 err:
1539 EVP_PKEY_free(pk);
1540 EVP_PKEY_free(copy_pk);
1541 EVP_PKEY_CTX_free(ctx);
1542 EVP_PKEY_CTX_free(ctx2);
1543
1544 return ret;
1545 }
1546 #endif /* OPENSSL_NO_ECX */
1547
test_fromdata_ec(void)1548 static int test_fromdata_ec(void)
1549 {
1550 int ret = 0;
1551 EVP_PKEY_CTX *ctx = NULL;
1552 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
1553 OSSL_PARAM_BLD *bld = NULL;
1554 BIGNUM *ec_priv_bn = NULL;
1555 BIGNUM *bn_priv = NULL;
1556 OSSL_PARAM *fromdata_params = NULL;
1557 const char *alg = "EC";
1558 const char *curve = "prime256v1";
1559 const char bad_curve[] = "nonexistent-curve";
1560 OSSL_PARAM nokey_params[2] = {
1561 OSSL_PARAM_END,
1562 OSSL_PARAM_END
1563 };
1564 /* UNCOMPRESSED FORMAT */
1565 static const unsigned char ec_pub_keydata[] = {
1566 POINT_CONVERSION_UNCOMPRESSED,
1567 0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
1568 0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
1569 0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
1570 0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
1571 0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
1572 0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
1573 0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
1574 0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
1575 };
1576 /* SAME BUT COMPRESSED FORMAT */
1577 static const unsigned char ec_pub_keydata_compressed[] = {
1578 POINT_CONVERSION_COMPRESSED + 1,
1579 0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
1580 0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
1581 0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
1582 0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2
1583 };
1584 static const unsigned char ec_priv_keydata[] = {
1585 0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
1586 0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
1587 0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
1588 0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
1589 };
1590 unsigned char out_pub[sizeof(ec_pub_keydata)];
1591 char out_curve_name[80];
1592 const OSSL_PARAM *gettable = NULL;
1593 size_t len;
1594 EC_GROUP *group = NULL;
1595 BIGNUM *group_a = NULL;
1596 BIGNUM *group_b = NULL;
1597 BIGNUM *group_p = NULL;
1598 BIGNUM *a = NULL;
1599 BIGNUM *b = NULL;
1600 BIGNUM *p = NULL;
1601 OSSL_PARAM probe[2] = {
1602 OSSL_PARAM_DEFN(OSSL_PKEY_PARAM_PRIV_KEY, OSSL_PARAM_UNSIGNED_INTEGER,
1603 NULL, 0),
1604 OSSL_PARAM_END
1605 };
1606
1607 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new()))
1608 goto err;
1609 if (!TEST_ptr(ec_priv_bn = BN_bin2bn(ec_priv_keydata,
1610 sizeof(ec_priv_keydata), NULL)))
1611 goto err;
1612
1613 if (OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME,
1614 curve, 0)
1615 <= 0)
1616 goto err;
1617 /*
1618 * We intentionally provide the input point in compressed format,
1619 * and avoid setting `OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT`.
1620 *
1621 * Later on we check what format is used when exporting the
1622 * `OSSL_PKEY_PARAM_PUB_KEY` and expect to default to uncompressed
1623 * format.
1624 */
1625 if (OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY,
1626 ec_pub_keydata_compressed,
1627 sizeof(ec_pub_keydata_compressed))
1628 <= 0)
1629 goto err;
1630 if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, ec_priv_bn) <= 0)
1631 goto err;
1632 if (!TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1633 goto err;
1634 ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
1635 if (!TEST_ptr(ctx))
1636 goto err;
1637
1638 /* try importing parameters with bad curve first */
1639 nokey_params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
1640 (char *)bad_curve, sizeof(bad_curve));
1641 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1642 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEY_PARAMETERS,
1643 nokey_params),
1644 0)
1645 || !TEST_ptr_null(pk))
1646 goto err;
1647
1648 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1649 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1650 fromdata_params),
1651 1))
1652 goto err;
1653
1654 for (;;) {
1655 ret = 0;
1656 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 256)
1657 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 128)
1658 || !TEST_int_eq(EVP_PKEY_get_size(pk), 2 + 35 * 2)
1659 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
1660 goto err;
1661
1662 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
1663 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
1664 goto err;
1665 EVP_PKEY_free(copy_pk);
1666 copy_pk = NULL;
1667
1668 if (!TEST_ptr(gettable = EVP_PKEY_gettable_params(pk))
1669 || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1670 OSSL_PKEY_PARAM_GROUP_NAME))
1671 || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1672 OSSL_PKEY_PARAM_PUB_KEY))
1673 || !TEST_ptr(OSSL_PARAM_locate_const(gettable,
1674 OSSL_PKEY_PARAM_PRIV_KEY)))
1675 goto err;
1676
1677 if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(OBJ_sn2nid(curve)))
1678 || !TEST_ptr(group_p = BN_new())
1679 || !TEST_ptr(group_a = BN_new())
1680 || !TEST_ptr(group_b = BN_new())
1681 || !TEST_true(EC_GROUP_get_curve(group, group_p, group_a, group_b, NULL)))
1682 goto err;
1683
1684 if (!TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_A, &a))
1685 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_B, &b))
1686 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_EC_P, &p)))
1687 goto err;
1688
1689 if (!TEST_BN_eq(group_p, p) || !TEST_BN_eq(group_a, a)
1690 || !TEST_BN_eq(group_b, b))
1691 goto err;
1692
1693 /*
1694 * Probe the EC private-key BN length via the explicit-params
1695 * path; with NULL data, return_size receives the required
1696 * (padded) buffer size, which equals the byte length of the
1697 * group order.
1698 */
1699 probe[0].return_size = OSSL_PARAM_UNMODIFIED;
1700 if (!TEST_true(EVP_PKEY_get_params(pk, probe))
1701 || !TEST_size_t_eq(probe[0].return_size,
1702 BN_num_bytes(EC_GROUP_get0_order(group))))
1703 goto err;
1704
1705 EC_GROUP_free(group);
1706 group = NULL;
1707 BN_free(group_p);
1708 group_p = NULL;
1709 BN_free(group_a);
1710 group_a = NULL;
1711 BN_free(group_b);
1712 group_b = NULL;
1713
1714 if (!EVP_PKEY_get_utf8_string_param(pk, OSSL_PKEY_PARAM_GROUP_NAME,
1715 out_curve_name,
1716 sizeof(out_curve_name),
1717 &len)
1718 || !TEST_str_eq(out_curve_name, curve)
1719 || !EVP_PKEY_get_octet_string_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
1720 out_pub, sizeof(out_pub), &len)
1721
1722 /*
1723 * Our providers use uncompressed format by default if
1724 * `OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT` was not
1725 * explicitly set, irrespective of the format used for the
1726 * input point given as a param to create this key.
1727 */
1728 || !TEST_true(out_pub[0] == POINT_CONVERSION_UNCOMPRESSED)
1729 || !TEST_mem_eq(out_pub + 1, len - 1,
1730 ec_pub_keydata + 1, sizeof(ec_pub_keydata) - 1)
1731
1732 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
1733 &bn_priv))
1734 || !TEST_BN_eq(ec_priv_bn, bn_priv))
1735 goto err;
1736 BN_free(bn_priv);
1737 bn_priv = NULL;
1738
1739 ret = test_print_key_using_pem(alg, pk)
1740 && test_print_key_using_encoder(alg, pk);
1741
1742 if (!ret || dup_pk != NULL)
1743 break;
1744
1745 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
1746 goto err;
1747 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
1748 EVP_PKEY_free(pk);
1749 pk = dup_pk;
1750 if (!ret)
1751 goto err;
1752 }
1753
1754 err:
1755 EC_GROUP_free(group);
1756 BN_free(group_a);
1757 BN_free(group_b);
1758 BN_free(group_p);
1759 BN_free(a);
1760 BN_free(b);
1761 BN_free(p);
1762 BN_free(bn_priv);
1763 BN_free(ec_priv_bn);
1764 OSSL_PARAM_free(fromdata_params);
1765 OSSL_PARAM_BLD_free(bld);
1766 EVP_PKEY_free(pk);
1767 EVP_PKEY_free(copy_pk);
1768 EVP_PKEY_CTX_free(ctx);
1769 return ret;
1770 }
1771
test_ec_dup_no_operation(void)1772 static int test_ec_dup_no_operation(void)
1773 {
1774 int ret = 0;
1775 EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1776 EVP_PKEY *param = NULL, *pkey = NULL;
1777
1778 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1779 || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1780 || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1781 NID_X9_62_prime256v1),
1782 0)
1783 || !TEST_int_gt(EVP_PKEY_paramgen(pctx, ¶m), 0)
1784 || !TEST_ptr(param))
1785 goto err;
1786
1787 EVP_PKEY_CTX_free(pctx);
1788 pctx = NULL;
1789
1790 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1791 || !TEST_ptr(kctx = EVP_PKEY_CTX_dup(ctx))
1792 || !TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1793 || !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0))
1794 goto err;
1795 ret = 1;
1796 err:
1797 EVP_PKEY_free(pkey);
1798 EVP_PKEY_free(param);
1799 EVP_PKEY_CTX_free(ctx);
1800 EVP_PKEY_CTX_free(kctx);
1801 EVP_PKEY_CTX_free(pctx);
1802 return ret;
1803 }
1804
1805 /* Test that keygen doesn't support EVP_PKEY_CTX_dup */
test_ec_dup_keygen_operation(void)1806 static int test_ec_dup_keygen_operation(void)
1807 {
1808 int ret = 0;
1809 EVP_PKEY_CTX *pctx = NULL, *ctx = NULL, *kctx = NULL;
1810 EVP_PKEY *param = NULL, *pkey = NULL;
1811
1812 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))
1813 || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1814 || !TEST_int_gt(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1815 NID_X9_62_prime256v1),
1816 0)
1817 || !TEST_int_gt(EVP_PKEY_paramgen(pctx, ¶m), 0)
1818 || !TEST_ptr(param))
1819 goto err;
1820
1821 EVP_PKEY_CTX_free(pctx);
1822 pctx = NULL;
1823
1824 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param, NULL))
1825 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1826 || !TEST_ptr_null(kctx = EVP_PKEY_CTX_dup(ctx)))
1827 goto err;
1828 ret = 1;
1829 err:
1830 EVP_PKEY_free(pkey);
1831 EVP_PKEY_free(param);
1832 EVP_PKEY_CTX_free(ctx);
1833 EVP_PKEY_CTX_free(kctx);
1834 EVP_PKEY_CTX_free(pctx);
1835 return ret;
1836 }
1837
1838 #endif /* OPENSSL_NO_EC */
1839
1840 #ifndef OPENSSL_NO_DSA
test_fromdata_dsa_fips186_4(void)1841 static int test_fromdata_dsa_fips186_4(void)
1842 {
1843 int ret = 0;
1844 EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
1845 EVP_PKEY *pk = NULL, *copy_pk = NULL, *dup_pk = NULL;
1846 BIGNUM *pub = NULL, *priv = NULL;
1847 BIGNUM *p = NULL, *q = NULL, *g = NULL;
1848 BIGNUM *pub_out = NULL, *priv_out = NULL;
1849 BIGNUM *p_out = NULL, *q_out = NULL, *g_out = NULL, *j_out = NULL;
1850 int gindex_out = 0, pcounter_out = 0, hindex_out = 0;
1851 char name_out[80];
1852 unsigned char seed_out[32];
1853 size_t len;
1854 OSSL_PARAM_BLD *bld = NULL;
1855 OSSL_PARAM *fromdata_params = NULL;
1856
1857 /*
1858 * DSA parameter data was generated using the following:
1859 * openssl genpkey -genparam -algorithm DSA -pkeyopt pbits:2048 \
1860 * -pkeyopt qbits:256 -pkeyopt type:0 \
1861 * -pkeyopt gindex:1 -out dsa_params.pem -text
1862 */
1863 static const unsigned char p_data[] = {
1864 0x00, 0xa0, 0xb7, 0x02, 0xc4, 0xac, 0xa6, 0x42, 0xab, 0xf2, 0x34, 0x0b,
1865 0x22, 0x47, 0x1f, 0x33, 0xcf, 0xd5, 0x04, 0xe4, 0x3e, 0xec, 0xa1, 0x21,
1866 0xc8, 0x41, 0x2b, 0xef, 0xb8, 0x1f, 0x0b, 0x5b, 0x88, 0x8b, 0x67, 0xf8,
1867 0x68, 0x6d, 0x7c, 0x4d, 0x96, 0x5f, 0x3c, 0x66, 0xef, 0x58, 0x34, 0xd7,
1868 0xf6, 0xa2, 0x1b, 0xad, 0xc8, 0x12, 0x52, 0xb8, 0xe8, 0x2a, 0x63, 0xcc,
1869 0xea, 0xe7, 0x4e, 0xc8, 0x34, 0x4c, 0x58, 0x59, 0x0a, 0xc2, 0x4a, 0xe4,
1870 0xb4, 0x64, 0x20, 0xf4, 0xf6, 0x0a, 0xcf, 0x86, 0x01, 0x6c, 0x7f, 0x23,
1871 0x4a, 0x51, 0x07, 0x99, 0x42, 0x28, 0x7a, 0xff, 0x18, 0x67, 0x52, 0x64,
1872 0xf2, 0x9a, 0x62, 0x30, 0xc3, 0x00, 0xde, 0x23, 0xe9, 0x11, 0x95, 0x7e,
1873 0xd1, 0x3d, 0x8d, 0xb4, 0x0e, 0x9f, 0x9e, 0xb1, 0x30, 0x03, 0xf0, 0x73,
1874 0xa8, 0x40, 0x48, 0x42, 0x7b, 0x60, 0xa0, 0xc4, 0xf2, 0x3b, 0x2d, 0x0a,
1875 0x0c, 0xb8, 0x19, 0xfb, 0xb4, 0xf8, 0xe0, 0x2a, 0xc7, 0xf1, 0xc0, 0xc6,
1876 0x86, 0x14, 0x60, 0x12, 0x0f, 0xc0, 0xde, 0x4a, 0x67, 0xec, 0xc7, 0xde,
1877 0x76, 0x21, 0x1a, 0x55, 0x7f, 0x86, 0xc3, 0x97, 0x98, 0xce, 0xf5, 0xcd,
1878 0xf0, 0xe7, 0x12, 0xd6, 0x93, 0xee, 0x1b, 0x9b, 0x61, 0xef, 0x05, 0x8c,
1879 0x45, 0x46, 0xd9, 0x64, 0x6f, 0xbe, 0x27, 0xaa, 0x67, 0x01, 0xcc, 0x71,
1880 0xb1, 0x60, 0xce, 0x21, 0xd8, 0x51, 0x17, 0x27, 0x0d, 0x90, 0x3d, 0x18,
1881 0x7c, 0x87, 0x15, 0x8e, 0x48, 0x4c, 0x6c, 0xc5, 0x72, 0xeb, 0xb7, 0x56,
1882 0xf5, 0x6b, 0x60, 0x8f, 0xc2, 0xfd, 0x3f, 0x46, 0x5c, 0x00, 0x91, 0x85,
1883 0x79, 0x45, 0x5b, 0x1c, 0x82, 0xc4, 0x87, 0x50, 0x79, 0xba, 0xcc, 0x1c,
1884 0x32, 0x7e, 0x2e, 0xb8, 0x2e, 0xc5, 0x4e, 0xd1, 0x9b, 0xdb, 0x66, 0x79,
1885 0x7c, 0xfe, 0xaf, 0x6a, 0x05
1886 };
1887 static const unsigned char q_data[] = {
1888 0xa8, 0xcd, 0xf4, 0x33, 0x7b, 0x13, 0x0a, 0x24, 0xc1, 0xde, 0x4a, 0x04,
1889 0x7b, 0x4b, 0x71, 0x51, 0x32, 0xe9, 0x47, 0x74, 0xbd, 0x0c, 0x21, 0x40,
1890 0x84, 0x12, 0x0a, 0x17, 0x73, 0xdb, 0x29, 0xc7
1891 };
1892 static const unsigned char g_data[] = {
1893 0x6c, 0xc6, 0xa4, 0x3e, 0x61, 0x84, 0xc1, 0xff, 0x6f, 0x4a, 0x1a, 0x6b,
1894 0xb0, 0x24, 0x4b, 0xd2, 0x92, 0x5b, 0x29, 0x5c, 0x61, 0xb8, 0xc9, 0x2b,
1895 0xd6, 0xf7, 0x59, 0xfd, 0xd8, 0x70, 0x66, 0x77, 0xfc, 0xc1, 0xa4, 0xd4,
1896 0xb0, 0x1e, 0xd5, 0xbf, 0x59, 0x98, 0xb3, 0x66, 0x8b, 0xf4, 0x2e, 0xe6,
1897 0x12, 0x3e, 0xcc, 0xf8, 0x02, 0xb8, 0xc6, 0xc3, 0x47, 0xd2, 0xf5, 0xaa,
1898 0x0c, 0x5f, 0x51, 0xf5, 0xd0, 0x4c, 0x55, 0x3d, 0x07, 0x73, 0xa6, 0x57,
1899 0xce, 0x5a, 0xad, 0x42, 0x0c, 0x13, 0x0f, 0xe2, 0x31, 0x25, 0x8e, 0x72,
1900 0x12, 0x73, 0x10, 0xdb, 0x7f, 0x79, 0xeb, 0x59, 0xfc, 0xfe, 0xf7, 0x0c,
1901 0x1a, 0x81, 0x53, 0x96, 0x22, 0xb8, 0xe7, 0x58, 0xd8, 0x67, 0x80, 0x60,
1902 0xad, 0x8b, 0x55, 0x1c, 0x91, 0xf0, 0x72, 0x9a, 0x7e, 0xad, 0x37, 0xf1,
1903 0x77, 0x18, 0x96, 0x8a, 0x68, 0x70, 0xfc, 0x71, 0xa9, 0xa2, 0xe8, 0x35,
1904 0x27, 0x78, 0xf2, 0xef, 0x59, 0x36, 0x6d, 0x7c, 0xb6, 0x98, 0xd8, 0x1e,
1905 0xfa, 0x25, 0x73, 0x97, 0x45, 0x58, 0xe3, 0xae, 0xbd, 0x52, 0x54, 0x05,
1906 0xd8, 0x26, 0x26, 0xba, 0xba, 0x05, 0xb5, 0xe9, 0xe5, 0x76, 0xae, 0x25,
1907 0xdd, 0xfc, 0x10, 0x89, 0x5a, 0xa9, 0xee, 0x59, 0xc5, 0x79, 0x8b, 0xeb,
1908 0x1e, 0x2c, 0x61, 0xab, 0x0d, 0xd1, 0x10, 0x04, 0x91, 0x32, 0x77, 0x4a,
1909 0xa6, 0x64, 0x53, 0xda, 0x4c, 0xd7, 0x3a, 0x29, 0xd4, 0xf3, 0x82, 0x25,
1910 0x1d, 0x6f, 0x4a, 0x7f, 0xd3, 0x08, 0x3b, 0x42, 0x30, 0x10, 0xd8, 0xd0,
1911 0x97, 0x3a, 0xeb, 0x92, 0x63, 0xec, 0x93, 0x2b, 0x6f, 0x32, 0xd8, 0xcd,
1912 0x80, 0xd3, 0xc0, 0x4c, 0x03, 0xd5, 0xca, 0xbc, 0x8f, 0xc7, 0x43, 0x53,
1913 0x64, 0x66, 0x1c, 0x82, 0x2d, 0xfb, 0xff, 0x39, 0xba, 0xd6, 0x42, 0x62,
1914 0x02, 0x6f, 0x96, 0x36
1915 };
1916 static const unsigned char seed_data[] = {
1917 0x64, 0x46, 0x07, 0x32, 0x8d, 0x70, 0x9c, 0xb3, 0x8a, 0x35, 0xde, 0x62,
1918 0x00, 0xf2, 0x6d, 0x52, 0x37, 0x4d, 0xb3, 0x84, 0xe1, 0x9d, 0x41, 0x04,
1919 0xda, 0x7b, 0xdc, 0x0d, 0x8b, 0x5e, 0xe0, 0x84
1920 };
1921 const int gindex = 1;
1922 const int pcounter = 53;
1923 /*
1924 * The keypair was generated using
1925 * openssl genpkey -paramfile dsa_params.pem --pkeyopt pcounter:53 \
1926 * -pkeyopt gindex:1 \
1927 * -pkeyopt hexseed:644607328d709cb38a35de6200f26d -text
1928 */
1929 static const unsigned char priv_data[] = {
1930 0x00, 0x8f, 0xc5, 0x9e, 0xd0, 0xf7, 0x2a, 0x0b, 0x66, 0xf1, 0x32, 0x73,
1931 0xae, 0xf6, 0xd9, 0xd4, 0xdb, 0x2d, 0x96, 0x55, 0x89, 0xff, 0xef, 0xa8,
1932 0x5f, 0x47, 0x8f, 0xca, 0x02, 0x8a, 0xe1, 0x35, 0x90
1933 };
1934 static const unsigned char pub_data[] = {
1935 0x44, 0x19, 0xc9, 0x46, 0x45, 0x57, 0xc1, 0xa9, 0xd8, 0x30, 0x99, 0x29,
1936 0x6a, 0x4b, 0x63, 0x71, 0x69, 0x96, 0x35, 0x17, 0xb2, 0x62, 0x9b, 0x80,
1937 0x0a, 0x95, 0x9d, 0x6a, 0xc0, 0x32, 0x0d, 0x07, 0x5f, 0x19, 0x44, 0x02,
1938 0xf1, 0xbd, 0xce, 0xdf, 0x10, 0xf8, 0x02, 0x5d, 0x7d, 0x98, 0x8a, 0x73,
1939 0x89, 0x00, 0xb6, 0x24, 0xd6, 0x33, 0xe7, 0xcf, 0x8b, 0x49, 0x2a, 0xaf,
1940 0x13, 0x1c, 0xb2, 0x52, 0x15, 0xfd, 0x9b, 0xd5, 0x40, 0x4a, 0x1a, 0xda,
1941 0x29, 0x4c, 0x92, 0x7e, 0x66, 0x06, 0xdb, 0x61, 0x86, 0xac, 0xb5, 0xda,
1942 0x3c, 0x7d, 0x73, 0x7e, 0x54, 0x32, 0x68, 0xa5, 0x02, 0xbc, 0x59, 0x47,
1943 0x84, 0xd3, 0x87, 0x71, 0x5f, 0xeb, 0x43, 0x45, 0x24, 0xd3, 0xec, 0x08,
1944 0x52, 0xc2, 0x89, 0x2d, 0x9c, 0x1a, 0xcc, 0x91, 0x65, 0x5d, 0xa3, 0xa1,
1945 0x35, 0x31, 0x10, 0x1c, 0x3a, 0xa8, 0x4d, 0x18, 0xd5, 0x06, 0xaf, 0xb2,
1946 0xec, 0x5c, 0x89, 0x9e, 0x90, 0x86, 0x10, 0x01, 0xeb, 0x51, 0xd5, 0x1b,
1947 0x9c, 0xcb, 0x66, 0x07, 0x3f, 0xc4, 0x6e, 0x0a, 0x1b, 0x73, 0xa0, 0x4b,
1948 0x5f, 0x4d, 0xab, 0x35, 0x28, 0xfa, 0xda, 0x3a, 0x0c, 0x08, 0xe8, 0xf3,
1949 0xef, 0x42, 0x67, 0xbc, 0x21, 0xf2, 0xc2, 0xb8, 0xff, 0x1a, 0x81, 0x05,
1950 0x68, 0x73, 0x62, 0xdf, 0xd7, 0xab, 0x0f, 0x22, 0x89, 0x57, 0x96, 0xd4,
1951 0x93, 0xaf, 0xa1, 0x21, 0xa3, 0x48, 0xe9, 0xf0, 0x97, 0x47, 0xa0, 0x27,
1952 0xba, 0x87, 0xb8, 0x15, 0x5f, 0xff, 0x2c, 0x50, 0x41, 0xf1, 0x7e, 0xc6,
1953 0x81, 0xc4, 0x51, 0xf1, 0xfd, 0xd6, 0x86, 0xf7, 0x69, 0x97, 0xf1, 0x49,
1954 0xc9, 0xf9, 0xf4, 0x9b, 0xf4, 0xe8, 0x85, 0xa7, 0xbd, 0x36, 0x55, 0x4a,
1955 0x3d, 0xe8, 0x65, 0x09, 0x7b, 0xb7, 0x12, 0x64, 0xd2, 0x0a, 0x53, 0x60,
1956 0x48, 0xd1, 0x8a, 0xbd
1957 };
1958
1959 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1960 || !TEST_ptr(pub = BN_bin2bn(pub_data, sizeof(pub_data), NULL))
1961 || !TEST_ptr(priv = BN_bin2bn(priv_data, sizeof(priv_data), NULL))
1962 || !TEST_ptr(p = BN_bin2bn(p_data, sizeof(p_data), NULL))
1963 || !TEST_ptr(q = BN_bin2bn(q_data, sizeof(q_data), NULL))
1964 || !TEST_ptr(g = BN_bin2bn(g_data, sizeof(g_data), NULL))
1965
1966 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
1967 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
1968 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
1969 || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1970 OSSL_PKEY_PARAM_FFC_SEED,
1971 seed_data,
1972 sizeof(seed_data)))
1973 || !TEST_true(OSSL_PARAM_BLD_push_int(bld, OSSL_PKEY_PARAM_FFC_GINDEX,
1974 gindex))
1975 || !TEST_true(OSSL_PARAM_BLD_push_int(bld,
1976 OSSL_PKEY_PARAM_FFC_PCOUNTER,
1977 pcounter))
1978 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
1979 pub))
1980 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
1981 priv))
1982 || !TEST_ptr(fromdata_params = OSSL_PARAM_BLD_to_param(bld)))
1983 goto err;
1984
1985 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL)))
1986 goto err;
1987
1988 if (!TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1989 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pk, EVP_PKEY_KEYPAIR,
1990 fromdata_params),
1991 1))
1992 goto err;
1993
1994 for (;;) {
1995 ret = 0;
1996 if (!TEST_int_eq(EVP_PKEY_get_bits(pk), 2048)
1997 || !TEST_int_eq(EVP_PKEY_get_security_bits(pk), 112)
1998 || !TEST_int_eq(EVP_PKEY_get_size(pk), 2 + 2 * (3 + sizeof(q_data)))
1999 || !TEST_false(EVP_PKEY_missing_parameters(pk)))
2000 goto err;
2001
2002 if (!TEST_false(EVP_PKEY_get_utf8_string_param(pk,
2003 OSSL_PKEY_PARAM_GROUP_NAME,
2004 name_out,
2005 sizeof(name_out),
2006 &len))
2007 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
2008 &pub_out))
2009 || !TEST_BN_eq(pub, pub_out)
2010 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_PRIV_KEY,
2011 &priv_out))
2012 || !TEST_BN_eq(priv, priv_out)
2013 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_P,
2014 &p_out))
2015 || !TEST_BN_eq(p, p_out)
2016 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_Q,
2017 &q_out))
2018 || !TEST_BN_eq(q, q_out)
2019 || !TEST_true(EVP_PKEY_get_bn_param(pk, OSSL_PKEY_PARAM_FFC_G,
2020 &g_out))
2021 || !TEST_BN_eq(g, g_out)
2022 || !TEST_false(EVP_PKEY_get_bn_param(pk,
2023 OSSL_PKEY_PARAM_FFC_COFACTOR,
2024 &j_out))
2025 || !TEST_ptr_null(j_out)
2026 || !TEST_true(EVP_PKEY_get_octet_string_param(pk,
2027 OSSL_PKEY_PARAM_FFC_SEED,
2028 seed_out,
2029 sizeof(seed_out),
2030 &len))
2031 || !TEST_true(EVP_PKEY_get_int_param(pk,
2032 OSSL_PKEY_PARAM_FFC_GINDEX,
2033 &gindex_out))
2034 || !TEST_int_eq(gindex, gindex_out)
2035 || !TEST_true(EVP_PKEY_get_int_param(pk, OSSL_PKEY_PARAM_FFC_H,
2036 &hindex_out))
2037 || !TEST_int_eq(hindex_out, 0)
2038 || !TEST_true(EVP_PKEY_get_int_param(pk,
2039 OSSL_PKEY_PARAM_FFC_PCOUNTER,
2040 &pcounter_out))
2041 || !TEST_int_eq(pcounter, pcounter_out))
2042 goto err;
2043 BN_free(p_out);
2044 p_out = NULL;
2045 BN_free(q_out);
2046 q_out = NULL;
2047 BN_free(g_out);
2048 g_out = NULL;
2049 BN_free(j_out);
2050 j_out = NULL;
2051 BN_free(pub_out);
2052 pub_out = NULL;
2053 BN_free(priv_out);
2054 priv_out = NULL;
2055
2056 if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
2057 goto err;
2058
2059 if (!TEST_int_gt(EVP_PKEY_check(key_ctx), 0)
2060 || !TEST_int_gt(EVP_PKEY_public_check(key_ctx), 0)
2061 || !TEST_int_gt(EVP_PKEY_private_check(key_ctx), 0)
2062 || !TEST_int_gt(EVP_PKEY_pairwise_check(key_ctx), 0))
2063 goto err;
2064 EVP_PKEY_CTX_free(key_ctx);
2065 key_ctx = NULL;
2066
2067 if (!TEST_ptr(copy_pk = EVP_PKEY_new())
2068 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk, pk)))
2069 goto err;
2070 EVP_PKEY_free(copy_pk);
2071 copy_pk = NULL;
2072
2073 ret = test_print_key_using_pem("DSA", pk)
2074 && test_print_key_using_encoder("DSA", pk);
2075
2076 if (!ret || dup_pk != NULL)
2077 break;
2078
2079 if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pk)))
2080 goto err;
2081 ret = ret && TEST_int_eq(EVP_PKEY_eq(pk, dup_pk), 1);
2082 EVP_PKEY_free(pk);
2083 pk = dup_pk;
2084 if (!ret)
2085 goto err;
2086 }
2087
2088 err:
2089 OSSL_PARAM_free(fromdata_params);
2090 OSSL_PARAM_BLD_free(bld);
2091 BN_free(p);
2092 BN_free(q);
2093 BN_free(g);
2094 BN_free(pub);
2095 BN_free(priv);
2096 BN_free(p_out);
2097 BN_free(q_out);
2098 BN_free(g_out);
2099 BN_free(pub_out);
2100 BN_free(priv_out);
2101 BN_free(j_out);
2102 EVP_PKEY_free(pk);
2103 EVP_PKEY_free(copy_pk);
2104 EVP_PKEY_CTX_free(ctx);
2105 EVP_PKEY_CTX_free(key_ctx);
2106
2107 return ret;
2108 }
2109
test_check_dsa(void)2110 static int test_check_dsa(void)
2111 {
2112 int ret = 0;
2113 EVP_PKEY_CTX *ctx = NULL;
2114
2115 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL))
2116 || !TEST_int_le(EVP_PKEY_check(ctx), 0)
2117 || !TEST_int_le(EVP_PKEY_public_check(ctx), 0)
2118 || !TEST_int_le(EVP_PKEY_private_check(ctx), 0)
2119 || !TEST_int_le(EVP_PKEY_pairwise_check(ctx), 0))
2120 goto err;
2121
2122 ret = 1;
2123 err:
2124 EVP_PKEY_CTX_free(ctx);
2125
2126 return ret;
2127 }
2128 #endif /* OPENSSL_NO_DSA */
2129
do_construct_hkdf_params(char * digest,char * key,size_t keylen,char * salt)2130 static OSSL_PARAM *do_construct_hkdf_params(char *digest, char *key,
2131 size_t keylen, char *salt)
2132 {
2133 OSSL_PARAM *params = OPENSSL_malloc(sizeof(OSSL_PARAM) * 5);
2134 OSSL_PARAM *p = params;
2135
2136 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, digest, 0);
2137 *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT,
2138 salt, strlen(salt));
2139 *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY,
2140 (unsigned char *)key, keylen);
2141 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_MODE,
2142 "EXTRACT_ONLY", 0);
2143 *p = OSSL_PARAM_construct_end();
2144
2145 return params;
2146 }
2147
test_evp_pkey_ctx_dup_kdf(void)2148 static int test_evp_pkey_ctx_dup_kdf(void)
2149 {
2150 int ret = 0;
2151 size_t len = 0, dlen = 0;
2152 EVP_PKEY_CTX *pctx = NULL, *dctx = NULL;
2153 OSSL_PARAM *params = NULL;
2154
2155 if (!TEST_ptr(params = do_construct_hkdf_params("sha256", "secret", 6,
2156 "salt")))
2157 goto err;
2158 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(NULL, "HKDF", NULL)))
2159 goto err;
2160 if (!TEST_int_eq(EVP_PKEY_derive_init_ex(pctx, params), 1))
2161 goto err;
2162 if (!TEST_ptr(dctx = EVP_PKEY_CTX_dup(pctx)))
2163 goto err;
2164 if (!TEST_int_eq(EVP_PKEY_derive(pctx, NULL, &len), 1)
2165 || !TEST_size_t_eq(len, SHA256_DIGEST_LENGTH)
2166 || !TEST_int_eq(EVP_PKEY_derive(dctx, NULL, &dlen), 1)
2167 || !TEST_size_t_eq(dlen, SHA256_DIGEST_LENGTH))
2168 goto err;
2169 ret = 1;
2170 err:
2171 OPENSSL_free(params);
2172 EVP_PKEY_CTX_free(dctx);
2173 EVP_PKEY_CTX_free(pctx);
2174 return ret;
2175 }
2176
2177 static const char *name_dup_algs[] = {
2178 #ifndef OPENSSL_NO_ECX
2179 "ED25519",
2180 #endif
2181 #ifndef OPENSSL_NO_ML_KEM
2182 "ML-KEM-512",
2183 #endif
2184 #ifndef OPENSSL_NO_ML_DSA
2185 "ML-DSA-44",
2186 #endif
2187 NULL
2188 };
2189
test_name_dup(int idx)2190 static int test_name_dup(int idx)
2191 {
2192 const char *alg = name_dup_algs[idx];
2193 EVP_PKEY *key = NULL;
2194 EVP_PKEY_CTX *factory = NULL, *ctx = NULL;
2195 int i, ret = 0;
2196
2197 if (alg == NULL
2198 || (factory = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL)) == NULL)
2199 return 1;
2200 TEST_info("Testing fresh context dup for: %s", alg);
2201
2202 /* Run twice to check that *repeated* use works */
2203 for (i = 0; i < 2; ++i) {
2204 EVP_PKEY_CTX_free(ctx);
2205 EVP_PKEY_free(key);
2206 key = NULL;
2207 if (!TEST_ptr(ctx = EVP_PKEY_CTX_dup(factory))
2208 || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
2209 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &key), 0)) {
2210 ERR_print_errors(bio_err);
2211 goto end;
2212 }
2213 }
2214 ret = 1;
2215
2216 end:
2217 EVP_PKEY_CTX_free(factory);
2218 EVP_PKEY_CTX_free(ctx);
2219 EVP_PKEY_free(key);
2220
2221 return ret;
2222 }
2223
setup_tests(void)2224 int setup_tests(void)
2225 {
2226 if (!test_skip_common_options()) {
2227 TEST_error("Error parsing test options\n");
2228 return 0;
2229 }
2230
2231 if (!TEST_ptr(datadir = test_get_argument(0)))
2232 return 0;
2233
2234 ADD_TEST(test_evp_pkey_ctx_dup_kdf);
2235 ADD_ALL_TESTS(test_name_dup, OSSL_NELEM(name_dup_algs));
2236 ADD_TEST(test_evp_pkey_get_bn_param_large);
2237 ADD_TEST(test_fromdata_rsa);
2238 ADD_TEST(test_fromdata_rsa_derive_from_pq_sp800);
2239 ADD_TEST(test_fromdata_rsa_derive_from_pq_multiprime);
2240 #ifndef OPENSSL_NO_DH
2241 ADD_TEST(test_fromdata_dh_fips186_4);
2242 ADD_TEST(test_fromdata_dh_named_group);
2243 #endif
2244 #ifndef OPENSSL_NO_DSA
2245 ADD_TEST(test_check_dsa);
2246 ADD_TEST(test_fromdata_dsa_fips186_4);
2247 #endif
2248 #ifndef OPENSSL_NO_EC
2249 #ifndef OPENSSL_NO_ECX
2250 ADD_ALL_TESTS(test_fromdata_ecx, 4 * 3);
2251 #endif
2252 ADD_TEST(test_fromdata_ec);
2253 ADD_TEST(test_ec_dup_no_operation);
2254 ADD_TEST(test_ec_dup_keygen_operation);
2255 #endif
2256 return 1;
2257 }
2258