rust-bitcoin

This commit is a routine API cleanup for the rust-bitcoin library. It adds a few helper methods (to_signature, from_signature, len, iter) to the ECDSA serialized-signature type and reorders existing methods in the Taproot serialized-signature type so both types look the same. There is no security fix or behavior change that would affect users' funds or data.

This commit is a minor code cleanup. It imports two common Rust traits (`Borrow` and `Deref`) directly at the top of two source files, instead of referring to them with their full `core::...` module path inside the code. There is no functional change, no bug fix, and no security relevance.

This commit is a small internal code reorganization. It moves an existing conversion helper (so a serialized ECDSA signature can be viewed as a script 'push bytes' object) to a more central location, and adds an equivalent helper for Taproot signatures. There is no security fix or behavior change visible to users.

This commit fixes a bug in how serialized Bitcoin signatures expose their byte content. Previously, code asking for the signature bytes could receive the entire internal buffer, including leftover or uninitialized bytes beyond the actual signature length. Now only the valid, used portion is returned. This prevents accidental misuse where someone might hash, encode, or transmit extra garbage bytes as if they were part of the signature.

This commit removes the ability for outside code to directly modify the raw bytes of an ECDSA serialized signature object in the rust-bitcoin library. Previously, callers could obtain a mutable reference to the internal byte buffer and change it, which the developers consider meaningless because a signature is supposed to be a fixed cryptographic result. The change makes the type consistent with the taproot signature type, which already did not allow mutation. It is a hardening/correctness change rather than a fix for a known exploitable vulnerability.

This commit simply reorders existing code in a Rust source file. It moves two blocks of code (implementations of Deref and DerefMut for SerializedSignature) to a different location within the same file so the order matches another module. No code behavior is changed, no bugs are fixed, and no security issue is introduced.

This commit adds standard Rust comparison traits (equality and ordering) to a type that wraps a raw ECDSA signature byte array. It simply lets programmers compare these signature objects more conveniently; it does not change signature validation or introduce a security vulnerability.

This commit adds two new ways to display a taproot serialized signature as hexadecimal text (lowercase and uppercase). It is a pure API-consistency change to make taproot signatures match the existing ecdsa signature API. There is no security issue visible in the diff.

This commit is a straightforward internal code reorganization. It moves the SerializedSignature type from one module to another within the same crate, without changing its behavior or public API. There is no security fix or vulnerability here.

This commit is purely a code cleanup: it moves some trait implementation blocks for the ECDSA SerializedSignature type to a different location in the same file and reorders the Taproot Eq impl to sit next to PartialEq. No logic, behavior, or signatures changed.

This commit only fixes a documentation comment in the source code. It changes the module description from incorrectly saying it contains Taproot keys to correctly saying it contains Taproot signatures. There is no code change and no security impact.

This commit simply reorders two methods inside the same Rust source file so that the taproot signature code matches the layout of the ECDSA signature code. No code behavior, logic, or public API changed. It is a cosmetic cleanup only.

This commit removes a redundant feature flag called 'rand-std' from the rust-bitcoin library and replaces its use with the combination of 'rand' and 'std'. It is a cleanup change to make feature selection clearer for users. There is no security vulnerability or bug fix in the code itself.

This commit is a large API refactoring in the rust-bitcoin library. It removes the need for callers to pass an explicit secp256k1 cryptographic context object to many functions. Instead, the library now uses a global or internally-managed context. The change touches examples, tests, and core modules for addresses, BIP32 key derivation, scripts, PSBT signing, message signing, and Taproot. There is no direct evidence in the commit that this fixes a security vulnerability; it appears to be a usability and maintainability improvement.

This commit is a routine code cleanup that updates rust-bitcoin to match a newer version of the secp256k1 cryptographic library. It only renames function calls (for example, switching from older methods like `secp.sign_ecdsa` to newer standalone functions like `secp256k1::ecdsa::sign`) and does not change any security logic, fix a bug, or alter how secrets are handled.

This commit updates the rust-bitcoin library to use a new beta version of its underlying secp256k1 cryptographic library (0.32.0-beta.2). It is a routine dependency upgrade that adjusts many internal calls to match the new library's simpler API. There is no direct evidence in the commit that this fixes a known security vulnerability, but it does remove an old, separately-patched version of a hashing dependency and moves to a newer cryptographic release. The main risk is that any upgrade of core crypto code could introduce subtle bugs or break downstream users who rely on the old API.

This commit fixes a denial-of-service weakness in how the library reads length-prefixed byte and element lists from untrusted data. Previously, the library would reserve up to 4 million bytes or elements immediately after seeing a length number, even if the actual data never arrived. Now it reserves memory in 1 MB chunks only as data actually comes in, so an attacker must send data to make the program use memory. The commit message and code comments explicitly describe this as a DoS-prevention change.

This commit creates a brand-new, empty placeholder Rust crate named `bitcoin-crypto` inside the rust-bitcoin workspace. It contains no executable code, no cryptographic logic, and no changes to existing crates. The sole purpose is to reserve the package name on crates.io before someone else takes it. There is nothing here that could affect security.

This commit is a routine maintenance patch that updates example code and tests to match a newer version of the underlying secp256k1 cryptography library. It replaces deprecated random-number calls with their modern equivalents and switches to a renamed key-construction function. There is no indication of a security vulnerability being fixed.

This commit updates the underlying cryptographic library (rust-secp256k1) from version 0.30.0 to 0.31.1 and makes the small code changes needed to keep the project compiling. The newer library version may include its own bug fixes, but the commit itself is a routine dependency upgrade rather than a direct fix for a known security flaw in rust-bitcoin.

This commit removes a single empty example file named 'ecdsa-psbt' from the rust-bitcoin repository. The file contained only a blank line and had no executable code, so the change cannot affect software behavior or introduce any security issue.

This commit tightens the security settings on the project's GitHub Actions workflows. Previously, these automated scripts likely ran with broad default permissions that could let a compromised action read or modify code, open pull requests, or access secrets. The change sets the default permission to 'none' and then explicitly grants each workflow only the minimum permissions it actually needs (mostly just reading the repository, with write access only where required). This is a defensive hardening measure rather than a fix for an active attack.

This commit changes the project's GitHub Actions CI workflows so that after checking out the source code, the temporary GitHub authentication token is no longer kept in memory for later steps. This is a defensive hardening change: it reduces the risk that a compromised third-party action or malicious build step could steal the token and modify the repository or release artifacts. It does not fix an active bug in the Bitcoin library code itself.

This commit only changes how GitHub Actions automation is configured. It replaces floating version tags like @v5 with exact commit hashes (plus a comment showing the version). This is a standard hardening practice to prevent a compromised third-party action from silently updating under the same tag. It does not change any of the project's actual Bitcoin/Rust code, so it cannot directly introduce or fix a vulnerability in the library users depend on.

This commit only adds two new unit tests for existing XOnlyPublicKey functions. It does not change any production code, fix bugs, or alter behavior. There is no security issue here.