Clippy, ensuring C++ runtime in debug builds, required ny libafl_frida, unti fixed

Author: mkravchik

fuzzers/libfuzzer_libpng/src/bin/libafl_cc.rs

@@ -18,8 +18,9 @@ pub fn main() {
 
         let mut cc = ClangWrapper::new();
         if let Some(code) = cc
-            .cpp(is_cpp)
-            // silence the compiler wrapper output, needed for some configure scripts.
+            .cpp(true) // Link with C++ standard library (Frida links to it in order to hook C++ functions)
+            // .cpp(is_cpp)
+        // silence the compiler wrapper output, needed for some configure scripts.
             .silence(true)
             .parse_args(&args)
             .expect("Failed to parse the command line")

fuzzers/libfuzzer_libpng/src/lib.rs

@@ -91,26 +91,6 @@ fn fuzz(corpus_dirs: &[PathBuf], objective_dir: PathBuf, broker_port: u16) -> Re
         .track_indices()
     };
 
-    let options = FuzzerOptions::try_parse();
-    log::info!("Options: {:?}", options );
-    let save_bb_coverage = options
-        .as_ref()
-        .map(|opts| opts.save_bb_coverage)
-        .unwrap_or(false);
-    let drcov_max_execution_cnt = options
-        .as_ref()
-        .map(|opts| opts.drcov_max_execution_cnt)
-        .unwrap_or(0);
-    let acc_observer = unsafe {
-        AccMapObserver::new(StdMapObserver::from_mut_ptr(
-            "edges",
-            EDGES_MAP.as_mut_ptr(),
-            MAX_EDGES_FOUND,
-        ))
-        .save_dr_cov(save_bb_coverage)
-        .max_cnt(drcov_max_execution_cnt)
-    };
-
     let options = FuzzerOptions::try_parse();
     let save_bb_coverage = options
         .as_ref()

fuzzers/toolbox/src/accum_observer.rs

@@ -4,6 +4,7 @@ use std::fs;
 use std::{
     collections::HashMap,
     hash::{BuildHasher, Hash, Hasher},
+    num::ParseIntError,
     path::PathBuf,
 };
 
@@ -128,18 +129,18 @@ where
                     if self.acc[i] == 0 {
                         continue;
                     }
-                    if pc_table.is_none() {
+                    if let Some(pc_table) = pc_table {
+                        // The addresses from PCTable are real memory addresses
+                        // The module is mapped starting from the beginning of the .init section
                         drcov_basic_blocks.push(DrCovBasicBlock {
-                            // I need the address to point to real memory addresses
-                            start: self.curr_mod_addr + i as usize, // this is fixed in the script
-                            end: self.curr_mod_addr + i as usize, // this is fixed in the script start == end indicates to fix the start as well
+                            start: pc_table[i].addr() + self.curr_mod_offset,
+                            end: pc_table[i].addr() + self.curr_mod_offset + 1, // this is fixed in the script
                         });
                     } else {
-                        // The addresses from PCTable are real memory addresses
-                        // The module is mapped starting from the beginning of the .init section
                         drcov_basic_blocks.push(DrCovBasicBlock {
-                            start: pc_table.unwrap()[i].addr() + self.curr_mod_offset,
-                            end: pc_table.unwrap()[i].addr() + self.curr_mod_offset + 1, // this is fixed in the script
+                            // I need the address to point to real memory addresses
+                            start: self.curr_mod_addr + i, // this is fixed in the script
+                            end: self.curr_mod_addr + i, // this is fixed in the script start == end indicates to fix the start as well
                         });
                     }
 
@@ -281,9 +282,19 @@ fn get_pid_name(pid: Option<u32>) -> String {
     }
 }
 
+#[derive(Debug)]
+pub enum CollectModulesError {
+    IoError(std::io::Error),
+    ParseError(std::num::ParseIntError),
+}
+impl From<ParseIntError> for CollectModulesError {
+    fn from(err: ParseIntError) -> Self {
+        CollectModulesError::ParseError(err)
+    }
+}
 /// A utility function to collect the modules of the current process and their ranges in memory
 #[allow(unused_mut)]
-pub fn collect_modules(pid: Option<u32>) -> Result<RangeMap<usize, (u16, String)>, ()> {
+pub fn collect_modules(pid: Option<u32>) -> Result<RangeMap<usize, (u16, String)>, CollectModulesError> {
     let mut ranges = RangeMap::new();
     #[cfg(windows)]
     {
@@ -300,15 +311,15 @@ pub fn collect_modules(pid: Option<u32>) -> Result<RangeMap<usize, (u16, String)
         };
 
         let file = File::open(get_pid_name(pid));
-        if file.is_err() {
-            return Err(());
+        if let Err(file_err) = file {
+            return Err(CollectModulesError::IoError(file_err));
         }
         let reader = BufReader::new(file.unwrap());
         let mut module_id = 0;
 
         for line in reader.lines() {
             if line.is_err() {
-                continue;
+                continue
             }
             let line = line.unwrap();
             log::info!("Line: {}", line);
@@ -327,8 +338,8 @@ pub fn collect_modules(pid: Option<u32>) -> Result<RangeMap<usize, (u16, String)
             if !parts[1].contains('x') {
                 continue;
             }
-            let start = usize::from_str_radix(range_parts[0], 16).map_err(|_| ())?;
-            let end = usize::from_str_radix(range_parts[1], 16).map_err(|_| ())?;
+            let start = usize::from_str_radix(range_parts[0], 16)?;
+            let end = usize::from_str_radix(range_parts[1], 16)?;
             let name = parts[5].to_string();
 
             log::info!("Module: {} - 0x{:x} - 0x{:x}", name, start, end);
@@ -397,7 +408,7 @@ fn collect_module_offsets(pid: Option<u32>) -> Result<HashMap<String, usize>, ()
                     // Iterate over section headers to find the .init section
                     for sh in elf.section_headers {
                         let offset = sh.sh_offset as usize;
-                        if let Some(section_name) = elf.shdr_strtab.get_at(sh.sh_name as usize) {
+                        if let Some(section_name) = elf.shdr_strtab.get_at(sh.sh_name) {
                             if section_name == ".init" {
                                 log::info!(
                                     "Module: {} - 0x{:x} - 0x{:x}",
@@ -440,7 +451,7 @@ fn find_module_params(
                          // curr_mod_name = ranges.get(&0).unwrap().1.clone();
         for (_, val) in ranges.iter() {
             if val.0 == curr_mod_id {
-                curr_mod_name = val.1.clone();
+                curr_mod_name.clone_from(&val.1);
                 break;
             }
         }
@@ -487,9 +498,9 @@ where
             cnt: 0,
             max_cnt: 0,
             stored_cnt: 0,
-            ranges: ranges,
-            curr_mod_offset: curr_mod_offset.clone(),
-            curr_mod_addr: curr_mod_addr,
+            ranges,
+            curr_mod_offset,
+            curr_mod_addr,
             use_pc_table: false,
             target_pid: 0,
         }

fuzzers/toolbox/src/crash_stack.rs

@@ -106,14 +106,14 @@ impl<'de> Visitor<'de> for PPFrameVisitor {
                 "ip" => {
                     let ip_str: String = map.next_value()?;
                     ip = Some(
-                        usize::from_str_radix(&ip_str.trim_start_matches("0x"), 16)
+                        usize::from_str_radix(ip_str.trim_start_matches("0x"), 16)
                             .map_err(de::Error::custom)?,
                     );
                 }
                 "symbol_address" => {
                     let symbol_address_str: String = map.next_value()?;
                     symbol_address = Some(
-                        usize::from_str_radix(&symbol_address_str.trim_start_matches("0x"), 16)
+                        usize::from_str_radix(symbol_address_str.trim_start_matches("0x"), 16)
                             .map_err(de::Error::custom)?,
                     );
                 }
@@ -122,7 +122,7 @@ impl<'de> Visitor<'de> for PPFrameVisitor {
                     if module_base_address_str != "unknown" {
                         module_base_address = Some(
                             usize::from_str_radix(
-                                &module_base_address_str.trim_start_matches("0x"),
+                                module_base_address_str.trim_start_matches("0x"),
                                 16,
                             )
                             .map_err(de::Error::custom)?,
@@ -157,20 +157,20 @@ impl<'de> Visitor<'de> for PPFrameVisitor {
         let ip_str = seq
             .next_element::<String>()?
             .ok_or_else(|| de::Error::invalid_length(0, &self))?;
-        let ip = usize::from_str_radix(&ip_str.trim_start_matches("0x"), 16)
+        let ip = usize::from_str_radix(ip_str.trim_start_matches("0x"), 16)
             .map_err(de::Error::custom)?;
 
         let symbol_address_str = seq
             .next_element::<String>()?
             .ok_or_else(|| de::Error::invalid_length(1, &self))?;
         let symbol_address =
-            usize::from_str_radix(&symbol_address_str.trim_start_matches("0x"), 16)
+            usize::from_str_radix(symbol_address_str.trim_start_matches("0x"), 16)
                 .map_err(de::Error::custom)?;
 
         let module_base_address_str = seq.next_element::<String>()?;
         let module_base_address_str = match module_base_address_str {
             Some(s) if s != "unknown" => Some(
-                usize::from_str_radix(&s.trim_start_matches("0x"), 16)
+                usize::from_str_radix(s.trim_start_matches("0x"), 16)
                     .map_err(de::Error::custom)?,
             ),
             _ => None,
@@ -183,7 +183,7 @@ impl<'de> Visitor<'de> for PPFrameVisitor {
             ip,
             symbol_address,
             module_base_address: module_base_address_str,
-            symbols: symbols,
+            symbols,
         })
     }
 }
@@ -215,7 +215,7 @@ impl Serialize for BacktraceMetadata {
                 module_base_address: frame.module_base_address().map(|addr| addr as usize),
                 symbols: frame
                     .symbols()
-                    .get(0)
+                    .first()
                     .map(|symbol| format!("{:?}", symbol))
                     .unwrap_or_else(|| "No symbol".to_string()),
             };
@@ -247,8 +247,8 @@ impl<'de> Visitor<'de> for BacktraceMetadataVisitor {
         // Read all elements from the sequence
         // while let Some(_) = seq.next_element::<HashMap<String, Self::Value>>()? {}
         // Read the name string and discard it
-        let _ = seq.next_element::<String>().map_err(|err| err);
-        while let Some(_) = seq.next_element::<PPFrame>().map_err(|err| err)? {}
+        let _ = seq.next_element::<String>();
+        while (seq.next_element::<PPFrame>()?).is_some() {}
         // Always return a current BacktraceMetadata.
         Ok(BacktraceMetadata::new(Backtrace::new_unresolved()))
     }
@@ -423,7 +423,7 @@ where
         //     .match_name::<BacktraceObserverWithStack>(&self.0.observer_name())
         //     .expect("A NewHashFeedbackWithStack needs a BacktraceObserverWithStack");
         let observer = observers
-            .get(&self.0.observer_handle())
+            .get(self.0.observer_handle())
             .expect("A NewHashFeedbackWithStack needs a BacktraceObserverWithStack");
 
         match observer.get_backtrace() {

fuzzers/toolbox/src/reachability_rt.rs

@@ -118,7 +118,7 @@ impl ReachabilityRuntime {
                 hooks_cnt: 0,
                 hook_indices: HashMap::new(),
                 _pinned: PhantomPinned,
-                hooks: hooks,
+                hooks,
             })),
         }
     }
@@ -188,15 +188,15 @@ impl ReachabilityRuntime {
             .insert(name.to_string(), hook_idx);
         let hook_ctx = HookCtx {
             rt: self,
-            org_fn: frida_gum::Module::find_export_by_name(Some(&lib), &name)
+            org_fn: frida_gum::Module::find_export_by_name(Some(lib), name)
                 .expect("Failed to find function"),
-            hook_idx: hook_idx,
+            hook_idx,
         };
         let hook_ctx_ptr = Box::into_raw(Box::new(hook_ctx));
 
         interceptor
             .replace(
-                frida_gum::Module::find_export_by_name(Some(&lib), &name)
+                frida_gum::Module::find_export_by_name(Some(lib), name)
                     .expect("Failed to find function"),
                 NativePointer(replacement as *mut c_void),
                 NativePointer(hook_ctx_ptr as *mut c_void),
@@ -233,7 +233,6 @@ impl ReachabilityRuntime {
             ),
             _ => {
                 log::error!("Unsupported number of parameters for function {}", name);
-                return;
             }
         }
     }
@@ -292,6 +291,7 @@ pub struct ReachabilityObserver {
 impl ReachabilityObserver {
     /// Creates a new [`ReachabilityObserver`] with the given name.
     #[must_use]
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn new<S>(observer_name: S, map: *mut u8, hooks_file: Option<&str>) -> Self
     where
         S: Into<Cow<'static, str>> + Clone,
@@ -316,7 +316,7 @@ impl ReachabilityObserver {
         Self {
             observer_name: observer_name.clone().into(),
             base: unsafe { StdMapObserver::from_mut_ptr(observer_name, map, MAP_SIZE) },
-            hooks: hooks,
+            hooks,
             invocations: Vec::new(),
         }
     }