sleeping_kangaroo12 0.0.1 → 0.0.5

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

@@ -1,190 +0,0 @@
-/*
-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[200] in a SnP-compatible way.
-Please refer to SnP-documentation.h for more details.
-
-This implementation comes with KeccakP-200-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 "KeccakP-200-SnP.h"
-
-/* #define DIVISION_INSTRUCTION    /* comment if no division instruction or more compact when not using division */
-#define UNROLL_CHILOOP        /* comment if more compact using for loop */
-
-typedef uint_fast8_t tSmallUInt;
-typedef uint8_t tKeccakLane;
-
-#define ROL8(a, offset) (uint8_t)((((uint8_t)a) << (offset&7)) ^ (((uint8_t)a) >> (8-(offset&7))))
-
-const uint8_t KeccakP200_RotationConstants[25] =
-{
-     1,  3,  6, 10, 15, 21, 28, 36, 45, 55,  2, 14, 27, 41, 56,  8, 25, 43, 62, 18, 39, 61, 20, 44
-};
-
-const uint8_t KeccakP200_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 KeccakP200_Mod5[10] =
-{
-    0, 1, 2, 3, 4, 0, 1, 2, 3, 4
-};
-#define MOD5(argValue)    KeccakP200_Mod5[argValue]
-#endif
-
-const uint8_t KeccakF200_RoundConstants[] =
-{
-    0x01, 0x82, 0x8a, 0x00, 0x8b, 0x01, 0x81, 0x09, 0x8a, 0x88, 0x09, 0x0a, 0x8b, 0x8b, 0x89, 0x03, 0x02, 0x80
-};
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_Initialize(void *argState)
-{
-    memset( argState, 0, 25 * sizeof(tKeccakLane) );
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_AddByte(void *argState, unsigned char byte, unsigned int offset)
-{
-    ((tKeccakLane*)argState)[offset] ^= byte;
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    tSmallUInt i;
-    tKeccakLane * state = (tKeccakLane*)argState + offset;
-    for(i=0; i<length; i++)
-        state[i] ^= data[i];
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    memcpy((unsigned char*)state+offset, data, length);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_OverwriteWithZeroes(void *state, unsigned int byteCount)
-{
-    memset(state, 0, byteCount);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_Permute_Nrounds(void *argState, unsigned int nr)
-{
-    tSmallUInt x, y;
-    tKeccakLane temp;
-    tKeccakLane BC[5];
-    tKeccakLane *state;
-    const tKeccakLane *rc;
-
-    state = (tKeccakLane*)argState;
-    rc = KeccakF200_RoundConstants + 18 - nr;
-    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)] ^ ROL8(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[KeccakP200_PiLane[x]];
-            state[KeccakP200_PiLane[x]] = ROL8( temp, KeccakP200_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 = *(rc++);
-        state[0] ^= temp;
-    }
-    while( temp != 0x80 );
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_Permute_18rounds(void *argState)
-{
-    KeccakP200_Permute_Nrounds(argState, 18);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
-{
-    memcpy(data, (uint8_t*)state+offset, length);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_ExtractAndAddBytes(const void *argState, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
-{
-    unsigned int i;
-    tKeccakLane * state = (tKeccakLane*)argState + offset;
-    for(i=0; i<length; i++)
-        output[i] = input[i] ^ state[i];
-}
-
-/* ---------------------------------------------------------------- */

data/ext/xkcp/lib/low/KeccakP-200/ref/KeccakP-200-SnP.h

@@ -1,43 +0,0 @@
-/*
-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 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/
-
----
-
-Please refer to SnP-documentation.h for more details.
-*/
-
-#ifndef _KeccakP_200_SnP_h_
-#define _KeccakP_200_SnP_h_
-
-#define KeccakP200_implementation      "8-bit reference implementation"
-#define KeccakP200_stateSizeInBytes    25
-#define KeccakP200_stateAlignment      1
-
-#ifdef KeccakReference
-void KeccakP200_StaticInitialize( void );
-#else
-#define KeccakP200_StaticInitialize()
-#endif
-void KeccakP200_Initialize(void *state);
-void KeccakP200_AddByte(void *state, unsigned char data, unsigned int offset);
-void KeccakP200_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP200_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP200_OverwriteWithZeroes(void *state, unsigned int byteCount);
-void KeccakP200_Permute_Nrounds(void *state, unsigned int nrounds);
-void KeccakP200_Permute_18rounds(void *state);
-void KeccakP200_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP200_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
-
-#endif

data/ext/xkcp/lib/low/KeccakP-200/ref/KeccakP-200-reference.c

@@ -1,412 +0,0 @@
-/*
-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 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/
-
----
-
-This file implements Keccak-p[200] in a SnP-compatible way.
-Please refer to SnP-documentation.h for more details.
-
-This implementation comes with KeccakP-200-SnP.h in the same folder.
-Please refer to LowLevel.build for the exact list of other files it must be combined with.
-*/
-
-#if DEBUG
-#include <assert.h>
-#endif
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "brg_endian.h"
-#ifdef KeccakReference
-#include "displayIntermediateValues.h"
-#endif
-
-typedef uint8_t tKeccakLane;
-
-#define maxNrRounds 18
-#define nrLanes 25
-#define index(x, y) (((x)%5)+5*((y)%5))
-
-#ifdef KeccakReference
-
-static tKeccakLane KeccakRoundConstants[maxNrRounds];
-static unsigned int KeccakRhoOffsets[nrLanes];
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_InitializeRoundConstants(void);
-void KeccakP200_InitializeRhoOffsets(void);
-static int LFSR86540(uint8_t *LFSR);
-
-void KeccakP200_StaticInitialize(void)
-{
-    if (sizeof(tKeccakLane) != 1) {
-        printf("tKeccakLane should be 8-bit wide\n");
-        abort();
-    }
-    KeccakP200_InitializeRoundConstants();
-    KeccakP200_InitializeRhoOffsets();
-}
-
-void KeccakP200_InitializeRoundConstants(void)
-{
-    uint8_t LFSRstate = 0x01;
-    unsigned int i, j, bitPosition;
-
-    for(i=0; i<maxNrRounds; i++) {
-        KeccakRoundConstants[i] = 0;
-        for(j=0; j<7; j++) {
-            bitPosition = (1<<j)-1; /* 2^j-1 */
-            if (LFSR86540(&LFSRstate) && (bitPosition < (sizeof(tKeccakLane)*8)))
-                KeccakRoundConstants[i] ^= (tKeccakLane)(1<<bitPosition);
-        }
-    }
-}
-
-void KeccakP200_InitializeRhoOffsets(void)
-{
-    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) % (sizeof(tKeccakLane) * 8);
-        newX = (0*x+1*y) % 5;
-        newY = (2*x+3*y) % 5;
-        x = newX;
-        y = newY;
-    }
-}
-
-static int LFSR86540(uint8_t *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;
-}
-
-#else
-
-static const tKeccakLane KeccakRoundConstants[maxNrRounds] =
-{
-    0x01,
-    0x82,
-    0x8a,
-    0x00,
-    0x8b,
-    0x01,
-    0x81,
-    0x09,
-    0x8a,
-    0x88,
-    0x09,
-    0x0a,
-    0x8b,
-    0x8b,
-    0x89,
-    0x03,
-    0x02,
-    0x80,
-};
-
-static const unsigned int KeccakRhoOffsets[nrLanes] =
-{
-     0, 1, 6, 4, 3, 4, 4, 6, 7, 4, 3, 2, 3, 1, 7, 1, 5, 7, 5, 0, 2, 2, 5, 0, 6
-};
-
-#endif
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_Initialize(void *state)
-{
-    memset(state, 0, nrLanes * sizeof(tKeccakLane));
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_AddByte(void *state, unsigned char byte, unsigned int offset)
-{
-    #if DEBUG
-    assert(offset < 25);
-    #endif
-    ((unsigned char *)state)[offset] ^= byte;
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    unsigned int i;
-
-    #if DEBUG
-    assert(offset < 25);
-    assert(offset+length <= 25);
-    #endif
-    for(i=0; i<length; i++)
-        ((unsigned char *)state)[offset+i] ^= data[i];
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    #if DEBUG
-    assert(offset < 25);
-    assert(offset+length <= 25);
-    #endif
-    memcpy((unsigned char*)state+offset, data, length);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_OverwriteWithZeroes(void *state, unsigned int byteCount)
-{
-    #if DEBUG
-    assert(byteCount <= 25);
-    #endif
-    memset(state, 0, byteCount);
-}
-
-/* ---------------------------------------------------------------- */
-
-static void fromBytesToWords(tKeccakLane *stateAsWords, const unsigned char *state);
-static void fromWordsToBytes(unsigned char *state, const tKeccakLane *stateAsWords);
-void KeccakP200OnWords(tKeccakLane *state, unsigned int nrRounds);
-void KeccakP200Round(tKeccakLane *state, unsigned int indexRound);
-static void theta(tKeccakLane *A);
-static void rho(tKeccakLane *A);
-static void pi(tKeccakLane *A);
-static void chi(tKeccakLane *A);
-static void iota(tKeccakLane *A, unsigned int indexRound);
-
-void KeccakP200_Permute_Nrounds(void *state, unsigned int nrounds)
-{
-#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-    tKeccakLane stateAsWords[nrLanes];
-#endif
-
-#ifdef KeccakReference
-    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state, nrLanes * sizeof(tKeccakLane) * 8);
-#endif
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakP200OnWords((tKeccakLane*)state, nrounds);
-#else
-    fromBytesToWords(stateAsWords, (const unsigned char *)state);
-    KeccakP200OnWords(stateAsWords, nrounds);
-    fromWordsToBytes((unsigned char *)state, stateAsWords);
-#endif
-#ifdef KeccakReference
-    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state, nrLanes * sizeof(tKeccakLane) * 8);
-#endif
-}
-
-void KeccakP200_Permute_18rounds(void *state)
-{
-#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-    tKeccakLane stateAsWords[nrLanes];
-#endif
-
-#ifdef KeccakReference
-    displayStateAsBytes(1, "Input of permutation", (const unsigned char *)state, nrLanes * sizeof(tKeccakLane) * 8);
-#endif
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakP200OnWords((tKeccakLane*)state, maxNrRounds);
-#else
-    fromBytesToWords(stateAsWords, (const unsigned char *)state);
-    KeccakP200OnWords(stateAsWords, maxNrRounds);
-    fromWordsToBytes((unsigned char *)state, stateAsWords);
-#endif
-#ifdef KeccakReference
-    displayStateAsBytes(1, "State after permutation", (const unsigned char *)state, nrLanes * sizeof(tKeccakLane) * 8);
-#endif
-}
-
-static 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<sizeof(tKeccakLane); j++)
-            stateAsWords[i] |= (tKeccakLane)(state[i*sizeof(tKeccakLane)+j]) << (8*j);
-    }
-}
-
-static void fromWordsToBytes(unsigned char *state, const tKeccakLane *stateAsWords)
-{
-    unsigned int i, j;
-
-    for(i=0; i<nrLanes; i++)
-        for(j=0; j<sizeof(tKeccakLane); j++)
-            state[i*sizeof(tKeccakLane)+j] = (stateAsWords[i] >> (8*j)) & 0xFF;
-}
-
-void KeccakP200OnWords(tKeccakLane *state, unsigned int nrRounds)
-{
-    unsigned int i;
-
-#ifdef KeccakReference
-    displayStateAsLanes(3, "Same, with lanes as 8-bit words", state, 200);
-#endif
-
-    for(i=(maxNrRounds-nrRounds); i<maxNrRounds; i++)
-        KeccakP200Round(state, i);
-}
-
-void KeccakP200Round(tKeccakLane *state, unsigned int indexRound)
-{
-#ifdef KeccakReference
-    displayRoundNumber(3, indexRound);
-#endif
-
-    theta(state);
-#ifdef KeccakReference
-    displayStateAsLanes(3, "After theta", state, 200);
-#endif
-
-    rho(state);
-#ifdef KeccakReference
-    displayStateAsLanes(3, "After rho", state, 200);
-#endif
-
-    pi(state);
-#ifdef KeccakReference
-    displayStateAsLanes(3, "After pi", state, 200);
-#endif
-
-    chi(state);
-#ifdef KeccakReference
-    displayStateAsLanes(3, "After chi", state, 200);
-#endif
-
-    iota(state, indexRound);
-#ifdef KeccakReference
-    displayStateAsLanes(3, "After iota", state, 200);
-#endif
-}
-
-#define ROL8(a, offset) ((offset != 0) ? ((((tKeccakLane)a) << offset) ^ (((tKeccakLane)a) >> (sizeof(tKeccakLane)*8-offset))) : a)
-
-static 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] = ROL8(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];
-}
-
-static void rho(tKeccakLane *A)
-{
-    unsigned int x, y;
-
-    for(x=0; x<5; x++) for(y=0; y<5; y++)
-        A[index(x, y)] = ROL8(A[index(x, y)], KeccakRhoOffsets[index(x, y)]);
-}
-
-static 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)];
-}
-
-static 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];
-    }
-}
-
-static void iota(tKeccakLane *A, unsigned int indexRound)
-{
-    A[index(0, 0)] ^= KeccakRoundConstants[indexRound];
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
-{
-    #if DEBUG
-    assert(offset < 25);
-    assert(offset+length <= 25);
-    #endif
-    memcpy(data, (unsigned char*)state+offset, length);
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
-{
-    unsigned int i;
-
-    #if DEBUG
-    assert(offset < 25);
-    assert(offset+length <= 25);
-    #endif
-    for(i=0; i<length; i++)
-        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
-}
-
-/* ---------------------------------------------------------------- */
-
-void KeccakP200_DisplayRoundConstants(FILE *f)
-{
-    unsigned int i;
-
-    for(i=0; i<maxNrRounds; i++) {
-        fprintf(f, "RC[%02i][0][0] = ", i);
-        fprintf(f, "%02X", (unsigned int)(KeccakRoundConstants[i]));
-        fprintf(f, "\n");
-    }
-    fprintf(f, "\n");
-}
-
-void KeccakP200_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");
-}

data/ext/xkcp/lib/low/KeccakP-200/ref/KeccakP-200-reference.h

@@ -1,23 +0,0 @@
-/*
-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 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 _KeccakP_200_reference_h_
-#define _KeccakP_200_reference_h_
-
-void KeccakP200_DisplayRoundConstants(FILE *f);
-void KeccakP200_DisplayRhoOffsets(FILE *f);
-
-#endif

data/ext/xkcp/lib/low/KeccakP-400/ARM/KeccakP-400-SnP.h

@@ -1,41 +0,0 @@
-/*
-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_400_SnP_h_
-#define _KeccakP_400_SnP_h_
-
-#define KeccakP400_implementation      "32-bit optimized ARM assembler implementation"
-#define KeccakP400_stateSizeInBytes    50
-#define KeccakP400_stateAlignment      4
-
-/* void KeccakP400_StaticInitialize( void ); */
-#define KeccakP400_StaticInitialize()
-void KeccakP400_Initialize(void *state);
-/* void KeccakP400_AddByte(void *state, unsigned char data, unsigned int offset); */
-#define KeccakP400_AddByte(argS, argData, argOffset)    ((unsigned char*)argS)[argOffset] ^= (argData)
-void KeccakP400_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP400_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP400_OverwriteWithZeroes(void *state, unsigned int byteCount);
-void KeccakP400_Permute_Nrounds(void *state, unsigned int nrounds);
-void KeccakP400_Permute_20rounds(void *state);
-void KeccakP400_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
-void KeccakP400_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
-
-#endif