Added hash code

binding.gyp

@@ -6,6 +6,8 @@
                 "src/main.cc",
                 "src/cryptonote_core/cryptonote_format_utils.cpp",
                 "src/crypto/tree-hash.c",
+                "src/crypto/hash.c",
+                "src/crypto/keccak.c",
                 "src/common/base58.cpp",
             ],
             "include_dirs": [

src/crypto/hash.c

@@ -0,0 +1,24 @@
+// 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.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "hash-ops.h"
+#include "keccak.h"
+
+void hash_permutation(union hash_state *state) {
+  keccakf((uint64_t*)state, 24);
+}
+
+void hash_process(union hash_state *state, const uint8_t *buf, size_t count) {
+  keccak1600(buf, count, (uint8_t*)state);
+}
+
+void cn_fast_hash(const void *data, size_t length, char *hash) {
+  union hash_state state;
+  hash_process(&state, data, length);
+  memcpy(hash, &state, HASH_SIZE);
+}

src/crypto/keccak.c

@@ -0,0 +1,112 @@
+// keccak.c
+// 19-Nov-11  Markku-Juhani O. Saarinen <mjos@iki.fi>
+// A baseline Keccak (3rd round) implementation.
+
+#include "hash-ops.h"
+#include "keccak.h"
+
+const uint64_t keccakf_rndc[24] = 
+{
+    0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+    0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+    0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+    0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+    0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+    0x8000000000008003, 0x8000000000008002, 0x8000000000000080, 
+    0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+    0x8000000000008080, 0x0000000080000001, 0x8000000080008008
+};
+
+const int keccakf_rotc[24] = 
+{
+    1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14, 
+    27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
+};
+
+const int keccakf_piln[24] = 
+{
+    10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4, 
+    15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1 
+};
+
+// update the state with given number of rounds
+
+void keccakf(uint64_t st[25], int rounds)
+{
+    int i, j, round;
+    uint64_t t, bc[5];
+
+    for (round = 0; round < rounds; round++) {
+
+        // Theta
+        for (i = 0; i < 5; i++)     
+            bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20];
+
+        for (i = 0; i < 5; i++) {
+            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1);
+            for (j = 0; j < 25; j += 5)
+                st[j + i] ^= t;
+        }
+
+        // Rho Pi
+        t = st[1];
+        for (i = 0; i < 24; i++) {
+            j = keccakf_piln[i];
+            bc[0] = st[j];
+            st[j] = ROTL64(t, keccakf_rotc[i]);
+            t = bc[0];
+        }
+
+        //  Chi
+        for (j = 0; j < 25; j += 5) {
+            for (i = 0; i < 5; i++)
+                bc[i] = st[j + i];
+            for (i = 0; i < 5; i++)
+                st[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];
+        }
+
+        //  Iota
+        st[0] ^= keccakf_rndc[round];
+    }
+}
+
+// compute a keccak hash (md) of given byte length from "in"
+typedef uint64_t state_t[25];
+
+int keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen)
+{
+    state_t st;
+    uint8_t temp[144];
+    int i, rsiz, rsizw;
+
+    rsiz = sizeof(state_t) == mdlen ? HASH_DATA_AREA : 200 - 2 * mdlen;
+    rsizw = rsiz / 8;
+    
+    memset(st, 0, sizeof(st));
+
+    for ( ; inlen >= rsiz; inlen -= rsiz, in += rsiz) {
+        for (i = 0; i < rsizw; i++)
+            st[i] ^= ((uint64_t *) in)[i];
+        keccakf(st, KECCAK_ROUNDS);
+    }
+    
+    // last block and padding
+    memcpy(temp, in, inlen);
+    temp[inlen++] = 1;
+    memset(temp + inlen, 0, rsiz - inlen);
+    temp[rsiz - 1] |= 0x80;
+
+    for (i = 0; i < rsizw; i++)
+        st[i] ^= ((uint64_t *) temp)[i];
+
+    keccakf(st, KECCAK_ROUNDS);
+
+    memcpy(md, st, mdlen);
+
+    return 0;
+}
+
+void keccak1600(const uint8_t *in, int inlen, uint8_t *md)
+{
+    keccak(in, inlen, md, sizeof(state_t));
+}

src/cryptonote_config.h

@@ -2,7 +2,6 @@
 
 #define CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER          0
 #define CURRENT_TRANSACTION_VERSION                     1
-#define MAX_TRANSACTION_VERSION                         2
 #define CURRENT_BLOCK_MAJOR_VERSION                     1
 #define CURRENT_BLOCK_MINOR_VERSION                     0
 

src/cryptonote_core/cryptonote_basic.h

@@ -174,8 +174,8 @@ namespace cryptonote
 
     BEGIN_SERIALIZE()
       VARINT_FIELD(version)
-      //if(MAX_TRANSACTION_VERSION < version) {
-      //  printf("!!! Current tx version %zu exceeds %zu max", version, MAX_TRANSACTION_VERSION);
+      //if(8 < version) {
+      //  printf("!!! Current tx version %zu exceeds %u max", version, 8);
       //  return false;
       //}
       VARINT_FIELD(unlock_time)