From 34cd7d11689f0e9be3f783751947042a108c9c48 Mon Sep 17 00:00:00 2001 From: Asmod4n Date: Sat, 9 Sep 2017 10:34:47 +0200 Subject: [PATCH] only add optional arguments to the end --- README.md | 3 ++- src/mrb_hash.h | 38 ++++++++++++++++++++++---------------- src/mrb_kdf.h | 9 ++++----- src/mrb_secretbox.h | 4 ++-- 4 files changed, 30 insertions(+), 24 deletions(-) diff --git a/README.md b/README.md index 8736a99..57bcae2 100644 --- a/README.md +++ b/README.md @@ -4,4 +4,5 @@ [libhydrogen](https://github.com/jedisct1/libhydrogen) for mruby. A lightweight, secure, easy-to-use crypto library for constrained environments. -This will be turned into a gem when i have written tests for it. + +For examples take a look at the wiki at https://github.com/Asmod4n/mruby-libhydrogen/wiki diff --git a/src/mrb_hash.h b/src/mrb_hash.h index 6e62c88..a6054ae 100644 --- a/src/mrb_hash.h +++ b/src/mrb_hash.h @@ -1,8 +1,8 @@ static mrb_value mrb_hydro_hash_keygen(mrb_state *mrb, mrb_value hydro_hash_class) { - mrb_int key_len = hydro_hash_KEYBYTES; - mrb_get_args(mrb, "|i", &key_len); + mrb_int key_len; + mrb_get_args(mrb, "i", &key_len); mrb_hydro_check_length_between(mrb, key_len, hydro_hash_KEYBYTES_MIN, hydro_hash_KEYBYTES_MAX, "key_len"); mrb_value key = mrb_str_new(mrb, NULL, key_len); @@ -15,14 +15,17 @@ static mrb_value mrb_hydro_hash_init(mrb_state *mrb, mrb_value self) { const char *ctx; - mrb_value key; - mrb_get_args(mrb, "zS", &ctx, &key); + char *key = NULL; + mrb_int key_len = 0; + mrb_get_args(mrb, "z|s!", &ctx, &key, &key_len); mrb_hydro_check_length(mrb, strlen(ctx), hydro_hash_CONTEXTBYTES, "ctx"); - mrb_hydro_check_length_between(mrb, RSTRING_LEN(key), hydro_hash_KEYBYTES_MIN, hydro_hash_KEYBYTES_MAX, "key"); + if (key) { + mrb_hydro_check_length_between(mrb, key_len, hydro_hash_KEYBYTES_MIN, hydro_hash_KEYBYTES_MAX, "key"); + } hydro_hash_state *state = (hydro_hash_state *) mrb_realloc(mrb, DATA_PTR(self), sizeof(*state)); mrb_data_init(self, state, &mrb_hydro_hash_state); - int rc = hydro_hash_init(state, ctx, (const uint8_t *) RSTRING_PTR(key), RSTRING_LEN(key)); + int rc = hydro_hash_init(state, ctx, (const uint8_t *) key, key_len); assert(rc == 0); return self; @@ -44,8 +47,8 @@ mrb_hydro_hash_update(mrb_state *mrb, mrb_value self) static mrb_value mrb_hydro_hash_final(mrb_state *mrb, mrb_value self) { - mrb_int out_len = hydro_hash_BYTES; - mrb_get_args(mrb, "|i", &out_len); + mrb_int out_len; + mrb_get_args(mrb, "i", &out_len); mrb_hydro_check_length_between(mrb, out_len, hydro_hash_BYTES_MIN, hydro_hash_BYTES_MAX, "out_len"); mrb_value out = mrb_str_new(mrb, NULL, out_len); @@ -58,20 +61,23 @@ mrb_hydro_hash_final(mrb_state *mrb, mrb_value self) static mrb_value mrb_hydro_hash_hash(mrb_state *mrb, mrb_value hydro_hash_class) { + mrb_int out_len; mrb_value in; const char *ctx; - mrb_value key; - mrb_int out_len = hydro_hash_BYTES; - mrb_get_args(mrb, "SzS|i", &in, &ctx, &key, &out_len); - mrb_hydro_check_length(mrb, strlen(ctx), hydro_hash_CONTEXTBYTES, "ctx"); - mrb_hydro_check_length_between(mrb, RSTRING_LEN(key), hydro_hash_KEYBYTES_MIN, hydro_hash_KEYBYTES_MAX, "key"); + char *key = NULL; + mrb_int key_len = 0; + mrb_get_args(mrb, "iSz|s!", &out_len, &in, &ctx, &key, &key_len); mrb_hydro_check_length_between(mrb, out_len, hydro_hash_BYTES_MIN, hydro_hash_BYTES_MAX, "out"); + mrb_hydro_check_length(mrb, strlen(ctx), hydro_hash_CONTEXTBYTES, "ctx"); + if (key) { + mrb_hydro_check_length_between(mrb, key_len, hydro_hash_KEYBYTES_MIN, hydro_hash_KEYBYTES_MAX, "key"); + } mrb_value out = mrb_str_new(mrb, NULL, out_len); int rc = hydro_hash_hash((uint8_t *) RSTRING_PTR(out), out_len, RSTRING_PTR(in), RSTRING_LEN(in), ctx, - (const uint8_t *) RSTRING_PTR(key), RSTRING_LEN(key)); + (const uint8_t *) key, key_len); assert(rc == 0); return out; @@ -89,8 +95,8 @@ mrb_hydro_hash_gem_init(mrb_state *mrb, struct RClass *hydro_mod) mrb_define_const(mrb, hydro_hash_cl, "KEYBYTES", mrb_fixnum_value(hydro_hash_KEYBYTES)); mrb_define_const(mrb, hydro_hash_cl, "KEYBYTES_MAX", mrb_fixnum_value(hydro_hash_KEYBYTES_MAX)); mrb_define_const(mrb, hydro_hash_cl, "KEYBYTES_MIN", mrb_fixnum_value(hydro_hash_KEYBYTES_MIN)); - mrb_define_class_method(mrb, hydro_hash_cl, "keygen", mrb_hydro_hash_keygen, MRB_ARGS_OPT(1)); - mrb_define_method(mrb, hydro_hash_cl, "initialize", mrb_hydro_hash_init, MRB_ARGS_REQ(2)); + mrb_define_class_method(mrb, hydro_hash_cl, "keygen", mrb_hydro_hash_keygen, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, hydro_hash_cl, "initialize", mrb_hydro_hash_init, MRB_ARGS_ARG(1, 1)); mrb_define_method(mrb, hydro_hash_cl, "update", mrb_hydro_hash_update, MRB_ARGS_REQ(1)); mrb_define_alias(mrb, hydro_hash_cl, "<<", "update"); mrb_define_method(mrb, hydro_hash_cl, "final", mrb_hydro_hash_final, MRB_ARGS_REQ(1)); diff --git a/src/mrb_kdf.h b/src/mrb_kdf.h index d7c5bec..c48454a 100644 --- a/src/mrb_kdf.h +++ b/src/mrb_kdf.h @@ -9,15 +9,14 @@ mrb_hydro_kdf_keygen(mrb_state *mrb, mrb_value hydro_kdf_module) static mrb_value mrb_hydro_kdf_derive_from_key(mrb_state *mrb, mrb_value hydro_kdf_module) { - mrb_int subkey_id; + mrb_int subkey_len, subkey_id; const char *ctx; mrb_value key; - mrb_int subkey_len = hydro_kdf_KEYBYTES; - mrb_get_args(mrb, "izS|i", &subkey_id, &ctx, &key, &subkey_len); + mrb_get_args(mrb, "iizS", &subkey_len, &subkey_id, &ctx, &key); + mrb_hydro_check_length_between(mrb, subkey_len, hydro_kdf_BYTES_MIN, hydro_kdf_BYTES_MAX, "subkey_len"); mrb_assert_int_fit(mrb_int, subkey_id, uint64_t, UINT64_MAX); mrb_hydro_check_length(mrb, strlen(ctx), hydro_kdf_CONTEXTBYTES, "ctx"); mrb_hydro_check_length(mrb, RSTRING_LEN(key), hydro_kdf_KEYBYTES, "key"); - mrb_hydro_check_length_between(mrb, subkey_len, hydro_kdf_BYTES_MIN, hydro_kdf_BYTES_MAX, "subkey_len"); mrb_value subkey = mrb_str_new(mrb, NULL, subkey_len); int rc = hydro_kdf_derive_from_key((uint8_t *) RSTRING_PTR(subkey), subkey_len, @@ -38,5 +37,5 @@ mrb_hydro_kdf_gem_init(mrb_state *mrb, struct RClass *hydro_mod) mrb_define_const(mrb, hydro_kdf_mod, "BYTES_MAX", mrb_fixnum_value(hydro_kdf_BYTES_MAX)); mrb_define_const(mrb, hydro_kdf_mod, "BYTES_MIN", mrb_fixnum_value(hydro_kdf_BYTES_MIN)); mrb_define_module_function(mrb, hydro_kdf_mod, "keygen", mrb_hydro_kdf_keygen, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, hydro_kdf_mod, "derive_from_key", mrb_hydro_kdf_derive_from_key, MRB_ARGS_ARG(3, 1)); + mrb_define_module_function(mrb, hydro_kdf_mod, "derive_from_key", mrb_hydro_kdf_derive_from_key, MRB_ARGS_REQ(4)); } diff --git a/src/mrb_secretbox.h b/src/mrb_secretbox.h index b6e93e3..ae9a44a 100644 --- a/src/mrb_secretbox.h +++ b/src/mrb_secretbox.h @@ -90,7 +90,7 @@ mrb_hydro_secretbox_probe_verify(mrb_state *mrb, mrb_value hydro_secretbox_modul mrb_value probe, c; const char *ctx; mrb_value key; - mrb_get_args(mrb, "SzS", &probe, &ctx, &key); + mrb_get_args(mrb, "SSzS", &probe, &c, &ctx, &key); mrb_hydro_check_length(mrb, RSTRING_LEN(probe), hydro_secretbox_PROBEBYTES, "probe"); if (RSTRING_LEN(c) < hydro_secretbox_HEADERBYTES) { mrb_raise(mrb, E_RANGE_ERROR, "ciphertext is too short"); @@ -118,5 +118,5 @@ mrb_hydro_secretbox_gem_init(mrb_state *mrb, struct RClass *hydro_mod) mrb_define_module_function(mrb, hydro_secretbox_mod, "encrypt", mrb_hydro_secretbox_encrypt, MRB_ARGS_ARG(3, 1)); mrb_define_module_function(mrb, hydro_secretbox_mod, "decrypt", mrb_hydro_secretbox_decrypt, MRB_ARGS_ARG(3, 1)); mrb_define_module_function(mrb, hydro_secretbox_mod, "probe_create", mrb_hydro_secretbox_probe_create, MRB_ARGS_REQ(3)); - mrb_define_module_function(mrb, hydro_secretbox_mod, "probe_verify", mrb_hydro_secretbox_probe_verify, MRB_ARGS_REQ(3)); + mrb_define_module_function(mrb, hydro_secretbox_mod, "probe_verify", mrb_hydro_secretbox_probe_verify, MRB_ARGS_REQ(4)); }