EC_KEY *EC_KEY_new_method(ENGINE *engine) { EC_KEY *ret = OPENSSL_zalloc(sizeof(*ret)); if (ret == NULL) { ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_MALLOC_FAILURE); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data)) { OPENSSL_free(ret); return NULL; } ret->lock = CRYPTO_THREAD_lock_new(); if (ret->lock == NULL) { ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_MALLOC_FAILURE); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data); OPENSSL_free(ret); return NULL; } ret->meth = EC_KEY_get_default_method(); #ifndef OPENSSL_NO_ENGINE if (engine != NULL) { if (!ENGINE_init(engine)) { ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data); CRYPTO_THREAD_lock_free(ret->lock); OPENSSL_free(ret); return NULL; } ret->engine = engine; } else ret->engine = ENGINE_get_default_EC(); if (ret->engine != NULL) { ret->meth = ENGINE_get_EC(ret->engine); if (ret->meth == NULL) { ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB); ENGINE_finish(ret->engine); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data); CRYPTO_THREAD_lock_free(ret->lock); OPENSSL_free(ret); return NULL; } } #endif ret->version = 1; ret->conv_form = POINT_CONVERSION_UNCOMPRESSED; ret->references = 1; if (ret->meth->init != NULL && ret->meth->init(ret) == 0) { EC_KEY_free(ret); return NULL; } return ret; }
void bio_cleanup(void) { #ifndef OPENSSL_NO_SOCK bio_sock_cleanup_int(); CRYPTO_THREAD_lock_free(bio_lookup_lock); bio_lookup_lock = NULL; #endif CRYPTO_THREAD_lock_free(bio_type_lock); bio_type_lock = NULL; }
void rand_cleanup_int(void) { const RAND_METHOD *meth = default_RAND_meth; if (meth && meth->cleanup) meth->cleanup(); RAND_set_rand_method(NULL); CRYPTO_THREAD_lock_free(rand_meth_lock); #ifndef OPENSSL_NO_ENGINE CRYPTO_THREAD_lock_free(rand_engine_lock); #endif }
static void rand_cleanup(void) { OPENSSL_cleanse(state, sizeof(state)); state_num = 0; state_index = 0; OPENSSL_cleanse(md, MD_DIGEST_LENGTH); md_count[0] = 0; md_count[1] = 0; entropy = 0; initialized = 0; CRYPTO_THREAD_lock_free(rand_lock); CRYPTO_THREAD_lock_free(rand_tmp_lock); }
void err_cleanup(void) { if (set_err_thread_local != 0) CRYPTO_THREAD_cleanup_local(&err_thread_local); CRYPTO_THREAD_lock_free(err_string_lock); err_string_lock = NULL; }
int BIO_set(BIO *bio, const BIO_METHOD *method) { bio->method = method; bio->callback = NULL; bio->cb_arg = NULL; bio->init = 0; bio->shutdown = 1; bio->flags = 0; bio->retry_reason = 0; bio->num = 0; bio->ptr = NULL; bio->prev_bio = NULL; bio->next_bio = NULL; bio->references = 1; bio->num_read = 0L; bio->num_write = 0L; CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); bio->lock = CRYPTO_THREAD_lock_new(); if (bio->lock == NULL) { CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); return 0; } if (method->create != NULL) { if (!method->create(bio)) { CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); CRYPTO_THREAD_lock_free(bio->lock); return 0; } } return 1; }
/* Destructor (complements the "ENGINE_chil()" constructor) */ static int hwcrhk_destroy(ENGINE *e) { free_HWCRHK_LIBNAME(); ERR_unload_HWCRHK_strings(); CRYPTO_THREAD_lock_free(chil_lock); return 1; }
int BIO_free(BIO *a) { int ret; if (a == NULL) return 0; if (CRYPTO_DOWN_REF(&a->references, &ret, a->lock) <= 0) return 0; REF_PRINT_COUNT("BIO", a); if (ret > 0) return 1; REF_ASSERT_ISNT(ret < 0); if (a->callback != NULL || a->callback_ex != NULL) { ret = (int)bio_call_callback(a, BIO_CB_FREE, NULL, 0, 0, 0L, 1L, NULL); if (ret <= 0) return ret; } if ((a->method != NULL) && (a->method->destroy != NULL)) a->method->destroy(a); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data); CRYPTO_THREAD_lock_free(a->lock); OPENSSL_free(a); return 1; }
void X509_STORE_free(X509_STORE *vfy) { int i; STACK_OF(X509_LOOKUP) *sk; X509_LOOKUP *lu; if (vfy == NULL) return; CRYPTO_atomic_add(&vfy->references, -1, &i, vfy->lock); REF_PRINT_COUNT("X509_STORE", vfy); if (i > 0) return; REF_ASSERT_ISNT(i < 0); sk = vfy->get_cert_methods; for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) { lu = sk_X509_LOOKUP_value(sk, i); X509_LOOKUP_shutdown(lu); X509_LOOKUP_free(lu); } sk_X509_LOOKUP_free(sk); sk_X509_OBJECT_pop_free(vfy->objs, cleanup); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, vfy, &vfy->ex_data); X509_VERIFY_PARAM_free(vfy->param); CRYPTO_THREAD_lock_free(vfy->lock); OPENSSL_free(vfy); }
void DSA_free(DSA *r) { int i; if (r == NULL) return; CRYPTO_DOWN_REF(&r->references, &i, r->lock); REF_PRINT_COUNT("DSA", r); if (i > 0) return; REF_ASSERT_ISNT(i < 0); if (r->meth->finish) r->meth->finish(r); #ifndef OPENSSL_NO_ENGINE ENGINE_finish(r->engine); #endif CRYPTO_free_ex_data(CRYPTO_EX_INDEX_DSA, r, &r->ex_data); CRYPTO_THREAD_lock_free(r->lock); BN_clear_free(r->p); BN_clear_free(r->q); BN_clear_free(r->g); BN_clear_free(r->pub_key); BN_clear_free(r->priv_key); OPENSSL_free(r); }
int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it) { const ASN1_AUX *aux; int *lck, ret; CRYPTO_RWLOCK **lock; if ((it->itype != ASN1_ITYPE_SEQUENCE) && (it->itype != ASN1_ITYPE_NDEF_SEQUENCE)) return 0; aux = it->funcs; if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) return 0; lck = offset2ptr(*pval, aux->ref_offset); lock = offset2ptr(*pval, aux->ref_lock); if (op == 0) { *lck = 1; *lock = CRYPTO_THREAD_lock_new(); if (*lock == NULL) return 0; return 1; } CRYPTO_atomic_add(lck, op, &ret, *lock); #ifdef REF_PRINT fprintf(stderr, "%p:%4d:%s\n", it, *lck, it->sname); #endif REF_ASSERT_ISNT(ret < 0); if (ret == 0) CRYPTO_THREAD_lock_free(*lock); return ret; }
SSL_SESSION *SSL_SESSION_new(void) { SSL_SESSION *ss; if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL)) return NULL; ss = OPENSSL_zalloc(sizeof(*ss)); if (ss == NULL) { SSLerr(SSL_F_SSL_SESSION_NEW, ERR_R_MALLOC_FAILURE); return NULL; } ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */ ss->references = 1; ss->timeout = 60 * 5 + 4; /* 5 minute timeout by default */ ss->time = (unsigned long)time(NULL); ss->lock = CRYPTO_THREAD_lock_new(); if (ss->lock == NULL) { SSLerr(SSL_F_SSL_SESSION_NEW, ERR_R_MALLOC_FAILURE); OPENSSL_free(ss); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data)) { CRYPTO_THREAD_lock_free(ss->lock); OPENSSL_free(ss); return NULL; } return ss; }
int BIO_free(BIO *a) { int i; if (a == NULL) return 0; if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0) return 0; REF_PRINT_COUNT("BIO", a); if (i > 0) return 1; REF_ASSERT_ISNT(i < 0); if ((a->callback != NULL) && ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0)) return i; CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data); CRYPTO_THREAD_lock_free(a->lock); if ((a->method != NULL) && (a->method->destroy != NULL)) a->method->destroy(a); OPENSSL_free(a); return 1; }
void EC_KEY_free(EC_KEY *r) { int i; if (r == NULL) return; CRYPTO_DOWN_REF(&r->references, &i, r->lock); REF_PRINT_COUNT("EC_KEY", r); if (i > 0) return; REF_ASSERT_ISNT(i < 0); if (r->meth->finish != NULL) r->meth->finish(r); #ifndef OPENSSL_NO_ENGINE ENGINE_finish(r->engine); #endif if (r->group && r->group->meth->keyfinish) r->group->meth->keyfinish(r); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, r, &r->ex_data); CRYPTO_THREAD_lock_free(r->lock); EC_GROUP_free(r->group); EC_POINT_free(r->pub_key); BN_clear_free(r->priv_key); OPENSSL_clear_free((void *)r, sizeof(EC_KEY)); }
void ssl_cert_free(CERT *c) { int i; if (c == NULL) return; CRYPTO_DOWN_REF(&c->references, &i, c->lock); REF_PRINT_COUNT("CERT", c); if (i > 0) return; REF_ASSERT_ISNT(i < 0); #ifndef OPENSSL_NO_DH EVP_PKEY_free(c->dh_tmp); #endif ssl_cert_clear_certs(c); OPENSSL_free(c->conf_sigalgs); OPENSSL_free(c->client_sigalgs); OPENSSL_free(c->shared_sigalgs); OPENSSL_free(c->ctype); X509_STORE_free(c->verify_store); X509_STORE_free(c->chain_store); custom_exts_free(&c->custext); #ifndef OPENSSL_NO_PSK OPENSSL_free(c->psk_identity_hint); #endif CRYPTO_THREAD_lock_free(c->lock); OPENSSL_free(c); }
int DSO_free(DSO *dso) { int i; if (dso == NULL) return (1); if (CRYPTO_DOWN_REF(&dso->references, &i, dso->lock) <= 0) return 0; REF_PRINT_COUNT("DSO", dso); if (i > 0) return 1; REF_ASSERT_ISNT(i < 0); if ((dso->flags & DSO_FLAG_NO_UNLOAD_ON_FREE) == 0) { if ((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso)) { DSOerr(DSO_F_DSO_FREE, DSO_R_UNLOAD_FAILED); return 0; } } if ((dso->meth->finish != NULL) && !dso->meth->finish(dso)) { DSOerr(DSO_F_DSO_FREE, DSO_R_FINISH_FAILED); return 0; } sk_void_free(dso->meth_data); OPENSSL_free(dso->filename); OPENSSL_free(dso->loaded_filename); CRYPTO_THREAD_lock_free(dso->lock); OPENSSL_free(dso); return 1; }
/* Cleans up the given global DRBG */ static void drbg_cleanup(RAND_DRBG *drbg) { if (drbg != NULL) { RAND_DRBG_uninstantiate(drbg); CRYPTO_THREAD_lock_free(drbg->lock); OPENSSL_secure_clear_free(drbg, sizeof(RAND_DRBG)); } }
void rand_cleanup_int(void) { const RAND_METHOD *meth = default_RAND_meth; if (meth != NULL && meth->cleanup != NULL) meth->cleanup(); RAND_set_rand_method(NULL); #ifndef OPENSSL_NO_ENGINE CRYPTO_THREAD_lock_free(rand_engine_lock); #endif CRYPTO_THREAD_lock_free(rand_meth_lock); CRYPTO_THREAD_lock_free(rand_bytes.lock); if (rand_bytes.secure) OPENSSL_secure_clear_free(rand_bytes.buff, rand_bytes.size); else OPENSSL_clear_free(rand_bytes.buff, rand_bytes.size); }
void engine_cleanup_int(void) { if (int_cleanup_check(0)) { sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack, engine_cleanup_cb_free); cleanup_stack = NULL; } CRYPTO_THREAD_lock_free(global_engine_lock); }
static void free_drbg(RAND_DRBG *drbg) { CRYPTO_THREAD_lock_free(drbg->lock); if (drbg->secure) OPENSSL_secure_clear_free(drbg->randomness, drbg->size); else OPENSSL_clear_free(drbg->randomness, drbg->size); RAND_DRBG_uninstantiate(drbg); }
void err_cleanup(void) { if (set_err_thread_local != 0) CRYPTO_THREAD_cleanup_local(&err_thread_local); CRYPTO_THREAD_lock_free(err_string_lock); err_string_lock = NULL; lh_ERR_STRING_DATA_free(int_error_hash); int_error_hash = NULL; }
void UI_free(UI *ui) { if (ui == NULL) return; sk_UI_STRING_pop_free(ui->strings, free_string); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data); CRYPTO_THREAD_lock_free(ui->lock); OPENSSL_free(ui); }
static void provider_store_free(void *vstore) { struct provider_store_st *store = vstore; if (store == NULL) return; sk_OSSL_PROVIDER_pop_free(store->providers, ossl_provider_free); CRYPTO_THREAD_lock_free(store->lock); OPENSSL_free(store); }
int CRYPTO_secure_malloc_done() { #ifdef IMPLEMENTED if (secure_mem_used == 0) { sh_done(); secure_mem_initialized = 0; CRYPTO_THREAD_lock_free(sec_malloc_lock); return 1; } #endif /* IMPLEMENTED */ return 0; }
void UI_free(UI *ui) { if (ui == NULL) return; if ((ui->flags & UI_FLAG_DUPL_DATA) != 0) { ui->meth->ui_destroy_data(ui, ui->user_data); } sk_UI_STRING_pop_free(ui->strings, free_string); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data); CRYPTO_THREAD_lock_free(ui->lock); OPENSSL_free(ui); }
void BN_BLINDING_free(BN_BLINDING *r) { if (r == NULL) return; BN_free(r->A); BN_free(r->Ai); BN_free(r->e); BN_free(r->mod); CRYPTO_THREAD_lock_free(r->lock); OPENSSL_free(r); }
static void EVP_PKEY_free_it(EVP_PKEY *x) { /* internal function; x is never NULL */ if (x->ameth && x->ameth->pkey_free) { x->ameth->pkey_free(x); x->pkey.ptr = NULL; } #ifndef OPENSSL_NO_ENGINE ENGINE_finish(x->engine); x->engine = NULL; #endif CRYPTO_THREAD_lock_free(x->lock); }
int CRYPTO_secure_malloc_done(void) { #ifdef OPENSSL_SECURE_MEMORY if (secure_mem_used == 0) { sh_done(); secure_mem_initialized = 0; CRYPTO_THREAD_lock_free(sec_malloc_lock); sec_malloc_lock = NULL; return 1; } #endif /* OPENSSL_SECURE_MEMORY */ return 0; }
void engine_cleanup_int(void) { if (int_cleanup_check(0)) { sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack, engine_cleanup_cb_free); cleanup_stack = NULL; } /* * FIXME: This should be handled (somehow) through RAND, eg. by it * registering a cleanup callback. */ RAND_set_rand_method(NULL); CRYPTO_THREAD_lock_free(global_engine_lock); }
/* * Uninstantiate |drbg| and free all memory. */ void RAND_DRBG_free(RAND_DRBG *drbg) { if (drbg == NULL) return; if (drbg->meth != NULL) drbg->meth->uninstantiate(drbg); CRYPTO_THREAD_lock_free(drbg->lock); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_DRBG, drbg, &drbg->ex_data); if (drbg->secure) OPENSSL_secure_clear_free(drbg, sizeof(*drbg)); else OPENSSL_clear_free(drbg, sizeof(*drbg)); }