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 #include "ies.h"
  17
  18 #include <openssl/ec.h> // for EC_KEY definition
  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     // Encrypt data
 211     void EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted);
 212 };
 213
 214 // secure_allocator is defined in allocators.h
 215 // CPrivKey is a serialized private key, with all parameters included (279 bytes)
 216 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
 217 // CSecret is a serialization of just the secret parameter (32 bytes)
 218 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CSecret;
 219
 220 /** An encapsulated OpenSSL Elliptic Curve key (private) */
 221 class CKey
 222 {
 223 protected:
 224     EC_KEY* pkey;
 225     bool fSet;
 226     bool fCompressedPubKey;
 227
 228 public:
 229
 230     void Reset();
 231
 232     CKey();
 233     CKey(const CKey& b);
 234     CKey(const CSecret& b, bool fCompressed=true);
 235
 236     CKey& operator=(const CKey& b);
 237
 238     ~CKey();
 239
 240     bool IsNull() const;
 241     bool IsCompressed() const;
 242
 243     void SetCompressedPubKey(bool fCompressed=true);
 244     void MakeNewKey(bool fCompressed=true);
 245     bool SetPrivKey(const CPrivKey& vchPrivKey);
 246     bool SetSecret(const CSecret& vchSecret, bool fCompressed = false);
 247     CSecret GetSecret(bool &fCompressed) const;
 248     CSecret GetSecret() const;
 249     CPrivKey GetPrivKey() const;
 250     CPubKey GetPubKey() const;
 251     bool WritePEM(BIO *streamObj, const SecureString &strPassKey) const;
 252
 253     bool Sign(uint256 hash, std::vector<unsigned char>& vchSig);
 254
 255     // create a compact signature (65 bytes), which allows reconstructing the used public key
 256     // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
 257     // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
 258     //                  0x1D = second key with even y, 0x1E = second key with odd y
 259     bool SignCompact(uint256 hash, std::vector<unsigned char>& vchSig);
 260
 261     bool IsValid();
 262
 263     // Check whether an element of a signature (r or s) is valid.
 264     static bool CheckSignatureElement(const unsigned char *vch, int len, bool half);
 265
 266     // Decrypt data
 267     void DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data);
 268 };
 269
 270 class CPoint
 271 {
 272 private:
 273     EC_POINT *point;
 274     EC_GROUP* group;
 275     BN_CTX* ctx;
 276
 277 public:
 278     CPoint();
 279     bool operator!=(const CPoint &a);
 280     ~CPoint();
 281
 282     // Initialize from octets stream
 283     bool setBytes(const std::vector<unsigned char> &vchBytes);
 284
 285     // Initialize from pubkey
 286     bool setPubKey(const CPubKey &vchPubKey);
 287
 288     // Serialize to octets stream
 289     bool getBytes(std::vector<unsigned char> &vchBytes);
 290
 291     // ECC multiplication by specified multiplier
 292     bool ECMUL(const CBigNum &bnMultiplier);
 293
 294     // Calculate G*m + q
 295     bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint);
 296
 297     bool IsInfinity() { return EC_POINT_is_at_infinity(group, point) != 0; }
 298 };
 299
 300 class CMalleablePubKey
 301 {
 302 private:
 303     CPubKey pubKeyL;
 304     CPubKey pubKeyH;
 305     friend class CMalleableKey;
 306
 307     static const unsigned char CURRENT_VERSION = 1;
 308
 309 public:
 310     CMalleablePubKey() { }
 311     CMalleablePubKey(const CMalleablePubKey& mpk)
 312     {
 313         pubKeyL = mpk.pubKeyL;
 314         pubKeyH = mpk.pubKeyH;
 315     }
 316     CMalleablePubKey(const std::vector<unsigned char> &vchPubKeyPair) { setvch(vchPubKeyPair); }
 317     CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); }
 318     CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { }
 319
 320     IMPLEMENT_SERIALIZE(
 321         READWRITE(pubKeyL);
 322         READWRITE(pubKeyH);
 323     )
 324
 325     bool IsValid() const {
 326         return pubKeyL.IsValid() && pubKeyH.IsValid();
 327     }
 328
 329     bool operator==(const CMalleablePubKey &b);
 330     bool operator!=(const CMalleablePubKey &b) { return !(*this == b); }
 331     CMalleablePubKey& operator=(const CMalleablePubKey& mpk) {
 332         pubKeyL = mpk.pubKeyL;
 333         pubKeyH = mpk.pubKeyH;
 334         return *this;
 335     }
 336
 337     std::string ToString() const;
 338     bool SetString(const std::string& strMalleablePubKey);
 339
 340     CKeyID GetID() const {
 341         return pubKeyL.GetID();
 342     }
 343
 344     bool setvch(const std::vector<unsigned char> &vchPubKeyPair);
 345     std::vector<unsigned char> Raw() const;
 346
 347     CPubKey& GetL() { return pubKeyL; }
 348     CPubKey& GetH() { return pubKeyH; }
 349     void GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant);
 350 };
 351
 352 class CMalleableKey
 353 {
 354 private:
 355     CSecret vchSecretL;
 356     CSecret vchSecretH;
 357
 358     friend class CMalleableKeyView;
 359
 360 public:
 361     CMalleableKey();
 362     CMalleableKey(const CMalleableKey &b);
 363     CMalleableKey(const CSecret &L, const CSecret &H);
 364     ~CMalleableKey();
 365
 366     IMPLEMENT_SERIALIZE(
 367         READWRITE(vchSecretL);
 368         READWRITE(vchSecretH);
 369     )
 370
 371     std::string ToString() const;
 372     bool SetString(const std::string& strMalleablePubKey);
 373     std::vector<unsigned char> Raw() const;
 374     CMalleableKey& operator=(const CMalleableKey& mk) {
 375         vchSecretL = mk.vchSecretL;
 376         vchSecretH = mk.vchSecretH;
 377         return *this;
 378     }
 379
 380     void Reset();
 381     void MakeNewKeys();
 382     bool IsNull() const;
 383     bool IsValid() const { return !IsNull() && GetMalleablePubKey().IsValid(); }
 384     bool SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH);
 385
 386     CSecret GetSecretL() const { return vchSecretL; }
 387     CSecret GetSecretH() const { return vchSecretH; }
 388
 389     CKeyID GetID() const {
 390         return GetMalleablePubKey().GetID();
 391     }
 392     CMalleablePubKey GetMalleablePubKey() const;
 393     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
 394     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const;
 395 };
 396
 397 class CMalleableKeyView
 398 {
 399 private:
 400     CSecret vchSecretL;
 401     CPubKey vchPubKeyH;
 402
 403 public:
 404     CMalleableKeyView() { };
 405     CMalleableKeyView(const CMalleableKey &b);
 406     CMalleableKeyView(const std::string &strMalleableKey);
 407
 408     CMalleableKeyView(const CMalleableKeyView &b);
 409     CMalleableKeyView& operator=(const CMalleableKey &b);
 410     ~CMalleableKeyView();
 411
 412     IMPLEMENT_SERIALIZE(
 413         READWRITE(vchSecretL);
 414         READWRITE(vchPubKeyH);
 415     )
 416
 417     bool IsValid() const;
 418     std::string ToString() const;
 419     bool SetString(const std::string& strMalleablePubKey);
 420     std::vector<unsigned char> Raw() const;
 421     CMalleableKeyView& operator=(const CMalleableKeyView& mkv) {
 422         vchSecretL = mkv.vchSecretL;
 423         vchPubKeyH = mkv.vchPubKeyH;
 424         return *this;
 425     }
 426
 427     CKeyID GetID() const {
 428         return GetMalleablePubKey().GetID();
 429     }
 430     CMalleablePubKey GetMalleablePubKey() const;
 431     CMalleableKey GetMalleableKey(const CSecret &vchSecretH) const { return CMalleableKey(vchSecretL, vchSecretH); }
 432     bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
 433
 434     bool operator <(const CMalleableKeyView& kv) const { return vchPubKeyH.GetID() < kv.vchPubKeyH.GetID(); }
 435 };
 436
 437 #endif