src/uint256.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_UINT256_H
   7 #define BITCOIN_UINT256_H
   8
   9 #include <assert.h>
  10 #include <cstring>
  11 #include <stdexcept>
  12 #include <stdint.h>
  13 #include <string>
  14 #include <vector>
  15 #include "crypto/common.h"
  16
  17 /** Template base class for fixed-sized opaque blobs. */
  18 template<unsigned int BITS>
  19 class base_blob
  20 {
  21 protected:
  22     enum { WIDTH=BITS/8 };
  23     uint8_t data[WIDTH];
  24 public:
  25     base_blob()
  26     {
  27         memset(data, 0, sizeof(data));
  28     }
  29
  30     explicit base_blob(const std::vector<unsigned char>& vch);
  31
  32     bool IsNull() const
  33     {
  34         for (int i = 0; i < WIDTH; i++)
  35             if (data[i] != 0)
  36                 return false;
  37         return true;
  38     }
  39
  40     void SetNull()
  41     {
  42         memset(data, 0, sizeof(data));
  43     }
  44
  45     inline int Compare(const base_blob& other) const { return memcmp(data, other.data, sizeof(data)); }
  46
  47     friend inline bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
  48     friend inline bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
  49     friend inline bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; }
  50
  51     std::string GetHex() const;
  52     void SetHex(const char* psz);
  53     void SetHex(const std::string& str);
  54     std::string ToString() const;
  55
  56     unsigned char* begin()
  57     {
  58         return &data[0];
  59     }
  60
  61     unsigned char* end()
  62     {
  63         return &data[WIDTH];
  64     }
  65
  66     const unsigned char* begin() const
  67     {
  68         return &data[0];
  69     }
  70
  71     const unsigned char* end() const
  72     {
  73         return &data[WIDTH];
  74     }
  75
  76     unsigned int size() const
  77     {
  78         return sizeof(data);
  79     }
  80
  81     uint64_t GetUint64(int pos) const
  82     {
  83         const uint8_t* ptr = data + pos * 8;
  84         return ((uint64_t)ptr[0]) | \
  85                ((uint64_t)ptr[1]) << 8 | \
  86                ((uint64_t)ptr[2]) << 16 | \
  87                ((uint64_t)ptr[3]) << 24 | \
  88                ((uint64_t)ptr[4]) << 32 | \
  89                ((uint64_t)ptr[5]) << 40 | \
  90                ((uint64_t)ptr[6]) << 48 | \
  91                ((uint64_t)ptr[7]) << 56;
  92     }
  93
  94     template<typename Stream>
  95     void Serialize(Stream& s) const
  96     {
  97         s.write((char*)data, sizeof(data));
  98     }
  99
 100     template<typename Stream>
 101     void Unserialize(Stream& s)
 102     {
 103         s.read((char*)data, sizeof(data));
 104     }
 105 };
 106
 107 /** 160-bit opaque blob.
 108  * @note This type is called uint160 for historical reasons only. It is an opaque
 109  * blob of 160 bits and has no integer operations.
 110  */
 111 class uint160 : public base_blob<160> {
 112 public:
 113     uint160() {}
 114     explicit uint160(const base_blob<160>& b) : base_blob<160>(b) {}
 115     explicit uint160(const std::vector<unsigned char>& vch) : base_blob<160>(vch) {}
 116 };
 117
 118 /** 256-bit opaque blob.
 119  * @note This type is called uint256 for historical reasons only. It is an
 120  * opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
 121  * those are required.
 122  */
 123 class uint256 : public base_blob<256> {
 124 public:
 125     uint256() {}
 126     explicit uint256(const base_blob<256>& b) : base_blob<256>(b) {}
 127     explicit uint256(const std::vector<unsigned char>& vch) : base_blob<256>(vch) {}
 128
 129     /** A cheap hash function that just returns 64 bits from the result, it can be
 130      * used when the contents are considered uniformly random. It is not appropriate
 131      * when the value can easily be influenced from outside as e.g. a network adversary could
 132      * provide values to trigger worst-case behavior.
 133      */
 134     uint64_t GetCheapHash() const
 135     {
 136         return ReadLE64(data);
 137     }
 138 };
 139
 140 /* uint256 from const char *.
 141  * This is a separate function because the constructor uint256(const char*) can result
 142  * in dangerously catching uint256(0).
 143  */
 144 inline uint256 uint256S(const char *str)
 145 {
 146     uint256 rv;
 147     rv.SetHex(str);
 148     return rv;
 149 }
 150 /* uint256 from std::string.
 151  * This is a separate function because the constructor uint256(const std::string &str) can result
 152  * in dangerously catching uint256(0) via std::string(const char*).
 153  */
 154 inline uint256 uint256S(const std::string& str)
 155 {
 156     uint256 rv;
 157     rv.SetHex(str);
 158     return rv;
 159 }
 160
 161 #endif // BITCOIN_UINT256_H