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

//! A stage implementation that can have dynamic stage runtime

use super::{Restartable, Stage};

/// A dynamic stage implementation. This explicity uses enum so that rustc can better
/// reason about the bounds.
#[derive(Debug)]
pub enum DynamicStage<T1, T2> {
    /// One stage
    Stage1(T1),
    /// The alernative stage
    Stage2(T2),
}

impl<T1, T2, E, EM, S, Z> Stage<E, EM, S, Z> for DynamicStage<T1, T2>
where
    T1: Stage<E, EM, S, Z>,
    T2: Stage<E, EM, S, Z>,
{
    fn perform(
        &mut self,
        fuzzer: &mut Z,
        executor: &mut E,
        state: &mut S,
        manager: &mut EM,
    ) -> Result<(), libafl_bolts::Error> {
        match self {
            Self::Stage1(st1) => st1.perform(fuzzer, executor, state, manager),
            Self::Stage2(st2) => st2.perform(fuzzer, executor, state, manager),
        }
    }
}

impl<T1, T2, S> Restartable<S> for DynamicStage<T1, T2>
where
    T1: Restartable<S>,
    T2: Restartable<S>,
{
    fn should_restart(&mut self, state: &mut S) -> Result<bool, libafl_bolts::Error> {
        match self {
            Self::Stage1(st1) => st1.should_restart(state),
            Self::Stage2(st2) => st2.should_restart(state),
        }
    }
    fn clear_progress(&mut self, state: &mut S) -> Result<(), libafl_bolts::Error> {
        match self {
            Self::Stage1(st1) => st1.clear_progress(state),
            Self::Stage2(st2) => st2.clear_progress(state),
        }
    }
}