X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fgossip.rs;h=49a76328659faa379b88d904d07db2a6ba3848be;hb=db489baee24cf53647d1a78360b2e643cc8d2542;hp=2fbbcb147d075aa64cf4d5b2fc5ca64aae009c1f;hpb=36e434d8cefe6b533a2ab378d2d65923433df373;p=rust-lightning diff --git a/lightning/src/routing/gossip.rs b/lightning/src/routing/gossip.rs index 2fbbcb14..49a76328 100644 --- a/lightning/src/routing/gossip.rs +++ b/lightning/src/routing/gossip.rs @@ -21,7 +21,7 @@ use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; use crate::events::{MessageSendEvent, MessageSendEventsProvider}; -use crate::ln::ChannelId; +use crate::ln::types::ChannelId; use crate::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures}; use crate::ln::msgs::{DecodeError, ErrorAction, Init, LightningError, RoutingMessageHandler, SocketAddress, MAX_VALUE_MSAT}; use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, GossipTimestampFilter}; @@ -38,7 +38,6 @@ use crate::io; use crate::io_extras::{copy, sink}; use crate::prelude::*; use core::{cmp, fmt}; -use core::convert::TryFrom; use crate::sync::{RwLock, RwLockReadGuard, LockTestExt}; #[cfg(feature = "std")] use core::sync::atomic::{AtomicUsize, Ordering}; @@ -74,6 +73,16 @@ impl NodeId { NodeId(pubkey.serialize()) } + /// Create a new NodeId from a slice of bytes + pub fn from_slice(bytes: &[u8]) -> Result { + if bytes.len() != PUBLIC_KEY_SIZE { + return Err(DecodeError::InvalidValue); + } + let mut data = [0; PUBLIC_KEY_SIZE]; + data.copy_from_slice(bytes); + Ok(NodeId(data)) + } + /// Get the public key slice from this NodeId pub fn as_slice(&self) -> &[u8] { &self.0 @@ -495,8 +504,8 @@ where U::Target: UtxoLookup, L::Target: Logger }; for (_, ref node) in iter { if let Some(node_info) = node.announcement_info.as_ref() { - if let Some(msg) = node_info.announcement_message.clone() { - return Some(msg); + if let NodeAnnouncementInfo::Relayed(announcement) = node_info { + return Some(announcement.clone()); } } } @@ -1121,45 +1130,136 @@ impl_writeable_tlv_based!(RoutingFees, { }); #[derive(Clone, Debug, PartialEq, Eq)] -/// Information received in the latest node_announcement from this node. -pub struct NodeAnnouncementInfo { +/// Non-relayable information received in the latest node_announcement from this node. +pub struct NodeAnnouncementDetails { /// Protocol features the node announced support for pub features: NodeFeatures, + /// When the last known update to the node state was issued. /// Value is opaque, as set in the announcement. pub last_update: u32, + /// Color assigned to the node pub rgb: [u8; 3], + /// Moniker assigned to the node. /// May be invalid or malicious (eg control chars), /// should not be exposed to the user. pub alias: NodeAlias, + + /// Internet-level addresses via which one can connect to the node + pub addresses: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +/// Information received in the latest node_announcement from this node. +pub enum NodeAnnouncementInfo { /// An initial announcement of the node - /// Mostly redundant with the data we store in fields explicitly. /// Everything else is useful only for sending out for initial routing sync. /// Not stored if contains excess data to prevent DoS. - pub announcement_message: Option + Relayed(NodeAnnouncement), + + /// Non-relayable information received in the latest node_announcement from this node. + Local(NodeAnnouncementDetails), } impl NodeAnnouncementInfo { + + /// Protocol features the node announced support for + pub fn features(&self) -> &NodeFeatures { + match self { + NodeAnnouncementInfo::Relayed(relayed) => { + &relayed.contents.features + } + NodeAnnouncementInfo::Local(local) => { + &local.features + } + } + } + + /// When the last known update to the node state was issued. + /// + /// Value may or may not be a timestamp, depending on the policy of the origin node. + pub fn last_update(&self) -> u32 { + match self { + NodeAnnouncementInfo::Relayed(relayed) => { + relayed.contents.timestamp + } + NodeAnnouncementInfo::Local(local) => { + local.last_update + } + } + } + + /// Color assigned to the node + pub fn rgb(&self) -> [u8; 3] { + match self { + NodeAnnouncementInfo::Relayed(relayed) => { + relayed.contents.rgb + } + NodeAnnouncementInfo::Local(local) => { + local.rgb + } + } + } + + /// Moniker assigned to the node. + /// + /// May be invalid or malicious (eg control chars), should not be exposed to the user. + pub fn alias(&self) -> &NodeAlias { + match self { + NodeAnnouncementInfo::Relayed(relayed) => { + &relayed.contents.alias + } + NodeAnnouncementInfo::Local(local) => { + &local.alias + } + } + } + /// Internet-level addresses via which one can connect to the node - pub fn addresses(&self) -> &[SocketAddress] { - self.announcement_message.as_ref() - .map(|msg| msg.contents.addresses.as_slice()) - .unwrap_or_default() + pub fn addresses(&self) -> &Vec { + match self { + NodeAnnouncementInfo::Relayed(relayed) => { + &relayed.contents.addresses + } + NodeAnnouncementInfo::Local(local) => { + &local.addresses + } + } + } + + /// An initial announcement of the node + /// + /// Not stored if contains excess data to prevent DoS. + pub fn announcement_message(&self) -> Option<&NodeAnnouncement> { + match self { + NodeAnnouncementInfo::Relayed(announcement) => { + Some(announcement) + } + NodeAnnouncementInfo::Local(_) => { + None + } + } } } impl Writeable for NodeAnnouncementInfo { fn write(&self, writer: &mut W) -> Result<(), io::Error> { - let empty_addresses = Vec::::new(); + let features = self.features(); + let last_update = self.last_update(); + let rgb = self.rgb(); + let alias = self.alias(); + let addresses = self.addresses(); + let announcement_message = self.announcement_message(); + write_tlv_fields!(writer, { - (0, self.features, required), - (2, self.last_update, required), - (4, self.rgb, required), - (6, self.alias, required), - (8, self.announcement_message, option), - (10, empty_addresses, required_vec), // Versions prior to 0.0.115 require this field + (0, features, required), + (2, last_update, required), + (4, rgb, required), + (6, alias, required), + (8, announcement_message, option), + (10, *addresses, required_vec), // Versions 0.0.115 through 0.0.123 only serialized an empty vec }); Ok(()) } @@ -1173,11 +1273,19 @@ impl Readable for NodeAnnouncementInfo { (4, rgb, required), (6, alias, required), (8, announcement_message, option), - (10, _addresses, optional_vec), // deprecated, not used anymore + (10, addresses, required_vec), }); - let _: Option> = _addresses; - Ok(Self { features: features.0.unwrap(), last_update: last_update.0.unwrap(), rgb: rgb.0.unwrap(), - alias: alias.0.unwrap(), announcement_message }) + if let Some(announcement) = announcement_message { + Ok(Self::Relayed(announcement)) + } else { + Ok(Self::Local(NodeAnnouncementDetails { + features: features.0.unwrap(), + last_update: last_update.0.unwrap(), + rgb: rgb.0.unwrap(), + alias: alias.0.unwrap(), + addresses, + })) + } } } @@ -1231,6 +1339,18 @@ pub struct NodeInfo { pub announcement_info: Option } +impl NodeInfo { + /// Returns whether the node has only announced Tor addresses. + pub fn is_tor_only(&self) -> bool { + self.announcement_info + .as_ref() + .map(|info| info.addresses()) + .and_then(|addresses| (!addresses.is_empty()).then(|| addresses)) + .map(|addresses| addresses.iter().all(|address| address.is_tor())) + .unwrap_or(false) + } +} + impl fmt::Display for NodeInfo { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { write!(f, " channels: {:?}, announcement_info: {:?}", @@ -1467,24 +1587,29 @@ impl NetworkGraph where L::Target: Logger { // The timestamp field is somewhat of a misnomer - the BOLTs use it to order // updates to ensure you always have the latest one, only vaguely suggesting // that it be at least the current time. - if node_info.last_update > msg.timestamp { + if node_info.last_update() > msg.timestamp { return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); - } else if node_info.last_update == msg.timestamp { + } else if node_info.last_update() == msg.timestamp { return Err(LightningError{err: "Update had the same timestamp as last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); } } let should_relay = msg.excess_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY && - msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY && - msg.excess_data.len() + msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY; - node.announcement_info = Some(NodeAnnouncementInfo { - features: msg.features.clone(), - last_update: msg.timestamp, - rgb: msg.rgb, - alias: msg.alias, - announcement_message: if should_relay { full_msg.cloned() } else { None }, - }); + msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY && + msg.excess_data.len() + msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY; + + node.announcement_info = if let (Some(signed_announcement), true) = (full_msg, should_relay) { + Some(NodeAnnouncementInfo::Relayed(signed_announcement.clone())) + } else { + Some(NodeAnnouncementInfo::Local(NodeAnnouncementDetails { + features: msg.features.clone(), + last_update: msg.timestamp, + rgb: msg.rgb, + alias: msg.alias, + addresses: msg.addresses.clone(), + })) + }; Ok(()) } @@ -2089,6 +2214,7 @@ pub(crate) mod tests { use crate::ln::chan_utils::make_funding_redeemscript; #[cfg(feature = "std")] use crate::ln::features::InitFeatures; + use crate::ln::msgs::SocketAddress; use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo, NodeAnnouncementInfo, NodeInfo}; use crate::routing::utxo::{UtxoLookupError, UtxoResult}; use crate::ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement, @@ -2096,7 +2222,7 @@ pub(crate) mod tests { ReplyChannelRange, QueryChannelRange, QueryShortChannelIds, MAX_VALUE_MSAT}; use crate::util::config::UserConfig; use crate::util::test_utils; - use crate::util::ser::{ReadableArgs, Readable, Writeable}; + use crate::util::ser::{Hostname, ReadableArgs, Readable, Writeable}; use crate::util::scid_utils::scid_from_parts; use crate::routing::gossip::REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS; @@ -3426,13 +3552,7 @@ pub(crate) mod tests { // 1. Check we can read a valid NodeAnnouncementInfo and fail on an invalid one let announcement_message = >::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a000122013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010000701fffefdfc2607").unwrap(); let announcement_message = NodeAnnouncement::read(&mut announcement_message.as_slice()).unwrap(); - let valid_node_ann_info = NodeAnnouncementInfo { - features: channelmanager::provided_node_features(&UserConfig::default()), - last_update: 0, - rgb: [0u8; 3], - alias: NodeAlias([0u8; 32]), - announcement_message: Some(announcement_message) - }; + let valid_node_ann_info = NodeAnnouncementInfo::Relayed(announcement_message); let mut encoded_valid_node_ann_info = Vec::new(); assert!(valid_node_ann_info.write(&mut encoded_valid_node_ann_info).is_ok()); @@ -3465,8 +3585,8 @@ pub(crate) mod tests { let old_ann_info_with_addresses = >::from_hex("3f0009000708a000080a51220204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014104d2").unwrap(); let ann_info_with_addresses = NodeAnnouncementInfo::read(&mut old_ann_info_with_addresses.as_slice()) .expect("to be able to read an old NodeAnnouncementInfo with addresses"); - // This serialized info has an address field but no announcement_message, therefore the addresses returned by our function will still be empty - assert!(ann_info_with_addresses.addresses().is_empty()); + // This serialized info has no announcement_message but its address field should still be considered + assert!(!ann_info_with_addresses.addresses().is_empty()); } #[test] @@ -3474,6 +3594,112 @@ pub(crate) mod tests { let node_id = NodeId([42; 33]); assert_eq!(format!("{}", &node_id), "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"); } + + #[test] + fn is_tor_only_node() { + let network_graph = create_network_graph(); + let (secp_ctx, gossip_sync) = create_gossip_sync(&network_graph); + + let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap(); + let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap(); + let node_1_id = NodeId::from_pubkey(&PublicKey::from_secret_key(&secp_ctx, node_1_privkey)); + + let announcement = get_signed_channel_announcement(|_| {}, node_1_privkey, node_2_privkey, &secp_ctx); + gossip_sync.handle_channel_announcement(&announcement).unwrap(); + + let tcp_ip_v4 = SocketAddress::TcpIpV4 { + addr: [255, 254, 253, 252], + port: 9735 + }; + let tcp_ip_v6 = SocketAddress::TcpIpV6 { + addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240], + port: 9735 + }; + let onion_v2 = SocketAddress::OnionV2([255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]); + let onion_v3 = SocketAddress::OnionV3 { + ed25519_pubkey: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224], + checksum: 32, + version: 16, + port: 9735 + }; + let hostname = SocketAddress::Hostname { + hostname: Hostname::try_from(String::from("host")).unwrap(), + port: 9735, + }; + + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement(|_| {}, node_1_privkey, &secp_ctx); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![ + tcp_ip_v4.clone(), tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone(), + hostname.clone() + ]; + announcement.timestamp += 1000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![ + tcp_ip_v4.clone(), tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone() + ]; + announcement.timestamp += 2000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![ + tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone() + ]; + announcement.timestamp += 3000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![onion_v2.clone(), onion_v3.clone()]; + announcement.timestamp += 4000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![onion_v2.clone()]; + announcement.timestamp += 5000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + + let announcement = get_signed_node_announcement( + |announcement| { + announcement.addresses = vec![tcp_ip_v4.clone()]; + announcement.timestamp += 6000; + }, + node_1_privkey, &secp_ctx + ); + gossip_sync.handle_node_announcement(&announcement).unwrap(); + assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only()); + } } #[cfg(ldk_bench)]