Struct StdFuzzer

pub struct StdFuzzer<CS, F, IC, IF, OF> { /* private fields */ }

Your default fuzzer instance, for everyday use.

Implementations

impl<CS, F, OF> StdFuzzer<CS, F, NopBytesConverter, NopInputFilter, OF>

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

Create a new StdFuzzer with standard behavior and no duplicate input execution filtering.

Trait Implementations

impl<CS: Debug, F: Debug, IC: Debug, IF: Debug, OF: Debug> Debug for StdFuzzer<CS, F, IC, IF, OF>

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

Formats the value using the given formatter.

impl<CS, E, EM, F, I, IC, IF, OF, S> Evaluator<E, EM, I, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, E: HasObservers + Executor<EM, I, S, Self>, E::Observers: MatchName + ObserversTuple<I, S> + Serialize, EM: EventFirer<I, S>, F: Feedback<EM, I, E::Observers, S>, OF: Feedback<EM, I, E::Observers, S>, S: HasCorpus<I> + HasSolutions<I> + MaybeHasClientPerfMonitor + HasCurrentTestcase<I> + HasLastFoundTime + HasExecutions, I: Input, IF: InputFilter<I>,

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

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

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

Adds an input, even if it’s not considered interesting by any of the executors If you are using inprocess executor, be careful. Your crash-causing testcase will NOT be added into the corpus (only to solution)

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

Runs the input if it was (likely) not previously run and triggers observers and feedback and adds the input to the previously executed list if it is interesting, returns an (option) the index of the new Testcase in the corpus

fn add_disabled_input( &mut self, state: &mut S, input: I, ) -> Result<CorpusId, Error>

Adds the input to the corpus as a disabled input. Used during initial corpus loading. Disabled testcases are only used for splicing Returns the index of the new testcase in the corpus. Usually, you want to use Evaluator::evaluate_input, unless you know what you are doing.

impl<CS, E, EM, F, I, IC, IF, OF, S> EvaluatorObservers<E, EM, I, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, E: HasObservers + Executor<EM, I, S, Self>, E::Observers: MatchName + ObserversTuple<I, S> + Serialize, EM: EventFirer<I, S>, F: Feedback<EM, I, E::Observers, S>, OF: Feedback<EM, I, E::Observers, S>, S: HasCorpus<I> + HasSolutions<I> + MaybeHasClientPerfMonitor + HasCurrentTestcase<I> + HasExecutions + HasLastFoundTime, I: Input,

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

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

impl<CS, E, EM, F, I, IC, IF, OF, S> EventProcessor<E, EM, I, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, E: HasObservers + Executor<EM, I, S, Self>, E::Observers: DeserializeOwned + Serialize + ObserversTuple<I, S>, EM: EventReceiver<I, S> + EventFirer<I, S>, F: Feedback<EM, I, E::Observers, S>, I: Input, OF: Feedback<EM, I, E::Observers, S>, S: HasCorpus<I> + HasSolutions<I> + HasExecutions + HasLastFoundTime + MaybeHasClientPerfMonitor + HasCurrentCorpusId + HasImported,

fn process_events( &mut self, state: &mut S, executor: &mut E, manager: &mut EM, ) -> Result<(), Error>

Asks event manager to see if there’s any event to evaluate If there is any, then evaluates it. After, run the post processing routines, for example, re-sending the events to the other

impl<CS, E, EM, F, I, IC, IF, OF, S> ExecutesInput<E, EM, I, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, E: Executor<EM, I, S, Self> + HasObservers, E::Observers: ObserversTuple<I, S>, S: HasExecutions + HasCorpus<I> + MaybeHasClientPerfMonitor,

fn execute_input( &mut self, state: &mut S, executor: &mut E, event_mgr: &mut EM, input: &I, ) -> Result<ExitKind, Error>

Runs the input and triggers observers and feedback

impl<CS, EM, F, I, IC, IF, OF, OT, S> ExecutionProcessor<EM, I, OT, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, EM: EventFirer<I, S>, F: Feedback<EM, I, OT, S>, I: Input, OF: Feedback<EM, I, OT, S>, OT: ObserversTuple<I, S> + Serialize, S: HasCorpus<I> + MaybeHasClientPerfMonitor + HasExecutions + HasCurrentTestcase<I> + HasSolutions<I> + HasLastFoundTime,

fn process_execution( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, exit_kind: &ExitKind, observers: &OT, ) -> Result<Option<CorpusId>, Error>

Post process a testcase depending the testcase execution results returns corpus id if it put something into corpus (not solution) This code will not be reached by inprocess executor if crash happened.

fn check_results( &mut self, state: &mut S, manager: &mut EM, input: &I, observers: &OT, exit_kind: &ExitKind, ) -> Result<ExecuteInputResult, Error>

Check the outcome of the execution, find if it is worth for corpus or objectives

fn serialize_and_dispatch( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, observers: &OT, exit_kind: &ExitKind, ) -> Result<(), Error>

serialize and send event via manager

fn dispatch_event( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, observers_buf: Option<Vec<u8>>, exit_kind: &ExitKind, ) -> Result<(), Error>

send event via manager

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

Evaluate if a set of observation channels has an interesting state

impl<CS, E, EM, F, I, IC, IF, OF, S, ST> Fuzzer<E, EM, I, S, ST> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, E: HasObservers + Executor<EM, I, S, Self>, E::Observers: DeserializeOwned + Serialize + ObserversTuple<I, S>, EM: EventFirer<I, S> + ProgressReporter<S> + SendExiting + EventReceiver<I, S>, I: Input, F: Feedback<EM, I, E::Observers, S>, OF: Feedback<EM, I, E::Observers, S>, S: HasExecutions + HasMetadata + HasCorpus<I> + HasSolutions<I> + HasLastReportTime + HasLastFoundTime + HasImported + HasTestcase<I> + HasCurrentCorpusId + HasCurrentStageId + Stoppable + MaybeHasClientPerfMonitor, ST: StagesTuple<E, EM, S, Self>,

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

Fuzz for a single iteration. Returns the index of the last fuzzed corpus item. (Note: An iteration represents a complete run of every stage. Therefore, it does not mean that the harness is executed for once, because each stage could run the harness for multiple times)

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

Fuzz forever (or until stopped)

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

Fuzz for n iterations. Returns the index of the last fuzzed corpus item. (Note: An iteration represents a complete run of every stage. therefore the number n is not always equal to the number of the actual harness executions, because each stage could run the harness for multiple times)

impl<CS, F, IC, IF, OF> HasBytesConverter for StdFuzzer<CS, F, IC, IF, OF>

type Converter = IC

The converter itself

fn converter(&self) -> &Self::Converter

the input converter

fn converter_mut(&mut self) -> &mut Self::Converter

the input converter(mut)

impl<CS, F, IC, IF, OF> HasFeedback for StdFuzzer<CS, F, IC, IF, OF>

type Feedback = F

The feedback type

fn feedback(&self) -> &Self::Feedback

The feedback

fn feedback_mut(&mut self) -> &mut Self::Feedback

The feedback (mutable)

impl<CS, F, IC, IF, OF> HasObjective for StdFuzzer<CS, F, IC, IF, OF>

type Objective = OF

The type of the Feedback used to find objectives for this fuzzer

fn objective(&self) -> &OF

The objective feedback

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

The objective feedback (mutable)

fn set_share_objectives(&mut self, share_objectives: bool)

Sets whether to share objectives among nodes

fn share_objectives(&self) -> bool

Whether to share objective testcases among fuzzing nodes

impl<CS, F, I, IC, IF, OF, S> HasScheduler<I, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>,

type Scheduler = CS

The Scheduler for this fuzzer

fn scheduler(&self) -> &CS

The scheduler

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

The scheduler (mutable)