Skip to content

Commit 5ceeeb5

Browse files
curiecryptcuriecrypt
committed
aggregate signature basic verifier removed
1 parent 97c27bd commit 5ceeeb5

File tree

10 files changed

+515
-321
lines changed

10 files changed

+515
-321
lines changed

‎mithril-stm/Cargo.toml‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ rug-backend = ["rug/default"]
1919
num-integer-backend = ["dep:num-bigint", "dep:num-rational", "dep:num-traits"]
2020
benchmark-internals = [] # For benchmarking multi_sig
2121
future_proof_system = [] # For activating future proof systems
22+
basic_verifier = [] # For activating basic verifier
2223
future_snark = [
2324
"dep:ff",
2425
"dep:group",
@@ -70,6 +71,18 @@ name = "multi_sig"
7071
harness = false
7172
required-features = ["benchmark-internals"]
7273

74+
[[bench]]
75+
name = "basic_verifier_size"
76+
harness = false
77+
required-features = ["basic_verifier"]
78+
path = "benches/basic_verifier/size.rs"
79+
80+
[[bench]]
81+
name = "basic_verifier_protocol"
82+
harness = false
83+
required-features = ["basic_verifier"]
84+
path = "benches/basic_verifier/protocol.rs"
85+
7386
[[bench]]
7487
name = "schnorr_sig"
7588
harness = false

‎mithril-stm/benches/basic_verifier/protocol.rs‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
use std::fmt::Debug;
2+
3+
use blake2::digest::{Digest, FixedOutput};
4+
use blake2::{Blake2b, digest::consts::U32};
5+
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
6+
use rand_chacha::ChaCha20Rng;
7+
use rand_core::{RngCore, SeedableRng};
8+
use rayon::prelude::*;
9+
10+
use mithril_stm::{BasicVerifier, Initializer, Parameters, Signer, Stake, VerificationKey};
11+
12+
fn basic_verifier_benches<H>(c: &mut Criterion, nr_parties: usize, params: Parameters)
13+
where
14+
H: Clone + Debug + Digest + Send + Sync + FixedOutput + Default,
15+
{
16+
let mut group = c.benchmark_group("Core verifier");
17+
let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
18+
let mut msg = [0u8; 16];
19+
rng.fill_bytes(&mut msg);
20+
21+
let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nr_parties);
22+
let mut initializers: Vec<Initializer> = Vec::with_capacity(nr_parties);
23+
24+
let param_string = format!(
25+
"k: {}, m: {}, nr_parties: {}",
26+
params.k, params.m, nr_parties
27+
);
28+
29+
let stakes = (0..nr_parties)
30+
.map(|_| 1 + (rng.next_u64() % 9999))
31+
.collect::<Vec<_>>();
32+
33+
for stake in stakes {
34+
let initializer = Initializer::new(params, stake, &mut rng);
35+
initializers.push(initializer.clone());
36+
public_signers.push((
37+
initializer.get_verification_key_proof_of_possession().vk,
38+
initializer.stake,
39+
));
40+
}
41+
42+
let core_verifier = BasicVerifier::new(&public_signers);
43+
44+
let signers: Vec<Signer<H>> = initializers
45+
.into_iter()
46+
.filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
47+
.collect();
48+
49+
group.bench_function(BenchmarkId::new("Play all lotteries", &param_string), |b| {
50+
b.iter(|| {
51+
signers[0].basic_sign(&msg, core_verifier.total_stake);
52+
})
53+
});
54+
55+
let signatures = signers
56+
.par_iter()
57+
.filter_map(|p| p.basic_sign(&msg, core_verifier.total_stake))
58+
.collect::<Vec<_>>();
59+
60+
group.bench_function(BenchmarkId::new("Core verification", &param_string), |b| {
61+
b.iter(|| core_verifier.verify(&signatures, &params, &msg))
62+
});
63+
}
64+
65+
fn core_verifier_benches_blake_300(c: &mut Criterion) {
66+
basic_verifier_benches::<Blake2b<U32>>(
67+
c,
68+
300,
69+
Parameters {
70+
m: 150,
71+
k: 25,
72+
phi_f: 0.2,
73+
},
74+
);
75+
}
76+
77+
fn core_verifier_benches_blake_2000(c: &mut Criterion) {
78+
basic_verifier_benches::<Blake2b<U32>>(
79+
c,
80+
2000,
81+
Parameters {
82+
m: 1523,
83+
k: 250,
84+
phi_f: 0.2,
85+
},
86+
);
87+
}
88+
89+
criterion_group!(name = benches;
90+
config = Criterion::default().nresamples(1000);
91+
targets =
92+
core_verifier_benches_blake_300,
93+
core_verifier_benches_blake_2000,
94+
);
95+
criterion_main!(benches);

‎mithril-stm/benches/basic_verifier/size.rs‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
use blake2::digest::FixedOutput;
2+
use blake2::{Blake2b, Digest, digest::consts::U64};
3+
use rand_chacha::ChaCha20Rng;
4+
use rand_core::{RngCore, SeedableRng};
5+
6+
use mithril_stm::{
7+
BasicVerifier, Initializer, Parameters, Signer, SingleSignature,
8+
SingleSignatureWithRegisteredParty, Stake, VerificationKey,
9+
};
10+
11+
fn core_size<H>(k: u64, m: u64, nparties: usize)
12+
where
13+
H: Digest + Clone + Sync + Send + Default + FixedOutput,
14+
{
15+
let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
16+
let mut msg = [0u8; 16];
17+
rng.fill_bytes(&mut msg);
18+
19+
let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nparties);
20+
let mut initializers: Vec<Initializer> = Vec::with_capacity(nparties);
21+
22+
let parties = (0..nparties).map(|_| 1 + (rng.next_u64() % 9999)).collect::<Vec<_>>();
23+
24+
let params = Parameters { k, m, phi_f: 0.2 };
25+
26+
for stake in parties {
27+
let initializer = Initializer::new(params, stake, &mut rng);
28+
initializers.push(initializer.clone());
29+
public_signers.push((
30+
initializer.get_verification_key_proof_of_possession().vk,
31+
initializer.stake,
32+
));
33+
}
34+
35+
let core_verifier = BasicVerifier::new(&public_signers);
36+
37+
let signers: Vec<Signer<H>> = initializers
38+
.into_iter()
39+
.filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
40+
.collect();
41+
42+
let mut signatures: Vec<SingleSignature> = Vec::with_capacity(nparties);
43+
for s in signers {
44+
if let Some(sig) = s.basic_sign(&msg, core_verifier.total_stake) {
45+
signatures.push(sig);
46+
}
47+
}
48+
49+
let sig_reg_list = signatures
50+
.iter()
51+
.map(|sig| SingleSignatureWithRegisteredParty {
52+
sig: sig.clone(),
53+
reg_party: core_verifier.eligible_parties[sig.signer_index as usize],
54+
})
55+
.collect::<Vec<SingleSignatureWithRegisteredParty>>();
56+
57+
let dedup_sigs = BasicVerifier::select_valid_signatures_for_k_indices(
58+
&core_verifier.total_stake,
59+
&params,
60+
&msg,
61+
&sig_reg_list,
62+
)
63+
.unwrap();
64+
65+
let mut size_sigs: usize = 0;
66+
for sig in dedup_sigs {
67+
size_sigs += sig.to_bytes().len();
68+
}
69+
70+
println!("k = {k} | m = {m} | nr parties = {nparties}; {size_sigs} bytes",);
71+
}
72+
73+
fn main() {
74+
println!("\n+-------------------------+");
75+
println!("| Size of core signatures |");
76+
println!("+-------------------------+");
77+
println!("+-------------------------+");
78+
let params: [(u64, u64, usize); 2] = [(445, 2728, 3000), (554, 3597, 3000)];
79+
for (k, m, nparties) in params {
80+
core_size::<Blake2b<U64>>(k, m, nparties);
81+
}
82+
println!("+-------------------------+");
83+
}

‎mithril-stm/benches/size_benches.rs‎

Lines changed: 2 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,8 @@ use rayon::iter::ParallelIterator;
99
use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator};
1010

1111
use mithril_stm::{
12-
AggregateSignatureType, BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer,
13-
SingleSignature, SingleSignatureWithRegisteredParty, Stake, VerificationKey,
12+
AggregateSignatureType, Clerk, Initializer, KeyRegistration, Parameters, Signer,
13+
SingleSignature,
1414
};
1515

1616
fn size<H>(k: u64, m: u64, nparties: usize, hash_name: &str)
@@ -66,68 +66,6 @@ where
6666
);
6767
}
6868

69-
fn core_size<H>(k: u64, m: u64, nparties: usize)
70-
where
71-
H: Digest + Clone + Sync + Send + Default + FixedOutput,
72-
{
73-
let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
74-
let mut msg = [0u8; 16];
75-
rng.fill_bytes(&mut msg);
76-
77-
let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nparties);
78-
let mut initializers: Vec<Initializer> = Vec::with_capacity(nparties);
79-
80-
let parties = (0..nparties).map(|_| 1 + (rng.next_u64() % 9999)).collect::<Vec<_>>();
81-
82-
let params = Parameters { k, m, phi_f: 0.2 };
83-
84-
for stake in parties {
85-
let initializer = Initializer::new(params, stake, &mut rng);
86-
initializers.push(initializer.clone());
87-
public_signers.push((
88-
initializer.get_verification_key_proof_of_possession().vk,
89-
initializer.stake,
90-
));
91-
}
92-
93-
let core_verifier = BasicVerifier::new(&public_signers);
94-
95-
let signers: Vec<Signer<H>> = initializers
96-
.into_iter()
97-
.filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
98-
.collect();
99-
100-
let mut signatures: Vec<SingleSignature> = Vec::with_capacity(nparties);
101-
for s in signers {
102-
if let Some(sig) = s.basic_sign(&msg, core_verifier.total_stake) {
103-
signatures.push(sig);
104-
}
105-
}
106-
107-
let sig_reg_list = signatures
108-
.iter()
109-
.map(|sig| SingleSignatureWithRegisteredParty {
110-
sig: sig.clone(),
111-
reg_party: core_verifier.eligible_parties[sig.signer_index as usize],
112-
})
113-
.collect::<Vec<SingleSignatureWithRegisteredParty>>();
114-
115-
let dedup_sigs = BasicVerifier::select_valid_signatures_for_k_indices(
116-
&core_verifier.total_stake,
117-
&params,
118-
&msg,
119-
&sig_reg_list,
120-
)
121-
.unwrap();
122-
123-
let mut size_sigs: usize = 0;
124-
for sig in dedup_sigs {
125-
size_sigs += sig.to_bytes().len();
126-
}
127-
128-
println!("k = {k} | m = {m} | nr parties = {nparties}; {size_sigs} bytes",);
129-
}
130-
13169
fn main() {
13270
println!("+-------------------+");
13371
println!("| Size of proofs |");
@@ -140,14 +78,5 @@ fn main() {
14078
size::<Blake2b<U64>>(k, m, nparties, "Blake2b 512");
14179
size::<Blake2b<U32>>(k, m, nparties, "Blake2b 256");
14280
}
143-
144-
println!("\n+-------------------------+");
145-
println!("| Size of core signatures |");
146-
println!("+-------------------------+");
147-
println!("+-------------------------+");
148-
149-
for (k, m, nparties) in params {
150-
core_size::<Blake2b<U64>>(k, m, nparties);
151-
}
15281
println!("+-------------------------+");
15382
}

0 commit comments

Comments
 (0)