crypto/heimdal/lib/hx509/cms.c

   1 /*
   2  * Copyright (c) 2003 - 2007 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "hx_locl.h"
  35
  36 /**
  37  * @page page_cms CMS/PKCS7 message functions.
  38  *
  39  * CMS is defined in RFC 3369 and is an continuation of the RSA Labs
  40  * standard PKCS7. The basic messages in CMS is
  41  *
  42  * - SignedData
  43  *   Data signed with private key (RSA, DSA, ECDSA) or secret
  44  *   (symmetric) key
  45  * - EnvelopedData
  46  *   Data encrypted with private key (RSA)
  47  * - EncryptedData
  48  *   Data encrypted with secret (symmetric) key.
  49  * - ContentInfo
  50  *   Wrapper structure including type and data.
  51  *
  52  *
  53  * See the library functions here: @ref hx509_cms
  54  */
  55
  56 #define ALLOC(X, N) (X) = calloc((N), sizeof(*(X)))
  57 #define ALLOC_SEQ(X, N) do { (X)->len = (N); ALLOC((X)->val, (N)); } while(0)
  58
  59 /**
  60  * Wrap data and oid in a ContentInfo and encode it.
  61  *
  62  * @param oid type of the content.
  63  * @param buf data to be wrapped. If a NULL pointer is passed in, the
  64  * optional content field in the ContentInfo is not going be filled
  65  * in.
  66  * @param res the encoded buffer, the result should be freed with
  67  * der_free_octet_string().
  68  *
  69  * @return Returns an hx509 error code.
  70  *
  71  * @ingroup hx509_cms
  72  */
  73
  74 int
  75 hx509_cms_wrap_ContentInfo(const heim_oid *oid,
  76                            const heim_octet_string *buf,
  77                            heim_octet_string *res)
  78 {
  79     ContentInfo ci;
  80     size_t size;
  81     int ret;
  82
  83     memset(res, 0, sizeof(*res));
  84     memset(&ci, 0, sizeof(ci));
  85
  86     ret = der_copy_oid(oid, &ci.contentType);
  87     if (ret)
  88         return ret;
  89     if (buf) {
  90         ALLOC(ci.content, 1);
  91         if (ci.content == NULL) {
  92             free_ContentInfo(&ci);
  93             return ENOMEM;
  94         }
  95         ci.content->data = malloc(buf->length);
  96         if (ci.content->data == NULL) {
  97             free_ContentInfo(&ci);
  98             return ENOMEM;
  99         }
 100         memcpy(ci.content->data, buf->data, buf->length);
 101         ci.content->length = buf->length;
 102     }
 103
 104     ASN1_MALLOC_ENCODE(ContentInfo, res->data, res->length, &ci, &size, ret);
 105     free_ContentInfo(&ci);
 106     if (ret)
 107         return ret;
 108     if (res->length != size)
 109         _hx509_abort("internal ASN.1 encoder error");
 110
 111     return 0;
 112 }
 113
 114 /**
 115  * Decode an ContentInfo and unwrap data and oid it.
 116  *
 117  * @param in the encoded buffer.
 118  * @param oid type of the content.
 119  * @param out data to be wrapped.
 120  * @param have_data since the data is optional, this flags show dthe
 121  * diffrence between no data and the zero length data.
 122  *
 123  * @return Returns an hx509 error code.
 124  *
 125  * @ingroup hx509_cms
 126  */
 127
 128 int
 129 hx509_cms_unwrap_ContentInfo(const heim_octet_string *in,
 130                              heim_oid *oid,
 131                              heim_octet_string *out,
 132                              int *have_data)
 133 {
 134     ContentInfo ci;
 135     size_t size;
 136     int ret;
 137
 138     memset(oid, 0, sizeof(*oid));
 139     memset(out, 0, sizeof(*out));
 140
 141     ret = decode_ContentInfo(in->data, in->length, &ci, &size);
 142     if (ret)
 143         return ret;
 144
 145     ret = der_copy_oid(&ci.contentType, oid);
 146     if (ret) {
 147         free_ContentInfo(&ci);
 148         return ret;
 149     }
 150     if (ci.content) {
 151         ret = der_copy_octet_string(ci.content, out);
 152         if (ret) {
 153             der_free_oid(oid);
 154             free_ContentInfo(&ci);
 155             return ret;
 156         }
 157     } else
 158         memset(out, 0, sizeof(*out));
 159
 160     if (have_data)
 161         *have_data = (ci.content != NULL) ? 1 : 0;
 162
 163     free_ContentInfo(&ci);
 164
 165     return 0;
 166 }
 167
 168 #define CMS_ID_SKI      0
 169 #define CMS_ID_NAME     1
 170
 171 static int
 172 fill_CMSIdentifier(const hx509_cert cert,
 173                    int type,
 174                    CMSIdentifier *id)
 175 {
 176     int ret;
 177
 178     switch (type) {
 179     case CMS_ID_SKI:
 180         id->element = choice_CMSIdentifier_subjectKeyIdentifier;
 181         ret = _hx509_find_extension_subject_key_id(_hx509_get_cert(cert),
 182                                                    &id->u.subjectKeyIdentifier);
 183         if (ret == 0)
 184             break;
 185         /* FALL THOUGH */
 186     case CMS_ID_NAME: {
 187         hx509_name name;
 188
 189         id->element = choice_CMSIdentifier_issuerAndSerialNumber;
 190         ret = hx509_cert_get_issuer(cert, &name);
 191         if (ret)
 192             return ret;
 193         ret = hx509_name_to_Name(name, &id->u.issuerAndSerialNumber.issuer);
 194         hx509_name_free(&name);
 195         if (ret)
 196             return ret;
 197
 198         ret = hx509_cert_get_serialnumber(cert, &id->u.issuerAndSerialNumber.serialNumber);
 199         break;
 200     }
 201     default:
 202         _hx509_abort("CMS fill identifier with unknown type");
 203     }
 204     return ret;
 205 }
 206
 207 static int
 208 unparse_CMSIdentifier(hx509_context context,
 209                       CMSIdentifier *id,
 210                       char **str)
 211 {
 212     int ret;
 213
 214     *str = NULL;
 215     switch (id->element) {
 216     case choice_CMSIdentifier_issuerAndSerialNumber: {
 217         IssuerAndSerialNumber *iasn;
 218         char *serial, *name;
 219
 220         iasn = &id->u.issuerAndSerialNumber;
 221
 222         ret = _hx509_Name_to_string(&iasn->issuer, &name);
 223         if(ret)
 224             return ret;
 225         ret = der_print_hex_heim_integer(&iasn->serialNumber, &serial);
 226         if (ret) {
 227             free(name);
 228             return ret;
 229         }
 230         asprintf(str, "certificate issued by %s with serial number %s",
 231                  name, serial);
 232         free(name);
 233         free(serial);
 234         break;
 235     }
 236     case choice_CMSIdentifier_subjectKeyIdentifier: {
 237         KeyIdentifier *ki  = &id->u.subjectKeyIdentifier;
 238         char *keyid;
 239         ssize_t len;
 240
 241         len = hex_encode(ki->data, ki->length, &keyid);
 242         if (len < 0)
 243             return ENOMEM;
 244
 245         asprintf(str, "certificate with id %s", keyid);
 246         free(keyid);
 247         break;
 248     }
 249     default:
 250         asprintf(str, "certificate have unknown CMSidentifier type");
 251         break;
 252     }
 253     if (*str == NULL)
 254         return ENOMEM;
 255     return 0;
 256 }
 257
 258 static int
 259 find_CMSIdentifier(hx509_context context,
 260                    CMSIdentifier *client,
 261                    hx509_certs certs,
 262                    time_t time_now,
 263                    hx509_cert *signer_cert,
 264                    int match)
 265 {
 266     hx509_query q;
 267     hx509_cert cert;
 268     Certificate c;
 269     int ret;
 270
 271     memset(&c, 0, sizeof(c));
 272     _hx509_query_clear(&q);
 273
 274     *signer_cert = NULL;
 275
 276     switch (client->element) {
 277     case choice_CMSIdentifier_issuerAndSerialNumber:
 278         q.serial = &client->u.issuerAndSerialNumber.serialNumber;
 279         q.issuer_name = &client->u.issuerAndSerialNumber.issuer;
 280         q.match = HX509_QUERY_MATCH_SERIALNUMBER|HX509_QUERY_MATCH_ISSUER_NAME;
 281         break;
 282     case choice_CMSIdentifier_subjectKeyIdentifier:
 283         q.subject_id = &client->u.subjectKeyIdentifier;
 284         q.match = HX509_QUERY_MATCH_SUBJECT_KEY_ID;
 285         break;
 286     default:
 287         hx509_set_error_string(context, 0, HX509_CMS_NO_RECIPIENT_CERTIFICATE,
 288                                "unknown CMS identifier element");
 289         return HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 290     }
 291
 292     q.match |= match;
 293
 294     q.match |= HX509_QUERY_MATCH_TIME;
 295     if (time_now)
 296         q.timenow = time_now;
 297     else
 298         q.timenow = time(NULL);
 299
 300     ret = hx509_certs_find(context, certs, &q, &cert);
 301     if (ret == HX509_CERT_NOT_FOUND) {
 302         char *str;
 303
 304         ret = unparse_CMSIdentifier(context, client, &str);
 305         if (ret == 0) {
 306             hx509_set_error_string(context, 0,
 307                                    HX509_CMS_NO_RECIPIENT_CERTIFICATE,
 308                                    "Failed to find %s", str);
 309         } else
 310             hx509_clear_error_string(context);
 311         return HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 312     } else if (ret) {
 313         hx509_set_error_string(context, HX509_ERROR_APPEND,
 314                                HX509_CMS_NO_RECIPIENT_CERTIFICATE,
 315                                "Failed to find CMS id in cert store");
 316         return HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 317     }
 318
 319     *signer_cert = cert;
 320
 321     return 0;
 322 }
 323
 324 /**
 325  * Decode and unencrypt EnvelopedData.
 326  *
 327  * Extract data and parameteres from from the EnvelopedData. Also
 328  * supports using detached EnvelopedData.
 329  *
 330  * @param context A hx509 context.
 331  * @param certs Certificate that can decrypt the EnvelopedData
 332  * encryption key.
 333  * @param flags HX509_CMS_UE flags to control the behavior.
 334  * @param data pointer the structure the contains the DER/BER encoded
 335  * EnvelopedData stucture.
 336  * @param length length of the data that data point to.
 337  * @param encryptedContent in case of detached signature, this
 338  * contains the actual encrypted data, othersize its should be NULL.
 339  * @param time_now set the current time, if zero the library uses now as the date.
 340  * @param contentType output type oid, should be freed with der_free_oid().
 341  * @param content the data, free with der_free_octet_string().
 342  *
 343  * @ingroup hx509_cms
 344  */
 345
 346 int
 347 hx509_cms_unenvelope(hx509_context context,
 348                      hx509_certs certs,
 349                      int flags,
 350                      const void *data,
 351                      size_t length,
 352                      const heim_octet_string *encryptedContent,
 353                      time_t time_now,
 354                      heim_oid *contentType,
 355                      heim_octet_string *content)
 356 {
 357     heim_octet_string key;
 358     EnvelopedData ed;
 359     hx509_cert cert;
 360     AlgorithmIdentifier *ai;
 361     const heim_octet_string *enccontent;
 362     heim_octet_string *params, params_data;
 363     heim_octet_string ivec;
 364     size_t size;
 365     int ret, matched = 0, findflags = 0;
 366     size_t i;
 367
 368
 369     memset(&key, 0, sizeof(key));
 370     memset(&ed, 0, sizeof(ed));
 371     memset(&ivec, 0, sizeof(ivec));
 372     memset(content, 0, sizeof(*content));
 373     memset(contentType, 0, sizeof(*contentType));
 374
 375     if ((flags & HX509_CMS_UE_DONT_REQUIRE_KU_ENCIPHERMENT) == 0)
 376         findflags |= HX509_QUERY_KU_ENCIPHERMENT;
 377
 378     ret = decode_EnvelopedData(data, length, &ed, &size);
 379     if (ret) {
 380         hx509_set_error_string(context, 0, ret,
 381                                "Failed to decode EnvelopedData");
 382         return ret;
 383     }
 384
 385     if (ed.recipientInfos.len == 0) {
 386         ret = HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 387         hx509_set_error_string(context, 0, ret,
 388                                "No recipient info in enveloped data");
 389         goto out;
 390     }
 391
 392     enccontent = ed.encryptedContentInfo.encryptedContent;
 393     if (enccontent == NULL) {
 394         if (encryptedContent == NULL) {
 395             ret = HX509_CMS_NO_DATA_AVAILABLE;
 396             hx509_set_error_string(context, 0, ret,
 397                                    "Content missing from encrypted data");
 398             goto out;
 399         }
 400         enccontent = encryptedContent;
 401     } else if (encryptedContent != NULL) {
 402         ret = HX509_CMS_NO_DATA_AVAILABLE;
 403         hx509_set_error_string(context, 0, ret,
 404                                "Both internal and external encrypted data");
 405         goto out;
 406     }
 407
 408     cert = NULL;
 409     for (i = 0; i < ed.recipientInfos.len; i++) {
 410         KeyTransRecipientInfo *ri;
 411         char *str;
 412         int ret2;
 413
 414         ri = &ed.recipientInfos.val[i];
 415
 416         ret = find_CMSIdentifier(context, &ri->rid, certs,
 417                                  time_now, &cert,
 418                                  HX509_QUERY_PRIVATE_KEY|findflags);
 419         if (ret)
 420             continue;
 421
 422         matched = 1; /* found a matching certificate, let decrypt */
 423
 424         ret = _hx509_cert_private_decrypt(context,
 425                                           &ri->encryptedKey,
 426                                           &ri->keyEncryptionAlgorithm.algorithm,
 427                                           cert, &key);
 428
 429         hx509_cert_free(cert);
 430         if (ret == 0)
 431             break; /* succuessfully decrypted cert */
 432         cert = NULL;
 433         ret2 = unparse_CMSIdentifier(context, &ri->rid, &str);
 434         if (ret2 == 0) {
 435             hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
 436                                    "Failed to decrypt with %s", str);
 437             free(str);
 438         }
 439     }
 440
 441     if (!matched) {
 442         ret = HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 443         hx509_set_error_string(context, 0, ret,
 444                                "No private key matched any certificate");
 445         goto out;
 446     }
 447
 448     if (cert == NULL) {
 449         ret = HX509_CMS_NO_RECIPIENT_CERTIFICATE;
 450         hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
 451                                "No private key decrypted the transfer key");
 452         goto out;
 453     }
 454
 455     ret = der_copy_oid(&ed.encryptedContentInfo.contentType, contentType);
 456     if (ret) {
 457         hx509_set_error_string(context, 0, ret,
 458                                "Failed to copy EnvelopedData content oid");
 459         goto out;
 460     }
 461
 462     ai = &ed.encryptedContentInfo.contentEncryptionAlgorithm;
 463     if (ai->parameters) {
 464         params_data.data = ai->parameters->data;
 465         params_data.length = ai->parameters->length;
 466         params = &params_data;
 467     } else
 468         params = NULL;
 469
 470     {
 471         hx509_crypto crypto;
 472
 473         ret = hx509_crypto_init(context, NULL, &ai->algorithm, &crypto);
 474         if (ret)
 475             goto out;
 476
 477         if (flags & HX509_CMS_UE_ALLOW_WEAK)
 478             hx509_crypto_allow_weak(crypto);
 479
 480         if (params) {
 481             ret = hx509_crypto_set_params(context, crypto, params, &ivec);
 482             if (ret) {
 483                 hx509_crypto_destroy(crypto);
 484                 goto out;
 485             }
 486         }
 487
 488         ret = hx509_crypto_set_key_data(crypto, key.data, key.length);
 489         if (ret) {
 490             hx509_crypto_destroy(crypto);
 491             hx509_set_error_string(context, 0, ret,
 492                                    "Failed to set key for decryption "
 493                                    "of EnvelopedData");
 494             goto out;
 495         }
 496
 497         ret = hx509_crypto_decrypt(crypto,
 498                                    enccontent->data,
 499                                    enccontent->length,
 500                                    ivec.length ? &ivec : NULL,
 501                                    content);
 502         hx509_crypto_destroy(crypto);
 503         if (ret) {
 504             hx509_set_error_string(context, 0, ret,
 505                                    "Failed to decrypt EnvelopedData");
 506             goto out;
 507         }
 508     }
 509
 510 out:
 511
 512     free_EnvelopedData(&ed);
 513     der_free_octet_string(&key);
 514     if (ivec.length)
 515         der_free_octet_string(&ivec);
 516     if (ret) {
 517         der_free_oid(contentType);
 518         der_free_octet_string(content);
 519     }
 520
 521     return ret;
 522 }
 523
 524 /**
 525  * Encrypt end encode EnvelopedData.
 526  *
 527  * Encrypt and encode EnvelopedData. The data is encrypted with a
 528  * random key and the the random key is encrypted with the
 529  * certificates private key. This limits what private key type can be
 530  * used to RSA.
 531  *
 532  * @param context A hx509 context.
 533  * @param flags flags to control the behavior.
 534  *    - HX509_CMS_EV_NO_KU_CHECK - Dont check KU on certificate
 535  *    - HX509_CMS_EV_ALLOW_WEAK - Allow weak crytpo
 536  *    - HX509_CMS_EV_ID_NAME - prefer issuer name and serial number
 537  * @param cert Certificate to encrypt the EnvelopedData encryption key
 538  * with.
 539  * @param data pointer the data to encrypt.
 540  * @param length length of the data that data point to.
 541  * @param encryption_type Encryption cipher to use for the bulk data,
 542  * use NULL to get default.
 543  * @param contentType type of the data that is encrypted
 544  * @param content the output of the function,
 545  * free with der_free_octet_string().
 546  *
 547  * @ingroup hx509_cms
 548  */
 549
 550 int
 551 hx509_cms_envelope_1(hx509_context context,
 552                      int flags,
 553                      hx509_cert cert,
 554                      const void *data,
 555                      size_t length,
 556                      const heim_oid *encryption_type,
 557                      const heim_oid *contentType,
 558                      heim_octet_string *content)
 559 {
 560     KeyTransRecipientInfo *ri;
 561     heim_octet_string ivec;
 562     heim_octet_string key;
 563     hx509_crypto crypto = NULL;
 564     int ret, cmsidflag;
 565     EnvelopedData ed;
 566     size_t size;
 567
 568     memset(&ivec, 0, sizeof(ivec));
 569     memset(&key, 0, sizeof(key));
 570     memset(&ed, 0, sizeof(ed));
 571     memset(content, 0, sizeof(*content));
 572
 573     if (encryption_type == NULL)
 574         encryption_type = &asn1_oid_id_aes_256_cbc;
 575
 576     if ((flags & HX509_CMS_EV_NO_KU_CHECK) == 0) {
 577         ret = _hx509_check_key_usage(context, cert, 1 << 2, TRUE);
 578         if (ret)
 579             goto out;
 580     }
 581
 582     ret = hx509_crypto_init(context, NULL, encryption_type, &crypto);
 583     if (ret)
 584         goto out;
 585
 586     if (flags & HX509_CMS_EV_ALLOW_WEAK)
 587         hx509_crypto_allow_weak(crypto);
 588
 589     ret = hx509_crypto_set_random_key(crypto, &key);
 590     if (ret) {
 591         hx509_set_error_string(context, 0, ret,
 592                                "Create random key for EnvelopedData content");
 593         goto out;
 594     }
 595
 596     ret = hx509_crypto_random_iv(crypto, &ivec);
 597     if (ret) {
 598         hx509_set_error_string(context, 0, ret,
 599                                "Failed to create a random iv");
 600         goto out;
 601     }
 602
 603     ret = hx509_crypto_encrypt(crypto,
 604                                data,
 605                                length,
 606                                &ivec,
 607                                &ed.encryptedContentInfo.encryptedContent);
 608     if (ret) {
 609         hx509_set_error_string(context, 0, ret,
 610                                "Failed to encrypt EnvelopedData content");
 611         goto out;
 612     }
 613
 614     {
 615         AlgorithmIdentifier *enc_alg;
 616         enc_alg = &ed.encryptedContentInfo.contentEncryptionAlgorithm;
 617         ret = der_copy_oid(encryption_type, &enc_alg->algorithm);
 618         if (ret) {
 619             hx509_set_error_string(context, 0, ret,
 620                                    "Failed to set crypto oid "
 621                                    "for EnvelopedData");
 622             goto out;
 623         }
 624         ALLOC(enc_alg->parameters, 1);
 625         if (enc_alg->parameters == NULL) {
 626             ret = ENOMEM;
 627             hx509_set_error_string(context, 0, ret,
 628                                    "Failed to allocate crypto paramaters "
 629                                    "for EnvelopedData");
 630             goto out;
 631         }
 632
 633         ret = hx509_crypto_get_params(context,
 634                                       crypto,
 635                                       &ivec,
 636                                       enc_alg->parameters);
 637         if (ret) {
 638             goto out;
 639         }
 640     }
 641
 642     ALLOC_SEQ(&ed.recipientInfos, 1);
 643     if (ed.recipientInfos.val == NULL) {
 644         ret = ENOMEM;
 645         hx509_set_error_string(context, 0, ret,
 646                                "Failed to allocate recipients info "
 647                                "for EnvelopedData");
 648         goto out;
 649     }
 650
 651     ri = &ed.recipientInfos.val[0];
 652
 653     if (flags & HX509_CMS_EV_ID_NAME) {
 654         ri->version = 0;
 655         cmsidflag = CMS_ID_NAME;
 656     } else {
 657         ri->version = 2;
 658         cmsidflag = CMS_ID_SKI;
 659     }
 660
 661     ret = fill_CMSIdentifier(cert, cmsidflag, &ri->rid);
 662     if (ret) {
 663         hx509_set_error_string(context, 0, ret,
 664                                "Failed to set CMS identifier info "
 665                                "for EnvelopedData");
 666         goto out;
 667     }
 668
 669     ret = hx509_cert_public_encrypt(context,
 670                                      &key, cert,
 671                                      &ri->keyEncryptionAlgorithm.algorithm,
 672                                      &ri->encryptedKey);
 673     if (ret) {
 674         hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
 675                                "Failed to encrypt transport key for "
 676                                "EnvelopedData");
 677         goto out;
 678     }
 679
 680     /*
 681      *
 682      */
 683
 684     ed.version = 0;
 685     ed.originatorInfo = NULL;
 686
 687     ret = der_copy_oid(contentType, &ed.encryptedContentInfo.contentType);
 688     if (ret) {
 689         hx509_set_error_string(context, 0, ret,
 690                                "Failed to copy content oid for "
 691                                "EnvelopedData");
 692         goto out;
 693     }
 694
 695     ed.unprotectedAttrs = NULL;
 696
 697     ASN1_MALLOC_ENCODE(EnvelopedData, content->data, content->length,
 698                        &ed, &size, ret);
 699     if (ret) {
 700         hx509_set_error_string(context, 0, ret,
 701                                "Failed to encode EnvelopedData");
 702         goto out;
 703     }
 704     if (size != content->length)
 705         _hx509_abort("internal ASN.1 encoder error");
 706
 707 out:
 708     if (crypto)
 709         hx509_crypto_destroy(crypto);
 710     if (ret)
 711         der_free_octet_string(content);
 712     der_free_octet_string(&key);
 713     der_free_octet_string(&ivec);
 714     free_EnvelopedData(&ed);
 715
 716     return ret;
 717 }
 718
 719 static int
 720 any_to_certs(hx509_context context, const SignedData *sd, hx509_certs certs)
 721 {
 722     int ret;
 723     size_t i;
 724
 725     if (sd->certificates == NULL)
 726         return 0;
 727
 728     for (i = 0; i < sd->certificates->len; i++) {
 729         hx509_cert c;
 730
 731         ret = hx509_cert_init_data(context,
 732                                    sd->certificates->val[i].data,
 733                                    sd->certificates->val[i].length,
 734                                    &c);
 735         if (ret)
 736             return ret;
 737         ret = hx509_certs_add(context, certs, c);
 738         hx509_cert_free(c);
 739         if (ret)
 740             return ret;
 741     }
 742
 743     return 0;
 744 }
 745
 746 static const Attribute *
 747 find_attribute(const CMSAttributes *attr, const heim_oid *oid)
 748 {
 749     size_t i;
 750     for (i = 0; i < attr->len; i++)
 751         if (der_heim_oid_cmp(&attr->val[i].type, oid) == 0)
 752             return &attr->val[i];
 753     return NULL;
 754 }
 755
 756 /**
 757  * Decode SignedData and verify that the signature is correct.
 758  *
 759  * @param context A hx509 context.
 760  * @param ctx a hx509 verify context.
 761  * @param flags to control the behaivor of the function.
 762  *    - HX509_CMS_VS_NO_KU_CHECK - Don't check KeyUsage
 763  *    - HX509_CMS_VS_ALLOW_DATA_OID_MISMATCH - allow oid mismatch
 764  *    - HX509_CMS_VS_ALLOW_ZERO_SIGNER - no signer, see below.
 765  * @param data pointer to CMS SignedData encoded data.
 766  * @param length length of the data that data point to.
 767  * @param signedContent external data used for signature.
 768  * @param pool certificate pool to build certificates paths.
 769  * @param contentType free with der_free_oid().
 770  * @param content the output of the function, free with
 771  * der_free_octet_string().
 772  * @param signer_certs list of the cerficates used to sign this
 773  * request, free with hx509_certs_free().
 774  *
 775  * @ingroup hx509_cms
 776  */
 777
 778 int
 779 hx509_cms_verify_signed(hx509_context context,
 780                         hx509_verify_ctx ctx,
 781                         unsigned int flags,
 782                         const void *data,
 783                         size_t length,
 784                         const heim_octet_string *signedContent,
 785                         hx509_certs pool,
 786                         heim_oid *contentType,
 787                         heim_octet_string *content,
 788                         hx509_certs *signer_certs)
 789 {
 790     SignerInfo *signer_info;
 791     hx509_cert cert = NULL;
 792     hx509_certs certs = NULL;
 793     SignedData sd;
 794     size_t size;
 795     int ret, found_valid_sig;
 796     size_t i;
 797
 798     *signer_certs = NULL;
 799     content->data = NULL;
 800     content->length = 0;
 801     contentType->length = 0;
 802     contentType->components = NULL;
 803
 804     memset(&sd, 0, sizeof(sd));
 805
 806     ret = decode_SignedData(data, length, &sd, &size);
 807     if (ret) {
 808         hx509_set_error_string(context, 0, ret,
 809                                "Failed to decode SignedData");
 810         goto out;
 811     }
 812
 813     if (sd.encapContentInfo.eContent == NULL && signedContent == NULL) {
 814         ret = HX509_CMS_NO_DATA_AVAILABLE;
 815         hx509_set_error_string(context, 0, ret,
 816                                "No content data in SignedData");
 817         goto out;
 818     }
 819     if (sd.encapContentInfo.eContent && signedContent) {
 820         ret = HX509_CMS_NO_DATA_AVAILABLE;
 821         hx509_set_error_string(context, 0, ret,
 822                                "Both external and internal SignedData");
 823         goto out;
 824     }
 825
 826     if (sd.encapContentInfo.eContent)
 827         ret = der_copy_octet_string(sd.encapContentInfo.eContent, content);
 828     else
 829         ret = der_copy_octet_string(signedContent, content);
 830     if (ret) {
 831         hx509_set_error_string(context, 0, ret, "malloc: out of memory");
 832         goto out;
 833     }
 834
 835     ret = hx509_certs_init(context, "MEMORY:cms-cert-buffer",
 836                            0, NULL, &certs);
 837     if (ret)
 838         goto out;
 839
 840     ret = hx509_certs_init(context, "MEMORY:cms-signer-certs",
 841                            0, NULL, signer_certs);
 842     if (ret)
 843         goto out;
 844
 845     /* XXX Check CMS version */
 846
 847     ret = any_to_certs(context, &sd, certs);
 848     if (ret)
 849         goto out;
 850
 851     if (pool) {
 852         ret = hx509_certs_merge(context, certs, pool);
 853         if (ret)
 854             goto out;
 855     }
 856
 857     for (found_valid_sig = 0, i = 0; i < sd.signerInfos.len; i++) {
 858         heim_octet_string signed_data;
 859         const heim_oid *match_oid;
 860         heim_oid decode_oid;
 861
 862         signer_info = &sd.signerInfos.val[i];
 863         match_oid = NULL;
 864
 865         if (signer_info->signature.length == 0) {
 866             ret = HX509_CMS_MISSING_SIGNER_DATA;
 867             hx509_set_error_string(context, 0, ret,
 868                                    "SignerInfo %d in SignedData "
 869                                    "missing sigature", i);
 870             continue;
 871         }
 872
 873         ret = find_CMSIdentifier(context, &signer_info->sid, certs,
 874                                  _hx509_verify_get_time(ctx), &cert,
 875                                  HX509_QUERY_KU_DIGITALSIGNATURE);
 876         if (ret) {
 877             /**
 878              * If HX509_CMS_VS_NO_KU_CHECK is set, allow more liberal
 879              * search for matching certificates by not considering
 880              * KeyUsage bits on the certificates.
 881              */
 882             if ((flags & HX509_CMS_VS_NO_KU_CHECK) == 0)
 883                 continue;
 884
 885             ret = find_CMSIdentifier(context, &signer_info->sid, certs,
 886                                      _hx509_verify_get_time(ctx), &cert,
 887                                      0);
 888             if (ret)
 889                 continue;
 890
 891         }
 892
 893         if (signer_info->signedAttrs) {
 894             const Attribute *attr;
 895
 896             CMSAttributes sa;
 897             heim_octet_string os;
 898
 899             sa.val = signer_info->signedAttrs->val;
 900             sa.len = signer_info->signedAttrs->len;
 901
 902             /* verify that sigature exists */
 903             attr = find_attribute(&sa, &asn1_oid_id_pkcs9_messageDigest);
 904             if (attr == NULL) {
 905                 ret = HX509_CRYPTO_SIGNATURE_MISSING;
 906                 hx509_set_error_string(context, 0, ret,
 907                                        "SignerInfo have signed attributes "
 908                                        "but messageDigest (signature) "
 909                                        "is missing");
 910                 goto next_sigature;
 911             }
 912             if (attr->value.len != 1) {
 913                 ret = HX509_CRYPTO_SIGNATURE_MISSING;
 914                 hx509_set_error_string(context, 0, ret,
 915                                        "SignerInfo have more then one "
 916                                        "messageDigest (signature)");
 917                 goto next_sigature;
 918             }
 919
 920             ret = decode_MessageDigest(attr->value.val[0].data,
 921                                        attr->value.val[0].length,
 922                                        &os,
 923                                        &size);
 924             if (ret) {
 925                 hx509_set_error_string(context, 0, ret,
 926                                        "Failed to decode "
 927                                        "messageDigest (signature)");
 928                 goto next_sigature;
 929             }
 930
 931             ret = _hx509_verify_signature(context,
 932                                           NULL,
 933                                           &signer_info->digestAlgorithm,
 934                                           content,
 935                                           &os);
 936             der_free_octet_string(&os);
 937             if (ret) {
 938                 hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
 939                                        "Failed to verify messageDigest");
 940                 goto next_sigature;
 941             }
 942
 943             /*
 944              * Fetch content oid inside signedAttrs or set it to
 945              * id-pkcs7-data.
 946              */
 947             attr = find_attribute(&sa, &asn1_oid_id_pkcs9_contentType);
 948             if (attr == NULL) {
 949                 match_oid = &asn1_oid_id_pkcs7_data;
 950             } else {
 951                 if (attr->value.len != 1) {
 952                     ret = HX509_CMS_DATA_OID_MISMATCH;
 953                     hx509_set_error_string(context, 0, ret,
 954                                            "More then one oid in signedAttrs");
 955                     goto next_sigature;
 956
 957                 }
 958                 ret = decode_ContentType(attr->value.val[0].data,
 959                                          attr->value.val[0].length,
 960                                          &decode_oid,
 961                                          &size);
 962                 if (ret) {
 963                     hx509_set_error_string(context, 0, ret,
 964                                            "Failed to decode "
 965                                            "oid in signedAttrs");
 966                     goto next_sigature;
 967                 }
 968                 match_oid = &decode_oid;
 969             }
 970
 971             ASN1_MALLOC_ENCODE(CMSAttributes,
 972                                signed_data.data,
 973                                signed_data.length,
 974                                &sa,
 975                                &size, ret);
 976             if (ret) {
 977                 if (match_oid == &decode_oid)
 978                     der_free_oid(&decode_oid);
 979                 hx509_clear_error_string(context);
 980                 goto next_sigature;
 981             }
 982             if (size != signed_data.length)
 983                 _hx509_abort("internal ASN.1 encoder error");
 984
 985         } else {
 986             signed_data.data = content->data;
 987             signed_data.length = content->length;
 988             match_oid = &asn1_oid_id_pkcs7_data;
 989         }
 990
 991         /**
 992          * If HX509_CMS_VS_ALLOW_DATA_OID_MISMATCH, allow
 993          * encapContentInfo mismatch with the oid in signedAttributes
 994          * (or if no signedAttributes where use, pkcs7-data oid).
 995          * This is only needed to work with broken CMS implementations
 996          * that doesn't follow CMS signedAttributes rules.
 997          */
 998
 999         if (der_heim_oid_cmp(match_oid, &sd.encapContentInfo.eContentType) &&
1000             (flags & HX509_CMS_VS_ALLOW_DATA_OID_MISMATCH) == 0) {
1001             ret = HX509_CMS_DATA_OID_MISMATCH;
1002             hx509_set_error_string(context, 0, ret,
1003                                    "Oid in message mismatch from the expected");
1004         }
1005         if (match_oid == &decode_oid)
1006             der_free_oid(&decode_oid);
1007
1008         if (ret == 0) {
1009             ret = hx509_verify_signature(context,
1010                                          cert,
1011                                          &signer_info->signatureAlgorithm,
1012                                          &signed_data,
1013                                          &signer_info->signature);
1014             if (ret)
1015                 hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
1016                                        "Failed to verify signature in "
1017                                        "CMS SignedData");
1018         }
1019         if (signer_info->signedAttrs)
1020             free(signed_data.data);
1021         if (ret)
1022             goto next_sigature;
1023
1024         /**
1025          * If HX509_CMS_VS_NO_VALIDATE flags is set, do not verify the
1026          * signing certificates and leave that up to the caller.
1027          */
1028
1029         if ((flags & HX509_CMS_VS_NO_VALIDATE) == 0) {
1030             ret = hx509_verify_path(context, ctx, cert, certs);
1031             if (ret)
1032                 goto next_sigature;
1033         }
1034
1035         ret = hx509_certs_add(context, *signer_certs, cert);
1036         if (ret)
1037             goto next_sigature;
1038
1039         found_valid_sig++;
1040
1041     next_sigature:
1042         if (cert)
1043             hx509_cert_free(cert);
1044         cert = NULL;
1045     }
1046     /**
1047      * If HX509_CMS_VS_ALLOW_ZERO_SIGNER is set, allow empty
1048      * SignerInfo (no signatures). If SignedData have no signatures,
1049      * the function will return 0 with signer_certs set to NULL. Zero
1050      * signers is allowed by the standard, but since its only useful
1051      * in corner cases, it make into a flag that the caller have to
1052      * turn on.
1053      */
1054     if (sd.signerInfos.len == 0 && (flags & HX509_CMS_VS_ALLOW_ZERO_SIGNER)) {
1055         if (*signer_certs)
1056             hx509_certs_free(signer_certs);
1057     } else if (found_valid_sig == 0) {
1058         if (ret == 0) {
1059             ret = HX509_CMS_SIGNER_NOT_FOUND;
1060             hx509_set_error_string(context, 0, ret,
1061                                    "No signers where found");
1062         }
1063         goto out;
1064     }
1065
1066     ret = der_copy_oid(&sd.encapContentInfo.eContentType, contentType);
1067     if (ret) {
1068         hx509_clear_error_string(context);
1069         goto out;
1070     }
1071
1072 out:
1073     free_SignedData(&sd);
1074     if (certs)
1075         hx509_certs_free(&certs);
1076     if (ret) {
1077         if (content->data)
1078             der_free_octet_string(content);
1079         if (*signer_certs)
1080             hx509_certs_free(signer_certs);
1081         der_free_oid(contentType);
1082         der_free_octet_string(content);
1083     }
1084
1085     return ret;
1086 }
1087
1088 static int
1089 add_one_attribute(Attribute **attr,
1090                   unsigned int *len,
1091                   const heim_oid *oid,
1092                   heim_octet_string *data)
1093 {
1094     void *d;
1095     int ret;
1096
1097     d = realloc(*attr, sizeof((*attr)[0]) * (*len + 1));
1098     if (d == NULL)
1099         return ENOMEM;
1100     (*attr) = d;
1101
1102     ret = der_copy_oid(oid, &(*attr)[*len].type);
1103     if (ret)
1104         return ret;
1105
1106     ALLOC_SEQ(&(*attr)[*len].value, 1);
1107     if ((*attr)[*len].value.val == NULL) {
1108         der_free_oid(&(*attr)[*len].type);
1109         return ENOMEM;
1110     }
1111
1112     (*attr)[*len].value.val[0].data = data->data;
1113     (*attr)[*len].value.val[0].length = data->length;
1114
1115     *len += 1;
1116
1117     return 0;
1118 }
1119
1120 /**
1121  * Decode SignedData and verify that the signature is correct.
1122  *
1123  * @param context A hx509 context.
1124  * @param flags
1125  * @param eContentType the type of the data.
1126  * @param data data to sign
1127  * @param length length of the data that data point to.
1128  * @param digest_alg digest algorithm to use, use NULL to get the
1129  * default or the peer determined algorithm.
1130  * @param cert certificate to use for sign the data.
1131  * @param peer info about the peer the message to send the message to,
1132  * like what digest algorithm to use.
1133  * @param anchors trust anchors that the client will use, used to
1134  * polulate the certificates included in the message
1135  * @param pool certificates to use in try to build the path to the
1136  * trust anchors.
1137  * @param signed_data the output of the function, free with
1138  * der_free_octet_string().
1139  *
1140  * @ingroup hx509_cms
1141  */
1142
1143 int
1144 hx509_cms_create_signed_1(hx509_context context,
1145                           int flags,
1146                           const heim_oid *eContentType,
1147                           const void *data, size_t length,
1148                           const AlgorithmIdentifier *digest_alg,
1149                           hx509_cert cert,
1150                           hx509_peer_info peer,
1151                           hx509_certs anchors,
1152                           hx509_certs pool,
1153                           heim_octet_string *signed_data)
1154 {
1155     hx509_certs certs;
1156     int ret = 0;
1157
1158     signed_data->data = NULL;
1159     signed_data->length = 0;
1160
1161     ret = hx509_certs_init(context, "MEMORY:certs", 0, NULL, &certs);
1162     if (ret)
1163         return ret;
1164     ret = hx509_certs_add(context, certs, cert);
1165     if (ret)
1166         goto out;
1167
1168     ret = hx509_cms_create_signed(context, flags, eContentType, data, length,
1169                                   digest_alg, certs, peer, anchors, pool,
1170                                   signed_data);
1171
1172  out:
1173     hx509_certs_free(&certs);
1174     return ret;
1175 }
1176
1177 struct sigctx {
1178     SignedData sd;
1179     const AlgorithmIdentifier *digest_alg;
1180     const heim_oid *eContentType;
1181     heim_octet_string content;
1182     hx509_peer_info peer;
1183     int cmsidflag;
1184     int leafonly;
1185     hx509_certs certs;
1186     hx509_certs anchors;
1187     hx509_certs pool;
1188 };
1189
1190 static int
1191 sig_process(hx509_context context, void *ctx, hx509_cert cert)
1192 {
1193     struct sigctx *sigctx = ctx;
1194     heim_octet_string buf, sigdata = { 0, NULL };
1195     SignerInfo *signer_info = NULL;
1196     AlgorithmIdentifier digest;
1197     size_t size;
1198     void *ptr;
1199     int ret;
1200     SignedData *sd = &sigctx->sd;
1201     hx509_path path;
1202
1203     memset(&digest, 0, sizeof(digest));
1204     memset(&path, 0, sizeof(path));
1205
1206     if (_hx509_cert_private_key(cert) == NULL) {
1207         hx509_set_error_string(context, 0, HX509_PRIVATE_KEY_MISSING,
1208                                "Private key missing for signing");
1209         return HX509_PRIVATE_KEY_MISSING;
1210     }
1211
1212     if (sigctx->digest_alg) {
1213         ret = copy_AlgorithmIdentifier(sigctx->digest_alg, &digest);
1214         if (ret)
1215             hx509_clear_error_string(context);
1216     } else {
1217         ret = hx509_crypto_select(context, HX509_SELECT_DIGEST,
1218                                   _hx509_cert_private_key(cert),
1219                                   sigctx->peer, &digest);
1220     }
1221     if (ret)
1222         goto out;
1223
1224     /*
1225      * Allocate on more signerInfo and do the signature processing
1226      */
1227
1228     ptr = realloc(sd->signerInfos.val,
1229                   (sd->signerInfos.len + 1) * sizeof(sd->signerInfos.val[0]));
1230     if (ptr == NULL) {
1231         ret = ENOMEM;
1232         goto out;
1233     }
1234     sd->signerInfos.val = ptr;
1235
1236     signer_info = &sd->signerInfos.val[sd->signerInfos.len];
1237
1238     memset(signer_info, 0, sizeof(*signer_info));
1239
1240     signer_info->version = 1;
1241
1242     ret = fill_CMSIdentifier(cert, sigctx->cmsidflag, &signer_info->sid);
1243     if (ret) {
1244         hx509_clear_error_string(context);
1245         goto out;
1246     }
1247
1248     signer_info->signedAttrs = NULL;
1249     signer_info->unsignedAttrs = NULL;
1250
1251     ret = copy_AlgorithmIdentifier(&digest, &signer_info->digestAlgorithm);
1252     if (ret) {
1253         hx509_clear_error_string(context);
1254         goto out;
1255     }
1256
1257     /*
1258      * If it isn't pkcs7-data send signedAttributes
1259      */
1260
1261     if (der_heim_oid_cmp(sigctx->eContentType, &asn1_oid_id_pkcs7_data) != 0) {
1262         CMSAttributes sa;
1263         heim_octet_string sig;
1264
1265         ALLOC(signer_info->signedAttrs, 1);
1266         if (signer_info->signedAttrs == NULL) {
1267             ret = ENOMEM;
1268             goto out;
1269         }
1270
1271         ret = _hx509_create_signature(context,
1272                                       NULL,
1273                                       &digest,
1274                                       &sigctx->content,
1275                                       NULL,
1276                                       &sig);
1277         if (ret)
1278             goto out;
1279
1280         ASN1_MALLOC_ENCODE(MessageDigest,
1281                            buf.data,
1282                            buf.length,
1283                            &sig,
1284                            &size,
1285                            ret);
1286         der_free_octet_string(&sig);
1287         if (ret) {
1288             hx509_clear_error_string(context);
1289             goto out;
1290         }
1291         if (size != buf.length)
1292             _hx509_abort("internal ASN.1 encoder error");
1293
1294         ret = add_one_attribute(&signer_info->signedAttrs->val,
1295                                 &signer_info->signedAttrs->len,
1296                                 &asn1_oid_id_pkcs9_messageDigest,
1297                                 &buf);
1298         if (ret) {
1299             free(buf.data);
1300             hx509_clear_error_string(context);
1301             goto out;
1302         }
1303
1304
1305         ASN1_MALLOC_ENCODE(ContentType,
1306                            buf.data,
1307                            buf.length,
1308                            sigctx->eContentType,
1309                            &size,
1310                            ret);
1311         if (ret)
1312             goto out;
1313         if (size != buf.length)
1314             _hx509_abort("internal ASN.1 encoder error");
1315
1316         ret = add_one_attribute(&signer_info->signedAttrs->val,
1317                                 &signer_info->signedAttrs->len,
1318                                 &asn1_oid_id_pkcs9_contentType,
1319                                 &buf);
1320         if (ret) {
1321             free(buf.data);
1322             hx509_clear_error_string(context);
1323             goto out;
1324         }
1325
1326         sa.val = signer_info->signedAttrs->val;
1327         sa.len = signer_info->signedAttrs->len;
1328
1329         ASN1_MALLOC_ENCODE(CMSAttributes,
1330                            sigdata.data,
1331                            sigdata.length,
1332                            &sa,
1333                            &size,
1334                            ret);
1335         if (ret) {
1336             hx509_clear_error_string(context);
1337             goto out;
1338         }
1339         if (size != sigdata.length)
1340             _hx509_abort("internal ASN.1 encoder error");
1341     } else {
1342         sigdata.data = sigctx->content.data;
1343         sigdata.length = sigctx->content.length;
1344     }
1345
1346     {
1347         AlgorithmIdentifier sigalg;
1348
1349         ret = hx509_crypto_select(context, HX509_SELECT_PUBLIC_SIG,
1350                                   _hx509_cert_private_key(cert), sigctx->peer,
1351                                   &sigalg);
1352         if (ret)
1353             goto out;
1354
1355         ret = _hx509_create_signature(context,
1356                                       _hx509_cert_private_key(cert),
1357                                       &sigalg,
1358                                       &sigdata,
1359                                       &signer_info->signatureAlgorithm,
1360                                       &signer_info->signature);
1361         free_AlgorithmIdentifier(&sigalg);
1362         if (ret)
1363             goto out;
1364     }
1365
1366     sigctx->sd.signerInfos.len++;
1367     signer_info = NULL;
1368
1369     /*
1370      * Provide best effort path
1371      */
1372     if (sigctx->certs) {
1373         unsigned int i;
1374
1375         if (sigctx->pool && sigctx->leafonly == 0) {
1376             _hx509_calculate_path(context,
1377                                   HX509_CALCULATE_PATH_NO_ANCHOR,
1378                                   time(NULL),
1379                                   sigctx->anchors,
1380                                   0,
1381                                   cert,
1382                                   sigctx->pool,
1383                                   &path);
1384         } else
1385             _hx509_path_append(context, &path, cert);
1386
1387         for (i = 0; i < path.len; i++) {
1388             /* XXX remove dups */
1389             ret = hx509_certs_add(context, sigctx->certs, path.val[i]);
1390             if (ret) {
1391                 hx509_clear_error_string(context);
1392                 goto out;
1393             }
1394         }
1395     }
1396
1397  out:
1398     if (signer_info)
1399         free_SignerInfo(signer_info);
1400     if (sigdata.data != sigctx->content.data)
1401         der_free_octet_string(&sigdata);
1402     _hx509_path_free(&path);
1403     free_AlgorithmIdentifier(&digest);
1404
1405     return ret;
1406 }
1407
1408 static int
1409 cert_process(hx509_context context, void *ctx, hx509_cert cert)
1410 {
1411     struct sigctx *sigctx = ctx;
1412     const unsigned int i = sigctx->sd.certificates->len;
1413     void *ptr;
1414     int ret;
1415
1416     ptr = realloc(sigctx->sd.certificates->val,
1417                   (i + 1) * sizeof(sigctx->sd.certificates->val[0]));
1418     if (ptr == NULL)
1419         return ENOMEM;
1420     sigctx->sd.certificates->val = ptr;
1421
1422     ret = hx509_cert_binary(context, cert,
1423                             &sigctx->sd.certificates->val[i]);
1424     if (ret == 0)
1425         sigctx->sd.certificates->len++;
1426
1427     return ret;
1428 }
1429
1430 static int
1431 cmp_AlgorithmIdentifier(const AlgorithmIdentifier *p, const AlgorithmIdentifier *q)
1432 {
1433     return der_heim_oid_cmp(&p->algorithm, &q->algorithm);
1434 }
1435
1436 int
1437 hx509_cms_create_signed(hx509_context context,
1438                         int flags,
1439                         const heim_oid *eContentType,
1440                         const void *data, size_t length,
1441                         const AlgorithmIdentifier *digest_alg,
1442                         hx509_certs certs,
1443                         hx509_peer_info peer,
1444                         hx509_certs anchors,
1445                         hx509_certs pool,
1446                         heim_octet_string *signed_data)
1447 {
1448     unsigned int i, j;
1449     hx509_name name;
1450     int ret;
1451     size_t size;
1452     struct sigctx sigctx;
1453
1454     memset(&sigctx, 0, sizeof(sigctx));
1455     memset(&name, 0, sizeof(name));
1456
1457     if (eContentType == NULL)
1458         eContentType = &asn1_oid_id_pkcs7_data;
1459
1460     sigctx.digest_alg = digest_alg;
1461     sigctx.content.data = rk_UNCONST(data);
1462     sigctx.content.length = length;
1463     sigctx.eContentType = eContentType;
1464     sigctx.peer = peer;
1465     /**
1466      * Use HX509_CMS_SIGNATURE_ID_NAME to preferred use of issuer name
1467      * and serial number if possible. Otherwise subject key identifier
1468      * will preferred.
1469      */
1470     if (flags & HX509_CMS_SIGNATURE_ID_NAME)
1471         sigctx.cmsidflag = CMS_ID_NAME;
1472     else
1473         sigctx.cmsidflag = CMS_ID_SKI;
1474
1475     /**
1476      * Use HX509_CMS_SIGNATURE_LEAF_ONLY to only request leaf
1477      * certificates to be added to the SignedData.
1478      */
1479     sigctx.leafonly = (flags & HX509_CMS_SIGNATURE_LEAF_ONLY) ? 1 : 0;
1480
1481     /**
1482      * Use HX509_CMS_NO_CERTS to make the SignedData contain no
1483      * certificates, overrides HX509_CMS_SIGNATURE_LEAF_ONLY.
1484      */
1485
1486     if ((flags & HX509_CMS_SIGNATURE_NO_CERTS) == 0) {
1487         ret = hx509_certs_init(context, "MEMORY:certs", 0, NULL, &sigctx.certs);
1488         if (ret)
1489             return ret;
1490     }
1491
1492     sigctx.anchors = anchors;
1493     sigctx.pool = pool;
1494
1495     sigctx.sd.version = CMSVersion_v3;
1496
1497     der_copy_oid(eContentType, &sigctx.sd.encapContentInfo.eContentType);
1498
1499     /**
1500      * Use HX509_CMS_SIGNATURE_DETACHED to create detached signatures.
1501      */
1502     if ((flags & HX509_CMS_SIGNATURE_DETACHED) == 0) {
1503         ALLOC(sigctx.sd.encapContentInfo.eContent, 1);
1504         if (sigctx.sd.encapContentInfo.eContent == NULL) {
1505             hx509_clear_error_string(context);
1506             ret = ENOMEM;
1507             goto out;
1508         }
1509
1510         sigctx.sd.encapContentInfo.eContent->data = malloc(length);
1511         if (sigctx.sd.encapContentInfo.eContent->data == NULL) {
1512             hx509_clear_error_string(context);
1513             ret = ENOMEM;
1514             goto out;
1515         }
1516         memcpy(sigctx.sd.encapContentInfo.eContent->data, data, length);
1517         sigctx.sd.encapContentInfo.eContent->length = length;
1518     }
1519
1520     /**
1521      * Use HX509_CMS_SIGNATURE_NO_SIGNER to create no sigInfo (no
1522      * signatures).
1523      */
1524     if ((flags & HX509_CMS_SIGNATURE_NO_SIGNER) == 0) {
1525         ret = hx509_certs_iter_f(context, certs, sig_process, &sigctx);
1526         if (ret)
1527             goto out;
1528     }
1529
1530     if (sigctx.sd.signerInfos.len) {
1531
1532         /*
1533          * For each signerInfo, collect all different digest types.
1534          */
1535         for (i = 0; i < sigctx.sd.signerInfos.len; i++) {
1536             AlgorithmIdentifier *di =
1537                 &sigctx.sd.signerInfos.val[i].digestAlgorithm;
1538
1539             for (j = 0; j < sigctx.sd.digestAlgorithms.len; j++)
1540                 if (cmp_AlgorithmIdentifier(di, &sigctx.sd.digestAlgorithms.val[j]) == 0)
1541                     break;
1542             if (j == sigctx.sd.digestAlgorithms.len) {
1543                 ret = add_DigestAlgorithmIdentifiers(&sigctx.sd.digestAlgorithms, di);
1544                 if (ret) {
1545                     hx509_clear_error_string(context);
1546                     goto out;
1547                 }
1548             }
1549         }
1550     }
1551
1552     /*
1553      * Add certs we think are needed, build as part of sig_process
1554      */
1555     if (sigctx.certs) {
1556         ALLOC(sigctx.sd.certificates, 1);
1557         if (sigctx.sd.certificates == NULL) {
1558             hx509_clear_error_string(context);
1559             ret = ENOMEM;
1560             goto out;
1561         }
1562
1563         ret = hx509_certs_iter_f(context, sigctx.certs, cert_process, &sigctx);
1564         if (ret)
1565             goto out;
1566     }
1567
1568     ASN1_MALLOC_ENCODE(SignedData,
1569                        signed_data->data, signed_data->length,
1570                        &sigctx.sd, &size, ret);
1571     if (ret) {
1572         hx509_clear_error_string(context);
1573         goto out;
1574     }
1575     if (signed_data->length != size)
1576         _hx509_abort("internal ASN.1 encoder error");
1577
1578 out:
1579     hx509_certs_free(&sigctx.certs);
1580     free_SignedData(&sigctx.sd);
1581
1582     return ret;
1583 }
1584
1585 int
1586 hx509_cms_decrypt_encrypted(hx509_context context,
1587                             hx509_lock lock,
1588                             const void *data,
1589                             size_t length,
1590                             heim_oid *contentType,
1591                             heim_octet_string *content)
1592 {
1593     heim_octet_string cont;
1594     CMSEncryptedData ed;
1595     AlgorithmIdentifier *ai;
1596     int ret;
1597
1598     memset(content, 0, sizeof(*content));
1599     memset(&cont, 0, sizeof(cont));
1600
1601     ret = decode_CMSEncryptedData(data, length, &ed, NULL);
1602     if (ret) {
1603         hx509_set_error_string(context, 0, ret,
1604                                "Failed to decode CMSEncryptedData");
1605         return ret;
1606     }
1607
1608     if (ed.encryptedContentInfo.encryptedContent == NULL) {
1609         ret = HX509_CMS_NO_DATA_AVAILABLE;
1610         hx509_set_error_string(context, 0, ret,
1611                                "No content in EncryptedData");
1612         goto out;
1613     }
1614
1615     ret = der_copy_oid(&ed.encryptedContentInfo.contentType, contentType);
1616     if (ret) {
1617         hx509_clear_error_string(context);
1618         goto out;
1619     }
1620
1621     ai = &ed.encryptedContentInfo.contentEncryptionAlgorithm;
1622     if (ai->parameters == NULL) {
1623         ret = HX509_ALG_NOT_SUPP;
1624         hx509_clear_error_string(context);
1625         goto out;
1626     }
1627
1628     ret = _hx509_pbe_decrypt(context,
1629                              lock,
1630                              ai,
1631                              ed.encryptedContentInfo.encryptedContent,
1632                              &cont);
1633     if (ret)
1634         goto out;
1635
1636     *content = cont;
1637
1638 out:
1639     if (ret) {
1640         if (cont.data)
1641             free(cont.data);
1642     }
1643     free_CMSEncryptedData(&ed);
1644     return ret;
1645 }