Skip to content

Commit 5ae3eeb

Browse files
sinui0sinui0
authored
fix: couple bugs (#370)
* fix(garble): mac commitment bug * Revert "feat(garble-core): randomize gate id and cipher key (#348)" This reverts commit b8b8884. * fix(zk): zero out PRG position
1 parent d9baf0f commit 5ae3eeb

File tree

17 files changed

+192
-733
lines changed

17 files changed

+192
-733
lines changed

‎crates/garble-core/benches/evaluate.rs‎

Lines changed: 9 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,6 @@ fn bench_evaluate(c: &mut Criterion) {
2020

2121
let mut rng = StdRng::seed_from_u64(0);
2222
let delta = Delta::random(&mut rng);
23-
let seed: [u8; 16] = rng.random();
2423

2524
// Prepare inputs
2625
let inputs: Vec<Key> = (0..256).map(|_| rng.random()).collect();
@@ -38,12 +37,10 @@ fn bench_evaluate(c: &mut Criterion) {
3837
let actual_gates = iterations as u64 * gates_per_circuit;
3938

4039
// Pre-generate garbled circuits (single gates)
41-
let mut gb = Garbler::new(seed, delta);
42-
let setup = gb.setup().unwrap();
40+
let mut gb = Garbler::default();
4341
let all_gates: Vec<Vec<_>> = (0..iterations)
4442
.map(|_| {
45-
let worker = gb.alloc_worker(circuit.and_count()).unwrap();
46-
let mut iter = worker.generate(circuit, &inputs).unwrap();
43+
let mut iter = gb.generate(circuit, delta, &inputs).unwrap();
4744
let gates: Vec<_> = iter.by_ref().collect();
4845
let _ = iter.finish().unwrap();
4946
gates
@@ -55,11 +52,9 @@ fn bench_evaluate(c: &mut Criterion) {
5552
// Iterator-based (one gate at a time)
5653
group.bench_function(BenchmarkId::new("iter", name), |b| {
5754
let mut ev = Evaluator::default();
58-
ev.setup(setup.clone()).unwrap();
5955
b.iter(|| {
6056
for gates in &all_gates {
61-
let worker = ev.alloc_worker(circuit.and_count()).unwrap();
62-
let mut consumer = worker.evaluate(circuit, &eval_inputs).unwrap();
57+
let mut consumer = ev.evaluate(circuit, &eval_inputs).unwrap();
6358
for gate in gates {
6459
consumer.next(*gate);
6560
}
@@ -73,19 +68,15 @@ fn bench_evaluate(c: &mut Criterion) {
7368
// iteration
7469
group.bench_function(BenchmarkId::new("batched", name), |b| {
7570
let mut ev = Evaluator::default();
76-
ev.setup(setup.clone()).unwrap();
77-
let mut gb = Garbler::new(seed, delta);
78-
let _ = gb.setup().unwrap();
71+
let mut gb = Garbler::default();
7972
b.iter(|| {
8073
for _ in 0..iterations {
8174
// Regenerate batches (not timed separately, but included in measurement)
82-
let worker = gb.alloc_worker(circuit.and_count()).unwrap();
83-
let mut iter = worker.generate_batched(circuit, &inputs).unwrap();
75+
let mut iter = gb.generate_batched(circuit, delta, &inputs).unwrap();
8476
let batches: Vec<_> = iter.by_ref().collect();
8577
let _ = iter.finish().unwrap();
8678

87-
let ev_worker = ev.alloc_worker(circuit.and_count()).unwrap();
88-
let mut consumer = ev_worker.evaluate_batched(circuit, &eval_inputs).unwrap();
79+
let mut consumer = ev.evaluate_batched(circuit, &eval_inputs).unwrap();
8980
for batch in batches {
9081
consumer.next(batch);
9182
}
@@ -105,7 +96,6 @@ fn bench_evaluate_parallel(c: &mut Criterion) {
10596

10697
let mut rng = StdRng::seed_from_u64(0);
10798
let delta = Delta::random(&mut rng);
108-
let seed: [u8; 16] = rng.random();
10999

110100
// Prepare inputs
111101
let inputs: Vec<Key> = (0..256).map(|_| rng.random()).collect();
@@ -123,12 +113,10 @@ fn bench_evaluate_parallel(c: &mut Criterion) {
123113
let actual_gates = circuit_count as u64 * gates_per_circuit;
124114

125115
// Pre-garble circuits
126-
let mut gb = Garbler::new(seed, delta);
127-
let setup = gb.setup().unwrap();
116+
let mut gb = Garbler::default();
128117
let garbled_circuits: Vec<GarbledCircuit> = (0..circuit_count)
129118
.map(|_| {
130-
let worker = gb.alloc_worker(circuit.and_count()).unwrap();
131-
let mut iter = worker.generate(&circuit, &inputs).unwrap();
119+
let mut iter = gb.generate(&circuit, delta, &inputs).unwrap();
132120
let gates: Vec<_> = iter.by_ref().collect();
133121
let _ = iter.finish().unwrap();
134122
GarbledCircuit { gates }
@@ -139,17 +127,12 @@ fn bench_evaluate_parallel(c: &mut Criterion) {
139127

140128
// Parallel evaluation using evaluate_garbled_circuits (uses rayon par_iter)
141129
group.bench_function(BenchmarkId::new("rayon", name), |b| {
142-
let mut ev = Evaluator::default();
143-
ev.setup(setup.clone()).unwrap();
144130
b.iter(|| {
145131
let circs: Vec<_> = garbled_circuits
146132
.iter()
147133
.map(|gc| (circuit.clone(), eval_inputs.clone(), gc.clone()))
148134
.collect();
149-
let workers: Vec<_> = (0..circuit_count)
150-
.map(|_| ev.alloc_worker(circuit.and_count()).unwrap())
151-
.collect();
152-
black_box(evaluate_garbled_circuits(circs, workers).unwrap())
135+
black_box(evaluate_garbled_circuits(circs).unwrap())
153136
})
154137
});
155138
}

‎crates/garble-core/benches/garble.rs‎

Lines changed: 5 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
55
use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
66
use mpz_circuits::AES128;
7-
use mpz_garble_core::{Evaluator, Garbler, Key};
7+
use mpz_garble_core::{Garbler, Key};
88
use mpz_memory_core::correlated::Delta;
99
use rand::{Rng, SeedableRng, rngs::StdRng};
1010

@@ -19,7 +19,6 @@ fn bench_garble(c: &mut Criterion) {
1919
let mut rng = StdRng::seed_from_u64(0);
2020
let delta = Delta::random(&mut rng);
2121
let inputs: Vec<Key> = (0..256).map(|_| rng.random()).collect();
22-
let seed: [u8; 16] = rng.random();
2322

2423
let gates_per_circuit = circuit.and_count() as u64;
2524

@@ -31,11 +30,10 @@ fn bench_garble(c: &mut Criterion) {
3130

3231
// Iterator-based (one gate at a time)
3332
group.bench_function(BenchmarkId::new("iter", name), |b| {
33+
let mut gb = Garbler::default();
3434
b.iter(|| {
3535
for _ in 0..iterations {
36-
let mut gb = Garbler::new(seed, delta);
37-
let _ = gb.setup().unwrap();
38-
let mut iter = gb.generate(circuit, &inputs).unwrap();
36+
let mut iter = gb.generate(circuit, delta, &inputs).unwrap();
3937
let _: Vec<_> = iter.by_ref().collect();
4038
black_box(iter.finish().unwrap());
4139
}
@@ -44,11 +42,10 @@ fn bench_garble(c: &mut Criterion) {
4442

4543
// Batched (multiple gates at a time)
4644
group.bench_function(BenchmarkId::new("batched", name), |b| {
45+
let mut gb = Garbler::default();
4746
b.iter(|| {
4847
for _ in 0..iterations {
49-
let mut gb = Garbler::new(seed, delta);
50-
let _ = gb.setup().unwrap();
51-
let mut iter = gb.generate_batched(circuit, &inputs).unwrap();
48+
let mut iter = gb.generate_batched(circuit, delta, &inputs).unwrap();
5249
let _: Vec<_> = iter.by_ref().collect();
5350
black_box(iter.finish().unwrap());
5451
}
@@ -57,38 +54,6 @@ fn bench_garble(c: &mut Criterion) {
5754
}
5855

5956
group.finish();
60-
61-
// Evaluator benchmarks
62-
let mut ev_group = c.benchmark_group("evaluate");
63-
64-
ev_group.bench_function("aes128", |b| {
65-
let mut gb = Garbler::new(seed, delta);
66-
let setup = gb.setup().unwrap();
67-
let mut gb_iter = gb.generate(&AES128, &inputs).unwrap();
68-
let gates: Vec<_> = gb_iter.by_ref().collect();
69-
70-
let choices: Vec<bool> = (0..256).map(|_| rng.random()).collect();
71-
let inputs: Vec<_> = inputs
72-
.iter()
73-
.zip(choices)
74-
.map(|(input, choice)| input.auth(choice, &delta))
75-
.collect();
76-
77-
b.iter(|| {
78-
let setup = setup.clone();
79-
let mut ev = Evaluator::default();
80-
ev.setup(setup).unwrap();
81-
let mut ev_consumer = ev.evaluate(&AES128, &inputs).unwrap();
82-
83-
for gate in &gates {
84-
ev_consumer.next(*gate);
85-
}
86-
87-
black_box(ev_consumer.finish().unwrap());
88-
})
89-
});
90-
91-
ev_group.finish();
9257
}
9358

9459
criterion_group!(benches, bench_garble);

0 commit comments

Comments
 (0)