arno
/
trezor-firmware
mirror of https://github.com/trezor/trezor-firmware.git
1
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '37c61c1381'
${ noResults }
trezor-firmware/core/src/apps/workflow_handlers.py

199 lines
7.7 KiB
Raw Normal View History Unescape

style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
from typing import TYPE_CHECKING
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
from trezor import utils
refactor(core): fix imports and use new protobuf API in apps
3 years ago
from trezor.enums import MessageType
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if TYPE_CHECKING:
from trezor.wire import Handler, Msg
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
from trezorio import WireInterface
workflow_handlers: dict[int, Handler] = {}
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
def register(wire_type: int, handler: Handler[Msg]) -> None:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
"""Register `handler` to get scheduled after `wire_type` message is received."""
workflow_handlers[wire_type] = handler
def find_message_handler_module(msg_type: int) -> str:
"""Statically find the appropriate workflow handler.
For now, new messages must be registered by hand in the if-elif manner below.
The reason for this is memory fragmentation optimization:
- using a dict would mean that the whole thing stays in RAM, whereas an if-elif
sequence is run from flash
- collecting everything as strings instead of importing directly means that we don't
need to load any of the modules into memory until we actually need them
"""
# debug
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if __debug__ and msg_type == MessageType.LoadDevice:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.debug.load_device"
# management
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.ResetDevice:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.reset_device"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.BackupDevice:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.backup_device"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.WipeDevice:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.wipe_device"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.RecoveryDevice:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.recovery_device"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.ApplySettings:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.apply_settings"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.ApplyFlags:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.apply_flags"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.ChangePin:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.change_pin"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.ChangeWipeCode:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.management.change_wipe_code"
feat(core): Implement Bitcoin payment requests.
3 years ago
elif msg_type == MessageType.GetNonce:
return "apps.management.get_nonce"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if utils.MODEL == "T" and msg_type == MessageType.SdProtect:
refactor(core): disable SD, SBU, fatfs for T1 build
3 years ago
return "apps.management.sd_protect"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
# bitcoin
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.AuthorizeCoinJoin:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.authorize_coinjoin"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.get_public_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetOwnershipId:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.get_ownership_id"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetOwnershipProof:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.get_ownership_proof"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.SignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.sign_tx"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.SignMessage:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.sign_message"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.VerifyMessage:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.bitcoin.verify_message"
# misc
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetEntropy:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.misc.get_entropy"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.SignIdentity:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.misc.sign_identity"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetECDHSessionKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.misc.get_ecdh_session_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.CipherKeyValue:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.misc.cipher_key_value"
feat(core): Implement GetFirmwareHash message.
2 years ago
if msg_type == MessageType.GetFirmwareHash:
return "apps.misc.get_firmware_hash"
feat(core): implement firmware dumping
2 years ago
if msg_type == MessageType.GetFirmware:
return "apps.misc.get_firmware"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if not utils.BITCOIN_ONLY:
if msg_type == MessageType.SetU2FCounter:
fix(core): exclude get/set U2F counter from BITCOIN_ONLY
3 years ago
return "apps.management.set_u2f_counter"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.GetNextU2FCounter:
fix(core): exclude get/set U2F counter from BITCOIN_ONLY
3 years ago
return "apps.management.get_next_u2f_counter"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
# webauthn
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.WebAuthnListResidentCredentials:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.webauthn.list_resident_credentials"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.WebAuthnAddResidentCredential:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.webauthn.add_resident_credential"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.WebAuthnRemoveResidentCredential:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.webauthn.remove_resident_credential"
# ethereum
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ethereum.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumGetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ethereum.get_public_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ethereum.sign_tx"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumSignTxEIP1559:
feat(core,python): support for Ethereum EIP1559 transactions Initial EIP1559 implementation Fix a few small issues Progress on Python lib implementation and firmware Fix RLP length Start fixing tests Fix legacy transactions Simplify API and logic Add EIP1559 tests Fix access list formatting Fix UI visiblity issue Fix commented out code fix: correct linting issues Fix access_list protobuf formatting Remove unneeded code Remove dead code Check tx_type bounds for EIP 2718 Reduce code duplication Prefer eip2718_type over re-using tx_type Add more tests Simplify format_access_list Simplify sign_tx slightly Change Access List format and add logic to encode it Fix a bunch of small PR comments Fix a linting issue Move tests out of class and regenerate Remove copy-pasted comments Add access list to CLI Simplify _parse_access_list_item Fix small mistakes following rebase Fix linting Refactor to use a separate message for EIP 1559 tx Simplify changed legacy code Fix a few small PR comments Fix linting fix(legacy): recognize SignTxEIP1559 on legacy build Fix PR comments
3 years ago
return "apps.ethereum.sign_tx_eip1559"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumSignMessage:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ethereum.sign_message"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumVerifyMessage:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ethereum.verify_message"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EthereumSignTypedData:
feat(core/ethereum): EIP-712 Based on original contribution by Max Kupriianov <xlab@hey.com> Implemented EIP-712 typed data signatures in Ethereum app. Add eth_abi into pyproject deps device test for EIP 712 fixed hex decoding for address fixup! fixed hex decoding for address code quality, more pythonic code, removing unused imports running black and isort on changed files trezorctl file input for EIP 712 data signing fixup! code quality, more pythonic code, removing unused imports fixup! fixup! code quality, more pythonic code, removing unused imports necessary changes after rebase to master unit tests for sign_typed_data.py new protobuf messages, working for nonarray types simplified and verified solution for our simple data support for simple arrays, without their confirmation reverting protobuf value messages to bytes, appropriate changes showing arrays in Trezor, code quality improvements data validation on Trezor, minor improvements using custom types for storing type data instead of dicts, addressing feedback from review moving helper functions to its own file, tests for decode_data additional overall tests support for arrays of structs adding support for metamask_v4_compat variable using HashWriter object to collect the final hash continously minor improvements in code quality validate_field_type function streaming values from client without saving them, missing UI prototype of streamed UI using confirm_properties accounting for bytes in data, more data types in integration tests rebase on master, using f-strings minor fixes and improvements from code review StructHasher class for the whole hashing process mypy and style changes asking users whether to show structs and arrays protobuf descriptions to fix make defs_check unifying comments, mypy fix unit tests for StructHasher class UI fixtures, skipping device tests for T1 addressing majority of code review comments about code quality and structure changing file structure - layouts, helpers, sign_typed_data decode_data renaming and docstring, renaming unit test file using tuples instead of lists in elifs layout improvements excluding core/src/apps/common/confirm.py file from the PR True/False returning layout with Show more button code review layout improvements forgotten br_type argument to should_show_more
3 years ago
return "apps.ethereum.sign_typed_data"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
# monero
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroGetWatchKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.get_watch_only"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroTransactionInitRequest:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.sign_tx"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroKeyImageExportInitRequest:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.key_image_sync"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroGetTxKeyRequest:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.get_tx_keys"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.MoneroLiveRefreshStartRequest:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.monero.live_refresh"
if __debug__ and msg_type == MessageType.DebugMoneroDiagRequest:
return "apps.monero.diag"
# nem
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.NEMGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.nem.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.NEMSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.nem.sign_tx"
# stellar
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.StellarGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.stellar.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.StellarSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.stellar.sign_tx"
# ripple
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.RippleGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ripple.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.RippleSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.ripple.sign_tx"
# cardano
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.CardanoGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.cardano.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.CardanoGetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.cardano.get_public_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.CardanoSignTxInit:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.cardano.sign_tx"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.CardanoGetNativeScriptHash:
feat(cardano): add get-native-script-hash call
3 years ago
return "apps.cardano.get_native_script_hash"
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
# tezos
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.TezosGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.tezos.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.TezosSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.tezos.sign_tx"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.TezosGetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.tezos.get_public_key"
# eos
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EosGetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.eos.get_public_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.EosSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.eos.sign_tx"
# binance
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.BinanceGetAddress:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.binance.get_address"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.BinanceGetPublicKey:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.binance.get_public_key"
style(core): full pyright-based type-checking Changes many fields to required -- as far as we were able to figure out, signing would fail if these fields aren't provided anyway, so this should not pose a compatibility problem. Co-authored-by: matejcik <ja@matejcik.cz>
2 years ago
if msg_type == MessageType.BinanceSignTx:
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
return "apps.binance.sign_tx"
raise ValueError
def find_registered_handler(iface: WireInterface, msg_type: int) -> Handler | None:
if msg_type in workflow_handlers:
# Message has a handler available, return it directly.
return workflow_handlers[msg_type]
try:
modname = find_message_handler_module(msg_type)
handler_name = modname[modname.rfind(".") + 1 :]
module = __import__(modname, None, None, (handler_name,), 0)
style(core): remove unused type:ignore comments
2 years ago
return getattr(module, handler_name)
refactor(core): move app registrations to a single handler function apps.webauthn.boot() does not need an if-condition because it's only called from session.py when the usb interface is enabled This means that they do not need to be stored in RAM at all. The obvious drawback is that we need to hand-edit the if/elif sequence, but we don't register new handlers all that often so :shrug:
3 years ago
except ValueError:
return None