Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
7 : :
8 : : #include <wallet/walletdb.h>
9 : :
10 : : #include <common/system.h>
11 : : #include <key_io.h>
12 : : #include <protocol.h>
13 : : #include <script/script.h>
14 : : #include <serialize.h>
15 : : #include <sync.h>
16 : : #include <util/bip32.h>
17 : : #include <util/check.h>
18 : : #include <util/fs.h>
19 : : #include <util/time.h>
20 : : #include <util/translation.h>
21 : : #ifdef USE_BDB
22 : : #include <wallet/bdb.h>
23 : : #endif
24 : : #include <wallet/migrate.h>
25 : : #ifdef USE_SQLITE
26 : : #include <wallet/sqlite.h>
27 : : #endif
28 : : #include <wallet/wallet.h>
29 : :
30 : : #include <atomic>
31 : : #include <optional>
32 : : #include <string>
33 : :
34 : : namespace wallet {
35 : : namespace DBKeys {
36 : : const std::string ACENTRY{"acentry"};
37 : : const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
38 : : const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
39 : : const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
40 : : const std::string BESTBLOCK{"bestblock"};
41 : : const std::string CRYPTED_KEY{"ckey"};
42 : : const std::string CSCRIPT{"cscript"};
43 : : const std::string DEFAULTKEY{"defaultkey"};
44 : : const std::string DESTDATA{"destdata"};
45 : : const std::string FLAGS{"flags"};
46 : : const std::string HDCHAIN{"hdchain"};
47 : : const std::string KEYMETA{"keymeta"};
48 : : const std::string KEY{"key"};
49 : : const std::string LOCKED_UTXO{"lockedutxo"};
50 : : const std::string MASTER_KEY{"mkey"};
51 : : const std::string MINVERSION{"minversion"};
52 : : const std::string NAME{"name"};
53 : : const std::string OLD_KEY{"wkey"};
54 : : const std::string ORDERPOSNEXT{"orderposnext"};
55 : : const std::string POOL{"pool"};
56 : : const std::string PURPOSE{"purpose"};
57 : : const std::string SETTINGS{"settings"};
58 : : const std::string TX{"tx"};
59 : : const std::string VERSION{"version"};
60 : : const std::string WALLETDESCRIPTOR{"walletdescriptor"};
61 : : const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
62 : : const std::string WALLETDESCRIPTORLHCACHE{"walletdescriptorlhcache"};
63 : : const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
64 : : const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
65 : : const std::string WATCHMETA{"watchmeta"};
66 : : const std::string WATCHS{"watchs"};
67 : : const std::unordered_set<std::string> LEGACY_TYPES{CRYPTED_KEY, CSCRIPT, DEFAULTKEY, HDCHAIN, KEYMETA, KEY, OLD_KEY, POOL, WATCHMETA, WATCHS};
68 : : } // namespace DBKeys
69 : :
70 : : //
71 : : // WalletBatch
72 : : //
73 : :
74 : 28369 : bool WalletBatch::WriteName(const std::string& strAddress, const std::string& strName)
75 : : {
76 [ + - ]: 56738 : return WriteIC(std::make_pair(DBKeys::NAME, strAddress), strName);
77 : : }
78 : :
79 : 20 : bool WalletBatch::EraseName(const std::string& strAddress)
80 : : {
81 : : // This should only be used for sending addresses, never for receiving addresses,
82 : : // receiving addresses must always have an address book entry if they're not change return.
83 [ + - ]: 40 : return EraseIC(std::make_pair(DBKeys::NAME, strAddress));
84 : : }
85 : :
86 : 28369 : bool WalletBatch::WritePurpose(const std::string& strAddress, const std::string& strPurpose)
87 : : {
88 [ + - ]: 56738 : return WriteIC(std::make_pair(DBKeys::PURPOSE, strAddress), strPurpose);
89 : : }
90 : :
91 : 20 : bool WalletBatch::ErasePurpose(const std::string& strAddress)
92 : : {
93 [ + - ]: 40 : return EraseIC(std::make_pair(DBKeys::PURPOSE, strAddress));
94 : : }
95 : :
96 : 22809 : bool WalletBatch::WriteTx(const CWalletTx& wtx)
97 : : {
98 [ + - ]: 22809 : return WriteIC(std::make_pair(DBKeys::TX, wtx.GetHash()), wtx);
99 : : }
100 : :
101 : 16 : bool WalletBatch::EraseTx(uint256 hash)
102 : : {
103 [ + - ]: 16 : return EraseIC(std::make_pair(DBKeys::TX, hash));
104 : : }
105 : :
106 : 5037 : bool WalletBatch::WriteKeyMetadata(const CKeyMetadata& meta, const CPubKey& pubkey, const bool overwrite)
107 : : {
108 [ + - ]: 5037 : return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
109 : : }
110 : :
111 : 1033 : bool WalletBatch::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata& keyMeta)
112 : : {
113 [ + - ]: 1033 : if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
114 : : return false;
115 : : }
116 : :
117 : : // hash pubkey/privkey to accelerate wallet load
118 : 1033 : std::vector<unsigned char> vchKey;
119 [ + - ]: 1033 : vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
120 [ + - ]: 1033 : vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
121 [ + - ]: 1033 : vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
122 : :
123 [ + - + - : 2066 : return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey)), false);
+ - ]
124 : 1033 : }
125 : :
126 : 4004 : bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
127 : : const std::vector<unsigned char>& vchCryptedSecret,
128 : : const CKeyMetadata &keyMeta)
129 : : {
130 [ + - ]: 4004 : if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
131 : : return false;
132 : : }
133 : :
134 : : // Compute a checksum of the encrypted key
135 : 4004 : uint256 checksum = Hash(vchCryptedSecret);
136 : :
137 : 4004 : const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
138 [ + - + - : 4004 : if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
- + ]
139 : : // It may already exist, so try writing just the checksum
140 : 0 : std::vector<unsigned char> val;
141 [ # # # # ]: 0 : if (!m_batch->Read(key, val)) {
142 : : return false;
143 : : }
144 [ # # # # : 0 : if (!WriteIC(key, std::make_pair(val, checksum), true)) {
# # ]
145 : : return false;
146 : : }
147 : 0 : }
148 [ + - + - ]: 4004 : EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
149 : 4004 : return true;
150 : 4004 : }
151 : :
152 : 27 : bool WalletBatch::WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
153 : : {
154 [ + - ]: 27 : return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
155 : : }
156 : :
157 : 1 : bool WalletBatch::EraseMasterKey(unsigned int id)
158 : : {
159 [ + - ]: 1 : return EraseIC(std::make_pair(DBKeys::MASTER_KEY, id));
160 : : }
161 : :
162 : 23 : bool WalletBatch::WriteCScript(const uint160& hash, const CScript& redeemScript)
163 : : {
164 [ + - ]: 23 : return WriteIC(std::make_pair(DBKeys::CSCRIPT, hash), redeemScript, false);
165 : : }
166 : :
167 : 2 : bool WalletBatch::WriteWatchOnly(const CScript &dest, const CKeyMetadata& keyMeta)
168 : : {
169 [ + - + - ]: 6 : if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
170 : : return false;
171 : : }
172 [ + - ]: 6 : return WriteIC(std::make_pair(DBKeys::WATCHS, dest), uint8_t{'1'});
173 : : }
174 : :
175 : 5 : bool WalletBatch::EraseWatchOnly(const CScript &dest)
176 : : {
177 [ + - + - ]: 15 : if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
178 : : return false;
179 : : }
180 [ + - ]: 15 : return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
181 : : }
182 : :
183 : 1093 : bool WalletBatch::WriteBestBlock(const CBlockLocator& locator)
184 : : {
185 [ + - ]: 1093 : WriteIC(DBKeys::BESTBLOCK, CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
186 : 1093 : return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
187 : : }
188 : :
189 : 1526 : bool WalletBatch::ReadBestBlock(CBlockLocator& locator)
190 : : {
191 [ + + + - ]: 1526 : if (m_batch->Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) return true;
192 : 1526 : return m_batch->Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
193 : : }
194 : :
195 : 0 : bool WalletBatch::IsEncrypted()
196 : : {
197 : 0 : DataStream prefix;
198 [ # # ]: 0 : prefix << DBKeys::MASTER_KEY;
199 [ # # # # ]: 0 : if (auto cursor = m_batch->GetNewPrefixCursor(prefix)) {
200 : 0 : DataStream k, v;
201 [ # # # # ]: 0 : if (cursor->Next(k, v) == DatabaseCursor::Status::MORE) return true;
202 : 0 : }
203 : 0 : return false;
204 : 0 : }
205 : :
206 : 17843 : bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext)
207 : : {
208 : 17843 : return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
209 : : }
210 : :
211 : 1 : bool WalletBatch::ReadPool(int64_t nPool, CKeyPool& keypool)
212 : : {
213 [ + - ]: 1 : return m_batch->Read(std::make_pair(DBKeys::POOL, nPool), keypool);
214 : : }
215 : :
216 : 2004 : bool WalletBatch::WritePool(int64_t nPool, const CKeyPool& keypool)
217 : : {
218 [ + - ]: 2004 : return WriteIC(std::make_pair(DBKeys::POOL, nPool), keypool);
219 : : }
220 : :
221 : 1000 : bool WalletBatch::ErasePool(int64_t nPool)
222 : : {
223 [ + - ]: 1000 : return EraseIC(std::make_pair(DBKeys::POOL, nPool));
224 : : }
225 : :
226 : 501 : bool WalletBatch::WriteMinVersion(int nVersion)
227 : : {
228 : 501 : return WriteIC(DBKeys::MINVERSION, nVersion);
229 : : }
230 : :
231 : 3103 : bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256& id, bool internal)
232 : : {
233 [ + + ]: 4686 : std::string key = internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
234 [ + - + - ]: 3103 : return WriteIC(make_pair(key, type), id);
235 : 3103 : }
236 : :
237 : 1 : bool WalletBatch::EraseActiveScriptPubKeyMan(uint8_t type, bool internal)
238 : : {
239 [ - + ]: 1 : const std::string key{internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK};
240 [ + - + - ]: 1 : return EraseIC(make_pair(key, type));
241 : 1 : }
242 : :
243 : 3272 : bool WalletBatch::WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const CPrivKey& privkey)
244 : : {
245 : : // hash pubkey/privkey to accelerate wallet load
246 : 3272 : std::vector<unsigned char> key;
247 [ + - ]: 3272 : key.reserve(pubkey.size() + privkey.size());
248 [ + - ]: 3272 : key.insert(key.end(), pubkey.begin(), pubkey.end());
249 [ + - ]: 3272 : key.insert(key.end(), privkey.begin(), privkey.end());
250 : :
251 [ + - + - : 6544 : return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)), std::make_pair(privkey, Hash(key)), false);
+ - ]
252 : 3272 : }
253 : :
254 : 265 : bool WalletBatch::WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret)
255 : : {
256 [ + - + - ]: 265 : if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY, std::make_pair(desc_id, pubkey)), secret, false)) {
257 : : return false;
258 : : }
259 [ + - ]: 265 : EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)));
260 : 265 : return true;
261 : : }
262 : :
263 : 94472 : bool WalletBatch::WriteDescriptor(const uint256& desc_id, const WalletDescriptor& descriptor)
264 : : {
265 [ + - ]: 94472 : return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
266 : : }
267 : :
268 : 10930 : bool WalletBatch::WriteDescriptorDerivedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index, uint32_t der_index)
269 : : {
270 : 10930 : std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
271 [ + - ]: 10930 : xpub.Encode(ser_xpub.data());
272 [ + - + - ]: 10930 : return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), std::make_pair(key_exp_index, der_index)), ser_xpub);
273 : 10930 : }
274 : :
275 : 3617 : bool WalletBatch::WriteDescriptorParentCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
276 : : {
277 : 3617 : std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
278 [ + - ]: 3617 : xpub.Encode(ser_xpub.data());
279 [ + - + - ]: 3617 : return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), key_exp_index), ser_xpub);
280 : 3617 : }
281 : :
282 : 2906 : bool WalletBatch::WriteDescriptorLastHardenedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
283 : : {
284 : 2906 : std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
285 [ + - ]: 2906 : xpub.Encode(ser_xpub.data());
286 [ + - + - ]: 2906 : return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORLHCACHE, desc_id), key_exp_index), ser_xpub);
287 : 2906 : }
288 : :
289 : 433629 : bool WalletBatch::WriteDescriptorCacheItems(const uint256& desc_id, const DescriptorCache& cache)
290 : : {
291 [ + + ]: 437246 : for (const auto& parent_xpub_pair : cache.GetCachedParentExtPubKeys()) {
292 [ + - - + ]: 3617 : if (!WriteDescriptorParentCache(parent_xpub_pair.second, desc_id, parent_xpub_pair.first)) {
293 : 0 : return false;
294 : : }
295 : 0 : }
296 [ + + ]: 444559 : for (const auto& derived_xpub_map_pair : cache.GetCachedDerivedExtPubKeys()) {
297 [ + + ]: 21860 : for (const auto& derived_xpub_pair : derived_xpub_map_pair.second) {
298 [ + - - + ]: 10930 : if (!WriteDescriptorDerivedCache(derived_xpub_pair.second, desc_id, derived_xpub_map_pair.first, derived_xpub_pair.first)) {
299 : 0 : return false;
300 : : }
301 : : }
302 : 0 : }
303 [ + + ]: 436535 : for (const auto& lh_xpub_pair : cache.GetCachedLastHardenedExtPubKeys()) {
304 [ + - - + ]: 2906 : if (!WriteDescriptorLastHardenedCache(lh_xpub_pair.second, desc_id, lh_xpub_pair.first)) {
305 : 0 : return false;
306 : : }
307 : 0 : }
308 : 433629 : return true;
309 : : }
310 : :
311 : 1 : bool WalletBatch::WriteLockedUTXO(const COutPoint& output)
312 : : {
313 [ + - ]: 1 : return WriteIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)), uint8_t{'1'});
314 : : }
315 : :
316 : 58 : bool WalletBatch::EraseLockedUTXO(const COutPoint& output)
317 : : {
318 [ + - ]: 58 : return EraseIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)));
319 : : }
320 : :
321 : 98 : bool LoadKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
322 : : {
323 : 98 : LOCK(pwallet->cs_wallet);
324 : 98 : try {
325 [ + - ]: 98 : CPubKey vchPubKey;
326 [ + - ]: 98 : ssKey >> vchPubKey;
327 [ - + ]: 98 : if (!vchPubKey.IsValid())
328 : : {
329 [ - - + - ]: 98 : strErr = "Error reading wallet database: CPubKey corrupt";
330 : : return false;
331 : : }
332 : 98 : CKey key;
333 : 98 : CPrivKey pkey;
334 : 98 : uint256 hash;
335 : :
336 [ + - ]: 98 : ssValue >> pkey;
337 : :
338 : : // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey]
339 : : // ... which was slow for wallets with lots of keys, because the public key is re-derived from the private key
340 : : // using EC operations as a checksum.
341 : : // Newer wallets store keys as DBKeys::KEY [pubkey] => [privkey][hash(pubkey,privkey)], which is much faster while
342 : : // remaining backwards-compatible.
343 : 98 : try
344 : : {
345 [ + - ]: 98 : ssValue >> hash;
346 : : }
347 [ - - ]: 0 : catch (const std::ios_base::failure&) {}
348 : :
349 : 98 : bool fSkipCheck = false;
350 : :
351 [ + - ]: 98 : if (!hash.IsNull())
352 : : {
353 : : // hash pubkey/privkey to accelerate wallet load
354 : 98 : std::vector<unsigned char> vchKey;
355 [ + - ]: 98 : vchKey.reserve(vchPubKey.size() + pkey.size());
356 [ + - ]: 98 : vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
357 [ + - ]: 98 : vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
358 : :
359 [ + - - + ]: 98 : if (Hash(vchKey) != hash)
360 : : {
361 [ # # ]: 0 : strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
362 : 0 : return false;
363 : : }
364 : :
365 : 98 : fSkipCheck = true;
366 : 98 : }
367 : :
368 [ + - - + ]: 98 : if (!key.Load(pkey, vchPubKey, fSkipCheck))
369 : : {
370 [ # # ]: 0 : strErr = "Error reading wallet database: CPrivKey corrupt";
371 : : return false;
372 : : }
373 [ + - + - : 98 : if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadKey(key, vchPubKey))
- + ]
374 : : {
375 [ # # ]: 0 : strErr = "Error reading wallet database: LegacyDataSPKM::LoadKey failed";
376 : : return false;
377 : : }
378 [ - - ]: 98 : } catch (const std::exception& e) {
379 [ - - ]: 0 : if (strErr.empty()) {
380 [ - - ]: 0 : strErr = e.what();
381 : : }
382 : 0 : return false;
383 : 0 : }
384 : 98 : return true;
385 : 98 : }
386 : :
387 : 8033 : bool LoadCryptedKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
388 : : {
389 : 8033 : LOCK(pwallet->cs_wallet);
390 : 8033 : try {
391 [ + - ]: 8033 : CPubKey vchPubKey;
392 [ + - ]: 8033 : ssKey >> vchPubKey;
393 [ + + ]: 8033 : if (!vchPubKey.IsValid())
394 : : {
395 [ + - + - ]: 8033 : strErr = "Error reading wallet database: CPubKey corrupt";
396 : : return false;
397 : : }
398 : 8032 : std::vector<unsigned char> vchPrivKey;
399 [ + - ]: 8032 : ssValue >> vchPrivKey;
400 : :
401 : : // Get the checksum and check it
402 : 8032 : bool checksum_valid = false;
403 [ + + ]: 8032 : if (!ssValue.eof()) {
404 : 8031 : uint256 checksum;
405 [ + - ]: 8031 : ssValue >> checksum;
406 [ + - + + ]: 8031 : if (!(checksum_valid = Hash(vchPrivKey) == checksum)) {
407 [ + - ]: 2 : strErr = "Error reading wallet database: Encrypted key corrupt";
408 : : return false;
409 : : }
410 : : }
411 : :
412 [ + - + - : 8030 : if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCryptedKey(vchPubKey, vchPrivKey, checksum_valid))
- + ]
413 : : {
414 [ - - ]: 2 : strErr = "Error reading wallet database: LegacyDataSPKM::LoadCryptedKey failed";
415 : : return false;
416 : : }
417 [ - - ]: 2 : } catch (const std::exception& e) {
418 [ - - ]: 0 : if (strErr.empty()) {
419 [ - - ]: 0 : strErr = e.what();
420 : : }
421 : 0 : return false;
422 : 0 : }
423 : 8030 : return true;
424 : 8033 : }
425 : :
426 : 23 : bool LoadEncryptionKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
427 : : {
428 : 23 : LOCK(pwallet->cs_wallet);
429 : 23 : try {
430 : : // Master encryption key is loaded into only the wallet and not any of the ScriptPubKeyMans.
431 : 23 : unsigned int nID;
432 [ + - ]: 23 : ssKey >> nID;
433 [ + - ]: 23 : CMasterKey kMasterKey;
434 [ + - ]: 23 : ssValue >> kMasterKey;
435 [ - + ]: 23 : if(pwallet->mapMasterKeys.count(nID) != 0)
436 : : {
437 [ # # ]: 0 : strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
438 : 0 : return false;
439 : : }
440 [ + - + - ]: 23 : pwallet->mapMasterKeys[nID] = kMasterKey;
441 [ + - ]: 23 : if (pwallet->nMasterKeyMaxID < nID)
442 : 23 : pwallet->nMasterKeyMaxID = nID;
443 : :
444 [ # # ]: 0 : } catch (const std::exception& e) {
445 [ - - ]: 0 : if (strErr.empty()) {
446 [ - - ]: 0 : strErr = e.what();
447 : : }
448 : 0 : return false;
449 : 0 : }
450 : 23 : return true;
451 : 23 : }
452 : :
453 : 25 : bool LoadHDChain(CWallet* pwallet, DataStream& ssValue, std::string& strErr)
454 : : {
455 : 25 : LOCK(pwallet->cs_wallet);
456 : 25 : try {
457 : 25 : CHDChain chain;
458 [ + - ]: 25 : ssValue >> chain;
459 [ + - + - ]: 25 : pwallet->GetOrCreateLegacyDataSPKM()->LoadHDChain(chain);
460 [ - - ]: 0 : } catch (const std::exception& e) {
461 [ - - ]: 0 : if (strErr.empty()) {
462 [ - - ]: 0 : strErr = e.what();
463 : : }
464 : 0 : return false;
465 : 0 : }
466 : : return true;
467 : 25 : }
468 : :
469 : 856 : static DBErrors LoadMinVersion(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
470 : : {
471 : 856 : AssertLockHeld(pwallet->cs_wallet);
472 : 856 : int nMinVersion = 0;
473 [ + + ]: 856 : if (batch.Read(DBKeys::MINVERSION, nMinVersion)) {
474 [ + - ]: 298 : if (nMinVersion > FEATURE_LATEST)
475 : : return DBErrors::TOO_NEW;
476 : 298 : pwallet->LoadMinVersion(nMinVersion);
477 : : }
478 : : return DBErrors::LOAD_OK;
479 : : }
480 : :
481 : 856 : static DBErrors LoadWalletFlags(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
482 : : {
483 : 856 : AssertLockHeld(pwallet->cs_wallet);
484 : 856 : uint64_t flags;
485 [ + + ]: 856 : if (batch.Read(DBKeys::FLAGS, flags)) {
486 [ - + ]: 302 : if (!pwallet->LoadWalletFlags(flags)) {
487 : 0 : pwallet->WalletLogPrintf("Error reading wallet database: Unknown non-tolerable wallet flags found\n");
488 : 0 : return DBErrors::TOO_NEW;
489 : : }
490 : : }
491 : : return DBErrors::LOAD_OK;
492 : : }
493 : :
494 : : struct LoadResult
495 : : {
496 : : DBErrors m_result{DBErrors::LOAD_OK};
497 : : int m_records{0};
498 : : };
499 : :
500 : : using LoadFunc = std::function<DBErrors(CWallet* pwallet, DataStream& key, DataStream& value, std::string& err)>;
501 : 23305 : static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, DataStream& prefix, LoadFunc load_func)
502 : : {
503 : 23305 : LoadResult result;
504 : 23305 : DataStream ssKey;
505 : 23305 : DataStream ssValue{};
506 : :
507 [ + - ]: 23305 : Assume(!prefix.empty());
508 [ + - ]: 23305 : std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
509 [ - + ]: 23305 : if (!cursor) {
510 [ # # ]: 0 : pwallet->WalletLogPrintf("Error getting database cursor for '%s' records\n", key);
511 : 0 : result.m_result = DBErrors::CORRUPT;
512 : 0 : return result;
513 : : }
514 : :
515 : 111105 : while (true) {
516 [ + - ]: 67205 : DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
517 [ + + ]: 67205 : if (status == DatabaseCursor::Status::DONE) {
518 : : break;
519 [ - + ]: 43900 : } else if (status == DatabaseCursor::Status::FAIL) {
520 [ # # ]: 0 : pwallet->WalletLogPrintf("Error reading next '%s' record for wallet database\n", key);
521 : 0 : result.m_result = DBErrors::CORRUPT;
522 : 0 : return result;
523 : : }
524 [ + - ]: 43900 : std::string type;
525 [ + - ]: 43900 : ssKey >> type;
526 [ - + ]: 43900 : assert(type == key);
527 [ + - + - ]: 87800 : std::string error;
528 [ + - ]: 43900 : DBErrors record_res = load_func(pwallet, ssKey, ssValue, error);
529 [ + + ]: 43900 : if (record_res != DBErrors::LOAD_OK) {
530 [ + - ]: 5 : pwallet->WalletLogPrintf("%s\n", error);
531 : : }
532 [ + + ]: 43900 : result.m_result = std::max(result.m_result, record_res);
533 : 43900 : ++result.m_records;
534 : 43900 : }
535 : 23305 : return result;
536 : 23305 : }
537 : :
538 : 14401 : static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, LoadFunc load_func)
539 : : {
540 : 14401 : DataStream prefix;
541 [ + - ]: 14401 : prefix << key;
542 [ + - + - ]: 28802 : return LoadRecords(pwallet, batch, key, prefix, load_func);
543 : 14401 : }
544 : :
545 : 856 : static DBErrors LoadLegacyWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
546 : : {
547 : 856 : AssertLockHeld(pwallet->cs_wallet);
548 : 856 : DBErrors result = DBErrors::LOAD_OK;
549 : :
550 : : // Make sure descriptor wallets don't have any legacy records
551 [ + + ]: 856 : if (pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
552 [ + + ]: 2978 : for (const auto& type : DBKeys::LEGACY_TYPES) {
553 : 2708 : DataStream key;
554 : 2708 : DataStream value{};
555 : :
556 : 2708 : DataStream prefix;
557 [ + - ]: 2708 : prefix << type;
558 [ + - ]: 2708 : std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
559 [ - + ]: 2708 : if (!cursor) {
560 [ # # ]: 0 : pwallet->WalletLogPrintf("Error getting database cursor for '%s' records\n", type);
561 : : return DBErrors::CORRUPT;
562 : : }
563 : :
564 [ + - ]: 2708 : DatabaseCursor::Status status = cursor->Next(key, value);
565 [ + + ]: 2708 : if (status != DatabaseCursor::Status::DONE) {
566 [ + - ]: 1 : pwallet->WalletLogPrintf("Error: Unexpected legacy entry found in descriptor wallet %s. The wallet might have been tampered with or created with malicious intent.\n", pwallet->GetName());
567 : : return DBErrors::UNEXPECTED_LEGACY_ENTRY;
568 : : }
569 : 2708 : }
570 : :
571 : : return DBErrors::LOAD_OK;
572 : : }
573 : :
574 : : // Load HD Chain
575 : : // Note: There should only be one HDCHAIN record with no data following the type
576 [ + - ]: 585 : LoadResult hd_chain_res = LoadRecords(pwallet, batch, DBKeys::HDCHAIN,
577 : 25 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
578 [ - + ]: 25 : return LoadHDChain(pwallet, value, err) ? DBErrors:: LOAD_OK : DBErrors::CORRUPT;
579 : : });
580 [ + - ]: 585 : result = std::max(result, hd_chain_res.m_result);
581 : :
582 : : // Load unencrypted keys
583 [ + - ]: 585 : LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::KEY,
584 : 98 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
585 [ - + ]: 98 : return LoadKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
586 : : });
587 [ + - ]: 585 : result = std::max(result, key_res.m_result);
588 : :
589 : : // Load encrypted keys
590 [ + - ]: 585 : LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::CRYPTED_KEY,
591 : 8033 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
592 [ + + ]: 8033 : return LoadCryptedKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
593 : : });
594 [ + + ]: 585 : result = std::max(result, ckey_res.m_result);
595 : :
596 : : // Load scripts
597 [ + - ]: 585 : LoadResult script_res = LoadRecords(pwallet, batch, DBKeys::CSCRIPT,
598 : 64 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
599 : 64 : uint160 hash;
600 : 64 : key >> hash;
601 : 64 : CScript script;
602 [ + - ]: 64 : value >> script;
603 [ + - + - : 64 : if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCScript(script))
- + ]
604 : : {
605 [ - - ]: 64 : strErr = "Error reading wallet database: LegacyDataSPKM::LoadCScript failed";
606 : : return DBErrors::NONCRITICAL_ERROR;
607 : : }
608 : : return DBErrors::LOAD_OK;
609 : 64 : });
610 [ + - ]: 585 : result = std::max(result, script_res.m_result);
611 : :
612 : : // Check whether rewrite is needed
613 [ + + ]: 585 : if (ckey_res.m_records > 0) {
614 : : // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
615 [ - + - - ]: 8 : if (last_client == 40000 || last_client == 50000) result = std::max(result, DBErrors::NEED_REWRITE);
616 : : }
617 : :
618 : : // Load keymeta
619 [ + - ]: 585 : std::map<uint160, CHDChain> hd_chains;
620 : 0 : LoadResult keymeta_res = LoadRecords(pwallet, batch, DBKeys::KEYMETA,
621 [ + - ]: 585 : [&hd_chains] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
622 : 8133 : CPubKey vchPubKey;
623 : 8133 : key >> vchPubKey;
624 : 8133 : CKeyMetadata keyMeta;
625 [ + - ]: 8133 : value >> keyMeta;
626 [ + - + - : 8133 : pwallet->GetOrCreateLegacyDataSPKM()->LoadKeyMetadata(vchPubKey.GetID(), keyMeta);
+ - ]
627 : :
628 : : // Extract some CHDChain info from this metadata if it has any
629 [ + - + + : 8133 : if (keyMeta.nVersion >= CKeyMetadata::VERSION_WITH_HDDATA && !keyMeta.hd_seed_id.IsNull() && keyMeta.hdKeypath.size() > 0) {
+ - ]
630 : : // Get the path from the key origin or from the path string
631 : : // Not applicable when path is "s" or "m" as those indicate a seed
632 : : // See https://github.com/bitcoin/bitcoin/pull/12924
633 : 8129 : bool internal = false;
634 : 8129 : uint32_t index = 0;
635 [ + + + - ]: 8129 : if (keyMeta.hdKeypath != "s" && keyMeta.hdKeypath != "m") {
636 : 8095 : std::vector<uint32_t> path;
637 [ + - ]: 8095 : if (keyMeta.has_key_origin) {
638 : : // We have a key origin, so pull it from its path vector
639 [ + - ]: 8095 : path = keyMeta.key_origin.path;
640 : : } else {
641 : : // No key origin, have to parse the string
642 [ # # # # ]: 0 : if (!ParseHDKeypath(keyMeta.hdKeypath, path)) {
643 [ # # ]: 0 : strErr = "Error reading wallet database: keymeta with invalid HD keypath";
644 : : return DBErrors::NONCRITICAL_ERROR;
645 : : }
646 : : }
647 : :
648 : : // Extract the index and internal from the path
649 : : // Path string is m/0'/k'/i'
650 : : // Path vector is [0', k', i'] (but as ints OR'd with the hardened bit
651 : : // k == 0 for external, 1 for internal. i is the index
652 [ - + ]: 8095 : if (path.size() != 3) {
653 [ # # ]: 0 : strErr = "Error reading wallet database: keymeta found with unexpected path";
654 : : return DBErrors::NONCRITICAL_ERROR;
655 : : }
656 [ - + ]: 8095 : if (path[0] != 0x80000000) {
657 [ # # ]: 0 : strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000) for the element at index 0", path[0]);
658 : 0 : return DBErrors::NONCRITICAL_ERROR;
659 : : }
660 [ + + + - ]: 8095 : if (path[1] != 0x80000000 && path[1] != (1 | 0x80000000)) {
661 [ # # ]: 0 : strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000 or 0x80000001) for the element at index 1", path[1]);
662 : 0 : return DBErrors::NONCRITICAL_ERROR;
663 : : }
664 [ - + ]: 8095 : if ((path[2] & 0x80000000) == 0) {
665 [ # # ]: 0 : strErr = strprintf("Unexpected path index of 0x%08x (expected to be greater than or equal to 0x80000000)", path[2]);
666 : 0 : return DBErrors::NONCRITICAL_ERROR;
667 : : }
668 : 8095 : internal = path[1] == (1 | 0x80000000);
669 : 8095 : index = path[2] & ~0x80000000;
670 : 8095 : }
671 : :
672 : : // Insert a new CHDChain, or get the one that already exists
673 [ + - + + ]: 8129 : auto [ins, inserted] = hd_chains.emplace(keyMeta.hd_seed_id, CHDChain());
674 [ + + ]: 8129 : CHDChain& chain = ins->second;
675 [ + + ]: 8129 : if (inserted) {
676 : : // For new chains, we want to default to VERSION_HD_BASE until we see an internal
677 : 34 : chain.nVersion = CHDChain::VERSION_HD_BASE;
678 : 34 : chain.seed_id = keyMeta.hd_seed_id;
679 : : }
680 [ + + ]: 8129 : if (internal) {
681 : 37 : chain.nVersion = CHDChain::VERSION_HD_CHAIN_SPLIT;
682 [ + + ]: 45 : chain.nInternalChainCounter = std::max(chain.nInternalChainCounter, index + 1);
683 : : } else {
684 [ + + ]: 16090 : chain.nExternalChainCounter = std::max(chain.nExternalChainCounter, index + 1);
685 : : }
686 : : }
687 : : return DBErrors::LOAD_OK;
688 : 8133 : });
689 [ + - ]: 585 : result = std::max(result, keymeta_res.m_result);
690 : :
691 : : // Set inactive chains
692 [ + + ]: 585 : if (!hd_chains.empty()) {
693 [ + - ]: 25 : LegacyDataSPKM* legacy_spkm = pwallet->GetLegacyDataSPKM();
694 [ + - ]: 25 : if (legacy_spkm) {
695 [ + + + + ]: 59 : for (const auto& [hd_seed_id, chain] : hd_chains) {
696 [ + + ]: 34 : if (hd_seed_id != legacy_spkm->GetHDChain().seed_id) {
697 [ + - ]: 9 : legacy_spkm->AddInactiveHDChain(chain);
698 : : }
699 : : }
700 : : } else {
701 [ # # ]: 0 : pwallet->WalletLogPrintf("Inactive HD Chains found but no Legacy ScriptPubKeyMan\n");
702 : 0 : result = DBErrors::CORRUPT;
703 : : }
704 : : }
705 : :
706 : : // Load watchonly scripts
707 [ + - ]: 585 : LoadResult watch_script_res = LoadRecords(pwallet, batch, DBKeys::WATCHS,
708 : 32 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
709 : 32 : CScript script;
710 [ + - ]: 32 : key >> script;
711 : 32 : uint8_t fYes;
712 [ + - ]: 32 : value >> fYes;
713 [ + - ]: 32 : if (fYes == '1') {
714 [ + - + - ]: 32 : pwallet->GetOrCreateLegacyDataSPKM()->LoadWatchOnly(script);
715 : : }
716 : 32 : return DBErrors::LOAD_OK;
717 : 32 : });
718 [ + - ]: 585 : result = std::max(result, watch_script_res.m_result);
719 : :
720 : : // Load watchonly meta
721 [ + - ]: 585 : LoadResult watch_meta_res = LoadRecords(pwallet, batch, DBKeys::WATCHMETA,
722 : 32 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
723 : 32 : CScript script;
724 [ + - ]: 32 : key >> script;
725 : 32 : CKeyMetadata keyMeta;
726 [ + - ]: 32 : value >> keyMeta;
727 [ + - + - : 32 : pwallet->GetOrCreateLegacyDataSPKM()->LoadScriptMetadata(CScriptID(script), keyMeta);
+ - ]
728 : 32 : return DBErrors::LOAD_OK;
729 : 32 : });
730 [ + - ]: 585 : result = std::max(result, watch_meta_res.m_result);
731 : :
732 : : // Load keypool
733 [ + - ]: 585 : LoadResult pool_res = LoadRecords(pwallet, batch, DBKeys::POOL,
734 : 4037 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
735 : 4037 : int64_t nIndex;
736 : 4037 : key >> nIndex;
737 : 4037 : CKeyPool keypool;
738 : 4037 : value >> keypool;
739 : 4037 : pwallet->GetOrCreateLegacyDataSPKM()->LoadKeyPool(nIndex, keypool);
740 : 4037 : return DBErrors::LOAD_OK;
741 : : });
742 [ + - ]: 585 : result = std::max(result, pool_res.m_result);
743 : :
744 : : // Deal with old "wkey" and "defaultkey" records.
745 : : // These are not actually loaded, but we need to check for them
746 : :
747 : : // We don't want or need the default key, but if there is one set,
748 : : // we want to make sure that it is valid so that we can detect corruption
749 : : // Note: There should only be one DEFAULTKEY with nothing trailing the type
750 [ + - ]: 585 : LoadResult default_key_res = LoadRecords(pwallet, batch, DBKeys::DEFAULTKEY,
751 : 0 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
752 [ # # ]: 0 : CPubKey default_pubkey;
753 : 0 : try {
754 [ # # ]: 0 : value >> default_pubkey;
755 [ - - ]: 0 : } catch (const std::exception& e) {
756 [ - - ]: 0 : err = e.what();
757 : 0 : return DBErrors::CORRUPT;
758 : 0 : }
759 [ # # ]: 0 : if (!default_pubkey.IsValid()) {
760 : 0 : err = "Error reading wallet database: Default Key corrupt";
761 : 0 : return DBErrors::CORRUPT;
762 : : }
763 : : return DBErrors::LOAD_OK;
764 : : });
765 [ + - ]: 585 : result = std::max(result, default_key_res.m_result);
766 : :
767 : : // "wkey" records are unsupported, if we see any, throw an error
768 [ + - ]: 585 : LoadResult wkey_res = LoadRecords(pwallet, batch, DBKeys::OLD_KEY,
769 : 0 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
770 : 0 : err = "Found unsupported 'wkey' record, try loading with version 0.18";
771 : 0 : return DBErrors::LOAD_FAIL;
772 : : });
773 [ + - ]: 585 : result = std::max(result, wkey_res.m_result);
774 : :
775 [ + + ]: 585 : if (result <= DBErrors::NONCRITICAL_ERROR) {
776 : : // Only do logging and time first key update if there were no critical errors
777 : 583 : pwallet->WalletLogPrintf("Legacy Wallet Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total.\n",
778 [ + - ]: 583 : key_res.m_records, ckey_res.m_records, keymeta_res.m_records, key_res.m_records + ckey_res.m_records);
779 : :
780 : : // nTimeFirstKey is only reliable if all keys have metadata
781 [ + - + - : 583 : if (pwallet->IsLegacy() && (key_res.m_records + ckey_res.m_records + watch_script_res.m_records) != (keymeta_res.m_records + watch_meta_res.m_records)) {
+ + ]
782 [ + - ]: 2 : auto spk_man = pwallet->GetLegacyScriptPubKeyMan();
783 [ - + ]: 2 : if (spk_man) {
784 [ # # ]: 0 : LOCK(spk_man->cs_KeyStore);
785 [ # # ]: 0 : spk_man->UpdateTimeFirstKey(1);
786 : 0 : }
787 : : }
788 : : }
789 : :
790 : 585 : return result;
791 : 585 : }
792 : :
793 : : template<typename... Args>
794 : 8904 : static DataStream PrefixStream(const Args&... args)
795 : : {
796 : 8904 : DataStream prefix;
797 [ + - ]: 8904 : SerializeMany(prefix, args...);
798 : 8904 : return prefix;
799 : 0 : }
800 : :
801 : 856 : static DBErrors LoadDescriptorWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
802 : : {
803 : 856 : AssertLockHeld(pwallet->cs_wallet);
804 : :
805 : : // Load descriptor record
806 : 856 : int num_keys = 0;
807 : 856 : int num_ckeys= 0;
808 [ + - ]: 856 : LoadResult desc_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTOR,
809 : 856 : [&batch, &num_keys, &num_ckeys, &last_client] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
810 : 2228 : DBErrors result = DBErrors::LOAD_OK;
811 : :
812 : 2228 : uint256 id;
813 : 2228 : key >> id;
814 : 2228 : WalletDescriptor desc;
815 : 2228 : try {
816 [ + + ]: 2228 : value >> desc;
817 [ - + ]: 1 : } catch (const std::ios_base::failure& e) {
818 [ + - ]: 1 : strErr = strprintf("Error: Unrecognized descriptor found in wallet %s. ", pwallet->GetName());
819 : 1 : strErr += (last_client > CLIENT_VERSION) ? "The wallet might had been created on a newer version. " :
820 [ + - ]: 1 : "The database might be corrupted or the software version is not compatible with one of your wallet descriptors. ";
821 [ + - ]: 1 : strErr += "Please try running the latest software version";
822 : : // Also include error details
823 [ + - ]: 1 : strErr = strprintf("%s\nDetails: %s", strErr, e.what());
824 : 1 : return DBErrors::UNKNOWN_DESCRIPTOR;
825 : 1 : }
826 [ + - ]: 2227 : DescriptorScriptPubKeyMan& spkm = pwallet->LoadDescriptorScriptPubKeyMan(id, desc);
827 : :
828 : : // Prior to doing anything with this spkm, verify ID compatibility
829 [ + - + + ]: 2227 : if (id != spkm.GetID()) {
830 [ + - ]: 1 : strErr = "The descriptor ID calculated by the wallet differs from the one in DB";
831 : : return DBErrors::CORRUPT;
832 : : }
833 : :
834 : 2226 : DescriptorCache cache;
835 : :
836 : : // Get key cache for this descriptor
837 [ + - ]: 2226 : DataStream prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCACHE, id);
838 : 0 : LoadResult key_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCACHE, prefix,
839 [ + - ]: 2226 : [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
840 : 2108 : bool parent = true;
841 : 2108 : uint256 desc_id;
842 : 2108 : uint32_t key_exp_index;
843 : 2108 : uint32_t der_index;
844 : 2108 : key >> desc_id;
845 [ - + ]: 2108 : assert(desc_id == id);
846 : 2108 : key >> key_exp_index;
847 : :
848 : : // if the der_index exists, it's a derived xpub
849 : 2108 : try
850 : : {
851 [ + + ]: 2108 : key >> der_index;
852 : : parent = false;
853 : : }
854 : 2001 : catch (...) {}
855 : :
856 : 2108 : std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
857 [ + - ]: 2108 : value >> ser_xpub;
858 [ + - ]: 2108 : CExtPubKey xpub;
859 [ + - ]: 2108 : xpub.Decode(ser_xpub.data());
860 [ + + ]: 2108 : if (parent) {
861 [ + - ]: 2001 : cache.CacheParentExtPubKey(key_exp_index, xpub);
862 : : } else {
863 [ + - ]: 107 : cache.CacheDerivedExtPubKey(key_exp_index, der_index, xpub);
864 : : }
865 : 2108 : return DBErrors::LOAD_OK;
866 : 2108 : });
867 [ + - ]: 2226 : result = std::max(result, key_cache_res.m_result);
868 : :
869 : : // Get last hardened cache for this descriptor
870 [ + - ]: 4452 : prefix = PrefixStream(DBKeys::WALLETDESCRIPTORLHCACHE, id);
871 : 0 : LoadResult lh_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORLHCACHE, prefix,
872 [ + - ]: 2226 : [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
873 : 1982 : uint256 desc_id;
874 : 1982 : uint32_t key_exp_index;
875 : 1982 : key >> desc_id;
876 [ - + ]: 1982 : assert(desc_id == id);
877 : 1982 : key >> key_exp_index;
878 : :
879 : 1982 : std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
880 [ + - ]: 1982 : value >> ser_xpub;
881 [ + - ]: 1982 : CExtPubKey xpub;
882 [ + - ]: 1982 : xpub.Decode(ser_xpub.data());
883 [ + - ]: 1982 : cache.CacheLastHardenedExtPubKey(key_exp_index, xpub);
884 : 1982 : return DBErrors::LOAD_OK;
885 : 1982 : });
886 [ + - ]: 2226 : result = std::max(result, lh_cache_res.m_result);
887 : :
888 : : // Set the cache for this descriptor
889 [ + - ]: 2226 : auto spk_man = (DescriptorScriptPubKeyMan*)pwallet->GetScriptPubKeyMan(id);
890 [ - + ]: 2226 : assert(spk_man);
891 [ + - ]: 2226 : spk_man->SetCache(cache);
892 : :
893 : : // Get unencrypted keys
894 [ + - ]: 4452 : prefix = PrefixStream(DBKeys::WALLETDESCRIPTORKEY, id);
895 : 0 : LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORKEY, prefix,
896 [ + - ]: 2226 : [&id, &spk_man] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
897 : 1931 : uint256 desc_id;
898 : 1931 : CPubKey pubkey;
899 : 1931 : key >> desc_id;
900 [ - + ]: 1931 : assert(desc_id == id);
901 : 1931 : key >> pubkey;
902 [ - + ]: 1931 : if (!pubkey.IsValid())
903 : : {
904 : 0 : strErr = "Error reading wallet database: descriptor unencrypted key CPubKey corrupt";
905 : 0 : return DBErrors::CORRUPT;
906 : : }
907 : 1931 : CKey privkey;
908 : 1931 : CPrivKey pkey;
909 : 1931 : uint256 hash;
910 : :
911 [ + - ]: 1931 : value >> pkey;
912 [ + - ]: 1931 : value >> hash;
913 : :
914 : : // hash pubkey/privkey to accelerate wallet load
915 : 1931 : std::vector<unsigned char> to_hash;
916 [ + - ]: 1931 : to_hash.reserve(pubkey.size() + pkey.size());
917 [ + - ]: 1931 : to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
918 [ + - ]: 1931 : to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
919 : :
920 [ + - - + ]: 1931 : if (Hash(to_hash) != hash)
921 : : {
922 [ # # ]: 0 : strErr = "Error reading wallet database: descriptor unencrypted key CPubKey/CPrivKey corrupt";
923 : : return DBErrors::CORRUPT;
924 : : }
925 : :
926 [ + - - + ]: 1931 : if (!privkey.Load(pkey, pubkey, true))
927 : : {
928 [ - - ]: 1931 : strErr = "Error reading wallet database: descriptor unencrypted key CPrivKey corrupt";
929 : : return DBErrors::CORRUPT;
930 : : }
931 [ + - + - ]: 1931 : spk_man->AddKey(pubkey.GetID(), privkey);
932 : : return DBErrors::LOAD_OK;
933 : 1931 : });
934 [ + - ]: 2226 : result = std::max(result, key_res.m_result);
935 : 2226 : num_keys = key_res.m_records;
936 : :
937 : : // Get encrypted keys
938 [ + - ]: 4452 : prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCKEY, id);
939 : 0 : LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCKEY, prefix,
940 [ + - ]: 2226 : [&id, &spk_man] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
941 : 231 : uint256 desc_id;
942 : 231 : CPubKey pubkey;
943 : 231 : key >> desc_id;
944 [ - + ]: 231 : assert(desc_id == id);
945 : 231 : key >> pubkey;
946 [ - + ]: 231 : if (!pubkey.IsValid())
947 : : {
948 : 0 : err = "Error reading wallet database: descriptor encrypted key CPubKey corrupt";
949 : 0 : return DBErrors::CORRUPT;
950 : : }
951 : 231 : std::vector<unsigned char> privkey;
952 [ + - ]: 231 : value >> privkey;
953 : :
954 [ + - + - ]: 231 : spk_man->AddCryptedKey(pubkey.GetID(), pubkey, privkey);
955 : 231 : return DBErrors::LOAD_OK;
956 : 231 : });
957 [ + - ]: 2226 : result = std::max(result, ckey_res.m_result);
958 : 2226 : num_ckeys = ckey_res.m_records;
959 : :
960 : 2226 : return result;
961 : 2228 : });
962 : :
963 [ + + ]: 856 : if (desc_res.m_result <= DBErrors::NONCRITICAL_ERROR) {
964 : : // Only log if there are no critical errors
965 : 854 : pwallet->WalletLogPrintf("Descriptors: %u, Descriptor Keys: %u plaintext, %u encrypted, %u total.\n",
966 : 854 : desc_res.m_records, num_keys, num_ckeys, num_keys + num_ckeys);
967 : : }
968 : :
969 : 856 : return desc_res.m_result;
970 : : }
971 : :
972 : 855 : static DBErrors LoadAddressBookRecords(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
973 : : {
974 : 855 : AssertLockHeld(pwallet->cs_wallet);
975 : 855 : DBErrors result = DBErrors::LOAD_OK;
976 : :
977 : : // Load name record
978 [ + - ]: 855 : LoadResult name_res = LoadRecords(pwallet, batch, DBKeys::NAME,
979 : 2822 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
980 [ + - ]: 2822 : std::string strAddress;
981 [ + - ]: 2822 : key >> strAddress;
982 [ + - ]: 2822 : std::string label;
983 [ + - ]: 2822 : value >> label;
984 [ + - + - : 5644 : pwallet->m_address_book[DecodeDestination(strAddress)].SetLabel(label);
+ - ]
985 : 2822 : return DBErrors::LOAD_OK;
986 : 2822 : });
987 [ + - ]: 855 : result = std::max(result, name_res.m_result);
988 : :
989 : : // Load purpose record
990 [ + - ]: 855 : LoadResult purpose_res = LoadRecords(pwallet, batch, DBKeys::PURPOSE,
991 : 2822 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
992 [ + - ]: 2822 : std::string strAddress;
993 [ + - ]: 2822 : key >> strAddress;
994 [ + - ]: 2822 : std::string purpose_str;
995 [ + - ]: 2822 : value >> purpose_str;
996 [ - + ]: 2822 : std::optional<AddressPurpose> purpose{PurposeFromString(purpose_str)};
997 [ - + ]: 2822 : if (!purpose) {
998 [ # # ]: 0 : pwallet->WalletLogPrintf("Warning: nonstandard purpose string '%s' for address '%s'\n", purpose_str, strAddress);
999 : : }
1000 [ + - + - ]: 2822 : pwallet->m_address_book[DecodeDestination(strAddress)].purpose = purpose;
1001 : 2822 : return DBErrors::LOAD_OK;
1002 : 2822 : });
1003 [ + - ]: 855 : result = std::max(result, purpose_res.m_result);
1004 : :
1005 : : // Load destination data record
1006 [ + - ]: 855 : LoadResult dest_res = LoadRecords(pwallet, batch, DBKeys::DESTDATA,
1007 : 10 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1008 [ + - ]: 10 : std::string strAddress, strKey, strValue;
1009 [ + - ]: 10 : key >> strAddress;
1010 [ + - ]: 10 : key >> strKey;
1011 [ + - ]: 10 : value >> strValue;
1012 [ + - ]: 10 : const CTxDestination& dest{DecodeDestination(strAddress)};
1013 [ + + ]: 10 : if (strKey.compare("used") == 0) {
1014 : : // Load "used" key indicating if an IsMine address has
1015 : : // previously been spent from with avoid_reuse option enabled.
1016 : : // The strValue is not used for anything currently, but could
1017 : : // hold more information in the future. Current values are just
1018 : : // "1" or "p" for present (which was written prior to
1019 : : // f5ba424cd44619d9b9be88b8593d69a7ba96db26).
1020 [ + - ]: 7 : pwallet->LoadAddressPreviouslySpent(dest);
1021 [ + - ]: 3 : } else if (strKey.starts_with("rr")) {
1022 : : // Load "rr##" keys where ## is a decimal number, and strValue
1023 : : // is a serialized RecentRequestEntry object.
1024 [ + - + - ]: 6 : pwallet->LoadAddressReceiveRequest(dest, strKey.substr(2), strValue);
1025 : : }
1026 : 10 : return DBErrors::LOAD_OK;
1027 : 10 : });
1028 [ + - ]: 855 : result = std::max(result, dest_res.m_result);
1029 : :
1030 : 855 : return result;
1031 : : }
1032 : :
1033 : 855 : static DBErrors LoadTxRecords(CWallet* pwallet, DatabaseBatch& batch, std::vector<uint256>& upgraded_txs, bool& any_unordered) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1034 : : {
1035 : 855 : AssertLockHeld(pwallet->cs_wallet);
1036 : 855 : DBErrors result = DBErrors::LOAD_OK;
1037 : :
1038 : : // Load tx record
1039 : 855 : any_unordered = false;
1040 : 0 : LoadResult tx_res = LoadRecords(pwallet, batch, DBKeys::TX,
1041 [ + - ]: 855 : [&any_unordered, &upgraded_txs] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1042 : 7242 : DBErrors result = DBErrors::LOAD_OK;
1043 : 7242 : uint256 hash;
1044 : 7242 : key >> hash;
1045 : : // LoadToWallet call below creates a new CWalletTx that fill_wtx
1046 : : // callback fills with transaction metadata.
1047 : 14484 : auto fill_wtx = [&](CWalletTx& wtx, bool new_tx) {
1048 [ - + ]: 7242 : if(!new_tx) {
1049 : : // There's some corruption here since the tx we just tried to load was already in the wallet.
1050 : 0 : err = "Error: Corrupt transaction found. This can be fixed by removing transactions from wallet and rescanning.";
1051 : 0 : result = DBErrors::CORRUPT;
1052 : 0 : return false;
1053 : : }
1054 : 7242 : value >> wtx;
1055 [ + - ]: 7242 : if (wtx.GetHash() != hash)
1056 : : return false;
1057 : :
1058 : : // Undo serialize changes in 31600
1059 [ - + ]: 7242 : if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
1060 : : {
1061 [ # # ]: 0 : if (!value.empty())
1062 : : {
1063 : 0 : uint8_t fTmp;
1064 : 0 : uint8_t fUnused;
1065 [ # # ]: 0 : std::string unused_string;
1066 [ # # # # : 0 : value >> fTmp >> fUnused >> unused_string;
# # ]
1067 : 0 : pwallet->WalletLogPrintf("LoadWallet() upgrading tx ver=%d %d %s\n",
1068 [ # # # # ]: 0 : wtx.fTimeReceivedIsTxTime, fTmp, hash.ToString());
1069 : 0 : wtx.fTimeReceivedIsTxTime = fTmp;
1070 : 0 : }
1071 : : else
1072 : : {
1073 [ # # ]: 0 : pwallet->WalletLogPrintf("LoadWallet() repairing tx ver=%d %s\n", wtx.fTimeReceivedIsTxTime, hash.ToString());
1074 : 0 : wtx.fTimeReceivedIsTxTime = 0;
1075 : : }
1076 : 0 : upgraded_txs.push_back(hash);
1077 : : }
1078 : :
1079 [ - + ]: 7242 : if (wtx.nOrderPos == -1)
1080 : 0 : any_unordered = true;
1081 : :
1082 : : return true;
1083 : 7242 : };
1084 [ + - - + ]: 7242 : if (!pwallet->LoadToWallet(hash, fill_wtx)) {
1085 : : // Use std::max as fill_wtx may have already set result to CORRUPT
1086 [ # # ]: 0 : result = std::max(result, DBErrors::NEED_RESCAN);
1087 : : }
1088 : 7242 : return result;
1089 : : });
1090 [ + - ]: 855 : result = std::max(result, tx_res.m_result);
1091 : :
1092 : : // Load locked utxo record
1093 [ + - ]: 855 : LoadResult locked_utxo_res = LoadRecords(pwallet, batch, DBKeys::LOCKED_UTXO,
1094 : 2 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1095 : 2 : Txid hash;
1096 : 2 : uint32_t n;
1097 : 2 : key >> hash;
1098 : 2 : key >> n;
1099 : 2 : pwallet->LockCoin(COutPoint(hash, n));
1100 : 2 : return DBErrors::LOAD_OK;
1101 : : });
1102 [ + - ]: 855 : result = std::max(result, locked_utxo_res.m_result);
1103 : :
1104 : : // Load orderposnext record
1105 : : // Note: There should only be one ORDERPOSNEXT record with nothing trailing the type
1106 [ + - ]: 855 : LoadResult order_pos_res = LoadRecords(pwallet, batch, DBKeys::ORDERPOSNEXT,
1107 : 155 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1108 : 155 : try {
1109 [ + - ]: 155 : value >> pwallet->nOrderPosNext;
1110 [ - - ]: 0 : } catch (const std::exception& e) {
1111 [ - - ]: 0 : err = e.what();
1112 : 0 : return DBErrors::NONCRITICAL_ERROR;
1113 : 0 : }
1114 : 155 : return DBErrors::LOAD_OK;
1115 : : });
1116 [ + - ]: 855 : result = std::max(result, order_pos_res.m_result);
1117 : :
1118 : 855 : return result;
1119 : : }
1120 : :
1121 : 855 : static DBErrors LoadActiveSPKMs(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1122 : : {
1123 : 855 : AssertLockHeld(pwallet->cs_wallet);
1124 : 855 : DBErrors result = DBErrors::LOAD_OK;
1125 : :
1126 : : // Load spk records
1127 [ + - ]: 855 : std::set<std::pair<OutputType, bool>> seen_spks;
1128 [ + - + - : 4275 : for (const auto& spk_key : {DBKeys::ACTIVEEXTERNALSPK, DBKeys::ACTIVEINTERNALSPK}) {
+ + - - ]
1129 : 0 : LoadResult spkm_res = LoadRecords(pwallet, batch, spk_key,
1130 [ + - ]: 1710 : [&seen_spks, &spk_key] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
1131 : 1890 : uint8_t output_type;
1132 : 1890 : key >> output_type;
1133 : 1890 : uint256 id;
1134 : 1890 : value >> id;
1135 : :
1136 : 1890 : bool internal = spk_key == DBKeys::ACTIVEINTERNALSPK;
1137 [ - + ]: 1890 : auto [it, insert] = seen_spks.emplace(static_cast<OutputType>(output_type), internal);
1138 [ - + ]: 1890 : if (!insert) {
1139 : 0 : strErr = "Multiple ScriptpubKeyMans specified for a single type";
1140 : 0 : return DBErrors::CORRUPT;
1141 : : }
1142 : 1890 : pwallet->LoadActiveScriptPubKeyMan(id, static_cast<OutputType>(output_type), /*internal=*/internal);
1143 : 1890 : return DBErrors::LOAD_OK;
1144 : : });
1145 [ + - ]: 3420 : result = std::max(result, spkm_res.m_result);
1146 [ + + - - ]: 2565 : }
1147 : 855 : return result;
1148 : 855 : }
1149 : :
1150 : 855 : static DBErrors LoadDecryptionKeys(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1151 : : {
1152 : 855 : AssertLockHeld(pwallet->cs_wallet);
1153 : :
1154 : : // Load decryption key (mkey) records
1155 [ + - ]: 855 : LoadResult mkey_res = LoadRecords(pwallet, batch, DBKeys::MASTER_KEY,
1156 : 23 : [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
1157 [ - + ]: 23 : if (!LoadEncryptionKey(pwallet, key, value, err)) {
1158 : 0 : return DBErrors::CORRUPT;
1159 : : }
1160 : : return DBErrors::LOAD_OK;
1161 : : });
1162 : 855 : return mkey_res.m_result;
1163 : : }
1164 : :
1165 : 856 : DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
1166 : : {
1167 : 856 : DBErrors result = DBErrors::LOAD_OK;
1168 : 856 : bool any_unordered = false;
1169 : 856 : std::vector<uint256> upgraded_txs;
1170 : :
1171 [ + - ]: 856 : LOCK(pwallet->cs_wallet);
1172 : :
1173 : : // Last client version to open this wallet
1174 : 856 : int last_client = CLIENT_VERSION;
1175 [ + - ]: 856 : bool has_last_client = m_batch->Read(DBKeys::VERSION, last_client);
1176 [ + - + - ]: 856 : pwallet->WalletLogPrintf("Wallet file version = %d, last client version = %d\n", pwallet->GetVersion(), last_client);
1177 : :
1178 : 856 : try {
1179 [ + - + - ]: 856 : if ((result = LoadMinVersion(pwallet, *m_batch)) != DBErrors::LOAD_OK) return result;
1180 : :
1181 : : // Load wallet flags, so they are known when processing other records.
1182 : : // The FLAGS key is absent during wallet creation.
1183 [ + - + - ]: 856 : if ((result = LoadWalletFlags(pwallet, *m_batch)) != DBErrors::LOAD_OK) return result;
1184 : :
1185 : : #ifndef ENABLE_EXTERNAL_SIGNER
1186 : : if (pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
1187 : : pwallet->WalletLogPrintf("Error: External signer wallet being loaded without external signer support compiled\n");
1188 : : return DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED;
1189 : : }
1190 : : #endif
1191 : :
1192 : : // Load legacy wallet keys
1193 [ + - + - ]: 856 : result = std::max(LoadLegacyWalletRecords(pwallet, *m_batch, last_client), result);
1194 : :
1195 : : // Load descriptors
1196 [ + - + + ]: 856 : result = std::max(LoadDescriptorWalletRecords(pwallet, *m_batch, last_client), result);
1197 : : // Early return if there are unknown descriptors. Later loading of ACTIVEINTERNALSPK and ACTIVEEXTERNALEXPK
1198 : : // may reference the unknown descriptor's ID which can result in a misleading corruption error
1199 : : // when in reality the wallet is simply too new.
1200 [ + + ]: 856 : if (result == DBErrors::UNKNOWN_DESCRIPTOR) return result;
1201 : :
1202 : : // Load address book
1203 [ + - + + ]: 855 : result = std::max(LoadAddressBookRecords(pwallet, *m_batch), result);
1204 : :
1205 : : // Load tx records
1206 [ + - + + ]: 855 : result = std::max(LoadTxRecords(pwallet, *m_batch, upgraded_txs, any_unordered), result);
1207 : :
1208 : : // Load SPKMs
1209 [ + - + + ]: 855 : result = std::max(LoadActiveSPKMs(pwallet, *m_batch), result);
1210 : :
1211 : : // Load decryption keys
1212 [ + - + + ]: 1706 : result = std::max(LoadDecryptionKeys(pwallet, *m_batch), result);
1213 : 0 : } catch (...) {
1214 : : // Exceptions that can be ignored or treated as non-critical are handled by the individual loading functions.
1215 : : // Any uncaught exceptions will be caught here and treated as critical.
1216 : 0 : result = DBErrors::CORRUPT;
1217 [ - - ]: 0 : }
1218 : :
1219 : : // Any wallet corruption at all: skip any rewriting or
1220 : : // upgrading, we don't want to make it worse.
1221 [ + + ]: 855 : if (result != DBErrors::LOAD_OK)
1222 : : return result;
1223 : :
1224 [ - + ]: 851 : for (const uint256& hash : upgraded_txs)
1225 [ # # # # ]: 0 : WriteTx(pwallet->mapWallet.at(hash));
1226 : :
1227 [ + + + + ]: 851 : if (!has_last_client || last_client != CLIENT_VERSION) // Update
1228 [ + - ]: 613 : m_batch->Write(DBKeys::VERSION, CLIENT_VERSION);
1229 : :
1230 [ - + ]: 851 : if (any_unordered)
1231 [ # # ]: 0 : result = pwallet->ReorderTransactions();
1232 : :
1233 : : // Upgrade all of the wallet keymetadata to have the hd master key id
1234 : : // This operation is not atomic, but if it fails, updated entries are still backwards compatible with older software
1235 : 851 : try {
1236 [ + - ]: 851 : pwallet->UpgradeKeyMetadata();
1237 : 0 : } catch (...) {
1238 : 0 : result = DBErrors::CORRUPT;
1239 [ - - ]: 0 : }
1240 : :
1241 : : // Upgrade all of the descriptor caches to cache the last hardened xpub
1242 : : // This operation is not atomic, but if it fails, only new entries are added so it is backwards compatible
1243 : 851 : try {
1244 [ + - ]: 851 : pwallet->UpgradeDescriptorCache();
1245 : 0 : } catch (...) {
1246 : 0 : result = DBErrors::CORRUPT;
1247 [ - - ]: 0 : }
1248 : :
1249 : : // Since it was accidentally possible to "encrypt" a wallet with private keys disabled, we should check if this is
1250 : : // such a wallet and remove the encryption key records to avoid any future issues.
1251 : : // Although wallets without private keys should not have *ckey records, we should double check that.
1252 : : // Removing the mkey records is only safe if there are no *ckey records.
1253 [ + - + + : 851 : if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && pwallet->HasEncryptionKeys() && !pwallet->HaveCryptedKeys()) {
+ - + + +
- + - ]
1254 [ + - ]: 1 : pwallet->WalletLogPrintf("Detected extraneous encryption keys in this wallet without private keys. Removing extraneous encryption keys.\n");
1255 [ + - + + ]: 2 : for (const auto& [id, _] : pwallet->mapMasterKeys) {
1256 [ + - - + ]: 1 : if (!EraseMasterKey(id)) {
1257 [ # # ]: 0 : pwallet->WalletLogPrintf("Error: Unable to remove extraneous encryption key '%u'. Wallet corrupt.\n", id);
1258 : : return DBErrors::CORRUPT;
1259 : : }
1260 : : }
1261 : 1 : pwallet->mapMasterKeys.clear();
1262 : : }
1263 : :
1264 : 851 : return result;
1265 : 856 : }
1266 : :
1267 : 370 : static bool RunWithinTxn(WalletBatch& batch, std::string_view process_desc, const std::function<bool(WalletBatch&)>& func)
1268 : : {
1269 [ - + ]: 370 : if (!batch.TxnBegin()) {
1270 [ # # ]: 0 : LogDebug(BCLog::WALLETDB, "Error: cannot create db txn for %s\n", process_desc);
1271 : 0 : return false;
1272 : : }
1273 : :
1274 : : // Run procedure
1275 [ + + ]: 370 : if (!func(batch)) {
1276 [ + - ]: 1 : LogDebug(BCLog::WALLETDB, "Error: %s failed\n", process_desc);
1277 : 1 : batch.TxnAbort();
1278 : 1 : return false;
1279 : : }
1280 : :
1281 [ - + ]: 369 : if (!batch.TxnCommit()) {
1282 [ # # ]: 0 : LogDebug(BCLog::WALLETDB, "Error: cannot commit db txn for %s\n", process_desc);
1283 : 0 : return false;
1284 : : }
1285 : :
1286 : : // All good
1287 : : return true;
1288 : : }
1289 : :
1290 : 370 : bool RunWithinTxn(WalletDatabase& database, std::string_view process_desc, const std::function<bool(WalletBatch&)>& func)
1291 : : {
1292 : 370 : WalletBatch batch(database);
1293 [ + - ]: 370 : return RunWithinTxn(batch, process_desc, func);
1294 : 370 : }
1295 : :
1296 : 20263 : void MaybeCompactWalletDB(WalletContext& context)
1297 : : {
1298 : 20263 : static std::atomic<bool> fOneThread(false);
1299 [ + - ]: 20263 : if (fOneThread.exchange(true)) {
1300 : : return;
1301 : : }
1302 : :
1303 [ + + ]: 46913 : for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
1304 : 26650 : WalletDatabase& dbh = pwallet->GetDatabase();
1305 : :
1306 [ + + ]: 26650 : unsigned int nUpdateCounter = dbh.nUpdateCounter;
1307 : :
1308 [ + + ]: 26650 : if (dbh.nLastSeen != nUpdateCounter) {
1309 : 2884 : dbh.nLastSeen = nUpdateCounter;
1310 [ + - ]: 2884 : dbh.nLastWalletUpdate = GetTime();
1311 : : }
1312 : :
1313 [ + + + - : 26650 : if (dbh.nLastFlushed != nUpdateCounter && GetTime() - dbh.nLastWalletUpdate >= 2) {
+ + ]
1314 [ + - - + ]: 21418 : if (dbh.PeriodicFlush()) {
1315 : 0 : dbh.nLastFlushed = nUpdateCounter;
1316 : : }
1317 : : }
1318 : 20263 : }
1319 : :
1320 : 20263 : fOneThread = false;
1321 : : }
1322 : :
1323 : 24 : bool WalletBatch::WriteAddressPreviouslySpent(const CTxDestination& dest, bool previously_spent)
1324 : : {
1325 [ + - + - ]: 96 : auto key{std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), std::string("used")))};
1326 [ + + + - : 71 : return previously_spent ? WriteIC(key, std::string("1")) : EraseIC(key);
+ - + - ]
1327 : 24 : }
1328 : :
1329 : 4 : bool WalletBatch::WriteAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& receive_request)
1330 : : {
1331 [ + - + - : 16 : return WriteIC(std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), "rr" + id)), receive_request);
+ - ]
1332 : : }
1333 : :
1334 : 1 : bool WalletBatch::EraseAddressReceiveRequest(const CTxDestination& dest, const std::string& id)
1335 : : {
1336 [ + - + - : 4 : return EraseIC(std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), "rr" + id)));
+ - ]
1337 : : }
1338 : :
1339 : 21 : bool WalletBatch::EraseAddressData(const CTxDestination& dest)
1340 : : {
1341 : 21 : DataStream prefix;
1342 [ + - + - ]: 42 : prefix << DBKeys::DESTDATA << EncodeDestination(dest);
1343 [ + - ]: 21 : return m_batch->ErasePrefix(prefix);
1344 : 21 : }
1345 : :
1346 : 2007 : bool WalletBatch::WriteHDChain(const CHDChain& chain)
1347 : : {
1348 : 2007 : return WriteIC(DBKeys::HDCHAIN, chain);
1349 : : }
1350 : :
1351 : 5681 : bool WalletBatch::WriteWalletFlags(const uint64_t flags)
1352 : : {
1353 : 5681 : return WriteIC(DBKeys::FLAGS, flags);
1354 : : }
1355 : :
1356 : 25 : bool WalletBatch::EraseRecords(const std::unordered_set<std::string>& types)
1357 : : {
1358 : 25 : return std::all_of(types.begin(), types.end(), [&](const std::string& type) {
1359 [ + - + - ]: 250 : return m_batch->ErasePrefix(DataStream() << type);
1360 : 25 : });
1361 : : }
1362 : :
1363 : 70263 : bool WalletBatch::TxnBegin()
1364 : : {
1365 : 70263 : return m_batch->TxnBegin();
1366 : : }
1367 : :
1368 : 70260 : bool WalletBatch::TxnCommit()
1369 : : {
1370 : 70260 : bool res = m_batch->TxnCommit();
1371 [ + - ]: 70260 : if (res) {
1372 [ + + ]: 70271 : for (const auto& listener : m_txn_listeners) {
1373 : 11 : listener.on_commit();
1374 : : }
1375 : : // txn finished, clear listeners
1376 : 70260 : m_txn_listeners.clear();
1377 : : }
1378 : 70260 : return res;
1379 : : }
1380 : :
1381 : 1 : bool WalletBatch::TxnAbort()
1382 : : {
1383 : 1 : bool res = m_batch->TxnAbort();
1384 [ + - ]: 1 : if (res) {
1385 [ - + ]: 1 : for (const auto& listener : m_txn_listeners) {
1386 : 0 : listener.on_abort();
1387 : : }
1388 : : // txn finished, clear listeners
1389 : 1 : m_txn_listeners.clear();
1390 : : }
1391 : 1 : return res;
1392 : : }
1393 : :
1394 : 11 : void WalletBatch::RegisterTxnListener(const DbTxnListener& l)
1395 : : {
1396 [ - + ]: 11 : assert(m_batch->HasActiveTxn());
1397 : 11 : m_txn_listeners.emplace_back(l);
1398 : 11 : }
1399 : :
1400 : 1220 : std::unique_ptr<WalletDatabase> MakeDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error)
1401 : : {
1402 : 1220 : bool exists;
1403 : 1220 : try {
1404 [ + - ]: 1220 : exists = fs::symlink_status(path).type() != fs::file_type::not_found;
1405 [ - - ]: 0 : } catch (const fs::filesystem_error& e) {
1406 [ - - - - : 0 : error = Untranslated(strprintf("Failed to access database path '%s': %s", fs::PathToString(path), fsbridge::get_filesystem_error_message(e)));
- - ]
1407 : 0 : status = DatabaseStatus::FAILED_BAD_PATH;
1408 : 0 : return nullptr;
1409 : 0 : }
1410 : :
1411 : 1220 : std::optional<DatabaseFormat> format;
1412 [ + + ]: 1220 : if (exists) {
1413 [ + - + + ]: 1424 : if (IsBDBFile(BDBDataFile(path))) {
1414 : 28 : format = DatabaseFormat::BERKELEY;
1415 : : }
1416 [ + - + + ]: 1424 : if (IsSQLiteFile(SQLiteDataFile(path))) {
1417 [ - + ]: 377 : if (format) {
1418 [ # # # # ]: 0 : error = Untranslated(strprintf("Failed to load database path '%s'. Data is in ambiguous format.", fs::PathToString(path)));
1419 : 0 : status = DatabaseStatus::FAILED_BAD_FORMAT;
1420 : 0 : return nullptr;
1421 : : }
1422 : 377 : format = DatabaseFormat::SQLITE;
1423 : : }
1424 [ + + ]: 508 : } else if (options.require_existing) {
1425 [ + - + - ]: 6 : error = Untranslated(strprintf("Failed to load database path '%s'. Path does not exist.", fs::PathToString(path)));
1426 : 3 : status = DatabaseStatus::FAILED_NOT_FOUND;
1427 : 3 : return nullptr;
1428 : : }
1429 : :
1430 [ + + + + ]: 1217 : if (!format && options.require_existing) {
1431 [ + - + - ]: 556 : error = Untranslated(strprintf("Failed to load database path '%s'. Data is not in recognized format.", fs::PathToString(path)));
1432 : 278 : status = DatabaseStatus::FAILED_BAD_FORMAT;
1433 : 278 : return nullptr;
1434 : : }
1435 : :
1436 [ + + + + ]: 939 : if (format && options.require_create) {
1437 [ + - + - ]: 8 : error = Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(path)));
1438 : 4 : status = DatabaseStatus::FAILED_ALREADY_EXISTS;
1439 : 4 : return nullptr;
1440 : : }
1441 : :
1442 : : // If BERKELEY was the format, then change the format from BERKELEY to BERKELEY_RO
1443 [ + + + + : 935 : if (format && options.require_format && format == DatabaseFormat::BERKELEY && options.require_format == DatabaseFormat::BERKELEY_RO) {
+ + + - ]
1444 : 27 : format = DatabaseFormat::BERKELEY_RO;
1445 : : }
1446 : :
1447 : : // A db already exists so format is set, but options also specifies the format, so make sure they agree
1448 [ + + + + : 935 : if (format && options.require_format && format != options.require_format) {
+ - ]
1449 [ # # # # ]: 0 : error = Untranslated(strprintf("Failed to load database path '%s'. Data is not in required format.", fs::PathToString(path)));
1450 : 0 : status = DatabaseStatus::FAILED_BAD_FORMAT;
1451 : 0 : return nullptr;
1452 : : }
1453 : :
1454 : : // Format is not set when a db doesn't already exist, so use the format specified by the options if it is set.
1455 [ + + + + ]: 935 : if (!format && options.require_format) format = options.require_format;
1456 : :
1457 : : // If the format is not specified or detected, choose the default format based on what is available. We prefer BDB over SQLite for now.
1458 [ + + ]: 935 : if (!format) {
1459 : : #ifdef USE_SQLITE
1460 : 3 : format = DatabaseFormat::SQLITE;
1461 : : #endif
1462 : : #ifdef USE_BDB
1463 : : format = DatabaseFormat::BERKELEY;
1464 : : #endif
1465 : : }
1466 : :
1467 [ + - ]: 935 : if (format == DatabaseFormat::SQLITE) {
1468 : : #ifdef USE_SQLITE
1469 : 908 : if constexpr (true) {
1470 : 908 : return MakeSQLiteDatabase(path, options, status, error);
1471 : : } else
1472 : : #endif
1473 : : {
1474 : : error = Untranslated(strprintf("Failed to open database path '%s'. Build does not support SQLite database format.", fs::PathToString(path)));
1475 : : status = DatabaseStatus::FAILED_BAD_FORMAT;
1476 : : return nullptr;
1477 : : }
1478 : : }
1479 : :
1480 [ + - ]: 27 : if (format == DatabaseFormat::BERKELEY_RO) {
1481 : 27 : return MakeBerkeleyRODatabase(path, options, status, error);
1482 : : }
1483 : :
1484 : : #ifdef USE_BDB
1485 : : if constexpr (true) {
1486 : : return MakeBerkeleyDatabase(path, options, status, error);
1487 : : } else
1488 : : #endif
1489 : 0 : {
1490 [ # # # # ]: 0 : error = Untranslated(strprintf("Failed to open database path '%s'. Build does not support Berkeley DB database format.", fs::PathToString(path)));
1491 : 0 : status = DatabaseStatus::FAILED_BAD_FORMAT;
1492 : 0 : return nullptr;
1493 : : }
1494 : : }
1495 : : } // namespace wallet
|
