Struct lain::mutator::Mutator

pub struct Mutator<R: Rng> {
    pub rng: R,
    // some fields omitted
}

Object which provides helper routines for mutating data structures and RNG management.

Fields

rng: R

Methods

impl<R: Rng> Mutator<R>

pub fn new(rng: R) -> Mutator<R>

pub fn set_mode(&mut self, mode: MutatorMode)

pub fn mode(&self) -> MutatorMode

pub fn get_corpus_state(&self) -> CorpusFuzzingState

pub fn set_corpus_state(&mut self, state: CorpusFuzzingState)

pub fn gen<T: 'static>(&mut self) -> T where
    T: NewFuzzed, 

Generates a random choice of the given type

pub fn mutate_from_mutation_mode<T>(&mut self, mn: &mut T) where
    T: BitXor<Output = T> + Add<Output = T> + Sub<Output = T> + WrappingAdd<Output = T> + WrappingSub<Output = T> + NumCast + Bounded + Copy + DangerousNumber<T> + Display, 

TODO: Change function name. Mutates mn while taking into consideration the current mutator mode.

pub fn next_mode<T: Bounded + NumCast + DangerousNumber<T>>(&mut self)

Manages the mutator mode state machine.

This will basically:

• Swap between the different MutatorModes. This will transition from walking bit flips to dangerous numbers, to havoc mode.
• For each mode, determine if there are any any other substates to exhaust (e.g. more bits to flip, more dangerous numbers to select), and update the state accordingly for the next iteration. If no other substates exist, the hard MutatorMode state will move to the next enum variant. Before reaching the MutatorMode::Havoc state, each subsequent mode will check if the last field has been mutated yet. If not, the state will reset to MutatorMode::WalkingBitFlip and adjust the current member index being fuzzed.
• Once all members have been fuzzed in all MutatorModes, the mode is set to MutatorMode::Havoc.

pub fn mutate<T>(&mut self, num: &mut T) where
    T: BitXor<Output = T> + Add<Output = T> + Sub<Output = T> + NumCast + Bounded + Copy + WrappingAdd<Output = T> + WrappingSub<Output = T>, 

Mutates a number after randomly selecting a mutation strategy (see [MutatorOperation] for a list of strategies) If a min/max is specified then a new number in this range is chosen instead of performing a bit/arithmetic mutation

pub fn gen_range<T, B1>(&mut self, min: B1, max: B1) -> T where
    T: SampleUniform + Display,
    B1: SampleBorrow<T> + Display + Add + Mul + NumCast + Sub + PartialEq + PartialOrd, 

Generates a number in the range from [min, max) (note: non-inclusive). Panics if min >= max.

pub fn gen_weighted_range<T, B1>(
    &mut self,
    min: B1,
    max: B1,
    weighted: Weighted
) -> T where
    T: SampleUniform + Display + NumCast,
    B1: SampleBorrow<T> + Display + Debug + Add<Output = B1> + Mul<Output = B1> + NumCast + Sub<Output = B1> + PartialEq + PartialOrd + Copy + Div<Output = B1>, 

Generates a number weighted to one end of the interval

pub fn gen_chance_to_mutate_field(&mut self, chance_percentage: f32) -> bool

Generates the chance to mutate a field. This will always return true if the current mode is MutatorMode::Havoc.

pub fn should_early_bail_mutation(&self) -> bool

Helper function for quitting the recursive mutation early if the target field has already been mutated.

pub fn gen_chance(&mut self, chance_percentage: f32) -> bool

Returns a boolean value indicating whether or not the chance event occurred

pub fn should_fixup(&mut self) -> bool

Returns a boolean indicating whether or not post mutation steps should be taken

pub fn begin_new_iteration(&mut self)

Client code should call this to signal to the mutator that a new fuzzer iteration is beginning and that the mutator should reset internal state.

pub fn begin_new_corpus(&mut self)

Resets the corpus state and current mutation mode.

Trait Implementations

impl<R: Debug + Rng> Debug for Mutator<R>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.