Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libcrypto/asn1/x_pubkey.c	Lines:	60	171	35.1 %
Date:	2017-11-13	Branches:	26	82	31.7 %


/* $OpenBSD: x_pubkey.c,v 1.26 2017/01/29 17:49:22 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * 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 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 acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS 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 AUTHOR OR 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.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>

#include <openssl/opensslconf.h>

#include <openssl/asn1t.h>
#include <openssl/err.h>
#include <openssl/x509.h>

#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
#ifndef OPENSSL_NO_RSA
#include <openssl/rsa.h>
#endif

#include "asn1_locl.h"

/* Minor tweak to operation: free up EVP_PKEY */
static int
pubkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
{
	if (operation == ASN1_OP_FREE_POST) {
		X509_PUBKEY *pubkey = (X509_PUBKEY *)*pval;
		EVP_PKEY_free(pubkey->pkey);
	}
	return 1;
}

static const ASN1_AUX X509_PUBKEY_aux = {
	.asn1_cb = pubkey_cb,
};
static const ASN1_TEMPLATE X509_PUBKEY_seq_tt[] = {
	{
		.offset = offsetof(X509_PUBKEY, algor),
		.field_name = "algor",
		.item = &X509_ALGOR_it,
	},
	{
		.offset = offsetof(X509_PUBKEY, public_key),
		.field_name = "public_key",
		.item = &ASN1_BIT_STRING_it,
	},
};

const ASN1_ITEM X509_PUBKEY_it = {
	.itype = ASN1_ITYPE_SEQUENCE,
	.utype = V_ASN1_SEQUENCE,
	.templates = X509_PUBKEY_seq_tt,
	.tcount = sizeof(X509_PUBKEY_seq_tt) / sizeof(ASN1_TEMPLATE),
	.funcs = &X509_PUBKEY_aux,
	.size = sizeof(X509_PUBKEY),
	.sname = "X509_PUBKEY",
};


X509_PUBKEY *
d2i_X509_PUBKEY(X509_PUBKEY **a, const unsigned char **in, long len)
{
	return (X509_PUBKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
	    &X509_PUBKEY_it);
}

int
i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out)
{
	return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it);
}

X509_PUBKEY *
X509_PUBKEY_new(void)
{
	return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it);
}

void
X509_PUBKEY_free(X509_PUBKEY *a)
{
	ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it);
}

int
X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
{
	X509_PUBKEY *pk = NULL;

	if (x == NULL)
		return (0);
	if ((pk = X509_PUBKEY_new()) == NULL)
		goto error;

	if (pkey->ameth) {
		if (pkey->ameth->pub_encode) {
			if (!pkey->ameth->pub_encode(pk, pkey)) {
				X509error(X509_R_PUBLIC_KEY_ENCODE_ERROR);
				goto error;
			}
		} else {
			X509error(X509_R_METHOD_NOT_SUPPORTED);
			goto error;
		}
	} else {
		X509error(X509_R_UNSUPPORTED_ALGORITHM);
		goto error;
	}

	if (*x != NULL)
		X509_PUBKEY_free(*x);

	*x = pk;

	return 1;

error:
	if (pk != NULL)
		X509_PUBKEY_free(pk);
	return 0;
}

EVP_PKEY *
X509_PUBKEY_get(X509_PUBKEY *key)
{
	EVP_PKEY *ret = NULL;

	if (key == NULL)
		goto error;

	if (key->pkey != NULL) {
		CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
		return key->pkey;
	}

	if (key->public_key == NULL)
		goto error;

	if ((ret = EVP_PKEY_new()) == NULL) {
		X509error(ERR_R_MALLOC_FAILURE);
		goto error;
	}

	if (!EVP_PKEY_set_type(ret, OBJ_obj2nid(key->algor->algorithm))) {
		X509error(X509_R_UNSUPPORTED_ALGORITHM);
		goto error;
	}

	if (ret->ameth->pub_decode) {
		if (!ret->ameth->pub_decode(ret, key)) {
			X509error(X509_R_PUBLIC_KEY_DECODE_ERROR);
			goto error;
		}
	} else {
		X509error(X509_R_METHOD_NOT_SUPPORTED);
		goto error;
	}

	/* Check to see if another thread set key->pkey first */
	CRYPTO_w_lock(CRYPTO_LOCK_EVP_PKEY);
	if (key->pkey) {
		CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
		EVP_PKEY_free(ret);
		ret = key->pkey;
	} else {
		key->pkey = ret;
		CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
	}
	CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY);

	return ret;

error:
	EVP_PKEY_free(ret);
	return (NULL);
}

/* Now two pseudo ASN1 routines that take an EVP_PKEY structure
 * and encode or decode as X509_PUBKEY
 */

EVP_PKEY *
d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length)
{
	X509_PUBKEY *xpk;
	EVP_PKEY *pktmp;
	xpk = d2i_X509_PUBKEY(NULL, pp, length);
	if (!xpk)
		return NULL;
	pktmp = X509_PUBKEY_get(xpk);
	X509_PUBKEY_free(xpk);
	if (!pktmp)
		return NULL;
	if (a) {
		EVP_PKEY_free(*a);
		*a = pktmp;
	}
	return pktmp;
}

int
i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
{
	X509_PUBKEY *xpk = NULL;
	int ret;
	if (!a)
		return 0;
	if (!X509_PUBKEY_set(&xpk, a))
		return 0;
	ret = i2d_X509_PUBKEY(xpk, pp);
	X509_PUBKEY_free(xpk);
	return ret;
}

/* The following are equivalents but which return RSA and DSA
 * keys
 */
#ifndef OPENSSL_NO_RSA
RSA *
d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length)
{
	EVP_PKEY *pkey;
	RSA *key;
	const unsigned char *q;
	q = *pp;
	pkey = d2i_PUBKEY(NULL, &q, length);
	if (!pkey)
		return NULL;
	key = EVP_PKEY_get1_RSA(pkey);
	EVP_PKEY_free(pkey);
	if (!key)
		return NULL;
	*pp = q;
	if (a) {
		RSA_free(*a);
		*a = key;
	}
	return key;
}

int
i2d_RSA_PUBKEY(RSA *a, unsigned char **pp)
{
	EVP_PKEY *pktmp;
	int ret;
	if (!a)
		return 0;
	pktmp = EVP_PKEY_new();
	if (!pktmp) {
		ASN1error(ERR_R_MALLOC_FAILURE);
		return 0;
	}
	EVP_PKEY_set1_RSA(pktmp, a);
	ret = i2d_PUBKEY(pktmp, pp);
	EVP_PKEY_free(pktmp);
	return ret;
}
#endif

#ifndef OPENSSL_NO_DSA
DSA *
d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length)
{
	EVP_PKEY *pkey;
	DSA *key;
	const unsigned char *q;
	q = *pp;
	pkey = d2i_PUBKEY(NULL, &q, length);
	if (!pkey)
		return NULL;
	key = EVP_PKEY_get1_DSA(pkey);
	EVP_PKEY_free(pkey);
	if (!key)
		return NULL;
	*pp = q;
	if (a) {
		DSA_free(*a);
		*a = key;
	}
	return key;
}

int
i2d_DSA_PUBKEY(DSA *a, unsigned char **pp)
{
	EVP_PKEY *pktmp;
	int ret;
	if (!a)
		return 0;
	pktmp = EVP_PKEY_new();
	if (!pktmp) {
		ASN1error(ERR_R_MALLOC_FAILURE);
		return 0;
	}
	EVP_PKEY_set1_DSA(pktmp, a);
	ret = i2d_PUBKEY(pktmp, pp);
	EVP_PKEY_free(pktmp);
	return ret;
}
#endif

#ifndef OPENSSL_NO_EC
EC_KEY *
d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length)
{
	EVP_PKEY *pkey;
	EC_KEY *key;
	const unsigned char *q;
	q = *pp;
	pkey = d2i_PUBKEY(NULL, &q, length);
	if (!pkey)
		return (NULL);
	key = EVP_PKEY_get1_EC_KEY(pkey);
	EVP_PKEY_free(pkey);
	if (!key)
		return (NULL);
	*pp = q;
	if (a) {
		EC_KEY_free(*a);
		*a = key;
	}
	return (key);
}

int
i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp)
{
	EVP_PKEY *pktmp;
	int ret;
	if (!a)
		return (0);
	if ((pktmp = EVP_PKEY_new()) == NULL) {
		ASN1error(ERR_R_MALLOC_FAILURE);
		return (0);
	}
	EVP_PKEY_set1_EC_KEY(pktmp, a);
	ret = i2d_PUBKEY(pktmp, pp);
	EVP_PKEY_free(pktmp);
	return (ret);
}
#endif

int
X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, int ptype,
    void *pval, unsigned char *penc, int penclen)
{
	if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval))
		return 0;
	if (penc) {
		free(pub->public_key->data);
		pub->public_key->data = penc;
		pub->public_key->length = penclen;
		/* Set number of unused bits to zero */
		pub->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
		pub->public_key->flags |= ASN1_STRING_FLAG_BITS_LEFT;
	}
	return 1;
}

int
X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk,
    int *ppklen, X509_ALGOR **pa, X509_PUBKEY *pub)
{
	if (ppkalg)
		*ppkalg = pub->algor->algorithm;
	if (pk) {
		*pk = pub->public_key->data;
		*ppklen = pub->public_key->length;
	}
	if (pa)
		*pa = pub->algor;
	return 1;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: x_pubkey.c,v 1.26 2017/01/29 17:49:22 beck Exp $ */
2			/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3			* All rights reserved.
4			*
5			* This package is an SSL implementation written
6			* by Eric Young (eay@cryptsoft.com).
7			* The implementation was written so as to conform with Netscapes SSL.
8			*
9			* This library is free for commercial and non-commercial use as long as
10			* the following conditions are aheared to. The following conditions
11			* apply to all code found in this distribution, be it the RC4, RSA,
12			* lhash, DES, etc., code; not just the SSL code. The SSL documentation
13			* included with this distribution is covered by the same copyright terms
14			* except that the holder is Tim Hudson (tjh@cryptsoft.com).
15			*
16			* Copyright remains Eric Young's, and as such any Copyright notices in
17			* the code are not to be removed.
18			* If this package is used in a product, Eric Young should be given attribution
19			* as the author of the parts of the library used.
20			* This can be in the form of a textual message at program startup or
21			* in documentation (online or textual) provided with the package.
22			*
23			* Redistribution and use in source and binary forms, with or without
24			* modification, are permitted provided that the following conditions
25			* are met:
26			* 1. Redistributions of source code must retain the copyright
27			* notice, this list of conditions and the following disclaimer.
28			* 2. Redistributions in binary form must reproduce the above copyright
29			* notice, this list of conditions and the following disclaimer in the
30			* documentation and/or other materials provided with the distribution.
31			* 3. All advertising materials mentioning features or use of this software
32			* must display the following acknowledgement:
33			* "This product includes cryptographic software written by
34			* Eric Young (eay@cryptsoft.com)"
35			* The word 'cryptographic' can be left out if the rouines from the library
36			* being used are not cryptographic related :-).
37			* 4. If you include any Windows specific code (or a derivative thereof) from
38			* the apps directory (application code) you must include an acknowledgement:
39			* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40			*
41			* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51			* SUCH DAMAGE.
52			*
53			* The licence and distribution terms for any publically available version or
54			* derivative of this code cannot be changed. i.e. this code cannot simply be
55			* copied and put under another distribution licence
56			* [including the GNU Public Licence.]
57			*/
58
59			#include <stdio.h>
60
61			#include <openssl/opensslconf.h>
62
63			#include <openssl/asn1t.h>
64			#include <openssl/err.h>
65			#include <openssl/x509.h>
66
67			#ifndef OPENSSL_NO_DSA
68			#include <openssl/dsa.h>
69			#endif
70			#ifndef OPENSSL_NO_RSA
71			#include <openssl/rsa.h>
72			#endif
73
74			#include "asn1_locl.h"
75
76			/* Minor tweak to operation: free up EVP_PKEY */
77			static int
78			pubkey_cb(int operation, ASN1_VALUE *pval, const ASN1_ITEM it, void *exarg)
79			{
80	✓✓	159196	if (operation == ASN1_OP_FREE_POST) {
81		13251	X509_PUBKEY pubkey = (X509_PUBKEY )*pval;
82		13251	EVP_PKEY_free(pubkey->pkey);
83		13251	}
84		79598	return 1;
85			}
86
87			static const ASN1_AUX X509_PUBKEY_aux = {
88			.asn1_cb = pubkey_cb,
89			};
90			static const ASN1_TEMPLATE X509_PUBKEY_seq_tt[] = {
91			{
92			.offset = offsetof(X509_PUBKEY, algor),
93			.field_name = "algor",
94			.item = &X509_ALGOR_it,
95			},
96			{
97			.offset = offsetof(X509_PUBKEY, public_key),
98			.field_name = "public_key",
99			.item = &ASN1_BIT_STRING_it,
100			},
101			};
102
103			const ASN1_ITEM X509_PUBKEY_it = {
104			.itype = ASN1_ITYPE_SEQUENCE,
105			.utype = V_ASN1_SEQUENCE,
106			.templates = X509_PUBKEY_seq_tt,
107			.tcount = sizeof(X509_PUBKEY_seq_tt) / sizeof(ASN1_TEMPLATE),
108			.funcs = &X509_PUBKEY_aux,
109			.size = sizeof(X509_PUBKEY),
110			.sname = "X509_PUBKEY",
111			};
112
113
114			X509_PUBKEY *
115			d2i_X509_PUBKEY(X509_PUBKEY a, const unsigned char in, long len)
116			{
117			return (X509_PUBKEY )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
118			&X509_PUBKEY_it);
119			}
120
121			int
122			i2d_X509_PUBKEY(X509_PUBKEY a, unsigned char *out)
123			{
124		12	return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it);
125			}
126
127			X509_PUBKEY *
128			X509_PUBKEY_new(void)
129			{
130		88	return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it);
131			}
132
133			void
134			X509_PUBKEY_free(X509_PUBKEY *a)
135			{
136		88	ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it);
137		44	}
138
139			int
140			X509_PUBKEY_set(X509_PUBKEY *x, EVP_PKEY pkey)
141			{
142			X509_PUBKEY *pk = NULL;
143
144	✗✓	88	if (x == NULL)
145			return (0);
146	✓✗	44	if ((pk = X509_PUBKEY_new()) == NULL)
147			goto error;
148
149	✓✗	44	if (pkey->ameth) {
150	✓✗	44	if (pkey->ameth->pub_encode) {
151	✗✓	44	if (!pkey->ameth->pub_encode(pk, pkey)) {
152			X509error(X509_R_PUBLIC_KEY_ENCODE_ERROR);
153			goto error;
154			}
155			} else {
156			X509error(X509_R_METHOD_NOT_SUPPORTED);
157			goto error;
158			}
159			} else {
160			X509error(X509_R_UNSUPPORTED_ALGORITHM);
161			goto error;
162			}
163
164	✓✓	44	if (*x != NULL)
165		40	X509_PUBKEY_free(*x);
166
167		44	*x = pk;
168
169		44	return 1;
170
171			error:
172			if (pk != NULL)
173			X509_PUBKEY_free(pk);
174			return 0;
175		44	}
176
177			EVP_PKEY *
178			X509_PUBKEY_get(X509_PUBKEY *key)
179			{
180			EVP_PKEY *ret = NULL;
181
182	✓✗	12706	if (key == NULL)
183			goto error;
184
185	✓✓	6353	if (key->pkey != NULL) {
186		4490	CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
187		4490	return key->pkey;
188			}
189
190	✓✗	1863	if (key->public_key == NULL)
191			goto error;
192
193	✗✓	1863	if ((ret = EVP_PKEY_new()) == NULL) {
194			X509error(ERR_R_MALLOC_FAILURE);
195			goto error;
196			}
197
198	✗✓	1863	if (!EVP_PKEY_set_type(ret, OBJ_obj2nid(key->algor->algorithm))) {
199			X509error(X509_R_UNSUPPORTED_ALGORITHM);
200			goto error;
201			}
202
203	✓✗	1863	if (ret->ameth->pub_decode) {
204	✗✓	1863	if (!ret->ameth->pub_decode(ret, key)) {
205			X509error(X509_R_PUBLIC_KEY_DECODE_ERROR);
206			goto error;
207			}
208			} else {
209			X509error(X509_R_METHOD_NOT_SUPPORTED);
210			goto error;
211			}
212
213			/* Check to see if another thread set key->pkey first */
214		1863	CRYPTO_w_lock(CRYPTO_LOCK_EVP_PKEY);
215	✗✓	1863	if (key->pkey) {
216			CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
217			EVP_PKEY_free(ret);
218			ret = key->pkey;
219			} else {
220		1863	key->pkey = ret;
221		1863	CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
222			}
223		1863	CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY);
224
225		1863	return ret;
226
227			error:
228			EVP_PKEY_free(ret);
229			return (NULL);
230		6353	}
231
232			/* Now two pseudo ASN1 routines that take an EVP_PKEY structure
233			* and encode or decode as X509_PUBKEY
234			*/
235
236			EVP_PKEY *
237			d2i_PUBKEY(EVP_PKEY a, const unsigned char pp, long length)
238			{
239			X509_PUBKEY *xpk;
240			EVP_PKEY *pktmp;
241			xpk = d2i_X509_PUBKEY(NULL, pp, length);
242			if (!xpk)
243			return NULL;
244			pktmp = X509_PUBKEY_get(xpk);
245			X509_PUBKEY_free(xpk);
246			if (!pktmp)
247			return NULL;
248			if (a) {
249			EVP_PKEY_free(*a);
250			*a = pktmp;
251			}
252			return pktmp;
253			}
254
255			int
256			i2d_PUBKEY(EVP_PKEY a, unsigned char *pp)
257			{
258		8	X509_PUBKEY *xpk = NULL;
259			int ret;
260	✗✓	4	if (!a)
261			return 0;
262	✗✓	4	if (!X509_PUBKEY_set(&xpk, a))
263			return 0;
264		4	ret = i2d_X509_PUBKEY(xpk, pp);
265		4	X509_PUBKEY_free(xpk);
266		4	return ret;
267		4	}
268
269			/* The following are equivalents but which return RSA and DSA
270			* keys
271			*/
272			#ifndef OPENSSL_NO_RSA
273			RSA *
274			d2i_RSA_PUBKEY(RSA a, const unsigned char pp, long length)
275			{
276			EVP_PKEY *pkey;
277			RSA *key;
278			const unsigned char *q;
279			q = *pp;
280			pkey = d2i_PUBKEY(NULL, &q, length);
281			if (!pkey)
282			return NULL;
283			key = EVP_PKEY_get1_RSA(pkey);
284			EVP_PKEY_free(pkey);
285			if (!key)
286			return NULL;
287			*pp = q;
288			if (a) {
289			RSA_free(*a);
290			*a = key;
291			}
292			return key;
293			}
294
295			int
296			i2d_RSA_PUBKEY(RSA a, unsigned char *pp)
297			{
298			EVP_PKEY *pktmp;
299			int ret;
300			if (!a)
301			return 0;
302			pktmp = EVP_PKEY_new();
303			if (!pktmp) {
304			ASN1error(ERR_R_MALLOC_FAILURE);
305			return 0;
306			}
307			EVP_PKEY_set1_RSA(pktmp, a);
308			ret = i2d_PUBKEY(pktmp, pp);
309			EVP_PKEY_free(pktmp);
310			return ret;
311			}
312			#endif
313
314			#ifndef OPENSSL_NO_DSA
315			DSA *
316			d2i_DSA_PUBKEY(DSA a, const unsigned char pp, long length)
317			{
318			EVP_PKEY *pkey;
319			DSA *key;
320			const unsigned char *q;
321			q = *pp;
322			pkey = d2i_PUBKEY(NULL, &q, length);
323			if (!pkey)
324			return NULL;
325			key = EVP_PKEY_get1_DSA(pkey);
326			EVP_PKEY_free(pkey);
327			if (!key)
328			return NULL;
329			*pp = q;
330			if (a) {
331			DSA_free(*a);
332			*a = key;
333			}
334			return key;
335			}
336
337			int
338			i2d_DSA_PUBKEY(DSA a, unsigned char *pp)
339			{
340			EVP_PKEY *pktmp;
341			int ret;
342			if (!a)
343			return 0;
344			pktmp = EVP_PKEY_new();
345			if (!pktmp) {
346			ASN1error(ERR_R_MALLOC_FAILURE);
347			return 0;
348			}
349			EVP_PKEY_set1_DSA(pktmp, a);
350			ret = i2d_PUBKEY(pktmp, pp);
351			EVP_PKEY_free(pktmp);
352			return ret;
353			}
354			#endif
355
356			#ifndef OPENSSL_NO_EC
357			EC_KEY *
358			d2i_EC_PUBKEY(EC_KEY a, const unsigned char pp, long length)
359			{
360			EVP_PKEY *pkey;
361			EC_KEY *key;
362			const unsigned char *q;
363			q = *pp;
364			pkey = d2i_PUBKEY(NULL, &q, length);
365			if (!pkey)
366			return (NULL);
367			key = EVP_PKEY_get1_EC_KEY(pkey);
368			EVP_PKEY_free(pkey);
369			if (!key)
370			return (NULL);
371			*pp = q;
372			if (a) {
373			EC_KEY_free(*a);
374			*a = key;
375			}
376			return (key);
377			}
378
379			int
380			i2d_EC_PUBKEY(EC_KEY a, unsigned char *pp)
381			{
382			EVP_PKEY *pktmp;
383			int ret;
384			if (!a)
385			return (0);
386			if ((pktmp = EVP_PKEY_new()) == NULL) {
387			ASN1error(ERR_R_MALLOC_FAILURE);
388			return (0);
389			}
390			EVP_PKEY_set1_EC_KEY(pktmp, a);
391			ret = i2d_PUBKEY(pktmp, pp);
392			EVP_PKEY_free(pktmp);
393			return (ret);
394			}
395			#endif
396
397			int
398			X509_PUBKEY_set0_param(X509_PUBKEY pub, ASN1_OBJECT aobj, int ptype,
399			void pval, unsigned char penc, int penclen)
400			{
401	✗✓	88	if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval))
402			return 0;
403	✓✗	44	if (penc) {
404		44	free(pub->public_key->data);
405		44	pub->public_key->data = penc;
406		44	pub->public_key->length = penclen;
407			/* Set number of unused bits to zero */
408		44	pub->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT\|0x07);
409		44	pub->public_key->flags \|= ASN1_STRING_FLAG_BITS_LEFT;
410		44	}
411		44	return 1;
412		44	}
413
414			int
415			X509_PUBKEY_get0_param(ASN1_OBJECT ppkalg, const unsigned char pk,
416			int ppklen, X509_ALGOR pa, X509_PUBKEY pub)
417			{
418	✗✓	3726	if (ppkalg)
419			*ppkalg = pub->algor->algorithm;
420	✓✗	1863	if (pk) {
421		1863	*pk = pub->public_key->data;
422		1863	*ppklen = pub->public_key->length;
423		1863	}
424	✓✓	1863	if (pa)
425		4	*pa = pub->algor;
426		1863	return 1;
427			}