Monero

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 commit is a small performance and code-quality change. It changes several functions that return copies of fixed cryptographic 'generator' values so that they return constant references instead. This avoids making unnecessary copies of values that never change. There is no security issue visible in the diff itself.

This commit changes three special cryptographic constants—named T, U, and V—used in Monero's upcoming FCMP++ privacy protocol. These constants are like fixed 'reference points' on a mathematical curve that the protocol relies on to prove transactions are valid without revealing who sent what. The old values were apparently copied from an outdated source and were wrong; the new values match the updated reference implementation. If the wrong constants had gone live, Monero's privacy proofs could have been broken or forged, potentially allowing someone to create fake coins or trace transactions. The commit itself only updates the byte strings and their sanity-check first bytes; it does not explain how the error was discovered or whether any real funds were at risk.

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.

This commit tightens how the Monero software reads incoming HTTP requests by only accepting method names like GET and POST when written in uppercase. Previously, lowercase or mixed-case versions such as 'get' or 'Post' were also accepted. The change makes the parser follow the HTTP standard more strictly, which can help block unusual requests that might be used to bypass security checks or confuse proxies and firewalls.

This patch fixes a crash in Monero's command-line wallet (simplewallet) when a user runs a 'sweep' command without providing a destination address. Before the fix, the wallet would try to read from an empty list of arguments, likely causing it to crash. The fix adds a simple check: if no address is given, it prints an error and shows usage instructions instead of crashing. This is a reliability bug, not a security vulnerability that allows theft or remote compromise.

This is a tiny Python 2-to-3 compatibility fix in a test helper script. It changes an outdated way of joining a list of strings into a modern one. The script only prints a help message listing available tests, so the change has no security relevance and does not affect the Monero wallet, daemon, or any user funds.

This Monero commit adds an optional size check to transaction parsing functions so that oversized transaction blobs from untrusted network sources are rejected before being decoded. It is a defensive hardening change that consolidates existing size checks and extends them to more code paths, reducing the chance that a maliciously large blob could waste resources or trigger memory-related issues during parsing.

This change fixes a bug in Monero's command-line wallet (simplewallet) where a user typing 'index=' in the wrong position of a 'sweep' command could be silently ignored. Previously, the wallet only checked the very first word for 'index='; if it appeared later, the wallet would act as if no subaddress index was specified, potentially sweeping funds from unintended addresses. The fix scans all words for 'index=' and removes it when found. This is primarily a usability/transaction-safety bug rather than a remote-exploitable vulnerability.

This is a build-system patch that lets the Rust part of Monero compile correctly when targeting Linux systems that use the lightweight 'musl' C library (common in Docker containers). It adds a check so the build picks the right Rust toolchain variant. There is no indication this changes any runtime behavior, cryptographic logic, or network code.

This commit changes the order in which Monero checks incoming transactions. Instead of running an expensive consensus check first, it now checks cheaper 'no-drop' rules (like whether the transaction pays a valid fee and isn't already known) before doing the heavy validation. This is a performance and resource-usage optimization, likely to reduce denial-of-service risk from spam transactions. A second small change makes the spent-key-image check skip non-standard input types instead of asserting they never occur. The commit message and diff do not describe this as a security fix, and no independent researcher is credited.

This change fixes a bug in Monero's multisig wallet import process. Previously, if importing multisig data failed partway through, the wallet could be left with a mix of old and new internal state, potentially causing confusion or incorrect behavior on the next import attempt. The patch now validates all incoming data in a temporary staging area and only replaces the wallet's live state after everything checks out, keeping things consistent even when something goes wrong.

This patch fixes a bug in Monero's peer-to-peer networking code. Previously, when the software tried to connect to 'seed nodes' (hardcoded first-contact servers that help a node find the network), it ignored the cache of recently-failed addresses. That meant an unreachable or rejecting seed node could be retried over and over again, wasting resources and potentially delaying or preventing a node from successfully joining the Monero network. The fix makes seed-node connections respect a shorter 5-minute 'cooldown' before retrying a failed seed, while normal peer connections keep the existing 1-hour cooldown.

This change stops the Monero command-line wallet's built-in 'donate' command from working on test networks. Previously, the wallet tried to convert the official donation address to a testnet/stagenet equivalent, which could send real-looking donations to an address the user did not expect. Now it simply refuses to donate unless you are on the main Monero network.

This commit adds a new 'change_amount' field to Monero wallet RPC responses that describe transfers. When you send Monero, part of the input often comes back to you as change. Previously, callers of the wallet RPC had to calculate this themselves from other fields; now it is exposed directly. This is a straightforward feature addition, not a security fix or vulnerability.

This commit refactors how Monero checks whether a new block's timestamp is valid. It splits one timestamp-check function into two: a general helper and one specifically for the main chain. The change also moves the 'future time' check (rejecting blocks stamped more than 2 hours ahead of local time) and the 'not enough blocks' check into the general helper, and it makes the median timestamp output optional. The commit appears to be a code-quality and consistency improvement rather than a clear-cut security fix, but it does tighten behavior when there are fewer than 60 prior blocks and removes a const qualifier from one function. Without a vendor statement, we cannot say it fixes a known vulnerability.

This commit simply adds the Rust programming language toolchain to the project's Docker build environment. It is a routine build-infrastructure change with no apparent security relevance.

This change fixes a peer-to-peer networking timeout behavior. Previously, the handshake timeout timer could be reset by incoming partial data, potentially allowing a remote peer to drag out the handshake indefinitely. Now, the handshake timeout is absolute: if it expires, the connection is dropped regardless of partial progress. This prevents a likely denial-of-service vector where a malicious or slow peer stalls handshakes.

This commit only adds the C++ keyword `static` to a single function declaration in a header file. It does not change what the function does, what data it can access, or how users interact with the software. There is no visible security effect.

This patch fixes a type-safety bug in Monero's peer-to-peer networking code. The send() function used to return an integer where -1 meant failure, 0 meant 'connection not found', and 1 meant success. Some callers treated any non-zero value as success, so a -1 failure could be misread as success. The patch changes send() to return a proper true/false boolean so failures cannot be misinterpreted. The commit message explicitly points to make_payload_send_txs as an example of such a caller.