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/translation.h>
23 : : #include <validation.h>
24 : : #include <wallet/scriptpubkeyman.h>
25 : : #include <wallet/test/util.h>
26 : : #include <wallet/types.h>
27 : : #include <wallet/wallet.h>
28 : : #include <wallet/walletutil.h>
29 : :
30 : : #include <map>
31 : : #include <memory>
32 : : #include <optional>
33 : : #include <string>
34 : : #include <utility>
35 : : #include <variant>
36 : :
37 : : namespace wallet {
38 : : namespace {
39 : : const TestingSetup* g_setup;
40 : :
41 : : //! The converter of mocked descriptors, needs to be initialized when the target is.
42 : : MockedDescriptorConverter MOCKED_DESC_CONVERTER;
43 : :
44 : 1 : void initialize_spkm()
45 : : {
46 [ + - + - ]: 2 : static const auto testing_setup{MakeNoLogFileContext<const TestingSetup>()};
47 : 1 : g_setup = testing_setup.get();
48 : 1 : SelectParams(ChainType::MAIN);
49 : 1 : MOCKED_DESC_CONVERTER.Init();
50 [ + - ]: 2 : }
51 : :
52 : : /**
53 : : * Key derivation is expensive. Deriving deep derivation paths take a lot of compute and we'd rather spend time
54 : : * elsewhere in this target, like on actually fuzzing the DescriptorScriptPubKeyMan. So rule out strings which could
55 : : * correspond to a descriptor containing a too large derivation path.
56 : : */
57 : 7455 : static bool TooDeepDerivPath(std::string_view desc)
58 : : {
59 : 7455 : const FuzzBufferType desc_buf{reinterpret_cast<const unsigned char *>(desc.data()), desc.size()};
60 : 7455 : return HasDeepDerivPath(desc_buf);
61 : : }
62 : :
63 : 7455 : static std::optional<std::pair<WalletDescriptor, FlatSigningProvider>> CreateWalletDescriptor(FuzzedDataProvider& fuzzed_data_provider)
64 : : {
65 : 7455 : const std::string mocked_descriptor{fuzzed_data_provider.ConsumeRandomLengthString()};
66 [ + - + + ]: 7455 : if (TooDeepDerivPath(mocked_descriptor)) return {};
67 [ + - ]: 7449 : const auto desc_str{MOCKED_DESC_CONVERTER.GetDescriptor(mocked_descriptor)};
68 [ + + ]: 7449 : if (!desc_str.has_value()) return std::nullopt;
69 : :
70 : 7340 : FlatSigningProvider keys;
71 [ + - ]: 7340 : std::string error;
72 [ + - + - ]: 7340 : std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str.value(), keys, error, false);
73 [ + + ]: 7340 : if (parsed_descs.empty()) return std::nullopt;
74 : :
75 [ + - + - : 5948 : WalletDescriptor w_desc{std::move(parsed_descs.at(0)), /*creation_time=*/0, /*range_start=*/0, /*range_end=*/1, /*next_index=*/1};
+ - ]
76 [ + - ]: 5948 : return std::make_pair(w_desc, keys);
77 : 22244 : }
78 : :
79 : 5195 : static DescriptorScriptPubKeyMan* CreateDescriptor(WalletDescriptor& wallet_desc, FlatSigningProvider& keys, CWallet& keystore)
80 : : {
81 : 5195 : LOCK(keystore.cs_wallet);
82 [ + - + - ]: 5195 : keystore.AddWalletDescriptor(wallet_desc, keys, /*label=*/"", /*internal=*/false);
83 [ + - + - ]: 5195 : return keystore.GetDescriptorScriptPubKeyMan(wallet_desc);
84 : 5195 : };
85 : :
86 [ + - ]: 6369 : FUZZ_TARGET(scriptpubkeyman, .init = initialize_spkm)
87 : : {
88 : 5957 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
89 : 5957 : const auto& node{g_setup->m_node};
90 : 5957 : Chainstate& chainstate{node.chainman->ActiveChainstate()};
91 [ + - + - ]: 5957 : std::unique_ptr<CWallet> wallet_ptr{std::make_unique<CWallet>(node.chain.get(), "", CreateMockableWalletDatabase())};
92 [ + - ]: 5957 : CWallet& wallet{*wallet_ptr};
93 : 5957 : {
94 [ + - ]: 5957 : LOCK(wallet.cs_wallet);
95 [ + - ]: 5957 : wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
96 [ + - + - ]: 11914 : wallet.SetLastBlockProcessed(chainstate.m_chain.Height(), chainstate.m_chain.Tip()->GetBlockHash());
97 [ + - ]: 5957 : wallet.m_keypool_size = 1;
98 : 0 : }
99 : :
100 [ + - ]: 5957 : auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
101 [ + + ]: 5957 : if (!wallet_desc.has_value()) return;
102 [ + - ]: 4744 : auto spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
103 [ + - ]: 4744 : if (spk_manager == nullptr) return;
104 : :
105 [ + + ]: 4744 : if (fuzzed_data_provider.ConsumeBool()) {
106 [ + - ]: 1498 : auto wallet_desc{CreateWalletDescriptor(fuzzed_data_provider)};
107 [ + + ]: 1498 : if (!wallet_desc.has_value()) {
108 : 294 : return;
109 : : }
110 [ + - ]: 1204 : std::string error;
111 [ + - + + ]: 1204 : if (spk_manager->CanUpdateToWalletDescriptor(wallet_desc->first, error)) {
112 [ + - ]: 451 : auto new_spk_manager{CreateDescriptor(wallet_desc->first, wallet_desc->second, wallet)};
113 [ + - ]: 451 : if (new_spk_manager != nullptr) spk_manager = new_spk_manager;
114 : : }
115 [ + - ]: 2702 : }
116 : :
117 : 4450 : bool good_data{true};
118 [ + + + + : 48508 : LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 20) {
+ + ]
119 [ + - ]: 20383 : CallOneOf(
120 : : fuzzed_data_provider,
121 : 1670 : [&] {
122 : 1670 : const CScript script{ConsumeScript(fuzzed_data_provider)};
123 [ + - ]: 1670 : auto is_mine{spk_manager->IsMine(script)};
124 [ + + ]: 1670 : if (is_mine == isminetype::ISMINE_SPENDABLE) {
125 [ + - - + ]: 105 : assert(spk_manager->GetScriptPubKeys().count(script));
126 : : }
127 : 1670 : },
128 : 5563 : [&] {
129 : 5563 : auto spks{spk_manager->GetScriptPubKeys()};
130 [ + + ]: 19340 : for (const CScript& spk : spks) {
131 [ + - - + ]: 13777 : assert(spk_manager->IsMine(spk) == ISMINE_SPENDABLE);
132 : 13777 : CTxDestination dest;
133 [ + - ]: 13777 : bool extract_dest{ExtractDestination(spk, dest)};
134 [ + + ]: 13777 : if (extract_dest) {
135 [ + - ]: 10796 : const std::string msg{fuzzed_data_provider.ConsumeRandomLengthString()};
136 [ + + + + ]: 10796 : PKHash pk_hash{std::get_if<PKHash>(&dest) && fuzzed_data_provider.ConsumeBool() ?
137 : 4113 : *std::get_if<PKHash>(&dest) :
138 : 10796 : PKHash{ConsumeUInt160(fuzzed_data_provider)}};
139 [ + - ]: 10796 : std::string str_sig;
140 [ + - ]: 10796 : (void)spk_manager->SignMessage(msg, pk_hash, str_sig);
141 [ + - ]: 10796 : (void)spk_manager->GetMetadata(dest);
142 : 10796 : }
143 : 13777 : }
144 : 5563 : },
145 : 1456 : [&] {
146 : 1456 : auto spks{spk_manager->GetScriptPubKeys()};
147 [ + + ]: 1456 : if (!spks.empty()) {
148 : 1359 : auto& spk{PickValue(fuzzed_data_provider, spks)};
149 [ + - ]: 1359 : (void)spk_manager->MarkUnusedAddresses(spk);
150 : : }
151 : 1456 : },
152 : 6228 : [&] {
153 : 6228 : LOCK(spk_manager->cs_desc_man);
154 [ + - ]: 6228 : auto wallet_desc{spk_manager->GetWalletDescriptor()};
155 [ + - + + ]: 6228 : if (wallet_desc.descriptor->IsSingleType()) {
156 [ + - ]: 6019 : auto output_type{wallet_desc.descriptor->GetOutputType()};
157 [ + + ]: 6019 : if (output_type.has_value()) {
158 [ + - ]: 4516 : auto dest{spk_manager->GetNewDestination(*output_type)};
159 [ + + ]: 4516 : if (dest) {
160 [ + - - + ]: 3108 : assert(IsValidDestination(*dest));
161 [ + - - + ]: 3108 : assert(spk_manager->IsHDEnabled());
162 : : }
163 : 4516 : }
164 : : }
165 [ + - ]: 12456 : },
166 : 2529 : [&] {
167 : 2529 : CMutableTransaction tx_to;
168 : 2529 : const std::optional<CMutableTransaction> opt_tx_to{ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS)};
169 [ + + ]: 2529 : if (!opt_tx_to) {
170 : 149 : good_data = false;
171 [ - + ]: 149 : return;
172 : : }
173 [ + - ]: 2380 : tx_to = *opt_tx_to;
174 : :
175 : 2380 : std::map<COutPoint, Coin> coins{ConsumeCoins(fuzzed_data_provider)};
176 : 2380 : const int sighash{fuzzed_data_provider.ConsumeIntegral<int>()};
177 [ + - ]: 2380 : std::map<int, bilingual_str> input_errors;
178 [ + - ]: 2380 : (void)spk_manager->SignTransaction(tx_to, coins, sighash, input_errors);
179 [ + - ]: 7438 : },
180 : 2937 : [&] {
181 : 2937 : std::optional<PartiallySignedTransaction> opt_psbt{ConsumeDeserializable<PartiallySignedTransaction>(fuzzed_data_provider)};
182 [ + + ]: 2937 : if (!opt_psbt) {
183 : 1009 : good_data = false;
184 : 1009 : return;
185 : : }
186 [ + - ]: 1928 : auto psbt{*opt_psbt};
187 [ + - ]: 1928 : const PrecomputedTransactionData txdata{PrecomputePSBTData(psbt)};
188 : 1928 : const int sighash_type{fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 150)};
189 : 1928 : auto sign = fuzzed_data_provider.ConsumeBool();
190 : 1928 : auto bip32derivs = fuzzed_data_provider.ConsumeBool();
191 : 1928 : auto finalize = fuzzed_data_provider.ConsumeBool();
192 [ + - ]: 1928 : (void)spk_manager->FillPSBT(psbt, txdata, sighash_type, sign, bip32derivs, nullptr, finalize);
193 : 2937 : }
194 : : );
195 : : }
196 : :
197 : 4450 : std::string descriptor;
198 [ + - ]: 4450 : (void)spk_manager->GetDescriptorString(descriptor, /*priv=*/fuzzed_data_provider.ConsumeBool());
199 [ + - ]: 4450 : (void)spk_manager->GetEndRange();
200 [ + - ]: 4450 : (void)spk_manager->GetKeyPoolSize();
201 [ + - + - : 16364 : }
+ - ]
202 : :
203 : : } // namespace
204 : : } // namespace wallet
|
