apps/cms.c

   1 /* apps/cms.c */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  */
  53
  54 /* CMS utility function */
  55
  56 #include <stdio.h>
  57 #include <string.h>
  58 #include "apps.h"
  59
  60 #ifndef OPENSSL_NO_CMS
  61
  62 #include <openssl/crypto.h>
  63 #include <openssl/pem.h>
  64 #include <openssl/err.h>
  65 #include <openssl/x509_vfy.h>
  66 #include <openssl/x509v3.h>
  67 #include <openssl/cms.h>
  68
  69 #undef PROG
  70 #define PROG cms_main
  71 static int save_certs(char *signerfile, STACK_OF(X509) *signers);
  72 static int smime_cb(int ok, X509_STORE_CTX *ctx);
  73
  74 #define SMIME_OP        0x10
  75 #define SMIME_IP        0x20
  76 #define SMIME_SIGNERS   0x40
  77 #define SMIME_ENCRYPT           (1 | SMIME_OP)
  78 #define SMIME_DECRYPT           (2 | SMIME_IP)
  79 #define SMIME_SIGN              (3 | SMIME_OP | SMIME_SIGNERS)
  80 #define SMIME_VERIFY            (4 | SMIME_IP)
  81 #define SMIME_CMSOUT            (5 | SMIME_IP | SMIME_OP)
  82 #define SMIME_RESIGN            (6 | SMIME_IP | SMIME_OP | SMIME_SIGNERS)
  83 #define SMIME_DATAOUT           (7 | SMIME_IP)
  84 #define SMIME_DATA_CREATE       (8 | SMIME_OP)
  85 #define SMIME_DIGEST_VERIFY     (9 | SMIME_IP)
  86 #define SMIME_DIGEST_CREATE     (10 | SMIME_OP)
  87 #define SMIME_UNCOMPRESS        (11 | SMIME_IP)
  88 #define SMIME_COMPRESS          (12 | SMIME_OP)
  89 #define SMIME_ENCRYPTED_DECRYPT (13 | SMIME_IP)
  90
  91 int MAIN(int, char **);
  92
  93 int MAIN(int argc, char **argv)
  94         {
  95         ENGINE *e = NULL;
  96         int operation = 0;
  97         int ret = 0;
  98         char **args;
  99         const char *inmode = "r", *outmode = "w";
 100         char *infile = NULL, *outfile = NULL;
 101         char *signerfile = NULL, *recipfile = NULL;
 102         STACK *sksigners = NULL, *skkeys = NULL;
 103         char *certfile = NULL, *keyfile = NULL, *contfile=NULL;
 104         const EVP_CIPHER *cipher = NULL;
 105         CMS_ContentInfo *cms = NULL;
 106         X509_STORE *store = NULL;
 107         X509 *cert = NULL, *recip = NULL, *signer = NULL;
 108         EVP_PKEY *key = NULL;
 109         STACK_OF(X509) *encerts = NULL, *other = NULL;
 110         BIO *in = NULL, *out = NULL, *indata = NULL;
 111         int badarg = 0;
 112         int flags = CMS_DETACHED;
 113         char *to = NULL, *from = NULL, *subject = NULL;
 114         char *CAfile = NULL, *CApath = NULL;
 115         char *passargin = NULL, *passin = NULL;
 116         char *inrand = NULL;
 117         int need_rand = 0;
 118         int indef = 0;
 119         const EVP_MD *sign_md = NULL;
 120         int informat = FORMAT_SMIME, outformat = FORMAT_SMIME;
 121         int keyform = FORMAT_PEM;
 122 #ifndef OPENSSL_NO_ENGINE
 123         char *engine=NULL;
 124 #endif
 125         unsigned char *secret_key = NULL;
 126         size_t secret_keylen;
 127
 128         X509_VERIFY_PARAM *vpm = NULL;
 129
 130         args = argv + 1;
 131         ret = 1;
 132
 133         apps_startup();
 134
 135         if (bio_err == NULL)
 136                 {
 137                 if ((bio_err = BIO_new(BIO_s_file())) != NULL)
 138                         BIO_set_fp(bio_err, stderr, BIO_NOCLOSE|BIO_FP_TEXT);
 139                 }
 140
 141         if (!load_config(bio_err, NULL))
 142                 goto end;
 143
 144         while (!badarg && *args && *args[0] == '-')
 145                 {
 146                 if (!strcmp (*args, "-encrypt"))
 147                         operation = SMIME_ENCRYPT;
 148                 else if (!strcmp (*args, "-decrypt"))
 149                         operation = SMIME_DECRYPT;
 150                 else if (!strcmp (*args, "-sign"))
 151                         operation = SMIME_SIGN;
 152                 else if (!strcmp (*args, "-resign"))
 153                         operation = SMIME_RESIGN;
 154                 else if (!strcmp (*args, "-verify"))
 155                         operation = SMIME_VERIFY;
 156                 else if (!strcmp (*args, "-cmsout"))
 157                         operation = SMIME_CMSOUT;
 158                 else if (!strcmp (*args, "-data_out"))
 159                         operation = SMIME_DATAOUT;
 160                 else if (!strcmp (*args, "-data_create"))
 161                         operation = SMIME_DATA_CREATE;
 162                 else if (!strcmp (*args, "-digest_verify"))
 163                         operation = SMIME_DIGEST_VERIFY;
 164                 else if (!strcmp (*args, "-digest_create"))
 165                         operation = SMIME_DIGEST_CREATE;
 166                 else if (!strcmp (*args, "-compress"))
 167                         operation = SMIME_COMPRESS;
 168                 else if (!strcmp (*args, "-uncompress"))
 169                         operation = SMIME_UNCOMPRESS;
 170                 else if (!strcmp (*args, "-EncryptedData_decrypt"))
 171                         operation = SMIME_ENCRYPTED_DECRYPT;
 172 #ifndef OPENSSL_NO_DES
 173                 else if (!strcmp (*args, "-des3"))
 174                                 cipher = EVP_des_ede3_cbc();
 175                 else if (!strcmp (*args, "-des"))
 176                                 cipher = EVP_des_cbc();
 177 #endif
 178 #ifndef OPENSSL_NO_SEED
 179                 else if (!strcmp (*args, "-seed"))
 180                                 cipher = EVP_seed_cbc();
 181 #endif
 182 #ifndef OPENSSL_NO_RC2
 183                 else if (!strcmp (*args, "-rc2-40"))
 184                                 cipher = EVP_rc2_40_cbc();
 185                 else if (!strcmp (*args, "-rc2-128"))
 186                                 cipher = EVP_rc2_cbc();
 187                 else if (!strcmp (*args, "-rc2-64"))
 188                                 cipher = EVP_rc2_64_cbc();
 189 #endif
 190 #ifndef OPENSSL_NO_AES
 191                 else if (!strcmp(*args,"-aes128"))
 192                                 cipher = EVP_aes_128_cbc();
 193                 else if (!strcmp(*args,"-aes192"))
 194                                 cipher = EVP_aes_192_cbc();
 195                 else if (!strcmp(*args,"-aes256"))
 196                                 cipher = EVP_aes_256_cbc();
 197 #endif
 198 #ifndef OPENSSL_NO_CAMELLIA
 199                 else if (!strcmp(*args,"-camellia128"))
 200                                 cipher = EVP_camellia_128_cbc();
 201                 else if (!strcmp(*args,"-camellia192"))
 202                                 cipher = EVP_camellia_192_cbc();
 203                 else if (!strcmp(*args,"-camellia256"))
 204                                 cipher = EVP_camellia_256_cbc();
 205 #endif
 206                 else if (!strcmp (*args, "-text"))
 207                                 flags |= CMS_TEXT;
 208                 else if (!strcmp (*args, "-nointern"))
 209                                 flags |= CMS_NOINTERN;
 210                 else if (!strcmp (*args, "-noverify")
 211                         || !strcmp (*args, "-no_signer_cert_verify"))
 212                                 flags |= CMS_NO_SIGNER_CERT_VERIFY;
 213                 else if (!strcmp (*args, "-nocerts"))
 214                                 flags |= CMS_NOCERTS;
 215                 else if (!strcmp (*args, "-noattr"))
 216                                 flags |= CMS_NOATTR;
 217                 else if (!strcmp (*args, "-nodetach"))
 218                                 flags &= ~CMS_DETACHED;
 219                 else if (!strcmp (*args, "-nosmimecap"))
 220                                 flags |= CMS_NOSMIMECAP;
 221                 else if (!strcmp (*args, "-binary"))
 222                                 flags |= CMS_BINARY;
 223                 else if (!strcmp (*args, "-keyid"))
 224                                 flags |= CMS_USE_KEYID;
 225                 else if (!strcmp (*args, "-nosigs"))
 226                                 flags |= CMS_NOSIGS;
 227                 else if (!strcmp (*args, "-no_content_verify"))
 228                                 flags |= CMS_NO_CONTENT_VERIFY;
 229                 else if (!strcmp (*args, "-no_attr_verify"))
 230                                 flags |= CMS_NO_ATTR_VERIFY;
 231                 else if (!strcmp (*args, "-stream"))
 232                                 indef = 1;
 233                 else if (!strcmp (*args, "-indef"))
 234                                 indef = 1;
 235                 else if (!strcmp (*args, "-noindef"))
 236                                 indef = 0;
 237                 else if (!strcmp (*args, "-nooldmime"))
 238                                 flags |= CMS_NOOLDMIMETYPE;
 239                 else if (!strcmp (*args, "-crlfeol"))
 240                                 flags |= CMS_CRLFEOL;
 241                 else if (!strcmp(*args,"-secretkey"))
 242                         {
 243                         long ltmp;
 244                         if (!args[1])
 245                                 goto argerr;
 246                         args++;
 247                         secret_key = string_to_hex(*args, &ltmp);
 248                         if (!secret_key)
 249                                 {
 250                                 BIO_printf(bio_err, "Invalid key %s\n", *args);
 251                                 goto argerr;
 252                                 }
 253                         secret_keylen = (size_t)ltmp;
 254                         }
 255                 else if (!strcmp(*args,"-rand"))
 256                         {
 257                         if (!args[1])
 258                                 goto argerr;
 259                         args++;
 260                         inrand = *args;
 261                         need_rand = 1;
 262                         }
 263 #ifndef OPENSSL_NO_ENGINE
 264                 else if (!strcmp(*args,"-engine"))
 265                         {
 266                         if (!args[1])
 267                                 goto argerr;
 268                         engine = *++args;
 269                         }
 270 #endif
 271                 else if (!strcmp(*args,"-passin"))
 272                         {
 273                         if (!args[1])
 274                                 goto argerr;
 275                         passargin = *++args;
 276                         }
 277                 else if (!strcmp (*args, "-to"))
 278                         {
 279                         if (!args[1])
 280                                 goto argerr;
 281                         to = *++args;
 282                         }
 283                 else if (!strcmp (*args, "-from"))
 284                         {
 285                         if (!args[1])
 286                                 goto argerr;
 287                         from = *++args;
 288                         }
 289                 else if (!strcmp (*args, "-subject"))
 290                         {
 291                         if (!args[1])
 292                                 goto argerr;
 293                         subject = *++args;
 294                         }
 295                 else if (!strcmp (*args, "-signer"))
 296                         {
 297                         if (!args[1])
 298                                 goto argerr;
 299                         /* If previous -signer argument add signer to list */
 300
 301                         if (signerfile)
 302                                 {
 303                                 if (!sksigners)
 304                                         sksigners = sk_new_null();
 305                                 sk_push(sksigners, signerfile);
 306                                 if (!keyfile)
 307                                         keyfile = signerfile;
 308                                 if (!skkeys)
 309                                         skkeys = sk_new_null();
 310                                 sk_push(skkeys, keyfile);
 311                                 keyfile = NULL;
 312                                 }
 313                         signerfile = *++args;
 314                         }
 315                 else if (!strcmp (*args, "-recip"))
 316                         {
 317                         if (!args[1])
 318                                 goto argerr;
 319                         recipfile = *++args;
 320                         }
 321                 else if (!strcmp (*args, "-md"))
 322                         {
 323                         if (!args[1])
 324                                 goto argerr;
 325                         sign_md = EVP_get_digestbyname(*++args);
 326                         if (sign_md == NULL)
 327                                 {
 328                                 BIO_printf(bio_err, "Unknown digest %s\n",
 329                                                         *args);
 330                                 goto argerr;
 331                                 }
 332                         }
 333                 else if (!strcmp (*args, "-inkey"))
 334                         {
 335                         if (!args[1])
 336                                 goto argerr;
 337                         /* If previous -inkey arument add signer to list */
 338                         if (keyfile)
 339                                 {
 340                                 if (!signerfile)
 341                                         {
 342                                         BIO_puts(bio_err, "Illegal -inkey without -signer\n");
 343                                         goto argerr;
 344                                         }
 345                                 if (!sksigners)
 346                                         sksigners = sk_new_null();
 347                                 sk_push(sksigners, signerfile);
 348                                 signerfile = NULL;
 349                                 if (!skkeys)
 350                                         skkeys = sk_new_null();
 351                                 sk_push(skkeys, keyfile);
 352                                 }
 353                         keyfile = *++args;
 354                         }
 355                 else if (!strcmp (*args, "-keyform"))
 356                         {
 357                         if (!args[1])
 358                                 goto argerr;
 359                         keyform = str2fmt(*++args);
 360                         }
 361                 else if (!strcmp (*args, "-certfile"))
 362                         {
 363                         if (!args[1])
 364                                 goto argerr;
 365                         certfile = *++args;
 366                         }
 367                 else if (!strcmp (*args, "-CAfile"))
 368                         {
 369                         if (!args[1])
 370                                 goto argerr;
 371                         CAfile = *++args;
 372                         }
 373                 else if (!strcmp (*args, "-CApath"))
 374                         {
 375                         if (!args[1])
 376                                 goto argerr;
 377                         CApath = *++args;
 378                         }
 379                 else if (!strcmp (*args, "-in"))
 380                         {
 381                         if (!args[1])
 382                                 goto argerr;
 383                         infile = *++args;
 384                         }
 385                 else if (!strcmp (*args, "-inform"))
 386                         {
 387                         if (!args[1])
 388                                 goto argerr;
 389                         informat = str2fmt(*++args);
 390                         }
 391                 else if (!strcmp (*args, "-outform"))
 392                         {
 393                         if (!args[1])
 394                                 goto argerr;
 395                         outformat = str2fmt(*++args);
 396                         }
 397                 else if (!strcmp (*args, "-out"))
 398                         {
 399                         if (!args[1])
 400                                 goto argerr;
 401                         outfile = *++args;
 402                         }
 403                 else if (!strcmp (*args, "-content"))
 404                         {
 405                         if (!args[1])
 406                                 goto argerr;
 407                         contfile = *++args;
 408                         }
 409                 else if (args_verify(&args, NULL, &badarg, bio_err, &vpm))
 410                         continue;
 411                 else if ((cipher = EVP_get_cipherbyname(*args + 1)) == NULL)
 412                         badarg = 1;
 413                 args++;
 414                 }
 415
 416         if (!(operation & SMIME_SIGNERS) && (skkeys || sksigners))
 417                 {
 418                 BIO_puts(bio_err, "Multiple signers or keys not allowed\n");
 419                 goto argerr;
 420                 }
 421
 422         if (operation & SMIME_SIGNERS)
 423                 {
 424                 /* Check to see if any final signer needs to be appended */
 425                 if (keyfile && !signerfile)
 426                         {
 427                         BIO_puts(bio_err, "Illegal -inkey without -signer\n");
 428                         goto argerr;
 429                         }
 430                 if (signerfile)
 431                         {
 432                         if (!sksigners)
 433                                 sksigners = sk_new_null();
 434                         sk_push(sksigners, signerfile);
 435                         if (!skkeys)
 436                                 skkeys = sk_new_null();
 437                         if (!keyfile)
 438                                 keyfile = signerfile;
 439                         sk_push(skkeys, keyfile);
 440                         }
 441                 if (!sksigners)
 442                         {
 443                         BIO_printf(bio_err, "No signer certificate specified\n");
 444                         badarg = 1;
 445                         }
 446                 signerfile = NULL;
 447                 keyfile = NULL;
 448                 need_rand = 1;
 449                 }
 450         else if (operation == SMIME_DECRYPT)
 451                 {
 452                 if (!recipfile && !keyfile)
 453                         {
 454                         BIO_printf(bio_err, "No recipient certificate or key specified\n");
 455                         badarg = 1;
 456                         }
 457                 }
 458         else if (operation == SMIME_ENCRYPT)
 459                 {
 460                 if (!*args)
 461                         {
 462                         BIO_printf(bio_err, "No recipient(s) certificate(s) specified\n");
 463                         badarg = 1;
 464                         }
 465                 need_rand = 1;
 466                 }
 467         else if (!operation)
 468                 badarg = 1;
 469
 470         if (badarg)
 471                 {
 472                 argerr:
 473                 BIO_printf (bio_err, "Usage smime [options] cert.pem ...\n");
 474                 BIO_printf (bio_err, "where options are\n");
 475                 BIO_printf (bio_err, "-encrypt       encrypt message\n");
 476                 BIO_printf (bio_err, "-decrypt       decrypt encrypted message\n");
 477                 BIO_printf (bio_err, "-sign          sign message\n");
 478                 BIO_printf (bio_err, "-verify        verify signed message\n");
 479                 BIO_printf (bio_err, "-cmsout        output CMS structure\n");
 480 #ifndef OPENSSL_NO_DES
 481                 BIO_printf (bio_err, "-des3          encrypt with triple DES\n");
 482                 BIO_printf (bio_err, "-des           encrypt with DES\n");
 483 #endif
 484 #ifndef OPENSSL_NO_SEED
 485                 BIO_printf (bio_err, "-seed          encrypt with SEED\n");
 486 #endif
 487 #ifndef OPENSSL_NO_RC2
 488                 BIO_printf (bio_err, "-rc2-40        encrypt with RC2-40 (default)\n");
 489                 BIO_printf (bio_err, "-rc2-64        encrypt with RC2-64\n");
 490                 BIO_printf (bio_err, "-rc2-128       encrypt with RC2-128\n");
 491 #endif
 492 #ifndef OPENSSL_NO_AES
 493                 BIO_printf (bio_err, "-aes128, -aes192, -aes256\n");
 494                 BIO_printf (bio_err, "               encrypt PEM output with cbc aes\n");
 495 #endif
 496 #ifndef OPENSSL_NO_CAMELLIA
 497                 BIO_printf (bio_err, "-camellia128, -camellia192, -camellia256\n");
 498                 BIO_printf (bio_err, "               encrypt PEM output with cbc camellia\n");
 499 #endif
 500                 BIO_printf (bio_err, "-nointern      don't search certificates in message for signer\n");
 501                 BIO_printf (bio_err, "-nosigs        don't verify message signature\n");
 502                 BIO_printf (bio_err, "-noverify      don't verify signers certificate\n");
 503                 BIO_printf (bio_err, "-nocerts       don't include signers certificate when signing\n");
 504                 BIO_printf (bio_err, "-nodetach      use opaque signing\n");
 505                 BIO_printf (bio_err, "-noattr        don't include any signed attributes\n");
 506                 BIO_printf (bio_err, "-binary        don't translate message to text\n");
 507                 BIO_printf (bio_err, "-certfile file other certificates file\n");
 508                 BIO_printf (bio_err, "-signer file   signer certificate file\n");
 509                 BIO_printf (bio_err, "-recip  file   recipient certificate file for decryption\n");
 510                 BIO_printf (bio_err, "-skeyid        use subject key identifier\n");
 511                 BIO_printf (bio_err, "-in file       input file\n");
 512                 BIO_printf (bio_err, "-inform arg    input format SMIME (default), PEM or DER\n");
 513                 BIO_printf (bio_err, "-inkey file    input private key (if not signer or recipient)\n");
 514                 BIO_printf (bio_err, "-keyform arg   input private key format (PEM or ENGINE)\n");
 515                 BIO_printf (bio_err, "-out file      output file\n");
 516                 BIO_printf (bio_err, "-outform arg   output format SMIME (default), PEM or DER\n");
 517                 BIO_printf (bio_err, "-content file  supply or override content for detached signature\n");
 518                 BIO_printf (bio_err, "-to addr       to address\n");
 519                 BIO_printf (bio_err, "-from ad       from address\n");
 520                 BIO_printf (bio_err, "-subject s     subject\n");
 521                 BIO_printf (bio_err, "-text          include or delete text MIME headers\n");
 522                 BIO_printf (bio_err, "-CApath dir    trusted certificates directory\n");
 523                 BIO_printf (bio_err, "-CAfile file   trusted certificates file\n");
 524                 BIO_printf (bio_err, "-crl_check     check revocation status of signer's certificate using CRLs\n");
 525                 BIO_printf (bio_err, "-crl_check_all check revocation status of signer's certificate chain using CRLs\n");
 526 #ifndef OPENSSL_NO_ENGINE
 527                 BIO_printf (bio_err, "-engine e      use engine e, possibly a hardware device.\n");
 528 #endif
 529                 BIO_printf (bio_err, "-passin arg    input file pass phrase source\n");
 530                 BIO_printf(bio_err,  "-rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR);
 531                 BIO_printf(bio_err,  "               load the file (or the files in the directory) into\n");
 532                 BIO_printf(bio_err,  "               the random number generator\n");
 533                 BIO_printf (bio_err, "cert.pem       recipient certificate(s) for encryption\n");
 534                 goto end;
 535                 }
 536
 537 #ifndef OPENSSL_NO_ENGINE
 538         e = setup_engine(bio_err, engine, 0);
 539 #endif
 540
 541         if (!app_passwd(bio_err, passargin, NULL, &passin, NULL))
 542                 {
 543                 BIO_printf(bio_err, "Error getting password\n");
 544                 goto end;
 545                 }
 546
 547         if (need_rand)
 548                 {
 549                 app_RAND_load_file(NULL, bio_err, (inrand != NULL));
 550                 if (inrand != NULL)
 551                         BIO_printf(bio_err,"%ld semi-random bytes loaded\n",
 552                                 app_RAND_load_files(inrand));
 553                 }
 554
 555         ret = 2;
 556
 557         if (!(operation & SMIME_SIGNERS))
 558                 flags &= ~CMS_DETACHED;
 559
 560         if (operation & SMIME_OP)
 561                 {
 562                 if (outformat == FORMAT_ASN1)
 563                         outmode = "wb";
 564                 }
 565         else
 566                 {
 567                 if (flags & CMS_BINARY)
 568                         outmode = "wb";
 569                 }
 570
 571         if (operation & SMIME_IP)
 572                 {
 573                 if (informat == FORMAT_ASN1)
 574                         inmode = "rb";
 575                 }
 576         else
 577                 {
 578                 if (flags & CMS_BINARY)
 579                         inmode = "rb";
 580                 }
 581
 582         if (operation == SMIME_ENCRYPT)
 583                 {
 584                 if (!cipher)
 585                         {
 586 #ifndef OPENSSL_NO_RC2
 587                         cipher = EVP_rc2_40_cbc();
 588 #else
 589                         BIO_printf(bio_err, "No cipher selected\n");
 590                         goto end;
 591 #endif
 592                         }
 593                 encerts = sk_X509_new_null();
 594                 while (*args)
 595                         {
 596                         if (!(cert = load_cert(bio_err,*args,FORMAT_PEM,
 597                                 NULL, e, "recipient certificate file")))
 598                                 {
 599 #if 0                           /* An appropriate message is already printed */
 600                                 BIO_printf(bio_err, "Can't read recipient certificate file %s\n", *args);
 601 #endif
 602                                 goto end;
 603                                 }
 604                         sk_X509_push(encerts, cert);
 605                         cert = NULL;
 606                         args++;
 607                         }
 608                 }
 609
 610         if (certfile)
 611                 {
 612                 if (!(other = load_certs(bio_err,certfile,FORMAT_PEM, NULL,
 613                         e, "certificate file")))
 614                         {
 615                         ERR_print_errors(bio_err);
 616                         goto end;
 617                         }
 618                 }
 619
 620         if (recipfile && (operation == SMIME_DECRYPT))
 621                 {
 622                 if (!(recip = load_cert(bio_err,recipfile,FORMAT_PEM,NULL,
 623                         e, "recipient certificate file")))
 624                         {
 625                         ERR_print_errors(bio_err);
 626                         goto end;
 627                         }
 628                 }
 629
 630         if (operation == SMIME_DECRYPT)
 631                 {
 632                 if (!keyfile)
 633                         keyfile = recipfile;
 634                 }
 635         else if (operation == SMIME_SIGN)
 636                 {
 637                 if (!keyfile)
 638                         keyfile = signerfile;
 639                 }
 640         else keyfile = NULL;
 641
 642         if (keyfile)
 643                 {
 644                 key = load_key(bio_err, keyfile, keyform, 0, passin, e,
 645                                "signing key file");
 646                 if (!key)
 647                         goto end;
 648                 }
 649
 650         if (infile)
 651                 {
 652                 if (!(in = BIO_new_file(infile, inmode)))
 653                         {
 654                         BIO_printf (bio_err,
 655                                  "Can't open input file %s\n", infile);
 656                         goto end;
 657                         }
 658                 }
 659         else
 660                 in = BIO_new_fp(stdin, BIO_NOCLOSE);
 661
 662         if (operation & SMIME_IP)
 663                 {
 664                 if (informat == FORMAT_SMIME)
 665                         cms = SMIME_read_CMS(in, &indata);
 666                 else if (informat == FORMAT_PEM)
 667                         cms = PEM_read_bio_CMS(in, NULL, NULL, NULL);
 668                 else if (informat == FORMAT_ASN1)
 669                         cms = d2i_CMS_bio(in, NULL);
 670                 else
 671                         {
 672                         BIO_printf(bio_err, "Bad input format for CMS file\n");
 673                         goto end;
 674                         }
 675
 676                 if (!cms)
 677                         {
 678                         BIO_printf(bio_err, "Error reading S/MIME message\n");
 679                         goto end;
 680                         }
 681                 if (contfile)
 682                         {
 683                         BIO_free(indata);
 684                         if (!(indata = BIO_new_file(contfile, "rb")))
 685                                 {
 686                                 BIO_printf(bio_err, "Can't read content file %s\n", contfile);
 687                                 goto end;
 688                                 }
 689                         }
 690                 }
 691
 692         if (outfile)
 693                 {
 694                 if (!(out = BIO_new_file(outfile, outmode)))
 695                         {
 696                         BIO_printf (bio_err,
 697                                  "Can't open output file %s\n", outfile);
 698                         goto end;
 699                         }
 700                 }
 701         else
 702                 {
 703                 out = BIO_new_fp(stdout, BIO_NOCLOSE);
 704 #ifdef OPENSSL_SYS_VMS
 705                 {
 706                     BIO *tmpbio = BIO_new(BIO_f_linebuffer());
 707                     out = BIO_push(tmpbio, out);
 708                 }
 709 #endif
 710                 }
 711
 712         if (operation == SMIME_VERIFY)
 713                 {
 714                 if (!(store = setup_verify(bio_err, CAfile, CApath)))
 715                         goto end;
 716                 X509_STORE_set_verify_cb_func(store, smime_cb);
 717                 if (vpm)
 718                         X509_STORE_set1_param(store, vpm);
 719                 }
 720
 721
 722         ret = 3;
 723
 724         if (operation == SMIME_DATA_CREATE)
 725                 {
 726                 if (indef)
 727                         flags |= CMS_STREAM;
 728                 cms = CMS_data_create(in, flags);
 729                 }
 730         else if (operation == SMIME_DIGEST_CREATE)
 731                 {
 732                 if (indef)
 733                         flags |= CMS_STREAM;
 734                 cms = CMS_digest_create(in, sign_md, flags);
 735                 }
 736         else if (operation == SMIME_COMPRESS)
 737                 {
 738                 if (indef)
 739                         flags |= CMS_STREAM;
 740                 cms = CMS_compress(in, -1, flags);
 741                 }
 742         else if (operation == SMIME_ENCRYPT)
 743                 {
 744                 if (indef)
 745                         flags |= CMS_STREAM;
 746                 cms = CMS_encrypt(encerts, in, cipher, flags);
 747                 }
 748         else if (operation & SMIME_SIGNERS)
 749                 {
 750                 int i;
 751                 /* If detached data content we only enable streaming if
 752                  * S/MIME output format.
 753                  */
 754                 if (operation == SMIME_SIGN)
 755                         {
 756                         if (flags & CMS_DETACHED)
 757                                 {
 758                                 if (outformat == FORMAT_SMIME)
 759                                         flags |= CMS_STREAM;
 760                                 }
 761                         else if (indef)
 762                                 flags |= CMS_STREAM;
 763                         flags |= CMS_PARTIAL;
 764                         cms = CMS_sign(NULL, NULL, other, in, flags);
 765                         if (!cms)
 766                                 goto end;
 767                         }
 768                 else
 769                         flags |= CMS_REUSE_DIGEST;
 770                 for (i = 0; i < sk_num(sksigners); i++)
 771                         {
 772                         signerfile = sk_value(sksigners, i);
 773                         keyfile = sk_value(skkeys, i);
 774                         signer = load_cert(bio_err, signerfile,FORMAT_PEM, NULL,
 775                                         e, "signer certificate");
 776                         if (!signer)
 777                                 goto end;
 778                         key = load_key(bio_err, keyfile, keyform, 0, passin, e,
 779                                "signing key file");
 780                         if (!key)
 781                                 goto end;
 782                         if (!CMS_add1_signer(cms, signer, key, sign_md, flags))
 783                                 goto end;
 784                         X509_free(signer);
 785                         signer = NULL;
 786                         EVP_PKEY_free(key);
 787                         key = NULL;
 788                         }
 789                 /* If not streaming or resigning finalize structure */
 790                 if ((operation == SMIME_SIGN) && !(flags & CMS_STREAM))
 791                         {
 792                         if (!CMS_final(cms, in, flags))
 793                                 goto end;
 794                         }
 795                 }
 796
 797         if (!cms)
 798                 {
 799                 BIO_printf(bio_err, "Error creating CMS structure\n");
 800                 goto end;
 801                 }
 802
 803         ret = 4;
 804         if (operation == SMIME_DECRYPT)
 805                 {
 806                 if (!CMS_decrypt(cms, key, recip, out, flags))
 807                         {
 808                         BIO_printf(bio_err, "Error decrypting CMS structure\n");
 809                         goto end;
 810                         }
 811                 }
 812         else if (operation == SMIME_DATAOUT)
 813                 {
 814                 if (!CMS_data(cms, out, flags))
 815                         goto end;
 816                 }
 817         else if (operation == SMIME_UNCOMPRESS)
 818                 {
 819                 if (!CMS_uncompress(cms, indata, out, flags))
 820                         goto end;
 821                 }
 822         else if (operation == SMIME_DIGEST_VERIFY)
 823                 {
 824                 if (CMS_digest_verify(cms, indata, out, flags) > 0)
 825                         BIO_printf(bio_err, "Verification successful\n");
 826                 else
 827                         {
 828                         BIO_printf(bio_err, "Verification failure\n");
 829                         goto end;
 830                         }
 831                 }
 832         else if (operation == SMIME_ENCRYPTED_DECRYPT)
 833                 {
 834                 if (!CMS_EncryptedData_decrypt(cms, secret_key, secret_keylen,
 835                                                 indata, out, flags))
 836                         goto end;
 837                 }
 838         else if (operation == SMIME_VERIFY)
 839                 {
 840                 if (CMS_verify(cms, other, store, indata, out, flags) > 0)
 841                         BIO_printf(bio_err, "Verification successful\n");
 842                 else
 843                         {
 844                         BIO_printf(bio_err, "Verification failure\n");
 845                         goto end;
 846                         }
 847                 if (signerfile)
 848                         {
 849                         STACK_OF(X509) *signers;
 850                         signers = CMS_get0_signers(cms);
 851                         if (!save_certs(signerfile, signers))
 852                                 {
 853                                 BIO_printf(bio_err,
 854                                                 "Error writing signers to %s\n",
 855                                                                 signerfile);
 856                                 ret = 5;
 857                                 goto end;
 858                                 }
 859                         sk_X509_free(signers);
 860                         }
 861                 }
 862         else
 863                 {
 864                 if (outformat == FORMAT_SMIME)
 865                         {
 866                         if (to)
 867                                 BIO_printf(out, "To: %s\n", to);
 868                         if (from)
 869                                 BIO_printf(out, "From: %s\n", from);
 870                         if (subject)
 871                                 BIO_printf(out, "Subject: %s\n", subject);
 872                         if (operation == SMIME_RESIGN)
 873                                 ret = SMIME_write_CMS(out, cms, indata, flags);
 874                         else
 875                                 ret = SMIME_write_CMS(out, cms, in, flags);
 876                         }
 877                 else if (outformat == FORMAT_PEM)
 878                         ret = PEM_write_bio_CMS_stream(out, cms, in, flags);
 879                 else if (outformat == FORMAT_ASN1)
 880                         ret = i2d_CMS_bio_stream(out,cms, in, flags);
 881                 else
 882                         {
 883                         BIO_printf(bio_err, "Bad output format for CMS file\n");
 884                         goto end;
 885                         }
 886                 if (ret <= 0)
 887                         {
 888                         ret = 6;
 889                         goto end;
 890                         }
 891                 }
 892         ret = 0;
 893 end:
 894         if (ret)
 895                 ERR_print_errors(bio_err);
 896         if (need_rand)
 897                 app_RAND_write_file(NULL, bio_err);
 898         sk_X509_pop_free(encerts, X509_free);
 899         sk_X509_pop_free(other, X509_free);
 900         if (vpm)
 901                 X509_VERIFY_PARAM_free(vpm);
 902         if (sksigners)
 903                 sk_free(sksigners);
 904         if (skkeys)
 905                 sk_free(skkeys);
 906         if (secret_key)
 907                 OPENSSL_free(secret_key);
 908         X509_STORE_free(store);
 909         X509_free(cert);
 910         X509_free(recip);
 911         X509_free(signer);
 912         EVP_PKEY_free(key);
 913         CMS_ContentInfo_free(cms);
 914         BIO_free(in);
 915         BIO_free(indata);
 916         BIO_free_all(out);
 917         if (passin) OPENSSL_free(passin);
 918         return (ret);
 919 }
 920
 921 static int save_certs(char *signerfile, STACK_OF(X509) *signers)
 922         {
 923         int i;
 924         BIO *tmp;
 925         if (!signerfile)
 926                 return 1;
 927         tmp = BIO_new_file(signerfile, "w");
 928         if (!tmp) return 0;
 929         for(i = 0; i < sk_X509_num(signers); i++)
 930                 PEM_write_bio_X509(tmp, sk_X509_value(signers, i));
 931         BIO_free(tmp);
 932         return 1;
 933         }
 934
 935
 936 /* Minimal callback just to output policy info (if any) */
 937
 938 static int smime_cb(int ok, X509_STORE_CTX *ctx)
 939         {
 940         int error;
 941
 942         error = X509_STORE_CTX_get_error(ctx);
 943
 944         if ((error != X509_V_ERR_NO_EXPLICIT_POLICY)
 945                 && ((error != X509_V_OK) || (ok != 2)))
 946                 return ok;
 947
 948         policies_print(NULL, ctx);
 949
 950         return ok;
 951
 952         }
 953
 954 #endif