Move all unnecessary std uses to core,alloc (#3027)

* Move all unnecessary std uses to core,alloc

* More

* more fix

* more

* more

* Remove libafl-fuzz grimoire

* more

* more

* more cleanup

* remove bins

* fix

* more fix

Author: domenukk

.gitignore

@@ -76,3 +76,6 @@ program
 fuzzer_libpng*
 
 *.patch
+
+# Sometimes this happens
+rustc-ice-*

Cargo.toml

@@ -148,6 +148,10 @@ all = { level = "deny", priority = -1 }
 pedantic = { level = "deny", priority = -1 }
 cargo_common_metadata = "deny"
 
+alloc_instead_of_core = "deny"
+std_instead_of_alloc = "deny"
+std_instead_of_core = "deny"
+
 # Warn
 cargo = { level = "warn", priority = -1 }
 

fuzzers/binary_only/qemu_launcher/injection_test/.gitignore

@@ -0,0 +1,2 @@
+injection_test
+static

libafl/examples/tui_mock/main.rs

@@ -1,7 +1,8 @@
 //! An example for TUI that uses the TUI without any real data.
 //! This is mainly to fix the UI without having to run a real fuzzer.
 
-use std::{thread::sleep, time::Duration};
+use core::time::Duration;
+use std::thread::sleep;
 
 use libafl::monitors::{
     Monitor,

libafl/src/common/nautilus/grammartec/chunkstore.rs

@@ -1,9 +1,6 @@
 use alloc::{string::String, vec::Vec};
-use std::{
-    fs::File,
-    io::Write,
-    sync::{RwLock, atomic::AtomicBool},
-};
+use core::sync::atomic::AtomicBool;
+use std::{fs::File, io::Write, sync::RwLock};
 
 use hashbrown::{HashMap, HashSet};
 use libafl_bolts::rands::Rand;

libafl/src/common/nautilus/grammartec/newtypes.rs

@@ -1,4 +1,4 @@
-use std::ops::Add;
+use core::ops::Add;
 
 use serde::{Deserialize, Serialize};
 

libafl/src/common/nautilus/grammartec/python_grammar_loader.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::useless_conversion)] // This seems to be a false-positive(?)
 
-use std::{ffi::CString, string::String, vec::Vec};
+use alloc::{ffi::CString, string::String, vec::Vec};
 
 use pyo3::{prelude::*, pyclass, types::IntoPyDict};
 

libafl/src/common/nautilus/grammartec/recursion_info.rs

@@ -1,5 +1,4 @@
-use alloc::vec::Vec;
-use std::fmt;
+use alloc::{fmt, vec::Vec};
 
 use hashbrown::HashMap;
 use libafl_bolts::{

libafl/src/common/nautilus/grammartec/rule.rs

@@ -25,7 +25,7 @@ static SPLITTER: OnceLock<regex::Regex> = OnceLock::new();
 static TOKENIZER: OnceLock<regex::bytes::Regex> = OnceLock::new();
 
 fn show_bytes(bs: &[u8]) -> String {
-    use std::{ascii::escape_default, str};
+    use core::{ascii::escape_default, str};
 
     let mut visible = String::new();
     for &b in bs {
@@ -265,7 +265,7 @@ impl Rule {
                 if let Some(sub) = cap.get(1) {
                     //println!("cap.get(1): {}", sub.as_str());
                     RuleChild::from_nt(
-                        std::str::from_utf8(sub.as_bytes())
+                        core::str::from_utf8(sub.as_bytes())
                             .expect("nonterminals need to be valid strings"),
                         ctx,
                     )

libafl/src/common/nautilus/grammartec/tree.rs

@@ -1,5 +1,6 @@
 use alloc::vec::Vec;
-use std::{cmp, io, io::Write, marker::Sized};
+use core::{cmp, marker::Sized};
+use std::io::{Cursor, Write, stdout};
 
 use hashbrown::HashSet;
 use libafl_bolts::rands::Rand;
@@ -28,7 +29,7 @@ enum UnparseStep<'dat> {
 struct Unparser<'data, 'tree: 'data, 'ctx: 'data, W: Write, T: TreeLike> {
     tree: &'tree T,
     stack: Vec<UnparseStep<'data>>,
-    buffers: Vec<io::Cursor<Vec<u8>>>,
+    buffers: Vec<Cursor<Vec<u8>>>,
     w: W,
     i: usize,
     ctx: &'ctx Context,
@@ -81,10 +82,7 @@ impl<'data, 'tree: 'data, 'ctx: 'data, W: Write, T: TreeLike> Unparser<'data, 't
     }
     fn script(&mut self, py: Python, num: usize, expr: &PyObject) -> PyResult<()> {
         let bufs = self.buffers.split_off(self.buffers.len() - num);
-        let bufs = bufs
-            .into_iter()
-            .map(io::Cursor::into_inner)
-            .collect::<Vec<_>>();
+        let bufs = bufs.into_iter().map(Cursor::into_inner).collect::<Vec<_>>();
         let byte_arrays = bufs.iter().map(|b| PyBytes::new(py, b));
         let res = expr.call1(py, PyTuple::new(py, byte_arrays)?)?;
         let bound = res.bind(py);
@@ -103,7 +101,7 @@ impl<'data, 'tree: 'data, 'ctx: 'data, W: Write, T: TreeLike> Unparser<'data, 't
     }
 
     fn push_buffer(&mut self) {
-        self.buffers.push(io::Cursor::new(vec![]));
+        self.buffers.push(Cursor::new(vec![]));
     }
 
     fn next_rule(&mut self, nt: NTermId) {
@@ -184,7 +182,7 @@ where
     }
 
     fn unparse_print(&self, ctx: &Context) {
-        self.unparse_to(ctx, &mut io::stdout());
+        self.unparse_to(ctx, &mut stdout());
     }
 }
 

libafl/src/common/nautilus/regex_mutator/mod.rs

@@ -59,7 +59,7 @@ fn append_unicode_range<R: Rand>(
     let a = u32::from_le_bytes(chr_a_buf);
     let b = u32::from_le_bytes(chr_b_buf);
     let c = scr.get_range(rand, a as usize, (b + 1) as usize) as u32;
-    append_char(res, std::char::from_u32(c).unwrap());
+    append_char(res, core::char::from_u32(c).unwrap());
 }
 
 fn append_byte_range<R: Rand>(

libafl/src/events/broker_hooks/centralized_multi_machine.rs

@@ -1,9 +1,8 @@
-use std::{
+use alloc::{sync::Arc, vec::Vec};
+use core::{
     fmt::{Debug, Display},
     marker::PhantomData,
     slice,
-    sync::Arc,
-    vec::Vec,
 };
 
 #[cfg(feature = "llmp_compression")]

libafl/src/events/launcher.rs

@@ -12,12 +12,13 @@
 //! On `Unix` systems, the [`Launcher`] will use `fork` if the `fork` feature is used for `LibAFL`.
 //! Else, it will start subsequent nodes with the same commandline, and will set special `env` variables accordingly.
 
+use alloc::string::String;
 use core::{
     fmt::{self, Debug, Formatter},
+    net::SocketAddr,
     num::NonZeroUsize,
     time::Duration,
 };
-use std::{net::SocketAddr, string::String};
 
 use libafl_bolts::{
     core_affinity::{CoreId, Cores},
@@ -32,13 +33,13 @@ use {
         events::{CentralizedLlmpHook, StdLlmpEventHook, centralized::CentralizedEventManager},
         inputs::Input,
     },
+    alloc::boxed::Box,
     alloc::string::ToString,
     libafl_bolts::{
         core_affinity::get_core_ids,
         llmp::{Broker, Brokers, LlmpBroker},
         os::{ForkResult, fork},
     },
-    std::boxed::Box,
 };
 #[cfg(unix)]
 use {

libafl/src/events/llmp/restarting.rs

@@ -8,11 +8,11 @@ use alloc::string::ToString;
 use alloc::vec::Vec;
 use core::{
     marker::PhantomData,
+    net::SocketAddr,
     num::NonZeroUsize,
     sync::atomic::{Ordering, compiler_fence},
     time::Duration,
 };
-use std::net::SocketAddr;
 #[cfg(feature = "std")]
 use std::net::TcpStream;
 

libafl/src/events/multi_machine.rs

@@ -1,16 +1,10 @@
-use core::fmt::Display;
-use std::{
-    boxed::Box,
-    collections::HashMap,
-    io::ErrorKind,
-    process,
-    sync::{
-        Arc, OnceLock,
-        atomic::{AtomicU64, Ordering},
-    },
+use alloc::{boxed::Box, sync::Arc, vec::Vec};
+use core::{
+    fmt::Display,
+    sync::atomic::{AtomicU64, Ordering},
     time::Duration,
-    vec::Vec,
 };
+use std::{collections::HashMap, io::ErrorKind, process, sync::OnceLock};
 
 use enumflags2::{BitFlags, bitflags};
 #[cfg(feature = "llmp_compression")]
@@ -407,9 +401,9 @@ where
 
     /// Write an [`OwnedTcpMultiMachineMsg`] to a stream.
     /// Can be read back using [`TcpMultiMachineState::read_msg`].
-    async fn write_msg<'a, I: Input>(
+    async fn write_msg<I: Input>(
         stream: &mut TcpStream,
-        msg: &MultiMachineMsg<'a, I>,
+        msg: &MultiMachineMsg<'_, I>,
     ) -> Result<(), Error> {
         let serialized_msg = msg.serialize_as_ref();
         let msg_len = u32::to_le_bytes(serialized_msg.len() as u32);
@@ -451,9 +445,9 @@ where
         Ok(())
     }
 
-    pub(crate) async fn send_interesting_event_to_nodes<'a, I: Input>(
+    pub(crate) async fn send_interesting_event_to_nodes<I: Input>(
         &mut self,
-        msg: &MultiMachineMsg<'a, I>,
+        msg: &MultiMachineMsg<'_, I>,
     ) -> Result<(), Error> {
         log::debug!("Sending interesting events to nodes...");
 
@@ -503,9 +497,9 @@ where
 
     /// Flush the message queue from other nodes and add incoming events to the
     /// centralized event manager queue.
-    pub(crate) async fn receive_new_messages_from_nodes<'a, I: Input>(
+    pub(crate) async fn receive_new_messages_from_nodes<I: Input>(
         &mut self,
-        msgs: &mut Vec<MultiMachineMsg<'a, I>>,
+        msgs: &mut Vec<MultiMachineMsg<'_, I>>,
     ) -> Result<(), Error> {
         log::debug!("Checking for new events from other nodes...");
         // let mut nb_received = 0usize;

libafl/src/events/tcp.rs

@@ -1,17 +1,17 @@
 //! TCP-backed event manager for scalable multi-processed fuzzing
 
-use alloc::vec::Vec;
+use alloc::{sync::Arc, vec::Vec};
 use core::{
     marker::PhantomData,
+    net::SocketAddr,
     num::NonZeroUsize,
     sync::atomic::{Ordering, compiler_fence},
     time::Duration,
 };
 use std::{
     env,
     io::{ErrorKind, Read, Write},
-    net::{SocketAddr, TcpListener, TcpStream, ToSocketAddrs},
-    sync::Arc,
+    net::{TcpListener, TcpStream, ToSocketAddrs},
 };
 
 #[cfg(feature = "tcp_compression")]

libafl/src/executors/command.rs

@@ -1,22 +1,23 @@
 //! The command executor executes a sub program for each run
+#[cfg(all(feature = "intel_pt", target_os = "linux"))]
+use alloc::ffi::CString;
 use alloc::vec::Vec;
+#[cfg(all(feature = "intel_pt", target_os = "linux"))]
+use core::ffi::CStr;
 use core::{
     fmt::{self, Debug, Formatter},
     marker::PhantomData,
     ops::IndexMut,
+    time::Duration,
 };
 #[cfg(all(feature = "intel_pt", target_os = "linux"))]
-use std::{
-    ffi::{CStr, CString},
-    os::fd::AsRawFd,
-};
+use std::os::fd::AsRawFd;
 use std::{
     ffi::{OsStr, OsString},
     io::{Read, Write},
     os::unix::ffi::OsStrExt,
     path::{Path, PathBuf},
     process::{Child, Command, Stdio},
-    time::Duration,
 };
 
 #[cfg(all(feature = "intel_pt", target_os = "linux"))]

libafl/src/executors/hooks/inprocess.rs

@@ -464,7 +464,7 @@ impl InProcessExecutorHandlerData {
                     );
 
                     if let Ok(bsod) = bsod {
-                        if let Ok(r) = std::str::from_utf8(&bsod) {
+                        if let Ok(r) = core::str::from_utf8(&bsod) {
                             log::error!("{}", r);
                         }
                     }

libafl/src/executors/hooks/unix.rs

@@ -238,7 +238,7 @@ pub mod unix_signal_handler {
                         }
                         let _ = writer.flush();
                     }
-                    if let Ok(r) = std::str::from_utf8(&bsod) {
+                    if let Ok(r) = core::str::from_utf8(&bsod) {
                         log::error!("{}", r);
                     }
                 }
@@ -278,7 +278,7 @@ pub mod unix_signal_handler {
                             }
                             let _ = writer.flush();
                         }
-                        if let Ok(r) = std::str::from_utf8(&bsod) {
+                        if let Ok(r) = core::str::from_utf8(&bsod) {
                             log::error!("{}", r);
                         }
                     }

libafl/src/feedbacks/capture_feedback.rs

@@ -1,5 +1,6 @@
 //! Feedback that captures Timeouts for re-running
-use std::{borrow::Cow, cell::RefCell, fmt::Debug, rc::Rc};
+use alloc::{borrow::Cow, rc::Rc};
+use core::{cell::RefCell, fmt::Debug};
 
 use libafl_bolts::{Error, Named};
 use serde::{Serialize, de::DeserializeOwned};

libafl/src/feedbacks/nautilus.rs

@@ -25,7 +25,7 @@ pub struct NautilusChunksMetadata {
 }
 
 impl Debug for NautilusChunksMetadata {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "NautilusChunksMetadata {{ {} }}",

libafl/src/feedbacks/new_hash_feedback.rs

@@ -1,7 +1,7 @@
 //! The [`NewHashFeedback`] uses the backtrace hash and a hashset to only keep novel cases
 
 use alloc::{borrow::Cow, string::ToString};
-use std::fmt::Debug;
+use core::fmt::Debug;
 
 use hashbrown::HashSet;
 use libafl_bolts::{

libafl/src/fuzzer/mod.rs

@@ -1,9 +1,9 @@
 //! The `Fuzzer` is the main struct for a fuzz campaign.
 
 use alloc::{string::ToString, vec::Vec};
-use core::{fmt::Debug, time::Duration};
 #[cfg(feature = "std")]
-use std::hash::Hash;
+use core::hash::Hash;
+use core::{fmt::Debug, time::Duration};
 
 #[cfg(feature = "std")]
 use fastbloom::BloomFilter;

libafl/src/generators/nautilus.rs

@@ -21,7 +21,7 @@ pub struct NautilusContext {
 }
 
 impl Debug for NautilusContext {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "NautilusContext {{}}",)
     }
 }
@@ -114,7 +114,7 @@ pub struct NautilusGenerator<'a> {
 }
 
 impl Debug for NautilusGenerator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "NautilusGenerator {{}}",)
     }
 }

libafl/src/inputs/multi.rs

@@ -1,7 +1,7 @@
 //! An input composed of multiple parts identified by a key.
 
-use alloc::{fmt::Debug, string::String, vec::Vec};
-use core::hash::Hash;
+use alloc::{string::String, vec::Vec};
+use core::{fmt::Debug, hash::Hash};
 
 use serde::{Serialize, de::DeserializeOwned};