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

refactor ownedref

Browse Source
This commit is contained in:
Andrea Fioraldi 2021-04-26 10:17:42 +02:00
parent f25862cb90
commit 1829fcf191
4 changed files with 107 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
libafl/src/bolts/ownedref.rs
View File

@ -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<T>),
}
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<S>(&self, se: S) -> Result<S::Ok, S::Error>
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<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).map(Ptr::Owned)
Deserialize::deserialize(deserializer).map(OwnedRef::Owned)
}
}
impl<'a, T: Sized> AsRef<T> for Ptr<'a, T> {
impl<'a, T> AsRef<T> 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<T>),
}
impl<'a, T: 'a + ?Sized + Serialize> Serialize for PtrMut<'a, T> {
impl<'a, T: 'a + ?Sized + Serialize> Serialize for OwnedRefMut<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
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<T>: 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<T> for PtrMut<'a, T> {
impl<'a, T: Sized> AsRef<T> 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<T> for PtrMut<'a, T> {
impl<'a, T: Sized> AsMut<T> 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<T>),
}
impl<'a, T: 'a + Sized + Serialize> Serialize for Slice<'a, T> {
impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSlice<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
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<T>: 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<T>),
}
impl<'a, T: 'a + Sized + Serialize> Serialize for SliceMut<'a, T> {
impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSliceMut<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
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<T>: 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<T: Sized> {
Cptr(*const T),
pub enum OwnedPtr<T: Sized> {
Ptr(*const T),
Owned(Box<T>),
}
impl<T: Sized + Serialize> Serialize for Cptr<T> {
impl<T: Sized + Serialize> Serialize for OwnedPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -197,7 +207,7 @@ impl<T: Sized + Serialize> Serialize for Cptr<T> {
}
}
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for Cptr<T>
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtr<T>
where
Vec<T>: Deserialize<'de>,
{
@ -205,27 +215,27 @@ where
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(Cptr::Owned)
Deserialize::deserialize(de).map(OwnedPtr::Owned)
}
}
impl<T: Sized> AsRef<T> for Cptr<T> {
impl<T: Sized> AsRef<T> for OwnedPtr<T> {
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<T: Sized> {
Cptr(*mut T),
pub enum OwnedPtrMut<T: Sized> {
Ptr(*mut T),
Owned(Box<T>),
}
impl<T: Sized + Serialize> Serialize for CptrMut<T> {
impl<T: Sized + Serialize> Serialize for OwnedPtrMut<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -234,7 +244,7 @@ impl<T: Sized + Serialize> Serialize for CptrMut<T> {
}
}
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for CptrMut<T>
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtrMut<T>
where
Vec<T>: Deserialize<'de>,
{
@ -242,36 +252,36 @@ where
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(CptrMut::Owned)
Deserialize::deserialize(de).map(OwnedPtrMut::Owned)
}
}
impl<T: Sized> AsRef<T> for CptrMut<T> {
impl<T: Sized> AsRef<T> for OwnedPtrMut<T> {
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<T: Sized> AsMut<T> for CptrMut<T> {
impl<T: Sized> AsMut<T> for OwnedPtrMut<T> {
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<T: Sized> {
Cptr((*const T, usize)),
pub enum OwnedArrayPtr<T: Sized> {
ArrayPtr((*const T, usize)),
Owned(Vec<T>),
}
impl<T: Sized + Serialize> Serialize for Array<T> {
impl<T: Sized + Serialize> Serialize for OwnedArrayPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -280,7 +290,7 @@ impl<T: Sized + Serialize> Serialize for Array<T> {
}
}
impl<'de, T: Sized + Serialize> Deserialize<'de> for Array<T>
impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtr<T>
where
Vec<T>: Deserialize<'de>,
{
@ -288,27 +298,27 @@ where
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(Array::Owned)
Deserialize::deserialize(de).map(OwnedArrayPtr::Owned)
}
}
impl<T: Sized> Array<T> {
impl<T: Sized> OwnedArrayPtr<T> {
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<T: Sized> {
Cptr((*mut T, usize)),
pub enum OwnedArrayPtrMut<T: Sized> {
ArrayPtr((*mut T, usize)),
Owned(Vec<T>),
}
impl<T: Sized + Serialize> Serialize for ArrayMut<T> {
impl<T: Sized + Serialize> Serialize for OwnedArrayPtrMut<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -317,7 +327,7 @@ impl<T: Sized + Serialize> Serialize for ArrayMut<T> {
}
}
impl<'de, T: Sized + Serialize> Deserialize<'de> for ArrayMut<T>
impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtrMut<T>
where
Vec<T>: Deserialize<'de>,
{
@ -325,22 +335,22 @@ where
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(ArrayMut::Owned)
Deserialize::deserialize(de).map(OwnedArrayPtrMut::Owned)
}
}
impl<T: Sized> ArrayMut<T> {
impl<T: Sized> OwnedArrayPtrMut<T> {
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(),
}
}
}

7
libafl/src/inputs/bytes.rs
View File

@ -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<u8> {
OwnedSlice::Ref(&self.bytes)
}
}

22
libafl/src/inputs/mod.rs
View File

@ -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<u8>),
}
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<u8> {
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<u8>;
}
/// Contains an internal bytes Vector

22
libafl/src/observers/map.rs
View File

@ -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<T>
where
T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned,
{
map: ArrayMut<T>,
map: OwnedArrayPtrMut<T>,
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<T>) -> 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<T>
where
T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned,
{
map: ArrayMut<T>,
size: Cptr<usize>,
map: OwnedArrayPtrMut<T>,
size: OwnedPtr<usize>,
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,
}