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