X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=c7310ac9d5d4a2c1e13b368c761ef8ef7204b3af;hb=f7dd69240afcd3a0087f7796824a9e2697ed85cf;hp=3cdd4c77cb0efbd198b2c1ef782186e488088a6f;hpb=40ab09f627a21d1f95c1fc418ec94c8e2fbc919b;p=rust-lightning diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 3cdd4c77..c7310ac9 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -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", } } } @@ -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 { @@ -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 { @@ -662,8 +680,18 @@ impl MsgEncodable for FundingLocked { } 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 +701,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 { @@ -684,8 +720,20 @@ impl MsgEncodable for ClosingSigned { } impl MsgDecodable for UpdateAddHTLC { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8+8+32+4+1+33+20*65+32 { + return Err(DecodeError::WrongLength); + } + let mut payment_hash = [0; 32]; + payment_hash.copy_from_slice(&v[48..80]); + Ok(Self{ + channel_id: deserialize(&v[0..32]).unwrap(), + htlc_id: byte_utils::slice_to_be64(&v[32..40]), + amount_msat: byte_utils::slice_to_be64(&v[40..48]), + payment_hash, + cltv_expiry: byte_utils::slice_to_be32(&v[80..84]), + onion_routing_packet: OnionPacket::decode(&v[84..])?, + }) } } impl MsgEncodable for UpdateAddHTLC { @@ -695,8 +743,17 @@ impl MsgEncodable for UpdateAddHTLC { } impl MsgDecodable for UpdateFulfillHTLC { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8+32 { + return Err(DecodeError::WrongLength); + } + let mut payment_preimage = [0; 32]; + payment_preimage.copy_from_slice(&v[40..72]); + Ok(Self{ + channel_id: deserialize(&v[0..32]).unwrap(), + htlc_id: byte_utils::slice_to_be64(&v[32..40]), + payment_preimage, + }) } } impl MsgEncodable for UpdateFulfillHTLC { @@ -706,8 +763,15 @@ impl MsgEncodable for UpdateFulfillHTLC { } impl MsgDecodable for UpdateFailHTLC { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8 { + return Err(DecodeError::WrongLength); + } + Ok(Self{ + channel_id: deserialize(&v[0..32]).unwrap(), + htlc_id: byte_utils::slice_to_be64(&v[32..40]), + reason: OnionErrorPacket::decode(&v[40..])?, + }) } } impl MsgEncodable for UpdateFailHTLC { @@ -717,8 +781,18 @@ impl MsgEncodable for UpdateFailHTLC { } impl MsgDecodable for UpdateFailMalformedHTLC { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+8+32+2 { + return Err(DecodeError::WrongLength); + } + let mut sha256_of_onion = [0; 32]; + sha256_of_onion.copy_from_slice(&v[40..72]); + Ok(Self{ + channel_id: deserialize(&v[0..32]).unwrap(), + htlc_id: byte_utils::slice_to_be64(&v[32..40]), + sha256_of_onion, + failure_code: byte_utils::slice_to_be16(&v[72..74]), + }) } } impl MsgEncodable for UpdateFailMalformedHTLC { @@ -728,8 +802,24 @@ impl MsgEncodable for UpdateFailMalformedHTLC { } impl MsgDecodable for CommitmentSigned { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+64+2 { + return Err(DecodeError::WrongLength); + } + let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize; + if v.len() < 32+64+2+htlcs*64 { + return Err(DecodeError::WrongLength); + } + let mut htlc_signatures = Vec::with_capacity(htlcs); + let secp_ctx = Secp256k1::without_caps(); + for i in 0..htlcs { + htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64])); + } + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + signature: secp_signature!(&secp_ctx, &v[32..96]), + htlc_signatures, + }) } } impl MsgEncodable for CommitmentSigned { @@ -739,8 +829,18 @@ impl MsgEncodable for CommitmentSigned { } impl MsgDecodable for RevokeAndACK { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+32+33 { + return Err(DecodeError::WrongLength); + } + let mut per_commitment_secret = [0; 32]; + per_commitment_secret.copy_from_slice(&v[32..64]); + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + per_commitment_secret, + next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]), + }) } } impl MsgEncodable for RevokeAndACK { @@ -750,8 +850,14 @@ impl MsgEncodable for RevokeAndACK { } impl MsgDecodable for UpdateFee { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+4 { + return Err(DecodeError::WrongLength); + } + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]), + }) } } impl MsgEncodable for UpdateFee { @@ -772,8 +878,17 @@ 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 { @@ -783,8 +898,105 @@ impl MsgEncodable for AnnouncementSignatures { } 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 { @@ -797,25 +1009,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)); }, } } @@ -826,8 +1045,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 { @@ -837,8 +1063,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 { @@ -857,8 +1097,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 { @@ -868,8 +1118,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 { @@ -888,15 +1150,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 } @@ -954,8 +1222,21 @@ impl MsgEncodable for OnionHopData { } impl MsgDecodable for OnionPacket { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 1+33+20*65+32 { + return Err(DecodeError::WrongLength); + } + let mut hop_data = [0; 20*65]; + hop_data.copy_from_slice(&v[34..1334]); + let mut hmac = [0; 32]; + hmac.copy_from_slice(&v[1334..1366]); + let secp_ctx = Secp256k1::without_caps(); + Ok(Self { + version: v[0], + public_key: secp_pubkey!(&secp_ctx, &v[1..34]), + hop_data, + hmac, + }) } } impl MsgEncodable for OnionPacket { @@ -987,8 +1268,17 @@ impl MsgEncodable for DecodedOnionErrorPacket { } impl MsgDecodable for OnionErrorPacket { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 2 { + return Err(DecodeError::WrongLength); + } + let len = byte_utils::slice_to_be16(&v[0..2]) as usize; + if v.len() < 2 + len { + return Err(DecodeError::WrongLength); + } + Ok(Self { + data: v[2..len+2].to_vec(), + }) } } impl MsgEncodable for OnionErrorPacket {