From 999e7023e40b71adc878c7e6dc136e6e21ea8be4 Mon Sep 17 00:00:00 2001 From: Andrea Fioraldi Date: Thu, 10 Dec 2020 17:05:49 +0100 Subject: [PATCH] serialize event test --- afl/src/events/mod.rs | 96 ++++++++++++++++++++++++------------ afl/src/serde_anymap.rs | 106 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 167 insertions(+), 35 deletions(-) diff --git a/afl/src/events/mod.rs b/afl/src/events/mod.rs index 001576b5d5..933669fe5a 100644 --- a/afl/src/events/mod.rs +++ b/afl/src/events/mod.rs @@ -35,7 +35,7 @@ pub trait ShowStats {} /* /// A custom event, in case a user wants to extend the features (at compile time) -pub trait CustomEvent +pub trait CustomEvent where S: State, C: Corpus, @@ -52,7 +52,7 @@ where } struct UnusedCustomEvent {} -impl CustomEvent for UnusedCustomEvent +impl CustomEvent for UnusedCustomEvent where S: State, C: Corpus, @@ -69,17 +69,14 @@ where /// Events sent around in the library #[derive(Serialize, Deserialize)] #[serde(bound = "I: serde::de::DeserializeOwned")] -pub enum Event<'a, C, E, I, R> +pub enum Event<'a, I> where - C: Corpus, - E: Executor, I: Input, - R: Rand, - // CE: CustomEvent, + // CE: CustomEvent, { LoadInitial { sender_id: u64, - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, NewTestcase { sender_id: u64, @@ -90,37 +87,34 @@ where sender_id: u64, executions: usize, execs_over_sec: u64, - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, Crash { sender_id: u64, input: I, - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, Timeout { sender_id: u64, input: I, - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, Log { sender_id: u64, severity_level: u8, message: String, - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, None { - phantom: PhantomData<(C, E, I, R)>, + phantom: PhantomData, }, //Custom {sender_id: u64, custom_event: CE}, } -impl<'a, C, E, I, R> Event<'a, C, E, I, R> +impl<'a, I> Event<'a, I> where - C: Corpus, - E: Executor, I: Input, - R: Rand, - //CE: CustomEvent, + //CE: CustomEvent, { pub fn name(&self) -> &str { match self { @@ -191,7 +185,7 @@ where /// Fire an Event fn fire<'a>( &mut self, - event: Event<'a, C, E, I, R>, + event: Event<'a, I>, state: &mut State, corpus: &mut C, ) -> Result<(), AflError>; @@ -209,7 +203,7 @@ where // TODO the broker has a state? do we need to pass state and corpus? fn handle_in_broker( &self, - event: &Event, + event: &Event, /*broker: &dyn EventManager,*/ _state: &mut State, _corpus: &mut C, ) -> Result { @@ -266,7 +260,7 @@ where fn handle_in_client( &self, - event: Event, + event: Event, /*client: &dyn EventManager,*/ _state: &mut State, corpus: &mut C, ) -> Result<(), AflError> { @@ -305,7 +299,7 @@ where pub struct LoggerEventManager where W: Write, - //CE: CustomEvent, + //CE: CustomEvent, { writer: W, count: usize, @@ -320,11 +314,11 @@ where I: Input, R: Rand, W: Write, - //CE: CustomEvent, + //CE: CustomEvent, { fn fire<'a>( &mut self, - event: Event<'a, C, E, I, R>, + event: Event<'a, I>, state: &mut State, corpus: &mut C, ) -> Result<(), AflError> { @@ -370,7 +364,7 @@ where I: Input, E: Executor, R: Rand, - //CE: CustomEvent, + //CE: CustomEvent, { llmp_broker: llmp::LlmpBroker, phantom: PhantomData<(C, E, I, R)>, @@ -390,7 +384,7 @@ where I: Input, E: Executor, R: Rand, - //CE: CustomEvent, + //CE: CustomEvent, { llmp_client: llmp::LlmpClient, phantom: PhantomData<(C, E, I, R)>, @@ -403,12 +397,12 @@ where E: Executor, I: Input, R: Rand, - //CE: CustomEvent, + //CE: CustomEvent, { /// Fire an Event fn fire<'a>( &mut self, - event: Event<'a, C, E, I, R>, + event: Event<'a, I>, state: &mut State, corpus: &mut C, ) -> Result<(), AflError> { @@ -455,7 +449,7 @@ where fn handle_in_broker( &self, - event: &Event, + event: &Event, /*broker: &dyn EventManager,*/ _state: &mut State, _corpus: &mut C, ) -> Result { @@ -512,7 +506,7 @@ where fn handle_in_client( &self, - event: Event, + event: Event, /*client: &dyn EventManager,*/ _state: &mut State, corpus: &mut C, ) -> Result<(), AflError> { @@ -534,3 +528,45 @@ where } } } + +#[cfg(feature = "std")] +#[cfg(test)] +mod tests { + + use crate::events::Event; + use crate::serde_anymap::{Ptr, PtrMut}; + use crate::inputs::bytes::BytesInput; + use crate::observers::{Observer, StdMapObserver}; + use crate::observers::observer_serde::NamedSerdeAnyMap; + + static mut MAP: [u32; 4] = [0; 4]; + + #[test] + fn test_event_serde() { + let mut map = NamedSerdeAnyMap::new(); + let obv = StdMapObserver::new("test", unsafe { &mut MAP }); + map.insert(Box::new(obv), &"key".to_string()); + + let i = BytesInput::new(vec![0]); + let e = Event::NewTestcase { + sender_id: 0, + input: Ptr::Ref(&i), + observers: PtrMut::Ref(&mut map), + }; + + let j = serde_json::to_string(&e).unwrap(); + + let d: Event = serde_json::from_str(&j).unwrap(); + match d { + Event::NewTestcase { + sender_id: _, + input: _, + observers: obs, + } => { + let o = obs.as_ref().get::>(&"key".to_string()).unwrap(); + assert_eq!("test".to_string(), *o.name()); + }, + _ => panic!("mistmatch".to_string()) + }; + } +} diff --git a/afl/src/serde_anymap.rs b/afl/src/serde_anymap.rs index 9583f177ca..d0a1b9dd64 100644 --- a/afl/src/serde_anymap.rs +++ b/afl/src/serde_anymap.rs @@ -364,7 +364,7 @@ macro_rules! create_serde_registry_for_trait { } pub fn insert(&mut self, val: Box, name: &String) { - let id = unpack_type_id(val.type_id()); + let id = unpack_type_id((*val).type_id()); if !self.map.contains_key(&id) { self.map.insert(id, HashMap::default()); } @@ -438,12 +438,23 @@ macro_rules! create_serde_registry_for_trait { create_serde_registry_for_trait!(serdeany_serde, crate::serde_anymap::SerdeAny); pub use serdeany_serde::*; -#[derive(Serialize)] pub enum Ptr<'a, T: 'a + ?Sized> { Ref(&'a T), Owned(Box), } +impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for Ptr<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: serde::Serializer, + { + match *self { + Ptr::Ref(ref r) => se.serialize_some(r), + Ptr::Owned(ref b) => se.serialize_some(b.as_ref()) + } + } +} + impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for Ptr<'a, T> where Box: Deserialize<'de>, @@ -456,12 +467,33 @@ where } } -#[derive(Serialize)] +impl<'a, T: Sized> Ptr<'a, T> { + pub fn as_ref(&self) -> &T { + match self { + Ptr::Ref(r) => r, + Ptr::Owned(v) => v.as_ref(), + } + } + +} + pub enum PtrMut<'a, T: 'a + ?Sized> { Ref(&'a mut T), Owned(Box), } +impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for PtrMut<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: serde::Serializer, + { + match *self { + PtrMut::Ref(ref r) => se.serialize_some(r), + PtrMut::Owned(ref b) => se.serialize_some(b.as_ref()) + } + } +} + impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for PtrMut<'a, T> where Box: Deserialize<'de>, @@ -474,12 +506,40 @@ where } } -#[derive(Serialize)] +impl<'a, T: Sized> PtrMut<'a, T> { + pub fn as_ref(&self) -> &T { + match self { + PtrMut::Ref(r) => r, + PtrMut::Owned(v) => v.as_ref(), + } + } + + pub fn as_mut(&mut self) -> &T { + match self { + PtrMut::Ref(r) => r, + PtrMut::Owned(v) => v.as_mut(), + } + } +} + + pub enum Slice<'a, T: 'a + Sized> { Ref(&'a [T]), Owned(Vec), } +impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for Slice<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: serde::Serializer, + { + match *self { + Slice::Ref(ref r) => se.serialize_some(r), + Slice::Owned(ref b) => se.serialize_some(b.as_slice()) + } + } +} + impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for Slice<'a, T> where Vec: Deserialize<'de>, @@ -492,12 +552,32 @@ where } } -#[derive(Serialize)] +impl<'a, T: Sized> Slice<'a, T> { + pub fn as_slice(&self) -> &[T] { + match self { + Slice::Ref(r) => r, + Slice::Owned(v) => v.as_slice(), + } + } +} + pub enum SliceMut<'a, T: 'a + Sized> { Ref(&'a mut [T]), Owned(Vec), } +impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for SliceMut<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: serde::Serializer, + { + match *self { + SliceMut::Ref(ref r) => se.serialize_some(r), + SliceMut::Owned(ref b) => se.serialize_some(b.as_slice()) + } + } +} + impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for SliceMut<'a, T> where Vec: Deserialize<'de>, @@ -510,6 +590,22 @@ where } } +impl<'a, T: Sized> SliceMut<'a, T> { + pub fn as_slice(&self) -> &[T] { + match self { + SliceMut::Ref(r) => r, + SliceMut::Owned(v) => v.as_slice(), + } + } + + pub fn as_mut_slice(&mut self) -> &[T] { + match self { + SliceMut::Ref(r) => r, + SliceMut::Owned(v) => v.as_mut_slice(), + } + } +} + pub enum Array { Cptr((*const T, usize)), Owned(Vec),