DanS
143c33de48
CWalletDB::WriteCryptedHDSeed wrote the "chdseed" record and left "hdseed" in place, unlike WriteCryptedKey which erases "key"/"wkey" after writing "ckey". No erase of "hdseed" existed anywhere in src/wallet/. CDB::Rewrite does not save us: EncryptWallet calls it with pszSkip defaulted, so it copies every surviving record verbatim into the new file. The result is that a wallet created unencrypted and later encrypted keeps its raw HD seed in cleartext on disk permanently, and reloads it into memory on every start. Add CWalletDB::EraseHDSeed and call it from CWallet::SetCryptedHDSeed after the encrypted record is written, through the same CWalletDB so it shares EncryptWallet's transaction. Erase returns true on DB_NOTFOUND, so a wallet that was never written in plaintext is unaffected. The erase is deliberately best-effort and only logs on failure. A hard failure here propagates into CCryptoKeyStore::EncryptKeys, which EncryptWallet turns into assert(false) with half the keys encrypted in memory; a warning is strictly better than that. Note this path is only reachable with -developerencryptwallet, which is experimental and off by default on this chain, so this is a latent fix rather than a live one. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
254 lines
9.3 KiB
C++
254 lines
9.3 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2013 The Bitcoin Core developers
|
|
// Copyright (c) 2009-2013 The Hush developers
|
|
// Distributed under the GPLv3 software license, see the accompanying
|
|
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|
|
|
/******************************************************************************
|
|
* Copyright © 2014-2019 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#ifndef HUSH_WALLET_WALLETDB_H
|
|
#define HUSH_WALLET_WALLETDB_H
|
|
|
|
#include "amount.h"
|
|
#include "wallet/db.h"
|
|
#include "key.h"
|
|
#include "keystore.h"
|
|
#include "zcash/Address.hpp"
|
|
#include "zcash/zip32.h"
|
|
|
|
#include <list>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
class CAccount;
|
|
class CAccountingEntry;
|
|
struct CBlockLocator;
|
|
class CKeyPool;
|
|
class CMasterKey;
|
|
class CScript;
|
|
class CWallet;
|
|
class CWalletTx;
|
|
class uint160;
|
|
class uint256;
|
|
|
|
/** Error statuses for the wallet database */
|
|
enum DBErrors
|
|
{
|
|
DB_LOAD_OK,
|
|
DB_CORRUPT,
|
|
DB_NONCRITICAL_ERROR,
|
|
DB_TOO_NEW,
|
|
DB_LOAD_FAIL,
|
|
DB_NEED_REWRITE
|
|
};
|
|
|
|
/* simple hd chain data model */
|
|
class CHDChain
|
|
{
|
|
public:
|
|
static const int VERSION_HD_BASE = 1;
|
|
// Version 2 adds the transparent (secp256k1/BIP44) external-chain counter.
|
|
static const int VERSION_HD_TRANSPARENT = 2;
|
|
// Version 3 marks a seed derived from a BIP39 mnemonic: the stored HDSeed is
|
|
// the 32-byte BIP39 entropy, expanded to the 64-byte seed for derivation
|
|
// (matches SilentDragonXLite's on-disk convention).
|
|
static const int VERSION_HD_MNEMONIC = 3;
|
|
static const int CURRENT_VERSION = VERSION_HD_MNEMONIC;
|
|
int nVersion;
|
|
uint256 seedFp;
|
|
int64_t nCreateTime; // 0 means unknown
|
|
uint32_t saplingAccountCounter;
|
|
// Next index on the HD transparent external chain m/44'/coin'/0'/0/i.
|
|
// Only serialized/consulted when nVersion >= VERSION_HD_TRANSPARENT.
|
|
uint32_t transparentChildCounter;
|
|
// True when the stored HDSeed is BIP39 entropy that must be expanded to the
|
|
// 64-byte BIP39 seed before HD derivation. Only serialized when
|
|
// nVersion >= VERSION_HD_MNEMONIC (false for all pre-existing wallets).
|
|
bool fMnemonicSeed;
|
|
|
|
CHDChain() { SetNull(); }
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action)
|
|
{
|
|
READWRITE(nVersion);
|
|
READWRITE(seedFp);
|
|
READWRITE(nCreateTime);
|
|
READWRITE(saplingAccountCounter);
|
|
// Version-gated so pre-existing v1 wallet.dat records still deserialize
|
|
// (they simply leave the newer fields at their SetNull defaults).
|
|
if (this->nVersion >= VERSION_HD_TRANSPARENT) {
|
|
READWRITE(transparentChildCounter);
|
|
}
|
|
if (this->nVersion >= VERSION_HD_MNEMONIC) {
|
|
READWRITE(fMnemonicSeed);
|
|
}
|
|
}
|
|
|
|
void SetNull()
|
|
{
|
|
nVersion = CHDChain::CURRENT_VERSION;
|
|
seedFp.SetNull();
|
|
nCreateTime = 0;
|
|
saplingAccountCounter = 0;
|
|
transparentChildCounter = 0;
|
|
fMnemonicSeed = false;
|
|
}
|
|
};
|
|
|
|
class CKeyMetadata
|
|
{
|
|
public:
|
|
static const int VERSION_BASIC=1;
|
|
static const int VERSION_WITH_HDDATA=10;
|
|
static const int CURRENT_VERSION=VERSION_WITH_HDDATA;
|
|
int nVersion;
|
|
int64_t nCreateTime; // 0 means unknown
|
|
std::string hdKeypath; //optional HD/zip32 keypath
|
|
uint256 seedFp;
|
|
|
|
CKeyMetadata()
|
|
{
|
|
SetNull();
|
|
}
|
|
CKeyMetadata(int64_t nCreateTime_)
|
|
{
|
|
SetNull();
|
|
nCreateTime = nCreateTime_;
|
|
}
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action) {
|
|
READWRITE(this->nVersion);
|
|
READWRITE(nCreateTime);
|
|
if (this->nVersion >= VERSION_WITH_HDDATA)
|
|
{
|
|
READWRITE(hdKeypath);
|
|
READWRITE(seedFp);
|
|
}
|
|
}
|
|
|
|
void SetNull()
|
|
{
|
|
nVersion = CKeyMetadata::CURRENT_VERSION;
|
|
nCreateTime = 0;
|
|
hdKeypath.clear();
|
|
seedFp.SetNull();
|
|
}
|
|
};
|
|
|
|
/** Access to the wallet database (wallet.dat) */
|
|
class CWalletDB : public CDB
|
|
{
|
|
public:
|
|
CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)
|
|
{
|
|
}
|
|
|
|
bool WriteName(const std::string& strAddress, const std::string& strName);
|
|
bool EraseName(const std::string& strAddress);
|
|
|
|
bool WritePurpose(const std::string& strAddress, const std::string& purpose);
|
|
bool ErasePurpose(const std::string& strAddress);
|
|
|
|
bool WriteTx(uint256 hash, const CWalletTx& wtx);
|
|
bool EraseTx(uint256 hash);
|
|
|
|
bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta);
|
|
bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta);
|
|
bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey);
|
|
|
|
bool WriteCScript(const uint160& hash, const CScript& redeemScript);
|
|
|
|
bool WriteWatchOnly(const CScript &script);
|
|
bool EraseWatchOnly(const CScript &script);
|
|
|
|
bool WriteBestBlock(const CBlockLocator& locator);
|
|
bool ReadBestBlock(CBlockLocator& locator);
|
|
|
|
bool WriteOrderPosNext(int64_t nOrderPosNext);
|
|
|
|
bool WriteDefaultKey(const CPubKey& vchPubKey);
|
|
|
|
bool WriteWitnessCacheSize(int64_t nWitnessCacheSize);
|
|
|
|
//! Record how this wallet's HD seed came to exist (CWallet::HDSeedOrigin).
|
|
bool WriteHDSeedOrigin(int64_t nOrigin);
|
|
|
|
bool ReadPool(int64_t nPool, CKeyPool& keypool);
|
|
bool WritePool(int64_t nPool, const CKeyPool& keypool);
|
|
bool ErasePool(int64_t nPool);
|
|
|
|
bool WriteMinVersion(int nVersion);
|
|
|
|
bool ReadAccount(const std::string& strAccount, CAccount& account);
|
|
bool WriteAccount(const std::string& strAccount, const CAccount& account);
|
|
|
|
/// Write destination data key,value tuple to database
|
|
bool WriteDestData(const std::string &address, const std::string &key, const std::string &value);
|
|
/// Erase destination data tuple from wallet database
|
|
bool EraseDestData(const std::string &address, const std::string &key);
|
|
|
|
bool WriteAccountingEntry(const CAccountingEntry& acentry);
|
|
CAmount GetAccountCreditDebit(const std::string& strAccount);
|
|
void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
|
|
|
|
DBErrors ReorderTransactions(CWallet* pwallet);
|
|
DBErrors LoadWallet(CWallet* pwallet);
|
|
DBErrors FindWalletTx(CWallet* pwallet, std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
|
|
DBErrors ZapWalletTx(CWallet* pwallet, std::vector<CWalletTx>& vWtx);
|
|
static bool Compact(CDBEnv& dbenv, const std::string& strFile);
|
|
static bool Recover(CDBEnv& dbenv, const std::string& filename, bool fOnlyKeys);
|
|
static bool Recover(CDBEnv& dbenv, const std::string& filename);
|
|
|
|
bool WriteHDSeed(const HDSeed& seed);
|
|
bool WriteCryptedHDSeed(const uint256& seedFp, const std::vector<unsigned char>& vchCryptedSecret);
|
|
//! Remove the PLAINTEXT hdseed record. Must be called once the seed has been
|
|
//! written in encrypted form: CDB::Rewrite (invoked at the end of
|
|
//! CWallet::EncryptWallet) copies whatever records still exist into the new
|
|
//! file, so a leftover "hdseed" leaves the unencrypted seed on disk forever.
|
|
bool EraseHDSeed(const uint256& seedFp);
|
|
//! write the hdchain model (external chain child index counter)
|
|
bool WriteHDChain(const CHDChain& chain);
|
|
|
|
/// Write spending key to wallet database, where key is payment address and value is spending key.
|
|
bool WriteSaplingZKey(const libzcash::SaplingIncomingViewingKey &ivk,
|
|
const libzcash::SaplingExtendedSpendingKey &key,
|
|
const CKeyMetadata &keyMeta);
|
|
bool WriteSaplingPaymentAddress(const libzcash::SaplingPaymentAddress &addr,
|
|
const libzcash::SaplingIncomingViewingKey &ivk);
|
|
bool WriteCryptedSaplingZKey(const libzcash::SaplingExtendedFullViewingKey &extfvk,
|
|
const std::vector<unsigned char>& vchCryptedSecret,
|
|
const CKeyMetadata &keyMeta);
|
|
|
|
private:
|
|
CWalletDB(const CWalletDB&);
|
|
void operator=(const CWalletDB&);
|
|
|
|
bool WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry);
|
|
};
|
|
|
|
bool BackupWallet(const CWallet& wallet, const std::string& strDest);
|
|
void ThreadFlushWalletDB(const std::string& strFile);
|
|
|
|
#endif // HUSH_WALLET_WALLETDB_H
|