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

Rename fixups

Browse Source
This commit is contained in:
Jesper Louis Andersen 2020-01-21 13:56:17 +01:00
parent 92b91bd806
commit ab40d5bbf8
8 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
c_src/enacl.c
View File

@ -2,7 +2,7 @@
#include "enacl.h"
ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *env, char *error_atom) {
ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *env, char *error_atom) {
return enif_make_tuple2(env, enif_make_atom(env, "error"),
enif_make_atom(env, error_atom));
}

2
c_src/enacl.h
View File

@ -8,6 +8,6 @@
#define ATOM_TRUE "true"
#define ATOM_FALSE "false"
ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *, char *);
ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *, char *);
#endif

26
c_src/generichash.c
View File

@ -93,7 +93,7 @@ ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,
// crypto_generichash_BYTES/crypto_generichash_BYTES_MIN/crypto_generichash_BYTES_MAX
if ((hash_size <= crypto_generichash_BYTES_MIN) ||
(hash_size >= crypto_generichash_BYTES_MAX)) {
ret = enacl_error_tuplee(env, "invalid_hash_size");
ret = enacl_error_tuple(env, "invalid_hash_size");
goto done;
}
@ -103,20 +103,20 @@ ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,
k = NULL;
} else if (key.size <= crypto_generichash_KEYBYTES_MIN ||
key.size >= crypto_generichash_KEYBYTES_MAX) {
ret = enacl_error_tuplee(env, "invalid_key_size");
ret = enacl_error_tuple(env, "invalid_key_size");
goto done;
}
// allocate memory for hash
if (!enif_alloc_binary(hash_size, &hash)) {
ret = enacl_error_tuplee(env, "alloc_failed");
ret = enacl_error_tuple(env, "alloc_failed");
goto done;
}
// calculate hash
if (0 != crypto_generichash(hash.data, hash.size, message.data, message.size,
k, key.size)) {
ret = enacl_error_tuplee(env, "hash_error");
ret = enacl_error_tuple(env, "hash_error");
goto release;
}
@ -152,7 +152,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
// Verify that hash size is valid
if ((hash_size <= crypto_generichash_BYTES_MIN) ||
(hash_size >= crypto_generichash_BYTES_MAX)) {
ret = enacl_error_tuplee(env, "invalid_hash_size");
ret = enacl_error_tuple(env, "invalid_hash_size");
goto done;
}
@ -162,7 +162,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
k = NULL;
} else if (key.size <= crypto_generichash_KEYBYTES_MIN ||
key.size >= crypto_generichash_KEYBYTES_MAX) {
ret = enacl_error_tuplee(env, "invalid_key_size");
ret = enacl_error_tuple(env, "invalid_key_size");
goto done;
}
@ -189,7 +189,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
// Call the library function
if (0 != crypto_generichash_init(obj->ctx, k, key.size, obj->outlen)) {
ret = enacl_error_tuplee(env, "hash_init_error");
ret = enacl_error_tuple(env, "hash_init_error");
goto err;
}
@ -199,7 +199,7 @@ bad_arg:
return enif_make_badarg(env);
err:
ret = enacl_error_tuplee(env, "internal_error");
ret = enacl_error_tuple(env, "internal_error");
if (obj != NULL) {
if (obj->alive) {
sodium_free(obj->ctx);
@ -231,13 +231,13 @@ ERL_NIF_TERM enacl_crypto_generichash_update(ErlNifEnv *env, int argc,
goto bad_arg;
if (!obj->alive) {
ret = enacl_error_tuplee(env, "finalized");
ret = enacl_error_tuple(env, "finalized");
goto done;
}
// Update hash state
if (0 != crypto_generichash_update(obj->ctx, data.data, data.size)) {
ret = enacl_error_tuplee(env, "hash_update_error");
ret = enacl_error_tuple(env, "hash_update_error");
goto done;
}
@ -263,17 +263,17 @@ ERL_NIF_TERM enacl_crypto_generichash_final(ErlNifEnv *env, int argc,
goto bad_arg;
if (!obj->alive) {
ret = enacl_error_tuplee(env, "finalized");
ret = enacl_error_tuple(env, "finalized");
goto done;
}
if (!enif_alloc_binary(obj->outlen, &hash)) {
ret = enacl_error_tuplee(env, "alloc_failed");
ret = enacl_error_tuple(env, "alloc_failed");
goto done;
}
if (0 != crypto_generichash_final(obj->ctx, hash.data, hash.size)) {
ret = enacl_error_tuplee(env, "hash_error");
ret = enacl_error_tuple(env, "hash_error");
goto release;
}

4
c_src/hash.c
View File

@ -28,7 +28,7 @@ ERL_NIF_TERM enacl_crypto_shorthash(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_shorthash_BYTES, &a)) {
return nacl_error_tuple(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_shorthash(a.data, m.data, m.size, k.data);
@ -56,7 +56,7 @@ bad_arg:
return enif_make_badarg(env);
err:
ret = nacl_error_tuple(env, "alloc_failed");
ret = enacl_error_tuple(env, "alloc_failed");
done:
return ret;
}

28
c_src/public.c
View File

@ -45,11 +45,11 @@ ERL_NIF_TERM enacl_crypto_box_keypair(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_box_PUBLICKEYBYTES, &pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_box_keypair(pk.data, sk.data);
@ -78,12 +78,12 @@ ERL_NIF_TERM enacl_crypto_box(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(padded_msg.size, &result)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (0 != crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data,
pk.data, sk.data)) {
return enacl_error_tuplee(env, "box_error");
return enacl_error_tuple(env, "box_error");
}
return enif_make_sub_binary(env, enif_make_binary(env, &result),
@ -111,14 +111,14 @@ ERL_NIF_TERM enacl_crypto_box_open(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(padded_ciphertext.size, &result)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (0 != crypto_box_open(result.data, padded_ciphertext.data,
padded_ciphertext.size, nonce.data, pk.data,
sk.data)) {
enif_release_binary(&result);
return enacl_error_tuplee(env, "failed_verification");
return enacl_error_tuple(env, "failed_verification");
}
return enif_make_sub_binary(env, enif_make_binary(env, &result),
@ -140,12 +140,12 @@ ERL_NIF_TERM enacl_crypto_box_beforenm(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_box_BEFORENMBYTES, &k)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (0 != crypto_box_beforenm(k.data, pk.data, sk.data)) {
// error
return enacl_error_tuplee(env, "error_gen_shared_secret");
return enacl_error_tuple(env, "error_gen_shared_secret");
}
return enif_make_binary(env, &k);
@ -165,7 +165,7 @@ ERL_NIF_TERM enacl_crypto_box_afternm(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(m.size, &result)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_box_afternm(result.data, m.data, m.size, nonce.data, k.data);
@ -189,13 +189,13 @@ ERL_NIF_TERM enacl_crypto_box_open_afternm(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(m.size, &result)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (0 != crypto_box_open_afternm(result.data, m.data, m.size, nonce.data,
k.data)) {
enif_release_binary(&result);
return enacl_error_tuplee(env, "failed_verification");
return enacl_error_tuple(env, "failed_verification");
}
return enif_make_sub_binary(env, enif_make_binary(env, &result),
@ -220,7 +220,7 @@ ERL_NIF_TERM enacl_crypto_box_seal(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(msg.size + crypto_box_SEALBYTES, &ciphertext)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_box_seal(ciphertext.data, msg.data, msg.size, key.data);
@ -244,13 +244,13 @@ ERL_NIF_TERM enacl_crypto_box_seal_open(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(ciphertext.size - crypto_box_SEALBYTES, &msg)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_box_seal_open(msg.data, ciphertext.data, ciphertext.size, pk.data,
sk.data) != 0) {
enif_release_binary(&msg);
return enacl_error_tuplee(env, "failed_verification");
return enacl_error_tuple(env, "failed_verification");
}
return enif_make_binary(env, &msg);

10
c_src/pwhash.c
View File

@ -78,19 +78,19 @@ ERL_NIF_TERM enacl_crypto_pwhash(ErlNifEnv *env, int argc,
// Check Salt size
if (s.size != crypto_pwhash_SALTBYTES) {
return enacl_error_tuplee(env, "invalid_salt_size");
return enacl_error_tuple(env, "invalid_salt_size");
}
// Allocate memory for return binary
if (!enif_alloc_binary(crypto_box_SEEDBYTES, &h)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_pwhash(h.data, h.size, (char *)p.data, p.size, s.data, o, m,
crypto_pwhash_ALG_DEFAULT) != 0) {
/* out of memory */
enif_release_binary(&h);
return enacl_error_tuplee(env, "out_of_memory");
return enacl_error_tuple(env, "out_of_memory");
}
ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);
@ -119,13 +119,13 @@ ERL_NIF_TERM enacl_crypto_pwhash_str(ErlNifEnv *env, int argc,
// Allocate memory for return binary
if (!enif_alloc_binary(crypto_pwhash_STRBYTES, &h)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_pwhash_str((char *)h.data, (char *)p.data, p.size, o, m) != 0) {
/* out of memory */
enif_release_binary(&h);
return enacl_error_tuplee(env, "out_of_memory");
return enacl_error_tuple(env, "out_of_memory");
}
ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);

2
c_src/randombytes.c
View File

@ -15,7 +15,7 @@ ERL_NIF_TERM enif_randombytes(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(req_size, &result)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
randombytes(result.data, result.size);

50
c_src/sign.c
View File

@ -52,19 +52,19 @@ ERL_NIF_TERM enacl_crypto_sign_init(ErlNifEnv *env, int argc,
if ((obj = enif_alloc_resource(enacl_sign_ctx_rtype,
sizeof(enacl_sign_ctx))) == NULL) {
ret = enacl_error_tuplee(env, "alloc_failed");
ret = enacl_error_tuple(env, "alloc_failed");
goto done;
}
obj->alive = 0;
obj->state = enif_alloc(crypto_sign_statebytes());
if (obj->state == NULL) {
ret = enacl_error_tuplee(env, "state_malloc");
ret = enacl_error_tuple(env, "state_malloc");
goto release;
}
obj->alive = 1;
if (0 != crypto_sign_init(obj->state)) {
ret = enacl_error_tuplee(env, "sign_init_error");
ret = enacl_error_tuple(env, "sign_init_error");
goto free;
}
@ -111,12 +111,12 @@ ERL_NIF_TERM enacl_crypto_sign_update(ErlNifEnv *env, int argc,
goto bad_arg;
if (!obj->alive) {
ret = enacl_error_tuplee(env, "finalized");
ret = enacl_error_tuple(env, "finalized");
goto done;
}
if (0 != crypto_sign_update(obj->state, data.data, data.size)) {
ret = enacl_error_tuplee(env, "sign_update_error");
ret = enacl_error_tuple(env, "sign_update_error");
goto done;
}
@ -146,17 +146,17 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
goto bad_arg;
if (!obj->alive) {
ret = enacl_error_tuplee(env, "finalized");
ret = enacl_error_tuple(env, "finalized");
goto done;
}
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
ret = enacl_error_tuplee(env, "alloc_failed");
ret = enacl_error_tuple(env, "alloc_failed");
goto done;
}
if (0 != crypto_sign_final_create(obj->state, sig.data, &siglen, sk.data)) {
ret = enacl_error_tuplee(env, "sign_error");
ret = enacl_error_tuple(env, "sign_error");
goto release;
}
@ -198,7 +198,7 @@ ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc,
if (0 == crypto_sign_final_verify(obj->state, sig.data, pk.data)) {
ret = enif_make_atom(env, ATOM_OK);
} else {
ret = enacl_error_tuplee(env, "failed_verification");
ret = enacl_error_tuple(env, "failed_verification");
}
// Mark as done
goto cleanup;
@ -226,11 +226,11 @@ enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_sign_ed25519_keypair(pk.data, sk.data);
@ -250,11 +250,11 @@ enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
return enacl_error_tuplee(env, "crypto_sign_ed25519_sk_to_pk_failed");
return enacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
}
return enif_make_binary(env, &pk);
@ -271,12 +271,12 @@ enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
ed25519_pk.data) != 0) {
return enacl_error_tuplee(env, "ed25519_public_to_curve25519_failed");
return enacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_pk);
@ -293,12 +293,12 @@ enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
ed25519_sk.data) != 0) {
return enacl_error_tuplee(env, "ed25519_secret_to_curve25519_failed");
return enacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
}
return enif_make_binary(env, &curve25519_sk);
@ -340,11 +340,11 @@ ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_sign_keypair(pk.data, sk.data);
@ -362,11 +362,11 @@ ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
@ -395,7 +395,7 @@ ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
@ -423,14 +423,14 @@ ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(sm.size, &m)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_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 enacl_error_tuplee(env, "failed_verification");
return enacl_error_tuple(env, "failed_verification");
}
}
@ -454,7 +454,7 @@ ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
}
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
return enacl_error_tuplee(env, "alloc_failed");
return enacl_error_tuple(env, "alloc_failed");
}
crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);