1/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2 * All rights reserved.
3 *
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
7 *
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to.  The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14 *
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
24 * are met:
25 * 1. Redistributions of source code must retain the copyright
26 *    notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 *    notice, this list of conditions and the following disclaimer in the
29 *    documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 *    must display the following acknowledgement:
32 *    "This product includes cryptographic software written by
33 *     Eric Young (eay@cryptsoft.com)"
34 *    The word 'cryptographic' can be left out if the rouines from the library
35 *    being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 *    the apps directory (application code) you must include an acknowledgement:
38 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed.  i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.] */
56
57#include <openssl/asn1.h>
58#include <openssl/buf.h>
59#include <openssl/digest.h>
60#include <openssl/dsa.h>
61#include <openssl/evp.h>
62#include <openssl/rsa.h>
63#include <openssl/stack.h>
64#include <openssl/x509.h>
65
66
67extern const ASN1_ITEM RSAPrivateKey_it;
68extern const ASN1_ITEM RSAPublicKey_it;
69
70int X509_verify(X509 *a, EVP_PKEY *r)
71	{
72	return(ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF),a->sig_alg,
73		a->signature,a->cert_info,r));
74	}
75
76int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
77	{
78	return( ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO),
79		a->sig_alg,a->signature,a->req_info,r));
80	}
81
82int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
83	{
84	x->cert_info->enc.modified = 1;
85	return(ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), x->cert_info->signature,
86		x->sig_alg, x->signature, x->cert_info,pkey,md));
87	}
88
89int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
90	{
91	x->cert_info->enc.modified = 1;
92	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
93		x->cert_info->signature,
94		x->sig_alg, x->signature, x->cert_info, ctx);
95	}
96
97/* TODO(fork)
98int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert)
99	{
100	return OCSP_REQ_CTX_nbio_d2i(rctx,
101				(ASN1_VALUE **)pcert, ASN1_ITEM_rptr(X509));
102	}
103*/
104
105int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
106	{
107	return(ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO),x->sig_alg, NULL,
108		x->signature, x->req_info,pkey,md));
109	}
110
111int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
112	{
113	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
114		x->sig_alg, NULL, x->signature, x->req_info, ctx);
115	}
116
117int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
118	{
119	x->crl->enc.modified = 1;
120	return(ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO),x->crl->sig_alg,
121		x->sig_alg, x->signature, x->crl,pkey,md));
122	}
123
124int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
125	{
126	x->crl->enc.modified = 1;
127	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
128		x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx);
129	}
130
131/* TODO(fork)
132int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl)
133	{
134	return OCSP_REQ_CTX_nbio_d2i(rctx,
135				(ASN1_VALUE **)pcrl, ASN1_ITEM_rptr(X509_CRL));
136	}
137*/
138
139int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
140	{
141	return(ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), x->sig_algor,NULL,
142		x->signature, x->spkac,pkey,md));
143	}
144
145#ifndef OPENSSL_NO_FP_API
146X509 *d2i_X509_fp(FILE *fp, X509 **x509)
147	{
148	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
149	}
150
151int i2d_X509_fp(FILE *fp, X509 *x509)
152	{
153	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
154	}
155#endif
156
157X509 *d2i_X509_bio(BIO *bp, X509 **x509)
158	{
159	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
160	}
161
162int i2d_X509_bio(BIO *bp, X509 *x509)
163	{
164	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
165	}
166
167#ifndef OPENSSL_NO_FP_API
168X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
169	{
170	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
171	}
172
173int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
174	{
175	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
176	}
177#endif
178
179X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
180	{
181	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
182	}
183
184int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
185	{
186	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
187	}
188
189/* TODO(fork) */
190#if 0
191#ifndef OPENSSL_NO_FP_API
192PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
193	{
194	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
195	}
196
197int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
198	{
199	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
200	}
201#endif
202
203PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
204	{
205	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
206	}
207
208int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
209	{
210	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
211	}
212#endif
213
214#ifndef OPENSSL_NO_FP_API
215X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
216	{
217	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
218	}
219
220int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
221	{
222	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
223	}
224#endif
225
226X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
227	{
228	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
229	}
230
231int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
232	{
233	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
234	}
235
236
237#ifndef OPENSSL_NO_FP_API
238RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
239	{
240	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
241	}
242
243int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
244	{
245	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
246	}
247
248RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
249	{
250	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
251	}
252
253RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
254	{
255	return ASN1_d2i_fp((void *(*)(void))
256			   RSA_new,(D2I_OF(void))d2i_RSA_PUBKEY, fp,
257			   (void **)rsa);
258	}
259
260int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
261	{
262	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
263	}
264
265int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
266	{
267	return ASN1_i2d_fp((I2D_OF_const(void))i2d_RSA_PUBKEY,fp,rsa);
268	}
269#endif
270
271RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
272	{
273	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
274	}
275
276int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
277	{
278	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
279	}
280
281RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
282	{
283	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
284	}
285
286
287RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
288	{
289	return ASN1_d2i_bio_of(RSA,RSA_new,d2i_RSA_PUBKEY,bp,rsa);
290	}
291
292int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
293	{
294	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
295	}
296
297int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
298	{
299	return ASN1_i2d_bio_of_const(RSA,i2d_RSA_PUBKEY,bp,rsa);
300	}
301
302#ifndef OPENSSL_NO_DSA
303#ifndef OPENSSL_NO_FP_API
304DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
305	{
306	return ASN1_d2i_fp_of(DSA,DSA_new,d2i_DSAPrivateKey,fp,dsa);
307	}
308
309int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
310	{
311	return ASN1_i2d_fp_of_const(DSA,i2d_DSAPrivateKey,fp,dsa);
312	}
313
314DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
315	{
316	return ASN1_d2i_fp_of(DSA,DSA_new,d2i_DSA_PUBKEY,fp,dsa);
317	}
318
319int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
320	{
321	return ASN1_i2d_fp_of_const(DSA,i2d_DSA_PUBKEY,fp,dsa);
322	}
323#endif
324
325DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
326	{
327	return ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAPrivateKey,bp,dsa
328);
329	}
330
331int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
332	{
333	return ASN1_i2d_bio_of_const(DSA,i2d_DSAPrivateKey,bp,dsa);
334	}
335
336DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
337	{
338	return ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSA_PUBKEY,bp,dsa);
339	}
340
341int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
342	{
343	return ASN1_i2d_bio_of_const(DSA,i2d_DSA_PUBKEY,bp,dsa);
344	}
345
346#endif
347
348#ifndef OPENSSL_NO_FP_API
349EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
350	{
351	return ASN1_d2i_fp_of(EC_KEY,EC_KEY_new,d2i_EC_PUBKEY,fp,eckey);
352	}
353
354int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey)
355	{
356	return ASN1_i2d_fp_of_const(EC_KEY,i2d_EC_PUBKEY,fp,eckey);
357	}
358
359EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
360	{
361	return ASN1_d2i_fp_of(EC_KEY,EC_KEY_new,d2i_ECPrivateKey,fp,eckey);
362	}
363
364int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
365	{
366	return ASN1_i2d_fp_of_const(EC_KEY,i2d_ECPrivateKey,fp,eckey);
367	}
368#endif
369EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
370	{
371	return ASN1_d2i_bio_of(EC_KEY,EC_KEY_new,d2i_EC_PUBKEY,bp,eckey);
372	}
373
374int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ecdsa)
375	{
376	return ASN1_i2d_bio_of_const(EC_KEY,i2d_EC_PUBKEY,bp,ecdsa);
377	}
378
379EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
380	{
381	return ASN1_d2i_bio_of(EC_KEY,EC_KEY_new,d2i_ECPrivateKey,bp,eckey);
382	}
383
384int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
385	{
386	return ASN1_i2d_bio_of_const(EC_KEY,i2d_ECPrivateKey,bp,eckey);
387	}
388
389
390int X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
391	     unsigned int *len)
392	{
393	ASN1_BIT_STRING *key;
394	key = X509_get0_pubkey_bitstr(data);
395	if(!key) return 0;
396	return EVP_Digest(key->data, key->length, md, len, type, NULL);
397	}
398
399int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
400	     unsigned int *len)
401	{
402	return(ASN1_item_digest(ASN1_ITEM_rptr(X509),type,(char *)data,md,len));
403	}
404
405int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
406	     unsigned int *len)
407	{
408	return(ASN1_item_digest(ASN1_ITEM_rptr(X509_CRL),type,(char *)data,md,len));
409	}
410
411int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
412	     unsigned int *len)
413	{
414	return(ASN1_item_digest(ASN1_ITEM_rptr(X509_REQ),type,(char *)data,md,len));
415	}
416
417int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
418	     unsigned int *len)
419	{
420	return(ASN1_item_digest(ASN1_ITEM_rptr(X509_NAME),type,(char *)data,md,len));
421	}
422
423#if 0 /* TODO(fork): remove */
424int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, const EVP_MD *type,
425	     unsigned char *md, unsigned int *len)
426	{
427	return(ASN1_item_digest(ASN1_ITEM_rptr(PKCS7_ISSUER_AND_SERIAL),type,
428		(char *)data,md,len));
429	}
430#endif
431
432#ifndef OPENSSL_NO_FP_API
433X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
434	{
435	return ASN1_d2i_fp_of(X509_SIG,X509_SIG_new,d2i_X509_SIG,fp,p8);
436	}
437
438int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
439	{
440	return ASN1_i2d_fp_of(X509_SIG,i2d_X509_SIG,fp,p8);
441	}
442#endif
443
444X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
445	{
446	return ASN1_d2i_bio_of(X509_SIG,X509_SIG_new,d2i_X509_SIG,bp,p8);
447	}
448
449int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
450	{
451	return ASN1_i2d_bio_of(X509_SIG,i2d_X509_SIG,bp,p8);
452	}
453
454#ifndef OPENSSL_NO_FP_API
455PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
456						 PKCS8_PRIV_KEY_INFO **p8inf)
457	{
458	return ASN1_d2i_fp_of(PKCS8_PRIV_KEY_INFO,PKCS8_PRIV_KEY_INFO_new,
459			      d2i_PKCS8_PRIV_KEY_INFO,fp,p8inf);
460	}
461
462int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
463	{
464	return ASN1_i2d_fp_of(PKCS8_PRIV_KEY_INFO,i2d_PKCS8_PRIV_KEY_INFO,fp,
465			      p8inf);
466	}
467
468int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
469	{
470	PKCS8_PRIV_KEY_INFO *p8inf;
471	int ret;
472	p8inf = EVP_PKEY2PKCS8(key);
473	if(!p8inf) return 0;
474	ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
475	PKCS8_PRIV_KEY_INFO_free(p8inf);
476	return ret;
477	}
478
479int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
480	{
481	return ASN1_i2d_fp_of_const(EVP_PKEY,i2d_PrivateKey,fp,pkey);
482	}
483
484EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
485{
486	return ASN1_d2i_fp_of(EVP_PKEY,EVP_PKEY_new,d2i_AutoPrivateKey,fp,a);
487}
488
489int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
490	{
491	return ASN1_i2d_fp_of_const(EVP_PKEY,i2d_PUBKEY,fp,pkey);
492	}
493
494EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a)
495{
496	return ASN1_d2i_fp_of(EVP_PKEY,EVP_PKEY_new,d2i_PUBKEY,fp,a);
497}
498
499PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
500						 PKCS8_PRIV_KEY_INFO **p8inf)
501	{
502	return ASN1_d2i_bio_of(PKCS8_PRIV_KEY_INFO,PKCS8_PRIV_KEY_INFO_new,
503			    d2i_PKCS8_PRIV_KEY_INFO,bp,p8inf);
504	}
505
506int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
507	{
508	return ASN1_i2d_bio_of(PKCS8_PRIV_KEY_INFO,i2d_PKCS8_PRIV_KEY_INFO,bp,
509			       p8inf);
510	}
511
512int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
513	{
514	PKCS8_PRIV_KEY_INFO *p8inf;
515	int ret;
516	p8inf = EVP_PKEY2PKCS8(key);
517	if(!p8inf) return 0;
518	ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
519	PKCS8_PRIV_KEY_INFO_free(p8inf);
520	return ret;
521	}
522#endif
523
524int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
525	{
526	return ASN1_i2d_bio_of_const(EVP_PKEY,i2d_PrivateKey,bp,pkey);
527	}
528
529EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
530	{
531	return ASN1_d2i_bio_of(EVP_PKEY,EVP_PKEY_new,d2i_AutoPrivateKey,bp,a);
532	}
533
534int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
535	{
536	return ASN1_i2d_bio_of_const(EVP_PKEY,i2d_PUBKEY,bp,pkey);
537	}
538
539EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a)
540	{
541	return ASN1_d2i_bio_of(EVP_PKEY,EVP_PKEY_new,d2i_PUBKEY,bp,a);
542	}
543