void ENGINE_register_all_RSA() { ENGINE *e; for(e=ENGINE_get_first() ; e ; e=ENGINE_get_next(e)) ENGINE_register_RSA(e); }
static void resume_engine(void *ctx,int mem) { ENGINE *e=(ENGINE *)ctx; if(mem&0x01)ENGINE_register_RSA(e); if(mem&0x02)ENGINE_register_DSA(e); #if OPENSSL_VERSION_NUMBER >= 0x1010000fL if(mem&0x04)ENGINE_register_EC(e); #else if(mem&0x04)ENGINE_register_ECDH(e); if(mem&0x08)ENGINE_register_ECDSA(e); #endif if(mem&0x10)ENGINE_register_DH(e); if(mem&0x20)ENGINE_register_RAND(e); }
int ENGINE_register_complete(ENGINE *e) { ENGINE_register_ciphers(e); ENGINE_register_digests(e); #ifndef OPENSSL_NO_RSA ENGINE_register_RSA(e); #endif #ifndef OPENSSL_NO_DSA ENGINE_register_DSA(e); #endif #ifndef OPENSSL_NO_DH ENGINE_register_DH(e); #endif #ifndef OPENSSL_NO_EC ENGINE_register_ECDH(e); ENGINE_register_ECDSA(e); #endif ENGINE_register_RAND(e); ENGINE_register_pkey_meths(e); return 1; }
static int openssl_engine_register(lua_State*L) { ENGINE* eng = CHECK_OBJECT(1, ENGINE, "openssl.engine"); int unregister = 0; int first = 2; int top = lua_gettop(L); if (lua_isboolean(L, 2)) { unregister = lua_toboolean(L, 2); first = 3; }; while (first <= top) { int c = luaL_checkoption(L, first, "RSA", list); switch (c) { case TYPE_RSA: if (unregister) ENGINE_unregister_RSA(eng); else ENGINE_register_RSA(eng); break; case TYPE_DSA: if (unregister) ENGINE_unregister_DSA(eng); else ENGINE_register_DSA(eng); break; case TYPE_ECDH: if (unregister) ENGINE_unregister_ECDH(eng); else ENGINE_register_ECDH(eng); break; case TYPE_ECDSA: if (unregister) ENGINE_unregister_ECDSA(eng); else ENGINE_register_ECDSA(eng); break; case TYPE_DH: if (unregister) ENGINE_unregister_DH(eng); else ENGINE_register_DH(eng); break; case TYPE_RAND: if (unregister) ENGINE_unregister_RAND(eng); else ENGINE_register_RAND(eng); break; case TYPE_STORE: if (unregister) ENGINE_unregister_STORE(eng); else ENGINE_register_STORE(eng); break; case TYPE_CIPHERS: if (unregister) ENGINE_unregister_ciphers(eng); else ENGINE_register_ciphers(eng); break; case TYPE_DIGESTS: if (unregister) ENGINE_unregister_digests(eng); else ENGINE_register_digests(eng); break; case TYPE_COMPLETE: { int ret = ENGINE_register_complete(eng); lua_pushboolean(L, ret); return 1; break; } default: luaL_error(L, "not support %d for %s", c, list[c]); break; } first++; } return 0; };
ERL_NIF_TERM engine_register_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {/* (Engine, EngineMethod) */ #ifdef HAS_ENGINE_SUPPORT struct engine_ctx *ctx; unsigned int method; // Get Engine ASSERT(argc == 2); if (!enif_get_resource(env, argv[0], engine_ctx_rtype, (void**)&ctx)) goto bad_arg; if (!enif_get_uint(env, argv[1], &method)) goto bad_arg; switch(method) { #ifdef ENGINE_METHOD_RSA case ENGINE_METHOD_RSA: if (!ENGINE_register_RSA(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_DSA case ENGINE_METHOD_DSA: if (!ENGINE_register_DSA(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_DH case ENGINE_METHOD_DH: if (!ENGINE_register_DH(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_RAND case ENGINE_METHOD_RAND: if (!ENGINE_register_RAND(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_ECDH case ENGINE_METHOD_ECDH: if (!ENGINE_register_ECDH(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_ECDSA case ENGINE_METHOD_ECDSA: if (!ENGINE_register_ECDSA(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_STORE case ENGINE_METHOD_STORE: if (!ENGINE_register_STORE(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_CIPHERS case ENGINE_METHOD_CIPHERS: if (!ENGINE_register_ciphers(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_DIGESTS case ENGINE_METHOD_DIGESTS: if (!ENGINE_register_digests(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_PKEY_METHS case ENGINE_METHOD_PKEY_METHS: if (!ENGINE_register_pkey_meths(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_PKEY_ASN1_METHS case ENGINE_METHOD_PKEY_ASN1_METHS: if (!ENGINE_register_pkey_asn1_meths(ctx->engine)) goto failed; break; #endif #ifdef ENGINE_METHOD_EC case ENGINE_METHOD_EC: if (!ENGINE_register_EC(ctx->engine)) goto failed; break; #endif default: return ERROR_Atom(env, "engine_method_not_supported"); } return atom_ok; bad_arg: return enif_make_badarg(env); failed: return ERROR_Atom(env, "register_engine_failed"); #else return atom_notsup; #endif }
int main(int argc, char *argv[]) { ENGINE *e; EVP_PKEY *pub_key; FILE *fp; char *engine = NULL; char *pin = NULL; char *keyname = NULL; char *filename = NULL; int c, errflg = 0; extern char *optarg; extern int optopt; while ((c = getopt(argc, argv, ":e:p:k:f:")) != -1) { switch (c) { case 'e': engine = optarg; break; case 'p': pin = optarg; break; case 'k': keyname = optarg; break; case 'f': filename = optarg; break; case ':': fprintf(stderr, "Option -%c requires an operand\n", optopt); errflg++; break; case '?': default: fprintf(stderr, "Unrecognised option: -%c\n", optopt); errflg++; } } if ((errflg) || (!engine) || (!filename) || (!keyname)) { fprintf(stderr, "usage: PEM_write_pubkey -e engine [-p pin] " "-k keyname -f filename\n"); exit(1); } /* Load the config file */ OPENSSL_config(NULL); /* Register engine */ e = ENGINE_by_id(engine); if (!e) { /* the engine isn't available */ printf("The engine isn't available\n"); ERR_print_errors_fp(stderr); exit(1); } /* Send PIN to engine */ if (pin && !ENGINE_ctrl_cmd_string(e, "PIN", pin, 0)){ printf("Error sending PIN to engine\n"); ERR_print_errors_fp(stderr); ENGINE_free(e); exit(1); } if (!ENGINE_init(e)) { /* the engine couldn't initialise, release 'e' */ printf("The engine couldn't initialise\n"); ERR_print_errors_fp(stderr); ENGINE_free(e); exit(1); } if (!ENGINE_register_RSA(e)){ /* This should only happen when 'e' can't initialise, but the previous * statement suggests it did. */ printf("This should not happen\n"); ERR_print_errors_fp(stderr); exit(1); } /* Load public key */ pub_key = ENGINE_load_public_key(e, keyname, NULL, NULL); if (pub_key == NULL) { /* No public key */ printf("Error loading public key\n"); ERR_print_errors_fp(stderr); ENGINE_free(e); exit(1); } /* write public key to file in PEM format */ fp = fopen(filename, "w"); if (fp == NULL) { printf("Error opening output file.\n"); ENGINE_free(e); exit(1); } if (!PEM_write_PUBKEY(fp, pub_key)) { /* Error writing public key */ printf("Error writing public key"); ERR_print_errors_fp(stderr); ENGINE_free(e); exit(1); } fclose(fp); exit(0); }