crypto/x509/x_all.c

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