 |
Bitcoin Core
22.99.0
P2P Digital Currency
|
Go to the documentation of this file.
37 const CKey key = [&] {
39 k.Set(buffer.begin(), buffer.end(),
true);
55 assert(!(invalid_key == key));
62 CKey uncompressed_key;
63 uncompressed_key.
Set(buffer.begin(), buffer.end(),
false);
64 assert(!(uncompressed_key == key));
78 CKey negated_key = key;
81 assert(!(negated_key == key));
84 assert(negated_key == key);
92 const bool ok = key.
Derive(child_key, child_chaincode, 0, random_uint256);
95 assert(!(child_key == key));
96 assert(child_chaincode != random_uint256);
120 assert(pubkey_deserialized == pubkey);
148 const bool ok_add_key = fillable_signing_provider.
AddKey(key);
155 const bool ok_add_key_pubkey = fillable_signing_provider_pub.
AddKeyPubKey(key, pubkey);
156 assert(ok_add_key_pubkey);
160 const bool is_standard_tx_pubkey =
IsStandard(tx_pubkey_script, which_type_tx_pubkey);
161 assert(is_standard_tx_pubkey);
165 const bool is_standard_tx_multisig =
IsStandard(tx_multisig_script, which_type_tx_multisig);
166 assert(is_standard_tx_multisig);
169 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_pubkey;
170 const TxoutType outtype_tx_pubkey =
Solver(tx_pubkey_script, v_solutions_ret_tx_pubkey);
172 assert(v_solutions_ret_tx_pubkey.size() == 1);
173 assert(v_solutions_ret_tx_pubkey[0].size() == 33);
175 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_multisig;
176 const TxoutType outtype_tx_multisig =
Solver(tx_multisig_script, v_solutions_ret_tx_multisig);
178 assert(v_solutions_ret_tx_multisig.size() == 3);
179 assert(v_solutions_ret_tx_multisig[0].size() == 1);
180 assert(v_solutions_ret_tx_multisig[1].size() == 33);
181 assert(v_solutions_ret_tx_multisig[2].size() == 1);
190 assert(script_for_destination.size() == 25);
195 const CPubKey pubkey_from_address_string =
AddrToPubKey(fillable_signing_provider, destination_address);
196 assert(pubkey_from_address_string == pubkey);
204 const bool ok_get_pubkey = fillable_signing_provider.
GetPubKey(key_id, pubkey_out);
208 const bool ok_get_key = fillable_signing_provider.
GetKey(key_id, key_out);
214 const bool ok_get_key_origin = fillable_signing_provider.
GetKeyOrigin(key_id, key_origin_info);
215 assert(!ok_get_key_origin);
219 const std::vector<unsigned char> vch_pubkey{pubkey.
begin(), pubkey.
end()};
223 const CPubKey pubkey_ctor_1{vch_pubkey};
224 assert(pubkey == pubkey_ctor_1);
226 const CPubKey pubkey_ctor_2{vch_pubkey.
begin(), vch_pubkey.end()};
227 assert(pubkey == pubkey_ctor_2);
230 pubkey_set.
Set(vch_pubkey.begin(), vch_pubkey.end());
231 assert(pubkey == pubkey_set);
235 const CPubKey invalid_pubkey{};
236 assert(!invalid_pubkey.IsValid());
237 assert(!invalid_pubkey.IsFullyValid());
238 assert(!(pubkey == invalid_pubkey));
239 assert(pubkey != invalid_pubkey);
240 assert(pubkey < invalid_pubkey);
245 unsigned int sum = 0;
246 for (
size_t i = 0; i < pubkey.
size(); ++i) {
253 CPubKey decompressed_pubkey = pubkey;
256 const bool ok = decompressed_pubkey.
Decompress();
263 std::vector<unsigned char> vch_sig;
264 const bool ok = key.
Sign(random_uint256, vch_sig,
false);
269 const std::vector<unsigned char> vch_invalid_sig{vch_sig.begin(), vch_sig.begin() + vch_sig.size() - 1};
270 assert(!pubkey.
Verify(random_uint256, vch_invalid_sig));
275 std::vector<unsigned char> vch_compact_sig;
276 const bool ok_sign_compact = key.
SignCompact(random_uint256, vch_compact_sig);
280 const bool ok_recover_compact = recover_pubkey.
RecoverCompact(random_uint256, vch_compact_sig);
281 assert(ok_recover_compact);
282 assert(recover_pubkey == pubkey);
288 const bool ok = pubkey.
Derive(child_pubkey, child_chaincode, 0, random_uint256);
290 assert(child_pubkey != pubkey);
295 assert(child_chaincode != random_uint256);
301 for (
const bool skip_check : {
true,
false}) {
303 const bool ok = loaded_key.
Load(priv_key, pubkey, skip_check);
305 assert(key == loaded_key);
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
virtual std::set< CKeyID > GetKeys() const
bool IsStandard(const CScript &scriptPubKey, TxoutType &whichType)
bool IsPayToWitnessScriptHash() const
Fillable signing provider that keeps keys in an address->secret map.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
void Set(const T pbegin, const T pend)
Initialize a public key using begin/end iterators to byte data.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
std::vector< unsigned char, secure_allocator< unsigned char > > CPrivKey
CPrivKey is a serialized private key, with all parameters included (SIZE bytes)
bool HasValidOps() const
Check if the script contains valid OP_CODES.
bool Derive(CPubKey &pubkeyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child pubkey.
const unsigned char * data() const
bool Decompress()
Turn this public key into an uncompressed public key.
CPubKey HexToPubKey(const std::string &hex_in)
bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child key.
A reference to a CKey: the Hash160 of its serialized public key.
bool IsPayToScriptHash() const
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
static bool ValidSize(const std::vector< unsigned char > &vch)
virtual bool AddKey(const CKey &key)
const unsigned char * end() const
FUZZ_TARGET_INIT(key, initialize_key)
bool IsPushOnly(const_iterator pc) const
Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical).
const unsigned char * begin() const
const unsigned char * begin() const
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
virtual bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
std::string EncodeSecret(const CKey &key)
virtual bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
const unsigned char * end() const
bool IsSegWitOutput(const SigningProvider &provider, const CScript &script)
Check whether a scriptPubKey is known to be segwit.
uint256 GetHash() const
Get the 256-bit hash of this public key.
bool SignCompact(const uint256 &hash, std::vector< unsigned char > &vchSig) const
Create a compact signature (65 bytes), which allows reconstructing the used public key.
static const std::string REGTEST
bool IsValid() const
Check whether this private key is valid.
void Unserialize(Stream &s)
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
void Serialize(Stream &s) const
Implement serialization, as if this was a byte vector.
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
void SelectParams(const std::string &network)
Sets the params returned by Params() to those for the given chain name.
CKey DecodeSecret(const std::string &str)
unsigned int size() const
Simple read-only vector-like interface to the pubkey data.
CPubKey GetPubKey() const
Compute the public key from a private key.
Serialized script, used inside transaction inputs and outputs.
bool RecoverCompact(const uint256 &hash, const std::vector< unsigned char > &vchSig)
Recover a public key from a compact signature.
bool Negate()
Negate private key.
bool IsCompressed() const
Check whether this is a compressed public key.
void ECC_Start()
Initialize the elliptic curve support.
An encapsulated public key.
unsigned int size() const
Simple read-only vector-like interface.
Users of this module must hold an ECCVerifyHandle.
An encapsulated private key.
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
virtual bool GetKey(const CKeyID &address, CKey &keyOut) const override
bool IsSolvable(const SigningProvider &provider, const CScript &script)
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
Double ended buffer combining vector and stream-like interfaces.
virtual bool HaveKey(const CKeyID &address) const override
bool Load(const CPrivKey &privkey, const CPubKey &vchPubKey, bool fSkipCheck)
Load private key and check that public key matches.
bool IsUnspendable() const
Returns whether the script is guaranteed to fail at execution, regardless of the initial stack.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::vector< CTxDestination > GetAllDestinationsForKey(const CPubKey &key)
Get all destinations (potentially) supported by the wallet for the given key.
CPubKey AddrToPubKey(const FillableSigningProvider &keystore, const std::string &addr_in)
std::string EncodeDestination(const CTxDestination &dest)
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
static bool CheckLowS(const std::vector< unsigned char > &vchSig)
Check whether a signature is normalized (lower-S).
static const int INIT_PROTO_VERSION
initial proto version, to be increased after version/verack negotiation