Monero

This commit refactors how Monero's blockchain code builds a lookup table used when checking incoming blocks. It replaces a slower, manual scan through offsets with a sorted binary search, and removes duplicate amount handling. The change appears to be a performance and correctness cleanup rather than a clear security fix, but the old code's linear search and duplicate-amount logic could theoretically hide or mishandle edge cases in block validation.

This commit is a performance optimization in Monero's transaction-processing code. It changes how the node detects duplicate transactions sent by a peer: instead of comparing the entire transaction data (which uses lots of memory), it compares small SHA-256 fingerprints. It also streamlines how those fingerprints are stored. There is no direct evidence this fixes a security bug, but it removes a memory-pressure path and hardens duplicate detection against subtle blob differences.

This commit is a performance optimization in the Monero wallet. It replaces repeated linear list scans with hash-set lookups when checking which transactions are in the memory pool. The change should make wallet refresh faster when there are many pending transactions, but it does not appear to fix a security vulnerability or change behavior in a way that is directly exploitable.

This commit only fixes spelling mistakes in comments, documentation, and user-facing error/log strings. No program logic, calculations, or security behavior was changed. It is not a security fix and cannot be exploited.

This commit removes a leftover wallet callback function that did nothing useful. The callback was called after a transaction record had already been deleted, so the transaction ID it received was technically invalid (a 'dangling reference'). Because the callback had no real implementation and was not exposed through the public wallet API, this appears to be a cleanup of dead code rather than a fix for an actively exploitable bug. The main risk is avoiding undefined behavior if someone later tried to use that invalid reference.

This commit only adds new software tests (fuzz tests) for Monero's CLSAG ring signature verification code. It does not change any production code that handles transactions, wallets, or network data. Fuzz tests feed random or crafted data to a function to check it behaves safely, but the tests themselves are not a vulnerability or a fix. There is no indication this commit addresses a known security bug.

This commit updates a Monero fuzz test that feeds random or crafted data to the wallet's cold-output import code. It only changes test files and test code; no production wallet or node code is modified. The change makes the fuzzer use the newer, safer import path (import_outputs_from_str) and adds a testnet wallet setup. On its own, this is a test-harness cleanup, not a fix for a live security bug.

This small patch changes Monero's peer-to-peer sync logic so that when the node's estimated target blockchain height suddenly drops, it re-enables 'safe sync mode' if the target is now very close to the node's current height. Safe sync mode is a more conservative way of downloading and verifying blocks. The change is defensive: without it, a node might stay in a faster but less safe sync mode even when the network no longer appears to be far ahead, which could make it more vulnerable to a malicious peer manipulating its view of the chain height. The commit message does not call this a security fix, and no independent researcher is credited.

This commit only adds a 'fee' field to two existing wallet error types (not_enough_unlocked_money and not_enough_money). It does not change how transactions are validated, how fees are calculated, or how money is handled. It simply lets the wallet remember and report what fee was involved when an error about insufficient balance occurs. There is no security issue visible in this change.

This commit simply deletes an old, unused test file and its header. The code being removed was entirely commented out since 2014, was never compiled into the test program, and was never run. It has no effect on the live Monero software or its users.

This commit simply deletes an unused header file and removes its leftover include statement. It is a cleanup change with no functional or security effect on the running software.

This commit tightens how Monero's built-in HTTP server reads the 'Content-Length' header. Previously, the server would accept malformed values like '5abc' or '0x10' and silently use only the leading digits as the body length. Now it rejects the whole value unless it is a plain number. This kind of lenient parsing can cause request smuggling or desynchronization between the server and other HTTP components, which attackers can sometimes exploit to bypass security controls or poison caches.

This commit fixes three spelling mistakes in user-facing error messages inside Monero's command-line wallet. There are no code logic changes, no security fixes, and no functional impact.

This commit only changes two CMake build messages from plain 'message(...)' to 'message(STATUS ...)'. That is a cosmetic/logging change: it tells CMake to print these lines as informational status messages instead of bare output. It does not change any compiled code, cryptographic logic, wallet behavior, or security boundary.

This commit replaces a complex regular-expression-based HTTP header parser with a single, stricter, hand-written parser shared between the client and server code. The old parser could silently accept malformed or ambiguous headers, which in HTTP can lead to security problems such as request smuggling, cache poisoning, or unexpected behavior. The new parser rejects headers that do not follow a well-defined format and validates the characters allowed in header names. It also adds many tests that demonstrate malformed headers are now rejected. The commit itself does not describe this as a security fix, but the change clearly reduces attack surface in the way Monero's HTTP stack processes incoming and outgoing headers.

This commit only adds standard copyright and license notice blocks to the top of three wallet source files. It does not change any program logic, data handling, or user-facing behavior, so it has no security impact on the Monero software itself.

This commit changes how Monero reads payment IDs embedded in transaction data. Previously, the code used a type-casting pointer trick to read the bytes; now it uses memcpy, which is the safer, standard way to copy raw bytes. The change is defensive and reduces the risk of subtle memory alignment or aliasing problems, but the commit itself does not claim to fix an active security bug.

This commit fixes a minor crash bug in Monero's wallet code. When the wallet tried to read a transaction data blob that contained only the file-type 'magic' header and nothing else, it would throw an uncaught out-of-range exception instead of cleanly reporting 'bad data.' The patch makes the wallet check that at least one byte follows the magic before reading it, turning the crash into a normal error return.

This commit is a routine cleanup that fixes spelling mistakes and typos across comments, error messages, variable names, and documentation strings. None of the changes alter program logic, data handling, or security behavior. The only file rename (instanciations.cpp → instantiations.cpp) is a spelling correction, and the CMakeLists.txt reference is updated to match. There is no security impact.

This commit fixes a single-word typo in a documentation file, changing 'Bitcoin' to 'Monero' in a sentence describing the dependency build system. It has no effect on program code, behavior, or security.

This commit simply deletes a helper function called power_integral that was not being used anywhere in the code. It is a routine cleanup with no visible security effect.

This commit changes how a Monero wallet reads sensitive key data from a multisig restore string. Previously, the code directly cast a pointer to the data buffer and read keys as if they were already in the correct structure. Now it uses memcpy, which is the safer, standard way to copy raw bytes into typed variables. The main practical concern is avoiding undefined behavior from unaligned or improperly typed memory access, especially for secret key types that may have stricter alignment requirements. It is a hardening fix rather than a clear-cut remote exploit.

This change makes the Monero wallet refuse to build transactions if the list of RingCT output counts it gets from a daemon is not in ascending order. A non-monotonic (out-of-order or decreasing) distribution could indicate a misbehaving or malicious daemon trying to trick the wallet into selecting invalid or non-existent outputs, which might lead to failed transactions or privacy/funds issues. The patch is a defensive check, but it is small and does not by itself prove an active attack is possible.

This commit changes the wallet's command-line argument handling so the program's input arguments are treated as read-only (const). It is a code-quality and type-safety improvement, not a security fix. There is no indication it prevents or fixes any exploit.

This commit fixes several crash bugs and one possible underflow bug in Monero's command-line wallet (simplewallet). Most changes add null-pointer checks before using the wallet object, preventing the program from crashing if a user runs commands before a wallet is loaded. One change prevents a subtraction from going below zero when computing the number of 'fake' transaction outputs. Another change removes an incorrect argument-count check in the device-name command. The commit is described by its author as general safety/correctness fixes, not as a security patch.