cms_sd.c revision 1.25
1/* $OpenBSD: cms_sd.c,v 1.25 2022/11/26 16:08:51 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_local.h" 65#include "asn1/asn1_local.h" 66#include "evp/evp_local.h" 67 68/* CMS SignedData Utilities */ 69 70static CMS_SignedData * 71cms_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 80static CMS_SignedData * 81cms_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 102int 103CMS_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 113static void 114cms_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 164static int 165cms_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 201int 202cms_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 225int 226cms_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 243int 244cms_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 254static int 255cms_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 275CMS_SignerInfo * 276CMS_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 428static int 429cms_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 457EVP_PKEY_CTX * 458CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si) 459{ 460 return si->pctx; 461} 462 463EVP_MD_CTX * 464CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si) 465{ 466 return si->mctx; 467} 468 469STACK_OF(CMS_SignerInfo) * 470CMS_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 481STACK_OF(X509) * 482CMS_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 508void 509CMS_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 520int 521CMS_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 527int 528CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert) 529{ 530 return cms_SignerIdentifier_cert_cmp(si->sid, cert); 531} 532 533int 534CMS_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 581void 582CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, X509 **signer, 583X509_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 595ASN1_OCTET_STRING * 596CMS_SignerInfo_get0_signature(CMS_SignerInfo *si) 597{ 598 return si->signature; 599} 600 601static int 602cms_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 691int 692cms_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 709int 710CMS_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 777int 778CMS_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 828BIO * 829cms_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 861int 862CMS_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 935int 936CMS_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 951int 952CMS_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 985static int 986cms_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 993static int 994cms_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 1001int 1002CMS_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