Feat: First round of fuzzing tests (#63)

Co-authored-by: LucasLvy <[email protected]>

Author: maciejka

.gitignore

@@ -18,5 +18,10 @@ Cargo.lock
 # Added by cargo
 
 /target
+.DS_Store
 
+corpus/
+artifacts/
+
+.idea
 *.DS_Store

Cargo.toml

@@ -4,7 +4,7 @@ members = [
     "crates/starknet-types-rpc",
 ]
 
-exclude = ["ensure_no_std"]
+exclude = ["ensure_no_std", "fuzz"]
 resolver = "2"
 
 [workspace.package]

fuzz/Cargo.toml

@@ -0,0 +1,15 @@
+[workspace]
+members = ["felt"]
+
+resolver = "2"
+
+[workspace.package]
+authors = [
+    "Lucas Levy <@LucasLvy>",
+]
+edition = "2021"
+repository = "https://github.com/starknet-io/types-rs"
+
+[workspace.dependencies]
+starknet-types-core = { path = "../crates/starknet-types-core", default-features = false, features = ["arbitrary"] }
+libfuzzer-sys = "0.4"

fuzz/Makefile

@@ -0,0 +1,13 @@
+.PHONY: fuzz-add fuzz-div fuzz-mul fuzz-conversions
+
+fuzz-add_sub:
+	cargo +nightly fuzz run add_sub_fuzzer --fuzz-dir=./felt
+
+fuzz-div:
+	cargo +nightly fuzz run div_fuzzer --fuzz-dir=./felt
+
+fuzz-mul:
+	cargo +nightly fuzz run mul_fuzzer --fuzz-dir=./felt
+
+fuzz-conversions:
+	cargo +nightly fuzz run conversions_fuzzer --fuzz-dir=./felt

fuzz/README.md

@@ -0,0 +1,13 @@
+# Fuzzing
+
+This directory contains the fuzzing infrastructure for the `types-rs` project.
+
+## Setup
+```
+cargo install cargo-fuzz
+```
+
+## Running the fuzzers
+* cd into one of the directories, e.g., `cd felt`
+* list the available fuzz targets, e.g., `cargo fuzz list --fuzz-dir=.`
+* run the fuzzer, e.g., `cargo +nightly fuzz run add_fuzzer  --fuzz-dir=.`

fuzz/felt/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "fuzzing_felt"
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+homepage = "https://github.com/starknet-io/types-rs"
+repository = "https://github.com/starknet-io/types-rs"
+categories = ["types", "math", "crypto", "fuzzing"]
+keywords = ["stark", "zkp", "cairo", "fuzzing"]
+description = "Fuzzing crate for the starknet common felt type"
+readme = "README.md"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+starknet-types-core = { path = "../../crates/starknet-types-core", default-features = false, features = ["arbitrary", "alloc"] }
+libfuzzer-sys.workspace = true
+num-bigint = "0.4.4"
+num-traits = "0.2.18"
+lambdaworks-math = { version = "0.7.0", default-features = false }
+
+[[bin]]
+name = "add_sub_fuzzer"
+path = "fuzz_targets/add_sub.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "mul_fuzzer"
+path = "fuzz_targets/mul.rs"
+test = false
+doc = false
+[[bin]]
+name = "conversions_fuzzer"
+path = "fuzz_targets/conversions.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "div_fuzzer"
+path = "fuzz_targets/div.rs"
+test = false
+doc = false
+bench = false

fuzz/felt/README.md

@@ -0,0 +1,58 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use starknet_types_core::felt::Felt;
+
+fuzz_target!(|data: (Felt, Felt)| {
+    let zero = Felt::ZERO;
+    let one = Felt::ONE;
+    let max = Felt::MAX;
+    let (a, b) = data;
+
+    // Check a + 0 = a
+    assert_eq!(a + zero, a);
+    assert_eq!(b + zero, b);
+
+    // Check a - 0 = a
+    assert_eq!(a - zero, a);
+    assert_eq!(b - zero, b);
+
+    // Check a - a = 0
+    assert_eq!(a - a, zero);
+    assert_eq!(b - b, zero);
+
+    // Check a + (-a) = 0
+    assert_eq!(a + (-a), zero);
+    assert_eq!(b + (-b), zero);
+
+    // Check a + b = a - (-b)
+    assert_eq!(a + b, a - (-b));
+
+    // Check a + a = a - (-a)
+    assert_eq!(a + a, a - (-a));
+    assert_eq!(b + b, b - (-b));
+
+    // Check a + a = 2 * a
+    assert_eq!(a + a, Felt::TWO * a);
+    assert_eq!(b + b, Felt::TWO * b);
+
+    // Check a + b = b + a
+    assert_eq!(a + b, b + a);
+
+    // Check (a + b) + b = a + (b + b)
+    assert_eq!((a + b) + b, a + (b + b));
+
+    // Check a + max = a - 1
+    assert_eq!(a + max, a - one);
+    assert_eq!(b + max, b - one);
+
+    // Check 0 - a = max - a + 1
+    assert_eq!(zero - a, max - a + one);
+    assert_eq!(zero - b, max - b + one);
+
+    // Check a + b = (a.to_biguint() + b.to_biguint()) % PRIME
+    assert_eq!(a + b, Felt::from(a.to_biguint() + b.to_biguint()));
+
+    // a.double = a + a
+    assert_eq!(a.double(), a + a);
+    assert_eq!(b.double(), b + b);
+});

fuzz/felt/fuzz_targets/add_sub.rs

@@ -0,0 +1,78 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use starknet_types_core::felt::Felt;
+
+use num_bigint::BigUint;
+use num_traits::{One, Zero};
+
+use lambdaworks_math::unsigned_integer::element::UnsignedInteger;
+
+fn pad_left_with_0(v: Vec<u8>) -> Vec<u8> {
+    let mut padded = vec![0; 32_usize.saturating_sub(v.len())];
+    padded.extend(v);
+    padded
+}
+
+fn pad_right_with_0(v: Vec<u8>) -> Vec<u8> {
+    let padded = vec![0; 32_usize.saturating_sub(v.len())];
+    [v, padded].concat()
+}
+
+fuzz_target!(|felt: Felt| {
+    // to_bytes_be, to_bytes_le
+    assert_eq!(felt, Felt::from_bytes_be(&felt.to_bytes_be()));
+    assert_eq!(felt, Felt::from_bytes_le(&felt.to_bytes_le()));
+    assert_eq!(felt, Felt::from_bytes_be_slice(&felt.to_bytes_be()));
+    assert_eq!(felt, Felt::from_bytes_le_slice(&felt.to_bytes_le()));
+
+    // to_bits_be
+    let felt_as_bits = &felt.to_bits_be();
+    let felt_as_buint = felt.to_biguint();
+    for i in 0..256 {
+        let bit = (&felt_as_buint & (BigUint::one() << i)) != BigUint::zero();
+        assert_eq!(felt_as_bits[255 - i], bit);
+    }
+
+    // to_bits_le
+    let felt_as_bits = &felt.to_bits_le();
+    for i in 0..256 {
+        let bit = (&felt_as_buint & (BigUint::one() << i)) != BigUint::zero();
+        assert_eq!(felt_as_bits[i], bit);
+    }
+
+    // to_hex_string, to_fixed_hex_string, from_hex_unchecked
+    assert_eq!(felt, Felt::from_hex_unchecked(&felt.to_hex_string()));
+    assert_eq!(felt, Felt::from_hex_unchecked(&felt.to_fixed_hex_string()));
+    assert_eq!(66, felt.to_fixed_hex_string().len());
+
+    // from_dec_str
+    assert_eq!(
+        felt,
+        Felt::from_dec_str(&felt_as_buint.to_string()).unwrap()
+    );
+
+    // to_bytes_be, to_bytes_le, to_big_uint
+    assert_eq!(
+        felt.to_bytes_be().to_vec(),
+        pad_left_with_0(felt_as_buint.to_bytes_be())
+    );
+    assert_eq!(
+        felt.to_bytes_le().to_vec(),
+        pad_right_with_0(felt_as_buint.to_bytes_le())
+    );
+
+    // to_raw, from_raw
+    assert_eq!(felt, Felt::from_raw(felt.to_raw()));
+
+    // to_be_digits, to_le_digits
+    assert_eq!(
+        UnsignedInteger::<4>::from_hex(&felt.to_hex_string()).unwrap(),
+        UnsignedInteger::<4>::from_limbs(felt.to_be_digits())
+    );
+    let mut le_digits_reversed = felt.to_le_digits();
+    le_digits_reversed.reverse();
+    assert_eq!(
+        UnsignedInteger::<4>::from_hex(&felt.to_hex_string()).unwrap(),
+        UnsignedInteger::<4>::from_limbs(le_digits_reversed)
+    );
+});

fuzz/felt/fuzz_targets/conversions.rs

@@ -0,0 +1,52 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use starknet_types_core::felt::{Felt, NonZeroFelt};
+
+fuzz_target!(|data: (Felt, Felt)| {
+    let zero = Felt::ZERO;
+    let one = Felt::ONE;
+
+    let (a, b) = data;
+
+    // Check a/a  = 1
+    if a != zero {
+        let a_non_zero = NonZeroFelt::try_from(a).unwrap();
+        assert_eq!(a.field_div(&a_non_zero), one);
+    }
+
+    // Check a / 1 = a
+    assert_eq!(a.field_div(&NonZeroFelt::try_from(one).unwrap()), a);
+
+    // Check a * a^-1 = 1
+    if a != zero {
+        assert_eq!(one, a * a.inverse().unwrap(),);
+    }
+
+    // Check a / b = a * b^-1
+    if b != zero {
+        let b_non_zero = NonZeroFelt::try_from(b).unwrap();
+        let b_inverse = b.inverse().unwrap();
+        assert_eq!(a.field_div(&b_non_zero), a * b_inverse);
+    }
+
+    // Check (a / b) / b  = a / (b * b)
+    if b != zero {
+        let b_non_zero = NonZeroFelt::try_from(b).unwrap();
+        let b_times_b_non_zero = NonZeroFelt::try_from(b * b).unwrap();
+        assert_eq!(
+            a.field_div(&b_non_zero).field_div(&b_non_zero),
+            a.field_div(&b_times_b_non_zero),
+        );
+    }
+
+    // Check a / b = (a.to_biguint() * b^-1.to_biguint()) % PRIME
+    if b != zero {
+        let b_non_zero = NonZeroFelt::try_from(b).unwrap();
+        let b_inverse = b.inverse().unwrap();
+        assert_eq!(
+            a.field_div(&b_non_zero),
+            Felt::from(a.to_biguint() * b_inverse.to_biguint()),
+        );
+    }
+});

fuzz/felt/fuzz_targets/div.rs

@@ -0,0 +1,37 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use starknet_types_core::felt::Felt;
+
+fuzz_target!(|data: (Felt, Felt)| {
+    let zero = Felt::ZERO;
+    let one = Felt::ONE;
+    let (a, b) = data;
+
+    // Check a * 1 = a
+    assert_eq!(a * one, a);
+    assert_eq!(b * one, b);
+
+    // Check 1 * a = a
+    assert_eq!(one * a, a);
+    assert_eq!(one * b, b);
+
+    // Check a * 0 = 0
+    assert_eq!(a * zero, zero);
+    assert_eq!(b * zero, zero);
+
+    // Check 0 * a = a
+    assert_eq!(zero * a, zero);
+    assert_eq!(zero * b, zero);
+
+    // Check a * max = max - a + 1
+    assert_eq!(a * Felt::MAX, Felt::MAX - a + 1);
+
+    // Check a * b = b * a
+    assert_eq!(a * b, b * a);
+
+    // Check a * b = (a.to_biguint() * b.to_biguint()) % PRIME
+    assert_eq!(a * b, Felt::from(a.to_biguint() * b.to_biguint()));
+
+    assert_eq!(a.square(), a * a);
+    assert_eq!(b.square(), b * b);
+});