Embed various signature algorithms.
[openssl.git] / crypto / x509 / x_all.c
1 /* crypto/x509/x_all.c */
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 #include <openssl/stack.h>
61 #include "internal/cryptlib.h"
62 #include <openssl/buffer.h>
63 #include <openssl/asn1.h>
64 #include <openssl/evp.h>
65 #include <openssl/x509.h>
66 #include "internal/x509_int.h"
67 #include <openssl/ocsp.h>
68 #ifndef OPENSSL_NO_RSA
69 # include <openssl/rsa.h>
70 #endif
71 #ifndef OPENSSL_NO_DSA
72 # include <openssl/dsa.h>
73 #endif
74
75 int X509_verify(X509 *a, EVP_PKEY *r)
76 {
77     if (X509_ALGOR_cmp(&a->sig_alg, &a->cert_info.signature))
78         return 0;
79     return (ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF), &a->sig_alg,
80                              a->signature, &a->cert_info, r));
81 }
82
83 int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
84 {
85     return (ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO),
86                              &a->sig_alg, a->signature, &a->req_info, r));
87 }
88
89 int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
90 {
91     return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC),
92                              &a->sig_algor, a->signature, a->spkac, r));
93 }
94
95 int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
96 {
97     x->cert_info.enc.modified = 1;
98     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), &x->cert_info.signature,
99                            &x->sig_alg, x->signature, &x->cert_info, pkey, md));
100 }
101
102 int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
103 {
104     x->cert_info.enc.modified = 1;
105     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
106                               &x->cert_info.signature,
107                               &x->sig_alg, x->signature, &x->cert_info, ctx);
108 }
109
110 int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert)
111 {
112     return OCSP_REQ_CTX_nbio_d2i(rctx,
113                                  (ASN1_VALUE **)pcert, ASN1_ITEM_rptr(X509));
114 }
115
116 int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
117 {
118     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), &x->sig_alg, NULL,
119                            x->signature, &x->req_info, pkey, md));
120 }
121
122 int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
123 {
124     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
125                               &x->sig_alg, NULL, x->signature, &x->req_info,
126                               ctx);
127 }
128
129 int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
130 {
131     x->crl.enc.modified = 1;
132     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), &x->crl.sig_alg,
133                            &x->sig_alg, x->signature, &x->crl, pkey, md));
134 }
135
136 int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
137 {
138     x->crl.enc.modified = 1;
139     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
140                               &x->crl.sig_alg, &x->sig_alg, x->signature,
141                               &x->crl, ctx);
142 }
143
144 int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl)
145 {
146     return OCSP_REQ_CTX_nbio_d2i(rctx,
147                                  (ASN1_VALUE **)pcrl,
148                                  ASN1_ITEM_rptr(X509_CRL));
149 }
150
151 int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
152 {
153     return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), &x->sig_algor, NULL,
154                            x->signature, x->spkac, pkey, md));
155 }
156
157 #ifndef OPENSSL_NO_STDIO
158 X509 *d2i_X509_fp(FILE *fp, X509 **x509)
159 {
160     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
161 }
162
163 int i2d_X509_fp(FILE *fp, X509 *x509)
164 {
165     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
166 }
167 #endif
168
169 X509 *d2i_X509_bio(BIO *bp, X509 **x509)
170 {
171     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
172 }
173
174 int i2d_X509_bio(BIO *bp, X509 *x509)
175 {
176     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
177 }
178
179 #ifndef OPENSSL_NO_STDIO
180 X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
181 {
182     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
183 }
184
185 int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
186 {
187     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
188 }
189 #endif
190
191 X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
192 {
193     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
194 }
195
196 int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
197 {
198     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
199 }
200
201 #ifndef OPENSSL_NO_STDIO
202 PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
203 {
204     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
205 }
206
207 int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
208 {
209     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
210 }
211 #endif
212
213 PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
214 {
215     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
216 }
217
218 int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
219 {
220     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
221 }
222
223 #ifndef OPENSSL_NO_STDIO
224 X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
225 {
226     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
227 }
228
229 int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
230 {
231     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
232 }
233 #endif
234
235 X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
236 {
237     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
238 }
239
240 int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
241 {
242     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
243 }
244
245 #ifndef OPENSSL_NO_RSA
246
247 # ifndef OPENSSL_NO_STDIO
248 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
249 {
250     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
251 }
252
253 int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
254 {
255     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
256 }
257
258 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
259 {
260     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
261 }
262
263 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
264 {
265     return ASN1_d2i_fp((void *(*)(void))
266                        RSA_new, (D2I_OF(void)) d2i_RSA_PUBKEY, fp,
267                        (void **)rsa);
268 }
269
270 int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
271 {
272     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
273 }
274
275 int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
276 {
277     return ASN1_i2d_fp((I2D_OF(void))i2d_RSA_PUBKEY, fp, rsa);
278 }
279 # endif
280
281 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
282 {
283     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
284 }
285
286 int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
287 {
288     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
289 }
290
291 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
292 {
293     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
294 }
295
296 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
297 {
298     return ASN1_d2i_bio_of(RSA, RSA_new, d2i_RSA_PUBKEY, bp, rsa);
299 }
300
301 int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
302 {
303     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
304 }
305
306 int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
307 {
308     return ASN1_i2d_bio_of(RSA, i2d_RSA_PUBKEY, bp, rsa);
309 }
310 #endif
311
312 #ifndef OPENSSL_NO_DSA
313 # ifndef OPENSSL_NO_STDIO
314 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
315 {
316     return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSAPrivateKey, fp, dsa);
317 }
318
319 int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
320 {
321     return ASN1_i2d_fp_of_const(DSA, i2d_DSAPrivateKey, fp, dsa);
322 }
323
324 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
325 {
326     return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSA_PUBKEY, fp, dsa);
327 }
328
329 int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
330 {
331     return ASN1_i2d_fp_of(DSA, i2d_DSA_PUBKEY, fp, dsa);
332 }
333 # endif
334
335 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
336 {
337     return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAPrivateKey, bp, dsa);
338 }
339
340 int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
341 {
342     return ASN1_i2d_bio_of_const(DSA, i2d_DSAPrivateKey, bp, dsa);
343 }
344
345 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
346 {
347     return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSA_PUBKEY, bp, dsa);
348 }
349
350 int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
351 {
352     return ASN1_i2d_bio_of(DSA, i2d_DSA_PUBKEY, bp, dsa);
353 }
354
355 #endif
356
357 #ifndef OPENSSL_NO_EC
358 # ifndef OPENSSL_NO_STDIO
359 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
360 {
361     return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, fp, eckey);
362 }
363
364 int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey)
365 {
366     return ASN1_i2d_fp_of(EC_KEY, i2d_EC_PUBKEY, fp, eckey);
367 }
368
369 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
370 {
371     return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
372 }
373
374 int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
375 {
376     return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
377 }
378 # endif
379 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
380 {
381     return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, bp, eckey);
382 }
383
384 int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ecdsa)
385 {
386     return ASN1_i2d_bio_of(EC_KEY, i2d_EC_PUBKEY, bp, ecdsa);
387 }
388
389 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
390 {
391     return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
392 }
393
394 int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
395 {
396     return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
397 }
398 #endif
399
400 int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
401                        unsigned char *md, unsigned int *len)
402 {
403     ASN1_BIT_STRING *key;
404     key = X509_get0_pubkey_bitstr(data);
405     if (!key)
406         return 0;
407     return EVP_Digest(key->data, key->length, md, len, type, NULL);
408 }
409
410 int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
411                 unsigned int *len)
412 {
413     return (ASN1_item_digest
414             (ASN1_ITEM_rptr(X509), type, (char *)data, md, len));
415 }
416
417 int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
418                     unsigned char *md, unsigned int *len)
419 {
420     return (ASN1_item_digest
421             (ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
422 }
423
424 int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
425                     unsigned char *md, unsigned int *len)
426 {
427     return (ASN1_item_digest
428             (ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
429 }
430
431 int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
432                      unsigned char *md, unsigned int *len)
433 {
434     return (ASN1_item_digest
435             (ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
436 }
437
438 int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
439                                    const EVP_MD *type, unsigned char *md,
440                                    unsigned int *len)
441 {
442     return (ASN1_item_digest(ASN1_ITEM_rptr(PKCS7_ISSUER_AND_SERIAL), type,
443                              (char *)data, md, len));
444 }
445
446 #ifndef OPENSSL_NO_STDIO
447 X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
448 {
449     return ASN1_d2i_fp_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, fp, p8);
450 }
451
452 int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
453 {
454     return ASN1_i2d_fp_of(X509_SIG, i2d_X509_SIG, fp, p8);
455 }
456 #endif
457
458 X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
459 {
460     return ASN1_d2i_bio_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, bp, p8);
461 }
462
463 int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
464 {
465     return ASN1_i2d_bio_of(X509_SIG, i2d_X509_SIG, bp, p8);
466 }
467
468 #ifndef OPENSSL_NO_STDIO
469 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
470                                                 PKCS8_PRIV_KEY_INFO **p8inf)
471 {
472     return ASN1_d2i_fp_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
473                           d2i_PKCS8_PRIV_KEY_INFO, fp, p8inf);
474 }
475
476 int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
477 {
478     return ASN1_i2d_fp_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, fp,
479                           p8inf);
480 }
481
482 int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
483 {
484     PKCS8_PRIV_KEY_INFO *p8inf;
485     int ret;
486     p8inf = EVP_PKEY2PKCS8(key);
487     if (!p8inf)
488         return 0;
489     ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
490     PKCS8_PRIV_KEY_INFO_free(p8inf);
491     return ret;
492 }
493
494 int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
495 {
496     return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
497 }
498
499 EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
500 {
501     return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, fp, a);
502 }
503
504 int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
505 {
506     return ASN1_i2d_fp_of(EVP_PKEY, i2d_PUBKEY, fp, pkey);
507 }
508
509 EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a)
510 {
511     return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, fp, a);
512 }
513
514 #endif
515
516 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
517                                                  PKCS8_PRIV_KEY_INFO **p8inf)
518 {
519     return ASN1_d2i_bio_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
520                            d2i_PKCS8_PRIV_KEY_INFO, bp, p8inf);
521 }
522
523 int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
524 {
525     return ASN1_i2d_bio_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, bp,
526                            p8inf);
527 }
528
529 int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
530 {
531     PKCS8_PRIV_KEY_INFO *p8inf;
532     int ret;
533     p8inf = EVP_PKEY2PKCS8(key);
534     if (!p8inf)
535         return 0;
536     ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
537     PKCS8_PRIV_KEY_INFO_free(p8inf);
538     return ret;
539 }
540
541 int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
542 {
543     return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
544 }
545
546 EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
547 {
548     return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, bp, a);
549 }
550
551 int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
552 {
553     return ASN1_i2d_bio_of(EVP_PKEY, i2d_PUBKEY, bp, pkey);
554 }
555
556 EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a)
557 {
558     return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, bp, a);
559 }