Named Mutators and MultiMutator API change

Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
+resolver = "2"
 members = [
     "libafl",
     "libafl_derive",

fuzzers/fuzzbench_forkserver_cmplog/src/main.rs

@@ -26,7 +26,7 @@ use libafl::{
     monitors::SimpleMonitor,
     mutators::{
         scheduled::havoc_mutations, token_mutations::AFLppRedQueen, tokens_mutations,
-        MutationResult, StdMOptMutator, Tokens,
+        StdMOptMutator, Tokens,
     },
     observers::{
         AFLppCmpMap, AFLppForkserverCmpObserver, HitcountsMapObserver, StdMapObserver, TimeObserver,
@@ -35,7 +35,7 @@ use libafl::{
         powersched::PowerSchedule, IndexesLenTimeMinimizerScheduler, StdWeightedScheduler,
     },
     stages::{
-        calibrate::CalibrationStage, mutational::MultipleMutationalStage,
+        calibrate::CalibrationStage, mutational::MultiMutationalStage,
         power::StdPowerMutationalStage, tracing::AFLppCmplogTracingStage, ColorizationStage,
         IfStage,
     },
@@ -368,7 +368,7 @@ fn fuzz(
         let tracing = AFLppCmplogTracingStage::with_cmplog_observer_name(cmplog_executor, "cmplog");
 
         // Setup a randomic Input2State stage
-        let rq = MultipleMutationalStage::new(AFLppRedQueen::with_cmplog_options(true, true));
+        let rq = MultiMutationalStage::new(AFLppRedQueen::with_cmplog_options(true, true));
 
         let cb = |_fuzzer: &mut _,
                   _executor: &mut _,

libafl/src/mutators/mod.rs

@@ -80,7 +80,7 @@ pub enum MutationResult {
 
 /// A mutator takes input, and mutates it.
 /// Simple as that.
-pub trait Mutator<I, S> {
+pub trait Mutator<I, S>: Named {
     /// Mutate a given input
     fn mutate(
         &mut self,
@@ -90,6 +90,7 @@ pub trait Mutator<I, S> {
     ) -> Result<MutationResult, Error>;
 
     /// Post-process given the outcome of the execution
+    #[inline]
     fn post_exec(
         &mut self,
         _state: &mut S,
@@ -102,18 +103,20 @@ pub trait Mutator<I, S> {
 
 /// A mutator that takes input, and returns a vector of mutated inputs.
 /// Simple as that.
-pub trait MultipleMutator<I, S> {
-    /// Mutate a given input
-    fn mutate(
+pub trait MultiMutator<I, S>: Named {
+    /// Mutate a given input up to `max_count` times,
+    /// or as many times as appropriate, if no `max_count` is given
+    fn multi_mutate(
         &mut self,
         state: &mut S,
         input: &I,
-        vec: &mut Vec<I>,
         stage_idx: i32,
-    ) -> Result<MutationResult, Error>;
+        max_count: Option<usize>,
+    ) -> Result<Vec<I>, Error>;
 
     /// Post-process given the outcome of the execution
-    fn post_exec(
+    #[inline]
+    fn multi_post_exec(
         &mut self,
         _state: &mut S,
         _stage_idx: i32,
@@ -158,9 +161,13 @@ pub trait MutatorsTuple<I, S>: HasConstLen {
         stage_idx: i32,
         corpus_idx: Option<CorpusId>,
     ) -> Result<(), Error>;
+
+    /// Gets all names of the wrapped [`Mutator`]`s`.
+    fn names(&self) -> Vec<&str>;
 }
 
 impl<I, S> MutatorsTuple<I, S> for () {
+    #[inline]
     fn mutate_all(
         &mut self,
         _state: &mut S,
@@ -170,6 +177,7 @@ impl<I, S> MutatorsTuple<I, S> for () {
         Ok(MutationResult::Skipped)
     }
 
+    #[inline]
     fn post_exec_all(
         &mut self,
         _state: &mut S,
@@ -179,6 +187,7 @@ impl<I, S> MutatorsTuple<I, S> for () {
         Ok(())
     }
 
+    #[inline]
     fn get_and_mutate(
         &mut self,
         _index: MutationId,
@@ -189,6 +198,7 @@ impl<I, S> MutatorsTuple<I, S> for () {
         Ok(MutationResult::Skipped)
     }
 
+    #[inline]
     fn get_and_post_exec(
         &mut self,
         _index: usize,
@@ -198,11 +208,16 @@ impl<I, S> MutatorsTuple<I, S> for () {
     ) -> Result<(), Error> {
         Ok(())
     }
+
+    #[inline]
+    fn names(&self) -> Vec<&str> {
+        Vec::new()
+    }
 }
 
 impl<Head, Tail, I, S> MutatorsTuple<I, S> for (Head, Tail)
 where
-    Head: Mutator<I, S> + Named,
+    Head: Mutator<I, S>,
     Tail: MutatorsTuple<I, S>,
 {
     fn mutate_all(
@@ -258,16 +273,25 @@ where
                 .get_and_post_exec(index - 1, state, stage_idx, corpus_idx)
         }
     }
+
+    fn names(&self) -> Vec<&str> {
+        let mut ret = self.1.names();
+        ret.insert(0, self.0.name());
+        ret
+    }
 }
 
 /// `Mutator` Python bindings
 #[cfg(feature = "python")]
 #[allow(missing_docs)]
 pub mod pybind {
-    use pyo3::prelude::*;
+    use core::ffi::CStr;
+
+    use pyo3::{prelude::*, AsPyPointer};
 
     use super::{MutationResult, Mutator};
     use crate::{
+        bolts::tuples::Named,
         corpus::CorpusId,
         inputs::{BytesInput, HasBytesVec},
         mutators::scheduled::pybind::PythonStdHavocMutator,
@@ -287,6 +311,14 @@ pub mod pybind {
         }
     }
 
+    impl Named for PyObjectMutator {
+        fn name(&self) -> &str {
+            unsafe { CStr::from_ptr((*(*self.inner.as_ptr()).ob_type).tp_name) }
+                .to_str()
+                .unwrap()
+        }
+    }
+
     impl Mutator<BytesInput, PythonStdState> for PyObjectMutator {
         fn mutate(
             &mut self,
@@ -386,6 +418,15 @@ pub mod pybind {
         }
     }
 
+    impl Named for PythonMutator {
+        fn name(&self) -> &str {
+            match &self.wrapper {
+                PythonMutatorWrapper::Python(pyo) => pyo.name(),
+                PythonMutatorWrapper::StdHavoc(_) => "StdHavocPythonMutator",
+            }
+        }
+    }
+
     impl Mutator<BytesInput, PythonStdState> for PythonMutator {
         fn mutate(
             &mut self,

libafl/src/mutators/mopt_mutator.rs

@@ -1,5 +1,8 @@
 //! The `MOpt` mutator scheduler, see <https://github.com/puppet-meteor/MOpt-AFL> and <https://www.usenix.org/conference/usenixsecurity19/presentation/lyu>
-use alloc::{string::ToString, vec::Vec};
+use alloc::{
+    string::{String, ToString},
+    vec::Vec,
+};
 use core::{
     fmt::{self, Debug},
     marker::PhantomData,
@@ -9,7 +12,10 @@ use serde::{Deserialize, Serialize};
 
 use super::MutationId;
 use crate::{
-    bolts::rands::{Rand, StdRand},
+    bolts::{
+        rands::{Rand, StdRand},
+        tuples::Named,
+    },
     corpus::{Corpus, CorpusId},
     mutators::{ComposedByMutations, MutationResult, Mutator, MutatorsTuple, ScheduledMutator},
     state::{HasCorpus, HasMetadata, HasRand, HasSolutions},
@@ -365,6 +371,7 @@ where
     MT: MutatorsTuple<I, S>,
     S: HasRand + HasMetadata + HasCorpus + HasSolutions,
 {
+    name: String,
     mode: MOptMode,
     finds_before: usize,
     mutations: MT,
@@ -539,6 +546,7 @@ where
             state.add_metadata::<MOpt>(MOpt::new(mutations.len(), swarm_num, rand_seed)?);
         }
         Ok(Self {
+            name: format!("StdMOptMutator[{}]", mutations.names().join(",")),
             mode: MOptMode::Pilotfuzzing,
             finds_before: 0,
             mutations,
@@ -632,6 +640,16 @@ where
     }
 }
 
+impl<I, MT, S> Named for StdMOptMutator<I, MT, S>
+where
+    MT: MutatorsTuple<I, S>,
+    S: HasRand + HasMetadata + HasCorpus + HasSolutions,
+{
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 impl<I, MT, S> ScheduledMutator<I, MT, S> for StdMOptMutator<I, MT, S>
 where
     MT: MutatorsTuple<I, S>,

libafl/src/mutators/scheduled.rs

@@ -13,7 +13,7 @@ pub use crate::mutators::{mutations::*, token_mutations::*};
 use crate::{
     bolts::{
         rands::Rand,
-        tuples::{tuple_list, tuple_list_type, NamedTuple},
+        tuples::{tuple_list, tuple_list_type, Named, NamedTuple},
         AsMutSlice, AsSlice,
     },
     corpus::{Corpus, CorpusId},
@@ -106,6 +106,7 @@ where
     MT: MutatorsTuple<I, S>,
     S: HasRand,
 {
+    name: String,
     mutations: MT,
     max_stack_pow: u64,
     phantom: PhantomData<(I, S)>,
@@ -126,6 +127,16 @@ where
     }
 }
 
+impl<I, MT, S> Named for StdScheduledMutator<I, MT, S>
+where
+    MT: MutatorsTuple<I, S>,
+    S: HasRand,
+{
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 impl<I, MT, S> Mutator<I, S> for StdScheduledMutator<I, MT, S>
 where
     MT: MutatorsTuple<I, S>,
@@ -185,6 +196,7 @@ where
     /// Create a new [`StdScheduledMutator`] instance specifying mutations
     pub fn new(mutations: MT) -> Self {
         StdScheduledMutator {
+            name: format!("StdScheduledMutator[{}]", mutations.names().join(", ")),
             mutations,
             max_stack_pow: 7,
             phantom: PhantomData,
@@ -194,6 +206,7 @@ where
     /// Create a new [`StdScheduledMutator`] instance specifying mutations and the maximun number of iterations
     pub fn with_max_stack_pow(mutations: MT, max_stack_pow: u64) -> Self {
         StdScheduledMutator {
+            name: format!("StdScheduledMutator[{}]", mutations.names().join(", ")),
             mutations,
             max_stack_pow,
             phantom: PhantomData,
@@ -279,6 +292,7 @@ where
     S: HasRand + HasCorpus,
     SM: ScheduledMutator<I, MT, S>,
 {
+    name: String,
     scheduled: SM,
     mutation_log: Vec<MutationId>,
     phantom: PhantomData<(I, MT, S)>,
@@ -300,6 +314,17 @@ where
     }
 }
 
+impl<I, MT, S, SM> Named for LoggerScheduledMutator<I, MT, S, SM>
+where
+    MT: MutatorsTuple<I, S> + NamedTuple,
+    S: HasRand + HasCorpus,
+    SM: ScheduledMutator<I, MT, S>,
+{
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 impl<I, MT, S, SM> Mutator<I, S> for LoggerScheduledMutator<I, MT, S, SM>
 where
     MT: MutatorsTuple<I, S> + NamedTuple,
@@ -403,9 +428,11 @@ where
     S: HasRand + HasCorpus,
     SM: ScheduledMutator<I, MT, S>,
 {
-    /// Create a new [`StdScheduledMutator`] instance without mutations and corpus
+    /// Create a new [`LoggerScheduledMutator`] instance without mutations and corpus
+    /// This mutator logs all mutators.
     pub fn new(scheduled: SM) -> Self {
         Self {
+            name: format!("LoggerScheduledMutator[{}]", scheduled.name()),
             scheduled,
             mutation_log: vec![],
             phantom: PhantomData,