Commit for regenerating OM fuzz no_breakage vectors

Use the OM generated for hop1->hop2 in the vmw_* tests
lightningdevkit · Jun 6, 2023 · c0b3380 · c0b3380
1 parent 7a0d86e
commit c0b3380
Show file tree

Hide file tree

Showing 2 changed files with 152 additions and 2 deletions.
diff --git a/fuzz/src/onion_message.rs b/fuzz/src/onion_message.rs
@@ -171,8 +171,36 @@ impl SignerProvider for KeyProvider {
 	fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()> { unreachable!() }
 }
 
+impl KeyProvider {
+	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
+		match recipient {
+			Recipient::Node => Ok(self.node_secret),
+			Recipient::PhantomNode => Err(())
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
+	use super::{TestCustomMessage, TestCustomMessageHandler, TestMessageRouter, TestOffersMessageHandler};
+	use lightning::blinded_path::BlindedPath;
+	use lightning::sign::Recipient;
+	use lightning::ln::features::InitFeatures;
+	use lightning::ln::msgs::{self, OnionMessageHandler};
+	use lightning::onion_message::{Destination, OnionMessenger, SendError};
+	use lightning::onion_message::OnionMessagePath;
+	use lightning::onion_message::OnionMessageContents;
+	use lightning::util::enforcing_trait_impls::EnforcingSigner;
+	use lightning::util::test_utils;
+	use lightning::util::ser::Writeable;
+
+	use bitcoin::network::constants::Network;
+	use bitcoin::secp256k1::{PublicKey, SecretKey, Secp256k1};
+
+	use std::sync::Arc;
+	use super::KeyProvider;
+	use std::sync::atomic::{AtomicU64, Ordering};
+
 	use lightning::util::logger::{Logger, Record};
 	use std::collections::HashMap;
 	use std::sync::Mutex;
@@ -188,6 +216,126 @@ mod tests {
 		}
 	}
 
+	struct MessengerNode {
+		keys_manager: Arc<KeyProvider>,
+		messenger: OnionMessenger<Arc<KeyProvider>, Arc<KeyProvider>, Arc<TrackingLogger>, Arc<TestMessageRouter>, Arc<TestOffersMessageHandler>, Arc<TestCustomMessageHandler>>,
+		logger: Arc<TrackingLogger>,
+	}
+
+	impl MessengerNode {
+		fn get_node_pk(&self) -> PublicKey {
+			let secp_ctx = Secp256k1::new();
+			PublicKey::from_secret_key(&secp_ctx, &self.keys_manager.get_node_secret(Recipient::Node).unwrap())
+		}
+	}
+	fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
+		let mut nodes = Vec::new();
+		for i in 0..num_messengers {
+			let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
+			let seed = [i as u8; 32];
+			let mut secret_bytes = [0; 32];
+			secret_bytes[31] = 2;
+			let secret = SecretKey::from_slice(&secret_bytes).unwrap();
+			let keys_manager = Arc::new(KeyProvider {
+				node_secret: secret,
+				counter: AtomicU64::new(0),
+			});
+			let message_router = Arc::new(TestMessageRouter {});
+			let offers_msg_handler = Arc::new(TestOffersMessageHandler {});
+			let custom_msg_handler = Arc::new(TestCustomMessageHandler {});
+			let onion_messenger = OnionMessenger::new(
+				keys_manager.clone(), keys_manager.clone(), logger.clone(), message_router, offers_msg_handler,
+				custom_msg_handler
+			);
+			nodes.push(MessengerNode {
+				keys_manager: keys_manager.clone(),
+				messenger: onion_messenger,
+				logger,
+			});
+		}
+		for idx in 0..num_messengers - 1 {
+			let i = idx as usize;
+			let mut features = InitFeatures::empty();
+			features.set_onion_messages_optional();
+			let init_msg = msgs::Init { features, remote_network_address: None };
+			nodes[i].messenger.peer_connected(&nodes[i + 1].get_node_pk(), &init_msg.clone(), true).unwrap();
+			nodes[i + 1].messenger.peer_connected(&nodes[i].get_node_pk(), &init_msg.clone(), false).unwrap();
+		}
+		nodes
+	}
+
+	fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>) {
+		let mut prev_node = &path[0];
+		let num_nodes = path.len();
+		for (idx, node) in path.into_iter().skip(1).enumerate() {
+			let events = prev_node.messenger.release_pending_msgs();
+			let onion_msg =  {
+				let msgs = events.get(&node.get_node_pk()).unwrap();
+				assert_eq!(msgs.len(), 1);
+				msgs[0].clone()
+			};
+			println!("VMW: encoded om: {:02x?}", onion_msg.encode());
+			node.messenger.handle_onion_message(&prev_node.get_node_pk(), &onion_msg);
+			if idx == num_nodes - 1 {
+				// node.logger.assert_log_contains(
+				//   "lightning::onion_message::messenger".to_string(),
+				//   format!("Received an onion message with path_id: {:02x?}", expected_path_id).to_string(), 1);
+			}
+			prev_node = node;
+		}
+	}
+
+	#[test]
+	fn vmw_om_one_hop() {
+		let nodes = create_nodes(2);
+		let path = OnionMessagePath {
+			intermediate_nodes: Vec::new(),
+			destination: Destination::Node(nodes[1].get_node_pk()),
+		};
+
+		nodes[0].messenger.send_onion_message(path, OnionMessageContents::Custom(TestCustomMessage {}), None).unwrap();
+		pass_along_path(&nodes, None);
+	}
+
+	#[test]
+	fn vmw_two_unblinded_hops() {
+		let nodes = create_nodes(3);
+		let path = OnionMessagePath {
+			intermediate_nodes: vec![nodes[1].get_node_pk()],
+			destination: Destination::Node(nodes[2].get_node_pk()),
+		};
+
+		nodes[0].messenger.send_onion_message(path, OnionMessageContents::Custom(TestCustomMessage {}), None).unwrap();
+		pass_along_path(&nodes, None);
+	}
+
+	#[test]
+	fn vmw_two_unblinded_two_blinded() {
+		let nodes = create_nodes(5);
+		let secp_ctx = Secp256k1::new();
+		let blinded_route = BlindedPath::new_for_message(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();
+		let path = OnionMessagePath {
+			intermediate_nodes: vec![nodes[1].get_node_pk(), nodes[2].get_node_pk()],
+			destination: Destination::BlindedPath(blinded_route),
+		};
+
+		nodes[0].messenger.send_onion_message(path, OnionMessageContents::Custom(TestCustomMessage {}), None).unwrap();
+		pass_along_path(&nodes, None);
+	}
+
+	#[test]
+	fn vmw_three_blinded_hops() {
+		let nodes = create_nodes(4);
+		let secp_ctx = Secp256k1::new();
+		let blinded_route = BlindedPath::new_for_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
+		let path = OnionMessagePath {
+			intermediate_nodes: vec![],
+			destination: Destination::BlindedPath(blinded_route),
+		};
+
+		nodes[0].messenger.send_onion_message(path, OnionMessageContents::Custom(TestCustomMessage {}), None).unwrap();
+		pass_along_path(&nodes, None);
+	}
 	#[test]
 	fn test_no_onion_message_breakage() {
 		let one_hop_om = "020000000000000000000000000000000000000000000000000000000000000e01055600020000000000000000000000000000000000000000000000000000000000000e0136041095000000000000000000000000000000fd1092202a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000";
@@ -200,6 +348,7 @@ mod tests {
 			// TODO: Add reply path to one_hop_om instead?
 			assert_eq!(log_entries.get(&("lightning::onion_message::messenger".to_string(),
 						"No reply path to respond to onion message with path_id None".to_string())), Some(&1));
+						//"Received an onion message with path_id None and no reply_path: Tlv { tag: 4242, value: [42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42] }".to_string())), Some(&1));
 		}
 
 		let two_unblinded_hops_om = "020000000000000000000000000000000000000000000000000000000000000e01055600020000000000000000000000000000000000000000000000000000000000000e0135043304210200000000000000000000000000000000000000000000000000000000000000029500000000000000000000000000000036000000000000000000000000000000000000000000000000000000000000003604104b000000000000000000000000000000fd1092202a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b200000000000000000000000000000000000000000000000000000000000000";

diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs
@@ -372,8 +372,9 @@ where
 		}
 	}
 
-	#[cfg(test)]
-	pub(super) fn release_pending_msgs(&self) -> HashMap<PublicKey, VecDeque<msgs::OnionMessage>> {
+	#[cfg(any(test, fuzzing))]
+	///
+	pub fn release_pending_msgs(&self) -> HashMap<PublicKey, VecDeque<msgs::OnionMessage>> {
 		let mut pending_msgs = self.pending_messages.lock().unwrap();
 		let mut msgs = HashMap::new();
 		// We don't want to disconnect the peers by removing them entirely from the original map, so we