2017-02-20 16:13:21 +01:00
|
|
|
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
|
|
|
// This file is part of Parity.
|
|
|
|
|
|
|
|
// Parity 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 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. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2017-04-08 11:26:16 +02:00
|
|
|
use std::collections::BTreeMap;
|
2017-04-03 17:46:51 +02:00
|
|
|
use std::sync::Arc;
|
2017-02-20 16:13:21 +01:00
|
|
|
use dir::default_data_path;
|
2017-07-25 15:30:24 +02:00
|
|
|
use ethcore::account_provider::AccountProvider;
|
2017-04-03 17:46:51 +02:00
|
|
|
use ethcore::client::Client;
|
2017-04-08 11:26:16 +02:00
|
|
|
use ethkey::{Secret, Public};
|
2017-11-20 13:18:31 +01:00
|
|
|
use ethsync::SyncProvider;
|
2017-02-20 16:13:21 +01:00
|
|
|
use helpers::replace_home;
|
2017-07-25 15:30:24 +02:00
|
|
|
use util::Address;
|
2017-02-20 16:13:21 +01:00
|
|
|
|
2017-07-25 09:19:48 +02:00
|
|
|
/// This node secret key.
|
2017-11-24 10:33:33 +01:00
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
2017-07-25 09:19:48 +02:00
|
|
|
pub enum NodeSecretKey {
|
|
|
|
/// Stored as plain text in configuration file.
|
|
|
|
Plain(Secret),
|
2017-07-25 15:30:24 +02:00
|
|
|
/// Stored as account in key store.
|
|
|
|
KeyStore(Address),
|
2017-07-25 09:19:48 +02:00
|
|
|
}
|
|
|
|
|
2017-11-24 10:33:33 +01:00
|
|
|
/// Secret store service contract address.
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
|
|
pub enum ContractAddress {
|
|
|
|
/// Contract address is read from registry.
|
|
|
|
Registry,
|
|
|
|
/// Contract address is specified.
|
|
|
|
Address(Address),
|
|
|
|
}
|
|
|
|
|
2017-02-20 16:13:21 +01:00
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
|
|
/// Secret store configuration
|
|
|
|
pub struct Configuration {
|
|
|
|
/// Is secret store functionality enabled?
|
|
|
|
pub enabled: bool,
|
2017-07-27 12:29:09 +02:00
|
|
|
/// Is HTTP API enabled?
|
|
|
|
pub http_enabled: bool,
|
2017-07-27 14:48:07 +02:00
|
|
|
/// Is ACL check enabled.
|
|
|
|
pub acl_check_enabled: bool,
|
2017-11-24 10:33:33 +01:00
|
|
|
/// Service contract address.
|
|
|
|
pub service_contract_address: Option<ContractAddress>,
|
2017-04-08 11:26:16 +02:00
|
|
|
/// This node secret.
|
2017-07-25 09:19:48 +02:00
|
|
|
pub self_secret: Option<NodeSecretKey>,
|
2017-04-08 11:26:16 +02:00
|
|
|
/// Other nodes IDs + addresses.
|
|
|
|
pub nodes: BTreeMap<Public, (String, u16)>,
|
2017-02-20 16:13:21 +01:00
|
|
|
/// Interface to listen to
|
|
|
|
pub interface: String,
|
|
|
|
/// Port to listen to
|
|
|
|
pub port: u16,
|
2017-04-08 11:26:16 +02:00
|
|
|
/// Interface to listen to
|
|
|
|
pub http_interface: String,
|
|
|
|
/// Port to listen to
|
|
|
|
pub http_port: u16,
|
2017-02-20 16:13:21 +01:00
|
|
|
/// Data directory path for secret store
|
|
|
|
pub data_path: String,
|
2017-10-02 15:27:31 +02:00
|
|
|
/// Administrator public key.
|
|
|
|
pub admin_public: Option<Public>,
|
2017-02-20 16:13:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Secret store dependencies
|
2017-07-25 15:30:24 +02:00
|
|
|
pub struct Dependencies<'a> {
|
2017-04-03 17:46:51 +02:00
|
|
|
/// Blockchain client.
|
|
|
|
pub client: Arc<Client>,
|
2017-11-20 13:18:31 +01:00
|
|
|
/// Sync provider.
|
|
|
|
pub sync: Arc<SyncProvider>,
|
2017-07-25 15:30:24 +02:00
|
|
|
/// Account provider.
|
|
|
|
pub account_provider: Arc<AccountProvider>,
|
|
|
|
/// Passed accounts passwords.
|
|
|
|
pub accounts_passwords: &'a [String],
|
2017-02-20 16:13:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(feature = "secretstore"))]
|
|
|
|
mod server {
|
|
|
|
use super::{Configuration, Dependencies};
|
|
|
|
|
|
|
|
/// Noop key server implementation
|
|
|
|
pub struct KeyServer;
|
|
|
|
|
|
|
|
impl KeyServer {
|
|
|
|
/// Create new noop key server
|
|
|
|
pub fn new(_conf: Configuration, _deps: Dependencies) -> Result<Self, String> {
|
|
|
|
Ok(KeyServer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature="secretstore")]
|
|
|
|
mod server {
|
2017-07-25 08:56:23 +02:00
|
|
|
use std::sync::Arc;
|
2017-07-25 15:30:24 +02:00
|
|
|
use ethcore_secretstore;
|
2017-04-08 11:26:16 +02:00
|
|
|
use ethkey::KeyPair;
|
2017-08-09 17:17:28 +02:00
|
|
|
use ansi_term::Colour::Red;
|
2017-11-24 10:33:33 +01:00
|
|
|
use super::{Configuration, Dependencies, NodeSecretKey, ContractAddress};
|
2017-02-20 16:13:21 +01:00
|
|
|
|
|
|
|
/// Key server
|
|
|
|
pub struct KeyServer {
|
|
|
|
_key_server: Box<ethcore_secretstore::KeyServer>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl KeyServer {
|
|
|
|
/// Create new key server
|
2017-07-25 09:19:48 +02:00
|
|
|
pub fn new(mut conf: Configuration, deps: Dependencies) -> Result<Self, String> {
|
2017-08-09 17:17:28 +02:00
|
|
|
if !conf.acl_check_enabled {
|
|
|
|
warn!("Running SecretStore with disabled ACL check: {}", Red.bold().paint("everyone has access to stored keys"));
|
|
|
|
}
|
|
|
|
|
2017-07-25 15:30:24 +02:00
|
|
|
let self_secret: Arc<ethcore_secretstore::NodeKeyPair> = match conf.self_secret.take() {
|
2017-07-25 09:19:48 +02:00
|
|
|
Some(NodeSecretKey::Plain(secret)) => Arc::new(ethcore_secretstore::PlainNodeKeyPair::new(
|
|
|
|
KeyPair::from_secret(secret).map_err(|e| format!("invalid secret: {}", e))?)),
|
2017-07-25 15:30:24 +02:00
|
|
|
Some(NodeSecretKey::KeyStore(account)) => {
|
|
|
|
// Check if account exists
|
|
|
|
if !deps.account_provider.has_account(account.clone()).unwrap_or(false) {
|
|
|
|
return Err(format!("Account {} passed as secret store node key is not found", account));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if any passwords have been read from the password file(s)
|
|
|
|
if deps.accounts_passwords.is_empty() {
|
|
|
|
return Err(format!("No password found for the secret store node account {}", account));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Attempt to sign in the engine signer.
|
|
|
|
let password = deps.accounts_passwords.iter()
|
|
|
|
.find(|p| deps.account_provider.sign(account.clone(), Some((*p).clone()), Default::default()).is_ok())
|
2017-12-21 14:50:58 +01:00
|
|
|
.ok_or_else(|| format!("No valid password for the secret store node account {}", account))?;
|
2017-07-25 15:30:24 +02:00
|
|
|
Arc::new(ethcore_secretstore::KeyStoreNodeKeyPair::new(deps.account_provider, account, password.clone())
|
|
|
|
.map_err(|e| format!("{}", e))?)
|
|
|
|
},
|
2017-07-25 09:19:48 +02:00
|
|
|
None => return Err("self secret is required when using secretstore".into()),
|
|
|
|
};
|
|
|
|
|
2017-07-27 10:33:09 +02:00
|
|
|
let key_server_name = format!("{}:{}", conf.interface, conf.port);
|
|
|
|
let mut cconf = ethcore_secretstore::ServiceConfiguration {
|
2017-07-27 12:29:09 +02:00
|
|
|
listener_address: if conf.http_enabled { Some(ethcore_secretstore::NodeAddress {
|
2017-04-08 11:26:16 +02:00
|
|
|
address: conf.http_interface.clone(),
|
|
|
|
port: conf.http_port,
|
2017-07-27 12:29:09 +02:00
|
|
|
}) } else { None },
|
2017-11-24 10:33:33 +01:00
|
|
|
service_contract_address: conf.service_contract_address.map(|c| match c {
|
|
|
|
ContractAddress::Registry => ethcore_secretstore::ContractAddress::Registry,
|
|
|
|
ContractAddress::Address(address) => ethcore_secretstore::ContractAddress::Address(address),
|
|
|
|
}),
|
2017-04-03 11:13:51 +02:00
|
|
|
data_path: conf.data_path.clone(),
|
2017-07-27 14:48:07 +02:00
|
|
|
acl_check_enabled: conf.acl_check_enabled,
|
2017-04-03 11:13:51 +02:00
|
|
|
cluster_config: ethcore_secretstore::ClusterConfiguration {
|
|
|
|
threads: 4,
|
|
|
|
listener_address: ethcore_secretstore::NodeAddress {
|
|
|
|
address: conf.interface.clone(),
|
2017-04-08 11:26:16 +02:00
|
|
|
port: conf.port,
|
2017-04-03 11:13:51 +02:00
|
|
|
},
|
2017-04-08 11:26:16 +02:00
|
|
|
nodes: conf.nodes.into_iter().map(|(p, (ip, port))| (p, ethcore_secretstore::NodeAddress {
|
|
|
|
address: ip,
|
|
|
|
port: port,
|
|
|
|
})).collect(),
|
2017-04-03 11:13:51 +02:00
|
|
|
allow_connecting_to_higher_nodes: true,
|
2017-10-02 15:27:31 +02:00
|
|
|
admin_public: conf.admin_public,
|
2017-04-08 11:26:16 +02:00
|
|
|
},
|
2017-02-20 16:13:21 +01:00
|
|
|
};
|
|
|
|
|
2017-07-27 10:33:09 +02:00
|
|
|
cconf.cluster_config.nodes.insert(self_secret.public().clone(), cconf.cluster_config.listener_address.clone());
|
2017-04-08 11:26:16 +02:00
|
|
|
|
2017-11-20 13:18:31 +01:00
|
|
|
let key_server = ethcore_secretstore::start(deps.client, deps.sync, self_secret, cconf)
|
2017-07-27 10:33:09 +02:00
|
|
|
.map_err(|e| format!("Error starting KeyServer {}: {}", key_server_name, e))?;
|
2017-02-20 16:13:21 +01:00
|
|
|
|
|
|
|
Ok(KeyServer {
|
|
|
|
_key_server: key_server,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub use self::server::KeyServer;
|
|
|
|
|
|
|
|
impl Default for Configuration {
|
|
|
|
fn default() -> Self {
|
|
|
|
let data_dir = default_data_path();
|
|
|
|
Configuration {
|
|
|
|
enabled: true,
|
2017-07-27 12:29:09 +02:00
|
|
|
http_enabled: true,
|
2017-07-27 14:48:07 +02:00
|
|
|
acl_check_enabled: true,
|
2017-11-24 10:33:33 +01:00
|
|
|
service_contract_address: None,
|
2017-04-08 11:26:16 +02:00
|
|
|
self_secret: None,
|
2017-10-02 15:27:31 +02:00
|
|
|
admin_public: None,
|
2017-04-08 11:26:16 +02:00
|
|
|
nodes: BTreeMap::new(),
|
2017-02-20 16:13:21 +01:00
|
|
|
interface: "127.0.0.1".to_owned(),
|
2017-04-08 11:26:16 +02:00
|
|
|
port: 8083,
|
|
|
|
http_interface: "127.0.0.1".to_owned(),
|
|
|
|
http_port: 8082,
|
2017-02-20 16:13:21 +01:00
|
|
|
data_path: replace_home(&data_dir, "$BASE/secretstore"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Start secret store-related functionality
|
|
|
|
pub fn start(conf: Configuration, deps: Dependencies) -> Result<Option<KeyServer>, String> {
|
|
|
|
if !conf.enabled {
|
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
|
|
|
KeyServer::new(conf, deps)
|
|
|
|
.map(|s| Some(s))
|
|
|
|
}
|