Added fuzz test for satisfy

Author: sanket1729

Cargo.toml

@@ -7,7 +7,6 @@ description = "Miniscript: a subset of Bitcoin Script designed for analysis"
 license = "CC0-1.0"
 
 [features]
-fuzztarget = ["bitcoin/fuzztarget"]
 compiler = []
 trace = []
 unstable = []

examples/parse.rs

@@ -20,7 +20,11 @@ extern crate miniscript;
 use miniscript::NullCtx;
 use std::str::FromStr;
 
+use miniscript::miniscript::satisfy::bitcoinsig_from_rawsig;
+
 fn main() {
+    let v : Vec<u8> = bitcoin::hashes::hex::FromHex::from_hex("30440220510316cbecd5c8057783d1bf15d050e34298fe44547ad3267a1d6dbdf912064c022066ac4137a1a8dc6d5ae1c37329ea022d45a7ac5c4500c325b570e4542d5e19f801").unwrap();
+    let sig = bitcoinsig_from_rawsig(&v).unwrap();
     let my_descriptor = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(
         "wsh(c:pk_k(020202020202020202020202020202020202020202020202020202020202020202))",
     )

fuzz/Cargo.toml

@@ -15,7 +15,7 @@ honggfuzz_fuzz = ["honggfuzz"]
 honggfuzz = { version = "0.5", optional = true }
 afl = { version = "0.8", optional = true }
 regex = { version = "1.4"}
-miniscript = { path = "..", features = ["fuzztarget", "compiler"] }
+miniscript = { path = "..", features = ["compiler"] }
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -52,3 +52,7 @@ path = "fuzz_targets/parse_descriptor.rs"
 [[bin]]
 name = "parse_descriptor_secret"
 path = "fuzz_targets/parse_descriptor_secret.rs"
+
+[[bin]]
+name = "miniscript_satisfy"
+path = "fuzz_targets/miniscript_satisfy.rs"

fuzz/fuzz_targets/miniscript_satisfy.rs

@@ -0,0 +1,121 @@
+extern crate miniscript;
+
+use miniscript::miniscript::satisfy::bitcoinsig_from_rawsig;
+use miniscript::Segwitv0;
+use miniscript::{
+    bitcoin, BitcoinSig, DummyKey, DummyKeyHash, Miniscript, NullCtx, Satisfier, ToPublicKey,
+};
+
+use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
+
+use std::str::FromStr;
+
+struct DummySatisfier {}
+
+impl Satisfier<NullCtx, DummyKey> for DummySatisfier {
+    fn lookup_sig(&self, pk: &DummyKey, _to_pk_ctx: NullCtx) -> Option<BitcoinSig> {
+        let v : Vec<u8> = bitcoin::hashes::hex::FromHex::from_hex("30440220510316cbecd5c8057783d1bf15d050e34298fe44547ad3267a1d6dbdf912064c022066ac4137a1a8dc6d5ae1c37329ea022d45a7ac5c4500c325b570e4542d5e19f801").unwrap();
+        dbg!("here");
+        Some(bitcoinsig_from_rawsig(&v).unwrap())
+    }
+
+    fn lookup_pkh_pk(&self, _: &DummyKeyHash) -> Option<DummyKey> {
+        Some(DummyKey)
+    }
+
+    fn lookup_pkh_sig(
+        &self,
+        _: &DummyKeyHash,
+        _to_pk_ctx: NullCtx,
+    ) -> Option<(bitcoin::PublicKey, BitcoinSig)> {
+        dbg!("here");
+        let dummy = DummyKey;
+        let v : Vec<u8> = bitcoin::hashes::hex::FromHex::from_hex("30440220510316cbecd5c8057783d1bf15d050e34298fe44547ad3267a1d6dbdf912064c022066ac4137a1a8dc6d5ae1c37329ea022d45a7ac5c4500c325b570e4542d5e19f801").unwrap();
+        panic!();
+        Some((
+            dummy.to_public_key(NullCtx),
+            (bitcoinsig_from_rawsig(&v).unwrap()),
+        ))
+    }
+
+    fn lookup_sha256(&self, _: sha256::Hash) -> Option<[u8; 32]> {
+        Some([0u8; 32])
+    }
+
+    fn lookup_hash256(&self, _: sha256d::Hash) -> Option<[u8; 32]> {
+        Some([0u8; 32])
+    }
+
+    fn lookup_ripemd160(&self, _: ripemd160::Hash) -> Option<[u8; 32]> {
+        Some([0u8; 32])
+    }
+
+    fn lookup_hash160(&self, _: hash160::Hash) -> Option<[u8; 32]> {
+        Some([0u8; 32])
+    }
+
+    fn check_older(&self, _: u32) -> bool {
+        true
+    }
+
+    fn check_after(&self, _: u32) -> bool {
+        true
+    }
+}
+
+fn do_test(data: &[u8]) {
+    let data_str = String::from_utf8_lossy(data);
+    if let Ok(ms) = Miniscript::<DummyKey, Segwitv0>::from_str(&data_str) {
+        if let Err(e) = ms.satisfy(DummySatisfier {}, NullCtx) {
+            dbg!(e);
+        }
+    }
+}
+
+#[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| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        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',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash_here() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("706b2829", &mut a);
+        super::do_test(&a);
+    }
+}