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