Trezor firmware

This commit adds new Rust code that lets other parts of the Trezor firmware call existing C-language ECDSA cryptographic functions (signature verification and public-key recovery). It is a feature addition that exposes already-trusted crypto code through a thin Rust wrapper. There is no indication in the commit that it fixes a bug or vulnerability.

This commit adds new Rust code that lets other parts of the Trezor firmware calculate SHA-3 and Keccak hashes. It is a feature addition (new bindings for an existing C library) and does not change any existing security behavior. There is no indication it fixes a bug or vulnerability.

This commit is a straightforward code cleanup: it exposes a single internal SHA3/Keccak initialization function so other code (specifically Rust) can call it directly with a chosen hash size, instead of going through four separate wrapper functions. There is no bug fix, behavior change, or security patch in the diff.

This commit fixes a type-stub mismatch in Trezor firmware. During normal runtime, the code was using a placeholder `IntEnum = object`, which made enum-like values behave as plain objects rather than integers. The fix changes the runtime alias to `IntEnum = int`, so integer-like behavior works as expected. The change is small and affects multiple files that define integer-backed enums. Without deeper context, it is unclear whether this caused an exploitable security bug, but it could have led to subtle logic errors in cryptographic/transaction code.

This commit adds runtime bookkeeping so the firmware can verify that every strong random-number generation actually used all available hardware random sources (the main chip, and optional Optiga/Tropic chips). It also fixes a small edge case in how Optiga random data is requested. The change is defensive: it makes the device deliberately fail if an expected entropy source was somehow skipped, reducing the risk that a bug or tampered code path silently weakens randomness used for secrets.

This commit is a code-quality cleanup in the Rust portions of Trezor's bootloader and production-test interfaces. It marks C-callable functions as 'unsafe' (a Rust keyword meaning the caller must guarantee pointer validity) and adds explanatory comments. It also replaces a few raw pointer operations with a safer wrapper type. There is no direct evidence this fixes an active security bug, but it improves documentation and reduces risky raw-pointer use in firmware UI code that handles untrusted C inputs.

This update fixes a bug in the Trezor hardware wallet's FIDO2/WebAuthn support. Previously, when the device was busy and tried to send a 'still processing' keepalive message to the computer, it would crash the whole FIDO operation if the USB send buffer happened to be full. Now it simply skips that single keepalive message and continues, making FIDO logins more reliable.

This commit adds a new automated check that scans Trezor hardware wallet firmware binaries for leftover 'insecure PRNG' test markers. These markers indicate places where the real random-number generator was replaced with a predictable mock for testing. The check ensures these markers are present in emulator builds (used for testing) but absent from real production hardware builds, where they could weaken security. It is a defensive build-pipeline hardening change, not a fix for an active vulnerability in shipped code.

This commit is a small internal cleanup in the Trezor hardware wallet's FIDO2 (WebAuthn) code. It removes an unused 'blocking write' USB function and replaces a general synchronous send routine with a simpler one that only sends one-byte 'still processing' keep-alive messages. There is no obvious security bug being fixed; it appears to be a refactoring change.

This commit fixes two overflow-prone safety checks in the Trezor firmware's flash storage code. The original checks added numbers together before comparing them to a limit; with specially crafted large values that addition could silently wrap around to a small number, making an out-of-bounds access look valid. The patch rewrites the checks using subtraction, which cannot wrap in the same way. The commit message says these particular checks are not reachable from current callers, so the immediate risk is low, but the change hardens the code against future misuse.

This commit is a simple rename of an internal developer tool from 'tf-tools' to 'tbench'. It updates folder names, configuration file references, and VS Code extension settings. There is no change to the actual Trezor firmware code that runs on devices, and nothing in the commit affects security.

This commit is a code cleanup: it renames an internal helper type from FatPtr to CSlice, adds lifetime tracking and documentation, and updates call sites to use the new helper. The changes are intended to make Rust/C boundary handling safer and clearer, not to introduce a vulnerability. There is no public security advisory or incident tied to this commit.

This is a hardening change, not a fix for an active bug. It adds a compile-time safety check to ensure that future changes to graphics dimensions cannot cause a memory-bounds check to silently undercount how much memory a drawing operation will touch. As written today the code is safe; the patch prevents a future, potentially dangerous code change from being accepted without notice.

This commit hardens the Trezor firmware's elliptic-curve cryptography by making a low-level coordinate-decompression function validate its inputs. Previously, if a compressed public key or signature-recovery value pointed to an x-coordinate that does not correspond to any valid point on the curve, the function could silently produce a meaningless y-coordinate. The change now returns an error and clears the result, preventing downstream code from acting on invalid curve points. The commit message frames this as a routine code-quality improvement ('chore'), not as a security fix.

This commit fixes a one-byte buffer overflow in the Trezor hardware wallet's Bluetooth code. When listing all paired Bluetooth devices, the software reserved a buffer that was one byte too small. If the maximum of eight devices were paired, the last byte of the last device's address would be written just past the end of the buffer. The commit message says no attacker is needed to trigger it; it can happen simply by requesting the bond list with eight bonded devices. The overflow is small and likely lands in harmless compiler padding, but it is still a real memory-safety bug.

This commit fixes a Bluetooth code flaw in Trezor's Nordic chip firmware. A function that receives data from another device over Bluetooth was copying that data into a fixed-size on-chip memory buffer without first checking how long the incoming data was. Right now the sizes happen to match, so no overflow occurs, but a configuration change or a connected peer sending a specially large write could have overflowed the buffer. The patch now rejects oversized incoming packets and adds a compile-time check so the buffer sizes cannot silently drift apart in future builds.

This commit fixes a small but real memory overflow bug in the code that handles Bluetooth-related SPI messages between the host microcontroller and the Nordic chip in a Trezor device. A malicious or malformed message could ask the firmware to copy slightly more data than the destination buffer can hold, potentially corrupting an adjacent length field and reading past the end of the receive buffer. The patch now rejects oversized frames at two different points in the code.

This commit fixes a kernel-level memory overflow bug in the Trezor firmware's Bluetooth system. A malicious applet running on the device could request a huge number of Bluetooth 'bond' records, causing a size calculation to wrap around due to 32-bit arithmetic limits. The kernel would then write far more data than the memory area it had verified was safe, potentially overwriting other memory. The fix rejects any request larger than the maximum number of bonds the system actually supports.

This commit adds experimental support for a new Ethereum feature (EIP-7702) that lets an account temporarily delegate control to a smart contract. The change is feature work, not a bug fix, and includes several safety guardrails: it is blocked unless experimental features are enabled, requires relaxed safety checks for authorizations (but not revocations), rejects cross-chain delegation, and only allows known delegate addresses. There is no direct evidence in the commit that this fixes a security vulnerability.

This commit is a minor cleanup in Trezor's Python test and command-line code. It stops treating Ethereum transaction signatures as plain tuples (v, r, s) and instead uses a named data class (SignTxResult). The only functional code change is converting the data class back to a tuple in one place so existing callers keep working. There is no security bug being fixed here.

This commit tightens access controls in the older Trezor firmware (legacy) for a privacy feature called CoinJoin. Previously, after a host app was pre-authorized, any next message could consume that authorization. Now only specific message types (SignTx and GetOwnershipProof for preauthorization; GetAddress, GetPublicKey, and SignTx for an unlocked path) can use it. The vendor describes this as defense in depth, not a fix for a directly reachable attack, because the host that could trigger it already has related access. Still, without the change, a preauthorization could let GetAddress or GetOwnershipId touch the CoinJoin account without showing the user the usual confirmation screen.

This commit fixes a bug in the older Trezor firmware (legacy) where a CoinJoin signing session would not be properly aborted if the requested coin name did not match the one in the prior authorization. Before the fix, the device sent an error message but continued processing, which could allow a malicious or mismatched transaction to proceed. The fix adds an explicit abort and return so the signing stops immediately, matching the behavior of newer Trezor firmware (core). The commit message downplays the practical risk, noting an attacker could not gain more than from a legitimate CoinJoin on the authorized coin.

This commit removes an Ethereum feature called EthereumSignAuth7702 from the Trezor firmware and related software. It deletes the message types, the signing handler, the command-line tool, and the tests. The commit message says this feature will later be merged into EthereumSignTxEIP1559. There is no security fix here—this is a routine cleanup/refactoring change.

This commit adds validation checks to Trezor's cryptocurrency wallet code to make sure private and public keys are mathematically valid before they are used. Previously, some code paths accepted invalid keys (such as a private key of zero, a private key equal to or larger than the curve order, or a public key that is not actually a point on the elliptic curve). Using invalid keys could in theory lead to incorrect cryptographic operations or weaken security. The change also fixes a missing check for unknown curve names during deserialization, which could have caused the code to read from a null pointer.

This commit only updates test data files for Ethereum EIP-7702 (account abstraction) signing. It renames a test field, adds more test cases, updates expected error messages, and adds mainnet transaction test vectors. There are no changes to the actual firmware or production code, so it does not introduce or fix a security vulnerability in the shipped product.