mmm

Author: tokatoka

fuzzers/structure_aware/nautilus_sync/src/lib.rs

@@ -15,7 +15,7 @@ use libafl::{
     feedbacks::{CrashFeedback, MaxMapFeedback, NautilusChunksMetadata, NautilusFeedback},
     fuzzer::{Fuzzer, StdFuzzer},
     generators::{NautilusContext, NautilusGenerator},
-    inputs::{NautilusInput, NautilusToBytesInputConverter},
+    inputs::{NautilusBytesConverter, NautilusInput},
     monitors::SimpleMonitor,
     mutators::{
         HavocScheduledMutator, NautilusRandomMutator, NautilusRecursionMutator,
@@ -126,7 +126,7 @@ pub extern "C" fn libafl_main() {
             .build_on_port(
                 shmem_provider.clone(),
                 port,
-                Some(NautilusToBytesInputConverter::new(&context)),
+                Some(NautilusBytesConverter::new(&context)),
                 none_input_converter!(),
             )
             .unwrap()

libafl/src/executors/forkserver.rs

@@ -41,7 +41,7 @@ use crate::observers::{
     AsanBacktraceObserver, get_asan_runtime_flags, get_asan_runtime_flags_with_log_path,
 };
 use crate::{
-    Error, HasInputConverter,
+    Error, HasBytesConverter,
     executors::{Executor, ExitKind, HasObservers},
     inputs::{Input, InputToBytes},
     mutators::Tokens,
@@ -1400,7 +1400,7 @@ where
     OT: ObserversTuple<I, S>,
     S: HasExecutions,
     SHM: ShMem,
-    Z: HasInputConverter,
+    Z: HasBytesConverter,
     Z::Converter: InputToBytes<I>,
 {
     #[inline]

libafl/src/fuzzer/mod.rs

@@ -79,7 +79,7 @@ pub trait HasObjective {
 }
 
 /// Can convert input to another type
-pub trait HasInputConverter {
+pub trait HasBytesConverter {
     /// The converter itself
     type Converter;
     /// the input converter
@@ -1077,7 +1077,7 @@ impl<IC, IF> StdFuzzerBuilder<IC, IF> {
     }
 }
 
-impl<CS, F, IC, IF, OF> HasInputConverter for StdFuzzer<CS, F, IC, IF, OF> {
+impl<CS, F, IC, IF, OF> HasBytesConverter for StdFuzzer<CS, F, IC, IF, OF> {
     type Converter = IC;
 
     fn converter(&self) -> &Self::Converter {

libafl/src/inputs/mod.rs

@@ -299,7 +299,7 @@ impl ResizableMutator<u8> for &mut Vec<u8> {
 }
 
 #[derive(Debug, Default)]
-/// Basic `InputConverter` with just one type that is not converting
+/// Basic `NopBytesConverter` with just one type that is not converting
 pub struct NopBytesConverter {}
 
 impl<I> InputToBytes<I> for NopBytesConverter

libafl/src/inputs/nautilus.rs

@@ -8,14 +8,15 @@ use core::{
 use libafl_bolts::{HasLen, ownedref::OwnedSlice};
 use serde::{Deserialize, Serialize};
 
+use super::BytesInput;
 use crate::{
     common::nautilus::grammartec::{
         newtypes::NodeId,
         rule::RuleIdOrCustom,
         tree::{Tree, TreeLike},
     },
     generators::nautilus::NautilusContext,
-    inputs::{Input, InputToBytes},
+    inputs::{Input, InputConverter, InputToBytes},
 };
 
 /// An [`Input`] implementation for `Nautilus` grammar.
@@ -95,20 +96,31 @@ impl Hash for NautilusInput {
     }
 }
 
-/// `InputConverter` to convert from `NautilusInput` to `BytesInput`
+/// Convert from `NautilusInput` to `BytesInput`
 #[derive(Debug)]
 pub struct NautilusBytesConverter<'a> {
     ctx: &'a NautilusContext,
 }
 
 impl<'a> NautilusBytesConverter<'a> {
     #[must_use]
-    /// Create a new `NautilusToBytesInputConverter` from a context
+    /// Create a new `NautilusBytesConverter` from a context
     pub fn new(ctx: &'a NautilusContext) -> Self {
         Self { ctx }
     }
 }
 
+impl InputConverter for NautilusBytesConverter<'_> {
+    type From = NautilusInput;
+    type To = BytesInput;
+
+    fn convert(&mut self, input: Self::From) -> Result<Self::To, libafl_bolts::Error> {
+        let mut bytes = vec![];
+        input.unparse(self.ctx, &mut bytes);
+        Ok(BytesInput::new(bytes))
+    }
+}
+
 impl InputToBytes<NautilusInput> for NautilusBytesConverter<'_> {
     fn to_bytes<'a>(&mut self, input: &'a NautilusInput) -> OwnedSlice<'a, u8> {
         let mut bytes = vec![];

libafl_frida/src/executor.rs

@@ -15,7 +15,7 @@ use frida_gum::{
 #[cfg(windows)]
 use libafl::executors::{hooks::inprocess::InProcessHooks, inprocess::HasInProcessHooks};
 use libafl::{
-    Error, HasInputConverter,
+    Error, HasBytesConverter,
     executors::{Executor, ExitKind, HasObservers, InProcessExecutor},
     inputs::{Input, InputToBytes},
     observers::ObserversTuple,
@@ -63,7 +63,7 @@ where
     S: HasExecutions + HasCurrentTestcase<I> + HasSolutions<I>,
     OT: ObserversTuple<I, S>,
     RT: FridaRuntimeTuple,
-    Z: HasInputConverter,
+    Z: HasBytesConverter,
     Z::Converter: InputToBytes<I>,
 {
     /// Instruct the target about the input and run

libafl_intelpt/src/linux.rs

@@ -903,7 +903,7 @@ fn linux_version() -> Result<(usize, usize, usize), ()> {
         domainname: [0; 65],
     };
 
-    if unsafe { libc::uname(&mut uname_data) } != 0 {
+    if unsafe { libc::uname(&raw mut uname_data) } != 0 {
         return Err(());
     }