From e67619a4030fcc6667f66c4057947b27ed42137a Mon Sep 17 00:00:00 2001 From: Jesper Louis Andersen Date: Wed, 22 Jan 2020 19:41:58 +0100 Subject: [PATCH] Update the naming scheme of AEAD xchacha20... Since this AEAD construction variant is an IETF variant, reflect this in the names of the functions. This streamlines the API with the libsodium API. --- c_src/aead.c | 105 +++++++++++++++++++++++++++++-------------- c_src/aead.h | 24 +++++----- c_src/enacl_nif.c | 24 +++++----- src/enacl.erl | 50 ++++++++++----------- src/enacl_nif.erl | 24 +++++----- test/enacl_SUITE.erl | 8 ++-- 6 files changed, 136 insertions(+), 99 deletions(-) diff --git a/c_src/aead.c b/c_src/aead.c index 24a71f1..055c222 100644 --- a/c_src/aead.c +++ b/c_src/aead.c @@ -131,85 +131,122 @@ done: * AEAD XChaCha20 Poly1305 */ ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_KEYBYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]) { +enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]) { return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_KEYBYTES); } ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_NPUBBYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]) { +enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]) { return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_NPUBBYTES); } ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_ABYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]) { +enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]) { return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_ABYTES); } ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX( +enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX( ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX); } ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_encrypt(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]) { +enacl_crypto_aead_xchacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]) { ErlNifBinary key, nonce, ad, message, ciphertext; + ERL_NIF_TERM ret; - if ((argc != 4) || (!enif_inspect_binary(env, argv[0], &key)) || - (!enif_inspect_binary(env, argv[1], &nonce)) || - (!enif_inspect_binary(env, argv[2], &ad)) || - (!enif_inspect_binary(env, argv[3], &message)) || - (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) || - (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) { - return enif_make_badarg(env); - } + if (argc != 4) + goto bad_arg; + if (!enif_inspect_binary(env, argv[0], &message)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[1], &ad)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[2], &nonce)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[3], &key)) + goto bad_arg; + + if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) + goto bad_arg; + if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES) + goto bad_arg; if (!enif_alloc_binary(message.size + crypto_aead_xchacha20poly1305_ietf_ABYTES, &ciphertext)) { - return enacl_error_tuple(env, "alloc_failed"); + ret = enacl_error_tuple(env, "alloc_failed"); + goto done; } if (crypto_aead_xchacha20poly1305_ietf_encrypt( ciphertext.data, NULL, message.data, message.size, ad.data, ad.size, NULL, nonce.data, key.data) < 0) { - return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed"); + ret = enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed"); + goto release; } - return enif_make_binary(env, &ciphertext); + ret = enif_make_binary(env, &ciphertext); + goto done; + +bad_arg: + return enif_make_badarg(env); +release: + enif_release_binary(&ciphertext); +done: + return ret; } ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_decrypt(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]) { +enacl_crypto_aead_xchacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]) { ErlNifBinary key, nonce, ad, message, ciphertext; + ERL_NIF_TERM ret; - if ((argc != 4) || (!enif_inspect_binary(env, argv[0], &key)) || - (!enif_inspect_binary(env, argv[1], &nonce)) || - (!enif_inspect_binary(env, argv[2], &ad)) || - (!enif_inspect_binary(env, argv[3], &ciphertext)) || - (ciphertext.size < crypto_aead_xchacha20poly1305_ietf_ABYTES) || - (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) || - (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) { - return enif_make_badarg(env); - } + if (argc != 4) + goto bad_arg; + if (!enif_inspect_binary(env, argv[0], &ciphertext)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[1], &ad)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[2], &nonce)) + goto bad_arg; + if (!enif_inspect_binary(env, argv[3], &key)) + goto bad_arg; + + if (ciphertext.size < crypto_aead_xchacha20poly1305_ietf_ABYTES) + goto bad_arg; + if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) + goto bad_arg; + if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES) + goto bad_arg; if (!enif_alloc_binary(ciphertext.size - crypto_aead_xchacha20poly1305_ietf_ABYTES, &message)) { - return enacl_error_tuple(env, "alloc_failed"); + ret = enacl_error_tuple(env, "alloc_failed"); + goto done; } if (crypto_aead_xchacha20poly1305_ietf_decrypt( message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data, ad.size, nonce.data, key.data) < 0) { - return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed"); + ret = enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed"); + goto release; } - return enif_make_binary(env, &message); + ret = enif_make_binary(env, &message); + goto done; + +bad_arg: + return enif_make_badarg(env); +release: + enif_release_binary(&message); +done: + return ret; } diff --git a/c_src/aead.h b/c_src/aead.h index 948cc3d..1591b24 100644 --- a/c_src/aead.h +++ b/c_src/aead.h @@ -25,22 +25,22 @@ enacl_crypto_aead_chacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc, /* AEAD XChaCha20 Poly1305 */ ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_KEYBYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]); ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_NPUBBYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]); ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_ABYTES(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]); ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX( + ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]); ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_encrypt(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]); ERL_NIF_TERM -enacl_crypto_aead_xchacha20poly1305_decrypt(ErlNifEnv *env, int argc, - ERL_NIF_TERM const argv[]); +enacl_crypto_aead_xchacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc, + ERL_NIF_TERM const argv[]); #endif diff --git a/c_src/enacl_nif.c b/c_src/enacl_nif.c index cdf6e7d..5e33df3 100644 --- a/c_src/enacl_nif.c +++ b/c_src/enacl_nif.c @@ -420,20 +420,20 @@ static ErlNifFunc nif_funcs[] = { "crypto_aead_chacha20poly1305_ietf_decrypt", 4, enacl_crypto_aead_chacha20poly1305_ietf_decrypt), - {"crypto_aead_xchacha20poly1305_KEYBYTES", 0, - enacl_crypto_aead_xchacha20poly1305_KEYBYTES}, - {"crypto_aead_xchacha20poly1305_NPUBBYTES", 0, - enacl_crypto_aead_xchacha20poly1305_NPUBBYTES}, - {"crypto_aead_xchacha20poly1305_ABYTES", 0, - enacl_crypto_aead_xchacha20poly1305_ABYTES}, - {"crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX", 0, - enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX}, + {"crypto_aead_xchacha20poly1305_ietf_KEYBYTES", 0, + enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES}, + {"crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", 0, + enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES}, + {"crypto_aead_xchacha20poly1305_ietf_ABYTES", 0, + enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES}, + {"crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", 0, + enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX}, erl_nif_dirty_job_cpu_bound_macro( - "crypto_aead_xchacha20poly1305_encrypt", 4, - enacl_crypto_aead_xchacha20poly1305_encrypt), + "crypto_aead_xchacha20poly1305_ietf_encrypt", 4, + enacl_crypto_aead_xchacha20poly1305_ietf_encrypt), erl_nif_dirty_job_cpu_bound_macro( - "crypto_aead_xchacha20poly1305_decrypt", 4, - enacl_crypto_aead_xchacha20poly1305_decrypt), + "crypto_aead_xchacha20poly1305_ietf_decrypt", 4, + enacl_crypto_aead_xchacha20poly1305_ietf_decrypt), {"crypto_generichash_BYTES", 0, enacl_crypto_generichash_BYTES}, {"crypto_generichash_BYTES_MIN", 0, enacl_crypto_generichash_BYTES_MIN}, diff --git a/src/enacl.erl b/src/enacl.erl index d00256a..cdfd578 100644 --- a/src/enacl.erl +++ b/src/enacl.erl @@ -74,12 +74,12 @@ aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX/0, %% No Tests! - aead_xchacha20poly1305_encrypt/4, - aead_xchacha20poly1305_decrypt/4, - aead_xchacha20poly1305_KEYBYTES/0, - aead_xchacha20poly1305_NONCEBYTES/0, - aead_xchacha20poly1305_ABYTES/0, - aead_xchacha20poly1305_MESSAGEBYTES_MAX/0, + aead_xchacha20poly1305_ietf_encrypt/4, + aead_xchacha20poly1305_ietf_decrypt/4, + aead_xchacha20poly1305_ietf_KEYBYTES/0, + aead_xchacha20poly1305_ietf_NPUBBYTES/0, + aead_xchacha20poly1305_ietf_ABYTES/0, + aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX/0, %% EQC stream_key_size/0, @@ -1224,54 +1224,54 @@ aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX() -> %% `AD' using `Key' and `Nonce'. Returns the encrypted message followed by %% `aead_xchacha20poly1305_ABYTES/0' bytes of MAC. %% @end --spec aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg) -> binary() | {error, term()} +-spec aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key) -> binary() | {error, term()} when Key :: binary(), Nonce :: binary(), AD :: binary(), Msg :: binary(). -aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg) -> - enacl_nif:crypto_aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg). +aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key) -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key). %% @doc aead_xchacha20poly1305_decrypt/4 decrypts ciphertext `CT' with additional %% data `AD' using `Key' and `Nonce'. Note: `CipherText' should contain %% `aead_xchacha20poly1305_ABYTES/0' bytes that is the MAC. Returns the decrypted %% message. %% @end --spec aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT) -> binary() | {error, term()} +-spec aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key) -> binary() | {error, term()} when Key :: binary(), Nonce :: binary(), AD :: binary(), CT :: binary(). -aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT) -> - enacl_nif:crypto_aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT). +aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key) -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key). %% @doc aead_xchacha20poly1305_KEYBYTES/0 returns the number of bytes %% of the key used in AEAD XChaCha20 Poly1305 encryption/decryption. %% @end --spec aead_xchacha20poly1305_KEYBYTES() -> pos_integer(). -aead_xchacha20poly1305_KEYBYTES() -> - enacl_nif:crypto_aead_xchacha20poly1305_KEYBYTES(). +-spec aead_xchacha20poly1305_ietf_KEYBYTES() -> pos_integer(). +aead_xchacha20poly1305_ietf_KEYBYTES() -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_KEYBYTES(). -%% @doc aead_xchacha20poly1305_NONCEBYTES/0 returns the number of bytes +%% @doc aead_xchacha20poly1305_NPUBBYTES/0 returns the number of bytes %% of the Nonce in AEAD XChaCha20 Poly1305 encryption/decryption. %% @end --spec aead_xchacha20poly1305_NONCEBYTES() -> pos_integer(). -aead_xchacha20poly1305_NONCEBYTES() -> - enacl_nif:crypto_aead_xchacha20poly1305_NPUBBYTES(). +-spec aead_xchacha20poly1305_ietf_NPUBBYTES() -> pos_integer(). +aead_xchacha20poly1305_ietf_NPUBBYTES() -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(). %% @doc aead_xchacha20poly1305_ABYTES/0 returns the number of bytes %% of the MAC in AEAD XChaCha20 Poly1305 encryption/decryption. %% @end --spec aead_xchacha20poly1305_ABYTES() -> pos_integer(). -aead_xchacha20poly1305_ABYTES() -> - enacl_nif:crypto_aead_xchacha20poly1305_ABYTES(). +-spec aead_xchacha20poly1305_ietf_ABYTES() -> pos_integer(). +aead_xchacha20poly1305_ietf_ABYTES() -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_ABYTES(). %% @doc aead_xchacha20poly1305_MESSAGEBYTES_MAX/0 returns the max number of bytes %% allowed in a message in AEAD XChaCha20 Poly1305 encryption/decryption. %% @end --spec aead_xchacha20poly1305_MESSAGEBYTES_MAX() -> pos_integer(). -aead_xchacha20poly1305_MESSAGEBYTES_MAX() -> - enacl_nif:crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX(). +-spec aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX() -> pos_integer(). +aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX() -> + enacl_nif:crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX(). %% Obtaining random bytes diff --git a/src/enacl_nif.erl b/src/enacl_nif.erl index 97816a0..1309a11 100644 --- a/src/enacl_nif.erl +++ b/src/enacl_nif.erl @@ -81,12 +81,12 @@ crypto_aead_chacha20poly1305_ietf_ABYTES/0, crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX/0, - crypto_aead_xchacha20poly1305_encrypt/4, - crypto_aead_xchacha20poly1305_decrypt/4, - crypto_aead_xchacha20poly1305_KEYBYTES/0, - crypto_aead_xchacha20poly1305_NPUBBYTES/0, - crypto_aead_xchacha20poly1305_ABYTES/0, - crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX/0, + crypto_aead_xchacha20poly1305_ietf_encrypt/4, + crypto_aead_xchacha20poly1305_ietf_decrypt/4, + crypto_aead_xchacha20poly1305_ietf_KEYBYTES/0, + crypto_aead_xchacha20poly1305_ietf_NPUBBYTES/0, + crypto_aead_xchacha20poly1305_ietf_ABYTES/0, + crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX/0, crypto_auth_BYTES/0, crypto_auth_KEYBYTES/0, @@ -279,12 +279,12 @@ crypto_aead_chacha20poly1305_ietf_NPUBBYTES() -> erlang crypto_aead_chacha20poly1305_ietf_ABYTES() -> erlang:nif_error(nif_not_loaded). crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX() -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_encrypt(_Message, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_decrypt(_CipherText, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_KEYBYTES() -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_NPUBBYTES() -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_ABYTES() -> erlang:nif_error(nif_not_loaded). -crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX() -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_encrypt(_Message, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_decrypt(_CipherText, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_KEYBYTES() -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_NPUBBYTES() -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_ABYTES() -> erlang:nif_error(nif_not_loaded). +crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX() -> erlang:nif_error(nif_not_loaded). crypto_auth_BYTES() -> erlang:nif_error(nif_not_loaded). crypto_auth_KEYBYTES() -> erlang:nif_error(nif_not_loaded). diff --git a/test/enacl_SUITE.erl b/test/enacl_SUITE.erl index 5798b7f..d36ba83 100644 --- a/test/enacl_SUITE.erl +++ b/test/enacl_SUITE.erl @@ -91,15 +91,15 @@ generichash_chunked(State, Msg, N) -> generichash_chunked(State2, Msg, N-1). aead_xchacha20poly1305(_Config) -> - NonceLen = enacl:aead_xchacha20poly1305_NONCEBYTES(), - KLen = enacl:aead_xchacha20poly1305_KEYBYTES(), + NonceLen = enacl:aead_xchacha20poly1305_ietf_NPUBBYTES(), + KLen = enacl:aead_xchacha20poly1305_ietf_KEYBYTES(), Key = binary:copy(<<"K">>, KLen), Msg = <<"test">>, AD = <<1,2,3,4,5,6>>, Nonce = binary:copy(<<"N">>, NonceLen), - CipherText = enacl:aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg), - Msg = enacl:aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CipherText), + CipherText = enacl:aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key), + Msg = enacl:aead_xchacha20poly1305_ietf_decrypt(CipherText, AD, Nonce, Key), ok. aead_chacha20poly1305_ietf(_Config) ->