btcd

This commit changes how submitted block proposals are decoded in the Bitcoin RPC server. It switches from a loose block parser to a stricter one that validates the block more thoroughly before accepting it. The likely goal is to prevent malformed or invalid block proposals from being processed further, which could otherwise cause incorrect behavior or resource waste.

This commit changes how the 'decoderawtransaction' RPC command reads raw transaction bytes. Previously it used a looser deserialization method that could accept data beyond the end of the transaction. Now it uses a stricter parser that rejects trailing extra bytes. The likely security relevance is preventing malformed or padded transaction blobs from being accepted as valid, which could otherwise mislead wallets, explorers, or downstream services that rely on this RPC output.

This commit only adds a new test to the btcd blockchain package. The test verifies that when the software starts up, it rejects a stored 'best block' whose saved bytes contain extra trailing data after the valid block. It does not change any production code, so by itself it cannot introduce or fix a runtime security issue. It is a regression test that documents expected behavior already enforced elsewhere.

This commit fixes a bug in the MuSig2 multi-signature code where reading a partial signature from an input stream could fail silently. Previously, if the stream ended early or had a read error, the function would return 'no error' as if the signature had been decoded successfully. Now it correctly returns the actual read error. This could have allowed malformed or truncated signatures to be treated as valid, potentially leading to incorrect multi-signature behavior.

This commit only adds new unit tests. It does not change any production code. The tests verify that two helper functions already reject input that contains extra bytes after a valid Bitcoin block or transaction. Because no code behavior is changed, there is no direct security fix here.

This commit tightens how a Bitcoin-related library reads transaction outputs stored inside PSBT (Partially Signed Bitcoin Transaction) data. Previously, the code read the output value and script in a loose, hand-rolled way that ignored extra trailing bytes and misinterpreted the script length byte. The change now uses the project's standard parser and insists every byte is consumed. That removes a class of parsing inconsistencies that could, in theory, let a malformed PSBT slip past validation or be interpreted differently by different software.

This commit only adds a new unit test that checks whether the MuSig2 partial signature decoder correctly rejects empty or too-short inputs. It does not change any production code, so by itself it cannot introduce or fix a security vulnerability. The test may be a regression test for an already-fixed bug, or simply defensive coverage, but the diff provides no evidence of a prior security issue.

This is a one-byte fix in a test file. A test transaction used to exercise the Bloom filter code had an extra trailing zero byte, making it malformed. The change removes that extra byte so the test data is a valid serialized Bitcoin transaction. It does not change any production code, network behavior, or security logic.

This change tightens how base64-encoded PSBT (Partially Signed Bitcoin Transaction) data is decoded. Previously, the decoder could silently ignore extra whitespace or unexpected characters in the base64 stream. Now it rejects anything that isn't strict, clean base64. This is a defensive hardening fix: it prevents malformed or cleverly padded base64 inputs from being accepted, which could in theory be used to sneak invalid data past validation or cause inconsistent parsing between different PSBT implementations.

This change tightens how PSBT (Partially Signed Bitcoin Transaction) files are read. Previously, transaction-valued fields could contain extra bytes after the valid transaction data; now the parser rejects such trailing data. This prevents a malformed or crafted PSBT from sneaking in unused bytes that might confuse downstream tools or alter how the PSBT is interpreted.

This commit only changes Go module configuration so that the main btcd project uses local copies of two of its own sub-packages (btcutil and wire) instead of fetching them from the internet. There is no code behavior change, no bug fix, and no security relevance visible in the diff.

This commit only adds a new test. It checks that the submitblock RPC command rejects block data that has extra trailing bytes after a valid block. The test confirms existing behavior rather than changing production code, so it is unlikely to be a live security fix by itself.

This commit only adds a new test to btcd. The test checks that a specific Bitcoin RPC command, used when miners propose new blocks, correctly rejects block data that has extra junk bytes tacked onto the end. The commit itself does not change the actual production code behavior; it only verifies that the existing rejection works. The test was likely added because a similar trailing-byte bug was fixed elsewhere and the developers wanted to make sure this code path was also protected.

This commit adds a new helper function to the PSBT (Partially Signed Bitcoin Transaction) package that checks whether a data reader still has leftover bytes after parsing. Leftover bytes could mean a malformed or malicious PSBT file was not fully processed. The helper lets the library reject such inputs. However, the commit only adds the helper; it does not yet wire it into any actual parsing path, so by itself it does not fix any vulnerability.

This commit adds a new test to make sure the 'decoderawtransaction' RPC command rejects transaction data that has extra bytes tacked on after a valid transaction. It does not change the actual command behavior; it only adds a test confirming the existing behavior works correctly.

This commit only adds a new test file. It does not change any production code. The test checks that the PSBT parser rejects transaction fields that have extra trailing bytes. Because no actual parser logic is modified, this commit by itself does not fix or introduce a security issue.

This commit only adds a new unit test. It does not change any production code. The test verifies that the sendrawtransaction RPC already rejects transaction hex strings that have extra trailing bytes after a valid transaction. Because no actual behavior of the live software is changed, this patch by itself does not create or fix a security issue.

This commit adds a new test to check that the Bitcoin wire protocol v2 message parser rejects messages containing extra, unexpected trailing bytes. It does not change production code; it only strengthens test coverage for a parsing safety check that already existed for v1 messages.

This commit tightens two helper functions that create Bitcoin block and transaction objects from raw bytes. Previously, extra bytes after a valid block or transaction were silently ignored. Now the functions return an error if any unexpected trailing data remains. This is a defensive correctness fix that can prevent subtle bugs or attacks where extra data is smuggled alongside a valid block or transaction.

This commit adds a check in btcd's Bitcoin network message parser to reject v2 protocol messages that contain leftover, unread data after the expected payload has been decoded. Previously, extra bytes at the end of a message payload were silently ignored. This could allow malformed or padded messages to be accepted, potentially causing inconsistent parsing between btcd and other Bitcoin node software, which in turn could be abused to split the peer-to-peer network or evade message-size limits.

This commit changes how raw transactions submitted to the Bitcoin node via RPC are decoded. It switches from a lenient decoder to a stricter one that validates the transaction more thoroughly before accepting it. The likely effect is to prevent malformed or non-standard transactions from being processed, which could otherwise cause node errors or unexpected behavior.

This commit adds a cleanup step in the function that decodes Bitcoin private keys from Wallet Import Format (WIF). It ensures a temporary mathematical value used to check the key is valid gets wiped from memory right after use, so the private key value does not linger in that temporary variable. This is a defensive memory-hygiene improvement rather than a fix for an active remote attack.

This commit simply changes a version label from 'beta.rc1' to 'beta' in preparation for a final release. It is a routine release-management change with no security relevance.

This commit adds a new client-side method called SubmitPackage to btcd's RPC client. It does not change any server-side code, mempool logic, or consensus rules. It simply lets programs ask a Bitcoin Core node (version 24+) to submit a group of related transactions using an existing Bitcoin Core RPC. There is no obvious security vulnerability in the change itself.

This commit fixes a bug in btcd's test-network synchronization logic. A previous change accidentally allowed light clients (such as Neutrino wallets) to be chosen as sync peers on regtest/simnet. Because light clients advertise a recent block height but cannot actually serve blocks, a node could pick one as its sync peer, stall, disconnect it, then pick another light client and stall again—potentially livelocking synchronization. The fix restores the requirement that sync peers must signal they can serve full blocks, while still allowing any network address on these test networks.