crypto/cms/cms_lib.c

   1 /*
   2  * Copyright 2008-2020 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 <openssl/asn1t.h>
  11 #include <openssl/x509v3.h>
  12 #include <openssl/err.h>
  13 #include <openssl/pem.h>
  14 #include <openssl/bio.h>
  15 #include <openssl/asn1.h>
  16 #include <openssl/cms.h>
  17 #include <openssl/cms.h>
  18 #include "crypto/x509.h"
  19 #include "cms_local.h"
  20
  21 static STACK_OF(CMS_CertificateChoices)
  22 **cms_get0_certificate_choices(CMS_ContentInfo *cms);
  23
  24 DEFINE_STACK_OF(CMS_RevocationInfoChoice)
  25
  26 IMPLEMENT_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
  27
  28 CMS_ContentInfo *d2i_CMS_ContentInfo(CMS_ContentInfo **a,
  29                                      const unsigned char **in, long len)
  30 {
  31     CMS_ContentInfo *ci;
  32
  33     ci = (CMS_ContentInfo *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
  34                                           (CMS_ContentInfo_it()));
  35     if (ci != NULL && a != NULL)
  36         cms_resolve_libctx(ci);
  37     return ci;
  38 }
  39
  40 int i2d_CMS_ContentInfo(const CMS_ContentInfo *a, unsigned char **out)
  41 {
  42     return ASN1_item_i2d((const ASN1_VALUE *)a, out, (CMS_ContentInfo_it()));
  43 }
  44
  45 CMS_ContentInfo *CMS_ContentInfo_new_with_libctx(OPENSSL_CTX *libctx,
  46                                                  const char *propq)
  47 {
  48     CMS_ContentInfo *ci;
  49
  50     ci = (CMS_ContentInfo *)ASN1_item_new(ASN1_ITEM_rptr(CMS_ContentInfo));
  51     if (ci != NULL) {
  52         ci->ctx.libctx = libctx;
  53         ci->ctx.propq = NULL;
  54         if (propq != NULL) {
  55             ci->ctx.propq = OPENSSL_strdup(propq);
  56             if (ci->ctx.propq == NULL) {
  57                 CMS_ContentInfo_free(ci);
  58                 ci = NULL;
  59                 ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
  60             }
  61         }
  62     }
  63     return ci;
  64 }
  65
  66 CMS_ContentInfo *CMS_ContentInfo_new(void)
  67 {
  68     return CMS_ContentInfo_new_with_libctx(NULL, NULL);
  69 }
  70
  71 void CMS_ContentInfo_free(CMS_ContentInfo *cms)
  72 {
  73     if (cms != NULL) {
  74         OPENSSL_free(cms->ctx.propq);
  75         ASN1_item_free((ASN1_VALUE *)cms, ASN1_ITEM_rptr(CMS_ContentInfo));
  76     }
  77 }
  78
  79 const CMS_CTX *cms_get0_cmsctx(const CMS_ContentInfo *cms)
  80 {
  81     return cms != NULL ? &cms->ctx : NULL;
  82 }
  83
  84 OPENSSL_CTX *cms_ctx_get0_libctx(const CMS_CTX *ctx)
  85 {
  86     return ctx->libctx;
  87 }
  88
  89 const char *cms_ctx_get0_propq(const CMS_CTX *ctx)
  90 {
  91     return ctx->propq;
  92 }
  93
  94 void cms_resolve_libctx(CMS_ContentInfo *ci)
  95 {
  96     int i;
  97     CMS_CertificateChoices *cch;
  98     STACK_OF(CMS_CertificateChoices) **pcerts;
  99     const CMS_CTX *ctx;
 100
 101     if (ci == NULL)
 102         return;
 103
 104     ctx = cms_get0_cmsctx(ci);
 105     cms_SignerInfos_set_cmsctx(ci);
 106     cms_RecipientInfos_set_cmsctx(ci);
 107
 108     pcerts = cms_get0_certificate_choices(ci);
 109     if (pcerts != NULL) {
 110         for (i = 0; i < sk_CMS_CertificateChoices_num(*pcerts); i++) {
 111             cch = sk_CMS_CertificateChoices_value(*pcerts, i);
 112             if (cch->type == CMS_CERTCHOICE_CERT)
 113                 x509_set0_libctx(cch->d.certificate, ctx->libctx, ctx->propq);
 114         }
 115     }
 116 }
 117
 118 const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms)
 119 {
 120     return cms->contentType;
 121 }
 122
 123 CMS_ContentInfo *cms_Data_create(OPENSSL_CTX *libctx, const char *propq)
 124 {
 125     CMS_ContentInfo *cms = CMS_ContentInfo_new_with_libctx(libctx, propq);
 126
 127     if (cms != NULL) {
 128         cms->contentType = OBJ_nid2obj(NID_pkcs7_data);
 129         /* Never detached */
 130         CMS_set_detached(cms, 0);
 131     }
 132     return cms;
 133 }
 134
 135 BIO *cms_content_bio(CMS_ContentInfo *cms)
 136 {
 137     ASN1_OCTET_STRING **pos = CMS_get0_content(cms);
 138
 139     if (pos == NULL)
 140         return NULL;
 141     /* If content detached data goes nowhere: create NULL BIO */
 142     if (*pos == NULL)
 143         return BIO_new(BIO_s_null());
 144     /*
 145      * If content not detached and created return memory BIO
 146      */
 147     if (*pos == NULL || ((*pos)->flags == ASN1_STRING_FLAG_CONT))
 148         return BIO_new(BIO_s_mem());
 149     /* Else content was read in: return read only BIO for it */
 150     return BIO_new_mem_buf((*pos)->data, (*pos)->length);
 151 }
 152
 153 BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont)
 154 {
 155     BIO *cmsbio, *cont;
 156     if (icont)
 157         cont = icont;
 158     else
 159         cont = cms_content_bio(cms);
 160     if (!cont) {
 161         CMSerr(CMS_F_CMS_DATAINIT, CMS_R_NO_CONTENT);
 162         return NULL;
 163     }
 164     switch (OBJ_obj2nid(cms->contentType)) {
 165
 166     case NID_pkcs7_data:
 167         return cont;
 168
 169     case NID_pkcs7_signed:
 170         cmsbio = cms_SignedData_init_bio(cms);
 171         break;
 172
 173     case NID_pkcs7_digest:
 174         cmsbio = cms_DigestedData_init_bio(cms);
 175         break;
 176 #ifdef ZLIB
 177     case NID_id_smime_ct_compressedData:
 178         cmsbio = cms_CompressedData_init_bio(cms);
 179         break;
 180 #endif
 181
 182     case NID_pkcs7_encrypted:
 183         cmsbio = cms_EncryptedData_init_bio(cms);
 184         break;
 185
 186     case NID_pkcs7_enveloped:
 187         cmsbio = cms_EnvelopedData_init_bio(cms);
 188         break;
 189
 190     case NID_id_smime_ct_authEnvelopedData:
 191         cmsbio = cms_AuthEnvelopedData_init_bio(cms);
 192         break;
 193
 194     default:
 195         CMSerr(CMS_F_CMS_DATAINIT, CMS_R_UNSUPPORTED_TYPE);
 196         goto err;
 197     }
 198
 199     if (cmsbio)
 200         return BIO_push(cmsbio, cont);
 201 err:
 202     if (!icont)
 203         BIO_free(cont);
 204     return NULL;
 205
 206 }
 207
 208 /* unfortunately cannot constify SMIME_write_ASN1() due to this function */
 209 int CMS_dataFinal(CMS_ContentInfo *cms, BIO *cmsbio)
 210 {
 211     ASN1_OCTET_STRING **pos = CMS_get0_content(cms);
 212
 213     if (pos == NULL)
 214         return 0;
 215     /* If embedded content find memory BIO and set content */
 216     if (*pos && ((*pos)->flags & ASN1_STRING_FLAG_CONT)) {
 217         BIO *mbio;
 218         unsigned char *cont;
 219         long contlen;
 220         mbio = BIO_find_type(cmsbio, BIO_TYPE_MEM);
 221         if (!mbio) {
 222             CMSerr(CMS_F_CMS_DATAFINAL, CMS_R_CONTENT_NOT_FOUND);
 223             return 0;
 224         }
 225         contlen = BIO_get_mem_data(mbio, &cont);
 226         /* Set bio as read only so its content can't be clobbered */
 227         BIO_set_flags(mbio, BIO_FLAGS_MEM_RDONLY);
 228         BIO_set_mem_eof_return(mbio, 0);
 229         ASN1_STRING_set0(*pos, cont, contlen);
 230         (*pos)->flags &= ~ASN1_STRING_FLAG_CONT;
 231     }
 232
 233     switch (OBJ_obj2nid(cms->contentType)) {
 234
 235     case NID_pkcs7_data:
 236     case NID_pkcs7_encrypted:
 237     case NID_id_smime_ct_compressedData:
 238         /* Nothing to do */
 239         return 1;
 240
 241     case NID_pkcs7_enveloped:
 242         return cms_EnvelopedData_final(cms, cmsbio);
 243
 244     case NID_id_smime_ct_authEnvelopedData:
 245         return cms_AuthEnvelopedData_final(cms, cmsbio);
 246
 247     case NID_pkcs7_signed:
 248         return cms_SignedData_final(cms, cmsbio);
 249
 250     case NID_pkcs7_digest:
 251         return cms_DigestedData_do_final(cms, cmsbio, 0);
 252
 253     default:
 254         CMSerr(CMS_F_CMS_DATAFINAL, CMS_R_UNSUPPORTED_TYPE);
 255         return 0;
 256     }
 257 }
 258
 259 /*
 260  * Return an OCTET STRING pointer to content. This allows it to be accessed
 261  * or set later.
 262  */
 263
 264 ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms)
 265 {
 266     switch (OBJ_obj2nid(cms->contentType)) {
 267
 268     case NID_pkcs7_data:
 269         return &cms->d.data;
 270
 271     case NID_pkcs7_signed:
 272         return &cms->d.signedData->encapContentInfo->eContent;
 273
 274     case NID_pkcs7_enveloped:
 275         return &cms->d.envelopedData->encryptedContentInfo->encryptedContent;
 276
 277     case NID_pkcs7_digest:
 278         return &cms->d.digestedData->encapContentInfo->eContent;
 279
 280     case NID_pkcs7_encrypted:
 281         return &cms->d.encryptedData->encryptedContentInfo->encryptedContent;
 282
 283     case NID_id_smime_ct_authEnvelopedData:
 284         return &cms->d.authEnvelopedData->authEncryptedContentInfo
 285                                         ->encryptedContent;
 286
 287     case NID_id_smime_ct_authData:
 288         return &cms->d.authenticatedData->encapContentInfo->eContent;
 289
 290     case NID_id_smime_ct_compressedData:
 291         return &cms->d.compressedData->encapContentInfo->eContent;
 292
 293     default:
 294         if (cms->d.other->type == V_ASN1_OCTET_STRING)
 295             return &cms->d.other->value.octet_string;
 296         CMSerr(CMS_F_CMS_GET0_CONTENT, CMS_R_UNSUPPORTED_CONTENT_TYPE);
 297         return NULL;
 298
 299     }
 300 }
 301
 302 /*
 303  * Return an ASN1_OBJECT pointer to content type. This allows it to be
 304  * accessed or set later.
 305  */
 306
 307 static ASN1_OBJECT **cms_get0_econtent_type(CMS_ContentInfo *cms)
 308 {
 309     switch (OBJ_obj2nid(cms->contentType)) {
 310
 311     case NID_pkcs7_signed:
 312         return &cms->d.signedData->encapContentInfo->eContentType;
 313
 314     case NID_pkcs7_enveloped:
 315         return &cms->d.envelopedData->encryptedContentInfo->contentType;
 316
 317     case NID_pkcs7_digest:
 318         return &cms->d.digestedData->encapContentInfo->eContentType;
 319
 320     case NID_pkcs7_encrypted:
 321         return &cms->d.encryptedData->encryptedContentInfo->contentType;
 322
 323     case NID_id_smime_ct_authEnvelopedData:
 324         return &cms->d.authEnvelopedData->authEncryptedContentInfo
 325                                         ->contentType;
 326     case NID_id_smime_ct_authData:
 327         return &cms->d.authenticatedData->encapContentInfo->eContentType;
 328
 329     case NID_id_smime_ct_compressedData:
 330         return &cms->d.compressedData->encapContentInfo->eContentType;
 331
 332     default:
 333         CMSerr(CMS_F_CMS_GET0_ECONTENT_TYPE, CMS_R_UNSUPPORTED_CONTENT_TYPE);
 334         return NULL;
 335
 336     }
 337 }
 338
 339 const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms)
 340 {
 341     ASN1_OBJECT **petype;
 342     petype = cms_get0_econtent_type(cms);
 343     if (petype)
 344         return *petype;
 345     return NULL;
 346 }
 347
 348 int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid)
 349 {
 350     ASN1_OBJECT **petype, *etype;
 351
 352     petype = cms_get0_econtent_type(cms);
 353     if (petype == NULL)
 354         return 0;
 355     if (oid == NULL)
 356         return 1;
 357     etype = OBJ_dup(oid);
 358     if (etype == NULL)
 359         return 0;
 360     ASN1_OBJECT_free(*petype);
 361     *petype = etype;
 362     return 1;
 363 }
 364
 365 int CMS_is_detached(CMS_ContentInfo *cms)
 366 {
 367     ASN1_OCTET_STRING **pos;
 368
 369     pos = CMS_get0_content(cms);
 370     if (pos == NULL)
 371         return -1;
 372     if (*pos != NULL)
 373         return 0;
 374     return 1;
 375 }
 376
 377 int CMS_set_detached(CMS_ContentInfo *cms, int detached)
 378 {
 379     ASN1_OCTET_STRING **pos;
 380
 381     pos = CMS_get0_content(cms);
 382     if (pos == NULL)
 383         return 0;
 384     if (detached) {
 385         ASN1_OCTET_STRING_free(*pos);
 386         *pos = NULL;
 387         return 1;
 388     }
 389     if (*pos == NULL)
 390         *pos = ASN1_OCTET_STRING_new();
 391     if (*pos != NULL) {
 392         /*
 393          * NB: special flag to show content is created and not read in.
 394          */
 395         (*pos)->flags |= ASN1_STRING_FLAG_CONT;
 396         return 1;
 397     }
 398     CMSerr(CMS_F_CMS_SET_DETACHED, ERR_R_MALLOC_FAILURE);
 399     return 0;
 400 }
 401
 402 /* Create a digest BIO from an X509_ALGOR structure */
 403
 404 BIO *cms_DigestAlgorithm_init_bio(X509_ALGOR *digestAlgorithm,
 405                                   const CMS_CTX *ctx)
 406 {
 407     BIO *mdbio = NULL;
 408     const ASN1_OBJECT *digestoid;
 409     const EVP_MD *digest = NULL;
 410     EVP_MD *fetched_digest = NULL;
 411     const char *alg;
 412
 413     X509_ALGOR_get0(&digestoid, NULL, NULL, digestAlgorithm);
 414     alg = OBJ_nid2sn(OBJ_obj2nid(digestoid));
 415
 416     (void)ERR_set_mark();
 417     fetched_digest = EVP_MD_fetch(ctx->libctx, alg, ctx->propq);
 418
 419     if (fetched_digest != NULL)
 420         digest = fetched_digest;
 421     else
 422         digest = EVP_get_digestbyobj(digestoid);
 423     if (digest == NULL) {
 424         (void)ERR_clear_last_mark();
 425         CMSerr(CMS_F_CMS_DIGESTALGORITHM_INIT_BIO,
 426                CMS_R_UNKNOWN_DIGEST_ALGORITHM);
 427         goto err;
 428     }
 429     (void)ERR_pop_to_mark();
 430
 431     mdbio = BIO_new(BIO_f_md());
 432     if (mdbio == NULL || !BIO_set_md(mdbio, digest)) {
 433         CMSerr(CMS_F_CMS_DIGESTALGORITHM_INIT_BIO, CMS_R_MD_BIO_INIT_ERROR);
 434         goto err;
 435     }
 436     EVP_MD_free(fetched_digest);
 437     return mdbio;
 438  err:
 439     EVP_MD_free(fetched_digest);
 440     BIO_free(mdbio);
 441     return NULL;
 442 }
 443
 444 /* Locate a message digest content from a BIO chain based on SignerInfo */
 445
 446 int cms_DigestAlgorithm_find_ctx(EVP_MD_CTX *mctx, BIO *chain,
 447                                  X509_ALGOR *mdalg)
 448 {
 449     int nid;
 450     const ASN1_OBJECT *mdoid;
 451     X509_ALGOR_get0(&mdoid, NULL, NULL, mdalg);
 452     nid = OBJ_obj2nid(mdoid);
 453     /* Look for digest type to match signature */
 454     for (;;) {
 455         EVP_MD_CTX *mtmp;
 456         chain = BIO_find_type(chain, BIO_TYPE_MD);
 457         if (chain == NULL) {
 458             CMSerr(CMS_F_CMS_DIGESTALGORITHM_FIND_CTX,
 459                    CMS_R_NO_MATCHING_DIGEST);
 460             return 0;
 461         }
 462         BIO_get_md_ctx(chain, &mtmp);
 463         if (EVP_MD_CTX_type(mtmp) == nid
 464             /*
 465              * Workaround for broken implementations that use signature
 466              * algorithm OID instead of digest.
 467              */
 468             || EVP_MD_pkey_type(EVP_MD_CTX_md(mtmp)) == nid)
 469             return EVP_MD_CTX_copy_ex(mctx, mtmp);
 470         chain = BIO_next(chain);
 471     }
 472 }
 473
 474 static STACK_OF(CMS_CertificateChoices)
 475 **cms_get0_certificate_choices(CMS_ContentInfo *cms)
 476 {
 477     switch (OBJ_obj2nid(cms->contentType)) {
 478
 479     case NID_pkcs7_signed:
 480         return &cms->d.signedData->certificates;
 481
 482     case NID_pkcs7_enveloped:
 483         if (cms->d.envelopedData->originatorInfo == NULL)
 484             return NULL;
 485         return &cms->d.envelopedData->originatorInfo->certificates;
 486
 487     case NID_id_smime_ct_authEnvelopedData:
 488         if (cms->d.authEnvelopedData->originatorInfo == NULL)
 489             return NULL;
 490         return &cms->d.authEnvelopedData->originatorInfo->certificates;
 491
 492     default:
 493         CMSerr(CMS_F_CMS_GET0_CERTIFICATE_CHOICES,
 494                CMS_R_UNSUPPORTED_CONTENT_TYPE);
 495         return NULL;
 496
 497     }
 498 }
 499
 500 CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms)
 501 {
 502     STACK_OF(CMS_CertificateChoices) **pcerts;
 503     CMS_CertificateChoices *cch;
 504
 505     pcerts = cms_get0_certificate_choices(cms);
 506     if (pcerts == NULL)
 507         return NULL;
 508     if (*pcerts == NULL)
 509         *pcerts = sk_CMS_CertificateChoices_new_null();
 510     if (*pcerts == NULL)
 511         return NULL;
 512     cch = M_ASN1_new_of(CMS_CertificateChoices);
 513     if (!cch)
 514         return NULL;
 515     if (!sk_CMS_CertificateChoices_push(*pcerts, cch)) {
 516         M_ASN1_free_of(cch, CMS_CertificateChoices);
 517         return NULL;
 518     }
 519     return cch;
 520 }
 521
 522 int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert)
 523 {
 524     CMS_CertificateChoices *cch;
 525     STACK_OF(CMS_CertificateChoices) **pcerts;
 526     int i;
 527
 528     pcerts = cms_get0_certificate_choices(cms);
 529     if (pcerts == NULL)
 530         return 0;
 531     for (i = 0; i < sk_CMS_CertificateChoices_num(*pcerts); i++) {
 532         cch = sk_CMS_CertificateChoices_value(*pcerts, i);
 533         if (cch->type == CMS_CERTCHOICE_CERT) {
 534             if (!X509_cmp(cch->d.certificate, cert)) {
 535                 CMSerr(CMS_F_CMS_ADD0_CERT,
 536                        CMS_R_CERTIFICATE_ALREADY_PRESENT);
 537                 return 0;
 538             }
 539         }
 540     }
 541     cch = CMS_add0_CertificateChoices(cms);
 542     if (!cch)
 543         return 0;
 544     cch->type = CMS_CERTCHOICE_CERT;
 545     cch->d.certificate = cert;
 546     return 1;
 547 }
 548
 549 int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert)
 550 {
 551     int r;
 552     r = CMS_add0_cert(cms, cert);
 553     if (r > 0)
 554         X509_up_ref(cert);
 555     return r;
 556 }
 557
 558 static STACK_OF(CMS_RevocationInfoChoice)
 559 **cms_get0_revocation_choices(CMS_ContentInfo *cms)
 560 {
 561     switch (OBJ_obj2nid(cms->contentType)) {
 562
 563     case NID_pkcs7_signed:
 564         return &cms->d.signedData->crls;
 565
 566     case NID_pkcs7_enveloped:
 567         if (cms->d.envelopedData->originatorInfo == NULL)
 568             return NULL;
 569         return &cms->d.envelopedData->originatorInfo->crls;
 570
 571     case NID_id_smime_ct_authEnvelopedData:
 572         if (cms->d.authEnvelopedData->originatorInfo == NULL)
 573             return NULL;
 574         return &cms->d.authEnvelopedData->originatorInfo->crls;
 575
 576     default:
 577         CMSerr(CMS_F_CMS_GET0_REVOCATION_CHOICES,
 578                CMS_R_UNSUPPORTED_CONTENT_TYPE);
 579         return NULL;
 580
 581     }
 582 }
 583
 584 CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms)
 585 {
 586     STACK_OF(CMS_RevocationInfoChoice) **pcrls;
 587     CMS_RevocationInfoChoice *rch;
 588
 589     pcrls = cms_get0_revocation_choices(cms);
 590     if (pcrls == NULL)
 591         return NULL;
 592     if (*pcrls == NULL)
 593         *pcrls = sk_CMS_RevocationInfoChoice_new_null();
 594     if (*pcrls == NULL)
 595         return NULL;
 596     rch = M_ASN1_new_of(CMS_RevocationInfoChoice);
 597     if (rch == NULL)
 598         return NULL;
 599     if (!sk_CMS_RevocationInfoChoice_push(*pcrls, rch)) {
 600         M_ASN1_free_of(rch, CMS_RevocationInfoChoice);
 601         return NULL;
 602     }
 603     return rch;
 604 }
 605
 606 int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl)
 607 {
 608     CMS_RevocationInfoChoice *rch;
 609     rch = CMS_add0_RevocationInfoChoice(cms);
 610     if (!rch)
 611         return 0;
 612     rch->type = CMS_REVCHOICE_CRL;
 613     rch->d.crl = crl;
 614     return 1;
 615 }
 616
 617 int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl)
 618 {
 619     int r;
 620     r = CMS_add0_crl(cms, crl);
 621     if (r > 0)
 622         X509_CRL_up_ref(crl);
 623     return r;
 624 }
 625
 626 STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms)
 627 {
 628     STACK_OF(X509) *certs = NULL;
 629     CMS_CertificateChoices *cch;
 630     STACK_OF(CMS_CertificateChoices) **pcerts;
 631     int i;
 632
 633     pcerts = cms_get0_certificate_choices(cms);
 634     if (pcerts == NULL)
 635         return NULL;
 636     for (i = 0; i < sk_CMS_CertificateChoices_num(*pcerts); i++) {
 637         cch = sk_CMS_CertificateChoices_value(*pcerts, i);
 638         if (cch->type == 0) {
 639             if (!X509_add_cert_new(&certs, cch->d.certificate,
 640                                    X509_ADD_FLAG_UP_REF)) {
 641                 sk_X509_pop_free(certs, X509_free);
 642                 return NULL;
 643             }
 644         }
 645     }
 646     return certs;
 647
 648 }
 649
 650 STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms)
 651 {
 652     STACK_OF(X509_CRL) *crls = NULL;
 653     STACK_OF(CMS_RevocationInfoChoice) **pcrls;
 654     CMS_RevocationInfoChoice *rch;
 655     int i;
 656
 657     pcrls = cms_get0_revocation_choices(cms);
 658     if (pcrls == NULL)
 659         return NULL;
 660     for (i = 0; i < sk_CMS_RevocationInfoChoice_num(*pcrls); i++) {
 661         rch = sk_CMS_RevocationInfoChoice_value(*pcrls, i);
 662         if (rch->type == 0) {
 663             if (!crls) {
 664                 crls = sk_X509_CRL_new_null();
 665                 if (!crls)
 666                     return NULL;
 667             }
 668             if (!sk_X509_CRL_push(crls, rch->d.crl)) {
 669                 sk_X509_CRL_pop_free(crls, X509_CRL_free);
 670                 return NULL;
 671             }
 672             X509_CRL_up_ref(rch->d.crl);
 673         }
 674     }
 675     return crls;
 676 }
 677
 678 int cms_ias_cert_cmp(CMS_IssuerAndSerialNumber *ias, X509 *cert)
 679 {
 680     int ret;
 681     ret = X509_NAME_cmp(ias->issuer, X509_get_issuer_name(cert));
 682     if (ret)
 683         return ret;
 684     return ASN1_INTEGER_cmp(ias->serialNumber, X509_get0_serialNumber(cert));
 685 }
 686
 687 int cms_keyid_cert_cmp(ASN1_OCTET_STRING *keyid, X509 *cert)
 688 {
 689     const ASN1_OCTET_STRING *cert_keyid = X509_get0_subject_key_id(cert);
 690
 691     if (cert_keyid == NULL)
 692         return -1;
 693     return ASN1_OCTET_STRING_cmp(keyid, cert_keyid);
 694 }
 695
 696 int cms_set1_ias(CMS_IssuerAndSerialNumber **pias, X509 *cert)
 697 {
 698     CMS_IssuerAndSerialNumber *ias;
 699     ias = M_ASN1_new_of(CMS_IssuerAndSerialNumber);
 700     if (!ias)
 701         goto err;
 702     if (!X509_NAME_set(&ias->issuer, X509_get_issuer_name(cert)))
 703         goto err;
 704     if (!ASN1_STRING_copy(ias->serialNumber, X509_get0_serialNumber(cert)))
 705         goto err;
 706     M_ASN1_free_of(*pias, CMS_IssuerAndSerialNumber);
 707     *pias = ias;
 708     return 1;
 709  err:
 710     M_ASN1_free_of(ias, CMS_IssuerAndSerialNumber);
 711     CMSerr(CMS_F_CMS_SET1_IAS, ERR_R_MALLOC_FAILURE);
 712     return 0;
 713 }
 714
 715 int cms_set1_keyid(ASN1_OCTET_STRING **pkeyid, X509 *cert)
 716 {
 717     ASN1_OCTET_STRING *keyid = NULL;
 718     const ASN1_OCTET_STRING *cert_keyid;
 719     cert_keyid = X509_get0_subject_key_id(cert);
 720     if (cert_keyid == NULL) {
 721         CMSerr(CMS_F_CMS_SET1_KEYID, CMS_R_CERTIFICATE_HAS_NO_KEYID);
 722         return 0;
 723     }
 724     keyid = ASN1_STRING_dup(cert_keyid);
 725     if (!keyid) {
 726         CMSerr(CMS_F_CMS_SET1_KEYID, ERR_R_MALLOC_FAILURE);
 727         return 0;
 728     }
 729     ASN1_OCTET_STRING_free(*pkeyid);
 730     *pkeyid = keyid;
 731     return 1;
 732 }