X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fmsgs.rs;h=b50e35b96dc14c62966aab1e8a3c85ca19097bd7;hb=c906f2843234ba9164e562a19bccaabde0243d95;hp=cccbf83acd2a740271f8d962e67d6038c4b61f75;hpb=0ad8fde0d6350d2ab3133c515bc09d39d242fa1a;p=rust-lightning diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs index cccbf83a..b50e35b9 100644 --- a/lightning/src/ln/msgs.rs +++ b/lightning/src/ln/msgs.rs @@ -21,14 +21,15 @@ use secp256k1; use bitcoin_hashes::sha256d::Hash as Sha256dHash; use bitcoin::blockdata::script::Script; +use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; + use std::error::Error; use std::{cmp, fmt}; use std::io::Read; use std::result::Result; -use std::marker::PhantomData; use util::events; -use util::ser::{Readable, Writeable, Writer}; +use util::ser::{Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt}; use ln::channelmanager::{PaymentPreimage, PaymentHash}; @@ -38,10 +39,11 @@ pub enum DecodeError { /// A version byte specified something we don't know how to handle. /// Includes unknown realm byte in an OnionHopData packet UnknownVersion, - /// Unknown feature mandating we fail to parse message + /// Unknown feature mandating we fail to parse message (eg TLV with an even, unknown type) UnknownRequiredFeature, /// Value was invalid, eg a byte which was supposed to be a bool was something other than a 0 - /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, etc + /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was + /// syntactically incorrect, etc InvalidValue, /// Buffer too short ShortRead, @@ -53,233 +55,12 @@ pub enum DecodeError { Io(::std::io::Error), } -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the init message, sent between peers and not -/// rumored around the P2P network. -pub struct FeatureContextInit {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the node_announcement message, as it is -/// rumored around the P2P network. -pub struct FeatureContextNode {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the ChannelAnnouncement message, as it is -/// rumored around the P2P network. -pub struct FeatureContextChannel {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in an invoice, used to determine the different -/// options available for routing a payment. -/// -/// Note that this is currently unused as invoices come to us via a different crate and are not -/// native to rust-lightning directly. -pub struct FeatureContextInvoice {} - -/// An internal trait capturing the various future context types -pub trait FeatureContext {} -impl FeatureContext for FeatureContextInit {} -impl FeatureContext for FeatureContextNode {} -impl FeatureContext for FeatureContextChannel {} -impl FeatureContext for FeatureContextInvoice {} - -/// An internal trait capturing FeatureContextInit and FeatureContextNode -pub trait FeatureContextInitNode : FeatureContext {} -impl FeatureContextInitNode for FeatureContextInit {} -impl FeatureContextInitNode for FeatureContextNode {} - -/// Tracks the set of features which a node implements, templated by the context in which it -/// appears. -pub struct Features { - #[cfg(not(test))] - flags: Vec, - // Used to test encoding of diverse msgs - #[cfg(test)] - pub flags: Vec, - mark: PhantomData, -} - -impl Clone for Features { - fn clone(&self) -> Self { - Self { - flags: self.flags.clone(), - mark: PhantomData, - } - } -} -impl PartialEq for Features { - fn eq(&self, o: &Self) -> bool { - self.flags.eq(&o.flags) - } -} -impl fmt::Debug for Features { - fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { - self.flags.fmt(fmt) - } -} - -/// A feature message as it appears in an init message -pub type InitFeatures = Features; -/// A feature message as it appears in a node_announcement message -pub type NodeFeatures = Features; -/// A feature message as it appears in a channel_announcement message -pub type ChannelFeatures = Features; - -impl Features { - /// Create a blank Features flags (visibility extended for fuzz tests) - #[cfg(not(feature = "fuzztarget"))] - pub(crate) fn new() -> Features { - Features { - flags: vec![2 | 1 << 5], - mark: PhantomData, - } - } - #[cfg(feature = "fuzztarget")] - pub fn new() -> Features { - Features { - flags: vec![2 | 1 << 5], - mark: PhantomData, - } - } -} - -impl Features { - /// Create a blank Features flags (visibility extended for fuzz tests) - #[cfg(not(feature = "fuzztarget"))] - pub(crate) fn new() -> Features { - Features { - flags: Vec::new(), - mark: PhantomData, - } - } - #[cfg(feature = "fuzztarget")] - pub fn new() -> Features { - Features { - flags: Vec::new(), - mark: PhantomData, - } - } -} - -impl Features { - pub(crate) fn requires_unknown_bits(&self) -> bool { - self.flags.iter().enumerate().any(|(idx, &byte)| { - ( idx != 0 && (byte & 0x55) != 0 ) || ( idx == 0 && (byte & 0x14) != 0 ) - }) - } - - pub(crate) fn supports_unknown_bits(&self) -> bool { - self.flags.iter().enumerate().any(|(idx, &byte)| { - ( idx != 0 && byte != 0 ) || ( idx == 0 && (byte & 0xc4) != 0 ) - }) - } - - /// The number of bytes required to represent the feaature flags present. This does not include - /// the length bytes which are included in the serialized form. - pub(crate) fn byte_count(&self) -> usize { - self.flags.len() - } - - #[cfg(test)] - pub(crate) fn set_require_unknown_bits(&mut self) { - let newlen = cmp::max(2, self.flags.len()); - self.flags.resize(newlen, 0u8); - self.flags[1] |= 0x40; - } - - #[cfg(test)] - pub(crate) fn clear_require_unknown_bits(&mut self) { - let newlen = cmp::max(2, self.flags.len()); - self.flags.resize(newlen, 0u8); - self.flags[1] &= !0x40; - if self.flags.len() == 2 && self.flags[1] == 0 { - self.flags.resize(1, 0u8); - } - } -} - -impl Features { - pub(crate) fn supports_data_loss_protect(&self) -> bool { - self.flags.len() > 0 && (self.flags[0] & 3) != 0 - } - - pub(crate) fn supports_upfront_shutdown_script(&self) -> bool { - self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0 - } - #[cfg(test)] - pub(crate) fn unset_upfront_shutdown_script(&mut self) { - self.flags[0] ^= 1 << 5; - } -} - -impl Features { - pub(crate) fn initial_routing_sync(&self) -> bool { - self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0 - } - pub(crate) fn set_initial_routing_sync(&mut self) { - if self.flags.len() == 0 { - self.flags.resize(1, 1 << 3); - } else { - self.flags[0] |= 1 << 3; - } - } - - /// Writes all features present up to, and including, 13. - pub(crate) fn write_up_to_13(&self, w: &mut W) -> Result<(), ::std::io::Error> { - let len = cmp::min(2, self.flags.len()); - w.size_hint(len + 2); - (len as u16).write(w)?; - for i in (0..len).rev() { - if i == 0 { - self.flags[i].write(w)?; - } else { - (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?; - } - } - Ok(()) - } - - /// or's another InitFeatures into this one. - pub(crate) fn or(&mut self, o: &InitFeatures) { - let total_feature_len = cmp::max(self.flags.len(), o.flags.len()); - self.flags.resize(total_feature_len, 0u8); - for (feature, o_feature) in self.flags.iter_mut().zip(o.flags.iter()) { - *feature |= *o_feature; - } - } -} - -impl Writeable for Features { - fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { - w.size_hint(self.flags.len() + 2); - self.flags.write(w) - } -} - -impl Readable for Features { - fn read(r: &mut R) -> Result { - Ok(Self { - flags: Readable::read(r)?, - mark: PhantomData, - }) - } -} /// An init message to be sent or received from a peer pub struct Init { + #[cfg(not(feature = "fuzztarget"))] pub(crate) features: InitFeatures, + #[cfg(feature = "fuzztarget")] + pub features: InitFeatures, } /// An error message to be sent or received from a peer @@ -362,9 +143,10 @@ pub struct FundingSigned { /// A funding_locked message to be sent or received from a peer #[derive(Clone, PartialEq)] +#[allow(missing_docs)] pub struct FundingLocked { - pub(crate) channel_id: [u8; 32], - pub(crate) next_per_commitment_point: PublicKey, + pub channel_id: [u8; 32], + pub next_per_commitment_point: PublicKey, } /// A shutdown message to be sent or received from a peer @@ -793,7 +575,7 @@ pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Syn fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool); /// Handle a peer reconnecting, possibly generating channel_reestablish message(s). - fn peer_connected(&self, their_node_id: &PublicKey); + fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init); /// Handle an incoming channel_reestablish message from the given peer. fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish); @@ -823,24 +605,29 @@ pub trait RoutingMessageHandler : Send + Sync { /// starting at the node *after* the provided publickey and including batch_amount entries. /// If None is provided for starting_point, we start at the first node. fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec; -} - -pub(crate) struct OnionRealm0HopData { - pub(crate) short_channel_id: u64, - pub(crate) amt_to_forward: u64, - pub(crate) outgoing_cltv_value: u32, - // 12 bytes of 0-padding + /// Returns whether a full sync should be requested from a peer. + fn should_request_full_sync(&self, node_id: &PublicKey) -> bool; } mod fuzzy_internal_msgs { // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize // them from untrusted input): - use super::OnionRealm0HopData; + pub(crate) enum OnionHopDataFormat { + Legacy { // aka Realm-0 + short_channel_id: u64, + }, + NonFinalNode { + short_channel_id: u64, + }, + FinalNode, + } + pub struct OnionHopData { - pub(crate) realm: u8, - pub(crate) data: OnionRealm0HopData, - pub(crate) hmac: [u8; 32], + pub(crate) format: OnionHopDataFormat, + pub(crate) amt_to_forward: u64, + pub(crate) outgoing_cltv_value: u32, + // 12 bytes of 0-padding for Legacy format } pub struct DecodedOnionErrorPacket { @@ -1062,10 +849,9 @@ impl Writeable for Init { impl Readable for Init { fn read(r: &mut R) -> Result { let global_features: InitFeatures = Readable::read(r)?; - let mut features: InitFeatures = Readable::read(r)?; - features.or(&global_features); + let features: InitFeatures = Readable::read(r)?; Ok(Init { - features + features: features.or(global_features), }) } } @@ -1178,53 +964,78 @@ impl_writeable!(UpdateAddHTLC, 32+8+8+32+4+1366, { onion_routing_packet }); -impl Writeable for OnionRealm0HopData { - fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { - w.size_hint(32); - self.short_channel_id.write(w)?; - self.amt_to_forward.write(w)?; - self.outgoing_cltv_value.write(w)?; - w.write_all(&[0;12])?; - Ok(()) - } -} - -impl Readable for OnionRealm0HopData { - fn read(r: &mut R) -> Result { - Ok(OnionRealm0HopData { - short_channel_id: Readable::read(r)?, - amt_to_forward: Readable::read(r)?, - outgoing_cltv_value: { - let v: u32 = Readable::read(r)?; - r.read_exact(&mut [0; 12])?; - v - } - }) - } -} - impl Writeable for OnionHopData { fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { - w.size_hint(65); - self.realm.write(w)?; - self.data.write(w)?; - self.hmac.write(w)?; + w.size_hint(33); + match self.format { + OnionHopDataFormat::Legacy { short_channel_id } => { + 0u8.write(w)?; + short_channel_id.write(w)?; + self.amt_to_forward.write(w)?; + self.outgoing_cltv_value.write(w)?; + w.write_all(&[0;12])?; + }, + OnionHopDataFormat::NonFinalNode { short_channel_id } => { + encode_varint_length_prefixed_tlv!(w, { + (2, HighZeroBytesDroppedVarInt(self.amt_to_forward)), + (4, HighZeroBytesDroppedVarInt(self.outgoing_cltv_value)), + (6, short_channel_id) + }); + }, + OnionHopDataFormat::FinalNode => { + encode_varint_length_prefixed_tlv!(w, { + (2, HighZeroBytesDroppedVarInt(self.amt_to_forward)), + (4, HighZeroBytesDroppedVarInt(self.outgoing_cltv_value)) + }); + }, + } Ok(()) } } impl Readable for OnionHopData { - fn read(r: &mut R) -> Result { - Ok(OnionHopData { - realm: { - let r: u8 = Readable::read(r)?; - if r != 0 { - return Err(DecodeError::UnknownVersion); + fn read(mut r: &mut R) -> Result { + use bitcoin::consensus::encode::{Decodable, Error, VarInt}; + let v: VarInt = Decodable::consensus_decode(&mut r) + .map_err(|e| match e { + Error::Io(ioe) => DecodeError::from(ioe), + _ => DecodeError::InvalidValue + })?; + const LEGACY_ONION_HOP_FLAG: u64 = 0; + let (format, amt, cltv_value) = if v.0 != LEGACY_ONION_HOP_FLAG { + let mut rd = FixedLengthReader::new(r, v.0); + let mut amt = HighZeroBytesDroppedVarInt(0u64); + let mut cltv_value = HighZeroBytesDroppedVarInt(0u32); + let mut short_id: Option = None; + decode_tlv!(&mut rd, { + (2, amt), + (4, cltv_value) + }, { + (6, short_id) + }); + rd.eat_remaining().map_err(|_| DecodeError::ShortRead)?; + let format = if let Some(short_channel_id) = short_id { + OnionHopDataFormat::NonFinalNode { + short_channel_id, } - r - }, - data: Readable::read(r)?, - hmac: Readable::read(r)?, + } else { + OnionHopDataFormat::FinalNode + }; + (format, amt.0, cltv_value.0) + } else { + let format = OnionHopDataFormat::Legacy { + short_channel_id: Readable::read(r)?, + }; + let amt: u64 = Readable::read(r)?; + let cltv_value: u32 = Readable::read(r)?; + r.read_exact(&mut [0; 12])?; + (format, amt, cltv_value) + }; + + Ok(OnionHopData { + format, + amt_to_forward: amt, + outgoing_cltv_value: cltv_value, }) } } @@ -1510,9 +1321,9 @@ impl_writeable_len_match!(NodeAnnouncement, { mod tests { use hex; use ln::msgs; - use ln::msgs::{ChannelFeatures, InitFeatures, NodeFeatures, OptionalField, OnionErrorPacket}; + use ln::msgs::{ChannelFeatures, InitFeatures, NodeFeatures, OptionalField, OnionErrorPacket, OnionHopDataFormat}; use ln::channelmanager::{PaymentPreimage, PaymentHash}; - use util::ser::Writeable; + use util::ser::{Writeable, Readable}; use bitcoin_hashes::sha256d::Hash as Sha256dHash; use bitcoin_hashes::hex::FromHex; @@ -1524,7 +1335,7 @@ mod tests { use secp256k1::key::{PublicKey,SecretKey}; use secp256k1::{Secp256k1, Message}; - use std::marker::PhantomData; + use std::io::Cursor; #[test] fn encoding_channel_reestablish_no_secret() { @@ -1609,9 +1420,9 @@ mod tests { let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101")); let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101")); let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101")); - let mut features = ChannelFeatures::new(); + let mut features = ChannelFeatures::supported(); if unknown_features_bits { - features.flags = vec![0xFF, 0xFF]; + features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]); } let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement { features, @@ -1665,10 +1476,12 @@ mod tests { let secp_ctx = Secp256k1::new(); let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx); let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101")); - let mut features = NodeFeatures::new(); - if unknown_features_bits { - features.flags = vec![0xFF, 0xFF]; - } + let features = if unknown_features_bits { + NodeFeatures::from_le_bytes(vec![0xFF, 0xFF]) + } else { + // Set to some features we may support + NodeFeatures::from_le_bytes(vec![2 | 1 << 5]) + }; let mut addresses = Vec::new(); if ipv4 { addresses.push(msgs::NetAddress::IPv4 { @@ -2122,22 +1935,13 @@ mod tests { #[test] fn encoding_init() { assert_eq!(msgs::Init { - features: InitFeatures { - flags: vec![0xFF, 0xFF, 0xFF], - mark: PhantomData, - }, + features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]), }.encode(), hex::decode("00023fff0003ffffff").unwrap()); assert_eq!(msgs::Init { - features: InitFeatures { - flags: vec![0xFF], - mark: PhantomData, - }, + features: InitFeatures::from_le_bytes(vec![0xFF]), }.encode(), hex::decode("0001ff0001ff").unwrap()); assert_eq!(msgs::Init { - features: InitFeatures { - flags: vec![], - mark: PhantomData, - }, + features: InitFeatures::from_le_bytes(vec![]), }.encode(), hex::decode("00000000").unwrap()); } @@ -2172,4 +1976,54 @@ mod tests { let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap(); assert_eq!(encoded_value, target_value); } + + #[test] + fn encoding_legacy_onion_hop_data() { + let msg = msgs::OnionHopData { + format: OnionHopDataFormat::Legacy { + short_channel_id: 0xdeadbeef1bad1dea, + }, + amt_to_forward: 0x0badf00d01020304, + outgoing_cltv_value: 0xffffffff, + }; + let encoded_value = msg.encode(); + let target_value = hex::decode("00deadbeef1bad1dea0badf00d01020304ffffffff000000000000000000000000").unwrap(); + assert_eq!(encoded_value, target_value); + } + + #[test] + fn encoding_nonfinal_onion_hop_data() { + let mut msg = msgs::OnionHopData { + format: OnionHopDataFormat::NonFinalNode { + short_channel_id: 0xdeadbeef1bad1dea, + }, + amt_to_forward: 0x0badf00d01020304, + outgoing_cltv_value: 0xffffffff, + }; + let encoded_value = msg.encode(); + let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap(); + assert_eq!(encoded_value, target_value); + msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap(); + if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format { + assert_eq!(short_channel_id, 0xdeadbeef1bad1dea); + } else { panic!(); } + assert_eq!(msg.amt_to_forward, 0x0badf00d01020304); + assert_eq!(msg.outgoing_cltv_value, 0xffffffff); + } + + #[test] + fn encoding_final_onion_hop_data() { + let mut msg = msgs::OnionHopData { + format: OnionHopDataFormat::FinalNode, + amt_to_forward: 0x0badf00d01020304, + outgoing_cltv_value: 0xffffffff, + }; + let encoded_value = msg.encode(); + let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap(); + assert_eq!(encoded_value, target_value); + msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap(); + if let OnionHopDataFormat::FinalNode = msg.format { } else { panic!(); } + assert_eq!(msg.amt_to_forward, 0x0badf00d01020304); + assert_eq!(msg.outgoing_cltv_value, 0xffffffff); + } }