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

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

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

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

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

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

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

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

/* Notice the program will be memory leak, as Mem_lhas is not free, ** and record the user malloc informations. */int main(){	char *p = NULL;	int i;	BIO *b = NULL;	// There are two methods calls debug functions.	// 1, build with -DCRYPTO_MDEBUG	// 2, CRYPTO_malloc_debug_init(), CRYPTO_set_mem_debug_options()	CRYPTO_malloc_debug_init();	CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);	MemCheck_start();	//p = OPENSSL_malloc(4);	//p = OPENSSL_remalloc(p, 40);	p = OPENSSL_malloc(1024);	for(i = 0; i < 1024; i++)		memset(&p[i], i, 1);		OPENSSL_free(p);	b = BIO_new_file("leak.log", "w");	CRYPTO_mem_leaks(b);		BIO_free(b);		return 0;}

/**   /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    }

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

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

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(void){    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    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();    CRYPTO_mem_leaks_fp(stderr);    printf("PASS/n");    return 0;}

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(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_state(0);    ERR_free_strings();    CRYPTO_mem_leaks(out);    if (out != NULL)        BIO_free(out);    return ret;}

void OPENSSL_init(void){#ifdef OPENSSL_FIPS    static int done = 0;    if (!done) {        int_ERR_lib_init();# ifdef CRYPTO_MDEBUG        CRYPTO_malloc_debug_init();# endif# ifndef OPENSSL_NO_ENGINE        int_EVP_MD_init_engine_callbacks();        int_EVP_CIPHER_init_engine_callbacks();        int_RAND_init_engine_callbacks();# endif        done = 1;    }#endif}

int main(int argc, char **argv){#ifdef ASYNC_NULL    fprintf(stderr, "NULL implementation - skipping async tests/n");#else    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    if (       !test_ASYNC_init()            || !test_ASYNC_start_job()            || !test_ASYNC_get_current_job()            || !test_ASYNC_get_wait_fd()            || !test_ASYNC_block_pause()) {        return 1;    }#endif    printf("PASS/n");    return 0;}

int main(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));    out = BIO_new(BIO_s_file());    if (out == NULL)        EXIT(1);    BIO_set_fp(out, stdout, BIO_NOCLOSE);    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;# ifndef OPENSSL_NO_EC2M    /* 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;# endif    if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP256r1", 256))        goto err;    if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP384r1", 384))        goto err;    if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP512r1", 512))        goto err;    ret = 0; err:    ERR_print_errors_fp(stderr);    if (ctx)        BN_CTX_free(ctx);    BIO_free(out);    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    CRYPTO_mem_leaks_fp(stderr);    EXIT(ret);    return (ret);}

//.........这里部分代码省略.........        if (client_cert == NULL) {            printf("/nError while reading PEM encoded client certificate file %s/n", client_cert_file);            exit(1);        }        BIO_free(certin);    }    /*     * Read in the client's private key     */    if (client_key_file[0]) {        keyin = BIO_new(BIO_s_file_internal());        if (BIO_read_filename(keyin, client_key_file) <= 0) {            printf("/nUnable to read client private key file %s/n", client_key_file);            exit(1);        }        /*         * This reads in the private key file, which is expected to be a PEM         * encoded private key.  If using DER encoding, you would invoke         * d2i_PrivateKey_bio() instead.         */        client_priv_key = PEM_read_bio_PrivateKey(keyin, NULL, NULL, NULL);        if (client_priv_key == NULL) {            printf("/nError while reading PEM encoded private key file %s/n", client_key_file);            ERR_print_errors_fp(stderr);            exit(1);        }        BIO_free(keyin);    }    est_apps_startup();#if DEBUG_OSSL_LEAKS    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#endif    if (verbose) {        est_init_logger(EST_LOG_LVL_INFO, &test_logger_stdout);        est_enable_backtrace(1);    } else {        est_init_logger(EST_LOG_LVL_ERR, &test_logger_stdout);    }    if (!priv_key_file[0] && enroll && !csr_file[0]) {	printf("/nA private key is required for enrolling.  Creating a new RSA key pair since you didn't provide a key using the -x option.");        /*         * Create a private key that will be used for the         * enroll operation.         */        new_pkey = generate_private_key(&new_pkey_len);        snprintf(file_name, MAX_FILENAME_LEN, "%s/newkey.pem", out_dir);        write_binary_file(file_name, new_pkey, new_pkey_len);        free(new_pkey);        /*         * prepare to read it back in to an EVP_PKEY struct         */        strncpy(priv_key_file, file_name, MAX_FILENAME_LEN);    }    if (enroll && !csr_file[0]) {	/* Read in the private key file */	priv_key = read_private_key(priv_key_file);

int openssl_main(int Argc, char *Argv[])#endif	{	ARGS arg;#define PROG_NAME_SIZE	39	char pname[PROG_NAME_SIZE+1];	FUNCTION f,*fp;	MS_STATIC const char *prompt;	MS_STATIC char buf[1024];	char *to_free=NULL;	int n,i,ret=0;	int argc;	char **argv,*p;	LHASH *prog=NULL;	long errline;	arg.data=NULL;	arg.count=0;	if (bio_err == NULL)		if ((bio_err=BIO_new(BIO_s_file())) != NULL)#ifdef SYMBIAN        BIO_set_fp(bio_err,fp_stderr,BIO_NOCLOSE|BIO_FP_TEXT);#else        BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);#endif	if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) /* if not defined, use compiled-in library defaults */		{		if (!(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);#if 0	if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)#endif		{		CRYPTO_set_locking_callback(lock_dbg_cb);		}	apps_startup();	/* Lets load up our environment a little */	p=getenv("OPENSSL_CONF");	if (p == NULL)		p=getenv("SSLEAY_CONF");	if (p == NULL)		p=to_free=make_config_name();	default_config_file=p;	config=NCONF_new(NULL);	i=NCONF_load(config,p,&errline);	if (i == 0)		{		NCONF_free(config);		config = NULL;		ERR_clear_error();		}	prog=prog_init();	/* first check the program name */	program_name(Argv[0],pname,sizeof pname);	f.name=pname;	fp=(FUNCTION *)lh_retrieve(prog,&f);	if (fp != NULL)		{		Argv[0]=pname;		ret=fp->func(Argc,Argv);		goto end;		}	/* ok, now check that there are not arguments, if there are,	 * run with them, shifting the ssleay off the front */	if (Argc != 1)		{		Argc--;		Argv++;		ret=do_cmd(prog,Argc,Argv);		if (ret < 0) ret=0;		goto end;		}	/* ok, lets enter the old 'OpenSSL>' mode */	for (;;)		{		ret=0;		p=buf;		n=sizeof buf;//.........这里部分代码省略.........

int main(int Argc, char *Argv[])	{	ARGS arg;#define PROG_NAME_SIZE	39	char pname[PROG_NAME_SIZE+1];	FUNCTION f,*fp;	MS_STATIC const char *prompt;	MS_STATIC char buf[1024];	char *to_free=NULL;	int n,i,ret=0;	int argc;	char **argv,*p;	LHASH_OF(FUNCTION) *prog=NULL;	long errline; 	arg.data=NULL;	arg.count=0;	if (bio_err == NULL)		if ((bio_err=BIO_new(BIO_s_file())) != NULL)			BIO_set_fp(bio_err,OPENSSL_TYPE__FILE_STDERR,BIO_NOCLOSE|BIO_FP_TEXT);	if (TINYCLR_SSL_GETENV("OPENSSL_DEBUG_MEMORY") != NULL) /* if not defined, use compiled-in library defaults */		{		if (!(0 == TINYCLR_SSL_STRCMP(TINYCLR_SSL_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);#if 0	if (TINYCLR_SSL_GETENV("OPENSSL_DEBUG_LOCKING") != NULL)#endif		{		CRYPTO_set_locking_callback(lock_dbg_cb);		}	apps_startup();	/* Lets load up our environment a little */	p=TINYCLR_SSL_GETENV("OPENSSL_CONF");	if (p == NULL)		p=TINYCLR_SSL_GETENV("SSLEAY_CONF");	if (p == NULL)		p=to_free=make_config_name();	default_config_file=p;	config=NCONF_new(NULL);	i=NCONF_load(config,p,&errline);	if (i == 0)		{		if (ERR_GET_REASON(ERR_peek_last_error())		    == CONF_R_NO_SUCH_FILE)			{			BIO_printf(bio_err,				   "WARNING: can't open config file: %s/n",p);			ERR_clear_error();			NCONF_free(config);			config = NULL;			}		else			{			ERR_print_errors(bio_err);			NCONF_free(config);			TINYCLR_SSL_EXIT(1);			}		}	prog=prog_init();	/* first check the program name */	program_name(Argv[0],pname,sizeof pname);	f.name=pname;	fp=lh_FUNCTION_retrieve(prog,&f);	if (fp != NULL)		{		Argv[0]=pname;		ret=fp->func(Argc,Argv);		goto end;		}	/* ok, now check that there are not arguments, if there are,	 * run with them, shifting the ssleay off the front */	if (Argc != 1)		{		Argc--;		Argv++;		ret=do_cmd(prog,Argc,Argv);		if (ret < 0) ret=0;		goto end;		}//.........这里部分代码省略.........

int main(int argc, char *argv[]){    FUNCTION f, *fp;    LHASH_OF(FUNCTION) *prog = NULL;    char **copied_argv = NULL;    char *p, *pname;    char buf[1024];    const char *prompt;    ARGS arg;    int first, n, i, ret = 0;    arg.argv = NULL;    arg.size = 0;    /* Set up some of the environment. */    default_config_file = make_config_name();    bio_in = dup_bio_in(FORMAT_TEXT);    bio_out = dup_bio_out(FORMAT_TEXT);    bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);#if defined( OPENSSL_SYS_VMS)    copied_argv = argv = copy_argv(&argc, argv);#endif    p = getenv("OPENSSL_DEBUG_MEMORY");    if (p == NULL)        /* if not set, use compiled-in default */        ;    else if (strcmp(p, "off") != 0) {        CRYPTO_malloc_debug_init();        CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    } else {        CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);    }    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    CRYPTO_set_locking_callback(lock_dbg_cb);    if (getenv("OPENSSL_FIPS")) {#ifdef OPENSSL_FIPS        if (!FIPS_mode_set(1)) {            ERR_load_crypto_strings();            ERR_print_errors(bio_err);            return 1;        }#else        BIO_printf(bio_err, "FIPS mode not supported./n");        return 1;#endif    }    if (!apps_startup())        goto end;    prog = prog_init();    pname = opt_progname(argv[0]);    /* first check the program name */    f.name = pname;    fp = lh_FUNCTION_retrieve(prog, &f);    if (fp != NULL) {        argv[0] = pname;        ret = fp->func(argc, argv);        goto end;    }    /* If there is stuff on the command line, run with that. */    if (argc != 1) {        argc--;        argv++;        ret = do_cmd(prog, argc, argv);        if (ret < 0)            ret = 0;        goto end;    }    /* ok, lets enter interactive mode */    for (;;) {        ret = 0;        /* Read a line, continue reading if line ends with / */        for (p = buf, n = sizeof buf, i = 0, first = 1; n > 0; first = 0) {            prompt = first ? "OpenSSL> " : "> ";            p[0] = '/0';#ifndef READLINE            fputs(prompt, stdout);            fflush(stdout);            if (!fgets(p, n, stdin))                goto end;            if (p[0] == '/0')                goto end;            i = strlen(p);            if (i <= 1)                break;            if (p[i - 2] != '//')                break;            i -= 2;            p += i;            n -= i;#else            {                extern char *readline(const char *);//.........这里部分代码省略.........

int main(int Argc, char *ARGV[]){    ARGS arg;#define PROG_NAME_SIZE	39    char pname[PROG_NAME_SIZE+1];    FUNCTION f,*fp;    MS_STATIC const char *prompt;    MS_STATIC char buf[1024];    char *to_free=NULL;    int n,i,ret=0;    int argc;    char **argv,*p;    LHASH_OF(FUNCTION) *prog=NULL;    long errline;#if defined( OPENSSL_SYS_VMS) && (__INITIAL_POINTER_SIZE == 64)    /* 2011-03-22 SMS.     * If we have 32-bit pointers everywhere, then we're safe, and     * we bypass this mess, as on non-VMS systems.  (See ARGV,     * above.)     * Problem 1: Compaq/HP C before V7.3 always used 32-bit     * pointers for argv[].     * Fix 1: For a 32-bit argv[], when we're using 64-bit pointers     * everywhere else, we always allocate and use a 64-bit     * duplicate of argv[].     * Problem 2: Compaq/HP C V7.3 (Alpha, IA64) before ECO1 failed     * to NULL-terminate a 64-bit argv[].  (As this was written, the     * compiler ECO was available only on IA64.)     * Fix 2: Unless advised not to (VMS_TRUST_ARGV), we test a     * 64-bit argv[argc] for NULL, and, if necessary, use a     * (properly) NULL-terminated (64-bit) duplicate of argv[].     * The same code is used in either case to duplicate argv[].     * Some of these decisions could be handled in preprocessing,     * but the code tends to get even uglier, and the penalty for     * deciding at compile- or run-time is tiny.     */    char **Argv = NULL;    int free_Argv = 0;    if ((sizeof( _Argv) < 8)        /* 32-bit argv[]. */# if !defined( VMS_TRUST_ARGV)            || (_Argv[ Argc] != NULL)      /* Untrusted argv[argc] not NULL. */# endif       )    {        int i;        Argv = OPENSSL_malloc( (Argc+ 1)* sizeof( char *));        if (Argv == NULL)        {            ret = -1;            goto end;        }        for(i = 0; i < Argc; i++)            Argv[i] = _Argv[i];        Argv[ Argc] = NULL;     /* Certain NULL termination. */        free_Argv = 1;    }    else    {        /* Use the known-good 32-bit argv[] (which needs the         * type cast to satisfy the compiler), or the trusted or         * tested-good 64-bit argv[] as-is. */        Argv = (char **)_Argv;    }#endif /* defined( OPENSSL_SYS_VMS) && (__INITIAL_POINTER_SIZE == 64) */    arg.data=NULL;    arg.count=0;    if (bio_err == NULL)        if ((bio_err=BIO_new(BIO_s_file())) != NULL)            BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);    if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) /* if not defined, use compiled-in library defaults */    {        if (!(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);#if 0    if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)#endif    {        CRYPTO_set_locking_callback(lock_dbg_cb);    }    apps_startup();    /* Lets load up our environment a little */    p=getenv("OPENSSL_CONF");    if (p == NULL)//.........这里部分代码省略.........

//.........这里部分代码省略.........     * (base 16)     */    rb_define_const(mOSSL, "OPENSSL_VERSION_NUMBER", INT2NUM(OPENSSL_VERSION_NUMBER));    /*     * Boolean indicating whether OpenSSL is FIPS-capable or not     */    rb_define_const(mOSSL, "OPENSSL_FIPS",#ifdef OPENSSL_FIPS		    Qtrue#else		    Qfalse#endif		   );    rb_define_module_function(mOSSL, "fips_mode", ossl_fips_mode_get, 0);    rb_define_module_function(mOSSL, "fips_mode=", ossl_fips_mode_set, 1);    /*     * Generic error,     * common for all classes under OpenSSL module     */    eOSSLError = rb_define_class_under(mOSSL,"OpenSSLError",rb_eStandardError);    rb_global_variable(&eOSSLError);    /*     * Init debug core     */    dOSSL = Qfalse;    rb_global_variable(&dOSSL);    rb_define_module_function(mOSSL, "debug", ossl_debug_get, 0);    rb_define_module_function(mOSSL, "debug=", ossl_debug_set, 1);    rb_define_module_function(mOSSL, "errors", ossl_get_errors, 0);    /*     * Get ID of to_der     */    ossl_s_to_der = rb_intern("to_der");#if !defined(HAVE_OPENSSL_110_THREADING_API)    Init_ossl_locks();#endif    /*     * Init components     */    Init_ossl_bn();    Init_ossl_cipher();    Init_ossl_config();    Init_ossl_digest();    Init_ossl_hmac();    Init_ossl_ns_spki();    Init_ossl_pkcs12();    Init_ossl_pkcs7();    Init_ossl_pkey();    Init_ossl_rand();    Init_ossl_ssl();    Init_ossl_x509();    Init_ossl_ocsp();    Init_ossl_engine();    Init_ossl_asn1();    Init_ossl_kdf();#if defined(OSSL_DEBUG)    /*     * For debugging Ruby/OpenSSL. Enable only when built with --enable-debug     */#if !defined(LIBRESSL_VERSION_NUMBER) && /    (OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(OPENSSL_NO_CRYPTO_MDEBUG) || /     defined(CRYPTO_malloc_debug_init))    rb_define_module_function(mOSSL, "mem_check_start", mem_check_start, 0);    rb_define_module_function(mOSSL, "print_mem_leaks", print_mem_leaks, 0);#if defined(CRYPTO_malloc_debug_init) /* <= 1.0.2 */    CRYPTO_malloc_debug_init();#endif#if defined(V_CRYPTO_MDEBUG_ALL) /* <= 1.0.2 */    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);#endif#if OPENSSL_VERSION_NUMBER < 0x10100000 /* <= 1.0.2 */    {	int i;	/*	 * See crypto/ex_data.c; call def_get_class() immediately to avoid	 * allocations. 15 is the maximum number that is used as the class index	 * in OpenSSL 1.0.2.	 */	for (i = 0; i <= 15; i++) {	    if (CRYPTO_get_ex_new_index(i, 0, (void *)"ossl-mdebug-dummy", 0, 0, 0) < 0)		rb_raise(rb_eRuntimeError, "CRYPTO_get_ex_new_index for "			 "class index %d failed", i);	}    }#endif#endif#endif}

int ssl_test_dsa(int argc, char **argv)	{	BN_GENCB cb;	DSA *dsa=NULL;	int counter,ret=0,i,j;	unsigned char buf[256];	unsigned long h;	unsigned char sig[256];	unsigned int siglen;#ifndef OPENSSL_SYS_WINDOWS		bio_err = BIO_new(BIO_s_mem());		if (bio_err == NULL) return(1);	#else		if (bio_err == NULL)			bio_err=BIO_new_fp(OPENSSL_TYPE__FILE_STDERR,BIO_NOCLOSE);#endif	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	ERR_load_crypto_strings();	RAND_seed(rnd_seed, sizeof rnd_seed);	TINYCLR_SSL_PRINTF("test generation of DSA parameters/n");	BN_GENCB_set(&cb, dsa_cb, bio_err);	if(((dsa = DSA_new()) == NULL) || !DSA_generate_parameters_ex(dsa, 512,				seed, 20, &counter, &h, &cb))		goto end;	TINYCLR_SSL_PRINTF("seed/n");	for (i=0; i<20; i+=4)		{		TINYCLR_SSL_PRINTF("%02X%02X%02X%02X ",			seed[i],seed[i+1],seed[i+2],seed[i+3]);		}	TINYCLR_SSL_PRINTF("/ncounter=%d h=%ld/n",counter,h);			DSA_print(bio_err,dsa,0);	if (counter != 105) 		{		TINYCLR_SSL_PRINTF("counter should be 105/n");		goto end;		}	if (h != 2)		{		TINYCLR_SSL_PRINTF("h should be 2/n");		goto end;		}	i=BN_bn2bin(dsa->q,buf);	j=sizeof(out_q);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_q,i) != 0))		{		TINYCLR_SSL_PRINTF("q value is wrong/n");		goto end;		}	i=BN_bn2bin(dsa->p,buf);	j=sizeof(out_p);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_p,i) != 0))		{		TINYCLR_SSL_PRINTF("p value is wrong/n");		goto end;		}	i=BN_bn2bin(dsa->g,buf);	j=sizeof(out_g);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_g,i) != 0))		{		TINYCLR_SSL_PRINTF("g value is wrong/n");		goto end;		}	dsa->flags |= DSA_FLAG_NO_EXP_CONSTTIME;	DSA_generate_key(dsa);	DSA_sign(0, str1, 20, sig, &siglen, dsa);	if (DSA_verify(0, str1, 20, sig, siglen, dsa) == 1)		ret=1;	dsa->flags &= ~DSA_FLAG_NO_EXP_CONSTTIME;	DSA_generate_key(dsa);	DSA_sign(0, str1, 20, sig, &siglen, dsa);	if (DSA_verify(0, str1, 20, sig, siglen, dsa) == 1)		ret=1;end:	if (!ret)		ERR_print_errors(bio_err);	if (dsa != NULL) DSA_free(dsa);	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	ERR_free_strings();	CRYPTO_mem_leaks(bio_err);	if (bio_err != NULL)		{		BIO_free(bio_err);//.........这里部分代码省略.........

int main(int argc, char *argv[])	{	ENGINE *block[512];	char buf[256];	const char *id, *name;	ENGINE *ptr;	int loop;	int to_return = 1;	ENGINE *new_h1 = NULL;	ENGINE *new_h2 = NULL;	ENGINE *new_h3 = NULL;	ENGINE *new_h4 = NULL;	/* 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();	memset(block, 0, 512 * sizeof(ENGINE *));	if(((new_h1 = ENGINE_new()) == NULL) ||			!ENGINE_set_id(new_h1, "test_id0") ||			!ENGINE_set_name(new_h1, "First test item") ||			((new_h2 = ENGINE_new()) == NULL) ||			!ENGINE_set_id(new_h2, "test_id1") ||			!ENGINE_set_name(new_h2, "Second test item") ||			((new_h3 = ENGINE_new()) == NULL) ||			!ENGINE_set_id(new_h3, "test_id2") ||			!ENGINE_set_name(new_h3, "Third test item") ||			((new_h4 = ENGINE_new()) == NULL) ||			!ENGINE_set_id(new_h4, "test_id3") ||			!ENGINE_set_name(new_h4, "Fourth test item"))		{		printf("Couldn't set up test ENGINE structures/n");		goto end;		}	printf("/nenginetest beginning/n/n");	display_engine_list();	if(!ENGINE_add(new_h1))		{		printf("Add failed!/n");		goto end;		}	display_engine_list();	ptr = ENGINE_get_first();	if(!ENGINE_remove(ptr))		{		printf("Remove failed!/n");		goto end;		}	if (ptr)		ENGINE_free(ptr);	display_engine_list();	if(!ENGINE_add(new_h3) || !ENGINE_add(new_h2))		{		printf("Add failed!/n");		goto end;		}	display_engine_list();	if(!ENGINE_remove(new_h2))		{		printf("Remove failed!/n");		goto end;		}	display_engine_list();	if(!ENGINE_add(new_h4))		{		printf("Add failed!/n");		goto end;		}	display_engine_list();	if(ENGINE_add(new_h3))		{		printf("Add *should* have failed but didn't!/n");		goto end;		}	else		printf("Add that should fail did./n");	ERR_clear_error();	if(ENGINE_remove(new_h2))		{		printf("Remove *should* have failed but didn't!/n");		goto end;		}	else		printf("Remove that should fail did./n");	ERR_clear_error();	if(!ENGINE_remove(new_h3))		{		printf("Remove failed!/n");		goto end;		}//.........这里部分代码省略.........

int main(int argc,char **argv)    {    const char *szTestFile;    FILE *f;    if(argc != 2)	{	fprintf(stderr,"%s <test file>/n",argv[0]);	EXIT(1);	}    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    szTestFile=argv[1];    f=fopen(szTestFile,"r");    if(!f)	{	perror(szTestFile);	EXIT(2);	}    /* Load up the software EVP_CIPHER and EVP_MD definitions */    OpenSSL_add_all_ciphers();    OpenSSL_add_all_digests();#ifndef OPENSSL_NO_ENGINE    /* Load all compiled-in ENGINEs */    ENGINE_load_builtin_engines();#endif#if 0    OPENSSL_config();#endif#ifndef OPENSSL_NO_ENGINE    /* Register all available ENGINE implementations of ciphers and digests.     * This could perhaps be changed to "ENGINE_register_all_complete()"? */    ENGINE_register_all_ciphers();    ENGINE_register_all_digests();    /* If we add command-line options, this statement should be switchable.     * It'll prevent ENGINEs being ENGINE_init()ialised for cipher/digest use if     * they weren't already initialised. */    /* ENGINE_set_cipher_flags(ENGINE_CIPHER_FLAG_NOINIT); */#endif    for( ; ; )	{	char line[4096];	char *p;	char *cipher;	unsigned char *iv,*key,*plaintext,*ciphertext;	int encdec;	int kn,in,pn,cn;	if(!fgets((char *)line,sizeof line,f))	    break;	if(line[0] == '#' || line[0] == '/n')	    continue;	p=line;	cipher=sstrsep(&p,":");		key=ustrsep(&p,":");	iv=ustrsep(&p,":");	plaintext=ustrsep(&p,":");	ciphertext=ustrsep(&p,":");	if (p[-1] == '/n') {	    p[-1] = '/0';	    encdec = -1;	} else {	    encdec = atoi(sstrsep(&p,"/n"));	}	      	kn=convert(key);	in=convert(iv);	pn=convert(plaintext);	cn=convert(ciphertext);	if(!test_cipher(cipher,key,kn,iv,in,plaintext,pn,ciphertext,cn,encdec)	   && !test_digest(cipher,plaintext,pn,ciphertext,cn))	    {#ifdef OPENSSL_NO_AES	    if (strstr(cipher, "AES") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif#ifdef OPENSSL_NO_DES	    if (strstr(cipher, "DES") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif#ifdef OPENSSL_NO_RC4	    if (strstr(cipher, "RC4") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif//.........这里部分代码省略.........

int main(int argc, char *argv[])    {    int err=0;    int v;    RSA *key;    unsigned char ptext[256];    unsigned char ctext[256];    static unsigned char ptext_ex[] = "/x54/x85/x9b/x34/x2c/x49/xea/x2a";    unsigned char ctext_ex[256];    int plen;    int clen = 0;    int num;    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 */    plen = sizeof(ptext_ex) - 1;    for (v = 0; v < 3; v++)	{	key = RSA_new();	switch (v) {    case 0:	clen = key1(key, ctext_ex);	break;    case 1:	clen = key2(key, ctext_ex);	break;    case 2:	clen = key3(key, ctext_ex);	break;	}	num = RSA_public_encrypt(plen, ptext_ex, ctext, key,				 RSA_PKCS1_PADDING);	if (num != clen)	    {	    printf("PKCS#1 v1.5 encryption failed!/n");	    err=1;	    goto oaep;	    }  	num = RSA_private_decrypt(num, ctext, ptext, key,				  RSA_PKCS1_PADDING);	if (num != plen || memcmp(ptext, ptext_ex, num) != 0)	    {	    printf("PKCS#1 v1.5 decryption failed!/n");	    err=1;	    }	else	    printf("PKCS #1 v1.5 encryption/decryption ok/n");    oaep:	ERR_clear_error();	num = RSA_public_encrypt(plen, ptext_ex, ctext, key,				 RSA_PKCS1_OAEP_PADDING);	if (num == -1 && pad_unknown())	    {	    printf("No OAEP support/n");	    goto next;	    }	if (num != clen)	    {	    printf("OAEP encryption failed!/n");	    err=1;	    goto next;	    }  	num = RSA_private_decrypt(num, ctext, ptext, key,				  RSA_PKCS1_OAEP_PADDING);	if (num != plen || memcmp(ptext, ptext_ex, num) != 0)	    {	    printf("OAEP decryption (encrypted data) failed!/n");	    err=1;	    }	else if (memcmp(ctext, ctext_ex, num) == 0)	    {	    printf("OAEP test vector %d passed!/n", v);	    goto next;	    }    	/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).	   Try decrypting ctext_ex */	num = RSA_private_decrypt(clen, ctext_ex, ptext, key,				  RSA_PKCS1_OAEP_PADDING);	if (num != plen || memcmp(ptext, ptext_ex, num) != 0)	    {	    printf("OAEP decryption (test vector data) failed!/n");	    err=1;	    }	else	    printf("OAEP encryption/decryption ok/n");    next:	RSA_free(key);	}//.........这里部分代码省略.........

int main(int argc, char *argv[]){    BIO *err;    int testresult = 0;    int currtest = 0;    SSL_library_init();    SSL_load_error_strings();    err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    confctx = SSL_CONF_CTX_new();    ctx = SSL_CTX_new(SSLv23_method());    ssl = SSL_new(ctx);    if (confctx == NULL || ctx == NULL)        goto end;    SSL_CONF_CTX_set_flags(confctx, SSL_CONF_FLAG_FILE                                    | SSL_CONF_FLAG_CLIENT                                    | SSL_CONF_FLAG_SERVER);    /*     * For each test set up an SSL_CTX and SSL and see whether SSLv2 is enabled     * as expected after various SSL_CONF_cmd("Protocol", ...) calls.     */    for (currtest = 0; currtest < TOTAL_NUM_TESTS; currtest++) {        BIO_printf(err, "SSLv2 CONF Test number %d/n", currtest);        if (currtest == TEST_SSL_CTX)            SSL_CONF_CTX_set_ssl_ctx(confctx, ctx);        else            SSL_CONF_CTX_set_ssl(confctx, ssl);        /* SSLv2 should be off by default */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off by default test FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "ALL") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Should still be off even after ALL Protocols on */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #1 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Should still be off even if explicitly asked for */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #2 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "-SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");;            goto end;        }        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #3 FAIL/n");            goto end;        }        if (currtest == TEST_SSL_CTX)            SSL_CTX_clear_options(ctx, SSL_OP_NO_SSLv2);        else            SSL_clear_options(ssl, SSL_OP_NO_SSLv2);        if (!checksslv2(currtest, SSLV2ON)) {            BIO_printf(err, "SSLv2 CONF Test: On after clear FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "ALL") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Option has been cleared and config says have SSLv2 so should be on */        if (!checksslv2(currtest, SSLV2ON)) {            BIO_printf(err, "SSLv2 CONF Test: On after config #1 FAIL/n");            goto end;        }//.........这里部分代码省略.........

int main(int argc, char *argv[])	{	BN_GENCB _cb;	DH *a;	DH *b=NULL;	char buf[12];	unsigned char *abuf=NULL,*bbuf=NULL;	int i,alen,blen,aout,bout,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);	BN_GENCB_set(&_cb, &cb, out);	if(((a = DH_new()) == NULL) || !DH_generate_parameters_ex(a, 64,				DH_GENERATOR_5, &_cb))		goto err;	if (!DH_check(a, &i)) goto err;	if (i & DH_CHECK_P_NOT_PRIME)		BIO_puts(out, "p value is not prime/n");	if (i & DH_CHECK_P_NOT_SAFE_PRIME)		BIO_puts(out, "p value is not a safe prime/n");	if (i & DH_UNABLE_TO_CHECK_GENERATOR)		BIO_puts(out, "unable to check the generator value/n");	if (i & DH_NOT_SUITABLE_GENERATOR)		BIO_puts(out, "the g value is not a generator/n");	BIO_puts(out,"/np    =");	BN_print(out,a->p);	BIO_puts(out,"/ng    =");	BN_print(out,a->g);	BIO_puts(out,"/n");	b=DH_new();	if (b == NULL) goto err;	b->p=BN_dup(a->p);	b->g=BN_dup(a->g);	if ((b->p == NULL) || (b->g == NULL)) goto err;	/* Set a to run with normal modexp and b to use constant time */	a->flags &= ~DH_FLAG_NO_EXP_CONSTTIME;	b->flags |= DH_FLAG_NO_EXP_CONSTTIME;	if (!DH_generate_key(a)) goto err;	BIO_puts(out,"pri 1=");	BN_print(out,a->priv_key);	BIO_puts(out,"/npub 1=");	BN_print(out,a->pub_key);	BIO_puts(out,"/n");	if (!DH_generate_key(b)) goto err;	BIO_puts(out,"pri 2=");	BN_print(out,b->priv_key);	BIO_puts(out,"/npub 2=");	BN_print(out,b->pub_key);	BIO_puts(out,"/n");	alen=DH_size(a);	abuf=(unsigned char *)OPENSSL_malloc(alen);	aout=DH_compute_key(abuf,b->pub_key,a);	BIO_puts(out,"key1 =");	for (i=0; i<aout; i++)		{		snprintf(buf, sizeof(buf), "%02X",abuf[i]);		BIO_puts(out,buf);		}	BIO_puts(out,"/n");	blen=DH_size(b);	bbuf=(unsigned char *)OPENSSL_malloc(blen);	bout=DH_compute_key(bbuf,a->pub_key,b);	BIO_puts(out,"key2 =");	for (i=0; i<bout; i++)		{		snprintf(buf, sizeof(buf), "%02X",bbuf[i]);		BIO_puts(out,buf);		}	BIO_puts(out,"/n");	if ((aout < 4) || (bout != aout) || (memcmp(abuf,bbuf,aout) != 0))		{		fprintf(stderr,"Error in DH routines/n");		ret=1;		}	else		ret=0;//.........这里部分代码省略.........