Monero

This commit changes how Monero hashes certain internal data types. Previously, some types were hashed using a simple identity function that directly used raw bytes as the hash value, which can cause many items to land in the same hash-table bucket and potentially leak information through timing or collision patterns. The patch replaces that with SipHash-2-4, a keyed, cryptographically designed hash function, using a secret random key generated at startup. This is a defensive hardening change; the commit message frames it only as a performance/distribution optimization, not as a security fix.

This is a small user-experience fix for the Monero wallet's auto-refresh feature. When a user turns on auto-refresh, the wallet will now refresh on the next idle tick instead of waiting a full period first. There is no security bug being fixed here based on the commit content.

This commit adds three new cryptographic generator points (named T, U, and V) to Monero's code. These are special numbers used in a new privacy feature called FCMP++. The commit also adds helper functions to recreate and access these generators. There is no indication of a security bug or vulnerability in this change; it is a straightforward addition of constants needed for future protocol work.

This commit adds a safety check in Monero's wallet code before accessing a list of 'additional derivations' by output index. Previously, if the list was shorter than expected, the code could read past its end (an out-of-bounds read). The patch throws a controlled wallet error instead of crashing or reading invalid memory. The most likely risk is a wallet crash or incorrect output detection when processing malformed or unusual transaction data, rather than direct theft of funds.

This commit adds a safety check in Monero's command-line wallet. When the wallet asks the network node (daemon) for details about certain transaction outputs, it now verifies that the daemon actually returned the same number of results that were requested. Without this check, a malicious or buggy daemon could return fewer (or conceivably different) output records than expected, which might cause the wallet to misread ring member data when displaying or analyzing transactions. The patch is small and defensive; it does not by itself prove an exploitable vulnerability, but it closes a trust boundary gap between the wallet and the daemon.

This patch changes how a Monero wallet waits for background worker threads while scanning incoming blocks. Previously, one shared waiter object was used across three separate multi-threaded stages. Now each stage gets its own waiter, so the wallet correctly waits for each batch of tasks to finish before starting the next stage. The commit title says it fixes 'task lifetime' issues, which suggests the old code could have allowed threads to keep running while later code already read or overwrote their data. That kind of bug can lead to crashes or incorrect wallet balance/transaction detection, but the patch does not by itself prove remote theft of funds is possible.

This commit removes the 'bootstrap mode' feature from the Monero daemon. Bootstrap mode let a not-yet-fully-synced local daemon forward wallet and mining RPC requests to a remote daemon. Removing it means wallets and miners now only get data from the local daemon. This is a hardening change: it shrinks the attack surface by eliminating a feature that could expose users to untrusted remote nodes, but it is not a fix for a specific known exploit.

This commit adds two new math helper functions that convert points between two related elliptic-curve formats used in cryptography (Ed25519 and X25519). It is a pure addition of utility code; there is no bug fix, no change to existing behavior, and no indication it addresses a security flaw. The code includes a safety check that rejects the special 'identity' (zero) point, which is a sensible defensive measure.

This is a one-line build-system change that adds a missing library dependency ('wire') so another component can compile and link correctly. There is no indication it fixes a security vulnerability; it appears to be a routine build fix.

This update adds safety checks to the Monero wallet software to detect and stop use of corrupted or tampered wallet cache data. Specifically, it verifies that internal indexes pointing to past transfers are not larger than the actual list of transfers. Without these checks, a damaged or maliciously crafted wallet cache could cause the wallet to read from invalid memory locations, potentially leading to crashes or unpredictable behavior. The change is defensive hardening rather than a fix for an active remote attack.

This commit removes compiler directives that forced certain cryptographic data structures to be packed tightly without padding, and replaces some direct multi-byte memory reads with safer memcpy operations. On some processors, reading a multi-byte value from a memory address that is not aligned to that value's size can cause a crash or reduced performance. The change makes the code safer and more portable across different CPU architectures, but it does not appear to fix an exploitable remote vulnerability in the Monero network itself.

This commit fixes a bug in Monero's wallet API where the recipientAddress() function only returned the first recipient of an unsigned transaction, even when the transaction had multiple recipients. Now it returns all recipients. This is primarily a correctness/functional bug fix. A possible minor security angle is that downstream code relying on recipientAddress() to verify all payment destinations could have been misled into thinking only one recipient existed, but the commit itself does not describe any security impact and no exploit path is evident from the diff.

This commit fixes the way a Monero cryptographic function for ARMv8 processors describes its inline assembly code to the C compiler. Previously, the assembly block did not properly tell the compiler which memory and CPU registers it reads and writes. This can lead to subtle bugs where the compiler optimizes code incorrectly around the assembly, potentially causing wrong hash results or memory corruption on ARMv8 devices. The fix adds proper input/output constraints and a clobber list so the compiler knows exactly what the assembly touches.

This commit adds a type check in Monero's JSON deserialization code. Before the fix, when reading a RingCT signature from JSON, the code assumed the 'prunable' field was a JSON object and accessed it directly. If someone supplied a non-object value (like a number or string), the code could read memory incorrectly or crash. The patch now throws a clear error if the type is wrong.

This commit adds a new internal helper function in Monero's experimental FCMP++ (Forward-Commitment Membership Proof) code. It converts transaction output data into an intermediate mathematical representation called a 'pre-leaf tuple' by computing derivatives of elliptic-curve points. There is no user-facing change, no bug fix, and no security-relevant behavior described in the commit or diff.

This commit adds new code for an upcoming Monero privacy feature called FCMP++. It creates a helper function that converts an output's public key and commitment into a special three-part tuple used by the new system. The commit is defensive in nature: it carefully clears mathematical 'torsion' from points, rejects identity points, and explicitly avoids a subtle double-spend risk that could occur if the wrong version of a key were used around a network upgrade. There is no indication this commit fixes an active bug or vulnerability; it appears to be a building block for future functionality.