BitBox02 firmware

This commit is a small internal cleanup in the BitBox02 firmware's Rust code. It removes a duplicate definition of a 'user cancelled' error type used when the user aborts an SD card insertion prompt, and makes all code use a single shared 'UserAbort' type instead. There is no change to user-facing behavior or security.

This commit is a routine internal code cleanup. It removes a small, dedicated 'cancel' error type and replaces it with an existing, equivalent 'UserAbort' type in the hardware abstraction layer (HAL). The goal stated by the developer is to make the HAL self-contained so it can later be moved to its own crate. There is no change to user-visible behavior, no bug fix, and no security-related change.

This commit is a simple internal code reorganization. It moves a small user-cancelled error type (UserAbort) from one Rust module to another so the hardware abstraction layer (HAL) can eventually become its own separate crate. No security behavior changes; only import paths and type references are updated.

This commit is a straightforward internal code cleanup. It replaces one definition of a user-cancellation error type with another identical one so that a hardware abstraction layer can be moved to its own crate. There is no change to user-facing behavior, security logic, or how transaction approvals and rejections are handled.

This is a small internal code cleanup: a helper function that displayed a list of recovery words for the user to pick from was moved from one Rust module into another and the old copy was deleted. The actual on-device behavior is unchanged, and there is no indication of a security bug being fixed.

This commit is a simple code cleanup: it moves the logic for displaying a recovery phrase (mnemonic) from a shared helper function directly into the device's user-interface layer, and removes the now-unused helper. There is no change in behavior, no bug fix, and no security-relevant change.

This commit is a straightforward internal code cleanup: it removes a thin Rust wrapper around a three-option user-interface prompt and calls the underlying function directly. There is no visible change in behavior, no bug fix, and no security-relevant change.

This is a routine code cleanup: a small helper function for showing a word menu was moved and the old wrapper module was deleted. There is no security-relevant change visible in the diff.

This commit is a simple internal code cleanup. It moves the logic for handling an SD card prompt from a separate wrapper function directly into the device's user-interface HAL layer. The actual behavior—waiting for the user to insert an SD card or cancel—does not change. There is no visible security fix or vulnerability here.

This commit is a small code cleanup: it moves the logic for entering a string on the BitBox02 device from a shared helper function directly into the device's user-interface layer, and removes the now-unused helper. There is no visible security change in behavior.

This commit is a simple internal code cleanup: it removes a tiny wrapper function that displayed status messages and calls the underlying status function directly instead. There is no user-facing change, no bug fix, and no security relevance visible in the code.

This commit is a simple internal code cleanup: it removes a thin wrapper function and calls the underlying UI confirmation directly. There is no visible change in behavior, no bug fix, and no security-relevant change.

This commit is a simple code cleanup: it moves the recipient-confirmation logic directly into the user-interface layer and removes a small wrapper function that was no longer needed. There is no change to security behavior, no bug fix, and no new feature.

This commit is a small internal code cleanup. It moves the logic that converts a user's approve/cancel response into a success or error result from a shared helper function directly into the user-interface implementation for the BitBox02 device. No behavior changes; no security relevance.

This commit is a pure code cleanup: it replaces hard-to-read byte-string literals in Ethereum test code with a more readable hex!() macro. The actual byte values are identical, and no production behavior changes. There is no security issue.

This commit is a straightforward internal refactoring: it moves a few memory-related reads and writes (Bluetooth enabled flag, device name, platform type) behind an existing hardware abstraction layer (HAL). The actual behavior of the firmware is unchanged; the code just calls the same underlying functions through a different interface. There is no indication of a security fix or vulnerability being addressed.

This commit is a software-architecture cleanup, not a security fix. It moves data types such as device platform, secure chip model, and password-stretching algorithm out of a low-level BitBox02-specific module into a new hardware-abstraction layer (HAL). The real hardware behavior is unchanged; only the internal Rust type names and error-conversion paths are different. A few error mappings were made slightly more precise (for example, a duplicate name now returns a clearer 'duplicate' error instead of a generic memory error), but these are minor refinements rather than vulnerability fixes.

This commit refactors how the BitBox02 hardware wallet handles U2F (Universal 2nd Factor) security-key workflows. It replaces an older polling-style task system with a new async executor and swaps several `static mut` global variables for safer building blocks from a vendored Rust crate called `grounded`. The change is mostly a code-quality and safety improvement: it removes deprecated `static mut` references and makes the U2F unlock/confirm workflows run as proper async tasks. There is no direct evidence in the commit message or diff that this fixes an active security vulnerability, but it reduces the risk of memory-unsafety bugs in a security-sensitive code path.

This is a routine build-system and toolchain update for the BitBox02 firmware. It adds support for a new ARM processor target (Cortex-M33), upgrades the Rust compiler, LLVM, and the ARM GNU toolchain, and pulls in newer versions of some third-party Rust libraries. There is no direct evidence in the commit of a security vulnerability being fixed or introduced. The main risk is the usual one with large toolchain and dependency updates: a small chance that compiler, library, or behavior changes could introduce subtle bugs, but nothing in the diff points to an exploitable flaw.

This commit is a routine internal code cleanup. It moves the logic for showing a short status message on the device screen from one Rust function to another and converts it to use the project's async/await pattern. There is no visible change in behavior: the status screen still appears for the same 2-second duration. Nothing in the commit suggests a security fix or vulnerability.

This commit adds an optional mode for signing Ethereum typed messages (EIP-712) that skips the anti-klepto protocol, falling back to normal deterministic signatures. The change is intentional and documented: some DeFi apps need signatures that are reproducible by other wallets, which the anti-klepto protocol prevents. The feature is gated behind a new host flag and requires firmware v9.26.0 or newer. It does not remove anti-klepto from other signing paths such as Bitcoin or regular Ethereum transactions.

This commit refactors how random numbers are generated during the backup verification workflow. Previously, the code called a low-level device function directly; now it uses a hardware abstraction layer (HAL) interface so the same code can be tested with a mock random source. The change itself is a code-quality/testability improvement and does not appear to fix an active security vulnerability, but it touches the code that creates the random word-order challenges used to verify a user's seed backup.

This commit adds a new method called mcu_32_bytes to the random number generation abstraction layer in the BitBox02 firmware. It is a straightforward code addition that exposes an existing microcontroller random function through the Rust hardware abstraction layer, and adds corresponding test support. There is no indication this fixes or introduces a security vulnerability.

This commit is a routine internal code cleanup in the BitBox02 firmware's Rust hardware-abstraction layer. It restructures how subsystems (screen UI, random number generator, SD card, secure chip, memory, system control) are accessed so that multiple subsystems can be borrowed at the same time. The stated reason is to let the user-interface code use the random generator for a mnemonic quiz feature. There is no security fix or vulnerability patch here.

This commit is a code cleanup in the BitBox02 firmware's Ethereum transaction signing module. It replaces a generic/template-based approach with dynamic dispatch (using Rust trait objects) to reduce firmware size by about 1,776 bytes. There is no indication in the commit or supplied references that this fixes a security vulnerability or changes security-relevant behavior.