Add support for KEKRecipientInfo in cms application.
[openssl.git] / crypto / cms / cms_env.c
1 /* crypto/cms/cms_env.c */
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 "cryptlib.h"
55 #include <openssl/asn1t.h>
56 #include <openssl/pem.h>
57 #include <openssl/x509v3.h>
58 #include <openssl/err.h>
59 #include <openssl/cms.h>
60 #include <openssl/rand.h>
61 #include <openssl/aes.h>
62 #include "cms_lcl.h"
63 #include "asn1_locl.h"
64
65 /* CMS EnvelopedData Utilities */
66
67 DECLARE_ASN1_ITEM(CMS_EnvelopedData)
68 DECLARE_ASN1_ITEM(CMS_RecipientInfo)
69 DECLARE_ASN1_ITEM(CMS_KeyTransRecipientInfo)
70 DECLARE_ASN1_ITEM(CMS_KEKRecipientInfo)
71 DECLARE_ASN1_ITEM(CMS_OtherKeyAttribute)
72
73 DECLARE_STACK_OF(CMS_RecipientInfo)
74
75 static CMS_EnvelopedData *cms_get0_enveloped(CMS_ContentInfo *cms)
76         {
77         if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_enveloped)
78                 {
79                 CMSerr(CMS_F_CMS_GET0_ENVELOPED,
80                                 CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA);
81                 return NULL;
82                 }
83         return cms->d.envelopedData;
84         }
85
86 static CMS_EnvelopedData *cms_enveloped_data_init(CMS_ContentInfo *cms)
87         {
88         if (cms->d.other == NULL)
89                 {
90                 cms->d.envelopedData = M_ASN1_new_of(CMS_EnvelopedData);
91                 if (!cms->d.envelopedData)
92                         {
93                         CMSerr(CMS_F_CMS_ENVELOPED_DATA_INIT,
94                                                         ERR_R_MALLOC_FAILURE);
95                         return NULL;
96                         }
97                 cms->d.envelopedData->version = 0;
98                 cms->d.envelopedData->encryptedContentInfo->contentType =
99                                                 OBJ_nid2obj(NID_pkcs7_data);
100                 ASN1_OBJECT_free(cms->contentType);
101                 cms->contentType = OBJ_nid2obj(NID_pkcs7_enveloped);
102                 return cms->d.envelopedData;
103                 }
104         return cms_get0_enveloped(cms);
105         }
106
107 STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms)
108         {
109         CMS_EnvelopedData *env;
110         env = cms_get0_enveloped(cms);
111         if (!env)
112                 return NULL;
113         return env->recipientInfos;
114         }
115
116 int CMS_RecipientInfo_type(CMS_RecipientInfo *ri)
117         {
118         return ri->type;
119         }
120
121 CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher)
122         {
123         CMS_ContentInfo *cms;
124         CMS_EnvelopedData *env;
125         cms = CMS_ContentInfo_new();
126         if (!cms)
127                 goto merr;
128         env = cms_enveloped_data_init(cms);
129         if (!env)
130                 goto merr;
131         if (!cms_EncryptedContent_init(env->encryptedContentInfo,
132                                         cipher, NULL, 0))
133                 goto merr;
134         return cms;
135         merr:
136         if (cms)
137                 CMS_ContentInfo_free(cms);
138         CMSerr(CMS_F_CMS_ENVELOPEDDATA_CREATE, ERR_R_MALLOC_FAILURE);
139         return NULL;
140         }
141
142 /* Key Transport Recipient Info (KTRI) routines */
143
144 /* Add a recipient certificate. For now only handle key transport.
145  * If we ever handle key agreement will need updating.
146  */
147
148 CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
149                                         X509 *recip, unsigned int flags)
150         {
151         CMS_RecipientInfo *ri = NULL;
152         CMS_KeyTransRecipientInfo *ktri;
153         CMS_EnvelopedData *env;
154         EVP_PKEY *pk = NULL;
155         int i, type;
156         env = cms_get0_enveloped(cms);
157         if (!env)
158                 goto err;
159
160         /* Initialize recipient info */
161         ri = M_ASN1_new_of(CMS_RecipientInfo);
162         if (!ri)
163                 goto merr;
164
165         /* Initialize and add key transport recipient info */
166
167         ri->d.ktri = M_ASN1_new_of(CMS_KeyTransRecipientInfo);
168         if (!ri->d.ktri)
169                 goto merr;
170         ri->type = CMS_RECIPINFO_TRANS;
171
172         ktri = ri->d.ktri;
173
174         X509_check_purpose(recip, -1, -1);
175         pk = X509_get_pubkey(recip);
176         if (!pk)
177                 {
178                 CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
179                                 CMS_R_ERROR_GETTING_PUBLIC_KEY);
180                 goto err;
181                 }
182         CRYPTO_add(&recip->references, 1, CRYPTO_LOCK_X509);
183         ktri->pkey = pk;
184         ktri->recip = recip;
185
186         if (flags & CMS_USE_KEYID)
187                 {
188                 ktri->version = 2;
189                 type = CMS_RECIPINFO_KEYIDENTIFIER;
190                 }
191         else
192                 {
193                 ktri->version = 0;
194                 type = CMS_RECIPINFO_ISSUER_SERIAL;
195                 }
196
197         /* Not a typo: RecipientIdentifier and SignerIdentifier are the
198          * same structure.
199          */
200
201         if (!cms_set1_SignerIdentifier(ktri->rid, recip, type))
202                 goto err;
203
204         if (pk->ameth && pk->ameth->pkey_ctrl)
205                 {
206                 i = pk->ameth->pkey_ctrl(pk, ASN1_PKEY_CTRL_CMS_ENVELOPE,
207                                                 0, ri);
208                 if (i == -2)
209                         {
210                         CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
211                                 CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
212                         goto err;
213                         }
214                 if (i <= 0)
215                         {
216                         CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
217                                 CMS_R_CTRL_FAILURE);
218                         goto err;
219                         }
220                 }
221
222         if (!sk_CMS_RecipientInfo_push(env->recipientInfos, ri))
223                 goto merr;
224
225         return ri;
226
227         merr:
228         CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT, ERR_R_MALLOC_FAILURE);
229         err:
230         if (ri)
231                 M_ASN1_free_of(ri, CMS_RecipientInfo);
232         return NULL;
233
234         }
235
236 int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri,
237                                         EVP_PKEY **pk, X509 **recip,
238                                         X509_ALGOR **palg)
239         {
240         CMS_KeyTransRecipientInfo *ktri;
241         if (ri->type != CMS_RECIPINFO_TRANS)
242                 {
243                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS,
244                         CMS_R_NOT_KEY_TRANSPORT);
245                 return 0;
246                 }
247
248         ktri = ri->d.ktri;
249
250         if (pk)
251                 *pk = ktri->pkey;
252         if (recip)
253                 *recip = ktri->recip;
254         if (palg)
255                 *palg = ktri->keyEncryptionAlgorithm;
256         return 1;
257         }
258
259 int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri,
260                                         ASN1_OCTET_STRING **keyid,
261                                         X509_NAME **issuer, ASN1_INTEGER **sno)
262         {
263         CMS_KeyTransRecipientInfo *ktri;
264         if (ri->type != CMS_RECIPINFO_TRANS)
265                 {
266                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID,
267                         CMS_R_NOT_KEY_TRANSPORT);
268                 return 0;
269                 }
270         ktri = ri->d.ktri;
271
272         return cms_SignerIdentifier_get0_signer_id(ktri->rid,
273                                                         keyid, issuer, sno);
274         }
275
276 int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert)
277         {
278         if (ri->type != CMS_RECIPINFO_TRANS)
279                 {
280                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP,
281                         CMS_R_NOT_KEY_TRANSPORT);
282                 return -2;
283                 }
284         return cms_SignerIdentifier_cert_cmp(ri->d.ktri->rid, cert);
285         }
286
287 int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey)
288         {
289         if (ri->type != CMS_RECIPINFO_TRANS)
290                 {
291                 CMSerr(CMS_F_CMS_RECIPIENTINFO_SET0_PKEY,
292                         CMS_R_NOT_KEY_TRANSPORT);
293                 return 0;
294                 }
295         ri->d.ktri->pkey = pkey;
296         return 1;
297         }
298
299 /* Encrypt content key in key transport recipient info */
300
301 static int cms_RecipientInfo_ktri_encrypt(CMS_ContentInfo *cms,
302                                         CMS_RecipientInfo *ri)
303         {
304         CMS_KeyTransRecipientInfo *ktri;
305         CMS_EncryptedContentInfo *ec;
306         EVP_PKEY_CTX *pctx = NULL;
307         unsigned char *ek = NULL;
308         size_t eklen;
309
310         int ret = 0;
311
312         if (ri->type != CMS_RECIPINFO_TRANS)
313                 {
314                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT,
315                         CMS_R_NOT_KEY_TRANSPORT);
316                 return 0;
317                 }
318         ktri = ri->d.ktri;
319         ec = cms->d.envelopedData->encryptedContentInfo;
320
321         pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
322         if (!pctx)
323                 return 0;
324
325         if (EVP_PKEY_encrypt_init(pctx) <= 0)
326                 goto err;
327
328         if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_ENCRYPT,
329                                 EVP_PKEY_CTRL_CMS_ENCRYPT, 0, ri) <= 0)
330                 {
331                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT, CMS_R_CTRL_ERROR);
332                 goto err;
333                 }
334
335         if (EVP_PKEY_encrypt(pctx, NULL, &eklen, ec->key, ec->keylen) <= 0)
336                 goto err;
337
338         ek = OPENSSL_malloc(eklen);
339
340         if (ek == NULL)
341                 {
342                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT,
343                                                         ERR_R_MALLOC_FAILURE);
344                 goto err;
345                 }
346
347         if (EVP_PKEY_encrypt(pctx, ek, &eklen, ec->key, ec->keylen) <= 0)
348                 goto err;
349
350         ASN1_STRING_set0(ktri->encryptedKey, ek, eklen);
351         ek = NULL;
352
353         ret = 1;
354
355         err:
356         if (pctx)
357                 EVP_PKEY_CTX_free(pctx);
358         if (ek)
359                 OPENSSL_free(ek);
360         return ret;
361
362         }
363
364 /* Decrypt content key from KTRI */
365
366 static int cms_RecipientInfo_ktri_decrypt(CMS_ContentInfo *cms,
367                                                         CMS_RecipientInfo *ri)
368         {
369         CMS_KeyTransRecipientInfo *ktri = ri->d.ktri;
370         EVP_PKEY_CTX *pctx = NULL;
371         unsigned char *ek = NULL;
372         size_t eklen;
373         int ret = 0;
374
375         if (ktri->pkey == NULL)
376                 {
377                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT,
378                         CMS_R_NO_PRIVATE_KEY);
379                 return 0;
380                 }
381
382         pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
383         if (!pctx)
384                 return 0;
385
386         if (EVP_PKEY_decrypt_init(pctx) <= 0)
387                 goto err;
388
389         if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DECRYPT,
390                                 EVP_PKEY_CTRL_CMS_DECRYPT, 0, ri) <= 0)
391                 {
392                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT, CMS_R_CTRL_ERROR);
393                 goto err;
394                 }
395
396         if (EVP_PKEY_decrypt(pctx, NULL, &eklen,
397                                 ktri->encryptedKey->data,
398                                 ktri->encryptedKey->length) <= 0)
399                 goto err;
400
401         ek = OPENSSL_malloc(eklen);
402
403         if (ek == NULL)
404                 {
405                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT,
406                                                         ERR_R_MALLOC_FAILURE);
407                 goto err;
408                 }
409
410         if (EVP_PKEY_decrypt(pctx, ek, &eklen,
411                                 ktri->encryptedKey->data,
412                                 ktri->encryptedKey->length) <= 0)
413                 {
414                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT, CMS_R_CMS_LIB);
415                 goto err;
416                 }
417
418         ret = 1;
419
420         cms->d.envelopedData->encryptedContentInfo->key = ek;
421         cms->d.envelopedData->encryptedContentInfo->keylen = eklen;
422
423         err:
424         if (pctx)
425                 EVP_PKEY_CTX_free(pctx);
426         if (!ret && ek)
427                 OPENSSL_free(ek);
428
429         return ret;
430         }
431
432 /* Key Encrypted Key (KEK) RecipientInfo routines */
433
434 /* For now hard code AES key wrap info */
435
436 static size_t aes_wrap_keylen(int nid)
437         {
438         switch (nid)
439                 {
440                 case NID_id_aes128_wrap:
441                 return 16;
442
443                 case NID_id_aes192_wrap:
444                 return  24;
445
446                 case NID_id_aes256_wrap:
447                 return  32;
448
449                 default:
450                 return 0;
451                 }
452         }
453
454 CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid,
455                                         unsigned char *key, size_t keylen,
456                                         unsigned char *id, size_t idlen,
457                                         ASN1_GENERALIZEDTIME *date,
458                                         ASN1_OBJECT *otherTypeId,
459                                         ASN1_TYPE *otherType)
460         {
461         CMS_RecipientInfo *ri = NULL;
462         CMS_EnvelopedData *env;
463         CMS_KEKRecipientInfo *kekri;
464         env = cms_get0_enveloped(cms);
465         if (!env)
466                 goto err;
467
468         if (nid == NID_undef)
469                 {
470                 switch (keylen)
471                         {
472                         case 16:
473                         nid = NID_id_aes128_wrap;
474                         break;
475
476                         case  24:
477                         nid = NID_id_aes192_wrap;
478                         break;
479
480                         case  32:
481                         nid = NID_id_aes256_wrap;
482                         break;
483
484                         default:
485                         CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY,
486                                                 CMS_R_INVALID_KEY_LENGTH);
487                         goto err;
488                         }
489
490                 }
491         else
492                 {
493
494                 size_t exp_keylen = aes_wrap_keylen(nid);
495
496                 if (!exp_keylen)
497                         {
498                         CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY,
499                                         CMS_R_UNSUPPORTED_KEK_ALGORITHM);
500                         goto err;
501                         }
502
503                 if (keylen != exp_keylen)
504                         {
505                         CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY,
506                                         CMS_R_INVALID_KEY_LENGTH);
507                         goto err;
508                         }
509
510                 }
511
512         /* Initialize recipient info */
513         ri = M_ASN1_new_of(CMS_RecipientInfo);
514         if (!ri)
515                 goto merr;
516
517         ri->d.kekri = M_ASN1_new_of(CMS_KEKRecipientInfo);
518         if (!ri->d.kekri)
519                 goto merr;
520         ri->type = CMS_RECIPINFO_KEK;
521
522         kekri = ri->d.kekri;
523
524         if (otherTypeId)
525                 {
526                 kekri->kekid->other = M_ASN1_new_of(CMS_OtherKeyAttribute);
527                 if (kekri->kekid->other == NULL)
528                         goto merr;
529                 }
530
531         if (!sk_CMS_RecipientInfo_push(env->recipientInfos, ri))
532                 goto merr;
533
534
535         /* After this point no calls can fail */
536
537         kekri->version = 4;
538
539         kekri->key = key;
540         kekri->keylen = keylen;
541
542         ASN1_STRING_set0(kekri->kekid->keyIdentifier, id, idlen);
543
544         kekri->kekid->date = date;
545
546         if (kekri->kekid->other)
547                 {
548                 kekri->kekid->other->keyAttrId = otherTypeId;
549                 kekri->kekid->other->keyAttr = otherType;
550                 }
551
552         X509_ALGOR_set0(kekri->keyEncryptionAlgorithm,
553                                 OBJ_nid2obj(nid), V_ASN1_UNDEF, NULL);
554
555         return ri;
556
557         merr:
558         CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY, ERR_R_MALLOC_FAILURE);
559         err:
560         if (ri)
561                 M_ASN1_free_of(ri, CMS_RecipientInfo);
562         return NULL;
563
564         }
565
566 int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri,
567                                         X509_ALGOR **palg,
568                                         ASN1_OCTET_STRING **pid,
569                                         ASN1_GENERALIZEDTIME **pdate,
570                                         ASN1_OBJECT **potherid,
571                                         ASN1_TYPE **pothertype)
572         {
573         CMS_KEKIdentifier *rkid;
574         if (ri->type != CMS_RECIPINFO_KEK)
575                 {
576                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID, CMS_R_NOT_KEK);
577                 return 0;
578                 }
579         rkid =  ri->d.kekri->kekid;
580         if (palg)
581                 *palg = ri->d.kekri->keyEncryptionAlgorithm;
582         if (pid)
583                 *pid = rkid->keyIdentifier;
584         if (pdate)
585                 *pdate = rkid->date;
586         if (potherid)
587                 {
588                 if (rkid->other)
589                         *potherid = rkid->other->keyAttrId;
590                 else
591                         *potherid = NULL;
592                 }
593         if (pothertype)
594                 {
595                 if (rkid->other)
596                         *pothertype = rkid->other->keyAttr;
597                 else
598                         *pothertype = NULL;
599                 }
600         return 1;
601         }
602
603
604 int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, 
605                                 unsigned char *key, size_t keylen)
606         {
607         CMS_KEKRecipientInfo *kekri;
608         int wrap_nid;
609         if (ri->type != CMS_RECIPINFO_KEK)
610                 {
611                 CMSerr(CMS_F_CMS_RECIPIENTINFO_SET0_KEY, CMS_R_NOT_KEK);
612                 return 0;
613                 }
614         kekri = ri->d.kekri;
615         wrap_nid = OBJ_obj2nid(kekri->keyEncryptionAlgorithm->algorithm);
616         if (aes_wrap_keylen(wrap_nid) != keylen)
617                 {
618                 CMSerr(CMS_F_CMS_RECIPIENTINFO_SET0_KEY,
619                         CMS_R_INVALID_KEY_LENGTH);
620                 return 0;
621                 }
622         kekri->key = key;
623         kekri->keylen = keylen;
624         return 1;
625         }
626
627
628 /* Encrypt content key in KEK recipient info */
629
630 static int cms_RecipientInfo_kekri_encrypt(CMS_ContentInfo *cms,
631                                         CMS_RecipientInfo *ri)
632         {
633         CMS_EncryptedContentInfo *ec;
634         CMS_KEKRecipientInfo *kekri;
635         AES_KEY actx;
636         unsigned char *wkey = NULL;
637         int wkeylen;
638         int r = 0;
639
640         ec = cms->d.envelopedData->encryptedContentInfo;
641
642         kekri = ri->d.kekri;
643
644         if (!kekri->key)
645                 {
646                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, CMS_R_NO_KEY);
647                 return 0;
648                 }
649
650         if (AES_set_encrypt_key(kekri->key, kekri->keylen << 3, &actx))
651                 { 
652                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT,
653                                                 CMS_R_ERROR_SETTING_KEY);
654                 goto err;
655                 }
656
657         wkey = OPENSSL_malloc(ec->keylen + 8);
658
659         if (!wkey)
660                 { 
661                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT,
662                                                 ERR_R_MALLOC_FAILURE);
663                 goto err;
664                 }
665
666         wkeylen = AES_wrap_key(&actx, NULL, wkey, ec->key, ec->keylen);
667
668         if (wkeylen <= 0)
669                 {
670                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, CMS_R_WRAP_ERROR);
671                 goto err;
672                 }
673
674         ASN1_STRING_set0(kekri->encryptedKey, wkey, wkeylen);
675
676         r = 1;
677
678         err:
679
680         if (!r && wkey)
681                 OPENSSL_free(wkey);
682         OPENSSL_cleanse(&actx, sizeof(actx));
683
684         return r;
685
686         }
687
688 /* Decrypt content key in KEK recipient info */
689
690 static int cms_RecipientInfo_kekri_decrypt(CMS_ContentInfo *cms,
691                                         CMS_RecipientInfo *ri)
692         {
693         CMS_EncryptedContentInfo *ec;
694         CMS_KEKRecipientInfo *kekri;
695         AES_KEY actx;
696         unsigned char *ukey = NULL;
697         int ukeylen;
698         int r = 0;
699
700         ec = cms->d.envelopedData->encryptedContentInfo;
701
702         kekri = ri->d.kekri;
703
704         if (!kekri->key)
705                 {
706                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, CMS_R_NO_KEY);
707                 return 0;
708                 }
709
710         /* If encrypted key length is invalid don't bother */
711
712         if (kekri->encryptedKey->length < 16)
713                 { 
714                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT,
715                                         CMS_R_INVALID_ENCRYPTED_KEY_LENGTH);
716                 goto err;
717                 }
718
719         if (AES_set_decrypt_key(kekri->key, kekri->keylen << 3, &actx))
720                 { 
721                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT,
722                                                 CMS_R_ERROR_SETTING_KEY);
723                 goto err;
724                 }
725
726         ukey = OPENSSL_malloc(kekri->encryptedKey->length - 8);
727
728         if (!ukey)
729                 { 
730                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT,
731                                                 ERR_R_MALLOC_FAILURE);
732                 goto err;
733                 }
734
735         ukeylen = AES_unwrap_key(&actx, NULL, ukey,
736                                         kekri->encryptedKey->data,
737                                         kekri->encryptedKey->length);
738
739         if (ukeylen <= 0)
740                 {
741                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT,
742                                                         CMS_R_UNWRAP_ERROR);
743                 goto err;
744                 }
745
746         ec->key = ukey;
747         ec->keylen = ukeylen;
748
749         r = 1;
750
751         err:
752
753         if (!r && ukey)
754                 OPENSSL_free(ukey);
755         OPENSSL_cleanse(&actx, sizeof(actx));
756
757         return r;
758
759         }
760
761 int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri)
762         {
763         switch(ri->type)
764                 {
765                 case CMS_RECIPINFO_TRANS:
766                 return cms_RecipientInfo_ktri_decrypt(cms, ri);
767
768                 case CMS_RECIPINFO_KEK:
769                 return cms_RecipientInfo_kekri_decrypt(cms, ri);
770
771                 default:
772                 CMSerr(CMS_F_CMS_RECIPIENTINFO_DECRYPT,
773                         CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE);
774                 return 0;
775                 }
776         }
777
778 BIO *cms_EnvelopedData_init_bio(CMS_ContentInfo *cms)
779         {
780         CMS_EncryptedContentInfo *ec;
781         STACK_OF(CMS_RecipientInfo) *rinfos;
782         CMS_RecipientInfo *ri;
783         int i, r, ok = 0;
784         BIO *ret;
785
786         /* Get BIO first to set up key */
787
788         ec = cms->d.envelopedData->encryptedContentInfo;
789         ret = cms_EncryptedContent_init_bio(ec);
790
791         /* If error or no cipher end of processing */
792
793         if (!ret || !ec->cipher)
794                 return ret;
795
796         /* Now encrypt content key according to each RecipientInfo type */
797
798         rinfos = cms->d.envelopedData->recipientInfos;
799
800         for (i = 0; i < sk_CMS_RecipientInfo_num(rinfos); i++)
801                 {
802                 ri = sk_CMS_RecipientInfo_value(rinfos, i);
803
804                 switch (ri->type)
805                         {
806                         case CMS_RECIPINFO_TRANS:
807                         r = cms_RecipientInfo_ktri_encrypt(cms, ri);
808                         break;
809
810                         case CMS_RECIPINFO_KEK:
811                         r = cms_RecipientInfo_kekri_encrypt(cms, ri);
812                         break;
813
814                         default:
815                         CMSerr(CMS_F_CMS_ENVELOPEDDATA_INIT_BIO,
816                                 CMS_R_UNSUPPORTED_RECIPIENT_TYPE);
817                         goto err;
818                         }
819
820                 if (r <= 0)
821                         {
822                         CMSerr(CMS_F_CMS_ENVELOPEDDATA_INIT_BIO,
823                                 CMS_R_ERROR_SETTING_RECIPIENTINFO);
824                         goto err;
825                         }
826                 }
827
828         ok = 1;
829
830         err:
831         ec->cipher = NULL;
832         if (ec->key)
833                 {
834                 OPENSSL_cleanse(ec->key, ec->keylen);
835                 OPENSSL_free(ec->key);
836                 ec->key = NULL;
837                 ec->keylen = 0;
838                 }
839         if (ok)
840                 return ret;
841         BIO_free(ret);
842         return NULL;
843
844         }