Monero

This patch tightens validation of Monero 'key images'—the special values that prevent the same coin from being spent twice. Before the change, a malformed key image that was either the identity point or had a small-order/torsion component could potentially slip through ring-signature verification. The fix rejects the identity key image outright and multiplies the key image by the curve order to confirm it lies on the proper subgroup, returning false if it does not. This closes a path that could let an attacker craft a signature that looks valid but does not actually mark a real coin as spent, which in Monero can translate to a double-spend or balance-inflation risk.

This change fixes a privacy leak in Monero's restricted RPC mode. When a node operator enabled restricted RPC (used for public RPC endpoints), the get_block_template RPC call could still include sensitive transactions—specifically Dandelion++ stem transactions that are not yet meant to be publicly broadcast. A remote user could request a block template from a restricted RPC node and learn about transactions that ordinary network participants should not yet see, weakening transaction privacy. The patch adds an include_sensitive flag that defaults to true for normal callers but is set to false when the request comes through a restricted RPC context, so those transactions are excluded from the returned template.

This patch changes the order in which two internal locks are acquired in a Monero blockchain-checking function. In multi-threaded software, taking locks in the wrong order can cause a 'deadlock,' where two parts of the program wait forever for each other and the node can freeze. The change makes the lock order consistent with the rest of the codebase, which is a defensive fix. There is no direct evidence in the commit that an attacker can trigger the deadlock on demand, but lock-order bugs are a classic source of denial-of-service problems in network-facing daemons.

This commit fixes a bug in Monero's wallet software where the program would partially change account labels before checking whether all requested accounts actually exist. The fix moves the boundary check to the very beginning so the operation either fully succeeds or fully fails, and no partial changes are saved. The practical security impact is limited because the bug only affects account tagging metadata, not balances or transactions.

This Monero wallet update adds safety checks when a wallet imports 'multisig_info' data shared between co-signers in a multi-signature wallet. It now rejects files where the declared signer doesn't match the file header, or where the number of partial key images or signing nonces is wrong. These checks prevent malformed or mismatched multisig data from being processed further. The change includes new unit tests that confirm the rejections work.

This update adds a safety check in the Monero wallet software. When the wallet asks a network node (daemon) for details about specific transactions, it now verifies that the transactions it gets back are actually the ones it asked for. Without this check, a malicious or compromised node could potentially return the wrong transactions, which might confuse the wallet about balances or transaction history. The fix makes the wallet reject any response where the returned transaction IDs do not match the requested ones.

This commit hardens a Monero blockchain lookup function so it returns a clean failure instead of letting an internal 'transaction does not exist' exception bubble up. The change makes the node more robust when asked about outputs for a transaction that is missing from the database, which could previously crash or abort the calling code path.

This patch fixes a connection-reuse bug in Monero's networking helper. Previously, the client could reuse a TCP connection that the peer had already half-closed (for example, after sending data and shutting down its send side). That could lead to sending new requests over a dead connection, reading stale or truncated data, or reusing a TLS session after the peer sent a close alert. The change makes the client check for peer EOF and TLS close-notify before declaring a connection reusable, and makes disconnect safe to call multiple times without crashing or corrupting buffered data.

This change adds a safety check in Monero's core code that rejects a block if it contains the same transaction hash more than once, before looking those transactions up in the memory pool. Duplicate transaction hashes in a single block could cause inconsistent behavior or be exploited to manipulate how transactions are fetched and included. The fix is small and defensive, but the commit message does not describe a specific attack or security impact.

This Monero commit changes how the wallet remembers which daemon (server) it should connect to. Previously, if you told the wallet RPC server to use a specific daemon before any wallet was open, that setting was lost as soon as you opened or created a wallet. Now that setting is saved and automatically applied to wallets opened or created later. The change also lets you call set_daemon even when no wallet is loaded. There is one small security-relevant side effect: because the daemon settings now persist, a test helper that temporarily switches to a wrong daemon had to explicitly restore the 'trusted' flag afterward, otherwise the restored daemon would be treated as untrusted. The commit itself is a feature/fix for configuration persistence, not an exploit.

This Monero wallet commit changes how proxy settings are handled. Previously, if you started the wallet with a global --proxy option, you could not later use the set_daemon command to pick a different proxy for a specific daemon. The commit removes that restriction, allowing set_daemon to override the global proxy. This is a behavior change that could matter for privacy and security, but the commit itself does not show an obvious vulnerability—just a relaxation of a guard rule.

This commit adds a safety check when loading older Monero wallet data. It ensures that a stored 'output index' (which points to a specific coin within a past transaction) does not point past the number of outputs that transaction actually has. Without this check, a malformed or manipulated old wallet file could reference a non-existent output, potentially causing crashes or undefined behavior when the wallet later uses that index.

This patch tightens a safety check in Monero's wallet when creating a 'reserve proof' (a cryptographic receipt proving funds exist). Previously the wallet only checked whether any extra public keys existed at all; now it checks whether the specific key needed for the output actually exists. Without this check, the wallet could read past the end of an empty list and crash or behave unpredictably, but the change is small and the error path already threw an exception.

This update adds safety checks to Monero's wallet code when reading wallet key files. Previously, the code assumed the file contained a properly formatted JSON object with a 'key_data' text field. If a file was malformed or missing that field, the program could read from invalid memory and crash or behave unpredictably. The patch now checks the structure before using the data and returns an error instead.

This small change makes the wallet refresh its account-tag list before assigning a tag to accounts. Without this refresh, the wallet might act on stale or inconsistent tag data, which could lead to tags being applied to the wrong accounts or to duplicate/confused labels. The commit message and reporter credit suggest this was treated as a real bug, but the diff itself does not show an obvious exploit path.