src/key.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_KEY_H
   6 #define BITCOIN_KEY_H
   7
   8 #include <stdexcept>
   9 #include <vector>
  10
  11 #include "allocators.h"
  12 #include "serialize.h"
  13 #include "uint256.h"
  14 #include "hash.h"
  15 #include "bignum.h"
  16
  17 #include <openssl/ec.h> // for EC_KEY definition
  18 #include <openssl/obj_mac.h>
  19
  20 // secp160k1
  21 // const unsigned int PRIVATE_KEY_SIZE = 192;
  22 // const unsigned int PUBLIC_KEY_SIZE  = 41;
  23 // const unsigned int SIGNATURE_SIZE   = 48;
  24 //
  25 // secp192k1
  26 // const unsigned int PRIVATE_KEY_SIZE = 222;
  27 // const unsigned int PUBLIC_KEY_SIZE  = 49;
  28 // const unsigned int SIGNATURE_SIZE   = 57;
  29 //
  30 // secp224k1
  31 // const unsigned int PRIVATE_KEY_SIZE = 250;
  32 // const unsigned int PUBLIC_KEY_SIZE  = 57;
  33 // const unsigned int SIGNATURE_SIZE   = 66;
  34 //
  35 // secp256k1:
  36 // const unsigned int PRIVATE_KEY_SIZE = 279;
  37 // const unsigned int PUBLIC_KEY_SIZE  = 65;
  38 // const unsigned int SIGNATURE_SIZE   = 72;
  39 //
  40 // see www.keylength.com
  41 // script supports up to 75 for single byte push
  42
  43 class key_error : public std::runtime_error
  44 {
  45 public:
  46     explicit key_error(const std::string& str) : std::runtime_error(str) {}
  47 };
  48
  49 /** A reference to a CKey: the Hash160 of its serialized public key */
  50 class CKeyID : public uint160
  51 {
  52 public:
  53     CKeyID() : uint160(0) { }
  54     CKeyID(const uint160 &in) : uint160(in) { }
  55 };
  56
  57 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
  58 class CScriptID : public uint160
  59 {
  60 public:
  61     CScriptID() : uint160(0) { }
  62     CScriptID(const uint160 &in) : uint160(in) { }
  63 };
  64
  65 /** An encapsulated OpenSSL Elliptic Curve key (public) */
  66 class CPubKey
  67 {
  68 private:
  69
  70     /**
  71      * Just store the serialized data.
  72      * Its length can very cheaply be computed from the first byte.
  73      */
  74     unsigned char vbytes[65];
  75
  76     //! Compute the length of a pubkey with a given first byte.
  77     unsigned int static GetLen(unsigned char chHeader)
  78     {
  79         if (chHeader == 2 || chHeader == 3)
  80             return 33;
  81         if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  82             return 65;
  83         return 0;
  84     }
  85
  86     // Set this key data to be invalid
  87     void Invalidate()
  88     {
  89         vbytes[0] = 0xFF;
  90     }
  91
  92 public:
  93     // Construct an invalid public key.
  94     CPubKey()
  95     {
  96         Invalidate();
  97     }
  98
  99     // Initialize a public key using begin/end iterators to byte data.
 100     template <typename T>
 101     void Set(const T pbegin, const T pend)
 102     {
 103         int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
 104         if (len && len == (pend - pbegin))
 105             memcpy(vbytes, (unsigned char*)&pbegin[0], len);
 106         else
 107             Invalidate();
 108     }
 109
 110     void Set(const std::vector<unsigned char>& vch)
 111     {
 112         Set(vch.begin(), vch.end());
 113     }
 114
 115     template <typename T>
 116     CPubKey(const T pbegin, const T pend)
 117     {
 118         Set(pbegin, pend);
 119     }
 120
 121     CPubKey(const std::vector<unsigned char>& vch)
 122     {
 123         Set(vch.begin(), vch.end());
 124     }
 125
 126     // Read-only vector-like interface to the data.
 127     unsigned int size() const { return GetLen(vbytes[0]); }
 128     const unsigned char* begin() const { return vbytes; }
 129     const unsigned char* end() const { return vbytes + size(); }
 130     const unsigned char& operator[](unsigned int pos) const { return vbytes[pos]; }
 131
 132     friend bool operator==(const CPubKey& a, const CPubKey& b) { return a.vbytes[0] == b.vbytes[0] && memcmp(a.vbytes, b.vbytes, a.size()) == 0; }
 133     friend bool operator!=(const CPubKey& a, const CPubKey& b) { return !(a == b); }
 134     friend bool operator<(const CPubKey& a, const CPubKey& b)  { return a.vbytes[0] < b.vbytes[0] || (a.vbytes[0] == b.vbytes[0] && memcmp(a.vbytes, b.vbytes, a.size()) < 0); }
 135
 136     //! Implement serialization, as if this was a byte vector.
 137     unsigned int GetSerializeSize(int nType, int nVersion) const
 138     {
 139         return size() + 1;
 140     }
 141     template <typename Stream>
 142     void Serialize(Stream& s, int nType, int nVersion) const
 143     {
 144         unsigned int len = size();
 145         ::WriteCompactSize(s, len);
 146         s.write((char*)vbytes, len);
 147     }
 148     template <typename Stream>
 149     void Unserialize(Stream& s, int nType, int nVersion)
 150     {
 151         unsigned int len = ::ReadCompactSize(s);
 152         if (len <= 65) {
 153             s.read((char*)vbytes, len);
 154         } else {
 155             // invalid pubkey, skip available data
 156             char dummy;
 157             while (len--)
 158                 s.read(&dummy, 1);
 159             Invalidate();
 160         }
 161     }
 162
 163     CKeyID GetID() const
 164     {
 165         return CKeyID(Hash160(vbytes, vbytes + size()));
 166     }
 167
 168     uint256 GetHash() const
 169     {
 170         return Hash(vbytes, vbytes + size());
 171     }
 172
 173     /*
 174      * Check syntactic correctness.
 175      *
 176      * Note that this is consensus critical as CheckSig() calls it!
 177      */
 178     bool IsValid() const
 179     {
 180         return size() > 0;
 181     }
 182
 183     //! fully validate whether this is a valid public key (more expensive than IsValid())
 184     bool IsFullyValid() const
 185     {
 186         const unsigned char* pbegin = &vbytes[0];
 187         EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
 188         if (o2i_ECPublicKey(&pkey, &pbegin, size()))
 189         {
 190             EC_KEY_free(pkey);
 191             return true;
 192         }
 193         return false;
 194     }
 195
 196     //! Check whether this is a compressed public key.
 197     bool IsCompressed() const
 198     {
 199         return size() == 33;
 200     }
 201
 202     bool Verify(const uint256& hash, const std::vector<unsigned char>& vchSig) const;
 203     bool VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig);
 204
 205     bool SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig);
 206
 207     // Reserialize to DER
 208     static bool ReserealizeSignature(std::vector<unsigned char>& vchSig);
 209 };
 210
 211 // secure_allocator is defined in allocators.h
 212 // CPrivKey is a serialized private key, with all parameters included (279 bytes)
 213 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
 214 // CSecret is a serialization of just the secret parameter (32 bytes)
 215 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CSecret;
 216
 217 /** An encapsulated OpenSSL Elliptic Curve key (private) */
 218 class CKey
 219 {
 220 protected:
 221     EC_KEY* pkey;
 222     bool fSet;
 223
 224 public:
 225
 226     void Reset();
 227
 228     CKey();
 229     CKey(const CKey& b);
 230     CKey(const CSecret& b, bool fCompressed=true);
 231
 232     CKey& operator=(const CKey& b);
 233
 234     ~CKey();
 235
 236     bool IsNull() const;
 237     bool IsCompressed() const;
 238
 239     void SetCompressedPubKey(bool fCompressed=true);
 240     void MakeNewKey(bool fCompressed=true);
 241     bool SetPrivKey(const CPrivKey& vchPrivKey);
 242     bool SetSecret(const CSecret& vchSecret, bool fCompressed = true);
 243     CSecret GetSecret(bool &fCompressed) const;
 244     CSecret GetSecret() const;
 245     CPrivKey GetPrivKey() const;
 246     CPubKey GetPubKey() const;
 247
 248     bool Sign(uint256 hash, std::vector<unsigned char>& vchSig);
 249
 250     // create a compact signature (65 bytes), which allows reconstructing the used public key
 251     // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
 252     // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
 253     //                  0x1D = second key with even y, 0x1E = second key with odd y
 254     bool SignCompact(uint256 hash, std::vector<unsigned char>& vchSig);
 255
 256     bool IsValid();
 257
 258     // Check whether an element of a signature (r or s) is valid.
 259     static bool CheckSignatureElement(const unsigned char *vch, int len, bool half);
 260 };
 261
 262 class CPoint
 263 {
 264 private:
 265     EC_POINT *point;
 266     EC_GROUP* group;
 267     BN_CTX* ctx;
 268
 269 public:
 270     CPoint();
 271     bool operator!=(const CPoint &a);
 272     ~CPoint();
 273
 274     // Initialize from octets stream
 275     bool setBytes(const std::vector<unsigned char> &vchBytes);
 276
 277     // Initialize from pubkey
 278     bool setPubKey(const CPubKey &vchPubKey);
 279
 280     // Serialize to octets stream
 281     bool getBytes(std::vector<unsigned char> &vchBytes);
 282
 283     // ECC multiplication by specified multiplier
 284     bool ECMUL(const CBigNum &bnMultiplier);
 285
 286     // Calculate G*m + q
 287     bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint);
 288
 289     bool IsInfinity() { return EC_POINT_is_at_infinity(group, point) != 0; }
 290 };
 291
 292 class CMalleablePubKey
 293 {
 294 private:
 295     CPubKey pubKeyL;
 296     CPubKey pubKeyH;
 297     friend class CMalleableKey;
 298
 299     static const unsigned char CURRENT_VERSION = 1;
 300
 301 public:
 302     CMalleablePubKey() { }
 303     CMalleablePubKey(const CMalleablePubKey& mpk)
 304     {
 305         pubKeyL = mpk.pubKeyL;
 306         pubKeyH = mpk.pubKeyH;
 307     }
 308     CMalleablePubKey(const std::vector<unsigned char> &vchPubKeyPair) { setvch(vchPubKeyPair); }
 309     CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); }
 310     CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { }
 311
 312     IMPLEMENT_SERIALIZE(
 313         READWRITE(pubKeyL);
 314         READWRITE(pubKeyH);
 315     )
 316
 317     bool IsValid() const {
 318         return pubKeyL.IsValid() && pubKeyH.IsValid();
 319     }
 320
 321     bool operator==(const CMalleablePubKey &b);
 322     bool operator!=(const CMalleablePubKey &b) { return !(*this == b); }
 323     CMalleablePubKey& operator=(const CMalleablePubKey& mpk) {
 324         pubKeyL = mpk.pubKeyL;
 325         pubKeyH = mpk.pubKeyH;
 326         return *this;
 327     }
 328
 329     std::string ToString() const;
 330     bool SetString(const std::string& strMalleablePubKey);
 331
 332     CKeyID GetID() const {
 333         return pubKeyL.GetID();
 334     }
 335
 336     bool setvch(const std::vector<unsigned char> &vchPubKeyPair);
 337     std::vector<unsigned char> Raw() const;
 338
 339     CPubKey& GetL() { return pubKeyL; }
 340     CPubKey& GetH() { return pubKeyH; }
 341     void GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant);
 342 };
 343
 344 class CMalleableKey
 345 {
 346 private:
 347     CSecret vchSecretL;
 348     CSecret vchSecretH;
 349
 350     friend class CMalleableKeyView;
 351
 352 public:
 353     CMalleableKey();
 354     CMalleableKey(const CMalleableKey &b);
 355     CMalleableKey(const CSecret &L, const CSecret &H);
 356     ~CMalleableKey();
 357
 358     IMPLEMENT_SERIALIZE(
 359         READWRITE(vchSecretL);
 360         READWRITE(vchSecretH);
 361     )
 362
 363     std::string ToString() const;
 364     bool SetString(const std::string& strMalleablePubKey);
 365     std::vector<unsigned char> Raw() const;
 366     CMalleableKey& operator=(const CMalleableKey& mk) {
 367         vchSecretL = mk.vchSecretL;
 368         vchSecretH = mk.vchSecretH;
 369         return *this;
 370     }
 371
 372     void Reset();
 373     void MakeNewKeys();
 374     bool IsNull() const;
 375     bool IsValid() const { return !IsNull() && GetMalleablePubKey().IsValid(); }
 376     bool SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH);
 377
 378     CSecret GetSecretL() const { return vchSecretL; }
 379     CSecret GetSecretH() const { return vchSecretH; }
 380
 381     CKeyID GetID() const {
 382         return GetMalleablePubKey().GetID();
 383     }
 384     CMalleablePubKey GetMalleablePubKey() const;
 385     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
 386     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const;
 387 };
 388
 389 class CMalleableKeyView
 390 {
 391 private:
 392     CSecret vchSecretL;
 393     CPubKey vchPubKeyH;
 394
 395 public:
 396     CMalleableKeyView() { };
 397     CMalleableKeyView(const CMalleableKey &b);
 398     CMalleableKeyView(const std::string &strMalleableKey);
 399
 400     CMalleableKeyView(const CMalleableKeyView &b);
 401     CMalleableKeyView& operator=(const CMalleableKey &b);
 402     ~CMalleableKeyView();
 403
 404     IMPLEMENT_SERIALIZE(
 405         READWRITE(vchSecretL);
 406         READWRITE(vchPubKeyH);
 407     )
 408
 409     bool IsValid() const;
 410     std::string ToString() const;
 411     bool SetString(const std::string& strMalleablePubKey);
 412     std::vector<unsigned char> Raw() const;
 413     CMalleableKeyView& operator=(const CMalleableKeyView& mkv) {
 414         vchSecretL = mkv.vchSecretL;
 415         vchPubKeyH = mkv.vchPubKeyH;
 416         return *this;
 417     }
 418
 419     CKeyID GetID() const {
 420         return GetMalleablePubKey().GetID();
 421     }
 422     CMalleablePubKey GetMalleablePubKey() const;
 423     CMalleableKey GetMalleableKey(const CSecret &vchSecretH) const { return CMalleableKey(vchSecretL, vchSecretH); }
 424     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
 425
 426     bool operator <(const CMalleableKeyView& kv) const { return vchPubKeyH.GetID() < kv.vchPubKeyH.GetID(); }
 427 };
 428
 429 #endif