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