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);