github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-24 04:40:05 +00:00
Code Issues Projects Releases Wiki Activity

remove bounds checker

Browse source
This commit is contained in:
schaeff 2021-05-03 19:20:18 +02:00
parent ec439a6b13
commit 3e5d71431a
3 changed files with 6 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
Cargo.lock generated
View file

@ -2269,7 +2269,7 @@ dependencies = [
[[package]]
name = "zokrates_cli"
version = "0.7.0"
version = "0.7.1"
dependencies = [
"assert_cli",
"bincode",
@ -2294,7 +2294,7 @@ version = "0.1.0"
[[package]]
name = "zokrates_core"
version = "0.6.0"
version = "0.6.1"
dependencies = [
"ark-bls12-377",
"ark-bn254",
@ -2335,7 +2335,7 @@ dependencies = [
[[package]]
name = "zokrates_core_test"
version = "0.2.0"
version = "0.2.1"
dependencies = [
"zokrates_test",
"zokrates_test_derive",
@ -2381,7 +2381,7 @@ dependencies = [
[[package]]
name = "zokrates_parser"
version = "0.2.0"
version = "0.2.1"
dependencies = [
"glob 0.2.11",
"pest",
@ -2390,7 +2390,7 @@ dependencies = [
[[package]]
name = "zokrates_pest_ast"
version = "0.2.0"
version = "0.2.1"
dependencies = [
"from-pest",
"glob 0.2.11",
@ -2402,7 +2402,7 @@ dependencies = [
[[package]]
name = "zokrates_stdlib"
version = "0.2.0"
version = "0.2.1"
dependencies = [
"fs_extra",
"zokrates_test",

134
zokrates_core/src/static_analysis/bounds_checker.rs
View file

@ -1,134 +0,0 @@
use crate::typed_absy::result_folder::*;
use crate::typed_absy::*;
use zokrates_field::Field;
pub struct BoundsChecker;
pub type Error = String;
impl BoundsChecker {
pub fn check<T: Field>(p: TypedProgram<T>) -> Result<TypedProgram<T>, Error> {
BoundsChecker.fold_program(p)
}
pub fn check_select<'ast, T: Field, U: Select<'ast, T>>(
&mut self,
array: ArrayExpression<'ast, T>,
index: UExpression<'ast, T>,
) -> Result<U, Error> {
let array = self.fold_array_expression(array)?;
let index = self.fold_uint_expression(index)?;
match (array.get_array_type().size.as_inner(), index.as_inner()) {
(UExpressionInner::Value(size), UExpressionInner::Value(index)) => {
if index >= size {
return Err(format!(
"Out of bounds access: {}[{}] but {} is of size {}",
array, index, array, size
));
}
}
_ => unreachable!(),
};
Ok(U::select(array, index))
}
}
impl<'ast, T: Field> ResultFolder<'ast, T> for BoundsChecker {
type Error = Error;
fn fold_array_expression_inner(
&mut self,
ty: &ArrayType<'ast, T>,
e: ArrayExpressionInner<'ast, T>,
) -> Result<ArrayExpressionInner<'ast, T>, Self::Error> {
match e {
ArrayExpressionInner::Select(box array, box index) => self
.check_select::<_, ArrayExpression<_>>(array, index)
.map(|a| a.into_inner()),
ArrayExpressionInner::Slice(box array, box from, box to) => {
let array = self.fold_array_expression(array)?;
let from = self.fold_uint_expression(from)?;
let to = self.fold_uint_expression(to)?;
match (
array.get_array_type().size.as_inner(),
from.as_inner(),
to.as_inner(),
) {
(
UExpressionInner::Value(size),
UExpressionInner::Value(from),
UExpressionInner::Value(to),
) => {
if from > to {
return Err(format!(
"Slice is created from an invalid range {}..{}",
from, to
));
}
if from > size {
return Err(format!("Lower bound {} of slice {}[{}..{}] is out of bounds for array of size {}", from, array, from, to, size));
}
if to > size {
return Err(format!("Upper bound {} of slice {}[{}..{}] is out of bounds for array of size {}", to, array, from, to, size));
}
}
_ => unreachable!(),
};
Ok(ArrayExpressionInner::Slice(box array, box from, box to))
}
e => fold_array_expression_inner(self, ty, e),
}
}
fn fold_struct_expression_inner(
&mut self,
ty: &StructType<'ast, T>,
e: StructExpressionInner<'ast, T>,
) -> Result<StructExpressionInner<'ast, T>, Self::Error> {
match e {
StructExpressionInner::Select(box array, box index) => self
.check_select::<_, StructExpression<_>>(array, index)
.map(|a| a.into_inner()),
e => fold_struct_expression_inner(self, ty, e),
}
}
fn fold_field_expression(
&mut self,
e: FieldElementExpression<'ast, T>,
) -> Result<FieldElementExpression<'ast, T>, Self::Error> {
match e {
FieldElementExpression::Select(box array, box index) => self.check_select(array, index),
e => fold_field_expression(self, e),
}
}
fn fold_boolean_expression(
&mut self,
e: BooleanExpression<'ast, T>,
) -> Result<BooleanExpression<'ast, T>, Self::Error> {
match e {
BooleanExpression::Select(box array, box index) => self.check_select(array, index),
e => fold_boolean_expression(self, e),
}
}
fn fold_uint_expression_inner(
&mut self,
bitwidth: UBitwidth,
e: UExpressionInner<'ast, T>,
) -> Result<UExpressionInner<'ast, T>, Self::Error> {
match e {
UExpressionInner::Select(box array, box index) => self
.check_select::<_, UExpression<_>>(array, index)
.map(|a| a.into_inner()),
e => fold_uint_expression_inner(self, bitwidth, e),
}
}
}

4
zokrates_core/src/static_analysis/mod.rs
View file

@ -4,7 +4,6 @@
//! @author Thibaut Schaeffer <thibaut@schaeff.fr>
//! @date 2018
mod bounds_checker;
mod constant_inliner;
mod flat_propagation;
mod flatten_complex_types;
@ -17,7 +16,6 @@ mod unconstrained_vars;
mod variable_read_remover;
mod variable_write_remover;
use self::bounds_checker::BoundsChecker;
use self::flatten_complex_types::Flattener;
use self::propagation::Propagator;
use self::redefinition::RedefinitionOptimizer;
@ -90,8 +88,6 @@ impl<'ast, T: Field> TypedProgram<'ast, T> {
let r = VariableWriteRemover::apply(r);
// remove variable access to complex types
let r = VariableReadRemover::apply(r);
// check array accesses are in bounds
let r = BoundsChecker::check(r).map_err(Error::from)?;
// detect non constant shifts
let r = ShiftChecker::check(r).map_err(Error::from)?;
// convert to zir, removing complex types