Make input loading fallible in SyncFromDiskStage

libafl/src/stages/sync.rs

@@ -8,16 +8,16 @@ use core::{marker::PhantomData, time::Duration};
 use std::path::{Path, PathBuf};
 
 use libafl_bolts::{
-    Named, current_time,
+    current_time,
     fs::find_new_files_rec,
     shmem::{ShMem, ShMemProvider},
+    Named,
 };
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    Error, HasMetadata, HasNamedMetadata,
     corpus::{Corpus, CorpusId, HasCurrentCorpusId},
-    events::{Event, EventConfig, EventFirer, EventWithStats, llmp::LlmpEventConverter},
+    events::{llmp::LlmpEventConverter, Event, EventConfig, EventFirer, EventWithStats},
     executors::{Executor, ExitKind, HasObservers},
     fuzzer::{Evaluator, EvaluatorObservers, ExecutionProcessor, HasObjective},
     inputs::{Input, InputConverter},
@@ -26,6 +26,7 @@ use crate::{
         HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, HasSolutions,
         MaybeHasClientPerfMonitor, Stoppable,
     },
+    Error, HasMetadata, HasNamedMetadata,
 };
 
 /// Default name for `SyncFromDiskStage`; derived from AFL++
@@ -58,6 +59,7 @@ impl SyncFromDiskMetadata {
 }
 
 /// A stage that loads testcases from disk to sync with other fuzzers such as AFL++
+/// When syncing, the stage will ignore `Error::InvalidInput` and will skip the file.
 #[derive(Debug)]
 pub struct SyncFromDiskStage<CB, E, EM, I, S, Z> {
     name: Cow<'static, str>,
@@ -125,15 +127,24 @@ where
         let to_sync = sync_from_disk_metadata.left_to_sync.clone();
         log::debug!("Number of files to sync: {:?}", to_sync.len());
         for path in to_sync {
-            let input = (self.load_callback)(fuzzer, state, &path)?;
             // Removing each path from the `left_to_sync` Vec before evaluating
             // prevents duplicate processing and ensures that each file is evaluated only once. This approach helps
-            // avoid potential infinite loops that may occur if a file is an objective.
+            // avoid potential infinite loops that may occur if a file is an objective or an invalid input.
             state
                 .metadata_mut::<SyncFromDiskMetadata>()
                 .unwrap()
                 .left_to_sync
                 .retain(|p| p != &path);
+            let input = match (self.load_callback)(fuzzer, state, &path) {
+                Ok(input) => input,
+                Err(Error::InvalidInput(reason, _)) => {
+                    log::debug!(
+                        "Invalid input found in {path:?} when syncing; reason {reason}; skipping;"
+                    );
+                    continue;
+                }
+                Err(e) => return Err(e),
+            };
             log::debug!("Syncing and evaluating {}", path.display());
             fuzzer.evaluate_input(state, executor, manager, &input)?;
         }
@@ -161,6 +172,7 @@ where
 
 impl<CB, E, EM, I, S, Z> SyncFromDiskStage<CB, E, EM, I, S, Z> {
     /// Creates a new [`SyncFromDiskStage`]
+    /// To skip a file, you can return `Error::invalid_input` in `load_callback`
     #[must_use]
     pub fn new(sync_dirs: Vec<PathBuf>, load_callback: CB, interval: Duration, name: &str) -> Self {
         Self {

libafl_bolts/src/lib.rs

@@ -62,7 +62,9 @@ type String = &'static str;
 /// Good enough for simple errors, for anything else, use the `alloc` feature.
 #[cfg(not(feature = "alloc"))]
 macro_rules! format {
-    ($fmt:literal) => {{ $fmt }};
+    ($fmt:literal) => {{
+        $fmt
+    }};
 }
 
 #[cfg(feature = "std")]
@@ -164,7 +166,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 #[cfg(all(unix, feature = "std"))]
 use std::{
     fs::File,
-    io::{Write, stderr, stdout},
+    io::{stderr, stdout, Write},
     os::fd::{AsRawFd, FromRawFd, RawFd},
     panic,
 };
@@ -341,6 +343,8 @@ pub enum Error {
     InvalidCorpus(String, ErrorBacktrace),
     /// Error specific to a runtime like QEMU or Frida
     Runtime(String, ErrorBacktrace),
+    /// The `Input` was invalid.
+    InvalidInput(String, ErrorBacktrace),
 }
 
 impl Error {
@@ -369,6 +373,15 @@ impl Error {
         Error::EmptyOptional(arg.into(), ErrorBacktrace::new())
     }
 
+    /// The `Input` was invalid
+    #[must_use]
+    pub fn invalid_input<S>(reason: S) -> Self
+    where
+        S: Into<String>,
+    {
+        Error::InvalidInput(reason.into(), ErrorBacktrace::new())
+    }
+
     /// Key not in Map
     #[must_use]
     pub fn key_not_found<S>(arg: S) -> Self
@@ -580,6 +593,10 @@ impl Display for Error {
                 write!(f, "Runtime error: {0}", &s)?;
                 display_error_backtrace(f, b)
             }
+            Self::InvalidInput(s, b) => {
+                write!(f, "Encountered an invalid input: {0}", &s)?;
+                display_error_backtrace(f, b)
+            }
         }
     }
 }
@@ -1088,7 +1105,7 @@ pub fn get_thread_id() -> u64 {
 #[allow(clippy::cast_sign_loss)]
 /// Return thread ID without using TLS
 pub fn get_thread_id() -> u64 {
-    use libc::{SYS_gettid, syscall};
+    use libc::{syscall, SYS_gettid};
 
     unsafe { syscall(SYS_gettid) as u64 }
 }
@@ -1441,7 +1458,7 @@ macro_rules! nonnull_raw_mut {
 #[allow(missing_docs)] // expect somehow breaks here
 pub mod pybind {
 
-    use pyo3::{Bound, PyResult, pymodule, types::PyModule};
+    use pyo3::{pymodule, types::PyModule, Bound, PyResult};
 
     #[macro_export]
     macro_rules! unwrap_me_body {