From 1829fcf19124eb9b4db3eac7b93503998bf33dfc Mon Sep 17 00:00:00 2001 From: Andrea Fioraldi Date: Mon, 26 Apr 2021 10:17:42 +0200 Subject: [PATCH] refactor ownedref --- libafl/src/bolts/ownedref.rs | 166 +++++++++++++++++++---------------- libafl/src/inputs/bytes.rs | 7 +- libafl/src/inputs/mod.rs | 22 +---- libafl/src/observers/map.rs | 22 ++--- 4 files changed, 107 insertions(+), 110 deletions(-) diff --git a/libafl/src/bolts/ownedref.rs b/libafl/src/bolts/ownedref.rs index 979f3fb00d..ad1a3c154d 100644 --- a/libafl/src/bolts/ownedref.rs +++ b/libafl/src/bolts/ownedref.rs @@ -7,64 +7,74 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer}; /// Wrap a reference and convert to a Box on serialize #[derive(Clone, Debug)] -pub enum Ptr<'a, T: 'a + ?Sized> { +pub enum OwnedRef<'a, T> +where + T: 'a + ?Sized, +{ Ref(&'a T), Owned(Box), } -impl<'a, T: 'a + ?Sized + Serialize> Serialize for Ptr<'a, T> { +impl<'a, T> Serialize for OwnedRef<'a, T> +where + T: 'a + ?Sized + Serialize, +{ fn serialize(&self, se: S) -> Result where S: Serializer, { match self { - Ptr::Ref(r) => r.serialize(se), - Ptr::Owned(b) => b.serialize(se), + OwnedRef::Ref(r) => r.serialize(se), + OwnedRef::Owned(b) => b.serialize(se), } } } -impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for Ptr<'a, T> +impl<'de, 'a, T> Deserialize<'de> for OwnedRef<'a, T> where + T: 'a + ?Sized, Box: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { - Deserialize::deserialize(deserializer).map(Ptr::Owned) + Deserialize::deserialize(deserializer).map(OwnedRef::Owned) } } -impl<'a, T: Sized> AsRef for Ptr<'a, T> { +impl<'a, T> AsRef for OwnedRef<'a, T> +where + T: Sized, +{ fn as_ref(&self) -> &T { match self { - Ptr::Ref(r) => r, - Ptr::Owned(v) => v.as_ref(), + OwnedRef::Ref(r) => r, + OwnedRef::Owned(v) => v.as_ref(), } } } /// Wrap a mutable reference and convert to a Box on serialize #[derive(Debug)] -pub enum PtrMut<'a, T: 'a + ?Sized> { +pub enum OwnedRefMut<'a, T: 'a + ?Sized> { Ref(&'a mut T), Owned(Box), } -impl<'a, T: 'a + ?Sized + Serialize> Serialize for PtrMut<'a, T> { +impl<'a, T: 'a + ?Sized + Serialize> Serialize for OwnedRefMut<'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), + OwnedRefMut::Ref(r) => r.serialize(se), + OwnedRefMut::Owned(b) => b.serialize(se), } } } -impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for PtrMut<'a, T> +impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for OwnedRefMut<'a, T> where Box: Deserialize<'de>, { @@ -72,48 +82,48 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(deserializer).map(PtrMut::Owned) + Deserialize::deserialize(deserializer).map(OwnedRefMut::Owned) } } -impl<'a, T: Sized> AsRef for PtrMut<'a, T> { +impl<'a, T: Sized> AsRef for OwnedRefMut<'a, T> { fn as_ref(&self) -> &T { match self { - PtrMut::Ref(r) => r, - PtrMut::Owned(v) => v.as_ref(), + OwnedRefMut::Ref(r) => r, + OwnedRefMut::Owned(v) => v.as_ref(), } } } -impl<'a, T: Sized> AsMut for PtrMut<'a, T> { +impl<'a, T: Sized> AsMut for OwnedRefMut<'a, T> { fn as_mut(&mut self) -> &mut T { match self { - PtrMut::Ref(r) => r, - PtrMut::Owned(v) => v.as_mut(), + OwnedRefMut::Ref(r) => r, + OwnedRefMut::Owned(v) => v.as_mut(), } } } /// Wrap a slice and convert to a Vec on serialize #[derive(Clone, Debug)] -pub enum Slice<'a, T: 'a + Sized> { +pub enum OwnedSlice<'a, T: 'a + Sized> { Ref(&'a [T]), Owned(Vec), } -impl<'a, T: 'a + Sized + Serialize> Serialize for Slice<'a, T> { +impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSlice<'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), + OwnedSlice::Ref(r) => r.serialize(se), + OwnedSlice::Owned(b) => b.serialize(se), } } } -impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for Slice<'a, T> +impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedSlice<'a, T> where Vec: Deserialize<'de>, { @@ -121,39 +131,39 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(deserializer).map(Slice::Owned) + Deserialize::deserialize(deserializer).map(OwnedSlice::Owned) } } -impl<'a, T: Sized> Slice<'a, T> { +impl<'a, T: Sized> OwnedSlice<'a, T> { pub fn as_slice(&self) -> &[T] { match self { - Slice::Ref(r) => r, - Slice::Owned(v) => v.as_slice(), + OwnedSlice::Ref(r) => r, + OwnedSlice::Owned(v) => v.as_slice(), } } } /// Wrap a mutable slice and convert to a Vec on serialize #[derive(Debug)] -pub enum SliceMut<'a, T: 'a + Sized> { +pub enum OwnedSliceMut<'a, T: 'a + Sized> { Ref(&'a mut [T]), Owned(Vec), } -impl<'a, T: 'a + Sized + Serialize> Serialize for SliceMut<'a, T> { +impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSliceMut<'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), + OwnedSliceMut::Ref(r) => r.serialize(se), + OwnedSliceMut::Owned(b) => b.serialize(se), } } } -impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for SliceMut<'a, T> +impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedSliceMut<'a, T> where Vec: Deserialize<'de>, { @@ -161,34 +171,34 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(deserializer).map(SliceMut::Owned) + Deserialize::deserialize(deserializer).map(OwnedSliceMut::Owned) } } -impl<'a, T: Sized> SliceMut<'a, T> { +impl<'a, T: Sized> OwnedSliceMut<'a, T> { pub fn as_slice(&self) -> &[T] { match self { - SliceMut::Ref(r) => r, - SliceMut::Owned(v) => v.as_slice(), + OwnedSliceMut::Ref(r) => r, + OwnedSliceMut::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(), + OwnedSliceMut::Ref(r) => r, + OwnedSliceMut::Owned(v) => v.as_mut_slice(), } } } /// Wrap a C-style pointer and convert to a Box on serialize #[derive(Clone, Debug)] -pub enum Cptr { - Cptr(*const T), +pub enum OwnedPtr { + Ptr(*const T), Owned(Box), } -impl Serialize for Cptr { +impl Serialize for OwnedPtr { fn serialize(&self, se: S) -> Result where S: Serializer, @@ -197,7 +207,7 @@ impl Serialize for Cptr { } } -impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for Cptr +impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtr where Vec: Deserialize<'de>, { @@ -205,27 +215,27 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(de).map(Cptr::Owned) + Deserialize::deserialize(de).map(OwnedPtr::Owned) } } -impl AsRef for Cptr { +impl AsRef for OwnedPtr { fn as_ref(&self) -> &T { match self { - Cptr::Cptr(p) => unsafe { p.as_ref().unwrap() }, - Cptr::Owned(v) => v.as_ref(), + OwnedPtr::Ptr(p) => unsafe { p.as_ref().unwrap() }, + OwnedPtr::Owned(v) => v.as_ref(), } } } /// Wrap a C-style mutable pointer and convert to a Box on serialize #[derive(Clone, Debug)] -pub enum CptrMut { - Cptr(*mut T), +pub enum OwnedPtrMut { + Ptr(*mut T), Owned(Box), } -impl Serialize for CptrMut { +impl Serialize for OwnedPtrMut { fn serialize(&self, se: S) -> Result where S: Serializer, @@ -234,7 +244,7 @@ impl Serialize for CptrMut { } } -impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for CptrMut +impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtrMut where Vec: Deserialize<'de>, { @@ -242,36 +252,36 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(de).map(CptrMut::Owned) + Deserialize::deserialize(de).map(OwnedPtrMut::Owned) } } -impl AsRef for CptrMut { +impl AsRef for OwnedPtrMut { fn as_ref(&self) -> &T { match self { - CptrMut::Cptr(p) => unsafe { p.as_ref().unwrap() }, - CptrMut::Owned(b) => b.as_ref(), + OwnedPtrMut::Ptr(p) => unsafe { p.as_ref().unwrap() }, + OwnedPtrMut::Owned(b) => b.as_ref(), } } } -impl AsMut for CptrMut { +impl AsMut for OwnedPtrMut { fn as_mut(&mut self) -> &mut T { match self { - CptrMut::Cptr(p) => unsafe { p.as_mut().unwrap() }, - CptrMut::Owned(b) => b.as_mut(), + OwnedPtrMut::Ptr(p) => unsafe { p.as_mut().unwrap() }, + OwnedPtrMut::Owned(b) => b.as_mut(), } } } /// Wrap a C-style pointer to an array (with size= and convert to a Vec on serialize #[derive(Clone, Debug)] -pub enum Array { - Cptr((*const T, usize)), +pub enum OwnedArrayPtr { + ArrayPtr((*const T, usize)), Owned(Vec), } -impl Serialize for Array { +impl Serialize for OwnedArrayPtr { fn serialize(&self, se: S) -> Result where S: Serializer, @@ -280,7 +290,7 @@ impl Serialize for Array { } } -impl<'de, T: Sized + Serialize> Deserialize<'de> for Array +impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtr where Vec: Deserialize<'de>, { @@ -288,27 +298,27 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(de).map(Array::Owned) + Deserialize::deserialize(de).map(OwnedArrayPtr::Owned) } } -impl Array { +impl OwnedArrayPtr { 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(), + OwnedArrayPtr::ArrayPtr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, + OwnedArrayPtr::Owned(v) => v.as_slice(), } } } /// Wrap a C-style mutable pointer to an array (with size= and convert to a Vec on serialize #[derive(Clone, Debug)] -pub enum ArrayMut { - Cptr((*mut T, usize)), +pub enum OwnedArrayPtrMut { + ArrayPtr((*mut T, usize)), Owned(Vec), } -impl Serialize for ArrayMut { +impl Serialize for OwnedArrayPtrMut { fn serialize(&self, se: S) -> Result where S: Serializer, @@ -317,7 +327,7 @@ impl Serialize for ArrayMut { } } -impl<'de, T: Sized + Serialize> Deserialize<'de> for ArrayMut +impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtrMut where Vec: Deserialize<'de>, { @@ -325,22 +335,22 @@ where where D: Deserializer<'de>, { - Deserialize::deserialize(de).map(ArrayMut::Owned) + Deserialize::deserialize(de).map(OwnedArrayPtrMut::Owned) } } -impl ArrayMut { +impl OwnedArrayPtrMut { 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(), + OwnedArrayPtrMut::ArrayPtr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, + OwnedArrayPtrMut::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(), + OwnedArrayPtrMut::ArrayPtr(p) => unsafe { core::slice::from_raw_parts_mut(p.0, p.1) }, + OwnedArrayPtrMut::Owned(v) => v.as_mut_slice(), } } } diff --git a/libafl/src/inputs/bytes.rs b/libafl/src/inputs/bytes.rs index 7ceb24a9d9..ade150fd98 100644 --- a/libafl/src/inputs/bytes.rs +++ b/libafl/src/inputs/bytes.rs @@ -12,7 +12,8 @@ use std::{ }; use crate::{ - inputs::{HasBytesVec, HasLen, HasTargetBytes, Input, TargetBytes}, + bolts::ownedref::OwnedSlice, + inputs::{HasBytesVec, HasLen, HasTargetBytes, Input}, Error, }; @@ -69,8 +70,8 @@ impl HasBytesVec for BytesInput { impl HasTargetBytes for BytesInput { #[inline] - fn target_bytes(&self) -> TargetBytes { - TargetBytes::Ref(&self.bytes) + fn target_bytes(&self) -> OwnedSlice { + OwnedSlice::Ref(&self.bytes) } } diff --git a/libafl/src/inputs/mod.rs b/libafl/src/inputs/mod.rs index cb409ed408..5f920b1496 100644 --- a/libafl/src/inputs/mod.rs +++ b/libafl/src/inputs/mod.rs @@ -14,7 +14,7 @@ use std::{ use serde::{Deserialize, Serialize}; -use crate::Error; +use crate::{bolts::ownedref::OwnedSlice, Error}; /// An input for the target pub trait Input: Clone + serde::Serialize + serde::de::DeserializeOwned + Debug { @@ -60,22 +60,8 @@ pub trait Input: Clone + serde::Serialize + serde::de::DeserializeOwned + Debug pub struct NopInput {} impl Input for NopInput {} impl HasTargetBytes for NopInput { - fn target_bytes(&self) -> TargetBytes { - TargetBytes::Owned(vec![0]) - } -} - -pub enum TargetBytes<'a> { - Ref(&'a [u8]), - Owned(Vec), -} - -impl<'a> TargetBytes<'a> { - pub fn as_slice(&self) -> &[u8] { - match self { - TargetBytes::Ref(r) => r, - TargetBytes::Owned(v) => v.as_slice(), - } + fn target_bytes(&self) -> OwnedSlice { + OwnedSlice::Owned(vec![0]) } } @@ -84,7 +70,7 @@ impl<'a> TargetBytes<'a> { /// Instead, it can be used as bytes input for a target pub trait HasTargetBytes { /// Target bytes, that can be written to a target - fn target_bytes(&self) -> TargetBytes; + fn target_bytes(&self) -> OwnedSlice; } /// Contains an internal bytes Vector diff --git a/libafl/src/observers/map.rs b/libafl/src/observers/map.rs index a32f3cf1e9..2188105f55 100644 --- a/libafl/src/observers/map.rs +++ b/libafl/src/observers/map.rs @@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize}; use crate::{ bolts::{ - ownedref::{ArrayMut, Cptr}, + ownedref::{OwnedArrayPtrMut, OwnedPtr}, tuples::Named, }, observers::Observer, @@ -63,7 +63,7 @@ pub struct StdMapObserver where T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned, { - map: ArrayMut, + map: OwnedArrayPtrMut, initial: T, name: String, } @@ -127,7 +127,7 @@ where assert!(map.len() >= len); let initial = if map.is_empty() { T::default() } else { map[0] }; Self { - map: ArrayMut::Cptr((map.as_mut_ptr(), len)), + map: OwnedArrayPtrMut::ArrayPtr((map.as_mut_ptr(), len)), name: name.to_string(), initial, } @@ -137,7 +137,7 @@ where pub fn new_owned(name: &'static str, map: Vec) -> Self { let initial = if map.is_empty() { T::default() } else { map[0] }; Self { - map: ArrayMut::Owned(map), + map: OwnedArrayPtrMut::Owned(map), name: name.to_string(), initial, } @@ -149,7 +149,7 @@ where pub unsafe fn new_from_ptr(name: &'static str, map_ptr: *mut T, len: usize) -> Self { let initial = if len > 0 { *map_ptr } else { T::default() }; StdMapObserver { - map: ArrayMut::Cptr((map_ptr, len)), + map: OwnedArrayPtrMut::ArrayPtr((map_ptr, len)), name: name.to_string(), initial, } @@ -164,8 +164,8 @@ pub struct VariableMapObserver where T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned, { - map: ArrayMut, - size: Cptr, + map: OwnedArrayPtrMut, + size: OwnedPtr, initial: T, name: String, } @@ -233,8 +233,8 @@ where pub fn new(name: &'static str, map: &'static mut [T], size: *const usize) -> Self { let initial = if map.is_empty() { T::default() } else { map[0] }; Self { - map: ArrayMut::Cptr((map.as_mut_ptr(), map.len())), - size: Cptr::Cptr(size), + map: OwnedArrayPtrMut::ArrayPtr((map.as_mut_ptr(), map.len())), + size: OwnedPtr::Ptr(size), name: name.into(), initial, } @@ -251,8 +251,8 @@ where ) -> Self { let initial = if max_len > 0 { *map_ptr } else { T::default() }; VariableMapObserver { - map: ArrayMut::Cptr((map_ptr, max_len)), - size: Cptr::Cptr(size_ptr), + map: OwnedArrayPtrMut::ArrayPtr((map_ptr, max_len)), + size: OwnedPtr::Ptr(size_ptr), name: name.into(), initial, }