crypto/openssl/crypto/pkcs7/pk7_smime.c

   1 /* pk7_smime.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   4  * project.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 1999-2004 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59
  60 /* Simple PKCS#7 processing functions */
  61
  62 #include <stdio.h>
  63 #include "cryptlib.h"
  64 #include <openssl/x509.h>
  65 #include <openssl/x509v3.h>
  66
  67 PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
  68                   BIO *data, int flags)
  69 {
  70     PKCS7 *p7 = NULL;
  71     PKCS7_SIGNER_INFO *si;
  72     BIO *p7bio = NULL;
  73     STACK_OF(X509_ALGOR) *smcap = NULL;
  74     int i;
  75
  76     if (!X509_check_private_key(signcert, pkey)) {
  77         PKCS7err(PKCS7_F_PKCS7_SIGN,
  78                  PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE);
  79         return NULL;
  80     }
  81
  82     if (!(p7 = PKCS7_new())) {
  83         PKCS7err(PKCS7_F_PKCS7_SIGN, ERR_R_MALLOC_FAILURE);
  84         return NULL;
  85     }
  86
  87     if (!PKCS7_set_type(p7, NID_pkcs7_signed))
  88         goto err;
  89
  90     if (!PKCS7_content_new(p7, NID_pkcs7_data))
  91         goto err;
  92
  93     if (!(si = PKCS7_add_signature(p7, signcert, pkey, EVP_sha1()))) {
  94         PKCS7err(PKCS7_F_PKCS7_SIGN, PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR);
  95         goto err;
  96     }
  97
  98     if (!(flags & PKCS7_NOCERTS)) {
  99         if (!PKCS7_add_certificate(p7, signcert))
 100             goto err;
 101         if (certs)
 102             for (i = 0; i < sk_X509_num(certs); i++)
 103                 if (!PKCS7_add_certificate(p7, sk_X509_value(certs, i)))
 104                     goto err;
 105     }
 106
 107     if (!(flags & PKCS7_NOATTR)) {
 108         if (!PKCS7_add_signed_attribute(si, NID_pkcs9_contentType,
 109                                         V_ASN1_OBJECT,
 110                                         OBJ_nid2obj(NID_pkcs7_data)))
 111             goto err;
 112         /* Add SMIMECapabilities */
 113         if (!(flags & PKCS7_NOSMIMECAP)) {
 114             if (!(smcap = sk_X509_ALGOR_new_null())) {
 115                 PKCS7err(PKCS7_F_PKCS7_SIGN, ERR_R_MALLOC_FAILURE);
 116                 goto err;
 117             }
 118 #ifndef OPENSSL_NO_DES
 119             if (!PKCS7_simple_smimecap(smcap, NID_des_ede3_cbc, -1))
 120                 goto err;
 121 #endif
 122 #ifndef OPENSSL_NO_RC2
 123             if (!PKCS7_simple_smimecap(smcap, NID_rc2_cbc, 128))
 124                 goto err;
 125             if (!PKCS7_simple_smimecap(smcap, NID_rc2_cbc, 64))
 126                 goto err;
 127 #endif
 128 #ifndef OPENSSL_NO_DES
 129             if (!PKCS7_simple_smimecap(smcap, NID_des_cbc, -1))
 130                 goto err;
 131 #endif
 132 #ifndef OPENSSL_NO_RC2
 133             if (!PKCS7_simple_smimecap(smcap, NID_rc2_cbc, 40))
 134                 goto err;
 135 #endif
 136             if (!PKCS7_add_attrib_smimecap(si, smcap))
 137                 goto err;
 138             sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
 139             smcap = NULL;
 140         }
 141     }
 142
 143     if (flags & PKCS7_DETACHED)
 144         PKCS7_set_detached(p7, 1);
 145
 146     if (flags & PKCS7_STREAM)
 147         return p7;
 148
 149     if (!(p7bio = PKCS7_dataInit(p7, NULL))) {
 150         PKCS7err(PKCS7_F_PKCS7_SIGN, ERR_R_MALLOC_FAILURE);
 151         goto err;
 152     }
 153
 154     SMIME_crlf_copy(data, p7bio, flags);
 155
 156     if (!PKCS7_dataFinal(p7, p7bio)) {
 157         PKCS7err(PKCS7_F_PKCS7_SIGN, PKCS7_R_PKCS7_DATASIGN);
 158         goto err;
 159     }
 160
 161     BIO_free_all(p7bio);
 162     return p7;
 163  err:
 164     sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
 165     BIO_free_all(p7bio);
 166     PKCS7_free(p7);
 167     return NULL;
 168 }
 169
 170 int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
 171                  BIO *indata, BIO *out, int flags)
 172 {
 173     STACK_OF(X509) *signers;
 174     X509 *signer;
 175     STACK_OF(PKCS7_SIGNER_INFO) *sinfos;
 176     PKCS7_SIGNER_INFO *si;
 177     X509_STORE_CTX cert_ctx;
 178     char buf[4096];
 179     int i, j = 0, k, ret = 0;
 180     BIO *p7bio;
 181     BIO *tmpin, *tmpout;
 182
 183     if (!p7) {
 184         PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_INVALID_NULL_POINTER);
 185         return 0;
 186     }
 187
 188     if (!PKCS7_type_is_signed(p7)) {
 189         PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_WRONG_CONTENT_TYPE);
 190         return 0;
 191     }
 192
 193     /* Check for no data and no content: no data to verify signature */
 194     if (PKCS7_get_detached(p7) && !indata) {
 195         PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_NO_CONTENT);
 196         return 0;
 197     }
 198 #if 0
 199     /*
 200      * NB: this test commented out because some versions of Netscape
 201      * illegally include zero length content when signing data.
 202      */
 203
 204     /* Check for data and content: two sets of data */
 205     if (!PKCS7_get_detached(p7) && indata) {
 206         PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_CONTENT_AND_DATA_PRESENT);
 207         return 0;
 208     }
 209 #endif
 210
 211     sinfos = PKCS7_get_signer_info(p7);
 212
 213     if (!sinfos || !sk_PKCS7_SIGNER_INFO_num(sinfos)) {
 214         PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_NO_SIGNATURES_ON_DATA);
 215         return 0;
 216     }
 217
 218     signers = PKCS7_get0_signers(p7, certs, flags);
 219
 220     if (!signers)
 221         return 0;
 222
 223     /* Now verify the certificates */
 224
 225     if (!(flags & PKCS7_NOVERIFY))
 226         for (k = 0; k < sk_X509_num(signers); k++) {
 227             signer = sk_X509_value(signers, k);
 228             if (!(flags & PKCS7_NOCHAIN)) {
 229                 if (!X509_STORE_CTX_init(&cert_ctx, store, signer,
 230                                          p7->d.sign->cert)) {
 231                     PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_X509_LIB);
 232                     sk_X509_free(signers);
 233                     return 0;
 234                 }
 235                 X509_STORE_CTX_set_default(&cert_ctx, "smime_sign");
 236             } else if (!X509_STORE_CTX_init(&cert_ctx, store, signer, NULL)) {
 237                 PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_X509_LIB);
 238                 sk_X509_free(signers);
 239                 return 0;
 240             }
 241             if (!(flags & PKCS7_NOCRL))
 242                 X509_STORE_CTX_set0_crls(&cert_ctx, p7->d.sign->crl);
 243             i = X509_verify_cert(&cert_ctx);
 244             if (i <= 0)
 245                 j = X509_STORE_CTX_get_error(&cert_ctx);
 246             X509_STORE_CTX_cleanup(&cert_ctx);
 247             if (i <= 0) {
 248                 PKCS7err(PKCS7_F_PKCS7_VERIFY,
 249                          PKCS7_R_CERTIFICATE_VERIFY_ERROR);
 250                 ERR_add_error_data(2, "Verify error:",
 251                                    X509_verify_cert_error_string(j));
 252                 sk_X509_free(signers);
 253                 return 0;
 254             }
 255             /* Check for revocation status here */
 256         }
 257
 258     /*
 259      * Performance optimization: if the content is a memory BIO then store
 260      * its contents in a temporary read only memory BIO. This avoids
 261      * potentially large numbers of slow copies of data which will occur when
 262      * reading from a read write memory BIO when signatures are calculated.
 263      */
 264
 265     if (indata && (BIO_method_type(indata) == BIO_TYPE_MEM)) {
 266         char *ptr;
 267         long len;
 268         len = BIO_get_mem_data(indata, &ptr);
 269         tmpin = BIO_new_mem_buf(ptr, len);
 270         if (tmpin == NULL) {
 271             PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_MALLOC_FAILURE);
 272             return 0;
 273         }
 274     } else
 275         tmpin = indata;
 276
 277     if (!(p7bio = PKCS7_dataInit(p7, tmpin)))
 278         goto err;
 279
 280     if (flags & PKCS7_TEXT) {
 281         if (!(tmpout = BIO_new(BIO_s_mem()))) {
 282             PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_MALLOC_FAILURE);
 283             goto err;
 284         }
 285         BIO_set_mem_eof_return(tmpout, 0);
 286     } else
 287         tmpout = out;
 288
 289     /* We now have to 'read' from p7bio to calculate digests etc. */
 290     for (;;) {
 291         i = BIO_read(p7bio, buf, sizeof(buf));
 292         if (i <= 0)
 293             break;
 294         if (tmpout)
 295             BIO_write(tmpout, buf, i);
 296     }
 297
 298     if (flags & PKCS7_TEXT) {
 299         if (!SMIME_text(tmpout, out)) {
 300             PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_SMIME_TEXT_ERROR);
 301             BIO_free(tmpout);
 302             goto err;
 303         }
 304         BIO_free(tmpout);
 305     }
 306
 307     /* Now Verify All Signatures */
 308     if (!(flags & PKCS7_NOSIGS))
 309         for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
 310             si = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
 311             signer = sk_X509_value(signers, i);
 312             j = PKCS7_signatureVerify(p7bio, p7, si, signer);
 313             if (j <= 0) {
 314                 PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_SIGNATURE_FAILURE);
 315                 goto err;
 316             }
 317         }
 318
 319     ret = 1;
 320
 321  err:
 322
 323     if (tmpin == indata) {
 324         if (indata)
 325             BIO_pop(p7bio);
 326     }
 327     BIO_free_all(p7bio);
 328
 329     sk_X509_free(signers);
 330
 331     return ret;
 332 }
 333
 334 STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
 335                                    int flags)
 336 {
 337     STACK_OF(X509) *signers;
 338     STACK_OF(PKCS7_SIGNER_INFO) *sinfos;
 339     PKCS7_SIGNER_INFO *si;
 340     PKCS7_ISSUER_AND_SERIAL *ias;
 341     X509 *signer;
 342     int i;
 343
 344     if (!p7) {
 345         PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_INVALID_NULL_POINTER);
 346         return NULL;
 347     }
 348
 349     if (!PKCS7_type_is_signed(p7)) {
 350         PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_WRONG_CONTENT_TYPE);
 351         return NULL;
 352     }
 353
 354     /* Collect all the signers together */
 355
 356     sinfos = PKCS7_get_signer_info(p7);
 357
 358     if (sk_PKCS7_SIGNER_INFO_num(sinfos) <= 0) {
 359         PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_NO_SIGNERS);
 360         return NULL;
 361     }
 362
 363     if (!(signers = sk_X509_new_null())) {
 364         PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, ERR_R_MALLOC_FAILURE);
 365         return NULL;
 366     }
 367
 368     for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
 369         si = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
 370         ias = si->issuer_and_serial;
 371         signer = NULL;
 372         /* If any certificates passed they take priority */
 373         if (certs)
 374             signer = X509_find_by_issuer_and_serial(certs,
 375                                                     ias->issuer, ias->serial);
 376         if (!signer && !(flags & PKCS7_NOINTERN)
 377             && p7->d.sign->cert)
 378             signer =
 379                 X509_find_by_issuer_and_serial(p7->d.sign->cert,
 380                                                ias->issuer, ias->serial);
 381         if (!signer) {
 382             PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,
 383                      PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND);
 384             sk_X509_free(signers);
 385             return NULL;
 386         }
 387
 388         if (!sk_X509_push(signers, signer)) {
 389             sk_X509_free(signers);
 390             return NULL;
 391         }
 392     }
 393     return signers;
 394 }
 395
 396 /* Build a complete PKCS#7 enveloped data */
 397
 398 PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher,
 399                      int flags)
 400 {
 401     PKCS7 *p7;
 402     BIO *p7bio = NULL;
 403     int i;
 404     X509 *x509;
 405     if (!(p7 = PKCS7_new())) {
 406         PKCS7err(PKCS7_F_PKCS7_ENCRYPT, ERR_R_MALLOC_FAILURE);
 407         return NULL;
 408     }
 409
 410     if (!PKCS7_set_type(p7, NID_pkcs7_enveloped))
 411         goto err;
 412     if (!PKCS7_set_cipher(p7, cipher)) {
 413         PKCS7err(PKCS7_F_PKCS7_ENCRYPT, PKCS7_R_ERROR_SETTING_CIPHER);
 414         goto err;
 415     }
 416
 417     for (i = 0; i < sk_X509_num(certs); i++) {
 418         x509 = sk_X509_value(certs, i);
 419         if (!PKCS7_add_recipient(p7, x509)) {
 420             PKCS7err(PKCS7_F_PKCS7_ENCRYPT, PKCS7_R_ERROR_ADDING_RECIPIENT);
 421             goto err;
 422         }
 423     }
 424
 425     if (!(p7bio = PKCS7_dataInit(p7, NULL))) {
 426         PKCS7err(PKCS7_F_PKCS7_ENCRYPT, ERR_R_MALLOC_FAILURE);
 427         goto err;
 428     }
 429
 430     SMIME_crlf_copy(in, p7bio, flags);
 431
 432     (void)BIO_flush(p7bio);
 433
 434     if (!PKCS7_dataFinal(p7, p7bio)) {
 435         PKCS7err(PKCS7_F_PKCS7_ENCRYPT, PKCS7_R_PKCS7_DATAFINAL_ERROR);
 436         goto err;
 437     }
 438     BIO_free_all(p7bio);
 439
 440     return p7;
 441
 442  err:
 443
 444     BIO_free_all(p7bio);
 445     PKCS7_free(p7);
 446     return NULL;
 447
 448 }
 449
 450 int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags)
 451 {
 452     BIO *tmpmem;
 453     int ret, i;
 454     char buf[4096];
 455
 456     if (!p7) {
 457         PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_INVALID_NULL_POINTER);
 458         return 0;
 459     }
 460
 461     if (!PKCS7_type_is_enveloped(p7)) {
 462         PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_WRONG_CONTENT_TYPE);
 463         return 0;
 464     }
 465
 466     if (cert && !X509_check_private_key(cert, pkey)) {
 467         PKCS7err(PKCS7_F_PKCS7_DECRYPT,
 468                  PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE);
 469         return 0;
 470     }
 471
 472     if (!(tmpmem = PKCS7_dataDecode(p7, pkey, NULL, cert))) {
 473         PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_DECRYPT_ERROR);
 474         return 0;
 475     }
 476
 477     if (flags & PKCS7_TEXT) {
 478         BIO *tmpbuf, *bread;
 479         /* Encrypt BIOs can't do BIO_gets() so add a buffer BIO */
 480         if (!(tmpbuf = BIO_new(BIO_f_buffer()))) {
 481             PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE);
 482             BIO_free_all(tmpmem);
 483             return 0;
 484         }
 485         if (!(bread = BIO_push(tmpbuf, tmpmem))) {
 486             PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE);
 487             BIO_free_all(tmpbuf);
 488             BIO_free_all(tmpmem);
 489             return 0;
 490         }
 491         ret = SMIME_text(bread, data);
 492         if (ret > 0 && BIO_method_type(tmpmem) == BIO_TYPE_CIPHER) {
 493             if (!BIO_get_cipher_status(tmpmem))
 494                 ret = 0;
 495         }
 496         BIO_free_all(bread);
 497         return ret;
 498     } else {
 499         for (;;) {
 500             i = BIO_read(tmpmem, buf, sizeof(buf));
 501             if (i <= 0) {
 502                 ret = 1;
 503                 if (BIO_method_type(tmpmem) == BIO_TYPE_CIPHER) {
 504                     if (!BIO_get_cipher_status(tmpmem))
 505                         ret = 0;
 506                 }
 507
 508                 break;
 509             }
 510             if (BIO_write(data, buf, i) != i) {
 511                 ret = 0;
 512                 break;
 513             }
 514         }
 515         BIO_free_all(tmpmem);
 516         return ret;
 517     }
 518 }