Use Password type

* Add as_str and as_bytes methods to Password
* Implement Default trait for Password

Author: kseo

codechain/account_command.rs

@@ -20,7 +20,7 @@ use std::str::FromStr;
 use rpassword;
 
 use ccore::AccountProvider;
-use ckey::{FullAddress, Private};
+use ckey::{FullAddress, Password, Private};
 use ckeystore::accounts_dir::RootDiskDirectory;
 use ckeystore::KeyStore;
 use clap::ArgMatches;
@@ -46,7 +46,7 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
     match matches.subcommand() {
         ("create", _) => {
             if let Some(password) = read_password_and_confirm() {
-                let (address, _) = ap.new_account_and_public(password.as_ref()).expect("Cannot create account");
+                let (address, _) = ap.new_account_and_public(&password).expect("Cannot create account");
                 println!(
                     "{}",
                     FullAddress::create_version0(network_id, address).expect("The network id is hardcoded to 0x11")
@@ -60,8 +60,8 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
             let json_path = matches.value_of("JSON_PATH").expect("JSON_PATH arg is required and its index is 1");
             match fs::read(json_path) {
                 Ok(json) => {
-                    let password = rpassword::prompt_password_stdout("Password: ").unwrap();
-                    match ap.import_wallet(json.as_slice(), password.as_ref()) {
+                    let password = prompt_password("Password: ");
+                    match ap.import_wallet(json.as_slice(), &password) {
                         Ok(address) => {
                             println!(
                                 "{}",
@@ -84,7 +84,7 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
             match Private::from_str(key) {
                 Ok(private) => {
                     if let Some(password) = read_password_and_confirm() {
-                        match ap.insert_account(private, password.as_ref()) {
+                        match ap.insert_account(private, &password) {
                             Ok(address) => println!(
                                 "{}",
                                 FullAddress::create_version0(network_id, address)
@@ -114,8 +114,8 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
             let key = matches.value_of("ADDRESS").expect("ADDRESS arg is required and its index is 1");
             match FullAddress::from_str(key) {
                 Ok(full_address) => {
-                    let password = rpassword::prompt_password_stdout("Password: ").unwrap();
-                    match ap.remove_account(full_address.address, password.as_ref()) {
+                    let password = prompt_password("Password: ");
+                    match ap.remove_account(full_address.address, &password) {
                         Ok(_) => println!("{} is deleted", full_address),
                         Err(e) => return Err(format!("{:?}", e)),
                     }
@@ -128,9 +128,9 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
             let key = matches.value_of("ADDRESS").expect("ADDRESS arg is required and its index is 1");
             match FullAddress::from_str(key) {
                 Ok(full_address) => {
-                    let old_password = rpassword::prompt_password_stdout("Old Password: ").unwrap();
+                    let old_password = prompt_password("Old Password: ");
                     if let Some(new_password) = read_password_and_confirm() {
-                        match ap.change_password(full_address.address, old_password.as_ref(), new_password.as_ref()) {
+                        match ap.change_password(full_address.address, &old_password, &new_password) {
                             Ok(_) => println!("Password has changed"),
                             Err(e) => return Err(format!("{:?}", e)),
                         }
@@ -146,11 +146,15 @@ pub fn run_account_command(matches: ArgMatches) -> Result<(), String> {
     }
 }
 
-fn read_password_and_confirm() -> Option<String> {
+fn prompt_password(prompt: &str) -> Password {
+    Password::from(rpassword::prompt_password_stdout(prompt).unwrap())
+}
+
+fn read_password_and_confirm() -> Option<Password> {
     let first = rpassword::prompt_password_stdout("Password: ").unwrap();
     let second = rpassword::prompt_password_stdout("Confirm Password: ").unwrap();
     if first == second {
-        Some(first)
+        Some(Password::from(first))
     } else {
         None
     }

codechain/main.rs

@@ -64,6 +64,7 @@ use ccore::{
     ShardValidatorConfig, Spec, Stratum, StratumConfig, StratumError,
 };
 use cdiscovery::{KademliaConfig, KademliaExtension, UnstructuredConfig, UnstructuredExtension};
+use ckey::Password;
 use ckeystore::accounts_dir::RootDiskDirectory;
 use ckeystore::KeyStore;
 use clap::ArgMatches;
@@ -154,7 +155,7 @@ fn new_shard_validator(config: ShardValidatorConfig, ap: Arc<AccountProvider>) -
             Some(password_path) => {
                 let content = fs::read_to_string(password_path).map_err(|e| format!("{:?}", e))?;
                 let password = content.lines().next().ok_or("Password file is empty")?;
-                Some(password.to_string())
+                Some(Password::from(password))
             }
         };
         Some((config.account, password))
@@ -230,7 +231,7 @@ fn new_miner(config: &config::Config, spec: &Spec, ap: Arc<AccountProvider>) ->
                             // Read the first line as password.
                             let password = content.lines().next().ok_or("Password file is empty")?;
                             miner
-                                .set_engine_signer(engine_signer, password.to_string())
+                                .set_engine_signer(engine_signer, Password::from(password))
                                 .map_err(|e| format!("{:?}", e))?
                         }
                         Err(_) => return Err(format!("Failed to read the password file")),

core/src/account_provider.rs

@@ -18,7 +18,8 @@ use std::fmt;
 use std::sync::Arc;
 
 use ckey::{
-    public_to_address, Address, Error as KeyError, Generator, KeyPair, Message, Private, Public, Random, Signature,
+    public_to_address, Address, Error as KeyError, Generator, KeyPair, Message, Password, Private, Public, Random,
+    Signature,
 };
 use ckeystore::accounts_dir::MemoryDirectory;
 use ckeystore::{Error as KeystoreError, KeyStore, SecretStore, SimpleSecretStore};
@@ -81,7 +82,7 @@ impl AccountProvider {
         })
     }
 
-    pub fn new_account_and_public(&self, password: &str) -> Result<(Address, Public), SignError> {
+    pub fn new_account_and_public(&self, password: &Password) -> Result<(Address, Public), SignError> {
         let acc = Random.generate().expect("secp context has generation capabilities; qed");
         let private = acc.private().clone();
         let public = acc.public().clone();
@@ -90,7 +91,7 @@ impl AccountProvider {
         Ok((address, public))
     }
 
-    pub fn insert_account(&self, private: Private, password: &str) -> Result<Address, SignError> {
+    pub fn insert_account(&self, private: Private, password: &Password) -> Result<Address, SignError> {
         let acc = KeyPair::from_private(private)?;
         let private = acc.private().clone();
         let public = acc.public().clone();
@@ -99,11 +100,11 @@ impl AccountProvider {
         Ok(address)
     }
 
-    pub fn remove_account(&self, address: Address, password: &str) -> Result<(), SignError> {
+    pub fn remove_account(&self, address: Address, password: &Password) -> Result<(), SignError> {
         Ok(self.keystore.write().remove_account(&address, password)?)
     }
 
-    pub fn sign(&self, address: Address, password: Option<String>, message: Message) -> Result<Signature, SignError> {
+    pub fn sign(&self, address: Address, password: Option<Password>, message: Message) -> Result<Signature, SignError> {
         match password {
             Some(password) => {
                 let signature = self.keystore.read().sign(&address, &password, &message)?;
@@ -123,11 +124,16 @@ impl AccountProvider {
         Ok(addresses)
     }
 
-    pub fn import_wallet(&self, json: &[u8], password: &str) -> Result<Address, SignError> {
+    pub fn import_wallet(&self, json: &[u8], password: &Password) -> Result<Address, SignError> {
         Ok(self.keystore.write().import_wallet(json, password, false)?)
     }
 
-    pub fn change_password(&self, address: Address, old_password: &str, new_password: &str) -> Result<(), SignError> {
+    pub fn change_password(
+        &self,
+        address: Address,
+        old_password: &Password,
+        new_password: &Password,
+    ) -> Result<(), SignError> {
         Ok(self.keystore.read().change_password(&address, &old_password, &new_password)?)
     }
 }

core/src/consensus/mod.rs

@@ -37,7 +37,7 @@ pub use self::validator_set::ValidatorSet;
 use std::fmt;
 use std::sync::{Arc, Weak};
 
-use ckey::{Address, Signature};
+use ckey::{Address, Password, Signature};
 use cnetwork::NetworkExtension;
 use ctypes::machine::Machine;
 use primitives::{Bytes, H256, U256};
@@ -215,7 +215,7 @@ pub trait ConsensusEngine<M: Machine>: Sync + Send {
     fn broadcast_proposal_block(&self, _block: SealedBlock) {}
 
     /// Register an account which signs consensus messages.
-    fn set_signer(&self, _ap: Arc<AccountProvider>, _address: Address, _password: String) {}
+    fn set_signer(&self, _ap: Arc<AccountProvider>, _address: Address, _password: Password) {}
 
     /// Sign using the EngineSigner, to be used for consensus parcel signing.
     fn sign(&self, _hash: H256) -> Result<Signature, Error> {

core/src/consensus/signer.rs

@@ -16,7 +16,7 @@
 
 use std::sync::Arc;
 
-use ckey::{Address, Signature};
+use ckey::{Address, Password, Signature};
 use primitives::H256;
 
 use super::super::account_provider::{AccountProvider, SignError};
@@ -25,7 +25,7 @@ use super::super::account_provider::{AccountProvider, SignError};
 pub struct EngineSigner {
     account_provider: Arc<AccountProvider>,
     address: Option<Address>,
-    password: Option<String>,
+    password: Option<Password>,
 }
 
 impl Default for EngineSigner {
@@ -40,7 +40,7 @@ impl Default for EngineSigner {
 
 impl EngineSigner {
     /// Set up the signer to sign with given address and password.
-    pub fn set(&mut self, ap: Arc<AccountProvider>, address: Address, password: String) {
+    pub fn set(&mut self, ap: Arc<AccountProvider>, address: Address, password: Password) {
         self.account_provider = ap;
         self.address = Some(address);
         self.password = Some(password);

core/src/consensus/solo_authority/mod.rs

@@ -18,7 +18,7 @@ mod params;
 
 use std::sync::{Arc, Weak};
 
-use ckey::{public_to_address, recover, Address, Signature};
+use ckey::{public_to_address, recover, Address, Password, Signature};
 use ctypes::machine::WithBalances;
 use parking_lot::RwLock;
 use primitives::{H256, U256};
@@ -186,7 +186,7 @@ impl ConsensusEngine<CodeChainMachine> for SoloAuthority {
     }
 
     /// Register an account which signs consensus messages.
-    fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: String) {
+    fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: Password) {
         self.signer.write().set(ap, address, password);
     }
 

core/src/consensus/tendermint/mod.rs

@@ -23,7 +23,7 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use std::sync::{Arc, Weak};
 
 use ccrypto::blake256;
-use ckey::{public_to_address, recover, Address, Message, Signature};
+use ckey::{public_to_address, recover, Address, Message, Password, Signature};
 use cnetwork::{Api, NetworkExtension, NodeId, TimerToken};
 use ctypes::machine::WithBalances;
 use ctypes::BlockNumber;
@@ -720,7 +720,7 @@ impl ConsensusEngine<CodeChainMachine> for Tendermint {
         header.set_score(new_score);
     }
 
-    fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: String) {
+    fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: Password) {
         {
             self.signer.write().set(ap, address, password);
         }

core/src/miner/miner.rs

@@ -18,7 +18,7 @@ use std::collections::HashSet;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
-use ckey::Address;
+use ckey::{Address, Password};
 use cstate::{StateError, TopLevelState};
 use ctypes::parcel::Error as ParcelError;
 use ctypes::BlockNumber;
@@ -543,7 +543,7 @@ impl MinerService for Miner {
         *self.extra_data.write() = extra_data;
     }
 
-    fn set_engine_signer(&self, address: Address, password: String) -> Result<(), SignError> {
+    fn set_engine_signer(&self, address: Address, password: Password) -> Result<(), SignError> {
         if self.engine.seals_internally().is_some() {
             if let Some(ref ap) = self.accounts {
                 ctrace!(MINER, "Set engine signer to {:?}", address);

core/src/miner/mod.rs

@@ -21,7 +21,7 @@ mod sealing_queue;
 mod stratum;
 mod work_notify;
 
-use ckey::Address;
+use ckey::{Address, Password};
 use cstate::TopStateInfo;
 use primitives::{Bytes, H256, U256};
 
@@ -55,7 +55,7 @@ pub trait MinerService: Send + Sync {
     fn set_extra_data(&self, extra_data: Bytes);
 
     /// Set info necessary to sign consensus messages.
-    fn set_engine_signer(&self, address: Address, password: String) -> Result<(), SignError>;
+    fn set_engine_signer(&self, address: Address, password: Password) -> Result<(), SignError>;
 
     /// Get current minimal fee for parcels accepted to queue.
     fn minimal_fee(&self) -> U256;

core/src/shard_validator/extension.rs

@@ -17,7 +17,7 @@
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
-use ckey::{Address, Signature};
+use ckey::{Address, Password, Signature};
 use cnetwork::{Api, NetworkExtension, NodeId};
 use ctypes::parcel::Action;
 use parking_lot::RwLock;
@@ -29,7 +29,7 @@ use super::client::ShardValidatorClient;
 use super::message::Message;
 
 pub struct ShardValidator {
-    account: Option<(Address, Option<String>)>,
+    account: Option<(Address, Option<Password>)>,
     account_provider: Arc<AccountProvider>,
 
     api: RwLock<Option<Arc<Api>>>,
@@ -46,7 +46,7 @@ enum RegisterActionOutcome {
 }
 
 impl ShardValidator {
-    pub fn new(account: Option<(Address, Option<String>)>, account_provider: Arc<AccountProvider>) -> Arc<Self> {
+    pub fn new(account: Option<(Address, Option<Password>)>, account_provider: Arc<AccountProvider>) -> Arc<Self> {
         Arc::new(Self {
             account,
             account_provider,
@@ -62,7 +62,7 @@ fn register_action(
     action: Action,
     actions: &mut HashMap<H256, Action>,
     account_provider: &AccountProvider,
-    account: &Option<(Address, Option<String>)>,
+    account: &Option<(Address, Option<Password>)>,
 ) -> Result<RegisterActionOutcome, AccountProviderError> {
     let action_hash = action.hash();