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};
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<Self, DecodeError>;
/// 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 {
msg: Option<ErrorMessage>
// 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 : Send + Sync {
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",
}
}
}
}
impl MsgEncodable for UpdateAddHTLC {
fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(32+8+8+32+4+1+1366);
+ 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));
if v.len() < start + 74 + addrlen {
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::ShortRead);
- }
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 {
read_pos += 1 + 6;
},
2 => {
- if v.len() < read_pos + 1 + 18 {
- return Err(DecodeError::ShortRead);
- }
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 {
read_pos += 1 + 18;
},
3 => {
- if v.len() < read_pos + 1 + 12 {
- return Err(DecodeError::ShortRead);
- }
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 {
read_pos += 1 + 12;
},
4 => {
- if v.len() < read_pos + 1 + 37 {
- return Err(DecodeError::ShortRead);
- }
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 {
if v.len() < 34 {
return Err(DecodeError::ShortRead);
}
- let len = byte_utils::slice_to_be16(&v[32..34]);
- if v.len() < 34 + len as usize {
- return Err(DecodeError::ShortRead);
- }
- let data = match String::from_utf8(v[34..34 + len as usize].to_vec()) {
+ // 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),
};
#[cfg(test)]
mod tests {
- use bitcoin::util::misc::hex_bytes;
+ use hex;
use ln::msgs::MsgEncodable;
use ln::msgs;
use secp256k1::key::{PublicKey,SecretKey};
fn encoding_channel_reestablish_no_secret() {
let public_key = {
let secp_ctx = Secp256k1::new();
- PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
};
let cr = msgs::ChannelReestablish {
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_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
};
let cr = msgs::ChannelReestablish {