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

Merge pull request #4 from AFLplusplus/event_trait

Browse Source 
Event trait
This commit is contained in:
Andrea Fioraldi 2020-12-15 18:37:04 +01:00 committed by GitHub
commit 0601934177
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 651 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,7 +6,7 @@ use core::marker::PhantomData;
use hashbrown::HashMap;
use crate::corpus::{Corpus, Testcase};
use crate::events::{Event, EventManager};
use crate::events::EventManager;
use crate::executors::{Executor, ExecutorsTuple, HasObservers};
use crate::feedbacks::FeedbacksTuple;
use crate::generators::Generator;
@ -211,15 +211,11 @@ where
if !self.add_if_interesting(corpus, input, fitness)?.is_none() {
added += 1;
}
manager.fire(Event::LoadInitial {
sender_id: 0,
phantom: PhantomData,
})?;
}
manager.fire(Event::log(
manager.log(
0,
format!("Loaded {} over {} initial testcases", added, num),
))?;
)?;
manager.process(self, corpus)?;
Ok(())
}
@ -339,10 +335,7 @@ where
let cur = current_milliseconds();
if cur - last > 60 * 100 {
last = cur;
manager.fire(Event::update_stats(
state.executions(),
state.executions_over_seconds(),
))?;
manager.update_stats(state.executions(), state.executions_over_seconds())?;
}
}
}
@ -417,7 +410,7 @@ mod tests {
use crate::corpus::{Corpus, InMemoryCorpus, Testcase};
use crate::engines::{Engine, Fuzzer, State, StdFuzzer};
#[cfg(feature = "std")]
use crate::events::LoggerEventManager;
use crate::events::{LoggerEventManager, SimpleStats};
use crate::executors::inmemory::InMemoryExecutor;
use crate::executors::{Executor, ExitKind};
use crate::inputs::bytes::BytesInput;
@ -441,7 +434,9 @@ mod tests {
let executor = InMemoryExecutor::<BytesInput, _>::new("main", harness, tuple_list!());
let mut state = State::new(tuple_list!());
let mut events_manager = LoggerEventManager::new(stderr());
let mut events_manager = LoggerEventManager::new(SimpleStats::new(|s| {
println!("{}", s);
}));
let mut engine = Engine::new(executor);
let mut mutator = StdScheduledMutator::new();
mutator.add_mutation(mutation_bitflip);

22
afl/src/events/llmp.rs
View File

@ -734,10 +734,14 @@ impl LlmpReceiver {
/// Returns the next message, tag, buf, if avaliable, else None
#[inline]
pub fn recv_buf(&mut self) -> Result<Option<(u32, &[u8])>, AflError> {
pub fn recv_buf(&mut self) -> Result<Option<(u32, u32, &[u8])>, AflError> {
unsafe {
Ok(match self.recv()? {
Some(msg) => Some(((*msg).tag, (*msg).as_slice(&self.current_recv_map)?)),
Some(msg) => Some((
(*msg).sender,
(*msg).tag,
(*msg).as_slice(&self.current_recv_map)?,
)),
None => None,
})
}
@ -745,10 +749,14 @@ impl LlmpReceiver {
/// Returns the next message, tag, buf, looping until it becomes available
#[inline]
pub fn recv_buf_blocking(&mut self) -> Result<(u32, &[u8]), AflError> {
pub fn recv_buf_blocking(&mut self) -> Result<(u32, u32, &[u8]), AflError> {
unsafe {
let msg = self.recv_blocking()?;
Ok(((*msg).tag, (*msg).as_slice(&self.current_recv_map)?))
Ok((
(*msg).sender,
(*msg).tag,
(*msg).as_slice(&self.current_recv_map)?,
))
}
}
}
@ -1116,17 +1124,18 @@ impl LlmpClient {
/// Returns the next message, tag, buf, if avaliable, else None
#[inline]
pub fn recv_buf(&mut self) -> Result<Option<(u32, &[u8])>, AflError> {
pub fn recv_buf(&mut self) -> Result<Option<(u32, u32, &[u8])>, AflError> {
self.llmp_in.recv_buf()
}
/// Receives a buf from the broker, looping until a messages becomes avaliable
#[inline]
pub fn recv_buf_blocking(&mut self) -> Result<(u32, &[u8]), AflError> {
pub fn recv_buf_blocking(&mut self) -> Result<(u32, u32, &[u8]), AflError> {
self.llmp_in.recv_buf_blocking()
}
}
/*
#[cfg(test)]
mod tests {
@ -1174,3 +1183,4 @@ mod tests {
assert_eq!(broker.llmp_clients.len(), 2);
}
}
*/

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

File diff suppressed because it is too large Load Diff

24
afl/src/serde_anymap.rs
View File

@ -469,9 +469,9 @@ impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for Ptr<'a, T> {
where
S: serde::Serializer,
{
match *self {
Ptr::Ref(ref r) => se.serialize_some(r),
Ptr::Owned(ref b) => se.serialize_some(b.as_ref()),
match self {
Ptr::Ref(r) => r.serialize(se),
Ptr::Owned(b) => b.serialize(se),
}
}
}
@ -507,9 +507,9 @@ impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for PtrMut<'a, T> {
where
S: serde::Serializer,
{
match *self {
PtrMut::Ref(ref r) => se.serialize_some(r),
PtrMut::Owned(ref b) => se.serialize_some(b.as_ref()),
match self {
PtrMut::Ref(r) => r.serialize(se),
PtrMut::Owned(b) => b.serialize(se),
}
}
}
@ -552,9 +552,9 @@ impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for Slice<'a, T> {
where
S: serde::Serializer,
{
match *self {
Slice::Ref(ref r) => se.serialize_some(r),
Slice::Owned(ref b) => se.serialize_some(b.as_slice()),
match self {
Slice::Ref(r) => r.serialize(se),
Slice::Owned(b) => b.serialize(se),
}
}
}
@ -590,9 +590,9 @@ impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for SliceMut<'a, T>
where
S: serde::Serializer,
{
match *self {
SliceMut::Ref(ref r) => se.serialize_some(r),
SliceMut::Owned(ref b) => se.serialize_some(b.as_slice()),
match self {
SliceMut::Ref(r) => r.serialize(se),
SliceMut::Owned(b) => b.serialize(se),
}
}
}

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

@ -1,5 +1,6 @@
use core::marker::PhantomData;
use crate::engines::State;
use crate::events::EventManager;
use crate::executors::{Executor, ExecutorsTuple, HasObservers};
use crate::feedbacks::FeedbacksTuple;
@ -10,7 +11,6 @@ use crate::stages::Corpus;
use crate::stages::{Engine, Stage};
use crate::utils::Rand;
use crate::AflError;
use crate::{engines::State, events::Event};
// TODO multi mutators stage
@ -73,7 +73,8 @@ where
// if needed by particular cases
if fitness > 0 {
// TODO decouple events manager and engine
manager.fire(Event::new_testcase("test".into(), input_mut, observers)?)?;
manager.new_testcase(&input_mut, observers, corpus.count() + 1, "test".into())?;
state.add_if_interesting(corpus, input_mut, fitness)?;
// let _ = corpus.add(testcase);
} else {
state.discard_input(&input_mut)?;

12
fuzzers/libfuzzer/src/lib.rs
View File

@ -2,15 +2,12 @@
extern crate alloc;
#[cfg(feature = "std")]
use std::io::stderr;
use afl::corpus::InMemoryCorpus;
use afl::engines::Engine;
use afl::engines::Fuzzer;
use afl::engines::State;
use afl::engines::StdFuzzer;
use afl::events::LlmpEventManager;
use afl::events::{SimpleStats, LlmpEventManager};
use afl::executors::inmemory::InMemoryExecutor;
use afl::executors::{Executor, ExitKind};
use afl::feedbacks::MaxMapFeedback;
@ -22,7 +19,6 @@ use afl::stages::mutational::StdMutationalStage;
use afl::tuples::tuple_list;
use afl::utils::StdRand;
#[no_mangle]
extern "C" {
/// int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
fn LLVMFuzzerTestOneInput(data: *const u8, size: usize) -> i32;
@ -48,10 +44,8 @@ pub extern "C" fn afl_libfuzzer_main() {
let mut corpus = InMemoryCorpus::new();
let mut generator = RandPrintablesGenerator::new(32);
// TODO: No_std event manager
#[cfg(feature = "std")]
//let mut events = LoggerEventManager::new(stderr());
let mut mgr = LlmpEventManager::new_on_port(1337, stderr()).unwrap();
let stats = SimpleStats::new(|s| println!("{}", s));
let mut mgr = LlmpEventManager::new_on_port(1337, stats).unwrap();
if mgr.is_broker() {
println!("Doing broker things.");
mgr.broker_loop().unwrap();