BitBox02 firmware

This commit swaps out an internal cryptographic library dependency. The firmware previously used a library called libwally-core, which bundled a special version of the secp256k1 elliptic-curve code. The change removes libwally-core and uses secp256k1-zkp directly. This is a build-system and dependency refactor, not a fix for a known attack. It slightly reduces firmware size and changes how the code is compiled and linked. There is no direct evidence in the commit that this resolves a security vulnerability, but any change to core crypto code carries a small risk that build settings could alter behavior.

This commit only changes a unit test file. It swaps one way of getting a test private key (from an older C library called libwally) for another way (from the project's newer Rust code). The actual device firmware and security logic are not changed. There is no indication this fixes or introduces a security bug.

This commit is a routine internal cleanup: it changes a cryptographic signing helper so that callers pass in the secp256k1 library context explicitly, instead of the function fetching that context itself from an internal helper. There is no direct security fix here and no evidence of an exploitable bug being patched. It is a step toward removing a dependency on an old wrapper function (`wally_get_secp_context()`).

This commit is a small internal cleanup: it changes a Bitcoin signing function so that the caller provides the cryptographic context, instead of the function fetching its own. There is no visible bug fix or security patch in the diff itself, and no security relevance is stated by the vendor.

This commit is a routine internal cleanup: it changes a cryptographic helper function so that callers pass in the secp256k1 context explicitly, instead of the function fetching a global context internally. There is no direct security vulnerability visible in the diff. It is part of a gradual migration away from an old context accessor (`wally_get_secp_context()`).

This commit is a small internal cleanup in the BitBox02 hardware wallet firmware. It changes how the code passes the cryptographic context (specifically for secp256k1 elliptic-curve operations) from using a shared context provided by an older library (libwally) to using a Rust-managed context. The functions themselves and the underlying cryptographic operations remain the same. There is no direct evidence in the commit that this fixes an exploitable security vulnerability.

This commit is a small internal cleanup in the BitBox02 firmware's silent-payment code. It replaces a locally-created secp256k1 cryptographic context with a shared global one. There is no direct evidence in the commit that this fixes an exploitable security bug; it appears to be a code-quality and consistency change.

This commit is a performance optimization for the BitBox02 hardware wallet firmware. It replaces repeated creation and destruction of a cryptographic context (used for Bitcoin's secp256k1 elliptic-curve operations) with a single global context that is initialized once and reused. There is no indication in the commit that this fixes a security vulnerability; it is described purely as an efficiency improvement.

This commit is a pure refactoring: it renames the test-only 'hardware-mocks' directory and all related function names to 'hardware-fakes' across build files, source code, and unit tests. No production firmware behavior changes, no security fixes, and no vulnerability is introduced or patched.

This commit is a pure internal test-code refactor. It moves CMocka-specific mock functions out of a shared hardware-mocks library and into the unit-test directory so that the simulator no longer depends on the CMocka testing framework. No production firmware code is changed, and nothing in the commit affects the security of the shipped BitBox02 device.

This commit is a large but purely organizational change: it moves all vendored (third-party) Rust dependencies from the `src` directory to a new `external/vendor` directory. Only two small configuration files were actually modified: `.cargo/config.toml` (to point Cargo at the new vendor directory) and `external/vendor-rust.sh` (a helper script). The millions of added and removed lines are just the same dependency files being relocated, not new code. There is no visible change to the firmware's behavior or security logic.

This commit is a routine code cleanup in the BitBox02 hardware wallet firmware. It removes an old wrapper around a C-language SHA-512 function and switches the Rust code to use a pure-Rust SHA-512 implementation from the `bitcoin::hashes` library. It also removes an unused feature flag and simplifies dependencies. There is no direct evidence in the commit that this fixes a security vulnerability.

This commit swaps the cryptographic hashing and HMAC functions used throughout the BitBox02 firmware from the libwally library to equivalent Rust implementations. The goal is to remove the libwally dependency. The change touches sensitive code paths such as seed stretching, U2F key generation, and secure-chip authorization, but the commit itself does not claim to fix any security bug. The main risk is that any subtle difference in behavior between the old and new implementations could affect how keys are derived or how the device authenticates, though the diff shows no obvious vulnerability.

This commit updates the BitBox02 firmware's Rust code to use Rust's built-in C type definitions instead of a custom module. The commit message notes a bug: the custom module incorrectly defined 'unsigned int' as 64 bits on 64-bit systems, when it should always be 32 bits. The change removes the buggy custom type definitions and switches to the standard Rust core::ffi types. This is primarily a code-quality and correctness fix, but the wrong type sizes could have caused subtle memory or interface mismatches between Rust and C code, especially during testing on 64-bit computers.

This is a tiny build-configuration fix for a specific BitBox02 hardware variant (the 'BitBox02 Plus' platform used in Nova bootloaders). The change removes two optional Rust dependencies that were accidentally enabled for that platform. The commit message says those dependencies are not needed there. There is no direct evidence in the commit of a security vulnerability; it looks like a cleanup to avoid compiling unnecessary code in the bootloader.

This commit simply moves a helper function that looks up a BIP39 word by its index from one Rust module to another. The code itself is unchanged, and there is no indication of a security fix or vulnerability.

This commit replaces the BIP39 (seed phrase) implementation inside the BitBox02 hardware wallet from one library (libwally-core) to another (rust-bip39). The main user-visible reason is speed: unlocking the device is now faster, so the unlock animation was shortened. The change touches how seed phrases are converted to cryptographic seeds and how individual BIP39 words are looked up. There is no direct evidence in the commit that this fixes a known security bug, but any change to cryptographic code can introduce subtle risks, so it deserves careful review.