rust-bitcoin

This commit adds automatic memory clearing when Bitcoin private key objects are destroyed. It is a defensive hardening change, not a fix for an active vulnerability. The change reduces the chance that secret key material lingers in memory after use, but the commit itself does not claim to fix any known exploit.

This commit removes the automatic byte-by-byte copying trait (Copy) from the PrivateKey type in the rust-bitcoin library. The goal is defensive: secret key material is less likely to be silently duplicated in memory, which can reduce the number of places an attacker or memory-dump tool might find leftover private key bytes. It is a hardening change, not a fix for an active exploit or a specific bug.

This commit removes the automatic 'Copy' trait from two Bitcoin key types that hold secret data (Keypair and TweakedKeypair). In Rust, 'Copy' makes it easy for the compiler to silently duplicate values, which can increase the chances of secret key material being copied around in memory unexpectedly. The change also renames a method from 'to_keypair' to 'into_keypair' and adjusts related code. It is a defensive hardening measure, not a fix for a known active exploit.

This commit only runs an automatic code formatter (rustfmt) across three source files. It changes whitespace, line breaks, and indentation but does not alter any program logic, function behavior, or security properties. There is no security issue here.

This commit only runs an automated code formatter (rustfmt) across three files. It changes whitespace, line breaks, and indentation but does not alter any program logic, function behavior, or security-relevant code paths.

This commit adds a convenience method so that a Bitcoin private key object can directly create an ECDSA signature, instead of forcing callers to reach into the underlying secp256k1 library. It also updates internal code and an example to use the new method. There is no obvious security bug in the change itself, but it slightly changes how nonces are generated for signatures: the new helper uses a 'low-R' nonce-grinding scheme, whereas the previous PSBT code used the default signing path. That is generally a compatibility improvement, not a vulnerability, but it is a behavior change worth noting.

This commit only changes a test file. It removes some test assertions that compared the library's PSBT output against fixed BIP-174 test vectors, because the project is switching to a different default signature style (low_r) that produces different but still valid signatures. No production code is changed, and no security vulnerability is introduced or fixed.

This commit only runs an automatic code formatter (rustfmt) across three source files. It changes whitespace, line breaks, and indentation but does not alter any program logic, function behavior, or security properties. There is no security issue here.

This commit only updates documentation comments in three Rust source files to add clickable cross-references (rustdoc links). No executable code, logic, or behavior was changed. It cannot affect security.

This commit is purely a code-formatting change. It rewraps a long `#[deprecated(...)]` attribute in a Rust source file onto multiple lines so it complies with the project's style rules. No logic, behavior, or security properties of the code were changed.

This is a tiny internal code cleanup that changes how a compressed Bitcoin public key is printed as text. It swaps one standard way of turning bytes into hex for another equivalent way. There is no security issue here.

This commit adds convenience conversion methods so that a CompressedPublicKey can be created directly from a secp256k1 public key or a keypair, matching the existing abilities of the regular PublicKey type. It is a routine API usability improvement with no apparent security relevance.

This commit adds a new convenience method called force_compressed to the PublicKey type in the rust-bitcoin library. It lets callers convert a public key into a compressed public key without handling a possible failure case. The change is purely additive (8 new lines, no deletions) and does not alter existing behavior or fix any bug. There is no indication of a security issue in the commit or supplied references.

This is a routine API cleanup, not a security fix. The developers renamed a function from from_slice to from_bytes on CompressedPublicKey so the name better matches that it now accepts a fixed 33-byte array. The old from_slice is kept but marked deprecated, and internally it now checks the slice length before delegating. No vulnerability is described or fixed.

This commit only adds a new automated test for an existing function called hash_64_many. It does not change any production code, fix a bug, or alter behavior. There is no security issue here.

This commit is purely a code formatting cleanup. It removes blank lines, reorders some import/module declarations, and collapses a few trivial function bodies onto one line. There are no functional changes to how the software behaves, and no security implications.

This commit simply moves an existing SHA256 midstate-to-engine conversion from one place in the code to another. The actual logic is unchanged; it is a code-organization refactor following a Rust API design guideline. There is no security fix or vulnerability here.

This commit is a routine API refactor in the rust-bitcoin library. It changes the message-signing function so it accepts a higher-level PrivateKey reference instead of a low-level secp256k1 secret key, and moves the underlying signing logic into a new PrivateKey method. There is no indication this fixes a security bug; it is a design cleanup to hide internal cryptographic types from users and prepare for future API changes.

This commit is a routine maintenance update to the project's automated testing setup. It upgrades an internal tool called cargo-rbmt and moves its configuration from separate files into each crate's Cargo.toml package metadata. It also changes how nightly and stable Rust compiler versions are tracked, storing them in the workspace Cargo.toml instead of separate version files. There are no changes to the actual Bitcoin library code that users depend on, and no security-relevant behavior is modified.

This commit simply changes an existing internal helper function to be publicly usable and adds documentation and examples. It does not fix a bug, change behavior, or introduce any new security-sensitive logic. The function already existed and behaved the same way; only its visibility changed from private to public.

This commit only adds new automated tests that check whether Bitcoin-style cryptographic keys can be converted to and from the underlying secp256k1 library's key types. It does not change any production code, fix a bug, or alter behavior. There is no security issue here.

This commit adds a new helper method, to_secret_bytes, to the PrivateKey type in the rust-bitcoin library. It returns a private key as a fixed 32-byte array instead of a variable-length vector. The existing to_secret_vec method is rewritten to use the new helper. There is no visible security fix or behavior change; it is a routine API convenience addition.

This commit adds two new helper methods, serialize_compressed and serialize_uncompressed, to the bitcoin::PublicKey type. Previously, users had to reach into the underlying secp256k1 library to serialize a public key. The change simply wraps that existing behavior in a more convenient API and updates internal callers to use the new methods. There is no indication of a security bug being fixed.

This commit adds a new performance-oriented function for computing many double-SHA256 hashes at once, with a special two-at-a-time path for ARM CPUs that support SHA2 hardware instructions. It also exposes that function as a new public API. There is nothing in the diff that fixes a bug, checks bounds incorrectly, or introduces an obvious security flaw; it appears to be a routine optimization and API addition.

This commit is a performance optimization for SHA256 double hashing on 64-bit ARM processors. It rewrites a single-hash ARM hardware-accelerated routine to compute two independent hashes at the same time, filling otherwise wasted CPU cycles. There is no security bug being fixed and no new attack surface introduced; it is purely a speed improvement.