only add optional arguments to the end

Asmod4n · Sep 9, 2017 · 34cd7d1 · 34cd7d1
1 parent 52deb13
commit 34cd7d1
Show file tree

Hide file tree

Showing 4 changed files with 30 additions and 24 deletions.
diff --git 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
@@ -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
@@ -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
@@ -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));
 }