moving unlock logics to secret-store itself

Cargo.lock

@@ -81,6 +81,15 @@ name = "cfg-if"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "chrono"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "num 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)",
+ "time 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "clippy"
 version = "0.0.44"
@@ -236,6 +245,7 @@ version = "0.9.99"
 dependencies = [
  "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
  "bigint 0.1.0",
+ "chrono 0.2.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "clippy 0.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",

rpc/src/v1/impls/personal.rs

@@ -19,30 +19,27 @@ use std::sync::{Arc, Weak};
 use jsonrpc_core::*;
 use v1::traits::Personal;
 use util::keys::store::*;
-use util::{Bytes, Address};
+use util::Address;
 use std::sync::RwLock;
 
 /// Account management (personal) rpc implementation.
 pub struct PersonalClient {
-	secret_store: Weak<SecretStore>,
+	secret_store: Weak<RwLock<SecretStore>>,
-	unlocked_account: Arc<RwLock<Option<Address>>>,
-	unlocked_secret: Arc<RwLock<Option<Bytes>>>,
 }
 
 impl PersonalClient {
 	/// Creates new PersonalClient
-	pub fn new(store: &Arc<SecretStore>) -> Self {
+	pub fn new(store: &Arc<RwLock<SecretStore>>) -> Self {
 		PersonalClient {
 			secret_store: Arc::downgrade(store),
-			unlocked_account: Arc::new(RwLock::new(None)),
-			unlocked_secret: Arc::new(RwLock::new(None)),
 		}
 	}
 }
 
 impl Personal for PersonalClient {
 	fn accounts(&self, _: Params) -> Result<Value, Error> {
-		let store = take_weak!(self.secret_store);
+		let store_wk = take_weak!(self.secret_store);
+		let store = store_wk.read().unwrap();
 		match store.accounts() {
 			Ok(account_list) => {
 				Ok(Value::Array(account_list.iter()
@@ -54,27 +51,27 @@ impl Personal for PersonalClient {
 		}
 	}
 
-	fn new_account(&self, _: Params) -> Result<Value, Error> {
+	fn new_account(&self, params: Params) -> Result<Value, Error> {
-		Err(Error::internal_error())
+		from_params::<(String, )>(params).and_then(
+			|(pass, )| {
+				let store_wk = take_weak!(self.secret_store);
+				let mut store = store_wk.write().unwrap();
+				match store.new_account(&pass) {
+					Ok(address) => Ok(Value::String(format!("{:?}", address))),
+					Err(_) => Err(Error::internal_error())
+				}
+			}
+		)
 	}
 
 	fn unlock_account(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(Address, String, u64)>(params).and_then(
 			|(account, account_pass, _)|{
-				let store = take_weak!(self.secret_store);
+				let store_wk = take_weak!(self.secret_store);
-				let secret_id = match store.account(&account)  {
+				let store = store_wk.read().unwrap();
-					None => { return Ok(Value::Bool(false)); }
+				match store.unlock_account(&account, &account_pass) {
-					Some(id) => id
+					Ok(_) => Ok(Value::Bool(true)),
-				};
+					Err(_) => Ok(Value::Bool(false)),
-				match store.get(&secret_id, &account_pass) {
-					Ok(secret) => {
-						*self.unlocked_account.write().unwrap() = Some(account);
-						*self.unlocked_secret.write().unwrap() = Some(secret);
-						Ok(Value::Bool(true))
-					},
-					Err(_) => {
-						Ok(Value::Bool(false))
-					}
 				}
 			})
 	}

util/Cargo.toml

@@ -36,6 +36,7 @@ libc = "0.2.7"
 vergen = "0.1"
 target_info = "0.1"
 bigint = { path = "bigint" }
+chrono = "0.2"
 
 [features]
 default = []

util/src/keys/store.rs

@@ -22,6 +22,7 @@ use rcrypto::pbkdf2::*;
 use rcrypto::scrypt::*;
 use rcrypto::hmac::*;
 use crypto;
+use chrono::*;
 
 const KEY_LENGTH: u32 = 32;
 const KEY_ITERATIONS: u32 = 10240;
@@ -57,7 +58,13 @@ pub enum EncryptedHashMapError {
 
 /// Represent service for storing encrypted arbitrary data
 pub struct SecretStore {
-	directory: KeyDirectory
+	directory: KeyDirectory,
+	unlocks: RwLock<HashMap<Address, AccountUnlock>>
+}
+
+struct AccountUnlock {
+	secret: H256,
+	expires: DateTime<UTC>,
 }
 
 impl SecretStore {
@@ -72,7 +79,8 @@ impl SecretStore {
 	/// new instance of Secret Store in specific directory
 	pub fn new_in(path: &Path) -> SecretStore {
 		SecretStore {
-			directory: KeyDirectory::new(path)
+			directory: KeyDirectory::new(path),
+			unlocks: RwLock::new(HashMap::new())
 		}
 	}
 
@@ -120,9 +128,37 @@ impl SecretStore {
 	#[cfg(test)]
 	fn new_test(path: &::devtools::RandomTempPath) -> SecretStore {
 		SecretStore {
-			directory: KeyDirectory::new(path.as_path())
+			directory: KeyDirectory::new(path.as_path()),
+			unlocks: RwLock::new(HashMap::new())
 		}
 	}
+
+	/// Unlocks account for use
+	pub fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError> {
+		let secret_id = try!(self.account(&account).ok_or(EncryptedHashMapError::UnknownIdentifier));
+		let secret = try!(self.get(&secret_id, pass));
+		{
+			let mut write_lock = self.unlocks.write().unwrap();
+			let mut unlock = write_lock.entry(*account)
+				.or_insert_with(|| AccountUnlock { secret: secret, expires: UTC::now() });
+			unlock.secret = secret;
+			unlock.expires = UTC::now() + Duration::minutes(20);
+		}
+		Ok(())
+	}
+
+	/// Creates new account
+	pub fn new_account(&mut self, pass: &str) -> Result<Address, ::std::io::Error> {
+		let secret = H256::random();
+		let key_id = H128::random();
+		self.insert(key_id.clone(), secret, pass);
+
+		let mut key_file = self.directory.get(&key_id).expect("the key was just inserted");
+		let address = Address::random();
+		key_file.account = Some(address);
+		try!(self.directory.save(key_file));
+		Ok(address)
+	}
 }
 
 fn derive_key_iterations(password: &str, salt: &H256, c: u32) -> (Bytes, Bytes) {
@@ -369,6 +405,24 @@ mod tests {
 		assert_eq!(4, sstore.directory.list().unwrap().len())
 	}
 
+	#[test]
+	fn can_create_account() {
+		let temp = RandomTempPath::create_dir();
+		let mut sstore = SecretStore::new_test(&temp);
+		sstore.new_account("123").unwrap();
+		assert_eq!(1, sstore.accounts().unwrap().len());
+	}
+
+	#[test]
+	fn can_unlock_account() {
+		let temp = RandomTempPath::create_dir();
+		let mut sstore = SecretStore::new_test(&temp);
+		let address = sstore.new_account("123").unwrap();
+
+		let secret = sstore.unlock_account(&address, "123");
+		assert!(secret.is_ok());
+	}
+
 	#[test]
 	fn can_import_account() {
 		use keys::directory::{KeyFileContent, KeyFileCrypto};

util/src/lib.rs

@@ -111,6 +111,7 @@ extern crate rustc_version;
 extern crate target_info;
 extern crate vergen;
 extern crate bigint;
+extern crate chrono;
 
 pub mod standard;
 #[macro_use]