crypto/libressl/crypto/pkcs7/pk7_lib.c

   1 /* $OpenBSD: pk7_lib.c,v 1.23 2021/12/12 21:30:14 tb Exp $ */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60
  61 #include <openssl/err.h>
  62 #include <openssl/objects.h>
  63 #include <openssl/x509.h>
  64
  65 #include "asn1_locl.h"
  66 #include "evp_locl.h"
  67 #include "x509_lcl.h"
  68
  69 long
  70 PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg)
  71 {
  72         int nid;
  73         long ret;
  74
  75         nid = OBJ_obj2nid(p7->type);
  76
  77         switch (cmd) {
  78         case PKCS7_OP_SET_DETACHED_SIGNATURE:
  79                 if (nid == NID_pkcs7_signed) {
  80                         ret = p7->detached = (int)larg;
  81                         if (ret && PKCS7_type_is_data(p7->d.sign->contents)) {
  82                                 ASN1_OCTET_STRING *os;
  83                                 os = p7->d.sign->contents->d.data;
  84                                 ASN1_OCTET_STRING_free(os);
  85                                 p7->d.sign->contents->d.data = NULL;
  86                         }
  87                 } else {
  88                         PKCS7error(PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
  89                         ret = 0;
  90                 }
  91                 break;
  92         case PKCS7_OP_GET_DETACHED_SIGNATURE:
  93                 if (nid == NID_pkcs7_signed) {
  94                         if (!p7->d.sign  || !p7->d.sign->contents->d.ptr)
  95                                 ret = 1;
  96                         else
  97                                 ret = 0;
  98
  99                         p7->detached = ret;
 100                 } else {
 101                         PKCS7error(PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
 102                         ret = 0;
 103                 }
 104
 105                 break;
 106         default:
 107                 PKCS7error(PKCS7_R_UNKNOWN_OPERATION);
 108                 ret = 0;
 109         }
 110         return (ret);
 111 }
 112
 113 int
 114 PKCS7_content_new(PKCS7 *p7, int type)
 115 {
 116         PKCS7 *ret = NULL;
 117
 118         if ((ret = PKCS7_new()) == NULL)
 119                 goto err;
 120         if (!PKCS7_set_type(ret, type))
 121                 goto err;
 122         if (!PKCS7_set_content(p7, ret))
 123                 goto err;
 124
 125         return (1);
 126 err:
 127         if (ret != NULL)
 128                 PKCS7_free(ret);
 129         return (0);
 130 }
 131
 132 int
 133 PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
 134 {
 135         int i;
 136
 137         i = OBJ_obj2nid(p7->type);
 138         switch (i) {
 139         case NID_pkcs7_signed:
 140                 if (p7->d.sign->contents != NULL)
 141                         PKCS7_free(p7->d.sign->contents);
 142                 p7->d.sign->contents = p7_data;
 143                 break;
 144         case NID_pkcs7_digest:
 145                 if (p7->d.digest->contents != NULL)
 146                         PKCS7_free(p7->d.digest->contents);
 147                 p7->d.digest->contents = p7_data;
 148                 break;
 149         case NID_pkcs7_data:
 150         case NID_pkcs7_enveloped:
 151         case NID_pkcs7_signedAndEnveloped:
 152         case NID_pkcs7_encrypted:
 153         default:
 154                 PKCS7error(PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 155                 goto err;
 156         }
 157         return (1);
 158 err:
 159         return (0);
 160 }
 161
 162 int
 163 PKCS7_set_type(PKCS7 *p7, int type)
 164 {
 165         ASN1_OBJECT *obj;
 166
 167         /*PKCS7_content_free(p7);*/
 168         obj=OBJ_nid2obj(type); /* will not fail */
 169
 170         switch (type) {
 171         case NID_pkcs7_signed:
 172                 p7->type = obj;
 173                 if ((p7->d.sign = PKCS7_SIGNED_new()) == NULL)
 174                         goto err;
 175                 if (!ASN1_INTEGER_set(p7->d.sign->version, 1)) {
 176                         PKCS7_SIGNED_free(p7->d.sign);
 177                         p7->d.sign = NULL;
 178                         goto err;
 179                 }
 180                 break;
 181         case NID_pkcs7_data:
 182                 p7->type = obj;
 183                 if ((p7->d.data = ASN1_OCTET_STRING_new()) == NULL)
 184                         goto err;
 185                 break;
 186         case NID_pkcs7_signedAndEnveloped:
 187                 p7->type = obj;
 188                 if ((p7->d.signed_and_enveloped =
 189                     PKCS7_SIGN_ENVELOPE_new()) == NULL)
 190                         goto err;
 191                 if (!ASN1_INTEGER_set(p7->d.signed_and_enveloped->version, 1))
 192                         goto err;
 193                 p7->d.signed_and_enveloped->enc_data->content_type =
 194                     OBJ_nid2obj(NID_pkcs7_data);
 195                 break;
 196         case NID_pkcs7_enveloped:
 197                 p7->type = obj;
 198                 if ((p7->d.enveloped = PKCS7_ENVELOPE_new()) == NULL)
 199                         goto err;
 200                 if (!ASN1_INTEGER_set(p7->d.enveloped->version, 0))
 201                         goto err;
 202                 p7->d.enveloped->enc_data->content_type =
 203                     OBJ_nid2obj(NID_pkcs7_data);
 204                 break;
 205         case NID_pkcs7_encrypted:
 206                 p7->type = obj;
 207                 if ((p7->d.encrypted = PKCS7_ENCRYPT_new()) == NULL)
 208                         goto err;
 209                 if (!ASN1_INTEGER_set(p7->d.encrypted->version, 0))
 210                         goto err;
 211                 p7->d.encrypted->enc_data->content_type =
 212                     OBJ_nid2obj(NID_pkcs7_data);
 213                 break;
 214
 215         case NID_pkcs7_digest:
 216                 p7->type = obj;
 217                 if ((p7->d.digest = PKCS7_DIGEST_new()) == NULL)
 218                         goto err;
 219                 if (!ASN1_INTEGER_set(p7->d.digest->version, 0))
 220                         goto err;
 221                 break;
 222         default:
 223                 PKCS7error(PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 224                 goto err;
 225         }
 226         return (1);
 227 err:
 228         return (0);
 229 }
 230
 231 int
 232 PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
 233 {
 234         p7->type = OBJ_nid2obj(type);
 235         p7->d.other = other;
 236         return 1;
 237 }
 238
 239 int
 240 PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
 241 {
 242         int i, j, nid;
 243         X509_ALGOR *alg;
 244         STACK_OF(PKCS7_SIGNER_INFO) *signer_sk;
 245         STACK_OF(X509_ALGOR) *md_sk;
 246
 247         i = OBJ_obj2nid(p7->type);
 248         switch (i) {
 249         case NID_pkcs7_signed:
 250                 signer_sk = p7->d.sign->signer_info;
 251                 md_sk = p7->d.sign->md_algs;
 252                 break;
 253         case NID_pkcs7_signedAndEnveloped:
 254                 signer_sk = p7->d.signed_and_enveloped->signer_info;
 255                 md_sk = p7->d.signed_and_enveloped->md_algs;
 256                 break;
 257         default:
 258                 PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 259                 return (0);
 260         }
 261
 262         nid = OBJ_obj2nid(psi->digest_alg->algorithm);
 263
 264         /* If the digest is not currently listed, add it */
 265         j = 0;
 266         for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++) {
 267                 alg = sk_X509_ALGOR_value(md_sk, i);
 268                 if (OBJ_obj2nid(alg->algorithm) == nid) {
 269                         j = 1;
 270                         break;
 271                 }
 272         }
 273         if (!j) /* we need to add another algorithm */
 274         {
 275                 if (!(alg = X509_ALGOR_new()) ||
 276                     !(alg->parameter = ASN1_TYPE_new())) {
 277                         X509_ALGOR_free(alg);
 278                         PKCS7error(ERR_R_MALLOC_FAILURE);
 279                         return (0);
 280                 }
 281                 alg->algorithm = OBJ_nid2obj(nid);
 282                 alg->parameter->type = V_ASN1_NULL;
 283                 if (!sk_X509_ALGOR_push(md_sk, alg)) {
 284                         X509_ALGOR_free(alg);
 285                         return 0;
 286                 }
 287         }
 288
 289         if (!sk_PKCS7_SIGNER_INFO_push(signer_sk, psi))
 290                 return 0;
 291         return (1);
 292 }
 293
 294 int
 295 PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
 296 {
 297         int i;
 298         STACK_OF(X509) **sk;
 299
 300         i = OBJ_obj2nid(p7->type);
 301         switch (i) {
 302         case NID_pkcs7_signed:
 303                 sk = &(p7->d.sign->cert);
 304                 break;
 305         case NID_pkcs7_signedAndEnveloped:
 306                 sk = &(p7->d.signed_and_enveloped->cert);
 307                 break;
 308         default:
 309                 PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 310                 return (0);
 311         }
 312
 313         if (*sk == NULL)
 314                 *sk = sk_X509_new_null();
 315         if (*sk == NULL) {
 316                 PKCS7error(ERR_R_MALLOC_FAILURE);
 317                 return 0;
 318         }
 319         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509);
 320         if (!sk_X509_push(*sk, x509)) {
 321                 X509_free(x509);
 322                 return 0;
 323         }
 324         return (1);
 325 }
 326
 327 int
 328 PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
 329 {
 330         int i;
 331         STACK_OF(X509_CRL) **sk;
 332
 333         i = OBJ_obj2nid(p7->type);
 334         switch (i) {
 335         case NID_pkcs7_signed:
 336                 sk = &(p7->d.sign->crl);
 337                 break;
 338         case NID_pkcs7_signedAndEnveloped:
 339                 sk = &(p7->d.signed_and_enveloped->crl);
 340                 break;
 341         default:
 342                 PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 343                 return (0);
 344         }
 345
 346         if (*sk == NULL)
 347                 *sk = sk_X509_CRL_new_null();
 348         if (*sk == NULL) {
 349                 PKCS7error(ERR_R_MALLOC_FAILURE);
 350                 return 0;
 351         }
 352
 353         CRYPTO_add(&crl->references, 1, CRYPTO_LOCK_X509_CRL);
 354         if (!sk_X509_CRL_push(*sk, crl)) {
 355                 X509_CRL_free(crl);
 356                 return 0;
 357         }
 358         return (1);
 359 }
 360
 361 int
 362 PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
 363     const EVP_MD *dgst)
 364 {
 365         int ret;
 366
 367         /* We now need to add another PKCS7_SIGNER_INFO entry */
 368         if (!ASN1_INTEGER_set(p7i->version, 1))
 369                 goto err;
 370         if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
 371             X509_get_issuer_name(x509)))
 372                 goto err;
 373
 374         /* because ASN1_INTEGER_set is used to set a 'long' we will do
 375          * things the ugly way. */
 376         ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
 377         if (!(p7i->issuer_and_serial->serial =
 378             ASN1_INTEGER_dup(X509_get_serialNumber(x509))))
 379                 goto err;
 380
 381         /* lets keep the pkey around for a while */
 382         CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 383         p7i->pkey = pkey;
 384
 385         /* Set the algorithms */
 386
 387         X509_ALGOR_set0(p7i->digest_alg, OBJ_nid2obj(EVP_MD_type(dgst)),
 388             V_ASN1_NULL, NULL);
 389
 390         if (pkey->ameth && pkey->ameth->pkey_ctrl) {
 391                 ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_SIGN,
 392                     0, p7i);
 393                 if (ret > 0)
 394                         return 1;
 395                 if (ret != -2) {
 396                         PKCS7error(PKCS7_R_SIGNING_CTRL_FAILURE);
 397                         return 0;
 398                 }
 399         }
 400         PKCS7error(PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 401 err:
 402         return 0;
 403 }
 404
 405 PKCS7_SIGNER_INFO *
 406 PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey, const EVP_MD *dgst)
 407 {
 408         PKCS7_SIGNER_INFO *si = NULL;
 409
 410         if (dgst == NULL) {
 411                 int def_nid;
 412                 if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0)
 413                         goto err;
 414                 dgst = EVP_get_digestbynid(def_nid);
 415                 if (dgst == NULL) {
 416                         PKCS7error(PKCS7_R_NO_DEFAULT_DIGEST);
 417                         goto err;
 418                 }
 419         }
 420
 421         if ((si = PKCS7_SIGNER_INFO_new()) == NULL)
 422                 goto err;
 423         if (!PKCS7_SIGNER_INFO_set(si, x509, pkey, dgst))
 424                 goto err;
 425         if (!PKCS7_add_signer(p7, si))
 426                 goto err;
 427         return (si);
 428 err:
 429         if (si)
 430                 PKCS7_SIGNER_INFO_free(si);
 431         return (NULL);
 432 }
 433
 434 int
 435 PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
 436 {
 437         if (PKCS7_type_is_digest(p7)) {
 438                 if (!(p7->d.digest->md->parameter = ASN1_TYPE_new())) {
 439                         PKCS7error(ERR_R_MALLOC_FAILURE);
 440                         return 0;
 441                 }
 442                 p7->d.digest->md->parameter->type = V_ASN1_NULL;
 443                 p7->d.digest->md->algorithm = OBJ_nid2obj(EVP_MD_nid(md));
 444                 return 1;
 445         }
 446
 447         PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 448         return 1;
 449 }
 450
 451 STACK_OF(PKCS7_SIGNER_INFO) *
 452 PKCS7_get_signer_info(PKCS7 *p7)
 453 {
 454         if (p7 == NULL || p7->d.ptr == NULL)
 455                 return (NULL);
 456         if (PKCS7_type_is_signed(p7)) {
 457                 return (p7->d.sign->signer_info);
 458         } else if (PKCS7_type_is_signedAndEnveloped(p7)) {
 459                 return (p7->d.signed_and_enveloped->signer_info);
 460         } else
 461                 return (NULL);
 462 }
 463
 464 void
 465 PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
 466     X509_ALGOR **pdig, X509_ALGOR **psig)
 467 {
 468         if (pk)
 469                 *pk = si->pkey;
 470         if (pdig)
 471                 *pdig = si->digest_alg;
 472         if (psig)
 473                 *psig = si->digest_enc_alg;
 474 }
 475
 476 void
 477 PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
 478 {
 479         if (penc)
 480                 *penc = ri->key_enc_algor;
 481 }
 482
 483 PKCS7_RECIP_INFO *
 484 PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
 485 {
 486         PKCS7_RECIP_INFO *ri;
 487
 488         if ((ri = PKCS7_RECIP_INFO_new()) == NULL)
 489                 goto err;
 490         if (!PKCS7_RECIP_INFO_set(ri, x509))
 491                 goto err;
 492         if (!PKCS7_add_recipient_info(p7, ri))
 493                 goto err;
 494         return ri;
 495 err:
 496         if (ri)
 497                 PKCS7_RECIP_INFO_free(ri);
 498         return NULL;
 499 }
 500
 501 int
 502 PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
 503 {
 504         int i;
 505         STACK_OF(PKCS7_RECIP_INFO) *sk;
 506
 507         i = OBJ_obj2nid(p7->type);
 508         switch (i) {
 509         case NID_pkcs7_signedAndEnveloped:
 510                 sk = p7->d.signed_and_enveloped->recipientinfo;
 511                 break;
 512         case NID_pkcs7_enveloped:
 513                 sk = p7->d.enveloped->recipientinfo;
 514                 break;
 515         default:
 516                 PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 517                 return (0);
 518         }
 519
 520         if (!sk_PKCS7_RECIP_INFO_push(sk, ri))
 521                 return 0;
 522         return (1);
 523 }
 524
 525 int
 526 PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
 527 {
 528         int ret;
 529         EVP_PKEY *pkey = NULL;
 530         if (!ASN1_INTEGER_set(p7i->version, 0))
 531                 return 0;
 532         if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
 533             X509_get_issuer_name(x509)))
 534                 return 0;
 535
 536         ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
 537         if (!(p7i->issuer_and_serial->serial =
 538             ASN1_INTEGER_dup(X509_get_serialNumber(x509))))
 539                 return 0;
 540
 541         pkey = X509_get_pubkey(x509);
 542
 543         if (!pkey || !pkey->ameth || !pkey->ameth->pkey_ctrl) {
 544                 PKCS7error(PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 545                 goto err;
 546         }
 547
 548         ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_ENCRYPT,
 549             0, p7i);
 550         if (ret == -2) {
 551                 PKCS7error(PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 552                 goto err;
 553         }
 554         if (ret <= 0) {
 555                 PKCS7error(PKCS7_R_ENCRYPTION_CTRL_FAILURE);
 556                 goto err;
 557         }
 558
 559         EVP_PKEY_free(pkey);
 560
 561         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509);
 562         p7i->cert = x509;
 563
 564         return 1;
 565
 566 err:
 567         EVP_PKEY_free(pkey);
 568         return 0;
 569 }
 570
 571 X509 *
 572 PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
 573 {
 574         if (PKCS7_type_is_signed(p7))
 575                 return(X509_find_by_issuer_and_serial(p7->d.sign->cert,
 576                     si->issuer_and_serial->issuer,
 577                     si->issuer_and_serial->serial));
 578         else
 579                 return (NULL);
 580 }
 581
 582 int
 583 PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
 584 {
 585         int i;
 586         PKCS7_ENC_CONTENT *ec;
 587
 588         i = OBJ_obj2nid(p7->type);
 589         switch (i) {
 590         case NID_pkcs7_signedAndEnveloped:
 591                 ec = p7->d.signed_and_enveloped->enc_data;
 592                 break;
 593         case NID_pkcs7_enveloped:
 594                 ec = p7->d.enveloped->enc_data;
 595                 break;
 596         default:
 597                 PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 598                 return (0);
 599         }
 600
 601         /* Check cipher OID exists and has data in it*/
 602         i = EVP_CIPHER_type(cipher);
 603         if (i == NID_undef) {
 604                 PKCS7error(PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);
 605                 return (0);
 606         }
 607
 608         ec->cipher = cipher;
 609         return 1;
 610 }
 611
 612 int
 613 PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
 614 {
 615         ASN1_OCTET_STRING *os = NULL;
 616
 617         switch (OBJ_obj2nid(p7->type)) {
 618         case NID_pkcs7_data:
 619                 os = p7->d.data;
 620                 break;
 621
 622         case NID_pkcs7_signedAndEnveloped:
 623                 os = p7->d.signed_and_enveloped->enc_data->enc_data;
 624                 if (os == NULL) {
 625                         os = ASN1_OCTET_STRING_new();
 626                         p7->d.signed_and_enveloped->enc_data->enc_data = os;
 627                 }
 628                 break;
 629
 630         case NID_pkcs7_enveloped:
 631                 os = p7->d.enveloped->enc_data->enc_data;
 632                 if (os == NULL) {
 633                         os = ASN1_OCTET_STRING_new();
 634                         p7->d.enveloped->enc_data->enc_data = os;
 635                 }
 636                 break;
 637
 638         case NID_pkcs7_signed:
 639                 os = p7->d.sign->contents->d.data;
 640                 break;
 641
 642         default:
 643                 os = NULL;
 644                 break;
 645         }
 646
 647         if (os == NULL)
 648                 return 0;
 649
 650         os->flags |= ASN1_STRING_FLAG_NDEF;
 651         *boundary = &os->data;
 652
 653         return 1;
 654 }