Monero

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.

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.