Keystone 3 firmware

This commit is a code review and cleanup of the Cosmos cryptocurrency support in the Keystone 3 hardware wallet firmware. It fixes several small but real issues: it corrects a buffer-size mismatch when copying passwords/passphrases into memory, avoids unnecessary cloning of transaction data, adds zeroing of the seed buffer after signing, and fixes memory leaks and repeated JSON parsing in the Cosmos UI code. There is no clear evidence of an exploitable remote attack, but the changes reduce the chance of memory corruption and secret leakage.

This commit is a code-quality and hardening review of the Aptos blockchain support in the Keystone 3 hardware wallet firmware. It adds input validation (e.g., public keys must be exactly 32 bytes), removes risky simulator-only code paths that could dereference null pointers, fixes memory leaks and seed-handling bugs, and tightens how derivation paths and master fingerprints are extracted from signing requests. There is no explicit vendor statement that these changes fix a security vulnerability, but several of the corrected patterns are classic sources of bugs that could affect wallet safety.

This commit is purely a code-formatting cleanup. It removes blank lines containing only whitespace and rewraps long lines in test code, plus one trivial comma removal in a Rust C wrapper. There is no change to program logic, no bug fix, and no security relevance.

This commit is mostly a routine addition of unit tests for Zcash transaction parsing. However, it also makes a small but meaningful security improvement in three C-callable Rust functions: after using the wallet's master seed, the code now explicitly wipes that seed from memory with `zeroize`. Previously the seed bytes could remain in memory after use, slightly increasing the risk that a sophisticated attacker with memory access could recover them. The change is defensive and reduces a real information-disclosure risk, but it is partial because many other seed-handling functions in the same file still do not zeroize.

This commit is mostly a routine cleanup and test-addition patch for Zcash support in the Keystone 3 firmware. It adds many Rust unit tests for error handling, PCZT parsing, and data structures, fixes a Cardano test that had an empty expected value, removes a stray blank line, and refactors the Zcash signing UI flow to use a shared internal helper. There is no direct evidence in the diff of a security vulnerability being fixed.

This commit only reorders two Rust import/use statements in a single source file. It makes no functional change to the code and does not affect program behavior or security.

This commit only adds new automated tests for existing Zcash parsing and formatting helper functions. It does not change any production code, fix bugs, or alter behavior. There is no security issue here.

This commit is a code-review hardening pass for the Cardano wallet module in the Keystone 3 firmware. It replaces many Rust `.unwrap()` calls with proper error handling, adds bounds checks for derivation paths and public keys, zeroizes sensitive seed/entropy buffers after use, and fixes a seed-length bug for BIP39 vs SLIP39 accounts. Most changes reduce the chance that malformed transaction data or missing key material causes a crash or leaks secrets, but the commit is broad and includes many test additions, so it is better characterized as defensive cleanup than a single fixed vulnerability.

This commit only adds unit tests to the Aptos Rust app. It does not change any production code, so it cannot introduce a security vulnerability or fix one. The tests exercise existing functions for address generation, transaction parsing, message decoding, signing, and various data-type helpers.

This commit only renames some Rust source directories from capital letters (C_chain, P_chain) to lowercase (c_chain, p_chain). The actual code inside the files is unchanged. It is a cosmetic cleanup with no security relevance.

This commit is a code review and cleanup pass for the Avalanche (AVAX) app in the Keystone 3 hardware wallet firmware. It fixes typos in transaction type names, adds a few length checks before reading transaction bytes, replaces direct low-level signing with a safer helper, and consolidates signing code so AVAX, IOTA, and SUI share the same secure path. Most changes are defensive hardening and refactoring rather than a single obvious critical bug fix.

This commit only changes test code for the Avalanche app. It adds two new unit tests for address encoding and HD path validation, and corrects one existing test assertion about which blockchain ID an export transaction should return. There are no changes to production code, so this does not fix or introduce a runtime security issue.

This commit only adds new automated test cases for the XRP app in the Keystone 3 firmware. It does not change any production code, fix bugs, or alter behavior. The tests exercise functions like address derivation, transaction parsing, signing, and public-key path lookup with valid and invalid inputs. There is no security patch or vulnerability present in the diff itself.

This commit is purely a code cleanup: it removes an unused duplicate import in an Avalanche test file and applies formatting (whitespace and line wrapping) to XRP test files. There are no functional code changes, no bug fixes affecting runtime behavior, and no security-relevant modifications.

This commit fixes a bug in the Solana address generation code for the Keystone 3 hardware wallet. Previously, if a public key was the wrong length (not 32 bytes), the code would create an error message but then ignore it and continue, producing an address from bad input. Now it correctly stops and returns the error. This prevents malformed or attacker-chosen keys from being silently accepted and turned into a Solana address.

This commit only adds new test cases to an existing Rust test file. It checks that the Ed25519 key derivation function correctly rejects invalid or non-hardened derivation paths and that a path missing the leading 'm/' still produces the expected key. No production code was changed, so this is a routine test improvement rather than a security fix or vulnerability.

This commit removes an unused C language label named 'out:' from a function in the RSA cryptography file. The label appears to have been leftover code with no actual security effect, because nothing in the function jumps to it and the cleanup logic runs unconditionally anyway. There is no indication this change fixes or introduces a security problem.

This commit refactors the Sui blockchain support in the Keystone 3 hardware wallet firmware. The main security-relevant changes are: replacing several panic-prone `.unwrap()` calls with proper error handling, adding checks for empty derivation paths that previously could have caused crashes or undefined behavior, validating public key length during address generation, and ensuring the wallet's seed is wiped from memory (zeroized) more reliably after signing. The commit also fixes a memory-freeing bug in the user interface where the wrong type of result could be freed depending on whether a normal transaction or a 'sign message hash' request was being handled.

This commit is purely a code formatting cleanup. It removes extra blank lines and rewraps function-call formatting in two Rust files. No program logic, security checks, or behavior changed.

This commit only adds new unit tests to the Sui app in the Keystone 3 firmware. It does not change any production code, fix bugs, or alter behavior. The tests check things like UTF-8 decoding rules, address generation error cases, intent parsing, and signature determinism. There is no security issue in the commit itself.

This commit updates the Rust zeroize library from version 1.8.1 to 1.8.2 in a cryptocurrency hardware wallet firmware project. The zeroize library is used to securely erase sensitive data like private keys from memory after use. The commit also adds a large Chinese-language technical specification document for Sui blockchain support. The actual code change is a routine dependency patch with no direct exploit visible in the diff, but the commit message claims it is for 'improved security features.'

This commit is a defensive security hardening patch for the Keystone 3 hardware wallet firmware. It adds the `zeroize` Rust crate and explicitly clears sensitive memory buffers (mnemonics, seeds, passwords, RSA seeds, entropy, SLIP39 shares) after use. It also replaces many unsafe `strcpy`/`strcat`/`memcpy` calls with safer bounded versions, removes several `unwrap()` panic points in Rust FFI code, and tightens error handling in wallet creation and recovery flows. The changes reduce the risk that secret material remains in RAM after operations, and reduce the chance that malformed input crashes the device or leaks secrets through panic paths.

This commit hardens how a hardware wallet (Keystone 3) handles sensitive RSA prime numbers used for Arweave transactions. It adds explicit length checks on seeds and prime inputs, switches to a safer memory-clearing helper (`zeroize` in Rust, `memset_s`/`CLEAR_ARRAY` in C), and removes an unused RSA helper that could have accepted arbitrary-length secrets. The changes reduce the risk of crashes, memory leaks of secret material, and misuse of malformed keys, but the commit itself is a defensive refactor rather than a fix for a confirmed active exploit.

This commit only adds new automated tests for Ed25519 key derivation and signing functions. It does not change any production code, so it cannot introduce or fix a security vulnerability on its own.

This commit hardens how the Keystone 3 firmware derives Ed25519 private keys from a recovery seed. It now requires seeds to be at least 16 bytes, scrubs sensitive intermediate values from memory after use, and switches the Monero app to use the project's shared zeroize dependency. These are defensive improvements that reduce the risk of leaking secret key material, but the commit does not claim to fix an active exploit.