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