Trezor Support

ethcore/src/account_provider/mod.rs

@@ -31,7 +31,8 @@ use ethstore::{
 use ethstore::dir::MemoryDirectory;
 use ethstore::ethkey::{Address, Message, Public, Secret, Random, Generator};
 use ethjson::misc::AccountMeta;
-use hardware_wallet::{Error as HardwareError, HardwareWalletManager, KeyPath};
+use hardware_wallet::{Error as HardwareError, HardwareWalletManager, KeyPath, TransactionInfo};
+use super::transaction::{Action, Transaction};
 pub use ethstore::ethkey::Signature;
 pub use ethstore::{Derivation, IndexDerivation, KeyFile};
 
@@ -288,6 +289,15 @@ impl AccountProvider {
 		Ok(accounts.into_iter().map(|a| a.address).collect())
 	}
 
+	/// Communicate with Trezor hardware wallet
+	pub fn trezor_message(&self, message_type: String, path: Option<String>, message: Option<String>) -> Result<String, SignError> {
+		match self.hardware_store.as_ref().map(|h| h.trezor_message(message_type, path, message)) {
+			None => Err(SignError::NotFound),
+			Some(Err(e)) => Err(SignError::Hardware(e)),
+			Some(Ok(s)) => Ok(s),
+		}
+	}
+
 	/// Sets addresses of accounts exposed for unknown dapps.
 	/// `None` means that all accounts will be visible.
 	/// If not `None` or empty it will also override default account.
@@ -779,8 +789,20 @@ impl AccountProvider {
 	}
 
 	/// Sign transaction with hardware wallet.
-	pub fn sign_with_hardware(&self, address: Address, transaction: &[u8]) -> Result<Signature, SignError> {
-		match self.hardware_store.as_ref().map(|s| s.sign_transaction(&address, transaction)) {
+	pub fn sign_with_hardware(&self, address: Address, transaction: &Transaction, network_id: Option<u64>, rlp_encoded_transaction: &[u8]) -> Result<Signature, SignError> {
+		let t_info = TransactionInfo {
+			nonce: transaction.nonce,
+			gas_price: transaction.gas_price,
+			gas_limit: transaction.gas,
+			to: match transaction.action {
+				Action::Create => None,
+				Action::Call(ref to) => Some(to.clone()),
+			},
+			value: transaction.value,
+			data: transaction.data.to_vec(),
+			network_id: network_id,
+		};
+		match self.hardware_store.as_ref().map(|s| s.sign_transaction(&address, &t_info, rlp_encoded_transaction)) {
 			None | Some(Err(HardwareError::KeyNotFound)) => Err(SignError::NotFound),
 			Some(Err(e)) => Err(From::from(e)),
 			Some(Ok(s)) => Ok(s),

hw/Cargo.toml

@@ -9,8 +9,12 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 log = "0.3"
 parking_lot = "0.4"
+protobuf = "1.4"
+serde = "1.0"
+serde_json = "1.0"
 hidapi = { git = "https://github.com/paritytech/hidapi-rs" }
 libusb = { git = "https://github.com/paritytech/libusb-rs" }
+trezor-sys = { git = "https://github.com/paritytech/trezor-sys" }
 ethkey = { path = "../ethkey" }
 ethcore-bigint = { path = "../util/bigint" }
 

hw/src/ledger.rs

@@ -17,19 +17,23 @@
 //! Ledger hardware wallet module. Supports Ledger Blue and Nano S.
 /// See https://github.com/LedgerHQ/blue-app-eth/blob/master/doc/ethapp.asc for protocol details.
 
+use super::{WalletInfo, KeyPath};
+
+use bigint::hash::H256;
+use ethkey::{Address, Signature};
 use hidapi;
-use std::fmt;
+use parking_lot::Mutex;
+
 use std::cmp::min;
+use std::fmt;
 use std::str::FromStr;
+use std::sync::Arc;
 use std::time::Duration;
-use super::WalletInfo;
-use ethkey::{Address, Signature};
-use bigint::hash::H256;
 
 const LEDGER_VID: u16 = 0x2c97;
 const LEDGER_PIDS: [u16; 2] = [0x0000, 0x0001]; // Nano S and Blue
-const ETH_DERIVATION_PATH_BE: [u8; 17] =  [ 4,  0x80, 0, 0, 44,  0x80, 0, 0, 60,  0x80, 0, 0, 0,  0, 0, 0, 0 ];  // 44'/60'/0'/0
-const ETC_DERIVATION_PATH_BE: [u8; 21] =  [ 5,  0x80, 0, 0, 44,  0x80, 0, 0, 60,  0x80, 0x02, 0x73, 0xd0,  0x80, 0, 0, 0,  0, 0, 0, 0 ];  // 44'/60'/160720'/0'/0
+const ETH_DERIVATION_PATH_BE: [u8; 17] = [4, 0x80, 0, 0, 44, 0x80, 0, 0, 60, 0x80, 0, 0, 0, 0, 0, 0, 0]; // 44'/60'/0'/0
+const ETC_DERIVATION_PATH_BE: [u8; 21] = [5, 0x80, 0, 0, 44, 0x80, 0, 0, 60, 0x80, 0x02, 0x73, 0xd0, 0x80, 0, 0, 0, 0, 0, 0, 0]; // 44'/60'/160720'/0'/0
 
 const APDU_TAG: u8 = 0x05;
 const APDU_CLA: u8 = 0xe0;
@@ -43,16 +47,7 @@ mod commands {
 	pub const SIGN_ETH_TRANSACTION: u8 = 0x04;
 }
 
-/// Key derivation paths used on ledger wallets.
-#[derive(Debug, Clone, Copy)]
-pub enum KeyPath {
-	/// Ethereum.
-	Ethereum,
-	/// Ethereum classic.
-	EthereumClassic,
-}
-
-/// Hardware waller error.
+/// Hardware wallet error.
 #[derive(Debug)]
 pub enum Error {
 	/// Ethereum wallet protocol error.
@@ -84,7 +79,7 @@ impl From<hidapi::HidError> for Error {
 
 /// Ledger device manager.
 pub struct Manager {
-	usb: hidapi::HidApi,
+	usb: Arc<Mutex<hidapi::HidApi>>,
 	devices: Vec<Device>,
 	key_path: KeyPath,
 }
@@ -97,19 +92,19 @@ struct Device {
 
 impl Manager {
 	/// Create a new instance.
-	pub fn new() -> Result<Manager, Error> {
-		let manager = Manager {
-			usb: hidapi::HidApi::new()?,
+	pub fn new(hidapi: Arc<Mutex<hidapi::HidApi>>) -> Manager {
+		Manager {
+			usb: hidapi,
 			devices: Vec::new(),
 			key_path: KeyPath::Ethereum,
-		};
-		Ok(manager)
+		}
 	}
 
 	/// Re-populate device list. Only those devices that have Ethereum app open will be added.
 	pub fn update_devices(&mut self) -> Result<usize, Error> {
-		self.usb.refresh_devices();
-		let devices = self.usb.devices();
+		let mut usb = self.usb.lock();
+		usb.refresh_devices();
+		let devices = usb.devices();
 		let mut new_devices = Vec::new();
 		let mut num_new_devices = 0;
 		for device in devices {
@@ -125,7 +120,7 @@ impl Manager {
 					}
 					new_devices.push(info);
 
-				},
+				}
 				Err(e) => debug!("Error reading device info: {}", e),
 			};
 		}
@@ -139,7 +134,8 @@ impl Manager {
 	}
 
 	fn read_device_info(&self, dev_info: &hidapi::HidDeviceInfo) -> Result<Device, Error> {
-		let mut handle = self.open_path(&dev_info.path)?;
+		let usb = self.usb.lock();
+		let mut handle = self.open_path(|| usb.open_path(&dev_info.path))?;
 		let address = Self::read_wallet_address(&mut handle, self.key_path)?;
 		let manufacturer = dev_info.manufacturer_string.clone().unwrap_or("Unknown".to_owned());
 		let name = dev_info.product_string.clone().unwrap_or("Unknown".to_owned());
@@ -197,10 +193,10 @@ impl Manager {
 
 	/// Sign transaction data with wallet managing `address`.
 	pub fn sign_transaction(&self, address: &Address, data: &[u8]) -> Result<Signature, Error> {
-		let device = self.devices.iter().find(|d| &d.info.address == address)
-			.ok_or(Error::KeyNotFound)?;
+		let device = self.devices.iter().find(|d| &d.info.address == address).ok_or(Error::KeyNotFound)?;
 
-		let handle = self.open_path(&device.path)?;
+		let usb = self.usb.lock();
+		let handle = self.open_path(|| usb.open_path(&device.path))?;
 
 		let eth_path = &ETH_DERIVATION_PATH_BE[..];
 		let etc_path = &ETC_DERIVATION_PATH_BE[..];
@@ -218,7 +214,7 @@ impl Manager {
 			let p1 = if data_pos == 0 { 0x00 } else { 0x80 };
 			let dest_left = MAX_CHUNK_SIZE - dest_offset;
 			let chunk_data_size = min(dest_left, data.len() - data_pos);
-			&mut chunk [dest_offset..][0..chunk_data_size].copy_from_slice(&data[data_pos..][0..chunk_data_size]);
+			&mut chunk[dest_offset..][0..chunk_data_size].copy_from_slice(&data[data_pos..][0..chunk_data_size]);
 			result = Self::send_apdu(&handle, commands::SIGN_ETH_TRANSACTION, p1, 0, &chunk[0..(dest_offset + chunk_data_size)])?;
 			dest_offset = 0;
 			data_pos += chunk_data_size;
@@ -236,11 +232,13 @@ impl Manager {
 		Ok(Signature::from_rsv(&r, &s, v))
 	}
 
-	fn open_path(&self, path: &str) -> Result<hidapi::HidDevice, Error> {
+	fn open_path<R, F>(&self, f: F) -> Result<R, Error>
+		where F: Fn() -> Result<R, &'static str>
+	{
 		let mut err = Error::KeyNotFound;
 		/// Try to open device a few times.
 		for _ in 0..10 {
-			match self.usb.open_path(&path) {
+			match f() {
 				Ok(handle) => return Ok(handle),
 				Err(e) => err = From::from(e),
 			}
@@ -253,33 +251,33 @@ impl Manager {
 		const HID_PACKET_SIZE: usize = 64 + HID_PREFIX_ZERO;
 		let mut offset = 0;
 		let mut chunk_index = 0;
-			loop {
-				let mut hid_chunk: [u8; HID_PACKET_SIZE] = [0; HID_PACKET_SIZE];
-				let mut chunk_size = if chunk_index == 0 { 12 } else { 5 };
-				let size = min(64 - chunk_size, data.len() - offset);
-				{
-					let mut chunk = &mut hid_chunk[HID_PREFIX_ZERO..];
-					&mut chunk[0..5].copy_from_slice(&[0x01, 0x01, APDU_TAG, (chunk_index >> 8) as u8, (chunk_index & 0xff) as u8 ]);
-
-					if chunk_index == 0 {
-						let data_len = data.len() + 5;
-						&mut chunk[5..12].copy_from_slice(&[ (data_len >> 8) as u8, (data_len & 0xff) as u8, APDU_CLA, command, p1, p2, data.len() as u8 ]);
-					}
-
-					&mut chunk[chunk_size..chunk_size + size].copy_from_slice(&data[offset..offset + size]);
-					offset += size;
-					chunk_size += size;
-				}
-				trace!("writing {:?}", &hid_chunk[..]);
-				let n = handle.write(&hid_chunk[..])?;
-				if n < chunk_size {
-					return Err(Error::Protocol("Write data size mismatch"));
-				}
-				if offset == data.len() {
-					break;
+		loop {
+			let mut hid_chunk: [u8; HID_PACKET_SIZE] = [0; HID_PACKET_SIZE];
+			let mut chunk_size = if chunk_index == 0 { 12 } else { 5 };
+			let size = min(64 - chunk_size, data.len() - offset);
+			{
+				let mut chunk = &mut hid_chunk[HID_PREFIX_ZERO..];
+				&mut chunk[0..5].copy_from_slice(&[0x01, 0x01, APDU_TAG, (chunk_index >> 8) as u8, (chunk_index & 0xff) as u8 ]);
+
+				if chunk_index == 0 {
+					let data_len = data.len() + 5;
+					&mut chunk[5..12].copy_from_slice(&[ (data_len >> 8) as u8, (data_len & 0xff) as u8, APDU_CLA, command, p1, p2, data.len() as u8 ]);
 				}
-				chunk_index += 1;
+
+				&mut chunk[chunk_size..chunk_size + size].copy_from_slice(&data[offset..offset + size]);
+				offset += size;
+				chunk_size += size;
+			}
+			trace!("writing {:?}", &hid_chunk[..]);
+			let n = handle.write(&hid_chunk[..])?;
+			if n < chunk_size {
+				return Err(Error::Protocol("Write data size mismatch"));
 			}
+			if offset == data.len() {
+				break;
+			}
+			chunk_index += 1;
+		}
 
 		// read response
 		chunk_index = 0;
@@ -303,20 +301,20 @@ impl Manager {
 				if chunk_size < 7 {
 					return Err(Error::Protocol("Unexpected chunk header"));
 				}
-				message_size = (chunk[5] as usize) << 8  | (chunk[6] as usize);
+				message_size = (chunk[5] as usize) << 8 | (chunk[6] as usize);
 				offset += 2;
 			}
 			message.extend_from_slice(&chunk[offset..chunk_size]);
 			message.truncate(message_size);
 			if message.len() == message_size {
 				break;
 			}
-			chunk_index +=1;
+			chunk_index += 1;
 		}
 		if message.len() < 2 {
 			return Err(Error::Protocol("No status word"));
 		}
-		let status = (message[message.len() - 2] as usize) << 8  | (message[message.len() - 1] as usize);
+		let status = (message[message.len() - 2] as usize) << 8 | (message[message.len() - 1] as usize);
 		debug!("Read status {:x}", status);
 		match status {
 			0x6700 => Err(Error::Protocol("Incorrect length")),
@@ -341,7 +339,8 @@ impl Manager {
 #[test]
 fn smoke() {
 	use rustc_hex::FromHex;
-	let mut manager = Manager::new().unwrap();
+	let hidapi = Arc::new(Mutex::new(hidapi::HidApi::new().unwrap()));
+	let mut manager = Manager::new(hidapi.clone());
 	manager.update_devices().unwrap();
 	for d in &manager.devices {
 		println!("Device: {:?}", d);