cryptonote-raw-crypto 0.5.1

Cryptography Primitives for Cryptonote
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// Copyright (c) 2011-2016 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 <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <vector>

#include "util.h"
#include "types.h"
using std::uint64_t;

extern "C"
{

#if defined(__SIZEOF_INT128__)

  static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high)
  {
    typedef unsigned __int128 uint128_t;
    uint128_t res = (uint128_t)a * (uint128_t)b;
    low = (uint64_t)res;
    high = (uint64_t)(res >> 64);
  }

#else

  static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high)
  {
    low = mul128(a, b, &high);
  }

#endif

  static inline bool cadd(uint64_t a, uint64_t b)
  {
    return a + b < a;
  }

  static inline bool cadc(uint64_t a, uint64_t b, bool c)
  {
    return a + b < a || (c && a + b == (uint64_t)-1);
  }

  bool check_hash(const hash_t *hash, uint64_t difficulty)
  {
    uint64_t low, high, top, cur;
    // First check the highest word, this will most likely fail for a random hash.
    mul(swap64le(((const uint64_t *)hash)[3]), difficulty, top, high);
    if (high != 0)
    {
      return false;
    }
    mul(swap64le(((const uint64_t *)hash)[0]), difficulty, low, cur);
    mul(swap64le(((const uint64_t *)hash)[1]), difficulty, low, high);
    bool carry = cadd(cur, low);
    cur = high;
    mul(swap64le(((const uint64_t *)hash)[2]), difficulty, low, high);
    carry = cadc(cur, low, carry);
    carry = cadc(high, top, carry);
    return !carry;
  }
}