X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=c09df17525972ea242fefc1184a5babf070c9802;hb=f53d13bcb8220b3ce39e51a4d20beb23b3930d1f;hp=86cd344ce352dea1544f27d894a94813a6ca3930;hpb=89cbb6d74b32b1d23090761dec216c942a846a04;p=rust-lightning diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 86cd344c..c09df175 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(()) } @@ -307,12 +307,12 @@ const OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP: usize = OUTBOUND_BUFFER_LIMIT_READ_PAUS /// Thus, to avoid needlessly disconnecting a peer, we allow a peer to take this many timer ticks /// per connected peer to respond to a ping, as long as they send us at least one message during /// each tick, ensuring we aren't actually just disconnected. -/// With a timer tick interval of five seconds, this translates to about 30 seconds per connected +/// With a timer tick interval of ten seconds, this translates to about 40 seconds per connected /// peer. /// /// When we improve parallelism somewhat we should reduce this to e.g. this many timer ticks per /// two connected peers, assuming most LDK-running systems have at least two cores. -const MAX_BUFFER_DRAIN_TICK_INTERVALS_PER_PEER: i8 = 6; +const MAX_BUFFER_DRAIN_TICK_INTERVALS_PER_PEER: i8 = 4; /// This is the minimum number of messages we expect a peer to be able to handle within one timer /// tick. Once we have sent this many messages since the last ping, we send a ping right away to @@ -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, @@ -376,6 +377,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 +387,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 +500,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 +578,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 +594,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 +604,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, @@ -583,7 +625,12 @@ impl P 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 +641,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 +650,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, @@ -864,7 +912,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 +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; }, @@ -902,7 +950,11 @@ impl P Ok(x) => x, Err(e) => { match e { - (msgs::DecodeError::UnknownRequiredFeature, _) => { + // Note that to avoid recursion we never call + // `do_attempt_write_data` from here, causing + // the messages enqueued here to not actually + // be sent before the peer is disconnected. + (msgs::DecodeError::UnknownRequiredFeature, Some(ty)) if is_gossip_msg(ty) => { log_gossip!(self.logger, "Got a channel/node announcement with an unknown required feature flag, you may want to update!"); continue; } @@ -916,6 +968,11 @@ impl P self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: "Unreadable/bogus gossip message".to_owned() }); continue; } + (msgs::DecodeError::UnknownRequiredFeature, ty) => { + log_gossip!(self.logger, "Received a message with an unknown required feature flag or TLV, you may want to update!"); + self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: format!("Received an unknown required feature/TLV in message type {:?}", ty) }); + return Err(PeerHandleError { no_connection_possible: false }); + } (msgs::DecodeError::UnknownVersion, _) => return Err(PeerHandleError { no_connection_possible: false }), (msgs::DecodeError::InvalidValue, _) => { log_debug!(self.logger, "Got an invalid value while deserializing message"); @@ -1009,7 +1066,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); @@ -1468,6 +1525,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); + } } } @@ -1563,9 +1623,9 @@ impl P /// Send pings to each peer and disconnect those which did not respond to the last round of /// pings. /// - /// This may be called on any timescale you want, however, roughly once every five to ten - /// seconds is preferred. The call rate determines both how often we send a ping to our peers - /// and how much time they have to respond before we disconnect them. + /// This may be called on any timescale you want, however, roughly once every ten seconds is + /// preferred. The call rate determines both how often we send a ping to our peers and how much + /// time they have to respond before we disconnect them. /// /// May call [`send_data`] on all [`SocketDescriptor`]s. Thus, be very careful with reentrancy /// issues! @@ -1647,15 +1707,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; @@ -1731,8 +1796,8 @@ 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); @@ -1839,8 +1904,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); @@ -1858,4 +1923,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); + } }