X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fgossip.rs;h=c7908d0040c1283347155b32ee7bcd95d8db0720;hb=a9dcfaf952584ed835d733cb4688d5f96e86349d;hp=b7aff2e6ced7555e24c20cbfc59d658dac664381;hpb=993cd1e5253d62abb3ef23a3e58de121139e8fce;p=rust-lightning diff --git a/lightning/src/routing/gossip.rs b/lightning/src/routing/gossip.rs index b7aff2e6..c7908d00 100644 --- a/lightning/src/routing/gossip.rs +++ b/lightning/src/routing/gossip.rs @@ -12,39 +12,39 @@ use bitcoin::amount::Amount; use bitcoin::blockdata::constants::ChainHash; +use bitcoin::secp256k1; use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE; -use bitcoin::secp256k1::{PublicKey, Verification}; use bitcoin::secp256k1::Secp256k1; -use bitcoin::secp256k1; +use bitcoin::secp256k1::{PublicKey, Verification}; use bitcoin::hashes::sha256d::Hash as Sha256dHash; use bitcoin::hashes::Hash; use bitcoin::network::Network; use crate::events::{MessageSendEvent, MessageSendEventsProvider}; -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}; -use crate::ln::msgs::{QueryChannelRange, ReplyChannelRange, QueryShortChannelIds, ReplyShortChannelIdsEnd}; +use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; use crate::ln::msgs; +use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, GossipTimestampFilter, NodeAnnouncement}; +use crate::ln::msgs::{DecodeError, ErrorAction, Init, LightningError, RoutingMessageHandler, SocketAddress, MAX_VALUE_MSAT}; +use crate::ln::msgs::{QueryChannelRange, QueryShortChannelIds, ReplyChannelRange, ReplyShortChannelIdsEnd}; +use crate::ln::types::ChannelId; use crate::routing::utxo::{self, UtxoLookup, UtxoResolver}; -use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer, MaybeReadable}; -use crate::util::logger::{Logger, Level}; +use crate::util::indexed_map::{Entry as IndexedMapEntry, IndexedMap}; +use crate::util::logger::{Level, Logger}; use crate::util::scid_utils::{block_from_scid, scid_from_parts, MAX_SCID_BLOCK}; +use crate::util::ser::{MaybeReadable, Readable, ReadableArgs, RequiredWrapper, Writeable, Writer}; use crate::util::string::PrintableString; -use crate::util::indexed_map::{IndexedMap, Entry as IndexedMapEntry}; use crate::io; use crate::io_extras::{copy, sink}; use crate::prelude::*; -use core::{cmp, fmt}; -use crate::sync::{RwLock, RwLockReadGuard, LockTestExt}; -#[cfg(feature = "std")] -use core::sync::atomic::{AtomicUsize, Ordering}; use crate::sync::Mutex; +use crate::sync::{LockTestExt, RwLock, RwLockReadGuard}; use core::ops::{Bound, Deref}; use core::str::FromStr; +#[cfg(feature = "std")] +use core::sync::atomic::{AtomicUsize, Ordering}; +use core::{cmp, fmt}; #[cfg(feature = "std")] use std::time::{SystemTime, UNIX_EPOCH}; @@ -219,12 +219,6 @@ pub struct ReadOnlyNetworkGraph<'a> { /// [BOLT #4]: https://github.com/lightning/bolts/blob/master/04-onion-routing.md #[derive(Clone, Debug, PartialEq, Eq)] pub enum NetworkUpdate { - /// An error indicating a `channel_update` messages should be applied via - /// [`NetworkGraph::update_channel`]. - ChannelUpdateMessage { - /// The update to apply via [`NetworkGraph::update_channel`]. - msg: ChannelUpdate, - }, /// An error indicating that a channel failed to route a payment, which should be applied via /// [`NetworkGraph::channel_failed_permanent`] if permanent. ChannelFailure { @@ -245,19 +239,69 @@ pub enum NetworkUpdate { } } -impl_writeable_tlv_based_enum_upgradable!(NetworkUpdate, - (0, ChannelUpdateMessage) => { - (0, msg, required), - }, - (2, ChannelFailure) => { - (0, short_channel_id, required), - (2, is_permanent, required), - }, - (4, NodeFailure) => { - (0, node_id, required), - (2, is_permanent, required), - }, -); +impl Writeable for NetworkUpdate { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { + match self { + Self::ChannelFailure { short_channel_id, is_permanent } => { + 2u8.write(writer)?; + write_tlv_fields!(writer, { + (0, short_channel_id, required), + (2, is_permanent, required), + }); + }, + Self::NodeFailure { node_id, is_permanent } => { + 4u8.write(writer)?; + write_tlv_fields!(writer, { + (0, node_id, required), + (2, is_permanent, required), + }); + } + } + Ok(()) + } +} + +impl MaybeReadable for NetworkUpdate { + fn read(reader: &mut R) -> Result, DecodeError> { + let id: u8 = Readable::read(reader)?; + match id { + 0 => { + // 0 was previously used for network updates containing a channel update, subsequently + // removed in LDK version 0.0.124. + let mut msg: RequiredWrapper = RequiredWrapper(None); + read_tlv_fields!(reader, { + (0, msg, required), + }); + Ok(Some(Self::ChannelFailure { + short_channel_id: msg.0.unwrap().contents.short_channel_id, + is_permanent: false + })) + }, + 2 => { + _init_and_read_len_prefixed_tlv_fields!(reader, { + (0, short_channel_id, required), + (2, is_permanent, required), + }); + Ok(Some(Self::ChannelFailure { + short_channel_id: short_channel_id.0.unwrap(), + is_permanent: is_permanent.0.unwrap(), + })) + }, + 4 => { + _init_and_read_len_prefixed_tlv_fields!(reader, { + (0, node_id, required), + (2, is_permanent, required), + }); + Ok(Some(Self::NodeFailure { + node_id: node_id.0.unwrap(), + is_permanent: is_permanent.0.unwrap(), + })) + } + t if t % 2 == 0 => Err(DecodeError::UnknownRequiredFeature), + _ => Ok(None), + } + } +} /// Receives and validates network updates from peers, /// stores authentic and relevant data as a network graph. @@ -354,19 +398,10 @@ where U::Target: UtxoLookup, L::Target: Logger impl NetworkGraph where L::Target: Logger { /// Handles any network updates originating from [`Event`]s. - // - /// Note that this will skip applying any [`NetworkUpdate::ChannelUpdateMessage`] to avoid - /// leaking possibly identifying information of the sender to the public network. /// /// [`Event`]: crate::events::Event pub fn handle_network_update(&self, network_update: &NetworkUpdate) { match *network_update { - NetworkUpdate::ChannelUpdateMessage { ref msg } => { - let short_channel_id = msg.contents.short_channel_id; - let is_enabled = msg.contents.flags & (1 << 1) != (1 << 1); - let status = if is_enabled { "enabled" } else { "disabled" }; - log_debug!(self.logger, "Skipping application of a channel update from a payment failure. Channel {} is {}.", short_channel_id, status); - }, NetworkUpdate::ChannelFailure { short_channel_id, is_permanent } => { if is_permanent { log_debug!(self.logger, "Removing channel graph entry for {} due to a payment failure.", short_channel_id); @@ -505,8 +540,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()); } } } @@ -1135,45 +1170,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(()) } @@ -1187,11 +1313,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, + })) + } } } @@ -1493,24 +1627,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(()) } @@ -2577,8 +2716,7 @@ pub(crate) mod tests { let short_channel_id; { - // Check we won't apply an update via `handle_network_update` for privacy reasons, but - // can continue fine if we manually apply it. + // Check that we can manually apply a channel update. let valid_channel_announcement = get_signed_channel_announcement(|_| {}, node_1_privkey, node_2_privkey, &secp_ctx); short_channel_id = valid_channel_announcement.contents.short_channel_id; let chain_source: Option<&test_utils::TestChainSource> = None; @@ -2586,14 +2724,10 @@ pub(crate) mod tests { assert!(network_graph.read_only().channels().get(&short_channel_id).is_some()); let valid_channel_update = get_signed_channel_update(|_| {}, node_1_privkey, &secp_ctx); - assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_none()); - - network_graph.handle_network_update(&NetworkUpdate::ChannelUpdateMessage { - msg: valid_channel_update.clone(), - }); assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_none()); network_graph.update_channel(&valid_channel_update).unwrap(); + assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_some()); } // Non-permanent failure doesn't touch the channel at all @@ -3454,13 +3588,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()); @@ -3493,8 +3621,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]