crypto/pkcs7/pk7_doit.c

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