libafl 0.15.4

Slot your own fuzzers together and extend their features using Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

//! This module defines trait shared across different `LibAFL` modules

use alloc::boxed::Box;
use core::any::type_name;

#[cfg(feature = "nautilus")]
pub mod nautilus;

use libafl_bolts::{
    Error,
    serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
};
/// Trait for elements offering metadata
pub trait HasMetadata {
    /// A map, storing all metadata
    fn metadata_map(&self) -> &SerdeAnyMap;
    /// A map, storing all metadata (mutable)
    fn metadata_map_mut(&mut self) -> &mut SerdeAnyMap;

    /// Add a metadata to the metadata map
    #[inline]
    fn add_metadata<M>(&mut self, meta: M)
    where
        M: SerdeAny,
    {
        self.metadata_map_mut().insert(meta);
    }

    /// Add a metadata to the metadata map
    /// Returns error if the metadata is already there
    #[inline]
    fn try_add_metadata<M>(&mut self, meta: M) -> Result<(), Error>
    where
        M: SerdeAny,
    {
        self.metadata_map_mut().try_insert(meta)
    }

    /// Gets metadata, or inserts it using the given construction function `default`
    fn metadata_or_insert_with<M>(&mut self, default: impl FnOnce() -> M) -> &mut M
    where
        M: SerdeAny,
    {
        self.metadata_map_mut().get_or_insert_with::<M>(default)
    }

    /// Remove a metadata from the metadata map
    #[inline]
    fn remove_metadata<M>(&mut self) -> Option<Box<M>>
    where
        M: SerdeAny,
    {
        self.metadata_map_mut().remove::<M>()
    }

    /// Check for a metadata
    ///
    /// # Note
    /// For performance reasons, you likely want to use [`Self::metadata_or_insert_with`] instead
    #[inline]
    fn has_metadata<M>(&self) -> bool
    where
        M: SerdeAny,
    {
        self.metadata_map().get::<M>().is_some()
    }

    /// To get metadata
    #[inline]
    fn metadata<M>(&self) -> Result<&M, Error>
    where
        M: SerdeAny,
    {
        self.metadata_map()
            .get::<M>()
            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
    }

    /// To get mutable metadata
    #[inline]
    fn metadata_mut<M>(&mut self) -> Result<&mut M, Error>
    where
        M: SerdeAny,
    {
        self.metadata_map_mut()
            .get_mut::<M>()
            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
    }
}

/// Trait for elements offering named metadata
pub trait HasNamedMetadata {
    /// A map, storing all metadata
    fn named_metadata_map(&self) -> &NamedSerdeAnyMap;
    /// A map, storing all metadata (mutable)
    fn named_metadata_map_mut(&mut self) -> &mut NamedSerdeAnyMap;

    /// Add a metadata to the metadata map
    #[inline]
    fn add_named_metadata<M>(&mut self, name: &str, meta: M)
    where
        M: SerdeAny,
    {
        self.named_metadata_map_mut().insert(name, meta);
    }

    /// Add a metadata to the metadata map
    /// Return an error if there already is the metadata with the same name
    #[inline]
    fn add_named_metadata_checked<M>(&mut self, name: &str, meta: M) -> Result<(), Error>
    where
        M: SerdeAny,
    {
        self.named_metadata_map_mut().try_insert(name, meta)
    }

    /// Add a metadata to the metadata map
    #[inline]
    fn remove_named_metadata<M>(&mut self, name: &str) -> Option<Box<M>>
    where
        M: SerdeAny,
    {
        self.named_metadata_map_mut().remove::<M>(name)
    }

    /// Gets metadata, or inserts it using the given construction function `default`
    fn named_metadata_or_insert_with<M>(
        &mut self,
        name: &str,
        default: impl FnOnce() -> M,
    ) -> &mut M
    where
        M: SerdeAny,
    {
        self.named_metadata_map_mut()
            .get_or_insert_with::<M>(name, default)
    }

    /// Check for a metadata
    ///
    /// # Note
    /// You likely want to use [`Self::named_metadata_or_insert_with`] for performance reasons.
    #[inline]
    fn has_named_metadata<M>(&self, name: &str) -> bool
    where
        M: SerdeAny,
    {
        self.named_metadata_map().contains::<M>(name)
    }

    /// To get named metadata
    #[inline]
    fn named_metadata<M>(&self, name: &str) -> Result<&M, Error>
    where
        M: SerdeAny,
    {
        self.named_metadata_map()
            .get::<M>(name)
            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
    }

    /// To get mutable named metadata
    #[inline]
    fn named_metadata_mut<M>(&mut self, name: &str) -> Result<&mut M, Error>
    where
        M: SerdeAny,
    {
        self.named_metadata_map_mut()
            .get_mut::<M>(name)
            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
    }
}