/* This internal function is used by ENGINE_pkcs11() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { if (!ENGINE_set_id(e, PKCS11_ENGINE_ID) || !ENGINE_set_destroy_function(e, engine_destroy) || !ENGINE_set_init_function(e, engine_init) || !ENGINE_set_finish_function(e, engine_finish) || !ENGINE_set_ctrl_function(e, engine_ctrl) || !ENGINE_set_cmd_defns(e, engine_cmd_defns) || !ENGINE_set_name(e, PKCS11_ENGINE_NAME) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, PKCS11_get_rsa_method()) || #endif #if OPENSSL_VERSION_NUMBER >= 0x10100002L #ifndef OPENSSL_NO_EC /* PKCS11_get_ec_key_method combines ECDSA and ECDH */ !ENGINE_set_EC(e, PKCS11_get_ec_key_method()) || #endif /* OPENSSL_NO_EC */ #else /* OPENSSL_VERSION_NUMBER */ #ifndef OPENSSL_NO_ECDSA !ENGINE_set_ECDSA(e, PKCS11_get_ecdsa_method()) || #endif #ifndef OPENSSL_NO_ECDH !ENGINE_set_ECDH(e, PKCS11_get_ecdh_method()) || #endif #endif /* OPENSSL_VERSION_NUMBER */ !ENGINE_set_load_pubkey_function(e, load_pubkey) || !ENGINE_set_load_privkey_function(e, load_privkey)) { return 0; } else { return 1; } }
static int bind_helper(ENGINE * e) { if (!ENGINE_set_id(e, TEST_ENGINE_ID) || !ENGINE_set_name(e, TEST_ENGINE_NAME) || !ENGINE_set_ctrl_function(e, test_engine_ctrl) || !ENGINE_set_cmd_defns(e, te_cmd_defns) || !ENGINE_set_digests(e, te_digests) || !ENGINE_set_pkey_meths(e, te_pkey_meths) || !ENGINE_set_pkey_asn1_meths(e, te_pkey_asn1_meths) ) { printf("Engine init failed\n"); return 0; } if (!register_ameth_gost(NID_hmac_sha1, &ameth_HMAC_SHA1, "hmac-sha1", "HMAC-SHA1 MAC") || !register_pmeth_gost(NID_hmac_sha1, &pmeth_HMAC_SHA1, 0)) { printf("Internal init failed\n"); return 0; } if(!ENGINE_register_digests(e) || !ENGINE_register_pkey_meths(e) || !ENGINE_register_pkey_asn1_meths(e) || !EVP_add_digest(&digest_hmac_sha1)) { printf("Digest registration failed\n"); return 0; } return 1; }
/* ---------------------*/ static int bind_helper(ENGINE *e) { if (!ENGINE_set_id(e, engine_cluster_labs_id) || !ENGINE_set_name(e, engine_cluster_labs_name) || # ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &cluster_labs_rsa) || # endif # ifndef OPENSSL_NO_DSA !ENGINE_set_DSA(e, &cluster_labs_dsa) || # endif # ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &cluster_labs_dh) || # endif !ENGINE_set_RAND(e, &cluster_labs_rand) || !ENGINE_set_destroy_function(e, cluster_labs_destroy) || !ENGINE_set_init_function(e, cluster_labs_init) || !ENGINE_set_finish_function(e, cluster_labs_finish) || !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) || !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns)) return 0; /* Ensure the error handling is set up */ ERR_load_CL_strings(); return 1; }
static int keystore_engine_setup(ENGINE* e) { ALOGV("keystore_engine_setup"); if (!ENGINE_set_id(e, KEYSTORE_ENGINE_ID) || !ENGINE_set_name(e, KEYSTORE_ENGINE_NAME) || !ENGINE_set_load_privkey_function(e, keystore_loadkey) || !ENGINE_set_load_pubkey_function(e, keystore_loadkey) || !ENGINE_set_cmd_defns(e, keystore_cmd_defns)) { ALOGE("Could not set up keystore engine"); return 0; } if (!ENGINE_set_RSA(e, &keystore_rsa_meth) || !register_rsa_methods()) { ALOGE("Could not set up keystore RSA methods"); return 0; } /* We need a handle in the RSA keys as well for keygen if it's not already initialized. */ pthread_once(&rsa_key_handle_control, init_rsa_key_handle); if (rsa_key_handle < 0) { ALOGE("Could not set up RSA ex_data index"); return 0; } return 1; }
/* This internal function is used by ENGINE_gmp() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { #ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; #endif if(!ENGINE_set_id(e, engine_e_gmp_id) || !ENGINE_set_name(e, engine_e_gmp_name) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &e_gmp_rsa) || #endif !ENGINE_set_destroy_function(e, e_gmp_destroy) || !ENGINE_set_init_function(e, e_gmp_init) || !ENGINE_set_finish_function(e, e_gmp_finish) || !ENGINE_set_ctrl_function(e, e_gmp_ctrl) || !ENGINE_set_cmd_defns(e, e_gmp_cmd_defns)) return 0; #ifndef OPENSSL_NO_RSA meth1 = RSA_PKCS1_SSLeay(); e_gmp_rsa.rsa_pub_enc = meth1->rsa_pub_enc; e_gmp_rsa.rsa_pub_dec = meth1->rsa_pub_dec; e_gmp_rsa.rsa_priv_enc = meth1->rsa_priv_enc; e_gmp_rsa.rsa_priv_dec = meth1->rsa_priv_dec; e_gmp_rsa.bn_mod_exp = meth1->bn_mod_exp; #endif /* Ensure the e_gmp error handling is set up */ ERR_load_GMP_strings(); return 1; }
static ENGINE* LoadEngine() { // This function creates an engine for PKCS#11 and inspired by // the "ENGINE_load_dynamic" function from OpenSSL, in file // "crypto/engine/eng_dyn.c" ENGINE* engine = ENGINE_new(); if (!engine) { LOG(ERROR) << "Cannot create an OpenSSL engine for PKCS#11"; throw OrthancException(ErrorCode_InternalError); } // Create a PKCS#11 context using libp11 context_ = pkcs11_new(); if (!context_) { LOG(ERROR) << "Cannot create a libp11 context for PKCS#11"; ENGINE_free(engine); throw OrthancException(ErrorCode_InternalError); } if (!ENGINE_set_id(engine, PKCS11_ENGINE_ID) || !ENGINE_set_name(engine, PKCS11_ENGINE_NAME) || !ENGINE_set_cmd_defns(engine, PKCS11_ENGINE_COMMANDS) || // Register the callback functions !ENGINE_set_init_function(engine, EngineInitialize) || !ENGINE_set_finish_function(engine, EngineFinalize) || !ENGINE_set_destroy_function(engine, EngineDestroy) || !ENGINE_set_ctrl_function(engine, EngineControl) || !ENGINE_set_load_pubkey_function(engine, EngineLoadPublicKey) || !ENGINE_set_load_privkey_function(engine, EngineLoadPrivateKey) || !ENGINE_set_RSA(engine, PKCS11_get_rsa_method()) || !ENGINE_set_ECDSA(engine, PKCS11_get_ecdsa_method()) || !ENGINE_set_ECDH(engine, PKCS11_get_ecdh_method()) || #if OPENSSL_VERSION_NUMBER >= 0x10100002L !ENGINE_set_EC(engine, PKCS11_get_ec_key_method()) || #endif // Make OpenSSL know about our PKCS#11 engine !ENGINE_add(engine)) { LOG(ERROR) << "Cannot initialize the OpenSSL engine for PKCS#11"; pkcs11_finish(context_); ENGINE_free(engine); throw OrthancException(ErrorCode_InternalError); } // If the "ENGINE_add" worked, it gets a structural // reference. We release our just-created reference. ENGINE_free(engine); return ENGINE_by_id(PKCS11_ENGINE_ID); }
/* * This internal function is used by ENGINE_ubsec() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { # ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; # endif # ifndef OPENSSL_NO_DH # ifndef HAVE_UBSEC_DH const DH_METHOD *meth3; # endif /* HAVE_UBSEC_DH */ # endif if (!ENGINE_set_id(e, engine_ubsec_id) || !ENGINE_set_name(e, engine_ubsec_name) || # ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &ubsec_rsa) || # endif # ifndef OPENSSL_NO_DSA !ENGINE_set_DSA(e, &ubsec_dsa) || # endif # ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &ubsec_dh) || # endif !ENGINE_set_destroy_function(e, ubsec_destroy) || !ENGINE_set_init_function(e, ubsec_init) || !ENGINE_set_finish_function(e, ubsec_finish) || !ENGINE_set_ctrl_function(e, ubsec_ctrl) || !ENGINE_set_cmd_defns(e, ubsec_cmd_defns)) return 0; # ifndef OPENSSL_NO_RSA /* * We know that the "PKCS1_OpenSSL()" functions hook properly to the * Broadcom-specific mod_exp and mod_exp_crt so we use those functions. * NB: We don't use ENGINE_openssl() or anything "more generic" because * something like the RSAref code may not hook properly, and if you own * one of these cards then you have the right to do RSA operations on it * anyway! */ meth1 = RSA_PKCS1_OpenSSL(); ubsec_rsa.rsa_pub_enc = meth1->rsa_pub_enc; ubsec_rsa.rsa_pub_dec = meth1->rsa_pub_dec; ubsec_rsa.rsa_priv_enc = meth1->rsa_priv_enc; ubsec_rsa.rsa_priv_dec = meth1->rsa_priv_dec; # endif # ifndef OPENSSL_NO_DH # ifndef HAVE_UBSEC_DH /* Much the same for Diffie-Hellman */ meth3 = DH_OpenSSL(); ubsec_dh.generate_key = meth3->generate_key; ubsec_dh.compute_key = meth3->compute_key; # endif /* HAVE_UBSEC_DH */ # endif /* Ensure the ubsec error handling is set up */ ERR_load_UBSEC_strings(); return 1; }
static int bind_devcrypto(ENGINE *e) { if (!ENGINE_set_id(e, engine_devcrypto_id) || !ENGINE_set_name(e, "/dev/crypto engine") || !ENGINE_set_destroy_function(e, devcrypto_unload) || !ENGINE_set_cmd_defns(e, devcrypto_cmds) || !ENGINE_set_ctrl_function(e, devcrypto_ctrl)) return 0; prepare_cipher_methods(); #ifdef IMPLEMENT_DIGEST prepare_digest_methods(); #endif return (ENGINE_set_ciphers(e, devcrypto_ciphers) #ifdef IMPLEMENT_DIGEST && ENGINE_set_digests(e, devcrypto_digests) #endif /* * Asymmetric ciphers aren't well supported with /dev/crypto. Among the BSD * implementations, it seems to only exist in FreeBSD, and regarding the * parameters in its crypt_kop, the manual crypto(4) has this to say: * * The semantics of these arguments are currently undocumented. * * Reading through the FreeBSD source code doesn't give much more than * their CRK_MOD_EXP implementation for ubsec. * * It doesn't look much better with cryptodev-linux. They have the crypt_kop * structure as well as the command (CRK_*) in cryptodev.h, but no support * seems to be implemented at all for the moment. * * At the time of writing, it seems impossible to write proper support for * FreeBSD's asym features without some very deep knowledge and access to * specific kernel modules. * * /Richard Levitte, 2017-05-11 */ #if 0 # ifndef OPENSSL_NO_RSA && ENGINE_set_RSA(e, devcrypto_rsa) # endif # ifndef OPENSSL_NO_DSA && ENGINE_set_DSA(e, devcrypto_dsa) # endif # ifndef OPENSSL_NO_DH && ENGINE_set_DH(e, devcrypto_dh) # endif # ifndef OPENSSL_NO_EC && ENGINE_set_EC(e, devcrypto_ec) # endif #endif ); }
/* * This internal function is used by ENGINE_chil() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { # ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; # endif # ifndef OPENSSL_NO_DH const DH_METHOD *meth2; # endif if (!ENGINE_set_id(e, engine_hwcrhk_id) || !ENGINE_set_name(e, engine_hwcrhk_name) || # ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &hwcrhk_rsa) || # endif # ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &hwcrhk_dh) || # endif !ENGINE_set_RAND(e, &hwcrhk_rand) || !ENGINE_set_destroy_function(e, hwcrhk_destroy) || !ENGINE_set_init_function(e, hwcrhk_init) || !ENGINE_set_finish_function(e, hwcrhk_finish) || !ENGINE_set_ctrl_function(e, hwcrhk_ctrl) || !ENGINE_set_load_privkey_function(e, hwcrhk_load_privkey) || !ENGINE_set_load_pubkey_function(e, hwcrhk_load_pubkey) || !ENGINE_set_cmd_defns(e, hwcrhk_cmd_defns)) return 0; # ifndef OPENSSL_NO_RSA /* * We know that the "PKCS1_SSLeay()" functions hook properly to the * cswift-specific mod_exp and mod_exp_crt so we use those functions. NB: * We don't use ENGINE_openssl() or anything "more generic" because * something like the RSAref code may not hook properly, and if you own * one of these cards then you have the right to do RSA operations on it * anyway! */ meth1 = RSA_PKCS1_SSLeay(); hwcrhk_rsa.rsa_pub_enc = meth1->rsa_pub_enc; hwcrhk_rsa.rsa_pub_dec = meth1->rsa_pub_dec; hwcrhk_rsa.rsa_priv_enc = meth1->rsa_priv_enc; hwcrhk_rsa.rsa_priv_dec = meth1->rsa_priv_dec; # endif # ifndef OPENSSL_NO_DH /* Much the same for Diffie-Hellman */ meth2 = DH_OpenSSL(); hwcrhk_dh.generate_key = meth2->generate_key; hwcrhk_dh.compute_key = meth2->compute_key; # endif /* Ensure the hwcrhk error handling is set up */ ERR_load_HWCRHK_strings(); return 1; }
static int cuda_bind_helper(ENGINE * e) { if (!ENGINE_set_id(e, CUDA_ENGINE_ID) || !ENGINE_set_init_function(e, cuda_init) || !ENGINE_set_finish_function(e, cuda_finish) || !ENGINE_set_ctrl_function(e, cuda_engine_ctrl) || !ENGINE_set_cmd_defns(e, cuda_cmd_defns) || !ENGINE_set_name(e, CUDA_ENGINE_NAME) || !ENGINE_set_ciphers (e, cuda_ciphers)) { return 0; } else { return 1; } }
static ENGINE *engine_dynamic(void) { ENGINE *ret = ENGINE_new(); if (ret == NULL) return NULL; if (!ENGINE_set_id(ret, engine_dynamic_id) || !ENGINE_set_name(ret, engine_dynamic_name) || !ENGINE_set_init_function(ret, dynamic_init) || !ENGINE_set_finish_function(ret, dynamic_finish) || !ENGINE_set_ctrl_function(ret, dynamic_ctrl) || !ENGINE_set_flags(ret, ENGINE_FLAGS_BY_ID_COPY) || !ENGINE_set_cmd_defns(ret, dynamic_cmd_defns)) { ENGINE_free(ret); return NULL; } return ret; }
static int bind_helper(ENGINE *e) { fprintf(stderr, "arrive at bind_helper\n"); if(!ENGINE_set_id(e, engine_hwdev_id) || !ENGINE_set_name(e, engine_hwdev_name) || !ENGINE_set_ECDH(e, &ecdh_meth) || !ENGINE_set_destroy_function(e, hwdev_destroy) || !ENGINE_set_init_function(e, hwdev_init) || !ENGINE_set_finish_function(e, hwdev_finish) || !ENGINE_set_ctrl_function(e, hwdev_ctrl) || !ENGINE_set_load_privkey_function(e, hwdev_load_privkey) || !ENGINE_set_load_pubkey_function(e, hwdev_load_pubkey) || !ENGINE_set_cmd_defns(e, hwdev_cmd_defns)) return 0; return 1; }
static int bind_capi(ENGINE *e) { if (!ENGINE_set_id(e, engine_capi_id) || !ENGINE_set_name(e, engine_capi_name) || !ENGINE_set_init_function(e, capi_init) || !ENGINE_set_finish_function(e, capi_finish) || !ENGINE_set_destroy_function(e, capi_destroy) || !ENGINE_set_RSA(e, &capi_rsa_method) || !ENGINE_set_DSA(e, &capi_dsa_method) || !ENGINE_set_load_privkey_function(e, capi_load_privkey) || !ENGINE_set_load_ssl_client_cert_function(e, capi_load_ssl_client_cert) || !ENGINE_set_cmd_defns(e, capi_cmd_defns) || !ENGINE_set_ctrl_function(e, capi_ctrl)) return 0; ERR_load_CAPI_strings(); return 1; }
/* This internal function is used by ENGINE_tpm() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE * e) { if (!ENGINE_set_id(e, engine_tpm_id) || !ENGINE_set_name(e, engine_tpm_name) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &tpm_rsa) || #endif !ENGINE_set_RAND(e, &tpm_rand) || !ENGINE_set_destroy_function(e, tpm_engine_destroy) || !ENGINE_set_init_function(e, tpm_engine_init) || !ENGINE_set_finish_function(e, tpm_engine_finish) || !ENGINE_set_ctrl_function(e, tpm_engine_ctrl) || !ENGINE_set_load_pubkey_function(e, tpm_engine_load_key) || !ENGINE_set_load_privkey_function(e, tpm_engine_load_key) || !ENGINE_set_cmd_defns(e, tpm_cmd_defns)) return 0; /* Ensure the tpm error handling is set up */ ERR_load_TPM_strings(); return 1; }
/* ---------------------*/ static int bind_helper(ENGINE *e) { if (!ENGINE_set_id(e, engine_4758_cca_id) || !ENGINE_set_name(e, engine_4758_cca_name) || # ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &ibm_4758_cca_rsa) || # endif !ENGINE_set_RAND(e, &ibm_4758_cca_rand) || !ENGINE_set_destroy_function(e, ibm_4758_cca_destroy) || !ENGINE_set_init_function(e, ibm_4758_cca_init) || !ENGINE_set_finish_function(e, ibm_4758_cca_finish) || !ENGINE_set_ctrl_function(e, ibm_4758_cca_ctrl) || # ifndef OPENSSL_NO_RSA !ENGINE_set_load_privkey_function(e, ibm_4758_load_privkey) || !ENGINE_set_load_pubkey_function(e, ibm_4758_load_pubkey) || # endif !ENGINE_set_cmd_defns(e, cca4758_cmd_defns)) return 0; /* Ensure the error handling is set up */ ERR_load_CCA4758_strings(); return 1; }
/* * This internal function is used by ENGINE_skf() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { # ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; # endif if (!ENGINE_set_id(e, engine_hwskf_id) || !ENGINE_set_name(e, engine_hwskf_name) || !ENGINE_set_destroy_function(e, hwskf_destroy) || !ENGINE_set_init_function(e, hwskf_init) || !ENGINE_set_finish_function(e, hwskf_finish) || !ENGINE_set_ctrl_function(e, hwskf_ctrl) || !ENGINE_set_load_privkey_function(e, hwskf_load_privkey) || !ENGINE_set_load_pubkey_function(e, hwskf_load_pubkey) || !ENGINE_set_cmd_defns(e, hwskf_cmd_defns)) return 0; # ifndef OPENSSL_NO_RSA /* * We know that the "PKCS1_SSLeay()" functions hook properly to the * cswift-specific mod_exp and mod_exp_crt so we use those functions. NB: * We don't use ENGINE_openssl() or anything "more generic" because * something like the RSAref code may not hook properly, and if you own * one of these cards then you have the right to do RSA operations on it * anyway! */ /* meth1 = RSA_PKCS1_SSLeay(); hwskf_rsa.rsa_pub_enc = meth1->rsa_pub_enc; hwskf_rsa.rsa_pub_dec = meth1->rsa_pub_dec; hwskf_rsa.rsa_priv_enc = meth1->rsa_priv_enc; hwskf_rsa.rsa_priv_dec = meth1->rsa_priv_dec; */ # endif /* Ensure the hwcrhk error handling is set up */ //ERR_load_HWSKF_strings(); return 1; }
/* Returns 1 if successfully added, 2 if engine has previously been added, and 0 for error. */ int Cryptography_add_osrandom_engine(void) { ENGINE *e; ERR_load_Cryptography_OSRandom_strings(); e = ENGINE_by_id(Cryptography_osrandom_engine_id); if (e != NULL) { ENGINE_free(e); return 2; } else { ERR_clear_error(); } e = ENGINE_new(); if (e == NULL) { return 0; } if (!ENGINE_set_id(e, Cryptography_osrandom_engine_id) || !ENGINE_set_name(e, Cryptography_osrandom_engine_name) || !ENGINE_set_RAND(e, &osrandom_rand) || !ENGINE_set_init_function(e, osrandom_init) || !ENGINE_set_finish_function(e, osrandom_finish) || !ENGINE_set_cmd_defns(e, osrandom_cmd_defns) || !ENGINE_set_ctrl_function(e, osrandom_ctrl)) { ENGINE_free(e); return 0; } if (!ENGINE_add(e)) { ENGINE_free(e); return 0; } if (!ENGINE_free(e)) { return 0; } return 1; }
static int bind_HCSP(ENGINE* e) { if (!ENGINE_set_id(e, engine_HCSP_id) || !ENGINE_set_name(e, engine_HCSP_name) || !ENGINE_set_RSA(e, &HCSP_rsa) || !ENGINE_set_destroy_function(e, HCSP_destroy) || !ENGINE_set_init_function(e, HCSP_init) || !ENGINE_set_finish_function(e, HCSP_finish) || !ENGINE_set_load_pubkey_function(e, HCSP_load_key) || !ENGINE_set_load_privkey_function(e, HCSP_load_key) #ifdef FILE_CONFIG || !ENGINE_set_ctrl_function(e, HCSP_ctrl) || !ENGINE_set_cmd_defns(e, HCSP_cmd_defns) #endif ) return 0; /* Ensure the rsaref error handling is set up */ #ifndef OPENSSL_NO_ERR ERR_load_HCSP_strings(); #endif return 1; }
/****************************************************************************** * function: * bind_qat(ENGINE *e, * const char *id) * * @param e [IN] - OpenSSL engine pointer * @param id [IN] - engine id * * description: * Connect Qat engine to OpenSSL engine library ******************************************************************************/ static int bind_qat(ENGINE *e, const char *id) { int ret = 0; #ifndef OPENSSL_ENABLE_QAT_UPSTREAM_DRIVER int upstream_flags = 0; unsigned int devmasks[] = { 0, 0, 0, 0, 0 }; #endif QAT_DEBUG_LOG_INIT(); WARN("QAT Warnings enabled.\n"); DEBUG("QAT Debug enabled.\n"); DEBUG("id=%s\n", id); if (access(QAT_DEV, F_OK) != 0) { WARN("Qat memory driver not present\n"); QATerr(QAT_F_BIND_QAT, QAT_R_MEM_DRV_NOT_PRESENT); goto end; } #ifndef OPENSSL_ENABLE_QAT_UPSTREAM_DRIVER if (!getDevices(devmasks, &upstream_flags)) { WARN("Qat device not present\n"); QATerr(QAT_F_BIND_QAT, QAT_R_QAT_DEV_NOT_PRESENT); goto end; } #endif if (id && (strcmp(id, engine_qat_id) != 0)) { WARN("ENGINE_id defined already!\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_ID_ALREADY_DEFINED); goto end; } if (!ENGINE_set_id(e, engine_qat_id)) { WARN("ENGINE_set_id failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_ID_FAILURE); goto end; } if (!ENGINE_set_name(e, engine_qat_name)) { WARN("ENGINE_set_name failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_NAME_FAILURE); goto end; } /* Ensure the QAT error handling is set up */ ERR_load_QAT_strings(); /* * Create static structures for ciphers now * as this function will be called by a single thread. */ qat_create_ciphers(); if (!ENGINE_set_RSA(e, qat_get_RSA_methods())) { WARN("ENGINE_set_RSA failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_RSA_FAILURE); goto end; } if (!ENGINE_set_DSA(e, qat_get_DSA_methods())) { WARN("ENGINE_set_DSA failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_DSA_FAILURE); goto end; } if (!ENGINE_set_DH(e, qat_get_DH_methods())) { WARN("ENGINE_set_DH failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_DH_FAILURE); goto end; } if (!ENGINE_set_EC(e, qat_get_EC_methods())) { WARN("ENGINE_set_EC failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_EC_FAILURE); goto end; } if (!ENGINE_set_ciphers(e, qat_ciphers)) { WARN("ENGINE_set_ciphers failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_CIPHER_FAILURE); goto end; } if (!ENGINE_set_pkey_meths(e, qat_PRF_pkey_methods)) { WARN("ENGINE_set_pkey_meths failed\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_PKEY_FAILURE); goto end; } pthread_atfork(engine_finish_before_fork_handler, NULL, engine_init_child_at_fork_handler); ret = 1; ret &= ENGINE_set_destroy_function(e, qat_engine_destroy); ret &= ENGINE_set_init_function(e, qat_engine_init); ret &= ENGINE_set_finish_function(e, qat_engine_finish); ret &= ENGINE_set_ctrl_function(e, qat_engine_ctrl); ret &= ENGINE_set_cmd_defns(e, qat_cmd_defns); if (ret == 0) { WARN("Engine failed to register init, finish or destroy functions\n"); QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_REGISTER_FUNC_FAILURE); } end: return ret; }
/* * This internal function is used by ENGINE_nuron() and possibly by the * "dynamic" ENGINE support too */ static int bind_helper(ENGINE *e) { # ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; # endif # ifndef OPENSSL_NO_DSA const DSA_METHOD *meth2; # endif # ifndef OPENSSL_NO_DH const DH_METHOD *meth3; # endif if (!ENGINE_set_id(e, engine_nuron_id) || !ENGINE_set_name(e, engine_nuron_name) || # ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &nuron_rsa) || # endif # ifndef OPENSSL_NO_DSA !ENGINE_set_DSA(e, &nuron_dsa) || # endif # ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &nuron_dh) || # endif !ENGINE_set_destroy_function(e, nuron_destroy) || !ENGINE_set_init_function(e, nuron_init) || !ENGINE_set_finish_function(e, nuron_finish) || !ENGINE_set_ctrl_function(e, nuron_ctrl) || !ENGINE_set_cmd_defns(e, nuron_cmd_defns)) return 0; # ifndef OPENSSL_NO_RSA /* * We know that the "PKCS1_SSLeay()" functions hook properly to the * nuron-specific mod_exp and mod_exp_crt so we use those functions. NB: * We don't use ENGINE_openssl() or anything "more generic" because * something like the RSAref code may not hook properly, and if you own * one of these cards then you have the right to do RSA operations on it * anyway! */ meth1 = RSA_PKCS1_SSLeay(); nuron_rsa.rsa_pub_enc = meth1->rsa_pub_enc; nuron_rsa.rsa_pub_dec = meth1->rsa_pub_dec; nuron_rsa.rsa_priv_enc = meth1->rsa_priv_enc; nuron_rsa.rsa_priv_dec = meth1->rsa_priv_dec; # endif # ifndef OPENSSL_NO_DSA /* * Use the DSA_OpenSSL() method and just hook the mod_exp-ish bits. */ meth2 = DSA_OpenSSL(); nuron_dsa.dsa_do_sign = meth2->dsa_do_sign; nuron_dsa.dsa_sign_setup = meth2->dsa_sign_setup; nuron_dsa.dsa_do_verify = meth2->dsa_do_verify; # endif # ifndef OPENSSL_NO_DH /* Much the same for Diffie-Hellman */ meth3 = DH_OpenSSL(); nuron_dh.generate_key = meth3->generate_key; nuron_dh.compute_key = meth3->compute_key; # endif /* Ensure the nuron error handling is set up */ ERR_load_NURON_strings(); return 1; }
/* This internal function is used by ENGINE_aep() and possibly by the * "dynamic" ENGINE support too */ static int bind_aep(ENGINE *e) { #ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; #endif #ifndef OPENSSL_NO_DSA const DSA_METHOD *meth2; #endif #ifndef OPENSSL_NO_DH const DH_METHOD *meth3; #endif if(!ENGINE_set_id(e, engine_aep_id) || !ENGINE_set_name(e, engine_aep_name) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &aep_rsa) || #endif #ifndef OPENSSL_NO_DSA !ENGINE_set_DSA(e, &aep_dsa) || #endif #ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &aep_dh) || #endif #ifdef AEPRAND !ENGINE_set_RAND(e, &aep_random) || #endif !ENGINE_set_init_function(e, aep_init) || !ENGINE_set_destroy_function(e, aep_destroy) || !ENGINE_set_finish_function(e, aep_finish) || !ENGINE_set_ctrl_function(e, aep_ctrl) || !ENGINE_set_cmd_defns(e, aep_cmd_defns)) return 0; #ifndef OPENSSL_NO_RSA /* We know that the "PKCS1_SSLeay()" functions hook properly * to the aep-specific mod_exp and mod_exp_crt so we use * those functions. NB: We don't use ENGINE_openssl() or * anything "more generic" because something like the RSAref * code may not hook properly, and if you own one of these * cards then you have the right to do RSA operations on it * anyway! */ meth1 = RSA_PKCS1_SSLeay(); aep_rsa.rsa_pub_enc = meth1->rsa_pub_enc; aep_rsa.rsa_pub_dec = meth1->rsa_pub_dec; aep_rsa.rsa_priv_enc = meth1->rsa_priv_enc; aep_rsa.rsa_priv_dec = meth1->rsa_priv_dec; #endif #ifndef OPENSSL_NO_DSA /* Use the DSA_OpenSSL() method and just hook the mod_exp-ish * bits. */ meth2 = DSA_OpenSSL(); aep_dsa.dsa_do_sign = meth2->dsa_do_sign; aep_dsa.dsa_sign_setup = meth2->dsa_sign_setup; aep_dsa.dsa_do_verify = meth2->dsa_do_verify; aep_dsa = *DSA_get_default_method(); aep_dsa.dsa_mod_exp = aep_dsa_mod_exp; aep_dsa.bn_mod_exp = aep_mod_exp_dsa; #endif #ifndef OPENSSL_NO_DH /* Much the same for Diffie-Hellman */ meth3 = DH_OpenSSL(); aep_dh.generate_key = meth3->generate_key; aep_dh.compute_key = meth3->compute_key; aep_dh.bn_mod_exp = meth3->bn_mod_exp; #endif /* Ensure the aep error handling is set up */ ERR_load_AEPHK_strings(); return 1; }
void ENGINE_load_cryptodev(void) { ENGINE *engine = ENGINE_new(); int fd; if (engine == NULL) return; if ((fd = get_dev_crypto()) < 0) { ENGINE_free(engine); return; } /* * find out what asymmetric crypto algorithms we support */ if (ioctl(fd, CIOCASYMFEAT, &cryptodev_asymfeat) == -1) { close(fd); ENGINE_free(engine); return; } close(fd); if (!ENGINE_set_id(engine, "cryptodev") || !ENGINE_set_name(engine, "BSD cryptodev engine") || !ENGINE_set_ciphers(engine, cryptodev_engine_ciphers) || !ENGINE_set_digests(engine, cryptodev_engine_digests) || !ENGINE_set_ctrl_function(engine, cryptodev_ctrl) || !ENGINE_set_cmd_defns(engine, cryptodev_defns)) { ENGINE_free(engine); return; } if (ENGINE_set_RSA(engine, &cryptodev_rsa)) { const RSA_METHOD *rsa_meth = RSA_PKCS1_SSLeay(); cryptodev_rsa.bn_mod_exp = rsa_meth->bn_mod_exp; cryptodev_rsa.rsa_mod_exp = rsa_meth->rsa_mod_exp; cryptodev_rsa.rsa_pub_enc = rsa_meth->rsa_pub_enc; cryptodev_rsa.rsa_pub_dec = rsa_meth->rsa_pub_dec; cryptodev_rsa.rsa_priv_enc = rsa_meth->rsa_priv_enc; cryptodev_rsa.rsa_priv_dec = rsa_meth->rsa_priv_dec; if (cryptodev_asymfeat & CRF_MOD_EXP) { cryptodev_rsa.bn_mod_exp = cryptodev_bn_mod_exp; if (cryptodev_asymfeat & CRF_MOD_EXP_CRT) cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_mod_exp; else cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_nocrt_mod_exp; } } if (ENGINE_set_DSA(engine, &cryptodev_dsa)) { const DSA_METHOD *meth = DSA_OpenSSL(); memcpy(&cryptodev_dsa, meth, sizeof(DSA_METHOD)); if (cryptodev_asymfeat & CRF_DSA_SIGN) cryptodev_dsa.dsa_do_sign = cryptodev_dsa_do_sign; if (cryptodev_asymfeat & CRF_MOD_EXP) { cryptodev_dsa.bn_mod_exp = cryptodev_dsa_bn_mod_exp; cryptodev_dsa.dsa_mod_exp = cryptodev_dsa_dsa_mod_exp; } if (cryptodev_asymfeat & CRF_DSA_VERIFY) cryptodev_dsa.dsa_do_verify = cryptodev_dsa_verify; } if (ENGINE_set_DH(engine, &cryptodev_dh)){ const DH_METHOD *dh_meth = DH_OpenSSL(); cryptodev_dh.generate_key = dh_meth->generate_key; cryptodev_dh.compute_key = dh_meth->compute_key; cryptodev_dh.bn_mod_exp = dh_meth->bn_mod_exp; if (cryptodev_asymfeat & CRF_MOD_EXP) { cryptodev_dh.bn_mod_exp = cryptodev_mod_exp_dh; if (cryptodev_asymfeat & CRF_DH_COMPUTE_KEY) cryptodev_dh.compute_key = cryptodev_dh_compute_key; } } ENGINE_add(engine); ENGINE_free(engine); ERR_clear_error(); }
/****************************************************************************** * function: * bind_qat(ENGINE *e, * const char *id) * * @param e [IN] - OpenSSL engine pointer * @param id [IN] - engine id * * description: * Connect Qat engine to OpenSSL engine library ******************************************************************************/ static int bind_qat(ENGINE *e, const char *id) { int ret = 0; WARN("QAT Warnings enabled.\n"); DEBUG("QAT Debug enabled.\n"); DEBUG("[%s] id=%s\n", __func__, id); if (id && (strcmp(id, engine_qat_id) != 0)) { WARN("ENGINE_id defined already!\n"); goto end; } if (!ENGINE_set_id(e, engine_qat_id)) { WARN("ENGINE_set_id failed\n"); goto end; } if (!ENGINE_set_name(e, engine_qat_name)) { WARN("ENGINE_set_name failed\n"); goto end; } /* Ensure the QAT error handling is set up */ ERR_load_QAT_strings(); /* * Create static structures for ciphers now * as this function will be called by a single thread. */ qat_create_ciphers(); #ifndef OPENSSL_ENABLE_QAT_SMALL_PACKET_CIPHER_OFFLOADS CRYPTO_THREAD_run_once(&qat_pkt_threshold_table_once,qat_pkt_threshold_table_make_key); #endif DEBUG("%s: About to set mem functions\n", __func__); if (!ENGINE_set_RSA(e, qat_get_RSA_methods())) { WARN("ENGINE_set_RSA failed\n"); goto end; } if (!ENGINE_set_DSA(e, qat_get_DSA_methods())) { WARN("ENGINE_set_DSA failed\n"); goto end; } if (!ENGINE_set_DH(e, qat_get_DH_methods())) { WARN("ENGINE_set_DH failed\n"); goto end; } if (!ENGINE_set_EC(e, qat_get_EC_methods())) { WARN("ENGINE_set_EC failed\n"); goto end; } if (!ENGINE_set_ciphers(e, qat_ciphers)) { WARN("ENGINE_set_ciphers failed\n"); goto end; } if (!ENGINE_set_pkey_meths(e, qat_PRF_pkey_methods)) { WARN("ENGINE_set_pkey_meths failed\n"); goto end; } pthread_atfork(engine_fork_handler, NULL, NULL); if (!ENGINE_set_destroy_function(e, qat_engine_destroy) || !ENGINE_set_init_function(e, qat_engine_init) || !ENGINE_set_finish_function(e, qat_engine_finish) || !ENGINE_set_ctrl_function(e, qat_engine_ctrl) || !ENGINE_set_cmd_defns(e, qat_cmd_defns)) { WARN("[%s] failed reg destroy, init or finish\n", __func__); goto end; } ret = 1; end: return ret; }
/* This internal function is used by ENGINE_zencod () and possibly by the * "dynamic" ENGINE support too ;-) */ static int bind_helper ( ENGINE *e ) { #ifndef OPENSSL_NO_RSA const RSA_METHOD *meth_rsa ; #endif #ifndef OPENSSL_NO_DSA const DSA_METHOD *meth_dsa ; #endif #ifndef OPENSSL_NO_DH const DH_METHOD *meth_dh ; #endif const RAND_METHOD *meth_rand ; if ( !ENGINE_set_id ( e, engine_zencod_id ) || !ENGINE_set_name ( e, engine_zencod_name ) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA ( e, &zencod_rsa ) || #endif #ifndef OPENSSL_NO_DSA !ENGINE_set_DSA ( e, &zencod_dsa ) || #endif #ifndef OPENSSL_NO_DH !ENGINE_set_DH ( e, &zencod_dh ) || #endif !ENGINE_set_RAND ( e, &zencod_rand ) || !ENGINE_set_destroy_function ( e, zencod_destroy ) || !ENGINE_set_init_function ( e, zencod_init ) || !ENGINE_set_finish_function ( e, zencod_finish ) || !ENGINE_set_ctrl_function ( e, zencod_ctrl ) || !ENGINE_set_cmd_defns ( e, zencod_cmd_defns ) || !ENGINE_set_digests ( e, engine_digests ) || !ENGINE_set_ciphers ( e, engine_ciphers ) ) { return 0 ; } #ifndef OPENSSL_NO_RSA /* We know that the "PKCS1_SSLeay()" functions hook properly * to the Zencod-specific mod_exp and mod_exp_crt so we use * those functions. NB: We don't use ENGINE_openssl() or * anything "more generic" because something like the RSAref * code may not hook properly, and if you own one of these * cards then you have the right to do RSA operations on it * anyway! */ meth_rsa = RSA_PKCS1_SSLeay () ; zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc ; zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec ; zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc ; zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec ; /* meth_rsa->rsa_mod_exp */ /* meth_rsa->bn_mod_exp */ zencod_rsa.init = meth_rsa->init ; zencod_rsa.finish = meth_rsa->finish ; #endif #ifndef OPENSSL_NO_DSA /* We use OpenSSL meth to supply what we don't provide ;-*) */ meth_dsa = DSA_OpenSSL () ; /* meth_dsa->dsa_do_sign */ zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup ; /* meth_dsa->dsa_do_verify */ zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp ; /* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */ zencod_dsa.init = meth_dsa->init ; zencod_dsa.finish = meth_dsa->finish ; #endif #ifndef OPENSSL_NO_DH /* We use OpenSSL meth to supply what we don't provide ;-*) */ meth_dh = DH_OpenSSL () ; /* zencod_dh.generate_key = meth_dh->generate_key ; */ /* zencod_dh.compute_key = meth_dh->compute_key ; */ /* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */ zencod_dh.init = meth_dh->init ; zencod_dh.finish = meth_dh->finish ; #endif /* We use OpenSSL (SSLeay) meth to supply what we don't provide ;-*) */ meth_rand = RAND_SSLeay () ; /* meth_rand->seed ; */ /* zencod_rand.seed = meth_rand->seed ; */ /* meth_rand->bytes ; */ /* zencod_rand.bytes = meth_rand->bytes ; */ zencod_rand.cleanup = meth_rand->cleanup ; zencod_rand.add = meth_rand->add ; /* meth_rand->pseudorand ; */ /* zencod_rand.pseudorand = meth_rand->pseudorand ; */ /* zencod_rand.status = meth_rand->status ; */ /* meth_rand->status ; */ /* Ensure the zencod error handling is set up */ ERR_load_ZENCOD_strings () ; return 1 ; }
static int bind_gost (ENGINE * e, const char *id) { int ret = 0; if (id && strcmp (id, engine_gost_id)) return 0; if (ameth_GostR3410_94) { printf ("GOST engine already loaded\n"); goto end; } if (!ENGINE_set_id (e, engine_gost_id)) { printf ("ENGINE_set_id failed\n"); goto end; } if (!ENGINE_set_name (e, engine_gost_name)) { printf ("ENGINE_set_name failed\n"); goto end; } if (!ENGINE_set_digests (e, gost_digests)) { printf ("ENGINE_set_digests failed\n"); goto end; } if (!ENGINE_set_ciphers (e, gost_ciphers)) { printf ("ENGINE_set_ciphers failed\n"); goto end; } if (!ENGINE_set_pkey_meths (e, gost_pkey_meths)) { printf ("ENGINE_set_pkey_meths failed\n"); goto end; } if (!ENGINE_set_pkey_asn1_meths (e, gost_pkey_asn1_meths)) { printf ("ENGINE_set_pkey_asn1_meths failed\n"); goto end; } /* Control function and commands */ if (!ENGINE_set_cmd_defns (e, gost_cmds)) { fprintf (stderr, "ENGINE_set_cmd_defns failed\n"); goto end; } if (!ENGINE_set_ctrl_function (e, gost_control_func)) { fprintf (stderr, "ENGINE_set_ctrl_func failed\n"); goto end; } if (!ENGINE_set_destroy_function (e, gost_engine_destroy) || !ENGINE_set_init_function (e, gost_engine_init) || !ENGINE_set_finish_function (e, gost_engine_finish)) { goto end; } if (!register_ameth_gost (NID_id_GostR3410_94, &ameth_GostR3410_94, "GOST94", "GOST R 34.10-94")) goto end; if (!register_ameth_gost (NID_id_GostR3410_2001, &ameth_GostR3410_2001, "GOST2001", "GOST R 34.10-2001")) goto end; if (!register_ameth_gost (NID_id_Gost28147_89_MAC, &ameth_Gost28147_MAC, "GOST-MAC", "GOST 28147-89 MAC")) goto end; if (!register_pmeth_gost (NID_id_GostR3410_94, &pmeth_GostR3410_94, 0)) goto end; if (!register_pmeth_gost (NID_id_GostR3410_2001, &pmeth_GostR3410_2001, 0)) goto end; if (!register_pmeth_gost (NID_id_Gost28147_89_MAC, &pmeth_Gost28147_MAC, 0)) goto end; if (!ENGINE_register_ciphers (e) || !ENGINE_register_digests (e) || !ENGINE_register_pkey_meths (e) /* These two actually should go in LIST_ADD command */ || !EVP_add_cipher (&cipher_gost) || !EVP_add_cipher (&cipher_gost_cpacnt) || !EVP_add_digest (&digest_gost) || !EVP_add_digest (&imit_gost_cpa)) { goto end; } ERR_load_GOST_strings (); ret = 1; end: return ret; }