Coverage Report

Created: 2026-11-16 07:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/crypto/x509/x509_lu.c
Line
Count
Source
1
/*
2
 * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
3
 *
4
 * Licensed under the Apache License 2.0 (the "License").  You may not use
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
8
 */
9
10
#include <stdio.h>
11
#include "internal/cryptlib.h"
12
#include "internal/hashtable.h"
13
#include "internal/refcount.h"
14
#include <openssl/x509.h>
15
#include "crypto/x509.h"
16
#include <openssl/x509v3.h>
17
#include "x509_local.h"
18
19
0
#define X509_OBJS_HT_BUCKETS 8
20
21
X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
22
0
{
23
0
    X509_LOOKUP *ret = OPENSSL_zalloc(sizeof(*ret));
24
25
0
    if (ret == NULL)
26
0
        return NULL;
27
28
0
    ret->method = method;
29
0
    if (method->new_item != NULL && method->new_item(ret) == 0) {
30
0
        OPENSSL_free(ret);
31
0
        return NULL;
32
0
    }
33
0
    return ret;
34
0
}
35
36
void X509_LOOKUP_free(X509_LOOKUP *ctx)
37
0
{
38
0
    if (ctx == NULL)
39
0
        return;
40
0
    if ((ctx->method != NULL) && (ctx->method->free != NULL))
41
0
        (*ctx->method->free)(ctx);
42
0
    OPENSSL_free(ctx);
43
0
}
44
45
int X509_STORE_lock(X509_STORE *xs)
46
0
{
47
0
    return CRYPTO_THREAD_write_lock(xs->lock);
48
0
}
49
50
int ossl_x509_store_read_lock(X509_STORE *xs)
51
0
{
52
0
    return CRYPTO_THREAD_read_lock(xs->lock);
53
0
}
54
55
int X509_STORE_unlock(X509_STORE *xs)
56
0
{
57
0
    return CRYPTO_THREAD_unlock(xs->lock);
58
0
}
59
60
int X509_LOOKUP_init(X509_LOOKUP *ctx)
61
0
{
62
0
    if (ctx->method == NULL)
63
0
        return 0;
64
0
    if (ctx->method->init != NULL)
65
0
        return ctx->method->init(ctx);
66
0
    else
67
0
        return 1;
68
0
}
69
70
int X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
71
0
{
72
0
    if (ctx->method == NULL)
73
0
        return 0;
74
0
    if (ctx->method->shutdown != NULL)
75
0
        return ctx->method->shutdown(ctx);
76
0
    else
77
0
        return 1;
78
0
}
79
80
int X509_LOOKUP_ctrl_ex(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
81
    char **ret, OSSL_LIB_CTX *libctx, const char *propq)
82
0
{
83
0
    if (ctx->method == NULL)
84
0
        return -1;
85
0
    if (ctx->method->ctrl_ex != NULL)
86
0
        return ctx->method->ctrl_ex(ctx, cmd, argc, argl, ret, libctx, propq);
87
0
    if (ctx->method->ctrl != NULL)
88
0
        return ctx->method->ctrl(ctx, cmd, argc, argl, ret);
89
0
    return 1;
90
0
}
91
92
int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
93
    char **ret)
94
0
{
95
0
    return X509_LOOKUP_ctrl_ex(ctx, cmd, argc, argl, ret, NULL, NULL);
96
0
}
97
98
int X509_LOOKUP_by_subject_ex(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
99
    const X509_NAME *name, X509_OBJECT *ret,
100
    OSSL_LIB_CTX *libctx, const char *propq)
101
0
{
102
0
    if (ctx->skip
103
0
        || ctx->method == NULL
104
0
        || (ctx->method->get_by_subject == NULL
105
0
            && ctx->method->get_by_subject_ex == NULL))
106
0
        return 0;
107
0
    if (ctx->method->get_by_subject_ex != NULL)
108
0
        return ctx->method->get_by_subject_ex(ctx, type, name, ret, libctx,
109
0
            propq);
110
0
    else
111
0
        return ctx->method->get_by_subject(ctx, type, name, ret);
112
0
}
113
114
int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
115
    const X509_NAME *name, X509_OBJECT *ret)
116
0
{
117
0
    return X509_LOOKUP_by_subject_ex(ctx, type, name, ret, NULL, NULL);
118
0
}
119
120
int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
121
    const X509_NAME *name,
122
    const ASN1_INTEGER *serial,
123
    X509_OBJECT *ret)
124
0
{
125
0
    if ((ctx->method == NULL) || (ctx->method->get_by_issuer_serial == NULL))
126
0
        return 0;
127
0
    return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret);
128
0
}
129
130
int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
131
    const unsigned char *bytes, int len,
132
    X509_OBJECT *ret)
133
0
{
134
0
    if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL))
135
0
        return 0;
136
0
    return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret);
137
0
}
138
139
int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
140
    const char *str, int len, X509_OBJECT *ret)
141
0
{
142
0
    if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL))
143
0
        return 0;
144
0
    return ctx->method->get_by_alias(ctx, type, str, len, ret);
145
0
}
146
147
int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data)
148
0
{
149
0
    ctx->method_data = data;
150
0
    return 1;
151
0
}
152
153
void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx)
154
0
{
155
0
    return ctx->method_data;
156
0
}
157
158
X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx)
159
0
{
160
0
    return ctx->store_ctx;
161
0
}
162
163
static int x509_object_cmp(const X509_OBJECT *const *a,
164
    const X509_OBJECT *const *b)
165
0
{
166
0
    int ret;
167
168
0
    ret = ((*a)->type - (*b)->type);
169
0
    if (ret)
170
0
        return ret;
171
0
    switch ((*a)->type) {
172
0
    case X509_LU_X509:
173
0
        ret = X509_subject_name_cmp((*a)->data.x509, (*b)->data.x509);
174
0
        break;
175
0
    case X509_LU_CRL:
176
0
        ret = X509_CRL_cmp((*a)->data.crl, (*b)->data.crl);
177
0
        break;
178
0
    case X509_LU_NONE:
179
        /* abort(); */
180
0
        return 0;
181
0
    }
182
0
    return ret;
183
0
}
184
185
static void objs_ht_free(HT_VALUE *v)
186
0
{
187
0
    STACK_OF(X509_OBJECT) *objs = v->value;
188
189
0
    sk_X509_OBJECT_pop_free(objs, X509_OBJECT_free);
190
0
}
191
192
static void objs_ht_init_key(OBJS_KEY *key, const X509_NAME *xn)
193
0
{
194
    /* Empty names have no canonical buffer, but the hash table copies the key. */
195
0
    HT_INIT_KEY(key);
196
0
    key->key_header.keybuf = xn->canon_enc != NULL ? xn->canon_enc : (unsigned char *)"";
197
0
    key->key_header.keysize = xn->canon_enclen;
198
0
}
199
200
X509_STORE *X509_STORE_new(void)
201
0
{
202
0
    X509_STORE *ret = OPENSSL_zalloc(sizeof(*ret));
203
0
    HT_CONFIG htconf = {
204
0
        .ht_free_fn = objs_ht_free,
205
0
        .collision_check = 1,
206
0
        .init_neighborhoods = X509_OBJS_HT_BUCKETS,
207
0
        .no_rcu = 1,
208
0
    };
209
210
0
    if (ret == NULL)
211
0
        return NULL;
212
0
    if ((ret->objs_ht = ossl_ht_new(&htconf)) == NULL) {
213
0
        ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
214
0
        goto err;
215
0
    }
216
0
    if ((ret->objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL) {
217
0
        ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
218
0
        goto err;
219
0
    }
220
0
    ret->cache = 1;
221
0
    if ((ret->get_cert_methods = sk_X509_LOOKUP_new_null()) == NULL) {
222
0
        ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
223
0
        goto err;
224
0
    }
225
226
0
    if ((ret->param = X509_VERIFY_PARAM_new()) == NULL) {
227
0
        ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
228
0
        goto err;
229
0
    }
230
0
    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data)) {
231
0
        ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
232
0
        goto err;
233
0
    }
234
235
0
    ret->lock = CRYPTO_THREAD_lock_new();
236
0
    if (ret->lock == NULL) {
237
0
        ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
238
0
        goto err;
239
0
    }
240
241
0
    if (!CRYPTO_NEW_REF(&ret->references, 1))
242
0
        goto err;
243
0
    return ret;
244
245
0
err:
246
0
    X509_VERIFY_PARAM_free(ret->param);
247
0
    sk_X509_OBJECT_free(ret->objs);
248
0
    sk_X509_LOOKUP_free(ret->get_cert_methods);
249
0
    ossl_ht_free(ret->objs_ht);
250
0
    CRYPTO_THREAD_lock_free(ret->lock);
251
0
    OPENSSL_free(ret);
252
0
    return NULL;
253
0
}
254
255
void X509_STORE_free(X509_STORE *xs)
256
0
{
257
0
    int i;
258
0
    STACK_OF(X509_LOOKUP) *sk;
259
0
    X509_LOOKUP *lu;
260
261
0
    if (xs == NULL)
262
0
        return;
263
0
    CRYPTO_DOWN_REF(&xs->references, &i);
264
0
    REF_PRINT_COUNT("X509_STORE", i, xs);
265
0
    if (i > 0)
266
0
        return;
267
0
    REF_ASSERT_ISNT(i < 0);
268
269
0
    sk = xs->get_cert_methods;
270
0
    for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
271
0
        lu = sk_X509_LOOKUP_value(sk, i);
272
0
        X509_LOOKUP_shutdown(lu);
273
0
        X509_LOOKUP_free(lu);
274
0
    }
275
0
    sk_X509_LOOKUP_free(sk);
276
0
    sk_X509_OBJECT_pop_free(xs->objs, X509_OBJECT_free);
277
278
0
    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, xs, &xs->ex_data);
279
0
    X509_VERIFY_PARAM_free(xs->param);
280
0
    CRYPTO_THREAD_lock_free(xs->lock);
281
0
    CRYPTO_FREE_REF(&xs->references);
282
0
    ossl_ht_free(xs->objs_ht);
283
0
    OPENSSL_free(xs);
284
0
}
285
286
int X509_STORE_up_ref(X509_STORE *xs)
287
0
{
288
0
    int i;
289
290
0
    if (!CRYPTO_UP_REF(&xs->references, &i))
291
0
        return 0;
292
293
0
    REF_PRINT_COUNT("X509_STORE", i, xs);
294
0
    REF_ASSERT_ISNT(i < 2);
295
0
    return i > 1 ? 1 : 0;
296
0
}
297
298
X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *xs, X509_LOOKUP_METHOD *m)
299
0
{
300
0
    int i;
301
0
    STACK_OF(X509_LOOKUP) *sk;
302
0
    X509_LOOKUP *lu;
303
304
0
    sk = xs->get_cert_methods;
305
0
    for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
306
0
        lu = sk_X509_LOOKUP_value(sk, i);
307
0
        if (m == lu->method) {
308
0
            return lu;
309
0
        }
310
0
    }
311
    /* a new one */
312
0
    lu = X509_LOOKUP_new(m);
313
0
    if (lu == NULL) {
314
0
        ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
315
0
        return NULL;
316
0
    }
317
318
0
    lu->store_ctx = xs;
319
0
    if (sk_X509_LOOKUP_push(xs->get_cert_methods, lu))
320
0
        return lu;
321
    /* sk_X509_LOOKUP_push() failed */
322
0
    ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
323
0
    X509_LOOKUP_free(lu);
324
0
    return NULL;
325
0
}
326
327
/* Also fill the cache (ctx->store->objs) with all matching certificates. */
328
X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *ctx,
329
    X509_LOOKUP_TYPE type,
330
    const X509_NAME *name)
331
0
{
332
0
    X509_OBJECT *ret = X509_OBJECT_new();
333
334
0
    if (ret == NULL)
335
0
        return NULL;
336
0
    if (!X509_STORE_CTX_get_by_subject(ctx, type, name, ret)) {
337
0
        X509_OBJECT_free(ret);
338
0
        return NULL;
339
0
    }
340
0
    return ret;
341
0
}
342
343
STACK_OF(X509_OBJECT) *ossl_x509_store_ht_get_by_name(const X509_STORE *store,
344
    const X509_NAME *xn)
345
0
{
346
0
    HT_VALUE *v;
347
0
    OBJS_KEY key;
348
0
    int ret;
349
350
0
    if (xn->canon_enc == NULL || xn->modified) {
351
0
        ret = i2d_X509_NAME((X509_NAME *)xn, NULL);
352
0
        if (ret < 0)
353
0
            return NULL;
354
0
    }
355
356
0
    objs_ht_init_key(&key, xn);
357
0
    v = ossl_ht_get(store->objs_ht, TO_HT_KEY(&key));
358
0
    if (v == NULL)
359
0
        return NULL;
360
0
    v = ossl_rcu_deref(&v);
361
362
0
    return v->value;
363
0
}
364
365
static int x509_name_objs_ht_insert(const X509_STORE *store, const X509_NAME *xn,
366
    STACK_OF(X509_OBJECT) *objs, X509_OBJECT *obj)
367
0
{
368
0
    int ret = 0, added = 0;
369
0
    OBJS_KEY key;
370
0
    HT_VALUE val = { 0 };
371
372
0
    if (objs != NULL) {
373
0
        added = sk_X509_OBJECT_push(objs, obj) != 0;
374
0
        return added;
375
0
    }
376
377
0
    if (xn->canon_enc == NULL || xn->modified) {
378
0
        ret = i2d_X509_NAME((X509_NAME *)xn, NULL);
379
0
        if (ret < 0)
380
0
            return 0;
381
0
    }
382
383
0
    objs = sk_X509_OBJECT_new(x509_object_cmp);
384
0
    if (objs == NULL)
385
0
        return 0;
386
387
0
    added = sk_X509_OBJECT_push(objs, obj) != 0;
388
0
    if (added == 0) {
389
0
        sk_X509_OBJECT_free(objs);
390
0
        return 0;
391
0
    }
392
393
0
    objs_ht_init_key(&key, xn);
394
0
    val.value = (void *)objs;
395
0
    ret = ossl_ht_insert(store->objs_ht, TO_HT_KEY(&key), &val, NULL);
396
0
    if (ret != 1) {
397
0
        sk_X509_OBJECT_free(objs);
398
0
        return 0;
399
0
    }
400
401
0
    return 1;
402
0
}
403
404
static int obj_ht_foreach_certs(HT_VALUE *v, void *arg)
405
0
{
406
0
    STACK_OF(X509) **sk = arg;
407
0
    STACK_OF(X509_OBJECT) *objs = v->value;
408
0
    int i, r;
409
410
0
    for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
411
0
        X509 *cert = X509_OBJECT_get0_X509(sk_X509_OBJECT_value(objs, i));
412
413
0
        if (cert == NULL)
414
0
            continue;
415
0
        r = X509_add_cert(*sk, cert, X509_ADD_FLAG_UP_REF);
416
0
        if (r == 0) {
417
0
            OSSL_STACK_OF_X509_free(*sk);
418
0
            *sk = NULL;
419
0
            return 0;
420
0
        }
421
0
    }
422
423
0
    return 1;
424
0
}
425
426
/*
427
 * Increment the reference count of the object contained in |a|, if any.
428
 * The X509_OBJECT itself is not reference counted.
429
 */
430
static int x509_object_up_ref_count(X509_OBJECT *a)
431
0
{
432
0
    switch (a->type) {
433
0
    case X509_LU_NONE:
434
0
        break;
435
0
    case X509_LU_X509:
436
0
        return X509_up_ref(a->data.x509);
437
0
    case X509_LU_CRL:
438
0
        return X509_CRL_up_ref(a->data.crl);
439
0
    }
440
0
    return 1;
441
0
}
442
443
/*
444
 * May be called with |ret| == NULL just for the side effect of
445
 * caching all certs matching the given subject DN in |ctx->store->objs|.
446
 * Returns 1 if successful,
447
 * 0 if not found or X509_LOOKUP_by_subject_ex() returns an error,
448
 * -1 on failure
449
 */
450
int ossl_x509_store_ctx_get_by_subject(const X509_STORE_CTX *ctx, X509_LOOKUP_TYPE type,
451
    const X509_NAME *name, X509_OBJECT *ret)
452
0
{
453
0
    X509_STORE *store = ctx->store;
454
0
    X509_LOOKUP *lu;
455
0
    X509_OBJECT stmp, *tmp = NULL;
456
0
    STACK_OF(X509_OBJECT) *objs;
457
0
    int i, j;
458
459
0
    if (store == NULL)
460
0
        return 0;
461
462
0
    stmp.type = X509_LU_NONE;
463
0
    stmp.data.x509 = NULL;
464
465
0
    if (!ossl_x509_store_read_lock(store))
466
0
        return 0;
467
0
    if (store->objs_ht != NULL) {
468
0
        objs = ossl_x509_store_ht_get_by_name(store, name);
469
0
        if (objs != NULL)
470
0
            tmp = X509_OBJECT_retrieve_by_subject(objs, type, name);
471
0
    } else {
472
0
        tmp = X509_OBJECT_retrieve_by_subject(store->objs, type, name);
473
0
    }
474
0
    X509_STORE_unlock(store);
475
476
0
    if (tmp == NULL || type == X509_LU_CRL) {
477
0
        for (i = 0; i < sk_X509_LOOKUP_num(store->get_cert_methods); i++) {
478
0
            lu = sk_X509_LOOKUP_value(store->get_cert_methods, i);
479
0
            if (lu->skip)
480
0
                continue;
481
0
            if (lu->method == NULL)
482
0
                return -1;
483
0
            j = X509_LOOKUP_by_subject_ex(lu, type, name, &stmp,
484
0
                ctx->libctx, ctx->propq);
485
0
            if (j != 0) { /* non-zero value is considered success here */
486
0
                tmp = &stmp;
487
0
                break;
488
0
            }
489
0
        }
490
0
        if (tmp == NULL)
491
0
            return 0;
492
0
    }
493
494
0
    if (ret != NULL) {
495
0
        if (!x509_object_up_ref_count(tmp))
496
0
            return -1;
497
0
        ret->type = tmp->type;
498
0
        ret->data = tmp->data;
499
0
    }
500
0
    return 1;
501
0
}
502
503
/* Also fill the cache |ctx->store->objs| with all matching certificates. */
504
int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *ctx,
505
    X509_LOOKUP_TYPE type,
506
    const X509_NAME *name, X509_OBJECT *ret)
507
0
{
508
0
    return ossl_x509_store_ctx_get_by_subject(ctx, type, name, ret) > 0;
509
0
}
510
static int x509_store_add_obj(X509_STORE *store, X509_OBJECT *obj)
511
0
{
512
0
    const X509_NAME *xn;
513
0
    STACK_OF(X509_OBJECT) *objs = NULL;
514
0
    int ret = 0, added = 0;
515
516
0
    if (obj->type == X509_LU_CRL)
517
0
        xn = obj->data.crl->crl.issuer;
518
0
    else
519
0
        xn = obj->data.x509->cert_info.subject;
520
521
0
    if (xn == NULL) {
522
0
        obj->type = X509_LU_NONE;
523
0
        X509_OBJECT_free(obj);
524
0
        return 0;
525
0
    }
526
527
0
    if (!x509_object_up_ref_count(obj)) {
528
0
        obj->type = X509_LU_NONE;
529
0
        X509_OBJECT_free(obj);
530
0
        return 0;
531
0
    }
532
533
0
    if (!X509_STORE_lock(store)) {
534
0
        X509_OBJECT_free(obj);
535
0
        return 0;
536
0
    }
537
538
0
    if (store->objs_ht != NULL) {
539
0
        objs = ossl_x509_store_ht_get_by_name(store, xn);
540
0
        if (objs != NULL && X509_OBJECT_retrieve_match(objs, obj)) {
541
0
            ret = 1;
542
0
        } else {
543
0
            added = x509_name_objs_ht_insert(store, xn, objs, obj);
544
0
            ret = added != 0;
545
0
        }
546
0
    } else {
547
0
        if (X509_OBJECT_retrieve_match(store->objs, obj)) {
548
0
            ret = 1;
549
0
        } else {
550
0
            added = sk_X509_OBJECT_push(store->objs, obj);
551
0
            ret = added != 0;
552
0
        }
553
0
    }
554
0
    X509_STORE_unlock(store);
555
556
0
    if (added == 0) /* obj not pushed */
557
0
        X509_OBJECT_free(obj);
558
559
0
    return ret;
560
0
}
561
562
static int x509_store_add_x509(X509_STORE *store, const X509 *x)
563
0
{
564
0
    X509_OBJECT *obj;
565
566
0
    if (x == NULL)
567
0
        return 0;
568
0
    obj = X509_OBJECT_new();
569
0
    if (obj == NULL)
570
0
        return 0;
571
572
0
    obj->type = X509_LU_X509;
573
    /*
574
     * XXX Casts away const, get rid of this once we can have the x509
575
     * member of OBJECT be const.
576
     */
577
0
    obj->data.x509 = (X509 *)x;
578
579
0
    return x509_store_add_obj(store, obj);
580
0
}
581
582
static int x509_store_add_crl(X509_STORE *store, X509_CRL *crl)
583
0
{
584
0
    X509_OBJECT *obj;
585
586
0
    if (crl == NULL)
587
0
        return 0;
588
0
    obj = X509_OBJECT_new();
589
0
    if (obj == NULL)
590
0
        return 0;
591
592
0
    obj->type = X509_LU_CRL;
593
0
    obj->data.crl = crl;
594
595
0
    return x509_store_add_obj(store, obj);
596
0
}
597
598
int X509_STORE_add_cert(X509_STORE *xs, const X509 *x)
599
0
{
600
0
    if (!x509_store_add_x509(xs, x)) {
601
0
        ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
602
0
        return 0;
603
0
    }
604
0
    return 1;
605
0
}
606
607
int X509_STORE_add_crl(X509_STORE *xs, X509_CRL *x)
608
0
{
609
0
    if (!x509_store_add_crl(xs, x)) {
610
0
        ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
611
0
        return 0;
612
0
    }
613
0
    return 1;
614
0
}
615
616
#ifndef OPENSSL_NO_DEPRECATED_4_2
617
int X509_OBJECT_up_ref_count(X509_OBJECT *a)
618
0
{
619
0
    return x509_object_up_ref_count(a);
620
0
}
621
#endif
622
623
X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a)
624
0
{
625
0
    if (a == NULL || a->type != X509_LU_X509)
626
0
        return NULL;
627
0
    return a->data.x509;
628
0
}
629
630
X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a)
631
0
{
632
0
    if (a == NULL || a->type != X509_LU_CRL)
633
0
        return NULL;
634
0
    return a->data.crl;
635
0
}
636
637
X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a)
638
0
{
639
0
    return a->type;
640
0
}
641
642
X509_OBJECT *X509_OBJECT_new(void)
643
0
{
644
0
    X509_OBJECT *ret = OPENSSL_zalloc(sizeof(*ret));
645
646
0
    if (ret == NULL)
647
0
        return NULL;
648
0
    ret->type = X509_LU_NONE;
649
0
    return ret;
650
0
}
651
652
static void x509_object_free_internal(X509_OBJECT *a)
653
0
{
654
0
    if (a == NULL)
655
0
        return;
656
0
    switch (a->type) {
657
0
    case X509_LU_NONE:
658
0
        break;
659
0
    case X509_LU_X509:
660
0
        X509_free(a->data.x509);
661
0
        break;
662
0
    case X509_LU_CRL:
663
0
        X509_CRL_free(a->data.crl);
664
0
        break;
665
0
    }
666
0
}
667
668
int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj)
669
0
{
670
0
    if (a == NULL || !X509_up_ref(obj))
671
0
        return 0;
672
673
0
    x509_object_free_internal(a);
674
0
    a->type = X509_LU_X509;
675
0
    a->data.x509 = obj;
676
0
    return 1;
677
0
}
678
679
int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj)
680
0
{
681
0
    if (a == NULL || !X509_CRL_up_ref(obj))
682
0
        return 0;
683
684
0
    x509_object_free_internal(a);
685
0
    a->type = X509_LU_CRL;
686
0
    a->data.crl = obj;
687
0
    return 1;
688
0
}
689
690
void X509_OBJECT_free(X509_OBJECT *a)
691
0
{
692
0
    x509_object_free_internal(a);
693
0
    OPENSSL_free(a);
694
0
}
695
696
/* Returns -1 if not found, but also on error */
697
static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
698
    const X509_NAME *name, int *pnmatch)
699
0
{
700
0
    X509_OBJECT stmp;
701
0
    X509 x509_s;
702
0
    X509_CRL crl_s;
703
704
0
    stmp.type = type;
705
0
    switch (type) {
706
0
    case X509_LU_X509:
707
0
        stmp.data.x509 = &x509_s;
708
0
        x509_s.cert_info.subject = (X509_NAME *)name; /* won't modify it */
709
0
        break;
710
0
    case X509_LU_CRL:
711
0
        stmp.data.crl = &crl_s;
712
0
        crl_s.crl.issuer = (X509_NAME *)name; /* won't modify it */
713
0
        break;
714
0
    case X509_LU_NONE:
715
0
    default:
716
        /* abort(); */
717
0
        return -1;
718
0
    }
719
720
    /* Assumes h is locked for read if applicable */
721
0
    return sk_X509_OBJECT_find_all(h, &stmp, pnmatch);
722
0
}
723
724
/* Assumes h is locked for read if applicable */
725
int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
726
    const X509_NAME *name)
727
0
{
728
0
    return x509_object_idx_cnt(h, type, name, NULL);
729
0
}
730
731
/* Assumes h is locked for read if applicable */
732
X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,
733
    X509_LOOKUP_TYPE type,
734
    const X509_NAME *name)
735
0
{
736
0
    int idx = X509_OBJECT_idx_by_subject(h, type, name);
737
738
0
    if (idx == -1)
739
0
        return NULL;
740
0
    return sk_X509_OBJECT_value(h, idx);
741
0
}
742
743
static X509_OBJECT *x509_object_dup(const X509_OBJECT *obj)
744
0
{
745
0
    X509_OBJECT *ret = X509_OBJECT_new();
746
0
    if (ret == NULL)
747
0
        return NULL;
748
749
0
    ret->type = obj->type;
750
0
    ret->data = obj->data;
751
752
0
    if (!x509_object_up_ref_count(ret)) {
753
0
        OPENSSL_free(ret);
754
0
        return NULL;
755
0
    }
756
757
0
    return ret;
758
0
}
759
760
#ifndef OPENSSL_NO_DEPRECATED_4_0
761
static int obj_ht_to_stack(HT_VALUE *v, void *arg)
762
0
{
763
0
    STACK_OF(X509_OBJECT) **sk = arg;
764
0
    STACK_OF(X509_OBJECT) *objs = v->value;
765
0
    X509_OBJECT *obj;
766
0
    int i;
767
768
0
    for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
769
0
        obj = sk_X509_OBJECT_value(objs, i);
770
0
        if (sk_X509_OBJECT_push(*sk, obj) == 0)
771
0
            goto err;
772
0
    }
773
774
0
    return 1;
775
776
0
err:
777
0
    sk_X509_OBJECT_zero(*sk);
778
779
0
    return 0;
780
0
}
781
782
static int obj_ht_zero_stacks(HT_VALUE *v, void *arg)
783
0
{
784
0
    STACK_OF(X509_OBJECT) *objs = v->value;
785
786
0
    sk_X509_OBJECT_zero(objs);
787
788
0
    return 1;
789
0
}
790
791
STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *xs)
792
0
{
793
0
    X509_STORE *store = (X509_STORE *)xs;
794
795
0
    if (xs->objs_ht != NULL) {
796
0
        ossl_ht_foreach_until(xs->objs_ht, obj_ht_to_stack, &store->objs);
797
0
        if (sk_X509_OBJECT_num(store->objs) > 0
798
0
            || ossl_ht_count(xs->objs_ht) == 0) {
799
0
            ossl_ht_foreach_until(xs->objs_ht, obj_ht_zero_stacks, NULL);
800
0
            ossl_ht_free(xs->objs_ht);
801
0
            store->objs_ht = NULL;
802
0
        } else {
803
0
            return NULL;
804
0
        }
805
0
    }
806
807
0
    return xs->objs;
808
0
}
809
#endif
810
811
static int obj_ht_foreach_object(HT_VALUE *v, void *arg)
812
0
{
813
0
    STACK_OF(X509_OBJECT) **sk = arg;
814
0
    STACK_OF(X509_OBJECT) *objs = v->value;
815
0
    X509_OBJECT *dup, *obj;
816
0
    int i;
817
818
0
    for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
819
0
        obj = sk_X509_OBJECT_value(objs, i);
820
0
        dup = x509_object_dup(obj);
821
0
        if (dup == NULL)
822
0
            goto err;
823
0
        if (sk_X509_OBJECT_push(*sk, dup) == 0)
824
0
            goto err;
825
0
    }
826
827
0
    return 1;
828
829
0
err:
830
0
    X509_OBJECT_free(dup);
831
0
    sk_X509_OBJECT_pop_free(*sk, X509_OBJECT_free);
832
0
    *sk = NULL;
833
834
0
    return 0;
835
0
}
836
837
STACK_OF(X509_OBJECT) *X509_STORE_get1_objects(X509_STORE *store)
838
0
{
839
0
    STACK_OF(X509_OBJECT) *objs;
840
841
0
    if (store == NULL) {
842
0
        ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER);
843
0
        return NULL;
844
0
    }
845
846
0
    if (!ossl_x509_store_read_lock(store))
847
0
        return NULL;
848
849
0
    if (store->objs_ht != NULL) {
850
0
        if ((objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL) {
851
0
            X509_STORE_unlock(store);
852
0
            return NULL;
853
0
        }
854
0
        ossl_ht_foreach_until(store->objs_ht, obj_ht_foreach_object, &objs);
855
0
    } else {
856
0
        objs = sk_X509_OBJECT_deep_copy(store->objs, x509_object_dup,
857
0
            X509_OBJECT_free);
858
0
    }
859
0
    X509_STORE_unlock(store);
860
861
0
    return objs;
862
0
}
863
864
STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *store)
865
0
{
866
0
    STACK_OF(X509) *sk = NULL;
867
868
0
    if (store == NULL) {
869
0
        ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER);
870
0
        return NULL;
871
0
    }
872
0
    if ((sk = sk_X509_new_null()) == NULL)
873
0
        return NULL;
874
875
0
    if (!ossl_x509_store_read_lock(store))
876
0
        goto out_free;
877
878
0
    if (store->objs_ht != NULL) {
879
0
        ossl_ht_foreach_until(store->objs_ht, obj_ht_foreach_certs, &sk);
880
0
    } else {
881
0
        for (int i = 0; i < sk_X509_OBJECT_num(store->objs); i++) {
882
0
            X509 *cert = X509_OBJECT_get0_X509(sk_X509_OBJECT_value(store->objs, i));
883
884
0
            if (cert != NULL
885
0
                && !X509_add_cert(sk, cert, X509_ADD_FLAG_UP_REF))
886
0
                goto err;
887
0
        }
888
0
    }
889
0
    X509_STORE_unlock(store);
890
891
0
    return sk;
892
893
0
err:
894
0
    X509_STORE_unlock(store);
895
0
out_free:
896
0
    OSSL_STACK_OF_X509_free(sk);
897
0
    return NULL;
898
0
}
899
900
/*-
901
 * Collect from |ctx->store| all certs with subject matching |nm|.
902
 * Returns NULL on internal/fatal error, empty stack if not found.
903
 */
904
STACK_OF(X509) *X509_STORE_CTX_get1_certs(const X509_STORE_CTX *ctx,
905
    const X509_NAME *nm)
906
0
{
907
0
    int i, idx = -1, cnt = 0;
908
0
    STACK_OF(X509) *sk = NULL;
909
0
    X509 *x;
910
0
    X509_OBJECT *obj;
911
0
    X509_STORE *store = ctx->store;
912
0
    STACK_OF(X509_OBJECT) *objs;
913
914
0
    if (store == NULL)
915
0
        return sk_X509_new_null();
916
917
0
    if (!ossl_x509_store_read_lock(store))
918
0
        return NULL;
919
920
0
    if (store->objs_ht != NULL) {
921
0
        objs = ossl_x509_store_ht_get_by_name(store, nm);
922
0
        if (objs != NULL)
923
0
            idx = x509_object_idx_cnt(objs, X509_LU_X509, nm, &cnt);
924
0
    } else {
925
0
        objs = store->objs;
926
0
        idx = x509_object_idx_cnt(objs, X509_LU_X509, nm, &cnt);
927
0
    }
928
0
    if (idx < 0 || objs == NULL) {
929
        /*
930
         * Nothing found in cache: do lookup to possibly add new objects to
931
         * cache
932
         */
933
0
        X509_STORE_unlock(store);
934
0
        i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_X509, nm, NULL);
935
0
        if (i <= 0)
936
0
            return i < 0 ? NULL : sk_X509_new_null();
937
0
        if (!ossl_x509_store_read_lock(store))
938
0
            return NULL;
939
0
        if (store->objs_ht != NULL) {
940
0
            objs = ossl_x509_store_ht_get_by_name(store, nm);
941
0
            if (objs == NULL)
942
0
                goto end;
943
0
        } else {
944
0
            objs = store->objs;
945
0
        }
946
0
        idx = x509_object_idx_cnt(objs, X509_LU_X509, nm, &cnt);
947
0
    }
948
949
0
    sk = sk_X509_new_null();
950
0
    if (idx < 0 || sk == NULL)
951
0
        goto end;
952
0
    for (i = idx; cnt > 0 && i < sk_X509_OBJECT_num(objs); i++) {
953
0
        obj = sk_X509_OBJECT_value(objs, i);
954
0
        if (obj->type != X509_LU_X509)
955
0
            continue;
956
0
        x = obj->data.x509;
957
        /*
958
         * x509_object_idx_cnt() returns the exact number of matches, but they
959
         * need not be contiguous in the unsorted flat store. Check the
960
         * subject name and stop once all |cnt| matches have been added.
961
         */
962
0
        if (X509_NAME_cmp(X509_get_subject_name(x), nm) != 0)
963
0
            continue;
964
0
        if (X509_add_cert(sk, x, X509_ADD_FLAG_UP_REF) == 0) {
965
0
            X509_STORE_unlock(store);
966
0
            OSSL_STACK_OF_X509_free(sk);
967
0
            return NULL;
968
0
        }
969
0
        cnt--;
970
0
    }
971
972
0
end:
973
0
    X509_STORE_unlock(store);
974
0
    return sk;
975
0
}
976
977
/* Returns NULL on internal/fatal error, empty stack if not found */
978
STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *ctx,
979
    const X509_NAME *nm)
980
0
{
981
0
    int i = 1, idx, cnt = 0;
982
0
    STACK_OF(X509_CRL) *sk;
983
0
    X509_CRL *x;
984
0
    X509_OBJECT *obj;
985
0
    X509_STORE *store = ctx->store;
986
0
    STACK_OF(X509_OBJECT) *objs;
987
988
    /* Always do lookup to possibly add new CRLs to cache */
989
0
    i = ossl_x509_store_ctx_get_by_subject(ctx, X509_LU_CRL, nm, NULL);
990
0
    if (i < 0)
991
0
        return NULL;
992
0
    sk = sk_X509_CRL_new_null();
993
0
    if (i == 0)
994
0
        return sk;
995
0
    if (!ossl_x509_store_read_lock(store)) {
996
0
        sk_X509_CRL_free(sk);
997
0
        return NULL;
998
0
    }
999
0
    if (store->objs_ht) {
1000
0
        objs = ossl_x509_store_ht_get_by_name(store, nm);
1001
0
        if (objs == NULL)
1002
0
            goto end;
1003
0
    } else {
1004
0
        objs = store->objs;
1005
0
    }
1006
0
    idx = x509_object_idx_cnt(objs, X509_LU_CRL, nm, &cnt);
1007
0
    if (idx < 0)
1008
0
        goto end;
1009
1010
0
    for (i = idx; cnt > 0 && i < sk_X509_OBJECT_num(objs); i++) {
1011
0
        obj = sk_X509_OBJECT_value(objs, i);
1012
0
        if (obj->type != X509_LU_CRL)
1013
0
            continue;
1014
0
        x = obj->data.crl;
1015
        /* See the comment in X509_STORE_CTX_get1_certs() */
1016
0
        if (X509_NAME_cmp(X509_CRL_get_issuer(x), nm) != 0)
1017
0
            continue;
1018
0
        if (!X509_CRL_up_ref(x)) {
1019
0
            X509_STORE_unlock(store);
1020
0
            sk_X509_CRL_pop_free(sk, X509_CRL_free);
1021
0
            return NULL;
1022
0
        }
1023
0
        if (!sk_X509_CRL_push(sk, x)) {
1024
0
            X509_STORE_unlock(store);
1025
0
            X509_CRL_free(x);
1026
0
            sk_X509_CRL_pop_free(sk, X509_CRL_free);
1027
0
            return NULL;
1028
0
        }
1029
0
        cnt--;
1030
0
    }
1031
0
end:
1032
0
    X509_STORE_unlock(store);
1033
0
    return sk;
1034
0
}
1035
1036
X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h,
1037
    X509_OBJECT *x)
1038
0
{
1039
0
    int idx, i, num, sorted;
1040
0
    X509_OBJECT *obj;
1041
1042
0
    idx = sk_X509_OBJECT_find(h, x);
1043
0
    if (idx < 0)
1044
0
        return NULL;
1045
0
    if ((x->type != X509_LU_X509) && (x->type != X509_LU_CRL))
1046
0
        return sk_X509_OBJECT_value(h, idx);
1047
0
    sorted = sk_X509_OBJECT_is_sorted(h);
1048
0
    for (i = idx, num = sk_X509_OBJECT_num(h); i < num; i++) {
1049
0
        obj = sk_X509_OBJECT_value(h, i);
1050
0
        if (x509_object_cmp((const X509_OBJECT **)&obj,
1051
0
                (const X509_OBJECT **)&x)) {
1052
            /* Matching objects are contiguous only in a sorted stack. */
1053
0
            if (sorted)
1054
0
                return NULL;
1055
0
            continue;
1056
0
        }
1057
0
        if (x->type == X509_LU_X509) {
1058
0
            if (!X509_cmp(obj->data.x509, x->data.x509))
1059
0
                return obj;
1060
0
        } else if (x->type == X509_LU_CRL) {
1061
0
            if (X509_CRL_match(obj->data.crl, x->data.crl) == 0)
1062
0
                return obj;
1063
0
        } else {
1064
0
            return obj;
1065
0
        }
1066
0
    }
1067
0
    return NULL;
1068
0
}
1069
1070
int X509_STORE_set_flags(X509_STORE *xs, unsigned long flags)
1071
0
{
1072
0
    return X509_VERIFY_PARAM_set_flags(xs->param, flags);
1073
0
}
1074
1075
int X509_STORE_set_depth(X509_STORE *xs, int depth)
1076
0
{
1077
0
    X509_VERIFY_PARAM_set_depth(xs->param, depth);
1078
0
    return 1;
1079
0
}
1080
1081
int X509_STORE_set_purpose(X509_STORE *xs, int purpose)
1082
0
{
1083
0
    return X509_VERIFY_PARAM_set_purpose(xs->param, purpose);
1084
0
}
1085
1086
int X509_STORE_set_trust(X509_STORE *xs, int trust)
1087
0
{
1088
0
    return X509_VERIFY_PARAM_set_trust(xs->param, trust);
1089
0
}
1090
1091
int X509_STORE_set1_param(X509_STORE *xs, const X509_VERIFY_PARAM *param)
1092
0
{
1093
0
    return X509_VERIFY_PARAM_set1(xs->param, param);
1094
0
}
1095
1096
X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *xs)
1097
0
{
1098
0
    return xs->param;
1099
0
}
1100
1101
void X509_STORE_set_verify(X509_STORE *xs, X509_STORE_CTX_verify_fn verify)
1102
0
{
1103
0
    xs->verify = verify;
1104
0
}
1105
1106
X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *xs)
1107
0
{
1108
0
    return xs->verify;
1109
0
}
1110
1111
void X509_STORE_set_verify_cb(X509_STORE *xs,
1112
    X509_STORE_CTX_verify_cb verify_cb)
1113
0
{
1114
0
    xs->verify_cb = verify_cb;
1115
0
}
1116
1117
X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *xs)
1118
0
{
1119
0
    return xs->verify_cb;
1120
0
}
1121
1122
void X509_STORE_set_get_issuer(X509_STORE *xs,
1123
    X509_STORE_CTX_get_issuer_fn get_issuer)
1124
0
{
1125
0
    xs->get_issuer = get_issuer;
1126
0
}
1127
1128
X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *xs)
1129
0
{
1130
0
    return xs->get_issuer;
1131
0
}
1132
1133
void X509_STORE_set_check_issued(X509_STORE *xs,
1134
    X509_STORE_CTX_check_issued_fn check_issued)
1135
0
{
1136
0
    xs->check_issued = check_issued;
1137
0
}
1138
1139
X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *xs)
1140
0
{
1141
0
    return xs->check_issued;
1142
0
}
1143
1144
void X509_STORE_set_check_revocation(X509_STORE *xs,
1145
    X509_STORE_CTX_check_revocation_fn cb)
1146
0
{
1147
0
    xs->check_revocation = cb;
1148
0
}
1149
1150
X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(const X509_STORE *xs)
1151
0
{
1152
0
    return xs->check_revocation;
1153
0
}
1154
1155
void X509_STORE_set_get_crl(X509_STORE *xs,
1156
    X509_STORE_CTX_get_crl_fn get_crl)
1157
0
{
1158
0
    xs->get_crl = get_crl;
1159
0
}
1160
1161
X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *xs)
1162
0
{
1163
0
    return xs->get_crl;
1164
0
}
1165
1166
void X509_STORE_set_check_crl(X509_STORE *xs,
1167
    X509_STORE_CTX_check_crl_fn check_crl)
1168
0
{
1169
0
    xs->check_crl = check_crl;
1170
0
}
1171
1172
X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *xs)
1173
0
{
1174
0
    return xs->check_crl;
1175
0
}
1176
1177
void X509_STORE_set_cert_crl(X509_STORE *xs,
1178
    X509_STORE_CTX_cert_crl_fn cert_crl)
1179
0
{
1180
0
    xs->cert_crl = cert_crl;
1181
0
}
1182
1183
X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *xs)
1184
0
{
1185
0
    return xs->cert_crl;
1186
0
}
1187
1188
void X509_STORE_set_check_policy(X509_STORE *xs,
1189
    X509_STORE_CTX_check_policy_fn check_policy)
1190
0
{
1191
0
    xs->check_policy = check_policy;
1192
0
}
1193
1194
X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *xs)
1195
0
{
1196
0
    return xs->check_policy;
1197
0
}
1198
1199
void X509_STORE_set_lookup_certs(X509_STORE *xs,
1200
    X509_STORE_CTX_lookup_certs_fn lookup_certs)
1201
0
{
1202
0
    xs->lookup_certs = lookup_certs;
1203
0
}
1204
1205
X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *xs)
1206
0
{
1207
0
    return xs->lookup_certs;
1208
0
}
1209
1210
void X509_STORE_set_lookup_crls(X509_STORE *xs,
1211
    X509_STORE_CTX_lookup_crls_fn lookup_crls)
1212
0
{
1213
0
    xs->lookup_crls = lookup_crls;
1214
0
}
1215
1216
X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *xs)
1217
0
{
1218
0
    return xs->lookup_crls;
1219
0
}
1220
1221
void X509_STORE_set_cleanup(X509_STORE *xs,
1222
    X509_STORE_CTX_cleanup_fn cleanup)
1223
0
{
1224
0
    xs->cleanup = cleanup;
1225
0
}
1226
1227
X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *xs)
1228
0
{
1229
0
    return xs->cleanup;
1230
0
}
1231
1232
int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data)
1233
0
{
1234
0
    return CRYPTO_set_ex_data(&xs->ex_data, idx, data);
1235
0
}
1236
1237
void *X509_STORE_get_ex_data(const X509_STORE *xs, int idx)
1238
0
{
1239
0
    return CRYPTO_get_ex_data(&xs->ex_data, idx);
1240
0
}
1241
1242
X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx)
1243
0
{
1244
0
    return ctx->store;
1245
0
}