What changed, and why it matters
This Monero wallet patch fixes a bug in cold-wallet signing where the full (offline) wallet could incorrectly trim or fail to update its list of spendable outputs when the watch-only wallet sent it an empty output export. The fix makes the offline signer recognize a special 'empty trim' signal in newer transaction export files, so it can safely discard outputs that the watch-only wallet no longer sees—such as after a blockchain reorganization—without losing other valid outputs. If left unfixed, a signer might try to spend outputs that no longer exist, or fail to sign valid transactions, but it does not appear to let an attacker steal funds directly.
Treat as a correctness/security fix for cold-wallet users. Review whether the new `has_new_transfers_total` flag is always set correctly on both serialization paths, and confirm that the `empty_trim` condition cannot be triggered by malformed or attacker-controlled `unsigned_tx_set` data to prune legitimate outputs. Backport to maintained branches that support cold signing.
Security signals we found
Cold/offline signing output synchronization bug
Potential spend attempt against outputs invalidated by reorg
New serialization version field used as safety flag
Functional tests explicitly exercise reorg and empty-export signing paths
Evidence from the diff
The change adds a boolean flag has_new_transfers_total to unsigned_tx_set, set only when deserializing version >= 2 data. In wallet2::sign_tx, the code now calls import_outputs(new_transfers) not only when the new_transfers container is non-empty, but also in an ‘empty_trim’ case: when has_new_transfers_total is true, the signer has never refreshed from a node, the new_transfers detail vector is empty, and the start/end indices in the tuple are equal and below the current local transfer count. This lets a refreshed full wallet behind a watch-only wallet, or a cold wallet after a reorg, correctly truncate its local outputs to match the watch-only view when the exported output set is intentionally empty. Tests cover refreshed full wallet signing, refreshed full wallet behind watch-only, and reorg-with-empty-output-export scenarios.
Changed components
src/wallet/wallet2.cppsrc/wallet/wallet2.htests/functional_tests/cold_signing.pytests/unit_tests/serialization.cppInspect captured patch +127 / −2
### src/wallet/wallet2.cpp
@@ -8271,8 +8271,13 @@ bool wallet2::sign_tx(unsigned_tx_set &exported_txs, std::vector<wallet2::pendin
{
wallet::sanity_check_unsigned_tx_set(exported_txs.txes, m_account.get_keys(), m_subaddresses);
- if (!std::get<2>(exported_txs.new_transfers).empty())
- import_outputs(exported_txs.new_transfers);
+ const auto &new_transfers = exported_txs.new_transfers;
+ const bool empty_trim = exported_txs.has_new_transfers_total &&
+ !m_has_ever_refreshed_from_node && std::get<2>(new_transfers).empty() &&
+ std::get<0>(new_transfers) == std::get<1>(new_transfers) &&
+ std::get<1>(new_transfers) < m_transfers.size();
+ if (!std::get<2>(new_transfers).empty() || empty_trim)
+ import_outputs(new_transfers);
else if (!std::get<2>(exported_txs.transfers).empty())
import_outputs(exported_txs.transfers);
### src/wallet/wallet2.h
@@ -477,9 +477,12 @@ namespace tools
std::vector<tx_construction_data> txes;
std::tuple<uint64_t, uint64_t, wallet2::transfer_container> transfers;
std::tuple<uint64_t, uint64_t, std::vector<wallet2::exported_transfer_details>> new_transfers;
+ bool has_new_transfers_total = false;
BEGIN_SERIALIZE_OBJECT()
VERSION_FIELD(2)
+ if (!typename Archive<W>::is_saving())
+ has_new_transfers_total = version >= 2;
FIELD(txes)
if (version == 0)
{
### tests/functional_tests/cold_signing.py
@@ -57,6 +57,9 @@ def run_test(self):
self.self_transfer_to_other_account()
self.sweep()
self.failed_output_import_keeps_complete_transfers()
+ self.sign_with_refreshed_full_wallet()
+ self.sign_with_refreshed_full_wallet_behind_watch_only()
+ self.sign_after_reorg_with_empty_output_export()
def reset(self):
print('Resetting blockchain')
@@ -471,6 +474,85 @@ def failed_output_import_keeps_complete_transfers(self):
assert imported_output.subaddr_index.minor == 220
assert imported_output.key_image
+ def sign_with_refreshed_full_wallet(self):
+ print("Signing with a refreshed full wallet after an empty output export")
+ self.reset()
+ self.create(0)
+ self.mine()
+ self.hot_wallet.refresh()
+
+ full_wallet = Wallet(idx = 1)
+ try: full_wallet.close_wallet()
+ except: pass
+ full_wallet.restore_deterministic_wallet(seed = SEED)
+ full_wallet.refresh()
+ original_count = len(self.hot_wallet.incoming_transfers()['transfers'])
+ assert len(full_wallet.incoming_transfers()['transfers']) == original_count
+
+ key_images = full_wallet.export_key_images(True)
+ self.hot_wallet.import_key_images(key_images.signed_key_images, offset = key_images.offset)
+
+ unsigned_txset = self.hot_wallet.transfer([{'address': OTHER_ADDRESS, 'amount': 1000000000000}]).unsigned_txset
+ signed_txset = full_wallet.sign_transfer(unsigned_txset).signed_txset
+ assert len(full_wallet.incoming_transfers()['transfers']) == original_count
+ assert len(self.hot_wallet.submit_transfer(signed_txset).tx_hash_list) == 1
+ full_wallet.close_wallet()
+
+ def sign_with_refreshed_full_wallet_behind_watch_only(self):
+ print("Signing with a refreshed full wallet behind the watch-only wallet")
+ self.reset()
+ self.create(0)
+ self.mine()
+
+ full_wallet = Wallet(idx = 1)
+ try: full_wallet.close_wallet()
+ except: pass
+ full_wallet.restore_deterministic_wallet(seed = SEED)
+ full_wallet.refresh()
+ signer_count = len(full_wallet.incoming_transfers()['transfers'])
+
+ daemon = Daemon()
+ daemon.generateblocks(STANDARD_ADDRESS, 1)
+ self.hot_wallet.refresh()
+ assert len(self.hot_wallet.incoming_transfers()['transfers']) == signer_count + 1
+
+ self.cold_wallet.import_outputs(self.hot_wallet.export_outputs().outputs_data_hex)
+ key_images = self.cold_wallet.export_key_images(True)
+ self.hot_wallet.import_key_images(key_images.signed_key_images, offset = key_images.offset)
+
+ unsigned_txset = self.hot_wallet.transfer([{'address': OTHER_ADDRESS, 'amount': 1000000000000}]).unsigned_txset
+ signed_txset = full_wallet.sign_transfer(unsigned_txset).signed_txset
+ assert len(full_wallet.incoming_transfers()['transfers']) == signer_count
+ assert len(self.hot_wallet.submit_transfer(signed_txset).tx_hash_list) == 1
+ full_wallet.close_wallet()
+
+ def sign_after_reorg_with_empty_output_export(self):
+ print("Signing after a reorg removes an output known to the cold wallet")
+ self.reset()
+ self.create(0)
+ self.mine()
+ self.export_import(False)
+
+ daemon = Daemon()
+ original_count = len(self.hot_wallet.incoming_transfers()['transfers'])
+ daemon.generateblocks(STANDARD_ADDRESS, 1)
+ self.hot_wallet.refresh()
+ assert len(self.hot_wallet.incoming_transfers()['transfers']) == original_count + 1
+ self.cold_wallet.import_outputs(self.hot_wallet.export_outputs().outputs_data_hex)
+ key_images = self.cold_wallet.export_key_images(True)
+ self.hot_wallet.import_key_images(key_images.signed_key_images, offset = key_images.offset)
+
+ daemon.pop_blocks(1)
+ daemon.generateblocks(OTHER_ADDRESS, 1)
+ self.hot_wallet.refresh()
+ assert len(self.hot_wallet.incoming_transfers()['transfers']) == original_count
+ assert len(self.cold_wallet.incoming_transfers()['transfers']) == original_count + 1
+
+ unsigned_txset = self.hot_wallet.transfer([{'address': OTHER_ADDRESS, 'amount': 1000000000000}]).unsigned_txset
+ signed_txset = self.cold_wallet.sign_transfer(unsigned_txset).signed_txset
+ assert len(self.cold_wallet.incoming_transfers()['transfers']) == original_count
+ assert len(self.hot_wallet.submit_transfer(signed_txset).tx_hash_list) == 1
+
class Guard:
def __enter__(self):
for i in range(2):
### tests/unit_tests/serialization.cpp
@@ -1039,6 +1039,41 @@ TEST(Serialization, tuple_3_4_backwards_compatibility)
EXPECT_EQ(t4, t4_recovered);
}
+TEST(Serialization, unsigned_tx_set_transfer_count_versions)
+{
+ for (uint32_t version = 0; version <= 2; ++version)
+ {
+ std::ostringstream oss;
+ binary_archive<true> ar(oss);
+ ar.serialize_varint(version);
+ std::vector<tools::wallet2::tx_construction_data> txes;
+ ASSERT_TRUE(::serialization::serialize(ar, txes));
+ if (version == 0)
+ {
+ std::pair<size_t, tools::wallet2::transfer_container> transfers{3, {}};
+ ASSERT_TRUE(::serialization::serialize(ar, transfers));
+ }
+ else if (version == 1)
+ {
+ std::pair<size_t, std::vector<tools::wallet2::exported_transfer_details>> transfers{3, {}};
+ ASSERT_TRUE(::serialization::serialize(ar, transfers));
+ }
+ else
+ {
+ std::tuple<uint64_t, uint64_t, std::vector<tools::wallet2::exported_transfer_details>> transfers{3, 3, {}};
+ ASSERT_TRUE(::serialization::serialize(ar, transfers));
+ }
+
+ tools::wallet2::unsigned_tx_set recovered;
+ ASSERT_TRUE(::serialization::parse_binary(oss.str(), recovered));
+ EXPECT_EQ(version == 2, recovered.has_new_transfers_total);
+ if (version == 0)
+ EXPECT_EQ(3, std::get<1>(recovered.transfers));
+ else
+ EXPECT_EQ(3, std::get<1>(recovered.new_transfers));
+ }
+}
+
struct Tupler
{
std::tuple<> t0;Why this scored 59/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.