2 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
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
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/params.h>
16 #include <openssl/core_names.h>
17 #include "crypto/ecx.h"
18 #include "internal/nelem.h"
19 #include "openssl/param_build.h"
20 #include "crypto/evp.h" /* For the internal API */
23 static char *datadir
= NULL
;
32 static void stripcr(char *buf
, size_t *len
)
37 for (i
= *len
, curr
= buf
, writ
= buf
; i
> 0; i
--, curr
++) {
48 static int compare_with_file(const char *alg
, int type
, BIO
*membio
)
53 char *memdata
, *fullfile
= NULL
;
86 TEST_error("Invalid file type");
90 BIO_snprintf(filename
, sizeof(filename
), "%s.%s", alg
, suffix
);
91 fullfile
= test_mk_file_path(datadir
, filename
);
92 if (!TEST_ptr(fullfile
))
95 file
= BIO_new_file(fullfile
, "rb");
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
)))
104 len
= BIO_get_mem_data(membio
, &memdata
);
105 if (!TEST_int_gt(len
, 0))
109 if (type
!= PRIV_DER
&& type
!= PUB_DER
) {
110 stripcr(memdata
, &slen
);
111 stripcr(buf
, &readbytes
);
114 if (!TEST_mem_eq(memdata
, slen
, buf
, readbytes
))
119 OPENSSL_free(fullfile
);
120 (void)BIO_reset(membio
);
125 static int test_print_key_using_pem(const char *alg
, const EVP_PKEY
*pk
)
127 BIO
*membio
= BIO_new(BIO_s_mem());
130 if (!TEST_ptr(membio
))
133 if (!TEST_true(EVP_PKEY_print_private(membio
, pk
, 0, NULL
))
134 || !TEST_true(compare_with_file(alg
, PRIV_TEXT
, membio
))
135 /* Public key in PEM form */
136 || !TEST_true(PEM_write_bio_PUBKEY(membio
, pk
))
137 || !TEST_true(compare_with_file(alg
, PUB_PEM
, membio
))
138 /* Unencrypted private key in PEM form */
139 || !TEST_true(PEM_write_bio_PrivateKey(membio
, pk
,
140 NULL
, NULL
, 0, NULL
, NULL
))
141 || !TEST_true(compare_with_file(alg
, PRIV_PEM
, membio
))
142 /* Encrypted private key in PEM form */
143 || !TEST_true(PEM_write_bio_PrivateKey(bio_out
, pk
, EVP_aes_256_cbc(),
144 (unsigned char *)"pass", 4,
154 static int test_print_key_type_using_serializer(const char *alg
, int type
,
158 OSSL_SERIALIZER_CTX
*ctx
= NULL
;
159 BIO
*membio
= BIO_new(BIO_s_mem());
164 pq
= OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ
;
168 pq
= OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ
;
172 pq
= OSSL_SERIALIZER_PrivateKey_TO_DER_PQ
;
176 pq
= OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ
;
180 pq
= OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ
;
184 pq
= OSSL_SERIALIZER_PUBKEY_TO_DER_PQ
;
188 TEST_error("Invalid serialization type");
192 if (!TEST_ptr(membio
))
195 /* Make a context, it's valid for several prints */
196 TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
197 if (!TEST_ptr(ctx
= OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk
, pq
))
198 /* Check that this operation is supported */
199 || !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx
)))
202 /* Use no cipher. This should give us an unencrypted PEM */
203 TEST_note("Testing with no encryption");
204 if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx
, membio
))
205 || !TEST_true(compare_with_file(alg
, type
, membio
)))
208 if (type
== PRIV_PEM
) {
209 /* Set a passphrase to be used later */
210 if (!TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx
,
211 (unsigned char *)"pass",
215 /* Use a valid cipher name */
216 TEST_note("Displaying PEM encrypted with AES-256-CBC");
217 if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx
, "AES-256-CBC", NULL
))
218 || !TEST_true(OSSL_SERIALIZER_to_bio(ctx
, bio_out
)))
221 /* Use an invalid cipher name, which should generate no output */
222 TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
223 if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx
, "FOO", NULL
))
224 || !TEST_false(OSSL_SERIALIZER_to_bio(ctx
, bio_out
)))
227 /* Clear the cipher. This should give us an unencrypted PEM again */
228 TEST_note("Testing with encryption cleared (no encryption)");
229 if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx
, NULL
, NULL
))
230 || !TEST_true(OSSL_SERIALIZER_to_bio(ctx
, membio
))
231 || !TEST_true(compare_with_file(alg
, type
, membio
)))
237 OSSL_SERIALIZER_CTX_free(ctx
);
241 static int test_print_key_using_serializer(const char *alg
, const EVP_PKEY
*pk
)
246 for (i
= 0; i
< 6; i
++)
247 ret
= ret
&& test_print_key_type_using_serializer(alg
, i
, pk
);
252 /* Array indexes used in test_fromdata_rsa */
262 static int test_fromdata_rsa(void)
265 EVP_PKEY_CTX
*ctx
= NULL
, *key_ctx
= NULL
;
266 EVP_PKEY
*pk
= NULL
, *copy_pk
= NULL
;
268 * 32-bit RSA key, extracted from this command,
269 * executed with OpenSSL 1.0.2:
271 * openssl genrsa 32 | openssl rsa -text
273 static unsigned long key_numbers
[] = {
283 OSSL_PARAM fromdata_params
[] = {
284 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N
, &key_numbers
[N
]),
285 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E
, &key_numbers
[E
]),
286 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D
, &key_numbers
[D
]),
287 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR1
, &key_numbers
[P
]),
288 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR2
, &key_numbers
[Q
]),
289 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT1
, &key_numbers
[DP
]),
290 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT2
, &key_numbers
[DQ
]),
291 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT1
, &key_numbers
[QINV
]),
294 BIGNUM
*bn
= BN_new();
295 BIGNUM
*bn_from
= BN_new();
297 if (!TEST_ptr(ctx
= EVP_PKEY_CTX_new_from_name(NULL
, "RSA", NULL
)))
300 if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx
))
301 || !TEST_true(EVP_PKEY_fromdata(ctx
, &pk
, fromdata_params
))
302 || !TEST_int_eq(EVP_PKEY_bits(pk
), 32)
303 || !TEST_int_eq(EVP_PKEY_security_bits(pk
), 8)
304 || !TEST_int_eq(EVP_PKEY_size(pk
), 4))
307 if (!TEST_ptr(key_ctx
= EVP_PKEY_CTX_new_from_pkey(NULL
, pk
, "")))
310 if (!TEST_true(EVP_PKEY_check(key_ctx
))
311 || !TEST_true(EVP_PKEY_public_check(key_ctx
))
312 || !TEST_true(EVP_PKEY_private_check(key_ctx
))
313 || !TEST_true(EVP_PKEY_pairwise_check(key_ctx
)))
316 /* EVP_PKEY_copy_parameters() should fail for RSA */
317 if (!TEST_ptr(copy_pk
= EVP_PKEY_new())
318 || !TEST_false(EVP_PKEY_copy_parameters(copy_pk
, pk
)))
321 for (i
= 0; fromdata_params
[i
].key
!= NULL
; ++i
) {
322 if (!TEST_true(BN_set_word(bn_from
, key_numbers
[i
]))
323 || !TEST_true(EVP_PKEY_get_bn_param(pk
, fromdata_params
[i
].key
, &bn
))
324 || !TEST_BN_eq(bn
, bn_from
))
327 ret
= test_print_key_using_pem("RSA", pk
)
328 && test_print_key_using_serializer("RSA", pk
);
333 EVP_PKEY_free(copy_pk
);
334 EVP_PKEY_CTX_free(key_ctx
);
335 EVP_PKEY_CTX_free(ctx
);
340 static int test_evp_pkey_get_bn_param_large(void)
343 EVP_PKEY_CTX
*ctx
= NULL
, *key_ctx
= NULL
;
345 OSSL_PARAM_BLD
*bld
= NULL
;
346 OSSL_PARAM
*fromdata_params
= NULL
;
347 BIGNUM
*n
= NULL
, *e
= NULL
, *d
= NULL
, *n_out
= NULL
;
349 * The buffer size chosen here for n_data larger than the buffer used
350 * internally in EVP_PKEY_get_bn_param.
352 static unsigned char n_data
[2050];
353 static const unsigned char e_data
[] = {
356 static const unsigned char d_data
[]= {
357 0x99, 0x33, 0x13, 0x7b
360 /* N is a large buffer */
361 memset(n_data
, 0xCE, sizeof(n_data
));
363 if (!TEST_ptr(bld
= OSSL_PARAM_BLD_new())
364 || !TEST_ptr(n
= BN_bin2bn(n_data
, sizeof(n_data
), NULL
))
365 || !TEST_ptr(e
= BN_bin2bn(e_data
, sizeof(e_data
), NULL
))
366 || !TEST_ptr(d
= BN_bin2bn(d_data
, sizeof(d_data
), NULL
))
367 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld
, OSSL_PKEY_PARAM_RSA_N
, n
))
368 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld
, OSSL_PKEY_PARAM_RSA_E
, e
))
369 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld
, OSSL_PKEY_PARAM_RSA_D
, d
))
370 || !TEST_ptr(fromdata_params
= OSSL_PARAM_BLD_to_param(bld
))
371 || !TEST_ptr(ctx
= EVP_PKEY_CTX_new_from_name(NULL
, "RSA", NULL
))
372 || !TEST_true(EVP_PKEY_key_fromdata_init(ctx
))
373 || !TEST_true(EVP_PKEY_fromdata(ctx
, &pk
, fromdata_params
))
374 || !TEST_ptr(key_ctx
= EVP_PKEY_CTX_new_from_pkey(NULL
, pk
, ""))
375 || !TEST_true(EVP_PKEY_get_bn_param(pk
, OSSL_PKEY_PARAM_RSA_N
, &n_out
))
376 || !TEST_BN_eq(n
, n_out
))
385 EVP_PKEY_CTX_free(key_ctx
);
386 EVP_PKEY_CTX_free(ctx
);
387 OSSL_PARAM_BLD_free_params(fromdata_params
);
388 OSSL_PARAM_BLD_free(bld
);
393 #ifndef OPENSSL_NO_DH
394 /* Array indexes used in test_fromdata_dh */
400 static int test_fromdata_dh(void)
403 EVP_PKEY_CTX
*ctx
= NULL
, *key_ctx
= NULL
;
404 EVP_PKEY
*pk
= NULL
, *copy_pk
= NULL
;
406 * 32-bit DH key, extracted from this command,
407 * executed with OpenSSL 1.0.2:
409 * openssl dhparam -out dhp.pem 32
410 * openssl genpkey -paramfile dhp.pem | openssl pkey -text
412 static unsigned long key_numbers
[] = {
413 0x666c2b06, /* priv-key */
414 0x6fa6de50, /* pub-key */
418 OSSL_PARAM fromdata_params
[] = {
419 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PRIV_KEY
, &key_numbers
[PRIV_KEY
]),
420 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PUB_KEY
, &key_numbers
[PUB_KEY
]),
421 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_P
, &key_numbers
[FFC_P
]),
422 OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_G
, &key_numbers
[FFC_G
]),
426 if (!TEST_ptr(ctx
= EVP_PKEY_CTX_new_from_name(NULL
, "DH", NULL
)))
429 if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx
))
430 || !TEST_true(EVP_PKEY_fromdata(ctx
, &pk
, fromdata_params
))
431 || !TEST_int_eq(EVP_PKEY_bits(pk
), 32)
432 || !TEST_int_eq(EVP_PKEY_security_bits(pk
), 0) /* Missing Q */
433 || !TEST_int_eq(EVP_PKEY_size(pk
), 4))
436 if (!TEST_ptr(copy_pk
= EVP_PKEY_new())
437 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk
, pk
)))
440 ret
= test_print_key_using_pem("DH", pk
)
441 && test_print_key_using_serializer("DH", pk
);
443 if (!TEST_ptr(key_ctx
= EVP_PKEY_CTX_new_from_pkey(NULL
, pk
, "")))
446 if (!TEST_false(EVP_PKEY_check(key_ctx
))
447 || !TEST_true(EVP_PKEY_public_check(key_ctx
))
448 || !TEST_false(EVP_PKEY_private_check(key_ctx
)) /* Need a q */
449 || !TEST_true(EVP_PKEY_pairwise_check(key_ctx
)))
454 EVP_PKEY_free(copy_pk
);
455 EVP_PKEY_CTX_free(ctx
);
456 EVP_PKEY_CTX_free(key_ctx
);
462 #ifndef OPENSSL_NO_EC
463 /* Array indexes used in test_fromdata_ecx */
467 # define X25519_IDX 0
469 # define ED25519_IDX 2
472 static int test_fromdata_ecx(int tst
)
475 EVP_PKEY_CTX
*ctx
= NULL
;
476 EVP_PKEY
*pk
= NULL
, *copy_pk
= NULL
;
477 const char *alg
= NULL
;
479 unsigned char out_pub
[ED448_KEYLEN
];
480 unsigned char out_priv
[ED448_KEYLEN
];
482 /* ED448_KEYLEN > X448_KEYLEN > X25519_KEYLEN == ED25519_KEYLEN */
483 static unsigned char key_numbers
[4][2][ED448_KEYLEN
] = {
484 /* X25519: Keys from RFC 7748 6.1 */
488 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
489 0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
490 0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
495 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
496 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
497 0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
501 /* X448: Keys from RFC 7748 6.2 */
505 0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
506 0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
507 0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
508 0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
509 0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
510 0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
514 0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
515 0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
516 0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
517 0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
518 0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
519 0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
522 /* ED25519: Keys from RFC 8032 */
526 0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84,
527 0x4a, 0xf4, 0x92, 0xec, 0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69,
528 0x7b, 0x32, 0x69, 0x19, 0x70, 0x3b, 0xac, 0x03, 0x1c, 0xae,
533 0xd7, 0x5a, 0x98, 0x01, 0x82, 0xb1, 0x0a, 0xb7, 0xd5, 0x4b,
534 0xfe, 0xd3, 0xc9, 0x64, 0x07, 0x3a, 0x0e, 0xe1, 0x72, 0xf3,
535 0xda, 0xa6, 0x23, 0x25, 0xaf, 0x02, 0x1a, 0x68, 0xf7, 0x07,
539 /* ED448: Keys from RFC 8032 */
543 0x6c, 0x82, 0xa5, 0x62, 0xcb, 0x80, 0x8d, 0x10, 0xd6, 0x32,
544 0xbe, 0x89, 0xc8, 0x51, 0x3e, 0xbf, 0x6c, 0x92, 0x9f, 0x34,
545 0xdd, 0xfa, 0x8c, 0x9f, 0x63, 0xc9, 0x96, 0x0e, 0xf6, 0xe3,
546 0x48, 0xa3, 0x52, 0x8c, 0x8a, 0x3f, 0xcc, 0x2f, 0x04, 0x4e,
547 0x39, 0xa3, 0xfc, 0x5b, 0x94, 0x49, 0x2f, 0x8f, 0x03, 0x2e,
548 0x75, 0x49, 0xa2, 0x00, 0x98, 0xf9, 0x5b
552 0x5f, 0xd7, 0x44, 0x9b, 0x59, 0xb4, 0x61, 0xfd, 0x2c, 0xe7,
553 0x87, 0xec, 0x61, 0x6a, 0xd4, 0x6a, 0x1d, 0xa1, 0x34, 0x24,
554 0x85, 0xa7, 0x0e, 0x1f, 0x8a, 0x0e, 0xa7, 0x5d, 0x80, 0xe9,
555 0x67, 0x78, 0xed, 0xf1, 0x24, 0x76, 0x9b, 0x46, 0xc7, 0x06,
556 0x1b, 0xd6, 0x78, 0x3d, 0xf1, 0xe5, 0x0f, 0x6c, 0xd1, 0xfa,
557 0x1a, 0xbe, 0xaf, 0xe8, 0x25, 0x61, 0x80
561 OSSL_PARAM x25519_fromdata_params
[] = {
562 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY
,
563 key_numbers
[X25519_IDX
][PRIV_KEY
],
565 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY
,
566 key_numbers
[X25519_IDX
][PUB_KEY
],
570 OSSL_PARAM x448_fromdata_params
[] = {
571 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY
,
572 key_numbers
[X448_IDX
][PRIV_KEY
],
574 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY
,
575 key_numbers
[X448_IDX
][PUB_KEY
],
579 OSSL_PARAM ed25519_fromdata_params
[] = {
580 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY
,
581 key_numbers
[ED25519_IDX
][PRIV_KEY
],
583 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY
,
584 key_numbers
[ED25519_IDX
][PUB_KEY
],
588 OSSL_PARAM ed448_fromdata_params
[] = {
589 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY
,
590 key_numbers
[ED448_IDX
][PRIV_KEY
],
592 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY
,
593 key_numbers
[ED448_IDX
][PUB_KEY
],
597 OSSL_PARAM
*fromdata_params
= NULL
;
598 int bits
= 0, security_bits
= 0, size
= 0;
602 fromdata_params
= x25519_fromdata_params
;
604 security_bits
= X25519_SECURITY_BITS
;
605 size
= X25519_KEYLEN
;
610 fromdata_params
= x448_fromdata_params
;
612 security_bits
= X448_SECURITY_BITS
;
618 fromdata_params
= ed25519_fromdata_params
;
620 security_bits
= ED25519_SECURITY_BITS
;
621 size
= ED25519_KEYLEN
;
626 fromdata_params
= ed448_fromdata_params
;
628 security_bits
= ED448_SECURITY_BITS
;
634 ctx
= EVP_PKEY_CTX_new_from_name(NULL
, alg
, NULL
);
638 if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx
))
639 || !TEST_true(EVP_PKEY_fromdata(ctx
, &pk
, fromdata_params
))
640 || !TEST_int_eq(EVP_PKEY_bits(pk
), bits
)
641 || !TEST_int_eq(EVP_PKEY_security_bits(pk
), security_bits
)
642 || !TEST_int_eq(EVP_PKEY_size(pk
), size
))
645 if (!TEST_ptr(copy_pk
= EVP_PKEY_new())
646 || !TEST_false(EVP_PKEY_copy_parameters(copy_pk
, pk
)))
649 if (!TEST_true(EVP_PKEY_get_octet_string_param(
650 pk
, fromdata_params
[PRIV_KEY
].key
,
651 out_priv
, sizeof(out_priv
), &len
))
652 || !TEST_mem_eq(out_priv
, len
,
653 fromdata_params
[PRIV_KEY
].data
,
654 fromdata_params
[PRIV_KEY
].data_size
)
655 || !TEST_true(EVP_PKEY_get_octet_string_param(
656 pk
, fromdata_params
[PUB_KEY
].key
,
657 out_pub
, sizeof(out_pub
), &len
))
658 || !TEST_mem_eq(out_pub
, len
,
659 fromdata_params
[PUB_KEY
].data
,
660 fromdata_params
[PUB_KEY
].data_size
))
663 ret
= test_print_key_using_pem(alg
, pk
)
664 && test_print_key_using_serializer(alg
, pk
);
668 EVP_PKEY_free(copy_pk
);
669 EVP_PKEY_CTX_free(ctx
);
676 static int test_fromdata_ec(void)
679 EVP_PKEY_CTX
*ctx
= NULL
;
680 EVP_PKEY
*pk
= NULL
, *copy_pk
= NULL
;
681 OSSL_PARAM_BLD
*bld
= OSSL_PARAM_BLD_new();
682 BIGNUM
*ec_priv_bn
= NULL
;
683 BIGNUM
*bn_priv
= NULL
;
684 OSSL_PARAM
*fromdata_params
= NULL
;
685 const char *alg
= "EC";
686 const char *curve
= "prime256v1";
687 /* UNCOMPRESSED FORMAT */
688 static const unsigned char ec_pub_keydata
[] = {
689 POINT_CONVERSION_UNCOMPRESSED
,
690 0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
691 0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
692 0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
693 0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
694 0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
695 0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
696 0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
697 0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
699 static const unsigned char ec_priv_keydata
[] = {
700 0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
701 0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
702 0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
703 0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
705 const int compressed_sz
= 1 + (sizeof(ec_pub_keydata
) - 1) / 2;
706 unsigned char out_pub
[sizeof(ec_pub_keydata
)];
707 char out_curve_name
[80];
708 const OSSL_PARAM
*gettable
= NULL
;
714 if (!TEST_ptr(ec_priv_bn
= BN_bin2bn(ec_priv_keydata
,
715 sizeof(ec_priv_keydata
), NULL
)))
718 if (OSSL_PARAM_BLD_push_utf8_string(bld
, OSSL_PKEY_PARAM_EC_NAME
,
721 if (OSSL_PARAM_BLD_push_octet_string(bld
, OSSL_PKEY_PARAM_PUB_KEY
,
723 sizeof(ec_pub_keydata
)) <= 0)
725 if (OSSL_PARAM_BLD_push_BN(bld
, OSSL_PKEY_PARAM_PRIV_KEY
, ec_priv_bn
) <= 0)
727 if (!TEST_ptr(fromdata_params
= OSSL_PARAM_BLD_to_param(bld
)))
729 ctx
= EVP_PKEY_CTX_new_from_name(NULL
, alg
, NULL
);
733 if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx
))
734 || !TEST_true(EVP_PKEY_fromdata(ctx
, &pk
, fromdata_params
))
735 || !TEST_int_eq(EVP_PKEY_bits(pk
), 256)
736 || !TEST_int_eq(EVP_PKEY_security_bits(pk
), 128)
737 || !TEST_int_eq(EVP_PKEY_size(pk
), 2 + 35 * 2))
740 if (!TEST_ptr(copy_pk
= EVP_PKEY_new())
741 || !TEST_true(EVP_PKEY_copy_parameters(copy_pk
, pk
)))
744 if (!TEST_ptr(gettable
= EVP_PKEY_gettable_params(pk
))
745 || !TEST_ptr(OSSL_PARAM_locate_const(gettable
, OSSL_PKEY_PARAM_EC_NAME
))
746 || !TEST_ptr(OSSL_PARAM_locate_const(gettable
, OSSL_PKEY_PARAM_PUB_KEY
))
747 || !TEST_ptr(OSSL_PARAM_locate_const(gettable
, OSSL_PKEY_PARAM_PRIV_KEY
)))
750 if (!EVP_PKEY_get_utf8_string_param(pk
, OSSL_PKEY_PARAM_EC_NAME
,
751 out_curve_name
, sizeof(out_curve_name
),
753 || !TEST_str_eq(out_curve_name
, curve
)
754 || !EVP_PKEY_get_octet_string_param(pk
, OSSL_PKEY_PARAM_PUB_KEY
,
755 out_pub
, sizeof(out_pub
), &len
)
756 || !TEST_true(out_pub
[0] == (POINT_CONVERSION_COMPRESSED
+ 1))
757 || !TEST_mem_eq(out_pub
+ 1, len
- 1,
758 ec_pub_keydata
+ 1, compressed_sz
- 1)
759 || !TEST_true(EVP_PKEY_get_bn_param(pk
, OSSL_PKEY_PARAM_PRIV_KEY
,
761 || !TEST_BN_eq(ec_priv_bn
, bn_priv
))
764 ret
= test_print_key_using_pem(alg
, pk
)
765 && test_print_key_using_serializer(alg
, pk
);
769 OSSL_PARAM_BLD_free_params(fromdata_params
);
770 OSSL_PARAM_BLD_free(bld
);
772 EVP_PKEY_free(copy_pk
);
773 EVP_PKEY_CTX_free(ctx
);
777 #endif /* OPENSSL_NO_EC */
779 int setup_tests(void)
781 if (!test_skip_common_options()) {
782 TEST_error("Error parsing test options\n");
786 if (!TEST_ptr(datadir
= test_get_argument(0)))
789 ADD_TEST(test_evp_pkey_get_bn_param_large
);
790 ADD_TEST(test_fromdata_rsa
);
791 #ifndef OPENSSL_NO_DH
792 ADD_TEST(test_fromdata_dh
);
794 #ifndef OPENSSL_NO_EC
795 ADD_ALL_TESTS(test_fromdata_ecx
, 4);
796 ADD_TEST(test_fromdata_ec
);