From 51aadf525f9ac22ba0afbf127f83e17dacb8f8a8 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Tue, 17 Nov 2026 13:06:31 -0500 Subject: [PATCH] Share deterministic parser damage fixtures without changing their corpus Preserve the fixture helpers originally authored in Craft Anything testkit and extracted by FredApps for TAR. EVM and TAR now reuse craft-testkit with unchanged mutation sequences. Add sequence and stride regressions. Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com> Co-authored-by: Dylan M. Taylor --- Cargo.lock | 2 + crates/evm/Cargo.toml | 3 ++ crates/evm/src/test_support.rs | 38 +-------------- crates/tar/Cargo.toml | 3 ++ crates/tar/src/testkit.rs | 42 +--------------- crates/testkit/src/lib.rs | 1 + crates/testkit/src/sample_damage.rs | 74 +++++++++++++++++++++++++++++ 7 files changed, 85 insertions(+), 78 deletions(-) create mode 100644 crates/testkit/src/sample_damage.rs diff --git a/Cargo.lock b/Cargo.lock index d554ad256..d90e8532b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1885,6 +1885,7 @@ dependencies = [ name = "craft-evm" version = "0.1.0" dependencies = [ + "craft-testkit", "serde", "serde_json", "thiserror 2.0.21", @@ -3139,6 +3140,7 @@ dependencies = [ name = "craft-tar" version = "0.1.0" dependencies = [ + "craft-testkit", "serde", ] diff --git a/crates/evm/Cargo.toml b/crates/evm/Cargo.toml index 92d0abae8..018f5dff0 100644 --- a/crates/evm/Cargo.toml +++ b/crates/evm/Cargo.toml @@ -12,3 +12,6 @@ workspace = true serde = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } + +[dev-dependencies] +craft-testkit = { workspace = true } diff --git a/crates/evm/src/test_support.rs b/crates/evm/src/test_support.rs index b31ace0a2..0dc9861ef 100644 --- a/crates/evm/src/test_support.rs +++ b/crates/evm/src/test_support.rs @@ -60,40 +60,4 @@ pub mod formats { s } } -pub fn noise(seed: u64, len: usize) -> Vec { - let mut x = seed.wrapping_mul(0x9e37_79b9_7f4a_7c15) | 1; - (0..len) - .map(|_| { - x ^= x << 13; - x ^= x >> 7; - x ^= x << 17; - x as u8 - }) - .collect() -} -pub fn mutations(sample: &[u8]) -> Vec> { - let mut out = Vec::new(); - let n = sample.len(); - let step = (n / 64).max(1); - let mut len = 0; - while len < n { - out.push(sample[..len].to_vec()); - len += step; - } - for (i, seed) in (0..n).step_by(step).zip(1u64..) { - let mut m = sample.to_vec(); - let noise = noise(seed, 8); - for (j, v) in noise.iter().enumerate() { - if let Some(b) = m.get_mut(i + j) { - *b = *v; - } - } - out.push(m); - let mut m = sample.to_vec(); - if let Some(b) = m.get_mut(i) { - *b = 0xff; - } - out.push(m); - } - out -} +pub use craft_testkit::sample_damage::{mutations, noise}; diff --git a/crates/tar/Cargo.toml b/crates/tar/Cargo.toml index e0628a35a..e76bb9e4c 100644 --- a/crates/tar/Cargo.toml +++ b/crates/tar/Cargo.toml @@ -16,3 +16,6 @@ serde = { workspace = true, optional = true } [features] serde = ["dep:serde"] + +[dev-dependencies] +craft-testkit = { workspace = true } diff --git a/crates/tar/src/testkit.rs b/crates/tar/src/testkit.rs index 828644a4b..f435b55e5 100644 --- a/crates/tar/src/testkit.rs +++ b/crates/tar/src/testkit.rs @@ -92,44 +92,4 @@ pub fn cpio_newc(files: &[(&str, &[u8], u32)]) -> Vec { out } -/// Deterministic pseudo-random bytes (xorshift) for fuzz-like loops. -pub fn noise(seed: u64, len: usize) -> Vec { - let mut x = seed.wrapping_mul(0x9e37_79b9_7f4a_7c15) | 1; - (0..len) - .map(|_| { - x ^= x << 13; - x ^= x >> 7; - x ^= x << 17; - x as u8 - }) - .collect() -} - -/// Every way to damage a sample used by robustness tests: truncations at many lengths and -/// single-byte corruptions spread across the file. -pub fn mutations(sample: &[u8]) -> Vec> { - let mut out = Vec::new(); - let n = sample.len(); - let step = (n / 64).max(1); - let mut len = 0; - while len < n { - out.push(sample[..len].to_vec()); - len += step; - } - for (i, seed) in (0..n).step_by(step).zip(1u64..) { - let mut m = sample.to_vec(); - let noise = noise(seed, 8); - for (j, v) in noise.iter().enumerate() { - if let Some(b) = m.get_mut(i + j) { - *b = *v; - } - } - out.push(m); - let mut m = sample.to_vec(); - if let Some(b) = m.get_mut(i) { - *b = 0xff; - } - out.push(m); - } - out -} +pub use craft_testkit::sample_damage::{mutations, noise}; diff --git a/crates/testkit/src/lib.rs b/crates/testkit/src/lib.rs index 020938371..910f25518 100644 --- a/crates/testkit/src/lib.rs +++ b/crates/testkit/src/lib.rs @@ -39,6 +39,7 @@ pub mod deadline; pub mod guards; pub mod hostile; +pub mod sample_damage; #[cfg(not(target_arch = "wasm32"))] pub use deadline::{DeadlineLimit, wait_until, with_deadline}; diff --git a/crates/testkit/src/sample_damage.rs b/crates/testkit/src/sample_damage.rs new file mode 100644 index 000000000..33d9632bf --- /dev/null +++ b/crates/testkit/src/sample_damage.rs @@ -0,0 +1,74 @@ +//! Stable sampled truncations and corruptions for existing parser regression corpora. +//! +//! Unlike `hostile::mutations`, this preserves the historical TAR/EVM fixture sequence. + +/// Deterministic pseudo-random bytes (xorshift) for fuzz-like loops. +pub fn noise(seed: u64, len: usize) -> Vec { + let mut x = seed.wrapping_mul(0x9e37_79b9_7f4a_7c15) | 1; + (0..len) + .map(|_| { + x ^= x << 13; + x ^= x >> 7; + x ^= x << 17; + x as u8 + }) + .collect() +} + +/// Every way to damage a sample used by robustness tests: truncations at many lengths and +/// single-byte corruptions spread across the file. +pub fn mutations(sample: &[u8]) -> Vec> { + let mut out = Vec::new(); + let n = sample.len(); + let step = (n / 64).max(1); + let mut len = 0; + while len < n { + out.push(sample[..len].to_vec()); + len += step; + } + for (i, seed) in (0..n).step_by(step).zip(1u64..) { + let mut m = sample.to_vec(); + let noise = noise(seed, 8); + for (j, v) in noise.iter().enumerate() { + if let Some(b) = m.get_mut(i + j) { + *b = *v; + } + } + out.push(m); + let mut m = sample.to_vec(); + if let Some(b) = m.get_mut(i) { + *b = 0xff; + } + out.push(m); + } + out +} + +#[cfg(test)] +mod tests { + use super::{mutations, noise}; + + #[test] + fn fixture_sequence_stays_stable() { + assert_eq!(noise(1, 8), [173, 118, 54, 116, 236, 121, 207, 234]); + assert!(noise(1, 0).is_empty()); + assert!(mutations(&[]).is_empty()); + assert_eq!(mutations(&[42]), vec![vec![], vec![173], vec![255]]); + } + + #[test] + fn sampling_stride_preserves_truncation_and_corruption_order() { + let sample = vec![42; 128]; + let cases = mutations(&sample); + assert_eq!(cases.len(), 192); + for (index, prefix) in cases.iter().take(64).enumerate() { + assert_eq!(prefix, &sample[..index * 2]); + } + for (index, pair) in cases[64..].chunks_exact(2).enumerate() { + assert_eq!(pair[0].len(), sample.len()); + let mut expected = sample.clone(); + expected[index * 2] = 255; + assert_eq!(pair[1], expected); + } + } +}