Merge pull request PhearNet#5 from LucasJones/master

Add support for more hash algorithms

Author: zone117x

binding.gyp

@@ -14,6 +14,12 @@
                 "bcrypt.c",
                 "groestl.c",
                 "blake.c",
+                "fugue.c",
+                "qubit.c",
+                "hefty1.c",
+                "shavite3.c",
+                "sha3/sph_hefty1.c",
+                "sha3/sph_fugue.c",
                 "sha3/aes_helper.c",
                 "sha3/sph_blake.c",
                 "sha3/sph_bmw.c",

blake.c

@@ -7,7 +7,7 @@
 #include "sha3/sph_blake.h"
 
 
-void blake_hash(const char* input, char* output, unsigned int len)
+void blake_hash(const char* input, char* output, uint32_t len)
 {
     sph_blake256_context ctx_blake;
     sph_blake256_init(&ctx_blake);

blake.h

@@ -5,7 +5,9 @@
 extern "C" {
 #endif
 
-void blake_hash(const char* input, char* output, unsigned int len);
+#include <stdint.h>
+
+void blake_hash(const char* input, char* output, uint32_t len);
 
 #ifdef __cplusplus
 }

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);
+}
+

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

groestl.c

@@ -5,13 +5,36 @@
 #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 groestl_hash(const char* input, char* output, unsigned int len)
+void groestl_myriad_hash(const char* input, char* output, uint32_t len)
 {
-    sph_groestl256_context ctx_groestl;
-    sph_groestl256_init(&ctx_groestl);
-    sph_groestl256(&ctx_groestl, input, len);
-    sph_groestl256_close(&ctx_groestl, output);
+    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);
 }
 

groestl.h

@@ -5,7 +5,10 @@
 extern "C" {
 #endif
 
-void groestl_hash(const char* input, char* output, unsigned int len);
+#include <stdint.h>
+
+void groestl_hash(const char* input, char* output, uint32_t len);
+void groestl_myriad_hash(const char* input, char* output, uint32_t len);
 
 #ifdef __cplusplus
 }

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);
+        }
+    }
+}
+

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

keccak.c

@@ -1,14 +1,10 @@
 #include "keccak.h"
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
 
 #include "sha3/sph_types.h"
 #include "sha3/sph_keccak.h"
 
 
-void keccak_hash(const char* input, char* output, unsigned int size)
+void keccak_hash(const char* input, char* output, uint32_t size)
 {
     sph_keccak256_context ctx_keccak;
     sph_keccak256_init(&ctx_keccak);