Monero

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.

This commit adds support for a new type of wallet backup phrase called Polyseed to the Monero wallet software. It touches many wallet components (CLI, RPC, library API) so users can create, restore, and display Polyseed backups alongside the older 25-word legacy seeds. The change also stores a new Polyseed field in encrypted wallet files and handles passphrases/seed offsets in a specific way. There is no direct evidence in the commit that this fixes an active security bug; it reads as a large feature addition. However, because it changes how secret key material is serialized, encrypted, and derived from seed words, any mistakes in this area could affect wallet security or recoverability.

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 the code that talks to USB hardware wallets (Ledger/Trezor-style devices via HID). Previously, when receiving a response in chunks, the code could keep writing past the end of a fixed-size buffer if a malicious or misbehaving device sent more data than expected. The new check stops this before each read, preventing a buffer overflow. The fix uses an assertion, which means the program will abort rather than continue in an unsafe state.

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 Monero commit fixes how the wallet handles transaction public keys and address public keys so that keys with small-order or non-standard curve points (called 'torsion' points) are normalized or rejected before being used. It also tightens validation of destination addresses and makes transaction-proof logic more consistent. In plain terms, the patch closes gaps where a malformed key could confuse the wallet about who paid whom or whether a payment proof is valid.

This commit is a code cleanup: it moves the logic that removes small-subgroup 'torsion' from elliptic-curve points out of a newer, specialized module (fcmp_pp) and into the core cryptography library (crypto). The same mathematical operation is now shared by the ring signature code and the new FCMP++ code. There is no direct evidence in the commit that this fixes an active vulnerability; it looks like a refactoring to avoid duplicated constants and helper functions.

This commit changes a single error log message. Instead of printing the full invalid hash string, it now prints only the length of that string. This is a minor logging improvement and does not change any program behavior, security boundary, or data flow.

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 fixes a security gap in how HTTP Digest authentication was validated in Monero's built-in HTTP server. Previously, a valid authentication response for one URL could potentially be accepted for a different URL. The fix now checks that the URL in the authentication response matches the URL actually being requested. The commit message itself says the practical impact for Monero's RPC use is limited.

This commit changes the order in which two internal locks are acquired in a Monero blockchain checkpoint-checking function. Lock ordering bugs are a common source of deadlocks, where two parts of the program wait forever for each other. The patch itself is very small and appears to be a partial fix rather than a complete security overhaul. There is no direct evidence in the commit that this was exploited or that it caused a concrete vulnerability, but inconsistent lock ordering in critical consensus code is a recognized reliability and potential security risk.

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 fixes how Monero's automatic update checker validates the cryptographic hash of a downloaded update. Previously, the code only checked that the hash string was 64 characters long and contained only letters or digits. That check was flawed: a 64-character hex string with only alphanumeric characters would pass even if it was not a valid hash, and the hash was never converted into a proper internal hash object. The patch now converts the hex string into a real cryptographic hash and then back to a normalized hex form, ensuring only correctly formatted hashes are accepted. This reduces the risk that a malicious or malformed update descriptor could trick the client into trusting a bad update.

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 adds a small convenience feature to Monero's remote procedure call (RPC) interface: the get_version response now tells callers which network the node is running on (mainnet, testnet, stagenet, fakechain, or unknown). It also refactors an existing inline network-name lookup into a reusable helper function. There is no security fix or behavior change that would allow an attacker to harm users or the network.

This commit adds stricter limits during deserialization of Monero transactions. It prevents attackers from sending malformed transactions with absurdly large numbers of inputs, outputs, or ring-member references, which could previously exhaust memory or CPU during parsing. The change moves some safety checks earlier in the process and makes them mandatory for all deserialization paths, not just the main transaction-parsing helpers.

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.