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

static void init_openssl(void){    atexit(fini_openssl);    OpenSSL_add_all_algorithms();    ENGINE_load_builtin_engines();    ENGINE_register_all_complete();}

//ignoreunsigned char *HMACRSA(const EVP_MD *evp_md, const void *key, int key_len,const unsigned char *d, size_t n, unsigned char *md,unsigned int *md_len){    HMAC_CTX c;    static unsigned char m[EVP_MAX_MD_SIZE];    //TODO: get/set rsa engine struct    const char *engine_id = "rsa";    ENGINE_load_builtin_engines();    ENGINE *e = ENGINE_by_id(engine_id);//ENGINE_;    if(!e)      fprintf(stderr,"Engine not available/n");    ENGINE_init(e);    if (md == NULL)        md = m;    HMAC_CTX_init(&c);    if (!HMAC_Init_ex(&c, key, key_len, evp_md, NULL))        goto err;    if (!HMAC_Update(&c, d, n))        goto err;    if (!HMAC_Final(&c, md, md_len))        goto err;    HMAC_CTX_cleanup(&c);    ENGINE_free(e);    return md; err:    HMAC_CTX_cleanup(&c);    ENGINE_free(e);    return NULL;}

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

voidtor_init (void){	if (initialized) {		return;	}	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();	// enable proper threading	locks.length = CRYPTO_num_locks();	locks.item   = malloc(locks.length * sizeof(uv_mutex_t));	for (size_t i = 0; i < locks.length; i++) {		uv_mutex_init(&locks.item[i]);	}	CRYPTO_set_locking_callback(_locking_callback);	CRYPTO_set_id_callback(uv_thread_self);	CRYPTO_set_dynlock_create_callback(_dynlock_create_callback);	CRYPTO_set_dynlock_lock_callback(_dynlock_lock_callback);	CRYPTO_set_dynlock_destroy_callback(_dynlock_destroy_callback);	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	initialized = true;}

/* Use AES-NI if available. This is not supported with low-level calls,   we have to use EVP) */static void init_aesni(void){	ENGINE *e;	const char *engine_id = "aesni";	ENGINE_load_builtin_engines();	e = ENGINE_by_id(engine_id);	if (!e) {		//fprintf(stderr, "AES-NI engine not available/n");		return;	}	if (!ENGINE_init(e)) {		fprintf(stderr, "AES-NI engine could not init/n");		ENGINE_free(e);		return;	}	if (!ENGINE_set_default(e, ENGINE_METHOD_ALL & ~ENGINE_METHOD_RAND)) {		/* This should only happen when 'e' can't initialise, but the		 * previous statement suggests it did. */		fprintf(stderr, "AES-NI engine initialized but then failed/n");		abort();	}	ENGINE_finish(e);	ENGINE_free(e);}

void openssl_init(bool threaded){    // initialize the SSL library    SSL_load_error_strings();    SSL_library_init();    unsigned int randSeed = 0;    RAND_bytes( (unsigned char*)&randSeed, sizeof(randSeed) );    srand( randSeed );#ifndef OPENSSL_NO_ENGINE    /* Load all bundled ENGINEs into memory and make them visible */    ENGINE_load_builtin_engines();    /* Register all of them for every algorithm they collectively implement */    ENGINE_register_all_complete();#endif // NO_ENGINE    if(threaded)    {	// provide locking functions to OpenSSL since we'll be running with	// threads accessing openssl in parallel.	CRYPTO_set_id_callback( threads_thread_id );	CRYPTO_set_locking_callback( threads_locking_callback );    }}

int ssl_init(void) { /* init SSL before parsing configuration file */    SSL_load_error_strings();    SSL_library_init();    index_cli=SSL_get_ex_new_index(0, "cli index",        NULL, NULL, NULL);    index_opt=SSL_CTX_get_ex_new_index(0, "opt index",        NULL, NULL, NULL);    index_redirect=SSL_SESSION_get_ex_new_index(0, "redirect index",        NULL, NULL, NULL);    index_addr=SSL_SESSION_get_ex_new_index(0, "addr index",        NULL, NULL, cb_free);    if(index_cli<0 || index_opt<0 || index_redirect<0 || index_addr<0) {        s_log(LOG_ERR, "Application specific data initialization failed");        return 1;    }#ifndef OPENSSL_NO_ENGINE    ENGINE_load_builtin_engines();#endif#ifndef OPENSSL_NO_DH    dh_params=get_dh2048();    if(!dh_params) {        s_log(LOG_ERR, "Failed to get default DH parameters");        return 1;    }#endif /* OPENSSL_NO_DH */    return 0;}

static int apps_startup(){#ifdef SIGPIPE    signal(SIGPIPE, SIG_IGN);#endif    CRYPTO_malloc_init();    ERR_load_crypto_strings();    ERR_load_SSL_strings();    OPENSSL_load_builtin_modules();#ifndef OPENSSL_NO_ENGINE    ENGINE_load_builtin_engines();#endif    if (!app_load_modules(NULL)) {        ERR_print_errors(bio_err);        BIO_printf(bio_err, "Error loading default configuration/n");        return 0;    }    OpenSSL_add_all_algorithms();    OpenSSL_add_ssl_algorithms();    setup_ui_method();    /*SSL_library_init();*/    return 1;}

char* QBox_MakeUpToken(const QBox_AuthPolicy* auth){	char* uptoken;	char* policy_str;	char* encoded_digest;	char* encoded_policy_str;	char digest[EVP_MAX_MD_SIZE + 1];	unsigned int dgtlen = sizeof(digest);	HMAC_CTX ctx;	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	policy_str = QBox_AuthPolicy_json(auth);	encoded_policy_str = QBox_String_Encode(policy_str);	free(policy_str);	bzero(digest, sizeof(digest));	HMAC_CTX_init(&ctx);	HMAC_Init_ex(&ctx, QBOX_SECRET_KEY, strlen(QBOX_SECRET_KEY), EVP_sha1(), NULL);	HMAC_Update(&ctx, encoded_policy_str, strlen(encoded_policy_str));	HMAC_Final(&ctx, digest, &dgtlen);	HMAC_CTX_cleanup(&ctx);	encoded_digest = QBox_Memory_Encode(digest, dgtlen);	uptoken = QBox_String_Concat(QBOX_ACCESS_KEY, ":", encoded_digest, ":", encoded_policy_str, NULL);	free(encoded_policy_str);	free(encoded_digest);	return uptoken;}

static VALUEossl_engine_s_load(int argc, VALUE *argv, VALUE klass){#if !defined(HAVE_ENGINE_LOAD_BUILTIN_ENGINES)    return Qnil;#else    VALUE name;    rb_scan_args(argc, argv, "01", &name);    if(NIL_P(name)){        ENGINE_load_builtin_engines();        return Qtrue;    }    StringValue(name);#ifndef OPENSSL_NO_STATIC_ENGINE    OSSL_ENGINE_LOAD_IF_MATCH(dynamic);    OSSL_ENGINE_LOAD_IF_MATCH(cswift);    OSSL_ENGINE_LOAD_IF_MATCH(chil);    OSSL_ENGINE_LOAD_IF_MATCH(atalla);    OSSL_ENGINE_LOAD_IF_MATCH(nuron);    OSSL_ENGINE_LOAD_IF_MATCH(ubsec);    OSSL_ENGINE_LOAD_IF_MATCH(aep);    OSSL_ENGINE_LOAD_IF_MATCH(sureware);    OSSL_ENGINE_LOAD_IF_MATCH(4758cca);#endif#ifdef HAVE_ENGINE_LOAD_OPENBSD_DEV_CRYPTO    OSSL_ENGINE_LOAD_IF_MATCH(openbsd_dev_crypto);#endif    OSSL_ENGINE_LOAD_IF_MATCH(openssl);    rb_warning("no such builtin loader for `%s'", RSTRING_PTR(name));    return Qnil;#endif /* HAVE_ENGINE_LOAD_BUILTIN_ENGINES */}

void BTCTrader::signRequest ( QString* header, QNetworkRequest* newRequest ){    nonce += 1;    *header = ( header->length() == 0 ) ? "nonce=" + QString::number( nonce ) : "nonce=" + QString::number( nonce ) + "&" + *header;    QByteArray key = QByteArray::fromBase64( restSign.toStdString().c_str() );    unsigned char* result;    unsigned int result_len = 512;    HMAC_CTX ctx;    result = (unsigned char*) malloc(sizeof(unsigned char) * result_len);    ENGINE_load_builtin_engines();    ENGINE_register_all_complete();    HMAC_CTX_init(&ctx);    HMAC_Init_ex(&ctx, key.constData(), key.length(), EVP_sha512(), NULL);    HMAC_Update(&ctx, (unsigned char*)header->toAscii().constData(), header->length());    HMAC_Final(&ctx, result, &result_len);    HMAC_CTX_cleanup(&ctx);    newRequest->setRawHeader( "Rest-Key", restKey.toStdString().c_str() );    newRequest->setRawHeader( "Rest-Sign", QByteArray::fromRawData( (char*)result, result_len ).toBase64() );    newRequest->setRawHeader( "content-type","application/x-www-form-urlencoded" );    free ( result );}

int main(int argc, char **argv) {	OpenSSL_add_all_algorithms();		int len = 128 * MB;	if (argc > 1) {		len = atoi(argv[1]) * MB;	}		unsigned char *buf = (unsigned char *) malloc(TOTAL_LEN);	if (!buf) {		fprintf(stderr, "Error Allocating Memory");	}		ENGINE_load_builtin_engines();#ifdef OPENCL_ENGINE	ENGINE *e = ENGINE_by_id("dynamic");	if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", OPENCL_ENGINE, 0) ||		!ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0)) {		fprintf(stderr, "Failed to load OpenCL engine!/n");		return -1;	}	ENGINE_set_default(e, ENGINE_METHOD_ALL);#endif		run(argv[0], buf, len);		free(buf);		return 0;}

static ENGINE *setup_engine (const char *engine){  ENGINE *e = NULL;  ENGINE_load_builtin_engines ();  if (engine)    {      if (strcmp (engine, "auto") == 0)	{	  msg (M_INFO, "Initializing OpenSSL auto engine support");	  ENGINE_register_all_complete ();	  return NULL;	}      if ((e = ENGINE_by_id (engine)) == NULL	 && (e = try_load_engine (engine)) == NULL)	{	  msg (M_FATAL, "OpenSSL error: cannot load engine '%s'", engine);	}      if (!ENGINE_set_default (e, ENGINE_METHOD_ALL))	{	  msg (M_FATAL, "OpenSSL error: ENGINE_set_default failed on engine '%s'",	       engine);	}      msg (M_INFO, "Initializing OpenSSL support for engine '%s'",	   ENGINE_get_id (e));    }  return e;}

int openssl_config_int(const OPENSSL_INIT_SETTINGS *settings){    int ret;    const char *filename;    const char *appname;    unsigned long flags;    if (openssl_configured)        return 1;    filename = settings ? settings->filename : NULL;    appname = settings ? settings->appname : NULL;    flags = settings ? settings->flags : DEFAULT_CONF_MFLAGS;#ifdef OPENSSL_INIT_DEBUG    fprintf(stderr, "OPENSSL_INIT: openssl_config_int(%s, %s, %lu)/n",            filename, appname, flags);#endif    OPENSSL_load_builtin_modules();#ifndef OPENSSL_NO_ENGINE    /* Need to load ENGINEs */    ENGINE_load_builtin_engines();#endif    ERR_clear_error();#ifndef OPENSSL_SYS_UEFI    ret = CONF_modules_load_file(filename, appname, flags);#endif    openssl_configured = 1;    return ret;}

void OPENSSL_config(const char *config_name)	{	if (openssl_configured)		return;	OPENSSL_load_builtin_modules();#ifndef OPENSSL_NO_ENGINE	/* Need to load ENGINEs */	ENGINE_load_builtin_engines();#endif	/* Add others here? */	ERR_clear_error();	if (CONF_modules_load_file(NULL, config_name,	CONF_MFLAGS_DEFAULT_SECTION|CONF_MFLAGS_IGNORE_MISSING_FILE) <= 0)		{		BIO *bio_err;		ERR_load_crypto_strings();		if ((bio_err=BIO_new_fp(stderr, BIO_NOCLOSE)) != NULL)			{			BIO_printf(bio_err,"Auto configuration failed/n");			ERR_print_errors(bio_err);			BIO_free(bio_err);			}		fprintf(stderr, "OpenSSL could not auto-configure./n");		exit(1);		}	return;	}

int global_init(void){    ENGINE_load_builtin_engines();# ifndef OPENSSL_NO_STATIC_ENGINE    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL);# endif    return 1;}

void _libssh2_openssl_crypto_init(void){#if OPENSSL_VERSION_NUMBER >= 0x10100000L    ENGINE_load_builtin_engines();    ENGINE_register_all_complete();#else    OpenSSL_add_all_algorithms();    OpenSSL_add_all_ciphers();    ENGINE_load_builtin_engines();    ENGINE_register_all_complete();#endif#ifndef HAVE_EVP_AES_128_CTR    _libssh2_EVP_aes_128_ctr();    _libssh2_EVP_aes_192_ctr();    _libssh2_EVP_aes_256_ctr();#endif}

voidssh_SSLeay_add_all_algorithms(void){	SSLeay_add_all_algorithms();	/* Enable use of crypto hardware */	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();}

static int load_tpm_certificate(struct openconnect_info *vpninfo){	ENGINE *e;	EVP_PKEY *key;	UI_METHOD *meth = NULL;	int ret = 0;	ENGINE_load_builtin_engines();	e = ENGINE_by_id("tpm");	if (!e) {		vpn_progress(vpninfo, PRG_ERR, _("Can't load TPM engine./n"));		openconnect_report_ssl_errors(vpninfo);		return -EINVAL;	}	if (!ENGINE_init(e) || !ENGINE_set_default_RSA(e) ||	    !ENGINE_set_default_RAND(e)) {		vpn_progress(vpninfo, PRG_ERR, _("Failed to init TPM engine/n"));		openconnect_report_ssl_errors(vpninfo);		ENGINE_free(e);		return -EINVAL;	}	if (vpninfo->cert_password) {		if (!ENGINE_ctrl_cmd(e, "PIN", strlen(vpninfo->cert_password),				     vpninfo->cert_password, NULL, 0)) {			vpn_progress(vpninfo, PRG_ERR,				     _("Failed to set TPM SRK password/n"));			openconnect_report_ssl_errors(vpninfo);		}		vpninfo->cert_password = NULL;		free(vpninfo->cert_password);	} else {		/* Provide our own UI method to handle the PIN callback. */		meth = create_openssl_ui(vpninfo);	}	key = ENGINE_load_private_key(e, vpninfo->sslkey, meth, NULL);	if (meth)		UI_destroy_method(meth);	if (!key) {		vpn_progress(vpninfo, PRG_ERR,			     _("Failed to load TPM private key/n"));		openconnect_report_ssl_errors(vpninfo);		ret = -EINVAL;		goto out;	}	if (!SSL_CTX_use_PrivateKey(vpninfo->https_ctx, key)) {		vpn_progress(vpninfo, PRG_ERR, _("Add key from TPM failed/n"));		openconnect_report_ssl_errors(vpninfo);		ret = -EINVAL;	}	EVP_PKEY_free(key); out:	ENGINE_finish(e);	ENGINE_free(e);	return ret;}

voidssh_OpenSSL_add_all_algorithms(void){	OpenSSL_add_all_algorithms();	/* Enable use of crypto hardware */	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	OPENSSL_config(NULL);}

voidca_sslinit(void){	OpenSSL_add_all_algorithms();	ERR_load_crypto_strings();	/* Init hardware crypto engines. */	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();}

intmain(int argc, char **argv){    ENGINE *engine = NULL;    int idx = 0;    setprogname(argv[0]);    if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &idx))	usage(1);    if (help_flag)	usage(0);    if(version_flag){	print_version(NULL);	exit(0);    }    argc -= idx;    argv += idx;    OpenSSL_add_all_algorithms();#ifdef OPENSSL    ENGINE_load_openssl();#endif    ENGINE_load_builtin_engines();    if (id_string) {	engine = ENGINE_by_id(id_string);	if (engine == NULL)	    engine = ENGINE_by_dso(id_string, id_string);    } else {	engine = ENGINE_by_id("builtin");    }    if (engine == NULL)	errx(1, "ENGINE_by_dso failed");    printf("dh %s/n", ENGINE_get_DH(engine)->name);    {	struct prime *p = primes;	for (; p->name; ++p)	    if (check_prime(engine, p))		printf("%s: shared secret OK/n", p->name);	    else		printf("%s: shared secret FAILURE/n", p->name);	return 0;    }    return 0;}

static void SMSSLInit(void){	SSL_load_error_strings();	SSL_library_init();	OpenSSL_add_all_algorithms();	//ERR_load_crypto_strings();	/* Init available hardware crypto engines. */	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();}

void initializeSecHandler(){	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();	// <FS:ND If we can, enabled the rdrand engine. It is available as a CPU instruction on newer Intel CPUs	ENGINE_load_builtin_engines();		ENGINE* engRdRand = ENGINE_by_id("rdrand");	if( engRdRand )		ENGINE_set_default(engRdRand, ENGINE_METHOD_RAND);		unsigned long lErr ( ERR_get_error() );	while( lErr )	{		char aError[128];		ERR_error_string_n( lErr, aError, sizeof( aError ) );		LL_WARNS() << aError << LL_ENDL;		lErr = ERR_get_error();	}	// </FS:ND>			gHandlerMap[BASIC_SECHANDLER] = new LLSecAPIBasicHandler();			// Currently, we only have the Basic handler, so we can point the main sechandler	// pointer to the basic handler.  Later, we'll create a wrapper handler that	// selects the appropriate sechandler as needed, for instance choosing the	// mac keyring handler, with fallback to the basic sechandler	gSecAPIHandler = gHandlerMap[BASIC_SECHANDLER];	// initialize all SecAPIHandlers	std::string exception_msg;	std::map<std::string, LLPointer<LLSecAPIHandler> >::const_iterator itr;	for(itr = gHandlerMap.begin(); itr != gHandlerMap.end(); ++itr)	{		LLPointer<LLSecAPIHandler> handler = (*itr).second;		try 		{			handler->init();		}		catch (LLProtectedDataException e)		{			exception_msg = e.getMessage();		}	}	if (!exception_msg.empty())  // an exception was thrown.	{		throw LLProtectedDataException(exception_msg.c_str());	}}

int get_aes_sha1_threshold(){AES_KEY key;uint8_t ukey[16];	ENGINE_load_builtin_engines();        ENGINE_register_all_complete();	memset(ukey, 0xaf, sizeof(ukey));	AES_set_encrypt_key(ukey, 16*8, &key);	return aead_test(CRYPTO_AES_CBC, CRYPTO_SHA1, ukey, 16, &key, aes_sha_combo);}

static QBox_Error QBox_DigestAuth_Auth(void* self, QBox_Header** header, const char* url, const char* addition, size_t addlen){	QBox_Error err;	char const* path = NULL;	char* auth = NULL;	char digest[EVP_MAX_MD_SIZE + 1];	unsigned int dgtlen = sizeof(digest);	char* enc_digest = NULL;	HMAC_CTX ctx;	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	path = strstr(url, "://");	if (path != NULL) {		path = strchr(path + 3, '/');	}	if (path == NULL) {		err.code = 400;		err.message = "Invalid URL";		return err;	}	/* Do digest calculation */	HMAC_CTX_init(&ctx);	HMAC_Init_ex(&ctx, QBOX_SECRET_KEY, strlen(QBOX_SECRET_KEY), EVP_sha1(), NULL);	HMAC_Update(&ctx, path, strlen(path));	HMAC_Update(&ctx, "/n", 1);	if (addlen > 0) {		HMAC_Update(&ctx, addition, addlen);	}	HMAC_Final(&ctx, digest, &dgtlen);	HMAC_CTX_cleanup(&ctx);	digest[dgtlen] = '/0';	enc_digest = QBox_String_Encode(digest);	/* Set appopriate HTTP header */	auth = QBox_String_Concat("Authorization: QBox ", QBOX_ACCESS_KEY, ":", enc_digest, NULL);	free(enc_digest);	*header = curl_slist_append(*header, auth);	free(auth);	err.code    = 200;	err.message = "OK";	return err;}

void OPENSSL_config(const char *config_name){    if (openssl_configured)        return;    OPENSSL_load_builtin_modules();#ifndef OPENSSL_NO_ENGINE    /* Need to load ENGINEs */    ENGINE_load_builtin_engines();#endif    ERR_clear_error();    CONF_modules_load_file(NULL, config_name, CONF_MFLAGS_DEFAULT_SECTION |                           CONF_MFLAGS_IGNORE_MISSING_FILE);}

/** * Initialise the crypto library and perform one time initialisation. */static apr_status_t crypto_init(apr_pool_t *pool, const char *params, int *rc){    CRYPTO_malloc_init();    ERR_load_crypto_strings();    /* SSL_load_error_strings(); */    OpenSSL_add_all_algorithms();    ENGINE_load_builtin_engines();    ENGINE_register_all_complete();    apr_pool_cleanup_register(pool, pool, crypto_shutdown_helper,            apr_pool_cleanup_null);    return APR_SUCCESS;}

static voidopenssl_startup(void){	signal(SIGPIPE, SIG_IGN);	CRYPTO_malloc_init();	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();#ifndef OPENSSL_NO_ENGINE	ENGINE_load_builtin_engines();#endif	setup_ui_method();}

/** * Global SSL init * * @retval 0 error initializing SSL * @retval 1 SSL initialized successfully */int Curl_ossl_init(void){#ifdef HAVE_ENGINE_LOAD_BUILTIN_ENGINES  ENGINE_load_builtin_engines();#endif  /* Lets get nice error messages */  SSL_load_error_strings();  /* Setup all the global SSL stuff */  if (!SSLeay_add_ssl_algorithms())    return 0;  return 1;}