Bitcoin Core

This is a code cleanup change that replaces scattered hard-coded byte counts like 1024*1024 with a single named helper, _MiB, and adds unit tests for it. It does not change any user-visible behavior or fix a known security bug. The main safety benefit is making future accidental mistakes (for example, writing the wrong number of zeros) less likely and turning some oversized-value mistakes into compile-time errors.

This commit adds a new code helper for writing byte sizes in gigabytes (GiB) and replaces a few existing hard-coded numbers with the new helper. It is a code cleanup and readability change with no security-relevant behavior change.

This is a small internal code cleanup in Bitcoin Core. It changes one function parameter from a pointer (which could theoretically be null) to a reference (which cannot be null), because the caller always passes a valid object anyway. There is no change to how the program behaves, no bug fixed, and no security issue introduced.

This is a small internal code cleanup in Bitcoin Core. It changes one function, CChain::FindFork(), so that callers must pass a valid block object directly rather than a pointer that might be null. The function previously handled null pointers safely by returning null; now callers must check for null themselves before calling it. The commit adds those checks at every call site. It is a defensive refactoring, not a fix for an active security bug.

This commit tightens up a low-level helper function in Bitcoin Core that finds the next block in the chain. It changes the function so callers must pass a real block object rather than a potentially-null pointer, and it adds a safety check in one place where the previous code could have passed a null pointer. The change is defensive hardening rather than a fix for a confirmed, exploitable bug.

This commit only adds new unit tests for an existing function called CChain::FindFork(). It does not change any production code, so it cannot directly introduce a security vulnerability or fix one. It is a routine test-only change.

This commit hardens a core Bitcoin method called CChain::Contains() so it can no longer be accidentally called with a null (missing) block pointer, which would crash the node. The change turns the method's input from a pointer into a reference, forcing every caller to prove the block exists before calling it. Several call sites were updated, and one place in startup index syncing now explicitly handles a missing block instead of silently passing a null pointer. It is a defensive fix that removes a class of potential null-dereference crashes, but the commit message does not frame it as a critical security vulnerability and no exploit is demonstrated.

This commit only adds new automated unit tests for the CChain class in Bitcoin Core. It does not change any production code, fix bugs, or introduce security-relevant behavior. The tests verify basic chain operations like height, tip, indexing, contains, next, and genesis on empty and two-block chains.

This commit simply moves a debug log message so it prints before the SOCKS5 username/password data is sent over the network, rather than after. It does not change what data is sent, how it is encrypted, or who can read it. The change only helps developers diagnose connection problems by ensuring the log appears at the correct moment.

This commit removes a debug log line that printed SOCKS5 proxy usernames and passwords in plain text. The change prevents sensitive credentials from being written to log files, which could otherwise expose them to anyone with access to those logs. It is a straightforward cleanup with clear security benefit, though it only affects debug-level logging.

This commit only changes a test file. It makes the existing Tor control line-length test more precise by checking that a line exactly at the maximum allowed length does not cause a disconnect, while a line one character over still does. There is no change to Bitcoin Core's actual production code, so it cannot directly affect live node security.

This change fixes a memory safety issue in Bitcoin Core's connection to the Tor control port. A malicious or misbehaving Tor control server could send an endless stream of reply lines, causing Bitcoin Core to keep allocating memory until the system ran out. The patch caps the number of lines accepted in a single reply at 1,000, after which the connection is closed. The commit message explicitly says this is to avoid out-of-memory (OOM) exhaustion.

This commit is a straightforward internal code cleanup in Bitcoin Core's logging system. It replaces a function that modified a string by repeatedly inserting text at the front with a function that builds the same string left-to-right and returns it. There is no security-relevant change here.

This is a small internal code cleanup in Bitcoin Core's logging system. It removes a duplicate log-entry structure and makes sure the real timestamp and the simulated 'mocktime' are recorded at the same instant. There is no indication this fixes a security bug or introduces a vulnerability.

This commit only adds documentation comments to a header file. It explains which integer types the Bitcoin Kernel C API uses for different kinds of values. No code behavior was changed.

This commit only changes a single test file (interface_http.py) in Bitcoin Core. It refactors the test to use one node instead of three, switches some encodings from utf-8 to ascii, makes tests independent, and updates expected HTTP error codes from 400 to 413 for oversized requests. There is no change to production code, no security fix, and no vulnerability being introduced.

This commit is a minor type-cleanup change in Bitcoin Core's internal kernel API. It changes several height-related function parameters and return values from the generic `int` type to the explicitly-sized `int32_t` type. There is no security-relevant behavior change, no bug fix, and no disclosed vulnerability.

This commit adds a new public function to the Bitcoin Core library API that lets callers efficiently look up any ancestor block of a given block by its height. It is a pure feature addition with no security-relevant changes to existing behavior. There is no bug fix, no vulnerability disclosure, and no indication of a security issue.

This commit is a straightforward internal code cleanup in Bitcoin Core's logging system. It bundles log details (timestamp, thread name, message, category, etc.) into a single struct called log::Entry and passes that struct around instead of many separate arguments. There is no security fix or behavior change visible in the diff.

This commit adds two pieces of metadata to each log entry: the time it was created and the name of the thread that created it. It is a straightforward internal logging improvement with no apparent security relevance.

This is a minor code-quality change that adds the C++ keyword 'explicit' to a constructor. It prevents the compiler from silently converting other types into a SourceLocation object, following a common C++ best-practice guideline. There is no security bug being fixed here.

This commit removes an extra linker flag (-lstdc++) from a Bitcoin Core continuous integration (CI) script used only for a memory-sanitizer fuzz-testing build. It is a build-configuration cleanup, not a code change affecting the Bitcoin software users run. There is no security-relevant change to the project's runtime behavior or to shipped binaries.

This commit simply updates the version of the LLVM compiler toolchain used in automated testing from 22.1.0 to 22.1.3. It is a routine maintenance change to the project's continuous integration (CI) setup and does not alter Bitcoin Core's actual code or how it runs for users.

This commit fixes four minor typos and spacing issues in documentation files only. There are no code changes and no security implications.

This commit is a minor cleanup of a Bitcoin Core functional test file. It moves some connection-checking code into a helper method so it is reused by multiple tests, rather than being duplicated in each test. There is no change to the actual Bitcoin Core software that users run, and no security issue is introduced or fixed.