Ledger Bitcoin app

This commit adds a new way for the Ledger Bitcoin client to ask the device for the wallet's master key fingerprint (a short public identifier). It also keeps an older fallback method for compatibility with devices that do not yet support the new command. The change is a feature addition in the client library, not a fix for a known vulnerability, and the commit message does not describe any security problem.

This commit fixes a bug where signing an empty Bitcoin message could cause the Ledger device to display random leftover data from its memory instead of a clean empty message. The fix simply ensures the message buffer starts as an empty string before any data is copied into it. This is an information disclosure issue: an attacker who can trigger an empty message signing request might get the device to show uninitialized stack memory on screen. It does not appear to allow stealing coins directly, but it is a security-relevant bug in a trusted display path.

This commit fixes two spots in Ledger's Bitcoin app where a very large 64-bit number could be silently truncated to a smaller 32-bit number. After the truncation, the app would treat a huge requested data length as a small one, which could let an attacker read memory beyond what was intended or behave in unexpected ways. The fix now checks for overflow and fails immediately before the conversion happens.

This commit adds a safety check in the Ledger Bitcoin app's code that handles BIP32 derivation paths extracted from a PSBT (Partially Signed Bitcoin Transaction). The change prevents a very large, attacker-chosen data length from being silently truncated when converted from a large unsigned integer (size_t) to a signed integer (int). Such truncation could theoretically cause the app to allocate or read/write the wrong amount of memory, potentially leading to crashes or memory corruption. The patch is narrow and defensive, but it does not show a complete exploit path.

This commit fixes two bugs in the Ledger Bitcoin app's MuSig (multi-signature) signing code. First, a function that should return true/false was returning -1 on error, which could be misinterpreted as 'true' (success). Second, after detecting a failed signature aggregation and sending an error code to the computer, the code kept running instead of stopping, which could lead to signing with invalid or partial data. Both are security-relevant control-flow bugs in a cryptocurrency signing path.

This commit only changes the displayed copyright year from 2025 to 2026 in the app's about/credits screen. It is a routine legal notice update with no security relevance.

This commit only updates three test screenshot images used for comparing the app's dashboard display during automated testing. No application code, logic, or security-sensitive files were changed.

This commit only bumps the app version number from 2.4.5 to 2.4.6 and updates the changelog. It does not change any source code, cryptographic logic, or security behavior. The changelog mentions that a prior release fixed a miniscript policy issue, but this commit itself is purely administrative packaging.

This commit adds an early safety check in a Bitcoin address formatting function. It returns an error immediately if the output buffer has zero length, preventing a possible integer underflow when the code later computes out_len - 1. The change is defensive and reduces the risk of memory corruption or unexpected behavior, though the commit message only frames it as avoiding underflows and does not claim a specific exploitable vulnerability.

This commit fixes a missing safety check in the Ledger Bitcoin app's code that copies a 'preimage' (a piece of data used in Bitcoin transactions) into an output buffer. Before the fix, if the preimage was larger than the buffer, the app could write past the end of the buffer, corrupting memory. The patch adds a size check and also checks the result of every buffer write so the app stops safely instead of overflowing. This is a memory-safety bug that could potentially be exploited from a host computer talking to the device.

This commit fixes a security-sensitive cleanup bug in the Ledger Bitcoin app's signing code. When a cryptographic signing operation failed, the output buffer that would normally hold the signature was not being cleared. That means a partially computed or leftover value could be returned to the caller instead of a valid signature. The fix wipes the buffer to zero whenever an error occurs, ensuring no misleading or exploitable signature-like data is produced.

This commit adds a safety check in the Ledger Bitcoin app's code that parses raw transactions from PSBT data. Before finalizing, it now verifies that if the caller asked for a specific transaction output by index, that output actually exists. Without this check, the code could have proceeded using data from a non-existent or uninitialized output, potentially leading to incorrect transaction details being shown or signed.

This commit fixes a length check in the Ledger Bitcoin app's PSBT signing code. Before reading the 9th byte of a witness UTXO field, the code now verifies the field is at least 9 bytes long. Previously, it only checked that some data was returned, which could lead to reading past the end of a malformed or truncated input. This is a defensive fix against an out-of-bounds read that could affect transaction amount calculations during signing.

This commit fixes a missing safety check in the Ledger Bitcoin app when reading BIP32 derivation data from a PSBT (Partially Signed Bitcoin Transaction). For non-Taproot transactions, the app was not verifying that the derivation data was not longer than the maximum supported size before copying it into a fixed-size internal buffer. This could allow a malicious or malformed PSBT to overflow that buffer, potentially corrupting memory and affecting the device's behavior during transaction signing.

This commit only adds documentation comments to a header file describing existing functions. No code behavior was changed, so it cannot introduce or fix a security issue on its own.

This commit only fixes a typo in a code comment. The comment previously referenced the wrong function name ('bip32_CKDpub' instead of 'crypto_tr_tweak_pubkey'). No actual code logic was changed, so there is no security impact.

This commit only updates test screenshot snapshots for the Ledger Bitcoin app. It renames and replaces image files used by the Ragger automated UI testing framework, changing test case names from '4to17' and '4to18' to '4toMax' and '4toMaxPlus1'. No application source code, firmware, or runtime behavior is modified, so there is no direct security impact on users.

This commit only changes test helper code so that automated tests for the Ledger Bitcoin app use a smaller number of outputs on the Nano X device. It does not change the actual app firmware. The change is a test-suite adaptation to match a previously reduced Nano X limit, not a fix for a new security bug.

This commit reduces how many Bitcoin transaction outputs the Ledger Nano X app can review at once (from 16 down to 8) in a specific non-streaming mode. The stated reason is to avoid exceeding the Nano X operating system's 8 KB stack limit, which could otherwise cause the app to crash or behave unpredictably when signing transactions with many outputs.

This commit adds a build-time safety check in the Ledger Bitcoin app's Makefile. It sets a minimum required stack size depending on the device (Nano X or other), which helps catch cases where too much memory is used globally and could overflow into the stack. It is a defensive hardening change, not a fix for a known active bug or attack.

This commit changes the JavaScript test step in the project's automated CI workflow to use 'yarn install --immutable' instead of 'yarn install'. This tells the package manager to strictly follow the existing lockfile and fail if it would need to change it. It is a supply-chain hygiene improvement for testing, not a fix for a runtime security vulnerability in the Bitcoin app itself.

This commit is a routine version bump for a JavaScript package from 0.3.0 to 0.3.1. It only changes two package metadata files and contains no code changes. There is no indication of a security fix or vulnerability.

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 fixes a boundary-check ordering bug in the Ledger Bitcoin app's wallet policy parser. Previously, the code stored an untrusted length value into a data structure before checking whether that length was too large. The fix moves the storage to after the validation check. This prevents a malformed wallet policy from causing the app to record an oversized length that could later lead to memory corruption or incorrect parsing.

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.