From e78fbc0f0f05c77ae47cc9a78dc67eca387f1381 Mon Sep 17 00:00:00 2001 From: Andrea Fioraldi Date: Fri, 12 Feb 2021 09:58:41 +0100 Subject: [PATCH] split serde_anymap --- afl/src/bolts/metamap.rs | 411 ------------------ afl/src/bolts/mod.rs | 4 +- afl/src/bolts/ownedref.rs | 325 ++++++++++++++ .../bolts/{serde_anymap.rs => serdeany.rs} | 354 +-------------- afl/src/corpus/testcase.rs | 2 +- afl/src/mutators/token_mutations.rs | 2 +- afl/src/observers/mod.rs | 2 +- afl/src/state/mod.rs | 2 +- afl/src/utils.rs | 38 -- 9 files changed, 347 insertions(+), 793 deletions(-) delete mode 100644 afl/src/bolts/metamap.rs create mode 100644 afl/src/bolts/ownedref.rs rename afl/src/bolts/{serde_anymap.rs => serdeany.rs} (65%) diff --git a/afl/src/bolts/metamap.rs b/afl/src/bolts/metamap.rs deleted file mode 100644 index 3edc566a00..0000000000 --- a/afl/src/bolts/metamap.rs +++ /dev/null @@ -1,411 +0,0 @@ -use alloc::{boxed::Box, vec::Vec}; -use core::{ - any::{Any, TypeId}, - slice::{Iter, IterMut}, -}; -use hashbrown::{ - hash_map::{Keys, Values, ValuesMut}, - HashMap, -}; - -/// A map, storing any trait object by TypeId -#[derive(Default)] -pub struct MetaMap { - map: HashMap>, -} - -impl MetaMap { - #[inline] - pub fn get(&self) -> Option<&T> - where - T: Any, - { - self.map - .get(&TypeId::of::()) - .map(|x| x.as_ref().downcast_ref::().unwrap()) - } - - #[inline] - pub fn get_mut(&mut self) -> Option<&mut T> - where - T: Any, - { - self.map - .get_mut(&TypeId::of::()) - .map(|x| x.as_mut().downcast_mut::().unwrap()) - } - - #[inline] - pub fn insert(&mut self, t: T) - where - T: Any, - { - self.map.insert(TypeId::of::(), Box::new(t)); - } - - #[inline] - pub fn len(&self) -> usize { - self.map.len() - } - - #[inline] - pub fn contains(&self) -> bool - where - T: Any, - { - self.map.contains_key(&TypeId::of::()) - } - - pub fn new() -> Self { - Self { - map: HashMap::default(), - } - } -} - -/// A map, allowing to store multiple elements of any given type, by TypeId. -pub struct MultiMetaMap { - map: HashMap>>, -} - -impl MultiMetaMap { - #[inline] - pub fn get(&self) -> Option>, fn(&Box) -> &T>> - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => None, - Some(v) => Some(v.iter().map(|x| x.as_ref().downcast_ref::().unwrap())), - } - } - - #[inline] - pub fn get_mut( - &mut self, - ) -> Option>, fn(&mut Box) -> &mut T>> - where - T: Any, - { - match self.map.get_mut(&TypeId::of::()) { - None => None, - Some(v) => Some( - v.iter_mut() - .map(|x| x.as_mut().downcast_mut::().unwrap()), - ), - } - } - - #[inline] - pub fn insert(&mut self, t: T) - where - T: Any, - { - let typeid = TypeId::of::(); - if !self.map.contains_key(&typeid) { - self.map.insert(typeid, vec![Box::new(t)]); - } else { - self.map.get_mut(&typeid).unwrap().push(Box::new(t)); - } - } - - #[inline] - pub fn len(&self) -> usize { - self.map.len() - } - - #[inline] - pub fn contains(&self) -> bool - where - T: Any, - { - self.map.contains_key(&TypeId::of::()) - } - - pub fn new() -> Self { - Self { - map: HashMap::default(), - } - } -} - -pub struct MetaInstanceMap { - map: HashMap>>, -} - -impl MetaInstanceMap { - #[inline] - pub fn get(&self, instance: &U) -> Option<&T> - where - T: Any, - { - self.get_ptr::(instance as *const _ as *const ()) - } - - pub fn get_ptr(&self, instance: *const ()) -> Option<&T> - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => None, - Some(h) => h - .get(&instance) - .map(|x| x.as_ref().downcast_ref::().unwrap()), - } - } - - #[inline] - pub fn get_mut(&mut self, instance: &U) -> Option<&mut T> - where - T: Any, - { - self.get_mut_ptr::(instance as *const _ as *const ()) - } - - pub fn get_mut_ptr(&mut self, instance: *const ()) -> Option<&mut T> - where - T: Any, - { - match self.map.get_mut(&TypeId::of::()) { - None => None, - Some(h) => h - .get_mut(&instance) - .map(|x| x.as_mut().downcast_mut::().unwrap()), - } - } - - pub fn get_all( - &self, - ) -> Option>, fn(&Box) -> &T>> - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => None, - Some(h) => Some(h.values().map(|x| x.as_ref().downcast_ref::().unwrap())), - } - } - - pub fn get_all_mut( - &mut self, - ) -> Option< - core::iter::Map>, fn(&mut Box) -> &mut T>, - > - where - T: Any, - { - match self.map.get_mut(&TypeId::of::()) { - None => None, - Some(h) => Some( - h.values_mut() - .map(|x| x.as_mut().downcast_mut::().unwrap()), - ), - } - } - - #[inline] - pub fn insert(&mut self, t: T, instance: &U) - where - T: Any, - { - self.insert_ptr(t, instance as *const _ as *const ()) - } - - pub fn insert_ptr(&mut self, t: T, instance: *const ()) - where - T: Any, - { - let typeid = TypeId::of::(); - if !self.map.contains_key(&typeid) { - self.map.insert(typeid, HashMap::default()); - } - self.map - .get_mut(&typeid) - .unwrap() - .insert(instance, Box::new(t)); - } - - #[inline] - pub fn len(&self) -> usize { - self.map.len() - } - - #[inline] - pub fn contains_type(&self) -> bool - where - T: Any, - { - self.map.contains_key(&TypeId::of::()) - } - - #[inline] - pub fn contains(&self, instance: &U) -> bool - where - T: Any, - { - self.contains_ptr::(instance as *const _ as *const ()) - } - - pub fn contains_ptr(&self, instance: *const ()) -> bool - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => false, - Some(h) => h.contains_key(&instance), - } - } - - pub fn new() -> Self { - Self { - map: HashMap::default(), - } - } -} - -pub trait AsAny { - fn as_any(&self) -> &dyn Any; - fn as_any_mut(&mut self) -> &mut dyn Any; -} - -/// A map, allowing to store and get any object by type and name -pub struct NamedAnyMap -where - B: ?Sized + Any + AsAny, -{ - map: HashMap>>, -} - -impl NamedAnyMap -where - B: ?Sized + Any + AsAny, -{ - pub fn get(&self, name: &'static str) -> Option<&T> - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => None, - Some(h) => h - .get(&name) - .map(|x| x.as_any().downcast_ref::().unwrap()), - } - } - - pub fn by_typeid(&self, name: &'static str, typeid: &TypeId) -> Option<&B> { - match self.map.get(typeid) { - None => None, - Some(h) => h.get(&name).map(|x| x.as_ref()), - } - } - - pub fn get_mut(&mut self, name: &'static str) -> Option<&mut T> - where - T: Any, - { - match self.map.get_mut(&TypeId::of::()) { - None => None, - Some(h) => h - .get_mut(&name) - .map(|x| x.as_any_mut().downcast_mut::().unwrap()), - } - } - - pub fn by_typeid_mut(&mut self, name: &'static str, typeid: &TypeId) -> Option<&mut B> { - match self.map.get_mut(typeid) { - None => None, - Some(h) => h.get_mut(&name).map(|x| x.as_mut()), - } - } - - pub fn get_all( - &self, - ) -> Option>, fn(&Box) -> &T>> - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => None, - Some(h) => Some(h.values().map(|x| x.as_any().downcast_ref::().unwrap())), - } - } - - pub fn all_by_typeid( - &self, - typeid: &TypeId, - ) -> Option>, fn(&Box) -> &B>> { - match self.map.get(typeid) { - None => None, - Some(h) => Some(h.values().map(|x| x.as_ref())), - } - } - - pub fn get_all_mut( - &mut self, - ) -> Option>, fn(&mut Box) -> &mut T>> - where - T: Any, - { - match self.map.get_mut(&TypeId::of::()) { - None => None, - Some(h) => Some( - h.values_mut() - .map(|x| x.as_any_mut().downcast_mut::().unwrap()), - ), - } - } - - pub fn all_by_typeid_mut( - &mut self, - typeid: &TypeId, - ) -> Option>, fn(&mut Box) -> &mut B>> - { - match self.map.get_mut(typeid) { - None => None, - Some(h) => Some(h.values_mut().map(|x| x.as_mut())), - } - } - - #[inline] - pub fn all_typeids(&self) -> Keys<'_, TypeId, HashMap<&'static str, Box>> { - self.map.keys() - } - - pub fn insert(&mut self, val: Box, name: &'static str) { - let typeid = val.type_id(); - if !self.map.contains_key(&typeid) { - self.map.insert(typeid, HashMap::default()); - } - self.map.get_mut(&typeid).unwrap().insert(name, val); - } - - #[inline] - pub fn len(&self) -> usize { - self.map.len() - } - - #[inline] - pub fn contains_type(&self) -> bool - where - T: Any, - { - self.map.contains_key(&TypeId::of::()) - } - - #[inline] - pub fn contains(&self, name: &'static str) -> bool - where - T: Any, - { - match self.map.get(&TypeId::of::()) { - None => false, - Some(h) => h.contains_key(&name), - } - } - - pub fn new() -> Self { - Self { - map: HashMap::default(), - } - } -} diff --git a/afl/src/bolts/mod.rs b/afl/src/bolts/mod.rs index 0ced888f4b..f9e6d52f06 100644 --- a/afl/src/bolts/mod.rs +++ b/afl/src/bolts/mod.rs @@ -1,7 +1,7 @@ //! Bolts are no conceptual fuzzing elements, but they keep libafl-based fuzzers together. pub mod llmp; -pub mod metamap; -pub mod serde_anymap; +pub mod ownedref; +pub mod serdeany; pub mod shmem; pub mod tuples; diff --git a/afl/src/bolts/ownedref.rs b/afl/src/bolts/ownedref.rs new file mode 100644 index 0000000000..82b6bef9ab --- /dev/null +++ b/afl/src/bolts/ownedref.rs @@ -0,0 +1,325 @@ +use alloc::{boxed::Box, vec::Vec}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[derive(Clone, Debug)] +pub enum Ptr<'a, T: 'a + ?Sized> { + Ref(&'a T), + Owned(Box), +} + +impl<'a, T: 'a + ?Sized + Serialize> Serialize for Ptr<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + match self { + Ptr::Ref(r) => r.serialize(se), + Ptr::Owned(b) => b.serialize(se), + } + } +} + +impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for Ptr<'a, T> +where + Box: Deserialize<'de>, +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(Ptr::Owned) + } +} + +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 + Serialize> Serialize for PtrMut<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + match self { + PtrMut::Ref(r) => r.serialize(se), + PtrMut::Owned(b) => b.serialize(se), + } + } +} + +impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for PtrMut<'a, T> +where + Box: Deserialize<'de>, +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(PtrMut::Owned) + } +} + +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 + Serialize> Serialize for Slice<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + match self { + Slice::Ref(r) => r.serialize(se), + Slice::Owned(b) => b.serialize(se), + } + } +} + +impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for Slice<'a, T> +where + Vec: Deserialize<'de>, +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(Slice::Owned) + } +} + +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 + Serialize> Serialize for SliceMut<'a, T> { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + match self { + SliceMut::Ref(r) => r.serialize(se), + SliceMut::Owned(b) => b.serialize(se), + } + } +} + +impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for SliceMut<'a, T> +where + Vec: Deserialize<'de>, +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(SliceMut::Owned) + } +} + +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(), + } + } +} + +#[derive(Clone, Debug)] +pub enum Cptr { + Cptr(*const T), + Owned(Box), +} + +impl Serialize for Cptr { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + self.as_ref().serialize(se) + } +} + +impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for Cptr +where + Vec: Deserialize<'de>, +{ + fn deserialize(de: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(de).map(Cptr::Owned) + } +} + +impl Cptr { + pub fn as_ref(&self) -> &T { + match self { + Cptr::Cptr(p) => unsafe { p.as_ref().unwrap() }, + Cptr::Owned(v) => v.as_ref(), + } + } +} + +pub enum CptrMut { + Cptr(*mut T), + Owned(Box), +} + +impl Serialize for CptrMut { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + self.as_ref().serialize(se) + } +} + +impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for CptrMut +where + Vec: Deserialize<'de>, +{ + fn deserialize(de: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(de).map(CptrMut::Owned) + } +} + +impl CptrMut { + pub fn as_ref(&self) -> &T { + match self { + CptrMut::Cptr(p) => unsafe { p.as_ref().unwrap() }, + CptrMut::Owned(b) => b.as_ref(), + } + } + + pub fn as_mut(&mut self) -> &mut T { + match self { + CptrMut::Cptr(p) => unsafe { p.as_mut().unwrap() }, + CptrMut::Owned(b) => b.as_mut(), + } + } +} + +pub enum Array { + Cptr((*const T, usize)), + Owned(Vec), +} + +impl Serialize for Array { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + self.as_slice().serialize(se) + } +} + +impl<'de, T: Sized + Serialize> Deserialize<'de> for Array +where + Vec: Deserialize<'de>, +{ + fn deserialize(de: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(de).map(Array::Owned) + } +} + +impl Array { + pub fn as_slice(&self) -> &[T] { + match self { + Array::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, + Array::Owned(v) => v.as_slice(), + } + } +} + +#[derive(Clone, Debug)] +pub enum ArrayMut { + Cptr((*mut T, usize)), + Owned(Vec), +} + +impl Serialize for ArrayMut { + fn serialize(&self, se: S) -> Result + where + S: Serializer, + { + self.as_slice().serialize(se) + } +} + +impl<'de, T: Sized + Serialize> Deserialize<'de> for ArrayMut +where + Vec: Deserialize<'de>, +{ + fn deserialize(de: D) -> Result + where + D: Deserializer<'de>, + { + Deserialize::deserialize(de).map(ArrayMut::Owned) + } +} + +impl ArrayMut { + pub fn as_slice(&self) -> &[T] { + match self { + ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, + ArrayMut::Owned(v) => v.as_slice(), + } + } + + pub fn as_mut_slice(&mut self) -> &mut [T] { + match self { + ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts_mut(p.0, p.1) }, + ArrayMut::Owned(v) => v.as_mut_slice(), + } + } +} diff --git a/afl/src/bolts/serde_anymap.rs b/afl/src/bolts/serdeany.rs similarity index 65% rename from afl/src/bolts/serde_anymap.rs rename to afl/src/bolts/serdeany.rs index f9df55db0f..c79ced0ce7 100644 --- a/afl/src/bolts/serde_anymap.rs +++ b/afl/src/bolts/serdeany.rs @@ -1,7 +1,8 @@ -use serde::Deserialize; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use alloc::{boxed::Box, vec::Vec}; +use alloc::boxed::Box; use core::any::{Any, TypeId}; + #[cfg(fature = "anymap_debug")] use serde_json; @@ -26,13 +27,13 @@ pub trait SerdeAny: Any + erased_serde::Serialize { } pub struct Wrap<'a, T: ?Sized>(pub &'a T); -impl<'a, T> serde::Serialize for Wrap<'a, T> +impl<'a, T> Serialize for Wrap<'a, T> where T: ?Sized + erased_serde::Serialize + 'a, { fn serialize(&self, serializer: S) -> Result where - S: serde::Serializer, + S: Serializer, { erased_serde::serialize(self.0, serializer) } @@ -78,7 +79,7 @@ macro_rules! create_serde_registry_for_trait { use hashbrown::hash_map::{Keys, Values, ValuesMut}; use hashbrown::HashMap; - use $crate::bolts::serde_anymap::{ + use $crate::bolts::serdeany::{ pack_type_id, unpack_type_id, DeserializeCallback, DeserializeCallbackSeed, }; use $crate::AflError; @@ -118,7 +119,7 @@ macro_rules! create_serde_registry_for_trait { impl Registry { pub fn register(&mut self) where - T: $trait_name + serde::Serialize + serde::de::DeserializeOwned, + T: $trait_name + Serialize + serde::de::DeserializeOwned, { if self.finalized { panic!("Registry is already finalized!"); @@ -145,7 +146,7 @@ macro_rules! create_serde_registry_for_trait { impl RegistryBuilder { pub fn register() where - T: $trait_name + serde::Serialize + serde::de::DeserializeOwned, + T: $trait_name + Serialize + serde::de::DeserializeOwned, { unsafe { REGISTRY.register::(); @@ -463,25 +464,25 @@ macro_rules! create_serde_registry_for_trait { } } - impl<'a> serde::Serialize for dyn $trait_name { + impl<'a> Serialize for dyn $trait_name { fn serialize(&self, se: S) -> Result where - S: serde::Serializer, + S: Serializer, { use serde::ser::SerializeSeq; - let id = $crate::bolts::serde_anymap::unpack_type_id(self.type_id()); + let id = $crate::bolts::serdeany::unpack_type_id(self.type_id()); let mut seq = se.serialize_seq(Some(2))?; seq.serialize_element(&id)?; - seq.serialize_element(&$crate::bolts::serde_anymap::Wrap(self))?; + seq.serialize_element(&$crate::bolts::serdeany::Wrap(self))?; seq.end() } } - impl<'de> serde::Deserialize<'de> for Box { + impl<'de> Deserialize<'de> for Box { fn deserialize(deserializer: D) -> Result, D::Error> where - D: serde::Deserializer<'de>, + D: Deserializer<'de>, { deserializer.deserialize_seq($mod_name::BoxDynVisitor {}) } @@ -489,328 +490,5 @@ macro_rules! create_serde_registry_for_trait { }; } -create_serde_registry_for_trait!(serdeany_serde, crate::bolts::serde_anymap::SerdeAny); -pub use serdeany_serde::*; - -#[derive(Clone, Debug)] -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(r) => r.serialize(se), - Ptr::Owned(b) => b.serialize(se), - } - } -} - -impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for Ptr<'a, T> -where - Box: Deserialize<'de>, -{ - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(deserializer).map(Ptr::Owned) - } -} - -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(r) => r.serialize(se), - PtrMut::Owned(b) => b.serialize(se), - } - } -} - -impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for PtrMut<'a, T> -where - Box: Deserialize<'de>, -{ - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(deserializer).map(PtrMut::Owned) - } -} - -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(r) => r.serialize(se), - Slice::Owned(b) => b.serialize(se), - } - } -} - -impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for Slice<'a, T> -where - Vec: Deserialize<'de>, -{ - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(deserializer).map(Slice::Owned) - } -} - -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(r) => r.serialize(se), - SliceMut::Owned(b) => b.serialize(se), - } - } -} - -impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for SliceMut<'a, T> -where - Vec: Deserialize<'de>, -{ - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(deserializer).map(SliceMut::Owned) - } -} - -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(), - } - } -} - -#[derive(Clone, Debug)] -pub enum Cptr { - Cptr(*const T), - Owned(Box), -} - -impl serde::Serialize for Cptr { - fn serialize(&self, se: S) -> Result - where - S: serde::Serializer, - { - self.as_ref().serialize(se) - } -} - -impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for Cptr -where - Vec: Deserialize<'de>, -{ - fn deserialize(de: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(de).map(Cptr::Owned) - } -} - -impl Cptr { - pub fn as_ref(&self) -> &T { - match self { - Cptr::Cptr(p) => unsafe { p.as_ref().unwrap() }, - Cptr::Owned(v) => v.as_ref(), - } - } -} - -pub enum CptrMut { - Cptr(*mut T), - Owned(Box), -} - -impl serde::Serialize for CptrMut { - fn serialize(&self, se: S) -> Result - where - S: serde::Serializer, - { - self.as_ref().serialize(se) - } -} - -impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for CptrMut -where - Vec: Deserialize<'de>, -{ - fn deserialize(de: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(de).map(CptrMut::Owned) - } -} - -impl CptrMut { - pub fn as_ref(&self) -> &T { - match self { - CptrMut::Cptr(p) => unsafe { p.as_ref().unwrap() }, - CptrMut::Owned(b) => b.as_ref(), - } - } - - pub fn as_mut(&mut self) -> &mut T { - match self { - CptrMut::Cptr(p) => unsafe { p.as_mut().unwrap() }, - CptrMut::Owned(b) => b.as_mut(), - } - } -} - -pub enum Array { - Cptr((*const T, usize)), - Owned(Vec), -} - -impl serde::Serialize for Array { - fn serialize(&self, se: S) -> Result - where - S: serde::Serializer, - { - self.as_slice().serialize(se) - } -} - -impl<'de, T: Sized + serde::Serialize> Deserialize<'de> for Array -where - Vec: Deserialize<'de>, -{ - fn deserialize(de: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(de).map(Array::Owned) - } -} - -impl Array { - pub fn as_slice(&self) -> &[T] { - match self { - Array::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, - Array::Owned(v) => v.as_slice(), - } - } -} - -#[derive(Clone, Debug)] -pub enum ArrayMut { - Cptr((*mut T, usize)), - Owned(Vec), -} - -impl serde::Serialize for ArrayMut { - fn serialize(&self, se: S) -> Result - where - S: serde::Serializer, - { - self.as_slice().serialize(se) - } -} - -impl<'de, T: Sized + serde::Serialize> Deserialize<'de> for ArrayMut -where - Vec: Deserialize<'de>, -{ - fn deserialize(de: D) -> Result - where - D: serde::Deserializer<'de>, - { - Deserialize::deserialize(de).map(ArrayMut::Owned) - } -} - -impl ArrayMut { - pub fn as_slice(&self) -> &[T] { - match self { - ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, - ArrayMut::Owned(v) => v.as_slice(), - } - } - - pub fn as_mut_slice(&mut self) -> &mut [T] { - match self { - ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts_mut(p.0, p.1) }, - ArrayMut::Owned(v) => v.as_mut_slice(), - } - } -} +create_serde_registry_for_trait!(serdeany_registry, crate::bolts::serdeany::SerdeAny); +pub use serdeany_registry::*; diff --git a/afl/src/corpus/testcase.rs b/afl/src/corpus/testcase.rs index 3177b6ca10..f605826683 100644 --- a/afl/src/corpus/testcase.rs +++ b/afl/src/corpus/testcase.rs @@ -6,7 +6,7 @@ use core::{convert::Into, default::Default, option::Option}; use serde::{Deserialize, Serialize}; use crate::{ - bolts::serde_anymap::{SerdeAny, SerdeAnyMap}, + bolts::serdeany::{SerdeAny, SerdeAnyMap}, inputs::Input, AflError, }; diff --git a/afl/src/mutators/token_mutations.rs b/afl/src/mutators/token_mutations.rs index 6459f56868..d762d07ff5 100644 --- a/afl/src/mutators/token_mutations.rs +++ b/afl/src/mutators/token_mutations.rs @@ -2,7 +2,7 @@ //! They may be inserted as part of mutations during fuzzing. use crate::{ - bolts::serde_anymap::SerdeAny, + bolts::serdeany::SerdeAny, inputs::{HasBytesVec, Input}, mutators::*, utils::Rand, diff --git a/afl/src/observers/mod.rs b/afl/src/observers/mod.rs index cc50dbeb01..f1b051cd33 100644 --- a/afl/src/observers/mod.rs +++ b/afl/src/observers/mod.rs @@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize}; use crate::{ bolts::{ - serde_anymap::{ArrayMut, Cptr}, + ownedref::{ArrayMut, Cptr}, tuples::{MatchNameAndType, MatchType, Named, TupleList}, }, utils::current_time, diff --git a/afl/src/state/mod.rs b/afl/src/state/mod.rs index 156ba3339f..d0aa45713f 100644 --- a/afl/src/state/mod.rs +++ b/afl/src/state/mod.rs @@ -9,7 +9,7 @@ use std::{ }; use crate::{ - bolts::serde_anymap::{SerdeAny, SerdeAnyMap}, + bolts::serdeany::{SerdeAny, SerdeAnyMap}, corpus::{Corpus, Testcase}, events::{Event, EventManager, LogSeverity}, executors::{Executor, HasObservers}, diff --git a/afl/src/utils.rs b/afl/src/utils.rs index bd01df80d4..3b206f22f3 100644 --- a/afl/src/utils.rs +++ b/afl/src/utils.rs @@ -1,52 +1,14 @@ //! Utility functions for AFL -use alloc::vec::Vec; use core::{cell::RefCell, debug_assert, fmt::Debug, time}; -use postcard; use serde::{Deserialize, Serialize}; use xxhash_rust::xxh3::xxh3_64_with_seed; #[cfg(feature = "std")] use std::time::{SystemTime, UNIX_EPOCH}; -use crate::{corpus::Corpus, feedbacks::FeedbacksTuple, inputs::Input, state::State, AflError}; - pub type StdRand = RomuTrioRand; -/// Serialize the current state and corpus during an executiont to bytes. -/// This method is needed when the fuzzer run crashes and has to restart. -pub fn serialize_state_corpus( - state: &State, - corpus: &C, -) -> Result, AflError> -where - C: Corpus, - FT: FeedbacksTuple, - I: Input, - R: Rand, -{ - let state_bytes = postcard::to_allocvec(&state)?; - let corpus_bytes = postcard::to_allocvec(&corpus)?; - Ok(postcard::to_allocvec(&(state_bytes, corpus_bytes))?) -} - -/// Deserialize the state and corpus tuple, previously serialized with `serialize_state_corpus(...)` -pub fn deserialize_state_corpus( - state_corpus_serialized: &[u8], -) -> Result<(State, C), AflError> -where - C: Corpus, - FT: FeedbacksTuple, - I: Input, - R: Rand, -{ - let tuple: (Vec, Vec) = postcard::from_bytes(&state_corpus_serialized)?; - Ok(( - postcard::from_bytes(&tuple.0)?, - postcard::from_bytes(&tuple.1)?, - )) -} - /// Ways to get random around here pub trait Rand: Debug + Serialize { // Sets the seed of this Rand