Initial hefty1 support

Author: lucasjones

Diff for: binding.gyp

@@ -16,6 +16,8 @@
                 "blake.c",
                 "fugue.c",
                 "qubit.c",
+                "hefty1.c",
+                "sha3/sph_hefty1.c",
                 "sha3/sph_fugue.c",
                 "sha3/aes_helper.c",
                 "sha3/sph_blake.c",

Diff for: hefty1.c

@@ -0,0 +1,67 @@
+#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 = (char*) malloc(32);
+    char* hash32_2 = (char*) malloc(32);
+    char* hash64_3 = (char*) malloc(64);
+    char* hash64_4 = (char*) malloc(64);
+    char* hash64_5 = (char*) malloc(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;
+    
+    for(i = 0; i < 64; i++) {
+        for(j = 0; j < 4; j++) {
+            if((*(hash[j] + i) & 0x80) != 0)
+                output[((i * 4 + j) - (i * 4 + j) % 8) / 8] |= 1 << (i * 4 + j) % 8;
+        }
+    }
+    
+    free(hash32_1);
+    free(hash32_2);
+    free(hash64_3);
+    free(hash64_4);
+    free(hash64_5);
+}
+

Diff for: 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

Diff for: multihashing.cc

@@ -16,6 +16,7 @@ extern "C" {
     #include "blake.h"
     #include "fugue.h"
     #include "qubit.h"
+    #include "hefty1.h"
 }
 
 using namespace node;
@@ -336,6 +337,29 @@ Handle<Value> qubit(const Arguments& args) {
     return scope.Close(buff->handle_);
 }
 
+
+Handle<Value> hefty1(const Arguments& args) {
+    HandleScope scope;
+
+    if (args.Length() < 1)
+        return except("You must provide one argument.");
+
+    Local<Object> target = args[0]->ToObject();
+
+    if(!Buffer::HasInstance(target))
+        return except("Argument should be a buffer object.");
+
+    char * input = Buffer::Data(target);
+    char * output = new char[32];
+    
+    uint32_t input_len = Buffer::Length(target);
+
+    hefty1_hash(input, output, input_len);
+
+    Buffer* buff = Buffer::New(output, 32);
+    return scope.Close(buff->handle_);
+}
+
 void init(Handle<Object> exports) {
     exports->Set(String::NewSymbol("quark"), FunctionTemplate::New(quark)->GetFunction());
     exports->Set(String::NewSymbol("x11"), FunctionTemplate::New(x11)->GetFunction());
@@ -350,6 +374,7 @@ void init(Handle<Object> exports) {
     exports->Set(String::NewSymbol("blake"), FunctionTemplate::New(blake)->GetFunction());
     exports->Set(String::NewSymbol("fugue"), FunctionTemplate::New(fugue)->GetFunction());
     exports->Set(String::NewSymbol("qubit"), FunctionTemplate::New(qubit)->GetFunction());
+    exports->Set(String::NewSymbol("hefty1"), FunctionTemplate::New(hefty1)->GetFunction());
 }
 
 NODE_MODULE(multihashing, init)

Diff for: qubit.c

@@ -19,7 +19,7 @@ void qubit_hash(const char* input, char* output, uint32_t len)
 
     sph_luffa512_init(&ctx_luffa);
     sph_luffa512(&ctx_luffa, (const void*) input, len);
-    sph_luffa512_close(&ctx_luffa, (void*) hash1); //1
+    sph_luffa512_close(&ctx_luffa, (void*) hash1); // 1
 
     sph_cubehash512_init(&ctx_cubehash);
     sph_cubehash512(&ctx_cubehash, (const void*) hash1, 64); // 1