@leocuvee/wrkzcoin-multi-hashing 0.0.20

package/nist5.c

@@ -0,0 +1,46 @@
+#include "nist5.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "sha3/sph_blake.h"
+#include "sha3/sph_groestl.h"
+#include "sha3/sph_jh.h"
+#include "sha3/sph_keccak.h"
+#include "sha3/sph_skein.h"
+
+
+void nist5_hash(const char* input, char* output, uint32_t len)
+{
+    sph_blake512_context     ctx_blake;
+    sph_groestl512_context   ctx_groestl;
+    sph_skein512_context     ctx_skein;
+    sph_jh512_context        ctx_jh;
+    sph_keccak512_context    ctx_keccak;
+
+    //these uint512 in the c++ source of the client are backed by an array of uint32
+    uint32_t hash[16];
+
+    sph_blake512_init(&ctx_blake);
+    sph_blake512 (&ctx_blake, input, len);
+    sph_blake512_close (&ctx_blake, hash);
+
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512 (&ctx_groestl, hash, 64);
+    sph_groestl512_close(&ctx_groestl, hash);
+
+    sph_jh512_init(&ctx_jh);
+    sph_jh512 (&ctx_jh, hash, 64);
+    sph_jh512_close(&ctx_jh, hash);
+
+    sph_keccak512_init(&ctx_keccak);
+    sph_keccak512 (&ctx_keccak, hash, 64);
+    sph_keccak512_close(&ctx_keccak, hash);
+    
+    sph_skein512_init(&ctx_skein);
+    sph_skein512 (&ctx_skein, hash, 64);
+    sph_skein512_close (&ctx_skein, hash);
+
+    memcpy(output, hash, 32);
+}

package/nist5.h

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

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@leocuvee/wrkzcoin-multi-hashing",
+    "version": "0.0.20",
+    "main": "multihashing",
+    "gypfile": true,
+    "author": "Matthew Little <zone117x@gmail.com>",
+    "contributors": [
+        {
+            "name": "Wrkz Team",
+            "email": "team@wrkz.work",
+            "url": "https://www.wrkz.work"
+        },
+        {
+            "name": "Leo Stehlik not associated with any bloody crypto project"
+        }
+    ],
+    "license": "GPL-3.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/derogold/wrkzcoin-multi-hashing.git"
+    },
+    "scripts": {
+        "test": "node-gyp clean && node-gyp configure && node-gyp build && node tests/cryptonight-tests.js && node tests/argon2-tests.js",
+        "install": "node-gyp rebuild"
+    },
+    "dependencies": {
+        "bindings": "^1.5.0",
+        "safe-buffer": "^5.1.2"
+    },
+    "keywords": [
+        "scrypt",
+        "scryptjane",
+        "script-n",
+        "x11",
+        "quark",
+        "keccak_hash",
+        "skein",
+        "bcrypt",
+        "keccak",
+        "blake",
+        "shavite",
+        "fugue",
+        "sha1",
+        "turtlecoin",
+        "wrkzcoin",
+        "cryptonight"
+    ],
+    "description": "Cryptocurrency hashing functions for NodeJS. Adapted to be used with DeroGold and WRKZCoin. Used as a dependency for nodejs pool.",
+    "directories": {
+        "test": "tests"
+    },
+    "bugs": {
+        "url": "https://github.com/derogold/wrkzcoin-multi-hashing/issues"
+    },
+    "homepage": "https://github.com/derogold/wrkzcoin-multi-hashing#readme"
+}

package/quark.c

@@ -0,0 +1,210 @@
+/*-
+ * Copyright 2009 Colin Percival, 2011 ArtForz, 2013 Neisklar,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+
+#include "quark.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include "sha3/sph_blake.h"
+#include "sha3/sph_bmw.h"
+#include "sha3/sph_groestl.h"
+#include "sha3/sph_jh.h"
+#include "sha3/sph_keccak.h"
+#include "sha3/sph_skein.h"
+
+
+static __inline uint32_t
+be32dec(const void *pp)
+{
+	const uint8_t *p = (uint8_t const *)pp;
+
+	return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
+	    ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
+}
+
+static __inline void
+be32enc(void *pp, uint32_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[3] = x & 0xff;
+	p[2] = (x >> 8) & 0xff;
+	p[1] = (x >> 16) & 0xff;
+	p[0] = (x >> 24) & 0xff;
+}
+
+static __inline uint32_t
+le32dec(const void *pp)
+{
+	const uint8_t *p = (uint8_t const *)pp;
+
+	return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +
+	    ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));
+}
+
+static __inline void
+le32enc(void *pp, uint32_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[0] = x & 0xff;
+	p[1] = (x >> 8) & 0xff;
+	p[2] = (x >> 16) & 0xff;
+	p[3] = (x >> 24) & 0xff;
+}
+
+/*
+ * Encode a length len/4 vector of (uint32_t) into a length len vector of
+ * (unsigned char) in big-endian form.  Assumes len is a multiple of 4.
+ */
+static void
+be32enc_vect(unsigned char *dst, const uint32_t *src, uint32_t len)
+{
+	size_t i;
+
+	for (i = 0; i < len / 4; i++)
+		be32enc(dst + i * 4, src[i]);
+}
+
+/*
+ * Decode a big-endian length len vector of (unsigned char) into a length
+ * len/4 vector of (uint32_t).  Assumes len is a multiple of 4.
+ */
+static void
+be32dec_vect(uint32_t *dst, const unsigned char *src, uint32_t len)
+{
+	size_t i;
+
+	for (i = 0; i < len / 4; i++)
+		dst[i] = be32dec(src + i * 4);
+}
+
+void quark_hash(const char* input, char* output, uint32_t len)
+{
+    sph_blake512_context     ctx_blake;
+    sph_bmw512_context       ctx_bmw;
+    sph_groestl512_context   ctx_groestl;
+    sph_jh512_context        ctx_jh;
+    sph_keccak512_context    ctx_keccak;
+    sph_skein512_context     ctx_skein;
+
+    uint32_t mask = 8;
+    uint32_t zero = 0;
+
+    uint32_t hashA[16], hashB[16];
+
+
+
+    sph_blake512_init(&ctx_blake);
+    sph_blake512 (&ctx_blake, input, len);
+    sph_blake512_close (&ctx_blake, hashA);	 //0
+
+
+    sph_bmw512_init(&ctx_bmw);
+    sph_bmw512 (&ctx_bmw, hashA, 64);    //0
+    sph_bmw512_close(&ctx_bmw, hashB);   //1
+
+
+    if ((hashB[0] & mask) != zero)   //1
+    {
+        sph_groestl512_init(&ctx_groestl);
+        sph_groestl512 (&ctx_groestl, hashB, 64); //1
+        sph_groestl512_close(&ctx_groestl, hashA); //2
+    }
+    else
+    {
+        sph_skein512_init(&ctx_skein);
+        sph_skein512 (&ctx_skein, hashB, 64); //1
+        sph_skein512_close(&ctx_skein, hashA); //2
+    }
+
+
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512 (&ctx_groestl, hashA, 64); //2
+    sph_groestl512_close(&ctx_groestl, hashB); //3
+
+    sph_jh512_init(&ctx_jh);
+    sph_jh512 (&ctx_jh, hashB, 64); //3
+    sph_jh512_close(&ctx_jh, hashA); //4
+
+    if ((hashA[0] & mask) != zero) //4
+    {
+        sph_blake512_init(&ctx_blake);
+        sph_blake512 (&ctx_blake, hashA, 64); //
+        sph_blake512_close(&ctx_blake, hashB); //5
+    }
+    else
+    {
+        sph_bmw512_init(&ctx_bmw);
+        sph_bmw512 (&ctx_bmw, hashA, 64); //4
+        sph_bmw512_close(&ctx_bmw, hashB);   //5
+    }
+
+    sph_keccak512_init(&ctx_keccak);
+    sph_keccak512 (&ctx_keccak,hashB, 64); //5
+    sph_keccak512_close(&ctx_keccak, hashA); //6
+
+    sph_skein512_init(&ctx_skein);
+    sph_skein512 (&ctx_skein, hashA, 64); //6
+    sph_skein512_close(&ctx_skein, hashB); //7
+
+    if ((hashB[0] & mask) != zero) //7
+    {
+        sph_keccak512_init(&ctx_keccak);
+        sph_keccak512 (&ctx_keccak, hashB, 64); //
+        sph_keccak512_close(&ctx_keccak, hashA); //8
+    }
+    else
+    {
+        sph_jh512_init(&ctx_jh);
+        sph_jh512 (&ctx_jh, hashB, 64); //7
+        sph_jh512_close(&ctx_jh, hashA); //8
+    }
+
+
+
+	memcpy(output, hashA, 32);
+
+
+/*
+	printf("result: ");
+	for (ii=0; ii < 32; ii++)
+	{
+		printf ("%.2x",((uint8_t*)output)[ii]);
+	}
+	printf ("\n");
+*/
+
+
+
+
+}
+
+

package/quark.h

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

package/qubit.c

@@ -0,0 +1,45 @@
+#include "qubit.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "sha3/sph_cubehash.h"
+#include "sha3/sph_luffa.h"
+#include "sha3/sph_shavite.h"
+#include "sha3/sph_simd.h"
+#include "sha3/sph_echo.h"
+
+void qubit_hash(const char* input, char* output, uint32_t len)
+{
+    sph_luffa512_context    ctx_luffa;
+    sph_cubehash512_context ctx_cubehash;
+    sph_shavite512_context  ctx_shavite;
+    sph_simd512_context     ctx_simd;
+    sph_echo512_context     ctx_echo;
+    
+    char hash1[64];
+    char hash2[64];
+    
+    sph_luffa512_init(&ctx_luffa);
+    sph_luffa512(&ctx_luffa, (const void*) input, len);
+    sph_luffa512_close(&ctx_luffa, (void*) &hash1); // 1
+    
+    sph_cubehash512_init(&ctx_cubehash);
+    sph_cubehash512(&ctx_cubehash, (const void*) &hash1, 64); // 1
+    sph_cubehash512_close(&ctx_cubehash, (void*) &hash2); // 2
+    
+    sph_shavite512_init(&ctx_shavite);
+    sph_shavite512(&ctx_shavite, (const void*) &hash2, 64); // 3
+    sph_shavite512_close(&ctx_shavite, (void*) &hash1); // 4
+    
+    sph_simd512_init(&ctx_simd);
+    sph_simd512(&ctx_simd, (const void*) &hash1, 64); // 4
+    sph_simd512_close(&ctx_simd, (void*) &hash2); // 5
+    
+    sph_echo512_init(&ctx_echo);
+    sph_echo512(&ctx_echo, (const void*) &hash2, 64); // 5
+    sph_echo512_close(&ctx_echo, (void*) &hash1); // 6
+    
+    memcpy(output, &hash1, 32);
+}
+

package/qubit.h

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

package/scryptjane/scrypt-jane-chacha.h

@@ -0,0 +1,132 @@
+#define SCRYPT_MIX_BASE "ChaCha20/8"
+
+typedef uint32_t scrypt_mix_word_t;
+
+#define SCRYPT_WORDTO8_LE U32TO8_LE
+#define SCRYPT_WORD_ENDIAN_SWAP U32_SWAP
+
+#define SCRYPT_BLOCK_BYTES 64
+#define SCRYPT_BLOCK_WORDS (SCRYPT_BLOCK_BYTES / sizeof(scrypt_mix_word_t))
+
+/* must have these here in case block bytes is ever != 64 */
+#include "scrypt-jane-romix-basic.h"
+
+#include "scrypt-jane-mix_chacha-avx.h"
+#include "scrypt-jane-mix_chacha-ssse3.h"
+#include "scrypt-jane-mix_chacha-sse2.h"
+#include "scrypt-jane-mix_chacha.h"
+
+#if defined(SCRYPT_CHACHA_AVX)
+	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_avx
+	#define SCRYPT_ROMIX_FN scrypt_ROMix_avx
+	#define SCRYPT_MIX_FN chacha_core_avx
+	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
+	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
+	#include "scrypt-jane-romix-template.h"
+#endif
+
+#if defined(SCRYPT_CHACHA_SSSE3)
+	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_ssse3
+	#define SCRYPT_ROMIX_FN scrypt_ROMix_ssse3
+	#define SCRYPT_MIX_FN chacha_core_ssse3
+	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
+	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
+	#include "scrypt-jane-romix-template.h"
+#endif
+
+#if defined(SCRYPT_CHACHA_SSE2)
+	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_sse2
+	#define SCRYPT_ROMIX_FN scrypt_ROMix_sse2
+	#define SCRYPT_MIX_FN chacha_core_sse2
+	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
+	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
+	#include "scrypt-jane-romix-template.h"
+#endif
+
+/* cpu agnostic */
+#define SCRYPT_ROMIX_FN scrypt_ROMix_basic
+#define SCRYPT_MIX_FN chacha_core_basic
+#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_convert_endian
+#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_convert_endian
+#include "scrypt-jane-romix-template.h"
+
+#if !defined(SCRYPT_CHOOSE_COMPILETIME)
+static scrypt_ROMixfn
+scrypt_getROMix() {
+	size_t cpuflags = detect_cpu();
+
+#if defined(SCRYPT_CHACHA_AVX)
+	if (cpuflags & cpu_avx)
+		return scrypt_ROMix_avx;
+	else
+#endif
+
+#if defined(SCRYPT_CHACHA_SSSE3)
+	if (cpuflags & cpu_ssse3)
+		return scrypt_ROMix_ssse3;
+	else
+#endif
+
+#if defined(SCRYPT_CHACHA_SSE2)
+	if (cpuflags & cpu_sse2)
+		return scrypt_ROMix_sse2;
+	else
+#endif
+
+	return scrypt_ROMix_basic;
+}
+#endif
+
+
+#if defined(SCRYPT_TEST_SPEED)
+static size_t
+available_implementations() {
+	size_t flags = 0;
+
+#if defined(SCRYPT_CHACHA_AVX)
+	flags |= cpu_avx;
+#endif
+
+#if defined(SCRYPT_CHACHA_SSSE3)
+	flags |= cpu_ssse3;
+#endif
+
+#if defined(SCRYPT_CHACHA_SSE2)
+		flags |= cpu_sse2;
+#endif
+
+	return flags;
+}
+#endif
+
+static int
+scrypt_test_mix() {
+	static const uint8_t expected[16] = {
+		0x48,0x2b,0x2d,0xb8,0xa1,0x33,0x22,0x73,0xcd,0x16,0xc4,0xb4,0xb0,0x7f,0xb1,0x8a,
+	};
+
+	int ret = 1;
+	size_t cpuflags = detect_cpu();
+
+#if defined(SCRYPT_CHACHA_AVX)
+	if (cpuflags & cpu_avx)
+		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_avx, scrypt_romix_nop, scrypt_romix_nop, expected);
+#endif
+
+#if defined(SCRYPT_CHACHA_SSSE3)
+	if (cpuflags & cpu_ssse3)
+		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_ssse3, scrypt_romix_nop, scrypt_romix_nop, expected);
+#endif
+
+#if defined(SCRYPT_CHACHA_SSE2)
+	if (cpuflags & cpu_sse2)
+		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_sse2, scrypt_romix_nop, scrypt_romix_nop, expected);
+#endif
+
+#if defined(SCRYPT_CHACHA_BASIC)
+	ret &= scrypt_test_mix_instance(scrypt_ChunkMix_basic, scrypt_romix_convert_endian, scrypt_romix_convert_endian, expected);
+#endif
+
+	return ret;
+}
+

package/scryptjane/scrypt-jane-hash.h

@@ -0,0 +1,48 @@
+#if defined(SCRYPT_BLAKE512)
+#include "scrypt-jane-hash_blake512.h"
+#elif defined(SCRYPT_BLAKE256)
+#include "scrypt-jane-hash_blake256.h"
+#elif defined(SCRYPT_SHA512)
+#include "scrypt-jane-hash_sha512.h"
+#elif defined(SCRYPT_SHA256)
+#include "scrypt-jane-hash_sha256.h"
+#elif defined(SCRYPT_SKEIN512)
+#include "scrypt-jane-hash_skein512.h"
+#elif defined(SCRYPT_KECCAK512) || defined(SCRYPT_KECCAK256)
+#include "scrypt-jane-hash_keccak.h"
+#else
+	#define SCRYPT_HASH "ERROR"
+	#define SCRYPT_HASH_BLOCK_SIZE 64
+	#define SCRYPT_HASH_DIGEST_SIZE 64
+	typedef struct scrypt_hash_state_t { size_t dummy; } scrypt_hash_state;
+	typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
+	static void scrypt_hash_init(scrypt_hash_state *S) {}
+	static void scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {}
+	static void scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {}
+	static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {0};
+	#error must define a hash function!
+#endif
+
+#include "scrypt-jane-pbkdf2.h"
+
+#define SCRYPT_TEST_HASH_LEN 257 /* (2 * largest block size) + 1 */
+
+static int
+scrypt_test_hash() {
+	scrypt_hash_state st;
+	scrypt_hash_digest hash, final;
+	uint8_t msg[SCRYPT_TEST_HASH_LEN];
+	size_t i;
+
+	for (i = 0; i < SCRYPT_TEST_HASH_LEN; i++)
+		msg[i] = (uint8_t)i;
+
+	scrypt_hash_init(&st);
+	for (i = 0; i < SCRYPT_TEST_HASH_LEN + 1; i++) {
+		scrypt_hash(hash, msg, i);
+		scrypt_hash_update(&st, hash, sizeof(hash));
+	}
+	scrypt_hash_finish(&st, final);
+	return scrypt_verify(final, scrypt_test_hash_expected, SCRYPT_HASH_DIGEST_SIZE);
+}
+