AFLplusplus
diff --git a/‎.github/workflows/build_and_test.yml
+2 b/‎.github/workflows/build_and_test.yml
+2
diff --git a/‎build_all_fuzzers.sh
+16 b/‎build_all_fuzzers.sh
+16
diff --git a/‎clippy.sh
+6-2 b/‎clippy.sh
+6-2
diff --git a/‎docs/src/baby_fuzzer.md
+1-1 b/‎docs/src/baby_fuzzer.md
+1-1
diff --git a/‎fuzzers/baby_fuzzer/Cargo.toml
+1-1 b/‎fuzzers/baby_fuzzer/Cargo.toml
+1-1
diff --git a/‎fuzzers/baby_fuzzer/src/main.rs
+10-9 b/‎fuzzers/baby_fuzzer/src/main.rs
+10-9
diff --git a/‎fuzzers/frida_libpng/Cargo.toml
+5-4 b/‎fuzzers/frida_libpng/Cargo.toml
+5-4
diff --git a/‎fuzzers/frida_libpng/README.md
+9 b/‎fuzzers/frida_libpng/README.md
+9
diff --git a/‎fuzzers/frida_libpng/build.rs
+7-8 b/‎fuzzers/frida_libpng/build.rs
+7-8
@@ -60,6 +60,8 @@ jobs:
       run: cargo test --all-features --doc
     - name: Run clippy
       run: ./clippy.sh
+    - name: Build fuzzers
+      run: ./build_all_fuzzers.sh
   windows:
     runs-on: windows-latest
     steps:
 
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+# TODO: This should be rewritten in rust, a Makefile, or some platform-independent language
+
+cd fuzzers
+
+for fuzzer in *;
+do
+    echo "[+] Checking fmt, clippy, and building $fuzzer"
+    cd $fuzzer \
+        && cargo fmt --all -- --check \
+        && ../../clippy.sh --no-clean \
+        && cargo build \
+        && cd .. \
+    || exit 1
+done
@@ -1,14 +1,18 @@
 #!/bin/sh
 # Clippy checks
-cargo clean -p libafl
+if [ "$1" != "--no-clean" ]; then
+   # Usually, we want to clean, since clippy won't work otherwise.
+   echo "[+] Cleaning up previous builds..."
+   cargo clean -p libafl
+fi
 RUST_BACKTRACE=full cargo clippy --all --all-features --tests -- \
    -D clippy::pedantic \
-   -W clippy::similar-names \
    -W clippy::unused_self \
    -W clippy::too_many_lines \
    -W clippy::option_if_let_else \
    -W clippy::must-use-candidate \
    -W clippy::if-not-else \
+   -W clippy::similar-names \
    -A clippy::type_repetition_in_bounds \
    -A clippy::missing-errors-doc \
    -A clippy::cast-possible-truncation \
 
@@ -156,13 +156,13 @@ Now you can prepend the following `use` directives to your main.rs and compile i
 ```rust 
 use std::path::PathBuf;
 use libafl::{
+    bolts::{current_nanos, rands::StdRand},
     corpus::{InMemoryCorpus, OnDiskCorpus, QueueCorpusScheduler},
     events::SimpleEventManager,
     executors::{inprocess::InProcessExecutor, ExitKind},
     generators::RandPrintablesGenerator,
     state::State,
     stats::SimpleStats,
-    utils::{current_nanos, StdRand},
 };
 ```
 
 
@@ -1,6 +1,6 @@
 [package]
 name = "baby_fuzzer"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Andrea Fioraldi <[email protected]>", "Dominik Maier <[email protected]>"]
 edition = "2018"
 
 
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use libafl::{
-    bolts::tuples::tuple_list,
+    bolts::{current_nanos, rands::StdRand, tuples::tuple_list},
     corpus::{InMemoryCorpus, OnDiskCorpus, QueueCorpusScheduler},
     events::SimpleEventManager,
     executors::{inprocess::InProcessExecutor, ExitKind},
@@ -13,25 +13,26 @@ use libafl::{
     stages::mutational::StdMutationalStage,
     state::StdState,
     stats::SimpleStats,
-    utils::{current_nanos, StdRand},
 };
 
-// Coverage map with explicit assignments due to the lack of instrumentation
+/// Coverage map with explicit assignments due to the lack of instrumentation
 static mut SIGNALS: [u8; 16] = [0; 16];
 
+/// Assign a signal to the signals map
 fn signals_set(idx: usize) {
     unsafe { SIGNALS[idx] = 1 };
 }
 
+#[allow(clippy::similar_names)]
 pub fn main() {
     // The closure that we want to fuzz
     let mut harness = |buf: &[u8]| {
         signals_set(0);
-        if buf.len() > 0 && buf[0] == 'a' as u8 {
+        if !buf.is_empty() && buf[0] == b'a' {
             signals_set(1);
-            if buf.len() > 1 && buf[1] == 'b' as u8 {
+            if buf.len() > 1 && buf[1] == b'b' {
                 signals_set(2);
-                if buf.len() > 2 && buf[2] == 'c' as u8 {
+                if buf.len() > 2 && buf[2] == b'c' {
                     panic!("=)");
                 }
             }
@@ -86,21 +87,21 @@ pub fn main() {
         &mut state,
         &mut mgr,
     )
-    .expect("Failed to create the Executor".into());
+    .expect("Failed to create the Executor");
 
     // Generator of printable bytearrays of max size 32
     let mut generator = RandPrintablesGenerator::new(32);
 
     // Generate 8 initial inputs
     state
         .generate_initial_inputs(&mut fuzzer, &mut executor, &mut generator, &mut mgr, 8)
-        .expect("Failed to generate the initial corpus".into());
+        .expect("Failed to generate the initial corpus");
 
     // Setup a mutational stage with a basic bytes mutator
     let mutator = StdScheduledMutator::new(havoc_mutations());
     let mut stages = tuple_list!(StdMutationalStage::new(mutator));
 
     fuzzer
         .fuzz_loop(&mut stages, &mut executor, &mut state, &mut mgr)
-        .expect("Error in the fuzzing loop".into());
+        .expect("Error in the fuzzing loop");
 }
@@ -1,6 +1,6 @@
 [package]
 name = "frida_libpng"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Andrea Fioraldi <[email protected]>", "Dominik Maier <[email protected]>"]
 edition = "2018"
 build = "build.rs"
@@ -21,17 +21,18 @@ num_cpus = "1.0"
 which = "4.1"
 
 [target.'cfg(unix)'.dependencies]
-libafl = { path = "../../libafl/", features = [ "std", "llmp_compression" ] } #,  "llmp_small_maps", "llmp_debug"]}
+libafl = { path = "../../libafl/", features = [ "std", "llmp_compression", "llmp_bind_public" ] } #,  "llmp_small_maps", "llmp_debug"]}
+libafl_frida = { path = "../../libafl_frida" }
 capstone = "0.8.0"
-frida-gum = { version = "0.4", git = "https://github.com/s1341/frida-rust", features = [ "auto-download", "event-sink", "invocation-listener"] }
+frida-gum = { version = "0.4.1", git = "https://github.com/frida/frida-rust", features = [ "auto-download", "event-sink", "invocation-listener"] }
 #frida-gum = { version = "0.4", path = "../../../frida-rust/frida-gum", features = [ "auto-download", "event-sink", "invocation-listener"] }
-libafl_frida = { path = "../../libafl_frida", version = "0.2.0" }
 lazy_static = "1.4.0"
 libc = "0.2"
 libloading = "0.7.0"
 num-traits = "0.2.14"
 rangemap = "0.1.10"
 seahash = "4.1.0"
+clap = "2.33"
 serde = "1.0"
 
 backtrace = "0.3"
 
@@ -11,6 +11,15 @@ This will call (the build.rs)[./build.rs], which in turn downloads a libpng arch
 Then, it will link (the fuzzer)[./src/fuzzer.rs] against (the C++ harness)[./harness.cc] and the instrumented `libpng`.
 Afterwards, the fuzzer will be ready to run, from `../../target/examples/libfuzzer_libpng`.
 
+### Build For Android
+When building for android using a cross-compiler, make sure you have a _standalone toolchain_, and then add the following:
+1. In the ~/.cargo/config file add a target with the correct cross-compiler toolchain name (in this case aarch64-linux-android, but names may vary)
+`[target.aarch64-linux-android]`
+`linker="aarch64-linux-android-clang"`
+2. add path to installed toolchain to PATH env variable.
+3. define CLANG_PATH and add target to the build command line:
+`CLANG_PATH=<path to installed toolchain>/bin/aarch64-linux-android-clang cargo -v build --release --target=aarch64-linux-android`
+
 ## Run
 
 The first time you run the binary, the broker will open a tcp port (currently on port `1337`), waiting for fuzzer clients to connect. This port is local and only used for the initial handshake. All further communication happens via shared map, to be independent of the kernel.
 
@@ -12,15 +12,14 @@ const LIBPNG_URL: &str =
     "https://deac-fra.dl.sourceforge.net/project/libpng/libpng16/1.6.37/libpng-1.6.37.tar.xz";
 
 fn build_dep_check(tools: &[&str]) {
-    for tool in tools.into_iter() {
+    for tool in tools {
         println!("Checking for build tool {}...", tool);
 
-        match which(tool) {
-            Ok(path) => println!("Found build tool {}", path.to_str().unwrap()),
-            Err(_) => {
-                println!("ERROR: missing build tool {}", tool);
-                exit(1);
-            }
+        if let Ok(path) = which(tool) {
+            println!("Found build tool {}", path.to_str().unwrap())
+        } else {
+            println!("ERROR: missing build tool {}", tool);
+            exit(1);
         };
     }
 }
@@ -35,7 +34,7 @@ fn main() {
     let cwd = env::current_dir().unwrap().to_string_lossy().to_string();
     let out_dir = out_dir.to_string_lossy().to_string();
     let out_dir_path = Path::new(&out_dir);
-    std::fs::create_dir_all(&out_dir).expect(&format!("Failed to create {}", &out_dir));
+    std::fs::create_dir_all(&out_dir).unwrap_or_else(|_| panic!("Failed to create {}", &out_dir));
 
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-changed=../libfuzzer_runtime/rt.c",);