]> git.ipfire.org Git - thirdparty/openssl.git/blob - crypto/evp/evp_fetch.c
Don't hold a lock when calling a callback in ossl_namemap_doall_names
[thirdparty/openssl.git] / crypto / evp / evp_fetch.c
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 #include <openssl/types.h>
12 #include <openssl/evp.h>
13 #include <openssl/core.h>
14 #include "internal/cryptlib.h"
15 #include "internal/thread_once.h"
16 #include "internal/property.h"
17 #include "internal/core.h"
18 #include "internal/provider.h"
19 #include "internal/namemap.h"
20 #include "internal/property.h"
21 #include "crypto/evp.h" /* evp_local.h needs it */
22 #include "evp_local.h"
23
24 #define NAME_SEPARATOR ':'
25
26 static void evp_method_store_free(void *vstore)
27 {
28 ossl_method_store_free(vstore);
29 }
30
31 static void *evp_method_store_new(OSSL_LIB_CTX *ctx)
32 {
33 return ossl_method_store_new(ctx);
34 }
35
36
37 static const OSSL_LIB_CTX_METHOD evp_method_store_method = {
38 evp_method_store_new,
39 evp_method_store_free,
40 };
41
42 /* Data to be passed through ossl_method_construct() */
43 struct evp_method_data_st {
44 OSSL_LIB_CTX *libctx;
45 OSSL_METHOD_CONSTRUCT_METHOD *mcm;
46 int operation_id; /* For get_evp_method_from_store() */
47 int name_id; /* For get_evp_method_from_store() */
48 const char *names; /* For get_evp_method_from_store() */
49 const char *propquery; /* For get_evp_method_from_store() */
50
51 unsigned int flag_construct_error_occured : 1;
52
53 void *(*method_from_dispatch)(int name_id, const OSSL_DISPATCH *,
54 OSSL_PROVIDER *);
55 int (*refcnt_up_method)(void *method);
56 void (*destruct_method)(void *method);
57 };
58
59 /*
60 * Generic routines to fetch / create EVP methods with ossl_method_construct()
61 */
62 static void *alloc_tmp_evp_method_store(OSSL_LIB_CTX *ctx)
63 {
64 return ossl_method_store_new(ctx);
65 }
66
67 static void dealloc_tmp_evp_method_store(void *store)
68 {
69 if (store != NULL)
70 ossl_method_store_free(store);
71 }
72
73 static OSSL_METHOD_STORE *get_evp_method_store(OSSL_LIB_CTX *libctx)
74 {
75 return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_EVP_METHOD_STORE_INDEX,
76 &evp_method_store_method);
77 }
78
79 /*
80 * To identify the method in the EVP method store, we mix the name identity
81 * with the operation identity, under the assumption that we don't have more
82 * than 2^24 names or more than 2^8 operation types.
83 *
84 * The resulting identity is a 32-bit integer, composed like this:
85 *
86 * +---------24 bits--------+-8 bits-+
87 * | name identity | op id |
88 * +------------------------+--------+
89 */
90 static uint32_t evp_method_id(int name_id, unsigned int operation_id)
91 {
92 if (!ossl_assert(name_id > 0 && name_id < (1 << 24))
93 || !ossl_assert(operation_id > 0 && operation_id < (1 << 8)))
94 return 0;
95 return ((name_id << 8) & 0xFFFFFF00) | (operation_id & 0x000000FF);
96 }
97
98 static void *get_evp_method_from_store(OSSL_LIB_CTX *libctx, void *store,
99 void *data)
100 {
101 struct evp_method_data_st *methdata = data;
102 void *method = NULL;
103 int name_id;
104 uint32_t meth_id;
105
106 /*
107 * get_evp_method_from_store() is only called to try and get the method
108 * that evp_generic_fetch() is asking for, and the operation id as well
109 * as the name or name id are passed via methdata.
110 */
111 if ((name_id = methdata->name_id) == 0) {
112 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
113 const char *names = methdata->names;
114 const char *q = strchr(names, NAME_SEPARATOR);
115 size_t l = (q == NULL ? strlen(names) : (size_t)(q - names));
116
117 if (namemap == 0)
118 return NULL;
119 name_id = ossl_namemap_name2num_n(namemap, names, l);
120 }
121
122 if (name_id == 0
123 || (meth_id = evp_method_id(name_id, methdata->operation_id)) == 0)
124 return NULL;
125
126 if (store == NULL
127 && (store = get_evp_method_store(libctx)) == NULL)
128 return NULL;
129
130 if (!ossl_method_store_fetch(store, meth_id, methdata->propquery,
131 &method))
132 return NULL;
133 return method;
134 }
135
136 static int put_evp_method_in_store(OSSL_LIB_CTX *libctx, void *store,
137 void *method, const OSSL_PROVIDER *prov,
138 int operation_id, const char *names,
139 const char *propdef, void *data)
140 {
141 struct evp_method_data_st *methdata = data;
142 OSSL_NAMEMAP *namemap;
143 int name_id;
144 uint32_t meth_id;
145 size_t l = 0;
146
147 /*
148 * put_evp_method_in_store() is only called with an EVP method that was
149 * successfully created by construct_method() below, which means that
150 * all the names should already be stored in the namemap with the same
151 * numeric identity, so just use the first to get that identity.
152 */
153 if (names != NULL) {
154 const char *q = strchr(names, NAME_SEPARATOR);
155
156 l = (q == NULL ? strlen(names) : (size_t)(q - names));
157 }
158
159 if ((namemap = ossl_namemap_stored(libctx)) == NULL
160 || (name_id = ossl_namemap_name2num_n(namemap, names, l)) == 0
161 || (meth_id = evp_method_id(name_id, operation_id)) == 0)
162 return 0;
163
164 if (store == NULL
165 && (store = get_evp_method_store(libctx)) == NULL)
166 return 0;
167
168 return ossl_method_store_add(store, prov, meth_id, propdef, method,
169 methdata->refcnt_up_method,
170 methdata->destruct_method);
171 }
172
173 /*
174 * The core fetching functionality passes the name of the implementation.
175 * This function is responsible to getting an identity number for it.
176 */
177 static void *construct_evp_method(const OSSL_ALGORITHM *algodef,
178 OSSL_PROVIDER *prov, void *data)
179 {
180 /*
181 * This function is only called if get_evp_method_from_store() returned
182 * NULL, so it's safe to say that of all the spots to create a new
183 * namemap entry, this is it. Should the name already exist there, we
184 * know that ossl_namemap_add_name() will return its corresponding
185 * number.
186 */
187 struct evp_method_data_st *methdata = data;
188 OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
189 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
190 const char *names = algodef->algorithm_names;
191 int name_id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
192 void *method;
193
194 if (name_id == 0)
195 return NULL;
196
197 method = methdata->method_from_dispatch(name_id, algodef->implementation,
198 prov);
199
200 /*
201 * Flag to indicate that there was actual construction errors. This
202 * helps inner_evp_generic_fetch() determine what error it should
203 * record on inaccessible algorithms.
204 */
205 if (method == NULL)
206 methdata->flag_construct_error_occured = 1;
207
208 return method;
209 }
210
211 static void destruct_evp_method(void *method, void *data)
212 {
213 struct evp_method_data_st *methdata = data;
214
215 methdata->destruct_method(method);
216 }
217
218 static void *
219 inner_evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id,
220 int name_id, const char *name,
221 const char *properties,
222 void *(*new_method)(int name_id,
223 const OSSL_DISPATCH *fns,
224 OSSL_PROVIDER *prov),
225 int (*up_ref_method)(void *),
226 void (*free_method)(void *))
227 {
228 OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
229 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
230 uint32_t meth_id = 0;
231 void *method = NULL;
232 int unsupported = 0;
233
234 if (store == NULL || namemap == NULL) {
235 ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_INVALID_ARGUMENT);
236 return NULL;
237 }
238
239 /*
240 * If there's ever an operation_id == 0 passed, we have an internal
241 * programming error.
242 */
243 if (!ossl_assert(operation_id > 0)) {
244 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
245 return NULL;
246 }
247
248 /*
249 * If we have been passed neither a name_id or a name, we have an
250 * internal programming error.
251 */
252 if (!ossl_assert(name_id != 0 || name != NULL)) {
253 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
254 return NULL;
255 }
256
257 /* If we haven't received a name id yet, try to get one for the name */
258 if (name_id == 0)
259 name_id = ossl_namemap_name2num(namemap, name);
260
261 /*
262 * If we have a name id, calculate a method id with evp_method_id().
263 *
264 * evp_method_id returns 0 if we have too many operations (more than
265 * about 2^8) or too many names (more than about 2^24). In that case,
266 * we can't create any new method.
267 * For all intents and purposes, this is an internal error.
268 */
269 if (name_id != 0 && (meth_id = evp_method_id(name_id, operation_id)) == 0) {
270 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
271 return NULL;
272 }
273
274 /*
275 * If we haven't found the name yet, chances are that the algorithm to
276 * be fetched is unsupported.
277 */
278 if (name_id == 0)
279 unsupported = 1;
280
281 if (meth_id == 0
282 || !ossl_method_store_cache_get(store, meth_id, properties, &method)) {
283 OSSL_METHOD_CONSTRUCT_METHOD mcm = {
284 alloc_tmp_evp_method_store,
285 dealloc_tmp_evp_method_store,
286 get_evp_method_from_store,
287 put_evp_method_in_store,
288 construct_evp_method,
289 destruct_evp_method
290 };
291 struct evp_method_data_st mcmdata;
292
293 mcmdata.mcm = &mcm;
294 mcmdata.libctx = libctx;
295 mcmdata.operation_id = operation_id;
296 mcmdata.name_id = name_id;
297 mcmdata.names = name;
298 mcmdata.propquery = properties;
299 mcmdata.method_from_dispatch = new_method;
300 mcmdata.refcnt_up_method = up_ref_method;
301 mcmdata.destruct_method = free_method;
302 mcmdata.flag_construct_error_occured = 0;
303 if ((method = ossl_method_construct(libctx, operation_id,
304 0 /* !force_cache */,
305 &mcm, &mcmdata)) != NULL) {
306 /*
307 * If construction did create a method for us, we know that
308 * there is a correct name_id and meth_id, since those have
309 * already been calculated in get_evp_method_from_store() and
310 * put_evp_method_in_store() above.
311 */
312 if (name_id == 0)
313 name_id = ossl_namemap_name2num(namemap, name);
314 meth_id = evp_method_id(name_id, operation_id);
315 ossl_method_store_cache_set(store, meth_id, properties, method,
316 up_ref_method, free_method);
317 }
318
319 /*
320 * If we never were in the constructor, the algorithm to be fetched
321 * is unsupported.
322 */
323 unsupported = !mcmdata.flag_construct_error_occured;
324 }
325
326 if (method == NULL) {
327 int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
328
329 if (name == NULL)
330 name = ossl_namemap_num2name(namemap, name_id, 0);
331 ERR_raise_data(ERR_LIB_EVP, code,
332 "%s, Algorithm (%s : %d), Properties (%s)",
333 ossl_lib_ctx_get_descriptor(libctx),
334 name = NULL ? "<null>" : name, name_id,
335 properties == NULL ? "<null>" : properties);
336 }
337
338 return method;
339 }
340
341 void *evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id,
342 const char *name, const char *properties,
343 void *(*new_method)(int name_id,
344 const OSSL_DISPATCH *fns,
345 OSSL_PROVIDER *prov),
346 int (*up_ref_method)(void *),
347 void (*free_method)(void *))
348 {
349 return inner_evp_generic_fetch(libctx,
350 operation_id, 0, name, properties,
351 new_method, up_ref_method, free_method);
352 }
353
354 /*
355 * evp_generic_fetch_by_number() is special, and only returns methods for
356 * already known names, i.e. it refuses to work if no name_id can be found
357 * (it's considered an internal programming error).
358 * This is meant to be used when one method needs to fetch an associated
359 * other method.
360 */
361 void *evp_generic_fetch_by_number(OSSL_LIB_CTX *libctx, int operation_id,
362 int name_id, const char *properties,
363 void *(*new_method)(int name_id,
364 const OSSL_DISPATCH *fns,
365 OSSL_PROVIDER *prov),
366 int (*up_ref_method)(void *),
367 void (*free_method)(void *))
368 {
369 return inner_evp_generic_fetch(libctx,
370 operation_id, name_id, NULL,
371 properties, new_method, up_ref_method,
372 free_method);
373 }
374
375 void evp_method_store_flush(OSSL_LIB_CTX *libctx)
376 {
377 OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
378
379 if (store != NULL)
380 ossl_method_store_flush_cache(store, 1);
381 }
382
383 static int evp_set_parsed_default_properties(OSSL_LIB_CTX *libctx,
384 OSSL_PROPERTY_LIST *def_prop,
385 int loadconfig)
386 {
387 OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
388 OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
389
390 if (plp != NULL) {
391 ossl_property_free(*plp);
392 *plp = def_prop;
393 if (store != NULL)
394 ossl_method_store_flush_cache(store, 0);
395 return 1;
396 }
397 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
398 return 0;
399 }
400
401 int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq,
402 int loadconfig)
403 {
404 OSSL_PROPERTY_LIST *pl = NULL;
405
406 if (propq != NULL && (pl = ossl_parse_query(libctx, propq)) == NULL) {
407 ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
408 return 0;
409 }
410 return evp_set_parsed_default_properties(libctx, pl, loadconfig);
411 }
412
413 int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq)
414 {
415 return evp_set_default_properties_int(libctx, propq, 1);
416 }
417
418 static int evp_default_properties_merge(OSSL_LIB_CTX *libctx, const char *propq)
419 {
420 OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, 1);
421 OSSL_PROPERTY_LIST *pl1, *pl2;
422
423 if (propq == NULL)
424 return 1;
425 if (plp == NULL || *plp == NULL)
426 return EVP_set_default_properties(libctx, propq);
427 if ((pl1 = ossl_parse_query(libctx, propq)) == NULL) {
428 ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
429 return 0;
430 }
431 pl2 = ossl_property_merge(pl1, *plp);
432 ossl_property_free(pl1);
433 if (pl2 == NULL) {
434 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
435 return 0;
436 }
437 return evp_set_parsed_default_properties(libctx, pl2, 0);
438 }
439
440 static int evp_default_property_is_enabled(OSSL_LIB_CTX *libctx,
441 const char *prop_name)
442 {
443 OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, 1);
444
445 return plp != NULL && ossl_property_is_enabled(libctx, prop_name, *plp);
446 }
447
448 int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx)
449 {
450 return evp_default_property_is_enabled(libctx, "fips");
451 }
452
453 int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable)
454 {
455 const char *query = (enable != 0) ? "fips=yes" : "-fips";
456
457 return evp_default_properties_merge(libctx, query);
458 }
459
460
461 struct do_all_data_st {
462 void (*user_fn)(void *method, void *arg);
463 void *user_arg;
464 void *(*new_method)(const int name_id, const OSSL_DISPATCH *fns,
465 OSSL_PROVIDER *prov);
466 void (*free_method)(void *);
467 };
468
469 static void do_one(OSSL_PROVIDER *provider, const OSSL_ALGORITHM *algo,
470 int no_store, void *vdata)
471 {
472 struct do_all_data_st *data = vdata;
473 OSSL_LIB_CTX *libctx = ossl_provider_libctx(provider);
474 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
475 int name_id = ossl_namemap_add_names(namemap, 0, algo->algorithm_names,
476 NAME_SEPARATOR);
477 void *method = NULL;
478
479 if (name_id != 0)
480 method = data->new_method(name_id, algo->implementation, provider);
481
482 if (method != NULL) {
483 data->user_fn(method, data->user_arg);
484 data->free_method(method);
485 }
486 }
487
488 void evp_generic_do_all(OSSL_LIB_CTX *libctx, int operation_id,
489 void (*user_fn)(void *method, void *arg),
490 void *user_arg,
491 void *(*new_method)(int name_id,
492 const OSSL_DISPATCH *fns,
493 OSSL_PROVIDER *prov),
494 void (*free_method)(void *))
495 {
496 struct do_all_data_st data;
497
498 data.new_method = new_method;
499 data.free_method = free_method;
500 data.user_fn = user_fn;
501 data.user_arg = user_arg;
502
503 /*
504 * No pre- or post-condition for this call, as this only creates methods
505 * temporarly and then promptly destroys them.
506 */
507 ossl_algorithm_do_all(libctx, operation_id, NULL, NULL, do_one, NULL,
508 &data);
509 }
510
511 const char *evp_first_name(const OSSL_PROVIDER *prov, int name_id)
512 {
513 OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
514 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
515
516 return ossl_namemap_num2name(namemap, name_id, 0);
517 }
518
519 int evp_is_a(OSSL_PROVIDER *prov, int number,
520 const char *legacy_name, const char *name)
521 {
522 /*
523 * For a |prov| that is NULL, the library context will be NULL
524 */
525 OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
526 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
527
528 if (prov == NULL)
529 number = ossl_namemap_name2num(namemap, legacy_name);
530 return ossl_namemap_name2num(namemap, name) == number;
531 }
532
533 int evp_names_do_all(OSSL_PROVIDER *prov, int number,
534 void (*fn)(const char *name, void *data),
535 void *data)
536 {
537 OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
538 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
539
540 return ossl_namemap_doall_names(namemap, number, fn, data);
541 }