libsecp256k1

This commit is a performance optimization for Bitcoin's secp256k1 cryptographic library. It tells the compiler to always inline (embed directly into calling code) certain low-level multiplication and squaring routines used heavily in elliptic-curve operations. The stated goal is faster signature verification and key agreement, at the cost of slightly larger compiled binaries. There is no security fix or vulnerability indicated in the commit itself.

This commit only changes compiler warning settings inside the project's test code. It turns on a warning for unused functions so the test suite catches dead code. It does not change any actual security logic, cryptography, or runtime behavior of the library.

This commit adds a new unit test to verify that two internal math functions in the secp256k1 library produce matching results. It does not change any production code, cryptographic logic, or fix a bug. It is purely a test addition.

This is a one-line fix in a test file. The original code called a function that checks whether a point is infinity but threw away the result, so the check did nothing. The fix wraps it in a CHECK() macro so the test actually verifies the result. It does not change any production code and has no security impact on real users.

This commit fixes how the shared library version number is set when building on OpenBSD. It adds an OpenBSD-specific branch in the CMake build logic so the library gets a proper version suffix. There is no direct security vulnerability here; it is a portability/build correctness fix. A wrong version could theoretically cause runtime linker confusion or load an unintended library, but the commit itself is defensive and small.

This commit fixes how version numbers are assigned to the shared library when building on NetBSD. It is a build-system portability fix with no apparent security relevance.

This commit only improves comments and documentation inside a CMake build script. It does not change any actual build behavior or code that runs in the library. There is no security issue here.

This commit is a straightforward cleanup of the build system. It moves existing logic for setting shared-library version numbers into a reusable CMake helper module, without changing the actual version-numbering behavior. There is no security-relevant change.

This commit is a minor cleanup in the project's internal test code. It replaces a two-step pattern (compute a point in one coordinate format, then convert it to another) with a single helper function that does the same thing. The author explicitly calls it a refactor and notes the only behavioral difference is that an intermediate variable is now cleared, which has no effect on test logic. There is no indication this changes any production cryptography or introduces a security issue.

This is a defensive code cleanup in a Bitcoin cryptography library. It introduces a helper function that wraps a common three-step pattern when multiplying by the generator point, ensuring that temporary sensitive Jacobian coordinate data is always wiped from memory. The change reduces the chance that a future developer forgets to clear that temporary data, which could theoretically leak tiny fragments of secret key information through memory side channels. It does not fix a known active bug or reported vulnerability.

This commit is a simple rename of an internal function from `secp256k1_ecmult_gen` to `secp256k1_ecmult_gen_gej` across six files. The change is purely cosmetic and intended to make the function name consistent with a newly added variant. No behavior, logic, or security properties of the code are changed.

This commit only adds a new internal performance benchmark for a low-level math helper function (secp256k1_fe_normalize_var). It does not change any cryptographic logic, library behavior, or user-facing code. There is no security issue here.

This commit only adds a new test file that exhaustively checks the ECDH (Elliptic Curve Diffie-Hellman) module. It does not change any production code, cryptographic logic, or build behavior for end users. There is no security vulnerability here; it is purely a test-suite improvement.

This is a tiny test-only change. It makes one unit test compare the full 66-byte MuSig aggregate nonce output instead of only the first 33 bytes. It does not change any production code, cryptographic behavior, or library API.

This commit only fixes wording in the API documentation comments. It changes the description of a function output parameter from 'pointer to an array' to 'pointer to a signature object' in two header files. No actual code behavior changed, so there is no security impact.

This is a small defensive cleanup in Bitcoin Core's libsecp256k1 MuSig code. The function that generates a cryptographic nonce could, in rare error cases, leave a temporary copy of the user's secret key in memory instead of wiping it. The patch makes sure the secret key buffer is always cleared, even when the internal function fails. The actual failure path can only be reached if the API is misused (bad keypair or cache), so this is best-practice hardening rather than an active exploit.

This commit simply updates the version number of an experimental GCC compiler snapshot used in automated testing, from version 16 to version 17. It is a routine CI/infrastructure maintenance change with no security relevance.

This change updates the project's automated testing setup for Windows builds. It stops using a third-party GitHub Action called `ilammy/msvc-dev-cmd` to prepare the Microsoft C++ compiler, and instead runs a built-in Microsoft batch file directly. The commit message says the third-party tool is considered abandoned and unsafe, so this is a preventive security hygiene change rather than a fix for an active vulnerability in the project's own code.

This commit tightens internal safety checks in the code that extracts bit chunks from large secret numbers (scalars) used in elliptic-curve cryptography. The changes make the library more defensive against accidental misuse, but the added checks are only active in special test/verification builds, not in normal production builds. There is no direct evidence this fixes an exploitable vulnerability in released software.

This commit simply updates several GitHub Actions workflow dependencies to newer major versions because the older versions rely on a Node.js runtime that GitHub is deprecating. It does not change any cryptographic code, build logic, or project behavior. There is no security vulnerability being fixed here.

This is a small code-quality change in Bitcoin Core's secp256k1 cryptographic library. It adds an explicit safety check confirming that a value converted from one internal format to another stays within the expected range, and it silences a compiler warning about an unused return value. The commit message frames this as avoiding a compiler warning, not fixing a security bug.

This is a minor test-code change that rewrites how two hash functions are selected inside a loop so the code complies with the older C89 standard. It does not change what the tests actually do, and it is not a security fix.

This commit only adds a documentation comment and extra test cases for an already-supported calling convention of an internal elliptic-curve multiplication function. It does not change any behavior or fix any bug.

This is a one-line internal code cleanup in Bitcoin's secp256k1 cryptographic library. It changes how a public-key tweaking function passes a zero value to the elliptic-curve multiplication routine, switching from an explicit zero scalar to a special NULL pointer that the same routine already understands. The commit message gives no security rationale, and the diff alone does not show a fix for an exploitable bug. It is best treated as a defensive correctness or performance simplification rather than a security patch.

This commit adds a new public API that lets users of the libsecp256k1 cryptography library swap out the internal SHA-256 compression function at runtime, typically to use a faster hardware-accelerated version. The library checks that the replacement behaves like the real SHA-256 step before accepting it. The change itself is a feature addition, not a bug fix, and there is no evidence in the commit or supplied references that it addresses a known security vulnerability.