Merge pull request #465 from sanket1729/psbt_updates

Added hash Preimages to psbt

.gitignore

@@ -8,3 +8,6 @@ fuzz/hfuzz_workspace
 #IntelliJ project files
 .idea
 *.iml
+
+#Vscode project files
+.vscode

src/util/psbt/error.rs

@@ -18,6 +18,17 @@ use std::fmt;
 use blockdata::transaction::Transaction;
 use util::psbt::raw;
 
+use hashes::{self, sha256, hash160, sha256d, ripemd160};
+use hash_types::Txid;
+
+/// Support hash-preimages in psbt
+#[derive(Debug)]
+pub enum PsbtHash{
+    Ripemd160(ripemd160::Hash),
+    Sha256(sha256::Hash),
+    Hash256(sha256d::Hash),
+    Hash160(hash160::Hash),
+}
 /// Ways that a Partially Signed Transaction might fail.
 #[derive(Debug)]
 pub enum Error {
@@ -48,6 +59,37 @@ pub enum Error {
     },
     /// Unable to parse as a standard SigHash type.
     NonStandardSigHashType(u32),
+    /// Parsing errors from bitcoin_hashes
+    HashParseError(hashes::Error),
+    /// The pre-image must hash to the correponding psbt hash
+    InvalidPreimageHashPair{
+        /// Pre-image
+        preimage: Vec<u8>,
+        /// Hash value
+        hash: PsbtHash,
+    },
+    /// If NonWitnessUtxo is used, the nonWitnessUtxo txid must
+    /// be the same of prevout txid
+    InvalidNonWitnessUtxo{
+        /// Pre-image
+        prevout_txid: Txid,
+        /// Hash value
+        non_witness_utxo_txid: Txid,
+    },
+    /// Incorrect P2sh/p2wsh script hash for the witness/redeem
+    /// script
+    InvalidWitnessScript{
+        /// Expected Witness/Redeem Script Hash
+        // returns a vec to unify the p2wsh(sha2) and p2sh(hash160)
+        expected: Vec<u8>,
+        /// Actual Witness script Hash
+        actual: Vec<u8>,
+    },
+    /// Currently only p2wpkh and p2wsh scripts are possible in segwit
+    UnrecognizedWitnessProgram,
+    /// The psbt input must either have an associated nonWitnessUtxo or
+    /// a WitnessUtxo
+    MustHaveSpendingUtxo,
 }
 
 impl fmt::Display for Error {
@@ -65,6 +107,23 @@ impl fmt::Display for Error {
                 f.write_str("partially signed transactions must have an unsigned transaction")
             }
             Error::NoMorePairs => f.write_str("no more key-value pairs for this psbt map"),
+            Error::HashParseError(e) => write!(f, "Hash Parse Error: {}", e),
+            Error::InvalidPreimageHashPair{ref preimage, ref hash} => {
+                // directly using debug forms of psbthash enums
+                write!(f, "Preimage {:?} does not match hash {:?}", preimage, hash )
+            },
+            Error::InvalidNonWitnessUtxo{ref prevout_txid, ref non_witness_utxo_txid} => {
+                write!(f, "NonWitnessUtxo txid {} must be the same as prevout txid {}", non_witness_utxo_txid, prevout_txid)
+            },
+            Error::InvalidWitnessScript{ref expected, ref actual} => {
+                write!(f, "Invalid Witness/Redeem script: Expected {:?}, got {:?}", expected, actual)
+            }
+            Error::UnrecognizedWitnessProgram => {
+                f.write_str("Witness program must be p2wpkh/p2wsh")
+            }
+            Error::MustHaveSpendingUtxo => {
+                f.write_str("Input must either WitnessUtxo/ NonWitnessUtxo")
+            }
         }
     }
 }
@@ -75,3 +134,10 @@ impl error::Error for Error {
         "description() is deprecated; use Display"
     }
 }
+
+#[doc(hidden)]
+impl From<hashes::Error> for Error {
+    fn from(e: hashes::Error) -> Error {
+        Error::HashParseError(e)
+    }
+}

src/util/psbt/macros.rs

@@ -130,6 +130,30 @@ macro_rules! impl_psbt_insert_pair {
     };
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
+macro_rules! impl_psbt_insert_hash_pair {
+    ($slf:ident.$keyed_name:ident <= <$raw_key:ident: $keyed_key_type:ty>|<$raw_value:ident: $keyed_value_type:ty>; $err_name: ident ) => {
+        if !$raw_key.key.is_empty() {
+            let key_val: $keyed_key_type = $crate::util::psbt::serialize::Deserialize::deserialize(&$raw_key.key)?;
+            match $slf.$keyed_name.entry(key_val) {
+                ::std::collections::btree_map::Entry::Vacant(empty_key) => {
+                    let val: $keyed_value_type = $crate::util::psbt::serialize::Deserialize::deserialize(&$raw_value)?;
+                    if <$keyed_key_type>::hash(&val) != key_val{
+                        return Err($crate::util::psbt::Error::InvalidPreimageHashPair{
+                            preimage: val,
+                            hash: $crate::util::psbt::error::PsbtHash::$err_name(key_val),
+                        }.into());
+                    }
+                    empty_key.insert(val);
+                }
+                ::std::collections::btree_map::Entry::Occupied(_) => return Err($crate::util::psbt::Error::DuplicateKey($raw_key).into()),
+            }
+        } else {
+            return Err($crate::util::psbt::Error::InvalidKey($raw_key).into());
+        }
+    };
+}
+
 #[cfg_attr(rustfmt, rustfmt_skip)]
 macro_rules! impl_psbt_get_pair {
     ($rv:ident.push($slf:ident.$unkeyed_name:ident as <$unkeyed_typeval:expr, _>|<$unkeyed_value_type:ty>)) => {
@@ -155,3 +179,33 @@ macro_rules! impl_psbt_get_pair {
         }
     };
 }
+
+// macros for serde of hashes
+macro_rules! impl_psbt_hash_de_serialize {
+    ($thing:ty) => {
+        impl_psbt_hash_serialize!($thing);
+        impl_psbt_hash_deserialize!($thing);
+    };
+}
+
+macro_rules! impl_psbt_hash_deserialize {
+    ($thing:ty) => {
+        impl $crate::util::psbt::serialize::Deserialize for $thing {
+            fn deserialize(bytes: &[u8]) -> Result<Self, $crate::consensus::encode::Error> {
+                <$thing>::from_slice(&bytes[..]).map_err(|e| {
+                    $crate::util::psbt::Error::from(e).into()
+                })
+            }
+        }
+    };
+}
+
+macro_rules! impl_psbt_hash_serialize {
+    ($thing:ty) => {
+        impl $crate::util::psbt::serialize::Serialize for $thing {
+            fn serialize(&self) -> Vec<u8> {
+                self.into_inner().to_vec()
+            }
+        }
+    };
+}

src/util/psbt/map/input.rs

@@ -17,13 +17,13 @@ use std::collections::BTreeMap;
 use blockdata::script::Script;
 use blockdata::transaction::{SigHashType, Transaction, TxOut};
 use consensus::encode;
+use hashes::{Hash, hash160, ripemd160, sha256, sha256d};
 use util::bip32::{DerivationPath, Fingerprint};
 use util::key::PublicKey;
 use util::psbt;
 use util::psbt::map::Map;
 use util::psbt::raw;
 use util::psbt::Error;
-
 /// A key-value map for an input of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq)]
@@ -55,6 +55,15 @@ pub struct Input {
     /// The finalized, fully-constructed scriptWitness with signatures and any
     /// other scripts necessary for this input to pass validation.
     pub final_script_witness: Option<Vec<Vec<u8>>>,
+    /// TODO: Proof of reserves commitment
+    /// RIPEMD hash to preimage map
+    pub ripemd_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
+    /// SHA256 hash to preimage map
+    pub sha256_preimages: BTreeMap<sha256::Hash, Vec<u8>>,
+    /// HSAH160 hash to preimage map
+    pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
+    /// HAS256 hash to preimage map
+    pub hash256_preimages: BTreeMap<sha256d::Hash, Vec<u8>>,
     /// Unknown key-value pairs for this input.
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
@@ -112,11 +121,35 @@ impl Map for Input {
                     self.hd_keypaths <= <raw_key: PublicKey>|<raw_value: (Fingerprint, DerivationPath)>
                 }
             }
-            _ => match self.unknown.entry(raw_key) {
+            10u8 => {
-                ::std::collections::btree_map::Entry::Vacant(empty_key) => {empty_key.insert(raw_value);},
+                impl_psbt_insert_hash_pair! {
-                ::std::collections::btree_map::Entry::Occupied(k) => return Err(Error::DuplicateKey(k.key().clone()).into()),
+                    self.ripemd_preimages <= <raw_key: ripemd160::Hash>|<raw_value: Vec<u8>>; Ripemd160
                 }
             }
+            11u8 => {
+                impl_psbt_insert_hash_pair! {
+                    self.sha256_preimages <= <raw_key: sha256::Hash>|<raw_value: Vec<u8>>; Sha256
+                }
+            }
+            12u8 => {
+                impl_psbt_insert_hash_pair! {
+                    self.hash160_preimages <= <raw_key: hash160::Hash>|<raw_value: Vec<u8>>; Hash160
+                }
+            }
+            13u8 => {
+                impl_psbt_insert_hash_pair! {
+                    self.hash256_preimages <= <raw_key: sha256d::Hash>|<raw_value: Vec<u8>>; Hash256
+                }
+            }
+            _ => match self.unknown.entry(raw_key) {
+                ::std::collections::btree_map::Entry::Vacant(empty_key) => {
+                    empty_key.insert(raw_value);
+                }
+                ::std::collections::btree_map::Entry::Occupied(k) => {
+                    return Err(Error::DuplicateKey(k.key().clone()).into())
+                }
+            },
+        }
 
         Ok(())
     }
@@ -160,6 +193,22 @@ impl Map for Input {
             rv.push(self.final_script_witness as <8u8, _>|<Script>)
         }
 
+        impl_psbt_get_pair! {
+            rv.push(self.ripemd_preimages as <10u8, ripemd160::Hash>|<Vec<u8>>)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.sha256_preimages as <11u8, sha256::Hash>|<Vec<u8>>)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.hash160_preimages as <12u8, hash160::Hash>|<Vec<u8>>)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.hash256_preimages as <13u8, sha256d::Hash>|<Vec<u8>>)
+        }
+
         for (key, value) in self.unknown.iter() {
             rv.push(raw::Pair {
                 key: key.clone(),
@@ -180,6 +229,10 @@ impl Map for Input {
 
         self.partial_sigs.extend(other.partial_sigs);
         self.hd_keypaths.extend(other.hd_keypaths);
+        self.ripemd_preimages.extend(other.ripemd_preimages);
+        self.sha256_preimages.extend(other.sha256_preimages);
+        self.hash160_preimages.extend(other.hash160_preimages);
+        self.hash256_preimages.extend(other.hash256_preimages);
         self.unknown.extend(other.unknown);
 
         merge!(redeem_script, self, other);

src/util/psbt/mod.rs

@@ -18,9 +18,12 @@
 //! defined at https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
 //! except we define PSBTs containing non-standard SigHash types as invalid.
 
-use blockdata::script::Script;
+use blockdata::transaction::{SigHashType, Transaction};
-use blockdata::transaction::Transaction;
+use hash_types::SigHash;
 use consensus::{encode, Encodable, Decodable};
+use util::bip143::SigHashCache;
+use blockdata::script::{Builder, Script};
+use blockdata::opcodes;
 
 use std::io;
 
@@ -88,6 +91,83 @@ impl PartiallySignedTransaction {
 
         Ok(())
     }
+
+    /// Calculate the Sighash for the Psbt Input at idx depending on whether input spends
+    /// spends a segwit or not
+    /// #Panics:
+    /// Panics if the index >= number of inputs in psbt
+    pub fn signature_hash(&self, idx: usize) -> Result<SigHash, self::Error> {
+        let inp = &self.inputs[idx];
+        let sighash_type = inp.sighash_type.unwrap_or_else(|| SigHashType::All);
+        // Compute Script code for the Script. When this script is used as scriptPubkey,
+        // the Script Code determines what goes into sighash.
+        // For non-p2sh non-segwit outputs and non-p2sh wrapped segwit-outputs
+        // script code is the public key.
+        let sighash = if let Some(ref non_witness_utxo) = inp.non_witness_utxo {
+            let spent_outpoint = self.global.unsigned_tx.input[idx].previous_output;
+            if spent_outpoint.txid != non_witness_utxo.txid() {
+                return Err(Error::InvalidNonWitnessUtxo {
+                    prevout_txid: spent_outpoint.txid,
+                    non_witness_utxo_txid: non_witness_utxo.txid()
+                });
+            }
+            let script_pubkey =  &non_witness_utxo.output[spent_outpoint.vout as usize].script_pubkey;
+            if let Some(ref redeem_script) = inp.redeem_script {
+                if redeem_script.to_p2sh() != *script_pubkey {
+                    return Err(Error::InvalidWitnessScript{
+                        expected: script_pubkey.to_bytes(),
+                        actual: redeem_script.to_p2sh().into_bytes(),
+                    });
+                }
+                self.global.unsigned_tx.signature_hash(
+                    idx, &redeem_script, sighash_type.as_u32()
+                )
+            } else {
+                self.global.unsigned_tx.signature_hash(
+                    idx, &script_pubkey, sighash_type.as_u32()
+                )
+            }
+        } else if let Some(ref witness_utxo) = inp.witness_utxo {
+            let script_pubkey = if let Some(ref redeem_script) = inp.redeem_script {
+                if redeem_script.to_p2sh() != witness_utxo.script_pubkey {
+                    return Err(Error::InvalidWitnessScript{
+                        expected: witness_utxo.script_pubkey.to_bytes(),
+                        actual: redeem_script.to_p2sh().into_bytes(),
+                    });
+                }
+                redeem_script
+            } else {
+                &witness_utxo.script_pubkey
+            };
+
+            let amt = witness_utxo.value;
+            let mut sighash_cache = SigHashCache::new(&self.global.unsigned_tx);
+            if let Some(ref witness_script) = inp.witness_script {
+                if witness_script.to_v0_p2wsh() != *script_pubkey {
+                    return Err(Error::InvalidWitnessScript{
+                        expected: script_pubkey.clone().into_bytes(),
+                        actual: witness_script.to_p2sh().into_bytes(),
+                    });
+                }
+                sighash_cache.signature_hash(idx, &witness_script, amt, sighash_type)
+            } else if script_pubkey.is_v0_p2wpkh() {
+                // Indirect way to get script code
+                let builder = Builder::new();
+                let script_code = builder
+                .push_opcode(opcodes::all::OP_DUP)
+                .push_opcode(opcodes::all::OP_HASH160)
+                .push_slice(&script_pubkey[2..22])
+                .push_opcode(opcodes::all::OP_EQUALVERIFY)
+                .into_script();
+                sighash_cache.signature_hash(idx, &script_code, amt, sighash_type)
+            } else {
+                return Err(Error::UnrecognizedWitnessProgram);
+            }
+        } else {
+            return Err(Error::MustHaveSpendingUtxo);
+        };
+        Ok(sighash)
+    }
 }
 
 impl Encodable for PartiallySignedTransaction {
@@ -163,6 +243,7 @@ impl Decodable for PartiallySignedTransaction {
 #[cfg(test)]
 mod tests {
     use hashes::hex::FromHex;
+    use hashes::{sha256, hash160, Hash, ripemd160};
     use hash_types::Txid;
 
     use std::collections::BTreeMap;
@@ -175,7 +256,7 @@ mod tests {
     use consensus::encode::{deserialize, serialize, serialize_hex};
     use util::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey, Fingerprint};
     use util::key::PublicKey;
-    use util::psbt::map::{Global, Output};
+    use util::psbt::map::{Global, Output, Input};
     use util::psbt::raw;
 
     use super::PartiallySignedTransaction;
@@ -561,4 +642,116 @@ mod tests {
             assert_eq!(psbt.inputs[0].unknown, unknown)
         }
     }
+
+    #[test]
+    fn serialize_and_deserialize_preimage_psbt(){
+        // create a sha preimage map
+        let mut sha256_preimages = BTreeMap::new();
+        sha256_preimages.insert(sha256::Hash::hash(&[1u8, 2u8]), vec![1u8, 2u8]);
+        sha256_preimages.insert(sha256::Hash::hash(&[1u8]), vec![1u8]);
+
+        // same for hash160
+        let mut hash160_preimages = BTreeMap::new();
+        hash160_preimages.insert(hash160::Hash::hash(&[1u8, 2u8]), vec![1u8, 2u8]);
+        hash160_preimages.insert(hash160::Hash::hash(&[1u8]), vec![1u8]);
+
+        // same vector as valid_vector_1 from BIPs with added
+        let mut unserialized = PartiallySignedTransaction {
+            global: Global {
+                unsigned_tx: Transaction {
+                    version: 2,
+                    lock_time: 1257139,
+                    input: vec![TxIn {
+                        previous_output: OutPoint {
+                            txid: Txid::from_hex(
+                                "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126",
+                            ).unwrap(),
+                            vout: 0,
+                        },
+                        script_sig: Script::new(),
+                        sequence: 4294967294,
+                        witness: vec![],
+                    }],
+                    output: vec![
+                        TxOut {
+                            value: 99999699,
+                            script_pubkey: hex_script!("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac"),
+                        },
+                        TxOut {
+                            value: 100000000,
+                            script_pubkey: hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787"),
+                        },
+                    ],
+                },
+                unknown: BTreeMap::new(),
+            },
+            inputs: vec![Input {
+                non_witness_utxo: Some(Transaction {
+                    version: 1,
+                    lock_time: 0,
+                    input: vec![TxIn {
+                        previous_output: OutPoint {
+                            txid: Txid::from_hex(
+                                "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389",
+                            ).unwrap(),
+                            vout: 1,
+                        },
+                        script_sig: hex_script!("160014be18d152a9b012039daf3da7de4f53349eecb985"),
+                        sequence: 4294967295,
+                        witness: vec![
+                            Vec::from_hex("304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c01").unwrap(),
+                            Vec::from_hex("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105").unwrap(),
+                        ],
+                    },
+                    TxIn {
+                        previous_output: OutPoint {
+                            txid: Txid::from_hex(
+                                "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886",
+                            ).unwrap(),
+                            vout: 1,
+                        },
+                        script_sig: hex_script!("160014fe3e9ef1a745e974d902c4355943abcb34bd5353"),
+                        sequence: 4294967295,
+                        witness: vec![
+                            Vec::from_hex("3045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01").unwrap(),
+                            Vec::from_hex("0223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab3").unwrap(),
+                        ],
+                    }],
+                    output: vec![
+                        TxOut {
+                            value: 200000000,
+                            script_pubkey: hex_script!("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac"),
+                        },
+                        TxOut {
+                            value: 190303501938,
+                            script_pubkey: hex_script!("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587"),
+                        },
+                    ],
+                }),
+                ..Default::default()
+            },],
+            outputs: vec![
+                Output {
+                    ..Default::default()
+                },
+                Output {
+                    ..Default::default()
+                },
+            ],
+        };
+        unserialized.inputs[0].hash160_preimages = hash160_preimages;
+        unserialized.inputs[0].sha256_preimages = sha256_preimages;
+
+        let rtt : PartiallySignedTransaction = hex_psbt!(&serialize_hex(&unserialized)).unwrap();
+        assert_eq!(rtt, unserialized);
+
+        // Now add an ripemd160 with incorrect preimage
+        let mut ripemd160_preimages = BTreeMap::new();
+        ripemd160_preimages.insert(ripemd160::Hash::hash(&[17u8]), vec![18u8]);
+        unserialized.inputs[0].ripemd_preimages = ripemd160_preimages;
+
+        // Now the roundtrip should fail as the preimage is incorrect.
+        let rtt : Result<PartiallySignedTransaction, _> = hex_psbt!(&serialize_hex(&unserialized));
+        assert!(rtt.is_err());
+    }
 }

src/util/psbt/serialize.rs

@@ -22,6 +22,7 @@ use std::io;
 use blockdata::script::Script;
 use blockdata::transaction::{SigHashType, Transaction, TxOut};
 use consensus::encode::{self, serialize, Decodable};
+use hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 use util::bip32::{ChildNumber, DerivationPath, Fingerprint};
 use util::key::PublicKey;
 use util::psbt;
@@ -42,6 +43,10 @@ pub trait Deserialize: Sized {
 impl_psbt_de_serialize!(Transaction);
 impl_psbt_de_serialize!(TxOut);
 impl_psbt_de_serialize!(Vec<Vec<u8>>); // scriptWitness
+impl_psbt_hash_de_serialize!(ripemd160::Hash);
+impl_psbt_hash_de_serialize!(sha256::Hash);
+impl_psbt_hash_de_serialize!(hash160::Hash);
+impl_psbt_hash_de_serialize!(sha256d::Hash);
 
 impl Serialize for Script {
     fn serialize(&self) -> Vec<u8> {