Blockstream Jade

This is a small compatibility fix for the Python Jade library so it works with both older and newer versions of the cbor2 serialization library. Newer cbor2 changed which exception it raises when data runs out, so the code now detects the available exception type and catches the right one. It is a robustness improvement rather than a fix for an active security vulnerability.

This is a small fix to a developer helper script (format.sh) used during code formatting. It prevents the script from trying to move a temporary file into place when a configuration-file check fails or never creates that temporary file. The change is about avoiding a build-tool error, not about stopping an attacker or protecting user funds.

This commit removes a custom bitmap-drawing function used only in the libjade build and makes that build use the same drawing path as other configurations. It is a code cleanup with no visible security relevance.

This commit fixes a small but real bug in Blockstream Jade's USB/serial message handling. A variable that decides whether a version-info message should get an immediate reply was not given a safe starting value. In C, that means it could accidentally contain leftover garbage data, causing the device to reply immediately when it shouldn't. The fix simply sets that variable to 'false' by default. This is a defensive hardening change; there is no public evidence it has been exploited.

This small change makes the 'precision' number in asset metadata optional, defaulting to 0 if missing. Previously, the code may have treated a missing precision field as a failure. The patch uses a wrapper that explicitly ignores any error from reading the field, which could hide unexpected parsing problems. There is no direct evidence this is exploitable, but silently ignoring errors can make future bugs harder to detect.

This commit is a preventive build-hardening change. It adds compiler annotations (WARN_UNUSED_RESULT) to many functions that return success/failure codes, so the compiler will warn if a caller ignores the result. The goal is to catch future bugs where an error return is silently dropped, but the commit itself does not fix any specific known bug or change runtime behavior.

This commit adds compiler flags and helper macros to make the build fail whenever a function's return value is ignored without explicit intent. It is a hardening change, not a fix for a specific known bug. By enforcing that programmers check or deliberately discard return values, it reduces the chance that silent failures (for example, a failed security check or memory operation) slip into future code. There is no direct evidence in the commit that an existing vulnerability is being patched.

This commit adds a safety check to Blockstream Jade's 'sign identity' feature. Before the change, the device would accept any identity string a connected app sent. Now it rejects identities that contain non-printable or unusual characters. This reduces the risk that a malicious or buggy app could trick the user into signing an identity they did not intend to, or could smuggle control characters into a string shown on the device's screen.

This commit tightens error handling when decoding the 'issuer' field of an OTP (one-time password) setup URI. Previously, a malformed issuer string could fail to decode silently; now the device shows an error and cancels the operation instead of continuing with potentially bad data. It also makes minor logging message changes and adds an assertion for the label/issuer decode in the display code.

This commit fixes a small but meaningful bug in how Jade, a hardware wallet, reads key paths from Bitcoin PSBT data. The code was passing the byte size of a buffer when it should have passed the number of 32-bit entries. Depending on how the underlying library interprets that value, this could lead to reading truncated paths, rejecting valid transactions, or possibly reading past the intended buffer. It is a defensive fix in security-sensitive parsing code, but the commit itself does not claim a specific exploitable vulnerability.

This commit is a minor code cleanup in the USB storage feature of the Blockstream Jade hardware wallet. It changes two functions so they return nothing (void) instead of a true/false value, because the returned value was never actually used. There is no security-relevant change here.

This commit fixes a logic gap in how Blockstream Jade checks cryptographic commitments for transaction outputs during signing. Previously, the code treated a missing commitment the same as an invalid one, which could cause the device to reject valid transactions or accept improperly validated ones. The change aligns this code path with the existing sign_tx logic, making output commitment handling consistent and more secure.

This commit changes the declared return type of a transaction-signing helper function from a transaction-type code (TxType_t) to a simple success/fail boolean (bool). The function body already appears to return true/false, so the change fixes a type mismatch between the function's implementation and its header. In plain terms, the code was telling the rest of the program 'I return a transaction type' while actually returning 'yes/no' answers; this patch makes the two match. That kind of mismatch can confuse the compiler and, in rare cases, lead to wrong decisions about what kind of transaction is being signed, but the diff itself is tiny and only shows the declaration/header change, not the full function body or any callers.

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