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