sha3 0.2.6 → 1.0.1

data/ext/sha3/Reference/KeccakF-reference.h

@@ -0,0 +1,26 @@
+/*
+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 _KeccakFReference_h_
+#define _KeccakFReference_h_
+#include "KeccakF-1600-interface.h"
+
+void displayRoundConstants(FILE *f);
+void displayRhoOffsets(FILE *f);
+
+#define KeccakF_Initialize                   KeccakF1600_Initialize
+#define KeccakF_StatePermute                KeccakF1600_StatePermute
+
+#endif

data/ext/sha3/Reference/SnP-FBWL-default.c

@@ -0,0 +1,96 @@
+/*
+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 <string.h>
+#include "SnP-interface.h"
+#ifdef KeccakReference
+#include "displayIntermediateValues.h"
+#endif
+
+size_t SnP_FBWL_Absorb_Default(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen, unsigned char trailingBits)
+{
+    size_t processed = 0;
+
+    while(dataByteLen >= laneCount*SnP_laneLengthInBytes) {
+        #ifdef KeccakReference
+        if (trailingBits == 0)
+            displayBytes(1, "Block to be absorbed", data, laneCount*SnP_laneLengthInBytes);
+        else {
+            displayBytes(1, "Block to be absorbed (part)", data, laneCount*SnP_laneLengthInBytes);
+            displayBytes(1, "Block to be absorbed (trailing bits)", &trailingBits, 1);
+        }
+        #endif
+        SnP_XORBytes(state, data, 0, laneCount*SnP_laneLengthInBytes);
+        SnP_XORBytes(state, &trailingBits, laneCount*SnP_laneLengthInBytes, 1);
+        SnP_Permute(state);
+        data += laneCount*SnP_laneLengthInBytes;
+        dataByteLen -= laneCount*SnP_laneLengthInBytes;
+        processed += laneCount*SnP_laneLengthInBytes;
+    }
+    return processed;
+}
+
+size_t SnP_FBWL_Squeeze_Default(void *state, unsigned int laneCount, unsigned char *data, size_t dataByteLen)
+{
+    size_t processed = 0;
+
+    while(dataByteLen >= laneCount*SnP_laneLengthInBytes) {
+        SnP_Permute(state);
+        SnP_ExtractBytes(state, data, 0, laneCount*SnP_laneLengthInBytes);
+        #ifdef KeccakReference
+        displayBytes(1, "Squeezed block", data, laneCount*SnP_laneLengthInBytes);
+        #endif
+        data += laneCount*SnP_laneLengthInBytes;
+        dataByteLen -= laneCount*SnP_laneLengthInBytes;
+        processed += laneCount*SnP_laneLengthInBytes;
+    }
+    return processed;
+}
+
+size_t SnP_FBWL_Wrap_Default(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits)
+{
+    size_t processed = 0;
+
+    while(dataByteLen >= laneCount*SnP_laneLengthInBytes) {
+        SnP_XORBytes(state, dataIn, 0, laneCount*SnP_laneLengthInBytes);
+        SnP_ExtractBytes(state, dataOut, 0, laneCount*SnP_laneLengthInBytes);
+        SnP_XORBytes(state, &trailingBits, laneCount*SnP_laneLengthInBytes, 1);
+        SnP_Permute(state);
+        dataIn += laneCount*SnP_laneLengthInBytes;
+        dataOut += laneCount*SnP_laneLengthInBytes;
+        dataByteLen -= laneCount*SnP_laneLengthInBytes;
+        processed += laneCount*SnP_laneLengthInBytes;
+    }
+    return processed;
+}
+
+size_t SnP_FBWL_Unwrap_Default(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits)
+{
+    size_t processed = 0;
+
+    if (dataIn != dataOut)
+        memcpy(dataOut, dataIn, dataByteLen);
+    while(dataByteLen >= laneCount*SnP_laneLengthInBytes) {
+        SnP_ExtractAndXORBytes(state, dataOut, 0, laneCount*SnP_laneLengthInBytes);
+        SnP_XORBytes(state, dataOut, 0, laneCount*SnP_laneLengthInBytes);
+        SnP_XORBytes(state, &trailingBits, laneCount*SnP_laneLengthInBytes, 1);
+        SnP_Permute(state);
+        dataIn += laneCount*SnP_laneLengthInBytes;
+        dataOut += laneCount*SnP_laneLengthInBytes;
+        dataByteLen -= laneCount*SnP_laneLengthInBytes;
+        processed += laneCount*SnP_laneLengthInBytes;
+    }
+    return processed;
+}

data/ext/sha3/Reference/SnP-FBWL-default.h

@@ -0,0 +1,26 @@
+/*
+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_FBWL_Default_h_
+#define _SnP_FBWL_Default_h_
+
+#include <string.h>
+
+size_t SnP_FBWL_Absorb_Default(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen, unsigned char trailingBits);
+size_t SnP_FBWL_Squeeze_Default(void *state, unsigned int laneCount, unsigned char *data, size_t dataByteLen);
+size_t SnP_FBWL_Wrap_Default(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits);
+size_t SnP_FBWL_Unwrap_Default(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits);
+
+#endif

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

@@ -0,0 +1,42 @@
+/*
+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"
+#include "SnP-FBWL-default.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_XORBytes                        KeccakF1600_StateXORBytes
+#define SnP_OverwriteBytes                  KeccakF1600_StateOverwriteBytes
+#define SnP_OverwriteWithZeroes             KeccakF1600_StateOverwriteWithZeroes
+#define SnP_ComplementBit                   KeccakF1600_StateComplementBit
+#define SnP_Permute                         KeccakF1600_StatePermute
+#define SnP_ExtractBytes                    KeccakF1600_StateExtractBytes
+#define SnP_ExtractAndXORBytes              KeccakF1600_StateExtractAndXORBytes
+
+#define SnP_FBWL_Absorb                     SnP_FBWL_Absorb_Default
+#define SnP_FBWL_Squeeze                    SnP_FBWL_Squeeze_Default
+#define SnP_FBWL_Wrap                       SnP_FBWL_Wrap_Default
+#define SnP_FBWL_Unwrap                     SnP_FBWL_Unwrap_Default
+
+#endif

data/ext/sha3/{displayIntermediateValues.c → Reference/displayIntermediateValues.c}

@@ -1,10 +1,12 @@
 /*
-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.
@@ -13,7 +15,7 @@ http://creativecommons.org/publicdomain/zero/1.0/
 
 #include <stdio.h>
 #include "displayIntermediateValues.h"
-#include "KeccakNISTInterface.h"
+#include "SnP-interface.h"
 
 FILE *intermediateValueFile = 0;
 int displayLevel = 0;
@@ -62,16 +64,17 @@ void displayBits(int level, const char *text, const unsigned char *data, unsigne
 
 void displayStateAsBytes(int level, const char *text, const unsigned char *state)
 {
-    displayBytes(level, text, state, KeccakPermutationSizeInBytes);
+    displayBytes(level, text, state, SnP_width/8);
 }
 
+#if (SnP_laneLengthInBytes == 8)
 void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
 {
     unsigned int i;
 
     if ((intermediateValueFile) && (level <= displayLevel)) {
         fprintf(intermediateValueFile, "%s:\n", text);
-        for(i=0; i<KeccakPermutationSize/64; i++) {
+        for(i=0; i<SnP_width/64; i++) {
             fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
             if ((i%5) == 4)
                 fprintf(intermediateValueFile, "\n");
@@ -80,14 +83,28 @@ void displayStateAs32bitWords(int level, const char *text, const unsigned int *s
         }
     }
 }
+#endif
 
-void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state)
+void displayStateAsLanes(int level, const char *text, void *statePointer)
 {
     unsigned int i;
+#if (SnP_laneLengthInBytes == 8)
+    unsigned long long int *state = statePointer;
+#endif
+#if (SnP_laneLengthInBytes == 4)
+    unsigned int *state = statePointer;
+#endif
+#if (SnP_laneLengthInBytes == 2)
+    unsigned short *state = statePointer;
+#endif
+#if (SnP_laneLengthInBytes == 1)
+    unsigned char *state = statePointer;
+#endif
 
     if ((intermediateValueFile) && (level <= displayLevel)) {
         fprintf(intermediateValueFile, "%s:\n", text);
-        for(i=0; i<KeccakPermutationSize/64; i++) {
+#if (SnP_laneLengthInBytes == 8)
+        for(i=0; i<25; i++) {
             fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
             fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
             if ((i%5) == 4)
@@ -95,6 +112,30 @@ void displayStateAs64bitWords(int level, const char *text, const unsigned long l
             else
                 fprintf(intermediateValueFile, " ");
         }
+#endif
+#if (SnP_laneLengthInBytes == 4)
+        for(i=0; i<25; i++) {
+            fprintf(intermediateValueFile, "%08X", state[i]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+#endif
+#if (SnP_laneLengthInBytes == 2)
+        for(i=0; i<25; i++) {
+            fprintf(intermediateValueFile, "%04X ", state[i]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+        }
+#endif
+#if (SnP_laneLengthInBytes == 1)
+        for(i=0; i<25; i++) {
+            fprintf(intermediateValueFile, "%02X ", state[i]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+        }
+#endif
     }
 }
 
@@ -110,7 +151,7 @@ void displayRoundNumber(int level, unsigned int i)
 void displayText(int level, const char *text)
 {
     if ((intermediateValueFile) && (level <= displayLevel)) {
-        fprintf(intermediateValueFile, text);
+        fprintf(intermediateValueFile, "%s", text);
         fprintf(intermediateValueFile, "\n");
         fprintf(intermediateValueFile, "\n");
     }

data/ext/sha3/{displayIntermediateValues.h → Reference/displayIntermediateValues.h}

@@ -1,10 +1,12 @@
 /*
-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.
@@ -15,14 +17,17 @@ http://creativecommons.org/publicdomain/zero/1.0/
 #define _displayIntermediateValues_h_
 
 #include <stdio.h>
+#include "SnP-interface.h"
 
 void displaySetIntermediateValueFile(FILE *f);
 void displaySetLevel(int level);
 void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size);
 void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst);
 void displayStateAsBytes(int level, const char *text, const unsigned char *state);
+#if (SnP_laneLengthInBytes == 8)
 void displayStateAs32bitWords(int level, const char *text, const unsigned int *state);
-void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state);
+#endif
+void displayStateAsLanes(int level, const char *text, void *statePointer);
 void displayRoundNumber(int level, unsigned int i);
 void displayText(int level, const char *text);
 

data/ext/sha3/SnP-Relaned.h

@@ -0,0 +1,249 @@
+/*
+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_Relaned_h_
+#define _SnP_Relaned_h_
+
+/** Function to XOR data given as bytes into the state.
+  * The bits to modify are restricted to be consecutive and to be in the same lane.
+  * The bit positions that are affected by this function are
+  * from @a lanePosition*(lane size in bits) + @a offset*8
+  * to @a lanePosition*(lane size in bits) + @a offset*8 + @a length*8.
+  * (The bit positions, the x,y,z coordinates and their link are defined in the "Keccak reference".)
+  * @param  state   Pointer to the state.
+  * @param  lanePosition    Index of the lane to be modified (x+5*y,
+  *                         or bit position divided by the lane size).
+  * @param  data    Pointer to the input data.
+  * @param  offset  Offset in bytes within the lane.
+  * @param  length  Number of bytes.
+  * @pre    0 ≤ @a lanePosition < 25
+  * @pre    0 ≤ @a offset < (lane size in bytes)
+  * @pre    0 ≤ @a offset + @a length ≤ (lane size in bytes)
+  */
+void SnP_XORBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length);
+
+/** Function to XOR data given as bytes into the state.
+  * The bits to modify are restricted to start from the bit position 0 and
+  * to span a whole number of lanes.
+  * @param  state   Pointer to the state.
+  * @param  data    Pointer to the input data.
+  * @param  laneCount   The number of lanes, i.e., the length of the data
+  *                     divided by the lane size.
+  * @pre    0 ≤ @a laneCount ≤ 25
+  */
+void SnP_XORLanes(void *state, const unsigned char *data, unsigned int laneCount);
+
+/** Function to overwrite data given as bytes into the state.
+  * The bits to modify are restricted to be consecutive and to be in the same lane.
+  * The bit positions that are affected by this function are
+  * from @a lanePosition*(lane size in bits) + @a offset*8
+  * to @a lanePosition*(lane size in bits) + @a offset*8 + @a length*8.
+  * (The bit positions, the x,y,z coordinates and their link are defined in the "Keccak reference".)
+  * @param  state   Pointer to the state.
+  * @param  lanePosition    Index of the lane to be modified (x+5*y,
+  *                         or bit position divided by the lane size).
+  * @param  data    Pointer to the input data.
+  * @param  offset  Offset in bytes within the lane.
+  * @param  length  Number of bytes.
+  * @pre    0 ≤ @a lanePosition < 25
+  * @pre    0 ≤ @a offset < (lane size in bytes)
+  * @pre    0 ≤ @a offset + @a length ≤ (lane size in bytes)
+  */
+void SnP_OverwriteBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length);
+
+/** Function to overwrite data given as bytes into the state.
+  * The bits to modify are restricted to start from the bit position 0 and
+  * to span a whole number of lanes.
+  * @param  state   Pointer to the state.
+  * @param  data    Pointer to the input data.
+  * @param  laneCount   The number of lanes, i.e., the length of the data
+  *                     divided by the lane size.
+  * @pre    0 ≤ @a laneCount ≤ 25
+  */
+void SnP_OverwriteLanes(void *state, const unsigned char *data, unsigned int laneCount);
+
+/** Function to retrieve data from the state into bytes.
+  * The bits to output are restricted to be consecutive and to be in the same lane.
+  * The bit positions that are retrieved by this function are
+  * from @a lanePosition*(lane size in bits) + @a offset*8
+  * to @a lanePosition*(lane size in bits) + @a offset*8 + @a length*8.
+  * (The bit positions, the x,y,z coordinates and their link are defined in the "Keccak reference".)
+  * @param  state   Pointer to the state.
+  * @param  lanePosition    Index of the lane to be read (x+5*y,
+  *                         or bit position divided by the lane size).
+  * @param  data    Pointer to the area where to store output data.
+  * @param  offset  Offset in byte within the lane.
+  * @param  length  Number of bytes.
+  * @pre    0 ≤ @a lanePosition < 25
+  * @pre    0 ≤ @a offset < (lane size in bytes)
+  * @pre    0 ≤ @a offset + @a length ≤ (lane size in bytes)
+  */
+void SnP_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length);
+
+/** Function to retrieve data from the state into bytes.
+  * The bits to output are restricted to start from the bit position 0 and
+  * to span a whole number of lanes.
+  * @param  state   Pointer to the state.
+  * @param  data    Pointer to the area where to store output data.
+  * @param  laneCount   The number of lanes, i.e., the length of the data
+  *                     divided by the lane size.
+  * @pre    0 ≤ @a laneCount ≤ 25
+  */
+void SnP_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount);
+
+/** Function to retrieve data from the state into bytes and
+  * to XOR them into the output buffer.
+  * The bits to output are restricted to be consecutive and to be in the same lane.
+  * The bit positions that are retrieved by this function are
+  * from @a lanePosition*(lane size in bits) + @a offset*8
+  * to @a lanePosition*(lane size in bits) + @a offset*8 + @a length*8.
+  * (The bit positions, the x,y,z coordinates and their link are defined in the "Keccak reference".)
+  * @param  state   Pointer to the state.
+  * @param  lanePosition    Index of the lane to be read (x+5*y,
+  *                         or bit position divided by the lane size).
+  * @param  data    Pointer to the area where to XOR output data.
+  * @param  offset  Offset in byte within the lane.
+  * @param  length  Number of bytes.
+  * @pre    0 ≤ @a lanePosition < 25
+  * @pre    0 ≤ @a offset < (lane size in bytes)
+  * @pre    0 ≤ @a offset + @a length ≤ (lane size in bytes)
+  */
+void SnP_ExtractAndXORBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length);
+
+/** Function to retrieve data from the state into bytes and
+  * to XOR them into the output buffer.
+  * The bits to output are restricted to start from the bit position 0 and
+  * to span a whole number of lanes.
+  * @param  state   Pointer to the state.
+  * @param  data    Pointer to the area where to XOR output data.
+  * @param  laneCount   The number of lanes, i.e., the length of the data
+  *                     divided by the lane size.
+  * @pre    0 ≤ @a laneCount ≤ 25
+  */
+void SnP_ExtractAndXORLanes(const void *state, unsigned char *data, unsigned int laneCount);
+
+#define SnP_XORBytes(state, data, offset, length) \
+    { \
+        if ((offset) == 0) { \
+            SnP_XORLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_XORBytesInLane(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_XORBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
+    }
+
+#define SnP_OverwriteBytes(state, data, offset, length) \
+    { \
+        if ((offset) == 0) { \
+            SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_OverwriteBytesInLane(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_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
+    }
+
+#define SnP_ExtractBytes(state, data, offset, length) \
+    { \
+        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; \
+            } \
+        } \
+    }
+
+#define SnP_ExtractAndXORBytes(state, data, offset, length) \
+    { \
+        if ((offset) == 0) { \
+            SnP_ExtractAndXORLanes(state, data, (length)/SnP_laneLengthInBytes); \
+            SnP_ExtractAndXORBytesInLane(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_ExtractAndXORBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+                _sizeLeft -= _bytesInLane; \
+                _lanePosition++; \
+                _offsetInLane = 0; \
+                _curData += _bytesInLane; \
+            } \
+        } \
+    }
+
+#endif