5 #include <chainparams.h>
41 const CKey key = [&] {
43 k.Set(buffer.begin(), buffer.end(),
true);
59 assert(!(invalid_key == key));
66 CKey uncompressed_key;
67 uncompressed_key.
Set(buffer.begin(), buffer.end(),
false);
68 assert(!(uncompressed_key == key));
86 const bool ok = key.
Derive(child_key, child_chaincode, 0, random_uint256);
89 assert(!(child_key == key));
90 assert(child_chaincode != random_uint256);
114 assert(pubkey_deserialized == pubkey);
140 const bool ok_add_key = fillable_signing_provider.
AddKey(key);
147 const bool ok_add_key_pubkey = fillable_signing_provider_pub.
AddKeyPubKey(key, pubkey);
148 assert(ok_add_key_pubkey);
152 const bool is_standard_tx_pubkey =
IsStandard(tx_pubkey_script, std::nullopt, which_type_tx_pubkey);
153 assert(is_standard_tx_pubkey);
157 const bool is_standard_tx_multisig =
IsStandard(tx_multisig_script, std::nullopt, which_type_tx_multisig);
158 assert(is_standard_tx_multisig);
161 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_pubkey;
162 const TxoutType outtype_tx_pubkey =
Solver(tx_pubkey_script, v_solutions_ret_tx_pubkey);
164 assert(v_solutions_ret_tx_pubkey.size() == 1);
165 assert(v_solutions_ret_tx_pubkey[0].size() == 33);
167 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_multisig;
168 const TxoutType outtype_tx_multisig =
Solver(tx_multisig_script, v_solutions_ret_tx_multisig);
170 assert(v_solutions_ret_tx_multisig.size() == 3);
171 assert(v_solutions_ret_tx_multisig[0].size() == 1);
172 assert(v_solutions_ret_tx_multisig[1].size() == 33);
173 assert(v_solutions_ret_tx_multisig[2].size() == 1);
179 assert(
PKHash{pubkey} == *std::get_if<PKHash>(&tx_destination));
182 assert(script_for_destination.size() == 25);
187 const CPubKey pubkey_from_address_string =
AddrToPubKey(fillable_signing_provider, destination_address);
188 assert(pubkey_from_address_string == pubkey);
196 const bool ok_get_pubkey = fillable_signing_provider.
GetPubKey(key_id, pubkey_out);
200 const bool ok_get_key = fillable_signing_provider.
GetKey(key_id, key_out);
206 const bool ok_get_key_origin = fillable_signing_provider.
GetKeyOrigin(key_id, key_origin_info);
207 assert(!ok_get_key_origin);
211 const std::vector<unsigned char> vch_pubkey{pubkey.
begin(), pubkey.
end()};
215 const CPubKey pubkey_ctor_1{vch_pubkey};
216 assert(pubkey == pubkey_ctor_1);
218 const CPubKey pubkey_ctor_2{vch_pubkey.
begin(), vch_pubkey.end()};
219 assert(pubkey == pubkey_ctor_2);
222 pubkey_set.
Set(vch_pubkey.begin(), vch_pubkey.end());
223 assert(pubkey == pubkey_set);
227 const CPubKey invalid_pubkey{};
228 assert(!invalid_pubkey.IsValid());
229 assert(!invalid_pubkey.IsFullyValid());
230 assert(!(pubkey == invalid_pubkey));
231 assert(pubkey != invalid_pubkey);
232 assert(pubkey < invalid_pubkey);
237 unsigned int sum = 0;
238 for (
size_t i = 0; i < pubkey.
size(); ++i) {
245 CPubKey decompressed_pubkey = pubkey;
248 const bool ok = decompressed_pubkey.
Decompress();
255 std::vector<unsigned char> vch_sig;
256 const bool ok = key.
Sign(random_uint256, vch_sig,
false);
261 const std::vector<unsigned char> vch_invalid_sig{vch_sig.begin(), vch_sig.begin() + vch_sig.size() - 1};
262 assert(!pubkey.
Verify(random_uint256, vch_invalid_sig));
267 std::vector<unsigned char> vch_compact_sig;
268 const bool ok_sign_compact = key.
SignCompact(random_uint256, vch_compact_sig);
272 const bool ok_recover_compact = recover_pubkey.
RecoverCompact(random_uint256, vch_compact_sig);
273 assert(ok_recover_compact);
274 assert(recover_pubkey == pubkey);
280 const bool ok = pubkey.
Derive(child_pubkey, child_chaincode, 0, random_uint256);
282 assert(child_pubkey != pubkey);
287 assert(child_chaincode != random_uint256);
293 for (
const bool skip_check : {
true,
false}) {
295 const bool ok = loaded_key.
Load(priv_key, pubkey, skip_check);
297 assert(key == loaded_key);
309 auto ent32 = fdp.ConsumeBytes<std::byte>(32);
313 auto decoded_pubkey = encoded_ellswift.
Decode();
316 std::vector<unsigned char> sig;
318 assert(decoded_pubkey.Verify(hash, sig));
334 auto ent32_1 = fdp.ConsumeBytes<std::byte>(32);
339 auto ent32_2 = fdp.ConsumeBytes<std::byte>(32);
344 auto ent32_2_bad = fdp.ConsumeBytes<std::byte>(32);
345 ent32_2_bad.resize(32);
347 assert((ent32_2_bad == ent32_2) == (k2_ellswift_bad == k2_ellswift));
350 bool initiating = fdp.ConsumeBool();
357 assert(ecdh_secret_1 == ecdh_secret_2);
359 if (k1_ellswift != k2_ellswift) {
362 assert(ecdh_secret_bad != ecdh_secret_1);
365 if (k2_ellswift_bad != k2_ellswift) {
368 assert(ecdh_secret_bad != ecdh_secret_1);
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
An encapsulated private key.
const std::byte * end() const
unsigned int size() const
Simple read-only vector-like interface.
bool IsValid() const
Check whether this private key is valid.
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
ECDHSecret ComputeBIP324ECDHSecret(const EllSwiftPubKey &their_ellswift, const EllSwiftPubKey &our_ellswift, bool initiating) const
Compute a BIP324-style ECDH shared secret.
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
CPubKey GetPubKey() const
Compute the public key from a private key.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
EllSwiftPubKey EllSwiftCreate(Span< const std::byte > entropy) const
Create an ellswift-encoded public key for this key, with specified entropy.
bool Load(const CPrivKey &privkey, const CPubKey &vchPubKey, bool fSkipCheck)
Load private key and check that public key matches.
const std::byte * begin() const
bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child 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.
A reference to a CKey: the Hash160 of its serialized public key.
An encapsulated public key.
bool RecoverCompact(const uint256 &hash, const std::vector< unsigned char > &vchSig)
Recover a public key from a compact signature.
const unsigned char * end() const
bool IsCompressed() const
Check whether this is a compressed public key.
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).
bool Decompress()
Turn this public key into an uncompressed public key.
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
unsigned int size() const
Simple read-only vector-like interface to the pubkey data.
static bool ValidSize(const std::vector< unsigned char > &vch)
const unsigned char * begin() const
void Serialize(Stream &s) const
Implement serialization, as if this was a byte vector.
void Unserialize(Stream &s)
uint256 GetHash() const
Get the 256-bit hash of this public key.
const unsigned char * data() const
bool Derive(CPubKey &pubkeyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child pubkey.
void Set(const T pbegin, const T pend)
Initialize a public key using begin/end iterators to byte data.
Serialized script, used inside transaction inputs and outputs.
bool IsPushOnly(const_iterator pc) const
Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical).
bool IsPayToScriptHash() const
bool IsUnspendable() const
Returns whether the script is guaranteed to fail at execution, regardless of the initial stack.
bool IsPayToWitnessScriptHash() const
bool HasValidOps() const
Check if the script contains valid OP_CODES.
Double ended buffer combining vector and stream-like interfaces.
RAII class initializing and deinitializing global state for elliptic curve support.
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
virtual bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
virtual bool GetKey(const CKeyID &address, CKey &keyOut) const override
virtual std::set< CKeyID > GetKeys() const
virtual bool AddKey(const CKey &key)
virtual bool HaveKey(const CKeyID &address) const override
virtual bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const
constexpr bool IsNull() const
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::vector< unsigned char, secure_allocator< unsigned char > > CPrivKey
CPrivKey is a serialized private key, with all parameters included (SIZE bytes)
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeSecret(const CKey &key)
std::string EncodeDestination(const CTxDestination &dest)
CKey DecodeSecret(const std::string &str)
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
std::vector< CTxDestination > GetAllDestinationsForKey(const CPubKey &key)
Get all destinations (potentially) supported by the wallet for the given key.
bool IsStandard(const CScript &scriptPubKey, const std::optional< unsigned > &max_datacarrier_bytes, TxoutType &whichType)
CPubKey HexToPubKey(const std::string &hex_in)
CPubKey AddrToPubKey(const FillableSigningProvider &keystore, const std::string &addr_in)
bool IsSegWitOutput(const SigningProvider &provider, const CScript &script)
Check whether a scriptPubKey is known to be segwit.
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
CPubKey Decode() const
Decode to normal compressed CPubKey (for debugging purposes).
FUZZ_TARGET(key,.init=initialize_key)
CKey ConsumePrivateKey(FuzzedDataProvider &fuzzed_data_provider, std::optional< bool > compressed) noexcept
uint256 ConsumeUInt256(FuzzedDataProvider &fuzzed_data_provider) noexcept