From 111e4069a0842fd028d4793f31853eecc0f4256a Mon Sep 17 00:00:00 2001 From: schaeff Date: Wed, 6 Jul 2022 11:50:01 +0200 Subject: [PATCH] remove libsnark references and orphaned modules --- .circleci/config.yml | 6 +- Dockerfile | 1 - zokrates_ast/src/common/utils.rs | 53 ---- zokrates_common/src/helpers.rs | 8 +- .../src/proof_system/libsnark/gm17.rs | 227 ---------------- .../src/proof_system/libsnark/pghr13.rs | 257 ------------------ zokrates_core/src/static_analysis/trimmer.rs | 88 ------ 7 files changed, 6 insertions(+), 634 deletions(-) delete mode 100644 zokrates_ast/src/common/utils.rs delete mode 100644 zokrates_core/src/proof_system/libsnark/gm17.rs delete mode 100644 zokrates_core/src/proof_system/libsnark/pghr13.rs delete mode 100644 zokrates_core/src/static_analysis/trimmer.rs diff --git a/.circleci/config.yml b/.circleci/config.yml index 605f9b42..f538c071 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -22,7 +22,7 @@ jobs: - restore-sccache-cache - run: name: Build - command: WITH_LIBSNARK=1 RUSTFLAGS="-D warnings" ./build.sh + command: RUSTFLAGS="-D warnings" ./build.sh - save-sccache-cache test: docker: @@ -45,7 +45,7 @@ jobs: - run: name: Run tests no_output_timeout: 1h - command: WITH_LIBSNARK=1 RUSTFLAGS="-D warnings" ./test.sh + command: RUSTFLAGS="-D warnings" ./test.sh - save-sccache-cache wasm_test: docker: @@ -79,7 +79,7 @@ jobs: - run: name: Run integration tests no_output_timeout: "30m" - command: WITH_LIBSNARK=1 RUSTFLAGS="-D warnings" ./integration_test.sh + command: RUSTFLAGS="-D warnings" ./integration_test.sh - save-sccache-cache deploy: docker: diff --git a/Dockerfile b/Dockerfile index 39bbe708..cef449fc 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,5 @@ FROM zokrates/env:20.04 as build -ENV WITH_LIBSNARK=1 WORKDIR /build COPY . src diff --git a/zokrates_ast/src/common/utils.rs b/zokrates_ast/src/common/utils.rs deleted file mode 100644 index ea31fb61..00000000 --- a/zokrates_ast/src/common/utils.rs +++ /dev/null @@ -1,53 +0,0 @@ -use crate::flat_absy::*; -use zokrates_field::Field; - -// util to convert a vector of `(coefficient, expression)` to a flat_expression -// we build a binary tree of additions by splitting the vector recursively -pub fn flat_expression_from_expression_summands>>( - v: &[(T, U)], -) -> FlatExpression { - match v.len() { - 0 => FlatExpression::Number(T::zero()), - 1 => { - let (val, var) = v[0].clone(); - FlatExpression::Mult(box FlatExpression::Number(val), box var.into()) - } - n => { - let (u, v) = v.split_at(n / 2); - FlatExpression::Add( - box flat_expression_from_expression_summands(u), - box flat_expression_from_expression_summands(v), - ) - } - } -} - -pub fn flat_expression_from_bits(v: Vec>) -> FlatExpression { - flat_expression_from_expression_summands( - &v.into_iter() - .rev() - .enumerate() - .map(|(index, var)| (T::from(2).pow(index), var)) - .collect::>(), - ) -} - -pub fn flat_expression_from_variable_summands(v: &[(T, usize)]) -> FlatExpression { - match v.len() { - 0 => FlatExpression::Number(T::zero()), - 1 => { - let (val, var) = v[0].clone(); - FlatExpression::Mult( - box FlatExpression::Number(val), - box FlatExpression::Identifier(FlatVariable::new(var)), - ) - } - n => { - let (u, v) = v.split_at(n / 2); - FlatExpression::Add( - box flat_expression_from_variable_summands(u), - box flat_expression_from_variable_summands(v), - ) - } - } -} diff --git a/zokrates_common/src/helpers.rs b/zokrates_common/src/helpers.rs index 683ce615..aa65f9fb 100644 --- a/zokrates_common/src/helpers.rs +++ b/zokrates_common/src/helpers.rs @@ -1,7 +1,7 @@ use crate::constants::*; use std::convert::TryFrom; -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Eq)] pub enum CurveParameter { Bn128, Bls12_381, @@ -22,7 +22,7 @@ impl std::fmt::Display for CurveParameter { } } -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Eq)] pub enum BackendParameter { #[cfg(feature = "bellman")] Bellman, @@ -39,14 +39,12 @@ impl std::fmt::Display for BackendParameter { Bellman => write!(f, "bellman"), #[cfg(feature = "ark")] Ark => write!(f, "ark"), - #[cfg(feature = "libsnark")] - Libsnark => write!(f, "libsnark"), } } } #[allow(clippy::upper_case_acronyms)] -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Eq)] pub enum SchemeParameter { G16, GM17, diff --git a/zokrates_core/src/proof_system/libsnark/gm17.rs b/zokrates_core/src/proof_system/libsnark/gm17.rs deleted file mode 100644 index 9d50da5f..00000000 --- a/zokrates_core/src/proof_system/libsnark/gm17.rs +++ /dev/null @@ -1,227 +0,0 @@ -use crate::ir::{ProgIterator, Statement, Witness}; -use crate::proof_system::gm17::{ProofPoints, VerificationKey, GM17}; -use crate::proof_system::libsnark::ffi::{c_free, Buffer, ProofResult, SetupResult}; -use crate::proof_system::libsnark::{ - prepare_generate_proof, prepare_public_inputs, prepare_setup, serialization::*, Libsnark, -}; -use crate::proof_system::Scheme; -use crate::proof_system::{Backend, G1Affine, G2Affine, NonUniversalBackend, Proof, SetupKeypair}; -use std::io::{BufReader, BufWriter, Write}; -use zokrates_field::{Bn128Field, Field}; - -extern "C" { - fn gm17_bn128_setup( - a: *const u8, - b: *const u8, - c: *const u8, - a_len: i32, - b_len: i32, - c_len: i32, - constraints: i32, - variables: i32, - inputs: i32, - ) -> SetupResult; - - fn gm17_bn128_generate_proof( - pk_buf: *mut Buffer, - public_query_inputs: *const u8, - public_query_inputs_length: i32, - private_inputs: *const u8, - private_inputs_length: i32, - ) -> ProofResult; - - fn gm17_bn128_verify( - vk_buf: *mut Buffer, - proof_buf: *mut Buffer, - public_inputs: *const u8, - public_inputs_length: i32, - ) -> bool; -} - -impl Backend for Libsnark { - fn generate_proof>>( - program: ProgIterator, - witness: Witness, - proving_key: Vec, - ) -> Proof { - let program = program.collect(); - - let (public_inputs_arr, public_inputs_length, private_inputs_arr, private_inputs_length) = - prepare_generate_proof(program.clone(), witness.clone()); - - let mut pk_buffer = Buffer::from_vec(&proving_key); - - let proof = unsafe { - let result = gm17_bn128_generate_proof( - &mut pk_buffer as *mut _, - public_inputs_arr[0].as_ptr(), - public_inputs_length as i32, - private_inputs_arr[0].as_ptr(), - private_inputs_length as i32, - ); - - let proof = std::slice::from_raw_parts(result.proof.data, result.proof.length as usize) - .to_vec(); - - // free c allocated buffer - c_free(result.proof.data); - - proof - }; - - let mut reader = BufReader::new(proof.as_slice()); - let a = read_g1(&mut reader).unwrap(); - let b = read_g2(&mut reader).unwrap(); - let c = read_g1(&mut reader).unwrap(); - - let points = ProofPoints:: { a, b, c }; - let public_inputs: Vec = program - .public_inputs_values(&witness) - .iter() - .map(|f| format!("0x{:064x}", f.to_biguint())) - .collect(); - - Proof::new(points, public_inputs) - } - - fn verify( - vk: >::VerificationKey, - proof: Proof, - ) -> bool { - let vk_buffer = vec![]; - let mut vk_writer = BufWriter::new(vk_buffer); - - write_g2(&mut vk_writer, &vk.h); - write_g1(&mut vk_writer, &vk.g_alpha); - write_g2(&mut vk_writer, &vk.h_beta); - write_g1(&mut vk_writer, &vk.g_gamma); - write_g2(&mut vk_writer, &vk.h_gamma); - - vk.query.iter().for_each(|q| write_g1(&mut vk_writer, q)); - - vk_writer.flush().unwrap(); - - let proof_buffer = vec![]; - let mut proof_writer = BufWriter::new(proof_buffer); - - write_g1(&mut proof_writer, &proof.proof.a); - write_g2(&mut proof_writer, &proof.proof.b); - write_g1(&mut proof_writer, &proof.proof.c); - proof_writer.flush().unwrap(); - - let public_inputs: Vec<_> = proof - .inputs - .iter() - .map(|v| Bn128Field::try_from_str(v.as_str().trim_start_matches("0x"), 16).unwrap()) - .collect(); - - let (public_inputs_arr, public_inputs_length) = prepare_public_inputs(public_inputs); - - let mut vk_buffer = Buffer::from_vec(vk_writer.get_ref()); - let mut proof_buffer = Buffer::from_vec(proof_writer.get_ref()); - - unsafe { - gm17_bn128_verify( - &mut vk_buffer as *mut _, - &mut proof_buffer as *mut _, - public_inputs_arr[0].as_ptr(), - public_inputs_length as i32, - ) - } - } -} - -impl NonUniversalBackend for Libsnark { - fn setup>>( - program: ProgIterator, - ) -> SetupKeypair { - let program = program.collect(); - - let (a_arr, b_arr, c_arr, a_vec, b_vec, c_vec, num_constraints, num_variables, num_inputs) = - prepare_setup(program); - - let (vk, pk) = unsafe { - let result: SetupResult = gm17_bn128_setup( - a_arr.as_ptr(), - b_arr.as_ptr(), - c_arr.as_ptr(), - a_vec.len() as i32, - b_vec.len() as i32, - c_vec.len() as i32, - num_constraints as i32, - num_variables as i32, - num_inputs as i32, - ); - - let vk: Vec = - std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec(); - let pk: Vec = - std::slice::from_raw_parts(result.pk.data, result.pk.length as usize).to_vec(); - - // free c allocated buffers - c_free(result.vk.data); - c_free(result.pk.data); - - (vk, pk) - }; - - let vk_slice = vk.as_slice(); - let mut reader = BufReader::new(vk_slice); - - let h = read_g2(&mut reader).unwrap(); - let g_alpha = read_g1(&mut reader).unwrap(); - let h_beta = read_g2(&mut reader).unwrap(); - let g_gamma = read_g1(&mut reader).unwrap(); - let h_gamma = read_g2(&mut reader).unwrap(); - - let mut query = vec![]; - while let Ok(q) = read_g1(&mut reader) { - query.push(q); - } - - let vk = VerificationKey:: { - h, - g_alpha, - h_beta, - g_gamma, - h_gamma, - query, - }; - - SetupKeypair::new(vk, pk) - } -} - -#[cfg(feature = "libsnark")] -#[cfg(test)] -mod tests { - use super::*; - use crate::flat_absy::{FlatParameter, FlatVariable}; - use crate::ir::{Interpreter, Prog, Statement}; - use zokrates_field::Bn128Field; - - #[test] - fn verify() { - let program: Prog = Prog { - arguments: vec![FlatParameter::private(FlatVariable::new(0))], - return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], - }; - - let keypair = >::setup(program.clone()); - let interpreter = Interpreter::default(); - - let witness = interpreter - .execute(program.clone(), &vec![Bn128Field::from(42)]) - .unwrap(); - - let proof = - >::generate_proof(program, witness, keypair.pk); - - let ans = >::verify(keypair.vk, proof); - assert!(ans); - } -} diff --git a/zokrates_core/src/proof_system/libsnark/pghr13.rs b/zokrates_core/src/proof_system/libsnark/pghr13.rs deleted file mode 100644 index 826ee0d5..00000000 --- a/zokrates_core/src/proof_system/libsnark/pghr13.rs +++ /dev/null @@ -1,257 +0,0 @@ -use crate::proof_system::libsnark::ffi::{c_free, Buffer, ProofResult, SetupResult}; -use crate::proof_system::libsnark::{ - prepare_generate_proof, prepare_public_inputs, prepare_setup, Libsnark, -}; -use crate::proof_system::{Backend, G1Affine, G2Affine, NonUniversalBackend, Proof, SetupKeypair}; - -use crate::ir::{ProgIterator, Statement, Witness}; -use crate::proof_system::libsnark::serialization::{read_g1, read_g2, write_g1, write_g2}; -use crate::proof_system::pghr13::{ProofPoints, VerificationKey, PGHR13}; -use crate::proof_system::Scheme; -use std::io::{BufReader, BufWriter, Write}; -use zokrates_field::Bn128Field; -use zokrates_field::Field; - -extern "C" { - fn pghr13_bn128_setup( - a: *const u8, - b: *const u8, - c: *const u8, - a_len: i32, - b_len: i32, - c_len: i32, - constraints: i32, - variables: i32, - inputs: i32, - ) -> SetupResult; - - fn pghr13_bn128_generate_proof( - pk_buf: *mut Buffer, - public_query_inputs: *const u8, - public_query_inputs_length: i32, - private_inputs: *const u8, - private_inputs_length: i32, - ) -> ProofResult; - - fn pghr13_bn128_verify( - vk_buf: *mut Buffer, - proof_buf: *mut Buffer, - public_inputs: *const u8, - public_inputs_length: i32, - ) -> bool; -} - -impl Backend for Libsnark { - fn generate_proof>>( - program: ProgIterator, - witness: Witness, - proving_key: Vec, - ) -> Proof { - let program = program.collect(); - - let (public_inputs_arr, public_inputs_length, private_inputs_arr, private_inputs_length) = - prepare_generate_proof(program.clone(), witness.clone()); - - let mut pk_buffer = Buffer::from_vec(&proving_key); - - let proof = unsafe { - let result = pghr13_bn128_generate_proof( - &mut pk_buffer as *mut _, - public_inputs_arr[0].as_ptr(), - public_inputs_length as i32, - private_inputs_arr[0].as_ptr(), - private_inputs_length as i32, - ); - - let proof = std::slice::from_raw_parts(result.proof.data, result.proof.length as usize) - .to_vec(); - - // free c allocated buffer - c_free(result.proof.data); - - proof - }; - - let mut reader = BufReader::new(proof.as_slice()); - let a = read_g1(&mut reader).unwrap(); - let a_p = read_g1(&mut reader).unwrap(); - let b = read_g2(&mut reader).unwrap(); - let b_p = read_g1(&mut reader).unwrap(); - let c = read_g1(&mut reader).unwrap(); - let c_p = read_g1(&mut reader).unwrap(); - let h = read_g1(&mut reader).unwrap(); - let k = read_g1(&mut reader).unwrap(); - - let points = ProofPoints:: { - a, - a_p, - b, - b_p, - c, - c_p, - h, - k, - }; - - let public_inputs: Vec = program - .public_inputs_values(&witness) - .iter() - .map(|f| format!("0x{:064x}", f.to_biguint())) - .collect(); - - Proof::new(points, public_inputs) - } - - fn verify( - vk: >::VerificationKey, - proof: Proof, - ) -> bool { - let vk_buffer = vec![]; - let mut vk_writer = BufWriter::new(vk_buffer); - - write_g2(&mut vk_writer, &vk.a); - write_g1(&mut vk_writer, &vk.b); - write_g2(&mut vk_writer, &vk.c); - write_g2(&mut vk_writer, &vk.gamma); - write_g1(&mut vk_writer, &vk.gamma_beta_1); - write_g2(&mut vk_writer, &vk.gamma_beta_2); - write_g2(&mut vk_writer, &vk.z); - - vk.ic - .iter() - .for_each(|ic_query| write_g1(&mut vk_writer, ic_query)); - vk_writer.flush().unwrap(); - - let proof_buffer = vec![]; - let mut proof_writer = BufWriter::new(proof_buffer); - - write_g1(&mut proof_writer, &proof.proof.a); - write_g1(&mut proof_writer, &proof.proof.a_p); - write_g2(&mut proof_writer, &proof.proof.b); - write_g1(&mut proof_writer, &proof.proof.b_p); - write_g1(&mut proof_writer, &proof.proof.c); - write_g1(&mut proof_writer, &proof.proof.c_p); - write_g1(&mut proof_writer, &proof.proof.h); - write_g1(&mut proof_writer, &proof.proof.k); - proof_writer.flush().unwrap(); - - let public_inputs: Vec<_> = proof - .inputs - .iter() - .map(|v| Bn128Field::try_from_str(v.as_str().trim_start_matches("0x"), 16).unwrap()) - .collect(); - - let (public_inputs_arr, public_inputs_length) = prepare_public_inputs(public_inputs); - - let mut vk_buffer = Buffer::from_vec(vk_writer.get_ref()); - let mut proof_buffer = Buffer::from_vec(proof_writer.get_ref()); - - unsafe { - pghr13_bn128_verify( - &mut vk_buffer as *mut _, - &mut proof_buffer as *mut _, - public_inputs_arr[0].as_ptr(), - public_inputs_length as i32, - ) - } - } -} - -impl NonUniversalBackend for Libsnark { - fn setup>>( - program: ProgIterator, - ) -> SetupKeypair { - let program = program.collect(); - - let (a_arr, b_arr, c_arr, a_vec, b_vec, c_vec, num_constraints, num_variables, num_inputs) = - prepare_setup(program); - - let (vk, pk) = unsafe { - let result: SetupResult = pghr13_bn128_setup( - a_arr.as_ptr(), - b_arr.as_ptr(), - c_arr.as_ptr(), - a_vec.len() as i32, - b_vec.len() as i32, - c_vec.len() as i32, - num_constraints as i32, - num_variables as i32, - num_inputs as i32, - ); - - let vk: Vec = - std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec(); - let pk: Vec = - std::slice::from_raw_parts(result.pk.data, result.pk.length as usize).to_vec(); - - // free c allocated buffers - c_free(result.vk.data); - c_free(result.pk.data); - - (vk, pk) - }; - - let vk_slice = vk.as_slice(); - let mut reader = BufReader::new(vk_slice); - - let a = read_g2(&mut reader).unwrap(); - let b = read_g1(&mut reader).unwrap(); - let c = read_g2(&mut reader).unwrap(); - let gamma = read_g2(&mut reader).unwrap(); - let gamma_beta_1 = read_g1(&mut reader).unwrap(); - let gamma_beta_2 = read_g2(&mut reader).unwrap(); - let z = read_g2(&mut reader).unwrap(); - - let mut ic = vec![]; - while let Ok(q) = read_g1(&mut reader) { - ic.push(q); - } - - let vk = VerificationKey:: { - a, - b, - c, - gamma, - gamma_beta_1, - gamma_beta_2, - z, - ic, - }; - - SetupKeypair::new(vk, pk) - } -} - -#[cfg(feature = "libsnark")] -#[cfg(test)] -mod tests { - use super::*; - use crate::flat_absy::{FlatParameter, FlatVariable}; - use crate::ir::{Interpreter, Prog, Statement}; - use zokrates_field::Bn128Field; - - #[test] - fn verify() { - let program: Prog = Prog { - arguments: vec![FlatParameter::private(FlatVariable::new(0))], - return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], - }; - - let keypair = >::setup(program.clone()); - let interpreter = Interpreter::default(); - - let witness = interpreter - .execute(program.clone(), &vec![Bn128Field::from(42)]) - .unwrap(); - - let proof = - >::generate_proof(program, witness, keypair.pk); - - let ans = >::verify(keypair.vk, proof); - assert!(ans); - } -} diff --git a/zokrates_core/src/static_analysis/trimmer.rs b/zokrates_core/src/static_analysis/trimmer.rs deleted file mode 100644 index f4a2f406..00000000 --- a/zokrates_core/src/static_analysis/trimmer.rs +++ /dev/null @@ -1,88 +0,0 @@ -use zokrates_ast::typed::TypedModule; -use zokrates_ast::typed::{TypedFunctionSymbol, TypedProgram}; -use zokrates_field::Field; - -pub struct Trimmer; - -impl Trimmer { - pub fn trim<'ast, T: Field>(p: TypedProgram<'ast, T>) -> TypedProgram<'ast, T> { - let main_module_id = p.main; - - // get the main module - let main_module = p.modules.get(&main_module_id).unwrap().clone(); - - // get the main function in the main module - let (main_key, main_function) = main_module - .functions - .into_iter() - .find(|(k, _)| k.id == "main") - .unwrap() - .clone(); - - // define a function in the main module for the `unpack` embed - let unpack = crate::embed::FlatEmbed::Unpack(T::get_required_bits()); - let unpack_key = unpack.key::(); - - // define a function in the main module for the `u32_to_bits` embed - let u32_to_bits = crate::embed::FlatEmbed::U32ToBits; - let u32_to_bits_key = u32_to_bits.key::(); - - // define a function in the main module for the `u16_to_bits` embed - let u16_to_bits = crate::embed::FlatEmbed::U16ToBits; - let u16_to_bits_key = u16_to_bits.key::(); - - // define a function in the main module for the `u8_to_bits` embed - let u8_to_bits = crate::embed::FlatEmbed::U8ToBits; - let u8_to_bits_key = u8_to_bits.key::(); - - // define a function in the main module for the `u32_from_bits` embed - let u32_from_bits = crate::embed::FlatEmbed::U32FromBits; - let u32_from_bits_key = u32_from_bits.key::(); - - // define a function in the main module for the `u16_from_bits` embed - let u16_from_bits = crate::embed::FlatEmbed::U16FromBits; - let u16_from_bits_key = u16_from_bits.key::(); - - // define a function in the main module for the `u8_from_bits` embed - let u8_from_bits = crate::embed::FlatEmbed::U8FromBits; - let u8_from_bits_key = u8_from_bits.key::(); - - TypedProgram { - main: main_module_id.clone(), - modules: vec![( - main_module_id, - TypedModule { - functions: vec![ - (main_key, main_function), - (unpack_key.into(), TypedFunctionSymbol::Flat(unpack)), - ( - u32_from_bits_key.into(), - TypedFunctionSymbol::Flat(u32_from_bits), - ), - ( - u16_from_bits_key.into(), - TypedFunctionSymbol::Flat(u16_from_bits), - ), - ( - u8_from_bits_key.into(), - TypedFunctionSymbol::Flat(u8_from_bits), - ), - ( - u32_to_bits_key.into(), - TypedFunctionSymbol::Flat(u32_to_bits), - ), - ( - u16_to_bits_key.into(), - TypedFunctionSymbol::Flat(u16_to_bits), - ), - (u8_to_bits_key.into(), TypedFunctionSymbol::Flat(u8_to_bits)), - ] - .into_iter() - .collect(), - }, - )] - .into_iter() - .collect(), - } - } -}