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

Rid ourselves of excess whitespace.

Browse Source
This commit is contained in:
Jesper Louis Andersen 2014-11-24 15:16:54 +01:00
parent 772a97d3db
commit 08297bb9c9
1 changed files with 44 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
c_src/enacl_nif.c
View File

@ -14,17 +14,17 @@ static
ERL_NIF_TERM enif_crypto_hash(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_hash(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary input; ErlNifBinary input;
ErlNifBinary result; ErlNifBinary result;
if ((argc != 1) || (!enif_inspect_iolist_as_binary(env, argv[0], &input))) { if ((argc != 1) || (!enif_inspect_iolist_as_binary(env, argv[0], &input))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(crypto_hash_BYTES, &result)) { if (!enif_alloc_binary(crypto_hash_BYTES, &result)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_hash(result.data, input.data, input.size); crypto_hash(result.data, input.data, input.size);
return enif_make_binary(env, &result); return enif_make_binary(env, &result);
} }
@ -57,28 +57,28 @@ ERL_NIF_TERM enif_crypto_box_SECRETKEYBYTES(ErlNifEnv *env, int argc, ERL_NIF_TE
static static
ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary pk, sk; ErlNifBinary pk, sk;
if (argc != 0) { if (argc != 0) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(crypto_box_PUBLICKEYBYTES, &pk)) { if (!enif_alloc_binary(crypto_box_PUBLICKEYBYTES, &pk)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk)) { if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_box_keypair(pk.data, sk.data); crypto_box_keypair(pk.data, sk.data);
return enif_make_tuple3(env, enif_make_atom(env, "ok"), enif_make_binary(env, &pk), enif_make_binary(env, &sk)); return enif_make_tuple3(env, enif_make_atom(env, "ok"), enif_make_binary(env, &pk), enif_make_binary(env, &sk));
} }
static static
ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary padded_msg, nonce, pk, sk, result; ErlNifBinary padded_msg, nonce, pk, sk, result;
if ( if (
(argc != 4) || (argc != 4) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &padded_msg)) || (!enif_inspect_iolist_as_binary(env, argv[0], &padded_msg)) ||
@ -87,7 +87,7 @@ ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]
(!enif_inspect_iolist_as_binary(env, argv[3], &sk))) { (!enif_inspect_iolist_as_binary(env, argv[3], &sk))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(nonce.size != crypto_box_NONCEBYTES) || (nonce.size != crypto_box_NONCEBYTES) ||
(pk.size != crypto_box_PUBLICKEYBYTES) || (pk.size != crypto_box_PUBLICKEYBYTES) ||
@ -95,13 +95,13 @@ ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]
(padded_msg.size < crypto_box_ZEROBYTES)) { (padded_msg.size < crypto_box_ZEROBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(padded_msg.size, &result)) { if (!enif_alloc_binary(padded_msg.size, &result)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data, pk.data, sk.data); crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data, pk.data, sk.data);
return enif_make_sub_binary( return enif_make_sub_binary(
env, env,
enif_make_binary(env, &result), enif_make_binary(env, &result),
@ -112,7 +112,7 @@ ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]
static static
ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary padded_ciphertext, nonce, pk, sk, result; ErlNifBinary padded_ciphertext, nonce, pk, sk, result;
if ( if (
(argc != 4) || (argc != 4) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &padded_ciphertext)) || (!enif_inspect_iolist_as_binary(env, argv[0], &padded_ciphertext)) ||
@ -121,7 +121,7 @@ ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const a
(!enif_inspect_iolist_as_binary(env, argv[3], &sk))) { (!enif_inspect_iolist_as_binary(env, argv[3], &sk))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(nonce.size != crypto_box_NONCEBYTES) || (nonce.size != crypto_box_NONCEBYTES) ||
(pk.size != crypto_box_PUBLICKEYBYTES) || (pk.size != crypto_box_PUBLICKEYBYTES) ||
@ -129,16 +129,16 @@ ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const a
(padded_ciphertext.size < crypto_box_BOXZEROBYTES)) { (padded_ciphertext.size < crypto_box_BOXZEROBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(padded_ciphertext.size, &result)) { if (!enif_alloc_binary(padded_ciphertext.size, &result)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
if (crypto_box_open(result.data, padded_ciphertext.data, padded_ciphertext.size, nonce.data, pk.data, sk.data) != 0) { if (crypto_box_open(result.data, padded_ciphertext.data, padded_ciphertext.size, nonce.data, pk.data, sk.data) != 0) {
enif_release_binary(&result); enif_release_binary(&result);
return nacl_error_tuple(env, "failed_verification"); return nacl_error_tuple(env, "failed_verification");
} }
return enif_make_sub_binary( return enif_make_sub_binary(
env, env,
enif_make_binary(env, &result), enif_make_binary(env, &result),
@ -185,7 +185,7 @@ ERL_NIF_TERM enif_crypto_auth_KEYBYTES(ErlNifEnv *env, int argc, ERL_NIF_TERM co
static static
ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary key, nonce, padded_msg, padded_ciphertext; ErlNifBinary key, nonce, padded_msg, padded_ciphertext;
if ( if (
(argc != 3) || (argc != 3) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &padded_msg)) || (!enif_inspect_iolist_as_binary(env, argv[0], &padded_msg)) ||
@ -193,24 +193,24 @@ ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc, ERL_NIF_TERM const
(!enif_inspect_iolist_as_binary(env, argv[2], &key))) { (!enif_inspect_iolist_as_binary(env, argv[2], &key))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(key.size != crypto_secretbox_KEYBYTES) || (key.size != crypto_secretbox_KEYBYTES) ||
(nonce.size != crypto_secretbox_NONCEBYTES) || (nonce.size != crypto_secretbox_NONCEBYTES) ||
(padded_msg.size < crypto_secretbox_ZEROBYTES)) { (padded_msg.size < crypto_secretbox_ZEROBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(padded_msg.size, &padded_ciphertext)) { if (!enif_alloc_binary(padded_msg.size, &padded_ciphertext)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_secretbox( crypto_secretbox(
padded_ciphertext.data, padded_ciphertext.data,
padded_msg.data, padded_msg.size, padded_msg.data, padded_msg.size,
nonce.data, nonce.data,
key.data); key.data);
return enif_make_sub_binary(env, return enif_make_sub_binary(env,
enif_make_binary(env, &padded_ciphertext), enif_make_binary(env, &padded_ciphertext),
crypto_secretbox_BOXZEROBYTES, crypto_secretbox_BOXZEROBYTES,
@ -220,7 +220,7 @@ ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc, ERL_NIF_TERM const
static static
ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary key, nonce, padded_ciphertext, padded_msg; ErlNifBinary key, nonce, padded_ciphertext, padded_msg;
if ( if (
(argc != 3) || (argc != 3) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &padded_ciphertext)) || (!enif_inspect_iolist_as_binary(env, argv[0], &padded_ciphertext)) ||
@ -228,18 +228,18 @@ ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc, ERL_NIF_TERM c
(!enif_inspect_iolist_as_binary(env, argv[2], &key))) { (!enif_inspect_iolist_as_binary(env, argv[2], &key))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(key.size != crypto_secretbox_KEYBYTES) || (key.size != crypto_secretbox_KEYBYTES) ||
(nonce.size != crypto_secretbox_NONCEBYTES) || (nonce.size != crypto_secretbox_NONCEBYTES) ||
(padded_ciphertext.size < crypto_secretbox_BOXZEROBYTES)) { (padded_ciphertext.size < crypto_secretbox_BOXZEROBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(padded_ciphertext.size, &padded_msg)) { if (!enif_alloc_binary(padded_ciphertext.size, &padded_msg)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
if (crypto_secretbox_open( if (crypto_secretbox_open(
padded_msg.data, padded_msg.data,
padded_ciphertext.data, padded_ciphertext.data,
@ -249,7 +249,7 @@ ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc, ERL_NIF_TERM c
enif_release_binary(&padded_msg); enif_release_binary(&padded_msg);
return nacl_error_tuple(env, "failed_verification"); return nacl_error_tuple(env, "failed_verification");
} }
return enif_make_sub_binary( return enif_make_sub_binary(
env, env,
enif_make_binary(env, &padded_msg), enif_make_binary(env, &padded_msg),
@ -269,26 +269,26 @@ ERL_NIF_TERM enif_crypto_stream(ErlNifEnv *env, int argc, ERL_NIF_TERM const arg
(!enif_inspect_iolist_as_binary(env, argv[2], &k))) { (!enif_inspect_iolist_as_binary(env, argv[2], &k))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(k.size != crypto_stream_KEYBYTES) || (k.size != crypto_stream_KEYBYTES) ||
(n.size != crypto_stream_NONCEBYTES)) { (n.size != crypto_stream_NONCEBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(clen, &c)) { if (!enif_alloc_binary(clen, &c)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_stream(c.data, c.size, n.data, k.data); crypto_stream(c.data, c.size, n.data, k.data);
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
static static
ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary c, m, n, k; ErlNifBinary c, m, n, k;
if ( if (
(argc != 3) || (argc != 3) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &m)) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@ -296,19 +296,19 @@ ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc, ERL_NIF_TERM const
(!enif_inspect_iolist_as_binary(env, argv[2], &k))) { (!enif_inspect_iolist_as_binary(env, argv[2], &k))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if ( if (
(k.size != crypto_stream_KEYBYTES) || (k.size != crypto_stream_KEYBYTES) ||
(n.size != crypto_stream_NONCEBYTES)) { (n.size != crypto_stream_NONCEBYTES)) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(m.size, &c)) { if (!enif_alloc_binary(m.size, &c)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_stream_xor(c.data, m.data, m.size, n.data, k.data); crypto_stream_xor(c.data, m.data, m.size, n.data, k.data);
return enif_make_binary(env, &c); return enif_make_binary(env, &c);
} }
@ -322,24 +322,24 @@ ERL_NIF_TERM enif_crypto_auth(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[
(!enif_inspect_iolist_as_binary(env, argv[1], &k))) { (!enif_inspect_iolist_as_binary(env, argv[1], &k))) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (k.size != crypto_auth_KEYBYTES) { if (k.size != crypto_auth_KEYBYTES) {
return enif_make_badarg(env); return enif_make_badarg(env);
} }
if (!enif_alloc_binary(crypto_auth_BYTES, &a)) { if (!enif_alloc_binary(crypto_auth_BYTES, &a)) {
return nacl_error_tuple(env, "alloc_failed"); return nacl_error_tuple(env, "alloc_failed");
} }
crypto_auth(a.data, m.data, m.size, k.data); crypto_auth(a.data, m.data, m.size, k.data);
return enif_make_binary(env, &a); return enif_make_binary(env, &a);
} }
static static
ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
ErlNifBinary a, m, k; ErlNifBinary a, m, k;
if ( if (
(argc != 3) || (argc != 3) ||
(!enif_inspect_iolist_as_binary(env, argv[0], &a)) || (!enif_inspect_iolist_as_binary(env, argv[0], &a)) ||
@ -372,7 +372,7 @@ static ErlNifFunc nif_funcs[] = {
{"crypto_box_keypair", 0, enif_crypto_box_keypair}, {"crypto_box_keypair", 0, enif_crypto_box_keypair},
{"crypto_box", 4, enif_crypto_box, ERL_NIF_DIRTY_JOB_CPU_BOUND}, {"crypto_box", 4, enif_crypto_box, ERL_NIF_DIRTY_JOB_CPU_BOUND},
{"crypto_box_open", 4, enif_crypto_box_open, ERL_NIF_DIRTY_JOB_CPU_BOUND}, {"crypto_box_open", 4, enif_crypto_box_open, ERL_NIF_DIRTY_JOB_CPU_BOUND},
{"crypto_secretbox_NONCEBYTES", 0, enif_crypto_secretbox_NONCEBYTES}, {"crypto_secretbox_NONCEBYTES", 0, enif_crypto_secretbox_NONCEBYTES},
{"crypto_secretbox_ZEROBYTES", 0, enif_crypto_secretbox_ZEROBYTES}, {"crypto_secretbox_ZEROBYTES", 0, enif_crypto_secretbox_ZEROBYTES},
{"crypto_secretbox_BOXZEROBYTES", 0, enif_crypto_secretbox_BOXZEROBYTES}, {"crypto_secretbox_BOXZEROBYTES", 0, enif_crypto_secretbox_BOXZEROBYTES},