feat(common): Add messages for entropy check workflow.

[no changelog]

common/protob/messages-management.proto

@@ -423,6 +423,7 @@ message ResetDevice {
     optional bool skip_backup = 8;                          // postpone seed backup to BackupDevice workflow
     optional bool no_backup = 9;                            // indicate that no backup is going to be made
     optional BackupType backup_type = 10 [default=Bip39];   // type of the mnemonic backup
+    optional bool entropy_check = 11;                       // run with entropy check protocol
 }
 
 /**
@@ -444,14 +445,34 @@ message BackupDevice {
  * @next EntropyAck
  */
 message EntropyRequest {
+    optional bytes entropy_commitment = 1;  // HMAC-SHA256 of Trezor's internal entropy used in entropy check.
+    optional bytes prev_entropy = 2;        // Trezor's internal entropy from the previous round of entropy check.
 }
 
 /**
  * Request: Provide additional entropy for seed generation function
  * @next Success
+ * @next EntropyCheckReady
  */
 message EntropyAck {
-    required bytes entropy = 1;     // 256 bits (32 bytes) of random data
+    required bytes entropy = 1;     // 256 bits (32 bytes) of the host's random data
+}
+
+/**
+ * Response: Trezor is ready for the next phase of the entropy check protocol.
+ * @next EntropyCheckContinue
+ * @next GetPublicKey
+ */
+message EntropyCheckReady {
+}
+
+/**
+ * Request: Proceed with the next phase of the entropy check protocol, asking Trezor to either reveal its internal entropy or to finish and store the seed.
+ * @next Success
+ * @next EntropyRequest
+ */
+message EntropyCheckContinue {
+    optional bool finish = 1 [default=false];  // finish the entropy check protocol, store the seed
 }
 
 /**

common/protob/messages.proto

@@ -45,6 +45,8 @@ enum MessageType {
     MessageType_BackupDevice = 34 [(bitcoin_only) = true, (wire_in) = true];
     MessageType_EntropyRequest = 35 [(bitcoin_only) = true, (wire_out) = true];
     MessageType_EntropyAck = 36 [(bitcoin_only) = true, (wire_in) = true];
+    MessageType_EntropyCheckReady = 994 [(bitcoin_only) = true, (wire_out) = true];
+    MessageType_EntropyCheckContinue = 995 [(bitcoin_only) = true, (wire_in) = true];
     MessageType_PassphraseRequest = 41 [(bitcoin_only) = true, (wire_out) = true];
     MessageType_PassphraseAck = 42 [(bitcoin_only) = true, (wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
     MessageType_RecoveryDevice = 45 [(bitcoin_only) = true, (wire_in) = true];

core/src/trezor/enums/MessageType.py

@@ -29,6 +29,8 @@ Nonce = 33
 BackupDevice = 34
 EntropyRequest = 35
 EntropyAck = 36
+EntropyCheckReady = 994
+EntropyCheckContinue = 995
 PassphraseRequest = 41
 PassphraseAck = 42
 RecoveryDevice = 45

core/src/trezor/enums/__init__.py

@@ -373,6 +373,8 @@ if TYPE_CHECKING:
         BackupDevice = 34
         EntropyRequest = 35
         EntropyAck = 36
+        EntropyCheckReady = 994
+        EntropyCheckContinue = 995
         PassphraseRequest = 41
         PassphraseAck = 42
         RecoveryDevice = 45

core/src/trezor/messages.py

@@ -2535,6 +2535,7 @@ if TYPE_CHECKING:
         skip_backup: "bool | None"
         no_backup: "bool | None"
         backup_type: "BackupType"
+        entropy_check: "bool | None"
 
         def __init__(
             self,
@@ -2547,6 +2548,7 @@ if TYPE_CHECKING:
             skip_backup: "bool | None" = None,
             no_backup: "bool | None" = None,
             backup_type: "BackupType | None" = None,
+            entropy_check: "bool | None" = None,
         ) -> None:
             pass
 
@@ -2571,6 +2573,16 @@ if TYPE_CHECKING:
             return isinstance(msg, cls)
 
     class EntropyRequest(protobuf.MessageType):
+        entropy_commitment: "bytes | None"
+        prev_entropy: "bytes | None"
+
+        def __init__(
+            self,
+            *,
+            entropy_commitment: "bytes | None" = None,
+            prev_entropy: "bytes | None" = None,
+        ) -> None:
+            pass
 
         @classmethod
         def is_type_of(cls, msg: Any) -> TypeGuard["EntropyRequest"]:
@@ -2590,6 +2602,26 @@ if TYPE_CHECKING:
         def is_type_of(cls, msg: Any) -> TypeGuard["EntropyAck"]:
             return isinstance(msg, cls)
 
+    class EntropyCheckReady(protobuf.MessageType):
+
+        @classmethod
+        def is_type_of(cls, msg: Any) -> TypeGuard["EntropyCheckReady"]:
+            return isinstance(msg, cls)
+
+    class EntropyCheckContinue(protobuf.MessageType):
+        finish: "bool"
+
+        def __init__(
+            self,
+            *,
+            finish: "bool | None" = None,
+        ) -> None:
+            pass
+
+        @classmethod
+        def is_type_of(cls, msg: Any) -> TypeGuard["EntropyCheckContinue"]:
+            return isinstance(msg, cls)
+
     class RecoveryDevice(protobuf.MessageType):
         word_count: "int | None"
         passphrase_protection: "bool | None"

legacy/firmware/protob/Makefile

@@ -11,7 +11,7 @@ SKIPPED_MESSAGES := Binance Cardano DebugMonero Eos Monero Ontology Ripple SdPro
 	UnlockBootloader AuthenticateDevice AuthenticityProof \
 	Solana StellarClaimClaimableBalanceOp \
 	ChangeLanguage TranslationDataRequest TranslationDataAck \
-	SetBrightness DebugLinkOptigaSetSecMax \
+	SetBrightness DebugLinkOptigaSetSecMax EntropyCheckReady EntropyCheckContinue \
 	BenchmarkListNames BenchmarkRun BenchmarkNames BenchmarkResult
 
 ifeq ($(BITCOIN_ONLY), 1)

legacy/firmware/protob/messages-management.options

@@ -30,6 +30,9 @@ BackupDevice.groups                     type:FT_IGNORE
 
 Entropy.entropy                         max_size:1024
 
+EntropyRequest.entropy_commitment       type:FT_IGNORE
+EntropyRequest.prev_entropy             type:FT_IGNORE
+
 EntropyAck.entropy                      max_size:128
 
 RecoveryDevice.language                 max_size:17

python/src/trezorlib/messages.py

@@ -426,6 +426,8 @@ class MessageType(IntEnum):
     BackupDevice = 34
     EntropyRequest = 35
     EntropyAck = 36
+    EntropyCheckReady = 994
+    EntropyCheckContinue = 995
     PassphraseRequest = 41
     PassphraseAck = 42
     RecoveryDevice = 45
@@ -3735,6 +3737,7 @@ class ResetDevice(protobuf.MessageType):
         8: protobuf.Field("skip_backup", "bool", repeated=False, required=False, default=None),
         9: protobuf.Field("no_backup", "bool", repeated=False, required=False, default=None),
         10: protobuf.Field("backup_type", "BackupType", repeated=False, required=False, default=BackupType.Bip39),
+        11: protobuf.Field("entropy_check", "bool", repeated=False, required=False, default=None),
     }
 
     def __init__(
@@ -3749,6 +3752,7 @@ class ResetDevice(protobuf.MessageType):
         skip_backup: Optional["bool"] = None,
         no_backup: Optional["bool"] = None,
         backup_type: Optional["BackupType"] = BackupType.Bip39,
+        entropy_check: Optional["bool"] = None,
     ) -> None:
         self.strength = strength
         self.passphrase_protection = passphrase_protection
@@ -3759,6 +3763,7 @@ class ResetDevice(protobuf.MessageType):
         self.skip_backup = skip_backup
         self.no_backup = no_backup
         self.backup_type = backup_type
+        self.entropy_check = entropy_check
 
 
 class BackupDevice(protobuf.MessageType):
@@ -3780,6 +3785,19 @@ class BackupDevice(protobuf.MessageType):
 
 class EntropyRequest(protobuf.MessageType):
     MESSAGE_WIRE_TYPE = 35
+    FIELDS = {
+        1: protobuf.Field("entropy_commitment", "bytes", repeated=False, required=False, default=None),
+        2: protobuf.Field("prev_entropy", "bytes", repeated=False, required=False, default=None),
+    }
+
+    def __init__(
+        self,
+        *,
+        entropy_commitment: Optional["bytes"] = None,
+        prev_entropy: Optional["bytes"] = None,
+    ) -> None:
+        self.entropy_commitment = entropy_commitment
+        self.prev_entropy = prev_entropy
 
 
 class EntropyAck(protobuf.MessageType):
@@ -3796,6 +3814,24 @@ class EntropyAck(protobuf.MessageType):
         self.entropy = entropy
 
 
+class EntropyCheckReady(protobuf.MessageType):
+    MESSAGE_WIRE_TYPE = 994
+
+
+class EntropyCheckContinue(protobuf.MessageType):
+    MESSAGE_WIRE_TYPE = 995
+    FIELDS = {
+        1: protobuf.Field("finish", "bool", repeated=False, required=False, default=False),
+    }
+
+    def __init__(
+        self,
+        *,
+        finish: Optional["bool"] = False,
+    ) -> None:
+        self.finish = finish
+
+
 class RecoveryDevice(protobuf.MessageType):
     MESSAGE_WIRE_TYPE = 45
     FIELDS = {

rust/trezor-client/src/messages/generated.rs

@@ -24,6 +24,8 @@ trezor_message_impl! {
     BackupDevice => MessageType_BackupDevice,
     EntropyRequest => MessageType_EntropyRequest,
     EntropyAck => MessageType_EntropyAck,
+    EntropyCheckReady => MessageType_EntropyCheckReady,
+    EntropyCheckContinue => MessageType_EntropyCheckContinue,
     PassphraseRequest => MessageType_PassphraseRequest,
     PassphraseAck => MessageType_PassphraseAck,
     RecoveryDevice => MessageType_RecoveryDevice,

rust/trezor-client/src/protos/generated/messages_management.rs

@@ -6866,6 +6866,8 @@ pub struct ResetDevice {
     pub no_backup: ::std::option::Option<bool>,
     // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.backup_type)
     pub backup_type: ::std::option::Option<::protobuf::EnumOrUnknown<BackupType>>,
+    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.entropy_check)
+    pub entropy_check: ::std::option::Option<bool>,
     // special fields
     // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ResetDevice.special_fields)
     pub special_fields: ::protobuf::SpecialFields,
@@ -7090,8 +7092,27 @@ impl ResetDevice {
         self.backup_type = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
     }
 
+    // optional bool entropy_check = 11;
+
+    pub fn entropy_check(&self) -> bool {
+        self.entropy_check.unwrap_or(false)
+    }
+
+    pub fn clear_entropy_check(&mut self) {
+        self.entropy_check = ::std::option::Option::None;
+    }
+
+    pub fn has_entropy_check(&self) -> bool {
+        self.entropy_check.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_entropy_check(&mut self, v: bool) {
+        self.entropy_check = ::std::option::Option::Some(v);
+    }
+
     fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(9);
+        let mut fields = ::std::vec::Vec::with_capacity(10);
         let mut oneofs = ::std::vec::Vec::with_capacity(0);
         fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
             "strength",
@@ -7138,6 +7159,11 @@ impl ResetDevice {
             |m: &ResetDevice| { &m.backup_type },
             |m: &mut ResetDevice| { &mut m.backup_type },
         ));
+        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
+            "entropy_check",
+            |m: &ResetDevice| { &m.entropy_check },
+            |m: &mut ResetDevice| { &mut m.entropy_check },
+        ));
         ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ResetDevice>(
             "ResetDevice",
             fields,
@@ -7183,6 +7209,9 @@ impl ::protobuf::Message for ResetDevice {
                 80 => {
                     self.backup_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                 },
+                88 => {
+                    self.entropy_check = ::std::option::Option::Some(is.read_bool()?);
+                },
                 tag => {
                     ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                 },
@@ -7222,6 +7251,9 @@ impl ::protobuf::Message for ResetDevice {
         if let Some(v) = self.backup_type {
             my_size += ::protobuf::rt::int32_size(10, v.value());
         }
+        if let Some(v) = self.entropy_check {
+            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
@@ -7255,6 +7287,9 @@ impl ::protobuf::Message for ResetDevice {
         if let Some(v) = self.backup_type {
             os.write_enum(10, ::protobuf::EnumOrUnknown::value(&v))?;
         }
+        if let Some(v) = self.entropy_check {
+            os.write_bool(11, v)?;
+        }
         os.write_unknown_fields(self.special_fields.unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -7281,6 +7316,7 @@ impl ::protobuf::Message for ResetDevice {
         self.skip_backup = ::std::option::Option::None;
         self.no_backup = ::std::option::Option::None;
         self.backup_type = ::std::option::Option::None;
+        self.entropy_check = ::std::option::Option::None;
         self.special_fields.clear();
     }
 
@@ -7295,6 +7331,7 @@ impl ::protobuf::Message for ResetDevice {
             skip_backup: ::std::option::Option::None,
             no_backup: ::std::option::Option::None,
             backup_type: ::std::option::Option::None,
+            entropy_check: ::std::option::Option::None,
             special_fields: ::protobuf::SpecialFields::new(),
         };
         &instance
@@ -7673,6 +7710,11 @@ pub mod backup_device {
 // @@protoc_insertion_point(message:hw.trezor.messages.management.EntropyRequest)
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct EntropyRequest {
+    // message fields
+    // @@protoc_insertion_point(field:hw.trezor.messages.management.EntropyRequest.entropy_commitment)
+    pub entropy_commitment: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:hw.trezor.messages.management.EntropyRequest.prev_entropy)
+    pub prev_entropy: ::std::option::Option<::std::vec::Vec<u8>>,
     // special fields
     // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EntropyRequest.special_fields)
     pub special_fields: ::protobuf::SpecialFields,
@@ -7689,9 +7731,91 @@ impl EntropyRequest {
         ::std::default::Default::default()
     }
 
+    // optional bytes entropy_commitment = 1;
+
+    pub fn entropy_commitment(&self) -> &[u8] {
+        match self.entropy_commitment.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_entropy_commitment(&mut self) {
+        self.entropy_commitment = ::std::option::Option::None;
+    }
+
+    pub fn has_entropy_commitment(&self) -> bool {
+        self.entropy_commitment.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_entropy_commitment(&mut self, v: ::std::vec::Vec<u8>) {
+        self.entropy_commitment = ::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_entropy_commitment(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.entropy_commitment.is_none() {
+            self.entropy_commitment = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.entropy_commitment.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_entropy_commitment(&mut self) -> ::std::vec::Vec<u8> {
+        self.entropy_commitment.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional bytes prev_entropy = 2;
+
+    pub fn prev_entropy(&self) -> &[u8] {
+        match self.prev_entropy.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_prev_entropy(&mut self) {
+        self.prev_entropy = ::std::option::Option::None;
+    }
+
+    pub fn has_prev_entropy(&self) -> bool {
+        self.prev_entropy.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_prev_entropy(&mut self, v: ::std::vec::Vec<u8>) {
+        self.prev_entropy = ::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_prev_entropy(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.prev_entropy.is_none() {
+            self.prev_entropy = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.prev_entropy.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_prev_entropy(&mut self) -> ::std::vec::Vec<u8> {
+        self.prev_entropy.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
     fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(0);
+        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::<_, _>(
+            "entropy_commitment",
+            |m: &EntropyRequest| { &m.entropy_commitment },
+            |m: &mut EntropyRequest| { &mut m.entropy_commitment },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
+            "prev_entropy",
+            |m: &EntropyRequest| { &m.prev_entropy },
+            |m: &mut EntropyRequest| { &mut m.prev_entropy },
+        ));
         ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EntropyRequest>(
             "EntropyRequest",
             fields,
@@ -7710,6 +7834,12 @@ impl ::protobuf::Message for EntropyRequest {
     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.entropy_commitment = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                18 => {
+                    self.prev_entropy = ::std::option::Option::Some(is.read_bytes()?);
+                },
                 tag => {
                     ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                 },
@@ -7722,12 +7852,24 @@ impl ::protobuf::Message for EntropyRequest {
     #[allow(unused_variables)]
     fn compute_size(&self) -> u64 {
         let mut my_size = 0;
+        if let Some(v) = self.entropy_commitment.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.prev_entropy.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(2, &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.entropy_commitment.as_ref() {
+            os.write_bytes(1, v)?;
+        }
+        if let Some(v) = self.prev_entropy.as_ref() {
+            os.write_bytes(2, v)?;
+        }
         os.write_unknown_fields(self.special_fields.unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -7745,11 +7887,15 @@ impl ::protobuf::Message for EntropyRequest {
     }
 
     fn clear(&mut self) {
+        self.entropy_commitment = ::std::option::Option::None;
+        self.prev_entropy = ::std::option::Option::None;
         self.special_fields.clear();
     }
 
     fn default_instance() -> &'static EntropyRequest {
         static instance: EntropyRequest = EntropyRequest {
+            entropy_commitment: ::std::option::Option::None,
+            prev_entropy: ::std::option::Option::None,
             special_fields: ::protobuf::SpecialFields::new(),
         };
         &instance
@@ -7934,6 +8080,250 @@ impl ::protobuf::reflect::ProtobufValue for EntropyAck {
     type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
 }
 
+// @@protoc_insertion_point(message:hw.trezor.messages.management.EntropyCheckReady)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct EntropyCheckReady {
+    // special fields
+    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EntropyCheckReady.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a EntropyCheckReady {
+    fn default() -> &'a EntropyCheckReady {
+        <EntropyCheckReady as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl EntropyCheckReady {
+    pub fn new() -> EntropyCheckReady {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(0);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EntropyCheckReady>(
+            "EntropyCheckReady",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for EntropyCheckReady {
+    const NAME: &'static str = "EntropyCheckReady";
+
+    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 {
+                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;
+        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<()> {
+        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() -> EntropyCheckReady {
+        EntropyCheckReady::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static EntropyCheckReady {
+        static instance: EntropyCheckReady = EntropyCheckReady {
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for EntropyCheckReady {
+    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("EntropyCheckReady").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for EntropyCheckReady {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for EntropyCheckReady {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
+// @@protoc_insertion_point(message:hw.trezor.messages.management.EntropyCheckContinue)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct EntropyCheckContinue {
+    // message fields
+    // @@protoc_insertion_point(field:hw.trezor.messages.management.EntropyCheckContinue.finish)
+    pub finish: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EntropyCheckContinue.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a EntropyCheckContinue {
+    fn default() -> &'a EntropyCheckContinue {
+        <EntropyCheckContinue as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl EntropyCheckContinue {
+    pub fn new() -> EntropyCheckContinue {
+        ::std::default::Default::default()
+    }
+
+    // optional bool finish = 1;
+
+    pub fn finish(&self) -> bool {
+        self.finish.unwrap_or(false)
+    }
+
+    pub fn clear_finish(&mut self) {
+        self.finish = ::std::option::Option::None;
+    }
+
+    pub fn has_finish(&self) -> bool {
+        self.finish.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_finish(&mut self, v: bool) {
+        self.finish = ::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::<_, _>(
+            "finish",
+            |m: &EntropyCheckContinue| { &m.finish },
+            |m: &mut EntropyCheckContinue| { &mut m.finish },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EntropyCheckContinue>(
+            "EntropyCheckContinue",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for EntropyCheckContinue {
+    const NAME: &'static str = "EntropyCheckContinue";
+
+    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.finish = ::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.finish {
+            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.finish {
+            os.write_bool(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() -> EntropyCheckContinue {
+        EntropyCheckContinue::new()
+    }
+
+    fn clear(&mut self) {
+        self.finish = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static EntropyCheckContinue {
+        static instance: EntropyCheckContinue = EntropyCheckContinue {
+            finish: ::std::option::Option::None,
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for EntropyCheckContinue {
+    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("EntropyCheckContinue").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for EntropyCheckContinue {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for EntropyCheckContinue {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
 // @@protoc_insertion_point(message:hw.trezor.messages.management.RecoveryDevice)
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct RecoveryDevice {
@@ -11285,7 +11675,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     ecksum\x18\x07\x20\x01(\x08R\x0cskipChecksum\x12\x1f\n\x0bu2f_counter\
     \x18\x08\x20\x01(\rR\nu2fCounter\x12!\n\x0cneeds_backup\x18\t\x20\x01(\
     \x08R\x0bneedsBackup\x12\x1b\n\tno_backup\x18\n\x20\x01(\x08R\x08noBacku\
-    p\"\xf8\x02\n\x0bResetDevice\x12\x1f\n\x08strength\x18\x02\x20\x01(\r:\
+    p\"\x9d\x03\n\x0bResetDevice\x12\x1f\n\x08strength\x18\x02\x20\x01(\r:\
     \x03256R\x08strength\x123\n\x15passphrase_protection\x18\x03\x20\x01(\
     \x08R\x14passphraseProtection\x12%\n\x0epin_protection\x18\x04\x20\x01(\
     \x08R\rpinProtection\x12\x1e\n\x08language\x18\x05\x20\x01(\tR\x08langua\
@@ -11293,57 +11683,61 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     \n\x0bu2f_counter\x18\x07\x20\x01(\rR\nu2fCounter\x12\x1f\n\x0bskip_back\
     up\x18\x08\x20\x01(\x08R\nskipBackup\x12\x1b\n\tno_backup\x18\t\x20\x01(\
     \x08R\x08noBackup\x12Q\n\x0bbackup_type\x18\n\x20\x01(\x0e2).hw.trezor.m\
-    essages.management.BackupType:\x05Bip39R\nbackupTypeJ\x04\x08\x01\x10\
+    essages.management.BackupType:\x05Bip39R\nbackupType\x12#\n\rentropy_che\
-    \x02\"\xe5\x01\n\x0cBackupDevice\x12'\n\x0fgroup_threshold\x18\x01\x20\
+    ck\x18\x0b\x20\x01(\x08R\x0centropyCheckJ\x04\x08\x01\x10\x02\"\xe5\x01\
-    \x01(\rR\x0egroupThreshold\x12O\n\x06groups\x18\x02\x20\x03(\x0b27.hw.tr\
+    \n\x0cBackupDevice\x12'\n\x0fgroup_threshold\x18\x01\x20\x01(\rR\x0egrou\
-    ezor.messages.management.BackupDevice.Slip39GroupR\x06groups\x1a[\n\x0bS\
+    pThreshold\x12O\n\x06groups\x18\x02\x20\x03(\x0b27.hw.trezor.messages.ma\
-    lip39Group\x12)\n\x10member_threshold\x18\x01\x20\x02(\rR\x0fmemberThres\
+    nagement.BackupDevice.Slip39GroupR\x06groups\x1a[\n\x0bSlip39Group\x12)\
-    hold\x12!\n\x0cmember_count\x18\x02\x20\x02(\rR\x0bmemberCount\"\x10\n\
+    \n\x10member_threshold\x18\x01\x20\x02(\rR\x0fmemberThreshold\x12!\n\x0c\
-    \x0eEntropyRequest\"&\n\nEntropyAck\x12\x18\n\x07entropy\x18\x01\x20\x02\
+    member_count\x18\x02\x20\x02(\rR\x0bmemberCount\"b\n\x0eEntropyRequest\
-    (\x0cR\x07entropy\"\x8d\x04\n\x0eRecoveryDevice\x12\x1d\n\nword_count\
+    \x12-\n\x12entropy_commitment\x18\x01\x20\x01(\x0cR\x11entropyCommitment\
-    \x18\x01\x20\x01(\rR\twordCount\x123\n\x15passphrase_protection\x18\x02\
+    \x12!\n\x0cprev_entropy\x18\x02\x20\x01(\x0cR\x0bprevEntropy\"&\n\nEntro\
-    \x20\x01(\x08R\x14passphraseProtection\x12%\n\x0epin_protection\x18\x03\
+    pyAck\x12\x18\n\x07entropy\x18\x01\x20\x02(\x0cR\x07entropy\"\x13\n\x11E\
-    \x20\x01(\x08R\rpinProtection\x12\x1e\n\x08language\x18\x04\x20\x01(\tR\
+    ntropyCheckReady\"5\n\x14EntropyCheckContinue\x12\x1d\n\x06finish\x18\
-    \x08languageB\x02\x18\x01\x12\x14\n\x05label\x18\x05\x20\x01(\tR\x05labe\
+    \x01\x20\x01(\x08:\x05falseR\x06finish\"\x8d\x04\n\x0eRecoveryDevice\x12\
-    l\x12)\n\x10enforce_wordlist\x18\x06\x20\x01(\x08R\x0fenforceWordlist\
+    \x1d\n\nword_count\x18\x01\x20\x01(\rR\twordCount\x123\n\x15passphrase_p\
-    \x12j\n\x0cinput_method\x18\x08\x20\x01(\x0e2G.hw.trezor.messages.manage\
+    rotection\x18\x02\x20\x01(\x08R\x14passphraseProtection\x12%\n\x0epin_pr\
-    ment.RecoveryDevice.RecoveryDeviceInputMethodR\x0binputMethod\x12\x1f\n\
+    otection\x18\x03\x20\x01(\x08R\rpinProtection\x12\x1e\n\x08language\x18\
-    \x0bu2f_counter\x18\t\x20\x01(\rR\nu2fCounter\x12O\n\x04type\x18\n\x20\
+    \x04\x20\x01(\tR\x08languageB\x02\x18\x01\x12\x14\n\x05label\x18\x05\x20\
-    \x01(\x0e2+.hw.trezor.messages.management.RecoveryType:\x0eNormalRecover\
+    \x01(\tR\x05label\x12)\n\x10enforce_wordlist\x18\x06\x20\x01(\x08R\x0fen\
-    yR\x04type\";\n\x19RecoveryDeviceInputMethod\x12\x12\n\x0eScrambledWords\
+    forceWordlist\x12j\n\x0cinput_method\x18\x08\x20\x01(\x0e2G.hw.trezor.me\
-    \x10\0\x12\n\n\x06Matrix\x10\x01J\x04\x08\x07\x10\x08\"\xc5\x01\n\x0bWor\
+    ssages.management.RecoveryDevice.RecoveryDeviceInputMethodR\x0binputMeth\
-    dRequest\x12N\n\x04type\x18\x01\x20\x02(\x0e2:.hw.trezor.messages.manage\
+    od\x12\x1f\n\x0bu2f_counter\x18\t\x20\x01(\rR\nu2fCounter\x12O\n\x04type\
-    ment.WordRequest.WordRequestTypeR\x04type\"f\n\x0fWordRequestType\x12\
+    \x18\n\x20\x01(\x0e2+.hw.trezor.messages.management.RecoveryType:\x0eNor\
-    \x19\n\x15WordRequestType_Plain\x10\0\x12\x1b\n\x17WordRequestType_Matri\
+    malRecoveryR\x04type\";\n\x19RecoveryDeviceInputMethod\x12\x12\n\x0eScra\
-    x9\x10\x01\x12\x1b\n\x17WordRequestType_Matrix6\x10\x02\"\x1d\n\x07WordA\
+    mbledWords\x10\0\x12\n\n\x06Matrix\x10\x01J\x04\x08\x07\x10\x08\"\xc5\
-    ck\x12\x12\n\x04word\x18\x01\x20\x02(\tR\x04word\"0\n\rSetU2FCounter\x12\
+    \x01\n\x0bWordRequest\x12N\n\x04type\x18\x01\x20\x02(\x0e2:.hw.trezor.me\
-    \x1f\n\x0bu2f_counter\x18\x01\x20\x02(\rR\nu2fCounter\"\x13\n\x11GetNext\
+    ssages.management.WordRequest.WordRequestTypeR\x04type\"f\n\x0fWordReque\
-    U2FCounter\"1\n\x0eNextU2FCounter\x12\x1f\n\x0bu2f_counter\x18\x01\x20\
+    stType\x12\x19\n\x15WordRequestType_Plain\x10\0\x12\x1b\n\x17WordRequest\
-    \x02(\rR\nu2fCounter\"\x11\n\x0fDoPreauthorized\"\x16\n\x14Preauthorized\
+    Type_Matrix9\x10\x01\x12\x1b\n\x17WordRequestType_Matrix6\x10\x02\"\x1d\
-    Request\"\x15\n\x13CancelAuthorization\"\x9a\x02\n\x12RebootToBootloader\
+    \n\x07WordAck\x12\x12\n\x04word\x18\x01\x20\x02(\tR\x04word\"0\n\rSetU2F\
-    \x12o\n\x0cboot_command\x18\x01\x20\x01(\x0e2=.hw.trezor.messages.manage\
+    Counter\x12\x1f\n\x0bu2f_counter\x18\x01\x20\x02(\rR\nu2fCounter\"\x13\n\
-    ment.RebootToBootloader.BootCommand:\rSTOP_AND_WAITR\x0bbootCommand\x12'\
+    \x11GetNextU2FCounter\"1\n\x0eNextU2FCounter\x12\x1f\n\x0bu2f_counter\
-    \n\x0ffirmware_header\x18\x02\x20\x01(\x0cR\x0efirmwareHeader\x123\n\x14\
+    \x18\x01\x20\x02(\rR\nu2fCounter\"\x11\n\x0fDoPreauthorized\"\x16\n\x14P\
-    language_data_length\x18\x03\x20\x01(\r:\x010R\x12languageDataLength\"5\
+    reauthorizedRequest\"\x15\n\x13CancelAuthorization\"\x9a\x02\n\x12Reboot\
-    \n\x0bBootCommand\x12\x11\n\rSTOP_AND_WAIT\x10\0\x12\x13\n\x0fINSTALL_UP\
+    ToBootloader\x12o\n\x0cboot_command\x18\x01\x20\x01(\x0e2=.hw.trezor.mes\
-    GRADE\x10\x01\"\x10\n\x08GetNonce:\x04\x88\xb2\x19\x01\"#\n\x05Nonce\x12\
+    sages.management.RebootToBootloader.BootCommand:\rSTOP_AND_WAITR\x0bboot\
-    \x14\n\x05nonce\x18\x01\x20\x02(\x0cR\x05nonce:\x04\x88\xb2\x19\x01\";\n\
+    Command\x12'\n\x0ffirmware_header\x18\x02\x20\x01(\x0cR\x0efirmwareHeade\
-    \nUnlockPath\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\
+    r\x123\n\x14language_data_length\x18\x03\x20\x01(\r:\x010R\x12languageDa\
-    \x10\n\x03mac\x18\x02\x20\x01(\x0cR\x03mac\"'\n\x13UnlockedPathRequest\
+    taLength\"5\n\x0bBootCommand\x12\x11\n\rSTOP_AND_WAIT\x10\0\x12\x13\n\
-    \x12\x10\n\x03mac\x18\x01\x20\x01(\x0cR\x03mac\"\x14\n\x12ShowDeviceTuto\
+    \x0fINSTALL_UPGRADE\x10\x01\"\x10\n\x08GetNonce:\x04\x88\xb2\x19\x01\"#\
-    rial\"\x12\n\x10UnlockBootloader\"%\n\rSetBrightness\x12\x14\n\x05value\
+    \n\x05Nonce\x12\x14\n\x05nonce\x18\x01\x20\x02(\x0cR\x05nonce:\x04\x88\
-    \x18\x01\x20\x01(\rR\x05value*\x99\x01\n\nBackupType\x12\t\n\x05Bip39\
+    \xb2\x19\x01\";\n\nUnlockPath\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\
-    \x10\0\x12\x10\n\x0cSlip39_Basic\x10\x01\x12\x13\n\x0fSlip39_Advanced\
+    \x08addressN\x12\x10\n\x03mac\x18\x02\x20\x01(\x0cR\x03mac\"'\n\x13Unloc\
-    \x10\x02\x12\x1c\n\x18Slip39_Single_Extendable\x10\x03\x12\x1b\n\x17Slip\
+    kedPathRequest\x12\x10\n\x03mac\x18\x01\x20\x01(\x0cR\x03mac\"\x14\n\x12\
-    39_Basic_Extendable\x10\x04\x12\x1e\n\x1aSlip39_Advanced_Extendable\x10\
+    ShowDeviceTutorial\"\x12\n\x10UnlockBootloader\"%\n\rSetBrightness\x12\
-    \x05*G\n\x10SafetyCheckLevel\x12\n\n\x06Strict\x10\0\x12\x10\n\x0cPrompt\
+    \x14\n\x05value\x18\x01\x20\x01(\rR\x05value*\x99\x01\n\nBackupType\x12\
-    Always\x10\x01\x12\x15\n\x11PromptTemporarily\x10\x02*=\n\x0fDisplayRota\
+    \t\n\x05Bip39\x10\0\x12\x10\n\x0cSlip39_Basic\x10\x01\x12\x13\n\x0fSlip3\
-    tion\x12\t\n\x05North\x10\0\x12\x08\n\x04East\x10Z\x12\n\n\x05South\x10\
+    9_Advanced\x10\x02\x12\x1c\n\x18Slip39_Single_Extendable\x10\x03\x12\x1b\
-    \xb4\x01\x12\t\n\x04West\x10\x8e\x02*0\n\x10HomescreenFormat\x12\x08\n\
+    \n\x17Slip39_Basic_Extendable\x10\x04\x12\x1e\n\x1aSlip39_Advanced_Exten\
-    \x04Toif\x10\x01\x12\x08\n\x04Jpeg\x10\x02\x12\x08\n\x04ToiG\x10\x03*H\n\
+    dable\x10\x05*G\n\x10SafetyCheckLevel\x12\n\n\x06Strict\x10\0\x12\x10\n\
-    \x0cRecoveryType\x12\x12\n\x0eNormalRecovery\x10\0\x12\n\n\x06DryRun\x10\
+    \x0cPromptAlways\x10\x01\x12\x15\n\x11PromptTemporarily\x10\x02*=\n\x0fD\
-    \x01\x12\x18\n\x14UnlockRepeatedBackup\x10\x02BB\n#com.satoshilabs.trezo\
+    isplayRotation\x12\t\n\x05North\x10\0\x12\x08\n\x04East\x10Z\x12\n\n\x05\
-    r.lib.protobufB\x17TrezorMessageManagement\x80\xa6\x1d\x01\
+    South\x10\xb4\x01\x12\t\n\x04West\x10\x8e\x02*0\n\x10HomescreenFormat\
+    \x12\x08\n\x04Toif\x10\x01\x12\x08\n\x04Jpeg\x10\x02\x12\x08\n\x04ToiG\
+    \x10\x03*H\n\x0cRecoveryType\x12\x12\n\x0eNormalRecovery\x10\0\x12\n\n\
+    \x06DryRun\x10\x01\x12\x18\n\x14UnlockRepeatedBackup\x10\x02BB\n#com.sat\
+    oshilabs.trezor.lib.protobufB\x17TrezorMessageManagement\x80\xa6\x1d\x01\
 ";
 
 /// `FileDescriptorProto` object which was a source for this generated file
@@ -11362,7 +11756,7 @@ pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
         let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
             let mut deps = ::std::vec::Vec::with_capacity(1);
             deps.push(super::options::file_descriptor().clone());
-            let mut messages = ::std::vec::Vec::with_capacity(46);
+            let mut messages = ::std::vec::Vec::with_capacity(48);
             messages.push(Initialize::generated_message_descriptor_data());
             messages.push(GetFeatures::generated_message_descriptor_data());
             messages.push(Features::generated_message_descriptor_data());
@@ -11391,6 +11785,8 @@ pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
             messages.push(BackupDevice::generated_message_descriptor_data());
             messages.push(EntropyRequest::generated_message_descriptor_data());
             messages.push(EntropyAck::generated_message_descriptor_data());
+            messages.push(EntropyCheckReady::generated_message_descriptor_data());
+            messages.push(EntropyCheckContinue::generated_message_descriptor_data());
             messages.push(RecoveryDevice::generated_message_descriptor_data());
             messages.push(WordRequest::generated_message_descriptor_data());
             messages.push(WordAck::generated_message_descriptor_data());