2295caef1671b51b64139f20b4c6de29d9da9ce0.patch

From 2295caef1671b51b64139f20b4c6de29d9da9ce0 Mon Sep 17 00:00:00 2001
From: cryptochangements34 <bevanoffr@gmail.com>
Date: Mon, 19 Mar 2018 17:02:15 -0400
Subject: [PATCH] use CryptonightV2 PoW for version 5

---
 src/crypto/chacha8.h                             |  5 +-
 src/crypto/hash-ops.h                            |  3 +-
 src/crypto/hash.h                                |  5 +-
 src/crypto/slow-hash.c                           | 94 ++++++++++++++++++++++--
 src/cryptonote_basic/cryptonote_format_utils.cpp |  3 +-
 tests/hash/CMakeLists.txt                        |  2 +-
 tests/hash/main.cpp                              | 13 +++-
 tests/hash/tests-slow-1.txt                      |  6 ++
 8 files changed, 114 insertions(+), 17 deletions(-)
 create mode 100644 tests/hash/tests-slow-1.txt

diff --git a/src/crypto/chacha8.h b/src/crypto/chacha8.h
index 26e3641..d3d0b72 100644
--- a/src/crypto/chacha8.h
+++ b/src/crypto/chacha8.h
@@ -71,10 +71,10 @@ namespace crypto {
     chacha8(data, length, reinterpret_cast<const uint8_t*>(&key), reinterpret_cast<const uint8_t*>(&iv), cipher);
   }
 
-  inline void generate_chacha8_key(const void *data, size_t size, chacha8_key& key) {
+  inline void generate_chacha8_key(const void *data, size_t size, chacha8_key& key, int cn_variant = 0) {
     static_assert(sizeof(chacha8_key) <= sizeof(hash), "Size of hash must be at least that of chacha8_key");
     char pwd_hash[HASH_SIZE];
-    crypto::cn_slow_hash(data, size, pwd_hash);
+    crypto::cn_slow_hash(data, size, pwd_hash, cn_variant);
     memcpy(&key, pwd_hash, sizeof(key));
     memset(pwd_hash, 0, sizeof(pwd_hash));
   }
@@ -85,3 +85,4 @@ namespace crypto {
 }
 
 #endif
+
diff --git a/src/crypto/hash-ops.h b/src/crypto/hash-ops.h
index 6ec49a2..8327e61 100644
--- a/src/crypto/hash-ops.h
+++ b/src/crypto/hash-ops.h
@@ -80,7 +80,7 @@ enum {
 };
 
 void cn_fast_hash(const void *data, size_t length, char *hash);
-void cn_slow_hash(const void *data, size_t length, char *hash);
+void cn_slow_hash(const void *data, size_t length, char *hash, int variant);
 
 void hash_extra_blake(const void *data, size_t length, char *hash);
 void hash_extra_groestl(const void *data, size_t length, char *hash);
@@ -88,3 +88,4 @@ void hash_extra_jh(const void *data, size_t length, char *hash);
 void hash_extra_skein(const void *data, size_t length, char *hash);
 
 void tree_hash(const char (*hashes)[HASH_SIZE], size_t count, char *root_hash);
+
diff --git a/src/crypto/hash.h b/src/crypto/hash.h
index b8636ef..2a0bce4 100644
--- a/src/crypto/hash.h
+++ b/src/crypto/hash.h
@@ -68,8 +68,8 @@ namespace crypto {
     return h;
   }
 
-  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash) {
-    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash));
+  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0) {
+    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant);
   }
 
   inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
@@ -80,3 +80,4 @@ namespace crypto {
 
 CRYPTO_MAKE_HASHABLE(hash)
 CRYPTO_MAKE_COMPARABLE(hash8)
+
diff --git a/src/crypto/slow-hash.c b/src/crypto/slow-hash.c
index 846185a..0dfd957 100644
--- a/src/crypto/slow-hash.c
+++ b/src/crypto/slow-hash.c
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018, The Masari Project
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 //
 // All rights reserved.
 //
@@ -33,6 +33,8 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+#include <stdio.h>
+#include <unistd.h>
 
 #include "common/int-util.h"
 #include "hash-ops.h"
@@ -49,6 +51,48 @@ extern int aesb_single_round(const uint8_t *in, uint8_t*out, const uint8_t *expa
 extern int aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *expandedKey);
 
 #if defined(__x86_64__) || (defined(_MSC_VER) && defined(_WIN64))
+#endif
+#define VARIANT1_1(p) \
+  do if (variant > 0) \
+  { \
+    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 > 0) \
+  { \
+    xor64(p, tweak1_2); \
+  } while(0)
+
+#define VARIANT1_CHECK() \
+  do if (length < 43) \
+  { \
+    fprintf(stderr, "Cryptonight variants need at least 43 bytes of data"); \
+    _exit(1); \
+  } while(0)
+
+#define NONCE_POINTER (((const uint8_t*)data)+35)
+
+#define VARIANT1_PORTABLE_INIT() \
+  uint8_t tweak1_2[8]; \
+  do if (variant > 0) \
+  { \
+    VARIANT1_CHECK(); \
+    memcpy(&tweak1_2, &state.hs.b[192], sizeof(tweak1_2)); \
+    xor64(tweak1_2, NONCE_POINTER); \
+  } while(0)
+
+#define VARIANT1_INIT64() \
+  if (variant > 0) \
+  { \
+    VARIANT1_CHECK(); \
+  } \
+  const uint64_t tweak1_2 = variant > 0 ? (state.hs.w[24] ^ (*((const uint64_t*)NONCE_POINTER))) : 0
+
+#if !defined NO_AES && (defined(__x86_64__) || (defined(_MSC_VER) && defined(_WIN64)))
 // Optimised code below, uses x86-specific intrinsics, SSE2, AES-NI
 // Fall back to more portable code is down at the bottom
 
@@ -126,6 +170,7 @@ extern int aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *exp
   _mm_store_si128(R128(c), _c); \
   _b = _mm_xor_si128(_b, _c); \
   _mm_store_si128(R128(&hp_state[j]), _b); \
+  VARIANT1_1(&hp_state[j]); \
   j = state_index(c); \
   p = U64(&hp_state[j]); \
   b[0] = p[0]; b[1] = p[1]; \
@@ -134,6 +179,7 @@ extern int aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *exp
   p = U64(&hp_state[j]); \
   p[0] = a[0];  p[1] = a[1]; \
   a[0] ^= b[0]; a[1] ^= b[1]; \
+  VARIANT1_2(p + 1); \
   _b = _c; \
 
 #if defined(_MSC_VER)
@@ -184,6 +230,11 @@ STATIC INLINE void xor_blocks(uint8_t *a, const uint8_t *b)
     U64(a)[1] ^= U64(b)[1];
 }
 
+STATIC INLINE void xor64(uint64_t *a, const uint64_t b)
+{
+    *a ^= b;
+}
+
 /**
  * @brief uses cpuid to determine if the CPU supports the AES instructions
  * @return true if the CPU supports AES, false otherwise
@@ -517,7 +568,7 @@ void slow_hash_free_state(void)
  * @param hash a pointer to a buffer in which the final 256 bit hash will be stored
  */
 
-void cn_slow_hash(const void *data, size_t length, char *hash)
+void cn_slow_hash(const void *data, size_t length, char *hash, int variant)
 {
     RDATA_ALIGN16 uint8_t expandedKey[240];  /* These buffers are aligned to use later with SSE functions */
 
@@ -544,10 +595,12 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
         slow_hash_allocate_state();
 
     /* CryptoNight Step 1:  Use Keccak1600 to initialize the 'state' (and 'text') buffers from the data. */
-
+    
     hash_process(&state.hs, data, length);
     memcpy(text, state.init, INIT_SIZE_BYTE);
 
+    VARIANT1_INIT64();
+
     /* CryptoNight Step 2:  Iteratively encrypt the results from Keccak to fill
      * the 2MB large random access buffer.
      */
@@ -646,7 +699,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
     extra_hashes[state.hs.b[0] & 3](&state, 200, hash);
 }
 
-#elif defined(__arm__) || defined(__aarch64__)
+#elif !defined NO_AES && (defined(__arm__) || defined(__aarch64__))
 void slow_hash_allocate_state(void)
 {
   // Do nothing, this is just to maintain compatibility with the upgraded slow-hash.c
@@ -671,6 +724,11 @@ void slow_hash_free_state(void)
 
 #define U64(x) ((uint64_t *) (x))
 
+STATIC INLINE void xor64(uint64_t *a, const uint64_t b)
+{
+    *a ^= b;
+}
+
 #pragma pack(push, 1)
 union cn_slow_hash_state
 {
@@ -707,6 +765,7 @@ union cn_slow_hash_state
   vst1q_u8((uint8_t *)c, _c); \
   _b = veorq_u8(_b, _c); \
   vst1q_u8(&hp_state[j], _b); \
+  VARIANT1_1(&hp_state[j]); \
   j = state_index(c); \
   p = U64(&hp_state[j]); \
   b[0] = p[0]; b[1] = p[1]; \
@@ -715,6 +774,7 @@ union cn_slow_hash_state
   p = U64(&hp_state[j]); \
   p[0] = a[0];  p[1] = a[1]; \
   a[0] ^= b[0]; a[1] ^= b[1]; \
+  VARIANT1_2(p + 1); \
   _b = _c; \
 
 
@@ -846,7 +906,7 @@ STATIC INLINE void aes_pseudo_round_xor(const uint8_t *in, uint8_t *out, const u
 	}
 }
 
-void cn_slow_hash(const void *data, size_t length, char *hash)
+void cn_slow_hash(const void *data, size_t length, char *hash, int variant)
 {
     RDATA_ALIGN16 uint8_t expandedKey[240];
     RDATA_ALIGN16 uint8_t hp_state[MEMORY];
@@ -872,6 +932,8 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
     hash_process(&state.hs, data, length);
     memcpy(text, state.init, INIT_SIZE_BYTE);
 
+    VARIANT1_INIT64();
+
     /* CryptoNight Step 2:  Iteratively encrypt the results from Keccak to fill
      * the 2MB large random access buffer.
      */
@@ -1040,7 +1102,7 @@ STATIC INLINE void xor_blocks(uint8_t* a, const uint8_t* b)
   U64(a)[1] ^= U64(b)[1];
 }
 
-void cn_slow_hash(const void *data, size_t length, char *hash)
+void cn_slow_hash(const void *data, size_t length, char *hash, int variant)
 {
     uint8_t text[INIT_SIZE_BYTE];
     uint8_t a[AES_BLOCK_SIZE];
@@ -1069,6 +1131,8 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
     hash_process(&state.hs, data, length);
     memcpy(text, state.init, INIT_SIZE_BYTE);
 
+    VARIANT1_INIT64();
+
     aes_ctx = (oaes_ctx *) oaes_alloc();
     oaes_key_import_data(aes_ctx, state.hs.b, AES_KEY_SIZE);
 
@@ -1098,6 +1162,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
       xor_blocks(b, p);
       swap_blocks(b, p);
       swap_blocks(a, b);
+      VARIANT1_1(p);
 
       // Iteration 2
       p = &long_state[state_index(a)];
@@ -1107,6 +1172,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
       swap_blocks(b, p);
       xor_blocks(b, p);
       swap_blocks(a, b);
+      VARIANT1_2(U64(p) + 1);
     }
 
     memcpy(text, state.init, INIT_SIZE_BYTE);
@@ -1201,6 +1267,15 @@ static void xor_blocks(uint8_t* a, const uint8_t* b) {
   }
 }
 
+static void xor64(uint8_t* left, const uint8_t* right)
+{
+  size_t i;
+  for (i = 0; i < 8; ++i)
+  {
+    left[i] ^= right[i];
+  }
+}
+
 #pragma pack(push, 1)
 union cn_slow_hash_state {
   union hash_state hs;
@@ -1211,7 +1286,7 @@ union cn_slow_hash_state {
 };
 #pragma pack(pop)
 
-void cn_slow_hash(const void *data, size_t length, char *hash) {
+void cn_slow_hash(const void *data, size_t length, char *hash, int variant) {
   uint8_t long_state[MEMORY];
   union cn_slow_hash_state state;
   uint8_t text[INIT_SIZE_BYTE];
@@ -1228,6 +1303,8 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
   memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
   aes_ctx = (oaes_ctx *) oaes_alloc();
 
+  VARIANT1_PORTABLE_INIT();
+
   oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
   for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
     for (j = 0; j < INIT_SIZE_BLK; j++) {
@@ -1255,6 +1332,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
     copy_block(&long_state[j * AES_BLOCK_SIZE], c);
     assert(j == e2i(a, MEMORY / AES_BLOCK_SIZE));
     swap_blocks(a, b);
+    VARIANT1_1(&long_state[j * AES_BLOCK_SIZE]);
     /* Iteration 2 */
     j = e2i(a, MEMORY / AES_BLOCK_SIZE);
     copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
@@ -1262,6 +1340,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
     sum_half_blocks(b, d);
     swap_blocks(b, c);
     xor_blocks(b, c);
+    VARIANT1_2(c + 8);
     copy_block(&long_state[j * AES_BLOCK_SIZE], c);
     assert(j == e2i(a, MEMORY / AES_BLOCK_SIZE));
     swap_blocks(a, b);
@@ -1283,3 +1362,4 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
 }
 
 #endif
+
diff --git a/src/cryptonote_basic/cryptonote_format_utils.cpp b/src/cryptonote_basic/cryptonote_format_utils.cpp
index 6bc1184..615e36b 100644
--- a/src/cryptonote_basic/cryptonote_format_utils.cpp
+++ b/src/cryptonote_basic/cryptonote_format_utils.cpp
@@ -665,7 +665,8 @@ namespace cryptonote
   bool get_block_longhash(const block& b, crypto::hash& res, uint64_t height)
   {
     blobdata bd = get_block_hashing_blob(b);
-    crypto::cn_slow_hash(bd.data(), bd.size(), res);
+    const int variant = b.major_version >= 5 ? b.major_version -4 : 0;
+    crypto::cn_slow_hash(bd.data(), bd.size(), res, variant);
     return true;
   }
   //---------------------------------------------------------------
diff --git a/tests/hash/CMakeLists.txt b/tests/hash/CMakeLists.txt
index e7519d4..f7f59b2 100644
--- a/tests/hash/CMakeLists.txt
+++ b/tests/hash/CMakeLists.txt
@@ -43,7 +43,7 @@ set_property(TARGET hash-tests
   PROPERTY
     FOLDER "tests")
 
-foreach (hash IN ITEMS fast slow tree extra-blake extra-groestl extra-jh extra-skein)
+foreach (hash IN ITEMS fast slow slow-1 tree extra-blake extra-groestl extra-jh extra-skein)
   add_test(
     NAME    "hash-${hash}"
     COMMAND hash-tests "${hash}" "${CMAKE_CURRENT_SOURCE_DIR}/tests-${hash}.txt")
diff --git a/tests/hash/main.cpp b/tests/hash/main.cpp
index 32d608f..cab1905 100644
--- a/tests/hash/main.cpp
+++ b/tests/hash/main.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018, The Masari Project
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 //
 // All rights reserved.
 //
@@ -52,6 +52,12 @@ extern "C" {
     }
     tree_hash((const char (*)[32]) data, length >> 5, hash);
   }
+  static void cn_slow_hash_0(const void *data, size_t length, char *hash) {
+    return cn_slow_hash(data, length, hash, 0);
+  }
+  static void cn_slow_hash_1(const void *data, size_t length, char *hash) {
+    return cn_slow_hash(data, length, hash, 1);
+  }
 }
 POP_WARNINGS
 
@@ -59,9 +65,10 @@ extern "C" typedef void hash_f(const void *, size_t, char *);
 struct hash_func {
   const string name;
   hash_f &f;
-} hashes[] = {{"fast", cn_fast_hash}, {"slow", cn_slow_hash}, {"tree", hash_tree},
+} hashes[] = {{"fast", cn_fast_hash}, {"slow", cn_slow_hash_0}, {"tree", hash_tree},
   {"extra-blake", hash_extra_blake}, {"extra-groestl", hash_extra_groestl},
-  {"extra-jh", hash_extra_jh}, {"extra-skein", hash_extra_skein}};
+  {"extra-jh", hash_extra_jh}, {"extra-skein", hash_extra_skein},
+  {"slow-1", cn_slow_hash_1}};
 
 int main(int argc, char *argv[]) {
   hash_f *f;
diff --git a/tests/hash/tests-slow-1.txt b/tests/hash/tests-slow-1.txt
new file mode 100644
index 0000000..60faf7d
--- /dev/null
+++ b/tests/hash/tests-slow-1.txt
@@ -0,0 +1,6 @@
+b46aab7facce3eb4b4679d1d526f2d500d43736988b7881853c4c0c4af04ac0e 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+f0f0ab8a50a809ccd82c76996e494b20a1e01e90ed4814a27db2558511559091 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+13310922971e1112b382357aeaa8b0bf0cd941dc6f5e398979f3fa77d13749bd 8519e039172b0d70e5ca7b3383d6b3167315a422747b73f019cf9528f0fde341fd0f2a63030ba6450525cf6de31837669af6f1df8131faf50aaab8d3a7405589
+0d9f641d14a782748ed5548f72a20c83c4a2cfe606015ad9eda5b36a00947d72 37a636d7dafdf259b7287eddca2f58099e98619d2f99bdb8969d7b14498102cc065201c8be90bd777323f449848b215d2977c92c4c1c2da36ab46b2e389689ed97c18fec08cd3b03235c5e4c62a37ad88c7b67932495a71090e85dd4020a9300
+d74a0c9b603aa9f9af0bfec0c36d3d383c14930a0ee2f08dab44536fccda5bee 38274c97c45a172cfc97679870422e3a1ab0784960c60514d816271415c306ee3a3ed1a77e31f6a885c3cb
+