crypto/pkcs7/pk7_doit.c

   1 /* crypto/pkcs7/pk7_doit.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include <openssl/rand.h>
  62 #include <openssl/objects.h>
  63 #include <openssl/x509.h>
  64 #include <openssl/x509v3.h>
  65 #include <openssl/err.h>
  66
  67 static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype,
  68                          void *value);
  69 static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid);
  70
  71 static int PKCS7_type_is_other(PKCS7 *p7)
  72 {
  73     int isOther = 1;
  74
  75     int nid = OBJ_obj2nid(p7->type);
  76
  77     switch (nid) {
  78     case NID_pkcs7_data:
  79     case NID_pkcs7_signed:
  80     case NID_pkcs7_enveloped:
  81     case NID_pkcs7_signedAndEnveloped:
  82     case NID_pkcs7_digest:
  83     case NID_pkcs7_encrypted:
  84         isOther = 0;
  85         break;
  86     default:
  87         isOther = 1;
  88     }
  89
  90     return isOther;
  91
  92 }
  93
  94 static ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7)
  95 {
  96     if (PKCS7_type_is_data(p7))
  97         return p7->d.data;
  98     if (PKCS7_type_is_other(p7) && p7->d.other
  99         && (p7->d.other->type == V_ASN1_OCTET_STRING))
 100         return p7->d.other->value.octet_string;
 101     return NULL;
 102 }
 103
 104 static int PKCS7_bio_add_digest(BIO **pbio, X509_ALGOR *alg)
 105 {
 106     BIO *btmp;
 107     const EVP_MD *md;
 108     if ((btmp = BIO_new(BIO_f_md())) == NULL) {
 109         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, ERR_R_BIO_LIB);
 110         goto err;
 111     }
 112
 113     md = EVP_get_digestbyobj(alg->algorithm);
 114     if (md == NULL) {
 115         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, PKCS7_R_UNKNOWN_DIGEST_TYPE);
 116         goto err;
 117     }
 118
 119     BIO_set_md(btmp, md);
 120     if (*pbio == NULL)
 121         *pbio = btmp;
 122     else if (!BIO_push(*pbio, btmp)) {
 123         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, ERR_R_BIO_LIB);
 124         goto err;
 125     }
 126     btmp = NULL;
 127
 128     return 1;
 129
 130  err:
 131     BIO_free(btmp);
 132     return 0;
 133
 134 }
 135
 136 static int pkcs7_encode_rinfo(PKCS7_RECIP_INFO *ri,
 137                               unsigned char *key, int keylen)
 138 {
 139     EVP_PKEY_CTX *pctx = NULL;
 140     EVP_PKEY *pkey = NULL;
 141     unsigned char *ek = NULL;
 142     int ret = 0;
 143     size_t eklen;
 144
 145     pkey = X509_get_pubkey(ri->cert);
 146
 147     if (!pkey)
 148         return 0;
 149
 150     pctx = EVP_PKEY_CTX_new(pkey, NULL);
 151     if (!pctx)
 152         return 0;
 153
 154     if (EVP_PKEY_encrypt_init(pctx) <= 0)
 155         goto err;
 156
 157     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_ENCRYPT,
 158                           EVP_PKEY_CTRL_PKCS7_ENCRYPT, 0, ri) <= 0) {
 159         PKCS7err(PKCS7_F_PKCS7_ENCODE_RINFO, PKCS7_R_CTRL_ERROR);
 160         goto err;
 161     }
 162
 163     if (EVP_PKEY_encrypt(pctx, NULL, &eklen, key, keylen) <= 0)
 164         goto err;
 165
 166     ek = OPENSSL_malloc(eklen);
 167
 168     if (ek == NULL) {
 169         PKCS7err(PKCS7_F_PKCS7_ENCODE_RINFO, ERR_R_MALLOC_FAILURE);
 170         goto err;
 171     }
 172
 173     if (EVP_PKEY_encrypt(pctx, ek, &eklen, key, keylen) <= 0)
 174         goto err;
 175
 176     ASN1_STRING_set0(ri->enc_key, ek, eklen);
 177     ek = NULL;
 178
 179     ret = 1;
 180
 181  err:
 182     EVP_PKEY_free(pkey);
 183     EVP_PKEY_CTX_free(pctx);
 184     if (ek)
 185         OPENSSL_free(ek);
 186     return ret;
 187
 188 }
 189
 190 static int pkcs7_decrypt_rinfo(unsigned char **pek, int *peklen,
 191                                PKCS7_RECIP_INFO *ri, EVP_PKEY *pkey)
 192 {
 193     EVP_PKEY_CTX *pctx = NULL;
 194     unsigned char *ek = NULL;
 195     size_t eklen;
 196
 197     int ret = -1;
 198
 199     pctx = EVP_PKEY_CTX_new(pkey, NULL);
 200     if (!pctx)
 201         return -1;
 202
 203     if (EVP_PKEY_decrypt_init(pctx) <= 0)
 204         goto err;
 205
 206     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DECRYPT,
 207                           EVP_PKEY_CTRL_PKCS7_DECRYPT, 0, ri) <= 0) {
 208         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, PKCS7_R_CTRL_ERROR);
 209         goto err;
 210     }
 211
 212     if (EVP_PKEY_decrypt(pctx, NULL, &eklen,
 213                          ri->enc_key->data, ri->enc_key->length) <= 0)
 214         goto err;
 215
 216     ek = OPENSSL_malloc(eklen);
 217
 218     if (ek == NULL) {
 219         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_MALLOC_FAILURE);
 220         goto err;
 221     }
 222
 223     if (EVP_PKEY_decrypt(pctx, ek, &eklen,
 224                          ri->enc_key->data, ri->enc_key->length) <= 0) {
 225         ret = 0;
 226         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_EVP_LIB);
 227         goto err;
 228     }
 229
 230     ret = 1;
 231
 232     OPENSSL_clear_free(*pek, *peklen);
 233     *pek = ek;
 234     *peklen = eklen;
 235
 236  err:
 237     EVP_PKEY_CTX_free(pctx);
 238     if (!ret && ek)
 239         OPENSSL_free(ek);
 240
 241     return ret;
 242 }
 243
 244 BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio)
 245 {
 246     int i;
 247     BIO *out = NULL, *btmp = NULL;
 248     X509_ALGOR *xa = NULL;
 249     const EVP_CIPHER *evp_cipher = NULL;
 250     STACK_OF(X509_ALGOR) *md_sk = NULL;
 251     STACK_OF(PKCS7_RECIP_INFO) *rsk = NULL;
 252     X509_ALGOR *xalg = NULL;
 253     PKCS7_RECIP_INFO *ri = NULL;
 254     ASN1_OCTET_STRING *os = NULL;
 255
 256     if (p7 == NULL) {
 257         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_INVALID_NULL_POINTER);
 258         return NULL;
 259     }
 260     /*
 261      * The content field in the PKCS7 ContentInfo is optional, but that really
 262      * only applies to inner content (precisely, detached signatures).
 263      *
 264      * When reading content, missing outer content is therefore treated as an
 265      * error.
 266      *
 267      * When creating content, PKCS7_content_new() must be called before
 268      * calling this method, so a NULL p7->d is always an error.
 269      */
 270     if (p7->d.ptr == NULL) {
 271         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_NO_CONTENT);
 272         return NULL;
 273     }
 274
 275     i = OBJ_obj2nid(p7->type);
 276     p7->state = PKCS7_S_HEADER;
 277
 278     switch (i) {
 279     case NID_pkcs7_signed:
 280         md_sk = p7->d.sign->md_algs;
 281         os = PKCS7_get_octet_string(p7->d.sign->contents);
 282         break;
 283     case NID_pkcs7_signedAndEnveloped:
 284         rsk = p7->d.signed_and_enveloped->recipientinfo;
 285         md_sk = p7->d.signed_and_enveloped->md_algs;
 286         xalg = p7->d.signed_and_enveloped->enc_data->algorithm;
 287         evp_cipher = p7->d.signed_and_enveloped->enc_data->cipher;
 288         if (evp_cipher == NULL) {
 289             PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_CIPHER_NOT_INITIALIZED);
 290             goto err;
 291         }
 292         break;
 293     case NID_pkcs7_enveloped:
 294         rsk = p7->d.enveloped->recipientinfo;
 295         xalg = p7->d.enveloped->enc_data->algorithm;
 296         evp_cipher = p7->d.enveloped->enc_data->cipher;
 297         if (evp_cipher == NULL) {
 298             PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_CIPHER_NOT_INITIALIZED);
 299             goto err;
 300         }
 301         break;
 302     case NID_pkcs7_digest:
 303         xa = p7->d.digest->md;
 304         os = PKCS7_get_octet_string(p7->d.digest->contents);
 305         break;
 306     case NID_pkcs7_data:
 307         break;
 308     default:
 309         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 310         goto err;
 311     }
 312
 313     for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++)
 314         if (!PKCS7_bio_add_digest(&out, sk_X509_ALGOR_value(md_sk, i)))
 315             goto err;
 316
 317     if (xa && !PKCS7_bio_add_digest(&out, xa))
 318         goto err;
 319
 320     if (evp_cipher != NULL) {
 321         unsigned char key[EVP_MAX_KEY_LENGTH];
 322         unsigned char iv[EVP_MAX_IV_LENGTH];
 323         int keylen, ivlen;
 324         EVP_CIPHER_CTX *ctx;
 325
 326         if ((btmp = BIO_new(BIO_f_cipher())) == NULL) {
 327             PKCS7err(PKCS7_F_PKCS7_DATAINIT, ERR_R_BIO_LIB);
 328             goto err;
 329         }
 330         BIO_get_cipher_ctx(btmp, &ctx);
 331         keylen = EVP_CIPHER_key_length(evp_cipher);
 332         ivlen = EVP_CIPHER_iv_length(evp_cipher);
 333         xalg->algorithm = OBJ_nid2obj(EVP_CIPHER_type(evp_cipher));
 334         if (ivlen > 0)
 335             if (RAND_bytes(iv, ivlen) <= 0)
 336                 goto err;
 337         if (EVP_CipherInit_ex(ctx, evp_cipher, NULL, NULL, NULL, 1) <= 0)
 338             goto err;
 339         if (EVP_CIPHER_CTX_rand_key(ctx, key) <= 0)
 340             goto err;
 341         if (EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, 1) <= 0)
 342             goto err;
 343
 344         if (ivlen > 0) {
 345             if (xalg->parameter == NULL) {
 346                 xalg->parameter = ASN1_TYPE_new();
 347                 if (xalg->parameter == NULL)
 348                     goto err;
 349             }
 350             if (EVP_CIPHER_param_to_asn1(ctx, xalg->parameter) < 0)
 351                 goto err;
 352         }
 353
 354         /* Lets do the pub key stuff :-) */
 355         for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
 356             ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
 357             if (pkcs7_encode_rinfo(ri, key, keylen) <= 0)
 358                 goto err;
 359         }
 360         OPENSSL_cleanse(key, keylen);
 361
 362         if (out == NULL)
 363             out = btmp;
 364         else
 365             BIO_push(out, btmp);
 366         btmp = NULL;
 367     }
 368
 369     if (bio == NULL) {
 370         if (PKCS7_is_detached(p7))
 371             bio = BIO_new(BIO_s_null());
 372         else if (os && os->length > 0)
 373             bio = BIO_new_mem_buf(os->data, os->length);
 374         if (bio == NULL) {
 375             bio = BIO_new(BIO_s_mem());
 376             if (bio == NULL)
 377                 goto err;
 378             BIO_set_mem_eof_return(bio, 0);
 379         }
 380     }
 381     if (out)
 382         BIO_push(out, bio);
 383     else
 384         out = bio;
 385     return out;
 386
 387  err:
 388     BIO_free_all(out);
 389     BIO_free_all(btmp);
 390     return NULL;
 391 }
 392
 393 static int pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)
 394 {
 395     int ret;
 396     ret = X509_NAME_cmp(ri->issuer_and_serial->issuer,
 397                         pcert->cert_info->issuer);
 398     if (ret)
 399         return ret;
 400     return ASN1_INTEGER_cmp(pcert->cert_info->serialNumber,
 401                               ri->issuer_and_serial->serial);
 402 }
 403
 404 /* int */
 405 BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert)
 406 {
 407     int i, j;
 408     BIO *out = NULL, *btmp = NULL, *etmp = NULL, *bio = NULL;
 409     X509_ALGOR *xa;
 410     ASN1_OCTET_STRING *data_body = NULL;
 411     const EVP_MD *evp_md;
 412     const EVP_CIPHER *evp_cipher = NULL;
 413     EVP_CIPHER_CTX *evp_ctx = NULL;
 414     X509_ALGOR *enc_alg = NULL;
 415     STACK_OF(X509_ALGOR) *md_sk = NULL;
 416     STACK_OF(PKCS7_RECIP_INFO) *rsk = NULL;
 417     PKCS7_RECIP_INFO *ri = NULL;
 418     unsigned char *ek = NULL, *tkey = NULL;
 419     int eklen = 0, tkeylen = 0;
 420
 421     if (p7 == NULL) {
 422         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_INVALID_NULL_POINTER);
 423         return NULL;
 424     }
 425
 426     if (p7->d.ptr == NULL) {
 427         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_NO_CONTENT);
 428         return NULL;
 429     }
 430
 431     i = OBJ_obj2nid(p7->type);
 432     p7->state = PKCS7_S_HEADER;
 433
 434     switch (i) {
 435     case NID_pkcs7_signed:
 436         data_body = PKCS7_get_octet_string(p7->d.sign->contents);
 437         if (!PKCS7_is_detached(p7) && data_body == NULL) {
 438             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
 439                      PKCS7_R_INVALID_SIGNED_DATA_TYPE);
 440             goto err;
 441         }
 442         md_sk = p7->d.sign->md_algs;
 443         break;
 444     case NID_pkcs7_signedAndEnveloped:
 445         rsk = p7->d.signed_and_enveloped->recipientinfo;
 446         md_sk = p7->d.signed_and_enveloped->md_algs;
 447         data_body = p7->d.signed_and_enveloped->enc_data->enc_data;
 448         enc_alg = p7->d.signed_and_enveloped->enc_data->algorithm;
 449         evp_cipher = EVP_get_cipherbyobj(enc_alg->algorithm);
 450         if (evp_cipher == NULL) {
 451             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
 452                      PKCS7_R_UNSUPPORTED_CIPHER_TYPE);
 453             goto err;
 454         }
 455         break;
 456     case NID_pkcs7_enveloped:
 457         rsk = p7->d.enveloped->recipientinfo;
 458         enc_alg = p7->d.enveloped->enc_data->algorithm;
 459         data_body = p7->d.enveloped->enc_data->enc_data;
 460         evp_cipher = EVP_get_cipherbyobj(enc_alg->algorithm);
 461         if (evp_cipher == NULL) {
 462             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
 463                      PKCS7_R_UNSUPPORTED_CIPHER_TYPE);
 464             goto err;
 465         }
 466         break;
 467     default:
 468         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 469         goto err;
 470     }
 471
 472     /* We will be checking the signature */
 473     if (md_sk != NULL) {
 474         for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++) {
 475             xa = sk_X509_ALGOR_value(md_sk, i);
 476             if ((btmp = BIO_new(BIO_f_md())) == NULL) {
 477                 PKCS7err(PKCS7_F_PKCS7_DATADECODE, ERR_R_BIO_LIB);
 478                 goto err;
 479             }
 480
 481             j = OBJ_obj2nid(xa->algorithm);
 482             evp_md = EVP_get_digestbynid(j);
 483             if (evp_md == NULL) {
 484                 PKCS7err(PKCS7_F_PKCS7_DATADECODE,
 485                          PKCS7_R_UNKNOWN_DIGEST_TYPE);
 486                 goto err;
 487             }
 488
 489             BIO_set_md(btmp, evp_md);
 490             if (out == NULL)
 491                 out = btmp;
 492             else
 493                 BIO_push(out, btmp);
 494             btmp = NULL;
 495         }
 496     }
 497
 498     if (evp_cipher != NULL) {
 499         if ((etmp = BIO_new(BIO_f_cipher())) == NULL) {
 500             PKCS7err(PKCS7_F_PKCS7_DATADECODE, ERR_R_BIO_LIB);
 501             goto err;
 502         }
 503
 504         /*
 505          * It was encrypted, we need to decrypt the secret key with the
 506          * private key
 507          */
 508
 509         /*
 510          * Find the recipientInfo which matches the passed certificate (if
 511          * any)
 512          */
 513
 514         if (pcert) {
 515             for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
 516                 ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
 517                 if (!pkcs7_cmp_ri(ri, pcert))
 518                     break;
 519                 ri = NULL;
 520             }
 521             if (ri == NULL) {
 522                 PKCS7err(PKCS7_F_PKCS7_DATADECODE,
 523                          PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE);
 524                 goto err;
 525             }
 526         }
 527
 528         /* If we haven't got a certificate try each ri in turn */
 529         if (pcert == NULL) {
 530             /*
 531              * Always attempt to decrypt all rinfo even after success as a
 532              * defence against MMA timing attacks.
 533              */
 534             for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
 535                 ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
 536
 537                 if (pkcs7_decrypt_rinfo(&ek, &eklen, ri, pkey) < 0)
 538                     goto err;
 539                 ERR_clear_error();
 540             }
 541         } else {
 542             /* Only exit on fatal errors, not decrypt failure */
 543             if (pkcs7_decrypt_rinfo(&ek, &eklen, ri, pkey) < 0)
 544                 goto err;
 545             ERR_clear_error();
 546         }
 547
 548         evp_ctx = NULL;
 549         BIO_get_cipher_ctx(etmp, &evp_ctx);
 550         if (EVP_CipherInit_ex(evp_ctx, evp_cipher, NULL, NULL, NULL, 0) <= 0)
 551             goto err;
 552         if (EVP_CIPHER_asn1_to_param(evp_ctx, enc_alg->parameter) < 0)
 553             goto err;
 554         /* Generate random key as MMA defence */
 555         tkeylen = EVP_CIPHER_CTX_key_length(evp_ctx);
 556         tkey = OPENSSL_malloc(tkeylen);
 557         if (!tkey)
 558             goto err;
 559         if (EVP_CIPHER_CTX_rand_key(evp_ctx, tkey) <= 0)
 560             goto err;
 561         if (ek == NULL) {
 562             ek = tkey;
 563             eklen = tkeylen;
 564             tkey = NULL;
 565         }
 566
 567         if (eklen != EVP_CIPHER_CTX_key_length(evp_ctx)) {
 568             /*
 569              * Some S/MIME clients don't use the same key and effective key
 570              * length. The key length is determined by the size of the
 571              * decrypted RSA key.
 572              */
 573             if (!EVP_CIPHER_CTX_set_key_length(evp_ctx, eklen)) {
 574                 /* Use random key as MMA defence */
 575                 OPENSSL_clear_free(ek, eklen);
 576                 ek = tkey;
 577                 eklen = tkeylen;
 578                 tkey = NULL;
 579             }
 580         }
 581         /* Clear errors so we don't leak information useful in MMA */
 582         ERR_clear_error();
 583         if (EVP_CipherInit_ex(evp_ctx, NULL, NULL, ek, NULL, 0) <= 0)
 584             goto err;
 585
 586         OPENSSL_clear_free(ek, eklen);
 587         ek = NULL;
 588         OPENSSL_clear_free(tkey, tkeylen);
 589         tkey = NULL;
 590
 591         if (out == NULL)
 592             out = etmp;
 593         else
 594             BIO_push(out, etmp);
 595         etmp = NULL;
 596     }
 597     if (PKCS7_is_detached(p7) || (in_bio != NULL)) {
 598         bio = in_bio;
 599     } else {
 600         if (data_body->length > 0)
 601             bio = BIO_new_mem_buf(data_body->data, data_body->length);
 602         else {
 603             bio = BIO_new(BIO_s_mem());
 604             BIO_set_mem_eof_return(bio, 0);
 605         }
 606         if (bio == NULL)
 607             goto err;
 608     }
 609     BIO_push(out, bio);
 610     bio = NULL;
 611     return out;
 612
 613  err:
 614     OPENSSL_clear_free(ek, eklen);
 615     OPENSSL_clear_free(tkey, tkeylen);
 616     BIO_free_all(out);
 617     BIO_free_all(btmp);
 618     BIO_free_all(etmp);
 619     BIO_free_all(bio);
 620     return  NULL;
 621 }
 622
 623 static BIO *PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid)
 624 {
 625     for (;;) {
 626         bio = BIO_find_type(bio, BIO_TYPE_MD);
 627         if (bio == NULL) {
 628             PKCS7err(PKCS7_F_PKCS7_FIND_DIGEST,
 629                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
 630             return NULL;
 631         }
 632         BIO_get_md_ctx(bio, pmd);
 633         if (*pmd == NULL) {
 634             PKCS7err(PKCS7_F_PKCS7_FIND_DIGEST, ERR_R_INTERNAL_ERROR);
 635             return NULL;
 636         }
 637         if (EVP_MD_CTX_type(*pmd) == nid)
 638             return bio;
 639         bio = BIO_next(bio);
 640     }
 641     return NULL;
 642 }
 643
 644 static int do_pkcs7_signed_attrib(PKCS7_SIGNER_INFO *si, EVP_MD_CTX *mctx)
 645 {
 646     unsigned char md_data[EVP_MAX_MD_SIZE];
 647     unsigned int md_len;
 648
 649     /* Add signing time if not already present */
 650     if (!PKCS7_get_signed_attribute(si, NID_pkcs9_signingTime)) {
 651         if (!PKCS7_add0_attrib_signing_time(si, NULL)) {
 652             PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_MALLOC_FAILURE);
 653             return 0;
 654         }
 655     }
 656
 657     /* Add digest */
 658     if (!EVP_DigestFinal_ex(mctx, md_data, &md_len)) {
 659         PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_EVP_LIB);
 660         return 0;
 661     }
 662     if (!PKCS7_add1_attrib_digest(si, md_data, md_len)) {
 663         PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_MALLOC_FAILURE);
 664         return 0;
 665     }
 666
 667     /* Now sign the attributes */
 668     if (!PKCS7_SIGNER_INFO_sign(si))
 669         return 0;
 670
 671     return 1;
 672 }
 673
 674 int PKCS7_dataFinal(PKCS7 *p7, BIO *bio)
 675 {
 676     int ret = 0;
 677     int i, j;
 678     BIO *btmp;
 679     PKCS7_SIGNER_INFO *si;
 680     EVP_MD_CTX *mdc, ctx_tmp;
 681     STACK_OF(X509_ATTRIBUTE) *sk;
 682     STACK_OF(PKCS7_SIGNER_INFO) *si_sk = NULL;
 683     ASN1_OCTET_STRING *os = NULL;
 684
 685     if (p7 == NULL) {
 686         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_INVALID_NULL_POINTER);
 687         return 0;
 688     }
 689
 690     if (p7->d.ptr == NULL) {
 691         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_NO_CONTENT);
 692         return 0;
 693     }
 694
 695     EVP_MD_CTX_init(&ctx_tmp);
 696     i = OBJ_obj2nid(p7->type);
 697     p7->state = PKCS7_S_HEADER;
 698
 699     switch (i) {
 700     case NID_pkcs7_data:
 701         os = p7->d.data;
 702         break;
 703     case NID_pkcs7_signedAndEnveloped:
 704         /* XXXXXXXXXXXXXXXX */
 705         si_sk = p7->d.signed_and_enveloped->signer_info;
 706         os = p7->d.signed_and_enveloped->enc_data->enc_data;
 707         if (!os) {
 708             os = ASN1_OCTET_STRING_new();
 709             if (!os) {
 710                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_MALLOC_FAILURE);
 711                 goto err;
 712             }
 713             p7->d.signed_and_enveloped->enc_data->enc_data = os;
 714         }
 715         break;
 716     case NID_pkcs7_enveloped:
 717         /* XXXXXXXXXXXXXXXX */
 718         os = p7->d.enveloped->enc_data->enc_data;
 719         if (!os) {
 720             os = ASN1_OCTET_STRING_new();
 721             if (!os) {
 722                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_MALLOC_FAILURE);
 723                 goto err;
 724             }
 725             p7->d.enveloped->enc_data->enc_data = os;
 726         }
 727         break;
 728     case NID_pkcs7_signed:
 729         si_sk = p7->d.sign->signer_info;
 730         os = PKCS7_get_octet_string(p7->d.sign->contents);
 731         /* If detached data then the content is excluded */
 732         if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached) {
 733             ASN1_OCTET_STRING_free(os);
 734             os = NULL;
 735             p7->d.sign->contents->d.data = NULL;
 736         }
 737         break;
 738
 739     case NID_pkcs7_digest:
 740         os = PKCS7_get_octet_string(p7->d.digest->contents);
 741         /* If detached data then the content is excluded */
 742         if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached) {
 743             ASN1_OCTET_STRING_free(os);
 744             os = NULL;
 745             p7->d.digest->contents->d.data = NULL;
 746         }
 747         break;
 748
 749     default:
 750         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
 751         goto err;
 752     }
 753
 754     if (si_sk != NULL) {
 755         for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(si_sk); i++) {
 756             si = sk_PKCS7_SIGNER_INFO_value(si_sk, i);
 757             if (si->pkey == NULL)
 758                 continue;
 759
 760             j = OBJ_obj2nid(si->digest_alg->algorithm);
 761
 762             btmp = bio;
 763
 764             btmp = PKCS7_find_digest(&mdc, btmp, j);
 765
 766             if (btmp == NULL)
 767                 goto err;
 768
 769             /*
 770              * We now have the EVP_MD_CTX, lets do the signing.
 771              */
 772             if (!EVP_MD_CTX_copy_ex(&ctx_tmp, mdc))
 773                 goto err;
 774
 775             sk = si->auth_attr;
 776
 777             /*
 778              * If there are attributes, we add the digest attribute and only
 779              * sign the attributes
 780              */
 781             if (sk_X509_ATTRIBUTE_num(sk) > 0) {
 782                 if (!do_pkcs7_signed_attrib(si, &ctx_tmp))
 783                     goto err;
 784             } else {
 785                 unsigned char *abuf = NULL;
 786                 unsigned int abuflen;
 787                 abuflen = EVP_PKEY_size(si->pkey);
 788                 abuf = OPENSSL_malloc(abuflen);
 789                 if (!abuf)
 790                     goto err;
 791
 792                 if (!EVP_SignFinal(&ctx_tmp, abuf, &abuflen, si->pkey)) {
 793                     PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_EVP_LIB);
 794                     goto err;
 795                 }
 796                 ASN1_STRING_set0(si->enc_digest, abuf, abuflen);
 797             }
 798         }
 799     } else if (i == NID_pkcs7_digest) {
 800         unsigned char md_data[EVP_MAX_MD_SIZE];
 801         unsigned int md_len;
 802         if (!PKCS7_find_digest(&mdc, bio,
 803                                OBJ_obj2nid(p7->d.digest->md->algorithm)))
 804             goto err;
 805         if (!EVP_DigestFinal_ex(mdc, md_data, &md_len))
 806             goto err;
 807         ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);
 808     }
 809
 810     if (!PKCS7_is_detached(p7)) {
 811         /*
 812          * NOTE(emilia): I think we only reach os == NULL here because detached
 813          * digested data support is broken.
 814          */
 815         if (os == NULL)
 816             goto err;
 817         if (!(os->flags & ASN1_STRING_FLAG_NDEF)) {
 818             char *cont;
 819             long contlen;
 820             btmp = BIO_find_type(bio, BIO_TYPE_MEM);
 821             if (btmp == NULL) {
 822                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_UNABLE_TO_FIND_MEM_BIO);
 823                 goto err;
 824             }
 825             contlen = BIO_get_mem_data(btmp, &cont);
 826             /*
 827              * Mark the BIO read only then we can use its copy of the data
 828              * instead of making an extra copy.
 829              */
 830             BIO_set_flags(btmp, BIO_FLAGS_MEM_RDONLY);
 831             BIO_set_mem_eof_return(btmp, 0);
 832             ASN1_STRING_set0(os, (unsigned char *)cont, contlen);
 833         }
 834     }
 835     ret = 1;
 836  err:
 837     EVP_MD_CTX_cleanup(&ctx_tmp);
 838     return (ret);
 839 }
 840
 841 int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si)
 842 {
 843     EVP_MD_CTX mctx;
 844     EVP_PKEY_CTX *pctx;
 845     unsigned char *abuf = NULL;
 846     int alen;
 847     size_t siglen;
 848     const EVP_MD *md = NULL;
 849
 850     md = EVP_get_digestbyobj(si->digest_alg->algorithm);
 851     if (md == NULL)
 852         return 0;
 853
 854     EVP_MD_CTX_init(&mctx);
 855     if (EVP_DigestSignInit(&mctx, &pctx, md, NULL, si->pkey) <= 0)
 856         goto err;
 857
 858     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
 859                           EVP_PKEY_CTRL_PKCS7_SIGN, 0, si) <= 0) {
 860         PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SIGN, PKCS7_R_CTRL_ERROR);
 861         goto err;
 862     }
 863
 864     alen = ASN1_item_i2d((ASN1_VALUE *)si->auth_attr, &abuf,
 865                          ASN1_ITEM_rptr(PKCS7_ATTR_SIGN));
 866     if (!abuf)
 867         goto err;
 868     if (EVP_DigestSignUpdate(&mctx, abuf, alen) <= 0)
 869         goto err;
 870     OPENSSL_free(abuf);
 871     abuf = NULL;
 872     if (EVP_DigestSignFinal(&mctx, NULL, &siglen) <= 0)
 873         goto err;
 874     abuf = OPENSSL_malloc(siglen);
 875     if (!abuf)
 876         goto err;
 877     if (EVP_DigestSignFinal(&mctx, abuf, &siglen) <= 0)
 878         goto err;
 879
 880     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
 881                           EVP_PKEY_CTRL_PKCS7_SIGN, 1, si) <= 0) {
 882         PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SIGN, PKCS7_R_CTRL_ERROR);
 883         goto err;
 884     }
 885
 886     EVP_MD_CTX_cleanup(&mctx);
 887
 888     ASN1_STRING_set0(si->enc_digest, abuf, siglen);
 889
 890     return 1;
 891
 892  err:
 893     if (abuf)
 894         OPENSSL_free(abuf);
 895     EVP_MD_CTX_cleanup(&mctx);
 896     return 0;
 897
 898 }
 899
 900 int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,
 901                      PKCS7 *p7, PKCS7_SIGNER_INFO *si)
 902 {
 903     PKCS7_ISSUER_AND_SERIAL *ias;
 904     int ret = 0, i;
 905     STACK_OF(X509) *cert;
 906     X509 *x509;
 907
 908     if (p7 == NULL) {
 909         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_INVALID_NULL_POINTER);
 910         return 0;
 911     }
 912
 913     if (p7->d.ptr == NULL) {
 914         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_NO_CONTENT);
 915         return 0;
 916     }
 917
 918     if (PKCS7_type_is_signed(p7)) {
 919         cert = p7->d.sign->cert;
 920     } else if (PKCS7_type_is_signedAndEnveloped(p7)) {
 921         cert = p7->d.signed_and_enveloped->cert;
 922     } else {
 923         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_WRONG_PKCS7_TYPE);
 924         goto err;
 925     }
 926     /* XXXXXXXXXXXXXXXXXXXXXXX */
 927     ias = si->issuer_and_serial;
 928
 929     x509 = X509_find_by_issuer_and_serial(cert, ias->issuer, ias->serial);
 930
 931     /* were we able to find the cert in passed to us */
 932     if (x509 == NULL) {
 933         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,
 934                  PKCS7_R_UNABLE_TO_FIND_CERTIFICATE);
 935         goto err;
 936     }
 937
 938     /* Lets verify */
 939     if (!X509_STORE_CTX_init(ctx, cert_store, x509, cert)) {
 940         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, ERR_R_X509_LIB);
 941         goto err;
 942     }
 943     X509_STORE_CTX_set_purpose(ctx, X509_PURPOSE_SMIME_SIGN);
 944     i = X509_verify_cert(ctx);
 945     if (i <= 0) {
 946         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, ERR_R_X509_LIB);
 947         X509_STORE_CTX_cleanup(ctx);
 948         goto err;
 949     }
 950     X509_STORE_CTX_cleanup(ctx);
 951
 952     return PKCS7_signatureVerify(bio, p7, si, x509);
 953  err:
 954     return ret;
 955 }
 956
 957 int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
 958                           X509 *x509)
 959 {
 960     ASN1_OCTET_STRING *os;
 961     EVP_MD_CTX mdc_tmp, *mdc;
 962     int ret = 0, i;
 963     int md_type;
 964     STACK_OF(X509_ATTRIBUTE) *sk;
 965     BIO *btmp;
 966     EVP_PKEY *pkey;
 967
 968     EVP_MD_CTX_init(&mdc_tmp);
 969
 970     if (!PKCS7_type_is_signed(p7) && !PKCS7_type_is_signedAndEnveloped(p7)) {
 971         PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_WRONG_PKCS7_TYPE);
 972         goto err;
 973     }
 974
 975     md_type = OBJ_obj2nid(si->digest_alg->algorithm);
 976
 977     btmp = bio;
 978     for (;;) {
 979         if ((btmp == NULL) ||
 980             ((btmp = BIO_find_type(btmp, BIO_TYPE_MD)) == NULL)) {
 981             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,
 982                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
 983             goto err;
 984         }
 985         BIO_get_md_ctx(btmp, &mdc);
 986         if (mdc == NULL) {
 987             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, ERR_R_INTERNAL_ERROR);
 988             goto err;
 989         }
 990         if (EVP_MD_CTX_type(mdc) == md_type)
 991             break;
 992         /*
 993          * Workaround for some broken clients that put the signature OID
 994          * instead of the digest OID in digest_alg->algorithm
 995          */
 996         if (EVP_MD_pkey_type(EVP_MD_CTX_md(mdc)) == md_type)
 997             break;
 998         btmp = BIO_next(btmp);
 999     }
1000
1001     /*
1002      * mdc is the digest ctx that we want, unless there are attributes, in
1003      * which case the digest is the signed attributes
1004      */
1005     if (!EVP_MD_CTX_copy_ex(&mdc_tmp, mdc))
1006         goto err;
1007
1008     sk = si->auth_attr;
1009     if ((sk != NULL) && (sk_X509_ATTRIBUTE_num(sk) != 0)) {
1010         unsigned char md_dat[EVP_MAX_MD_SIZE], *abuf = NULL;
1011         unsigned int md_len;
1012         int alen;
1013         ASN1_OCTET_STRING *message_digest;
1014
1015         if (!EVP_DigestFinal_ex(&mdc_tmp, md_dat, &md_len))
1016             goto err;
1017         message_digest = PKCS7_digest_from_attributes(sk);
1018         if (!message_digest) {
1019             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,
1020                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
1021             goto err;
1022         }
1023         if ((message_digest->length != (int)md_len) ||
1024             (memcmp(message_digest->data, md_dat, md_len))) {
1025             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_DIGEST_FAILURE);
1026             ret = -1;
1027             goto err;
1028         }
1029
1030         if (!EVP_VerifyInit_ex(&mdc_tmp, EVP_get_digestbynid(md_type), NULL))
1031             goto err;
1032
1033         alen = ASN1_item_i2d((ASN1_VALUE *)sk, &abuf,
1034                              ASN1_ITEM_rptr(PKCS7_ATTR_VERIFY));
1035         if (alen <= 0) {
1036             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, ERR_R_ASN1_LIB);
1037             ret = -1;
1038             goto err;
1039         }
1040         if (!EVP_VerifyUpdate(&mdc_tmp, abuf, alen))
1041             goto err;
1042
1043         OPENSSL_free(abuf);
1044     }
1045
1046     os = si->enc_digest;
1047     pkey = X509_get_pubkey(x509);
1048     if (!pkey) {
1049         ret = -1;
1050         goto err;
1051     }
1052
1053     i = EVP_VerifyFinal(&mdc_tmp, os->data, os->length, pkey);
1054     EVP_PKEY_free(pkey);
1055     if (i <= 0) {
1056         PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_SIGNATURE_FAILURE);
1057         ret = -1;
1058         goto err;
1059     }
1060     ret = 1;
1061  err:
1062     EVP_MD_CTX_cleanup(&mdc_tmp);
1063     return (ret);
1064 }
1065
1066 PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
1067 {
1068     STACK_OF(PKCS7_RECIP_INFO) *rsk;
1069     PKCS7_RECIP_INFO *ri;
1070     int i;
1071
1072     i = OBJ_obj2nid(p7->type);
1073     if (i != NID_pkcs7_signedAndEnveloped)
1074         return NULL;
1075     if (p7->d.signed_and_enveloped == NULL)
1076         return NULL;
1077     rsk = p7->d.signed_and_enveloped->recipientinfo;
1078     if (rsk == NULL)
1079         return NULL;
1080     ri = sk_PKCS7_RECIP_INFO_value(rsk, 0);
1081     if (sk_PKCS7_RECIP_INFO_num(rsk) <= idx)
1082         return (NULL);
1083     ri = sk_PKCS7_RECIP_INFO_value(rsk, idx);
1084     return (ri->issuer_and_serial);
1085 }
1086
1087 ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid)
1088 {
1089     return (get_attribute(si->auth_attr, nid));
1090 }
1091
1092 ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid)
1093 {
1094     return (get_attribute(si->unauth_attr, nid));
1095 }
1096
1097 static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid)
1098 {
1099     int idx;
1100     X509_ATTRIBUTE *xa;
1101     idx = X509at_get_attr_by_NID(sk, nid, -1);
1102     xa = X509at_get_attr(sk, idx);
1103     return X509_ATTRIBUTE_get0_type(xa, 0);
1104 }
1105
1106 ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk)
1107 {
1108     ASN1_TYPE *astype;
1109     if (!(astype = get_attribute(sk, NID_pkcs9_messageDigest)))
1110         return NULL;
1111     return astype->value.octet_string;
1112 }
1113
1114 int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
1115                                 STACK_OF(X509_ATTRIBUTE) *sk)
1116 {
1117     int i;
1118
1119     sk_X509_ATTRIBUTE_pop_free(p7si->auth_attr, X509_ATTRIBUTE_free);
1120     p7si->auth_attr = sk_X509_ATTRIBUTE_dup(sk);
1121     if (p7si->auth_attr == NULL)
1122         return 0;
1123     for (i = 0; i < sk_X509_ATTRIBUTE_num(sk); i++) {
1124         if ((sk_X509_ATTRIBUTE_set(p7si->auth_attr, i,
1125                                    X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value
1126                                                       (sk, i))))
1127             == NULL)
1128             return (0);
1129     }
1130     return (1);
1131 }
1132
1133 int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
1134                          STACK_OF(X509_ATTRIBUTE) *sk)
1135 {
1136     int i;
1137
1138     sk_X509_ATTRIBUTE_pop_free(p7si->unauth_attr, X509_ATTRIBUTE_free);
1139     p7si->unauth_attr = sk_X509_ATTRIBUTE_dup(sk);
1140     if (p7si->unauth_attr == NULL)
1141         return 0;
1142     for (i = 0; i < sk_X509_ATTRIBUTE_num(sk); i++) {
1143         if ((sk_X509_ATTRIBUTE_set(p7si->unauth_attr, i,
1144                                    X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value
1145                                                       (sk, i))))
1146             == NULL)
1147             return (0);
1148     }
1149     return (1);
1150 }
1151
1152 int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
1153                                void *value)
1154 {
1155     return (add_attribute(&(p7si->auth_attr), nid, atrtype, value));
1156 }
1157
1158 int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
1159                         void *value)
1160 {
1161     return (add_attribute(&(p7si->unauth_attr), nid, atrtype, value));
1162 }
1163
1164 static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype,
1165                          void *value)
1166 {
1167     X509_ATTRIBUTE *attr = NULL;
1168
1169     if (*sk == NULL) {
1170         *sk = sk_X509_ATTRIBUTE_new_null();
1171         if (*sk == NULL)
1172             return 0;
1173  new_attrib:
1174         if (!(attr = X509_ATTRIBUTE_create(nid, atrtype, value)))
1175             return 0;
1176         if (!sk_X509_ATTRIBUTE_push(*sk, attr)) {
1177             X509_ATTRIBUTE_free(attr);
1178             return 0;
1179         }
1180     } else {
1181         int i;
1182
1183         for (i = 0; i < sk_X509_ATTRIBUTE_num(*sk); i++) {
1184             attr = sk_X509_ATTRIBUTE_value(*sk, i);
1185             if (OBJ_obj2nid(X509_ATTRIBUTE_get0_object(attr)) == nid) {
1186                 X509_ATTRIBUTE_free(attr);
1187                 attr = X509_ATTRIBUTE_create(nid, atrtype, value);
1188                 if (attr == NULL)
1189                     return 0;
1190                 if (!sk_X509_ATTRIBUTE_set(*sk, i, attr)) {
1191                     X509_ATTRIBUTE_free(attr);
1192                     return 0;
1193                 }
1194                 goto end;
1195             }
1196         }
1197         goto new_attrib;
1198     }
1199  end:
1200     return (1);
1201 }