crypto/x509/x_all.c

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