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