async_ctx *async_get_ctx(void) { if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL)) return NULL; return (async_ctx *)CRYPTO_THREAD_get_local(&ctxkey); }
int ossl_init_thread_start(uint64_t opts) { struct thread_local_inits_st *locals; if (!OPENSSL_init_crypto(0, NULL)) return 0; locals = ossl_init_get_thread_local(1); if (locals == NULL) return 0; if (opts & OPENSSL_INIT_THREAD_ASYNC) { #ifdef OPENSSL_INIT_DEBUG fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: " "marking thread for async\n"); #endif locals->async = 1; } if (opts & OPENSSL_INIT_THREAD_ERR_STATE) { #ifdef OPENSSL_INIT_DEBUG fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: " "marking thread for err_state\n"); #endif locals->err_state = 1; } return 1; }
int FuzzerInitialize(int *argc, char ***argv) { OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); ERR_get_state(); CRYPTO_free_ex_index(0, -1); return 1; }
/* * If this function is called with a non NULL settings value then it must be * called prior to any threads making calls to any OpenSSL functions, * i.e. passing a non-null settings value is assumed to be single-threaded. */ int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) { static int stoperrset = 0; if (stopped) { if (!stoperrset) { /* * We only ever set this once to avoid getting into an infinite * loop where the error system keeps trying to init and fails so * sets an error etc */ stoperrset = 1; SSLerr(SSL_F_OPENSSL_INIT_SSL_LIBRARY_START, ERR_R_INIT_FAIL); } return 0; } if (!OPENSSL_init_crypto(opts | OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS, settings)) return 0; ossl_init_once_run(&ssl_base, ossl_init_ssl_base); if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS) ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings); if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS) ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings); return 1; }
int ossl_init_thread_start(uint64_t opts) { struct thread_local_inits_st *locals; if (!OPENSSL_init_crypto(0, NULL)) return 0; locals = ossl_init_get_thread_local(1); if (locals == NULL) return 0; if (opts & OPENSSL_INIT_THREAD_ASYNC) { OSSL_TRACE(INIT, "ossl_init_thread_start: " "marking thread for async\n"); locals->async = 1; } if (opts & OPENSSL_INIT_THREAD_ERR_STATE) { OSSL_TRACE(INIT, "ossl_init_thread_start: " "marking thread for err_state\n"); locals->err_state = 1; } if (opts & OPENSSL_INIT_THREAD_RAND) { OSSL_TRACE(INIT, "ossl_init_thread_start: " "marking thread for rand\n"); locals->rand = 1; } return 1; }
static void log_openssl_error (const char * file, int line) { const unsigned long error_code = ERR_get_error (); if (tr_logLevelIsActive (TR_LOG_ERROR)) { char buf[512]; #ifndef TR_LIGHTWEIGHT static bool strings_loaded = false; if (!strings_loaded) { #if OPENSSL_VERSION_NUMBER < 0x10100000 ERR_load_crypto_strings (); #else OPENSSL_init_crypto (OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); #endif strings_loaded = true; } #endif ERR_error_string_n (error_code, buf, sizeof (buf)); tr_logAddMessage (file, line, TR_LOG_ERROR, MY_NAME, "OpenSSL error: %s", buf); } }
ERR_STATE *ERR_get_state(void) { ERR_STATE *state = NULL; if (!RUN_ONCE(&err_init, err_do_init)) return NULL; state = CRYPTO_THREAD_get_local(&err_thread_local); if (state == NULL) { state = OPENSSL_zalloc(sizeof(*state)); if (state == NULL) return NULL; if (!CRYPTO_THREAD_set_local(&err_thread_local, state)) { ERR_STATE_free(state); return NULL; } /* Ignore failures from these */ OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); ossl_init_thread_start(OPENSSL_INIT_THREAD_ERR_STATE); } return state; }
/* * err_shelve_state returns the current thread local error state * and freezes the error module until err_unshelve_state is called. */ int err_shelve_state(void **state) { int saveerrno = get_last_sys_error(); /* * Note, at present our only caller is OPENSSL_init_crypto(), indirectly * via ossl_init_load_crypto_nodelete(), by which point the requested * "base" initialization has already been performed, so the below call is a * NOOP, that re-enters OPENSSL_init_crypto() only to quickly return. * * If are no other valid callers of this function, the call below can be * removed, avoiding the re-entry into OPENSSL_init_crypto(). If there are * potential uses that are not from inside OPENSSL_init_crypto(), then this * call is needed, but some care is required to make sure that the re-entry * remains a NOOP. */ if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL)) return 0; if (!RUN_ONCE(&err_init, err_do_init)) return 0; *state = CRYPTO_THREAD_get_local(&err_thread_local); if (!CRYPTO_THREAD_set_local(&err_thread_local, (ERR_STATE*)-1)) return 0; set_sys_error(saveerrno); return 1; }
gboolean signature_init(GError **error) { #if (OPENSSL_VERSION_NUMBER < 0x10100000L) OPENSSL_config(NULL); OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); #else int ret; g_return_val_if_fail(error == FALSE || *error == NULL, FALSE); ret = OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); if (!ret) { unsigned long err; const gchar *data; int flags; err = ERR_get_error_line_data(NULL, NULL, &data, &flags); g_set_error( error, R_SIGNATURE_ERROR, R_SIGNATURE_ERROR_CRYPTOINIT_FAILED, "Failed to initalize OpenSSL crypto: %s", (flags & ERR_TXT_STRING) ? data : ERR_error_string(err, NULL)); return FALSE; } #endif return TRUE; }
int main(int argc, char **argv) { int i; testdata *test = test_cases; CRYPTO_set_mem_debug(1); CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN, NULL); printf("PKCS5_PBKDF2_HMAC() tests "); for (i = 0; test->pass != NULL; i++, test++) { test_p5_pbkdf2(i, "sha1", test, sha1_results[i]); test_p5_pbkdf2(i, "sha256", test, sha256_results[i]); test_p5_pbkdf2(i, "sha512", test, sha512_results[i]); printf("."); } printf(" done\n"); #ifndef OPENSSL_NO_CRYPTO_MDEBUG if (CRYPTO_mem_leaks_fp(stderr) <= 0) return 1; # endif return 0; }
int ASYNC_init_thread(size_t max_size, size_t init_size) { async_pool *pool; size_t curr_size = 0; if (init_size > max_size) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE); return 0; } if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL)) { return 0; } if (!ossl_init_thread_start(OPENSSL_INIT_THREAD_ASYNC)) { return 0; } pool = OPENSSL_zalloc(sizeof(*pool)); if (pool == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); return 0; } pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, init_size); if (pool->jobs == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); OPENSSL_free(pool); return 0; } pool->max_size = max_size; /* Pre-create jobs as required */ while (init_size--) { ASYNC_JOB *job; job = async_job_new(); if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) { /* * Not actually fatal because we already created the pool, just * skip creation of any more jobs */ async_job_free(job); break; } job->funcargs = NULL; sk_ASYNC_JOB_push(pool->jobs, job); /* Cannot fail due to reserve */ curr_size++; } pool->curr_size = curr_size; if (!CRYPTO_THREAD_set_local(&poolkey, pool)) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL); goto err; } return 1; err: async_free_pool_internal(pool); return 0; }
BackendOpenSsl::BackendOpenSsl() { #if OPENSSL_API_COMPAT < 0x10100000L ERR_load_crypto_strings(); #else OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, nullptr); #endif }
int global_init(void) { ENGINE_load_builtin_engines(); # ifndef OPENSSL_NO_STATIC_ENGINE OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL); # endif return 1; }
void OPENSSL_config(const char *config_name) { OPENSSL_INIT_SETTINGS settings; memset(&settings, 0, sizeof(settings)); if (config_name != NULL) settings.config_name = strdup(config_name); OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, &settings); }