From 3a74f5335aa3698e59a8ac12aadd4d5207668d14 Mon Sep 17 00:00:00 2001
From: Dominik Maier <domenukk@gmail.com>
Date: Fri, 8 Jan 2021 19:14:08 +0100
Subject: [PATCH] make mutators easier to use

---
 afl/src/executors/inmemory.rs |   2 +-
 afl/src/mutators/mutations.rs | 118 ++++++++++++----------------------
 2 files changed, 42 insertions(+), 78 deletions(-)

diff --git a/afl/src/executors/inmemory.rs b/afl/src/executors/inmemory.rs
index 1e19e75e79..d11d0dd006 100644
--- a/afl/src/executors/inmemory.rs
+++ b/afl/src/executors/inmemory.rs
@@ -318,7 +318,7 @@ mod tests {
     use alloc::boxed::Box;
 
     use crate::{
-        executors::{inmemory::InMemoryExecutor, Executor, ExitKind},
+        executors::{Executor, ExitKind, InMemoryExecutor},
         inputs::NopInput,
         tuples::tuple_list,
     };
diff --git a/afl/src/mutators/mutations.rs b/afl/src/mutators/mutations.rs
index e487b7955c..80999bc6bb 100644
--- a/afl/src/mutators/mutations.rs
+++ b/afl/src/mutators/mutations.rs
@@ -104,14 +104,12 @@ fn mem_set(data: &mut [u8], from: usize, len: usize, val: u8) {
 
 /// Bitflip mutation for inputs with a bytes vector
 pub fn mutation_bitflip<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -128,14 +126,12 @@ where
 }
 
 pub fn mutation_byteflip<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -152,14 +148,12 @@ where
 }
 
 pub fn mutation_byteinc<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -177,14 +171,12 @@ where
 }
 
 pub fn mutation_bytedec<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -202,14 +194,12 @@ where
 }
 
 pub fn mutation_byteneg<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -226,14 +216,12 @@ where
 }
 
 pub fn mutation_byterand<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -250,14 +238,12 @@ where
 }
 
 pub fn mutation_byteadd<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -279,14 +265,12 @@ where
 }
 
 pub fn mutation_wordadd<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -310,14 +294,12 @@ where
 }
 
 pub fn mutation_dwordadd<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -341,14 +323,12 @@ where
 }
 
 pub fn mutation_qwordadd<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -372,14 +352,12 @@ where
 }
 
 pub fn mutation_byteinteresting<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -397,14 +375,12 @@ where
 }
 
 pub fn mutation_wordinteresting<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -427,14 +403,12 @@ where
 }
 
 pub fn mutation_dwordinteresting<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -457,14 +431,12 @@ where
 }
 
 pub fn mutation_bytesdelete<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -481,9 +453,10 @@ where
 }
 
 pub fn mutation_bytesexpand<M, C, I, R>(
+    // TODO: max_size instead of mutator?
     mutator: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
@@ -508,7 +481,7 @@ where
 pub fn mutation_bytesinsert<M, C, I, R>(
     mutator: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
@@ -535,7 +508,7 @@ where
 pub fn mutation_bytesrandinsert<M, C, I, R>(
     mutator: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
@@ -560,14 +533,12 @@ where
 }
 
 pub fn mutation_bytesset<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -588,14 +559,12 @@ where
 }
 
 pub fn mutation_bytesrandset<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -616,14 +585,12 @@ where
 }
 
 pub fn mutation_bytescopy<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -641,14 +608,12 @@ where
 }
 
 pub fn mutation_bytesswap<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
-    _corpus: &C,
+    _: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
-    C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
@@ -685,13 +650,12 @@ fn locate_diffs(this: &[u8], other: &[u8]) -> (i64, i64) {
 
 /// Splicing mutator
 pub fn mutation_splice<M, C, I, R>(
-    _mutator: &mut M,
+    _: &mut M,
     rand: &mut R,
     corpus: &C,
     input: &mut I,
 ) -> Result<MutationResult, AflError>
 where
-    M: Mutator<C, I, R>,
     C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,