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