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