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));
82 CKey negated_key = key;
85 assert(!(negated_key == key));
88 assert(negated_key == key);
96 const bool ok = key.
Derive(child_key, child_chaincode, 0, random_uint256);
99 assert(!(child_key == key));
100 assert(child_chaincode != random_uint256);
124 assert(pubkey_deserialized == pubkey);
150 const bool ok_add_key = fillable_signing_provider.
AddKey(key);
157 const bool ok_add_key_pubkey = fillable_signing_provider_pub.
AddKeyPubKey(key, pubkey);
158 assert(ok_add_key_pubkey);
162 const bool is_standard_tx_pubkey =
IsStandard(tx_pubkey_script, std::nullopt, which_type_tx_pubkey);
163 assert(is_standard_tx_pubkey);
167 const bool is_standard_tx_multisig =
IsStandard(tx_multisig_script, std::nullopt, which_type_tx_multisig);
168 assert(is_standard_tx_multisig);
171 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_pubkey;
172 const TxoutType outtype_tx_pubkey =
Solver(tx_pubkey_script, v_solutions_ret_tx_pubkey);
174 assert(v_solutions_ret_tx_pubkey.size() == 1);
175 assert(v_solutions_ret_tx_pubkey[0].size() == 33);
177 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_multisig;
178 const TxoutType outtype_tx_multisig =
Solver(tx_multisig_script, v_solutions_ret_tx_multisig);
180 assert(v_solutions_ret_tx_multisig.size() == 3);
181 assert(v_solutions_ret_tx_multisig[0].size() == 1);
182 assert(v_solutions_ret_tx_multisig[1].size() == 33);
183 assert(v_solutions_ret_tx_multisig[2].size() == 1);
189 assert(
PKHash{pubkey} == *std::get_if<PKHash>(&tx_destination));
192 assert(script_for_destination.size() == 25);
197 const CPubKey pubkey_from_address_string =
AddrToPubKey(fillable_signing_provider, destination_address);
198 assert(pubkey_from_address_string == pubkey);
206 const bool ok_get_pubkey = fillable_signing_provider.
GetPubKey(key_id, pubkey_out);
210 const bool ok_get_key = fillable_signing_provider.
GetKey(key_id, key_out);
216 const bool ok_get_key_origin = fillable_signing_provider.
GetKeyOrigin(key_id, key_origin_info);
217 assert(!ok_get_key_origin);
221 const std::vector<unsigned char> vch_pubkey{pubkey.
begin(), pubkey.
end()};
225 const CPubKey pubkey_ctor_1{vch_pubkey};
226 assert(pubkey == pubkey_ctor_1);
228 const CPubKey pubkey_ctor_2{vch_pubkey.
begin(), vch_pubkey.end()};
229 assert(pubkey == pubkey_ctor_2);
232 pubkey_set.
Set(vch_pubkey.begin(), vch_pubkey.end());
233 assert(pubkey == pubkey_set);
237 const CPubKey invalid_pubkey{};
238 assert(!invalid_pubkey.IsValid());
239 assert(!invalid_pubkey.IsFullyValid());
240 assert(!(pubkey == invalid_pubkey));
241 assert(pubkey != invalid_pubkey);
242 assert(pubkey < invalid_pubkey);
247 unsigned int sum = 0;
248 for (
size_t i = 0; i < pubkey.
size(); ++i) {
255 CPubKey decompressed_pubkey = pubkey;
258 const bool ok = decompressed_pubkey.
Decompress();
265 std::vector<unsigned char> vch_sig;
266 const bool ok = key.
Sign(random_uint256, vch_sig,
false);
271 const std::vector<unsigned char> vch_invalid_sig{vch_sig.begin(), vch_sig.begin() + vch_sig.size() - 1};
272 assert(!pubkey.
Verify(random_uint256, vch_invalid_sig));
277 std::vector<unsigned char> vch_compact_sig;
278 const bool ok_sign_compact = key.
SignCompact(random_uint256, vch_compact_sig);
282 const bool ok_recover_compact = recover_pubkey.
RecoverCompact(random_uint256, vch_compact_sig);
283 assert(ok_recover_compact);
284 assert(recover_pubkey == pubkey);
290 const bool ok = pubkey.
Derive(child_pubkey, child_chaincode, 0, random_uint256);
292 assert(child_pubkey != pubkey);
297 assert(child_chaincode != random_uint256);
303 for (
const bool skip_check : {
true,
false}) {
305 const bool ok = loaded_key.
Load(priv_key, pubkey, skip_check);
307 assert(key == loaded_key);
319 auto ent32 = fdp.ConsumeBytes<std::byte>(32);
323 auto decoded_pubkey = encoded_ellswift.
Decode();
326 std::vector<unsigned char> sig;
328 assert(decoded_pubkey.Verify(hash, sig));
344 auto ent32_1 = fdp.ConsumeBytes<std::byte>(32);
349 auto ent32_2 = fdp.ConsumeBytes<std::byte>(32);
354 auto ent32_2_bad = fdp.ConsumeBytes<std::byte>(32);
355 ent32_2_bad.resize(32);
357 assert((ent32_2_bad == ent32_2) == (k2_ellswift_bad == k2_ellswift));
360 bool initiating = fdp.ConsumeBool();
367 assert(ecdh_secret_1 == ecdh_secret_2);
369 if (k1_ellswift != k2_ellswift) {
372 assert(ecdh_secret_bad != ecdh_secret_1);
375 if (k2_ellswift_bad != k2_ellswift) {
378 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.
bool Negate()
Negate 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.
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.
void ECC_Start()
Initialize the elliptic curve support.
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
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.