X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=07300fdf62ef122fd9e8826e5ce24604ba506df0;hb=9fbafd4b6cc7a290fbd952d8baf58d6017fc3078;hp=d3ac2ebe9a39bf2e918f58dbf4d012ac0434ae99;hpb=252280d6bfda49a7ed4fd5d427eed5c74af65ae5;p=rust-lightning diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index d3ac2ebe..07300fdf 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -19,7 +19,7 @@ use bitcoin::secp256k1::key::{SecretKey,PublicKey}; use ln::features::InitFeatures; use ln::msgs; -use ln::msgs::{ChannelMessageHandler, LightningError, RoutingMessageHandler}; +use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, RoutingMessageHandler}; use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager}; use util::ser::{VecWriter, Writeable, Writer}; use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep}; @@ -69,7 +69,7 @@ impl RoutingMessageHandler for IgnoringMessageHandler { fn get_next_channel_announcements(&self, _starting_point: u64, _batch_amount: u8) -> Vec<(msgs::ChannelAnnouncement, Option, Option)> { Vec::new() } fn get_next_node_announcements(&self, _starting_point: Option<&PublicKey>, _batch_amount: u8) -> Vec { Vec::new() } - fn sync_routing_table(&self, _their_node_id: &PublicKey, _init: &msgs::Init) {} + fn peer_connected(&self, _their_node_id: &PublicKey, _init: &msgs::Init) {} fn handle_reply_channel_range(&self, _their_node_id: &PublicKey, _msg: msgs::ReplyChannelRange) -> Result<(), LightningError> { Ok(()) } fn handle_reply_short_channel_ids_end(&self, _their_node_id: &PublicKey, _msg: msgs::ReplyShortChannelIdsEnd) -> Result<(), LightningError> { Ok(()) } fn handle_query_channel_range(&self, _their_node_id: &PublicKey, _msg: msgs::QueryChannelRange) -> Result<(), LightningError> { Ok(()) } @@ -324,6 +324,7 @@ struct Peer { channel_encryptor: PeerChannelEncryptor, their_node_id: Option, their_features: Option, + their_net_address: Option, pending_outbound_buffer: LinkedList>, pending_outbound_buffer_first_msg_offset: usize, @@ -338,6 +339,7 @@ struct Peer { msgs_sent_since_pong: usize, awaiting_pong_timer_tick_intervals: i8, received_message_since_timer_tick: bool, + sent_gossip_timestamp_filter: bool, } impl Peer { @@ -347,7 +349,11 @@ impl Peer { /// announcements/updates for the given channel_id then we will send it when we get to that /// point and we shouldn't send it yet to avoid sending duplicate updates. If we've already /// sent the old versions, we should send the update, and so return true here. - fn should_forward_channel_announcement(&self, channel_id: u64)->bool{ + fn should_forward_channel_announcement(&self, channel_id: u64) -> bool { + if self.their_features.as_ref().unwrap().supports_gossip_queries() && + !self.sent_gossip_timestamp_filter { + return false; + } match self.sync_status { InitSyncTracker::NoSyncRequested => true, InitSyncTracker::ChannelsSyncing(i) => i < channel_id, @@ -357,6 +363,10 @@ impl Peer { /// Similar to the above, but for node announcements indexed by node_id. fn should_forward_node_announcement(&self, node_id: PublicKey) -> bool { + if self.their_features.as_ref().unwrap().supports_gossip_queries() && + !self.sent_gossip_timestamp_filter { + return false; + } match self.sync_status { InitSyncTracker::NoSyncRequested => true, InitSyncTracker::ChannelsSyncing(_) => false, @@ -376,6 +386,8 @@ struct PeerHolder { /// lifetimes). Other times you can afford a reference, which is more efficient, in which case /// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents /// issues such as overly long function definitions. +/// +/// (C-not exported) as Arcs don't make sense in bindings pub type SimpleArcPeerManager = PeerManager>, Arc, Arc, Arc>>, Arc, Arc>; /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference @@ -384,6 +396,8 @@ pub type SimpleArcPeerManager = PeerManager = PeerManager, &'e NetGraphMsgHandler<&'g NetworkGraph, &'h C, &'f L>, &'f L, IgnoringMessageHandler>; /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls @@ -495,6 +509,36 @@ impl core::fmt::Display for OptionalFromDebugger<'_> { } } +/// A function used to filter out local or private addresses +/// https://www.iana.org./assignments/ipv4-address-space/ipv4-address-space.xhtml +/// https://www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xhtml +fn filter_addresses(ip_address: Option) -> Option { + match ip_address{ + // For IPv4 range 10.0.0.0 - 10.255.255.255 (10/8) + Some(NetAddress::IPv4{addr: [10, _, _, _], port: _}) => None, + // For IPv4 range 0.0.0.0 - 0.255.255.255 (0/8) + Some(NetAddress::IPv4{addr: [0, _, _, _], port: _}) => None, + // For IPv4 range 100.64.0.0 - 100.127.255.255 (100.64/10) + Some(NetAddress::IPv4{addr: [100, 64..=127, _, _], port: _}) => None, + // For IPv4 range 127.0.0.0 - 127.255.255.255 (127/8) + Some(NetAddress::IPv4{addr: [127, _, _, _], port: _}) => None, + // For IPv4 range 169.254.0.0 - 169.254.255.255 (169.254/16) + Some(NetAddress::IPv4{addr: [169, 254, _, _], port: _}) => None, + // For IPv4 range 172.16.0.0 - 172.31.255.255 (172.16/12) + Some(NetAddress::IPv4{addr: [172, 16..=31, _, _], port: _}) => None, + // For IPv4 range 192.168.0.0 - 192.168.255.255 (192.168/16) + Some(NetAddress::IPv4{addr: [192, 168, _, _], port: _}) => None, + // For IPv4 range 192.88.99.0 - 192.88.99.255 (192.88.99/24) + Some(NetAddress::IPv4{addr: [192, 88, 99, _], port: _}) => None, + // For IPv6 range 2000:0000:0000:0000:0000:0000:0000:0000 - 3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff (2000::/3) + Some(NetAddress::IPv6{addr: [0x20..=0x3F, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], port: _}) => ip_address, + // For remaining addresses + Some(NetAddress::IPv6{addr: _, port: _}) => None, + Some(..) => ip_address, + None => None, + } +} + impl PeerManager where CM::Target: ChannelMessageHandler, RM::Target: RoutingMessageHandler, @@ -543,7 +587,13 @@ impl P SecretKey::from_slice(&Sha256::from_engine(ephemeral_hash).into_inner()).expect("You broke SHA-256!") } - /// Indicates a new outbound connection has been established to a node with the given node_id. + /// Indicates a new outbound connection has been established to a node with the given node_id + /// and an optional remote network address. + /// + /// The remote network address adds the option to report a remote IP address back to a connecting + /// peer using the init message. + /// The user should pass the remote network address of the host they are connected to. + /// /// Note that if an Err is returned here you MUST NOT call socket_disconnected for the new /// descriptor but must disconnect the connection immediately. /// @@ -553,7 +603,7 @@ impl P /// [`socket_disconnected()`]. /// /// [`socket_disconnected()`]: PeerManager::socket_disconnected - pub fn new_outbound_connection(&self, their_node_id: PublicKey, descriptor: Descriptor) -> Result, PeerHandleError> { + pub fn new_outbound_connection(&self, their_node_id: PublicKey, descriptor: Descriptor, remote_network_address: Option) -> Result, PeerHandleError> { let mut peer_encryptor = PeerChannelEncryptor::new_outbound(their_node_id.clone(), self.get_ephemeral_key()); let res = peer_encryptor.get_act_one().to_vec(); let pending_read_buffer = [0; 50].to_vec(); // Noise act two is 50 bytes @@ -563,6 +613,7 @@ impl P channel_encryptor: peer_encryptor, their_node_id: None, their_features: None, + their_net_address: remote_network_address, pending_outbound_buffer: LinkedList::new(), pending_outbound_buffer_first_msg_offset: 0, @@ -577,13 +628,19 @@ impl P msgs_sent_since_pong: 0, awaiting_pong_timer_tick_intervals: 0, received_message_since_timer_tick: false, + sent_gossip_timestamp_filter: false, }).is_some() { panic!("PeerManager driver duplicated descriptors!"); }; Ok(res) } - /// Indicates a new inbound connection has been established. + /// Indicates a new inbound connection has been established to a node with an optional remote + /// network address. + /// + /// The remote network address adds the option to report a remote IP address back to a connecting + /// peer using the init message. + /// The user should pass the remote network address of the host they are connected to. /// /// May refuse the connection by returning an Err, but will never write bytes to the remote end /// (outbound connector always speaks first). Note that if an Err is returned here you MUST NOT @@ -594,7 +651,7 @@ impl P /// [`socket_disconnected()`]. /// /// [`socket_disconnected()`]: PeerManager::socket_disconnected - pub fn new_inbound_connection(&self, descriptor: Descriptor) -> Result<(), PeerHandleError> { + pub fn new_inbound_connection(&self, descriptor: Descriptor, remote_network_address: Option) -> Result<(), PeerHandleError> { let peer_encryptor = PeerChannelEncryptor::new_inbound(&self.our_node_secret); let pending_read_buffer = [0; 50].to_vec(); // Noise act one is 50 bytes @@ -603,6 +660,7 @@ impl P channel_encryptor: peer_encryptor, their_node_id: None, their_features: None, + their_net_address: remote_network_address, pending_outbound_buffer: LinkedList::new(), pending_outbound_buffer_first_msg_offset: 0, @@ -617,6 +675,7 @@ impl P msgs_sent_since_pong: 0, awaiting_pong_timer_tick_intervals: 0, received_message_since_timer_tick: false, + sent_gossip_timestamp_filter: false, }).is_some() { panic!("PeerManager driver duplicated descriptors!"); }; @@ -864,7 +923,7 @@ impl P peer.their_node_id = Some(their_node_id); insert_node_id!(); let features = InitFeatures::known(); - let resp = msgs::Init { features }; + let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone())}; self.enqueue_message(peer, &resp); peer.awaiting_pong_timer_tick_intervals = 0; }, @@ -875,7 +934,7 @@ impl P peer.their_node_id = Some(their_node_id); insert_node_id!(); let features = InitFeatures::known(); - let resp = msgs::Init { features }; + let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone())}; self.enqueue_message(peer, &resp); peer.awaiting_pong_timer_tick_intervals = 0; }, @@ -1010,7 +1069,8 @@ impl P log_info!(self.logger, "Received peer Init message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.features); - if msg.features.initial_routing_sync() { + // For peers not supporting gossip queries start sync now, otherwise wait until we receive a filter. + if msg.features.initial_routing_sync() && !msg.features.supports_gossip_queries() { peer.sync_status = InitSyncTracker::ChannelsSyncing(0); } if !msg.features.supports_static_remote_key() { @@ -1018,7 +1078,7 @@ impl P return Err(PeerHandleError{ no_connection_possible: true }.into()); } - self.message_handler.route_handler.sync_routing_table(&peer.their_node_id.unwrap(), &msg); + self.message_handler.route_handler.peer_connected(&peer.their_node_id.unwrap(), &msg); self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg); peer.their_features = Some(msg.features); @@ -1157,7 +1217,13 @@ impl P self.message_handler.route_handler.handle_reply_channel_range(&peer.their_node_id.unwrap(), msg)?; }, wire::Message::GossipTimestampFilter(_msg) => { - // TODO: handle message + // When supporting gossip messages, start inital gossip sync only after we receive + // a GossipTimestampFilter + if peer.their_features.as_ref().unwrap().supports_gossip_queries() && + !peer.sent_gossip_timestamp_filter { + peer.sent_gossip_timestamp_filter = true; + peer.sync_status = InitSyncTracker::ChannelsSyncing(0); + } }, // Unknown messages: @@ -1477,6 +1543,9 @@ impl P msg.sync_complete); self.enqueue_message(get_peer_for_forwarding!(node_id), msg); } + MessageSendEvent::SendGossipTimestampFilter { ref node_id, ref msg } => { + self.enqueue_message(get_peer_for_forwarding!(node_id), msg); + } } } @@ -1656,15 +1725,20 @@ fn is_gossip_msg(type_id: u16) -> bool { match type_id { msgs::ChannelAnnouncement::TYPE | msgs::ChannelUpdate::TYPE | - msgs::NodeAnnouncement::TYPE => true, + msgs::NodeAnnouncement::TYPE | + msgs::QueryChannelRange::TYPE | + msgs::ReplyChannelRange::TYPE | + msgs::QueryShortChannelIds::TYPE | + msgs::ReplyShortChannelIdsEnd::TYPE => true, _ => false } } #[cfg(test)] mod tests { - use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler}; + use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses}; use ln::msgs; + use ln::msgs::NetAddress; use util::events; use util::test_utils; @@ -1740,13 +1814,15 @@ mod tests { let a_id = PublicKey::from_secret_key(&secp_ctx, &peer_a.our_node_secret); let mut fd_a = FileDescriptor { fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())) }; let mut fd_b = FileDescriptor { fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())) }; - let initial_data = peer_b.new_outbound_connection(a_id, fd_b.clone()).unwrap(); - peer_a.new_inbound_connection(fd_a.clone()).unwrap(); + let initial_data = peer_b.new_outbound_connection(a_id, fd_b.clone(), None).unwrap(); + peer_a.new_inbound_connection(fd_a.clone(), None).unwrap(); assert_eq!(peer_a.read_event(&mut fd_a, &initial_data).unwrap(), false); peer_a.process_events(); assert_eq!(peer_b.read_event(&mut fd_b, &fd_a.outbound_data.lock().unwrap().split_off(0)).unwrap(), false); peer_b.process_events(); assert_eq!(peer_a.read_event(&mut fd_a, &fd_b.outbound_data.lock().unwrap().split_off(0)).unwrap(), false); + peer_a.process_events(); + assert_eq!(peer_b.read_event(&mut fd_b, &fd_a.outbound_data.lock().unwrap().split_off(0)).unwrap(), false); (fd_a.clone(), fd_b.clone()) } @@ -1810,21 +1886,21 @@ mod tests { let (mut fd_a, mut fd_b) = establish_connection(&peers[0], &peers[1]); // Make each peer to read the messages that the other peer just wrote to them. Note that - // due to the max-messagse-before-ping limits this may take a few iterations to complete. + // due to the max-message-before-ping limits this may take a few iterations to complete. for _ in 0..150/super::BUFFER_DRAIN_MSGS_PER_TICK + 1 { - peers[0].process_events(); - let b_read_data = fd_a.outbound_data.lock().unwrap().split_off(0); - assert!(!b_read_data.is_empty()); - - peers[1].read_event(&mut fd_b, &b_read_data).unwrap(); peers[1].process_events(); - let a_read_data = fd_b.outbound_data.lock().unwrap().split_off(0); assert!(!a_read_data.is_empty()); + peers[0].read_event(&mut fd_a, &a_read_data).unwrap(); + peers[0].process_events(); - peers[1].process_events(); - assert_eq!(fd_b.outbound_data.lock().unwrap().len(), 0, "Until B receives data, it shouldn't send more messages"); + let b_read_data = fd_a.outbound_data.lock().unwrap().split_off(0); + assert!(!b_read_data.is_empty()); + peers[1].read_event(&mut fd_b, &b_read_data).unwrap(); + + peers[0].process_events(); + assert_eq!(fd_a.outbound_data.lock().unwrap().len(), 0, "Until A receives data, it shouldn't send more messages"); } // Check that each peer has received the expected number of channel updates and channel @@ -1848,8 +1924,8 @@ mod tests { let a_id = PublicKey::from_secret_key(&secp_ctx, &peers[0].our_node_secret); let mut fd_a = FileDescriptor { fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())) }; let mut fd_b = FileDescriptor { fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())) }; - let initial_data = peers[1].new_outbound_connection(a_id, fd_b.clone()).unwrap(); - peers[0].new_inbound_connection(fd_a.clone()).unwrap(); + let initial_data = peers[1].new_outbound_connection(a_id, fd_b.clone(), None).unwrap(); + peers[0].new_inbound_connection(fd_a.clone(), None).unwrap(); // If we get a single timer tick before completion, that's fine assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); @@ -1867,4 +1943,100 @@ mod tests { assert!(peers[0].read_event(&mut fd_a, &fd_b.outbound_data.lock().unwrap().split_off(0)).is_err()); } + + #[test] + fn test_filter_addresses(){ + // Tests the filter_addresses function. + + // For (10/8) + let ip_address = NetAddress::IPv4{addr: [10, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [10, 0, 255, 201], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [10, 255, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (0/8) + let ip_address = NetAddress::IPv4{addr: [0, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [0, 0, 255, 187], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [0, 255, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (100.64/10) + let ip_address = NetAddress::IPv4{addr: [100, 64, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [100, 78, 255, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [100, 127, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (127/8) + let ip_address = NetAddress::IPv4{addr: [127, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [127, 65, 73, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [127, 255, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (169.254/16) + let ip_address = NetAddress::IPv4{addr: [169, 254, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [169, 254, 221, 101], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [169, 254, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (172.16/12) + let ip_address = NetAddress::IPv4{addr: [172, 16, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [172, 27, 101, 23], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [172, 31, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (192.168/16) + let ip_address = NetAddress::IPv4{addr: [192, 168, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [192, 168, 205, 159], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [192, 168, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (192.88.99/24) + let ip_address = NetAddress::IPv4{addr: [192, 88, 99, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [192, 88, 99, 140], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv4{addr: [192, 88, 99, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For other IPv4 addresses + let ip_address = NetAddress::IPv4{addr: [188, 255, 99, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + let ip_address = NetAddress::IPv4{addr: [123, 8, 129, 14], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + let ip_address = NetAddress::IPv4{addr: [2, 88, 9, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + + // For (2000::/3) + let ip_address = NetAddress::IPv6{addr: [32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + let ip_address = NetAddress::IPv6{addr: [45, 34, 209, 190, 0, 123, 55, 34, 0, 0, 3, 27, 201, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + let ip_address = NetAddress::IPv6{addr: [63, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), Some(ip_address.clone())); + + // For other IPv6 addresses + let ip_address = NetAddress::IPv6{addr: [24, 240, 12, 32, 0, 0, 0, 0, 20, 97, 0, 32, 121, 254, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv6{addr: [68, 23, 56, 63, 0, 0, 2, 7, 75, 109, 0, 39, 0, 0, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + let ip_address = NetAddress::IPv6{addr: [101, 38, 140, 230, 100, 0, 30, 98, 0, 26, 0, 0, 57, 96, 0, 0], port: 1000}; + assert_eq!(filter_addresses(Some(ip_address.clone())), None); + + // For (None) + assert_eq!(filter_addresses(None), None); + } }