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