crypto/pkcs7/pk7_lib.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 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/objects.h>
  13 #include <openssl/x509.h>
  14 #include "crypto/asn1.h"
  15 #include "crypto/evp.h"
  16 #include "crypto/x509.h" /* for sk_X509_add1_cert() */
  17 #include "pk7_local.h"
  18
  19 DEFINE_STACK_OF(PKCS7_RECIP_INFO)
  20 DEFINE_STACK_OF(PKCS7_SIGNER_INFO)
  21
  22 long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg)
  23 {
  24     int nid;
  25     long ret;
  26
  27     nid = OBJ_obj2nid(p7->type);
  28
  29     switch (cmd) {
  30     /* NOTE(emilia): does not support detached digested data. */
  31     case PKCS7_OP_SET_DETACHED_SIGNATURE:
  32         if (nid == NID_pkcs7_signed) {
  33             ret = p7->detached = (int)larg;
  34             if (ret && PKCS7_type_is_data(p7->d.sign->contents)) {
  35                 ASN1_OCTET_STRING *os;
  36                 os = p7->d.sign->contents->d.data;
  37                 ASN1_OCTET_STRING_free(os);
  38                 p7->d.sign->contents->d.data = NULL;
  39             }
  40         } else {
  41             PKCS7err(PKCS7_F_PKCS7_CTRL,
  42                      PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
  43             ret = 0;
  44         }
  45         break;
  46     case PKCS7_OP_GET_DETACHED_SIGNATURE:
  47         if (nid == NID_pkcs7_signed) {
  48             if (p7->d.sign == NULL || p7->d.sign->contents->d.ptr == NULL)
  49                 ret = 1;
  50             else
  51                 ret = 0;
  52
  53             p7->detached = ret;
  54         } else {
  55             PKCS7err(PKCS7_F_PKCS7_CTRL,
  56                      PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
  57             ret = 0;
  58         }
  59
  60         break;
  61     default:
  62         PKCS7err(PKCS7_F_PKCS7_CTRL, PKCS7_R_UNKNOWN_OPERATION);
  63         ret = 0;
  64     }
  65     return ret;
  66 }
  67
  68 int PKCS7_content_new(PKCS7 *p7, int type)
  69 {
  70     PKCS7 *ret = NULL;
  71
  72     if ((ret = PKCS7_new()) == NULL)
  73         goto err;
  74     if (!PKCS7_set_type(ret, type))
  75         goto err;
  76     if (!PKCS7_set_content(p7, ret))
  77         goto err;
  78
  79     return 1;
  80  err:
  81     PKCS7_free(ret);
  82     return 0;
  83 }
  84
  85 int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
  86 {
  87     int i;
  88
  89     i = OBJ_obj2nid(p7->type);
  90     switch (i) {
  91     case NID_pkcs7_signed:
  92         PKCS7_free(p7->d.sign->contents);
  93         p7->d.sign->contents = p7_data;
  94         break;
  95     case NID_pkcs7_digest:
  96         PKCS7_free(p7->d.digest->contents);
  97         p7->d.digest->contents = p7_data;
  98         break;
  99     case NID_pkcs7_data:
 100     case NID_pkcs7_enveloped:
 101     case NID_pkcs7_signedAndEnveloped:
 102     case NID_pkcs7_encrypted:
 103     default:
 104         PKCS7err(PKCS7_F_PKCS7_SET_CONTENT, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 105         goto err;
 106     }
 107     return 1;
 108  err:
 109     return 0;
 110 }
 111
 112 int PKCS7_set_type(PKCS7 *p7, int type)
 113 {
 114     ASN1_OBJECT *obj;
 115
 116     /*
 117      * PKCS7_content_free(p7);
 118      */
 119     obj = OBJ_nid2obj(type);    /* will not fail */
 120
 121     switch (type) {
 122     case NID_pkcs7_signed:
 123         p7->type = obj;
 124         if ((p7->d.sign = PKCS7_SIGNED_new()) == NULL)
 125             goto err;
 126         if (!ASN1_INTEGER_set(p7->d.sign->version, 1)) {
 127             PKCS7_SIGNED_free(p7->d.sign);
 128             p7->d.sign = NULL;
 129             goto err;
 130         }
 131         break;
 132     case NID_pkcs7_data:
 133         p7->type = obj;
 134         if ((p7->d.data = ASN1_OCTET_STRING_new()) == NULL)
 135             goto err;
 136         break;
 137     case NID_pkcs7_signedAndEnveloped:
 138         p7->type = obj;
 139         if ((p7->d.signed_and_enveloped = PKCS7_SIGN_ENVELOPE_new())
 140             == NULL)
 141             goto err;
 142         if (!ASN1_INTEGER_set(p7->d.signed_and_enveloped->version, 1))
 143             goto err;
 144         p7->d.signed_and_enveloped->enc_data->content_type
 145             = OBJ_nid2obj(NID_pkcs7_data);
 146         break;
 147     case NID_pkcs7_enveloped:
 148         p7->type = obj;
 149         if ((p7->d.enveloped = PKCS7_ENVELOPE_new())
 150             == NULL)
 151             goto err;
 152         if (!ASN1_INTEGER_set(p7->d.enveloped->version, 0))
 153             goto err;
 154         p7->d.enveloped->enc_data->content_type = OBJ_nid2obj(NID_pkcs7_data);
 155         break;
 156     case NID_pkcs7_encrypted:
 157         p7->type = obj;
 158         if ((p7->d.encrypted = PKCS7_ENCRYPT_new())
 159             == NULL)
 160             goto err;
 161         if (!ASN1_INTEGER_set(p7->d.encrypted->version, 0))
 162             goto err;
 163         p7->d.encrypted->enc_data->content_type = OBJ_nid2obj(NID_pkcs7_data);
 164         break;
 165
 166     case NID_pkcs7_digest:
 167         p7->type = obj;
 168         if ((p7->d.digest = PKCS7_DIGEST_new())
 169             == NULL)
 170             goto err;
 171         if (!ASN1_INTEGER_set(p7->d.digest->version, 0))
 172             goto err;
 173         break;
 174     default:
 175         PKCS7err(PKCS7_F_PKCS7_SET_TYPE, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 176         goto err;
 177     }
 178     return 1;
 179  err:
 180     return 0;
 181 }
 182
 183 int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
 184 {
 185     p7->type = OBJ_nid2obj(type);
 186     p7->d.other = other;
 187     return 1;
 188 }
 189
 190 int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
 191 {
 192     int i, j, nid;
 193     X509_ALGOR *alg;
 194     STACK_OF(PKCS7_SIGNER_INFO) *signer_sk;
 195     STACK_OF(X509_ALGOR) *md_sk;
 196
 197     i = OBJ_obj2nid(p7->type);
 198     switch (i) {
 199     case NID_pkcs7_signed:
 200         signer_sk = p7->d.sign->signer_info;
 201         md_sk = p7->d.sign->md_algs;
 202         break;
 203     case NID_pkcs7_signedAndEnveloped:
 204         signer_sk = p7->d.signed_and_enveloped->signer_info;
 205         md_sk = p7->d.signed_and_enveloped->md_algs;
 206         break;
 207     default:
 208         PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER, PKCS7_R_WRONG_CONTENT_TYPE);
 209         return 0;
 210     }
 211
 212     nid = OBJ_obj2nid(psi->digest_alg->algorithm);
 213
 214     /* If the digest is not currently listed, add it */
 215     j = 0;
 216     for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++) {
 217         alg = sk_X509_ALGOR_value(md_sk, i);
 218         if (OBJ_obj2nid(alg->algorithm) == nid) {
 219             j = 1;
 220             break;
 221         }
 222     }
 223     if (!j) {                   /* we need to add another algorithm */
 224         if ((alg = X509_ALGOR_new()) == NULL
 225             || (alg->parameter = ASN1_TYPE_new()) == NULL) {
 226             X509_ALGOR_free(alg);
 227             PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER, ERR_R_MALLOC_FAILURE);
 228             return 0;
 229         }
 230         alg->algorithm = OBJ_nid2obj(nid);
 231         alg->parameter->type = V_ASN1_NULL;
 232         if (!sk_X509_ALGOR_push(md_sk, alg)) {
 233             X509_ALGOR_free(alg);
 234             return 0;
 235         }
 236     }
 237
 238     psi->ctx = pkcs7_get0_ctx(p7);
 239     if (!sk_PKCS7_SIGNER_INFO_push(signer_sk, psi))
 240         return 0;
 241     return 1;
 242 }
 243
 244 int PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
 245 {
 246     int i;
 247     STACK_OF(X509) **sk;
 248
 249     i = OBJ_obj2nid(p7->type);
 250     switch (i) {
 251     case NID_pkcs7_signed:
 252         sk = &(p7->d.sign->cert);
 253         break;
 254     case NID_pkcs7_signedAndEnveloped:
 255         sk = &(p7->d.signed_and_enveloped->cert);
 256         break;
 257     default:
 258         PKCS7err(PKCS7_F_PKCS7_ADD_CERTIFICATE, PKCS7_R_WRONG_CONTENT_TYPE);
 259         return 0;
 260     }
 261
 262     return X509_add_cert_new(sk, x509, X509_ADD_FLAG_UP_REF);
 263 }
 264
 265 int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
 266 {
 267     int i;
 268     STACK_OF(X509_CRL) **sk;
 269
 270     i = OBJ_obj2nid(p7->type);
 271     switch (i) {
 272     case NID_pkcs7_signed:
 273         sk = &(p7->d.sign->crl);
 274         break;
 275     case NID_pkcs7_signedAndEnveloped:
 276         sk = &(p7->d.signed_and_enveloped->crl);
 277         break;
 278     default:
 279         PKCS7err(PKCS7_F_PKCS7_ADD_CRL, PKCS7_R_WRONG_CONTENT_TYPE);
 280         return 0;
 281     }
 282
 283     if (*sk == NULL)
 284         *sk = sk_X509_CRL_new_null();
 285     if (*sk == NULL) {
 286         PKCS7err(PKCS7_F_PKCS7_ADD_CRL, ERR_R_MALLOC_FAILURE);
 287         return 0;
 288     }
 289
 290     X509_CRL_up_ref(crl);
 291     if (!sk_X509_CRL_push(*sk, crl)) {
 292         X509_CRL_free(crl);
 293         return 0;
 294     }
 295     return 1;
 296 }
 297
 298 int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
 299                           const EVP_MD *dgst)
 300 {
 301     int ret;
 302
 303     /* We now need to add another PKCS7_SIGNER_INFO entry */
 304     if (!ASN1_INTEGER_set(p7i->version, 1))
 305         goto err;
 306     if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
 307                        X509_get_issuer_name(x509)))
 308         goto err;
 309
 310     /*
 311      * because ASN1_INTEGER_set is used to set a 'long' we will do things the
 312      * ugly way.
 313      */
 314     ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
 315     if (!(p7i->issuer_and_serial->serial =
 316           ASN1_INTEGER_dup(X509_get0_serialNumber(x509))))
 317         goto err;
 318
 319     /*
 320      * TODO(3.0) Adapt for provider-native keys
 321      * Meanwhile, we downgrade the key.
 322      * #legacy
 323      */
 324     if (!evp_pkey_downgrade(pkey)) {
 325         PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SET,
 326                  PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 327         goto err;
 328     }
 329
 330     /* lets keep the pkey around for a while */
 331     EVP_PKEY_up_ref(pkey);
 332     p7i->pkey = pkey;
 333
 334     /* Set the algorithms */
 335
 336     X509_ALGOR_set0(p7i->digest_alg, OBJ_nid2obj(EVP_MD_type(dgst)),
 337                     V_ASN1_NULL, NULL);
 338
 339     if (pkey->ameth && pkey->ameth->pkey_ctrl) {
 340         ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_SIGN, 0, p7i);
 341         if (ret > 0)
 342             return 1;
 343         if (ret != -2) {
 344             PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SET,
 345                      PKCS7_R_SIGNING_CTRL_FAILURE);
 346             return 0;
 347         }
 348     }
 349     PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SET,
 350              PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 351  err:
 352     return 0;
 353 }
 354
 355 PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey,
 356                                        const EVP_MD *dgst)
 357 {
 358     PKCS7_SIGNER_INFO *si = NULL;
 359
 360     if (dgst == NULL) {
 361         int def_nid;
 362         if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0)
 363             goto err;
 364         dgst = EVP_get_digestbynid(def_nid);
 365         if (dgst == NULL) {
 366             PKCS7err(PKCS7_F_PKCS7_ADD_SIGNATURE, PKCS7_R_NO_DEFAULT_DIGEST);
 367             goto err;
 368         }
 369     }
 370
 371     if ((si = PKCS7_SIGNER_INFO_new()) == NULL)
 372         goto err;
 373     if (!PKCS7_SIGNER_INFO_set(si, x509, pkey, dgst))
 374         goto err;
 375     if (!PKCS7_add_signer(p7, si))
 376         goto err;
 377     return si;
 378  err:
 379     PKCS7_SIGNER_INFO_free(si);
 380     return NULL;
 381 }
 382
 383 static STACK_OF(X509) *pkcs7_get_signer_certs(const PKCS7 *p7)
 384 {
 385     if (PKCS7_type_is_signed(p7))
 386         return p7->d.sign->cert;
 387     if (PKCS7_type_is_signedAndEnveloped(p7))
 388         return p7->d.signed_and_enveloped->cert;
 389     return NULL;
 390 }
 391
 392 static STACK_OF(PKCS7_RECIP_INFO) *pkcs7_get_recipient_info(const PKCS7 *p7)
 393 {
 394     if (PKCS7_type_is_signedAndEnveloped(p7))
 395         return p7->d.signed_and_enveloped->recipientinfo;
 396     if (PKCS7_type_is_enveloped(p7))
 397         return p7->d.enveloped->recipientinfo;
 398     return NULL;
 399 }
 400
 401 /*
 402  * Set up the library context into any loaded structure that needs it.
 403  * i.e loaded X509 objects.
 404  */
 405 void pkcs7_resolve_libctx(PKCS7 *p7)
 406 {
 407     int i;
 408     const PKCS7_CTX *ctx = pkcs7_get0_ctx(p7);
 409     STACK_OF(PKCS7_RECIP_INFO) *rinfos = pkcs7_get_recipient_info(p7);
 410     STACK_OF(PKCS7_SIGNER_INFO) *sinfos = PKCS7_get_signer_info(p7);
 411     STACK_OF(X509) *certs = pkcs7_get_signer_certs(p7);
 412
 413     if (ctx == NULL)
 414         return;
 415
 416     for (i = 0; i < sk_X509_num(certs); i++)
 417         x509_set0_libctx(sk_X509_value(certs, i), ctx->libctx, ctx->propq);
 418
 419     for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rinfos); i++) {
 420         PKCS7_RECIP_INFO *ri = sk_PKCS7_RECIP_INFO_value(rinfos, i);
 421
 422         x509_set0_libctx(ri->cert, ctx->libctx, ctx->propq);
 423     }
 424
 425     for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
 426         PKCS7_SIGNER_INFO *si = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
 427
 428         if (si != NULL)
 429             si->ctx = ctx;
 430     }
 431 }
 432
 433 const PKCS7_CTX *pkcs7_get0_ctx(const PKCS7 *p7)
 434 {
 435     return p7 != NULL ? &p7->ctx : NULL;
 436 }
 437
 438 OPENSSL_CTX *pkcs7_ctx_get0_libctx(const PKCS7_CTX *ctx)
 439 {
 440     return ctx != NULL ? ctx->libctx : NULL;
 441 }
 442 const char *pkcs7_ctx_get0_propq(const PKCS7_CTX *ctx)
 443 {
 444     return ctx != NULL ? ctx->propq : NULL;
 445 }
 446
 447 int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
 448 {
 449     if (PKCS7_type_is_digest(p7)) {
 450         if ((p7->d.digest->md->parameter = ASN1_TYPE_new()) == NULL) {
 451             PKCS7err(PKCS7_F_PKCS7_SET_DIGEST, ERR_R_MALLOC_FAILURE);
 452             return 0;
 453         }
 454         p7->d.digest->md->parameter->type = V_ASN1_NULL;
 455         p7->d.digest->md->algorithm = OBJ_nid2obj(EVP_MD_nid(md));
 456         return 1;
 457     }
 458
 459     PKCS7err(PKCS7_F_PKCS7_SET_DIGEST, PKCS7_R_WRONG_CONTENT_TYPE);
 460     return 1;
 461 }
 462
 463 STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7)
 464 {
 465     if (p7 == NULL || p7->d.ptr == NULL)
 466         return NULL;
 467     if (PKCS7_type_is_signed(p7)) {
 468         return p7->d.sign->signer_info;
 469     } else if (PKCS7_type_is_signedAndEnveloped(p7)) {
 470         return p7->d.signed_and_enveloped->signer_info;
 471     } else
 472         return NULL;
 473 }
 474
 475 void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
 476                                  X509_ALGOR **pdig, X509_ALGOR **psig)
 477 {
 478     if (pk)
 479         *pk = si->pkey;
 480     if (pdig)
 481         *pdig = si->digest_alg;
 482     if (psig)
 483         *psig = si->digest_enc_alg;
 484 }
 485
 486 void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
 487 {
 488     if (penc)
 489         *penc = ri->key_enc_algor;
 490 }
 491
 492 PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
 493 {
 494     PKCS7_RECIP_INFO *ri;
 495
 496     if ((ri = PKCS7_RECIP_INFO_new()) == NULL)
 497         goto err;
 498     if (!PKCS7_RECIP_INFO_set(ri, x509))
 499         goto err;
 500     if (!PKCS7_add_recipient_info(p7, ri))
 501         goto err;
 502     ri->ctx = pkcs7_get0_ctx(p7);
 503     return ri;
 504  err:
 505     PKCS7_RECIP_INFO_free(ri);
 506     return NULL;
 507 }
 508
 509 int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
 510 {
 511     int i;
 512     STACK_OF(PKCS7_RECIP_INFO) *sk;
 513
 514     i = OBJ_obj2nid(p7->type);
 515     switch (i) {
 516     case NID_pkcs7_signedAndEnveloped:
 517         sk = p7->d.signed_and_enveloped->recipientinfo;
 518         break;
 519     case NID_pkcs7_enveloped:
 520         sk = p7->d.enveloped->recipientinfo;
 521         break;
 522     default:
 523         PKCS7err(PKCS7_F_PKCS7_ADD_RECIPIENT_INFO,
 524                  PKCS7_R_WRONG_CONTENT_TYPE);
 525         return 0;
 526     }
 527
 528     if (!sk_PKCS7_RECIP_INFO_push(sk, ri))
 529         return 0;
 530     return 1;
 531 }
 532
 533 int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
 534 {
 535     int ret;
 536     EVP_PKEY *pkey = NULL;
 537     if (!ASN1_INTEGER_set(p7i->version, 0))
 538         return 0;
 539     if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
 540                        X509_get_issuer_name(x509)))
 541         return 0;
 542
 543     ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
 544     if (!(p7i->issuer_and_serial->serial =
 545           ASN1_INTEGER_dup(X509_get0_serialNumber(x509))))
 546         return 0;
 547
 548     pkey = X509_get0_pubkey(x509);
 549
 550     if (!pkey || !pkey->ameth || !pkey->ameth->pkey_ctrl) {
 551         PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
 552                  PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 553         goto err;
 554     }
 555
 556     ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_ENCRYPT, 0, p7i);
 557     if (ret == -2) {
 558         PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
 559                  PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 560         goto err;
 561     }
 562     if (ret <= 0) {
 563         PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
 564                  PKCS7_R_ENCRYPTION_CTRL_FAILURE);
 565         goto err;
 566     }
 567
 568     X509_up_ref(x509);
 569     p7i->cert = x509;
 570
 571     return 1;
 572
 573  err:
 574     return 0;
 575 }
 576
 577 X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
 578 {
 579     if (PKCS7_type_is_signed(p7))
 580         return (X509_find_by_issuer_and_serial(p7->d.sign->cert,
 581                                                si->issuer_and_serial->issuer,
 582                                                si->
 583                                                issuer_and_serial->serial));
 584     else
 585         return NULL;
 586 }
 587
 588 int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
 589 {
 590     int i;
 591     PKCS7_ENC_CONTENT *ec;
 592
 593     i = OBJ_obj2nid(p7->type);
 594     switch (i) {
 595     case NID_pkcs7_signedAndEnveloped:
 596         ec = p7->d.signed_and_enveloped->enc_data;
 597         break;
 598     case NID_pkcs7_enveloped:
 599         ec = p7->d.enveloped->enc_data;
 600         break;
 601     default:
 602         PKCS7err(PKCS7_F_PKCS7_SET_CIPHER, PKCS7_R_WRONG_CONTENT_TYPE);
 603         return 0;
 604     }
 605
 606     /* Check cipher OID exists and has data in it */
 607     i = EVP_CIPHER_type(cipher);
 608     if (i == NID_undef) {
 609         PKCS7err(PKCS7_F_PKCS7_SET_CIPHER,
 610                  PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);
 611         return 0;
 612     }
 613
 614     ec->cipher = cipher;
 615     ec->ctx = pkcs7_get0_ctx(p7);
 616     return 1;
 617 }
 618
 619 /* unfortunately cannot constify BIO_new_NDEF() due to this and CMS_stream() */
 620 int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
 621 {
 622     ASN1_OCTET_STRING *os = NULL;
 623
 624     switch (OBJ_obj2nid(p7->type)) {
 625     case NID_pkcs7_data:
 626         os = p7->d.data;
 627         break;
 628
 629     case NID_pkcs7_signedAndEnveloped:
 630         os = p7->d.signed_and_enveloped->enc_data->enc_data;
 631         if (os == NULL) {
 632             os = ASN1_OCTET_STRING_new();
 633             p7->d.signed_and_enveloped->enc_data->enc_data = os;
 634         }
 635         break;
 636
 637     case NID_pkcs7_enveloped:
 638         os = p7->d.enveloped->enc_data->enc_data;
 639         if (os == NULL) {
 640             os = ASN1_OCTET_STRING_new();
 641             p7->d.enveloped->enc_data->enc_data = os;
 642         }
 643         break;
 644
 645     case NID_pkcs7_signed:
 646         os = p7->d.sign->contents->d.data;
 647         break;
 648
 649     default:
 650         os = NULL;
 651         break;
 652     }
 653
 654     if (os == NULL)
 655         return 0;
 656
 657     os->flags |= ASN1_STRING_FLAG_NDEF;
 658     *boundary = &os->data;
 659
 660     return 1;
 661 }