]>
Commit | Line | Data |
---|---|---|
b1322259 | 1 | /* |
b6461792 | 2 | * Copyright 1995-2024 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 | } |
a903a132 P |
212 | |
213 | if (!CRYPTO_NEW_REF(&ret->references, 1)) | |
214 | goto err; | |
0f113f3e | 215 | return ret; |
c001ce33 | 216 | |
90945fa3 MC |
217 | err: |
218 | X509_VERIFY_PARAM_free(ret->param); | |
219 | sk_X509_OBJECT_free(ret->objs); | |
220 | sk_X509_LOOKUP_free(ret->get_cert_methods); | |
a903a132 | 221 | CRYPTO_THREAD_lock_free(ret->lock); |
90945fa3 MC |
222 | OPENSSL_free(ret); |
223 | return NULL; | |
0f113f3e | 224 | } |
d02b48c6 | 225 | |
c34e7876 | 226 | void X509_STORE_free(X509_STORE *xs) |
0f113f3e MC |
227 | { |
228 | int i; | |
229 | STACK_OF(X509_LOOKUP) *sk; | |
230 | X509_LOOKUP *lu; | |
d02b48c6 | 231 | |
c34e7876 | 232 | if (xs == NULL) |
e6e9170d | 233 | return; |
a903a132 | 234 | CRYPTO_DOWN_REF(&xs->references, &i); |
c34e7876 | 235 | REF_PRINT_COUNT("X509_STORE", xs); |
0f113f3e MC |
236 | if (i > 0) |
237 | return; | |
f3f1cf84 | 238 | REF_ASSERT_ISNT(i < 0); |
bff9ce4d | 239 | |
c34e7876 | 240 | sk = xs->get_cert_methods; |
0f113f3e MC |
241 | for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) { |
242 | lu = sk_X509_LOOKUP_value(sk, i); | |
243 | X509_LOOKUP_shutdown(lu); | |
244 | X509_LOOKUP_free(lu); | |
245 | } | |
246 | sk_X509_LOOKUP_free(sk); | |
c34e7876 | 247 | sk_X509_OBJECT_pop_free(xs->objs, X509_OBJECT_free); |
0f113f3e | 248 | |
c34e7876 DDO |
249 | CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, xs, &xs->ex_data); |
250 | X509_VERIFY_PARAM_free(xs->param); | |
251 | CRYPTO_THREAD_lock_free(xs->lock); | |
a903a132 | 252 | CRYPTO_FREE_REF(&xs->references); |
c34e7876 | 253 | OPENSSL_free(xs); |
0f113f3e | 254 | } |
d02b48c6 | 255 | |
c34e7876 | 256 | int X509_STORE_up_ref(X509_STORE *xs) |
c001ce33 AG |
257 | { |
258 | int i; | |
259 | ||
a903a132 | 260 | if (CRYPTO_UP_REF(&xs->references, &i) <= 0) |
c001ce33 AG |
261 | return 0; |
262 | ||
c34e7876 | 263 | REF_PRINT_COUNT("X509_STORE", xs); |
c001ce33 | 264 | REF_ASSERT_ISNT(i < 2); |
c34e7876 | 265 | return i > 1 ? 1 : 0; |
c001ce33 AG |
266 | } |
267 | ||
c34e7876 | 268 | X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *xs, X509_LOOKUP_METHOD *m) |
0f113f3e MC |
269 | { |
270 | int i; | |
271 | STACK_OF(X509_LOOKUP) *sk; | |
272 | X509_LOOKUP *lu; | |
273 | ||
c34e7876 | 274 | sk = xs->get_cert_methods; |
0f113f3e MC |
275 | for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) { |
276 | lu = sk_X509_LOOKUP_value(sk, i); | |
277 | if (m == lu->method) { | |
278 | return lu; | |
279 | } | |
280 | } | |
281 | /* a new one */ | |
282 | lu = X509_LOOKUP_new(m); | |
7fcdbd83 | 283 | if (lu == NULL) { |
e077455e | 284 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
0f113f3e | 285 | return NULL; |
0f113f3e | 286 | } |
7fcdbd83 | 287 | |
c34e7876 DDO |
288 | lu->store_ctx = xs; |
289 | if (sk_X509_LOOKUP_push(xs->get_cert_methods, lu)) | |
7fcdbd83 | 290 | return lu; |
e077455e RL |
291 | /* sk_X509_LOOKUP_push() failed */ |
292 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); | |
7fcdbd83 F |
293 | X509_LOOKUP_free(lu); |
294 | return NULL; | |
0f113f3e | 295 | } |
d02b48c6 | 296 | |
c34e7876 DDO |
297 | /* Also fill the cache (ctx->store->objs) with all matching certificates. */ |
298 | X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *ctx, | |
0946a198 | 299 | X509_LOOKUP_TYPE type, |
8cc86b81 | 300 | const X509_NAME *name) |
f0e0fd51 | 301 | { |
6ddbb4cd | 302 | X509_OBJECT *ret = X509_OBJECT_new(); |
f0e0fd51 | 303 | |
6ddbb4cd | 304 | if (ret == NULL) |
f0e0fd51 | 305 | return NULL; |
c34e7876 | 306 | if (!X509_STORE_CTX_get_by_subject(ctx, type, name, ret)) { |
6ddbb4cd | 307 | X509_OBJECT_free(ret); |
f0e0fd51 RS |
308 | return NULL; |
309 | } | |
310 | return ret; | |
311 | } | |
312 | ||
0ce8271c | 313 | /* |
c34e7876 DDO |
314 | * May be called with |ret| == NULL just for the side effect of |
315 | * caching all certs matching the given subject DN in |ctx->store->objs|. | |
0ce8271c DDO |
316 | * Returns 1 if successful, |
317 | * 0 if not found or X509_LOOKUP_by_subject_ex() returns an error, | |
318 | * -1 on failure | |
319 | */ | |
c34e7876 | 320 | static int ossl_x509_store_ctx_get_by_subject(const X509_STORE_CTX *ctx, |
0ce8271c DDO |
321 | X509_LOOKUP_TYPE type, |
322 | const X509_NAME *name, | |
323 | X509_OBJECT *ret) | |
0f113f3e | 324 | { |
c34e7876 | 325 | X509_STORE *store = ctx->store; |
0f113f3e MC |
326 | X509_LOOKUP *lu; |
327 | X509_OBJECT stmp, *tmp; | |
328 | int i, j; | |
329 | ||
7a9abccd | 330 | if (store == NULL) |
1c705121 MC |
331 | return 0; |
332 | ||
b926f9de MC |
333 | stmp.type = X509_LU_NONE; |
334 | stmp.data.ptr = NULL; | |
335 | ||
80935bf5 | 336 | if (!x509_store_read_lock(store)) |
814999cb | 337 | return 0; |
80935bf5 MC |
338 | /* Should already be sorted...but just in case */ |
339 | if (!sk_X509_OBJECT_is_sorted(store->objs)) { | |
340 | X509_STORE_unlock(store); | |
341 | /* Take a write lock instead of a read lock */ | |
6404d064 TM |
342 | if (!X509_STORE_lock(store)) |
343 | return 0; | |
80935bf5 MC |
344 | /* |
345 | * Another thread might have sorted it in the meantime. But if so, | |
346 | * sk_X509_OBJECT_sort() exits early. | |
347 | */ | |
348 | sk_X509_OBJECT_sort(store->objs); | |
349 | } | |
7a9abccd SL |
350 | tmp = X509_OBJECT_retrieve_by_subject(store->objs, type, name); |
351 | X509_STORE_unlock(store); | |
0f113f3e MC |
352 | |
353 | if (tmp == NULL || type == X509_LU_CRL) { | |
7a9abccd SL |
354 | for (i = 0; i < sk_X509_LOOKUP_num(store->get_cert_methods); i++) { |
355 | lu = sk_X509_LOOKUP_value(store->get_cert_methods, i); | |
0ce8271c DDO |
356 | if (lu->skip) |
357 | continue; | |
358 | if (lu->method == NULL) | |
359 | return -1; | |
360 | j = X509_LOOKUP_by_subject_ex(lu, type, name, &stmp, | |
c34e7876 | 361 | ctx->libctx, ctx->propq); |
0ce8271c | 362 | if (j != 0) { /* non-zero value is considered success here */ |
0f113f3e MC |
363 | tmp = &stmp; |
364 | break; | |
365 | } | |
366 | } | |
0f113f3e MC |
367 | if (tmp == NULL) |
368 | return 0; | |
369 | } | |
c70e2ec3 | 370 | if (!X509_OBJECT_up_ref_count(tmp)) |
0ce8271c | 371 | return -1; |
c70e2ec3 | 372 | |
0f113f3e MC |
373 | ret->type = tmp->type; |
374 | ret->data.ptr = tmp->data.ptr; | |
0f113f3e MC |
375 | return 1; |
376 | } | |
d02b48c6 | 377 | |
c34e7876 DDO |
378 | /* Also fill the cache |ctx->store->objs| with all matching certificates. */ |
379 | int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *ctx, | |
0ce8271c DDO |
380 | X509_LOOKUP_TYPE type, |
381 | const X509_NAME *name, X509_OBJECT *ret) | |
382 | { | |
c34e7876 | 383 | return ossl_x509_store_ctx_get_by_subject(ctx, type, name, ret) > 0; |
0ce8271c DDO |
384 | } |
385 | ||
c34e7876 DDO |
386 | static int x509_store_add(X509_STORE *store, void *x, int crl) |
387 | { | |
0f113f3e | 388 | X509_OBJECT *obj; |
c0452248 | 389 | int ret = 0, added = 0; |
0f113f3e MC |
390 | |
391 | if (x == NULL) | |
392 | return 0; | |
6ddbb4cd RS |
393 | obj = X509_OBJECT_new(); |
394 | if (obj == NULL) | |
0f113f3e | 395 | return 0; |
c0452248 RS |
396 | |
397 | if (crl) { | |
398 | obj->type = X509_LU_CRL; | |
399 | obj->data.crl = (X509_CRL *)x; | |
400 | } else { | |
401 | obj->type = X509_LU_X509; | |
402 | obj->data.x509 = (X509 *)x; | |
403 | } | |
c70e2ec3 BE |
404 | if (!X509_OBJECT_up_ref_count(obj)) { |
405 | obj->type = X509_LU_NONE; | |
406 | X509_OBJECT_free(obj); | |
407 | return 0; | |
408 | } | |
0f113f3e | 409 | |
814999cb JJ |
410 | if (!X509_STORE_lock(store)) { |
411 | obj->type = X509_LU_NONE; | |
412 | X509_OBJECT_free(obj); | |
413 | return 0; | |
414 | } | |
415 | ||
7a9abccd | 416 | if (X509_OBJECT_retrieve_match(store->objs, obj)) { |
c0452248 | 417 | ret = 1; |
68efafc5 | 418 | } else { |
7a9abccd | 419 | added = sk_X509_OBJECT_push(store->objs, obj); |
68efafc5 F |
420 | ret = added != 0; |
421 | } | |
7a9abccd | 422 | X509_STORE_unlock(store); |
0f113f3e | 423 | |
c0452248 | 424 | if (added == 0) /* obj not pushed */ |
68efafc5 | 425 | X509_OBJECT_free(obj); |
68efafc5 | 426 | |
0f113f3e MC |
427 | return ret; |
428 | } | |
2f043896 | 429 | |
c34e7876 | 430 | int X509_STORE_add_cert(X509_STORE *xs, X509 *x) |
0f113f3e | 431 | { |
c34e7876 | 432 | if (!x509_store_add(xs, x, 0)) { |
e077455e | 433 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
0f113f3e | 434 | return 0; |
68efafc5 | 435 | } |
c0452248 RS |
436 | return 1; |
437 | } | |
0f113f3e | 438 | |
c34e7876 | 439 | int X509_STORE_add_crl(X509_STORE *xs, X509_CRL *x) |
c0452248 | 440 | { |
c34e7876 | 441 | if (!x509_store_add(xs, x, 1)) { |
e077455e | 442 | ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB); |
c0452248 RS |
443 | return 0; |
444 | } | |
445 | return 1; | |
0f113f3e | 446 | } |
2f043896 | 447 | |
c5ebfcab | 448 | int X509_OBJECT_up_ref_count(X509_OBJECT *a) |
0f113f3e MC |
449 | { |
450 | switch (a->type) { | |
f3b3d7f0 | 451 | case X509_LU_NONE: |
bca3f06b | 452 | break; |
0f113f3e | 453 | case X509_LU_X509: |
c5ebfcab | 454 | return X509_up_ref(a->data.x509); |
0f113f3e | 455 | case X509_LU_CRL: |
c5ebfcab | 456 | return X509_CRL_up_ref(a->data.crl); |
0f113f3e | 457 | } |
c5ebfcab | 458 | return 1; |
0f113f3e | 459 | } |
d02b48c6 | 460 | |
7d7da288 | 461 | X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a) |
f0e0fd51 | 462 | { |
6ddbb4cd RS |
463 | if (a == NULL || a->type != X509_LU_X509) |
464 | return NULL; | |
f0e0fd51 RS |
465 | return a->data.x509; |
466 | } | |
467 | ||
8cc86b81 | 468 | X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a) |
6ddbb4cd RS |
469 | { |
470 | if (a == NULL || a->type != X509_LU_CRL) | |
471 | return NULL; | |
472 | return a->data.crl; | |
473 | } | |
474 | ||
0946a198 | 475 | X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a) |
f0c58c32 CH |
476 | { |
477 | return a->type; | |
478 | } | |
479 | ||
3cb7c5cf | 480 | X509_OBJECT *X509_OBJECT_new(void) |
f0e0fd51 | 481 | { |
6ddbb4cd RS |
482 | X509_OBJECT *ret = OPENSSL_zalloc(sizeof(*ret)); |
483 | ||
e077455e | 484 | if (ret == NULL) |
6ddbb4cd | 485 | return NULL; |
ba1a1c37 | 486 | ret->type = X509_LU_NONE; |
6ddbb4cd | 487 | return ret; |
f0e0fd51 RS |
488 | } |
489 | ||
0124f32a | 490 | static void x509_object_free_internal(X509_OBJECT *a) |
0f113f3e | 491 | { |
f0e0fd51 | 492 | if (a == NULL) |
222561fe | 493 | return; |
0f113f3e | 494 | switch (a->type) { |
f3b3d7f0 | 495 | case X509_LU_NONE: |
bca3f06b | 496 | break; |
0f113f3e MC |
497 | case X509_LU_X509: |
498 | X509_free(a->data.x509); | |
499 | break; | |
500 | case X509_LU_CRL: | |
501 | X509_CRL_free(a->data.crl); | |
502 | break; | |
503 | } | |
0124f32a MY |
504 | } |
505 | ||
506 | int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj) | |
507 | { | |
508 | if (a == NULL || !X509_up_ref(obj)) | |
509 | return 0; | |
510 | ||
511 | x509_object_free_internal(a); | |
512 | a->type = X509_LU_X509; | |
513 | a->data.x509 = obj; | |
514 | return 1; | |
515 | } | |
516 | ||
517 | int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj) | |
518 | { | |
519 | if (a == NULL || !X509_CRL_up_ref(obj)) | |
520 | return 0; | |
521 | ||
522 | x509_object_free_internal(a); | |
523 | a->type = X509_LU_CRL; | |
524 | a->data.crl = obj; | |
525 | return 1; | |
526 | } | |
527 | ||
528 | void X509_OBJECT_free(X509_OBJECT *a) | |
529 | { | |
530 | x509_object_free_internal(a); | |
6ddbb4cd | 531 | OPENSSL_free(a); |
0f113f3e | 532 | } |
d02b48c6 | 533 | |
0ce8271c | 534 | /* Returns -1 if not found, but also on error */ |
0946a198 | 535 | static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, |
8cc86b81 | 536 | const X509_NAME *name, int *pnmatch) |
0f113f3e MC |
537 | { |
538 | X509_OBJECT stmp; | |
539 | X509 x509_s; | |
0f113f3e | 540 | X509_CRL crl_s; |
0f113f3e MC |
541 | |
542 | stmp.type = type; | |
543 | switch (type) { | |
544 | case X509_LU_X509: | |
545 | stmp.data.x509 = &x509_s; | |
8cc86b81 | 546 | x509_s.cert_info.subject = (X509_NAME *)name; /* won't modify it */ |
0f113f3e MC |
547 | break; |
548 | case X509_LU_CRL: | |
549 | stmp.data.crl = &crl_s; | |
8cc86b81 | 550 | crl_s.crl.issuer = (X509_NAME *)name; /* won't modify it */ |
0f113f3e | 551 | break; |
f3b3d7f0 | 552 | case X509_LU_NONE: |
0ce8271c | 553 | default: |
0f113f3e MC |
554 | /* abort(); */ |
555 | return -1; | |
556 | } | |
557 | ||
80935bf5 | 558 | /* Assumes h is locked for read if applicable */ |
0ce8271c | 559 | return sk_X509_OBJECT_find_all(h, &stmp, pnmatch); |
0f113f3e | 560 | } |
4d50a2b4 | 561 | |
80935bf5 | 562 | /* Assumes h is locked for read if applicable */ |
0946a198 | 563 | int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, |
8cc86b81 | 564 | const X509_NAME *name) |
0f113f3e MC |
565 | { |
566 | return x509_object_idx_cnt(h, type, name, NULL); | |
567 | } | |
568 | ||
80935bf5 | 569 | /* Assumes h is locked for read if applicable */ |
0f113f3e | 570 | X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, |
0946a198 | 571 | X509_LOOKUP_TYPE type, |
8cc86b81 | 572 | const X509_NAME *name) |
0f113f3e | 573 | { |
0ce8271c DDO |
574 | int idx = X509_OBJECT_idx_by_subject(h, type, name); |
575 | ||
0f113f3e MC |
576 | if (idx == -1) |
577 | return NULL; | |
578 | return sk_X509_OBJECT_value(h, idx); | |
579 | } | |
11262391 | 580 | |
c34e7876 | 581 | STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *xs) |
f0c58c32 | 582 | { |
c34e7876 | 583 | return xs->objs; |
f0c58c32 CH |
584 | } |
585 | ||
08cecb44 DB |
586 | static X509_OBJECT *x509_object_dup(const X509_OBJECT *obj) |
587 | { | |
588 | X509_OBJECT *ret = X509_OBJECT_new(); | |
589 | if (ret == NULL) | |
590 | return NULL; | |
591 | ||
592 | ret->type = obj->type; | |
593 | ret->data = obj->data; | |
594 | X509_OBJECT_up_ref_count(ret); | |
595 | return ret; | |
596 | } | |
597 | ||
598 | STACK_OF(X509_OBJECT) *X509_STORE_get1_objects(X509_STORE *store) | |
599 | { | |
600 | STACK_OF(X509_OBJECT) *objs; | |
601 | ||
602 | if (store == NULL) { | |
603 | ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER); | |
604 | return NULL; | |
605 | } | |
606 | ||
607 | if (!x509_store_read_lock(store)) | |
608 | return NULL; | |
609 | ||
610 | objs = sk_X509_OBJECT_deep_copy(store->objs, x509_object_dup, | |
611 | X509_OBJECT_free); | |
612 | X509_STORE_unlock(store); | |
613 | return objs; | |
614 | } | |
615 | ||
31b28ad9 DDO |
616 | STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *store) |
617 | { | |
618 | STACK_OF(X509) *sk; | |
619 | STACK_OF(X509_OBJECT) *objs; | |
620 | int i; | |
621 | ||
622 | if (store == NULL) { | |
9311d0c4 | 623 | ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER); |
31b28ad9 DDO |
624 | return NULL; |
625 | } | |
626 | if ((sk = sk_X509_new_null()) == NULL) | |
627 | return NULL; | |
814999cb JJ |
628 | if (!X509_STORE_lock(store)) |
629 | goto out_free; | |
630 | ||
3ef5b600 | 631 | sk_X509_OBJECT_sort(store->objs); |
31b28ad9 DDO |
632 | objs = X509_STORE_get0_objects(store); |
633 | for (i = 0; i < sk_X509_OBJECT_num(objs); i++) { | |
634 | X509 *cert = X509_OBJECT_get0_X509(sk_X509_OBJECT_value(objs, i)); | |
635 | ||
eeccc237 DDO |
636 | if (cert != NULL |
637 | && !X509_add_cert(sk, cert, X509_ADD_FLAG_UP_REF)) | |
638 | goto err; | |
31b28ad9 DDO |
639 | } |
640 | X509_STORE_unlock(store); | |
641 | return sk; | |
642 | ||
643 | err: | |
644 | X509_STORE_unlock(store); | |
814999cb | 645 | out_free: |
79b2a2f2 | 646 | OSSL_STACK_OF_X509_free(sk); |
31b28ad9 DDO |
647 | return NULL; |
648 | } | |
649 | ||
0ce8271c | 650 | /* Returns NULL on internal/fatal error, empty stack if not found */ |
8cc86b81 DDO |
651 | STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *ctx, |
652 | const X509_NAME *nm) | |
0f113f3e MC |
653 | { |
654 | int i, idx, cnt; | |
6ddbb4cd | 655 | STACK_OF(X509) *sk = NULL; |
0f113f3e MC |
656 | X509 *x; |
657 | X509_OBJECT *obj; | |
faa9dcd4 | 658 | X509_STORE *store = ctx->store; |
6ddbb4cd | 659 | |
7a9abccd | 660 | if (store == NULL) |
0ce8271c | 661 | return sk_X509_new_null(); |
1c705121 | 662 | |
814999cb JJ |
663 | if (!X509_STORE_lock(store)) |
664 | return NULL; | |
665 | ||
3ef5b600 | 666 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 667 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, nm, &cnt); |
0f113f3e MC |
668 | if (idx < 0) { |
669 | /* | |
670 | * Nothing found in cache: do lookup to possibly add new objects to | |
671 | * cache | |
672 | */ | |
6ddbb4cd RS |
673 | X509_OBJECT *xobj = X509_OBJECT_new(); |
674 | ||
7a9abccd | 675 | X509_STORE_unlock(store); |
6ddbb4cd RS |
676 | if (xobj == NULL) |
677 | return NULL; | |
0ce8271c DDO |
678 | i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_X509, nm, xobj); |
679 | if (i <= 0) { | |
6ddbb4cd | 680 | X509_OBJECT_free(xobj); |
0ce8271c | 681 | return i < 0 ? NULL : sk_X509_new_null(); |
0f113f3e | 682 | } |
6ddbb4cd | 683 | X509_OBJECT_free(xobj); |
814999cb JJ |
684 | if (!X509_STORE_lock(store)) |
685 | return NULL; | |
3ef5b600 | 686 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 687 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, nm, &cnt); |
0f113f3e | 688 | if (idx < 0) { |
0ce8271c DDO |
689 | sk = sk_X509_new_null(); |
690 | goto end; | |
0f113f3e MC |
691 | } |
692 | } | |
6ddbb4cd RS |
693 | |
694 | sk = sk_X509_new_null(); | |
0ce8271c DDO |
695 | if (sk == NULL) |
696 | goto end; | |
0f113f3e | 697 | for (i = 0; i < cnt; i++, idx++) { |
7a9abccd | 698 | obj = sk_X509_OBJECT_value(store->objs, idx); |
0f113f3e | 699 | x = obj->data.x509; |
eeccc237 | 700 | if (!X509_add_cert(sk, x, X509_ADD_FLAG_UP_REF)) { |
7a9abccd | 701 | X509_STORE_unlock(store); |
79b2a2f2 | 702 | OSSL_STACK_OF_X509_free(sk); |
0f113f3e MC |
703 | return NULL; |
704 | } | |
705 | } | |
0ce8271c | 706 | end: |
7a9abccd | 707 | X509_STORE_unlock(store); |
0f113f3e | 708 | return sk; |
0f113f3e | 709 | } |
4d50a2b4 | 710 | |
0ce8271c | 711 | /* Returns NULL on internal/fatal error, empty stack if not found */ |
8cc86b81 DDO |
712 | STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *ctx, |
713 | const X509_NAME *nm) | |
0f113f3e | 714 | { |
0ce8271c | 715 | int i = 1, idx, cnt; |
6ddbb4cd | 716 | STACK_OF(X509_CRL) *sk = sk_X509_CRL_new_null(); |
0f113f3e | 717 | X509_CRL *x; |
6ddbb4cd | 718 | X509_OBJECT *obj, *xobj = X509_OBJECT_new(); |
faa9dcd4 | 719 | X509_STORE *store = ctx->store; |
0f113f3e | 720 | |
6ddbb4cd | 721 | /* Always do lookup to possibly add new CRLs to cache */ |
1c705121 | 722 | if (sk == NULL |
0ce8271c DDO |
723 | || xobj == NULL |
724 | || (i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_CRL, | |
725 | nm, xobj)) < 0) { | |
6ddbb4cd | 726 | X509_OBJECT_free(xobj); |
0f113f3e MC |
727 | sk_X509_CRL_free(sk); |
728 | return NULL; | |
729 | } | |
6ddbb4cd | 730 | X509_OBJECT_free(xobj); |
0ce8271c DDO |
731 | if (i == 0) |
732 | return sk; | |
814999cb JJ |
733 | if (!X509_STORE_lock(store)) { |
734 | sk_X509_CRL_free(sk); | |
735 | return NULL; | |
736 | } | |
3ef5b600 | 737 | sk_X509_OBJECT_sort(store->objs); |
7a9abccd | 738 | idx = x509_object_idx_cnt(store->objs, X509_LU_CRL, nm, &cnt); |
0f113f3e | 739 | if (idx < 0) { |
7a9abccd | 740 | X509_STORE_unlock(store); |
0ce8271c | 741 | return sk; |
0f113f3e MC |
742 | } |
743 | ||
744 | for (i = 0; i < cnt; i++, idx++) { | |
7a9abccd | 745 | obj = sk_X509_OBJECT_value(store->objs, idx); |
0f113f3e | 746 | x = obj->data.crl; |
c70e2ec3 BE |
747 | if (!X509_CRL_up_ref(x)) { |
748 | X509_STORE_unlock(store); | |
749 | sk_X509_CRL_pop_free(sk, X509_CRL_free); | |
750 | return NULL; | |
751 | } | |
0f113f3e | 752 | if (!sk_X509_CRL_push(sk, x)) { |
7a9abccd | 753 | X509_STORE_unlock(store); |
0f113f3e MC |
754 | X509_CRL_free(x); |
755 | sk_X509_CRL_pop_free(sk, X509_CRL_free); | |
756 | return NULL; | |
757 | } | |
758 | } | |
7a9abccd | 759 | X509_STORE_unlock(store); |
0f113f3e MC |
760 | return sk; |
761 | } | |
762 | ||
763 | X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, | |
764 | X509_OBJECT *x) | |
765 | { | |
5b37fef0 | 766 | int idx, i, num; |
0f113f3e | 767 | X509_OBJECT *obj; |
5b37fef0 | 768 | |
0f113f3e | 769 | idx = sk_X509_OBJECT_find(h, x); |
5b37fef0 | 770 | if (idx < 0) |
0f113f3e MC |
771 | return NULL; |
772 | if ((x->type != X509_LU_X509) && (x->type != X509_LU_CRL)) | |
773 | return sk_X509_OBJECT_value(h, idx); | |
5b37fef0 | 774 | for (i = idx, num = sk_X509_OBJECT_num(h); i < num; i++) { |
0f113f3e | 775 | obj = sk_X509_OBJECT_value(h, i); |
5b37fef0 AP |
776 | if (x509_object_cmp((const X509_OBJECT **)&obj, |
777 | (const X509_OBJECT **)&x)) | |
0f113f3e MC |
778 | return NULL; |
779 | if (x->type == X509_LU_X509) { | |
780 | if (!X509_cmp(obj->data.x509, x->data.x509)) | |
781 | return obj; | |
782 | } else if (x->type == X509_LU_CRL) { | |
f2a04587 | 783 | if (X509_CRL_match(obj->data.crl, x->data.crl) == 0) |
0f113f3e | 784 | return obj; |
c34e7876 | 785 | } else { |
0f113f3e | 786 | return obj; |
c34e7876 | 787 | } |
0f113f3e MC |
788 | } |
789 | return NULL; | |
790 | } | |
d02b48c6 | 791 | |
1d97c843 | 792 | /*- |
f1923a21 DDO |
793 | * Try to get issuer cert from |ctx->store| matching the subject name of |x|. |
794 | * Prefer the first non-expired one, else take the most recently expired one. | |
2f043896 DSH |
795 | * |
796 | * Return values are: | |
797 | * 1 lookup successful. | |
798 | * 0 certificate not found. | |
799 | * -1 some other error. | |
800 | */ | |
2f043896 | 801 | int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x) |
0f113f3e | 802 | { |
8cc86b81 | 803 | const X509_NAME *xn; |
6ddbb4cd | 804 | X509_OBJECT *obj = X509_OBJECT_new(), *pobj = NULL; |
faa9dcd4 | 805 | X509_STORE *store = ctx->store; |
5fd7eb5c | 806 | int i, ok, idx, ret, nmatch = 0; |
f0e0fd51 | 807 | |
6ddbb4cd RS |
808 | if (obj == NULL) |
809 | return -1; | |
0f113f3e MC |
810 | *issuer = NULL; |
811 | xn = X509_get_issuer_name(x); | |
0ce8271c | 812 | ok = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_X509, xn, obj); |
ba1a1c37 | 813 | if (ok != 1) { |
6ddbb4cd | 814 | X509_OBJECT_free(obj); |
0ce8271c | 815 | return ok; |
0f113f3e | 816 | } |
f1923a21 | 817 | /* If certificate matches and is currently valid all OK */ |
6ddbb4cd | 818 | if (ctx->check_issued(ctx, x, obj->data.x509)) { |
4669015d | 819 | if (ossl_x509_check_cert_time(ctx, obj->data.x509, -1)) { |
6ddbb4cd | 820 | *issuer = obj->data.x509; |
d6bf19a4 DDO |
821 | /* |*issuer| has taken over the cert reference from |obj| */ |
822 | obj->type = X509_LU_NONE; | |
6ddbb4cd | 823 | X509_OBJECT_free(obj); |
d6bf19a4 | 824 | return 1; |
0f113f3e MC |
825 | } |
826 | } | |
6ddbb4cd | 827 | X509_OBJECT_free(obj); |
0f113f3e | 828 | |
f1923a21 DDO |
829 | /* |
830 | * Due to limitations of the API this can only retrieve a single cert. | |
831 | * However it will fill the cache with all matching certificates, | |
832 | * so we can examine the cache for all matches. | |
833 | */ | |
7a9abccd | 834 | if (store == NULL) |
1c705121 MC |
835 | return 0; |
836 | ||
f1923a21 | 837 | /* Find index of first currently valid cert accepted by 'check_issued' */ |
0f113f3e | 838 | ret = 0; |
814999cb JJ |
839 | if (!X509_STORE_lock(store)) |
840 | return 0; | |
841 | ||
3ef5b600 | 842 | sk_X509_OBJECT_sort(store->objs); |
5fd7eb5c | 843 | idx = x509_object_idx_cnt(store->objs, X509_LU_X509, xn, &nmatch); |
f1923a21 | 844 | if (idx != -1) { /* should be true as we've had at least one match */ |
0f113f3e | 845 | /* Look through all matching certs for suitable issuer */ |
5fd7eb5c | 846 | for (i = idx; i < idx + nmatch; i++) { |
7a9abccd | 847 | pobj = sk_X509_OBJECT_value(store->objs, i); |
0f113f3e MC |
848 | /* See if we've run past the matches */ |
849 | if (pobj->type != X509_LU_X509) | |
850 | break; | |
0f113f3e | 851 | if (ctx->check_issued(ctx, x, pobj->data.x509)) { |
0f113f3e | 852 | ret = 1; |
f1923a21 | 853 | /* If times check fine, exit with match, else keep looking. */ |
4669015d | 854 | if (ossl_x509_check_cert_time(ctx, pobj->data.x509, -1)) { |
f1923a21 DDO |
855 | *issuer = pobj->data.x509; |
856 | break; | |
857 | } | |
0f113f3e | 858 | /* |
f1923a21 DDO |
859 | * Leave the so far most recently expired match in *issuer |
860 | * so we return nearest match if no certificate time is OK. | |
0f113f3e | 861 | */ |
f1923a21 DDO |
862 | if (*issuer == NULL |
863 | || ASN1_TIME_compare(X509_get0_notAfter(pobj->data.x509), | |
864 | X509_get0_notAfter(*issuer)) > 0) | |
865 | *issuer = pobj->data.x509; | |
0f113f3e MC |
866 | } |
867 | } | |
868 | } | |
f1923a21 | 869 | if (*issuer != NULL && !X509_up_ref(*issuer)) { |
c70e2ec3 BE |
870 | *issuer = NULL; |
871 | ret = -1; | |
872 | } | |
7a9abccd | 873 | X509_STORE_unlock(store); |
0f113f3e MC |
874 | return ret; |
875 | } | |
d02b48c6 | 876 | |
c34e7876 | 877 | int X509_STORE_set_flags(X509_STORE *xs, unsigned long flags) |
0f113f3e | 878 | { |
c34e7876 | 879 | return X509_VERIFY_PARAM_set_flags(xs->param, flags); |
0f113f3e | 880 | } |
5d7c222d | 881 | |
c34e7876 | 882 | int X509_STORE_set_depth(X509_STORE *xs, int depth) |
0f113f3e | 883 | { |
c34e7876 | 884 | X509_VERIFY_PARAM_set_depth(xs->param, depth); |
0f113f3e MC |
885 | return 1; |
886 | } | |
bdee69f7 | 887 | |
c34e7876 | 888 | int X509_STORE_set_purpose(X509_STORE *xs, int purpose) |
0f113f3e | 889 | { |
c34e7876 | 890 | return X509_VERIFY_PARAM_set_purpose(xs->param, purpose); |
0f113f3e | 891 | } |
926a56bf | 892 | |
c34e7876 | 893 | int X509_STORE_set_trust(X509_STORE *xs, int trust) |
0f113f3e | 894 | { |
c34e7876 | 895 | return X509_VERIFY_PARAM_set_trust(xs->param, trust); |
0f113f3e | 896 | } |
5d7c222d | 897 | |
c34e7876 | 898 | int X509_STORE_set1_param(X509_STORE *xs, const X509_VERIFY_PARAM *param) |
0f113f3e | 899 | { |
c34e7876 | 900 | return X509_VERIFY_PARAM_set1(xs->param, param); |
0f113f3e | 901 | } |
926a56bf | 902 | |
c34e7876 | 903 | X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *xs) |
f0c58c32 | 904 | { |
c34e7876 | 905 | return xs->param; |
f0c58c32 CH |
906 | } |
907 | ||
c34e7876 | 908 | void X509_STORE_set_verify(X509_STORE *xs, X509_STORE_CTX_verify_fn verify) |
1060a50b | 909 | { |
c34e7876 | 910 | xs->verify = verify; |
1060a50b RL |
911 | } |
912 | ||
c34e7876 | 913 | X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *xs) |
1060a50b | 914 | { |
c34e7876 | 915 | return xs->verify; |
1060a50b RL |
916 | } |
917 | ||
c34e7876 | 918 | void X509_STORE_set_verify_cb(X509_STORE *xs, |
1060a50b | 919 | X509_STORE_CTX_verify_cb verify_cb) |
0f113f3e | 920 | { |
c34e7876 | 921 | xs->verify_cb = verify_cb; |
0f113f3e | 922 | } |
a5b37fca | 923 | |
c34e7876 | 924 | X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *xs) |
7cafbb4b | 925 | { |
c34e7876 | 926 | return xs->verify_cb; |
1060a50b RL |
927 | } |
928 | ||
c34e7876 | 929 | void X509_STORE_set_get_issuer(X509_STORE *xs, |
1060a50b RL |
930 | X509_STORE_CTX_get_issuer_fn get_issuer) |
931 | { | |
c34e7876 | 932 | xs->get_issuer = get_issuer; |
1060a50b RL |
933 | } |
934 | ||
c34e7876 | 935 | X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *xs) |
1060a50b | 936 | { |
c34e7876 | 937 | return xs->get_issuer; |
1060a50b RL |
938 | } |
939 | ||
c34e7876 | 940 | void X509_STORE_set_check_issued(X509_STORE *xs, |
1060a50b RL |
941 | X509_STORE_CTX_check_issued_fn check_issued) |
942 | { | |
c34e7876 | 943 | xs->check_issued = check_issued; |
1060a50b RL |
944 | } |
945 | ||
c34e7876 | 946 | X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *xs) |
1060a50b | 947 | { |
c34e7876 | 948 | return xs->check_issued; |
1060a50b RL |
949 | } |
950 | ||
c34e7876 DDO |
951 | void X509_STORE_set_check_revocation(X509_STORE *xs, |
952 | X509_STORE_CTX_check_revocation_fn cb) | |
1060a50b | 953 | { |
c34e7876 | 954 | xs->check_revocation = cb; |
1060a50b RL |
955 | } |
956 | ||
c34e7876 | 957 | X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(const X509_STORE *xs) |
1060a50b | 958 | { |
c34e7876 | 959 | return xs->check_revocation; |
1060a50b RL |
960 | } |
961 | ||
c34e7876 | 962 | void X509_STORE_set_get_crl(X509_STORE *xs, |
1060a50b RL |
963 | X509_STORE_CTX_get_crl_fn get_crl) |
964 | { | |
c34e7876 | 965 | xs->get_crl = get_crl; |
1060a50b RL |
966 | } |
967 | ||
c34e7876 | 968 | X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *xs) |
1060a50b | 969 | { |
c34e7876 | 970 | return xs->get_crl; |
1060a50b RL |
971 | } |
972 | ||
c34e7876 | 973 | void X509_STORE_set_check_crl(X509_STORE *xs, |
1060a50b RL |
974 | X509_STORE_CTX_check_crl_fn check_crl) |
975 | { | |
c34e7876 | 976 | xs->check_crl = check_crl; |
1060a50b RL |
977 | } |
978 | ||
c34e7876 | 979 | X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *xs) |
1060a50b | 980 | { |
c34e7876 | 981 | return xs->check_crl; |
1060a50b RL |
982 | } |
983 | ||
c34e7876 | 984 | void X509_STORE_set_cert_crl(X509_STORE *xs, |
1060a50b RL |
985 | X509_STORE_CTX_cert_crl_fn cert_crl) |
986 | { | |
c34e7876 | 987 | xs->cert_crl = cert_crl; |
1060a50b RL |
988 | } |
989 | ||
c34e7876 | 990 | X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *xs) |
1060a50b | 991 | { |
c34e7876 | 992 | return xs->cert_crl; |
1060a50b RL |
993 | } |
994 | ||
c34e7876 | 995 | void X509_STORE_set_check_policy(X509_STORE *xs, |
0a5fe2eb RL |
996 | X509_STORE_CTX_check_policy_fn check_policy) |
997 | { | |
c34e7876 | 998 | xs->check_policy = check_policy; |
0a5fe2eb RL |
999 | } |
1000 | ||
c34e7876 | 1001 | X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *xs) |
0a5fe2eb | 1002 | { |
c34e7876 | 1003 | return xs->check_policy; |
0a5fe2eb RL |
1004 | } |
1005 | ||
c34e7876 | 1006 | void X509_STORE_set_lookup_certs(X509_STORE *xs, |
1060a50b RL |
1007 | X509_STORE_CTX_lookup_certs_fn lookup_certs) |
1008 | { | |
c34e7876 | 1009 | xs->lookup_certs = lookup_certs; |
1060a50b RL |
1010 | } |
1011 | ||
c34e7876 | 1012 | X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *xs) |
1060a50b | 1013 | { |
c34e7876 | 1014 | return xs->lookup_certs; |
1060a50b RL |
1015 | } |
1016 | ||
c34e7876 | 1017 | void X509_STORE_set_lookup_crls(X509_STORE *xs, |
1060a50b RL |
1018 | X509_STORE_CTX_lookup_crls_fn lookup_crls) |
1019 | { | |
c34e7876 | 1020 | xs->lookup_crls = lookup_crls; |
1060a50b RL |
1021 | } |
1022 | ||
c34e7876 | 1023 | X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *xs) |
1060a50b | 1024 | { |
c34e7876 | 1025 | return xs->lookup_crls; |
1060a50b RL |
1026 | } |
1027 | ||
c34e7876 DDO |
1028 | void X509_STORE_set_cleanup(X509_STORE *xs, |
1029 | X509_STORE_CTX_cleanup_fn cleanup) | |
1060a50b | 1030 | { |
c34e7876 | 1031 | xs->cleanup = cleanup; |
7cafbb4b MC |
1032 | } |
1033 | ||
c34e7876 | 1034 | X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *xs) |
0f113f3e | 1035 | { |
c34e7876 | 1036 | return xs->cleanup; |
0f113f3e | 1037 | } |
2c340864 | 1038 | |
c34e7876 | 1039 | int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data) |
3aec886e | 1040 | { |
c34e7876 | 1041 | return CRYPTO_set_ex_data(&xs->ex_data, idx, data); |
3aec886e KY |
1042 | } |
1043 | ||
c34e7876 | 1044 | void *X509_STORE_get_ex_data(const X509_STORE *xs, int idx) |
3aec886e | 1045 | { |
c34e7876 | 1046 | return CRYPTO_get_ex_data(&xs->ex_data, idx); |
3aec886e KY |
1047 | } |
1048 | ||
8cc86b81 | 1049 | X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx) |
0f113f3e | 1050 | { |
faa9dcd4 | 1051 | return ctx->store; |
0f113f3e | 1052 | } |