src/pubkey.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 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_PUBKEY_H
   7 #define BITCOIN_PUBKEY_H
   8
   9 #include "hash.h"
  10 #include "serialize.h"
  11 #include "uint256.h"
  12
  13 #include <stdexcept>
  14 #include <vector>
  15
  16 /**
  17  * secp256k1:
  18  * const unsigned int PRIVATE_KEY_SIZE = 279;
  19  * const unsigned int PUBLIC_KEY_SIZE  = 65;
  20  * const unsigned int SIGNATURE_SIZE   = 72;
  21  *
  22  * see www.keylength.com
  23  * script supports up to 75 for single byte push
  24  */
  25
  26 /** A reference to a CKey: the Hash160 of its serialized public key */
  27 class CKeyID : public uint160
  28 {
  29 public:
  30     CKeyID() : uint160() {}
  31     CKeyID(const uint160& in) : uint160(in) {}
  32 };
  33
  34 /** An encapsulated public key. */
  35 class CPubKey
  36 {
  37 private:
  38
  39     /**
  40      * Just store the serialized data.
  41      * Its length can very cheaply be computed from the first byte.
  42      */
  43     unsigned char vch[65];
  44
  45     //! Compute the length of a pubkey with a given first byte.
  46     unsigned int static GetLen(unsigned char chHeader)
  47     {
  48         if (chHeader == 2 || chHeader == 3)
  49             return 33;
  50         if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  51             return 65;
  52         return 0;
  53     }
  54
  55     //! Set this key data to be invalid
  56     void Invalidate()
  57     {
  58         vch[0] = 0xFF;
  59     }
  60
  61 public:
  62     //! Construct an invalid public key.
  63     CPubKey()
  64     {
  65         Invalidate();
  66     }
  67
  68     //! Initialize a public key using begin/end iterators to byte data.
  69     template <typename T>
  70     void Set(const T pbegin, const T pend)
  71     {
  72         int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  73         if (len && len == (pend - pbegin))
  74             memcpy(vch, (unsigned char*)&pbegin[0], len);
  75         else
  76             Invalidate();
  77     }
  78
  79     //! Construct a public key using begin/end iterators to byte data.
  80     template <typename T>
  81     CPubKey(const T pbegin, const T pend)
  82     {
  83         Set(pbegin, pend);
  84     }
  85
  86     //! Construct a public key from a byte vector.
  87     CPubKey(const std::vector<unsigned char>& vch)
  88     {
  89         Set(vch.begin(), vch.end());
  90     }
  91
  92     //! Simple read-only vector-like interface to the pubkey data.
  93     unsigned int size() const { return GetLen(vch[0]); }
  94     const unsigned char* begin() const { return vch; }
  95     const unsigned char* end() const { return vch + size(); }
  96     const unsigned char& operator[](unsigned int pos) const { return vch[pos]; }
  97
  98     //! Comparator implementation.
  99     friend bool operator==(const CPubKey& a, const CPubKey& b)
 100     {
 101         return a.vch[0] == b.vch[0] &&
 102                memcmp(a.vch, b.vch, a.size()) == 0;
 103     }
 104     friend bool operator!=(const CPubKey& a, const CPubKey& b)
 105     {
 106         return !(a == b);
 107     }
 108     friend bool operator<(const CPubKey& a, const CPubKey& b)
 109     {
 110         return a.vch[0] < b.vch[0] ||
 111                (a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) < 0);
 112     }
 113
 114     //! Implement serialization, as if this was a byte vector.
 115     unsigned int GetSerializeSize(int nType, int nVersion) const
 116     {
 117         return size() + 1;
 118     }
 119     template <typename Stream>
 120     void Serialize(Stream& s, int nType, int nVersion) const
 121     {
 122         unsigned int len = size();
 123         ::WriteCompactSize(s, len);
 124         s.write((char*)vch, len);
 125     }
 126     template <typename Stream>
 127     void Unserialize(Stream& s, int nType, int nVersion)
 128     {
 129         unsigned int len = ::ReadCompactSize(s);
 130         if (len <= 65) {
 131             s.read((char*)vch, len);
 132         } else {
 133             // invalid pubkey, skip available data
 134             char dummy;
 135             while (len--)
 136                 s.read(&dummy, 1);
 137             Invalidate();
 138         }
 139     }
 140
 141     //! Get the KeyID of this public key (hash of its serialization)
 142     CKeyID GetID() const
 143     {
 144         return CKeyID(Hash160(vch, vch + size()));
 145     }
 146
 147     //! Get the 256-bit hash of this public key.
 148     uint256 GetHash() const
 149     {
 150         return Hash(vch, vch + size());
 151     }
 152
 153     /*
 154      * Check syntactic correctness.
 155      *
 156      * Note that this is consensus critical as CheckSig() calls it!
 157      */
 158     bool IsValid() const
 159     {
 160         return size() > 0;
 161     }
 162
 163     //! fully validate whether this is a valid public key (more expensive than IsValid())
 164     bool IsFullyValid() const;
 165
 166     //! Check whether this is a compressed public key.
 167     bool IsCompressed() const
 168     {
 169         return size() == 33;
 170     }
 171
 172     /**
 173      * Verify a DER signature (~72 bytes).
 174      * If this public key is not fully valid, the return value will be false.
 175      */
 176     bool Verify(const uint256& hash, const std::vector<unsigned char>& vchSig) const;
 177
 178     //! Recover a public key from a compact signature.
 179     bool RecoverCompact(const uint256& hash, const std::vector<unsigned char>& vchSig);
 180
 181     //! Turn this public key into an uncompressed public key.
 182     bool Decompress();
 183
 184     //! Derive BIP32 child pubkey.
 185     bool Derive(CPubKey& pubkeyChild, unsigned char ccChild[32], unsigned int nChild, const unsigned char cc[32]) const;
 186 };
 187
 188 struct CExtPubKey {
 189     unsigned char nDepth;
 190     unsigned char vchFingerprint[4];
 191     unsigned int nChild;
 192     unsigned char vchChainCode[32];
 193     CPubKey pubkey;
 194
 195     friend bool operator==(const CExtPubKey& a, const CExtPubKey& b)
 196     {
 197         return a.nDepth == b.nDepth && memcmp(&a.vchFingerprint[0], &b.vchFingerprint[0], 4) == 0 && a.nChild == b.nChild &&
 198                memcmp(&a.vchChainCode[0], &b.vchChainCode[0], 32) == 0 && a.pubkey == b.pubkey;
 199     }
 200
 201     void Encode(unsigned char code[74]) const;
 202     void Decode(const unsigned char code[74]);
 203     bool Derive(CExtPubKey& out, unsigned int nChild) const;
 204 };
 205
 206 #endif // BITCOIN_PUBKEY_H