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