|
1 | | -use commonware_cryptography::{ |
2 | | - bls12381::{ |
3 | | - dkg::{deal, Dealer, Info, Logs, Player}, |
4 | | - primitives::variant::MinSig, |
5 | | - }, |
6 | | - ed25519::{Batch, PrivateKey, PublicKey}, |
7 | | - Signer as _, |
8 | | -}; |
9 | | -use commonware_math::algebra::Random; |
10 | | -use commonware_parallel::{Rayon, Sequential}; |
11 | | -use commonware_utils::{ordered::Set, Faults, N3f1, NZUsize, TryCollect}; |
12 | | -use criterion::{criterion_group, BatchSize, Criterion}; |
13 | | -use rand::{rngs::StdRng, SeedableRng}; |
14 | | -use rand_core::CryptoRngCore; |
15 | | -use std::{collections::BTreeMap, hint::black_box}; |
16 | | - |
17 | | -type V = MinSig; |
18 | | - |
19 | | -struct Bench { |
20 | | - info: Info<V, PublicKey>, |
21 | | - me: PrivateKey, |
22 | | - logs: Logs<V, PublicKey, N3f1>, |
23 | | -} |
24 | | - |
25 | | -impl Bench { |
26 | | - fn new(mut rng: impl CryptoRngCore, reshare: bool, n: u32) -> Self { |
27 | | - let private_keys = (0..n) |
28 | | - .map(|_| PrivateKey::random(&mut rng)) |
29 | | - .collect::<Vec<_>>(); |
30 | | - let me = private_keys.first().unwrap().clone(); |
31 | | - let me_pk = me.public_key(); |
32 | | - let dealers = private_keys |
33 | | - .iter() |
34 | | - .map(|sk| sk.public_key()) |
35 | | - .try_collect::<Set<_>>() |
36 | | - .unwrap(); |
37 | | - |
38 | | - let (output, shares) = if reshare { |
39 | | - let (o, s) = |
40 | | - deal::<V, PublicKey, N3f1>(&mut rng, Default::default(), dealers.clone()).unwrap(); |
41 | | - (Some(o), Some(s)) |
42 | | - } else { |
43 | | - (None, None) |
44 | | - }; |
45 | | - let players = dealers.clone(); |
46 | | - let info = Info::new::<N3f1>( |
47 | | - b"_COMMONWARE_CRYPTOGRAPHY_BLS12381_DKG_BENCH", |
48 | | - 0, |
49 | | - output, |
50 | | - Default::default(), |
51 | | - dealers, |
52 | | - players, |
53 | | - ) |
54 | | - .unwrap(); |
55 | | - |
56 | | - // Create player state for every participant |
57 | | - let mut player_states = private_keys |
58 | | - .iter() |
59 | | - .filter_map(|sk| { |
60 | | - let pk = sk.public_key(); |
61 | | - if pk == me_pk { |
62 | | - return None; |
63 | | - } |
64 | | - Some(( |
65 | | - pk, |
66 | | - Player::<MinSig, PrivateKey>::new(info.clone(), sk.clone()).unwrap(), |
67 | | - )) |
68 | | - }) |
69 | | - .collect::<BTreeMap<_, _>>(); |
70 | | - |
71 | | - let mut logs = Logs::<V, PublicKey, N3f1>::new(info.clone()); |
72 | | - for sk in private_keys { |
73 | | - let pk = sk.public_key(); |
74 | | - let (mut dealer, pub_msg, priv_msgs) = Dealer::start::<N3f1>( |
75 | | - &mut rng, |
76 | | - info.clone(), |
77 | | - sk, |
78 | | - shares |
79 | | - .as_ref() |
80 | | - .and_then(|shares| shares.get_value(&pk).cloned()), |
81 | | - ) |
82 | | - .unwrap(); |
83 | | - for (target_pk, priv_msg) in priv_msgs { |
84 | | - // The only missing player should be ourselves. |
85 | | - if let Some(player) = player_states.get_mut(&target_pk) { |
86 | | - if let Some(ack) = |
87 | | - player.dealer_message::<N3f1>(pk.clone(), pub_msg.clone(), priv_msg) |
88 | | - { |
89 | | - dealer.receive_player_ack(target_pk.clone(), ack).unwrap(); |
90 | | - } |
91 | | - } |
92 | | - } |
93 | | - logs.record(pk, dealer.finalize::<N3f1>().check(&info).unwrap().1); |
94 | | - } |
95 | | - |
96 | | - Self { info, me, logs } |
97 | | - } |
98 | | - |
99 | | - fn pre_finalize(&self) -> (Player<V, PrivateKey>, Logs<V, PublicKey, N3f1>) { |
100 | | - ( |
101 | | - Player::<MinSig, PrivateKey>::new(self.info.clone(), self.me.clone()).unwrap(), |
102 | | - self.logs.clone(), |
103 | | - ) |
104 | | - } |
105 | | -} |
106 | | - |
107 | | -// Configure contributors based on context |
108 | | -cfg_if::cfg_if! { |
109 | | - if #[cfg(full_bench)] { |
110 | | - const CONTRIBUTORS: &[u32] = &[5, 10, 20, 50, 100, 250, 500]; |
111 | | - const CONCURRENCY: &[usize] = &[1, 4, 8]; |
112 | | - } else { |
113 | | - const CONTRIBUTORS: &[u32] = &[5, 10, 20, 50]; |
114 | | - const CONCURRENCY: &[usize] = &[1]; |
115 | | - } |
116 | | -} |
117 | | - |
118 | | -fn bench_dkg(c: &mut Criterion, reshare: bool) { |
119 | | - let suffix = if reshare { |
120 | | - "_reshare_recovery" |
121 | | - } else { |
122 | | - "_recovery" |
123 | | - }; |
124 | | - let mut rng = StdRng::seed_from_u64(0); |
125 | | - for &n in CONTRIBUTORS { |
126 | | - let t = N3f1::quorum(n); |
127 | | - let bench = Bench::new(&mut rng, reshare, n); |
128 | | - for &concurrency in CONCURRENCY { |
129 | | - let strategy = Rayon::new(NZUsize!(concurrency)).unwrap(); |
130 | | - c.bench_function( |
131 | | - &format!( |
132 | | - "{}{}/n={} t={} conc={}", |
133 | | - module_path!(), |
134 | | - suffix, |
135 | | - n, |
136 | | - t, |
137 | | - concurrency, |
138 | | - ), |
139 | | - |b| { |
140 | | - b.iter_batched( |
141 | | - || bench.pre_finalize(), |
142 | | - |(player, logs)| { |
143 | | - let mut finalize_rng = StdRng::seed_from_u64(0); |
144 | | - if concurrency > 1 { |
145 | | - black_box( |
146 | | - player |
147 | | - .finalize::<N3f1, Batch>(&mut finalize_rng, logs, &strategy) |
148 | | - .unwrap(), |
149 | | - ); |
150 | | - } else { |
151 | | - black_box( |
152 | | - player |
153 | | - .finalize::<N3f1, Batch>( |
154 | | - &mut finalize_rng, |
155 | | - logs, |
156 | | - &Sequential, |
157 | | - ) |
158 | | - .unwrap(), |
159 | | - ); |
160 | | - } |
161 | | - }, |
162 | | - BatchSize::SmallInput, |
163 | | - ); |
164 | | - }, |
165 | | - ); |
166 | | - } |
167 | | - } |
168 | | -} |
169 | | - |
170 | | -fn bench_dkg_recovery(c: &mut Criterion) { |
171 | | - bench_dkg(c, false); |
172 | | -} |
173 | | - |
174 | | -fn bench_dkg_reshare_recovery(c: &mut Criterion) { |
175 | | - bench_dkg(c, true); |
176 | | -} |
177 | | - |
178 | | -criterion_group! { |
179 | | - name = benches; |
180 | | - config = Criterion::default().sample_size(10); |
181 | | - targets = bench_dkg_recovery, bench_dkg_reshare_recovery |
182 | | -} |
| 1 | +pub mod feldman_desmedt; |
| 2 | +pub mod golden; |
0 commit comments