Branch data Line data Source code
1 : : // Copyright (c) 2019-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 <hash.h>
6 : : #include <key_io.h>
7 : : #include <logging.h>
8 : : #include <node/types.h>
9 : : #include <outputtype.h>
10 : : #include <script/descriptor.h>
11 : : #include <script/script.h>
12 : : #include <script/sign.h>
13 : : #include <script/solver.h>
14 : : #include <util/bip32.h>
15 : : #include <util/check.h>
16 : : #include <util/strencodings.h>
17 : : #include <util/string.h>
18 : : #include <util/time.h>
19 : : #include <util/translation.h>
20 : : #include <wallet/scriptpubkeyman.h>
21 : :
22 : : #include <optional>
23 : :
24 : : using common::PSBTError;
25 : : using util::ToString;
26 : :
27 : : namespace wallet {
28 : :
29 : : typedef std::vector<unsigned char> valtype;
30 : :
31 : : // Legacy wallet IsMine(). Used only in migration
32 : : // DO NOT USE ANYTHING IN THIS NAMESPACE OUTSIDE OF MIGRATION
33 : : namespace {
34 : :
35 : : /**
36 : : * This is an enum that tracks the execution context of a script, similar to
37 : : * SigVersion in script/interpreter. It is separate however because we want to
38 : : * distinguish between top-level scriptPubKey execution and P2SH redeemScript
39 : : * execution (a distinction that has no impact on consensus rules).
40 : : */
41 : : enum class IsMineSigVersion
42 : : {
43 : : TOP = 0, //!< scriptPubKey execution
44 : : P2SH = 1, //!< P2SH redeemScript
45 : : WITNESS_V0 = 2, //!< P2WSH witness script execution
46 : : };
47 : :
48 : : /**
49 : : * This is an internal representation of isminetype + invalidity.
50 : : * Its order is significant, as we return the max of all explored
51 : : * possibilities.
52 : : */
53 : : enum class IsMineResult
54 : : {
55 : : NO = 0, //!< Not ours
56 : : WATCH_ONLY = 1, //!< Included in watch-only balance
57 : : SPENDABLE = 2, //!< Included in all balances
58 : : INVALID = 3, //!< Not spendable by anyone (uncompressed pubkey in segwit, P2SH inside P2SH or witness, witness inside witness)
59 : : };
60 : :
61 : 1925 : bool PermitsUncompressed(IsMineSigVersion sigversion)
62 : : {
63 : 1925 : return sigversion == IsMineSigVersion::TOP || sigversion == IsMineSigVersion::P2SH;
64 : : }
65 : :
66 : 48 : bool HaveKeys(const std::vector<valtype>& pubkeys, const LegacyDataSPKM& keystore)
67 : : {
68 [ + + ]: 114 : for (const valtype& pubkey : pubkeys) {
69 [ - + ]: 105 : CKeyID keyID = CPubKey(pubkey).GetID();
70 [ + + ]: 105 : if (!keystore.HaveKey(keyID)) return false;
71 : : }
72 : : return true;
73 : : }
74 : :
75 : : //! Recursively solve script and return spendable/watchonly/invalid status.
76 : : //!
77 : : //! @param keystore legacy key and script store
78 : : //! @param scriptPubKey script to solve
79 : : //! @param sigversion script type (top-level / redeemscript / witnessscript)
80 : : //! @param recurse_scripthash whether to recurse into nested p2sh and p2wsh
81 : : //! scripts or simply treat any script that has been
82 : : //! stored in the keystore as spendable
83 : : // NOLINTNEXTLINE(misc-no-recursion)
84 : 5353 : IsMineResult LegacyWalletIsMineInnerDONOTUSE(const LegacyDataSPKM& keystore, const CScript& scriptPubKey, IsMineSigVersion sigversion, bool recurse_scripthash=true)
85 : : {
86 : 5353 : IsMineResult ret = IsMineResult::NO;
87 : :
88 : 5353 : std::vector<valtype> vSolutions;
89 [ + - ]: 5353 : TxoutType whichType = Solver(scriptPubKey, vSolutions);
90 : :
91 [ + + + + : 5353 : CKeyID keyID;
+ + + ]
92 [ + + + + : 5353 : switch (whichType) {
+ + + ]
93 : : case TxoutType::NONSTANDARD:
94 : : case TxoutType::NULL_DATA:
95 : : case TxoutType::WITNESS_UNKNOWN:
96 : : case TxoutType::WITNESS_V1_TAPROOT:
97 : : case TxoutType::ANCHOR:
98 : : break;
99 : 420 : case TxoutType::PUBKEY:
100 [ - + + - ]: 420 : keyID = CPubKey(vSolutions[0]).GetID();
101 [ - + - - : 420 : if (!PermitsUncompressed(sigversion) && vSolutions[0].size() != 33) {
- - ]
102 : : return IsMineResult::INVALID;
103 : : }
104 [ + - + + ]: 420 : if (keystore.HaveKey(keyID)) {
105 [ - + ]: 390 : ret = std::max(ret, IsMineResult::SPENDABLE);
106 : : }
107 : : break;
108 : 1028 : case TxoutType::WITNESS_V0_KEYHASH:
109 : 1028 : {
110 [ + - ]: 1028 : if (sigversion == IsMineSigVersion::WITNESS_V0) {
111 : : // P2WPKH inside P2WSH is invalid.
112 : : return IsMineResult::INVALID;
113 : : }
114 [ + + + - : 1449 : if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
- + + - +
- + + +
+ ]
115 : : // We do not support bare witness outputs unless the P2SH version of it would be
116 : : // acceptable as well. This protects against matching before segwit activates.
117 : : // This also applies to the P2WSH case.
118 : : break;
119 : : }
120 [ - + + - : 1039 : ret = std::max(ret, LegacyWalletIsMineInnerDONOTUSE(keystore, GetScriptForDestination(PKHash(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
+ - + + ]
121 : 1015 : break;
122 : : }
123 : 1457 : case TxoutType::PUBKEYHASH:
124 [ - + + + ]: 1457 : keyID = CKeyID(uint160(vSolutions[0]));
125 [ + + ]: 1457 : if (!PermitsUncompressed(sigversion)) {
126 [ + - ]: 1033 : CPubKey pubkey;
127 [ + - + - : 1033 : if (keystore.GetPubKey(keyID, pubkey) && !pubkey.IsCompressed()) {
+ + ]
128 : : return IsMineResult::INVALID;
129 : : }
130 : : }
131 [ + - + + ]: 1452 : if (keystore.HaveKey(keyID)) {
132 [ - + ]: 1384 : ret = std::max(ret, IsMineResult::SPENDABLE);
133 : : }
134 : : break;
135 : 1542 : case TxoutType::SCRIPTHASH:
136 : 1542 : {
137 [ + + ]: 1542 : if (sigversion != IsMineSigVersion::TOP) {
138 : : // P2SH inside P2WSH or P2SH is invalid.
139 : : return IsMineResult::INVALID;
140 : : }
141 [ - + + - ]: 1532 : CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
142 : 1532 : CScript subscript;
143 [ + - + + ]: 1532 : if (keystore.GetCScript(scriptID, subscript)) {
144 [ + + + - : 739 : ret = std::max(ret, recurse_scripthash ? LegacyWalletIsMineInnerDONOTUSE(keystore, subscript, IsMineSigVersion::P2SH) : IsMineResult::SPENDABLE);
+ + ]
145 : : }
146 : 1532 : break;
147 : 1532 : }
148 : 827 : case TxoutType::WITNESS_V0_SCRIPTHASH:
149 : 827 : {
150 [ + + ]: 827 : if (sigversion == IsMineSigVersion::WITNESS_V0) {
151 : : // P2WSH inside P2WSH is invalid.
152 : : return IsMineResult::INVALID;
153 : : }
154 [ + + + - : 1612 : if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
- + + - +
- + + +
+ ]
155 : : break;
156 : : }
157 [ - + + - ]: 76 : CScriptID scriptID{RIPEMD160(vSolutions[0])};
158 : 76 : CScript subscript;
159 [ + - + + ]: 76 : if (keystore.GetCScript(scriptID, subscript)) {
160 [ + + + - : 96 : ret = std::max(ret, recurse_scripthash ? LegacyWalletIsMineInnerDONOTUSE(keystore, subscript, IsMineSigVersion::WITNESS_V0) : IsMineResult::SPENDABLE);
+ + ]
161 : : }
162 : 76 : break;
163 : 76 : }
164 : :
165 : 55 : case TxoutType::MULTISIG:
166 : 55 : {
167 : : // Never treat bare multisig outputs as ours (they can still be made watchonly-though)
168 [ + + ]: 55 : if (sigversion == IsMineSigVersion::TOP) {
169 : : break;
170 : : }
171 : :
172 : : // Only consider transactions "mine" if we own ALL the
173 : : // keys involved. Multi-signature transactions that are
174 : : // partially owned (somebody else has a key that can spend
175 : : // them) enable spend-out-from-under-you attacks, especially
176 : : // in shared-wallet situations.
177 [ - + + - ]: 48 : std::vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
178 [ + + ]: 48 : if (!PermitsUncompressed(sigversion)) {
179 [ - + + + ]: 116 : for (size_t i = 0; i < keys.size(); i++) {
180 [ - + - + ]: 83 : if (keys[i].size() != 33) {
181 : 0 : return IsMineResult::INVALID;
182 : : }
183 : : }
184 : : }
185 [ + - + + ]: 48 : if (HaveKeys(keys, keystore)) {
186 [ - + ]: 9 : ret = std::max(ret, IsMineResult::SPENDABLE);
187 : : }
188 : 48 : break;
189 : 48 : }
190 : : } // no default case, so the compiler can warn about missing cases
191 : :
192 [ + + + - : 5333 : if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
+ + ]
193 [ - + ]: 148 : ret = std::max(ret, IsMineResult::WATCH_ONLY);
194 : : }
195 : 5333 : return ret;
196 : 5353 : }
197 : :
198 : : } // namespace
199 : :
200 : 3041 : bool LegacyDataSPKM::IsMine(const CScript& script) const
201 : : {
202 [ + - + ]: 3041 : switch (LegacyWalletIsMineInnerDONOTUSE(*this, script, IsMineSigVersion::TOP)) {
203 : : case IsMineResult::INVALID:
204 : : case IsMineResult::NO:
205 : : return false;
206 : 1931 : case IsMineResult::WATCH_ONLY:
207 : 1931 : case IsMineResult::SPENDABLE:
208 : 1931 : return true;
209 : : }
210 : 0 : assert(false);
211 : : }
212 : :
213 : 1 : bool LegacyDataSPKM::CheckDecryptionKey(const CKeyingMaterial& master_key)
214 : : {
215 : 1 : {
216 : 1 : LOCK(cs_KeyStore);
217 [ - + ]: 1 : assert(mapKeys.empty());
218 : :
219 [ + - ]: 1 : bool keyPass = mapCryptedKeys.empty(); // Always pass when there are no encrypted keys
220 : 1 : bool keyFail = false;
221 [ + - ]: 1 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
222 [ + - + - ]: 1 : WalletBatch batch(m_storage.GetDatabase());
223 [ + - ]: 1 : for (; mi != mapCryptedKeys.end(); ++mi)
224 : : {
225 [ - + ]: 1 : const CPubKey &vchPubKey = (*mi).second.first;
226 : 1 : const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
227 : 1 : CKey key;
228 [ - + + - : 1 : if (!DecryptKey(master_key, vchCryptedSecret, vchPubKey, key))
+ - ]
229 : : {
230 : : keyFail = true;
231 : : break;
232 : : }
233 : 1 : keyPass = true;
234 [ - + ]: 1 : if (fDecryptionThoroughlyChecked)
235 : : break;
236 : : else {
237 : : // Rewrite these encrypted keys with checksums
238 [ # # # # : 0 : batch.WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
# # ]
239 : : }
240 : 1 : }
241 [ - + ]: 1 : if (keyPass && keyFail)
242 : : {
243 [ # # ]: 0 : LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
244 [ # # ]: 0 : throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
245 : : }
246 [ - + ]: 1 : if (keyFail || !keyPass)
247 : 0 : return false;
248 : 1 : fDecryptionThoroughlyChecked = true;
249 [ - - + - ]: 1 : }
250 : 1 : return true;
251 : : }
252 : :
253 : 85 : std::unique_ptr<SigningProvider> LegacyDataSPKM::GetSolvingProvider(const CScript& script) const
254 : : {
255 : 85 : return std::make_unique<LegacySigningProvider>(*this);
256 : : }
257 : :
258 : 547 : bool LegacyDataSPKM::CanProvide(const CScript& script, SignatureData& sigdata)
259 : : {
260 : 547 : IsMineResult ismine = LegacyWalletIsMineInnerDONOTUSE(*this, script, IsMineSigVersion::TOP, /* recurse_scripthash= */ false);
261 [ + + ]: 547 : if (ismine == IsMineResult::SPENDABLE || ismine == IsMineResult::WATCH_ONLY) {
262 : : // If ismine, it means we recognize keys or script ids in the script, or
263 : : // are watching the script itself, and we can at least provide metadata
264 : : // or solving information, even if not able to sign fully.
265 : : return true;
266 : : } else {
267 : : // If, given the stuff in sigdata, we could make a valid signature, then we can provide for this script
268 : 519 : ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
269 [ + + ]: 519 : if (!sigdata.signatures.empty()) {
270 : : // If we could make signatures, make sure we have a private key to actually make a signature
271 : 1 : bool has_privkeys = false;
272 [ + + ]: 2 : for (const auto& key_sig_pair : sigdata.signatures) {
273 : 1 : has_privkeys |= HaveKey(key_sig_pair.first);
274 : : }
275 : : return has_privkeys;
276 : : }
277 : : return false;
278 : : }
279 : : }
280 : :
281 : 189 : bool LegacyDataSPKM::LoadKey(const CKey& key, const CPubKey &pubkey)
282 : : {
283 : 189 : return AddKeyPubKeyInner(key, pubkey);
284 : : }
285 : :
286 : 87 : bool LegacyDataSPKM::LoadCScript(const CScript& redeemScript)
287 : : {
288 : : /* A sanity check was added in pull #3843 to avoid adding redeemScripts
289 : : * that never can be redeemed. However, old wallets may still contain
290 : : * these. Do not add them to the wallet and warn. */
291 [ + + - + ]: 87 : if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
292 : : {
293 [ # # ]: 0 : std::string strAddr = EncodeDestination(ScriptHash(redeemScript));
294 [ # # # # ]: 0 : WalletLogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
295 : 0 : return true;
296 : 0 : }
297 : :
298 : 87 : return FillableSigningProvider::AddCScript(redeemScript);
299 : : }
300 : :
301 : 217 : void LegacyDataSPKM::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata& meta)
302 : : {
303 : 217 : LOCK(cs_KeyStore);
304 [ + - + - ]: 217 : mapKeyMetadata[keyID] = meta;
305 : 217 : }
306 : :
307 : 45 : void LegacyDataSPKM::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata& meta)
308 : : {
309 : 45 : LOCK(cs_KeyStore);
310 [ + - + - ]: 45 : m_script_metadata[script_id] = meta;
311 : 45 : }
312 : :
313 : 189 : bool LegacyDataSPKM::AddKeyPubKeyInner(const CKey& key, const CPubKey& pubkey)
314 : : {
315 : 189 : LOCK(cs_KeyStore);
316 [ + - + - ]: 189 : return FillableSigningProvider::AddKeyPubKey(key, pubkey);
317 : 189 : }
318 : :
319 : 24 : bool LegacyDataSPKM::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid)
320 : : {
321 : : // Set fDecryptionThoroughlyChecked to false when the checksum is invalid
322 [ - + ]: 24 : if (!checksum_valid) {
323 : 0 : fDecryptionThoroughlyChecked = false;
324 : : }
325 : :
326 : 24 : return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
327 : : }
328 : :
329 : 24 : bool LegacyDataSPKM::AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
330 : : {
331 : 24 : LOCK(cs_KeyStore);
332 [ - + ]: 24 : assert(mapKeys.empty());
333 : :
334 [ + - + - : 48 : mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
+ - ]
335 [ + - ]: 24 : ImplicitlyLearnRelatedKeyScripts(vchPubKey);
336 [ + - ]: 24 : return true;
337 : 24 : }
338 : :
339 : 1838 : bool LegacyDataSPKM::HaveWatchOnly(const CScript &dest) const
340 : : {
341 : 1838 : LOCK(cs_KeyStore);
342 [ + - ]: 1838 : return setWatchOnly.count(dest) > 0;
343 : 1838 : }
344 : :
345 : 45 : bool LegacyDataSPKM::LoadWatchOnly(const CScript &dest)
346 : : {
347 : 45 : return AddWatchOnlyInMem(dest);
348 : : }
349 : :
350 : 45 : static bool ExtractPubKey(const CScript &dest, CPubKey& pubKeyOut)
351 : : {
352 : 45 : std::vector<std::vector<unsigned char>> solutions;
353 [ + - + + : 54 : return Solver(dest, solutions) == TxoutType::PUBKEY &&
- + ]
354 [ - + + - ]: 54 : (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
355 : 45 : }
356 : :
357 : 45 : bool LegacyDataSPKM::AddWatchOnlyInMem(const CScript &dest)
358 : : {
359 : 45 : LOCK(cs_KeyStore);
360 [ + - ]: 45 : setWatchOnly.insert(dest);
361 [ + - ]: 45 : CPubKey pubKey;
362 [ + - + + ]: 45 : if (ExtractPubKey(dest, pubKey)) {
363 [ + - + - ]: 9 : mapWatchKeys[pubKey.GetID()] = pubKey;
364 [ + - ]: 9 : ImplicitlyLearnRelatedKeyScripts(pubKey);
365 : : }
366 [ + - ]: 45 : return true;
367 : 45 : }
368 : :
369 : 32 : void LegacyDataSPKM::LoadHDChain(const CHDChain& chain)
370 : : {
371 : 32 : LOCK(cs_KeyStore);
372 [ + - ]: 32 : m_hd_chain = chain;
373 : 32 : }
374 : :
375 : 6 : void LegacyDataSPKM::AddInactiveHDChain(const CHDChain& chain)
376 : : {
377 : 6 : LOCK(cs_KeyStore);
378 [ - + ]: 12 : assert(!chain.seed_id.IsNull());
379 [ + - + - ]: 6 : m_inactive_hd_chains[chain.seed_id] = chain;
380 : 6 : }
381 : :
382 : 1978 : bool LegacyDataSPKM::HaveKey(const CKeyID &address) const
383 : : {
384 : 1978 : LOCK(cs_KeyStore);
385 [ + - + + ]: 1978 : if (!m_storage.HasEncryptionKeys()) {
386 [ + - ]: 1924 : return FillableSigningProvider::HaveKey(address);
387 : : }
388 : 54 : return mapCryptedKeys.count(address) > 0;
389 : 1978 : }
390 : :
391 : 1253 : bool LegacyDataSPKM::GetKey(const CKeyID &address, CKey& keyOut) const
392 : : {
393 : 1253 : LOCK(cs_KeyStore);
394 [ + - + + ]: 1253 : if (!m_storage.HasEncryptionKeys()) {
395 [ + - ]: 1246 : return FillableSigningProvider::GetKey(address, keyOut);
396 : : }
397 : :
398 : 7 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
399 [ + - ]: 7 : if (mi != mapCryptedKeys.end())
400 : : {
401 [ + - ]: 7 : const CPubKey &vchPubKey = (*mi).second.first;
402 : 7 : const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
403 [ + - + - ]: 7 : return m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
404 [ - + ]: 7 : return DecryptKey(encryption_key, vchCryptedSecret, vchPubKey, keyOut);
405 : : });
406 : : }
407 : : return false;
408 : 1253 : }
409 : :
410 : 141 : bool LegacyDataSPKM::GetKeyOrigin(const CKeyID& keyID, KeyOriginInfo& info) const
411 : : {
412 : 141 : CKeyMetadata meta;
413 : 141 : {
414 [ + - ]: 141 : LOCK(cs_KeyStore);
415 : 141 : auto it = mapKeyMetadata.find(keyID);
416 [ + + ]: 141 : if (it == mapKeyMetadata.end()) {
417 [ + - ]: 54 : return false;
418 : : }
419 [ + - ]: 87 : meta = it->second;
420 : 54 : }
421 [ + + ]: 87 : if (meta.has_key_origin) {
422 : 45 : std::copy(meta.key_origin.fingerprint, meta.key_origin.fingerprint + 4, info.fingerprint);
423 [ + - ]: 45 : info.path = meta.key_origin.path;
424 : : } else { // Single pubkeys get the master fingerprint of themselves
425 : 42 : std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
426 : : }
427 : : return true;
428 : 141 : }
429 : :
430 : 73 : bool LegacyDataSPKM::GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
431 : : {
432 : 73 : LOCK(cs_KeyStore);
433 : 73 : WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
434 [ + + ]: 73 : if (it != mapWatchKeys.end()) {
435 : 64 : pubkey_out = it->second;
436 : 64 : return true;
437 : : }
438 : : return false;
439 : 73 : }
440 : :
441 : 1072 : bool LegacyDataSPKM::GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
442 : : {
443 : 1072 : LOCK(cs_KeyStore);
444 [ + - + + ]: 1072 : if (!m_storage.HasEncryptionKeys()) {
445 [ + - + + ]: 1042 : if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
446 [ + - ]: 73 : return GetWatchPubKey(address, vchPubKeyOut);
447 : : }
448 : : return true;
449 : : }
450 : :
451 : 30 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
452 [ + - ]: 30 : if (mi != mapCryptedKeys.end())
453 : : {
454 : 30 : vchPubKeyOut = (*mi).second.first;
455 : 30 : return true;
456 : : }
457 : : // Check for watch-only pubkeys
458 [ # # ]: 0 : return GetWatchPubKey(address, vchPubKeyOut);
459 : 1072 : }
460 : :
461 : 68 : std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetCandidateScriptPubKeys() const
462 : : {
463 : 68 : LOCK(cs_KeyStore);
464 [ + - ]: 68 : std::unordered_set<CScript, SaltedSipHasher> candidate_spks;
465 : :
466 : : // For every private key in the wallet, there should be a P2PK, P2PKH, P2WPKH, and P2SH-P2WPKH
467 : 458 : const auto& add_pubkey = [&candidate_spks](const CPubKey& pub) -> void {
468 [ + - ]: 390 : candidate_spks.insert(GetScriptForRawPubKey(pub));
469 [ + - ]: 780 : candidate_spks.insert(GetScriptForDestination(PKHash(pub)));
470 : :
471 [ + - ]: 390 : CScript wpkh = GetScriptForDestination(WitnessV0KeyHash(pub));
472 [ + - ]: 390 : candidate_spks.insert(wpkh);
473 [ + - + - ]: 780 : candidate_spks.insert(GetScriptForDestination(ScriptHash(wpkh)));
474 : 390 : };
475 [ + - + + ]: 446 : for (const auto& [_, key] : mapKeys) {
476 [ + - + - ]: 378 : add_pubkey(key.GetPubKey());
477 : : }
478 [ + - + + ]: 80 : for (const auto& [_, ckeypair] : mapCryptedKeys) {
479 [ + - ]: 12 : add_pubkey(ckeypair.first);
480 : : }
481 : :
482 : : // mapScripts contains all redeemScripts and witnessScripts. Therefore each script in it has
483 : : // itself, P2SH, P2WSH, and P2SH-P2WSH as a candidate.
484 : : // Invalid scripts such as P2SH-P2SH and P2WSH-P2SH, among others, will be added as candidates.
485 : : // Callers of this function will need to remove such scripts.
486 : 626 : const auto& add_script = [&candidate_spks](const CScript& script) -> void {
487 : 558 : candidate_spks.insert(script);
488 [ + - ]: 1116 : candidate_spks.insert(GetScriptForDestination(ScriptHash(script)));
489 : :
490 [ + - ]: 558 : CScript wsh = GetScriptForDestination(WitnessV0ScriptHash(script));
491 [ + - ]: 558 : candidate_spks.insert(wsh);
492 [ + - + - ]: 1116 : candidate_spks.insert(GetScriptForDestination(ScriptHash(wsh)));
493 : 558 : };
494 [ + - + + ]: 536 : for (const auto& [_, script] : mapScripts) {
495 [ + - ]: 468 : add_script(script);
496 : : }
497 : :
498 : : // Although setWatchOnly should only contain output scripts, we will also include each script's
499 : : // P2SH, P2WSH, and P2SH-P2WSH as a precaution.
500 [ + + ]: 158 : for (const auto& script : setWatchOnly) {
501 [ + - ]: 90 : add_script(script);
502 : : }
503 : :
504 [ + - ]: 68 : return candidate_spks;
505 : 68 : }
506 : :
507 : 34 : std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetScriptPubKeys() const
508 : : {
509 : : // Run IsMine() on each candidate output script. Any script that IsMine is an output
510 : : // script to return.
511 : : // This both filters out things that are not watched by the wallet, and things that are invalid.
512 : 34 : std::unordered_set<CScript, SaltedSipHasher> spks;
513 [ + - + + : 1428 : for (const CScript& script : GetCandidateScriptPubKeys()) {
+ - ]
514 [ + + + - ]: 1394 : if (IsMine(script)) {
515 [ + - ]: 835 : spks.insert(script);
516 : : }
517 : : }
518 : :
519 : 34 : return spks;
520 : 0 : }
521 : :
522 : 32 : std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetNotMineScriptPubKeys() const
523 : : {
524 : 32 : LOCK(cs_KeyStore);
525 [ + - ]: 32 : std::unordered_set<CScript, SaltedSipHasher> spks;
526 [ + + ]: 75 : for (const CScript& script : setWatchOnly) {
527 [ + - + + : 43 : if (!IsMine(script)) spks.insert(script);
+ - ]
528 : : }
529 [ + - ]: 32 : return spks;
530 : 32 : }
531 : :
532 : 34 : std::optional<MigrationData> LegacyDataSPKM::MigrateToDescriptor()
533 : : {
534 : 34 : LOCK(cs_KeyStore);
535 [ + - - + ]: 34 : if (m_storage.IsLocked()) {
536 : 0 : return std::nullopt;
537 : : }
538 : :
539 : 34 : MigrationData out;
540 : :
541 [ + - ]: 34 : std::unordered_set<CScript, SaltedSipHasher> spks{GetScriptPubKeys()};
542 : :
543 : : // Get all key ids
544 : 34 : std::set<CKeyID> keyids;
545 [ + + ]: 223 : for (const auto& key_pair : mapKeys) {
546 [ + - ]: 189 : keyids.insert(key_pair.first);
547 : : }
548 [ + + ]: 40 : for (const auto& key_pair : mapCryptedKeys) {
549 [ + - ]: 6 : keyids.insert(key_pair.first);
550 : : }
551 : :
552 : : // Get key metadata and figure out which keys don't have a seed
553 : : // Note that we do not ignore the seeds themselves because they are considered IsMine!
554 [ + + ]: 229 : for (auto keyid_it = keyids.begin(); keyid_it != keyids.end();) {
555 : 195 : const CKeyID& keyid = *keyid_it;
556 : 195 : const auto& it = mapKeyMetadata.find(keyid);
557 [ + - ]: 195 : if (it != mapKeyMetadata.end()) {
558 [ + + ]: 195 : const CKeyMetadata& meta = it->second;
559 [ + + + + ]: 195 : if (meta.hdKeypath == "s" || meta.hdKeypath == "m") {
560 : 33 : keyid_it++;
561 : 33 : continue;
562 : : }
563 [ + + + + : 324 : if (!meta.hd_seed_id.IsNull() && (m_hd_chain.seed_id == meta.hd_seed_id || m_inactive_hd_chains.count(meta.hd_seed_id) > 0)) {
+ - + - ]
564 : 158 : keyid_it = keyids.erase(keyid_it);
565 : 158 : continue;
566 : : }
567 : : }
568 : 4 : keyid_it++;
569 : : }
570 : :
571 [ + - + - ]: 34 : WalletBatch batch(m_storage.GetDatabase());
572 [ + - - + ]: 34 : if (!batch.TxnBegin()) {
573 [ # # ]: 0 : LogPrintf("Error generating descriptors for migration, cannot initialize db transaction\n");
574 : 0 : return std::nullopt;
575 : : }
576 : :
577 : : // keyids is now all non-HD keys. Each key will have its own combo descriptor
578 [ + + ]: 71 : for (const CKeyID& keyid : keyids) {
579 : 37 : CKey key;
580 [ + - - + ]: 37 : if (!GetKey(keyid, key)) {
581 : 0 : assert(false);
582 : : }
583 : :
584 : : // Get birthdate from key meta
585 : 37 : uint64_t creation_time = 0;
586 : 37 : const auto& it = mapKeyMetadata.find(keyid);
587 [ + - ]: 37 : if (it != mapKeyMetadata.end()) {
588 : 37 : creation_time = it->second.nCreateTime;
589 : : }
590 : :
591 : : // Get the key origin
592 : : // Maybe this doesn't matter because floating keys here shouldn't have origins
593 [ + - ]: 37 : KeyOriginInfo info;
594 [ + - ]: 37 : bool has_info = GetKeyOrigin(keyid, info);
595 [ + - + - : 185 : std::string origin_str = has_info ? "[" + HexStr(info.fingerprint) + FormatHDKeypath(info.path) + "]" : "";
+ - + - +
- + - - -
+ - + - +
- - - - -
- - - - ]
596 : :
597 : : // Construct the combo descriptor
598 [ + - + - : 74 : std::string desc_str = "combo(" + origin_str + HexStr(key.GetPubKey()) + ")";
+ - + - ]
599 : 37 : FlatSigningProvider keys;
600 [ - + ]: 37 : std::string error;
601 [ - + + - ]: 37 : std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, error, false);
602 [ - + + - ]: 37 : CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
603 [ + - + - : 37 : WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
+ - ]
604 : :
605 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
606 [ + - ]: 37 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
607 [ + - + - : 111 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, key, key.GetPubKey()));
+ - ]
608 [ + - ]: 37 : desc_spk_man->TopUpWithDB(batch);
609 [ + - ]: 37 : auto desc_spks = desc_spk_man->GetScriptPubKeys();
610 : :
611 : : // Remove the scriptPubKeys from our current set
612 [ + + + - ]: 183 : for (const CScript& spk : desc_spks) {
613 [ + - ]: 146 : size_t erased = spks.erase(spk);
614 [ - + ]: 146 : assert(erased == 1);
615 [ + - - + ]: 146 : assert(IsMine(spk));
616 : : }
617 : :
618 [ + - ]: 37 : out.desc_spkms.push_back(std::move(desc_spk_man));
619 : 37 : }
620 : :
621 : : // Handle HD keys by using the CHDChains
622 : 34 : std::vector<CHDChain> chains;
623 [ + - ]: 34 : chains.push_back(m_hd_chain);
624 [ + + + - ]: 37 : for (const auto& chain_pair : m_inactive_hd_chains) {
625 [ + - ]: 3 : chains.push_back(chain_pair.second);
626 : : }
627 : :
628 : 34 : bool can_support_hd_split_feature = m_hd_chain.nVersion >= CHDChain::VERSION_HD_CHAIN_SPLIT;
629 : :
630 [ + + ]: 71 : for (const CHDChain& chain : chains) {
631 [ + + ]: 111 : for (int i = 0; i < 2; ++i) {
632 : : // Skip if doing internal chain and split chain is not supported
633 [ + + + + : 148 : if (chain.seed_id.IsNull() || (i == 1 && !can_support_hd_split_feature)) {
+ - ]
634 : 10 : continue;
635 : : }
636 : : // Get the master xprv
637 : 64 : CKey seed_key;
638 [ + - - + ]: 64 : if (!GetKey(chain.seed_id, seed_key)) {
639 : 0 : assert(false);
640 : : }
641 [ + - ]: 64 : CExtKey master_key;
642 [ + - + - ]: 128 : master_key.SetSeed(seed_key);
643 : :
644 : : // Make the combo descriptor
645 [ + - + - ]: 64 : std::string xpub = EncodeExtPubKey(master_key.Neuter());
646 [ + - + - : 192 : std::string desc_str = "combo(" + xpub + "/0h/" + ToString(i) + "h/*h)";
+ - ]
647 : 64 : FlatSigningProvider keys;
648 [ - + ]: 64 : std::string error;
649 [ - + + - ]: 64 : std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, error, false);
650 [ - + + - ]: 64 : CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
651 [ + + ]: 64 : uint32_t chain_counter = std::max((i == 1 ? chain.nInternalChainCounter : chain.nExternalChainCounter), (uint32_t)0);
652 [ + - + - : 64 : WalletDescriptor w_desc(std::move(descs.at(0)), 0, 0, chain_counter, 0);
+ - ]
653 : :
654 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
655 [ + - ]: 64 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
656 [ + - + - : 192 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey()));
+ - ]
657 [ + - ]: 64 : desc_spk_man->TopUpWithDB(batch);
658 [ + - ]: 64 : auto desc_spks = desc_spk_man->GetScriptPubKeys();
659 : :
660 : : // Remove the scriptPubKeys from our current set
661 [ + + + - ]: 696 : for (const CScript& spk : desc_spks) {
662 [ + - ]: 632 : size_t erased = spks.erase(spk);
663 [ - + ]: 632 : assert(erased == 1);
664 [ + - - + ]: 632 : assert(IsMine(spk));
665 : : }
666 : :
667 [ + - ]: 64 : out.desc_spkms.push_back(std::move(desc_spk_man));
668 : 64 : }
669 : : }
670 : : // Add the current master seed to the migration data
671 [ + + ]: 68 : if (!m_hd_chain.seed_id.IsNull()) {
672 : 29 : CKey seed_key;
673 [ + - - + ]: 29 : if (!GetKey(m_hd_chain.seed_id, seed_key)) {
674 : 0 : assert(false);
675 : : }
676 [ + - + - ]: 58 : out.master_key.SetSeed(seed_key);
677 : 29 : }
678 : :
679 : : // Handle the rest of the scriptPubKeys which must be imports and may not have all info
680 [ + + ]: 91 : for (auto it = spks.begin(); it != spks.end();) {
681 [ + - ]: 57 : const CScript& spk = *it;
682 : :
683 : : // Get birthdate from script meta
684 : 57 : uint64_t creation_time = 0;
685 [ + - ]: 57 : const auto& mit = m_script_metadata.find(CScriptID(spk));
686 [ + + ]: 57 : if (mit != m_script_metadata.end()) {
687 : 40 : creation_time = mit->second.nCreateTime;
688 : : }
689 : :
690 : : // InferDescriptor as that will get us all the solving info if it is there
691 [ + - + - ]: 114 : std::unique_ptr<Descriptor> desc = InferDescriptor(spk, *GetSolvingProvider(spk));
692 : :
693 : : // Past bugs in InferDescriptor have caused it to create descriptors which cannot be re-parsed.
694 : : // Re-parse the descriptors to detect that, and skip any that do not parse.
695 : 57 : {
696 [ + - ]: 57 : std::string desc_str = desc->ToString();
697 : 57 : FlatSigningProvider parsed_keys;
698 [ - + ]: 57 : std::string parse_error;
699 [ - + + - ]: 57 : std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str, parsed_keys, parse_error);
700 [ - + ]: 57 : if (parsed_descs.empty()) {
701 : : // Remove this scriptPubKey from the set
702 : 0 : it = spks.erase(it);
703 : 0 : continue;
704 : : }
705 : 57 : }
706 : :
707 : : // Get the private keys for this descriptor
708 : 57 : std::vector<CScript> scripts;
709 : 57 : FlatSigningProvider keys;
710 [ + - - + ]: 57 : if (!desc->Expand(0, DUMMY_SIGNING_PROVIDER, scripts, keys)) {
711 : 0 : assert(false);
712 : : }
713 : 57 : std::set<CKeyID> privkeyids;
714 [ + + ]: 109 : for (const auto& key_orig_pair : keys.origins) {
715 [ + - ]: 52 : privkeyids.insert(key_orig_pair.first);
716 : : }
717 : :
718 : 57 : std::vector<CScript> desc_spks;
719 : :
720 : : // Make the descriptor string with private keys
721 [ + - ]: 57 : std::string desc_str;
722 [ + - ]: 57 : bool watchonly = !desc->ToPrivateString(*this, desc_str);
723 [ + + + - : 57 : if (watchonly && !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+ + ]
724 [ + - + - ]: 36 : out.watch_descs.emplace_back(desc->ToString(), creation_time);
725 : :
726 : : // Get the scriptPubKeys without writing this to the wallet
727 : 36 : FlatSigningProvider provider;
728 [ + - ]: 36 : desc->Expand(0, provider, desc_spks, provider);
729 : 36 : } else {
730 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
731 [ + - + - ]: 21 : WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
732 [ + - ]: 21 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
733 [ + + ]: 48 : for (const auto& keyid : privkeyids) {
734 : 27 : CKey key;
735 [ + - + + ]: 27 : if (!GetKey(keyid, key)) {
736 : 9 : continue;
737 : : }
738 [ + - + - : 54 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, key, key.GetPubKey()));
+ - ]
739 : 27 : }
740 [ + - ]: 21 : desc_spk_man->TopUpWithDB(batch);
741 [ + - ]: 21 : auto desc_spks_set = desc_spk_man->GetScriptPubKeys();
742 [ + - ]: 21 : desc_spks.insert(desc_spks.end(), desc_spks_set.begin(), desc_spks_set.end());
743 : :
744 [ + - ]: 21 : out.desc_spkms.push_back(std::move(desc_spk_man));
745 : 21 : }
746 : :
747 : : // Remove the scriptPubKeys from our current set
748 [ + + ]: 114 : for (const CScript& desc_spk : desc_spks) {
749 [ + - ]: 57 : auto del_it = spks.find(desc_spk);
750 [ + - ]: 57 : assert(del_it != spks.end());
751 [ + - - + ]: 57 : assert(IsMine(desc_spk));
752 : 57 : it = spks.erase(del_it);
753 : : }
754 : 57 : }
755 : :
756 : : // Make sure that we have accounted for all scriptPubKeys
757 [ - + ]: 34 : if (!Assume(spks.empty())) {
758 [ # # # # ]: 0 : LogPrintf("%s\n", STR_INTERNAL_BUG("Error: Some output scripts were not migrated.\n"));
759 : 0 : return std::nullopt;
760 : : }
761 : :
762 : : // Legacy wallets can also contain scripts whose P2SH, P2WSH, or P2SH-P2WSH it is not watching for
763 : : // but can provide script data to a PSBT spending them. These "solvable" output scripts will need to
764 : : // be put into the separate "solvables" wallet.
765 : : // These can be detected by going through the entire candidate output scripts, finding the not IsMine scripts,
766 : : // and checking CanProvide() which will dummy sign.
767 [ + - + + : 1428 : for (const CScript& script : GetCandidateScriptPubKeys()) {
+ - ]
768 : : // Since we only care about P2SH, P2WSH, and P2SH-P2WSH, filter out any scripts that are not those
769 [ + + + - : 1394 : if (!script.IsPayToScriptHash() && !script.IsPayToWitnessScriptHash()) {
+ + + - ]
770 : 625 : continue;
771 : : }
772 [ + - + + ]: 769 : if (IsMine(script)) {
773 : 222 : continue;
774 : : }
775 : 547 : SignatureData dummy_sigdata;
776 [ + - + + ]: 547 : if (!CanProvide(script, dummy_sigdata)) {
777 : 519 : continue;
778 : : }
779 : :
780 : : // Get birthdate from script meta
781 : 28 : uint64_t creation_time = 0;
782 [ + - ]: 28 : const auto& it = m_script_metadata.find(CScriptID(script));
783 [ + + ]: 28 : if (it != m_script_metadata.end()) {
784 : 4 : creation_time = it->second.nCreateTime;
785 : : }
786 : :
787 : : // InferDescriptor as that will get us all the solving info if it is there
788 [ + - + - ]: 28 : std::unique_ptr<Descriptor> desc = InferDescriptor(script, *GetSolvingProvider(script));
789 [ + - + + ]: 28 : if (!desc->IsSolvable()) {
790 : : // The wallet was able to provide some information, but not enough to make a descriptor that actually
791 : : // contains anything useful. This is probably because the script itself is actually unsignable (e.g. P2WSH-P2WSH).
792 : 10 : continue;
793 : : }
794 : :
795 : : // Past bugs in InferDescriptor have caused it to create descriptors which cannot be re-parsed
796 : : // Re-parse the descriptors to detect that, and skip any that do not parse.
797 : 18 : {
798 [ + - ]: 18 : std::string desc_str = desc->ToString();
799 : 18 : FlatSigningProvider parsed_keys;
800 [ - + ]: 18 : std::string parse_error;
801 [ - + + - ]: 18 : std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str, parsed_keys, parse_error, false);
802 [ - + ]: 18 : if (parsed_descs.empty()) {
803 : 0 : continue;
804 : : }
805 : 18 : }
806 : :
807 [ + - + - ]: 18 : out.solvable_descs.emplace_back(desc->ToString(), creation_time);
808 : 547 : }
809 : :
810 : : // Finalize transaction
811 [ + - - + ]: 34 : if (!batch.TxnCommit()) {
812 [ # # ]: 0 : LogPrintf("Error generating descriptors for migration, cannot commit db transaction\n");
813 : 0 : return std::nullopt;
814 : : }
815 : :
816 : 34 : return out;
817 : 102 : }
818 : :
819 : 32 : bool LegacyDataSPKM::DeleteRecordsWithDB(WalletBatch& batch)
820 : : {
821 : 32 : LOCK(cs_KeyStore);
822 [ + - + - ]: 32 : return batch.EraseRecords(DBKeys::LEGACY_TYPES);
823 : 32 : }
824 : :
825 : 19198 : util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type)
826 : : {
827 : : // Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later
828 [ - + ]: 19198 : if (!CanGetAddresses()) {
829 : 0 : return util::Error{_("No addresses available")};
830 : : }
831 : 19198 : {
832 : 19198 : LOCK(cs_desc_man);
833 [ + - - + ]: 19198 : assert(m_wallet_descriptor.descriptor->IsSingleType()); // This is a combo descriptor which should not be an active descriptor
834 [ + - ]: 19198 : std::optional<OutputType> desc_addr_type = m_wallet_descriptor.descriptor->GetOutputType();
835 [ - + ]: 19198 : assert(desc_addr_type);
836 [ - + ]: 19198 : if (type != *desc_addr_type) {
837 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": Types are inconsistent. Stored type does not match type of newly generated address");
838 : : }
839 : :
840 [ + - ]: 19198 : TopUp();
841 : :
842 : : // Get the scriptPubKey from the descriptor
843 : 19198 : FlatSigningProvider out_keys;
844 : 19198 : std::vector<CScript> scripts_temp;
845 [ - + - - : 19198 : if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
- - ]
846 : : // We can't generate anymore keys
847 [ # # ]: 0 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
848 : : }
849 [ + - + + ]: 19198 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
850 : : // We can't generate anymore keys
851 [ + - ]: 24 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
852 : : }
853 : :
854 : 19190 : CTxDestination dest;
855 [ + - - + ]: 19190 : if (!ExtractDestination(scripts_temp[0], dest)) {
856 [ # # ]: 0 : return util::Error{_("Error: Cannot extract destination from the generated scriptpubkey")}; // shouldn't happen
857 : : }
858 : 19190 : m_wallet_descriptor.next_index++;
859 [ + - + - : 19190 : WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
+ - + - ]
860 : 19190 : return dest;
861 [ + - ]: 38396 : }
862 : : }
863 : :
864 : 620937 : bool DescriptorScriptPubKeyMan::IsMine(const CScript& script) const
865 : : {
866 : 620937 : LOCK(cs_desc_man);
867 [ + - ]: 620937 : return m_map_script_pub_keys.contains(script);
868 : 620937 : }
869 : :
870 : 874 : bool DescriptorScriptPubKeyMan::CheckDecryptionKey(const CKeyingMaterial& master_key)
871 : : {
872 : 874 : LOCK(cs_desc_man);
873 [ + - ]: 874 : if (!m_map_keys.empty()) {
874 : : return false;
875 : : }
876 : :
877 : 874 : bool keyPass = m_map_crypted_keys.empty(); // Always pass when there are no encrypted keys
878 : 874 : bool keyFail = false;
879 [ + + ]: 1089 : for (const auto& mi : m_map_crypted_keys) {
880 : 736 : const CPubKey &pubkey = mi.second.first;
881 : 736 : const std::vector<unsigned char> &crypted_secret = mi.second.second;
882 : 736 : CKey key;
883 [ - + + - : 736 : if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
+ - ]
884 : : keyFail = true;
885 : : break;
886 : : }
887 : 736 : keyPass = true;
888 [ + + ]: 736 : if (m_decryption_thoroughly_checked)
889 : : break;
890 : 736 : }
891 [ - + ]: 874 : if (keyPass && keyFail) {
892 [ # # ]: 0 : LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
893 [ # # ]: 0 : throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
894 : : }
895 [ + - ]: 874 : if (keyFail || !keyPass) {
896 : : return false;
897 : : }
898 : 874 : m_decryption_thoroughly_checked = true;
899 : 874 : return true;
900 : 874 : }
901 : :
902 : 103 : bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch)
903 : : {
904 : 103 : LOCK(cs_desc_man);
905 [ + - ]: 103 : if (!m_map_crypted_keys.empty()) {
906 : : return false;
907 : : }
908 : :
909 [ + + ]: 206 : for (const KeyMap::value_type& key_in : m_map_keys)
910 : : {
911 : 103 : const CKey &key = key_in.second;
912 [ + - ]: 103 : CPubKey pubkey = key.GetPubKey();
913 [ + - + - : 309 : CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
914 : 103 : std::vector<unsigned char> crypted_secret;
915 [ + - + - : 103 : if (!EncryptSecret(master_key, secret, pubkey.GetHash(), crypted_secret)) {
- + ]
916 : 0 : return false;
917 : : }
918 [ + - + - : 206 : m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
+ - ]
919 [ + - + - ]: 103 : batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
920 : 103 : }
921 : 103 : m_map_keys.clear();
922 : 103 : return true;
923 : 103 : }
924 : :
925 : 2053 : util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, int64_t& index)
926 : : {
927 : 2053 : LOCK(cs_desc_man);
928 [ + - ]: 2053 : auto op_dest = GetNewDestination(type);
929 : 2053 : index = m_wallet_descriptor.next_index - 1;
930 [ + - ]: 2053 : return op_dest;
931 : 2053 : }
932 : :
933 : 96 : void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)
934 : : {
935 : 96 : LOCK(cs_desc_man);
936 : : // Only return when the index was the most recent
937 [ + - ]: 96 : if (m_wallet_descriptor.next_index - 1 == index) {
938 : 96 : m_wallet_descriptor.next_index--;
939 : : }
940 [ + - + - : 96 : WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
+ - + - ]
941 [ + - ]: 96 : NotifyCanGetAddressesChanged();
942 : 96 : }
943 : :
944 : 91335 : std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const
945 : : {
946 : 91335 : AssertLockHeld(cs_desc_man);
947 [ + + + + ]: 91335 : if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
948 : 2285 : KeyMap keys;
949 [ + + ]: 4570 : for (const auto& key_pair : m_map_crypted_keys) {
950 : 2285 : const CPubKey& pubkey = key_pair.second.first;
951 : 2285 : const std::vector<unsigned char>& crypted_secret = key_pair.second.second;
952 : 2285 : CKey key;
953 [ + - + - ]: 2285 : m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
954 [ - + ]: 2285 : return DecryptKey(encryption_key, crypted_secret, pubkey, key);
955 : : });
956 [ + - + - : 2285 : keys[pubkey.GetID()] = key;
+ - ]
957 : 2285 : }
958 : : return keys;
959 : 0 : }
960 : 89050 : return m_map_keys;
961 : : }
962 : :
963 : 225 : bool DescriptorScriptPubKeyMan::HasPrivKey(const CKeyID& keyid) const
964 : : {
965 : 225 : AssertLockHeld(cs_desc_man);
966 [ + + + + ]: 225 : return m_map_keys.contains(keyid) || m_map_crypted_keys.contains(keyid);
967 : : }
968 : :
969 : 79 : std::optional<CKey> DescriptorScriptPubKeyMan::GetKey(const CKeyID& keyid) const
970 : : {
971 : 79 : AssertLockHeld(cs_desc_man);
972 [ + + + - ]: 79 : if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
973 : 9 : const auto& it = m_map_crypted_keys.find(keyid);
974 [ - + ]: 9 : if (it == m_map_crypted_keys.end()) {
975 : 0 : return std::nullopt;
976 : : }
977 [ + - ]: 9 : const std::vector<unsigned char>& crypted_secret = it->second.second;
978 : 9 : CKey key;
979 [ + - + - : 18 : if (!Assume(m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
- + - + ]
980 : : return DecryptKey(encryption_key, crypted_secret, it->second.first, key);
981 : : }))) {
982 : 0 : return std::nullopt;
983 : : }
984 : 9 : return key;
985 : 9 : }
986 : 70 : const auto& it = m_map_keys.find(keyid);
987 [ + + ]: 70 : if (it == m_map_keys.end()) {
988 : 8 : return std::nullopt;
989 : : }
990 : 62 : return it->second;
991 : : }
992 : :
993 : 73771 : bool DescriptorScriptPubKeyMan::TopUp(unsigned int size)
994 : : {
995 : 73771 : WalletBatch batch(m_storage.GetDatabase());
996 [ + - + - ]: 73771 : if (!batch.TxnBegin()) return false;
997 [ + - ]: 73771 : bool res = TopUpWithDB(batch, size);
998 [ + - - + : 73771 : if (!batch.TxnCommit()) throw std::runtime_error(strprintf("Error during descriptors keypool top up. Cannot commit changes for wallet [%s]", m_storage.LogName()));
- - - - -
- ]
999 : : return res;
1000 : 73771 : }
1001 : :
1002 : 77399 : bool DescriptorScriptPubKeyMan::TopUpWithDB(WalletBatch& batch, unsigned int size)
1003 : : {
1004 : 77399 : LOCK(cs_desc_man);
1005 [ + + ]: 77399 : std::set<CScript> new_spks;
1006 : 77399 : unsigned int target_size;
1007 [ + + ]: 77399 : if (size > 0) {
1008 : : target_size = size;
1009 : : } else {
1010 : 77327 : target_size = m_keypool_size;
1011 : : }
1012 : :
1013 : : // Calculate the new range_end
1014 [ + + ]: 77399 : int32_t new_range_end = std::max(m_wallet_descriptor.next_index + (int32_t)target_size, m_wallet_descriptor.range_end);
1015 : :
1016 : : // If the descriptor is not ranged, we actually just want to fill the first cache item
1017 [ + - + + ]: 77399 : if (!m_wallet_descriptor.descriptor->IsRange()) {
1018 : 13008 : new_range_end = 1;
1019 : 13008 : m_wallet_descriptor.range_end = 1;
1020 : 13008 : m_wallet_descriptor.range_start = 0;
1021 : : }
1022 : :
1023 : 77399 : FlatSigningProvider provider;
1024 [ + - ]: 154798 : provider.keys = GetKeys();
1025 : :
1026 [ + - ]: 77399 : uint256 id = GetID();
1027 [ + + ]: 501521 : for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
1028 : 424229 : FlatSigningProvider out_keys;
1029 : 424229 : std::vector<CScript> scripts_temp;
1030 : 424229 : DescriptorCache temp_cache;
1031 : : // Maybe we have a cached xpub and we can expand from the cache first
1032 [ + - + + ]: 424229 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1033 [ + - + + ]: 14068 : if (!m_wallet_descriptor.descriptor->Expand(i, provider, scripts_temp, out_keys, &temp_cache)) return false;
1034 : : }
1035 : : // Add all of the scriptPubKeys to the scriptPubKey set
1036 [ + - ]: 424122 : new_spks.insert(scripts_temp.begin(), scripts_temp.end());
1037 [ + + ]: 849379 : for (const CScript& script : scripts_temp) {
1038 [ + - ]: 425257 : m_map_script_pub_keys[script] = i;
1039 : : }
1040 [ + + ]: 896129 : for (const auto& pk_pair : out_keys.pubkeys) {
1041 : 472007 : const CPubKey& pubkey = pk_pair.second;
1042 [ + + ]: 472007 : if (m_map_pubkeys.count(pubkey) != 0) {
1043 : : // We don't need to give an error here.
1044 : : // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
1045 : 10429 : continue;
1046 : : }
1047 [ + - ]: 461578 : m_map_pubkeys[pubkey] = i;
1048 : : }
1049 : : // Merge and write the cache
1050 [ + - ]: 424122 : DescriptorCache new_items = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
1051 [ + - - + ]: 424122 : if (!batch.WriteDescriptorCacheItems(id, new_items)) {
1052 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
1053 : : }
1054 : 424122 : m_max_cached_index++;
1055 : 424229 : }
1056 : 77292 : m_wallet_descriptor.range_end = new_range_end;
1057 [ + - + - ]: 77292 : batch.WriteDescriptor(GetID(), m_wallet_descriptor);
1058 : :
1059 : : // By this point, the cache size should be the size of the entire range
1060 [ - + ]: 77292 : assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
1061 : :
1062 [ + - ]: 77292 : m_storage.TopUpCallback(new_spks, this);
1063 [ + - ]: 77292 : NotifyCanGetAddressesChanged();
1064 : : return true;
1065 [ + - ]: 154798 : }
1066 : :
1067 : 48445 : std::vector<WalletDestination> DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript& script)
1068 : : {
1069 : 48445 : LOCK(cs_desc_man);
1070 : 48445 : std::vector<WalletDestination> result;
1071 [ + - + - ]: 48445 : if (IsMine(script)) {
1072 [ + - ]: 48445 : int32_t index = m_map_script_pub_keys[script];
1073 [ + + ]: 48445 : if (index >= m_wallet_descriptor.next_index) {
1074 [ + - ]: 518 : WalletLogPrintf("%s: Detected a used keypool item at index %d, mark all keypool items up to this item as used\n", __func__, index);
1075 [ + - ]: 518 : auto out_keys = std::make_unique<FlatSigningProvider>();
1076 : 518 : std::vector<CScript> scripts_temp;
1077 [ + + ]: 28924 : while (index >= m_wallet_descriptor.next_index) {
1078 [ + - - + ]: 28406 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
1079 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": Unable to expand descriptor from cache");
1080 : : }
1081 : 28406 : CTxDestination dest;
1082 [ + - ]: 28406 : ExtractDestination(scripts_temp[0], dest);
1083 : 28406 : result.push_back({dest, std::nullopt});
1084 : 28406 : m_wallet_descriptor.next_index++;
1085 : 28406 : }
1086 [ + - ]: 1036 : }
1087 [ + - - + ]: 48445 : if (!TopUp()) {
1088 [ # # ]: 0 : WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
1089 : : }
1090 : : }
1091 : :
1092 [ + - ]: 48445 : return result;
1093 [ + - + - ]: 105257 : }
1094 : :
1095 : 603 : void DescriptorScriptPubKeyMan::AddDescriptorKey(const CKey& key, const CPubKey &pubkey)
1096 : : {
1097 : 603 : LOCK(cs_desc_man);
1098 [ + - + - ]: 603 : WalletBatch batch(m_storage.GetDatabase());
1099 [ + - - + ]: 603 : if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
1100 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor private key failed");
1101 : : }
1102 [ + - ]: 1206 : }
1103 : :
1104 : 4212 : bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch& batch, const CKey& key, const CPubKey &pubkey)
1105 : : {
1106 : 4212 : AssertLockHeld(cs_desc_man);
1107 [ - + ]: 4212 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
1108 : :
1109 : : // Check if provided key already exists
1110 [ + + - + ]: 8416 : if (m_map_keys.find(pubkey.GetID()) != m_map_keys.end() ||
1111 [ - + ]: 4204 : m_map_crypted_keys.find(pubkey.GetID()) != m_map_crypted_keys.end()) {
1112 : 8 : return true;
1113 : : }
1114 : :
1115 [ + + ]: 4204 : if (m_storage.HasEncryptionKeys()) {
1116 [ + - ]: 162 : if (m_storage.IsLocked()) {
1117 : : return false;
1118 : : }
1119 : :
1120 : 162 : std::vector<unsigned char> crypted_secret;
1121 [ + - + - : 486 : CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
1122 [ + - + - : 162 : if (!m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
+ - ]
1123 : 162 : return EncryptSecret(encryption_key, secret, pubkey.GetHash(), crypted_secret);
1124 : : })) {
1125 : : return false;
1126 : : }
1127 : :
1128 [ + - + - : 324 : m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
+ - ]
1129 [ + - + - ]: 162 : return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
1130 : 162 : } else {
1131 : 4042 : m_map_keys[pubkey.GetID()] = key;
1132 [ + - + - ]: 4042 : return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
1133 : : }
1134 : : }
1135 : :
1136 : 3490 : bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(WalletBatch& batch, const CExtKey& master_key, OutputType addr_type, bool internal)
1137 : : {
1138 : 3490 : LOCK(cs_desc_man);
1139 [ + - - + ]: 3490 : assert(m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
1140 : :
1141 : : // Ignore when there is already a descriptor
1142 [ + - ]: 3490 : if (m_wallet_descriptor.descriptor) {
1143 : : return false;
1144 : : }
1145 : :
1146 [ + - + - ]: 3490 : m_wallet_descriptor = GenerateWalletDescriptor(master_key.Neuter(), addr_type, internal);
1147 : :
1148 : : // Store the master private key, and descriptor
1149 [ + - + - : 3490 : if (!AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey())) {
- + ]
1150 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor master private key failed");
1151 : : }
1152 [ + - + - : 3490 : if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
- + ]
1153 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
1154 : : }
1155 : :
1156 : : // TopUp
1157 [ + - ]: 3490 : TopUpWithDB(batch);
1158 : :
1159 [ + - ]: 3490 : m_storage.UnsetBlankWalletFlag(batch);
1160 : : return true;
1161 : 3490 : }
1162 : :
1163 : 77 : bool DescriptorScriptPubKeyMan::IsHDEnabled() const
1164 : : {
1165 : 77 : LOCK(cs_desc_man);
1166 [ + - + - ]: 77 : return m_wallet_descriptor.descriptor->IsRange();
1167 : 77 : }
1168 : :
1169 : 30460 : bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const
1170 : : {
1171 : : // We can only give out addresses from descriptors that are single type (not combo), ranged,
1172 : : // and either have cached keys or can generate more keys (ignoring encryption)
1173 : 30460 : LOCK(cs_desc_man);
1174 [ + - + - ]: 60920 : return m_wallet_descriptor.descriptor->IsSingleType() &&
1175 [ + - + - : 60920 : m_wallet_descriptor.descriptor->IsRange() &&
+ + ]
1176 [ + - - + : 60920 : (HavePrivateKeys() || m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
+ - ]
1177 : 30460 : }
1178 : :
1179 : 336765 : bool DescriptorScriptPubKeyMan::HavePrivateKeys() const
1180 : : {
1181 : 336765 : LOCK(cs_desc_man);
1182 [ + + + + : 365955 : return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
+ - ]
1183 : 336765 : }
1184 : :
1185 : 0 : bool DescriptorScriptPubKeyMan::HaveCryptedKeys() const
1186 : : {
1187 : 0 : LOCK(cs_desc_man);
1188 [ # # ]: 0 : return !m_map_crypted_keys.empty();
1189 : 0 : }
1190 : :
1191 : 9112 : unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const
1192 : : {
1193 : 9112 : LOCK(cs_desc_man);
1194 [ + - ]: 9112 : return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
1195 : 9112 : }
1196 : :
1197 : 12295 : int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const
1198 : : {
1199 : 12295 : LOCK(cs_desc_man);
1200 [ + - ]: 12295 : return m_wallet_descriptor.creation_time;
1201 : 12295 : }
1202 : :
1203 : 431081 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CScript& script, bool include_private) const
1204 : : {
1205 : 431081 : LOCK(cs_desc_man);
1206 : :
1207 : : // Find the index of the script
1208 : 431081 : auto it = m_map_script_pub_keys.find(script);
1209 [ + + ]: 431081 : if (it == m_map_script_pub_keys.end()) {
1210 : 125623 : return nullptr;
1211 : : }
1212 [ + - ]: 305458 : int32_t index = it->second;
1213 : :
1214 [ + - ]: 305458 : return GetSigningProvider(index, include_private);
1215 : 431081 : }
1216 : :
1217 : 29650 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey& pubkey) const
1218 : : {
1219 : 29650 : LOCK(cs_desc_man);
1220 : :
1221 : : // Find index of the pubkey
1222 : 29650 : auto it = m_map_pubkeys.find(pubkey);
1223 [ + + ]: 29650 : if (it == m_map_pubkeys.end()) {
1224 : 28817 : return nullptr;
1225 : : }
1226 [ + - ]: 833 : int32_t index = it->second;
1227 : :
1228 : : // Always try to get the signing provider with private keys. This function should only be called during signing anyways
1229 [ + - ]: 833 : std::unique_ptr<FlatSigningProvider> out = GetSigningProvider(index, true);
1230 [ + - + - : 833 : if (!out->HaveKey(pubkey.GetID())) {
+ + ]
1231 : 490 : return nullptr;
1232 : : }
1233 : 343 : return out;
1234 : 30483 : }
1235 : :
1236 : 306291 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index, bool include_private) const
1237 : : {
1238 : 306291 : AssertLockHeld(cs_desc_man);
1239 : :
1240 : 306291 : std::unique_ptr<FlatSigningProvider> out_keys = std::make_unique<FlatSigningProvider>();
1241 : :
1242 : : // Fetch SigningProvider from cache to avoid re-deriving
1243 : 306291 : auto it = m_map_signing_providers.find(index);
1244 [ + + ]: 306291 : if (it != m_map_signing_providers.end()) {
1245 [ + - + - ]: 290031 : out_keys->Merge(FlatSigningProvider{it->second});
1246 : : } else {
1247 : : // Get the scripts, keys, and key origins for this script
1248 : 16260 : std::vector<CScript> scripts_temp;
1249 [ + - - + ]: 16260 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) return nullptr;
1250 : :
1251 : : // Cache SigningProvider so we don't need to re-derive if we need this SigningProvider again
1252 [ + - + - ]: 16260 : m_map_signing_providers[index] = *out_keys;
1253 : 16260 : }
1254 : :
1255 [ + - + + : 306291 : if (HavePrivateKeys() && include_private) {
+ + ]
1256 : 11958 : FlatSigningProvider master_provider;
1257 [ + - ]: 23916 : master_provider.keys = GetKeys();
1258 [ + - ]: 11958 : m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider, *out_keys);
1259 : :
1260 : : // Always include musig_secnonces as this descriptor may have a participant private key
1261 : : // but not a musig() descriptor
1262 : 11958 : out_keys->musig2_secnonces = &m_musig2_secnonces;
1263 : 11958 : }
1264 : :
1265 : 306291 : return out_keys;
1266 : 306291 : }
1267 : :
1268 : 364713 : std::unique_ptr<SigningProvider> DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript& script) const
1269 : : {
1270 [ - + ]: 364713 : return GetSigningProvider(script, false);
1271 : : }
1272 : :
1273 : 376930 : bool DescriptorScriptPubKeyMan::CanProvide(const CScript& script, SignatureData& sigdata)
1274 : : {
1275 : 376930 : return IsMine(script);
1276 : : }
1277 : :
1278 : 18247 : bool DescriptorScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
1279 : : {
1280 : 18247 : std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
1281 [ + + ]: 61617 : for (const auto& coin_pair : coins) {
1282 [ + - ]: 43370 : std::unique_ptr<FlatSigningProvider> coin_keys = GetSigningProvider(coin_pair.second.out.scriptPubKey, true);
1283 [ + + ]: 43370 : if (!coin_keys) {
1284 : 33813 : continue;
1285 : : }
1286 [ + - ]: 9557 : keys->Merge(std::move(*coin_keys));
1287 : 43370 : }
1288 : :
1289 [ + - + - ]: 18247 : return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
1290 : 18247 : }
1291 : :
1292 : 9 : SigningResult DescriptorScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
1293 : : {
1294 [ + - + - ]: 18 : std::unique_ptr<FlatSigningProvider> keys = GetSigningProvider(GetScriptForDestination(pkhash), true);
1295 [ + - ]: 9 : if (!keys) {
1296 : : return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
1297 : : }
1298 : :
1299 : 9 : CKey key;
1300 [ + - + - : 9 : if (!keys->GetKey(ToKeyID(pkhash), key)) {
+ - ]
1301 : : return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
1302 : : }
1303 : :
1304 [ + - - + ]: 9 : if (!MessageSign(key, message, str_sig)) {
1305 : 0 : return SigningResult::SIGNING_FAILED;
1306 : : }
1307 : : return SigningResult::OK;
1308 : 18 : }
1309 : :
1310 : 7589 : std::optional<PSBTError> DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, std::optional<int> sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
1311 : : {
1312 [ + - ]: 7589 : if (n_signed) {
1313 : 7589 : *n_signed = 0;
1314 : : }
1315 [ - + + + ]: 36587 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
1316 : 29006 : const CTxIn& txin = psbtx.tx->vin[i];
1317 : 29006 : PSBTInput& input = psbtx.inputs.at(i);
1318 : :
1319 [ + + ]: 29006 : if (PSBTInputSigned(input)) {
1320 : 6476 : continue;
1321 : : }
1322 : :
1323 : : // Get the scriptPubKey to know which SigningProvider to use
1324 : 22530 : CScript script;
1325 [ + + ]: 22530 : if (!input.witness_utxo.IsNull()) {
1326 : 16097 : script = input.witness_utxo.scriptPubKey;
1327 [ + + ]: 6433 : } else if (input.non_witness_utxo) {
1328 [ - + + + ]: 6236 : if (txin.prevout.n >= input.non_witness_utxo->vout.size()) {
1329 : 1 : return PSBTError::MISSING_INPUTS;
1330 : : }
1331 : 6235 : script = input.non_witness_utxo->vout[txin.prevout.n].scriptPubKey;
1332 : : } else {
1333 : : // There's no UTXO so we can just skip this now
1334 : 197 : continue;
1335 : : }
1336 : :
1337 [ + - ]: 22332 : std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
1338 [ + - ]: 22332 : std::unique_ptr<FlatSigningProvider> script_keys = GetSigningProvider(script, /*include_private=*/sign);
1339 [ + + ]: 22332 : if (script_keys) {
1340 [ + - ]: 3324 : keys->Merge(std::move(*script_keys));
1341 : : } else {
1342 : : // Maybe there are pubkeys listed that we can sign for
1343 : 19008 : std::vector<CPubKey> pubkeys;
1344 [ + - ]: 19008 : pubkeys.reserve(input.hd_keypaths.size() + 2);
1345 : :
1346 : : // ECDSA Pubkeys
1347 [ + - + + ]: 31304 : for (const auto& [pk, _] : input.hd_keypaths) {
1348 [ + - ]: 12296 : pubkeys.push_back(pk);
1349 : : }
1350 : :
1351 : : // Taproot output pubkey
1352 : 19008 : std::vector<std::vector<unsigned char>> sols;
1353 [ + - + + ]: 19008 : if (Solver(script, sols) == TxoutType::WITNESS_V1_TAPROOT) {
1354 [ + - ]: 1996 : sols[0].insert(sols[0].begin(), 0x02);
1355 [ + - ]: 1996 : pubkeys.emplace_back(sols[0]);
1356 [ + - ]: 1996 : sols[0][0] = 0x03;
1357 [ + - ]: 1996 : pubkeys.emplace_back(sols[0]);
1358 : : }
1359 : :
1360 : : // Taproot pubkeys
1361 [ + + ]: 25688 : for (const auto& pk_pair : input.m_tap_bip32_paths) {
1362 : 6680 : const XOnlyPubKey& pubkey = pk_pair.first;
1363 [ + + ]: 20040 : for (unsigned char prefix : {0x02, 0x03}) {
1364 : 13360 : unsigned char b[33] = {prefix};
1365 : 13360 : std::copy(pubkey.begin(), pubkey.end(), b + 1);
1366 : 13360 : CPubKey fullpubkey;
1367 : 13360 : fullpubkey.Set(b, b + 33);
1368 [ + - ]: 13360 : pubkeys.push_back(fullpubkey);
1369 : : }
1370 : : }
1371 : :
1372 [ + + ]: 48656 : for (const auto& pubkey : pubkeys) {
1373 [ + - ]: 29648 : std::unique_ptr<FlatSigningProvider> pk_keys = GetSigningProvider(pubkey);
1374 [ + + ]: 29648 : if (pk_keys) {
1375 [ + - ]: 342 : keys->Merge(std::move(*pk_keys));
1376 : : }
1377 : 29648 : }
1378 : 19008 : }
1379 : :
1380 [ + - + + ]: 22332 : PSBTError res = SignPSBTInput(HidingSigningProvider(keys.get(), /*hide_secret=*/!sign, /*hide_origin=*/!bip32derivs), psbtx, i, &txdata, sighash_type, nullptr, finalize);
1381 [ + + ]: 22332 : if (res != PSBTError::OK && res != PSBTError::INCOMPLETE) {
1382 [ - + ]: 7 : return res;
1383 : : }
1384 : :
1385 [ + - ]: 22325 : bool signed_one = PSBTInputSigned(input);
1386 [ + - + + ]: 22325 : if (n_signed && (signed_one || !sign)) {
1387 : : // If sign is false, we assume that we _could_ sign if we get here. This
1388 : : // will never have false negatives; it is hard to tell under what i
1389 : : // circumstances it could have false positives.
1390 : 15145 : (*n_signed)++;
1391 : : }
1392 [ + - + - ]: 44869 : }
1393 : :
1394 : : // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
1395 [ - + + + ]: 81291 : for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
1396 : 74618 : std::unique_ptr<SigningProvider> keys = GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
1397 [ + + ]: 73710 : if (!keys) {
1398 : 72802 : continue;
1399 : : }
1400 [ + - ]: 908 : UpdatePSBTOutput(HidingSigningProvider(keys.get(), /*hide_secret=*/true, /*hide_origin=*/!bip32derivs), psbtx, i);
1401 : 73710 : }
1402 : :
1403 : 7581 : return {};
1404 : : }
1405 : :
1406 : 657 : std::unique_ptr<CKeyMetadata> DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
1407 : : {
1408 [ + - ]: 657 : std::unique_ptr<SigningProvider> provider = GetSigningProvider(GetScriptForDestination(dest));
1409 [ + - ]: 657 : if (provider) {
1410 [ + - ]: 657 : KeyOriginInfo orig;
1411 [ + - ]: 657 : CKeyID key_id = GetKeyForDestination(*provider, dest);
1412 [ + - + + ]: 657 : if (provider->GetKeyOrigin(key_id, orig)) {
1413 [ + - ]: 571 : LOCK(cs_desc_man);
1414 [ + - ]: 571 : std::unique_ptr<CKeyMetadata> meta = std::make_unique<CKeyMetadata>();
1415 [ + - ]: 571 : meta->key_origin = orig;
1416 [ + - ]: 571 : meta->has_key_origin = true;
1417 : 571 : meta->nCreateTime = m_wallet_descriptor.creation_time;
1418 [ + - ]: 571 : return meta;
1419 : 571 : }
1420 : 657 : }
1421 : 86 : return nullptr;
1422 : 657 : }
1423 : :
1424 : 190327 : uint256 DescriptorScriptPubKeyMan::GetID() const
1425 : : {
1426 : 190327 : LOCK(cs_desc_man);
1427 [ + - ]: 190327 : return m_wallet_descriptor.id;
1428 : 190327 : }
1429 : :
1430 : 2513 : void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache& cache)
1431 : : {
1432 : 2513 : LOCK(cs_desc_man);
1433 [ + - ]: 2513 : std::set<CScript> new_spks;
1434 [ + - ]: 2513 : m_wallet_descriptor.cache = cache;
1435 [ + + ]: 59907 : for (int32_t i = m_wallet_descriptor.range_start; i < m_wallet_descriptor.range_end; ++i) {
1436 : 57394 : FlatSigningProvider out_keys;
1437 : 57394 : std::vector<CScript> scripts_temp;
1438 [ + - - + ]: 57394 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1439 [ # # ]: 0 : throw std::runtime_error("Error: Unable to expand wallet descriptor from cache");
1440 : : }
1441 : : // Add all of the scriptPubKeys to the scriptPubKey set
1442 [ + - ]: 57394 : new_spks.insert(scripts_temp.begin(), scripts_temp.end());
1443 [ + + ]: 115764 : for (const CScript& script : scripts_temp) {
1444 [ - + ]: 58370 : if (m_map_script_pub_keys.count(script) != 0) {
1445 [ # # # # : 0 : throw std::runtime_error(strprintf("Error: Already loaded script at index %d as being at index %d", i, m_map_script_pub_keys[script]));
# # ]
1446 : : }
1447 [ + - ]: 58370 : m_map_script_pub_keys[script] = i;
1448 : : }
1449 [ + + ]: 118801 : for (const auto& pk_pair : out_keys.pubkeys) {
1450 : 61407 : const CPubKey& pubkey = pk_pair.second;
1451 [ - + ]: 61407 : if (m_map_pubkeys.count(pubkey) != 0) {
1452 : : // We don't need to give an error here.
1453 : : // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
1454 : 0 : continue;
1455 : : }
1456 [ + - ]: 61407 : m_map_pubkeys[pubkey] = i;
1457 : : }
1458 : 57394 : m_max_cached_index++;
1459 : 57394 : }
1460 : : // Make sure the wallet knows about our new spks
1461 [ + - ]: 2513 : m_storage.TopUpCallback(new_spks, this);
1462 [ + - ]: 5026 : }
1463 : :
1464 : 2189 : bool DescriptorScriptPubKeyMan::AddKey(const CKeyID& key_id, const CKey& key)
1465 : : {
1466 : 2189 : LOCK(cs_desc_man);
1467 [ + - + - ]: 2189 : m_map_keys[key_id] = key;
1468 [ + - ]: 2189 : return true;
1469 : 2189 : }
1470 : :
1471 : 231 : bool DescriptorScriptPubKeyMan::AddCryptedKey(const CKeyID& key_id, const CPubKey& pubkey, const std::vector<unsigned char>& crypted_key)
1472 : : {
1473 : 231 : LOCK(cs_desc_man);
1474 [ + - ]: 231 : if (!m_map_keys.empty()) {
1475 : : return false;
1476 : : }
1477 : :
1478 [ + - + - ]: 462 : m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
1479 : 231 : return true;
1480 : 231 : }
1481 : :
1482 : 40 : bool DescriptorScriptPubKeyMan::HasWalletDescriptor(const WalletDescriptor& desc) const
1483 : : {
1484 : 40 : LOCK(cs_desc_man);
1485 [ + - + - : 120 : return !m_wallet_descriptor.id.IsNull() && !desc.id.IsNull() && m_wallet_descriptor.id == desc.id;
- + + - ]
1486 : 40 : }
1487 : :
1488 : 793 : void DescriptorScriptPubKeyMan::WriteDescriptor()
1489 : : {
1490 : 793 : LOCK(cs_desc_man);
1491 [ + - + - ]: 793 : WalletBatch batch(m_storage.GetDatabase());
1492 [ + - + - : 793 : if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
- + ]
1493 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
1494 : : }
1495 [ + - ]: 1586 : }
1496 : :
1497 : 57776 : WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const
1498 : : {
1499 : 57776 : return m_wallet_descriptor;
1500 : : }
1501 : :
1502 : 452 : std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys() const
1503 : : {
1504 : 452 : return GetScriptPubKeys(0);
1505 : : }
1506 : :
1507 : 577 : std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys(int32_t minimum_index) const
1508 : : {
1509 : 577 : LOCK(cs_desc_man);
1510 [ + - ]: 577 : std::unordered_set<CScript, SaltedSipHasher> script_pub_keys;
1511 [ + - ]: 577 : script_pub_keys.reserve(m_map_script_pub_keys.size());
1512 : :
1513 [ + + + + ]: 37474 : for (auto const& [script_pub_key, index] : m_map_script_pub_keys) {
1514 [ + + + - ]: 36897 : if (index >= minimum_index) script_pub_keys.insert(script_pub_key);
1515 : : }
1516 [ + - ]: 577 : return script_pub_keys;
1517 : 577 : }
1518 : :
1519 : 4968 : int32_t DescriptorScriptPubKeyMan::GetEndRange() const
1520 : : {
1521 : 4968 : return m_max_cached_index + 1;
1522 : : }
1523 : :
1524 : 1972 : bool DescriptorScriptPubKeyMan::GetDescriptorString(std::string& out, const bool priv) const
1525 : : {
1526 : 1972 : LOCK(cs_desc_man);
1527 : :
1528 : 1972 : FlatSigningProvider provider;
1529 [ + - ]: 3944 : provider.keys = GetKeys();
1530 : :
1531 [ + + ]: 1972 : if (priv) {
1532 : : // For the private version, always return the master key to avoid
1533 : : // exposing child private keys. The risk implications of exposing child
1534 : : // private keys together with the parent xpub may be non-obvious for users.
1535 [ + - ]: 448 : return m_wallet_descriptor.descriptor->ToPrivateString(provider, out);
1536 : : }
1537 : :
1538 [ + - ]: 1524 : return m_wallet_descriptor.descriptor->ToNormalizedString(provider, out, &m_wallet_descriptor.cache);
1539 [ + - ]: 3944 : }
1540 : :
1541 : 44 : void DescriptorScriptPubKeyMan::UpgradeDescriptorCache()
1542 : : {
1543 : 44 : LOCK(cs_desc_man);
1544 [ + - + - : 44 : if (m_storage.IsLocked() || m_storage.IsWalletFlagSet(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED)) {
+ - - + ]
1545 : 0 : return;
1546 : : }
1547 : :
1548 : : // Skip if we have the last hardened xpub cache
1549 [ + - + + ]: 44 : if (m_wallet_descriptor.cache.GetCachedLastHardenedExtPubKeys().size() > 0) {
1550 : : return;
1551 : : }
1552 : :
1553 : : // Expand the descriptor
1554 : 6 : FlatSigningProvider provider;
1555 [ + - ]: 12 : provider.keys = GetKeys();
1556 : 6 : FlatSigningProvider out_keys;
1557 : 6 : std::vector<CScript> scripts_temp;
1558 : 6 : DescriptorCache temp_cache;
1559 [ + - - + ]: 6 : if (!m_wallet_descriptor.descriptor->Expand(0, provider, scripts_temp, out_keys, &temp_cache)){
1560 [ # # ]: 0 : throw std::runtime_error("Unable to expand descriptor");
1561 : : }
1562 : :
1563 : : // Cache the last hardened xpubs
1564 [ + - ]: 6 : DescriptorCache diff = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
1565 [ + - + - : 12 : if (!WalletBatch(m_storage.GetDatabase()).WriteDescriptorCacheItems(GetID(), diff)) {
+ - + - -
+ ]
1566 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
1567 : : }
1568 [ + - ]: 50 : }
1569 : :
1570 : 20 : util::Result<void> DescriptorScriptPubKeyMan::UpdateWalletDescriptor(WalletDescriptor& descriptor)
1571 : : {
1572 : 20 : LOCK(cs_desc_man);
1573 [ + - ]: 20 : std::string error;
1574 [ + - + + ]: 20 : if (!CanUpdateToWalletDescriptor(descriptor, error)) {
1575 [ + - ]: 9 : return util::Error{Untranslated(std::move(error))};
1576 : : }
1577 : :
1578 : 17 : m_map_pubkeys.clear();
1579 : 17 : m_map_script_pub_keys.clear();
1580 : 17 : m_max_cached_index = -1;
1581 [ + - ]: 17 : m_wallet_descriptor = descriptor;
1582 : :
1583 [ + - ]: 17 : NotifyFirstKeyTimeChanged(this, m_wallet_descriptor.creation_time);
1584 : 17 : return {};
1585 [ + - ]: 40 : }
1586 : :
1587 : 20 : bool DescriptorScriptPubKeyMan::CanUpdateToWalletDescriptor(const WalletDescriptor& descriptor, std::string& error)
1588 : : {
1589 : 20 : LOCK(cs_desc_man);
1590 [ + - - + ]: 20 : if (!HasWalletDescriptor(descriptor)) {
1591 [ - - + - ]: 20 : error = "can only update matching descriptor";
1592 : : return false;
1593 : : }
1594 : :
1595 [ + - + + ]: 20 : if (!descriptor.descriptor->IsRange()) {
1596 : : // Skip range check for non-range descriptors
1597 : : return true;
1598 : : }
1599 : :
1600 [ + + ]: 15 : if (descriptor.range_start > m_wallet_descriptor.range_start ||
1601 [ + + ]: 13 : descriptor.range_end < m_wallet_descriptor.range_end) {
1602 : : // Use inclusive range for error
1603 : 6 : error = strprintf("new range must include current range = [%d,%d]",
1604 : 3 : m_wallet_descriptor.range_start,
1605 [ + - ]: 3 : m_wallet_descriptor.range_end - 1);
1606 : 3 : return false;
1607 : : }
1608 : :
1609 : : return true;
1610 : 20 : }
1611 : : } // namespace wallet
|
