void ENGINE_load_builtin_engines(void)
{
/* Some ENGINEs need this */
OPENSSL_cpuid_setup();
#if 0
/* There's no longer any need for an "openssl" ENGINE unless, one day,
* it is the *only* way for standard builtin implementations to be be
* accessed (ie. it would be possible to statically link binaries with
* *no* builtin implementations). */
ENGINE_load_openssl();
#endif
#if !defined(OPENSSL_NO_HW) && (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
ENGINE_load_cryptodev();
#endif
#ifndef OPENSSL_NO_RDRAND
ENGINE_load_rdrand();
#endif
ENGINE_load_dynamic();
#ifndef OPENSSL_NO_STATIC_ENGINE
#ifndef OPENSSL_NO_HW
#ifndef OPENSSL_NO_HW_4758_CCA
ENGINE_load_4758cca();
#endif
#ifndef OPENSSL_NO_HW_AEP
ENGINE_load_aep();
#endif
#ifndef OPENSSL_NO_HW_ATALLA
ENGINE_load_atalla();
#endif
#ifndef OPENSSL_NO_HW_CSWIFT
ENGINE_load_cswift();
#endif
#ifndef OPENSSL_NO_HW_NCIPHER
ENGINE_load_chil();
#endif
#ifndef OPENSSL_NO_HW_NURON
ENGINE_load_nuron();
#endif
#ifndef OPENSSL_NO_HW_SUREWARE
ENGINE_load_sureware();
#endif
#ifndef OPENSSL_NO_HW_UBSEC
ENGINE_load_ubsec();
#endif
#ifndef OPENSSL_NO_HW_PADLOCK
ENGINE_load_padlock();
#endif
#endif
#ifndef OPENSSL_NO_GOST
ENGINE_load_gost();
#endif
#ifndef OPENSSL_NO_GMP
ENGINE_load_gmp();
#endif
#if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
ENGINE_load_capi();
#endif
#endif
ENGINE_register_all_complete();
}
void ENGINE_load_builtin_engines(void)
{
/* Some ENGINEs need this */
OPENSSL_cpuid_setup();
#if 0
/* There's no longer any need for an "openssl" ENGINE unless, one day,
* it is the *only* way for standard builtin implementations to be be
* accessed (ie. it would be possible to statically link binaries with
* *no* builtin implementations). */
ENGINE_load_openssl();
#endif
#if !defined(OPENSSL_NO_HW) && (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
ENGINE_load_cryptodev();
#endif
#ifndef OPENSSL_NO_RSAX
ENGINE_load_rsax();
#endif
#ifndef OPENSSL_NO_RDRAND
ENGINE_load_rdrand();
#endif
ENGINE_load_dynamic();
#ifndef OPENSSL_NO_STATIC_ENGINE
#ifndef OPENSSL_NO_HW
#ifndef OPENSSL_NO_HW_PADLOCK
ENGINE_load_padlock();
#endif
#endif
#ifndef OPENSSL_NO_GOST
ENGINE_load_gost();
#endif
#endif
ENGINE_register_all_complete();
}
int
main(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;
}
void ENGINE_load_builtin_engines(void)
{
/* There's no longer any need for an "openssl" ENGINE unless, one day,
* it is the *only* way for standard builtin implementations to be be
* accessed (ie. it would be possible to statically link binaries with
* *no* builtin implementations). */
#if 0
ENGINE_load_openssl();
#endif
#if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
ENGINE_load_padlock();
#endif
ENGINE_load_dynamic();
#ifndef OPENSSL_NO_STATIC_ENGINE
#ifndef OPENSSL_NO_HW
#ifndef OPENSSL_NO_HW_4758_CCA
ENGINE_load_4758cca();
#endif
#ifndef OPENSSL_NO_HW_AEP
ENGINE_load_aep();
#endif
#ifndef OPENSSL_NO_HW_ATALLA
ENGINE_load_atalla();
#endif
#ifndef OPENSSL_NO_HW_CSWIFT
ENGINE_load_cswift();
#endif
#ifndef OPENSSL_NO_HW_NCIPHER
ENGINE_load_chil();
#endif
#ifndef OPENSSL_NO_HW_NURON
ENGINE_load_nuron();
#endif
#ifndef OPENSSL_NO_HW_SUREWARE
ENGINE_load_sureware();
#endif
#ifndef OPENSSL_NO_HW_UBSEC
ENGINE_load_ubsec();
#endif
#endif
#if !defined(OPENSSL_NO_GMP) && !defined(OPENSSL_NO_HW_GMP)
ENGINE_load_gmp();
#endif
#endif
#ifndef OPENSSL_NO_HW
#if defined(__OpenBSD__) || defined(__FreeBSD__)
ENGINE_load_cryptodev();
#endif
#endif
}
int
main(int argc, char **argv)
{
ENGINE *engine = NULL;
int i, j, idx = 0;
RSA *rsa;
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);
}
*/
while(1) {
int c = getopt_long(argc, argv, "hq", args, &idx);
if (c == -1)
break;
switch (c) {
case 'q':
verbose = 0;
break;
case 'h':
usage(0);
break;
case '?':
default:
usage(-1);
break;
}
}
/*
argc -= idx;
argv += idx;
*/
if (verbose) printf("[TEST] RSA\n");
/* OpenSSL_add_all_algorithms(); */
#ifdef OPENSSL
ENGINE_load_openssl();
#endif
ENGINE_load_builtin_engines();
/*
if (argc == 0) {
engine = ENGINE_by_id("builtin");
} else {
engine = ENGINE_by_id(argv[0]);
if (engine == NULL)
engine = ENGINE_by_dso(argv[0], id_flag);
}
if (engine == NULL) {
fprintf(stderr, "ENGINE_by_dso failed"\n);
return 76;
}
if (ENGINE_get_RSA(engine) == NULL)
return 77;
printf("rsa %s\n", ENGINE_get_RSA(engine)->name);
*/
if (time_keygen) {
struct timeval tv1, tv2;
BIGNUM *e;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
printf("running keygen with %d loops\n", loops);
gettimeofday(&tv1, NULL);
for (i = 0; i < loops; i++) {
rsa = RSA_new_method(engine);
if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1) {
RSA_free(rsa);
fprintf(stderr, "RSA_generate_key_ex");
fail++;
return 1;
}
RSA_free(rsa);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("time %lu.%06lu\n",
(unsigned long)tv2.tv_sec,
(unsigned long)tv2.tv_usec);
BN_free(e);
/*
ENGINE_finish(engine);
*/
return 0;
}
/*
if (time_key) {
const int size = 20;
struct timeval tv1, tv2;
unsigned char *p;
if (strcmp(time_key, "generate") == 0) {
BIGNUM *e;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1) {
fprintf(stderr, "RSA_generate_key_ex");
fail++;
return (1);
}
} else {
rsa = read_key(engine, time_key);
}
p = emalloc(loops * size);
CCRandomCopyBytes(kCCRandomDefault, p, loops * size);
gettimeofday(&tv1, NULL);
for (i = 0; i < loops; i++)
check_rsa(p + (i * size), size, rsa, RSA_PKCS1_PADDING);
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("time %lu.%06lu\n",
(unsigned long)tv2.tv_sec,
(unsigned long)tv2.tv_usec);
RSA_free(rsa);
ENGINE_finish(engine);
return 0;
}
*/
if (rsa_key) {
rsa = read_key(engine, rsa_key);
/*
* Assuming that you use the RSA key in the distribution, this
* test will generate a signature have a starting zero and thus
* will generate a checksum that is 127 byte instead of the
* checksum that is 128 byte (like the key).
*/
{
const unsigned char sha1[20] = {
0x6d, 0x33, 0xf9, 0x40, 0x75, 0x5b, 0x4e, 0xc5, 0x90, 0x35,
0x48, 0xab, 0x75, 0x02, 0x09, 0x76, 0x9a, 0xb4, 0x7d, 0x6b
};
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char sha1[20];
CCRandomCopyBytes(kCCRandomDefault, sha1, sizeof(sha1));
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char des3[21];
CCRandomCopyBytes(kCCRandomDefault, des3, sizeof(des3));
check_rsa(des3, sizeof(des3), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char aes[32];
CCRandomCopyBytes(kCCRandomDefault, aes, sizeof(aes));
check_rsa(aes, sizeof(aes), rsa, RSA_PKCS1_PADDING);
}
RSA_free(rsa);
}
if (verbose) {
printf("[BEGIN] RSA loops\n");
printf("Running %d loops\n", loops);
}
total++;
for (i = 0; i < loops; i++) {
BN_GENCB cb;
BIGNUM *e;
unsigned int n;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
BN_GENCB_set(&cb, cb_func, NULL);
CCRandomCopyBytes(kCCRandomDefault, &n, sizeof(n));
n &= 0x1ff;
n += 1024;
if (RSA_generate_key_ex(rsa, n, e, &cb) != 1) {
fprintf(stderr, "RSA_generate_key_ex");
fail++;
return 1;
}
BN_free(e);
for (j = 0; j < 8; j++) {
unsigned char sha1[20];
CCRandomCopyBytes(kCCRandomDefault, sha1, sizeof(sha1));
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
RSA_free(rsa);
}
if (verbose) printf("[PASS] RSA loops\n");
pass++;
if (verbose) {
printf("[SUMMARY]\n");
printf("total: %d\n", total);
printf("passed: %d\n", pass);
printf("failed: %d\n", fail);
}
/* ENGINE_finish(engine); */
return (fail);
}
LUALIB_API int luaopen_openssl(lua_State*L)
{
//CRYPTO_thread_setup();
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
SSL_library_init();
ERR_load_ERR_strings();
ERR_load_EVP_strings();
ERR_load_crypto_strings();
ENGINE_load_dynamic();
ENGINE_load_openssl();
#ifdef LOAD_ENGINE_CUSTOM
LOAD_ENGINE_CUSTOM();
#endif
#ifdef OPENSSL_SYS_WINDOWS
RAND_screen();
#endif
lua_newtable(L);
luaL_setfuncs(L, eay_functions, 0);
openssl_register_lhash(L);
openssl_register_engine(L);
luaopen_bio(L);
lua_setfield(L, -2, "bio");
luaopen_asn1(L);
lua_setfield(L, -2, "asn1");
luaopen_digest(L);
lua_setfield(L, -2, "digest");
luaopen_cipher(L);
lua_setfield(L, -2, "cipher");
luaopen_hmac(L);
lua_setfield(L, -2, "hmac");
luaopen_pkey(L);
lua_setfield(L, -2, "pkey");
#ifdef EVP_PKEY_EC
luaopen_ec(L);
lua_setfield(L, -2, "ec");
#endif
luaopen_x509(L);
lua_setfield(L, -2, "x509");
luaopen_pkcs7(L);
lua_setfield(L, -2, "pkcs7");
luaopen_pkcs12(L);
lua_setfield(L, -2, "pkcs12");
luaopen_ocsp(L);
lua_setfield(L, -2, "ocsp");
#ifdef OPENSSL_HAVE_TS
/* timestamp handling */
luaopen_ts(L);
lua_setfield(L, -2, "ts");
#endif
luaopen_cms(L);
lua_setfield(L, -2, "cms");
luaopen_ssl(L);
lua_setfield(L, -2, "ssl");
/* third part */
luaopen_bn(L);
lua_setfield(L, -2, "bn");
luaopen_rsa(L);
luaopen_dsa(L);
luaopen_dh(L);
#ifdef ENABLE_OPENSSL_GLOBAL
lua_pushvalue(L, -1);
lua_setglobal(L, "openssl");
#endif
return 1;
}
int
main(int argc, char **argv)
{
ENGINE *engine = NULL;
int i, j, idx = 0;
RSA *rsa;
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 (argc == 0) {
engine = ENGINE_by_id("builtin");
} else {
engine = ENGINE_by_id(argv[0]);
if (engine == NULL)
engine = ENGINE_by_dso(argv[0], id_flag);
}
if (engine == NULL)
errx(1, "ENGINE_by_dso failed");
if (ENGINE_get_RSA(engine) == NULL)
return 77;
printf("rsa %s\n", ENGINE_get_RSA(engine)->name);
if (RAND_status() != 1)
errx(77, "no functional random device, refusing to run tests");
if (time_keygen) {
struct timeval tv1, tv2;
BIGNUM *e;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
printf("running keygen with %d loops\n", loops);
gettimeofday(&tv1, NULL);
for (i = 0; i < loops; i++) {
rsa = RSA_new_method(engine);
if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1)
errx(1, "RSA_generate_key_ex");
RSA_free(rsa);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("time %lu.%06lu\n",
(unsigned long)tv2.tv_sec,
(unsigned long)tv2.tv_usec);
BN_free(e);
ENGINE_finish(engine);
return 0;
}
if (time_key) {
const int size = 20;
struct timeval tv1, tv2;
unsigned char *p;
if (strcmp(time_key, "generate") == 0) {
BIGNUM *e;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1)
errx(1, "RSA_generate_key_ex");
} else {
rsa = read_key(engine, time_key);
}
p = emalloc(loops * size);
RAND_bytes(p, loops * size);
gettimeofday(&tv1, NULL);
for (i = 0; i < loops; i++)
check_rsa(p + (i * size), size, rsa, RSA_PKCS1_PADDING);
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("time %lu.%06lu\n",
(unsigned long)tv2.tv_sec,
(unsigned long)tv2.tv_usec);
RSA_free(rsa);
ENGINE_finish(engine);
return 0;
}
if (rsa_key) {
rsa = read_key(engine, rsa_key);
/*
* Assuming that you use the RSA key in the distribution, this
* test will generate a signature have a starting zero and thus
* will generate a checksum that is 127 byte instead of the
* checksum that is 128 byte (like the key).
*/
{
const unsigned char sha1[20] = {
0x6d, 0x33, 0xf9, 0x40, 0x75, 0x5b, 0x4e, 0xc5, 0x90, 0x35,
0x48, 0xab, 0x75, 0x02, 0x09, 0x76, 0x9a, 0xb4, 0x7d, 0x6b
};
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char sha1[20];
RAND_bytes(sha1, sizeof(sha1));
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char des3[21];
RAND_bytes(des3, sizeof(des3));
check_rsa(des3, sizeof(des3), rsa, RSA_PKCS1_PADDING);
}
for (i = 0; i < 128; i++) {
unsigned char aes[32];
RAND_bytes(aes, sizeof(aes));
check_rsa(aes, sizeof(aes), rsa, RSA_PKCS1_PADDING);
}
RSA_free(rsa);
}
for (i = 0; i < loops; i++) {
BN_GENCB cb;
BIGNUM *e;
unsigned int n;
rsa = RSA_new_method(engine);
if (!key_blinding)
rsa->flags |= RSA_FLAG_NO_BLINDING;
e = BN_new();
BN_set_word(e, 0x10001);
BN_GENCB_set(&cb, cb_func, NULL);
RAND_bytes(&n, sizeof(n));
n &= 0x1ff;
n += 1024;
if (RSA_generate_key_ex(rsa, n, e, &cb) != 1)
errx(1, "RSA_generate_key_ex");
BN_free(e);
for (j = 0; j < 8; j++) {
unsigned char sha1[20];
RAND_bytes(sha1, sizeof(sha1));
check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
}
RSA_free(rsa);
}
ENGINE_finish(engine);
return 0;
}
LUALIB_API int luaopen_openssl(lua_State*L)
{
if (atomic_fetch_add(&init, 1) == 0)
{
#if defined(OPENSSL_THREADS)
CRYPTO_thread_setup();
#endif
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
SSL_library_init();
ERR_load_ERR_strings();
ERR_load_EVP_strings();
ERR_load_crypto_strings();
ERR_load_SSL_strings();
ENGINE_load_dynamic();
ENGINE_load_openssl();
#ifdef LOAD_ENGINE_CUSTOM
LOAD_ENGINE_CUSTOM
#endif
#ifdef OPENSSL_SYS_WINDOWS
#if OPENSSL_VERSION_NUMBER < 0x10100000L
RAND_screen();
#endif
#endif
}
lua_newtable(L);
lua_newtable(L);
lua_pushcfunction(L, luaclose_openssl);
lua_setfield(L, -2, "__gc");
lua_setmetatable(L, -2);
luaL_setfuncs(L, eay_functions, 0);
openssl_register_lhash(L);
openssl_register_engine(L);
luaopen_bio(L);
lua_setfield(L, -2, "bio");
luaopen_asn1(L);
lua_setfield(L, -2, "asn1");
luaopen_digest(L);
lua_setfield(L, -2, "digest");
luaopen_cipher(L);
lua_setfield(L, -2, "cipher");
luaopen_hmac(L);
lua_setfield(L, -2, "hmac");
luaopen_pkey(L);
lua_setfield(L, -2, "pkey");
#ifdef EVP_PKEY_EC
luaopen_ec(L);
lua_setfield(L, -2, "ec");
#endif
luaopen_x509(L);
lua_setfield(L, -2, "x509");
luaopen_pkcs7(L);
lua_setfield(L, -2, "pkcs7");
luaopen_pkcs12(L);
lua_setfield(L, -2, "pkcs12");
luaopen_ocsp(L);
lua_setfield(L, -2, "ocsp");
#ifdef OPENSSL_HAVE_TS
/* timestamp handling */
luaopen_ts(L);
lua_setfield(L, -2, "ts");
#endif
luaopen_cms(L);
lua_setfield(L, -2, "cms");
luaopen_ssl(L);
lua_setfield(L, -2, "ssl");
/* third part */
luaopen_bn(L);
lua_setfield(L, -2, "bn");
luaopen_rsa(L);
lua_setfield(L, -2, "rsa");
luaopen_dsa(L);
lua_setfield(L, -2, "dsa");
luaopen_dh(L);
lua_setfield(L, -2, "dh");
#ifndef OPENSSL_NO_SRP
luaopen_srp(L);
lua_setfield(L, -2, "srp");
#endif
#ifdef ENABLE_OPENSSL_GLOBAL
lua_pushvalue(L, -1);
lua_setglobal(L, "openssl");
#endif
return 1;
}
static void broken_openssl_init(void)
{
SSL_library_init();
ENGINE_load_openssl();
ENGINE_register_all_RSA();
}
void
zdb_init()
{
if(zdb_init_done)
{
return;
}
/* DO or DIE */
if(dnscore_getfingerprint() != (dnsdb_getfingerprint() & dnscore_fingerprint_mask()))
{
osformatln(termerr, "Mismatched fingerprints: %08x != (%08x = %08x & %08x)",
dnscore_getfingerprint(),
dnsdb_getfingerprint() & dnscore_fingerprint_mask(),
dnsdb_getfingerprint() , dnscore_fingerprint_mask());
flusherr();
exit(-1);
}
zdb_init_done = TRUE;
/* Init the dns core */
dnscore_init();
/* Init the error table */
zdb_register_errors();
/* Init the hash tables */
hash_init();
#if ZDB_OPENSSL_SUPPORT!=0
/* Init openssl */
ENGINE_load_openssl();
ENGINE_load_builtin_engines();
ssl_mutex_count = CRYPTO_num_locks();
MALLOC_OR_DIE(pthread_mutex_t*, ssl_mutex, ssl_mutex_count * sizeof (pthread_mutex_t), ZDB_SSLMUTEX_TAG);
int i;
for(i = 0; i < ssl_mutex_count; i++)
{
pthread_mutex_init(&ssl_mutex[i], NULL);
}
CRYPTO_set_id_callback(ssl_thread_id);
CRYPTO_set_locking_callback(ssl_lock);
#endif
#if ZDB_USE_THREADPOOL != 0
/*
* The default value for the database.
* This initialization will do nothing if it has already been done.
*
* The server will have to do it before calling zdb_init();
*
*/
u32 count = sys_get_cpu_count() + 2;
ya_result return_value = thread_pool_init(count);
if(FAIL(return_value))
{
log_crit("unable to initialise the thread pool to %d threads: %r", count, return_value); /* will ultimately lead to the end of the program */
exit(-1);
}
thread_pool_initialized_by_zdb = (return_value == count);
#endif
#if ZDB_USES_ZALLOC != 0
zdb_set_zowner(pthread_self());
#endif
logger_start();
zdb_rdtsc_registations();
}
LUA_API int luaopen_openssl(lua_State*L)
{
char * config_filename;
#ifdef ENABLE_CRYPTO_THREAD
CRYPTO_thread_setup();
CRYPTO_lock(CRYPTO_LOCK,CRYPTO_LOCK_ERR,__FILE__,__LINE__);
#endif
if(g_init==0)
{
g_init = 1;
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
SSL_library_init();
ERR_load_ERR_strings();
ERR_load_crypto_strings();
ERR_load_EVP_strings();
ERR_load_SSL_strings();
ENGINE_load_dynamic();
ENGINE_load_openssl();
}
#ifdef ENABLE_CRYPTO_THREAD
CRYPTO_lock(CRYPTO_UNLOCK,CRYPTO_LOCK_ERR,__FILE__,__LINE__);
#endif
/* Determine default SSL configuration file */
config_filename = getenv("OPENSSL_CONF");
if (config_filename == NULL) {
config_filename = getenv("SSLEAY_CONF");
}
/* default to 'openssl.cnf' if no environment variable is set */
if (config_filename == NULL) {
snprintf(default_ssl_conf_filename, sizeof(default_ssl_conf_filename), "%s/%s",
X509_get_default_cert_area(),
"openssl.cnf");
} else {
strncpy(default_ssl_conf_filename, config_filename, sizeof(default_ssl_conf_filename));
}
openssl_register_pkey(L);
openssl_register_x509(L);
openssl_register_csr(L);
openssl_register_digest(L);
openssl_register_cipher(L);
openssl_register_sk_x509(L);
openssl_register_bio(L);
openssl_register_crl(L);
#ifdef OPENSSL_HAVE_TS
openssl_register_ts(L);
#endif
openssl_register_conf(L);
openssl_register_pkcs7(L);
openssl_register_misc(L);
openssl_register_engine(L);
openssl_register_ssl(L);
openssl_register_ocsp(L);
#if LUA_VERSION_NUM==501
luaL_register(L,"openssl",eay_functions);
#elif LUA_VERSION_NUM==502
lua_newtable(L);
luaL_setfuncs(L, eay_functions, 0);
#endif
setNamedIntegers(L, consts);
/* third part */
luaopen_bn(L);
lua_setfield(L, -2, "bn");
return 1;
}
