sha3 2.1.0 → 2.2.0

data/ext/sha3/sp800_185.c

@@ -0,0 +1,311 @@
+#include "sp800_185.h"
+
+#include "sha3.h"
+
+/*** Function table for SP800-185 algorithms ***/
+sp800_185_function_table_t sp800_185_functions[] = {{.algorithm = SP800_185_CSHAKE_128,
+                                                     .name = "CSHAKE128",
+                                                     .state_size = sizeof(cSHAKE_Instance),
+                                                     .cshake = {.init = (sp800_185_init_fn)cSHAKE128_Initialize,
+                                                                .update = (sp800_185_update_fn)cSHAKE128_Update,
+                                                                .final = (sp800_185_final_fn)cSHAKE128_Final,
+                                                                .squeeze = (sp800_185_squeeze_fn)cSHAKE128_Squeeze}},
+                                                    {.algorithm = SP800_185_CSHAKE_256,
+                                                     .name = "CSHAKE256",
+                                                     .state_size = sizeof(cSHAKE_Instance),
+                                                     .cshake = {.init = (sp800_185_init_fn)cSHAKE256_Initialize,
+                                                                .update = (sp800_185_update_fn)cSHAKE256_Update,
+                                                                .final = (sp800_185_final_fn)cSHAKE256_Final,
+                                                                .squeeze = (sp800_185_squeeze_fn)cSHAKE256_Squeeze}},
+                                                    {.algorithm = SP800_185_KMAC_128,
+                                                     .name = "KMAC128",
+                                                     .state_size = sizeof(KMAC_Instance),
+                                                     .kmac = {.init = (sp800_185_init_key_fn)KMAC128_Initialize,
+                                                              .update = (sp800_185_update_fn)KMAC128_Update,
+                                                              .final = (sp800_185_final_fn)KMAC128_Final,
+                                                              .squeeze = (sp800_185_squeeze_fn)KMAC128_Squeeze}},
+                                                    {.algorithm = SP800_185_KMAC_256,
+                                                     .name = "KMAC256",
+                                                     .state_size = sizeof(KMAC_Instance),
+                                                     .kmac = {.init = (sp800_185_init_key_fn)KMAC256_Initialize,
+                                                              .update = (sp800_185_update_fn)KMAC256_Update,
+                                                              .final = (sp800_185_final_fn)KMAC256_Final,
+                                                              .squeeze = (sp800_185_squeeze_fn)KMAC256_Squeeze}}};
+
+// Generic context allocation function
+sp800_185_context_t *sp800_185_alloc_context(size_t context_size, size_t state_size) {
+    sp800_185_context_t *context = (sp800_185_context_t *)malloc(context_size);
+    if (!context) return NULL;
+
+    context->state = calloc(1, state_size);
+    if (!context->state) {
+        free(context);
+        return NULL;
+    }
+
+    context->error_class = Qnil;  // Initialize error class to nil
+
+    return context;
+}
+
+// Generic context freeing function
+void sp800_185_free_context(sp800_185_context_t *context) {
+    if (context) {
+        if (context->state) {
+            free(context->state);
+        }
+        free(context);
+    }
+}
+
+// Generic context size function
+size_t sp800_185_context_size(const sp800_185_context_t *context, size_t struct_size) {
+    size_t size = struct_size;
+    if (context && context->functions) {
+        size += context->functions->state_size;
+    }
+    return size;
+}
+
+// Generic state copy function
+void *sp800_185_copy_state(sp800_185_context_t *context) {
+    if (context->functions->state_size <= 0) {
+        rb_raise(context->error_class, "invalid state size");
+    }
+    void *state_copy = malloc(context->functions->state_size);
+
+    if (!state_copy) {
+        rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
+    }
+
+    memcpy(state_copy, context->state, context->functions->state_size);
+
+    return state_copy;
+}
+
+VALUE sp800_185_update(sp800_185_context_t *context, VALUE data) {
+    StringValue(data);
+    size_t data_len = (RSTRING_LEN(data) * 8);
+
+    if (data_len == 0) {
+        return Qnil;
+    }
+
+    // Use the function table to call the appropriate update function
+    int result;
+
+    // KMAC, cSHAKE, and ParallelHash share the same update function signature
+    switch (context->functions->algorithm) {
+        case SP800_185_CSHAKE_128:
+        case SP800_185_CSHAKE_256:
+            result =
+                context->functions->cshake.update(context->state, (const BitSequence *)RSTRING_PTR(data), data_len);
+            break;
+        case SP800_185_KMAC_128:
+        case SP800_185_KMAC_256:
+            result = context->functions->kmac.update(context->state, (const BitSequence *)RSTRING_PTR(data), data_len);
+            break;
+        default:
+            rb_raise(context->error_class, "unknown algorithm");
+            return Qnil;
+    }
+
+    if (result != 0) {
+        rb_raise(context->error_class, "failed to update %s state", context->functions->name);
+    }
+
+    return Qnil;
+}
+
+VALUE sp800_185_finish(sp800_185_context_t *context, VALUE output) {
+    // Create a new string if output isn't provided
+    if (NIL_P(output)) {
+        output = rb_str_new(0, context->output_length / 8);
+    } else {
+        StringValue(output);
+        rb_str_resize(output, context->output_length / 8);
+    }
+
+    // Use the function table to call the appropriate final function
+    int result;
+
+    switch (context->functions->algorithm) {
+        case SP800_185_CSHAKE_128:
+        case SP800_185_CSHAKE_256:
+            result = context->functions->cshake.final(context->state, (BitSequence *)RSTRING_PTR(output));
+            break;
+        case SP800_185_KMAC_128:
+        case SP800_185_KMAC_256:
+            result = context->functions->kmac.final(context->state, (BitSequence *)RSTRING_PTR(output));
+            break;
+        default:
+            rb_raise(context->error_class, "unknown algorithm");
+            return Qnil;
+    }
+
+    if (result != 0) {
+        rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
+    }
+
+    return output;
+}
+
+const char *sp800_185_name(sp800_185_context_t *context) { return context->functions->name; }
+
+VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data) {
+    if (context->output_length == 0) {
+        rb_raise(context->error_class, "use squeeze methods for arbitrary length output");
+    }
+
+    // Create a copy of the state for processing
+    void *state_copy = malloc(context->functions->state_size);
+    if (!state_copy) {
+        rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
+    }
+
+    memcpy(state_copy, context->state, context->functions->state_size);
+
+    int result;
+
+    // If data is provided, update the copy
+    if (!NIL_P(data)) {
+        StringValue(data);
+        size_t data_len = (RSTRING_LEN(data) * 8);
+
+        if (data_len > 0) {
+            switch (context->functions->algorithm) {
+                case SP800_185_CSHAKE_128:
+                case SP800_185_CSHAKE_256:
+                    result =
+                        context->functions->cshake.update(state_copy, (const BitSequence *)RSTRING_PTR(data), data_len);
+                    break;
+                case SP800_185_KMAC_128:
+                case SP800_185_KMAC_256:
+                    result =
+                        context->functions->kmac.update(state_copy, (const BitSequence *)RSTRING_PTR(data), data_len);
+                    break;
+                default:
+                    free(state_copy);
+                    rb_raise(context->error_class, "unknown algorithm");
+                    return Qnil;
+            }
+
+            if (result != 0) {
+                free(state_copy);
+                rb_raise(context->error_class, "failed to update %s state", context->functions->name);
+            }
+        }
+    }
+
+    // Prepare output and finalize
+    VALUE output = rb_str_new(0, context->output_length / 8);
+
+    switch (context->functions->algorithm) {
+        case SP800_185_CSHAKE_128:
+        case SP800_185_CSHAKE_256:
+            result = context->functions->cshake.final(state_copy, (BitSequence *)RSTRING_PTR(output));
+            break;
+        case SP800_185_KMAC_128:
+        case SP800_185_KMAC_256:
+            result = context->functions->kmac.final(state_copy, (BitSequence *)RSTRING_PTR(output));
+            break;
+        default:
+            free(state_copy);
+            rb_raise(context->error_class, "unknown algorithm");
+            return Qnil;
+    }
+
+    free(state_copy);
+
+    if (result != 0) {
+        rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
+    }
+
+    return output;
+}
+
+VALUE sp800_185_hexdigest(sp800_185_context_t *context, VALUE data) {
+    VALUE bin_str = sp800_185_digest(context, data);
+    return rb_funcall(bin_str, rb_intern("unpack1"), 1, rb_str_new2("H*"));
+}
+
+VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
+    if (context->output_length != 0) {
+        rb_raise(context->error_class, "use digest methods for fixed-length output");
+    }
+
+    size_t output_byte_len;
+    VALUE str;
+
+    Check_Type(length, T_FIXNUM);
+    output_byte_len = NUM2ULONG(length);
+
+    if (output_byte_len <= 0) {
+        rb_raise(context->error_class, "output length must be specified");
+    }
+
+    // Create a copy of the state for processing
+    void *state_copy = malloc(context->functions->state_size);
+    if (!state_copy) {
+        rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
+    }
+
+    memcpy(state_copy, context->state, context->functions->state_size);
+
+    // First transition the state to FINAL
+    VALUE dummy_output = rb_str_new(0, 0);
+    int result;
+
+    switch (context->functions->algorithm) {
+        case SP800_185_CSHAKE_128:
+        case SP800_185_CSHAKE_256:
+            result = context->functions->cshake.final(state_copy, (BitSequence *)RSTRING_PTR(dummy_output));
+            break;
+        case SP800_185_KMAC_128:
+        case SP800_185_KMAC_256:
+            result = context->functions->kmac.final(state_copy, (BitSequence *)RSTRING_PTR(dummy_output));
+            break;
+        default:
+            free(state_copy);
+            rb_raise(context->error_class, "unknown algorithm");
+            return Qnil;
+    }
+
+    if (result != 0) {
+        free(state_copy);
+        rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
+    }
+
+    // Allocate the output buffer for the specified number of bytes
+    str = rb_str_new(0, output_byte_len);
+
+    // Use the function table to call the appropriate squeeze function
+    switch (context->functions->algorithm) {
+        case SP800_185_CSHAKE_128:
+        case SP800_185_CSHAKE_256:
+            result =
+                context->functions->cshake.squeeze(state_copy, (BitSequence *)RSTRING_PTR(str), output_byte_len * 8);
+            break;
+        case SP800_185_KMAC_128:
+        case SP800_185_KMAC_256:
+            result = context->functions->kmac.squeeze(state_copy, (BitSequence *)RSTRING_PTR(str), output_byte_len * 8);
+            break;
+        default:
+            free(state_copy);
+            rb_raise(context->error_class, "unknown algorithm");
+            return Qnil;
+    }
+
+    free(state_copy);
+
+    if (result != 0) {
+        rb_raise(context->error_class, "failed to squeeze %s", context->functions->name);
+    }
+
+    return str;
+}
+
+VALUE sp800_185_hex_squeeze(sp800_185_context_t *context, VALUE length) {
+    VALUE binary_result = sp800_185_squeeze(context, length);
+    return rb_funcall(binary_result, rb_intern("unpack1"), 1, rb_str_new2("H*"));
+}

data/ext/sha3/sp800_185.h

@@ -0,0 +1,94 @@
+#ifndef _SHA3_SP800_185_H_
+#define _SHA3_SP800_185_H_
+
+#include <ruby.h>
+#include <ruby/thread.h>
+
+#include "KeccakHash.h"
+#include "SP800-185.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* SP800-185 algorithm family */
+typedef enum {
+    SP800_185_CSHAKE_128 = 0,
+    SP800_185_CSHAKE_256,
+    SP800_185_KMAC_128,
+    SP800_185_KMAC_256,
+} sp800_185_algorithm_t;
+
+/* Common function pointer typedefs for SP800-185 algorithms */
+typedef int (*sp800_185_init_fn)(void *state, size_t capacity, const BitSequence *N, size_t NLen, const BitSequence *S,
+                                 size_t SLen);
+
+typedef int (*sp800_185_init_key_fn)(void *state, const BitSequence *key, BitLength keyBitLen, BitLength outputBitLen,
+                                     const BitSequence *customization, BitLength customBitLen);
+
+typedef int (*sp800_185_update_fn)(void *state, const BitSequence *data, size_t dataLen);
+typedef int (*sp800_185_final_fn)(void *state, BitSequence *output);
+typedef int (*sp800_185_squeeze_fn)(void *state, BitSequence *output, size_t outputLen);
+
+/* Function table for SP800-185 algorithm operations */
+typedef struct {
+    sp800_185_algorithm_t algorithm;
+    const char *name;
+    size_t state_size;
+
+    union {
+        struct {
+            sp800_185_init_fn init;
+            sp800_185_update_fn update;
+            sp800_185_final_fn final;
+            sp800_185_squeeze_fn squeeze;
+        } cshake;
+
+        struct {
+            sp800_185_init_key_fn init;
+            sp800_185_update_fn update;
+            sp800_185_final_fn final;
+            sp800_185_squeeze_fn squeeze;
+        } kmac;
+    };
+} sp800_185_function_table_t;
+
+/* Base context structure for SP800-185 algorithms */
+typedef struct {
+    void *state;
+    const sp800_185_function_table_t *functions;
+    size_t output_length;
+    VALUE error_class;
+} sp800_185_context_t;
+
+/* Global variables */
+extern sp800_185_function_table_t sp800_185_functions[];
+
+extern sp800_185_context_t *sp800_185_alloc_context(size_t, size_t);
+extern size_t sp800_185_context_size(const sp800_185_context_t *, size_t);
+extern void sp800_185_free_context(sp800_185_context_t *);
+
+/* Helper functions - these are now internal C functions with an additional context parameter */
+VALUE sp800_185_update(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_hexdigest(sp800_185_context_t *context, VALUE data);
+VALUE sp800_185_finish(sp800_185_context_t *context, VALUE output);
+VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length);
+VALUE sp800_185_hex_squeeze(sp800_185_context_t *context, VALUE length);
+const char *sp800_185_name(sp800_185_context_t *context);
+
+// Macro to define common Ruby methods
+#define DEFINE_SP800_185_METHOD(name) static VALUE rb_sp800_185_##name(int argc, VALUE *argv, VALUE self);
+
+DEFINE_SP800_185_METHOD(update)
+DEFINE_SP800_185_METHOD(finish)
+DEFINE_SP800_185_METHOD(digest)
+DEFINE_SP800_185_METHOD(hexdigest)
+DEFINE_SP800_185_METHOD(squeeze)
+DEFINE_SP800_185_METHOD(hex_squeeze)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SHA3_SP800_185_H_ */

data/lib/constants.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SHA3
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sha3
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Johanns Gregorian
@@ -34,12 +34,12 @@ cert_chain:
   UjZtrp/rHLfHln46RvB+a1NlMRWxtJ7mQc/CMEbT+cpHlzuYa9qGakA4TmMpK10h
   uYUv/V6CD4iTEMby0dopwHt5NqE=
   -----END CERTIFICATE-----
-date: 2025-03-03 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   A high-performance native binding to the SHA3 (FIPS 202) cryptographic hashing algorithms, based on the XKCP - eXtended Keccak Code Package.
   This gem provides support for the standard SHA-3 fixed-length functions (224, 256, 384, and 512 bits),
-  as well as the SHAKE128/SHAKE256 extendable-output functions (XOFs) and KMAC (Keccak Message Authentication Code) as specified in NIST SP 800-185.'
+  as well as the SHAKE128/SHAKE256 extendable-output functions (XOFs), cSHAKE128/256, and KMAC as specified in NIST SP 800-185.'
 email:
 - io+sha3@jsg.io
 executables: []
@@ -52,6 +52,9 @@ files:
 - ".rdoc_options"
 - ".rspec"
 - ".rubocop.yml"
+- ".vscode/launch.json"
+- ".vscode/settings.json"
+- ".vscode/tasks.json"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -60,6 +63,8 @@ files:
 - certs/io+sha3@jsg.io.pem
 - doc/sha3.rb
 - ext/sha3/config.h
+- ext/sha3/cshake.c
+- ext/sha3/cshake.h
 - ext/sha3/digest.c
 - ext/sha3/digest.h
 - ext/sha3/extconf.rb
@@ -94,6 +99,8 @@ files:
 - ext/sha3/lib/low/common/SnP-Relaned.h
 - ext/sha3/sha3.c
 - ext/sha3/sha3.h
+- ext/sha3/sp800_185.c
+- ext/sha3/sp800_185.h
 - lib/constants.rb
 - lib/sha3.rb
 homepage: https://github.com/johanns/sha3
@@ -124,6 +131,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: 'SHA3 (FIPS 202) cryptographic hashing algorithms: SHA3-224/256/384/512,
-  SHAKE128/256, and KMAC'
+summary: SHA-3 (FIPS 202), SHAKE128/SHAKE256, cSHAKE128/cSHAKE256, and KMAC (NIST
+  SP 800-185), powered by XKCP.
 test_files: []