openethereum/accounts/src/lib.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1015 lines
34 KiB
Rust
Raw Normal View History

// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.
// Parity Ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity Ethereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
#![warn(missing_docs)]
//! Account management.
mod account_data;
mod error;
mod stores;
#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
extern crate fake_hardware_wallet as hardware_wallet;
use self::{
account_data::{AccountData, Unlock},
stores::AddressBook,
};
use std::{
collections::HashMap,
time::{Duration, Instant},
};
use common_types::transaction::{Action, Transaction};
use ethkey::{Address, Generator, Message, Password, Public, Random, Secret};
use ethstore::{
2017-06-06 18:06:40 +02:00
accounts_dir::MemoryDirectory, random_string, EthMultiStore, EthStore, OpaqueSecret,
SecretStore, SecretVaultRef, SimpleSecretStore, StoreAccountRef,
};
use log::{debug, warn};
use parking_lot::RwLock;
pub use ethkey::Signature;
pub use ethstore::{Derivation, Error, IndexDerivation, KeyFile};
pub use hardware_wallet::{
Error as HardwareError, HardwareWalletManager, KeyPath, TransactionInfo,
};
pub use self::{account_data::AccountMeta, error::SignError};
type AccountToken = Password;
/// Account management settings.
#[derive(Debug, Default)]
pub struct AccountProviderSettings {
/// Enable hardware wallet support.
pub enable_hardware_wallets: bool,
/// Use the classic chain key on the hardware wallet.
pub hardware_wallet_classic_key: bool,
/// Store raw account secret when unlocking the account permanently.
pub unlock_keep_secret: bool,
/// Disallowed accounts.
pub blacklisted_accounts: Vec<Address>,
}
/// Account management.
/// Responsible for unlocking accounts.
pub struct AccountProvider {
2017-06-06 18:06:40 +02:00
/// For performance reasons some methods can re-use unlocked secrets.
unlocked_secrets: RwLock<HashMap<StoreAccountRef, OpaqueSecret>>,
/// Unlocked account data.
unlocked: RwLock<HashMap<StoreAccountRef, AccountData>>,
2017-06-06 18:06:40 +02:00
/// Address book.
address_book: RwLock<AddressBook>,
2016-11-30 13:47:14 +01:00
/// Accounts on disk
2020-07-29 10:36:15 +02:00
sstore: Box<dyn SecretStore>,
2016-11-30 13:47:14 +01:00
/// Accounts unlocked with rolling tokens
2016-11-30 15:08:38 +01:00
transient_sstore: EthMultiStore,
/// Accounts in hardware wallets.
hardware_store: Option<HardwareWalletManager>,
/// When unlocking account permanently we additionally keep a raw secret in memory
/// to increase the performance of transaction signing.
unlock_keep_secret: bool,
/// Disallowed accounts.
blacklisted_accounts: Vec<Address>,
}
fn transient_sstore() -> EthMultiStore {
EthMultiStore::open(Box::new(MemoryDirectory::default()))
.expect("MemoryDirectory load always succeeds; qed")
}
impl AccountProvider {
/// Creates new account provider.
2020-07-29 10:36:15 +02:00
pub fn new(sstore: Box<dyn SecretStore>, settings: AccountProviderSettings) -> Self {
let mut hardware_store = None;
2020-08-05 06:08:03 +02:00
if settings.enable_hardware_wallets {
match HardwareWalletManager::new() {
Ok(manager) => {
manager.set_key_path(if settings.hardware_wallet_classic_key {
KeyPath::EthereumClassic
} else {
KeyPath::Ethereum
});
hardware_store = Some(manager)
}
2017-03-10 10:25:40 +01:00
Err(e) => debug!("Error initializing hardware wallets: {}", e),
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
if let Ok(accounts) = sstore.accounts() {
for account in accounts
.into_iter()
.filter(|a| settings.blacklisted_accounts.contains(&a.address))
{
warn!("Local Account {} has a blacklisted (known to be weak) address and will be ignored",
account.address);
}
}
2020-08-05 06:08:03 +02:00
// Remove blacklisted accounts from address book.
let mut address_book = AddressBook::new(&sstore.local_path());
for addr in &settings.blacklisted_accounts {
address_book.remove(*addr);
}
2020-08-05 06:08:03 +02:00
AccountProvider {
2017-06-06 18:06:40 +02:00
unlocked_secrets: RwLock::new(HashMap::new()),
2016-12-09 09:31:58 +01:00
unlocked: RwLock::new(HashMap::new()),
address_book: RwLock::new(address_book),
sstore: sstore,
2016-11-30 13:47:14 +01:00
transient_sstore: transient_sstore(),
hardware_store: hardware_store,
unlock_keep_secret: settings.unlock_keep_secret,
blacklisted_accounts: settings.blacklisted_accounts,
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Creates not disk backed provider.
pub fn transient_provider() -> Self {
AccountProvider {
2017-06-06 18:06:40 +02:00
unlocked_secrets: RwLock::new(HashMap::new()),
2016-12-09 09:31:58 +01:00
unlocked: RwLock::new(HashMap::new()),
address_book: RwLock::new(AddressBook::transient()),
2016-12-09 10:45:34 +01:00
sstore: Box::new(
EthStore::open(Box::new(MemoryDirectory::default()))
.expect("MemoryDirectory load always succeeds; qed"),
2020-08-05 06:08:03 +02:00
),
2016-11-30 13:47:14 +01:00
transient_sstore: transient_sstore(),
hardware_store: None,
unlock_keep_secret: false,
blacklisted_accounts: vec![],
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Creates new random account.
pub fn new_account(&self, password: &Password) -> Result<Address, Error> {
self.new_account_and_public(password).map(|d| d.0)
}
2020-08-05 06:08:03 +02:00
/// Creates new random account and returns address and public key
pub fn new_account_and_public(&self, password: &Password) -> Result<(Address, Public), Error> {
let acc = Random
.generate()
.expect("secp context has generation capabilities; qed");
let public = acc.public().clone();
let secret = acc.secret().clone();
let account = self
.sstore
.insert_account(SecretVaultRef::Root, secret, password)?;
Ok((account.address, public))
}
2020-08-05 06:08:03 +02:00
/// Inserts new account into underlying store.
/// Does not unlock account!
pub fn insert_account(&self, secret: Secret, password: &Password) -> Result<Address, Error> {
let account = self
.sstore
.insert_account(SecretVaultRef::Root, secret, password)?;
if self.blacklisted_accounts.contains(&account.address) {
self.sstore.remove_account(&account, password)?;
return Err(Error::InvalidAccount.into());
}
Ok(account.address)
}
2020-08-05 06:08:03 +02:00
/// Generates new derived account based on the existing one
/// If password is not provided, account must be unlocked
/// New account will be created with the same password (if save: true)
pub fn derive_account(
&self,
address: &Address,
password: Option<Password>,
derivation: Derivation,
save: bool,
) -> Result<Address, SignError> {
let account = self.sstore.account_ref(&address)?;
let password = password
.map(Ok)
.unwrap_or_else(|| self.password(&account))?;
Ok(if save {
self.sstore
.insert_derived(SecretVaultRef::Root, &account, &password, derivation)?
.address
} else {
self.sstore
.generate_derived(&account, &password, derivation)?
})
}
2020-08-05 06:08:03 +02:00
/// Import a new presale wallet.
pub fn import_presale(
&self,
presale_json: &[u8],
password: &Password,
) -> Result<Address, Error> {
let account = self
.sstore
.import_presale(SecretVaultRef::Root, presale_json, password)?;
Ok(Address::from(account.address).into())
}
2020-08-05 06:08:03 +02:00
/// Import a new wallet.
pub fn import_wallet(
&self,
json: &[u8],
password: &Password,
gen_id: bool,
) -> Result<Address, Error> {
let account = self
.sstore
.import_wallet(SecretVaultRef::Root, json, password, gen_id)?;
if self.blacklisted_accounts.contains(&account.address) {
self.sstore.remove_account(&account, password)?;
return Err(Error::InvalidAccount.into());
}
Ok(Address::from(account.address).into())
}
2020-08-05 06:08:03 +02:00
2017-01-04 12:50:50 +01:00
/// Checks whether an account with a given address is present.
pub fn has_account(&self, address: Address) -> bool {
self.sstore.account_ref(&address).is_ok() && !self.blacklisted_accounts.contains(&address)
2017-01-04 12:50:50 +01:00
}
2020-08-05 06:08:03 +02:00
/// Returns addresses of all accounts.
pub fn accounts(&self) -> Result<Vec<Address>, Error> {
let accounts = self.sstore.accounts()?;
Ok(accounts
.into_iter()
.map(|a| a.address)
.filter(|address| !self.blacklisted_accounts.contains(address))
.collect())
}
2020-08-05 06:08:03 +02:00
/// Returns the address of default account.
pub fn default_account(&self) -> Result<Address, Error> {
Ok(self.accounts()?.first().cloned().unwrap_or_default())
}
2020-08-05 06:08:03 +02:00
/// Returns addresses of hardware accounts.
pub fn hardware_accounts(&self) -> Result<Vec<Address>, Error> {
if let Some(accounts) = self.hardware_store.as_ref().map(|h| h.list_wallets()) {
if !accounts.is_empty() {
return Ok(accounts.into_iter().map(|a| a.address).collect());
2020-08-05 06:08:03 +02:00
}
}
Err(Error::Custom(
"No hardware wallet accounts were found".into(),
))
}
2020-08-05 06:08:03 +02:00
Trezor Support (#6403) * Copy modal from keepkey branch and generalize The keepkey PinMatrix modal needs to be the same for Trezor, but we should probably try to keep it general since it can be used for both. * Add trezor communication code This is a result of much trial-and-error and a couple of dead-ends in how to communicate and wire everything up. Code here is still a bit WIP with lots of debug prints and stuff. The test works though, it is possible to sign a transaction. * Extend the basic lib to allow Trezor This is kind of ugly and needs some cleanup and generalization. I’ve just copy-pasted some things to bring in the trezor wallets. I’ve also had to add a lock to the USB API so that only one thing talks to the USB at once. * Add RPC plumbing needed We need to be able to get “locked” devices from the frontend to figure out if we’re going to display the PinMatrix or not. Then we need to be able to send a pin to a device. * Add logic to query backend for Trezor and display PinMatrix There’s a bug somewhere here because signing a transaction fails if you take too long to press the confirm button on the device. * Change back to paritytech branch As my fork has been merged in. * Converting spaces to tabs, as it should be * Incorporate correct handling of EIP-155 Turns out the Trezor was adjusting the v part of the signature, and we’re already doing that so it was done twice. * Some circular logic here that was incorrect BE-encoded U256 is almost the same as RLP encoded without the size-byte, except for <u8 sized values. What’s really done is BE-encoded U256 and then left-trimmed to the smallest size. Kind of obvious in hindsight. * Resolve issue where not clicking fast enough fails The device will not repeat a ButtonRequest when you read from it, so you need to have a blocking `read` for whatever amount of time that you want to give the user to click. You could also have a shorter timeout but keep retrying for some amount of time, but it would amount to the same thing. * Scan after pin entry to make accepting it faster * Remove ability to cancel pin request * Some slight cleanup * Probe for the correct HID Version to determine padding * Move the PinMatrix from Accounts to Application * Removing unused dependencies * Mistake in copying over stuff from keepkey branch * Simplify FormattedMessage * Move generated code to external crate * Remove ethcore-util dependency * Fix broken import in test This test is useless without a connected Trezor, not sure how to make it useful without one. * Merge branch 'master' into fh-4500-trezor-support # Conflicts: # rpc/src/v1/helpers/dispatch.rs * Ignore test that can't be run without trezor device * Fixing grumbles * Avoiding owning data in RPC method * Checking for overflow in v part of signature * s/network_id/chain_id * Propagating an error from the HID Api * Condensing code a little bit * Fixing UI. * Debugging trezor. * Minor styling tweak * Make message type into an actual type This makes the message type that the RPC message accepts into an actual type as opposed to just a string, based on feedback. Although I’m not 100% sure this has actually improved the situation. Overall I think the hardware wallet interface needs some refactoring love. * Split the trezor RPC endpoint It’s split into two more generic endpoints that should be suitable for any hardware wallets with the same behavior to sit behind. * Reflect RPC method split in javascript * Fix bug with pin entry * Fix deadlock for Ledger * Avoid having a USB lock in just listing locked wallets * Fix javascript issue (see #6509) * Replace Mutex with RwLock * Update Ledger test * Fix typo causing faulty signatures (sometimes) * *Actually* fix tests * Update git submodule Needed to make tests pass * Swap line orders to prevent possible deadlock * Make setPinMatrixRequest an @action
2017-09-14 19:28:43 +02:00
/// Get a list of paths to locked hardware wallets
pub fn locked_hardware_accounts(&self) -> Result<Vec<String>, SignError> {
match self
.hardware_store
.as_ref()
.map(|h| h.list_locked_wallets())
{
None => Err(SignError::NotFound),
Some(Err(e)) => Err(SignError::Hardware(e)),
Some(Ok(s)) => Ok(s),
}
}
2020-08-05 06:08:03 +02:00
Trezor Support (#6403) * Copy modal from keepkey branch and generalize The keepkey PinMatrix modal needs to be the same for Trezor, but we should probably try to keep it general since it can be used for both. * Add trezor communication code This is a result of much trial-and-error and a couple of dead-ends in how to communicate and wire everything up. Code here is still a bit WIP with lots of debug prints and stuff. The test works though, it is possible to sign a transaction. * Extend the basic lib to allow Trezor This is kind of ugly and needs some cleanup and generalization. I’ve just copy-pasted some things to bring in the trezor wallets. I’ve also had to add a lock to the USB API so that only one thing talks to the USB at once. * Add RPC plumbing needed We need to be able to get “locked” devices from the frontend to figure out if we’re going to display the PinMatrix or not. Then we need to be able to send a pin to a device. * Add logic to query backend for Trezor and display PinMatrix There’s a bug somewhere here because signing a transaction fails if you take too long to press the confirm button on the device. * Change back to paritytech branch As my fork has been merged in. * Converting spaces to tabs, as it should be * Incorporate correct handling of EIP-155 Turns out the Trezor was adjusting the v part of the signature, and we’re already doing that so it was done twice. * Some circular logic here that was incorrect BE-encoded U256 is almost the same as RLP encoded without the size-byte, except for <u8 sized values. What’s really done is BE-encoded U256 and then left-trimmed to the smallest size. Kind of obvious in hindsight. * Resolve issue where not clicking fast enough fails The device will not repeat a ButtonRequest when you read from it, so you need to have a blocking `read` for whatever amount of time that you want to give the user to click. You could also have a shorter timeout but keep retrying for some amount of time, but it would amount to the same thing. * Scan after pin entry to make accepting it faster * Remove ability to cancel pin request * Some slight cleanup * Probe for the correct HID Version to determine padding * Move the PinMatrix from Accounts to Application * Removing unused dependencies * Mistake in copying over stuff from keepkey branch * Simplify FormattedMessage * Move generated code to external crate * Remove ethcore-util dependency * Fix broken import in test This test is useless without a connected Trezor, not sure how to make it useful without one. * Merge branch 'master' into fh-4500-trezor-support # Conflicts: # rpc/src/v1/helpers/dispatch.rs * Ignore test that can't be run without trezor device * Fixing grumbles * Avoiding owning data in RPC method * Checking for overflow in v part of signature * s/network_id/chain_id * Propagating an error from the HID Api * Condensing code a little bit * Fixing UI. * Debugging trezor. * Minor styling tweak * Make message type into an actual type This makes the message type that the RPC message accepts into an actual type as opposed to just a string, based on feedback. Although I’m not 100% sure this has actually improved the situation. Overall I think the hardware wallet interface needs some refactoring love. * Split the trezor RPC endpoint It’s split into two more generic endpoints that should be suitable for any hardware wallets with the same behavior to sit behind. * Reflect RPC method split in javascript * Fix bug with pin entry * Fix deadlock for Ledger * Avoid having a USB lock in just listing locked wallets * Fix javascript issue (see #6509) * Replace Mutex with RwLock * Update Ledger test * Fix typo causing faulty signatures (sometimes) * *Actually* fix tests * Update git submodule Needed to make tests pass * Swap line orders to prevent possible deadlock * Make setPinMatrixRequest an @action
2017-09-14 19:28:43 +02:00
/// Provide a pin to a locked hardware wallet on USB path to unlock it
pub fn hardware_pin_matrix_ack(&self, path: &str, pin: &str) -> Result<bool, SignError> {
match self
.hardware_store
.as_ref()
.map(|h| h.pin_matrix_ack(path, pin))
{
None => Err(SignError::NotFound),
Some(Err(e)) => Err(SignError::Hardware(e)),
Some(Ok(s)) => Ok(s),
2020-08-05 06:08:03 +02:00
}
Trezor Support (#6403) * Copy modal from keepkey branch and generalize The keepkey PinMatrix modal needs to be the same for Trezor, but we should probably try to keep it general since it can be used for both. * Add trezor communication code This is a result of much trial-and-error and a couple of dead-ends in how to communicate and wire everything up. Code here is still a bit WIP with lots of debug prints and stuff. The test works though, it is possible to sign a transaction. * Extend the basic lib to allow Trezor This is kind of ugly and needs some cleanup and generalization. I’ve just copy-pasted some things to bring in the trezor wallets. I’ve also had to add a lock to the USB API so that only one thing talks to the USB at once. * Add RPC plumbing needed We need to be able to get “locked” devices from the frontend to figure out if we’re going to display the PinMatrix or not. Then we need to be able to send a pin to a device. * Add logic to query backend for Trezor and display PinMatrix There’s a bug somewhere here because signing a transaction fails if you take too long to press the confirm button on the device. * Change back to paritytech branch As my fork has been merged in. * Converting spaces to tabs, as it should be * Incorporate correct handling of EIP-155 Turns out the Trezor was adjusting the v part of the signature, and we’re already doing that so it was done twice. * Some circular logic here that was incorrect BE-encoded U256 is almost the same as RLP encoded without the size-byte, except for <u8 sized values. What’s really done is BE-encoded U256 and then left-trimmed to the smallest size. Kind of obvious in hindsight. * Resolve issue where not clicking fast enough fails The device will not repeat a ButtonRequest when you read from it, so you need to have a blocking `read` for whatever amount of time that you want to give the user to click. You could also have a shorter timeout but keep retrying for some amount of time, but it would amount to the same thing. * Scan after pin entry to make accepting it faster * Remove ability to cancel pin request * Some slight cleanup * Probe for the correct HID Version to determine padding * Move the PinMatrix from Accounts to Application * Removing unused dependencies * Mistake in copying over stuff from keepkey branch * Simplify FormattedMessage * Move generated code to external crate * Remove ethcore-util dependency * Fix broken import in test This test is useless without a connected Trezor, not sure how to make it useful without one. * Merge branch 'master' into fh-4500-trezor-support # Conflicts: # rpc/src/v1/helpers/dispatch.rs * Ignore test that can't be run without trezor device * Fixing grumbles * Avoiding owning data in RPC method * Checking for overflow in v part of signature * s/network_id/chain_id * Propagating an error from the HID Api * Condensing code a little bit * Fixing UI. * Debugging trezor. * Minor styling tweak * Make message type into an actual type This makes the message type that the RPC message accepts into an actual type as opposed to just a string, based on feedback. Although I’m not 100% sure this has actually improved the situation. Overall I think the hardware wallet interface needs some refactoring love. * Split the trezor RPC endpoint It’s split into two more generic endpoints that should be suitable for any hardware wallets with the same behavior to sit behind. * Reflect RPC method split in javascript * Fix bug with pin entry * Fix deadlock for Ledger * Avoid having a USB lock in just listing locked wallets * Fix javascript issue (see #6509) * Replace Mutex with RwLock * Update Ledger test * Fix typo causing faulty signatures (sometimes) * *Actually* fix tests * Update git submodule Needed to make tests pass * Swap line orders to prevent possible deadlock * Make setPinMatrixRequest an @action
2017-09-14 19:28:43 +02:00
}
2020-08-05 06:08:03 +02:00
/// Returns each address along with metadata.
pub fn addresses_info(&self) -> HashMap<Address, AccountMeta> {
self.address_book.read().get()
}
2020-08-05 06:08:03 +02:00
/// Returns each address along with metadata.
pub fn set_address_name(&self, account: Address, name: String) {
self.address_book.write().set_name(account, name)
}
2020-08-05 06:08:03 +02:00
/// Returns each address along with metadata.
pub fn set_address_meta(&self, account: Address, meta: String) {
self.address_book.write().set_meta(account, meta)
2020-08-05 06:08:03 +02:00
}
/// Removes and address from the address book
pub fn remove_address(&self, addr: Address) {
self.address_book.write().remove(addr)
2020-08-05 06:08:03 +02:00
}
/// Returns each account along with name and meta.
pub fn accounts_info(&self) -> Result<HashMap<Address, AccountMeta>, Error> {
let r = self
.sstore
.accounts()?
.into_iter()
.filter(|a| !self.blacklisted_accounts.contains(&a.address))
2020-08-05 06:08:03 +02:00
.map(|a| {
(
a.address.clone(),
self.account_meta(a.address).ok().unwrap_or_default(),
)
2020-08-05 06:08:03 +02:00
})
.collect();
Ok(r)
2016-12-07 16:53:46 +01:00
}
2020-08-05 06:08:03 +02:00
/// Returns each hardware account along with name and meta.
pub fn hardware_accounts_info(&self) -> Result<HashMap<Address, AccountMeta>, Error> {
let r = self
.hardware_accounts()?
.into_iter()
.map(|address| {
(
address.clone(),
self.account_meta(address).ok().unwrap_or_default(),
)
2020-08-05 06:08:03 +02:00
})
.collect();
Ok(r)
}
2020-08-05 06:08:03 +02:00
/// Returns each hardware account along with name and meta.
pub fn is_hardware_address(&self, address: &Address) -> bool {
self.hardware_store
.as_ref()
.and_then(|s| s.wallet_info(address))
.is_some()
}
2020-08-05 06:08:03 +02:00
/// Returns each account along with name and meta.
pub fn account_meta(&self, address: Address) -> Result<AccountMeta, Error> {
if let Some(info) = self
.hardware_store
.as_ref()
.and_then(|s| s.wallet_info(&address))
{
Ok(AccountMeta {
name: info.name,
meta: info.manufacturer,
uuid: None,
})
} else {
let account = self.sstore.account_ref(&address)?;
Ok(AccountMeta {
name: self.sstore.name(&account)?,
meta: self.sstore.meta(&account)?,
uuid: self.sstore.uuid(&account).ok().map(Into::into), // allowed to not have a Uuid
})
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
/// Returns account public key.
pub fn account_public(&self, address: Address, password: &Password) -> Result<Public, Error> {
self.sstore
.public(&self.sstore.account_ref(&address)?, password)
}
2020-08-05 06:08:03 +02:00
/// Returns each account along with name and meta.
pub fn set_account_name(&self, address: Address, name: String) -> Result<(), Error> {
self.sstore
.set_name(&self.sstore.account_ref(&address)?, name)?;
2020-08-05 06:08:03 +02:00
Ok(())
}
/// Returns each account along with name and meta.
pub fn set_account_meta(&self, address: Address, meta: String) -> Result<(), Error> {
self.sstore
.set_meta(&self.sstore.account_ref(&address)?, meta)?;
Ok(())
}
2020-08-05 06:08:03 +02:00
/// Returns `true` if the password for `account` is `password`. `false` if not.
pub fn test_password(&self, address: &Address, password: &Password) -> Result<bool, Error> {
self.sstore
.test_password(&self.sstore.account_ref(&address)?, password)
.map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Permanently removes an account.
pub fn kill_account(&self, address: &Address, password: &Password) -> Result<(), Error> {
self.sstore
.remove_account(&self.sstore.account_ref(&address)?, &password)?;
Ok(())
}
2020-08-05 06:08:03 +02:00
/// Changes the password of `account` from `password` to `new_password`. Fails if incorrect `password` given.
pub fn change_password(
&self,
address: &Address,
password: Password,
new_password: Password,
) -> Result<(), Error> {
self.sstore
.change_password(&self.sstore.account_ref(address)?, &password, &new_password)
2020-08-05 06:08:03 +02:00
}
/// Exports an account for given address.
pub fn export_account(&self, address: &Address, password: Password) -> Result<KeyFile, Error> {
self.sstore
.export_account(&self.sstore.account_ref(address)?, &password)
2020-08-05 06:08:03 +02:00
}
/// Helper method used for unlocking accounts.
fn unlock_account(
&self,
address: Address,
password: Password,
unlock: Unlock,
) -> Result<(), Error> {
let account = self.sstore.account_ref(&address)?;
2020-08-05 06:08:03 +02:00
// check if account is already unlocked permanently, if it is, do nothing
2016-12-09 09:31:58 +01:00
let mut unlocked = self.unlocked.write();
if let Some(data) = unlocked.get(&account) {
if let Unlock::Perm = data.unlock {
return Ok(());
}
}
2020-08-05 06:08:03 +02:00
if self.unlock_keep_secret && unlock == Unlock::Perm {
// verify password and get the secret
let secret = self.sstore.raw_secret(&account, &password)?;
self.unlocked_secrets
2020-08-05 06:08:03 +02:00
.write()
2017-06-06 18:06:40 +02:00
.insert(account.clone(), secret);
2020-08-05 06:08:03 +02:00
} else {
2017-06-06 18:06:40 +02:00
// verify password by signing dump message
// result may be discarded
let _ = self.sstore.sign(&account, &password, &Default::default())?;
2020-08-05 06:08:03 +02:00
}
2017-06-06 18:06:40 +02:00
let data = AccountData {
unlock: unlock,
password: password,
2020-08-05 06:08:03 +02:00
};
2017-06-06 18:06:40 +02:00
unlocked.insert(account, data);
Ok(())
}
2020-08-05 06:08:03 +02:00
2017-06-06 18:06:40 +02:00
fn password(&self, account: &StoreAccountRef) -> Result<Password, SignError> {
let mut unlocked = self.unlocked.write();
let data = unlocked.get(account).ok_or(SignError::NotUnlocked)?.clone();
2017-06-06 18:06:40 +02:00
if let Unlock::OneTime = data.unlock {
2020-08-05 06:08:03 +02:00
unlocked
.remove(account)
.expect("data exists: so key must exist: qed");
2020-08-05 06:08:03 +02:00
}
2016-12-09 09:31:58 +01:00
if let Unlock::Timed(ref end) = data.unlock {
if Instant::now() > *end {
unlocked
.remove(account)
.expect("data exists: so key must exist: qed");
return Err(SignError::NotUnlocked);
2020-08-05 06:08:03 +02:00
}
}
Ok(data.password)
2020-08-05 06:08:03 +02:00
}
/// Unlocks account permanently.
pub fn unlock_account_permanently(
2020-08-05 06:08:03 +02:00
&self,
account: Address,
password: Password,
) -> Result<(), Error> {
self.unlock_account(account, password, Unlock::Perm)
}
2020-08-05 06:08:03 +02:00
/// Unlocks account temporarily (for one signing).
pub fn unlock_account_temporarily(
&self,
account: Address,
password: Password,
) -> Result<(), Error> {
self.unlock_account(account, password, Unlock::OneTime)
}
2020-08-05 06:08:03 +02:00
/// Unlocks account temporarily with a timeout.
pub fn unlock_account_timed(
&self,
account: Address,
password: Password,
duration: Duration,
) -> Result<(), Error> {
self.unlock_account(account, password, Unlock::Timed(Instant::now() + duration))
2020-08-05 06:08:03 +02:00
}
/// Checks if given account is unlocked
pub fn is_unlocked(&self, address: &Address) -> bool {
let unlocked = self.unlocked.read();
2017-06-06 18:06:40 +02:00
let unlocked_secrets = self.unlocked_secrets.read();
self.sstore
.account_ref(address)
2017-06-06 18:06:40 +02:00
.map(|r| unlocked.get(&r).is_some() || unlocked_secrets.get(&r).is_some())
.unwrap_or(false)
}
2020-08-05 06:08:03 +02:00
2016-06-22 21:32:26 +02:00
/// Checks if given account is unlocked permanently
pub fn is_unlocked_permanently(&self, address: &Address) -> bool {
2016-12-09 09:31:58 +01:00
let unlocked = self.unlocked.read();
self.sstore
.account_ref(address)
2017-06-06 18:06:40 +02:00
.map(|r| {
unlocked
.get(&r)
.map_or(false, |account| account.unlock == Unlock::Perm)
2020-08-05 06:08:03 +02:00
})
.unwrap_or(false)
2020-08-05 06:08:03 +02:00
}
/// Signs the message. If password is not provided the account must be unlocked.
pub fn sign(
2020-08-05 06:08:03 +02:00
&self,
address: Address,
password: Option<Password>,
message: Message,
) -> Result<Signature, SignError> {
let account = self.sstore.account_ref(&address)?;
2017-06-06 18:06:40 +02:00
match self.unlocked_secrets.read().get(&account) {
Some(secret) => Ok(self.sstore.sign_with_secret(&secret, &message)?),
None => {
let password = password
2020-08-05 06:08:03 +02:00
.map(Ok)
2017-06-06 18:06:40 +02:00
.unwrap_or_else(|| self.password(&account))?;
Ok(self.sstore.sign(&account, &password, &message)?)
}
2020-08-05 06:08:03 +02:00
}
}
/// Signs message using the derived secret. If password is not provided the account must be unlocked.
pub fn sign_derived(
&self,
address: &Address,
password: Option<Password>,
derivation: Derivation,
message: Message,
) -> Result<Signature, SignError> {
let account = self.sstore.account_ref(address)?;
let password = password
.map(Ok)
.unwrap_or_else(|| self.password(&account))?;
Ok(self
.sstore
.sign_derived(&account, &password, derivation, &message)?)
}
2020-08-05 06:08:03 +02:00
2016-11-30 15:08:38 +01:00
/// Signs given message with supplied token. Returns a token to use in next signing within this session.
pub fn sign_with_token(
&self,
address: Address,
token: AccountToken,
message: Message,
) -> Result<(Signature, AccountToken), SignError> {
let account = self.sstore.account_ref(&address)?;
let is_std_password = self.sstore.test_password(&account, &token)?;
2020-08-05 06:08:03 +02:00
let new_token = Password::from(random_string(16));
2016-11-30 15:08:38 +01:00
let signature = if is_std_password {
// Insert to transient store
self.sstore.copy_account(
&self.transient_sstore,
SecretVaultRef::Root,
&account,
&token,
&new_token,
)?;
2016-11-30 15:08:38 +01:00
// sign
self.sstore.sign(&account, &token, &message)?
2016-11-30 15:08:38 +01:00
} else {
// check transient store
self.transient_sstore
.change_password(&account, &token, &new_token)?;
2016-11-30 15:08:38 +01:00
// and sign
self.transient_sstore.sign(&account, &new_token, &message)?
2016-11-30 15:08:38 +01:00
};
2020-08-05 06:08:03 +02:00
2016-11-30 15:08:38 +01:00
Ok((signature, new_token))
}
2020-08-05 06:08:03 +02:00
2016-11-30 16:11:41 +01:00
/// Decrypts a message with given token. Returns a token to use in next operation for this account.
pub fn decrypt_with_token(
&self,
address: Address,
token: AccountToken,
shared_mac: &[u8],
message: &[u8],
) -> Result<(Vec<u8>, AccountToken), SignError> {
let account = self.sstore.account_ref(&address)?;
let is_std_password = self.sstore.test_password(&account, &token)?;
2020-08-05 06:08:03 +02:00
let new_token = Password::from(random_string(16));
2016-11-30 16:11:41 +01:00
let message = if is_std_password {
// Insert to transient store
self.sstore.copy_account(
&self.transient_sstore,
SecretVaultRef::Root,
&account,
&token,
&new_token,
)?;
2016-11-30 16:11:41 +01:00
// decrypt
self.sstore.decrypt(&account, &token, shared_mac, message)?
2016-11-30 16:11:41 +01:00
} else {
// check transient store
self.transient_sstore
.change_password(&account, &token, &new_token)?;
2016-11-30 16:11:41 +01:00
// and decrypt
self.transient_sstore
.decrypt(&account, &token, shared_mac, message)?
2016-11-30 16:11:41 +01:00
};
2020-08-05 06:08:03 +02:00
2016-11-30 16:11:41 +01:00
Ok((message, new_token))
}
2020-08-05 06:08:03 +02:00
/// Decrypts a message. If password is not provided the account must be unlocked.
pub fn decrypt(
&self,
address: Address,
password: Option<Password>,
shared_mac: &[u8],
message: &[u8],
) -> Result<Vec<u8>, SignError> {
let account = self.sstore.account_ref(&address)?;
let password = password
.map(Ok)
.unwrap_or_else(|| self.password(&account))?;
Ok(self
.sstore
.decrypt(&account, &password, shared_mac, message)?)
}
2020-08-05 06:08:03 +02:00
/// Agree on shared key.
pub fn agree(
&self,
address: Address,
password: Option<Password>,
other_public: &Public,
) -> Result<Secret, SignError> {
let account = self.sstore.account_ref(&address)?;
let password = password
.map(Ok)
.unwrap_or_else(|| self.password(&account))?;
Ok(self.sstore.agree(&account, &password, other_public)?)
}
2020-08-05 06:08:03 +02:00
/// Returns the underlying `SecretStore` reference if one exists.
pub fn list_geth_accounts(&self, testnet: bool) -> Vec<Address> {
self.sstore
.list_geth_accounts(testnet)
.into_iter()
.map(|a| Address::from(a).into())
.collect()
}
2020-08-05 06:08:03 +02:00
/// Returns the underlying `SecretStore` reference if one exists.
pub fn import_geth_accounts(
&self,
desired: Vec<Address>,
testnet: bool,
) -> Result<Vec<Address>, Error> {
self.sstore
.import_geth_accounts(SecretVaultRef::Root, desired, testnet)
.map(|a| a.into_iter().map(|a| a.address).collect())
.map_err(Into::into)
2020-08-05 06:08:03 +02:00
}
/// Create new vault.
pub fn create_vault(&self, name: &str, password: &Password) -> Result<(), Error> {
self.sstore.create_vault(name, password).map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Open existing vault.
pub fn open_vault(&self, name: &str, password: &Password) -> Result<(), Error> {
self.sstore.open_vault(name, password).map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Close previously opened vault.
pub fn close_vault(&self, name: &str) -> Result<(), Error> {
self.sstore.close_vault(name).map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// List all vaults
pub fn list_vaults(&self) -> Result<Vec<String>, Error> {
self.sstore.list_vaults().map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// List all currently opened vaults
pub fn list_opened_vaults(&self) -> Result<Vec<String>, Error> {
self.sstore.list_opened_vaults().map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Change vault password.
pub fn change_vault_password(&self, name: &str, new_password: &Password) -> Result<(), Error> {
self.sstore
.change_vault_password(name, new_password)
.map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Change vault of the given address.
pub fn change_vault(&self, address: Address, new_vault: &str) -> Result<(), Error> {
let new_vault_ref = if new_vault.is_empty() {
SecretVaultRef::Root
} else {
SecretVaultRef::Vault(new_vault.to_owned())
};
let old_account_ref = self.sstore.account_ref(&address)?;
self.sstore
.change_account_vault(new_vault_ref, old_account_ref)
.map_err(Into::into)
.map(|_| ())
}
2020-08-05 06:08:03 +02:00
/// Get vault metadata string.
pub fn get_vault_meta(&self, name: &str) -> Result<String, Error> {
self.sstore.get_vault_meta(name).map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Set vault metadata string.
pub fn set_vault_meta(&self, name: &str, meta: &str) -> Result<(), Error> {
self.sstore.set_vault_meta(name, meta).map_err(Into::into)
}
2020-08-05 06:08:03 +02:00
/// Sign message with hardware wallet.
pub fn sign_message_with_hardware(
&self,
address: &Address,
message: &[u8],
) -> Result<Signature, SignError> {
match self
.hardware_store
.as_ref()
.map(|s| s.sign_message(address, message))
{
None | Some(Err(HardwareError::KeyNotFound)) => Err(SignError::NotFound),
Some(Err(e)) => Err(From::from(e)),
Some(Ok(s)) => Ok(s),
}
}
2020-08-05 06:08:03 +02:00
/// Sign transaction with hardware wallet.
pub fn sign_transaction_with_hardware(
&self,
address: &Address,
transaction: &Transaction,
chain_id: Option<u64>,
rlp_encoded_transaction: &[u8],
) -> Result<Signature, SignError> {
Trezor Support (#6403) * Copy modal from keepkey branch and generalize The keepkey PinMatrix modal needs to be the same for Trezor, but we should probably try to keep it general since it can be used for both. * Add trezor communication code This is a result of much trial-and-error and a couple of dead-ends in how to communicate and wire everything up. Code here is still a bit WIP with lots of debug prints and stuff. The test works though, it is possible to sign a transaction. * Extend the basic lib to allow Trezor This is kind of ugly and needs some cleanup and generalization. I’ve just copy-pasted some things to bring in the trezor wallets. I’ve also had to add a lock to the USB API so that only one thing talks to the USB at once. * Add RPC plumbing needed We need to be able to get “locked” devices from the frontend to figure out if we’re going to display the PinMatrix or not. Then we need to be able to send a pin to a device. * Add logic to query backend for Trezor and display PinMatrix There’s a bug somewhere here because signing a transaction fails if you take too long to press the confirm button on the device. * Change back to paritytech branch As my fork has been merged in. * Converting spaces to tabs, as it should be * Incorporate correct handling of EIP-155 Turns out the Trezor was adjusting the v part of the signature, and we’re already doing that so it was done twice. * Some circular logic here that was incorrect BE-encoded U256 is almost the same as RLP encoded without the size-byte, except for <u8 sized values. What’s really done is BE-encoded U256 and then left-trimmed to the smallest size. Kind of obvious in hindsight. * Resolve issue where not clicking fast enough fails The device will not repeat a ButtonRequest when you read from it, so you need to have a blocking `read` for whatever amount of time that you want to give the user to click. You could also have a shorter timeout but keep retrying for some amount of time, but it would amount to the same thing. * Scan after pin entry to make accepting it faster * Remove ability to cancel pin request * Some slight cleanup * Probe for the correct HID Version to determine padding * Move the PinMatrix from Accounts to Application * Removing unused dependencies * Mistake in copying over stuff from keepkey branch * Simplify FormattedMessage * Move generated code to external crate * Remove ethcore-util dependency * Fix broken import in test This test is useless without a connected Trezor, not sure how to make it useful without one. * Merge branch 'master' into fh-4500-trezor-support # Conflicts: # rpc/src/v1/helpers/dispatch.rs * Ignore test that can't be run without trezor device * Fixing grumbles * Avoiding owning data in RPC method * Checking for overflow in v part of signature * s/network_id/chain_id * Propagating an error from the HID Api * Condensing code a little bit * Fixing UI. * Debugging trezor. * Minor styling tweak * Make message type into an actual type This makes the message type that the RPC message accepts into an actual type as opposed to just a string, based on feedback. Although I’m not 100% sure this has actually improved the situation. Overall I think the hardware wallet interface needs some refactoring love. * Split the trezor RPC endpoint It’s split into two more generic endpoints that should be suitable for any hardware wallets with the same behavior to sit behind. * Reflect RPC method split in javascript * Fix bug with pin entry * Fix deadlock for Ledger * Avoid having a USB lock in just listing locked wallets * Fix javascript issue (see #6509) * Replace Mutex with RwLock * Update Ledger test * Fix typo causing faulty signatures (sometimes) * *Actually* fix tests * Update git submodule Needed to make tests pass * Swap line orders to prevent possible deadlock * Make setPinMatrixRequest an @action
2017-09-14 19:28:43 +02:00
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(),
chain_id: chain_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),
}
}
}
#[cfg(test)]
mod tests {
use super::{AccountProvider, Unlock};
use ethereum_types::H256;
use ethkey::{Address, Generator, Random};
use ethstore::{Derivation, StoreAccountRef};
use std::time::{Duration, Instant};
2020-08-05 06:08:03 +02:00
#[test]
fn unlock_account_temp() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"test".into())
.is_ok());
assert!(ap
.unlock_account_temporarily(kp.address(), "test1".into())
.is_err());
assert!(ap
.unlock_account_temporarily(kp.address(), "test".into())
.is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_err());
}
2020-08-05 06:08:03 +02:00
#[test]
fn derived_account_nosave() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"base".into())
.is_ok());
assert!(ap
.unlock_account_permanently(kp.address(), "base".into())
.is_ok());
2020-08-05 06:08:03 +02:00
let derived_addr = ap
.derive_account(
&kp.address(),
None,
Derivation::SoftHash(H256::from(999)),
false,
)
.expect("Derivation should not fail");
2020-08-05 06:08:03 +02:00
assert!(
ap.unlock_account_permanently(derived_addr, "base".into())
.is_err(),
"There should be an error because account is not supposed to be saved"
);
}
2020-08-05 06:08:03 +02:00
#[test]
fn derived_account_save() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"base".into())
.is_ok());
assert!(ap
.unlock_account_permanently(kp.address(), "base".into())
.is_ok());
2020-08-05 06:08:03 +02:00
let derived_addr = ap
.derive_account(
&kp.address(),
None,
Derivation::SoftHash(H256::from(999)),
true,
)
.expect("Derivation should not fail");
2020-08-05 06:08:03 +02:00
assert!(
ap.unlock_account_permanently(derived_addr, "base_wrong".into())
.is_err(),
"There should be an error because password is invalid"
);
2020-08-05 06:08:03 +02:00
assert!(
ap.unlock_account_permanently(derived_addr, "base".into())
.is_ok(),
"Should be ok because account is saved and password is valid"
);
}
2020-08-05 06:08:03 +02:00
#[test]
fn derived_account_sign() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"base".into())
.is_ok());
assert!(ap
.unlock_account_permanently(kp.address(), "base".into())
.is_ok());
2020-08-05 06:08:03 +02:00
let derived_addr = ap
.derive_account(
&kp.address(),
None,
Derivation::SoftHash(H256::from(1999)),
true,
)
.expect("Derivation should not fail");
ap.unlock_account_permanently(derived_addr, "base".into())
.expect("Should be ok because account is saved and password is valid");
2020-08-05 06:08:03 +02:00
let msg = Default::default();
let signed_msg1 = ap
.sign(derived_addr, None, msg)
.expect("Signing with existing unlocked account should not fail");
let signed_msg2 = ap
.sign_derived(
&kp.address(),
None,
Derivation::SoftHash(H256::from(1999)),
msg,
)
.expect("Derived signing with existing unlocked account should not fail");
2020-08-05 06:08:03 +02:00
assert_eq!(signed_msg1, signed_msg2, "Signed messages should match");
}
2020-08-05 06:08:03 +02:00
#[test]
fn unlock_account_perm() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"test".into())
.is_ok());
assert!(ap
.unlock_account_permanently(kp.address(), "test1".into())
.is_err());
assert!(ap
.unlock_account_permanently(kp.address(), "test".into())
.is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
assert!(ap
.unlock_account_temporarily(kp.address(), "test".into())
.is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
}
2020-08-05 06:08:03 +02:00
#[test]
fn unlock_account_timer() {
let kp = Random.generate().unwrap();
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"test".into())
.is_ok());
assert!(ap
.unlock_account_timed(kp.address(), "test1".into(), Duration::from_secs(60))
.is_err());
assert!(ap
.unlock_account_timed(kp.address(), "test".into(), Duration::from_secs(60))
.is_ok());
assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
ap.unlocked
.write()
.get_mut(&StoreAccountRef::root(kp.address()))
.unwrap()
.unlock = Unlock::Timed(Instant::now());
assert!(ap.sign(kp.address(), None, Default::default()).is_err());
}
2020-08-05 06:08:03 +02:00
2016-11-30 13:47:14 +01:00
#[test]
fn should_sign_and_return_token() {
// given
2016-11-30 16:11:41 +01:00
let kp = Random.generate().unwrap();
2016-11-30 13:47:14 +01:00
let ap = AccountProvider::transient_provider();
assert!(ap
.insert_account(kp.secret().clone(), &"test".into())
.is_ok());
2020-08-05 06:08:03 +02:00
2016-11-30 13:47:14 +01:00
// when
2016-11-30 15:08:38 +01:00
let (_signature, token) = ap
.sign_with_token(kp.address(), "test".into(), Default::default())
.unwrap();
2020-08-05 06:08:03 +02:00
2016-11-30 15:08:38 +01:00
// then
ap.sign_with_token(kp.address(), token.clone(), Default::default())
.expect("First usage of token should be correct.");
assert!(
ap.sign_with_token(kp.address(), token, Default::default())
.is_err(),
"Second usage of the same token should fail."
);
2016-11-30 13:47:14 +01:00
}
2020-08-05 06:08:03 +02:00
#[test]
fn should_not_return_blacklisted_account() {
// given
let mut ap = AccountProvider::transient_provider();
let acc = ap.new_account(&"test".into()).unwrap();
ap.blacklisted_accounts = vec![acc];
2020-08-05 06:08:03 +02:00
// then
assert_eq!(
ap.accounts_info()
.unwrap()
.keys()
.cloned()
.collect::<Vec<Address>>(),
vec![]
);
assert_eq!(ap.accounts().unwrap(), vec![]);
}
}