Blockstream Jade

This commit tightens bounds checks in URL encoding/decoding functions used in Blockstream Jade, a hardware wallet. The changes fix potential off-by-one/out-of-bounds memory reads and writes when handling percent-encoded characters. Because Jade processes untrusted data (e.g., QR codes, USB messages, or companion-app URLs), a malformed URL fragment could previously trigger a buffer overread or, in encoding, a truncated/overwritten output buffer. The patch is defensive and partial: it improves checks but does not fully restructure the API, so residual risks from caller misuse remain possible.

This commit tightens how a Bitcoin hardware wallet (Blockstream Jade) validates the length of a child key path string before copying it into a fixed-size buffer. The change adds an explicit length check and uses the already-computed length rather than recomputing it after the copy. This appears to be a defensive hardening fix against a potential buffer overflow when handling wallet descriptors, though the commit message does not call it a security fix and no exploit details are provided.

This commit hardens error handling in a hardware wallet's key derivation code by wrapping two function calls with an assertion macro. Previously, if these functions failed silently, the device could continue with invalid or uninitialized cryptographic keys. Now the device will halt if those functions fail, preventing use of bad keys. The actual security impact depends on whether those failures were reachable in practice.

This commit fixes error handling in the QR-code backup feature of a hardware wallet. Previously, if generating QR fragments or scanning the verification QR failed, the code could continue with invalid data and wrongly tell the user the backup was verified. The patch now aborts on generation failure and only marks the backup as verified when the camera scan actually succeeds and matches the expected secret.

This commit fixes a bug in the Blockstream Jade hardware wallet's PSBT (Partially Signed Bitcoin Transaction) signing code. Previously, when the transaction's genesis block hash did not match the expected network, the code set an error message but accidentally continued processing instead of stopping. This one-line fix adds the missing 'return' so the device rejects mismatched transactions immediately. Without the fix, a user could potentially be tricked into signing a transaction on the wrong network, which might lead to loss of funds or confusion between mainnet and testnet/signet assets.

This commit fixes a missing 'goto cleanup' after a failed attempt to save encrypted key data during a debug handshake. Without the fix, the code would continue running after reporting an error, potentially leaving sensitive key material in memory or skipping cleanup steps. The change ensures the function exits cleanly and securely when storage fails.

This commit fixes a bug in the Blockstream Jade hardware wallet's one-time-password (OTP) registration feature. Previously, if no wallet seed existed, the device would log an error and show a reset message, but then accidentally continue with OTP registration anyway. Now it stops and cleans up properly. The direct security impact is moderate: continuing without a seed could have led to storing an OTP secret that the device could not properly protect or later use, but the commit itself does not show an attacker-controlled path to exploit this.

This commit fixes a bug in the PIN-change flow on Blockstream Jade hardware wallets. Previously, if re-encrypting the wallet keys with a new PIN failed, or if the user abandoned the PIN change, the code did not jump to cleanup as intended. Instead, it could fall through and continue executing subsequent code paths that were meant to be skipped. This could lead to incorrect state handling, potential use of stale or invalid key material, or confusing behavior after a failed PIN change. The fix adds explicit 'goto cleanup' statements so the function exits the sensitive section safely in both error and abandonment cases.

This commit hardens three logging functions so they stop immediately if formatting a log message fails, instead of continuing with a negative or zero length. Previously, a failed format could cause the code to pass an invalid length to network or serial send functions. The change is defensive and reduces the chance of unexpected behavior from malformed log data, but it does not appear to fix an active security vulnerability.

This commit adds a safety check to ensure the device can read its unique hardware identifier (MAC address) from a special chip memory area (efuse) before continuing startup. Previously, the code read the MAC address but ignored whether it succeeded. If that read failed, the device would continue running with an uninitialized/empty MAC address, which could cause operational problems or weaken security features that rely on a unique device identity. The fix makes the device halt with an error if the MAC cannot be read.

This tiny change makes the device firmly check that the screen successfully powers on during startup, rather than silently continuing if something goes wrong. It is a defensive hardening fix, not a clear-cut vulnerability patch. The commit message and diff do not describe any attack or security incident.

This commit fixes two error-handling bugs in Blockstream Jade's multisignature wallet code. In one case, an invalid multisig wallet record was detected but the function kept running instead of returning immediately, which could lead to using corrupted wallet data. In the other, a path-validation failure was silently ignored, so a bad signer path might be accepted. Both are correctness fixes that improve safety, but the diff alone does not prove they are exploitable attacks.

This commit tightens validation when a Bitcoin hardware wallet reloads saved 'descriptors' (recipe-like data that describes how coins can be spent). It changes several length checks from 'greater than' to 'greater than or equal to', and adds a cap on the number of stored values. The change prevents a stored descriptor from claiming a length exactly equal to the fixed buffer size, which could leave the buffer without a terminating zero byte and cause memory corruption or crashes when the data is later used. Because the data is reloaded from the device's own storage, exploitation likely requires an attacker who can already tamper with stored data or trick the user into registering a malicious descriptor.

This commit fixes a bug in the Blockstream Jade hardware wallet's attestation signing process. Previously, if signing the attestation challenge failed, the device would send an error message but then continue running the rest of the function anyway, potentially sending an invalid or uninitialized reply back to the caller. The fix ensures the function stops immediately after reporting the error.

This commit fixes a small but real bug in the device attestation setup code for Blockstream Jade, a hardware crypto wallet. When a one-time programmable security fuse failed to burn, the code used to exit immediately without releasing memory or undoing earlier setup steps. The fix makes it jump to a cleanup routine instead. The direct risk is mainly a resource leak or partial initialization state on a rare hardware failure, not an obvious remote attack.

This change makes the Jade hardware wallet library wipe sensitive key material from memory when the library is stopped. Previously, stopping the library may have left private keys or seed data sitting in memory, which could be read by other software or later code running on the same device. The fix adds a single cleanup call when libjade_stop() runs.

This commit is a routine build-script maintenance change for the QEMU Docker container used to emulate the Jade hardware wallet. It merges two build commands into one so the ESP-IDF environment stays activated, and updates the container command syntax for newer Docker versions. There is no indication this affects the security of the actual Jade firmware or real devices.

This commit fixes a bug where a memory-backed file handle could fail to open, but the code immediately tried to use and close it anyway. If opening failed, the program could crash or behave unpredictably when handling asset contract data on a Blockstream Jade hardware wallet. The fix checks whether the file handle was created successfully before using it.

This commit only updates the project's test file (test_jade.py). It adjusts test cases and adds new tests for how Bitcoin/Liquid wallet descriptors are parsed and validated, including new rules around SLIP-77 blinding keys on Liquid. There is no change to production firmware or wallet code in this commit, so it does not introduce or fix a runtime security vulnerability by itself.

This commit only adds a new test case to the device's self-check suite. It exercises Liquid Bitcoin descriptor parsing and checks that blinding keys and script outputs are produced correctly. There is no change to production code, no bug fix, and no security-relevant behavior change.

This commit adds support for Liquid confidential descriptors to the Blockstream Jade hardware wallet. It is a feature addition, not a fix for a known vulnerability. The code introduces new validation rules that reject non-SLIP77 blinding keys on Liquid and reject confidential descriptors on Bitcoin. It also shows the blinding key on the device screen during wallet registration and management. The feature is gated so it is only active in debug builds unless explicitly enabled at compile time.

This commit updates an internal dependency (libwally-core) to a newer version so that Blockstream Jade can support Liquid descriptors. No actual code changes are shown, and the commit message describes only a feature addition, not a security fix.

This commit only changes a test file. It fixes how a multi-signature wallet test is structured so that wallet registration happens inside the test loop and so that blinding-key and commitment checks run for each wallet separately. There is no change to the actual Jade firmware or wallet code that users rely on.

This commit only changes the project's internal test script. It adds a command-line option that lets developers run a subset of test cases by matching JSON fixture filenames with a glob pattern. There is no change to the actual Jade firmware, wallet logic, cryptography, or any code that end users run on the device.