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

Using destination address type alias rather than just array of 32

Browse Source 
( + rustfmt)
This commit is contained in:
Jedrzej Stuczynski
2019-12-18 09:40:15 +00:00
parent b63494f686
commit 06c645cf56
2 changed files with 109 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/provider/client_handling/mod.rs
+107 -47
View File
@@ -1,17 +1,21 @@
use crate::provider::storage::{ClientStorage, StoreError};
use sfw_provider_requests::requests::{ProviderRequestError, ProviderRequests, PullRequest, RegisterRequest, ProviderRequest, AuthToken};
use sfw_provider_requests::responses::{ProviderResponse, PullResponse, RegisterResponse};
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
use curve25519_dalek::digest::Digest;
use sha2::Sha256;
use std::io;
use std::collections::HashMap;
use serde_json::json;
use serde::{Deserialize, Serialize};
use std::hash::Hash;
use curve25519_dalek::scalar::Scalar;
use hmac::{Hmac, Mac};
use serde::{Deserialize, Serialize};
use serde_json::json;
use sfw_provider_requests::requests::{
AuthToken, ProviderRequest, ProviderRequestError, ProviderRequests, PullRequest,
RegisterRequest,
};
use sfw_provider_requests::responses::{ProviderResponse, PullResponse, RegisterResponse};
use sha2::Sha256;
use sphinx::route::DestinationAddressBytes;
use std::collections::HashMap;
use std::hash::Hash;
use std::io;
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
type HmacSha256 = Hmac<Sha256>;
@@ -43,12 +47,18 @@ impl From<StoreError> for ClientProcessingError {
#[derive(Debug, Clone)]
pub(crate) struct ClientProcessingData {
store_dir: PathBuf,
registered_clients_ledger: HashMap<[u8; 32], Vec<u8>>,
registered_clients_ledger: HashMap<DestinationAddressBytes, Vec<u8>>,
}
impl ClientProcessingData {
pub(crate) fn new(store_dir: PathBuf, registered_clients_ledger: HashMap<[u8; 32], Vec<u8>>) -> Self {
ClientProcessingData { store_dir, registered_clients_ledger}
pub(crate) fn new(
store_dir: PathBuf,
registered_clients_ledger: HashMap<DestinationAddressBytes, Vec<u8>>,
) -> Self {
ClientProcessingData {
store_dir,
registered_clients_ledger,
}
}
pub(crate) fn add_arc_rwlock(self) -> Arc<RwLock<Self>> {
@@ -62,19 +72,31 @@ impl ClientRequestProcessor {
pub(crate) fn process_client_request(
data: &[u8],
processing_data: &RwLock<ClientProcessingData>,
provider_secret_key: Scalar
provider_secret_key: Scalar,
) -> Result<Vec<u8>, ClientProcessingError> {
let client_request = ProviderRequests::from_bytes(&data)?;
println!("Received the following request: {:?}", client_request);
match client_request {
ProviderRequests::Register(req) => {
Ok(ClientRequestProcessor::register_new_client(req, processing_data.read().unwrap().store_dir.as_path(),&mut processing_data.read().unwrap().registered_clients_ledger.clone(), provider_secret_key)?.to_bytes())
},
ProviderRequests::Register(req) => Ok(ClientRequestProcessor::register_new_client(
req,
processing_data.read().unwrap().store_dir.as_path(),
&mut processing_data
.read()
.unwrap()
.registered_clients_ledger
.clone(),
provider_secret_key,
)?
.to_bytes()),
ProviderRequests::PullMessages(req) => {
Ok(ClientRequestProcessor::process_pull_messages_request(
req,
processing_data.read().unwrap().store_dir.as_path(),
&mut processing_data.read().unwrap().registered_clients_ledger.clone(),
&mut processing_data
.read()
.unwrap()
.registered_clients_ledger
.clone(),
)?
.to_bytes())
}
@@ -84,30 +106,41 @@ impl ClientRequestProcessor {
fn process_pull_messages_request(
req: PullRequest,
store_dir: &Path,
registered_client_ledger: &mut HashMap<[u8; 32], Vec<u8>>,
registered_client_ledger: &mut HashMap<DestinationAddressBytes, Vec<u8>>,
) -> Result<PullResponse, ClientProcessingError> {
println!("Processing pull!");
if registered_client_ledger.contains_key(&req.auth_token.value){
if registered_client_ledger.contains_key(&req.auth_token.value) {
let retrieved_messages =
ClientStorage::retrieve_client_files(req.destination_address, store_dir)?;
Ok(PullResponse::new(retrieved_messages))
} else {
Err(ClientProcessingError::WrongToken)
}
}
fn register_new_client(req:RegisterRequest, store_dir: &Path, registered_client_ledger: &mut HashMap<[u8; 32], Vec<u8>>, provider_secret_key: Scalar) -> Result<RegisterResponse, ClientProcessingError>{
fn register_new_client(
req: RegisterRequest,
store_dir: &Path,
registered_client_ledger: &mut HashMap<DestinationAddressBytes, Vec<u8>>,
provider_secret_key: Scalar,
) -> Result<RegisterResponse, ClientProcessingError> {
println!("Processing register new client request!");
let auth_token = ClientRequestProcessor::generate_new_auth_token(req.destination_address.to_vec(), provider_secret_key);
let auth_token = ClientRequestProcessor::generate_new_auth_token(
req.destination_address.to_vec(),
provider_secret_key,
);
if !registered_client_ledger.contains_key(&auth_token.value) {
registered_client_ledger.insert(auth_token.value.clone(), req.destination_address.to_vec());
registered_client_ledger
.insert(auth_token.value.clone(), req.destination_address.to_vec());
ClientRequestProcessor::create_storage_dir(req.destination_address, store_dir);
}
Ok(RegisterResponse::new(auth_token.value.to_vec()))
}
fn create_storage_dir(client_address : sphinx::route::DestinationAddressBytes, store_dir: &Path) -> io::Result<()>{
fn create_storage_dir(
client_address: sphinx::route::DestinationAddressBytes,
store_dir: &Path,
) -> io::Result<()> {
let client_dir_name = hex::encode(client_address);
let full_store_dir = store_dir.join(client_dir_name);
let full_store_path = full_store_dir.join(ClientStorage::generate_random_file_name());
@@ -115,14 +148,14 @@ impl ClientRequestProcessor {
Ok(())
}
fn generate_new_auth_token(data: Vec<u8>, key: Scalar) -> AuthToken{
let mut auth_token = HmacSha256::new_varkey(&key.to_bytes()).expect("HMAC can take key of any size");
fn generate_new_auth_token(data: Vec<u8>, key: Scalar) -> AuthToken {
let mut auth_token =
HmacSha256::new_varkey(&key.to_bytes()).expect("HMAC can take key of any size");
auth_token.input(&data);
let mut result = [0u8; 32];
result.copy_from_slice(&auth_token.result().code().to_vec());
AuthToken{value: result}
AuthToken { value: result }
}
}
#[cfg(test)]
@@ -130,29 +163,59 @@ mod register_new_client {
use super::*;
#[test]
fn registers_new_auth_token_for_each_new_client(){
let req1 = RegisterRequest{destination_address: [1u8; 32]};
let mut registered_client_ledger: HashMap<[u8; 32], Vec<u8>> = HashMap::new();
fn registers_new_auth_token_for_each_new_client() {
let req1 = RegisterRequest {
destination_address: [1u8; 32],
};
let mut registered_client_ledger: HashMap<DestinationAddressBytes, Vec<u8>> =
HashMap::new();
let store_dir = Path::new("./foo/");
let key = Scalar::from_bytes_mod_order([1u8; 32]);
assert_eq!(0, registered_client_ledger.len());
ClientRequestProcessor::register_new_client(req1, &store_dir, &mut registered_client_ledger, key);
ClientRequestProcessor::register_new_client(
req1,
&store_dir,
&mut registered_client_ledger,
key,
);
assert_eq!(1, registered_client_ledger.len());
let req2 = RegisterRequest{destination_address: [2u8; 32]};
ClientRequestProcessor::register_new_client(req2, &store_dir, &mut registered_client_ledger, key);
let req2 = RegisterRequest {
destination_address: [2u8; 32],
};
ClientRequestProcessor::register_new_client(
req2,
&store_dir,
&mut registered_client_ledger,
key,
);
assert_eq!(2, registered_client_ledger.len());
}
#[test]
fn registers_given_token_only_once() {
let req1 = RegisterRequest{destination_address: [1u8; 32]};
let mut registered_client_ledger: HashMap<[u8; 32], Vec<u8>> = HashMap::new();
let req1 = RegisterRequest {
destination_address: [1u8; 32],
};
let mut registered_client_ledger: HashMap<DestinationAddressBytes, Vec<u8>> =
HashMap::new();
let store_dir = Path::new("./foo/");
let key = Scalar::from_bytes_mod_order([1u8; 32]);
ClientRequestProcessor::register_new_client(req1, &store_dir, &mut registered_client_ledger, key);
let req2 = RegisterRequest{destination_address: [1u8; 32]};
ClientRequestProcessor::register_new_client(req2, &store_dir, &mut registered_client_ledger, key);
ClientRequestProcessor::register_new_client(
req1,
&store_dir,
&mut registered_client_ledger,
key,
);
let req2 = RegisterRequest {
destination_address: [1u8; 32],
};
ClientRequestProcessor::register_new_client(
req2,
&store_dir,
&mut registered_client_ledger,
key,
);
assert_eq!(1, registered_client_ledger.len())
}
}
@@ -163,19 +226,18 @@ mod create_storage_dir {
use sphinx::route::DestinationAddressBytes;
#[test]
fn it_creates_a_correct_storage_directory(){
fn it_creates_a_correct_storage_directory() {
let client_address: DestinationAddressBytes = [1u8; 32];
let store_dir = Path::new("./foo/");
ClientRequestProcessor::create_storage_dir(client_address, store_dir);
}
}
#[cfg(test)]
mod generating_new_auth_token {
use super::*;
#[test]
fn for_the_same_input_generates_the_same_auth_token(){
fn for_the_same_input_generates_the_same_auth_token() {
let data1 = vec![1u8; 55];
let data2 = vec![1u8; 55];
let key = Scalar::from_bytes_mod_order([1u8; 32]);
@@ -185,7 +247,7 @@ mod generating_new_auth_token {
}
#[test]
fn for_different_inputs_generates_different_auth_tokens(){
fn for_different_inputs_generates_different_auth_tokens() {
let data1 = vec![1u8; 55];
let data2 = vec![2u8; 55];
let key = Scalar::from_bytes_mod_order([1u8; 32]);
@@ -200,6 +262,4 @@ mod generating_new_auth_token {
let token2 = ClientRequestProcessor::generate_new_auth_token(data2, key);
assert_ne!(token1.value, token2.value);
}
}
}
src/provider/mod.rs
+2 -1
View File
@@ -11,6 +11,7 @@ use crate::provider::client_handling::{ClientProcessingData, ClientRequestProces
use crate::provider::mix_handling::{MixPacketProcessor, MixProcessingData};
use crate::provider::storage::ClientStorage;
use std::collections::HashMap;
use sphinx::route::DestinationAddressBytes;
mod client_handling;
mod mix_handling;
@@ -26,7 +27,7 @@ pub struct ServiceProvider {
client_network_address: SocketAddr,
secret_key: Scalar,
store_dir: PathBuf,
registered_clients_ledger: HashMap<[u8; 32], Vec<u8>>,
registered_clients_ledger: HashMap<DestinationAddressBytes, Vec<u8>>,
}
impl ServiceProvider {