SYS-OSS/FRET-LibAFL
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fmt

Browse Source
This commit is contained in:
Dominik Maier 2020-11-26 02:31:02 +01:00
parent 68a72f583c
commit 944753c741
3 changed files with 137 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
afl/src/engines/mod.rs
View File

@ -9,7 +9,7 @@ use core::marker::PhantomData;
use hashbrown::HashMap;
use crate::corpus::{Corpus, Testcase};
use crate::events::{EventManager, Event};
use crate::events::{Event, EventManager};
use crate::executors::Executor;
use crate::feedbacks::Feedback;
use crate::generators::Generator;
@ -177,7 +177,10 @@ where
for _ in 0..num {
let input = generator.generate(rand)?;
state.add_input(corpus, input)?;
let event = Event::LoadInitial {sender_id: 0, _marker: PhantomData};
let event = Event::LoadInitial {
sender_id: 0,
_marker: PhantomData,
};
events.fire(event)?;
}
events.process(state, corpus)?;
@ -332,7 +335,11 @@ where
let cur = current_milliseconds();
if cur - last > 60 * 100 {
last = cur;
events.fire(Event::UpdateStats {sender_id: 0, new_execs: 1, _marker: PhantomData})?; // TODO self.new_execs});
events.fire(Event::UpdateStats {
sender_id: 0,
new_execs: 1,
_marker: PhantomData,
})?; // TODO self.new_execs});
}
}
}

165
afl/src/events/mod.rs
View File

@ -9,7 +9,7 @@ pub mod shmem_translated;
pub use crate::events::llmp::LLMP;
#[cfg(feature = "std")]
use std::{marker::PhantomData, io::Write};
use std::{io::Write, marker::PhantomData};
use crate::corpus::{Corpus, Testcase};
use crate::engines::State;
@ -69,12 +69,37 @@ where
R: Rand,
// CE: CustomEvent<S, C, E, I, R>,
{
LoadInitial {sender_id: u64, _marker: PhantomData<(S, C, E, I, R)>},
NewTestcase {sender_id: u64, input: I, fitness: u32, _marker: PhantomData<(S, C, E, I, R)>},
UpdateStats {sender_id: u64, new_execs: usize, _marker: PhantomData<(S, C, E, I, R)>},
Crash {sender_id: u64, input: I, _marker: PhantomData<(S, C, E, I, R)>},
Timeout {sender_id: u64, input: I, _marker: PhantomData<(S, C, E, I, R)>},
Log {sender_id: u64, severity_level: u8, message: String, _marker: PhantomData<(S, C, E, I, R)>},
LoadInitial {
sender_id: u64,
_marker: PhantomData<(S, C, E, I, R)>,
},
NewTestcase {
sender_id: u64,
input: I,
fitness: u32,
_marker: PhantomData<(S, C, E, I, R)>,
},
UpdateStats {
sender_id: u64,
new_execs: usize,
_marker: PhantomData<(S, C, E, I, R)>,
},
Crash {
sender_id: u64,
input: I,
_marker: PhantomData<(S, C, E, I, R)>,
},
Timeout {
sender_id: u64,
input: I,
_marker: PhantomData<(S, C, E, I, R)>,
},
Log {
sender_id: u64,
severity_level: u8,
message: String,
_marker: PhantomData<(S, C, E, I, R)>,
},
//Custom {sender_id: u64, custom_event: CE},
}
@ -89,54 +114,107 @@ where
{
fn name(&self) -> &str {
match self {
Event::LoadInitial {sender_id, _marker} => "Initial",
Event::NewTestcase {sender_id, input, fitness, _marker} => "New Testcase",
Event::UpdateStats {sender_id, new_execs, _marker} => "Stats",
Event::Crash {sender_id, input, _marker} => "Crash",
Event::Timeout {sender_id, input, _marker} => "Timeout",
Event::Log {sender_id, severity_level, message, _marker} => "Log",
Event::LoadInitial { sender_id, _marker } => "Initial",
Event::NewTestcase {
sender_id,
input,
fitness,
_marker,
} => "New Testcase",
Event::UpdateStats {
sender_id,
new_execs,
_marker,
} => "Stats",
Event::Crash {
sender_id,
input,
_marker,
} => "Crash",
Event::Timeout {
sender_id,
input,
_marker,
} => "Timeout",
Event::Log {
sender_id,
severity_level,
message,
_marker,
} => "Log",
//Event::Custom {sender_id, custom_event} => custom_event.name(),
}
}
fn handle_in_broker(&self, /*broker: &dyn EventManager<S, C, E, I, R>,*/ state: &mut S, corpus: &mut C) -> Result<BrokerEventResult, AflError> {
fn handle_in_broker(
&self,
/*broker: &dyn EventManager<S, C, E, I, R>,*/ state: &mut S,
corpus: &mut C,
) -> Result<BrokerEventResult, AflError> {
match self {
Event::LoadInitial {sender_id, _marker} => {
Ok(BrokerEventResult::Handled)
}
Event::NewTestcase {sender_id, input, fitness, _marker} => {
Ok(BrokerEventResult::Forward)
}
Event::UpdateStats {sender_id, new_execs, _marker} => {
Event::LoadInitial { sender_id, _marker } => Ok(BrokerEventResult::Handled),
Event::NewTestcase {
sender_id,
input,
fitness,
_marker,
} => Ok(BrokerEventResult::Forward),
Event::UpdateStats {
sender_id,
new_execs,
_marker,
} => {
// TODO
Ok(BrokerEventResult::Handled)
}
Event::Crash {sender_id, input, _marker} => {
Ok(BrokerEventResult::Handled)
}
Event::Timeout {sender_id, input, _marker} => {
Event::Crash {
sender_id,
input,
_marker,
} => Ok(BrokerEventResult::Handled),
Event::Timeout {
sender_id,
input,
_marker,
} => {
// TODO
Ok(BrokerEventResult::Handled)
},
Event::Log {sender_id, severity_level, message, _marker} => {
}
Event::Log {
sender_id,
severity_level,
message,
_marker,
} => {
//TODO: broker.log()
println!("{}[{}]: {}", sender_id, severity_level, message);
Ok(BrokerEventResult::Handled)
},
}
//Event::Custom {sender_id, custom_event} => custom_event.handle_in_broker(state, corpus),
_ => Ok(BrokerEventResult::Forward)
_ => Ok(BrokerEventResult::Forward),
}
}
fn handle_in_client(&self, /*client: &dyn EventManager<S, C, E, I, R>,*/ state: &mut S, corpus: &mut C) -> Result<(), AflError> {
fn handle_in_client(
&self,
/*client: &dyn EventManager<S, C, E, I, R>,*/ state: &mut S,
corpus: &mut C,
) -> Result<(), AflError> {
match self {
Event::NewTestcase {sender_id, input, fitness, _marker} => {
Event::NewTestcase {
sender_id,
input,
fitness,
_marker,
} => {
let mut testcase = Testcase::new(input.to_owned());
testcase.set_fitness(*fitness);
corpus.add(testcase);
Ok(())
}
_ => Err(AflError::Unknown("Received illegal message that message should not have arrived.".into()))
_ => Err(AflError::Unknown(
"Received illegal message that message should not have arrived.".into(),
)),
}
}
@ -150,7 +228,6 @@ where
E: Executor<I>,
I: Input,
R: Rand,
//CE: CustomEvent<S, C, E, I, R>,
{
/// Check if this EventaManager support a given Event type
/// To compare events, use Event::name().as_ptr()
@ -163,7 +240,6 @@ where
/// Return the number of processes events or an error
fn process(&mut self, state: &mut S, corpus: &mut C) -> Result<usize, AflError>;
fn on_recv(&self, _state: &mut S, corpus: &mut C) -> Result<(), AflError> {
// TODO: Better way to move out of testcase, or get ref
//Ok(corpus.add(self.testcase.take().unwrap()))
@ -209,31 +285,30 @@ where
W: Write,
//CE: CustomEvent<S, C, E, I, R>,
{
fn enabled(&self) -> bool
{
fn enabled(&self) -> bool {
true
}
fn fire(&mut self, event: Event<S, C, E, I, R>) -> Result<(), AflError>
{
fn fire(&mut self, event: Event<S, C, E, I, R>) -> Result<(), AflError> {
self.events.push(event);
Ok(())
}
fn process(&mut self, state: &mut S, corpus: &mut C) -> Result<usize, AflError> {
// TODO: iterators
let mut handled = vec!();
let mut handled = vec![];
for x in self.events.iter() {
handled.push(x.handle_in_broker(state, corpus)?);
}
handled.iter().zip(self.events.iter()).map(|(x, event)| match x {
BrokerEventResult::Forward => {
event.handle_in_client(state, corpus)
},
handled
.iter()
.zip(self.events.iter())
.map(|(x, event)| match x {
BrokerEventResult::Forward => event.handle_in_client(state, corpus),
// Ignore broker-only events
BrokerEventResult::Handled => Ok(()),
}
).collect::<Result<(), AflError>>();
})
.collect::<Result<(), AflError>>();
let count = self.events.len();
dbg!("Handled {} events", count);
self.events.clear();

9
afl/src/stages/mutational.rs
View File

@ -1,6 +1,5 @@
use core::marker::PhantomData;
use crate::{events::Event, engines::State};
use crate::events::EventManager;
use crate::executors::Executor;
use crate::inputs::Input;
@ -9,6 +8,7 @@ use crate::stages::Corpus;
use crate::stages::Stage;
use crate::utils::Rand;
use crate::AflError;
use crate::{engines::State, events::Event};
// TODO multi mutators stage
@ -56,7 +56,12 @@ where
if interesting > 0 {
//let new_testcase = state.input_to_testcase(input_mut, interesting)?;
events.fire(Event::NewTestcase { sender_id: 0, input: input_mut, fitness: interesting , _marker: PhantomData})?;
events.fire(Event::NewTestcase {
sender_id: 0,
input: input_mut,
fitness: interesting,
_marker: PhantomData,
})?;
//state.corpus_mut().add(new_testcase); // TODO: Probably no longer needed, once events work
} else {
state.discard_input(&input_mut)?;