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