[thirdparty/openssl.git] / crypto / asn1 / ameth_lib.c

/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
 * project 2006.
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/asn1t.h>
#include <openssl/x509.h>
#include <openssl/ec.h>
#include "asn1_locl.h"

extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[];
extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[];
extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth;
extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth;

/* Keep this sorted in type order !! */
static const EVP_PKEY_ASN1_METHOD *standard_methods[] = 
	{
#ifndef OPENSSL_NO_RSA
	&rsa_asn1_meths[0],
	&rsa_asn1_meths[1],
#endif
#ifndef OPENSSL_NO_DH
	&dh_asn1_meth,
#endif
#ifndef OPENSSL_NO_DSA
	&dsa_asn1_meths[0],
	&dsa_asn1_meths[1],
	&dsa_asn1_meths[2],
	&dsa_asn1_meths[3],
	&dsa_asn1_meths[4],
#endif
#ifndef OPENSSL_NO_EC
	&eckey_asn1_meth
#endif
	};

typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
static STACK *app_methods = NULL;


#ifdef TEST
void main()
	{
	int i;
	for (i = 0;
		i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
		i++)
		fprintf(stderr, "Number %d id=%d (%s)\n", i,
			standard_methods[i]->pkey_id,
			OBJ_nid2sn(standard_methods[i]->pkey_id));
	}
#endif

static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a,
                const EVP_PKEY_ASN1_METHOD * const *b)
	{
        return ((*a)->pkey_id - (*b)->pkey_id);
	}

int EVP_PKEY_asn1_get_count(void)
	{
	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	if (app_methods)
		num += sk_num(app_methods);
	return num;
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
	{
	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	if (idx < 0)
		return NULL; 
	if (idx < num)
		return standard_methods[idx];
	idx -= num;
	return (const EVP_PKEY_ASN1_METHOD *)sk_value(app_methods, idx);
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(int type)
	{
	EVP_PKEY_ASN1_METHOD tmp, *t = &tmp, **ret;
	tmp.pkey_id = type;
	if (app_methods)
		{
		int idx;
		idx = sk_find(app_methods, (char *)&tmp);
		if (idx >= 0)
			return (EVP_PKEY_ASN1_METHOD *)
				sk_value(app_methods, idx);
		}
	ret = (EVP_PKEY_ASN1_METHOD **) OBJ_bsearch((char *)&t,
        		(char *)standard_methods,
			sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *),
        		sizeof(EVP_PKEY_ASN1_METHOD *),
			(int (*)(const void *, const void *))ameth_cmp);
	if (!ret || !*ret)
		return NULL;
	if ((*ret)->pkey_flags & ASN1_PKEY_ALIAS)
		return EVP_PKEY_asn1_find((*ret)->pkey_base_id);
	return *ret;
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(const char *str, int len)
	{
	int i;
	const EVP_PKEY_ASN1_METHOD *ameth;
	if (len == -1)
		len = strlen(str);
	for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
		{
		ameth = EVP_PKEY_asn1_get0(i);
		if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
			continue;
		if (((int)strlen(ameth->pem_str) == len) && 
			!strncasecmp(ameth->pem_str, str, len))
			return ameth;
		}
	return NULL;
	}

int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
	{
	if (app_methods == NULL)
		{
		app_methods = sk_new((sk_cmp_fn_type *)ameth_cmp);
		if (!app_methods)
			return 0;
		}
	if (!sk_push(app_methods, (char *)ameth))
		return 0;
	sk_sort(app_methods);
	return 1;
	}

int EVP_PKEY_asn1_add_alias(int to, int from)
	{
	EVP_PKEY_ASN1_METHOD *ameth;
	ameth = EVP_PKEY_asn1_new(from, NULL, NULL);
	if (!ameth)
		return 0;
	ameth->pkey_base_id = to;
	ameth->pkey_flags |= ASN1_PKEY_ALIAS;
	return EVP_PKEY_asn1_add0(ameth);
	}

int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
				const char **pinfo, const char **ppem_str,
					const EVP_PKEY_ASN1_METHOD *ameth)
	{
	if (!ameth)
		return 0;
	if (ppkey_id)
		*ppkey_id = ameth->pkey_id;
	if (ppkey_base_id)
		*ppkey_base_id = ameth->pkey_base_id;
	if (ppkey_flags)
		*ppkey_flags = ameth->pkey_flags;
	if (pinfo)
		*pinfo = ameth->info;
	if (ppem_str)
		*ppem_str = ameth->pem_str;
	return 1;
	}

EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id,
					const char *pem_str, const char *info)
	{
	EVP_PKEY_ASN1_METHOD *ameth;
	ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));
	if (!ameth)
		return NULL;

	ameth->pkey_id = id;
	ameth->pkey_base_id = id;
	ameth->pkey_flags = ASN1_PKEY_DYNAMIC;

	if (info)
		{
		ameth->info = BUF_strdup(info);
		if (!ameth->info)
			goto err;
		}

	if (pem_str)
		{
		ameth->pem_str = BUF_strdup(pem_str);
		if (!ameth->pem_str)
			goto err;
		}
	
	ameth->pub_decode = 0;
	ameth->pub_encode = 0;
	ameth->pub_cmp = 0;
	ameth->pub_print = 0;

	ameth->priv_decode = 0;
	ameth->priv_encode = 0;
	ameth->priv_print = 0;

	ameth->pkey_size = 0;
	ameth->pkey_bits = 0;

	ameth->param_decode = 0;
	ameth->param_encode = 0;
	ameth->param_missing = 0;
	ameth->param_copy = 0;
	ameth->param_cmp = 0;
	ameth->param_print = 0;

	ameth->pkey_free = 0;
	ameth->pkey_ctrl = 0;

	return ameth;

	err:

	EVP_PKEY_asn1_free(ameth);
	return NULL;

	}

void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
	{
	if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
		{
		if (ameth->pem_str)
			OPENSSL_free(ameth->pem_str);
		if (ameth->info)
			OPENSSL_free(ameth->info);
		OPENSSL_free(ameth);
		}
	}

void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
		int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub),
		int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk),
		int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
		int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx),
		int (*pkey_size)(const EVP_PKEY *pk),
		int (*pkey_bits)(const EVP_PKEY *pk))
	{
	ameth->pub_decode = pub_decode;
	ameth->pub_encode = pub_encode;
	ameth->pub_cmp = pub_cmp;
	ameth->pub_print = pub_print;
	ameth->pkey_size = pkey_size;
	ameth->pkey_bits = pkey_bits;
	}

void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
		int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf),
		int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk),
		int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx))
	{
	ameth->priv_decode = priv_decode;
	ameth->priv_encode = priv_encode;
	ameth->priv_print = priv_print;
	}

void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
		int (*param_decode)(EVP_PKEY *pkey,
				const unsigned char **pder, int derlen),
		int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder),
		int (*param_missing)(const EVP_PKEY *pk),
		int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from),
		int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
		int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx))
	{
	ameth->param_decode = param_decode;
	ameth->param_encode = param_encode;
	ameth->param_missing = param_missing;
	ameth->param_copy = param_copy;
	ameth->param_cmp = param_cmp;
	ameth->param_print = param_print;
	}

void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
		void (*pkey_free)(EVP_PKEY *pkey))
	{
	ameth->pkey_free = pkey_free;
	}

void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
		int (*pkey_ctrl)(EVP_PKEY *pkey, int op,
							long arg1, void *arg2))
	{
	ameth->pkey_ctrl = pkey_ctrl;
	}
Commit	Line	Data
448be743 DSH	1	/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
	2	* project 2006.
	3	*/
	4	/* ====================================================================
	5	* Copyright (c) 2006 The OpenSSL Project. All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	*
	14	* 2. Redistributions in binary form must reproduce the above copyright
	15	* notice, this list of conditions and the following disclaimer in
	16	* the documentation and/or other materials provided with the
	17	* distribution.
	18	*
	19	* 3. All advertising materials mentioning features or use of this
	20	* software must display the following acknowledgment:
	21	* "This product includes software developed by the OpenSSL Project
	22	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	23	*
	24	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	25	* endorse or promote products derived from this software without
	26	* prior written permission. For written permission, please contact
	27	* licensing@OpenSSL.org.
	28	*
	29	* 5. Products derived from this software may not be called "OpenSSL"
	30	* nor may "OpenSSL" appear in their names without prior written
	31	* permission of the OpenSSL Project.
	32	*
	33	* 6. Redistributions of any form whatsoever must retain the following
	34	* acknowledgment:
	35	* "This product includes software developed by the OpenSSL Project
	36	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	37	*
	38	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	39	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	40	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	41	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	42	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	43	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	44	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	45	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	46	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	47	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	48	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	49	* OF THE POSSIBILITY OF SUCH DAMAGE.
	50	* ====================================================================
	51	*
	52	* This product includes cryptographic software written by Eric Young
	53	* (eay@cryptsoft.com). This product includes software written by Tim
	54	* Hudson (tjh@cryptsoft.com).
	55	*
	56	*/
	57
	58	#include <stdio.h>
	59	#include "cryptlib.h"
	60	#include <openssl/asn1t.h>
	61	#include <openssl/x509.h>
	62	#include <openssl/ec.h>
	63	#include "asn1_locl.h"
	64
65	extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[];
66	extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[];
6f81892e	67	extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth;
448be743 DSH	68	extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth;
	69
	70	/* Keep this sorted in type order !! */
9e4d0f0b	71	static const EVP_PKEY_ASN1_METHOD *standard_methods[] =
448be743	72	{
db98bbc1	73	#ifndef OPENSSL_NO_RSA
448be743 DSH	74	&rsa_asn1_meths[0],
448be743 DSH	75	&rsa_asn1_meths[1],
db98bbc1 DSH	76	#endif
db98bbc1 DSH	77	#ifndef OPENSSL_NO_DH
6f81892e	78	&dh_asn1_meth,
db98bbc1 DSH	79	#endif
db98bbc1 DSH	80	#ifndef OPENSSL_NO_DSA
448be743 DSH	81	&dsa_asn1_meths[0],
	82	&dsa_asn1_meths[1],
	83	&dsa_asn1_meths[2],
	84	&dsa_asn1_meths[3],
	85	&dsa_asn1_meths[4],
db98bbc1 DSH	86	#endif
db98bbc1 DSH	87	#ifndef OPENSSL_NO_EC
448be743	88	&eckey_asn1_meth
db98bbc1	89	#endif
448be743 DSH	90	};
448be743 DSH	91
18e377b4 DSH	92	typedef int sk_cmp_fn_type(const char * const a, const char const *b);
	93	static STACK *app_methods = NULL;
	94
	95
	96
448be743 DSH	97	#ifdef TEST
	98	void main()
	99	{
	100	int i;
	101	for (i = 0;
	102	i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	103	i++)
6f81892e DSH	104	fprintf(stderr, "Number %d id=%d (%s)\n", i,
	105	standard_methods[i]->pkey_id,
	106	OBJ_nid2sn(standard_methods[i]->pkey_id));
448be743 DSH	107	}
	108	#endif
	109
	110	static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a,
	111	const EVP_PKEY_ASN1_METHOD * const *b)
	112	{
	113	return ((a)->pkey_id - (b)->pkey_id);
	114	}
	115
e4263314 DSH	116	int EVP_PKEY_asn1_get_count(void)
	117	{
	118	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	119	if (app_methods)
	120	num += sk_num(app_methods);
	121	return num;
	122	}
	123
	124	const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
	125	{
	126	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	127	if (idx < 0)
	128	return NULL;
	129	if (idx < num)
	130	return standard_methods[idx];
	131	idx -= num;
	132	return (const EVP_PKEY_ASN1_METHOD *)sk_value(app_methods, idx);
	133	}
	134
18e377b4	135	const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(int type)
448be743 DSH	136	{
	137	EVP_PKEY_ASN1_METHOD tmp, t = &tmp, *ret;
	138	tmp.pkey_id = type;
18e377b4 DSH	139	if (app_methods)
	140	{
	141	int idx;
86377906 DSH	142	idx = sk_find(app_methods, (char *)&tmp);
86377906 DSH	143	if (idx >= 0)
18e377b4 DSH	144	return (EVP_PKEY_ASN1_METHOD *)
	145	sk_value(app_methods, idx);
	146	}
448be743 DSH	147	ret = (EVP_PKEY_ASN1_METHOD *) OBJ_bsearch((char )&t,
	148	(char *)standard_methods,
	149	sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *),
	150	sizeof(EVP_PKEY_ASN1_METHOD *),
	151	(int ()(const void , const void *))ameth_cmp);
6f81892e DSH	152	if (!ret \|\| !*ret)
6f81892e DSH	153	return NULL;
448be743	154	if ((*ret)->pkey_flags & ASN1_PKEY_ALIAS)
18e377b4	155	return EVP_PKEY_asn1_find((*ret)->pkey_base_id);
448be743 DSH	156	return *ret;
	157	}
	158
e4263314 DSH	159	const EVP_PKEY_ASN1_METHOD EVP_PKEY_asn1_find_str(const char str, int len)
	160	{
	161	int i;
	162	const EVP_PKEY_ASN1_METHOD *ameth;
f5cda4cb DSH	163	if (len == -1)
f5cda4cb DSH	164	len = strlen(str);
e4263314 DSH	165	for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
	166	{
	167	ameth = EVP_PKEY_asn1_get0(i);
	168	if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
	169	continue;
c20276e4	170	if (((int)strlen(ameth->pem_str) == len) &&
e4263314 DSH	171	!strncasecmp(ameth->pem_str, str, len))
	172	return ameth;
	173	}
	174	return NULL;
	175	}
	176
e46691a0	177	int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
18e377b4 DSH	178	{
	179	if (app_methods == NULL)
	180	{
	181	app_methods = sk_new((sk_cmp_fn_type *)ameth_cmp);
	182	if (!app_methods)
	183	return 0;
	184	}
	185	if (!sk_push(app_methods, (char *)ameth))
	186	return 0;
	187	sk_sort(app_methods);
	188	return 1;
	189	}
	190
e46691a0 DSH	191	int EVP_PKEY_asn1_add_alias(int to, int from)
	192	{
	193	EVP_PKEY_ASN1_METHOD *ameth;
	194	ameth = EVP_PKEY_asn1_new(from, NULL, NULL);
	195	if (!ameth)
	196	return 0;
	197	ameth->pkey_base_id = to;
	198	ameth->pkey_flags \|= ASN1_PKEY_ALIAS;
	199	return EVP_PKEY_asn1_add0(ameth);
	200	}
	201
0b33dac3 DSH	202	int EVP_PKEY_asn1_get0_info(int ppkey_id, int ppkey_base_id, int *ppkey_flags,
	203	const char pinfo, const char ppem_str,
	204	const EVP_PKEY_ASN1_METHOD *ameth)
	205	{
	206	if (!ameth)
	207	return 0;
	208	if (ppkey_id)
	209	*ppkey_id = ameth->pkey_id;
	210	if (ppkey_base_id)
	211	*ppkey_base_id = ameth->pkey_base_id;
	212	if (ppkey_flags)
	213	*ppkey_flags = ameth->pkey_flags;
	214	if (pinfo)
	215	*pinfo = ameth->info;
	216	if (ppem_str)
	217	*ppem_str = ameth->pem_str;
	218	return 1;
	219	}
	220
d82e2718 DSH	221	EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id,
d82e2718 DSH	222	const char pem_str, const char info)
18e377b4 DSH	223	{
	224	EVP_PKEY_ASN1_METHOD *ameth;
	225	ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));
	226	if (!ameth)
	227	return NULL;
	228
	229	ameth->pkey_id = id;
	230	ameth->pkey_base_id = id;
	231	ameth->pkey_flags = ASN1_PKEY_DYNAMIC;
d82e2718 DSH	232
	233	if (info)
	234	{
	235	ameth->info = BUF_strdup(info);
	236	if (!ameth->info)
	237	goto err;
	238	}
	239
	240	if (pem_str)
	241	{
	242	ameth->pem_str = BUF_strdup(pem_str);
	243	if (!ameth->pem_str)
	244	goto err;
	245	}
18e377b4 DSH	246
	247	ameth->pub_decode = 0;
	248	ameth->pub_encode = 0;
	249	ameth->pub_cmp = 0;
	250	ameth->pub_print = 0;
	251
18e377b4 DSH	252	ameth->priv_decode = 0;
	253	ameth->priv_encode = 0;
	254	ameth->priv_print = 0;
18e377b4 DSH	255
	256	ameth->pkey_size = 0;
	257	ameth->pkey_bits = 0;
	258
	259	ameth->param_decode = 0;
	260	ameth->param_encode = 0;
	261	ameth->param_missing = 0;
	262	ameth->param_copy = 0;
	263	ameth->param_cmp = 0;
	264	ameth->param_print = 0;
	265
18e377b4 DSH	266	ameth->pkey_free = 0;
	267	ameth->pkey_ctrl = 0;
	268
	269	return ameth;
d82e2718 DSH	270
	271	err:
	272
	273	EVP_PKEY_asn1_free(ameth);
	274	return NULL;
	275
	276	}
	277
	278	void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
	279	{
	280	if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
	281	{
	282	if (ameth->pem_str)
	283	OPENSSL_free(ameth->pem_str);
	284	if (ameth->info)
	285	OPENSSL_free(ameth->info);
	286	OPENSSL_free(ameth);
	287	}
18e377b4 DSH	288	}
	289
	290	void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
	291	int (pub_decode)(EVP_PKEY pk, X509_PUBKEY *pub),
	292	int (pub_encode)(X509_PUBKEY pub, const EVP_PKEY *pk),
	293	int (pub_cmp)(const EVP_PKEY a, const EVP_PKEY *b),
	294	int (pub_print)(BIO out, const EVP_PKEY *pkey, int indent,
	295	ASN1_PCTX *pctx),
	296	int (pkey_size)(const EVP_PKEY pk),
	297	int (pkey_bits)(const EVP_PKEY pk))
	298	{
	299	ameth->pub_decode = pub_decode;
	300	ameth->pub_encode = pub_encode;
	301	ameth->pub_cmp = pub_cmp;
	302	ameth->pub_print = pub_print;
	303	ameth->pkey_size = pkey_size;
	304	ameth->pkey_bits = pkey_bits;
	305	}
	306
	307	void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
	308	int (priv_decode)(EVP_PKEY pk, PKCS8_PRIV_KEY_INFO *p8inf),
	309	int (priv_encode)(PKCS8_PRIV_KEY_INFO p8, const EVP_PKEY *pk),
	310	int (priv_print)(BIO out, const EVP_PKEY *pkey, int indent,
	311	ASN1_PCTX *pctx))
	312	{
	313	ameth->priv_decode = priv_decode;
	314	ameth->priv_encode = priv_encode;
	315	ameth->priv_print = priv_print;
	316	}
	317
	318	void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
db98bbc1 DSH	319	int (param_decode)(EVP_PKEY pkey,
	320	const unsigned char **pder, int derlen),
	321	int (param_encode)(const EVP_PKEY pkey, unsigned char **pder),
18e377b4 DSH	322	int (param_missing)(const EVP_PKEY pk),
	323	int (param_copy)(EVP_PKEY to, const EVP_PKEY *from),
	324	int (param_cmp)(const EVP_PKEY a, const EVP_PKEY *b),
	325	int (param_print)(BIO out, const EVP_PKEY *pkey, int indent,
	326	ASN1_PCTX *pctx))
	327	{
	328	ameth->param_decode = param_decode;
	329	ameth->param_encode = param_encode;
	330	ameth->param_missing = param_missing;
	331	ameth->param_copy = param_copy;
	332	ameth->param_cmp = param_cmp;
	333	ameth->param_print = param_print;
	334	}
	335
	336	void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
	337	void (pkey_free)(EVP_PKEY pkey))
	338	{
	339	ameth->pkey_free = pkey_free;
	340	}
	341
	342	void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
492a9e24	343	int (pkey_ctrl)(EVP_PKEY pkey, int op,
18e377b4 DSH	344	long arg1, void *arg2))
	345	{
	346	ameth->pkey_ctrl = pkey_ctrl;
	347	}