Every captured commit receives deterministic security triage and a separate communication-quality score. Security candidates and broader second-pass signals receive full-patch Ollama analysis.
Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.
This commit pins the exact versions of Python testing tools used by the project's automated tests. Previously, the test setup allowed any newly released version of those tools to be installed automatically, which could introduce unexpected…
Supply-chain risk reduction for test/CI dependenciesPrevents unreviewed automatic upgrades of speculos and raggerNo change to firmware or published package code
This commit is a routine version bump from 2.5.1 to 2.6.0 in the Ledger Bitcoin app. It only updates the version number in the Makefile and the release date in the CHANGELOG. There are no code changes, no bug fixes, and no security-related…
This commit tightens how the Ledger Bitcoin app and its companion client libraries read PSBT (Partially Signed Bitcoin Transaction) data. It adds checks that reject malformed or suspicious PSBTs: truncated fields, unexpected extra bytes af…
Hardened PSBT deserialization against truncation and trailing dataAdded duplicate-key detection in PSBT mapsRejected PSBTv2-only fields inside PSBTv0 to prevent locktime/field override attacks
This commit tightens input validation in the Python helper library that prepares Bitcoin transaction data for Ledger hardware wallets. It now rejects PSBT files that claim to be the older version 0 format but contain fields that only belon…
Input-validation hardening: stricter parsing of PSBT version 0 to reject v2-only key typesConsistency fix across clients: aligns Python client with HS and Rust client behaviorLocktime normalization during v0-to-v2 conversion to prevent per-input locktime from overriding transaction locktime
This commit updates a test helper file used to talk to a Bitcoin node during automated testing. The old helper could accidentally send the same command twice if the network connection hiccuped, which could cause a test-only action like sen…
Removed transparent retry of non-idempotent RPC requests after connection resetsTest helper could execute state-changing RPCs twice before the fixNew connection-per-call configuration mitigates idle-timeout disconnects without retry risk
This commit fixes the JavaScript PSBT (Partially Signed Bitcoin Transaction) parser in Ledger's Bitcoin app so it now rejects malformed PSBTs that contain duplicate keys or extra trailing bytes. Previously, such malformed data could be acc…
BIP-174 non-compliance: duplicate keys and trailing data were previously acceptedState reuse bug: deserializing multiple PSBTs in the same instance could merge mapsInput validation gap in client-side PSBT parsing
This commit fixes the automated test harness, not the Ledger Bitcoin app itself. Previously, the test framework could silently pass even when the device completed a request without showing the expected on-screen review. The change makes te…
Test-hardening only: no firmware or runtime application code changedFixes false-negative test results where a request could succeed without expected UI reviewCorrects scope of navigation settings to avoid leaking across nested or subsequent calls
This commit fixes an arithmetic overflow bug in a test-only PSBT (Bitcoin transaction format) parser used in unit tests. The bug could let a crafted test input make the parser think a data length is huge, potentially confusing the mock dis…
Integer overflow/wrap-around in length calculationOut-of-bounds length derived from arithmetic on attacker-influenced offsetsUnit-test-only code path, not device firmware
This commit fixes a bug in the Ledger Bitcoin app's Rust client where a PSBT v0 (an older transaction format) could silently carry fields that only have meaning in PSBT v2. When converting v0 to v2, those fields could override values taken…
Input validation added for cross-format PSBT conversionPrevents v2-only fields from overriding unsigned-transaction-derived valuesBIP-370 compliance enforcement for PSBTv0
This commit fixes a bug in the Ledger Bitcoin app's JavaScript client library. When converting an older-style Bitcoin transaction file (PSBT version 0) into the newer PSBT version 2 format, the library previously ignored fields that are on…
Input validation fix: rejects malformed PSBTv0 containing v2-only fieldsPrevents silent override of transaction locktime during PSBTv0-to-v2 conversionAdds missing BIP-370 key type constants for required time/height locktime
This commit fixes a bug in how the Ledger Bitcoin app client parses PSBT (Partially Signed Bitcoin Transaction) maps. Previously, if the same key appeared twice in a map, the parser silently kept the last value. A malicious or malformed PS…
Silent overwrite of duplicate PSBT map keys could create commitment mismatch between client and deviceTruncated PSBT maps were silently accepted due to exception swallowing in deserialization loopsTrailing data after PSBT maps was ignored, allowing reserialization to silently normalize malformed inputs
This commit fixes several bugs in Ledger's Bitcoin app. The most serious ones are: (1) a set of miniscript policy analyzer mistakes that could let the app accept Bitcoin wallet policies whose scripts are too large or too expensive to execu…
Miniscript cost/property analysis errors that could allow oversized/undercosted wallet policiesHost-driven infinite-loop / denial-of-service via zero-length GET_MORE_ELEMENTS responsesUI state inconsistency causing a security warning to be prematurely dismissed
This commit improves the Ledger Bitcoin app's MuSig2 multi-signature feature. It lets wallet software pre-generate public nonces before a transaction is known, adds an optional MUSIG2_SESSION_ID field so multiple signing sessions can be in…
New PSBT proprietary field parsing with length validation (1-32 bytes, empty rejected)Session ID now commits to wallet policy plus optional MUSIG2_SESSION_IDSession storage limit raised from 8 to 32 with LRU eviction
This commit is a small code cleanup in Ledger's Bitcoin app. It changes two local arrays from unsigned (uint16_t) to signed (int16_t) in functions that count operations and stack sizes for Bitcoin miniscript 'thresh' policies. The commit m…
Signed/unsigned type mismatch in sentinel handlingPotential latent integer interpretation bug in miniscript threshold policy analysisCode clarity improvement around invalid (dis)satisfaction markers
This commit fixes the Ledger Bitcoin app's internal checker for Miniscript wallet policies. The checker was incorrectly rejecting some valid Bitcoin spending policies as unsafe, and in a few places it was computing safety properties using …
Logic change in Miniscript policy analysisAlignment with upstream Bitcoin Core reference implementationRelaxation of overly strict non-malleability and timelock-mixing checks
This commit fixes a bug in how the Ledger Bitcoin app counts the number of Bitcoin script operations (ops) needed to spend certain wallet policies that use a 'miniscript andor' fragment. Because the count was wrong, the app could allow use…
Incorrect miniscript ops accounting for andor fragmentPolicy sanity check bypass leading to unspendable registered walletsReference alignment with Bitcoin Core implementation
This commit fixes a bug in how the Ledger Bitcoin app counts Bitcoin script operations ('ops') for two specific Miniscript fragments, 'l:' and 'u:'. Because the count was too low, the app could accept wallet policies that look valid but ar…
Undercounting of script operation budget leading to acceptance of unspendable policiesIncorrect handling of Miniscript wrapper dissatisfaction semanticsPolicy sanity check bypass via operation-count accounting flaw
This commit only updates documentation and the changelog. It explains a new optional PSBT field called MUSIG2_SESSION_ID that lets software wallets manage multiple MuSig2 signing sessions for the same wallet policy on a Ledger device. Ther…
This commit is a simple capacity increase, not a security fix. It raises the number of simultaneous MuSig2 signing sessions the Ledger Bitcoin app can keep in memory from 8 to 32, because users with multiple MuSig accounts or wallets that …
This commit improves the user experience and error handling for Ledger's Bitcoin app when using MuSig2 multi-signatures. Previously, if a required MuSig2 session was missing during the second round of signing, the device would only report …
UX-hardening: fail-fast before user approval instead of afterNew specific error code EC_SIGN_PSBT_MUSIG2_SESSION_NOT_FOUND for missing MuSig2 sessionsRefactored session storage lookup to support non-destructive existence check
Unit tests for PSBTv2 locktime fields, and nLocktime calculation
60/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Mentions testing or verification! No meaningful explanatory body
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 12/100
This commit only adds new automated tests for how the Bitcoin app figures out transaction lock times from PSBTv2 data. It does not change the actual app logic, so by itself it cannot introduce a security bug or fix one. The tests are defensive: they check edge cases that could matter for security if the underlying code were wrong, but the commit only verifies behavior, it does not alter it.
Before this, the app used to simplify the specs by taking the PSBT's fallback locktime (or its absence) at face value.
It was documented as a deviation from the specs, but it might lead to future unexpected behaviors from software wallets that expect the BIP-370 computation.
This fixes the gap.
68/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundarysigning or wallet path
AI analysis · Moderate 59/100
Ledger's Bitcoin app changed how it calculates the 'nLockTime' value when signing a PSBT (Partially Signed Bitcoin Transaction). Previously, it simply used the PSBT's fallback locktime and ignored per-input locktime requirements. Now it follows the BIP-370 standard: it looks at each input's required locktime, picks the correct type (block height or timestamp), and uses the maximum required value. This prevents a wallet from preparing a PSBT where the Ledger would sign with a different locktime than the wallet intended, which could in some cases let funds be spent earlier or later than expected, or cause the signed transaction to be rejected by the network.
Merge pull request #569 from LedgerHQ/client-fixes
Client fixes on PSBTv2 field handling
58/100 · ThinMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
signing boundarysigning or wallet pathparser or protocol pathmerge-commit duplicate discount
AI analysis · Low 37/100
This commit fixes how Ledger's Bitcoin client libraries convert older PSBTv0 transaction data into the newer PSBTv2 format that Ledger hardware wallets expect. The changes correct several field-handling bugs: the transaction locktime is now written to the right place, missing input sequence numbers are treated as the default final value, and the Rust client now forwards unknown PSBTv2 fields (such as required locktimes) instead of dropping them. It also rejects malformed PSBTs where v0 and v2 fields contradict each other, rather than producing an invalid PSBT that the device would refuse. These are client-side robustness fixes; they do not appear to be a security patch for the device firmware itself.
AI review queuedpython client: use default value for nSequence if not givenby Salvatore Ingala · 2bf0eed6 · Sep 18, 2026 · 1 fileMessage 65 · AdequateInformational 24Details
Commit message · Salvatore Ingala
python client: use default value for nSequence if not given
Matches BIP-370 and HWI's implementation upstream.
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Informational 24/100
This commit fixes a small bug in the Python helper library that builds unsigned Bitcoin transactions from PSBT data. Previously, if a PSBT did not explicitly include a per-input sequence number, the code would crash with an assertion error. The change follows the BIP-370 standard and HWI by treating a missing sequence number as the default final value (0xffffffff). This is a client-side convenience fix; it does not change how the Ledger device itself validates or signs transactions.
The public interface in the psbt module changed, therefore a minor version bump is necessary.
60/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing boundary
AI analysis · Informational 15/100
This commit only updates a version number from 0.6.2 to 0.7.0 in two Rust package files. It is a routine bookkeeping change because the public interface of the PSBT module changed, requiring a minor version bump under semantic versioning rules. No code behavior changes are present in the diff.
Security candidatejs tests: drop a bogus required height locktime of 0 from test PSBTsby Salvatore Ingala · ec992074 · Sep 18, 2026 · 2 filesMessage 83 · StrongInformational 15Details
Commit message · Salvatore Ingala
js tests: drop a bogus required height locktime of 0 from test PSBTs
The hardcoded PSBTs that were used in the tests are actually invalid, as they have PSBT_IN_REQUIRED_HEIGHT_LOCKTIME = 0; but the field is required to be > (or absent) per BIP-370.
The PSBT_IN_REQUIRED_HEIGHT_LOCKTIME field is therefore dropped in this commit.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 15/100
This commit only changes hardcoded test data used in JavaScript unit tests. It removes an invalid zero-value locktime field from two PSBT (Partially Signed Bitcoin Transaction) test fixtures so they conform to the BIP-370 standard. No production code, device firmware, or user-facing behavior is changed.
python client: fix three PSBTv2 defects in psbt.py
- get_unsigned_tx assigned the computed lock time to `self.nLockTime` instead of `tx.nLockTime`, so the CTransaction it returned always kept the nLockTime 0.
- cache_unsigned_tx_pieces tested `self.tx is not None`, but __init__ always creates a CTransaction, so the condition is always true -- its own docstring says "does nothing if the PSBT is already v2". For a deserialized PSBTv2, whose tx is null, setup_from_tx therefore overwrote tx_version with 1 and fallback_locktime with 0, discarding the values just parsed. Test the version instead.
- convert_to_v0 cleared tx_version and fallback_locktime and only then called get_unsigned_tx(). Build the transaction first to avoid the values of those fields.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
95/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification
Why it was queued
signing boundarysigning or wallet path
AI analysis · Low 48/100
This commit fixes three bugs in a Python helper that converts modern PSBTv2 transaction data into the older PSBTv0 format used by Ledger hardware wallets. The bugs could silently corrupt the transaction's lock time and version fields during conversion, which might alter when a transaction becomes valid or what transaction format the device signs. The fixes ensure the correct values are copied before they are erased. There is no direct evidence this was exploitable as a security attack, but it could cause unexpected or invalid signatures in wallet software relying on this library.
Security candidaterust client: build PSBTv2 maps from all pairs, not an enumerated listby Salvatore Ingala · a16bb101 · Sep 17, 2026 · 4 filesMessage 73 · AdequateLow 35Details
Commit message · Salvatore Ingala
rust client: build PSBTv2 maps from all pairs, not an enumerated list
`get_v2_{global,input,output}_pairs` were a hand-maintained copy of rust-bitcoin's `Map::get_pairs`.
This is error-prone, and forced us to reimplement a lot of the (de)serialization logic.
Instead, we let rust-bitcoin serialization the psbt as v0, instead, and only touch the keys where v0 and v2 actually differ: drop PSBT_GLOBAL_UNSIGNED_TX, add the global v2 fields and each input's and output's v2 fields.
This also simplifies the code, as more is delegated to rust-bitcoin.
`get_v2_global_pairs`, `get_v2_input_pairs` and `get_v2_output_pairs` are replaced with a single `get_v2_maps` function, so the whole PSBT is serialized once rather than once per input and output.
Key order is irrelevant -- `add_known_mapping` and `get_merkleized_map_commitment` both sort -- so the commitments remain valid as per the app's expectations.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundarysigning or wallet pathparser or protocol path
AI analysis · Low 35/100
This commit refactors how the Ledger Bitcoin app's Rust client converts a PSBT (Partially Signed Bitcoin Transaction) from version 0 to version 2. Previously, the code manually listed every PSBT field it knew how to serialize, which risked silently dropping newer or unknown fields. The new code lets the rust-bitcoin library do most of the serialization, then only adds, removes, or changes the specific fields that differ between v0 and v2. It also adds checks that reject malformed PSBTs where v2 fields already exist and conflict with the v0 transaction data. The change is a defensive cleanup that reduces the chance of an incomplete or inconsistent PSBT being sent to the hardware wallet.
✓ Subject identifies a change✓ Names a concrete action or component! No meaningful explanatory body
Why it was queued
second-pass: opaque commit message
AI analysis · Informational 15/100
This commit is a routine version bump from 2.5.0 to 2.5.1 for the Ledger Bitcoin app. It only updates the changelog and Makefile version number. No code changes are present in the diff, and no security fixes or vulnerabilities are described.
Security candidateunit-tests: drive the BIP-322 tests from the BIP's pinned test vectorsby Ruben Waterman · 2e1d265c · Sep 8, 2026 · 7 filesMessage 91 · StrongInformational 15Details
Commit message · Ruben Waterman
unit-tests: drive the BIP-322 tests from the BIP's pinned test vectors
Replace the two hand-copied cases with the "tx_hashes" table of bip-0322/basic-test-vectors.json, vendored verbatim in specs/bip322/ (pinned to bips commit d77863fb, 2026-05-06) and rendered into unit-tests/bip322_vectors.inc.c by specs/bip322/gen.py. The generator recomputes every hash independently before emitting anything, and CI now runs its --check alongside the BIP388 one, in the workflow renamed to codegen-check.yml.
This adds the UTF-8 vector that was missing, and covers the to_sign txid of each vector on top of the to_spend one.
Also check, for every vector, that the message hashes to the vector's message_hash with bip322_message_hash_init().
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KAfA54Ci4gLkZnxHa6qrgV Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
91/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
secret or key materialfuzzing or regression evidencecryptography-sensitive path
AI analysis · Informational 15/100
This commit is a routine improvement to the project's automated tests. It replaces two hand-copied BIP-322 test cases with a larger set of official, pinned test vectors (including a new UTF-8 message case) and adds a code generator plus CI check to keep the generated test data in sync. It does not change the actual Bitcoin app code that users run, so it cannot directly affect device security or user funds.
Security candidatebip322: label as v2.0.0 and test proof-of-funds without message_challengeby Ruben Waterman · 056fad95 · Sep 8, 2026 · 7 filesMessage 100 · StrongInformational 12Details
Commit message · Ruben Waterman
bip322: label as v2.0.0 and test proof-of-funds without message_challenge
BIP-322 v2.0.0 (2026-06-04) clarifies that the message_challenge input is not optional in a proof of funds. The validator already enforces this, as the first input is always checked against the recomputed to_spend txid; this commit updates the references to the BIP version and adds a regression test for a proof-of-funds request made only of real UTXOs.
The test uses a zero-valued real UTXO at output index 0 as the first input, so that it passes the amount and prevout index checks and is rejected by the txid binding itself.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KAfA54Ci4gLkZnxHa6qrgV
100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
secret or key materialfuzzing or regression evidencecryptography-sensitive pathsigning or wallet path
AI analysis · Informational 12/100
This commit is a documentation and test update for the Ledger Bitcoin app. It updates references to BIP-322 from an unspecified version to v2.0.0, clarifies that a proof-of-funds message signature must still include the virtual first input, and adds a regression test to confirm the app already rejects malformed requests that omit that virtual input. The actual security check in the device code was already present and is not changed.
Merge pull request #546 from LedgerHQ/simplify_ast
Get rid of relative pointers in wallet policy AST
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
signing or wallet pathmerge-commit duplicate discountsecond-pass: security-sensitive path
AI analysis · Low 27/100
This commit is a large internal refactoring of the Ledger Bitcoin app's wallet-policy parser. It replaces compact 'relative pointers' with ordinary memory pointers in the abstract syntax tree (AST) used to represent Bitcoin wallet descriptors. The change increases the memory each policy node uses, so the app also enlarges the policy buffer and updates related size limits. There is no direct evidence in the commit that this fixes an exploitable vulnerability; it appears to be a code-simplification and maintainability change. However, because it touches memory layout and parsing limits, it could indirectly affect security if the old relative-pointer scheme had subtle bugs or if the new buffer sizing introduces edge cases.
AI review queuedIncrease MAX_POLICY_KEY_INFO_LEN to the actual maximum; nits from PR reviewby Salvatore Ingala · afd42b6d · Sep 3, 2026 · 1 fileMessage 85 · StrongLow 37Details
Commit message · Salvatore Ingala
Increase MAX_POLICY_KEY_INFO_LEN to the actual maximum; nits from PR review
The value of MAX_POLICY_KEY_INFO_LEN did not quite reflect the actual maximum. Unlikely to be hit in practice, because derivation steps used in practice are small - but this fixes it, with some increase in memory usage during wallet registration.
Other nits from PR review.
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Low 37/100
This commit fixes a size limit in the Ledger Bitcoin app that was too small. The app uses this limit when registering Bitcoin wallet policies (descriptions of how to spend coins). The old limit underestimated how long a key description can be when many derivation steps are used. If a real wallet policy exceeded the old limit, the app could reject valid wallets or, in the worst case, mishandle memory. The commit also removes an unused header and updates related comments.
Remove obsolete workaround on stack utilization on Nano X
68/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive pathsigning or wallet pathmerge-commit duplicate discount
AI analysis · Low 32/100
This commit removes an old memory workaround in Ledger's Bitcoin app. Previously, a large data structure used during transaction signing was stored in global memory instead of on the function's stack, because some Ledger devices were thought to have only 8 KB of stack space. The update increases the allowed stack size for the Nano X and moves that data structure back onto the stack. This is a routine code cleanup, but it changes how memory is allocated during the most memory-intensive signing operation. If the new stack limit is slightly wrong, it could in theory cause stack overflows or memory corruption during signing on a Nano X.
Merge pull request #558 from LedgerHQ/embit_private
Mark vendored embit clone 'private' in python client
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive pathsigning or wallet pathmerge-commit duplicate discount
AI analysis · Informational 15/100
This commit simply renames an internal Python package from `embit` to `_embit` (a common convention indicating it is private/implementation detail) and updates all import statements accordingly. There is no functional code change and no security fix or vulnerability present in the diff.
AI review queuedMerge pull request #559 from LedgerHQ/parse_unhardenedby Salvatore Ingala · 96e999fe · Aug 31, 2026 · 8 filesMessage 73 · AdequateModerate 61Details
Commit message · Salvatore Ingala
Merge pull request #559 from LedgerHQ/parse_unhardened
Always reject hardened derivation steps in `<M;N>` in wallet policies
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validationsigning or wallet pathmerge-commit duplicate discountsecond-pass: security-sensitive path
AI analysis · Moderate 61/100
This update fixes a boundary bug in how the Ledger Bitcoin app parses wallet policies that use multi-path key expressions like /<M;N>/*. The app was supposed to reject hardened (high-security) derivation indexes, but it incorrectly allowed the exact boundary value 0x80000000 (2,147,483,648) as if it were unhardened. The patch changes the check from 'greater than' to 'greater than or equal to' so that hardened indexes are always rejected. The rest of the changes are minor cleanups: adding 'U' suffixes to numeric constants and using unsigned types in a few places to avoid comparison bugs.
AI review queuedLabel unsigned constants in constants.hby Salvatore Ingala · e1fcefb4 · Aug 31, 2026 · 6 filesMessage 60 · AdequateInformational 15Details
Commit message · Salvatore Ingala
Label unsigned constants in constants.h
This broke some comparisons under -Werror, so some small adjustments were needed.
60/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Informational 15/100
This commit only adds 'U' suffixes to numeric constants in a header file and makes a few matching type adjustments in C source files so the code still compiles cleanly with strict compiler warnings. It is a code-quality cleanup, not a security fix.
Security candidatePin @bitcoinerlab/descriptors to v3.1.7by Salvatore Ingala · 6262d104 · Aug 31, 2026 · 2 filesMessage 45 · ThinLow 25Details
Commit message · Salvatore Ingala
Pin @bitcoinerlab/descriptors to v3.1.7
45/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component! No meaningful explanatory body
Why it was queued
access control
AI analysis · Low 25/100
This commit changes a JavaScript package dependency from allowing any compatible 3.x version of @bitcoinerlab/descriptors to a fixed, exact version (3.1.7). Pinning a dependency is often done to prevent unexpected future changes, but the commit itself does not say whether it fixes a security bug. It is a routine dependency-management change with no direct evidence of a vulnerability being patched.
Security candidateReject 0x80000000 as an unhardened step in wallet policy parsingby Salvatore Ingala · 44f98a0e · Aug 31, 2026 · 1 fileMessage 73 · AdequateModerate 60Details
Commit message · Salvatore Ingala
Reject 0x80000000 as an unhardened step in wallet policy parsing
2147483648 must be rejected, as it would result in an hardened derivation step, which is no acceptable in BIP-388 (and would later fail address derivation and signing).
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundarydefensive validationsigning or wallet path
AI analysis · Moderate 60/100
This commit fixes a boundary-check bug in how the Ledger Bitcoin app parses wallet policies (BIP-388). The app was supposed to reject any hardened derivation step in a specific range expression, but it allowed the value 2147483648 (0x80000000) because the check used 'greater than' instead of 'greater than or equal to'. That value actually represents a hardened step, which is forbidden here. The fix changes the comparison so 0x80000000 is correctly rejected. If accepted, it could later cause address derivation or signing to fail or behave unexpectedly.
AI review queuedAdd regression test for unhardened derivation step parsingby Salvatore Ingala · ce2c25c6 · Aug 31, 2026 · 1 fileMessage 60 · AdequateLow 47Details
Commit message · Salvatore Ingala
Add regression test for unhardened derivation step parsing
60/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Mentions testing or verification! No meaningful explanatory body
Why it was queued
defensive validationfuzzing or regression evidencesigning or wallet pathsecond-pass: near security thresholdsecond-pass: security-sensitive path
AI analysis · Low 47/100
This commit only adds a new regression test to the Bitcoin app's test suite. The test checks that wallet policy key expressions reject a specific boundary value (2147483648, the first 'hardened' child index) where only 'unhardened' values are allowed. The commit message says an older version of the code incorrectly accepted this boundary value, but the actual code fix is not present in this commit—only the test is added. So this is a test-only change that documents a previously fixed parsing bug.
Mark vendored embit clone 'private' in python client
It was always meant for internal use only, and not part of the public interface.
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
cryptography-sensitive pathsigning or wallet path
AI analysis · Informational 15/100
This commit simply renames a vendored (internally bundled) copy of the 'embit' library inside the Python client from `embit` to `_embit`. The leading underscore is a Python convention meaning 'private/internal use only.' No code behavior changes; only import paths are updated. There is no security fix or vulnerability here.
Security candidateDelete the hash context before return in compute_rand_i_jby Salvatore Ingala · 121a18ce · Aug 27, 2026 · 1 fileMessage 73 · AdequateLow 33Details
Commit message · Salvatore Ingala
Delete the hash context before return in compute_rand_i_j
Defense-in-depth: once partial signatures are known, rand_i_j is sensitive data, and the hash context might allow retrieving it if leaked.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Low 33/100
This commit adds a memory wipe of a cryptographic hash context after it is used to derive a secret random value in the Ledger Bitcoin app's MuSig multi-signature code. The change is described by the developer as a 'defense-in-depth' measure: once partial signatures are public, the internal randomness used to create them becomes sensitive, and leftover data in memory could theoretically help an attacker if they later gained access to the device's memory. There is no evidence this issue was exploited or publicly disclosed as a security vulnerability.
AI review queuedHarden count_distinct_keys_info to correctly count the used keysby Salvatore Ingala · d94c51a2 · Aug 27, 2026 · 4 filesMessage 65 · AdequateModerate 67Details
Commit message · Salvatore Ingala
Harden count_distinct_keys_info to correctly count the used keys
This avoids registering wallet policies that contain unused xpubs that are not referenced in the descriptor template.
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
defensive validationsigning or wallet pathsecond-pass: near security thresholdsecond-pass: security-sensitive path
AI analysis · Moderate 67/100
This commit fixes a bug in Ledger's Bitcoin app that could let a wallet policy slip through registration even when it contained unused or out-of-range public keys. The old code simply looked at the highest key index referenced in the wallet descriptor and assumed every key up to that number was used. That meant an attacker could craft a policy where the user's own key was listed as an unused extra key while the descriptor only required the attacker's key. The fix now explicitly counts which keys are actually referenced and rejects policies with gaps or unreferenced keys.
AI review queuedReject registering wallet policies with pubkeys not on the curveby Salvatore Ingala · d0c47c7a · Aug 27, 2026 · 1 fileMessage 73 · AdequateLow 44Details
Commit message · Salvatore Ingala
Reject registering wallet policies with pubkeys not on the curve
While this would be detected and fail at the first attempt at deriving addresses from it, checking it early consts little.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Low 44/100
This commit adds an early safety check in the Ledger Bitcoin app. Before registering a new wallet policy, the app now verifies that each public key is a valid point on the Bitcoin elliptic curve. Previously, an invalid public key would only be caught later when trying to derive addresses. Catching it earlier prevents the device from storing a broken or potentially manipulated wallet policy.
Security candidateAdditional validation in crypto_get_uncompressed_pubkeyby Salvatore Ingala · d7fc0f8a · Aug 27, 2026 · 1 fileMessage 55 · ThinModerate 61Details
Commit message · Salvatore Ingala
Additional validation in crypto_get_uncompressed_pubkey
Return with error if: - x is too large - x^3 + 7 is not a quadratic residue
55/100 · ThinMessage clarity
✓ Specific, descriptive subject✓ Provides an explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · Moderate 61/100
This commit tightens checks in a Ledger Bitcoin app function that converts compressed public keys into full (x,y) public key points. Previously, the code did not verify that the supplied x-coordinate is a valid field element (less than the curve prime p) and did not confirm that the computed y really satisfies the secp256k1 curve equation. The patch adds both checks, rejecting malformed keys. Without these checks, a specially crafted compressed key could cause the function to produce a point that is not actually on the Bitcoin curve, which could then be used in subsequent cryptographic operations in unexpected ways.