[thirdparty/openssl.git] / providers / encoders.inc

/*
 * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#ifndef ENCODER_PROVIDER
# error Macro ENCODER_PROVIDER undefined
#endif

#define ENCODER_STRUCTURE_type_specific_keypair         "type-specific"
#define ENCODER_STRUCTURE_type_specific_params          "type-specific"
#define ENCODER_STRUCTURE_type_specific                 "type-specific"
#define ENCODER_STRUCTURE_type_specific_no_pub          "type-specific"
#define ENCODER_STRUCTURE_EncryptedPrivateKeyInfo       "EncryptedPrivateKeyInfo"
#define ENCODER_STRUCTURE_PrivateKeyInfo                "PrivateKeyInfo"
#define ENCODER_STRUCTURE_SubjectPublicKeyInfo          "SubjectPublicKeyInfo"
#define ENCODER_STRUCTURE_DH                            "dh"
#define ENCODER_STRUCTURE_DHX                           "dhx"
#define ENCODER_STRUCTURE_DSA                           "dsa"
#define ENCODER_STRUCTURE_EC                            "ec"
#define ENCODER_STRUCTURE_RSA                           "rsa"
#define ENCODER_STRUCTURE_PKCS1                         "pkcs1"
#define ENCODER_STRUCTURE_PKCS3                         "pkcs3"
#define ENCODER_STRUCTURE_X9_42                         "X9.42"
#define ENCODER_STRUCTURE_X9_62                         "X9.62"

/* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
#define ENCODER_TEXT(_name, _sym, _fips)                                \
    { _name,                                                            \
      "provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=text",      \
      (ossl_##_sym##_to_text_encoder_functions) }
#define ENCODER(_name, _sym, _fips, _output)                            \
    { _name,                                                            \
      "provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=" #_output, \
      (ossl_##_sym##_to_##_output##_encoder_functions) }
#define ENCODER_w_structure(_name, _sym, _fips, _output, _structure)    \
    { _name,                                                            \
      "provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=" #_output  \
      ",structure=" ENCODER_STRUCTURE_##_structure,                     \
      (ossl_##_sym##_to_##_structure##_##_output##_encoder_functions) }

/*
 * Entries for human text "encoders"
 */
ENCODER_TEXT("RSA", rsa, yes),
ENCODER_TEXT("RSA-PSS", rsapss, yes),
#ifndef OPENSSL_NO_DH
ENCODER_TEXT("DH", dh, yes),
ENCODER_TEXT("DHX", dhx, yes),
#endif
#ifndef OPENSSL_NO_DSA
ENCODER_TEXT("DSA", dsa, yes),
#endif
#ifndef OPENSSL_NO_EC
ENCODER_TEXT("EC", ec, yes),
# ifndef OPENSSL_NO_ECX
ENCODER_TEXT("ED25519", ed25519, yes),
ENCODER_TEXT("ED448", ed448, yes),
ENCODER_TEXT("X25519", x25519, yes),
ENCODER_TEXT("X448", x448, yes),
# endif
# ifndef OPENSSL_NO_SM2
ENCODER_TEXT("SM2", sm2, no),
# endif
#endif

/*
 * Entries for key type specific output formats.  The structure name on these
 * is the same as the key type name.  This allows us to say something like:
 *
 * To replace i2d_{TYPE}PrivateKey(), i2d_{TYPE}PublicKey() and
 * i2d_{TYPE}Params(), use OSSL_ENCODER functions with an OSSL_ENCODER_CTX
 * created like this:
 *
 * OSSL_ENCODER_CTX *ctx =
 *     OSSL_ENCODER_CTX_new_for_pkey(pkey, selection, "DER", "type-specific",
 *                                   NULL, NULL);
 *
 * To replace PEM_write_bio_{TYPE}PrivateKey(), PEM_write_bio_{TYPE}PublicKey()
 * and PEM_write_bio_{TYPE}Params(), use OSSL_ENCODER functions with an
 * OSSL_ENCODER_CTX created like this:
 *
 * OSSL_ENCODER_CTX *ctx =
 *     OSSL_ENCODER_CTX_new_for_pkey(pkey, selection, "PEM", "type-specific",
 *                                   NULL, NULL);
 *
 * We only implement those for which there are current i2d_ and PEM_write_bio
 * implementations.
 */

/* The RSA encoders only support private key and public key output */
ENCODER_w_structure("RSA", rsa, yes, der, type_specific_keypair),
ENCODER_w_structure("RSA", rsa, yes, pem, type_specific_keypair),
#ifndef OPENSSL_NO_DH
/* DH and X9.42 DH only support key parameters output. */
ENCODER_w_structure("DH", dh, yes, der, type_specific_params),
ENCODER_w_structure("DH", dh, yes, pem, type_specific_params),
ENCODER_w_structure("DHX", dhx, yes, der, type_specific_params),
ENCODER_w_structure("DHX", dhx, yes, pem, type_specific_params),
#endif
#ifndef OPENSSL_NO_DSA
ENCODER_w_structure("DSA", dsa, yes, der, type_specific),
ENCODER_w_structure("DSA", dsa, yes, pem, type_specific),
#endif
#ifndef OPENSSL_NO_EC
/* EC only supports keypair and parameters DER and PEM output. */
ENCODER_w_structure("EC", ec, yes, der, type_specific_no_pub),
ENCODER_w_structure("EC", ec, yes, pem, type_specific_no_pub),
/* EC supports blob output for the public key */
ENCODER("EC", ec, yes, blob),
# ifndef OPENSSL_NO_SM2
ENCODER_w_structure("SM2", sm2, no, der, type_specific_no_pub),
ENCODER_w_structure("SM2", sm2, no, pem, type_specific_no_pub),
ENCODER("SM2", sm2, no, blob),
# endif
#endif

/*
 * Entries for the output formats MSBLOB and PVK
 */
ENCODER("RSA", rsa, yes, msblob),
ENCODER("RSA", rsa, yes, pvk),
#ifndef OPENSSL_NO_DSA
ENCODER("DSA", dsa, yes, msblob),
ENCODER("DSA", dsa, yes, pvk),
#endif

/*
 * Entries for encrypted PKCS#8 (EncryptedPrivateKeyInfo), unencrypted PKCS#8
 * (PrivateKeyInfo) and SubjectPublicKeyInfo.  The "der" ones are added
 * convenience for any user that wants to use OSSL_ENCODER directly.
 * The "pem" ones also support PEM_write_bio_PrivateKey() and
 * PEM_write_bio_PUBKEY().
 */
ENCODER_w_structure("RSA", rsa, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("RSA", rsa, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("RSA", rsa, yes, der, PrivateKeyInfo),
ENCODER_w_structure("RSA", rsa, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("RSA", rsa, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("RSA", rsa, yes, pem, SubjectPublicKeyInfo),

ENCODER_w_structure("RSA-PSS", rsapss, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("RSA-PSS", rsapss, yes, der, PrivateKeyInfo),
ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("RSA-PSS", rsapss, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, SubjectPublicKeyInfo),

#ifndef OPENSSL_NO_DH
ENCODER_w_structure("DH", dh, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DH", dh, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DH", dh, yes, der, PrivateKeyInfo),
ENCODER_w_structure("DH", dh, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("DH", dh, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("DH", dh, yes, pem, SubjectPublicKeyInfo),

ENCODER_w_structure("DHX", dhx, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DHX", dhx, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DHX", dhx, yes, der, PrivateKeyInfo),
ENCODER_w_structure("DHX", dhx, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("DHX", dhx, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("DHX", dhx, yes, pem, SubjectPublicKeyInfo),
#endif

#ifndef OPENSSL_NO_DSA
ENCODER_w_structure("DSA", dsa, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DSA", dsa, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("DSA", dsa, yes, der, PrivateKeyInfo),
ENCODER_w_structure("DSA", dsa, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("DSA", dsa, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("DSA", dsa, yes, pem, SubjectPublicKeyInfo),
#endif

#ifndef OPENSSL_NO_EC
ENCODER_w_structure("EC", ec, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("EC", ec, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("EC", ec, yes, der, PrivateKeyInfo),
ENCODER_w_structure("EC", ec, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("EC", ec, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("EC", ec, yes, pem, SubjectPublicKeyInfo),

#ifndef OPENSSL_NO_ECX
ENCODER_w_structure("X25519", x25519, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("X25519", x25519, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("X25519", x25519, yes, der, PrivateKeyInfo),
ENCODER_w_structure("X25519", x25519, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("X25519", x25519, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("X25519", x25519, yes, pem, SubjectPublicKeyInfo),

ENCODER_w_structure("X448", x448, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("X448", x448, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("X448", x448, yes, der, PrivateKeyInfo),
ENCODER_w_structure("X448", x448, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("X448", x448, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("X448", x448, yes, pem, SubjectPublicKeyInfo),

ENCODER_w_structure("ED25519", ed25519, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("ED25519", ed25519, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("ED25519", ed25519, yes, der, PrivateKeyInfo),
ENCODER_w_structure("ED25519", ed25519, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("ED25519", ed25519, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("ED25519", ed25519, yes, pem, SubjectPublicKeyInfo),

ENCODER_w_structure("ED448", ed448, yes, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("ED448", ed448, yes, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("ED448", ed448, yes, der, PrivateKeyInfo),
ENCODER_w_structure("ED448", ed448, yes, pem, PrivateKeyInfo),
ENCODER_w_structure("ED448", ed448, yes, der, SubjectPublicKeyInfo),
ENCODER_w_structure("ED448", ed448, yes, pem, SubjectPublicKeyInfo),
# endif

# ifndef OPENSSL_NO_SM2
ENCODER_w_structure("SM2", sm2, no, der, EncryptedPrivateKeyInfo),
ENCODER_w_structure("SM2", sm2, no, pem, EncryptedPrivateKeyInfo),
ENCODER_w_structure("SM2", sm2, no, der, PrivateKeyInfo),
ENCODER_w_structure("SM2", sm2, no, pem, PrivateKeyInfo),
ENCODER_w_structure("SM2", sm2, no, der, SubjectPublicKeyInfo),
ENCODER_w_structure("SM2", sm2, no, pem, SubjectPublicKeyInfo),
# endif
#endif

/*
 * Entries for key type specific output formats.  These are exactly the
 * same as the type specific above, except that they use the key type
 * name as structure name instead of "type-specific", in the call on
 * OSSL_ENCODER_CTX_new_for_pkey().
 */

/* The RSA encoders only support private key and public key output */
ENCODER_w_structure("RSA", rsa, yes, der, RSA),
ENCODER_w_structure("RSA", rsa, yes, pem, RSA),
#ifndef OPENSSL_NO_DH
/* DH and X9.42 DH only support key parameters output. */
ENCODER_w_structure("DH", dh, yes, der, DH),
ENCODER_w_structure("DH", dh, yes, pem, DH),
ENCODER_w_structure("DHX", dhx, yes, der, DHX),
ENCODER_w_structure("DHX", dhx, yes, pem, DHX),
#endif
#ifndef OPENSSL_NO_DSA
ENCODER_w_structure("DSA", dsa, yes, der, DSA),
ENCODER_w_structure("DSA", dsa, yes, pem, DSA),
#endif
#ifndef OPENSSL_NO_EC
ENCODER_w_structure("EC", ec, yes, der, EC),
ENCODER_w_structure("EC", ec, yes, pem, EC),
#endif

/*
 * Additional entries with structure names being the standard name.
 * This is entirely for the convenience of the user that wants to use
 * OSSL_ENCODER directly with names they may fancy.  These do not impact
 * on libcrypto functionality in any way.
 */
/* PKCS#1 is a well known for plain RSA keys, so we add that too */
ENCODER_w_structure("RSA", rsa, yes, der, PKCS1),
ENCODER_w_structure("RSA", rsa, yes, pem, PKCS1),
ENCODER_w_structure("RSA-PSS", rsapss, yes, der, PKCS1),
ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, PKCS1),
#ifndef OPENSSL_NO_DH
/* PKCS#3 defines the format for DH parameters */
ENCODER_w_structure("DH", dh, yes, der, PKCS3),
ENCODER_w_structure("DH", dh, yes, pem, PKCS3),
/* X9.42 defines the format for DHX parameters */
ENCODER_w_structure("DHX", dhx, yes, der, X9_42),
ENCODER_w_structure("DHX", dhx, yes, pem, X9_42),
#endif
#ifndef OPENSSL_NO_EC
/* RFC 5915 defines the format for EC keys and parameters */
ENCODER_w_structure("EC", ec, yes, der, X9_62),
ENCODER_w_structure("EC", ec, yes, pem, X9_62),
#endif
Commit	Line	Data
ece9304c	1	/*
da1c088f	2	* Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved.
ece9304c RL	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
c319b627 RL	10	#ifndef ENCODER_PROVIDER
c319b627 RL	11	# error Macro ENCODER_PROVIDER undefined
ece9304c RL	12	#endif
ece9304c RL	13
c319b627 RL	14	#define ENCODER_STRUCTURE_type_specific_keypair "type-specific"
	15	#define ENCODER_STRUCTURE_type_specific_params "type-specific"
	16	#define ENCODER_STRUCTURE_type_specific "type-specific"
	17	#define ENCODER_STRUCTURE_type_specific_no_pub "type-specific"
0195cdd2	18	#define ENCODER_STRUCTURE_EncryptedPrivateKeyInfo "EncryptedPrivateKeyInfo"
6a2b8ff3	19	#define ENCODER_STRUCTURE_PrivateKeyInfo "PrivateKeyInfo"
c319b627 RL	20	#define ENCODER_STRUCTURE_SubjectPublicKeyInfo "SubjectPublicKeyInfo"
	21	#define ENCODER_STRUCTURE_DH "dh"
	22	#define ENCODER_STRUCTURE_DHX "dhx"
	23	#define ENCODER_STRUCTURE_DSA "dsa"
	24	#define ENCODER_STRUCTURE_EC "ec"
	25	#define ENCODER_STRUCTURE_RSA "rsa"
	26	#define ENCODER_STRUCTURE_PKCS1 "pkcs1"
	27	#define ENCODER_STRUCTURE_PKCS3 "pkcs3"
	28	#define ENCODER_STRUCTURE_X9_42 "X9.42"
	29	#define ENCODER_STRUCTURE_X9_62 "X9.62"
	30
	31	/* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
	32	#define ENCODER_TEXT(_name, _sym, _fips) \
	33	{ _name, \
	34	"provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=text", \
	35	(ossl_##_sym##_to_text_encoder_functions) }
0cc0164d RL	36	#define ENCODER(_name, _sym, _fips, _output) \
	37	{ _name, \
	38	"provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=" #_output, \
	39	(ossl_##_sym##_to_##_output##_encoder_functions) }
	40	#define ENCODER_w_structure(_name, _sym, _fips, _output, _structure) \
c319b627 RL	41	{ _name, \
	42	"provider=" ENCODER_PROVIDER ",fips=" #_fips ",output=" #_output \
	43	",structure=" ENCODER_STRUCTURE_##_structure, \
	44	(ossl_##_sym##_to_##_structure##_##_output##_encoder_functions) }
	45
	46	/*
	47	* Entries for human text "encoders"
	48	*/
	49	ENCODER_TEXT("RSA", rsa, yes),
	50	ENCODER_TEXT("RSA-PSS", rsapss, yes),
	51	#ifndef OPENSSL_NO_DH
	52	ENCODER_TEXT("DH", dh, yes),
	53	ENCODER_TEXT("DHX", dhx, yes),
	54	#endif
	55	#ifndef OPENSSL_NO_DSA
	56	ENCODER_TEXT("DSA", dsa, yes),
	57	#endif
	58	#ifndef OPENSSL_NO_EC
	59	ENCODER_TEXT("EC", ec, yes),
4032cd9a	60	# ifndef OPENSSL_NO_ECX
c319b627 RL	61	ENCODER_TEXT("ED25519", ed25519, yes),
	62	ENCODER_TEXT("ED448", ed448, yes),
	63	ENCODER_TEXT("X25519", x25519, yes),
	64	ENCODER_TEXT("X448", x448, yes),
4032cd9a	65	# endif
f2db0528	66	# ifndef OPENSSL_NO_SM2
a6f8e131	67	ENCODER_TEXT("SM2", sm2, no),
f2db0528	68	# endif
c319b627 RL	69	#endif
	70
	71	/*
	72	* Entries for key type specific output formats. The structure name on these
	73	* is the same as the key type name. This allows us to say something like:
	74	*
	75	* To replace i2d_{TYPE}PrivateKey(), i2d_{TYPE}PublicKey() and
	76	* i2d_{TYPE}Params(), use OSSL_ENCODER functions with an OSSL_ENCODER_CTX
	77	* created like this:
	78	*
	79	* OSSL_ENCODER_CTX *ctx =
fe75766c TM	80	* OSSL_ENCODER_CTX_new_for_pkey(pkey, selection, "DER", "type-specific",
fe75766c TM	81	* NULL, NULL);
c319b627 RL	82	*
	83	* To replace PEM_write_bio_{TYPE}PrivateKey(), PEM_write_bio_{TYPE}PublicKey()
	84	* and PEM_write_bio_{TYPE}Params(), use OSSL_ENCODER functions with an
	85	* OSSL_ENCODER_CTX created like this:
	86	*
	87	* OSSL_ENCODER_CTX *ctx =
fe75766c TM	88	* OSSL_ENCODER_CTX_new_for_pkey(pkey, selection, "PEM", "type-specific",
fe75766c TM	89	* NULL, NULL);
c319b627 RL	90	*
	91	* We only implement those for which there are current i2d_ and PEM_write_bio
	92	* implementations.
	93	*/
	94
	95	/* The RSA encoders only support private key and public key output */
0cc0164d RL	96	ENCODER_w_structure("RSA", rsa, yes, der, type_specific_keypair),
0cc0164d RL	97	ENCODER_w_structure("RSA", rsa, yes, pem, type_specific_keypair),
c319b627 RL	98	#ifndef OPENSSL_NO_DH
c319b627 RL	99	/* DH and X9.42 DH only support key parameters output. */
0cc0164d RL	100	ENCODER_w_structure("DH", dh, yes, der, type_specific_params),
	101	ENCODER_w_structure("DH", dh, yes, pem, type_specific_params),
	102	ENCODER_w_structure("DHX", dhx, yes, der, type_specific_params),
	103	ENCODER_w_structure("DHX", dhx, yes, pem, type_specific_params),
c319b627 RL	104	#endif
c319b627 RL	105	#ifndef OPENSSL_NO_DSA
0cc0164d RL	106	ENCODER_w_structure("DSA", dsa, yes, der, type_specific),
0cc0164d RL	107	ENCODER_w_structure("DSA", dsa, yes, pem, type_specific),
c319b627 RL	108	#endif
c319b627 RL	109	#ifndef OPENSSL_NO_EC
c8182743	110	/* EC only supports keypair and parameters DER and PEM output. */
0cc0164d RL	111	ENCODER_w_structure("EC", ec, yes, der, type_specific_no_pub),
0cc0164d RL	112	ENCODER_w_structure("EC", ec, yes, pem, type_specific_no_pub),
c8182743 RL	113	/* EC supports blob output for the public key */
c8182743 RL	114	ENCODER("EC", ec, yes, blob),
f2db0528	115	# ifndef OPENSSL_NO_SM2
a6f8e131 P	116	ENCODER_w_structure("SM2", sm2, no, der, type_specific_no_pub),
	117	ENCODER_w_structure("SM2", sm2, no, pem, type_specific_no_pub),
	118	ENCODER("SM2", sm2, no, blob),
f2db0528	119	# endif
0cc0164d RL	120	#endif
	121
	122	/*
	123	* Entries for the output formats MSBLOB and PVK
	124	*/
	125	ENCODER("RSA", rsa, yes, msblob),
	126	ENCODER("RSA", rsa, yes, pvk),
	127	#ifndef OPENSSL_NO_DSA
	128	ENCODER("DSA", dsa, yes, msblob),
	129	ENCODER("DSA", dsa, yes, pvk),
c319b627 RL	130	#endif
	131
	132	/*
0195cdd2 RL	133	* Entries for encrypted PKCS#8 (EncryptedPrivateKeyInfo), unencrypted PKCS#8
	134	* (PrivateKeyInfo) and SubjectPublicKeyInfo. The "der" ones are added
	135	* convenience for any user that wants to use OSSL_ENCODER directly.
c319b627 RL	136	* The "pem" ones also support PEM_write_bio_PrivateKey() and
	137	* PEM_write_bio_PUBKEY().
	138	*/
0195cdd2 RL	139	ENCODER_w_structure("RSA", rsa, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	140	ENCODER_w_structure("RSA", rsa, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	141	ENCODER_w_structure("RSA", rsa, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	142	ENCODER_w_structure("RSA", rsa, yes, pem, PrivateKeyInfo),
0cc0164d RL	143	ENCODER_w_structure("RSA", rsa, yes, der, SubjectPublicKeyInfo),
0cc0164d RL	144	ENCODER_w_structure("RSA", rsa, yes, pem, SubjectPublicKeyInfo),
c319b627	145
0195cdd2 RL	146	ENCODER_w_structure("RSA-PSS", rsapss, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	147	ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	148	ENCODER_w_structure("RSA-PSS", rsapss, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	149	ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, PrivateKeyInfo),
0cc0164d RL	150	ENCODER_w_structure("RSA-PSS", rsapss, yes, der, SubjectPublicKeyInfo),
0cc0164d RL	151	ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, SubjectPublicKeyInfo),
ece9304c RL	152
ece9304c RL	153	#ifndef OPENSSL_NO_DH
0195cdd2 RL	154	ENCODER_w_structure("DH", dh, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	155	ENCODER_w_structure("DH", dh, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	156	ENCODER_w_structure("DH", dh, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	157	ENCODER_w_structure("DH", dh, yes, pem, PrivateKeyInfo),
0cc0164d RL	158	ENCODER_w_structure("DH", dh, yes, der, SubjectPublicKeyInfo),
	159	ENCODER_w_structure("DH", dh, yes, pem, SubjectPublicKeyInfo),
	160
0195cdd2 RL	161	ENCODER_w_structure("DHX", dhx, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	162	ENCODER_w_structure("DHX", dhx, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	163	ENCODER_w_structure("DHX", dhx, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	164	ENCODER_w_structure("DHX", dhx, yes, pem, PrivateKeyInfo),
0cc0164d RL	165	ENCODER_w_structure("DHX", dhx, yes, der, SubjectPublicKeyInfo),
0cc0164d RL	166	ENCODER_w_structure("DHX", dhx, yes, pem, SubjectPublicKeyInfo),
ece9304c RL	167	#endif
	168
	169	#ifndef OPENSSL_NO_DSA
0195cdd2 RL	170	ENCODER_w_structure("DSA", dsa, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	171	ENCODER_w_structure("DSA", dsa, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	172	ENCODER_w_structure("DSA", dsa, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	173	ENCODER_w_structure("DSA", dsa, yes, pem, PrivateKeyInfo),
0cc0164d RL	174	ENCODER_w_structure("DSA", dsa, yes, der, SubjectPublicKeyInfo),
0cc0164d RL	175	ENCODER_w_structure("DSA", dsa, yes, pem, SubjectPublicKeyInfo),
ece9304c RL	176	#endif
	177
	178	#ifndef OPENSSL_NO_EC
0195cdd2 RL	179	ENCODER_w_structure("EC", ec, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	180	ENCODER_w_structure("EC", ec, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	181	ENCODER_w_structure("EC", ec, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	182	ENCODER_w_structure("EC", ec, yes, pem, PrivateKeyInfo),
0cc0164d RL	183	ENCODER_w_structure("EC", ec, yes, der, SubjectPublicKeyInfo),
	184	ENCODER_w_structure("EC", ec, yes, pem, SubjectPublicKeyInfo),
	185
4032cd9a	186	#ifndef OPENSSL_NO_ECX
0195cdd2 RL	187	ENCODER_w_structure("X25519", x25519, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	188	ENCODER_w_structure("X25519", x25519, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	189	ENCODER_w_structure("X25519", x25519, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	190	ENCODER_w_structure("X25519", x25519, yes, pem, PrivateKeyInfo),
0cc0164d RL	191	ENCODER_w_structure("X25519", x25519, yes, der, SubjectPublicKeyInfo),
	192	ENCODER_w_structure("X25519", x25519, yes, pem, SubjectPublicKeyInfo),
	193
0195cdd2 RL	194	ENCODER_w_structure("X448", x448, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	195	ENCODER_w_structure("X448", x448, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	196	ENCODER_w_structure("X448", x448, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	197	ENCODER_w_structure("X448", x448, yes, pem, PrivateKeyInfo),
0cc0164d RL	198	ENCODER_w_structure("X448", x448, yes, der, SubjectPublicKeyInfo),
	199	ENCODER_w_structure("X448", x448, yes, pem, SubjectPublicKeyInfo),
	200
0195cdd2 RL	201	ENCODER_w_structure("ED25519", ed25519, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	202	ENCODER_w_structure("ED25519", ed25519, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	203	ENCODER_w_structure("ED25519", ed25519, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	204	ENCODER_w_structure("ED25519", ed25519, yes, pem, PrivateKeyInfo),
0cc0164d RL	205	ENCODER_w_structure("ED25519", ed25519, yes, der, SubjectPublicKeyInfo),
	206	ENCODER_w_structure("ED25519", ed25519, yes, pem, SubjectPublicKeyInfo),
	207
0195cdd2 RL	208	ENCODER_w_structure("ED448", ed448, yes, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	209	ENCODER_w_structure("ED448", ed448, yes, pem, EncryptedPrivateKeyInfo),
6a2b8ff3 RL	210	ENCODER_w_structure("ED448", ed448, yes, der, PrivateKeyInfo),
6a2b8ff3 RL	211	ENCODER_w_structure("ED448", ed448, yes, pem, PrivateKeyInfo),
0cc0164d RL	212	ENCODER_w_structure("ED448", ed448, yes, der, SubjectPublicKeyInfo),
0cc0164d RL	213	ENCODER_w_structure("ED448", ed448, yes, pem, SubjectPublicKeyInfo),
4032cd9a	214	# endif
f2db0528 RL	215
f2db0528 RL	216	# ifndef OPENSSL_NO_SM2
0195cdd2 RL	217	ENCODER_w_structure("SM2", sm2, no, der, EncryptedPrivateKeyInfo),
0195cdd2 RL	218	ENCODER_w_structure("SM2", sm2, no, pem, EncryptedPrivateKeyInfo),
a6f8e131 P	219	ENCODER_w_structure("SM2", sm2, no, der, PrivateKeyInfo),
	220	ENCODER_w_structure("SM2", sm2, no, pem, PrivateKeyInfo),
	221	ENCODER_w_structure("SM2", sm2, no, der, SubjectPublicKeyInfo),
	222	ENCODER_w_structure("SM2", sm2, no, pem, SubjectPublicKeyInfo),
f2db0528	223	# endif
c319b627 RL	224	#endif
	225
	226	/*
	227	* Entries for key type specific output formats. These are exactly the
	228	* same as the type specific above, except that they use the key type
	229	* name as structure name instead of "type-specific", in the call on
fe75766c	230	* OSSL_ENCODER_CTX_new_for_pkey().
c319b627 RL	231	*/
	232
	233	/* The RSA encoders only support private key and public key output */
0cc0164d RL	234	ENCODER_w_structure("RSA", rsa, yes, der, RSA),
0cc0164d RL	235	ENCODER_w_structure("RSA", rsa, yes, pem, RSA),
c319b627 RL	236	#ifndef OPENSSL_NO_DH
c319b627 RL	237	/* DH and X9.42 DH only support key parameters output. */
0cc0164d RL	238	ENCODER_w_structure("DH", dh, yes, der, DH),
	239	ENCODER_w_structure("DH", dh, yes, pem, DH),
	240	ENCODER_w_structure("DHX", dhx, yes, der, DHX),
	241	ENCODER_w_structure("DHX", dhx, yes, pem, DHX),
c319b627 RL	242	#endif
c319b627 RL	243	#ifndef OPENSSL_NO_DSA
0cc0164d RL	244	ENCODER_w_structure("DSA", dsa, yes, der, DSA),
0cc0164d RL	245	ENCODER_w_structure("DSA", dsa, yes, pem, DSA),
c319b627 RL	246	#endif
c319b627 RL	247	#ifndef OPENSSL_NO_EC
0cc0164d RL	248	ENCODER_w_structure("EC", ec, yes, der, EC),
0cc0164d RL	249	ENCODER_w_structure("EC", ec, yes, pem, EC),
c319b627 RL	250	#endif
	251
	252	/*
	253	* Additional entries with structure names being the standard name.
	254	* This is entirely for the convenience of the user that wants to use
	255	* OSSL_ENCODER directly with names they may fancy. These do not impact
	256	* on libcrypto functionality in any way.
	257	*/
	258	/* PKCS#1 is a well known for plain RSA keys, so we add that too */
0cc0164d RL	259	ENCODER_w_structure("RSA", rsa, yes, der, PKCS1),
	260	ENCODER_w_structure("RSA", rsa, yes, pem, PKCS1),
	261	ENCODER_w_structure("RSA-PSS", rsapss, yes, der, PKCS1),
	262	ENCODER_w_structure("RSA-PSS", rsapss, yes, pem, PKCS1),
c319b627 RL	263	#ifndef OPENSSL_NO_DH
c319b627 RL	264	/* PKCS#3 defines the format for DH parameters */
0cc0164d RL	265	ENCODER_w_structure("DH", dh, yes, der, PKCS3),
0cc0164d RL	266	ENCODER_w_structure("DH", dh, yes, pem, PKCS3),
c319b627	267	/* X9.42 defines the format for DHX parameters */
0cc0164d RL	268	ENCODER_w_structure("DHX", dhx, yes, der, X9_42),
0cc0164d RL	269	ENCODER_w_structure("DHX", dhx, yes, pem, X9_42),
c319b627 RL	270	#endif
	271	#ifndef OPENSSL_NO_EC
	272	/* RFC 5915 defines the format for EC keys and parameters */
0cc0164d RL	273	ENCODER_w_structure("EC", ec, yes, der, X9_62),
0cc0164d RL	274	ENCODER_w_structure("EC", ec, yes, pem, X9_62),
ece9304c	275	#endif