Coverage Report

Created: 2024-11-21 07:03

/src/openssl/crypto/core_fetch.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2019-2021 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 <stddef.h>
11
12
#include <openssl/core.h>
13
#include "internal/cryptlib.h"
14
#include "internal/core.h"
15
#include "internal/property.h"
16
#include "internal/provider.h"
17
18
struct construct_data_st {
19
    OSSL_LIB_CTX *libctx;
20
    OSSL_METHOD_STORE *store;
21
    int operation_id;
22
    int force_store;
23
    OSSL_METHOD_CONSTRUCT_METHOD *mcm;
24
    void *mcm_data;
25
};
26
27
static int is_temporary_method_store(int no_store, void *cbdata)
28
6.21k
{
29
6.21k
    struct construct_data_st *data = cbdata;
30
31
6.21k
    return no_store && !data->force_store;
32
6.21k
}
33
34
static int ossl_method_construct_reserve_store(int no_store, void *cbdata)
35
3.09k
{
36
3.09k
    struct construct_data_st *data = cbdata;
37
38
3.09k
    if (is_temporary_method_store(no_store, data) && data->store == NULL) {
39
        /*
40
         * If we have been told not to store the method "permanently", we
41
         * ask for a temporary store, and store the method there.
42
         * The owner of |data->mcm| is completely responsible for managing
43
         * that temporary store.
44
         */
45
0
        if ((data->store = data->mcm->get_tmp_store(data->mcm_data)) == NULL)
46
0
            return 0;
47
0
    }
48
49
3.09k
    return data->mcm->lock_store(data->store, data->mcm_data);
50
3.09k
}
51
52
static int ossl_method_construct_unreserve_store(void *cbdata)
53
3.09k
{
54
3.09k
    struct construct_data_st *data = cbdata;
55
56
3.09k
    return data->mcm->unlock_store(data->store, data->mcm_data);
57
3.09k
}
58
59
static int ossl_method_construct_precondition(OSSL_PROVIDER *provider,
60
                                              int operation_id, int no_store,
61
                                              void *cbdata, int *result)
62
3.09k
{
63
3.09k
    if (!ossl_assert(result != NULL)) {
64
0
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
65
0
        return 0;
66
0
    }
67
68
    /* Assume that no bits are set */
69
3.09k
    *result = 0;
70
71
    /* No flag bits for temporary stores */
72
3.09k
    if (!is_temporary_method_store(no_store, cbdata)
73
3.09k
        && !ossl_provider_test_operation_bit(provider, operation_id, result))
74
0
        return 0;
75
76
    /*
77
     * The result we get tells if methods have already been constructed.
78
     * However, we want to tell whether construction should happen (true)
79
     * or not (false), which is the opposite of what we got.
80
     */
81
3.09k
    *result = !*result;
82
83
3.09k
    return 1;
84
3.09k
}
85
86
static int ossl_method_construct_postcondition(OSSL_PROVIDER *provider,
87
                                               int operation_id, int no_store,
88
                                               void *cbdata, int *result)
89
16
{
90
16
    if (!ossl_assert(result != NULL)) {
91
0
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
92
0
        return 0;
93
0
    }
94
95
16
    *result = 1;
96
97
    /* No flag bits for temporary stores */
98
16
    return is_temporary_method_store(no_store, cbdata)
99
16
        || ossl_provider_set_operation_bit(provider, operation_id);
100
16
}
101
102
static void ossl_method_construct_this(OSSL_PROVIDER *provider,
103
                                       const OSSL_ALGORITHM *algo,
104
                                       int no_store, void *cbdata)
105
508
{
106
508
    struct construct_data_st *data = cbdata;
107
508
    void *method = NULL;
108
109
508
    if ((method = data->mcm->construct(algo, provider, data->mcm_data))
110
508
        == NULL)
111
0
        return;
112
113
    /*
114
     * Note regarding putting the method in stores:
115
     *
116
     * we don't need to care if it actually got in or not here.
117
     * If it didn't get in, it will simply not be available when
118
     * ossl_method_construct() tries to get it from the store.
119
     *
120
     * It is *expected* that the put function increments the refcnt
121
     * of the passed method.
122
     */
123
508
    data->mcm->put(data->store, method, provider, algo->algorithm_names,
124
508
                   algo->property_definition, data->mcm_data);
125
126
    /* refcnt-- because we're dropping the reference */
127
508
    data->mcm->destruct(method, data->mcm_data);
128
508
}
129
130
void *ossl_method_construct(OSSL_LIB_CTX *libctx, int operation_id,
131
                            OSSL_PROVIDER **provider_rw, int force_store,
132
                            OSSL_METHOD_CONSTRUCT_METHOD *mcm, void *mcm_data)
133
3.09k
{
134
3.09k
    void *method = NULL;
135
3.09k
    OSSL_PROVIDER *provider = provider_rw != NULL ? *provider_rw : NULL;
136
3.09k
    struct construct_data_st cbdata;
137
138
    /*
139
     * We might be tempted to try to look into the method store without
140
     * constructing to see if we can find our method there already.
141
     * Unfortunately that does not work well if the query contains
142
     * optional properties as newly loaded providers can match them better.
143
     * We trust that ossl_method_construct_precondition() and
144
     * ossl_method_construct_postcondition() make sure that the
145
     * ossl_algorithm_do_all() does very little when methods from
146
     * a provider have already been constructed.
147
     */
148
149
3.09k
    cbdata.store = NULL;
150
3.09k
    cbdata.force_store = force_store;
151
3.09k
    cbdata.mcm = mcm;
152
3.09k
    cbdata.mcm_data = mcm_data;
153
3.09k
    ossl_algorithm_do_all(libctx, operation_id, provider,
154
3.09k
                          ossl_method_construct_precondition,
155
3.09k
                          ossl_method_construct_reserve_store,
156
3.09k
                          ossl_method_construct_this,
157
3.09k
                          ossl_method_construct_unreserve_store,
158
3.09k
                          ossl_method_construct_postcondition,
159
3.09k
                          &cbdata);
160
161
    /* If there is a temporary store, try there first */
162
3.09k
    if (cbdata.store != NULL)
163
0
        method = mcm->get(cbdata.store, (const OSSL_PROVIDER **)provider_rw,
164
0
                          mcm_data);
165
166
    /* If no method was found yet, try the global store */
167
3.09k
    if (method == NULL)
168
3.09k
        method = mcm->get(NULL, (const OSSL_PROVIDER **)provider_rw, mcm_data);
169
170
3.09k
    return method;
171
3.09k
}