fuzz: remove afl feature, clean up fuzztests a bit

Substantially rewrite the `encode_decode` fuzztest, which had some
ugly/awkward control flow. For the other tests, remove the AFL feature
which has not been used in years and the now-unneeded `extern crate` and
`macro_use` calls.

Now you can fuzz things by just running `cargo hfuzz` directly without
needing to set rustflags etc.

Also run shellcheck on fuzz.sh, add a bunch of quotes to it, and change
the runtime from 100000 iterations (which seems to run in less than a
second on my system for all the existing tests) to a fixed 10 seconds.

This does **not** pull the full rust-bitcoin fuzztest scripts over. I
would like to wait until the "move fuzztests to cron" PR merges in
rust-bitcoin, and consider trying to move all the scripts into a shared
repo rather than copy/pasting them in, before doing so.

Author: apoelstra

fuzz/Cargo.toml

@@ -1,20 +1,16 @@
 [package]
 name = "bech32-fuzz"
+edition = "2021"
+rust-version = "1.56.1"
 version = "0.0.1"
 authors = ["Automatically generated"]
 publish = false
 
 [package.metadata]
 cargo-fuzz = true
 
-[features]
-afl_fuzz = ["afl"]
-honggfuzz_fuzz = ["honggfuzz"]
-
 [dependencies]
-honggfuzz = { version = "0.5", default-features = false, optional = true }
-afl = { version = "0.3", optional = true }
-libc = "0.2"
+honggfuzz = { version = "0.5.55", default-features = false }
 bech32 = { path = ".." }
 
 # Prevent this from interfering with workspaces

fuzz/fuzz.sh

@@ -2,17 +2,17 @@
 set -e
 cargo install --force honggfuzz --no-default-features
 for TARGET in fuzz_targets/*; do
-    FILENAME=$(basename $TARGET)
+    FILENAME=$(basename "$TARGET")
 	FILE="${FILENAME%.*}"
-	if [ -d hfuzz_input/$FILE ]; then
+	if [ -d "hfuzz_input/$FILE" ]; then
 	    HFUZZ_INPUT_ARGS="-f hfuzz_input/$FILE/input"
 	fi
-	HFUZZ_BUILD_ARGS="--features honggfuzz_fuzz" HFUZZ_RUN_ARGS="-N1000000 --exit_upon_crash -v $HFUZZ_INPUT_ARGS" cargo hfuzz run $FILE
+	HFUZZ_RUN_ARGS="--run_time 10 --exit_upon_crash -v $HFUZZ_INPUT_ARGS" cargo hfuzz run "$FILE"
 
-	if [ -f hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT ]; then
-		cat hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT
-		for CASE in hfuzz_workspace/$FILE/SIG*; do
-			cat $CASE | xxd -p
+	if [ -f "hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT" ]; then
+		cat "hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT"
+		for CASE in "hfuzz_workspace/$FILE/SIG"*; do
+			xxd -p < "$CASE"
 		done
 		exit 1
 	fi

fuzz/fuzz_targets/decode_rnd.rs

@@ -1,7 +1,6 @@
-extern crate bech32;
-
 use bech32::primitives::decode::{CheckedHrpstring, SegwitHrpstring, UncheckedHrpstring};
 use bech32::Bech32m;
+use honggfuzz::fuzz;
 
 // Checks that we do not crash if passed random data while decoding.
 fn do_test(data: &[u8]) {
@@ -11,19 +10,6 @@ fn do_test(data: &[u8]) {
     let _ = SegwitHrpstring::new(&data_str);
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use]
-extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -39,9 +25,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {

fuzz/fuzz_targets/encode_decode.rs

@@ -1,11 +1,10 @@
-extern crate bech32;
-
 use std::str;
 
 use bech32::{Bech32m, Hrp};
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    if data.len() < 1 {
+    if data.is_empty() {
         return;
     }
 
@@ -17,35 +16,23 @@ fn do_test(data: &[u8]) {
 
     let dp = &data[hrp_end..];
 
-    match str::from_utf8(&data[1..hrp_end]) {
+    let s = match str::from_utf8(&data[1..hrp_end]) {
+        Ok(s) => s,
         Err(_) => return,
-        Ok(s) => {
-            match Hrp::parse(&s) {
-                Err(_) => return,
-                Ok(hrp) => {
-                    if let Ok(address) = bech32::encode::<Bech32m>(hrp, dp) {
-                        let (hrp, data) = bech32::decode(&address).expect("should be able to decode own encoding");
-                        assert_eq!(bech32::encode::<Bech32m>(hrp, &data).unwrap(), address);
-                    }
-                }
-            }
-        }
-    }
-}
+    };
+    let hrp = match Hrp::parse(s) {
+        Ok(hrp) => hrp,
+        Err(_) => return,
+    };
+    let address = match bech32::encode::<Bech32m>(hrp, dp) {
+        Ok(addr) => addr,
+        Err(_) => return,
+    };
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
+    let (hrp, data) = bech32::decode(&address).expect("should be able to decode own encoding");
+    assert_eq!(bech32::encode::<Bech32m>(hrp, &data).unwrap(), address);
 }
 
-#[cfg(feature = "honggfuzz")]
-#[macro_use]
-extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -61,9 +48,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().filter(|&&c| c != b'\n').enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {

fuzz/fuzz_targets/parse_hrp.rs

@@ -1,6 +1,5 @@
-extern crate bech32;
-
 use bech32::Hrp;
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     let s = String::from_utf8_lossy(data);
@@ -10,19 +9,6 @@ fn do_test(data: &[u8]) {
     let _ = Hrp::parse(&s);
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use]
-extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -38,9 +24,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().filter(|&&c| c != b'\n').enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {