From dc39a5591ac038ea3b2fad3469074b4aac9121cd Mon Sep 17 00:00:00 2001 From: Andrea Fioraldi Date: Mon, 1 Mar 2021 10:04:59 +0100 Subject: [PATCH] format --- fuzzers/libfuzzer_libpng/src/fuzzer.rs | 20 +++++++++++---- libafl/src/events/llmp.rs | 25 ++++++++++++++----- libafl/src/events/mod.rs | 16 +++++++++--- libafl/src/events/simple.rs | 11 ++++++--- libafl/src/fuzzer.rs | 3 ++- libafl/src/stages/mod.rs | 18 ++++++++------ libafl/src/stages/mutational.rs | 5 ++-- libafl/src/state/mod.rs | 34 +++++++++++++++++++------- 8 files changed, 95 insertions(+), 37 deletions(-) diff --git a/fuzzers/libfuzzer_libpng/src/fuzzer.rs b/fuzzers/libfuzzer_libpng/src/fuzzer.rs index 66cd674c5d..c18aa49c7f 100644 --- a/fuzzers/libfuzzer_libpng/src/fuzzer.rs +++ b/fuzzers/libfuzzer_libpng/src/fuzzer.rs @@ -6,12 +6,13 @@ use std::{env, path::PathBuf}; use libafl::{ bolts::{shmem::UnixShMem, tuples::tuple_list}, corpus::{ - Corpus, InMemoryCorpus, IndexesLenTimeMinimizerCorpusScheduler, OnDiskCorpus, QueueCorpusScheduler + Corpus, InMemoryCorpus, IndexesLenTimeMinimizerCorpusScheduler, OnDiskCorpus, + QueueCorpusScheduler, }, events::setup_restarting_mgr, executors::{inprocess::InProcessExecutor, Executor, ExitKind}, feedbacks::{CrashFeedback, MaxMapFeedback}, - fuzzer::{Fuzzer, StdFuzzer, HasCorpusScheduler}, + fuzzer::{Fuzzer, HasCorpusScheduler, StdFuzzer}, inputs::Input, mutators::scheduled::HavocBytesMutator, mutators::token_mutations::TokensMetadata, @@ -91,7 +92,11 @@ fn fuzz(corpus_dirs: Vec, objective_dir: PathBuf, broker_port: u16) -> // Corpus that will be evolved, we keep it in memory for performance InMemoryCorpus::new(), // Feedbacks to rate the interestingness of an input - tuple_list!(MaxMapFeedback::new_with_observer_track(&edges_observer, true, false)), + tuple_list!(MaxMapFeedback::new_with_observer_track( + &edges_observer, + true, + false + )), // Corpus in which we store solutions (crashes in this example), // on disk so the user can get them after stopping the fuzzer OnDiskCorpus::new(objective_dir), @@ -142,14 +147,19 @@ fn fuzz(corpus_dirs: Vec, objective_dir: PathBuf, broker_port: u16) -> // In case the corpus is empty (on first run), reset if state.corpus().count() < 1 { state - .load_initial_inputs(&mut executor, &mut restarting_mgr, fuzzer.scheduler(), &corpus_dirs) + .load_initial_inputs( + &mut executor, + &mut restarting_mgr, + fuzzer.scheduler(), + &corpus_dirs, + ) .expect(&format!( "Failed to load initial corpus at {:?}", &corpus_dirs )); println!("We imported {} inputs from disk.", state.corpus().count()); } - + fuzzer.fuzz_loop(&mut state, &mut executor, &mut restarting_mgr)?; // Never reached diff --git a/libafl/src/events/llmp.rs b/libafl/src/events/llmp.rs index 051167b732..102cab12d9 100644 --- a/libafl/src/events/llmp.rs +++ b/libafl/src/events/llmp.rs @@ -17,12 +17,12 @@ use crate::{ llmp::{self, LlmpClient, LlmpClientDescription, Tag}, shmem::ShMem, }, + corpus::CorpusScheduler, events::{BrokerEventResult, Event, EventManager}, executors::ExitKind, executors::{Executor, HasObservers}, inputs::Input, observers::ObserversTuple, - corpus::CorpusScheduler, state::IfInteresting, stats::Stats, Error, @@ -284,7 +284,10 @@ where // TODO include ExitKind in NewTestcase let fitness = state.is_interesting(&input, &observers, ExitKind::Ok)?; if fitness > 0 { - if !state.add_if_interesting(&input, fitness, scheduler)?.is_none() { + if !state + .add_if_interesting(&input, fitness, scheduler)? + .is_none() + { #[cfg(feature = "std")] println!("Added received Testcase"); } @@ -318,11 +321,16 @@ where } } - fn process(&mut self, state: &mut S, executor: &mut E, scheduler: &CS) -> Result + fn process( + &mut self, + state: &mut S, + executor: &mut E, + scheduler: &CS, + ) -> Result where CS: CorpusScheduler, E: Executor + HasObservers, - OT: ObserversTuple + OT: ObserversTuple, { // TODO: Get around local event copy by moving handle_in_client let mut events = vec![]; @@ -430,11 +438,16 @@ where .send_buf(_LLMP_TAG_RESTART, &state_corpus_serialized) } - fn process(&mut self, state: &mut S, executor: &mut E, scheduler: &CS) -> Result + fn process( + &mut self, + state: &mut S, + executor: &mut E, + scheduler: &CS, + ) -> Result where CS: CorpusScheduler, E: Executor + HasObservers, - OT: ObserversTuple + OT: ObserversTuple, { self.llmp_mgr.process(state, executor, scheduler) } diff --git a/libafl/src/events/mod.rs b/libafl/src/events/mod.rs index 934a3163c7..280c1ac8bf 100644 --- a/libafl/src/events/mod.rs +++ b/libafl/src/events/mod.rs @@ -10,9 +10,9 @@ use core::{fmt, marker::PhantomData, time::Duration}; use serde::{Deserialize, Serialize}; use crate::{ + corpus::CorpusScheduler, executors::{Executor, HasObservers}, inputs::Input, - corpus::{ CorpusScheduler}, observers::ObserversTuple, Error, }; @@ -160,7 +160,12 @@ where /// Lookup for incoming events and process them. /// Return the number of processes events or an error - fn process(&mut self, state: &mut S, executor: &mut E, scheduler: &CS) -> Result + fn process( + &mut self, + state: &mut S, + executor: &mut E, + scheduler: &CS, + ) -> Result where CS: CorpusScheduler, E: Executor + HasObservers, @@ -205,7 +210,12 @@ impl EventManager for NopEventManager where I: Input, { - fn process(&mut self, _state: &mut S, _executor: &mut E, _scheduler: &CS) -> Result + fn process( + &mut self, + _state: &mut S, + _executor: &mut E, + _scheduler: &CS, + ) -> Result where CS: CorpusScheduler, E: Executor + HasObservers, diff --git a/libafl/src/events/simple.rs b/libafl/src/events/simple.rs index b3f3fce830..ec91e2c1b1 100644 --- a/libafl/src/events/simple.rs +++ b/libafl/src/events/simple.rs @@ -3,11 +3,11 @@ use alloc::{string::ToString, vec::Vec}; use core::marker::PhantomData; use crate::{ + corpus::CorpusScheduler, events::{BrokerEventResult, Event, EventManager}, executors::{Executor, HasObservers}, inputs::Input, observers::ObserversTuple, - corpus::CorpusScheduler, stats::Stats, Error, }; @@ -31,11 +31,16 @@ where I: Input, ST: Stats, //CE: CustomEvent, { - fn process(&mut self, state: &mut S, _executor: &mut E, _scheduler: &CS) -> Result + fn process( + &mut self, + state: &mut S, + _executor: &mut E, + _scheduler: &CS, + ) -> Result where CS: CorpusScheduler, E: Executor + HasObservers, - OT: ObserversTuple + OT: ObserversTuple, { let count = self.events.len(); while self.events.len() > 0 { diff --git a/libafl/src/fuzzer.rs b/libafl/src/fuzzer.rs index 127794458a..d4507ed9b6 100644 --- a/libafl/src/fuzzer.rs +++ b/libafl/src/fuzzer.rs @@ -105,7 +105,8 @@ where fn fuzz_one(&self, state: &mut S, executor: &mut E, manager: &mut EM) -> Result { let idx = self.scheduler().next(state)?; - self.stages().perform_all(state, executor, manager, self.scheduler(), idx)?; + self.stages() + .perform_all(state, executor, manager, self.scheduler(), idx)?; manager.process(state, executor, self.scheduler())?; Ok(idx) diff --git a/libafl/src/stages/mod.rs b/libafl/src/stages/mod.rs index 03ada9567d..e50a165d0b 100644 --- a/libafl/src/stages/mod.rs +++ b/libafl/src/stages/mod.rs @@ -7,7 +7,7 @@ use crate::{ /// A stage is one step in the fuzzing process. /// Multiple stages will be scheduled one by one for each input. -pub trait Stage +pub trait Stage where EM: EventManager, E: Executor, @@ -24,7 +24,7 @@ where ) -> Result<(), Error>; } -pub trait StagesTuple +pub trait StagesTuple where EM: EventManager, E: Executor, @@ -40,7 +40,7 @@ where ) -> Result<(), Error>; } -impl StagesTuple for () +impl StagesTuple for () where EM: EventManager, E: Executor, @@ -51,10 +51,10 @@ where } } -impl StagesTuple for (Head, Tail) +impl StagesTuple for (Head, Tail) where - Head: Stage, - Tail: StagesTuple + TupleList, + Head: Stage, + Tail: StagesTuple + TupleList, EM: EventManager, E: Executor, I: Input, @@ -67,7 +67,9 @@ where scheduler: &CS, corpus_idx: usize, ) -> Result<(), Error> { - self.0.perform(state, executor, manager, scheduler, corpus_idx)?; - self.1.perform_all(state, executor, manager, scheduler, corpus_idx) + self.0 + .perform(state, executor, manager, scheduler, corpus_idx)?; + self.1 + .perform_all(state, executor, manager, scheduler, corpus_idx) } } diff --git a/libafl/src/stages/mutational.rs b/libafl/src/stages/mutational.rs index 7a2731a058..bf05d9c803 100644 --- a/libafl/src/stages/mutational.rs +++ b/libafl/src/stages/mutational.rs @@ -27,7 +27,7 @@ where EM: EventManager, E: Executor + HasObservers, OT: ObserversTuple, - CS: CorpusScheduler + CS: CorpusScheduler, { /// The mutator registered for this stage fn mutator(&self) -> &M; @@ -116,7 +116,8 @@ where } } -impl Stage for StdMutationalStage +impl Stage + for StdMutationalStage where M: Mutator, I: Input, diff --git a/libafl/src/state/mod.rs b/libafl/src/state/mod.rs index e1d29ecb37..b9ce39b076 100644 --- a/libafl/src/state/mod.rs +++ b/libafl/src/state/mod.rs @@ -10,7 +10,7 @@ use std::{ use crate::{ bolts::serdeany::{SerdeAny, SerdeAnyMap}, - corpus::{Corpus, Testcase, CorpusScheduler}, + corpus::{Corpus, CorpusScheduler, Testcase}, events::{Event, EventManager, LogSeverity}, executors::{Executor, ExitKind, HasObservers}, feedbacks::FeedbacksTuple, @@ -175,7 +175,12 @@ where OT: ObserversTuple; /// Adds this input to the corpus, if it's intersting, and return the index - fn add_if_interesting(&mut self, input: &I, fitness: u32, scheduler: &CS) -> Result, Error> + fn add_if_interesting( + &mut self, + input: &I, + fitness: u32, + scheduler: &CS, + ) -> Result, Error> where CS: CorpusScheduler, Self: Sized; @@ -455,9 +460,14 @@ where /// Adds this input to the corpus, if it's intersting, and return the index #[inline] - fn add_if_interesting(&mut self, input: &I, fitness: u32, scheduler: &CS) -> Result, Error> + fn add_if_interesting( + &mut self, + input: &I, + fitness: u32, + scheduler: &CS, + ) -> Result, Error> where - CS: CorpusScheduler + CS: CorpusScheduler, { if fitness > 0 { let testcase = self.testcase_with_feedbacks_metadata(input.clone(), fitness)?; @@ -495,7 +505,7 @@ where OT: ObserversTuple, C: Corpus, EM: EventManager, - CS: CorpusScheduler + CS: CorpusScheduler, { let (fitness, is_solution) = self.execute_input(&input, executor, manager)?; let observers = executor.observers(); @@ -505,7 +515,10 @@ where self.solutions_mut().add(Testcase::new(input.clone()))?; } - if !self.add_if_interesting(&input, fitness, scheduler)?.is_none() { + if !self + .add_if_interesting(&input, fitness, scheduler)? + .is_none() + { let observers_buf = manager.serialize_observers(observers)?; manager.fire( self, @@ -544,7 +557,7 @@ where E: Executor + HasObservers, OT: ObserversTuple, EM: EventManager, - CS: CorpusScheduler + CS: CorpusScheduler, { for entry in fs::read_dir(in_dir)? { let entry = entry?; @@ -562,7 +575,10 @@ where let bytes = fs::read(&path)?; let input = BytesInput::new(bytes); let (fitness, is_solution) = self.execute_input(&input, executor, manager)?; - if self.add_if_interesting(&input, fitness, scheduler)?.is_none() { + if self + .add_if_interesting(&input, fitness, scheduler)? + .is_none() + { println!("File {:?} was not interesting, skipped.", &path); } if is_solution { @@ -662,7 +678,7 @@ where E: Executor + HasObservers, OT: ObserversTuple, EM: EventManager, - CS: CorpusScheduler + CS: CorpusScheduler, { let mut added = 0; for _ in 0..num {