1/* 2 * Copyright 2008-2021 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10#include "internal/cryptlib.h" 11#include <openssl/asn1t.h> 12#include <openssl/pem.h> 13#include <openssl/x509.h> 14#include <openssl/x509v3.h> 15#include <openssl/err.h> 16#include <openssl/cms.h> 17#include <openssl/ess.h> 18#include "internal/sizes.h" 19#include "crypto/asn1.h" 20#include "crypto/evp.h" 21#include "crypto/ess.h" 22#include "crypto/x509.h" /* for ossl_x509_add_cert_new() */ 23#include "cms_local.h" 24 25/* CMS SignedData Utilities */ 26 27static CMS_SignedData *cms_get0_signed(CMS_ContentInfo *cms) 28{ 29 if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_signed) { 30 ERR_raise(ERR_LIB_CMS, CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA); 31 return NULL; 32 } 33 return cms->d.signedData; 34} 35 36static CMS_SignedData *cms_signed_data_init(CMS_ContentInfo *cms) 37{ 38 if (cms->d.other == NULL) { 39 cms->d.signedData = M_ASN1_new_of(CMS_SignedData); 40 if (!cms->d.signedData) { 41 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 42 return NULL; 43 } 44 cms->d.signedData->version = 1; 45 cms->d.signedData->encapContentInfo->eContentType = 46 OBJ_nid2obj(NID_pkcs7_data); 47 cms->d.signedData->encapContentInfo->partial = 1; 48 ASN1_OBJECT_free(cms->contentType); 49 cms->contentType = OBJ_nid2obj(NID_pkcs7_signed); 50 return cms->d.signedData; 51 } 52 return cms_get0_signed(cms); 53} 54 55/* Just initialise SignedData e.g. for certs only structure */ 56 57int CMS_SignedData_init(CMS_ContentInfo *cms) 58{ 59 if (cms_signed_data_init(cms)) 60 return 1; 61 else 62 return 0; 63} 64 65 66/* Check structures and fixup version numbers (if necessary) */ 67 68static void cms_sd_set_version(CMS_SignedData *sd) 69{ 70 int i; 71 CMS_CertificateChoices *cch; 72 CMS_RevocationInfoChoice *rch; 73 CMS_SignerInfo *si; 74 75 for (i = 0; i < sk_CMS_CertificateChoices_num(sd->certificates); i++) { 76 cch = sk_CMS_CertificateChoices_value(sd->certificates, i); 77 if (cch->type == CMS_CERTCHOICE_OTHER) { 78 if (sd->version < 5) 79 sd->version = 5; 80 } else if (cch->type == CMS_CERTCHOICE_V2ACERT) { 81 if (sd->version < 4) 82 sd->version = 4; 83 } else if (cch->type == CMS_CERTCHOICE_V1ACERT) { 84 if (sd->version < 3) 85 sd->version = 3; 86 } 87 } 88 89 for (i = 0; i < sk_CMS_RevocationInfoChoice_num(sd->crls); i++) { 90 rch = sk_CMS_RevocationInfoChoice_value(sd->crls, i); 91 if (rch->type == CMS_REVCHOICE_OTHER) { 92 if (sd->version < 5) 93 sd->version = 5; 94 } 95 } 96 97 if ((OBJ_obj2nid(sd->encapContentInfo->eContentType) != NID_pkcs7_data) 98 && (sd->version < 3)) 99 sd->version = 3; 100 101 for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) { 102 si = sk_CMS_SignerInfo_value(sd->signerInfos, i); 103 if (si->sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) { 104 if (si->version < 3) 105 si->version = 3; 106 if (sd->version < 3) 107 sd->version = 3; 108 } else if (si->version < 1) 109 si->version = 1; 110 } 111 112 if (sd->version < 1) 113 sd->version = 1; 114 115} 116 117/* 118 * RFC 5652 Section 11.1 Content Type 119 * The content-type attribute within signed-data MUST 120 * 1) be present if there are signed attributes 121 * 2) match the content type in the signed-data, 122 * 3) be a signed attribute. 123 * 4) not have more than one copy of the attribute. 124 * 125 * Note that since the CMS_SignerInfo_sign() always adds the "signing time" 126 * attribute, the content type attribute MUST be added also. 127 * Assumptions: This assumes that the attribute does not already exist. 128 */ 129static int cms_set_si_contentType_attr(CMS_ContentInfo *cms, CMS_SignerInfo *si) 130{ 131 ASN1_OBJECT *ctype = cms->d.signedData->encapContentInfo->eContentType; 132 133 /* Add the contentType attribute */ 134 return CMS_signed_add1_attr_by_NID(si, NID_pkcs9_contentType, 135 V_ASN1_OBJECT, ctype, -1) > 0; 136} 137 138/* Copy an existing messageDigest value */ 139 140static int cms_copy_messageDigest(CMS_ContentInfo *cms, CMS_SignerInfo *si) 141{ 142 STACK_OF(CMS_SignerInfo) *sinfos; 143 CMS_SignerInfo *sitmp; 144 int i; 145 146 sinfos = CMS_get0_SignerInfos(cms); 147 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 148 ASN1_OCTET_STRING *messageDigest; 149 150 sitmp = sk_CMS_SignerInfo_value(sinfos, i); 151 if (sitmp == si) 152 continue; 153 if (CMS_signed_get_attr_count(sitmp) < 0) 154 continue; 155 if (OBJ_cmp(si->digestAlgorithm->algorithm, 156 sitmp->digestAlgorithm->algorithm)) 157 continue; 158 messageDigest = CMS_signed_get0_data_by_OBJ(sitmp, 159 OBJ_nid2obj 160 (NID_pkcs9_messageDigest), 161 -3, V_ASN1_OCTET_STRING); 162 if (!messageDigest) { 163 ERR_raise(ERR_LIB_CMS, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE); 164 return 0; 165 } 166 167 if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest, 168 V_ASN1_OCTET_STRING, 169 messageDigest, -1)) 170 return 1; 171 else 172 return 0; 173 } 174 ERR_raise(ERR_LIB_CMS, CMS_R_NO_MATCHING_DIGEST); 175 return 0; 176} 177 178int ossl_cms_set1_SignerIdentifier(CMS_SignerIdentifier *sid, X509 *cert, 179 int type, const CMS_CTX *ctx) 180{ 181 switch (type) { 182 case CMS_SIGNERINFO_ISSUER_SERIAL: 183 if (!ossl_cms_set1_ias(&sid->d.issuerAndSerialNumber, cert)) 184 return 0; 185 break; 186 187 case CMS_SIGNERINFO_KEYIDENTIFIER: 188 if (!ossl_cms_set1_keyid(&sid->d.subjectKeyIdentifier, cert)) 189 return 0; 190 break; 191 192 default: 193 ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_ID); 194 return 0; 195 } 196 197 sid->type = type; 198 199 return 1; 200} 201 202int ossl_cms_SignerIdentifier_get0_signer_id(CMS_SignerIdentifier *sid, 203 ASN1_OCTET_STRING **keyid, 204 X509_NAME **issuer, 205 ASN1_INTEGER **sno) 206{ 207 if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL) { 208 if (issuer) 209 *issuer = sid->d.issuerAndSerialNumber->issuer; 210 if (sno) 211 *sno = sid->d.issuerAndSerialNumber->serialNumber; 212 } else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) { 213 if (keyid) 214 *keyid = sid->d.subjectKeyIdentifier; 215 } else 216 return 0; 217 return 1; 218} 219 220int ossl_cms_SignerIdentifier_cert_cmp(CMS_SignerIdentifier *sid, X509 *cert) 221{ 222 if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL) 223 return ossl_cms_ias_cert_cmp(sid->d.issuerAndSerialNumber, cert); 224 else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) 225 return ossl_cms_keyid_cert_cmp(sid->d.subjectKeyIdentifier, cert); 226 else 227 return -1; 228} 229 230static int cms_sd_asn1_ctrl(CMS_SignerInfo *si, int cmd) 231{ 232 EVP_PKEY *pkey = si->pkey; 233 int i; 234 235 if (EVP_PKEY_is_a(pkey, "DSA") || EVP_PKEY_is_a(pkey, "EC")) 236 return ossl_cms_ecdsa_dsa_sign(si, cmd); 237 else if (EVP_PKEY_is_a(pkey, "RSA") || EVP_PKEY_is_a(pkey, "RSA-PSS")) 238 return ossl_cms_rsa_sign(si, cmd); 239 240 /* Something else? We'll give engines etc a chance to handle this */ 241 if (pkey->ameth == NULL || pkey->ameth->pkey_ctrl == NULL) 242 return 1; 243 i = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_CMS_SIGN, cmd, si); 244 if (i == -2) { 245 ERR_raise(ERR_LIB_CMS, CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE); 246 return 0; 247 } 248 if (i <= 0) { 249 ERR_raise(ERR_LIB_CMS, CMS_R_CTRL_FAILURE); 250 return 0; 251 } 252 return 1; 253} 254 255/* Add SigningCertificate signed attribute to the signer info. */ 256static int ossl_cms_add1_signing_cert(CMS_SignerInfo *si, 257 const ESS_SIGNING_CERT *sc) 258{ 259 ASN1_STRING *seq = NULL; 260 unsigned char *p, *pp = NULL; 261 int ret, len = i2d_ESS_SIGNING_CERT(sc, NULL); 262 263 if (len <= 0 || (pp = OPENSSL_malloc(len)) == NULL) 264 return 0; 265 266 p = pp; 267 i2d_ESS_SIGNING_CERT(sc, &p); 268 if (!(seq = ASN1_STRING_new()) || !ASN1_STRING_set(seq, pp, len)) { 269 ASN1_STRING_free(seq); 270 OPENSSL_free(pp); 271 return 0; 272 } 273 OPENSSL_free(pp); 274 ret = CMS_signed_add1_attr_by_NID(si, NID_id_smime_aa_signingCertificate, 275 V_ASN1_SEQUENCE, seq, -1); 276 ASN1_STRING_free(seq); 277 return ret; 278} 279 280/* Add SigningCertificateV2 signed attribute to the signer info. */ 281static int ossl_cms_add1_signing_cert_v2(CMS_SignerInfo *si, 282 const ESS_SIGNING_CERT_V2 *sc) 283{ 284 ASN1_STRING *seq = NULL; 285 unsigned char *p, *pp = NULL; 286 int ret, len = i2d_ESS_SIGNING_CERT_V2(sc, NULL); 287 288 if (len <= 0 || (pp = OPENSSL_malloc(len)) == NULL) 289 return 0; 290 291 p = pp; 292 i2d_ESS_SIGNING_CERT_V2(sc, &p); 293 if (!(seq = ASN1_STRING_new()) || !ASN1_STRING_set(seq, pp, len)) { 294 ASN1_STRING_free(seq); 295 OPENSSL_free(pp); 296 return 0; 297 } 298 OPENSSL_free(pp); 299 ret = CMS_signed_add1_attr_by_NID(si, NID_id_smime_aa_signingCertificateV2, 300 V_ASN1_SEQUENCE, seq, -1); 301 ASN1_STRING_free(seq); 302 return ret; 303} 304 305CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, 306 X509 *signer, EVP_PKEY *pk, const EVP_MD *md, 307 unsigned int flags) 308{ 309 CMS_SignedData *sd; 310 CMS_SignerInfo *si = NULL; 311 X509_ALGOR *alg; 312 int i, type; 313 const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms); 314 315 if (!X509_check_private_key(signer, pk)) { 316 ERR_raise(ERR_LIB_CMS, CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE); 317 return NULL; 318 } 319 sd = cms_signed_data_init(cms); 320 if (!sd) 321 goto err; 322 si = M_ASN1_new_of(CMS_SignerInfo); 323 if (!si) 324 goto merr; 325 /* Call for side-effect of computing hash and caching extensions */ 326 X509_check_purpose(signer, -1, -1); 327 328 X509_up_ref(signer); 329 EVP_PKEY_up_ref(pk); 330 331 si->cms_ctx = ctx; 332 si->pkey = pk; 333 si->signer = signer; 334 si->mctx = EVP_MD_CTX_new(); 335 si->pctx = NULL; 336 337 if (si->mctx == NULL) { 338 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 339 goto err; 340 } 341 342 if (flags & CMS_USE_KEYID) { 343 si->version = 3; 344 if (sd->version < 3) 345 sd->version = 3; 346 type = CMS_SIGNERINFO_KEYIDENTIFIER; 347 } else { 348 type = CMS_SIGNERINFO_ISSUER_SERIAL; 349 si->version = 1; 350 } 351 352 if (!ossl_cms_set1_SignerIdentifier(si->sid, signer, type, ctx)) 353 goto err; 354 355 if (md == NULL) { 356 int def_nid; 357 if (EVP_PKEY_get_default_digest_nid(pk, &def_nid) <= 0) 358 goto err; 359 md = EVP_get_digestbynid(def_nid); 360 if (md == NULL) { 361 ERR_raise(ERR_LIB_CMS, CMS_R_NO_DEFAULT_DIGEST); 362 goto err; 363 } 364 } 365 366 if (!md) { 367 ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET); 368 goto err; 369 } 370 371 if (md == NULL) { 372 ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET); 373 goto err; 374 } 375 376 X509_ALGOR_set_md(si->digestAlgorithm, md); 377 378 /* See if digest is present in digestAlgorithms */ 379 for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) { 380 const ASN1_OBJECT *aoid; 381 char name[OSSL_MAX_NAME_SIZE]; 382 383 alg = sk_X509_ALGOR_value(sd->digestAlgorithms, i); 384 X509_ALGOR_get0(&aoid, NULL, NULL, alg); 385 OBJ_obj2txt(name, sizeof(name), aoid, 0); 386 if (EVP_MD_is_a(md, name)) 387 break; 388 } 389 390 if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) { 391 alg = X509_ALGOR_new(); 392 if (alg == NULL) 393 goto merr; 394 X509_ALGOR_set_md(alg, md); 395 if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) { 396 X509_ALGOR_free(alg); 397 goto merr; 398 } 399 } 400 401 if (!(flags & CMS_KEY_PARAM) && !cms_sd_asn1_ctrl(si, 0)) 402 goto err; 403 if (!(flags & CMS_NOATTR)) { 404 /* 405 * Initialize signed attributes structure so other attributes 406 * such as signing time etc are added later even if we add none here. 407 */ 408 if (!si->signedAttrs) { 409 si->signedAttrs = sk_X509_ATTRIBUTE_new_null(); 410 if (!si->signedAttrs) 411 goto merr; 412 } 413 414 if (!(flags & CMS_NOSMIMECAP)) { 415 STACK_OF(X509_ALGOR) *smcap = NULL; 416 i = CMS_add_standard_smimecap(&smcap); 417 if (i) 418 i = CMS_add_smimecap(si, smcap); 419 sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free); 420 if (!i) 421 goto merr; 422 } 423 if (flags & CMS_CADES) { 424 ESS_SIGNING_CERT *sc = NULL; 425 ESS_SIGNING_CERT_V2 *sc2 = NULL; 426 int add_sc; 427 428 if (md == NULL || EVP_MD_is_a(md, SN_sha1)) { 429 if ((sc = OSSL_ESS_signing_cert_new_init(signer, 430 NULL, 1)) == NULL) 431 goto err; 432 add_sc = ossl_cms_add1_signing_cert(si, sc); 433 ESS_SIGNING_CERT_free(sc); 434 } else { 435 if ((sc2 = OSSL_ESS_signing_cert_v2_new_init(md, signer, 436 NULL, 1)) == NULL) 437 goto err; 438 add_sc = ossl_cms_add1_signing_cert_v2(si, sc2); 439 ESS_SIGNING_CERT_V2_free(sc2); 440 } 441 if (!add_sc) 442 goto err; 443 } 444 if (flags & CMS_REUSE_DIGEST) { 445 if (!cms_copy_messageDigest(cms, si)) 446 goto err; 447 if (!cms_set_si_contentType_attr(cms, si)) 448 goto err; 449 if (!(flags & (CMS_PARTIAL | CMS_KEY_PARAM)) && 450 !CMS_SignerInfo_sign(si)) 451 goto err; 452 } 453 } 454 455 if (!(flags & CMS_NOCERTS)) { 456 /* NB ignore -1 return for duplicate cert */ 457 if (!CMS_add1_cert(cms, signer)) 458 goto merr; 459 } 460 461 if (flags & CMS_KEY_PARAM) { 462 if (flags & CMS_NOATTR) { 463 si->pctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx), 464 si->pkey, 465 ossl_cms_ctx_get0_propq(ctx)); 466 if (si->pctx == NULL) 467 goto err; 468 if (EVP_PKEY_sign_init(si->pctx) <= 0) 469 goto err; 470 if (EVP_PKEY_CTX_set_signature_md(si->pctx, md) <= 0) 471 goto err; 472 } else if (EVP_DigestSignInit_ex(si->mctx, &si->pctx, 473 EVP_MD_get0_name(md), 474 ossl_cms_ctx_get0_libctx(ctx), 475 ossl_cms_ctx_get0_propq(ctx), 476 pk, NULL) <= 0) { 477 si->pctx = NULL; 478 goto err; 479 } 480 else { 481 EVP_MD_CTX_set_flags(si->mctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX); 482 } 483 } 484 485 if (!sd->signerInfos) 486 sd->signerInfos = sk_CMS_SignerInfo_new_null(); 487 if (!sd->signerInfos || !sk_CMS_SignerInfo_push(sd->signerInfos, si)) 488 goto merr; 489 490 return si; 491 492 merr: 493 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 494 err: 495 M_ASN1_free_of(si, CMS_SignerInfo); 496 return NULL; 497 498} 499 500void ossl_cms_SignerInfos_set_cmsctx(CMS_ContentInfo *cms) 501{ 502 int i; 503 CMS_SignerInfo *si; 504 STACK_OF(CMS_SignerInfo) *sinfos; 505 const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms); 506 507 ERR_set_mark(); 508 sinfos = CMS_get0_SignerInfos(cms); 509 ERR_pop_to_mark(); /* removes error in case sinfos == NULL */ 510 511 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 512 si = sk_CMS_SignerInfo_value(sinfos, i); 513 if (si != NULL) 514 si->cms_ctx = ctx; 515 } 516} 517 518static int cms_add1_signingTime(CMS_SignerInfo *si, ASN1_TIME *t) 519{ 520 ASN1_TIME *tt; 521 int r = 0; 522 523 if (t != NULL) 524 tt = t; 525 else 526 tt = X509_gmtime_adj(NULL, 0); 527 528 if (tt == NULL) 529 goto merr; 530 531 if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_signingTime, 532 tt->type, tt, -1) <= 0) 533 goto merr; 534 535 r = 1; 536 merr: 537 if (t == NULL) 538 ASN1_TIME_free(tt); 539 540 if (!r) 541 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 542 543 return r; 544 545} 546 547EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si) 548{ 549 return si->pctx; 550} 551 552EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si) 553{ 554 return si->mctx; 555} 556 557STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms) 558{ 559 CMS_SignedData *sd = cms_get0_signed(cms); 560 561 return sd != NULL ? sd->signerInfos : NULL; 562} 563 564STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms) 565{ 566 STACK_OF(X509) *signers = NULL; 567 STACK_OF(CMS_SignerInfo) *sinfos; 568 CMS_SignerInfo *si; 569 int i; 570 571 sinfos = CMS_get0_SignerInfos(cms); 572 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 573 si = sk_CMS_SignerInfo_value(sinfos, i); 574 if (si->signer != NULL) { 575 if (!ossl_x509_add_cert_new(&signers, si->signer, 576 X509_ADD_FLAG_DEFAULT)) { 577 sk_X509_free(signers); 578 return NULL; 579 } 580 } 581 } 582 return signers; 583} 584 585void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer) 586{ 587 if (signer != NULL) { 588 X509_up_ref(signer); 589 EVP_PKEY_free(si->pkey); 590 si->pkey = X509_get_pubkey(signer); 591 } 592 X509_free(si->signer); 593 si->signer = signer; 594} 595 596int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, 597 ASN1_OCTET_STRING **keyid, 598 X509_NAME **issuer, ASN1_INTEGER **sno) 599{ 600 return ossl_cms_SignerIdentifier_get0_signer_id(si->sid, keyid, issuer, sno); 601} 602 603int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert) 604{ 605 return ossl_cms_SignerIdentifier_cert_cmp(si->sid, cert); 606} 607 608int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *scerts, 609 unsigned int flags) 610{ 611 CMS_SignedData *sd; 612 CMS_SignerInfo *si; 613 CMS_CertificateChoices *cch; 614 STACK_OF(CMS_CertificateChoices) *certs; 615 X509 *x; 616 int i, j; 617 int ret = 0; 618 619 sd = cms_get0_signed(cms); 620 if (sd == NULL) 621 return -1; 622 certs = sd->certificates; 623 for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) { 624 si = sk_CMS_SignerInfo_value(sd->signerInfos, i); 625 if (si->signer != NULL) 626 continue; 627 628 for (j = 0; j < sk_X509_num(scerts); j++) { 629 x = sk_X509_value(scerts, j); 630 if (CMS_SignerInfo_cert_cmp(si, x) == 0) { 631 CMS_SignerInfo_set1_signer_cert(si, x); 632 ret++; 633 break; 634 } 635 } 636 637 if (si->signer != NULL || (flags & CMS_NOINTERN)) 638 continue; 639 640 for (j = 0; j < sk_CMS_CertificateChoices_num(certs); j++) { 641 cch = sk_CMS_CertificateChoices_value(certs, j); 642 if (cch->type != 0) 643 continue; 644 x = cch->d.certificate; 645 if (CMS_SignerInfo_cert_cmp(si, x) == 0) { 646 CMS_SignerInfo_set1_signer_cert(si, x); 647 ret++; 648 break; 649 } 650 } 651 } 652 return ret; 653} 654 655void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, 656 X509 **signer, X509_ALGOR **pdig, 657 X509_ALGOR **psig) 658{ 659 if (pk != NULL) 660 *pk = si->pkey; 661 if (signer != NULL) 662 *signer = si->signer; 663 if (pdig != NULL) 664 *pdig = si->digestAlgorithm; 665 if (psig != NULL) 666 *psig = si->signatureAlgorithm; 667} 668 669ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si) 670{ 671 return si->signature; 672} 673 674static int cms_SignerInfo_content_sign(CMS_ContentInfo *cms, 675 CMS_SignerInfo *si, BIO *chain) 676{ 677 EVP_MD_CTX *mctx = EVP_MD_CTX_new(); 678 int r = 0; 679 EVP_PKEY_CTX *pctx = NULL; 680 const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms); 681 682 if (mctx == NULL) { 683 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 684 return 0; 685 } 686 687 if (si->pkey == NULL) { 688 ERR_raise(ERR_LIB_CMS, CMS_R_NO_PRIVATE_KEY); 689 goto err; 690 } 691 692 if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm)) 693 goto err; 694 /* Set SignerInfo algorithm details if we used custom parameter */ 695 if (si->pctx && !cms_sd_asn1_ctrl(si, 0)) 696 goto err; 697 698 /* 699 * If any signed attributes calculate and add messageDigest attribute 700 */ 701 702 if (CMS_signed_get_attr_count(si) >= 0) { 703 unsigned char md[EVP_MAX_MD_SIZE]; 704 unsigned int mdlen; 705 706 if (!EVP_DigestFinal_ex(mctx, md, &mdlen)) 707 goto err; 708 if (!CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest, 709 V_ASN1_OCTET_STRING, md, mdlen)) 710 goto err; 711 /* Copy content type across */ 712 if (!cms_set_si_contentType_attr(cms, si)) 713 goto err; 714 715 if (!CMS_SignerInfo_sign(si)) 716 goto err; 717 } else if (si->pctx) { 718 unsigned char *sig; 719 size_t siglen; 720 unsigned char md[EVP_MAX_MD_SIZE]; 721 unsigned int mdlen; 722 723 pctx = si->pctx; 724 si->pctx = NULL; 725 if (!EVP_DigestFinal_ex(mctx, md, &mdlen)) 726 goto err; 727 siglen = EVP_PKEY_get_size(si->pkey); 728 sig = OPENSSL_malloc(siglen); 729 if (sig == NULL) { 730 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 731 goto err; 732 } 733 if (EVP_PKEY_sign(pctx, sig, &siglen, md, mdlen) <= 0) { 734 OPENSSL_free(sig); 735 goto err; 736 } 737 ASN1_STRING_set0(si->signature, sig, siglen); 738 } else { 739 unsigned char *sig; 740 unsigned int siglen; 741 742 sig = OPENSSL_malloc(EVP_PKEY_get_size(si->pkey)); 743 if (sig == NULL) { 744 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 745 goto err; 746 } 747 if (!EVP_SignFinal_ex(mctx, sig, &siglen, si->pkey, 748 ossl_cms_ctx_get0_libctx(ctx), 749 ossl_cms_ctx_get0_propq(ctx))) { 750 ERR_raise(ERR_LIB_CMS, CMS_R_SIGNFINAL_ERROR); 751 OPENSSL_free(sig); 752 goto err; 753 } 754 ASN1_STRING_set0(si->signature, sig, siglen); 755 } 756 757 r = 1; 758 759 err: 760 EVP_MD_CTX_free(mctx); 761 EVP_PKEY_CTX_free(pctx); 762 return r; 763 764} 765 766int ossl_cms_SignedData_final(CMS_ContentInfo *cms, BIO *chain) 767{ 768 STACK_OF(CMS_SignerInfo) *sinfos; 769 CMS_SignerInfo *si; 770 int i; 771 772 sinfos = CMS_get0_SignerInfos(cms); 773 for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) { 774 si = sk_CMS_SignerInfo_value(sinfos, i); 775 if (!cms_SignerInfo_content_sign(cms, si, chain)) 776 return 0; 777 } 778 cms->d.signedData->encapContentInfo->partial = 0; 779 return 1; 780} 781 782int CMS_SignerInfo_sign(CMS_SignerInfo *si) 783{ 784 EVP_MD_CTX *mctx = si->mctx; 785 EVP_PKEY_CTX *pctx = NULL; 786 unsigned char *abuf = NULL; 787 int alen; 788 size_t siglen; 789 const CMS_CTX *ctx = si->cms_ctx; 790 char md_name[OSSL_MAX_NAME_SIZE]; 791 792 if (OBJ_obj2txt(md_name, sizeof(md_name), 793 si->digestAlgorithm->algorithm, 0) <= 0) 794 return 0; 795 796 if (CMS_signed_get_attr_by_NID(si, NID_pkcs9_signingTime, -1) < 0) { 797 if (!cms_add1_signingTime(si, NULL)) 798 goto err; 799 } 800 801 if (!ossl_cms_si_check_attributes(si)) 802 goto err; 803 804 if (si->pctx) 805 pctx = si->pctx; 806 else { 807 EVP_MD_CTX_reset(mctx); 808 if (EVP_DigestSignInit_ex(mctx, &pctx, md_name, 809 ossl_cms_ctx_get0_libctx(ctx), 810 ossl_cms_ctx_get0_propq(ctx), si->pkey, 811 NULL) <= 0) 812 goto err; 813 EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX); 814 si->pctx = pctx; 815 } 816 817 alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf, 818 ASN1_ITEM_rptr(CMS_Attributes_Sign)); 819 if (!abuf) 820 goto err; 821 if (EVP_DigestSignUpdate(mctx, abuf, alen) <= 0) 822 goto err; 823 if (EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) 824 goto err; 825 OPENSSL_free(abuf); 826 abuf = OPENSSL_malloc(siglen); 827 if (abuf == NULL) 828 goto err; 829 if (EVP_DigestSignFinal(mctx, abuf, &siglen) <= 0) 830 goto err; 831 832 EVP_MD_CTX_reset(mctx); 833 834 ASN1_STRING_set0(si->signature, abuf, siglen); 835 836 return 1; 837 838 err: 839 OPENSSL_free(abuf); 840 EVP_MD_CTX_reset(mctx); 841 return 0; 842} 843 844int CMS_SignerInfo_verify(CMS_SignerInfo *si) 845{ 846 EVP_MD_CTX *mctx = NULL; 847 unsigned char *abuf = NULL; 848 int alen, r = -1; 849 char name[OSSL_MAX_NAME_SIZE]; 850 const EVP_MD *md; 851 EVP_MD *fetched_md = NULL; 852 const CMS_CTX *ctx = si->cms_ctx; 853 OSSL_LIB_CTX *libctx = ossl_cms_ctx_get0_libctx(ctx); 854 const char *propq = ossl_cms_ctx_get0_propq(ctx); 855 856 if (si->pkey == NULL) { 857 ERR_raise(ERR_LIB_CMS, CMS_R_NO_PUBLIC_KEY); 858 return -1; 859 } 860 861 if (!ossl_cms_si_check_attributes(si)) 862 return -1; 863 864 OBJ_obj2txt(name, sizeof(name), si->digestAlgorithm->algorithm, 0); 865 866 (void)ERR_set_mark(); 867 fetched_md = EVP_MD_fetch(libctx, name, propq); 868 869 if (fetched_md != NULL) 870 md = fetched_md; 871 else 872 md = EVP_get_digestbyobj(si->digestAlgorithm->algorithm); 873 if (md == NULL) { 874 (void)ERR_clear_last_mark(); 875 ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_DIGEST_ALGORITHM); 876 return -1; 877 } 878 (void)ERR_pop_to_mark(); 879 880 if (si->mctx == NULL && (si->mctx = EVP_MD_CTX_new()) == NULL) { 881 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 882 goto err; 883 } 884 mctx = si->mctx; 885 if (si->pctx != NULL) { 886 EVP_PKEY_CTX_free(si->pctx); 887 si->pctx = NULL; 888 } 889 if (EVP_DigestVerifyInit_ex(mctx, &si->pctx, EVP_MD_get0_name(md), libctx, 890 propq, si->pkey, NULL) <= 0) { 891 si->pctx = NULL; 892 goto err; 893 } 894 EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX); 895 896 if (!cms_sd_asn1_ctrl(si, 1)) 897 goto err; 898 899 alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf, 900 ASN1_ITEM_rptr(CMS_Attributes_Verify)); 901 if (abuf == NULL || alen < 0) 902 goto err; 903 r = EVP_DigestVerifyUpdate(mctx, abuf, alen); 904 OPENSSL_free(abuf); 905 if (r <= 0) { 906 r = -1; 907 goto err; 908 } 909 r = EVP_DigestVerifyFinal(mctx, 910 si->signature->data, si->signature->length); 911 if (r <= 0) 912 ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE); 913 err: 914 EVP_MD_free(fetched_md); 915 EVP_MD_CTX_reset(mctx); 916 return r; 917} 918 919/* Create a chain of digest BIOs from a CMS ContentInfo */ 920 921BIO *ossl_cms_SignedData_init_bio(CMS_ContentInfo *cms) 922{ 923 int i; 924 CMS_SignedData *sd; 925 BIO *chain = NULL; 926 927 sd = cms_get0_signed(cms); 928 if (sd == NULL) 929 return NULL; 930 if (cms->d.signedData->encapContentInfo->partial) 931 cms_sd_set_version(sd); 932 for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) { 933 X509_ALGOR *digestAlgorithm; 934 BIO *mdbio; 935 936 digestAlgorithm = sk_X509_ALGOR_value(sd->digestAlgorithms, i); 937 mdbio = ossl_cms_DigestAlgorithm_init_bio(digestAlgorithm, 938 ossl_cms_get0_cmsctx(cms)); 939 if (mdbio == NULL) 940 goto err; 941 if (chain != NULL) 942 BIO_push(chain, mdbio); 943 else 944 chain = mdbio; 945 } 946 return chain; 947 err: 948 BIO_free_all(chain); 949 return NULL; 950} 951 952int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain) 953{ 954 ASN1_OCTET_STRING *os = NULL; 955 EVP_MD_CTX *mctx = EVP_MD_CTX_new(); 956 EVP_PKEY_CTX *pkctx = NULL; 957 int r = -1; 958 unsigned char mval[EVP_MAX_MD_SIZE]; 959 unsigned int mlen; 960 961 if (mctx == NULL) { 962 ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE); 963 goto err; 964 } 965 /* If we have any signed attributes look for messageDigest value */ 966 if (CMS_signed_get_attr_count(si) >= 0) { 967 os = CMS_signed_get0_data_by_OBJ(si, 968 OBJ_nid2obj(NID_pkcs9_messageDigest), 969 -3, V_ASN1_OCTET_STRING); 970 if (os == NULL) { 971 ERR_raise(ERR_LIB_CMS, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE); 972 goto err; 973 } 974 } 975 976 if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm)) 977 goto err; 978 979 if (EVP_DigestFinal_ex(mctx, mval, &mlen) <= 0) { 980 ERR_raise(ERR_LIB_CMS, CMS_R_UNABLE_TO_FINALIZE_CONTEXT); 981 goto err; 982 } 983 984 /* If messageDigest found compare it */ 985 986 if (os != NULL) { 987 if (mlen != (unsigned int)os->length) { 988 ERR_raise(ERR_LIB_CMS, CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH); 989 goto err; 990 } 991 992 if (memcmp(mval, os->data, mlen)) { 993 ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE); 994 r = 0; 995 } else 996 r = 1; 997 } else { 998 const EVP_MD *md = EVP_MD_CTX_get0_md(mctx); 999 const CMS_CTX *ctx = si->cms_ctx; 1000 1001 pkctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx), 1002 si->pkey, 1003 ossl_cms_ctx_get0_propq(ctx)); 1004 if (pkctx == NULL) 1005 goto err; 1006 if (EVP_PKEY_verify_init(pkctx) <= 0) 1007 goto err; 1008 if (EVP_PKEY_CTX_set_signature_md(pkctx, md) <= 0) 1009 goto err; 1010 si->pctx = pkctx; 1011 if (!cms_sd_asn1_ctrl(si, 1)) { 1012 si->pctx = NULL; 1013 goto err; 1014 } 1015 si->pctx = NULL; 1016 r = EVP_PKEY_verify(pkctx, si->signature->data, 1017 si->signature->length, mval, mlen); 1018 if (r <= 0) { 1019 ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE); 1020 r = 0; 1021 } 1022 } 1023 1024 err: 1025 EVP_PKEY_CTX_free(pkctx); 1026 EVP_MD_CTX_free(mctx); 1027 return r; 1028 1029} 1030 1031int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs) 1032{ 1033 unsigned char *smder = NULL; 1034 int smderlen, r; 1035 1036 smderlen = i2d_X509_ALGORS(algs, &smder); 1037 if (smderlen <= 0) 1038 return 0; 1039 r = CMS_signed_add1_attr_by_NID(si, NID_SMIMECapabilities, 1040 V_ASN1_SEQUENCE, smder, smderlen); 1041 OPENSSL_free(smder); 1042 return r; 1043} 1044 1045int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, 1046 int algnid, int keysize) 1047{ 1048 X509_ALGOR *alg = NULL; 1049 ASN1_INTEGER *key = NULL; 1050 1051 if (keysize > 0) { 1052 key = ASN1_INTEGER_new(); 1053 if (key == NULL || !ASN1_INTEGER_set(key, keysize)) 1054 goto err; 1055 } 1056 alg = X509_ALGOR_new(); 1057 if (alg == NULL) 1058 goto err; 1059 1060 if (!X509_ALGOR_set0(alg, OBJ_nid2obj(algnid), 1061 key ? V_ASN1_INTEGER : V_ASN1_UNDEF, key)) 1062 goto err; 1063 key = NULL; 1064 if (*algs == NULL) 1065 *algs = sk_X509_ALGOR_new_null(); 1066 if (*algs == NULL || !sk_X509_ALGOR_push(*algs, alg)) 1067 goto err; 1068 return 1; 1069 1070 err: 1071 ASN1_INTEGER_free(key); 1072 X509_ALGOR_free(alg); 1073 return 0; 1074} 1075 1076/* Check to see if a cipher exists and if so add S/MIME capabilities */ 1077 1078static int cms_add_cipher_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg) 1079{ 1080 if (EVP_get_cipherbynid(nid)) 1081 return CMS_add_simple_smimecap(sk, nid, arg); 1082 return 1; 1083} 1084 1085static int cms_add_digest_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg) 1086{ 1087 if (EVP_get_digestbynid(nid)) 1088 return CMS_add_simple_smimecap(sk, nid, arg); 1089 return 1; 1090} 1091 1092int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap) 1093{ 1094 if (!cms_add_cipher_smcap(smcap, NID_aes_256_cbc, -1) 1095 || !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_256, -1) 1096 || !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_512, -1) 1097 || !cms_add_digest_smcap(smcap, NID_id_GostR3411_94, -1) 1098 || !cms_add_cipher_smcap(smcap, NID_id_Gost28147_89, -1) 1099 || !cms_add_cipher_smcap(smcap, NID_aes_192_cbc, -1) 1100 || !cms_add_cipher_smcap(smcap, NID_aes_128_cbc, -1) 1101 || !cms_add_cipher_smcap(smcap, NID_des_ede3_cbc, -1) 1102 || !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 128) 1103 || !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 64) 1104 || !cms_add_cipher_smcap(smcap, NID_des_cbc, -1) 1105 || !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 40)) 1106 return 0; 1107 return 1; 1108} 1109