152 fuzzing constants (#153)

It is easy to generate a graph that results in out-of-memory if we let types with arbitrary sizes. Limiting constants are needed to avoid out-of-memory at the start of fuzzing, so the fuzzer can reach meaningful coverage. Resolves #152

Author: javad-seyed

ciphercore-base/Cargo.toml

@@ -35,6 +35,7 @@ bincode = "1.3.3"
 [features]
 default = []
 nightly-features = []
+fuzzing = []
 
 [[bin]]
 name = "ciphercore_compile"

ciphercore-base/src/constants.rs

@@ -1,5 +1,16 @@
-pub(super) const MAX_TOTAL_SIZE_NODES: u64 = u64::MAX - 1;
-pub(super) const MAX_INDIVIDUAL_NODE_SIZE: u64 = u64::MAX - 1;
-pub(super) const TYPES_VECTOR_LENGTH_LIMIT: usize = usize::MAX - 1;
-pub(super) const TYPE_MEMORY_OVERHEAD: u64 = 1;
-pub(super) const NON_STANDARD_SCALAR_LEN_SUPPORT: bool = false;
+#[cfg(feature = "fuzzing")]
+pub mod type_size_limit_constants {
+ pub const MAX_TOTAL_SIZE_NODES: u64 = 10000;
+ pub const MAX_INDIVIDUAL_NODE_SIZE: u64 = 1000;
+ pub const TYPES_VECTOR_LENGTH_LIMIT: usize = 1000;
+ pub const TYPE_MEMORY_OVERHEAD: u64 = 1;
+ pub const NON_STANDARD_SCALAR_LEN_SUPPORT: bool = false;
+}
+#[cfg(not(feature = "fuzzing"))]
+pub mod type_size_limit_constants {
+ pub const MAX_TOTAL_SIZE_NODES: u64 = u64::MAX - 1;
+ pub const MAX_INDIVIDUAL_NODE_SIZE: u64 = u64::MAX - 1;
+ pub const TYPES_VECTOR_LENGTH_LIMIT: usize = usize::MAX - 1;
+ pub const TYPE_MEMORY_OVERHEAD: u64 = 1;
+ pub const NON_STANDARD_SCALAR_LEN_SUPPORT: bool = false;
+}

ciphercore-base/src/data_types.rs

@@ -1,5 +1,5 @@
 //! Types used within CipherCore and related functions.
-use crate::constants;
+use crate::constants::type_size_limit_constants;
 use crate::errors::CiphercoreBaseError;
 use crate::errors::Result;
 use serde::{Deserialize, Serialize};
@@ -133,8 +133,8 @@ impl ScalarType {
  if let Some(m) = self.modulus {
  //Currently our evaluator only supports bit_size = 1,8,16,32,64
  let supported_modulus = vec![TWO, TWO.pow(8), TWO.pow(16), TWO.pow(32)];
- let supported =
- constants::NON_STANDARD_SCALAR_LEN_SUPPORT || supported_modulus.contains(&m);
+ let supported = type_size_limit_constants::NON_STANDARD_SCALAR_LEN_SUPPORT
+ || supported_modulus.contains(&m);
  supported && (m > 2 || (m == 2 && !self.signed))
  } else {
  true
@@ -1202,7 +1202,7 @@ pub(super) fn get_size_estimation_in_bits(t: Type) -> Result<u64> {
  }
  };
  result
- .checked_add(constants::TYPE_MEMORY_OVERHEAD)
+ .checked_add(type_size_limit_constants::TYPE_MEMORY_OVERHEAD)
  .ok_or_else(|| runtime_error!("add overflow!"))
 }
 
@@ -1253,7 +1253,7 @@ pub(super) fn get_size_estimation_in_bits(t: Type) -> Result<u64> {
 pub fn get_types_vector(t: Type) -> Result<Vec<TypePointer>> {
  match t {
  Type::Vector(length, element_type) => {
- if length > constants::TYPES_VECTOR_LENGTH_LIMIT as u64 {
+ if length > type_size_limit_constants::TYPES_VECTOR_LENGTH_LIMIT as u64 {
  return Err(runtime_error!(
  "Vector length is greater than TYPES_VECTOR_LENGTH_LIMIT!"
  ));
@@ -1266,7 +1266,7 @@ pub fn get_types_vector(t: Type) -> Result<Vec<TypePointer>> {
  }
  Type::Tuple(types) => {
  let length = types.len();
- if length > constants::TYPES_VECTOR_LENGTH_LIMIT {
+ if length > type_size_limit_constants::TYPES_VECTOR_LENGTH_LIMIT {
  return Err(runtime_error!(
  "Tuple length is greater than TYPES_VECTOR_LENGTH_LIMIT!"
  ));
@@ -1279,7 +1279,7 @@ pub fn get_types_vector(t: Type) -> Result<Vec<TypePointer>> {
  }
  Type::NamedTuple(names_types) => {
  let length = names_types.len();
- if length > constants::TYPES_VECTOR_LENGTH_LIMIT {
+ if length > type_size_limit_constants::TYPES_VECTOR_LENGTH_LIMIT {
  return Err(runtime_error!(
  "NamedTuple length is greater than TYPES_VECTOR_LENGTH_LIMIT!"
  ));

ciphercore-base/src/data_values.rs

@@ -1316,7 +1316,7 @@ impl ToNdarray<i64> for Value {
 #[cfg(test)]
 mod tests {
  use super::*;
- use crate::constants;
+ use crate::constants::type_size_limit_constants;
  use crate::data_types::{
  array_type, create_scalar_type, named_tuple_type, scalar_type, tuple_type, vector_type,
  BIT, INT32, INT64, INT8, UINT16, UINT32, UINT64, UINT8,
@@ -1362,7 +1362,7 @@ mod tests {
  check_type_test_worker_fail(&v, tuple_type(vec![]));
  let v = Value::from_bytes(vec![0, 0, 0]);
  check_type_test_worker_fail(&v, tuple_type(vec![]));
- if constants::NON_STANDARD_SCALAR_LEN_SUPPORT {
+ if type_size_limit_constants::NON_STANDARD_SCALAR_LEN_SUPPORT {
  let v = Value::from_bytes(vec![0]);
  check_type_test_worker(&v, scalar_type(create_scalar_type(false, Some(253))));
  check_type_test_worker(&v, scalar_type(create_scalar_type(false, Some(254))));
@@ -1699,7 +1699,7 @@ mod tests {
  let result = get_types_vector(t);
  assert!(result.is_ok());
  let t = vector_type(
- constants::TYPES_VECTOR_LENGTH_LIMIT as u64 + 1,
+ type_size_limit_constants::TYPES_VECTOR_LENGTH_LIMIT as u64 + 1,
  scalar_type(UINT16),
  );
  let result = get_types_vector(t);

ciphercore-base/src/graphs.rs

@@ -10,7 +10,7 @@ use std::sync::Weak;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::constants;
+use crate::constants::type_size_limit_constants;
 use crate::custom_ops::CustomOperation;
 use crate::data_types::{get_size_estimation_in_bits, ArrayShape, ScalarType, Type};
 use crate::data_values::Value;
@@ -483,7 +483,7 @@ impl Graph {
  self.remove_last_node(result)?;
  return Err(runtime_error!("Trying to add a node with invalid size"));
  }
- if size_estimate? > constants::MAX_INDIVIDUAL_NODE_SIZE {
+ if size_estimate? > type_size_limit_constants::MAX_INDIVIDUAL_NODE_SIZE {
  self.remove_last_node(result)?;
  return Err(runtime_error!(
  "Trying to add a node larger than MAX_INDIVIDUAL_NODE_SIZE"
@@ -928,7 +928,7 @@ impl Graph {
  "Trying to add a reshape node with invalid type size"
  ));
  }
- if size_estimate? > constants::MAX_INDIVIDUAL_NODE_SIZE {
+ if size_estimate? > type_size_limit_constants::MAX_INDIVIDUAL_NODE_SIZE {
  return Err(runtime_error!(
  "Trying to add a reshape node larger than MAX_INDIVIDUAL_NODE_SIZE"
  ));
@@ -2219,7 +2219,7 @@ impl Context {
  .get_total_size_nodes()
  .checked_add(get_size_estimation_in_bits(node_type)?)
  .ok_or_else(|| runtime_error!("add overflow!"))?;
- if new_total_size > constants::MAX_TOTAL_SIZE_NODES {
+ if new_total_size > type_size_limit_constants::MAX_TOTAL_SIZE_NODES {
  return Err(runtime_error!(
  "Can't add a node: total size of nodes exceeds MAX_TOTAL_SIZE_NODES"
  ));

ciphercore-base/src/type_inference.rs

@@ -1757,7 +1757,7 @@ mod tests {
  assert!(e.is_err());
  }
 
- use crate::constants;
+ use crate::constants::type_size_limit_constants;
  #[test]
  fn test_b2a() {
  test_b2a_worker(
@@ -1770,7 +1770,7 @@ mod tests {
  test_b2a_worker_fail(array_type(vec![10, 20, 1], BIT), BIT);
  test_b2a_worker_fail(array_type(vec![10, 20, 1], INT32), INT32);
  test_b2a_worker_fail(array_type(vec![10, 40], BIT), INT32);
- if constants::NON_STANDARD_SCALAR_LEN_SUPPORT {
+ if type_size_limit_constants::NON_STANDARD_SCALAR_LEN_SUPPORT {
  let t = create_scalar_type(false, Some(126));
  test_b2a_worker(array_type(vec![7], BIT), t.clone(), scalar_type(t.clone()));
  test_b2a_worker(