Bitcoin Core

This commit changes how Bitcoin Core's Guix build system obtains a Python cryptography helper library called oscrypto. Previously, Bitcoin Core maintained its own custom package definition and a patch that forced oscrypto to use a specific OpenSSL library path. Now it uses the standard upstream package from the Guix distribution. This is primarily a build-maintenance simplification. It is not a direct fix for a known vulnerability, but it removes a local patch and custom package, which could slightly change what code is compiled into release builds.

This is a code-quality fix for Bitcoin Core's RPC help output. It changes how the documentation generator marks parts of the response as '...' (elided) so that the internal type checker can still verify the real data types. It does not change how transactions are decoded or how the network behaves, and it is not a security patch in the usual sense. The only user-visible change is a slightly clearer help message for the decodepsbt command.

This is a small test-only change in Bitcoin Core's Python testing framework. It moves where an internal networking event loop is created so it is created on the same thread that later runs it, rather than on the main test thread. The goal is to stop an intermittent crash/abort that happens on Windows when running functional tests. It does not change the Bitcoin node itself, consensus rules, wallet handling, or network protocol, and there is no indication it fixes a security vulnerability.

This commit simply removes two unused variables from a single test file. It does not change any production code, network behavior, or security logic. There is no security relevance.

This commit adds a new automated CI (Continuous Integration) test step for macOS releases. After building the macOS app bundle, the script now unzips the produced file and runs Apple's `codesign --verify` to confirm the application is properly code-signed. It does not change any wallet, networking, or consensus code, and it does not fix a security bug in the software itself. It is purely a build/verification improvement.

This change makes Bitcoin Core store sensitive AES encryption/decryption context data in locked, non-swappable memory instead of ordinary memory. The goal is to reduce the chance that encryption keys or key-derived data leak into swap files or core dumps. It is a defensive hardening patch, not a fix for an actively exploitable bug.

This change makes the encryption initialization vector (IV) used by Bitcoin Core's AES-256-CBC routines live in locked, non-swappable memory and be securely erased when no longer needed. Previously the IV was a normal stack-like array, which could potentially be swapped to disk or remain in memory after use. The IV is not a secret key, but it is cryptographic material that should be handled carefully. The patch is a hardening improvement rather than a fix for a known active attack.

This commit is a pure build-system refactor: it moves the file `lockedpool.cpp` from the `kernel` and `util` libraries into the `crypto` library. The change is organizational only and does not alter any code behavior. It is not a security fix and does not introduce a vulnerability.

This commit is a small bug fix in the Bitcoin Core graphical wallet (bitcoin-qt). When a user starts the GUI with an invalid custom network parameter (the -vbparams option), the program used to quit without showing any error message. The fix makes the GUI display the same helpful error message that the command-line daemon already shows, so users know what went wrong.

This commit adds fuzz-testing coverage for whitelist permission settings inside a test harness. It does not change production network code, user-facing behavior, or fix a live vulnerability. It is a test-quality improvement that helps automated fuzzers explore more code paths in CConnman initialization.

This commit adds a new fuzz test to Bitcoin Core that checks whether PSBT (Partially Signed Bitcoin Transaction) data can be serialized and then deserialized back to the exact same bytes. It is a defensive test meant to catch future bugs where the software might write a PSBT format it cannot later read. The commit itself does not fix any active vulnerability; it adds a regression test.

This commit only updates two comments in a test file. It replaces the word 'Appveyor' (an old Windows continuous-integration service) with 'Windows' to reflect that the project no longer uses Appveyor. No actual code behavior changes, and there is no security relevance.

This is a tiny test-only change that adds the server's response text to an error message shown when a Bitcoin Core functional test receives an unexpected non-JSON HTTP response. It only affects the test framework's debugging output and does not change production Bitcoin Core code, network behavior, or security boundaries.

This commit is a pure test-code refactoring. It moves helper functions that let Boost test macros print custom Bitcoin types (like transaction IDs and 256-bit numbers) into a shared test header, and replaces several specific helpers with one generic template. It does not change any production code, network behavior, or wallet logic, and it introduces no security fix or vulnerability.

This commit updates Bitcoin Core's built-in list of network seed nodes—the addresses new wallets use to find peers for the first time. It replaces old, stale addresses with a fresh set of IPv4, IPv6, I2P, and Tor onion-service entries. There is no code change and no indication of a security vulnerability; it is routine network-maintenance data.

This commit fixes a small bug in an internal Bitcoin Core seed-list generator script. When the script saw the same IP address and port more than once, it used to keep whichever entry it encountered last. Now it keeps the one with the most recent successful contact. This makes the generated list of network peers slightly more accurate and reliable, but it is not a security fix for the Bitcoin software itself.

This commit simply updates the list of recognized Bitcoin Core version numbers in a helper script used to generate the network seed list. It is a routine maintenance change with no security relevance.

This commit removes a temporary workaround in Bitcoin Core's automated testing setup that relaxed a security policy for checking the cryptographic signature on LLVM's software repository. The workaround was added because LLVM's signing key still used the older SHA1 hash algorithm, which newer Linux systems began rejecting. Now that LLVM has fixed its key, the workaround is no longer needed and is being removed. This is a cleanup change that restores normal, stricter security checks in the continuous integration (CI) environment. It does not change the Bitcoin Core software that users run.

This commit only changes Bitcoin Core's internal functional test code. It makes the default timeout for a debug-log assertion helper stricter (0 seconds instead of 2 seconds) and updates existing tests to explicitly pass a 2-second timeout where needed. There is no change to the actual Bitcoin node software that users run, so it cannot affect live networks, wallets, or consensus.

This commit is a routine code cleanup in Bitcoin Core's transaction-cluster linearization logic. It removes a helper function called UpdateChunk and copies its logic directly into the two places that used it (Activate and Deactivate). The behavior is intended to stay exactly the same; the change is described by the author as an optimization and preparation for future work. There is no indication of a security fix.

This change is purely cosmetic: it stops Bitcoin Core from repeatedly printing the same router-related warning in the log. Home routers that don't support automatic port mapping now produce one warning instead of many, with later messages hidden behind a debug log level. There is no security vulnerability being fixed and no behavior of the network code is changed.

This commit only changes test-framework helper code. It improves error messages shown when a Bitcoin RPC call fails during automated testing, so developers get more useful diagnostics instead of a blank message. It does not touch the live Bitcoin node software, wallet handling, consensus rules, or network code, so it cannot directly affect real users' funds or node security.

This commit adds a new helper function called CeilDiv that performs ceiling division in a way that avoids integer overflow. It then replaces many existing hand-written ceiling division expressions across the Bitcoin Core codebase with this safer helper. The change is primarily a defensive refactor to prevent a class of subtle overflow bugs, rather than a fix for a known exploitable vulnerability.

This commit fixes a typo in the documentation example for the `send` RPC command. The example was missing a placeholder for the `fee_rate` argument, which caused the example command to be interpreted incorrectly and produce an error if copied exactly. It is a documentation-only change and does not alter any executable code.

This change adjusts how Bitcoin Core builds an internal cryptographic library (libsecp256k1) so that its internal function names are no longer exposed in the final library files. It is a hardening/cleanup change rather than a fix for an active bug or exploit. The commit message frames it as preventing implementation-detail symbols from leaking out of the kernel library, which can reduce attack surface but does not by itself fix a known vulnerability.