From 9e9425c622934fc9390a67e7ba7c60fb1a11c57a Mon Sep 17 00:00:00 2001
From: Andrea Fioraldi <andreafioraldi@gmail.com>
Date: Wed, 9 Jun 2021 12:15:08 +0200
Subject: [PATCH] introduce ShadowExecutor

---
 libafl/src/executors/mod.rs    |   3 +
 libafl/src/executors/shadow.rs | 178 +++++++++++++++++++++++++++++++++
 2 files changed, 181 insertions(+)
 create mode 100644 libafl/src/executors/shadow.rs

diff --git a/libafl/src/executors/mod.rs b/libafl/src/executors/mod.rs
index 25bcaf3c89..4dfa0d4cdc 100644
--- a/libafl/src/executors/mod.rs
+++ b/libafl/src/executors/mod.rs
@@ -13,6 +13,9 @@ pub use forkserver::{Forkserver, ForkserverExecutor, OutFile, TimeoutForkserverE
 pub mod combined;
 pub use combined::CombinedExecutor;
 
+pub mod shadow;
+pub use shadow::{HasShadowObserverHooks, ShadowExecutor};
+
 use crate::{
     bolts::serdeany::SerdeAny,
     inputs::{HasTargetBytes, Input},
diff --git a/libafl/src/executors/shadow.rs b/libafl/src/executors/shadow.rs
new file mode 100644
index 0000000000..99441fcf59
--- /dev/null
+++ b/libafl/src/executors/shadow.rs
@@ -0,0 +1,178 @@
+//! A `ShadowExecutor` wraps an executor to have shadow observer that will not be considered by the manager
+
+use crate::{
+    executors::{Executor, ExitKind, HasExecHooksTuple, HasObservers, HasObserversHooks},
+    inputs::Input,
+    observers::ObserversTuple,
+    Error,
+};
+
+pub trait HasShadowObserverHooks<EM, I, S, SOT, Z> {
+    /// Run the pre exec hook for all the shadow [`crate::observers::Observer`]`s`
+    fn pre_exec_shadow_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error>;
+
+    /// Run the post exec hook for all the shadow [`crate::observers::Observer`]`s`
+    fn post_exec_shadow_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error>;
+}
+
+/// A [`ShadowExecutor`] wraps a primary executor, forwarding its methods, and a secondary one
+pub struct ShadowExecutor<E, SOT> {
+    executor: E,
+    shadow_observers: SOT,
+    // Enable the execution of the shadow observers hooks with the regular observers hooks
+    shadow_hooks: bool,
+}
+
+impl<E, SOT> ShadowExecutor<E, SOT>
+where
+    SOT: ObserversTuple,
+{
+    /// Create a new `ShadowExecutor`, wrapping the given `executor`.
+    pub fn new<EM, I, S, Z>(executor: E, shadow_observers: SOT) -> Self {
+        Self {
+            executor,
+            shadow_observers,
+            shadow_hooks: false,
+        }
+    }
+
+    /// Create a new `ShadowExecutor`, wrapping the given `executor`.
+    pub fn with_shadow_hooks<EM, I, S, Z>(
+        executor: E,
+        shadow_observers: SOT,
+        shadow_hooks: bool,
+    ) -> Self {
+        Self {
+            executor,
+            shadow_observers,
+            shadow_hooks,
+        }
+    }
+
+    #[inline]
+    pub fn shadow_observers(&self) -> &SOT {
+        &self.shadow_observers
+    }
+
+    #[inline]
+    pub fn shadow_observers_mut(&mut self) -> &mut SOT {
+        &mut self.shadow_observers
+    }
+}
+
+impl<E, EM, I, S, SOT, Z> HasShadowObserverHooks<EM, I, S, SOT, Z> for ShadowExecutor<E, SOT>
+where
+    I: Input,
+    SOT: ObserversTuple + HasExecHooksTuple<EM, I, S, Z>,
+{
+    #[inline]
+    fn pre_exec_shadow_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error> {
+        self.shadow_observers
+            .pre_exec_all(fuzzer, state, mgr, input)
+    }
+
+    #[inline]
+    fn post_exec_shadow_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error> {
+        self.shadow_observers
+            .post_exec_all(fuzzer, state, mgr, input)
+    }
+}
+
+impl<E, EM, I, S, SOT, Z> Executor<EM, I, S, Z> for ShadowExecutor<E, SOT>
+where
+    E: Executor<EM, I, S, Z>,
+    I: Input,
+    SOT: ObserversTuple,
+{
+    fn run_target(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<ExitKind, Error> {
+        self.executor.run_target(fuzzer, state, mgr, input)
+    }
+}
+
+impl<E, OT, SOT> HasObservers<OT> for ShadowExecutor<E, SOT>
+where
+    E: HasObservers<OT>,
+    OT: ObserversTuple,
+    SOT: ObserversTuple,
+{
+    #[inline]
+    fn observers(&self) -> &OT {
+        self.executor.observers()
+    }
+
+    #[inline]
+    fn observers_mut(&mut self) -> &mut OT {
+        self.executor.observers_mut()
+    }
+}
+
+impl<E, EM, I, OT, S, SOT, Z> HasObserversHooks<EM, I, OT, S, Z> for ShadowExecutor<E, SOT>
+where
+    E: HasObservers<OT>,
+    I: Input,
+    OT: ObserversTuple + HasExecHooksTuple<EM, I, S, Z>,
+    SOT: ObserversTuple + HasExecHooksTuple<EM, I, S, Z>,
+{
+    /// Run the pre exec hook for all [`crate::observers::Observer`]`s` linked to this [`Executor`].
+    #[inline]
+    fn pre_exec_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error> {
+        if self.shadow_hooks {
+            self.shadow_observers
+                .pre_exec_all(fuzzer, state, mgr, input)?;
+        }
+        self.observers_mut().pre_exec_all(fuzzer, state, mgr, input)
+    }
+
+    /// Run the post exec hook for all the [`crate::observers::Observer`]`s` linked to this [`Executor`].
+    #[inline]
+    fn post_exec_observers(
+        &mut self,
+        fuzzer: &mut Z,
+        state: &mut S,
+        mgr: &mut EM,
+        input: &I,
+    ) -> Result<(), Error> {
+        if self.shadow_hooks {
+            self.shadow_observers
+                .post_exec_all(fuzzer, state, mgr, input)?;
+        }
+        self.observers_mut()
+            .post_exec_all(fuzzer, state, mgr, input)
+    }
+}