sha3-ruby 0.0.1

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/timing-Double.c

@@ -0,0 +1,225 @@
+/*
+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>
+
+/************** Timing routine (for performance measurements) ***********/
+/* By Doug Whiting */
+/* unfortunately, this is generally assembly code and not very portable */
+#if defined(_M_IX86) || defined(__i386) || defined(_i386) || defined(__i386__) || defined(i386) || \
+    defined(_X86_)   || defined(__x86_64__) || defined(_M_X64) || defined(__x86_64)
+#define _Is_X86_    1
+#endif
+
+#if  defined(_Is_X86_) && (!defined(__STRICT_ANSI__)) && (defined(__GNUC__) || !defined(__STDC__)) && \
+    (defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW_H) || defined(__GNUC__))
+#define HI_RES_CLK_OK         1          /* it's ok to use RDTSC opcode */
+
+#if defined(_MSC_VER) // && defined(_M_X64)
+#include <intrin.h>
+#pragma intrinsic(__rdtsc)         /* use MSVC rdtsc call where defined */
+#endif
+
+#endif
+
+typedef unsigned int uint_32t;
+
+uint_32t HiResTime(void)           /* return the current value of time stamp counter */
+    {
+#if defined(HI_RES_CLK_OK)
+    uint_32t x[2];
+#if   defined(__BORLANDC__)
+#define COMPILER_ID "BCC"
+    __emit__(0x0F,0x31);           /* RDTSC instruction */
+    _asm { mov x[0],eax };
+#elif defined(_MSC_VER)
+#define COMPILER_ID "MSC"
+#if defined(_MSC_VER) // && defined(_M_X64)
+    x[0] = (uint_32t) __rdtsc();
+#else
+    _asm { _emit 0fh }; _asm { _emit 031h };
+    _asm { mov x[0],eax };
+#endif
+#elif defined(__MINGW_H) || defined(__GNUC__)
+#define COMPILER_ID "GCC"
+    asm volatile("rdtsc" : "=a"(x[0]), "=d"(x[1]));
+#else
+#error  "HI_RES_CLK_OK -- but no assembler code for this platform (?)"
+#endif
+    return x[0];
+#else
+    /* avoid annoying MSVC 9.0 compiler warning #4720 in ANSI mode! */
+#if (!defined(_MSC_VER)) || (!defined(__STDC__)) || (_MSC_VER < 1300)
+    FatalError("No support for RDTSC on this CPU platform\n");
+#endif
+    return 0;
+#endif /* defined(HI_RES_CLK_OK) */
+    }
+
+#define TIMER_SAMPLE_CNT (10)
+
+uint_32t calibrate()
+{
+    uint_32t dtMin = 0xFFFFFFFF;        /* big number to start */
+    uint_32t t0,t1,i;
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        t1 = HiResTime();
+        if (dtMin > t1-t0)              /* keep only the minimum time */
+            dtMin = t1-t0;
+        }
+    return dtMin;
+}
+
+#include "DoublePermutation.h"
+
+uint_32t measureDoubleKeccakAbsorb1344bits(uint_32t dtMin)
+{
+    uint_32t tMin = 0xFFFFFFFF;         /* big number to start */
+    uint_32t t0,t1,i;
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char input[168*2];
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        KeccakDoublePermutationOnWordsAfterXoring2x1344bits((V128*)state, (V128*)input);
+        t1 = HiResTime();
+        if (tMin > t1-t0 - dtMin)       /* keep only the minimum time */
+            tMin = t1-t0 - dtMin;
+        }
+
+    /* now tMin = # clocks required for running RoutineToBeTimed() */
+    
+    return tMin;
+}
+
+uint_32t measureDoubleKeccakAbsorb1088bits(uint_32t dtMin)
+{
+    uint_32t tMin = 0xFFFFFFFF;         /* big number to start */
+    uint_32t t0,t1,i;
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char input[136*2];
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        KeccakDoublePermutationOnWordsAfterXoring2x1088bits((V128*)state, (V128*)input);
+        t1 = HiResTime();
+        if (tMin > t1-t0 - dtMin)       /* keep only the minimum time */
+            tMin = t1-t0 - dtMin;
+        }
+
+    /* now tMin = # clocks required for running RoutineToBeTimed() */
+    
+    return tMin;
+}
+
+uint_32t measureDoubleKeccakAbsorb1024bits(uint_32t dtMin)
+{
+    uint_32t tMin = 0xFFFFFFFF;         /* big number to start */
+    uint_32t t0,t1,i;
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char input[128*2];
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        KeccakDoublePermutationOnWordsAfterXoring2x1024bits((V128*)state, (V128*)input);
+        t1 = HiResTime();
+        if (tMin > t1-t0 - dtMin)       /* keep only the minimum time */
+            tMin = t1-t0 - dtMin;
+        }
+
+    /* now tMin = # clocks required for running RoutineToBeTimed() */
+    
+    return tMin;
+}
+
+uint_32t measureDoubleKeccakAbsorb512bits(uint_32t dtMin)
+{
+    uint_32t tMin = 0xFFFFFFFF;         /* big number to start */
+    uint_32t t0,t1,i;
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+    ALIGN unsigned char input[64*2];
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        KeccakDoublePermutationOnWordsAfterXoring2x512bits((V128*)state, (V128*)input);
+        t1 = HiResTime();
+        if (tMin > t1-t0 - dtMin)       /* keep only the minimum time */
+            tMin = t1-t0 - dtMin;
+        }
+
+    /* now tMin = # clocks required for running RoutineToBeTimed() */
+    
+    return tMin;
+}
+
+uint_32t measureDoubleKeccakPermutation(uint_32t dtMin)
+{
+    uint_32t tMin = 0xFFFFFFFF;         /* big number to start */
+    uint_32t t0,t1,i;
+    ALIGN unsigned char state[KeccakPermutationSizeInBytes*2];
+
+    for (i=0;i < TIMER_SAMPLE_CNT;i++)  /* calibrate the overhead for measuring time */
+        {
+        t0 = HiResTime();
+        KeccakDoublePermutationOnWords((V128*)state);
+        t1 = HiResTime();
+        if (tMin > t1-t0 - dtMin)       /* keep only the minimum time */
+            tMin = t1-t0 - dtMin;
+        }
+
+    /* now tMin = # clocks required for running RoutineToBeTimed() */
+    
+    return tMin;
+}
+
+
+
+void doTiming()
+{
+    uint_32t calibration;
+    uint_32t measurementDoubleKeccakPermutation;
+    uint_32t measurementDoubleKeccakAbsorb1344bits;
+    uint_32t measurementDoubleKeccakAbsorb1088bits;
+    uint_32t measurementDoubleKeccakAbsorb1024bits;
+
+    calibration = calibrate();
+
+    measurementDoubleKeccakPermutation = measureDoubleKeccakPermutation(calibration);
+    printf("Cycles for DoubleKeccakPermutation(state): %d\n", measurementDoubleKeccakPermutation);
+    printf("Cycles per byte for rate 1024: %f\n", measurementDoubleKeccakPermutation/128.0/2.0);
+    printf("Cycles per byte for rate 1088: %f\n", measurementDoubleKeccakPermutation/136.0/2.0);
+    printf("Cycles per byte for rate 1344: %f\n", measurementDoubleKeccakPermutation/168.0/2.0);
+    printf("\n");
+
+    measurementDoubleKeccakAbsorb1344bits = measureDoubleKeccakAbsorb1344bits(calibration);
+    printf("Cycles for DoubleKeccakAbsorb1344bits(state, input): %d\n", measurementDoubleKeccakAbsorb1344bits);
+    printf("Cycles per byte for rate 1344: %f\n", measurementDoubleKeccakAbsorb1344bits/168.0/2.0);
+    printf("\n");
+
+    measurementDoubleKeccakAbsorb1088bits = measureDoubleKeccakAbsorb1088bits(calibration);
+    printf("Cycles for DoubleKeccakAbsorb1088bits(state, input): %d\n", measurementDoubleKeccakAbsorb1088bits);
+    printf("Cycles per byte for rate 1088: %f\n", measurementDoubleKeccakAbsorb1088bits/136.0/2.0);
+    printf("\n");
+
+    measurementDoubleKeccakAbsorb1024bits = measureDoubleKeccakAbsorb1024bits(calibration);
+    printf("Cycles for DoubleKeccakAbsorb1024bits(state, input): %d\n", measurementDoubleKeccakAbsorb1024bits);
+    printf("Cycles per byte for rate 1024: %f\n", measurementDoubleKeccakAbsorb1024bits/128.0/2.0);
+    printf("\n");
+}

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/Sources/timing-Double.h

@@ -0,0 +1,20 @@
+/*
+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 _timing_h_
+#define _timing_h_
+
+void doTiming();
+
+#endif
+

data/ext/sha3/KeccakReferenceAndOptimized/TreeHashing/makefile

@@ -0,0 +1,68 @@
+all: Keccakc256TreeD2 Keccakc512TreeD2
+
+SOURCES_D2 = \
+    Sources/mainOptimized.c \
+    Sources/timing-Double.c \
+    Sources/DoublePermutation.c
+
+HEADERS_D2 = \
+    Sources/timing-Double.h \
+    Sources/KeccakF-1600-unrolling.macros \
+    Sources/DoublePermutation.h
+
+SOURCES_c256D2 = $(SOURCES_D2) \
+    Sources/Keccakc256TreeD2.c
+
+SOURCES_c512D2 = $(SOURCES_D2) \
+    Sources/Keccakc512TreeD2.c
+
+HEADERS_c256D2 = $(HEADERS_D2) \
+    Sources/Keccakc256TreeD2.h
+
+HEADERS_c512D2 = $(HEADERS_D2) \
+    Sources/Keccakc512TreeD2.h
+
+BINDIR_c256D2 = bin/c256D2
+
+$(BINDIR_c256D2):
+	mkdir -p $(BINDIR_c256D2)
+
+OBJECTS_c256D2 = $(addprefix $(BINDIR_c256D2)/, $(notdir $(patsubst %.c,%.o,$(SOURCES_c256D2))))
+
+CFLAGS_c256D2 = -Dc256 -DD2 -fomit-frame-pointer -O3 -g0 -march=native -mtune=native
+
+BINDIR_c512D2 = bin/c512D2
+
+$(BINDIR_c512D2):
+	mkdir -p $(BINDIR_c512D2)
+
+OBJECTS_c512D2 = $(addprefix $(BINDIR_c512D2)/, $(notdir $(patsubst %.c,%.o,$(SOURCES_c512D2))))
+
+CFLAGS_c512D2 = -Dc512 -DD2 -fomit-frame-pointer -O3 -g0 -march=native -mtune=native
+
+VPATH = Sources
+
+INCLUDES = -ISources
+
+$(BINDIR_c256D2)/%.o:%.c $(HEADERS_c256D2)
+	$(CC) $(INCLUDES) $(CFLAGS_c256D2) -c $< -o $@
+
+$(BINDIR_c512D2)/%.o:%.c $(HEADERS_c512D2)
+	$(CC) $(INCLUDES) $(CFLAGS_c512D2) -c $< -o $@
+
+.PHONY: Keccakc256TreeD2 Keccakc512TreeD2
+
+Keccakc256TreeD2: bin/Keccakc256TreeD2
+
+bin/Keccakc256TreeD2:  $(BINDIR_c256D2) $(OBJECTS_c256D2)  $(HEADERS_c256D2)
+	$(CC) $(CFLAGS_c256D2) -o $@ $(OBJECTS_c256D2)
+
+Keccakc512TreeD2: bin/Keccakc512TreeD2
+
+bin/Keccakc512TreeD2:  $(BINDIR_c512D2) $(OBJECTS_c512D2)  $(HEADERS_c512D2)
+	$(CC) $(CFLAGS_c512D2) -o $@ $(OBJECTS_c512D2)
+
+.PHONY: clean
+
+clean:
+	rm -rf bin/

data/ext/sha3/KeccakReferenceAndOptimized/compile64.bat

@@ -0,0 +1 @@
+cl.exe Sources\mainOptimized.c Sources\genKAT.c Sources\KeccakDuplex.c Sources\KeccakF-1600-opt64.c Sources\KeccakNISTInterface.c Sources\KeccakSponge.c Sources\timing.c /O2 /Ot /favor:INTEL64

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccak

@@ -0,0 +1 @@
+b81e02441c494c66e2a45cd1cd6ce40721eae5126523b1c4586cab9be9e0ccf23c3eac48edcce8ce7c587762817e213a44c6d85bf14b259fda5107cb96b298f175765f5684a86933d775d13ea2665940082740ad94d5cd006878e44ff0801c35e65e5a80b5ebb9ff6b4c44177667d2a3c68c73e7777eeba14738bb1d9ba673d4

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc1024

@@ -0,0 +1 @@
+9b820a6ad49da5a2359566919b6d987d58eca84888c2123363ee57a932326449c8ca6bb9c3fb9f3be8364bf6ef3c2522140d92d636df0f580beeb381bc46491c

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc256

@@ -0,0 +1 @@
+58f992ee3a30041c7b5987ce169be4e18a8096bbb00c8794f377dff6bfedc76f4b11bc516d906b34062bf253a25e295d1f70addd94469bdf56268c19210639949c4821d83b78679168f582d31d7e942ebb297139f04595f1381942d03453779f477083075c6679819786e920069803af1359dfb78a1723638dcbea18ac80d3f1e1cd22b2e60accb25cc78f67e203372fb8fb2d3929cb95812622db2822ae8db951b675480a93273a

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc256treed2

@@ -0,0 +1 @@
+fe523291a13a5d4a395b11b922f5f0b99ec186097a9cbc2bfbef7b0aa03551adaaf1cd4651c7a675b9d3f9fd4e844572c716e50fed42feaede27b744b08950e5010700589513523a87a283c6c124032f77e1f18abfca2a046ae3c5aca543f9491037bab12ab1d58ab3d735680c543bb55d5759a949ca71b407ff27a2ce79de7853429b5264aa351397175fbe1e9ec784414ae4af270b88b8b011a54cea61ad3308cec8ef5ad96cc7

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc448

@@ -0,0 +1 @@
+f96de427ccfc25f1ec48311b7bbbf00d8c5dbd25be1e91c1bd170562

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc512

@@ -0,0 +1 @@
+ef4c3a6ae3c066643e3132da983f4e6ae4e15d222225d06c9fd5a2c4c794501c

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc512treed2

@@ -0,0 +1 @@
+689ae4bd325cb0744ebc4a18ae565608fe6d3cf716196ab951afed2fe4fadbc1e204c73a869ebecf7ba9482401a2be0815ea7d728fec4a06961e35dcdbab4332fd6a0efcded7103e906cf3faa4b0a15bb6aa6172dccd01a566ddcda2f54ed78826400429fa20673002edbe0d5ee1e2d1741915e695b93778e6914d1d1065a1a1817af7d599bfd73d

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/checksum-keccakc768

@@ -0,0 +1 @@
+1dcf9ddf8ca2d0df093c215224bff74fe6e41e1fbda16a5aa076f4efdfa27aa43aca5001b79a69083449d39b22c593e5

data/ext/sha3/KeccakReferenceAndOptimized/eBASH/hash-keccak.c

@@ -0,0 +1,11 @@
+#include "crypto_hash.h"
+#include "KeccakSponge.h"
+
+int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen)
+{
+    spongeState state;
+    InitSponge(&state, 1024, 576);
+    Absorb(&state, in, inlen*8);
+    Squeeze(&state, out, crypto_hash_BYTES*8);
+    return 0;
+}