Struct libafl::state::StdState

pub struct StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,{ /* private fields */ }

The state a fuzz run.

Implementations

impl<C, I, R, SC> StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

pub fn load_from_directory<E, EM, Z>(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut E,
    manager: &mut EM,
    in_dir: &Path,
    forced: bool,
    loader: &mut dyn FnMut(&mut Z, &mut Self, &Path) -> Result<I, Error>
) -> Result<(), Error>where
    Z: Evaluator<E, EM, I, Self>,

Loads inputs from a directory. If forced is true, the value will be loaded, even if it’s not considered to be interesting.

pub fn load_initial_inputs_forced<E, EM, Z>(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut E,
    manager: &mut EM,
    in_dirs: &[PathBuf]
) -> Result<(), Error>where
    Z: Evaluator<E, EM, I, Self>,
    EM: EventFirer<I>,

Loads all intial inputs, even if they are not considered interesting. This is rarely the right method, use load_initial_inputs, and potentially fix your Feedback, instead.

pub fn load_initial_inputs<E, EM, Z>(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut E,
    manager: &mut EM,
    in_dirs: &[PathBuf]
) -> Result<(), Error>where
    Z: Evaluator<E, EM, I, Self>,
    EM: EventFirer<I>,

Loads initial inputs from the passed-in in_dirs.

impl<C, I, R, SC> StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

pub fn generate_initial_inputs_forced<G, E, EM, Z>(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut E,
    generator: &mut G,
    manager: &mut EM,
    num: usize
) -> Result<(), Error>where
    G: Generator<I, Self>,
    Z: Evaluator<E, EM, I, Self>,
    EM: EventFirer<I>,

Generate num initial inputs, using the passed-in generator and force the addition to corpus.

pub fn generate_initial_inputs<G, E, EM, Z>(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut E,
    generator: &mut G,
    manager: &mut EM,
    num: usize
) -> Result<(), Error>where
    G: Generator<I, Self>,
    Z: Evaluator<E, EM, I, Self>,
    EM: EventFirer<I>,

Generate num initial inputs, using the passed-in generator.

pub fn new<F, O>(
    rand: R,
    corpus: C,
    solutions: SC,
    feedback: &mut F,
    objective: &mut O
) -> Result<Self, Error>where
    F: Feedback<I, Self>,
    O: Feedback<I, Self>,

Creates a new State, taking ownership of all of the individual components during fuzzing.

Trait Implementations

impl<C: Clone, I: Clone, R: Clone, SC: Clone> Clone for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn clone(&self) -> StdState<C, I, R, SC>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug, I: Debug, R: Debug, SC: Debug> Debug for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, C, I, R, SC> Deserialize<'de> for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,
    C: Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C, I, R, SC> HasClientPerfMonitor for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn introspection_monitor(&self) -> &ClientPerfMonitor

ClientPerfMonitor itself

fn introspection_monitor_mut(&mut self) -> &mut ClientPerfMonitor

Mutatable ref to ClientPerfMonitor

impl<C, I, R, SC> HasCorpus<I> for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn corpus(&self) -> &C

Returns the corpus

fn corpus_mut(&mut self) -> &mut C

Returns the mutable corpus

type Corpus = C

The associated type implementing Corpus.

impl<C, I, R, SC> HasExecutions for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn executions(&self) -> &usize

The executions counter

fn executions_mut(&mut self) -> &mut usize

The executions counter (mutable)

impl<C, I, R, SC> HasMaxSize for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn max_size(&self) -> usize

The maximum size hint for items and mutations returned

fn set_max_size(&mut self, max_size: usize)

Sets the maximum size hint for the items and mutations

impl<C, I, R, SC> HasMetadata for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn metadata(&self) -> &SerdeAnyMap

Get all the metadata into an hashbrown::HashMap

fn metadata_mut(&mut self) -> &mut SerdeAnyMap

Get all the metadata into an hashbrown::HashMap (mutable)

fn add_metadata<M>(&mut self, meta: M)where
    M: SerdeAny,

Add a metadata to the metadata map

fn has_metadata<M>(&self) -> boolwhere
    M: SerdeAny,

Check for a metadata

impl<C, I, R, SC> HasNamedMetadata for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn named_metadata(&self) -> &NamedSerdeAnyMap

Get all the metadata into an hashbrown::HashMap

fn named_metadata_mut(&mut self) -> &mut NamedSerdeAnyMap

Get all the metadata into an hashbrown::HashMap (mutable)

fn add_named_metadata<M>(&mut self, meta: M, name: &str)where
    M: SerdeAny,

Add a metadata to the metadata map

fn has_named_metadata<M>(&self, name: &str) -> boolwhere
    M: SerdeAny,

Check for a metadata

impl<C, I, R, SC> HasRand for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn rand(&self) -> &Self::Rand

The rand instance

fn rand_mut(&mut self) -> &mut Self::Rand

The rand instance (mutable)

type Rand = R

The associated type implementing Rand

impl<C, I, R, SC> HasSolutions<I> for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn solutions(&self) -> &SC

Returns the solutions corpus

fn solutions_mut(&mut self) -> &mut SC

Returns the solutions corpus (mutable)

type Solutions = SC

The associated type implementing Corpus for solutions

impl<C, I, R, SC> HasStartTime for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,

fn start_time(&self) -> &Duration

The starting time

fn start_time_mut(&mut self) -> &mut Duration

The starting time (mutable)

impl<C, I, R, SC> Serialize for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,
    C: Serialize + for<'a> Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C, I, R, SC> State for StdState<C, I, R, SC>where
    C: Corpus<I>,
    I: Input,
    R: Rand,
    SC: Corpus<I>,