810 lines
28 KiB
Rust
810 lines
28 KiB
Rust
// 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/>.
|
|
|
|
use super::{acl_storage::AclStorage, key_server_set::KeyServerSet, key_storage::KeyStorage};
|
|
use crypto::DEFAULT_MAC;
|
|
use ethkey::crypto;
|
|
use key_server_cluster::{
|
|
math, new_network_cluster, ClusterClient, ClusterConfiguration as NetClusterConfiguration,
|
|
NetConnectionsManagerConfig,
|
|
};
|
|
use parity_runtime::Executor;
|
|
use parking_lot::Mutex;
|
|
use std::{collections::BTreeSet, sync::Arc};
|
|
use traits::{
|
|
AdminSessionsServer, DocumentKeyServer, KeyServer, MessageSigner, NodeKeyPair,
|
|
ServerKeyGenerator,
|
|
};
|
|
use types::{
|
|
ClusterConfiguration, EncryptedDocumentKey, EncryptedDocumentKeyShadow,
|
|
EncryptedMessageSignature, Error, MessageHash, NodeId, Public, RequestSignature, Requester,
|
|
ServerKeyId,
|
|
};
|
|
|
|
/// Secret store key server implementation
|
|
pub struct KeyServerImpl {
|
|
data: Arc<Mutex<KeyServerCore>>,
|
|
}
|
|
|
|
/// Secret store key server data.
|
|
pub struct KeyServerCore {
|
|
cluster: Arc<dyn ClusterClient>,
|
|
}
|
|
|
|
impl KeyServerImpl {
|
|
/// Create new key server instance
|
|
pub fn new(
|
|
config: &ClusterConfiguration,
|
|
key_server_set: Arc<dyn KeyServerSet>,
|
|
self_key_pair: Arc<dyn NodeKeyPair>,
|
|
acl_storage: Arc<dyn AclStorage>,
|
|
key_storage: Arc<dyn KeyStorage>,
|
|
executor: Executor,
|
|
) -> Result<Self, Error> {
|
|
Ok(KeyServerImpl {
|
|
data: Arc::new(Mutex::new(KeyServerCore::new(
|
|
config,
|
|
key_server_set,
|
|
self_key_pair,
|
|
acl_storage,
|
|
key_storage,
|
|
executor,
|
|
)?)),
|
|
})
|
|
}
|
|
|
|
/// Get cluster client reference.
|
|
pub fn cluster(&self) -> Arc<dyn ClusterClient> {
|
|
self.data.lock().cluster.clone()
|
|
}
|
|
}
|
|
|
|
impl KeyServer for KeyServerImpl {}
|
|
|
|
impl AdminSessionsServer for KeyServerImpl {
|
|
fn change_servers_set(
|
|
&self,
|
|
old_set_signature: RequestSignature,
|
|
new_set_signature: RequestSignature,
|
|
new_servers_set: BTreeSet<NodeId>,
|
|
) -> Result<(), Error> {
|
|
let servers_set_change_session = self.data.lock().cluster.new_servers_set_change_session(
|
|
None,
|
|
None,
|
|
new_servers_set,
|
|
old_set_signature,
|
|
new_set_signature,
|
|
)?;
|
|
servers_set_change_session
|
|
.as_servers_set_change()
|
|
.expect("new_servers_set_change_session creates servers_set_change_session; qed")
|
|
.wait()
|
|
.map_err(Into::into)
|
|
}
|
|
}
|
|
|
|
impl ServerKeyGenerator for KeyServerImpl {
|
|
fn generate_key(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
author: &Requester,
|
|
threshold: usize,
|
|
) -> Result<Public, Error> {
|
|
// recover requestor' public key from signature
|
|
let address = author
|
|
.address(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// generate server key
|
|
let generation_session = self.data.lock().cluster.new_generation_session(
|
|
key_id.clone(),
|
|
None,
|
|
address,
|
|
threshold,
|
|
)?;
|
|
generation_session
|
|
.wait(None)
|
|
.expect("when wait is called without timeout it always returns Some; qed")
|
|
.map_err(Into::into)
|
|
}
|
|
|
|
fn restore_key_public(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
author: &Requester,
|
|
) -> Result<Public, Error> {
|
|
// recover requestor' public key from signature
|
|
let address = author
|
|
.address(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// negotiate key version && retrieve common key data
|
|
let negotiation_session = self
|
|
.data
|
|
.lock()
|
|
.cluster
|
|
.new_key_version_negotiation_session(*key_id)?;
|
|
negotiation_session
|
|
.wait()
|
|
.and_then(|_| negotiation_session.common_key_data())
|
|
.and_then(|key_share| {
|
|
if key_share.author == address {
|
|
Ok(key_share.public)
|
|
} else {
|
|
Err(Error::AccessDenied)
|
|
}
|
|
})
|
|
.map_err(Into::into)
|
|
}
|
|
}
|
|
|
|
impl DocumentKeyServer for KeyServerImpl {
|
|
fn store_document_key(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
author: &Requester,
|
|
common_point: Public,
|
|
encrypted_document_key: Public,
|
|
) -> Result<(), Error> {
|
|
// store encrypted key
|
|
let encryption_session = self.data.lock().cluster.new_encryption_session(
|
|
key_id.clone(),
|
|
author.clone(),
|
|
common_point,
|
|
encrypted_document_key,
|
|
)?;
|
|
encryption_session.wait(None).map_err(Into::into)
|
|
}
|
|
|
|
fn generate_document_key(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
author: &Requester,
|
|
threshold: usize,
|
|
) -> Result<EncryptedDocumentKey, Error> {
|
|
// recover requestor' public key from signature
|
|
let public = author
|
|
.public(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// generate server key
|
|
let server_key = self.generate_key(key_id, author, threshold)?;
|
|
|
|
// generate random document key
|
|
let document_key = math::generate_random_point()?;
|
|
let encrypted_document_key = math::encrypt_secret(&document_key, &server_key)?;
|
|
|
|
// store document key in the storage
|
|
self.store_document_key(
|
|
key_id,
|
|
author,
|
|
encrypted_document_key.common_point,
|
|
encrypted_document_key.encrypted_point,
|
|
)?;
|
|
|
|
// encrypt document key with requestor public key
|
|
let document_key = crypto::ecies::encrypt(&public, &DEFAULT_MAC, &document_key)
|
|
.map_err(|err| Error::Internal(format!("Error encrypting document key: {}", err)))?;
|
|
Ok(document_key)
|
|
}
|
|
|
|
fn restore_document_key(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
requester: &Requester,
|
|
) -> Result<EncryptedDocumentKey, Error> {
|
|
// recover requestor' public key from signature
|
|
let public = requester
|
|
.public(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// decrypt document key
|
|
let decryption_session = self.data.lock().cluster.new_decryption_session(
|
|
key_id.clone(),
|
|
None,
|
|
requester.clone(),
|
|
None,
|
|
false,
|
|
false,
|
|
)?;
|
|
let document_key = decryption_session
|
|
.wait(None)
|
|
.expect("when wait is called without timeout it always returns Some; qed")?
|
|
.decrypted_secret;
|
|
|
|
// encrypt document key with requestor public key
|
|
let document_key = crypto::ecies::encrypt(&public, &DEFAULT_MAC, &document_key)
|
|
.map_err(|err| Error::Internal(format!("Error encrypting document key: {}", err)))?;
|
|
Ok(document_key)
|
|
}
|
|
|
|
fn restore_document_key_shadow(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
requester: &Requester,
|
|
) -> Result<EncryptedDocumentKeyShadow, Error> {
|
|
let decryption_session = self.data.lock().cluster.new_decryption_session(
|
|
key_id.clone(),
|
|
None,
|
|
requester.clone(),
|
|
None,
|
|
true,
|
|
false,
|
|
)?;
|
|
decryption_session
|
|
.wait(None)
|
|
.expect("when wait is called without timeout it always returns Some; qed")
|
|
.map_err(Into::into)
|
|
}
|
|
}
|
|
|
|
impl MessageSigner for KeyServerImpl {
|
|
fn sign_message_schnorr(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
requester: &Requester,
|
|
message: MessageHash,
|
|
) -> Result<EncryptedMessageSignature, Error> {
|
|
// recover requestor' public key from signature
|
|
let public = requester
|
|
.public(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// sign message
|
|
let signing_session = self.data.lock().cluster.new_schnorr_signing_session(
|
|
key_id.clone(),
|
|
requester.clone().into(),
|
|
None,
|
|
message,
|
|
)?;
|
|
let message_signature = signing_session.wait()?;
|
|
|
|
// compose two message signature components into single one
|
|
let mut combined_signature = [0; 64];
|
|
combined_signature[..32].clone_from_slice(&**message_signature.0);
|
|
combined_signature[32..].clone_from_slice(&**message_signature.1);
|
|
|
|
// encrypt combined signature with requestor public key
|
|
let message_signature = crypto::ecies::encrypt(&public, &DEFAULT_MAC, &combined_signature)
|
|
.map_err(|err| {
|
|
Error::Internal(format!("Error encrypting message signature: {}", err))
|
|
})?;
|
|
Ok(message_signature)
|
|
}
|
|
|
|
fn sign_message_ecdsa(
|
|
&self,
|
|
key_id: &ServerKeyId,
|
|
requester: &Requester,
|
|
message: MessageHash,
|
|
) -> Result<EncryptedMessageSignature, Error> {
|
|
// recover requestor' public key from signature
|
|
let public = requester
|
|
.public(key_id)
|
|
.map_err(Error::InsufficientRequesterData)?;
|
|
|
|
// sign message
|
|
let signing_session = self.data.lock().cluster.new_ecdsa_signing_session(
|
|
key_id.clone(),
|
|
requester.clone().into(),
|
|
None,
|
|
message,
|
|
)?;
|
|
let message_signature = signing_session.wait()?;
|
|
|
|
// encrypt combined signature with requestor public key
|
|
let message_signature = crypto::ecies::encrypt(&public, &DEFAULT_MAC, &*message_signature)
|
|
.map_err(|err| {
|
|
Error::Internal(format!("Error encrypting message signature: {}", err))
|
|
})?;
|
|
Ok(message_signature)
|
|
}
|
|
}
|
|
|
|
impl KeyServerCore {
|
|
pub fn new(
|
|
config: &ClusterConfiguration,
|
|
key_server_set: Arc<dyn KeyServerSet>,
|
|
self_key_pair: Arc<dyn NodeKeyPair>,
|
|
acl_storage: Arc<dyn AclStorage>,
|
|
key_storage: Arc<dyn KeyStorage>,
|
|
executor: Executor,
|
|
) -> Result<Self, Error> {
|
|
let cconfig = NetClusterConfiguration {
|
|
self_key_pair: self_key_pair.clone(),
|
|
key_server_set: key_server_set,
|
|
acl_storage: acl_storage,
|
|
key_storage: key_storage,
|
|
admin_public: config.admin_public,
|
|
preserve_sessions: false,
|
|
};
|
|
let net_config = NetConnectionsManagerConfig {
|
|
listen_address: (
|
|
config.listener_address.address.clone(),
|
|
config.listener_address.port,
|
|
),
|
|
allow_connecting_to_higher_nodes: config.allow_connecting_to_higher_nodes,
|
|
auto_migrate_enabled: config.auto_migrate_enabled,
|
|
};
|
|
|
|
let core = new_network_cluster(executor, cconfig, net_config)?;
|
|
let cluster = core.client();
|
|
core.run()?;
|
|
|
|
Ok(KeyServerCore { cluster })
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub mod tests {
|
|
use super::KeyServerImpl;
|
|
use acl_storage::DummyAclStorage;
|
|
use crypto::DEFAULT_MAC;
|
|
use ethereum_types::{H256, H520};
|
|
use ethkey::{self, crypto, verify_public, Generator, Random, Secret};
|
|
use key_server_cluster::math;
|
|
use key_server_set::tests::MapKeyServerSet;
|
|
use key_storage::{tests::DummyKeyStorage, KeyStorage};
|
|
use node_key_pair::PlainNodeKeyPair;
|
|
use parity_runtime::Runtime;
|
|
use std::{
|
|
collections::{BTreeMap, BTreeSet},
|
|
net::SocketAddr,
|
|
sync::Arc,
|
|
time,
|
|
};
|
|
use traits::{
|
|
AdminSessionsServer, DocumentKeyServer, KeyServer, MessageSigner, ServerKeyGenerator,
|
|
};
|
|
use types::{
|
|
ClusterConfiguration, EncryptedDocumentKey, EncryptedDocumentKeyShadow,
|
|
EncryptedMessageSignature, Error, MessageHash, NodeAddress, NodeId, Public,
|
|
RequestSignature, Requester, ServerKeyId,
|
|
};
|
|
|
|
#[derive(Default)]
|
|
pub struct DummyKeyServer;
|
|
|
|
impl KeyServer for DummyKeyServer {}
|
|
|
|
impl AdminSessionsServer for DummyKeyServer {
|
|
fn change_servers_set(
|
|
&self,
|
|
_old_set_signature: RequestSignature,
|
|
_new_set_signature: RequestSignature,
|
|
_new_servers_set: BTreeSet<NodeId>,
|
|
) -> Result<(), Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
}
|
|
|
|
impl ServerKeyGenerator for DummyKeyServer {
|
|
fn generate_key(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_author: &Requester,
|
|
_threshold: usize,
|
|
) -> Result<Public, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
|
|
fn restore_key_public(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_author: &Requester,
|
|
) -> Result<Public, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
}
|
|
|
|
impl DocumentKeyServer for DummyKeyServer {
|
|
fn store_document_key(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_author: &Requester,
|
|
_common_point: Public,
|
|
_encrypted_document_key: Public,
|
|
) -> Result<(), Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
|
|
fn generate_document_key(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_author: &Requester,
|
|
_threshold: usize,
|
|
) -> Result<EncryptedDocumentKey, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
|
|
fn restore_document_key(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_requester: &Requester,
|
|
) -> Result<EncryptedDocumentKey, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
|
|
fn restore_document_key_shadow(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_requester: &Requester,
|
|
) -> Result<EncryptedDocumentKeyShadow, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
}
|
|
|
|
impl MessageSigner for DummyKeyServer {
|
|
fn sign_message_schnorr(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_requester: &Requester,
|
|
_message: MessageHash,
|
|
) -> Result<EncryptedMessageSignature, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
|
|
fn sign_message_ecdsa(
|
|
&self,
|
|
_key_id: &ServerKeyId,
|
|
_requester: &Requester,
|
|
_message: MessageHash,
|
|
) -> Result<EncryptedMessageSignature, Error> {
|
|
unimplemented!("test-only")
|
|
}
|
|
}
|
|
|
|
fn make_key_servers(
|
|
start_port: u16,
|
|
num_nodes: usize,
|
|
) -> (Vec<KeyServerImpl>, Vec<Arc<DummyKeyStorage>>, Runtime) {
|
|
let key_pairs: Vec<_> = (0..num_nodes).map(|_| Random.generate().unwrap()).collect();
|
|
let configs: Vec<_> = (0..num_nodes)
|
|
.map(|i| ClusterConfiguration {
|
|
listener_address: NodeAddress {
|
|
address: "127.0.0.1".into(),
|
|
port: start_port + (i as u16),
|
|
},
|
|
nodes: key_pairs
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(j, kp)| {
|
|
(
|
|
kp.public().clone(),
|
|
NodeAddress {
|
|
address: "127.0.0.1".into(),
|
|
port: start_port + (j as u16),
|
|
},
|
|
)
|
|
})
|
|
.collect(),
|
|
key_server_set_contract_address: None,
|
|
allow_connecting_to_higher_nodes: false,
|
|
admin_public: None,
|
|
auto_migrate_enabled: false,
|
|
})
|
|
.collect();
|
|
let key_servers_set: BTreeMap<Public, SocketAddr> = configs[0]
|
|
.nodes
|
|
.iter()
|
|
.map(|(k, a)| {
|
|
(
|
|
k.clone(),
|
|
format!("{}:{}", a.address, a.port).parse().unwrap(),
|
|
)
|
|
})
|
|
.collect();
|
|
let key_storages = (0..num_nodes)
|
|
.map(|_| Arc::new(DummyKeyStorage::default()))
|
|
.collect::<Vec<_>>();
|
|
let runtime = Runtime::with_thread_count(4);
|
|
let key_servers: Vec<_> = configs
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(i, cfg)| {
|
|
KeyServerImpl::new(
|
|
&cfg,
|
|
Arc::new(MapKeyServerSet::new(false, key_servers_set.clone())),
|
|
Arc::new(PlainNodeKeyPair::new(key_pairs[i].clone())),
|
|
Arc::new(DummyAclStorage::default()),
|
|
key_storages[i].clone(),
|
|
runtime.executor(),
|
|
)
|
|
.unwrap()
|
|
})
|
|
.collect();
|
|
|
|
// wait until connections are established. It is fast => do not bother with events here
|
|
let start = time::Instant::now();
|
|
let mut tried_reconnections = false;
|
|
loop {
|
|
if key_servers
|
|
.iter()
|
|
.all(|ks| ks.cluster().is_fully_connected())
|
|
{
|
|
break;
|
|
}
|
|
|
|
let old_tried_reconnections = tried_reconnections;
|
|
let mut fully_connected = true;
|
|
for key_server in &key_servers {
|
|
if !key_server.cluster().is_fully_connected() {
|
|
fully_connected = false;
|
|
if !old_tried_reconnections {
|
|
tried_reconnections = true;
|
|
key_server.cluster().connect();
|
|
}
|
|
}
|
|
}
|
|
if fully_connected {
|
|
break;
|
|
}
|
|
if time::Instant::now() - start > time::Duration::from_millis(3000) {
|
|
panic!("connections are not established in 3000ms");
|
|
}
|
|
}
|
|
|
|
(key_servers, key_storages, runtime)
|
|
}
|
|
|
|
#[test]
|
|
fn document_key_generation_and_retrievement_works_over_network_with_single_node() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, _, runtime) = make_key_servers(6070, 1);
|
|
|
|
// generate document key
|
|
let threshold = 0;
|
|
let document = Random.generate().unwrap().secret().clone();
|
|
let secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&secret, &document).unwrap();
|
|
let generated_key = key_servers[0]
|
|
.generate_document_key(&document, &signature.clone().into(), threshold)
|
|
.unwrap();
|
|
let generated_key = crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &generated_key).unwrap();
|
|
|
|
// now let's try to retrieve key back
|
|
for key_server in key_servers.iter() {
|
|
let retrieved_key = key_server
|
|
.restore_document_key(&document, &signature.clone().into())
|
|
.unwrap();
|
|
let retrieved_key =
|
|
crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &retrieved_key).unwrap();
|
|
assert_eq!(retrieved_key, generated_key);
|
|
}
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn document_key_generation_and_retrievement_works_over_network_with_3_nodes() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, key_storages, runtime) = make_key_servers(6080, 3);
|
|
|
|
let test_cases = [0, 1, 2];
|
|
for threshold in &test_cases {
|
|
// generate document key
|
|
let document = Random.generate().unwrap().secret().clone();
|
|
let secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&secret, &document).unwrap();
|
|
let generated_key = key_servers[0]
|
|
.generate_document_key(&document, &signature.clone().into(), *threshold)
|
|
.unwrap();
|
|
let generated_key =
|
|
crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &generated_key).unwrap();
|
|
|
|
// now let's try to retrieve key back
|
|
for (i, key_server) in key_servers.iter().enumerate() {
|
|
let retrieved_key = key_server
|
|
.restore_document_key(&document, &signature.clone().into())
|
|
.unwrap();
|
|
let retrieved_key =
|
|
crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &retrieved_key).unwrap();
|
|
assert_eq!(retrieved_key, generated_key);
|
|
|
|
let key_share = key_storages[i].get(&document).unwrap().unwrap();
|
|
assert!(key_share.common_point.is_some());
|
|
assert!(key_share.encrypted_point.is_some());
|
|
}
|
|
}
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn server_key_generation_and_storing_document_key_works_over_network_with_3_nodes() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, _, runtime) = make_key_servers(6090, 3);
|
|
|
|
let test_cases = [0, 1, 2];
|
|
for threshold in &test_cases {
|
|
// generate server key
|
|
let server_key_id = Random.generate().unwrap().secret().clone();
|
|
let requestor_secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&requestor_secret, &server_key_id).unwrap();
|
|
let server_public = key_servers[0]
|
|
.generate_key(&server_key_id, &signature.clone().into(), *threshold)
|
|
.unwrap();
|
|
|
|
// generate document key (this is done by KS client so that document key is unknown to any KS)
|
|
let generated_key = Random.generate().unwrap().public().clone();
|
|
let encrypted_document_key =
|
|
math::encrypt_secret(&generated_key, &server_public).unwrap();
|
|
|
|
// store document key
|
|
key_servers[0]
|
|
.store_document_key(
|
|
&server_key_id,
|
|
&signature.clone().into(),
|
|
encrypted_document_key.common_point,
|
|
encrypted_document_key.encrypted_point,
|
|
)
|
|
.unwrap();
|
|
|
|
// now let's try to retrieve key back
|
|
for key_server in key_servers.iter() {
|
|
let retrieved_key = key_server
|
|
.restore_document_key(&server_key_id, &signature.clone().into())
|
|
.unwrap();
|
|
let retrieved_key =
|
|
crypto::ecies::decrypt(&requestor_secret, &DEFAULT_MAC, &retrieved_key)
|
|
.unwrap();
|
|
let retrieved_key = Public::from_slice(&retrieved_key);
|
|
assert_eq!(retrieved_key, generated_key);
|
|
}
|
|
}
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn server_key_generation_and_message_signing_works_over_network_with_3_nodes() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, _, runtime) = make_key_servers(6100, 3);
|
|
|
|
let test_cases = [0, 1, 2];
|
|
for threshold in &test_cases {
|
|
// generate server key
|
|
let server_key_id = Random.generate().unwrap().secret().clone();
|
|
let requestor_secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&requestor_secret, &server_key_id).unwrap();
|
|
let server_public = key_servers[0]
|
|
.generate_key(&server_key_id, &signature.clone().into(), *threshold)
|
|
.unwrap();
|
|
|
|
// sign message
|
|
let message_hash = H256::from(42);
|
|
let combined_signature = key_servers[0]
|
|
.sign_message_schnorr(&server_key_id, &signature.into(), message_hash.clone())
|
|
.unwrap();
|
|
let combined_signature =
|
|
crypto::ecies::decrypt(&requestor_secret, &DEFAULT_MAC, &combined_signature)
|
|
.unwrap();
|
|
let signature_c = Secret::from_slice(&combined_signature[..32]).unwrap();
|
|
let signature_s = Secret::from_slice(&combined_signature[32..]).unwrap();
|
|
|
|
// check signature
|
|
assert_eq!(
|
|
math::verify_schnorr_signature(
|
|
&server_public,
|
|
&(signature_c, signature_s),
|
|
&message_hash
|
|
),
|
|
Ok(true)
|
|
);
|
|
}
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn decryption_session_is_delegated_when_node_does_not_have_key_share() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, key_storages, runtime) = make_key_servers(6110, 3);
|
|
|
|
// generate document key
|
|
let threshold = 0;
|
|
let document = Random.generate().unwrap().secret().clone();
|
|
let secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&secret, &document).unwrap();
|
|
let generated_key = key_servers[0]
|
|
.generate_document_key(&document, &signature.clone().into(), threshold)
|
|
.unwrap();
|
|
let generated_key = crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &generated_key).unwrap();
|
|
|
|
// remove key from node0
|
|
key_storages[0].remove(&document).unwrap();
|
|
|
|
// now let's try to retrieve key back by requesting it from node0, so that session must be delegated
|
|
let retrieved_key = key_servers[0]
|
|
.restore_document_key(&document, &signature.into())
|
|
.unwrap();
|
|
let retrieved_key = crypto::ecies::decrypt(&secret, &DEFAULT_MAC, &retrieved_key).unwrap();
|
|
assert_eq!(retrieved_key, generated_key);
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn schnorr_signing_session_is_delegated_when_node_does_not_have_key_share() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, key_storages, runtime) = make_key_servers(6114, 3);
|
|
let threshold = 1;
|
|
|
|
// generate server key
|
|
let server_key_id = Random.generate().unwrap().secret().clone();
|
|
let requestor_secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&requestor_secret, &server_key_id).unwrap();
|
|
let server_public = key_servers[0]
|
|
.generate_key(&server_key_id, &signature.clone().into(), threshold)
|
|
.unwrap();
|
|
|
|
// remove key from node0
|
|
key_storages[0].remove(&server_key_id).unwrap();
|
|
|
|
// sign message
|
|
let message_hash = H256::from(42);
|
|
let combined_signature = key_servers[0]
|
|
.sign_message_schnorr(&server_key_id, &signature.into(), message_hash.clone())
|
|
.unwrap();
|
|
let combined_signature =
|
|
crypto::ecies::decrypt(&requestor_secret, &DEFAULT_MAC, &combined_signature).unwrap();
|
|
let signature_c = Secret::from_slice(&combined_signature[..32]).unwrap();
|
|
let signature_s = Secret::from_slice(&combined_signature[32..]).unwrap();
|
|
|
|
// check signature
|
|
assert_eq!(
|
|
math::verify_schnorr_signature(
|
|
&server_public,
|
|
&(signature_c, signature_s),
|
|
&message_hash
|
|
),
|
|
Ok(true)
|
|
);
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn ecdsa_signing_session_is_delegated_when_node_does_not_have_key_share() {
|
|
let _ = ::env_logger::try_init();
|
|
let (key_servers, key_storages, runtime) = make_key_servers(6117, 4);
|
|
let threshold = 1;
|
|
|
|
// generate server key
|
|
let server_key_id = Random.generate().unwrap().secret().clone();
|
|
let requestor_secret = Random.generate().unwrap().secret().clone();
|
|
let signature = ethkey::sign(&requestor_secret, &server_key_id).unwrap();
|
|
let server_public = key_servers[0]
|
|
.generate_key(&server_key_id, &signature.clone().into(), threshold)
|
|
.unwrap();
|
|
|
|
// remove key from node0
|
|
key_storages[0].remove(&server_key_id).unwrap();
|
|
|
|
// sign message
|
|
let message_hash = H256::random();
|
|
let signature = key_servers[0]
|
|
.sign_message_ecdsa(&server_key_id, &signature.into(), message_hash.clone())
|
|
.unwrap();
|
|
let signature =
|
|
crypto::ecies::decrypt(&requestor_secret, &DEFAULT_MAC, &signature).unwrap();
|
|
let signature: H520 = signature[0..65].into();
|
|
|
|
// check signature
|
|
assert!(verify_public(&server_public, &signature.into(), &message_hash).unwrap());
|
|
drop(runtime);
|
|
}
|
|
|
|
#[test]
|
|
fn servers_set_change_session_works_over_network() {
|
|
// TODO [Test]
|
|
}
|
|
}
|