fuzz: pull FuzzPk out of miniscript_satisfy target

This should be in a library so it can be used by multiple fuzztests.

Author: apoelstra

fuzz/fuzz_targets/miniscript_satisfy.rs

@@ -1,72 +1,14 @@
 #![allow(unexpected_cfgs)]
 
-use std::fmt;
-use std::str::FromStr;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
+use descriptor_fuzz::FuzzPk;
 use honggfuzz::fuzz;
-use miniscript::bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
+use miniscript::bitcoin::hashes::hash160;
 use miniscript::bitcoin::locktime::{absolute, relative};
 use miniscript::bitcoin::taproot::Signature;
 use miniscript::bitcoin::{secp256k1, PublicKey, TapLeafHash, TapSighashType, XOnlyPublicKey};
-use miniscript::{hash256, Miniscript, MiniscriptKey, Satisfier, Segwitv0, Tap, ToPublicKey};
-
-// FIXME pull this out into a library used by all the fuzztests
-#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Debug, Hash)]
-struct FuzzPk {
-    compressed: bool,
-}
-
-impl FuzzPk {
-    pub fn new_from_control_byte(control: u8) -> Self { Self { compressed: control & 1 == 1 } }
-}
-
-impl FromStr for FuzzPk {
-    type Err = std::num::ParseIntError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let byte = u8::from_str_radix(s, 16)?;
-        Ok(Self::new_from_control_byte(byte))
-    }
-}
-
-impl fmt::Display for FuzzPk {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { "[fuzz pubkey]".fmt(f) }
-}
-
-impl MiniscriptKey for FuzzPk {
-    type Sha256 = u8;
-    type Ripemd160 = u8;
-    type Hash160 = u8;
-    type Hash256 = u8;
-}
-
-impl ToPublicKey for FuzzPk {
-    fn to_public_key(&self) -> PublicKey {
-        let secp_pk = secp256k1::PublicKey::from_slice(&[
-            0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78,
-            0xce, 0x56, 0x3f, 0x89, 0xa0, 0xed, 0x94, 0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96,
-            0xd6, 0x79, 0x5f, 0x9c, 0x63, 0x3f, 0x39, 0x79, 0xbf, 0x72, 0xae, 0x82, 0x02, 0x98,
-            0x3d, 0xc9, 0x89, 0xae, 0xc7, 0xf2, 0xff, 0x2e, 0xd9, 0x1b, 0xdd, 0x69, 0xce, 0x02,
-            0xfc, 0x07, 0x00, 0xca, 0x10, 0x0e, 0x59, 0xdd, 0xf3,
-        ])
-        .unwrap();
-        PublicKey { inner: secp_pk, compressed: self.compressed }
-    }
-
-    fn to_sha256(hash: &Self::Sha256) -> sha256::Hash { sha256::Hash::from_byte_array([*hash; 32]) }
-
-    fn to_hash256(hash: &Self::Hash256) -> hash256::Hash {
-        hash256::Hash::from_byte_array([*hash; 32])
-    }
-
-    fn to_ripemd160(hash: &Self::Ripemd160) -> ripemd160::Hash {
-        ripemd160::Hash::from_byte_array([*hash; 20])
-    }
-
-    fn to_hash160(hash: &Self::Ripemd160) -> hash160::Hash {
-        hash160::Hash::from_byte_array([*hash; 20])
-    }
-}
+use miniscript::{Miniscript, Satisfier, Segwitv0, Tap};
 
 struct FuzzSatisfier<'b> {
     idx: AtomicUsize,
@@ -198,14 +140,14 @@ fn do_test(data: &[u8]) {
 
     let s = String::from_utf8_lossy(s);
     if control & 1 == 1 {
-        let ms = match Miniscript::<FuzzPk, Segwitv0>::from_str(&s) {
+        let ms = match s.parse::<Miniscript<FuzzPk, Segwitv0>>() {
             Ok(d) => d,
             Err(_) => return,
         };
 
         let _ = ms.build_template(&fuzz_sat);
     } else {
-        let ms = match Miniscript::<FuzzPk, Tap>::from_str(&s) {
+        let ms = match s.parse::<Miniscript<FuzzPk, Tap>>() {
             Ok(d) => d,
             Err(_) => return,
         };

fuzz/src/lib.rs

@@ -0,0 +1,71 @@
+// Written in 2019 by Andrew Poelstra <[email protected]>
+// SPDX-License-Identifier: CC0-1.0
+
+//! Miniscript Fuzzing Library
+//!
+//! This contains data structures and utilities used by the fuzz tests.
+
+use core::{fmt, str};
+
+use miniscript::bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
+use miniscript::bitcoin::{secp256k1, PublicKey};
+use miniscript::{hash256, MiniscriptKey, ToPublicKey};
+
+/// A public key which is encoded as a single hex byte (two hex characters).
+///
+/// Implements `ToPublicKey` but (for now) always maps to the same bitcoin public key.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Debug, Hash)]
+pub struct FuzzPk {
+    compressed: bool,
+}
+
+impl FuzzPk {
+    pub fn new_from_control_byte(control: u8) -> Self { Self { compressed: control & 1 == 1 } }
+}
+
+impl str::FromStr for FuzzPk {
+    type Err = std::num::ParseIntError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let byte = u8::from_str_radix(s, 16)?;
+        Ok(Self::new_from_control_byte(byte))
+    }
+}
+
+impl fmt::Display for FuzzPk {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { "[fuzz pubkey]".fmt(f) }
+}
+
+impl MiniscriptKey for FuzzPk {
+    type Sha256 = u8;
+    type Ripemd160 = u8;
+    type Hash160 = u8;
+    type Hash256 = u8;
+}
+
+impl ToPublicKey for FuzzPk {
+    fn to_public_key(&self) -> PublicKey {
+        let secp_pk = secp256k1::PublicKey::from_slice(&[
+            0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78,
+            0xce, 0x56, 0x3f, 0x89, 0xa0, 0xed, 0x94, 0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96,
+            0xd6, 0x79, 0x5f, 0x9c, 0x63, 0x3f, 0x39, 0x79, 0xbf, 0x72, 0xae, 0x82, 0x02, 0x98,
+            0x3d, 0xc9, 0x89, 0xae, 0xc7, 0xf2, 0xff, 0x2e, 0xd9, 0x1b, 0xdd, 0x69, 0xce, 0x02,
+            0xfc, 0x07, 0x00, 0xca, 0x10, 0x0e, 0x59, 0xdd, 0xf3,
+        ])
+        .unwrap();
+        PublicKey { inner: secp_pk, compressed: self.compressed }
+    }
+
+    fn to_sha256(hash: &Self::Sha256) -> sha256::Hash { sha256::Hash::from_byte_array([*hash; 32]) }
+
+    fn to_hash256(hash: &Self::Hash256) -> hash256::Hash {
+        hash256::Hash::from_byte_array([*hash; 32])
+    }
+
+    fn to_ripemd160(hash: &Self::Ripemd160) -> ripemd160::Hash {
+        ripemd160::Hash::from_byte_array([*hash; 20])
+    }
+
+    fn to_hash160(hash: &Self::Ripemd160) -> hash160::Hash {
+        hash160::Hash::from_byte_array([*hash; 20])
+    }
+}