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

Run cargo fmt

Browse Source
This commit is contained in:
aniampio
2021-10-25 09:59:05 +02:00
parent d1563c079e
commit 39af6abec7
9 changed files with 226 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files
clients/native/src/commands/init.rs
-1
View File
@@ -64,7 +64,6 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
)
}
// this behaviour should definitely be changed, we shouldn't
// need to get bandwidth credential for registration
async fn prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
clients/socks5/src/commands/init.rs
-1
View File
@@ -7,7 +7,6 @@ use clap::{App, Arg, ArgMatches};
use client_core::client::key_manager::KeyManager;
use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
use config::NymConfig;
#[cfg(feature = "coconut")]
clients/tauri-client/src-tauri/src/main.rs
+140 -137
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,203 +9,206 @@ use tokio::sync::RwLock;
use url::Url;
use coconut_interface::{
self, Attribute, Credential, hash_to_scalar, Parameters, Signature, Theta, VerificationKey,
self, hash_to_scalar, Attribute, Credential, 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)),
}
} else {
Err("Got invalid Signature idx".to_string())
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())
}
}
#[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 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 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,
&verification_key,
)
.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
+6 -4
View File
@@ -9,8 +9,7 @@
use url::Url;
use coconut_interface::{
Credential, Parameters, PrivateAttribute, PublicAttribute,
Signature, VerificationKey,
Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
};
use crate::error::Error;
@@ -66,7 +65,7 @@ pub async fn obtain_signature(
validators,
verification_key,
)
.await
.await
}
pub fn prepare_for_spending(
@@ -75,7 +74,10 @@ pub fn prepare_for_spending(
attributes: &BandwidthVoucherAttributes,
verification_key: &VerificationKey,
) -> Result<Credential, Error> {
let public_attributes = vec![raw_identity.to_vec(), BANDWIDTH_VALUE.to_be_bytes().to_vec()];
let public_attributes = vec![
raw_identity.to_vec(),
BANDWIDTH_VALUE.to_be_bytes().to_vec(),
];
let params = Parameters::new(TOTAL_ATTRIBUTES)?;
common/credentials/src/utils.rs
+4 -4
View File
@@ -4,8 +4,8 @@
use url::Url;
use coconut_interface::{
aggregate_signature_shares, aggregate_verification_keys, Attribute,
BlindSignRequestBody, Credential, Parameters, prepare_blind_sign, prove_bandwidth_credential, Signature,
aggregate_signature_shares, aggregate_verification_keys, prepare_blind_sign,
prove_bandwidth_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
SignatureShare, VerificationKey,
};
@@ -121,7 +121,7 @@ pub async fn obtain_aggregate_signature(
&client,
&validator_partial_vk.key,
)
.await?;
.await?;
shares.push(SignatureShare::new(first, 0));
for (id, validator_url) in validators.iter().enumerate().skip(1) {
@@ -134,7 +134,7 @@ pub async fn obtain_aggregate_signature(
&client,
&validator_partial_vk.key,
)
.await?;
.await?;
let share = SignatureShare::new(signature, id as u64);
shares.push(share)
}
common/nymcoconut/src/error.rs
+3 -3
View File
@@ -38,9 +38,9 @@ pub enum CoconutError {
#[error("Deserialization error: {0}")]
Deserialization(String),
#[error(
"Deserailization error, expected at least {} bytes, got {}",
min,
actual
"Deserailization error, expected at least {} bytes, got {}",
min,
actual
)]
DeserializationMinLength { min: usize, actual: usize },
#[error("Tried to deserialize {object} with bytes of invalid length. Expected {actual} < {} or {modulus_target} % {modulus} == 0")]
common/nymcoconut/src/lib.rs
+7 -7
View File
@@ -22,20 +22,20 @@ pub use elgamal::PublicKey;
pub use error::CoconutError;
pub use scheme::aggregation::aggregate_signature_shares;
pub use scheme::aggregation::aggregate_verification_keys;
pub use scheme::BlindedSignature;
pub use scheme::issuance::blind_sign;
pub use scheme::issuance::BlindSignRequest;
pub use scheme::issuance::prepare_blind_sign;
pub use scheme::keygen::KeyPair;
pub use scheme::issuance::BlindSignRequest;
pub use scheme::keygen::ttp_keygen;
pub use scheme::keygen::KeyPair;
pub use scheme::keygen::VerificationKey;
pub use scheme::setup::Parameters;
pub use scheme::setup::setup;
pub use scheme::setup::Parameters;
pub use scheme::verification::prove_bandwidth_credential;
pub use scheme::verification::verify_credential;
pub use scheme::verification::Theta;
pub use scheme::BlindedSignature;
pub use scheme::Signature;
pub use scheme::SignatureShare;
pub use scheme::verification::prove_bandwidth_credential;
pub use scheme::verification::Theta;
pub use scheme::verification::verify_credential;
pub use traits::Base58;
pub use utils::hash_to_scalar;
common/nymcoconut/src/scheme/mod.rs
+63 -63
View File
@@ -22,13 +22,13 @@ use group::Curve;
pub use keygen::{SecretKey, VerificationKey};
use crate::{Attribute, elgamal};
use crate::elgamal::Ciphertext;
use crate::error::{CoconutError, Result};
use crate::scheme::setup::Parameters;
use crate::scheme::verification::check_bilinear_pairing;
use crate::traits::{Base58, Bytable};
use crate::utils::try_deserialize_g1_projective;
use crate::{elgamal, Attribute};
pub mod aggregation;
pub mod issuance;
@@ -265,16 +265,16 @@ mod tests {
&lambda,
&[],
)
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair1.verification_key(),
&private_attributes,
&[],
&lambda.commitment_hash,
)
.unwrap();
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair1.verification_key(),
&private_attributes,
&[],
&lambda.commitment_hash,
)
.unwrap();
let sig2 = blind_sign(
&mut params,
@@ -283,16 +283,16 @@ mod tests {
&lambda,
&[],
)
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair2.verification_key(),
&private_attributes,
&[],
&lambda.commitment_hash,
)
.unwrap();
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair2.verification_key(),
&private_attributes,
&[],
&lambda.commitment_hash,
)
.unwrap();
let theta1 = prove_bandwidth_credential(
&mut params,
@@ -301,7 +301,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
let theta2 = prove_bandwidth_credential(
&mut params,
@@ -310,7 +310,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
assert!(verify_credential(
&params,
@@ -384,7 +384,7 @@ mod tests {
&private_attributes,
&public_attributes,
)
.unwrap();
.unwrap();
let sig1 = blind_sign(
&mut params,
@@ -393,16 +393,16 @@ mod tests {
&lambda,
&public_attributes,
)
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair1.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap();
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair1.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap();
let sig2 = blind_sign(
&mut params,
@@ -411,16 +411,16 @@ mod tests {
&lambda,
&public_attributes,
)
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair2.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap();
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair2.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap();
let theta1 = prove_bandwidth_credential(
&mut params,
@@ -429,7 +429,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
let theta2 = prove_bandwidth_credential(
&mut params,
@@ -438,7 +438,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
assert!(verify_credential(
&params,
@@ -479,7 +479,7 @@ mod tests {
&private_attributes,
&public_attributes,
)
.unwrap();
.unwrap();
let sigs = keypairs
.iter()
@@ -491,16 +491,16 @@ mod tests {
&lambda,
&public_attributes,
)
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap()
.unwrap()
.unblind(
&params,
elgamal_keypair.private_key(),
&keypair.verification_key(),
&private_attributes,
&public_attributes,
&lambda.commitment_hash,
)
.unwrap()
})
.collect::<Vec<_>>();
@@ -525,7 +525,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
assert!(verify_credential(
&params,
@@ -547,7 +547,7 @@ mod tests {
serial_number,
binding_number,
)
.unwrap();
.unwrap();
assert!(verify_credential(
&params,
@@ -570,7 +570,7 @@ mod tests {
signature.0.to_affine().to_compressed(),
signature.1.to_affine().to_compressed(),
]
.concat();
.concat();
assert_eq!(expected_bytes, bytes);
assert_eq!(signature, Signature::try_from(&bytes[..]).unwrap())
}
@@ -590,10 +590,10 @@ mod tests {
// also make sure it is equivalent to the internal g1 compressed bytes concatenated
let expected_bytes = [
blinded_sig.0.to_affine().to_compressed(),
blinded_sig.1.0.to_affine().to_compressed(),
blinded_sig.1.1.to_affine().to_compressed(),
blinded_sig.1 .0.to_affine().to_compressed(),
blinded_sig.1 .1.to_affine().to_compressed(),
]
.concat();
.concat();
assert_eq!(expected_bytes, bytes);
assert_eq!(blinded_sig, BlindedSignature::try_from(&bytes[..]).unwrap())
}
common/nymcoconut/src/tests/e2e.rs
+3 -3
View File
@@ -1,7 +1,7 @@
use crate::{
aggregate_signature_shares, aggregate_verification_keys, blind_sign, CoconutError,
elgamal_keygen, prepare_blind_sign, prove_bandwidth_credential, setup, Signature, SignatureShare,
ttp_keygen, VerificationKey, verify_credential,
aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
CoconutError, Signature, SignatureShare, VerificationKey,
};
#[test]