sha3 2.2.2 → 2.2.4

data/ext/sha3/sp800_185.c

@@ -22,38 +22,46 @@ static int kmac256_init_wrapper(void *state, void *params) {
 }
 
 /*** 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),
-                                                     .is_keyed = false,
-                                                     .init = cshake128_init_wrapper,
-                                                     .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),
-                                                     .is_keyed = false,
-                                                     .init = cshake256_init_wrapper,
-                                                     .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),
-                                                     .is_keyed = true,
-                                                     .init = kmac128_init_wrapper,
-                                                     .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),
-                                                     .is_keyed = true,
-                                                     .init = kmac256_init_wrapper,
-                                                     .update = (sp800_185_update_fn)KMAC256_Update,
-                                                     .final = (sp800_185_final_fn)KMAC256_Final,
-                                                     .squeeze = (sp800_185_squeeze_fn)KMAC256_Squeeze}};
+sp800_185_function_table_t sp800_185_functions[] = {{
+                                                        .algorithm = SP800_185_CSHAKE_128,
+                                                        .name = "CSHAKE128",
+                                                        .state_size = sizeof(cSHAKE_Instance),
+                                                        .is_keyed = false,
+                                                        .init = cshake128_init_wrapper,
+                                                        .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),
+                                                        .is_keyed = false,
+                                                        .init = cshake256_init_wrapper,
+                                                        .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),
+                                                        .is_keyed = true,
+                                                        .init = kmac128_init_wrapper,
+                                                        .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),
+                                                        .is_keyed = true,
+                                                        .init = kmac256_init_wrapper,
+                                                        .update = (sp800_185_update_fn)KMAC256_Update,
+                                                        .final = (sp800_185_final_fn)KMAC256_Final,
+                                                        .squeeze = (sp800_185_squeeze_fn)KMAC256_Squeeze,
+                                                    }};
 
 /* Algorithm lookup functions */
 const sp800_185_function_table_t *sp800_185_get_algorithm(sp800_185_algorithm_t algorithm) {
@@ -74,12 +82,12 @@ const sp800_185_function_table_t *sp800_185_get_algorithm_by_name(const char *na
 
 // 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);
+    sp800_185_context_t *context = (sp800_185_context_t *)ruby_xmalloc(context_size);
     if (!context) return NULL;
 
-    context->state = calloc(1, state_size);
+    context->state = ruby_xcalloc(1, state_size);
     if (!context->state) {
-        free(context);
+        ruby_xfree(context);
         return NULL;
     }
 
@@ -92,9 +100,9 @@ sp800_185_context_t *sp800_185_alloc_context(size_t context_size, size_t state_s
 void sp800_185_free_context(sp800_185_context_t *context) {
     if (context) {
         if (context->state) {
-            free(context->state);
+            ruby_xfree(context->state);
         }
-        free(context);
+        ruby_xfree(context);
     }
 }
 
@@ -112,7 +120,7 @@ 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);
+    void *state_copy = ruby_xmalloc(context->functions->state_size);
 
     if (!state_copy) {
         rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
@@ -125,6 +133,12 @@ void *sp800_185_copy_state(sp800_185_context_t *context) {
 
 VALUE sp800_185_update(sp800_185_context_t *context, VALUE data) {
     StringValue(data);
+
+    // Check for NULL data pointer
+    if (RSTRING_PTR(data) == NULL && RSTRING_LEN(data) > 0) {
+        rb_raise(context->error_class, "cannot update with NULL data");
+    }
+
     size_t data_len = (RSTRING_LEN(data) * 8);
 
     if (data_len == 0) {
@@ -172,7 +186,7 @@ VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data) {
     }
 
     // Create a copy of the state for processing
-    void *state_copy = malloc(context->functions->state_size);
+    void *state_copy = ruby_xmalloc(context->functions->state_size);
     if (!state_copy) {
         rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
     }
@@ -190,7 +204,7 @@ VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data) {
             result = context->functions->update(state_copy, (const BitSequence *)RSTRING_PTR(data), data_len);
 
             if (result != 0) {
-                free(state_copy);
+                ruby_xfree(state_copy);
                 rb_raise(context->error_class, "failed to update %s state", context->functions->name);
             }
         }
@@ -201,7 +215,7 @@ VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data) {
 
     result = context->functions->final(state_copy, (BitSequence *)RSTRING_PTR(output));
 
-    free(state_copy);
+    ruby_xfree(state_copy);
 
     if (result != 0) {
         rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
@@ -220,18 +234,23 @@ VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
         rb_raise(context->error_class, "use digest methods for fixed-length output");
     }
 
-    size_t output_byte_len;
+    long output_byte_len;
     VALUE str;
 
     Check_Type(length, T_FIXNUM);
-    output_byte_len = NUM2ULONG(length);
+    output_byte_len = NUM2LONG(length);
 
     if (output_byte_len <= 0) {
-        rb_raise(context->error_class, "output length must be specified");
+        rb_raise(context->error_class, "output length must be positive");
+    }
+
+    // Limit output to 1MB for safety
+    if (output_byte_len > (1L << 20)) {
+        rb_raise(context->error_class, "output length too large (max 1MB)");
     }
 
     // Create a copy of the state for processing
-    void *state_copy = malloc(context->functions->state_size);
+    void *state_copy = ruby_xmalloc(context->functions->state_size);
     if (!state_copy) {
         rb_raise(rb_eNoMemError, "failed to allocate memory for state copy");
     }
@@ -245,7 +264,7 @@ VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
     result = context->functions->final(state_copy, (BitSequence *)RSTRING_PTR(dummy_output));
 
     if (result != 0) {
-        free(state_copy);
+        ruby_xfree(state_copy);
         rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
     }
 
@@ -255,7 +274,7 @@ VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
     // Use the function table to call the appropriate squeeze function
     result = context->functions->squeeze(state_copy, (BitSequence *)RSTRING_PTR(str), output_byte_len * 8);
 
-    free(state_copy);
+    ruby_xfree(state_copy);
 
     if (result != 0) {
         rb_raise(context->error_class, "failed to squeeze %s", context->functions->name);
@@ -268,3 +287,24 @@ 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*"));
 }
+
+/* Ruby wrapper functions for common method patterns */
+
+VALUE sp800_185_rb_update(sp800_185_context_t *context, VALUE data) {
+    sp800_185_update(context, data);
+    return Qnil;  // Caller will return self
+}
+
+VALUE sp800_185_rb_name(sp800_185_context_t *context) { return rb_str_new2(sp800_185_name(context)); }
+
+VALUE sp800_185_rb_finish(sp800_185_context_t *context, VALUE output) { return sp800_185_finish(context, output); }
+
+VALUE sp800_185_rb_digest(sp800_185_context_t *context, VALUE data) { return sp800_185_digest(context, data); }
+
+VALUE sp800_185_rb_hexdigest(sp800_185_context_t *context, VALUE data) { return sp800_185_hexdigest(context, data); }
+
+VALUE sp800_185_rb_squeeze(sp800_185_context_t *context, VALUE length) { return sp800_185_squeeze(context, length); }
+
+VALUE sp800_185_rb_hex_squeeze(sp800_185_context_t *context, VALUE length) {
+    return sp800_185_hex_squeeze(context, length);
+}

data/lib/constants.rb

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

data/sha3.gemspec

@@ -9,26 +9,26 @@ Gem::Specification.new do |spec|
   spec.authors = ['Johanns Gregorian']
   spec.email = ['io+sha3@jsg.io']
 
-  spec.description = <<~EOF
+  spec.description = <<~DESC
     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), cSHAKE128/256, and KMAC as specified in NIST SP 800-185.'
-  EOF
+  DESC
   spec.summary = 'SHA-3 (FIPS 202), SHAKE128/SHAKE256, cSHAKE128/cSHAKE256, and KMAC (NIST SP 800-185), powered by XKCP.'
 
   spec.homepage = 'https://github.com/johanns/sha3'
   spec.license = 'MIT'
   spec.required_ruby_version = '>= 2.7.0'
 
-  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['documentation_uri'] = 'https://docs.jsg.io/sha3/index.html'
 
-  spec.post_install_message = <<-EOF
+  spec.post_install_message = <<-NOTICE
     [NOTICE] SHA3 version 2.0 introduces breaking changes to the API.
     Please review the changelog and ensure compatibility with your application.
     If you need the previous behavior, lock your Gemfile to version '~> 1.0'."
-  EOF
+  NOTICE
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sha3
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.4
 platform: ruby
 authors:
 - Johanns Gregorian
@@ -11,28 +11,28 @@ cert_chain:
   -----BEGIN CERTIFICATE-----
   MIIEYDCCAsigAwIBAgIBATANBgkqhkiG9w0BAQsFADA7MRAwDgYDVQQDDAdpb19z
   aGEzMRMwEQYKCZImiZPyLGQBGRYDanNnMRIwEAYKCZImiZPyLGQBGRYCaW8wHhcN
-  MjUwMzAxMDYxMTE1WhcNMjYwMzAxMDYxMTE1WjA7MRAwDgYDVQQDDAdpb19zaGEz
+  MjYwNTE3MjAwNTE1WhcNMjgwNTE2MjAwNTE1WjA7MRAwDgYDVQQDDAdpb19zaGEz
   MRMwEQYKCZImiZPyLGQBGRYDanNnMRIwEAYKCZImiZPyLGQBGRYCaW8wggGiMA0G
-  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDMdO1oUQ9FzXYtfFktOXDx6oIf9uSk
-  mg+yfo7uvcyNSa4gsF4+CY/TOYNBtwlD25AlgDqpxVCHFwUaBD+MHKyd8p6Eto1Q
-  Bwb7YrjPOXlmCKQYr5sFfbjeUfQRKBUTAhzM0W/5Zh9C4gkOyZ/7SaU6mI/M/LgQ
-  dZsw2y6l2bAl4aZaXgbnO7B1rPTPr6yQRZTveacmeTGHav1WACdE36Txqyv2QA7+
-  +VdYx04fOe2FEipan7d4TA4XKW+0Z+VWyoWFNyyxJtiT53PB10lztPiycBqZ+A3L
-  aA2VjZekn3NFbsXMOa4fbSTMddb784IWEeySmTMu6W/yYpo1B1PbgRaD/z2Zg0Qj
-  SZ2ldqqk68nvFVWqUlRbT8ZY6McKC1VEbNLLk7jNvdbgr/VPo4Zu5TP3FXjsPlpz
-  1duXTtAGtHjPnS+tdkSinKv4OmbTHid9gnoDcRjlNpWxoULs9iSNb6lOCUeBxvF6
-  4Eh7nyIPmaTDwPQtg5/RTvjZMqprS8D3tKsCAwEAAaNvMG0wCQYDVR0TBAIwADAL
-  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFLCWxOjmn5qTuhjFG7fwiPXzSIlFMBkGA1Ud
+  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQC16QqqWL49C7rqtj8HoYMippjH6T4A
+  MvK8w1nXPsGOhIP0BYcjNajdFxzOXZ9NcYPxosQAvY97THO7zEGsM2VrvPzsPL8J
+  8DqRS6wHUezA2ZffGpUvsesNlIpzSkEXXXRTe/8dq2/TnIeKEyx4dhu1cKL6h/22
+  Mng14M25QJK0JI5xhQ/+i9UXeNCwFjwINbOzJD1XZ2VtOJkMm/yHZvB6ww8qu+gS
+  N4J2iiCbFRsbYRPuoVFVuSOD0lgX1tvwOtUucSdF1EzvEX5XW2avzOWsKab0V3ET
+  puZ9F36dmkfNan5n5GApyKkOZ/mfC8s9brjRXVlp4YPHBK3zFEU6VsCtIa08dPXI
+  axUZlmwQLhvtsnX3nkgvbGpvFZmhBs4JBssEur7Gf9bgLbXYngfmgIZv5WFRravJ
+  qvHCehkpVgqi+ebW15UzhPwQ5wNxdm/I+tAt/u08m0R4m6kQYbk2yAimjrVLx0f/
+  JPcoi+4QXrmYZujkhqhIw2lDPOCD2oKPUVECAwEAAaNvMG0wCQYDVR0TBAIwADAL
+  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFKuRt91muWm/9XZBRDt8Nkm1IdjdMBkGA1Ud
   EQQSMBCBDmlvK3NoYTNAanNnLmlvMBkGA1UdEgQSMBCBDmlvK3NoYTNAanNnLmlv
-  MA0GCSqGSIb3DQEBCwUAA4IBgQC4Y5pXxtopzHiSBsg6fuozv7zHXXuYXOL2Bq2x
-  l8C8lYjC2pN/Fh+FlgrJkqAoJ0wBlh3+wkhYPhSehkUy/2HaUYYTd1Zv4Odw+C/Q
-  rQnN5+nIv+gMrLwoBXH9sFjAp/iYKd4cDz5aUVNrPqibj8zivcSqFJ9lsyOvIZO6
-  tajU2HVxXOkpTtLzMgPEGdwlFEd2tB7VCGFbrTskxrpv243b0HdpeEVh2e9dNkl4
-  XobOvUPXHzFTDucYe8jpCn7e7Cj43PpTZFnxIRJnO8cVpX6n7UG8+JgBSqvwuv5C
-  YwFBqP6G2+0e0EdIIMdbCDBTmJbFyBr6y4pzED/FvEFzhAmCKOcZ6RJ8H7hkX5rh
-  +L4c9pHTemc2sQl7kH+mrntu7pt6D4EM4FD5eyWujQN1ME7xvLIFm5SczqCzFDfe
-  UjZtrp/rHLfHln46RvB+a1NlMRWxtJ7mQc/CMEbT+cpHlzuYa9qGakA4TmMpK10h
-  uYUv/V6CD4iTEMby0dopwHt5NqE=
+  MA0GCSqGSIb3DQEBCwUAA4IBgQBI38LgcqdqpfkaiEGfr3fLtsOBkE1Q7mEHjeIS
+  JcEiu16sP0iR/0QzN/DS0vPMQUhl4dvkUl7euVOo8rp0mwzUyaSvq+MSQlpxwgjb
+  AQ5A8VAkkIMbTbCqRU9q9KQObmO8/NaFFFGgmRegp8eBEGdixbiIsReEeWzEICe1
+  TOmXWl1X7EBUF7CdSIHxBAjF16YXJoDJp16DonZ/pzbgeO85OzFmfnA+B9nsHXS4
+  3CeJ/lKznIM8XWSXA1ruSkZeB5ouNtauqSAaBJoMkAB0DbOrZ6yo/mP8x3WtSLKY
+  SdQdy412nPewWa08VXIjZqd1Q+rI9Wq2pY6TOqML1Iu5nB2VMAr9PoHcIPz1P9N8
+  sM8XX4fXOsMtSc4SzMOqlkg2qRdo4/1eIjVSxCM84VqppRnH8syAzny6COQ0Xo+z
+  /PqqO8TUsynEGVsjIkBIa8Y5zoXBfcQ6PQpSbeY0bXhhsxclL3fKWSQQC4MN/OFE
+  5aeBE+xHYdmI3UoIAXt1xB0hU9w=
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
@@ -62,6 +62,7 @@ files:
 - Rakefile
 - certs/io+sha3@jsg.io.pem
 - doc/sha3.rb
+- ext/sha3/common.h
 - ext/sha3/config.h
 - ext/sha3/cshake.c
 - ext/sha3/cshake.h
@@ -108,7 +109,7 @@ homepage: https://github.com/johanns/sha3
 licenses:
 - MIT
 metadata:
-  changelog_uri: https://github.com/johanns/sha3/CHANGELOG.md
+  changelog_uri: https://github.com/johanns/sha3/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/johanns/sha3
   documentation_uri: https://docs.jsg.io/sha3/index.html
   rubygems_mfa_required: 'true'
@@ -130,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.11
 specification_version: 4
 summary: SHA-3 (FIPS 202), SHAKE128/SHAKE256, cSHAKE128/cSHAKE256, and KMAC (NIST
   SP 800-185), powered by XKCP.