Monero

This Monero code change fixes how the /get_blocks.bin RPC endpoint limits the size of transaction-pool data it returns. Previously, the code reused a P2P Levin packet-size constant that does not apply to HTTP RPC responses, and it tried to budget pool data against the size of the block data already sent. The patch removes that size-budget plumbing and instead caps the number of added pool transactions at a fixed maximum (20,000). This is a correctness fix for response-size limiting, but it also removes a cumulative byte-size cap that could, in edge cases, allow very large individual transactions to make responses bigger than intended.

This commit adds a safety check in Monero's wallet code to prevent a crash or undefined behavior when the wallet tries to select decoy transaction outputs but finds none in the expected time window. It also fixes a related unit test that was not correctly simulating a blockchain with only one output. The change is defensive and improves robustness, but the commit message does not describe it as a security fix.

This is a tiny cosmetic fix in Monero's command-line wallet. It removes a stray colon and space from a prompt asking the user whether to enable background mining. The change does not affect security, user funds, cryptography, network behavior, or how user input is interpreted.

This commit fixes a bug in Monero's wallet programming interface (wallet_api). When a wallet was restored from a recovery seed or from private keys, the internal copy of the wallet password was not being saved. As a result, operations that later needed the password—such as saving the wallet to disk—could fail or behave incorrectly. The patch simply records the password in those three recovery code paths and adds tests to confirm that a recovered wallet can be saved and reopened with the same password.

This commit changes how Monero reads 64-bit chunks from cryptographic hashes during difficulty checks. Previously the code cast a byte array directly to a uint64_t pointer, which can violate strict aliasing rules and cause unaligned or misread memory on some platforms. The new code copies the bytes with memcpy first, then converts endianness. This is a correctness and portability fix; it likely prevents subtle consensus bugs where different nodes might interpret a hash's numeric value differently, but the commit itself does not describe any active security incident or exploit.

This commit only changes two error log messages in Monero's blockchain code. It removes the phrase 'dropping connection' from messages that are printed when a peer sends an invalid chain request. The actual behavior—returning false and not dropping the connection—was already in place; the logs were simply inaccurate. There is no security fix here.

This change fixes a bug in how Monero wallet software reads payment web links (URIs). Before the fix, if a payment link did not specify an amount, description, or other optional fields, the wallet could accidentally keep leftover values from a previous parse. That could mislead the user into sending the wrong amount or seeing wrong payment details. The patch now clears those fields right after confirming the address is valid, and adds a test to prove it.

This commit fixes the 'donate' command in Monero's command-line wallet. Previously, the command accepted an optional extra argument (an obsolete payment ID) and its argument-count check allowed up to 5 items. The code then tried to read the last item as an amount after optionally popping the payment ID, which could lead to reading from an empty argument list or misinterpreting arguments. The patch removes the obsolete payment ID handling and tightens the argument limit to 4, preventing the out-of-bounds or misdirected read. There is no evidence in the commit that this was exploitable for code execution or theft; it appears to be a defensive correctness fix.

This commit changes the Monero daemon's OpenRC service script so that it now requires ('needs') a working network and uses DNS, rather than merely starting after the network service. This is a service-dependency hardening fix: it helps ensure the Monero daemon does not start without network connectivity, which could prevent misbehavior or partial startup failures. It is not a code vulnerability fix and does not directly allow an attacker to exploit the daemon.

This change tightens security for Monero wallet users who connect to a daemon through a proxy (such as Tor or I2P). Previously, when a proxy was used, the wallet did not require users to supply a way to verify the daemon's SSL certificate. That could let a malicious exit node or proxy operator impersonate the daemon and steal wallet data or funds. The patch now requires strong verification (a known certificate, fingerprint, or an onion/i2p address) whenever a proxy or SSL is used.

This change makes the Monero wallet RPC server refuse to start if its SSL/TLS-related settings are incomplete or invalid. Previously, the server may have started anyway when only a wallet directory was supplied, potentially leaving the RPC interface in an unintended security state. The fix validates the configuration early by running a dummy wallet creation check before proceeding.

This commit adds new cryptographic code to Monero that converts points on the Ed25519 curve into Weierstraß (short Weierstrass) form. It introduces helper functions, new curve constants, and unit tests, but does not appear to fix any known vulnerability. The change is a feature addition for the FCMP++ (Full Chain Membership Proofs) work. There is no direct evidence in the commit or supplied references that this patch addresses a security bug, but any new elliptic-curve conversion code carries implementation-risk that could affect correctness or side-channel resistance if used incorrectly.

This commit fixes the way Monero's internal JSON serializer handles special low-value characters (control characters). Previously, characters such as vertical tab and other invisible control characters were either escaped in non-standard ways or left unescaped, which could produce JSON that violates the official JSON standard (RFC 8259). Invalid JSON can confuse other programs that read Monero's output, and in the worst case could be abused to alter how data is parsed or to inject unexpected content. The patch now correctly escapes all control characters and adds tests to prove it.

This commit adds a new cryptographic safety check for Monero's upcoming FCMP++ (Full Chain Membership Proof) system. It makes sure that certain elliptic-curve points used in transactions are free of small 'torsion' components—mathematical artifacts that can be exploited in some zero-knowledge proof attacks. The patch introduces helper functions to clear torsion and a new validation routine, plus tests. It does not by itself fix a known exploitable bug in live code; it is a defensive hardening measure for a feature that is still being integrated.

This commit fixes a bug in Monero's wallet software where exporting 'key images' (cryptographic proofs that help verify account balances without exposing private keys) could use an outdated cached value instead of the freshly generated correct one. The change ensures the wallet always exports the newly generated key image, and adds a test to confirm this behavior. If the wrong key image were exported, a wallet relying on it could fail to prove ownership of funds correctly, potentially causing accounting errors or denial of service in balance verification.

This commit changes how Monero's wallet code copies sensitive cryptographic data (secret keys, transaction hashes, payment IDs) from one memory location to another. Previously it used direct pointer casting, which can violate strict type alignment rules and may cause undefined behavior on some platforms. The patch replaces those casts with explicit memory copies (memcpy). This is a defensive hardening change: it reduces the risk of crashes or misaligned memory reads, but the commit itself does not claim to fix an active exploit or known vulnerability.

This commit narrows a long-standing special-case workaround for Monero block 202612. Previously, any new blockchain fork would have inherited a hard-coded proof-of-work hash at that exact height, which could stop nodes from syncing or miners from producing valid blocks if the network's difficulty was higher than the fixed value. The change now applies the workaround only to the known historical mainnet, testnet, and stagenet blocks, so new or private chains compute proof of work normally.

This commit fixes a race condition in Monero's block synchronization code. When multiple threads check which blocks are missing and write newly received blocks to the database at the same time, one thread can read an outdated database height and wrongly conclude that a block is missing. The patch adds a new mutex to synchronize these checks, reducing false 'missing span' reports that could slow or disrupt syncing. The commit message and comments do not frame this as a security vulnerability, but as a correctness/robustness fix.

This commit fixes three test-only issues that caused unit tests to fail on Windows. It ensures test data files keep consistent line endings so their cryptographic hashes match, lets a test briefly release a file lock so it can read a wallet keys file on Windows, and avoids a minor undefined-behavior case when checking whether characters are printable. None of these changes affect the Monero wallet or node code that users rely on; they only make the test suite more reliable.

This commit removes an old, unused way of representing Monero wallet addresses. The old format used a simple checksum that added up bytes, which is weaker than modern formats. The change deletes the legacy parser and the test that checked it still worked. There is no direct evidence this was exploitable, but removing weak legacy code reduces future risk.

This commit removes leftover code that was only used when building Monero with Microsoft Visual C++ (MSVC). It deletes special-case build rules, compiler-specific macros, and Windows-only helper code. There is no change to how Monero handles money, keys, network messages, or cryptography on supported platforms. It is a cleanup change, not a security fix.

This patch fixes a bug in how Monero nodes remember whether they have shared new transactions with peers. If a node received a transaction but shut down before it could broadcast it, the node would previously never try again after restarting, so the transaction could sit forgotten in the node's memory pool. The fix makes the node re-broadcast such unshared transactions during its normal cleanup loop. It also fixes a related timing issue for privacy-preserving 'stem' transactions so they are not permanently blocked from re-broadcasting.

This commit refactors how Monero converts byte strings into elliptic-curve field elements and adds a helper function to 'reduce' oversized field elements back into a safe range. The change is defensive: it separates the low-level byte-to-field conversion from the point-decompression logic and introduces a normalization routine so that outputs of addition/subtraction can safely be reused as inputs to further additions/subtractions. There is no direct evidence in the commit message or diff of an exploitable vulnerability, but the new helper addresses a known class of subtle correctness issues in Curve25519-style field arithmetic.

This commit adds a faster way to compute many mathematical inverses at once in Monero's cryptography code, plus helper functions and tests. It is a performance and code-organization change, not a security fix or vulnerability. There is no evidence in the commit or supplied references that it addresses a security issue.

This commit updates Monero's built-in blockchain checkpoints to match the v0.18.5.1 release. Checkpoints are hard-coded reference points that help nodes quickly verify they are following the correct chain and protect against certain history-rewriting attacks. The README version references are also updated from v0.18.4.1 to v0.18.5.1. There is no code-level vulnerability being patched here; it is a routine network-consistency maintenance update.