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"
17 #include <openssl/ec.h> // for EC_KEY definition
20 // const unsigned int PRIVATE_KEY_SIZE = 192;
21 // const unsigned int PUBLIC_KEY_SIZE = 41;
22 // const unsigned int SIGNATURE_SIZE = 48;
25 // const unsigned int PRIVATE_KEY_SIZE = 222;
26 // const unsigned int PUBLIC_KEY_SIZE = 49;
27 // const unsigned int SIGNATURE_SIZE = 57;
30 // const unsigned int PRIVATE_KEY_SIZE = 250;
31 // const unsigned int PUBLIC_KEY_SIZE = 57;
32 // const unsigned int SIGNATURE_SIZE = 66;
35 // const unsigned int PRIVATE_KEY_SIZE = 279;
36 // const unsigned int PUBLIC_KEY_SIZE = 65;
37 // const unsigned int SIGNATURE_SIZE = 72;
39 // see www.keylength.com
40 // script supports up to 75 for single byte push
42 class key_error : public std::runtime_error
45 explicit key_error(const std::string& str) : std::runtime_error(str) {}
48 /** A reference to a CKey: the Hash160 of its serialized public key */
49 class CKeyID : public uint160
52 CKeyID() : uint160(0) { }
53 CKeyID(const uint160 &in) : uint160(in) { }
56 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
57 class CScriptID : public uint160
60 CScriptID() : uint160(0) { }
61 CScriptID(const uint160 &in) : uint160(in) { }
64 /** An encapsulated public key. */
67 std::vector<unsigned char> vchPubKey;
72 CPubKey(const std::vector<unsigned char> &vchPubKeyIn) : vchPubKey(vchPubKeyIn) { }
73 friend bool operator==(const CPubKey &a, const CPubKey &b) { return a.vchPubKey == b.vchPubKey; }
74 friend bool operator!=(const CPubKey &a, const CPubKey &b) { return a.vchPubKey != b.vchPubKey; }
75 friend bool operator<(const CPubKey &a, const CPubKey &b) { return a.vchPubKey < b.vchPubKey; }
81 CKeyID GetID() const {
82 return CKeyID(Hash160(vchPubKey));
85 uint256 GetHash() const {
86 return Hash(vchPubKey.begin(), vchPubKey.end());
89 bool IsValid() const {
90 return vchPubKey.size() == 33 || vchPubKey.size() == 65;
93 bool IsCompressed() const {
94 return vchPubKey.size() == 33;
97 std::vector<unsigned char> Raw() const {
103 // secure_allocator is defined in allocators.h
104 // CPrivKey is a serialized private key, with all parameters included (279 bytes)
105 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
106 // CSecret is a serialization of just the secret parameter (32 bytes)
107 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CSecret;
109 /** An encapsulated OpenSSL Elliptic Curve key (public and/or private) */
115 bool fCompressedPubKey;
117 void SetCompressedPubKey();
126 CKey& operator=(const CKey& b);
131 bool IsCompressed() const;
133 void MakeNewKey(bool fCompressed);
134 bool SetPrivKey(const CPrivKey& vchPrivKey);
135 bool SetSecret(const CSecret& vchSecret, bool fCompressed = false);
136 CSecret GetSecret(bool &fCompressed) const;
137 CPrivKey GetPrivKey() const;
138 bool SetPubKey(const CPubKey& vchPubKey);
139 CPubKey GetPubKey() const;
141 bool Sign(uint256 hash, std::vector<unsigned char>& vchSig);
143 // create a compact signature (65 bytes), which allows reconstructing the used public key
144 // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
145 // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
146 // 0x1D = second key with even y, 0x1E = second key with odd y
147 bool SignCompact(uint256 hash, std::vector<unsigned char>& vchSig);
149 // reconstruct public key from a compact signature
150 // This is only slightly more CPU intensive than just verifying it.
151 // If this function succeeds, the recovered public key is guaranteed to be valid
152 // (the signature is a valid signature of the given data for that key)
153 bool SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig);
155 bool Verify(uint256 hash, const std::vector<unsigned char>& vchSig);
157 // Verify a compact signature
158 bool VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig);
162 // Check whether an element of a signature (r or s) is valid.
163 static bool CheckSignatureElement(const unsigned char *vch, int len, bool half);
165 // Reserialize to DER
166 static bool ReserealizeSignature(std::vector<unsigned char>& vchSig);
178 bool operator!=(const CPoint &a);
181 // Initialize from octets stream
182 bool setBytes(const std::vector<unsigned char> &vchBytes);
184 // Serialize to octets stream
185 bool getBytes(std::vector<unsigned char> &vchBytes);
187 // ECC multiplication by specified multiplier
188 bool ECMUL(const CBigNum &bnMultiplier);
191 bool ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint);
193 bool IsInfinity() { return EC_POINT_is_at_infinity(group, point); }
196 class CMalleablePubKey
199 unsigned char nVersion;
202 friend class CMalleableKey;
204 static const unsigned char CURRENT_VERSION = 1;
207 CMalleablePubKey() { nVersion = CMalleablePubKey::CURRENT_VERSION; }
208 CMalleablePubKey(const std::string& strMalleablePubKey) { SetString(strMalleablePubKey); }
209 CMalleablePubKey(const CPubKey &pubKeyInL, const CPubKey &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { nVersion = CMalleablePubKey::CURRENT_VERSION; }
210 CMalleablePubKey(const std::vector<unsigned char> &pubKeyInL, const std::vector<unsigned char> &pubKeyInH) : pubKeyL(pubKeyInL), pubKeyH(pubKeyInH) { nVersion = CMalleablePubKey::CURRENT_VERSION; }
213 READWRITE(this->nVersion);
214 nVersion = this->nVersion;
219 bool IsValid() const {
220 return pubKeyL.IsValid() && pubKeyH.IsValid();
223 bool operator==(const CMalleablePubKey &b);
224 bool operator!=(const CMalleablePubKey &b) { return !(*this == b); }
226 std::string ToString();
227 bool SetString(const std::string& strMalleablePubKey);
228 uint256 GetID() const;
230 CPubKey& GetL() { return pubKeyL; }
231 CPubKey& GetH() { return pubKeyH; }
232 void GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant);
238 unsigned char nVersion;
242 friend class CMalleableKeyView;
244 static const unsigned char CURRENT_VERSION = 1;
248 CMalleableKey(const CMalleableKey &b);
249 CMalleableKey(const CSecret &L, const CSecret &H);
250 CMalleableKey& operator=(const CMalleableKey &b);
254 READWRITE(this->nVersion);
255 nVersion = this->nVersion;
256 READWRITE(vchSecretL);
257 READWRITE(vchSecretH);
260 std::string ToString();
261 bool SetString(const std::string& strMalleablePubKey);
266 bool SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH);
267 void GetSecrets(CSecret &pvchSecretL, CSecret &pvchSecretH) const;
269 CMalleablePubKey GetMalleablePubKey() const;
271 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant);
272 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant);
275 class CMalleableKeyView
279 std::vector<unsigned char> vchPubKeyH;
281 // disabled constructor
282 CMalleableKeyView() { };
284 static const unsigned char CURRENT_VERSION = 1;
287 CMalleableKeyView(const CMalleableKey &b);
288 CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH);
290 CMalleableKeyView(const CMalleableKeyView &b);
291 CMalleableKeyView& operator=(const CMalleableKey &b);
292 ~CMalleableKeyView();
294 CMalleablePubKey GetMalleablePubKey() const;
296 bool CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant);