[draft] THP

common/protob/messages-common.proto

@@ -39,6 +39,10 @@ message Failure {
         Failure_PinMismatch = 12;
         Failure_WipeCodeMismatch = 13;
         Failure_InvalidSession = 14;
+        Failure_ThpUnallocatedSession = 15;
+        Failure_InvalidProtocol = 16;
+        Failure_BufferError = 17;
+        Failure_DeviceIsBusy = 18;
         Failure_FirmwareError = 99;
     }
 }

common/protob/messages-debug.proto

@@ -85,7 +85,7 @@ message DebugLinkRecordScreen {
 }
 
 /**
- * Request: Computer asks for device state
+ * Request: Host asks for device state
  * @start
  * @next DebugLinkState
  */
@@ -132,6 +132,29 @@ message DebugLinkState {
     repeated string tokens = 13;                            // current layout represented as a list of string tokens
 }
 
+/**
+ * Request: Host asks for device pairing info
+ * @start
+ * @next DebugLinkPairingInfo
+ */
+ message DebugLinkGetPairingInfo {
+    optional bytes channel_id = 1;              // ID of the THP channel to get pairing info from
+    optional bytes handshake_hash = 2;          // handshake hash of the THP channel
+    optional bytes nfc_secret_host = 3;         // host's NFC secret (In case of NFC pairing)
+}
+
+ /**
+ * Response: Device pairing info
+ * @end
+ */
+ message DebugLinkPairingInfo {
+    optional bytes channel_id = 1;              // ID of the THP channel the pairing info is from
+    optional bytes handshake_hash = 2;          // handshake hash of the THP channel
+    optional uint32 code_entry_code = 3;        // CodeEntry pairing code
+    optional bytes code_qr_code = 4;            // QrCode pairing code
+    optional bytes nfc_secret_trezor = 5;       // NFC secret used in NFC pairing
+}
+
 /**
  * Request: Ask device to restart
  * @start

common/protob/messages-thp.proto

@@ -9,13 +9,232 @@ import "options.proto";
 
 option (include_in_bitcoin_only) = true;
 
+/**
+ * Mapping between Trezor wire identifier (uint) and a Thp protobuf message
+ */
+enum ThpMessageType {
+    reserved 0 to 999;  // Values reserved by other messages, see messages.proto
+
+    ThpMessageType_ThpCreateNewSession = 1000 [(bitcoin_only)=true];
+    ThpMessageType_ThpPairingRequest = 1006 [(bitcoin_only) = true];
+    ThpMessageType_ThpPairingRequestApproved = 1007 [(bitcoin_only) = true];
+    ThpMessageType_ThpSelectMethod = 1008 [(bitcoin_only) = true];
+    ThpMessageType_ThpPairingPreparationsFinished = 1009 [(bitcoin_only) = true];
+    ThpMessageType_ThpCredentialRequest = 1010 [(bitcoin_only) = true];
+    ThpMessageType_ThpCredentialResponse = 1011 [(bitcoin_only) = true];
+    ThpMessageType_ThpEndRequest = 1012 [(bitcoin_only) = true];
+    ThpMessageType_ThpEndResponse = 1013 [(bitcoin_only) = true];
+    ThpMessageType_ThpCodeEntryCommitment = 1016 [(bitcoin_only)=true];
+    ThpMessageType_ThpCodeEntryChallenge = 1017 [(bitcoin_only)=true];
+    ThpMessageType_ThpCodeEntryCpaceTrezor = 1018 [(bitcoin_only)=true];
+    ThpMessageType_ThpCodeEntryCpaceHostTag = 1019 [(bitcoin_only)=true];
+    ThpMessageType_ThpCodeEntrySecret = 1020 [(bitcoin_only)=true];
+    ThpMessageType_ThpQrCodeTag = 1024 [(bitcoin_only)=true];
+    ThpMessageType_ThpQrCodeSecret = 1025 [(bitcoin_only)=true];
+    ThpMessageType_ThpNfcTagHost = 1032 [(bitcoin_only)=true];
+    ThpMessageType_ThpNfcTagTrezor = 1033 [(bitcoin_only)=true];
+
+    reserved 1100 to 2147483647;  // Values reserved by other messages, see messages.proto
+}
+
+
+/**
+ * Numeric identifiers of pairing methods.
+ * @embed
+ */
+enum ThpPairingMethod {
+    SkipPairing = 1;          // Trust without MITM protection.
+    CodeEntry = 2;            // User types code diplayed on Trezor into the host application.
+    QrCode = 3;               // User scans code displayed on Trezor into host application.
+    NFC = 4;                  // Trezor and host application exchange authentication secrets via NFC.
+}
+
+/**
+ * @embed
+ */
+message ThpDeviceProperties {
+    optional string internal_model = 1;               // Internal model name e.g. "T2B1".
+    optional uint32 model_variant = 2;                // Encodes the device properties such as color.
+    optional uint32 protocol_version_major = 3;       // The major version of the communication protocol used by the firmware.
+    optional uint32 protocol_version_minor = 4;       // The minor version of the communication protocol used by the firmware.
+    repeated ThpPairingMethod pairing_methods = 5;    // The pairing methods supported by the Trezor.
+}
+
+/**
+ * @embed
+ */
+message ThpHandshakeCompletionReqNoisePayload {
+    optional bytes host_pairing_credential = 1;       // Host's pairing credential
+}
+
+/**
+ * Request: Ask device for a new session with given passphrase.
+ * @start
+ * @next Success
+ */
+message ThpCreateNewSession{
+    optional string passphrase = 1;
+    optional bool on_device = 2;       // User wants to enter passphrase on the device
+    optional bool derive_cardano = 3;  // If True, Cardano keys will be derived. Ignored with BTC-only
+}
+
+
+/**
+ * Request: Start pairing process.
+ * @start
+ * @next ThpPairingRequestApproved
+ */
+message ThpPairingRequest{
+    optional string host_name = 1;     // Human-readable host name
+}
+
+/**
+ * Response: Host is allowed to start pairing process.
+ * @start
+ * @next ThpSelectMethod
+ */
+message ThpPairingRequestApproved{
+}
+
+/**
+ * Request: Start pairing using the method selected.
+ * @start
+ * @next ThpPairingPreparationsFinished
+ * @next ThpCodeEntryCommitment
+ */
+message ThpSelectMethod {
+    optional ThpPairingMethod selected_pairing_method = 1;
+}
+
+/**
+ * Response: Pairing is ready for user input / OOB communication.
+ * @next ThpCodeEntryCpace
+ * @next ThpQrCodeTag
+ * @next ThpNfcTagHost
+ */
+message ThpPairingPreparationsFinished{
+}
+
+/**
+ * Response: If Code Entry is an allowed pairing option, Trezor responds with a commitment.
+ * @next ThpCodeEntryChallenge
+ */
+message ThpCodeEntryCommitment {
+    optional bytes commitment = 1;     // SHA-256 of Trezor's random 32-byte secret
+}
+
+/**
+ * Response: Host responds to Trezor's Code Entry commitment with a challenge.
+ * @next ThpCodeEntryCpaceTrezor
+ */
+message ThpCodeEntryChallenge {
+    optional bytes challenge = 1;      // Host's random 32-byte challenge
+}
+
+
+
+/**
+ * Response: Trezor continues with the CPACE protocol.
+ * @next ThpCodeEntryCpaceHostTag
+ */
+message ThpCodeEntryCpaceTrezor {
+    optional bytes cpace_trezor_public_key = 1;  // Trezor's ephemeral CPace public key
+}
+
+/**
+ * Request: User selected Code Entry option in Host. Host starts CPACE protocol with Trezor.
+ * @next ThpCodeEntrySecret
+ */
+ message ThpCodeEntryCpaceHostTag {
+    optional bytes cpace_host_public_key = 1;    // Host's ephemeral CPace public key
+    optional bytes tag = 2;                      // SHA-256 of shared secret
+
+}
+
+/**
+ * Response: Trezor finishes the CPACE protocol.
+ * @next ThpCredentialRequest
+ * @next ThpEndRequest
+ */
+message ThpCodeEntrySecret {
+    optional bytes secret = 1;    // Trezor's secret
+}
+
+/**
+ * Request: User selected QR Code pairing option. Host sends a QR Tag.
+ * @next ThpQrCodeSecret
+ */
+message ThpQrCodeTag {
+    optional bytes tag = 1;       // SHA-256 of shared secret
+}
+
+/**
+ * Response: Trezor sends the QR secret.
+ * @next ThpCredentialRequest
+ * @next ThpEndRequest
+ */
+message ThpQrCodeSecret {
+    optional bytes secret = 1;    // Trezor's secret
+}
+
+/**
+ * Request: User selected Unidirectional NFC pairing option. Host sends an Unidirectional NFC Tag.
+ * @next ThpNfcTagTrezor
+ */
+message ThpNfcTagHost {
+    optional bytes tag = 1;       // Host's tag
+}
+
+/**
+ * Response: Trezor sends the Unidirectioal NFC secret.
+ * @next ThpCredentialRequest
+ * @next ThpEndRequest
+ */
+message ThpNfcTagTrezor {
+    optional bytes tag = 1;       // Trezor's tag
+}
+
+/**
+ * Request: Host requests issuance of a new pairing credential.
+ * @start
+ * @next ThpCredentialResponse
+ */
+message ThpCredentialRequest {
+    optional bytes host_static_pubkey = 1;       // Host's static public key used in the handshake.
+    optional bool autoconnect = 2;               // Whether host wants to autoconnect without user confirmation
+}
+
+/**
+ * Response: Trezor issues a new pairing credential.
+ * @next ThpCredentialRequest
+ * @next ThpEndRequest
+ */
+message ThpCredentialResponse {
+    optional bytes trezor_static_pubkey = 1;     // Trezor's static public key used in the handshake.
+    optional bytes credential = 2;               // The pairing credential issued by the Trezor to the host.
+}
+
+/**
+ * Request: Host requests transition to the encrypted traffic phase.
+ * @start
+ * @next ThpEndResponse
+ */
+message ThpEndRequest {}
+
+/**
+ * Response: Trezor approves transition to the encrypted traffic phase
+ * @end
+ */
+message ThpEndResponse {}
+
 /**
  * Only for internal use.
  * @embed
  */
  message ThpCredentialMetadata {
     option (internal_only) = true;
     optional string host_name = 1;     // Human-readable host name
+    optional bool autoconnect = 2;     // Whether host is allowed to autoconnect without user confirmation
 }
 
 /**

common/protob/messages.proto

@@ -134,6 +134,8 @@ enum MessageType {
     MessageType_DebugLinkWatchLayout = 9006 [(bitcoin_only) = true, (wire_debug_in) = true];
     MessageType_DebugLinkResetDebugEvents = 9007 [(bitcoin_only) = true, (wire_debug_in) = true];
     MessageType_DebugLinkOptigaSetSecMax = 9008 [(bitcoin_only) = true, (wire_debug_in) = true];
+    MessageType_DebugLinkGetPairingInfo = 9009 [(bitcoin_only) = true, (wire_debug_in) = true];
+    MessageType_DebugLinkPairingInfo = 9010 [(bitcoin_only) = true, (wire_debug_out) = true];
 
     // Ethereum
     MessageType_EthereumGetPublicKey = 450 [(wire_in) = true];

common/protob/pb2py

@@ -62,6 +62,7 @@ INT_TYPES = (
 )
 
 MESSAGE_TYPE_ENUM = "MessageType"
+THP_MESSAGE_TYPE_ENUM = "ThpMessageType"
 
 LengthDelimited = c.Struct(
     "len" / c.VarInt,
@@ -239,6 +240,9 @@ class ProtoMessage:
     @classmethod
     def from_message(cls, descriptor: "Descriptor", message):
         message_type = find_by_name(descriptor.message_type_enum.value, message.name)
+        thp_message_type = None
+        if not isinstance(descriptor.thp_message_type_enum,tuple):
+            thp_message_type = find_by_name(descriptor.thp_message_type_enum.value, message.name)
         # use extensions set on the message_type entry (if any)
         extensions = descriptor.get_extensions(message_type)
         # override with extensions set on the message itself
@@ -248,6 +252,8 @@ class ProtoMessage:
             wire_type = extensions["wire_type"]
         elif message_type is not None:
             wire_type = message_type.number
+        elif thp_message_type is not None:
+            wire_type = thp_message_type.number
         else:
             wire_type = None
 
@@ -351,10 +357,13 @@ class Descriptor:
             ]
             logging.debug(f"found {len(self.files)} bitcoin-only files")
 
-        # find message_type enum
+        # find message_type and thp_message_type enum
         top_level_enums = itertools.chain.from_iterable(f.enum_type for f in self.files)
         self.message_type_enum = find_by_name(top_level_enums, MESSAGE_TYPE_ENUM, ())
+        top_level_enums = itertools.chain.from_iterable(f.enum_type for f in self.files)
+        self.thp_message_type_enum = find_by_name(top_level_enums, THP_MESSAGE_TYPE_ENUM, ())
         self.convert_enum_value_names(self.message_type_enum)
+        self.convert_enum_value_names(self.thp_message_type_enum)
 
         # find messages and enums
         self.messages = []
@@ -423,6 +432,8 @@ class Descriptor:
             self._nested_types_from_message(nested.orig)
 
     def convert_enum_value_names(self, enum):
+        if isinstance(enum,tuple):
+            return
         for value in enum.value:
             value.name = strip_enum_prefix(enum.name, value.name)
 
@@ -558,6 +569,8 @@ class RustBlobRenderer:
         enums = []
         cursor = 0
         for enum in sorted(self.descriptor.enums, key=lambda e: e.name):
+            if enum.name == "MessageType":
+                continue
             self.enum_map[enum.name] = cursor
             enum_blob = ENUM_ENTRY.build(sorted(v.number for v in enum.value))
             enums.append(enum_blob)

core/Makefile

@@ -296,6 +296,10 @@ build_unix: templates ## build unix port
 build_unix_frozen: templates build_cross ## build unix port with frozen modules
 	$(SCONS) $(UNIX_BUILD_DIR)/trezor-emu-core $(UNIX_PORT_OPTS) TREZOR_EMULATOR_FROZEN=1
 
+build_unix_frozen_debug: templates build_cross ## build unix port with frozen modules and DEBUG (PYOPT="0")
+	$(SCONS) $(UNIX_BUILD_DIR)/trezor-emu-core $(UNIX_PORT_OPTS) TREZOR_EMULATOR_FROZEN=1 \
+		PYOPT=0
+
 build_unix_debug: templates ## build unix port
 	$(SCONS) --max-drift=1 $(UNIX_BUILD_DIR)/trezor-emu-core $(UNIX_PORT_OPTS) \
 		TREZOR_EMULATOR_ASAN=1 TREZOR_EMULATOR_DEBUGGABLE=1

core/SConscript.firmware

@@ -578,14 +578,23 @@ if FROZEN:
         ] if not EVERYTHING else []
     ))
 
+    if THP:
+        SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/wire/thp/*.py'))
+    if not THP or PYOPT == '0':
+        SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/wire/codec/*.py'))
+
     SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/wire/*.py'))
-    SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/wire/codec/*.py'))
 
-    SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'storage/*.py',
-        exclude=[
-            SOURCE_PY_DIR + 'storage/sd_salt.py',
-        ] if not SDCARD else []
-    ))
+
+    exclude_list = []
+    if 'sd_card' not in FEATURES_AVAILABLE:
+        exclude_list.append(SOURCE_PY_DIR + 'storage/sd_salt.py')
+    if THP and PYOPT == '1':
+        exclude_list.append(SOURCE_PY_DIR + 'storage/cache_codec.py')
+    if not THP:
+        exclude_list.append(SOURCE_PY_DIR + 'storage/cache_thp.py')
+
+    SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'storage/*.py', exclude=exclude_list))
 
     SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/messages/__init__.py'))
     SOURCE_PY.extend(Glob(SOURCE_PY_DIR + 'trezor/enums/*.py',