Add a NetworkGraph reference to OnionMessenger

When buffering onion messages for a node that is not connected as a
peer, it's possible that node does not exist. Include a NetworkGraph
reference in OnionMessenger so that it can be used to check if the node
actually exists. Otherwise, an malicious node may send an onion message
where the reply path's introduction node doesn't exist. This would
result in buffering messages that may never be delivered.

Author: jkczyz

lightning/src/onion_message/functional_tests.rs

@@ -12,6 +12,7 @@
 use crate::blinded_path::BlindedPath;
 use crate::ln::features::InitFeatures;
 use crate::ln::msgs::{self, DecodeError, OnionMessageHandler};
+use crate::routing::gossip::NetworkGraph;
 use crate::sign::{NodeSigner, Recipient};
 use crate::util::ser::{FixedLengthReader, LengthReadable, Writeable, Writer};
 use crate::util::test_utils;
@@ -31,6 +32,7 @@ struct MessengerNode {
 	messenger: OnionMessenger<
 		Arc<test_utils::TestKeysInterface>,
 		Arc<test_utils::TestKeysInterface>,
+		Arc<NetworkGraph<Arc<test_utils::TestLogger>>>,
 		Arc<test_utils::TestLogger>,
 		Arc<TestMessageRouter>,
 		Arc<TestOffersMessageHandler>,
@@ -157,6 +159,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 	let mut nodes = Vec::new();
 	for i in 0..num_messengers {
 		let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
+		let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, logger.clone()));
 		let seed = [i as u8; 32];
 		let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 		let message_router = Arc::new(TestMessageRouter {});
@@ -165,7 +168,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 		nodes.push(MessengerNode {
 			keys_manager: keys_manager.clone(),
 			messenger: OnionMessenger::new(
-				keys_manager.clone(), keys_manager, logger.clone(), message_router,
+				keys_manager.clone(), keys_manager, network_graph, logger.clone(), message_router,
 				offers_message_handler, custom_message_handler.clone()
 			),
 			custom_message_handler,
@@ -456,9 +459,10 @@ fn spec_test_vector() {
 	let mut nodes = Vec::new();
 	for (idx, (entropy_source, node_signer)) in keys_mgrs.iter().enumerate() {
 		let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", idx)));
+		let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, logger.clone()));
 		nodes.push(OnionMessenger::new(
-			entropy_source.clone(), node_signer.clone(), logger.clone(), message_router.clone(),
-			offers_message_handler.clone(), custom_message_handler.clone()
+			entropy_source.clone(), node_signer.clone(), network_graph, logger.clone(),
+			message_router.clone(), offers_message_handler.clone(), custom_message_handler.clone()
 		));
 	}
 	for idx in 0..nodes.len() - 1 {

lightning/src/onion_message/messenger.rs

@@ -25,6 +25,7 @@ use crate::ln::features::{InitFeatures, NodeFeatures};
 use crate::ln::msgs::{self, OnionMessage, OnionMessageHandler};
 use crate::ln::onion_utils;
 use crate::ln::peer_handler::IgnoringMessageHandler;
+use crate::routing::gossip::{NetworkGraph, NodeId};
 pub use super::packet::OnionMessageContents;
 use super::packet::ParsedOnionMessageContents;
 use super::offers::OffersMessageHandler;
@@ -59,15 +60,17 @@ use crate::prelude::*;
 /// ```
 /// # extern crate bitcoin;
 /// # use bitcoin::hashes::_export::_core::time::Duration;
+/// # use bitcoin::network::constants::Network;
 /// # use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 /// # use lightning::blinded_path::BlindedPath;
 /// # use lightning::sign::KeysManager;
 /// # use lightning::ln::peer_handler::IgnoringMessageHandler;
 /// # use lightning::onion_message::{OnionMessageContents, Destination, MessageRouter, OnionMessagePath, OnionMessenger};
+/// # use lightning::routing::gossip::NetworkGraph;
 /// # use lightning::util::logger::{Logger, Record};
 /// # use lightning::util::ser::{Writeable, Writer};
 /// # use lightning::io;
-/// # use std::sync::Arc;
+/// #
 /// # struct FakeLogger;
 /// # impl Logger for FakeLogger {
 /// #     fn log(&self, record: &Record) { unimplemented!() }
@@ -81,20 +84,21 @@ use crate::prelude::*;
 /// # let seed = [42u8; 32];
 /// # let time = Duration::from_secs(123456);
 /// # let keys_manager = KeysManager::new(&seed, time.as_secs(), time.subsec_nanos());
-/// # let logger = Arc::new(FakeLogger {});
+/// # let logger = FakeLogger {};
+/// # let network_graph = NetworkGraph::new(Network::Testnet, &logger);
 /// # let node_secret = SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap();
 /// # let secp_ctx = Secp256k1::new();
 /// # let hop_node_id1 = PublicKey::from_secret_key(&secp_ctx, &node_secret);
 /// # let (hop_node_id2, hop_node_id3, hop_node_id4) = (hop_node_id1, hop_node_id1, hop_node_id1);
 /// # let destination_node_id = hop_node_id1;
-/// # let message_router = Arc::new(FakeMessageRouter {});
+/// # let message_router = FakeMessageRouter {};
 /// # let custom_message_handler = IgnoringMessageHandler {};
 /// # let offers_message_handler = IgnoringMessageHandler {};
 /// // Create the onion messenger. This must use the same `keys_manager` as is passed to your
 /// // ChannelManager.
 /// let onion_messenger = OnionMessenger::new(
-///     &keys_manager, &keys_manager, logger, message_router, &offers_message_handler,
-///     &custom_message_handler
+///     &keys_manager, &keys_manager, &network_graph, &logger, &message_router,
+///     &offers_message_handler, &custom_message_handler
 /// );
 ///
 /// # struct YourCustomMessage {}
@@ -136,17 +140,19 @@ use crate::prelude::*;
 ///
 /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
 /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
-pub struct OnionMessenger<ES: Deref, NS: Deref, L: Deref, MR: Deref, OMH: Deref, CMH: Deref>
+pub struct OnionMessenger<ES: Deref, NS: Deref, G, L: Deref, MR: Deref, OMH: Deref, CMH: Deref>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
+	G: Deref<Target=NetworkGraph<L>>,
 	L::Target: Logger,
 	MR::Target: MessageRouter,
 	OMH::Target: OffersMessageHandler,
 	CMH:: Target: CustomOnionMessageHandler,
 {
 	entropy_source: ES,
 	node_signer: NS,
+	network_graph: G,
 	logger: L,
 	message_buffers: Mutex<HashMap<PublicKey, OnionMessageBuffer>>,
 	secp_ctx: Secp256k1<secp256k1::All>,
@@ -533,11 +539,12 @@ where
 	}
 }
 
-impl<ES: Deref, NS: Deref, L: Deref, MR: Deref, OMH: Deref, CMH: Deref>
-OnionMessenger<ES, NS, L, MR, OMH, CMH>
+impl<ES: Deref, NS: Deref, G, L: Deref, MR: Deref, OMH: Deref, CMH: Deref>
+OnionMessenger<ES, NS, G, L, MR, OMH, CMH>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
+	G: Deref<Target=NetworkGraph<L>>,
 	L::Target: Logger,
 	MR::Target: MessageRouter,
 	OMH::Target: OffersMessageHandler,
@@ -546,14 +553,15 @@ where
 	/// Constructs a new `OnionMessenger` to send, forward, and delegate received onion messages to
 	/// their respective handlers.
 	pub fn new(
-		entropy_source: ES, node_signer: NS, logger: L, message_router: MR, offers_handler: OMH,
-		custom_handler: CMH
+		entropy_source: ES, node_signer: NS, network_graph: G, logger: L, message_router: MR,
+		offers_handler: OMH, custom_handler: CMH
 	) -> Self {
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
 		OnionMessenger {
 			entropy_source,
 			node_signer,
+			network_graph,
 			message_buffers: Mutex::new(HashMap::new()),
 			secp_ctx,
 			logger,
@@ -687,11 +695,12 @@ fn outbound_buffer_full(peer_node_id: &PublicKey, buffer: &HashMap<PublicKey, On
 	false
 }
 
-impl<ES: Deref, NS: Deref, L: Deref, MR: Deref, OMH: Deref, CMH: Deref> OnionMessageHandler
-for OnionMessenger<ES, NS, L, MR, OMH, CMH>
+impl<ES: Deref, NS: Deref, G, L: Deref, MR: Deref, OMH: Deref, CMH: Deref> OnionMessageHandler
+for OnionMessenger<ES, NS, G, L, MR, OMH, CMH>
 where
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
+	G: Deref<Target=NetworkGraph<L>>,
 	L::Target: Logger,
 	MR::Target: MessageRouter,
 	OMH::Target: OffersMessageHandler,
@@ -830,6 +839,7 @@ where
 pub type SimpleArcOnionMessenger<M, T, F, L> = OnionMessenger<
 	Arc<KeysManager>,
 	Arc<KeysManager>,
+	Arc<NetworkGraph<L>>,
 	Arc<L>,
 	Arc<DefaultMessageRouter>,
 	Arc<SimpleArcChannelManager<M, T, F, L>>,
@@ -849,6 +859,7 @@ pub type SimpleRefOnionMessenger<
 > = OnionMessenger<
 	&'a KeysManager,
 	&'a KeysManager,
+	&'g NetworkGraph<&'b L>,
 	&'b L,
 	&'i DefaultMessageRouter,
 	&'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, M, T, F, L>,