Monero

This commit is a performance optimization for Monero's RPC endpoints that fetch blocks and transactions. It replaces slow full transaction parsing with a lightweight custom parser, avoids unnecessary re-serialization, and improves how mempool transactions are returned. The changes touch security-relevant code paths (parsing untrusted transaction blobs and deciding what data to expose), but the commit itself is framed as a speedup, not a security fix. There is no direct evidence in the commit message or diff of a vulnerability being fixed, though the new parser could in principle introduce parsing bugs.

This commit is a routine performance cleanup. It reserves memory ahead of time for a list of output keys, avoids one unnecessary move of a block object, and reuses a boolean tracking vector instead of recreating it inside a loop. None of these changes alter security behavior or fix a vulnerability.

This Monero patch adds validation checks during ring signature verification to reject certain malformed 'key images.' A key image is a cryptographic fingerprint that proves a coin is being spent without revealing which coin. Before this fix, the verifier accepted some mathematically invalid key images, such as the identity point or points whose order divides a small number (torsioned points). An attacker could potentially craft such a key image to bypass the 'already spent' check, enabling double-spending of coins or denial of service against the network.

This commit removes a build-time test that checked whether the Protobuf library could compile and link correctly for Trezor hardware wallet support. It does not change any runtime code that handles user funds, transactions, or network data. The change only affects the build system and removes a compile-time sanity check, so it is not a security vulnerability by itself.

This commit changes how Monero's build system handles the protobuf library on Android. It disables protobuf's use of Android's system logging and stops linking the Android 'log' library when building through the project's dependency system. The change appears to be a build-system hardening or compatibility fix, not a patch for an active security vulnerability. There is no direct evidence in the commit that this fixes an exploitable bug.

This commit only adds a new automated fuzz test for Monero's Bulletproof+ range proof verification code. It does not change any production code, cryptographic logic, or network behavior. There is no indication this commit fixes or introduces a security issue.

This commit fixes two memory-safety bugs in Monero's command-line blockchain utility tools. One bug could let a crafted saved state file cause the program to allocate an enormous vector and crash or exhaust memory. The other bug could cause the program to read a transaction input incorrectly and crash when computing ring-size statistics. These are offline analysis tools, not the live Monero daemon or wallet, so they do not directly affect running nodes or user funds.

This commit changes how Monero's public RPC endpoint 'get_transaction_pool' reports the contents of the memory pool (pending transactions). Previously, the endpoint could be called in 'restricted' mode and would hide some sensitive timing fields but still return transaction data. Now the endpoint always returns full timing metadata, but the entire method is blocked when the RPC is running in restricted mode. In short, the patch trades more complete data for a smaller attack surface: only trusted callers can query the transaction pool at all.

This commit changes how the Monero wallet's HTTP client tears down network connections when the wallet shuts down. It adds a new 'shutdown' path that can interrupt blocked network operations from another thread or even a Unix signal handler, so the wallet stops promptly instead of hanging on a slow or unresponsive daemon. The change is framed by the author as a robustness/cleanup improvement, not as a fix for an active security vulnerability. It does not appear to introduce obvious new attack surface, but it touches low-level socket and SSL code where bugs could in principle create crashes or race conditions.

This commit adds two safety checks to Monero's command-line wallet for multisignature (multisig) setup commands. One prevents converting a wallet to multisig while a background sync is running, and the other prevents certain idle/background tasks from running during the key-exchange step. These are hardening fixes that reduce the chance of wallet state corruption or unsafe key handling, but the commit itself does not describe a specific exploit or known attack.

This commit only changes a user-facing error message in the Monero command-line wallet. When the wallet cannot connect to the daemon, the message now tells the user whether they should be looking for a mainnet, testnet, or stagenet daemon. There is no security issue here.

This commit tweaks how Monero's built-in background miner decides how long to rest between attempts. Previously the miner was forced to sleep at least 5 milliseconds; now it can sleep zero milliseconds. This is a small behavior change in a non-default, local-only feature and does not appear to be a security fix or vulnerability on its own.

This change only improves an error message shown in Monero's command-line wallet when a refresh fails. If the wallet uses a hardware device (like a Ledger or Trezor) and refresh fails unexpectedly, it now tells the user to check the device connection and run a reconnect command. There is no code fix for an underlying bug and no security vulnerability is apparent.

This commit mostly turns on extra compiler warnings and fixes the code that those warnings flagged. The one behavior change is in wallet signature verification: both 'SigV1' and 'SigV2' signatures are now parsed using the same 5-character header length. That is a minor logic simplification, not a clear security fix. The rest of the changes are cleanup to prevent compiler warnings about missing 'fallthrough' annotations and hidden base-class methods.

This commit updates Monero's networking code to use modern C++14 move semantics for asynchronous callbacks. The changes make callback passing more efficient and avoid unnecessary copies, but they do not appear to fix any active security vulnerability. It is primarily a code modernization and robustness improvement.

This change caps how much data Monero's blockchain code pre-loads into a temporary memory cache when processing incoming blocks. Before, the cache could grow very large if a batch contained many transaction offsets, increasing memory use and potentially causing nodes to slow down or run out of memory. The patch limits the cache to roughly 100 MB and falls back to reading from the database when the limit is reached. It is a hardening/resource-management fix, not a clear-cut exploit patch.

This patch adds two calls to wait for background worker threads to finish before handling certain refresh errors in the Monero wallet. Without these waits, the wallet could read or modify shared data while background threads are still running, causing a 'data race.' Data races can lead to crashes, corrupted wallet state, or unpredictable behavior during synchronization. The patch is small and clearly aimed at making error handling safer, but it does not by itself prove that an attacker can reliably exploit the race from the outside.

This patch fixes shutdown and wallet-replacement bugs in Monero's wallet RPC server. Previously, a long-running blockchain refresh could block the server from exiting, and signal handlers or background threads could try to stop or delete a wallet that was already being swapped or destroyed, leading to crashes or use-after-free memory corruption. The change adds a dedicated 'stop refresh' path, a 'shutdown' state, and guards around wallet replacement so teardown waits for in-flight refresh-stop calls to finish first.