QPQ-AG/enacl
10
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename enif_crypto_ to enacl_crypto_

Browse Source 
This is a better name which spits stuff appropriately.

We don't pollute the enif_ namespace.
This commit is contained in:
Jesper Louis Andersen 2020-01-19 17:56:31 +01:00
parent f5b8a8eb3b
commit 0427fa42ee
5 changed files with 549 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

558
c_src/enacl_nif.c
View File

@ -20,7 +20,7 @@
#endif #endif
/* Initialization */ /* Initialization */
static int enif_crypto_load(ErlNifEnv *env, void **priv_data, static int enacl_crypto_load(ErlNifEnv *env, void **priv_data,
ERL_NIF_TERM load_info) { ERL_NIF_TERM load_info) {
// Create a new resource type for crypto_generichash_state // Create a new resource type for crypto_generichash_state
if (!enacl_init_generic_hash_ctx(env)) { if (!enacl_init_generic_hash_ctx(env)) {
@ -34,7 +34,7 @@ static int enif_crypto_load(ErlNifEnv *env, void **priv_data,
return sodium_init(); return sodium_init();
} }
static ERL_NIF_TERM enif_crypto_verify_16(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_verify_16(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary x, y; ErlNifBinary x, y;
@ -54,7 +54,7 @@ static ERL_NIF_TERM enif_crypto_verify_16(ErlNifEnv *env, int argc,
} }
} }
static ERL_NIF_TERM enif_crypto_verify_32(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_verify_32(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary x, y; ErlNifBinary x, y;
@ -92,7 +92,7 @@ static ERL_NIF_TERM enif_sodium_memzero(ErlNifEnv *env, int argc,
/* Curve 25519 */ /* Curve 25519 */
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc, enacl_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ERL_NIF_TERM result; ERL_NIF_TERM result;
ErlNifBinary secret, basepoint, output; ErlNifBinary secret, basepoint, output;
@ -130,7 +130,7 @@ enif_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc, enacl_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ERL_NIF_TERM result; ERL_NIF_TERM result;
ErlNifBinary secret, output; ErlNifBinary secret, output;
@ -157,139 +157,38 @@ enif_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
return result; return result;
} }
/* Ed 25519 */
static ERL_NIF_TERM
enif_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if (argc != 0) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_ed25519_keypair(pk.data, sk.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
static ERL_NIF_TERM
enif_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &sk)) ||
(sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
return nacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
}
return enif_make_binary(env, &pk);
}
static ERL_NIF_TERM
enif_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary curve25519_pk, ed25519_pk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_pk)) ||
(ed25519_pk.size != crypto_sign_ed25519_PUBLICKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
ed25519_pk.data) != 0) {
return nacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_pk);
}
static ERL_NIF_TERM
enif_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary curve25519_sk, ed25519_sk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_sk)) ||
(ed25519_sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
ed25519_sk.data) != 0) {
return nacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_sk);
}
static ERL_NIF_TERM
enif_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_ed25519_PUBLICKEYBYTES);
}
static ERL_NIF_TERM
enif_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_ed25519_SECRETKEYBYTES);
}
/* Public-key cryptography */ /* Public-key cryptography */
static ERL_NIF_TERM enif_crypto_box_NONCEBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_NONCEBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_NONCEBYTES); return enif_make_int64(env, crypto_box_NONCEBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_ZEROBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_ZEROBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_ZEROBYTES); return enif_make_int64(env, crypto_box_ZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_BOXZEROBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_BOXZEROBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_BOXZEROBYTES); return enif_make_int64(env, crypto_box_BOXZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_PUBLICKEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_PUBLICKEYBYTES); return enif_make_int64(env, crypto_box_PUBLICKEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_SECRETKEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_SECRETKEYBYTES); return enif_make_int64(env, crypto_box_SECRETKEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_BEFORENMBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_BEFORENMBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_BEFORENMBYTES); return enif_make_int64(env, crypto_box_BEFORENMBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk; ErlNifBinary pk, sk;
@ -311,7 +210,7 @@ static ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc,
enif_make_binary(env, &sk)); enif_make_binary(env, &sk));
} }
static ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary padded_msg, nonce, pk, sk, result; ErlNifBinary padded_msg, nonce, pk, sk, result;
@ -344,7 +243,7 @@ static ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc,
padded_msg.size - crypto_box_BOXZEROBYTES); padded_msg.size - crypto_box_BOXZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary padded_ciphertext, nonce, pk, sk, result; ErlNifBinary padded_ciphertext, nonce, pk, sk, result;
@ -381,7 +280,7 @@ static ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc,
/* Precomputed crypto boxes */ /* Precomputed crypto boxes */
static ERL_NIF_TERM enif_crypto_box_beforenm(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_beforenm(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary k, pk, sk; ErlNifBinary k, pk, sk;
@ -404,7 +303,7 @@ static ERL_NIF_TERM enif_crypto_box_beforenm(ErlNifEnv *env, int argc,
return enif_make_binary(env, &k); return enif_make_binary(env, &k);
} }
static ERL_NIF_TERM enif_crypto_box_afternm(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_afternm(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary result, m, nonce, k; ErlNifBinary result, m, nonce, k;
@ -428,7 +327,7 @@ static ERL_NIF_TERM enif_crypto_box_afternm(ErlNifEnv *env, int argc,
m.size - crypto_box_BOXZEROBYTES); m.size - crypto_box_BOXZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_open_afternm(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_open_afternm(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary result, m, nonce, k; ErlNifBinary result, m, nonce, k;
@ -456,189 +355,14 @@ static ERL_NIF_TERM enif_crypto_box_open_afternm(ErlNifEnv *env, int argc,
m.size - crypto_box_ZEROBYTES); m.size - crypto_box_ZEROBYTES);
} }
/* Signing */
static ERL_NIF_TERM enif_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_PUBLICKEYBYTES);
}
static ERL_NIF_TERM enif_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_SECRETKEYBYTES);
}
static ERL_NIF_TERM enif_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_SEEDBYTES);
}
static ERL_NIF_TERM enif_crypto_sign_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if (argc != 0) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_keypair(pk.data, sk.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
static ERL_NIF_TERM enif_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk, seed;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &seed))) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
/*
int crypto_sign(unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk);
*/
static ERL_NIF_TERM enif_crypto_sign(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sk, sm;
unsigned long long smlen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
(!enif_inspect_binary(env, argv[1], &sk))) {
return enif_make_badarg(env);
}
if (sk.size != crypto_sign_SECRETKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
return enif_make_sub_binary(env, enif_make_binary(env, &sm), 0, smlen);
}
/*
int crypto_sign_open(unsigned char *m, unsigned long long *mlen,
const unsigned char *sm, unsigned long long smlen,
const unsigned char *pk);
*/
static ERL_NIF_TERM enif_crypto_sign_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sm, pk;
unsigned long long mlen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &sm)) ||
(!enif_inspect_binary(env, argv[1], &pk))) {
return enif_make_badarg(env);
}
if (pk.size != crypto_sign_PUBLICKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(sm.size, &m)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (0 == crypto_sign_open(m.data, &mlen, sm.data, sm.size, pk.data)) {
return enif_make_sub_binary(env, enif_make_binary(env, &m), 0, mlen);
} else {
enif_release_binary(&m);
return nacl_error_tuple(env, "failed_verification");
}
}
/*
int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk);
*/
static ERL_NIF_TERM enif_crypto_sign_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sk, sig;
unsigned long long siglen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
(!enif_inspect_binary(env, argv[1], &sk))) {
return enif_make_badarg(env);
}
if (sk.size != crypto_sign_SECRETKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);
return enif_make_binary(env, &sig);
}
/*
int crypto_sign_verify_detached(const unsigned char *sig,
const unsigned char *m,
unsigned long long mlen,
const unsigned char *pk);
*/
static ERL_NIF_TERM
enif_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sig, pk;
if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &sig)) ||
(!enif_inspect_iolist_as_binary(env, argv[1], &m)) ||
(!enif_inspect_binary(env, argv[2], &pk))) {
return enif_make_badarg(env);
}
if (pk.size != crypto_sign_PUBLICKEYBYTES) {
return enif_make_badarg(env);
}
if (0 == crypto_sign_verify_detached(sig.data, m.data, m.size, pk.data)) {
return enif_make_atom(env, "true");
} else {
return enif_make_atom(env, "false");
}
}
/* Sealed box functions */ /* Sealed box functions */
static ERL_NIF_TERM enif_crypto_box_SEALBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_SEALBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_box_SEALBYTES); return enif_make_int64(env, crypto_box_SEALBYTES);
} }
static ERL_NIF_TERM enif_crypto_box_seal(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_seal(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary key, msg, ciphertext; ErlNifBinary key, msg, ciphertext;
@ -656,7 +380,7 @@ static ERL_NIF_TERM enif_crypto_box_seal(ErlNifEnv *env, int argc,
return enif_make_binary(env, &ciphertext); return enif_make_binary(env, &ciphertext);
} }
static ERL_NIF_TERM enif_crypto_box_seal_open(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_box_seal_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk, ciphertext, msg; ErlNifBinary pk, sk, ciphertext, msg;
@ -687,81 +411,82 @@ static ERL_NIF_TERM enif_crypto_box_seal_open(ErlNifEnv *env, int argc,
/* Secret key cryptography */ /* Secret key cryptography */
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_secretbox_NONCEBYTES(ErlNifEnv *env, int argc, enacl_crypto_secretbox_NONCEBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_secretbox_NONCEBYTES); return enif_make_int64(env, crypto_secretbox_NONCEBYTES);
} }
static ERL_NIF_TERM enif_crypto_secretbox_KEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_secretbox_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_secretbox_KEYBYTES); return enif_make_int64(env, crypto_secretbox_KEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_secretbox_ZEROBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM
enacl_crypto_secretbox_ZEROBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_secretbox_ZEROBYTES); return enif_make_int64(env, crypto_secretbox_ZEROBYTES);
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_secretbox_BOXZEROBYTES(ErlNifEnv *env, int argc, enacl_crypto_secretbox_BOXZEROBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_secretbox_BOXZEROBYTES); return enif_make_int64(env, crypto_secretbox_BOXZEROBYTES);
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_stream_chacha20_KEYBYTES(ErlNifEnv *env, int argc, enacl_crypto_stream_chacha20_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_stream_chacha20_KEYBYTES); return enif_make_int64(env, crypto_stream_chacha20_KEYBYTES);
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_stream_chacha20_NONCEBYTES(ErlNifEnv *env, int argc, enacl_crypto_stream_chacha20_NONCEBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_stream_chacha20_NONCEBYTES); return enif_make_int64(env, crypto_stream_chacha20_NONCEBYTES);
} }
static ERL_NIF_TERM enif_crypto_stream_KEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_stream_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_stream_KEYBYTES); return enif_make_int64(env, crypto_stream_KEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_stream_NONCEBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_stream_NONCEBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_stream_NONCEBYTES); return enif_make_int64(env, crypto_stream_NONCEBYTES);
} }
static ERL_NIF_TERM enif_crypto_auth_BYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_auth_BYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_auth_BYTES); return enif_make_int64(env, crypto_auth_BYTES);
} }
static ERL_NIF_TERM enif_crypto_auth_KEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_auth_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_auth_KEYBYTES); return enif_make_int64(env, crypto_auth_KEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_shorthash_BYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_shorthash_BYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_shorthash_BYTES); return enif_make_int64(env, crypto_shorthash_BYTES);
} }
static ERL_NIF_TERM enif_crypto_shorthash_KEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_shorthash_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_shorthash_KEYBYTES); return enif_make_int64(env, crypto_shorthash_KEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_onetimeauth_BYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_onetimeauth_BYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_onetimeauth_BYTES); return enif_make_int64(env, crypto_onetimeauth_BYTES);
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_onetimeauth_KEYBYTES(ErlNifEnv *env, int argc, enacl_crypto_onetimeauth_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_onetimeauth_KEYBYTES); return enif_make_int64(env, crypto_onetimeauth_KEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_secretbox(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary key, nonce, padded_msg, padded_ciphertext; ErlNifBinary key, nonce, padded_msg, padded_ciphertext;
@ -790,7 +515,7 @@ static ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc,
padded_msg.size - crypto_secretbox_BOXZEROBYTES); padded_msg.size - crypto_secretbox_BOXZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_secretbox_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary key, nonce, padded_ciphertext, padded_msg; ErlNifBinary key, nonce, padded_ciphertext, padded_msg;
@ -823,7 +548,7 @@ static ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc,
padded_ciphertext.size - crypto_secretbox_ZEROBYTES); padded_ciphertext.size - crypto_secretbox_ZEROBYTES);
} }
static ERL_NIF_TERM enif_crypto_stream_chacha20(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_stream_chacha20(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary c, n, k; ErlNifBinary c, n, k;
ErlNifUInt64 clen; ErlNifUInt64 clen;
@ -848,7 +573,8 @@ static ERL_NIF_TERM enif_crypto_stream_chacha20(ErlNifEnv *env, int argc,
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
static ERL_NIF_TERM enif_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc, static ERL_NIF_TERM
enacl_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary c, m, n, k; ErlNifBinary c, m, n, k;
@ -872,7 +598,7 @@ static ERL_NIF_TERM enif_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
static ERL_NIF_TERM enif_crypto_stream(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_stream(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary c, n, k; ErlNifBinary c, n, k;
ErlNifUInt64 clen; ErlNifUInt64 clen;
@ -897,7 +623,7 @@ static ERL_NIF_TERM enif_crypto_stream(ErlNifEnv *env, int argc,
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
static ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_stream_xor(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary c, m, n, k; ErlNifBinary c, m, n, k;
@ -921,7 +647,7 @@ static ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc,
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
static ERL_NIF_TERM enif_crypto_auth(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_auth(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
@ -943,7 +669,7 @@ static ERL_NIF_TERM enif_crypto_auth(ErlNifEnv *env, int argc,
return enif_make_binary(env, &a); return enif_make_binary(env, &a);
} }
static ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_auth_verify(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
@ -964,7 +690,7 @@ static ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc,
} }
} }
static ERL_NIF_TERM enif_crypto_shorthash(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_shorthash(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
@ -986,7 +712,7 @@ static ERL_NIF_TERM enif_crypto_shorthash(ErlNifEnv *env, int argc,
return enif_make_binary(env, &a); return enif_make_binary(env, &a);
} }
static ERL_NIF_TERM enif_crypto_onetimeauth(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_onetimeauth(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
@ -1008,7 +734,7 @@ static ERL_NIF_TERM enif_crypto_onetimeauth(ErlNifEnv *env, int argc,
return enif_make_binary(env, &a); return enif_make_binary(env, &a);
} }
static ERL_NIF_TERM enif_crypto_onetimeauth_verify(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_onetimeauth_verify(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
@ -1075,22 +801,22 @@ static ERL_NIF_TERM enif_randombytes_uniform(ErlNifEnv *env, int argc,
/* Key exchange */ /* Key exchange */
static ERL_NIF_TERM enif_crypto_kx_SECRETKEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_kx_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_kx_SECRETKEYBYTES); return enif_make_int64(env, crypto_kx_SECRETKEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_kx_PUBLICKEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_kx_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_kx_PUBLICKEYBYTES); return enif_make_int64(env, crypto_kx_PUBLICKEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_kx_SESSIONKEYBYTES(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_kx_SESSIONKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_kx_SESSIONKEYBYTES); return enif_make_int64(env, crypto_kx_SESSIONKEYBYTES);
} }
static ERL_NIF_TERM enif_crypto_kx_keypair(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_kx_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk; ErlNifBinary pk, sk;
@ -1113,7 +839,7 @@ static ERL_NIF_TERM enif_crypto_kx_keypair(ErlNifEnv *env, int argc,
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_kx_server_session_keys(ErlNifEnv *env, int argc, enacl_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary rx, tx, server_pk, server_sk, client_pk; ErlNifBinary rx, tx, server_pk, server_sk, client_pk;
@ -1145,7 +871,7 @@ enif_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
} }
static ERL_NIF_TERM static ERL_NIF_TERM
enif_crypto_kx_client_session_keys(ErlNifEnv *env, int argc, enacl_crypto_kx_client_session_keys(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary rx, tx, client_pk, client_sk, server_pk; ErlNifBinary rx, tx, client_pk, client_sk, server_pk;
@ -1308,7 +1034,7 @@ static size_t enacl_pwhash_memlimit(ErlNifEnv *env, ERL_NIF_TERM arg) {
return 0; return 0;
} }
static ERL_NIF_TERM enif_crypto_pwhash(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_pwhash(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary h, p, s; ErlNifBinary h, p, s;
size_t o, m; size_t o, m;
@ -1350,7 +1076,7 @@ static ERL_NIF_TERM enif_crypto_pwhash(ErlNifEnv *env, int argc,
return enif_make_tuple2(env, ok, ret); return enif_make_tuple2(env, ok, ret);
} }
static ERL_NIF_TERM enif_crypto_pwhash_str(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_pwhash_str(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary h, p; ErlNifBinary h, p;
size_t o, m; size_t o, m;
@ -1385,7 +1111,7 @@ static ERL_NIF_TERM enif_crypto_pwhash_str(ErlNifEnv *env, int argc,
return enif_make_tuple2(env, ok, ret); return enif_make_tuple2(env, ok, ret);
} }
static ERL_NIF_TERM enif_crypto_pwhash_str_verify(ErlNifEnv *env, int argc, static ERL_NIF_TERM enacl_crypto_pwhash_str_verify(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
ErlNifBinary h, p; ErlNifBinary h, p;
@ -1406,43 +1132,43 @@ static ERL_NIF_TERM enif_crypto_pwhash_str_verify(ErlNifEnv *env, int argc,
/* Tie the knot to the Erlang world */ /* Tie the knot to the Erlang world */
static ErlNifFunc nif_funcs[] = { static ErlNifFunc nif_funcs[] = {
{"crypto_box_NONCEBYTES", 0, enif_crypto_box_NONCEBYTES}, {"crypto_box_NONCEBYTES", 0, enacl_crypto_box_NONCEBYTES},
{"crypto_box_ZEROBYTES", 0, enif_crypto_box_ZEROBYTES}, {"crypto_box_ZEROBYTES", 0, enacl_crypto_box_ZEROBYTES},
{"crypto_box_BOXZEROBYTES", 0, enif_crypto_box_BOXZEROBYTES}, {"crypto_box_BOXZEROBYTES", 0, enacl_crypto_box_BOXZEROBYTES},
{"crypto_box_PUBLICKEYBYTES", 0, enif_crypto_box_PUBLICKEYBYTES}, {"crypto_box_PUBLICKEYBYTES", 0, enacl_crypto_box_PUBLICKEYBYTES},
{"crypto_box_SECRETKEYBYTES", 0, enif_crypto_box_SECRETKEYBYTES}, {"crypto_box_SECRETKEYBYTES", 0, enacl_crypto_box_SECRETKEYBYTES},
{"crypto_box_BEFORENMBYTES", 0, enif_crypto_box_BEFORENMBYTES}, {"crypto_box_BEFORENMBYTES", 0, enacl_crypto_box_BEFORENMBYTES},
erl_nif_dirty_job_cpu_bound_macro("crypto_box_keypair", 0, erl_nif_dirty_job_cpu_bound_macro("crypto_box_keypair", 0,
enif_crypto_box_keypair), enacl_crypto_box_keypair),
erl_nif_dirty_job_cpu_bound_macro("crypto_box", 4, enif_crypto_box), erl_nif_dirty_job_cpu_bound_macro("crypto_box", 4, enacl_crypto_box),
erl_nif_dirty_job_cpu_bound_macro("crypto_box_open", 4, erl_nif_dirty_job_cpu_bound_macro("crypto_box_open", 4,
enif_crypto_box_open), enacl_crypto_box_open),
{"crypto_box_beforenm", 2, enif_crypto_box_beforenm}, {"crypto_box_beforenm", 2, enacl_crypto_box_beforenm},
{"crypto_box_afternm_b", 3, enif_crypto_box_afternm}, {"crypto_box_afternm_b", 3, enacl_crypto_box_afternm},
erl_nif_dirty_job_cpu_bound_macro("crypto_box_afternm", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_box_afternm", 3,
enif_crypto_box_afternm), enacl_crypto_box_afternm),
{"crypto_box_open_afternm_b", 3, enif_crypto_box_open_afternm}, {"crypto_box_open_afternm_b", 3, enacl_crypto_box_open_afternm},
erl_nif_dirty_job_cpu_bound_macro("crypto_box_open_afternm", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_box_open_afternm", 3,
enif_crypto_box_open_afternm), enacl_crypto_box_open_afternm),
{"crypto_sign_PUBLICKEYBYTES", 0, enif_crypto_sign_PUBLICKEYBYTES}, {"crypto_sign_PUBLICKEYBYTES", 0, enacl_crypto_sign_PUBLICKEYBYTES},
{"crypto_sign_SECRETKEYBYTES", 0, enif_crypto_sign_SECRETKEYBYTES}, {"crypto_sign_SECRETKEYBYTES", 0, enacl_crypto_sign_SECRETKEYBYTES},
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_keypair", 0, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_keypair", 0,
enif_crypto_sign_keypair), enacl_crypto_sign_keypair),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_seed_keypair", 1, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_seed_keypair", 1,
enif_crypto_sign_seed_keypair), enacl_crypto_sign_seed_keypair),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign", 2, enif_crypto_sign), erl_nif_dirty_job_cpu_bound_macro("crypto_sign", 2, enacl_crypto_sign),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_open", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_open", 2,
enif_crypto_sign_open), enacl_crypto_sign_open),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_detached", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_detached", 2,
enif_crypto_sign_detached), enacl_crypto_sign_detached),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_verify_detached", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_verify_detached", 3,
enif_crypto_sign_verify_detached), enacl_crypto_sign_verify_detached),
{"crypto_sign_init", 0, enacl_crypto_sign_init}, {"crypto_sign_init", 0, enacl_crypto_sign_init},
{"crypto_sign_update", 2, enacl_crypto_sign_update}, {"crypto_sign_update", 2, enacl_crypto_sign_update},
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_create", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_create", 2,
@ -1450,93 +1176,93 @@ static ErlNifFunc nif_funcs[] = {
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_verify", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_verify", 3,
enacl_crypto_sign_final_verify), enacl_crypto_sign_final_verify),
{"crypto_sign_ed25519_sk_to_pk", 1, enif_crypto_sign_ed25519_sk_to_pk}, {"crypto_sign_ed25519_sk_to_pk", 1, enacl_crypto_sign_ed25519_sk_to_pk},
{"crypto_box_SEALBYTES", 0, enif_crypto_box_SEALBYTES}, {"crypto_box_SEALBYTES", 0, enacl_crypto_box_SEALBYTES},
erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal", 2,
enif_crypto_box_seal), enacl_crypto_box_seal),
erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal_open", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal_open", 3,
enif_crypto_box_seal_open), enacl_crypto_box_seal_open),
{"crypto_secretbox_NONCEBYTES", 0, enif_crypto_secretbox_NONCEBYTES}, {"crypto_secretbox_NONCEBYTES", 0, enacl_crypto_secretbox_NONCEBYTES},
{"crypto_secretbox_ZEROBYTES", 0, enif_crypto_secretbox_ZEROBYTES}, {"crypto_secretbox_ZEROBYTES", 0, enacl_crypto_secretbox_ZEROBYTES},
{"crypto_secretbox_BOXZEROBYTES", 0, enif_crypto_secretbox_BOXZEROBYTES}, {"crypto_secretbox_BOXZEROBYTES", 0, enacl_crypto_secretbox_BOXZEROBYTES},
{"crypto_secretbox_KEYBYTES", 0, enif_crypto_secretbox_KEYBYTES}, {"crypto_secretbox_KEYBYTES", 0, enacl_crypto_secretbox_KEYBYTES},
{"crypto_secretbox_b", 3, enif_crypto_secretbox}, {"crypto_secretbox_b", 3, enacl_crypto_secretbox},
erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox", 3,
enif_crypto_secretbox), enacl_crypto_secretbox),
{"crypto_secretbox_open_b", 3, enif_crypto_secretbox_open}, {"crypto_secretbox_open_b", 3, enacl_crypto_secretbox_open},
erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox_open", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox_open", 3,
enif_crypto_secretbox_open), enacl_crypto_secretbox_open),
{"crypto_stream_chacha20_KEYBYTES", 0, {"crypto_stream_chacha20_KEYBYTES", 0,
enif_crypto_stream_chacha20_KEYBYTES}, enacl_crypto_stream_chacha20_KEYBYTES},
{"crypto_stream_chacha20_NONCEBYTES", 0, {"crypto_stream_chacha20_NONCEBYTES", 0,
enif_crypto_stream_chacha20_NONCEBYTES}, enacl_crypto_stream_chacha20_NONCEBYTES},
{"crypto_stream_chacha20_b", 3, enif_crypto_stream_chacha20}, {"crypto_stream_chacha20_b", 3, enacl_crypto_stream_chacha20},
erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20", 3,
enif_crypto_stream_chacha20), enacl_crypto_stream_chacha20),
{"crypto_stream_chacha20_xor_b", 3, enif_crypto_stream_chacha20_xor}, {"crypto_stream_chacha20_xor_b", 3, enacl_crypto_stream_chacha20_xor},
erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20_xor", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20_xor", 3,
enif_crypto_stream_chacha20_xor), enacl_crypto_stream_chacha20_xor),
{"crypto_stream_KEYBYTES", 0, enif_crypto_stream_KEYBYTES}, {"crypto_stream_KEYBYTES", 0, enacl_crypto_stream_KEYBYTES},
{"crypto_stream_NONCEBYTES", 0, enif_crypto_stream_NONCEBYTES}, {"crypto_stream_NONCEBYTES", 0, enacl_crypto_stream_NONCEBYTES},
{"crypto_stream_b", 3, enif_crypto_stream}, {"crypto_stream_b", 3, enacl_crypto_stream},
erl_nif_dirty_job_cpu_bound_macro("crypto_stream", 3, enif_crypto_stream), erl_nif_dirty_job_cpu_bound_macro("crypto_stream", 3, enacl_crypto_stream),
{"crypto_stream_xor_b", 3, enif_crypto_stream_xor}, {"crypto_stream_xor_b", 3, enacl_crypto_stream_xor},
erl_nif_dirty_job_cpu_bound_macro("crypto_stream_xor", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_stream_xor", 3,
enif_crypto_stream_xor), enacl_crypto_stream_xor),
{"crypto_auth_BYTES", 0, enif_crypto_auth_BYTES}, {"crypto_auth_BYTES", 0, enacl_crypto_auth_BYTES},
{"crypto_auth_KEYBYTES", 0, enif_crypto_auth_KEYBYTES}, {"crypto_auth_KEYBYTES", 0, enacl_crypto_auth_KEYBYTES},
{"crypto_auth_b", 2, enif_crypto_auth}, {"crypto_auth_b", 2, enacl_crypto_auth},
erl_nif_dirty_job_cpu_bound_macro("crypto_auth", 2, enif_crypto_auth), erl_nif_dirty_job_cpu_bound_macro("crypto_auth", 2, enacl_crypto_auth),
{"crypto_auth_verify_b", 3, enif_crypto_auth_verify}, {"crypto_auth_verify_b", 3, enacl_crypto_auth_verify},
erl_nif_dirty_job_cpu_bound_macro("crypto_auth_verify", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_auth_verify", 3,
enif_crypto_auth_verify), enacl_crypto_auth_verify),
{"crypto_shorthash_BYTES", 0, enif_crypto_shorthash_BYTES}, {"crypto_shorthash_BYTES", 0, enacl_crypto_shorthash_BYTES},
{"crypto_shorthash_KEYBYTES", 0, enif_crypto_shorthash_KEYBYTES}, {"crypto_shorthash_KEYBYTES", 0, enacl_crypto_shorthash_KEYBYTES},
{"crypto_shorthash", 2, enif_crypto_shorthash}, {"crypto_shorthash", 2, enacl_crypto_shorthash},
{"crypto_onetimeauth_BYTES", 0, enif_crypto_onetimeauth_BYTES}, {"crypto_onetimeauth_BYTES", 0, enacl_crypto_onetimeauth_BYTES},
{"crypto_onetimeauth_KEYBYTES", 0, enif_crypto_onetimeauth_KEYBYTES}, {"crypto_onetimeauth_KEYBYTES", 0, enacl_crypto_onetimeauth_KEYBYTES},
{"crypto_onetimeauth_b", 2, enif_crypto_onetimeauth}, {"crypto_onetimeauth_b", 2, enacl_crypto_onetimeauth},
erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth", 2,
enif_crypto_onetimeauth), enacl_crypto_onetimeauth),
{"crypto_onetimeauth_verify_b", 3, enif_crypto_onetimeauth_verify}, {"crypto_onetimeauth_verify_b", 3, enacl_crypto_onetimeauth_verify},
erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth_verify", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth_verify", 3,
enif_crypto_onetimeauth_verify), enacl_crypto_onetimeauth_verify),
{"crypto_hash_b", 1, enacl_crypto_hash}, {"crypto_hash_b", 1, enacl_crypto_hash},
erl_nif_dirty_job_cpu_bound_macro("crypto_hash", 1, enacl_crypto_hash), erl_nif_dirty_job_cpu_bound_macro("crypto_hash", 1, enacl_crypto_hash),
{"crypto_verify_16", 2, enif_crypto_verify_16}, {"crypto_verify_16", 2, enacl_crypto_verify_16},
{"crypto_verify_32", 2, enif_crypto_verify_32}, {"crypto_verify_32", 2, enacl_crypto_verify_32},
{"sodium_memzero", 1, enif_sodium_memzero}, {"sodium_memzero", 1, enif_sodium_memzero},
erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash", 4, enif_crypto_pwhash), erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash", 4, enacl_crypto_pwhash),
erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str", 3,
enif_crypto_pwhash_str), enacl_crypto_pwhash_str),
erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str_verify", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str_verify", 2,
enif_crypto_pwhash_str_verify), enacl_crypto_pwhash_str_verify),
erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult", 2, erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult", 2,
enif_crypto_curve25519_scalarmult), enacl_crypto_curve25519_scalarmult),
erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult_base", 1, erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult_base", 1,
enif_crypto_curve25519_scalarmult_base), enacl_crypto_curve25519_scalarmult_base),
erl_nif_dirty_job_cpu_bound_macro("crypto_sign_ed25519_keypair", 0, erl_nif_dirty_job_cpu_bound_macro("crypto_sign_ed25519_keypair", 0,
enif_crypto_sign_ed25519_keypair), enacl_crypto_sign_ed25519_keypair),
{"crypto_sign_ed25519_public_to_curve25519", 1, {"crypto_sign_ed25519_public_to_curve25519", 1,
enif_crypto_sign_ed25519_public_to_curve25519}, enacl_crypto_sign_ed25519_public_to_curve25519},
{"crypto_sign_ed25519_secret_to_curve25519", 1, {"crypto_sign_ed25519_secret_to_curve25519", 1,
enif_crypto_sign_ed25519_secret_to_curve25519}, enacl_crypto_sign_ed25519_secret_to_curve25519},
{"crypto_sign_ed25519_PUBLICKEYBYTES", 0, {"crypto_sign_ed25519_PUBLICKEYBYTES", 0,
enif_crypto_sign_ed25519_PUBLICKEYBYTES}, enacl_crypto_sign_ed25519_PUBLICKEYBYTES},
{"crypto_sign_ed25519_SECRETKEYBYTES", 0, {"crypto_sign_ed25519_SECRETKEYBYTES", 0,
enif_crypto_sign_ed25519_SECRETKEYBYTES}, enacl_crypto_sign_ed25519_SECRETKEYBYTES},
// Linux might block here if early in the boot sequence, so get it off the // Linux might block here if early in the boot sequence, so get it off the
// main scheduler. Otherwise, it it would probably be fine to run on the // main scheduler. Otherwise, it it would probably be fine to run on the
@ -1548,14 +1274,14 @@ static ErlNifFunc nif_funcs[] = {
enif_randombytes_uniform), enif_randombytes_uniform),
erl_nif_dirty_job_cpu_bound_macro("crypto_kx_keypair", 0, erl_nif_dirty_job_cpu_bound_macro("crypto_kx_keypair", 0,
enif_crypto_kx_keypair), enacl_crypto_kx_keypair),
erl_nif_dirty_job_cpu_bound_macro("crypto_kx_client_session_keys", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_kx_client_session_keys", 3,
enif_crypto_kx_client_session_keys), enacl_crypto_kx_client_session_keys),
erl_nif_dirty_job_cpu_bound_macro("crypto_kx_server_session_keys", 3, erl_nif_dirty_job_cpu_bound_macro("crypto_kx_server_session_keys", 3,
enif_crypto_kx_server_session_keys), enacl_crypto_kx_server_session_keys),
{"crypto_kx_PUBLICKEYBYTES", 0, enif_crypto_kx_PUBLICKEYBYTES}, {"crypto_kx_PUBLICKEYBYTES", 0, enacl_crypto_kx_PUBLICKEYBYTES},
{"crypto_kx_SECRETKEYBYTES", 0, enif_crypto_kx_SECRETKEYBYTES}, {"crypto_kx_SECRETKEYBYTES", 0, enacl_crypto_kx_SECRETKEYBYTES},
{"crypto_kx_SESSIONKEYBYTES", 0, enif_crypto_kx_SESSIONKEYBYTES}, {"crypto_kx_SESSIONKEYBYTES", 0, enacl_crypto_kx_SESSIONKEYBYTES},
{"scramble_block_16", 2, enif_scramble_block_16}, {"scramble_block_16", 2, enif_scramble_block_16},
@ -1589,14 +1315,14 @@ static ErlNifFunc nif_funcs[] = {
"crypto_aead_xchacha20poly1305_decrypt", 4, "crypto_aead_xchacha20poly1305_decrypt", 4,
enacl_crypto_aead_xchacha20poly1305_decrypt), enacl_crypto_aead_xchacha20poly1305_decrypt),
{"crypto_generichash_BYTES", 0, enif_crypto_generichash_BYTES}, {"crypto_generichash_BYTES", 0, enacl_crypto_generichash_BYTES},
{"crypto_generichash_BYTES_MIN", 0, enif_crypto_generichash_BYTES_MIN}, {"crypto_generichash_BYTES_MIN", 0, enacl_crypto_generichash_BYTES_MIN},
{"crypto_generichash_BYTES_MAX", 0, enif_crypto_generichash_BYTES_MAX}, {"crypto_generichash_BYTES_MAX", 0, enacl_crypto_generichash_BYTES_MAX},
{"crypto_generichash_KEYBYTES", 0, enif_crypto_generichash_KEYBYTES}, {"crypto_generichash_KEYBYTES", 0, enacl_crypto_generichash_KEYBYTES},
{"crypto_generichash_KEYBYTES_MIN", 0, {"crypto_generichash_KEYBYTES_MIN", 0,
enif_crypto_generichash_KEYBYTES_MIN}, enacl_crypto_generichash_KEYBYTES_MIN},
{"crypto_generichash_KEYBYTES_MAX", 0, {"crypto_generichash_KEYBYTES_MAX", 0,
enif_crypto_generichash_KEYBYTES_MAX}, enacl_crypto_generichash_KEYBYTES_MAX},
{"crypto_generichash", 3, enacl_crypto_generichash}, {"crypto_generichash", 3, enacl_crypto_generichash},
{"crypto_generichash_init", 2, enacl_crypto_generichash_init}, {"crypto_generichash_init", 2, enacl_crypto_generichash_init},
{"crypto_generichash_update", 2, enacl_crypto_generichash_update}, {"crypto_generichash_update", 2, enacl_crypto_generichash_update},
@ -1604,4 +1330,4 @@ static ErlNifFunc nif_funcs[] = {
}; };
ERL_NIF_INIT(enacl_nif, nif_funcs, enif_crypto_load, NULL, NULL, NULL); ERL_NIF_INIT(enacl_nif, nif_funcs, enacl_crypto_load, NULL, NULL, NULL);

12
c_src/generichash.c
View File

@ -43,32 +43,32 @@ static void enacl_generic_hash_ctx_dtor(ErlNifEnv *env,
/* /*
* Generic hash * Generic hash
*/ */
ERL_NIF_TERM enif_crypto_generichash_BYTES(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_BYTES); return enif_make_int64(env, crypto_generichash_BYTES);
} }
ERL_NIF_TERM enif_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_BYTES_MIN); return enif_make_int64(env, crypto_generichash_BYTES_MIN);
} }
ERL_NIF_TERM enif_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_BYTES_MAX); return enif_make_int64(env, crypto_generichash_BYTES_MAX);
} }
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_KEYBYTES); return enif_make_int64(env, crypto_generichash_KEYBYTES);
} }
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_KEYBYTES_MIN); return enif_make_int64(env, crypto_generichash_KEYBYTES_MIN);
} }
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) { ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_generichash_KEYBYTES_MAX); return enif_make_int64(env, crypto_generichash_KEYBYTES_MAX);
} }

12
c_src/generichash.h
View File

@ -3,18 +3,18 @@
int enacl_init_generic_hash_ctx(ErlNifEnv *env); int enacl_init_generic_hash_ctx(ErlNifEnv *env);
ERL_NIF_TERM enif_crypto_generichash_BYTES(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enif_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enif_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
const ERL_NIF_TERM argv[]); const ERL_NIF_TERM argv[]);
ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,

281
c_src/sign.c
View File

@ -10,9 +10,9 @@ typedef struct enacl_sign_ctx {
int alive; // Is the context still valid for updates/finalization int alive; // Is the context still valid for updates/finalization
} enacl_sign_ctx; } enacl_sign_ctx;
static ErlNifResourceType *enacl_sign_ctx_rtype = NULL; ErlNifResourceType *enacl_sign_ctx_rtype = NULL;
static void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *); void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *);
int enacl_init_sign_ctx(ErlNifEnv *env) { int enacl_init_sign_ctx(ErlNifEnv *env) {
enacl_sign_ctx_rtype = enacl_sign_ctx_rtype =
@ -26,7 +26,7 @@ int enacl_init_sign_ctx(ErlNifEnv *env) {
return 1; return 1;
} }
static void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *obj) { void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *obj) {
if (!obj->alive) if (!obj->alive)
return; return;
@ -214,3 +214,278 @@ cleanup:
return ret; return ret;
} }
/* Ed 25519 */
ERL_NIF_TERM
enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if (argc != 0) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_ed25519_keypair(pk.data, sk.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
ERL_NIF_TERM
enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &sk)) ||
(sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
return nacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
}
return enif_make_binary(env, &pk);
}
ERL_NIF_TERM
enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary curve25519_pk, ed25519_pk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_pk)) ||
(ed25519_pk.size != crypto_sign_ed25519_PUBLICKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
ed25519_pk.data) != 0) {
return nacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_pk);
}
ERL_NIF_TERM
enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary curve25519_sk, ed25519_sk;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_sk)) ||
(ed25519_sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
ed25519_sk.data) != 0) {
return nacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_sk);
}
ERL_NIF_TERM
enacl_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_ed25519_PUBLICKEYBYTES);
}
ERL_NIF_TERM
enacl_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_ed25519_SECRETKEYBYTES);
}
ERL_NIF_TERM enacl_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_PUBLICKEYBYTES);
}
ERL_NIF_TERM enacl_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_SECRETKEYBYTES);
}
ERL_NIF_TERM enacl_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
return enif_make_int64(env, crypto_sign_SEEDBYTES);
}
ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk;
if (argc != 0) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_keypair(pk.data, sk.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk, seed;
if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &seed))) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
return enif_make_tuple2(env, enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
/*
int crypto_sign(unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk);
*/
ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sk, sm;
unsigned long long smlen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
(!enif_inspect_binary(env, argv[1], &sk))) {
return enif_make_badarg(env);
}
if (sk.size != crypto_sign_SECRETKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
return enif_make_sub_binary(env, enif_make_binary(env, &sm), 0, smlen);
}
/*
int crypto_sign_open(unsigned char *m, unsigned long long *mlen,
const unsigned char *sm, unsigned long long smlen,
const unsigned char *pk);
*/
ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sm, pk;
unsigned long long mlen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &sm)) ||
(!enif_inspect_binary(env, argv[1], &pk))) {
return enif_make_badarg(env);
}
if (pk.size != crypto_sign_PUBLICKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(sm.size, &m)) {
return nacl_error_tuple(env, "alloc_failed");
}
if (0 == crypto_sign_open(m.data, &mlen, sm.data, sm.size, pk.data)) {
return enif_make_sub_binary(env, enif_make_binary(env, &m), 0, mlen);
} else {
enif_release_binary(&m);
return nacl_error_tuple(env, "failed_verification");
}
}
/*
int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk);
*/
ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sk, sig;
unsigned long long siglen;
if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
(!enif_inspect_binary(env, argv[1], &sk))) {
return enif_make_badarg(env);
}
if (sk.size != crypto_sign_SECRETKEYBYTES) {
return enif_make_badarg(env);
}
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
return nacl_error_tuple(env, "alloc_failed");
}
crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);
return enif_make_binary(env, &sig);
}
/*
int crypto_sign_verify_detached(const unsigned char *sig,
const unsigned char *m,
unsigned long long mlen,
const unsigned char *pk);
*/
ERL_NIF_TERM
enacl_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]) {
ErlNifBinary m, sig, pk;
if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &sig)) ||
(!enif_inspect_iolist_as_binary(env, argv[1], &m)) ||
(!enif_inspect_binary(env, argv[2], &pk))) {
return enif_make_badarg(env);
}
if (pk.size != crypto_sign_PUBLICKEYBYTES) {
return enif_make_badarg(env);
}
if (0 == crypto_sign_verify_detached(sig.data, m.data, m.size, pk.data)) {
return enif_make_atom(env, "true");
} else {
return enif_make_atom(env, "false");
}
}

51
c_src/sign.h
View File

@ -16,4 +16,55 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc, ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]); ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM
enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM
enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM
enacl_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM
enacl_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
ERL_NIF_TERM
enacl_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
ERL_NIF_TERM const argv[]);
#endif #endif