apps/ts.c

   1 /*
   2  * Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL project
   3  * 2002.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2001 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  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62 #include "apps.h"
  63 #include <openssl/bio.h>
  64 #include <openssl/err.h>
  65 #include <openssl/pem.h>
  66 #include <openssl/rand.h>
  67 #include <openssl/ts.h>
  68 #include <openssl/bn.h>
  69
  70 /* Length of the nonce of the request in bits (must be a multiple of 8). */
  71 #define NONCE_LENGTH            64
  72
  73 /* Macro definitions for the configuration file. */
  74 #define ENV_OID_FILE            "oid_file"
  75
  76 /* Local function declarations. */
  77
  78 static ASN1_OBJECT *txt2obj(const char *oid);
  79 static CONF *load_config_file(const char *configfile);
  80
  81 /* Query related functions. */
  82 static int query_command(const char *data, char *digest,
  83                          const EVP_MD *md, const char *policy, int no_nonce,
  84                          int cert, const char *in, const char *out, int text);
  85 static TS_REQ *create_query(BIO *data_bio, char *digest, const EVP_MD *md,
  86                             const char *policy, int no_nonce, int cert);
  87 static int create_digest(BIO *input, char *digest,
  88                          const EVP_MD *md, unsigned char **md_value);
  89 static ASN1_INTEGER *create_nonce(int bits);
  90
  91 /* Reply related functions. */
  92 static int reply_command(CONF *conf, char *section, char *engine,
  93                          char *queryfile, char *passin, char *inkey,
  94                          char *signer, char *chain, const char *policy,
  95                          char *in, int token_in, char *out, int token_out,
  96                          int text);
  97 static TS_RESP *read_PKCS7(BIO *in_bio);
  98 static TS_RESP *create_response(CONF *conf, const char *section, char *engine,
  99                                 char *queryfile, char *passin,
 100                                 char *inkey, char *signer, char *chain,
 101                                 const char *policy);
 102 static ASN1_INTEGER *serial_cb(TS_RESP_CTX *ctx, void *data);
 103 static ASN1_INTEGER *next_serial(const char *serialfile);
 104 static int save_ts_serial(const char *serialfile, ASN1_INTEGER *serial);
 105
 106 /* Verify related functions. */
 107 static int verify_command(char *data, char *digest, char *queryfile,
 108                           char *in, int token_in,
 109                           char *CApath, char *CAfile, char *untrusted);
 110 static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest,
 111                                         char *queryfile,
 112                                         char *CApath, char *CAfile,
 113                                         char *untrusted);
 114 static X509_STORE *create_cert_store(char *CApath, char *CAfile);
 115 static int verify_cb(int ok, X509_STORE_CTX *ctx);
 116
 117 typedef enum OPTION_choice {
 118     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 119     OPT_ENGINE, OPT_CONFIG, OPT_SECTION, OPT_QUERY, OPT_DATA,
 120     OPT_DIGEST, OPT_RAND, OPT_POLICY, OPT_NO_NONCE, OPT_CERT,
 121     OPT_IN, OPT_TOKEN_IN, OPT_OUT, OPT_TOKEN_OUT, OPT_TEXT,
 122     OPT_REPLY, OPT_QUERYFILE, OPT_PASSIN, OPT_INKEY, OPT_SIGNER,
 123     OPT_CHAIN, OPT_VERIFY, OPT_CAPATH, OPT_CAFILE, OPT_UNTRUSTED,
 124     OPT_MD
 125 } OPTION_CHOICE;
 126
 127 OPTIONS ts_options[] = {
 128     {"help", OPT_HELP, '-', "Display this summary"},
 129     {"config", OPT_CONFIG, '<', "Configuration file"},
 130     {"section", OPT_SECTION, 's', "Section to use within config file"},
 131     {"query", OPT_QUERY, '-', "Generate a TS query"},
 132     {"data", OPT_DATA, '<', "File to hash"},
 133     {"digest", OPT_DIGEST, 's', "Digest (as a hex string)"},
 134     {"rand", OPT_RAND, 's',
 135      "Load the file(s) into the random number generator"},
 136     {"policy", OPT_POLICY, 's', "Policy OID to use"},
 137     {"no_nonce", OPT_NO_NONCE, '-', "Do not include a nonce"},
 138     {"cert", OPT_CERT, '-', "Put cert request into query"},
 139     {"in", OPT_IN, '<', "Input file"},
 140     {"token_in", OPT_TOKEN_IN, '-', "Input is a PKCS#7 file"},
 141     {"out", OPT_OUT, '>', "Output file"},
 142     {"token_out", OPT_TOKEN_OUT, '-', "Output is a PKCS#7 file"},
 143     {"text", OPT_TEXT, '-', "Output text (not DER)"},
 144     {"reply", OPT_REPLY, '-', "Generate a TS reply"},
 145     {"queryfile", OPT_QUERYFILE, '<', "File containing a TS query"},
 146     {"passin", OPT_PASSIN, 's'},
 147     {"inkey", OPT_INKEY, '<', "File with private key for reply"},
 148     {"signer", OPT_SIGNER, 's'},
 149     {"chain", OPT_CHAIN, '<', "File with signer CA chain"},
 150     {"verify", OPT_VERIFY, '-', "Verify a TS response"},
 151     {"CApath", OPT_CAPATH, '/', "Path to trusted CA files"},
 152     {"CAfile", OPT_CAFILE, '<', "File with trusted CA certs"},
 153     {"untrusted", OPT_UNTRUSTED, '<', "File with untrusted certs"},
 154     {"", OPT_MD, '-', "Any supported digest"},
 155 #ifndef OPENSSL_NO_ENGINE
 156     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 157 #endif
 158     {NULL}
 159 };
 160
 161 /*
 162  * This comand is so complex, special help is needed.
 163  */
 164 static char* opt_helplist[] = {
 165     "Typical uses:",
 166     "ts -query [-rand file...] [-config file] [-data file]",
 167     "          [-digest hexstring] [-policy oid] [-no_nonce] [-cert]",
 168     "          [-in file] [-out file] [-text]",
 169     "  or",
 170     "ts -reply [-config file] [-section tsa_section]",
 171     "          [-queryfile file] [-passin password]",
 172     "          [-signer tsa_cert.pem] [-inkey private_key.pem]",
 173     "          [-chain certs_file.pem] [-policy oid]",
 174     "          [-in file] [-token_in] [-out file] [-token_out]",
 175 #ifndef OPENSSL_NO_ENGINE
 176     "          [-text]",
 177 #else
 178     "          [-text] [-engine id]",
 179 #endif
 180     "  or",
 181     "ts -verify -CApath dir -CAfile file.pem -untrusted file.pem",
 182     "           [-data file] [-digest hexstring]",
 183     "           [-queryfile file] -in file [-token_in]",
 184     NULL,
 185 };
 186
 187 int ts_main(int argc, char **argv)
 188 {
 189     CONF *conf = NULL;
 190     char *CAfile = NULL, *untrusted = NULL, *engine = NULL, *prog, **helpp;
 191     char *configfile = default_config_file;
 192     char *section = NULL, *password = NULL;
 193     char *data = NULL, *digest = NULL, *rnd = NULL, *policy = NULL;
 194     char *in = NULL, *out = NULL, *queryfile = NULL, *passin = NULL;
 195     char *inkey = NULL, *signer = NULL, *chain = NULL, *CApath = NULL;
 196     const EVP_MD *md = NULL;
 197     OPTION_CHOICE o, mode = OPT_ERR;
 198     int ret = 1, no_nonce = 0, cert = 0, text = 0;
 199     /* Input is ContentInfo instead of TimeStampResp. */
 200     int token_in = 0;
 201     /* Output is ContentInfo instead of TimeStampResp. */
 202     int token_out = 0;
 203
 204     prog = opt_init(argc, argv, ts_options);
 205     while ((o = opt_next()) != OPT_EOF) {
 206         switch (o) {
 207         case OPT_EOF:
 208         case OPT_ERR:
 209  opthelp:
 210             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 211             goto end;
 212         case OPT_HELP:
 213             opt_help(ts_options);
 214             for (helpp = opt_helplist; *helpp; ++helpp)
 215                 BIO_printf(bio_err, "%s\n", *helpp);
 216             ret = 0;
 217             goto end;
 218         case OPT_CONFIG:
 219             configfile = opt_arg();
 220             break;
 221         case OPT_SECTION:
 222             section = opt_arg();
 223             break;
 224         case OPT_QUERY:
 225         case OPT_REPLY:
 226         case OPT_VERIFY:
 227             if (mode != OPT_ERR)
 228                 goto opthelp;
 229             mode = o;
 230             break;
 231         case OPT_DATA:
 232             data = opt_arg();
 233             break;
 234         case OPT_DIGEST:
 235             digest = opt_arg();
 236             break;
 237         case OPT_RAND:
 238             rnd = opt_arg();
 239             break;
 240         case OPT_POLICY:
 241             policy = opt_arg();
 242             break;
 243         case OPT_NO_NONCE:
 244             no_nonce = 1;
 245             break;
 246         case OPT_CERT:
 247             cert = 1;
 248             break;
 249         case OPT_IN:
 250             in = opt_arg();
 251             break;
 252         case OPT_TOKEN_IN:
 253             token_in = 1;
 254             break;
 255         case OPT_OUT:
 256             out = opt_arg();
 257             break;
 258         case OPT_TOKEN_OUT:
 259             token_out = 1;
 260             break;
 261         case OPT_TEXT:
 262             text = 1;
 263             break;
 264         case OPT_QUERYFILE:
 265             queryfile = opt_arg();
 266             break;
 267         case OPT_PASSIN:
 268             passin = opt_arg();
 269             break;
 270         case OPT_INKEY:
 271             inkey = opt_arg();
 272             break;
 273         case OPT_SIGNER:
 274             signer = opt_arg();
 275             break;
 276         case OPT_CHAIN:
 277             chain = opt_arg();
 278             break;
 279         case OPT_CAPATH:
 280             CApath = opt_arg();
 281             break;
 282         case OPT_CAFILE:
 283             CAfile = opt_arg();
 284             break;
 285         case OPT_UNTRUSTED:
 286             untrusted = opt_arg();
 287             break;
 288         case OPT_ENGINE:
 289             engine = opt_arg();
 290             break;
 291         case OPT_MD:
 292             if (!opt_md(opt_unknown(), &md))
 293                 goto opthelp;
 294             break;
 295         }
 296     }
 297     argc = opt_num_rest();
 298     argv = opt_rest();
 299     if (mode == OPT_ERR || argc != 0)
 300         goto opthelp;
 301
 302     /* Seed the random number generator if it is going to be used. */
 303     if (mode == OPT_QUERY && !no_nonce) {
 304         if (!app_RAND_load_file(NULL, 1) && rnd == NULL)
 305             BIO_printf(bio_err, "warning, not much extra random "
 306                        "data, consider using the -rand option\n");
 307         if (rnd != NULL)
 308             BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
 309                        app_RAND_load_files(rnd));
 310     }
 311
 312     /* Get the password if required. */
 313     if (mode == OPT_REPLY && passin &&
 314         !app_passwd(passin, NULL, &password, NULL)) {
 315         BIO_printf(bio_err, "Error getting password.\n");
 316         goto end;
 317     }
 318
 319     conf = load_config_file(configfile);
 320     if (!app_load_modules(conf))
 321         goto end;
 322
 323     /*
 324      * Check consistency of parameters and execute the appropriate function.
 325      */
 326     switch (mode) {
 327     default:
 328     case OPT_ERR:
 329         goto opthelp;
 330     case OPT_QUERY:
 331         /*
 332          * Data file and message imprint cannot be specified at the same
 333          * time.
 334          */
 335         ret = data != NULL && digest != NULL;
 336         if (ret)
 337             goto opthelp;
 338         ret = !query_command(data, digest, md, policy, no_nonce, cert,
 339                              in, out, text);
 340         break;
 341     case OPT_REPLY:
 342         if (in == NULL) {
 343             ret = !(queryfile != NULL && conf != NULL && !token_in);
 344             if (ret)
 345                 goto opthelp;
 346         } else {
 347             /* 'in' and 'queryfile' are exclusive. */
 348             ret = !(queryfile == NULL);
 349             if (ret)
 350                 goto opthelp;
 351         }
 352         ret = !reply_command(conf, section, engine, queryfile,
 353                              password, inkey, signer, chain, policy,
 354                              in, token_in, out, token_out, text);
 355         break;
 356     case OPT_VERIFY:
 357         ret = !(((queryfile && !data && !digest)
 358                  || (!queryfile && data && !digest)
 359                  || (!queryfile && !data && digest))
 360                 && in != NULL);
 361         if (ret)
 362             goto opthelp;
 363
 364         ret = !verify_command(data, digest, queryfile, in, token_in,
 365                               CApath, CAfile, untrusted);
 366     }
 367
 368  end:
 369     /* Clean up. */
 370     app_RAND_write_file(NULL);
 371     NCONF_free(conf);
 372     OPENSSL_free(password);
 373     OBJ_cleanup();
 374
 375     return (ret);
 376 }
 377
 378 /*
 379  * Configuration file-related function definitions.
 380  */
 381
 382 static ASN1_OBJECT *txt2obj(const char *oid)
 383 {
 384     ASN1_OBJECT *oid_obj = NULL;
 385
 386     if ((oid_obj = OBJ_txt2obj(oid, 0)) == NULL)
 387         BIO_printf(bio_err, "cannot convert %s to OID\n", oid);
 388
 389     return oid_obj;
 390 }
 391
 392 static CONF *load_config_file(const char *configfile)
 393 {
 394     CONF *conf = app_load_config(configfile);
 395
 396     if (conf != NULL) {
 397         const char *p;
 398
 399         BIO_printf(bio_err, "Using configuration from %s\n", configfile);
 400         p = NCONF_get_string(conf, NULL, ENV_OID_FILE);
 401         if (p != NULL) {
 402             BIO *oid_bio = BIO_new_file(p, "r");
 403             if (!oid_bio)
 404                 ERR_print_errors(bio_err);
 405             else {
 406                 OBJ_create_objects(oid_bio);
 407                 BIO_free_all(oid_bio);
 408             }
 409         } else
 410             ERR_clear_error();
 411         if (!add_oid_section(conf))
 412             ERR_print_errors(bio_err);
 413     }
 414     return conf;
 415 }
 416
 417 /*
 418  * Query-related method definitions.
 419  */
 420 static int query_command(const char *data, char *digest, const EVP_MD *md,
 421                          const char *policy, int no_nonce,
 422                          int cert, const char *in, const char *out, int text)
 423 {
 424     int ret = 0;
 425     TS_REQ *query = NULL;
 426     BIO *in_bio = NULL;
 427     BIO *data_bio = NULL;
 428     BIO *out_bio = NULL;
 429
 430     /* Build query object either from file or from scratch. */
 431     if (in != NULL) {
 432         if ((in_bio = BIO_new_file(in, "rb")) == NULL)
 433             goto end;
 434         query = d2i_TS_REQ_bio(in_bio, NULL);
 435     } else {
 436         /* Open the file if no explicit digest bytes were specified. */
 437         if (digest == NULL
 438             && (data_bio = bio_open_default(data, "rb")) == NULL)
 439             goto end;
 440         query = create_query(data_bio, digest, md, policy, no_nonce, cert);
 441     }
 442     if (query == NULL)
 443         goto end;
 444
 445     /* Write query either in ASN.1 or in text format. */
 446     if ((out_bio = bio_open_default(out, "wb")) == NULL)
 447         goto end;
 448     if (text) {
 449         /* Text output. */
 450         if (!TS_REQ_print_bio(out_bio, query))
 451             goto end;
 452     } else {
 453         /* ASN.1 output. */
 454         if (!i2d_TS_REQ_bio(out_bio, query))
 455             goto end;
 456     }
 457
 458     ret = 1;
 459
 460  end:
 461     ERR_print_errors(bio_err);
 462
 463     /* Clean up. */
 464     BIO_free_all(in_bio);
 465     BIO_free_all(data_bio);
 466     BIO_free_all(out_bio);
 467     TS_REQ_free(query);
 468
 469     return ret;
 470 }
 471
 472 static TS_REQ *create_query(BIO *data_bio, char *digest, const EVP_MD *md,
 473                             const char *policy, int no_nonce, int cert)
 474 {
 475     int ret = 0;
 476     TS_REQ *ts_req = NULL;
 477     int len;
 478     TS_MSG_IMPRINT *msg_imprint = NULL;
 479     X509_ALGOR *algo = NULL;
 480     unsigned char *data = NULL;
 481     ASN1_OBJECT *policy_obj = NULL;
 482     ASN1_INTEGER *nonce_asn1 = NULL;
 483
 484     /* Setting default message digest. */
 485     if (md == NULL && (md = EVP_get_digestbyname("sha1")) == NULL)
 486         goto err;
 487
 488     /* Creating request object. */
 489     if ((ts_req = TS_REQ_new()) == NULL)
 490         goto err;
 491
 492     /* Setting version. */
 493     if (!TS_REQ_set_version(ts_req, 1))
 494         goto err;
 495
 496     /* Creating and adding MSG_IMPRINT object. */
 497     if ((msg_imprint = TS_MSG_IMPRINT_new()) == NULL)
 498         goto err;
 499
 500     /* Adding algorithm. */
 501     if ((algo = X509_ALGOR_new()) == NULL)
 502         goto err;
 503     if ((algo->algorithm = OBJ_nid2obj(EVP_MD_type(md))) == NULL)
 504         goto err;
 505     if ((algo->parameter = ASN1_TYPE_new()) == NULL)
 506         goto err;
 507     algo->parameter->type = V_ASN1_NULL;
 508     if (!TS_MSG_IMPRINT_set_algo(msg_imprint, algo))
 509         goto err;
 510
 511     /* Adding message digest. */
 512     if ((len = create_digest(data_bio, digest, md, &data)) == 0)
 513         goto err;
 514     if (!TS_MSG_IMPRINT_set_msg(msg_imprint, data, len))
 515         goto err;
 516
 517     if (!TS_REQ_set_msg_imprint(ts_req, msg_imprint))
 518         goto err;
 519
 520     /* Setting policy if requested. */
 521     if (policy && (policy_obj = txt2obj(policy)) == NULL)
 522         goto err;
 523     if (policy_obj && !TS_REQ_set_policy_id(ts_req, policy_obj))
 524         goto err;
 525
 526     /* Setting nonce if requested. */
 527     if (!no_nonce && (nonce_asn1 = create_nonce(NONCE_LENGTH)) == NULL)
 528         goto err;
 529     if (nonce_asn1 && !TS_REQ_set_nonce(ts_req, nonce_asn1))
 530         goto err;
 531
 532     /* Setting certificate request flag if requested. */
 533     if (!TS_REQ_set_cert_req(ts_req, cert))
 534         goto err;
 535
 536     ret = 1;
 537  err:
 538     if (!ret) {
 539         TS_REQ_free(ts_req);
 540         ts_req = NULL;
 541         BIO_printf(bio_err, "could not create query\n");
 542     }
 543     TS_MSG_IMPRINT_free(msg_imprint);
 544     X509_ALGOR_free(algo);
 545     OPENSSL_free(data);
 546     ASN1_OBJECT_free(policy_obj);
 547     ASN1_INTEGER_free(nonce_asn1);
 548     return ts_req;
 549 }
 550
 551 static int create_digest(BIO *input, char *digest, const EVP_MD *md,
 552                          unsigned char **md_value)
 553 {
 554     int md_value_len;
 555
 556     md_value_len = EVP_MD_size(md);
 557     if (md_value_len < 0)
 558         goto err;
 559     if (input) {
 560         /* Digest must be computed from an input file. */
 561         EVP_MD_CTX md_ctx;
 562         unsigned char buffer[4096];
 563         int length;
 564
 565         *md_value = app_malloc(md_value_len, "digest buffer");
 566         EVP_DigestInit(&md_ctx, md);
 567         while ((length = BIO_read(input, buffer, sizeof(buffer))) > 0) {
 568             EVP_DigestUpdate(&md_ctx, buffer, length);
 569         }
 570         if (!EVP_DigestFinal(&md_ctx, *md_value, NULL))
 571             return 0;
 572     } else {
 573         /* Digest bytes are specified with digest. */
 574         long digest_len;
 575         *md_value = string_to_hex(digest, &digest_len);
 576         if (!*md_value || md_value_len != digest_len) {
 577             OPENSSL_free(*md_value);
 578             *md_value = NULL;
 579             BIO_printf(bio_err, "bad digest, %d bytes "
 580                        "must be specified\n", md_value_len);
 581             goto err;
 582         }
 583     }
 584
 585     return md_value_len;
 586  err:
 587     return 0;
 588 }
 589
 590 static ASN1_INTEGER *create_nonce(int bits)
 591 {
 592     unsigned char buf[20];
 593     ASN1_INTEGER *nonce = NULL;
 594     int len = (bits - 1) / 8 + 1;
 595     int i;
 596
 597     /* Generating random byte sequence. */
 598     if (len > (int)sizeof(buf))
 599         goto err;
 600     if (RAND_bytes(buf, len) <= 0)
 601         goto err;
 602
 603     /* Find the first non-zero byte and creating ASN1_INTEGER object. */
 604     for (i = 0; i < len && !buf[i]; ++i)
 605         continue;
 606     if ((nonce = ASN1_INTEGER_new()) == NULL)
 607         goto err;
 608     OPENSSL_free(nonce->data);
 609     /* Allocate at least one byte. */
 610     nonce->length = len - i;
 611     nonce->data = app_malloc(nonce->length + 1, "nonce buffer");
 612     memcpy(nonce->data, buf + i, nonce->length);
 613
 614     return nonce;
 615  err:
 616     BIO_printf(bio_err, "could not create nonce\n");
 617     ASN1_INTEGER_free(nonce);
 618     return NULL;
 619 }
 620
 621 /*
 622  * Reply-related method definitions.
 623  */
 624
 625 static int reply_command(CONF *conf, char *section, char *engine,
 626                          char *queryfile, char *passin, char *inkey,
 627                          char *signer, char *chain, const char *policy,
 628                          char *in, int token_in,
 629                          char *out, int token_out, int text)
 630 {
 631     int ret = 0;
 632     TS_RESP *response = NULL;
 633     BIO *in_bio = NULL;
 634     BIO *query_bio = NULL;
 635     BIO *inkey_bio = NULL;
 636     BIO *signer_bio = NULL;
 637     BIO *out_bio = NULL;
 638
 639     /* Build response object either from response or query. */
 640     if (in != NULL) {
 641         if ((in_bio = BIO_new_file(in, "rb")) == NULL)
 642             goto end;
 643         if (token_in) {
 644             /*
 645              * We have a ContentInfo (PKCS7) object, add 'granted' status
 646              * info around it.
 647              */
 648             response = read_PKCS7(in_bio);
 649         } else {
 650             /* We have a ready-made TS_RESP object. */
 651             response = d2i_TS_RESP_bio(in_bio, NULL);
 652         }
 653     } else {
 654         response = create_response(conf, section, engine, queryfile,
 655                                    passin, inkey, signer, chain, policy);
 656         if (response)
 657             BIO_printf(bio_err, "Response has been generated.\n");
 658         else
 659             BIO_printf(bio_err, "Response is not generated.\n");
 660     }
 661     if (response == NULL)
 662         goto end;
 663
 664     /* Write response either in ASN.1 or text format. */
 665     if ((out_bio = bio_open_default(out, "wb")) == NULL)
 666         goto end;
 667     if (text) {
 668         /* Text output. */
 669         if (token_out) {
 670             TS_TST_INFO *tst_info = TS_RESP_get_tst_info(response);
 671             if (!TS_TST_INFO_print_bio(out_bio, tst_info))
 672                 goto end;
 673         } else {
 674             if (!TS_RESP_print_bio(out_bio, response))
 675                 goto end;
 676         }
 677     } else {
 678         /* ASN.1 DER output. */
 679         if (token_out) {
 680             PKCS7 *token = TS_RESP_get_token(response);
 681             if (!i2d_PKCS7_bio(out_bio, token))
 682                 goto end;
 683         } else {
 684             if (!i2d_TS_RESP_bio(out_bio, response))
 685                 goto end;
 686         }
 687     }
 688
 689     ret = 1;
 690
 691  end:
 692     ERR_print_errors(bio_err);
 693
 694     /* Clean up. */
 695     BIO_free_all(in_bio);
 696     BIO_free_all(query_bio);
 697     BIO_free_all(inkey_bio);
 698     BIO_free_all(signer_bio);
 699     BIO_free_all(out_bio);
 700     TS_RESP_free(response);
 701
 702     return ret;
 703 }
 704
 705 /* Reads a PKCS7 token and adds default 'granted' status info to it. */
 706 static TS_RESP *read_PKCS7(BIO *in_bio)
 707 {
 708     int ret = 0;
 709     PKCS7 *token = NULL;
 710     TS_TST_INFO *tst_info = NULL;
 711     TS_RESP *resp = NULL;
 712     TS_STATUS_INFO *si = NULL;
 713
 714     /* Read PKCS7 object and extract the signed time stamp info. */
 715     if ((token = d2i_PKCS7_bio(in_bio, NULL)) == NULL)
 716         goto end;
 717     if ((tst_info = PKCS7_to_TS_TST_INFO(token)) == NULL)
 718         goto end;
 719
 720     /* Creating response object. */
 721     if ((resp = TS_RESP_new()) == NULL)
 722         goto end;
 723
 724     /* Create granted status info. */
 725     if ((si = TS_STATUS_INFO_new()) == NULL)
 726         goto end;
 727     if (!(ASN1_INTEGER_set(si->status, TS_STATUS_GRANTED)))
 728         goto end;
 729     if (!TS_RESP_set_status_info(resp, si))
 730         goto end;
 731
 732     /* Setting encapsulated token. */
 733     TS_RESP_set_tst_info(resp, token, tst_info);
 734     token = NULL;               /* Ownership is lost. */
 735     tst_info = NULL;            /* Ownership is lost. */
 736
 737     ret = 1;
 738  end:
 739     PKCS7_free(token);
 740     TS_TST_INFO_free(tst_info);
 741     if (!ret) {
 742         TS_RESP_free(resp);
 743         resp = NULL;
 744     }
 745     TS_STATUS_INFO_free(si);
 746     return resp;
 747 }
 748
 749 static TS_RESP *create_response(CONF *conf, const char *section, char *engine,
 750                                 char *queryfile, char *passin,
 751                                 char *inkey, char *signer, char *chain,
 752                                 const char *policy)
 753 {
 754     int ret = 0;
 755     TS_RESP *response = NULL;
 756     BIO *query_bio = NULL;
 757     TS_RESP_CTX *resp_ctx = NULL;
 758
 759     if ((query_bio = BIO_new_file(queryfile, "rb")) == NULL)
 760         goto end;
 761
 762     /* Getting TSA configuration section. */
 763     if ((section = TS_CONF_get_tsa_section(conf, section)) == NULL)
 764         goto end;
 765
 766     /* Setting up response generation context. */
 767     if ((resp_ctx = TS_RESP_CTX_new()) == NULL)
 768         goto end;
 769
 770     /* Setting serial number provider callback. */
 771     if (!TS_CONF_set_serial(conf, section, serial_cb, resp_ctx))
 772         goto end;
 773 #ifndef OPENSSL_NO_ENGINE
 774     /* Setting default OpenSSL engine. */
 775     if (!TS_CONF_set_crypto_device(conf, section, engine))
 776         goto end;
 777 #endif
 778
 779     /* Setting TSA signer certificate. */
 780     if (!TS_CONF_set_signer_cert(conf, section, signer, resp_ctx))
 781         goto end;
 782
 783     /* Setting TSA signer certificate chain. */
 784     if (!TS_CONF_set_certs(conf, section, chain, resp_ctx))
 785         goto end;
 786
 787     /* Setting TSA signer private key. */
 788     if (!TS_CONF_set_signer_key(conf, section, inkey, passin, resp_ctx))
 789         goto end;
 790
 791     /* Setting default policy OID. */
 792     if (!TS_CONF_set_def_policy(conf, section, policy, resp_ctx))
 793         goto end;
 794
 795     /* Setting acceptable policy OIDs. */
 796     if (!TS_CONF_set_policies(conf, section, resp_ctx))
 797         goto end;
 798
 799     /* Setting the acceptable one-way hash algorithms. */
 800     if (!TS_CONF_set_digests(conf, section, resp_ctx))
 801         goto end;
 802
 803     /* Setting guaranteed time stamp accuracy. */
 804     if (!TS_CONF_set_accuracy(conf, section, resp_ctx))
 805         goto end;
 806
 807     /* Setting the precision of the time. */
 808     if (!TS_CONF_set_clock_precision_digits(conf, section, resp_ctx))
 809         goto end;
 810
 811     /* Setting the ordering flaf if requested. */
 812     if (!TS_CONF_set_ordering(conf, section, resp_ctx))
 813         goto end;
 814
 815     /* Setting the TSA name required flag if requested. */
 816     if (!TS_CONF_set_tsa_name(conf, section, resp_ctx))
 817         goto end;
 818
 819     /* Setting the ESS cert id chain flag if requested. */
 820     if (!TS_CONF_set_ess_cert_id_chain(conf, section, resp_ctx))
 821         goto end;
 822
 823     /* Creating the response. */
 824     if ((response = TS_RESP_create_response(resp_ctx, query_bio)) == NULL)
 825         goto end;
 826
 827     ret = 1;
 828  end:
 829     if (!ret) {
 830         TS_RESP_free(response);
 831         response = NULL;
 832     }
 833     TS_RESP_CTX_free(resp_ctx);
 834     BIO_free_all(query_bio);
 835
 836     return response;
 837 }
 838
 839 static ASN1_INTEGER *serial_cb(TS_RESP_CTX *ctx, void *data)
 840 {
 841     const char *serial_file = (const char *)data;
 842     ASN1_INTEGER *serial = next_serial(serial_file);
 843
 844     if (!serial) {
 845         TS_RESP_CTX_set_status_info(ctx, TS_STATUS_REJECTION,
 846                                     "Error during serial number "
 847                                     "generation.");
 848         TS_RESP_CTX_add_failure_info(ctx, TS_INFO_ADD_INFO_NOT_AVAILABLE);
 849     } else
 850         save_ts_serial(serial_file, serial);
 851
 852     return serial;
 853 }
 854
 855 static ASN1_INTEGER *next_serial(const char *serialfile)
 856 {
 857     int ret = 0;
 858     BIO *in = NULL;
 859     ASN1_INTEGER *serial = NULL;
 860     BIGNUM *bn = NULL;
 861
 862     if ((serial = ASN1_INTEGER_new()) == NULL)
 863         goto err;
 864
 865     if ((in = BIO_new_file(serialfile, "r")) == NULL) {
 866         ERR_clear_error();
 867         BIO_printf(bio_err, "Warning: could not open file %s for "
 868                    "reading, using serial number: 1\n", serialfile);
 869         if (!ASN1_INTEGER_set(serial, 1))
 870             goto err;
 871     } else {
 872         char buf[1024];
 873         if (!a2i_ASN1_INTEGER(in, serial, buf, sizeof(buf))) {
 874             BIO_printf(bio_err, "unable to load number from %s\n",
 875                        serialfile);
 876             goto err;
 877         }
 878         if ((bn = ASN1_INTEGER_to_BN(serial, NULL)) == NULL)
 879             goto err;
 880         ASN1_INTEGER_free(serial);
 881         serial = NULL;
 882         if (!BN_add_word(bn, 1))
 883             goto err;
 884         if ((serial = BN_to_ASN1_INTEGER(bn, NULL)) == NULL)
 885             goto err;
 886     }
 887     ret = 1;
 888  err:
 889     if (!ret) {
 890         ASN1_INTEGER_free(serial);
 891         serial = NULL;
 892     }
 893     BIO_free_all(in);
 894     BN_free(bn);
 895     return serial;
 896 }
 897
 898 static int save_ts_serial(const char *serialfile, ASN1_INTEGER *serial)
 899 {
 900     int ret = 0;
 901     BIO *out = NULL;
 902
 903     if ((out = BIO_new_file(serialfile, "w")) == NULL)
 904         goto err;
 905     if (i2a_ASN1_INTEGER(out, serial) <= 0)
 906         goto err;
 907     if (BIO_puts(out, "\n") <= 0)
 908         goto err;
 909     ret = 1;
 910  err:
 911     if (!ret)
 912         BIO_printf(bio_err, "could not save serial number to %s\n",
 913                    serialfile);
 914     BIO_free_all(out);
 915     return ret;
 916 }
 917
 918 /*
 919  * Verify-related method definitions.
 920  */
 921
 922 static int verify_command(char *data, char *digest, char *queryfile,
 923                           char *in, int token_in,
 924                           char *CApath, char *CAfile, char *untrusted)
 925 {
 926     BIO *in_bio = NULL;
 927     PKCS7 *token = NULL;
 928     TS_RESP *response = NULL;
 929     TS_VERIFY_CTX *verify_ctx = NULL;
 930     int ret = 0;
 931
 932     /* Decode the token (PKCS7) or response (TS_RESP) files. */
 933     if ((in_bio = BIO_new_file(in, "rb")) == NULL)
 934         goto end;
 935     if (token_in) {
 936         if ((token = d2i_PKCS7_bio(in_bio, NULL)) == NULL)
 937             goto end;
 938     } else {
 939         if ((response = d2i_TS_RESP_bio(in_bio, NULL)) == NULL)
 940             goto end;
 941     }
 942
 943     if ((verify_ctx = create_verify_ctx(data, digest, queryfile,
 944                                         CApath, CAfile, untrusted)) == NULL)
 945         goto end;
 946
 947     /* Checking the token or response against the request. */
 948     ret = token_in ?
 949         TS_RESP_verify_token(verify_ctx, token) :
 950         TS_RESP_verify_response(verify_ctx, response);
 951
 952  end:
 953     printf("Verification: ");
 954     if (ret)
 955         printf("OK\n");
 956     else {
 957         printf("FAILED\n");
 958         /* Print errors, if there are any. */
 959         ERR_print_errors(bio_err);
 960     }
 961
 962     /* Clean up. */
 963     BIO_free_all(in_bio);
 964     PKCS7_free(token);
 965     TS_RESP_free(response);
 966     TS_VERIFY_CTX_free(verify_ctx);
 967     return ret;
 968 }
 969
 970 static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest,
 971                                         char *queryfile,
 972                                         char *CApath, char *CAfile,
 973                                         char *untrusted)
 974 {
 975     TS_VERIFY_CTX *ctx = NULL;
 976     BIO *input = NULL;
 977     TS_REQ *request = NULL;
 978     int ret = 0;
 979
 980     if (data != NULL || digest != NULL) {
 981         if ((ctx = TS_VERIFY_CTX_new()) == NULL)
 982             goto err;
 983         ctx->flags = TS_VFY_VERSION | TS_VFY_SIGNER;
 984         if (data != NULL) {
 985             ctx->flags |= TS_VFY_DATA;
 986             if ((ctx->data = BIO_new_file(data, "rb")) == NULL)
 987                 goto err;
 988         } else if (digest != NULL) {
 989             long imprint_len;
 990             ctx->flags |= TS_VFY_IMPRINT;
 991             if ((ctx->imprint = string_to_hex(digest, &imprint_len)) == NULL) {
 992                 BIO_printf(bio_err, "invalid digest string\n");
 993                 goto err;
 994             }
 995             ctx->imprint_len = imprint_len;
 996         }
 997
 998     } else if (queryfile != NULL) {
 999         /*
1000          * The request has just to be read, decoded and converted to a verify
1001          * context object.
1002          */
1003         if ((input = BIO_new_file(queryfile, "rb")) == NULL)
1004             goto err;
1005         if ((request = d2i_TS_REQ_bio(input, NULL)) == NULL)
1006             goto err;
1007         if ((ctx = TS_REQ_to_TS_VERIFY_CTX(request, NULL)) == NULL)
1008             goto err;
1009     } else
1010         return NULL;
1011
1012     /* Add the signature verification flag and arguments. */
1013     ctx->flags |= TS_VFY_SIGNATURE;
1014
1015     /* Initialising the X509_STORE object. */
1016     if ((ctx->store = create_cert_store(CApath, CAfile)) == NULL)
1017         goto err;
1018
1019     /* Loading untrusted certificates. */
1020     if (untrusted && (ctx->certs = TS_CONF_load_certs(untrusted)) == NULL)
1021         goto err;
1022
1023     ret = 1;
1024  err:
1025     if (!ret) {
1026         TS_VERIFY_CTX_free(ctx);
1027         ctx = NULL;
1028     }
1029     BIO_free_all(input);
1030     TS_REQ_free(request);
1031     return ctx;
1032 }
1033
1034 static X509_STORE *create_cert_store(char *CApath, char *CAfile)
1035 {
1036     X509_STORE *cert_ctx = NULL;
1037     X509_LOOKUP *lookup = NULL;
1038     int i;
1039
1040     /* Creating the X509_STORE object. */
1041     cert_ctx = X509_STORE_new();
1042
1043     /* Setting the callback for certificate chain verification. */
1044     X509_STORE_set_verify_cb(cert_ctx, verify_cb);
1045
1046     /* Adding a trusted certificate directory source. */
1047     if (CApath) {
1048         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
1049         if (lookup == NULL) {
1050             BIO_printf(bio_err, "memory allocation failure\n");
1051             goto err;
1052         }
1053         i = X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM);
1054         if (!i) {
1055             BIO_printf(bio_err, "Error loading directory %s\n", CApath);
1056             goto err;
1057         }
1058     }
1059
1060     /* Adding a trusted certificate file source. */
1061     if (CAfile) {
1062         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
1063         if (lookup == NULL) {
1064             BIO_printf(bio_err, "memory allocation failure\n");
1065             goto err;
1066         }
1067         i = X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM);
1068         if (!i) {
1069             BIO_printf(bio_err, "Error loading file %s\n", CAfile);
1070             goto err;
1071         }
1072     }
1073
1074     return cert_ctx;
1075  err:
1076     X509_STORE_free(cert_ctx);
1077     return NULL;
1078 }
1079
1080 static int verify_cb(int ok, X509_STORE_CTX *ctx)
1081 {
1082     return ok;
1083 }