Monero

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 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 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 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.

This commit adds a new wallet RPC command called wallet_exists that lets a caller check whether a wallet file already exists on the server. It also refactors existing filename validation into a shared helper. The change is mostly a feature addition, but it does expose filesystem information (file presence) over the RPC interface, which can aid reconnaissance if the RPC endpoint is reachable by an attacker.

This commit adds a safety check in Monero's wallet code. When the wallet tries to repair its local record of the blockchain (the 'hashchain'), it now refuses to continue if the network node returns a block hash that isn't a valid hexadecimal string. Before this change, an invalid or malformed hash could silently be converted to an empty or garbage value, potentially corrupting the wallet's view of the blockchain.

This small patch fixes a logic bug in how the Monero wallet decides whether SSL/TLS is required when connecting to a daemon. Previously, the wallet only treated SSL as required when the user explicitly pinned a specific certificate ('user_certificates' mode). If the user supplied a custom CA file or allowed certificate fingerprints, the code did not mark SSL as required, which could let the wallet silently fall back to an unencrypted connection in some situations. The fix introduces a separate flag so that supplying a CA file or fingerprints now correctly forces SSL to be required, preserving the user's intended security setting.

This small patch fixes a state-cleanup bug in Monero's wallet API. Previously, when a wallet connected to a new daemon without providing a username, it could accidentally reuse login credentials from an earlier connection. The patch now explicitly clears those old credentials when no username is supplied, preventing the wallet from sending stale authentication to the wrong daemon.

This commit changes how the Monero wallet handles error responses from the daemon (the network node it talks to). Previously, certain RPC calls used a macro that did not check the daemon's returned status code in all cases. The new code explicitly checks that status and throws a proper wallet error if the daemon reports a failure. In practical terms, this reduces the chance that the wallet will silently continue with stale or incomplete data when the daemon is actually telling it something went wrong. It is a hardening fix rather than a clear-cut exploit patch, and the commit message does not describe a specific vulnerability.

This commit adds validation and formatting fixes for public Monero node addresses shown in the wallet. It prevents invalid or malformed node entries (such as those with port 0 or unparseable hostnames) from being displayed, and it correctly wraps IPv6 addresses in brackets so they are not misread. The change reduces the chance that a user connects to or trusts a bogus node listed among public nodes, but it does not by itself stop an attacker from listing a malicious node—only from listing one with an obviously invalid address.

This patch changes how a Monero wallet records the breakdown of received amounts when an existing output is 'burnt' and replaced by a new one during transaction processing. It ensures the stored amount list stays consistent with the actual new output value. The commit message frames this as a consistency fix, not a security fix, and the supplied materials do not show any exploit path.

This commit only removes eight short inline comments from a header file because equivalent descriptions already exist as formal documentation comments directly beneath each one. There are no code, logic, or security changes.

This commit fixes a bug in Monero's network message handling that only affects computers using big-endian processors (a rare type of CPU architecture). The bug caused the program to misread the sizes and flags of split-up network messages, which could make the software reject valid network traffic or behave incorrectly. It does not appear to be a security exploit against typical users, but it is a correctness fix for an important networking component.

This is a small performance cleanup in Monero's wallet code. It replaces two unnecessary copies of transaction lists with references, and switches one lookup from a two-step 'check then fetch' to a single map lookup. There is no security issue visible in the change.

This commit removes attacker-controlled HTTP header text from error and debug log messages in Monero's epee networking code. Before the change, a malicious peer or server could put fake log lines, terminal escape codes, or misleading text into HTTP headers, and those characters would be written verbatim into application logs. That could trick administrators, hide real alerts, or in some terminal setups manipulate display output. The patch replaces the raw header content in log messages with just the byte size of the offending data, so the malicious bytes are no longer echoed into logs.

This commit fixes a bug in the Monero wallet where it would partially change account tags even when some requested account numbers did not exist. Previously, the wallet checked each account number one at a time and applied the tag immediately, so an invalid account number appearing after a valid one could leave tags changed. Now all account numbers are checked first, and only if they are all valid are any tags changed. The included test confirms that an out-of-bounds account index now causes an error and leaves existing tags untouched.

This Monero wallet update adds safety checks when a multisig wallet imports data shared by other signers. Before, the code trusted the size and claimed signer of imported multisig data too much; now it rejects blobs with the wrong number of partial key images, wrong number of signing nonces, or a signer that does not match the file header. The change is defensive and prevents malformed or mismatched data from being processed further, but the commit message does not call it a security fix and no exploit is demonstrated.

This Monero wallet commit adds stronger safety checks when handling unsigned, partially signed, and fully signed transactions before they are signed or broadcast. It prevents several risky situations: reusing the same coin across multiple transactions, sending change to an address that does not belong to the wallet, mismatched destination address types, and a byte-order bug when verifying encrypted payment amounts. These are defensive hardening fixes in transaction validation code paths that handle sensitive user funds.

This change stops users from starting the Monero wallet RPC server with both a global wallet password and a wallet directory mode. When running with --wallet-dir, the server can manage multiple wallets, each with its own password. Supplying a single --password in that mode could have caused the password to be applied to all wallets or otherwise weaken security expectations. The patch now rejects that combination and updates shell tab-completion to reflect the restriction.

This change moves an error check earlier in the Monero wallet's 'generate wallet from keys' RPC command. Previously, the code would create a wallet file before checking whether the requested seed language was valid. Now it checks the language first and refuses to proceed if it's invalid. The main risk is that a user or attacker could supply a bad language and leave behind a partially-created wallet file or trigger unexpected behavior. The fix is straightforward and defensive, and the test confirms the invalid language is now rejected before any file is written.

This commit changes one line in Monero's wallet API. When recovering a wallet from a hardware device fails, the code now marks the error as 'critical' rather than just a regular error. This is a status/severity classification change, not a fix for a code vulnerability. It may help downstream callers notice recovery failures more clearly, but it does not by itself prevent or enable any attack.

This is a tiny code cleanup in Monero's wallet RPC server. The code was accidentally reusing the wrong response variable when checking whether background mining started successfully. The fix makes it use the correct response variable, so error messages and status checks are accurate. There is no security vulnerability here—just a bug fix that prevents misleading log output.

This commit adds a safety check in the Monero wallet software. When the wallet asks a remote node (daemon) for specific transaction data, it now verifies that the daemon actually returned the exact transactions that were requested, in the correct order. Before this change, a malicious or buggy daemon could potentially return the wrong transactions, which the wallet might then process as if they were the right ones. This could lead to incorrect balance calculations, failed transactions, or other wallet confusion.

This patch fixes a bug in the Monero daemon's 'start_mining' command. Previously, when a user started mining to a human-readable address (like a domain name), the code asked for a DNSSEC-validated lookup but then ignored whether DNSSEC actually succeeded. That could let an attacker on the network tamper with the DNS response and redirect mining rewards to their own wallet. The patch now rejects the command if DNSSEC validation fails.