Trait libafl::stages::Stage

pub trait Stage<E, EM, Z>: UsesState
where
    E: UsesState<State = Self::State>,
    EM: UsesState<State = Self::State>,
    Z: UsesState<State = Self::State>,
{
    // Required method
    fn perform(
        &mut self,
        fuzzer: &mut Z,
        executor: &mut E,
        state: &mut Self::State,
        manager: &mut EM,
        corpus_idx: CorpusId
    ) -> Result<(), Error>;
}

A stage is one step in the fuzzing process. Multiple stages will be scheduled one by one for each input.

Required Methods

fn perform( &mut self, fuzzer: &mut Z, executor: &mut E, state: &mut Self::State, manager: &mut EM, corpus_idx: CorpusId ) -> Result<(), Error>

Run the stage

Implementors

impl Stage<PythonExecutor, PythonEventManager, StdFuzzer<QueueScheduler<StdState<BytesInput, PythonCorpus, PythonRand, PythonCorpus>>, PythonFeedback, PythonFeedback, PythonObserversTuple>> for PyObjectStage

impl Stage<PythonExecutor, PythonEventManager, StdFuzzer<QueueScheduler<StdState<BytesInput, PythonCorpus, PythonRand, PythonCorpus>>, PythonFeedback, PythonFeedback, PythonObserversTuple>> for PythonStage

impl<CB, E, EM, ST1, ST2, Z> Stage<E, EM, Z> for IfElseStage<CB, E, EM, ST1, ST2, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM, CorpusId) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST1: StagesTuple<E, EM, E::State, Z>, ST2: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

impl<CB, E, EM, ST, Z> Stage<E, EM, Z> for IfStage<CB, E, EM, ST, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM, CorpusId) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

impl<CB, E, EM, ST, Z> Stage<E, EM, Z> for WhileStage<CB, E, EM, ST, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM, CorpusId) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

impl<CB, E, EM, Z> Stage<E, EM, Z> for DumpToDiskStage<CB, EM, Z>

where CB: FnMut(&<Z::State as UsesInput>::Input, &Z::State) -> Vec<u8>, EM: UsesState<State = Z::State>, E: UsesState<State = Z::State>, Z: UsesState, Z::State: HasCorpus + HasSolutions + HasRand + HasMetadata,

impl<CB, E, EM, Z> Stage<E, EM, Z> for ClosureStage<CB, E, EM, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM, CorpusId) -> Result<(), Error>, E: UsesState, EM: UsesState<State = E::State>, Z: UsesState<State = E::State>,

impl<CB, E, EM, Z> Stage<E, EM, Z> for SyncFromDiskStage<CB, E, EM, Z>

where CB: FnMut(&mut Z, &mut Z::State, &Path) -> Result<<Z::State as UsesInput>::Input, Error>, E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand + HasMetadata,

impl<CS, E, EM, F1, F2, FF, M, OT, Z> Stage<E, EM, Z> for StdTMinMutationalStage<CS, E, EM, F1, F2, FF, M, OT, Z>

where CS: Scheduler + RemovableScheduler, CS::State: HasCorpus + HasSolutions + HasExecutions + HasMaxSize, <CS::State as UsesInput>::Input: HasLen + Hash, E: Executor<EM, Z> + HasObservers<Observers = OT, State = CS::State>, EM: EventFirer<State = CS::State>, F1: Feedback<CS::State>, F2: Feedback<CS::State>, FF: FeedbackFactory<F2, CS::State, OT>, M: Mutator<CS::Input, CS::State>, OT: ObserversTuple<CS::State>, Z: ExecutionProcessor<OT, State = CS::State> + ExecutesInput<E, EM> + HasFeedback<Feedback = F1> + HasScheduler<Scheduler = CS>,

impl<CS, E, EM, OT, PS, Z> Stage<E, EM, Z> for PushStageAdapter<CS, EM, OT, PS, Z>

where CS: Scheduler, CS::State: HasExecutions + HasMetadata + HasRand + HasCorpus + HasLastReportTime, E: Executor<EM, Z> + HasObservers<Observers = OT, State = CS::State>, EM: EventFirer<State = CS::State> + EventRestarter + HasEventManagerId + ProgressReporter<State = CS::State>, OT: ObserversTuple<CS::State>, PS: PushStage<CS, EM, OT, Z>, Z: ExecutesInput<E, EM, State = CS::State> + ExecutionProcessor<OT, State = CS::State> + EvaluatorObservers<OT> + HasScheduler<Scheduler = CS>,

impl<E, EM, I, M, Z> Stage<E, EM, Z> for MultiMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: MultiMutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand, I: MutatedTransform<Self::Input, Self::State> + Clone,

impl<E, EM, I, M, Z> Stage<E, EM, Z> for StdMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: Mutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand, I: MutatedTransform<Self::Input, Self::State> + Clone,

impl<E, EM, I, M, Z> Stage<E, EM, Z> for TuneableMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: Mutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand + HasNamedMetadata + HasMetadata, I: MutatedTransform<Z::Input, Z::State> + Clone,

impl<E, EM, IC, ICB, DI, S, SP, Z> Stage<E, EM, Z> for SyncFromBrokerStage<IC, ICB, DI, S, SP>

where EM: UsesState<State = S> + EventFirer, S: State + HasExecutions + HasCorpus + HasRand + HasMetadata + HasTestcase, SP: ShMemProvider, E: HasObservers<State = S> + Executor<EM, Z>, for<'a> E::Observers: Deserialize<'a>, Z: EvaluatorObservers<E::Observers, State = S> + ExecutionProcessor<E::Observers, State = S>, IC: InputConverter<From = S::Input, To = DI>, ICB: InputConverter<From = DI, To = S::Input>, DI: Input,

impl<E, EM, O, OT, Z> Stage<E, EM, Z> for CalibrationStage<O, OT, E::State>

where E: Executor<EM, Z> + HasObservers<Observers = OT>, EM: EventFirer<State = E::State>, O: MapObserver, for<'de> <O as MapObserver>::Entry: Serialize + Deserialize<'de> + 'static, OT: ObserversTuple<E::State>, E::State: HasCorpus + HasMetadata + HasNamedMetadata + HasExecutions, Z: Evaluator<E, EM, State = E::State>,

impl<E, EM, O, Z> Stage<E, EM, Z> for ColorizationStage<EM, O, E, Z>

where EM: UsesState<State = E::State> + EventFirer, E: HasObservers + Executor<EM, Z>, E::State: HasCorpus + HasMetadata + HasRand, E::Input: HasBytesVec, O: MapObserver, Z: UsesState<State = E::State>,

impl<E, EM, O, Z> Stage<E, EM, Z> for GeneralizationStage<EM, O, E::Observers, Z>

where O: MapObserver, E: Executor<EM, Z> + HasObservers, E::Observers: ObserversTuple<E::State>, E::State: UsesInput<Input = BytesInput> + HasExecutions + HasMetadata + HasCorpus, EM: UsesState<State = E::State>, Z: UsesState<State = E::State>,

impl<E, EM, SOT, Z> Stage<ShadowExecutor<E, SOT>, EM, Z> for ShadowTracingStage<E, EM, SOT, Z>

where E: Executor<EM, Z> + HasObservers, EM: UsesState<State = E::State>, SOT: ObserversTuple<E::State>, Z: UsesState<State = E::State>, E::State: State + HasExecutions + HasCorpus + Debug,

impl<E, EM, ST, Z> Stage<E, EM, Z> for OptionalStage<E, EM, ST, Z>

where E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

impl<E, EM, TE, Z> Stage<E, EM, Z> for ConcolicTracingStage<EM, TE, Z>

where E: UsesState<State = TE::State>, EM: UsesState<State = TE::State>, TE: Executor<EM, Z> + HasObservers, TE::State: HasExecutions + HasCorpus, Z: UsesState<State = TE::State>,

impl<E, EM, TE, Z> Stage<E, EM, Z> for TracingStage<EM, TE, Z>

where E: UsesState<State = TE::State>, TE: Executor<EM, Z> + HasObservers, TE::State: HasExecutions + HasCorpus, EM: UsesState<State = TE::State>, Z: UsesState<State = TE::State>,

impl<E, EM, Z> Stage<E, EM, Z> for SimpleConcolicMutationalStage<Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, Z: Evaluator<E, EM>, Z::Input: HasBytesVec, Z::State: State + HasExecutions + HasCorpus,

impl<E, EM, Z> Stage<E, EM, Z> for AflStatsStage<E, EM, Z>

where E: UsesState, EM: EventFirer<State = E::State>, Z: UsesState<State = E::State>, E::State: HasImported + HasCorpus + HasMetadata,

impl<E, F, EM, I, M, Z> Stage<E, EM, Z> for PowerMutationalStage<E, F, EM, I, M, Z>

where E: Executor<EM, Z> + HasObservers, EM: UsesState<State = E::State>, F: TestcaseScore<E::State>, M: Mutator<I, E::State>, E::State: HasCorpus + HasMetadata + HasRand, Z: Evaluator<E, EM, State = E::State>, I: MutatedTransform<E::Input, E::State> + Clone,

impl<S, E, EM, Z> Stage<E, EM, Z> for StringIdentificationStage<S>

where S: HasTestcase<Input = BytesInput> + HasCorpus + State, E: UsesState<State = S>, EM: UsesState<State = S>, Z: UsesState<State = S>,