BitBox02 firmware

This commit is purely a code-style and build-maintenance change. It makes the Rust code generated from protocol-buffer definitions be formatted by rustfmt automatically and included in style checks. No security-sensitive behavior is changed.

This commit is a build-system and code-organization refactor. It moves the automatically generated Rust protobuf message definitions from inside the main bitbox02-rust crate into a new, separate bitbox-proto crate. It also switches the generation flow from CMake to Cargo, adds a CI check to ensure the committed generated files stay in sync with the .proto source files, and avoids touching timestamps when regeneration produces identical output. There is no change to the actual device firmware logic or to how messages are parsed and validated.

This commit is a straightforward code cleanup: it changes the return type of password-stretching functions from a variable-length byte list to a fixed 32-byte array, because the result is always exactly 32 bytes. The change makes the code clearer and lets the compiler enforce the size, but it does not fix any security bug or change behavior.

This commit is a user-interface polish change for the BitBox02 hardware wallet. It replaces a generic 'waiting' spinner with the first frame of the unlock animation while the device is busy stretching the user's password. There is no security vulnerability or fix here—only a visual improvement to make the device look smoother during unlock.

This commit rewrites how the BitBox02 hardware wallet performs a key-derivation operation inside its secure chip (OPTIGA). Previously the operation was synchronous and wrapped in C; now it is asynchronous and called from Rust through the existing async command bridge. The change touches many files because every caller of the KDF/keystore functions had to be updated to `await` the result. The diff itself is a large refactoring with no obvious security bug, but it introduces new async machinery around a sensitive cryptographic operation, so it warrants careful review for memory-safety and concurrency issues.

This commit is a code cleanup in the BitBox02 firmware's Rust code. It changes how random numbers are supplied when creating cryptographic keys for the Noise protocol, moving from a device-specific random type to a more generic hardware abstraction layer (HAL) random source. The commit message and diff do not describe this as fixing a security bug; it reads as an architectural refactor to simplify dependencies. There is no direct evidence in the commit that the old code was exploitable or that any vulnerability was fixed.

This commit is a routine code reorganization: it moves two small helper modules (one for generating random bytes, one for salting/hashing data) from an existing Rust crate into a new shared workspace crate named bitbox-core-utils. The actual logic, algorithms, and behavior are copied unchanged; only the file paths and import names are updated. There is no indication this fixes or introduces a security vulnerability.

This commit changes how the BitBox02 hardware wallet generates random numbers used to create secret keys and encrypt stored data. Previously, the firmware used a single 32-byte random value from the microcontroller. After this change, it mixes three sources: the microcontroller's random generator, the secure chip's random generator, and a fixed 32-byte 'factory randomness' value stored in a special flash memory location. The commit also adds a factory script to write that fixed value into devices during production. The change is a defensive hardening measure, not a fix for an active bug, but it introduces a new dependency: if the factory randomness is not actually random or is reused across devices, it could weaken security instead of strengthening it.

This commit changes how the BitBox02 hardware wallet warns users about very large Ethereum transaction data and typed messages. Previously, large transaction data was shown only as a byte count with the message 'too large to display.' Now the device shows a preview of the actual hex data (up to the screen limit, with a '...' truncation indicator) and adds a warning screen saying the value is too large to display in full. The change also reuses the same truncation logic already used for EIP-712 typed messages, so both flows behave consistently. The commit does not fix a vulnerability, but it improves the user's ability to inspect what they are signing.

This commit is a code-quality refactor for unit tests only. It introduces a small Rust helper macro called async_test::test that lets developers write async test functions directly, instead of manually wrapping async code in a block_on() call. The change touches many test files but does not alter any production firmware behavior, user-facing functionality, or security logic.

This commit adds a new optional 'payment request' field to Ethereum EIP-1559 signing requests in the BitBox02 firmware's protocol definitions and generated code. It does not contain any actual implementation of how that field is processed, validated, or shown to the user. Based only on the code changed here, there is no identifiable security vulnerability.

This commit rewrites the firmware's USB report queue from C to Rust. It is a large refactoring that replaces a hand-written C ring buffer with a Rust VecDeque wrapped in a C-compatible FFI. The change touches the core USB communication path used by both the main hardware wallet (HWW) and U2F interfaces. There is no explicit security bug fixed or introduced in the diff, but any mistake in the boundary between C and Rust could affect how the device receives and sends USB messages.

This commit extends an existing Ethereum data-streaming feature so it also works for EIP-712 typed messages with large data fields (e.g., a 50 KB 'bytes' field). Previously, only large Ethereum transaction data could be streamed in chunks; now the same chunking is applied to typed-message values. The change also improves on-screen display of long values by warning the user when a value is too large to show in full and by showing an ellipsis. It is a feature addition with defensive input checks, not a fix for a known vulnerability.

This commit adds a new graphical simulator for the BitBox02 hardware wallet using the LVGL UI library. It is a large development-only change that introduces simulator code, vendored Rust dependencies, and build configuration updates. There is no indication it fixes a security bug or introduces a security vulnerability in the firmware itself.

This commit is a large revert that removes a previously added graphical simulator feature (LVGL init) from the BitBox02 firmware repository. It deletes the LVGL submodule, vendored Rust dependencies, simulator code, and related build files. There is no indication in the commit message or diff that this change fixes a security vulnerability; it appears to be a routine rollback of an unfinished or unwanted feature.

This commit adds a new graphical simulator for the BitBox02 hardware wallet using the LVGL UI library. It is a large development-only change that introduces simulator code, vendored Rust dependencies, and build tooling. There is no indication from the commit title, message, or diff that this fixes or introduces any security vulnerability.

This is a minor Python import cleanup in a developer/test script. It changes how one internal class is imported so that the script works reliably when installed in 'editable' mode. There is no security issue here.

This commit hardens the project's automated CI workflow in two ways: it pins a third-party Mattermost notification action to a specific, unchangeable version (instead of a moving 'master' branch), and it restricts the job's GitHub token permissions to read-only access to repository contents. These are defensive security improvements that reduce supply-chain and privilege risks, but the commit itself does not fix an active vulnerability.

This commit swaps out an old C ringbuffer for a new Rust-based byte queue used to hold data sent to the Bluetooth chip. The change touches many files but is mostly a rewrite/refactor. It removes several explicit 'will it fit?' size checks before adding data to the queue, and it changes how callers pass the queue around. The Rust ByteQueue implementation itself is not shown in the diff, so we cannot verify whether it safely handles overflow, memory allocation failures, or concurrent access. The change is therefore a security-relevant refactor with some risk, but no proven vulnerability is visible in the supplied commit.

This commit adds a new 'coin purchase memo' feature to BitBox02 payment requests. It lets a payment request include details about a separate coin purchase (e.g., '0.25 ETH to address 0x...') and verifies that the listed Ethereum address really belongs to the wallet by deriving it from a provided keypath. The change is mostly a feature addition, but it introduces cross-currency validation logic and a TODO noting that the user-interface confirmation for this new memo type is not yet implemented.

This commit only cleans up test code by removing unnecessary calls to a mock memory setup function. It does not change the actual firmware that runs on the BitBox02 device, so it has no security impact on users.

This commit is a straightforward internal code refactor. It introduces a new 'KeystoreHal' adapter so that the keystore code can borrow only the hardware subsystems it needs (memory, random number generator, secure chip) instead of borrowing the entire HAL, which also contains the user interface. The stated reason is to allow a UI animation to run in parallel while the device unlocks. There is no change to security logic, cryptography, or user-facing behavior.

This is a small internal code cleanup in the BitBox02 firmware's Rust code. It changes a helper function so it borrows only the memory/storage part of the hardware abstraction layer, rather than the whole hardware abstraction layer. The commit message says this is preparation for a future change where the user interface part of the hardware layer will be used at the same time during wallet unlocking. There is no direct security fix here and no vulnerability is described.

This commit is a routine internal code cleanup. It moves the definitions of confirmation-screen parameters and fonts out of the workflow layer and into the hardware-abstraction (HAL) layer, then updates all call sites to use the new names. There is no change to user-facing behavior, no bug fix, and no security vulnerability being addressed.

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.