1 /* $OpenBSD: cms_sd.c,v 1.24 2022/08/28 18:27:47 tb Exp $ */ 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 <string.h> 56 57 #include "cryptlib.h" 58 #include <openssl/asn1t.h> 59 #include <openssl/pem.h> 60 #include <openssl/x509.h> 61 #include <openssl/x509v3.h> 62 #include <openssl/err.h> 63 #include <openssl/cms.h> 64 #include "cms_lcl.h" 65 #include "asn1/asn1_locl.h" 66 #include "evp/evp_locl.h" 67 68 /* CMS SignedData Utilities */ 69 70 static CMS_SignedData * 71 cms_get0_signed(CMS_ContentInfo *cms) 72 { 73 if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_signed) { 74 CMSerror(CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA); 75 return NULL; 76 } 77 return cms->d.signedData; 78 } 79 80 static CMS_SignedData * 81 cms_signed_data_init(CMS_ContentInfo *cms) 82 { 83 if (cms->d.other == NULL) { 84 cms->d.signedData = (CMS_SignedData *)ASN1_item_new(&CMS_SignedData_it); 85 if (!cms->d.signedData) { 86 CMSerror(ERR_R_MALLOC_FAILURE); 87 return NULL; 88 } 89 cms->d.signedData->version = 1; 90 cms->d.signedData->encapContentInfo->eContentType = 91 OBJ_nid2obj(NID_pkcs7_data); 92 cms->d.signedData->encapContentInfo->partial = 1; 93 ASN1_OBJECT_free(cms->contentType); 94 cms->contentType = OBJ_nid2obj(NID_pkcs7_signed); 95 return cms->d.signedData; 96 } 97 return cms_get0_signed(cms); 98 } 99 100 /* Just initialise SignedData e.g. for certs only structure */ 101 102 int 103 CMS_SignedData_init(CMS_ContentInfo *cms) 104 { 105 if (cms_signed_data_init(cms)) 106 return 1; 107 else 108 return 0; 109 } 110 111 /* Check structures and fixup version numbers (if necessary) */ 112 113 static void 114 cms_sd_set_version(CMS_SignedData *sd) 115 { 116 int i; 117 CMS_CertificateChoices *cch; 118 CMS_RevocationInfoChoice *rch; 119 CMS_SignerInfo *si; 120 121 for (i = 0; i < sk_CMS_CertificateChoices_num(sd->certificates); i++) { 122 cch = sk_CMS_CertificateChoices_value(sd->certificates, i); 123 if (cch->type == CMS_CERTCHOICE_OTHER) { 124 if (sd->version < 5) 125 sd->version = 5; 126 } else if (cch->type == CMS_CERTCHOICE_V2ACERT) { 127 if (sd->version < 4) 128 sd->version = 4; 129 } else if (cch->type == CMS_CERTCHOICE_V1ACERT) { 130 if (sd->version < 3) 131 sd->version = 3; 132 } 133 } 134 135 for (i = 0; i < sk_CMS_RevocationInfoChoice_num(sd->crls); i++) { 136 rch = sk_CMS_RevocationInfoChoice_value(sd->crls, i); 137 if (rch->type == CMS_REVCHOICE_OTHER) { 138 if (sd->version < 5) 139 sd->version = 5; 140 } 141 } 142 143 if ((OBJ_obj2nid(sd->encapContentInfo->eContentType) != NID_pkcs7_data) 144 && (sd->version < 3)) 145 sd->version = 3; 146 147 for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) { 148 si = sk_CMS_SignerInfo_value(sd->signerInfos, i); 149 if (si->sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) { 150 if (si->version < 3) 151 si->version = 3; 152 if (sd->version < 3) 153 sd->version = 3; 154 } else if (si->version < 1) 155 si->version = 1; 156 } 157 158 if (sd->version < 1) 159 sd->version = 1; 160 } 161 162 /* Copy an existing messageDigest value */ 163 164 static int 165 cms_copy_messageDigest(CMS_ContentInfo *cms, CMS_SignerInfo *si) 166 { 167 STACK_OF(CMS_SignerInfo) *sinfos; 168 CMS_SignerInfo *sitmp; 169 int i; 170 171 sinfos = CMS_get0_SignerInfos(cms); 172 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 173 ASN1_OCTET_STRING *messageDigest; 174 sitmp = sk_CMS_SignerInfo_value(sinfos, i); 175 if (sitmp == si) 176 continue; 177 if (CMS_signed_get_attr_count(sitmp) < 0) 178 continue; 179 if (OBJ_cmp(si->digestAlgorithm->algorithm, 180 sitmp->digestAlgorithm->algorithm)) 181 continue; 182 messageDigest = CMS_signed_get0_data_by_OBJ(sitmp, 183 OBJ_nid2obj(NID_pkcs9_messageDigest), -3, V_ASN1_OCTET_STRING); 184 if (!messageDigest) { 185 CMSerror(CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE); 186 return 0; 187 } 188 189 if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest, 190 V_ASN1_OCTET_STRING, messageDigest, -1)) 191 return 1; 192 else 193 return 0; 194 } 195 196 CMSerror(CMS_R_NO_MATCHING_DIGEST); 197 198 return 0; 199 } 200 201 int 202 cms_set1_SignerIdentifier(CMS_SignerIdentifier *sid, X509 *cert, int type) 203 { 204 switch (type) { 205 case CMS_SIGNERINFO_ISSUER_SERIAL: 206 if (!cms_set1_ias(&sid->d.issuerAndSerialNumber, cert)) 207 return 0; 208 break; 209 210 case CMS_SIGNERINFO_KEYIDENTIFIER: 211 if (!cms_set1_keyid(&sid->d.subjectKeyIdentifier, cert)) 212 return 0; 213 break; 214 215 default: 216 CMSerror(CMS_R_UNKNOWN_ID); 217 return 0; 218 } 219 220 sid->type = type; 221 222 return 1; 223 } 224 225 int 226 cms_SignerIdentifier_get0_signer_id(CMS_SignerIdentifier *sid, 227 ASN1_OCTET_STRING **keyid, X509_NAME **issuer, ASN1_INTEGER **sno) 228 { 229 if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL) { 230 if (issuer) 231 *issuer = sid->d.issuerAndSerialNumber->issuer; 232 if (sno) 233 *sno = sid->d.issuerAndSerialNumber->serialNumber; 234 } else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) { 235 if (keyid) 236 *keyid = sid->d.subjectKeyIdentifier; 237 } else 238 return 0; 239 240 return 1; 241 } 242 243 int 244 cms_SignerIdentifier_cert_cmp(CMS_SignerIdentifier *sid, X509 *cert) 245 { 246 if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL) 247 return cms_ias_cert_cmp(sid->d.issuerAndSerialNumber, cert); 248 else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) 249 return cms_keyid_cert_cmp(sid->d.subjectKeyIdentifier, cert); 250 else 251 return -1; 252 } 253 254 static int 255 cms_sd_asn1_ctrl(CMS_SignerInfo *si, int cmd) 256 { 257 EVP_PKEY *pkey = si->pkey; 258 int i; 259 260 if (!pkey->ameth || !pkey->ameth->pkey_ctrl) 261 return 1; 262 i = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_CMS_SIGN, cmd, si); 263 if (i == -2) { 264 CMSerror(CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE); 265 return 0; 266 } 267 if (i <= 0) { 268 CMSerror(CMS_R_CTRL_FAILURE); 269 return 0; 270 } 271 272 return 1; 273 } 274 275 CMS_SignerInfo * 276 CMS_add1_signer(CMS_ContentInfo *cms, X509 *signer, EVP_PKEY *pk, 277 const EVP_MD *md, unsigned int flags) 278 { 279 CMS_SignedData *sd; 280 CMS_SignerInfo *si = NULL; 281 X509_ALGOR *alg; 282 int i, type; 283 284 if (!X509_check_private_key(signer, pk)) { 285 CMSerror(CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE); 286 return NULL; 287 } 288 sd = cms_signed_data_init(cms); 289 if (!sd) 290 goto err; 291 si = (CMS_SignerInfo *)ASN1_item_new(&CMS_SignerInfo_it); 292 if (!si) 293 goto merr; 294 /* Call for side-effect of computing hash and caching extensions */ 295 X509_check_purpose(signer, -1, -1); 296 297 X509_up_ref(signer); 298 EVP_PKEY_up_ref(pk); 299 300 si->pkey = pk; 301 si->signer = signer; 302 si->mctx = EVP_MD_CTX_new(); 303 si->pctx = NULL; 304 305 if (si->mctx == NULL) { 306 CMSerror(ERR_R_MALLOC_FAILURE); 307 goto err; 308 } 309 310 if (flags & CMS_USE_KEYID) { 311 si->version = 3; 312 if (sd->version < 3) 313 sd->version = 3; 314 type = CMS_SIGNERINFO_KEYIDENTIFIER; 315 } else { 316 type = CMS_SIGNERINFO_ISSUER_SERIAL; 317 si->version = 1; 318 } 319 320 if (!cms_set1_SignerIdentifier(si->sid, signer, type)) 321 goto err; 322 323 if (md == NULL) { 324 int def_nid; 325 if (EVP_PKEY_get_default_digest_nid(pk, &def_nid) <= 0) 326 goto err; 327 md = EVP_get_digestbynid(def_nid); 328 if (md == NULL) { 329 CMSerror(CMS_R_NO_DEFAULT_DIGEST); 330 goto err; 331 } 332 } 333 334 if (!md) { 335 CMSerror(CMS_R_NO_DIGEST_SET); 336 goto err; 337 } 338 339 X509_ALGOR_set_md(si->digestAlgorithm, md); 340 341 /* See if digest is present in digestAlgorithms */ 342 for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) { 343 const ASN1_OBJECT *aoid; 344 alg = sk_X509_ALGOR_value(sd->digestAlgorithms, i); 345 X509_ALGOR_get0(&aoid, NULL, NULL, alg); 346 if (OBJ_obj2nid(aoid) == EVP_MD_type(md)) 347 break; 348 } 349 350 if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) { 351 alg = X509_ALGOR_new(); 352 if (alg == NULL) 353 goto merr; 354 X509_ALGOR_set_md(alg, md); 355 if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) { 356 X509_ALGOR_free(alg); 357 goto merr; 358 } 359 } 360 361 if (!(flags & CMS_KEY_PARAM) && !cms_sd_asn1_ctrl(si, 0)) 362 goto err; 363 if (!(flags & CMS_NOATTR)) { 364 /* 365 * Initialize signed attributes structure so other attributes 366 * such as signing time etc are added later even if we add none here. 367 */ 368 if (!si->signedAttrs) { 369 si->signedAttrs = sk_X509_ATTRIBUTE_new_null(); 370 if (!si->signedAttrs) 371 goto merr; 372 } 373 374 if (!(flags & CMS_NOSMIMECAP)) { 375 STACK_OF(X509_ALGOR) *smcap = NULL; 376 377 i = CMS_add_standard_smimecap(&smcap); 378 if (i) 379 i = CMS_add_smimecap(si, smcap); 380 sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free); 381 if (!i) 382 goto merr; 383 } 384 if (flags & CMS_REUSE_DIGEST) { 385 if (!cms_copy_messageDigest(cms, si)) 386 goto err; 387 if (!(flags & (CMS_PARTIAL | CMS_KEY_PARAM)) && 388 !CMS_SignerInfo_sign(si)) 389 goto err; 390 } 391 } 392 393 if (!(flags & CMS_NOCERTS)) { 394 /* NB ignore -1 return for duplicate cert */ 395 if (!CMS_add1_cert(cms, signer)) 396 goto merr; 397 } 398 399 if (flags & CMS_KEY_PARAM) { 400 if (flags & CMS_NOATTR) { 401 si->pctx = EVP_PKEY_CTX_new(si->pkey, NULL); 402 if (si->pctx == NULL) 403 goto err; 404 if (EVP_PKEY_sign_init(si->pctx) <= 0) 405 goto err; 406 if (EVP_PKEY_CTX_set_signature_md(si->pctx, md) <= 0) 407 goto err; 408 } else if (EVP_DigestSignInit(si->mctx, &si->pctx, md, 409 NULL, pk) <= 0) 410 goto err; 411 } 412 413 if (!sd->signerInfos) 414 sd->signerInfos = sk_CMS_SignerInfo_new_null(); 415 if (!sd->signerInfos || !sk_CMS_SignerInfo_push(sd->signerInfos, si)) 416 goto merr; 417 418 return si; 419 420 merr: 421 CMSerror(ERR_R_MALLOC_FAILURE); 422 err: 423 ASN1_item_free((ASN1_VALUE *)si, &CMS_SignerInfo_it); 424 425 return NULL; 426 } 427 428 static int 429 cms_add1_signingTime(CMS_SignerInfo *si, ASN1_TIME *t) 430 { 431 ASN1_TIME *tt; 432 int r = 0; 433 434 if (t) 435 tt = t; 436 else 437 tt = X509_gmtime_adj(NULL, 0); 438 439 if (!tt) 440 goto merr; 441 442 if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_signingTime, 443 tt->type, tt, -1) <= 0) 444 goto merr; 445 446 r = 1; 447 448 merr: 449 if (!t) 450 ASN1_TIME_free(tt); 451 if (!r) 452 CMSerror(ERR_R_MALLOC_FAILURE); 453 454 return r; 455 } 456 457 EVP_PKEY_CTX * 458 CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si) 459 { 460 return si->pctx; 461 } 462 463 EVP_MD_CTX * 464 CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si) 465 { 466 return si->mctx; 467 } 468 469 STACK_OF(CMS_SignerInfo) * 470 CMS_get0_SignerInfos(CMS_ContentInfo *cms) 471 { 472 CMS_SignedData *sd; 473 474 sd = cms_get0_signed(cms); 475 if (!sd) 476 return NULL; 477 478 return sd->signerInfos; 479 } 480 481 STACK_OF(X509) * 482 CMS_get0_signers(CMS_ContentInfo *cms) 483 { 484 STACK_OF(X509) *signers = NULL; 485 STACK_OF(CMS_SignerInfo) *sinfos; 486 CMS_SignerInfo *si; 487 int i; 488 489 sinfos = CMS_get0_SignerInfos(cms); 490 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 491 si = sk_CMS_SignerInfo_value(sinfos, i); 492 if (si->signer) { 493 if (!signers) { 494 signers = sk_X509_new_null(); 495 if (!signers) 496 return NULL; 497 } 498 if (!sk_X509_push(signers, si->signer)) { 499 sk_X509_free(signers); 500 return NULL; 501 } 502 } 503 } 504 505 return signers; 506 } 507 508 void 509 CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer) 510 { 511 if (signer) { 512 X509_up_ref(signer); 513 EVP_PKEY_free(si->pkey); 514 si->pkey = X509_get_pubkey(signer); 515 } 516 X509_free(si->signer); 517 si->signer = signer; 518 } 519 520 int 521 CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, ASN1_OCTET_STRING **keyid, 522 X509_NAME **issuer, ASN1_INTEGER **sno) 523 { 524 return cms_SignerIdentifier_get0_signer_id(si->sid, keyid, issuer, sno); 525 } 526 527 int 528 CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert) 529 { 530 return cms_SignerIdentifier_cert_cmp(si->sid, cert); 531 } 532 533 int 534 CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *scerts, 535 unsigned int flags) 536 { 537 CMS_SignedData *sd; 538 CMS_SignerInfo *si; 539 CMS_CertificateChoices *cch; 540 STACK_OF(CMS_CertificateChoices) *certs; 541 X509 *x; 542 int i, j; 543 int ret = 0; 544 545 sd = cms_get0_signed(cms); 546 if (!sd) 547 return -1; 548 certs = sd->certificates; 549 for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) { 550 si = sk_CMS_SignerInfo_value(sd->signerInfos, i); 551 if (si->signer) 552 continue; 553 554 for (j = 0; j < sk_X509_num(scerts); j++) { 555 x = sk_X509_value(scerts, j); 556 if (CMS_SignerInfo_cert_cmp(si, x) == 0) { 557 CMS_SignerInfo_set1_signer_cert(si, x); 558 ret++; 559 break; 560 } 561 } 562 563 if (si->signer || (flags & CMS_NOINTERN)) 564 continue; 565 566 for (j = 0; j < sk_CMS_CertificateChoices_num(certs); j++) { 567 cch = sk_CMS_CertificateChoices_value(certs, j); 568 if (cch->type != 0) 569 continue; 570 x = cch->d.certificate; 571 if (CMS_SignerInfo_cert_cmp(si, x) == 0) { 572 CMS_SignerInfo_set1_signer_cert(si, x); 573 ret++; 574 break; 575 } 576 } 577 } 578 return ret; 579 } 580 581 void 582 CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, X509 **signer, 583 X509_ALGOR **pdig, X509_ALGOR **psig) 584 { 585 if (pk) 586 *pk = si->pkey; 587 if (signer) 588 *signer = si->signer; 589 if (pdig) 590 *pdig = si->digestAlgorithm; 591 if (psig) 592 *psig = si->signatureAlgorithm; 593 } 594 595 ASN1_OCTET_STRING * 596 CMS_SignerInfo_get0_signature(CMS_SignerInfo *si) 597 { 598 return si->signature; 599 } 600 601 static int 602 cms_SignerInfo_content_sign(CMS_ContentInfo *cms, CMS_SignerInfo *si, BIO *chain) 603 { 604 EVP_MD_CTX *mctx = EVP_MD_CTX_new(); 605 int r = 0; 606 EVP_PKEY_CTX *pctx = NULL; 607 608 if (mctx == NULL) { 609 CMSerror(ERR_R_MALLOC_FAILURE); 610 return 0; 611 } 612 613 if (!si->pkey) { 614 CMSerror(CMS_R_NO_PRIVATE_KEY); 615 goto err; 616 } 617 618 if (!cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm)) 619 goto err; 620 /* Set SignerInfo algorithm details if we used custom parameter */ 621 if (si->pctx && !cms_sd_asn1_ctrl(si, 0)) 622 goto err; 623 624 /* 625 * If any signed attributes calculate and add messageDigest attribute 626 */ 627 628 if (CMS_signed_get_attr_count(si) >= 0) { 629 ASN1_OBJECT *ctype = 630 cms->d.signedData->encapContentInfo->eContentType; 631 unsigned char md[EVP_MAX_MD_SIZE]; 632 unsigned int mdlen; 633 634 if (!EVP_DigestFinal_ex(mctx, md, &mdlen)) 635 goto err; 636 if (!CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest, 637 V_ASN1_OCTET_STRING, md, mdlen)) 638 goto err; 639 /* Copy content type across */ 640 if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_contentType, 641 V_ASN1_OBJECT, ctype, -1) <= 0) 642 goto err; 643 if (!CMS_SignerInfo_sign(si)) 644 goto err; 645 } else if (si->pctx) { 646 unsigned char *sig; 647 size_t siglen; 648 unsigned char md[EVP_MAX_MD_SIZE]; 649 unsigned int mdlen; 650 651 pctx = si->pctx; 652 if (!EVP_DigestFinal_ex(mctx, md, &mdlen)) 653 goto err; 654 siglen = EVP_PKEY_size(si->pkey); 655 sig = malloc(siglen); 656 if (sig == NULL) { 657 CMSerror(ERR_R_MALLOC_FAILURE); 658 goto err; 659 } 660 if (EVP_PKEY_sign(pctx, sig, &siglen, md, mdlen) <= 0) { 661 free(sig); 662 goto err; 663 } 664 ASN1_STRING_set0(si->signature, sig, siglen); 665 } else { 666 unsigned char *sig; 667 unsigned int siglen; 668 669 sig = malloc(EVP_PKEY_size(si->pkey)); 670 if (sig == NULL) { 671 CMSerror(ERR_R_MALLOC_FAILURE); 672 goto err; 673 } 674 if (!EVP_SignFinal(mctx, sig, &siglen, si->pkey)) { 675 CMSerror(CMS_R_SIGNFINAL_ERROR); 676 free(sig); 677 goto err; 678 } 679 ASN1_STRING_set0(si->signature, sig, siglen); 680 } 681 682 r = 1; 683 684 err: 685 EVP_MD_CTX_free(mctx); 686 EVP_PKEY_CTX_free(pctx); 687 688 return r; 689 } 690 691 int 692 cms_SignedData_final(CMS_ContentInfo *cms, BIO *chain) 693 { 694 STACK_OF(CMS_SignerInfo) *sinfos; 695 CMS_SignerInfo *si; 696 int i; 697 698 sinfos = CMS_get0_SignerInfos(cms); 699 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 700 si = sk_CMS_SignerInfo_value(sinfos, i); 701 if (!cms_SignerInfo_content_sign(cms, si, chain)) 702 return 0; 703 } 704 cms->d.signedData->encapContentInfo->partial = 0; 705 706 return 1; 707 } 708 709 int 710 CMS_SignerInfo_sign(CMS_SignerInfo *si) 711 { 712 EVP_MD_CTX *mctx = si->mctx; 713 EVP_PKEY_CTX *pctx = NULL; 714 unsigned char *abuf = NULL; 715 int alen; 716 size_t siglen; 717 const EVP_MD *md = NULL; 718 719 md = EVP_get_digestbyobj(si->digestAlgorithm->algorithm); 720 if (md == NULL) 721 return 0; 722 723 if (CMS_signed_get_attr_by_NID(si, NID_pkcs9_signingTime, -1) < 0) { 724 if (!cms_add1_signingTime(si, NULL)) 725 goto err; 726 } 727 728 if (si->pctx) 729 pctx = si->pctx; 730 else { 731 EVP_MD_CTX_reset(mctx); 732 if (EVP_DigestSignInit(mctx, &pctx, md, NULL, si->pkey) <= 0) 733 goto err; 734 si->pctx = pctx; 735 } 736 737 if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN, 738 EVP_PKEY_CTRL_CMS_SIGN, 0, si) <= 0) { 739 CMSerror(CMS_R_CTRL_ERROR); 740 goto err; 741 } 742 743 alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf, 744 &CMS_Attributes_Sign_it); 745 if (!abuf) 746 goto err; 747 if (EVP_DigestSignUpdate(mctx, abuf, alen) <= 0) 748 goto err; 749 if (EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) 750 goto err; 751 free(abuf); 752 abuf = malloc(siglen); 753 if (abuf == NULL) 754 goto err; 755 if (EVP_DigestSignFinal(mctx, abuf, &siglen) <= 0) 756 goto err; 757 758 if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN, 759 EVP_PKEY_CTRL_CMS_SIGN, 1, si) <= 0) { 760 CMSerror(CMS_R_CTRL_ERROR); 761 goto err; 762 } 763 764 EVP_MD_CTX_reset(mctx); 765 766 ASN1_STRING_set0(si->signature, abuf, siglen); 767 768 return 1; 769 770 err: 771 free(abuf); 772 EVP_MD_CTX_reset(mctx); 773 774 return 0; 775 } 776 777 int 778 CMS_SignerInfo_verify(CMS_SignerInfo *si) 779 { 780 EVP_MD_CTX *mctx = NULL; 781 unsigned char *abuf = NULL; 782 int alen, r = -1; 783 const EVP_MD *md = NULL; 784 785 if (!si->pkey) { 786 CMSerror(CMS_R_NO_PUBLIC_KEY); 787 return -1; 788 } 789 790 md = EVP_get_digestbyobj(si->digestAlgorithm->algorithm); 791 if (md == NULL) 792 return -1; 793 if (si->mctx == NULL && (si->mctx = EVP_MD_CTX_new()) == NULL) { 794 CMSerror(ERR_R_MALLOC_FAILURE); 795 return -1; 796 } 797 mctx = si->mctx; 798 if (EVP_DigestVerifyInit(mctx, &si->pctx, md, NULL, si->pkey) <= 0) 799 goto err; 800 801 if (!cms_sd_asn1_ctrl(si, 1)) 802 goto err; 803 804 alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf, 805 &CMS_Attributes_Verify_it); 806 if (!abuf) 807 goto err; 808 r = EVP_DigestVerifyUpdate(mctx, abuf, alen); 809 free(abuf); 810 if (r <= 0) { 811 r = -1; 812 goto err; 813 } 814 815 r = EVP_DigestVerifyFinal(mctx, si->signature->data, 816 si->signature->length); 817 if (r <= 0) 818 CMSerror(CMS_R_VERIFICATION_FAILURE); 819 820 err: 821 EVP_MD_CTX_reset(mctx); 822 823 return r; 824 } 825 826 /* Create a chain of digest BIOs from a CMS ContentInfo */ 827 828 BIO * 829 cms_SignedData_init_bio(CMS_ContentInfo *cms) 830 { 831 int i; 832 CMS_SignedData *sd; 833 BIO *chain = NULL; 834 835 sd = cms_get0_signed(cms); 836 if (!sd) 837 return NULL; 838 if (cms->d.signedData->encapContentInfo->partial) 839 cms_sd_set_version(sd); 840 for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) { 841 X509_ALGOR *digestAlgorithm; 842 BIO *mdbio; 843 digestAlgorithm = sk_X509_ALGOR_value(sd->digestAlgorithms, i); 844 mdbio = cms_DigestAlgorithm_init_bio(digestAlgorithm); 845 if (!mdbio) 846 goto err; 847 if (chain) 848 BIO_push(chain, mdbio); 849 else 850 chain = mdbio; 851 } 852 853 return chain; 854 855 err: 856 BIO_free_all(chain); 857 858 return NULL; 859 } 860 861 int 862 CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain) 863 { 864 ASN1_OCTET_STRING *os = NULL; 865 EVP_MD_CTX *mctx = EVP_MD_CTX_new(); 866 EVP_PKEY_CTX *pkctx = NULL; 867 int r = -1; 868 unsigned char mval[EVP_MAX_MD_SIZE]; 869 unsigned int mlen; 870 871 if (mctx == NULL) { 872 CMSerror(ERR_R_MALLOC_FAILURE); 873 goto err; 874 } 875 /* If we have any signed attributes look for messageDigest value */ 876 if (CMS_signed_get_attr_count(si) >= 0) { 877 os = CMS_signed_get0_data_by_OBJ(si, 878 OBJ_nid2obj(NID_pkcs9_messageDigest), -3, 879 V_ASN1_OCTET_STRING); 880 if (!os) { 881 CMSerror(CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE); 882 goto err; 883 } 884 } 885 886 if (!cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm)) 887 goto err; 888 889 if (EVP_DigestFinal_ex(mctx, mval, &mlen) <= 0) { 890 CMSerror(CMS_R_UNABLE_TO_FINALIZE_CONTEXT); 891 goto err; 892 } 893 894 /* If messageDigest found compare it */ 895 896 if (os) { 897 if (mlen != (unsigned int)os->length) { 898 CMSerror(CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH); 899 goto err; 900 } 901 902 if (memcmp(mval, os->data, mlen)) { 903 CMSerror(CMS_R_VERIFICATION_FAILURE); 904 r = 0; 905 } else 906 r = 1; 907 } else { 908 const EVP_MD *md = EVP_MD_CTX_md(mctx); 909 910 pkctx = EVP_PKEY_CTX_new(si->pkey, NULL); 911 if (pkctx == NULL) 912 goto err; 913 if (EVP_PKEY_verify_init(pkctx) <= 0) 914 goto err; 915 if (EVP_PKEY_CTX_set_signature_md(pkctx, md) <= 0) 916 goto err; 917 si->pctx = pkctx; 918 if (!cms_sd_asn1_ctrl(si, 1)) 919 goto err; 920 r = EVP_PKEY_verify(pkctx, si->signature->data, 921 si->signature->length, mval, mlen); 922 if (r <= 0) { 923 CMSerror(CMS_R_VERIFICATION_FAILURE); 924 r = 0; 925 } 926 } 927 928 err: 929 EVP_PKEY_CTX_free(pkctx); 930 EVP_MD_CTX_free(mctx); 931 932 return r; 933 } 934 935 int 936 CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs) 937 { 938 unsigned char *smder = NULL; 939 int smderlen, r; 940 941 smderlen = i2d_X509_ALGORS(algs, &smder); 942 if (smderlen <= 0) 943 return 0; 944 r = CMS_signed_add1_attr_by_NID(si, NID_SMIMECapabilities, 945 V_ASN1_SEQUENCE, smder, smderlen); 946 free(smder); 947 948 return r; 949 } 950 951 int 952 CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, int algnid, int keysize) 953 { 954 X509_ALGOR *alg; 955 ASN1_INTEGER *key = NULL; 956 957 if (keysize > 0) { 958 if ((key = ASN1_INTEGER_new()) == NULL) 959 return 0; 960 if (!ASN1_INTEGER_set(key, keysize)) { 961 ASN1_INTEGER_free(key); 962 return 0; 963 } 964 } 965 alg = X509_ALGOR_new(); 966 if (alg == NULL) { 967 ASN1_INTEGER_free(key); 968 return 0; 969 } 970 971 X509_ALGOR_set0(alg, OBJ_nid2obj(algnid), 972 key ? V_ASN1_INTEGER : V_ASN1_UNDEF, key); 973 if (*algs == NULL) 974 *algs = sk_X509_ALGOR_new_null(); 975 if (*algs == NULL || !sk_X509_ALGOR_push(*algs, alg)) { 976 X509_ALGOR_free(alg); 977 return 0; 978 } 979 980 return 1; 981 } 982 983 /* Check to see if a cipher exists and if so add S/MIME capabilities */ 984 985 static int 986 cms_add_cipher_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg) 987 { 988 if (EVP_get_cipherbynid(nid)) 989 return CMS_add_simple_smimecap(sk, nid, arg); 990 return 1; 991 } 992 993 static int 994 cms_add_digest_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg) 995 { 996 if (EVP_get_digestbynid(nid)) 997 return CMS_add_simple_smimecap(sk, nid, arg); 998 return 1; 999 } 1000 1001 int 1002 CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap) 1003 { 1004 if (!cms_add_cipher_smcap(smcap, NID_aes_256_cbc, -1) || 1005 !cms_add_digest_smcap(smcap, NID_id_GostR3411_94, -1) || 1006 !cms_add_cipher_smcap(smcap, NID_id_Gost28147_89, -1) || 1007 !cms_add_cipher_smcap(smcap, NID_aes_192_cbc, -1) || 1008 !cms_add_cipher_smcap(smcap, NID_aes_128_cbc, -1) || 1009 !cms_add_cipher_smcap(smcap, NID_des_ede3_cbc, -1) || 1010 !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 128) || 1011 !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 64) || 1012 !cms_add_cipher_smcap(smcap, NID_des_cbc, -1) || 1013 !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 40)) 1014 return 0; 1015 1016 return 1; 1017 } 1018