Struct libafl::fuzzer::StdFuzzer

pub struct StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasClientPerfStats,  { /* fields omitted */ }

Your default fuzzer instance, for everyday use.

Implementations

impl<C, CS, F, I, OF, OT, S, SC> StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasExecutions + HasClientPerfStats, 

pub fn new(scheduler: CS, feedback: F, objective: OF) -> Self

Create a new StdFuzzer with standard behavior.

pub fn execute_input<E, EM>(
    &mut self,
    state: &mut S,
    executor: &mut E,
    event_mgr: &mut EM,
    input: &I
) -> Result<ExitKind, Error> where
    E: Executor<EM, I, S, Self> + HasObservers<I, OT, S>,
    OT: ObserversTuple<I, S>, 

Runs the input and triggers observers and feedback

Trait Implementations

impl<C: Debug, CS: Debug, F: Debug, I: Debug, OF: Debug, OT: Debug, S: Debug, SC: Debug> Debug for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasClientPerfStats, 

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

Formats the value using the given formatter.

impl<C, CS, E, EM, F, I, OF, OT, S, SC> Evaluator<E, EM, I, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    C: Corpus<I>,
    CS: CorpusScheduler<I, S>,
    E: Executor<EM, I, S, Self> + HasObservers<I, OT, S>,
    OT: ObserversTuple<I, S> + Serialize + DeserializeOwned,
    EM: EventManager<E, I, S, Self>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasExecutions + HasCorpus<C, I> + HasSolutions<SC, I> + HasClientPerfStats,
    SC: Corpus<I>, 

fn evaluate_input_events(
    &mut self,
    state: &mut S,
    executor: &mut E,
    manager: &mut EM,
    input: I,
    send_events: bool
) -> Result<(ExecuteInputResult, Option<usize>), Error>

Process one input, adding to the respective corpuses if needed and firing the right events

fn add_input(
    &mut self,
    state: &mut S,
    executor: &mut E,
    manager: &mut EM,
    input: I
) -> Result<usize, Error>

Adds an input, even if it’s not conisered interesting by any of the executors

fn evaluate_input(
    &mut self,
    state: &mut S,
    executor: &mut E,
    manager: &mut EM,
    input: I
) -> Result<(ExecuteInputResult, Option<usize>), Error>

Runs the input and triggers observers and feedback, returns if is interesting an (option) the index of the new testcase in the corpus

impl<C, CS, F, I, OF, OT, S, SC> EvaluatorObservers<I, OT, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    C: Corpus<I>,
    CS: CorpusScheduler<I, S>,
    OT: ObserversTuple<I, S> + Serialize + DeserializeOwned,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasExecutions + HasCorpus<C, I> + HasSolutions<SC, I> + HasClientPerfStats,
    SC: Corpus<I>, 

fn evaluate_input_with_observers<E, EM>(
    &mut self,
    state: &mut S,
    executor: &mut E,
    manager: &mut EM,
    input: I,
    send_events: bool
) -> Result<(ExecuteInputResult, Option<usize>), Error> where
    E: Executor<EM, I, S, Self> + HasObservers<I, OT, S>,
    EM: EventManager<E, I, S, Self>, 

Process one input, adding to the respective corpuses if needed and firing the right events

impl<C, CS, F, I, OF, OT, S, SC> ExecutionProcessor<I, OT, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    C: Corpus<I>,
    SC: Corpus<I>,
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    OT: ObserversTuple<I, S> + Serialize + DeserializeOwned,
    S: HasCorpus<C, I> + HasSolutions<SC, I> + HasClientPerfStats + HasExecutions, 

fn process_execution<EM>(
    &mut self,
    state: &mut S,
    manager: &mut EM,
    input: I,
    observers: &OT,
    exit_kind: &ExitKind,
    send_events: bool
) -> Result<(ExecuteInputResult, Option<usize>), Error> where
    EM: EventFirer<I, S>, 

Evaluate if a set of observation channels has an interesting state

impl<C, CS, E, EM, F, I, OF, OT, S, ST, SC> Fuzzer<E, EM, I, S, ST> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    EM: EventManager<E, I, S, Self>,
    F: Feedback<I, S>,
    I: Input,
    S: HasExecutions + HasClientPerfStats,
    OF: Feedback<I, S>,
    ST: StagesTuple<E, EM, S, Self>, 

fn maybe_report_stats(
    state: &mut S,
    manager: &mut EM,
    last: Duration,
    stats_timeout: Duration
) -> Result<Duration, Error>

Given the last time, if stats_timeout seconds passed, send off an info/stats/heartbeat message to the broker. Returns the new last time (so the old one, unless stats_timeout time has passed and stats have been sent) Will return an crate::Error, if the stats could not be sent.

fn fuzz_one(
    &mut self,
    stages: &mut ST,
    executor: &mut E,
    state: &mut S,
    manager: &mut EM
) -> Result<usize, Error>

Fuzz for a single iteration Returns the index of the last fuzzed corpus item

fn fuzz_loop(
    &mut self,
    stages: &mut ST,
    executor: &mut E,
    state: &mut S,
    manager: &mut EM
) -> Result<usize, Error>

Fuzz forever (or until stopped)

fn fuzz_loop_for(
    &mut self,
    stages: &mut ST,
    state: &mut S,
    executor: &mut E,
    manager: &mut EM,
    iters: u64
) -> Result<usize, Error>

Fuzz for n iterations Returns the index of the last fuzzed corpus item

impl<C, CS, F, I, OF, OT, S, SC> HasCorpusScheduler<CS, I, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasClientPerfStats, 

fn scheduler(&self) -> &CS

The scheduler

fn scheduler_mut(&mut self) -> &mut CS

The scheduler (mut)

impl<C, CS, F, I, OF, OT, S, SC> HasFeedback<F, I, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasClientPerfStats, 

fn feedback(&self) -> &F

The feedback

fn feedback_mut(&mut self) -> &mut F

The feedback (mut)

impl<C, CS, F, I, OF, OT, S, SC> HasObjective<I, OF, S> for StdFuzzer<C, CS, F, I, OF, OT, S, SC> where
    CS: CorpusScheduler<I, S>,
    F: Feedback<I, S>,
    I: Input,
    OF: Feedback<I, S>,
    S: HasClientPerfStats, 

fn objective(&self) -> &OF

The objective feedback

fn objective_mut(&mut self) -> &mut OF

The objective feedback (mut)