TZ
← All projectsTrezor

Trezor firmware

Firmware monorepo for Trezor One, Model T, and Safe devices.

BitcoinHardware walletsNormal
Repository coverage

3768 commits in the local evidence base

Every captured commit receives deterministic security triage and a separate communication-quality score. Security candidates and broader second-pass signals receive full-patch Ollama analysis.

1328security candidates435second-pass queue3191AI analyses
201commits · 30 days
450commits · 60 days
1754commits · 180 days
2832commits · 365 days
Backfill bands
Aug 5 → Feb 61298 seen115 candidatesComplete
Feb 6 → Jun 6775 seen58 candidatesComplete
Jun 6 → Jul 6217 seen13 candidatesComplete
Jul 6 → Aug 5360 seen54 candidatesComplete
Commit communication

Does the history explain itself?

Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.

68/100 average clarity
841Strong · 80–100
1731Adequate · 60–79
1189Thin · 40–59
7Opaque · 0–39
1security candidate with opaque commit messaging
Read the scoring rubric →
Developer activity

Who is changing the project?

Public Git author strings; identities are not independently verified.

DeveloperCommitsCandidatesAnalyzedHigh riskMessage avg.
tychovrahe394164355667
Jakub Janků1023067681
Roman Zeyde721230639372
obrusvit333135281364
cepetr301111228259
PrisionMike153101149271
Andrew Kozlik893885267
Petr Susil1159286
Martin Pastyřík291025175
M1nd3r292106248071
Ioan Bizău23076230059
Lukas Bielesch1067592066
Analysis record

Published AI watches

Last scanned 5 minutes ago

Informational 15 AI analysisMessage 90 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

ci(core): reuse HW tests Slack webhook

This is a routine GitHub Actions workflow fix. It changes which Slack webhook secret is used for nightly test failure notifications and removes a now-unnecessary safety check. There is no security vulnerability in the change itself.

abfe74f9by Michal Kazda+1−51 file
No security note in commit
Informational 15 AI analysisMessage 90 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

test(clear_signing): name the skipped cases

This commit only improves a test report for Trezor's clear-signing feature. It changes how skipped test cases are listed in a nightly summary, showing each skipped case's source file and calldata size instead of just counting them by reaso…

98deb5b0by PrisionMike+25−92 files
No security note in commit
Informational 15 AI analysisMessage 95 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

test(clear_signing): run the cases without display format

This commit only changes test scripts and documentation for the Trezor firmware clear-signing test suite. It makes the tests run more registry cases—specifically those where the developer definitions do not yet have a display format—so the…

05c1f4efby PrisionMike+63−225 files
No security note in commit
Informational 15 AI analysisMessage 72 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

fix(translations): fix failing tutorial test in FR and small update to PT

This commit updates French and Portuguese translation strings in the Trezor firmware and refreshes the translation signature metadata. The changes are purely wording adjustments (for example, replacing abbreviations like 'nº' with the full…

29cbc419by Michal Kazda+19−193 files
No security note in commit
Informational 10 AI analysisMessage 95 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(core/rust): reduce coverage map size

This commit changes a code-coverage tracking map inside the Trezor firmware from a claimed capacity of 1,048,576 entries down to 65,536 entries. The commit message says the old capacity was never truly that large because the heapless libra…

No cryptographic or secret-handling code changedNo input parsing, deserialization, or memory allocator changesChange is in a debug/test instrumentation module (coverage)
9bf2fc3aby M1nd3r+1−11 file
No security note in commit
Informational 15 AI analysisMessage 57 · Thin
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(translations): sync Crowdin translations

This commit is a routine update of translated user-interface text strings for the Trezor hardware wallet. It adds new translations (for example, warnings about exporting public keys and Solana blind-signing prompts), updates existing wordi…

b2e8b5e6by Thalarion+141−1837 files
No security note in commit
Informational 12 AI analysisMessage 67 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

test(clear_signing): edge cases for arrays

This commit only adds new test cases for Ethereum clear-signing array parsing. It does not change any production code, so it cannot introduce a new security vulnerability on its own. The tests verify that malformed arrays (out-of-bounds of…

test-only changeno production code modifiedadds defensive test coverage for ABI decoding edge cases
dcdf3068by PrisionMike+169−01 file
No security note in commit
High 70 AI analysisMessage 62 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

refactor(core): harden task switching against fault injections

This commit hardens the Trezor firmware's task scheduler against fault-injection attacks. These attacks use physical techniques like voltage glitches or laser pulses to trick the device into executing code with higher privileges than inten…

Fault-injection hardening (FIH) explicitly mentioned in commit title and code commentsPrivilege-level transition split into multiple guarded stepsAdded runtime invariant check that only the kernel task may run privileged
2f159c6bby cepetr+16−51 file
Vendor flagged security relevance
Informational 15 AI analysisMessage 67 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

fix(tests): removed unused is_dynamic

This commit only removes an unused parameter called `is_dynamic` from test helper functions and from test data in three test files. It does not change any production firmware code, wallet behavior, or security logic. It is a cleanup of the…

2ada2691by PrisionMike+6−323 files
No security note in commit
Informational 21 AI analysisMessage 62 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

feat(clear_signing): update proto defs for features to be supported.

This commit updates the data-format definitions used by Trezor devices for Ethereum 'clear signing' (showing human-readable details of smart-contract interactions). It adds support for more numeric types, new path-step structures, and extr…

Schema expansion increases attack surface for future clear-signing parser logic, but no new parser logic is present in this commit.Replacement of NotImplementedError with InvalidFormatDefinition is a defensive change that turns unimplemented paths into a handled error rather than a crash/DoS vector.New optional fields and deprecated old fields (is_dynamic, lookup_address) are backward-compatible changes.
84cb6a4bby PrisionMike+1207−979 files
No security note in commit
Informational 19 AI analysisMessage 62 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(python): fix protocol_v1 probe for bridge transport

This is a bug-fix patch in the Python Trezor client library. It changes how the software probes whether a connected device uses the older protocol v1. Previously, the probe tried to read and throw away leftover data, but that read could ac…

No security-relevant signal in commit message or diffFix is described as a connectivity/functional bug, not a vulnerabilityNo mention of CVE, researcher credit, or security advisory
46492ba4by M1nd3r+18−124 files
No security note in commit
Informational 15 AI analysisMessage 80 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

feat(core): show language name in change confirm

This commit is a user-interface improvement, not a security fix. It changes the language-change confirmation prompt on Trezor devices so that it shows a human-readable language name (for example, 'French') instead of a raw code like 'fr-FR…

5ff5cba0by Michal Kazda+295−67 files
No security note in commit
Informational 15 AI analysisMessage 67 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

fix(translations): fix failing tests in ES and FR

This commit updates Spanish and French translation strings in the Trezor firmware and refreshes the translation signature file. The changes are purely textual wording adjustments (for example, changing 'Mostrar palab.' to 'Mostrar palabras…

9a12ab12by Michal Kazda+15−103 files
No security note in commit
Low 47 AI analysisMessage 85 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(crypto): hardening against potential side-channel leakage

This commit hardens cryptographic code in Trezor firmware against two potential side-channel leaks. First, it simplifies how a secret condition value is checked inside an assert statement so the compiler produces only one branch instead of…

Side-channel hardening in constant-time cryptographic primitivesReplacement of double-evaluation volatile assert with single-branch assertElimination of secret-dependent memory access in elliptic-curve scalar multiplication
7829d7c7by M1nd3r+27−93 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 72 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

feat(ci, clear_signing): add clear signing device tests as a nightly run.

This commit adds a new nightly automated testing workflow for Ethereum 'clear signing' on Trezor hardware wallets. It does not change any wallet firmware code that users run; it only adds test scripts, CI configuration, documentation, and …

fea125baby PrisionMike+2986−2117 files
No security note in commit
Informational 15 AI analysisMessage 57 · Thin
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(core): move `keccak_32` to unittests

This commit is a routine code cleanup. It removes a small helper function called keccak_32 from a shared crypto utility file and places an equivalent helper directly inside the only test file that still uses it. There is no change to how t…

f3225451by Roman Zeyde+8−122 files
No security note in commit
Informational 15 AI analysisMessage 63 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

chore: remove SmartCash

This commit removes support for a cryptocurrency called SmartCash from Trezor hardware wallets. It deletes coin definitions, support entries, and a custom cryptographic curve used only by SmartCash. There is no security vulnerability being…

No security-relevant signals detectedPure feature removal / code cleanup
b6d65c00by Roman Zeyde+5−52916 files
No security note in commit
Informational 15 AI analysisMessage 77 · Adequate
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(common,core,legacy,crypto): remove Groestlcoin

This commit removes all support for the Groestlcoin cryptocurrency from Trezor firmware. It deletes coin definitions, the custom Groestl hash algorithm code, related address/transaction handling, and tests. There is no security vulnerabili…

No security-relevant change: pure feature removalNo new attack surface introducedNo vulnerability patched or created
e22d597dby Roman Zeyde+41−446845 files
No security note in commit
Informational 15 AI analysisMessage 47 · Thin
TZ TrezorTrezor firmware BitcoinHardware wallets

chore(core): remove Tezos

This commit removes all support for the Tezos cryptocurrency from Trezor firmware, software libraries, and documentation. It is a feature-removal change, not a security fix or vulnerability patch. There is no indication in the commit that …

433075c0by obrusvit+9531−1751964 files
No security note in commit
Informational 24 AI analysisMessage 85 · Strong
TZ TrezorTrezor firmware BitcoinHardware wallets

fix(legacy): lower maximum auto-lock delay to 149 hours

This update reduces the longest allowed screen-lock timeout on older Trezor devices from about 6 days down to 149 hours (just over 6 days). It makes the legacy firmware behave the same as newer Trezor firmware and prevents users from setti…

Bounds enforcement added for a configurable security-relevant timeoutAlignment of security policy between legacy and core firmware variantsTest coverage added for boundary values above and below new maximum
c108f275by Ondřej Vejpustek+16−64 files
No security note in commit
Repository ledger

Explore captured commits

Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.

Security candidatefix(core): use `IntEnum = int` in run-timeby Roman Zeyde · e0cdde38 · Aug 13, 2026 · 6 filesMessage 92 · StrongLow 34Details
Commit message · Roman Zeyde

fix(core): use `IntEnum = int` in run-time

Otherwise, `IntEnum(arg)` c-tor returns a new non-integer object in runtime.

[no changelog]

(cherry picked from commit ea07e6bd15004b36c923df186141566b0535d173)

92/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
cryptography-sensitive pathsigning or wallet path
AI analysis · Low 34/100

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.

Security candidatefeat(core): introduce runtime TRNG use checksby cepetr · e394b535 · Aug 13, 2026 · 8 filesMessage 57 · ThinLow 32Details
Commit message · cepetr

feat(core): introduce runtime TRNG use checks

[no changelog]

57/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope! No meaningful explanatory body
Why it was queued
entropy or randomnessseed or entropy path
AI analysis · Low 32/100

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.

Security candidatechore(rust): improve unsafety annotationsby matejcik · 67a82645 · Aug 13, 2026 · 2 filesMessage 57 · ThinInformational 20Details
Commit message · matejcik

chore(rust): improve unsafety annotations

in bootloader_c, prodtest_c

57/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope! No meaningful explanatory body
Why it was queued
update trustboot or update path
AI analysis · Informational 20/100

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.

Security candidatefix(core/fido): don't fail if `_KEEPALIVE_STATUS_PROCESSING` is blockedby Roman Zeyde · e7e15170 · Aug 13, 2026 · 2 filesMessage 100 · StrongLow 37Details
Commit message · Roman Zeyde

fix(core/fido): don't fail if `_KEEPALIVE_STATUS_PROCESSING` is blocked

Otherwise, an OSError is raised by mod_trezorio_USBIF_write if the outgoing buffer is full.

Related to #7487.

There is a similar issue in fido2.send_cmd() -> #7553.

100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
authentication path
AI analysis · Low 37/100

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.

Security candidatefeat(core): detect PRNG presence in hw buildsby cepetr · 4bdcc409 · Aug 13, 2026 · 3 filesMessage 57 · ThinModerate 59Details
Commit message · cepetr

feat(core): detect PRNG presence in hw builds

[no changelog]

57/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope! No meaningful explanatory body
Why it was queued
entropy or randomnessseed or entropy path
AI analysis · Moderate 59/100

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.

Security candidaterefactor(core): drop `USBIF.write_blocking()` and simplify FIDO2 keep-alive sendingby Roman Zeyde · f269eccd · Aug 13, 2026 · 3 filesMessage 85 · StrongInformational 18Details
Commit message · Roman Zeyde

refactor(core): drop `USBIF.write_blocking()` and simplify FIDO2 keep-alive sending

Since `fido2.send_cmd_sync()` has been used only for sending 1-byte
keep-alive messages, we can drop the continuation handling part.

[no changelog]

85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
Why it was queued
authentication path
AI analysis · Informational 18/100

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.

Security candidatefix(storage): make flash area bounds checks overflow-safeby tychovrahe · aeda2a30 · Aug 13, 2026 · 1 fileMessage 90 · StrongLow 39Details
Commit message · tychovrahe

fix(storage): make flash area bounds checks overflow-safe

Both bounds checks added an offset to a size in `uint32_t` before comparing
against the limit:

flash_area_get_address(): offset + size <= subarea_size
flash_area_write_data_padded(): offset + total_size > flash_area_get_size()

A sufficiently large second operand wraps the sum to a small value, so the
comparison passes and the function reports the range as fitting. Rewrite both
as subtractions, which cannot wrap. In `flash_area_get_address()` the
subtraction cannot underflow either, since the enclosing condition has already
established that the offset is below the sub-area size.

Neither check is reachable with such arguments today. The address lookup is
gated by `offset < subarea_size` first, so wrapping needs an almost 4 GB size
rather than a large offset, and no caller passes one - `secret_read()` is not
exposed as a syscall and every one of its call sites uses a constant or a
range-checked length. The padded write is backed by `get_sector_and_offset()`,
which re-derives the sector for every block written and fails for an offset
past the area. Both checks are nonetheless the documented bound that a future
caller would reasonably trust.

[no changelog]

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

90/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
memory safety
AI analysis · Low 39/100

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.

Security candidatechore(core): rename tf-tools to tbenchby cepetr · 045ddd49 · Aug 13, 2026 · 15 filesMessage 57 · ThinInformational 15Details
Commit message · cepetr

chore(core): rename tf-tools to tbench

[no changelog]

57/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope! No meaningful explanatory body
Why it was queued
boot or update path
AI analysis · Informational 15/100

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.

Security candidaterefactor(rust): rename FatPtr to CSlice, use more extensivelyby matejcik · c5970975 · Aug 12, 2026 · 16 filesMessage 77 · AdequateInformational 20Details
Commit message · matejcik

refactor(rust): rename FatPtr to CSlice, use more extensively

replacing `from_c_str` and `from_c_array` utility functions

adding detailed doc for CSlice

77/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides an explanatory body
Why it was queued
cryptography-sensitive pathboot or update path
AI analysis · Informational 20/100

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.

Security candidatechore(core/embed): assert that bitblt probe lengths cannot overflowby tychovrahe · cf21b998 · Aug 12, 2026 · 1 fileMessage 100 · StrongLow 31Details
Commit message · tychovrahe

chore(core/embed): assert that bitblt probe lengths cannot overflow

CHECK_BB_DST and CHECK_BB_SRC multiply a stride by a height into a `size_t`
to get the length they probe. That is safe today only because every dimension
in `gfx_bitblt_t` is 16-bit: an unsigned product needs as many bits as its
operands have together, so 16 + 16 fits a 32-bit `size_t` exactly, with a
maximum product of 4294836225.

The relationship was implicit. Widening any of those fields would turn the
product into a wrapped, much smaller value, and the macros would then probe a
fraction of the memory the blit goes on to touch - the probe would start
approving what it is meant to reject. State the requirement as a static
assert so that change breaks the build instead.

No behavioural change.

[no changelog]

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Names security-relevant behavior explicitly
Why it was queued
memory safety
AI analysis · Low 31/100

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.

Security candidatechore(crypto): ecdsa uncompres_coords input checkby M1nd3r · 397564ab · Aug 12, 2026 · 3 filesMessage 80 · StrongModerate 59Details
Commit message · M1nd3r

chore(crypto): ecdsa uncompres_coords input check

- Calling `uncompres_coords` will now return 0 (error) if the input `x` is a non-residue (has no sqrt) - as non-residue `x` results in an invalid `y` value. In case of failure, `y` is zeroed-out.

80/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
Why it was queued
cryptography-sensitive path
AI analysis · Moderate 59/100

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.

Security candidatefix(nordic): size the bond list event buffer for a full bond tableby tychovrahe · d8727fca · Aug 12, 2026 · 1 fileMessage 97 · StrongLow 45Details
Commit message · tychovrahe

fix(nordic): size the bond list event buffer for a full bond table

management_send_bonds() writes an event byte, a bond count, and then one
seven-byte record per bond, but sized the buffer for the count plus the
records only. With CONFIG_BT_MAX_PAIRED=8 bonds present, the final byte of
the last record lands one past the end of a 57-byte array.

No attacker is involved - eight bonded devices and a bond list request are
enough. It has likely gone unnoticed because the stray byte falls into stack
alignment padding, which is the compiler's choice rather than a guarantee.

[no changelog]

97/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
explicit security language
AI analysis · Low 45/100

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.

Security candidatefix(nordic): bound the GATT write length in bt_receive_cb()by tychovrahe · e46fdaeb · Aug 12, 2026 · 1 fileMessage 100 · StrongModerate 64Details
Commit message · tychovrahe

fix(nordic): bound the GATT write length in bt_receive_cb()

The receive callback copied the GATT write payload into a fixed 251-byte
stack buffer without checking its length. It does not overflow today, but
only because the numbers happen to line up exactly: one L2CAP RX buffer
holds a 247-byte ATT PDU, an ATT write spends 3 bytes on the opcode and the
handle, and 244 plus the 7-byte address prefix is exactly the buffer size.

Nothing tied those numbers together. Raising CONFIG_BT_BUF_ACL_RX_SIZE on
its own is enough to let a peer deliver more, because the delivered length
is bounded by the L2CAP RX MTU rather than by the negotiated ATT MTU -
att_write_req() and att_write_cmd() pass the received length straight to the
callback.

Reject anything longer than BLE_RX_PACKET_SIZE, and add a BUILD_ASSERT so
that the Bluetooth buffer configuration and BLE_RX_PACKET_SIZE can no longer
drift apart silently.

[no changelog]

100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Names security-relevant behavior explicitly
Why it was queued
memory safety
AI analysis · Moderate 64/100

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.

Security candidatefix(nordic): bound the length of SPI frames from the host MCUby tychovrahe · fd866b0a · Aug 12, 2026 · 2 filesMessage 85 · StrongLow 49Details
Commit message · tychovrahe

fix(nordic): bound the length of SPI frames from the host MCU

process_rx_msg() copied `len` bytes into trz_packet_t.data[254] without
checking it. `msg_len` is a uint8_t, so the destination could be overflowed
by one byte - landing in the packet's own `len` field - and the source read
could run two bytes past the 254-byte SPI receive buffer, whose data field
starts at offset 2 and is 251 bytes long.

Bound both ends: reject frames whose msg_len exceeds MAX_SPI_DATA_SIZE while
the frame is being validated, and keep a check against PACKET_DATA_SIZE in
process_rx_msg(), which owns the destination.

[no changelog]

85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
Why it was queued
memory safetydefensive validation
AI analysis · Low 49/100

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.

Security candidatefix(core/embed): bound bond count before sizing the BLE bond list probeby tychovrahe · 8fe5d4f8 · Aug 12, 2026 · 1 fileMessage 90 · StrongHigh 70Details
Commit message · tychovrahe

fix(core/embed): bound bond count before sizing the BLE bond list probe

`sizeof(bt_le_addr_t) * count` is computed in a 32-bit `size_t`, so a
large `count` wraps and shrinks the probed range to a few bytes, while
`ble_get_bond_list()` ignores `count` on that path and always copies
`BLE_MAX_BONDS` entries. An applet could therefore have the kernel write
bond records past the end of the memory that was checked.

Reject counts above `BLE_MAX_BONDS`, which is both what the
implementation is willing to write and low enough that the size cannot
overflow. The only callers pass exactly `BLE_MAX_BONDS`.

[no changelog]

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

90/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
memory safety
AI analysis · High 70/100

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.

Security candidatefeat(core/ethereum): integrate EIP-7702 delegation into `EthereumSignTxEIP1559`by Roman Zeyde · 9a044adb · Aug 12, 2026 · 4 filesMessage 90 · StrongLow 36Details
Commit message · Roman Zeyde

feat(core/ethereum): integrate EIP-7702 delegation into `EthereumSignTxEIP1559`

For now, let's support at most one EIP-7702 authorization tuple per transaction.

The feature is still experimental, so no changelog entry is added.

[no changelog]

90/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
access controlsigning or wallet path
AI analysis · Low 36/100

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.

Security candidaterefactor(core/ethereum): don't unpack Ethereum signaturesby Roman Zeyde · 5361917d · Aug 11, 2026 · 2 filesMessage 100 · StrongInformational 15Details
Commit message · Roman Zeyde

refactor(core/ethereum): don't unpack Ethereum signatures

```
tests/device_tests/ethereum/test_signtx.py: 176 warnings
/home/rzeyde/src/trezor-firmware/tests/device_tests/ethereum/test_signtx.py:139: DeprecationWarning: Ethereum signature is a dataclass (`SignTxResult`), not a tuple.
sig_v, sig_r, sig_s = ethereum.sign_tx(

tests/device_tests/ethereum/test_signtx.py: 636 warnings
/home/rzeyde/src/trezor-firmware/tests/device_tests/ethereum/test_signtx.py:96: DeprecationWarning: Ethereum signature is a dataclass (`SignTxResult`), not a tuple.
sig_v, sig_r, sig_s = ethereum.sign_tx(

tests/device_tests/ethereum/test_signtx.py: 64 warnings
/home/rzeyde/src/trezor-firmware/tests/device_tests/ethereum/test_signtx.py:258: DeprecationWarning: Ethereum signature is a dataclass (`SignTxResult`), not a tuple.
sig_v, sig_r, sig_s = ethereum.sign_tx_eip1559(

tests/device_tests/ethereum/test_signtx.py: 24 warnings
/home/rzeyde/src/trezor-firmware/tests/device_tests/ethereum/test_signtx.py:685: DeprecationWarning: Ethereum signature is a dataclass (`SignTxResult`), not a tuple.
sig_v, sig_r, sig_s = ethereum.sign_tx_eip1559(

tests/device_tests/ethereum/test_signtx.py: 12 warnings
/home/rzeyde/src/trezor-firmware/tests/device_tests/ethereum/test_signtx.py:471: DeprecationWarning: Ethereum signature is a dataclass (`SignTxResult`), not a tuple.
sig_v, sig_r, sig_s = ethereum.sign_tx_eip1559(
```

[no changelog]

100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 15/100

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.

Security candidatefix(legacy): align coinjoin behavior with coreby Andrew Kozlik · e1463ec0 · Aug 11, 2026 · 5 filesMessage 85 · StrongLow 35Details
Commit message · Andrew Kozlik

fix(legacy): align coinjoin behavior with core

An authorization granted by DoPreauthorized was consumed by whatever
message arrived next, and the same applied to a path unlocked by
UnlockPath. Core allows a coinjoin preauthorization to be used only by
SignTx and GetOwnershipProof, and an unlocked path only by GetAddress,
GetPublicKey and SignTx. Apply the same allowlists by dropping the
authorization before dispatching a message it does not apply to, which
reproduces core's behavior of aborting the workflow and reprocessing the
message as a new one.

This is defense in depth rather than a fix for a reachable issue. The
authorization is stored per session, so whoever can use it is the host
that ran AuthorizeCoinJoin, which already holds the SLIP-25 xpub from a
confirmed UnlockPath. Without the allowlist a coinjoin authorization
additionally let GetAddress and GetOwnershipId reach the SLIP-25
external chain without the coinjoin account access confirmation. The
xpub was never exposed, as GetPublicKey checks unlock_path directly.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

85/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
access controlboot or update pathauthentication path
AI analysis · Low 35/100

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.

Security candidatefix(legacy): abort on coinjoin coin-name mismatchby Andrew Kozlik · afc6ebe3 · Aug 11, 2026 · 3 filesMessage 80 · StrongLow 34Details
Commit message · Andrew Kozlik

fix(legacy): abort on coinjoin coin-name mismatch

Enforces a check aligning the behavior with core. The missing check did
not yield anything an attacker couldn't get from a legitimate coinjoin
round on the authorized coin. The inputs signed are always from the
authorized SLIP-25 account regardless of what coin_name claims.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

80/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
Why it was queued
explicit security languagesigning or wallet pathboot or update pathauthentication path
AI analysis · Low 34/100

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.

Security candidatechore(core/ethereum): drop `EthereumSignAuth7702` and its handlerby Roman Zeyde · bd6186c4 · Aug 11, 2026 · 17 filesMessage 77 · AdequateInformational 15Details
Commit message · Roman Zeyde

chore(core/ethereum): drop `EthereumSignAuth7702` and its handler

It will be integrated into `EthereumSignTxEIP1559`.

[no changelog]

77/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides an explanatory body
Why it was queued
signing or wallet pathauthentication path
AI analysis · Informational 15/100

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.

Security candidatechore(crypto): add hdnode key verificationby M1nd3r · fe2680cd · Aug 11, 2026 · 4 filesMessage 82 · StrongModerate 59Details
Commit message · M1nd3r

chore(crypto): add hdnode key verification

[no changelog]

Assisted-by: Claude, Opus 5

82/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides an explanatory body✓ Mentions testing or verification
Why it was queued
defensive validationcryptography-sensitive path
AI analysis · Moderate 59/100

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.

Security candidatetest(core/ethereum): adjust EIP-7702 test vectorsby Roman Zeyde · d5dea04b · Aug 11, 2026 · 3 filesMessage 90 · StrongInformational 15Details
Commit message · Roman Zeyde

test(core/ethereum): adjust EIP-7702 test vectors

- rename `nonce` to `tuple_nonce` since it's not the same as the tx nonce
- set `to_address` to `m/44'/60'/0'/0/0`-derived address
- test non-empty calldata, empty destination and payment request
- update `chain_id` 0 error message
- add mainnet test vectors

[no changelog]

90/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
fuzzing or regression evidencesigning or wallet pathauthentication path
AI analysis · Informational 15/100

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.

Security candidatechore(vendor): update secp256k1-zkp to v0.7.1by M1nd3r · 0904b41b · Aug 11, 2026 · 1 fileMessage 88 · StrongInformational 15Details
Commit message · M1nd3r

chore(vendor): update secp256k1-zkp to v0.7.1

- Updated from v0.7.0.
- Pinned to release/commit: https://github.com/bitcoin-core/secp256k1/releases/tag/v0.7.1
- Changelog: https://github.com/bitcoin-core/secp256k1/blob/master/CHANGELOG.md#071---2026-01-26
- Changes: https://github.com/bitcoin-core/secp256k1/compare/v0.7.0...v0.7.1

88/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive path
AI analysis · Informational 15/100

This commit only updates a bundled cryptographic library (secp256k1-zkp) from version 0.7.0 to 0.7.1. The actual code change is a one-line update to the submodule pointer. The commit message does not describe any security fix, and no security-relevant details are visible in the diff itself.

Security candidatechore: remove libtropic's pin to develop branchby M1nd3r · 8290eeef · Aug 11, 2026 · 1 fileMessage 57 · ThinInformational 15Details
Commit message · M1nd3r

chore: remove libtropic's pin to develop branch

[no changelog]

57/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope! No meaningful explanatory body
Why it was queued
access control
AI analysis · Informational 15/100

This commit removes a single line from the project's Git submodule configuration. It stops pinning the libtropic submodule to the 'develop' branch, meaning the project will now use the submodule's default branch (likely 'main' or 'master'). There is no code change, no bug fix, and no direct security issue visible in the diff itself.

Security candidatechore(core/embed): clear temporary buffer across Optiga/Tropic callsby Roman Zeyde · 01ebda93 · Aug 10, 2026 · 1 fileMessage 70 · AdequateLow 37Details
Commit message · Roman Zeyde

chore(core/embed): clear temporary buffer across Optiga/Tropic calls

We don't need to keep Optiga/Tropic-generated entropy
after XOR-ing it into `dest`.

In addition, it prevents the "Tropic" for-loop from "undoing" the
"Optiga" for-loop result, if `tropic_random_buffer()` somehow succeeds
without modifying its buffer.

The additional `memzero` calls performance impact should be small
compared to Optiga/Tropic communication latency.

[no changelog]

70/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly! Contains work-in-progress language
Why it was queued
entropy or randomnessseed or entropy path
AI analysis · Low 37/100

This is a hardening change for the random number generator inside Trezor hardware wallets. It makes sure that temporary memory holding secret random values from the Optiga and Tropic security chips is wiped immediately after use, rather than only once at the end. It also fixes a subtle edge case where a buggy Tropic chip call could leave old Optiga randomness in the temporary buffer, potentially weakening the final random output.