crypto: pk sign with new function from PR838

The function  pkey_verify_nif handles pk signing with a general approach that is enabled by EVP api in OpenSSL 1.0.0
The rejected PR838 introduced that function and lots of other stuff so far neglected. It also made some different rsa padding methods possible (included).

Since the crypto code base has changed significantly, it was an overhelming work to try a git merge.  Therefore this commit is a manual move of the source code from the PR into current maint.

This commit concentrates to use the new function compatible with the old functions. This includes some #if:s for different versions, compatibility code for 0.9.8.

Lacking:  test cases, exporting the more general erlang api, documentation...

1 files changed, 389 insertions, 236 deletions

diff --git a/lib/crypto/c_src/crypto.c b/lib/crypto/c_src/crypto.c
index e0029d1d9a..028eebd7e6 100644
--- a/lib/crypto/c_src/crypto.c
+++ b/lib/crypto/c_src/crypto.c
@@ -438,8 +438,7 @@ static ERL_NIF_TERM rsa_verify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 static ERL_NIF_TERM do_exor(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM rc4_set_key(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM rc4_encrypt_with_state(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-static ERL_NIF_TERM rsa_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-static ERL_NIF_TERM dss_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM pkey_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM rsa_public_crypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM rsa_private_crypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM rsa_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
@@ -452,7 +451,6 @@ static ERL_NIF_TERM srp_user_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_
 static ERL_NIF_TERM srp_host_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
 static ERL_NIF_TERM ec_key_generate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-static ERL_NIF_TERM ecdsa_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM ecdsa_verify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM ecdh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
@@ -511,8 +509,7 @@ static ErlNifFunc nif_funcs[] = {
     {"do_exor", 2, do_exor},
     {"rc4_set_key", 1, rc4_set_key},
     {"rc4_encrypt_with_state", 2, rc4_encrypt_with_state},
-    {"rsa_sign_nif", 3, rsa_sign_nif},
-    {"dss_sign_nif", 3, dss_sign_nif},
+    {"pkey_sign_nif", 5, pkey_sign_nif},
     {"rsa_public_crypt", 4, rsa_public_crypt},
     {"rsa_private_crypt", 4, rsa_private_crypt},
     {"rsa_generate_key_nif", 2, rsa_generate_key_nif},
@@ -525,7 +522,6 @@ static ErlNifFunc nif_funcs[] = {
     {"srp_host_secret_nif", 5, srp_host_secret_nif},
 
     {"ec_key_generate", 2, ec_key_generate},
-    {"ecdsa_sign_nif", 4, ecdsa_sign_nif},
     {"ecdsa_verify_nif", 5, ecdsa_verify_nif},
     {"ecdh_compute_key_nif", 3, ecdh_compute_key_nif},
 
@@ -589,6 +585,23 @@ static ERL_NIF_TERM atom_des_ecb;
 static ERL_NIF_TERM atom_blowfish_ecb;
 #endif
 
+static ERL_NIF_TERM atom_rsa;
+static ERL_NIF_TERM atom_dss;
+static ERL_NIF_TERM atom_ecdsa;
+static ERL_NIF_TERM atom_rsa_mgf1_md;
+static ERL_NIF_TERM atom_rsa_padding;
+static ERL_NIF_TERM atom_rsa_pkcs1_pss_padding;
+static ERL_NIF_TERM atom_rsa_x931_padding;
+static ERL_NIF_TERM atom_rsa_pss_saltlen;
+static ERL_NIF_TERM atom_sha224;
+static ERL_NIF_TERM atom_sha256;
+static ERL_NIF_TERM atom_sha384;
+static ERL_NIF_TERM atom_sha512;
+static ERL_NIF_TERM atom_md5;
+static ERL_NIF_TERM atom_ripemd160;
+
+
+
 static ErlNifResourceType* hmac_context_rtype;
 struct hmac_context
 {
@@ -916,6 +929,20 @@ static int initialize(ErlNifEnv* env, ERL_NIF_TERM load_info)
 #else
     atom_not_supported = enif_make_atom(env,"not_supported");
 #endif
+    atom_rsa = enif_make_atom(env,"rsa");
+    atom_dss = enif_make_atom(env,"dss");
+    atom_ecdsa = enif_make_atom(env,"ecdsa");
+    atom_rsa_mgf1_md = enif_make_atom(env,"rsa_mgf1_md");
+    atom_rsa_padding = enif_make_atom(env,"rsa_padding");
+    atom_rsa_pkcs1_pss_padding = enif_make_atom(env,"rsa_pkcs1_pss_padding");
+    atom_rsa_x931_padding = enif_make_atom(env,"rsa_x931_padding");
+    atom_rsa_pss_saltlen = enif_make_atom(env,"rsa_pss_saltlen");
+    atom_sha224 = enif_make_atom(env,"sha224");
+    atom_sha256 = enif_make_atom(env,"sha256");
+    atom_sha384 = enif_make_atom(env,"sha384");
+    atom_sha512 = enif_make_atom(env,"sha512");
+    atom_md5 = enif_make_atom(env,"md5");
+    atom_ripemd160 = enif_make_atom(env,"ripemd160");
 
     init_digest_types(env);
     init_cipher_types(env);
@@ -2633,82 +2660,6 @@ static int get_rsa_public_key(ErlNifEnv* env, ERL_NIF_TERM key, RSA *rsa)
 }
 
 
-static ERL_NIF_TERM rsa_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (Type, Digest, Key=[E,N,D]|[E,N,D,P1,P2,E1,E2,C]) */
-    ErlNifBinary         digest_bin, ret_bin;
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-    EVP_PKEY             *pkey;
-    EVP_PKEY_CTX         *ctx;
-    size_t               rsa_s_len;
-#else
-    unsigned             rsa_s_len, len;
-#endif
-    RSA                  *rsa;
-    int                  i;
-    struct digest_type_t *digp;
-    const EVP_MD         *md;
-
-    digp = get_digest_type(argv[0]);
-    if (!digp) {
-	return enif_make_badarg(env);
-    }
-    md = digp->md.p;
-    if (!md) {
-	return atom_notsup;
-    }
-
-    if (!enif_inspect_binary(env,argv[1],&digest_bin)
-        || digest_bin.size != EVP_MD_size(md)) {
-        return enif_make_badarg(env);
-    }
-
-    rsa = RSA_new();
-    if (!get_rsa_private_key(env, argv[2], rsa)) {
-	RSA_free(rsa);
-	return enif_make_badarg(env);
-    }
-
-
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-    pkey = EVP_PKEY_new();
-    EVP_PKEY_set1_RSA(pkey, rsa);
-    rsa_s_len=(size_t)EVP_PKEY_size(pkey);
-    enif_alloc_binary(rsa_s_len, &ret_bin);
-
-    ctx = EVP_PKEY_CTX_new(pkey, NULL);
-    EVP_PKEY_sign_init(ctx);
-    EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING);
-    EVP_PKEY_CTX_set_signature_md(ctx, md);
-
-    i = EVP_PKEY_sign(ctx, ret_bin.data, &rsa_s_len,
-                      digest_bin.data, digest_bin.size);
-    ASSERT(i<=0 || rsa_s_len <= ret_bin.size);
-    EVP_PKEY_CTX_free(ctx);
-    EVP_PKEY_free(pkey);
-#else
-    enif_alloc_binary(RSA_size(rsa), &ret_bin);
-    len = EVP_MD_size(md);
-
-    ERL_VALGRIND_ASSERT_MEM_DEFINED(digest_bin.data, len);
-    i =  RSA_sign(md->type, digest_bin.data, len,
-		  ret_bin.data, &rsa_s_len, rsa);
-#endif
-
-    RSA_free(rsa);
-    if (i > 0) {
-	ERL_VALGRIND_MAKE_MEM_DEFINED(ret_bin.data, rsa_s_len);
-	if (rsa_s_len != ret_bin.size) {
-	    enif_realloc_binary(&ret_bin, rsa_s_len);
-	    ERL_VALGRIND_ASSERT_MEM_DEFINED(ret_bin.data, rsa_s_len);
-	}
-	return enif_make_binary(env,&ret_bin);
-    }
-    else {
-	enif_release_binary(&ret_bin);
-	return atom_error;
-    }
-}
-
 static ERL_NIF_TERM rsa_verify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Type, Digest, Signature, Key=[E,N]) */
     ErlNifBinary         digest_bin, sign_bin;
@@ -2829,83 +2780,6 @@ static int get_dss_public_key(ErlNifEnv* env, ERL_NIF_TERM key, DSA *dsa)
     return 1;
 }
 
-static ERL_NIF_TERM dss_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (sha, Digest, Key=[P,Q,G,PrivKey]) */
-    ErlNifBinary digest_bin, ret_bin;
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-    EVP_PKEY             *pkey;
-    EVP_PKEY_CTX         *ctx;
-    size_t               dsa_s_len;
-#else
-    unsigned             dsa_s_len, len;
-#endif
-    DSA                  *dsa;
-    int i;
-    struct digest_type_t *digp;
-    const EVP_MD         *md;
-
-    if (argv[0] != atom_sha) { /* dsa uses sha1 */
-        return enif_make_badarg(env);
-    }
-
-    digp = get_digest_type(argv[0]);
-    if (!digp) {
-	return enif_make_badarg(env);
-    }
-    md = digp->md.p;
-    if (!md) {
-	return atom_notsup;
-    }
-
-    if (!enif_inspect_binary(env,argv[1],&digest_bin)
-        || digest_bin.size != EVP_MD_size(md)) {
-        return enif_make_badarg(env);
-    }
-
-    dsa = DSA_new();
-    if (!get_dss_private_key(env, argv[2], dsa)) {
-        DSA_free(dsa);
-        return enif_make_badarg(env);
-    }
-
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-     pkey = EVP_PKEY_new();
-     EVP_PKEY_set1_DSA(pkey, dsa);
-     dsa_s_len=(size_t)EVP_PKEY_size(pkey);
-     enif_alloc_binary(dsa_s_len, &ret_bin);
-
-     ctx = EVP_PKEY_CTX_new(pkey, NULL);
-     EVP_PKEY_sign_init(ctx);
-     /* EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING); */
-     EVP_PKEY_CTX_set_signature_md(ctx, md);
-
-     i = EVP_PKEY_sign(ctx, ret_bin.data, &dsa_s_len,
-                       digest_bin.data, digest_bin.size);
-     ASSERT(i<=0 || dsa_s_len <= ret_bin.size);
-     EVP_PKEY_CTX_free(ctx);
-     EVP_PKEY_free(pkey);
-#else
-    enif_alloc_binary(DSA_size(dsa), &ret_bin);
-    len = EVP_MD_size(md);
-
-    i =  DSA_sign(md->type, digest_bin.data, len,
-		  ret_bin.data, &dsa_s_len, dsa);
-#endif
-
-    DSA_free(dsa);
-
-    if (i) {
-	if (dsa_s_len != ret_bin.size) {
-	    enif_realloc_binary(&ret_bin, dsa_s_len);
-	}
-	return enif_make_binary(env, &ret_bin);
-    }
-    else {
-	enif_release_binary(&ret_bin);
-	return atom_error;
-    }
-}
-
 static ERL_NIF_TERM dss_verify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (sha, Digest, Signature,Key=[P, Q, G, Y]) */
     ErlNifBinary digest_bin, sign_bin;
@@ -3916,83 +3790,6 @@ badarg:
 #endif
 }
 
-static ERL_NIF_TERM ecdsa_sign_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (Type, Digest, Curve, Key) */
-#if defined(HAVE_EC)
-    ErlNifBinary digest_bin, ret_bin;
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-    EVP_PKEY             *pkey;
-    EVP_PKEY_CTX         *ctx;
-    size_t               ecdsa_s_len;
-#else
-    unsigned             ecdsa_s_len, len;
-#endif
-    EC_KEY              *ec = NULL;
-    int i;
-    struct digest_type_t *digp;
-    const EVP_MD         *md;
-
-    digp = get_digest_type(argv[0]);
-    if (!digp) {
-	return enif_make_badarg(env);
-    }
-    md = digp->md.p;
-    if (!md) {
-	return atom_notsup;
-    }
-
-    if (!enif_inspect_binary(env,argv[1],&digest_bin)
-        || digest_bin.size != EVP_MD_size(md))
-      goto badarg;
-
-    if (!get_ec_key(env, argv[2], argv[3], atom_undefined, &ec))
-      goto badarg;
-
-#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
-    pkey = EVP_PKEY_new();
-    EVP_PKEY_set1_EC_KEY(pkey, ec);
-    ecdsa_s_len=(size_t)EVP_PKEY_size(pkey);
-    enif_alloc_binary(ecdsa_s_len, &ret_bin);
-
-    ctx = EVP_PKEY_CTX_new(pkey, NULL);
-    EVP_PKEY_sign_init(ctx);
-    /* EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING); */
-    EVP_PKEY_CTX_set_signature_md(ctx, md);
-
-    i = EVP_PKEY_sign(ctx, ret_bin.data, &ecdsa_s_len,
-                      digest_bin.data, digest_bin.size);
-    ASSERT(i<=0 || ecdsa_s_len <= ret_bin.size);
-    EVP_PKEY_CTX_free(ctx);
-    EVP_PKEY_free(pkey);
-#else
-    enif_alloc_binary(ECDSA_size(ec), &ret_bin);
-    len = EVP_MD_size(md);
-    
-    i = ECDSA_sign(EVP_MD_type(md), digest_bin.data, len,
-		   ret_bin.data, &ecdsa_s_len, ec);
-#endif
-
-    EC_KEY_free(ec);
-    if (i) {
-	if (ecdsa_s_len != ret_bin.size) {
-	    enif_realloc_binary(&ret_bin, ecdsa_s_len);
-	}
-	return enif_make_binary(env, &ret_bin);
-    }
-    else {
-	enif_release_binary(&ret_bin);
-	return atom_error;
-    }
-
-badarg:
-    if (ec)
-	EC_KEY_free(ec);
-    return make_badarg_maybe(env);
-#else
-    return atom_notsup;
-#endif
-}
-
 static ERL_NIF_TERM ecdsa_verify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Type, Digest, Signature, Curve, Key) */
 #if defined(HAVE_EC)
@@ -4109,6 +3906,362 @@ out_err:
 #endif
 }
 
+/*================================================================*/
+#define PKEY_BADARG -1
+#define PKEY_NOTSUP 0
+#define PKEY_OK 1
+
+typedef struct PKeyCryptOptions {
+    const EVP_MD *rsa_mgf1_md;
+    ErlNifBinary rsa_oaep_label;
+    const EVP_MD *rsa_oaep_md;
+    int rsa_padding;
+    const EVP_MD *signature_md;
+} PKeyCryptOptions;
+
+typedef struct PKeySignOptions {
+    const EVP_MD *rsa_mgf1_md;
+    int rsa_padding;
+    int rsa_pss_saltlen;
+} PKeySignOptions;
+
+static int get_pkey_digest_type(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_TERM type,
+				const EVP_MD **md)
+{
+    struct digest_type_t *digp = NULL;
+    *md = NULL;
+
+    if (type == atom_none && algorithm == atom_rsa) return PKEY_OK;
+
+    digp = get_digest_type(type);
+    if (!digp) return PKEY_BADARG;
+    if (!digp->md.p) return PKEY_NOTSUP;
+
+    *md = digp->md.p;
+    return PKEY_OK;
+}
+
+
+static int get_pkey_sign_digest(ErlNifEnv *env, ERL_NIF_TERM algorithm,
+				ERL_NIF_TERM type, ERL_NIF_TERM data,
+				unsigned char *md_value, const EVP_MD **mdp,
+				unsigned char **tbsp, size_t *tbslenp)
+{
+    int i;
+    const ERL_NIF_TERM *tpl_terms;
+    int tpl_arity;
+    ErlNifBinary tbs_bin;
+    EVP_MD_CTX *mdctx;
+    const EVP_MD *md = *mdp;
+    unsigned char *tbs = *tbsp;
+    size_t tbslen = *tbslenp;
+    unsigned int tbsleni;
+
+    if ((i = get_pkey_digest_type(env, algorithm, type, &md)) != PKEY_OK) {
+	return i;
+    }
+    if (enif_get_tuple(env, data, &tpl_arity, &tpl_terms)) {
+	if (tpl_arity != 2 || tpl_terms[0] != atom_digest
+	    || !enif_inspect_binary(env, tpl_terms[1], &tbs_bin)
+	    || (md != NULL && tbs_bin.size != EVP_MD_size(md))) {
+	    return PKEY_BADARG;
+	}
+        /* We have a digest (= hashed text) in tbs_bin */
+	tbs = tbs_bin.data;
+	tbslen = tbs_bin.size;
+    } else if (md == NULL) {
+	if (!enif_inspect_binary(env, data, &tbs_bin)) {
+	    return PKEY_BADARG;
+	}
+        /* md == NULL, that is no hashing because DigestType argument was atom_none */
+	tbs = tbs_bin.data;
+	tbslen = tbs_bin.size;
+    } else {
+	if (!enif_inspect_binary(env, data, &tbs_bin)) {
+	    return PKEY_BADARG;
+	}
+        /* We have the cleartext in tbs_bin and the hash algo info in md */
+	tbs = md_value;
+	mdctx = EVP_MD_CTX_create();
+	if (!mdctx) {
+	    return PKEY_BADARG;
+	}
+        /* Looks well, now hash the plain text into a digest according to md */
+	if (EVP_DigestInit_ex(mdctx, md, NULL) <= 0) {
+	    EVP_MD_CTX_destroy(mdctx);
+	    return PKEY_BADARG;
+	}
+	if (EVP_DigestUpdate(mdctx, tbs_bin.data, tbs_bin.size) <= 0) {
+	    EVP_MD_CTX_destroy(mdctx);
+	    return PKEY_BADARG;
+	}
+	if (EVP_DigestFinal_ex(mdctx, tbs, &tbsleni) <= 0) {
+	    EVP_MD_CTX_destroy(mdctx);
+	    return PKEY_BADARG;
+	}
+	tbslen = (size_t)(tbsleni);
+	EVP_MD_CTX_destroy(mdctx);
+    }
+
+    *mdp = md;
+    *tbsp = tbs;
+    *tbslenp = tbslen;
+
+    return PKEY_OK;
+}
+
+
+static int get_pkey_sign_options(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_TERM options,
+                                 const EVP_MD *md, PKeySignOptions *opt)
+{
+    ERL_NIF_TERM head, tail;
+    const ERL_NIF_TERM *tpl_terms;
+    int tpl_arity;
+    const EVP_MD *opt_md;
+    int i;
+
+    if (!enif_is_list(env, options)) {
+	return PKEY_BADARG;
+    }
+
+    /* defaults */
+    if (algorithm == atom_rsa) {
+	opt->rsa_mgf1_md = NULL;
+	opt->rsa_padding = RSA_PKCS1_PADDING;
+	opt->rsa_pss_saltlen = -2;
+    }
+
+    if (enif_is_empty_list(env, options)) {
+	return PKEY_OK;
+    }
+
+    if (algorithm == atom_rsa) {
+	tail = options;
+	while (enif_get_list_cell(env, tail, &head, &tail)) {
+	    if (enif_get_tuple(env, head, &tpl_arity, &tpl_terms) && tpl_arity == 2) {
+		if (tpl_terms[0] == atom_rsa_mgf1_md && enif_is_atom(env, tpl_terms[1])) {
+		    i = get_pkey_digest_type(env, algorithm, tpl_terms[1], &opt_md);
+		    if (i != PKEY_OK) {
+			return i;
+		    }
+		    opt->rsa_mgf1_md = opt_md;
+		} else if (tpl_terms[0] == atom_rsa_padding) {
+		    if (tpl_terms[1] == atom_rsa_pkcs1_padding) {
+			opt->rsa_padding = RSA_PKCS1_PADDING;
+		    /* } else if (tpl_terms[1] == atom_rsa_pkcs1_pss_padding) { */
+		    /*     opt->rsa_padding = RSA_PKCS1_PSS_PADDING; */
+		    /*     if (opt->rsa_mgf1_md == NULL) { */
+		    /*         opt->rsa_mgf1_md = md; */
+		    /*     } */
+		    } else if (tpl_terms[1] == atom_rsa_x931_padding) {
+			opt->rsa_padding = RSA_X931_PADDING;
+		    } else if (tpl_terms[1] == atom_rsa_no_padding) {
+			opt->rsa_padding = RSA_NO_PADDING;
+		    } else {
+			return PKEY_BADARG;
+		    }
+		} else if (tpl_terms[0] == atom_rsa_pss_saltlen) {
+		    if (!enif_get_int(env, tpl_terms[1], &(opt->rsa_pss_saltlen))
+			|| opt->rsa_pss_saltlen < -2) {
+			return PKEY_BADARG;
+		    }
+		} else {
+		    return PKEY_BADARG;
+		}
+	    } else {
+		return PKEY_BADARG;
+	    }
+	}
+    } else {
+	return PKEY_BADARG;
+    }
+
+    return PKEY_OK;
+}
+
+static int get_pkey_sign_key(ErlNifEnv *env, ERL_NIF_TERM algorithm, ERL_NIF_TERM key, EVP_PKEY **pkey)
+{
+    if (algorithm == atom_rsa) {
+	RSA *rsa = RSA_new();
+
+	if (!get_rsa_private_key(env, key, rsa)) {
+	    RSA_free(rsa);
+	    return PKEY_BADARG;
+	}
+
+	*pkey = EVP_PKEY_new();
+	if (!EVP_PKEY_assign_RSA(*pkey, rsa)) {
+	    EVP_PKEY_free(*pkey);
+	    RSA_free(rsa);
+	    return PKEY_BADARG;
+	}
+    } else if (algorithm == atom_ecdsa) {
+#if defined(HAVE_EC)
+	EC_KEY *ec = NULL;
+	const ERL_NIF_TERM *tpl_terms;
+	int tpl_arity;
+
+	if (enif_get_tuple(env, key, &tpl_arity, &tpl_terms) && tpl_arity == 2
+	    && enif_is_tuple(env, tpl_terms[0]) && enif_is_binary(env, tpl_terms[1])
+	    && get_ec_key(env, tpl_terms[0], tpl_terms[1], atom_undefined, &ec)) {
+
+	    *pkey = EVP_PKEY_new();
+	    if (!EVP_PKEY_assign_EC_KEY(*pkey, ec)) {
+		EVP_PKEY_free(*pkey);
+		EC_KEY_free(ec);
+		return PKEY_BADARG;
+	    }
+	} else {
+	    return PKEY_BADARG;
+	}
+#else
+	return PKEY_NOTSUP;
+#endif
+    } else if (algorithm == atom_dss) {
+	DSA *dsa = DSA_new();
+
+	if (!get_dss_private_key(env, key, dsa)) {
+	    DSA_free(dsa);
+            return PKEY_BADARG;
+        }
+
+	*pkey = EVP_PKEY_new();
+	if (!EVP_PKEY_assign_DSA(*pkey, dsa)) {
+	    EVP_PKEY_free(*pkey);
+	    DSA_free(dsa);
+	    return PKEY_BADARG;
+	}
+    } else {
+	return PKEY_BADARG;
+    }
+
+    return PKEY_OK;
+}
+
+static ERL_NIF_TERM pkey_sign_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{/* (Algorithm, Type, Data|{digest,Digest}, Key, Options) */
+    int i;
+    const EVP_MD *md = NULL;
+    unsigned char md_value[EVP_MAX_MD_SIZE];
+    EVP_PKEY *pkey;
+#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
+    EVP_PKEY_CTX *ctx;
+    size_t siglen;
+#else
+    unsigned len, siglen;
+#endif
+    PKeySignOptions sig_opt;
+    ErlNifBinary sig_bin; /* signature */
+    unsigned char *tbs; /* data to be signed */
+    size_t tbslen;
+/*char buf[1024];
+enif_get_atom(env,argv[0],buf,1024,ERL_NIF_LATIN1); printf("algo=%s ",buf);
+enif_get_atom(env,argv[1],buf,1024,ERL_NIF_LATIN1); printf("hash=%s ",buf);
+printf("\r\n");
+*/
+    i = get_pkey_sign_digest(env, argv[0], argv[1], argv[2], md_value, &md, &tbs, &tbslen);
+    if (i != PKEY_OK) {
+	if (i == PKEY_NOTSUP)
+	    return atom_notsup;
+	else
+	    return enif_make_badarg(env);
+    }
+
+    i = get_pkey_sign_options(env, argv[0], argv[4], md, &sig_opt);
+    if (i != PKEY_OK) {
+	if (i == PKEY_NOTSUP)
+	    return atom_notsup;
+	else
+	    return enif_make_badarg(env);
+    }
+
+    if (get_pkey_sign_key(env, argv[0], argv[3], &pkey) != PKEY_OK) {
+	return enif_make_badarg(env);
+    }
+
+#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
+/* printf("EVP interface\r\n"); 
+ */
+    ctx = EVP_PKEY_CTX_new(pkey, NULL);
+    if (!ctx) goto badarg;
+    if (EVP_PKEY_sign_init(ctx) <= 0) goto badarg;
+    if (md != NULL && EVP_PKEY_CTX_set_signature_md(ctx, md) <= 0) goto badarg;
+
+    if (argv[0] == atom_rsa) {
+	if (EVP_PKEY_CTX_set_rsa_padding(ctx, sig_opt.rsa_padding) <= 0) goto badarg;
+	if (sig_opt.rsa_padding == RSA_PKCS1_PSS_PADDING) {
+	    if (sig_opt.rsa_mgf1_md != NULL
+		&& EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, sig_opt.rsa_mgf1_md) <= 0) goto badarg;
+	    if (sig_opt.rsa_pss_saltlen > -2
+		&& EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sig_opt.rsa_pss_saltlen) <= 0)
+		goto badarg;
+	}
+    }
+
+    if (EVP_PKEY_sign(ctx, NULL, &siglen, tbs, tbslen) <= 0) goto badarg;
+    enif_alloc_binary(siglen, &sig_bin);
+
+    if (md != NULL) {
+	ERL_VALGRIND_ASSERT_MEM_DEFINED(tbs, EVP_MD_size(md));
+    }
+    i = EVP_PKEY_sign(ctx, sig_bin.data, &siglen, tbs, tbslen);
+
+    EVP_PKEY_CTX_free(ctx);
+#else
+/*printf("Old interface\r\n");
+ */
+    if (argv[0] == atom_rsa) {
+       RSA *rsa = EVP_PKEY_get1_RSA(pkey);
+       enif_alloc_binary(RSA_size(rsa), &sig_bin);
+       len = EVP_MD_size(md);
+       ERL_VALGRIND_ASSERT_MEM_DEFINED(digest_bin.data, len);
+       i = RSA_sign(md->type, tbs, len, sig_bin.data, &siglen, rsa);
+
+    } else if (argv[0] == atom_dss) {
+       DSA *dsa = EVP_PKEY_get1_DSA(pkey);
+       enif_alloc_binary(DSA_size(dsa), &sig_bin);
+       len = EVP_MD_size(md);
+       ERL_VALGRIND_ASSERT_MEM_DEFINED(digest_bin.data, len);
+       i = DSA_sign(md->type, tbs, len, sig_bin.data, &siglen, dsa);
+
+    } else if (argv[0] == atom_ecdsa) {
+#if defined(HAVE_EC)
+       EC_KEY *ec = EVP_PKEY_get1_EC_KEY(pkey);
+       enif_alloc_binary(ECDSA_size(ec), &sig_bin);
+       len = EVP_MD_size(md);
+       ERL_VALGRIND_ASSERT_MEM_DEFINED(digest_bin.data, len);
+       i = ECDSA_sign(md->type, tbs, len, sig_bin.data, &siglen, ec);
+#else
+        return atom_notsup;
+#endif
+    } else {
+	goto badarg;
+    }
+#endif
+
+    EVP_PKEY_free(pkey);
+    if (i == 1) {
+	ERL_VALGRIND_MAKE_MEM_DEFINED(sig_bin.data, siglen);
+	if (siglen != sig_bin.size) {
+	    enif_realloc_binary(&sig_bin, siglen);
+	    ERL_VALGRIND_ASSERT_MEM_DEFINED(sig_bin.data, siglen);
+	}
+	return enif_make_binary(env, &sig_bin);
+    } else {
+	enif_release_binary(&sig_bin);
+	return atom_error;
+    }
+
+ badarg:
+#if OPENSSL_VERSION_NUMBER >= PACKED_OPENSSL_VERSION_PLAIN(1,0,0)
+    EVP_PKEY_CTX_free(ctx);
+#endif
+    EVP_PKEY_free(pkey);
+    return enif_make_badarg(env);
+}
+
+/*================================================================*/
+
 static ERL_NIF_TERM rand_seed_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     ErlNifBinary seed_bin;