sha3 1.0.5 → 2.0.0

data/ext/sha3/lib/low/KeccakP-1600/ref-32bits/KeccakP-1600-reference32BI.c

@@ -32,6 +32,7 @@ Please refer to LowLevel.build for the exact list of other files it must be comb
 #ifdef KeccakReference
 #include "displayIntermediateValues.h"
 #endif
+#include "KeccakP-1600-SnP.h"
 
 #define maxNrRounds 24
 #define nrLanes 25
@@ -187,16 +188,16 @@ static const unsigned int KeccakRhoOffsets[nrLanes] =
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_Initialize(void *state)
+void KeccakP1600_Initialize(KeccakP1600_plain32_state *state)
 {
     memset(state, 0, 1600/8);
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_AddBytes(KeccakP1600_plain32_state *state, const unsigned char *data, unsigned int offset, unsigned int length);
 
-void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
+void KeccakP1600_AddByte(KeccakP1600_plain32_state *state, unsigned char byte, unsigned int offset)
 {
     unsigned char data[1];
 
@@ -209,13 +210,12 @@ void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_AddBytesInLane(KeccakP1600_plain32_state *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
         uint8_t laneAsBytes[8];
         uint32_t low, high;
         uint32_t lane[2];
-        uint32_t *stateAsHalfLanes;
 
         memset(laneAsBytes, 0, 8);
         memcpy(laneAsBytes+offset, data, length);
@@ -228,13 +228,12 @@ void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const un
             | ((uint32_t)(laneAsBytes[6]) << 16)
             | ((uint32_t)(laneAsBytes[7]) << 24);
         toBitInterleaving(low, high, lane, lane+1);
-        stateAsHalfLanes = (uint32_t*)state;
-        stateAsHalfLanes[lanePosition*2+0] ^= lane[0];
-        stateAsHalfLanes[lanePosition*2+1] ^= lane[1];
+        state->A[lanePosition*2+0] ^= lane[0];
+        state->A[lanePosition*2+1] ^= lane[1];
     }
 }
 
-void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_AddBytes(KeccakP1600_plain32_state *state, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     unsigned int lanePosition = offset/8;
     unsigned int offsetInLane = offset%8;
@@ -257,15 +256,14 @@ void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int o
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_ExtractBytesInLane(const KeccakP1600_plain32_state *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length);
 
-void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_OverwriteBytesInLane(KeccakP1600_plain32_state *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
         uint8_t laneAsBytes[8];
         uint32_t low, high;
         uint32_t lane[2];
-        uint32_t *stateAsHalfLanes;
 
         KeccakP1600_ExtractBytesInLane(state, lanePosition, laneAsBytes, 0, 8);
         memcpy(laneAsBytes+offset, data, length);
@@ -278,13 +276,12 @@ void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, co
             | ((uint32_t)(laneAsBytes[6]) << 16)
             | ((uint32_t)(laneAsBytes[7]) << 24);
         toBitInterleaving(low, high, lane, lane+1);
-        stateAsHalfLanes = (uint32_t*)state;
-        stateAsHalfLanes[lanePosition*2+0] = lane[0];
-        stateAsHalfLanes[lanePosition*2+1] = lane[1];
+        state->A[lanePosition*2+0] = lane[0];
+        state->A[lanePosition*2+1] = lane[1];
     }
 }
 
-void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_OverwriteBytes(KeccakP1600_plain32_state *state, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     unsigned int lanePosition = offset/8;
     unsigned int offsetInLane = offset%8;
@@ -307,7 +304,7 @@ void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
+void KeccakP1600_OverwriteWithZeroes(KeccakP1600_plain32_state *state, unsigned int byteCount)
 {
     uint8_t laneAsBytes[8];
     unsigned int lanePosition = 0;
@@ -322,9 +319,8 @@ void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
             byteCount = 0;
         }
         else {
-            uint32_t *stateAsHalfLanes = (uint32_t*)state;
-            stateAsHalfLanes[lanePosition*2+0] = 0;
-            stateAsHalfLanes[lanePosition*2+1] = 0;
+            state->A[lanePosition*2+0] = 0;
+            state->A[lanePosition*2+1] = 0;
             byteCount -= 8;
             lanePosition++;
         }
@@ -339,11 +335,10 @@ static void rho(uint32_t *A);
 static void pi(uint32_t *A);
 static void chi(uint32_t *A);
 static void iota(uint32_t *A, unsigned int indexRound);
-void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_ExtractBytes(const KeccakP1600_plain32_state *state, unsigned char *data, unsigned int offset, unsigned int length);
 
-void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds)
+void KeccakP1600_Permute_Nrounds(KeccakP1600_plain32_state *state, unsigned int nrounds)
 {
-    uint32_t *stateAsHalfLanes = (uint32_t*)state;
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -351,7 +346,7 @@ void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds)
         displayStateAsBytes(1, "Input of permutation", stateAsBytes, 1600);
 #endif
     }
-    KeccakP1600_PermutationOnWords(stateAsHalfLanes, nrounds);
+    KeccakP1600_PermutationOnWords(state->A, nrounds);
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -362,9 +357,8 @@ void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds)
 }
 
 
-void KeccakP1600_Permute_12rounds(void *state)
+void KeccakP1600_Permute_12rounds(KeccakP1600_plain32_state *state)
 {
-    uint32_t *stateAsHalfLanes = (uint32_t*)state;
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -372,7 +366,7 @@ void KeccakP1600_Permute_12rounds(void *state)
         displayStateAsBytes(1, "Input of permutation", stateAsBytes, 1600);
 #endif
     }
-    KeccakP1600_PermutationOnWords(stateAsHalfLanes, 12);
+    KeccakP1600_PermutationOnWords(state->A, 12);
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -382,9 +376,8 @@ void KeccakP1600_Permute_12rounds(void *state)
     }
 }
 
-void KeccakP1600_Permute_24rounds(void *state)
+void KeccakP1600_Permute_24rounds(KeccakP1600_plain32_state *state)
 {
-    uint32_t *stateAsHalfLanes = (uint32_t*)state;
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -392,7 +385,7 @@ void KeccakP1600_Permute_24rounds(void *state)
         displayStateAsBytes(1, "Input of permutation", stateAsBytes, 1600);
 #endif
     }
-    KeccakP1600_PermutationOnWords(stateAsHalfLanes, 24);
+    KeccakP1600_PermutationOnWords(state->A, 24);
     {
         uint8_t stateAsBytes[1600/8];
         KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
@@ -522,13 +515,12 @@ static void iota(uint32_t *A, unsigned int indexRound)
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractBytesInLane(const KeccakP1600_plain32_state *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length)
 {
     if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
-        uint32_t *stateAsHalfLanes = (uint32_t*)state;
         uint32_t lane[2];
         uint8_t laneAsBytes[8];
-        fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], lane, lane+1);
+        fromBitInterleaving(state->A[lanePosition*2], state->A[lanePosition*2+1], lane, lane+1);
         laneAsBytes[0] = lane[0] & 0xFF;
         laneAsBytes[1] = (lane[0] >> 8) & 0xFF;
         laneAsBytes[2] = (lane[0] >> 16) & 0xFF;
@@ -541,7 +533,7 @@ void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition
     }
 }
 
-void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractBytes(const KeccakP1600_plain32_state *state, unsigned char *data, unsigned int offset, unsigned int length)
 {
     unsigned int lanePosition = offset/8;
     unsigned int offsetInLane = offset%8;
@@ -564,7 +556,7 @@ void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned i
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractAndAddBytesInLane(const KeccakP1600_plain32_state *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
 {
     if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
         uint8_t laneAsBytes[8];
@@ -576,7 +568,7 @@ void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePo
     }
 }
 
-void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractAndAddBytes(const KeccakP1600_plain32_state *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
 {
     unsigned int lanePosition = offset/8;
     unsigned int offsetInLane = offset%8;

data/ext/sha3/lib/low/KeccakP-1600/ref-64bits/KeccakP-1600-SnP.h

@@ -21,24 +21,30 @@ Please refer to SnP-documentation.h for more details.
 #ifndef _KeccakP_1600_SnP_h_
 #define _KeccakP_1600_SnP_h_
 
+#include <stdint.h>
+
+typedef struct {
+    uint8_t A[200];
+} KeccakP1600_plain8_state;
+
+typedef KeccakP1600_plain8_state KeccakP1600_state;
+
 #define KeccakP1600_implementation      "64-bit reference implementation"
-#define KeccakP1600_stateSizeInBytes    200
-#define KeccakP1600_stateAlignment      8
 
 #ifdef KeccakReference
 void KeccakP1600_StaticInitialize( void );
 #else
 #define KeccakP1600_StaticInitialize()
 #endif
-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);
+void KeccakP1600_Initialize(KeccakP1600_plain8_state *state);
+void KeccakP1600_AddByte(KeccakP1600_plain8_state *state, unsigned char data, unsigned int offset);
+void KeccakP1600_AddBytes(KeccakP1600_plain8_state *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteBytes(KeccakP1600_plain8_state *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteWithZeroes(KeccakP1600_plain8_state *state, unsigned int byteCount);
+void KeccakP1600_Permute_Nrounds(KeccakP1600_plain8_state *state, unsigned int nrounds);
+void KeccakP1600_Permute_12rounds(KeccakP1600_plain8_state *state);
+void KeccakP1600_Permute_24rounds(KeccakP1600_plain8_state *state);
+void KeccakP1600_ExtractBytes(const KeccakP1600_plain8_state *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_ExtractAndAddBytes(const KeccakP1600_plain8_state *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
 
 #endif

data/ext/sha3/lib/low/KeccakP-1600/ref-64bits/KeccakP-1600-reference.c

@@ -33,6 +33,7 @@ Please refer to LowLevel.build for the exact list of other files it must be comb
 #ifdef KeccakReference
 #include "displayIntermediateValues.h"
 #endif
+#include "KeccakP-1600-SnP.h"
 
 typedef uint64_t tKeccakLane;
 
@@ -142,24 +143,24 @@ static const unsigned int KeccakRhoOffsets[nrLanes] =
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_Initialize(void *state)
+void KeccakP1600_Initialize(KeccakP1600_plain8_state *state)
 {
-    memset(state, 0, 1600/8);
+    memset(state->A, 0, sizeof(state->A));
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
+void KeccakP1600_AddByte(KeccakP1600_plain8_state *state, unsigned char byte, unsigned int offset)
 {
     #if DEBUG
     assert(offset < 200);
     #endif
-    ((unsigned char *)state)[offset] ^= byte;
+    state->A[offset] ^= byte;
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_AddBytes(KeccakP1600_plain8_state *state, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     unsigned int i;
 
@@ -168,28 +169,28 @@ void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int o
     assert(offset+length <= 200);
     #endif
     for(i=0; i<length; i++)
-        ((unsigned char *)state)[offset+i] ^= data[i];
+        state->A[offset+i] ^= data[i];
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_OverwriteBytes(KeccakP1600_plain8_state *state, const unsigned char *data, unsigned int offset, unsigned int length)
 {
     #if DEBUG
     assert(offset < 200);
     assert(offset+length <= 200);
     #endif
-    memcpy((unsigned char*)state+offset, data, length);
+    memcpy(state->A+offset, data, length);
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
+void KeccakP1600_OverwriteWithZeroes(KeccakP1600_plain8_state *state, unsigned int byteCount)
 {
     #if DEBUG
     assert(byteCount <= 200);
     #endif
-    memset(state, 0, byteCount);
+    memset(state->A, 0, byteCount);
 }
 
 /* ---------------------------------------------------------------- */
@@ -206,71 +207,39 @@ static void pi(tKeccakLane *A);
 static void chi(tKeccakLane *A);
 static void iota(tKeccakLane *A, unsigned int indexRound);
 
-void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds)
+void KeccakP1600_Permute_Nrounds(KeccakP1600_plain8_state *state, unsigned int nrounds)
 {
 #if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
     tKeccakLane stateAsWords[1600/64];
 #endif
 
 #ifdef KeccakReference
-    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state, 1600);
+    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state->A, 1600);
 #endif
 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakP1600OnWords((tKeccakLane*)state, nrounds);
+    KeccakP1600OnWords((tKeccakLane*)state->A, nrounds);
 #else
-    fromBytesToWords(stateAsWords, (const unsigned char *)state);
+    fromBytesToWords(stateAsWords, state->A);
     KeccakP1600OnWords(stateAsWords, nrounds);
-    fromWordsToBytes((unsigned char *)state, stateAsWords);
+    fromWordsToBytes(state->A, stateAsWords);
 #endif
 #ifdef KeccakReference
-    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state, 1600);
+    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state->A, 1600);
 #endif
 }
 
-void KeccakP1600_Permute_12rounds(void *state)
+void KeccakP1600_Permute_12rounds(KeccakP1600_plain8_state *state)
 {
-#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-    tKeccakLane stateAsWords[1600/64];
-#endif
-
-#ifdef KeccakReference
-    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state, 1600);
-#endif
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakP1600OnWords((tKeccakLane*)state, 12);
-#else
-    fromBytesToWords(stateAsWords, (const unsigned char *)state);
-    KeccakP1600OnWords(stateAsWords, 12);
-    fromWordsToBytes((unsigned char *)state, stateAsWords);
-#endif
-#ifdef KeccakReference
-    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state, 1600);
-#endif
+    KeccakP1600_Permute_Nrounds(state, 12);
 }
 
-void KeccakP1600_Permute_24rounds(void *state)
+void KeccakP1600_Permute_24rounds(KeccakP1600_plain8_state *state)
 {
-#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-    tKeccakLane stateAsWords[1600/64];
-#endif
-
-#ifdef KeccakReference
-    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state, 1600);
-#endif
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakP1600OnWords((tKeccakLane*)state, 24);
-#else
-    fromBytesToWords(stateAsWords, (const unsigned char *)state);
-    KeccakP1600OnWords(stateAsWords, 24);
-    fromWordsToBytes((unsigned char *)state, stateAsWords);
-#endif
-#ifdef KeccakReference
-    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state, 1600);
-#endif
+    KeccakP1600_Permute_Nrounds(state, 24);
 }
 
 #if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-static void fromBytesToWords(tKeccakLane *stateAsWords, const unsigned char *state)
+static void fromBytesToWords(tKeccakLane *stateAsWords, const uint8_t *state)
 {
     unsigned int i, j;
 
@@ -281,13 +250,13 @@ static void fromBytesToWords(tKeccakLane *stateAsWords, const unsigned char *sta
     }
 }
 
-static void fromWordsToBytes(unsigned char *state, const tKeccakLane *stateAsWords)
+static void fromWordsToBytes(uint8_t *state, const tKeccakLane *stateAsWords)
 {
     unsigned int i, j;
 
     for(i=0; i<nrLanes; i++)
         for(j=0; j<(64/8); j++)
-            state[i*(64/8)+j] = (unsigned char)((stateAsWords[i] >> (8*j)) & 0xFF);
+            state[i*(64/8)+j] = (uint8_t)((stateAsWords[i] >> (8*j)) & 0xFF);
 }
 #endif
 
@@ -393,18 +362,18 @@ static void iota(tKeccakLane *A, unsigned int indexRound)
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractBytes(const KeccakP1600_plain8_state *state, unsigned char *data, unsigned int offset, unsigned int length)
 {
     #if DEBUG
     assert(offset < 200);
     assert(offset+length <= 200);
     #endif
-    memcpy(data, (unsigned char*)state+offset, length);
+    memcpy(data, state->A+offset, length);
 }
 
 /* ---------------------------------------------------------------- */
 
-void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+void KeccakP1600_ExtractAndAddBytes(const KeccakP1600_plain8_state *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
 {
     unsigned int i;
 
@@ -413,7 +382,7 @@ void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *inpu
     assert(offset+length <= 200);
     #endif
     for(i=0; i<length; i++)
-        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
+        output[i] = input[i] ^ state->A[offset+i];
 }
 
 /* ---------------------------------------------------------------- */