sha3 1.0.5 → 2.0.0

data/ext/sha3/digest.h

@@ -1,45 +1,81 @@
-/* Copyright (c) 2012 - 2013 Johanns Gregorian <io+sha3@jsani.com> */
+// Copyright (c) 2012 - 2025 Johanns Gregorian <io+sha3@jsg.io>
 
 #ifndef _DIGEST_H_
 #define _DIGEST_H_
 
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <string.h>
+
+#include "KeccakHash.h"
+
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-// From ruby/ext/openssl/ossl_digest.c
-#define GETMDX(obj, mdx)                                                \
-    do                                                                  \
-    {                                                                   \
-        Data_Get_Struct((obj), MDX, (mdx));                             \
-        if (!(mdx))                                                     \
-        {                                                               \
-            rb_raise(rb_eRuntimeError, "Digest data not initialized!"); \
-        }                                                               \
-    } while (0)
-
-#define SAFEGETMDX(obj, mdx)                                              \
-    do                                                                    \
-    {                                                                     \
-        if (!rb_obj_is_kind_of(obj, cSHA3Digest))                         \
-        {                                                                 \
-            rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", \
-                     rb_obj_classname(obj), rb_class2name(cSHA3Digest));  \
-        }                                                                 \
-        GETMDX(obj, mdx);                                                 \
-    } while (0)
-
-    extern VALUE cSHA3Digest;
-    extern VALUE eSHA3DigestError;
-
-    typedef struct
-    {
-        Keccak_HashInstance *state;
-        int hashbitlen;
-    } MDX;
-
-    void Init_sha3_n_digest(void);
+typedef enum { SHA3_224 = 0, SHA3_256, SHA3_384, SHA3_512, SHAKE_128, SHAKE_256 } algorithm_type;
+
+typedef HashReturn (*keccak_init_func)(Keccak_HashInstance*);
+
+typedef struct {
+    Keccak_HashInstance* state;
+    int hashbitlen;
+    algorithm_type algorithm;
+} MDX;
+
+VALUE sha3_module;
+VALUE digest_class;
+VALUE digest_error_class;
+
+/* Static IDs for faster symbol lookup */
+static ID sha3_224_id;
+static ID sha3_256_id;
+static ID sha3_384_id;
+static ID sha3_512_id;
+static ID shake_128_id;
+static ID shake_256_id;
+
+// TypedData functions
+extern const rb_data_type_t mdx_type;
+
+// Static inline functions replacing macros
+static inline void get_mdx(VALUE obj, MDX** mdx) {
+    TypedData_Get_Struct((obj), MDX, &mdx_type, (*mdx));
+    if (!(*mdx)) {
+        rb_raise(rb_eRuntimeError, "Digest data not initialized!");
+    }
+}
+
+static inline void safe_get_mdx(VALUE obj, MDX** mdx) {
+    if (!rb_obj_is_kind_of(obj, digest_class)) {
+        rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", rb_obj_classname(obj),
+                 rb_class2name(digest_class));
+    }
+    get_mdx(obj, mdx);
+}
+
+/* Allocation and initialization */
+static VALUE rb_digest_alloc(VALUE);
+static VALUE rb_digest_init(int, VALUE*, VALUE);
+
+/* Core digest operations */
+static VALUE rb_digest_copy(VALUE, VALUE);
+static VALUE rb_digest_finish(int, VALUE*, VALUE);
+static VALUE rb_digest_reset(VALUE);
+static VALUE rb_digest_update(VALUE, VALUE);
+
+/* Digest properties */
+static VALUE rb_digest_block_length(VALUE);
+static VALUE rb_digest_length(VALUE);
+static VALUE rb_digest_name(VALUE);
+
+/* Output methods */
+static VALUE rb_digest_digest(int, VALUE*, VALUE);
+static VALUE rb_digest_hexdigest(int, VALUE*, VALUE);
+static VALUE rb_digest_hex_squeeze(VALUE, VALUE);
+static VALUE rb_digest_squeeze(VALUE, VALUE);
+static VALUE rb_digest_self_digest(VALUE, VALUE, VALUE);
+static VALUE rb_digest_self_hexdigest(VALUE, VALUE, VALUE);
 
 #ifdef __cplusplus
 }

data/ext/sha3/extconf.rb

@@ -3,48 +3,52 @@
 require 'mkmf'
 require 'rbconfig'
 
-# Maintaining XKCP lib directory structure to hopefully simplify 
-# future upgrades.
+b64 = 8.size == 8
+extension_name = 'sha3_digest'
+ref_dir = b64 ? 'ref-64bits' : 'ref-32bits'
 
-keccak_base_files = [
-  'lib/high/Keccak/KeccakSponge.c',
-  'lib/high/Keccak/FIPS202/KeccakHash.c'
-]
+dir_config(extension_name)
 
-if 1.size == 8
-  Logging.message "=== Using 64-bit reference ===\n"
+# Set compiler flags
+$CFLAGS << ' -fomit-frame-pointer -O3 -g0 -fms-extensions'
 
-  keccak_base_files << 'lib/low/KeccakP-1600/ref-64bits/KeccakP-1600-reference.c'
-else
-  Logging.message "=== Using 32-bit reference ===\n"
+# Add architecture-specific optimizations if enabled
+$CFLAGS << ' -march=native' if enable_config('march-tune-native', false)
 
-  keccak_base_files << 'lib/low/KeccakP-1600/ref-32bits/KeccakP-1600-reference32BI.c'
-end
+# Add security hardening flags
+$CFLAGS << ' -D_FORTIFY_SOURCE=2 -fstack-protector-strong'
 
-FileUtils.cp keccak_base_files.map { |f| "#{$srcdir}/#{f}" }, $srcdir
+# Add warning flags to catch potential issues
+$CFLAGS << ' -Wall -Wextra -Wformat -Wformat-security'
 
-extension_name = 'sha3_n'
-dir_config(extension_name)
+# 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) }
+                .select { |dir| !dir.include?('KeccakP-1600/ref-') || dir.include?(ref_dir) }
+
+# Process directory paths for both VPATH and INCFLAGS
+vpath_dirs_processed = vpath_dirs.map { |dir| dir.sub($srcdir, '') }
+
+# Add source directories to VPATH
+$VPATH << vpath_dirs_processed
+          .map { |dir| "$(srcdir)#{dir}" }
+          .join(File::PATH_SEPARATOR)
+
+# Add include flags
+$INCFLAGS << vpath_dirs_processed
+             .map { |dir| " -I$(srcdir)#{dir}" }
+             .join('')
+
+# Base source files
+$srcs = ['digest.c']
+
+# Find and add all .c files from the filtered directories
+$srcs += vpath_dirs
+         .flat_map { |dir| Dir.glob("#{dir}/*.c") }
+         .map { |file| File.basename(file) }
+         .uniq
 
-$INCFLAGS << [
-  ' -I$(src) ',
-  ' -I$(srcdir)lib/ ',
-  ' -I$(srcdir)/lib/common ',
-  ' -I$(srcdir)/lib/high/Keccak ',
-  ' -I$(srcdir)/lib/high/Keccak/FIPS202 ',
-  ' -I$(srcdir)/lib/low/KeccakP-1600/common ',
-  ' -I$(srcdir)/lib/low/KeccakP-1600/ref-32bits ',
-  ' -I$(srcdir)/lib/low/KeccakP-1600/ref-64bits '
-].join
-
-$CFLAGS << ' -fomit-frame-pointer -O3 -g0 -fms-extensions '
-$CFLAGS << ' -march=native ' if enable_config('march-tune-native', false)
-
-find_header('sha3.h')
-find_header('digest.h')
-find_header('align.h')
-find_header('brg_endian.h')
-find_header('KeccakSponge.h')
-find_header('KeccakHash.h')
-
-create_makefile extension_name
+create_makefile(extension_name)

data/ext/sha3/lib/high/Keccak/KeccakDuplex.c

@@ -0,0 +1,81 @@
+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Keccak, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
+
+Implementation by the designers, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include "KeccakDuplex.h"
+
+#ifdef KeccakReference
+    #include "displayIntermediateValues.h"
+#endif
+
+#ifdef XKCP_has_KeccakP200
+    #include "KeccakP-200-SnP.h"
+
+    #define prefix KeccakWidth200
+    #define SnP KeccakP200
+    #define SnP_width 200
+    #define SnP_Permute KeccakP200_Permute_18rounds
+        #include "KeccakDuplex.inc"
+    #undef prefix
+    #undef SnP
+    #undef SnP_width
+    #undef SnP_Permute
+    #undef SnP_FastLoop_Absorb
+#endif
+
+#ifdef XKCP_has_KeccakP400
+    #include "KeccakP-400-SnP.h"
+
+    #define prefix KeccakWidth400
+    #define SnP KeccakP400
+    #define SnP_width 400
+    #define SnP_Permute KeccakP400_Permute_20rounds
+        #include "KeccakDuplex.inc"
+    #undef prefix
+    #undef SnP
+    #undef SnP_width
+    #undef SnP_Permute
+    #undef SnP_FastLoop_Absorb
+#endif
+
+#ifdef XKCP_has_KeccakP800
+    #include "KeccakP-800-SnP.h"
+
+    #define prefix KeccakWidth800
+    #define SnP KeccakP800
+    #define SnP_width 800
+    #define SnP_Permute KeccakP800_Permute_22rounds
+        #include "KeccakDuplex.inc"
+    #undef prefix
+    #undef SnP
+    #undef SnP_width
+    #undef SnP_Permute
+    #undef SnP_FastLoop_Absorb
+#endif
+
+#ifdef XKCP_has_KeccakP1600
+    #include "KeccakP-1600-SnP.h"
+
+    #define prefix KeccakWidth1600
+    #define SnP KeccakP1600
+    #define SnP_width 1600
+    #define SnP_Permute KeccakP1600_Permute_24rounds
+        #include "KeccakDuplex.inc"
+    #undef prefix
+    #undef SnP
+    #undef SnP_width
+    #undef SnP_Permute
+    #undef SnP_FastLoop_Absorb
+#endif

data/ext/sha3/lib/high/Keccak/KeccakDuplex.h

@@ -0,0 +1,73 @@
+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Keccak, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
+
+Implementation by the designers, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _KeccakDuplex_h_
+#define _KeccakDuplex_h_
+
+/* For the documentation, please follow the link: */
+/* #include "KeccakDuplex-documentation.h" */
+
+#include <string.h>
+#include "align.h"
+#include "config.h"
+
+#define XKCP_DeclareDuplexStructure(prefix, state_t) \
+    typedef struct prefix##_DuplexInstanceStruct { \
+        state_t state; \
+        unsigned int rate; \
+        unsigned int byteInputIndex; \
+        unsigned int byteOutputIndex; \
+    } prefix##_DuplexInstance;
+
+#define XKCP_DeclareDuplexFunctions(prefix) \
+    int prefix##_DuplexInitialize(prefix##_DuplexInstance *duplexInstance, unsigned int rate, unsigned int capacity); \
+    int prefix##_Duplexing(prefix##_DuplexInstance *duplexInstance, const unsigned char *sigmaBegin, unsigned int sigmaBeginByteLen, unsigned char *Z, unsigned int ZByteLen, unsigned char delimitedSigmaEnd); \
+    int prefix##_DuplexingFeedPartialInput(prefix##_DuplexInstance *duplexInstance, const unsigned char *input, unsigned int inputByteLen); \
+    int prefix##_DuplexingFeedZeroes(prefix##_DuplexInstance *duplexInstance, unsigned int inputByteLen); \
+    int prefix##_DuplexingOverwritePartialInput(prefix##_DuplexInstance *duplexInstance, const unsigned char *input, unsigned int inputByteLen); \
+    int prefix##_DuplexingOverwriteWithZeroes(prefix##_DuplexInstance *duplexInstance, unsigned int inputByteLen); \
+    int prefix##_DuplexingGetFurtherOutput(prefix##_DuplexInstance *duplexInstance, unsigned char *out, unsigned int outByteLen); \
+    int prefix##_DuplexingGetFurtherOutputAndAdd(prefix##_DuplexInstance *duplexInstance, const unsigned char *input, unsigned char *output, unsigned int outputByteLen);
+
+#ifdef XKCP_has_KeccakP200
+    #include "KeccakP-200-SnP.h"
+    XKCP_DeclareDuplexStructure(KeccakWidth200, KeccakP200_stateSizeInBytes, KeccakP200_stateAlignment)
+    XKCP_DeclareDuplexFunctions(KeccakWidth200)
+    #define XKCP_has_Duplex_Keccak_width200
+#endif
+
+#ifdef XKCP_has_KeccakP400
+    #include "KeccakP-400-SnP.h"
+    XKCP_DeclareDuplexStructure(KeccakWidth400, KeccakP400_stateSizeInBytes, KeccakP400_stateAlignment)
+    XKCP_DeclareDuplexFunctions(KeccakWidth400)
+    #define XKCP_has_Duplex_Keccak_width400
+#endif
+
+#ifdef XKCP_has_KeccakP800
+    #include "KeccakP-800-SnP.h"
+    XKCP_DeclareDuplexStructure(KeccakWidth800, KeccakP800_stateSizeInBytes, KeccakP800_stateAlignment)
+    XKCP_DeclareDuplexFunctions(KeccakWidth800)
+    #define XKCP_has_Duplex_Keccak_width800
+#endif
+
+#ifdef XKCP_has_KeccakP1600
+    #include "KeccakP-1600-SnP.h"
+    XKCP_DeclareDuplexStructure(KeccakWidth1600, KeccakP1600_state)
+    XKCP_DeclareDuplexFunctions(KeccakWidth1600)
+    #define XKCP_has_Duplex_Keccak_width1600
+#endif
+
+#endif

data/ext/sha3/lib/high/Keccak/KeccakDuplex.inc

@@ -0,0 +1,201 @@
+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Keccak, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
+
+Implementation by the designers, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#define JOIN0(a, b)                     a ## b
+#define JOIN(a, b)                      JOIN0(a, b)
+
+#define DuplexInstance                  JOIN(prefix, _DuplexInstance)
+#define DuplexInitialize                JOIN(prefix, _DuplexInitialize)
+#define Duplexing                       JOIN(prefix, _Duplexing)
+#define DuplexingFeedPartialInput       JOIN(prefix, _DuplexingFeedPartialInput)
+#define DuplexingFeedZeroes             JOIN(prefix, _DuplexingFeedZeroes)
+#define DuplexingOverwritePartialInput  JOIN(prefix, _DuplexingOverwritePartialInput)
+#define DuplexingOverwriteWithZeroes    JOIN(prefix, _DuplexingOverwriteWithZeroes)
+#define DuplexingGetFurtherOutput       JOIN(prefix, _DuplexingGetFurtherOutput)
+#define DuplexingGetFurtherOutputAndAdd JOIN(prefix, _DuplexingGetFurtherOutputAndAdd)
+
+#define SnP_StaticInitialize            JOIN(SnP, _StaticInitialize)
+#define SnP_Initialize                  JOIN(SnP, _Initialize)
+#define SnP_AddByte                     JOIN(SnP, _AddByte)
+#define SnP_AddBytes                    JOIN(SnP, _AddBytes)
+#define SnP_OverwriteBytes              JOIN(SnP, _OverwriteBytes)
+#define SnP_OverwriteWithZeroes         JOIN(SnP, _OverwriteWithZeroes)
+#define SnP_ExtractBytes                JOIN(SnP, _ExtractBytes)
+#define SnP_ExtractAndAddBytes          JOIN(SnP, _ExtractAndAddBytes)
+
+int DuplexInitialize(DuplexInstance *instance, unsigned int rate, unsigned int capacity)
+{
+    if (rate+capacity != SnP_width)
+        return 1;
+    if ((rate <= 2) || (rate > SnP_width))
+        return 1;
+    SnP_StaticInitialize();
+    instance->rate = rate;
+    SnP_Initialize(&instance->state);
+    instance->byteInputIndex = 0;
+    instance->byteOutputIndex = (instance->rate+7)/8;
+    return 0;
+}
+
+int Duplexing(DuplexInstance *instance, const unsigned char *sigmaBegin, unsigned int sigmaBeginByteLen, unsigned char *Z, unsigned int ZByteLen, unsigned char delimitedSigmaEnd)
+{
+    const unsigned int rho_max = instance->rate - 2;
+
+    if (delimitedSigmaEnd == 0)
+        return 1;
+    if (sigmaBeginByteLen > rho_max/8)
+        return 1;
+    if ((instance->byteInputIndex+sigmaBeginByteLen)*8 > rho_max)
+        return 1;
+    if (rho_max - sigmaBeginByteLen*8 < 7) {
+        unsigned int maxBitsInDelimitedSigmaEnd = rho_max - sigmaBeginByteLen*8;
+        if (delimitedSigmaEnd >= (1 << (maxBitsInDelimitedSigmaEnd+1)))
+            return 1;
+    }
+    if (ZByteLen > (instance->rate+7)/8)
+        return 1; /* The output length must not be greater than the rate (rounded up to a byte) */
+
+    SnP_AddBytes(&instance->state, sigmaBegin, instance->byteInputIndex, sigmaBeginByteLen);
+    #ifdef KeccakReference
+    {
+        unsigned char block[SnP_width/8];
+        memcpy(block, sigmaBegin, sigmaBeginByteLen);
+        block[sigmaBeginByteLen] = delimitedSigmaEnd;
+        memset(block+sigmaBeginByteLen+1, 0, sizeof(block)-sigmaBeginByteLen-1);
+        block[(instance->rate-1)/8] |= 1 << ((instance->rate-1) % 8);
+        displayBytes(1, "Block to be absorbed (after padding)", block, (instance->rate+7)/8);
+    }
+    #endif
+
+    /* Last few bits, whose delimiter coincides with first bit of padding */
+    SnP_AddByte(&instance->state, delimitedSigmaEnd, instance->byteInputIndex+sigmaBeginByteLen);
+    /* Second bit of padding */
+    SnP_AddByte(&instance->state, (unsigned char)1 << ((instance->rate - 1)%8), (instance->rate - 1)/8);
+    SnP_Permute(&instance->state);
+    SnP_ExtractBytes(&instance->state, Z, 0, ZByteLen);
+
+    if (ZByteLen*8 > instance->rate) {
+        unsigned char mask = (unsigned char)(1 << (instance->rate % 8)) - 1;
+        Z[ZByteLen-1] &= mask;
+    }
+
+    instance->byteInputIndex = 0;
+    instance->byteOutputIndex = ZByteLen;
+
+    return 0;
+}
+
+int DuplexingFeedPartialInput(DuplexInstance *instance, const unsigned char *input, unsigned int inputByteLen)
+{
+    const unsigned int rho_max = instance->rate - 2;
+
+    if (inputByteLen > rho_max/8)
+        return 1;
+    if ((instance->byteInputIndex+inputByteLen)*8 > rho_max)
+        return 1;
+
+    SnP_AddBytes(&instance->state, input, instance->byteInputIndex, inputByteLen);
+    instance->byteInputIndex += inputByteLen;
+    return 0;
+}
+
+int DuplexingFeedZeroes(DuplexInstance *instance, unsigned int inputByteLen)
+{
+    const unsigned int rho_max = instance->rate - 2;
+
+    if (inputByteLen > rho_max/8)
+        return 1;
+    if ((instance->byteInputIndex+inputByteLen)*8 > rho_max)
+        return 1;
+
+    instance->byteInputIndex += inputByteLen;
+    return 0;
+}
+
+int DuplexingOverwritePartialInput(DuplexInstance *instance, const unsigned char *input, unsigned int inputByteLen)
+{
+    const unsigned int rho_max = instance->rate - 2;
+
+    if (inputByteLen > rho_max/8)
+        return 1;
+    if ((instance->byteInputIndex+inputByteLen)*8 > rho_max)
+        return 1;
+
+    SnP_OverwriteBytes(&instance->state, input, instance->byteInputIndex, inputByteLen);
+    instance->byteInputIndex += inputByteLen;
+    return 0;
+}
+
+int DuplexingOverwriteWithZeroes(DuplexInstance *instance, unsigned int inputByteLen)
+{
+    const unsigned int rho_max = instance->rate - 2;
+
+    if (inputByteLen > rho_max/8)
+        return 1;
+    if ((instance->byteInputIndex != 0) || (inputByteLen*8 > rho_max))
+        return 1;
+
+    SnP_OverwriteWithZeroes(&instance->state, inputByteLen);
+    instance->byteInputIndex = inputByteLen;
+
+    return 0;
+}
+
+int DuplexingGetFurtherOutput(DuplexInstance *instance, unsigned char *output, unsigned int outputByteLen)
+{
+    if (outputByteLen > (instance->rate+7)/8 - instance->byteOutputIndex)
+        return 1; /* The output length must not be greater than the rate (rounded up to a byte) */
+
+    SnP_ExtractBytes(&instance->state, output, instance->byteOutputIndex, outputByteLen);
+    instance->byteOutputIndex += outputByteLen;
+    if (instance->byteOutputIndex*8 > instance->rate) {
+        unsigned char mask = (1 << (instance->rate % 8)) - 1;
+        output[outputByteLen-1] &= mask;
+    }
+    return 0;
+}
+
+int DuplexingGetFurtherOutputAndAdd(DuplexInstance *instance, const unsigned char *input, unsigned char *output, unsigned int outputByteLen)
+{
+    if (outputByteLen > (instance->rate+7)/8 - instance->byteOutputIndex)
+        return 1; /* The output length must not be greater than the rate (rounded up to a byte) */
+
+    SnP_ExtractAndAddBytes(&instance->state, input, output, instance->byteOutputIndex, outputByteLen);
+    instance->byteOutputIndex += outputByteLen;
+    if (instance->byteOutputIndex*8 > instance->rate) {
+        unsigned char mask = (1 << (instance->rate % 8)) - 1;
+        output[outputByteLen-1] &= mask;
+    }
+    return 0;
+}
+
+#undef DuplexInstance
+#undef DuplexInitialize
+#undef Duplexing
+#undef DuplexingFeedPartialInput
+#undef DuplexingFeedZeroes
+#undef DuplexingOverwritePartialInput
+#undef DuplexingOverwriteWithZeroes
+#undef DuplexingGetFurtherOutput
+#undef DuplexingGetFurtherOutputAndAdd
+#undef SnP_StaticInitialize
+#undef SnP_Initialize
+#undef SnP_AddByte
+#undef SnP_AddBytes
+#undef SnP_OverwriteBytes
+#undef SnP_OverwriteWithZeroes
+#undef SnP_ExtractBytes
+#undef SnP_ExtractAndAddBytes

data/ext/sha3/lib/high/Keccak/KeccakSponge.c

@@ -79,6 +79,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
 
     #define prefix KeccakWidth1600
     #define SnP KeccakP1600
+    #define SnP_state KeccakP1600_state
     #define SnP_width 1600
     #define SnP_Permute KeccakP1600_Permute_24rounds
     #if defined(KeccakF1600_FastLoop_supported)
@@ -87,24 +88,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         #include "KeccakSponge.inc"
     #undef prefix
     #undef SnP
-    #undef SnP_width
-    #undef SnP_Permute
-    #undef SnP_FastLoop_Absorb
-#endif
-
-#ifdef XKCP_has_KeccakP1600
-    #include "KeccakP-1600-SnP.h"
-
-    #define prefix KeccakWidth1600_12rounds
-    #define SnP KeccakP1600
-    #define SnP_width 1600
-    #define SnP_Permute KeccakP1600_Permute_12rounds
-    #if defined(KeccakP1600_12rounds_FastLoop_supported)
-        #define SnP_FastLoop_Absorb KeccakP1600_12rounds_FastLoop_Absorb
-    #endif
-        #include "KeccakSponge.inc"
-    #undef prefix
-    #undef SnP
+    #undef SnP_state
     #undef SnP_width
     #undef SnP_Permute
     #undef SnP_FastLoop_Absorb

data/ext/sha3/lib/high/Keccak/KeccakSponge.h

@@ -24,9 +24,9 @@ http://creativecommons.org/publicdomain/zero/1.0/
 #include "align.h"
 #include "config.h"
 
-#define XKCP_DeclareSpongeStructure(prefix, size, alignment) \
-    ALIGN(alignment) typedef struct prefix##_SpongeInstanceStruct { \
-        unsigned char state[size]; \
+#define XKCP_DeclareSpongeStructure(prefix, state_t) \
+    typedef struct prefix##_SpongeInstanceStruct { \
+        state_t state; \
         unsigned int rate; \
         unsigned int byteIOIndex; \
         int squeezing; \
@@ -62,15 +62,9 @@ http://creativecommons.org/publicdomain/zero/1.0/
 
 #ifdef XKCP_has_KeccakP1600
     #include "KeccakP-1600-SnP.h"
-    XKCP_DeclareSpongeStructure(KeccakWidth1600, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
+    XKCP_DeclareSpongeStructure(KeccakWidth1600, KeccakP1600_state)
     XKCP_DeclareSpongeFunctions(KeccakWidth1600)
     #define XKCP_has_Sponge_Keccak_width1600
 #endif
 
-#ifdef XKCP_has_KeccakP1600
-    #include "KeccakP-1600-SnP.h"
-    XKCP_DeclareSpongeStructure(KeccakWidth1600_12rounds, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
-    XKCP_DeclareSpongeFunctions(KeccakWidth1600_12rounds)
-#endif
-
 #endif