crypto/initthread.c

   1 /*
   2  * Copyright 2019-2022 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_init_provider).
  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
  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
  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 **
  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  */
 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
 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
 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
 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
 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
 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
 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
 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 void *ossl_thread_event_ctx_new(OSSL_LIB_CTX *libctx)
 253 {
 254     THREAD_EVENT_HANDLER **hands = NULL;
 255     CRYPTO_THREAD_LOCAL *tlocal = OPENSSL_zalloc(sizeof(*tlocal));
 256
 257     if (tlocal == NULL)
 258         return NULL;
 259
 260     if (!CRYPTO_THREAD_init_local(tlocal,  NULL)) {
 261         goto err;
 262     }
 263
 264     hands = OPENSSL_zalloc(sizeof(*hands));
 265     if (hands == NULL)
 266         goto err;
 267
 268     if (!CRYPTO_THREAD_set_local(tlocal, hands))
 269         goto err;
 270
 271     return tlocal;
 272  err:
 273     OPENSSL_free(hands);
 274     OPENSSL_free(tlocal);
 275     return NULL;
 276 }
 277
 278 void ossl_thread_event_ctx_free(void *tlocal)
 279 {
 280     OPENSSL_free(tlocal);
 281 }
 282
 283 static void ossl_arg_thread_stop(void *arg)
 284 {
 285     ossl_ctx_thread_stop((OSSL_LIB_CTX *)arg);
 286 }
 287
 288 void ossl_ctx_thread_stop(OSSL_LIB_CTX *ctx)
 289 {
 290     THREAD_EVENT_HANDLER **hands;
 291     CRYPTO_THREAD_LOCAL *local
 292         = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);
 293
 294     if (local == NULL)
 295         return;
 296     hands = init_get_thread_local(local, 0, 0);
 297     init_thread_stop(ctx, hands);
 298     OPENSSL_free(hands);
 299 }
 300 #endif /* FIPS_MODULE */
 301
 302
 303 static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands)
 304 {
 305     THREAD_EVENT_HANDLER *curr, *prev = NULL, *tmp;
 306 #ifndef FIPS_MODULE
 307     GLOBAL_TEVENT_REGISTER *gtr;
 308 #endif
 309
 310     /* Can't do much about this */
 311     if (hands == NULL)
 312         return;
 313
 314 #ifndef FIPS_MODULE
 315     gtr = get_global_tevent_register();
 316     if (gtr == NULL)
 317         return;
 318
 319     if (!CRYPTO_THREAD_write_lock(gtr->lock))
 320         return;
 321 #endif
 322
 323     curr = *hands;
 324     while (curr != NULL) {
 325         if (arg != NULL && curr->arg != arg) {
 326             prev = curr;
 327             curr = curr->next;
 328             continue;
 329         }
 330         curr->handfn(curr->arg);
 331         if (prev == NULL)
 332             *hands = curr->next;
 333         else
 334             prev->next = curr->next;
 335
 336         tmp = curr;
 337         curr = curr->next;
 338
 339         OPENSSL_free(tmp);
 340     }
 341 #ifndef FIPS_MODULE
 342     CRYPTO_THREAD_unlock(gtr->lock);
 343 #endif
 344 }
 345
 346 int ossl_init_thread_start(const void *index, void *arg,
 347                            OSSL_thread_stop_handler_fn handfn)
 348 {
 349     THREAD_EVENT_HANDLER **hands;
 350     THREAD_EVENT_HANDLER *hand;
 351 #ifdef FIPS_MODULE
 352     OSSL_LIB_CTX *ctx = arg;
 353
 354     /*
 355      * In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
 356      * of OSSL_LIB_CTX and thread. This is because in FIPS mode each
 357      * OSSL_LIB_CTX gets informed about thread stop events individually.
 358      */
 359     CRYPTO_THREAD_LOCAL *local
 360         = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);
 361 #else
 362     /*
 363      * Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
 364      * thread, but may hold multiple OSSL_LIB_CTXs. We only get told about
 365      * thread stop events globally, so we have to ensure all affected
 366      * OSSL_LIB_CTXs are informed.
 367      */
 368     CRYPTO_THREAD_LOCAL *local = &destructor_key.value;
 369 #endif
 370
 371     hands = init_get_thread_local(local, 1, 0);
 372     if (hands == NULL)
 373         return 0;
 374
 375 #ifdef FIPS_MODULE
 376     if (*hands == NULL) {
 377         /*
 378          * We've not yet registered any handlers for this thread. We need to get
 379          * libcrypto to tell us about later thread stop events. c_thread_start
 380          * is a callback to libcrypto defined in fipsprov.c
 381          */
 382         if (!c_thread_start(FIPS_get_core_handle(ctx), ossl_arg_thread_stop,
 383                             ctx))
 384             return 0;
 385     }
 386 #endif
 387
 388     hand = OPENSSL_malloc(sizeof(*hand));
 389     if (hand == NULL)
 390         return 0;
 391
 392     hand->handfn = handfn;
 393     hand->arg = arg;
 394 #ifndef FIPS_MODULE
 395     hand->index = index;
 396 #endif
 397     hand->next = *hands;
 398     *hands = hand;
 399
 400     return 1;
 401 }
 402
 403 #ifndef FIPS_MODULE
 404 static int init_thread_deregister(void *index, int all)
 405 {
 406     GLOBAL_TEVENT_REGISTER *gtr;
 407     int i;
 408
 409     gtr = get_global_tevent_register();
 410     if (gtr == NULL)
 411         return 0;
 412     if (!all) {
 413         if (!CRYPTO_THREAD_write_lock(gtr->lock))
 414             return 0;
 415     } else {
 416         glob_tevent_reg = NULL;
 417     }
 418     for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
 419         THREAD_EVENT_HANDLER **hands
 420             = sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
 421         THREAD_EVENT_HANDLER *curr = NULL, *prev = NULL, *tmp;
 422
 423         if (hands == NULL) {
 424             if (!all)
 425                 CRYPTO_THREAD_unlock(gtr->lock);
 426             return 0;
 427         }
 428         curr = *hands;
 429         while (curr != NULL) {
 430             if (all || curr->index == index) {
 431                 if (prev != NULL)
 432                     prev->next = curr->next;
 433                 else
 434                     *hands = curr->next;
 435                 tmp = curr;
 436                 curr = curr->next;
 437                 OPENSSL_free(tmp);
 438                 continue;
 439             }
 440             prev = curr;
 441             curr = curr->next;
 442         }
 443         if (all)
 444             OPENSSL_free(hands);
 445     }
 446     if (all) {
 447         CRYPTO_THREAD_lock_free(gtr->lock);
 448         sk_THREAD_EVENT_HANDLER_PTR_free(gtr->skhands);
 449         OPENSSL_free(gtr);
 450     } else {
 451         CRYPTO_THREAD_unlock(gtr->lock);
 452     }
 453     return 1;
 454 }
 455
 456 int ossl_init_thread_deregister(void *index)
 457 {
 458     return init_thread_deregister(index, 0);
 459 }
 460 #endif