Monero

This commit changes only the spacing in a command-line prompt message, removing one extra space before the '[y/N]' confirmation prompt. It has no security relevance.

This commit only renames two CSV column headers in the Monero wallet's export_transfers output from 'amount' to 'transaction amount' and 'destination amount' to make them less confusing. No numbers, logic, or behavior changed.

This commit adds a new wallet API function that exposes more details when verifying a signed message, such as which key was used and which signature version was detected. It does not change existing behavior; the old simple true/false check still works exactly as before. There is no indication this fixes a security bug or introduces a vulnerability.

This fix corrects a Monero wallet bug where a user could generate a cryptographic 'reserve proof' claiming they still owned money that they had already committed to spending. Before the patch, the wallet only excluded outputs from the proof once the spending transaction was confirmed on the blockchain. Because the wallet marks outputs as spent earlier—when the transaction is first submitted to the network—a user could honestly but incorrectly prove reserve over outputs that would disappear as soon as the pending send confirmed. The patch makes the wallet treat pending-spent outputs as unavailable and checks the exact outputs selected for the proof rather than a broader balance figure that could include pending change.

This commit fixes a typo in two user-facing error messages, changing 'LDMB' to 'LMDB'. It does not change any program logic, database handling, or security behavior.

This is a tiny user-interface wording change in Monero's command-line wallet. It changes when and how a 'suggested threshold' of confirmations is shown to the user when viewing a transfer. Previously, the threshold was shown whenever it was greater than zero. Now, it is only shown when the actual number of confirmations is still below that threshold. Once the threshold is reached, the extra text is hidden. This is a cosmetic change, not a security fix.

This change fixes a CSV export bug in Monero's command-line wallet. User-written notes attached to transfers were written into the export file without surrounding quotes, while other fields were quoted. If a note contained a comma, the exported CSV would have extra columns, and if it contained a quote, the file could become malformed. This is a data-integrity/formatting fix rather than a code-execution vulnerability, but it could mislead users or break import into spreadsheet software.

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

This commit fixes a display bug in Monero's command-line wallet. When showing details of a transfer, the number of 'confirmations' was previously calculated using the wrong block height (the spendable-unlock height instead of the transaction's own block height). This could mislead users about how deeply confirmed a transaction was, especially if the transaction had an unusual unlock time. There is no direct evidence this affects funds safety or can be exploited by an attacker.

This commit removes user-controlled JSON content from error and log messages in Monero's epee networking/serialization library. Previously, when the JSON parser failed, it would copy parts of the raw request into log files or error strings. A malicious user could craft JSON containing fake log entries, terminal escape sequences, or misleading text, which might then be written to logs or shown to administrators. The fix replaces those messages with fixed, safe descriptions and escapes any exception text before logging it.

This change only touches Monero's internal test code. It makes sure automated wallet tests stop background refresh threads before closing the wallet, likely to prevent flaky or crashing tests. There is no indication this fixes a security vulnerability in the actual Monero wallet software that end users run.

This Monero wallet RPC patch changes how transaction hashes are reported for incoming transfers that the wallet does not know the source transaction for. Previously, the RPC would return a string of all-zero characters ('0000...0000') as the transaction hash. After the patch, it returns an empty string instead. This is a correctness and API-clarity fix rather than a direct exploit, but returning a fake all-zero hash could have misled downstream software into treating an unknown transfer as a known one.

This commit fixes a thread-safety bug in the Monero wallet. A function that reads the daemon's network address (get_daemon_address) was accessing shared data without holding a lock, while other parts of the code can change that same data under a mutex. The fix adds the missing lock and makes the mutex 'mutable' so it can be locked even in functions that promise not to modify anything. In practice this could lead to race conditions such as reading a partially updated or inconsistent daemon address, which might cause the wallet to connect to the wrong node or behave unpredictably. There is no direct evidence in the commit of an exploitable security outcome such as remote code execution or theft of funds.

This patch fixes two data races in Monero's asynchronous Levin network protocol handler. A data race happens when multiple threads access the same memory at the same time without proper locking, which can cause crashes, hangs, or corrupted state. The fix adds a mutex around shared callback/timer state and removes a separate 'cancel_timer' virtual method that was being called from multiple threads without synchronization. The commit title explicitly calls these 'data races'.

This change fixes a small user-experience bug in Monero's command-line wallet. Previously, if the wallet locked itself after a period of inactivity and the user tried to close it (for example by pressing Ctrl-C while being asked for the password), the program would keep looping and asking for the password, making it hard to exit. Now, when the password prompt is interrupted, the wallet closes cleanly instead.

This change alters how the Monero wallet picks transaction fees when its automatic fee-estimation helper runs into problems. Previously, if the helper failed or got bad data, it returned whatever priority the caller had requested—potentially a high or urgent priority. Now it falls back to the lowest priority ('Unimportant'). This could mean users' transactions get delayed rather than overpaying, and it reduces the chance that an attacker who can feed bad blockchain data to the wallet can trick it into paying inflated fees. It is a defensive hardening fix, not a clear-cut remote exploit.

This change makes the Monero command-line wallet more forgiving when a user provides a restore date but the wallet cannot reach the network daemon to convert that date into a blockchain height. Previously the wallet would quit with an error; now it prints a warning and continues using a default restore height. This is primarily a usability improvement, but it slightly increases the risk that a restored wallet might scan from the wrong (too recent or too old) block height, potentially missing transactions or scanning more than intended until the user manually corrects it.