Move build_id to bolts (#649)

* Drop the build_id depedency and move to bolts

* tabs->spaces

* clippy build_id fixes

* frida clippy

Co-authored-by: Dominik Maier <dmnk@google.com>

libafl/Cargo.toml

@@ -13,7 +13,7 @@ categories = ["development-tools::testing", "emulators", "embedded", "os", "no-s
 
 [features]
 default = ["std", "derive", "llmp_compression", "rand_trait", "fork"]
-std = ["serde_json", "serde_json/std", "hostname", "core_affinity", "nix", "serde/std", "bincode", "wait-timeout", "regex", "build_id", "uuid", "tui_monitor", "ctor", "backtrace"] # print, env, launcher ... support
+std = ["serde_json", "serde_json/std", "hostname", "core_affinity", "nix", "serde/std", "bincode", "wait-timeout", "regex", "byteorder", "once_cell", "uuid", "tui_monitor", "ctor", "backtrace"] # print, env, launcher ... support
 derive = ["libafl_derive"] # provide derive(SerdeAny) macro.
 fork = [] # uses the fork() syscall to spawn children, instead of launching a new command, if supported by the OS (has no effect on Windows, no_std).
 rand_trait = ["rand_core"] # If set, libafl's rand implementations will implement `rand::Rng`
@@ -73,8 +73,9 @@ hostname = { version = "^0.3", optional = true } # Is there really no gethostnam
 rand_core = { version = "0.5.1", optional = true } # This dependency allows us to export our RomuRand as rand::Rng. We cannot update to the latest version because it breaks compatibility to microsoft lain.
 nix = { version = "0.23", optional = true }
 regex = { version = "1", optional = true }
-build_id = { version = "0.2.1", git = "https://github.com/domenukk/build_id", rev = "6a61943", optional = true }
 uuid = { version = "0.8.2", optional = true, features = ["serde", "v4"] }
+byteorder = { version = "1.2", optional = true }
+once_cell = { version =  "1.2", optional = true }
 libm = "0.2.1"
 tui = { version = "0.16", default-features = false, features = ['crossterm'], optional = true }
 crossterm = { version = "0.20", optional = true }

libafl/src/bolts/build_id.rs

@@ -0,0 +1,111 @@
+//! Based on <https://github.com/alecmocatta/build_id>
+//! (C) Alec Mocatta <alec@mocatta.net> under license MIT or Apache 2
+
+use once_cell::sync::Lazy;
+use std::{
+    any::TypeId,
+    env,
+    fs::File,
+    hash::{Hash, Hasher},
+    io,
+};
+use uuid::Uuid;
+
+static BUILD_ID: Lazy<Uuid> = Lazy::new(calculate);
+
+/// Returns a [Uuid] uniquely representing the build of the current binary.
+///
+/// This is intended to be used to check that different processes are indeed
+/// invocations of identically laid out binaries.
+///
+/// As such:
+/// * It is guaranteed to be identical within multiple invocations of the same
+/// binary.
+/// * It is guaranteed to be different across binaries with different code or
+/// data segments or layout.
+/// * Equality is unspecified if the binaries have identical code and data
+/// segments and layout but differ immaterially (e.g. if a timestamp is included
+/// in the binary at compile time).
+///
+/// # Examples
+///
+/// ```
+/// # let remote_build_id = libafl::bolts::build_id::get();
+/// let local_build_id = libafl::bolts::build_id::get();
+/// if local_build_id == remote_build_id {
+///     println!("We're running the same binary as remote!");
+/// } else {
+///     println!("We're running a different binary to remote");
+/// }
+/// ```
+///
+/// # Note
+///
+/// This looks first for linker-inserted build ID / binary UUIDs (i.e.
+/// `.note.gnu.build-id` on Linux; `LC_UUID` in Mach-O; etc), falling back to
+/// hashing the whole binary.
+#[inline]
+#[must_use]
+pub fn get() -> Uuid {
+    *BUILD_ID
+}
+
+fn from_exe<H: Hasher>(mut hasher: H) -> Result<H, ()> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        if cfg!(miri) {
+            return Err(());
+        }
+        let file = File::open(env::current_exe().map_err(drop)?).map_err(drop)?;
+        let _ = io::copy(&mut &file, &mut HashWriter(&mut hasher)).map_err(drop)?;
+        Ok(hasher)
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let _ = &mut hasher;
+        Err(())
+    }
+}
+fn from_type_id<H: Hasher>(mut hasher: H) -> H {
+    fn type_id_of<T: 'static>(_: &T) -> TypeId {
+        TypeId::of::<T>()
+    }
+    TypeId::of::<()>().hash(&mut hasher);
+    TypeId::of::<u8>().hash(&mut hasher);
+    let a = |x: ()| x;
+    type_id_of(&a).hash(&mut hasher);
+    let b = |x: u8| x;
+    type_id_of(&b).hash(&mut hasher);
+    hasher
+}
+
+fn calculate() -> Uuid {
+    let hasher = xxhash_rust::xxh3::Xxh3::with_seed(0);
+
+    let hasher = from_exe(hasher.clone()).unwrap_or(hasher);
+    let mut hasher = from_type_id(hasher);
+
+    let mut bytes = [0; 16];
+    <byteorder::NativeEndian as byteorder::ByteOrder>::write_u64(&mut bytes[..8], hasher.finish());
+    hasher.write_u8(0);
+    <byteorder::NativeEndian as byteorder::ByteOrder>::write_u64(&mut bytes[8..], hasher.finish());
+
+    uuid::Builder::from_bytes(bytes)
+        .set_variant(uuid::Variant::RFC4122)
+        .set_version(uuid::Version::Random)
+        .build()
+}
+
+struct HashWriter<T: Hasher>(T);
+impl<T: Hasher> io::Write for HashWriter<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf);
+        Ok(buf.len())
+    }
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.write(buf).map(|_| ())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

libafl/src/bolts/mod.rs

@@ -1,6 +1,8 @@
 //! Bolts are no conceptual fuzzing elements, but they keep libafl-based fuzzers together.
 
 pub mod anymap;
+#[cfg(feature = "std")]
+pub mod build_id;
 #[cfg(all(
     any(feature = "cli", feature = "frida_cli", feature = "qemu_cli"),
     feature = "std"

libafl/src/events/mod.rs

@@ -106,7 +106,7 @@ impl EventConfig {
     #[must_use]
     pub fn from_build_id() -> Self {
         EventConfig::BuildID {
-            id: build_id::get(),
+            id: crate::bolts::build_id::get(),
         }
     }