Struct libafl::fuzzer::StdFuzzer

source · 
pub struct StdFuzzer<CS, F, OF, OT>
where
    CS: Scheduler,
    F: Feedback<CS::State>,
    OF: Feedback<CS::State>,
    CS::State: HasCorpus,
{ /* private fields */ }
Expand description

Your default fuzzer instance, for everyday use.

Implementations§

source§

impl<CS, F, OF, OT> StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: UsesInput + HasExecutions + HasCorpus,

source

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

Create a new StdFuzzer with standard behavior.

source

pub fn execute_input<E, EM>( &mut self, state: &mut CS::State, executor: &mut E, event_mgr: &mut EM, input: &<CS::State as UsesInput>::Input ) -> Result<ExitKind, Error>
where E: Executor<EM, Self> + HasObservers<Observers = OT, State = CS::State>, EM: UsesState<State = CS::State>, OT: ObserversTuple<CS::State>,

Runs the input and triggers observers and feedback

Trait Implementations§

source§

impl<CS, F, OF, OT: Debug> Debug for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler + Debug, F: Feedback<CS::State> + Debug, OF: Feedback<CS::State> + Debug, CS::State: HasCorpus,

source§

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

Formats the value using the given formatter. Read more
source§

impl<CS, E, EM, F, OF, OT> Evaluator<E, EM> for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, E: HasObservers<State = CS::State, Observers = OT> + Executor<EM, Self>, EM: EventFirer<State = CS::State>, F: Feedback<CS::State>, OF: Feedback<CS::State>, OT: ObserversTuple<CS::State> + Serialize + DeserializeOwned, CS::State: HasCorpus + HasSolutions + HasExecutions + HasImported,

source§

fn evaluate_input_events( &mut self, state: &mut Self::State, executor: &mut E, manager: &mut EM, input: <Self::State as UsesInput>::Input, send_events: bool ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>

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

source§

fn add_input( &mut self, state: &mut Self::State, executor: &mut E, manager: &mut EM, input: <Self::State as UsesInput>::Input ) -> Result<CorpusId, Error>

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

source§

fn add_disabled_input( &mut self, state: &mut Self::State, input: <Self::State as UsesInput>::Input ) -> Result<CorpusId, Error>

Adds the input to the corpus as disabled a 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.
source§

fn evaluate_input( &mut self, state: &mut Self::State, executor: &mut E, manager: &mut EM, input: <Self::State as UsesInput>::Input ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>

Runs the input and triggers observers and feedback, returns if is interesting an (option) the index of the new crate::corpus::Testcase in the corpus
source§

impl<CS, F, OF, OT> EvaluatorObservers<OT> for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, OT: ObserversTuple<CS::State> + Serialize + DeserializeOwned, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus + HasSolutions + HasExecutions + HasImported,

source§

fn evaluate_input_with_observers<E, EM>( &mut self, state: &mut Self::State, executor: &mut E, manager: &mut EM, input: <Self::State as UsesInput>::Input, send_events: bool ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>
where E: Executor<EM, Self> + HasObservers<Observers = OT, State = Self::State>, EM: EventFirer<State = Self::State>,

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

source§

impl<CS, E, EM, F, OF> ExecutesInput<E, EM> for StdFuzzer<CS, F, OF, E::Observers>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, E: Executor<EM, Self> + HasObservers<State = CS::State>, EM: UsesState<State = CS::State>, CS::State: UsesInput + HasExecutions + HasCorpus,

source§

fn execute_input( &mut self, state: &mut CS::State, executor: &mut E, event_mgr: &mut EM, input: &<CS::State as UsesInput>::Input ) -> Result<ExitKind, Error>

Runs the input and triggers observers and feedback

source§

impl<CS, F, OF, OT> ExecutionProcessor<OT> for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, OT: ObserversTuple<CS::State> + Serialize + DeserializeOwned, CS::State: HasCorpus + HasSolutions + HasExecutions + HasImported,

source§

fn process_execution<EM>( &mut self, state: &mut Self::State, manager: &mut EM, input: <Self::State as UsesInput>::Input, exec_res: &ExecuteInputResult, observers: &OT, exit_kind: &ExitKind, send_events: bool ) -> Result<Option<CorpusId>, Error>
where EM: EventFirer<State = Self::State>,

Evaluate if a set of observation channels has an interesting state

source§

fn execute_no_process<EM>( &mut self, state: &mut Self::State, manager: &mut EM, input: &<Self::State as UsesInput>::Input, observers: &OT, exit_kind: &ExitKind ) -> Result<ExecuteInputResult, Error>
where EM: EventFirer<State = Self::State>,

Evaluate if a set of observation channels has an interesting state
source§

fn execute_and_process<EM>( &mut self, state: &mut Self::State, manager: &mut EM, input: <Self::State as UsesInput>::Input, observers: &OT, exit_kind: &ExitKind, send_events: bool ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>
where EM: EventFirer<State = Self::State>,

Evaluate if a set of observation channels has an interesting state
source§

impl<CS, E, EM, F, OF, OT, ST> Fuzzer<E, EM, ST> for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, E: UsesState<State = CS::State>, EM: ProgressReporter + EventProcessor<E, Self, State = CS::State>, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasExecutions + HasMetadata + HasCorpus + HasTestcase + HasImported + HasLastReportTime + HasCurrentCorpusIdx + HasCurrentStage, ST: StagesTuple<E, EM, CS::State, Self>,

source§

fn fuzz_one( &mut self, stages: &mut ST, executor: &mut E, state: &mut CS::State, 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) Read more
source§

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

Fuzz forever (or until stopped)
source§

fn fuzz_loop_for( &mut self, stages: &mut ST, executor: &mut E, state: &mut EM::State, 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) Read more
source§

impl<CS, F, OF, OT> HasFeedback for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus,

§

type Feedback = F

The feedback type
source§

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

The feedback
source§

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

The feedback (mutable)
source§

impl<CS, F, OF, OT> HasObjective for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus,

§

type Objective = OF

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

fn objective(&self) -> &OF

The objective feedback
source§

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

The objective feedback (mutable)
source§

impl<CS, F, OF, OT> HasScheduler for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus,

§

type Scheduler = CS

The Scheduler for this fuzzer
source§

fn scheduler(&self) -> &CS

The scheduler
source§

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

The scheduler (mutable)
source§

impl<CS, F, OF, OT> UsesState for StdFuzzer<CS, F, OF, OT>
where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus,

§

type State = <CS as UsesState>::State

The state known by this type.

Auto Trait Implementations§

§

impl<CS, F, OF, OT> Freeze for StdFuzzer<CS, F, OF, OT>
where CS: Freeze, F: Freeze, OF: Freeze,

§

impl<CS, F, OF, OT> RefUnwindSafe for StdFuzzer<CS, F, OF, OT>
where CS: RefUnwindSafe, F: RefUnwindSafe, OF: RefUnwindSafe, OT: RefUnwindSafe,

§

impl<CS, F, OF, OT> Send for StdFuzzer<CS, F, OF, OT>
where CS: Send, F: Send, OF: Send, OT: Send,

§

impl<CS, F, OF, OT> Sync for StdFuzzer<CS, F, OF, OT>
where CS: Sync, F: Sync, OF: Sync, OT: Sync,

§

impl<CS, F, OF, OT> Unpin for StdFuzzer<CS, F, OF, OT>
where CS: Unpin, F: Unpin, OF: Unpin, OT: Unpin,

§

impl<CS, F, OF, OT> UnwindSafe for StdFuzzer<CS, F, OF, OT>
where CS: UnwindSafe, F: UnwindSafe, OF: UnwindSafe, OT: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Conv for T

source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
source§

impl<T> FmtForward for T

source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

source§

const WITNESS: W = W::MAKE

A constant of the type witness
source§

impl<T> Identity for T
where T: ?Sized,

§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
source§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Pipe for T
where T: ?Sized,

source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<Tail, T> Prepend<T> for Tail

§

type PreprendResult = Tail

The Resulting TupleList, of an Prepend::prepend() call, including the prepended entry.
source§

fn prepend(self, value: T) -> (T, <Tail as Prepend<T>>::PreprendResult)

Prepend a value to this tuple, returning a new tuple with prepended value.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> Tap for T

source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
source§

impl<T> TryConv for T

source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<KS> UsesInput for KS
where KS: UsesState,

§

type Input = <<KS as UsesState>::State as UsesInput>::Input

Type which will be used throughout this state.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> Ungil for T
where T: Send,