Bitcoin Core 29.99.0
P2P Digital Currency
scriptpubkeyman.cpp
Go to the documentation of this file.
1// Copyright (c) 2023-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <addresstype.h>
6#include <chainparams.h>
7#include <coins.h>
8#include <key.h>
10#include <psbt.h>
11#include <script/descriptor.h>
12#include <script/interpreter.h>
13#include <script/script.h>
15#include <sync.h>
17#include <test/fuzz/fuzz.h>
18#include <test/fuzz/util.h>
21#include <util/check.h>
22#include <util/time.h>
23#include <util/translation.h>
24#include <validation.h>
26#include <wallet/test/util.h>
27#include <wallet/types.h>
28#include <wallet/wallet.h>
29#include <wallet/walletutil.h>
30
31#include <map>
32#include <memory>
33#include <optional>
34#include <string>
35#include <utility>
36#include <variant>
37
38namespace wallet {
39namespace {
40const TestingSetup* g_setup;
41
44
45void initialize_spkm()
46{
47 static const auto testing_setup{MakeNoLogFileContext<const TestingSetup>()};
48 g_setup = testing_setup.get();
51}
52
58static bool TooDeepDerivPath(std::string_view desc)
59{
60 const FuzzBufferType desc_buf{reinterpret_cast<const unsigned char *>(desc.data()), desc.size()};
61 return HasDeepDerivPath(desc_buf);
62}
63
64static std::optional<std::pair<WalletDescriptor, FlatSigningProvider>> CreateWalletDescriptor(FuzzedDataProvider& fuzzed_data_provider)
65{
66 const std::string mocked_descriptor{fuzzed_data_provider.ConsumeRandomLengthString()};
67 if (TooDeepDerivPath(mocked_descriptor)) return {};
68 const auto desc_str{MOCKED_DESC_CONVERTER.GetDescriptor(mocked_descriptor)};
69 if (!desc_str.has_value()) return std::nullopt;
70
72 std::string error;
73 std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str.value(), keys, error, false);
74 if (parsed_descs.empty()) return std::nullopt;
75
76 WalletDescriptor w_desc{std::move(parsed_descs.at(0)), /*creation_time=*/0, /*range_start=*/0, /*range_end=*/1, /*next_index=*/1};
77 return std::make_pair(w_desc, keys);
78}
79
80static DescriptorScriptPubKeyMan* CreateDescriptor(WalletDescriptor& wallet_desc, FlatSigningProvider& keys, CWallet& keystore)
81{
82 LOCK(keystore.cs_wallet);
83 auto spk_manager_res = keystore.AddWalletDescriptor(wallet_desc, keys, /*label=*/"", /*internal=*/false);
84 if (!spk_manager_res) return nullptr;
85 return &spk_manager_res.value().get();
86};
87
88FUZZ_TARGET(scriptpubkeyman, .init = initialize_spkm)
89{
91 FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
92 SetMockTime(ConsumeTime(fuzzed_data_provider));
93 const auto& node{g_setup->m_node};
94 Chainstate& chainstate{node.chainman->ActiveChainstate()};
95 std::unique_ptr<CWallet> wallet_ptr{std::make_unique<CWallet>(node.chain.get(), "", CreateMockableWalletDatabase())};
96 CWallet& wallet{*wallet_ptr};
97 {
98 LOCK(wallet.cs_wallet);
99 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
100 wallet.SetLastBlockProcessed(chainstate.m_chain.Height(), chainstate.m_chain.Tip()->GetBlockHash());
101 wallet.m_keypool_size = 1;
102 }
103
104 auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
105 if (!wallet_desc.has_value()) return;
106 auto spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
107 if (spk_manager == nullptr) return;
108
109 if (fuzzed_data_provider.ConsumeBool()) {
110 auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
111 if (!wallet_desc.has_value()) {
112 return;
113 }
114 std::string error;
115 if (spk_manager->CanUpdateToWalletDescriptor(wallet_desc->first, error)) {
116 auto new_spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
117 if (new_spk_manager != nullptr) spk_manager = new_spk_manager;
118 }
119 }
120
121 bool good_data{true};
122 LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 20) {
123 CallOneOf(
124 fuzzed_data_provider,
125 [&] {
126 const CScript script{ConsumeScript(fuzzed_data_provider)};
127 auto is_mine{spk_manager->IsMine(script)};
128 if (is_mine == isminetype::ISMINE_SPENDABLE) {
129 assert(spk_manager->GetScriptPubKeys().count(script));
130 }
131 },
132 [&] {
133 auto spks{spk_manager->GetScriptPubKeys()};
134 for (const CScript& spk : spks) {
135 assert(spk_manager->IsMine(spk) == ISMINE_SPENDABLE);
136 CTxDestination dest;
137 bool extract_dest{ExtractDestination(spk, dest)};
138 if (extract_dest) {
139 const std::string msg{fuzzed_data_provider.ConsumeRandomLengthString()};
140 PKHash pk_hash{std::get_if<PKHash>(&dest) && fuzzed_data_provider.ConsumeBool() ?
141 *std::get_if<PKHash>(&dest) :
142 PKHash{ConsumeUInt160(fuzzed_data_provider)}};
143 std::string str_sig;
144 (void)spk_manager->SignMessage(msg, pk_hash, str_sig);
145 (void)spk_manager->GetMetadata(dest);
146 }
147 }
148 },
149 [&] {
150 auto spks{spk_manager->GetScriptPubKeys()};
151 if (!spks.empty()) {
152 auto& spk{PickValue(fuzzed_data_provider, spks)};
153 (void)spk_manager->MarkUnusedAddresses(spk);
154 }
155 },
156 [&] {
157 LOCK(spk_manager->cs_desc_man);
158 auto wallet_desc{spk_manager->GetWalletDescriptor()};
159 if (wallet_desc.descriptor->IsSingleType()) {
160 auto output_type{wallet_desc.descriptor->GetOutputType()};
161 if (output_type.has_value()) {
162 auto dest{spk_manager->GetNewDestination(*output_type)};
163 if (dest) {
165 assert(spk_manager->IsHDEnabled());
166 }
167 }
168 }
169 },
170 [&] {
172 const std::optional<CMutableTransaction> opt_tx_to{ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS)};
173 if (!opt_tx_to) {
174 good_data = false;
175 return;
176 }
177 tx_to = *opt_tx_to;
178
179 std::map<COutPoint, Coin> coins{ConsumeCoins(fuzzed_data_provider)};
180 const int sighash{fuzzed_data_provider.ConsumeIntegral<int>()};
181 std::map<int, bilingual_str> input_errors;
182 (void)spk_manager->SignTransaction(tx_to, coins, sighash, input_errors);
183 },
184 [&] {
185 std::optional<PartiallySignedTransaction> opt_psbt{ConsumeDeserializable<PartiallySignedTransaction>(fuzzed_data_provider)};
186 if (!opt_psbt) {
187 good_data = false;
188 return;
189 }
190 auto psbt{*opt_psbt};
192 std::optional<int> sighash_type{fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 151)};
193 if (sighash_type == 151) sighash_type = std::nullopt;
194 auto sign = fuzzed_data_provider.ConsumeBool();
195 auto bip32derivs = fuzzed_data_provider.ConsumeBool();
196 auto finalize = fuzzed_data_provider.ConsumeBool();
197 (void)spk_manager->FillPSBT(psbt, txdata, sighash_type, sign, bip32derivs, nullptr, finalize);
198 }
199 );
200 }
201
202 std::string descriptor;
203 (void)spk_manager->GetDescriptorString(descriptor, /*priv=*/fuzzed_data_provider.ConsumeBool());
204 (void)spk_manager->GetEndRange();
205 (void)spk_manager->GetKeyPoolSize();
206}
207
208} // namespace
209} // namespace wallet
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
Definition: addresstype.cpp:49
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:143
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:507
std::string ConsumeRandomLengthString(size_t max_length)
T ConsumeIntegralInRange(T min, T max)
Converts a mocked descriptor string to a valid one.
Definition: descriptor.h:21
void Init()
When initializing the target, populate the list of keys.
Definition: descriptor.cpp:10
std::optional< std::string > GetDescriptor(std::string_view mocked_desc) const
Get an actual descriptor string from a descriptor string whose keys were mocked.
Definition: descriptor.cpp:51
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:317
MockedDescriptorConverter MOCKED_DESC_CONVERTER
The converter of mocked descriptors, needs to be initialized when the target is.
std::span< const uint8_t > FuzzBufferType
Definition: fuzz.h:25
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
Definition: fuzz.h:22
static int sign(const secp256k1_context *ctx, struct signer_secrets *signer_secrets, struct signer *signer, const secp256k1_musig_keyagg_cache *cache, const unsigned char *msg32, unsigned char *sig64)
Definition: musig.c:106
Definition: messages.h:20
wallet::DescriptorScriptPubKeyMan * CreateDescriptor(CWallet &keystore, const std::string &desc_str, const bool success)
Definition: util.cpp:196
FUZZ_TARGET(coin_grinder)
std::unique_ptr< WalletDatabase > CreateMockableWalletDatabase(MockableData records)
Definition: util.cpp:186
@ ISMINE_SPENDABLE
Definition: types.h:44
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition: walletutil.h:74
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction &psbt)
Compute a PrecomputedTransactionData object from a psbt.
Definition: psbt.cpp:361
node::NodeContext m_node
Definition: setup_common.h:66
A mutable version of CTransaction.
Definition: transaction.h:378
Testing setup that configures a complete environment.
Definition: setup_common.h:121
#define LOCK(cs)
Definition: sync.h:257
bool HasDeepDerivPath(const FuzzBufferType &buff, const int max_depth)
Whether the buffer, if it represents a valid descriptor, contains a derivation path deeper than a giv...
Definition: descriptor.cpp:77
CScript ConsumeScript(FuzzedDataProvider &fuzzed_data_provider, const bool maybe_p2wsh) noexcept
Definition: util.cpp:93
int64_t ConsumeTime(FuzzedDataProvider &fuzzed_data_provider, const std::optional< int64_t > &min, const std::optional< int64_t > &max) noexcept
Definition: util.cpp:34
std::map< COutPoint, Coin > ConsumeCoins(FuzzedDataProvider &fuzzed_data_provider) noexcept
Definition: util.cpp:166
auto & PickValue(FuzzedDataProvider &fuzzed_data_provider, Collection &col)
Definition: util.h:47
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)
Definition: util.h:35
uint160 ConsumeUInt160(FuzzedDataProvider &fuzzed_data_provider) noexcept
Definition: util.h:162
void SeedRandomStateForTest(SeedRand seedtype)
Seed the global RNG state for testing and log the seed value.
Definition: random.cpp:19
@ ZEROS
Seed with a compile time constant of zeros.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40
assert(!tx.IsCoinBase())
is a home for public enum and struct type definitions that are used by internally by wallet code,...