diff options
Diffstat (limited to 'src/lib/libcrypto/x509/x509_vfy.h')
-rw-r--r-- | src/lib/libcrypto/x509/x509_vfy.h | 362 |
1 files changed, 0 insertions, 362 deletions
diff --git a/src/lib/libcrypto/x509/x509_vfy.h b/src/lib/libcrypto/x509/x509_vfy.h deleted file mode 100644 index 4637aecedf..0000000000 --- a/src/lib/libcrypto/x509/x509_vfy.h +++ /dev/null | |||
@@ -1,362 +0,0 @@ | |||
1 | /* crypto/x509/x509_vfy.h */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | #ifndef HEADER_X509_H | ||
60 | #include <openssl/x509.h> | ||
61 | /* openssl/x509.h ends up #include-ing this file at about the only | ||
62 | * appropriate moment. */ | ||
63 | #endif | ||
64 | |||
65 | #ifndef HEADER_X509_VFY_H | ||
66 | #define HEADER_X509_VFY_H | ||
67 | |||
68 | #ifdef __cplusplus | ||
69 | extern "C" { | ||
70 | #endif | ||
71 | |||
72 | #include <openssl/bio.h> | ||
73 | #include <openssl/crypto.h> | ||
74 | |||
75 | /* Outer object */ | ||
76 | typedef struct x509_hash_dir_st | ||
77 | { | ||
78 | int num_dirs; | ||
79 | char **dirs; | ||
80 | int *dirs_type; | ||
81 | int num_dirs_alloced; | ||
82 | } X509_HASH_DIR_CTX; | ||
83 | |||
84 | typedef struct x509_file_st | ||
85 | { | ||
86 | int num_paths; /* number of paths to files or directories */ | ||
87 | int num_alloced; | ||
88 | char **paths; /* the list of paths or directories */ | ||
89 | int *path_type; | ||
90 | } X509_CERT_FILE_CTX; | ||
91 | |||
92 | /*******************************/ | ||
93 | /* | ||
94 | SSL_CTX -> X509_STORE | ||
95 | -> X509_LOOKUP | ||
96 | ->X509_LOOKUP_METHOD | ||
97 | -> X509_LOOKUP | ||
98 | ->X509_LOOKUP_METHOD | ||
99 | |||
100 | SSL -> X509_STORE_CTX | ||
101 | ->X509_STORE | ||
102 | |||
103 | The X509_STORE holds the tables etc for verification stuff. | ||
104 | A X509_STORE_CTX is used while validating a single certificate. | ||
105 | The X509_STORE has X509_LOOKUPs for looking up certs. | ||
106 | The X509_STORE then calls a function to actually verify the | ||
107 | certificate chain. | ||
108 | */ | ||
109 | |||
110 | #define X509_LU_RETRY -1 | ||
111 | #define X509_LU_FAIL 0 | ||
112 | #define X509_LU_X509 1 | ||
113 | #define X509_LU_CRL 2 | ||
114 | #define X509_LU_PKEY 3 | ||
115 | |||
116 | typedef struct x509_object_st | ||
117 | { | ||
118 | /* one of the above types */ | ||
119 | int type; | ||
120 | union { | ||
121 | char *ptr; | ||
122 | X509 *x509; | ||
123 | X509_CRL *crl; | ||
124 | EVP_PKEY *pkey; | ||
125 | } data; | ||
126 | } X509_OBJECT; | ||
127 | |||
128 | typedef struct x509_lookup_st X509_LOOKUP; | ||
129 | |||
130 | DECLARE_STACK_OF(X509_LOOKUP) | ||
131 | |||
132 | /* This is a static that defines the function interface */ | ||
133 | typedef struct x509_lookup_method_st | ||
134 | { | ||
135 | const char *name; | ||
136 | int (*new_item)(X509_LOOKUP *ctx); | ||
137 | void (*free)(X509_LOOKUP *ctx); | ||
138 | int (*init)(X509_LOOKUP *ctx); | ||
139 | int (*shutdown)(X509_LOOKUP *ctx); | ||
140 | int (*ctrl)(X509_LOOKUP *ctx,int cmd,const char *argc,long argl, | ||
141 | char **ret); | ||
142 | int (*get_by_subject)(X509_LOOKUP *ctx,int type,X509_NAME *name, | ||
143 | X509_OBJECT *ret); | ||
144 | int (*get_by_issuer_serial)(X509_LOOKUP *ctx,int type,X509_NAME *name, | ||
145 | ASN1_INTEGER *serial,X509_OBJECT *ret); | ||
146 | int (*get_by_fingerprint)(X509_LOOKUP *ctx,int type, | ||
147 | unsigned char *bytes,int len, | ||
148 | X509_OBJECT *ret); | ||
149 | int (*get_by_alias)(X509_LOOKUP *ctx,int type,char *str,int len, | ||
150 | X509_OBJECT *ret); | ||
151 | } X509_LOOKUP_METHOD; | ||
152 | |||
153 | typedef struct x509_store_state_st X509_STORE_CTX; | ||
154 | |||
155 | /* This is used to hold everything. It is used for all certificate | ||
156 | * validation. Once we have a certificate chain, the 'verify' | ||
157 | * function is then called to actually check the cert chain. */ | ||
158 | typedef struct x509_store_st | ||
159 | { | ||
160 | /* The following is a cache of trusted certs */ | ||
161 | int cache; /* if true, stash any hits */ | ||
162 | #ifdef HEADER_LHASH_H | ||
163 | LHASH *certs; /* cached certs; */ | ||
164 | #else | ||
165 | char *certs; | ||
166 | #endif | ||
167 | |||
168 | /* These are external lookup methods */ | ||
169 | STACK_OF(X509_LOOKUP) *get_cert_methods; | ||
170 | int (*verify)(X509_STORE_CTX *ctx); /* called to verify a certificate */ | ||
171 | int (*verify_cb)(int ok,X509_STORE_CTX *ctx); /* error callback */ | ||
172 | |||
173 | CRYPTO_EX_DATA ex_data; | ||
174 | int references; | ||
175 | int depth; /* how deep to look (still unused -- X509_STORE_CTX's depth is used) */ | ||
176 | } X509_STORE; | ||
177 | |||
178 | #define X509_STORE_set_depth(ctx,d) ((ctx)->depth=(d)) | ||
179 | |||
180 | #define X509_STORE_set_verify_cb_func(ctx,func) ((ctx)->verify_cb=(func)) | ||
181 | #define X509_STORE_set_verify_func(ctx,func) ((ctx)->verify=(func)) | ||
182 | |||
183 | /* This is the functions plus an instance of the local variables. */ | ||
184 | struct x509_lookup_st | ||
185 | { | ||
186 | int init; /* have we been started */ | ||
187 | int skip; /* don't use us. */ | ||
188 | X509_LOOKUP_METHOD *method; /* the functions */ | ||
189 | char *method_data; /* method data */ | ||
190 | |||
191 | X509_STORE *store_ctx; /* who owns us */ | ||
192 | }; | ||
193 | |||
194 | /* This is a temporary used when processing cert chains. Since the | ||
195 | * gathering of the cert chain can take some time (and have to be | ||
196 | * 'retried', this needs to be kept and passed around. */ | ||
197 | struct x509_store_state_st /* X509_STORE_CTX */ | ||
198 | { | ||
199 | X509_STORE *ctx; | ||
200 | int current_method; /* used when looking up certs */ | ||
201 | |||
202 | /* The following are set by the caller */ | ||
203 | X509 *cert; /* The cert to check */ | ||
204 | STACK_OF(X509) *untrusted; /* chain of X509s - untrusted - passed in */ | ||
205 | int purpose; /* purpose to check untrusted certificates */ | ||
206 | int trust; /* trust setting to check */ | ||
207 | |||
208 | /* The following is built up */ | ||
209 | int depth; /* how far to go looking up certs */ | ||
210 | int valid; /* if 0, rebuild chain */ | ||
211 | int last_untrusted; /* index of last untrusted cert */ | ||
212 | STACK_OF(X509) *chain; /* chain of X509s - built up and trusted */ | ||
213 | |||
214 | /* When something goes wrong, this is why */ | ||
215 | int error_depth; | ||
216 | int error; | ||
217 | X509 *current_cert; | ||
218 | |||
219 | CRYPTO_EX_DATA ex_data; | ||
220 | }; | ||
221 | |||
222 | #define X509_STORE_CTX_set_depth(ctx,d) ((ctx)->depth=(d)) | ||
223 | |||
224 | #define X509_STORE_CTX_set_app_data(ctx,data) \ | ||
225 | X509_STORE_CTX_set_ex_data(ctx,0,data) | ||
226 | #define X509_STORE_CTX_get_app_data(ctx) \ | ||
227 | X509_STORE_CTX_get_ex_data(ctx,0) | ||
228 | |||
229 | #define X509_L_FILE_LOAD 1 | ||
230 | #define X509_L_ADD_DIR 2 | ||
231 | |||
232 | #define X509_LOOKUP_load_file(x,name,type) \ | ||
233 | X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL) | ||
234 | |||
235 | #define X509_LOOKUP_add_dir(x,name,type) \ | ||
236 | X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL) | ||
237 | |||
238 | #define X509_V_OK 0 | ||
239 | /* illegal error (for uninitialized values, to avoid X509_V_OK): 1 */ | ||
240 | |||
241 | #define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT 2 | ||
242 | #define X509_V_ERR_UNABLE_TO_GET_CRL 3 | ||
243 | #define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE 4 | ||
244 | #define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE 5 | ||
245 | #define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY 6 | ||
246 | #define X509_V_ERR_CERT_SIGNATURE_FAILURE 7 | ||
247 | #define X509_V_ERR_CRL_SIGNATURE_FAILURE 8 | ||
248 | #define X509_V_ERR_CERT_NOT_YET_VALID 9 | ||
249 | #define X509_V_ERR_CERT_HAS_EXPIRED 10 | ||
250 | #define X509_V_ERR_CRL_NOT_YET_VALID 11 | ||
251 | #define X509_V_ERR_CRL_HAS_EXPIRED 12 | ||
252 | #define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD 13 | ||
253 | #define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD 14 | ||
254 | #define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD 15 | ||
255 | #define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD 16 | ||
256 | #define X509_V_ERR_OUT_OF_MEM 17 | ||
257 | #define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT 18 | ||
258 | #define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN 19 | ||
259 | #define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 20 | ||
260 | #define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE 21 | ||
261 | #define X509_V_ERR_CERT_CHAIN_TOO_LONG 22 | ||
262 | #define X509_V_ERR_CERT_REVOKED 23 | ||
263 | #define X509_V_ERR_INVALID_CA 24 | ||
264 | #define X509_V_ERR_PATH_LENGTH_EXCEEDED 25 | ||
265 | #define X509_V_ERR_INVALID_PURPOSE 26 | ||
266 | #define X509_V_ERR_CERT_UNTRUSTED 27 | ||
267 | #define X509_V_ERR_CERT_REJECTED 28 | ||
268 | |||
269 | /* The application is not happy */ | ||
270 | #define X509_V_ERR_APPLICATION_VERIFICATION 50 | ||
271 | |||
272 | /* These functions are being redefined in another directory, | ||
273 | and clash when the linker is case-insensitive, so let's | ||
274 | hide them a little, by giving them an extra 'o' at the | ||
275 | beginning of the name... */ | ||
276 | #ifdef VMS | ||
277 | #undef X509v3_cleanup_extensions | ||
278 | #define X509v3_cleanup_extensions oX509v3_cleanup_extensions | ||
279 | #undef X509v3_add_extension | ||
280 | #define X509v3_add_extension oX509v3_add_extension | ||
281 | #undef X509v3_add_netscape_extensions | ||
282 | #define X509v3_add_netscape_extensions oX509v3_add_netscape_extensions | ||
283 | #undef X509v3_add_standard_extensions | ||
284 | #define X509v3_add_standard_extensions oX509v3_add_standard_extensions | ||
285 | #endif | ||
286 | |||
287 | #ifdef HEADER_LHASH_H | ||
288 | X509_OBJECT *X509_OBJECT_retrieve_by_subject(LHASH *h,int type,X509_NAME *name); | ||
289 | #endif | ||
290 | void X509_OBJECT_up_ref_count(X509_OBJECT *a); | ||
291 | void X509_OBJECT_free_contents(X509_OBJECT *a); | ||
292 | X509_STORE *X509_STORE_new(void ); | ||
293 | void X509_STORE_free(X509_STORE *v); | ||
294 | |||
295 | X509_STORE_CTX *X509_STORE_CTX_new(void); | ||
296 | void X509_STORE_CTX_free(X509_STORE_CTX *ctx); | ||
297 | void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, | ||
298 | X509 *x509, STACK_OF(X509) *chain); | ||
299 | void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx); | ||
300 | |||
301 | X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m); | ||
302 | |||
303 | X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void); | ||
304 | X509_LOOKUP_METHOD *X509_LOOKUP_file(void); | ||
305 | |||
306 | int X509_STORE_add_cert(X509_STORE *ctx, X509 *x); | ||
307 | int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x); | ||
308 | |||
309 | int X509_STORE_get_by_subject(X509_STORE_CTX *vs,int type,X509_NAME *name, | ||
310 | X509_OBJECT *ret); | ||
311 | |||
312 | int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, | ||
313 | long argl, char **ret); | ||
314 | |||
315 | #ifndef NO_STDIO | ||
316 | int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type); | ||
317 | int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type); | ||
318 | int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type); | ||
319 | #endif | ||
320 | |||
321 | |||
322 | X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method); | ||
323 | void X509_LOOKUP_free(X509_LOOKUP *ctx); | ||
324 | int X509_LOOKUP_init(X509_LOOKUP *ctx); | ||
325 | int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name, | ||
326 | X509_OBJECT *ret); | ||
327 | int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name, | ||
328 | ASN1_INTEGER *serial, X509_OBJECT *ret); | ||
329 | int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type, | ||
330 | unsigned char *bytes, int len, X509_OBJECT *ret); | ||
331 | int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, | ||
332 | int len, X509_OBJECT *ret); | ||
333 | int X509_LOOKUP_shutdown(X509_LOOKUP *ctx); | ||
334 | |||
335 | #ifndef NO_STDIO | ||
336 | int X509_STORE_load_locations (X509_STORE *ctx, | ||
337 | const char *file, const char *dir); | ||
338 | int X509_STORE_set_default_paths(X509_STORE *ctx); | ||
339 | #endif | ||
340 | |||
341 | int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, | ||
342 | CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); | ||
343 | int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx,int idx,void *data); | ||
344 | void * X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx,int idx); | ||
345 | int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx); | ||
346 | void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx,int s); | ||
347 | int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx); | ||
348 | X509 * X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx); | ||
349 | STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx); | ||
350 | STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx); | ||
351 | void X509_STORE_CTX_set_cert(X509_STORE_CTX *c,X509 *x); | ||
352 | void X509_STORE_CTX_set_chain(X509_STORE_CTX *c,STACK_OF(X509) *sk); | ||
353 | int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose); | ||
354 | int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust); | ||
355 | int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, | ||
356 | int purpose, int trust); | ||
357 | |||
358 | #ifdef __cplusplus | ||
359 | } | ||
360 | #endif | ||
361 | #endif | ||
362 | |||