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 <openssl/local/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 <openssl/local/asn1_locl.h> 64 65/* CMS EnvelopedData Utilities */ 66 67DECLARE_ASN1_ITEM(CMS_EnvelopedData) 68DECLARE_ASN1_ITEM(CMS_RecipientInfo) 69DECLARE_ASN1_ITEM(CMS_KeyTransRecipientInfo) 70DECLARE_ASN1_ITEM(CMS_KEKRecipientInfo) 71DECLARE_ASN1_ITEM(CMS_OtherKeyAttribute) 72 73DECLARE_STACK_OF(CMS_RecipientInfo) 74 75static 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 86static 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 107STACK_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 116int CMS_RecipientInfo_type(CMS_RecipientInfo *ri) 117 { 118 return ri->type; 119 } 120 121CMS_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 148CMS_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 236int 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 259int 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 276int 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 287int 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 301static 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 366static 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 434int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, 435 const unsigned char *id, size_t idlen) 436 { 437 ASN1_OCTET_STRING tmp_os; 438 CMS_KEKRecipientInfo *kekri; 439 if (ri->type != CMS_RECIPINFO_KEK) 440 { 441 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP, CMS_R_NOT_KEK); 442 return -2; 443 } 444 kekri = ri->d.kekri; 445 tmp_os.type = V_ASN1_OCTET_STRING; 446 tmp_os.flags = 0; 447 tmp_os.data = (unsigned char *)id; 448 tmp_os.length = (int)idlen; 449 return ASN1_OCTET_STRING_cmp(&tmp_os, kekri->kekid->keyIdentifier); 450 } 451 452/* For now hard code AES key wrap info */ 453 454static size_t aes_wrap_keylen(int nid) 455 { 456 switch (nid) 457 { 458 case NID_id_aes128_wrap: 459 return 16; 460 461 case NID_id_aes192_wrap: 462 return 24; 463 464 case NID_id_aes256_wrap: 465 return 32; 466 467 default: 468 return 0; 469 } 470 } 471 472CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, 473 unsigned char *key, size_t keylen, 474 unsigned char *id, size_t idlen, 475 ASN1_GENERALIZEDTIME *date, 476 ASN1_OBJECT *otherTypeId, 477 ASN1_TYPE *otherType) 478 { 479 CMS_RecipientInfo *ri = NULL; 480 CMS_EnvelopedData *env; 481 CMS_KEKRecipientInfo *kekri; 482 env = cms_get0_enveloped(cms); 483 if (!env) 484 goto err; 485 486 if (nid == NID_undef) 487 { 488 switch (keylen) 489 { 490 case 16: 491 nid = NID_id_aes128_wrap; 492 break; 493 494 case 24: 495 nid = NID_id_aes192_wrap; 496 break; 497 498 case 32: 499 nid = NID_id_aes256_wrap; 500 break; 501 502 default: 503 CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY, 504 CMS_R_INVALID_KEY_LENGTH); 505 goto err; 506 } 507 508 } 509 else 510 { 511 512 size_t exp_keylen = aes_wrap_keylen(nid); 513 514 if (!exp_keylen) 515 { 516 CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY, 517 CMS_R_UNSUPPORTED_KEK_ALGORITHM); 518 goto err; 519 } 520 521 if (keylen != exp_keylen) 522 { 523 CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY, 524 CMS_R_INVALID_KEY_LENGTH); 525 goto err; 526 } 527 528 } 529 530 /* Initialize recipient info */ 531 ri = M_ASN1_new_of(CMS_RecipientInfo); 532 if (!ri) 533 goto merr; 534 535 ri->d.kekri = M_ASN1_new_of(CMS_KEKRecipientInfo); 536 if (!ri->d.kekri) 537 goto merr; 538 ri->type = CMS_RECIPINFO_KEK; 539 540 kekri = ri->d.kekri; 541 542 if (otherTypeId) 543 { 544 kekri->kekid->other = M_ASN1_new_of(CMS_OtherKeyAttribute); 545 if (kekri->kekid->other == NULL) 546 goto merr; 547 } 548 549 if (!sk_CMS_RecipientInfo_push(env->recipientInfos, ri)) 550 goto merr; 551 552 553 /* After this point no calls can fail */ 554 555 kekri->version = 4; 556 557 kekri->key = key; 558 kekri->keylen = keylen; 559 560 ASN1_STRING_set0(kekri->kekid->keyIdentifier, id, idlen); 561 562 kekri->kekid->date = date; 563 564 if (kekri->kekid->other) 565 { 566 kekri->kekid->other->keyAttrId = otherTypeId; 567 kekri->kekid->other->keyAttr = otherType; 568 } 569 570 X509_ALGOR_set0(kekri->keyEncryptionAlgorithm, 571 OBJ_nid2obj(nid), V_ASN1_UNDEF, NULL); 572 573 return ri; 574 575 merr: 576 CMSerr(CMS_F_CMS_ADD0_RECIPIENT_KEY, ERR_R_MALLOC_FAILURE); 577 err: 578 if (ri) 579 M_ASN1_free_of(ri, CMS_RecipientInfo); 580 return NULL; 581 582 } 583 584int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, 585 X509_ALGOR **palg, 586 ASN1_OCTET_STRING **pid, 587 ASN1_GENERALIZEDTIME **pdate, 588 ASN1_OBJECT **potherid, 589 ASN1_TYPE **pothertype) 590 { 591 CMS_KEKIdentifier *rkid; 592 if (ri->type != CMS_RECIPINFO_KEK) 593 { 594 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID, CMS_R_NOT_KEK); 595 return 0; 596 } 597 rkid = ri->d.kekri->kekid; 598 if (palg) 599 *palg = ri->d.kekri->keyEncryptionAlgorithm; 600 if (pid) 601 *pid = rkid->keyIdentifier; 602 if (pdate) 603 *pdate = rkid->date; 604 if (potherid) 605 { 606 if (rkid->other) 607 *potherid = rkid->other->keyAttrId; 608 else 609 *potherid = NULL; 610 } 611 if (pothertype) 612 { 613 if (rkid->other) 614 *pothertype = rkid->other->keyAttr; 615 else 616 *pothertype = NULL; 617 } 618 return 1; 619 } 620 621int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, 622 unsigned char *key, size_t keylen) 623 { 624 CMS_KEKRecipientInfo *kekri; 625 if (ri->type != CMS_RECIPINFO_KEK) 626 { 627 CMSerr(CMS_F_CMS_RECIPIENTINFO_SET0_KEY, CMS_R_NOT_KEK); 628 return 0; 629 } 630 631 kekri = ri->d.kekri; 632 kekri->key = key; 633 kekri->keylen = keylen; 634 return 1; 635 } 636 637 638/* Encrypt content key in KEK recipient info */ 639 640static int cms_RecipientInfo_kekri_encrypt(CMS_ContentInfo *cms, 641 CMS_RecipientInfo *ri) 642 { 643 CMS_EncryptedContentInfo *ec; 644 CMS_KEKRecipientInfo *kekri; 645 AES_KEY actx; 646 unsigned char *wkey = NULL; 647 int wkeylen; 648 int r = 0; 649 650 ec = cms->d.envelopedData->encryptedContentInfo; 651 652 kekri = ri->d.kekri; 653 654 if (!kekri->key) 655 { 656 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, CMS_R_NO_KEY); 657 return 0; 658 } 659 660 if (AES_set_encrypt_key(kekri->key, kekri->keylen << 3, &actx)) 661 { 662 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, 663 CMS_R_ERROR_SETTING_KEY); 664 goto err; 665 } 666 667 wkey = OPENSSL_malloc(ec->keylen + 8); 668 669 if (!wkey) 670 { 671 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, 672 ERR_R_MALLOC_FAILURE); 673 goto err; 674 } 675 676 wkeylen = AES_wrap_key(&actx, NULL, wkey, ec->key, ec->keylen); 677 678 if (wkeylen <= 0) 679 { 680 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, CMS_R_WRAP_ERROR); 681 goto err; 682 } 683 684 ASN1_STRING_set0(kekri->encryptedKey, wkey, wkeylen); 685 686 r = 1; 687 688 err: 689 690 if (!r && wkey) 691 OPENSSL_free(wkey); 692 OPENSSL_cleanse(&actx, sizeof(actx)); 693 694 return r; 695 696 } 697 698/* Decrypt content key in KEK recipient info */ 699 700static int cms_RecipientInfo_kekri_decrypt(CMS_ContentInfo *cms, 701 CMS_RecipientInfo *ri) 702 { 703 CMS_EncryptedContentInfo *ec; 704 CMS_KEKRecipientInfo *kekri; 705 AES_KEY actx; 706 unsigned char *ukey = NULL; 707 int ukeylen; 708 int r = 0, wrap_nid; 709 710 ec = cms->d.envelopedData->encryptedContentInfo; 711 712 kekri = ri->d.kekri; 713 714 if (!kekri->key) 715 { 716 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, CMS_R_NO_KEY); 717 return 0; 718 } 719 720 wrap_nid = OBJ_obj2nid(kekri->keyEncryptionAlgorithm->algorithm); 721 if (aes_wrap_keylen(wrap_nid) != kekri->keylen) 722 { 723 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, 724 CMS_R_INVALID_KEY_LENGTH); 725 return 0; 726 } 727 728 /* If encrypted key length is invalid don't bother */ 729 730 if (kekri->encryptedKey->length < 16) 731 { 732 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, 733 CMS_R_INVALID_ENCRYPTED_KEY_LENGTH); 734 goto err; 735 } 736 737 if (AES_set_decrypt_key(kekri->key, kekri->keylen << 3, &actx)) 738 { 739 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, 740 CMS_R_ERROR_SETTING_KEY); 741 goto err; 742 } 743 744 ukey = OPENSSL_malloc(kekri->encryptedKey->length - 8); 745 746 if (!ukey) 747 { 748 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, 749 ERR_R_MALLOC_FAILURE); 750 goto err; 751 } 752 753 ukeylen = AES_unwrap_key(&actx, NULL, ukey, 754 kekri->encryptedKey->data, 755 kekri->encryptedKey->length); 756 757 if (ukeylen <= 0) 758 { 759 CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, 760 CMS_R_UNWRAP_ERROR); 761 goto err; 762 } 763 764 ec->key = ukey; 765 ec->keylen = ukeylen; 766 767 r = 1; 768 769 err: 770 771 if (!r && ukey) 772 OPENSSL_free(ukey); 773 OPENSSL_cleanse(&actx, sizeof(actx)); 774 775 return r; 776 777 } 778 779int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri) 780 { 781 switch(ri->type) 782 { 783 case CMS_RECIPINFO_TRANS: 784 return cms_RecipientInfo_ktri_decrypt(cms, ri); 785 786 case CMS_RECIPINFO_KEK: 787 return cms_RecipientInfo_kekri_decrypt(cms, ri); 788 789 default: 790 CMSerr(CMS_F_CMS_RECIPIENTINFO_DECRYPT, 791 CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE); 792 return 0; 793 } 794 } 795 796BIO *cms_EnvelopedData_init_bio(CMS_ContentInfo *cms) 797 { 798 CMS_EncryptedContentInfo *ec; 799 STACK_OF(CMS_RecipientInfo) *rinfos; 800 CMS_RecipientInfo *ri; 801 int i, r, ok = 0; 802 BIO *ret; 803 804 /* Get BIO first to set up key */ 805 806 ec = cms->d.envelopedData->encryptedContentInfo; 807 ret = cms_EncryptedContent_init_bio(ec); 808 809 /* If error or no cipher end of processing */ 810 811 if (!ret || !ec->cipher) 812 return ret; 813 814 /* Now encrypt content key according to each RecipientInfo type */ 815 816 rinfos = cms->d.envelopedData->recipientInfos; 817 818 for (i = 0; i < sk_CMS_RecipientInfo_num(rinfos); i++) 819 { 820 ri = sk_CMS_RecipientInfo_value(rinfos, i); 821 822 switch (ri->type) 823 { 824 case CMS_RECIPINFO_TRANS: 825 r = cms_RecipientInfo_ktri_encrypt(cms, ri); 826 break; 827 828 case CMS_RECIPINFO_KEK: 829 r = cms_RecipientInfo_kekri_encrypt(cms, ri); 830 break; 831 832 default: 833 CMSerr(CMS_F_CMS_ENVELOPEDDATA_INIT_BIO, 834 CMS_R_UNSUPPORTED_RECIPIENT_TYPE); 835 goto err; 836 } 837 838 if (r <= 0) 839 { 840 CMSerr(CMS_F_CMS_ENVELOPEDDATA_INIT_BIO, 841 CMS_R_ERROR_SETTING_RECIPIENTINFO); 842 goto err; 843 } 844 } 845 846 ok = 1; 847 848 err: 849 ec->cipher = NULL; 850 if (ec->key) 851 { 852 OPENSSL_cleanse(ec->key, ec->keylen); 853 OPENSSL_free(ec->key); 854 ec->key = NULL; 855 ec->keylen = 0; 856 } 857 if (ok) 858 return ret; 859 BIO_free(ret); 860 return NULL; 861 862 } 863