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