endecode_test.c@ 100832

Last change on this file since 100832 was 99366, checked in by vboxsync, 23 months ago
openssl-3.1.0: Applied and adjusted our OpenSSL changes to 3.0.7. bugref:10418
File size: 57.5 KB

Line
1	/*
2	* Copyright 2020-2022 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>
11	#include <openssl/core_dispatch.h>
12	#include <openssl/evp.h>
13	#include <openssl/pem.h>
14	#include <openssl/rsa.h>
15	#include <openssl/x509.h>
16	#include <openssl/core_names.h>
17	#include <openssl/params.h>
18	#include <openssl/param_build.h>
19	#include <openssl/encoder.h>
20	#include <openssl/decoder.h>
21
22	#include "internal/cryptlib.h" /* ossl_assert */
23	#include "crypto/pem.h" /* For PVK and "blob" PEM headers */
24	#include "crypto/evp.h" /* For evp_pkey_is_provided() */
25
26	#include "helpers/predefined_dhparams.h"
27	#include "testutil.h"
28
29	#ifdef STATIC_LEGACY
30	OSSL_provider_init_fn ossl_legacy_provider_init;
31	#endif
32
33	/* Extended test macros to allow passing file & line number */
34	#define TEST_FL_ptr(a) test_ptr(file, line, #a, a)
35	#define TEST_FL_mem_eq(a, m, b, n) test_mem_eq(file, line, #a, #b, a, m, b, n)
36	#define TEST_FL_strn_eq(a, b, n) test_strn_eq(file, line, #a, #b, a, n, b, n)
37	#define TEST_FL_strn2_eq(a, m, b, n) test_strn_eq(file, line, #a, #b, a, m, b, n)
38	#define TEST_FL_int_eq(a, b) test_int_eq(file, line, #a, #b, a, b)
39	#define TEST_FL_int_ge(a, b) test_int_ge(file, line, #a, #b, a, b)
40	#define TEST_FL_int_gt(a, b) test_int_gt(file, line, #a, #b, a, b)
41	#define TEST_FL_long_gt(a, b) test_long_gt(file, line, #a, #b, a, b)
42	#define TEST_FL_true(a) test_true(file, line, #a, (a) != 0)
43
44	#if defined(OPENSSL_NO_DH) && defined(OPENSSL_NO_DSA) && defined(OPENSSL_NO_EC)
45	# define OPENSSL_NO_KEYPARAMS
46	#endif
47
48	static int default_libctx = 1;
49	static int is_fips = 0;
50	static int is_fips_3_0_0 = 0;
51
52	static OSSL_LIB_CTX *testctx = NULL;
53	static OSSL_LIB_CTX *keyctx = NULL;
54	static char *testpropq = NULL;
55
56	static OSSL_PROVIDER *nullprov = NULL;
57	static OSSL_PROVIDER *deflprov = NULL;
58	static OSSL_PROVIDER *keyprov = NULL;
59
60	#ifndef OPENSSL_NO_EC
61	static BN_CTX *bnctx = NULL;
62	static OSSL_PARAM_BLD *bld_prime_nc = NULL;
63	static OSSL_PARAM_BLD *bld_prime = NULL;
64	static OSSL_PARAM *ec_explicit_prime_params_nc = NULL;
65	static OSSL_PARAM *ec_explicit_prime_params_explicit = NULL;
66
67	# ifndef OPENSSL_NO_EC2M
68	static OSSL_PARAM_BLD *bld_tri_nc = NULL;
69	static OSSL_PARAM_BLD *bld_tri = NULL;
70	static OSSL_PARAM *ec_explicit_tri_params_nc = NULL;
71	static OSSL_PARAM *ec_explicit_tri_params_explicit = NULL;
72	# endif
73	#endif
74
75	#ifndef OPENSSL_NO_KEYPARAMS
76	static EVP_PKEY make_template(const char type, OSSL_PARAM *genparams)
77	{
78	EVP_PKEY *pkey = NULL;
79	EVP_PKEY_CTX *ctx = NULL;
80
81	# ifndef OPENSSL_NO_DH
82	/*
83	* Use 512-bit DH(X) keys with predetermined parameters for efficiency,
84	* for testing only. Use a minimum key size of 2048 for security purposes.
85	*/
86	if (strcmp(type, "DH") == 0)
87	return get_dh512(keyctx);
88
89	if (strcmp(type, "X9.42 DH") == 0)
90	return get_dhx512(keyctx);
91	# endif
92
93	/*
94	* No real need to check the errors other than for the cascade
95	* effect. \|pkey\| will simply remain NULL if something goes wrong.
96	*/
97	(void)((ctx = EVP_PKEY_CTX_new_from_name(keyctx, type, testpropq)) != NULL
98	&& EVP_PKEY_paramgen_init(ctx) > 0
99	&& (genparams == NULL
100	\|\| EVP_PKEY_CTX_set_params(ctx, genparams) > 0)
101	&& EVP_PKEY_generate(ctx, &pkey) > 0);
102	EVP_PKEY_CTX_free(ctx);
103
104	return pkey;
105	}
106	#endif
107
108	#if !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_DSA) \|\| !defined(OPENSSL_NO_EC)
109	static EVP_PKEY make_key(const char type, EVP_PKEY *template,
110	OSSL_PARAM *genparams)
111	{
112	EVP_PKEY *pkey = NULL;
113	EVP_PKEY_CTX *ctx =
114	template != NULL
115	? EVP_PKEY_CTX_new_from_pkey(keyctx, template, testpropq)
116	: EVP_PKEY_CTX_new_from_name(keyctx, type, testpropq);
117
118	/*
119	* No real need to check the errors other than for the cascade
120	* effect. \|pkey\| will simply remain NULL if something goes wrong.
121	*/
122	(void)(ctx != NULL
123	&& EVP_PKEY_keygen_init(ctx) > 0
124	&& (genparams == NULL
125	\|\| EVP_PKEY_CTX_set_params(ctx, genparams) > 0)
126	&& EVP_PKEY_keygen(ctx, &pkey) > 0);
127	EVP_PKEY_CTX_free(ctx);
128	return pkey;
129	}
130	#endif
131
132	/* Main test driver */
133
134	typedef int (encoder)(const char *file, const int line,
135	void *encoded, long encoded_len,
136	void *object, int selection,
137	const char output_type, const char output_structure,
138	const char pass, const char pcipher);
139	typedef int (decoder)(const char *file, const int line,
140	void *object, void encoded, long encoded_len,
141	const char input_type, const char structure_type,
142	const char keytype, int selection, const char pass);
143	typedef int (tester)(const char *file, const int line,
144	const void *data1, size_t data1_len,
145	const void *data2, size_t data2_len);
146	typedef int (checker)(const char *file, const int line,
147	const char type, const void data, size_t data_len);
148	typedef void (dumper)(const char label, const void data, size_t data_len);
149
150	#define FLAG_DECODE_WITH_TYPE 0x0001
151	#define FLAG_FAIL_IF_FIPS 0x0002
152
153	static int test_encode_decode(const char *file, const int line,
154	const char type, EVP_PKEY pkey,
155	int selection, const char *output_type,
156	const char *output_structure,
157	const char pass, const char pcipher,
158	encoder encode_cb, decoder decode_cb,
159	tester test_cb, checker check_cb,
160	dumper *dump_cb, int flags)
161	{
162	void *encoded = NULL;
163	long encoded_len = 0;
164	EVP_PKEY *pkey2 = NULL;
165	void *encoded2 = NULL;
166	long encoded2_len = 0;
167	int ok = 0;
168
169	/*
170	* Encode \|pkey\|, decode the result into \|pkey2\|, and finish off by
171	* encoding \|pkey2\| as well. That last encoding is for checking and
172	* dumping purposes.
173	*/
174	if (!TEST_true(encode_cb(file, line, &encoded, &encoded_len, pkey, selection,
175	output_type, output_structure, pass, pcipher)))
176	goto end;
177
178	if ((flags & FLAG_FAIL_IF_FIPS) != 0 && is_fips && !is_fips_3_0_0) {
179	if (TEST_false(decode_cb(file, line, (void **)&pkey2, encoded,
180	encoded_len, output_type, output_structure,
181	(flags & FLAG_DECODE_WITH_TYPE ? type : NULL),
182	selection, pass)))
183	ok = 1;
184	goto end;
185	}
186
187	if (!TEST_true(check_cb(file, line, type, encoded, encoded_len))
188	\|\| !TEST_true(decode_cb(file, line, (void **)&pkey2, encoded, encoded_len,
189	output_type, output_structure,
190	(flags & FLAG_DECODE_WITH_TYPE ? type : NULL),
191	selection, pass))
192	\|\| !TEST_true(encode_cb(file, line, &encoded2, &encoded2_len, pkey2, selection,
193	output_type, output_structure, pass, pcipher)))
194	goto end;
195
196	if (selection == OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) {
197	if (!TEST_int_eq(EVP_PKEY_parameters_eq(pkey, pkey2), 1))
198	goto end;
199	} else {
200	if (!TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 1))
201	goto end;
202	}
203
204	/*
205	* Double check the encoding, but only for unprotected keys,
206	* as protected keys have a random component, which makes the output
207	* differ.
208	*/
209	if ((pass == NULL && pcipher == NULL)
210	&& !test_cb(file, line, encoded, encoded_len, encoded2, encoded2_len))
211	goto end;
212
213	ok = 1;
214	end:
215	if (!ok) {
216	if (encoded != NULL && encoded_len != 0)
217	dump_cb("\|pkey\| encoded", encoded, encoded_len);
218	if (encoded2 != NULL && encoded2_len != 0)
219	dump_cb("\|pkey2\| encoded", encoded2, encoded2_len);
220	}
221
222	OPENSSL_free(encoded);
223	OPENSSL_free(encoded2);
224	EVP_PKEY_free(pkey2);
225	return ok;
226	}
227
228	/* Encoding and decoding methods */
229
230	static int encode_EVP_PKEY_prov(const char *file, const int line,
231	void *encoded, long encoded_len,
232	void *object, int selection,
233	const char *output_type,
234	const char *output_structure,
235	const char pass, const char pcipher)
236	{
237	EVP_PKEY *pkey = object;
238	OSSL_ENCODER_CTX *ectx = NULL;
239	BIO *mem_ser = NULL;
240	BUF_MEM *mem_buf = NULL;
241	const unsigned char upass = (const unsigned char )pass;
242	int ok = 0;
243
244	if (!TEST_FL_ptr(ectx = OSSL_ENCODER_CTX_new_for_pkey(pkey, selection,
245	output_type,
246	output_structure,
247	testpropq))
248	\|\| !TEST_FL_int_gt(OSSL_ENCODER_CTX_get_num_encoders(ectx), 0)
249	\|\| (pass != NULL
250	&& !TEST_FL_true(OSSL_ENCODER_CTX_set_passphrase(ectx, upass,
251	strlen(pass))))
252	\|\| (pcipher != NULL
253	&& !TEST_FL_true(OSSL_ENCODER_CTX_set_cipher(ectx, pcipher, NULL)))
254	\|\| !TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
255	\|\| !TEST_FL_true(OSSL_ENCODER_to_bio(ectx, mem_ser))
256	\|\| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
257	\|\| !TEST_FL_ptr(*encoded = mem_buf->data)
258	\|\| !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
259	goto end;
260
261	/* Detach the encoded output */
262	mem_buf->data = NULL;
263	mem_buf->length = 0;
264	ok = 1;
265	end:
266	BIO_free(mem_ser);
267	OSSL_ENCODER_CTX_free(ectx);
268	return ok;
269	}
270
271	static int decode_EVP_PKEY_prov(const char *file, const int line,
272	void *object, void encoded, long encoded_len,
273	const char *input_type,
274	const char *structure_type,
275	const char *keytype, int selection,
276	const char *pass)
277	{
278	EVP_PKEY pkey = NULL, testpkey = NULL;
279	OSSL_DECODER_CTX *dctx = NULL;
280	BIO *encoded_bio = NULL;
281	const unsigned char upass = (const unsigned char )pass;
282	int ok = 0;
283	int i;
284	const char *badtype;
285
286	if (strcmp(input_type, "DER") == 0)
287	badtype = "PEM";
288	else
289	badtype = "DER";
290
291	if (!TEST_FL_ptr(encoded_bio = BIO_new_mem_buf(encoded, encoded_len)))
292	goto end;
293
294	/*
295	* We attempt the decode 3 times. The first time we provide the expected
296	* starting input type. The second time we provide NULL for the starting
297	* type. The third time we provide a bad starting input type.
298	* The bad starting input type should fail. The other two should succeed
299	* and produce the same result.
300	*/
301	for (i = 0; i < 3; i++) {
302	const char *testtype = (i == 0) ? input_type
303	: ((i == 1) ? NULL : badtype);
304
305	if (!TEST_FL_ptr(dctx = OSSL_DECODER_CTX_new_for_pkey(&testpkey,
306	testtype,
307	structure_type,
308	keytype,
309	selection,
310	testctx, testpropq))
311	\|\| (pass != NULL
312	&& !OSSL_DECODER_CTX_set_passphrase(dctx, upass, strlen(pass)))
313	\|\| !TEST_FL_int_gt(BIO_reset(encoded_bio), 0)
314	/* We expect to fail when using a bad input type */
315	\|\| !TEST_FL_int_eq(OSSL_DECODER_from_bio(dctx, encoded_bio),
316	(i == 2) ? 0 : 1))
317	goto end;
318	OSSL_DECODER_CTX_free(dctx);
319	dctx = NULL;
320
321	if (i == 0) {
322	pkey = testpkey;
323	testpkey = NULL;
324	} else if (i == 1) {
325	if (selection == OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) {
326	if (!TEST_FL_int_eq(EVP_PKEY_parameters_eq(pkey, testpkey), 1))
327	goto end;
328	} else {
329	if (!TEST_FL_int_eq(EVP_PKEY_eq(pkey, testpkey), 1))
330	goto end;
331	}
332	}
333	}
334	ok = 1;
335	*object = pkey;
336	pkey = NULL;
337
338	end:
339	EVP_PKEY_free(pkey);
340	EVP_PKEY_free(testpkey);
341	BIO_free(encoded_bio);
342	OSSL_DECODER_CTX_free(dctx);
343	return ok;
344	}
345
346	static int encode_EVP_PKEY_legacy_PEM(const char *file, const int line,
347	void *encoded, long encoded_len,
348	void *object, ossl_unused int selection,
349	ossl_unused const char *output_type,
350	ossl_unused const char *output_structure,
351	const char pass, const char pcipher)
352	{
353	EVP_PKEY *pkey = object;
354	EVP_CIPHER *cipher = NULL;
355	BIO *mem_ser = NULL;
356	BUF_MEM *mem_buf = NULL;
357	const unsigned char upass = (const unsigned char )pass;
358	size_t passlen = 0;
359	int ok = 0;
360
361	if (pcipher != NULL && pass != NULL) {
362	passlen = strlen(pass);
363	if (!TEST_FL_ptr(cipher = EVP_CIPHER_fetch(testctx, pcipher, testpropq)))
364	goto end;
365	}
366	if (!TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
367	\|\| !TEST_FL_true(PEM_write_bio_PrivateKey_traditional(mem_ser, pkey,
368	cipher,
369	upass, passlen,
370	NULL, NULL))
371	\|\| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
372	\|\| !TEST_FL_ptr(*encoded = mem_buf->data)
373	\|\| !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
374	goto end;
375
376	/* Detach the encoded output */
377	mem_buf->data = NULL;
378	mem_buf->length = 0;
379	ok = 1;
380	end:
381	BIO_free(mem_ser);
382	EVP_CIPHER_free(cipher);
383	return ok;
384	}
385
386	static int encode_EVP_PKEY_MSBLOB(const char *file, const int line,
387	void *encoded, long encoded_len,
388	void *object, int selection,
389	ossl_unused const char *output_type,
390	ossl_unused const char *output_structure,
391	ossl_unused const char *pass,
392	ossl_unused const char *pcipher)
393	{
394	EVP_PKEY *pkey = object;
395	BIO *mem_ser = NULL;
396	BUF_MEM *mem_buf = NULL;
397	int ok = 0;
398
399	if (!TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem())))
400	goto end;
401
402	if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
403	if (!TEST_FL_int_ge(i2b_PrivateKey_bio(mem_ser, pkey), 0))
404	goto end;
405	} else {
406	if (!TEST_FL_int_ge(i2b_PublicKey_bio(mem_ser, pkey), 0))
407	goto end;
408	}
409
410	if (!TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
411	\|\| !TEST_FL_ptr(*encoded = mem_buf->data)
412	\|\| !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
413	goto end;
414
415	/* Detach the encoded output */
416	mem_buf->data = NULL;
417	mem_buf->length = 0;
418	ok = 1;
419	end:
420	BIO_free(mem_ser);
421	return ok;
422	}
423
424	static pem_password_cb pass_pw;
425	static int pass_pw(char buf, int size, int rwflag, void userdata)
426	{
427	OPENSSL_strlcpy(buf, userdata, size);
428	return strlen(userdata);
429	}
430
431	static int encode_EVP_PKEY_PVK(const char *file, const int line,
432	void *encoded, long encoded_len,
433	void *object, int selection,
434	ossl_unused const char *output_type,
435	ossl_unused const char *output_structure,
436	const char *pass,
437	ossl_unused const char *pcipher)
438	{
439	EVP_PKEY *pkey = object;
440	BIO *mem_ser = NULL;
441	BUF_MEM *mem_buf = NULL;
442	int enc = (pass != NULL);
443	int ok = 0;
444
445	if (!TEST_FL_true(ossl_assert((selection
446	& OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0))
447	\|\| !TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
448	\|\| !TEST_FL_int_ge(i2b_PVK_bio_ex(mem_ser, pkey, enc,
449	pass_pw, (void *)pass, testctx, testpropq), 0)
450	\|\| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
451	\|\| !TEST_FL_ptr(*encoded = mem_buf->data)
452	\|\| !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
453	goto end;
454
455	/* Detach the encoded output */
456	mem_buf->data = NULL;
457	mem_buf->length = 0;
458	ok = 1;
459	end:
460	BIO_free(mem_ser);
461	return ok;
462	}
463
464	static int test_text(const char *file, const int line,
465	const void *data1, size_t data1_len,
466	const void *data2, size_t data2_len)
467	{
468	return TEST_FL_strn2_eq(data1, data1_len, data2, data2_len);
469	}
470
471	static int test_mem(const char *file, const int line,
472	const void *data1, size_t data1_len,
473	const void *data2, size_t data2_len)
474	{
475	return TEST_FL_mem_eq(data1, data1_len, data2, data2_len);
476	}
477
478	/* Test cases and their dumpers / checkers */
479
480	static void collect_name(const char name, void arg)
481	{
482	char **namelist = arg;
483	char *new_namelist;
484	size_t space;
485
486	space = strlen(name);
487	if (*namelist != NULL)
488	space += strlen(namelist) + 2 / for comma and space */;
489	space++; /* for terminating null byte */
490
491	new_namelist = OPENSSL_realloc(*namelist, space);
492	if (new_namelist == NULL)
493	return;
494	if (*namelist != NULL) {
495	strcat(new_namelist, ", ");
496	strcat(new_namelist, name);
497	} else {
498	strcpy(new_namelist, name);
499	}
500	*namelist = new_namelist;
501	}
502
503	static void dump_der(const char label, const void data, size_t data_len)
504	{
505	test_output_memory(label, data, data_len);
506	}
507
508	static void dump_pem(const char label, const void data, size_t data_len)
509	{
510	test_output_string(label, data, data_len - 1);
511	}
512
513	static int check_unprotected_PKCS8_DER(const char *file, const int line,
514	const char *type,
515	const void *data, size_t data_len)
516	{
517	const unsigned char *datap = data;
518	PKCS8_PRIV_KEY_INFO *p8inf =
519	d2i_PKCS8_PRIV_KEY_INFO(NULL, &datap, data_len);
520	int ok = 0;
521
522	if (TEST_FL_ptr(p8inf)) {
523	EVP_PKEY *pkey = EVP_PKCS82PKEY_ex(p8inf, testctx, testpropq);
524	char *namelist = NULL;
525
526	if (TEST_FL_ptr(pkey)) {
527	if (!(ok = TEST_FL_true(EVP_PKEY_is_a(pkey, type)))) {
528	EVP_PKEY_type_names_do_all(pkey, collect_name, &namelist);
529	if (namelist != NULL)
530	TEST_note("%s isn't any of %s", type, namelist);
531	OPENSSL_free(namelist);
532	}
533	ok = ok && TEST_FL_true(evp_pkey_is_provided(pkey));
534	EVP_PKEY_free(pkey);
535	}
536	}
537	PKCS8_PRIV_KEY_INFO_free(p8inf);
538	return ok;
539	}
540
541	static int test_unprotected_via_DER(const char type, EVP_PKEY key, int fips)
542	{
543	return test_encode_decode(__FILE__, __LINE__, type, key,
544	OSSL_KEYMGMT_SELECT_KEYPAIR
545	\| OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
546	"DER", "PrivateKeyInfo", NULL, NULL,
547	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
548	test_mem, check_unprotected_PKCS8_DER,
549	dump_der, fips ? 0 : FLAG_FAIL_IF_FIPS);
550	}
551
552	static int check_unprotected_PKCS8_PEM(const char *file, const int line,
553	const char *type,
554	const void *data, size_t data_len)
555	{
556	static const char expected_pem_header[] =
557	"-----BEGIN " PEM_STRING_PKCS8INF "-----";
558
559	return TEST_FL_strn_eq(data, expected_pem_header,
560	sizeof(expected_pem_header) - 1);
561	}
562
563	static int test_unprotected_via_PEM(const char type, EVP_PKEY key, int fips)
564	{
565	return test_encode_decode(__FILE__, __LINE__, type, key,
566	OSSL_KEYMGMT_SELECT_KEYPAIR
567	\| OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
568	"PEM", "PrivateKeyInfo", NULL, NULL,
569	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
570	test_text, check_unprotected_PKCS8_PEM,
571	dump_pem, fips ? 0 : FLAG_FAIL_IF_FIPS);
572	}
573
574	#ifndef OPENSSL_NO_KEYPARAMS
575	static int check_params_DER(const char *file, const int line,
576	const char type, const void data, size_t data_len)
577	{
578	const unsigned char *datap = data;
579	int ok = 0;
580	int itype = NID_undef;
581	EVP_PKEY *pkey = NULL;
582
583	if (strcmp(type, "DH") == 0)
584	itype = EVP_PKEY_DH;
585	else if (strcmp(type, "X9.42 DH") == 0)
586	itype = EVP_PKEY_DHX;
587	else if (strcmp(type, "DSA") == 0)
588	itype = EVP_PKEY_DSA;
589	else if (strcmp(type, "EC") == 0)
590	itype = EVP_PKEY_EC;
591
592	if (itype != NID_undef) {
593	pkey = d2i_KeyParams(itype, NULL, &datap, data_len);
594	ok = (pkey != NULL);
595	EVP_PKEY_free(pkey);
596	}
597
598	return ok;
599	}
600
601	static int check_params_PEM(const char *file, const int line,
602	const char *type,
603	const void *data, size_t data_len)
604	{
605	static char expected_pem_header[80];
606
607	return
608	TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
609	sizeof(expected_pem_header),
610	"-----BEGIN %s PARAMETERS-----", type), 0)
611	&& TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header));
612	}
613
614	static int test_params_via_DER(const char type, EVP_PKEY key)
615	{
616	return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
617	"DER", "type-specific", NULL, NULL,
618	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
619	test_mem, check_params_DER,
620	dump_der, FLAG_DECODE_WITH_TYPE);
621	}
622
623	static int test_params_via_PEM(const char type, EVP_PKEY key)
624	{
625	return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
626	"PEM", "type-specific", NULL, NULL,
627	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
628	test_text, check_params_PEM,
629	dump_pem, 0);
630	}
631	#endif /* !OPENSSL_NO_KEYPARAMS */
632
633	static int check_unprotected_legacy_PEM(const char *file, const int line,
634	const char *type,
635	const void *data, size_t data_len)
636	{
637	static char expected_pem_header[80];
638
639	return
640	TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
641	sizeof(expected_pem_header),
642	"-----BEGIN %s PRIVATE KEY-----", type), 0)
643	&& TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header));
644	}
645
646	static int test_unprotected_via_legacy_PEM(const char type, EVP_PKEY key)
647	{
648	if (!default_libctx \|\| is_fips)
649	return TEST_skip("Test not available if using a non-default library context or FIPS provider");
650
651	return test_encode_decode(__FILE__, __LINE__, type, key,
652	OSSL_KEYMGMT_SELECT_KEYPAIR
653	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
654	"PEM", "type-specific", NULL, NULL,
655	encode_EVP_PKEY_legacy_PEM, decode_EVP_PKEY_prov,
656	test_text, check_unprotected_legacy_PEM,
657	dump_pem, 0);
658	}
659
660	static int check_MSBLOB(const char *file, const int line,
661	const char type, const void data, size_t data_len)
662	{
663	const unsigned char *datap = data;
664	EVP_PKEY *pkey = b2i_PrivateKey(&datap, data_len);
665	int ok = TEST_FL_ptr(pkey);
666
667	EVP_PKEY_free(pkey);
668	return ok;
669	}
670
671	static int test_unprotected_via_MSBLOB(const char type, EVP_PKEY key)
672	{
673	return test_encode_decode(__FILE__, __LINE__, type, key,
674	OSSL_KEYMGMT_SELECT_KEYPAIR
675	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
676	"MSBLOB", NULL, NULL, NULL,
677	encode_EVP_PKEY_MSBLOB, decode_EVP_PKEY_prov,
678	test_mem, check_MSBLOB,
679	dump_der, 0);
680	}
681
682	static int check_PVK(const char *file, const int line,
683	const char type, const void data, size_t data_len)
684	{
685	const unsigned char *in = data;
686	unsigned int saltlen = 0, keylen = 0;
687	int ok = ossl_do_PVK_header(&in, data_len, 0, &saltlen, &keylen);
688
689	return ok;
690	}
691
692	static int test_unprotected_via_PVK(const char type, EVP_PKEY key)
693	{
694	return test_encode_decode(__FILE__, __LINE__, type, key,
695	OSSL_KEYMGMT_SELECT_KEYPAIR
696	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
697	"PVK", NULL, NULL, NULL,
698	encode_EVP_PKEY_PVK, decode_EVP_PKEY_prov,
699	test_mem, check_PVK,
700	dump_der, 0);
701	}
702
703	static const char *pass_cipher = "AES-256-CBC";
704	static const char *pass = "the holy handgrenade of antioch";
705
706	static int check_protected_PKCS8_DER(const char *file, const int line,
707	const char *type,
708	const void *data, size_t data_len)
709	{
710	const unsigned char *datap = data;
711	X509_SIG *p8 = d2i_X509_SIG(NULL, &datap, data_len);
712	int ok = TEST_FL_ptr(p8);
713
714	X509_SIG_free(p8);
715	return ok;
716	}
717
718	static int test_protected_via_DER(const char type, EVP_PKEY key, int fips)
719	{
720	return test_encode_decode(__FILE__, __LINE__, type, key,
721	OSSL_KEYMGMT_SELECT_KEYPAIR
722	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
723	"DER", "EncryptedPrivateKeyInfo",
724	pass, pass_cipher,
725	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
726	test_mem, check_protected_PKCS8_DER,
727	dump_der, fips ? 0 : FLAG_FAIL_IF_FIPS);
728	}
729
730	static int check_protected_PKCS8_PEM(const char *file, const int line,
731	const char *type,
732	const void *data, size_t data_len)
733	{
734	static const char expected_pem_header[] =
735	"-----BEGIN " PEM_STRING_PKCS8 "-----";
736
737	return TEST_FL_strn_eq(data, expected_pem_header,
738	sizeof(expected_pem_header) - 1);
739	}
740
741	static int test_protected_via_PEM(const char type, EVP_PKEY key, int fips)
742	{
743	return test_encode_decode(__FILE__, __LINE__, type, key,
744	OSSL_KEYMGMT_SELECT_KEYPAIR
745	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
746	"PEM", "EncryptedPrivateKeyInfo",
747	pass, pass_cipher,
748	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
749	test_text, check_protected_PKCS8_PEM,
750	dump_pem, fips ? 0 : FLAG_FAIL_IF_FIPS);
751	}
752
753	static int check_protected_legacy_PEM(const char *file, const int line,
754	const char *type,
755	const void *data, size_t data_len)
756	{
757	static char expected_pem_header[80];
758
759	return
760	TEST_FL_int_gt(BIO_snprintf(expected_pem_header,
761	sizeof(expected_pem_header),
762	"-----BEGIN %s PRIVATE KEY-----", type), 0)
763	&& TEST_FL_strn_eq(data, expected_pem_header, strlen(expected_pem_header))
764	&& TEST_FL_ptr(strstr(data, "\nDEK-Info: "));
765	}
766
767	static int test_protected_via_legacy_PEM(const char type, EVP_PKEY key)
768	{
769	if (!default_libctx \|\| is_fips)
770	return TEST_skip("Test not available if using a non-default library context or FIPS provider");
771
772	return test_encode_decode(__FILE__, __LINE__, type, key,
773	OSSL_KEYMGMT_SELECT_KEYPAIR
774	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
775	"PEM", "type-specific", pass, pass_cipher,
776	encode_EVP_PKEY_legacy_PEM, decode_EVP_PKEY_prov,
777	test_text, check_protected_legacy_PEM,
778	dump_pem, 0);
779	}
780
781	#ifndef OPENSSL_NO_RC4
782	static int test_protected_via_PVK(const char type, EVP_PKEY key)
783	{
784	int ret = 0;
785	OSSL_PROVIDER *lgcyprov = OSSL_PROVIDER_load(testctx, "legacy");
786	if (lgcyprov == NULL)
787	return TEST_skip("Legacy provider not available");
788
789	ret = test_encode_decode(__FILE__, __LINE__, type, key,
790	OSSL_KEYMGMT_SELECT_KEYPAIR
791	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
792	"PVK", NULL, pass, NULL,
793	encode_EVP_PKEY_PVK, decode_EVP_PKEY_prov,
794	test_mem, check_PVK, dump_der, 0);
795	OSSL_PROVIDER_unload(lgcyprov);
796	return ret;
797	}
798	#endif
799
800	static int check_public_DER(const char *file, const int line,
801	const char type, const void data, size_t data_len)
802	{
803	const unsigned char *datap = data;
804	EVP_PKEY *pkey = d2i_PUBKEY_ex(NULL, &datap, data_len, testctx, testpropq);
805	int ok = (TEST_FL_ptr(pkey) && TEST_FL_true(EVP_PKEY_is_a(pkey, type)));
806
807	EVP_PKEY_free(pkey);
808	return ok;
809	}
810
811	static int test_public_via_DER(const char type, EVP_PKEY key, int fips)
812	{
813	return test_encode_decode(__FILE__, __LINE__, type, key,
814	OSSL_KEYMGMT_SELECT_PUBLIC_KEY
815	\| OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
816	"DER", "SubjectPublicKeyInfo", NULL, NULL,
817	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
818	test_mem, check_public_DER, dump_der,
819	fips ? 0 : FLAG_FAIL_IF_FIPS);
820	}
821
822	static int check_public_PEM(const char *file, const int line,
823	const char type, const void data, size_t data_len)
824	{
825	static const char expected_pem_header[] =
826	"-----BEGIN " PEM_STRING_PUBLIC "-----";
827
828	return
829	TEST_FL_strn_eq(data, expected_pem_header,
830	sizeof(expected_pem_header) - 1);
831	}
832
833	static int test_public_via_PEM(const char type, EVP_PKEY key, int fips)
834	{
835	return test_encode_decode(__FILE__, __LINE__, type, key,
836	OSSL_KEYMGMT_SELECT_PUBLIC_KEY
837	\| OSSL_KEYMGMT_SELECT_ALL_PARAMETERS,
838	"PEM", "SubjectPublicKeyInfo", NULL, NULL,
839	encode_EVP_PKEY_prov, decode_EVP_PKEY_prov,
840	test_text, check_public_PEM, dump_pem,
841	fips ? 0 : FLAG_FAIL_IF_FIPS);
842	}
843
844	static int check_public_MSBLOB(const char *file, const int line,
845	const char *type,
846	const void *data, size_t data_len)
847	{
848	const unsigned char *datap = data;
849	EVP_PKEY *pkey = b2i_PublicKey(&datap, data_len);
850	int ok = TEST_FL_ptr(pkey);
851
852	EVP_PKEY_free(pkey);
853	return ok;
854	}
855
856	static int test_public_via_MSBLOB(const char type, EVP_PKEY key)
857	{
858	return test_encode_decode(__FILE__, __LINE__, type, key, OSSL_KEYMGMT_SELECT_PUBLIC_KEY
859	\| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
860	"MSBLOB", NULL, NULL, NULL,
861	encode_EVP_PKEY_MSBLOB, decode_EVP_PKEY_prov,
862	test_mem, check_public_MSBLOB, dump_der, 0);
863	}
864
865	#define KEYS(KEYTYPE) \
866	static EVP_PKEY *key_##KEYTYPE = NULL
867	#define MAKE_KEYS(KEYTYPE, KEYTYPEstr, params) \
868	ok = ok \
869	&& TEST_ptr(key_##KEYTYPE = make_key(KEYTYPEstr, NULL, params))
870	#define FREE_KEYS(KEYTYPE) \
871	EVP_PKEY_free(key_##KEYTYPE); \
872
873	#define DOMAIN_KEYS(KEYTYPE) \
874	static EVP_PKEY *template_##KEYTYPE = NULL; \
875	static EVP_PKEY *key_##KEYTYPE = NULL
876	#define MAKE_DOMAIN_KEYS(KEYTYPE, KEYTYPEstr, params) \
877	ok = ok \
878	&& TEST_ptr(template_##KEYTYPE = \
879	make_template(KEYTYPEstr, params)) \
880	&& TEST_ptr(key_##KEYTYPE = \
881	make_key(KEYTYPEstr, template_##KEYTYPE, NULL))
882	#define FREE_DOMAIN_KEYS(KEYTYPE) \
883	EVP_PKEY_free(template_##KEYTYPE); \
884	EVP_PKEY_free(key_##KEYTYPE)
885
886	#define IMPLEMENT_TEST_SUITE(KEYTYPE, KEYTYPEstr, fips) \
887	static int test_unprotected_##KEYTYPE##_via_DER(void) \
888	{ \
889	return test_unprotected_via_DER(KEYTYPEstr, key_##KEYTYPE, fips); \
890	} \
891	static int test_unprotected_##KEYTYPE##_via_PEM(void) \
892	{ \
893	return test_unprotected_via_PEM(KEYTYPEstr, key_##KEYTYPE, fips); \
894	} \
895	static int test_protected_##KEYTYPE##_via_DER(void) \
896	{ \
897	return test_protected_via_DER(KEYTYPEstr, key_##KEYTYPE, fips); \
898	} \
899	static int test_protected_##KEYTYPE##_via_PEM(void) \
900	{ \
901	return test_protected_via_PEM(KEYTYPEstr, key_##KEYTYPE, fips); \
902	} \
903	static int test_public_##KEYTYPE##_via_DER(void) \
904	{ \
905	return test_public_via_DER(KEYTYPEstr, key_##KEYTYPE, fips); \
906	} \
907	static int test_public_##KEYTYPE##_via_PEM(void) \
908	{ \
909	return test_public_via_PEM(KEYTYPEstr, key_##KEYTYPE, fips); \
910	}
911
912	#define ADD_TEST_SUITE(KEYTYPE) \
913	ADD_TEST(test_unprotected_##KEYTYPE##_via_DER); \
914	ADD_TEST(test_unprotected_##KEYTYPE##_via_PEM); \
915	ADD_TEST(test_protected_##KEYTYPE##_via_DER); \
916	ADD_TEST(test_protected_##KEYTYPE##_via_PEM); \
917	ADD_TEST(test_public_##KEYTYPE##_via_DER); \
918	ADD_TEST(test_public_##KEYTYPE##_via_PEM)
919
920	#define IMPLEMENT_TEST_SUITE_PARAMS(KEYTYPE, KEYTYPEstr) \
921	static int test_params_##KEYTYPE##_via_DER(void) \
922	{ \
923	return test_params_via_DER(KEYTYPEstr, key_##KEYTYPE); \
924	} \
925	static int test_params_##KEYTYPE##_via_PEM(void) \
926	{ \
927	return test_params_via_PEM(KEYTYPEstr, key_##KEYTYPE); \
928	}
929
930	#define ADD_TEST_SUITE_PARAMS(KEYTYPE) \
931	ADD_TEST(test_params_##KEYTYPE##_via_DER); \
932	ADD_TEST(test_params_##KEYTYPE##_via_PEM)
933
934	#define IMPLEMENT_TEST_SUITE_LEGACY(KEYTYPE, KEYTYPEstr) \
935	static int test_unprotected_##KEYTYPE##_via_legacy_PEM(void) \
936	{ \
937	return \
938	test_unprotected_via_legacy_PEM(KEYTYPEstr, key_##KEYTYPE); \
939	} \
940	static int test_protected_##KEYTYPE##_via_legacy_PEM(void) \
941	{ \
942	return \
943	test_protected_via_legacy_PEM(KEYTYPEstr, key_##KEYTYPE); \
944	}
945
946	#define ADD_TEST_SUITE_LEGACY(KEYTYPE) \
947	ADD_TEST(test_unprotected_##KEYTYPE##_via_legacy_PEM); \
948	ADD_TEST(test_protected_##KEYTYPE##_via_legacy_PEM)
949
950	#define IMPLEMENT_TEST_SUITE_MSBLOB(KEYTYPE, KEYTYPEstr) \
951	static int test_unprotected_##KEYTYPE##_via_MSBLOB(void) \
952	{ \
953	return test_unprotected_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE); \
954	} \
955	static int test_public_##KEYTYPE##_via_MSBLOB(void) \
956	{ \
957	return test_public_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE); \
958	}
959
960	#define ADD_TEST_SUITE_MSBLOB(KEYTYPE) \
961	ADD_TEST(test_unprotected_##KEYTYPE##_via_MSBLOB); \
962	ADD_TEST(test_public_##KEYTYPE##_via_MSBLOB)
963
964	#define IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(KEYTYPE, KEYTYPEstr) \
965	static int test_unprotected_##KEYTYPE##_via_PVK(void) \
966	{ \
967	return test_unprotected_via_PVK(KEYTYPEstr, key_##KEYTYPE); \
968	}
969	# define ADD_TEST_SUITE_UNPROTECTED_PVK(KEYTYPE) \
970	ADD_TEST(test_unprotected_##KEYTYPE##_via_PVK)
971	#ifndef OPENSSL_NO_RC4
972	# define IMPLEMENT_TEST_SUITE_PROTECTED_PVK(KEYTYPE, KEYTYPEstr) \
973	static int test_protected_##KEYTYPE##_via_PVK(void) \
974	{ \
975	return test_protected_via_PVK(KEYTYPEstr, key_##KEYTYPE); \
976	}
977	# define ADD_TEST_SUITE_PROTECTED_PVK(KEYTYPE) \
978	ADD_TEST(test_protected_##KEYTYPE##_via_PVK)
979	#endif
980
981	#ifndef OPENSSL_NO_DH
982	DOMAIN_KEYS(DH);
983	IMPLEMENT_TEST_SUITE(DH, "DH", 1)
984	IMPLEMENT_TEST_SUITE_PARAMS(DH, "DH")
985	DOMAIN_KEYS(DHX);
986	IMPLEMENT_TEST_SUITE(DHX, "X9.42 DH", 1)
987	IMPLEMENT_TEST_SUITE_PARAMS(DHX, "X9.42 DH")
988	/*
989	* DH has no support for PEM_write_bio_PrivateKey_traditional(),
990	* so no legacy tests.
991	*/
992	#endif
993	#ifndef OPENSSL_NO_DSA
994	DOMAIN_KEYS(DSA);
995	IMPLEMENT_TEST_SUITE(DSA, "DSA", 1)
996	IMPLEMENT_TEST_SUITE_PARAMS(DSA, "DSA")
997	IMPLEMENT_TEST_SUITE_LEGACY(DSA, "DSA")
998	IMPLEMENT_TEST_SUITE_MSBLOB(DSA, "DSA")
999	IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(DSA, "DSA")
1000	# ifndef OPENSSL_NO_RC4
1001	IMPLEMENT_TEST_SUITE_PROTECTED_PVK(DSA, "DSA")
1002	# endif
1003	#endif
1004	#ifndef OPENSSL_NO_EC
1005	DOMAIN_KEYS(EC);
1006	IMPLEMENT_TEST_SUITE(EC, "EC", 1)
1007	IMPLEMENT_TEST_SUITE_PARAMS(EC, "EC")
1008	IMPLEMENT_TEST_SUITE_LEGACY(EC, "EC")
1009	DOMAIN_KEYS(ECExplicitPrimeNamedCurve);
1010	IMPLEMENT_TEST_SUITE(ECExplicitPrimeNamedCurve, "EC", 1)
1011	IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitPrimeNamedCurve, "EC")
1012	DOMAIN_KEYS(ECExplicitPrime2G);
1013	IMPLEMENT_TEST_SUITE(ECExplicitPrime2G, "EC", 0)
1014	IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitPrime2G, "EC")
1015	# ifndef OPENSSL_NO_EC2M
1016	DOMAIN_KEYS(ECExplicitTriNamedCurve);
1017	IMPLEMENT_TEST_SUITE(ECExplicitTriNamedCurve, "EC", 1)
1018	IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitTriNamedCurve, "EC")
1019	DOMAIN_KEYS(ECExplicitTri2G);
1020	IMPLEMENT_TEST_SUITE(ECExplicitTri2G, "EC", 0)
1021	IMPLEMENT_TEST_SUITE_LEGACY(ECExplicitTri2G, "EC")
1022	# endif
1023	KEYS(ED25519);
1024	IMPLEMENT_TEST_SUITE(ED25519, "ED25519", 1)
1025	KEYS(ED448);
1026	IMPLEMENT_TEST_SUITE(ED448, "ED448", 1)
1027	KEYS(X25519);
1028	IMPLEMENT_TEST_SUITE(X25519, "X25519", 1)
1029	KEYS(X448);
1030	IMPLEMENT_TEST_SUITE(X448, "X448", 1)
1031	/*
1032	* ED25519, ED448, X25519 and X448 have no support for
1033	* PEM_write_bio_PrivateKey_traditional(), so no legacy tests.
1034	*/
1035	#endif
1036	KEYS(RSA);
1037	IMPLEMENT_TEST_SUITE(RSA, "RSA", 1)
1038	IMPLEMENT_TEST_SUITE_LEGACY(RSA, "RSA")
1039	KEYS(RSA_PSS);
1040	IMPLEMENT_TEST_SUITE(RSA_PSS, "RSA-PSS", 1)
1041	/*
1042	* RSA-PSS has no support for PEM_write_bio_PrivateKey_traditional(),
1043	* so no legacy tests.
1044	*/
1045	IMPLEMENT_TEST_SUITE_MSBLOB(RSA, "RSA")
1046	IMPLEMENT_TEST_SUITE_UNPROTECTED_PVK(RSA, "RSA")
1047	#ifndef OPENSSL_NO_RC4
1048	IMPLEMENT_TEST_SUITE_PROTECTED_PVK(RSA, "RSA")
1049	#endif
1050
1051	#ifndef OPENSSL_NO_EC
1052	/* Explicit parameters that match a named curve */
1053	static int do_create_ec_explicit_prime_params(OSSL_PARAM_BLD *bld,
1054	const unsigned char *gen,
1055	size_t gen_len)
1056	{
1057	BIGNUM a, b, prime, order;
1058
1059	/* Curve prime256v1 */
1060	static const unsigned char prime_data[] = {
1061	0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1062	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1063	0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
1064	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1065	0xff
1066	};
1067	static const unsigned char a_data[] = {
1068	0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1069	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1070	0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
1071	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1072	0xfc
1073	};
1074	static const unsigned char b_data[] = {
1075	0x5a, 0xc6, 0x35, 0xd8, 0xaa, 0x3a, 0x93, 0xe7,
1076	0xb3, 0xeb, 0xbd, 0x55, 0x76, 0x98, 0x86, 0xbc,
1077	0x65, 0x1d, 0x06, 0xb0, 0xcc, 0x53, 0xb0, 0xf6,
1078	0x3b, 0xce, 0x3c, 0x3e, 0x27, 0xd2, 0x60, 0x4b
1079	};
1080	static const unsigned char seed[] = {
1081	0xc4, 0x9d, 0x36, 0x08, 0x86, 0xe7, 0x04, 0x93,
1082	0x6a, 0x66, 0x78, 0xe1, 0x13, 0x9d, 0x26, 0xb7,
1083	0x81, 0x9f, 0x7e, 0x90
1084	};
1085	static const unsigned char order_data[] = {
1086	0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1087	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1088	0xff, 0xbc, 0xe6, 0xfa, 0xad, 0xa7, 0x17, 0x9e,
1089	0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x51
1090	};
1091	return TEST_ptr(a = BN_CTX_get(bnctx))
1092	&& TEST_ptr(b = BN_CTX_get(bnctx))
1093	&& TEST_ptr(prime = BN_CTX_get(bnctx))
1094	&& TEST_ptr(order = BN_CTX_get(bnctx))
1095	&& TEST_ptr(BN_bin2bn(prime_data, sizeof(prime_data), prime))
1096	&& TEST_ptr(BN_bin2bn(a_data, sizeof(a_data), a))
1097	&& TEST_ptr(BN_bin2bn(b_data, sizeof(b_data), b))
1098	&& TEST_ptr(BN_bin2bn(order_data, sizeof(order_data), order))
1099	&& TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
1100	OSSL_PKEY_PARAM_EC_FIELD_TYPE, SN_X9_62_prime_field,
1101	0))
1102	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_P, prime))
1103	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_A, a))
1104	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_B, b))
1105	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld,
1106	OSSL_PKEY_PARAM_EC_ORDER, order))
1107	&& TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1108	OSSL_PKEY_PARAM_EC_GENERATOR, gen, gen_len))
1109	&& TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1110	OSSL_PKEY_PARAM_EC_SEED, seed, sizeof(seed)))
1111	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_COFACTOR,
1112	BN_value_one()));
1113	}
1114
1115	static int create_ec_explicit_prime_params_namedcurve(OSSL_PARAM_BLD *bld)
1116	{
1117	static const unsigned char prime256v1_gen[] = {
1118	0x04,
1119	0x6b, 0x17, 0xd1, 0xf2, 0xe1, 0x2c, 0x42, 0x47,
1120	0xf8, 0xbc, 0xe6, 0xe5, 0x63, 0xa4, 0x40, 0xf2,
1121	0x77, 0x03, 0x7d, 0x81, 0x2d, 0xeb, 0x33, 0xa0,
1122	0xf4, 0xa1, 0x39, 0x45, 0xd8, 0x98, 0xc2, 0x96,
1123	0x4f, 0xe3, 0x42, 0xe2, 0xfe, 0x1a, 0x7f, 0x9b,
1124	0x8e, 0xe7, 0xeb, 0x4a, 0x7c, 0x0f, 0x9e, 0x16,
1125	0x2b, 0xce, 0x33, 0x57, 0x6b, 0x31, 0x5e, 0xce,
1126	0xcb, 0xb6, 0x40, 0x68, 0x37, 0xbf, 0x51, 0xf5
1127	};
1128	return do_create_ec_explicit_prime_params(bld, prime256v1_gen,
1129	sizeof(prime256v1_gen));
1130	}
1131
1132	static int create_ec_explicit_prime_params(OSSL_PARAM_BLD *bld)
1133	{
1134	/* 2G */
1135	static const unsigned char prime256v1_gen2[] = {
1136	0x04,
1137	0xe4, 0x97, 0x08, 0xbe, 0x7d, 0xfa, 0xa2, 0x9a,
1138	0xa3, 0x12, 0x6f, 0xe4, 0xe7, 0xd0, 0x25, 0xe3,
1139	0x4a, 0xc1, 0x03, 0x15, 0x8c, 0xd9, 0x33, 0xc6,
1140	0x97, 0x42, 0xf5, 0xdc, 0x97, 0xb9, 0xd7, 0x31,
1141	0xe9, 0x7d, 0x74, 0x3d, 0x67, 0x6a, 0x3b, 0x21,
1142	0x08, 0x9c, 0x31, 0x73, 0xf8, 0xc1, 0x27, 0xc9,
1143	0xd2, 0xa0, 0xa0, 0x83, 0x66, 0xe0, 0xc9, 0xda,
1144	0xa8, 0xc6, 0x56, 0x2b, 0x94, 0xb1, 0xae, 0x55
1145	};
1146	return do_create_ec_explicit_prime_params(bld, prime256v1_gen2,
1147	sizeof(prime256v1_gen2));
1148	}
1149
1150	# ifndef OPENSSL_NO_EC2M
1151	static int do_create_ec_explicit_trinomial_params(OSSL_PARAM_BLD *bld,
1152	const unsigned char *gen,
1153	size_t gen_len)
1154	{
1155	BIGNUM a, b, poly, order, *cofactor;
1156	/* sect233k1 characteristic-two-field tpBasis */
1157	static const unsigned char poly_data[] = {
1158	0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1159	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1160	0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1161	};
1162	static const unsigned char a_data[] = {
1163	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1164	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1165	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1166	};
1167	static const unsigned char b_data[] = {
1168	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1169	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1170	0x00, 0x00, 0x00, 0x00, 0x00, 0x01
1171	};
1172	static const unsigned char order_data[] = {
1173	0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1174	0x00, 0x00, 0x00, 0x06, 0x9D, 0x5B, 0xB9, 0x15, 0xBC, 0xD4, 0x6E, 0xFB,
1175	0x1A, 0xD5, 0xF1, 0x73, 0xAB, 0xDF
1176	};
1177	static const unsigned char cofactor_data[]= {
1178	0x4
1179	};
1180	return TEST_ptr(a = BN_CTX_get(bnctx))
1181	&& TEST_ptr(b = BN_CTX_get(bnctx))
1182	&& TEST_ptr(poly = BN_CTX_get(bnctx))
1183	&& TEST_ptr(order = BN_CTX_get(bnctx))
1184	&& TEST_ptr(cofactor = BN_CTX_get(bnctx))
1185	&& TEST_ptr(BN_bin2bn(poly_data, sizeof(poly_data), poly))
1186	&& TEST_ptr(BN_bin2bn(a_data, sizeof(a_data), a))
1187	&& TEST_ptr(BN_bin2bn(b_data, sizeof(b_data), b))
1188	&& TEST_ptr(BN_bin2bn(order_data, sizeof(order_data), order))
1189	&& TEST_ptr(BN_bin2bn(cofactor_data, sizeof(cofactor_data), cofactor))
1190	&& TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
1191	OSSL_PKEY_PARAM_EC_FIELD_TYPE,
1192	SN_X9_62_characteristic_two_field, 0))
1193	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_P, poly))
1194	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_A, a))
1195	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_B, b))
1196	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld,
1197	OSSL_PKEY_PARAM_EC_ORDER, order))
1198	&& TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
1199	OSSL_PKEY_PARAM_EC_GENERATOR, gen, gen_len))
1200	&& TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_EC_COFACTOR,
1201	cofactor));
1202	}
1203
1204	static int create_ec_explicit_trinomial_params_namedcurve(OSSL_PARAM_BLD *bld)
1205	{
1206	static const unsigned char gen[] = {
1207	0x04,
1208	0x01, 0x72, 0x32, 0xBA, 0x85, 0x3A, 0x7E, 0x73, 0x1A, 0xF1, 0x29, 0xF2,
1209	0x2F, 0xF4, 0x14, 0x95, 0x63, 0xA4, 0x19, 0xC2, 0x6B, 0xF5, 0x0A, 0x4C,
1210	0x9D, 0x6E, 0xEF, 0xAD, 0x61, 0x26,
1211	0x01, 0xDB, 0x53, 0x7D, 0xEC, 0xE8, 0x19, 0xB7, 0xF7, 0x0F, 0x55, 0x5A,
1212	0x67, 0xC4, 0x27, 0xA8, 0xCD, 0x9B, 0xF1, 0x8A, 0xEB, 0x9B, 0x56, 0xE0,
1213	0xC1, 0x10, 0x56, 0xFA, 0xE6, 0xA3
1214	};
1215	return do_create_ec_explicit_trinomial_params(bld, gen, sizeof(gen));
1216	}
1217
1218	static int create_ec_explicit_trinomial_params(OSSL_PARAM_BLD *bld)
1219	{
1220	static const unsigned char gen2[] = {
1221	0x04,
1222	0x00, 0xd7, 0xba, 0xd0, 0x26, 0x6c, 0x31, 0x6a, 0x78, 0x76, 0x01, 0xd1,
1223	0x32, 0x4b, 0x8f, 0x30, 0x29, 0x2d, 0x78, 0x30, 0xca, 0x43, 0xaa, 0xf0,
1224	0xa2, 0x5a, 0xd4, 0x0f, 0xb3, 0xf4,
1225	0x00, 0x85, 0x4b, 0x1b, 0x8d, 0x50, 0x10, 0xa5, 0x1c, 0x80, 0xf7, 0x86,
1226	0x40, 0x62, 0x4c, 0x87, 0xd1, 0x26, 0x7a, 0x9c, 0x5c, 0xe9, 0x82, 0x29,
1227	0xd1, 0x67, 0x70, 0x41, 0xea, 0xcb
1228	};
1229	return do_create_ec_explicit_trinomial_params(bld, gen2, sizeof(gen2));
1230	}
1231	# endif /* OPENSSL_NO_EC2M */
1232	#endif /* OPENSSL_NO_EC */
1233
1234	typedef enum OPTION_choice {
1235	OPT_ERR = -1,
1236	OPT_EOF = 0,
1237	OPT_CONTEXT,
1238	OPT_RSA_FILE,
1239	OPT_RSA_PSS_FILE,
1240	OPT_CONFIG_FILE,
1241	OPT_PROVIDER_NAME,
1242	OPT_TEST_ENUM
1243	} OPTION_CHOICE;
1244
1245	const OPTIONS *test_get_options(void)
1246	{
1247	static const OPTIONS options[] = {
1248	OPT_TEST_OPTIONS_DEFAULT_USAGE,
1249	{ "context", OPT_CONTEXT, '-',
1250	"Explicitly use a non-default library context" },
1251	{ "rsa", OPT_RSA_FILE, '<',
1252	"PEM format RSA key file to encode/decode" },
1253	{ "pss", OPT_RSA_PSS_FILE, '<',
1254	"PEM format RSA-PSS key file to encode/decode" },
1255	{ "config", OPT_CONFIG_FILE, '<',
1256	"The configuration file to use for the library context" },
1257	{ "provider", OPT_PROVIDER_NAME, 's',
1258	"The provider to load (The default value is 'default')" },
1259	{ NULL }
1260	};
1261	return options;
1262	}
1263
1264	int setup_tests(void)
1265	{
1266	const char *rsa_file = NULL;
1267	const char *rsa_pss_file = NULL;
1268	const char *prov_name = "default";
1269	char *config_file = NULL;
1270	int ok = 1;
1271
1272	#ifndef OPENSSL_NO_DSA
1273	static size_t qbits = 160; /* PVK only tolerates 160 Q bits */
1274	static size_t pbits = 1024; /* With 160 Q bits, we MUST use 1024 P bits */
1275	OSSL_PARAM DSA_params[] = {
1276	OSSL_PARAM_size_t("pbits", &pbits),
1277	OSSL_PARAM_size_t("qbits", &qbits),
1278	OSSL_PARAM_END
1279	};
1280	#endif
1281
1282	#ifndef OPENSSL_NO_EC
1283	static char groupname[] = "prime256v1";
1284	OSSL_PARAM EC_params[] = {
1285	OSSL_PARAM_utf8_string("group", groupname, sizeof(groupname) - 1),
1286	OSSL_PARAM_END
1287	};
1288	#endif
1289
1290	OPTION_CHOICE o;
1291
1292	while ((o = opt_next()) != OPT_EOF) {
1293	switch (o) {
1294	case OPT_CONTEXT:
1295	default_libctx = 0;
1296	break;
1297	case OPT_PROVIDER_NAME:
1298	prov_name = opt_arg();
1299	break;
1300	case OPT_CONFIG_FILE:
1301	config_file = opt_arg();
1302	break;
1303	case OPT_RSA_FILE:
1304	rsa_file = opt_arg();
1305	break;
1306	case OPT_RSA_PSS_FILE:
1307	rsa_pss_file = opt_arg();
1308	break;
1309	case OPT_TEST_CASES:
1310	break;
1311	default:
1312	return 0;
1313	}
1314	}
1315
1316	if (strcmp(prov_name, "fips") == 0)
1317	is_fips = 1;
1318
1319	if (default_libctx) {
1320	if (!test_get_libctx(NULL, NULL, config_file, &deflprov, prov_name))
1321	return 0;
1322	} else {
1323	if (!test_get_libctx(&testctx, &nullprov, config_file, &deflprov, prov_name))
1324	return 0;
1325	}
1326
1327	/* FIPS(3.0.0): provider imports explicit params but they won't work #17998 */
1328	is_fips_3_0_0 = fips_provider_version_eq(testctx, 3, 0, 0);
1329	if (is_fips_3_0_0 < 0)
1330	return 0;
1331
1332	#ifdef STATIC_LEGACY
1333	/*
1334	* This test is always statically linked against libcrypto. We must not
1335	* attempt to load legacy.so that might be dynamically linked against
1336	* libcrypto. Instead we use a built-in version of the legacy provider.
1337	*/
1338	if (!OSSL_PROVIDER_add_builtin(testctx, "legacy", ossl_legacy_provider_init))
1339	return 0;
1340	#endif
1341
1342	/* Separate provider/ctx for generating the test data */
1343	if (!TEST_ptr(keyctx = OSSL_LIB_CTX_new()))
1344	return 0;
1345	if (!TEST_ptr(keyprov = OSSL_PROVIDER_load(keyctx, "default")))
1346	return 0;
1347
1348	#ifndef OPENSSL_NO_EC
1349	if (!TEST_ptr(bnctx = BN_CTX_new_ex(testctx))
1350	\|\| !TEST_ptr(bld_prime_nc = OSSL_PARAM_BLD_new())
1351	\|\| !TEST_ptr(bld_prime = OSSL_PARAM_BLD_new())
1352	\|\| !create_ec_explicit_prime_params_namedcurve(bld_prime_nc)
1353	\|\| !create_ec_explicit_prime_params(bld_prime)
1354	\|\| !TEST_ptr(ec_explicit_prime_params_nc = OSSL_PARAM_BLD_to_param(bld_prime_nc))
1355	\|\| !TEST_ptr(ec_explicit_prime_params_explicit = OSSL_PARAM_BLD_to_param(bld_prime))
1356	# ifndef OPENSSL_NO_EC2M
1357	\|\| !TEST_ptr(bld_tri_nc = OSSL_PARAM_BLD_new())
1358	\|\| !TEST_ptr(bld_tri = OSSL_PARAM_BLD_new())
1359	\|\| !create_ec_explicit_trinomial_params_namedcurve(bld_tri_nc)
1360	\|\| !create_ec_explicit_trinomial_params(bld_tri)
1361	\|\| !TEST_ptr(ec_explicit_tri_params_nc = OSSL_PARAM_BLD_to_param(bld_tri_nc))
1362	\|\| !TEST_ptr(ec_explicit_tri_params_explicit = OSSL_PARAM_BLD_to_param(bld_tri))
1363	# endif
1364	)
1365	return 0;
1366	#endif
1367
1368	TEST_info("Generating keys...");
1369
1370	#ifndef OPENSSL_NO_DH
1371	TEST_info("Generating DH keys...");
1372	MAKE_DOMAIN_KEYS(DH, "DH", NULL);
1373	MAKE_DOMAIN_KEYS(DHX, "X9.42 DH", NULL);
1374	#endif
1375	#ifndef OPENSSL_NO_DSA
1376	TEST_info("Generating DSA keys...");
1377	MAKE_DOMAIN_KEYS(DSA, "DSA", DSA_params);
1378	#endif
1379	#ifndef OPENSSL_NO_EC
1380	TEST_info("Generating EC keys...");
1381	MAKE_DOMAIN_KEYS(EC, "EC", EC_params);
1382	MAKE_DOMAIN_KEYS(ECExplicitPrimeNamedCurve, "EC", ec_explicit_prime_params_nc);
1383	MAKE_DOMAIN_KEYS(ECExplicitPrime2G, "EC", ec_explicit_prime_params_explicit);
1384	# ifndef OPENSSL_NO_EC2M
1385	MAKE_DOMAIN_KEYS(ECExplicitTriNamedCurve, "EC", ec_explicit_tri_params_nc);
1386	MAKE_DOMAIN_KEYS(ECExplicitTri2G, "EC", ec_explicit_tri_params_explicit);
1387	# endif
1388	MAKE_KEYS(ED25519, "ED25519", NULL);
1389	MAKE_KEYS(ED448, "ED448", NULL);
1390	MAKE_KEYS(X25519, "X25519", NULL);
1391	MAKE_KEYS(X448, "X448", NULL);
1392	#endif
1393	TEST_info("Loading RSA key...");
1394	ok = ok && TEST_ptr(key_RSA = load_pkey_pem(rsa_file, keyctx));
1395	TEST_info("Loading RSA_PSS key...");
1396	ok = ok && TEST_ptr(key_RSA_PSS = load_pkey_pem(rsa_pss_file, keyctx));
1397	TEST_info("Generating keys done");
1398
1399	if (ok) {
1400	#ifndef OPENSSL_NO_DH
1401	ADD_TEST_SUITE(DH);
1402	ADD_TEST_SUITE_PARAMS(DH);
1403	ADD_TEST_SUITE(DHX);
1404	ADD_TEST_SUITE_PARAMS(DHX);
1405	/*
1406	* DH has no support for PEM_write_bio_PrivateKey_traditional(),
1407	* so no legacy tests.
1408	*/
1409	#endif
1410	#ifndef OPENSSL_NO_DSA
1411	ADD_TEST_SUITE(DSA);
1412	ADD_TEST_SUITE_PARAMS(DSA);
1413	ADD_TEST_SUITE_LEGACY(DSA);
1414	ADD_TEST_SUITE_MSBLOB(DSA);
1415	ADD_TEST_SUITE_UNPROTECTED_PVK(DSA);
1416	# ifndef OPENSSL_NO_RC4
1417	ADD_TEST_SUITE_PROTECTED_PVK(DSA);
1418	# endif
1419	#endif
1420	#ifndef OPENSSL_NO_EC
1421	ADD_TEST_SUITE(EC);
1422	ADD_TEST_SUITE_PARAMS(EC);
1423	ADD_TEST_SUITE_LEGACY(EC);
1424	ADD_TEST_SUITE(ECExplicitPrimeNamedCurve);
1425	ADD_TEST_SUITE_LEGACY(ECExplicitPrimeNamedCurve);
1426	ADD_TEST_SUITE(ECExplicitPrime2G);
1427	ADD_TEST_SUITE_LEGACY(ECExplicitPrime2G);
1428	# ifndef OPENSSL_NO_EC2M
1429	ADD_TEST_SUITE(ECExplicitTriNamedCurve);
1430	ADD_TEST_SUITE_LEGACY(ECExplicitTriNamedCurve);
1431	ADD_TEST_SUITE(ECExplicitTri2G);
1432	ADD_TEST_SUITE_LEGACY(ECExplicitTri2G);
1433	# endif
1434	ADD_TEST_SUITE(ED25519);
1435	ADD_TEST_SUITE(ED448);
1436	ADD_TEST_SUITE(X25519);
1437	ADD_TEST_SUITE(X448);
1438	/*
1439	* ED25519, ED448, X25519 and X448 have no support for
1440	* PEM_write_bio_PrivateKey_traditional(), so no legacy tests.
1441	*/
1442	#endif
1443	ADD_TEST_SUITE(RSA);
1444	ADD_TEST_SUITE_LEGACY(RSA);
1445	ADD_TEST_SUITE(RSA_PSS);
1446	/*
1447	* RSA-PSS has no support for PEM_write_bio_PrivateKey_traditional(),
1448	* so no legacy tests.
1449	*/
1450	ADD_TEST_SUITE_MSBLOB(RSA);
1451	ADD_TEST_SUITE_UNPROTECTED_PVK(RSA);
1452	# ifndef OPENSSL_NO_RC4
1453	ADD_TEST_SUITE_PROTECTED_PVK(RSA);
1454	# endif
1455	}
1456
1457	return 1;
1458	}
1459
1460	void cleanup_tests(void)
1461	{
1462	#ifndef OPENSSL_NO_EC
1463	OSSL_PARAM_free(ec_explicit_prime_params_nc);
1464	OSSL_PARAM_free(ec_explicit_prime_params_explicit);
1465	OSSL_PARAM_BLD_free(bld_prime_nc);
1466	OSSL_PARAM_BLD_free(bld_prime);
1467	# ifndef OPENSSL_NO_EC2M
1468	OSSL_PARAM_free(ec_explicit_tri_params_nc);
1469	OSSL_PARAM_free(ec_explicit_tri_params_explicit);
1470	OSSL_PARAM_BLD_free(bld_tri_nc);
1471	OSSL_PARAM_BLD_free(bld_tri);
1472	# endif
1473	BN_CTX_free(bnctx);
1474	#endif /* OPENSSL_NO_EC */
1475
1476	#ifndef OPENSSL_NO_DH
1477	FREE_DOMAIN_KEYS(DH);
1478	FREE_DOMAIN_KEYS(DHX);
1479	#endif
1480	#ifndef OPENSSL_NO_DSA
1481	FREE_DOMAIN_KEYS(DSA);
1482	#endif
1483	#ifndef OPENSSL_NO_EC
1484	FREE_DOMAIN_KEYS(EC);
1485	FREE_DOMAIN_KEYS(ECExplicitPrimeNamedCurve);
1486	FREE_DOMAIN_KEYS(ECExplicitPrime2G);
1487	# ifndef OPENSSL_NO_EC2M
1488	FREE_DOMAIN_KEYS(ECExplicitTriNamedCurve);
1489	FREE_DOMAIN_KEYS(ECExplicitTri2G);
1490	# endif
1491	FREE_KEYS(ED25519);
1492	FREE_KEYS(ED448);
1493	FREE_KEYS(X25519);
1494	FREE_KEYS(X448);
1495	#endif
1496	FREE_KEYS(RSA);
1497	FREE_KEYS(RSA_PSS);
1498
1499	OSSL_PROVIDER_unload(nullprov);
1500	OSSL_PROVIDER_unload(deflprov);
1501	OSSL_PROVIDER_unload(keyprov);
1502	OSSL_LIB_CTX_free(testctx);
1503	OSSL_LIB_CTX_free(keyctx);
1504	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.1.0/test/endecode_test.c@ 100832

Download in other formats: