/* (de)initialisation functions. */ static int cswift_init(ENGINE *e) { SW_CONTEXT_HANDLE hac; t_swAcquireAccContext *p1; t_swAttachKeyParam *p2; t_swSimpleRequest *p3; t_swReleaseAccContext *p4; if(cswift_dso != NULL) { CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_ALREADY_LOADED); goto err; } /* Attempt to load libswift.so/swift.dll/whatever. */ cswift_dso = DSO_load(NULL, get_CSWIFT_LIBNAME(), NULL, 0); if(cswift_dso == NULL) { CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_NOT_LOADED); goto err; } if(!(p1 = (t_swAcquireAccContext *) DSO_bind_func(cswift_dso, CSWIFT_F1)) || !(p2 = (t_swAttachKeyParam *) DSO_bind_func(cswift_dso, CSWIFT_F2)) || !(p3 = (t_swSimpleRequest *) DSO_bind_func(cswift_dso, CSWIFT_F3)) || !(p4 = (t_swReleaseAccContext *) DSO_bind_func(cswift_dso, CSWIFT_F4))) { CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_NOT_LOADED); goto err; } /* Copy the pointers */ p_CSwift_AcquireAccContext = p1; p_CSwift_AttachKeyParam = p2; p_CSwift_SimpleRequest = p3; p_CSwift_ReleaseAccContext = p4; /* Try and get a context - if not, we may have a DSO but no * accelerator! */ if(!get_context(&hac)) { CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_UNIT_FAILURE); goto err; } release_context(hac); /* Everything's fine. */ return 1; err: if(cswift_dso) { DSO_free(cswift_dso); cswift_dso = NULL; } p_CSwift_AcquireAccContext = NULL; p_CSwift_AttachKeyParam = NULL; p_CSwift_SimpleRequest = NULL; p_CSwift_ReleaseAccContext = NULL; return 0; }
/* (de)initialisation functions. */ static int atalla_init(ENGINE *e) { tfnASI_GetHardwareConfig *p1; tfnASI_RSAPrivateKeyOpFn *p2; tfnASI_GetPerformanceStatistics *p3; /* Not sure of the origin of this magic value, but Ben's code had it * and it seemed to have been working for a few people. :-) */ unsigned int config_buf[1024]; if(atalla_dso != NULL) { ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_ALREADY_LOADED); goto err; } /* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be * changed unfortunately because the Atalla drivers don't have * standard library names that can be platform-translated well. */ /* TODO: Work out how to actually map to the names the Atalla * drivers really use - for now a symbollic link needs to be * created on the host system from libatasi.so to atasi.so on * unix variants. */ atalla_dso = DSO_load(NULL, get_ATALLA_LIBNAME(), NULL, 0); if(atalla_dso == NULL) { ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED); goto err; } if(!(p1 = (tfnASI_GetHardwareConfig *)DSO_bind_func( atalla_dso, ATALLA_F1)) || !(p2 = (tfnASI_RSAPrivateKeyOpFn *)DSO_bind_func( atalla_dso, ATALLA_F2)) || !(p3 = (tfnASI_GetPerformanceStatistics *)DSO_bind_func( atalla_dso, ATALLA_F3))) { ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED); goto err; } /* Copy the pointers */ p_Atalla_GetHardwareConfig = p1; p_Atalla_RSAPrivateKeyOpFn = p2; p_Atalla_GetPerformanceStatistics = p3; /* Perform a basic test to see if there's actually any unit * running. */ if(p1(0L, config_buf) != 0) { ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_UNIT_FAILURE); goto err; } /* Everything's fine. */ return 1; err: if(atalla_dso) DSO_free(atalla_dso); atalla_dso = NULL; p_Atalla_GetHardwareConfig = NULL; p_Atalla_RSAPrivateKeyOpFn = NULL; p_Atalla_GetPerformanceStatistics = NULL; return 0; }
COMP_METHOD *COMP_zlib(void) { COMP_METHOD *meth = &zlib_method_nozlib; #ifdef ZLIB_SHARED if (!zlib_loaded) { # if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) zlib_dso = DSO_load(NULL, "ZLIB1", NULL, 0); # else zlib_dso = DSO_load(NULL, "z", NULL, 0); # endif if (zlib_dso != NULL) { p_compress = (compress_ft) DSO_bind_func(zlib_dso, "compress"); p_inflateEnd = (inflateEnd_ft) DSO_bind_func(zlib_dso, "inflateEnd"); p_inflate = (inflate_ft) DSO_bind_func(zlib_dso, "inflate"); p_inflateInit_ = (inflateInit__ft) DSO_bind_func(zlib_dso, "inflateInit_"); p_deflateEnd = (deflateEnd_ft) DSO_bind_func(zlib_dso, "deflateEnd"); p_deflate = (deflate_ft) DSO_bind_func(zlib_dso, "deflate"); p_deflateInit_ = (deflateInit__ft) DSO_bind_func(zlib_dso, "deflateInit_"); p_zError = (zError__ft) DSO_bind_func(zlib_dso, "zError"); if (p_compress && p_inflateEnd && p_inflate && p_inflateInit_ && p_deflateEnd && p_deflate && p_deflateInit_ && p_zError) zlib_loaded++; } } #endif #ifdef ZLIB_SHARED if (zlib_loaded) #endif #if defined(ZLIB) || defined(ZLIB_SHARED) { /* * init zlib_stateful_ex_idx here so that in a multi-process * application it's enough to intialize openssl before forking (idx * will be inherited in all the children) */ if (zlib_stateful_ex_idx == -1) { CRYPTO_w_lock(CRYPTO_LOCK_COMP); if (zlib_stateful_ex_idx == -1) zlib_stateful_ex_idx = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_COMP, 0, NULL, NULL, NULL, NULL); CRYPTO_w_unlock(CRYPTO_LOCK_COMP); if (zlib_stateful_ex_idx == -1) goto err; } meth = &zlib_stateful_method; } err: #endif return (meth); }
int main(int argc,char *argv[]) { DSO *dso; DSO_FUNC_TYPE func; BIO *bio_err; if (argc < 2) { fprintf (stderr,"usage: %s libcrypto.dso\n",argv[0]); return 1; } if ((bio_err=BIO_new(BIO_s_file())) == NULL) { fprintf (stderr,"unable to allocate BIO\n"); return 1; } BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT); ERR_load_crypto_strings(); dso = DSO_load(NULL,argv[1],NULL,DSO_FLAG_NO_NAME_TRANSLATION); if (dso == NULL) { ERR_print_errors(bio_err); return 1; } /* This is not normally reached, because FINGERPRINT_premain should * have executed and terminated application already upon DSO_load... */ func = DSO_bind_func(dso,"FINGERPRINT_premain"); if (func == NULL) { ERR_print_errors(bio_err); return 1; } (*func)(); return 0; }
static int nuron_init(ENGINE *e) { if(pvDSOHandle != NULL) { NURONerr(NURON_F_NURON_INIT,NURON_R_ALREADY_LOADED); return 0; } pvDSOHandle = DSO_load(NULL, get_NURON_LIBNAME(), NULL, DSO_FLAG_NAME_TRANSLATION_EXT_ONLY); if(!pvDSOHandle) { NURONerr(NURON_F_NURON_INIT,NURON_R_DSO_NOT_FOUND); return 0; } pfnModExp = (tfnModExp *)DSO_bind_func(pvDSOHandle, NURON_F1); if(!pfnModExp) { NURONerr(NURON_F_NURON_INIT,NURON_R_DSO_FUNCTION_NOT_FOUND); return 0; } return 1; }
COMP_METHOD *COMP_zlib(void) { COMP_METHOD *meth = &zlib_method_nozlib; #ifdef ZLIB_SHARED /* LIBZ may be externally defined, and we should respect that value */ # ifndef LIBZ # if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) # define LIBZ "ZLIB1" # elif defined(OPENSSL_SYS_VMS) # define LIBZ "LIBZ" # else # define LIBZ "z" # endif # endif if (!zlib_loaded) { zlib_dso = DSO_load(NULL, LIBZ, NULL, 0); if (zlib_dso != NULL) { p_compress = (compress_ft) DSO_bind_func(zlib_dso, "compress"); p_inflateEnd = (inflateEnd_ft) DSO_bind_func(zlib_dso, "inflateEnd"); p_inflate = (inflate_ft) DSO_bind_func(zlib_dso, "inflate"); p_inflateInit_ = (inflateInit__ft) DSO_bind_func(zlib_dso, "inflateInit_"); p_deflateEnd = (deflateEnd_ft) DSO_bind_func(zlib_dso, "deflateEnd"); p_deflate = (deflate_ft) DSO_bind_func(zlib_dso, "deflate"); p_deflateInit_ = (deflateInit__ft) DSO_bind_func(zlib_dso, "deflateInit_"); p_zError = (zError__ft) DSO_bind_func(zlib_dso, "zError"); if (p_compress && p_inflateEnd && p_inflate && p_inflateInit_ && p_deflateEnd && p_deflate && p_deflateInit_ && p_zError) zlib_loaded++; if (!OPENSSL_init_crypto(OPENSSL_INIT_ZLIB, NULL)) { comp_zlib_cleanup_int(); return meth; } if (zlib_loaded) meth = &zlib_stateful_method; } } #endif #if defined(ZLIB) meth = &zlib_stateful_method; #endif return meth; }
COMP_METHOD *COMP_zlib(void) { COMP_METHOD *meth = &zlib_method_nozlib; #ifdef ZLIB_SHARED if (!zlib_loaded) { #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) zlib_dso = DSO_load(NULL, "ZLIB", NULL, 0); #else zlib_dso = DSO_load(NULL, "z", NULL, 0); #endif if (zlib_dso != NULL) { p_compress = (compress_ft) DSO_bind_func(zlib_dso, "compress"); p_inflateEnd = (inflateEnd_ft) DSO_bind_func(zlib_dso, "inflateEnd"); p_inflate = (inflate_ft) DSO_bind_func(zlib_dso, "inflate"); p_inflateInit_ = (inflateInit__ft) DSO_bind_func(zlib_dso, "inflateInit_"); zlib_loaded++; } } #endif #if defined(ZLIB) || defined(ZLIB_SHARED) meth = &zlib_method; #endif return(meth); }
COMP_METHOD *COMP_zlib(void) { COMP_METHOD *meth = &zlib_method_nozlib; #ifdef ZLIB_SHARED if (!zlib_loaded) { # if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) zlib_dso = DSO_load(NULL, "ZLIB1", NULL, 0); # else zlib_dso = DSO_load(NULL, "z", NULL, 0); # endif if (zlib_dso != NULL) { p_compress = (compress_ft) DSO_bind_func(zlib_dso, "compress"); p_inflateEnd = (inflateEnd_ft) DSO_bind_func(zlib_dso, "inflateEnd"); p_inflate = (inflate_ft) DSO_bind_func(zlib_dso, "inflate"); p_inflateInit_ = (inflateInit__ft) DSO_bind_func(zlib_dso, "inflateInit_"); p_deflateEnd = (deflateEnd_ft) DSO_bind_func(zlib_dso, "deflateEnd"); p_deflate = (deflate_ft) DSO_bind_func(zlib_dso, "deflate"); p_deflateInit_ = (deflateInit__ft) DSO_bind_func(zlib_dso, "deflateInit_"); p_zError = (zError__ft) DSO_bind_func(zlib_dso, "zError"); if (p_compress && p_inflateEnd && p_inflate && p_inflateInit_ && p_deflateEnd && p_deflate && p_deflateInit_ && p_zError) zlib_loaded++; if (!OPENSSL_init_crypto(OPENSSL_INIT_ZLIB, NULL)) { COMP_zlib_cleanup(); return meth; } if (zlib_loaded) meth = &zlib_stateful_method; } } #endif #if defined(ZLIB) meth = &zlib_stateful_method; #endif return (meth); }
/* (de)initialisation functions. */ static int ubsec_init(ENGINE *e) { t_UBSEC_ubsec_bytes_to_bits *p1; t_UBSEC_ubsec_bits_to_bytes *p2; t_UBSEC_ubsec_open *p3; t_UBSEC_ubsec_close *p4; #ifndef OPENSSL_NO_DH t_UBSEC_diffie_hellman_generate_ioctl *p5; t_UBSEC_diffie_hellman_agree_ioctl *p6; #endif /* #ifndef OPENSSL_NO_RSA */ t_UBSEC_rsa_mod_exp_ioctl *p7; t_UBSEC_rsa_mod_exp_crt_ioctl *p8; /* #endif */ #ifndef OPENSSL_NO_DSA t_UBSEC_dsa_sign_ioctl *p9; t_UBSEC_dsa_verify_ioctl *p10; #endif t_UBSEC_math_accelerate_ioctl *p11; t_UBSEC_rng_ioctl *p12; t_UBSEC_max_key_len_ioctl *p13; int fd = 0; if(ubsec_dso != NULL) { UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_ALREADY_LOADED); goto err; } /* * Attempt to load libubsec.so/ubsec.dll/whatever. */ ubsec_dso = DSO_load(NULL, get_UBSEC_LIBNAME(), NULL, 0); if(ubsec_dso == NULL) { UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE); goto err; } if ( !(p1 = (t_UBSEC_ubsec_bytes_to_bits *) DSO_bind_func(ubsec_dso, UBSEC_F1)) || !(p2 = (t_UBSEC_ubsec_bits_to_bytes *) DSO_bind_func(ubsec_dso, UBSEC_F2)) || !(p3 = (t_UBSEC_ubsec_open *) DSO_bind_func(ubsec_dso, UBSEC_F3)) || !(p4 = (t_UBSEC_ubsec_close *) DSO_bind_func(ubsec_dso, UBSEC_F4)) || #ifndef OPENSSL_NO_DH !(p5 = (t_UBSEC_diffie_hellman_generate_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F5)) || !(p6 = (t_UBSEC_diffie_hellman_agree_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F6)) || #endif /* #ifndef OPENSSL_NO_RSA */ !(p7 = (t_UBSEC_rsa_mod_exp_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F7)) || !(p8 = (t_UBSEC_rsa_mod_exp_crt_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F8)) || /* #endif */ #ifndef OPENSSL_NO_DSA !(p9 = (t_UBSEC_dsa_sign_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F9)) || !(p10 = (t_UBSEC_dsa_verify_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F10)) || #endif !(p11 = (t_UBSEC_math_accelerate_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F11)) || !(p12 = (t_UBSEC_rng_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F12)) || !(p13 = (t_UBSEC_max_key_len_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F13))) { UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE); goto err; } /* Copy the pointers */ p_UBSEC_ubsec_bytes_to_bits = p1; p_UBSEC_ubsec_bits_to_bytes = p2; p_UBSEC_ubsec_open = p3; p_UBSEC_ubsec_close = p4; #ifndef OPENSSL_NO_DH p_UBSEC_diffie_hellman_generate_ioctl = p5; p_UBSEC_diffie_hellman_agree_ioctl = p6; #endif #ifndef OPENSSL_NO_RSA p_UBSEC_rsa_mod_exp_ioctl = p7; p_UBSEC_rsa_mod_exp_crt_ioctl = p8; #endif #ifndef OPENSSL_NO_DSA p_UBSEC_dsa_sign_ioctl = p9; p_UBSEC_dsa_verify_ioctl = p10; #endif p_UBSEC_math_accelerate_ioctl = p11; p_UBSEC_rng_ioctl = p12; p_UBSEC_max_key_len_ioctl = p13; /* Perform an open to see if there's actually any unit running. */ if (((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) > 0) && (p_UBSEC_max_key_len_ioctl(fd, &max_key_len) == 0)) { p_UBSEC_ubsec_close(fd); return 1; } else { UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_UNIT_FAILURE); } err: if(ubsec_dso) DSO_free(ubsec_dso); ubsec_dso = NULL; p_UBSEC_ubsec_bytes_to_bits = NULL; p_UBSEC_ubsec_bits_to_bytes = NULL; p_UBSEC_ubsec_open = NULL; p_UBSEC_ubsec_close = NULL; #ifndef OPENSSL_NO_DH p_UBSEC_diffie_hellman_generate_ioctl = NULL; p_UBSEC_diffie_hellman_agree_ioctl = NULL; #endif #ifndef OPENSSL_NO_RSA p_UBSEC_rsa_mod_exp_ioctl = NULL; p_UBSEC_rsa_mod_exp_crt_ioctl = NULL; #endif #ifndef OPENSSL_NO_DSA p_UBSEC_dsa_sign_ioctl = NULL; p_UBSEC_dsa_verify_ioctl = NULL; #endif p_UBSEC_math_accelerate_ioctl = NULL; p_UBSEC_rng_ioctl = NULL; p_UBSEC_max_key_len_ioctl = NULL; return 0; }
static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx) { ENGINE cpy; dynamic_fns fns; if (ctx->dynamic_dso == NULL) ctx->dynamic_dso = DSO_new(); if (ctx->dynamic_dso == NULL) return 0; if (!ctx->DYNAMIC_LIBNAME) { if (!ctx->engine_id) return 0; ctx->DYNAMIC_LIBNAME = DSO_convert_filename(ctx->dynamic_dso, ctx->engine_id); } if (!int_load(ctx)) { ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_DSO_NOT_FOUND); DSO_free(ctx->dynamic_dso); ctx->dynamic_dso = NULL; return 0; } /* We have to find a bind function otherwise it'll always end badly */ if (! (ctx->bind_engine = (dynamic_bind_engine) DSO_bind_func(ctx->dynamic_dso, ctx->DYNAMIC_F2))) { ctx->bind_engine = NULL; DSO_free(ctx->dynamic_dso); ctx->dynamic_dso = NULL; ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_DSO_FAILURE); return 0; } /* Do we perform version checking? */ if (!ctx->no_vcheck) { unsigned long vcheck_res = 0; /* * Now we try to find a version checking function and decide how to * cope with failure if/when it fails. */ ctx->v_check = (dynamic_v_check_fn) DSO_bind_func(ctx->dynamic_dso, ctx->DYNAMIC_F1); if (ctx->v_check) vcheck_res = ctx->v_check(OSSL_DYNAMIC_VERSION); /* * We fail if the version checker veto'd the load *or* if it is * deferring to us (by returning its version) and we think it is too * old. */ if (vcheck_res < OSSL_DYNAMIC_OLDEST) { /* Fail */ ctx->bind_engine = NULL; ctx->v_check = NULL; DSO_free(ctx->dynamic_dso); ctx->dynamic_dso = NULL; ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_VERSION_INCOMPATIBILITY); return 0; } } /* * First binary copy the ENGINE structure so that we can roll back if the * hand-over fails */ memcpy(&cpy, e, sizeof(ENGINE)); /* * Provide the ERR, "ex_data", memory, and locking callbacks so the * loaded library uses our state rather than its own. FIXME: As noted in * engine.h, much of this would be simplified if each area of code * provided its own "summary" structure of all related callbacks. It * would also increase opaqueness. */ fns.static_state = ENGINE_get_static_state(); fns.lock_fns.lock_locking_cb = CRYPTO_get_locking_callback(); fns.lock_fns.lock_add_lock_cb = CRYPTO_get_add_lock_callback(); fns.lock_fns.dynlock_create_cb = CRYPTO_get_dynlock_create_callback(); fns.lock_fns.dynlock_lock_cb = CRYPTO_get_dynlock_lock_callback(); fns.lock_fns.dynlock_destroy_cb = CRYPTO_get_dynlock_destroy_callback(); /* * Now that we've loaded the dynamic engine, make sure no "dynamic" * ENGINE elements will show through. */ engine_set_all_null(e); /* Try to bind the ENGINE onto our own ENGINE structure */ if (!ctx->bind_engine(e, ctx->engine_id, &fns)) { ctx->bind_engine = NULL; ctx->v_check = NULL; DSO_free(ctx->dynamic_dso); ctx->dynamic_dso = NULL; ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_INIT_FAILED); /* Copy the original ENGINE structure back */ memcpy(e, &cpy, sizeof(ENGINE)); return 0; } /* Do we try to add this ENGINE to the internal list too? */ if (ctx->list_add_value > 0) { if (!ENGINE_add(e)) { /* Do we tolerate this or fail? */ if (ctx->list_add_value > 1) { /* * Fail - NB: By this time, it's too late to rollback, and * trying to do so allows the bind_engine() code to have * created leaks. We just have to fail where we are, after * the ENGINE has changed. */ ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_CONFLICTING_ENGINE_ID); return 0; } /* Tolerate */ ERR_clear_error(); } } return 1; }
/* (de)initialisation functions. */ static int surewarehk_init(ENGINE *e) { char msg[64]="ENGINE_init"; SureWareHook_Init_t *p1=NULL; SureWareHook_Finish_t *p2=NULL; SureWareHook_Rand_Bytes_t *p3=NULL; SureWareHook_Rand_Seed_t *p4=NULL; SureWareHook_Load_Privkey_t *p5=NULL; SureWareHook_Load_Rsa_Pubkey_t *p6=NULL; SureWareHook_Free_t *p7=NULL; SureWareHook_Rsa_Priv_Dec_t *p8=NULL; SureWareHook_Rsa_Sign_t *p9=NULL; SureWareHook_Dsa_Sign_t *p12=NULL; SureWareHook_Info_Pubkey_t *p13=NULL; SureWareHook_Load_Dsa_Pubkey_t *p14=NULL; SureWareHook_Mod_Exp_t *p15=NULL; if(surewarehk_dso != NULL) { SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_ALREADY_LOADED); goto err; } /* Attempt to load libsurewarehk.so/surewarehk.dll/whatever. */ surewarehk_dso = DSO_load(NULL, surewarehk_LIBNAME, NULL, 0); if(surewarehk_dso == NULL) { SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_DSO_FAILURE); goto err; } if(!(p1=(SureWareHook_Init_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Init)) || !(p2=(SureWareHook_Finish_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Finish)) || !(p3=(SureWareHook_Rand_Bytes_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rand_Bytes)) || !(p4=(SureWareHook_Rand_Seed_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rand_Seed)) || !(p5=(SureWareHook_Load_Privkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Privkey)) || !(p6=(SureWareHook_Load_Rsa_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Rsa_Pubkey)) || !(p7=(SureWareHook_Free_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Free)) || !(p8=(SureWareHook_Rsa_Priv_Dec_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rsa_Priv_Dec)) || !(p9=(SureWareHook_Rsa_Sign_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rsa_Sign)) || !(p12=(SureWareHook_Dsa_Sign_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Dsa_Sign)) || !(p13=(SureWareHook_Info_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Info_Pubkey)) || !(p14=(SureWareHook_Load_Dsa_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Dsa_Pubkey)) || !(p15=(SureWareHook_Mod_Exp_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Mod_Exp))) { SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_DSO_FAILURE); goto err; } /* Copy the pointers */ p_surewarehk_Init = p1; p_surewarehk_Finish = p2; p_surewarehk_Rand_Bytes = p3; p_surewarehk_Rand_Seed = p4; p_surewarehk_Load_Privkey = p5; p_surewarehk_Load_Rsa_Pubkey = p6; p_surewarehk_Free = p7; p_surewarehk_Rsa_Priv_Dec = p8; p_surewarehk_Rsa_Sign = p9; p_surewarehk_Dsa_Sign = p12; p_surewarehk_Info_Pubkey = p13; p_surewarehk_Load_Dsa_Pubkey = p14; p_surewarehk_Mod_Exp = p15; /* Contact the hardware and initialises it. */ if(p_surewarehk_Init(msg,threadsafe)==SUREWAREHOOK_ERROR_UNIT_FAILURE) { SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,SUREWARE_R_UNIT_FAILURE); goto err; } if(p_surewarehk_Init(msg,threadsafe)==SUREWAREHOOK_ERROR_UNIT_FAILURE) { SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,SUREWARE_R_UNIT_FAILURE); goto err; } /* try to load the default private key, if failed does not return a failure but wait for an explicit ENGINE_load_privakey */ surewarehk_load_privkey(e,NULL,NULL,NULL); /* Everything's fine. */ #ifndef OPENSSL_NO_RSA if (rsaHndidx == -1) rsaHndidx = RSA_get_ex_new_index(0, (void*)"SureWareHook RSA key handle", NULL, NULL, surewarehk_ex_free); #endif #ifndef OPENSSL_NO_DSA if (dsaHndidx == -1) dsaHndidx = DSA_get_ex_new_index(0, (void*)"SureWareHook DSA key handle", NULL, NULL, surewarehk_ex_free); #endif return 1; err: if(surewarehk_dso) DSO_free(surewarehk_dso); surewarehk_dso = NULL; p_surewarehk_Init = NULL; p_surewarehk_Finish = NULL; p_surewarehk_Rand_Bytes = NULL; p_surewarehk_Rand_Seed = NULL; p_surewarehk_Load_Privkey = NULL; p_surewarehk_Load_Rsa_Pubkey = NULL; p_surewarehk_Free = NULL; p_surewarehk_Rsa_Priv_Dec = NULL; p_surewarehk_Rsa_Sign = NULL; p_surewarehk_Dsa_Sign = NULL; p_surewarehk_Info_Pubkey = NULL; p_surewarehk_Load_Dsa_Pubkey = NULL; p_surewarehk_Mod_Exp = NULL; return 0; }
static int ibm_4758_cca_init(ENGINE *e) { if (dso) { CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_ALREADY_LOADED); goto err; } dso = DSO_load(NULL, get_CCA4758_LIB_NAME(), NULL, 0); if (!dso) { CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE); goto err; } # ifndef OPENSSL_NO_RSA if (!(keyRecordRead = (F_KEYRECORDREAD) DSO_bind_func(dso, n_keyRecordRead)) || !(randomNumberGenerate = (F_RANDOMNUMBERGENERATE) DSO_bind_func(dso, n_randomNumberGenerate)) || !(digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE) DSO_bind_func(dso, n_digitalSignatureGenerate)) || !(digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY) DSO_bind_func(dso, n_digitalSignatureVerify)) || !(publicKeyExtract = (F_PUBLICKEYEXTRACT) DSO_bind_func(dso, n_publicKeyExtract)) || !(pkaEncrypt = (F_PKAENCRYPT) DSO_bind_func(dso, n_pkaEncrypt)) || !(pkaDecrypt = (F_PKADECRYPT) DSO_bind_func(dso, n_pkaDecrypt))) { CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE); goto err; } # else if (!(randomNumberGenerate = (F_RANDOMNUMBERGENERATE) DSO_bind_func(dso, n_randomNumberGenerate))) { CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE); goto err; } # endif # ifndef OPENSSL_NO_RSA hndidx = RSA_get_ex_new_index(0, "IBM 4758 CCA RSA key handle", NULL, NULL, cca_ex_free); # endif return 1; err: if (dso) DSO_free(dso); dso = NULL; # ifndef OPENSSL_NO_RSA keyRecordRead = (F_KEYRECORDREAD) 0; digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE) 0; digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0; publicKeyExtract = (F_PUBLICKEYEXTRACT)0; pkaEncrypt = (F_PKAENCRYPT) 0; pkaDecrypt = (F_PKADECRYPT) 0; # endif randomNumberGenerate = (F_RANDOMNUMBERGENERATE) 0; return 0; }
/* (de)initialisation functions. */ static int hwcrhk_init(ENGINE *e) { HWCryptoHook_Init_t *p1; HWCryptoHook_Finish_t *p2; HWCryptoHook_ModExp_t *p3; #ifndef OPENSSL_NO_RSA HWCryptoHook_RSA_t *p4; HWCryptoHook_RSALoadKey_t *p5; HWCryptoHook_RSAGetPublicKey_t *p6; HWCryptoHook_RSAUnloadKey_t *p7; #endif HWCryptoHook_RandomBytes_t *p8; HWCryptoHook_ModExpCRT_t *p9; if(hwcrhk_dso != NULL) { HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_ALREADY_LOADED); goto err; } /* Attempt to load libnfhwcrhk.so/nfhwcrhk.dll/whatever. */ hwcrhk_dso = DSO_load(NULL, get_HWCRHK_LIBNAME(), NULL, 0); if(hwcrhk_dso == NULL) { HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE); goto err; } if(!(p1 = (HWCryptoHook_Init_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_Init)) || !(p2 = (HWCryptoHook_Finish_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_Finish)) || !(p3 = (HWCryptoHook_ModExp_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExp)) || #ifndef OPENSSL_NO_RSA !(p4 = (HWCryptoHook_RSA_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSA)) || !(p5 = (HWCryptoHook_RSALoadKey_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSALoadKey)) || !(p6 = (HWCryptoHook_RSAGetPublicKey_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAGetPublicKey)) || !(p7 = (HWCryptoHook_RSAUnloadKey_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAUnloadKey)) || #endif !(p8 = (HWCryptoHook_RandomBytes_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_RandomBytes)) || !(p9 = (HWCryptoHook_ModExpCRT_t *) DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExpCRT))) { HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE); goto err; } /* Copy the pointers */ p_hwcrhk_Init = p1; p_hwcrhk_Finish = p2; p_hwcrhk_ModExp = p3; #ifndef OPENSSL_NO_RSA p_hwcrhk_RSA = p4; p_hwcrhk_RSALoadKey = p5; p_hwcrhk_RSAGetPublicKey = p6; p_hwcrhk_RSAUnloadKey = p7; #endif p_hwcrhk_RandomBytes = p8; p_hwcrhk_ModExpCRT = p9; /* Check if the application decided to support dynamic locks, and if it does, use them. */ if (disable_mutex_callbacks == 0) { if (CRYPTO_get_dynlock_create_callback() != NULL && CRYPTO_get_dynlock_lock_callback() != NULL && CRYPTO_get_dynlock_destroy_callback() != NULL) { hwcrhk_globals.mutex_init = hwcrhk_mutex_init; hwcrhk_globals.mutex_acquire = hwcrhk_mutex_lock; hwcrhk_globals.mutex_release = hwcrhk_mutex_unlock; hwcrhk_globals.mutex_destroy = hwcrhk_mutex_destroy; } } /* Try and get a context - if not, we may have a DSO but no * accelerator! */ if(!get_context(&hwcrhk_context, &password_context)) { HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_UNIT_FAILURE); goto err; } /* Everything's fine. */ #ifndef OPENSSL_NO_RSA if (hndidx_rsa == -1) hndidx_rsa = RSA_get_ex_new_index(0, "nFast HWCryptoHook RSA key handle", NULL, NULL, NULL); #endif return 1; err: if(hwcrhk_dso) DSO_free(hwcrhk_dso); hwcrhk_dso = NULL; p_hwcrhk_Init = NULL; p_hwcrhk_Finish = NULL; p_hwcrhk_ModExp = NULL; #ifndef OPENSSL_NO_RSA p_hwcrhk_RSA = NULL; p_hwcrhk_RSALoadKey = NULL; p_hwcrhk_RSAGetPublicKey = NULL; p_hwcrhk_RSAUnloadKey = NULL; #endif p_hwcrhk_ModExpCRT = NULL; p_hwcrhk_RandomBytes = NULL; return 0; }
/* * Internal version that doesn't affect the store flags, and thereby avoid * locking. Direct callers must remember to set the store flags when * appropriate */ static int provider_activate(OSSL_PROVIDER *prov) { const OSSL_DISPATCH *provider_dispatch = NULL; if (prov->flag_initialized) return 1; /* * If the init function isn't set, it indicates that this provider is * a loadable module. */ if (prov->init_function == NULL) { if (prov->module == NULL) { char *allocated_path = NULL; const char *module_path = NULL; char *merged_path = NULL; const char *load_dir = ossl_safe_getenv("OPENSSL_MODULES"); if ((prov->module = DSO_new()) == NULL) { /* DSO_new() generates an error already */ return 0; } if (load_dir == NULL) load_dir = MODULESDIR; DSO_ctrl(prov->module, DSO_CTRL_SET_FLAGS, DSO_FLAG_NAME_TRANSLATION_EXT_ONLY, NULL); module_path = prov->path; if (module_path == NULL) module_path = allocated_path = DSO_convert_filename(prov->module, prov->name); if (module_path != NULL) merged_path = DSO_merge(prov->module, module_path, load_dir); if (merged_path == NULL || (DSO_load(prov->module, merged_path, NULL, 0)) == NULL) { DSO_free(prov->module); prov->module = NULL; } OPENSSL_free(merged_path); OPENSSL_free(allocated_path); } if (prov->module != NULL) prov->init_function = (OSSL_provider_init_fn *) DSO_bind_func(prov->module, "OSSL_provider_init"); } if (prov->init_function == NULL || !prov->init_function(prov, core_dispatch, &provider_dispatch)) { CRYPTOerr(CRYPTO_F_PROVIDER_ACTIVATE, ERR_R_INIT_FAIL); ERR_add_error_data(2, "name=", prov->name); DSO_free(prov->module); prov->module = NULL; return 0; } for (; provider_dispatch->function_id != 0; provider_dispatch++) { switch (provider_dispatch->function_id) { case OSSL_FUNC_PROVIDER_TEARDOWN: prov->teardown = OSSL_get_provider_teardown(provider_dispatch); break; case OSSL_FUNC_PROVIDER_GET_PARAM_TYPES: prov->get_param_types = OSSL_get_provider_get_param_types(provider_dispatch); break; case OSSL_FUNC_PROVIDER_GET_PARAMS: prov->get_params = OSSL_get_provider_get_params(provider_dispatch); break; case OSSL_FUNC_PROVIDER_QUERY_OPERATION: prov->query_operation = OSSL_get_provider_query_operation(provider_dispatch); break; } } /* With this flag set, this provider has become fully "loaded". */ prov->flag_initialized = 1; return 1; }
static int ibmca_init(ENGINE *e) { void (*p1)(); void (*p2)(); void (*p3)(); void (*p4)(); void (*p5)(); if(ibmca_dso != NULL) { IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_ALREADY_LOADED); goto err; } /* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be * changed unfortunately because the Ibmca drivers don't have * standard library names that can be platform-translated well. */ /* TODO: Work out how to actually map to the names the Ibmca * drivers really use - for now a symbollic link needs to be * created on the host system from libatasi.so to atasi.so on * unix variants. */ /* WJH XXX check name translation */ ibmca_dso = DSO_load(NULL, IBMCA_LIBNAME, NULL, /* DSO_FLAG_NAME_TRANSLATION */ 0); if(ibmca_dso == NULL) { IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE); goto err; } if(!(p1 = DSO_bind_func( ibmca_dso, IBMCA_F1)) || !(p2 = DSO_bind_func( ibmca_dso, IBMCA_F2)) || !(p3 = DSO_bind_func( ibmca_dso, IBMCA_F3)) || !(p4 = DSO_bind_func( ibmca_dso, IBMCA_F4)) || !(p5 = DSO_bind_func( ibmca_dso, IBMCA_F5))) { IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE); goto err; } /* Copy the pointers */ p_icaOpenAdapter = (unsigned int (ICA_CALL *)())p1; p_icaCloseAdapter = (unsigned int (ICA_CALL *)())p2; p_icaRsaModExpo = (unsigned int (ICA_CALL *)())p3; p_icaRandomNumberGenerate = (unsigned int (ICA_CALL *)())p4; p_icaRsaCrt = (unsigned int (ICA_CALL *)())p5; if(!get_context(&handle)) { IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_UNIT_FAILURE); goto err; } return 1; err: if(ibmca_dso) DSO_free(ibmca_dso); p_icaOpenAdapter = NULL; p_icaCloseAdapter = NULL; p_icaRsaModExpo = NULL; p_icaRandomNumberGenerate = NULL; return 0; }
/* (de)initialisation functions. */ static int aep_init(ENGINE *e) { t_AEP_ModExp *p1; t_AEP_ModExpCrt *p2; #ifdef AEPRAND t_AEP_GenRandom *p3; #endif t_AEP_Finalize *p4; t_AEP_Initialize *p5; t_AEP_OpenConnection *p6; t_AEP_SetBNCallBacks *p7; t_AEP_CloseConnection *p8; int to_return = 0; if(aep_dso != NULL) { AEPHKerr(AEPHK_F_AEP_INIT,AEPHK_R_ALREADY_LOADED); goto err; } /* Attempt to load libaep.so. */ aep_dso = DSO_load(NULL, get_AEP_LIBNAME(), NULL, 0); if(aep_dso == NULL) { AEPHKerr(AEPHK_F_AEP_INIT,AEPHK_R_NOT_LOADED); goto err; } if( !(p1 = (t_AEP_ModExp *) DSO_bind_func( aep_dso,AEP_F1)) || !(p2 = (t_AEP_ModExpCrt*) DSO_bind_func( aep_dso,AEP_F2)) || #ifdef AEPRAND !(p3 = (t_AEP_GenRandom*) DSO_bind_func( aep_dso,AEP_F3)) || #endif !(p4 = (t_AEP_Finalize*) DSO_bind_func( aep_dso,AEP_F4)) || !(p5 = (t_AEP_Initialize*) DSO_bind_func( aep_dso,AEP_F5)) || !(p6 = (t_AEP_OpenConnection*) DSO_bind_func( aep_dso,AEP_F6)) || !(p7 = (t_AEP_SetBNCallBacks*) DSO_bind_func( aep_dso,AEP_F7)) || !(p8 = (t_AEP_CloseConnection*) DSO_bind_func( aep_dso,AEP_F8))) { AEPHKerr(AEPHK_F_AEP_INIT,AEPHK_R_NOT_LOADED); goto err; } /* Copy the pointers */ p_AEP_ModExp = p1; p_AEP_ModExpCrt = p2; #ifdef AEPRAND p_AEP_GenRandom = p3; #endif p_AEP_Finalize = p4; p_AEP_Initialize = p5; p_AEP_OpenConnection = p6; p_AEP_SetBNCallBacks = p7; p_AEP_CloseConnection = p8; to_return = 1; return to_return; err: if(aep_dso) DSO_free(aep_dso); aep_dso = NULL; p_AEP_OpenConnection = NULL; p_AEP_ModExp = NULL; p_AEP_ModExpCrt = NULL; #ifdef AEPRAND p_AEP_GenRandom = NULL; #endif p_AEP_Initialize = NULL; p_AEP_Finalize = NULL; p_AEP_SetBNCallBacks = NULL; p_AEP_CloseConnection = NULL; return to_return; }
/* (de)initialisation functions. Control Function */ static int zencod_init ( ENGINE *e ) { t_zencod_test *ptr_0 ; t_zencod_bytes2bits *ptr_1 ; t_zencod_bits2bytes *ptr_2 ; t_zencod_new_number *ptr_3 ; t_zencod_init_number *ptr_4 ; t_zencod_rsa_mod_exp *ptr_exp_1 ; t_zencod_rsa_mod_exp_crt *ptr_exp_2 ; t_zencod_dsa_do_sign *ptr_dsa_1 ; t_zencod_dsa_do_verify *ptr_dsa_2 ; t_zencod_dh_generate_key *ptr_dh_1 ; t_zencod_dh_compute_key *ptr_dh_2 ; t_zencod_rand_bytes *ptr_rand_1 ; t_zencod_math_mod_exp *ptr_math_1 ; t_zencod_md5_init *ptr_md5_1 ; t_zencod_md5_update *ptr_md5_2 ; t_zencod_md5_do_final *ptr_md5_3 ; t_zencod_sha1_init *ptr_sha1_1 ; t_zencod_sha1_update *ptr_sha1_2 ; t_zencod_sha1_do_final *ptr_sha1_3 ; t_zencod_xdes_cipher *ptr_xdes_1 ; t_zencod_rc4_cipher *ptr_rc4_1 ; CHEESE () ; /* * We Should add some tests for non NULL parameters or bad value !! * Stuff to be done ... */ if ( zencod_dso != NULL ) { ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_ALREADY_LOADED ) ; goto err ; } /* Trying to load the Library "cryptozen" */ zencod_dso = DSO_load ( NULL, ZENCOD_LIBNAME, NULL, 0 ) ; if ( zencod_dso == NULL ) { ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE ) ; goto err ; } /* Trying to load Function from the Library */ if ( ! ( ptr_1 = (t_zencod_bytes2bits*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_1 ) ) || ! ( ptr_2 = (t_zencod_bits2bytes*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_2 ) ) || ! ( ptr_3 = (t_zencod_new_number*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_3 ) ) || ! ( ptr_4 = (t_zencod_init_number*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_4 ) ) || ! ( ptr_exp_1 = (t_zencod_rsa_mod_exp*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_exp_1 ) ) || ! ( ptr_exp_2 = (t_zencod_rsa_mod_exp_crt*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_exp_2 ) ) || ! ( ptr_dsa_1 = (t_zencod_dsa_do_sign*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dsa_1 ) ) || ! ( ptr_dsa_2 = (t_zencod_dsa_do_verify*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dsa_2 ) ) || ! ( ptr_dh_1 = (t_zencod_dh_generate_key*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dh_1 ) ) || ! ( ptr_dh_2 = (t_zencod_dh_compute_key*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dh_2 ) ) || ! ( ptr_rand_1 = (t_zencod_rand_bytes*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_rand_1 ) ) || ! ( ptr_math_1 = (t_zencod_math_mod_exp*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_math_1 ) ) || ! ( ptr_0 = (t_zencod_test *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_0 ) ) || ! ( ptr_md5_1 = (t_zencod_md5_init *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_1 ) ) || ! ( ptr_md5_2 = (t_zencod_md5_update *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_2 ) ) || ! ( ptr_md5_3 = (t_zencod_md5_do_final *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_3 ) ) || ! ( ptr_sha1_1 = (t_zencod_sha1_init *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_1 ) ) || ! ( ptr_sha1_2 = (t_zencod_sha1_update *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_2 ) ) || ! ( ptr_sha1_3 = (t_zencod_sha1_do_final *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_3 ) ) || ! ( ptr_xdes_1 = (t_zencod_xdes_cipher *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_xdes_1 ) ) || ! ( ptr_rc4_1 = (t_zencod_rc4_cipher *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_rc4_1 ) ) ) { ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE ) ; goto err ; } /* The function from "cryptozen" Library have been correctly loaded so copy them */ ptr_zencod_test = ptr_0 ; ptr_zencod_bytes2bits = ptr_1 ; ptr_zencod_bits2bytes = ptr_2 ; ptr_zencod_new_number = ptr_3 ; ptr_zencod_init_number = ptr_4 ; ptr_zencod_rsa_mod_exp = ptr_exp_1 ; ptr_zencod_rsa_mod_exp_crt = ptr_exp_2 ; ptr_zencod_dsa_do_sign = ptr_dsa_1 ; ptr_zencod_dsa_do_verify = ptr_dsa_2 ; ptr_zencod_dh_generate_key = ptr_dh_1 ; ptr_zencod_dh_compute_key = ptr_dh_2 ; ptr_zencod_rand_bytes = ptr_rand_1 ; ptr_zencod_math_mod_exp = ptr_math_1 ; ptr_zencod_test = ptr_0 ; ptr_zencod_md5_init = ptr_md5_1 ; ptr_zencod_md5_update = ptr_md5_2 ; ptr_zencod_md5_do_final = ptr_md5_3 ; ptr_zencod_sha1_init = ptr_sha1_1 ; ptr_zencod_sha1_update = ptr_sha1_2 ; ptr_zencod_sha1_do_final = ptr_sha1_3 ; ptr_zencod_xdes_cipher = ptr_xdes_1 ; ptr_zencod_rc4_cipher = ptr_rc4_1 ; /* We should peform a test to see if there is actually any unit runnig on the system ... * Even if the cryptozen library is loaded the module coul not be loaded on the system ... * For now we may just open and close the device !! */ if ( ptr_zencod_test () != 0 ) { ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_UNIT_FAILURE ) ; goto err ; } return 1 ; err : if ( zencod_dso ) { DSO_free ( zencod_dso ) ; } zencod_dso = NULL ; ptr_zencod_bytes2bits = NULL ; ptr_zencod_bits2bytes = NULL ; ptr_zencod_new_number = NULL ; ptr_zencod_init_number = NULL ; ptr_zencod_rsa_mod_exp = NULL ; ptr_zencod_rsa_mod_exp_crt = NULL ; ptr_zencod_dsa_do_sign = NULL ; ptr_zencod_dsa_do_verify = NULL ; ptr_zencod_dh_generate_key = NULL ; ptr_zencod_dh_compute_key = NULL ; ptr_zencod_rand_bytes = NULL ; ptr_zencod_math_mod_exp = NULL ; ptr_zencod_test = NULL ; ptr_zencod_md5_init = NULL ; ptr_zencod_md5_update = NULL ; ptr_zencod_md5_do_final = NULL ; ptr_zencod_sha1_init = NULL ; ptr_zencod_sha1_update = NULL ; ptr_zencod_sha1_do_final = NULL ; ptr_zencod_xdes_cipher = NULL ; ptr_zencod_rc4_cipher = NULL ; return 0 ; }
int cluster_labs_init(ENGINE *e) { cl_engine_init *p1; cl_mod_exp *p2; cl_mod_exp_crt *p3; cl_rsa_mod_exp *p4; cl_rsa_priv_enc *p5; cl_rsa_priv_dec *p6; cl_rsa_pub_enc *p7; cl_rsa_pub_dec *p8; cl_rand_bytes *p20; cl_dsa_sign *p30; cl_dsa_verify *p31; /* engine already loaded */ if(cluster_labs_dso != NULL) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_ALREADY_LOADED); goto err; } /* try to load engine */ cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL,0); if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); goto err; } /* bind functions */ if( !(p1 = (cl_engine_init *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F1)) || !(p2 = (cl_mod_exp *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F2)) || !(p3 = (cl_mod_exp_crt *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F3)) || !(p4 = (cl_rsa_mod_exp *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F4)) || !(p5 = (cl_rsa_priv_enc *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F5)) || !(p6 = (cl_rsa_priv_dec *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F6)) || !(p7 = (cl_rsa_pub_enc *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F7)) || !(p8 = (cl_rsa_pub_dec *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F8)) || !(p20= (cl_rand_bytes *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F20)) || !(p30= (cl_dsa_sign *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F30)) || !(p31= (cl_dsa_verify *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F31))) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); goto err; } /* copy function pointers */ p_cl_engine_init = p1; p_cl_mod_exp = p2; p_cl_mod_exp_crt = p3; p_cl_rsa_mod_exp = p4; p_cl_rsa_priv_enc = p5; p_cl_rsa_priv_dec = p6; p_cl_rsa_pub_enc = p7; p_cl_rsa_pub_dec = p8; p_cl_rand_bytes = p20; p_cl_dsa_sign = p30; p_cl_dsa_verify = p31; /* cluster labs engine init */ if(p_cl_engine_init()== 0){ CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_INIT_FAILED); goto err; } return(1); err: /* reset all pointers */ if(cluster_labs_dso) DSO_free(cluster_labs_dso); cluster_labs_dso = NULL; p_cl_engine_init = NULL; p_cl_mod_exp = NULL; p_cl_mod_exp_crt = NULL; p_cl_rsa_mod_exp = NULL; p_cl_rsa_priv_enc = NULL; p_cl_rsa_priv_dec = NULL; p_cl_rsa_pub_enc = NULL; p_cl_rsa_pub_dec = NULL; p_cl_rand_bytes = NULL; p_cl_dsa_sign = NULL; p_cl_dsa_verify = NULL; return(0); }