Branch data Line data Source code
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>
9 : : #include <primitives/transaction.h>
10 : : #include <psbt.h>
11 : : #include <script/descriptor.h>
12 : : #include <script/interpreter.h>
13 : : #include <script/script.h>
14 : : #include <script/signingprovider.h>
15 : : #include <sync.h>
16 : : #include <test/fuzz/FuzzedDataProvider.h>
17 : : #include <test/fuzz/fuzz.h>
18 : : #include <test/fuzz/util.h>
19 : : #include <test/fuzz/util/descriptor.h>
20 : : #include <test/util/setup_common.h>
21 : : #include <util/check.h>
22 : : #include <util/time.h>
23 : : #include <util/translation.h>
24 : : #include <validation.h>
25 : : #include <wallet/scriptpubkeyman.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 : :
38 : : namespace wallet {
39 : : namespace {
40 : : const TestingSetup* g_setup;
41 : :
42 : : //! The converter of mocked descriptors, needs to be initialized when the target is.
43 : : MockedDescriptorConverter MOCKED_DESC_CONVERTER;
44 : :
45 : 1 : void initialize_spkm()
46 : : {
47 [ + - + - ]: 2 : static const auto testing_setup{MakeNoLogFileContext<const TestingSetup>()};
48 : 1 : g_setup = testing_setup.get();
49 : 1 : SelectParams(ChainType::MAIN);
50 : 1 : MOCKED_DESC_CONVERTER.Init();
51 [ + - ]: 2 : }
52 : :
53 : : /**
54 : : * Key derivation is expensive. Deriving deep derivation paths take a lot of compute and we'd rather spend time
55 : : * elsewhere in this target, like on actually fuzzing the DescriptorScriptPubKeyMan. So rule out strings which could
56 : : * correspond to a descriptor containing a too large derivation path.
57 : : */
58 : 14418 : static bool TooDeepDerivPath(std::string_view desc)
59 : : {
60 : 14418 : const FuzzBufferType desc_buf{reinterpret_cast<const unsigned char *>(desc.data()), desc.size()};
61 : 14418 : return HasDeepDerivPath(desc_buf);
62 : : }
63 : :
64 : 14418 : static std::optional<std::pair<WalletDescriptor, FlatSigningProvider>> CreateWalletDescriptor(FuzzedDataProvider& fuzzed_data_provider)
65 : : {
66 : 14418 : const std::string mocked_descriptor{fuzzed_data_provider.ConsumeRandomLengthString()};
67 [ + - + + ]: 14418 : if (TooDeepDerivPath(mocked_descriptor)) return {};
68 [ + - ]: 14328 : const auto desc_str{MOCKED_DESC_CONVERTER.GetDescriptor(mocked_descriptor)};
69 [ + + ]: 14328 : if (!desc_str.has_value()) return std::nullopt;
70 : :
71 : 13292 : FlatSigningProvider keys;
72 [ + - ]: 13292 : std::string error;
73 [ + - + - ]: 13292 : std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str.value(), keys, error, false);
74 [ + + ]: 13292 : if (parsed_descs.empty()) return std::nullopt;
75 : :
76 [ + - + - : 9833 : WalletDescriptor w_desc{std::move(parsed_descs.at(0)), /*creation_time=*/0, /*range_start=*/0, /*range_end=*/1, /*next_index=*/1};
+ - ]
77 [ + - ]: 9833 : return std::make_pair(w_desc, keys);
78 : 42038 : }
79 : :
80 : 8508 : static DescriptorScriptPubKeyMan* CreateDescriptor(WalletDescriptor& wallet_desc, FlatSigningProvider& keys, CWallet& keystore)
81 : : {
82 : 8508 : LOCK(keystore.cs_wallet);
83 [ + - + - ]: 8508 : keystore.AddWalletDescriptor(wallet_desc, keys, /*label=*/"", /*internal=*/false);
84 [ + - + - ]: 8508 : return keystore.GetDescriptorScriptPubKeyMan(wallet_desc);
85 : 8508 : };
86 : :
87 [ + - ]: 10600 : FUZZ_TARGET(scriptpubkeyman, .init = initialize_spkm)
88 : : {
89 : 10168 : SeedRandomStateForTest(SeedRand::ZEROS);
90 : 10168 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
91 : 10168 : SetMockTime(ConsumeTime(fuzzed_data_provider));
92 : 10168 : const auto& node{g_setup->m_node};
93 : 10168 : Chainstate& chainstate{node.chainman->ActiveChainstate()};
94 [ + - + - ]: 10168 : std::unique_ptr<CWallet> wallet_ptr{std::make_unique<CWallet>(node.chain.get(), "", CreateMockableWalletDatabase())};
95 [ + - ]: 10168 : CWallet& wallet{*wallet_ptr};
96 : 10168 : {
97 [ + - ]: 10168 : LOCK(wallet.cs_wallet);
98 [ + - ]: 10168 : wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
99 [ + - + - ]: 20336 : wallet.SetLastBlockProcessed(chainstate.m_chain.Height(), chainstate.m_chain.Tip()->GetBlockHash());
100 [ + - ]: 10168 : wallet.m_keypool_size = 1;
101 : 0 : }
102 : :
103 [ + - ]: 10168 : auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
104 [ + + ]: 10168 : if (!wallet_desc.has_value()) return;
105 [ + - ]: 8373 : auto spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
106 [ + - ]: 8373 : if (spk_manager == nullptr) return;
107 : :
108 [ + + ]: 8373 : if (fuzzed_data_provider.ConsumeBool()) {
109 [ + - ]: 4250 : auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
110 [ + + ]: 4250 : if (!wallet_desc.has_value()) {
111 : 2790 : return;
112 : : }
113 [ + - ]: 1460 : std::string error;
114 [ + - + + ]: 1460 : if (spk_manager->CanUpdateToWalletDescriptor(wallet_desc->first, error)) {
115 [ + - ]: 135 : auto new_spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
116 [ + - ]: 135 : if (new_spk_manager != nullptr) spk_manager = new_spk_manager;
117 : : }
118 [ + - ]: 5710 : }
119 : :
120 : 5583 : bool good_data{true};
121 [ + + + + : 59246 : LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 20) {
+ + ]
122 [ + - ]: 24500 : CallOneOf(
123 : : fuzzed_data_provider,
124 : 1585 : [&] {
125 : 1585 : const CScript script{ConsumeScript(fuzzed_data_provider)};
126 [ + - ]: 1585 : auto is_mine{spk_manager->IsMine(script)};
127 [ + + ]: 1585 : if (is_mine == isminetype::ISMINE_SPENDABLE) {
128 [ + - - + ]: 9 : assert(spk_manager->GetScriptPubKeys().count(script));
129 : : }
130 : 1585 : },
131 : 8740 : [&] {
132 : 8740 : auto spks{spk_manager->GetScriptPubKeys()};
133 [ + + ]: 36115 : for (const CScript& spk : spks) {
134 [ + - - + ]: 27375 : assert(spk_manager->IsMine(spk) == ISMINE_SPENDABLE);
135 : 27375 : CTxDestination dest;
136 [ + - ]: 27375 : bool extract_dest{ExtractDestination(spk, dest)};
137 [ + + ]: 27375 : if (extract_dest) {
138 [ + - ]: 20414 : const std::string msg{fuzzed_data_provider.ConsumeRandomLengthString()};
139 [ + + + + ]: 20414 : PKHash pk_hash{std::get_if<PKHash>(&dest) && fuzzed_data_provider.ConsumeBool() ?
140 : 7330 : *std::get_if<PKHash>(&dest) :
141 : 20414 : PKHash{ConsumeUInt160(fuzzed_data_provider)}};
142 [ + - ]: 20414 : std::string str_sig;
143 [ + - ]: 20414 : (void)spk_manager->SignMessage(msg, pk_hash, str_sig);
144 [ + - ]: 20414 : (void)spk_manager->GetMetadata(dest);
145 : 20414 : }
146 : 27375 : }
147 : 8740 : },
148 : 1260 : [&] {
149 : 1260 : auto spks{spk_manager->GetScriptPubKeys()};
150 [ + + ]: 1260 : if (!spks.empty()) {
151 : 1199 : auto& spk{PickValue(fuzzed_data_provider, spks)};
152 [ + - ]: 1199 : (void)spk_manager->MarkUnusedAddresses(spk);
153 : : }
154 : 1260 : },
155 : 8294 : [&] {
156 : 8294 : LOCK(spk_manager->cs_desc_man);
157 [ + - ]: 8294 : auto wallet_desc{spk_manager->GetWalletDescriptor()};
158 [ + - + + ]: 8294 : if (wallet_desc.descriptor->IsSingleType()) {
159 [ + - ]: 8047 : auto output_type{wallet_desc.descriptor->GetOutputType()};
160 [ + + ]: 8047 : if (output_type.has_value()) {
161 [ + - ]: 5738 : auto dest{spk_manager->GetNewDestination(*output_type)};
162 [ + + ]: 5738 : if (dest) {
163 [ + - - + ]: 2526 : assert(IsValidDestination(*dest));
164 [ + - - + ]: 2526 : assert(spk_manager->IsHDEnabled());
165 : : }
166 : 5738 : }
167 : : }
168 [ + - ]: 16588 : },
169 : 1717 : [&] {
170 : 1717 : CMutableTransaction tx_to;
171 : 1717 : const std::optional<CMutableTransaction> opt_tx_to{ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS)};
172 [ + + ]: 1717 : if (!opt_tx_to) {
173 : 192 : good_data = false;
174 [ - + ]: 192 : return;
175 : : }
176 [ + - ]: 1525 : tx_to = *opt_tx_to;
177 : :
178 : 1525 : std::map<COutPoint, Coin> coins{ConsumeCoins(fuzzed_data_provider)};
179 : 1525 : const int sighash{fuzzed_data_provider.ConsumeIntegral<int>()};
180 [ + - ]: 1525 : std::map<int, bilingual_str> input_errors;
181 [ + - ]: 1525 : (void)spk_manager->SignTransaction(tx_to, coins, sighash, input_errors);
182 [ + - ]: 4959 : },
183 : 2904 : [&] {
184 : 2904 : std::optional<PartiallySignedTransaction> opt_psbt{ConsumeDeserializable<PartiallySignedTransaction>(fuzzed_data_provider)};
185 [ + + ]: 2904 : if (!opt_psbt) {
186 : 728 : good_data = false;
187 : 728 : return;
188 : : }
189 [ + - ]: 2176 : auto psbt{*opt_psbt};
190 [ + - ]: 2176 : const PrecomputedTransactionData txdata{PrecomputePSBTData(psbt)};
191 : 2176 : const int sighash_type{fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 150)};
192 : 2176 : auto sign = fuzzed_data_provider.ConsumeBool();
193 : 2176 : auto bip32derivs = fuzzed_data_provider.ConsumeBool();
194 : 2176 : auto finalize = fuzzed_data_provider.ConsumeBool();
195 [ + - ]: 2176 : (void)spk_manager->FillPSBT(psbt, txdata, sighash_type, sign, bip32derivs, nullptr, finalize);
196 : 2904 : }
197 : : );
198 : : }
199 : :
200 : 5583 : std::string descriptor;
201 [ + - ]: 5583 : (void)spk_manager->GetDescriptorString(descriptor, /*priv=*/fuzzed_data_provider.ConsumeBool());
202 [ + - ]: 5583 : (void)spk_manager->GetEndRange();
203 [ + - ]: 5583 : (void)spk_manager->GetKeyPoolSize();
204 [ + - + - : 25919 : }
+ - ]
205 : :
206 : : } // namespace
207 : : } // namespace wallet
|
