| /* |
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. |
| * |
| * Licensed under the OpenSSL license (the "License"). You may not use |
| * this file except in compliance with the License. You can obtain a copy |
| * in the file LICENSE in the source distribution or at |
| * https://www.openssl.org/source/license.html |
| */ |
| |
| #include "crypto/cryptlib.h" |
| #include "internal/thread_once.h" |
| |
| /* |
| * Each structure type (sometimes called a class), that supports |
| * exdata has a stack of callbacks for each instance. |
| */ |
| struct ex_callback_st { |
| long argl; /* Arbitrary long */ |
| void *argp; /* Arbitrary void * */ |
| CRYPTO_EX_new *new_func; |
| CRYPTO_EX_free *free_func; |
| CRYPTO_EX_dup *dup_func; |
| }; |
| |
| /* |
| * The state for each class. This could just be a typedef, but |
| * a structure allows future changes. |
| */ |
| typedef struct ex_callbacks_st { |
| STACK_OF(EX_CALLBACK) *meth; |
| } EX_CALLBACKS; |
| |
| static EX_CALLBACKS ex_data[CRYPTO_EX_INDEX__COUNT]; |
| |
| static CRYPTO_RWLOCK *ex_data_lock = NULL; |
| static CRYPTO_ONCE ex_data_init = CRYPTO_ONCE_STATIC_INIT; |
| |
| DEFINE_RUN_ONCE_STATIC(do_ex_data_init) |
| { |
| if (!OPENSSL_init_crypto(0, NULL)) |
| return 0; |
| ex_data_lock = CRYPTO_THREAD_lock_new(); |
| return ex_data_lock != NULL; |
| } |
| |
| /* |
| * Return the EX_CALLBACKS from the |ex_data| array that corresponds to |
| * a given class. On success, *holds the lock.* |
| */ |
| static EX_CALLBACKS *get_and_lock(int class_index) |
| { |
| EX_CALLBACKS *ip; |
| |
| if (class_index < 0 || class_index >= CRYPTO_EX_INDEX__COUNT) { |
| CRYPTOerr(CRYPTO_F_GET_AND_LOCK, ERR_R_PASSED_INVALID_ARGUMENT); |
| return NULL; |
| } |
| |
| if (!RUN_ONCE(&ex_data_init, do_ex_data_init)) { |
| CRYPTOerr(CRYPTO_F_GET_AND_LOCK, ERR_R_MALLOC_FAILURE); |
| return NULL; |
| } |
| |
| if (ex_data_lock == NULL) { |
| /* |
| * This can happen in normal operation when using CRYPTO_mem_leaks(). |
| * The CRYPTO_mem_leaks() function calls OPENSSL_cleanup() which cleans |
| * up the locks. Subsequently the BIO that CRYPTO_mem_leaks() uses gets |
| * freed, which also attempts to free the ex_data. However |
| * CRYPTO_mem_leaks() ensures that the ex_data is freed early (i.e. |
| * before OPENSSL_cleanup() is called), so if we get here we can safely |
| * ignore this operation. We just treat it as an error. |
| */ |
| return NULL; |
| } |
| |
| ip = &ex_data[class_index]; |
| CRYPTO_THREAD_write_lock(ex_data_lock); |
| return ip; |
| } |
| |
| static void cleanup_cb(EX_CALLBACK *funcs) |
| { |
| OPENSSL_free(funcs); |
| } |
| |
| /* |
| * Release all "ex_data" state to prevent memory leaks. This can't be made |
| * thread-safe without overhauling a lot of stuff, and shouldn't really be |
| * called under potential race-conditions anyway (it's for program shutdown |
| * after all). |
| */ |
| void crypto_cleanup_all_ex_data_int(void) |
| { |
| int i; |
| |
| for (i = 0; i < CRYPTO_EX_INDEX__COUNT; ++i) { |
| EX_CALLBACKS *ip = &ex_data[i]; |
| |
| sk_EX_CALLBACK_pop_free(ip->meth, cleanup_cb); |
| ip->meth = NULL; |
| } |
| |
| CRYPTO_THREAD_lock_free(ex_data_lock); |
| ex_data_lock = NULL; |
| } |
| |
| |
| /* |
| * Unregister a new index by replacing the callbacks with no-ops. |
| * Any in-use instances are leaked. |
| */ |
| static void dummy_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, |
| long argl, void *argp) |
| { |
| } |
| |
| static void dummy_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, |
| long argl, void *argp) |
| { |
| } |
| |
| static int dummy_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from, |
| void *from_d, int idx, |
| long argl, void *argp) |
| { |
| return 1; |
| } |
| |
| int CRYPTO_free_ex_index(int class_index, int idx) |
| { |
| EX_CALLBACKS *ip = get_and_lock(class_index); |
| EX_CALLBACK *a; |
| int toret = 0; |
| |
| if (ip == NULL) |
| return 0; |
| if (idx < 0 || idx >= sk_EX_CALLBACK_num(ip->meth)) |
| goto err; |
| a = sk_EX_CALLBACK_value(ip->meth, idx); |
| if (a == NULL) |
| goto err; |
| a->new_func = dummy_new; |
| a->dup_func = dummy_dup; |
| a->free_func = dummy_free; |
| toret = 1; |
| err: |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| return toret; |
| } |
| |
| /* |
| * Register a new index. |
| */ |
| int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, |
| CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, |
| CRYPTO_EX_free *free_func) |
| { |
| int toret = -1; |
| EX_CALLBACK *a; |
| EX_CALLBACKS *ip = get_and_lock(class_index); |
| |
| if (ip == NULL) |
| return -1; |
| |
| if (ip->meth == NULL) { |
| ip->meth = sk_EX_CALLBACK_new_null(); |
| /* We push an initial value on the stack because the SSL |
| * "app_data" routines use ex_data index zero. See RT 3710. */ |
| if (ip->meth == NULL |
| || !sk_EX_CALLBACK_push(ip->meth, NULL)) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX, ERR_R_MALLOC_FAILURE); |
| goto err; |
| } |
| } |
| |
| a = (EX_CALLBACK *)OPENSSL_malloc(sizeof(*a)); |
| if (a == NULL) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX, ERR_R_MALLOC_FAILURE); |
| goto err; |
| } |
| a->argl = argl; |
| a->argp = argp; |
| a->new_func = new_func; |
| a->dup_func = dup_func; |
| a->free_func = free_func; |
| |
| if (!sk_EX_CALLBACK_push(ip->meth, NULL)) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX, ERR_R_MALLOC_FAILURE); |
| OPENSSL_free(a); |
| goto err; |
| } |
| toret = sk_EX_CALLBACK_num(ip->meth) - 1; |
| (void)sk_EX_CALLBACK_set(ip->meth, toret, a); |
| |
| err: |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| return toret; |
| } |
| |
| /* |
| * Initialise a new CRYPTO_EX_DATA for use in a particular class - including |
| * calling new() callbacks for each index in the class used by this variable |
| * Thread-safe by copying a class's array of "EX_CALLBACK" entries |
| * in the lock, then using them outside the lock. Note this only applies |
| * to the global "ex_data" state (ie. class definitions), not 'ad' itself. |
| */ |
| int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad) |
| { |
| int mx, i; |
| void *ptr; |
| EX_CALLBACK **storage = NULL; |
| EX_CALLBACK *stack[10]; |
| EX_CALLBACKS *ip = get_and_lock(class_index); |
| |
| if (ip == NULL) |
| return 0; |
| |
| ad->sk = NULL; |
| |
| mx = sk_EX_CALLBACK_num(ip->meth); |
| if (mx > 0) { |
| if (mx < (int)OSSL_NELEM(stack)) |
| storage = stack; |
| else |
| storage = OPENSSL_malloc(sizeof(*storage) * mx); |
| if (storage != NULL) |
| for (i = 0; i < mx; i++) |
| storage[i] = sk_EX_CALLBACK_value(ip->meth, i); |
| } |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| |
| if (mx > 0 && storage == NULL) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_NEW_EX_DATA, ERR_R_MALLOC_FAILURE); |
| return 0; |
| } |
| for (i = 0; i < mx; i++) { |
| if (storage[i] != NULL && storage[i]->new_func != NULL) { |
| ptr = CRYPTO_get_ex_data(ad, i); |
| storage[i]->new_func(obj, ptr, ad, i, |
| storage[i]->argl, storage[i]->argp); |
| } |
| } |
| if (storage != stack) |
| OPENSSL_free(storage); |
| return 1; |
| } |
| |
| /* |
| * Duplicate a CRYPTO_EX_DATA variable - including calling dup() callbacks |
| * for each index in the class used by this variable |
| */ |
| int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, |
| const CRYPTO_EX_DATA *from) |
| { |
| int mx, j, i; |
| void *ptr; |
| EX_CALLBACK *stack[10]; |
| EX_CALLBACK **storage = NULL; |
| EX_CALLBACKS *ip; |
| int toret = 0; |
| |
| if (from->sk == NULL) |
| /* Nothing to copy over */ |
| return 1; |
| if ((ip = get_and_lock(class_index)) == NULL) |
| return 0; |
| |
| mx = sk_EX_CALLBACK_num(ip->meth); |
| j = sk_void_num(from->sk); |
| if (j < mx) |
| mx = j; |
| if (mx > 0) { |
| if (mx < (int)OSSL_NELEM(stack)) |
| storage = stack; |
| else |
| storage = OPENSSL_malloc(sizeof(*storage) * mx); |
| if (storage != NULL) |
| for (i = 0; i < mx; i++) |
| storage[i] = sk_EX_CALLBACK_value(ip->meth, i); |
| } |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| |
| if (mx == 0) |
| return 1; |
| if (storage == NULL) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_DUP_EX_DATA, ERR_R_MALLOC_FAILURE); |
| return 0; |
| } |
| /* |
| * Make sure the ex_data stack is at least |mx| elements long to avoid |
| * issues in the for loop that follows; so go get the |mx|'th element |
| * (if it does not exist CRYPTO_get_ex_data() returns NULL), and assign |
| * to itself. This is normally a no-op; but ensures the stack is the |
| * proper size |
| */ |
| if (!CRYPTO_set_ex_data(to, mx - 1, CRYPTO_get_ex_data(to, mx - 1))) |
| goto err; |
| |
| for (i = 0; i < mx; i++) { |
| ptr = CRYPTO_get_ex_data(from, i); |
| if (storage[i] != NULL && storage[i]->dup_func != NULL) |
| if (!storage[i]->dup_func(to, from, &ptr, i, |
| storage[i]->argl, storage[i]->argp)) |
| goto err; |
| CRYPTO_set_ex_data(to, i, ptr); |
| } |
| toret = 1; |
| err: |
| if (storage != stack) |
| OPENSSL_free(storage); |
| return toret; |
| } |
| |
| |
| /* |
| * Cleanup a CRYPTO_EX_DATA variable - including calling free() callbacks for |
| * each index in the class used by this variable |
| */ |
| void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad) |
| { |
| int mx, i; |
| EX_CALLBACKS *ip; |
| void *ptr; |
| EX_CALLBACK *f; |
| EX_CALLBACK *stack[10]; |
| EX_CALLBACK **storage = NULL; |
| |
| if ((ip = get_and_lock(class_index)) == NULL) |
| goto err; |
| |
| mx = sk_EX_CALLBACK_num(ip->meth); |
| if (mx > 0) { |
| if (mx < (int)OSSL_NELEM(stack)) |
| storage = stack; |
| else |
| storage = OPENSSL_malloc(sizeof(*storage) * mx); |
| if (storage != NULL) |
| for (i = 0; i < mx; i++) |
| storage[i] = sk_EX_CALLBACK_value(ip->meth, i); |
| } |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| |
| for (i = 0; i < mx; i++) { |
| if (storage != NULL) |
| f = storage[i]; |
| else { |
| CRYPTO_THREAD_write_lock(ex_data_lock); |
| f = sk_EX_CALLBACK_value(ip->meth, i); |
| CRYPTO_THREAD_unlock(ex_data_lock); |
| } |
| if (f != NULL && f->free_func != NULL) { |
| ptr = CRYPTO_get_ex_data(ad, i); |
| f->free_func(obj, ptr, ad, i, f->argl, f->argp); |
| } |
| } |
| |
| if (storage != stack) |
| OPENSSL_free(storage); |
| err: |
| sk_void_free(ad->sk); |
| ad->sk = NULL; |
| } |
| |
| /* |
| * For a given CRYPTO_EX_DATA variable, set the value corresponding to a |
| * particular index in the class used by this variable |
| */ |
| int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val) |
| { |
| int i; |
| |
| if (ad->sk == NULL) { |
| if ((ad->sk = sk_void_new_null()) == NULL) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE); |
| return 0; |
| } |
| } |
| |
| for (i = sk_void_num(ad->sk); i <= idx; ++i) { |
| if (!sk_void_push(ad->sk, NULL)) { |
| CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE); |
| return 0; |
| } |
| } |
| sk_void_set(ad->sk, idx, val); |
| return 1; |
| } |
| |
| /* |
| * For a given CRYPTO_EX_DATA_ variable, get the value corresponding to a |
| * particular index in the class used by this variable |
| */ |
| void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx) |
| { |
| if (ad->sk == NULL || idx >= sk_void_num(ad->sk)) |
| return NULL; |
| return sk_void_value(ad->sk, idx); |
| } |