@leocuvee/wrkzcoin-multi-hashing 0.0.20

package/cryptonight_turtle_lite.c

@@ -0,0 +1,300 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+// Portions Copyright (c) 2018 The Monero developers
+// Portions Copyright (c) 2018 The TurtleCoin Developers
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "crypto/oaes_lib.h"
+#include "crypto/c_keccak.h"
+#include "crypto/c_groestl.h"
+#include "crypto/c_blake256.h"
+#include "crypto/c_jh.h"
+#include "crypto/c_skein.h"
+#include "crypto/int-util.h"
+#include "crypto/hash-ops.h"
+#include "crypto/variant2_int_sqrt.h"
+
+#if defined(_MSC_VER)
+#include <malloc.h>
+#endif
+
+#define MEMORY          262144 /* 256KB - 2^18 */
+#define ITER            131072 /* 2^17 */
+#define ITER_DIV        65536 /* 2^16 */
+#define AES_BLOCK_SIZE  16
+#define AES_KEY_SIZE    32 /*16*/
+#define INIT_SIZE_BLK   8
+#define INIT_SIZE_BYTE  (INIT_SIZE_BLK * AES_BLOCK_SIZE)
+#define CN_INIT         (MEMORY / INIT_SIZE_BYTE)
+#define CN_AES_INIT     (MEMORY / AES_BLOCK_SIZE) / 2
+
+#define VARIANT1_1(p) \
+  do if (variant == 1) \
+  { \
+    const uint8_t tmp = ((const uint8_t*)(p))[11]; \
+    static const uint32_t table = 0x75310; \
+    const uint8_t index = (((tmp >> 3) & 6) | (tmp & 1)) << 1; \
+    ((uint8_t*)(p))[11] = tmp ^ ((table >> index) & 0x30); \
+  } while(0)
+
+#define VARIANT1_2(p) \
+   do if (variant == 1) \
+   { \
+     ((uint64_t*)p)[1] ^= tweak1_2; \
+   } while(0)
+
+#define VARIANT1_INIT() \
+  if (variant == 1 && len < 43) \
+  { \
+    fprintf(stderr, "Cryptonight variant 1 needs at least 43 bytes of data"); \
+    _exit(1); \
+  } \
+  const uint64_t tweak1_2 = (variant == 1) ? *(const uint64_t*)(((const uint8_t*)input)+35) ^ ctx->state.hs.w[24] : 0
+
+#define U64(p) ((uint64_t*)(p))
+
+#define VARIANT2_INIT(b, state) \
+  uint64_t division_result; \
+  uint64_t sqrt_result; \
+  do if (variant >= 2) \
+  { \
+    U64(b)[2] = state.hs.w[8] ^ state.hs.w[10]; \
+    U64(b)[3] = state.hs.w[9] ^ state.hs.w[11]; \
+    division_result = state.hs.w[12]; \
+    sqrt_result = state.hs.w[13]; \
+  } while (0)
+
+#define VARIANT2_SHUFFLE_ADD(base_ptr, offset, a, b) \
+  do if (variant >= 2) \
+  { \
+    uint64_t* chunk1 = U64((base_ptr) + ((offset) ^ 0x10)); \
+    uint64_t* chunk2 = U64((base_ptr) + ((offset) ^ 0x20)); \
+    uint64_t* chunk3 = U64((base_ptr) + ((offset) ^ 0x30)); \
+    \
+    const uint64_t chunk1_old[2] = { chunk1[0], chunk1[1] }; \
+    \
+    chunk1[0] = chunk3[0] + U64(b + 16)[0]; \
+    chunk1[1] = chunk3[1] + U64(b + 16)[1]; \
+    \
+    chunk3[0] = chunk2[0] + U64(a)[0]; \
+    chunk3[1] = chunk2[1] + U64(a)[1]; \
+    \
+    chunk2[0] = chunk1_old[0] + U64(b)[0]; \
+    chunk2[1] = chunk1_old[1] + U64(b)[1]; \
+  } while (0)
+
+#define VARIANT2_INTEGER_MATH_DIVISION_STEP(b, ptr) \
+  ((uint64_t*)(b))[0] ^= division_result ^ (sqrt_result << 32); \
+  { \
+    const uint64_t dividend = ((uint64_t*)(ptr))[1]; \
+    const uint32_t divisor = (((uint32_t*)(ptr))[0] + (uint32_t)(sqrt_result << 1)) | 0x80000001UL; \
+    division_result = ((uint32_t)(dividend / divisor)) + \
+                     (((uint64_t)(dividend % divisor)) << 32); \
+  } \
+  const uint64_t sqrt_input = ((uint64_t*)(ptr))[0] + division_result
+
+#define VARIANT2_INTEGER_MATH(b, ptr) \
+    do if (variant >= 2) \
+    { \
+      VARIANT2_INTEGER_MATH_DIVISION_STEP(b, ptr); \
+      VARIANT2_INTEGER_MATH_SQRT_STEP_FP64(); \
+      VARIANT2_INTEGER_MATH_SQRT_FIXUP(sqrt_result); \
+    } while (0)
+
+#define VARIANT2_2() \
+  do if (variant >= 2) { \
+    ((uint64_t*)(ctx->long_state + ((j * AES_BLOCK_SIZE) ^ 0x10)))[0] ^= hi; \
+    ((uint64_t*)(ctx->long_state + ((j * AES_BLOCK_SIZE) ^ 0x10)))[1] ^= lo; \
+    hi ^= ((uint64_t*)(ctx->long_state + ((j * AES_BLOCK_SIZE) ^ 0x20)))[0]; \
+    lo ^= ((uint64_t*)(ctx->long_state + ((j * AES_BLOCK_SIZE) ^ 0x20)))[1]; \
+  } while (0)
+
+#pragma pack(push, 1)
+union cn_slow_hash_state {
+    union hash_state hs;
+    struct {
+        uint8_t k[64];
+        uint8_t init[INIT_SIZE_BYTE];
+    };
+};
+#pragma pack(pop)
+
+static void do_turtle_lite_blake_hash(const void* input, size_t len, char* output) {
+    blake256_hash((uint8_t*)output, input, len);
+}
+
+void do_turtle_lite_groestl_hash(const void* input, size_t len, char* output) {
+    groestl(input, len * 8, (uint8_t*)output);
+}
+
+static void do_turtle_lite_jh_hash(const void* input, size_t len, char* output) {
+    int r = jh_hash(HASH_SIZE * 8, input, 8 * len, (uint8_t*)output);
+    assert(SUCCESS == r);
+}
+
+static void do_turtle_lite_skein_hash(const void* input, size_t len, char* output) {
+    int r = c_skein_hash(8 * HASH_SIZE, input, 8 * len, (uint8_t*)output);
+    assert(SKEIN_SUCCESS == r);
+}
+
+static void (* const extra_hashes[4])(const void *, size_t, char *) = {
+    do_turtle_lite_blake_hash, do_turtle_lite_groestl_hash, do_turtle_lite_jh_hash, do_turtle_lite_skein_hash
+};
+
+extern int aesb_single_round(const uint8_t *in, uint8_t*out, const uint8_t *expandedKey);
+extern int aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *expandedKey);
+
+static inline size_t e2i(const uint8_t* a) {
+    return (*((uint64_t*) a) / AES_BLOCK_SIZE) & (CN_AES_INIT - 1);
+}
+
+static void mul(const uint8_t* a, const uint8_t* b, uint8_t* res) {
+    ((uint64_t*) res)[1] = mul128(((uint64_t*) a)[0], ((uint64_t*) b)[0], (uint64_t*) res);
+}
+
+static void sum_half_blocks(uint8_t* a, const uint8_t* b) {
+    uint64_t a0, a1, b0, b1;
+
+    a0 = SWAP64LE(((uint64_t*) a)[0]);
+    a1 = SWAP64LE(((uint64_t*) a)[1]);
+    b0 = SWAP64LE(((uint64_t*) b)[0]);
+    b1 = SWAP64LE(((uint64_t*) b)[1]);
+    a0 += b0;
+    a1 += b1;
+    ((uint64_t*) a)[0] = SWAP64LE(a0);
+    ((uint64_t*) a)[1] = SWAP64LE(a1);
+}
+
+static inline void copy_block(uint8_t* dst, const uint8_t* src) {
+    ((uint64_t*) dst)[0] = ((uint64_t*) src)[0];
+    ((uint64_t*) dst)[1] = ((uint64_t*) src)[1];
+}
+
+static void swap_blocks(uint8_t* a, uint8_t* b) {
+    size_t i;
+    uint8_t t;
+    for (i = 0; i < AES_BLOCK_SIZE; i++) {
+        t = a[i];
+        a[i] = b[i];
+        b[i] = t;
+    }
+}
+
+static inline void xor_blocks(uint8_t* a, const uint8_t* b) {
+    ((uint64_t*) a)[0] ^= ((uint64_t*) b)[0];
+    ((uint64_t*) a)[1] ^= ((uint64_t*) b)[1];
+}
+
+static inline void xor_blocks_dst(const uint8_t* a, const uint8_t* b, uint8_t* dst) {
+    ((uint64_t*) dst)[0] = ((uint64_t*) a)[0] ^ ((uint64_t*) b)[0];
+    ((uint64_t*) dst)[1] = ((uint64_t*) a)[1] ^ ((uint64_t*) b)[1];
+}
+
+struct cryptonightturtlelite_ctx {
+    uint8_t long_state[MEMORY];
+    union cn_slow_hash_state state;
+    uint8_t text[INIT_SIZE_BYTE];
+    uint8_t a[AES_BLOCK_SIZE];
+    uint8_t b[AES_BLOCK_SIZE * 2];
+    uint8_t c[AES_BLOCK_SIZE];
+    uint8_t aes_key[AES_KEY_SIZE];
+    oaes_ctx* aes_ctx;
+};
+
+void cryptonightturtlelite_hash(const char* input, char* output, uint32_t len, int variant) {
+#if defined(_MSC_VER)
+    struct cryptonightturtlelite_ctx *ctx = _malloca(sizeof(struct cryptonightturtlelite_ctx));
+#else
+    struct cryptonightturtlelite_ctx *ctx = alloca(sizeof(struct cryptonightturtlelite_ctx));
+#endif
+    hash_process(&ctx->state.hs, (const uint8_t*) input, len);
+    memcpy(ctx->text, ctx->state.init, INIT_SIZE_BYTE);
+    memcpy(ctx->aes_key, ctx->state.hs.b, AES_KEY_SIZE);
+    ctx->aes_ctx = (oaes_ctx*) oaes_alloc();
+    size_t i, j;
+
+    VARIANT1_INIT();
+    VARIANT2_INIT(ctx->b, ctx->state);
+
+    oaes_key_import_data(ctx->aes_ctx, ctx->aes_key, AES_KEY_SIZE);
+    for (i = 0; i < CN_INIT; i++) {
+        for (j = 0; j < INIT_SIZE_BLK; j++) {
+            aesb_pseudo_round(&ctx->text[AES_BLOCK_SIZE * j],
+                    &ctx->text[AES_BLOCK_SIZE * j],
+                    ctx->aes_ctx->key->exp_data);
+        }
+        memcpy(&ctx->long_state[i * INIT_SIZE_BYTE], ctx->text, INIT_SIZE_BYTE);
+    }
+
+    for (i = 0; i < 16; i++) {
+        ctx->a[i] = ctx->state.k[i] ^ ctx->state.k[32 + i];
+        ctx->b[i] = ctx->state.k[16 + i] ^ ctx->state.k[48 + i];
+    }
+
+    for (i = 0; i < ITER_DIV; i++) {
+        /* Dependency chain: address -> read value ------+
+         * written value <-+ hard function (AES or MUL) <+
+         * next address  <-+
+         */
+        /* Iteration 1 */
+        j = e2i(ctx->a);
+        aesb_single_round(&ctx->long_state[j * AES_BLOCK_SIZE], ctx->c, ctx->a);
+        VARIANT2_SHUFFLE_ADD(ctx->long_state, j * AES_BLOCK_SIZE, ctx->a, ctx->b);
+        xor_blocks_dst(ctx->c, ctx->b, &ctx->long_state[j * AES_BLOCK_SIZE]);
+        VARIANT1_1((uint8_t*)&ctx->long_state[j * AES_BLOCK_SIZE]);
+        /* Iteration 2 */
+        j = e2i(ctx->c);
+
+        uint64_t* dst = (uint64_t*)&ctx->long_state[j * AES_BLOCK_SIZE];
+
+        uint64_t t[2];
+        t[0] = dst[0];
+        t[1] = dst[1];
+
+        VARIANT2_INTEGER_MATH(t, ctx->c);
+
+        uint64_t hi;
+        uint64_t lo = mul128(((uint64_t*)ctx->c)[0], t[0], &hi);
+
+        VARIANT2_2();
+        VARIANT2_SHUFFLE_ADD(ctx->long_state, j * AES_BLOCK_SIZE, ctx->a, ctx->b);
+
+        ((uint64_t*)ctx->a)[0] += hi;
+        ((uint64_t*)ctx->a)[1] += lo;
+
+        dst[0] = ((uint64_t*)ctx->a)[0];
+        dst[1] = ((uint64_t*)ctx->a)[1];
+
+        ((uint64_t*)ctx->a)[0] ^= t[0];
+        ((uint64_t*)ctx->a)[1] ^= t[1];
+
+        VARIANT1_2((uint8_t*)&ctx->long_state[j * AES_BLOCK_SIZE]);
+        copy_block(ctx->b + AES_BLOCK_SIZE, ctx->b);
+        copy_block(ctx->b, ctx->c);
+    }
+
+    memcpy(ctx->text, ctx->state.init, INIT_SIZE_BYTE);
+    oaes_key_import_data(ctx->aes_ctx, &ctx->state.hs.b[32], AES_KEY_SIZE);
+    for (i = 0; i < CN_INIT; i++) {
+        for (j = 0; j < INIT_SIZE_BLK; j++) {
+            xor_blocks(&ctx->text[j * AES_BLOCK_SIZE],
+                    &ctx->long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
+            aesb_pseudo_round(&ctx->text[j * AES_BLOCK_SIZE],
+                    &ctx->text[j * AES_BLOCK_SIZE],
+                    ctx->aes_ctx->key->exp_data);
+        }
+    }
+    memcpy(ctx->state.init, ctx->text, INIT_SIZE_BYTE);
+    hash_permutation(&ctx->state.hs);
+    /*memcpy(hash, &state, 32);*/
+    extra_hashes[ctx->state.hs.b[0] & 3](&ctx->state, 200, output);
+    oaes_free((OAES_CTX **) &ctx->aes_ctx);
+}
+
+void cryptonightturtlelite_fast_hash(const char* input, char* output, uint32_t len) {
+    union hash_state state;
+    hash_process(&state, (const uint8_t*) input, len);
+    memcpy(output, &state, HASH_SIZE);
+}

package/cryptonight_turtle_lite.h

@@ -0,0 +1,17 @@
+#ifndef CRYPTONIGHTTURTLELITE_H
+#define CRYPTONIGHTTURTLELITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void cryptonightturtlelite_hash(const char* input, char* output, uint32_t len, int variant);
+void cryptonightturtlelite_fast_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/fresh.c

@@ -0,0 +1,42 @@
+#include "fresh.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "sha3/sph_shavite.h"
+#include "sha3/sph_simd.h"
+#include "sha3/sph_echo.h"
+
+void fresh_hash(const char* input, char* output, uint32_t len)
+{
+    sph_shavite512_context	ctx_shavite1;
+    sph_simd512_context		ctx_simd1;
+    sph_echo512_context		ctx_echo1;
+
+    //these uint512 in the c++ source of the client are backed by an array of uint32
+    uint32_t hashA[16], hashB[16];
+
+    sph_shavite512_init (&ctx_shavite1);
+    sph_shavite512 (&ctx_shavite1, input, len);
+    sph_shavite512_close(&ctx_shavite1, hashA);
+
+    sph_simd512_init (&ctx_simd1);
+    sph_simd512 (&ctx_simd1, hashA, 64);
+    sph_simd512_close(&ctx_simd1, hashB);
+
+    sph_shavite512_init (&ctx_shavite1);
+    sph_shavite512 (&ctx_shavite1, hashB, 64);
+    sph_shavite512_close(&ctx_shavite1, hashA);
+
+    sph_simd512_init (&ctx_simd1);
+    sph_simd512 (&ctx_simd1, hashA, 64);
+    sph_simd512_close(&ctx_simd1, hashB);
+
+    sph_echo512_init (&ctx_echo1);
+    sph_echo512 (&ctx_echo1, hashB, 64);
+    sph_echo512_close(&ctx_echo1, hashA);
+
+    memcpy(output, hashA, 32);
+
+}

package/fresh.h

@@ -0,0 +1,16 @@
+#ifndef FRESH_H
+#define FRESH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void fresh_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/fugue.c

@@ -0,0 +1,12 @@
+#include "fugue.h"
+
+#include "sha3/sph_fugue.h"
+
+void fugue_hash(const char* input, char* output, uint32_t len)
+{
+    sph_fugue256_context ctx_fugue;
+    sph_fugue256_init(&ctx_fugue);
+    sph_fugue256(&ctx_fugue, input, len);
+    sph_fugue256_close(&ctx_fugue, output);
+}
+

package/fugue.h

@@ -0,0 +1,16 @@
+#ifndef FUGUE_H
+#define FUGUE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void fugue_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/groestl.c

@@ -0,0 +1,40 @@
+#include "groestl.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "sha3/sph_groestl.h"
+#include "sha256.h"
+
+void groestl_hash(const char* input, char* output, uint32_t len)
+{
+    char hash1[64];
+    char hash2[64];
+    
+    sph_groestl512_context ctx_groestl;
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512(&ctx_groestl, input, len);
+    sph_groestl512_close(&ctx_groestl, &hash1);
+    
+    sph_groestl512(&ctx_groestl, hash1, 64);
+    sph_groestl512_close(&ctx_groestl, &hash2);
+    
+    memcpy(output, &hash2, 32);
+}
+
+void groestlmyriad_hash(const char* input, char* output, uint32_t len)
+{
+    char temp[64];
+    
+    sph_groestl512_context ctx_groestl;
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512(&ctx_groestl, input, len);
+    sph_groestl512_close(&ctx_groestl, &temp);
+    
+    SHA256_CTX ctx_sha256;
+    SHA256_Init(&ctx_sha256);
+    SHA256_Update(&ctx_sha256, &temp, 64);
+    SHA256_Final((unsigned char*) output, &ctx_sha256);
+}
+

package/groestl.h

@@ -0,0 +1,17 @@
+#ifndef GROESTL_H
+#define GROESTL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void groestl_hash(const char* input, char* output, uint32_t len);
+void groestlmyriad_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/hefty1.c

@@ -0,0 +1,63 @@
+#include "hefty1.h"
+
+#include "sha3/sph_hefty1.h"
+#include "sha3/sph_keccak.h"
+#include "sha3/sph_groestl.h"
+#include "sha3/sph_blake.h"
+#include "sha256.h"
+
+void hefty1_hash(const char* input, char* output, uint32_t len)
+{
+    HEFTY1_CTX              ctx_hefty1;
+    SHA256_CTX              ctx_sha256;
+    sph_keccak512_context   ctx_keccak;
+    sph_groestl512_context  ctx_groestl;
+    sph_blake512_context    ctx_blake;
+    
+    char hash32_1[32];
+    char hash32_2[32];
+    char hash64_3[64];
+    char hash64_4[64];
+    char hash64_5[64];
+    
+    HEFTY1_Init(&ctx_hefty1);
+    HEFTY1_Update(&ctx_hefty1, (const void*) input, len);
+    HEFTY1_Final((unsigned char*) &hash32_1, &ctx_hefty1); // 1
+    
+    SHA256_Init(&ctx_sha256);
+    SHA256_Update(&ctx_sha256, (const void*) input, len);
+    SHA256_Update(&ctx_sha256, (unsigned char*) &hash32_1, 32); // 1
+    SHA256_Final((unsigned char*) &hash32_2, &ctx_sha256); // 2
+    
+    sph_keccak512_init(&ctx_keccak);
+    sph_keccak512(&ctx_keccak, (const void*) input, len);
+    sph_keccak512(&ctx_keccak, (unsigned char*) &hash32_1, 32); //1
+    sph_keccak512_close(&ctx_keccak, (void*) &hash64_3); // 3
+    
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512(&ctx_groestl, (const void*) input, len);
+    sph_groestl512(&ctx_groestl, (unsigned char*) &hash32_1, 32); // 1
+    sph_groestl512_close(&ctx_groestl, (void*) &hash64_4); // 4
+    
+    sph_blake512_init(&ctx_blake);
+    sph_blake512(&ctx_blake, (const void*) input, len);
+    sph_blake512(&ctx_blake, (unsigned char*) &hash32_1, 32); // 1
+    sph_blake512_close(&ctx_blake, (void*) &hash64_5); // 5
+    
+    memset(output, 0, 32);
+    
+    char* hash[4] = { hash32_2, hash64_3, hash64_4, hash64_5 };
+    
+    uint32_t i;
+    uint32_t j;
+    
+    #define OUTPUT_BIT (i * 4 + j)
+    
+    for(i = 0; i < 64; i++) {
+        for(j = 0; j < 4; j++) {
+            if((*(hash[j] + (i / 8)) & (0x80 >> (i % 8))) != 0)
+                *(output + (OUTPUT_BIT / 8)) |= 0x80 >> (OUTPUT_BIT % 8);
+        }
+    }
+}
+

package/hefty1.h

@@ -0,0 +1,16 @@
+#ifndef HEFTY1_H
+#define HEFTY1_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void hefty1_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/index.js

@@ -0,0 +1 @@
+module.exports = require('bindings')('multihashing.node')

package/keccak.c

@@ -0,0 +1,14 @@
+#include "keccak.h"
+
+#include "sha3/sph_types.h"
+#include "sha3/sph_keccak.h"
+
+
+void keccak_hash(const char* input, char* output, uint32_t size)
+{
+    sph_keccak256_context ctx_keccak;
+    sph_keccak256_init(&ctx_keccak);
+    sph_keccak256 (&ctx_keccak, input, size);//80);
+    sph_keccak256_close(&ctx_keccak, output);
+}
+

package/keccak.h

@@ -0,0 +1,16 @@
+#ifndef KECCAK_H
+#define KECCAK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void keccak_hash(const char* input, char* output, uint32_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif