Ledger Bitcoin app

This commit fixes a small but meaningful bug in the Ledger Bitcoin app's code that handles advanced multi-signature (MuSig) operations. A function called crypto_tr_lift_x can fail when given an invalid x-coordinate that does not correspond to any real point on the Bitcoin elliptic curve. Previously, the cpoint function ignored that failure and kept using the resulting output as if it were valid. The patch now checks the return value, prints an error message, and returns an error code instead of continuing with potentially bad data. In a hardware wallet, using invalid curve points could in theory lead to incorrect signature calculations or unexpected behavior, though the practical exploit path is not fully clear from the diff alone.

This update fixes a stack-exhaustion weakness in Ledger's Bitcoin app. A malicious or unusually crafted wallet policy (the text string that describes how coins can be spent) could make the app recurse so deeply that it runs out of call stack and crashes. The patch adds depth limits during parsing, reduces large on-stack buffers, and moves big buffers out of recursive functions so the app rejects oversized policies safely instead of crashing.

This commit adds automated tests to the Ledger Bitcoin app to check that very deep or heavily nested wallet policies are rejected safely. The tests confirm that an over-deep policy returns an error instead of freezing or crashing the device. The commit itself only adds tests; it does not change the app's actual handling code, so it is a defensive test addition rather than a fix.

This commit reduces a hard-coded limit in Ledger's Bitcoin app on how many branches a 'thresh' miniscript operator can have, from 128 down to 24. The change is framed as a memory-usage improvement, not a security fix. It also adds a test to make sure policies exceeding the new limit are rejected rather than analyzed with an undersized table. There is no direct evidence in the commit or supplied references that this was a disclosed vulnerability or that an exploit exists.

This commit fixes a bug in the Ledger Bitcoin app's wallet-policy parser. Miniscript 'wrappers' (short letters like 'n' that modify a policy) were not counted toward the parser's recursion-depth safety limit. A crafted wallet descriptor with a long chain of wrappers could create an extremely deep policy tree, causing later recursive functions to exhaust the device's limited stack and crash. The patch now charges each wrapper against the same depth budget as nested expressions, and adds tests proving the boundary works.

This commit changes how deeply nested Bitcoin wallet policies can be when processed by a Ledger hardware wallet app. It removes a separate, smaller limit (10 levels) and instead uses the same deeper limit already applied during an earlier parsing stage. The change is likely a hardening or consistency fix rather than an obvious exploit, but it could affect whether very deep policies are accepted or rejected.

This commit fixes a stack-overflow risk in Ledger's Bitcoin app when parsing wallet policies that deeply nest 'thresh' miniscript fragments. It limits nesting to four levels and prevents two helper functions from being inlined so their large local arrays don't multiply across every recursive call. Without the fix, a crafted policy could exhaust the device's limited stack and crash or potentially corrupt memory.

This commit refactors the Ledger Bitcoin app's wallet registration code so that the user-confirmation step runs in a separate function that the compiler is told not to inline. The stated goal is to reduce peak stack memory use by freeing large validation buffers before the UI rendering phase. The change itself is a defensive hardening/optimization patch; there is no direct evidence in the commit that it fixes an exploitable vulnerability.

This commit rewrites a function in the Ledger Bitcoin app to use less memory. The old code stored a large table of key-derivation pairs for every possible class of key expression, which grew quadratically with the maximum number of key expressions. The new code stores only the class assignment for each key expression and rebuilds the pair list one class at a time, cutting stack usage by several kilobytes. The change also narrows some integer types. There is no explicit security bug fixed in the commit message, but on memory-constrained hardware large stack frames can contribute to crashes or stack overflows.

This commit only changes a code comment to accurately describe how child scripts are stored. It does not alter any actual program logic, data structures, or behavior, so it has no security impact.

This commit temporarily blocks a specific advanced Bitcoin wallet feature (MuSig inside multi_a/sortedmulti_a) because the code that reads those wallet descriptions doesn't handle it correctly yet. It's a defensive change to prevent malformed or unexpected wallet policies from being accepted, rather than a fix for a known active attack.

This commit adds extra safety checks when the Ledger Bitcoin app verifies Merkle proofs, which are cryptographic evidence used to confirm that a piece of data belongs to a larger set. The changes ensure that the proof length matches the expected tree depth and that streamed data has the correct leaf prefix. Without these checks, a malicious or malformed proof might have been accepted incorrectly, potentially allowing an attacker to lie about which data is stored in the wallet's Merkle tree.

This commit only adds new unit tests for existing code. It does not change any production behavior, fix a bug, or introduce new functionality. The tests verify that certain security checks (proof length and domain separator checks) already reject malformed inputs. There is no direct security risk in this commit itself.

This commit hardens a Bitcoin transaction parser in Ledger's app. It changes some numeric fields to safer types, adds bounds checks on transaction counts and sizes, rejects extra trailing bytes after a transaction, checks a previously-ignored internal buffer operation, and zeroes out result memory before use. These are defensive fixes that could prevent memory corruption, incorrect parsing, or information leakage, but the commit does not describe a specific active exploit.

This commit tightens how the Ledger Bitcoin app parses previous transaction data when signing Bitcoin transactions. It adds size limits and completion checks that prevent malformed or oversized previous transaction outputs from being processed. These changes reduce the chance that an attacker could trick the device into reading bad data, overflowing buffers, or signing based on an incomplete/corrupted view of a prior transaction.

This commit only changes the declared type of three array-length constants from signed int to unsigned size_t, and removes two stale comments about a 10,000-byte limit. There is no change to program logic, memory allocation, bounds checking, or parsing behavior. It is a code-style/cleanup change with no security relevance visible in the diff.

This commit fixes a copy-paste bug in test helper code used during automated testing of Ledger's Bitcoin app. The bug caused the right-hand branch of a Taproot script tree to be ignored and the left-hand branch to be hashed twice when computing the tree's root hash. This only affects Python test utilities, not the device firmware or production wallet code, so real user funds are not at risk. However, the bug could have made some tests silently pass with an incorrect taptree hash, weakening test coverage for Taproot/MuSig2 features.

This commit removes manual shortening of preset names in a developer-only playground GUI and lets the UI toolkit handle truncation automatically. It is a cosmetic/usability fix with no apparent security relevance.

This commit only touches a developer playground helper script. It adds a small safety check when building test PSBTs and adds a new test preset for a Taproot miniscript wallet. There is no change to the actual Ledger Bitcoin app code that runs on the device or that users rely on for security.

This commit fixes a bug in internal developer/test tooling for Ledger's Bitcoin app. The bug caused test PSBTs (Partially Signed Bitcoin Transactions) with certain SIGHASH flags to be built incorrectly, because the tool wrongly assumed the transaction had to balance. The fix makes the test generator understand that some sighash types allow the transaction to be unbalanced. This is a test/playground fix, not a change to the app that runs on the hardware wallet.

This commit only updates the project's changelog file to prepare for release 2.5.0. It renames an upcoming version placeholder, reorganizes release notes, and adds descriptions of user-facing changes. No source code, build scripts, or security-sensitive files were modified.

This commit only changes two documentation files. It clarifies when the Ledger Bitcoin app can and cannot display the total amount of external transaction inputs. The change adds a note that for non-Taproot transactions, if the PSBT lacks the non-witness UTXO data for external inputs, the shown external-input amount is not trustworthy because legacy and SegWit signatures do not commit to that data. There is no code change in the commit, so it does not by itself fix or introduce a vulnerability.

This commit only adds documentation. It explains how the Ledger Bitcoin app handles unusual signing options (non-default sighash flags and transactions with external inputs) and what warnings users see. There are no code changes, so it does not introduce, fix, or change any security behavior by itself.

This commit only changes the application's version number in the build file from 2.4.6 to 2.5.0. There are no code changes, no security fixes, and no functional changes visible in this commit.

This commit only updates test snapshot images (screenshots used in automated UI testing) for the Ledger Bitcoin app. No application source code, firmware logic, or security-sensitive files were changed. It does not fix or introduce any security issue on its own.