Add random 'shadow route' CLTV delta offsets to improve privacy.

fuzz/src/full_stack.rs

@@ -459,7 +459,8 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};
-				let route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer) {
+				let random_seed_bytes: [u8; 32] = keys_manager.get_secure_random_bytes();
+				let route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer, &random_seed_bytes) {
 					Ok(route) => route,
 					Err(_) => return,
 				};
@@ -482,7 +483,8 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};
-				let mut route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer) {
+				let random_seed_bytes: [u8; 32] = keys_manager.get_secure_random_bytes();
+				let mut route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer, &random_seed_bytes) {
 					Ok(route) => route,
 					Err(_) => return,
 				};

fuzz/src/router.rs

@@ -250,6 +250,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 					}
 				}
 				let scorer = FixedPenaltyScorer::with_penalty(0);
+				let random_seed_bytes: [u8; 32] = [get_slice!(1)[0]; 32];
 				for target in node_pks.iter() {
 					let route_params = RouteParameters {
 						payment_params: PaymentParameters::from_node_id(*target).with_route_hints(last_hops.clone()),
@@ -258,7 +259,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 					};
 					let _ = find_route(&our_pubkey, &route_params, &net_graph,
 						first_hops.map(|c| c.iter().collect::<Vec<_>>()).as_ref().map(|a| a.as_slice()),
-						Arc::clone(&logger), &scorer);
+						Arc::clone(&logger), &scorer, &random_seed_bytes);
 				}
 			},
 		}

lightning-background-processor/src/lib.rs

@@ -669,13 +669,15 @@ mod tests {
 
 	#[test]
 	fn test_invoice_payer() {
+		let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+		let random_seed_bytes = keys_manager.get_secure_random_bytes();
 		let nodes = create_nodes(2, "test_invoice_payer".to_string());
 
 		// Initiate the background processors to watch each node.
 		let data_dir = nodes[0].persister.get_data_dir();
 		let persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
-		let router = DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger));
 		let scorer = Arc::new(Mutex::new(test_utils::TestScorer::with_penalty(0)));
+		let router = DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger), random_seed_bytes);
 		let invoice_payer = Arc::new(InvoicePayer::new(Arc::clone(&nodes[0].node), router, scorer, Arc::clone(&nodes[0].logger), |_: &_| {}, RetryAttempts(2)));
 		let event_handler = Arc::clone(&invoice_payer);
 		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());

lightning-invoice/src/utils.rs

@@ -4,7 +4,7 @@ use {CreationError, Currency, DEFAULT_EXPIRY_TIME, Invoice, InvoiceBuilder, Sign
 use payment::{Payer, Router};
 
 use bech32::ToBase32;
-use bitcoin_hashes::Hash;
+use bitcoin_hashes::{Hash, sha256};
 use crate::prelude::*;
 use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
@@ -22,6 +22,7 @@ use secp256k1::key::PublicKey;
 use core::convert::TryInto;
 use core::ops::Deref;
 use core::time::Duration;
+use sync::Mutex;
 
 #[cfg(feature = "std")]
 /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice."
@@ -224,12 +225,15 @@ where
 pub struct DefaultRouter<G: Deref<Target = NetworkGraph>, L: Deref> where L::Target: Logger {
 	network_graph: G,
 	logger: L,
+	random_seed_bytes: Mutex<[u8; 32]>,
 }
 
 impl<G: Deref<Target = NetworkGraph>, L: Deref> DefaultRouter<G, L> where L::Target: Logger {
-	/// Creates a new router using the given [`NetworkGraph`] and  [`Logger`].
-	pub fn new(network_graph: G, logger: L) -> Self {
-		Self { network_graph, logger }
+	/// Creates a new router using the given [`NetworkGraph`], a [`Logger`], and a randomness source
+	/// `random_seed_bytes`.
+	pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32]) -> Self {
+		let random_seed_bytes = Mutex::new(random_seed_bytes);
+		Self { network_graph, logger, random_seed_bytes }
 	}
 }
 
@@ -239,7 +243,12 @@ where L::Target: Logger {
 		&self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
 		first_hops: Option<&[&ChannelDetails]>, scorer: &S
 	) -> Result<Route, LightningError> {
-		find_route(payer, params, &*self.network_graph, first_hops, &*self.logger, scorer)
+		let random_seed_bytes = {
+			let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
+			*locked_random_seed_bytes = sha256::Hash::hash(&*locked_random_seed_bytes).into_inner();
+			*locked_random_seed_bytes
+		};
+		find_route(payer, params, &*self.network_graph, first_hops, &*self.logger, scorer, &random_seed_bytes)
 	}
 }
 
@@ -299,6 +308,7 @@ mod test {
 	use lightning::util::enforcing_trait_impls::EnforcingSigner;
 	use lightning::util::events::{MessageSendEvent, MessageSendEventsProvider, Event};
 	use lightning::util::test_utils;
+	use lightning::chain::keysinterface::KeysInterface;
 	use utils::create_invoice_from_channelmanager_and_duration_since_epoch;
 
 	#[test]
@@ -327,9 +337,10 @@ mod test {
 		let network_graph = node_cfgs[0].network_graph;
 		let logger = test_utils::TestLogger::new();
 		let scorer = test_utils::TestScorer::with_penalty(0);
+		let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &route_params, network_graph,
-			Some(&first_hops.iter().collect::<Vec<_>>()), &logger, &scorer,
+			Some(&first_hops.iter().collect::<Vec<_>>()), &logger, &scorer, &random_seed_bytes
 		).unwrap();
 
 		let payment_event = {
@@ -415,9 +426,10 @@ mod test {
 		let network_graph = node_cfgs[0].network_graph;
 		let logger = test_utils::TestLogger::new();
 		let scorer = test_utils::TestScorer::with_penalty(0);
+		let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &params, network_graph,
-			Some(&first_hops.iter().collect::<Vec<_>>()), &logger, &scorer,
+			Some(&first_hops.iter().collect::<Vec<_>>()), &logger, &scorer, &random_seed_bytes
 		).unwrap();
 		let (payment_event, fwd_idx) = {
 			let mut payment_hash = PaymentHash([0; 32]);

lightning/src/ln/channelmanager.rs

@@ -6844,6 +6844,7 @@ mod tests {
 	use util::errors::APIError;
 	use util::events::{Event, MessageSendEvent, MessageSendEventsProvider};
 	use util::test_utils;
+	use chain::keysinterface::KeysInterface;
 
 	#[cfg(feature = "std")]
 	#[test]
@@ -7097,6 +7098,7 @@ mod tests {
 		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 		create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 		let scorer = test_utils::TestScorer::with_penalty(0);
+		let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
 
 		// To start (1), send a regular payment but don't claim it.
 		let expected_route = [&nodes[1]];
@@ -7110,7 +7112,7 @@ mod tests {
 		};
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &route_params, nodes[0].network_graph, None,
-			nodes[0].logger, &scorer
+			nodes[0].logger, &scorer, &random_seed_bytes
 		).unwrap();
 		nodes[0].node.send_spontaneous_payment(&route, Some(payment_preimage)).unwrap();
 		check_added_monitors!(nodes[0], 1);
@@ -7141,7 +7143,7 @@ mod tests {
 		let payment_preimage = PaymentPreimage([42; 32]);
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &route_params, nodes[0].network_graph, None,
-			nodes[0].logger, &scorer
+			nodes[0].logger, &scorer, &random_seed_bytes
 		).unwrap();
 		let (payment_hash, _) = nodes[0].node.send_spontaneous_payment(&route, Some(payment_preimage)).unwrap();
 		check_added_monitors!(nodes[0], 1);
@@ -7202,9 +7204,10 @@ mod tests {
 		let network_graph = nodes[0].network_graph;
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = test_utils::TestScorer::with_penalty(0);
+		let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
 		let route = find_route(
 			&payer_pubkey, &route_params, network_graph, Some(&first_hops.iter().collect::<Vec<_>>()),
-			nodes[0].logger, &scorer
+			nodes[0].logger, &scorer, &random_seed_bytes
 		).unwrap();
 
 		let test_preimage = PaymentPreimage([42; 32]);
@@ -7245,9 +7248,10 @@ mod tests {
 		let network_graph = nodes[0].network_graph;
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = test_utils::TestScorer::with_penalty(0);
+		let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
 		let route = find_route(
 			&payer_pubkey, &route_params, network_graph, Some(&first_hops.iter().collect::<Vec<_>>()),
-			nodes[0].logger, &scorer
+			nodes[0].logger, &scorer, &random_seed_bytes
 		).unwrap();
 
 		let test_preimage = PaymentPreimage([42; 32]);
@@ -7331,7 +7335,7 @@ mod tests {
 pub mod bench {
 	use chain::Listen;
 	use chain::chainmonitor::{ChainMonitor, Persist};
-	use chain::keysinterface::{KeysManager, InMemorySigner};
+	use chain::keysinterface::{KeysManager, KeysInterface, InMemorySigner};
 	use ln::channelmanager::{BestBlock, ChainParameters, ChannelManager, PaymentHash, PaymentPreimage};
 	use ln::features::{InitFeatures, InvoiceFeatures};
 	use ln::functional_test_utils::*;
@@ -7340,7 +7344,7 @@ pub mod bench {
 	use routing::router::{PaymentParameters, get_route};
 	use util::test_utils;
 	use util::config::UserConfig;
-	use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose};
+	use util::events::{Event, MessageSendEvent, MessageSendEventsProvider};
 
 	use bitcoin::hashes::Hash;
 	use bitcoin::hashes::sha256::Hash as Sha256;
@@ -7448,8 +7452,11 @@ pub mod bench {
 				let payment_params = PaymentParameters::from_node_id($node_b.get_our_node_id())
 					.with_features(InvoiceFeatures::known());
 				let scorer = test_utils::TestScorer::with_penalty(0);
-				let route = get_route(&$node_a.get_our_node_id(), &payment_params, &dummy_graph,
-					Some(&usable_channels.iter().map(|r| r).collect::<Vec<_>>()), 10_000, TEST_FINAL_CLTV, &logger_a, &scorer).unwrap();
+				let seed = [3u8; 32];
+				let keys_manager = KeysManager::new(&seed, 42, 42);
+				let random_seed_bytes = keys_manager.get_secure_random_bytes();
+				let route = get_route(&$node_a.get_our_node_id(), &payment_params, &dummy_graph.read_only(),
+					Some(&usable_channels.iter().map(|r| r).collect::<Vec<_>>()), 10_000, TEST_FINAL_CLTV, &logger_a, &scorer, &random_seed_bytes).unwrap();
 
 				let mut payment_preimage = PaymentPreimage([0; 32]);
 				payment_preimage.0[0..8].copy_from_slice(&payment_count.to_le_bytes());

lightning/src/ln/functional_test_utils.rs

@@ -10,7 +10,7 @@
 //! A bunch of useful utilities for building networks of nodes and exchanging messages between
 //! nodes for functional tests.
 
-use chain::{BestBlock, Confirm, Listen, Watch};
+use chain::{BestBlock, Confirm, Listen, Watch, keysinterface::KeysInterface};
 use chain::channelmonitor::ChannelMonitor;
 use chain::transaction::OutPoint;
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
@@ -1094,15 +1094,18 @@ macro_rules! get_route_and_payment_hash {
 		$crate::get_route_and_payment_hash!($send_node, $recv_node, vec![], $recv_value, TEST_FINAL_CLTV)
 	}};
 	($send_node: expr, $recv_node: expr, $last_hops: expr, $recv_value: expr, $cltv: expr) => {{
+		use $crate::chain::keysinterface::KeysInterface;
 		let (payment_preimage, payment_hash, payment_secret) = $crate::get_payment_preimage_hash!($recv_node, Some($recv_value));
 		let payment_params = $crate::routing::router::PaymentParameters::from_node_id($recv_node.node.get_our_node_id())
 			.with_features($crate::ln::features::InvoiceFeatures::known())
 			.with_route_hints($last_hops);
 		let scorer = $crate::util::test_utils::TestScorer::with_penalty(0);
+		let keys_manager = $crate::util::test_utils::TestKeysInterface::new(&[0u8; 32], bitcoin::network::constants::Network::Testnet);
+		let random_seed_bytes = keys_manager.get_secure_random_bytes();
 		let route = $crate::routing::router::get_route(
-			&$send_node.node.get_our_node_id(), &payment_params, $send_node.network_graph,
+			&$send_node.node.get_our_node_id(), &payment_params, &$send_node.network_graph.read_only(),
 			Some(&$send_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
-			$recv_value, $cltv, $send_node.logger, &scorer
+			$recv_value, $cltv, $send_node.logger, &scorer, &random_seed_bytes
 		).unwrap();
 		(route, payment_hash, payment_preimage, payment_secret)
 	}}
@@ -1557,11 +1560,15 @@ pub const TEST_FINAL_CLTV: u32 = 70;
 pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) {
 	let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id())
 		.with_features(InvoiceFeatures::known());
+	let network_graph = origin_node.network_graph.read_only();
 	let scorer = test_utils::TestScorer::with_penalty(0);
+	let seed = [0u8; 32];
+	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+	let random_seed_bytes = keys_manager.get_secure_random_bytes();
 	let route = get_route(
-		&origin_node.node.get_our_node_id(), &payment_params, &origin_node.network_graph,
+		&origin_node.node.get_our_node_id(), &payment_params, &network_graph,
 		Some(&origin_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
-		recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer).unwrap();
+		recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
@@ -1575,10 +1582,14 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64)  {
 	let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id())
 		.with_features(InvoiceFeatures::known());
+	let network_graph = origin_node.network_graph.read_only();
 	let scorer = test_utils::TestScorer::with_penalty(0);
+	let seed = [0u8; 32];
+	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+	let random_seed_bytes = keys_manager.get_secure_random_bytes();
 	let route = get_route(
-		&origin_node.node.get_our_node_id(), &payment_params, origin_node.network_graph,
-		None, recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer).unwrap();
+		&origin_node.node.get_our_node_id(), &payment_params, &network_graph,
+		None, recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {