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