sha3 2.1.0 → 2.2.0

data/ext/sha3/digest.c

@@ -22,32 +22,33 @@
 typedef enum { SHA3_224 = 0, SHA3_256, SHA3_384, SHA3_512, SHAKE_128, SHAKE_256 } sha3_digest_algorithms;
 
 typedef struct {
-    Keccak_HashInstance* state;
+    Keccak_HashInstance *state;
     int hashbitlen;
     sha3_digest_algorithms algorithm;
 } sha3_digest_context_t;
 
-typedef HashReturn (*keccak_init_func)(Keccak_HashInstance*);
+typedef HashReturn (*keccak_init_func)(Keccak_HashInstance *);
 
 /*** Function prototypes ***/
 
-static int compare_contexts(const sha3_digest_context_t*, const sha3_digest_context_t*);
-static inline void get_sha3_digest_context(VALUE, sha3_digest_context_t**);
-static inline void safe_get_sha3_digest_context(VALUE, sha3_digest_context_t**);
+static int compare_contexts(const sha3_digest_context_t *, const sha3_digest_context_t *);
+static inline void get_sha3_digest_context(VALUE, sha3_digest_context_t **);
+static inline void safe_get_sha3_digest_context(VALUE, sha3_digest_context_t **);
+static inline int is_shake_algorithm(sha3_digest_algorithms);
 
-static int get_hashbit_length(VALUE, sha3_digest_algorithms*);
-static HashReturn keccak_hash_initialize(sha3_digest_context_t*);
+static int get_hashbit_length(VALUE, sha3_digest_algorithms *);
+static HashReturn keccak_hash_initialize(sha3_digest_context_t *);
 
-static void sha3_digest_free_context(void*);
-static size_t sha3_digest_context_size(const void*);
+static void sha3_digest_free_context(void *);
+static size_t sha3_digest_context_size(const void *);
 
 /* Allocation and initialization */
 static VALUE rb_sha3_digest_alloc(VALUE);
-static VALUE rb_sha3_digest_init(int, VALUE*, VALUE);
+static VALUE rb_sha3_digest_init(int, VALUE *, VALUE);
 static VALUE rb_sha3_digest_copy(VALUE, VALUE);
 
 /* Core digest operations */
-static VALUE rb_sha3_digest_finish(int, VALUE*, VALUE);
+static VALUE rb_sha3_digest_finish(int, VALUE *, VALUE);
 static VALUE rb_sha3_digest_reset(VALUE);
 static VALUE rb_sha3_digest_update(VALUE, VALUE);
 
@@ -57,8 +58,8 @@ static VALUE rb_sha3_digest_length(VALUE);
 static VALUE rb_sha3_digest_name(VALUE);
 
 /* Output methods */
-static VALUE rb_sha3_digest_digest(int, VALUE*, VALUE);
-static VALUE rb_sha3_digest_hexdigest(int, VALUE*, VALUE);
+static VALUE rb_sha3_digest_digest(int, VALUE *, VALUE);
+static VALUE rb_sha3_digest_hexdigest(int, VALUE *, VALUE);
 static VALUE rb_sha3_digest_hex_squeeze(VALUE, VALUE);
 static VALUE rb_sha3_digest_squeeze(VALUE, VALUE);
 static VALUE rb_sha3_digest_self_digest(VALUE, VALUE, VALUE);
@@ -109,12 +110,12 @@ void Init_sha3_digest(void) {
      *
      * It is a subclass of the Digest::Class class, which provides a framework for
      * creating and manipulating hash digest. Supported Algorithms are:
-     * - SHA3-224
-     * - SHA3-256
-     * - SHA3-384
-     * - SHA3-512
-     * - SHAKE128
-     * - SHAKE256
+     * - SHA3-224 (:sha3_224)
+     * - SHA3-256 (:sha3_256)
+     * - SHA3-384 (:sha3_384)
+     * - SHA3-512 (:sha3_512)
+     * - SHAKE128 (:shake_128)
+     * - SHAKE256 (:shake_256)
      */
     _sha3_digest_class = rb_define_class_under(_sha3_module, "Digest", rb_path2class("Digest::Class"));
 
@@ -126,7 +127,7 @@ void Init_sha3_digest(void) {
      * It is a subclass of the StandardError class -- see the Ruby documentation
      * for more information.
      */
-    _sha3_digest_error_class = rb_define_class_under(_sha3_digest_class, "DigestError", rb_eStandardError);
+    _sha3_digest_error_class = rb_define_class_under(_sha3_digest_class, "Error", rb_eStandardError);
 
     rb_define_alloc_func(_sha3_digest_class, rb_sha3_digest_alloc);
     rb_define_method(_sha3_digest_class, "initialize", rb_sha3_digest_init, -1);
@@ -152,14 +153,14 @@ void Init_sha3_digest(void) {
 }
 
 // Static inline functions replacing macros
-static inline void get_sha3_digest_context(VALUE obj, sha3_digest_context_t** context) {
+static inline void get_sha3_digest_context(VALUE obj, sha3_digest_context_t **context) {
     TypedData_Get_Struct((obj), sha3_digest_context_t, &sha3_digest_data_type_t, (*context));
     if (!(*context)) {
         rb_raise(rb_eRuntimeError, "Digest data not initialized!");
     }
 }
 
-static inline void safe_get_sha3_digest_context(VALUE obj, sha3_digest_context_t** context) {
+static inline void safe_get_sha3_digest_context(VALUE obj, sha3_digest_context_t **context) {
     if (!rb_obj_is_kind_of(obj, _sha3_digest_class)) {
         rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", rb_obj_classname(obj),
                  rb_class2name(_sha3_digest_class));
@@ -167,7 +168,9 @@ static inline void safe_get_sha3_digest_context(VALUE obj, sha3_digest_context_t
     get_sha3_digest_context(obj, context);
 }
 
-int get_hashbit_length(VALUE obj, sha3_digest_algorithms* algorithm) {
+static inline int is_shake_algorithm(sha3_digest_algorithms alg) { return alg == SHAKE_128 || alg == SHAKE_256; }
+
+int get_hashbit_length(VALUE obj, sha3_digest_algorithms *algorithm) {
     if (TYPE(obj) == T_SYMBOL) {
         ID symid = SYM2ID(obj);
 
@@ -191,17 +194,18 @@ int get_hashbit_length(VALUE obj, sha3_digest_algorithms* algorithm) {
             return 256;
         }
 
-        rb_raise(_sha3_digest_error_class,
+        rb_raise(rb_eArgError,
                  "invalid hash algorithm symbol (should be: :sha3_224, "
                  ":sha3_256, :sha3_384, :sha3_512, :shake_128, or :shake_256)");
     }
 
     rb_raise(_sha3_digest_error_class, "unknown type value");
+
     return 0;  // Never reached, but silences compiler warnings
 }
 
-static void sha3_digest_free_context(void* ptr) {
-    sha3_digest_context_t* context = (sha3_digest_context_t*)ptr;
+static void sha3_digest_free_context(void *ptr) {
+    sha3_digest_context_t *context = (sha3_digest_context_t *)ptr;
     if (context) {
         if (context->state) {
             free(context->state);
@@ -210,8 +214,8 @@ static void sha3_digest_free_context(void* ptr) {
     }
 }
 
-static size_t sha3_digest_context_size(const void* ptr) {
-    const sha3_digest_context_t* context = (const sha3_digest_context_t*)ptr;
+static size_t sha3_digest_context_size(const void *ptr) {
+    const sha3_digest_context_t *context = (const sha3_digest_context_t *)ptr;
     size_t size = sizeof(sha3_digest_context_t);
 
     if (context && context->state) {
@@ -221,7 +225,7 @@ static size_t sha3_digest_context_size(const void* ptr) {
     return size;
 }
 
-static HashReturn keccak_hash_initialize(sha3_digest_context_t* context) {
+static HashReturn keccak_hash_initialize(sha3_digest_context_t *context) {
     switch (context->algorithm) {
         case SHA3_224:
             return Keccak_HashInitialize_SHA3_224(context->state);
@@ -241,12 +245,12 @@ static HashReturn keccak_hash_initialize(sha3_digest_context_t* context) {
 }
 
 static VALUE rb_sha3_digest_alloc(VALUE klass) {
-    sha3_digest_context_t* context = (sha3_digest_context_t*)malloc(sizeof(sha3_digest_context_t));
+    sha3_digest_context_t *context = (sha3_digest_context_t *)malloc(sizeof(sha3_digest_context_t));
     if (!context) {
         rb_raise(_sha3_digest_error_class, "failed to allocate object memory");
     }
 
-    context->state = (Keccak_HashInstance*)calloc(1, sizeof(Keccak_HashInstance));
+    context->state = (Keccak_HashInstance *)calloc(1, sizeof(Keccak_HashInstance));
     if (!context->state) {
         sha3_digest_free_context(context);
         rb_raise(_sha3_digest_error_class, "failed to allocate state memory");
@@ -283,8 +287,8 @@ static VALUE rb_sha3_digest_alloc(VALUE klass) {
  *   SHA3::Digest.new(:sha3_256)
  *   SHA3::Digest.new(:shake_128, "initial data")
  */
-static VALUE rb_sha3_digest_init(int argc, VALUE* argv, VALUE self) {
-    sha3_digest_context_t* context;
+static VALUE rb_sha3_digest_init(int argc, VALUE *argv, VALUE self) {
+    sha3_digest_context_t *context;
     VALUE hlen, data;
 
     rb_scan_args(argc, argv, "02", &hlen, &data);
@@ -322,7 +326,7 @@ static VALUE rb_sha3_digest_init(int argc, VALUE* argv, VALUE self) {
  *   digest << "more data"  # alias for update
  */
 static VALUE rb_sha3_digest_update(VALUE self, VALUE data) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     BitLength dlen;
 
     StringValue(data);
@@ -340,7 +344,7 @@ static VALUE rb_sha3_digest_update(VALUE self, VALUE data) {
 
     dlen = (RSTRING_LEN(data) * 8);
 
-    if (Keccak_HashUpdate(context->state, (BitSequence*)RSTRING_PTR(data), dlen) != KECCAK_SUCCESS) {
+    if (Keccak_HashUpdate(context->state, (BitSequence *)RSTRING_PTR(data), dlen) != KECCAK_SUCCESS) {
         rb_raise(_sha3_digest_error_class, "failed to update hash data");
     }
 
@@ -357,7 +361,7 @@ static VALUE rb_sha3_digest_update(VALUE self, VALUE data) {
  *   digest.reset
  */
 static VALUE rb_sha3_digest_reset(VALUE self) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     memset(context->state, 0, sizeof(Keccak_HashInstance));
@@ -369,7 +373,7 @@ static VALUE rb_sha3_digest_reset(VALUE self) {
     return self;
 }
 
-static int compare_contexts(const sha3_digest_context_t* context1, const sha3_digest_context_t* context2) {
+static int compare_contexts(const sha3_digest_context_t *context1, const sha3_digest_context_t *context2) {
     // First check the hashbitlen and algorithm
     if (context1->hashbitlen != context2->hashbitlen || context1->algorithm != context2->algorithm) {
         return 0;
@@ -411,8 +415,8 @@ static int compare_contexts(const sha3_digest_context_t* context1, const sha3_di
  *   new_digest = digest.dup
  */
 static VALUE rb_sha3_digest_copy(VALUE self, VALUE other) {
-    sha3_digest_context_t* context;
-    sha3_digest_context_t* other_context;
+    sha3_digest_context_t *context;
+    sha3_digest_context_t *other_context;
 
     rb_check_frozen(self);
     if (self == other) {
@@ -448,7 +452,7 @@ static VALUE rb_sha3_digest_copy(VALUE self, VALUE other) {
  *   digest.length  #=> 32 for SHA3-256
  */
 static VALUE rb_sha3_digest_length(VALUE self) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     return ULL2NUM(context->hashbitlen / 8);
@@ -464,7 +468,7 @@ static VALUE rb_sha3_digest_length(VALUE self) {
  *   digest.block_length
  */
 static VALUE rb_sha3_digest_block_length(VALUE self) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     return ULL2NUM(200 - (2 * (context->hashbitlen / 8)));
@@ -480,7 +484,7 @@ static VALUE rb_sha3_digest_block_length(VALUE self) {
  *   digest.name  #=> "SHA3-256"
  */
 static VALUE rb_sha3_digest_name(VALUE self) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     switch (context->algorithm) {
@@ -514,8 +518,8 @@ static VALUE rb_sha3_digest_name(VALUE self) {
  *   digest.finish
  *   digest.finish("final chunk")
  */
-static VALUE rb_sha3_digest_finish(int argc, VALUE* argv, VALUE self) {
-    sha3_digest_context_t* context;
+static VALUE rb_sha3_digest_finish(int argc, VALUE *argv, VALUE self) {
+    sha3_digest_context_t *context;
     VALUE str;
     int digest_bytes;
 
@@ -533,7 +537,7 @@ static VALUE rb_sha3_digest_finish(int argc, VALUE* argv, VALUE self) {
         rb_str_resize(str, digest_bytes);
     }
 
-    if (Keccak_HashFinal(context->state, (BitSequence*)RSTRING_PTR(str)) != KECCAK_SUCCESS) {
+    if (Keccak_HashFinal(context->state, (BitSequence *)RSTRING_PTR(str)) != KECCAK_SUCCESS) {
         rb_raise(_sha3_digest_error_class, "failed to finalize digest");
     }
 
@@ -554,7 +558,7 @@ static VALUE rb_sha3_digest_finish(int argc, VALUE* argv, VALUE self) {
  *   digest.squeeze(32)  # Get 32 bytes of output
  */
 static VALUE rb_sha3_digest_squeeze(VALUE self, VALUE length) {
-    sha3_digest_context_t* context;
+    sha3_digest_context_t *context;
     VALUE str, copy;
     int output_bytes;
 
@@ -568,7 +572,7 @@ static VALUE rb_sha3_digest_squeeze(VALUE self, VALUE length) {
     get_sha3_digest_context(self, &context);
 
     // Only SHAKE algorithms support arbitrary-length output
-    if (context->algorithm != SHAKE_128 && context->algorithm != SHAKE_256) {
+    if (!is_shake_algorithm(context->algorithm)) {
         rb_raise(_sha3_digest_error_class, "squeeze is only supported for SHAKE algorithms");
     }
 
@@ -576,7 +580,7 @@ static VALUE rb_sha3_digest_squeeze(VALUE self, VALUE length) {
     copy = rb_obj_clone(self);
 
     // Get the sha3_digest_context_t struct from the copy
-    sha3_digest_context_t* context_copy;
+    sha3_digest_context_t *context_copy;
     get_sha3_digest_context(copy, &context_copy);
 
     str = rb_str_new(0, output_bytes);
@@ -587,7 +591,7 @@ static VALUE rb_sha3_digest_squeeze(VALUE self, VALUE length) {
     }
 
     // Then squeeze out the desired number of bytes
-    if (Keccak_HashSqueeze(context_copy->state, (BitSequence*)RSTRING_PTR(str), output_bytes * 8) != KECCAK_SUCCESS) {
+    if (Keccak_HashSqueeze(context_copy->state, (BitSequence *)RSTRING_PTR(str), output_bytes * 8) != KECCAK_SUCCESS) {
         rb_raise(_sha3_digest_error_class, "failed to squeeze output");
     }
 
@@ -614,6 +618,26 @@ static VALUE rb_sha3_digest_hex_squeeze(VALUE self, VALUE length) {
     return rb_funcall(bin_str, rb_intern("unpack1"), 1, rb_str_new2("H*"));
 }
 
+static VALUE prepare_shake_output(VALUE self, int argc, VALUE *argv, int hex_output) {
+    sha3_digest_context_t *context;
+    VALUE length, data;
+
+    get_sha3_digest_context(self, &context);
+    rb_scan_args(argc, argv, "02", &length, &data);
+
+    if (NIL_P(length)) {
+        rb_raise(_sha3_digest_error_class, "output length must be specified for SHAKE algorithms");
+    }
+
+    Check_Type(length, T_FIXNUM);
+
+    if (!NIL_P(data)) {
+        rb_sha3_digest_update(self, data);
+    }
+
+    return hex_output ? rb_sha3_digest_hex_squeeze(self, length) : rb_sha3_digest_squeeze(self, length);
+}
+
 /*
  * :call-seq:
  *   digest() -> string
@@ -636,31 +660,15 @@ static VALUE rb_sha3_digest_hex_squeeze(VALUE self, VALUE length) {
  *   digest.digest(12)  # For SHAKE algorithms
  *   digest.digest(12, 'compute me')  # For SHAKE algorithms
  */
-static VALUE rb_sha3_digest_digest(int argc, VALUE* argv, VALUE self) {
-    sha3_digest_context_t* context;
+static VALUE rb_sha3_digest_digest(int argc, VALUE *argv, VALUE self) {
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     if (context->algorithm != SHAKE_128 && context->algorithm != SHAKE_256) {
         return rb_call_super(argc, argv);
     }
 
-    VALUE length, data;
-    rb_scan_args(argc, argv, "02", &length, &data);
-
-    // For SHAKE algorithms
-    if (NIL_P(length)) {
-        rb_raise(_sha3_digest_error_class, "output length must be specified for SHAKE algorithms");
-    }
-
-    // Add type checking for length
-    Check_Type(length, T_FIXNUM);
-
-    // If data is provided, update the state before squeezing
-    if (!NIL_P(data)) {
-        rb_sha3_digest_update(self, data);
-    }
-
-    return rb_sha3_digest_squeeze(self, length);
+    return prepare_shake_output(self, argc, argv, 0);
 }
 
 /*
@@ -685,30 +693,15 @@ static VALUE rb_sha3_digest_digest(int argc, VALUE* argv, VALUE self) {
  *   digest.hexdigest(12)  # For SHAKE algorithms
  *   digest.hexdigest(12, 'compute me')  # For SHAKE algorithms
  */
-static VALUE rb_sha3_digest_hexdigest(int argc, VALUE* argv, VALUE self) {
-    sha3_digest_context_t* context;
+static VALUE rb_sha3_digest_hexdigest(int argc, VALUE *argv, VALUE self) {
+    sha3_digest_context_t *context;
     get_sha3_digest_context(self, &context);
 
     if (context->algorithm != SHAKE_128 && context->algorithm != SHAKE_256) {
         return rb_call_super(argc, argv);
     }
 
-    VALUE length, data;
-    rb_scan_args(argc, argv, "02", &length, &data);
-
-    if (NIL_P(length)) {
-        rb_raise(_sha3_digest_error_class, "output length must be specified for SHAKE algorithms");
-    }
-
-    // Add type checking for length
-    Check_Type(length, T_FIXNUM);
-
-    // If data is provided, update the state before squeezing
-    if (!NIL_P(data)) {
-        rb_sha3_digest_update(self, data);
-    }
-
-    return rb_sha3_digest_hex_squeeze(self, length);
+    return prepare_shake_output(self, argc, argv, 1);
 }
 
 /*
@@ -738,6 +731,17 @@ static VALUE rb_sha3_digest_hexdigest(int argc, VALUE* argv, VALUE self) {
  * To squeeze a different length, use #squeeze instance method.
  */
 static VALUE rb_sha3_digest_self_digest(VALUE klass, VALUE name, VALUE data) {
+    // Add null checks
+    if (NIL_P(name) || NIL_P(data)) {
+        rb_raise(_sha3_digest_error_class, "algorithm name and data cannot be nil");
+    }
+
+    // Add type validation for name
+    if (TYPE(name) != T_SYMBOL) {
+        rb_raise(_sha3_digest_error_class, "algorithm name must be a symbol");
+    }
+
+    // Existing code...
     VALUE args[2];
 
     // Need to add type checking for the data parameter

data/ext/sha3/digest.h

@@ -1,10 +1,7 @@
 // Copyright (c) 2012 - 2025 Johanns Gregorian <io+sha3@jsg.io>
 
-#ifndef _DIGEST_H_
-#define _DIGEST_H_
-
-#include <ruby.h>
-#include <ruby/encoding.h>
+#ifndef _SHA3_DIGEST_H_
+#define _SHA3_DIGEST_H_
 
 #ifdef __cplusplus
 extern "C" {

data/ext/sha3/extconf.rb

@@ -12,6 +12,9 @@ dir_config(extension_name)
 # Set compiler flags
 $CFLAGS << ' -fomit-frame-pointer -O3 -g0 -fms-extensions'
 
+# Add vectorization flags for better performance on supported platforms
+$CFLAGS << ' -ftree-vectorize' if RUBY_PLATFORM =~ /x86_64|amd64|arm64/
+
 # Add architecture-specific optimizations if enabled
 $CFLAGS << ' -march=native' if enable_config('march-tune-native', false)
 
@@ -21,9 +24,6 @@ $CFLAGS << ' -D_FORTIFY_SOURCE=2 -fstack-protector-strong'
 # Add warning flags to catch potential issues
 $CFLAGS << ' -Wall -Wextra -Wformat -Wformat-security'
 
-# Add vectorization flags for better performance on supported platforms
-$CFLAGS << ' -ftree-vectorize' if RUBY_PLATFORM =~ /x86_64|amd64|arm64/
-
 # Find all relevant subdirectories and filter appropriately
 vpath_dirs = Dir.glob("#{$srcdir}/lib/**/*")
                 .select { |path| File.directory?(path) }
@@ -42,8 +42,14 @@ $INCFLAGS << vpath_dirs_processed
              .map { |dir| " -I$(srcdir)#{dir}" }
              .join
 
-# Base source files
-$srcs = ['digest.c', 'kmac.c', 'sha3.c']
+# Define source files
+$srcs = %w[
+  cshake.c
+  digest.c
+  kmac.c
+  sha3.c
+  sp800_185.c
+]
 
 # Find and add all .c files from the filtered directories
 $srcs += vpath_dirs