sha3-ruby 0.0.1

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/DoublePermutation.h

@@ -0,0 +1,38 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 _DoublePermutation_h_
+#define _DoublePermutation_h_
+
+#include <x86intrin.h>
+typedef __m128i V128;
+
+void KeccakDoublePermutationOnWords(V128 *state);
+void KeccakDoublePermutationOnWordsAfterXoring2x512bits(V128 *state, const V128 *input);
+void KeccakDoublePermutationOnWordsAfterXoring2x1024bits(V128 *state, const V128 *input);
+void KeccakDoublePermutationOnWordsAfterXoring2x1088bits(V128 *state, const V128 *input);
+void KeccakDoublePermutationOnWordsAfterXoring2x1344bits(V128 *state, const V128 *input);
+void KeccakInitializeDoubleState(V128 *state);
+
+#define KeccakPermutationSize 1600
+#define KeccakPermutationSizeInBytes (KeccakPermutationSize/8)
+
+#if defined(__GNUC__)
+#define ALIGN __attribute__ ((aligned(32)))
+#elif defined(_MSC_VER)
+#define ALIGN __declspec(align(32))
+#else
+#define ALIGN
+#endif
+
+#endif

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/KeccakF-1600-unrolling.macros

@@ -0,0 +1,124 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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)
+#define rounds \
+    prepareTheta \
+    thetaRhoPiChiIotaPrepareTheta( 0, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 1, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 2, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 3, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 4, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 5, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 6, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 7, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 8, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 9, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(10, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(11, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(12, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(13, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(14, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(15, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(16, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(17, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+    thetaRhoPiChiIota(23, E, A) \
+    copyToState(state, A)
+#elif (Unrolling == 12)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=12) { \
+        thetaRhoPiChiIotaPrepareTheta(i   , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 5, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 6, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 7, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 8, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 9, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+10, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+11, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 8)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=8) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+6, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+7, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 6)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=6) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 4)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=4) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 3)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=3) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        copyStateVariables(A, E) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 2)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=2) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 1)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i++) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        copyStateVariables(A, E) \
+    } \
+    copyToState(state, A)
+#else
+#error "Unrolling is not correctly specified!"
+#endif

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/Keccakc256TreeD2.c

@@ -0,0 +1,81 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 "crypto_hash.h"
+#include "DoublePermutation.h"
+#include "Keccakc256TreeD2.h"
+
+int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen)
+{
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char buffer[rateInBytes*2];
+    ALIGN unsigned char finalNode[rateInBytes*2];
+    unsigned int padLeftBranch, padRightBranch;
+    unsigned int i;
+
+    KeccakInitializeDoubleState((V128*)state);
+
+    while(inlen >= rateInBytes*2) {
+        KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (const V128*)in);
+        in += rateInBytes*2;
+        inlen -= rateInBytes*2;
+    }
+
+    memset(finalNode, 0, rateInBytes*2);
+    memset(buffer, 0, rateInBytes*2);
+    memcpy(buffer, in, inlen);
+    if (inlen % 16 < 8) {
+        padLeftBranch = inlen;
+        padRightBranch = (inlen/16)*16+8;
+    }
+    else {
+        padLeftBranch = ((inlen+15)/16)*16;
+        padRightBranch = inlen;
+    }
+    buffer[padRightBranch] = 0x02; //non-final bit and first bit of padding
+    buffer[rateInBytes*2-1] |= 0x80; // second bit of padding
+    if (padLeftBranch < rateInBytes*2) {
+        buffer[padLeftBranch] = 0x02; //non-final bit and first bit of padding
+        buffer[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+        KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++) {
+            memcpy(finalNode+i*16, state+i*16, 8);
+            memcpy(finalNode+CinBytes*2+i*16, state+i*16+8, 8);
+        }
+    }
+    else {
+        KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++)
+            memcpy(finalNode+CinBytes*2+i*16, state+i*16+8, 8);
+        memset(buffer, 0, rateInBytes*2);
+        buffer[0] = 0x02; //non-final bit and first bit of padding
+        buffer[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+        KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++)
+            memcpy(finalNode+i*16, state+i*16, 8);
+    }
+    finalNode[CinBytes*4+0] = 0x40; // B=64 bits
+    finalNode[CinBytes*4+1] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+2] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+3] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+4] = 0x00 | 0x20 | 0x40; // 5 bits set to zero (reserved for future use, for other layouts), plus final bit, plus first bit of padding
+    finalNode[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+
+    KeccakInitializeDoubleState((V128*)state);
+    KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (const V128*)finalNode);
+    for(i=0; i<rateInBytes/8; i++)
+        memcpy(out+i*8, state+i*16, 8);
+
+    return 0;
+}

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/Keccakc256TreeD2.h

@@ -0,0 +1,18 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 rate 1344
+#define rateInBytes (rate/8)
+#define C 256
+#define CinBytes (C/8)
+

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/Keccakc512TreeD2.c

@@ -0,0 +1,81 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 "crypto_hash.h"
+#include "DoublePermutation.h"
+#include "Keccakc512TreeD2.h"
+
+int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen)
+{
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char buffer[rateInBytes*2];
+    ALIGN unsigned char finalNode[rateInBytes*2];
+    unsigned int padLeftBranch, padRightBranch;
+    unsigned int i;
+
+    KeccakInitializeDoubleState((V128*)state);
+
+    while(inlen >= rateInBytes*2) {
+        KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (const V128*)in);
+        in += rateInBytes*2;
+        inlen -= rateInBytes*2;
+    }
+
+    memset(finalNode, 0, rateInBytes*2);
+    memset(buffer, 0, rateInBytes*2);
+    memcpy(buffer, in, inlen);
+    if (inlen % 16 < 8) {
+        padLeftBranch = inlen;
+        padRightBranch = (inlen/16)*16+8;
+    }
+    else {
+        padLeftBranch = ((inlen+15)/16)*16;
+        padRightBranch = inlen;
+    }
+    buffer[padRightBranch] = 0x02; //non-final bit and first bit of padding
+    buffer[rateInBytes*2-1] |= 0x80; // second bit of padding
+    if (padLeftBranch < rateInBytes*2) {
+        buffer[padLeftBranch] = 0x02; //non-final bit and first bit of padding
+        buffer[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+        KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++) {
+            memcpy(finalNode+i*16, state+i*16, 8);
+            memcpy(finalNode+CinBytes*2+i*16, state+i*16+8, 8);
+        }
+    }
+    else {
+        KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++)
+            memcpy(finalNode+CinBytes*2+i*16, state+i*16+8, 8);
+        memset(buffer, 0, rateInBytes*2);
+        buffer[0] = 0x02; //non-final bit and first bit of padding
+        buffer[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+        KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (const V128*)buffer);
+        for(i=0; i<CinBytes/8; i++)
+            memcpy(finalNode+i*16, state+i*16, 8);
+    }
+    finalNode[CinBytes*4+0] = 0x40; // B=64 bits
+    finalNode[CinBytes*4+1] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+2] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+3] = 0x00; // B=64 bits
+    finalNode[CinBytes*4+4] = 0x00 | 0x20 | 0x40; // 5 bits set to zero (reserved for future use, for other layouts), plus final bit, plus first bit of padding
+    finalNode[rateInBytes*2-8-1] |= 0x80; // second bit of padding
+
+    KeccakInitializeDoubleState((V128*)state);
+    KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (const V128*)finalNode);
+    for(i=0; i<rateInBytes/8; i++)
+        memcpy(out+i*8, state+i*16, 8);
+
+    return 0;
+}

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/Keccakc512TreeD2.h

@@ -0,0 +1,18 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 rate 1088
+#define rateInBytes (rate/8)
+#define C 512
+#define CinBytes (C/8)
+

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/mainOptimized.c

@@ -0,0 +1,112 @@
+/*
+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 designers,
+hereby denoted as "the implementer".
+
+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 <string.h>
+
+#ifdef D2
+#include "timing-Double.h"
+#include "DoublePermutation.h"
+#endif
+
+#ifdef D4
+#include "timing-Quad.h"
+#include "QuadPermutation.h"
+#endif
+
+#if defined(c256) && defined(D2)
+#include "Keccakc256TreeD2.h"
+#endif
+#if defined(c512) && defined(D2)
+#include "Keccakc512TreeD2.h"
+#endif
+
+
+#ifdef D2
+typedef unsigned long long int UINT64;
+
+void printDoubleState(const UINT64* doubleState)
+{
+    unsigned int i;
+    for(i=0; i<25; i++) {
+        printf("%08X", (doubleState[i*2] >> 32));
+        printf("%08X", (doubleState[i*2] & 0xFFFFFFFFULL));
+        if ((i%5) == 4)
+            printf("\n");
+        else
+            printf(" ");
+    }
+
+    printf("\n");
+
+    for(i=0; i<25; i++) {
+        printf("%08X", (doubleState[i*2+1] >> 32));
+        printf("%08X", (doubleState[i*2+1] & 0xFFFFFFFFULL));
+        if ((i%5) == 4)
+            printf("\n");
+        else
+            printf(" ");
+    }
+}
+
+void testDoublePermutation()
+{
+    unsigned int i;
+    ALIGN UINT64 doubleState[25*2];
+    memset(doubleState, 0, sizeof(doubleState));
+    printf("Double state before:\n");
+    printDoubleState(doubleState);
+    KeccakDoublePermutationOnWords((V128*)doubleState);
+    printf("Double state after:\n");
+    printDoubleState(doubleState);
+
+    for(i=0; i<25; i++)
+        doubleState[i*2] = 0;
+
+    KeccakDoublePermutationOnWords((V128*)doubleState);
+    printf("Double state after after:\n");
+    printDoubleState(doubleState);
+}
+#endif
+
+#ifdef rateInBytes
+void testKeccakTree()
+{
+    unsigned char message[1000];
+    unsigned char out[1000];
+    unsigned int len;
+    unsigned int i;
+    
+    for(len=0; len<=1000; len++) {
+        for(i=0; i<len; i++)
+            message[i] = (unsigned char)(len-i);
+        crypto_hash(out, message, len);
+        printf("Message of length %d bits\n", len*8);
+        for(i=0; i<rateInBytes; i++)
+            printf("%02x ", out[i]);
+        printf("\n");
+    }
+}
+#endif
+
+int main()
+{
+#ifdef D2
+    //testDoublePermutation();
+#endif
+#ifdef rateInBytes
+    testKeccakTree();
+#endif
+    doTiming();
+    return 0;
+}