sleeping_kangaroo12 0.0.1

data/ext/xkcp/lib/low/KeccakP-800/compact/KeccakP-800-SnP.h

@@ -0,0 +1,40 @@
+/*
+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 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 SnP-documentation.h for more details.
+*/
+
+#ifndef _KeccakP_800_SnP_h_
+#define _KeccakP_800_SnP_h_
+
+#define KeccakP800_implementation      "32-bit compact implementation"
+#define KeccakP800_stateSizeInBytes    100
+#define KeccakP800_stateAlignment      4
+
+#define KeccakP800_StaticInitialize()
+void KeccakP800_Initialize(void *state);
+void KeccakP800_AddByte(void *state, unsigned char data, unsigned int offset);
+void KeccakP800_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_OverwriteWithZeroes(void *state, unsigned int byteCount);
+void KeccakP800_Permute_Nrounds(void *state, unsigned int nrounds);
+void KeccakP800_Permute_12rounds(void *state);
+void KeccakP800_Permute_22rounds(void *state);
+void KeccakP800_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
+
+#endif

data/ext/xkcp/lib/low/KeccakP-800/compact/KeccakP-800-compact.c

@@ -0,0 +1,244 @@
+/*
+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 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/
+
+---
+
+This file implements Keccak-p[800] in a SnP-compatible way.
+Please refer to SnP-documentation.h for more details.
+
+This implementation comes with KeccakP-800-SnP.h in the same folder.
+Please refer to LowLevel.build for the exact list of other files it must be combined with.
+*/
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "brg_endian.h"
+#include "KeccakP-800-SnP.h"
+
+#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
+#error Not yet implemented
+#endif
+
+#define USE_MEMSET
+/* #define DIVISION_INSTRUCTION    /* comment if no division instruction or more compact when not using division */
+#define UNROLL_CHILOOP        /* comment more compact using for loop */
+
+typedef uint_fast8_t tSmallUInt;
+typedef uint32_t tKeccakLane;
+
+#if defined (__arm__) && !defined(__GNUC__)
+#define ROL32(a, offset) __ror(a, 32-(offset))
+#elif defined(_MSC_VER)
+#define ROL32(a, offset) _rotl(a, offset)
+#else
+#define ROL32(a, offset) ((((uint32_t)a) << offset) ^ (((uint32_t)a) >> (32-offset)))
+#endif
+
+#define    cKeccakNumberOfRounds    22
+
+const uint8_t KeccakP800_RotationConstants[25] =
+{
+     1,  3,  6, 10, 15, 21, 28, 4, 13, 23,  2, 14, 27, 9, 24,  8, 25, 11, 30, 18, 7, 29, 20, 12
+};
+
+const uint8_t KeccakP800_PiLane[25] =
+{
+    10,  7, 11, 17, 18,  3,  5, 16,  8, 21, 24,  4, 15, 23, 19, 13, 12,  2, 20, 14, 22,  9,  6,  1
+};
+
+#if    defined(DIVISION_INSTRUCTION)
+#define MOD5(argValue)    ((argValue) % 5)
+#else
+const uint8_t KeccakP800_Mod5[10] =
+{
+    0, 1, 2, 3, 4, 0, 1, 2, 3, 4
+};
+#define MOD5(argValue)    KeccakP800_Mod5[argValue]
+#endif
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_Initialize(void *argState)
+{
+    #if defined(USE_MEMSET)
+    memset( argState, 0, 25 * sizeof(tKeccakLane) );
+    #else
+    tSmallUInt i;
+    tKeccakLane *state;
+
+    state = (tKeccakLane*)argState;
+    i = 25;
+    do
+    {
+        *(state++) = 0;
+    }
+    while ( --i != 0 );
+    #endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_AddByte(void *state, unsigned char data, unsigned int offset)
+{
+    ((unsigned char *)state)[offset] ^= data;
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    tSmallUInt i;
+    unsigned char * state = (unsigned char*)argState + offset;
+
+    for(i=0; i<length; i++)
+        ((unsigned char *)state)[i] ^= data[i];
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    memcpy((unsigned char*)state+offset, data, length);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_OverwriteWithZeroes(void *state, unsigned int byteCount)
+{
+    memset(state, 0, byteCount);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_Permute_Nrounds(void *argState, unsigned int nr)
+{
+    tSmallUInt x, y;
+    tKeccakLane temp;
+    tKeccakLane BC[5];
+    tKeccakLane *state;
+    uint8_t       LFSRstate;
+
+    state = (tKeccakLane*)argState;
+    LFSRstate = 0x01;
+    for ( y = (tSmallUInt)(cKeccakNumberOfRounds - nr); y != 0; --y )
+    {
+        for( x = 1; x < 128; x <<= 1 )
+        {
+            if ((LFSRstate & 0x80) != 0)
+                /* Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1 */
+                LFSRstate = (LFSRstate << 1) ^ 0x71;
+            else
+                LFSRstate <<= 1;
+        }
+    }
+
+    do
+    {
+        /* Theta */
+        for ( x = 0; x < 5; ++x )
+        {
+            BC[x] = state[x] ^ state[5 + x] ^ state[10 + x] ^ state[15 + x] ^ state[20 + x];
+        }
+        for ( x = 0; x < 5; ++x )
+        {
+            temp = BC[MOD5(x+4)] ^ ROL32(BC[MOD5(x+1)], 1);
+            for ( y = 0; y < 25; y += 5 )
+            {
+                state[y + x] ^= temp;
+            }
+        }
+
+        /* Rho Pi */
+        temp = state[1];
+        for ( x = 0; x < 24; ++x )
+        {
+            BC[0] = state[KeccakP800_PiLane[x]];
+            state[KeccakP800_PiLane[x]] = ROL32( temp, KeccakP800_RotationConstants[x] );
+            temp = BC[0];
+        }
+
+        /*    Chi */
+        for ( y = 0; y < 25; y += 5 )
+        {
+#if defined(UNROLL_CHILOOP)
+            BC[0] = state[y + 0];
+            BC[1] = state[y + 1];
+            BC[2] = state[y + 2];
+            BC[3] = state[y + 3];
+            BC[4] = state[y + 4];
+#else
+            for ( x = 0; x < 5; ++x )
+            {
+                BC[x] = state[y + x];
+            }
+#endif
+            for ( x = 0; x < 5; ++x )
+            {
+                state[y + x] = BC[x] ^((~BC[MOD5(x+1)]) & BC[MOD5(x+2)]);
+            }
+        }
+
+        /*    Iota */
+        temp = 0;
+        for( x = 1; x < 128; x <<= 1 )
+        {
+            if ( x <= (sizeof(tKeccakLane)*8) )
+                temp ^= (tKeccakLane)(LFSRstate & 1) << (x - 1);
+
+            if ((LFSRstate & 0x80) != 0)
+                /* Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1 */
+                LFSRstate = (LFSRstate << 1) ^ 0x71;
+            else
+                LFSRstate <<= 1;
+        }
+        state[0] ^= temp;
+    }
+    while( --nr != 0 );
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_Permute_12rounds(void *argState)
+{
+    KeccakP800_Permute_Nrounds(argState, 12);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_Permute_22rounds(void *argState)
+{
+    KeccakP800_Permute_Nrounds(argState, 22);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    memcpy(data, (const uint8_t*)state+offset, length);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP800_ExtractAndAddBytes(const void *argState, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+{
+    tSmallUInt i;
+    const unsigned char * state = (const unsigned char*)argState + offset;
+
+    for(i=0; i<length; i++)
+        output[i] = input[i] ^ state[i];
+}
+
+/* ---------------------------------------------------------------- */

data/ext/xkcp/lib/low/KeccakP-800/plain/KeccakP-800-SnP.h

@@ -0,0 +1,46 @@
+/*
+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 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 SnP-documentation.h for more details.
+*/
+
+#ifndef _KeccakP_800_SnP_h_
+#define _KeccakP_800_SnP_h_
+
+#include "KeccakP-800-opt32-config.h"
+
+#define KeccakP800_implementation      "generic 32-bit optimized implementation (" KeccakP800_implementation_config ")"
+#define KeccakP800_stateSizeInBytes    100
+#define KeccakP800_stateAlignment      4
+#define KeccakF800_FastLoop_supported
+
+#include <stddef.h>
+
+#define KeccakP800_StaticInitialize()
+void KeccakP800_Initialize(void *state);
+void KeccakP800_AddByte(void *state, unsigned char data, unsigned int offset);
+void KeccakP800_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_OverwriteWithZeroes(void *state, unsigned int byteCount);
+void KeccakP800_Permute_Nrounds(void *state, unsigned int nrounds);
+void KeccakP800_Permute_12rounds(void *state);
+void KeccakP800_Permute_22rounds(void *state);
+void KeccakP800_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP800_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
+size_t KeccakF800_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen);
+
+#endif

data/ext/xkcp/lib/low/KeccakP-800/plain/KeccakP-800-opt32-bis.macros

@@ -0,0 +1,184 @@
+/*
+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 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/
+*/
+
+#define _b  0
+#define _g  5
+#define _k  10
+#define _m  15
+#define _s  20
+
+#define _a  0
+#define _e  1
+#define _i  2
+#define _o  3
+#define _u  4
+
+#define Ca Ba
+#define Ce Be
+#define Ci Bi
+#define Co Bo
+#define Cu Bu
+
+#define declareBCDE \
+    uint32_t Ba, Be, Bi, Bo, Bu; \
+    uint32_t Da, De, Di, Do, Du; \
+    uint32_t Estate[25]; \
+
+#ifdef UseBebigokimisa
+/* --- Code for round (lane complementing pattern 'bebigokimisa') */
+/* --- 32-bit lanes mapped to 32-bit words */
+#define thetaRhoPiChiIota(i, A, E) \
+    Ca = A##state[_b+_a]^A##state[_g+_a]^A##state[_k+_a]^A##state[_m+_a]^A##state[_s+_a]; \
+    Ce = A##state[_b+_e]^A##state[_g+_e]^A##state[_k+_e]^A##state[_m+_e]^A##state[_s+_e]; \
+    Ci = A##state[_b+_i]^A##state[_g+_i]^A##state[_k+_i]^A##state[_m+_i]^A##state[_s+_i]; \
+    Co = A##state[_b+_o]^A##state[_g+_o]^A##state[_k+_o]^A##state[_m+_o]^A##state[_s+_o]; \
+    Cu = A##state[_b+_u]^A##state[_g+_u]^A##state[_k+_u]^A##state[_m+_u]^A##state[_s+_u]; \
+    Da = Cu^ROL32(Ce, 1); \
+    De = Ca^ROL32(Ci, 1); \
+    Di = Ce^ROL32(Co, 1); \
+    Do = Ci^ROL32(Cu, 1); \
+    Du = Co^ROL32(Ca, 1); \
+\
+    Ba = A##state[_b+_a] ^ Da; \
+    Be = ROL32(A##state[_g+_e] ^ De, 12); \
+    Bi = ROL32(A##state[_k+_i] ^ Di, 11); \
+    Bo = ROL32(A##state[_m+_o] ^ Do, 21); \
+    Bu = ROL32(A##state[_s+_u] ^ Du, 14); \
+    E##state[_b+_a] =   Ba ^(  Be |  Bi ) ^ KeccakF800RoundConstants[i]; \
+    E##state[_b+_e] =   Be ^((~Bi)|  Bo ); \
+    E##state[_b+_i] =   Bi ^(  Bo &  Bu ); \
+    E##state[_b+_o] =   Bo ^(  Bu |  Ba ); \
+    E##state[_b+_u] =   Bu ^(  Ba &  Be ); \
+\
+    Ba = ROL32(A##state[_b+_o] ^ Do, 28); \
+    Be = ROL32(A##state[_g+_u] ^ Du, 20); \
+    Bi = ROL32(A##state[_k+_a] ^ Da,  3); \
+    Bo = ROL32(A##state[_m+_e] ^ De, 13); \
+    Bu = ROL32(A##state[_s+_i] ^ Di, 29); \
+    E##state[_g+_a] =   Ba ^(  Be |  Bi ); \
+    E##state[_g+_e] =   Be ^(  Bi &  Bo ); \
+    E##state[_g+_i] =   Bi ^(  Bo |(~Bu)); \
+    E##state[_g+_o] =   Bo ^(  Bu |  Ba ); \
+    E##state[_g+_u] =   Bu ^(  Ba &  Be ); \
+\
+    Ba = ROL32(A##state[_b+_e] ^ De,  1); \
+    Be = ROL32(A##state[_g+_i] ^ Di,  6); \
+    Bi = ROL32(A##state[_k+_o] ^ Do, 25); \
+    Bo = ROL32(A##state[_m+_u] ^ Du,  8); \
+    Bu = ROL32(A##state[_s+_a] ^ Da, 18); \
+    E##state[_k+_a] =   Ba ^(  Be |  Bi ); \
+    E##state[_k+_e] =   Be ^(  Bi &  Bo ); \
+    E##state[_k+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_k+_o] = (~Bo)^(  Bu |  Ba ); \
+    E##state[_k+_u] =   Bu ^(  Ba &  Be ); \
+\
+    Ba = ROL32(A##state[_b+_u] ^ Du, 27); \
+    Be = ROL32(A##state[_g+_a] ^ Da,  4); \
+    Bi = ROL32(A##state[_k+_e] ^ De, 10); \
+    Bo = ROL32(A##state[_m+_i] ^ Di, 15); \
+    Bu = ROL32(A##state[_s+_o] ^ Do, 24); \
+    E##state[_m+_a] =   Ba ^(  Be &  Bi ); \
+    E##state[_m+_e] =   Be ^(  Bi |  Bo ); \
+    E##state[_m+_i] =   Bi ^((~Bo)|  Bu ); \
+    E##state[_m+_o] = (~Bo)^(  Bu &  Ba ); \
+    E##state[_m+_u] =   Bu ^(  Ba |  Be ); \
+\
+    Ba = ROL32(A##state[_b+_i] ^ Di, 30); \
+    Be = ROL32(A##state[_g+_o] ^ Do, 23); \
+    Bi = ROL32(A##state[_k+_u] ^ Du,  7); \
+    Bo = ROL32(A##state[_m+_a] ^ Da,  9); \
+    Bu = ROL32(A##state[_s+_e] ^ De,  2); \
+    E##state[_s+_a] =   Ba ^((~Be)&  Bi ); \
+    E##state[_s+_e] = (~Be)^(  Bi |  Bo ); \
+    E##state[_s+_i] =   Bi ^(  Bo &  Bu ); \
+    E##state[_s+_o] =   Bo ^(  Bu |  Ba ); \
+    E##state[_s+_u] =   Bu ^(  Ba &  Be ); \
+\
+
+#else /* UseBebigokimisa */
+
+/* --- Code for round */
+/* --- 32-bit lanes mapped to 32-bit words */
+#define thetaRhoPiChiIota(i, A, E) \
+    Ca = A##state[_b+_a]^A##state[_g+_a]^A##state[_k+_a]^A##state[_m+_a]^A##state[_s+_a]; \
+    Ce = A##state[_b+_e]^A##state[_g+_e]^A##state[_k+_e]^A##state[_m+_e]^A##state[_s+_e]; \
+    Ci = A##state[_b+_i]^A##state[_g+_i]^A##state[_k+_i]^A##state[_m+_i]^A##state[_s+_i]; \
+    Co = A##state[_b+_o]^A##state[_g+_o]^A##state[_k+_o]^A##state[_m+_o]^A##state[_s+_o]; \
+    Cu = A##state[_b+_u]^A##state[_g+_u]^A##state[_k+_u]^A##state[_m+_u]^A##state[_s+_u]; \
+    Da = Cu^ROL32(Ce, 1); \
+    De = Ca^ROL32(Ci, 1); \
+    Di = Ce^ROL32(Co, 1); \
+    Do = Ci^ROL32(Cu, 1); \
+    Du = Co^ROL32(Ca, 1); \
+\
+    Ba = A##state[_b+_a] ^ Da; \
+    Be = ROL32(A##state[_g+_e] ^ De, 12); \
+    Bi = ROL32(A##state[_k+_i] ^ Di, 11); \
+    Bo = ROL32(A##state[_m+_o] ^ Do, 21); \
+    Bu = ROL32(A##state[_s+_u] ^ Du, 14); \
+    E##state[_b+_a] =   Ba ^((~Be)&  Bi ) ^ KeccakF800RoundConstants[i]; \
+    E##state[_b+_e] =   Be ^((~Bi)&  Bo ); \
+    E##state[_b+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_b+_o] =   Bo ^((~Bu)&  Ba ); \
+    E##state[_b+_u] =   Bu ^((~Ba)&  Be ); \
+\
+    Ba = ROL32(A##state[_b+_o] ^ Do, 28); \
+    Be = ROL32(A##state[_g+_u] ^ Du, 20); \
+    Bi = ROL32(A##state[_k+_a] ^ Da,  3); \
+    Bo = ROL32(A##state[_m+_e] ^ De, 13); \
+    Bu = ROL32(A##state[_s+_i] ^ Di, 29); \
+    E##state[_g+_a] =   Ba ^((~Be)&  Bi ); \
+    E##state[_g+_e] =   Be ^((~Bi)&  Bo ); \
+    E##state[_g+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_g+_o] =   Bo ^((~Bu)&  Ba ); \
+    E##state[_g+_u] =   Bu ^((~Ba)&  Be ); \
+\
+    Ba = ROL32(A##state[_b+_e] ^ De,  1); \
+    Be = ROL32(A##state[_g+_i] ^ Di,  6); \
+    Bi = ROL32(A##state[_k+_o] ^ Do, 25); \
+    Bo = ROL32(A##state[_m+_u] ^ Du,  8); \
+    Bu = ROL32(A##state[_s+_a] ^ Da, 18); \
+    E##state[_k+_a] =   Ba ^((~Be)&  Bi ); \
+    E##state[_k+_e] =   Be ^((~Bi)&  Bo ); \
+    E##state[_k+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_k+_o] =   Bo ^((~Bu)&  Ba ); \
+    E##state[_k+_u] =   Bu ^((~Ba)&  Be ); \
+\
+    Ba = ROL32(A##state[_b+_u] ^ Du, 27); \
+    Be = ROL32(A##state[_g+_a] ^ Da,  4); \
+    Bi = ROL32(A##state[_k+_e] ^ De, 10); \
+    Bo = ROL32(A##state[_m+_i] ^ Di, 15); \
+    Bu = ROL32(A##state[_s+_o] ^ Do, 24); \
+    E##state[_m+_a] =   Ba ^((~Be)&  Bi ); \
+    E##state[_m+_e] =   Be ^((~Bi)&  Bo ); \
+    E##state[_m+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_m+_o] =   Bo ^((~Bu)&  Ba ); \
+    E##state[_m+_u] =   Bu ^((~Ba)&  Be ); \
+\
+    Ba = ROL32(A##state[_b+_i] ^ Di, 30); \
+    Be = ROL32(A##state[_g+_o] ^ Do, 23); \
+    Bi = ROL32(A##state[_k+_u] ^ Du,  7); \
+    Bo = ROL32(A##state[_m+_a] ^ Da,  9); \
+    Bu = ROL32(A##state[_s+_e] ^ De,  2); \
+    E##state[_s+_a] =   Ba ^((~Be)&  Bi ); \
+    E##state[_s+_e] =   Be ^((~Bi)&  Bo ); \
+    E##state[_s+_i] =   Bi ^((~Bo)&  Bu ); \
+    E##state[_s+_o] =   Bo ^((~Bu)&  Ba ); \
+    E##state[_s+_u] =   Bu ^((~Ba)&  Be ); \
+\
+
+#endif /* UseBebigokimisa */
+