Monero

This Monero wallet update fixes a bookkeeping bug. When a wallet imported a list of its owned outputs and that list was smaller than a previous import, internal lookup maps (key images and public keys) could still point to entries that no longer existed. The patch trims those stale pointers whenever the transfer list is shrunk, and also repairs them when loading an older wallet cache that has never been refreshed from a node. The main risk is that stale indices could cause the wallet to crash or behave incorrectly, but the code already threw an error if an out-of-range index was detected, so this is more of a robustness/correctness fix than an obvious exploit path.

This commit simplifies how Monero's simplewallet decides whether a payment ID is a real encrypted ID or a dummy placeholder. Previously, the wallet checked both the payment ID value and whether any destination was an integrated address, and it would abort with an error if those two signals disagreed. Now it trusts only the actual payment ID value (a zero/empty value means dummy). The change removes a safety check that could reject otherwise-valid transactions, which could matter if the old check was too strict or could be triggered by unusual wallet/address combinations.

This Monero wallet patch cleans up internal lookup tables (key-image and public-key indexes) when the list of owned transaction outputs is shrunk, for example during an output import. Without the cleanup, those indexes could point to entries that no longer exist, which could cause the wallet to crash or behave incorrectly when it later tries to spend or display funds. The patch also repairs any stale indexes when loading an older wallet cache that has never been refreshed from a node.

This small change removes a consistency check in Monero's command-line wallet when loading a saved transaction. Previously, the wallet verified that a 'dummy' payment ID label matched a special zero-value payment ID. Now it labels the payment ID as dummy based only on the zero value, without checking whether any destination is an integrated address. This could let a crafted saved transaction file display a misleading payment ID label, but it does not by itself steal funds or break cryptography.

This commit updates Monero's built-in blockchain checkpoints to match the v0.18.5.3 release. Checkpoints are hard-coded reference points that help nodes quickly verify they are following the correct chain and resist certain attacks. The change only updates data values (block heights and hashes) and version references in documentation; it does not introduce new code logic or fix a known vulnerability.

This is a small code fix in Monero's wallet that keeps the recorded breakdown of received amounts consistent when a transaction output is 'burnt' (replaced or spent as part of a transaction the wallet is processing). The change adds a check that throws an internal wallet error if the expected amount cannot be found in the wallet's tracking list, and updates the tracked value to the remaining 'extra' amount. The commit message does not describe this as a security fix, and there is no direct evidence in the diff or supplied references that this is exploitable by an attacker.

This patch fixes a spot in the Monero wallet where an untrusted remote server (daemon) could supply a misleading 'status' field. Previously, the wallet used that raw status directly in its error handling, which could potentially make a malicious daemon's response look trustworthy or cause the wallet to misbehave. The fix passes the status through a helper that treats the daemon as untrusted unless the user has explicitly marked it trusted.

This commit adds two new read-only options to the wallet's remote procedure call (RPC) interface so users can request their public view key and public spend key. Public keys are meant to be shared openly and are not secrets, so exposing them through an existing authenticated API is not a security issue. The change also includes tests verifying the new behavior.

This commit only updates a submodule pointer for the external polyseed library from one commit hash to another. The actual code changes inside the submodule are not shown in the diff, and no public references were supplied. There is no visible security issue in the commit itself.

This patch fixes a size-limit accounting bug in Monero's built-in HTTP server. When a client sends multiple HTTP requests back-to-back on the same connection (pipelining), leftover buffered data from the next request was not being counted toward the server's maximum allowed request size. A malicious or misbehaving client could therefore sneak in a request larger than the configured limit, potentially causing excessive memory use or a denial of service. The fix makes the server count that already-buffered data against the limit when it starts processing the next request.

This patch fixes a privacy leak in Monero's wallet RPC server. Previously, the --no-dns flag was ignored when no wallet was loaded, so the validate_address RPC call could still perform a DNS lookup (OpenAlias) even though the user had explicitly disabled DNS. This could leak which address or alias a user was checking to DNS servers. The fix makes the RPC server honor --no-dns and --offline flags even without a wallet open.

This commit adds cleanup of three additional memory buffers in Monero's seed-phrase key-stretching code. Before the change, leftover copies of intermediate secrets could remain in stack memory after the function finished. An attacker who could read process memory (for example, through another vulnerability or a memory dump) might recover parts of a wallet's seed-phrase secret. The patch wipes those buffers before returning, reducing that exposure.

This update improves the Monero wallet's command that connects to a network node (daemon). It lets users supply a username/password and a proxy address when switching daemons, and it replaces an older one-step connection method with a newer, more complete setup method. A small thread-safety lock was also added to the proxy-setting function. There is no clear security bug being fixed; it looks like a usability and consistency improvement.

This change alters how Monero creates a view-only wallet copy. Previously, the code exported outputs using a method that could strip some metadata. Now it copies the full internal transfer records directly, then wipes and clears the multi-signature key field to avoid leaking a signing secret. The intent appears to be a security fix: preserving more metadata in view-only wallets while scrubbing data that should not be exported. However, the patch is small and the commit message does not explicitly call it a security fix, so the classification is uncertain.

This Monero update hardens how public keys and transaction pubkeys are handled. It moves a low-level 'torsion clearing' routine into the core crypto library, adds checks that wallet/destination addresses are valid points on the main subgroup of the curve, and normalizes transaction public keys before they are used for payment-ID decryption, transaction proofs, and hardware-wallet communication. The changes reduce the risk that malformed or small-subgroup public keys could be used to confuse wallet logic, leak information, or cause inconsistent behavior. The commit message frames it as a fix for 'inconsistent tx pubkey handling' and a crypto cleanup, not as an active-exploit patch.

This Monero update fixes a networking bug where the server could accidentally block all of its worker threads while waiting for slow clients to accept data. If all workers became stuck this way, the node could stop processing any network traffic, effectively causing a denial-of-service. The patch removes the blocking wait and instead drops connections that exceed send limits. It also makes HTTP response failures propagate correctly so a failed send stops further request processing instead of continuing blindly.

This Monero wallet patch adds stronger safety checks when a wallet prepares, signs, or loads multi-step transactions (unsigned transactions, multisig transactions, and cold-device transactions). It verifies that money going into the transaction is not counted twice, that change addresses really belong to the wallet, that outputs do not exceed inputs, and that destination address types stay consistent. These are defensive hardening measures against mistakes or maliciously crafted transaction files that could otherwise make the wallet sign an invalid or harmful transaction.

This Monero update makes the network layer clean up leftover block download records when a peer connection fails or is rejected. Previously, rejected or disconnected peers could leave stale block spans in a queue, which might cause the node to skip fetching those blocks from other peers and potentially stall synchronization. The fix flushes those stale spans so the node can re-request the blocks elsewhere.

This small patch fixes a bug in the Monero wallet where, if an output had already been scanned once, the wallet would return early without clearing an error flag. In rare cases this could leave a stale 'error' state attached to a transaction output, potentially causing the wallet to misreport whether a payment was received or whether scanning succeeded. It is a defensive correctness fix rather than a clear exploit, but stale error state in financial software can have security-adjacent consequences.

This change fixes a binary search in the Monero wallet that previously could loop forever or behave incorrectly if something went wrong. The old code used an unbounded 'while (true)' loop and a midpoint calculation that could overflow. The patch limits the loop to 64 iterations (enough for any blockchain height) and switches to a safer midpoint formula. In the worst case, the old loop might never terminate, causing the wallet to hang when looking up a blockchain height from a timestamp.

This change upgrades the Monero RPC server's HTTP Digest Authentication to support SHA-256 and adds a command-line flag to disable the older MD5 algorithm. MD5 is considered weak by modern security standards, so this gives node operators a way to enforce stronger authentication hashing. By default, both MD5 and SHA-256 are still offered, so the change is backwards-compatible and does not by itself remove the weaker option.

This commit changes how a Monero wallet handles error status codes returned by a remote daemon during a cleanup operation called 'sweep unmixable.' Previously, the wallet trusted the daemon's raw status response. Now it passes that status through a helper that treats certain errors differently when the daemon is not trusted. This is a hardening fix: a malicious or compromised remote node could potentially return a misleading status code that the wallet would treat as a fatal error, possibly disrupting the operation or influencing wallet behavior. The patch narrows what the wallet believes from an untrusted daemon.

This tiny change adjusts how the Monero wallet treats old-style unencrypted payment IDs when it cannot determine the block version of the transaction. Previously, if the block version was unknown (reported as 0), the wallet would still process the long payment ID. Now it ignores it, matching the intended privacy-preserving behavior for modern blocks. The risk is reduced privacy or accidental information leakage in edge cases, not theft of funds.

This Monero update tightens how the network handles trimmed-down (pruned) transaction data shared between nodes. Before, a node could accept extra junk bytes tacked onto the end of a pruned transaction blob. Now it rejects such blobs. This closes a potential avenue for malformed data to be accepted or processed unexpectedly, which could lead to inconsistent node state or denial-of-service issues.

This commit fixes a wallet-creation bug: when restoring a Monero wallet from a special newer-style seed (called a Polyseed) using a JSON configuration file, the wallet software previously treated it like an older Electrum-style seed. This could cause the restore height to be set incorrectly and could apply an optional seed passphrase to the wrong key derivation path. The patch makes the JSON restore path recognize Polyseeds and handle their passphrase and birthday height correctly. It also preserves the restore height in the simplewallet command-line tool when no explicit restore height is provided.