X509: Refactor X509_verify() and X509_REQ_verify() for better streamlining
[openssl.git] / crypto / x509 / x_all.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/buffer.h>
13 #include <openssl/asn1.h>
14 #include <openssl/evp.h>
15 #include <openssl/x509.h>
16 #include "crypto/x509.h"
17 #include <openssl/ocsp.h>
18 #include <openssl/rsa.h>
19 #include <openssl/dsa.h>
20 #include <openssl/x509v3.h>
21
22 static void clean_id_ctx(EVP_MD_CTX *ctx)
23 {
24     EVP_PKEY_CTX *pctx = EVP_MD_CTX_pkey_ctx(ctx);
25
26     EVP_PKEY_CTX_free(pctx);
27     EVP_MD_CTX_free(ctx);
28 }
29
30 static EVP_MD_CTX *make_id_ctx(EVP_PKEY *r, ASN1_OCTET_STRING *id)
31 {
32     EVP_MD_CTX *ctx = NULL;
33     EVP_PKEY_CTX *pctx = NULL;
34
35     if ((ctx = EVP_MD_CTX_new()) == NULL
36         || (pctx = EVP_PKEY_CTX_new(r, NULL)) == NULL) {
37         X509err(0, ERR_R_MALLOC_FAILURE);
38         goto error;
39     }
40
41     if (id != NULL) {
42         if (EVP_PKEY_CTX_set1_id(pctx, id->data, id->length) <= 0) {
43             X509err(0, ERR_R_MALLOC_FAILURE);
44             goto error;
45         }
46     }
47
48     EVP_MD_CTX_set_pkey_ctx(ctx, pctx);
49
50     return ctx;
51  error:
52     EVP_PKEY_CTX_free(pctx);
53     EVP_MD_CTX_free(ctx);
54     return NULL;
55 }
56
57 int X509_verify(X509 *a, EVP_PKEY *r)
58 {
59     int rv = 0;
60     EVP_MD_CTX *ctx = NULL;
61     ASN1_OCTET_STRING *id = NULL;
62
63     if (X509_ALGOR_cmp(&a->sig_alg, &a->cert_info.signature))
64         return 0;
65
66 #ifndef OPENSSL_NO_SM2
67     id = a->sm2_id;
68 #endif
69
70     if ((ctx = make_id_ctx(r, id)) != NULL) {
71         rv = ASN1_item_verify_ctx(ASN1_ITEM_rptr(X509_CINF), &a->sig_alg,
72                                   &a->signature, &a->cert_info, ctx);
73         clean_id_ctx(ctx);
74     }
75     return rv;
76 }
77
78 int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
79 {
80     int rv = 0;
81     EVP_MD_CTX *ctx = NULL;
82     ASN1_OCTET_STRING *id = NULL;
83
84 #ifndef OPENSSL_NO_SM2
85     id = a->sm2_id;
86 #endif
87
88     if ((ctx = make_id_ctx(r, id)) != NULL) {
89         rv = ASN1_item_verify_ctx(ASN1_ITEM_rptr(X509_REQ_INFO), &a->sig_alg,
90                                   a->signature, &a->req_info, ctx);
91         clean_id_ctx(ctx);
92     }
93     return rv;
94 }
95
96 int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
97 {
98     return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC),
99                              &a->sig_algor, a->signature, a->spkac, r));
100 }
101
102 int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
103 {
104     x->cert_info.enc.modified = 1;
105     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), &x->cert_info.signature,
106                            &x->sig_alg, &x->signature, &x->cert_info, pkey,
107                            md));
108 }
109
110 int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
111 {
112     x->cert_info.enc.modified = 1;
113     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
114                               &x->cert_info.signature,
115                               &x->sig_alg, &x->signature, &x->cert_info, ctx);
116 }
117
118 #ifndef OPENSSL_NO_OCSP
119 int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert)
120 {
121     return OCSP_REQ_CTX_nbio_d2i(rctx,
122                                  (ASN1_VALUE **)pcert, ASN1_ITEM_rptr(X509));
123 }
124 #endif
125
126 int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
127 {
128     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), &x->sig_alg, NULL,
129                            x->signature, &x->req_info, pkey, md));
130 }
131
132 int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
133 {
134     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
135                               &x->sig_alg, NULL, x->signature, &x->req_info,
136                               ctx);
137 }
138
139 int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
140 {
141     x->crl.enc.modified = 1;
142     return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), &x->crl.sig_alg,
143                            &x->sig_alg, &x->signature, &x->crl, pkey, md));
144 }
145
146 int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
147 {
148     x->crl.enc.modified = 1;
149     return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
150                               &x->crl.sig_alg, &x->sig_alg, &x->signature,
151                               &x->crl, ctx);
152 }
153
154 #ifndef OPENSSL_NO_OCSP
155 int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl)
156 {
157     return OCSP_REQ_CTX_nbio_d2i(rctx,
158                                  (ASN1_VALUE **)pcrl,
159                                  ASN1_ITEM_rptr(X509_CRL));
160 }
161 #endif
162
163 int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
164 {
165     return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), &x->sig_algor, NULL,
166                            x->signature, x->spkac, pkey, md));
167 }
168
169 #ifndef OPENSSL_NO_STDIO
170 X509 *d2i_X509_fp(FILE *fp, X509 **x509)
171 {
172     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
173 }
174
175 int i2d_X509_fp(FILE *fp, const X509 *x509)
176 {
177     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
178 }
179 #endif
180
181 X509 *d2i_X509_bio(BIO *bp, X509 **x509)
182 {
183     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
184 }
185
186 int i2d_X509_bio(BIO *bp, const X509 *x509)
187 {
188     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
189 }
190
191 #ifndef OPENSSL_NO_STDIO
192 X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
193 {
194     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
195 }
196
197 int i2d_X509_CRL_fp(FILE *fp, const X509_CRL *crl)
198 {
199     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
200 }
201 #endif
202
203 X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
204 {
205     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
206 }
207
208 int i2d_X509_CRL_bio(BIO *bp, const X509_CRL *crl)
209 {
210     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
211 }
212
213 #ifndef OPENSSL_NO_STDIO
214 PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
215 {
216     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
217 }
218
219 int i2d_PKCS7_fp(FILE *fp, const PKCS7 *p7)
220 {
221     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
222 }
223 #endif
224
225 PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
226 {
227     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
228 }
229
230 int i2d_PKCS7_bio(BIO *bp, const PKCS7 *p7)
231 {
232     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
233 }
234
235 #ifndef OPENSSL_NO_STDIO
236 X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
237 {
238     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
239 }
240
241 int i2d_X509_REQ_fp(FILE *fp, const X509_REQ *req)
242 {
243     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
244 }
245 #endif
246
247 X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
248 {
249     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
250 }
251
252 int i2d_X509_REQ_bio(BIO *bp, const X509_REQ *req)
253 {
254     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
255 }
256
257 #ifndef OPENSSL_NO_RSA
258
259 # ifndef OPENSSL_NO_STDIO
260 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
261 {
262     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
263 }
264
265 int i2d_RSAPrivateKey_fp(FILE *fp, const RSA *rsa)
266 {
267     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
268 }
269
270 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
271 {
272     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
273 }
274
275 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
276 {
277     return ASN1_d2i_fp((void *(*)(void))
278                        RSA_new, (D2I_OF(void)) d2i_RSA_PUBKEY, fp,
279                        (void **)rsa);
280 }
281
282 int i2d_RSAPublicKey_fp(FILE *fp, const RSA *rsa)
283 {
284     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
285 }
286
287 int i2d_RSA_PUBKEY_fp(FILE *fp, const RSA *rsa)
288 {
289     return ASN1_i2d_fp((I2D_OF(void))i2d_RSA_PUBKEY, fp, rsa);
290 }
291 # endif
292
293 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
294 {
295     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
296 }
297
298 int i2d_RSAPrivateKey_bio(BIO *bp, const RSA *rsa)
299 {
300     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
301 }
302
303 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
304 {
305     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
306 }
307
308 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
309 {
310     return ASN1_d2i_bio_of(RSA, RSA_new, d2i_RSA_PUBKEY, bp, rsa);
311 }
312
313 int i2d_RSAPublicKey_bio(BIO *bp, const RSA *rsa)
314 {
315     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
316 }
317
318 int i2d_RSA_PUBKEY_bio(BIO *bp, const RSA *rsa)
319 {
320     return ASN1_i2d_bio_of(RSA, i2d_RSA_PUBKEY, bp, rsa);
321 }
322 #endif
323
324 #ifndef OPENSSL_NO_DSA
325 # ifndef OPENSSL_NO_STDIO
326 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
327 {
328     return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSAPrivateKey, fp, dsa);
329 }
330
331 int i2d_DSAPrivateKey_fp(FILE *fp, const DSA *dsa)
332 {
333     return ASN1_i2d_fp_of(DSA, i2d_DSAPrivateKey, fp, dsa);
334 }
335
336 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
337 {
338     return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSA_PUBKEY, fp, dsa);
339 }
340
341 int i2d_DSA_PUBKEY_fp(FILE *fp, const DSA *dsa)
342 {
343     return ASN1_i2d_fp_of(DSA, i2d_DSA_PUBKEY, fp, dsa);
344 }
345 # endif
346
347 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
348 {
349     return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAPrivateKey, bp, dsa);
350 }
351
352 int i2d_DSAPrivateKey_bio(BIO *bp, const DSA *dsa)
353 {
354     return ASN1_i2d_bio_of(DSA, i2d_DSAPrivateKey, bp, dsa);
355 }
356
357 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
358 {
359     return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSA_PUBKEY, bp, dsa);
360 }
361
362 int i2d_DSA_PUBKEY_bio(BIO *bp, const DSA *dsa)
363 {
364     return ASN1_i2d_bio_of(DSA, i2d_DSA_PUBKEY, bp, dsa);
365 }
366
367 #endif
368
369 #ifndef OPENSSL_NO_EC
370 # ifndef OPENSSL_NO_STDIO
371 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
372 {
373     return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, fp, eckey);
374 }
375
376 int i2d_EC_PUBKEY_fp(FILE *fp, const EC_KEY *eckey)
377 {
378     return ASN1_i2d_fp_of(EC_KEY, i2d_EC_PUBKEY, fp, eckey);
379 }
380
381 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
382 {
383     return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
384 }
385
386 int i2d_ECPrivateKey_fp(FILE *fp, const EC_KEY *eckey)
387 {
388     return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
389 }
390 # endif
391 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
392 {
393     return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, bp, eckey);
394 }
395
396 int i2d_EC_PUBKEY_bio(BIO *bp, const EC_KEY *ecdsa)
397 {
398     return ASN1_i2d_bio_of(EC_KEY, i2d_EC_PUBKEY, bp, ecdsa);
399 }
400
401 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
402 {
403     return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
404 }
405
406 int i2d_ECPrivateKey_bio(BIO *bp, const EC_KEY *eckey)
407 {
408     return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
409 }
410 #endif
411
412 int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
413                        unsigned char *md, unsigned int *len)
414 {
415     ASN1_BIT_STRING *key;
416     key = X509_get0_pubkey_bitstr(data);
417     if (!key)
418         return 0;
419     return EVP_Digest(key->data, key->length, md, len, type, NULL);
420 }
421
422 int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
423                 unsigned int *len)
424 {
425     if (type == EVP_sha1() && (data->ex_flags & EXFLAG_SET) != 0) {
426         /* Asking for SHA1 and we already computed it. */
427         if (len != NULL)
428             *len = sizeof(data->sha1_hash);
429         memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
430         return 1;
431     }
432     return (ASN1_item_digest
433             (ASN1_ITEM_rptr(X509), type, (char *)data, md, len));
434 }
435
436 int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
437                     unsigned char *md, unsigned int *len)
438 {
439     if (type == EVP_sha1() && (data->flags & EXFLAG_SET) != 0) {
440         /* Asking for SHA1; always computed in CRL d2i. */
441         if (len != NULL)
442             *len = sizeof(data->sha1_hash);
443         memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
444         return 1;
445     }
446     return (ASN1_item_digest
447             (ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
448 }
449
450 int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
451                     unsigned char *md, unsigned int *len)
452 {
453     return (ASN1_item_digest
454             (ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
455 }
456
457 int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
458                      unsigned char *md, unsigned int *len)
459 {
460     return (ASN1_item_digest
461             (ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
462 }
463
464 int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
465                                    const EVP_MD *type, unsigned char *md,
466                                    unsigned int *len)
467 {
468     return (ASN1_item_digest(ASN1_ITEM_rptr(PKCS7_ISSUER_AND_SERIAL), type,
469                              (char *)data, md, len));
470 }
471
472 #ifndef OPENSSL_NO_STDIO
473 X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
474 {
475     return ASN1_d2i_fp_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, fp, p8);
476 }
477
478 int i2d_PKCS8_fp(FILE *fp, const X509_SIG *p8)
479 {
480     return ASN1_i2d_fp_of(X509_SIG, i2d_X509_SIG, fp, p8);
481 }
482 #endif
483
484 X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
485 {
486     return ASN1_d2i_bio_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, bp, p8);
487 }
488
489 int i2d_PKCS8_bio(BIO *bp, const X509_SIG *p8)
490 {
491     return ASN1_i2d_bio_of(X509_SIG, i2d_X509_SIG, bp, p8);
492 }
493
494 #ifndef OPENSSL_NO_STDIO
495 X509_PUBKEY *d2i_X509_PUBKEY_fp(FILE *fp, X509_PUBKEY **xpk)
496 {
497     return ASN1_d2i_fp_of(X509_PUBKEY, X509_PUBKEY_new, d2i_X509_PUBKEY,
498                           fp, xpk);
499 }
500
501 int i2d_X509_PUBKEY_fp(FILE *fp, const X509_PUBKEY *xpk)
502 {
503     return ASN1_i2d_fp_of(X509_PUBKEY, i2d_X509_PUBKEY, fp, xpk);
504 }
505 #endif
506
507 X509_PUBKEY *d2i_X509_PUBKEY_bio(BIO *bp, X509_PUBKEY **xpk)
508 {
509     return ASN1_d2i_bio_of(X509_PUBKEY, X509_PUBKEY_new, d2i_X509_PUBKEY,
510                            bp, xpk);
511 }
512
513 int i2d_X509_PUBKEY_bio(BIO *bp, const X509_PUBKEY *xpk)
514 {
515     return ASN1_i2d_bio_of(X509_PUBKEY, i2d_X509_PUBKEY, bp, xpk);
516 }
517
518 #ifndef OPENSSL_NO_STDIO
519 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
520                                                 PKCS8_PRIV_KEY_INFO **p8inf)
521 {
522     return ASN1_d2i_fp_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
523                           d2i_PKCS8_PRIV_KEY_INFO, fp, p8inf);
524 }
525
526 int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, const PKCS8_PRIV_KEY_INFO *p8inf)
527 {
528     return ASN1_i2d_fp_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, fp,
529                           p8inf);
530 }
531
532 int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, const EVP_PKEY *key)
533 {
534     PKCS8_PRIV_KEY_INFO *p8inf;
535     int ret;
536
537     p8inf = EVP_PKEY2PKCS8(key);
538     if (p8inf == NULL)
539         return 0;
540     ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
541     PKCS8_PRIV_KEY_INFO_free(p8inf);
542     return ret;
543 }
544
545 int i2d_PrivateKey_fp(FILE *fp, const EVP_PKEY *pkey)
546 {
547     return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
548 }
549
550 EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
551 {
552     return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, fp, a);
553 }
554
555 int i2d_PUBKEY_fp(FILE *fp, const EVP_PKEY *pkey)
556 {
557     return ASN1_i2d_fp_of(EVP_PKEY, i2d_PUBKEY, fp, pkey);
558 }
559
560 EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a)
561 {
562     return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, fp, a);
563 }
564
565 #endif
566
567 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
568                                                  PKCS8_PRIV_KEY_INFO **p8inf)
569 {
570     return ASN1_d2i_bio_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
571                            d2i_PKCS8_PRIV_KEY_INFO, bp, p8inf);
572 }
573
574 int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, const PKCS8_PRIV_KEY_INFO *p8inf)
575 {
576     return ASN1_i2d_bio_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, bp,
577                            p8inf);
578 }
579
580 int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, const EVP_PKEY *key)
581 {
582     PKCS8_PRIV_KEY_INFO *p8inf;
583     int ret;
584
585     p8inf = EVP_PKEY2PKCS8(key);
586     if (p8inf == NULL)
587         return 0;
588     ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
589     PKCS8_PRIV_KEY_INFO_free(p8inf);
590     return ret;
591 }
592
593 int i2d_PrivateKey_bio(BIO *bp, const EVP_PKEY *pkey)
594 {
595     return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
596 }
597
598 EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
599 {
600     return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, bp, a);
601 }
602
603 int i2d_PUBKEY_bio(BIO *bp, const EVP_PKEY *pkey)
604 {
605     return ASN1_i2d_bio_of(EVP_PKEY, i2d_PUBKEY, bp, pkey);
606 }
607
608 EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a)
609 {
610     return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, bp, a);
611 }