crypto/cms/cms_smime.c

   1 /*
   2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  */
  53
  54 #include "internal/cryptlib.h"
  55 #include <openssl/asn1t.h>
  56 #include <openssl/x509.h>
  57 #include <openssl/x509v3.h>
  58 #include <openssl/err.h>
  59 #include <openssl/cms.h>
  60 #include "cms_lcl.h"
  61 #include "internal/asn1_int.h"
  62
  63 static BIO *cms_get_text_bio(BIO *out, unsigned int flags)
  64 {
  65     BIO *rbio;
  66     if (out == NULL)
  67         rbio = BIO_new(BIO_s_null());
  68     else if (flags & CMS_TEXT) {
  69         rbio = BIO_new(BIO_s_mem());
  70         BIO_set_mem_eof_return(rbio, 0);
  71     } else
  72         rbio = out;
  73     return rbio;
  74 }
  75
  76 static int cms_copy_content(BIO *out, BIO *in, unsigned int flags)
  77 {
  78     unsigned char buf[4096];
  79     int r = 0, i;
  80     BIO *tmpout;
  81
  82     tmpout = cms_get_text_bio(out, flags);
  83
  84     if (tmpout == NULL) {
  85         CMSerr(CMS_F_CMS_COPY_CONTENT, ERR_R_MALLOC_FAILURE);
  86         goto err;
  87     }
  88
  89     /* Read all content through chain to process digest, decrypt etc */
  90     for (;;) {
  91         i = BIO_read(in, buf, sizeof(buf));
  92         if (i <= 0) {
  93             if (BIO_method_type(in) == BIO_TYPE_CIPHER) {
  94                 if (!BIO_get_cipher_status(in))
  95                     goto err;
  96             }
  97             if (i < 0)
  98                 goto err;
  99             break;
 100         }
 101
 102         if (tmpout && (BIO_write(tmpout, buf, i) != i))
 103             goto err;
 104     }
 105
 106     if (flags & CMS_TEXT) {
 107         if (!SMIME_text(tmpout, out)) {
 108             CMSerr(CMS_F_CMS_COPY_CONTENT, CMS_R_SMIME_TEXT_ERROR);
 109             goto err;
 110         }
 111     }
 112
 113     r = 1;
 114
 115  err:
 116     if (tmpout != out)
 117         BIO_free(tmpout);
 118     return r;
 119
 120 }
 121
 122 static int check_content(CMS_ContentInfo *cms)
 123 {
 124     ASN1_OCTET_STRING **pos = CMS_get0_content(cms);
 125     if (!pos || !*pos) {
 126         CMSerr(CMS_F_CHECK_CONTENT, CMS_R_NO_CONTENT);
 127         return 0;
 128     }
 129     return 1;
 130 }
 131
 132 static void do_free_upto(BIO *f, BIO *upto)
 133 {
 134     if (upto) {
 135         BIO *tbio;
 136         do {
 137             tbio = BIO_pop(f);
 138             BIO_free(f);
 139             f = tbio;
 140         }
 141         while (f && f != upto);
 142     } else
 143         BIO_free_all(f);
 144 }
 145
 146 int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags)
 147 {
 148     BIO *cont;
 149     int r;
 150     if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_data) {
 151         CMSerr(CMS_F_CMS_DATA, CMS_R_TYPE_NOT_DATA);
 152         return 0;
 153     }
 154     cont = CMS_dataInit(cms, NULL);
 155     if (!cont)
 156         return 0;
 157     r = cms_copy_content(out, cont, flags);
 158     BIO_free_all(cont);
 159     return r;
 160 }
 161
 162 CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags)
 163 {
 164     CMS_ContentInfo *cms;
 165     cms = cms_Data_create();
 166     if (!cms)
 167         return NULL;
 168
 169     if ((flags & CMS_STREAM) || CMS_final(cms, in, NULL, flags))
 170         return cms;
 171
 172     CMS_ContentInfo_free(cms);
 173
 174     return NULL;
 175 }
 176
 177 int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
 178                       unsigned int flags)
 179 {
 180     BIO *cont;
 181     int r;
 182     if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_digest) {
 183         CMSerr(CMS_F_CMS_DIGEST_VERIFY, CMS_R_TYPE_NOT_DIGESTED_DATA);
 184         return 0;
 185     }
 186
 187     if (!dcont && !check_content(cms))
 188         return 0;
 189
 190     cont = CMS_dataInit(cms, dcont);
 191     if (!cont)
 192         return 0;
 193     r = cms_copy_content(out, cont, flags);
 194     if (r)
 195         r = cms_DigestedData_do_final(cms, cont, 1);
 196     do_free_upto(cont, dcont);
 197     return r;
 198 }
 199
 200 CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md,
 201                                    unsigned int flags)
 202 {
 203     CMS_ContentInfo *cms;
 204     if (!md)
 205         md = EVP_sha1();
 206     cms = cms_DigestedData_create(md);
 207     if (!cms)
 208         return NULL;
 209
 210     if (!(flags & CMS_DETACHED))
 211         CMS_set_detached(cms, 0);
 212
 213     if ((flags & CMS_STREAM) || CMS_final(cms, in, NULL, flags))
 214         return cms;
 215
 216     CMS_ContentInfo_free(cms);
 217     return NULL;
 218 }
 219
 220 int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
 221                               const unsigned char *key, size_t keylen,
 222                               BIO *dcont, BIO *out, unsigned int flags)
 223 {
 224     BIO *cont;
 225     int r;
 226     if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_encrypted) {
 227         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_DECRYPT,
 228                CMS_R_TYPE_NOT_ENCRYPTED_DATA);
 229         return 0;
 230     }
 231
 232     if (!dcont && !check_content(cms))
 233         return 0;
 234
 235     if (CMS_EncryptedData_set1_key(cms, NULL, key, keylen) <= 0)
 236         return 0;
 237     cont = CMS_dataInit(cms, dcont);
 238     if (!cont)
 239         return 0;
 240     r = cms_copy_content(out, cont, flags);
 241     do_free_upto(cont, dcont);
 242     return r;
 243 }
 244
 245 CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
 246                                            const unsigned char *key,
 247                                            size_t keylen, unsigned int flags)
 248 {
 249     CMS_ContentInfo *cms;
 250     if (!cipher) {
 251         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT, CMS_R_NO_CIPHER);
 252         return NULL;
 253     }
 254     cms = CMS_ContentInfo_new();
 255     if (cms == NULL)
 256         return NULL;
 257     if (!CMS_EncryptedData_set1_key(cms, cipher, key, keylen))
 258         return NULL;
 259
 260     if (!(flags & CMS_DETACHED))
 261         CMS_set_detached(cms, 0);
 262
 263     if ((flags & (CMS_STREAM | CMS_PARTIAL))
 264         || CMS_final(cms, in, NULL, flags))
 265         return cms;
 266
 267     CMS_ContentInfo_free(cms);
 268     return NULL;
 269 }
 270
 271 static int cms_signerinfo_verify_cert(CMS_SignerInfo *si,
 272                                       X509_STORE *store,
 273                                       STACK_OF(X509) *certs,
 274                                       STACK_OF(X509_CRL) *crls)
 275 {
 276     X509_STORE_CTX *ctx = X509_STORE_CTX_new();
 277     X509 *signer;
 278     int i, j, r = 0;
 279
 280     if (ctx == NULL) {
 281         CMSerr(CMS_F_CMS_SIGNERINFO_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
 282         goto err;
 283     }
 284     CMS_SignerInfo_get0_algs(si, NULL, &signer, NULL, NULL);
 285     if (!X509_STORE_CTX_init(ctx, store, signer, certs)) {
 286         CMSerr(CMS_F_CMS_SIGNERINFO_VERIFY_CERT, CMS_R_STORE_INIT_ERROR);
 287         goto err;
 288     }
 289     X509_STORE_CTX_set_default(ctx, "smime_sign");
 290     if (crls)
 291         X509_STORE_CTX_set0_crls(ctx, crls);
 292
 293     i = X509_verify_cert(ctx);
 294     if (i <= 0) {
 295         j = X509_STORE_CTX_get_error(ctx);
 296         CMSerr(CMS_F_CMS_SIGNERINFO_VERIFY_CERT,
 297                CMS_R_CERTIFICATE_VERIFY_ERROR);
 298         ERR_add_error_data(2, "Verify error:",
 299                            X509_verify_cert_error_string(j));
 300         goto err;
 301     }
 302     r = 1;
 303  err:
 304     X509_STORE_CTX_free(ctx);
 305     return r;
 306
 307 }
 308
 309 int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
 310                X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags)
 311 {
 312     CMS_SignerInfo *si;
 313     STACK_OF(CMS_SignerInfo) *sinfos;
 314     STACK_OF(X509) *cms_certs = NULL;
 315     STACK_OF(X509_CRL) *crls = NULL;
 316     X509 *signer;
 317     int i, scount = 0, ret = 0;
 318     BIO *cmsbio = NULL, *tmpin = NULL, *tmpout = NULL;
 319
 320     if (!dcont && !check_content(cms))
 321         return 0;
 322     if (dcont && !(flags & CMS_BINARY)) {
 323         const ASN1_OBJECT *coid = CMS_get0_eContentType(cms);
 324         if (OBJ_obj2nid(coid) == NID_id_ct_asciiTextWithCRLF)
 325             flags |= CMS_ASCIICRLF;
 326     }
 327
 328     /* Attempt to find all signer certificates */
 329
 330     sinfos = CMS_get0_SignerInfos(cms);
 331
 332     if (sk_CMS_SignerInfo_num(sinfos) <= 0) {
 333         CMSerr(CMS_F_CMS_VERIFY, CMS_R_NO_SIGNERS);
 334         goto err;
 335     }
 336
 337     for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
 338         si = sk_CMS_SignerInfo_value(sinfos, i);
 339         CMS_SignerInfo_get0_algs(si, NULL, &signer, NULL, NULL);
 340         if (signer)
 341             scount++;
 342     }
 343
 344     if (scount != sk_CMS_SignerInfo_num(sinfos))
 345         scount += CMS_set1_signers_certs(cms, certs, flags);
 346
 347     if (scount != sk_CMS_SignerInfo_num(sinfos)) {
 348         CMSerr(CMS_F_CMS_VERIFY, CMS_R_SIGNER_CERTIFICATE_NOT_FOUND);
 349         goto err;
 350     }
 351
 352     /* Attempt to verify all signers certs */
 353
 354     if (!(flags & CMS_NO_SIGNER_CERT_VERIFY)) {
 355         cms_certs = CMS_get1_certs(cms);
 356         if (!(flags & CMS_NOCRL))
 357             crls = CMS_get1_crls(cms);
 358         for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
 359             si = sk_CMS_SignerInfo_value(sinfos, i);
 360             if (!cms_signerinfo_verify_cert(si, store, cms_certs, crls))
 361                 goto err;
 362         }
 363     }
 364
 365     /* Attempt to verify all SignerInfo signed attribute signatures */
 366
 367     if (!(flags & CMS_NO_ATTR_VERIFY)) {
 368         for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
 369             si = sk_CMS_SignerInfo_value(sinfos, i);
 370             if (CMS_signed_get_attr_count(si) < 0)
 371                 continue;
 372             if (CMS_SignerInfo_verify(si) <= 0)
 373                 goto err;
 374         }
 375     }
 376
 377     /*
 378      * Performance optimization: if the content is a memory BIO then store
 379      * its contents in a temporary read only memory BIO. This avoids
 380      * potentially large numbers of slow copies of data which will occur when
 381      * reading from a read write memory BIO when signatures are calculated.
 382      */
 383
 384     if (dcont && (BIO_method_type(dcont) == BIO_TYPE_MEM)) {
 385         char *ptr;
 386         long len;
 387         len = BIO_get_mem_data(dcont, &ptr);
 388         tmpin = BIO_new_mem_buf(ptr, len);
 389         if (tmpin == NULL) {
 390             CMSerr(CMS_F_CMS_VERIFY, ERR_R_MALLOC_FAILURE);
 391             goto err2;
 392         }
 393     } else
 394         tmpin = dcont;
 395     /*
 396      * If not binary mode and detached generate digests by *writing* through
 397      * the BIO. That makes it possible to canonicalise the input.
 398      */
 399     if (!(flags & SMIME_BINARY) && dcont) {
 400         /*
 401          * Create output BIO so we can either handle text or to ensure
 402          * included content doesn't override detached content.
 403          */
 404         tmpout = cms_get_text_bio(out, flags);
 405         if (!tmpout) {
 406             CMSerr(CMS_F_CMS_VERIFY, ERR_R_MALLOC_FAILURE);
 407             goto err;
 408         }
 409         cmsbio = CMS_dataInit(cms, tmpout);
 410         if (!cmsbio)
 411             goto err;
 412         /*
 413          * Don't use SMIME_TEXT for verify: it adds headers and we want to
 414          * remove them.
 415          */
 416         SMIME_crlf_copy(dcont, cmsbio, flags & ~SMIME_TEXT);
 417
 418         if (flags & CMS_TEXT) {
 419             if (!SMIME_text(tmpout, out)) {
 420                 CMSerr(CMS_F_CMS_VERIFY, CMS_R_SMIME_TEXT_ERROR);
 421                 goto err;
 422             }
 423         }
 424     } else {
 425         cmsbio = CMS_dataInit(cms, tmpin);
 426         if (!cmsbio)
 427             goto err;
 428
 429         if (!cms_copy_content(out, cmsbio, flags))
 430             goto err;
 431
 432     }
 433     if (!(flags & CMS_NO_CONTENT_VERIFY)) {
 434         for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
 435             si = sk_CMS_SignerInfo_value(sinfos, i);
 436             if (CMS_SignerInfo_verify_content(si, cmsbio) <= 0) {
 437                 CMSerr(CMS_F_CMS_VERIFY, CMS_R_CONTENT_VERIFY_ERROR);
 438                 goto err;
 439             }
 440         }
 441     }
 442
 443     ret = 1;
 444
 445  err:
 446     if (!(flags & SMIME_BINARY) && dcont) {
 447         do_free_upto(cmsbio, tmpout);
 448         if (tmpin != dcont)
 449             BIO_free(tmpin);
 450     } else {
 451         if (dcont && (tmpin == dcont))
 452             do_free_upto(cmsbio, dcont);
 453         else
 454             BIO_free_all(cmsbio);
 455     }
 456
 457     if (out != tmpout)
 458         BIO_free_all(tmpout);
 459
 460  err2:
 461     sk_X509_pop_free(cms_certs, X509_free);
 462     sk_X509_CRL_pop_free(crls, X509_CRL_free);
 463
 464     return ret;
 465 }
 466
 467 int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms,
 468                        STACK_OF(X509) *certs,
 469                        X509_STORE *store, unsigned int flags)
 470 {
 471     int r;
 472     flags &= ~(CMS_DETACHED | CMS_TEXT);
 473     r = CMS_verify(rcms, certs, store, NULL, NULL, flags);
 474     if (r <= 0)
 475         return r;
 476     return cms_Receipt_verify(rcms, ocms);
 477 }
 478
 479 CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
 480                           STACK_OF(X509) *certs, BIO *data,
 481                           unsigned int flags)
 482 {
 483     CMS_ContentInfo *cms;
 484     int i;
 485
 486     cms = CMS_ContentInfo_new();
 487     if (cms == NULL || !CMS_SignedData_init(cms))
 488         goto merr;
 489     if (flags & CMS_ASCIICRLF
 490         && !CMS_set1_eContentType(cms,
 491                                   OBJ_nid2obj(NID_id_ct_asciiTextWithCRLF)))
 492         goto err;
 493
 494     if (pkey && !CMS_add1_signer(cms, signcert, pkey, NULL, flags)) {
 495         CMSerr(CMS_F_CMS_SIGN, CMS_R_ADD_SIGNER_ERROR);
 496         goto err;
 497     }
 498
 499     for (i = 0; i < sk_X509_num(certs); i++) {
 500         X509 *x = sk_X509_value(certs, i);
 501         if (!CMS_add1_cert(cms, x))
 502             goto merr;
 503     }
 504
 505     if (!(flags & CMS_DETACHED))
 506         CMS_set_detached(cms, 0);
 507
 508     if ((flags & (CMS_STREAM | CMS_PARTIAL))
 509         || CMS_final(cms, data, NULL, flags))
 510         return cms;
 511     else
 512         goto err;
 513
 514  merr:
 515     CMSerr(CMS_F_CMS_SIGN, ERR_R_MALLOC_FAILURE);
 516
 517  err:
 518     CMS_ContentInfo_free(cms);
 519     return NULL;
 520 }
 521
 522 CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si,
 523                                   X509 *signcert, EVP_PKEY *pkey,
 524                                   STACK_OF(X509) *certs, unsigned int flags)
 525 {
 526     CMS_SignerInfo *rct_si;
 527     CMS_ContentInfo *cms = NULL;
 528     ASN1_OCTET_STRING **pos, *os;
 529     BIO *rct_cont = NULL;
 530     int r = 0;
 531
 532     flags &= ~(CMS_STREAM | CMS_TEXT);
 533     /* Not really detached but avoids content being allocated */
 534     flags |= CMS_PARTIAL | CMS_BINARY | CMS_DETACHED;
 535     if (!pkey || !signcert) {
 536         CMSerr(CMS_F_CMS_SIGN_RECEIPT, CMS_R_NO_KEY_OR_CERT);
 537         return NULL;
 538     }
 539
 540     /* Initialize signed data */
 541
 542     cms = CMS_sign(NULL, NULL, certs, NULL, flags);
 543     if (!cms)
 544         goto err;
 545
 546     /* Set inner content type to signed receipt */
 547     if (!CMS_set1_eContentType(cms, OBJ_nid2obj(NID_id_smime_ct_receipt)))
 548         goto err;
 549
 550     rct_si = CMS_add1_signer(cms, signcert, pkey, NULL, flags);
 551     if (!rct_si) {
 552         CMSerr(CMS_F_CMS_SIGN_RECEIPT, CMS_R_ADD_SIGNER_ERROR);
 553         goto err;
 554     }
 555
 556     os = cms_encode_Receipt(si);
 557
 558     if (!os)
 559         goto err;
 560
 561     /* Set content to digest */
 562     rct_cont = BIO_new_mem_buf(os->data, os->length);
 563     if (!rct_cont)
 564         goto err;
 565
 566     /* Add msgSigDigest attribute */
 567
 568     if (!cms_msgSigDigest_add1(rct_si, si))
 569         goto err;
 570
 571     /* Finalize structure */
 572     if (!CMS_final(cms, rct_cont, NULL, flags))
 573         goto err;
 574
 575     /* Set embedded content */
 576     pos = CMS_get0_content(cms);
 577     *pos = os;
 578
 579     r = 1;
 580
 581  err:
 582     BIO_free(rct_cont);
 583     if (r)
 584         return cms;
 585     CMS_ContentInfo_free(cms);
 586     return NULL;
 587
 588 }
 589
 590 CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *data,
 591                              const EVP_CIPHER *cipher, unsigned int flags)
 592 {
 593     CMS_ContentInfo *cms;
 594     int i;
 595     X509 *recip;
 596     cms = CMS_EnvelopedData_create(cipher);
 597     if (!cms)
 598         goto merr;
 599     for (i = 0; i < sk_X509_num(certs); i++) {
 600         recip = sk_X509_value(certs, i);
 601         if (!CMS_add1_recipient_cert(cms, recip, flags)) {
 602             CMSerr(CMS_F_CMS_ENCRYPT, CMS_R_RECIPIENT_ERROR);
 603             goto err;
 604         }
 605     }
 606
 607     if (!(flags & CMS_DETACHED))
 608         CMS_set_detached(cms, 0);
 609
 610     if ((flags & (CMS_STREAM | CMS_PARTIAL))
 611         || CMS_final(cms, data, NULL, flags))
 612         return cms;
 613     else
 614         goto err;
 615
 616  merr:
 617     CMSerr(CMS_F_CMS_ENCRYPT, ERR_R_MALLOC_FAILURE);
 618  err:
 619     CMS_ContentInfo_free(cms);
 620     return NULL;
 621 }
 622
 623 static int cms_kari_set1_pkey(CMS_ContentInfo *cms, CMS_RecipientInfo *ri,
 624                               EVP_PKEY *pk, X509 *cert)
 625 {
 626     int i;
 627     STACK_OF(CMS_RecipientEncryptedKey) *reks;
 628     CMS_RecipientEncryptedKey *rek;
 629     reks = CMS_RecipientInfo_kari_get0_reks(ri);
 630     if (!cert)
 631         return 0;
 632     for (i = 0; i < sk_CMS_RecipientEncryptedKey_num(reks); i++) {
 633         int rv;
 634         rek = sk_CMS_RecipientEncryptedKey_value(reks, i);
 635         if (CMS_RecipientEncryptedKey_cert_cmp(rek, cert))
 636             continue;
 637         CMS_RecipientInfo_kari_set0_pkey(ri, pk);
 638         rv = CMS_RecipientInfo_kari_decrypt(cms, ri, rek);
 639         CMS_RecipientInfo_kari_set0_pkey(ri, NULL);
 640         if (rv > 0)
 641             return 1;
 642         return -1;
 643     }
 644     return 0;
 645 }
 646
 647 int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert)
 648 {
 649     STACK_OF(CMS_RecipientInfo) *ris;
 650     CMS_RecipientInfo *ri;
 651     int i, r, ri_type;
 652     int debug = 0, match_ri = 0;
 653     ris = CMS_get0_RecipientInfos(cms);
 654     if (ris)
 655         debug = cms->d.envelopedData->encryptedContentInfo->debug;
 656     ri_type = cms_pkey_get_ri_type(pk);
 657     if (ri_type == CMS_RECIPINFO_NONE) {
 658         CMSerr(CMS_F_CMS_DECRYPT_SET1_PKEY,
 659                CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
 660         return 0;
 661     }
 662
 663     for (i = 0; i < sk_CMS_RecipientInfo_num(ris); i++) {
 664         ri = sk_CMS_RecipientInfo_value(ris, i);
 665         if (CMS_RecipientInfo_type(ri) != ri_type)
 666             continue;
 667         match_ri = 1;
 668         if (ri_type == CMS_RECIPINFO_AGREE) {
 669             r = cms_kari_set1_pkey(cms, ri, pk, cert);
 670             if (r > 0)
 671                 return 1;
 672             if (r < 0)
 673                 return 0;
 674         }
 675         /*
 676          * If we have a cert try matching RecipientInfo otherwise try them
 677          * all.
 678          */
 679         else if (!cert || !CMS_RecipientInfo_ktri_cert_cmp(ri, cert)) {
 680             CMS_RecipientInfo_set0_pkey(ri, pk);
 681             r = CMS_RecipientInfo_decrypt(cms, ri);
 682             CMS_RecipientInfo_set0_pkey(ri, NULL);
 683             if (cert) {
 684                 /*
 685                  * If not debugging clear any error and return success to
 686                  * avoid leaking of information useful to MMA
 687                  */
 688                 if (!debug) {
 689                     ERR_clear_error();
 690                     return 1;
 691                 }
 692                 if (r > 0)
 693                     return 1;
 694                 CMSerr(CMS_F_CMS_DECRYPT_SET1_PKEY, CMS_R_DECRYPT_ERROR);
 695                 return 0;
 696             }
 697             /*
 698              * If no cert and not debugging don't leave loop after first
 699              * successful decrypt. Always attempt to decrypt all recipients
 700              * to avoid leaking timing of a successful decrypt.
 701              */
 702             else if (r > 0 && debug)
 703                 return 1;
 704         }
 705     }
 706     /* If no cert and not debugging always return success */
 707     if (match_ri && !cert && !debug) {
 708         ERR_clear_error();
 709         return 1;
 710     }
 711
 712     CMSerr(CMS_F_CMS_DECRYPT_SET1_PKEY, CMS_R_NO_MATCHING_RECIPIENT);
 713     return 0;
 714
 715 }
 716
 717 int CMS_decrypt_set1_key(CMS_ContentInfo *cms,
 718                          unsigned char *key, size_t keylen,
 719                          unsigned char *id, size_t idlen)
 720 {
 721     STACK_OF(CMS_RecipientInfo) *ris;
 722     CMS_RecipientInfo *ri;
 723     int i, r;
 724     ris = CMS_get0_RecipientInfos(cms);
 725     for (i = 0; i < sk_CMS_RecipientInfo_num(ris); i++) {
 726         ri = sk_CMS_RecipientInfo_value(ris, i);
 727         if (CMS_RecipientInfo_type(ri) != CMS_RECIPINFO_KEK)
 728             continue;
 729
 730         /*
 731          * If we have an id try matching RecipientInfo otherwise try them
 732          * all.
 733          */
 734         if (!id || (CMS_RecipientInfo_kekri_id_cmp(ri, id, idlen) == 0)) {
 735             CMS_RecipientInfo_set0_key(ri, key, keylen);
 736             r = CMS_RecipientInfo_decrypt(cms, ri);
 737             CMS_RecipientInfo_set0_key(ri, NULL, 0);
 738             if (r > 0)
 739                 return 1;
 740             if (id) {
 741                 CMSerr(CMS_F_CMS_DECRYPT_SET1_KEY, CMS_R_DECRYPT_ERROR);
 742                 return 0;
 743             }
 744             ERR_clear_error();
 745         }
 746     }
 747
 748     CMSerr(CMS_F_CMS_DECRYPT_SET1_KEY, CMS_R_NO_MATCHING_RECIPIENT);
 749     return 0;
 750
 751 }
 752
 753 int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
 754                               unsigned char *pass, ossl_ssize_t passlen)
 755 {
 756     STACK_OF(CMS_RecipientInfo) *ris;
 757     CMS_RecipientInfo *ri;
 758     int i, r;
 759     ris = CMS_get0_RecipientInfos(cms);
 760     for (i = 0; i < sk_CMS_RecipientInfo_num(ris); i++) {
 761         ri = sk_CMS_RecipientInfo_value(ris, i);
 762         if (CMS_RecipientInfo_type(ri) != CMS_RECIPINFO_PASS)
 763             continue;
 764         CMS_RecipientInfo_set0_password(ri, pass, passlen);
 765         r = CMS_RecipientInfo_decrypt(cms, ri);
 766         CMS_RecipientInfo_set0_password(ri, NULL, 0);
 767         if (r > 0)
 768             return 1;
 769     }
 770
 771     CMSerr(CMS_F_CMS_DECRYPT_SET1_PASSWORD, CMS_R_NO_MATCHING_RECIPIENT);
 772     return 0;
 773
 774 }
 775
 776 int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert,
 777                 BIO *dcont, BIO *out, unsigned int flags)
 778 {
 779     int r;
 780     BIO *cont;
 781     if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_enveloped) {
 782         CMSerr(CMS_F_CMS_DECRYPT, CMS_R_TYPE_NOT_ENVELOPED_DATA);
 783         return 0;
 784     }
 785     if (!dcont && !check_content(cms))
 786         return 0;
 787     if (flags & CMS_DEBUG_DECRYPT)
 788         cms->d.envelopedData->encryptedContentInfo->debug = 1;
 789     else
 790         cms->d.envelopedData->encryptedContentInfo->debug = 0;
 791     if (!pk && !cert && !dcont && !out)
 792         return 1;
 793     if (pk && !CMS_decrypt_set1_pkey(cms, pk, cert))
 794         return 0;
 795     cont = CMS_dataInit(cms, dcont);
 796     if (!cont)
 797         return 0;
 798     r = cms_copy_content(out, cont, flags);
 799     do_free_upto(cont, dcont);
 800     return r;
 801 }
 802
 803 int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, unsigned int flags)
 804 {
 805     BIO *cmsbio;
 806     int ret = 0;
 807
 808     if ((cmsbio = CMS_dataInit(cms, dcont)) == NULL) {
 809         CMSerr(CMS_F_CMS_FINAL, CMS_R_CMS_LIB);
 810         return 0;
 811     }
 812
 813     SMIME_crlf_copy(data, cmsbio, flags);
 814
 815     (void)BIO_flush(cmsbio);
 816
 817     if (!CMS_dataFinal(cms, cmsbio)) {
 818         CMSerr(CMS_F_CMS_FINAL, CMS_R_CMS_DATAFINAL_ERROR);
 819         goto err;
 820     }
 821
 822     ret = 1;
 823
 824  err:
 825     do_free_upto(cmsbio, dcont);
 826
 827     return ret;
 828
 829 }
 830
 831 #ifdef ZLIB
 832
 833 int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
 834                    unsigned int flags)
 835 {
 836     BIO *cont;
 837     int r;
 838     if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_id_smime_ct_compressedData) {
 839         CMSerr(CMS_F_CMS_UNCOMPRESS, CMS_R_TYPE_NOT_COMPRESSED_DATA);
 840         return 0;
 841     }
 842
 843     if (!dcont && !check_content(cms))
 844         return 0;
 845
 846     cont = CMS_dataInit(cms, dcont);
 847     if (!cont)
 848         return 0;
 849     r = cms_copy_content(out, cont, flags);
 850     do_free_upto(cont, dcont);
 851     return r;
 852 }
 853
 854 CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags)
 855 {
 856     CMS_ContentInfo *cms;
 857     if (comp_nid <= 0)
 858         comp_nid = NID_zlib_compression;
 859     cms = cms_CompressedData_create(comp_nid);
 860     if (!cms)
 861         return NULL;
 862
 863     if (!(flags & CMS_DETACHED))
 864         CMS_set_detached(cms, 0);
 865
 866     if ((flags & CMS_STREAM) || CMS_final(cms, in, NULL, flags))
 867         return cms;
 868
 869     CMS_ContentInfo_free(cms);
 870     return NULL;
 871 }
 872
 873 #else
 874
 875 int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
 876                    unsigned int flags)
 877 {
 878     CMSerr(CMS_F_CMS_UNCOMPRESS, CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
 879     return 0;
 880 }
 881
 882 CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags)
 883 {
 884     CMSerr(CMS_F_CMS_COMPRESS, CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
 885     return NULL;
 886 }
 887
 888 #endif