github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 04:08:33 +00:00
Code Issues Projects Releases Wiki Activity

remove libsnark references and orphaned modules

Browse source
This commit is contained in:
schaeff 2022-07-06 11:50:01 +02:00
parent 634c17cb56
commit 111e4069a0
7 changed files with 6 additions and 634 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.circleci/config.yml
View file

@ -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:

1
Dockerfile
View file

@ -1,6 +1,5 @@
FROM zokrates/env:20.04 as build
ENV WITH_LIBSNARK=1
WORKDIR /build
COPY . src

53
zokrates_ast/src/common/utils.rs
View file

@ -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<T: Field, U: Clone + Into<FlatExpression<T>>>(
v: &[(T, U)],
) -> FlatExpression<T> {
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<T: Field>(v: Vec<FlatExpression<T>>) -> FlatExpression<T> {
flat_expression_from_expression_summands(
&v.into_iter()
.rev()
.enumerate()
.map(|(index, var)| (T::from(2).pow(index), var))
.collect::<Vec<_>>(),
)
}
pub fn flat_expression_from_variable_summands<T: Field>(v: &[(T, usize)]) -> FlatExpression<T> {
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),
)
}
}
}

8
zokrates_common/src/helpers.rs
View file

@ -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,

227
zokrates_core/src/proof_system/libsnark/gm17.rs
View file

@ -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<Bn128Field, GM17> for Libsnark {
fn generate_proof<I: IntoIterator<Item = Statement<Bn128Field>>>(
program: ProgIterator<Bn128Field, I>,
witness: Witness<Bn128Field>,
proving_key: Vec<u8>,
) -> Proof<Bn128Field, GM17> {
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::<G1Affine, G2Affine> { a, b, c };
let public_inputs: Vec<String> = program
.public_inputs_values(&witness)
.iter()
.map(|f| format!("0x{:064x}", f.to_biguint()))
.collect();
Proof::new(points, public_inputs)
}
fn verify(
vk: <GM17 as Scheme<Bn128Field>>::VerificationKey,
proof: Proof<Bn128Field, GM17>,
) -> 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<Bn128Field, GM17> for Libsnark {
fn setup<I: IntoIterator<Item = Statement<Bn128Field>>>(
program: ProgIterator<Bn128Field, I>,
) -> SetupKeypair<Bn128Field, GM17> {
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<u8> =
std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec();
let pk: Vec<u8> =
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::<G1Affine, G2Affine> {
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<Bn128Field> = Prog {
arguments: vec![FlatParameter::private(FlatVariable::new(0))],
return_count: 1,
statements: vec![Statement::constraint(
FlatVariable::new(0),
FlatVariable::public(0),
)],
};
let keypair = <Libsnark as NonUniversalBackend<Bn128Field, GM17>>::setup(program.clone());
let interpreter = Interpreter::default();
let witness = interpreter
.execute(program.clone(), &vec![Bn128Field::from(42)])
.unwrap();
let proof =
<Libsnark as Backend<Bn128Field, GM17>>::generate_proof(program, witness, keypair.pk);
let ans = <Libsnark as Backend<Bn128Field, GM17>>::verify(keypair.vk, proof);
assert!(ans);
}
}

257
zokrates_core/src/proof_system/libsnark/pghr13.rs
View file

@ -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<Bn128Field, PGHR13> for Libsnark {
fn generate_proof<I: IntoIterator<Item = Statement<Bn128Field>>>(
program: ProgIterator<Bn128Field, I>,
witness: Witness<Bn128Field>,
proving_key: Vec<u8>,
) -> Proof<Bn128Field, PGHR13> {
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::<G1Affine, G2Affine> {
a,
a_p,
b,
b_p,
c,
c_p,
h,
k,
};
let public_inputs: Vec<String> = program
.public_inputs_values(&witness)
.iter()
.map(|f| format!("0x{:064x}", f.to_biguint()))
.collect();
Proof::new(points, public_inputs)
}
fn verify(
vk: <PGHR13 as Scheme<Bn128Field>>::VerificationKey,
proof: Proof<Bn128Field, PGHR13>,
) -> 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<Bn128Field, PGHR13> for Libsnark {
fn setup<I: IntoIterator<Item = Statement<Bn128Field>>>(
program: ProgIterator<Bn128Field, I>,
) -> SetupKeypair<Bn128Field, PGHR13> {
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<u8> =
std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec();
let pk: Vec<u8> =
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::<G1Affine, G2Affine> {
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<Bn128Field> = Prog {
arguments: vec![FlatParameter::private(FlatVariable::new(0))],
return_count: 1,
statements: vec![Statement::constraint(
FlatVariable::new(0),
FlatVariable::public(0),
)],
};
let keypair = <Libsnark as NonUniversalBackend<Bn128Field, PGHR13>>::setup(program.clone());
let interpreter = Interpreter::default();
let witness = interpreter
.execute(program.clone(), &vec![Bn128Field::from(42)])
.unwrap();
let proof =
<Libsnark as Backend<Bn128Field, PGHR13>>::generate_proof(program, witness, keypair.pk);
let ans = <Libsnark as Backend<Bn128Field, PGHR13>>::verify(keypair.vk, proof);
assert!(ans);
}
}

88
zokrates_core/src/static_analysis/trimmer.rs
View file

@ -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::<T>();
// 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::<T>();
// 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::<T>();
// 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::<T>();
// 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::<T>();
// 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::<T>();
// 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::<T>();
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(),
}
}
}