encode_key2any.c@ 101021

Last change on this file since 101021 was 101021, checked in by vboxsync, 18 months ago
openssl-3.1.2: Applied and adjusted our OpenSSL changes to 3.1.0. bugref:10519
File size: 53.3 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	/*
11	* Low level APIs are deprecated for public use, but still ok for internal use.
12	*/
13	#include "internal/deprecated.h"
14
15	#include <openssl/core.h>
16	#include <openssl/core_dispatch.h>
17	#include <openssl/core_names.h>
18	#include <openssl/crypto.h>
19	#include <openssl/params.h>
20	#include <openssl/asn1.h>
21	#include <openssl/err.h>
22	#include <openssl/pem.h>
23	#include <openssl/x509.h>
24	#include <openssl/pkcs12.h> /* PKCS8_encrypt() */
25	#include <openssl/dh.h>
26	#include <openssl/dsa.h>
27	#include <openssl/ec.h>
28	#include <openssl/proverr.h>
29	#include "internal/passphrase.h"
30	#include "internal/cryptlib.h"
31	#include "crypto/ecx.h"
32	#include "crypto/rsa.h"
33	#include "prov/implementations.h"
34	#include "prov/bio.h"
35	#include "prov/provider_ctx.h"
36	#include "prov/der_rsa.h"
37	#include "endecoder_local.h"
38
39	#if defined(OPENSSL_NO_DH) && defined(OPENSSL_NO_DSA) && defined(OPENSSL_NO_EC)
40	# define OPENSSL_NO_KEYPARAMS
41	#endif
42
43	struct key2any_ctx_st {
44	PROV_CTX *provctx;
45
46	/* Set to 0 if parameters should not be saved (dsa only) */
47	int save_parameters;
48
49	/* Set to 1 if intending to encrypt/decrypt, otherwise 0 */
50	int cipher_intent;
51
52	EVP_CIPHER *cipher;
53
54	struct ossl_passphrase_data_st pwdata;
55	};
56
57	typedef int check_key_type_fn(const void *key, int nid);
58	typedef int key_to_paramstring_fn(const void *key, int nid, int save,
59	void *str, int strtype);
60	typedef int key_to_der_fn(BIO out, const void key,
61	int key_nid, const char *pemname,
62	key_to_paramstring_fn p2s, i2d_of_void k2d,
63	struct key2any_ctx_st *ctx);
64	typedef int write_bio_of_void_fn(BIO bp, const void x);
65
66
67	/* Free the blob allocated during key_to_paramstring_fn */
68	static void free_asn1_data(int type, void *data)
69	{
70	switch(type) {
71	case V_ASN1_OBJECT:
72	ASN1_OBJECT_free(data);
73	break;
74	case V_ASN1_SEQUENCE:
75	ASN1_STRING_free(data);
76	break;
77	}
78	}
79
80	static PKCS8_PRIV_KEY_INFO key_to_p8info(const void key, int key_nid,
81	void *params, int params_type,
82	i2d_of_void *k2d)
83	{
84	/* der, derlen store the key DER output and its length */
85	unsigned char *der = NULL;
86	int derlen;
87	/* The final PKCS#8 info */
88	PKCS8_PRIV_KEY_INFO *p8info = NULL;
89
90	if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
91	\|\| (derlen = k2d(key, &der)) <= 0
92	\|\| !PKCS8_pkey_set0(p8info, OBJ_nid2obj(key_nid), 0,
93	params_type, params, der, derlen)) {
94	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
95	PKCS8_PRIV_KEY_INFO_free(p8info);
96	OPENSSL_free(der);
97	p8info = NULL;
98	}
99
100	return p8info;
101	}
102
103	static X509_SIG p8info_to_encp8(PKCS8_PRIV_KEY_INFO p8info,
104	struct key2any_ctx_st *ctx)
105	{
106	X509_SIG *p8 = NULL;
107	char kstr[PEM_BUFSIZE];
108	size_t klen = 0;
109	OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(ctx->provctx);
110
111	if (ctx->cipher == NULL)
112	return NULL;
113
114	if (!ossl_pw_get_passphrase(kstr, sizeof(kstr), &klen, NULL, 1,
115	&ctx->pwdata)) {
116	ERR_raise(ERR_LIB_PROV, PROV_R_UNABLE_TO_GET_PASSPHRASE);
117	return NULL;
118	}
119	/* First argument == -1 means "standard" */
120	p8 = PKCS8_encrypt_ex(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info, libctx, NULL);
121	OPENSSL_cleanse(kstr, klen);
122	return p8;
123	}
124
125	static X509_SIG key_to_encp8(const void key, int key_nid,
126	void *params, int params_type,
127	i2d_of_void k2d, struct key2any_ctx_st ctx)
128	{
129	PKCS8_PRIV_KEY_INFO *p8info =
130	key_to_p8info(key, key_nid, params, params_type, k2d);
131	X509_SIG *p8 = NULL;
132
133	if (p8info == NULL) {
134	free_asn1_data(params_type, params);
135	} else {
136	p8 = p8info_to_encp8(p8info, ctx);
137	PKCS8_PRIV_KEY_INFO_free(p8info);
138	}
139	return p8;
140	}
141
142	static X509_PUBKEY key_to_pubkey(const void key, int key_nid,
143	void *params, int params_type,
144	i2d_of_void k2d)
145	{
146	/* der, derlen store the key DER output and its length */
147	unsigned char *der = NULL;
148	int derlen;
149	/* The final X509_PUBKEY */
150	X509_PUBKEY *xpk = NULL;
151
152
153	if ((xpk = X509_PUBKEY_new()) == NULL
154	\|\| (derlen = k2d(key, &der)) <= 0
155	\|\| !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(key_nid),
156	params_type, params, der, derlen)) {
157	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
158	X509_PUBKEY_free(xpk);
159	OPENSSL_free(der);
160	xpk = NULL;
161	}
162
163	return xpk;
164	}
165
166	/*
167	* key_to_epki_* produce encoded output with the private key data in a
168	* EncryptedPrivateKeyInfo structure (defined by PKCS#8). They require
169	* that there's an intent to encrypt, anything else is an error.
170	*
171	* key_to_pki_* primarily produce encoded output with the private key data
172	* in a PrivateKeyInfo structure (also defined by PKCS#8). However, if
173	* there is an intent to encrypt the data, the corresponding key_to_epki_*
174	* function is used instead.
175	*
176	* key_to_spki_* produce encoded output with the public key data in an
177	* X.509 SubjectPublicKeyInfo.
178	*
179	* Key parameters don't have any defined envelopment of this kind, but are
180	* included in some manner in the output from the functions described above,
181	* either in the AlgorithmIdentifier's parameter field, or as part of the
182	* key data itself.
183	*/
184
185	static int key_to_epki_der_priv_bio(BIO out, const void key,
186	int key_nid,
187	ossl_unused const char *pemname,
188	key_to_paramstring_fn *p2s,
189	i2d_of_void *k2d,
190	struct key2any_ctx_st *ctx)
191	{
192	int ret = 0;
193	void *str = NULL;
194	int strtype = V_ASN1_UNDEF;
195	X509_SIG *p8;
196
197	if (!ctx->cipher_intent)
198	return 0;
199
200	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
201	&str, &strtype))
202	return 0;
203
204	p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
205	if (p8 != NULL)
206	ret = i2d_PKCS8_bio(out, p8);
207
208	X509_SIG_free(p8);
209
210	return ret;
211	}
212
213	static int key_to_epki_pem_priv_bio(BIO out, const void key,
214	int key_nid,
215	ossl_unused const char *pemname,
216	key_to_paramstring_fn *p2s,
217	i2d_of_void *k2d,
218	struct key2any_ctx_st *ctx)
219	{
220	int ret = 0;
221	void *str = NULL;
222	int strtype = V_ASN1_UNDEF;
223	X509_SIG *p8;
224
225	if (!ctx->cipher_intent)
226	return 0;
227
228	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
229	&str, &strtype))
230	return 0;
231
232	p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
233	if (p8 != NULL)
234	ret = PEM_write_bio_PKCS8(out, p8);
235
236	X509_SIG_free(p8);
237
238	return ret;
239	}
240
241	static int key_to_pki_der_priv_bio(BIO out, const void key,
242	int key_nid,
243	ossl_unused const char *pemname,
244	key_to_paramstring_fn *p2s,
245	i2d_of_void *k2d,
246	struct key2any_ctx_st *ctx)
247	{
248	int ret = 0;
249	void *str = NULL;
250	int strtype = V_ASN1_UNDEF;
251	PKCS8_PRIV_KEY_INFO *p8info;
252
253	if (ctx->cipher_intent)
254	return key_to_epki_der_priv_bio(out, key, key_nid, pemname,
255	p2s, k2d, ctx);
256
257	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
258	&str, &strtype))
259	return 0;
260
261	p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
262
263	if (p8info != NULL)
264	ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);
265	else
266	free_asn1_data(strtype, str);
267
268	PKCS8_PRIV_KEY_INFO_free(p8info);
269
270	return ret;
271	}
272
273	static int key_to_pki_pem_priv_bio(BIO out, const void key,
274	int key_nid,
275	ossl_unused const char *pemname,
276	key_to_paramstring_fn *p2s,
277	i2d_of_void *k2d,
278	struct key2any_ctx_st *ctx)
279	{
280	int ret = 0;
281	void *str = NULL;
282	int strtype = V_ASN1_UNDEF;
283	PKCS8_PRIV_KEY_INFO *p8info;
284
285	if (ctx->cipher_intent)
286	return key_to_epki_pem_priv_bio(out, key, key_nid, pemname,
287	p2s, k2d, ctx);
288
289	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
290	&str, &strtype))
291	return 0;
292
293	p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
294
295	if (p8info != NULL)
296	ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);
297	else
298	free_asn1_data(strtype, str);
299
300	PKCS8_PRIV_KEY_INFO_free(p8info);
301
302	return ret;
303	}
304
305	static int key_to_spki_der_pub_bio(BIO out, const void key,
306	int key_nid,
307	ossl_unused const char *pemname,
308	key_to_paramstring_fn *p2s,
309	i2d_of_void *k2d,
310	struct key2any_ctx_st *ctx)
311	{
312	int ret = 0;
313	void *str = NULL;
314	int strtype = V_ASN1_UNDEF;
315	X509_PUBKEY *xpk = NULL;
316
317	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
318	&str, &strtype))
319	return 0;
320
321	xpk = key_to_pubkey(key, key_nid, str, strtype, k2d);
322
323	if (xpk != NULL)
324	ret = i2d_X509_PUBKEY_bio(out, xpk);
325
326	/* Also frees \|str\| */
327	X509_PUBKEY_free(xpk);
328	return ret;
329	}
330
331	static int key_to_spki_pem_pub_bio(BIO out, const void key,
332	int key_nid,
333	ossl_unused const char *pemname,
334	key_to_paramstring_fn *p2s,
335	i2d_of_void *k2d,
336	struct key2any_ctx_st *ctx)
337	{
338	int ret = 0;
339	void *str = NULL;
340	int strtype = V_ASN1_UNDEF;
341	X509_PUBKEY *xpk = NULL;
342
343	if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
344	&str, &strtype))
345	return 0;
346
347	xpk = key_to_pubkey(key, key_nid, str, strtype, k2d);
348
349	if (xpk != NULL)
350	ret = PEM_write_bio_X509_PUBKEY(out, xpk);
351	else
352	free_asn1_data(strtype, str);
353
354	/* Also frees \|str\| */
355	X509_PUBKEY_free(xpk);
356	return ret;
357	}
358
359	/*
360	* key_to_type_specific_* produce encoded output with type specific key data,
361	* no envelopment; the same kind of output as the type specific i2d_ and
362	* PEM_write_ functions, which is often a simple SEQUENCE of INTEGER.
363	*
364	* OpenSSL tries to discourage production of new keys in this form, because
365	* of the ambiguity when trying to recognise them, but can't deny that PKCS#1
366	* et al still are live standards.
367	*
368	* Note that these functions completely ignore p2s, and rather rely entirely
369	* on k2d to do the complete work.
370	*/
371	static int key_to_type_specific_der_bio(BIO out, const void key,
372	int key_nid,
373	ossl_unused const char *pemname,
374	key_to_paramstring_fn *p2s,
375	i2d_of_void *k2d,
376	struct key2any_ctx_st *ctx)
377	{
378	unsigned char *der = NULL;
379	int derlen;
380	int ret;
381
382	if ((derlen = k2d(key, &der)) <= 0) {
383	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
384	return 0;
385	}
386
387	ret = BIO_write(out, der, derlen);
388	OPENSSL_free(der);
389	return ret > 0;
390	}
391	#define key_to_type_specific_der_priv_bio key_to_type_specific_der_bio
392	#define key_to_type_specific_der_pub_bio key_to_type_specific_der_bio
393	#define key_to_type_specific_der_param_bio key_to_type_specific_der_bio
394
395	static int key_to_type_specific_pem_bio_cb(BIO out, const void key,
396	int key_nid, const char *pemname,
397	key_to_paramstring_fn *p2s,
398	i2d_of_void *k2d,
399	struct key2any_ctx_st *ctx,
400	pem_password_cb cb, void cbarg)
401	{
402	return
403	PEM_ASN1_write_bio(k2d, pemname, out, key, ctx->cipher,
404	NULL, 0, cb, cbarg) > 0;
405	}
406
407	static int key_to_type_specific_pem_priv_bio(BIO out, const void key,
408	int key_nid, const char *pemname,
409	key_to_paramstring_fn *p2s,
410	i2d_of_void *k2d,
411	struct key2any_ctx_st *ctx)
412	{
413	return key_to_type_specific_pem_bio_cb(out, key, key_nid, pemname,
414	p2s, k2d, ctx,
415	ossl_pw_pem_password, &ctx->pwdata);
416	}
417
418	static int key_to_type_specific_pem_pub_bio(BIO out, const void key,
419	int key_nid, const char *pemname,
420	key_to_paramstring_fn *p2s,
421	i2d_of_void *k2d,
422	struct key2any_ctx_st *ctx)
423	{
424	return key_to_type_specific_pem_bio_cb(out, key, key_nid, pemname,
425	p2s, k2d, ctx, NULL, NULL);
426	}
427
428	#ifndef OPENSSL_NO_KEYPARAMS
429	static int key_to_type_specific_pem_param_bio(BIO out, const void key,
430	int key_nid, const char *pemname,
431	key_to_paramstring_fn *p2s,
432	i2d_of_void *k2d,
433	struct key2any_ctx_st *ctx)
434	{
435	return key_to_type_specific_pem_bio_cb(out, key, key_nid, pemname,
436	p2s, k2d, ctx, NULL, NULL);
437	}
438	#endif
439
440	/* ---------------------------------------------------------------------- */
441
442	#ifndef OPENSSL_NO_DH
443	static int prepare_dh_params(const void *dh, int nid, int save,
444	void *pstr, int pstrtype)
445	{
446	ASN1_STRING *params = ASN1_STRING_new();
447
448	if (params == NULL) {
449	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
450	return 0;
451	}
452
453	if (nid == EVP_PKEY_DHX)
454	params->length = i2d_DHxparams(dh, &params->data);
455	else
456	params->length = i2d_DHparams(dh, &params->data);
457
458	if (params->length <= 0) {
459	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
460	ASN1_STRING_free(params);
461	return 0;
462	}
463	params->type = V_ASN1_SEQUENCE;
464
465	*pstr = params;
466	*pstrtype = V_ASN1_SEQUENCE;
467	return 1;
468	}
469
470	static int dh_spki_pub_to_der(const void dh, unsigned char *pder)
471	{
472	const BIGNUM *bn = NULL;
473	ASN1_INTEGER *pub_key = NULL;
474	int ret;
475
476	if ((bn = DH_get0_pub_key(dh)) == NULL) {
477	ERR_raise(ERR_LIB_PROV, PROV_R_NOT_A_PUBLIC_KEY);
478	return 0;
479	}
480	if ((pub_key = BN_to_ASN1_INTEGER(bn, NULL)) == NULL) {
481	ERR_raise(ERR_LIB_PROV, PROV_R_BN_ERROR);
482	return 0;
483	}
484
485	ret = i2d_ASN1_INTEGER(pub_key, pder);
486
487	ASN1_STRING_clear_free(pub_key);
488	return ret;
489	}
490
491	static int dh_pki_priv_to_der(const void dh, unsigned char *pder)
492	{
493	const BIGNUM *bn = NULL;
494	ASN1_INTEGER *priv_key = NULL;
495	int ret;
496
497	if ((bn = DH_get0_priv_key(dh)) == NULL) {
498	ERR_raise(ERR_LIB_PROV, PROV_R_NOT_A_PRIVATE_KEY);
499	return 0;
500	}
501	if ((priv_key = BN_to_ASN1_INTEGER(bn, NULL)) == NULL) {
502	ERR_raise(ERR_LIB_PROV, PROV_R_BN_ERROR);
503	return 0;
504	}
505
506	ret = i2d_ASN1_INTEGER(priv_key, pder);
507
508	ASN1_STRING_clear_free(priv_key);
509	return ret;
510	}
511
512	# define dh_epki_priv_to_der dh_pki_priv_to_der
513
514	static int dh_type_specific_params_to_der(const void dh, unsigned char *pder)
515	{
516	if (DH_test_flags(dh, DH_FLAG_TYPE_DHX))
517	return i2d_DHxparams(dh, pder);
518	return i2d_DHparams(dh, pder);
519	}
520
521	/*
522	* DH doesn't have i2d_DHPrivateKey or i2d_DHPublicKey, so we can't make
523	* corresponding functions here.
524	*/
525	# define dh_type_specific_priv_to_der NULL
526	# define dh_type_specific_pub_to_der NULL
527
528	static int dh_check_key_type(const void *dh, int expected_type)
529	{
530	int type =
531	DH_test_flags(dh, DH_FLAG_TYPE_DHX) ? EVP_PKEY_DHX : EVP_PKEY_DH;
532
533	return type == expected_type;
534	}
535
536	# define dh_evp_type EVP_PKEY_DH
537	# define dhx_evp_type EVP_PKEY_DHX
538	# define dh_input_type "DH"
539	# define dhx_input_type "DHX"
540	# define dh_pem_type "DH"
541	# define dhx_pem_type "X9.42 DH"
542	#endif
543
544	/* ---------------------------------------------------------------------- */
545
546	#ifndef OPENSSL_NO_DSA
547	static int encode_dsa_params(const void *dsa, int nid,
548	void *pstr, int pstrtype)
549	{
550	ASN1_STRING *params = ASN1_STRING_new();
551
552	if (params == NULL) {
553	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
554	return 0;
555	}
556
557	params->length = i2d_DSAparams(dsa, &params->data);
558
559	if (params->length <= 0) {
560	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
561	ASN1_STRING_free(params);
562	return 0;
563	}
564
565	*pstrtype = V_ASN1_SEQUENCE;
566	*pstr = params;
567	return 1;
568	}
569
570	static int prepare_dsa_params(const void *dsa, int nid, int save,
571	void *pstr, int pstrtype)
572	{
573	const BIGNUM *p = DSA_get0_p(dsa);
574	const BIGNUM *q = DSA_get0_q(dsa);
575	const BIGNUM *g = DSA_get0_g(dsa);
576
577	if (save && p != NULL && q != NULL && g != NULL)
578	return encode_dsa_params(dsa, nid, pstr, pstrtype);
579
580	*pstr = NULL;
581	*pstrtype = V_ASN1_UNDEF;
582	return 1;
583	}
584
585	static int dsa_spki_pub_to_der(const void dsa, unsigned char *pder)
586	{
587	const BIGNUM *bn = NULL;
588	ASN1_INTEGER *pub_key = NULL;
589	int ret;
590
591	if ((bn = DSA_get0_pub_key(dsa)) == NULL) {
592	ERR_raise(ERR_LIB_PROV, PROV_R_NOT_A_PUBLIC_KEY);
593	return 0;
594	}
595	if ((pub_key = BN_to_ASN1_INTEGER(bn, NULL)) == NULL) {
596	ERR_raise(ERR_LIB_PROV, PROV_R_BN_ERROR);
597	return 0;
598	}
599
600	ret = i2d_ASN1_INTEGER(pub_key, pder);
601
602	ASN1_STRING_clear_free(pub_key);
603	return ret;
604	}
605
606	static int dsa_pki_priv_to_der(const void dsa, unsigned char *pder)
607	{
608	const BIGNUM *bn = NULL;
609	ASN1_INTEGER *priv_key = NULL;
610	int ret;
611
612	if ((bn = DSA_get0_priv_key(dsa)) == NULL) {
613	ERR_raise(ERR_LIB_PROV, PROV_R_NOT_A_PRIVATE_KEY);
614	return 0;
615	}
616	if ((priv_key = BN_to_ASN1_INTEGER(bn, NULL)) == NULL) {
617	ERR_raise(ERR_LIB_PROV, PROV_R_BN_ERROR);
618	return 0;
619	}
620
621	ret = i2d_ASN1_INTEGER(priv_key, pder);
622
623	ASN1_STRING_clear_free(priv_key);
624	return ret;
625	}
626
627	# define dsa_epki_priv_to_der dsa_pki_priv_to_der
628
629	# define dsa_type_specific_priv_to_der (i2d_of_void *)i2d_DSAPrivateKey
630	# define dsa_type_specific_pub_to_der (i2d_of_void *)i2d_DSAPublicKey
631	# define dsa_type_specific_params_to_der (i2d_of_void *)i2d_DSAparams
632
633	# define dsa_check_key_type NULL
634	# define dsa_evp_type EVP_PKEY_DSA
635	# define dsa_input_type "DSA"
636	# define dsa_pem_type "DSA"
637	#endif
638
639	/* ---------------------------------------------------------------------- */
640
641	#ifndef OPENSSL_NO_EC
642	static int prepare_ec_explicit_params(const void *eckey,
643	void *pstr, int pstrtype)
644	{
645	ASN1_STRING *params = ASN1_STRING_new();
646
647	if (params == NULL) {
648	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
649	return 0;
650	}
651
652	params->length = i2d_ECParameters(eckey, &params->data);
653	if (params->length <= 0) {
654	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
655	ASN1_STRING_free(params);
656	return 0;
657	}
658
659	*pstrtype = V_ASN1_SEQUENCE;
660	*pstr = params;
661	return 1;
662	}
663
664	/*
665	* This implements EcpkParameters, where the CHOICE is based on whether there
666	* is a curve name (curve nid) to be found or not. See RFC 3279 for details.
667	*/
668	static int prepare_ec_params(const void *eckey, int nid, int save,
669	void *pstr, int pstrtype)
670	{
671	int curve_nid;
672	const EC_GROUP *group = EC_KEY_get0_group(eckey);
673	ASN1_OBJECT *params = NULL;
674
675	if (group == NULL)
676	return 0;
677	curve_nid = EC_GROUP_get_curve_name(group);
678	if (curve_nid != NID_undef) {
679	params = OBJ_nid2obj(curve_nid);
680	if (params == NULL)
681	return 0;
682	}
683
684	if (curve_nid != NID_undef
685	&& (EC_GROUP_get_asn1_flag(group) & OPENSSL_EC_NAMED_CURVE)) {
686	/* The CHOICE came to namedCurve */
687	if (OBJ_length(params) == 0) {
688	/* Some curves might not have an associated OID */
689	ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_OID);
690	ASN1_OBJECT_free(params);
691	return 0;
692	}
693	*pstr = params;
694	*pstrtype = V_ASN1_OBJECT;
695	return 1;
696	} else {
697	/* The CHOICE came to ecParameters */
698	return prepare_ec_explicit_params(eckey, pstr, pstrtype);
699	}
700	}
701
702	static int ec_spki_pub_to_der(const void eckey, unsigned char *pder)
703	{
704	if (EC_KEY_get0_public_key(eckey) == NULL) {
705	ERR_raise(ERR_LIB_PROV, PROV_R_NOT_A_PUBLIC_KEY);
706	return 0;
707	}
708	return i2o_ECPublicKey(eckey, pder);
709	}
710
711	static int ec_pki_priv_to_der(const void veckey, unsigned char *pder)
712	{
713	EC_KEY eckey = (EC_KEY )veckey;
714	unsigned int old_flags;
715	int ret = 0;
716
717	/*
718	* For PKCS8 the curve name appears in the PKCS8_PRIV_KEY_INFO object
719	* as the pkeyalg->parameter field. (For a named curve this is an OID)
720	* The pkey field is an octet string that holds the encoded
721	* ECPrivateKey SEQUENCE with the optional parameters field omitted.
722	* We omit this by setting the EC_PKEY_NO_PARAMETERS flag.
723	*/
724	old_flags = EC_KEY_get_enc_flags(eckey); /* save old flags */
725	EC_KEY_set_enc_flags(eckey, old_flags \| EC_PKEY_NO_PARAMETERS);
726	ret = i2d_ECPrivateKey(eckey, pder);
727	EC_KEY_set_enc_flags(eckey, old_flags); /* restore old flags */
728	return ret; /* return the length of the der encoded data */
729	}
730
731	# define ec_epki_priv_to_der ec_pki_priv_to_der
732
733	# define ec_type_specific_params_to_der (i2d_of_void *)i2d_ECParameters
734	/* No ec_type_specific_pub_to_der, there simply is no such thing */
735	# define ec_type_specific_priv_to_der (i2d_of_void *)i2d_ECPrivateKey
736
737	# define ec_check_key_type NULL
738	# define ec_evp_type EVP_PKEY_EC
739	# define ec_input_type "EC"
740	# define ec_pem_type "EC"
741
742	# ifndef OPENSSL_NO_SM2
743	# define sm2_evp_type EVP_PKEY_SM2
744	# define sm2_input_type "SM2"
745	# define sm2_pem_type "SM2"
746	# endif
747	#endif
748
749	/* ---------------------------------------------------------------------- */
750
751	#ifndef OPENSSL_NO_EC
752	# define prepare_ecx_params NULL
753
754	static int ecx_spki_pub_to_der(const void vecxkey, unsigned char *pder)
755	{
756	const ECX_KEY *ecxkey = vecxkey;
757	unsigned char *keyblob;
758
759	if (ecxkey == NULL) {
760	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_NULL_PARAMETER);
761	return 0;
762	}
763
764	keyblob = OPENSSL_memdup(ecxkey->pubkey, ecxkey->keylen);
765	if (keyblob == NULL) {
766	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
767	return 0;
768	}
769
770	*pder = keyblob;
771	return ecxkey->keylen;
772	}
773
774	static int ecx_pki_priv_to_der(const void vecxkey, unsigned char *pder)
775	{
776	const ECX_KEY *ecxkey = vecxkey;
777	ASN1_OCTET_STRING oct;
778	int keybloblen;
779
780	if (ecxkey == NULL \|\| ecxkey->privkey == NULL) {
781	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_NULL_PARAMETER);
782	return 0;
783	}
784
785	oct.data = ecxkey->privkey;
786	oct.length = ecxkey->keylen;
787	oct.flags = 0;
788
789	keybloblen = i2d_ASN1_OCTET_STRING(&oct, pder);
790	if (keybloblen < 0) {
791	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
792	return 0;
793	}
794
795	return keybloblen;
796	}
797
798	# define ecx_epki_priv_to_der ecx_pki_priv_to_der
799
800	/*
801	* ED25519, ED448, X25519 and X448 only has PKCS#8 / SubjectPublicKeyInfo
802	* representation, so we don't define ecx_type_specific_[priv,pub,params]_to_der.
803	*/
804
805	# define ecx_check_key_type NULL
806
807	# define ed25519_evp_type EVP_PKEY_ED25519
808	# define ed448_evp_type EVP_PKEY_ED448
809	# define x25519_evp_type EVP_PKEY_X25519
810	# define x448_evp_type EVP_PKEY_X448
811	# define ed25519_input_type "ED25519"
812	# define ed448_input_type "ED448"
813	# define x25519_input_type "X25519"
814	# define x448_input_type "X448"
815	# define ed25519_pem_type "ED25519"
816	# define ed448_pem_type "ED448"
817	# define x25519_pem_type "X25519"
818	# define x448_pem_type "X448"
819	#endif
820
821	/* ---------------------------------------------------------------------- */
822
823	/*
824	* Helper functions to prepare RSA-PSS params for encoding. We would
825	* have simply written the whole AlgorithmIdentifier, but existing libcrypto
826	* functionality doesn't allow that.
827	*/
828
829	static int prepare_rsa_params(const void *rsa, int nid, int save,
830	void *pstr, int pstrtype)
831	{
832	const RSA_PSS_PARAMS_30 pss = ossl_rsa_get0_pss_params_30((RSA )rsa);
833
834	*pstr = NULL;
835
836	switch (RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK)) {
837	case RSA_FLAG_TYPE_RSA:
838	/* If plain RSA, the parameters shall be NULL */
839	*pstrtype = V_ASN1_NULL;
840	return 1;
841	case RSA_FLAG_TYPE_RSASSAPSS:
842	if (ossl_rsa_pss_params_30_is_unrestricted(pss)) {
843	*pstrtype = V_ASN1_UNDEF;
844	return 1;
845	} else {
846	ASN1_STRING *astr = NULL;
847	WPACKET pkt;
848	unsigned char *str = NULL;
849	size_t str_sz = 0;
850	int i;
851
852	for (i = 0; i < 2; i++) {
853	switch (i) {
854	case 0:
855	if (!WPACKET_init_null_der(&pkt))
856	goto err;
857	break;
858	case 1:
859	if ((str = OPENSSL_malloc(str_sz)) == NULL
860	\|\| !WPACKET_init_der(&pkt, str, str_sz)) {
861	goto err;
862	}
863	break;
864	}
865	if (!ossl_DER_w_RSASSA_PSS_params(&pkt, -1, pss)
866	\|\| !WPACKET_finish(&pkt)
867	\|\| !WPACKET_get_total_written(&pkt, &str_sz))
868	goto err;
869	WPACKET_cleanup(&pkt);
870
871	/*
872	* If no PSS parameters are going to be written, there's no
873	* point going for another iteration.
874	* This saves us from getting \|str\| allocated just to have it
875	* immediately de-allocated.
876	*/
877	if (str_sz == 0)
878	break;
879	}
880
881	if ((astr = ASN1_STRING_new()) == NULL)
882	goto err;
883	*pstrtype = V_ASN1_SEQUENCE;
884	ASN1_STRING_set0(astr, str, (int)str_sz);
885	*pstr = astr;
886
887	return 1;
888	err:
889	OPENSSL_free(str);
890	return 0;
891	}
892	}
893
894	/* Currently unsupported RSA key type */
895	return 0;
896	}
897
898	/*
899	* RSA is extremely simple, as PKCS#1 is used for the PKCS#8 \|privateKey\|
900	* field as well as the SubjectPublicKeyInfo \|subjectPublicKey\| field.
901	*/
902	#define rsa_pki_priv_to_der rsa_type_specific_priv_to_der
903	#define rsa_epki_priv_to_der rsa_type_specific_priv_to_der
904	#define rsa_spki_pub_to_der rsa_type_specific_pub_to_der
905	#define rsa_type_specific_priv_to_der (i2d_of_void *)i2d_RSAPrivateKey
906	#define rsa_type_specific_pub_to_der (i2d_of_void *)i2d_RSAPublicKey
907	#define rsa_type_specific_params_to_der NULL
908
909	static int rsa_check_key_type(const void *rsa, int expected_type)
910	{
911	switch (RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK)) {
912	case RSA_FLAG_TYPE_RSA:
913	return expected_type == EVP_PKEY_RSA;
914	case RSA_FLAG_TYPE_RSASSAPSS:
915	return expected_type == EVP_PKEY_RSA_PSS;
916	}
917
918	/* Currently unsupported RSA key type */
919	return EVP_PKEY_NONE;
920	}
921
922	#define rsa_evp_type EVP_PKEY_RSA
923	#define rsapss_evp_type EVP_PKEY_RSA_PSS
924	#define rsa_input_type "RSA"
925	#define rsapss_input_type "RSA-PSS"
926	#define rsa_pem_type "RSA"
927	#define rsapss_pem_type "RSA-PSS"
928
929	/* ---------------------------------------------------------------------- */
930
931	static OSSL_FUNC_decoder_newctx_fn key2any_newctx;
932	static OSSL_FUNC_decoder_freectx_fn key2any_freectx;
933
934	static void key2any_newctx(void provctx)
935	{
936	struct key2any_ctx_st ctx = OPENSSL_zalloc(sizeof(ctx));
937
938	if (ctx != NULL) {
939	ctx->provctx = provctx;
940	ctx->save_parameters = 1;
941	}
942
943	return ctx;
944	}
945
946	static void key2any_freectx(void *vctx)
947	{
948	struct key2any_ctx_st *ctx = vctx;
949
950	ossl_pw_clear_passphrase_data(&ctx->pwdata);
951	EVP_CIPHER_free(ctx->cipher);
952	OPENSSL_free(ctx);
953	}
954
955	static const OSSL_PARAM key2any_settable_ctx_params(ossl_unused void provctx)
956	{
957	static const OSSL_PARAM settables[] = {
958	OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_CIPHER, NULL, 0),
959	OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_PROPERTIES, NULL, 0),
960	OSSL_PARAM_END,
961	};
962
963	return settables;
964	}
965
966	static int key2any_set_ctx_params(void *vctx, const OSSL_PARAM params[])
967	{
968	struct key2any_ctx_st *ctx = vctx;
969	OSSL_LIB_CTX *libctx = ossl_prov_ctx_get0_libctx(ctx->provctx);
970	const OSSL_PARAM *cipherp =
971	OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_CIPHER);
972	const OSSL_PARAM *propsp =
973	OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_PROPERTIES);
974	const OSSL_PARAM *save_paramsp =
975	OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_SAVE_PARAMETERS);
976
977	if (cipherp != NULL) {
978	const char *ciphername = NULL;
979	const char *props = NULL;
980
981	if (!OSSL_PARAM_get_utf8_string_ptr(cipherp, &ciphername))
982	return 0;
983	if (propsp != NULL && !OSSL_PARAM_get_utf8_string_ptr(propsp, &props))
984	return 0;
985
986	EVP_CIPHER_free(ctx->cipher);
987	ctx->cipher = NULL;
988	ctx->cipher_intent = ciphername != NULL;
989	if (ciphername != NULL
990	&& ((ctx->cipher =
991	EVP_CIPHER_fetch(libctx, ciphername, props)) == NULL))
992	return 0;
993	}
994
995	if (save_paramsp != NULL) {
996	if (!OSSL_PARAM_get_int(save_paramsp, &ctx->save_parameters))
997	return 0;
998	}
999	return 1;
1000	}
1001
1002	static int key2any_check_selection(int selection, int selection_mask)
1003	{
1004	/*
1005	* The selections are kinda sorta "levels", i.e. each selection given
1006	* here is assumed to include those following.
1007	*/
1008	int checks[] = {
1009	OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
1010	OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
1011	OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1012	};
1013	size_t i;
1014
1015	/* The decoder implementations made here support guessing */
1016	if (selection == 0)
1017	return 1;
1018
1019	for (i = 0; i < OSSL_NELEM(checks); i++) {
1020	int check1 = (selection & checks[i]) != 0;
1021	int check2 = (selection_mask & checks[i]) != 0;
1022
1023	/*
1024	* If the caller asked for the currently checked bit(s), return
1025	* whether the decoder description says it's supported.
1026	*/
1027	if (check1)
1028	return check2;
1029	}
1030
1031	/* This should be dead code, but just to be safe... */
1032	return 0;
1033	}
1034
1035	static int key2any_encode(struct key2any_ctx_st ctx, OSSL_CORE_BIO cout,
1036	const void key, int type, const char pemname,
1037	check_key_type_fn *checker,
1038	key_to_der_fn *writer,
1039	OSSL_PASSPHRASE_CALLBACK pwcb, void pwcbarg,
1040	key_to_paramstring_fn *key2paramstring,
1041	i2d_of_void *key2der)
1042	{
1043	int ret = 0;
1044
1045	if (key == NULL) {
1046	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_NULL_PARAMETER);
1047	} else if (writer != NULL
1048	&& (checker == NULL \|\| checker(key, type))) {
1049	BIO *out = ossl_bio_new_from_core_bio(ctx->provctx, cout);
1050
1051	if (out != NULL
1052	&& (pwcb == NULL
1053	\|\| ossl_pw_set_ossl_passphrase_cb(&ctx->pwdata, pwcb, pwcbarg)))
1054	ret =
1055	writer(out, key, type, pemname, key2paramstring, key2der, ctx);
1056
1057	BIO_free(out);
1058	} else {
1059	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT);
1060	}
1061	return ret;
1062	}
1063
1064	#define DO_PRIVATE_KEY_selection_mask OSSL_KEYMGMT_SELECT_PRIVATE_KEY
1065	#define DO_PRIVATE_KEY(impl, type, kind, output) \
1066	if ((selection & DO_PRIVATE_KEY_selection_mask) != 0) \
1067	return key2any_encode(ctx, cout, key, impl##_evp_type, \
1068	impl##_pem_type " PRIVATE KEY", \
1069	type##_check_key_type, \
1070	key_to_##kind##_##output##_priv_bio, \
1071	cb, cbarg, prepare_##type##_params, \
1072	type##_##kind##_priv_to_der);
1073
1074	#define DO_PUBLIC_KEY_selection_mask OSSL_KEYMGMT_SELECT_PUBLIC_KEY
1075	#define DO_PUBLIC_KEY(impl, type, kind, output) \
1076	if ((selection & DO_PUBLIC_KEY_selection_mask) != 0) \
1077	return key2any_encode(ctx, cout, key, impl##_evp_type, \
1078	impl##_pem_type " PUBLIC KEY", \
1079	type##_check_key_type, \
1080	key_to_##kind##_##output##_pub_bio, \
1081	cb, cbarg, prepare_##type##_params, \
1082	type##_##kind##_pub_to_der);
1083
1084	#define DO_PARAMETERS_selection_mask OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1085	#define DO_PARAMETERS(impl, type, kind, output) \
1086	if ((selection & DO_PARAMETERS_selection_mask) != 0) \
1087	return key2any_encode(ctx, cout, key, impl##_evp_type, \
1088	impl##_pem_type " PARAMETERS", \
1089	type##_check_key_type, \
1090	key_to_##kind##_##output##_param_bio, \
1091	NULL, NULL, NULL, \
1092	type##_##kind##_params_to_der);
1093
1094	/*-
1095	* Implement the kinds of output structure that can be produced. They are
1096	* referred to by name, and for each name, the following macros are defined
1097	* (braces not included):
1098	*
1099	* DO_{kind}_selection_mask
1100	*
1101	* A mask of selection bits that must not be zero. This is used as a
1102	* selection criterion for each implementation.
1103	* This mask must never be zero.
1104	*
1105	* DO_{kind}
1106	*
1107	* The performing macro. It must use the DO_ macros defined above,
1108	* always in this order:
1109	*
1110	* - DO_PRIVATE_KEY
1111	* - DO_PUBLIC_KEY
1112	* - DO_PARAMETERS
1113	*
1114	* Any of those may be omitted, but the relative order must still be
1115	* the same.
1116	*/
1117
1118	/*
1119	* PKCS#8 defines two structures for private keys only:
1120	* - PrivateKeyInfo (raw unencrypted form)
1121	* - EncryptedPrivateKeyInfo (encrypted wrapping)
1122	*
1123	* To allow a certain amount of flexibility, we allow the routines
1124	* for PrivateKeyInfo to also produce EncryptedPrivateKeyInfo if a
1125	* passphrase callback has been passed to them.
1126	*/
1127	#define DO_PrivateKeyInfo_selection_mask DO_PRIVATE_KEY_selection_mask
1128	#define DO_PrivateKeyInfo(impl, type, output) \
1129	DO_PRIVATE_KEY(impl, type, pki, output)
1130
1131	#define DO_EncryptedPrivateKeyInfo_selection_mask DO_PRIVATE_KEY_selection_mask
1132	#define DO_EncryptedPrivateKeyInfo(impl, type, output) \
1133	DO_PRIVATE_KEY(impl, type, epki, output)
1134
1135	/* SubjectPublicKeyInfo is a structure for public keys only */
1136	#define DO_SubjectPublicKeyInfo_selection_mask DO_PUBLIC_KEY_selection_mask
1137	#define DO_SubjectPublicKeyInfo(impl, type, output) \
1138	DO_PUBLIC_KEY(impl, type, spki, output)
1139
1140	/*
1141	* "type-specific" is a uniform name for key type specific output for private
1142	* and public keys as well as key parameters. This is used internally in
1143	* libcrypto so it doesn't have to have special knowledge about select key
1144	* types, but also when no better name has been found. If there are more
1145	* expressive DO_ names above, those are preferred.
1146	*
1147	* Three forms exist:
1148	*
1149	* - type_specific_keypair Only supports private and public key
1150	* - type_specific_params Only supports parameters
1151	* - type_specific Supports all parts of an EVP_PKEY
1152	* - type_specific_no_pub Supports all parts of an EVP_PKEY
1153	* except public key
1154	*/
1155	#define DO_type_specific_params_selection_mask DO_PARAMETERS_selection_mask
1156	#define DO_type_specific_params(impl, type, output) \
1157	DO_PARAMETERS(impl, type, type_specific, output)
1158	#define DO_type_specific_keypair_selection_mask \
1159	( DO_PRIVATE_KEY_selection_mask \| DO_PUBLIC_KEY_selection_mask )
1160	#define DO_type_specific_keypair(impl, type, output) \
1161	DO_PRIVATE_KEY(impl, type, type_specific, output) \
1162	DO_PUBLIC_KEY(impl, type, type_specific, output)
1163	#define DO_type_specific_selection_mask \
1164	( DO_type_specific_keypair_selection_mask \
1165	\| DO_type_specific_params_selection_mask )
1166	#define DO_type_specific(impl, type, output) \
1167	DO_type_specific_keypair(impl, type, output) \
1168	DO_type_specific_params(impl, type, output)
1169	#define DO_type_specific_no_pub_selection_mask \
1170	( DO_PRIVATE_KEY_selection_mask \| DO_PARAMETERS_selection_mask)
1171	#define DO_type_specific_no_pub(impl, type, output) \
1172	DO_PRIVATE_KEY(impl, type, type_specific, output) \
1173	DO_type_specific_params(impl, type, output)
1174
1175	/*
1176	* Type specific aliases for the cases where we need to refer to them by
1177	* type name.
1178	* This only covers key types that are represented with i2d_{TYPE}PrivateKey,
1179	* i2d_{TYPE}PublicKey and i2d_{TYPE}params / i2d_{TYPE}Parameters.
1180	*/
1181	#define DO_RSA_selection_mask DO_type_specific_keypair_selection_mask
1182	#define DO_RSA(impl, type, output) DO_type_specific_keypair(impl, type, output)
1183
1184	#define DO_DH_selection_mask DO_type_specific_params_selection_mask
1185	#define DO_DH(impl, type, output) DO_type_specific_params(impl, type, output)
1186
1187	#define DO_DHX_selection_mask DO_type_specific_params_selection_mask
1188	#define DO_DHX(impl, type, output) DO_type_specific_params(impl, type, output)
1189
1190	#define DO_DSA_selection_mask DO_type_specific_selection_mask
1191	#define DO_DSA(impl, type, output) DO_type_specific(impl, type, output)
1192
1193	#define DO_EC_selection_mask DO_type_specific_no_pub_selection_mask
1194	#define DO_EC(impl, type, output) DO_type_specific_no_pub(impl, type, output)
1195
1196	#define DO_SM2_selection_mask DO_type_specific_no_pub_selection_mask
1197	#define DO_SM2(impl, type, output) DO_type_specific_no_pub(impl, type, output)
1198
1199	/* PKCS#1 defines a structure for RSA private and public keys */
1200	#define DO_PKCS1_selection_mask DO_RSA_selection_mask
1201	#define DO_PKCS1(impl, type, output) DO_RSA(impl, type, output)
1202
1203	/* PKCS#3 defines a structure for DH parameters */
1204	#define DO_PKCS3_selection_mask DO_DH_selection_mask
1205	#define DO_PKCS3(impl, type, output) DO_DH(impl, type, output)
1206	/* X9.42 defines a structure for DHx parameters */
1207	#define DO_X9_42_selection_mask DO_DHX_selection_mask
1208	#define DO_X9_42(impl, type, output) DO_DHX(impl, type, output)
1209
1210	/* X9.62 defines a structure for EC keys and parameters */
1211	#define DO_X9_62_selection_mask DO_EC_selection_mask
1212	#define DO_X9_62(impl, type, output) DO_EC(impl, type, output)
1213
1214	/*
1215	* MAKE_ENCODER is the single driver for creating OSSL_DISPATCH tables.
1216	* It takes the following arguments:
1217	*
1218	* impl This is the key type name that's being implemented.
1219	* type This is the type name for the set of functions that implement
1220	* the key type. For example, ed25519, ed448, x25519 and x448
1221	* are all implemented with the exact same set of functions.
1222	* evp_type The corresponding EVP_PKEY_xxx type macro for each key.
1223	* Necessary because we currently use EVP_PKEY with legacy
1224	* native keys internally. This will need to be refactored
1225	* when that legacy support goes away.
1226	* kind What kind of support to implement. These translate into
1227	* the DO_##kind macros above.
1228	* output The output type to implement. may be der or pem.
1229	*
1230	* The resulting OSSL_DISPATCH array gets the following name (expressed in
1231	* C preprocessor terms) from those arguments:
1232	*
1233	* ossl_##impl##_to_##kind##_##output##_encoder_functions
1234	*/
1235	#define MAKE_ENCODER(impl, type, evp_type, kind, output) \
1236	static OSSL_FUNC_encoder_import_object_fn \
1237	impl##_to_##kind##_##output##_import_object; \
1238	static OSSL_FUNC_encoder_free_object_fn \
1239	impl##_to_##kind##_##output##_free_object; \
1240	static OSSL_FUNC_encoder_encode_fn \
1241	impl##_to_##kind##_##output##_encode; \
1242	\
1243	static void * \
1244	impl##_to_##kind##_##output##_import_object(void *vctx, int selection, \
1245	const OSSL_PARAM params[]) \
1246	{ \
1247	struct key2any_ctx_st *ctx = vctx; \
1248	\
1249	return ossl_prov_import_key(ossl_##impl##_keymgmt_functions, \
1250	ctx->provctx, selection, params); \
1251	} \
1252	static void impl##_to_##kind##_##output##_free_object(void *key) \
1253	{ \
1254	ossl_prov_free_key(ossl_##impl##_keymgmt_functions, key); \
1255	} \
1256	static int impl##_to_##kind##_##output##_does_selection(void *ctx, \
1257	int selection) \
1258	{ \
1259	return key2any_check_selection(selection, \
1260	DO_##kind##_selection_mask); \
1261	} \
1262	static int \
1263	impl##_to_##kind##_##output##_encode(void ctx, OSSL_CORE_BIO cout, \
1264	const void *key, \
1265	const OSSL_PARAM key_abstract[], \
1266	int selection, \
1267	OSSL_PASSPHRASE_CALLBACK *cb, \
1268	void *cbarg) \
1269	{ \
1270	/* We don't deal with abstract objects */ \
1271	if (key_abstract != NULL) { \
1272	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT); \
1273	return 0; \
1274	} \
1275	DO_##kind(impl, type, output) \
1276	\
1277	ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT); \
1278	return 0; \
1279	} \
1280	const OSSL_DISPATCH \
1281	ossl_##impl##_to_##kind##_##output##_encoder_functions[] = { \
1282	{ OSSL_FUNC_ENCODER_NEWCTX, \
1283	(void (*)(void))key2any_newctx }, \
1284	{ OSSL_FUNC_ENCODER_FREECTX, \
1285	(void (*)(void))key2any_freectx }, \
1286	{ OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS, \
1287	(void (*)(void))key2any_settable_ctx_params }, \
1288	{ OSSL_FUNC_ENCODER_SET_CTX_PARAMS, \
1289	(void (*)(void))key2any_set_ctx_params }, \
1290	{ OSSL_FUNC_ENCODER_DOES_SELECTION, \
1291	(void (*)(void))impl##_to_##kind##_##output##_does_selection }, \
1292	{ OSSL_FUNC_ENCODER_IMPORT_OBJECT, \
1293	(void (*)(void))impl##_to_##kind##_##output##_import_object }, \
1294	{ OSSL_FUNC_ENCODER_FREE_OBJECT, \
1295	(void (*)(void))impl##_to_##kind##_##output##_free_object }, \
1296	{ OSSL_FUNC_ENCODER_ENCODE, \
1297	(void (*)(void))impl##_to_##kind##_##output##_encode }, \
1298	{ 0, NULL } \
1299	}
1300
1301	/*
1302	* Replacements for i2d_{TYPE}PrivateKey, i2d_{TYPE}PublicKey,
1303	* i2d_{TYPE}params, as they exist.
1304	*/
1305	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, type_specific_keypair, der);
1306	#ifndef OPENSSL_NO_DH
1307	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, type_specific_params, der);
1308	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, type_specific_params, der);
1309	#endif
1310	#ifndef OPENSSL_NO_DSA
1311	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, type_specific, der);
1312	#endif
1313	#ifndef OPENSSL_NO_EC
1314	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, type_specific_no_pub, der);
1315	# ifndef OPENSSL_NO_SM2
1316	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, type_specific_no_pub, der);
1317	# endif
1318	#endif
1319
1320	/*
1321	* Replacements for PEM_write_bio_{TYPE}PrivateKey,
1322	* PEM_write_bio_{TYPE}PublicKey, PEM_write_bio_{TYPE}params, as they exist.
1323	*/
1324	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, type_specific_keypair, pem);
1325	#ifndef OPENSSL_NO_DH
1326	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, type_specific_params, pem);
1327	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, type_specific_params, pem);
1328	#endif
1329	#ifndef OPENSSL_NO_DSA
1330	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, type_specific, pem);
1331	#endif
1332	#ifndef OPENSSL_NO_EC
1333	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, type_specific_no_pub, pem);
1334	# ifndef OPENSSL_NO_SM2
1335	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, type_specific_no_pub, pem);
1336	# endif
1337	#endif
1338
1339	/*
1340	* PKCS#8 and SubjectPublicKeyInfo support. This may duplicate some of the
1341	* implementations specified above, but are more specific.
1342	* The SubjectPublicKeyInfo implementations also replace the
1343	* PEM_write_bio_{TYPE}_PUBKEY functions.
1344	* For PEM, these are expected to be used by PEM_write_bio_PrivateKey(),
1345	* PEM_write_bio_PUBKEY() and PEM_write_bio_Parameters().
1346	*/
1347	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, EncryptedPrivateKeyInfo, der);
1348	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, EncryptedPrivateKeyInfo, pem);
1349	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, PrivateKeyInfo, der);
1350	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, PrivateKeyInfo, pem);
1351	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, SubjectPublicKeyInfo, der);
1352	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, SubjectPublicKeyInfo, pem);
1353	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, EncryptedPrivateKeyInfo, der);
1354	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, EncryptedPrivateKeyInfo, pem);
1355	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, PrivateKeyInfo, der);
1356	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, PrivateKeyInfo, pem);
1357	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, SubjectPublicKeyInfo, der);
1358	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, SubjectPublicKeyInfo, pem);
1359	#ifndef OPENSSL_NO_DH
1360	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, EncryptedPrivateKeyInfo, der);
1361	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, EncryptedPrivateKeyInfo, pem);
1362	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, PrivateKeyInfo, der);
1363	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, PrivateKeyInfo, pem);
1364	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, SubjectPublicKeyInfo, der);
1365	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, SubjectPublicKeyInfo, pem);
1366	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, EncryptedPrivateKeyInfo, der);
1367	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, EncryptedPrivateKeyInfo, pem);
1368	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, PrivateKeyInfo, der);
1369	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, PrivateKeyInfo, pem);
1370	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, SubjectPublicKeyInfo, der);
1371	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, SubjectPublicKeyInfo, pem);
1372	#endif
1373	#ifndef OPENSSL_NO_DSA
1374	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, EncryptedPrivateKeyInfo, der);
1375	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, EncryptedPrivateKeyInfo, pem);
1376	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, PrivateKeyInfo, der);
1377	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, PrivateKeyInfo, pem);
1378	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, SubjectPublicKeyInfo, der);
1379	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, SubjectPublicKeyInfo, pem);
1380	#endif
1381	#ifndef OPENSSL_NO_EC
1382	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, EncryptedPrivateKeyInfo, der);
1383	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, EncryptedPrivateKeyInfo, pem);
1384	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, PrivateKeyInfo, der);
1385	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, PrivateKeyInfo, pem);
1386	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, SubjectPublicKeyInfo, der);
1387	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, SubjectPublicKeyInfo, pem);
1388	# ifndef OPENSSL_NO_SM2
1389	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, EncryptedPrivateKeyInfo, der);
1390	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, EncryptedPrivateKeyInfo, pem);
1391	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, PrivateKeyInfo, der);
1392	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, PrivateKeyInfo, pem);
1393	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, SubjectPublicKeyInfo, der);
1394	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, SubjectPublicKeyInfo, pem);
1395	# endif
1396	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, EncryptedPrivateKeyInfo, der);
1397	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, EncryptedPrivateKeyInfo, pem);
1398	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, PrivateKeyInfo, der);
1399	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, PrivateKeyInfo, pem);
1400	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, SubjectPublicKeyInfo, der);
1401	MAKE_ENCODER(ed25519, ecx, EVP_PKEY_ED25519, SubjectPublicKeyInfo, pem);
1402	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, EncryptedPrivateKeyInfo, der);
1403	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, EncryptedPrivateKeyInfo, pem);
1404	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, PrivateKeyInfo, der);
1405	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, PrivateKeyInfo, pem);
1406	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, SubjectPublicKeyInfo, der);
1407	MAKE_ENCODER(ed448, ecx, EVP_PKEY_ED448, SubjectPublicKeyInfo, pem);
1408	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, EncryptedPrivateKeyInfo, der);
1409	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, EncryptedPrivateKeyInfo, pem);
1410	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, PrivateKeyInfo, der);
1411	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, PrivateKeyInfo, pem);
1412	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, SubjectPublicKeyInfo, der);
1413	MAKE_ENCODER(x25519, ecx, EVP_PKEY_X25519, SubjectPublicKeyInfo, pem);
1414	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, EncryptedPrivateKeyInfo, der);
1415	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, EncryptedPrivateKeyInfo, pem);
1416	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, PrivateKeyInfo, der);
1417	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, PrivateKeyInfo, pem);
1418	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, SubjectPublicKeyInfo, der);
1419	MAKE_ENCODER(x448, ecx, EVP_PKEY_ED448, SubjectPublicKeyInfo, pem);
1420	#endif
1421
1422	/*
1423	* Support for key type specific output formats. Not all key types have
1424	* this, we only aim to duplicate what is available in 1.1.1 as
1425	* i2d_TYPEPrivateKey(), i2d_TYPEPublicKey() and i2d_TYPEparams().
1426	* For example, there are no publicly available i2d_ function for
1427	* ED25519, ED448, X25519 or X448, and they therefore only have PKCS#8
1428	* and SubjectPublicKeyInfo implementations as implemented above.
1429	*/
1430	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, RSA, der);
1431	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, RSA, pem);
1432	#ifndef OPENSSL_NO_DH
1433	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, DH, der);
1434	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, DH, pem);
1435	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, DHX, der);
1436	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, DHX, pem);
1437	#endif
1438	#ifndef OPENSSL_NO_DSA
1439	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, DSA, der);
1440	MAKE_ENCODER(dsa, dsa, EVP_PKEY_DSA, DSA, pem);
1441	#endif
1442	#ifndef OPENSSL_NO_EC
1443	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, EC, der);
1444	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, EC, pem);
1445	# ifndef OPENSSL_NO_SM2
1446	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, SM2, der);
1447	MAKE_ENCODER(sm2, ec, EVP_PKEY_EC, SM2, pem);
1448	# endif
1449	#endif
1450
1451	/* Convenience structure names */
1452	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, PKCS1, der);
1453	MAKE_ENCODER(rsa, rsa, EVP_PKEY_RSA, PKCS1, pem);
1454	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, PKCS1, der);
1455	MAKE_ENCODER(rsapss, rsa, EVP_PKEY_RSA_PSS, PKCS1, pem);
1456	#ifndef OPENSSL_NO_DH
1457	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, PKCS3, der); /* parameters only */
1458	MAKE_ENCODER(dh, dh, EVP_PKEY_DH, PKCS3, pem); /* parameters only */
1459	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, X9_42, der); /* parameters only */
1460	MAKE_ENCODER(dhx, dh, EVP_PKEY_DHX, X9_42, pem); /* parameters only */
1461	#endif
1462	#ifndef OPENSSL_NO_EC
1463	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, X9_62, der);
1464	MAKE_ENCODER(ec, ec, EVP_PKEY_EC, X9_62, pem);
1465	#endif

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

source: vbox/trunk/src/libs/openssl-3.1.2/providers/implementations/encode_decode/encode_key2any.c@ 101021

Download in other formats: