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