Trait libafl::mutators::Mutator

pub trait Mutator<I, S> where
    I: Input, {
    fn mutate(
        &mut self, 
        state: &mut S, 
        input: &mut I, 
        stage_idx: i32
    ) -> Result<MutationResult, Error>;

    fn post_exec(
        &mut self, 
        _state: &mut S, 
        _stage_idx: i32, 
        _corpus_idx: Option<usize>
    ) -> Result<(), Error> { ... }
}

A mutator takes input, and mutates it. Simple as that.

Required methods

fn mutate(
    &mut self,
    state: &mut S,
    input: &mut I,
    stage_idx: i32
) -> Result<MutationResult, Error>

Mutate a given input

Provided methods

fn post_exec(
    &mut self,
    _state: &mut S,
    _stage_idx: i32,
    _corpus_idx: Option<usize>
) -> Result<(), Error>

Post-process given the outcome of the execution

Implementors

impl<C, I, MT, R, S, SC> Mutator<I, S> for StdMOptMutator<C, I, MT, R, S, SC> where
    C: Corpus<I>,
    I: Input,
    MT: MutatorsTuple<I, S>,
    R: Rand,
    S: HasRand<R> + HasMetadata + HasCorpus<C, I> + HasSolutions<SC, I>,
    SC: Corpus<I>, 

impl<C, I, MT, R, S, SM> Mutator<I, S> for LoggerScheduledMutator<C, I, MT, R, S, SM> where
    C: Corpus<I>,
    I: Input,
    MT: MutatorsTuple<I, S> + NamedTuple,
    R: Rand,
    S: HasRand<R> + HasCorpus<C, I>,
    SM: ScheduledMutator<I, MT, S>, 

impl<C, I, R, S> Mutator<I, S> for CrossoverInsertMutator<C, I, R, S> where
    C: Corpus<I>,
    I: Input + HasBytesVec,
    R: Rand,
    S: HasRand<R> + HasCorpus<C, I> + HasMaxSize, 

impl<C, I, R, S> Mutator<I, S> for CrossoverReplaceMutator<C, I, R, S> where
    C: Corpus<I>,
    I: Input + HasBytesVec,
    R: Rand,
    S: HasRand<R> + HasCorpus<C, I>, 

impl<C, I, R, S> Mutator<I, S> for SpliceMutator<C, I, R, S> where
    C: Corpus<I>,
    I: Input + HasBytesVec,
    R: Rand,
    S: HasRand<R> + HasCorpus<C, I>, 

impl<I, MT, R, S> Mutator<I, S> for StdScheduledMutator<I, MT, R, S> where
    I: Input,
    MT: MutatorsTuple<I, S>,
    R: Rand,
    S: HasRand<R>, 

impl<I, R, S> Mutator<I, S> for BitFlipMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteAddMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteDecMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteFlipMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteIncMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteInterestingMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteNegMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for ByteRandMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesCopyMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesDeleteMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesExpandMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R> + HasMaxSize,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesInsertMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R> + HasMaxSize,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesRandInsertMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R> + HasMaxSize,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesRandSetMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesSetMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for BytesSwapMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for DwordAddMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for DwordInterestingMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for QwordAddMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for WordAddMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for WordInterestingMutator<I, R, S> where
    I: Input + HasBytesVec,
    S: HasRand<R>,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for I2SRandReplace<I, R, S> where
    I: Input + HasBytesVec,
    S: HasMetadata + HasRand<R> + HasMaxSize,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for TokenInsert<I, R, S> where
    I: Input + HasBytesVec,
    S: HasMetadata + HasRand<R> + HasMaxSize,
    R: Rand, 

impl<I, R, S> Mutator<I, S> for TokenReplace<I, R, S> where
    I: Input + HasBytesVec,
    S: HasMetadata + HasRand<R> + HasMaxSize,
    R: Rand,