sha3 2.2.1 → 2.2.3

data/ext/sha3/sp800_185.c

@@ -1,45 +1,85 @@
 #include "sp800_185.h"
 
-#include "sha3.h"
+/* Wrapper functions for consistent interface */
+static int cshake128_init_wrapper(void *state, void *params) {
+    cshake_init_params_t *p = (cshake_init_params_t *)params;
+    return cSHAKE128_Initialize(state, p->capacity, p->N, p->NLen, p->S, p->SLen);
+}
+
+static int cshake256_init_wrapper(void *state, void *params) {
+    cshake_init_params_t *p = (cshake_init_params_t *)params;
+    return cSHAKE256_Initialize(state, p->capacity, p->N, p->NLen, p->S, p->SLen);
+}
+
+static int kmac128_init_wrapper(void *state, void *params) {
+    kmac_init_params_t *p = (kmac_init_params_t *)params;
+    return KMAC128_Initialize(state, p->key, p->keyBitLen, p->outputBitLen, p->customization, p->customBitLen);
+}
+
+static int kmac256_init_wrapper(void *state, void *params) {
+    kmac_init_params_t *p = (kmac_init_params_t *)params;
+    return KMAC256_Initialize(state, p->key, p->keyBitLen, p->outputBitLen, p->customization, p->customBitLen);
+}
 
 /*** 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}},
+                                                     .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),
-                                                     .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}},
+                                                     .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),
-                                                     .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}},
+                                                     .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),
-                                                     .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}}};
+                                                     .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) {
+    if (algorithm >= SP800_185_CSHAKE_128 && algorithm <= SP800_185_KMAC_256) {
+        return &sp800_185_functions[algorithm];
+    }
+    return NULL;
+}
+
+const sp800_185_function_table_t *sp800_185_get_algorithm_by_name(const char *name) {
+    for (size_t i = 0; i < sizeof(sp800_185_functions) / sizeof(sp800_185_functions[0]); i++) {
+        if (strcmp(sp800_185_functions[i].name, name) == 0) {
+            return &sp800_185_functions[i];
+        }
+    }
+    return NULL;
+}
 
 // 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;
     }
 
@@ -52,9 +92,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);
     }
 }
 
@@ -72,7 +112,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");
@@ -85,6 +125,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) {
@@ -94,21 +140,7 @@ VALUE sp800_185_update(sp800_185_context_t *context, VALUE data) {
     // 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;
-    }
+    result = context->functions->update(context->state, (const BitSequence *)RSTRING_PTR(data), data_len);
 
     if (result != 0) {
         rb_raise(context->error_class, "failed to update %s state", context->functions->name);
@@ -129,19 +161,7 @@ VALUE sp800_185_finish(sp800_185_context_t *context, VALUE output) {
     // 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;
-    }
+    result = context->functions->final(context->state, (BitSequence *)RSTRING_PTR(output));
 
     if (result != 0) {
         rb_raise(context->error_class, "failed to finalize %s state", context->functions->name);
@@ -158,7 +178,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");
     }
@@ -173,25 +193,10 @@ VALUE sp800_185_digest(sp800_185_context_t *context, VALUE 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;
-            }
+            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);
             }
         }
@@ -200,22 +205,9 @@ VALUE sp800_185_digest(sp800_185_context_t *context, VALUE data) {
     // 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;
-    }
+    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);
@@ -234,18 +226,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");
     }
@@ -256,23 +253,10 @@ VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
     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;
-    }
+    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);
     }
 
@@ -280,23 +264,9 @@ VALUE sp800_185_squeeze(sp800_185_context_t *context, VALUE length) {
     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;
-    }
+    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);
@@ -309,3 +279,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/ext/sha3/sp800_185.h

@@ -3,6 +3,7 @@
 
 #include <ruby.h>
 #include <ruby/thread.h>
+#include <stdbool.h>
 
 #include "KeccakHash.h"
 #include "SP800-185.h"
@@ -11,6 +12,12 @@
 extern "C" {
 #endif
 
+/* Forward declarations for types from Keccak if not already defined */
+#ifndef KECCAK_TYPES_DEFINED
+typedef unsigned char BitSequence;
+typedef size_t BitLength;
+#endif
+
 /* SP800-185 algorithm family */
 typedef enum {
     SP800_185_CSHAKE_128 = 0,
@@ -20,37 +27,49 @@ typedef enum {
 } 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 */
+/* Error codes for SP800-185 operations */
+typedef enum {
+    SP800_185_SUCCESS = 0,
+    SP800_185_ERROR_INVALID_ALGORITHM = -1,
+    SP800_185_ERROR_INVALID_PARAMS = -2,
+    SP800_185_ERROR_INIT_FAILED = -3,
+    SP800_185_ERROR_INVALID_STATE = -4
+} sp800_185_error_t;
+
+/* Parameter structures for different algorithms */
+typedef struct {
+    size_t capacity;
+    const BitSequence *N;
+    size_t NLen;
+    const BitSequence *S;
+    size_t SLen;
+} cshake_init_params_t;
+
+typedef struct {
+    const BitSequence *key;
+    BitLength keyBitLen;
+    BitLength outputBitLen;
+    const BitSequence *customization;
+    BitLength customBitLen;
+} kmac_init_params_t;
+
 typedef struct {
     sp800_185_algorithm_t algorithm;
     const char *name;
     size_t state_size;
+    bool is_keyed; /* true for KMAC, false for CSHAKE */
+
+    /* All algorithms use these same signatures */
+    sp800_185_update_fn update;
+    sp800_185_final_fn final;
+    sp800_185_squeeze_fn squeeze;
 
-    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;
-    };
+    /* Generic initialization - let the caller handle parameter differences */
+    int (*init)(void *state, void *params);
 } sp800_185_function_table_t;
 
 /* Base context structure for SP800-185 algorithms */
@@ -64,6 +83,34 @@ typedef struct {
 /* Global variables */
 extern sp800_185_function_table_t sp800_185_functions[];
 
+/* Algorithm lookup functions */
+const sp800_185_function_table_t *sp800_185_get_algorithm(sp800_185_algorithm_t algorithm);
+const sp800_185_function_table_t *sp800_185_get_algorithm_by_name(const char *name);
+
+/* Safe accessor functions for algorithm-specific operations */
+static inline int sp800_185_init_cshake(const sp800_185_function_table_t *table, void *state, size_t capacity,
+                                        const BitSequence *N, size_t NLen, const BitSequence *S, size_t SLen) {
+    if (!table || table->is_keyed) {
+        return SP800_185_ERROR_INVALID_ALGORITHM;
+    }
+    cshake_init_params_t params = {capacity, N, NLen, S, SLen};
+    return table->init(state, &params);
+}
+
+static inline int sp800_185_init_kmac(const sp800_185_function_table_t *table, void *state, const BitSequence *key,
+                                      BitLength keyBitLen, BitLength outputBitLen, const BitSequence *customization,
+                                      BitLength customBitLen) {
+    if (!table || !table->is_keyed) {
+        return SP800_185_ERROR_INVALID_ALGORITHM;
+    }
+    kmac_init_params_t params = {key, keyBitLen, outputBitLen, customization, customBitLen};
+    return table->init(state, &params);
+}
+
+/* Validation and utility functions */
+bool sp800_185_validate_table(const sp800_185_function_table_t *table);
+const char *sp800_185_algorithm_name(sp800_185_algorithm_t algorithm);
+
 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 *);

data/lib/constants.rb

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

data/sha3.gemspec

@@ -9,11 +9,11 @@ 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'
@@ -24,11 +24,11 @@ Gem::Specification.new do |spec|
   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.1
+  version: 2.2.3
 platform: ruby
 authors:
 - Johanns Gregorian
@@ -34,7 +34,7 @@ cert_chain:
   UjZtrp/rHLfHln46RvB+a1NlMRWxtJ7mQc/CMEbT+cpHlzuYa9qGakA4TmMpK10h
   uYUv/V6CD4iTEMby0dopwHt5NqE=
   -----END CERTIFICATE-----
-date: 2025-03-27 00:00:00.000000000 Z
+date: 1980-01-02 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.
@@ -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
@@ -130,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.1
 specification_version: 4
 summary: SHA-3 (FIPS 202), SHAKE128/SHAKE256, cSHAKE128/cSHAKE256, and KMAC (NIST
   SP 800-185), powered by XKCP.

metadata.gz.sig

@@ -1 +1,2 @@
-T&��qn���J�OM6<;ʝ�6�����a��-�g�#]ߩ����/��y}��8?%Aw����k�Vc#]h�rI�Ǝ��X�*Z(}���H��yf����j�vJH@XWd�BP/���l�֓N�z�)�ކ`�2�>0�&9jP�b�SS��J��A�,V��mb0�fS�L�C�z�s���`��f�����D�=�mPt����q��� �}�@=M�|�]�7_��lq�SS���.��74.0��ȕuV)�9#TP�jX��d_�)��h��,��دM�G@��Eqe��\&��I��Ys����t�$��]�\!"�0"���؇��7J1
��c.���=[K�PR�N�C�/��sm|f�r_�L�,��َ�@�
+n
���,����e�/��K��ڒFɎ�~홭�,1S:���
+��� �f<u���I�xs��