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

a small cleanup of warns

Browse Source
This commit is contained in:
Andrea Fioraldi 2020-12-09 10:34:59 +01:00
parent 94736f0b31
commit 2c299a1518
9 changed files with 135 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,9 +1,7 @@
//! The engine is the core piece of every good fuzzer
use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::vec::Vec;
use core::cell::RefCell;
use core::fmt::Debug;
use core::marker::PhantomData;
use hashbrown::HashMap;
@ -14,7 +12,6 @@ use crate::executors::Executor;
use crate::feedbacks::Feedback;
use crate::generators::Generator;
use crate::inputs::Input;
use crate::observers::Observer;
use crate::stages::Stage;
use crate::utils::{current_milliseconds, Rand};
use crate::AflError;
@ -199,10 +196,14 @@ where
let input = generator.generate(rand)?;
let fitness = self.evaluate_input(&input, engine)?;
self.add_if_interesting(corpus, input, fitness)?;
engine.events_manager_mut().fire(Event::LoadInitial {
sender_id: 0,
phantom: PhantomData,
}, self, corpus)?;
engine.events_manager_mut().fire(
Event::LoadInitial {
sender_id: 0,
phantom: PhantomData,
},
self,
corpus,
)?;
}
engine.events_manager_mut().process(self, corpus)?;
Ok(())
@ -324,11 +325,15 @@ where
let cur = current_milliseconds();
if cur - last > 60 * 100 {
last = cur;
engine.events_manager_mut().fire(Event::UpdateStats {
sender_id: 0,
new_execs: 1,
phantom: PhantomData,
}, state, corpus)?; // TODO self.new_execs});
engine.events_manager_mut().fire(
Event::UpdateStats {
sender_id: 0,
new_execs: 1,
phantom: PhantomData,
},
state,
corpus,
)?; // TODO self.new_execs});
}
}
}
@ -411,7 +416,7 @@ mod tests {
let executor = InMemoryExecutor::<BytesInput>::new(harness);
let mut state = State::new();
let mut events_manager = LoggerEventManager::new(stderr());
let events_manager = LoggerEventManager::new(stderr());
let mut engine = Engine::new(executor, events_manager);
let mut mutator = StdScheduledMutator::new();

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

@ -21,8 +21,8 @@ use crate::corpus::{Corpus, Testcase};
use crate::engines::State;
use crate::executors::Executor;
use crate::inputs::Input;
use crate::utils::Rand;
use crate::serde_anymap::{Ptr, PtrMut};
use crate::utils::Rand;
use crate::AflError;
/// Indicate if an event worked or not
enum BrokerEventResult {
@ -88,7 +88,7 @@ where
NewTestcase2 {
sender_id: u64,
input: Ptr<'a, I>,
observers: PtrMut<'a, crate::observers::observer_serde::NamedSerdeAnyMap>
observers: PtrMut<'a, crate::observers::observer_serde::NamedSerdeAnyMap>,
},
UpdateStats {
sender_id: u64,
@ -262,7 +262,12 @@ where
fn enabled(&self) -> bool;
/// Fire an Event
fn fire<'a>(&mut self, event: Event<'a, C, E, I, R>, state: &mut State<I, R>, corpus: &mut C) -> Result<(), AflError>;
fn fire<'a>(
&mut self,
event: Event<'a, C, E, I, R>,
state: &mut State<I, R>,
corpus: &mut C,
) -> Result<(), AflError>;
/// Lookup for incoming events and process them.
/// Return the number of processes events or an error
@ -295,7 +300,7 @@ where
{
writer: W,
count: usize,
phantom: PhantomData<(C, E, I, R)>
phantom: PhantomData<(C, E, I, R)>,
}
#[cfg(feature = "std")]
@ -312,7 +317,12 @@ where
true
}
fn fire<'a>(&mut self, event: Event<'a, C, E, I, R>, state: &mut State<I, R>, corpus: &mut C) -> Result<(), AflError> {
fn fire<'a>(
&mut self,
event: Event<'a, C, E, I, R>,
state: &mut State<I, R>,
corpus: &mut C,
) -> Result<(), AflError> {
match event.handle_in_broker(state, corpus)? {
BrokerEventResult::Forward => event.handle_in_client(state, corpus)?,
// Ignore broker-only events
@ -321,7 +331,7 @@ where
Ok(())
}
fn process(&mut self, state: &mut State<I, R>, corpus: &mut C) -> Result<usize, AflError> {
fn process(&mut self, _state: &mut State<I, R>, _corpus: &mut C) -> Result<usize, AflError> {
let c = self.count;
self.count = 0;
Ok(c)
@ -342,7 +352,7 @@ where
Self {
writer: writer,
count: 0,
phantom: PhantomData
phantom: PhantomData,
}
}
}

2
afl/src/executors/inmemory.rs
View File

@ -3,8 +3,8 @@ use core::ptr;
use crate::executors::{Executor, ExitKind};
use crate::inputs::Input;
use crate::observers::Observer;
use crate::observers::observer_serde::NamedSerdeAnyMap;
use crate::observers::Observer;
use crate::AflError;
type HarnessFunction<I> = fn(&dyn Executor<I>, &[u8]) -> ExitKind;

2
afl/src/executors/mod.rs
View File

@ -1,8 +1,8 @@
pub mod inmemory;
use crate::inputs::Input;
use crate::observers::Observer;
use crate::observers::observer_serde::NamedSerdeAnyMap;
use crate::observers::Observer;
use crate::AflError;
pub enum ExitKind {

10
afl/src/feedbacks/mod.rs
View File

@ -2,10 +2,10 @@ use alloc::vec::Vec;
use core::marker::PhantomData;
use num::Integer;
use crate::corpus::{Testcase, TestcaseMetadata};
use crate::corpus::Testcase;
use crate::inputs::Input;
use crate::observers::{MapObserver, Observer};
use crate::observers::observer_serde::NamedSerdeAnyMap;
use crate::observers::MapObserver;
use crate::AflError;
pub trait Feedback<I>
@ -13,11 +13,7 @@ where
I: Input,
{
/// is_interesting should return the "Interestingness" from 0 to 255 (percent times 2.55)
fn is_interesting(
&mut self,
input: &I,
observers: &NamedSerdeAnyMap,
) -> Result<u32, AflError>;
fn is_interesting(&mut self, input: &I, observers: &NamedSerdeAnyMap) -> Result<u32, AflError>;
/// Append to the testcase the generated metadata in case of a new corpus item
fn append_metadata(&mut self, _testcase: &mut Testcase<I>) -> Result<(), AflError> {

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

@ -27,18 +27,17 @@ pub trait Observer: SerdeAny + 'static {
crate::create_serde_registry_for_trait!(observer_serde, crate::observers::Observer);
#[derive(Serialize, Deserialize)]
pub struct NopObserver {
}
pub struct NopObserver {}
impl Observer for NopObserver {
fn name(&self) -> &'static str {
"aa"
}
fn reset(&mut self) -> Result<(), AflError> { Ok(()) }
fn reset(&mut self) -> Result<(), AflError> {
Ok(())
}
}
impl SerdeAny for NopObserver
{
impl SerdeAny for NopObserver {
fn as_any(&self) -> &dyn Any {
self
}

130
afl/src/serde_anymap.rs
View File

@ -1,12 +1,7 @@
use hashbrown::HashMap;
use serde::{Deserialize, Serialize};
use alloc::boxed::Box;
use core::any::{Any, TypeId};
use core::default::Default;
use hashbrown::hash_map::{Keys, Values, ValuesMut};
use crate::AflError;
pub fn pack_type_id(id: u64) -> TypeId {
unsafe { *(&id as *const u64 as *const TypeId) }
@ -37,11 +32,17 @@ where
pub type DeserializeCallback<B> =
fn(&mut dyn erased_serde::Deserializer) -> Result<Box<B>, erased_serde::Error>;
pub struct DeserializeCallbackSeed<B> where B: ?Sized {
pub struct DeserializeCallbackSeed<B>
where
B: ?Sized,
{
pub cb: DeserializeCallback<B>,
}
impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B> where B: ?Sized {
impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B>
where
B: ?Sized,
{
type Value = Box<B>;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
@ -56,20 +57,21 @@ impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B> wher
#[macro_export]
macro_rules! create_serde_registry_for_trait {
($mod_name:ident, $trait_name:path) => {
pub mod $mod_name {
use alloc::boxed::Box;
use core::fmt;
use core::any::{Any, TypeId};
use serde::{Deserialize, Serialize};
use hashbrown::HashMap;
use hashbrown::hash_map::{Keys, Values, ValuesMut};
use alloc::boxed::Box;
use core::any::{Any, TypeId};
use core::fmt;
use serde::{Deserialize, Serialize};
use hashbrown::hash_map::{Keys, Values, ValuesMut};
use hashbrown::HashMap;
use $crate::serde_anymap::{
pack_type_id, unpack_type_id, DeserializeCallback, DeserializeCallbackSeed,
};
use $crate::AflError;
use $crate::serde_anymap::{DeserializeCallback, DeserializeCallbackSeed, pack_type_id, unpack_type_id};
pub struct BoxDynVisitor {}
impl<'de> serde::de::Visitor<'de> for BoxDynVisitor {
type Value = Box<dyn $trait_name>;
@ -82,7 +84,7 @@ macro_rules! create_serde_registry_for_trait {
where
V: serde::de::SeqAccess<'de>,
{
/*let id: u64 = visitor.next_element()?.unwrap();
let id: u64 = visitor.next_element()?.unwrap();
let cb = unsafe {
*REGISTRY
.deserializers
@ -90,14 +92,13 @@ macro_rules! create_serde_registry_for_trait {
.unwrap()
.get(&id)
.expect("Cannot deserialize an unregistered type")
};*/
//let seed = DeserializeCallbackSeed::<dyn $trait_name> { cb: cb };
//let obj: Self::Value = visitor.next_element_seed(seed)?.unwrap();
let obj = Box::new(crate::observers::NopObserver::new());
};
let seed = DeserializeCallbackSeed::<dyn $trait_name> { cb: cb };
let obj: Self::Value = visitor.next_element_seed(seed)?.unwrap();
Ok(obj)
}
}
struct Registry {
deserializers: Option<HashMap<u64, DeserializeCallback<dyn $trait_name>>>,
finalized: bool,
@ -112,7 +113,8 @@ macro_rules! create_serde_registry_for_trait {
panic!("Registry is already finalized!");
}
let deserializers = self.deserializers.get_or_insert_with(|| HashMap::default());
let deserializers =
self.deserializers.get_or_insert_with(|| HashMap::default());
deserializers.insert(unpack_type_id(TypeId::of::<T>()), |de| {
Ok(Box::new(erased_serde::deserialize::<T>(de)?))
});
@ -145,15 +147,13 @@ macro_rules! create_serde_registry_for_trait {
}
}
}
#[derive(Serialize, Deserialize)]
pub struct SerdeAnyMap
{
pub struct SerdeAnyMap {
map: HashMap<u64, Box<dyn $trait_name>>,
}
impl SerdeAnyMap
{
impl SerdeAnyMap {
pub fn get<T>(&self) -> Option<&T>
where
T: $trait_name,
@ -198,22 +198,18 @@ macro_rules! create_serde_registry_for_trait {
}
}
impl Default for SerdeAnyMap
{
impl Default for SerdeAnyMap {
fn default() -> Self {
Self::new()
}
}
#[derive(Serialize, Deserialize)]
pub struct NamedSerdeAnyMap
{
pub struct NamedSerdeAnyMap {
map: HashMap<u64, HashMap<u64, Box<dyn $trait_name>>>,
}
impl NamedSerdeAnyMap
{
impl NamedSerdeAnyMap {
pub fn get<T>(&self, name: &'static str) -> Option<&T>
where
T: Any,
@ -226,7 +222,11 @@ macro_rules! create_serde_registry_for_trait {
}
}
pub fn by_typeid(&self, name: &'static str, typeid: &TypeId) -> Option<&dyn $trait_name> {
pub fn by_typeid(
&self,
name: &'static str,
typeid: &TypeId,
) -> Option<&dyn $trait_name> {
match self.map.get(&unpack_type_id(*typeid)) {
None => None,
Some(h) => h
@ -247,7 +247,11 @@ macro_rules! create_serde_registry_for_trait {
}
}
pub fn by_typeid_mut(&mut self, name: &'static str, typeid: &TypeId) -> Option<&mut dyn $trait_name> {
pub fn by_typeid_mut(
&mut self,
name: &'static str,
typeid: &TypeId,
) -> Option<&mut dyn $trait_name> {
match self.map.get_mut(&unpack_type_id(*typeid)) {
None => None,
Some(h) => h
@ -256,20 +260,34 @@ macro_rules! create_serde_registry_for_trait {
}
}
pub fn get_all<T>(&self) -> Option<core::iter::Map<Values<'_, u64, Box<dyn $trait_name>>, fn(&Box<dyn $trait_name>) -> &T>>
pub fn get_all<T>(
&self,
) -> Option<
core::iter::Map<
Values<'_, u64, Box<dyn $trait_name>>,
fn(&Box<dyn $trait_name>) -> &T,
>,
>
where
T: Any,
{
match self.map.get(&unpack_type_id(TypeId::of::<T>())) {
None => None,
Some(h) => Some(h.values().map(|x| x.as_any().downcast_ref::<T>().unwrap())),
Some(h) => {
Some(h.values().map(|x| x.as_any().downcast_ref::<T>().unwrap()))
}
}
}
pub fn all_by_typeid(
&self,
typeid: &TypeId,
) -> Option<core::iter::Map<Values<'_, u64, Box<dyn $trait_name>>, fn(&Box<dyn $trait_name>) -> &dyn $trait_name>> {
) -> Option<
core::iter::Map<
Values<'_, u64, Box<dyn $trait_name>>,
fn(&Box<dyn $trait_name>) -> &dyn $trait_name,
>,
> {
match self.map.get(&unpack_type_id(*typeid)) {
None => None,
Some(h) => Some(h.values().map(|x| x.as_ref())),
@ -278,7 +296,12 @@ macro_rules! create_serde_registry_for_trait {
pub fn get_all_mut<T>(
&mut self,
) -> Option<core::iter::Map<ValuesMut<'_, u64, Box<dyn $trait_name>>, fn(&mut Box<dyn $trait_name>) -> &mut T>>
) -> Option<
core::iter::Map<
ValuesMut<'_, u64, Box<dyn $trait_name>>,
fn(&mut Box<dyn $trait_name>) -> &mut T,
>,
>
where
T: Any,
{
@ -294,7 +317,12 @@ macro_rules! create_serde_registry_for_trait {
pub fn all_by_typeid_mut(
&mut self,
typeid: &TypeId,
) -> Option<core::iter::Map<ValuesMut<'_, u64, Box<dyn $trait_name>>, fn(&mut Box<dyn $trait_name>) -> &mut dyn $trait_name>> {
) -> Option<
core::iter::Map<
ValuesMut<'_, u64, Box<dyn $trait_name>>,
fn(&mut Box<dyn $trait_name>) -> &mut dyn $trait_name,
>,
> {
match self.map.get_mut(&unpack_type_id(*typeid)) {
None => None,
Some(h) => Some(h.values_mut().map(|x| x.as_mut())),
@ -303,7 +331,10 @@ macro_rules! create_serde_registry_for_trait {
pub fn all_typeids(
&self,
) -> core::iter::Map<Keys<'_, u64, HashMap<u64, Box<dyn $trait_name>>>, fn(&u64) -> TypeId> {
) -> core::iter::Map<
Keys<'_, u64, HashMap<u64, Box<dyn $trait_name>>>,
fn(&u64) -> TypeId,
> {
self.map.keys().map(|x| pack_type_id(*x))
}
@ -370,15 +401,13 @@ macro_rules! create_serde_registry_for_trait {
}
}
impl Default for NamedSerdeAnyMap
{
impl Default for NamedSerdeAnyMap {
fn default() -> Self {
Self::new()
}
}
}
impl<'a> serde::Serialize for dyn $trait_name {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
@ -393,7 +422,7 @@ macro_rules! create_serde_registry_for_trait {
seq.end()
}
}
impl<'de> serde::Deserialize<'de> for Box<dyn $trait_name> {
fn deserialize<D>(deserializer: D) -> Result<Box<dyn $trait_name>, D::Error>
where
@ -402,7 +431,6 @@ macro_rules! create_serde_registry_for_trait {
deserializer.deserialize_seq($mod_name::BoxDynVisitor {})
}
}
};
}

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

@ -56,11 +56,15 @@ where
let testcase_maybe = state.testcase_if_interesting(input_mut, fitness)?;
if let Some(testcase) = testcase_maybe {
//corpus.entries()[idx]
engine.events_manager_mut().fire(Event::NewTestcase {
sender_id: 0,
testcase: testcase,
phantom: PhantomData,
}, state, corpus)?;
engine.events_manager_mut().fire(
Event::NewTestcase {
sender_id: 0,
testcase: testcase,
phantom: PhantomData,
},
state,
corpus,
)?;
}
}
Ok(())

2
afl/src/utils.rs
View File

@ -303,7 +303,7 @@ pub const fn next_pow2(val: u64) -> u64 {
#[cfg(test)]
mod tests {
use xxhash_rust::xxh3::xxh3_64_with_seed;
//use xxhash_rust::xxh3::xxh3_64_with_seed;
use crate::utils::{next_pow2, Rand, StdRand};