sleeping_kangaroo12 0.0.1 → 0.0.5

data/ext/k12/lib/ARMv8Asha3/KeccakP-1600-opt64.c

@@ -0,0 +1,227 @@
+/*
+K12 based on the eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+The Keccak-p permutations, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
+
+Implementation by Gilles Van Assche and Ronny Van Keer, 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/
+
+---
+
+Please refer to the XKCP for more details.
+*/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <KeccakP-1600-SnP.h>
+
+const char * KeccakP1600_GetImplementation()
+{
+    return "ARMv8-A+SHA3 optimized implementation";
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_Initialize(void *state)
+{
+    memset(state, 0, 200);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    uint64_t lane;
+
+    if (length == 0)
+        return;
+    if (length == 1)
+        lane = data[0];
+    else {
+        lane = 0;
+        memcpy(&lane, data, length);
+    }
+    lane <<= offset*8;
+    ((uint64_t*)state)[lanePosition] ^= lane;
+}
+
+/* ---------------------------------------------------------------- */
+
+static void KeccakP1600_opt64_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
+{
+    unsigned int i = 0;
+
+    for( ; (i+8)<=laneCount; i+=8) {
+        ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+        ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+        ((uint64_t*)state)[i+2] ^= ((uint64_t*)data)[i+2];
+        ((uint64_t*)state)[i+3] ^= ((uint64_t*)data)[i+3];
+        ((uint64_t*)state)[i+4] ^= ((uint64_t*)data)[i+4];
+        ((uint64_t*)state)[i+5] ^= ((uint64_t*)data)[i+5];
+        ((uint64_t*)state)[i+6] ^= ((uint64_t*)data)[i+6];
+        ((uint64_t*)state)[i+7] ^= ((uint64_t*)data)[i+7];
+    }
+    for( ; (i+4)<=laneCount; i+=4) {
+        ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+        ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+        ((uint64_t*)state)[i+2] ^= ((uint64_t*)data)[i+2];
+        ((uint64_t*)state)[i+3] ^= ((uint64_t*)data)[i+3];
+    }
+    for( ; (i+2)<=laneCount; i+=2) {
+        ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+        ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+    }
+    if (i<laneCount) {
+        ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+    }
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_AddByte(void *state, unsigned char byte, unsigned int offset)
+{
+    ((unsigned char*)(state))[offset] ^= byte;
+}
+
+/* ---------------------------------------------------------------- */
+
+#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
+    { \
+        if ((offset) == 0) { \
+            SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_AddBytesInLane(state, \
+                (length)/SnP_laneLengthInBytes, \
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+                0, \
+                (length)%SnP_laneLengthInBytes); \
+        } \
+        else { \
+            unsigned int _sizeLeft = (length); \
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+            const unsigned char *_curData = (data); \
+            while(_sizeLeft > 0) { \
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+                if (_bytesInLane > _sizeLeft) \
+                    _bytesInLane = _sizeLeft; \
+                SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
+    }
+
+void KeccakP1600_opt64_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    SnP_AddBytes(state, data, offset, length, KeccakP1600_opt64_AddLanes, KeccakP1600_opt64_AddBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    uint64_t lane = ((uint64_t*)state)[lanePosition];
+    {
+        uint64_t lane1[1];
+        lane1[0] = lane;
+        memcpy(data, (uint8_t*)lane1+offset, length);
+    }
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
+{
+    memcpy(data, state, laneCount*8);
+}
+
+/* ---------------------------------------------------------------- */
+
+#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
+    { \
+        if ((offset) == 0) { \
+            SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_ExtractBytesInLane(state, \
+                (length)/SnP_laneLengthInBytes, \
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+                0, \
+                (length)%SnP_laneLengthInBytes); \
+        } \
+        else { \
+            unsigned int _sizeLeft = (length); \
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+            unsigned char *_curData = (data); \
+            while(_sizeLeft > 0) { \
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+                if (_bytesInLane > _sizeLeft) \
+                    _bytesInLane = _sizeLeft; \
+                SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
+    }
+
+void KeccakP1600_opt64_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    SnP_ExtractBytes(state, data, offset, length, KeccakP1600_opt64_ExtractLanes, KeccakP1600_opt64_ExtractBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+/* Keccak-p[1600]×2 */
+
+int KeccakP1600times2_IsAvailable()
+{
+    return 1;
+}
+
+const char * KeccakP1600times2_GetImplementation()
+{
+    return "ARMv8-A+SHA3 optimized implementation";
+}
+
+/* Keccak-p[1600]×4 */
+
+int KeccakP1600times4_IsAvailable()
+{
+    return 0;
+}
+
+const char * KeccakP1600times4_GetImplementation()
+{
+    return "";
+}
+
+void KangarooTwelve_Process4Leaves(const unsigned char *input, unsigned char *output)
+{
+}
+
+/* Keccak-p[1600]×8 */
+
+int KeccakP1600times8_IsAvailable()
+{
+    return 0;
+}
+
+const char * KeccakP1600times8_GetImplementation()
+{
+    return "";
+}
+
+void KangarooTwelve_Process8Leaves(const unsigned char *input, unsigned char *output)
+{
+}

data/ext/{xkcp/lib/low/KeccakP-1600/compact → k12/lib/Inplace32BI}/KeccakP-1600-SnP.h

@@ -1,5 +1,5 @@
 /*
-The eXtended Keccak Code Package (XKCP)
+K12 based on the eXtended Keccak Code Package (XKCP)
 https://github.com/XKCP/XKCP
 
 The Keccak-p permutations, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
@@ -15,26 +15,21 @@ http://creativecommons.org/publicdomain/zero/1.0/
 
 ---
 
-Please refer to SnP-documentation.h for more details.
+Please refer to the XKCP for more details.
 */
 
 #ifndef _KeccakP_1600_SnP_h_
 #define _KeccakP_1600_SnP_h_
 
-#define KeccakP1600_implementation      "64-bit compact implementation"
 #define KeccakP1600_stateSizeInBytes    200
 #define KeccakP1600_stateAlignment      8
+#define KeccakP1600_disableParallelism
 
-#define KeccakP1600_StaticInitialize()
+const char * KeccakP1600_GetImplementation();
 void KeccakP1600_Initialize(void *state);
 void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset);
 void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount);
-void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds);
 void KeccakP1600_Permute_12rounds(void *state);
-void KeccakP1600_Permute_24rounds(void *state);
 void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
 
 #endif

data/ext/{xkcp/lib/low/KeccakP-1600/plain-32bits-inplace → k12/lib/Inplace32BI}/KeccakP-1600-inplace32BI.c

@@ -1,5 +1,5 @@
 /*
-The eXtended Keccak Code Package (XKCP)
+K12 based on the eXtended Keccak Code Package (XKCP)
 https://github.com/XKCP/XKCP
 
 The Keccak-p permutations, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
@@ -15,18 +15,19 @@ http://creativecommons.org/publicdomain/zero/1.0/
 
 ---
 
-This file implements Keccak-p[1600] in a SnP-compatible way.
-Please refer to SnP-documentation.h for more details.
-
-This implementation comes with KeccakP-1600-SnP.h in the same folder.
-Please refer to LowLevel.build for the exact list of other files it must be combined with.
+Please refer to the XKCP for more details.
 */
 
 #include <stdint.h>
 #include <string.h>
 #include "brg_endian.h"
 #include "KeccakP-1600-SnP.h"
-#include "SnP-Relaned.h"
+
+const char * KeccakP1600_GetImplementation()
+{
+    return "in-place 32-bit implementation";
+}
+
 
 #define ROL32(a, offset) ((((uint32_t)a) << (offset)) ^ (((uint32_t)a) >> (32-(offset))))
 
@@ -167,7 +168,7 @@ void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const un
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
+static void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
 {
 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
     const uint32_t * pI = (const uint32_t *)data;
@@ -207,79 +208,37 @@ void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int l
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    SnP_AddBytes(state, data, offset, length, KeccakP1600_AddLanes, KeccakP1600_AddBytesInLane, 8);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    KeccakP1600_SetBytesInLaneToZero(state, lanePosition, offset, length);
-    KeccakP1600_AddBytesInLane(state, lanePosition, data, offset, length);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_OverwriteLanes(void *state, const unsigned char *data, unsigned int laneCount)
-{
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    const uint32_t * pI = (const uint32_t *)data;
-    uint32_t * pS = (uint32_t *)state;
-    uint32_t t, x0, x1;
-    int i;
-    for (i = laneCount-1; i >= 0; --i) {
-#ifdef NO_MISALIGNED_ACCESSES
-        uint32_t low;
-        uint32_t high;
-        memcpy(&low, pI++, 4);
-        memcpy(&high, pI++, 4);
-        toBitInterleavingAndSet(low, high, *(pS++), *(pS++), t, x0, x1);
-#else
-        toBitInterleavingAndSet(*(pI++), *(pI++), *(pS++), *(pS++), t, x0, x1)
-#endif
-    }
-#else
-    unsigned int lanePosition;
-    for(lanePosition=0; lanePosition<laneCount; lanePosition++) {
-        uint8_t laneAsBytes[8];
-        memcpy(laneAsBytes, data+lanePosition*8, 8);
-        uint32_t low = laneAsBytes[0]
-            | ((uint32_t)(laneAsBytes[1]) << 8)
-            | ((uint32_t)(laneAsBytes[2]) << 16)
-            | ((uint32_t)(laneAsBytes[3]) << 24);
-        uint32_t high = laneAsBytes[4]
-            | ((uint32_t)(laneAsBytes[5]) << 8)
-            | ((uint32_t)(laneAsBytes[6]) << 16)
-            | ((uint32_t)(laneAsBytes[7]) << 24);
-        uint32_t even, odd, temp, temp0, temp1;
-        uint32_t *stateAsHalfLanes = (uint32_t*)state;
-        toBitInterleavingAndSet(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
+#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
+    { \
+        if ((offset) == 0) { \
+            SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_AddBytesInLane(state, \
+                (length)/SnP_laneLengthInBytes, \
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+                0, \
+                (length)%SnP_laneLengthInBytes); \
+        } \
+        else { \
+            unsigned int _sizeLeft = (length); \
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+            const unsigned char *_curData = (data); \
+            while(_sizeLeft > 0) { \
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+                if (_bytesInLane > _sizeLeft) \
+                    _bytesInLane = _sizeLeft; \
+                SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
     }
-#endif
-}
 
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    SnP_OverwriteBytes(state, data, offset, length, KeccakP1600_OverwriteLanes, KeccakP1600_OverwriteBytesInLane, 8);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
+void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
 {
-    uint32_t *stateAsHalfLanes = (uint32_t*)state;
-    unsigned int i;
-
-    for(i=0; i<byteCount/8; i++) {
-        stateAsHalfLanes[i*2+0] = 0;
-        stateAsHalfLanes[i*2+1] = 0;
-    }
-    if (byteCount%8 != 0)
-        KeccakP1600_SetBytesInLaneToZero(state, byteCount/8, 0, byteCount%8);
+    SnP_AddBytes(state, data, offset, length, KeccakP1600_AddLanes, KeccakP1600_AddBytesInLane, 8);
 }
 
 /* ---------------------------------------------------------------- */
@@ -349,84 +308,37 @@ void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned i
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
-{
-    SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
-{
-    uint32_t *stateAsHalfLanes = (uint32_t*)state;
-    uint32_t low, high, temp, temp0, temp1;
-    uint8_t laneAsBytes[8];
-    unsigned int i;
-
-    fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    *((uint32_t*)(laneAsBytes+0)) = low;
-    *((uint32_t*)(laneAsBytes+4)) = high;
-#else
-    laneAsBytes[0] = low & 0xFF;
-    laneAsBytes[1] = (low >> 8) & 0xFF;
-    laneAsBytes[2] = (low >> 16) & 0xFF;
-    laneAsBytes[3] = (low >> 24) & 0xFF;
-    laneAsBytes[4] = high & 0xFF;
-    laneAsBytes[5] = (high >> 8) & 0xFF;
-    laneAsBytes[6] = (high >> 16) & 0xFF;
-    laneAsBytes[7] = (high >> 24) & 0xFF;
-#endif
-    for(i=0; i<length; i++)
-        output[i] = input[i] ^ laneAsBytes[offset+i];
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_ExtractAndAddLanes(const void *state, const unsigned char *input, unsigned char *output, unsigned int laneCount)
-{
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    const uint32_t * pI = (const uint32_t *)input;
-    uint32_t * pO = (uint32_t *)output;
-    const uint32_t * pS = (const uint32_t *)state;
-    uint32_t t, x0, x1;
-    int i;
-    for (i = laneCount-1; i >= 0; --i) {
-#ifdef NO_MISALIGNED_ACCESSES
-        uint32_t low;
-        uint32_t high;
-        fromBitInterleaving(*(pS++), *(pS++), low, high, t, x0, x1);
-        *(pO++) = *(pI++) ^ low;
-        *(pO++) = *(pI++) ^ high;
-#else
-        fromBitInterleavingAndXOR(*(pS++), *(pS++), *(pI++), *(pI++), *(pO++), *(pO++), t, x0, x1)
-#endif
+#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
+    { \
+        if ((offset) == 0) { \
+            SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_ExtractBytesInLane(state, \
+                (length)/SnP_laneLengthInBytes, \
+                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+                0, \
+                (length)%SnP_laneLengthInBytes); \
+        } \
+        else { \
+            unsigned int _sizeLeft = (length); \
+            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+            unsigned char *_curData = (data); \
+            while(_sizeLeft > 0) { \
+                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+                if (_bytesInLane > _sizeLeft) \
+                    _bytesInLane = _sizeLeft; \
+                SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
     }
-#else
-    unsigned int lanePosition;
-    for(lanePosition=0; lanePosition<laneCount; lanePosition++) {
-        uint32_t *stateAsHalfLanes = (uint32_t*)state;
-        uint32_t low, high, temp, temp0, temp1;
-        fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
-        uint8_t laneAsBytes[8];
-        laneAsBytes[0] = low & 0xFF;
-        laneAsBytes[1] = (low >> 8) & 0xFF;
-        laneAsBytes[2] = (low >> 16) & 0xFF;
-        laneAsBytes[3] = (low >> 24) & 0xFF;
-        laneAsBytes[4] = high & 0xFF;
-        laneAsBytes[5] = (high >> 8) & 0xFF;
-        laneAsBytes[6] = (high >> 16) & 0xFF;
-        laneAsBytes[7] = (high >> 24) & 0xFF;
-        ((uint32_t*)(output+lanePosition*8))[0] = ((uint32_t*)(input+lanePosition*8))[0] ^ (*(const uint32_t*)(laneAsBytes+0));
-        ((uint32_t*)(output+lanePosition*8))[1] = ((uint32_t*)(input+lanePosition*8))[0] ^ (*(const uint32_t*)(laneAsBytes+4));
-    }
-#endif
-}
-/* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
 {
-    SnP_ExtractAndAddBytes(state, input, output, offset, length, KeccakP1600_ExtractAndAddLanes, KeccakP1600_ExtractAndAddBytesInLane, 8);
+    SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8);
 }
 
 /* ---------------------------------------------------------------- */
@@ -1154,10 +1066,3 @@ void KeccakP1600_Permute_12rounds(void *state)
 {
      KeccakP1600_Permute_Nrounds(state, 12);
 }
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP1600_Permute_24rounds(void *state)
-{
-     KeccakP1600_Permute_Nrounds(state, 24);
-}