feat(bhwi): add Trezor sans-I/O interpreter

Author: PraneethGunas

bhwi/Cargo.toml

@@ -26,6 +26,7 @@ bitbox = [
     "dep:zeroize",
     "dep:zeroize_derive",
 ]
+trezor = ["dep:prost"]
 
 [dependencies]
 base64ct = { workspace = true, features = ["alloc"] }

bhwi/src/common.rs

@@ -1,6 +1,8 @@
 #[cfg(feature = "bitbox")]
 use crate::bitbox;
 use crate::miniscript::descriptor::{DescriptorPublicKey, WalletPolicy};
+#[cfg(feature = "trezor")]
+use crate::trezor;
 use crate::{coldcard, jade, ledger};
 use bitcoin::Network;
 use bitcoin::address::AddressType;
@@ -230,6 +232,8 @@ pub type ColdcardInterpreter<'a> =
     coldcard::ColdcardInterpreter<'a, Command, Transmit, Response, Error>;
 pub type JadeInterpreter = jade::JadeInterpreter<Command, Transmit, Response, Error>;
 pub type LedgerInterpreter = ledger::LedgerInterpreter<Command, Transmit, Response, Error>;
+#[cfg(feature = "trezor")]
+pub type TrezorInterpreter = trezor::TrezorInterpreter<Command, Transmit, Response, Error>;
 
 impl From<Vec<u8>> for Transmit {
     fn from(payload: Vec<u8>) -> Transmit {

bhwi/src/lib.rs

@@ -9,6 +9,8 @@ pub mod device;
 pub mod jade;
 pub mod ledger;
 pub mod policy;
+#[cfg(feature = "trezor")]
+pub mod trezor;
 
 pub trait Interpreter {
     type Command;

bhwi/src/trezor/api.rs

@@ -0,0 +1,108 @@
+use crate::trezor::error::TrezorError;
+use crate::trezor::proto::{bitcoin as btc, common as pb, management as mgmt};
+use prost::Message;
+
+const HEADER: [u8; 2] = *b"##";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u16)]
+pub enum MessageType {
+    Initialize = 0,
+    Success = 2,
+    Failure = 3,
+    GetPublicKey = 11,
+    PublicKey = 12,
+    Features = 17,
+    PinMatrixRequest = 18,
+    ButtonRequest = 26,
+    ButtonAck = 27,
+    GetAddress = 29,
+    Address = 30,
+    PassphraseRequest = 41,
+    PassphraseAck = 42,
+    GetFeatures = 55,
+}
+
+pub fn frame(msg_type: u16, payload: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(8 + payload.len());
+    out.extend_from_slice(&HEADER);
+    out.extend_from_slice(&msg_type.to_be_bytes());
+    out.extend_from_slice(&(payload.len() as u32).to_be_bytes());
+    out.extend_from_slice(payload);
+    out
+}
+
+pub fn parse_frame(data: &[u8]) -> Result<(u16, Vec<u8>), TrezorError> {
+    if data.len() < 8 || data[0..2] != HEADER {
+        return Err(TrezorError::MalformedFrame);
+    }
+    let msg_type = u16::from_be_bytes([data[2], data[3]]);
+    let len = u32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize;
+    let payload = data
+        .get(8..8 + len)
+        .ok_or(TrezorError::MalformedFrame)?
+        .to_vec();
+    Ok((msg_type, payload))
+}
+
+pub fn decode<M: Message + Default>(payload: &[u8]) -> Result<M, TrezorError> {
+    M::decode(payload).map_err(TrezorError::Decode)
+}
+
+fn encode<M: Message>(msg_type: MessageType, msg: &M) -> Vec<u8> {
+    frame(msg_type as u16, &msg.encode_to_vec())
+}
+
+pub fn initialize() -> Vec<u8> {
+    encode(MessageType::Initialize, &mgmt::Initialize::default())
+}
+
+pub fn get_features() -> Vec<u8> {
+    encode(MessageType::GetFeatures, &mgmt::GetFeatures::default())
+}
+
+pub fn button_ack() -> Vec<u8> {
+    encode(MessageType::ButtonAck, &pb::ButtonAck::default())
+}
+
+pub fn passphrase_ack_on_device() -> Vec<u8> {
+    let msg = pb::PassphraseAck {
+        on_device: Some(true),
+        passphrase: None,
+        ..Default::default()
+    };
+    encode(MessageType::PassphraseAck, &msg)
+}
+
+pub fn get_public_key(
+    address_n: Vec<u32>,
+    show_display: bool,
+    script_type: btc::InputScriptType,
+    coin_name: String,
+) -> Vec<u8> {
+    let msg = btc::GetPublicKey {
+        address_n,
+        show_display: Some(show_display),
+        coin_name: Some(coin_name),
+        script_type: Some(script_type as i32),
+        ignore_xpub_magic: Some(true),
+        ..Default::default()
+    };
+    encode(MessageType::GetPublicKey, &msg)
+}
+
+pub fn get_address(
+    address_n: Vec<u32>,
+    show_display: bool,
+    script_type: btc::InputScriptType,
+    coin_name: String,
+) -> Vec<u8> {
+    let msg = btc::GetAddress {
+        address_n,
+        show_display: Some(show_display),
+        coin_name: Some(coin_name),
+        script_type: Some(script_type as i32),
+        ..Default::default()
+    };
+    encode(MessageType::GetAddress, &msg)
+}

bhwi/src/trezor/error.rs

@@ -0,0 +1,50 @@
+use crate::common;
+
+#[derive(Debug, thiserror::Error)]
+pub enum TrezorError {
+    #[error("protobuf decode error: {0}")]
+    Decode(#[from] prost::DecodeError),
+    #[error("malformed trezor message frame")]
+    MalformedFrame,
+    #[error("unexpected trezor message type {0} while {1}")]
+    UnexpectedMessage(u16, &'static str),
+    #[error("device failure: {1}")]
+    Failure(i32, String),
+    #[error("device is locked: {0}")]
+    Locked(&'static str),
+    #[error("device returned a key for the wrong network")]
+    NetworkMismatch,
+    #[error("device refused the operation")]
+    ActionCancelled,
+    #[error("unsupported command: {0}")]
+    Unsupported(&'static str),
+    #[error("unsupported display address: {0}")]
+    UnsupportedDisplayAddress(&'static str),
+    #[error("invalid input: {0}")]
+    InvalidInput(String),
+}
+
+impl From<TrezorError> for common::Error {
+    fn from(e: TrezorError) -> Self {
+        match e {
+            TrezorError::Decode(err) => common::Error::Serialization(err.to_string()),
+            TrezorError::MalformedFrame => {
+                common::Error::Serialization("malformed trezor message frame".into())
+            }
+            TrezorError::UnexpectedMessage(t, ctx) => {
+                common::Error::unexpected_result(t.to_be_bytes().to_vec(), format!("trezor: {ctx}"))
+            }
+            TrezorError::Failure(_, msg) => common::Error::Device(msg),
+            TrezorError::Locked(ctx) => common::Error::Device(format!("device is locked: {ctx}")),
+            TrezorError::NetworkMismatch => {
+                common::Error::InvalidInput("device returned a key for the wrong network".into())
+            }
+            TrezorError::ActionCancelled => common::Error::AuthenticationRefused,
+            TrezorError::Unsupported(s) => common::Error::InvalidInput(s.into()),
+            TrezorError::UnsupportedDisplayAddress(s) => {
+                common::Error::UnsupportedDisplayAddress(s.into())
+            }
+            TrezorError::InvalidInput(s) => common::Error::InvalidInput(s),
+        }
+    }
+}