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.
11 #include "allocators.h"
12 #include "serialize.h"
18 #include <openssl/ec.h> // for EC_KEY definition
21 // const unsigned int PRIVATE_KEY_SIZE = 192;
22 // const unsigned int PUBLIC_KEY_SIZE = 41;
23 // const unsigned int SIGNATURE_SIZE = 48;
26 // const unsigned int PRIVATE_KEY_SIZE = 222;
27 // const unsigned int PUBLIC_KEY_SIZE = 49;
28 // const unsigned int SIGNATURE_SIZE = 57;
31 // const unsigned int PRIVATE_KEY_SIZE = 250;
32 // const unsigned int PUBLIC_KEY_SIZE = 57;
33 // const unsigned int SIGNATURE_SIZE = 66;
36 // const unsigned int PRIVATE_KEY_SIZE = 279;
37 // const unsigned int PUBLIC_KEY_SIZE = 65;
38 // const unsigned int SIGNATURE_SIZE = 72;
40 // see www.keylength.com
41 // script supports up to 75 for single byte push
43 class key_error : public std::runtime_error
46 explicit key_error(const std::string& str) : std::runtime_error(str) {}
49 /** A reference to a CKey: the Hash160 of its serialized public key */
50 class CKeyID : public uint160
53 CKeyID() : uint160(0) { }
54 CKeyID(const uint160 &in) : uint160(in) { }
57 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
58 class CScriptID : public uint160
61 CScriptID() : uint160(0) { }
62 CScriptID(const uint160 &in) : uint160(in) { }
65 /** An encapsulated OpenSSL Elliptic Curve key (public) */
71 * Just store the serialized data.
72 * Its length can very cheaply be computed from the first byte.
74 unsigned char vbytes[65];
76 //! Compute the length of a pubkey with a given first byte.
77 unsigned int static GetLen(unsigned char chHeader)
79 if (chHeader == 2 || chHeader == 3)
81 if (chHeader == 4 || chHeader == 6 || chHeader == 7)
86 // Set this key data to be invalid
93 // Construct an invalid public key.
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)
103 int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
104 if (len && len == (pend - pbegin))
105 memcpy(vbytes, (unsigned char*)&pbegin[0], len);
110 void Set(const std::vector<unsigned char>& vch)
112 Set(vch.begin(), vch.end());
115 template <typename T>
116 CPubKey(const T pbegin, const T pend)
121 CPubKey(const std::vector<unsigned char>& vch)
123 Set(vch.begin(), vch.end());
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]; }
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); }
136 //! Implement serialization, as if this was a byte vector.
137 unsigned int GetSerializeSize(int nType, int nVersion) const
141 template <typename Stream>
142 void Serialize(Stream& s, int nType, int nVersion) const
144 unsigned int len = size();
145 ::WriteCompactSize(s, len);
146 s.write((char*)vbytes, len);
148 template <typename Stream>
149 void Unserialize(Stream& s, int nType, int nVersion)
151 unsigned int len = ::ReadCompactSize(s);
153 s.read((char*)vbytes, len);
155 // invalid pubkey, skip available data
165 return CKeyID(Hash160(vbytes, vbytes + size()));
168 uint256 GetHash() const
170 return Hash(vbytes, vbytes + size());
174 * Check syntactic correctness.
176 * Note that this is consensus critical as CheckSig() calls it!
183 //! fully validate whether this is a valid public key (more expensive than IsValid())
184 bool IsFullyValid() const
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()))
196 //! Check whether this is a compressed public key.
197 bool IsCompressed() const
202 bool Verify(const uint256& hash, const std::vector<unsigned char>& vchSig) const;
203 bool VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig);
205 bool SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig);
207 // Reserialize to DER
208 static bool ReserealizeSignature(std::vector<unsigned char>& vchSig);
211 void EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted);
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;
220 /** An encapsulated OpenSSL Elliptic Curve key (private) */
233 CKey(const CSecret& b, bool fCompressed=true);
235 CKey& operator=(const CKey& b);
240 bool IsCompressed() const;
242 void SetCompressedPubKey(bool fCompressed=true);
243 void MakeNewKey(bool fCompressed=true);
244 bool SetPrivKey(const CPrivKey& vchPrivKey);
245 bool SetSecret(const CSecret& vchSecret, bool fCompressed = true);
246 CSecret GetSecret(bool &fCompressed) const;
247 CSecret GetSecret() const;
248 CPrivKey GetPrivKey() const;
249 CPubKey GetPubKey() const;
250 bool WritePEM(BIO *streamObj, const SecureString &strPassKey) const;
252 bool Sign(uint256 hash, std::vector<unsigned char>& vchSig);
254 // create a compact signature (65 bytes), which allows reconstructing the used public key
255 // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
256 // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
257 // 0x1D = second key with even y, 0x1E = second key with odd y
258 bool SignCompact(uint256 hash, std::vector<unsigned char>& vchSig);
262 // Check whether an element of a signature (r or s) is valid.
263 static bool CheckSignatureElement(const unsigned char *vch, int len, bool half);
266 void DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data);
278 bool operator!=(const CPoint &a);
281 // Initialize from octets stream
282 bool setBytes(const std::vector<unsigned char> &vchBytes);
284 // Initialize from pubkey
285 bool setPubKey(const CPubKey &vchPubKey);
287 // Serialize to octets stream
288 bool getBytes(std::vector<unsigned char> &vchBytes);
290 // ECC multiplication by specified multiplier
291 bool ECMUL(const CBigNum &bnMultiplier);
294 bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint);
296 bool IsInfinity() { return EC_POINT_is_at_infinity(group, point) != 0; }
299 class CMalleablePubKey
304 friend class CMalleableKey;
306 static const unsigned char CURRENT_VERSION = 1;
309 CMalleablePubKey() { }
310 CMalleablePubKey(const CMalleablePubKey& mpk)
312 pubKeyL = mpk.pubKeyL;
313 pubKeyH = mpk.pubKeyH;
315 CMalleablePubKey(const std::vector<unsigned char> &vchPubKeyPair) { setvch(vchPubKeyPair); }
316 CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); }
317 CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { }
324 bool IsValid() const {
325 return pubKeyL.IsValid() && pubKeyH.IsValid();
328 bool operator==(const CMalleablePubKey &b);
329 bool operator!=(const CMalleablePubKey &b) { return !(*this == b); }
330 CMalleablePubKey& operator=(const CMalleablePubKey& mpk) {
331 pubKeyL = mpk.pubKeyL;
332 pubKeyH = mpk.pubKeyH;
336 std::string ToString() const;
337 bool SetString(const std::string& strMalleablePubKey);
339 CKeyID GetID() const {
340 return pubKeyL.GetID();
343 bool setvch(const std::vector<unsigned char> &vchPubKeyPair);
344 std::vector<unsigned char> Raw() const;
346 CPubKey& GetL() { return pubKeyL; }
347 CPubKey& GetH() { return pubKeyH; }
348 void GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant);
357 friend class CMalleableKeyView;
361 CMalleableKey(const CMalleableKey &b);
362 CMalleableKey(const CSecret &L, const CSecret &H);
366 READWRITE(vchSecretL);
367 READWRITE(vchSecretH);
370 std::string ToString() const;
371 bool SetString(const std::string& strMalleablePubKey);
372 std::vector<unsigned char> Raw() const;
373 CMalleableKey& operator=(const CMalleableKey& mk) {
374 vchSecretL = mk.vchSecretL;
375 vchSecretH = mk.vchSecretH;
382 bool IsValid() const { return !IsNull() && GetMalleablePubKey().IsValid(); }
383 bool SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH);
385 CSecret GetSecretL() const { return vchSecretL; }
386 CSecret GetSecretH() const { return vchSecretH; }
388 CKeyID GetID() const {
389 return GetMalleablePubKey().GetID();
391 CMalleablePubKey GetMalleablePubKey() const;
392 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
393 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const;
396 class CMalleableKeyView
403 CMalleableKeyView() { };
404 CMalleableKeyView(const CMalleableKey &b);
405 CMalleableKeyView(const std::string &strMalleableKey);
407 CMalleableKeyView(const CMalleableKeyView &b);
408 CMalleableKeyView& operator=(const CMalleableKey &b);
409 ~CMalleableKeyView();
412 READWRITE(vchSecretL);
413 READWRITE(vchPubKeyH);
416 bool IsValid() const;
417 std::string ToString() const;
418 bool SetString(const std::string& strMalleablePubKey);
419 std::vector<unsigned char> Raw() const;
420 CMalleableKeyView& operator=(const CMalleableKeyView& mkv) {
421 vchSecretL = mkv.vchSecretL;
422 vchPubKeyH = mkv.vchPubKeyH;
426 CKeyID GetID() const {
427 return GetMalleablePubKey().GetID();
429 CMalleablePubKey GetMalleablePubKey() const;
430 CMalleableKey GetMalleableKey(const CSecret &vchSecretH) const { return CMalleableKey(vchSecretL, vchSecretH); }
431 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const;
433 bool operator <(const CMalleableKeyView& kv) const { return vchPubKeyH.GetID() < kv.vchPubKeyH.GetID(); }