X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmonitor.rs;h=f3eed0fe16ac0ed9d7e4a59d67f8e82bf5330e8f;hb=3aeec96470cc681bf6bf50baa5ce1b533762c479;hp=cb2aba780a5862ae48ba87bc77db4f07b837e0eb;hpb=6c07555cad1d8500dca3fd11ab736d4e5c84f8c2;p=rust-lightning diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index cb2aba78..f3eed0fe 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -1,3 +1,14 @@ +//! The logic to monitor for on-chain transactions and create the relevant claim responses lives +//! here. +//! ChannelMonitor objects are generated by ChannelManager in response to relevant +//! messages/actions, and MUST be persisted to disk (and, preferably, remotely) before progress can +//! be made in responding to certain messages, see ManyChannelMonitor for more. +//! Note that ChannelMonitors are an important part of the lightning trust model and a copy of the +//! latest ChannelMonitor must always be actively monitoring for chain updates (and no out-of-date +//! ChannelMonitors should do so). Thus, if you're building rust-lightning into an HSM or other +//! security-domain-separated system design, you should consider having multiple paths for +//! ChannelMonitors to get out of the HSM and onto monitoring devices. + use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::transaction::{TxIn,TxOut,SigHashType,Transaction}; use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint; @@ -24,6 +35,7 @@ use std::collections::HashMap; use std::sync::{Arc,Mutex}; use std::{hash,cmp}; +/// An error enum representing a failure to persist a channel monitor update. pub enum ChannelMonitorUpdateErr { /// Used to indicate a temporary failure (eg connection to a watchtower failed, but is expected /// to succeed at some point in the future). @@ -46,10 +58,11 @@ pub enum ChannelMonitorUpdateErr { /// channel's monitor everywhere (including remote watchtowers) *before* this function returns. If /// an update occurs and a remote watchtower is left with old state, it may broadcast transactions /// which we have revoked, allowing our counterparty to claim all funds in the channel! -/// A call to add_update_monitor is needed to register outpoint and its txid with ChainWatchInterface -/// after setting funding_txo in a ChannelMonitor pub trait ManyChannelMonitor: Send + Sync { /// Adds or updates a monitor for the given `funding_txo`. + /// Implementor must also ensure that the funding_txo outpoint is registered with any relevant + /// ChainWatchInterfaces such that the provided monitor receives block_connected callbacks with + /// any spends of it. fn add_update_monitor(&self, funding_txo: OutPoint, monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr>; } @@ -62,6 +75,9 @@ pub trait ManyChannelMonitor: Send + Sync { /// If you're using this for local monitoring of your own channels, you probably want to use /// `OutPoint` as the key, which will give you a ManyChannelMonitor implementation. pub struct SimpleManyChannelMonitor { + #[cfg(test)] // Used in ChannelManager tests to manipulate channels directly + pub monitors: Mutex>, + #[cfg(not(test))] monitors: Mutex>, chain_monitor: Arc, broadcaster: Arc @@ -84,6 +100,8 @@ impl ChainListener for SimpleManyChannelMonit } impl SimpleManyChannelMonitor { + /// Creates a new object which can be used to monitor several channels given the chain + /// interface with which to register to receive notifications. pub fn new(chain_monitor: Arc, broadcaster: Arc) -> Arc> { let res = Arc::new(SimpleManyChannelMonitor { monitors: Mutex::new(HashMap::new()), @@ -95,6 +113,7 @@ impl SimpleManyChannelMonitor res } + /// Adds or udpates the monitor which monitors the channel referred to by the given key. pub fn add_update_monitor_by_key(&self, key: Key, monitor: ChannelMonitor) -> Result<(), HandleError> { let mut monitors = self.monitors.lock().unwrap(); match monitors.get_mut(&key) { @@ -158,6 +177,10 @@ struct LocalSignedTx { const SERIALIZATION_VERSION: u8 = 1; const MIN_SERIALIZATION_VERSION: u8 = 1; +/// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates +/// on-chain transactions to ensure no loss of funds occurs. +/// You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date +/// information and are actively monitoring the chain. pub struct ChannelMonitor { funding_txo: Option<(OutPoint, Script)>, commitment_transaction_number_obscure_factor: u64, @@ -165,6 +188,7 @@ pub struct ChannelMonitor { key_storage: KeyStorage, delayed_payment_base_key: PublicKey, their_htlc_base_key: Option, + their_delayed_payment_base_key: Option, // first is the idx of the first of the two revocation points their_cur_revocation_points: Option<(u64, PublicKey, Option)>, @@ -206,6 +230,7 @@ impl Clone for ChannelMonitor { key_storage: self.key_storage.clone(), delayed_payment_base_key: self.delayed_payment_base_key.clone(), their_htlc_base_key: self.their_htlc_base_key.clone(), + their_delayed_payment_base_key: self.their_delayed_payment_base_key.clone(), their_cur_revocation_points: self.their_cur_revocation_points.clone(), our_to_self_delay: self.our_to_self_delay, @@ -237,6 +262,7 @@ impl PartialEq for ChannelMonitor { self.key_storage != other.key_storage || self.delayed_payment_base_key != other.delayed_payment_base_key || self.their_htlc_base_key != other.their_htlc_base_key || + self.their_delayed_payment_base_key != other.their_delayed_payment_base_key || self.their_cur_revocation_points != other.their_cur_revocation_points || self.our_to_self_delay != other.our_to_self_delay || self.their_to_self_delay != other.their_to_self_delay || @@ -262,7 +288,7 @@ impl PartialEq for ChannelMonitor { } impl ChannelMonitor { - pub fn new(revocation_base_key: &SecretKey, delayed_payment_base_key: &PublicKey, htlc_base_key: &SecretKey, our_to_self_delay: u16, destination_script: Script) -> ChannelMonitor { + pub(super) fn new(revocation_base_key: &SecretKey, delayed_payment_base_key: &PublicKey, htlc_base_key: &SecretKey, our_to_self_delay: u16, destination_script: Script) -> ChannelMonitor { ChannelMonitor { funding_txo: None, commitment_transaction_number_obscure_factor: 0, @@ -273,6 +299,7 @@ impl ChannelMonitor { }, delayed_payment_base_key: delayed_payment_base_key.clone(), their_htlc_base_key: None, + their_delayed_payment_base_key: None, their_cur_revocation_points: None, our_to_self_delay: our_to_self_delay, @@ -430,6 +457,9 @@ impl ChannelMonitor { self.payment_preimages.insert(payment_hash.clone(), payment_preimage.clone()); } + /// Combines this ChannelMonitor with the information contained in the other ChannelMonitor. + /// After a successful call this ChannelMonitor is up-to-date and is safe to use to monitor the + /// chain for new blocks/transactions. pub fn insert_combine(&mut self, mut other: ChannelMonitor) -> Result<(), HandleError> { if self.funding_txo.is_some() { // We should be able to compare the entire funding_txo, but in fuzztarget its trivially @@ -471,14 +501,16 @@ impl ChannelMonitor { /// optional, without it this monitor cannot be used in an SPV client, but you may wish to /// avoid this (or call unset_funding_info) on a monitor you wish to send to a watchtower as it /// provides slightly better privacy. - /// It's the responsability of the caller to register outpoint and script with passing the former + /// It's the responsibility of the caller to register outpoint and script with passing the former /// value as key to add_update_monitor. pub(super) fn set_funding_info(&mut self, funding_info: (OutPoint, Script)) { self.funding_txo = Some(funding_info); } - pub(super) fn set_their_htlc_base_key(&mut self, their_htlc_base_key: &PublicKey) { + /// We log these base keys at channel opening to being able to rebuild redeemscript in case of leaked revoked commit tx + pub(super) fn set_their_base_keys(&mut self, their_htlc_base_key: &PublicKey, their_delayed_payment_base_key: &PublicKey) { self.their_htlc_base_key = Some(their_htlc_base_key.clone()); + self.their_delayed_payment_base_key = Some(their_delayed_payment_base_key.clone()); } pub(super) fn set_their_to_self_delay(&mut self, their_to_self_delay: u16) { @@ -489,6 +521,7 @@ impl ChannelMonitor { self.funding_txo = None; } + /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. pub fn get_funding_txo(&self) -> Option { match self.funding_txo { Some((outpoint, _)) => Some(outpoint), @@ -530,6 +563,7 @@ impl ChannelMonitor { res.extend_from_slice(&self.delayed_payment_base_key.serialize()); res.extend_from_slice(&self.their_htlc_base_key.as_ref().unwrap().serialize()); + res.extend_from_slice(&self.their_delayed_payment_base_key.as_ref().unwrap().serialize()); match self.their_cur_revocation_points { Some((idx, pubkey, second_option)) => { @@ -704,6 +738,7 @@ impl ChannelMonitor { let delayed_payment_base_key = unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33))); let their_htlc_base_key = Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))); + let their_delayed_payment_base_key = Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))); let their_cur_revocation_points = { let first_idx = byte_utils::slice_to_be48(read_bytes!(6)); @@ -866,6 +901,7 @@ impl ChannelMonitor { key_storage, delayed_payment_base_key, their_htlc_base_key, + their_delayed_payment_base_key, their_cur_revocation_points, our_to_self_delay, @@ -890,7 +926,7 @@ impl ChannelMonitor { //we want to leave out (eg funding_txo, etc). /// Can only fail if idx is < get_min_seen_secret - pub fn get_secret(&self, idx: u64) -> Result<[u8; 32], HandleError> { + pub(super) fn get_secret(&self, idx: u64) -> Result<[u8; 32], HandleError> { for i in 0..self.old_secrets.len() { if (idx & (!((1 << i) - 1))) == self.old_secrets[i].1 { return Ok(ChannelMonitor::derive_secret(self.old_secrets[i].0, i as u8, idx)) @@ -900,7 +936,7 @@ impl ChannelMonitor { Err(HandleError{err: "idx too low", action: None}) } - pub fn get_min_seen_secret(&self) -> u64 { + pub(super) fn get_min_seen_secret(&self) -> u64 { //TODO This can be optimized? let mut min = 1 << 48; for &(_, idx) in self.old_secrets.iter() { @@ -914,8 +950,7 @@ impl ChannelMonitor { /// Attempts to claim a remote commitment transaction's outputs using the revocation key and /// data in remote_claimable_outpoints. Will directly claim any HTLC outputs which expire at a /// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for - /// HTLC-Success/HTLC-Timeout transactions, and claim them using the revocation key (if - /// applicable) as well. + /// HTLC-Success/HTLC-Timeout transactions. fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec, (Sha256dHash, Vec)) { // Most secp and related errors trying to create keys means we have no hope of constructing // a spend transaction...so we return no transactions to broadcast @@ -1195,13 +1230,92 @@ impl ChannelMonitor { txn_to_broadcast.push(spend_tx); } } - } else { - //TODO: For each input check if its in our remote_commitment_txn_on_chain map! } (txn_to_broadcast, (commitment_txid, watch_outputs)) } + /// Attempst to claim a remote HTLC-Success/HTLC-Timeout s outputs using the revocation key + fn check_spend_remote_htlc(&self, tx: &Transaction, commitment_number: u64) -> Option { + let htlc_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers! + + macro_rules! ignore_error { + ( $thing : expr ) => { + match $thing { + Ok(a) => a, + Err(_) => return None + } + }; + } + + let secret = ignore_error!(self.get_secret(commitment_number)); + let per_commitment_key = ignore_error!(SecretKey::from_slice(&self.secp_ctx, &secret)); + let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key); + let revocation_pubkey = match self.key_storage { + KeyStorage::PrivMode { ref revocation_base_key, .. } => { + ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))) + }, + KeyStorage::SigsMode { ref revocation_base_key, .. } => { + ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &revocation_base_key)) + }, + }; + let delayed_key = match self.their_delayed_payment_base_key { + None => return None, + Some(their_delayed_payment_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &their_delayed_payment_base_key)), + }; + let redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.their_to_self_delay.unwrap(), &delayed_key); + let revokeable_p2wsh = redeemscript.to_v0_p2wsh(); + + let mut inputs = Vec::new(); + let mut amount = 0; + + if tx.output[0].script_pubkey == revokeable_p2wsh { //HTLC transactions have one txin, one txout + inputs.push(TxIn { + previous_output: BitcoinOutPoint { + txid: htlc_txid, + vout: 0, + }, + script_sig: Script::new(), + sequence: 0xfffffffd, + witness: Vec::new(), + }); + amount = tx.output[0].value; + } + + if !inputs.is_empty() { + let outputs = vec!(TxOut { + script_pubkey: self.destination_script.clone(), + value: amount, //TODO: - fee + }); + + let mut spend_tx = Transaction { + version: 2, + lock_time: 0, + input: inputs, + output: outputs, + }; + + let sighash_parts = bip143::SighashComponents::new(&spend_tx); + + let sig = match self.key_storage { + KeyStorage::PrivMode { ref revocation_base_key, .. } => { + let sighash = ignore_error!(Message::from_slice(&sighash_parts.sighash_all(&spend_tx.input[0], &redeemscript, amount)[..])); + let revocation_key = ignore_error!(chan_utils::derive_private_revocation_key(&self.secp_ctx, &per_commitment_key, &revocation_base_key)); + self.secp_ctx.sign(&sighash, &revocation_key) + } + KeyStorage::SigsMode { .. } => { + unimplemented!(); + } + }; + spend_tx.input[0].witness.push(sig.serialize_der(&self.secp_ctx).to_vec()); + spend_tx.input[0].witness[0].push(SigHashType::All as u8); + spend_tx.input[0].witness.push(vec!(1)); + spend_tx.input[0].witness.push(redeemscript.into_bytes()); + + Some(spend_tx) + } else { None } + } + fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx) -> Vec { let mut res = Vec::with_capacity(local_tx.htlc_outputs.len()); @@ -1263,19 +1377,33 @@ impl ChannelMonitor { fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface)-> Vec<(Sha256dHash, Vec)> { let mut watch_outputs = Vec::new(); for tx in txn_matched { - for txin in tx.input.iter() { - if self.funding_txo.is_none() || (txin.previous_output.txid == self.funding_txo.as_ref().unwrap().0.txid && txin.previous_output.vout == self.funding_txo.as_ref().unwrap().0.index as u32) { - let (mut txn, new_outputs) = self.check_spend_remote_transaction(tx, height); + if tx.input.len() == 1 { + // Assuming our keys were not leaked (in which case we're screwed no matter what), + // commitment transactions and HTLC transactions will all only ever have one input, + // which is an easy way to filter out any potential non-matching txn for lazy + // filters. + let prevout = &tx.input[0].previous_output; + let mut txn: Vec = Vec::new(); + if self.funding_txo.is_none() || (prevout.txid == self.funding_txo.as_ref().unwrap().0.txid && prevout.vout == self.funding_txo.as_ref().unwrap().0.index as u32) { + let (remote_txn, new_outputs) = self.check_spend_remote_transaction(tx, height); + txn = remote_txn; if !new_outputs.1.is_empty() { watch_outputs.push(new_outputs); } if txn.is_empty() { txn = self.check_spend_local_transaction(tx, height); } - for tx in txn.iter() { - broadcaster.broadcast_transaction(tx); + } else { + let remote_commitment_txn_on_chain = self.remote_commitment_txn_on_chain.lock().unwrap(); + if let Some(commitment_number) = remote_commitment_txn_on_chain.get(&prevout.txid) { + if let Some(tx) = self.check_spend_remote_htlc(tx, *commitment_number) { + txn.push(tx); + } } } + for tx in txn.iter() { + broadcaster.broadcast_transaction(tx); + } } } if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx { @@ -1298,7 +1426,7 @@ impl ChannelMonitor { watch_outputs } - pub fn would_broadcast_at_height(&self, height: u32) -> bool { + pub(super) fn would_broadcast_at_height(&self, height: u32) -> bool { if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx { for &(ref htlc, _, _) in cur_local_tx.htlc_outputs.iter() { if htlc.cltv_expiry <= height + CLTV_CLAIM_BUFFER {