2021-01-15 13:35:49 -08:00
|
|
|
use halo2::{
|
2021-07-16 08:33:22 -07:00
|
|
|
circuit::{Layouter, SimpleFloorPlanner},
|
2021-10-27 06:58:28 -07:00
|
|
|
pasta::{pallas, EqAffine},
|
2021-01-15 13:35:49 -08:00
|
|
|
plonk::{
|
2021-07-16 08:33:22 -07:00
|
|
|
create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, ConstraintSystem, Error,
|
|
|
|
VerifyingKey,
|
2021-01-15 13:35:49 -08:00
|
|
|
},
|
|
|
|
poly::commitment::Params,
|
2021-04-30 18:28:50 -07:00
|
|
|
transcript::{Blake2bRead, Blake2bWrite, Challenge255},
|
2021-01-15 13:35:49 -08:00
|
|
|
};
|
2022-01-20 08:16:48 -08:00
|
|
|
use rand_core::OsRng;
|
2021-01-15 13:35:49 -08:00
|
|
|
|
|
|
|
use std::{
|
|
|
|
fs::File,
|
|
|
|
io::{prelude::*, BufReader},
|
|
|
|
path::Path,
|
|
|
|
};
|
|
|
|
|
2021-02-25 11:50:50 -08:00
|
|
|
use criterion::{criterion_group, criterion_main, Criterion};
|
|
|
|
|
|
|
|
use crate::{BlockWord, Sha256, Table16Chip, Table16Config, BLOCK_SIZE};
|
2021-01-15 13:35:49 -08:00
|
|
|
|
2021-02-25 12:34:07 -08:00
|
|
|
#[allow(dead_code)]
|
2021-01-15 13:35:49 -08:00
|
|
|
fn bench(name: &str, k: u32, c: &mut Criterion) {
|
2021-07-16 08:33:22 -07:00
|
|
|
#[derive(Default)]
|
2021-01-15 13:35:49 -08:00
|
|
|
struct MyCircuit {}
|
|
|
|
|
2021-10-27 06:58:28 -07:00
|
|
|
impl Circuit<pallas::Base> for MyCircuit {
|
2021-01-15 13:35:49 -08:00
|
|
|
type Config = Table16Config;
|
2021-07-16 08:33:22 -07:00
|
|
|
type FloorPlanner = SimpleFloorPlanner;
|
|
|
|
|
|
|
|
fn without_witnesses(&self) -> Self {
|
|
|
|
Self::default()
|
|
|
|
}
|
2021-01-15 13:35:49 -08:00
|
|
|
|
2021-10-27 06:58:28 -07:00
|
|
|
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
|
2021-01-15 13:35:49 -08:00
|
|
|
Table16Chip::configure(meta)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn synthesize(
|
|
|
|
&self,
|
2021-04-20 04:26:32 -07:00
|
|
|
config: Self::Config,
|
2021-10-27 06:58:28 -07:00
|
|
|
mut layouter: impl Layouter<pallas::Base>,
|
2021-01-15 13:35:49 -08:00
|
|
|
) -> Result<(), Error> {
|
2021-10-27 06:58:28 -07:00
|
|
|
Table16Chip::load(config.clone(), &mut layouter)?;
|
|
|
|
let table16_chip = Table16Chip::construct(config);
|
2021-01-15 13:35:49 -08:00
|
|
|
|
|
|
|
// Test vector: "abc"
|
|
|
|
let test_input = [
|
2021-07-19 07:23:20 -07:00
|
|
|
BlockWord(Some(0b01100001011000100110001110000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000000000)),
|
|
|
|
BlockWord(Some(0b00000000000000000000000000011000)),
|
2021-01-15 13:35:49 -08:00
|
|
|
];
|
|
|
|
|
|
|
|
// Create a message of length 31 blocks
|
|
|
|
let mut input = Vec::with_capacity(31 * BLOCK_SIZE);
|
|
|
|
for _ in 0..31 {
|
|
|
|
input.extend_from_slice(&test_input);
|
|
|
|
}
|
|
|
|
|
2021-04-20 04:26:32 -07:00
|
|
|
Sha256::digest(table16_chip, layouter.namespace(|| "'abc' * 2"), &input)?;
|
2021-01-15 13:35:49 -08:00
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the polynomial commitment parameters
|
|
|
|
let params_path = Path::new("./benches/sha256_assets/sha256_params");
|
2021-02-25 12:34:07 -08:00
|
|
|
if File::open(¶ms_path).is_err() {
|
2021-01-15 13:35:49 -08:00
|
|
|
let params: Params<EqAffine> = Params::new(k);
|
|
|
|
let mut buf = Vec::new();
|
|
|
|
|
|
|
|
params.write(&mut buf).expect("Failed to write params");
|
|
|
|
let mut file = File::create(¶ms_path).expect("Failed to create sha256_params");
|
|
|
|
|
|
|
|
file.write_all(&buf[..])
|
|
|
|
.expect("Failed to write params to file");
|
|
|
|
}
|
|
|
|
|
|
|
|
let params_fs = File::open(¶ms_path).expect("couldn't load sha256_params");
|
|
|
|
let params: Params<EqAffine> =
|
|
|
|
Params::read::<_>(&mut BufReader::new(params_fs)).expect("Failed to read params");
|
|
|
|
|
|
|
|
let empty_circuit: MyCircuit = MyCircuit {};
|
|
|
|
|
|
|
|
// Initialize the proving key
|
|
|
|
let vk_path = Path::new("./benches/sha256_assets/sha256_vk");
|
2021-02-25 12:34:07 -08:00
|
|
|
if File::open(&vk_path).is_err() {
|
2021-01-15 13:35:49 -08:00
|
|
|
let vk = keygen_vk(¶ms, &empty_circuit).expect("keygen_vk should not fail");
|
|
|
|
let mut buf = Vec::new();
|
|
|
|
|
|
|
|
vk.write(&mut buf).expect("Failed to write vk");
|
|
|
|
let mut file = File::create(&vk_path).expect("Failed to create sha256_vk");
|
|
|
|
|
|
|
|
file.write_all(&buf[..])
|
|
|
|
.expect("Failed to write vk to file");
|
|
|
|
}
|
|
|
|
|
2021-12-28 23:00:32 -08:00
|
|
|
let vk_fs = File::open(&vk_path).expect("couldn't load sha256_vk");
|
2021-01-15 13:35:49 -08:00
|
|
|
let vk: VerifyingKey<EqAffine> =
|
|
|
|
VerifyingKey::<EqAffine>::read::<_, MyCircuit>(&mut BufReader::new(vk_fs), ¶ms)
|
|
|
|
.expect("Failed to read vk");
|
|
|
|
|
|
|
|
let pk = keygen_pk(¶ms, vk, &empty_circuit).expect("keygen_pk should not fail");
|
|
|
|
|
|
|
|
let circuit: MyCircuit = MyCircuit {};
|
|
|
|
|
|
|
|
// let prover_name = name.to_string() + "-prover";
|
|
|
|
let verifier_name = name.to_string() + "-verifier";
|
|
|
|
|
|
|
|
// /// Benchmark proof creation
|
|
|
|
// c.bench_function(&prover_name, |b| {
|
|
|
|
// b.iter(|| {
|
|
|
|
// let mut transcript = Blake2bWrite::init(Fq::one());
|
|
|
|
// create_proof(¶ms, &pk, &circuit, &[], &mut transcript)
|
|
|
|
// .expect("proof generation should not fail");
|
|
|
|
// let proof: Vec<u8> = transcript.finalize();
|
|
|
|
// });
|
|
|
|
// });
|
|
|
|
|
|
|
|
// Create a proof
|
|
|
|
let proof_path = Path::new("./benches/sha256_assets/sha256_proof");
|
2021-02-25 12:34:07 -08:00
|
|
|
if File::open(&proof_path).is_err() {
|
2021-05-07 07:21:54 -07:00
|
|
|
let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
|
2021-12-25 05:36:41 -08:00
|
|
|
create_proof(¶ms, &pk, &[circuit], &[], OsRng, &mut transcript)
|
2021-01-15 13:35:49 -08:00
|
|
|
.expect("proof generation should not fail");
|
|
|
|
let proof: Vec<u8> = transcript.finalize();
|
|
|
|
let mut file = File::create(&proof_path).expect("Failed to create sha256_proof");
|
|
|
|
file.write_all(&proof[..]).expect("Failed to write proof");
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut proof_fs = File::open(&proof_path).expect("couldn't load sha256_proof");
|
|
|
|
let mut proof = Vec::<u8>::new();
|
|
|
|
proof_fs
|
|
|
|
.read_to_end(&mut proof)
|
|
|
|
.expect("Couldn't read proof");
|
|
|
|
|
|
|
|
c.bench_function(&verifier_name, |b| {
|
|
|
|
b.iter(|| {
|
|
|
|
let msm = params.empty_msm();
|
2021-05-07 07:21:54 -07:00
|
|
|
let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
|
2022-01-20 08:16:48 -08:00
|
|
|
let guard =
|
|
|
|
verify_proof(¶ms, pk.get_vk(), msm, &[], OsRng, &mut transcript).unwrap();
|
2021-01-15 13:35:49 -08:00
|
|
|
let msm = guard.clone().use_challenges();
|
|
|
|
assert!(msm.eval());
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-02-25 12:34:07 -08:00
|
|
|
#[allow(dead_code)]
|
2021-01-15 13:35:49 -08:00
|
|
|
fn criterion_benchmark(c: &mut Criterion) {
|
2021-07-16 08:33:22 -07:00
|
|
|
bench("sha256", 17, c);
|
2021-01-15 13:35:49 -08:00
|
|
|
// bench("sha256", 20, c);
|
|
|
|
}
|
|
|
|
|
|
|
|
criterion_group!(benches, criterion_benchmark);
|
|
|
|
criterion_main!(benches);
|