Ledger Bitcoin app

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 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 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 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 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 updates a test helper script that builds Bitcoin PSBT test transactions. It makes the generated test PSBTs more standards-compliant by adding missing key origin information, global extended public keys, and setting the transaction version to 2. The change only affects test utilities, not the actual Ledger app code that runs on devices or handles real funds.

This commit shortens a number of internal error messages in Ledger's Bitcoin app so they no longer exceed a 50-character internal limit. The title says the long messages were causing LEDGER_ASSERT failures, which means the app could crash or refuse to proceed simply because a diagnostic string was too long. The change only rewords messages; it does not alter the underlying security checks or fix any vulnerability in the cryptographic logic.

This commit only fixes spelling mistakes in source code comments and documentation strings. No executable code, logic, or security behavior was changed. It cannot be exploited and has no security impact.

This commit removes a local set of helper functions for reading and writing memory buffers and switches the Ledger Bitcoin app to use equivalent functions now provided by the Ledger SDK. It is a code cleanup and modernization change, not a fix for a known security bug. The only functional code change is removing unnecessary type casts when accessing buffer memory, which does not introduce a vulnerability.

This commit only changes test files for the Ledger Bitcoin app. It adds and updates automated tests to verify that the app correctly accepts derivation paths up to a defined maximum length and rejects paths that are too long. There are no changes to the actual app code that runs on the device, so this commit does not introduce or fix a security vulnerability by itself. It appears to be a follow-up testing patch related to separating two internal constants about path length limits.

This commit renames and splits two related constants for Bitcoin derivation paths. Previously, the same limit was used both for wallet-policy xpub derivations and for full signing paths. The change gives xpub derivations their own smaller limit (8 steps) while keeping the full signing path limit at 10 steps (8 + 2 for change/address index). It also fixes a potential off-by-one check when parsing xpub derivations by changing '>' to '>='. Most of the file changes are cosmetic whitespace removals.

This commit is a routine maintenance change to the project's unit tests. It updates the test build system to use shared utility code from the Ledger SDK instead of local copies, deletes tests for functions that now live in the SDK, and adds a couple of new test cases for wallet policy parsing. There is no change to the actual Bitcoin app code that runs on the device, and nothing in the commit suggests a security fix or vulnerability.

This commit is a large refactoring that replaces many locally-implemented utility files (for parsing APDUs, buffers, base58, BIP32, varints, read/write helpers, etc.) with equivalent files from Ledger's official SDK library (lib_standard_app). It also renames some local files (e.g., io.c -> io_ext.c, buffer.c -> buffer_ext.c) to hold only app-specific extensions. The change itself is not a security patch; it is a code-maintenance / deduplication move. However, any large-scale dependency switch can introduce subtle behavioral differences or regressions, so it warrants careful review rather than alarm.

This commit fixes two bugs in the Ledger Bitcoin app's data-receiving code when large messages are split into multiple chunks. One bug caused the app to hash and copy from the wrong memory location after the first chunk, potentially corrupting a cryptographic proof. The other bug could read corrupted data or behave incorrectly if an empty chunk arrived, or if a taproot PSBT field started with a very large variable-length integer. These are memory/data-integrity issues in security-critical signing code, but the commit does not state they are exploitable for theft.

This commit adds a safety check in the Ledger Bitcoin app's code that parses previous transaction outputs. Before copying a scriptPubKey (the part of a Bitcoin output that locks funds) into a fixed-size buffer, the code now verifies the copy won't exceed the buffer's maximum length when combined with how much has already been written. Without this check, a malformed or oversized scriptPubKey could overflow the buffer, potentially corrupting memory and affecting the device's behavior. The commit also fixes two nearby variables from 'bool' to 'int' so parser error codes are preserved instead of being collapsed to true/false.

This commit changes how the Ledger Bitcoin app reports failures when deriving public keys from a BIP32 path. Previously, almost any derivation failure was reported as a generic 'bad state' error. Now, the app distinguishes between different underlying error codes, specifically mapping two SDK error codes (0x4212 and 0x4215) to a 'not supported' status word instead of 'bad state'. This is a defensive hardening change: it gives callers more accurate error information and avoids misleading 'bad state' responses for permission or policy-related derivation failures. There is no direct evidence in the commit of an exploitable vulnerability being fixed.

This commit fixes a buffer-size mismatch in the Ledger Bitcoin app. A function that derives secret keys was being asked to write 64 bytes of output into a caller-supplied 32-byte buffer. The patch now provides a 64-byte temporary buffer and copies only the needed 32 bytes afterward, then securely wipes the temporary buffer. The original bug could have caused memory corruption or leaked key material, depending on how the SDK behaves when given an undersized buffer.

This commit only changes automated test code for the Bitcoin app's message-signing feature. It adds a new test for messages containing a line feed (LF) character and updates an existing test to use a carriage return (CR) instead of a line feed. There is no change to the actual app code that runs on the Ledger device, so this commit does not introduce or fix a security vulnerability by itself.

This commit changes how the Ledger Bitcoin app decides whether a message being signed is 'printable' on the device screen. It now allows the Line Feed (newline) character to pass through, because the newer NBGL screen library can display multi-line text. Previously, any character outside the normal visible ASCII range would make the message be shown as a hex dump instead of readable text. The change is a small UI/UX improvement for message signing and does not appear to alter the actual cryptographic signature.

This commit only updates test screenshot images (snapshots) for the Ledger Bitcoin app's message-signing user-interface tests. It does not change any application source code, cryptographic logic, or device behavior. The snapshots reflect a switch to the 'classical NBGL API' for message signing, but this is a test-asset update, not a security-relevant code change.

This commit refactors how the Ledger Bitcoin app displays messages before signing. It replaces a streaming, paginated message-review flow with a single-page review using the standard NBGL API. The change increases the maximum message that can be shown from about 128 bytes to roughly 640 bytes, and removes the intermediate 'loading' start page. There is no direct evidence in the commit that this fixes a security vulnerability; it appears to be a user-interface simplification. However, any change to the confirmation screen logic can affect whether users correctly see what they are signing, so it warrants careful review.

This commit is a minor user-interface wording change. It replaces the generic spinner text 'Signing' with the more descriptive phrase 'Signing transaction' shown while the device is computing a Bitcoin transaction signature. There is no change to cryptographic logic, transaction validation, or security behavior.

This commit fixes a defensive coding issue in the Ledger Bitcoin app. A function that derives a secret key from a text label could overflow an internal 32-byte buffer if given a label longer than 32 bytes. In practice, the app only ever passed one fixed short label, so the overflow was not reachable from normal use. The patch now rejects oversized labels and also handles the rare failure case when generating a wallet security code (HMAC).