Ledger Bitcoin app

This commit fixes a security issue where a secret cryptographic key could be left behind in memory if an error occurred during a key-tweaking operation. The patch now wipes the output buffer on failure paths, reducing the risk that leftover secret material could be extracted later.

This commit fixes a small but real off-by-one buffer sizing bug in the Ledger Bitcoin app's wallet code. A string buffer meant to hold a serialized extended public key was sized to the maximum character length, but C strings need an extra byte for the terminating null character ('\0'). Without that extra byte, code later reading or copying the string could read past the buffer or write the terminator into adjacent memory, which on a constrained hardware wallet could potentially leak secrets or cause a crash. The fix adds the missing +1 byte.

This commit fixes a bug in how the Ledger Bitcoin app reads large numbers from wallet policy strings. The old overflow check could miss some values that are too large to fit in a 32-bit unsigned integer, causing the app to silently accept and truncate an oversized number. This could let an attacker craft a wallet policy that passes validation when it should have been rejected, potentially changing the meaning of a spending condition such as a time lock. The fix corrects the math used to detect overflow and adds a regression test.

This commit adds a safety limit to a recursive function called parse_script in Ledger's Bitcoin app. Without such a limit, an attacker could potentially feed the device an extremely nested Bitcoin script that causes the function to call itself so many times that the device's limited stack memory runs out. A stack overflow on a hardware wallet could crash the app or, in worst cases, be exploited to alter behavior. The fix caps nesting at 16 levels, which is above any realistic legitimate use.

This commit tightens validation in a Ledger Bitcoin app function that reads a Merkle tree leaf index from an external message. Previously, the function accepted any 64-bit unsigned index value. Now it rejects indexes larger than the maximum signed integer and indexes equal to or larger than the number of leaves. This prevents a malformed or hostile message from passing an out-of-range index into later code that expects a normal array position, which could otherwise cause incorrect behavior or memory corruption on a secure hardware wallet.

This commit only adds or updates comments describing what several existing functions do. No program code, logic, or behavior was changed. It is a documentation-only change and does not affect security.

A single-line fix in Ledger's Bitcoin app changes a memory allocation from using the size of a pointer to using the size of the actual data structure. On the 32-bit ARM hardware used by Ledger devices, both sizes happen to be 4 bytes, so the bug had no practical effect there. On a different architecture with larger pointers, the allocation would have been too small, potentially causing memory corruption when the structure is later written to. The commit message explicitly says this was not a bug on current 32-bit ARM devices.

This commit is a straightforward code cleanup in Ledger's Bitcoin app. It removes an old memory-saving trick used for the discontinued Nano S device and replaces it with a cleaner, more readable approach that uses a dedicated local variable to hold the final hash. There is no security-relevant change: the same hash is computed and compared in the same way, just stored in a different place.

This commit changes several function parameters from signed integers (int) to unsigned size values (size_t) in code that handles key lookups in cryptographic maps. The stated goal is to avoid silent conversions between signed and unsigned types, which can hide bugs. The change is defensive and does not by itself fix a confirmed exploitable vulnerability, but it removes a class of low-level risks that could contribute to memory-safety issues in a security-critical hardware wallet app.

This commit is a code cleanup with no functional change. It removes an unnecessary comparison to 'true' in two boolean checks. The behavior of the program is identical before and after the change.

This commit fixes a spelling mistake in a code comment ('singla' to 'single'). It does not change any executable code, logic, or behavior of the Ledger Bitcoin app. There is no security impact.

This commit adds a safety check to the Ledger Bitcoin app's transaction-signing code. Before signing a Bitcoin transaction, the app now refuses if the transaction has more outputs than a defined maximum. Without this check, a specially crafted transaction with an extremely large number of outputs could potentially overflow internal counters or exhaust memory, leading to crashes or unexpected behavior on the hardware wallet.

This commit is a simple code cleanup: it replaces two hard-coded copies of the maximum possible number of satoshis in existence with a single named constant. The actual safety check and the numeric value it compares against remain exactly the same, so there is no security change.

This commit adds safety checks in the Ledger Bitcoin app's transaction signing code. Before this change, the app would continue processing Bitcoin transaction inputs and outputs even if their amounts were larger than all the Bitcoin that will ever exist. Such absurdly large values could potentially cause arithmetic overflows in later calculations. The fix makes the app immediately reject these transactions with an error instead of continuing.

This is a routine JavaScript library upgrade. The project moved its bitcoinjs-lib dependency from version 6 to version 7, which changed some internal return types from Buffer to Uint8Array and from number to bigint. The commit adds small adapter functions (like Buffer.from(...) and a bigint-to-number helper) so the rest of the code keeps working without wider rewrites. There is no direct evidence in the commit that this fixes an active security vulnerability; it reads as a compatibility/refactoring change.

This commit removes a single inline comment from a JavaScript test file. It does not change any executable code, test logic, or behavior. There is no security relevance.

This commit updates the JavaScript Bitcoin client used with Ledger hardware wallets so that address validation now uses a newer version of a third-party descriptor library. It also adds many more test cases covering newer Bitcoin address types such as Taproot and MuSig. The change itself is a refactoring and test expansion; there is no direct evidence in the commit that it fixes an active security vulnerability. It appears intended to keep the client compatible with newer wallet policies and to improve test coverage.

This commit is a routine maintenance update for the JavaScript Bitcoin client package. It upgrades the TypeScript compiler, Jest test framework, Typedoc documentation tool, and several related development dependencies. It also raises the minimum required Node.js version from 14 to 18.14 and tells Jest to ignore the build/ directory when running tests. There are no application code changes and no direct security fixes or new features.

This commit only updates screenshot files used for automated UI testing. There are no changes to the actual Ledger Bitcoin app code, so it cannot directly affect device security or user funds.

This commit only changes user-facing text strings in the Ledger Bitcoin app. It capitalizes 'Bitcoin' as 'bitcoin' in a few labels and rewords some warning messages to be clearer. There are no code logic changes, no security fixes, and no behavior changes.

This commit is a build-system cleanup for Ledger's Bitcoin app. It wraps all code related to the optional 'SWAP' feature inside #ifdef HAVE_SWAP guards so that, when the app is compiled without SWAP support, none of that code is compiled or linked. The change removes unconditional references to swap-specific global variables and functions from non-swap source files. On its own this is a hardening/compilation-fix change rather than a fix for an active, exploitable vulnerability in already-shipped code.

This commit fixes a type mismatch in the Ledger Bitcoin app's swap verification code. The lengths of Bitcoin addresses were being stored in small signed/char variables instead of the proper unsigned size type. For extremely long strings this could in theory cause the comparison to misbehave, but in practice Bitcoin addresses are short enough that the bug is unlikely to be exploitable. It is a hardening fix rather than a clear vulnerability.

This commit fixes a small coding issue in the Ledger Bitcoin app's transaction-signing code. Two local variables that previously had no starting value are now initialized to zero. In some code paths, these variables could have been used before being set, which might lead to incorrect checks when validating special 'OP_RETURN' outputs used in cryptocurrency swaps. The change is defensive and reduces the risk of unpredictable behavior, but the commit message does not claim it fixes an active security bug.

This commit adds compile-time checks to make sure the Bitcoin app's own swap error codes line up with the official Ledger SDK's swap error codes. It does not change any runtime behavior or fix an active bug; it is a defensive quality-assurance change that prevents future mismatches.

This commit is mostly a renaming exercise: functions that started with 'io_' in the Ledger Bitcoin app now start with 'ioe_' to avoid clashing with the operating system's own 'io_' functions. Alongside the rename, one small logic fix was made in the response-buffering code. Previously, when adding response data that was too large, the code could pass a negative length to a recursive call, which is unsafe. The new code computes how much space remains, copies only that amount, and then marks the response as too long. This is a defensive improvement, not an active vulnerability fix for a known exploit.