Monero

This commit adds a missing lock around a function that estimates transaction fees. Without the lock, multiple threads could read blockchain data while it is being changed, leading to inconsistent or incorrect fee estimates. The fix prevents this 'data race' by ensuring only one thread accesses the relevant data at a time.

This commit changes how Monero's daemon returns blocks when a remote caller asks for pruned (trimmed-down) block data. Previously, pruned responses omitted a hash for the prunable part of each transaction. Now the daemon fetches and returns that prunable hash alongside the pruned transaction blob. This is a protocol/data-integrity improvement, not an obvious remote exploit, but it touches the RPC layer and changes the data structure passed between the database, core, and RPC server.

This commit only changes the wording of four user-facing error messages in Monero's command-line wallet. It corrects grammar and fixes a swapped description of multisig threshold parameters. There is no change to program logic, validation, cryptography, or network behavior, so it has no security impact.

This commit fixes a comparison between a signed and unsigned number in Monero's wallet code that estimates the current blockchain height. Before the fix, mixing signed and unsigned values could lead to incorrect behavior when calculating block height near a future network fork. The patch makes the calculation use only unsigned numbers and keeps the safety check that returns an error if the estimate would go negative. This is a correctness and robustness fix rather than a direct theft-of-funds vulnerability, but bad height estimates could affect transaction creation or fee calculations.

This commit fixes a bug in Monero's JSON parser where it used the standard C 'isalpha' function to decide if a value looks like a keyword such as 'true', 'false', or 'null'. On some systems, passing a negative number (which can happen when the input contains high-byte non-ASCII characters like certain UTF-8 bytes) to the standard 'isalpha' can cause undefined behavior or be misclassified as alphabetic. The patch replaces the unsafe call with a custom byte-safe version that only looks at the raw byte value. A new test confirms that a value starting with a non-ASCII byte is now rejected instead of being treated as a keyword.

This patch changes how Monero's wallet handles multisig transactions. In a multisig wallet, several people must cooperate to sign a transaction. The patch makes sure that sensitive one-time secret values (called 'nonces') are wiped from the wallet's memory and saved to disk *before* the partially-signed transaction file is handed back to the user. Previously, the wallet could return the signed transaction file while still keeping those secret values in memory. If the wallet later crashed or was used again without saving, those secret values might be reused or leaked, which could weaken the security of the multisig scheme and, in the worst case, allow an attacker to recover private key material or forge signatures.

This commit fixes how Monero's JSON parser handles special Unicode escape sequences called UTF-16 surrogate pairs. Previously, the parser treated each half of a surrogate pair as a separate character, which could produce invalid UTF-8 output or fail to decode characters outside the basic multilingual plane correctly. The patch now combines the two halves into the correct single Unicode character and rejects malformed or lone surrogates. This is a correctness fix in JSON string parsing; it does not appear to be a critical security vulnerability on its own, but malformed Unicode handling can sometimes lead to downstream issues in systems that process the parsed strings.

This commit fixes a spelling mistake in an error message. The phrase 'bounds of of hashchain' is corrected to 'bounds of hashchain'. There is no change to program logic, behavior, or security.

This commit fixes a bug in Monero's built-in miner where mining thread #0 was accidentally running in a slower, more secure mode meant for non-mining code. The fix makes all mining threads run with the faster miner-optimized mode. It is a performance bug, not a security vulnerability, and it only affects users who actively use the built-in miner.

This commit is a massive initial import or merge of the entire Monero repository, adding 1,300 files including source code, build scripts, CI workflows, documentation, tests, and submodules. The only actual code change described in the commit message is a tiny addition of a helper function `sc_1()` in the crypto module. There is no indication this is a security patch or fixes any vulnerability.

This commit fixes a C programming rule violation called 'strict aliasing' in Monero's AES encryption helper code. Previously, the code treated a byte buffer as if it were an array of 32-bit integers by casting the pointer directly. The patch copies the bytes into a properly typed local array first. This is a correctness and portability fix; under aggressive compiler optimization, the old code could theoretically produce wrong encryption results or expose subtle bugs, but there is no direct evidence it was exploitable as a security vulnerability.

This commit changes how the Monero wallet RPC server reads certain fixed-size cryptographic identifiers (payment IDs and transaction IDs) from user-supplied blobs. It replaces direct pointer casting with explicit memory copying. The main practical effect is avoiding undefined behavior when the input buffer is not properly aligned for the target type, which could in theory cause crashes or misbehavior on strict CPU architectures. There is no direct evidence in the commit that this fixes an exploitable security vulnerability.

This commit is a large repository initialization or merge that adds the entire Monero codebase, including build files, CI workflows, documentation, and tests. The commit title mentions unit tests for JSON transaction representation, but the actual diff shows a massive addition of files rather than a focused code change. There is no indication of a security fix or vulnerability being addressed.

This patch fixes a threading bug in Monero's peer-discovery code. The old code launched background threads that wrote into a local variable (`dns_results`) owned by the main function. If the main function finished or the variable went out of scope while a thread was still running, the thread would write to freed memory. That is undefined behavior and could crash the node or, in theory, be abused to corrupt memory. The fix moves the shared data into a heap-allocated structure kept alive with a smart pointer and protects it with a mutex, so threads can finish safely even if the main code no longer waits for them.

This commit changes how Monero's wallet reads cryptographic data from imported files. It replaces direct pointer casts with explicit memory copying (memcpy). This is a defensive coding fix that primarily addresses alignment and strict-aliasing issues, which can cause crashes or undefined behavior on some platforms. It is not a clear-cut remote exploit fix, but it removes a class of low-level memory-safety risks when loading wallet-related import data.

This is a one-line bug fix in Monero's embedded HTTP protocol handler. The code was accidentally passing the major HTTP version number twice to a parsing function, instead of passing both the major and minor version numbers. The fix makes the parser receive the correct minor version number. This is clearly a bug, but from the diff alone it is hard to tell whether it has any practical security consequence.

This change makes Monero's Ledger hardware wallet integration ask for the private view key only when it is first needed, rather than immediately when connecting. If the user refuses, the software no longer fails and can continue in a slower mode where the Ledger does more cryptographic work. The change also clears the cached view key from memory when disconnecting. It is a usability improvement, not a fix for an active security flaw.

This commit fixes a bug where Monero's transaction creation code did not check whether a hardware wallet device successfully generated the one-time public key and view tag for a transaction output. If the hardware device call failed, the code would continue using uninitialized cryptographic values, which could lead to creating an invalid or insecure transaction. The fix adds an explicit error check that aborts transaction creation if the key generation fails.

This commit is a defensive code cleanup in Monero's transaction verification system. It restructures how a temporary list of extra block transactions (the 'pool supplement') is handled so that callers cannot accidentally forget to mark the list as unverified when adding new transactions. Before, outside code directly inserted transactions and separately reset a verification flag, which created a risk that someone could add a transaction without resetting the flag and potentially use a stale 'already verified' status. Now, adding or clearing transactions automatically resets the flag, and only the dedicated verification function can set it to a valid version. There is no direct evidence in the commit of an actual exploit or bug being fixed, but the change removes a fragile pattern that could lead to consensus or security issues.

This commit fixes a bug in Monero's blockchain code where a node could accidentally report the wrong block size (weight) to a peer. The bug happened because the code used a mismatched index when some requested blocks were missing. A peer receiving the wrong weight might ban the node, hurting network connectivity. The fix also removes an unnecessary database lookup.

This commit fixes a bug in Monero's wallet RPC server where editing an address book entry could accidentally drop or mishandle the payment ID associated with an integrated address. The fix ensures the payment ID flag is preserved correctly, and new tests check that converting between integrated and standard addresses works as expected. In practical terms, this could have caused users to send funds without the intended payment identifier, making transactions harder to track or reconcile.

This commit removes source-code file names and line numbers from Monero's translation files. It is a routine cleanup to make translation updates smaller and less noisy. There is no change to program logic, no bug fix, and no security improvement or regression.

This commit fixes a use-after-free bug in Monero's transaction pool (tx_pool). The code was storing a reference to a transaction ID, then deleting the underlying data structure that held that ID, and later still using the now-stale reference. The fix simply copies the ID value instead of holding a reference, so it remains valid after deletion. This is a memory-safety bug that could cause crashes or, in the worst case, be exploited to manipulate transaction processing, though the commit itself does not describe any exploit.

This commit adds a new --wallet-dir command-line option to the Monero command-line wallet (monero-wallet-cli). It lets users specify a single directory where wallet files should be looked for and saved. The change is a convenience/usability feature and does not appear to fix a security bug or introduce a dangerous capability. The code only accepts absolute paths for the directory and ignores the option if an absolute wallet-file path is given, which reduces the chance of tricking the wallet into writing files somewhere unexpected.

This change makes Monero's network address handling for Tor and I2P more consistent by converting hostnames to lowercase when they are read from stored or received data. Before this fix, an address like 'EXAMPLE.onion' written in capital letters would be treated differently from 'example.onion', which could cause mismatches, failed connections, or possibly bypass security checks that rely on exact string comparison. The patch adds a normalization step during deserialization and includes tests to confirm it works.