From f2e46f184183cb5c0f78336bca569f1016a95d65 Mon Sep 17 00:00:00 2001 From: M1nd3r Date: Thu, 28 Mar 2024 11:34:54 +0100 Subject: [PATCH] Fix protobuf --- common/protob/messages-thp.proto | 2 +- core/src/trezor/enums/MessageType.py | 8 + core/src/trezor/enums/PairingMethod.py | 8 + core/src/trezor/enums/__init__.py | 13 + core/src/trezor/messages.py | 85 +- core/tests/myTests.sh | 42 + python/src/trezorlib/messages.py | 89 ++ rust/trezor-client/src/messages/generated.rs | 8 + .../src/protos/generated/messages.rs | 108 +- .../src/protos/generated/messages_thp.rs | 962 ++++++++++++++++++ 10 files changed, 1283 insertions(+), 42 deletions(-) create mode 100644 core/src/trezor/enums/PairingMethod.py create mode 100755 core/tests/myTests.sh create mode 100644 rust/trezor-client/src/protos/generated/messages_thp.rs diff --git a/common/protob/messages-thp.proto b/common/protob/messages-thp.proto index 41309101b..919d28968 100644 --- a/common/protob/messages-thp.proto +++ b/common/protob/messages-thp.proto @@ -9,7 +9,7 @@ option java_outer_classname = "TrezorMessageThp"; // Numeric identifiers of pairing methods. enum PairingMethod { - PairingMethod_None = 1; // Trust without MITM protection. + PairingMethod_NoMethod = 1; // Trust without MITM protection. PairingMethod_CodeEntry = 2; // User types code diplayed on Trezor into the host application. PairingMethod_QrCode = 3; // User scans code displayed on Trezor into host application. PairingMethod_NFC_Unidirectional = 4; // Trezor transmits an authentication key to the host device via NFC. diff --git a/core/src/trezor/enums/MessageType.py b/core/src/trezor/enums/MessageType.py index 0023ef9f1..7bc467cd7 100644 --- a/core/src/trezor/enums/MessageType.py +++ b/core/src/trezor/enums/MessageType.py @@ -97,6 +97,14 @@ DebugLinkRecordScreen = 9003 DebugLinkEraseSdCard = 9005 DebugLinkWatchLayout = 9006 DebugLinkResetDebugEvents = 9007 +StartPairingRequest = 1000 +StartPairingResponse = 1001 +CredentialRequest = 1002 +CredentialResponse = 1003 +EndRequest = 1004 +EndResponse = 1005 +CreateNewSession = 1006 +NewSession = 1007 if not utils.BITCOIN_ONLY: SetU2FCounter = 63 GetNextU2FCounter = 80 diff --git a/core/src/trezor/enums/PairingMethod.py b/core/src/trezor/enums/PairingMethod.py new file mode 100644 index 000000000..b356cdf47 --- /dev/null +++ b/core/src/trezor/enums/PairingMethod.py @@ -0,0 +1,8 @@ +# Automatically generated by pb2py +# fmt: off +# isort:skip_file + +NoMethod = 1 +CodeEntry = 2 +QrCode = 3 +NFC_Unidirectional = 4 diff --git a/core/src/trezor/enums/__init__.py b/core/src/trezor/enums/__init__.py index cadc7ae17..c26138027 100644 --- a/core/src/trezor/enums/__init__.py +++ b/core/src/trezor/enums/__init__.py @@ -264,7 +264,14 @@ if TYPE_CHECKING: SolanaAddress = 903 SolanaSignTx = 904 SolanaTxSignature = 905 + StartPairingRequest = 1000 + StartPairingResponse = 1001 + CredentialRequest = 1002 + CredentialResponse = 1003 + EndRequest = 1004 + EndResponse = 1005 CreateNewSession = 1006 + NewSession = 1007 class FailureType(IntEnum): UnexpectedMessage = 1 @@ -544,3 +551,9 @@ if TYPE_CHECKING: Yay = 0 Nay = 1 Pass = 2 + + class PairingMethod(IntEnum): + NoMethod = 1 + CodeEntry = 2 + QrCode = 3 + NFC_Unidirectional = 4 diff --git a/core/src/trezor/messages.py b/core/src/trezor/messages.py index d7dec6b05..43959aa0d 100644 --- a/core/src/trezor/messages.py +++ b/core/src/trezor/messages.py @@ -51,6 +51,7 @@ if TYPE_CHECKING: from trezor.enums import NEMMosaicLevy # noqa: F401 from trezor.enums import NEMSupplyChangeType # noqa: F401 from trezor.enums import OutputScriptType # noqa: F401 + from trezor.enums import PairingMethod # noqa: F401 from trezor.enums import PinMatrixRequestType # noqa: F401 from trezor.enums import RecoveryDeviceType # noqa: F401 from trezor.enums import RequestType # noqa: F401 @@ -372,22 +373,6 @@ if TYPE_CHECKING: @classmethod def is_type_of(cls, msg: Any) -> TypeGuard["PassphraseAck"]: return isinstance(msg, cls) - - class CreateNewSession(protobuf.MessageType): - passphrase: "str | None" - on_device: "bool | None" - - def __init__( - self, - *, - passphrase: "str | None" = None, - on_device: "bool | None" = None, - ) -> None: - pass - - @classmethod - def is_type_of(cls, msg: Any) -> TypeGuard["CreateNewSession"]: - return isinstance(msg, cls) class HDNodeType(protobuf.MessageType): depth: "int" @@ -6113,6 +6098,74 @@ if TYPE_CHECKING: def is_type_of(cls, msg: Any) -> TypeGuard["TezosManagerTransfer"]: return isinstance(msg, cls) + class DeviceProperties(protobuf.MessageType): + internal_model: "str | None" + model_variant: "int | None" + bootloader_mode: "bool | None" + protocol_version: "int | None" + pairing_methods: "list[PairingMethod]" + + def __init__( + self, + *, + pairing_methods: "list[PairingMethod] | None" = None, + internal_model: "str | None" = None, + model_variant: "int | None" = None, + bootloader_mode: "bool | None" = None, + protocol_version: "int | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: Any) -> TypeGuard["DeviceProperties"]: + return isinstance(msg, cls) + + class HandshakeCompletionReqNoisePayload(protobuf.MessageType): + host_pairing_credential: "bytes | None" + pairing_methods: "list[PairingMethod]" + + def __init__( + self, + *, + pairing_methods: "list[PairingMethod] | None" = None, + host_pairing_credential: "bytes | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: Any) -> TypeGuard["HandshakeCompletionReqNoisePayload"]: + return isinstance(msg, cls) + + class CreateNewSession(protobuf.MessageType): + passphrase: "str | None" + on_device: "bool | None" + + def __init__( + self, + *, + passphrase: "str | None" = None, + on_device: "bool | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: Any) -> TypeGuard["CreateNewSession"]: + return isinstance(msg, cls) + + class NewSession(protobuf.MessageType): + new_session_id: "int | None" + + def __init__( + self, + *, + new_session_id: "int | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: Any) -> TypeGuard["NewSession"]: + return isinstance(msg, cls) + class WebAuthnListResidentCredentials(protobuf.MessageType): @classmethod diff --git a/core/tests/myTests.sh b/core/tests/myTests.sh new file mode 100755 index 000000000..ca55f0b5a --- /dev/null +++ b/core/tests/myTests.sh @@ -0,0 +1,42 @@ +#!/usr/bin/env bash + +declare -a results +declare -i passed=0 failed=0 exit_code=0 +declare COLOR_GREEN='\e[32m' COLOR_RED='\e[91m' COLOR_RESET='\e[39m' +MICROPYTHON="${MICROPYTHON:-../build/unix/trezor-emu-core -X heapsize=2M}" +print_summary() { + echo + echo 'Summary:' + echo '-------------------' + printf '%b\n' "${results[@]}" + if [ $exit_code == 0 ]; then + echo -e "${COLOR_GREEN}PASSED:${COLOR_RESET} $passed/$num_of_tests tests OK!" + else + echo -e "${COLOR_RED}FAILED:${COLOR_RESET} $failed/$num_of_tests tests failed!" + fi +} + +trap 'print_summary; echo -e "${COLOR_RED}Interrupted by user!${COLOR_RESET}"; exit 1' SIGINT + +cd $(dirname $0) + +[ -z "$*" ] && tests=(test_trezor.wire.t*.py ) || tests=($*) + +declare -i num_of_tests=${#tests[@]} + +for test_case in ${tests[@]}; do + echo ${MICROPYTHON} + echo ${test_case} + echo + if $MICROPYTHON $test_case; then + results+=("${COLOR_GREEN}OK:${COLOR_RESET} $test_case") + ((passed++)) + else + results+=("${COLOR_RED}FAIL:${COLOR_RESET} $test_case") + ((failed++)) + exit_code=1 + fi +done + +print_summary +exit $exit_code diff --git a/python/src/trezorlib/messages.py b/python/src/trezorlib/messages.py index d52619a5e..a8e14325b 100644 --- a/python/src/trezorlib/messages.py +++ b/python/src/trezorlib/messages.py @@ -272,6 +272,14 @@ class MessageType(IntEnum): SolanaAddress = 903 SolanaSignTx = 904 SolanaTxSignature = 905 + StartPairingRequest = 1000 + StartPairingResponse = 1001 + CredentialRequest = 1002 + CredentialResponse = 1003 + EndRequest = 1004 + EndResponse = 1005 + CreateNewSession = 1006 + NewSession = 1007 class FailureType(IntEnum): @@ -595,6 +603,13 @@ class TezosBallotType(IntEnum): Pass = 2 +class PairingMethod(IntEnum): + NoMethod = 1 + CodeEntry = 2 + QrCode = 3 + NFC_Unidirectional = 4 + + class BinanceGetAddress(protobuf.MessageType): MESSAGE_WIRE_TYPE = 700 FIELDS = { @@ -7701,6 +7716,80 @@ class TezosManagerTransfer(protobuf.MessageType): self.amount = amount +class DeviceProperties(protobuf.MessageType): + MESSAGE_WIRE_TYPE = None + FIELDS = { + 1: protobuf.Field("internal_model", "string", repeated=False, required=False, default=None), + 2: protobuf.Field("model_variant", "uint32", repeated=False, required=False, default=None), + 3: protobuf.Field("bootloader_mode", "bool", repeated=False, required=False, default=None), + 4: protobuf.Field("protocol_version", "uint32", repeated=False, required=False, default=None), + 5: protobuf.Field("pairing_methods", "PairingMethod", repeated=True, required=False, default=None), + } + + def __init__( + self, + *, + pairing_methods: Optional[Sequence["PairingMethod"]] = None, + internal_model: Optional["str"] = None, + model_variant: Optional["int"] = None, + bootloader_mode: Optional["bool"] = None, + protocol_version: Optional["int"] = None, + ) -> None: + self.pairing_methods: Sequence["PairingMethod"] = pairing_methods if pairing_methods is not None else [] + self.internal_model = internal_model + self.model_variant = model_variant + self.bootloader_mode = bootloader_mode + self.protocol_version = protocol_version + + +class HandshakeCompletionReqNoisePayload(protobuf.MessageType): + MESSAGE_WIRE_TYPE = None + FIELDS = { + 1: protobuf.Field("host_pairing_credential", "bytes", repeated=False, required=False, default=None), + 2: protobuf.Field("pairing_methods", "PairingMethod", repeated=True, required=False, default=None), + } + + def __init__( + self, + *, + pairing_methods: Optional[Sequence["PairingMethod"]] = None, + host_pairing_credential: Optional["bytes"] = None, + ) -> None: + self.pairing_methods: Sequence["PairingMethod"] = pairing_methods if pairing_methods is not None else [] + self.host_pairing_credential = host_pairing_credential + + +class CreateNewSession(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 1006 + FIELDS = { + 1: protobuf.Field("passphrase", "string", repeated=False, required=False, default=None), + 2: protobuf.Field("on_device", "bool", repeated=False, required=False, default=None), + } + + def __init__( + self, + *, + passphrase: Optional["str"] = None, + on_device: Optional["bool"] = None, + ) -> None: + self.passphrase = passphrase + self.on_device = on_device + + +class NewSession(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 1007 + FIELDS = { + 1: protobuf.Field("new_session_id", "uint32", repeated=False, required=False, default=None), + } + + def __init__( + self, + *, + new_session_id: Optional["int"] = None, + ) -> None: + self.new_session_id = new_session_id + + class WebAuthnListResidentCredentials(protobuf.MessageType): MESSAGE_WIRE_TYPE = 800 diff --git a/rust/trezor-client/src/messages/generated.rs b/rust/trezor-client/src/messages/generated.rs index f0737a52a..dcd1713d9 100644 --- a/rust/trezor-client/src/messages/generated.rs +++ b/rust/trezor-client/src/messages/generated.rs @@ -82,6 +82,14 @@ trezor_message_impl! { DebugLinkEraseSdCard => MessageType_DebugLinkEraseSdCard, DebugLinkWatchLayout => MessageType_DebugLinkWatchLayout, DebugLinkResetDebugEvents => MessageType_DebugLinkResetDebugEvents, + StartPairingRequest => MessageType_StartPairingRequest, + StartPairingResponse => MessageType_StartPairingResponse, + CredentialRequest => MessageType_CredentialRequest, + CredentialResponse => MessageType_CredentialResponse, + EndRequest => MessageType_EndRequest, + EndResponse => MessageType_EndResponse, + CreateNewSession => MessageType_CreateNewSession, + NewSession => MessageType_NewSession, } #[cfg(feature = "binance")] diff --git a/rust/trezor-client/src/protos/generated/messages.rs b/rust/trezor-client/src/protos/generated/messages.rs index ebd3224f2..d91997b31 100644 --- a/rust/trezor-client/src/protos/generated/messages.rs +++ b/rust/trezor-client/src/protos/generated/messages.rs @@ -514,6 +514,22 @@ pub enum MessageType { MessageType_SolanaSignTx = 904, // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_SolanaTxSignature) MessageType_SolanaTxSignature = 905, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_StartPairingRequest) + MessageType_StartPairingRequest = 1000, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_StartPairingResponse) + MessageType_StartPairingResponse = 1001, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_CredentialRequest) + MessageType_CredentialRequest = 1002, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_CredentialResponse) + MessageType_CredentialResponse = 1003, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_EndRequest) + MessageType_EndRequest = 1004, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_EndResponse) + MessageType_EndResponse = 1005, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_CreateNewSession) + MessageType_CreateNewSession = 1006, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.MessageType.MessageType_NewSession) + MessageType_NewSession = 1007, } impl ::protobuf::Enum for MessageType { @@ -768,6 +784,14 @@ impl ::protobuf::Enum for MessageType { 903 => ::std::option::Option::Some(MessageType::MessageType_SolanaAddress), 904 => ::std::option::Option::Some(MessageType::MessageType_SolanaSignTx), 905 => ::std::option::Option::Some(MessageType::MessageType_SolanaTxSignature), + 1000 => ::std::option::Option::Some(MessageType::MessageType_StartPairingRequest), + 1001 => ::std::option::Option::Some(MessageType::MessageType_StartPairingResponse), + 1002 => ::std::option::Option::Some(MessageType::MessageType_CredentialRequest), + 1003 => ::std::option::Option::Some(MessageType::MessageType_CredentialResponse), + 1004 => ::std::option::Option::Some(MessageType::MessageType_EndRequest), + 1005 => ::std::option::Option::Some(MessageType::MessageType_EndResponse), + 1006 => ::std::option::Option::Some(MessageType::MessageType_CreateNewSession), + 1007 => ::std::option::Option::Some(MessageType::MessageType_NewSession), _ => ::std::option::Option::None } } @@ -1017,6 +1041,14 @@ impl ::protobuf::Enum for MessageType { "MessageType_SolanaAddress" => ::std::option::Option::Some(MessageType::MessageType_SolanaAddress), "MessageType_SolanaSignTx" => ::std::option::Option::Some(MessageType::MessageType_SolanaSignTx), "MessageType_SolanaTxSignature" => ::std::option::Option::Some(MessageType::MessageType_SolanaTxSignature), + "MessageType_StartPairingRequest" => ::std::option::Option::Some(MessageType::MessageType_StartPairingRequest), + "MessageType_StartPairingResponse" => ::std::option::Option::Some(MessageType::MessageType_StartPairingResponse), + "MessageType_CredentialRequest" => ::std::option::Option::Some(MessageType::MessageType_CredentialRequest), + "MessageType_CredentialResponse" => ::std::option::Option::Some(MessageType::MessageType_CredentialResponse), + "MessageType_EndRequest" => ::std::option::Option::Some(MessageType::MessageType_EndRequest), + "MessageType_EndResponse" => ::std::option::Option::Some(MessageType::MessageType_EndResponse), + "MessageType_CreateNewSession" => ::std::option::Option::Some(MessageType::MessageType_CreateNewSession), + "MessageType_NewSession" => ::std::option::Option::Some(MessageType::MessageType_NewSession), _ => ::std::option::Option::None } } @@ -1265,6 +1297,14 @@ impl ::protobuf::Enum for MessageType { MessageType::MessageType_SolanaAddress, MessageType::MessageType_SolanaSignTx, MessageType::MessageType_SolanaTxSignature, + MessageType::MessageType_StartPairingRequest, + MessageType::MessageType_StartPairingResponse, + MessageType::MessageType_CredentialRequest, + MessageType::MessageType_CredentialResponse, + MessageType::MessageType_EndRequest, + MessageType::MessageType_EndResponse, + MessageType::MessageType_CreateNewSession, + MessageType::MessageType_NewSession, ]; } @@ -1519,6 +1559,14 @@ impl ::protobuf::EnumFull for MessageType { MessageType::MessageType_SolanaAddress => 240, MessageType::MessageType_SolanaSignTx => 241, MessageType::MessageType_SolanaTxSignature => 242, + MessageType::MessageType_StartPairingRequest => 243, + MessageType::MessageType_StartPairingResponse => 244, + MessageType::MessageType_CredentialRequest => 245, + MessageType::MessageType_CredentialResponse => 246, + MessageType::MessageType_EndRequest => 247, + MessageType::MessageType_EndResponse => 248, + MessageType::MessageType_CreateNewSession => 249, + MessageType::MessageType_NewSession => 250, }; Self::enum_descriptor().value_by_index(index) } @@ -1568,7 +1616,7 @@ pub mod exts { static file_descriptor_proto_data: &'static [u8] = b"\ \n\x0emessages.proto\x12\x12hw.trezor.messages\x1a\x20google/protobuf/de\ - scriptor.proto*\x9aT\n\x0bMessageType\x12(\n\x16MessageType_Initialize\ + scriptor.proto*\xfbV\n\x0bMessageType\x12(\n\x16MessageType_Initialize\ \x10\0\x1a\x0c\x80\xa6\x1d\x01\xb0\xb5\x18\x01\x90\xb5\x18\x01\x12\x1e\n\ \x10MessageType_Ping\x10\x01\x1a\x08\x80\xa6\x1d\x01\x90\xb5\x18\x01\x12\ %\n\x13MessageType_Success\x10\x02\x1a\x0c\x80\xa6\x1d\x01\xa8\xb5\x18\ @@ -1843,30 +1891,40 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x07\x1a\x04\x90\xb5\x18\x01\x12$\n\x19MessageType_SolanaAddress\x10\x87\ \x07\x1a\x04\x98\xb5\x18\x01\x12#\n\x18MessageType_SolanaSignTx\x10\x88\ \x07\x1a\x04\x90\xb5\x18\x01\x12(\n\x1dMessageType_SolanaTxSignature\x10\ - \x89\x07\x1a\x04\x98\xb5\x18\x01\x1a\x04\xc8\xf3\x18\x01\"\x04\x08Z\x10\ - \\\"\x04\x08r\x10z\"\x06\x08\xdb\x01\x10\xdb\x01\"\x06\x08\xe0\x01\x10\ - \xe0\x01\"\x06\x08\xac\x02\x10\xb0\x02\"\x06\x08\xb5\x02\x10\xb8\x02:<\n\ - \x07wire_in\x18\xd2\x86\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueO\ - ptionsR\x06wireIn:>\n\x08wire_out\x18\xd3\x86\x03\x20\x01(\x08\x12!.goog\ - le.protobuf.EnumValueOptionsR\x07wireOut:G\n\rwire_debug_in\x18\xd4\x86\ - \x03\x20\x01(\x08\x12!.google.protobuf.EnumValueOptionsR\x0bwireDebugIn:\ - I\n\x0ewire_debug_out\x18\xd5\x86\x03\x20\x01(\x08\x12!.google.protobuf.\ - EnumValueOptionsR\x0cwireDebugOut:@\n\twire_tiny\x18\xd6\x86\x03\x20\x01\ - (\x08\x12!.google.protobuf.EnumValueOptionsR\x08wireTiny:L\n\x0fwire_boo\ - tloader\x18\xd7\x86\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueOptio\ - nsR\x0ewireBootloader:C\n\x0bwire_no_fsm\x18\xd8\x86\x03\x20\x01(\x08\ - \x12!.google.protobuf.EnumValueOptionsR\twireNoFsm:F\n\x0cbitcoin_only\ - \x18\xe0\xd4\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueOptionsR\x0b\ - bitcoinOnly:U\n\x17has_bitcoin_only_values\x18\xb9\x8e\x03\x20\x01(\x08\ - \x12\x1c.google.protobuf.EnumOptionsR\x14hasBitcoinOnlyValues:T\n\x14exp\ - erimental_message\x18\xa1\x96\x03\x20\x01(\x08\x12\x1f.google.protobuf.M\ - essageOptionsR\x13experimentalMessage:>\n\twire_type\x18\xa2\x96\x03\x20\ - \x01(\r\x12\x1f.google.protobuf.MessageOptionsR\x08wireType:N\n\x12exper\ - imental_field\x18\x89\x9e\x03\x20\x01(\x08\x12\x1d.google.protobuf.Field\ - OptionsR\x11experimentalField:U\n\x17include_in_bitcoin_only\x18\xe0\xd4\ - \x03\x20\x01(\x08\x12\x1c.google.protobuf.FileOptionsR\x14includeInBitco\ - inOnlyB8\n#com.satoshilabs.trezor.lib.protobufB\rTrezorMessage\x80\xa6\ - \x1d\x01\ + \x89\x07\x1a\x04\x98\xb5\x18\x01\x12.\n\x1fMessageType_StartPairingReque\ + st\x10\xe8\x07\x1a\x08\x80\xa6\x1d\x01\x90\xb5\x18\x01\x12/\n\x20Message\ + Type_StartPairingResponse\x10\xe9\x07\x1a\x08\x80\xa6\x1d\x01\x98\xb5\ + \x18\x01\x12,\n\x1dMessageType_CredentialRequest\x10\xea\x07\x1a\x08\x80\ + \xa6\x1d\x01\x90\xb5\x18\x01\x12-\n\x1eMessageType_CredentialResponse\ + \x10\xeb\x07\x1a\x08\x80\xa6\x1d\x01\x98\xb5\x18\x01\x12%\n\x16MessageTy\ + pe_EndRequest\x10\xec\x07\x1a\x08\x80\xa6\x1d\x01\x90\xb5\x18\x01\x12&\n\ + \x17MessageType_EndResponse\x10\xed\x07\x1a\x08\x80\xa6\x1d\x01\x98\xb5\ + \x18\x01\x12+\n\x1cMessageType_CreateNewSession\x10\xee\x07\x1a\x08\x80\ + \xa6\x1d\x01\x90\xb5\x18\x01\x12%\n\x16MessageType_NewSession\x10\xef\ + \x07\x1a\x08\x80\xa6\x1d\x01\x98\xb5\x18\x01\x1a\x04\xc8\xf3\x18\x01\"\ + \x04\x08Z\x10\\\"\x04\x08r\x10z\"\x06\x08\xdb\x01\x10\xdb\x01\"\x06\x08\ + \xe0\x01\x10\xe0\x01\"\x06\x08\xac\x02\x10\xb0\x02\"\x06\x08\xb5\x02\x10\ + \xb8\x02:<\n\x07wire_in\x18\xd2\x86\x03\x20\x01(\x08\x12!.google.protobu\ + f.EnumValueOptionsR\x06wireIn:>\n\x08wire_out\x18\xd3\x86\x03\x20\x01(\ + \x08\x12!.google.protobuf.EnumValueOptionsR\x07wireOut:G\n\rwire_debug_i\ + n\x18\xd4\x86\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueOptionsR\ + \x0bwireDebugIn:I\n\x0ewire_debug_out\x18\xd5\x86\x03\x20\x01(\x08\x12!.\ + google.protobuf.EnumValueOptionsR\x0cwireDebugOut:@\n\twire_tiny\x18\xd6\ + \x86\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueOptionsR\x08wireTiny\ + :L\n\x0fwire_bootloader\x18\xd7\x86\x03\x20\x01(\x08\x12!.google.protobu\ + f.EnumValueOptionsR\x0ewireBootloader:C\n\x0bwire_no_fsm\x18\xd8\x86\x03\ + \x20\x01(\x08\x12!.google.protobuf.EnumValueOptionsR\twireNoFsm:F\n\x0cb\ + itcoin_only\x18\xe0\xd4\x03\x20\x01(\x08\x12!.google.protobuf.EnumValueO\ + ptionsR\x0bbitcoinOnly:U\n\x17has_bitcoin_only_values\x18\xb9\x8e\x03\ + \x20\x01(\x08\x12\x1c.google.protobuf.EnumOptionsR\x14hasBitcoinOnlyValu\ + es:T\n\x14experimental_message\x18\xa1\x96\x03\x20\x01(\x08\x12\x1f.goog\ + le.protobuf.MessageOptionsR\x13experimentalMessage:>\n\twire_type\x18\ + \xa2\x96\x03\x20\x01(\r\x12\x1f.google.protobuf.MessageOptionsR\x08wireT\ + ype:N\n\x12experimental_field\x18\x89\x9e\x03\x20\x01(\x08\x12\x1d.googl\ + e.protobuf.FieldOptionsR\x11experimentalField:U\n\x17include_in_bitcoin_\ + only\x18\xe0\xd4\x03\x20\x01(\x08\x12\x1c.google.protobuf.FileOptionsR\ + \x14includeInBitcoinOnlyB8\n#com.satoshilabs.trezor.lib.protobufB\rTrezo\ + rMessage\x80\xa6\x1d\x01\ "; /// `FileDescriptorProto` object which was a source for this generated file diff --git a/rust/trezor-client/src/protos/generated/messages_thp.rs b/rust/trezor-client/src/protos/generated/messages_thp.rs new file mode 100644 index 000000000..eaca90070 --- /dev/null +++ b/rust/trezor-client/src/protos/generated/messages_thp.rs @@ -0,0 +1,962 @@ +// This file is generated by rust-protobuf 3.3.0. Do not edit +// .proto file is parsed by protoc 3.19.6 +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_results)] +#![allow(unused_mut)] + +//! Generated file from `messages-thp.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_3_0; + +// @@protoc_insertion_point(message:hw.trezor.messages.thp.DeviceProperties) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct DeviceProperties { + // message fields + // @@protoc_insertion_point(field:hw.trezor.messages.thp.DeviceProperties.internal_model) + pub internal_model: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.DeviceProperties.model_variant) + pub model_variant: ::std::option::Option, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.DeviceProperties.bootloader_mode) + pub bootloader_mode: ::std::option::Option, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.DeviceProperties.protocol_version) + pub protocol_version: ::std::option::Option, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.DeviceProperties.pairing_methods) + pub pairing_methods: ::std::vec::Vec<::protobuf::EnumOrUnknown>, + // special fields + // @@protoc_insertion_point(special_field:hw.trezor.messages.thp.DeviceProperties.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a DeviceProperties { + fn default() -> &'a DeviceProperties { + ::default_instance() + } +} + +impl DeviceProperties { + pub fn new() -> DeviceProperties { + ::std::default::Default::default() + } + + // optional string internal_model = 1; + + pub fn internal_model(&self) -> &str { + match self.internal_model.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_internal_model(&mut self) { + self.internal_model = ::std::option::Option::None; + } + + pub fn has_internal_model(&self) -> bool { + self.internal_model.is_some() + } + + // Param is passed by value, moved + pub fn set_internal_model(&mut self, v: ::std::string::String) { + self.internal_model = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_internal_model(&mut self) -> &mut ::std::string::String { + if self.internal_model.is_none() { + self.internal_model = ::std::option::Option::Some(::std::string::String::new()); + } + self.internal_model.as_mut().unwrap() + } + + // Take field + pub fn take_internal_model(&mut self) -> ::std::string::String { + self.internal_model.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional uint32 model_variant = 2; + + pub fn model_variant(&self) -> u32 { + self.model_variant.unwrap_or(0) + } + + pub fn clear_model_variant(&mut self) { + self.model_variant = ::std::option::Option::None; + } + + pub fn has_model_variant(&self) -> bool { + self.model_variant.is_some() + } + + // Param is passed by value, moved + pub fn set_model_variant(&mut self, v: u32) { + self.model_variant = ::std::option::Option::Some(v); + } + + // optional bool bootloader_mode = 3; + + pub fn bootloader_mode(&self) -> bool { + self.bootloader_mode.unwrap_or(false) + } + + pub fn clear_bootloader_mode(&mut self) { + self.bootloader_mode = ::std::option::Option::None; + } + + pub fn has_bootloader_mode(&self) -> bool { + self.bootloader_mode.is_some() + } + + // Param is passed by value, moved + pub fn set_bootloader_mode(&mut self, v: bool) { + self.bootloader_mode = ::std::option::Option::Some(v); + } + + // optional uint32 protocol_version = 4; + + pub fn protocol_version(&self) -> u32 { + self.protocol_version.unwrap_or(0) + } + + pub fn clear_protocol_version(&mut self) { + self.protocol_version = ::std::option::Option::None; + } + + pub fn has_protocol_version(&self) -> bool { + self.protocol_version.is_some() + } + + // Param is passed by value, moved + pub fn set_protocol_version(&mut self, v: u32) { + self.protocol_version = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(5); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "internal_model", + |m: &DeviceProperties| { &m.internal_model }, + |m: &mut DeviceProperties| { &mut m.internal_model }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "model_variant", + |m: &DeviceProperties| { &m.model_variant }, + |m: &mut DeviceProperties| { &mut m.model_variant }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "bootloader_mode", + |m: &DeviceProperties| { &m.bootloader_mode }, + |m: &mut DeviceProperties| { &mut m.bootloader_mode }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "protocol_version", + |m: &DeviceProperties| { &m.protocol_version }, + |m: &mut DeviceProperties| { &mut m.protocol_version }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "pairing_methods", + |m: &DeviceProperties| { &m.pairing_methods }, + |m: &mut DeviceProperties| { &mut m.pairing_methods }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "DeviceProperties", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for DeviceProperties { + const NAME: &'static str = "DeviceProperties"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.internal_model = ::std::option::Option::Some(is.read_string()?); + }, + 16 => { + self.model_variant = ::std::option::Option::Some(is.read_uint32()?); + }, + 24 => { + self.bootloader_mode = ::std::option::Option::Some(is.read_bool()?); + }, + 32 => { + self.protocol_version = ::std::option::Option::Some(is.read_uint32()?); + }, + 40 => { + self.pairing_methods.push(is.read_enum_or_unknown()?); + }, + 42 => { + ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.pairing_methods)? + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.internal_model.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.model_variant { + my_size += ::protobuf::rt::uint32_size(2, v); + } + if let Some(v) = self.bootloader_mode { + my_size += 1 + 1; + } + if let Some(v) = self.protocol_version { + my_size += ::protobuf::rt::uint32_size(4, v); + } + for value in &self.pairing_methods { + my_size += ::protobuf::rt::int32_size(5, value.value()); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.internal_model.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.model_variant { + os.write_uint32(2, v)?; + } + if let Some(v) = self.bootloader_mode { + os.write_bool(3, v)?; + } + if let Some(v) = self.protocol_version { + os.write_uint32(4, v)?; + } + for v in &self.pairing_methods { + os.write_enum(5, ::protobuf::EnumOrUnknown::value(v))?; + }; + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> DeviceProperties { + DeviceProperties::new() + } + + fn clear(&mut self) { + self.internal_model = ::std::option::Option::None; + self.model_variant = ::std::option::Option::None; + self.bootloader_mode = ::std::option::Option::None; + self.protocol_version = ::std::option::Option::None; + self.pairing_methods.clear(); + self.special_fields.clear(); + } + + fn default_instance() -> &'static DeviceProperties { + static instance: DeviceProperties = DeviceProperties { + internal_model: ::std::option::Option::None, + model_variant: ::std::option::Option::None, + bootloader_mode: ::std::option::Option::None, + protocol_version: ::std::option::Option::None, + pairing_methods: ::std::vec::Vec::new(), + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for DeviceProperties { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceProperties").unwrap()).clone() + } +} + +impl ::std::fmt::Display for DeviceProperties { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeviceProperties { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +// @@protoc_insertion_point(message:hw.trezor.messages.thp.HandshakeCompletionReqNoisePayload) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct HandshakeCompletionReqNoisePayload { + // message fields + // @@protoc_insertion_point(field:hw.trezor.messages.thp.HandshakeCompletionReqNoisePayload.host_pairing_credential) + pub host_pairing_credential: ::std::option::Option<::std::vec::Vec>, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.HandshakeCompletionReqNoisePayload.pairing_methods) + pub pairing_methods: ::std::vec::Vec<::protobuf::EnumOrUnknown>, + // special fields + // @@protoc_insertion_point(special_field:hw.trezor.messages.thp.HandshakeCompletionReqNoisePayload.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a HandshakeCompletionReqNoisePayload { + fn default() -> &'a HandshakeCompletionReqNoisePayload { + ::default_instance() + } +} + +impl HandshakeCompletionReqNoisePayload { + pub fn new() -> HandshakeCompletionReqNoisePayload { + ::std::default::Default::default() + } + + // optional bytes host_pairing_credential = 1; + + pub fn host_pairing_credential(&self) -> &[u8] { + match self.host_pairing_credential.as_ref() { + Some(v) => v, + None => &[], + } + } + + pub fn clear_host_pairing_credential(&mut self) { + self.host_pairing_credential = ::std::option::Option::None; + } + + pub fn has_host_pairing_credential(&self) -> bool { + self.host_pairing_credential.is_some() + } + + // Param is passed by value, moved + pub fn set_host_pairing_credential(&mut self, v: ::std::vec::Vec) { + self.host_pairing_credential = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_host_pairing_credential(&mut self) -> &mut ::std::vec::Vec { + if self.host_pairing_credential.is_none() { + self.host_pairing_credential = ::std::option::Option::Some(::std::vec::Vec::new()); + } + self.host_pairing_credential.as_mut().unwrap() + } + + // Take field + pub fn take_host_pairing_credential(&mut self) -> ::std::vec::Vec { + self.host_pairing_credential.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "host_pairing_credential", + |m: &HandshakeCompletionReqNoisePayload| { &m.host_pairing_credential }, + |m: &mut HandshakeCompletionReqNoisePayload| { &mut m.host_pairing_credential }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "pairing_methods", + |m: &HandshakeCompletionReqNoisePayload| { &m.pairing_methods }, + |m: &mut HandshakeCompletionReqNoisePayload| { &mut m.pairing_methods }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "HandshakeCompletionReqNoisePayload", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for HandshakeCompletionReqNoisePayload { + const NAME: &'static str = "HandshakeCompletionReqNoisePayload"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.host_pairing_credential = ::std::option::Option::Some(is.read_bytes()?); + }, + 16 => { + self.pairing_methods.push(is.read_enum_or_unknown()?); + }, + 18 => { + ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.pairing_methods)? + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.host_pairing_credential.as_ref() { + my_size += ::protobuf::rt::bytes_size(1, &v); + } + for value in &self.pairing_methods { + my_size += ::protobuf::rt::int32_size(2, value.value()); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.host_pairing_credential.as_ref() { + os.write_bytes(1, v)?; + } + for v in &self.pairing_methods { + os.write_enum(2, ::protobuf::EnumOrUnknown::value(v))?; + }; + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> HandshakeCompletionReqNoisePayload { + HandshakeCompletionReqNoisePayload::new() + } + + fn clear(&mut self) { + self.host_pairing_credential = ::std::option::Option::None; + self.pairing_methods.clear(); + self.special_fields.clear(); + } + + fn default_instance() -> &'static HandshakeCompletionReqNoisePayload { + static instance: HandshakeCompletionReqNoisePayload = HandshakeCompletionReqNoisePayload { + host_pairing_credential: ::std::option::Option::None, + pairing_methods: ::std::vec::Vec::new(), + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for HandshakeCompletionReqNoisePayload { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("HandshakeCompletionReqNoisePayload").unwrap()).clone() + } +} + +impl ::std::fmt::Display for HandshakeCompletionReqNoisePayload { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for HandshakeCompletionReqNoisePayload { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +// @@protoc_insertion_point(message:hw.trezor.messages.thp.CreateNewSession) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct CreateNewSession { + // message fields + // @@protoc_insertion_point(field:hw.trezor.messages.thp.CreateNewSession.passphrase) + pub passphrase: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:hw.trezor.messages.thp.CreateNewSession.on_device) + pub on_device: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:hw.trezor.messages.thp.CreateNewSession.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a CreateNewSession { + fn default() -> &'a CreateNewSession { + ::default_instance() + } +} + +impl CreateNewSession { + pub fn new() -> CreateNewSession { + ::std::default::Default::default() + } + + // optional string passphrase = 1; + + pub fn passphrase(&self) -> &str { + match self.passphrase.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_passphrase(&mut self) { + self.passphrase = ::std::option::Option::None; + } + + pub fn has_passphrase(&self) -> bool { + self.passphrase.is_some() + } + + // Param is passed by value, moved + pub fn set_passphrase(&mut self, v: ::std::string::String) { + self.passphrase = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_passphrase(&mut self) -> &mut ::std::string::String { + if self.passphrase.is_none() { + self.passphrase = ::std::option::Option::Some(::std::string::String::new()); + } + self.passphrase.as_mut().unwrap() + } + + // Take field + pub fn take_passphrase(&mut self) -> ::std::string::String { + self.passphrase.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool on_device = 2; + + pub fn on_device(&self) -> bool { + self.on_device.unwrap_or(false) + } + + pub fn clear_on_device(&mut self) { + self.on_device = ::std::option::Option::None; + } + + pub fn has_on_device(&self) -> bool { + self.on_device.is_some() + } + + // Param is passed by value, moved + pub fn set_on_device(&mut self, v: bool) { + self.on_device = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "passphrase", + |m: &CreateNewSession| { &m.passphrase }, + |m: &mut CreateNewSession| { &mut m.passphrase }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "on_device", + |m: &CreateNewSession| { &m.on_device }, + |m: &mut CreateNewSession| { &mut m.on_device }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "CreateNewSession", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for CreateNewSession { + const NAME: &'static str = "CreateNewSession"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.passphrase = ::std::option::Option::Some(is.read_string()?); + }, + 16 => { + self.on_device = ::std::option::Option::Some(is.read_bool()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.passphrase.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.on_device { + my_size += 1 + 1; + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.passphrase.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.on_device { + os.write_bool(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> CreateNewSession { + CreateNewSession::new() + } + + fn clear(&mut self) { + self.passphrase = ::std::option::Option::None; + self.on_device = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static CreateNewSession { + static instance: CreateNewSession = CreateNewSession { + passphrase: ::std::option::Option::None, + on_device: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for CreateNewSession { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("CreateNewSession").unwrap()).clone() + } +} + +impl ::std::fmt::Display for CreateNewSession { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateNewSession { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +// @@protoc_insertion_point(message:hw.trezor.messages.thp.NewSession) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct NewSession { + // message fields + // @@protoc_insertion_point(field:hw.trezor.messages.thp.NewSession.new_session_id) + pub new_session_id: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:hw.trezor.messages.thp.NewSession.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a NewSession { + fn default() -> &'a NewSession { + ::default_instance() + } +} + +impl NewSession { + pub fn new() -> NewSession { + ::std::default::Default::default() + } + + // optional uint32 new_session_id = 1; + + pub fn new_session_id(&self) -> u32 { + self.new_session_id.unwrap_or(0) + } + + pub fn clear_new_session_id(&mut self) { + self.new_session_id = ::std::option::Option::None; + } + + pub fn has_new_session_id(&self) -> bool { + self.new_session_id.is_some() + } + + // Param is passed by value, moved + pub fn set_new_session_id(&mut self, v: u32) { + self.new_session_id = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(1); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "new_session_id", + |m: &NewSession| { &m.new_session_id }, + |m: &mut NewSession| { &mut m.new_session_id }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "NewSession", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for NewSession { + const NAME: &'static str = "NewSession"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.new_session_id = ::std::option::Option::Some(is.read_uint32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.new_session_id { + my_size += ::protobuf::rt::uint32_size(1, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.new_session_id { + os.write_uint32(1, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> NewSession { + NewSession::new() + } + + fn clear(&mut self) { + self.new_session_id = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static NewSession { + static instance: NewSession = NewSession { + new_session_id: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for NewSession { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("NewSession").unwrap()).clone() + } +} + +impl ::std::fmt::Display for NewSession { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for NewSession { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] +// @@protoc_insertion_point(enum:hw.trezor.messages.thp.PairingMethod) +pub enum PairingMethod { + // @@protoc_insertion_point(enum_value:hw.trezor.messages.thp.PairingMethod.PairingMethod_NoMethod) + PairingMethod_NoMethod = 1, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.thp.PairingMethod.PairingMethod_CodeEntry) + PairingMethod_CodeEntry = 2, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.thp.PairingMethod.PairingMethod_QrCode) + PairingMethod_QrCode = 3, + // @@protoc_insertion_point(enum_value:hw.trezor.messages.thp.PairingMethod.PairingMethod_NFC_Unidirectional) + PairingMethod_NFC_Unidirectional = 4, +} + +impl ::protobuf::Enum for PairingMethod { + const NAME: &'static str = "PairingMethod"; + + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(PairingMethod::PairingMethod_NoMethod), + 2 => ::std::option::Option::Some(PairingMethod::PairingMethod_CodeEntry), + 3 => ::std::option::Option::Some(PairingMethod::PairingMethod_QrCode), + 4 => ::std::option::Option::Some(PairingMethod::PairingMethod_NFC_Unidirectional), + _ => ::std::option::Option::None + } + } + + fn from_str(str: &str) -> ::std::option::Option { + match str { + "PairingMethod_NoMethod" => ::std::option::Option::Some(PairingMethod::PairingMethod_NoMethod), + "PairingMethod_CodeEntry" => ::std::option::Option::Some(PairingMethod::PairingMethod_CodeEntry), + "PairingMethod_QrCode" => ::std::option::Option::Some(PairingMethod::PairingMethod_QrCode), + "PairingMethod_NFC_Unidirectional" => ::std::option::Option::Some(PairingMethod::PairingMethod_NFC_Unidirectional), + _ => ::std::option::Option::None + } + } + + const VALUES: &'static [PairingMethod] = &[ + PairingMethod::PairingMethod_NoMethod, + PairingMethod::PairingMethod_CodeEntry, + PairingMethod::PairingMethod_QrCode, + PairingMethod::PairingMethod_NFC_Unidirectional, + ]; +} + +impl ::protobuf::EnumFull for PairingMethod { + fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().enum_by_package_relative_name("PairingMethod").unwrap()).clone() + } + + fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { + let index = match self { + PairingMethod::PairingMethod_NoMethod => 0, + PairingMethod::PairingMethod_CodeEntry => 1, + PairingMethod::PairingMethod_QrCode => 2, + PairingMethod::PairingMethod_NFC_Unidirectional => 3, + }; + Self::enum_descriptor().value_by_index(index) + } +} + +// Note, `Default` is implemented although default value is not 0 +impl ::std::default::Default for PairingMethod { + fn default() -> Self { + PairingMethod::PairingMethod_NoMethod + } +} + +impl PairingMethod { + fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { + ::protobuf::reflect::GeneratedEnumDescriptorData::new::("PairingMethod") + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x12messages-thp.proto\x12\x16hw.trezor.messages.thp\"\x82\x02\n\x10De\ + viceProperties\x12%\n\x0einternal_model\x18\x01\x20\x01(\tR\rinternalMod\ + el\x12#\n\rmodel_variant\x18\x02\x20\x01(\rR\x0cmodelVariant\x12'\n\x0fb\ + ootloader_mode\x18\x03\x20\x01(\x08R\x0ebootloaderMode\x12)\n\x10protoco\ + l_version\x18\x04\x20\x01(\rR\x0fprotocolVersion\x12N\n\x0fpairing_metho\ + ds\x18\x05\x20\x03(\x0e2%.hw.trezor.messages.thp.PairingMethodR\x0epairi\ + ngMethods\"\xac\x01\n\"HandshakeCompletionReqNoisePayload\x126\n\x17host\ + _pairing_credential\x18\x01\x20\x01(\x0cR\x15hostPairingCredential\x12N\ + \n\x0fpairing_methods\x18\x02\x20\x03(\x0e2%.hw.trezor.messages.thp.Pair\ + ingMethodR\x0epairingMethods\"O\n\x10CreateNewSession\x12\x1e\n\npassphr\ + ase\x18\x01\x20\x01(\tR\npassphrase\x12\x1b\n\ton_device\x18\x02\x20\x01\ + (\x08R\x08onDevice\"2\n\nNewSession\x12$\n\x0enew_session_id\x18\x01\x20\ + \x01(\rR\x0cnewSessionId*\x88\x01\n\rPairingMethod\x12\x1a\n\x16PairingM\ + ethod_NoMethod\x10\x01\x12\x1b\n\x17PairingMethod_CodeEntry\x10\x02\x12\ + \x18\n\x14PairingMethod_QrCode\x10\x03\x12$\n\x20PairingMethod_NFC_Unidi\ + rectional\x10\x04B7\n#com.satoshilabs.trezor.lib.protobufB\x10TrezorMess\ + ageThp\ +"; + +/// `FileDescriptorProto` object which was a source for this generated file +fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new(); + file_descriptor_proto_lazy.get(|| { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() + }) +} + +/// `FileDescriptor` object which allows dynamic access to files +pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor { + static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new(); + static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new(); + file_descriptor.get(|| { + let generated_file_descriptor = generated_file_descriptor_lazy.get(|| { + let mut deps = ::std::vec::Vec::with_capacity(0); + let mut messages = ::std::vec::Vec::with_capacity(4); + messages.push(DeviceProperties::generated_message_descriptor_data()); + messages.push(HandshakeCompletionReqNoisePayload::generated_message_descriptor_data()); + messages.push(CreateNewSession::generated_message_descriptor_data()); + messages.push(NewSession::generated_message_descriptor_data()); + let mut enums = ::std::vec::Vec::with_capacity(1); + enums.push(PairingMethod::generated_enum_descriptor_data()); + ::protobuf::reflect::GeneratedFileDescriptor::new_generated( + file_descriptor_proto(), + deps, + messages, + enums, + ) + }); + ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor) + }) +}