Keystone 3 firmware

This commit only changes a code comment in a Zcash-related Rust file. It does not modify any actual program logic, function behavior, or memory-management code. The new comment explains more clearly that certain memory must be freed through a specific C-style free function rather than Rust's normal cleanup, and warns that leaving the function early after partial conversion would leak memory. There is no code change to fix or introduce a leak.

This commit rewrites how a Zcash wallet's firmware summarizes batches of migration transactions on its screen. Previously, the code assumed the first message in a batch was an ordinary transaction and all later messages were migration-style transfers, then folded only those later messages into a compact summary. The new code inspects every message individually and decides by its actual contents whether it can be compacted. This makes the review order-independent and avoids mis-classifying a batch when the first message is actually a migration or when there are multiple ordinary transactions. The change is a defensive refactor rather than a clear-cut vulnerability patch, but the old design could have led to misleading on-device transaction summaries if a batch were presented in an unexpected order.

This commit adds a new compact review screen for batches of Zcash 'migration' transactions (moving funds from the Orchard pool to the newer Ironwood pool). It also fixes a small user-experience issue: the device will no longer auto-lock while a long batch of transactions is loading or being signed. The change is a feature addition with defensive checks, not a fix for an active security bug.

This commit fixes a security hygiene issue in the Keystone hardware wallet's Zcash signing code. Previously, secret 'spend authorizing keys' were cached in ordinary memory and could remain there after use. The patch adds explicit memory scrubbing (zeroization) when keys are replaced or no longer needed, reducing the chance that an attacker with physical or debug access could recover leftover secret key material.

This commit fixes validation of Zcash shielded transaction data on a Keystone hardware wallet. Previously, the device could accept transactions where it could not verify where shielded funds were going, could not read certain encrypted outputs, or could be shown invalid memos. The patch makes the wallet reject such cases, helping prevent theft or misleading transaction review.

This commit refactors how Keystone's Zcash firmware checks and parses batches of partially-created shielded transactions (PCZTs). It merges what used to be separate validation and display steps into a single pass, adds a new public function for batch PCZTs, and adds tests for Ironwood spends and Orchard-to-Ironwood migrations. The change is described by the vendor as a refactor, not a security fix, and no independent security references are supplied.

This commit removes an unused helper function called sign_message_orchard from the Zcash code in a cryptocurrency hardware wallet firmware. The function was not being called anywhere in the codebase (orphaned/dead code), so removing it is a routine cleanup. There is no direct evidence in the commit that this was a security fix or that the removed code was exploitable.

This commit is a small performance and code-clarity improvement for Zcash shielded transaction signing in a Keystone hardware wallet firmware component. It moves a repeated transaction-hash calculation out of a per-action loop so it is computed once per transaction instead of once per action, and replaces hard-coded byte-slice numbers with named constants. There is no direct evidence this fixes a security vulnerability, but it reduces the chance of accidental slicing mistakes when handling encrypted note data.

This commit only adds a new GitHub Actions CI workflow that runs automated tests for Zcash-related Rust code when relevant files change. It does not modify any firmware code, cryptographic logic, or user-facing behavior. There is no security issue here.

This commit removes a compile-time feature flag called NU6.3 from the Zcash code in the Keystone hardware wallet firmware. Previously, Ironwood (a newer Zcash shielded pool) and v6 transaction support were only compiled when the 'zcash_unstable="nu6.3"' flag was set. The change makes that code always compile and run, effectively enabling Ironwood/v6 support by default. There is no direct evidence in the commit that this fixes a security vulnerability; it appears to be a cleanup that promotes experimental code to stable. However, enabling new consensus code paths always carries some risk that previously-unreachable bugs or parsing differences could now affect real transactions.

This commit only reformats existing Zcash PCZT code—adjusting line breaks, indentation, and whitespace. No logic, behavior, or security checks were changed.

This commit only rewrites a comment in a dependency configuration file. No code, dependency versions, or build settings were changed. It has no security relevance on its own.

This commit removes a security check that verified a Zcash transaction buffer had not been tampered with between the 'check/review' screen and the 'sign' step on a Keystone hardware wallet. Before the change, the device stored a fingerprint (SHA-256 digest) of the reviewed transaction and re-checked it before signing. After the change, it only checks that the buffer pointer is not null. This weakens the defense-in-depth boundary between the C code and the Rust code that handles signing, but the commit does not by itself create a known exploitable bug.

This is a one-line comment change in a Zcash test file. It rewords an explanatory note about why a test sample lacks a Sapling bundle. No code behavior changes, no security fix or vulnerability is introduced.

This commit only renames a test-only helper struct and updates comments in unit tests for Zcash PCZT (partially-created transaction) handling. It makes no changes to production code, cryptography, transaction parsing, or wallet behavior. There is no security issue here.

This commit is a straightforward code cleanup in the Zcash PCZT (Partially Created Zcash Transaction) handling code. It merges two nearly identical internal helper functions into one shared helper that takes a policy argument, and removes a separate 'already parsed' helper that was only used internally. There is no change to user-visible behavior, no new security checks removed, and no bug fix or vulnerability patch evident from the diff.

This commit only removes explanatory comments from three Zcash test files. No code behavior, logic, or security checks were changed. It is a documentation cleanup inside test code and has no security relevance.

This commit only rewords a code comment in a Zcash test file. No program logic, behavior, or security properties changed. It is a documentation-only edit.

This commit only updates a code comment in a Zcash test file. It corrects an outdated explanation about why an anchor value can be removed during signing. No code behavior was changed, and there is no security issue present in the diff.

This commit is a simple rename of an internal function from `sign_pczt_to_pczt` to `sign_and_redact_pczt` in the Zcash Rust code. No behavior, logic, or security properties changed; it only makes the function name more descriptive. There is no security issue here.

This commit is a pure rename refactor. It changes the word 'preflight' to 'check' in function names, variable names, test names, and comments across three files related to Zcash batch transaction handling. The commit message explicitly states there is no behavior change, and the diff shows only identifier and comment updates with no logic modifications.

This commit fixes a bug in the Keystone 3 hardware wallet's Zcash QR-code batch transaction flow. Previously, scanning a Zcash batch QR code skipped a required safety preflight check, causing the wallet to fail with a confusing 'no checked Zcash batch available' error instead of showing a meaningful error. The patch runs the missing preflight inside the QR display path and surfaces any failure message to the user. It is a reliability/usability fix rather than a demonstrated exploit.

This commit changes how a hardware wallet handles Zcash transaction data before signing. Previously, some compact or abbreviated fields (like encrypted memos and hidden value commitments) were left as placeholders to be filled in later. Now they are fully reconstructed once during a 'preflight' check, and the complete data is baked into the bytes that get shown to the user and signed. This reduces the risk that an attacker could sneak different values into those fields between display and signing, or that the wallet would accidentally sign incomplete data. However, the commit is only a partial fix: a related multi-coin code path still has a 'future work' comment and does not call the new resolution routine.

This commit updates the Zcash PCZT (Partially Created Zcash Transaction) library stack to a newer upstream test revision. It is a maintenance/dependency bump that adapts the firmware's code to new library APIs, adds error handling around serialization, and adjusts how Orchard/Ironwood transaction fields are handled for transaction signing. There is no direct evidence in the commit that this fixes a known security vulnerability; it appears to be a routine dependency repin to keep up with an upstream test stack.

This commit is a pure code cleanup: it renames Zcash PCZT (Partially Created Zcash Transaction) helper functions from 'preflight' wording to 'check' wording and merges two nearly identical wrapper functions. The actual transaction validation logic, security checks, and behavior do not change. It is not a security fix and does not introduce a vulnerability.