X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=072383c11cab4a1670e0dfe322a0315d5daebe1c;hb=faff5c2da3d75783a9141ad3cf74011d2d7f9126;hp=e85f25ac78a23248690d520a586af5cb1cca9fb5;hpb=69eb59b24d502f3df6f4dd3990aad99cc727385c;p=rust-lightning diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index e85f25ac..072383c1 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -1,12 +1,12 @@ use secp256k1::key::PublicKey; use secp256k1::{Secp256k1, Signature}; -use bitcoin::util::uint::Uint256; +use secp256k1; use bitcoin::util::hash::Sha256dHash; use bitcoin::network::serialize::{deserialize,serialize}; use bitcoin::blockdata::script::Script; use std::error::Error; -use std::fmt; +use std::{cmp, fmt}; use std::result::Result; use util::{byte_utils, internal_traits, events}; @@ -15,19 +15,34 @@ pub trait MsgEncodable { fn encode(&self) -> Vec; #[inline] fn encoded_len(&self) -> usize { self.encode().len() } + #[inline] + fn encode_with_len(&self) -> Vec { + let enc = self.encode(); + let mut res = Vec::with_capacity(enc.len() + 2); + res.extend_from_slice(&byte_utils::be16_to_array(enc.len() as u16)); + res.extend_from_slice(&enc); + res + } } #[derive(Debug)] 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) BadSignature, - /// Buffer not of right length (either too short or too long) - WrongLength, + /// Value expected to be text wasn't decodable as text + BadText, + /// Buffer too short + ShortRead, /// node_announcement included more than one address of a given type! ExtraAddressesPerType, + /// A length descriptor in the packet didn't describe the later data correctly + /// (currently only generated in node_announcement) + BadLengthDescriptor, } pub trait MsgDecodable: Sized { fn decode(v: &[u8]) -> Result; @@ -53,9 +68,16 @@ impl LocalFeatures { self.flags.len() > 0 && (self.flags[0] & 1) != 0 } - pub fn supports_initial_routing_sync(&self) -> bool { + pub fn initial_routing_sync(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0 } + pub fn set_initial_routing_sync(&mut self) { + if self.flags.len() == 0 { + self.flags.resize(1, 1 << 3); + } else { + self.flags[0] |= 1 << 3; + } + } pub fn supports_upfront_shutdown_script(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0 @@ -124,9 +146,23 @@ pub struct Init { pub local_features: LocalFeatures, } +pub struct ErrorMessage { + pub channel_id: [u8; 32], + pub data: String, +} + +pub struct Ping { + pub ponglen: u16, + pub byteslen: u16, +} + +pub struct Pong { + pub byteslen: u16, +} + pub struct OpenChannel { pub chain_hash: Sha256dHash, - pub temporary_channel_id: Uint256, + pub temporary_channel_id: [u8; 32], pub funding_satoshis: u64, pub push_msat: u64, pub dust_limit_satoshis: u64, @@ -147,7 +183,7 @@ pub struct OpenChannel { } pub struct AcceptChannel { - pub temporary_channel_id: Uint256, + pub temporary_channel_id: [u8; 32], pub dust_limit_satoshis: u64, pub max_htlc_value_in_flight_msat: u64, pub channel_reserve_satoshis: u64, @@ -165,36 +201,36 @@ pub struct AcceptChannel { } pub struct FundingCreated { - pub temporary_channel_id: Uint256, + pub temporary_channel_id: [u8; 32], pub funding_txid: Sha256dHash, pub funding_output_index: u16, pub signature: Signature, } pub struct FundingSigned { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub signature: Signature, } pub struct FundingLocked { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub next_per_commitment_point: PublicKey, } pub struct Shutdown { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub scriptpubkey: Script, } pub struct ClosingSigned { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub fee_satoshis: u64, pub signature: Signature, } #[derive(Clone)] pub struct UpdateAddHTLC { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub htlc_id: u64, pub amount_msat: u64, pub payment_hash: [u8; 32], @@ -204,21 +240,21 @@ pub struct UpdateAddHTLC { #[derive(Clone)] pub struct UpdateFulfillHTLC { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub htlc_id: u64, pub payment_preimage: [u8; 32], } #[derive(Clone)] pub struct UpdateFailHTLC { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub htlc_id: u64, pub reason: OnionErrorPacket, } #[derive(Clone)] pub struct UpdateFailMalformedHTLC { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub htlc_id: u64, pub sha256_of_onion: [u8; 32], pub failure_code: u16, @@ -226,33 +262,37 @@ pub struct UpdateFailMalformedHTLC { #[derive(Clone)] pub struct CommitmentSigned { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub signature: Signature, pub htlc_signatures: Vec, } pub struct RevokeAndACK { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub per_commitment_secret: [u8; 32], pub next_per_commitment_point: PublicKey, } pub struct UpdateFee { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub feerate_per_kw: u32, } +pub struct DataLossProtect { + pub your_last_per_commitment_secret: [u8; 32], + pub my_current_per_commitment_point: PublicKey, +} + pub struct ChannelReestablish { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub next_local_commitment_number: u64, pub next_remote_commitment_number: u64, - pub your_last_per_commitment_secret: Option<[u8; 32]>, - pub my_current_per_commitment_point: PublicKey, + pub data_loss_protect: Option, } #[derive(Clone)] pub struct AnnouncementSignatures { - pub channel_id: Uint256, + pub channel_id: [u8; 32], pub short_channel_id: u64, pub node_signature: Signature, pub bitcoin_signature: Signature, @@ -299,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, + pub excess_address_data: Vec, + pub excess_data: Vec, } pub struct NodeAnnouncement { pub signature: Signature, @@ -314,6 +356,7 @@ pub struct UnsignedChannelAnnouncement { pub node_id_2: PublicKey, pub bitcoin_key_1: PublicKey, pub bitcoin_key_2: PublicKey, + pub excess_data: Vec, } #[derive(PartialEq, Clone)] pub struct ChannelAnnouncement { @@ -334,6 +377,7 @@ pub struct UnsignedChannelUpdate { pub htlc_minimum_msat: u64, pub fee_base_msat: u32, pub fee_proportional_millionths: u32, + pub excess_data: Vec, } #[derive(PartialEq, Clone)] pub struct ChannelUpdate { @@ -343,24 +387,46 @@ pub struct ChannelUpdate { /// Used to put an error message in a HandleError pub enum ErrorAction { - /// Indicates an inbound HTLC add resulted in a failure, and the UpdateFailHTLC provided in msg - /// should be sent back to the sender. - UpdateFailHTLC { - msg: UpdateFailHTLC - }, /// The peer took some action which made us think they were useless. Disconnect them. - DisconnectPeer {}, + DisconnectPeer { + msg: Option + }, + /// The peer did something harmless that we weren't able to process, just log and ignore + IgnoreError, + /// The peer did something incorrect. Tell them. + SendErrorMessage { + msg: ErrorMessage + }, } pub struct HandleError { //TODO: rename me pub err: &'static str, - pub msg: Option, //TODO: Make this required and rename it + pub action: Option, //TODO: Make this required +} + +/// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment +/// transaction updates if they were pending. +pub struct CommitmentUpdate { + pub update_add_htlcs: Vec, + pub update_fulfill_htlcs: Vec, + pub update_fail_htlcs: Vec, + pub update_fail_malformed_htlcs: Vec, + pub commitment_signed: CommitmentSigned, +} + +pub enum HTLCFailChannelUpdate { + ChannelUpdateMessage { + msg: ChannelUpdate, + }, + ChannelClosed { + short_channel_id: u64, + }, } /// A trait to describe an object which can receive channel messages. Messages MAY be called in /// paralell when they originate from different their_node_ids, however they MUST NOT be called in /// paralell when the two calls have the same their_node_id. -pub trait ChannelMessageHandler : events::EventsProvider { +pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync { //Channel init: fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result; fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>; @@ -375,30 +441,33 @@ pub trait ChannelMessageHandler : events::EventsProvider { // 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<(), HandleError>; - fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> 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, CommitmentSigned)>, HandleError>; + fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option), HandleError>; + fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result, HandleError>; fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>; // Channel-to-announce: fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>; - // Informational: + // Error conditions: /// Indicates a connection to the peer failed/an existing connection was lost. If no connection /// is believed to be possible in the future (eg they're sending us messages we don't /// understand or indicate they require unknown feature bits), no_connection_possible is set /// and any outstanding channels should be failed. fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool); + + fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage); } -pub trait RoutingMessageHandler { +pub trait RoutingMessageHandler : Send + Sync { fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<(), HandleError>; /// Handle a channel_announcement message, returning true if it should be forwarded on, false /// or returning an Err otherwise. fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result; fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<(), HandleError>; + fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate); } pub struct OnionRealm0HopData { @@ -418,7 +487,10 @@ unsafe impl internal_traits::NoDealloc for OnionHopData{} #[derive(Clone)] pub struct OnionPacket { pub version: u8, - pub public_key: PublicKey, + /// In order to ensure we always return an error on Onion decode in compliance with BOLT 4, we + /// have to deserialize OnionPackets contained in UpdateAddHTLCs even if the ephemeral public + /// key (here) is bogus, so we hold a Result instead of a PublicKey as we'd like. + pub public_key: Result, pub hop_data: [u8; 20*65], pub hmac: [u8; 32], } @@ -440,10 +512,13 @@ 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::WrongLength => "Data was wrong length for packet", + DecodeError::BadText => "Invalid text in packet", + DecodeError::ShortRead => "Packet extended beyond the provided bytes", DecodeError::ExtraAddressesPerType => "More than one address of a single type", + DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly", } } } @@ -479,9 +554,9 @@ macro_rules! secp_signature { impl MsgDecodable for LocalFeatures { fn decode(v: &[u8]) -> Result { - if v.len() < 3 { return Err(DecodeError::WrongLength); } + if v.len() < 2 { return Err(DecodeError::ShortRead); } let len = byte_utils::slice_to_be16(&v[0..2]) as usize; - if v.len() < len + 2 { return Err(DecodeError::WrongLength); } + if v.len() < len + 2 { return Err(DecodeError::ShortRead); } let mut flags = Vec::with_capacity(len); flags.extend_from_slice(&v[2..2 + len]); Ok(Self { @@ -501,9 +576,9 @@ impl MsgEncodable for LocalFeatures { impl MsgDecodable for GlobalFeatures { fn decode(v: &[u8]) -> Result { - if v.len() < 3 { return Err(DecodeError::WrongLength); } + if v.len() < 2 { return Err(DecodeError::ShortRead); } let len = byte_utils::slice_to_be16(&v[0..2]) as usize; - if v.len() < len + 2 { return Err(DecodeError::WrongLength); } + if v.len() < len + 2 { return Err(DecodeError::ShortRead); } let mut flags = Vec::with_capacity(len); flags.extend_from_slice(&v[2..2 + len]); Ok(Self { @@ -525,7 +600,7 @@ impl MsgDecodable for Init { fn decode(v: &[u8]) -> Result { let global_features = GlobalFeatures::decode(v)?; if v.len() < global_features.flags.len() + 4 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?; Ok(Self { @@ -543,10 +618,58 @@ impl MsgEncodable for Init { } } +impl MsgDecodable for Ping { + fn decode(v: &[u8]) -> Result { + if v.len() < 4 { + return Err(DecodeError::ShortRead); + } + let ponglen = byte_utils::slice_to_be16(&v[0..2]); + let byteslen = byte_utils::slice_to_be16(&v[2..4]); + if v.len() < 4 + byteslen as usize { + return Err(DecodeError::ShortRead); + } + Ok(Self { + ponglen, + byteslen, + }) + } +} +impl MsgEncodable for Ping { + fn encode(&self) -> Vec { + let mut res = Vec::with_capacity(self.byteslen as usize + 2); + res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); + res.resize(2 + self.byteslen as usize, 0); + res + } +} + +impl MsgDecodable for Pong { + fn decode(v: &[u8]) -> Result { + if v.len() < 2 { + return Err(DecodeError::ShortRead); + } + let byteslen = byte_utils::slice_to_be16(&v[0..2]); + if v.len() < 2 + byteslen as usize { + return Err(DecodeError::ShortRead); + } + Ok(Self { + byteslen + }) + } +} +impl MsgEncodable for Pong { + fn encode(&self) -> Vec { + let mut res = Vec::with_capacity(self.byteslen as usize + 2); + res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); + res.resize(2 + self.byteslen as usize, 0); + res + } +} + impl MsgDecodable for OpenChannel { fn decode(v: &[u8]) -> Result { if v.len() < 2*32+6*8+4+2*2+6*33+1 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let ctx = Secp256k1::without_caps(); @@ -554,11 +677,9 @@ impl MsgDecodable for OpenChannel { if v.len() >= 321 { let len = byte_utils::slice_to_be16(&v[319..321]) as usize; if v.len() < 321+len { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec())); - } else if v.len() != 2*32+6*8+4+2*2+6*33+1 { // Message cant have 1 extra byte - return Err(DecodeError::WrongLength); } Ok(OpenChannel { @@ -586,14 +707,40 @@ impl MsgDecodable for OpenChannel { } impl MsgEncodable for OpenChannel { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = match &self.shutdown_scriptpubkey { + &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()), + &None => Vec::with_capacity(319), + }; + res.extend_from_slice(&serialize(&self.chain_hash).unwrap()); + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat)); + 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.feerate_per_kw)); + 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()); + res.push(self.channel_flags); + 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 } } impl MsgDecodable for AcceptChannel { fn decode(v: &[u8]) -> Result { if v.len() < 32+4*8+4+2*2+6*33 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let ctx = Secp256k1::without_caps(); @@ -601,15 +748,15 @@ impl MsgDecodable for AcceptChannel { if v.len() >= 272 { let len = byte_utils::slice_to_be16(&v[270..272]) as usize; if v.len() < 272+len { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec())); - } else if v.len() != 32+4*8+4+2*2+6*33 { // Message cant have 1 extra byte - return Err(DecodeError::WrongLength); } + let mut temporary_channel_id = [0; 32]; + temporary_channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - temporary_channel_id: deserialize(&v[0..32]).unwrap(), + temporary_channel_id, dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]), max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]), channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]), @@ -633,7 +780,7 @@ impl MsgEncodable for AcceptChannel { &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(&self.temporary_channel_id); 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)); @@ -658,11 +805,13 @@ impl MsgEncodable for AcceptChannel { impl MsgDecodable for FundingCreated { fn decode(v: &[u8]) -> Result { if v.len() < 32+32+2+64 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let ctx = Secp256k1::without_caps(); + let mut temporary_channel_id = [0; 32]; + temporary_channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - temporary_channel_id: deserialize(&v[0..32]).unwrap(), + temporary_channel_id, funding_txid: deserialize(&v[32..64]).unwrap(), funding_output_index: byte_utils::slice_to_be16(&v[64..66]), signature: secp_signature!(&ctx, &v[66..130]), @@ -672,7 +821,7 @@ impl MsgDecodable for FundingCreated { impl MsgEncodable for FundingCreated { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(32+32+2+64); - res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]); + res.extend_from_slice(&self.temporary_channel_id); 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(); @@ -684,29 +833,36 @@ impl MsgEncodable for FundingCreated { impl MsgDecodable for FundingSigned { fn decode(v: &[u8]) -> Result { if v.len() < 32+64 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let ctx = Secp256k1::without_caps(); + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, signature: secp_signature!(&ctx, &v[32..96]), }) } } impl MsgEncodable for FundingSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+64); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())); + res } } impl MsgDecodable for FundingLocked { fn decode(v: &[u8]) -> Result { if v.len() < 32+33 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let ctx = Secp256k1::without_caps(); + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]), }) } @@ -714,7 +870,7 @@ impl MsgDecodable for FundingLocked { impl MsgEncodable for FundingLocked { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(32+33); - res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.channel_id); res.extend_from_slice(&self.next_per_commitment_point.serialize()); res } @@ -723,32 +879,40 @@ impl MsgEncodable for FundingLocked { impl MsgDecodable for Shutdown { fn decode(v: &[u8]) -> Result { if v.len() < 32 + 2 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize; if v.len() < 32 + 2 + scriptlen { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()), }) } } impl MsgEncodable for Shutdown { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len()); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16)); + res.extend_from_slice(&self.scriptpubkey[..]); + res } } impl MsgDecodable for ClosingSigned { fn decode(v: &[u8]) -> Result { if v.len() < 32 + 8 + 64 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let secp_ctx = Secp256k1::without_caps(); + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, fee_satoshis: byte_utils::slice_to_be64(&v[32..40]), signature: secp_signature!(&secp_ctx, &v[40..104]), }) @@ -756,42 +920,58 @@ impl MsgDecodable for ClosingSigned { } impl MsgEncodable for ClosingSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+64); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res } } impl MsgDecodable for UpdateAddHTLC { fn decode(v: &[u8]) -> Result { if v.len() < 32+8+8+32+4+1+33+20*65+32 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); let mut payment_hash = [0; 32]; payment_hash.copy_from_slice(&v[48..80]); Ok(Self{ - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, 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..])?, + onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?, }) } } impl MsgEncodable for UpdateAddHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+8+32+4+1366); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat)); + res.extend_from_slice(&self.payment_hash); + res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry)); + res.extend_from_slice(&self.onion_routing_packet.encode()[..]); + res } } impl MsgDecodable for UpdateFulfillHTLC { fn decode(v: &[u8]) -> Result { if v.len() < 32+8+32 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); let mut payment_preimage = [0; 32]; payment_preimage.copy_from_slice(&v[40..72]); Ok(Self{ - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, htlc_id: byte_utils::slice_to_be64(&v[32..40]), payment_preimage, }) @@ -799,17 +979,23 @@ impl MsgDecodable for UpdateFulfillHTLC { } impl MsgEncodable for UpdateFulfillHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+32); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&self.payment_preimage); + res } } impl MsgDecodable for UpdateFailHTLC { fn decode(v: &[u8]) -> Result { if v.len() < 32+8 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self{ - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, htlc_id: byte_utils::slice_to_be64(&v[32..40]), reason: OnionErrorPacket::decode(&v[40..])?, }) @@ -817,19 +1003,26 @@ impl MsgDecodable for UpdateFailHTLC { } impl MsgEncodable for UpdateFailHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let reason = self.reason.encode(); + let mut res = Vec::with_capacity(32+8+reason.len()); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&reason[..]); + res } } impl MsgDecodable for UpdateFailMalformedHTLC { fn decode(v: &[u8]) -> Result { if v.len() < 32+8+32+2 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); 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(), + channel_id, htlc_id: byte_utils::slice_to_be64(&v[32..40]), sha256_of_onion, failure_code: byte_utils::slice_to_be16(&v[72..74]), @@ -838,18 +1031,26 @@ impl MsgDecodable for UpdateFailMalformedHTLC { } impl MsgEncodable for UpdateFailMalformedHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+32+2); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&self.sha256_of_onion); + res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code)); + res } } impl MsgDecodable for CommitmentSigned { fn decode(v: &[u8]) -> Result { if v.len() < 32+64+2 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); + let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize; if v.len() < 32+64+2+htlcs*64 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let mut htlc_signatures = Vec::with_capacity(htlcs); let secp_ctx = Secp256k1::without_caps(); @@ -857,7 +1058,7 @@ impl MsgDecodable for CommitmentSigned { htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64])); } Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, signature: secp_signature!(&secp_ctx, &v[32..96]), htlc_signatures, }) @@ -865,20 +1066,30 @@ impl MsgDecodable for CommitmentSigned { } impl MsgEncodable for CommitmentSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64); + res.extend_from_slice(&self.channel_id); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16)); + for i in 0..self.htlc_signatures.len() { + res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx)); + } + res } } impl MsgDecodable for RevokeAndACK { fn decode(v: &[u8]) -> Result { if v.len() < 32+32+33 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); 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(), + channel_id, per_commitment_secret, next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]), }) @@ -886,46 +1097,88 @@ impl MsgDecodable for RevokeAndACK { } impl MsgEncodable for RevokeAndACK { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+32+33); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&self.per_commitment_secret); + res.extend_from_slice(&self.next_per_commitment_point.serialize()); + res } } impl MsgDecodable for UpdateFee { fn decode(v: &[u8]) -> Result { if v.len() < 32+4 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]), }) } } impl MsgEncodable for UpdateFee { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+4); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw)); + res } } impl MsgDecodable for ChannelReestablish { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32+2*8 { + return Err(DecodeError::ShortRead); + } + + let data_loss_protect = if v.len() > 32+2*8 { + if v.len() < 32+2*8 + 33+32 { + return Err(DecodeError::ShortRead); + } + let mut inner_array = [0; 32]; + inner_array.copy_from_slice(&v[48..48+32]); + Some(DataLossProtect { + your_last_per_commitment_secret: inner_array, + my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &v[48+32..48+32+33]), + }) + } else { None }; + + Ok(Self { + channel_id: deserialize(&v[0..32]).unwrap(), + next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]), + next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]), + data_loss_protect: data_loss_protect, + }) } } impl MsgEncodable for ChannelReestablish { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 }); + + res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]); + res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_commitment_number)); + res.extend_from_slice(&byte_utils::be64_to_array(self.next_remote_commitment_number)); + + if let &Some(ref data_loss_protect) = &self.data_loss_protect { + res.extend_from_slice(&data_loss_protect.your_last_per_commitment_secret[..]); + res.extend_from_slice(&data_loss_protect.my_current_per_commitment_point.serialize()); + } + res } } impl MsgDecodable for AnnouncementSignatures { fn decode(v: &[u8]) -> Result { if v.len() < 32+8+64*2 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let secp_ctx = Secp256k1::without_caps(); + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), + channel_id, 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]), @@ -935,7 +1188,7 @@ impl MsgDecodable for AnnouncementSignatures { impl MsgEncodable for AnnouncementSignatures { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(32+8+64*2); - res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.channel_id); 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)); @@ -947,8 +1200,12 @@ impl MsgEncodable for AnnouncementSignatures { impl MsgDecodable for UnsignedNodeAnnouncement { fn decode(v: &[u8]) -> Result { 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::WrongLength); + return Err(DecodeError::ShortRead); } let start = features.encoded_len(); @@ -960,22 +1217,22 @@ impl MsgDecodable for UnsignedNodeAnnouncement { let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize; if v.len() < start + 74 + addrlen { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let addr_read_limit = start + 74 + addrlen; let mut addresses = Vec::with_capacity(4); let mut read_pos = start + 74; loop { - if v.len() <= read_pos { break; } + if addr_read_limit <= 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); } + if addr_read_limit < read_pos + 1 + 6 { + return Err(DecodeError::BadLengthDescriptor); + } let mut addr = [0; 4]; addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]); addresses.push(NetAddress::IPv4 { @@ -985,12 +1242,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement { 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); } + if addr_read_limit < read_pos + 1 + 18 { + return Err(DecodeError::BadLengthDescriptor); + } let mut addr = [0; 16]; addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]); addresses.push(NetAddress::IPv6 { @@ -1000,12 +1257,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement { 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); } + if addr_read_limit < read_pos + 1 + 12 { + return Err(DecodeError::BadLengthDescriptor); + } let mut addr = [0; 10]; addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]); addresses.push(NetAddress::OnionV2 { @@ -1015,12 +1272,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement { 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); } + if addr_read_limit < read_pos + 1 + 37 { + return Err(DecodeError::BadLengthDescriptor); + } let mut ed25519_pubkey = [0; 32]; ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]); addresses.push(NetAddress::OnionV3 { @@ -1035,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, @@ -1043,13 +1309,15 @@ impl MsgDecodable for UnsignedNodeAnnouncement { rgb, alias, addresses, + excess_address_data, + excess_data, }) } } impl MsgEncodable for UnsignedNodeAnnouncement { fn encode(&self) -> Vec { 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()); @@ -1085,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 } } @@ -1094,7 +1364,7 @@ impl MsgEncodable for UnsignedNodeAnnouncement { impl MsgDecodable for NodeAnnouncement { fn decode(v: &[u8]) -> Result { if v.len() < 64 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let secp_ctx = Secp256k1::without_caps(); Ok(Self { @@ -1105,18 +1375,28 @@ impl MsgDecodable for NodeAnnouncement { } impl MsgEncodable for NodeAnnouncement { fn encode(&self) -> Vec { - unimplemented!(); + let contents = self.contents.encode(); + let mut res = Vec::with_capacity(64 + contents.len()); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&contents); + res } } impl MsgDecodable for UnsignedChannelAnnouncement { fn decode(v: &[u8]) -> Result { 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::WrongLength); + return Err(DecodeError::ShortRead); } let start = features.encoded_len(); let secp_ctx = Secp256k1::without_caps(); + let mut excess_data = Vec::with_capacity(v.len() - start - 172); + excess_data.extend_from_slice(&v[start + 172..]); Ok(Self { features, chain_hash: deserialize(&v[start..start + 32]).unwrap(), @@ -1125,13 +1405,14 @@ impl MsgDecodable for UnsignedChannelAnnouncement { 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]), + excess_data, }) } } impl MsgEncodable for UnsignedChannelAnnouncement { fn encode(&self) -> Vec { let features = self.features.encode(); - let mut res = Vec::with_capacity(172 + features.len()); + let mut res = Vec::with_capacity(172 + features.len() + self.excess_data.len()); res.extend_from_slice(&features[..]); res.extend_from_slice(&self.chain_hash[..]); res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id)); @@ -1139,6 +1420,7 @@ impl MsgEncodable for UnsignedChannelAnnouncement { res.extend_from_slice(&self.node_id_2.serialize()); res.extend_from_slice(&self.bitcoin_key_1.serialize()); res.extend_from_slice(&self.bitcoin_key_2.serialize()); + res.extend_from_slice(&self.excess_data[..]); res } } @@ -1146,7 +1428,7 @@ impl MsgEncodable for UnsignedChannelAnnouncement { impl MsgDecodable for ChannelAnnouncement { fn decode(v: &[u8]) -> Result { if v.len() < 64*4 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let secp_ctx = Secp256k1::without_caps(); Ok(Self { @@ -1160,15 +1442,25 @@ impl MsgDecodable for ChannelAnnouncement { } impl MsgEncodable for ChannelAnnouncement { fn encode(&self) -> Vec { - unimplemented!(); + let secp_ctx = Secp256k1::without_caps(); + let contents = self.contents.encode(); + let mut res = Vec::with_capacity(64 + contents.len()); + res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx)); + res.extend_from_slice(&contents); + res } } impl MsgDecodable for UnsignedChannelUpdate { fn decode(v: &[u8]) -> Result { if v.len() < 32+8+4+2+2+8+4+4 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } + let mut excess_data = Vec::with_capacity(v.len() - 64); + excess_data.extend_from_slice(&v[64..]); Ok(Self { chain_hash: deserialize(&v[0..32]).unwrap(), short_channel_id: byte_utils::slice_to_be64(&v[32..40]), @@ -1178,12 +1470,13 @@ impl MsgDecodable for UnsignedChannelUpdate { 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]), + excess_data }) } } impl MsgEncodable for UnsignedChannelUpdate { fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(64); + let mut res = Vec::with_capacity(64 + self.excess_data.len()); res.extend_from_slice(&self.chain_hash[..]); res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id)); res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp)); @@ -1192,6 +1485,7 @@ impl MsgEncodable for UnsignedChannelUpdate { res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); res.extend_from_slice(&byte_utils::be32_to_array(self.fee_base_msat)); res.extend_from_slice(&byte_utils::be32_to_array(self.fee_proportional_millionths)); + res.extend_from_slice(&self.excess_data[..]); res } } @@ -1199,7 +1493,7 @@ impl MsgEncodable for UnsignedChannelUpdate { impl MsgDecodable for ChannelUpdate { fn decode(v: &[u8]) -> Result { if v.len() < 128 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let secp_ctx = Secp256k1::without_caps(); Ok(Self { @@ -1220,7 +1514,7 @@ impl MsgEncodable for ChannelUpdate { impl MsgDecodable for OnionRealm0HopData { fn decode(v: &[u8]) -> Result { if v.len() < 32 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } Ok(OnionRealm0HopData { short_channel_id: byte_utils::slice_to_be64(&v[0..8]), @@ -1243,7 +1537,7 @@ impl MsgEncodable for OnionRealm0HopData { impl MsgDecodable for OnionHopData { fn decode(v: &[u8]) -> Result { if v.len() < 65 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let realm = v[0]; if realm != 0 { @@ -1271,7 +1565,7 @@ impl MsgEncodable for OnionHopData { impl MsgDecodable for OnionPacket { fn decode(v: &[u8]) -> Result { if v.len() < 1+33+20*65+32 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let mut hop_data = [0; 20*65]; hop_data.copy_from_slice(&v[34..1334]); @@ -1280,7 +1574,7 @@ impl MsgDecodable for OnionPacket { let secp_ctx = Secp256k1::without_caps(); Ok(Self { version: v[0], - public_key: secp_pubkey!(&secp_ctx, &v[1..34]), + public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]), hop_data, hmac, }) @@ -1290,7 +1584,10 @@ impl MsgEncodable for OnionPacket { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32); res.push(self.version); - res.extend_from_slice(&self.public_key.serialize()); + match self.public_key { + Ok(pubkey) => res.extend_from_slice(&pubkey.serialize()), + Err(_) => res.extend_from_slice(&[0; 33]), + } res.extend_from_slice(&self.hop_data); res.extend_from_slice(&self.hmac); res @@ -1298,8 +1595,26 @@ impl MsgEncodable for OnionPacket { } impl MsgDecodable for DecodedOnionErrorPacket { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32 + 4 { + return Err(DecodeError::ShortRead); + } + let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize; + if v.len() < 32 + 4 + failuremsg_len { + return Err(DecodeError::ShortRead); + } + let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize; + if v.len() < 32 + 4 + failuremsg_len + padding_len { + return Err(DecodeError::ShortRead); + } + + let mut hmac = [0; 32]; + hmac.copy_from_slice(&v[0..32]); + Ok(Self { + hmac, + failuremsg: v[34..34 + failuremsg_len].to_vec(), + pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(), + }) } } impl MsgEncodable for DecodedOnionErrorPacket { @@ -1317,11 +1632,11 @@ impl MsgEncodable for DecodedOnionErrorPacket { impl MsgDecodable for OnionErrorPacket { fn decode(v: &[u8]) -> Result { if v.len() < 2 { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } let len = byte_utils::slice_to_be16(&v[0..2]) as usize; if v.len() < 2 + len { - return Err(DecodeError::WrongLength); + return Err(DecodeError::ShortRead); } Ok(Self { data: v[2..len+2].to_vec(), @@ -1330,7 +1645,84 @@ impl MsgDecodable for OnionErrorPacket { } impl MsgEncodable for OnionErrorPacket { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(2 + self.data.len()); + res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16)); + res.extend_from_slice(&self.data); + res + } +} + +impl MsgEncodable for ErrorMessage { + fn encode(&self) -> Vec { + let mut res = Vec::with_capacity(34 + self.data.len()); + res.extend_from_slice(&self.channel_id); + res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16)); + res.extend_from_slice(&self.data.as_bytes()); + res + } +} +impl MsgDecodable for ErrorMessage { + fn decode(v: &[u8]) -> Result { + if v.len() < 34 { + return Err(DecodeError::ShortRead); + } + // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range + let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34); + let data = match String::from_utf8(v[34..34 + len].to_vec()) { + Ok(s) => s, + Err(_) => return Err(DecodeError::BadText), + }; + let mut channel_id = [0; 32]; + channel_id[..].copy_from_slice(&v[0..32]); + Ok(Self { + channel_id, + data, + }) } } +#[cfg(test)] +mod tests { + use hex; + use ln::msgs::MsgEncodable; + use ln::msgs; + use secp256k1::key::{PublicKey,SecretKey}; + use secp256k1::Secp256k1; + + #[test] + fn encoding_channel_reestablish_no_secret() { + let cr = msgs::ChannelReestablish { + channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0], + next_local_commitment_number: 3, + next_remote_commitment_number: 4, + data_loss_protect: None, + }; + + let encoded_value = cr.encode(); + assert_eq!( + encoded_value, + vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4] + ); + } + + #[test] + fn encoding_channel_reestablish_with_secret() { + let public_key = { + let secp_ctx = Secp256k1::new(); + PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()) + }; + + let cr = msgs::ChannelReestablish { + channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0], + next_local_commitment_number: 3, + next_remote_commitment_number: 4, + data_loss_protect: Some(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}), + }; + + let encoded_value = cr.encode(); + assert_eq!( + encoded_value, + vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143] + ); + } +}