1 /*
2 * Copyright 2019-2023 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 <openssl/crypto.h>
11 #include <openssl/core_dispatch.h>
12 #include "crypto/cryptlib.h"
13 #include "prov/providercommon.h"
14 #include "internal/thread_once.h"
15 #include "crypto/context.h"
16
17 #ifdef FIPS_MODULE
18 #include "prov/provider_ctx.h"
19
20 /*
21 * Thread aware code may want to be told about thread stop events. We register
22 * to hear about those thread stop events when we see a new thread has started.
23 * We call the ossl_init_thread_start function to do that. In the FIPS provider
24 * we have our own copy of ossl_init_thread_start, which cascades notifications
25 * about threads stopping from libcrypto to all the code in the FIPS provider
26 * that needs to know about it.
27 *
28 * The FIPS provider tells libcrypto about which threads it is interested in
29 * by calling "c_thread_start" which is a function pointer created during
30 * provider initialisation (i.e. OSSL_provider_init).
31 */
32 extern OSSL_FUNC_core_thread_start_fn *c_thread_start;
33 #endif
34
35 typedef struct thread_event_handler_st THREAD_EVENT_HANDLER;
36 struct thread_event_handler_st {
37 #ifndef FIPS_MODULE
38 const void *index;
39 #endif
40 void *arg;
41 OSSL_thread_stop_handler_fn handfn;
42 THREAD_EVENT_HANDLER *next;
43 };
44
45 #ifndef FIPS_MODULE
46 DEFINE_SPECIAL_STACK_OF(THREAD_EVENT_HANDLER_PTR, THREAD_EVENT_HANDLER *)
47
48 typedef struct global_tevent_register_st GLOBAL_TEVENT_REGISTER;
49 struct global_tevent_register_st {
50 STACK_OF(THREAD_EVENT_HANDLER_PTR) *skhands;
51 CRYPTO_RWLOCK *lock;
52 };
53
54 static GLOBAL_TEVENT_REGISTER *glob_tevent_reg = NULL;
55
56 static CRYPTO_ONCE tevent_register_runonce = CRYPTO_ONCE_STATIC_INIT;
57
DEFINE_RUN_ONCE_STATIC(create_global_tevent_register)58 DEFINE_RUN_ONCE_STATIC(create_global_tevent_register)
59 {
60 glob_tevent_reg = OPENSSL_zalloc(sizeof(*glob_tevent_reg));
61 if (glob_tevent_reg == NULL)
62 return 0;
63
64 glob_tevent_reg->skhands = sk_THREAD_EVENT_HANDLER_PTR_new_null();
65 glob_tevent_reg->lock = CRYPTO_THREAD_lock_new();
66 if (glob_tevent_reg->skhands == NULL || glob_tevent_reg->lock == NULL) {
67 sk_THREAD_EVENT_HANDLER_PTR_free(glob_tevent_reg->skhands);
68 CRYPTO_THREAD_lock_free(glob_tevent_reg->lock);
69 OPENSSL_free(glob_tevent_reg);
70 glob_tevent_reg = NULL;
71 return 0;
72 }
73
74 return 1;
75 }
76
get_global_tevent_register(void)77 static GLOBAL_TEVENT_REGISTER *get_global_tevent_register(void)
78 {
79 if (!RUN_ONCE(&tevent_register_runonce, create_global_tevent_register))
80 return NULL;
81 return glob_tevent_reg;
82 }
83 #endif
84
85 #ifndef FIPS_MODULE
86 static int init_thread_push_handlers(THREAD_EVENT_HANDLER **hands);
87 static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin);
88 static void init_thread_destructor(void *hands);
89 static int init_thread_deregister(void *arg, int all);
90 #endif
91 static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands);
92
93 static THREAD_EVENT_HANDLER **
init_get_thread_local(CRYPTO_THREAD_LOCAL * local,int alloc,int keep)94 init_get_thread_local(CRYPTO_THREAD_LOCAL *local, int alloc, int keep)
95 {
96 THREAD_EVENT_HANDLER **hands = CRYPTO_THREAD_get_local(local);
97
98 if (alloc) {
99 if (hands == NULL) {
100
101 if ((hands = OPENSSL_zalloc(sizeof(*hands))) == NULL)
102 return NULL;
103
104 if (!CRYPTO_THREAD_set_local(local, hands)) {
105 OPENSSL_free(hands);
106 return NULL;
107 }
108
109 #ifndef FIPS_MODULE
110 if (!init_thread_push_handlers(hands)) {
111 CRYPTO_THREAD_set_local(local, NULL);
112 OPENSSL_free(hands);
113 return NULL;
114 }
115 #endif
116 }
117 } else if (!keep) {
118 CRYPTO_THREAD_set_local(local, NULL);
119 }
120
121 return hands;
122 }
123
124 #ifndef FIPS_MODULE
125 /*
126 * Since per-thread-specific-data destructors are not universally
127 * available, i.e. not on Windows, only below CRYPTO_THREAD_LOCAL key
128 * is assumed to have destructor associated. And then an effort is made
129 * to call this single destructor on non-pthread platform[s].
130 *
131 * Initial value is "impossible". It is used as guard value to shortcut
132 * destructor for threads terminating before libcrypto is initialized or
133 * after it's de-initialized. Access to the key doesn't have to be
134 * serialized for the said threads, because they didn't use libcrypto
135 * and it doesn't matter if they pick "impossible" or dereference real
136 * key value and pull NULL past initialization in the first thread that
137 * intends to use libcrypto.
138 */
139 static union {
140 long sane;
141 CRYPTO_THREAD_LOCAL value;
142 } destructor_key = { -1 };
143
144 /*
145 * The thread event handler list is a thread specific linked list
146 * of callback functions which are invoked in list order by the
147 * current thread in case of certain events. (Currently, there is
148 * only one type of event, the 'thread stop' event.)
149 *
150 * We also keep a global reference to that linked list, so that we
151 * can deregister handlers if necessary before all the threads are
152 * stopped.
153 */
init_thread_push_handlers(THREAD_EVENT_HANDLER ** hands)154 static int init_thread_push_handlers(THREAD_EVENT_HANDLER **hands)
155 {
156 int ret;
157 GLOBAL_TEVENT_REGISTER *gtr;
158
159 gtr = get_global_tevent_register();
160 if (gtr == NULL)
161 return 0;
162
163 if (!CRYPTO_THREAD_write_lock(gtr->lock))
164 return 0;
165 ret = (sk_THREAD_EVENT_HANDLER_PTR_push(gtr->skhands, hands) != 0);
166 CRYPTO_THREAD_unlock(gtr->lock);
167
168 return ret;
169 }
170
init_thread_remove_handlers(THREAD_EVENT_HANDLER ** handsin)171 static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin)
172 {
173 GLOBAL_TEVENT_REGISTER *gtr;
174 int i;
175
176 gtr = get_global_tevent_register();
177 if (gtr == NULL)
178 return;
179 if (!CRYPTO_THREAD_write_lock(gtr->lock))
180 return;
181 for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
182 THREAD_EVENT_HANDLER **hands
183 = sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
184
185 if (hands == handsin) {
186 sk_THREAD_EVENT_HANDLER_PTR_delete(gtr->skhands, i);
187 CRYPTO_THREAD_unlock(gtr->lock);
188 return;
189 }
190 }
191 CRYPTO_THREAD_unlock(gtr->lock);
192 return;
193 }
194
init_thread_destructor(void * hands)195 static void init_thread_destructor(void *hands)
196 {
197 init_thread_stop(NULL, (THREAD_EVENT_HANDLER **)hands);
198 init_thread_remove_handlers(hands);
199 OPENSSL_free(hands);
200 }
201
ossl_init_thread(void)202 int ossl_init_thread(void)
203 {
204 if (!CRYPTO_THREAD_init_local(&destructor_key.value,
205 init_thread_destructor))
206 return 0;
207
208 return 1;
209 }
210
ossl_cleanup_thread(void)211 void ossl_cleanup_thread(void)
212 {
213 init_thread_deregister(NULL, 1);
214 CRYPTO_THREAD_cleanup_local(&destructor_key.value);
215 destructor_key.sane = -1;
216 }
217
OPENSSL_thread_stop_ex(OSSL_LIB_CTX * ctx)218 void OPENSSL_thread_stop_ex(OSSL_LIB_CTX *ctx)
219 {
220 ctx = ossl_lib_ctx_get_concrete(ctx);
221 /*
222 * It would be nice if we could figure out a way to do this on all threads
223 * that have used the OSSL_LIB_CTX when the context is freed. This is
224 * currently not possible due to the use of thread local variables.
225 */
226 ossl_ctx_thread_stop(ctx);
227 }
228
OPENSSL_thread_stop(void)229 void OPENSSL_thread_stop(void)
230 {
231 if (destructor_key.sane != -1) {
232 THREAD_EVENT_HANDLER **hands
233 = init_get_thread_local(&destructor_key.value, 0, 0);
234 init_thread_stop(NULL, hands);
235
236 init_thread_remove_handlers(hands);
237 OPENSSL_free(hands);
238 }
239 }
240
ossl_ctx_thread_stop(OSSL_LIB_CTX * ctx)241 void ossl_ctx_thread_stop(OSSL_LIB_CTX *ctx)
242 {
243 if (destructor_key.sane != -1) {
244 THREAD_EVENT_HANDLER **hands
245 = init_get_thread_local(&destructor_key.value, 0, 1);
246 init_thread_stop(ctx, hands);
247 }
248 }
249
250 #else
251
252 static void ossl_arg_thread_stop(void *arg);
253
254 /* Register the current thread so that we are informed if it gets stopped */
ossl_thread_register_fips(OSSL_LIB_CTX * libctx)255 int ossl_thread_register_fips(OSSL_LIB_CTX *libctx)
256 {
257 return c_thread_start(FIPS_get_core_handle(libctx), ossl_arg_thread_stop,
258 libctx);
259 }
260
ossl_thread_event_ctx_new(OSSL_LIB_CTX * libctx)261 void *ossl_thread_event_ctx_new(OSSL_LIB_CTX *libctx)
262 {
263 THREAD_EVENT_HANDLER **hands = NULL;
264 CRYPTO_THREAD_LOCAL *tlocal = OPENSSL_zalloc(sizeof(*tlocal));
265
266 if (tlocal == NULL)
267 return NULL;
268
269 if (!CRYPTO_THREAD_init_local(tlocal, NULL))
270 goto deinit;
271
272 hands = OPENSSL_zalloc(sizeof(*hands));
273 if (hands == NULL)
274 goto err;
275
276 if (!CRYPTO_THREAD_set_local(tlocal, hands))
277 goto err;
278
279 /*
280 * We should ideally call ossl_thread_register_fips() here. This function
281 * is called during the startup of the FIPS provider and we need to ensure
282 * that the main thread is registered to receive thread callbacks in order
283 * to free |hands| that we allocated above. However we are too early in
284 * the FIPS provider initialisation that FIPS_get_core_handle() doesn't work
285 * yet. So we defer this to the main provider OSSL_provider_init_int()
286 * function.
287 */
288
289 return tlocal;
290 err:
291 OPENSSL_free(hands);
292 CRYPTO_THREAD_cleanup_local(tlocal);
293 deinit:
294 OPENSSL_free(tlocal);
295 return NULL;
296 }
297
ossl_thread_event_ctx_free(void * tlocal)298 void ossl_thread_event_ctx_free(void *tlocal)
299 {
300 CRYPTO_THREAD_cleanup_local(tlocal);
301 OPENSSL_free(tlocal);
302 }
303
ossl_arg_thread_stop(void * arg)304 static void ossl_arg_thread_stop(void *arg)
305 {
306 ossl_ctx_thread_stop((OSSL_LIB_CTX *)arg);
307 }
308
ossl_ctx_thread_stop(OSSL_LIB_CTX * ctx)309 void ossl_ctx_thread_stop(OSSL_LIB_CTX *ctx)
310 {
311 THREAD_EVENT_HANDLER **hands;
312 CRYPTO_THREAD_LOCAL *local
313 = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);
314
315 if (local == NULL)
316 return;
317 hands = init_get_thread_local(local, 0, 0);
318 init_thread_stop(ctx, hands);
319 OPENSSL_free(hands);
320 }
321 #endif /* FIPS_MODULE */
322
323
init_thread_stop(void * arg,THREAD_EVENT_HANDLER ** hands)324 static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands)
325 {
326 THREAD_EVENT_HANDLER *curr, *prev = NULL, *tmp;
327 #ifndef FIPS_MODULE
328 GLOBAL_TEVENT_REGISTER *gtr;
329 #endif
330
331 /* Can't do much about this */
332 if (hands == NULL)
333 return;
334
335 #ifndef FIPS_MODULE
336 gtr = get_global_tevent_register();
337 if (gtr == NULL)
338 return;
339
340 if (!CRYPTO_THREAD_write_lock(gtr->lock))
341 return;
342 #endif
343
344 curr = *hands;
345 while (curr != NULL) {
346 if (arg != NULL && curr->arg != arg) {
347 prev = curr;
348 curr = curr->next;
349 continue;
350 }
351 curr->handfn(curr->arg);
352 if (prev == NULL)
353 *hands = curr->next;
354 else
355 prev->next = curr->next;
356
357 tmp = curr;
358 curr = curr->next;
359
360 OPENSSL_free(tmp);
361 }
362 #ifndef FIPS_MODULE
363 CRYPTO_THREAD_unlock(gtr->lock);
364 #endif
365 }
366
ossl_init_thread_start(const void * index,void * arg,OSSL_thread_stop_handler_fn handfn)367 int ossl_init_thread_start(const void *index, void *arg,
368 OSSL_thread_stop_handler_fn handfn)
369 {
370 THREAD_EVENT_HANDLER **hands;
371 THREAD_EVENT_HANDLER *hand;
372 #ifdef FIPS_MODULE
373 OSSL_LIB_CTX *ctx = arg;
374
375 /*
376 * In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
377 * of OSSL_LIB_CTX and thread. This is because in FIPS mode each
378 * OSSL_LIB_CTX gets informed about thread stop events individually.
379 */
380 CRYPTO_THREAD_LOCAL *local
381 = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);
382 #else
383 /*
384 * Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
385 * thread, but may hold multiple OSSL_LIB_CTXs. We only get told about
386 * thread stop events globally, so we have to ensure all affected
387 * OSSL_LIB_CTXs are informed.
388 */
389 CRYPTO_THREAD_LOCAL *local = &destructor_key.value;
390 #endif
391
392 hands = init_get_thread_local(local, 1, 0);
393 if (hands == NULL)
394 return 0;
395
396 #ifdef FIPS_MODULE
397 if (*hands == NULL) {
398 /*
399 * We've not yet registered any handlers for this thread. We need to get
400 * libcrypto to tell us about later thread stop events. c_thread_start
401 * is a callback to libcrypto defined in fipsprov.c
402 */
403 if (!ossl_thread_register_fips(ctx))
404 return 0;
405 }
406 #endif
407
408 hand = OPENSSL_malloc(sizeof(*hand));
409 if (hand == NULL)
410 return 0;
411
412 hand->handfn = handfn;
413 hand->arg = arg;
414 #ifndef FIPS_MODULE
415 hand->index = index;
416 #endif
417 hand->next = *hands;
418 *hands = hand;
419
420 return 1;
421 }
422
423 #ifndef FIPS_MODULE
init_thread_deregister(void * index,int all)424 static int init_thread_deregister(void *index, int all)
425 {
426 GLOBAL_TEVENT_REGISTER *gtr;
427 int i;
428
429 gtr = get_global_tevent_register();
430 if (gtr == NULL)
431 return 0;
432 if (!all) {
433 if (!CRYPTO_THREAD_write_lock(gtr->lock))
434 return 0;
435 } else {
436 glob_tevent_reg = NULL;
437 }
438 for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
439 THREAD_EVENT_HANDLER **hands
440 = sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
441 THREAD_EVENT_HANDLER *curr = NULL, *prev = NULL, *tmp;
442
443 if (hands == NULL) {
444 if (!all)
445 CRYPTO_THREAD_unlock(gtr->lock);
446 return 0;
447 }
448 curr = *hands;
449 while (curr != NULL) {
450 if (all || curr->index == index) {
451 if (prev != NULL)
452 prev->next = curr->next;
453 else
454 *hands = curr->next;
455 tmp = curr;
456 curr = curr->next;
457 OPENSSL_free(tmp);
458 continue;
459 }
460 prev = curr;
461 curr = curr->next;
462 }
463 if (all)
464 OPENSSL_free(hands);
465 }
466 if (all) {
467 CRYPTO_THREAD_lock_free(gtr->lock);
468 sk_THREAD_EVENT_HANDLER_PTR_free(gtr->skhands);
469 OPENSSL_free(gtr);
470 } else {
471 CRYPTO_THREAD_unlock(gtr->lock);
472 }
473 return 1;
474 }
475
ossl_init_thread_deregister(void * index)476 int ossl_init_thread_deregister(void *index)
477 {
478 return init_thread_deregister(index, 0);
479 }
480 #endif
481
