OpenSSL  1.0.1c
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
ts.h
Go to the documentation of this file.
1 /* crypto/ts/ts.h */
2 /* Written by Zoltan Glozik ([email protected]) for the OpenSSL
3  * project 2002, 2003, 2004.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 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
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  * ([email protected]). This product includes software written by Tim
55  * Hudson ([email protected]).
56  *
57  */
58 
59 #ifndef HEADER_TS_H
60 #define HEADER_TS_H
61 
62 #include <openssl/opensslconf.h>
63 #include <openssl/symhacks.h>
64 #ifndef OPENSSL_NO_BUFFER
65 #include <openssl/buffer.h>
66 #endif
67 #ifndef OPENSSL_NO_EVP
68 #include <openssl/evp.h>
69 #endif
70 #ifndef OPENSSL_NO_BIO
71 #include <openssl/bio.h>
72 #endif
73 #include <openssl/stack.h>
74 #include <openssl/asn1.h>
75 #include <openssl/safestack.h>
76 
77 #ifndef OPENSSL_NO_RSA
78 #include <openssl/rsa.h>
79 #endif
80 
81 #ifndef OPENSSL_NO_DSA
82 #include <openssl/dsa.h>
83 #endif
84 
85 #ifndef OPENSSL_NO_DH
86 #include <openssl/dh.h>
87 #endif
88 
89 #ifdef __cplusplus
90 extern "C" {
91 #endif
92 
93 #ifdef WIN32
94 /* Under Win32 this is defined in wincrypt.h */
95 #undef X509_NAME
96 #endif
97 
98 #include <openssl/x509.h>
99 #include <openssl/x509v3.h>
100 
101 /*
102 MessageImprint ::= SEQUENCE {
103  hashAlgorithm AlgorithmIdentifier,
104  hashedMessage OCTET STRING }
105 */
106 
107 typedef struct TS_msg_imprint_st
108  {
111  } TS_MSG_IMPRINT;
112 
113 /*
114 TimeStampReq ::= SEQUENCE {
115  version INTEGER { v1(1) },
116  messageImprint MessageImprint,
117  --a hash algorithm OID and the hash value of the data to be
118  --time-stamped
119  reqPolicy TSAPolicyId OPTIONAL,
120  nonce INTEGER OPTIONAL,
121  certReq BOOLEAN DEFAULT FALSE,
122  extensions [0] IMPLICIT Extensions OPTIONAL }
123 */
124 
125 typedef struct TS_req_st
126  {
129  ASN1_OBJECT *policy_id; /* OPTIONAL */
130  ASN1_INTEGER *nonce; /* OPTIONAL */
131  ASN1_BOOLEAN cert_req; /* DEFAULT FALSE */
132  STACK_OF(X509_EXTENSION) *extensions; /* [0] OPTIONAL */
133  } TS_REQ;
134 
135 /*
136 Accuracy ::= SEQUENCE {
137  seconds INTEGER OPTIONAL,
138  millis [0] INTEGER (1..999) OPTIONAL,
139  micros [1] INTEGER (1..999) OPTIONAL }
140 */
141 
142 typedef struct TS_accuracy_st
143  {
147  } TS_ACCURACY;
148 
149 /*
150 TSTInfo ::= SEQUENCE {
151  version INTEGER { v1(1) },
152  policy TSAPolicyId,
153  messageImprint MessageImprint,
154  -- MUST have the same value as the similar field in
155  -- TimeStampReq
156  serialNumber INTEGER,
157  -- Time-Stamping users MUST be ready to accommodate integers
158  -- up to 160 bits.
159  genTime GeneralizedTime,
160  accuracy Accuracy OPTIONAL,
161  ordering BOOLEAN DEFAULT FALSE,
162  nonce INTEGER OPTIONAL,
163  -- MUST be present if the similar field was present
164  -- in TimeStampReq. In that case it MUST have the same value.
165  tsa [0] GeneralName OPTIONAL,
166  extensions [1] IMPLICIT Extensions OPTIONAL }
167 */
168 
169 typedef struct TS_tst_info_st
170  {
179  GENERAL_NAME *tsa;
180  STACK_OF(X509_EXTENSION) *extensions;
181  } TS_TST_INFO;
182 
183 /*
184 PKIStatusInfo ::= SEQUENCE {
185  status PKIStatus,
186  statusString PKIFreeText OPTIONAL,
187  failInfo PKIFailureInfo OPTIONAL }
188 
189 From RFC 1510 - section 3.1.1:
190 PKIFreeText ::= SEQUENCE SIZE (1..MAX) OF UTF8String
191  -- text encoded as UTF-8 String (note: each UTF8String SHOULD
192  -- include an RFC 1766 language tag to indicate the language
193  -- of the contained text)
194 */
195 
196 /* Possible values for status. See ts_resp_print.c && ts_resp_verify.c. */
197 
198 #define TS_STATUS_GRANTED 0
199 #define TS_STATUS_GRANTED_WITH_MODS 1
200 #define TS_STATUS_REJECTION 2
201 #define TS_STATUS_WAITING 3
202 #define TS_STATUS_REVOCATION_WARNING 4
203 #define TS_STATUS_REVOCATION_NOTIFICATION 5
204 
205 /* Possible values for failure_info. See ts_resp_print.c && ts_resp_verify.c */
206 
207 #define TS_INFO_BAD_ALG 0
208 #define TS_INFO_BAD_REQUEST 2
209 #define TS_INFO_BAD_DATA_FORMAT 5
210 #define TS_INFO_TIME_NOT_AVAILABLE 14
211 #define TS_INFO_UNACCEPTED_POLICY 15
212 #define TS_INFO_UNACCEPTED_EXTENSION 16
213 #define TS_INFO_ADD_INFO_NOT_AVAILABLE 17
214 #define TS_INFO_SYSTEM_FAILURE 25
215 
216 typedef struct TS_status_info_st
217  {
221  } TS_STATUS_INFO;
222 
225 
226 /*
227 TimeStampResp ::= SEQUENCE {
228  status PKIStatusInfo,
229  timeStampToken TimeStampToken OPTIONAL }
230 */
231 
232 typedef struct TS_resp_st
233  {
234  TS_STATUS_INFO *status_info;
235  PKCS7 *token;
236  TS_TST_INFO *tst_info;
237  } TS_RESP;
238 
239 /* The structure below would belong to the ESS component. */
240 
241 /*
242 IssuerSerial ::= SEQUENCE {
243  issuer GeneralNames,
244  serialNumber CertificateSerialNumber
245  }
246 */
247 
248 typedef struct ESS_issuer_serial
249  {
250  STACK_OF(GENERAL_NAME) *issuer;
253 
254 /*
255 ESSCertID ::= SEQUENCE {
256  certHash Hash,
257  issuerSerial IssuerSerial OPTIONAL
258 }
259 */
260 
261 typedef struct ESS_cert_id
262  {
263  ASN1_OCTET_STRING *hash; /* Always SHA-1 digest. */
265  } ESS_CERT_ID;
266 
269 
270 /*
271 SigningCertificate ::= SEQUENCE {
272  certs SEQUENCE OF ESSCertID,
273  policies SEQUENCE OF PolicyInformation OPTIONAL
274 }
275 */
276 
277 typedef struct ESS_signing_cert
278  {
279  STACK_OF(ESS_CERT_ID) *cert_ids;
280  STACK_OF(POLICYINFO) *policy_info;
282 
283 
284 TS_REQ *TS_REQ_new(void);
285 void TS_REQ_free(TS_REQ *a);
286 int i2d_TS_REQ(const TS_REQ *a, unsigned char **pp);
287 TS_REQ *d2i_TS_REQ(TS_REQ **a, const unsigned char **pp, long length);
288 
290 
291 TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a);
292 int i2d_TS_REQ_fp(FILE *fp, TS_REQ *a);
294 int i2d_TS_REQ_bio(BIO *fp, TS_REQ *a);
295 
298 int i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **pp);
300  const unsigned char **pp, long length);
301 
303 
308 
309 TS_RESP *TS_RESP_new(void);
310 void TS_RESP_free(TS_RESP *a);
311 int i2d_TS_RESP(const TS_RESP *a, unsigned char **pp);
312 TS_RESP *d2i_TS_RESP(TS_RESP **a, const unsigned char **pp, long length);
315 
316 TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a);
317 int i2d_TS_RESP_fp(FILE *fp, TS_RESP *a);
319 int i2d_TS_RESP_bio(BIO *fp, TS_RESP *a);
320 
323 int i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **pp);
325  const unsigned char **pp, long length);
327 
330 int i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **pp);
331 TS_TST_INFO *d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **pp,
332  long length);
334 
336 int i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a);
339 
342 int i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **pp);
343 TS_ACCURACY *d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **pp,
344  long length);
346 
350  unsigned char **pp);
352  const unsigned char **pp, long length);
354 
357 int i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **pp);
358 ESS_CERT_ID *d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **pp,
359  long length);
361 
365  unsigned char **pp);
367  const unsigned char **pp, long length);
369 
370 void ERR_load_TS_strings(void);
371 
372 int TS_REQ_set_version(TS_REQ *a, long version);
373 long TS_REQ_get_version(const TS_REQ *a);
374 
375 int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint);
377 
380 
381 int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len);
383 
386 
387 int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce);
388 const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a);
389 
390 int TS_REQ_set_cert_req(TS_REQ *a, int cert_req);
391 int TS_REQ_get_cert_req(const TS_REQ *a);
392 
393 STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a);
394 void TS_REQ_ext_free(TS_REQ *a);
396 int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos);
397 int TS_REQ_get_ext_by_OBJ(TS_REQ *a, ASN1_OBJECT *obj, int lastpos);
398 int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos);
402 void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx);
403 
404 /* Function declarations for TS_REQ defined in ts/ts_req_print.c */
405 
406 int TS_REQ_print_bio(BIO *bio, TS_REQ *a);
407 
408 /* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */
409 
412 
413 /* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
414 void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info);
417 
418 int TS_TST_INFO_set_version(TS_TST_INFO *a, long version);
420 
423 
426 
427 int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial);
429 
432 
435 
436 int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds);
438 
439 int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis);
441 
442 int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros);
444 
445 int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering);
447 
448 int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce);
450 
453 
454 STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a);
457 int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos);
459 int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos);
463 void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);
464 
465 /* Declarations related to response generation, defined in ts/ts_resp_sign.c. */
466 
467 /* Optional flags for response generation. */
468 
469 /* Don't include the TSA name in response. */
470 #define TS_TSA_NAME 0x01
471 
472 /* Set ordering to true in response. */
473 #define TS_ORDERING 0x02
474 
475 /*
476  * Include the signer certificate and the other specified certificates in
477  * the ESS signing certificate attribute beside the PKCS7 signed data.
478  * Only the signer certificates is included by default.
479  */
480 #define TS_ESS_CERT_ID_CHAIN 0x04
481 
482 /* Forward declaration. */
483 struct TS_resp_ctx;
484 
485 /* This must return a unique number less than 160 bits long. */
486 typedef ASN1_INTEGER *(*TS_serial_cb)(struct TS_resp_ctx *, void *);
487 
488 /* This must return the seconds and microseconds since Jan 1, 1970 in
489  the sec and usec variables allocated by the caller.
490  Return non-zero for success and zero for failure. */
491 typedef int (*TS_time_cb)(struct TS_resp_ctx *, void *, long *sec, long *usec);
492 
493 /* This must process the given extension.
494  * It can modify the TS_TST_INFO object of the context.
495  * Return values: !0 (processed), 0 (error, it must set the
496  * status info/failure info of the response).
497  */
498 typedef int (*TS_extension_cb)(struct TS_resp_ctx *, X509_EXTENSION *, void *);
499 
500 typedef struct TS_resp_ctx
501  {
502  X509 *signer_cert;
504  STACK_OF(X509) *certs; /* Certs to include in signed data. */
505  STACK_OF(ASN1_OBJECT) *policies; /* Acceptable policies. */
506  ASN1_OBJECT *default_policy; /* It may appear in policies, too. */
507  STACK_OF(EVP_MD) *mds; /* Acceptable message digests. */
508  ASN1_INTEGER *seconds; /* accuracy, 0 means not specified. */
509  ASN1_INTEGER *millis; /* accuracy, 0 means not specified. */
510  ASN1_INTEGER *micros; /* accuracy, 0 means not specified. */
511  unsigned clock_precision_digits; /* fraction of seconds in
512  time stamp token. */
513  unsigned flags; /* Optional info, see values above. */
514 
515  /* Callback functions. */
517  void *serial_cb_data; /* User data for serial_cb. */
518 
520  void *time_cb_data; /* User data for time_cb. */
521 
523  void *extension_cb_data; /* User data for extension_cb. */
524 
525  /* These members are used only while creating the response. */
526  TS_REQ *request;
527  TS_RESP *response;
529  } TS_RESP_CTX;
530 
533 
534 /* Creates a response context that can be used for generating responses. */
536 void TS_RESP_CTX_free(TS_RESP_CTX *ctx);
537 
538 /* This parameter must be set. */
539 int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer);
540 
541 /* This parameter must be set. */
543 
544 /* This parameter must be set. */
545 int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *def_policy);
546 
547 /* No additional certs are included in the response by default. */
549 
550 /* Adds a new acceptable policy, only the default policy
551  is accepted by default. */
553 
554 /* Adds a new acceptable message digest. Note that no message digests
555  are accepted by default. The md argument is shared with the caller. */
556 int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);
557 
558 /* Accuracy is not included by default. */
560  int secs, int millis, int micros);
561 
562 /* Clock precision digits, i.e. the number of decimal digits:
563  '0' means sec, '3' msec, '6' usec, and so on. Default is 0. */
565  unsigned clock_precision_digits);
566 /* At most we accept usec precision. */
567 #define TS_MAX_CLOCK_PRECISION_DIGITS 6
568 
569 /* No flags are set by default. */
570 void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags);
571 
572 /* Default callback always returns a constant. */
574 
575 /* Default callback uses the gettimeofday() and gmtime() system calls. */
577 
578 /* Default callback rejects all extensions. The extension callback is called
579  * when the TS_TST_INFO object is already set up and not signed yet. */
580 /* FIXME: extension handling is not tested yet. */
582  TS_extension_cb cb, void *data);
583 
584 /* The following methods can be used in the callbacks. */
586  int status, const char *text);
587 
588 /* Sets the status info only if it is still TS_STATUS_GRANTED. */
590  int status, const char *text);
591 
592 int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);
593 
594 /* The get methods below can be used in the extension callback. */
596 
598 
599 /*
600  * Creates the signed TS_TST_INFO and puts it in TS_RESP.
601  * In case of errors it sets the status info properly.
602  * Returns NULL only in case of memory allocation/fatal error.
603  */
605 
606 /*
607  * Declarations related to response verification,
608  * they are defined in ts/ts_resp_verify.c.
609  */
610 
611 int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
612  X509_STORE *store, X509 **signer_out);
613 
614 /* Context structure for the generic verify method. */
615 
616 /* Verify the signer's certificate and the signature of the response. */
617 #define TS_VFY_SIGNATURE (1u << 0)
618 /* Verify the version number of the response. */
619 #define TS_VFY_VERSION (1u << 1)
620 /* Verify if the policy supplied by the user matches the policy of the TSA. */
621 #define TS_VFY_POLICY (1u << 2)
622 /* Verify the message imprint provided by the user. This flag should not be
623  specified with TS_VFY_DATA. */
624 #define TS_VFY_IMPRINT (1u << 3)
625 /* Verify the message imprint computed by the verify method from the user
626  provided data and the MD algorithm of the response. This flag should not be
627  specified with TS_VFY_IMPRINT. */
628 #define TS_VFY_DATA (1u << 4)
629 /* Verify the nonce value. */
630 #define TS_VFY_NONCE (1u << 5)
631 /* Verify if the TSA name field matches the signer certificate. */
632 #define TS_VFY_SIGNER (1u << 6)
633 /* Verify if the TSA name field equals to the user provided name. */
634 #define TS_VFY_TSA_NAME (1u << 7)
635 
636 /* You can use the following convenience constants. */
637 #define TS_VFY_ALL_IMPRINT (TS_VFY_SIGNATURE \
638  | TS_VFY_VERSION \
639  | TS_VFY_POLICY \
640  | TS_VFY_IMPRINT \
641  | TS_VFY_NONCE \
642  | TS_VFY_SIGNER \
643  | TS_VFY_TSA_NAME)
644 #define TS_VFY_ALL_DATA (TS_VFY_SIGNATURE \
645  | TS_VFY_VERSION \
646  | TS_VFY_POLICY \
647  | TS_VFY_DATA \
648  | TS_VFY_NONCE \
649  | TS_VFY_SIGNER \
650  | TS_VFY_TSA_NAME)
651 
652 typedef struct TS_verify_ctx
653  {
654  /* Set this to the union of TS_VFY_... flags you want to carry out. */
655  unsigned flags;
656 
657  /* Must be set only with TS_VFY_SIGNATURE. certs is optional. */
658  X509_STORE *store;
659  STACK_OF(X509) *certs;
660 
661  /* Must be set only with TS_VFY_POLICY. */
663 
664  /* Must be set only with TS_VFY_IMPRINT. If md_alg is NULL,
665  the algorithm from the response is used. */
667  unsigned char *imprint;
668  unsigned imprint_len;
669 
670  /* Must be set only with TS_VFY_DATA. */
671  BIO *data;
672 
673  /* Must be set only with TS_VFY_TSA_NAME. */
675 
676  /* Must be set only with TS_VFY_TSA_NAME. */
678  } TS_VERIFY_CTX;
679 
680 int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);
681 int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);
682 
683 /*
684  * Declarations related to response verification context,
685  * they are defined in ts/ts_verify_ctx.c.
686  */
687 
688 /* Set all fields to zero. */
693 
694 /*
695  * If ctx is NULL, it allocates and returns a new object, otherwise
696  * it returns ctx. It initialises all the members as follows:
697  * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
698  * certs = NULL
699  * store = NULL
700  * policy = policy from the request or NULL if absent (in this case
701  * TS_VFY_POLICY is cleared from flags as well)
702  * md_alg = MD algorithm from request
703  * imprint, imprint_len = imprint from request
704  * data = NULL
705  * nonce, nonce_len = nonce from the request or NULL if absent (in this case
706  * TS_VFY_NONCE is cleared from flags as well)
707  * tsa_name = NULL
708  * Important: after calling this method TS_VFY_SIGNATURE should be added!
709  */
711 
712 /* Function declarations for TS_RESP defined in ts/ts_resp_print.c */
713 
714 int TS_RESP_print_bio(BIO *bio, TS_RESP *a);
717 
718 /* Common utility functions defined in ts/ts_lib.c */
719 
721 int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj);
722 int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions);
723 int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg);
725 
726 /* Function declarations for handling configuration options,
727  defined in ts/ts_conf.c */
728 
729 X509 *TS_CONF_load_cert(const char *file);
730 STACK_OF(X509) *TS_CONF_load_certs(const char *file);
731 EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);
732 const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);
733 int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
734  TS_RESP_CTX *ctx);
735 int TS_CONF_set_crypto_device(CONF *conf, const char *section,
736  const char *device);
737 int TS_CONF_set_default_engine(const char *name);
738 int TS_CONF_set_signer_cert(CONF *conf, const char *section,
739  const char *cert, TS_RESP_CTX *ctx);
740 int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
741  TS_RESP_CTX *ctx);
742 int TS_CONF_set_signer_key(CONF *conf, const char *section,
743  const char *key, const char *pass, TS_RESP_CTX *ctx);
744 int TS_CONF_set_def_policy(CONF *conf, const char *section,
745  const char *policy, TS_RESP_CTX *ctx);
746 int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);
747 int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);
748 int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);
749 int TS_CONF_set_clock_precision_digits(CONF *conf, const char *section,
750  TS_RESP_CTX *ctx);
751 int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);
752 int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);
753 int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,
754  TS_RESP_CTX *ctx);
755 
756 /* -------------------------------------------------- */
757 /* BEGIN ERROR CODES */
758 /* The following lines are auto generated by the script mkerr.pl. Any changes
759  * made after this point may be overwritten when the script is next run.
760  */
761 void ERR_load_TS_strings(void);
762 
763 /* Error codes for the TS functions. */
764 
765 /* Function codes. */
766 #define TS_F_D2I_TS_RESP 147
767 #define TS_F_DEF_SERIAL_CB 110
768 #define TS_F_DEF_TIME_CB 111
769 #define TS_F_ESS_ADD_SIGNING_CERT 112
770 #define TS_F_ESS_CERT_ID_NEW_INIT 113
771 #define TS_F_ESS_SIGNING_CERT_NEW_INIT 114
772 #define TS_F_INT_TS_RESP_VERIFY_TOKEN 149
773 #define TS_F_PKCS7_TO_TS_TST_INFO 148
774 #define TS_F_TS_ACCURACY_SET_MICROS 115
775 #define TS_F_TS_ACCURACY_SET_MILLIS 116
776 #define TS_F_TS_ACCURACY_SET_SECONDS 117
777 #define TS_F_TS_CHECK_IMPRINTS 100
778 #define TS_F_TS_CHECK_NONCES 101
779 #define TS_F_TS_CHECK_POLICY 102
780 #define TS_F_TS_CHECK_SIGNING_CERTS 103
781 #define TS_F_TS_CHECK_STATUS_INFO 104
782 #define TS_F_TS_COMPUTE_IMPRINT 145
783 #define TS_F_TS_CONF_SET_DEFAULT_ENGINE 146
784 #define TS_F_TS_GET_STATUS_TEXT 105
785 #define TS_F_TS_MSG_IMPRINT_SET_ALGO 118
786 #define TS_F_TS_REQ_SET_MSG_IMPRINT 119
787 #define TS_F_TS_REQ_SET_NONCE 120
788 #define TS_F_TS_REQ_SET_POLICY_ID 121
789 #define TS_F_TS_RESP_CREATE_RESPONSE 122
790 #define TS_F_TS_RESP_CREATE_TST_INFO 123
791 #define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO 124
792 #define TS_F_TS_RESP_CTX_ADD_MD 125
793 #define TS_F_TS_RESP_CTX_ADD_POLICY 126
794 #define TS_F_TS_RESP_CTX_NEW 127
795 #define TS_F_TS_RESP_CTX_SET_ACCURACY 128
796 #define TS_F_TS_RESP_CTX_SET_CERTS 129
797 #define TS_F_TS_RESP_CTX_SET_DEF_POLICY 130
798 #define TS_F_TS_RESP_CTX_SET_SIGNER_CERT 131
799 #define TS_F_TS_RESP_CTX_SET_STATUS_INFO 132
800 #define TS_F_TS_RESP_GET_POLICY 133
801 #define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION 134
802 #define TS_F_TS_RESP_SET_STATUS_INFO 135
803 #define TS_F_TS_RESP_SET_TST_INFO 150
804 #define TS_F_TS_RESP_SIGN 136
805 #define TS_F_TS_RESP_VERIFY_SIGNATURE 106
806 #define TS_F_TS_RESP_VERIFY_TOKEN 107
807 #define TS_F_TS_TST_INFO_SET_ACCURACY 137
808 #define TS_F_TS_TST_INFO_SET_MSG_IMPRINT 138
809 #define TS_F_TS_TST_INFO_SET_NONCE 139
810 #define TS_F_TS_TST_INFO_SET_POLICY_ID 140
811 #define TS_F_TS_TST_INFO_SET_SERIAL 141
812 #define TS_F_TS_TST_INFO_SET_TIME 142
813 #define TS_F_TS_TST_INFO_SET_TSA 143
814 #define TS_F_TS_VERIFY 108
815 #define TS_F_TS_VERIFY_CERT 109
816 #define TS_F_TS_VERIFY_CTX_NEW 144
817 
818 /* Reason codes. */
819 #define TS_R_BAD_PKCS7_TYPE 132
820 #define TS_R_BAD_TYPE 133
821 #define TS_R_CERTIFICATE_VERIFY_ERROR 100
822 #define TS_R_COULD_NOT_SET_ENGINE 127
823 #define TS_R_COULD_NOT_SET_TIME 115
824 #define TS_R_D2I_TS_RESP_INT_FAILED 128
825 #define TS_R_DETACHED_CONTENT 134
826 #define TS_R_ESS_ADD_SIGNING_CERT_ERROR 116
827 #define TS_R_ESS_SIGNING_CERTIFICATE_ERROR 101
828 #define TS_R_INVALID_NULL_POINTER 102
829 #define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE 117
830 #define TS_R_MESSAGE_IMPRINT_MISMATCH 103
831 #define TS_R_NONCE_MISMATCH 104
832 #define TS_R_NONCE_NOT_RETURNED 105
833 #define TS_R_NO_CONTENT 106
834 #define TS_R_NO_TIME_STAMP_TOKEN 107
835 #define TS_R_PKCS7_ADD_SIGNATURE_ERROR 118
836 #define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR 119
837 #define TS_R_PKCS7_TO_TS_TST_INFO_FAILED 129
838 #define TS_R_POLICY_MISMATCH 108
839 #define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 120
840 #define TS_R_RESPONSE_SETUP_ERROR 121
841 #define TS_R_SIGNATURE_FAILURE 109
842 #define TS_R_THERE_MUST_BE_ONE_SIGNER 110
843 #define TS_R_TIME_SYSCALL_ERROR 122
844 #define TS_R_TOKEN_NOT_PRESENT 130
845 #define TS_R_TOKEN_PRESENT 131
846 #define TS_R_TSA_NAME_MISMATCH 111
847 #define TS_R_TSA_UNTRUSTED 112
848 #define TS_R_TST_INFO_SETUP_ERROR 123
849 #define TS_R_TS_DATASIGN 124
850 #define TS_R_UNACCEPTABLE_POLICY 125
851 #define TS_R_UNSUPPORTED_MD_ALGORITHM 126
852 #define TS_R_UNSUPPORTED_VERSION 113
853 #define TS_R_WRONG_CONTENT_TYPE 114
854 
855 #ifdef __cplusplus
856 }
857 #endif
858 #endif