]>
Commit | Line | Data |
---|---|---|
b1322259 | 1 | /* |
fecb3aae | 2 | * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. |
d02b48c6 | 3 | * |
3e4b43b9 | 4 | * Licensed under the Apache License 2.0 (the "License"). You may not use |
b1322259 RS |
5 | * this file except in compliance with the License. You can obtain a copy |
6 | * in the file LICENSE in the source distribution or at | |
7 | * https://www.openssl.org/source/license.html | |
d02b48c6 RE |
8 | */ |
9 | ||
10 | #include <stdio.h> | |
b39fc560 | 11 | #include "internal/cryptlib.h" |
cd420b0b | 12 | #include "internal/refcount.h" |
ec577822 | 13 | #include <openssl/x509.h> |
25f2138b | 14 | #include "crypto/x509.h" |
926a56bf | 15 | #include <openssl/x509v3.h> |
706457b7 | 16 | #include "x509_local.h" |
d02b48c6 | 17 | |
6b691a5c | 18 | X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method) |
0f113f3e | 19 | { |
7fcdbd83 | 20 | X509_LOOKUP *ret = OPENSSL_zalloc(sizeof(*ret)); |
0f113f3e | 21 | |
e077455e | 22 | if (ret == NULL) |
0f113f3e MC |
23 | return NULL; |
24 | ||
0f113f3e | 25 | ret->method = method; |
7fcdbd83 | 26 | if (method->new_item != NULL && method->new_item(ret) == 0) { |
0f113f3e MC |
27 | OPENSSL_free(ret); |
28 | return NULL; | |
29 | } | |
30 | return ret; | |
31 | } | |
d02b48c6 | 32 | |
6b691a5c | 33 | void X509_LOOKUP_free(X509_LOOKUP *ctx) |
0f113f3e MC |
34 | { |
35 | if (ctx == NULL) | |
36 | return; | |
37 | if ((ctx->method != NULL) && (ctx->method->free != NULL)) | |
38 | (*ctx->method->free) (ctx); | |
39 | OPENSSL_free(ctx); | |
40 | } | |
d02b48c6 | 41 | |
c34e7876 | 42 | int X509_STORE_lock(X509_STORE *xs) |
3067095e | 43 | { |
c34e7876 | 44 | return CRYPTO_THREAD_write_lock(xs->lock); |
3067095e RL |
45 | } |
46 | ||
80935bf5 MC |
47 | static int x509_store_read_lock(X509_STORE *xs) |
48 | { | |
49 | return CRYPTO_THREAD_read_lock(xs->lock); | |
50 | } | |
51 | ||
c34e7876 | 52 | int X509_STORE_unlock(X509_STORE *xs) |
3067095e | 53 | { |
c34e7876 | 54 | return CRYPTO_THREAD_unlock(xs->lock); |
3067095e RL |
55 | } |
56 | ||
6b691a5c | 57 | int X509_LOOKUP_init(X509_LOOKUP *ctx) |
0f113f3e MC |
58 | { |
59 | if (ctx->method == NULL) | |
60 | return 0; | |
61 | if (ctx->method->init != NULL) | |
62 | return ctx->method->init(ctx); | |
63 | else | |
64 | return 1; | |
65 | } | |
d02b48c6 | 66 | |
6b691a5c | 67 | int X509_LOOKUP_shutdown(X509_LOOKUP *ctx) |
0f113f3e MC |
68 | { |
69 | if (ctx->method == NULL) | |
70 | return 0; | |
71 | if (ctx->method->shutdown != NULL) | |
72 | return ctx->method->shutdown(ctx); | |
73 | else | |
74 | return 1; | |
75 | } | |
d02b48c6 | 76 | |
d8652be0 | 77 | int X509_LOOKUP_ctrl_ex(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, |
b4250010 | 78 | char **ret, OSSL_LIB_CTX *libctx, const char *propq) |
0f113f3e MC |
79 | { |
80 | if (ctx->method == NULL) | |
81 | return -1; | |
d8652be0 MC |
82 | if (ctx->method->ctrl_ex != NULL) |
83 | return ctx->method->ctrl_ex(ctx, cmd, argc, argl, ret, libctx, propq); | |
0f113f3e MC |
84 | if (ctx->method->ctrl != NULL) |
85 | return ctx->method->ctrl(ctx, cmd, argc, argl, ret); | |
6725682d SL |
86 | return 1; |
87 | } | |
88 | ||
89 | int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, | |
90 | char **ret) | |
91 | { | |
d8652be0 | 92 | return X509_LOOKUP_ctrl_ex(ctx, cmd, argc, argl, ret, NULL, NULL); |
6725682d SL |
93 | } |
94 | ||
d8652be0 MC |
95 | int X509_LOOKUP_by_subject_ex(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, |
96 | const X509_NAME *name, X509_OBJECT *ret, | |
b4250010 | 97 | OSSL_LIB_CTX *libctx, const char *propq) |
6725682d SL |
98 | { |
99 | if (ctx->skip | |
100 | || ctx->method == NULL | |
101 | || (ctx->method->get_by_subject == NULL | |
d8652be0 | 102 | && ctx->method->get_by_subject_ex == NULL)) |
6725682d | 103 | return 0; |
d8652be0 MC |
104 | if (ctx->method->get_by_subject_ex != NULL) |
105 | return ctx->method->get_by_subject_ex(ctx, type, name, ret, libctx, | |
106 | propq); | |
0f113f3e | 107 | else |
6725682d | 108 | return ctx->method->get_by_subject(ctx, type, name, ret); |
0f113f3e | 109 | } |
d02b48c6 | 110 | |
0946a198 | 111 | int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, |
8cc86b81 | 112 | const X509_NAME *name, X509_OBJECT *ret) |
0f113f3e | 113 | { |
d8652be0 | 114 | return X509_LOOKUP_by_subject_ex(ctx, type, name, ret, NULL, NULL); |
0f113f3e | 115 | } |
d02b48c6 | 116 | |
0946a198 | 117 | int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, |
8cc86b81 DDO |
118 | const X509_NAME *name, |
119 | const ASN1_INTEGER *serial, | |
0946a198 | 120 | X509_OBJECT *ret) |
0f113f3e MC |
121 | { |
122 | if ((ctx->method == NULL) || (ctx->method->get_by_issuer_serial == NULL)) | |
ba1a1c37 | 123 | return 0; |
0f113f3e MC |
124 | return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret); |
125 | } | |
d02b48c6 | 126 | |
0946a198 | 127 | int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, |
cfc5e0aa | 128 | const unsigned char *bytes, int len, |
0f113f3e MC |
129 | X509_OBJECT *ret) |
130 | { | |
131 | if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL)) | |
ba1a1c37 | 132 | return 0; |
0f113f3e MC |
133 | return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret); |
134 | } | |
d02b48c6 | 135 | |
0946a198 | 136 | int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, |
cfc5e0aa | 137 | const char *str, int len, X509_OBJECT *ret) |
0f113f3e MC |
138 | { |
139 | if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL)) | |
ba1a1c37 | 140 | return 0; |
0f113f3e MC |
141 | return ctx->method->get_by_alias(ctx, type, str, len, ret); |
142 | } | |
143 | ||
0124f32a MY |
144 | int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data) |
145 | { | |
146 | ctx->method_data = data; | |
147 | return 1; | |
148 | } | |
149 | ||
150 | void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx) | |
151 | { | |
152 | return ctx->method_data; | |
153 | } | |
154 | ||
155 | X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx) | |
156 | { | |
157 | return ctx->store_ctx; | |
158 | } | |
159 | ||
0f113f3e MC |
160 | static int x509_object_cmp(const X509_OBJECT *const *a, |
161 | const X509_OBJECT *const *b) | |
162 | { | |
163 | int ret; | |
164 | ||
165 | ret = ((*a)->type - (*b)->type); | |
166 | if (ret) | |
167 | return ret; | |
168 | switch ((*a)->type) { | |
169 | case X509_LU_X509: | |
170 | ret = X509_subject_name_cmp((*a)->data.x509, (*b)->data.x509); | |
171 | break; | |
172 | case X509_LU_CRL: | |
173 | ret = X509_CRL_cmp((*a)->data.crl, (*b)->data.crl); | |
174 | break; | |
f3b3d7f0 | 175 | case X509_LU_NONE: |
0f113f3e MC |
176 | /* abort(); */ |
177 | return 0; | |
178 | } | |
179 | return ret; | |
180 | } | |
d02b48c6 | 181 | |
6b691a5c | 182 | X509_STORE *X509_STORE_new(void) |
0f113f3e | 183 | { |
7fcdbd83 | 184 | X509_STORE *ret = OPENSSL_zalloc(sizeof(*ret)); |
0f113f3e | 185 | |
e077455e | 186 | if (ret == NULL) |
0f113f3e | 187 | return NULL; |
7fcdbd83 | 188 | if ((ret->objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL) { |
e077455e | 189 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
90945fa3 | 190 | goto err; |
7fcdbd83 | 191 | } |
0f113f3e | 192 | ret->cache = 1; |
7fcdbd83 | 193 | if ((ret->get_cert_methods = sk_X509_LOOKUP_new_null()) == NULL) { |
e077455e | 194 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
90945fa3 | 195 | goto err; |
7fcdbd83 | 196 | } |
0f113f3e | 197 | |
7fcdbd83 | 198 | if ((ret->param = X509_VERIFY_PARAM_new()) == NULL) { |
e077455e | 199 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
90945fa3 | 200 | goto err; |
7fcdbd83 F |
201 | } |
202 | if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data)) { | |
e077455e | 203 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
90945fa3 | 204 | goto err; |
7fcdbd83 | 205 | } |
0f113f3e | 206 | |
c001ce33 | 207 | ret->lock = CRYPTO_THREAD_lock_new(); |
7fcdbd83 | 208 | if (ret->lock == NULL) { |
e077455e | 209 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
c001ce33 | 210 | goto err; |
7fcdbd83 | 211 | } |
0f113f3e MC |
212 | ret->references = 1; |
213 | return ret; | |
c001ce33 | 214 | |
90945fa3 MC |
215 | err: |
216 | X509_VERIFY_PARAM_free(ret->param); | |
217 | sk_X509_OBJECT_free(ret->objs); | |
218 | sk_X509_LOOKUP_free(ret->get_cert_methods); | |
219 | OPENSSL_free(ret); | |
220 | return NULL; | |
0f113f3e | 221 | } |
d02b48c6 | 222 | |
c34e7876 | 223 | void X509_STORE_free(X509_STORE *xs) |
0f113f3e MC |
224 | { |
225 | int i; | |
226 | STACK_OF(X509_LOOKUP) *sk; | |
227 | X509_LOOKUP *lu; | |
d02b48c6 | 228 | |
c34e7876 | 229 | if (xs == NULL) |
e6e9170d | 230 | return; |
c34e7876 DDO |
231 | CRYPTO_DOWN_REF(&xs->references, &i, xs->lock); |
232 | REF_PRINT_COUNT("X509_STORE", xs); | |
0f113f3e MC |
233 | if (i > 0) |
234 | return; | |
f3f1cf84 | 235 | REF_ASSERT_ISNT(i < 0); |
bff9ce4d | 236 | |
c34e7876 | 237 | sk = xs->get_cert_methods; |
0f113f3e MC |
238 | for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) { |
239 | lu = sk_X509_LOOKUP_value(sk, i); | |
240 | X509_LOOKUP_shutdown(lu); | |
241 | X509_LOOKUP_free(lu); | |
242 | } | |
243 | sk_X509_LOOKUP_free(sk); | |
c34e7876 | 244 | sk_X509_OBJECT_pop_free(xs->objs, X509_OBJECT_free); |
0f113f3e | 245 | |
c34e7876 DDO |
246 | CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, xs, &xs->ex_data); |
247 | X509_VERIFY_PARAM_free(xs->param); | |
248 | CRYPTO_THREAD_lock_free(xs->lock); | |
249 | OPENSSL_free(xs); | |
0f113f3e | 250 | } |
d02b48c6 | 251 | |
c34e7876 | 252 | int X509_STORE_up_ref(X509_STORE *xs) |
c001ce33 AG |
253 | { |
254 | int i; | |
255 | ||
c34e7876 | 256 | if (CRYPTO_UP_REF(&xs->references, &i, xs->lock) <= 0) |
c001ce33 AG |
257 | return 0; |
258 | ||
c34e7876 | 259 | REF_PRINT_COUNT("X509_STORE", xs); |
c001ce33 | 260 | REF_ASSERT_ISNT(i < 2); |
c34e7876 | 261 | return i > 1 ? 1 : 0; |
c001ce33 AG |
262 | } |
263 | ||
c34e7876 | 264 | X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *xs, X509_LOOKUP_METHOD *m) |
0f113f3e MC |
265 | { |
266 | int i; | |
267 | STACK_OF(X509_LOOKUP) *sk; | |
268 | X509_LOOKUP *lu; | |
269 | ||
c34e7876 | 270 | sk = xs->get_cert_methods; |
0f113f3e MC |
271 | for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) { |
272 | lu = sk_X509_LOOKUP_value(sk, i); | |
273 | if (m == lu->method) { | |
274 | return lu; | |
275 | } | |
276 | } | |
277 | /* a new one */ | |
278 | lu = X509_LOOKUP_new(m); | |
7fcdbd83 | 279 | if (lu == NULL) { |
e077455e | 280 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
0f113f3e | 281 | return NULL; |
0f113f3e | 282 | } |
7fcdbd83 | 283 | |
c34e7876 DDO |
284 | lu->store_ctx = xs; |
285 | if (sk_X509_LOOKUP_push(xs->get_cert_methods, lu)) | |
7fcdbd83 | 286 | return lu; |
e077455e RL |
287 | /* sk_X509_LOOKUP_push() failed */ |
288 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); | |
7fcdbd83 F |
289 | X509_LOOKUP_free(lu); |
290 | return NULL; | |
0f113f3e | 291 | } |
d02b48c6 | 292 | |
c34e7876 DDO |
293 | /* Also fill the cache (ctx->store->objs) with all matching certificates. */ |
294 | X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *ctx, | |
0946a198 | 295 | X509_LOOKUP_TYPE type, |
8cc86b81 | 296 | const X509_NAME *name) |
f0e0fd51 | 297 | { |
6ddbb4cd | 298 | X509_OBJECT *ret = X509_OBJECT_new(); |
f0e0fd51 | 299 | |
6ddbb4cd | 300 | if (ret == NULL) |
f0e0fd51 | 301 | return NULL; |
c34e7876 | 302 | if (!X509_STORE_CTX_get_by_subject(ctx, type, name, ret)) { |
6ddbb4cd | 303 | X509_OBJECT_free(ret); |
f0e0fd51 RS |
304 | return NULL; |
305 | } | |
306 | return ret; | |
307 | } | |
308 | ||
0ce8271c | 309 | /* |
c34e7876 DDO |
310 | * May be called with |ret| == NULL just for the side effect of |
311 | * caching all certs matching the given subject DN in |ctx->store->objs|. | |
0ce8271c DDO |
312 | * Returns 1 if successful, |
313 | * 0 if not found or X509_LOOKUP_by_subject_ex() returns an error, | |
314 | * -1 on failure | |
315 | */ | |
c34e7876 | 316 | static int ossl_x509_store_ctx_get_by_subject(const X509_STORE_CTX *ctx, |
0ce8271c DDO |
317 | X509_LOOKUP_TYPE type, |
318 | const X509_NAME *name, | |
319 | X509_OBJECT *ret) | |
0f113f3e | 320 | { |
c34e7876 | 321 | X509_STORE *store = ctx->store; |
0f113f3e MC |
322 | X509_LOOKUP *lu; |
323 | X509_OBJECT stmp, *tmp; | |
324 | int i, j; | |
325 | ||
7a9abccd | 326 | if (store == NULL) |
1c705121 MC |
327 | return 0; |
328 | ||
b926f9de MC |
329 | stmp.type = X509_LU_NONE; |
330 | stmp.data.ptr = NULL; | |
331 | ||
80935bf5 | 332 | if (!x509_store_read_lock(store)) |
814999cb | 333 | return 0; |
80935bf5 MC |
334 | /* Should already be sorted...but just in case */ |
335 | if (!sk_X509_OBJECT_is_sorted(store->objs)) { | |
336 | X509_STORE_unlock(store); | |
337 | /* Take a write lock instead of a read lock */ | |
338 | X509_STORE_lock(store); | |
339 | /* | |
340 | * Another thread might have sorted it in the meantime. But if so, | |
341 | * sk_X509_OBJECT_sort() exits early. | |
342 | */ | |
343 | sk_X509_OBJECT_sort(store->objs); | |
344 | } | |
7a9abccd SL |
345 | tmp = X509_OBJECT_retrieve_by_subject(store->objs, type, name); |
346 | X509_STORE_unlock(store); | |
0f113f3e MC |
347 | |
348 | if (tmp == NULL || type == X509_LU_CRL) { | |
7a9abccd SL |
349 | for (i = 0; i < sk_X509_LOOKUP_num(store->get_cert_methods); i++) { |
350 | lu = sk_X509_LOOKUP_value(store->get_cert_methods, i); | |
0ce8271c DDO |
351 | if (lu->skip) |
352 | continue; | |
353 | if (lu->method == NULL) | |
354 | return -1; | |
355 | j = X509_LOOKUP_by_subject_ex(lu, type, name, &stmp, | |
c34e7876 | 356 | ctx->libctx, ctx->propq); |
0ce8271c | 357 | if (j != 0) { /* non-zero value is considered success here */ |
0f113f3e MC |
358 | tmp = &stmp; |
359 | break; | |
360 | } | |
361 | } | |
0f113f3e MC |
362 | if (tmp == NULL) |
363 | return 0; | |
364 | } | |
c70e2ec3 | 365 | if (!X509_OBJECT_up_ref_count(tmp)) |
0ce8271c | 366 | return -1; |
c70e2ec3 | 367 | |
0f113f3e MC |
368 | ret->type = tmp->type; |
369 | ret->data.ptr = tmp->data.ptr; | |
0f113f3e MC |
370 | return 1; |
371 | } | |
d02b48c6 | 372 | |
c34e7876 DDO |
373 | /* Also fill the cache |ctx->store->objs| with all matching certificates. */ |
374 | int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *ctx, | |
0ce8271c DDO |
375 | X509_LOOKUP_TYPE type, |
376 | const X509_NAME *name, X509_OBJECT *ret) | |
377 | { | |
c34e7876 | 378 | return ossl_x509_store_ctx_get_by_subject(ctx, type, name, ret) > 0; |
0ce8271c DDO |
379 | } |
380 | ||
c34e7876 DDO |
381 | static int x509_store_add(X509_STORE *store, void *x, int crl) |
382 | { | |
0f113f3e | 383 | X509_OBJECT *obj; |
c0452248 | 384 | int ret = 0, added = 0; |
0f113f3e MC |
385 | |
386 | if (x == NULL) | |
387 | return 0; | |
6ddbb4cd RS |
388 | obj = X509_OBJECT_new(); |
389 | if (obj == NULL) | |
0f113f3e | 390 | return 0; |
c0452248 RS |
391 | |
392 | if (crl) { | |
393 | obj->type = X509_LU_CRL; | |
394 | obj->data.crl = (X509_CRL *)x; | |
395 | } else { | |
396 | obj->type = X509_LU_X509; | |
397 | obj->data.x509 = (X509 *)x; | |
398 | } | |
c70e2ec3 BE |
399 | if (!X509_OBJECT_up_ref_count(obj)) { |
400 | obj->type = X509_LU_NONE; | |
401 | X509_OBJECT_free(obj); | |
402 | return 0; | |
403 | } | |
0f113f3e | 404 | |
814999cb JJ |
405 | if (!X509_STORE_lock(store)) { |
406 | obj->type = X509_LU_NONE; | |
407 | X509_OBJECT_free(obj); | |
408 | return 0; | |
409 | } | |
410 | ||
7a9abccd | 411 | if (X509_OBJECT_retrieve_match(store->objs, obj)) { |
c0452248 | 412 | ret = 1; |
68efafc5 | 413 | } else { |
7a9abccd | 414 | added = sk_X509_OBJECT_push(store->objs, obj); |
68efafc5 F |
415 | ret = added != 0; |
416 | } | |
7a9abccd | 417 | X509_STORE_unlock(store); |
0f113f3e | 418 | |
c0452248 | 419 | if (added == 0) /* obj not pushed */ |
68efafc5 | 420 | X509_OBJECT_free(obj); |
68efafc5 | 421 | |
0f113f3e MC |
422 | return ret; |
423 | } | |
2f043896 | 424 | |
c34e7876 | 425 | int X509_STORE_add_cert(X509_STORE *xs, X509 *x) |
0f113f3e | 426 | { |
c34e7876 | 427 | if (!x509_store_add(xs, x, 0)) { |
e077455e | 428 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
0f113f3e | 429 | return 0; |
68efafc5 | 430 | } |
c0452248 RS |
431 | return 1; |
432 | } | |
0f113f3e | 433 | |
c34e7876 | 434 | int X509_STORE_add_crl(X509_STORE *xs, X509_CRL *x) |
c0452248 | 435 | { |
c34e7876 | 436 | if (!x509_store_add(xs, x, 1)) { |
e077455e | 437 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
c0452248 RS |
438 | return 0; |
439 | } | |
440 | return 1; | |
0f113f3e | 441 | } |
2f043896 | 442 | |
c5ebfcab | 443 | int X509_OBJECT_up_ref_count(X509_OBJECT *a) |
0f113f3e MC |
444 | { |
445 | switch (a->type) { | |
f3b3d7f0 | 446 | case X509_LU_NONE: |
bca3f06b | 447 | break; |
0f113f3e | 448 | case X509_LU_X509: |
c5ebfcab | 449 | return X509_up_ref(a->data.x509); |
0f113f3e | 450 | case X509_LU_CRL: |
c5ebfcab | 451 | return X509_CRL_up_ref(a->data.crl); |
0f113f3e | 452 | } |
c5ebfcab | 453 | return 1; |
0f113f3e | 454 | } |
d02b48c6 | 455 | |
7d7da288 | 456 | X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a) |
f0e0fd51 | 457 | { |
6ddbb4cd RS |
458 | if (a == NULL || a->type != X509_LU_X509) |
459 | return NULL; | |
f0e0fd51 RS |
460 | return a->data.x509; |
461 | } | |
462 | ||
8cc86b81 | 463 | X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a) |
6ddbb4cd RS |
464 | { |
465 | if (a == NULL || a->type != X509_LU_CRL) | |
466 | return NULL; | |
467 | return a->data.crl; | |
468 | } | |
469 | ||
0946a198 | 470 | X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a) |
f0c58c32 CH |
471 | { |
472 | return a->type; | |
473 | } | |
474 | ||
3cb7c5cf | 475 | X509_OBJECT *X509_OBJECT_new(void) |
f0e0fd51 | 476 | { |
6ddbb4cd RS |
477 | X509_OBJECT *ret = OPENSSL_zalloc(sizeof(*ret)); |
478 | ||
e077455e | 479 | if (ret == NULL) |
6ddbb4cd | 480 | return NULL; |
ba1a1c37 | 481 | ret->type = X509_LU_NONE; |
6ddbb4cd | 482 | return ret; |
f0e0fd51 RS |
483 | } |
484 | ||
0124f32a | 485 | static void x509_object_free_internal(X509_OBJECT *a) |
0f113f3e | 486 | { |
f0e0fd51 | 487 | if (a == NULL) |
222561fe | 488 | return; |
0f113f3e | 489 | switch (a->type) { |
f3b3d7f0 | 490 | case X509_LU_NONE: |
bca3f06b | 491 | break; |
0f113f3e MC |
492 | case X509_LU_X509: |
493 | X509_free(a->data.x509); | |
494 | break; | |
495 | case X509_LU_CRL: | |
496 | X509_CRL_free(a->data.crl); | |
497 | break; | |
498 | } | |
0124f32a MY |
499 | } |
500 | ||
501 | int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj) | |
502 | { | |
503 | if (a == NULL || !X509_up_ref(obj)) | |
504 | return 0; | |
505 | ||
506 | x509_object_free_internal(a); | |
507 | a->type = X509_LU_X509; | |
508 | a->data.x509 = obj; | |
509 | return 1; | |
510 | } | |
511 | ||
512 | int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj) | |
513 | { | |
514 | if (a == NULL || !X509_CRL_up_ref(obj)) | |
515 | return 0; | |
516 | ||
517 | x509_object_free_internal(a); | |
518 | a->type = X509_LU_CRL; | |
519 | a->data.crl = obj; | |
520 | return 1; | |
521 | } | |
522 | ||
523 | void X509_OBJECT_free(X509_OBJECT *a) | |
524 | { | |
525 | x509_object_free_internal(a); | |
6ddbb4cd | 526 | OPENSSL_free(a); |
0f113f3e | 527 | } |
d02b48c6 | 528 | |
0ce8271c | 529 | /* Returns -1 if not found, but also on error */ |
0946a198 | 530 | static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, |
8cc86b81 | 531 | const X509_NAME *name, int *pnmatch) |
0f113f3e MC |
532 | { |
533 | X509_OBJECT stmp; | |
534 | X509 x509_s; | |
0f113f3e | 535 | X509_CRL crl_s; |
0f113f3e MC |
536 | |
537 | stmp.type = type; | |
538 | switch (type) { | |
539 | case X509_LU_X509: | |
540 | stmp.data.x509 = &x509_s; | |
8cc86b81 | 541 | x509_s.cert_info.subject = (X509_NAME *)name; /* won't modify it */ |
0f113f3e MC |
542 | break; |
543 | case X509_LU_CRL: | |
544 | stmp.data.crl = &crl_s; | |
8cc86b81 | 545 | crl_s.crl.issuer = (X509_NAME *)name; /* won't modify it */ |
0f113f3e | 546 | break; |
f3b3d7f0 | 547 | case X509_LU_NONE: |
0ce8271c | 548 | default: |
0f113f3e MC |
549 | /* abort(); */ |
550 | return -1; | |
551 | } | |
552 | ||
80935bf5 | 553 | /* Assumes h is locked for read if applicable */ |
0ce8271c | 554 | return sk_X509_OBJECT_find_all(h, &stmp, pnmatch); |
0f113f3e | 555 | } |
4d50a2b4 | 556 | |
80935bf5 | 557 | /* Assumes h is locked for read if applicable */ |
0946a198 | 558 | int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, |
8cc86b81 | 559 | const X509_NAME *name) |
0f113f3e MC |
560 | { |
561 | return x509_object_idx_cnt(h, type, name, NULL); | |
562 | } | |
563 | ||
80935bf5 | 564 | /* Assumes h is locked for read if applicable */ |
0f113f3e | 565 | X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, |
0946a198 | 566 | X509_LOOKUP_TYPE type, |
8cc86b81 | 567 | const X509_NAME *name) |
0f113f3e | 568 | { |
0ce8271c DDO |
569 | int idx = X509_OBJECT_idx_by_subject(h, type, name); |
570 | ||
0f113f3e MC |
571 | if (idx == -1) |
572 | return NULL; | |
573 | return sk_X509_OBJECT_value(h, idx); | |
574 | } | |
11262391 | 575 | |
c34e7876 | 576 | STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *xs) |
f0c58c32 | 577 | { |
c34e7876 | 578 | return xs->objs; |
f0c58c32 CH |
579 | } |
580 | ||
31b28ad9 DDO |
581 | STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *store) |
582 | { | |
583 | STACK_OF(X509) *sk; | |
584 | STACK_OF(X509_OBJECT) *objs; | |
585 | int i; | |
586 | ||
587 | if (store == NULL) { | |
9311d0c4 | 588 | ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER); |
31b28ad9 DDO |
589 | return NULL; |
590 | } | |
591 | if ((sk = sk_X509_new_null()) == NULL) | |
592 | return NULL; | |
814999cb JJ |
593 | if (!X509_STORE_lock(store)) |
594 | goto out_free; | |
595 | ||
3ef5b600 | 596 | sk_X509_OBJECT_sort(store->objs); |
31b28ad9 DDO |
597 | objs = X509_STORE_get0_objects(store); |
598 | for (i = 0; i < sk_X509_OBJECT_num(objs); i++) { | |
599 | X509 *cert = X509_OBJECT_get0_X509(sk_X509_OBJECT_value(objs, i)); | |
600 | ||
eeccc237 DDO |
601 | if (cert != NULL |
602 | && !X509_add_cert(sk, cert, X509_ADD_FLAG_UP_REF)) | |
603 | goto err; | |
31b28ad9 DDO |
604 | } |
605 | X509_STORE_unlock(store); | |
606 | return sk; | |
607 | ||
608 | err: | |
609 | X509_STORE_unlock(store); | |
814999cb | 610 | out_free: |
79b2a2f2 | 611 | OSSL_STACK_OF_X509_free(sk); |
31b28ad9 DDO |
612 | return NULL; |
613 | } | |
614 | ||
0ce8271c | 615 | /* Returns NULL on internal/fatal error, empty stack if not found */ |
8cc86b81 DDO |
616 | STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *ctx, |
617 | const X509_NAME *nm) | |
0f113f3e MC |
618 | { |
619 | int i, idx, cnt; | |
6ddbb4cd | 620 | STACK_OF(X509) *sk = NULL; |
0f113f3e MC |
621 | X509 *x; |
622 | X509_OBJECT *obj; | |
faa9dcd4 | 623 | X509_STORE *store = ctx->store; |
6ddbb4cd | 624 | |
7a9abccd | 625 | if (store == NULL) |
0ce8271c | 626 | return sk_X509_new_null(); |
1c705121 | 627 | |
814999cb JJ |
628 | if (!X509_STORE_lock(store)) |
629 | return NULL; | |
630 | ||
3ef5b600 | 631 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 632 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, nm, &cnt); |
0f113f3e MC |
633 | if (idx < 0) { |
634 | /* | |
635 | * Nothing found in cache: do lookup to possibly add new objects to | |
636 | * cache | |
637 | */ | |
6ddbb4cd RS |
638 | X509_OBJECT *xobj = X509_OBJECT_new(); |
639 | ||
7a9abccd | 640 | X509_STORE_unlock(store); |
6ddbb4cd RS |
641 | if (xobj == NULL) |
642 | return NULL; | |
0ce8271c DDO |
643 | i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_X509, nm, xobj); |
644 | if (i <= 0) { | |
6ddbb4cd | 645 | X509_OBJECT_free(xobj); |
0ce8271c | 646 | return i < 0 ? NULL : sk_X509_new_null(); |
0f113f3e | 647 | } |
6ddbb4cd | 648 | X509_OBJECT_free(xobj); |
814999cb JJ |
649 | if (!X509_STORE_lock(store)) |
650 | return NULL; | |
3ef5b600 | 651 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 652 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, nm, &cnt); |
0f113f3e | 653 | if (idx < 0) { |
0ce8271c DDO |
654 | sk = sk_X509_new_null(); |
655 | goto end; | |
0f113f3e MC |
656 | } |
657 | } | |
6ddbb4cd RS |
658 | |
659 | sk = sk_X509_new_null(); | |
0ce8271c DDO |
660 | if (sk == NULL) |
661 | goto end; | |
0f113f3e | 662 | for (i = 0; i < cnt; i++, idx++) { |
7a9abccd | 663 | obj = sk_X509_OBJECT_value(store->objs, idx); |
0f113f3e | 664 | x = obj->data.x509; |
eeccc237 | 665 | if (!X509_add_cert(sk, x, X509_ADD_FLAG_UP_REF)) { |
7a9abccd | 666 | X509_STORE_unlock(store); |
79b2a2f2 | 667 | OSSL_STACK_OF_X509_free(sk); |
0f113f3e MC |
668 | return NULL; |
669 | } | |
670 | } | |
0ce8271c | 671 | end: |
7a9abccd | 672 | X509_STORE_unlock(store); |
0f113f3e | 673 | return sk; |
0f113f3e | 674 | } |
4d50a2b4 | 675 | |
0ce8271c | 676 | /* Returns NULL on internal/fatal error, empty stack if not found */ |
8cc86b81 DDO |
677 | STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *ctx, |
678 | const X509_NAME *nm) | |
0f113f3e | 679 | { |
0ce8271c | 680 | int i = 1, idx, cnt; |
6ddbb4cd | 681 | STACK_OF(X509_CRL) *sk = sk_X509_CRL_new_null(); |
0f113f3e | 682 | X509_CRL *x; |
6ddbb4cd | 683 | X509_OBJECT *obj, *xobj = X509_OBJECT_new(); |
faa9dcd4 | 684 | X509_STORE *store = ctx->store; |
0f113f3e | 685 | |
6ddbb4cd | 686 | /* Always do lookup to possibly add new CRLs to cache */ |
1c705121 | 687 | if (sk == NULL |
0ce8271c DDO |
688 | || xobj == NULL |
689 | || (i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_CRL, | |
690 | nm, xobj)) < 0) { | |
6ddbb4cd | 691 | X509_OBJECT_free(xobj); |
0f113f3e MC |
692 | sk_X509_CRL_free(sk); |
693 | return NULL; | |
694 | } | |
6ddbb4cd | 695 | X509_OBJECT_free(xobj); |
0ce8271c DDO |
696 | if (i == 0) |
697 | return sk; | |
814999cb JJ |
698 | if (!X509_STORE_lock(store)) { |
699 | sk_X509_CRL_free(sk); | |
700 | return NULL; | |
701 | } | |
3ef5b600 | 702 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 703 | idx = x509_object_idx_cnt(store->objs, X509_LU_CRL, nm, &cnt); |
0f113f3e | 704 | if (idx < 0) { |
7a9abccd | 705 | X509_STORE_unlock(store); |
0ce8271c | 706 | return sk; |
0f113f3e MC |
707 | } |
708 | ||
709 | for (i = 0; i < cnt; i++, idx++) { | |
7a9abccd | 710 | obj = sk_X509_OBJECT_value(store->objs, idx); |
0f113f3e | 711 | x = obj->data.crl; |
c70e2ec3 BE |
712 | if (!X509_CRL_up_ref(x)) { |
713 | X509_STORE_unlock(store); | |
714 | sk_X509_CRL_pop_free(sk, X509_CRL_free); | |
715 | return NULL; | |
716 | } | |
0f113f3e | 717 | if (!sk_X509_CRL_push(sk, x)) { |
7a9abccd | 718 | X509_STORE_unlock(store); |
0f113f3e MC |
719 | X509_CRL_free(x); |
720 | sk_X509_CRL_pop_free(sk, X509_CRL_free); | |
721 | return NULL; | |
722 | } | |
723 | } | |
7a9abccd | 724 | X509_STORE_unlock(store); |
0f113f3e MC |
725 | return sk; |
726 | } | |
727 | ||
728 | X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, | |
729 | X509_OBJECT *x) | |
730 | { | |
5b37fef0 | 731 | int idx, i, num; |
0f113f3e | 732 | X509_OBJECT *obj; |
5b37fef0 | 733 | |
0f113f3e | 734 | idx = sk_X509_OBJECT_find(h, x); |
5b37fef0 | 735 | if (idx < 0) |
0f113f3e MC |
736 | return NULL; |
737 | if ((x->type != X509_LU_X509) && (x->type != X509_LU_CRL)) | |
738 | return sk_X509_OBJECT_value(h, idx); | |
5b37fef0 | 739 | for (i = idx, num = sk_X509_OBJECT_num(h); i < num; i++) { |
0f113f3e | 740 | obj = sk_X509_OBJECT_value(h, i); |
5b37fef0 AP |
741 | if (x509_object_cmp((const X509_OBJECT **)&obj, |
742 | (const X509_OBJECT **)&x)) | |
0f113f3e MC |
743 | return NULL; |
744 | if (x->type == X509_LU_X509) { | |
745 | if (!X509_cmp(obj->data.x509, x->data.x509)) | |
746 | return obj; | |
747 | } else if (x->type == X509_LU_CRL) { | |
f2a04587 | 748 | if (X509_CRL_match(obj->data.crl, x->data.crl) == 0) |
0f113f3e | 749 | return obj; |
c34e7876 | 750 | } else { |
0f113f3e | 751 | return obj; |
c34e7876 | 752 | } |
0f113f3e MC |
753 | } |
754 | return NULL; | |
755 | } | |
d02b48c6 | 756 | |
1d97c843 | 757 | /*- |
f1923a21 DDO |
758 | * Try to get issuer cert from |ctx->store| matching the subject name of |x|. |
759 | * Prefer the first non-expired one, else take the most recently expired one. | |
2f043896 DSH |
760 | * |
761 | * Return values are: | |
762 | * 1 lookup successful. | |
763 | * 0 certificate not found. | |
764 | * -1 some other error. | |
765 | */ | |
2f043896 | 766 | int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x) |
0f113f3e | 767 | { |
8cc86b81 | 768 | const X509_NAME *xn; |
6ddbb4cd | 769 | X509_OBJECT *obj = X509_OBJECT_new(), *pobj = NULL; |
faa9dcd4 | 770 | X509_STORE *store = ctx->store; |
5fd7eb5c | 771 | int i, ok, idx, ret, nmatch = 0; |
f0e0fd51 | 772 | |
6ddbb4cd RS |
773 | if (obj == NULL) |
774 | return -1; | |
0f113f3e MC |
775 | *issuer = NULL; |
776 | xn = X509_get_issuer_name(x); | |
0ce8271c | 777 | ok = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_X509, xn, obj); |
ba1a1c37 | 778 | if (ok != 1) { |
6ddbb4cd | 779 | X509_OBJECT_free(obj); |
0ce8271c | 780 | return ok; |
0f113f3e | 781 | } |
f1923a21 | 782 | /* If certificate matches and is currently valid all OK */ |
6ddbb4cd | 783 | if (ctx->check_issued(ctx, x, obj->data.x509)) { |
4669015d | 784 | if (ossl_x509_check_cert_time(ctx, obj->data.x509, -1)) { |
6ddbb4cd | 785 | *issuer = obj->data.x509; |
d6bf19a4 DDO |
786 | /* |*issuer| has taken over the cert reference from |obj| */ |
787 | obj->type = X509_LU_NONE; | |
6ddbb4cd | 788 | X509_OBJECT_free(obj); |
d6bf19a4 | 789 | return 1; |
0f113f3e MC |
790 | } |
791 | } | |
6ddbb4cd | 792 | X509_OBJECT_free(obj); |
0f113f3e | 793 | |
f1923a21 DDO |
794 | /* |
795 | * Due to limitations of the API this can only retrieve a single cert. | |
796 | * However it will fill the cache with all matching certificates, | |
797 | * so we can examine the cache for all matches. | |
798 | */ | |
7a9abccd | 799 | if (store == NULL) |
1c705121 MC |
800 | return 0; |
801 | ||
f1923a21 | 802 | /* Find index of first currently valid cert accepted by 'check_issued' */ |
0f113f3e | 803 | ret = 0; |
814999cb JJ |
804 | if (!X509_STORE_lock(store)) |
805 | return 0; | |
806 | ||
3ef5b600 | 807 | sk_X509_OBJECT_sort(store->objs); |
5fd7eb5c | 808 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, xn, &nmatch); |
f1923a21 | 809 | if (idx != -1) { /* should be true as we've had at least one match */ |
0f113f3e | 810 | /* Look through all matching certs for suitable issuer */ |
5fd7eb5c | 811 | for (i = idx; i < idx + nmatch; i++) { |
7a9abccd | 812 | pobj = sk_X509_OBJECT_value(store->objs, i); |
0f113f3e MC |
813 | /* See if we've run past the matches */ |
814 | if (pobj->type != X509_LU_X509) | |
815 | break; | |
0f113f3e | 816 | if (ctx->check_issued(ctx, x, pobj->data.x509)) { |
0f113f3e | 817 | ret = 1; |
f1923a21 | 818 | /* If times check fine, exit with match, else keep looking. */ |
4669015d | 819 | if (ossl_x509_check_cert_time(ctx, pobj->data.x509, -1)) { |
f1923a21 DDO |
820 | *issuer = pobj->data.x509; |
821 | break; | |
822 | } | |
0f113f3e | 823 | /* |
f1923a21 DDO |
824 | * Leave the so far most recently expired match in *issuer |
825 | * so we return nearest match if no certificate time is OK. | |
0f113f3e | 826 | */ |
f1923a21 DDO |
827 | if (*issuer == NULL |
828 | || ASN1_TIME_compare(X509_get0_notAfter(pobj->data.x509), | |
829 | X509_get0_notAfter(*issuer)) > 0) | |
830 | *issuer = pobj->data.x509; | |
0f113f3e MC |
831 | } |
832 | } | |
833 | } | |
f1923a21 | 834 | if (*issuer != NULL && !X509_up_ref(*issuer)) { |
c70e2ec3 BE |
835 | *issuer = NULL; |
836 | ret = -1; | |
837 | } | |
7a9abccd | 838 | X509_STORE_unlock(store); |
0f113f3e MC |
839 | return ret; |
840 | } | |
d02b48c6 | 841 | |
c34e7876 | 842 | int X509_STORE_set_flags(X509_STORE *xs, unsigned long flags) |
0f113f3e | 843 | { |
c34e7876 | 844 | return X509_VERIFY_PARAM_set_flags(xs->param, flags); |
0f113f3e | 845 | } |
5d7c222d | 846 | |
c34e7876 | 847 | int X509_STORE_set_depth(X509_STORE *xs, int depth) |
0f113f3e | 848 | { |
c34e7876 | 849 | X509_VERIFY_PARAM_set_depth(xs->param, depth); |
0f113f3e MC |
850 | return 1; |
851 | } | |
bdee69f7 | 852 | |
c34e7876 | 853 | int X509_STORE_set_purpose(X509_STORE *xs, int purpose) |
0f113f3e | 854 | { |
c34e7876 | 855 | return X509_VERIFY_PARAM_set_purpose(xs->param, purpose); |
0f113f3e | 856 | } |
926a56bf | 857 | |
c34e7876 | 858 | int X509_STORE_set_trust(X509_STORE *xs, int trust) |
0f113f3e | 859 | { |
c34e7876 | 860 | return X509_VERIFY_PARAM_set_trust(xs->param, trust); |
0f113f3e | 861 | } |
5d7c222d | 862 | |
c34e7876 | 863 | int X509_STORE_set1_param(X509_STORE *xs, const X509_VERIFY_PARAM *param) |
0f113f3e | 864 | { |
c34e7876 | 865 | return X509_VERIFY_PARAM_set1(xs->param, param); |
0f113f3e | 866 | } |
926a56bf | 867 | |
c34e7876 | 868 | X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *xs) |
f0c58c32 | 869 | { |
c34e7876 | 870 | return xs->param; |
f0c58c32 CH |
871 | } |
872 | ||
c34e7876 | 873 | void X509_STORE_set_verify(X509_STORE *xs, X509_STORE_CTX_verify_fn verify) |
1060a50b | 874 | { |
c34e7876 | 875 | xs->verify = verify; |
1060a50b RL |
876 | } |
877 | ||
c34e7876 | 878 | X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *xs) |
1060a50b | 879 | { |
c34e7876 | 880 | return xs->verify; |
1060a50b RL |
881 | } |
882 | ||
c34e7876 | 883 | void X509_STORE_set_verify_cb(X509_STORE *xs, |
1060a50b | 884 | X509_STORE_CTX_verify_cb verify_cb) |
0f113f3e | 885 | { |
c34e7876 | 886 | xs->verify_cb = verify_cb; |
0f113f3e | 887 | } |
a5b37fca | 888 | |
c34e7876 | 889 | X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *xs) |
7cafbb4b | 890 | { |
c34e7876 | 891 | return xs->verify_cb; |
1060a50b RL |
892 | } |
893 | ||
c34e7876 | 894 | void X509_STORE_set_get_issuer(X509_STORE *xs, |
1060a50b RL |
895 | X509_STORE_CTX_get_issuer_fn get_issuer) |
896 | { | |
c34e7876 | 897 | xs->get_issuer = get_issuer; |
1060a50b RL |
898 | } |
899 | ||
c34e7876 | 900 | X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *xs) |
1060a50b | 901 | { |
c34e7876 | 902 | return xs->get_issuer; |
1060a50b RL |
903 | } |
904 | ||
c34e7876 | 905 | void X509_STORE_set_check_issued(X509_STORE *xs, |
1060a50b RL |
906 | X509_STORE_CTX_check_issued_fn check_issued) |
907 | { | |
c34e7876 | 908 | xs->check_issued = check_issued; |
1060a50b RL |
909 | } |
910 | ||
c34e7876 | 911 | X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *xs) |
1060a50b | 912 | { |
c34e7876 | 913 | return xs->check_issued; |
1060a50b RL |
914 | } |
915 | ||
c34e7876 DDO |
916 | void X509_STORE_set_check_revocation(X509_STORE *xs, |
917 | X509_STORE_CTX_check_revocation_fn cb) | |
1060a50b | 918 | { |
c34e7876 | 919 | xs->check_revocation = cb; |
1060a50b RL |
920 | } |
921 | ||
c34e7876 | 922 | X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(const X509_STORE *xs) |
1060a50b | 923 | { |
c34e7876 | 924 | return xs->check_revocation; |
1060a50b RL |
925 | } |
926 | ||
c34e7876 | 927 | void X509_STORE_set_get_crl(X509_STORE *xs, |
1060a50b RL |
928 | X509_STORE_CTX_get_crl_fn get_crl) |
929 | { | |
c34e7876 | 930 | xs->get_crl = get_crl; |
1060a50b RL |
931 | } |
932 | ||
c34e7876 | 933 | X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *xs) |
1060a50b | 934 | { |
c34e7876 | 935 | return xs->get_crl; |
1060a50b RL |
936 | } |
937 | ||
c34e7876 | 938 | void X509_STORE_set_check_crl(X509_STORE *xs, |
1060a50b RL |
939 | X509_STORE_CTX_check_crl_fn check_crl) |
940 | { | |
c34e7876 | 941 | xs->check_crl = check_crl; |
1060a50b RL |
942 | } |
943 | ||
c34e7876 | 944 | X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *xs) |
1060a50b | 945 | { |
c34e7876 | 946 | return xs->check_crl; |
1060a50b RL |
947 | } |
948 | ||
c34e7876 | 949 | void X509_STORE_set_cert_crl(X509_STORE *xs, |
1060a50b RL |
950 | X509_STORE_CTX_cert_crl_fn cert_crl) |
951 | { | |
c34e7876 | 952 | xs->cert_crl = cert_crl; |
1060a50b RL |
953 | } |
954 | ||
c34e7876 | 955 | X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *xs) |
1060a50b | 956 | { |
c34e7876 | 957 | return xs->cert_crl; |
1060a50b RL |
958 | } |
959 | ||
c34e7876 | 960 | void X509_STORE_set_check_policy(X509_STORE *xs, |
0a5fe2eb RL |
961 | X509_STORE_CTX_check_policy_fn check_policy) |
962 | { | |
c34e7876 | 963 | xs->check_policy = check_policy; |
0a5fe2eb RL |
964 | } |
965 | ||
c34e7876 | 966 | X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *xs) |
0a5fe2eb | 967 | { |
c34e7876 | 968 | return xs->check_policy; |
0a5fe2eb RL |
969 | } |
970 | ||
c34e7876 | 971 | void X509_STORE_set_lookup_certs(X509_STORE *xs, |
1060a50b RL |
972 | X509_STORE_CTX_lookup_certs_fn lookup_certs) |
973 | { | |
c34e7876 | 974 | xs->lookup_certs = lookup_certs; |
1060a50b RL |
975 | } |
976 | ||
c34e7876 | 977 | X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *xs) |
1060a50b | 978 | { |
c34e7876 | 979 | return xs->lookup_certs; |
1060a50b RL |
980 | } |
981 | ||
c34e7876 | 982 | void X509_STORE_set_lookup_crls(X509_STORE *xs, |
1060a50b RL |
983 | X509_STORE_CTX_lookup_crls_fn lookup_crls) |
984 | { | |
c34e7876 | 985 | xs->lookup_crls = lookup_crls; |
1060a50b RL |
986 | } |
987 | ||
c34e7876 | 988 | X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *xs) |
1060a50b | 989 | { |
c34e7876 | 990 | return xs->lookup_crls; |
1060a50b RL |
991 | } |
992 | ||
c34e7876 DDO |
993 | void X509_STORE_set_cleanup(X509_STORE *xs, |
994 | X509_STORE_CTX_cleanup_fn cleanup) | |
1060a50b | 995 | { |
c34e7876 | 996 | xs->cleanup = cleanup; |
7cafbb4b MC |
997 | } |
998 | ||
c34e7876 | 999 | X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *xs) |
0f113f3e | 1000 | { |
c34e7876 | 1001 | return xs->cleanup; |
0f113f3e | 1002 | } |
2c340864 | 1003 | |
c34e7876 | 1004 | int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data) |
3aec886e | 1005 | { |
c34e7876 | 1006 | return CRYPTO_set_ex_data(&xs->ex_data, idx, data); |
3aec886e KY |
1007 | } |
1008 | ||
c34e7876 | 1009 | void *X509_STORE_get_ex_data(const X509_STORE *xs, int idx) |
3aec886e | 1010 | { |
c34e7876 | 1011 | return CRYPTO_get_ex_data(&xs->ex_data, idx); |
3aec886e KY |
1012 | } |
1013 | ||
8cc86b81 | 1014 | X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx) |
0f113f3e | 1015 | { |
faa9dcd4 | 1016 | return ctx->store; |
0f113f3e | 1017 | } |