Trait libafl::mutators::Mutator[−][src]

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>[src]

Mutate a given input

Loading content...

Provided methods

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

Post-process given the outcome of the execution

Loading content...

Implementors

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>, [src]

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

fn post_exec(
    &mut self,
    state: &mut S,
    _stage_idx: i32,
    corpus_idx: Option<usize>
) -> Result<(), Error>[src]

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, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...