No Uses* from fuzzer (#2761)

* go

* fixing stuf

* hello from windows

* more

* lolg

* lolf

* fix

* a

---------

Co-authored-by: Your Name <[email protected]>

fuzzers/baby/baby_fuzzer_custom_executor/src/main.rs

@@ -53,13 +53,12 @@ impl<EM, S, Z> Executor<EM, Z> for CustomExecutor<S>
 where
     EM: UsesState<State = S>,
     S: State + HasExecutions,
-    Z: UsesState<State = S>,
     Self::Input: HasTargetBytes,
 {
     fn run_target(
         &mut self,
         _fuzzer: &mut Z,
-        state: &mut Self::State,
+        state: &mut S,
         _mgr: &mut EM,
         input: &Self::Input,
     ) -> Result<ExitKind, libafl::Error> {

fuzzers/binary_only/qemu_launcher/src/instance.rs

@@ -312,9 +312,8 @@ impl<M: Monitor> Instance<'_, M> {
         stages: &mut ST,
     ) -> Result<(), Error>
     where
-        Z: Fuzzer<E, ClientMgr<M>, ST>
-            + UsesState<State = ClientState>
-            + Evaluator<E, ClientMgr<M>, State = ClientState>,
+        Z: Fuzzer<E, ClientMgr<M>, ClientState, ST>
+            + Evaluator<E, ClientMgr<M>, BytesInput, ClientState>,
         E: UsesState<State = ClientState>,
         ST: StagesTuple<E, ClientMgr<M>, ClientState, Z>,
     {

fuzzers/forkserver/libafl-fuzz/src/executor.rs

@@ -357,7 +357,6 @@ pub enum SupportedExecutors<S, OT, FSV> {
 impl<S, OT, FSV, EM, Z> Executor<EM, Z> for SupportedExecutors<S, OT, FSV>
 where
     S: State,
-    Z: UsesState<State = S>,
     EM: UsesState<State = S>,
     FSV: Executor<EM, Z, State = S>,
 {

fuzzers/forkserver/libafl-fuzz/src/fuzzer.rs

@@ -22,7 +22,7 @@ use libafl::{
         CaptureTimeoutFeedback, ConstFeedback, CrashFeedback, MaxMapFeedback, TimeFeedback,
     },
     fuzzer::StdFuzzer,
-    inputs::{BytesInput, NopTargetBytesConverter},
+    inputs::{BytesInput, NopTargetBytesConverter, UsesInput},
     mutators::{havoc_mutations, tokens_mutations, AFLppRedQueen, StdScheduledMutator, Tokens},
     observers::{CanTrack, HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{
@@ -38,7 +38,6 @@ use libafl::{
     },
     state::{
         HasCorpus, HasCurrentTestcase, HasExecutions, HasLastReportTime, HasStartTime, StdState,
-        UsesState,
     },
     Error, Fuzzer, HasFeedback, HasMetadata, SerdeAny,
 };
@@ -649,20 +648,19 @@ pub fn fuzzer_target_mode(opt: &Opt) -> Cow<'static, str> {
 #[derive(Debug, Serialize, Deserialize, SerdeAny)]
 pub struct IsInitialCorpusEntryMetadata {}
 
-pub fn run_fuzzer_with_stages<Z, ST, E, EM>(
+pub fn run_fuzzer_with_stages<E, EM, S, ST, Z>(
     opt: &Opt,
     fuzzer: &mut Z,
     stages: &mut ST,
     executor: &mut E,
-    state: &mut <Z as UsesState>::State,
+    state: &mut S,
     mgr: &mut EM,
 ) -> Result<(), Error>
 where
-    Z: Fuzzer<E, EM, ST>,
-    E: UsesState<State = Z::State>,
-    EM: ProgressReporter<State = Z::State>,
-    ST: StagesTuple<E, EM, Z::State, Z>,
-    <Z as UsesState>::State: HasLastReportTime + HasExecutions + HasMetadata,
+    Z: Fuzzer<E, EM, S, ST>,
+    EM: ProgressReporter<State = S>,
+    ST: StagesTuple<E, EM, S, Z>,
+    S: HasLastReportTime + HasExecutions + HasMetadata + UsesInput,
 {
     if opt.bench_just_one {
         fuzzer.fuzz_loop_for(stages, executor, state, mgr, 1)?;

libafl/src/corpus/minimizer.rs

@@ -77,7 +77,7 @@ where
         E::Observers: ObserversTuple<E::Input, E::State>,
         CS: Scheduler<E::Input, E::State> + RemovableScheduler<E::Input, E::State>,
         EM: EventFirer<State = E::State>,
-        Z: HasScheduler<Scheduler = CS, State = E::State>,
+        Z: HasScheduler<E::Input, E::State, Scheduler = CS>,
     {
         // don't delete this else it won't work after restart
         let current = *state.corpus().current();

libafl/src/events/centralized.rs

@@ -30,6 +30,7 @@ use crate::events::llmp::COMPRESS_THRESHOLD;
 #[cfg(feature = "scalability_introspection")]
 use crate::state::HasScalabilityMonitor;
 use crate::{
+    corpus::Corpus,
     events::{
         AdaptiveSerializer, CustomBufEventResult, Event, EventConfig, EventFirer, EventManager,
         EventManagerHooksTuple, EventManagerId, EventProcessor, EventRestarter,
@@ -39,7 +40,7 @@ use crate::{
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
     inputs::{Input, NopInput, UsesInput},
     observers::{ObserversTuple, TimeObserver},
-    state::{HasExecutions, HasLastReportTime, NopState, State, Stoppable, UsesState},
+    state::{HasCorpus, HasExecutions, HasLastReportTime, NopState, State, Stoppable, UsesState},
     Error, HasMetadata,
 };
 
@@ -49,8 +50,8 @@ pub(crate) const _LLMP_TAG_TO_MAIN: Tag = Tag(0x3453453);
 #[derive(Debug)]
 pub struct CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: UsesState,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: UsesState<State = S>,
+    EMH: EventManagerHooksTuple<S>,
     S: State,
     SP: ShMemProvider,
 {
@@ -114,8 +115,8 @@ impl CentralizedEventManagerBuilder {
         time_obs: Option<Handle<TimeObserver>>,
     ) -> Result<CentralizedEventManager<EM, EMH, S, SP>, Error>
     where
-        EM: UsesState,
-        EMH: EventManagerHooksTuple<EM::State>,
+        EM: UsesState<State = S>,
+        EMH: EventManagerHooksTuple<S>,
         S: State,
         SP: ShMemProvider,
     {
@@ -135,7 +136,6 @@ impl CentralizedEventManagerBuilder {
     ///
     /// If the port is not yet bound, it will act as a broker; otherwise, it
     /// will act as a client.
-    #[cfg(feature = "std")]
     pub fn build_on_port<EM, EMH, S, SP>(
         self,
         inner: EM,
@@ -145,8 +145,8 @@ impl CentralizedEventManagerBuilder {
         time_obs: Option<Handle<TimeObserver>>,
     ) -> Result<CentralizedEventManager<EM, EMH, S, SP>, Error>
     where
-        EM: UsesState,
-        EMH: EventManagerHooksTuple<EM::State>,
+        EM: UsesState<State = S>,
+        EMH: EventManagerHooksTuple<S>,
         S: State,
         SP: ShMemProvider,
     {
@@ -165,7 +165,6 @@ impl CentralizedEventManagerBuilder {
 
     /// If a client respawns, it may reuse the existing connection, previously
     /// stored by [`LlmpClient::to_env()`].
-    #[cfg(feature = "std")]
     pub fn build_existing_client_from_env<EM, EMH, S, SP>(
         self,
         inner: EM,
@@ -175,8 +174,8 @@ impl CentralizedEventManagerBuilder {
         time_obs: Option<Handle<TimeObserver>>,
     ) -> Result<CentralizedEventManager<EM, EMH, S, SP>, Error>
     where
-        EM: UsesState,
-        EMH: EventManagerHooksTuple<EM::State>,
+        EM: UsesState<State = S>,
+        EMH: EventManagerHooksTuple<S>,
         S: State,
         SP: ShMemProvider,
     {
@@ -193,7 +192,6 @@ impl CentralizedEventManagerBuilder {
     }
 
     /// Create an existing client from description
-    #[cfg(feature = "std")]
     pub fn existing_client_from_description<EM, EMH, S, SP>(
         self,
         inner: EM,
@@ -203,8 +201,8 @@ impl CentralizedEventManagerBuilder {
         time_obs: Option<Handle<TimeObserver>>,
     ) -> Result<CentralizedEventManager<EM, EMH, S, SP>, Error>
     where
-        EM: UsesState,
-        EMH: EventManagerHooksTuple<EM::State>,
+        EM: UsesState<State = S>,
+        EMH: EventManagerHooksTuple<S>,
         S: State,
         SP: ShMemProvider,
     {
@@ -222,8 +220,8 @@ impl CentralizedEventManagerBuilder {
 }
 impl<EM, EMH, S, SP> UsesState for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: UsesState,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: UsesState<State = S>,
+    EMH: EventManagerHooksTuple<S>,
     S: State,
     SP: ShMemProvider,
 {
@@ -232,8 +230,8 @@ where
 
 impl<EM, EMH, S, SP> AdaptiveSerializer for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: AdaptiveSerializer + UsesState,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: AdaptiveSerializer + UsesState<State = S>,
+    EMH: EventManagerHooksTuple<S>,
     S: State,
     SP: ShMemProvider,
 {
@@ -270,9 +268,10 @@ where
 
 impl<EM, EMH, S, SP> EventFirer for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: AdaptiveSerializer + EventFirer + HasEventManagerId,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State,
+    EM: AdaptiveSerializer + EventFirer<State = S> + HasEventManagerId,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
 {
     fn should_send(&self) -> bool {
@@ -342,8 +341,8 @@ where
 
 impl<EM, EMH, S, SP> EventRestarter for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: EventRestarter,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: EventRestarter<State = S>,
+    EMH: EventManagerHooksTuple<S>,
     S: State,
     SP: ShMemProvider,
 {
@@ -368,17 +367,18 @@ where
 
 impl<E, EM, EMH, S, SP, Z> EventProcessor<E, Z> for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: AdaptiveSerializer + EventProcessor<E, Z> + EventFirer + HasEventManagerId,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: AdaptiveSerializer + EventProcessor<E, Z> + EventFirer<State = S> + HasEventManagerId,
+    EMH: EventManagerHooksTuple<S>,
     E: HasObservers + Executor<Self, Z, State = Self::State>,
     E::Observers:
         ObserversTuple<<Self as UsesInput>::Input, <Self as UsesState>::State> + Serialize,
     for<'a> E::Observers: Deserialize<'a>,
-    S: State,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     Self::State: HasExecutions + HasMetadata,
     SP: ShMemProvider,
-    Z: EvaluatorObservers<Self, E::Observers, State = Self::State>
-        + ExecutionProcessor<Self, E::Observers, State = Self::State>,
+    Z: EvaluatorObservers<E, Self, <S::Corpus as Corpus>::Input, S>
+        + ExecutionProcessor<Self, <S::Corpus as Corpus>::Input, E::Observers, S>,
 {
     fn process(
         &mut self,
@@ -408,20 +408,21 @@ where
     E::Observers:
         ObserversTuple<<Self as UsesInput>::Input, <Self as UsesState>::State> + Serialize,
     for<'a> E::Observers: Deserialize<'a>,
-    EM: AdaptiveSerializer + EventManager<E, Z>,
+    EM: AdaptiveSerializer + EventManager<E, Z, State = S>,
     EM::State: HasExecutions + HasMetadata + HasLastReportTime,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
-    Z: EvaluatorObservers<Self, E::Observers, State = Self::State>
-        + ExecutionProcessor<Self, E::Observers, State = Self::State>,
+    Z: EvaluatorObservers<E, Self, <S::Corpus as Corpus>::Input, S>
+        + ExecutionProcessor<Self, <S::Corpus as Corpus>::Input, E::Observers, S>,
 {
 }
 
 impl<EM, EMH, S, SP> HasCustomBufHandlers for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: HasCustomBufHandlers,
-    EMH: EventManagerHooksTuple<EM::State>,
+    EM: HasCustomBufHandlers<State = S>,
+    EMH: EventManagerHooksTuple<S>,
     S: State,
     SP: ShMemProvider,
 {
@@ -438,19 +439,21 @@ where
 
 impl<EM, EMH, S, SP> ProgressReporter for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: AdaptiveSerializer + ProgressReporter + HasEventManagerId,
+    EM: AdaptiveSerializer + ProgressReporter<State = S> + HasEventManagerId,
     EM::State: HasMetadata + HasExecutions + HasLastReportTime,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
 {
 }
 
 impl<EM, EMH, S, SP> HasEventManagerId for CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: HasEventManagerId + UsesState,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State,
+    EM: HasEventManagerId + UsesState<State = S>,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
 {
     fn mgr_id(&self) -> EventManagerId {
@@ -460,9 +463,10 @@ where
 
 impl<EM, EMH, S, SP> CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: UsesState,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State,
+    EM: UsesState<State = S>,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
 {
     /// Describe the client event manager's LLMP parts in a restorable fashion
@@ -472,7 +476,6 @@ where
 
     /// Write the config for a client [`EventManager`] to env vars, a new
     /// client can reattach using [`CentralizedEventManagerBuilder::build_existing_client_from_env()`].
-    #[cfg(feature = "std")]
     pub fn to_env(&self, env_name: &str) {
         self.client.to_env(env_name).unwrap();
     }
@@ -485,9 +488,10 @@ where
 
 impl<EM, EMH, S, SP> CentralizedEventManager<EM, EMH, S, SP>
 where
-    EM: UsesState + EventFirer + AdaptiveSerializer + HasEventManagerId,
-    EMH: EventManagerHooksTuple<EM::State>,
-    S: State + Stoppable,
+    EM: UsesState<State = S> + EventFirer + AdaptiveSerializer + HasEventManagerId,
+    EMH: EventManagerHooksTuple<S>,
+    S: State + Stoppable + HasCorpus,
+    S::Corpus: Corpus<Input = S::Input>,
     SP: ShMemProvider,
 {
     #[cfg(feature = "llmp_compression")]
@@ -535,8 +539,8 @@ where
             ObserversTuple<<Self as UsesInput>::Input, <Self as UsesState>::State> + Serialize,
         <Self as UsesState>::State: UsesInput + HasExecutions + HasMetadata,
         for<'a> E::Observers: Deserialize<'a>,
-        Z: ExecutionProcessor<Self, E::Observers, State = <Self as UsesState>::State>
-            + EvaluatorObservers<Self, E::Observers>,
+        Z: EvaluatorObservers<E, Self, <S::Corpus as Corpus>::Input, S>
+            + ExecutionProcessor<Self, <S::Corpus as Corpus>::Input, E::Observers, S>,
     {
         // TODO: Get around local event copy by moving handle_in_client
         let self_id = self.client.sender().id();
@@ -585,8 +589,8 @@ where
             ObserversTuple<<Self as UsesInput>::Input, <Self as UsesState>::State> + Serialize,
         <Self as UsesState>::State: UsesInput + HasExecutions + HasMetadata,
         for<'a> E::Observers: Deserialize<'a> + Serialize,
-        Z: ExecutionProcessor<Self, E::Observers, State = <Self as UsesState>::State>
-            + EvaluatorObservers<Self, E::Observers>,
+        Z: EvaluatorObservers<E, Self, <S::Corpus as Corpus>::Input, S>
+            + ExecutionProcessor<Self, <S::Corpus as Corpus>::Input, E::Observers, S>,
     {
         log::debug!("handle_in_main!");
 
@@ -640,7 +644,7 @@ where
                             process::id(),
                             event_name
                         );
-                        fuzzer.evaluate_input_with_observers::<E>(
+                        fuzzer.evaluate_input_with_observers(
                             state,
                             executor,
                             self,