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 }