fixup: Enable ChainMonitor to distribute PeerStorage

Author: adi2011

lightning-background-processor/src/lib.rs

@@ -36,6 +36,7 @@ use lightning::onion_message::messenger::AOnionMessenger;
 use lightning::routing::gossip::{NetworkGraph, P2PGossipSync};
 use lightning::routing::scoring::{ScoreUpdate, WriteableScore};
 use lightning::routing::utxo::UtxoLookup;
+use lightning::sign::EntropySource;
 use lightning::util::logger::Logger;
 use lightning::util::persist::Persister;
 #[cfg(feature = "std")]
@@ -911,8 +912,11 @@ impl BackgroundProcessor {
 		P: 'static + Deref + Send + Sync,
 		EH: 'static + EventHandler + Send,
 		PS: 'static + Deref + Send,
+		ES: 'static + Deref + Send,
 		M: 'static
-			+ Deref<Target = ChainMonitor<<CM::Target as AChannelManager>::Signer, CF, T, F, L, P>>
+			+ Deref<
+				Target = ChainMonitor<<CM::Target as AChannelManager>::Signer, CF, T, F, L, P, ES>,
+			>
 			+ Send
 			+ Sync,
 		CM: 'static + Deref + Send + Sync,
@@ -935,6 +939,7 @@ impl BackgroundProcessor {
 		L::Target: 'static + Logger,
 		P::Target: 'static + Persist<<CM::Target as AChannelManager>::Signer>,
 		PS::Target: 'static + Persister<'a, CM, L, S>,
+		ES::Target: 'static + EntropySource,
 		CM::Target: AChannelManager + Send + Sync,
 		OM::Target: AOnionMessenger + Send + Sync,
 		PM::Target: APeerManager + Send + Sync,
@@ -1160,6 +1165,7 @@ mod tests {
 		Arc<test_utils::TestFeeEstimator>,
 		Arc<test_utils::TestLogger>,
 		Arc<FilesystemStore>,
+		Arc<KeysManager>,
 	>;
 
 	type PGS = Arc<
@@ -1569,6 +1575,7 @@ mod tests {
 				logger.clone(),
 				fee_estimator.clone(),
 				kv_store.clone(),
+				keys_manager.clone(),
 				keys_manager.get_peer_storage_key(),
 			));
 			let best_block = BestBlock::from_network(network);

lightning-liquidity/tests/common/mod.rs

@@ -101,6 +101,7 @@ type ChainMonitor = chainmonitor::ChainMonitor<
 	Arc<test_utils::TestFeeEstimator>,
 	Arc<test_utils::TestLogger>,
 	Arc<FilesystemStore>,
+	Arc<KeysManager>,
 >;
 
 type PGS = Arc<
@@ -431,6 +432,7 @@ pub(crate) fn create_liquidity_node(
 		logger.clone(),
 		fee_estimator.clone(),
 		kv_store.clone(),
+		keys_manager.clone(),
 		keys_manager.get_peer_storage_key(),
 	));
 	let best_block = BestBlock::from_network(network);

lightning/src/chain/chainmonitor.rs

@@ -35,7 +35,7 @@ use crate::ln::types::ChannelId;
 use crate::ln::msgs::{self, BaseMessageHandler, Init, MessageSendEvent};
 use crate::ln::our_peer_storage::OurPeerStorage;
 use crate::sign::ecdsa::EcdsaChannelSigner;
-use crate::sign::PeerStorageKey;
+use crate::sign::{EntropySource, PeerStorageKey};
 use crate::events::{self, Event, EventHandler, ReplayEvent};
 use crate::util::logger::{Logger, WithContext};
 use crate::util::errors::APIError;
@@ -234,19 +234,21 @@ impl<ChannelSigner: EcdsaChannelSigner> Deref for LockedChannelMonitor<'_, Chann
 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 /// [module-level documentation]: crate::chain::chainmonitor
 /// [`rebroadcast_pending_claims`]: Self::rebroadcast_pending_claims
-pub struct ChainMonitor<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref>
+pub struct ChainMonitor<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref>
 	where C::Target: chain::Filter,
         T::Target: BroadcasterInterface,
         F::Target: FeeEstimator,
         L::Target: Logger,
         P::Target: Persist<ChannelSigner>,
+		ES::Target: EntropySource,
 {
 	monitors: RwLock<HashMap<ChannelId, MonitorHolder<ChannelSigner>>>,
 	chain_source: Option<C>,
 	broadcaster: T,
 	logger: L,
 	fee_estimator: F,
 	persister: P,
+	entropy_source: ES,
 	/// "User-provided" (ie persistence-completion/-failed) [`MonitorEvent`]s. These came directly
 	/// from the user and not from a [`ChannelMonitor`].
 	pending_monitor_events: Mutex<Vec<(OutPoint, ChannelId, Vec<MonitorEvent>, PublicKey)>>,
@@ -261,12 +263,13 @@ pub struct ChainMonitor<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F
 	our_peerstorage_encryption_key: PeerStorageKey,
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref> ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 where C::Target: chain::Filter,
 	    T::Target: BroadcasterInterface,
 	    F::Target: FeeEstimator,
 	    L::Target: Logger,
 	    P::Target: Persist<ChannelSigner>,
+		ES::Target: EntropySource,
 {
 	/// Dispatches to per-channel monitors, which are responsible for updating their on-chain view
 	/// of a channel and reacting accordingly based on transactions in the given chain data. See
@@ -400,14 +403,15 @@ where C::Target: chain::Filter,
 	/// **Important**: This key should not be set arbitrarily or changed after initialization. The same key
 	/// is obtained by the `ChannelManager` through `KeyMananger` to decrypt peer backups.
 	/// Using an inconsistent or incorrect key will result in the inability to decrypt previously encrypted backups.
-	pub fn new(chain_source: Option<C>, broadcaster: T, logger: L, feeest: F, persister: P, our_peerstorage_encryption_key: PeerStorageKey) -> Self {
+	pub fn new(chain_source: Option<C>, broadcaster: T, logger: L, feeest: F, persister: P, entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey) -> Self {
 		Self {
 			monitors: RwLock::new(new_hash_map()),
 			chain_source,
 			broadcaster,
 			logger,
 			fee_estimator: feeest,
 			persister,
+			entropy_source,
 			pending_monitor_events: Mutex::new(Vec::new()),
 			highest_chain_height: AtomicUsize::new(0),
 			event_notifier: Notifier::new(),
@@ -697,19 +701,20 @@ where C::Target: chain::Filter,
 	fn send_peer_storage(&self, their_node_id: PublicKey) {
 		// TODO: Serialize `ChannelMonitor`s inside `our_peer_storage`.
 
-		let our_peer_storage = OurPeerStorage::create_from_data(self.our_peerstorage_encryption_key.clone(), Vec::new());
+		let our_peer_storage = OurPeerStorage::create_from_data(self.our_peerstorage_encryption_key.clone(), Vec::new(), self.entropy_source.get_secure_random_bytes());
 		log_debug!(self.logger, "Sending Peer Storage from chainmonitor");
 		self.pending_send_only_events.lock().unwrap().push(MessageSendEvent::SendPeerStorage { node_id: their_node_id,
 			msg: msgs::PeerStorage { data: our_peer_storage.encrypted_data() } })
 	}
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> BaseMessageHandler for ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref> BaseMessageHandler for ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 where C::Target: chain::Filter,
 		T::Target: BroadcasterInterface,
 		F::Target: FeeEstimator,
 		L::Target: Logger,
 		P::Target: Persist<ChannelSigner>,
+		ES::Target: EntropySource,
 {
 	fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> {
 		let mut pending_events = self.pending_send_only_events.lock().unwrap();
@@ -729,14 +734,15 @@ where C::Target: chain::Filter,
 	fn peer_connected(&self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool) -> Result<(), ()> { Ok(()) }
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref>
-chain::Listen for ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref>
+chain::Listen for ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 where
 	C::Target: chain::Filter,
 	T::Target: BroadcasterInterface,
 	F::Target: FeeEstimator,
 	L::Target: Logger,
 	P::Target: Persist<ChannelSigner>,
+	ES::Target: EntropySource,
 {
 	fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) {
 		log_debug!(self.logger, "New best block {} at height {} provided via block_connected", header.block_hash(), height);
@@ -764,14 +770,15 @@ where
 	}
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref>
-chain::Confirm for ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref>
+chain::Confirm for ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 where
 	C::Target: chain::Filter,
 	T::Target: BroadcasterInterface,
 	F::Target: FeeEstimator,
 	L::Target: Logger,
 	P::Target: Persist<ChannelSigner>,
+	ES::Target: EntropySource,
 {
 	fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) {
 		log_debug!(self.logger, "{} provided transactions confirmed at height {} in block {}", txdata.len(), height, header.block_hash());
@@ -824,13 +831,14 @@ where
 	}
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref , T: Deref , F: Deref , L: Deref , P: Deref >
-chain::Watch<ChannelSigner> for ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref , T: Deref , F: Deref , L: Deref , P: Deref, ES: Deref>
+chain::Watch<ChannelSigner> for ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 where C::Target: chain::Filter,
 	    T::Target: BroadcasterInterface,
 	    F::Target: FeeEstimator,
 	    L::Target: Logger,
 	    P::Target: Persist<ChannelSigner>,
+		ES::Target: EntropySource,
 {
 	fn watch_channel(&self, channel_id: ChannelId, monitor: ChannelMonitor<ChannelSigner>) -> Result<ChannelMonitorUpdateStatus, ()> {
 		let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
@@ -963,12 +971,13 @@ where C::Target: chain::Filter,
 	}
 }
 
-impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> events::EventsProvider for ChainMonitor<ChannelSigner, C, T, F, L, P>
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref> events::EventsProvider for ChainMonitor<ChannelSigner, C, T, F, L, P, ES>
 	where C::Target: chain::Filter,
 	      T::Target: BroadcasterInterface,
 	      F::Target: FeeEstimator,
 	      L::Target: Logger,
 	      P::Target: Persist<ChannelSigner>,
+		  ES::Target: EntropySource,
 {
 	/// Processes [`SpendableOutputs`] events produced from each [`ChannelMonitor`] upon maturity.
 	///

lightning/src/ln/our_peer_storage.rs

@@ -11,6 +11,9 @@
 //! It supports encryption and decryption to maintain data integrity and security during
 //! transmission.
 //!
+use bitcoin::hashes::sha256::Hash as Sha256;
+use bitcoin::hashes::{Hash, HashEngine};
+
 use crate::sign::PeerStorageKey;
 
 use crate::crypto::chacha20poly1305rfc::ChaCha20Poly1305RFC;
@@ -63,40 +66,56 @@ impl OurPeerStorage {
 	/// (serialised channel information), and returns a serialised [`OurPeerStorage`] as a `Vec<u8>`.
 	///
 	/// The resulting serialised data is intended to be directly used for transmission to the peers.
-	pub fn create_from_data(key: PeerStorageKey, mut ser_channels: Vec<u8>) -> OurPeerStorage {
-		let n = 0u64;
+	pub fn create_from_data(
+		key: PeerStorageKey, mut ser_channels: Vec<u8>, random_bytes: [u8; 32],
+	) -> OurPeerStorage {
+		let key_hash = Sha256::const_hash(&key.inner);
 
 		let plaintext_len = ser_channels.len();
 
-		let mut nonce = [0; 12];
-		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
+		// Compute Sha256(Sha256(key) + random_bytes).
+		let mut sha = Sha256::engine();
+		sha.input(&key_hash.to_byte_array());
+		sha.input(&random_bytes);
+
+		let mut nonce = [0u8; 12];
+		nonce[4..].copy_from_slice(&Sha256::from_engine(sha).to_byte_array()[0..8]);
 
 		let mut chacha = ChaCha20Poly1305RFC::new(&key.inner, &nonce, b"");
 		let mut tag = [0; 16];
 		chacha.encrypt_full_message_in_place(&mut ser_channels[0..plaintext_len], &mut tag);
 
 		ser_channels.extend_from_slice(&tag);
 
+		// Append `random_bytes` in front of the encrypted_blob.
+		ser_channels.splice(0..0, random_bytes);
 		Self { encrypted_data: ser_channels }
 	}
 
 	/// Decrypt `OurPeerStorage` using the `key`, result is stored inside the `res`.
 	/// Returns an error if the the `cyphertext` is not correct.
 	pub fn decrypt_our_peer_storage(mut self, key: PeerStorageKey) -> Result<Vec<u8>, ()> {
-		const MIN_CYPHERTEXT_LEN: usize = 16;
+		let key_hash = Sha256::const_hash(&key.inner);
+
+		// Length of tag + Length of random_bytes
+		const MIN_CYPHERTEXT_LEN: usize = 16 + 32;
 		let cyphertext_len = self.encrypted_data.len();
 
 		// Ensure the cyphertext is at least as large as the MIN_CYPHERTEXT_LEN.
 		if cyphertext_len < MIN_CYPHERTEXT_LEN {
 			return Err(());
 		}
 
-		// Split the cyphertext into the encrypted data and the authentication tag.
-		let (encrypted_data, tag) = self.encrypted_data.split_at_mut(cyphertext_len - 16);
+		// Ciphertext is of the form: random_bytes(32 bytes) + encrypted_data + tag(16 bytes).
+		let (data_mut, tag) = self.encrypted_data.split_at_mut(cyphertext_len - 16);
+		let (random_bytes, encrypted_data) = data_mut.split_at_mut(32);
+
+		let mut sha = Sha256::engine();
+		sha.input(&key_hash.to_byte_array());
+		sha.input(random_bytes);
 
-		let n = 0u64;
-		let mut nonce = [0; 12];
-		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
+		let mut nonce = [0u8; 12];
+		nonce[4..].copy_from_slice(&Sha256::from_engine(sha).to_byte_array()[0..8]);
 
 		let mut chacha = ChaCha20Poly1305RFC::new(&key.inner, &nonce, b"");
 
@@ -105,6 +124,7 @@ impl OurPeerStorage {
 		}
 
 		self.encrypted_data.truncate(cyphertext_len - 16);
+		self.encrypted_data.drain(0..32);
 
 		Ok(self.encrypted_data)
 	}

lightning/src/ln/peer_handler.rs

@@ -721,7 +721,7 @@ pub type SimpleArcPeerManager<SD, M, T, F, C, L, CF, S> = PeerManager<
 	Arc<L>,
 	IgnoringMessageHandler,
 	Arc<KeysManager>,
-	Arc<ChainMonitor<InMemorySigner, Arc<CF>, Arc<T>, Arc<F>, Arc<L>, Arc<S>>>,
+	Arc<ChainMonitor<InMemorySigner, Arc<CF>, Arc<T>, Arc<F>, Arc<L>, Arc<S>, Arc<KeysManager>>>,
 >;
 
 /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
@@ -743,7 +743,7 @@ pub type SimpleRefPeerManager<
 	&'logger L,
 	IgnoringMessageHandler,
 	&'c KeysManager,
-	&'j ChainMonitor<&'a M, C, &'b T, &'c F, &'logger L, &'c KeysManager>,
+	&'j ChainMonitor<&'a M, C, &'b T, &'c F, &'logger L, &'c KeysManager, &'c KeysManager>,
 >;
 
 

lightning/src/util/anchor_channel_reserves.rs

@@ -29,6 +29,7 @@ use crate::ln::chan_utils::max_htlcs;
 use crate::ln::channelmanager::AChannelManager;
 use crate::prelude::new_hash_set;
 use crate::sign::ecdsa::EcdsaChannelSigner;
+use crate::sign::EntropySource;
 use crate::types::features::ChannelTypeFeatures;
 use crate::util::logger::Logger;
 use bitcoin::constants::WITNESS_SCALE_FACTOR;
@@ -276,6 +277,7 @@ pub fn can_support_additional_anchor_channel<
 	EstimatorRef: Deref,
 	LoggerRef: Deref,
 	PersistRef: Deref,
+	EntropySourceRef: Deref,
 	ChainMonitorRef: Deref<
 		Target = ChainMonitor<
 			ChannelSigner,
@@ -284,6 +286,7 @@ pub fn can_support_additional_anchor_channel<
 			EstimatorRef,
 			LoggerRef,
 			PersistRef,
+			EntropySourceRef,
 		>,
 	>,
 >(
@@ -297,6 +300,7 @@ where
 	EstimatorRef::Target: FeeEstimator,
 	LoggerRef::Target: Logger,
 	PersistRef::Target: Persist<ChannelSigner>,
+	EntropySourceRef::Target: EntropySource,
 {
 	let mut anchor_channels = new_hash_set();
 	// Calculate the number of in-progress anchor channels by inspecting ChannelMonitors with balance.

lightning/src/util/test_utils.rs

@@ -407,6 +407,7 @@ pub struct TestChainMonitor<'a> {
 		&'a TestFeeEstimator,
 		&'a TestLogger,
 		&'a dyn SyncPersist,
+		&'a TestKeysInterface,
 	>,
 	pub keys_manager: &'a TestKeysInterface,
 	/// If this is set to Some(), the next update_channel call (not watch_channel) must be a
@@ -435,6 +436,7 @@ impl<'a> TestChainMonitor<'a> {
 				logger,
 				fee_estimator,
 				persister,
+				keys_manager,
 				keys_manager.get_peer_storage_key(),
 			),
 			keys_manager,