crypto: Add generic functions generate_key and compute_key

and remove corresponding specific functions for srp and ecdh
but leave dh_ functions for backward compatibility.

3 files changed, 150 insertions, 170 deletions

diff --git a/lib/crypto/c_src/crypto.c b/lib/crypto/c_src/crypto.c
index 08c6d4dbc5..c5d181ea25 100644
--- a/lib/crypto/c_src/crypto.c
+++ b/lib/crypto/c_src/crypto.c
@@ -222,8 +222,8 @@ static ERL_NIF_TERM dh_check(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
 static ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM srp_value_B_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-static ERL_NIF_TERM srp_client_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
-static ERL_NIF_TERM srp_server_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM srp_user_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM srp_host_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM bf_cfb64_crypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM bf_cbc_crypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM bf_ecb_crypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
@@ -349,11 +349,11 @@ static ErlNifFunc nif_funcs[] = {
     {"rsa_private_crypt", 4, rsa_private_crypt},
     {"dh_generate_parameters_nif", 2, dh_generate_parameters_nif},
     {"dh_check", 1, dh_check},
-    {"dh_generate_key_nif", 2, dh_generate_key_nif},
+    {"dh_generate_key_nif", 3, dh_generate_key_nif},
     {"dh_compute_key_nif", 3, dh_compute_key_nif},
     {"srp_value_B_nif", 5, srp_value_B_nif},
-    {"srp_client_secret_nif", 7, srp_client_secret_nif},
-    {"srp_server_secret_nif", 5, srp_server_secret_nif},
+    {"srp_user_secret_nif", 7, srp_user_secret_nif},
+    {"srp_host_secret_nif", 5, srp_host_secret_nif},
     {"bf_cfb64_crypt", 4, bf_cfb64_crypt},
     {"bf_cbc_crypt", 4, bf_cbc_crypt},
     {"bf_ecb_crypt", 3, bf_ecb_crypt},
@@ -2442,14 +2442,12 @@ static ERL_NIF_TERM dh_generate_parameters_nif(ErlNifEnv* env, int argc, const E
     }
     p_len = BN_num_bytes(dh_params->p);
     g_len = BN_num_bytes(dh_params->g);
-    p_ptr = enif_make_new_binary(env, p_len+4, &ret_p);
-    g_ptr = enif_make_new_binary(env, g_len+4, &ret_g);
-    put_int32(p_ptr, p_len);
-    put_int32(g_ptr, g_len);
-    BN_bn2bin(dh_params->p, p_ptr+4);
-    BN_bn2bin(dh_params->g, g_ptr+4);
-    ERL_VALGRIND_MAKE_MEM_DEFINED(p_ptr+4, p_len);                
-    ERL_VALGRIND_MAKE_MEM_DEFINED(g_ptr+4, g_len);
+    p_ptr = enif_make_new_binary(env, p_len, &ret_p);
+    g_ptr = enif_make_new_binary(env, g_len, &ret_g);
+    BN_bn2bin(dh_params->p, p_ptr);
+    BN_bn2bin(dh_params->g, g_ptr);
+    ERL_VALGRIND_MAKE_MEM_DEFINED(p_ptr, p_len);
+    ERL_VALGRIND_MAKE_MEM_DEFINED(g_ptr, g_len);
     DH_free(dh_params);
     return enif_make_list2(env, ret_p, ret_g);    
 }
@@ -2461,9 +2459,9 @@ static ERL_NIF_TERM dh_check(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
     ERL_NIF_TERM ret, head, tail;
 
     if (!enif_get_list_cell(env, argv[0], &head, &tail)   
-	|| !get_bn_from_mpint(env, head, &dh_params->p)
+	|| !get_bn_from_bin(env, head, &dh_params->p)
 	|| !enif_get_list_cell(env, tail, &head, &tail)   
-	|| !get_bn_from_mpint(env, head, &dh_params->g)
+	|| !get_bn_from_bin(env, head, &dh_params->g)
 	|| !enif_is_empty_list(env,tail)) {
 
 	DH_free(dh_params);
@@ -2485,19 +2483,21 @@ static ERL_NIF_TERM dh_check(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
 }   
 
 static ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{/* (PrivKey, DHParams=[P,G]) */
+{/* (PrivKey, DHParams=[P,G], Mpint) */
     DH* dh_params = DH_new();
     int pub_len, prv_len;
     unsigned char *pub_ptr, *prv_ptr;
     ERL_NIF_TERM ret, ret_pub, ret_prv, head, tail;
+    int mpint; /* 0 or 4 */
 
-    if (!(get_bn_from_mpint(env, argv[0], &dh_params->priv_key)
+    if (!(get_bn_from_bin(env, argv[0], &dh_params->priv_key)
 	  || argv[0] == atom_undefined)
 	|| !enif_get_list_cell(env, argv[1], &head, &tail)
-	|| !get_bn_from_mpint(env, head, &dh_params->p)
+	|| !get_bn_from_bin(env, head, &dh_params->p)
 	|| !enif_get_list_cell(env, tail, &head, &tail)
-	|| !get_bn_from_mpint(env, head, &dh_params->g)
-	|| !enif_is_empty_list(env, tail)) {
+	|| !get_bn_from_bin(env, head, &dh_params->g)
+	|| !enif_is_empty_list(env, tail)
+	|| !enif_get_int(env, argv[2], &mpint) || (mpint & ~4)) {
 	DH_free(dh_params);
 	return enif_make_badarg(env);
     }
@@ -2505,14 +2505,16 @@ static ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_
     if (DH_generate_key(dh_params)) {
 	pub_len = BN_num_bytes(dh_params->pub_key);
 	prv_len = BN_num_bytes(dh_params->priv_key);    
-	pub_ptr = enif_make_new_binary(env, pub_len+4, &ret_pub);
-	prv_ptr = enif_make_new_binary(env, prv_len+4, &ret_prv);
-	put_int32(pub_ptr, pub_len);
-	put_int32(prv_ptr, prv_len);
-	BN_bn2bin(dh_params->pub_key, pub_ptr+4);
-	BN_bn2bin(dh_params->priv_key, prv_ptr+4);
-	ERL_VALGRIND_MAKE_MEM_DEFINED(pub_ptr+4, pub_len);    
-	ERL_VALGRIND_MAKE_MEM_DEFINED(prv_ptr+4, prv_len);
+	pub_ptr = enif_make_new_binary(env, pub_len+mpint, &ret_pub);
+	prv_ptr = enif_make_new_binary(env, prv_len+mpint, &ret_prv);
+	if (mpint) {
+	    put_int32(pub_ptr, pub_len); pub_ptr += 4;
+	    put_int32(prv_ptr, prv_len); prv_ptr += 4;
+	}
+	BN_bn2bin(dh_params->pub_key, pub_ptr);
+	BN_bn2bin(dh_params->priv_key, prv_ptr);
+	ERL_VALGRIND_MAKE_MEM_DEFINED(pub_ptr, pub_len);
+	ERL_VALGRIND_MAKE_MEM_DEFINED(prv_ptr, prv_len);
 	ret = enif_make_tuple2(env, ret_pub, ret_prv);
     }
     else {
@@ -2530,12 +2532,12 @@ static ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_T
     ErlNifBinary ret_bin;
     ERL_NIF_TERM ret, head, tail;
 
-    if (!get_bn_from_mpint(env, argv[0], &pubkey)
-	|| !get_bn_from_mpint(env, argv[1], &dh_params->priv_key)       
+    if (!get_bn_from_bin(env, argv[0], &pubkey)
+	|| !get_bn_from_bin(env, argv[1], &dh_params->priv_key)
 	|| !enif_get_list_cell(env, argv[2], &head, &tail)
-	|| !get_bn_from_mpint(env, head, &dh_params->p)
+	|| !get_bn_from_bin(env, head, &dh_params->p)
 	|| !enif_get_list_cell(env, tail, &head, &tail)
-	|| !get_bn_from_mpint(env, head, &dh_params->g)
+	|| !get_bn_from_bin(env, head, &dh_params->g)
 	|| !enif_is_empty_list(env, tail)) {
 
 	ret = enif_make_badarg(env);
@@ -2613,7 +2615,7 @@ static ERL_NIF_TERM srp_value_B_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     return ret;
 }
 
-static ERL_NIF_TERM srp_client_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM srp_user_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (a, u, B, Multiplier, Prime, Exponent, Generator) */
 /*
         <premaster secret> = (B - (k * g^x)) ^ (a + (u * x)) % N
@@ -2693,7 +2695,7 @@ static ERL_NIF_TERM srp_client_secret_nif(ErlNifEnv* env, int argc, const ERL_NI
     return ret;
 }
 
-static ERL_NIF_TERM srp_server_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM srp_host_secret_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Verifier, b, u, A, Prime) */
 /*
         <premaster secret> = (A * v^u) ^ b % N
diff --git a/lib/crypto/src/crypto.erl b/lib/crypto/src/crypto.erl
index 894253f84d..76e4ac620c 100644
--- a/lib/crypto/src/crypto.erl
+++ b/lib/crypto/src/crypto.erl
@@ -58,8 +58,6 @@
 -export([rand_bytes/1, rand_bytes/3, rand_uniform/2]).
 -export([strong_rand_bytes/1, strong_rand_mpint/3]).
 -export([mod_exp/3, mod_exp_prime/3, mpint/1, erlint/1]).
--export([srp_generate_key/4, srp_generate_key/3,
-	 srp_generate_key/5, srp_compute_key/6, srp_compute_key/7, srp_compute_key/8]).
 
 %% -export([idea_cbc_encrypt/3, idea_cbc_decrypt/3]).
 -export([aes_cbc_128_encrypt/3, aes_cbc_128_decrypt/3]).
@@ -67,8 +65,9 @@
 -export([aes_cbc_ivec/1]).
 -export([aes_ctr_encrypt/3, aes_ctr_decrypt/3]).
 -export([aes_ctr_stream_init/2, aes_ctr_stream_encrypt/2, aes_ctr_stream_decrypt/2]).
--export([ecdh_generate_key/1, ecdh_compute_key/3]).
 -export([sign/4, verify/5]).
+-export([generate_key/2, generate_key/3, compute_key/4]).
+
 
 -export([dh_generate_parameters/2, dh_check/1]). %% Testing see below
 
@@ -114,9 +113,7 @@
 		    hash, hash_init, hash_update, hash_final,
 		    hmac, hmac_init, hmac_update, hmac_final, hmac_final_n, info,
 		    rc2_cbc_encrypt, rc2_cbc_decrypt,
-		    srp_generate_key, srp_compute_key,
-		    ecdh_generate_key, ecdh_compute_key,
-		    sign, verify,
+		    sign, verify, generate_key, compute_key,
 		    info_lib, algorithms]).
 
 -type mpint() :: binary().
@@ -1122,118 +1119,98 @@ dh_check([_Prime,_Gen]) -> ?nif_stub.
 			     {binary(),binary()}.
 
 dh_generate_key(DHParameters) ->
-    dh_generate_key(undefined, DHParameters).
+    dh_generate_key_nif(undefined, map_mpint_to_bin(DHParameters), 4).
 dh_generate_key(PrivateKey, DHParameters) ->
-    case dh_generate_key_nif(PrivateKey, DHParameters) of
-	error -> erlang:error(generation_failed, [PrivateKey,DHParameters]);
-	Res -> Res
-    end.
+    dh_generate_key_nif(mpint_to_bin(PrivateKey), map_mpint_to_bin(DHParameters), 4).
 
-dh_generate_key_nif(_PrivateKey, _DHParameters) -> ?nif_stub.
+dh_generate_key_nif(_PrivateKey, _DHParameters, _Mpint) -> ?nif_stub.
 
 %% DHParameters = [P (Prime)= mpint(), G(Generator) = mpint()]
-%% MyPrivKey, OthersPublicKey = mpint() 
+%% MyPrivKey, OthersPublicKey = mpint()
 -spec dh_compute_key(binary(), binary(), [binary()]) -> binary().
 
 dh_compute_key(OthersPublicKey, MyPrivateKey, DHParameters) ->
-    case dh_compute_key_nif(OthersPublicKey,MyPrivateKey,DHParameters) of
-	error -> erlang:error(computation_failed, [OthersPublicKey,MyPrivateKey,DHParameters]);
-	Ret -> Ret
-    end.
+    compute_key(dh, mpint_to_bin(OthersPublicKey), mpint_to_bin(MyPrivateKey),
+		map_mpint_to_bin(DHParameters)).
+
 
 dh_compute_key_nif(_OthersPublicKey, _MyPrivateKey, _DHParameters) -> ?nif_stub.
 
+generate_key(Type, Params) ->
+    generate_key(Type, Params, undefined).
+
+generate_key(dh, DHParameters, PrivateKey) ->
+    dh_generate_key_nif(PrivateKey, DHParameters, 0);
+
+generate_key(srp, {host, [Verifier, Generator, Prime, Version]}, PrivArg)
+  when is_binary(Verifier), is_binary(Generator), is_binary(Prime), is_atom(Version) ->
+    Private = case PrivArg of
+		  undefined -> random_bytes(32);
+		  _ -> PrivArg
+	      end,
+    host_srp_gen_key(Private, Verifier, Generator, Prime, Version);
+
+generate_key(srp, {user, [Generator, Prime, Version]}, PrivateArg)
+  when is_binary(Generator), is_binary(Prime), is_atom(Version) ->
+    Private = case PrivateArg of
+		  undefined -> random_bytes(32);
+		  _ -> PrivateArg
+	      end,
+    user_srp_gen_key(Private, Generator, Prime);
+
+generate_key(ecdh, Curve, undefined) ->
+    ec_key_to_term(ec_key_generate(Curve)).
+
+
+ec_key_generate(_Key) -> ?nif_stub.
+
+
+compute_key(dh, OthersPublicKey, MyPrivateKey, DHParameters) ->
+    case dh_compute_key_nif(OthersPublicKey,MyPrivateKey,DHParameters) of
+	error -> erlang:error(computation_failed,
+			      [OthersPublicKey,MyPrivateKey,DHParameters]);
+	Ret -> Ret
+    end;
 
-%%% SRP
--spec srp_generate_key(binary(), binary(), atom() | binary(), atom() | binary() ) -> {Public::binary(), Private::binary()}.
-srp_generate_key(Verifier, Generator, Prime, Version) when is_binary(Verifier),
-							   is_binary(Generator),
-							   is_binary(Prime), 
-							   is_atom(Version) ->
-    Private = random_bytes(32),
-    server_srp_gen_key(Private, Verifier, Generator, Prime, Version);
-
-srp_generate_key(Generator, Prime, Version, Private) when is_binary(Generator),
-							  is_binary(Prime), 
-							  is_atom(Version),
-							  is_binary(Private) ->
-    client_srp_gen_key(Private, Generator, Prime).
-
--spec srp_generate_key(binary(), binary(), binary(), atom(), binary()) -> {Public::binary(), Private::binary()}.
-srp_generate_key(Verifier, Generator, Prime, Version, Private) when is_binary(Verifier),
-								    is_binary(Generator),
-								    is_binary(Prime), 
-								    is_atom(Version),
-								    is_binary(Private)
-								    -> 
-    server_srp_gen_key(Private, Verifier, Generator, Prime, Version).
-
--spec srp_generate_key(binary(), binary(), atom()) -> {Public::binary(), Private::binary()}.
-srp_generate_key(Generator, Prime, Version) when is_binary(Generator),
-						 is_binary(Prime), 
-						 is_atom(Version) ->
-    Private = random_bytes(32),
-    client_srp_gen_key(Private, Generator, Prime).
-
--spec srp_compute_key(binary(), binary(), binary(), binary(), binary(), atom()| binary(), atom() | binary() ) -> binary().
-srp_compute_key(DerivedKey, Prime, Generator, ClientPublic, ClientPrivate, ServerPublic, Version) when 
-      is_binary(Prime), 
+compute_key(srp, HostPublic, {UserPublic, UserPrivate},
+	    {user, [DerivedKey, Prime, Generator, Version | ScramblerArg]}) when
+      is_binary(Prime),
       is_binary(Generator),
-      is_binary(ClientPublic),
-      is_binary(ClientPrivate),
-      is_binary(ServerPublic),
+      is_binary(UserPublic),
+      is_binary(UserPrivate),
+      is_binary(HostPublic),
       is_atom(Version) ->
     Multiplier = srp_multiplier(Version, Generator, Prime),
-    Scrambler = srp_scrambler(Version, ClientPublic, ServerPublic, Prime),
-    srp_client_secret_nif(ClientPrivate, Scrambler, ServerPublic, Multiplier,
-		      Generator, DerivedKey, Prime);
-
-srp_compute_key(Verifier, Prime, ClientPublic, ServerPublic, ServerPrivate, Version, Scrambler) when 
-      is_binary(Verifier),
-      is_binary(Prime), 
-      is_binary(ClientPublic),
-      is_binary(ServerPublic),
-      is_binary(ServerPrivate),
-      is_atom(Version),
-      is_binary(Scrambler) ->
-   srp_server_secret_nif(Verifier, ServerPrivate, Scrambler, ClientPublic, Prime).
-
--spec srp_compute_key(binary(), binary(), binary(), binary(), binary(), binary(), atom(), binary()) -> binary().
-srp_compute_key(DerivedKey, Prime, Generator, ClientPublic, ClientPrivate, 
-		ServerPublic, Version, Scrambler) when is_binary(DerivedKey),
-						       is_binary(Prime), 
-						       is_binary(Generator),
-						       is_binary(ClientPublic),
-						       is_binary(ClientPrivate),
-						       is_binary(ServerPublic),
-						       is_atom(Version),
-						       is_binary(Scrambler) ->
-    Multiplier = srp_multiplier(Version, Generator, Prime),
-    srp_client_secret_nif(ClientPrivate, Scrambler, ServerPublic, Multiplier,
-			  Generator, DerivedKey, Prime).
-
--spec srp_compute_key(binary(), binary(), binary(), binary(), binary(), atom()) -> binary().
-srp_compute_key(Verifier, Prime, ClientPublic, ServerPublic, ServerPrivate, Version) when 
+    Scrambler = case ScramblerArg of
+		    [] -> srp_scrambler(Version, UserPublic, HostPublic, Prime);
+		    [S] -> S
+		end,
+    srp_user_secret_nif(UserPrivate, Scrambler, HostPublic, Multiplier,
+			  Generator, DerivedKey, Prime);
+
+compute_key(srp, UserPublic, {HostPublic, HostPrivate},
+	    {host,[Verifier, Prime, Version | ScramblerArg]}) when
       is_binary(Verifier),
-      is_binary(Prime), 
-      is_binary(ClientPublic),
-      is_binary(ServerPublic),
-      is_binary(ServerPrivate),
+      is_binary(Prime),
+      is_binary(UserPublic),
+      is_binary(HostPublic),
+      is_binary(HostPrivate),
       is_atom(Version) ->
-   Scrambler = srp_scrambler(Version, ClientPublic, ServerPublic, Prime),
-   srp_server_secret_nif(Verifier, ServerPrivate, Scrambler, ClientPublic, Prime).
+    Scrambler = case ScramblerArg of
+		    [] -> srp_scrambler(Version, UserPublic, HostPublic, Prime);
+		    [S] -> S
+		end,
+    srp_host_secret_nif(Verifier, HostPrivate, Scrambler, UserPublic, Prime);
 
-%%
-%% EC
-%%
-
--spec ecdh_generate_key(ec_curve()) -> ec_key() | error.
-ecdh_generate_key(Curve) ->
-    ec_key_to_term(ec_key_generate(Curve)).
+compute_key(ecdh, Others, My, Curve) ->
+    ecdh_compute_key_nif(Others, term_to_ec_key({Curve,My,undefined})).
 
+ecdh_compute_key_nif(_Others, _My) -> ?nif_stub.
 
-ec_key_generate(_Key) -> ?nif_stub.
 
+%%
+%% EC
+%%
 
 -spec ec_key_to_term(ec_key_res()) -> ec_key().
 ec_key_to_term(Key) ->
@@ -1267,17 +1244,11 @@ term_to_ec_key({Curve, PrivKey, PubKey}) ->
 term_to_ec_key_nif(_Curve, _PrivKey, _PubKey) -> ?nif_stub.
 
 
--spec ecdh_compute_key(ec_point(), binary(), ec_curve()) -> binary().
-ecdh_compute_key(Others, My, Curve) ->
-    ecdh_compute_key_nif(Others, term_to_ec_key({Curve,My,undefined})).
-
-ecdh_compute_key_nif(_Others, _My) -> ?nif_stub.
-
 
 %%  LOCAL FUNCTIONS
 %%
 
-client_srp_gen_key(Private, Generator, Prime) ->
+user_srp_gen_key(Private, Generator, Prime) ->
     case mod_exp_prime(Generator, Private, Prime) of
 	error ->
 	    error;
@@ -1285,7 +1256,7 @@ client_srp_gen_key(Private, Generator, Prime) ->
 	    {Public, Private}
     end.
 
-server_srp_gen_key(Private, Verifier, Generator, Prime, Version) ->
+host_srp_gen_key(Private, Verifier, Generator, Prime, Version) ->
  Multiplier = srp_multiplier(Version, Generator, Prime),
    case srp_value_B_nif(Multiplier, Verifier, Generator, Private, Prime) of
    error ->
@@ -1305,17 +1276,17 @@ srp_multiplier('6', _, _) ->
 srp_multiplier('3', _, _) ->
     <<1/integer>>.
 
-srp_scrambler(Version, ClientPublic, ServerPublic, Prime) when Version == '6'; Version == '6a'->
+srp_scrambler(Version, UserPublic, HostPublic, Prime) when Version == '6'; Version == '6a'->
     %% SHA1(PAD(A) | PAD(B)) from http://srp.stanford.edu/design.html
     PadLength = erlang:byte_size(Prime),
     C0 = sha_init(),
-    C1 = sha_update(C0, srp_pad_to(PadLength, ClientPublic)),
-    C2 = sha_update(C1, srp_pad_to(PadLength, ServerPublic)),
+    C1 = sha_update(C0, srp_pad_to(PadLength, UserPublic)),
+    C2 = sha_update(C1, srp_pad_to(PadLength, HostPublic)),
     sha_final(C2);
-srp_scrambler('3', _, ServerPublic, _Prime) ->
+srp_scrambler('3', _, HostPublic, _Prime) ->
     %% The parameter u is a 32-bit unsigned integer which takes its value
     %% from the first 32 bits of the SHA1 hash of B, MSB first.
-    <<U:32/bits, _/binary>> = sha(ServerPublic),
+    <<U:32/bits, _/binary>> = sha(HostPublic),
     U.
 
 srp_pad_length(Width, Length) ->
@@ -1327,9 +1298,9 @@ srp_pad_to(Width, Binary) ->
         N -> << 0:(N*8), Binary/binary>>
     end.
 
-srp_server_secret_nif(_Verifier, _B, _U, _A, _Prime) -> ?nif_stub.
+srp_host_secret_nif(_Verifier, _B, _U, _A, _Prime) -> ?nif_stub.
 
-srp_client_secret_nif(_A, _U, _B, _Multiplier, _Generator, _Exponent, _Prime) -> ?nif_stub.
+srp_user_secret_nif(_A, _U, _B, _Multiplier, _Generator, _Exponent, _Prime) -> ?nif_stub.
 
 srp_value_B_nif(_Multiplier, _Verifier, _Generator, _Exponent, _Prime) -> ?nif_stub.
 
diff --git a/lib/crypto/test/crypto_SUITE.erl b/lib/crypto/test/crypto_SUITE.erl
index 384d15c68c..473609778c 100644
--- a/lib/crypto/test/crypto_SUITE.erl
+++ b/lib/crypto/test/crypto_SUITE.erl
@@ -1864,13 +1864,16 @@ dh(Config) when is_list(Config) ->
 	{param, DHPs} ->
 	    timer:sleep(100), 
 	    io:format("DHP ~p~n", [DHPs]),
-	    ?line {Pub1,Priv1} = crypto:dh_generate_key(DHPs),
+	    DHPs_mpint = lists:map(fun(E) -> sized_binary(E) end, DHPs),
+	    ?line {Pub1,Priv1} = crypto:generate_key(dh, DHPs),
 	    io:format("Key1:~n~p~n~p~n~n", [Pub1,Priv1]),
-	    ?line {Pub2,Priv2} = crypto:dh_generate_key(DHPs),
+	    ?line {Pub2,Priv2} = crypto:dh_generate_key(DHPs_mpint),
 	    io:format("Key2:~n~p~n~p~n~n", [Pub2,Priv2]),
-	    ?line A = crypto:dh_compute_key(Pub1, Priv2, DHPs),
+	    ?line A = crypto:compute_key(dh, Pub1, unsized_binary(Priv2), DHPs),
+	    ?line A = crypto:dh_compute_key(sized_binary(Pub1), Priv2, DHPs_mpint),
 	    timer:sleep(100),  %% Get another thread see if that triggers problem
-	    ?line B = crypto:dh_compute_key(Pub2, Priv1, DHPs),
+	    ?line B = crypto:compute_key(dh, unsized_binary(Pub2), Priv1, DHPs),
+	    ?line B = crypto:dh_compute_key(Pub2, sized_binary(Priv1), DHPs_mpint),
 	    io:format("A ~p~n",[A]),
 	    io:format("B ~p~n",[B]),
 	    ?line A = B
@@ -1879,6 +1882,7 @@ dh(Config) when is_list(Config) ->
 	    exit(Pid, kill)
     end.
 
+
 ec(doc) ->
     ["Test ec (Ecliptic Curve) functions."];
 ec(suite) -> [];
@@ -1887,7 +1891,7 @@ ec(Config) when is_list(Config) ->
 
 ec_do() ->
     %% test for a name curve
-    {D2_priv, D2_pub} = crypto:ecdh_generate_key(sect113r2),
+    {D2_priv, D2_pub} = crypto:generate_key(ecdh, sect113r2),
     D2 = {sect113r2, D2_priv, D2_pub},
 
     %%TODO: find a published test case for a EC key
@@ -1985,12 +1989,12 @@ srp3(Config) when is_list(Config) ->
     Verifier = crypto:mod_exp_prime(Generator, UserPassHash, Prime), 
     ClientPublic = crypto:mod_exp_prime(Generator, ClientPrivate, Prime),
 
-    {ClientPublic, ClientPrivate} = crypto:srp_generate_key(Generator, Prime, Version, ClientPrivate),
-    {ServerPublic, ServerPrivate} = crypto:srp_generate_key(Verifier, Generator, Prime, Version, ServerPrivate),
-    SessionKey = crypto:srp_compute_key(UserPassHash, Prime, Generator, ClientPublic,
-					ClientPrivate, ServerPublic, Version, Scrambler),
-    SessionKey = crypto:srp_compute_key(Verifier, Prime, ClientPublic,
-					ServerPublic, ServerPrivate, Version, Scrambler).
+    {ClientPublic, ClientPrivate} = crypto:generate_key(srp, {user, [Generator, Prime, Version]}, ClientPrivate),
+    {ServerPublic, ServerPrivate} = crypto:generate_key(srp, {host, [Verifier, Generator, Prime, Version]}, ServerPrivate),
+    SessionKey = crypto:compute_key(srp, ServerPublic, {ClientPublic, ClientPrivate},
+				    {user, [UserPassHash, Prime, Generator, Version, Scrambler]}),
+    SessionKey = crypto:compute_key(srp, ClientPublic, {ServerPublic, ServerPrivate},
+				    {host, [Verifier, Prime, Version, Scrambler]}).
 
 srp6(doc) ->
     ["SRP-6 test vectors generated by http://srp.stanford.edu/demo/demo.html"];
@@ -2036,12 +2040,12 @@ srp6(Config) when is_list(Config) ->
     Verifier = crypto:mod_exp_prime(Generator, UserPassHash, Prime), 
     ClientPublic = crypto:mod_exp_prime(Generator, ClientPrivate, Prime),
 
-    {ClientPublic, ClientPrivate} = crypto:srp_generate_key(Generator, Prime, Version, ClientPrivate),
-    {ServerPublic, ServerPrivate} = crypto:srp_generate_key(Verifier, Generator, Prime, Version, ServerPrivate),
-    SessionKey = crypto:srp_compute_key(UserPassHash, Prime, Generator, ClientPublic,
-					ClientPrivate, ServerPublic, Version, Scrambler),
-    SessionKey = crypto:srp_compute_key(Verifier, Prime, ClientPublic,
-					ServerPublic, ServerPrivate, Version, Scrambler).
+    {ClientPublic, ClientPrivate} = crypto:generate_key(srp, {user, [Generator, Prime, Version]}, ClientPrivate),
+    {ServerPublic, ServerPrivate} = crypto:generate_key(srp, {host, [Verifier, Generator, Prime, Version]}, ServerPrivate),
+    SessionKey = crypto:compute_key(srp, ServerPublic, {ClientPublic, ClientPrivate},
+				    {user, [UserPassHash, Prime, Generator, Version, Scrambler]}),
+    SessionKey = crypto:compute_key(srp, ClientPublic, {ServerPublic, ServerPrivate},
+				    {host, [Verifier, Prime, Version, Scrambler]}).
 
 srp6a(doc) ->
     ["SRP-6a test vectors from RFC5054."];
@@ -2086,13 +2090,13 @@ srp6a(Config) when is_list(Config) ->
     UserPassHash = crypto:sha([Salt, crypto:sha([Username, <<$:>>, Password])]),
     Verifier = crypto:mod_exp_prime(Generator, UserPassHash, Prime), 
 
-    {ClientPublic, ClientPrivate} = crypto:srp_generate_key(Generator, Prime, Version, ClientPrivate),
-    {ServerPublic, ServerPrivate} = crypto:srp_generate_key(Verifier, Generator, Prime, Version, ServerPrivate),
+    {ClientPublic, ClientPrivate} = crypto:generate_key(srp, {user, [Generator, Prime, Version]}, ClientPrivate),
+    {ServerPublic, ServerPrivate} = crypto:generate_key(srp, {host, [Verifier, Generator, Prime, Version]}, ServerPrivate),
 
-    SessionKey = crypto:srp_compute_key(UserPassHash, Prime, Generator, ClientPublic,
-					ClientPrivate, ServerPublic, Version, Scrambler),
-    SessionKey = crypto:srp_compute_key(Verifier, Prime, ClientPublic,
-					ServerPublic, ServerPrivate, Version, Scrambler).
+    SessionKey = crypto:compute_key(srp, ServerPublic, {ClientPublic, ClientPrivate},
+				    {user, [UserPassHash, Prime, Generator, Version, Scrambler]}),
+    SessionKey = crypto:compute_key(srp, ClientPublic, {ServerPublic, ServerPrivate},
+				    {host, [Verifier, Prime, Version, Scrambler]}).
     
 %%
 %%
@@ -2287,6 +2291,9 @@ sized_binary(Binary) when is_binary(Binary) ->
 sized_binary(List) ->
     sized_binary(list_to_binary(List)).
 
+unsized_binary(<<Sz:32/integer, Binary:Sz/binary>>) ->
+    Binary.
+
 xor_bytes(Bin1, Bin2) when is_binary(Bin1), is_binary(Bin2) ->
     L1 = binary_to_list(Bin1),
     L2 = binary_to_list(Bin2),