自学教程：C++ CRYPTO_mem_ctrl函数代码示例

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;}

boolSSLContext::Init(X509 *pCert, EVP_PKEY *pPrivatekey){	int nLockCt = CRYPTO_num_locks();	InitializeCryptoLocks(nLockCt);#ifdef _DEBUG    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options	(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl			(CRYPTO_MEM_CHECK_ON);#endif		CRYPTO_set_locking_callback			(&ssl_lock_callback);    CRYPTO_set_dynlock_create_callback	(&ssl_lock_dyn_create_callback);	CRYPTO_set_dynlock_lock_callback	(&ssl_lock_dyn_callback);    CRYPTO_set_dynlock_destroy_callback	(&ssl_lock_dyn_destroy_callback);    SSL_load_error_strings	();    SSL_library_init		();	// Initialize and verify SSL context. {{	const SSL_METHOD* meth = SSLv23_method();	m_pssl_ctx = SSL_CTX_new(meth);	SSL_CTX_set_verify(m_pssl_ctx, SSL_VERIFY_NONE, nullptr);	// }}#ifdef _SERVER	SSL_CTX_set_options(m_pssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE); #endif	if( pCert )		SSL_CTX_use_certificate	(m_pssl_ctx, pCert);	if( pPrivatekey )		SSL_CTX_use_PrivateKey	(m_pssl_ctx, pPrivatekey);	return true;	}

int main(int argc, char **argv)	{	BIO *bio_err;	X509 *x509=NULL;	EVP_PKEY *pkey=NULL;	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);	mkcert(&x509,&pkey,512,0,365);	RSA_print_fp(stdout,pkey->pkey.rsa,0);	X509_print_fp(stdout,x509);	PEM_write_PrivateKey(stdout,pkey,NULL,NULL,0,NULL, NULL);	PEM_write_X509(stdout,x509);	X509_free(x509);	EVP_PKEY_free(pkey);#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	CRYPTO_mem_leaks(bio_err);	BIO_free(bio_err);	return(0);	}

void RSAZCryptor::init(){    m_trace_level = 0;    m_encoding = true;    bio_err = NULL;    priv_mem = NULL;    pub_mem = NULL;    privkey = NULL;    pubkey = NULL;    priv_rsa = NULL;    pub_rsa = NULL;    priv_size = 0;    pub_size = 0;    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);#if defined(_WIN32) || defined(__linux__)    OpenSSL_add_all_ciphers();#else    SSL_library_init();#endif    ERR_load_crypto_strings ();    seed_prng();    m_keycache = new ZKeyCache();    m_filesToBeZIP = NULL;}

int main(int argc, char **argv)	{	BIO *bio_err;	X509_REQ *req=NULL;	EVP_PKEY *pkey=NULL;	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);	mkreq(&req,&pkey,512,0,365);	RSA_print_fp(stdout,pkey->pkey.rsa,0);	X509_REQ_print_fp(stdout,req);	PEM_write_X509_REQ(stdout,req);	X509_REQ_free(req);	EVP_PKEY_free(pkey);#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	CRYPTO_mem_leaks(bio_err);	BIO_free(bio_err);	return(0);	}

CSSLApplication::CSSLApplication(){	if (SSLInited) return;	SSLInited = 1;	NeedDataOp = 0;#ifdef _DEBUG	// OpenSSL internal memory-leak checkers	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#endif	openssl_locks = new Synchronizer[CRYPTO_num_locks()];	// callbacks for static lock	CRYPTO_set_locking_callback(funcOpenSSLLockingCallback);	CRYPTO_set_id_callback(funcOpenSSLIDCallback);	// callbacks for dynamic lock	CRYPTO_set_dynlock_create_callback(funcOpenSSLDynCreateCallback);	CRYPTO_set_dynlock_destroy_callback(funcOpenSSLDynDestroyCallback);	CRYPTO_set_dynlock_lock_callback(funcOpenSSLDynLockCallback);	// Load algorithms and error strings.	SSL_load_error_strings();	SSL_library_init();};

int main(int argc, char *argv[])	{			/* 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();	RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_generate_prime may fail */	prime_field_tests();	puts("");	char2_field_tests();	/* test the internal curves */	internal_curve_test();#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	ERR_remove_state(0);	CRYPTO_mem_leaks_fp(stderr);		return 0;	}

int main(int argc, char **argv){    int i;    testdata *test = test_cases;    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    OpenSSL_add_all_digests();# ifndef OPENSSL_NO_ENGINE    ENGINE_load_builtin_engines();    ENGINE_register_all_digests();# endif    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_ENGINE    ENGINE_cleanup();# endif    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();    CRYPTO_mem_leaks_fp(stderr);    return 0;}

static intcrypto( const char     *key,        bool           decrypt,        const bytes_t  &bytes,        bytes_t        &crypt ){    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    RAND_seed(rnd_seed, sizeof(rnd_seed)); /* or OAEP may fail */	RSA *rsa = NULL;	int rval = loadKey(key, decrypt, &rsa);	if ( rval == 0 )		rval = crypto(rsa, decrypt, bytes, crypt);	RSA_free(rsa);	ERR_print_errors_fp(stdout);    CRYPTO_cleanup_all_ex_data();	EVP_cleanup();	ERR_remove_state(0);    CRYPTO_mem_leaks_fp(stderr);	return ( rval );}

void setup_test(){    char *TAP_levels = getenv("HARNESS_OSSL_LEVEL");    char *test_seed = getenv("OPENSSL_TEST_RAND_ORDER");    test_open_streams();    level = TAP_levels != NULL ? 4 * atoi(TAP_levels) : 0;    if (test_seed != NULL) {        seed = atoi(test_seed);        if (seed <= 0)            seed = time(NULL);        test_printf_stdout("%*s# RAND SEED %d/n", subtest_level(), "", seed);        test_flush_stdout();        srand(seed);    }#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (should_report_leaks()) {        CRYPTO_set_mem_debug(1);        CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    }#endif}

int main(int argc, char **argv){    BIO *bio_err;    bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    /* "Negative" test, expect a mismatch */    if (run_srp("alice", "password1", "password2") == 0) {        fprintf(stderr, "Mismatched SRP run failed/n");        return 1;    }    /* "Positive" test, should pass */    if (run_srp("alice", "password", "password") != 0) {        fprintf(stderr, "Plain SRP run failed/n");        return 1;    }    /* KAT from RFC5054: should pass */    if (run_srp_kat() != 1) {        fprintf(stderr, "SRP KAT failed/n");        return 1;    }#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks(bio_err) <= 0)        return 1;#endif    BIO_free(bio_err);    return 0;}

int main(int argc, char **argv){	if (argc > 2) {		printf("usage: %s [passwd]/n", argv[0]);		return -1;	}	BIO* bio_err;	X509_REQ* req = NULL;	EVP_PKEY* pkey = NULL;	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);	mkreq(&req, &pkey, 1024, 0, 365);	if (argc == 1) {		mkcert(req, "rootkey.pem", "rootcert.pem", NULL);	} else if (argc == 2) {		mkcert(req, "rootkey.pem", "rootcert.pem", argv[1]);	}	RSA_print_fp(stdout, pkey->pkey.rsa, 0);	X509_REQ_print_fp(stdout, req);	PEM_write_X509_REQ(stdout, req);	X509_REQ_free(req);	EVP_PKEY_free(pkey);	CRYPTO_cleanup_all_ex_data();	CRYPTO_mem_leaks(bio_err);	BIO_free(bio_err);	return 0;}

int main(int argc, char *argv[]){#ifndef OPENSSL_NO_CRYPTO_MDEBUG    char *p;    char *lost;    int noleak;    p = getenv("OPENSSL_DEBUG_MEMORY");    if (p != NULL && strcmp(p, "on") == 0)        CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    lost = OPENSSL_malloc(3);    if (!TEST_ptr(lost))        return EXIT_FAILURE;    if (argv[1] && strcmp(argv[1], "freeit") == 0) {        OPENSSL_free(lost);        lost = NULL;    }    noleak = CRYPTO_mem_leaks_fp(stderr);    /* If -1 return value something bad happened */    if (!TEST_int_ne(noleak, -1))        return EXIT_FAILURE;    return TEST_int_eq(lost != NULL, noleak == 0) ? EXIT_SUCCESS : EXIT_FAILURE;#else    return EXIT_SUCCESS;#endif}

int main(){    BIO *bio_err;    X509 *x509 = NULL;    EVP_PKEY *pkey = NULL;    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);    mkit(&x509, &pkey, 512, 0, 365);    RSA_print_fp(stdout, pkey->pkey.rsa, 0);    X509_print_fp(stdout, x509);    PEM_write_PrivateKey(stdout, pkey, NULL, NULL, 0, NULL, NULL);    PEM_write_X509(stdout, x509);    X509_free(x509);    EVP_PKEY_free(pkey);#ifdef CUSTOM_EXT    /* Only needed if we add objects or custom extensions */    X509V3_EXT_cleanup();    OBJ_cleanup();#endif    CRYPTO_mem_leaks(bio_err);    BIO_free(bio_err);    return (0);}

int main(int argc, char **argv){    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    ERR_load_crypto_strings();    OpenSSL_add_all_digests();    if (argc != 4) {        fprintf(stderr, "usage: verify_extra_test roots.pem untrusted.pem bad.pem/n");        return 1;    }    if (!test_alt_chains_cert_forgery(argv[1], argv[2], argv[3])) {        fprintf(stderr, "Test alt chains cert forgery failed/n");        return 1;    }    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        return 1;#endif    printf("PASS/n");    return 0;}

int main(int argc, char **argv)	{	BIO *bio_err;	bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	ERR_load_crypto_strings();	/* "Negative" test, expect a mismatch */	if(run_srp("alice", "password1", "password2") == 0)		{		fprintf(stderr, "Mismatched SRP run failed/n");		return 1;		}	/* "Positive" test, should pass */	if(run_srp("alice", "password", "password") != 0)		{		fprintf(stderr, "Plain SRP run failed/n");		return 1;		}	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	ERR_free_strings();	CRYPTO_mem_leaks(bio_err);	return 0;	}

boolSSLSocketServer::SSL_Init(){	int nLockCt = CRYPTO_num_locks();	InitializeCryptoLocks(nLockCt);#ifdef _DEBUG    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options	(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl			(CRYPTO_MEM_CHECK_ON);#endif		CRYPTO_set_locking_callback			(&ssl_lock_callback);    CRYPTO_set_dynlock_create_callback	(&ssl_lock_dyn_create_callback);	CRYPTO_set_dynlock_lock_callback	(&ssl_lock_dyn_callback);    CRYPTO_set_dynlock_destroy_callback	(&ssl_lock_dyn_destroy_callback);    SSL_load_error_strings	();    SSL_library_init		();	// Initialize and verify SSL context. {{	const SSL_METHOD* meth = SSLv23_method();	m_pssl_ctx = SSL_CTX_new(meth);	SSL_CTX_set_verify(m_pssl_ctx, SSL_VERIFY_NONE, nullptr);	// }}	::InitializeCriticalSection(&m_lock_connect_ex);	return true;	}

int main(int argc, char **argv){#ifdef CRYPTO_MDEBUG    char *p;    char *lost;    p = getenv("OPENSSL_DEBUG_MEMORY");    if (p != NULL && strcmp(p, "on") == 0)        CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    lost = OPENSSL_malloc(3);    if (lost == NULL) {        fprintf(stderr, "OPENSSL_malloc failed/n");        return 1;    }    if (argv[1] && strcmp(argv[1], "freeit") == 0)        OPENSSL_free(lost);    CRYPTO_mem_leaks_fp(stderr);    return 0;#else    if (argv[1] && strcmp(argv[1], "freeit") == 0)        return 0;    fprintf(stderr, "Leak simulated/n");    return 1;#endif}

void mem_debug_end(){	char *logFile = "leak.log";	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF);	BIO *b = BIO_new_file(logFile,"w");	CRYPTO_mem_leaks(b);	BIO_free(b);}

voidApplication::initSSL(){    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    RAND_seed(kRandSeed, sizeof(kRandSeed));}

/**   /ingroup Core_Crypto   /brief initialises openssl   /note Would usually call ops_init() instead   /sa ops_init()*/void ops_crypto_init()    {#ifdef DMALLOC    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#endif    }

/* * call-seq: *   OpenSSL.debug = boolean -> boolean * * Turns on or off CRYPTO_MEM_CHECK. * Also shows some debugging message on stderr. */static VALUEossl_debug_set(VALUE self, VALUE val){    VALUE old = dOSSL;    dOSSL = val;    if (old != dOSSL) {	if (dOSSL == Qtrue) {	    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	    fprintf(stderr, "OSSL_DEBUG: IS NOW ON!/n");	} else if (old == Qtrue) {	    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF);	    fprintf(stderr, "OSSL_DEBUG: IS NOW OFF!/n");	}    }    return val;}

int ssl_test_ecdh(int argc, char *argv[])	{	BN_CTX *ctx=NULL;	int ret=1;	BIO *out;	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#ifdef OPENSSL_SYS_WIN32	CRYPTO_malloc_init();#endif	RAND_seed(rnd_seed, sizeof rnd_seed);#ifndef OPENSSL_SYS_WINDOWS	out = BIO_new(BIO_s_mem());	if (out == NULL) return(1);#else	out=BIO_new(BIO_s_file());	if (out == NULL) return(1);	BIO_set_fp(out,OPENSSL_TYPE__FILE_STDOUT,BIO_NOCLOSE);#endif		if ((ctx=BN_CTX_new()) == NULL) goto err;	/* NIST PRIME CURVES TESTS */	if (!test_ecdh_curve(NID_X9_62_prime192v1, "NIST Prime-Curve P-192", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp224r1, "NIST Prime-Curve P-224", ctx, out)) goto err;	if (!test_ecdh_curve(NID_X9_62_prime256v1, "NIST Prime-Curve P-256", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp384r1, "NIST Prime-Curve P-384", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp521r1, "NIST Prime-Curve P-521", ctx, out)) goto err;	/* NIST BINARY CURVES TESTS */	if (!test_ecdh_curve(NID_sect163k1, "NIST Binary-Curve K-163", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect163r2, "NIST Binary-Curve B-163", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect233k1, "NIST Binary-Curve K-233", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect233r1, "NIST Binary-Curve B-233", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect283k1, "NIST Binary-Curve K-283", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect283r1, "NIST Binary-Curve B-283", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect409k1, "NIST Binary-Curve K-409", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect409r1, "NIST Binary-Curve B-409", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect571k1, "NIST Binary-Curve K-571", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect571r1, "NIST Binary-Curve B-571", ctx, out)) goto err;	ret = 0;err:	ERR_print_errors_fp(OPENSSL_TYPE__FILE_STDERR);	if (ctx) BN_CTX_free(ctx);	BIO_free(out);	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	CRYPTO_mem_leaks_fp(OPENSSL_TYPE__FILE_STDERR);	return(ret);	}

int main(void){    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    ERR_load_crypto_strings();    /* Load up the software EVP_CIPHER and EVP_MD definitions */    OpenSSL_add_all_ciphers();    OpenSSL_add_all_digests();    if (!test_EVP_DigestSignInit()) {        fprintf(stderr, "EVP_DigestSignInit failed/n");        return 1;    }    if (!test_EVP_DigestVerifyInit()) {        fprintf(stderr, "EVP_DigestVerifyInit failed/n");        return 1;    }    if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),                                 EVP_PKEY_RSA)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed/n");        return 1;    }    if (!test_d2i_AutoPrivateKey        (kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed/n");        return 1;    }#ifndef OPENSSL_NO_EC    if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),                                 EVP_PKEY_EC)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed/n");        return 1;    }    if (!test_EVP_PKCS82PKEY()) {        fprintf(stderr, "test_EVP_PKCS82PKEY failed/n");        return 1;    }#endif    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        return 1;#endif    printf("PASS/n");    return 0;}

void setup_test(){#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (should_report_leaks()) {        CRYPTO_set_mem_debug(1);        CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    }#endif}

isc_result_tdst__openssl_init() {	isc_result_t result;#ifdef  DNS_CRYPTO_LEAKS	CRYPTO_malloc_debug_init();	CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#endif	CRYPTO_set_mem_functions(mem_alloc, mem_realloc, mem_free);	nlocks = CRYPTO_num_locks();	locks = mem_alloc(sizeof(isc_mutex_t) * nlocks);	if (locks == NULL)		return (ISC_R_NOMEMORY);	result = isc_mutexblock_init(locks, nlocks);	if (result != ISC_R_SUCCESS)		goto cleanup_mutexalloc;	CRYPTO_set_locking_callback(lock_callback);	CRYPTO_set_id_callback(id_callback);	rm = mem_alloc(sizeof(RAND_METHOD));	if (rm == NULL) {		result = ISC_R_NOMEMORY;		goto cleanup_mutexinit;	}	rm->seed = NULL;	rm->bytes = entropy_get;	rm->cleanup = NULL;	rm->add = entropy_add;	rm->pseudorand = entropy_getpseudo;	rm->status = entropy_status;#ifdef USE_ENGINE	e = ENGINE_new();	if (e == NULL) {		result = ISC_R_NOMEMORY;		goto cleanup_rm;	}	ENGINE_set_RAND(e, rm);	RAND_set_rand_method(rm);#else	RAND_set_rand_method(rm);#endif /* USE_ENGINE */	return (ISC_R_SUCCESS);#ifdef USE_ENGINE cleanup_rm:	mem_free(rm);#endif cleanup_mutexinit:	CRYPTO_set_locking_callback(NULL);	DESTROYMUTEXBLOCK(locks, nlocks); cleanup_mutexalloc:	mem_free(locks);	return (result);}

int main(int argc, char *argv[]){    BN_CTX *ctx = NULL;    int nid, ret = 1;    EC_builtin_curve *curves = NULL;    size_t crv_len = 0, n = 0;    BIO *out;    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    RAND_seed(rnd_seed, sizeof rnd_seed);    out = BIO_new(BIO_s_file());    if (out == NULL)        EXIT(1);    BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);    if ((ctx = BN_CTX_new()) == NULL)        goto err;    /* get a list of all internal curves */    crv_len = EC_get_builtin_curves(NULL, 0);    curves = OPENSSL_malloc(sizeof(*curves) * crv_len);    if (curves == NULL) goto err;    if (!EC_get_builtin_curves(curves, crv_len)) goto err;    /* NAMED CURVES TESTS */    for (n = 0; n < crv_len; n++) {        nid = curves[n].nid;        if (!test_ecdh_curve(nid, ctx, out)) goto err;    }    /* KATs */    for (n = 0; n < (sizeof(ecdh_kats)/sizeof(ecdh_kat_t)); n++) {        if (!ecdh_kat(out, &ecdh_kats[n]))            goto err;    }    ret = 0; err:    ERR_print_errors_fp(stderr);    OPENSSL_free(curves);    BN_CTX_free(ctx);    BIO_free(out);    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        ret = 1;#endif    EXIT(ret);}

int main(int argc, char *argv[]) {  int ret = 1;  BIO *out;  CRYPTO_malloc_debug_init();  CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);  CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#ifdef OPENSSL_SYS_WIN32  CRYPTO_malloc_init();#endif  RAND_seed(rnd_seed, sizeof rnd_seed);  out = BIO_new(BIO_s_file());  if (out == NULL) EXIT(1);  BIO_set_fp(out, stdout, BIO_NOCLOSE);  if (argc == 1) {    if (!test_lwekex(out, 1)) goto err;  } else if (argc == 2 && !strcmp((const char *)argv[1], "cont")) {    BIO_printf(out, "Running continuous test. ^C to quit./n/n");    int iterations = 0;    int failures = 0;    time_t starttime = time(NULL);    while (1) {      iterations++;      if (test_lwekex(out, 0) == 1) {      } else {        failures++;      }      if ((iterations % 100) == 0) {        BIO_printf(out, "Iterations: %d, failures: %d, elapsed time: %ld/n",                   iterations, failures, time(NULL) - starttime);        if (iterations > (1 << 20)) break;      }    }  } else {    BIO_printf(out,               "Error: argument must be /"cont/" for invoking /continuously run test./n");  }  ret = 0;err:  ERR_print_errors_fp(stderr);  BIO_free(out);  CRYPTO_cleanup_all_ex_data();  ERR_remove_thread_state(NULL);  CRYPTO_mem_leaks_fp(stderr);  EXIT(ret);  return (ret);}

int main(int argc, char *argv[]){    BIO *err = NULL;    int testresult = 1;    if (argc != 3) {        printf("Invalid argument count/n");        return 1;    }    cert = argv[1];    privkey = argv[2];    err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    ADD_TEST(test_large_message_tls);    ADD_TEST(test_large_message_tls_read_ahead);#ifndef OPENSSL_NO_DTLS    ADD_TEST(test_large_message_dtls);#endif#ifndef OPENSSL_NO_OCSP    ADD_TEST(test_tlsext_status_type);#endif    ADD_TEST(test_session_with_only_int_cache);    ADD_TEST(test_session_with_only_ext_cache);    ADD_TEST(test_session_with_both_cache);    ADD_ALL_TESTS(test_ssl_set_bio, TOTAL_SSL_SET_BIO_TESTS);    ADD_TEST(test_ssl_bio_pop_next_bio);    ADD_TEST(test_ssl_bio_pop_ssl_bio);    ADD_TEST(test_ssl_bio_change_rbio);    ADD_TEST(test_ssl_bio_change_wbio);    ADD_ALL_TESTS(test_set_sigalgs, OSSL_NELEM(testsigalgs) * 2);    ADD_ALL_TESTS(test_custom_exts, 2);    testresult = run_tests(argv[0]);    bio_s_mempacket_test_free();#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks(err) <= 0)        testresult = 1;#endif    BIO_free(err);    if (!testresult)        printf("PASS/n");    return testresult;}