Skip to content

Commit f580f65

Browse files
jlouisjlouis
committed
Streamline _open style calls
Those now return {ok, Msg} or {error, term()} so you are kind of forced to match on them. This is likely to help with correctnes.
1 parent 7999d08 commit f580f65

File tree

7 files changed

+45
-103
lines changed

7 files changed

+45
-103
lines changed

‎CHANGELOG.md

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
99

1010
- Go through all calls and make them return streamlined exceptions if applicable.
1111
Pretty large change, but OTOH, this ought to happen before a 1.0 release as well.
12-
- sign
12+
- Generichashes must support the finalized state
1313

1414
- Implement missing EQC tests
15+
- stream_chacha20...
16+
- stream_xor...
17+
- generichash...
1518

1619
## [Unreleased]
1720

‎c_src/enacl.c

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,4 +9,8 @@ ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *env, char *error_atom) {
99

1010
ERL_NIF_TERM enacl_internal_error(ErlNifEnv *env) {
1111
return enif_raise_exception(env, enif_make_atom(env, "enacl_internal_error"));
12+
}
13+
14+
ERL_NIF_TERM enacl_error_finalized(ErlNifEnv *env) {
15+
return enif_raise_exception(env, enif_make_atom(env, "enacl_finalized"));
1216
}

‎c_src/enacl.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
#define ATOM_FALSE "false"
1010

1111
ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *, char *);
12+
ERL_NIF_TERM enacl_error_finalized(ErlNifEnv *);
1213
ERL_NIF_TERM enacl_internal_error(ErlNifEnv *);
1314

1415
#endif

‎c_src/secret.c

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -130,9 +130,11 @@ ERL_NIF_TERM enacl_crypto_secretbox_open(ErlNifEnv *env, int argc,
130130
return enacl_error_tuple(env, "failed_verification");
131131
}
132132

133-
return enif_make_sub_binary(
133+
ERL_NIF_TERM ret_ok = enif_make_atom(env, ATOM_OK);
134+
ERL_NIF_TERM ret_bin = enif_make_sub_binary(
134135
env, enif_make_binary(env, &padded_msg), crypto_secretbox_ZEROBYTES,
135136
padded_ciphertext.size - crypto_secretbox_ZEROBYTES);
137+
return enif_make_tuple2(env, ret_ok, ret_bin);
136138
}
137139

138140
ERL_NIF_TERM enacl_crypto_stream_chacha20(ErlNifEnv *env, int argc,

‎c_src/sign.c

Lines changed: 28 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -56,24 +56,20 @@ ERL_NIF_TERM enacl_crypto_sign_init(ErlNifEnv *env, int argc,
5656

5757
if ((obj = enif_alloc_resource(enacl_sign_ctx_rtype,
5858
sizeof(enacl_sign_ctx))) == NULL) {
59-
ret = enacl_error_tuple(env, "alloc_failed");
60-
goto done;
59+
goto err;
6160
}
6261
obj->alive = 0;
6362
obj->state = enif_alloc(crypto_sign_statebytes());
6463
if (obj->state == NULL) {
65-
ret = enacl_error_tuple(env, "state_malloc");
6664
goto release;
6765
}
6866
obj->alive = 1;
6967

7068
if ((obj->mtx = enif_mutex_create("enacl.sign")) == NULL) {
71-
ret = enacl_error_tuple(env, "mutex_create");
7269
goto free;
7370
}
7471

7572
if (0 != crypto_sign_init(obj->state)) {
76-
ret = enacl_error_tuple(env, "sign_init_error");
7773
goto free;
7874
}
7975

@@ -94,6 +90,8 @@ ERL_NIF_TERM enacl_crypto_sign_init(ErlNifEnv *env, int argc,
9490
release:
9591
// This also frees the mutex via the destructor
9692
enif_release_resource(obj);
93+
err:
94+
ret = enacl_internal_error(env);
9795
done:
9896
return ret;
9997
}
@@ -120,12 +118,12 @@ ERL_NIF_TERM enacl_crypto_sign_update(ErlNifEnv *env, int argc,
120118

121119
enif_mutex_lock(obj->mtx);
122120
if (!obj->alive) {
123-
ret = enacl_error_tuple(env, "finalized");
121+
ret = enacl_error_finalized(env);
124122
goto done;
125123
}
126124

127125
if (0 != crypto_sign_update(obj->state, data.data, data.size)) {
128-
ret = enacl_error_tuple(env, "sign_update_error");
126+
ret = enacl_internal_error(env); // This should never be hit
129127
goto done;
130128
}
131129

@@ -157,19 +155,16 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
157155

158156
enif_mutex_lock(obj->mtx);
159157
if (!obj->alive) {
160-
ret = enacl_error_tuple(env, "finalized");
158+
ret = enacl_error_finalized(env);
161159
goto done;
162160
}
163161

164162
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
165-
ret = enacl_error_tuple(env, "alloc_failed");
163+
ret = enacl_internal_error(env);
166164
goto done;
167165
}
168166

169-
if (0 != crypto_sign_final_create(obj->state, sig.data, &siglen, sk.data)) {
170-
ret = enacl_error_tuple(env, "sign_error");
171-
goto release;
172-
}
167+
crypto_sign_final_create(obj->state, sig.data, &siglen, sk.data);
173168

174169
ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);
175170
ERL_NIF_TERM signature = enif_make_binary(env, &sig);
@@ -179,8 +174,6 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
179174

180175
bad_arg:
181176
return enif_make_badarg(env);
182-
release:
183-
enif_release_binary(&sig);
184177
cleanup:
185178
obj->alive = 0;
186179
sodium_memzero(obj->state, crypto_sign_statebytes());
@@ -210,7 +203,7 @@ ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc,
210203

211204
enif_mutex_lock(obj->mtx);
212205
if (!obj->alive) {
213-
ret = enacl_error_tuple(env, "finalized");
206+
ret = enacl_error_finalized(env);
214207
goto done;
215208
}
216209

@@ -246,12 +239,12 @@ enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
246239
}
247240

248241
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
249-
return enacl_error_tuple(env, "alloc_failed");
242+
return enacl_internal_error(env);
250243
}
251244

252245
if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
253246
enif_release_binary(&pk);
254-
return enacl_error_tuple(env, "alloc_failed");
247+
return enacl_internal_error(env);
255248
}
256249

257250
crypto_sign_ed25519_keypair(pk.data, sk.data);
@@ -271,13 +264,10 @@ enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
271264
}
272265

273266
if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
274-
return enacl_error_tuple(env, "alloc_failed");
267+
return enacl_internal_error(env);
275268
}
276269

277-
if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
278-
enif_release_binary(&pk);
279-
return enacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
280-
}
270+
crypto_sign_ed25519_sk_to_pk(pk.data, sk.data);
281271

282272
return enif_make_binary(env, &pk);
283273
}
@@ -293,14 +283,10 @@ enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
293283
}
294284

295285
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
296-
return enacl_error_tuple(env, "alloc_failed");
286+
return enacl_internal_error(env);
297287
}
298288

299-
if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
300-
ed25519_pk.data) != 0) {
301-
enif_release_binary(&curve25519_pk);
302-
return enacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
303-
}
289+
crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data, ed25519_pk.data);
304290

305291
return enif_make_binary(env, &curve25519_pk);
306292
}
@@ -316,14 +302,10 @@ enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
316302
}
317303

318304
if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
319-
return enacl_error_tuple(env, "alloc_failed");
305+
return enacl_internal_error(env);
320306
}
321307

322-
if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
323-
ed25519_sk.data) != 0) {
324-
enif_release_binary(&curve25519_sk);
325-
return enacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
326-
}
308+
crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data, ed25519_sk.data);
327309

328310
return enif_make_binary(env, &curve25519_sk);
329311
}
@@ -364,12 +346,12 @@ ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
364346
}
365347

366348
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
367-
return enacl_error_tuple(env, "alloc_failed");
349+
return enacl_internal_error(env);
368350
}
369351

370352
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
371353
enif_release_binary(&pk);
372-
return enacl_error_tuple(env, "alloc_failed");
354+
return enacl_internal_error(env);
373355
}
374356

375357
crypto_sign_keypair(pk.data, sk.data);
@@ -387,12 +369,12 @@ ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
387369
}
388370

389371
if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
390-
return enacl_error_tuple(env, "alloc_failed");
372+
return enacl_internal_error(env);
391373
}
392374

393375
if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
394376
enif_release_binary(&pk);
395-
return enacl_error_tuple(env, "alloc_failed");
377+
return enacl_internal_error(env);
396378
}
397379

398380
crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
@@ -401,11 +383,6 @@ ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
401383
enif_make_binary(env, &sk));
402384
}
403385

404-
/*
405-
int crypto_sign(unsigned char *sm, unsigned long long *smlen,
406-
const unsigned char *m, unsigned long long mlen,
407-
const unsigned char *sk);
408-
*/
409386
ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
410387
ERL_NIF_TERM const argv[]) {
411388
ErlNifBinary m, sk, sm;
@@ -421,19 +398,14 @@ ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
421398
}
422399

423400
if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
424-
return enacl_error_tuple(env, "alloc_failed");
401+
return enacl_internal_error(env);
425402
}
426403

427404
crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
428405

429406
return enif_make_sub_binary(env, enif_make_binary(env, &sm), 0, smlen);
430407
}
431408

432-
/*
433-
int crypto_sign_open(unsigned char *m, unsigned long long *mlen,
434-
const unsigned char *sm, unsigned long long smlen,
435-
const unsigned char *pk);
436-
*/
437409
ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
438410
ERL_NIF_TERM const argv[]) {
439411
ErlNifBinary m, sm, pk;
@@ -449,22 +421,20 @@ ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
449421
}
450422

451423
if (!enif_alloc_binary(sm.size, &m)) {
452-
return enacl_error_tuple(env, "alloc_failed");
424+
return enacl_internal_error(env);
453425
}
454426

455427
if (0 == crypto_sign_open(m.data, &mlen, sm.data, sm.size, pk.data)) {
456-
return enif_make_sub_binary(env, enif_make_binary(env, &m), 0, mlen);
428+
ERL_NIF_TERM ret_ok = enif_make_atom(env, ATOM_OK);
429+
ERL_NIF_TERM ret_bin =
430+
enif_make_sub_binary(env, enif_make_binary(env, &m), 0, mlen);
431+
return enif_make_tuple2(env, ret_ok, ret_bin);
457432
} else {
458433
enif_release_binary(&m);
459434
return enacl_error_tuple(env, "failed_verification");
460435
}
461436
}
462437

463-
/*
464-
int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen,
465-
const unsigned char *m, unsigned long long mlen,
466-
const unsigned char *sk);
467-
*/
468438
ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
469439
ERL_NIF_TERM const argv[]) {
470440
ErlNifBinary m, sk, sig;
@@ -480,20 +450,14 @@ ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
480450
}
481451

482452
if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
483-
return enacl_error_tuple(env, "alloc_failed");
453+
return enacl_internal_error(env);
484454
}
485455

486456
crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);
487457

488458
return enif_make_binary(env, &sig);
489459
}
490460

491-
/*
492-
int crypto_sign_verify_detached(const unsigned char *sig,
493-
const unsigned char *m,
494-
unsigned long long mlen,
495-
const unsigned char *pk);
496-
*/
497461
ERL_NIF_TERM
498462
enacl_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
499463
ERL_NIF_TERM const argv[]) {

‎eqc_test/enacl_eqc.erl

Lines changed: 0 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -607,24 +607,6 @@ xor_bytes(<<A, As/binary>>, <<B, Bs/binary>>) ->
607607
[A bxor B | xor_bytes(As, Bs)];
608608
xor_bytes(<<>>, <<>>) -> [].
609609

610-
%% prop_stream_xor_correct() ->
611-
%% ?FORALL({Msg, Nonce, Key},
612-
%% {?FAULT_RATE(1, 40, g_iodata()),
613-
%% ?FAULT_RATE(1, 40, nonce()),
614-
%% ?FAULT_RATE(1, 40, secret_key())},
615-
%% case v_iodata(Msg) andalso nonce_valid(Nonce) andalso secret_key_valid(Key) of
616-
%% true ->
617-
%% Stream = enacl:stream(iolist_size(Msg), Nonce, Key),
618-
%% CipherText = enacl:stream_xor(Msg, Nonce, Key),
619-
%% StreamXor = enacl:stream_xor(CipherText, Nonce, Key),
620-
%% conjunction([
621-
%% {'xor', equals(iolist_to_binary(Msg), StreamXor)},
622-
%% {stream, equals(iolist_to_binary(xor_bytes(Stream, iolist_to_binary(Msg))), CipherText)}
623-
%% ]);
624-
%% false ->
625-
%% badargs(fun() -> enacl:stream_xor(Msg, Nonce, Key) end)
626-
%% end).
627-
628610
%% CRYPTO AUTH
629611
%% ------------------------------------------------------------
630612
%% * auth/2

0 commit comments

Comments
 (0)