contrib/openssl/include/openssl/ts.h

   1 /* crypto/ts/ts.h */\r
   2 /* Written by Zoltan Glozik (zglozik@opentsa.org) for the OpenSSL\r
   3  * project 2002, 2003, 2004.\r
   4  */\r
   5 /* ====================================================================\r
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.\r
   7  *\r
   8  * Redistribution and use in source and binary forms, with or without\r
   9  * modification, are permitted provided that the following conditions\r
  10  * are met:\r
  11  *\r
  12  * 1. Redistributions of source code must retain the above copyright\r
  13  *    notice, this list of conditions and the following disclaimer.\r
  14  *\r
  15  * 2. Redistributions in binary form must reproduce the above copyright\r
  16  *    notice, this list of conditions and the following disclaimer in\r
  17  *    the documentation and/or other materials provided with the\r
  18  *    distribution.\r
  19  *\r
  20  * 3. All advertising materials mentioning features or use of this\r
  21  *    software must display the following acknowledgment:\r
  22  *    "This product includes software developed by the OpenSSL Project\r
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"\r
  24  *\r
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to\r
  26  *    endorse or promote products derived from this software without\r
  27  *    prior written permission. For written permission, please contact\r
  28  *    licensing@OpenSSL.org.\r
  29  *\r
  30  * 5. Products derived from this software may not be called "OpenSSL"\r
  31  *    nor may "OpenSSL" appear in their names without prior written\r
  32  *    permission of the OpenSSL Project.\r
  33  *\r
  34  * 6. Redistributions of any form whatsoever must retain the following\r
  35  *    acknowledgment:\r
  36  *    "This product includes software developed by the OpenSSL Project\r
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"\r
  38  *\r
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\r
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR\r
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\r
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\r
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.\r
  51  * ====================================================================\r
  52  *\r
  53  * This product includes cryptographic software written by Eric Young\r
  54  * (eay@cryptsoft.com).  This product includes software written by Tim\r
  55  * Hudson (tjh@cryptsoft.com).\r
  56  *\r
  57  */\r
  58 \r
  59 #ifndef HEADER_TS_H\r
  60 #define HEADER_TS_H\r
  61 \r
  62 #include <openssl/opensslconf.h>\r
  63 #include <openssl/symhacks.h>\r
  64 #ifndef OPENSSL_NO_BUFFER\r
  65 #include <openssl/buffer.h>\r
  66 #endif\r
  67 #ifndef OPENSSL_NO_EVP\r
  68 #include <openssl/evp.h>\r
  69 #endif\r
  70 #ifndef OPENSSL_NO_BIO\r
  71 #include <openssl/bio.h>\r
  72 #endif\r
  73 #include <openssl/stack.h>\r
  74 #include <openssl/asn1.h>\r
  75 #include <openssl/safestack.h>\r
  76 \r
  77 #ifndef OPENSSL_NO_RSA\r
  78 #include <openssl/rsa.h>\r
  79 #endif\r
  80 \r
  81 #ifndef OPENSSL_NO_DSA\r
  82 #include <openssl/dsa.h>\r
  83 #endif\r
  84 \r
  85 #ifndef OPENSSL_NO_DH\r
  86 #include <openssl/dh.h>\r
  87 #endif\r
  88 \r
  89 #ifdef  __cplusplus\r
  90 extern "C" {\r
  91 #endif\r
  92 \r
  93 #ifdef WIN32\r
  94 /* Under Win32 this is defined in wincrypt.h */\r
  95 #undef X509_NAME\r
  96 #endif\r
  97 \r
  98 #include <openssl/x509.h>\r
  99 #include <openssl/x509v3.h>\r
 100 \r
 101 /*\r
 102 MessageImprint ::= SEQUENCE  {\r
 103      hashAlgorithm                AlgorithmIdentifier,\r
 104      hashedMessage                OCTET STRING  }\r
 105 */\r
 106 \r
 107 typedef struct TS_msg_imprint_st\r
 108         {\r
 109         X509_ALGOR *hash_algo;\r
 110         ASN1_OCTET_STRING *hashed_msg;\r
 111         } TS_MSG_IMPRINT;\r
 112 \r
 113 /*\r
 114 TimeStampReq ::= SEQUENCE  {\r
 115    version                  INTEGER  { v1(1) },\r
 116    messageImprint           MessageImprint,\r
 117      --a hash algorithm OID and the hash value of the data to be\r
 118      --time-stamped\r
 119    reqPolicy                TSAPolicyId                OPTIONAL,\r
 120    nonce                    INTEGER                    OPTIONAL,\r
 121    certReq                  BOOLEAN                    DEFAULT FALSE,\r
 122    extensions               [0] IMPLICIT Extensions    OPTIONAL  }\r
 123 */\r
 124 \r
 125 typedef struct TS_req_st\r
 126         {\r
 127         ASN1_INTEGER *version;\r
 128         TS_MSG_IMPRINT *msg_imprint;\r
 129         ASN1_OBJECT *policy_id;         /* OPTIONAL */\r
 130         ASN1_INTEGER *nonce;            /* OPTIONAL */\r
 131         ASN1_BOOLEAN cert_req;          /* DEFAULT FALSE */\r
 132         STACK_OF(X509_EXTENSION) *extensions;   /* [0] OPTIONAL */\r
 133         } TS_REQ;\r
 134 \r
 135 /*\r
 136 Accuracy ::= SEQUENCE {\r
 137                 seconds        INTEGER           OPTIONAL,\r
 138                 millis     [0] INTEGER  (1..999) OPTIONAL,\r
 139                 micros     [1] INTEGER  (1..999) OPTIONAL  }\r
 140 */\r
 141 \r
 142 typedef struct TS_accuracy_st\r
 143         {\r
 144         ASN1_INTEGER *seconds;\r
 145         ASN1_INTEGER *millis;\r
 146         ASN1_INTEGER *micros;\r
 147         } TS_ACCURACY;\r
 148 \r
 149 /*\r
 150 TSTInfo ::= SEQUENCE  {\r
 151     version                      INTEGER  { v1(1) },\r
 152     policy                       TSAPolicyId,\r
 153     messageImprint               MessageImprint,\r
 154       -- MUST have the same value as the similar field in\r
 155       -- TimeStampReq\r
 156     serialNumber                 INTEGER,\r
 157      -- Time-Stamping users MUST be ready to accommodate integers\r
 158      -- up to 160 bits.\r
 159     genTime                      GeneralizedTime,\r
 160     accuracy                     Accuracy                 OPTIONAL,\r
 161     ordering                     BOOLEAN             DEFAULT FALSE,\r
 162     nonce                        INTEGER                  OPTIONAL,\r
 163       -- MUST be present if the similar field was present\r
 164       -- in TimeStampReq.  In that case it MUST have the same value.\r
 165     tsa                          [0] GeneralName          OPTIONAL,\r
 166     extensions                   [1] IMPLICIT Extensions  OPTIONAL   }\r
 167 */\r
 168 \r
 169 typedef struct TS_tst_info_st\r
 170         {\r
 171         ASN1_INTEGER *version;\r
 172         ASN1_OBJECT *policy_id;\r
 173         TS_MSG_IMPRINT *msg_imprint;\r
 174         ASN1_INTEGER *serial;\r
 175         ASN1_GENERALIZEDTIME *time;\r
 176         TS_ACCURACY *accuracy;\r
 177         ASN1_BOOLEAN ordering;\r
 178         ASN1_INTEGER *nonce;\r
 179         GENERAL_NAME *tsa;\r
 180         STACK_OF(X509_EXTENSION) *extensions;\r
 181         } TS_TST_INFO;\r
 182 \r
 183 /*\r
 184 PKIStatusInfo ::= SEQUENCE {\r
 185     status        PKIStatus,\r
 186     statusString  PKIFreeText     OPTIONAL,\r
 187     failInfo      PKIFailureInfo  OPTIONAL  }\r
 188 \r
 189 From RFC 1510 - section 3.1.1:\r
 190 PKIFreeText ::= SEQUENCE SIZE (1..MAX) OF UTF8String\r
 191         -- text encoded as UTF-8 String (note:  each UTF8String SHOULD\r
 192         -- include an RFC 1766 language tag to indicate the language\r
 193         -- of the contained text)\r
 194 */\r
 195 \r
 196 /* Possible values for status. See ts_resp_print.c && ts_resp_verify.c. */\r
 197 \r
 198 #define TS_STATUS_GRANTED                       0\r
 199 #define TS_STATUS_GRANTED_WITH_MODS             1\r
 200 #define TS_STATUS_REJECTION                     2\r
 201 #define TS_STATUS_WAITING                       3\r
 202 #define TS_STATUS_REVOCATION_WARNING            4\r
 203 #define TS_STATUS_REVOCATION_NOTIFICATION       5\r
 204 \r
 205 /* Possible values for failure_info. See ts_resp_print.c && ts_resp_verify.c */\r
 206 \r
 207 #define TS_INFO_BAD_ALG                 0\r
 208 #define TS_INFO_BAD_REQUEST             2\r
 209 #define TS_INFO_BAD_DATA_FORMAT         5\r
 210 #define TS_INFO_TIME_NOT_AVAILABLE      14\r
 211 #define TS_INFO_UNACCEPTED_POLICY       15\r
 212 #define TS_INFO_UNACCEPTED_EXTENSION    16\r
 213 #define TS_INFO_ADD_INFO_NOT_AVAILABLE  17\r
 214 #define TS_INFO_SYSTEM_FAILURE          25\r
 215 \r
 216 typedef struct TS_status_info_st\r
 217         {\r
 218         ASN1_INTEGER *status;\r
 219         STACK_OF(ASN1_UTF8STRING) *text;\r
 220         ASN1_BIT_STRING *failure_info;\r
 221         } TS_STATUS_INFO;\r
 222 \r
 223 DECLARE_STACK_OF(ASN1_UTF8STRING)\r
 224 DECLARE_ASN1_SET_OF(ASN1_UTF8STRING)\r
 225 \r
 226 /*\r
 227 TimeStampResp ::= SEQUENCE  {\r
 228      status                  PKIStatusInfo,\r
 229      timeStampToken          TimeStampToken     OPTIONAL }\r
 230 */\r
 231 \r
 232 typedef struct TS_resp_st\r
 233         {\r
 234         TS_STATUS_INFO *status_info;\r
 235         PKCS7 *token;\r
 236         TS_TST_INFO *tst_info;\r
 237         } TS_RESP;\r
 238 \r
 239 /* The structure below would belong to the ESS component. */\r
 240 \r
 241 /*\r
 242 IssuerSerial ::= SEQUENCE {\r
 243         issuer                   GeneralNames,\r
 244         serialNumber             CertificateSerialNumber\r
 245         }\r
 246 */\r
 247 \r
 248 typedef struct ESS_issuer_serial\r
 249         {\r
 250         STACK_OF(GENERAL_NAME)  *issuer;\r
 251         ASN1_INTEGER            *serial;\r
 252         } ESS_ISSUER_SERIAL;\r
 253 \r
 254 /*\r
 255 ESSCertID ::=  SEQUENCE {\r
 256         certHash                 Hash,\r
 257         issuerSerial             IssuerSerial OPTIONAL\r
 258 }\r
 259 */\r
 260 \r
 261 typedef struct ESS_cert_id\r
 262         {\r
 263         ASN1_OCTET_STRING *hash;        /* Always SHA-1 digest. */\r
 264         ESS_ISSUER_SERIAL *issuer_serial;\r
 265         } ESS_CERT_ID;\r
 266 \r
 267 DECLARE_STACK_OF(ESS_CERT_ID)\r
 268 DECLARE_ASN1_SET_OF(ESS_CERT_ID)\r
 269 \r
 270 /*\r
 271 SigningCertificate ::=  SEQUENCE {\r
 272        certs        SEQUENCE OF ESSCertID,\r
 273        policies     SEQUENCE OF PolicyInformation OPTIONAL\r
 274 }\r
 275 */\r
 276 \r
 277 typedef struct ESS_signing_cert\r
 278         {\r
 279         STACK_OF(ESS_CERT_ID) *cert_ids;\r
 280         STACK_OF(POLICYINFO) *policy_info;\r
 281         } ESS_SIGNING_CERT;\r
 282 \r
 283 \r
 284 TS_REQ  *TS_REQ_new(void);\r
 285 void    TS_REQ_free(TS_REQ *a);\r
 286 int     i2d_TS_REQ(const TS_REQ *a, unsigned char **pp);\r
 287 TS_REQ  *d2i_TS_REQ(TS_REQ **a, const unsigned char **pp, long length);\r
 288 \r
 289 TS_REQ  *TS_REQ_dup(TS_REQ *a);\r
 290 \r
 291 TS_REQ  *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a);\r
 292 int     i2d_TS_REQ_fp(FILE *fp, TS_REQ *a);\r
 293 TS_REQ  *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a);\r
 294 int     i2d_TS_REQ_bio(BIO *fp, TS_REQ *a);\r
 295 \r
 296 TS_MSG_IMPRINT  *TS_MSG_IMPRINT_new(void);\r
 297 void            TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a);\r
 298 int             i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **pp);\r
 299 TS_MSG_IMPRINT  *d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a,\r
 300                                     const unsigned char **pp, long length);\r
 301 \r
 302 TS_MSG_IMPRINT  *TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *a);\r
 303 \r
 304 TS_MSG_IMPRINT  *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a);\r
 305 int             i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a);\r
 306 TS_MSG_IMPRINT  *d2i_TS_MSG_IMPRINT_bio(BIO *fp, TS_MSG_IMPRINT **a);\r
 307 int             i2d_TS_MSG_IMPRINT_bio(BIO *fp, TS_MSG_IMPRINT *a);\r
 308 \r
 309 TS_RESP *TS_RESP_new(void);\r
 310 void    TS_RESP_free(TS_RESP *a);\r
 311 int     i2d_TS_RESP(const TS_RESP *a, unsigned char **pp);\r
 312 TS_RESP *d2i_TS_RESP(TS_RESP **a, const unsigned char **pp, long length);\r
 313 TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token);\r
 314 TS_RESP *TS_RESP_dup(TS_RESP *a);\r
 315 \r
 316 TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a);\r
 317 int     i2d_TS_RESP_fp(FILE *fp, TS_RESP *a);\r
 318 TS_RESP *d2i_TS_RESP_bio(BIO *fp, TS_RESP **a);\r
 319 int     i2d_TS_RESP_bio(BIO *fp, TS_RESP *a);\r
 320 \r
 321 TS_STATUS_INFO  *TS_STATUS_INFO_new(void);\r
 322 void            TS_STATUS_INFO_free(TS_STATUS_INFO *a);\r
 323 int             i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **pp);\r
 324 TS_STATUS_INFO  *d2i_TS_STATUS_INFO(TS_STATUS_INFO **a,\r
 325                                     const unsigned char **pp, long length);\r
 326 TS_STATUS_INFO  *TS_STATUS_INFO_dup(TS_STATUS_INFO *a);\r
 327 \r
 328 TS_TST_INFO     *TS_TST_INFO_new(void);\r
 329 void            TS_TST_INFO_free(TS_TST_INFO *a);\r
 330 int             i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **pp);\r
 331 TS_TST_INFO     *d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **pp,\r
 332                                     long length);\r
 333 TS_TST_INFO     *TS_TST_INFO_dup(TS_TST_INFO *a);\r
 334 \r
 335 TS_TST_INFO     *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a);\r
 336 int             i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a);\r
 337 TS_TST_INFO     *d2i_TS_TST_INFO_bio(BIO *fp, TS_TST_INFO **a);\r
 338 int             i2d_TS_TST_INFO_bio(BIO *fp, TS_TST_INFO *a);\r
 339 \r
 340 TS_ACCURACY     *TS_ACCURACY_new(void);\r
 341 void            TS_ACCURACY_free(TS_ACCURACY *a);\r
 342 int             i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **pp);\r
 343 TS_ACCURACY     *d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **pp,\r
 344                                     long length);\r
 345 TS_ACCURACY     *TS_ACCURACY_dup(TS_ACCURACY *a);\r
 346 \r
 347 ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_new(void);\r
 348 void              ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a);\r
 349 int               i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a,\r
 350                                         unsigned char **pp);\r
 351 ESS_ISSUER_SERIAL *d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a,\r
 352                                          const unsigned char **pp, long length);\r
 353 ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *a);\r
 354 \r
 355 ESS_CERT_ID     *ESS_CERT_ID_new(void);\r
 356 void            ESS_CERT_ID_free(ESS_CERT_ID *a);\r
 357 int             i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **pp);\r
 358 ESS_CERT_ID     *d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **pp,\r
 359                                  long length);\r
 360 ESS_CERT_ID     *ESS_CERT_ID_dup(ESS_CERT_ID *a);\r
 361 \r
 362 ESS_SIGNING_CERT *ESS_SIGNING_CERT_new(void);\r
 363 void             ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a);\r
 364 int              i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a,\r
 365                                       unsigned char **pp);\r
 366 ESS_SIGNING_CERT *d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a,\r
 367                                        const unsigned char **pp, long length);\r
 368 ESS_SIGNING_CERT *ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *a);\r
 369 \r
 370 void ERR_load_TS_strings(void);\r
 371 \r
 372 int TS_REQ_set_version(TS_REQ *a, long version);\r
 373 long TS_REQ_get_version(const TS_REQ *a);\r
 374 \r
 375 int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint);\r
 376 TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a);\r
 377 \r
 378 int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg);\r
 379 X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a);\r
 380 \r
 381 int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len);\r
 382 ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a);\r
 383 \r
 384 int TS_REQ_set_policy_id(TS_REQ *a, ASN1_OBJECT *policy);\r
 385 ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a);\r
 386 \r
 387 int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce);\r
 388 const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a);\r
 389 \r
 390 int TS_REQ_set_cert_req(TS_REQ *a, int cert_req);\r
 391 int TS_REQ_get_cert_req(const TS_REQ *a);\r
 392 \r
 393 STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a);\r
 394 void TS_REQ_ext_free(TS_REQ *a);\r
 395 int TS_REQ_get_ext_count(TS_REQ *a);\r
 396 int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos);\r
 397 int TS_REQ_get_ext_by_OBJ(TS_REQ *a, ASN1_OBJECT *obj, int lastpos);\r
 398 int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos);\r
 399 X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc);\r
 400 X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc);\r
 401 int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc);\r
 402 void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx);\r
 403 \r
 404 /* Function declarations for TS_REQ defined in ts/ts_req_print.c */\r
 405 \r
 406 int TS_REQ_print_bio(BIO *bio, TS_REQ *a);\r
 407 \r
 408 /* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */\r
 409 \r
 410 int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info);\r
 411 TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a);\r
 412 \r
 413 /* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */\r
 414 void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info);\r
 415 PKCS7 *TS_RESP_get_token(TS_RESP *a);\r
 416 TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a);\r
 417 \r
 418 int TS_TST_INFO_set_version(TS_TST_INFO *a, long version);\r
 419 long TS_TST_INFO_get_version(const TS_TST_INFO *a);\r
 420 \r
 421 int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id);\r
 422 ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a);\r
 423 \r
 424 int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint);\r
 425 TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a);\r
 426 \r
 427 int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial);\r
 428 const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a);\r
 429 \r
 430 int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime);\r
 431 const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a);\r
 432 \r
 433 int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy);\r
 434 TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a);\r
 435 \r
 436 int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds);\r
 437 const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a);\r
 438 \r
 439 int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis);\r
 440 const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a);\r
 441 \r
 442 int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros);\r
 443 const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a);\r
 444 \r
 445 int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering);\r
 446 int TS_TST_INFO_get_ordering(const TS_TST_INFO *a);\r
 447 \r
 448 int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce);\r
 449 const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a);\r
 450 \r
 451 int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa);\r
 452 GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a);\r
 453 \r
 454 STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a);\r
 455 void TS_TST_INFO_ext_free(TS_TST_INFO *a);\r
 456 int TS_TST_INFO_get_ext_count(TS_TST_INFO *a);\r
 457 int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos);\r
 458 int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, ASN1_OBJECT *obj, int lastpos);\r
 459 int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos);\r
 460 X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc);\r
 461 X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc);\r
 462 int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc);\r
 463 void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);\r
 464 \r
 465 /* Declarations related to response generation, defined in ts/ts_resp_sign.c. */\r
 466 \r
 467 /* Optional flags for response generation. */\r
 468 \r
 469 /* Don't include the TSA name in response. */\r
 470 #define TS_TSA_NAME             0x01\r
 471 \r
 472 /* Set ordering to true in response. */\r
 473 #define TS_ORDERING             0x02\r
 474 \r
 475 /*\r
 476  * Include the signer certificate and the other specified certificates in\r
 477  * the ESS signing certificate attribute beside the PKCS7 signed data.\r
 478  * Only the signer certificates is included by default.\r
 479  */\r
 480 #define TS_ESS_CERT_ID_CHAIN    0x04\r
 481 \r
 482 /* Forward declaration. */\r
 483 struct TS_resp_ctx;\r
 484 \r
 485 /* This must return a unique number less than 160 bits long. */\r
 486 typedef ASN1_INTEGER *(*TS_serial_cb)(struct TS_resp_ctx *, void *);\r
 487 \r
 488 /* This must return the seconds and microseconds since Jan 1, 1970 in\r
 489    the sec and usec variables allocated by the caller.\r
 490    Return non-zero for success and zero for failure. */\r
 491 typedef int (*TS_time_cb)(struct TS_resp_ctx *, void *, long *sec, long *usec);\r
 492 \r
 493 /* This must process the given extension.\r
 494  * It can modify the TS_TST_INFO object of the context.\r
 495  * Return values: !0 (processed), 0 (error, it must set the\r
 496  * status info/failure info of the response).\r
 497  */\r
 498 typedef int (*TS_extension_cb)(struct TS_resp_ctx *, X509_EXTENSION *, void *);\r
 499 \r
 500 typedef struct TS_resp_ctx\r
 501         {\r
 502         X509            *signer_cert;\r
 503         EVP_PKEY        *signer_key;\r
 504         STACK_OF(X509)  *certs; /* Certs to include in signed data. */\r
 505         STACK_OF(ASN1_OBJECT)   *policies;      /* Acceptable policies. */\r
 506         ASN1_OBJECT     *default_policy; /* It may appear in policies, too. */\r
 507         STACK_OF(EVP_MD)        *mds;   /* Acceptable message digests. */\r
 508         ASN1_INTEGER    *seconds;       /* accuracy, 0 means not specified. */\r
 509         ASN1_INTEGER    *millis;        /* accuracy, 0 means not specified. */\r
 510         ASN1_INTEGER    *micros;        /* accuracy, 0 means not specified. */\r
 511         unsigned        clock_precision_digits; /* fraction of seconds in\r
 512                                                    time stamp token. */\r
 513         unsigned        flags;          /* Optional info, see values above. */\r
 514 \r
 515         /* Callback functions. */\r
 516         TS_serial_cb serial_cb;\r
 517         void *serial_cb_data;   /* User data for serial_cb. */\r
 518 \r
 519         TS_time_cb time_cb;\r
 520         void *time_cb_data;     /* User data for time_cb. */\r
 521 \r
 522         TS_extension_cb extension_cb;\r
 523         void *extension_cb_data;        /* User data for extension_cb. */\r
 524 \r
 525         /* These members are used only while creating the response. */\r
 526         TS_REQ          *request;\r
 527         TS_RESP         *response;\r
 528         TS_TST_INFO     *tst_info;\r
 529         } TS_RESP_CTX;\r
 530 \r
 531 DECLARE_STACK_OF(EVP_MD)\r
 532 DECLARE_ASN1_SET_OF(EVP_MD)\r
 533 \r
 534 /* Creates a response context that can be used for generating responses. */\r
 535 TS_RESP_CTX *TS_RESP_CTX_new(void);\r
 536 void TS_RESP_CTX_free(TS_RESP_CTX *ctx);\r
 537 \r
 538 /* This parameter must be set. */\r
 539 int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer);\r
 540 \r
 541 /* This parameter must be set. */\r
 542 int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key);\r
 543 \r
 544 /* This parameter must be set. */\r
 545 int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *def_policy);\r
 546 \r
 547 /* No additional certs are included in the response by default. */\r
 548 int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs);\r
 549 \r
 550 /* Adds a new acceptable policy, only the default policy\r
 551    is accepted by default. */\r
 552 int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *policy);\r
 553 \r
 554 /* Adds a new acceptable message digest. Note that no message digests\r
 555    are accepted by default. The md argument is shared with the caller. */\r
 556 int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);\r
 557 \r
 558 /* Accuracy is not included by default. */\r
 559 int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx,\r
 560                              int secs, int millis, int micros);\r
 561 \r
 562 /* Clock precision digits, i.e. the number of decimal digits:\r
 563    '0' means sec, '3' msec, '6' usec, and so on. Default is 0. */\r
 564 int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx,\r
 565                                            unsigned clock_precision_digits);\r
 566 /* At most we accept usec precision. */\r
 567 #define TS_MAX_CLOCK_PRECISION_DIGITS   6\r
 568 \r
 569 /* No flags are set by default. */\r
 570 void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags);\r
 571 \r
 572 /* Default callback always returns a constant. */\r
 573 void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data);\r
 574 \r
 575 /* Default callback uses the gettimeofday() and gmtime() system calls. */\r
 576 void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data);\r
 577 \r
 578 /* Default callback rejects all extensions. The extension callback is called\r
 579  * when the TS_TST_INFO object is already set up and not signed yet. */\r
 580 /* FIXME: extension handling is not tested yet. */\r
 581 void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx,\r
 582                                   TS_extension_cb cb, void *data);\r
 583 \r
 584 /* The following methods can be used in the callbacks. */\r
 585 int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx,\r
 586                                 int status, const char *text);\r
 587 \r
 588 /* Sets the status info only if it is still TS_STATUS_GRANTED. */\r
 589 int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx,\r
 590                                      int status, const char *text);\r
 591 \r
 592 int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);\r
 593 \r
 594 /* The get methods below can be used in the extension callback. */\r
 595 TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx);\r
 596 \r
 597 TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx);\r
 598 \r
 599 /*\r
 600  * Creates the signed TS_TST_INFO and puts it in TS_RESP.\r
 601  * In case of errors it sets the status info properly.\r
 602  * Returns NULL only in case of memory allocation/fatal error.\r
 603  */\r
 604 TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio);\r
 605 \r
 606 /*\r
 607  * Declarations related to response verification,\r
 608  * they are defined in ts/ts_resp_verify.c.\r
 609  */\r
 610 \r
 611 int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,\r
 612                              X509_STORE *store, X509 **signer_out);\r
 613 \r
 614 /* Context structure for the generic verify method. */\r
 615 \r
 616 /* Verify the signer's certificate and the signature of the response. */\r
 617 #define TS_VFY_SIGNATURE        (1u << 0)\r
 618 /* Verify the version number of the response. */\r
 619 #define TS_VFY_VERSION          (1u << 1)\r
 620 /* Verify if the policy supplied by the user matches the policy of the TSA. */\r
 621 #define TS_VFY_POLICY           (1u << 2)\r
 622 /* Verify the message imprint provided by the user. This flag should not be\r
 623    specified with TS_VFY_DATA. */\r
 624 #define TS_VFY_IMPRINT          (1u << 3)\r
 625 /* Verify the message imprint computed by the verify method from the user\r
 626    provided data and the MD algorithm of the response. This flag should not be\r
 627    specified with TS_VFY_IMPRINT. */\r
 628 #define TS_VFY_DATA             (1u << 4)\r
 629 /* Verify the nonce value. */\r
 630 #define TS_VFY_NONCE            (1u << 5)\r
 631 /* Verify if the TSA name field matches the signer certificate. */\r
 632 #define TS_VFY_SIGNER           (1u << 6)\r
 633 /* Verify if the TSA name field equals to the user provided name. */\r
 634 #define TS_VFY_TSA_NAME         (1u << 7)\r
 635 \r
 636 /* You can use the following convenience constants. */\r
 637 #define TS_VFY_ALL_IMPRINT      (TS_VFY_SIGNATURE       \\r
 638                                  | TS_VFY_VERSION       \\r
 639                                  | TS_VFY_POLICY        \\r
 640                                  | TS_VFY_IMPRINT       \\r
 641                                  | TS_VFY_NONCE         \\r
 642                                  | TS_VFY_SIGNER        \\r
 643                                  | TS_VFY_TSA_NAME)\r
 644 #define TS_VFY_ALL_DATA         (TS_VFY_SIGNATURE       \\r
 645                                  | TS_VFY_VERSION       \\r
 646                                  | TS_VFY_POLICY        \\r
 647                                  | TS_VFY_DATA          \\r
 648                                  | TS_VFY_NONCE         \\r
 649                                  | TS_VFY_SIGNER        \\r
 650                                  | TS_VFY_TSA_NAME)\r
 651 \r
 652 typedef struct TS_verify_ctx\r
 653         {\r
 654         /* Set this to the union of TS_VFY_... flags you want to carry out. */\r
 655         unsigned        flags;\r
 656 \r
 657         /* Must be set only with TS_VFY_SIGNATURE. certs is optional. */\r
 658         X509_STORE      *store;\r
 659         STACK_OF(X509)  *certs;\r
 660 \r
 661         /* Must be set only with TS_VFY_POLICY. */\r
 662         ASN1_OBJECT     *policy;\r
 663 \r
 664         /* Must be set only with TS_VFY_IMPRINT. If md_alg is NULL,\r
 665            the algorithm from the response is used. */\r
 666         X509_ALGOR      *md_alg;\r
 667         unsigned char   *imprint;\r
 668         unsigned        imprint_len;\r
 669 \r
 670         /* Must be set only with TS_VFY_DATA. */\r
 671         BIO             *data;\r
 672 \r
 673         /* Must be set only with TS_VFY_TSA_NAME. */\r
 674         ASN1_INTEGER    *nonce;\r
 675 \r
 676         /* Must be set only with TS_VFY_TSA_NAME. */\r
 677         GENERAL_NAME    *tsa_name;\r
 678         } TS_VERIFY_CTX;\r
 679 \r
 680 int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);\r
 681 int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);\r
 682 \r
 683 /*\r
 684  * Declarations related to response verification context,\r
 685  * they are defined in ts/ts_verify_ctx.c.\r
 686  */\r
 687 \r
 688 /* Set all fields to zero. */\r
 689 TS_VERIFY_CTX *TS_VERIFY_CTX_new(void);\r
 690 void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx);\r
 691 void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx);\r
 692 void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);\r
 693 \r
 694 /*\r
 695  * If ctx is NULL, it allocates and returns a new object, otherwise\r
 696  * it returns ctx. It initialises all the members as follows:\r
 697  * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)\r
 698  * certs = NULL\r
 699  * store = NULL\r
 700  * policy = policy from the request or NULL if absent (in this case\r
 701  *      TS_VFY_POLICY is cleared from flags as well)\r
 702  * md_alg = MD algorithm from request\r
 703  * imprint, imprint_len = imprint from request\r
 704  * data = NULL\r
 705  * nonce, nonce_len = nonce from the request or NULL if absent (in this case\r
 706  *      TS_VFY_NONCE is cleared from flags as well)\r
 707  * tsa_name = NULL\r
 708  * Important: after calling this method TS_VFY_SIGNATURE should be added!\r
 709  */\r
 710 TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx);\r
 711 \r
 712 /* Function declarations for TS_RESP defined in ts/ts_resp_print.c */\r
 713 \r
 714 int TS_RESP_print_bio(BIO *bio, TS_RESP *a);\r
 715 int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a);\r
 716 int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a);\r
 717 \r
 718 /* Common utility functions defined in ts/ts_lib.c */\r
 719 \r
 720 int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num);\r
 721 int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj);\r
 722 int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions);\r
 723 int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg);\r
 724 int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg);\r
 725 \r
 726 /* Function declarations for handling configuration options,\r
 727    defined in ts/ts_conf.c */\r
 728 \r
 729 X509 *TS_CONF_load_cert(const char *file);\r
 730 STACK_OF(X509) *TS_CONF_load_certs(const char *file);\r
 731 EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);\r
 732 const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);\r
 733 int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,\r
 734                        TS_RESP_CTX *ctx);\r
 735 int TS_CONF_set_crypto_device(CONF *conf, const char *section,\r
 736                               const char *device);\r
 737 int TS_CONF_set_default_engine(const char *name);\r
 738 int TS_CONF_set_signer_cert(CONF *conf, const char *section,\r
 739                             const char *cert, TS_RESP_CTX *ctx);\r
 740 int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,\r
 741                       TS_RESP_CTX *ctx);\r
 742 int TS_CONF_set_signer_key(CONF *conf, const char *section,\r
 743                            const char *key, const char *pass, TS_RESP_CTX *ctx);\r
 744 int TS_CONF_set_def_policy(CONF *conf, const char *section,\r
 745                            const char *policy, TS_RESP_CTX *ctx);\r
 746 int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);\r
 747 int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);\r
 748 int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);\r
 749 int TS_CONF_set_clock_precision_digits(CONF *conf, const char *section,\r
 750                                        TS_RESP_CTX *ctx);\r
 751 int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);\r
 752 int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);\r
 753 int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,\r
 754                                   TS_RESP_CTX *ctx);\r
 755 \r
 756 /* -------------------------------------------------- */\r
 757 /* BEGIN ERROR CODES */\r
 758 /* The following lines are auto generated by the script mkerr.pl. Any changes\r
 759  * made after this point may be overwritten when the script is next run.\r
 760  */\r
 761 void ERR_load_TS_strings(void);\r
 762 \r
 763 /* Error codes for the TS functions. */\r
 764 \r
 765 /* Function codes. */\r
 766 #define TS_F_D2I_TS_RESP                                 147\r
 767 #define TS_F_DEF_SERIAL_CB                               110\r
 768 #define TS_F_DEF_TIME_CB                                 111\r
 769 #define TS_F_ESS_ADD_SIGNING_CERT                        112\r
 770 #define TS_F_ESS_CERT_ID_NEW_INIT                        113\r
 771 #define TS_F_ESS_SIGNING_CERT_NEW_INIT                   114\r
 772 #define TS_F_INT_TS_RESP_VERIFY_TOKEN                    149\r
 773 #define TS_F_PKCS7_TO_TS_TST_INFO                        148\r
 774 #define TS_F_TS_ACCURACY_SET_MICROS                      115\r
 775 #define TS_F_TS_ACCURACY_SET_MILLIS                      116\r
 776 #define TS_F_TS_ACCURACY_SET_SECONDS                     117\r
 777 #define TS_F_TS_CHECK_IMPRINTS                           100\r
 778 #define TS_F_TS_CHECK_NONCES                             101\r
 779 #define TS_F_TS_CHECK_POLICY                             102\r
 780 #define TS_F_TS_CHECK_SIGNING_CERTS                      103\r
 781 #define TS_F_TS_CHECK_STATUS_INFO                        104\r
 782 #define TS_F_TS_COMPUTE_IMPRINT                          145\r
 783 #define TS_F_TS_CONF_SET_DEFAULT_ENGINE                  146\r
 784 #define TS_F_TS_GET_STATUS_TEXT                          105\r
 785 #define TS_F_TS_MSG_IMPRINT_SET_ALGO                     118\r
 786 #define TS_F_TS_REQ_SET_MSG_IMPRINT                      119\r
 787 #define TS_F_TS_REQ_SET_NONCE                            120\r
 788 #define TS_F_TS_REQ_SET_POLICY_ID                        121\r
 789 #define TS_F_TS_RESP_CREATE_RESPONSE                     122\r
 790 #define TS_F_TS_RESP_CREATE_TST_INFO                     123\r
 791 #define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO                124\r
 792 #define TS_F_TS_RESP_CTX_ADD_MD                          125\r
 793 #define TS_F_TS_RESP_CTX_ADD_POLICY                      126\r
 794 #define TS_F_TS_RESP_CTX_NEW                             127\r
 795 #define TS_F_TS_RESP_CTX_SET_ACCURACY                    128\r
 796 #define TS_F_TS_RESP_CTX_SET_CERTS                       129\r
 797 #define TS_F_TS_RESP_CTX_SET_DEF_POLICY                  130\r
 798 #define TS_F_TS_RESP_CTX_SET_SIGNER_CERT                 131\r
 799 #define TS_F_TS_RESP_CTX_SET_STATUS_INFO                 132\r
 800 #define TS_F_TS_RESP_GET_POLICY                          133\r
 801 #define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION          134\r
 802 #define TS_F_TS_RESP_SET_STATUS_INFO                     135\r
 803 #define TS_F_TS_RESP_SET_TST_INFO                        150\r
 804 #define TS_F_TS_RESP_SIGN                                136\r
 805 #define TS_F_TS_RESP_VERIFY_SIGNATURE                    106\r
 806 #define TS_F_TS_RESP_VERIFY_TOKEN                        107\r
 807 #define TS_F_TS_TST_INFO_SET_ACCURACY                    137\r
 808 #define TS_F_TS_TST_INFO_SET_MSG_IMPRINT                 138\r
 809 #define TS_F_TS_TST_INFO_SET_NONCE                       139\r
 810 #define TS_F_TS_TST_INFO_SET_POLICY_ID                   140\r
 811 #define TS_F_TS_TST_INFO_SET_SERIAL                      141\r
 812 #define TS_F_TS_TST_INFO_SET_TIME                        142\r
 813 #define TS_F_TS_TST_INFO_SET_TSA                         143\r
 814 #define TS_F_TS_VERIFY                                   108\r
 815 #define TS_F_TS_VERIFY_CERT                              109\r
 816 #define TS_F_TS_VERIFY_CTX_NEW                           144\r
 817 \r
 818 /* Reason codes. */\r
 819 #define TS_R_BAD_PKCS7_TYPE                              132\r
 820 #define TS_R_BAD_TYPE                                    133\r
 821 #define TS_R_CERTIFICATE_VERIFY_ERROR                    100\r
 822 #define TS_R_COULD_NOT_SET_ENGINE                        127\r
 823 #define TS_R_COULD_NOT_SET_TIME                          115\r
 824 #define TS_R_D2I_TS_RESP_INT_FAILED                      128\r
 825 #define TS_R_DETACHED_CONTENT                            134\r
 826 #define TS_R_ESS_ADD_SIGNING_CERT_ERROR                  116\r
 827 #define TS_R_ESS_SIGNING_CERTIFICATE_ERROR               101\r
 828 #define TS_R_INVALID_NULL_POINTER                        102\r
 829 #define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE          117\r
 830 #define TS_R_MESSAGE_IMPRINT_MISMATCH                    103\r
 831 #define TS_R_NONCE_MISMATCH                              104\r
 832 #define TS_R_NONCE_NOT_RETURNED                          105\r
 833 #define TS_R_NO_CONTENT                                  106\r
 834 #define TS_R_NO_TIME_STAMP_TOKEN                         107\r
 835 #define TS_R_PKCS7_ADD_SIGNATURE_ERROR                   118\r
 836 #define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR                 119\r
 837 #define TS_R_PKCS7_TO_TS_TST_INFO_FAILED                 129\r
 838 #define TS_R_POLICY_MISMATCH                             108\r
 839 #define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE      120\r
 840 #define TS_R_RESPONSE_SETUP_ERROR                        121\r
 841 #define TS_R_SIGNATURE_FAILURE                           109\r
 842 #define TS_R_THERE_MUST_BE_ONE_SIGNER                    110\r
 843 #define TS_R_TIME_SYSCALL_ERROR                          122\r
 844 #define TS_R_TOKEN_NOT_PRESENT                           130\r
 845 #define TS_R_TOKEN_PRESENT                               131\r
 846 #define TS_R_TSA_NAME_MISMATCH                           111\r
 847 #define TS_R_TSA_UNTRUSTED                               112\r
 848 #define TS_R_TST_INFO_SETUP_ERROR                        123\r
 849 #define TS_R_TS_DATASIGN                                 124\r
 850 #define TS_R_UNACCEPTABLE_POLICY                         125\r
 851 #define TS_R_UNSUPPORTED_MD_ALGORITHM                    126\r
 852 #define TS_R_UNSUPPORTED_VERSION                         113\r
 853 #define TS_R_WRONG_CONTENT_TYPE                          114\r
 854 \r
 855 #ifdef  __cplusplus\r
 856 }\r
 857 #endif\r
 858 #endif\r