sha3 0.2.2 → 1.0.2

data/ext/sha3/{KeccakF-1600-unrolling.macros → Optimized64/KeccakF-1600-unrolling.macros}

@@ -1,17 +1,19 @@
 /*
-The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
-Michaël Peeters and Gilles Van Assche. For more information, feedback or
-questions, please refer to our website: http://keccak.noekeon.org/
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
 
-Implementation by the designers,
-hereby denoted as "the implementer".
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
 
 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/
 */
 
-#if (Unrolling == 24)
+#if (defined(FullUnrolling))
 #define rounds \
     prepareTheta \
     thetaRhoPiChiIotaPrepareTheta( 0, A, E) \
@@ -38,7 +40,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
     thetaRhoPiChiIotaPrepareTheta(21, E, A) \
     thetaRhoPiChiIotaPrepareTheta(22, A, E) \
     thetaRhoPiChiIota(23, E, A) \
-    copyToState(state, A)
+
 #elif (Unrolling == 12)
 #define rounds \
     prepareTheta \
@@ -56,7 +58,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i+10, A, E) \
         thetaRhoPiChiIotaPrepareTheta(i+11, E, A) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 8)
 #define rounds \
     prepareTheta \
@@ -70,7 +72,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i+6, A, E) \
         thetaRhoPiChiIotaPrepareTheta(i+7, E, A) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 6)
 #define rounds \
     prepareTheta \
@@ -82,7 +84,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
         thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 4)
 #define rounds \
     prepareTheta \
@@ -92,7 +94,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
         thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 3)
 #define rounds \
     prepareTheta \
@@ -102,7 +104,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
         copyStateVariables(A, E) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 2)
 #define rounds \
     prepareTheta \
@@ -110,7 +112,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
         thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
     } \
-    copyToState(state, A)
+
 #elif (Unrolling == 1)
 #define rounds \
     prepareTheta \
@@ -118,7 +120,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
         thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
         copyStateVariables(A, E) \
     } \
-    copyToState(state, A)
+
 #else
 #error "Unrolling is not correctly specified!"
 #endif

data/ext/sha3/Optimized64/SnP-interface.h

@@ -0,0 +1,47 @@
+/*
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
+
+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 _SnP_Interface_h_
+#define _SnP_Interface_h_
+
+#include "KeccakF-1600-interface.h"
+
+#define SnP_width                           KeccakF_width
+#define SnP_stateSizeInBytes                KeccakF_stateSizeInBytes
+#define SnP_laneLengthInBytes               KeccakF_laneInBytes
+#define SnP_laneCount                       25
+
+#define SnP_StaticInitialize                KeccakF1600_Initialize
+#define SnP_Initialize                      KeccakF1600_StateInitialize
+#define SnP_XORBytesInLane                  KeccakF1600_StateXORBytesInLane
+#define SnP_XORLanes                        KeccakF1600_StateXORLanes
+#define SnP_OverwriteBytesInLane            KeccakF1600_StateOverwriteBytesInLane
+#define SnP_OverwriteLanes                  KeccakF1600_StateOverwriteLanes
+#define SnP_OverwriteWithZeroes             KeccakF1600_StateOverwriteWithZeroes
+#define SnP_ComplementBit                   KeccakF1600_StateComplementBit
+#define SnP_Permute                         KeccakF1600_StatePermute
+#define SnP_ExtractBytesInLane              KeccakF1600_StateExtractBytesInLane
+#define SnP_ExtractLanes                    KeccakF1600_StateExtractLanes
+#define SnP_ExtractAndXORBytesInLane        KeccakF1600_StateExtractAndXORBytesInLane
+#define SnP_ExtractAndXORLanes              KeccakF1600_StateExtractAndXORLanes
+
+#include "SnP-Relaned.h"
+
+#define SnP_FBWL_Absorb                     KeccakF1600_FBWL_Absorb
+#define SnP_FBWL_Squeeze                    KeccakF1600_FBWL_Squeeze
+#define SnP_FBWL_Wrap                       KeccakF1600_FBWL_Wrap
+#define SnP_FBWL_Unwrap                     KeccakF1600_FBWL_Unwrap
+
+#endif

data/ext/sha3/Reference/KeccakF-1600-reference.c

@@ -0,0 +1,311 @@
+/*
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
+
+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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "brg_endian.h"
+#include "displayIntermediateValues.h"
+
+typedef unsigned char UINT8;
+typedef unsigned long long UINT64;
+typedef UINT64 tKeccakLane;
+
+#define nrRounds 24
+tKeccakLane KeccakRoundConstants[nrRounds];
+#define nrLanes 25
+unsigned int KeccakRhoOffsets[nrLanes];
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_InitializeRoundConstants();
+void KeccakF1600_InitializeRhoOffsets();
+int LFSR86540(UINT8 *LFSR);
+
+void KeccakF1600_Initialize()
+{
+    if (sizeof(tKeccakLane) != 8) {
+        printf("tKeccakLane should be 64-bit wide\n");
+        abort();
+    }
+    KeccakF1600_InitializeRoundConstants();
+    KeccakF1600_InitializeRhoOffsets();
+}
+
+void KeccakF1600_InitializeRoundConstants()
+{
+    UINT8 LFSRstate = 0x01;
+    unsigned int i, j, bitPosition;
+
+    for(i=0; i<nrRounds; i++) {
+        KeccakRoundConstants[i] = 0;
+        for(j=0; j<7; j++) {
+            bitPosition = (1<<j)-1; //2^j-1
+            if (LFSR86540(&LFSRstate))
+                KeccakRoundConstants[i] ^= (tKeccakLane)1<<bitPosition;
+        }
+    }
+}
+
+#define index(x, y) (((x)%5)+5*((y)%5))
+
+void KeccakF1600_InitializeRhoOffsets()
+{
+    unsigned int x, y, t, newX, newY;
+
+    KeccakRhoOffsets[index(0, 0)] = 0;
+    x = 1;
+    y = 0;
+    for(t=0; t<24; t++) {
+        KeccakRhoOffsets[index(x, y)] = ((t+1)*(t+2)/2) % 64;
+        newX = (0*x+1*y) % 5;
+        newY = (2*x+3*y) % 5;
+        x = newX;
+        y = newY;
+    }
+}
+
+int LFSR86540(UINT8 *LFSR)
+{
+    int result = ((*LFSR) & 0x01) != 0;
+    if (((*LFSR) & 0x80) != 0)
+        // Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1
+        (*LFSR) = ((*LFSR) << 1) ^ 0x71;
+    else
+        (*LFSR) <<= 1;
+    return result;
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateInitialize(void *state)
+{
+    memset(state, 0, KeccakF_width/8);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateXORBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    unsigned int i;
+
+    for(i=0; i<length; i++)
+        ((unsigned char *)state)[offset+i] ^= data[i];
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateOverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    memcpy((unsigned char*)state+offset, data, length);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateOverwriteWithZeroes(void *state, unsigned int byteCount)
+{
+    memset(state, 0, byteCount);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateComplementBit(void *state, unsigned int position)
+{
+    if (position < 1600) {
+        unsigned int bytePosition = position/8;
+        unsigned int bitPosition = position%8;
+
+        ((unsigned char *)state)[bytePosition] ^= (UINT8)1 << bitPosition;
+    }
+}
+
+/* ---------------------------------------------------------------- */
+
+void fromBytesToWords(tKeccakLane *stateAsWords, const unsigned char *state);
+void fromWordsToBytes(unsigned char *state, const tKeccakLane *stateAsWords);
+void KeccakF1600OnWords(tKeccakLane *state);
+void KeccakF1600Round(tKeccakLane *state, unsigned int indexRound);
+void theta(tKeccakLane *A);
+void rho(tKeccakLane *A);
+void pi(tKeccakLane *A);
+void chi(tKeccakLane *A);
+void iota(tKeccakLane *A, unsigned int indexRound);
+
+void KeccakF1600_StatePermute(void *state)
+{
+#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
+    tKeccakLane stateAsWords[KeccakF_width/64];
+#endif
+
+    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state);
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    KeccakF1600OnWords((tKeccakLane*)state);
+#else
+    fromBytesToWords(stateAsWords, (const unsigned char *)state);
+    KeccakF1600OnWords(stateAsWords);
+    fromWordsToBytes((unsigned char *)state, stateAsWords);
+#endif
+    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state);
+}
+
+void fromBytesToWords(tKeccakLane *stateAsWords, const unsigned char *state)
+{
+    unsigned int i, j;
+
+    for(i=0; i<nrLanes; i++) {
+        stateAsWords[i] = 0;
+        for(j=0; j<(64/8); j++)
+            stateAsWords[i] |= (tKeccakLane)(state[i*(64/8)+j]) << (8*j);
+    }
+}
+
+void fromWordsToBytes(unsigned char *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] = (stateAsWords[i] >> (8*j)) & 0xFF;
+}
+
+void KeccakF1600OnWords(tKeccakLane *state)
+{
+    unsigned int i;
+
+    displayStateAsLanes(3, "Same, with lanes as 64-bit words", state);
+
+    for(i=0; i<nrRounds; i++)
+        KeccakF1600Round(state, i);
+}
+
+void KeccakF1600Round(tKeccakLane *state, unsigned int indexRound)
+{
+    displayRoundNumber(3, indexRound);
+
+    theta(state);
+    displayStateAsLanes(3, "After theta", state);
+
+    rho(state);
+    displayStateAsLanes(3, "After rho", state);
+
+    pi(state);
+    displayStateAsLanes(3, "After pi", state);
+
+    chi(state);
+    displayStateAsLanes(3, "After chi", state);
+
+    iota(state, indexRound);
+    displayStateAsLanes(3, "After iota", state);
+}
+
+#define ROL64(a, offset) ((offset != 0) ? ((((tKeccakLane)a) << offset) ^ (((tKeccakLane)a) >> (64-offset))) : a)
+
+void theta(tKeccakLane *A)
+{
+    unsigned int x, y;
+    tKeccakLane C[5], D[5];
+
+    for(x=0; x<5; x++) {
+        C[x] = 0;
+        for(y=0; y<5; y++)
+            C[x] ^= A[index(x, y)];
+    }
+    for(x=0; x<5; x++)
+        D[x] = ROL64(C[(x+1)%5], 1) ^ C[(x+4)%5];
+    for(x=0; x<5; x++)
+        for(y=0; y<5; y++)
+            A[index(x, y)] ^= D[x];
+}
+
+void rho(tKeccakLane *A)
+{
+    unsigned int x, y;
+
+    for(x=0; x<5; x++) for(y=0; y<5; y++)
+        A[index(x, y)] = ROL64(A[index(x, y)], KeccakRhoOffsets[index(x, y)]);
+}
+
+void pi(tKeccakLane *A)
+{
+    unsigned int x, y;
+    tKeccakLane tempA[25];
+
+    for(x=0; x<5; x++) for(y=0; y<5; y++)
+        tempA[index(x, y)] = A[index(x, y)];
+    for(x=0; x<5; x++) for(y=0; y<5; y++)
+        A[index(0*x+1*y, 2*x+3*y)] = tempA[index(x, y)];
+}
+
+void chi(tKeccakLane *A)
+{
+    unsigned int x, y;
+    tKeccakLane C[5];
+
+    for(y=0; y<5; y++) {
+        for(x=0; x<5; x++)
+            C[x] = A[index(x, y)] ^ ((~A[index(x+1, y)]) & A[index(x+2, y)]);
+        for(x=0; x<5; x++)
+            A[index(x, y)] = C[x];
+    }
+}
+
+void iota(tKeccakLane *A, unsigned int indexRound)
+{
+    A[index(0, 0)] ^= KeccakRoundConstants[indexRound];
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    memcpy(data, (unsigned char*)state+offset, length);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakF1600_StateExtractAndXORBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    unsigned int i;
+
+    for(i=0; i<length; i++)
+        data[i] ^= ((unsigned char *)state)[offset+i];
+}
+
+/* ---------------------------------------------------------------- */
+
+void displayRoundConstants(FILE *f)
+{
+    unsigned int i;
+
+    for(i=0; i<nrRounds; i++) {
+        fprintf(f, "RC[%02i][0][0] = ", i);
+        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] >> 32));
+        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] & 0xFFFFFFFFULL));
+        fprintf(f, "\n");
+    }
+    fprintf(f, "\n");
+}
+
+void displayRhoOffsets(FILE *f)
+{
+    unsigned int x, y;
+
+    for(y=0; y<5; y++) for(x=0; x<5; x++) {
+        fprintf(f, "RhoOffset[%i][%i] = ", x, y);
+        fprintf(f, "%2i", KeccakRhoOffsets[index(x, y)]);
+        fprintf(f, "\n");
+    }
+    fprintf(f, "\n");
+}