Fail parsing node/channel announcements with unknown even features

[rust-lightning] / src / ln / msgs.rs

diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs
index eb96fdf225dd035855e8b27f86c1ec9d1547856c..072383c11cab4a1670e0dfe322a0315d5daebe1c 100644 (file)
--- a/src/ln/msgs.rs
+++ b/src/ln/msgs.rs
@@ -28,6 +28,8 @@ pub trait MsgEncodable {
 pub enum DecodeError {
        /// Unknown realm byte in an OnionHopData packet
        UnknownRealmByte,
+       /// Unknown feature mandating we fail to parse message
+       UnknownRequiredFeature,
        /// Failed to decode a public key (ie it's invalid)
        BadPublicKey,
        /// Failed to decode a signature (ie it's invalid)
@@ -337,6 +339,8 @@ pub struct UnsignedNodeAnnouncement {
        /// List of addresses on which this node is reachable. Note that you may only have up to one
        /// address of each type, if you have more, they may be silently discarded or we may panic!
        pub addresses: Vec<NetAddress>,
+       pub excess_address_data: Vec<u8>,
+       pub excess_data: Vec<u8>,
 }
 pub struct NodeAnnouncement {
        pub signature: Signature,
@@ -508,6 +512,7 @@ impl Error for DecodeError {
        fn description(&self) -> &str {
                match *self {
                        DecodeError::UnknownRealmByte => "Unknown realm byte in Onion packet",
+                       DecodeError::UnknownRequiredFeature => "Unknown required feature preventing decode",
                        DecodeError::BadPublicKey => "Invalid public key in packet",
                        DecodeError::BadSignature => "Invalid signature in packet",
                        DecodeError::BadText => "Invalid text in packet",
@@ -1195,6 +1200,10 @@ impl MsgEncodable for AnnouncementSignatures {
 impl MsgDecodable for UnsignedNodeAnnouncement {
        fn decode(v: &[u8]) -> Result<Self, DecodeError> {
                let features = GlobalFeatures::decode(&v[..])?;
+               if features.requires_unknown_bits() {
+                       return Err(DecodeError::UnknownRequiredFeature);
+               }
+
                if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 {
                        return Err(DecodeError::ShortRead);
                }
@@ -1217,7 +1226,6 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                loop {
                        if addr_read_limit <= read_pos { break; }
                        match v[read_pos] {
-                               0 => { read_pos += 1; },
                                1 => {
                                        if addresses.len() > 0 {
                                                return Err(DecodeError::ExtraAddressesPerType);
@@ -1284,6 +1292,15 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                        }
                }
 
+               let excess_address_data = if read_pos < addr_read_limit {
+                       let mut excess_address_data = Vec::with_capacity(addr_read_limit - read_pos);
+                       excess_address_data.extend_from_slice(&v[read_pos..addr_read_limit]);
+                       excess_address_data
+               } else { Vec::new() };
+
+               let mut excess_data = Vec::with_capacity(v.len() - addr_read_limit);
+               excess_data.extend_from_slice(&v[addr_read_limit..]);
+
                let secp_ctx = Secp256k1::without_caps();
                Ok(Self {
                        features,
@@ -1292,13 +1309,15 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                        rgb,
                        alias,
                        addresses,
+                       excess_address_data,
+                       excess_data,
                })
        }
 }
 impl MsgEncodable for UnsignedNodeAnnouncement {
        fn encode(&self) -> Vec<u8> {
                let features = self.features.encode();
-               let mut res = Vec::with_capacity(74 + features.len() + self.addresses.len());
+               let mut res = Vec::with_capacity(74 + features.len() + self.addresses.len()*7 + self.excess_address_data.len() + self.excess_data.len());
                res.extend_from_slice(&features[..]);
                res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
                res.extend_from_slice(&self.node_id.serialize());
@@ -1334,8 +1353,10 @@ impl MsgEncodable for UnsignedNodeAnnouncement {
                                },
                        }
                }
-               res.extend_from_slice(&byte_utils::be16_to_array(addr_slice.len() as u16));
+               res.extend_from_slice(&byte_utils::be16_to_array((addr_slice.len() + self.excess_address_data.len()) as u16));
                res.extend_from_slice(&addr_slice[..]);
+               res.extend_from_slice(&self.excess_address_data[..]);
+               res.extend_from_slice(&self.excess_data[..]);
                res
        }
 }
@@ -1366,6 +1387,9 @@ impl MsgEncodable for NodeAnnouncement {
 impl MsgDecodable for UnsignedChannelAnnouncement {
        fn decode(v: &[u8]) -> Result<Self, DecodeError> {
                let features = GlobalFeatures::decode(&v[..])?;
+               if features.requires_unknown_bits() {
+                       return Err(DecodeError::UnknownRequiredFeature);
+               }
                if v.len() < features.encoded_len() + 32 + 8 + 33*4 {
                        return Err(DecodeError::ShortRead);
                }