X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=312fea206e44d5702f02e4065e7d260f034381bf;hb=b21048a1ce25c69a1b6167715a51a5116fe61e6d;hp=97ed1e320f9350b4ac69fc04ca7a8ce49abfbb5b;hpb=bceb952b1270eb114a6268fcea9c69dc9c2e68c3;p=rust-lightning diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 97ed1e32..312fea20 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -2,7 +2,7 @@ use secp256k1::key::PublicKey; use secp256k1::{Secp256k1, Signature}; use bitcoin::util::uint::Uint256; use bitcoin::util::hash::Sha256dHash; -use bitcoin::network::serialize::deserialize; +use bitcoin::network::serialize::{deserialize,serialize}; use bitcoin::blockdata::script::Script; use std::error::Error; @@ -13,6 +13,8 @@ use util::{byte_utils, internal_traits, events}; pub trait MsgEncodable { fn encode(&self) -> Vec; + #[inline] + fn encoded_len(&self) -> usize { self.encode().len() } } #[derive(Debug)] pub enum DecodeError { @@ -24,6 +26,8 @@ pub enum DecodeError { BadSignature, /// Buffer not of right length (either too short or too long) WrongLength, + /// node_announcement included more than one address of a given type! + ExtraAddressesPerType, } pub trait MsgDecodable: Sized { fn decode(v: &[u8]) -> Result; @@ -256,7 +260,6 @@ pub struct AnnouncementSignatures { #[derive(Clone)] pub enum NetAddress { - Dummy, IPv4 { addr: [u8; 4], port: u16, @@ -273,9 +276,19 @@ pub enum NetAddress { ed25519_pubkey: [u8; 32], checksum: u16, version: u8, - //TODO: Do we need a port number here??? + port: u16, }, } +impl NetAddress { + fn get_id(&self) -> u8 { + match self { + &NetAddress::IPv4 {..} => { 1 }, + &NetAddress::IPv6 {..} => { 2 }, + &NetAddress::OnionV2 {..} => { 3 }, + &NetAddress::OnionV3 {..} => { 4 }, + } + } +} pub struct UnsignedNodeAnnouncement { pub features: GlobalFeatures, @@ -283,6 +296,8 @@ pub struct UnsignedNodeAnnouncement { pub node_id: PublicKey, pub rgb: [u8; 3], pub alias: [u8; 32], + /// 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, } pub struct NodeAnnouncement { @@ -351,16 +366,16 @@ pub trait ChannelMessageHandler : events::EventsProvider { fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked) -> Result, HandleError>; // Channl close: - fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(), HandleError>; - fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result<(), HandleError>; + fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(Option, Option), HandleError>; + fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result, HandleError>; // HTLC handling: fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC) -> Result<(), HandleError>; - fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result, CommitmentSigned)>, HandleError>; - fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result, CommitmentSigned)>, HandleError>; - fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result, CommitmentSigned)>, HandleError>; + fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>; + fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<(), HandleError>; + fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>; fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result; - fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<(), HandleError>; + fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result, CommitmentSigned)>, HandleError>; fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>; @@ -418,6 +433,7 @@ impl Error for DecodeError { DecodeError::BadPublicKey => "Invalid public key in packet", DecodeError::BadSignature => "Invalid signature in packet", DecodeError::WrongLength => "Data was wrong length for packet", + DecodeError::ExtraAddressesPerType => "More than one address of a single type", } } } @@ -457,7 +473,7 @@ impl MsgDecodable for LocalFeatures { let len = byte_utils::slice_to_be16(&v[0..2]) as usize; if v.len() < len + 2 { return Err(DecodeError::WrongLength); } let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..]); + flags.extend_from_slice(&v[2..2 + len]); Ok(Self { flags: flags }) @@ -470,6 +486,7 @@ impl MsgEncodable for LocalFeatures { res.extend_from_slice(&self.flags[..]); res } + fn encoded_len(&self) -> usize { self.flags.len() + 2 } } impl MsgDecodable for GlobalFeatures { @@ -478,7 +495,7 @@ impl MsgDecodable for GlobalFeatures { let len = byte_utils::slice_to_be16(&v[0..2]) as usize; if v.len() < len + 2 { return Err(DecodeError::WrongLength); } let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..]); + flags.extend_from_slice(&v[2..2 + len]); Ok(Self { flags: flags }) @@ -491,6 +508,7 @@ impl MsgEncodable for GlobalFeatures { res.extend_from_slice(&self.flags[..]); res } + fn encoded_len(&self) -> usize { self.flags.len() + 2 } } impl MsgDecodable for Init { @@ -601,7 +619,29 @@ impl MsgDecodable for AcceptChannel { } impl MsgEncodable for AcceptChannel { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = match &self.shutdown_scriptpubkey { + &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()), + &None => Vec::with_capacity(270), + }; + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]); + res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat)); + res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); + res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth)); + res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay)); + res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs)); + res.extend_from_slice(&self.funding_pubkey.serialize()); + res.extend_from_slice(&self.revocation_basepoint.serialize()); + res.extend_from_slice(&self.payment_basepoint.serialize()); + res.extend_from_slice(&self.delayed_payment_basepoint.serialize()); + res.extend_from_slice(&self.htlc_basepoint.serialize()); + res.extend_from_slice(&self.first_per_commitment_point.serialize()); + if let &Some(ref script) = &self.shutdown_scriptpubkey { + res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16)); + res.extend_from_slice(&script[..]); + } + res } } @@ -621,7 +661,13 @@ impl MsgDecodable for FundingCreated { } impl MsgEncodable for FundingCreated { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+32+2+64); + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]); + res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]); + res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res } } @@ -657,13 +703,26 @@ impl MsgDecodable for FundingLocked { } impl MsgEncodable for FundingLocked { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+33); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.next_per_commitment_point.serialize()); + res } } impl MsgDecodable for Shutdown { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32 + 2 { + return Err(DecodeError::WrongLength); + } + let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize; + if v.len() < 32 + 2 + scriptlen { + return Err(DecodeError::WrongLength); + } + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()), + }) } } impl MsgEncodable for Shutdown { @@ -673,8 +732,16 @@ impl MsgEncodable for Shutdown { } impl MsgDecodable for ClosingSigned { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32 + 8 + 64 { + return Err(DecodeError::WrongLength); + } + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + fee_satoshis: byte_utils::slice_to_be64(&v[32..40]), + signature: secp_signature!(&secp_ctx, &v[40..104]), + }) } } impl MsgEncodable for ClosingSigned { @@ -842,19 +909,131 @@ impl MsgEncodable for ChannelReestablish { } impl MsgDecodable for AnnouncementSignatures { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8+64*2 { + return Err(DecodeError::WrongLength); + } + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + short_channel_id: byte_utils::slice_to_be64(&v[32..40]), + node_signature: secp_signature!(&secp_ctx, &v[40..104]), + bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]), + }) } } impl MsgEncodable for AnnouncementSignatures { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+64*2); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx)); + res } } impl MsgDecodable for UnsignedNodeAnnouncement { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + let features = GlobalFeatures::decode(&v[..])?; + if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 { + return Err(DecodeError::WrongLength); + } + let start = features.encoded_len(); + + let mut rgb = [0; 3]; + rgb.copy_from_slice(&v[start + 37..start + 40]); + + let mut alias = [0; 32]; + alias.copy_from_slice(&v[start + 40..start + 72]); + + let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize; + if v.len() < start + 74 + addrlen { + return Err(DecodeError::WrongLength); + } + + let mut addresses = Vec::with_capacity(4); + let mut read_pos = start + 74; + loop { + if v.len() <= read_pos { break; } + match v[read_pos] { + 0 => { read_pos += 1; }, + 1 => { + if v.len() < read_pos + 1 + 6 { + return Err(DecodeError::WrongLength); + } + if addresses.len() > 0 { + return Err(DecodeError::ExtraAddressesPerType); + } + let mut addr = [0; 4]; + addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]); + addresses.push(NetAddress::IPv4 { + addr, + port: byte_utils::slice_to_be16(&v[read_pos + 5..read_pos + 7]), + }); + read_pos += 1 + 6; + }, + 2 => { + if v.len() < read_pos + 1 + 18 { + return Err(DecodeError::WrongLength); + } + if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) { + return Err(DecodeError::ExtraAddressesPerType); + } + let mut addr = [0; 16]; + addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]); + addresses.push(NetAddress::IPv6 { + addr, + port: byte_utils::slice_to_be16(&v[read_pos + 17..read_pos + 19]), + }); + read_pos += 1 + 18; + }, + 3 => { + if v.len() < read_pos + 1 + 12 { + return Err(DecodeError::WrongLength); + } + if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) { + return Err(DecodeError::ExtraAddressesPerType); + } + let mut addr = [0; 10]; + addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]); + addresses.push(NetAddress::OnionV2 { + addr, + port: byte_utils::slice_to_be16(&v[read_pos + 11..read_pos + 13]), + }); + read_pos += 1 + 12; + }, + 4 => { + if v.len() < read_pos + 1 + 37 { + return Err(DecodeError::WrongLength); + } + if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) { + return Err(DecodeError::ExtraAddressesPerType); + } + let mut ed25519_pubkey = [0; 32]; + ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]); + addresses.push(NetAddress::OnionV3 { + ed25519_pubkey, + checksum: byte_utils::slice_to_be16(&v[read_pos + 33..read_pos + 35]), + version: v[read_pos + 35], + port: byte_utils::slice_to_be16(&v[read_pos + 36..read_pos + 38]), + }); + read_pos += 1 + 37; + }, + _ => { break; } // We've read all we can, we dont understand anything higher (and they're sorted) + } + } + + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + features, + timestamp: byte_utils::slice_to_be32(&v[start..start + 4]), + node_id: secp_pubkey!(&secp_ctx, &v[start + 4..start + 37]), + rgb, + alias, + addresses, + }) } } impl MsgEncodable for UnsignedNodeAnnouncement { @@ -867,25 +1046,32 @@ impl MsgEncodable for UnsignedNodeAnnouncement { res.extend_from_slice(&self.rgb); res.extend_from_slice(&self.alias); let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18); - for addr in self.addresses.iter() { + let mut addrs_to_encode = self.addresses.clone(); + addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) }); + addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() }); + for addr in addrs_to_encode.iter() { match addr { - &NetAddress::Dummy => {}, &NetAddress::IPv4{addr, port} => { + addr_slice.push(1); addr_slice.extend_from_slice(&addr); addr_slice.extend_from_slice(&byte_utils::be16_to_array(port)); }, &NetAddress::IPv6{addr, port} => { + addr_slice.push(2); addr_slice.extend_from_slice(&addr); addr_slice.extend_from_slice(&byte_utils::be16_to_array(port)); }, &NetAddress::OnionV2{addr, port} => { + addr_slice.push(3); addr_slice.extend_from_slice(&addr); addr_slice.extend_from_slice(&byte_utils::be16_to_array(port)); }, - &NetAddress::OnionV3{ed25519_pubkey, checksum, version} => { + &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => { + addr_slice.push(4); addr_slice.extend_from_slice(&ed25519_pubkey); addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum)); addr_slice.push(version); + addr_slice.extend_from_slice(&byte_utils::be16_to_array(port)); }, } } @@ -896,8 +1082,15 @@ impl MsgEncodable for UnsignedNodeAnnouncement { } impl MsgDecodable for NodeAnnouncement { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 64 { + return Err(DecodeError::WrongLength); + } + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + signature: secp_signature!(&secp_ctx, &v[0..64]), + contents: UnsignedNodeAnnouncement::decode(&v[64..])?, + }) } } impl MsgEncodable for NodeAnnouncement { @@ -907,8 +1100,22 @@ impl MsgEncodable for NodeAnnouncement { } impl MsgDecodable for UnsignedChannelAnnouncement { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + let features = GlobalFeatures::decode(&v[..])?; + if v.len() < features.encoded_len() + 32 + 8 + 33*4 { + return Err(DecodeError::WrongLength); + } + let start = features.encoded_len(); + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + features, + chain_hash: deserialize(&v[start..start + 32]).unwrap(), + short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]), + node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]), + node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]), + bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]), + bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]), + }) } } impl MsgEncodable for UnsignedChannelAnnouncement { @@ -927,8 +1134,18 @@ impl MsgEncodable for UnsignedChannelAnnouncement { } impl MsgDecodable for ChannelAnnouncement { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 64*4 { + return Err(DecodeError::WrongLength); + } + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + node_signature_1: secp_signature!(&secp_ctx, &v[0..64]), + node_signature_2: secp_signature!(&secp_ctx, &v[64..128]), + bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]), + bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]), + contents: UnsignedChannelAnnouncement::decode(&v[256..])?, + }) } } impl MsgEncodable for ChannelAnnouncement { @@ -938,8 +1155,20 @@ impl MsgEncodable for ChannelAnnouncement { } impl MsgDecodable for UnsignedChannelUpdate { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8+4+2+2+8+4+4 { + return Err(DecodeError::WrongLength); + } + Ok(Self { + chain_hash: deserialize(&v[0..32]).unwrap(), + short_channel_id: byte_utils::slice_to_be64(&v[32..40]), + timestamp: byte_utils::slice_to_be32(&v[40..44]), + flags: byte_utils::slice_to_be16(&v[44..46]), + cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]), + htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]), + fee_base_msat: byte_utils::slice_to_be32(&v[56..60]), + fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]), + }) } } impl MsgEncodable for UnsignedChannelUpdate { @@ -958,15 +1187,21 @@ impl MsgEncodable for UnsignedChannelUpdate { } impl MsgDecodable for ChannelUpdate { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 128 { + return Err(DecodeError::WrongLength); + } + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + signature: secp_signature!(&secp_ctx, &v[0..64]), + contents: UnsignedChannelUpdate::decode(&v[64..])?, + }) } } impl MsgEncodable for ChannelUpdate { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(128); - //TODO: Should avoid creating a new secp ctx just for a serialize call :( - res.extend_from_slice(&self.signature.serialize_der(&Secp256k1::new())[..]); //TODO: Need in non-der form! (probably elsewhere too) + res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())[..]); res.extend_from_slice(&self.contents.encode()[..]); res }