Allow toggling specific signing methods in test channel signer

Author: alecchendev

lightning/src/ln/functional_test_utils.rs

@@ -30,7 +30,7 @@ use crate::util::errors::APIError;
 #[cfg(test)]
 use crate::util::logger::Logger;
 use crate::util::scid_utils;
-use crate::util::test_channel_signer::TestChannelSigner;
+use crate::util::test_channel_signer::{TestChannelSigner, ops};
 use crate::util::test_utils;
 use crate::util::test_utils::{panicking, TestChainMonitor, TestScorer, TestKeysInterface};
 use crate::util::ser::{ReadableArgs, Writeable};
@@ -523,6 +523,41 @@ impl<'a, 'b, 'c> Node<'a, 'b, 'c> {
 				.insert(channel_keys_id.unwrap());
 		}
 	}
+
+	/// Changes the channel signer's availability for the specified peer and channel.
+	///
+	/// When `available` is set to `true`, the channel signer will behave normally. When set to
+	/// `false`, the channel signer will act like an off-line remote signer and will return `Err` for
+	/// several of the signing methods. Currently, only `get_per_commitment_point` and
+	/// `release_commitment_secret` are affected by this setting.
+	/// several of the signing methods.
+	#[cfg(test)]
+	pub fn set_channel_signer_ops_available(&self, peer_id: &PublicKey, chan_id: &ChannelId, mask: u32, available: bool) {
+		use crate::sign::ChannelSigner;
+		log_debug!(self.logger, "Setting channel signer for {} as available={}", chan_id, available);
+
+		let per_peer_state = self.node.per_peer_state.read().unwrap();
+		let chan_lock = per_peer_state.get(peer_id).unwrap().lock().unwrap();
+
+		let mut channel_keys_id = None;
+		if let Some(chan) = chan_lock.channel_by_id.get(chan_id).map(|phase| phase.context()) {
+			chan.get_signer().as_ecdsa().unwrap().set_ops_available(mask, available);
+			channel_keys_id = Some(chan.channel_keys_id);
+		}
+
+		let mut monitor = None;
+		for (funding_txo, channel_id) in self.chain_monitor.chain_monitor.list_monitors() {
+			if *chan_id == channel_id {
+				monitor = self.chain_monitor.chain_monitor.get_monitor(funding_txo).ok();
+			}
+		}
+		if let Some(monitor) = monitor {
+			monitor.do_signer_call(|signer| {
+				channel_keys_id = channel_keys_id.or(Some(signer.inner.channel_keys_id()));
+				signer.set_ops_available(mask, available)
+			});
+		}
+	}
 }
 
 /// If we need an unsafe pointer to a `Node` (ie to reference it in a thread

lightning/src/util/test_channel_signer.rs

@@ -76,6 +76,51 @@ pub struct TestChannelSigner {
 	pub available: Arc<Mutex<bool>>,
 }
 
+/// Channel signer operations that can be individually enabled and disabled. If a particular value
+/// is set in the `TestChannelSigner::unavailable` bitmask, then that operation will return an
+/// error.
+pub mod ops {
+	pub const GET_PER_COMMITMENT_POINT: u32                  = 1 << 0;
+	pub const RELEASE_COMMITMENT_SECRET: u32                 = 1 << 1;
+	pub const VALIDATE_HOLDER_COMMITMENT: u32                = 1 << 2;
+	pub const SIGN_COUNTERPARTY_COMMITMENT: u32              = 1 << 3;
+	pub const VALIDATE_COUNTERPARTY_REVOCATION: u32          = 1 << 4;
+	pub const SIGN_HOLDER_COMMITMENT_AND_HTLCS: u32          = 1 << 5;
+	pub const SIGN_JUSTICE_REVOKED_OUTPUT: u32               = 1 << 6;
+	pub const SIGN_JUSTICE_REVOKED_HTLC: u32                 = 1 << 7;
+	pub const SIGN_HOLDER_HTLC_TRANSACTION: u32              = 1 << 8;
+	pub const SIGN_COUNTERPARTY_HTLC_TRANSACTION: u32        = 1 << 9;
+	pub const SIGN_CLOSING_TRANSACTION: u32                  = 1 << 10;
+	pub const SIGN_HOLDER_ANCHOR_INPUT: u32                  = 1 << 11;
+	pub const SIGN_CHANNEL_ANNOUNCMENT_WITH_FUNDING_KEY: u32 = 1 << 12;
+
+	#[cfg(test)]
+	pub fn string_from(mask: u32) -> String {
+		if mask == 0 {
+			return "nothing".to_owned();
+		}
+		if mask == !(0 as u32) {
+			return "everything".to_owned();
+		}
+
+		vec![
+			if (mask & GET_PER_COMMITMENT_POINT) != 0 { Some("get_per_commitment_point") } else { None },
+			if (mask & RELEASE_COMMITMENT_SECRET) != 0 { Some("release_commitment_secret") } else { None },
+			if (mask & VALIDATE_HOLDER_COMMITMENT) != 0 { Some("validate_holder_commitment") } else { None },
+			if (mask & SIGN_COUNTERPARTY_COMMITMENT) != 0 { Some("sign_counterparty_commitment") } else { None },
+			if (mask & VALIDATE_COUNTERPARTY_REVOCATION) != 0 { Some("validate_counterparty_revocation") } else { None },
+			if (mask & SIGN_HOLDER_COMMITMENT_AND_HTLCS) != 0 { Some("sign_holder_commitment_and_htlcs") } else { None },
+			if (mask & SIGN_JUSTICE_REVOKED_OUTPUT) != 0 { Some("sign_justice_revoked_output") } else { None },
+			if (mask & SIGN_JUSTICE_REVOKED_HTLC) != 0 { Some("sign_justice_revoked_htlc") } else { None },
+			if (mask & SIGN_HOLDER_HTLC_TRANSACTION) != 0 { Some("sign_holder_htlc_transaction") } else { None },
+			if (mask & SIGN_COUNTERPARTY_HTLC_TRANSACTION) != 0 { Some("sign_counterparty_htlc_transaction") } else { None },
+			if (mask & SIGN_CLOSING_TRANSACTION) != 0 { Some("sign_closing_transaction") } else { None },
+			if (mask & SIGN_HOLDER_ANCHOR_INPUT) != 0 { Some("sign_holder_anchor_input") } else { None },
+			if (mask & SIGN_CHANNEL_ANNOUNCMENT_WITH_FUNDING_KEY) != 0 { Some("sign_channel_announcment_with_funding_key") } else { None },
+		].iter().flatten().map(|s| s.to_string()).collect::<Vec<_>>().join(", ")
+	}
+}
+
 impl PartialEq for TestChannelSigner {
 	fn eq(&self, o: &Self) -> bool {
 		Arc::ptr_eq(&self.state, &o.state)
@@ -123,6 +168,20 @@ impl TestChannelSigner {
 	pub fn set_available(&self, available: bool) {
 		*self.available.lock().unwrap() = available;
 	}
+
+	#[cfg(test)]
+	pub fn set_ops_available(&self, mask: u32, available: bool) {
+		let mut state = self.get_enforcement_state();
+		if available {
+			state.unavailable_signer_ops &= !mask;  // clear the bits that are now available
+		} else {
+			state.unavailable_signer_ops |= mask;   // set the bits that are now unavailable
+		}
+	}
+
+	fn is_signer_available(&self, ops_mask: u32) -> bool {
+		self.state.lock().unwrap().is_signer_available(ops_mask)
+	}
 }
 
 impl ChannelSigner for TestChannelSigner {
@@ -379,6 +438,10 @@ pub struct EnforcementState {
 	pub last_holder_revoked_commitment: u64,
 	/// The last validated holder commitment number, backwards counting
 	pub last_holder_commitment: u64,
+	/// A flag array that indicates which signing operations are currently *not* available in the
+	/// channel. When a method's bit is set, then the signer will act as if the signature is
+	/// unavailable and return an error result.
+	pub unavailable_signer_ops: u32,
 }
 
 impl EnforcementState {
@@ -389,6 +452,11 @@ impl EnforcementState {
 			last_counterparty_revoked_commitment: INITIAL_REVOKED_COMMITMENT_NUMBER,
 			last_holder_revoked_commitment: INITIAL_REVOKED_COMMITMENT_NUMBER,
 			last_holder_commitment: INITIAL_REVOKED_COMMITMENT_NUMBER,
+			unavailable_signer_ops: 0,
 		}
 	}
+
+	pub fn is_signer_available(&self, ops_mask: u32) -> bool {
+		(self.unavailable_signer_ops & ops_mask) == 0
+	}
 }