GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Provider starting to use new config

Browse Source
This commit is contained in:
Jedrzej Stuczynski
2020-02-05 12:38:32 +00:00
parent c5ec0591e1
commit 3fdf7b4f10
4 changed files with 48 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sfw-provider/src/commands/run.rs
+1 -19
View File
@@ -161,24 +161,6 @@ pub fn execute(matches: &ArgMatches) {
config.get_clients_ledger_path()
);
// key will be loaded directly provider in just a moment
let key_pair = ServiceProvider::load_sphinx_keys(&config);
// stupid temporary hack
let private_bytes = key_pair.private_key().to_bytes();
let public_bytes = key_pair.public_key().to_bytes();
let old_startup_config = provider::Config {
client_socket_address: config.get_clients_listening_address(),
directory_server: config.get_presence_directory_server(),
mix_socket_address: config.get_mix_listening_address(),
// identity keys are wrapper for encryption keys so this temporary hack will work to just make it compile once
public_key: MixIdentityPublicKey::from_bytes(public_bytes.as_ref()),
secret_key: MixIdentityPrivateKey::from_bytes(private_bytes.as_ref()),
store_dir: Default::default(),
};
let provider = ServiceProvider::new(old_startup_config);
let provider = ServiceProvider::new(config);
provider.start().unwrap()
}
sfw-provider/src/provider/client_handling/mod.rs
+5 -4
View File
@@ -1,5 +1,6 @@
use crate::provider::storage::{ClientStorage, StoreError};
use crate::provider::ClientLedger;
use crypto::encryption;
use crypto::identity::MixIdentityPrivateKey;
use futures::lock::Mutex as FMutex;
use hmac::{Hmac, Mac};
@@ -54,14 +55,14 @@ impl From<io::Error> for ClientProcessingError {
pub(crate) struct ClientProcessingData {
store_dir: PathBuf,
registered_clients_ledger: Arc<FMutex<ClientLedger>>,
secret_key: MixIdentityPrivateKey,
secret_key: encryption::PrivateKey,
}
impl ClientProcessingData {
pub(crate) fn new(
store_dir: PathBuf,
registered_clients_ledger: Arc<FMutex<ClientLedger>>,
secret_key: MixIdentityPrivateKey,
secret_key: encryption::PrivateKey,
) -> Self {
ClientProcessingData {
store_dir,
@@ -132,7 +133,7 @@ impl ClientRequestProcessor {
let auth_token = ClientRequestProcessor::generate_new_auth_token(
req.destination_address.to_vec(),
processing_data.secret_key,
&processing_data.secret_key,
);
if !unlocked_ledger.has_token(&auth_token) {
unlocked_ledger.insert_token(auth_token.clone(), req.destination_address);
@@ -153,7 +154,7 @@ impl ClientRequestProcessor {
std::fs::create_dir_all(full_store_dir)
}
fn generate_new_auth_token(data: Vec<u8>, key: MixIdentityPrivateKey) -> AuthToken {
fn generate_new_auth_token(data: Vec<u8>, key: &encryption::PrivateKey) -> AuthToken {
// also note that `new_varkey` doesn't even have an execution branch returning an error
let mut auth_token_raw = HmacSha256::new_varkey(&key.to_bytes())
.expect("HMAC should be able take key of any size");
sfw-provider/src/provider/mix_handling/mod.rs
+4 -3
View File
@@ -1,4 +1,5 @@
use crate::provider::storage::StoreData;
use crypto::encryption;
use crypto::identity::MixIdentityPrivateKey;
use log::{error, warn};
use sphinx::{ProcessedPacket, SphinxPacket};
@@ -37,12 +38,12 @@ impl From<std::io::Error> for MixProcessingError {
// ProcessingData defines all data required to correctly unwrap sphinx packets
#[derive(Debug, Clone)]
pub(crate) struct MixProcessingData {
secret_key: MixIdentityPrivateKey,
secret_key: encryption::PrivateKey,
pub(crate) store_dir: PathBuf,
}
impl MixProcessingData {
pub(crate) fn new(secret_key: MixIdentityPrivateKey, store_dir: PathBuf) -> Self {
pub(crate) fn new(secret_key: encryption::PrivateKey, store_dir: PathBuf) -> Self {
MixProcessingData {
secret_key,
store_dir,
@@ -70,7 +71,7 @@ impl MixPacketProcessor {
}
};
let (client_address, client_surb_id, payload) =
match packet.process(read_processing_data.secret_key.as_scalar()) {
match packet.process(read_processing_data.secret_key.inner()) {
Ok(ProcessedPacket::ProcessedPacketFinalHop(client_address, surb_id, payload)) => {
(client_address, surb_id, payload)
}
sfw-provider/src/provider/mod.rs
+38 -49
View File
@@ -1,4 +1,5 @@
use crate::config::persistance::pathfinder::ProviderPathfinder;
use crate::config::Config;
use crate::provider::client_handling::{ClientProcessingData, ClientRequestProcessor};
use crate::provider::mix_handling::{MixPacketProcessor, MixProcessingData};
use crate::provider::storage::ClientStorage;
@@ -28,15 +29,6 @@ mod storage;
const STORED_MESSAGE_FILENAME_LENGTH: usize = 16;
const MESSAGE_RETRIEVAL_LIMIT: usize = 5;
pub struct Config {
pub client_socket_address: SocketAddr,
pub directory_server: String,
pub mix_socket_address: SocketAddr,
pub public_key: MixIdentityPublicKey,
pub secret_key: MixIdentityPrivateKey,
pub store_dir: PathBuf,
}
#[derive(Debug)]
pub enum ProviderError {
TcpListenerBindingError,
@@ -102,29 +94,34 @@ impl ClientLedger {
}
pub struct ServiceProvider {
directory_server: String,
mix_network_address: SocketAddr,
client_network_address: SocketAddr,
public_key: MixIdentityPublicKey,
secret_key: MixIdentityPrivateKey,
store_dir: PathBuf,
config: Config,
sphinx_keypair: encryption::KeyPair,
registered_clients_ledger: ClientLedger,
}
impl ServiceProvider {
pub fn new(config: Config) -> Self {
let sphinx_keypair = Self::load_sphinx_keys(&config);
ServiceProvider {
mix_network_address: config.mix_socket_address,
client_network_address: config.client_socket_address,
secret_key: config.secret_key,
public_key: config.public_key,
store_dir: PathBuf::from(config.store_dir.clone()),
config,
sphinx_keypair,
// TODO: load initial ledger from file
registered_clients_ledger: ClientLedger::new(),
directory_server: config.directory_server.clone(),
}
}
fn load_sphinx_keys(config_file: &Config) -> encryption::KeyPair {
let sphinx_keypair = PemStore::new(ProviderPathfinder::new_from_config(&config_file))
.read_encryption()
.expect("Failed to read stored sphinx key files");
println!(
"Public encryption key: {}\nFor time being, it is identical to identity keys",
sphinx_keypair.public_key().to_base58_string()
);
sphinx_keypair
}
async fn process_mixnet_socket_connection(
mut socket: tokio::net::TcpStream,
processing_data: Arc<RwLock<MixProcessingData>>,
@@ -239,7 +236,7 @@ impl ServiceProvider {
async fn start_mixnet_listening(
address: SocketAddr,
secret_key: MixIdentityPrivateKey,
secret_key: encryption::PrivateKey,
store_dir: PathBuf,
) -> Result<(), ProviderError> {
let mut listener = tokio::net::TcpListener::bind(address).await?;
@@ -261,7 +258,7 @@ impl ServiceProvider {
address: SocketAddr,
store_dir: PathBuf,
client_ledger: Arc<FMutex<ClientLedger>>,
secret_key: MixIdentityPrivateKey,
secret_key: encryption::PrivateKey,
) -> Result<(), ProviderError> {
let mut listener = tokio::net::TcpListener::bind(address).await?;
let processing_data =
@@ -279,19 +276,6 @@ impl ServiceProvider {
}
}
// TODO: make private and change config import path
pub fn load_sphinx_keys(config_file: &crate::config::Config) -> encryption::KeyPair {
let sphinx_keypair = PemStore::new(ProviderPathfinder::new_from_config(&config_file))
.read_encryption()
.expect("Failed to read stored sphinx key files");
println!(
"Public encryption key: {}\nFor time being, it is identical to identity keys",
sphinx_keypair.public_key().to_base58_string()
);
sphinx_keypair
}
// Note: this now consumes the provider
pub fn start(self) -> Result<(), Box<dyn std::error::Error>> {
// Create the runtime, probably later move it to Provider struct itself?
// TODO: figure out the difference between Runtime and Handle
@@ -301,25 +285,30 @@ impl ServiceProvider {
let initial_client_ledger = self.registered_clients_ledger;
let thread_shareable_ledger = initial_client_ledger.add_arc_futures_mutex();
let presence_notifier = presence::Notifier::new(
self.directory_server,
self.client_network_address.clone(),
self.mix_network_address.clone(),
self.public_key,
thread_shareable_ledger.clone(),
let notifier_config = presence::NotifierConfig::new(
self.config.get_presence_directory_server(),
self.config.get_mix_announce_address(),
self.config.get_clients_announce_address(),
self.sphinx_keypair.public_key().to_base58_string(),
self.config.get_presence_sending_delay(),
);
let presence_future = rt.spawn(presence_notifier.run());
let presence_future = rt.spawn({
let presence_notifier =
presence::Notifier::new(notifier_config, thread_shareable_ledger.clone());
presence_notifier.run()
});
let mix_future = rt.spawn(ServiceProvider::start_mixnet_listening(
self.mix_network_address,
self.secret_key.clone(),
self.store_dir.clone(),
self.config.get_mix_listening_address(),
*self.sphinx_keypair.private_key(),
self.config.get_clients_inboxes_dir(),
));
let client_future = rt.spawn(ServiceProvider::start_client_listening(
self.client_network_address,
self.store_dir.clone(),
self.config.get_clients_listening_address(),
self.config.get_clients_inboxes_dir(),
thread_shareable_ledger,
self.secret_key,
*self.sphinx_keypair.private_key(),
));
// Spawn the root task
rt.block_on(async {