Add crypto_sign_ed25519_{sk,pk}_to_curve25519

.gitignore

@@ -8,3 +8,4 @@ erl_crash.dump
 *.sw*
 *.o
 /priv
+/.elixir_ls

lib/salty/nif.ex

@@ -206,6 +206,8 @@ defmodule Salty.Nif do
   def sign_ed25519_SECRETKEYBYTES, do: :erlang.exit(:salty_nif_not_loaded)
   def sign_ed25519_seed_keypair(_), do: :erlang.exit(:salty_nif_not_loaded)
   def sign_ed25519_keypair(), do: :erlang.exit(:salty_nif_not_loaded)
+  def crypto_sign_ed25519_pk_to_curve25519(_), do: :erlang.exit(:salty_nif_not_loaded)
+  def crypto_sign_ed25519_sk_to_curve25519(_), do: :erlang.exit(:salty_nif_not_loaded)
   def sign_ed25519(_,_), do: :erlang.exit(:salty_nif_not_loaded)
   def sign_ed25519_detached(_,_), do: :erlang.exit(:salty_nif_not_loaded)
   def sign_ed25519_verify_detached(_,_,_), do: :erlang.exit(:salty_nif_not_loaded)

lib/salty/sign.ex

@@ -53,6 +53,10 @@ defmodule Salty.Sign do
 
   @callback keypair() :: {:ok, binary(), binary()} | {:error, atom()}
 
+  @callback crypto_sign_ed25519_pk_to_curve25519(binary()) :: {:ok, binary()} | {:error, atom()}
+
+  @callback crypto_sign_ed25519_sk_to_curve25519(binary()) :: {:ok, binary()} | {:error, atom()}
+
   @callback sign(binary(), binary()) :: {:ok, binary()} | {:error, atom()}
 
   @callback sign_detached(binary(), binary()) :: {:ok, binary()} | {:error, atom()}

lib/salty/sign_ed25519.ex

@@ -25,6 +25,14 @@ defmodule Salty.Sign.Ed25519 do
     C.sign_ed25519_keypair()
   end
 
+  def crypto_sign_ed25519_pk_to_curve25519(data) do
+    C.crypto_sign_ed25519_pk_to_curve25519(data)
+  end
+
+  def crypto_sign_ed25519_sk_to_curve25519(data) do
+    C.crypto_sign_ed25519_sk_to_curve25519(data)
+  end
+
   def sign(data, sk) do
     C.sign_ed25519(data, sk)
   end

src/salty_nif.c

@@ -42,7 +42,7 @@
 #define SALTY_BADARG enif_make_badarg(env)
 #define SALTY_BADALLOC SALTY_BADARG /* TODO make this return an actual failed-to-alloc error */
 
-#define SALTY_ERROR tuple_error_unknown
+#define SALTY_ERROR enif_make_tuple2(env, atom_error, atom_error_unknown)
 #define SALTY_ERROR_PAIR(err) enif_make_tuple2(env, atom_error, err)
 #define SALTY_OK atom_ok
 #define SALTY_OK_PAIR(a) enif_make_tuple2(env, atom_ok, a)
@@ -415,7 +415,6 @@ ERL_NIF_TERM atom_error_no_match;
 ERL_NIF_TERM atom_error_not_available;
 ERL_NIF_TERM atom_error_forged;
 ERL_NIF_TERM atom_error_unknown;
-ERL_NIF_TERM tuple_error_unknown;
 
 /* erl_nif code */
 static int
@@ -429,7 +428,6 @@ salty_onload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
     atom_error_not_available = enif_make_atom(env, "not_available");
     atom_error_forged        = enif_make_atom(env, "forged");
     atom_error_unknown       = enif_make_atom(env, "salty_error_unknown");
-    tuple_error_unknown      = enif_make_tuple2(env, atom_error, atom_error_unknown);
 
     return 0;
 }
@@ -1662,6 +1660,23 @@ SALTY_FUNC(sign_ed25519_keypair, 0) DO
                 pk.data, sk.data), pk, sk);
 END_OK_WITH2(pk, sk);
 
+SALTY_FUNC(crypto_sign_ed25519_pk_to_curve25519, 1) DO
+    SALTY_INPUT_BIN(0, pk_ed25519, crypto_sign_ed25519_PUBLICKEYBYTES);
+    SALTY_OUTPUT_BIN(pk_curve25519, crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
+
+    SALTY_CALL2(crypto_sign_ed25519_pk_to_curve25519(
+                pk_curve25519.data, pk_ed25519.data), pk_ed25519, pk_curve25519);
+END_OK_WITH(pk_curve25519);
+
+SALTY_FUNC(crypto_sign_ed25519_sk_to_curve25519, 1) DO
+    SALTY_INPUT_BIN(0, sk_ed25519, crypto_sign_ed25519_PUBLICKEYBYTES);
+\
+    SALTY_OUTPUT_BIN(sk_curve25519, crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES);
+
+    SALTY_CALL2(crypto_sign_ed25519_sk_to_curve25519(
+                sk_curve25519.data, sk_ed25519.data), sk_ed25519, sk_curve25519);
+END_OK_WITH(sk_curve25519);
+
 SALTY_FUNC(sign_ed25519, 2) DO
     SALTY_INPUT_BIN(0, data, SALTY_BIN_NO_SIZE);
     SALTY_INPUT_BIN(1, sk, crypto_sign_ed25519_SECRETKEYBYTES);
@@ -2194,6 +2209,8 @@ salty_exports[] = {
     SALTY_EXPORT_CONS(sign_ed25519_SECRETKEYBYTES, 0),
     SALTY_EXPORT_FUNC(sign_ed25519_seed_keypair, 1),
     SALTY_EXPORT_FUNC(sign_ed25519_keypair, 0),
+    SALTY_EXPORT_FUNC(crypto_sign_ed25519_pk_to_curve25519, 1),
+    SALTY_EXPORT_FUNC(crypto_sign_ed25519_sk_to_curve25519, 1),
     SALTY_EXPORT_FUNC(sign_ed25519, 2),
     SALTY_EXPORT_FUNC(sign_ed25519_detached, 2),
     SALTY_EXPORT_FUNC(sign_ed25519_verify_detached, 3),

test/salty_test.exs

@@ -130,4 +130,9 @@ defmodule SaltyTest do
     assert Salty.Sign.Ed25519.sk_to_pk(sk) == pk
   end
 
+  test "crypto_sign_ed25519_{pk,sk}_to_curve25519 works" do
+    {:ok, pk, sk} = Salty.Sign.Ed25519.keypair()
+    {:ok, _} = Salty.Sign.Ed25519.crypto_sign_ed25519_pk_to_curve25519(pk)
+    {:ok, _} = Salty.Sign.Ed25519.crypto_sign_ed25519_sk_to_curve25519(sk)
+  end
 end