Persisting and loading wallet records

501            pwallet->WalletLogPrintf("%s\n", error);
502        }
503        result.m_result = std::max(result.m_result, record_res);
504        ++result.m_records;
505    }
506    return result;
507}
508
509static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, LoadFunc load_func)
510{
511    DataStream prefix;
512    prefix << key;
513    return LoadRecords(pwallet, batch, key, prefix, load_func);
514}
515
516bool HasLegacyRecords(CWallet& wallet)
517{
518    const auto& batch = wallet.GetDatabase().MakeBatch();
519    return HasLegacyRecords(wallet, *batch);
520}
521
522bool HasLegacyRecords(CWallet& wallet, DatabaseBatch& batch)
523{
524    for (const auto& type : DBKeys::LEGACY_TYPES) {
525        DataStream key;
526        DataStream value{};
527        DataStream prefix;
528
529        prefix << type;
530        std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
531        if (!cursor) {
532            // Could only happen on a closed db, which means there is an error in the code flow.
533            throw std::runtime_error(strprintf("Error getting database cursor for '%s' records", type));
534        }
535
536        DatabaseCursor::Status status = cursor->Next(key, value);
537        if (status != DatabaseCursor::Status::DONE) {
538            return true;
539        }
540    }
541    return false;
542}
543
544static DBErrors LoadLegacyWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
545{
546    AssertLockHeld(pwallet->cs_wallet);
547    DBErrors result = DBErrors::LOAD_OK;
548
549    // Make sure descriptor wallets don't have any legacy records
550    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
551        if (HasLegacyRecords(*pwallet, batch)) {
552            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());
553            return DBErrors::UNEXPECTED_LEGACY_ENTRY;
554        }
555
556        return DBErrors::LOAD_OK;
557    }
558
559    // Load HD Chain
560    // Note: There should only be one HDCHAIN record with no data following the type
561    LoadResult hd_chain_res = LoadRecords(pwallet, batch, DBKeys::HDCHAIN,
562        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
563        return LoadHDChain(pwallet, value, err) ? DBErrors:: LOAD_OK : DBErrors::CORRUPT;
564    });
565    result = std::max(result, hd_chain_res.m_result);
566
567    // Load unencrypted keys
568    LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::KEY,
569        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
570        return LoadKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
571    });
572    result = std::max(result, key_res.m_result);
573
574    // Load encrypted keys
575    LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::CRYPTED_KEY,
576        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
577        return LoadCryptedKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
578    });
579    result = std::max(result, ckey_res.m_result);
580
581    // Load scripts
582    LoadResult script_res = LoadRecords(pwallet, batch, DBKeys::CSCRIPT,
583        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
584        uint160 hash;
585        key >> hash;
586        CScript script;
587        value >> script;
588        if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCScript(script))
589        {
590            strErr = "Error reading wallet database: LegacyDataSPKM::LoadCScript failed";
591            return DBErrors::NONCRITICAL_ERROR;
592        }
593        return DBErrors::LOAD_OK;
594    });
595    result = std::max(result, script_res.m_result);
596
597    // Load keymeta
598    std::map<uint160, CHDChain> hd_chains;
599    LoadResult keymeta_res = LoadRecords(pwallet, batch, DBKeys::KEYMETA,
600        [&hd_chains] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
601        CPubKey vchPubKey;
602        key >> vchPubKey;
603        CKeyMetadata keyMeta;
604        value >> keyMeta;
605        pwallet->GetOrCreateLegacyDataSPKM()->LoadKeyMetadata(vchPubKey.GetID(), keyMeta);
606
607        // Extract some CHDChain info from this metadata if it has any
608        if (keyMeta.nVersion >= CKeyMetadata::VERSION_WITH_HDDATA && !keyMeta.hd_seed_id.IsNull() && keyMeta.hdKeypath.size() > 0) {
609            // Get the path from the key origin or from the path string
610            // Not applicable when path is "s" or "m" as those indicate a seed
611            // See https://github.com/bitcoin/bitcoin/pull/12924
612            bool internal = false;
613            uint32_t index = 0;
614            if (keyMeta.hdKeypath != "s" && keyMeta.hdKeypath != "m") {
615                std::vector<uint32_t> path;
616                if (keyMeta.has_key_origin) {
617                    // We have a key origin, so pull it from its path vector
618                    path = keyMeta.key_origin.path;
619                } else {
620                    // No key origin, have to parse the string
621                    if (!ParseHDKeypath(keyMeta.hdKeypath, path)) {
622                        strErr = "Error reading wallet database: keymeta with invalid HD keypath";
623                        return DBErrors::NONCRITICAL_ERROR;
624                    }
625                }
626
627                // Extract the index and internal from the path
628                // Path string is m/0'/k'/i'
629                // Path vector is [0', k', i'] (but as ints OR'd with the hardened bit
630                // k == 0 for external, 1 for internal. i is the index
631                if (path.size() != 3) {
632                    strErr = "Error reading wallet database: keymeta found with unexpected path";
633                    return DBErrors::NONCRITICAL_ERROR;
634                }
635                if (path[0] != BIP32_HARDENED_FLAG) {
636                    strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000) for the element at index 0", path[0]);
637                    return DBErrors::NONCRITICAL_ERROR;
638                }
639                if (path[1] != BIP32_HARDENED_FLAG && path[1] != (1 | BIP32_HARDENED_FLAG)) {
640                    strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000 or 0x80000001) for the element at index 1", path[1]);
641                    return DBErrors::NONCRITICAL_ERROR;
642                }
643                if ((path[2] & BIP32_HARDENED_FLAG) == 0) {
644                    strErr = strprintf("Unexpected path index of 0x%08x (expected to be greater than or equal to 0x80000000)", path[2]);
645                    return DBErrors::NONCRITICAL_ERROR;
646                }
647                internal = path[1] == (1 | BIP32_HARDENED_FLAG);
648                index = path[2] & ~BIP32_HARDENED_FLAG;
649            }
650
651            // Insert a new CHDChain, or get the one that already exists
652            auto [ins, inserted] = hd_chains.emplace(keyMeta.hd_seed_id, CHDChain());
653            CHDChain& chain = ins->second;
654            if (inserted) {
655                // For new chains, we want to default to VERSION_HD_BASE until we see an internal
656                chain.nVersion = CHDChain::VERSION_HD_BASE;
657                chain.seed_id = keyMeta.hd_seed_id;
658            }
659            if (internal) {
660                chain.nVersion = CHDChain::VERSION_HD_CHAIN_SPLIT;
661                chain.nInternalChainCounter = std::max(chain.nInternalChainCounter, index + 1);
662            } else {
663                chain.nExternalChainCounter = std::max(chain.nExternalChainCounter, index + 1);
664            }
665        }
666        return DBErrors::LOAD_OK;
667    });
668    result = std::max(result, keymeta_res.m_result);
669
670    // Set inactive chains
671    if (!hd_chains.empty()) {
672        LegacyDataSPKM* legacy_spkm = pwallet->GetLegacyDataSPKM();
673        if (legacy_spkm) {
674            for (const auto& [hd_seed_id, chain] : hd_chains) {
675                if (hd_seed_id != legacy_spkm->GetHDChain().seed_id) {
676                    legacy_spkm->AddInactiveHDChain(chain);
677                }
678            }
679        } else {
680            pwallet->WalletLogPrintf("Inactive HD chains found but no LegacyDataSPKM\n");
681            result = DBErrors::CORRUPT;
682        }
683    }
684
685    // Load watchonly scripts
686    LoadResult watch_script_res = LoadRecords(pwallet, batch, DBKeys::WATCHS,
687        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
688        CScript script;
689        key >> script;
690        uint8_t fYes;
691        value >> fYes;
692        if (fYes == '1') {
693            pwallet->GetOrCreateLegacyDataSPKM()->LoadWatchOnly(script);
694        }
695        return DBErrors::LOAD_OK;
696    });
697    result = std::max(result, watch_script_res.m_result);
698
699    // Load watchonly meta
700    LoadResult watch_meta_res = LoadRecords(pwallet, batch, DBKeys::WATCHMETA,
701        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
702        CScript script;
703        key >> script;
704        CKeyMetadata keyMeta;
705        value >> keyMeta;
706        pwallet->GetOrCreateLegacyDataSPKM()->LoadScriptMetadata(CScriptID(script), keyMeta);
707        return DBErrors::LOAD_OK;
708    });
709    result = std::max(result, watch_meta_res.m_result);
710
711    // Deal with old "wkey" and "defaultkey" records.
712    // These are not actually loaded, but we need to check for them
713
714    // We don't want or need the default key, but if there is one set,
715    // we want to make sure that it is valid so that we can detect corruption
716    // Note: There should only be one DEFAULTKEY with nothing trailing the type
717    LoadResult default_key_res = LoadRecords(pwallet, batch, DBKeys::DEFAULTKEY,
718        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
719        CPubKey default_pubkey;
720        try {
721            value >> default_pubkey;
722        } catch (const std::exception& e) {
723            err = e.what();
724            return DBErrors::CORRUPT;
725        }
726        if (!default_pubkey.IsValid()) {
727            err = "Error reading wallet database: Default Key corrupt";
728            return DBErrors::CORRUPT;
729        }
730        return DBErrors::LOAD_OK;
731    });
732    result = std::max(result, default_key_res.m_result);
733
734    // "wkey" records are unsupported, if we see any, throw an error
735    LoadResult wkey_res = LoadRecords(pwallet, batch, DBKeys::OLD_KEY,
736        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
737        err = "Found unsupported 'wkey' record, try loading with version 0.18";
738        return DBErrors::LOAD_FAIL;
739    });
740    result = std::max(result, wkey_res.m_result);
741
742    if (result <= DBErrors::NONCRITICAL_ERROR) {
743        // Only do logging and time first key update if there were no critical errors
744        pwallet->WalletLogPrintf("Legacy Wallet Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total.\n",
745               key_res.m_records, ckey_res.m_records, keymeta_res.m_records, key_res.m_records + ckey_res.m_records);
746    }
747
748    return result;
749}
750