sha3 2.2.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b25d248bf32a3f2971ddf97235ce8549de783fb01624c2ae70d8e82aa78754fd
-  data.tar.gz: fa3842d268143da115070c236d181a67bbeef4f2ac3cfe41eb0a50b7049c2721
+  metadata.gz: 9efe4158e87ea949852977b7791cf56838a9fefdbe226ebf7fdb4c5e962e927b
+  data.tar.gz: 6f41a24a48b714a33f846e6458aad350be5168f33202c51a95bda7a364cffc5f
 SHA512:
-  metadata.gz: 16c197fb78685b2ed46fd7b3de1bc7ae6305a4da07afd118d3b986377cd03e414d363da8416c2951aed334ca1e35a267c9ba1f815ad7b352812a47312b5dbddb
-  data.tar.gz: 5f13f5dde1b91a2635c3f7db660fbbcb6e162053d5597db3e64db72ca780f095922d63e13da3475b1cb77a7c1bd7dab5d0cfafa70ed884e13237a58b1ed75809
+  metadata.gz: 21086756d157c20bd8f74fde996cabfc8c2a8975b913cab0da03a311d41eb3d44427e344419344e7d8729b21edf0c1d550732c583df8a1f2797b700b64468464
+  data.tar.gz: fd6dacfcb827ecbdf8d3d60cd1b9dfacd6f50fc9c4440100890fbac7302d26f8119da33f95b67c270c73b6f75789a7b5e569e04c638a834dce9ff99a5b2050a7

data/.rubocop.yml

@@ -6,8 +6,74 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 2.7
 
+  Exclude:
+    - ext/**/*.rb
+
 Layout/LineLength:
   Max: 120
 
+# Metrics
+
+Metrics/AbcSize:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Metrics/MethodLength:
+  Max: 15
+  Exclude:
+    - spec/**/*_spec.rb
+
+# Naming
+
+Naming/ClassAndModuleCamelCase:
+  Enabled: false
+
 Naming/VariableNumber:
   EnforcedStyle: snake_case
+  Exclude:
+    - spec/**/*.rb
+
+# Security
+
+# Allow URI.open for test vector downloads
+Security/Open:
+  Exclude:
+    - spec/sha3_digest_vectors_spec.rb
+
+# RSpec configuration
+
+RSpec/ExampleLength:
+  Max: 15
+  CountAsOne:
+    - array
+    - hash
+    - heredoc
+
+RSpec/MultipleExpectations:
+  Max: 8
+
+RSpec/SpecFilePathFormat:
+  Enabled: false
+
+RSpec/LeakyConstantDeclaration:
+  Enabled: false
+
+RSpec/BeforeAfterAll:
+  Enabled: false
+
+RSpec/MultipleDescribes:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+RSpec/DescribeClass:
+  Enabled: false

data/ext/sha3/common.h

@@ -0,0 +1,118 @@
+// Copyright (c) 2025 Johanns Gregorian <io+sha3@jsg.io>
+
+#ifndef _SHA3_COMMON_H_
+#define _SHA3_COMMON_H_
+
+#include <ruby.h>
+
+#include "sp800_185.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Common macros for SP800-185 based implementations (CSHAKE, KMAC) */
+
+/* Define a simple method that just calls an sp800_185 function */
+#define DEFINE_SP800_185_SIMPLE_METHOD(method_name, sp_func, get_ctx_func) \
+    static VALUE method_name(VALUE self, VALUE data) {                     \
+        sp800_185_context_t *context;                                      \
+        get_ctx_func(self, &context);                                      \
+        sp_func(context, data);                                            \
+        return self;                                                       \
+    }
+
+/* Define a method that returns a value from sp800_185 function */
+#define DEFINE_SP800_185_RETURN_METHOD(method_name, sp_func, get_ctx_func) \
+    static VALUE method_name(VALUE self) {                                 \
+        sp800_185_context_t *context;                                      \
+        get_ctx_func(self, &context);                                      \
+        return sp_func(context);                                           \
+    }
+
+/* Define a method with single VALUE parameter that returns VALUE */
+#define DEFINE_SP800_185_VALUE_METHOD(method_name, sp_func, get_ctx_func) \
+    static VALUE method_name(VALUE self, VALUE param) {                   \
+        sp800_185_context_t *context;                                     \
+        get_ctx_func(self, &context);                                     \
+        return sp_func(context, param);                                   \
+    }
+
+/* Define a method with variable arguments */
+#define DEFINE_SP800_185_VARARGS_METHOD(method_name, sp_func, get_ctx_func) \
+    static VALUE method_name(int argc, VALUE *argv, VALUE self) {           \
+        sp800_185_context_t *context;                                       \
+        get_ctx_func(self, &context);                                       \
+        VALUE param = argc > 0 ? argv[0] : Qnil;                            \
+        return sp_func(context, param);                                     \
+    }
+
+/* Define common memory management functions */
+#define DEFINE_SP800_185_MEMORY_FUNCS(prefix, context_type)                                              \
+    static void prefix##_free_context(void *ptr) { sp800_185_free_context((sp800_185_context_t *)ptr); } \
+                                                                                                         \
+    static size_t prefix##_context_size(const void *ptr) {                                               \
+        return sp800_185_context_size((const sp800_185_context_t *)ptr, sizeof(context_type));           \
+    }
+
+/* Define common allocation function */
+#define DEFINE_SP800_185_ALLOC(prefix, context_type, instance_type, error_class)                                      \
+    static VALUE rb_##prefix##_alloc(VALUE klass) {                                                                   \
+        context_type *context = (context_type *)sp800_185_alloc_context(sizeof(context_type), sizeof(instance_type)); \
+                                                                                                                      \
+        if (!context) {                                                                                               \
+            rb_raise(error_class, "failed to allocate memory");                                                       \
+        }                                                                                                             \
+                                                                                                                      \
+        VALUE obj = TypedData_Wrap_Struct(klass, &prefix##_data_type, context);                                       \
+        return obj;                                                                                                   \
+    }
+
+/* Define common copy method */
+#define DEFINE_SP800_185_COPY_METHOD(method_name, context_type, data_type, class_var)                    \
+    static VALUE method_name(VALUE self, VALUE other) {                                                  \
+        context_type *context, *other_context;                                                           \
+                                                                                                         \
+        rb_check_frozen(self);                                                                           \
+        if (self == other) {                                                                             \
+            return self;                                                                                 \
+        }                                                                                                \
+                                                                                                         \
+        if (!rb_obj_is_kind_of(other, class_var)) {                                                      \
+            rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", rb_obj_classname(other),       \
+                     rb_class2name(class_var));                                                          \
+        }                                                                                                \
+                                                                                                         \
+        TypedData_Get_Struct(other, context_type, &data_type, other_context);                            \
+        TypedData_Get_Struct(self, context_type, &data_type, context);                                   \
+                                                                                                         \
+        /* Copy the base context attributes */                                                           \
+        context->base.functions = other_context->base.functions;                                         \
+        context->base.output_length = other_context->base.output_length;                                 \
+        context->base.error_class = other_context->base.error_class;                                     \
+                                                                                                         \
+        /* Copy the algorithm-specific state */                                                          \
+        if (context->base.functions && other_context->base.state) {                                      \
+            memcpy(context->base.state, other_context->base.state, context->base.functions->state_size); \
+        }                                                                                                \
+                                                                                                         \
+        return self;                                                                                     \
+    }
+
+/* Ruby wrapper functions for SP800-185 operations */
+VALUE sp800_185_rb_update(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_rb_name(sp800_185_context_t *context);
+VALUE sp800_185_rb_finish(sp800_185_context_t *context, VALUE output);
+VALUE sp800_185_rb_digest(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_rb_hexdigest(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_rb_squeeze(sp800_185_context_t *context, VALUE length);
+VALUE sp800_185_rb_hex_squeeze(sp800_185_context_t *context, VALUE length);
+
+/* Helper function to register common methods */
+void register_sp800_185_common_methods(VALUE klass);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SHA3_COMMON_H_ */

data/ext/sha3/cshake.c

@@ -1,5 +1,6 @@
 #include "cshake.h"
 
+#include "common.h"
 #include "sha3.h"
 #include "sp800_185.h"
 
@@ -42,10 +43,9 @@ static ID _cshake_256_id;
 static const rb_data_type_t sha3_cshake_data_type = {
     "SHA3::CSHAKE",
     {
-        NULL,
-        sha3_cshake_free_context,  // Use our free function directly
-        sha3_cshake_context_size,  /* We'll do our own size calculation */
-        NULL,                      /* dcompact field */
+        NULL, sha3_cshake_free_context,  // Use our free function directly
+        sha3_cshake_context_size,        /* We'll do our own size calculation */
+        NULL,                            /* dcompact field */
     },
     NULL,
     NULL,
@@ -77,7 +77,7 @@ void Init_sha3_cshake(void) {
     /*
      * Document-class: SHA3::CSHAKE::Error
      *
-     * All KMAC methods raise this exception on error.
+     * All CSHAKE methods raise this exception on error.
      *
      * It is a subclass of the StandardError class -- see the Ruby documentation
      * for more information.
@@ -105,25 +105,11 @@ void Init_sha3_cshake(void) {
     return;
 }
 
-static void sha3_cshake_free_context(void *ptr) { sp800_185_free_context((sp800_185_context_t *)ptr); }
+/* Use common memory management functions */
+DEFINE_SP800_185_MEMORY_FUNCS(sha3_cshake, sha3_cshake_context_t)
 
-static size_t sha3_cshake_context_size(const void *ptr) {
-    return sp800_185_context_size((const sp800_185_context_t *)ptr, sizeof(sha3_cshake_context_t));
-}
-
-static VALUE rb_sha3_cshake_alloc(VALUE klass) {
-    sha3_cshake_context_t *context =
-        (sha3_cshake_context_t *)sp800_185_alloc_context(sizeof(sha3_cshake_context_t), sizeof(cSHAKE_Instance));
-
-    if (!context) {
-        rb_raise(_sha3_cshake_error_class, "failed to allocate memory");
-    }
-
-    // Create the Ruby object with TypedData - this will automatically handle freeing
-    VALUE obj = TypedData_Wrap_Struct(klass, &sha3_cshake_data_type, context);
-
-    return obj;
-}
+/* Use common allocation function */
+DEFINE_SP800_185_ALLOC(sha3_cshake, sha3_cshake_context_t, cSHAKE_Instance, _sha3_cshake_error_class)
 
 /*
  * :call-seq:
@@ -145,14 +131,14 @@ static VALUE rb_sha3_cshake_alloc(VALUE klass) {
  *   _optional_ The customization string to use
  *
  * = example
- *   # Initialize instance for fix-ed-length operation
+ *   # Initialize instance for fixed-length operation
  *   cshake = SHA3::CSHAKE.new(:cshake_128, 32, name: 'my-app')
  *   cshake << 'data...'
  *   cshake.hexdigest
  *
  *   # Initialize instance for XOF operation (arbitrary-long output)
  *   cshake = SHA3::CSHAKE.new(:cshake_256, 0, customization: 'Email Signature')
- *   cshask.update('data...')
+ *   cshake.update('data...')
  *   cshake.squeeze(64)
  */
 static VALUE rb_sha3_cshake_init(int argc, VALUE *argv, VALUE self) {
@@ -187,7 +173,7 @@ static VALUE rb_sha3_cshake_init(int argc, VALUE *argv, VALUE self) {
 
     VALUE customization = values[1] == Qundef ? rb_str_new2("") : values[1];
     StringValue(customization);
-    
+
     sha3_cshake_context_t *context;
     TypedData_Get_Struct(self, sha3_cshake_context_t, &sha3_cshake_data_type, context);
 
@@ -196,18 +182,24 @@ static VALUE rb_sha3_cshake_init(int argc, VALUE *argv, VALUE self) {
     context->base.error_class = _sha3_cshake_error_class;
 
     // Find the appropriate function table based on the algorithm
+    sp800_185_algorithm_t alg_type;
     if (algorithm == ID2SYM(_cshake_128_id)) {
-        context->base.functions = &sp800_185_functions[SP800_185_CSHAKE_128];
+        alg_type = SP800_185_CSHAKE_128;
     } else if (algorithm == ID2SYM(_cshake_256_id)) {
-        context->base.functions = &sp800_185_functions[SP800_185_CSHAKE_256];
+        alg_type = SP800_185_CSHAKE_256;
     } else {
         rb_raise(rb_eArgError, "invalid algorithm: %s", rb_id2name(SYM2ID(algorithm)));
     }
 
-    // Initialize the state using the function table
-    int result = context->base.functions->cshake.init(
-        context->base.state, context->base.output_length, (BitSequence *)RSTRING_PTR(name_str),
-        RSTRING_LEN(name_str) * 8, (BitSequence *)RSTRING_PTR(customization), RSTRING_LEN(customization) * 8);
+    context->base.functions = sp800_185_get_algorithm(alg_type);
+    if (!context->base.functions) {
+        rb_raise(_sha3_cshake_error_class, "algorithm not available");
+    }
+
+    // Initialize using the safe accessor function
+    int result = sp800_185_init_cshake(context->base.functions, context->base.state, context->base.output_length,
+                                       (BitSequence *)RSTRING_PTR(name_str), RSTRING_LEN(name_str) * 8,
+                                       (BitSequence *)RSTRING_PTR(customization), RSTRING_LEN(customization) * 8);
 
     if (result != 0) {
         rb_raise(_sha3_cshake_error_class, "failed to initialize %s algorithm", context->base.functions->name);
@@ -228,31 +220,7 @@ static VALUE rb_sha3_cshake_init(int argc, VALUE *argv, VALUE self) {
  * = example
  *  cshake2 = cshake.dup
  */
-static VALUE rb_sha3_cshake_copy(VALUE self, VALUE other) {
-    sha3_cshake_context_t *context, *other_context;
-
-    rb_check_frozen(self);
-    if (self == other) {
-        return self;
-    }
-
-    if (!rb_obj_is_kind_of(other, _sha3_cshake_class)) {
-        rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", rb_obj_classname(other),
-                 rb_class2name(_sha3_cshake_class));
-    }
-
-    TypedData_Get_Struct(other, sha3_cshake_context_t, &sha3_cshake_data_type, other_context);
-    TypedData_Get_Struct(self, sha3_cshake_context_t, &sha3_cshake_data_type, context);
-
-    // Copy the base context attributes
-    context->base.functions = other_context->base.functions;
-    context->base.output_length = other_context->base.output_length;
-
-    // Copy the algorithm-specific state
-    memcpy(context->base.state, other_context->base.state, context->base.functions->state_size);
-
-    return self;
-}
+DEFINE_SP800_185_COPY_METHOD(rb_sha3_cshake_copy, sha3_cshake_context_t, sha3_cshake_data_type, _sha3_cshake_class)
 
 /*
  * :call-seq:
@@ -267,13 +235,7 @@ static VALUE rb_sha3_cshake_copy(VALUE self, VALUE other) {
  *   cshake.update("more data")
  *   cshake << "more data"  # alias for update
  */
-static VALUE rb_sha3_cshake_update(VALUE self, VALUE data) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-    sp800_185_update(context, data);
-
-    return self;
-}
+DEFINE_SP800_185_SIMPLE_METHOD(rb_sha3_cshake_update, sp800_185_rb_update, get_cshake_context)
 
 /*
  * :call-seq:
@@ -281,12 +243,7 @@ static VALUE rb_sha3_cshake_update(VALUE self, VALUE data) {
  *
  * Returns the name of the CSHAKE instance.
  */
-static VALUE rb_sha3_cshake_name(VALUE self) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    return rb_str_new2(sp800_185_name(context));
-}
+DEFINE_SP800_185_RETURN_METHOD(rb_sha3_cshake_name, sp800_185_rb_name, get_cshake_context)
 
 /*
  * :call-seq:
@@ -300,13 +257,7 @@ static VALUE rb_sha3_cshake_name(VALUE self) {
  * = example
  *   cshake.finish
  */
-static VALUE rb_sha3_cshake_finish(int argc, VALUE *argv, VALUE self) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    VALUE output = argc > 0 ? argv[0] : Qnil;
-    return sp800_185_finish(context, output);
-}
+DEFINE_SP800_185_VARARGS_METHOD(rb_sha3_cshake_finish, sp800_185_rb_finish, get_cshake_context)
 
 /*
  * :call-seq:
@@ -321,14 +272,7 @@ static VALUE rb_sha3_cshake_finish(int argc, VALUE *argv, VALUE self) {
  *   cshake.digest
  *   cshake.digest("final chunk")
  */
-static VALUE rb_sha3_cshake_digest(int argc, VALUE *argv, VALUE self) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    VALUE data = argc > 0 ? argv[0] : Qnil;
-
-    return sp800_185_digest(context, data);
-}
+DEFINE_SP800_185_VARARGS_METHOD(rb_sha3_cshake_digest, sp800_185_rb_digest, get_cshake_context)
 
 /*
  * :call-seq:
@@ -343,14 +287,7 @@ static VALUE rb_sha3_cshake_digest(int argc, VALUE *argv, VALUE self) {
  *   cshake.hexdigest
  *   cshake.hexdigest("final chunk")
  */
-static VALUE rb_sha3_cshake_hexdigest(int argc, VALUE *argv, VALUE self) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    VALUE data = argc > 0 ? argv[0] : Qnil;
-
-    return sp800_185_hexdigest(context, data);
-}
+DEFINE_SP800_185_VARARGS_METHOD(rb_sha3_cshake_hexdigest, sp800_185_rb_hexdigest, get_cshake_context)
 
 /*
  * :call-seq:
@@ -364,12 +301,7 @@ static VALUE rb_sha3_cshake_hexdigest(int argc, VALUE *argv, VALUE self) {
  * = example
  *   cshake.squeeze(32)
  */
-static VALUE rb_sha3_cshake_squeeze(VALUE self, VALUE length) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    return sp800_185_squeeze(context, length);
-}
+DEFINE_SP800_185_VALUE_METHOD(rb_sha3_cshake_squeeze, sp800_185_rb_squeeze, get_cshake_context)
 
 /*
  * :call-seq:
@@ -383,9 +315,4 @@ static VALUE rb_sha3_cshake_squeeze(VALUE self, VALUE length) {
  * = example
  *   cshake.hex_squeeze(32)
  */
-static VALUE rb_sha3_cshake_hex_squeeze(VALUE self, VALUE length) {
-    sp800_185_context_t *context;
-    get_cshake_context(self, &context);
-
-    return sp800_185_hex_squeeze(context, length);
-}
+DEFINE_SP800_185_VALUE_METHOD(rb_sha3_cshake_hex_squeeze, sp800_185_rb_hex_squeeze, get_cshake_context)

data/ext/sha3/cshake.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2012 - 2025 Johanns Gregorian <io+sha3@jsg.io>
 
-#ifndef _SHA3_CSHAKE_H
-#define _SHA3_CSHAKE_H
+#ifndef _SHA3_CSHAKE_H_
+#define _SHA3_CSHAKE_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,4 +14,4 @@ void Init_sha3_cshake(void);
 }
 #endif
 
-#endif /* SHA3_CSHAKE_H */
+#endif /* _SHA3_CSHAKE_H_ */