Add parse/parse_insane for schnorr keys

Author: sanket1729

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -8,7 +8,7 @@ fn do_test(data: &[u8]) {
     // Try round-tripping as a script
     let script = script::Script::from(data.to_owned());
 
-    if let Ok(pt) = Miniscript::<_, Segwitv0>::parse(&script) {
+    if let Ok(pt) = Miniscript::<miniscript::bitcoin::PublicKey, Segwitv0>::parse(&script) {
         let output = pt.encode();
         assert_eq!(pt.script_size(), output.len());
         assert_eq!(output, script);

src/interpreter/inner.rs

@@ -50,7 +50,8 @@ fn script_from_stackelem<'a>(
 ) -> Result<Miniscript<bitcoin::PublicKey, NoChecks>, Error> {
     match *elem {
         stack::Element::Push(sl) => {
-            Miniscript::parse_insane(&bitcoin::Script::from(sl.to_owned())).map_err(Error::from)
+            Miniscript::<bitcoin::PublicKey, _>::parse_insane(&bitcoin::Script::from(sl.to_owned()))
+                .map_err(Error::from)
         }
         stack::Element::Satisfied => Miniscript::from_ast(::Terminal::True).map_err(Error::from),
         stack::Element::Dissatisfied => {
@@ -270,7 +271,7 @@ pub fn from_txdata<'txin>(
     // ** bare script **
     } else {
         if wit_stack.is_empty() {
-            let miniscript = Miniscript::parse_insane(spk)?;
+            let miniscript = Miniscript::<bitcoin::PublicKey, _>::parse_insane(spk)?;
             Ok((
                 Inner::Script(miniscript, ScriptType::Bare),
                 ssig_stack,

src/lib.rs

@@ -124,7 +124,7 @@ use bitcoin::hashes::{hash160, sha256, Hash};
 
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
-pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0};
+pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use miniscript::decode::Terminal;
 pub use miniscript::satisfy::{BitcoinSig, Preimage32, Satisfier};
 pub use miniscript::Miniscript;

src/miniscript/mod.rs

@@ -30,7 +30,7 @@ use std::{fmt, str};
 use bitcoin;
 use bitcoin::blockdata::script;
 
-pub use self::context::{BareCtx, Legacy, Segwitv0};
+pub use self::context::{BareCtx, Legacy, Segwitv0, Tap};
 
 pub mod analyzable;
 pub mod astelem;
@@ -175,6 +175,46 @@ impl<Ctx: ScriptContext> Miniscript<bitcoin::PublicKey, Ctx> {
     }
 }
 
+impl<Ctx: ScriptContext> Miniscript<bitcoin::schnorr::PublicKey, Ctx> {
+    /// Attempt to parse an insane(scripts don't clear sanity checks)
+    /// script into a Miniscript representation.
+    /// Use this to parse scripts with repeated pubkeys, timelock mixing, malleable
+    /// scripts without sig or scripts that can exceed resource limits.
+    /// Some of the analysis guarantees of miniscript are lost when dealing with
+    /// insane scripts. In general, in a multi-party setting users should only
+    /// accept sane scripts.
+    pub fn parse_insane(
+        script: &script::Script,
+    ) -> Result<Miniscript<bitcoin::schnorr::PublicKey, Ctx>, Error> {
+        let tokens = lex(script)?;
+        let mut iter = TokenIter::new(tokens);
+
+        let top = decode::parse_tapscript(&mut iter)?;
+        Ctx::check_global_validity(&top)?;
+        let type_check = types::Type::type_check(&top.node, |_| None)?;
+        if type_check.corr.base != types::Base::B {
+            return Err(Error::NonTopLevel(format!("{:?}", top)));
+        };
+        if let Some(leading) = iter.next() {
+            Err(Error::Trailing(leading.to_string()))
+        } else {
+            Ok(top)
+        }
+    }
+
+    /// Attempt to parse a Script into Miniscript representation.
+    /// This function will fail parsing for scripts that do not clear
+    /// the [Miniscript::sanity_check] checks. Use [Miniscript::parse_insane] to
+    /// parse such scripts.
+    pub fn parse(
+        script: &script::Script,
+    ) -> Result<Miniscript<bitcoin::schnorr::PublicKey, Ctx>, Error> {
+        let ms = Self::parse_insane(script)?;
+        ms.sanity_check()?;
+        Ok(ms)
+    }
+}
+
 impl<Pk, Ctx> Miniscript<Pk, Ctx>
 where
     Pk: MiniscriptKey,
@@ -417,8 +457,8 @@ serde_string_impl_pk!(Miniscript, "a miniscript", Ctx; ScriptContext);
 
 #[cfg(test)]
 mod tests {
-    use super::Segwitv0;
     use super::{Miniscript, ScriptContext};
+    use super::{Segwitv0, Tap};
     use hex_script;
     use miniscript::types::{self, ExtData, Property, Type};
     use miniscript::Terminal;
@@ -433,6 +473,7 @@ mod tests {
     use std::sync::Arc;
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
+    type Tapscript = Miniscript<bitcoin::schnorr::PublicKey, Tap>;
 
     fn pubkeys(n: usize) -> Vec<bitcoin::PublicKey> {
         let mut ret = Vec::with_capacity(n);
@@ -669,19 +710,19 @@ mod tests {
     fn verify_parse() {
         let ms = "and_v(v:hash160(20195b5a3d650c17f0f29f91c33f8f6335193d07),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:ripemd160(20195b5a3d650c17f0f29f91c33f8f6335193d07),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:hash256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
     }
 
     #[test]
@@ -907,4 +948,65 @@ mod tests {
             .to_string()
             .contains("unprintable character"));
     }
+
+    #[test]
+    fn test_tapscript_rtt() {
+        // Test x-only invalid under segwitc0 context
+        let ms = Segwitv0Script::from_str_insane(&format!(
+            "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ));
+        assert_eq!(
+            ms.unwrap_err().to_string(),
+            "unexpected «Key secp256k1 error: secp: malformed public key»"
+        );
+        Tapscript::from_str_insane(&format!(
+            "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+
+        // Now test that bitcoin::PublicKey works with Taproot context
+        Miniscript::<bitcoin::PublicKey, Tap>::from_str_insane(&format!(
+            "pk(022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+
+        // uncompressed keys should not be allowed
+        Miniscript::<bitcoin::PublicKey, Tap>::from_str_insane(&format!(
+            "pk(04eed24a081bf1b1e49e3300df4bebe04208ac7e516b6f3ea8eb6e094584267c13483f89dcf194132e12238cc5a34b6b286fc7990d68ed1db86b69ebd826c63b29)"
+        ))
+        .unwrap_err();
+
+        //---------------- test script <-> miniscript ---------------
+        // Test parsing from scripts: x-only fails decoding in segwitv0 ctx
+        Segwitv0Script::parse_insane(&hex_script(
+            "202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap_err();
+        // x-only succeeds in tap ctx
+        Tapscript::parse_insane(&hex_script(
+            "202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap();
+        // tapscript fails decoding with compressed
+        Tapscript::parse_insane(&hex_script(
+            "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap_err();
+        // Segwitv0 succeeds decoding with tapscript.
+        Segwitv0Script::parse_insane(&hex_script(
+            "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap();
+
+        // multi not allowed in tapscript
+        Tapscript::from_str_insane(&format!(
+            "multi(1,2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap_err();
+        // but allowed in segwit
+        Segwitv0Script::from_str_insane(&format!(
+            "multi(1,022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+    }
 }