diff --git a/clients/native/src/client/mod.rs b/clients/native/src/client/mod.rs index 7b76a1c695..07ddb9b462 100644 --- a/clients/native/src/client/mod.rs +++ b/clients/native/src/client/mod.rs @@ -1,8 +1,10 @@ // Copyright 2021 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 -use crate::client::config::{Config, SocketType}; -use crate::websocket; +use futures::channel::mpsc; +use log::*; +use tokio::runtime::Runtime; + use client_core::client::cover_traffic_stream::LoopCoverTrafficStream; use client_core::client::inbound_messages::{ InputMessage, InputMessageReceiver, InputMessageSender, @@ -22,28 +24,26 @@ use client_core::client::topology_control::{ TopologyAccessor, TopologyRefresher, TopologyRefresherConfig, }; use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder; - #[cfg(feature = "coconut")] -use coconut_interface::{hash_to_scalar, Credential, Parameters}; +use coconut_interface::{Credential, hash_to_scalar, Parameters}; #[cfg(feature = "coconut")] use credentials::bandwidth::{ - prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES, + BANDWIDTH_VALUE, BandwidthVoucherAttributes, prepare_for_spending, TOTAL_ATTRIBUTES, }; #[cfg(feature = "coconut")] use credentials::obtain_aggregate_verification_key; - use crypto::asymmetric::identity; -use futures::channel::mpsc; use gateway_client::{ AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver, MixnetMessageSender, }; -use log::*; use nymsphinx::addressing::clients::Recipient; use nymsphinx::addressing::nodes::NodeIdentity; use nymsphinx::anonymous_replies::ReplySurb; use nymsphinx::receiver::ReconstructedMessage; -use tokio::runtime::Runtime; + +use crate::client::config::{Config, SocketType}; +use crate::websocket; pub(crate) mod config; @@ -117,7 +117,7 @@ impl NymClient { self.as_mix_recipient(), topology_accessor, ) - .start(self.runtime.handle()); + .start(self.runtime.handle()); } fn start_real_traffic_controller( @@ -152,7 +152,7 @@ impl NymClient { topology_accessor, reply_key_storage, ) - .start(self.runtime.handle()); + .start(self.runtime.handle()); } // buffer controlling all messages fetched from provider @@ -170,7 +170,7 @@ impl NymClient { mixnet_receiver, reply_key_storage, ) - .start(self.runtime.handle()) + .start(self.runtime.handle()) } #[cfg(feature = "coconut")] @@ -178,8 +178,8 @@ impl NymClient { let verification_key = obtain_aggregate_verification_key( &self.config.get_base().get_validator_api_endpoints(), ) - .await - .expect("could not obtain aggregate verification key of validators"); + .await + .expect("could not obtain aggregate verification key of validators"); let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap(); let bandwidth_credential_attributes = BandwidthVoucherAttributes { @@ -193,10 +193,9 @@ impl NymClient { ¶ms, &bandwidth_credential_attributes, &self.config.get_base().get_validator_api_endpoints(), - &verification_key, ) - .await - .expect("could not obtain bandwidth credential"); + .await + .expect("could not obtain bandwidth credential"); // the above would presumably be loaded from a file // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff) @@ -206,7 +205,7 @@ impl NymClient { &bandwidth_credential_attributes, &verification_key, ) - .expect("could not prepare out bandwidth credential for spending") + .expect("could not prepare out bandwidth credential for spending") } fn start_gateway_client( @@ -228,7 +227,7 @@ impl NymClient { self.runtime.block_on(async { #[cfg(feature = "coconut")] - let coconut_credential = self.prepare_coconut_credential().await; + let coconut_credential = self.prepare_coconut_credential().await; let mut gateway_client = GatewayClient::new( gateway_address, @@ -243,7 +242,7 @@ impl NymClient { gateway_client .authenticate_and_start( #[cfg(feature = "coconut")] - Some(coconut_credential), + Some(coconut_credential), ) .await .expect("could not authenticate and start up the gateway connection"); diff --git a/clients/native/src/commands/init.rs b/clients/native/src/commands/init.rs index 728ed8765f..cb05b4c98c 100644 --- a/clients/native/src/commands/init.rs +++ b/clients/native/src/commands/init.rs @@ -14,11 +14,11 @@ use url::Url; use client_core::client::key_manager::KeyManager; use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder; #[cfg(feature = "coconut")] -use coconut_interface::{hash_to_scalar, Credential, Parameters}; +use coconut_interface::{Credential, hash_to_scalar, Parameters}; use config::NymConfig; #[cfg(feature = "coconut")] use credentials::bandwidth::{ - prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES, + BANDWIDTH_VALUE, BandwidthVoucherAttributes, prepare_for_spending, TOTAL_ATTRIBUTES, }; #[cfg(feature = "coconut")] use credentials::obtain_aggregate_verification_key; @@ -88,10 +88,9 @@ async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) ¶ms, &bandwidth_credential_attributes, validators, - &verification_key, ) - .await - .expect("could not obtain bandwidth credential"); + .await + .expect("could not obtain bandwidth credential"); prepare_for_spending( raw_identity, @@ -99,7 +98,7 @@ async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) &bandwidth_credential_attributes, &verification_key, ) - .expect("could not prepare out bandwidth credential for spending") + .expect("could not prepare out bandwidth credential for spending") } async fn register_with_gateway( @@ -164,7 +163,7 @@ fn show_address(config: &Config) { pathfinder.private_identity_key().to_owned(), pathfinder.public_identity_key().to_owned(), )) - .expect("Failed to read stored identity key files"); + .expect("Failed to read stored identity key files"); identity_keypair } @@ -174,7 +173,7 @@ fn show_address(config: &Config) { pathfinder.private_encryption_key().to_owned(), pathfinder.public_encryption_key().to_owned(), )) - .expect("Failed to read stored sphinx key files"); + .expect("Failed to read stored sphinx key files"); sphinx_keypair } @@ -229,7 +228,7 @@ pub fn execute(matches: &ArgMatches) { config.get_base().get_validator_api_endpoints(), chosen_gateway_id, ) - .await; + .await; config .get_base_mut() .with_gateway_id(gate_details.identity_key.to_base58_string()); @@ -258,7 +257,7 @@ pub fn execute(matches: &ArgMatches) { .save_to_file(None) .expect("Failed to save the config file"); println!("Saved configuration file to {:?}", config_save_location); - println!("Using gateway: {}", config.get_base().get_gateway_id(),); + println!("Using gateway: {}", config.get_base().get_gateway_id(), ); println!("Client configuration completed.\n\n\n"); show_address(&config); diff --git a/clients/socks5/src/client/mod.rs b/clients/socks5/src/client/mod.rs index de445f26af..54a113453f 100644 --- a/clients/socks5/src/client/mod.rs +++ b/clients/socks5/src/client/mod.rs @@ -1,11 +1,10 @@ // Copyright 2021 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 -use crate::client::config::Config; -use crate::socks::{ - authentication::{AuthenticationMethods, Authenticator, User}, - server::SphinxSocksServer, -}; +use futures::channel::mpsc; +use log::*; +use tokio::runtime::Runtime; + use client_core::client::cover_traffic_stream::LoopCoverTrafficStream; use client_core::client::inbound_messages::{ InputMessage, InputMessageReceiver, InputMessageSender, @@ -23,26 +22,27 @@ use client_core::client::topology_control::{ TopologyAccessor, TopologyRefresher, TopologyRefresherConfig, }; use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder; - #[cfg(feature = "coconut")] -use coconut_interface::{hash_to_scalar, Credential, Parameters}; +use coconut_interface::{Credential, hash_to_scalar, Parameters}; #[cfg(feature = "coconut")] use credentials::bandwidth::{ - prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES, + BANDWIDTH_VALUE, BandwidthVoucherAttributes, prepare_for_spending, TOTAL_ATTRIBUTES, }; #[cfg(feature = "coconut")] use credentials::obtain_aggregate_verification_key; - use crypto::asymmetric::identity; -use futures::channel::mpsc; use gateway_client::{ AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver, MixnetMessageSender, }; -use log::*; use nymsphinx::addressing::clients::Recipient; use nymsphinx::addressing::nodes::NodeIdentity; -use tokio::runtime::Runtime; + +use crate::client::config::Config; +use crate::socks::{ + authentication::{AuthenticationMethods, Authenticator, User}, + server::SphinxSocksServer, +}; pub(crate) mod config; @@ -105,7 +105,7 @@ impl NymClient { self.as_mix_recipient(), topology_accessor, ) - .start(self.runtime.handle()); + .start(self.runtime.handle()); } fn start_real_traffic_controller( @@ -140,7 +140,7 @@ impl NymClient { topology_accessor, reply_key_storage, ) - .start(self.runtime.handle()); + .start(self.runtime.handle()); } // buffer controlling all messages fetched from provider @@ -158,7 +158,7 @@ impl NymClient { mixnet_receiver, reply_key_storage, ) - .start(self.runtime.handle()) + .start(self.runtime.handle()) } #[cfg(feature = "coconut")] @@ -166,8 +166,8 @@ impl NymClient { let verification_key = obtain_aggregate_verification_key( &self.config.get_base().get_validator_api_endpoints(), ) - .await - .expect("could not obtain aggregate verification key of validators"); + .await + .expect("could not obtain aggregate verification key of validators"); let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap(); let bandwidth_credential_attributes = BandwidthVoucherAttributes { @@ -181,10 +181,9 @@ impl NymClient { ¶ms, &bandwidth_credential_attributes, &self.config.get_base().get_validator_api_endpoints(), - &verification_key, ) - .await - .expect("could not obtain bandwidth credential"); + .await + .expect("could not obtain bandwidth credential"); // the above would presumably be loaded from a file // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff) @@ -194,7 +193,7 @@ impl NymClient { &bandwidth_credential_attributes, &verification_key, ) - .expect("could not prepare out bandwidth credential for spending") + .expect("could not prepare out bandwidth credential for spending") } fn start_gateway_client( @@ -216,7 +215,7 @@ impl NymClient { self.runtime.block_on(async { #[cfg(feature = "coconut")] - let coconut_credential = self.prepare_coconut_credential().await; + let coconut_credential = self.prepare_coconut_credential().await; let mut gateway_client = GatewayClient::new( gateway_address, @@ -231,7 +230,7 @@ impl NymClient { gateway_client .authenticate_and_start( #[cfg(feature = "coconut")] - Some(coconut_credential), + Some(coconut_credential), ) .await .expect("could not authenticate and start up the gateway connection"); diff --git a/clients/socks5/src/commands/init.rs b/clients/socks5/src/commands/init.rs index f6bc31624b..c7cc4e00c3 100644 --- a/clients/socks5/src/commands/init.rs +++ b/clients/socks5/src/commands/init.rs @@ -12,11 +12,11 @@ use url::Url; use client_core::client::key_manager::KeyManager; use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder; #[cfg(feature = "coconut")] -use coconut_interface::{hash_to_scalar, Credential, Parameters}; +use coconut_interface::{Credential, hash_to_scalar, Parameters}; use config::NymConfig; #[cfg(feature = "coconut")] use credentials::bandwidth::{ - prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES, + BANDWIDTH_VALUE, BandwidthVoucherAttributes, prepare_for_spending, TOTAL_ATTRIBUTES, }; #[cfg(feature = "coconut")] use credentials::obtain_aggregate_verification_key; @@ -81,17 +81,16 @@ async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) serial_number: params.random_scalar(), binding_number: params.random_scalar(), voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()), - voucher_info: hash_to_scalar("BandwidthVoucher"), + voucher_info: hash_to_scalar("BandwidthVoucher"), }; let bandwidth_credential = credentials::bandwidth::obtain_signature( ¶ms, &bandwidth_credential_attributes, validators, - &verification_key, ) - .await - .expect("could not obtain bandwidth credential"); + .await + .expect("could not obtain bandwidth credential"); prepare_for_spending( raw_identity, @@ -99,7 +98,7 @@ async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) &bandwidth_credential_attributes, &verification_key, ) - .expect("could not prepare out bandwidth credential for spending") + .expect("could not prepare out bandwidth credential for spending") } async fn register_with_gateway( @@ -164,7 +163,7 @@ fn show_address(config: &Config) { pathfinder.private_identity_key().to_owned(), pathfinder.public_identity_key().to_owned(), )) - .expect("Failed to read stored identity key files"); + .expect("Failed to read stored identity key files"); identity_keypair } @@ -174,7 +173,7 @@ fn show_address(config: &Config) { pathfinder.private_encryption_key().to_owned(), pathfinder.public_encryption_key().to_owned(), )) - .expect("Failed to read stored sphinx key files"); + .expect("Failed to read stored sphinx key files"); sphinx_keypair } @@ -230,7 +229,7 @@ pub fn execute(matches: &ArgMatches) { config.get_base().get_validator_api_endpoints(), chosen_gateway_id, ) - .await; + .await; config .get_base_mut() .with_gateway_id(gate_details.identity_key.to_base58_string()); @@ -259,7 +258,7 @@ pub fn execute(matches: &ArgMatches) { .save_to_file(None) .expect("Failed to save the config file"); println!("Saved configuration file to {:?}", config_save_location); - println!("Using gateway: {}", config.get_base().get_gateway_id(),); + println!("Using gateway: {}", config.get_base().get_gateway_id(), ); println!("Client configuration completed.\n\n\n"); show_address(&config); diff --git a/clients/tauri-client/src-tauri/src/main.rs b/clients/tauri-client/src-tauri/src/main.rs index 051bc0bb3c..287aff21a4 100644 --- a/clients/tauri-client/src-tauri/src/main.rs +++ b/clients/tauri-client/src-tauri/src/main.rs @@ -1,6 +1,6 @@ #![cfg_attr( - all(not(debug_assertions), target_os = "windows"), - windows_subsystem = "windows" +all(not(debug_assertions), target_os = "windows"), +windows_subsystem = "windows" )] use std::sync::Arc; @@ -9,206 +9,203 @@ use tokio::sync::RwLock; use url::Url; use coconut_interface::{ - self, hash_to_scalar, Attribute, Credential, Parameters, Signature, Theta, VerificationKey, + self, Attribute, Credential, hash_to_scalar, Parameters, Signature, Theta, VerificationKey, }; use credentials::{obtain_aggregate_signature, obtain_aggregate_verification_key}; struct State { - signatures: Vec, - n_attributes: u32, - params: Parameters, - serial_number: Attribute, - binding_number: Attribute, - voucher_value: Attribute, - voucher_info: Attribute, - aggregated_verification_key: Option, + signatures: Vec, + n_attributes: u32, + params: Parameters, + serial_number: Attribute, + binding_number: Attribute, + voucher_value: Attribute, + voucher_info: Attribute, + aggregated_verification_key: Option, } impl State { - fn init(public_attributes_bytes: Vec>, private_attributes_bytes: Vec>) -> State { - let n_attributes = (public_attributes_bytes.len() + private_attributes_bytes.len()) as u32; - let params = Parameters::new(n_attributes).unwrap(); - let public_attributes = public_attributes_bytes - .iter() - .map(hash_to_scalar) - .collect::>(); - let private_attributes = private_attributes_bytes - .iter() - .map(hash_to_scalar) - .collect::>(); - State { - signatures: Vec::new(), - n_attributes, - params, - serial_number: private_attributes[0], - binding_number: private_attributes[1], - voucher_value: public_attributes[0], - voucher_info: public_attributes[1], - aggregated_verification_key: None, + fn init(public_attributes_bytes: Vec>, private_attributes_bytes: Vec>) -> State { + let n_attributes = (public_attributes_bytes.len() + private_attributes_bytes.len()) as u32; + let params = Parameters::new(n_attributes).unwrap(); + let public_attributes = public_attributes_bytes + .iter() + .map(hash_to_scalar) + .collect::>(); + let private_attributes = private_attributes_bytes + .iter() + .map(hash_to_scalar) + .collect::>(); + State { + signatures: Vec::new(), + n_attributes, + params, + serial_number: private_attributes[0], + binding_number: private_attributes[1], + voucher_value: public_attributes[0], + voucher_info: public_attributes[1], + aggregated_verification_key: None, + } } - } } fn parse_url_validators(raw: &[String]) -> Result, String> { - let mut parsed_urls = Vec::with_capacity(raw.len()); - for url in raw { - let parsed_url: Url = url - .parse() - .map_err(|err| format!("one of validator urls is malformed - {}", err))?; - parsed_urls.push(parsed_url) - } - Ok(parsed_urls) + let mut parsed_urls = Vec::with_capacity(raw.len()); + for url in raw { + let parsed_url: Url = url + .parse() + .map_err(|err| format!("one of validator urls is malformed - {}", err))?; + parsed_urls.push(parsed_url) + } + Ok(parsed_urls) } #[tauri::command] async fn randomise_credential( - idx: usize, - state: tauri::State<'_, Arc>>, + idx: usize, + state: tauri::State<'_, Arc>>, ) -> Result, String> { - let mut state = state.write().await; - let signature = state.signatures.remove(idx); - let (new_signature, _) = signature.randomise(&state.params); - state.signatures.insert(idx, new_signature); - Ok(state.signatures.clone()) + let mut state = state.write().await; + let signature = state.signatures.remove(idx); + let (new_signature, _) = signature.randomise(&state.params); + state.signatures.insert(idx, new_signature); + Ok(state.signatures.clone()) } #[tauri::command] async fn delete_credential( - idx: usize, - state: tauri::State<'_, Arc>>, + idx: usize, + state: tauri::State<'_, Arc>>, ) -> Result, String> { - let mut state = state.write().await; - state.signatures.remove(idx); - Ok(state.signatures.clone()) + let mut state = state.write().await; + state.signatures.remove(idx); + Ok(state.signatures.clone()) } #[tauri::command] async fn list_credentials( - state: tauri::State<'_, Arc>>, + state: tauri::State<'_, Arc>>, ) -> Result, String> { - let state = state.read().await; - Ok(state.signatures.clone()) + let state = state.read().await; + Ok(state.signatures.clone()) } async fn get_aggregated_verification_key( - validator_urls: Vec, - state: tauri::State<'_, Arc>>, + validator_urls: Vec, + state: tauri::State<'_, Arc>>, ) -> Result { - if let Some(verification_key) = &state.read().await.aggregated_verification_key { - return Ok(verification_key.clone()); - } + if let Some(verification_key) = &state.read().await.aggregated_verification_key { + return Ok(verification_key.clone()); + } - let parsed_urls = parse_url_validators(&validator_urls)?; - let key = obtain_aggregate_verification_key(&parsed_urls) - .await - .map_err(|err| format!("failed to obtain aggregate verification key - {:?}", err))?; + let parsed_urls = parse_url_validators(&validator_urls)?; + let key = obtain_aggregate_verification_key(&parsed_urls) + .await + .map_err(|err| format!("failed to obtain aggregate verification key - {:?}", err))?; - state - .write() - .await - .aggregated_verification_key - .replace(key.clone()); + state + .write() + .await + .aggregated_verification_key + .replace(key.clone()); - Ok(key) + Ok(key) } async fn prove_credential( - idx: usize, - validator_urls: Vec, - state: tauri::State<'_, Arc>>, + idx: usize, + validator_urls: Vec, + state: tauri::State<'_, Arc>>, ) -> Result { - let verification_key = get_aggregated_verification_key(validator_urls, state.clone()).await?; - let state = state.read().await; + let verification_key = get_aggregated_verification_key(validator_urls, state.clone()).await?; + let state = state.read().await; - if let Some(signature) = state.signatures.get(idx) { - match coconut_interface::prove_bandwidth_credential( - &state.params, - &verification_key, - signature, - state.serial_number, - state.binding_number, - ) { - Ok(theta) => Ok(theta), - Err(e) => Err(format!("{:?}", e)), + if let Some(signature) = state.signatures.get(idx) { + match coconut_interface::prove_bandwidth_credential( + &state.params, + &verification_key, + signature, + state.serial_number, + state.binding_number, + ) { + Ok(theta) => Ok(theta), + Err(e) => Err(format!("{:?}", e)), + } + } else { + Err("Got invalid Signature idx".to_string()) } - } else { - Err("Got invalid Signature idx".to_string()) - } } #[tauri::command] async fn verify_credential( - idx: usize, - validator_urls: Vec, - state: tauri::State<'_, Arc>>, + idx: usize, + validator_urls: Vec, + state: tauri::State<'_, Arc>>, ) -> Result { - // the API needs to be improved but at least it should compile (in theory) - let verification_key = - get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?; - let theta = prove_credential(idx, validator_urls, state.clone()).await?; + // the API needs to be improved but at least it should compile (in theory) + let verification_key = + get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?; + let theta = prove_credential(idx, validator_urls, state.clone()).await?; - let state = state.read().await; + let state = state.read().await; - let public_attributes_bytes = vec![ - state.voucher_value.to_bytes().to_vec(), - state.voucher_info.to_bytes().to_vec(), - ]; + let public_attributes_bytes = vec![ + state.voucher_value.to_bytes().to_vec(), + state.voucher_info.to_bytes().to_vec(), + ]; - let credential = Credential::new( - state.n_attributes, - theta, - public_attributes_bytes, - state - .signatures - .get(idx) - .ok_or("Got invalid signature idx")?, - ); + let credential = Credential::new( + state.n_attributes, + theta, + public_attributes_bytes, + state + .signatures + .get(idx) + .ok_or("Got invalid signature idx")?, + ); - Ok(credential.verify(&verification_key)) + Ok(credential.verify(&verification_key)) } #[tauri::command] async fn get_credential( - validator_urls: Vec, - state: tauri::State<'_, Arc>>, + validator_urls: Vec, + state: tauri::State<'_, Arc>>, ) -> Result, String> { - let guard = state.read().await; - let parsed_urls = parse_url_validators(&validator_urls)?; - let verification_key = - get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?; - let public_attributes = vec![guard.voucher_value, guard.voucher_info]; - let private_attributes = vec![guard.serial_number, guard.binding_number]; + let guard = state.read().await; + let parsed_urls = parse_url_validators(&validator_urls)?; + let public_attributes = vec![guard.voucher_value, guard.voucher_info]; + let private_attributes = vec![guard.serial_number, guard.binding_number]; - let signature = obtain_aggregate_signature( - &guard.params, - &public_attributes, - &private_attributes, - &parsed_urls, - &verification_key, - ) - .await - .map_err(|err| format!("failed to obtain aggregate signature - {:?}", err))?; + let signature = obtain_aggregate_signature( + &guard.params, + &public_attributes, + &private_attributes, + &parsed_urls, + ) + .await + .map_err(|err| format!("failed to obtain aggregate signature - {:?}", err))?; - let mut state = state.write().await; - state.signatures.push(signature); - Ok(state.signatures.clone()) + let mut state = state.write().await; + state.signatures.push(signature); + Ok(state.signatures.clone()) } fn main() { - let public_attributes = vec![b"public_key".to_vec()]; - let private_attributes = vec![b"private_key".to_vec()]; - tauri::Builder::default() - .manage(Arc::new(RwLock::new(State::init( - public_attributes, - private_attributes, - )))) - .invoke_handler(tauri::generate_handler![ + let public_attributes = vec![b"public_key".to_vec()]; + let private_attributes = vec![b"private_key".to_vec()]; + tauri::Builder::default() + .manage(Arc::new(RwLock::new(State::init( + public_attributes, + private_attributes, + )))) + .invoke_handler(tauri::generate_handler![ get_credential, randomise_credential, delete_credential, list_credentials, verify_credential ]) - .run(tauri::generate_context!()) - .expect("error while running tauri application"); + .run(tauri::generate_context!()) + .expect("error while running tauri application"); } diff --git a/common/credentials/src/bandwidth.rs b/common/credentials/src/bandwidth.rs index cbb80439e2..27c2263a9c 100644 --- a/common/credentials/src/bandwidth.rs +++ b/common/credentials/src/bandwidth.rs @@ -54,7 +54,6 @@ pub async fn obtain_signature( params: &Parameters, attributes: &BandwidthVoucherAttributes, validators: &[Url], - verification_key: &VerificationKey, ) -> Result { let public_attributes = attributes.get_public_attributes(); let private_attributes = attributes.get_private_attributes(); @@ -64,9 +63,8 @@ pub async fn obtain_signature( &public_attributes, &private_attributes, validators, - verification_key, ) - .await + .await } pub fn prepare_for_spending( diff --git a/common/credentials/src/utils.rs b/common/credentials/src/utils.rs index 737b21249e..8d4a69cb26 100644 --- a/common/credentials/src/utils.rs +++ b/common/credentials/src/utils.rs @@ -104,16 +104,17 @@ pub async fn obtain_aggregate_signature( public_attributes: &[Attribute], private_attributes: &[Attribute], validators: &[Url], - verification_key: &VerificationKey, ) -> Result { if validators.is_empty() { return Err(Error::NoValidatorsAvailable); } let mut shares = Vec::with_capacity(validators.len()); + let mut validators_partial_vks: Vec = Vec::with_capacity(validators.len()); let mut client = validator_client::ApiClient::new(validators[0].clone()); let validator_partial_vk = client.get_coconut_verification_key().await?; + validators_partial_vks.push(validator_partial_vk.key.clone()); let first = obtain_partial_credential( params, @@ -128,6 +129,7 @@ pub async fn obtain_aggregate_signature( for (id, validator_url) in validators.iter().enumerate().skip(1) { client.change_validator_api(validator_url.clone()); let validator_partial_vk = client.get_coconut_verification_key().await?; + validators_partial_vks.push(validator_partial_vk.key.clone()); let signature = obtain_partial_credential( params, public_attributes, @@ -144,9 +146,14 @@ pub async fn obtain_aggregate_signature( attributes.extend_from_slice(private_attributes); attributes.extend_from_slice(public_attributes); + let mut indices: Vec = Vec::with_capacity(validators_partial_vks.len()); + for i in 1..validators_partial_vks.len() { + indices.push(i as u64); + } + let verification_key = aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref())).unwrap(); Ok(aggregate_signature_shares( params, - verification_key, + &verification_key, &attributes, &shares, )?) diff --git a/validator-api/src/network_monitor/mod.rs b/validator-api/src/network_monitor/mod.rs index d51dfc21ba..9cd9734c14 100644 --- a/validator-api/src/network_monitor/mod.rs +++ b/validator-api/src/network_monitor/mod.rs @@ -1,8 +1,26 @@ // Copyright 2021 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 +use std::sync::Arc; + +use futures::channel::mpsc; +use log::info; + +#[cfg(feature = "coconut")] +use coconut_interface::{Credential, hash_to_scalar, Parameters}; +#[cfg(feature = "coconut")] +use credentials::bandwidth::{ + BANDWIDTH_VALUE, BandwidthVoucherAttributes, prepare_for_spending, TOTAL_ATTRIBUTES, +}; +#[cfg(feature = "coconut")] +use credentials::obtain_aggregate_verification_key; +use crypto::asymmetric::{encryption, identity}; +use nymsphinx::addressing::clients::Recipient; +use topology::NymTopology; + use crate::cache::ValidatorCache; use crate::config::Config; +use crate::network_monitor::monitor::Monitor; use crate::network_monitor::monitor::preparer::PacketPreparer; use crate::network_monitor::monitor::processor::{ ReceivedProcessor, ReceivedProcessorReceiver, ReceivedProcessorSender, @@ -12,26 +30,9 @@ use crate::network_monitor::monitor::receiver::{ }; use crate::network_monitor::monitor::sender::PacketSender; use crate::network_monitor::monitor::summary_producer::SummaryProducer; -use crate::network_monitor::monitor::Monitor; use crate::network_monitor::tested_network::TestedNetwork; use crate::storage::NodeStatusStorage; -#[cfg(feature = "coconut")] -use coconut_interface::{hash_to_scalar, Credential, Parameters}; -#[cfg(feature = "coconut")] -use credentials::bandwidth::{ - prepare_for_spending, BandwidthVoucherAttributes, BANDWIDTH_VALUE, TOTAL_ATTRIBUTES, -}; -#[cfg(feature = "coconut")] -use credentials::obtain_aggregate_verification_key; - -use crypto::asymmetric::{encryption, identity}; -use futures::channel::mpsc; -use log::info; -use nymsphinx::addressing::clients::Recipient; -use std::sync::Arc; -use topology::NymTopology; - pub(crate) mod chunker; pub(crate) mod gateways_reader; pub(crate) mod monitor; @@ -98,7 +99,7 @@ impl<'a> NetworkMonitorBuilder<'a> { ); #[cfg(feature = "coconut")] - let bandwidth_credential = + let bandwidth_credential = TEMPORARY_obtain_bandwidth_credential(self.config, identity_keypair.public_key()).await; let packet_sender = new_packet_sender( @@ -107,7 +108,7 @@ impl<'a> NetworkMonitorBuilder<'a> { Arc::clone(&identity_keypair), self.config.get_gateway_sending_rate(), #[cfg(feature = "coconut")] - bandwidth_credential, + bandwidth_credential, ); let received_processor = new_received_processor( @@ -197,10 +198,9 @@ async fn TEMPORARY_obtain_bandwidth_credential( ¶ms, &bandwidth_credential_attributes, &validators, - &verification_key, ) - .await - .expect("failed to obtain bandwidth credential!"); + .await + .expect("failed to obtain bandwidth credential!"); prepare_for_spending( &identity.to_bytes(), @@ -208,7 +208,7 @@ async fn TEMPORARY_obtain_bandwidth_credential( &bandwidth_credential_attributes, &verification_key, ) - .expect("failed to prepare bandwidth credential for spending!") + .expect("failed to prepare bandwidth credential for spending!") } fn new_packet_sender( @@ -226,7 +226,7 @@ fn new_packet_sender( config.get_max_concurrent_gateway_clients(), max_sending_rate, #[cfg(feature = "coconut")] - bandwidth_credential, + bandwidth_credential, ) }