Ledger Bitcoin app

This commit is a routine cleanup of the project's unit-test code. It removes duplicate mock implementations of a small helper function called `pic()` from 14 test files and places a single shared version in a mock header. The change only affects test code, not the actual Ledger Bitcoin app that runs on devices. The commit message says the cleanup was done to fix confusing code-coverage measurements. There is no indication this fixes a security vulnerability or changes how the app behaves.

This commit only adds new unit tests to the Ledger Bitcoin app. It does not change any production code, so it cannot introduce a security vulnerability or fix one directly. The tests exercise edge cases and adversarial inputs for functions that handle Merkle-tree preimages and BIP32 derivation extraction, which helps confirm existing defensive checks reject malformed data.

This commit is a small cleanup following a code review. It updates comments, adds safety checks to a test-only mock function, increases a test mock queue size, and adds a missing standard header include. None of the changes affect the real device firmware's security behavior.

This commit only adds new unit-test helper code and test cases. It does not change the actual Ledger Bitcoin app that runs on the device, nor does it fix or alter any production security logic. The new files parse PSBT data and mock dispatcher responses so developers can test the existing `extract_bip32_derivation` function in isolation. Nothing here is shipped to users or reachable by an attacker.

This commit is a performance optimization for the Ledger Bitcoin app. It reorders nested loops in two signing-related functions so that the app reads each transaction input's data once and then processes all relevant internal keys, rather than re-reading the input data once per key. The commit message and diff show no functional change—only a reduction in redundant work.

This commit only changes automated test files. It forces the test transactions to use Bitcoin transaction version 2 so that a test helper called combinepsbt works correctly. There is no change to the actual Ledger app code that users run, and no security fix or vulnerability is present in the diff.

This commit is a large but purely structural code cleanup: it splits the single large sign_psbt.c file into many smaller, focused source files under src/handler/sign_psbt/. The actual logic, function bodies, validation checks, and security-sensitive operations appear to be moved verbatim into the new modules, with only minor header/include adjustments and copyright-notice updates. There is no indication of a behavior change, bug fix, or security patch.

This commit is a straightforward internal code cleanup: it splits one large function into three smaller, well-documented helper functions and moves one data field into a shared state structure. There is no change to what the code checks, accepts, or rejects. It does not fix a bug or add a security feature.

This commit is a straightforward internal code cleanup in Ledger's Bitcoin app. It groups several pieces of wallet-policy data into a new 'account context' structure and updates all references accordingly. There is no change to how transactions are validated, signed, or shown to the user, and no security bug is fixed or introduced in the visible diff.

This is a small defensive update to the Python companion library for Ledger's Bitcoin app. It changes how the client handles unexpected data returned by a future version of the hardware app, so that the data is labeled as 'unknown' rather than being misread as a transaction input number. It is a robustness/future-proofing fix, not a patch for an active security flaw.

This commit only adds new test cases for an existing feature (MuSig multi-signature signing) in the Rust client test suite. It does not change any production code, cryptographic logic, or application behavior. The changes are purely in test files: extending the test harness to check two new kinds of returned data (public nonces and partial signatures) and adding recorded device communication data for two MuSig signing scenarios. There is no indication of a security fix or vulnerability.

This commit is a routine API update for the Ledger Bitcoin app's Rust client library. It changes what kind of data the library returns when a user signs a Bitcoin transaction (PSBT), so it can also return MuSig2 multi-signature material (public nonces and partial signatures) in addition to ordinary signatures. The commit message explicitly calls this a breaking change that requires a major release. There is no indication of a security bug being fixed or introduced.

This commit only changes test code for a Bitcoin descriptor helper. It updates existing test strings to use a newer standard derivation format and adds two new test cases (an empty multi-signature expression and a descriptor containing two separate multi-signature expressions). There is no change to production code, no fix, and no security-relevant behavior change.

This commit adds code to the Ledger Bitcoin app's Rust client that pre-processes wallet descriptors containing 'musig(...)' key groups before computing addresses. It implements a small BIP-327/BIP-328 key aggregation so the existing miniscript library can still parse the descriptor. It is a feature addition, not a reported vulnerability fix, but any new cryptographic code can introduce bugs that could cause wrong addresses or, in the worst case, weaken security if implemented incorrectly.

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 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 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 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 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 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 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 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 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.