endecode_test.c@ 95218

最後變更在這個檔案從95218是 94320,由 vboxsync 提交於 3 年前
libs/openssl-3.0.1: Export to OSE and fix copyright headers in Makefiles, bugref:10128
檔案大小: 56.1 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.0.3/test/endecode_test.c@ 95218

以其他格式下載: