]>
Commit | Line | Data |
---|---|---|
c13d2ab4 | 1 | /* |
da1c088f | 2 | * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved. |
c13d2ab4 RL |
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> | |
50cd4768 | 11 | #include <openssl/types.h> |
c13d2ab4 RL |
12 | #include <openssl/evp.h> |
13 | #include <openssl/core.h> | |
14 | #include "internal/cryptlib.h" | |
15 | #include "internal/thread_once.h" | |
c13d2ab4 RL |
16 | #include "internal/property.h" |
17 | #include "internal/core.h" | |
f7c16d48 | 18 | #include "internal/provider.h" |
baff732d | 19 | #include "internal/namemap.h" |
98d81174 | 20 | #include "crypto/decoder.h" |
706457b7 DMSP |
21 | #include "crypto/evp.h" /* evp_local.h needs it */ |
22 | #include "evp_local.h" | |
c13d2ab4 | 23 | |
695d195b RL |
24 | #define NAME_SEPARATOR ':' |
25 | ||
c13d2ab4 | 26 | /* Data to be passed through ossl_method_construct() */ |
181ea366 | 27 | struct evp_method_data_st { |
b4250010 | 28 | OSSL_LIB_CTX *libctx; |
181ea366 RL |
29 | int operation_id; /* For get_evp_method_from_store() */ |
30 | int name_id; /* For get_evp_method_from_store() */ | |
31 | const char *names; /* For get_evp_method_from_store() */ | |
32 | const char *propquery; /* For get_evp_method_from_store() */ | |
ec0ce188 | 33 | |
9067cf6c RL |
34 | OSSL_METHOD_STORE *tmp_store; /* For get_tmp_evp_method_store() */ |
35 | ||
e3a2ba75 | 36 | unsigned int flag_construct_error_occurred : 1; |
ec0ce188 | 37 | |
309a78aa RL |
38 | void *(*method_from_algorithm)(int name_id, const OSSL_ALGORITHM *, |
39 | OSSL_PROVIDER *); | |
c13d2ab4 RL |
40 | int (*refcnt_up_method)(void *method); |
41 | void (*destruct_method)(void *method); | |
42 | }; | |
43 | ||
44 | /* | |
45 | * Generic routines to fetch / create EVP methods with ossl_method_construct() | |
46 | */ | |
9067cf6c | 47 | static void *get_tmp_evp_method_store(void *data) |
c13d2ab4 | 48 | { |
9067cf6c RL |
49 | struct evp_method_data_st *methdata = data; |
50 | ||
51 | if (methdata->tmp_store == NULL) | |
52 | methdata->tmp_store = ossl_method_store_new(methdata->libctx); | |
53 | return methdata->tmp_store; | |
c13d2ab4 RL |
54 | } |
55 | ||
181ea366 | 56 | static void dealloc_tmp_evp_method_store(void *store) |
c13d2ab4 RL |
57 | { |
58 | if (store != NULL) | |
59 | ossl_method_store_free(store); | |
60 | } | |
61 | ||
b4250010 | 62 | static OSSL_METHOD_STORE *get_evp_method_store(OSSL_LIB_CTX *libctx) |
c13d2ab4 | 63 | { |
927d0566 | 64 | return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_EVP_METHOD_STORE_INDEX); |
c13d2ab4 RL |
65 | } |
66 | ||
e1eafe8c RL |
67 | static int reserve_evp_method_store(void *store, void *data) |
68 | { | |
69 | struct evp_method_data_st *methdata = data; | |
70 | ||
71 | if (store == NULL | |
72 | && (store = get_evp_method_store(methdata->libctx)) == NULL) | |
73 | return 0; | |
74 | ||
75 | return ossl_method_lock_store(store); | |
76 | } | |
77 | ||
78 | static int unreserve_evp_method_store(void *store, void *data) | |
79 | { | |
80 | struct evp_method_data_st *methdata = data; | |
81 | ||
82 | if (store == NULL | |
83 | && (store = get_evp_method_store(methdata->libctx)) == NULL) | |
84 | return 0; | |
85 | ||
86 | return ossl_method_unlock_store(store); | |
87 | } | |
88 | ||
2ccb1b4e | 89 | /* |
64f849f4 DMSP |
90 | * To identify the method in the EVP method store, we mix the name identity |
91 | * with the operation identity, under the assumption that we don't have more | |
793b0586 | 92 | * than 2^23 names or more than 2^8 operation types. |
2ccb1b4e | 93 | * |
793b0586 | 94 | * The resulting identity is a 31-bit integer, composed like this: |
2ccb1b4e | 95 | * |
793b0586 | 96 | * +---------23 bits--------+-8 bits-+ |
2ccb1b4e RL |
97 | * | name identity | op id | |
98 | * +------------------------+--------+ | |
793b0586 RL |
99 | * |
100 | * We limit this composite number to 31 bits, thus leaving the top uint32_t | |
101 | * bit always zero, to avoid negative sign extension when downshifting after | |
102 | * this number happens to be passed to an int (which happens as soon as it's | |
103 | * passed to ossl_method_store_cache_set(), and it's in that form that it | |
104 | * gets passed along to filter_on_operation_id(), defined further down. | |
2ccb1b4e | 105 | */ |
793b0586 RL |
106 | #define METHOD_ID_OPERATION_MASK 0x000000FF |
107 | #define METHOD_ID_OPERATION_MAX ((1 << 8) - 1) | |
108 | #define METHOD_ID_NAME_MASK 0x7FFFFF00 | |
109 | #define METHOD_ID_NAME_OFFSET 8 | |
110 | #define METHOD_ID_NAME_MAX ((1 << 23) - 1) | |
b418980c | 111 | static uint32_t evp_method_id(int name_id, unsigned int operation_id) |
2ccb1b4e | 112 | { |
793b0586 RL |
113 | if (!ossl_assert(name_id > 0 && name_id <= METHOD_ID_NAME_MAX) |
114 | || !ossl_assert(operation_id > 0 | |
115 | && operation_id <= METHOD_ID_OPERATION_MAX)) | |
2ccb1b4e | 116 | return 0; |
793b0586 RL |
117 | return (((name_id << METHOD_ID_NAME_OFFSET) & METHOD_ID_NAME_MASK) |
118 | | (operation_id & METHOD_ID_OPERATION_MASK)); | |
2ccb1b4e RL |
119 | } |
120 | ||
dc010ca6 RL |
121 | static void *get_evp_method_from_store(void *store, const OSSL_PROVIDER **prov, |
122 | void *data) | |
c13d2ab4 | 123 | { |
181ea366 | 124 | struct evp_method_data_st *methdata = data; |
c13d2ab4 | 125 | void *method = NULL; |
16ff70a5 | 126 | int name_id; |
f7c16d48 | 127 | uint32_t meth_id; |
c13d2ab4 | 128 | |
f7c16d48 | 129 | /* |
181ea366 RL |
130 | * get_evp_method_from_store() is only called to try and get the method |
131 | * that evp_generic_fetch() is asking for, and the operation id as well | |
132 | * as the name or name id are passed via methdata. | |
f7c16d48 | 133 | */ |
793b0586 | 134 | if ((name_id = methdata->name_id) == 0 && methdata->names != NULL) { |
6882652e | 135 | OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx); |
695d195b RL |
136 | const char *names = methdata->names; |
137 | const char *q = strchr(names, NAME_SEPARATOR); | |
138 | size_t l = (q == NULL ? strlen(names) : (size_t)(q - names)); | |
f7c16d48 RL |
139 | |
140 | if (namemap == 0) | |
141 | return NULL; | |
695d195b | 142 | name_id = ossl_namemap_name2num_n(namemap, names, l); |
f7c16d48 RL |
143 | } |
144 | ||
145 | if (name_id == 0 | |
b418980c | 146 | || (meth_id = evp_method_id(name_id, methdata->operation_id)) == 0) |
c13d2ab4 RL |
147 | return NULL; |
148 | ||
f7c16d48 | 149 | if (store == NULL |
6882652e | 150 | && (store = get_evp_method_store(methdata->libctx)) == NULL) |
2e49c054 RL |
151 | return NULL; |
152 | ||
dc010ca6 | 153 | if (!ossl_method_store_fetch(store, meth_id, methdata->propquery, prov, |
bdbf2df2 P |
154 | &method)) |
155 | return NULL; | |
c13d2ab4 RL |
156 | return method; |
157 | } | |
158 | ||
6882652e RL |
159 | static int put_evp_method_in_store(void *store, void *method, |
160 | const OSSL_PROVIDER *prov, | |
161 | const char *names, const char *propdef, | |
162 | void *data) | |
c13d2ab4 | 163 | { |
181ea366 | 164 | struct evp_method_data_st *methdata = data; |
2e49c054 | 165 | OSSL_NAMEMAP *namemap; |
f7c16d48 RL |
166 | int name_id; |
167 | uint32_t meth_id; | |
695d195b | 168 | size_t l = 0; |
dc46e3dd | 169 | |
f7c16d48 | 170 | /* |
181ea366 RL |
171 | * put_evp_method_in_store() is only called with an EVP method that was |
172 | * successfully created by construct_method() below, which means that | |
173 | * all the names should already be stored in the namemap with the same | |
174 | * numeric identity, so just use the first to get that identity. | |
f7c16d48 | 175 | */ |
695d195b RL |
176 | if (names != NULL) { |
177 | const char *q = strchr(names, NAME_SEPARATOR); | |
178 | ||
179 | l = (q == NULL ? strlen(names) : (size_t)(q - names)); | |
180 | } | |
181 | ||
6882652e | 182 | if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL |
695d195b | 183 | || (name_id = ossl_namemap_name2num_n(namemap, names, l)) == 0 |
6882652e | 184 | || (meth_id = evp_method_id(name_id, methdata->operation_id)) == 0) |
dc46e3dd | 185 | return 0; |
c13d2ab4 RL |
186 | |
187 | if (store == NULL | |
6882652e | 188 | && (store = get_evp_method_store(methdata->libctx)) == NULL) |
c13d2ab4 RL |
189 | return 0; |
190 | ||
f7c16d48 | 191 | return ossl_method_store_add(store, prov, meth_id, propdef, method, |
b1d40ddf RL |
192 | methdata->refcnt_up_method, |
193 | methdata->destruct_method); | |
c13d2ab4 RL |
194 | } |
195 | ||
f7c16d48 RL |
196 | /* |
197 | * The core fetching functionality passes the name of the implementation. | |
198 | * This function is responsible to getting an identity number for it. | |
199 | */ | |
36fa4d8a | 200 | static void *construct_evp_method(const OSSL_ALGORITHM *algodef, |
181ea366 | 201 | OSSL_PROVIDER *prov, void *data) |
c13d2ab4 | 202 | { |
f7c16d48 | 203 | /* |
181ea366 | 204 | * This function is only called if get_evp_method_from_store() returned |
f7c16d48 RL |
205 | * NULL, so it's safe to say that of all the spots to create a new |
206 | * namemap entry, this is it. Should the name already exist there, we | |
3d83c735 RL |
207 | * know that ossl_namemap_add_name() will return its corresponding |
208 | * number. | |
f7c16d48 | 209 | */ |
181ea366 | 210 | struct evp_method_data_st *methdata = data; |
a829b735 | 211 | OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov); |
f7c16d48 | 212 | OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx); |
36fa4d8a | 213 | const char *names = algodef->algorithm_names; |
3d83c735 | 214 | int name_id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR); |
ec0ce188 | 215 | void *method; |
c13d2ab4 | 216 | |
695d195b RL |
217 | if (name_id == 0) |
218 | return NULL; | |
ec0ce188 | 219 | |
309a78aa | 220 | method = methdata->method_from_algorithm(name_id, algodef, prov); |
ec0ce188 RL |
221 | |
222 | /* | |
223 | * Flag to indicate that there was actual construction errors. This | |
224 | * helps inner_evp_generic_fetch() determine what error it should | |
225 | * record on inaccessible algorithms. | |
226 | */ | |
227 | if (method == NULL) | |
e3a2ba75 | 228 | methdata->flag_construct_error_occurred = 1; |
ec0ce188 RL |
229 | |
230 | return method; | |
c13d2ab4 RL |
231 | } |
232 | ||
181ea366 | 233 | static void destruct_evp_method(void *method, void *data) |
c13d2ab4 | 234 | { |
181ea366 | 235 | struct evp_method_data_st *methdata = data; |
c13d2ab4 RL |
236 | |
237 | methdata->destruct_method(method); | |
238 | } | |
239 | ||
181ea366 | 240 | static void * |
cfce50f7 RL |
241 | inner_evp_generic_fetch(struct evp_method_data_st *methdata, |
242 | OSSL_PROVIDER *prov, int operation_id, | |
16ff70a5 | 243 | const char *name, const char *properties, |
181ea366 | 244 | void *(*new_method)(int name_id, |
309a78aa | 245 | const OSSL_ALGORITHM *algodef, |
0ddf74bf | 246 | OSSL_PROVIDER *prov), |
181ea366 RL |
247 | int (*up_ref_method)(void *), |
248 | void (*free_method)(void *)) | |
c13d2ab4 | 249 | { |
9067cf6c RL |
250 | OSSL_METHOD_STORE *store = get_evp_method_store(methdata->libctx); |
251 | OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx); | |
af788ad6 | 252 | const char *const propq = properties != NULL ? properties : ""; |
f7c16d48 | 253 | uint32_t meth_id = 0; |
c13d2ab4 | 254 | void *method = NULL; |
16ff70a5 | 255 | int unsupported, name_id; |
c13d2ab4 | 256 | |
ec0ce188 | 257 | if (store == NULL || namemap == NULL) { |
d6d42cda | 258 | ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_INVALID_ARGUMENT); |
e019da7b | 259 | return NULL; |
ec0ce188 | 260 | } |
e019da7b | 261 | |
2ccb1b4e RL |
262 | /* |
263 | * If there's ever an operation_id == 0 passed, we have an internal | |
264 | * programming error. | |
265 | */ | |
ec0ce188 | 266 | if (!ossl_assert(operation_id > 0)) { |
d6d42cda | 267 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); |
2ccb1b4e | 268 | return NULL; |
ec0ce188 | 269 | } |
2ccb1b4e | 270 | |
f7c16d48 | 271 | /* If we haven't received a name id yet, try to get one for the name */ |
16ff70a5 | 272 | name_id = name != NULL ? ossl_namemap_name2num(namemap, name) : 0; |
f7c16d48 RL |
273 | |
274 | /* | |
181ea366 | 275 | * If we have a name id, calculate a method id with evp_method_id(). |
f7c16d48 | 276 | * |
181ea366 RL |
277 | * evp_method_id returns 0 if we have too many operations (more than |
278 | * about 2^8) or too many names (more than about 2^24). In that case, | |
279 | * we can't create any new method. | |
ec0ce188 | 280 | * For all intents and purposes, this is an internal error. |
2ccb1b4e | 281 | */ |
ec0ce188 | 282 | if (name_id != 0 && (meth_id = evp_method_id(name_id, operation_id)) == 0) { |
d6d42cda | 283 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); |
2ccb1b4e | 284 | return NULL; |
ec0ce188 RL |
285 | } |
286 | ||
287 | /* | |
288 | * If we haven't found the name yet, chances are that the algorithm to | |
289 | * be fetched is unsupported. | |
290 | */ | |
16ff70a5 | 291 | unsupported = name_id == 0; |
2ccb1b4e | 292 | |
f7c16d48 | 293 | if (meth_id == 0 |
af788ad6 | 294 | || !ossl_method_store_cache_get(store, prov, meth_id, propq, &method)) { |
c13d2ab4 | 295 | OSSL_METHOD_CONSTRUCT_METHOD mcm = { |
9067cf6c | 296 | get_tmp_evp_method_store, |
e1eafe8c RL |
297 | reserve_evp_method_store, |
298 | unreserve_evp_method_store, | |
181ea366 RL |
299 | get_evp_method_from_store, |
300 | put_evp_method_in_store, | |
301 | construct_evp_method, | |
302 | destruct_evp_method | |
c13d2ab4 | 303 | }; |
9067cf6c | 304 | |
9067cf6c RL |
305 | methdata->operation_id = operation_id; |
306 | methdata->name_id = name_id; | |
307 | methdata->names = name; | |
af788ad6 | 308 | methdata->propquery = propq; |
9067cf6c RL |
309 | methdata->method_from_algorithm = new_method; |
310 | methdata->refcnt_up_method = up_ref_method; | |
311 | methdata->destruct_method = free_method; | |
312 | methdata->flag_construct_error_occurred = 0; | |
313 | if ((method = ossl_method_construct(methdata->libctx, operation_id, | |
dc010ca6 | 314 | &prov, 0 /* !force_cache */, |
9067cf6c | 315 | &mcm, methdata)) != NULL) { |
2ccb1b4e RL |
316 | /* |
317 | * If construction did create a method for us, we know that | |
181ea366 RL |
318 | * there is a correct name_id and meth_id, since those have |
319 | * already been calculated in get_evp_method_from_store() and | |
320 | * put_evp_method_in_store() above. | |
94be985c NH |
321 | * Note that there is a corner case here, in which, if a user |
322 | * passes a name of the form name1:name2:..., then the construction | |
323 | * will create a method against all names, but the lookup will fail | |
324 | * as ossl_namemap_name2num treats the name string as a single name | |
325 | * rather than introducing new features where in the EVP_<obj>_fetch | |
f7241edd | 326 | * parses the string and queries for each, return an error. |
2ccb1b4e | 327 | */ |
f7c16d48 RL |
328 | if (name_id == 0) |
329 | name_id = ossl_namemap_name2num(namemap, name); | |
94be985c NH |
330 | if (name_id == 0) { |
331 | ERR_raise_data(ERR_LIB_EVP, ERR_R_FETCH_FAILED, | |
332 | "Algorithm %s cannot be found", name); | |
333 | free_method(method); | |
334 | method = NULL; | |
335 | } else { | |
336 | meth_id = evp_method_id(name_id, operation_id); | |
da840c37 | 337 | if (meth_id != 0) |
94be985c NH |
338 | ossl_method_store_cache_set(store, prov, meth_id, propq, |
339 | method, up_ref_method, free_method); | |
340 | } | |
2ccb1b4e | 341 | } |
ec0ce188 RL |
342 | |
343 | /* | |
344 | * If we never were in the constructor, the algorithm to be fetched | |
345 | * is unsupported. | |
346 | */ | |
9067cf6c | 347 | unsupported = !methdata->flag_construct_error_occurred; |
c13d2ab4 RL |
348 | } |
349 | ||
793b0586 | 350 | if ((name_id != 0 || name != NULL) && method == NULL) { |
d6d42cda | 351 | int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED; |
cb929645 | 352 | |
ec0ce188 RL |
353 | if (name == NULL) |
354 | name = ossl_namemap_num2name(namemap, name_id, 0); | |
355 | ERR_raise_data(ERR_LIB_EVP, code, | |
356 | "%s, Algorithm (%s : %d), Properties (%s)", | |
9067cf6c | 357 | ossl_lib_ctx_get_descriptor(methdata->libctx), |
ef9909f3 | 358 | name == NULL ? "<null>" : name, name_id, |
ec0ce188 RL |
359 | properties == NULL ? "<null>" : properties); |
360 | } | |
361 | ||
362 | return method; | |
cfbd76c1 | 363 | } |
cfbd76c1 | 364 | |
b4250010 | 365 | void *evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id, |
f7c16d48 RL |
366 | const char *name, const char *properties, |
367 | void *(*new_method)(int name_id, | |
309a78aa | 368 | const OSSL_ALGORITHM *algodef, |
0ddf74bf | 369 | OSSL_PROVIDER *prov), |
f7c16d48 RL |
370 | int (*up_ref_method)(void *), |
371 | void (*free_method)(void *)) | |
372 | { | |
9067cf6c RL |
373 | struct evp_method_data_st methdata; |
374 | void *method; | |
375 | ||
376 | methdata.libctx = libctx; | |
377 | methdata.tmp_store = NULL; | |
cfce50f7 | 378 | method = inner_evp_generic_fetch(&methdata, NULL, operation_id, |
16ff70a5 | 379 | name, properties, |
9067cf6c RL |
380 | new_method, up_ref_method, free_method); |
381 | dealloc_tmp_evp_method_store(methdata.tmp_store); | |
382 | return method; | |
f7c16d48 RL |
383 | } |
384 | ||
2fd3392c RL |
385 | /* |
386 | * evp_generic_fetch_from_prov() is special, and only returns methods from | |
387 | * the given provider. | |
388 | * This is meant to be used when one method needs to fetch an associated | |
389 | * method. | |
390 | */ | |
391 | void *evp_generic_fetch_from_prov(OSSL_PROVIDER *prov, int operation_id, | |
392 | const char *name, const char *properties, | |
393 | void *(*new_method)(int name_id, | |
394 | const OSSL_ALGORITHM *algodef, | |
395 | OSSL_PROVIDER *prov), | |
396 | int (*up_ref_method)(void *), | |
397 | void (*free_method)(void *)) | |
398 | { | |
399 | struct evp_method_data_st methdata; | |
400 | void *method; | |
401 | ||
402 | methdata.libctx = ossl_provider_libctx(prov); | |
403 | methdata.tmp_store = NULL; | |
404 | method = inner_evp_generic_fetch(&methdata, prov, operation_id, | |
16ff70a5 | 405 | name, properties, |
2fd3392c RL |
406 | new_method, up_ref_method, free_method); |
407 | dealloc_tmp_evp_method_store(methdata.tmp_store); | |
408 | return method; | |
409 | } | |
410 | ||
60640d79 | 411 | int evp_method_store_cache_flush(OSSL_LIB_CTX *libctx) |
04cb5ec0 SL |
412 | { |
413 | OSSL_METHOD_STORE *store = get_evp_method_store(libctx); | |
414 | ||
415 | if (store != NULL) | |
60640d79 | 416 | return ossl_method_store_cache_flush_all(store); |
860ecfd7 | 417 | return 1; |
04cb5ec0 SL |
418 | } |
419 | ||
2e4d0677 RL |
420 | int evp_method_store_remove_all_provided(const OSSL_PROVIDER *prov) |
421 | { | |
422 | OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov); | |
423 | OSSL_METHOD_STORE *store = get_evp_method_store(libctx); | |
424 | ||
425 | if (store != NULL) | |
426 | return ossl_method_store_remove_all_provided(store, prov); | |
427 | return 1; | |
428 | } | |
429 | ||
b4250010 | 430 | static int evp_set_parsed_default_properties(OSSL_LIB_CTX *libctx, |
e6c54619 | 431 | OSSL_PROPERTY_LIST *def_prop, |
b1c053ac MC |
432 | int loadconfig, |
433 | int mirrored) | |
cb929645 | 434 | { |
181ea366 | 435 | OSSL_METHOD_STORE *store = get_evp_method_store(libctx); |
e6c54619 | 436 | OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig); |
f9e504e8 | 437 | |
447588b6 | 438 | if (plp != NULL && store != NULL) { |
32d3c3ab | 439 | int ret; |
b1c053ac | 440 | #ifndef FIPS_MODULE |
447588b6 MC |
441 | char *propstr = NULL; |
442 | size_t strsz; | |
443 | ||
b1c053ac MC |
444 | if (mirrored) { |
445 | if (ossl_global_properties_no_mirrored(libctx)) | |
446 | return 0; | |
447 | } else { | |
448 | /* | |
449 | * These properties have been explicitly set on this libctx, so | |
450 | * don't allow any mirroring from a parent libctx. | |
451 | */ | |
452 | ossl_global_properties_stop_mirroring(libctx); | |
453 | } | |
454 | ||
447588b6 MC |
455 | strsz = ossl_property_list_to_string(libctx, def_prop, NULL, 0); |
456 | if (strsz > 0) | |
457 | propstr = OPENSSL_malloc(strsz); | |
458 | if (propstr == NULL) { | |
459 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); | |
460 | return 0; | |
461 | } | |
462 | if (ossl_property_list_to_string(libctx, def_prop, propstr, | |
463 | strsz) == 0) { | |
464 | OPENSSL_free(propstr); | |
465 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); | |
466 | return 0; | |
467 | } | |
447588b6 MC |
468 | ossl_provider_default_props_update(libctx, propstr); |
469 | OPENSSL_free(propstr); | |
b1c053ac MC |
470 | #endif |
471 | ossl_property_free(*plp); | |
472 | *plp = def_prop; | |
32d3c3ab MC |
473 | |
474 | ret = ossl_method_store_cache_flush_all(store); | |
475 | #ifndef FIPS_MODULE | |
476 | ossl_decoder_cache_flush(libctx); | |
477 | #endif | |
478 | return ret; | |
f9e504e8 | 479 | } |
9311d0c4 | 480 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); |
cb929645 RL |
481 | return 0; |
482 | } | |
3d96a51c | 483 | |
b4250010 | 484 | int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq, |
b1c053ac | 485 | int loadconfig, int mirrored) |
f9e504e8 P |
486 | { |
487 | OSSL_PROPERTY_LIST *pl = NULL; | |
488 | ||
1e08f3ba | 489 | if (propq != NULL && (pl = ossl_parse_query(libctx, propq, 1)) == NULL) { |
9311d0c4 | 490 | ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR); |
f9e504e8 P |
491 | return 0; |
492 | } | |
b1c053ac | 493 | if (!evp_set_parsed_default_properties(libctx, pl, loadconfig, mirrored)) { |
e2ed740e MC |
494 | ossl_property_free(pl); |
495 | return 0; | |
496 | } | |
497 | return 1; | |
f9e504e8 P |
498 | } |
499 | ||
b4250010 | 500 | int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq) |
e6c54619 | 501 | { |
b1c053ac | 502 | return evp_set_default_properties_int(libctx, propq, 1, 0); |
e6c54619 | 503 | } |
e0624f0d | 504 | |
589fbc18 MC |
505 | static int evp_default_properties_merge(OSSL_LIB_CTX *libctx, const char *propq, |
506 | int loadconfig) | |
e0624f0d | 507 | { |
589fbc18 | 508 | OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig); |
f9e504e8 P |
509 | OSSL_PROPERTY_LIST *pl1, *pl2; |
510 | ||
511 | if (propq == NULL) | |
512 | return 1; | |
513 | if (plp == NULL || *plp == NULL) | |
589fbc18 | 514 | return evp_set_default_properties_int(libctx, propq, 0, 0); |
1e08f3ba | 515 | if ((pl1 = ossl_parse_query(libctx, propq, 1)) == NULL) { |
9311d0c4 | 516 | ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR); |
f9e504e8 P |
517 | return 0; |
518 | } | |
519 | pl2 = ossl_property_merge(pl1, *plp); | |
520 | ossl_property_free(pl1); | |
521 | if (pl2 == NULL) { | |
e077455e | 522 | ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB); |
f9e504e8 P |
523 | return 0; |
524 | } | |
b1c053ac | 525 | if (!evp_set_parsed_default_properties(libctx, pl2, 0, 0)) { |
e2ed740e MC |
526 | ossl_property_free(pl2); |
527 | return 0; | |
528 | } | |
529 | return 1; | |
e0624f0d SL |
530 | } |
531 | ||
b4250010 | 532 | static int evp_default_property_is_enabled(OSSL_LIB_CTX *libctx, |
e0624f0d SL |
533 | const char *prop_name) |
534 | { | |
e6c54619 | 535 | OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, 1); |
e0624f0d | 536 | |
f9e504e8 | 537 | return plp != NULL && ossl_property_is_enabled(libctx, prop_name, *plp); |
e0624f0d SL |
538 | } |
539 | ||
b4250010 | 540 | int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx) |
e0624f0d SL |
541 | { |
542 | return evp_default_property_is_enabled(libctx, "fips"); | |
543 | } | |
544 | ||
589fbc18 MC |
545 | int evp_default_properties_enable_fips_int(OSSL_LIB_CTX *libctx, int enable, |
546 | int loadconfig) | |
e0624f0d SL |
547 | { |
548 | const char *query = (enable != 0) ? "fips=yes" : "-fips"; | |
549 | ||
589fbc18 MC |
550 | return evp_default_properties_merge(libctx, query, loadconfig); |
551 | } | |
552 | ||
553 | int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable) | |
554 | { | |
555 | return evp_default_properties_enable_fips_int(libctx, enable, 1); | |
e0624f0d SL |
556 | } |
557 | ||
447588b6 MC |
558 | char *evp_get_global_properties_str(OSSL_LIB_CTX *libctx, int loadconfig) |
559 | { | |
560 | OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig); | |
561 | char *propstr = NULL; | |
562 | size_t sz; | |
563 | ||
72f62f44 P |
564 | if (plp == NULL) |
565 | return OPENSSL_strdup(""); | |
566 | ||
447588b6 MC |
567 | sz = ossl_property_list_to_string(libctx, *plp, NULL, 0); |
568 | if (sz == 0) { | |
569 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); | |
570 | return NULL; | |
571 | } | |
572 | ||
573 | propstr = OPENSSL_malloc(sz); | |
e077455e | 574 | if (propstr == NULL) |
447588b6 | 575 | return NULL; |
447588b6 MC |
576 | if (ossl_property_list_to_string(libctx, *plp, propstr, sz) == 0) { |
577 | ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); | |
578 | OPENSSL_free(propstr); | |
579 | return NULL; | |
580 | } | |
581 | return propstr; | |
582 | } | |
e0624f0d | 583 | |
793b0586 RL |
584 | struct filter_data_st { |
585 | int operation_id; | |
3d96a51c RL |
586 | void (*user_fn)(void *method, void *arg); |
587 | void *user_arg; | |
3d96a51c RL |
588 | }; |
589 | ||
793b0586 | 590 | static void filter_on_operation_id(int id, void *method, void *arg) |
3d96a51c | 591 | { |
793b0586 | 592 | struct filter_data_st *data = arg; |
3d96a51c | 593 | |
793b0586 | 594 | if ((id & METHOD_ID_OPERATION_MASK) == data->operation_id) |
3d96a51c | 595 | data->user_fn(method, data->user_arg); |
3d96a51c RL |
596 | } |
597 | ||
b4250010 | 598 | void evp_generic_do_all(OSSL_LIB_CTX *libctx, int operation_id, |
3d96a51c RL |
599 | void (*user_fn)(void *method, void *arg), |
600 | void *user_arg, | |
f7c16d48 | 601 | void *(*new_method)(int name_id, |
309a78aa | 602 | const OSSL_ALGORITHM *algodef, |
0ddf74bf | 603 | OSSL_PROVIDER *prov), |
793b0586 | 604 | int (*up_ref_method)(void *), |
3d96a51c RL |
605 | void (*free_method)(void *)) |
606 | { | |
793b0586 RL |
607 | struct evp_method_data_st methdata; |
608 | struct filter_data_st data; | |
609 | ||
610 | methdata.libctx = libctx; | |
611 | methdata.tmp_store = NULL; | |
16ff70a5 | 612 | (void)inner_evp_generic_fetch(&methdata, NULL, operation_id, NULL, NULL, |
793b0586 | 613 | new_method, up_ref_method, free_method); |
3d96a51c | 614 | |
793b0586 | 615 | data.operation_id = operation_id; |
3d96a51c RL |
616 | data.user_fn = user_fn; |
617 | data.user_arg = user_arg; | |
793b0586 RL |
618 | if (methdata.tmp_store != NULL) |
619 | ossl_method_store_do_all(methdata.tmp_store, &filter_on_operation_id, | |
620 | &data); | |
621 | ossl_method_store_do_all(get_evp_method_store(libctx), | |
622 | &filter_on_operation_id, &data); | |
623 | dealloc_tmp_evp_method_store(methdata.tmp_store); | |
3d96a51c | 624 | } |
f7c16d48 | 625 | |
e4a1d023 RL |
626 | int evp_is_a(OSSL_PROVIDER *prov, int number, |
627 | const char *legacy_name, const char *name) | |
7cfa1717 | 628 | { |
e4a1d023 RL |
629 | /* |
630 | * For a |prov| that is NULL, the library context will be NULL | |
631 | */ | |
a829b735 | 632 | OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov); |
7cfa1717 RL |
633 | OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx); |
634 | ||
e4a1d023 RL |
635 | if (prov == NULL) |
636 | number = ossl_namemap_name2num(namemap, legacy_name); | |
7cfa1717 RL |
637 | return ossl_namemap_name2num(namemap, name) == number; |
638 | } | |
32040838 | 639 | |
d84f5515 MC |
640 | int evp_names_do_all(OSSL_PROVIDER *prov, int number, |
641 | void (*fn)(const char *name, void *data), | |
642 | void *data) | |
32040838 | 643 | { |
a829b735 | 644 | OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov); |
32040838 RL |
645 | OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx); |
646 | ||
d84f5515 | 647 | return ossl_namemap_doall_names(namemap, number, fn, data); |
32040838 | 648 | } |