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

Change passing verification key as inpput to functions to actually computing it when it is needed

Browse Source
This commit is contained in:
aniampio
2021-11-04 12:30:43 +00:00
parent f3a192a023
commit b00fa15b55
8 changed files with 231 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files
clients/native/src/client/mod.rs
+19 -20
View File
@@ -1,8 +1,10 @@
// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
// 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 {
&params,
&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");
clients/native/src/commands/init.rs
+9 -10
View File
@@ -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])
&params,
&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);
clients/socks5/src/client/mod.rs
+22 -23
View File
@@ -1,11 +1,10 @@
// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
// 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 {
&params,
&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");
clients/socks5/src/commands/init.rs
+10 -11
View File
@@ -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(
&params,
&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);
clients/tauri-client/src-tauri/src/main.rs
+137 -140
View File
@@ -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<Signature>,
n_attributes: u32,
params: Parameters,
serial_number: Attribute,
binding_number: Attribute,
voucher_value: Attribute,
voucher_info: Attribute,
aggregated_verification_key: Option<VerificationKey>,
signatures: Vec<Signature>,
n_attributes: u32,
params: Parameters,
serial_number: Attribute,
binding_number: Attribute,
voucher_value: Attribute,
voucher_info: Attribute,
aggregated_verification_key: Option<VerificationKey>,
}
impl State {
fn init(public_attributes_bytes: Vec<Vec<u8>>, private_attributes_bytes: Vec<Vec<u8>>) -> 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::<Vec<Attribute>>();
let private_attributes = private_attributes_bytes
.iter()
.map(hash_to_scalar)
.collect::<Vec<Attribute>>();
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<Vec<u8>>, private_attributes_bytes: Vec<Vec<u8>>) -> 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::<Vec<Attribute>>();
let private_attributes = private_attributes_bytes
.iter()
.map(hash_to_scalar)
.collect::<Vec<Attribute>>();
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<Vec<Url>, 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<RwLock<State>>>,
idx: usize,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Vec<Signature>, 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<RwLock<State>>>,
idx: usize,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Vec<Signature>, 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<RwLock<State>>>,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Vec<Signature>, 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<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
validator_urls: Vec<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<VerificationKey, String> {
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<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
idx: usize,
validator_urls: Vec<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Theta, String> {
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<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
idx: usize,
validator_urls: Vec<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<bool, String> {
// 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<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
validator_urls: Vec<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Vec<Signature>, 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");
}
common/credentials/src/bandwidth.rs
+1 -3
View File
@@ -54,7 +54,6 @@ pub async fn obtain_signature(
params: &Parameters,
attributes: &BandwidthVoucherAttributes,
validators: &[Url],
verification_key: &VerificationKey,
) -> Result<Signature, Error> {
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(
common/credentials/src/utils.rs
+9 -2
View File
@@ -104,16 +104,17 @@ pub async fn obtain_aggregate_signature(
public_attributes: &[Attribute],
private_attributes: &[Attribute],
validators: &[Url],
verification_key: &VerificationKey,
) -> Result<Signature, Error> {
if validators.is_empty() {
return Err(Error::NoValidatorsAvailable);
}
let mut shares = Vec::with_capacity(validators.len());
let mut validators_partial_vks: Vec<VerificationKey> = 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<u64> = 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,
)?)
validator-api/src/network_monitor/mod.rs
+24 -24
View File
@@ -1,8 +1,26 @@
// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
// 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(
&params,
&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,
)
}