void finish() { av_lockmgr_register(nullptr); CRYPTO_cleanup_all_ex_data(); FIPS_mode_set(0); ENGINE_cleanup(); CONF_modules_unload(1); ERR_remove_state(0); ERR_free_strings(); ERR_remove_thread_state(nullptr); EVP_cleanup(); delete[] _sslLocks; _sslLocks = nullptr; Platform::ThirdParty::finish(); }
static void SQBIND_Exit_curl() { oexAutoLock ll( _g_curl_lock ); if ( !ll.IsLocked() ) return; // Cleanup curl curl_global_cleanup(); // SSL cleanup sequence ERR_remove_state( 0 ); // ENGINE_cleanup(); CONF_modules_unload( 1 ); ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); }
LWS_VISIBLE void lws_ssl_context_destroy(struct lws_context *context) { if (context->ssl_ctx) SSL_CTX_free(context->ssl_ctx); if (!context->user_supplied_ssl_ctx && context->ssl_client_ctx) SSL_CTX_free(context->ssl_client_ctx); #if (OPENSSL_VERSION_NUMBER < 0x01000000) || defined(USE_WOLFSSL) ERR_remove_state(0); #else ERR_remove_thread_state(NULL); #endif ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); }
static void openssl_shutdown(void) { CONF_modules_unload(1); destroy_ui_method(); OBJ_cleanup(); EVP_cleanup(); #ifndef OPENSSL_NO_ENGINE ENGINE_cleanup(); #endif CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); RAND_cleanup(); ERR_free_strings(); }
int main(void) { int ret = 1; BIO *out; out = BIO_new_fp(stdout, BIO_NOCLOSE); /* enable memory leak checking unless explicitly disabled */ if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))) { CRYPTO_malloc_debug_init(); CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL); } else { /* OPENSSL_DEBUG_MEMORY=off */ CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0); } CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); ERR_load_crypto_strings(); /* initialize the prng */ RAND_seed(rnd_seed, sizeof(rnd_seed)); /* the tests */ if (!x9_62_tests(out)) goto err; if (!test_builtin(out)) goto err; ret = 0; err: if (ret) BIO_printf(out, "\nECDSA test failed\n"); else BIO_printf(out, "\nECDSA test passed\n"); if (ret) ERR_print_errors(out); CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); ERR_free_strings(); CRYPTO_mem_leaks(out); if (out != NULL) BIO_free(out); return ret; }
void check_finish() { iconv_close(iconv_utf8); iconv_close(iconv_ucs2); iconv_close(iconv_utf32); BN_free(bn_factors); ASN1_OBJECT_free(obj_jurisdictionCountryName); ASN1_OBJECT_free(obj_jurisdictionLocalityName); ASN1_OBJECT_free(obj_jurisdictionStateOrProvinceName); ASN1_OBJECT_free(obj_StreetAddress); ASN1_OBJECT_free(obj_postalCode); ASN1_OBJECT_free(obj_postOfficeBox); ASN1_OBJECT_free(obj_anyEKU); ASN1_OBJECT_free(obj_IntelAMTvProEKU); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); }
void dst__openssl_destroy(void) { /* * Sequence taken from apps_shutdown() in <apps/apps.h>. */ if (rm != NULL) { #if OPENSSL_VERSION_NUMBER >= 0x00907000L RAND_cleanup(); #endif mem_free(rm); rm = NULL; } #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) CONF_modules_free(); #endif OBJ_cleanup(); EVP_cleanup(); #if defined(USE_ENGINE) if (e != NULL) ENGINE_free(e); e = NULL; #if defined(USE_ENGINE) && OPENSSL_VERSION_NUMBER >= 0x00907000L ENGINE_cleanup(); #endif #endif #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) CRYPTO_cleanup_all_ex_data(); #endif ERR_clear_error(); #if OPENSSL_VERSION_NUMBER < 0x10100000L ERR_remove_state(0); #endif ERR_free_strings(); #ifdef DNS_CRYPTO_LEAKS CRYPTO_mem_leaks_fp(stderr); #endif if (locks != NULL) { CRYPTO_set_locking_callback(NULL); DESTROYMUTEXBLOCK(locks, nlocks); mem_free(locks); locks = NULL; } }
void cleanupOpenSSL() { if(m_ssl != NULL) { SSL_shutdown (m_ssl); /* send SSL/TLS close_notify */ SSL_free (m_ssl); m_ssl = NULL; } if(m_ctx != NULL) { SSL_CTX_free (m_ctx); m_ctx = NULL; ERR_remove_state(0); ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); } }
/** * oh_ssl_finit * * Finalizes the OpenSSL library. The calls used in this routine releases global * data created/initialized by the OpenSSL library. * * Note that it is the responisbility of the caller of this function to make * sure that no other threads are making the OpenSSL library calls. The openhpid * should close all the threads and call this function from the main (single) * thread. * * Return value: None **/ void oh_ssl_finit(void) { /* TODO: Check whether any other SSL library cleanup should be called */ thread_cleanup(); ENGINE_cleanup(); CONF_modules_unload(0); ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); /* The valgrind is showing possible memory leak by * SSL_COMP_get_compression_methods() call. * * Call to SSL_free_comp_methods() may resolve the memory leak. * But not able to find this call in the openssl 0.9.8e * TODO: Find whether its a real problem or not */ }
static void apps_shutdown() { #ifndef OPENSSL_NO_ENGINE ENGINE_cleanup(); #endif destroy_ui_method(); CONF_modules_unload(1); #ifndef OPENSSL_NO_COMP COMP_zlib_cleanup(); SSL_COMP_free_compression_methods(); #endif OBJ_cleanup(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); RAND_cleanup(); ERR_free_strings(); }
void finish() { av_lockmgr_register(nullptr); CRYPTO_cleanup_all_ex_data(); #ifndef LIBRESSL_VERSION_NUMBER FIPS_mode_set(0); #endif ENGINE_cleanup(); CONF_modules_unload(1); ERR_remove_state(0); ERR_free_strings(); ERR_remove_thread_state(nullptr); EVP_cleanup(); delete[] base::take(_sslLocks); Platform::ThirdParty::finish(); }
// .. c:function:: ch_error_t ch_en_openssl_uninit(void) // :noindex: // // see: :c:func:`ch_en_openssl_uninit` // // .. code-block:: cpp // { FIPS_mode_set(0); ENGINE_cleanup(); CONF_modules_unload(1); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_free_strings(); CONF_modules_free(); return CH_SUCCESS; }
/** * @see clientlib.h */ void selfTest(){ ERR_load_crypto_strings(); OpenSSL_add_all_algorithms(); OPENSSL_config(NULL); // TODO: do some encryption unsigned char data[] = "HelloWorld"; unsigned char hash[SHA512_DIGEST_LENGTH]; SHA512(data, sizeof(data), hash); int i; for (i = 0; i < sizeof(data); i++) { printf("%02x ", data[i]); } printf("\n"); // EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_free_strings(); }
int main( int argc, char** argv ) { SSTRACE_ARGS args; int rc = 0; memset( &args, 0, sizeof( args ) ); ErrBuffer[0] = 0; if( argc < 3 ) { print_usage(); return 0; } if( load_args( argc, argv, &args ) != 0 ) { if( strlen( ErrBuffer ) ) { fprintf( stderr, ErrBuffer ); } else { print_usage(); } return 1; } /* Initialize OpenSSL library before using DSSL! */ SSL_library_init(); OpenSSL_add_all_ciphers(); OpenSSL_add_all_digests(); rc = proceed( &args ); if( rc != 0 ) { if( strlen( ErrBuffer ) ) fprintf( stderr, ErrBuffer ); } /* Cleanup OpenSSL */ EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); return rc; }
/* Global cleanup */ void Curl_ossl_cleanup(void) { /* Free the SSL error strings */ ERR_free_strings(); /* EVP_cleanup() removes all ciphers and digests from the table. */ EVP_cleanup(); #ifdef HAVE_ENGINE_cleanup ENGINE_cleanup(); #endif #ifdef HAVE_CRYPTO_CLEANUP_ALL_EX_DATA /* this function was not present in 0.9.6b, but was added sometimes later */ CRYPTO_cleanup_all_ex_data(); #endif }
//-------------------------------------------------------------------------------------------------- le_result_t secSocket_Delete ( secSocket_Ctx_t* ctxPtr ///< [INOUT] Secure socket context pointer ) { if (!ctxPtr) { return LE_BAD_PARAMETER; } OpensslCtx_t* contextPtr = GetContext(ctxPtr); if (!contextPtr) { return LE_BAD_PARAMETER; } BIO_free_all(contextPtr->bioPtr); contextPtr->bioPtr = NULL; SSL_CTX_free(contextPtr->sslCtxPtr); contextPtr->sslCtxPtr = NULL; #if OPENSSL_API_COMPAT < 0x10100000L #if OPENSSL_API_COMPAT > 0x10002000L // In versions of OpenSSL prior to 1.1.0 SSL_COMP_free_compression_methods() freed the // internal table of compression methods that were built internally, and possibly augmented // by adding SSL_COMP_add_compression_method(). // However this is now unnecessary from version 1.1.0. No explicit initialisation or // de-initialisation is necessary. SSL_COMP_free_compression_methods(); #endif #endif EVP_cleanup(); ERR_free_strings(); CRYPTO_cleanup_all_ex_data(); #if OPENSSL_VERSION_NUMBER < 0x10100000L ERR_remove_state(0); #endif contextPtr->isInit = false; le_mem_Release(contextPtr); return LE_OK; }
/* * called from main.c when opensips exits (main process) */ static void mod_destroy(void) { struct tls_domain *d; LM_DBG("entered\n"); if (dom_lock) { lock_destroy_rw(dom_lock); dom_lock = 0; } d = tls_server_domains; while (d) { if (d->ctx) SSL_CTX_free(d->ctx); lock_destroy(d->lock); lock_dealloc(d->lock); d = d->next; } d = tls_client_domains; while (d) { if (d->ctx) SSL_CTX_free(d->ctx); lock_destroy(d->lock); lock_dealloc(d->lock); d = d->next; } if (tls_default_server_domain.ctx) { SSL_CTX_free(tls_default_server_domain.ctx); } if (tls_default_client_domain.ctx) { SSL_CTX_free(tls_default_client_domain.ctx); } tls_free_domains(); /* TODO - destroy static locks */ /* library destroy */ ERR_free_strings(); /*SSL_free_comp_methods(); - this function is not on std. openssl*/ EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); return; }
void _mosquitto_net_cleanup(void) { #ifdef WITH_TLS ERR_remove_state(0); ENGINE_cleanup(); CONF_modules_unload(1); ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); #endif #ifdef WITH_SRV ares_library_cleanup(); #endif #ifdef WIN32 WSACleanup(); #endif }
bool msl::encrypt_rsa(const void* plain,const size_t size,const std::string& key,std::string& cipher) { bool success=true; ERR_load_crypto_strings(); OpenSSL_add_all_algorithms(); BIO* keybio=BIO_new_mem_buf((uint8_t*)key.c_str(),-1); if(keybio==nullptr) success=false; RSA* rsa=nullptr; if(success) rsa=PEM_read_bio_RSA_PUBKEY(keybio,&rsa,nullptr,nullptr); if(rsa==nullptr) success=false; if(size>(size_t)RSA_size(rsa)-RSA_PKCS1_OAEP_PADDING_SIZE) success=false; size_t temp_size=(size_t)-1; uint8_t* temp_data=new uint8_t[RSA_size(rsa)]; if(success) temp_size=RSA_public_encrypt(size,(uint8_t*)plain,temp_data,rsa,RSA_PKCS1_OAEP_PADDING); if(success&&temp_size==(size_t)~0) success=false; if(success) cipher=std::string((char*)temp_data,temp_size); delete[] temp_data; BIO_free(keybio); RSA_free(rsa); ERR_free_strings(); EVP_cleanup(); ERR_remove_state(0); CRYPTO_cleanup_all_ex_data(); return success; }
/* Release SSL and free resources Will be automatically executed by mysql_server_end() function SYNOPSIS my_ssl_end() void RETURN VALUES void */ void my_ssl_end() { DBUG_ENTER("my_ssl_end"); pthread_mutex_lock(&LOCK_ssl_config); if (my_ssl_initialized) { int i; if (LOCK_crypto) { CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); for (i=0; i < CRYPTO_num_locks(); i++) pthread_mutex_destroy(&LOCK_crypto[i]); my_free(LOCK_crypto); LOCK_crypto= NULL; } if (SSL_context) { SSL_CTX_free(SSL_context); SSL_context= FALSE; } if (mariadb_deinitialize_ssl) { #if OPENSSL_VERSION_NUMBER < 0x10100000 ERR_remove_state(0); #endif EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_free_strings(); CONF_modules_free(); CONF_modules_unload(1); } my_ssl_initialized= FALSE; } pthread_mutex_unlock(&LOCK_ssl_config); pthread_mutex_destroy(&LOCK_ssl_config); DBUG_VOID_RETURN; }
void cleanup_openssl(global_data_t *global_data) { SSL_CTX_free(global_data->ssl_ctx); CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); CRYPTO_set_dynlock_create_callback(NULL); CRYPTO_set_dynlock_destroy_callback(NULL); CRYPTO_set_dynlock_lock_callback(NULL); ERR_remove_state(0); ERR_free_strings(); CONF_modules_unload(1); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); for (size_t i = 0; i < openssl_global_data.num_lock; i++) CHECK_ERROR(pthread_mutex_destroy, openssl_global_data.lock + i); free(openssl_global_data.lock); CHECK_ERROR(pthread_mutexattr_destroy, &openssl_global_data.lock_attr); }
void ssl_stream::close() { socket_ = INVALID_SOCKET; if( ssl_ != NULL ) { SSL_shutdown( ssl_ ); /* send SSL/TLS close_notify */ SSL_free( ssl_ ); ssl_ = NULL; } if( ssl_ctx_ != NULL ) { SSL_CTX_free( ssl_ctx_ ); ssl_ctx_ = NULL; ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); } }
bool SSLContext::Destroy(){ if( !m_pssl_ctx ) return false; SSL_CTX_free(m_pssl_ctx); m_pssl_ctx = NULL; CRYPTO_set_locking_callback (NULL); CRYPTO_set_dynlock_create_callback (NULL); CRYPTO_set_dynlock_lock_callback (NULL); CRYPTO_set_dynlock_destroy_callback (NULL); EVP_cleanup(); CRYPTO_cleanup_all_ex_data (); ERR_remove_state (0); ERR_free_strings (); // Destroy crypto locks. DestroyCryptoLocks (); return true; }
static void internal_idevice_deinit(void) { #ifdef HAVE_OPENSSL int i; if (mutex_buf) { CRYPTO_set_id_callback(NULL); CRYPTO_set_locking_callback(NULL); for (i = 0; i < CRYPTO_num_locks(); i++) mutex_destroy(&mutex_buf[i]); free(mutex_buf); mutex_buf = NULL; } /* Since there is no SSL_library_deinit... */ EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); sk_SSL_COMP_free(SSL_COMP_get_compression_methods()); #else gnutls_global_deinit(); #endif }
void tls_shutdown(void) { /* * FIXME: Don't free global tables, program or other libraries may use * openssl after libstrophe finalization. Maybe better leak some fixed * memory rather than cause random crashes of the main program. */ #if OPENSSL_VERSION_NUMBER < 0x10100000L ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); #if OPENSSL_VERSION_NUMBER >= 0x10002000L SSL_COMP_free_compression_methods(); #endif #if OPENSSL_VERSION_NUMBER < 0x10000000L ERR_remove_state(0); #else ERR_remove_thread_state(NULL); #endif #endif }
bool SSLSocketServer::SSL_Destroy(){ SSL_CTX_free(m_pssl_ctx); m_pssl_ctx = NULL; CRYPTO_set_locking_callback (NULL); CRYPTO_set_dynlock_create_callback (NULL); CRYPTO_set_dynlock_lock_callback (NULL); CRYPTO_set_dynlock_destroy_callback (NULL); EVP_cleanup(); CRYPTO_cleanup_all_ex_data (); ERR_remove_state (0); ERR_free_strings (); // Destroy crypto locks. DestroyCryptoLocks (); DeleteCriticalSection(&m_lock_connect_ex); return false; }
ENVELOP_API void env_release() { #ifdef WIN32 if(0 == env_release_cert_list() && g_pub_key != NULL) EVP_PKEY_free(g_pub_key); #else if(g_pub_key != NULL) EVP_PKEY_free(g_pub_key); #endif if(g_prv_key != NULL) EVP_PKEY_free(g_prv_key); //释放Openssl do { EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_remove_state(0); ERR_free_strings(); } while(0); }
LWS_VISIBLE void lws_ssl_destroy(struct lws_vhost *vhost) { if (!lws_check_opt(vhost->context->options, LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT)) return; if (vhost->ssl_ctx) SSL_CTX_free(vhost->ssl_ctx); if (!vhost->user_supplied_ssl_ctx && vhost->ssl_client_ctx) SSL_CTX_free(vhost->ssl_client_ctx); #if defined(LWS_WITH_MBEDTLS) if (vhost->x509_client_CA) X509_free(vhost->x509_client_CA); #else // after 1.1.0 no need #if (OPENSSL_VERSION_NUMBER < 0x10100000) // <= 1.0.1f = old api, 1.0.1g+ = new api #if (OPENSSL_VERSION_NUMBER <= 0x1000106f) || defined(USE_WOLFSSL) ERR_remove_state(0); #else #if OPENSSL_VERSION_NUMBER >= 0x1010005f && \ !defined(LIBRESSL_VERSION_NUMBER) && \ !defined(OPENSSL_IS_BORINGSSL) ERR_remove_thread_state(); #else ERR_remove_thread_state(NULL); #endif #endif // after 1.1.0 no need #if (OPENSSL_VERSION_NUMBER >= 0x10002000) && (OPENSSL_VERSION_NUMBER <= 0x10100000) SSL_COMP_free_compression_methods(); #endif ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); #endif #endif }
static bool boot_verify_compare_sha256(unsigned char *image_ptr, unsigned int image_size, unsigned char *signature_ptr, RSA *rsa) { int ret = -1; bool auth = false; unsigned char *plain_text = NULL; unsigned int digest[8]; plain_text = (unsigned char *)calloc(sizeof(char), SIGNATURE_SIZE); if (plain_text == NULL) { dprintf(CRITICAL, "boot_verifier: Calloc failed during verification\n"); goto cleanup; } /* Calculate SHA256sum */ image_find_digest(image_ptr, image_size, CRYPTO_AUTH_ALG_SHA256, (unsigned char *)&digest); /* Find digest from the image */ ret = image_decrypt_signature_rsa(signature_ptr, plain_text, rsa); dprintf(SPEW, "boot_verifier: Return of RSA_public_decrypt = %d\n", ret); ret = verify_digest(plain_text, (unsigned char*)digest, SHA256_SIZE); if(ret == 0) { auth = true; } cleanup: if (plain_text != NULL) free(plain_text); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); return auth; }
/* Release SSL and free resources Will be automatically executed by mysql_server_end() function SYNOPSIS my_ssl_end() void RETURN VALUES void */ void ma_tls_end() { if (ma_tls_initialized) { pthread_mutex_lock(&LOCK_openssl_config); #if OPENSSL_VERSION_NUMBER < 0x10100000L CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); { int i; for (i=0; i < CRYPTO_num_locks(); i++) pthread_mutex_destroy(&LOCK_crypto[i]); } ma_free((gptr)LOCK_crypto); LOCK_crypto= NULL; #endif if (SSL_context) { SSL_CTX_free(SSL_context); SSL_context= NULL; } if (mariadb_deinitialize_ssl) { #if OPENSSL_VERSION_NUMBER < 0x10100000L ERR_remove_state(0); #endif EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_free_strings(); CONF_modules_free(); CONF_modules_unload(1); } ma_tls_initialized= FALSE; pthread_mutex_unlock(&LOCK_openssl_config); pthread_mutex_destroy(&LOCK_openssl_config); } return; }