From 09c55dface85a0f3a8eaec0aff7a9efd0e88fa91 Mon Sep 17 00:00:00 2001 From: Yuntai Kyong Date: Sat, 1 Sep 2018 16:18:56 +0900 Subject: [PATCH 01/12] Implement Writer/Reader with additional variants in DecodeError --- fuzz/fuzz_targets/channel_target.rs | 6 + fuzz/fuzz_targets/router_target.rs | 3 + src/ln/msgs.rs | 19 ++ src/ln/peer_handler.rs | 3 + src/util/mod.rs | 7 + src/util/ser.rs | 400 ++++++++++++++++++++++++++++ 6 files changed, 438 insertions(+) create mode 100644 src/util/ser.rs diff --git a/fuzz/fuzz_targets/channel_target.rs b/fuzz/fuzz_targets/channel_target.rs index 7b3b7df1ce2..31149fbc194 100644 --- a/fuzz/fuzz_targets/channel_target.rs +++ b/fuzz/fuzz_targets/channel_target.rs @@ -131,6 +131,9 @@ pub fn do_test(data: &[u8]) { msgs::DecodeError::ExtraAddressesPerType => return, msgs::DecodeError::BadLengthDescriptor => return, msgs::DecodeError::ShortRead => panic!("We picked the length..."), + msgs::DecodeError::InvalidValue => panic!("Writeable not used yet..."), + msgs::DecodeError::InvalidLength => panic!("Writeable not used yet..."), + msgs::DecodeError::Io(_) => panic!("Writeable not used yet..."), } } } @@ -154,6 +157,9 @@ pub fn do_test(data: &[u8]) { msgs::DecodeError::ExtraAddressesPerType => return, msgs::DecodeError::BadLengthDescriptor => return, msgs::DecodeError::ShortRead => panic!("We picked the length..."), + msgs::DecodeError::InvalidValue => panic!("Writeable not used yet..."), + msgs::DecodeError::InvalidLength => panic!("Writeable not used yet..."), + msgs::DecodeError::Io(_) => panic!("Writeable not used yet..."), } } } diff --git a/fuzz/fuzz_targets/router_target.rs b/fuzz/fuzz_targets/router_target.rs index 6476f812fb3..24aa3d3f17c 100644 --- a/fuzz/fuzz_targets/router_target.rs +++ b/fuzz/fuzz_targets/router_target.rs @@ -131,6 +131,9 @@ pub fn do_test(data: &[u8]) { msgs::DecodeError::ExtraAddressesPerType => return, msgs::DecodeError::BadLengthDescriptor => return, msgs::DecodeError::ShortRead => panic!("We picked the length..."), + msgs::DecodeError::InvalidValue => panic!("Writeable not used yet..."), + msgs::DecodeError::InvalidLength => panic!("Writeable not used yet..."), + msgs::DecodeError::Io(_) => panic!("Writeable not used yet..."), } } } diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 1d0ea1c6372..0859ab2b4aa 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -43,6 +43,12 @@ pub enum DecodeError { /// A length descriptor in the packet didn't describe the later data correctly /// (currently only generated in node_announcement) BadLengthDescriptor, + /// Error from std::io + Io(::std::io::Error), + /// Invalid value found when decoding + InvalidValue, + /// Data too big + InvalidLength, } pub trait MsgDecodable: Sized { fn decode(v: &[u8]) -> Result; @@ -519,6 +525,9 @@ impl Error for DecodeError { 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", + DecodeError::Io(ref e) => e.description(), + DecodeError::InvalidValue => "Invalid value in the bytes", + DecodeError::InvalidLength => "Data size is too big", } } } @@ -534,6 +543,16 @@ impl fmt::Debug for HandleError { } } +impl From<::std::io::Error> for DecodeError { + fn from(e: ::std::io::Error) -> Self { + if e.kind() == ::std::io::ErrorKind::UnexpectedEof { + DecodeError::ShortRead + } else { + DecodeError::Io(e) + } + } +} + macro_rules! secp_pubkey { ( $ctx: expr, $slice: expr ) => { match PublicKey::from_slice($ctx, $slice) { diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index 8a4228851b7..5d5641bbe55 100644 --- a/src/ln/peer_handler.rs +++ b/src/ln/peer_handler.rs @@ -363,6 +363,9 @@ impl PeerManager { continue; }, msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError{ no_connection_possible: false }), + msgs::DecodeError::Io(_) => return Err(PeerHandleError{ no_connection_possible: false }), + msgs::DecodeError::InvalidValue => return Err(PeerHandleError{ no_connection_possible: false }), + msgs::DecodeError::InvalidLength => return Err(PeerHandleError{ no_connection_possible: false }), } } }; diff --git a/src/util/mod.rs b/src/util/mod.rs index 571a4dbed10..308825855bd 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -21,4 +21,11 @@ pub(crate) mod test_utils; #[macro_use] pub(crate) mod macro_logger; +#[cfg(feature = "fuzztarget")] +#[macro_use] +pub mod ser; +#[cfg(not(feature = "fuzztarget"))] +#[macro_use] +pub(crate) mod ser; + pub mod logger; diff --git a/src/util/ser.rs b/src/util/ser.rs new file mode 100644 index 00000000000..7630b5abc6b --- /dev/null +++ b/src/util/ser.rs @@ -0,0 +1,400 @@ +use std::result::Result; +use std::io::{Read, Write}; +use std::collections::HashMap; +use std::hash::Hash; +use std::mem; + +use secp256k1::{Secp256k1, Signature}; +use secp256k1::key::PublicKey; +use bitcoin::util::hash::Sha256dHash; +use bitcoin::blockdata::script::Script; +use std::marker::Sized; +use ln::msgs::DecodeError; + +const MAX_BUF_SIZE: usize = 16 * 1024; + +pub struct Writer { writer: W } +pub struct Reader { reader: R } + +pub trait Writeable { + fn write(&self, writer: &mut Writer) -> Result<(), DecodeError>; +} + +pub trait Readable + where Self: Sized, + R: Read +{ + fn read(reader: &mut Reader) -> Result; +} + +macro_rules! writer_fn { + ($name:ident, $val_type:ty, $convfn:ident) => { + #[inline] + fn $name(&mut self, v: $val_type) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&$convfn(v))?) + } + } +} + +macro_rules! reader_fn { + ($name:ident, $val_type:ty, $val_size: expr, $convfn:ident) => { + #[inline] + fn $name(&mut self) -> Result<$val_type, DecodeError> { + let mut buf = [0; $val_size]; + self.reader.read_exact(&mut buf)?; + Ok($convfn(&buf)) + } + } +} + +use util::byte_utils::{be64_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be64}; + +impl Writer { + #[cfg(feature = "fuzztarget")] + pub fn new(writer: W) -> Writer { + return Writer { writer } + } + #[cfg(feature = "fuzztarget")] + pub fn into_inner(self) -> W { self.writer } + #[cfg(feature = "fuzztarget")] + pub fn get_ref(&self) -> &W { &self.writer } + writer_fn!(write_u64, u64, be64_to_array); + writer_fn!(write_u32, u32, be32_to_array); + writer_fn!(write_u16, u16, be16_to_array); + fn write_u8(&mut self, v: u8) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&[v])?) + } + fn write_bool(&mut self, v: bool) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&[if v {1} else {0}])?) + } + pub fn write_all(&mut self, v: &[u8]) -> Result<(), DecodeError> { + Ok(self.writer.write_all(v)?) + } +} + +impl Reader { + #[cfg(feature = "fuzztarget")] + pub fn new(reader: R) -> Reader { + return Reader { reader } + } + #[cfg(feature = "fuzztarget")] + pub fn into_inner(self) -> R { self.reader } + pub fn get_ref(&self) -> &R { &self.reader } + + reader_fn!(read_u16, u16, 2, slice_to_be16); + reader_fn!(read_u32, u32, 4, slice_to_be32); + reader_fn!(read_u64, u64, 8, slice_to_be64); + + fn read_u8(&mut self) -> Result { + let mut buf = [0; 1]; + self.reader.read_exact(&mut buf)?; + Ok(buf[0]) + } + fn read_bool(&mut self) -> Result { + let mut buf = [0; 1]; + self.reader.read_exact(&mut buf)?; + if buf[0] != 0 && buf[0] != 1 { + return Err(DecodeError::InvalidValue); + } + Ok(buf[0] == 1) + } + pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), DecodeError> { + Ok(self.reader.read_exact(buf)?) + } + pub fn read_to_end(&mut self, buf: &mut Vec) -> Result { + Ok(self.reader.read_to_end(buf)?) + } +} + +macro_rules! impl_writeable_primitive { + ($val_type:ty, $meth_write:ident, $meth_read:ident) => { + impl Writeable for $val_type { + #[inline] + fn write(&self, writer: &mut Writer) -> Result<(), DecodeError> { + writer.$meth_write(*self) + } + } + impl Readable for $val_type { + #[inline] + fn read(reader: &mut Reader) -> Result<$val_type, DecodeError> { + reader.$meth_read() + } + } + } +} + +impl_writeable_primitive!(u64, write_u64, read_u64); +impl_writeable_primitive!(u32, write_u32, read_u32); +impl_writeable_primitive!(u16, write_u16, read_u16); +impl_writeable_primitive!(u8, write_u8, read_u8); +impl_writeable_primitive!(bool, write_bool, read_bool); + +// Arrays +macro_rules! impl_array { + ( $size:expr ) => ( + impl Writeable for [T; $size] + where W: Write, + T: Writeable, + { + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + for i in self.iter() { i.write(w)?; } + Ok(()) + } + } + + impl Readable for [T; $size] + where R: Read, + T: Readable + Copy, + { + #[inline] + fn read(r: &mut Reader) -> Result<[T; $size], DecodeError> { + let mut ret = [T::read(r)?; $size]; + for item in ret.iter_mut().take($size).skip(1) { *item = T::read(r)?; } + Ok(ret) + } + } + ); +} + +//TODO: performance issue with [u8; size] with impl_array!() +impl_array!(32); // for channel id & hmac +impl_array!(33); // for PublicKey +impl_array!(64); // for Signature + +// Tuples +macro_rules! tuple_encode { + ($($x:ident),*) => ( + impl),*> Writeable for ($($x),*) { + #[inline] + #[allow(non_snake_case)] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + let &($(ref $x),*) = self; + $( $x.write(w)?; )* + Ok(()) + } + } + impl),*> Readable for ($($x),*) { + #[inline] + #[allow(non_snake_case)] + fn read(r: &mut Reader) -> Result<($($x),*), DecodeError> { + Ok(($({let $x = $x::read(r)?; $x }),*)) + } + } + ); +} + +tuple_encode!(T0, T1); +tuple_encode!(T0, T1, T2, T3); +tuple_encode!(T0, T1, T2, T3, T4, T5); +tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7); + +/* +// References +impl> Writeable for Box { + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { (**self).write(w) } +} + +impl> Readable for Box { + #[inline] + fn read(r: &mut Reader) -> Result, DecodeError> { + Ok(Box::new(T::read(r)?)) + } +} +*/ + +// HashMap +impl Writeable for HashMap + where W: Write, + K: Writeable + Eq + Hash, + V: Writeable +{ + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + (self.len() as u16).write(w)?; + for (key, value) in self.iter() { + key.write(w)?; + value.write(w)?; + } + Ok(()) + } +} + +impl Readable for HashMap + where R: Read, + K: Readable + Eq + Hash, + V: Readable +{ + #[inline] + fn read(r: &mut Reader) -> Result, DecodeError> { + let len: u16 = Readable::read(r)?; + let mut ret = HashMap::with_capacity(len as usize); + for _ in 0..len { + ret.insert(K::read(r)?, V::read(r)?); + } + Ok(ret) + } +} + + +// don't want [u8; sz] be encoded thru this +// to dump slice with size-prefix use vec +/* +impl> Writeable for [T] { + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + (self.len() as u16).write(w)?; + for c in self.iter() { c.write(w)?; } + Ok(()) + } +} +*/ + +// Vectors +impl> Writeable for Vec { + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + let byte_size = (self.len() as usize) + .checked_mul(mem::size_of::()) + .ok_or(DecodeError::InvalidLength)?; + if byte_size > MAX_BUF_SIZE { + return Err(DecodeError::InvalidLength); + } + (self.len() as u16).write(w)?; + // performance with Vec + for e in self.iter() { + e.write(w)?; + } + Ok(()) + } +} + +impl> Readable for Vec { + #[inline] + fn read(r: &mut Reader) -> Result, DecodeError> { + let len: u16 = Readable::read(r)?; + let byte_size = (len as usize) + .checked_mul(mem::size_of::()) + .ok_or(DecodeError::InvalidLength)?; + if byte_size > MAX_BUF_SIZE { + return Err(DecodeError::InvalidLength); + } + let mut ret = Vec::with_capacity(len as usize); + for _ in 0..len { ret.push(T::read(r)?); } + Ok(ret) + } +} + +impl Writeable for Option + where W: Write, + T: ::std::ops::Index<::std::ops::RangeFull, Output=[u8]> +{ + #[inline] + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + if let &Some(ref data) = self { + data[..].to_vec().write(w)?; + } else { + 0u16.write(w)?; + } + Ok(()) + } +} + +impl Readable for Option + where R: Read, + T: From>, +{ + #[inline] + fn read(r: &mut Reader) -> Result, DecodeError> { + match >::read(r)? as usize { + 0 => { + Ok(None) + }, + len => { + let mut buf = vec![0; len]; + r.read_exact(&mut buf)?; + Ok(Some(T::from(buf))) + } + } + } +} + +impl Writeable for Script { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.to_bytes().to_vec().write(w) + } +} + +impl Readable for Script { + fn read(r: &mut Reader) -> Result { + let len = >::read(r)? as usize; + let mut buf = vec![0; len]; + r.read_exact(&mut buf)?; + Ok(Script::from(buf)) + } +} + +impl Writeable for PublicKey { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.serialize().write(w) + } +} + +impl Readable for PublicKey { + fn read(r: &mut Reader) -> Result { + let buf: [u8; 33] = Readable::read(r)?; + match PublicKey::from_slice(&Secp256k1::without_caps(), &buf) { + Ok(key) => Ok(key), + Err(_) => return Err(DecodeError::BadPublicKey), + } + } +} + +impl Writeable for Sha256dHash { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.as_bytes().write(w) + } +} + +impl Readable for Sha256dHash { + fn read(r: &mut Reader) -> Result { + let buf: [u8; 32] = Readable::read(r)?; + Ok(From::from(&buf[..])) + } +} + +impl Writeable for Signature { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.serialize_compact(&Secp256k1::without_caps()).write(w) + } +} + +impl Readable for Signature { + fn read(r: &mut Reader) -> Result { + let buf: [u8; 64] = Readable::read(r)?; + match Signature::from_compact(&Secp256k1::without_caps(), &buf) { + Ok(sig) => Ok(sig), + Err(_) => return Err(DecodeError::BadSignature), + } + } +} + +macro_rules! impl_writeable { + ($st:ident, {$($field:ident),*}) => { + impl Writeable for $st { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + $( self.$field.write(w)?; )* + Ok(()) + } + } + + impl Readable for $st { + fn read(r: &mut Reader) -> Result { + Ok(Self { + $($field: Readable::read(r)?),* + }) + } + } + } +} From 7a1e0b36455ee73f005557d8e7d5ca7da4616a62 Mon Sep 17 00:00:00 2001 From: Yuntai Kyong Date: Sat, 1 Sep 2018 16:20:26 +0900 Subject: [PATCH 02/12] Implement Writeable for messages --- src/ln/msgs.rs | 589 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 589 insertions(+) diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 0859ab2b4aa..a44cdaf5041 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -10,6 +10,7 @@ use std::{cmp, fmt}; use std::result::Result; use util::{byte_utils, internal_traits, events}; +use util::ser::{Readable, Reader, Writeable, Writer}; pub trait MsgEncodable { fn encode(&self) -> Vec; @@ -1701,6 +1702,594 @@ impl MsgDecodable for ErrorMessage { } } +impl_writeable!(AcceptChannel, { + temporary_channel_id, + dust_limit_satoshis, + max_htlc_value_in_flight_msat, + channel_reserve_satoshis, + htlc_minimum_msat, + minimum_depth, + to_self_delay, + max_accepted_htlcs, + funding_pubkey, + revocation_basepoint, + payment_basepoint, + delayed_payment_basepoint, + htlc_basepoint, + first_per_commitment_point, + shutdown_scriptpubkey +}); + +impl_writeable!(AnnouncementSignatures, { + channel_id, + short_channel_id, + node_signature, + bitcoin_signature +}); + +impl Writeable for ChannelReestablish { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.channel_id.write(w)?; + self.next_local_commitment_number.write(w)?; + self.next_remote_commitment_number.write(w)?; + if let Some(ref data_loss_protect) = self.data_loss_protect { + data_loss_protect.your_last_per_commitment_secret.write(w)?; + data_loss_protect.my_current_per_commitment_point.write(w)?; + } + Ok(()) + } +} + +impl Readable for ChannelReestablish{ + fn read(r: &mut Reader) -> Result { + Ok(Self { + channel_id: Readable::read(r)?, + next_local_commitment_number: Readable::read(r)?, + next_remote_commitment_number: Readable::read(r)?, + data_loss_protect: { + let mut buf = [0; 32+33]; + match r.read_exact(&mut buf) { + Ok(()) => Some(DataLossProtect { + your_last_per_commitment_secret: { + let mut a: [u8; 32] = Default::default(); + a.copy_from_slice(&buf[..32]); + a + }, + my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &buf[32..]), + }), + Err(DecodeError::ShortRead) => None, + Err(e) => return Err(e) + } + } + }) + } +} + +impl_writeable!(ClosingSigned, { + channel_id, + fee_satoshis, + signature +}); + +impl_writeable!(CommitmentSigned, { + channel_id, + signature, + htlc_signatures +}); + +impl_writeable!(DecodedOnionErrorPacket, { + hmac, + failuremsg, + pad +}); + +impl_writeable!(FundingCreated, { + temporary_channel_id, + funding_txid, + funding_output_index, + signature +}); + +impl_writeable!(FundingSigned, { + channel_id, + signature +}); + +impl_writeable!(FundingLocked, { + channel_id, + next_per_commitment_point +}); + +impl_writeable!(GlobalFeatures, { + flags +}); + +impl_writeable!(LocalFeatures, { + flags +}); + +impl_writeable!(Init, { + global_features, + local_features +}); + +impl_writeable!(OpenChannel, { + chain_hash, + temporary_channel_id, + funding_satoshis, + push_msat, + dust_limit_satoshis, + max_htlc_value_in_flight_msat, + channel_reserve_satoshis, + htlc_minimum_msat, + feerate_per_kw, + to_self_delay, + max_accepted_htlcs, + funding_pubkey, + revocation_basepoint, + payment_basepoint, + delayed_payment_basepoint, + htlc_basepoint, + first_per_commitment_point, + channel_flags, + shutdown_scriptpubkey +}); + +impl_writeable!(RevokeAndACK, { + channel_id, + per_commitment_secret, + next_per_commitment_point +}); + +impl_writeable!(Shutdown, { + channel_id, + scriptpubkey +}); + +impl_writeable!(UpdateFailHTLC, { + channel_id, + htlc_id, + reason +}); + +impl_writeable!(UpdateFailMalformedHTLC, { + channel_id, + htlc_id, + sha256_of_onion, + failure_code +}); + +impl_writeable!(UpdateFee, { + channel_id, + feerate_per_kw +}); + +impl_writeable!(UpdateFulfillHTLC, { + channel_id, + htlc_id, + payment_preimage +}); + +impl_writeable!(OnionErrorPacket, { + data +}); + +impl Writeable for OnionPacket { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.version.write(w)?; + match self.public_key { + Ok(pubkey) => pubkey.write(w)?, + Err(_) => [0u8;33].write(w)?, + } + w.write_all(&self.hop_data)?; + self.hmac.write(w)?; + Ok(()) + } +} + +impl Readable for OnionPacket { + fn read(r: &mut Reader) -> Result { + Ok(OnionPacket { + version: Readable::read(r)?, + public_key: { + let mut buf = [0u8;33]; + r.read_exact(&mut buf)?; + PublicKey::from_slice(&Secp256k1::without_caps(), &buf) + }, + hop_data: { + let mut buf = [0u8;20*65]; + r.read_exact(&mut buf)?; + buf + }, + hmac: Readable::read(r)?, + }) + } +} + +impl_writeable!(UpdateAddHTLC, { + channel_id, + htlc_id, + amount_msat, + payment_hash, + cltv_expiry, + onion_routing_packet +}); + +impl Writeable for OnionRealm0HopData { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.short_channel_id.write(w)?; + self.amt_to_forward.write(w)?; + self.outgoing_cltv_value.write(w)?; + w.write_all(&[0;12])?; + Ok(()) + } +} + +impl Readable for OnionRealm0HopData { + fn read(r: &mut Reader) -> Result { + Ok(OnionRealm0HopData { + short_channel_id: Readable::read(r)?, + amt_to_forward: Readable::read(r)?, + outgoing_cltv_value: { + let v: u32 = Readable::read(r)?; + r.read_exact(&mut [0; 12])?; + v + } + }) + } +} + +impl Writeable for OnionHopData { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.realm.write(w)?; + self.data.write(w)?; + self.hmac.write(w)?; + Ok(()) + } +} + +impl Readable for OnionHopData { + fn read(r: &mut Reader) -> Result { + Ok(OnionHopData { + realm: { + let r: u8 = Readable::read(r)?; + if r != 0 { + return Err(DecodeError::UnknownRealmByte); + } + r + }, + data: Readable::read(r)?, + hmac: Readable::read(r)?, + }) + } +} + +impl Writeable for Ping { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.ponglen.write(w)?; + vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write + Ok(()) + } +} + +impl Readable for Ping { + fn read(r: &mut Reader) -> Result { + Ok(Ping { + ponglen: Readable::read(r)?, + byteslen: { + let byteslen = Readable::read(r)?; + r.read_exact(&mut vec![0u8; byteslen as usize][..])?; + byteslen + } + }) + } +} + +impl Writeable for Pong { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write + Ok(()) + } +} + +impl Readable for Pong { + fn read(r: &mut Reader) -> Result { + Ok(Pong { + byteslen: { + let byteslen = Readable::read(r)?; + r.read_exact(&mut vec![0u8; byteslen as usize][..])?; + byteslen + } + }) + } +} + +impl Writeable for UnsignedChannelAnnouncement { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.features.write(w)?; + self.chain_hash.write(w)?; + self.short_channel_id.write(w)?; + self.node_id_1.write(w)?; + self.node_id_2.write(w)?; + self.bitcoin_key_1.write(w)?; + self.bitcoin_key_2.write(w)?; + w.write_all(&self.excess_data[..])?; + Ok(()) + } +} + +impl Readable for UnsignedChannelAnnouncement { + fn read(r: &mut Reader) -> Result { + Ok(Self { + features: { + let f: GlobalFeatures = Readable::read(r)?; + if f.requires_unknown_bits() { + return Err(DecodeError::UnknownRequiredFeature); + } + f + }, + chain_hash: Readable::read(r)?, + short_channel_id: Readable::read(r)?, + node_id_1: Readable::read(r)?, + node_id_2: Readable::read(r)?, + bitcoin_key_1: Readable::read(r)?, + bitcoin_key_2: Readable::read(r)?, + excess_data: { + let mut excess_data = vec![]; + r.read_to_end(&mut excess_data)?; + excess_data + }, + }) + } +} + +impl_writeable!(ChannelAnnouncement,{ + node_signature_1, + node_signature_2, + bitcoin_signature_1, + bitcoin_signature_2, + contents +}); + +impl Writeable for UnsignedChannelUpdate { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.chain_hash.write(w)?; + self.short_channel_id.write(w)?; + self.timestamp.write(w)?; + self.flags.write(w)?; + self.cltv_expiry_delta.write(w)?; + self.htlc_minimum_msat.write(w)?; + self.fee_base_msat.write(w)?; + self.fee_proportional_millionths.write(w)?; + w.write_all(&self.excess_data[..])?; + Ok(()) + } +} + +impl Readable for UnsignedChannelUpdate { + fn read(r: &mut Reader) -> Result { + Ok(Self { + chain_hash: Readable::read(r)?, + short_channel_id: Readable::read(r)?, + timestamp: Readable::read(r)?, + flags: Readable::read(r)?, + cltv_expiry_delta: Readable::read(r)?, + htlc_minimum_msat: Readable::read(r)?, + fee_base_msat: Readable::read(r)?, + fee_proportional_millionths: Readable::read(r)?, + excess_data: { + let mut excess_data = vec![]; + r.read_to_end(&mut excess_data)?; + excess_data + }, + }) + } +} + +impl_writeable!(ChannelUpdate, { + signature, + contents +}); + +impl Writeable for ErrorMessage { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.channel_id.write(w)?; + self.data.as_bytes().to_vec().write(w)?; // write with size prefix + Ok(()) + } +} + +impl Readable for ErrorMessage { + fn read(r: &mut Reader) -> Result { + Ok(Self { + channel_id: Readable::read(r)?, + data: { + let mut sz: usize = >::read(r)? as usize; + let mut data = vec![]; + let data_len = r.read_to_end(&mut data)?; + sz = cmp::min(data_len, sz); + match String::from_utf8(data[..sz as usize].to_vec()) { + Ok(s) => s, + Err(_) => return Err(DecodeError::BadText), + } + } + }) + } +} + +impl Writeable for UnsignedNodeAnnouncement { + fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { + self.features.write(w)?; + self.timestamp.write(w)?; + self.node_id.write(w)?; + w.write_all(&self.rgb)?; + self.alias.write(w)?; + + let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18); + 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::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, 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)); + }, + } + } + ((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?; + w.write_all(&addr_slice[..])?; + w.write_all(&self.excess_address_data[..])?; + w.write_all(&self.excess_data[..])?; + Ok(()) + } +} + +impl Readable for UnsignedNodeAnnouncement { + fn read(r: &mut Reader) -> Result { + let features: GlobalFeatures = Readable::read(r)?; + if features.requires_unknown_bits() { + return Err(DecodeError::UnknownRequiredFeature); + } + let timestamp: u32 = Readable::read(r)?; + let node_id: PublicKey = Readable::read(r)?; + let mut rgb = [0; 3]; + r.read_exact(&mut rgb)?; + let alias: [u8; 32] = Readable::read(r)?; + + let addrlen: u16 = Readable::read(r)?; + let mut addr_readpos = 0; + let mut addresses = Vec::with_capacity(4); + let mut f: u8 = 0; + let mut excess = 0; + loop { + if addrlen <= addr_readpos { break; } + f = Readable::read(r)?; + match f { + 1 => { + if addresses.len() > 0 { + return Err(DecodeError::ExtraAddressesPerType); + } + if addrlen < addr_readpos + 1 + 6 { + return Err(DecodeError::BadLengthDescriptor); + } + addresses.push(NetAddress::IPv4 { + addr: { + let mut addr = [0; 4]; + r.read_exact(&mut addr)?; + addr + }, + port: Readable::read(r)?, + }); + addr_readpos += 1 + 6 + }, + 2 => { + if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) { + return Err(DecodeError::ExtraAddressesPerType); + } + if addrlen < addr_readpos + 1 + 18 { + return Err(DecodeError::BadLengthDescriptor); + } + addresses.push(NetAddress::IPv6 { + addr: { + let mut addr = [0; 16]; + r.read_exact(&mut addr)?; + addr + }, + port: Readable::read(r)?, + }); + addr_readpos += 1 + 18 + }, + 3 => { + if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) { + return Err(DecodeError::ExtraAddressesPerType); + } + if addrlen < addr_readpos + 1 + 12 { + return Err(DecodeError::BadLengthDescriptor); + } + addresses.push(NetAddress::OnionV2 { + addr: { + let mut addr = [0; 10]; + r.read_exact(&mut addr)?; + addr + }, + port: Readable::read(r)?, + }); + addr_readpos += 1 + 12 + }, + 4 => { + if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) { + return Err(DecodeError::ExtraAddressesPerType); + } + if addrlen < addr_readpos + 1 + 37 { + return Err(DecodeError::BadLengthDescriptor); + } + addresses.push(NetAddress::OnionV3 { + ed25519_pubkey: Readable::read(r)?, + checksum: Readable::read(r)?, + version: Readable::read(r)?, + port: Readable::read(r)?, + }); + addr_readpos += 1 + 37 + }, + _ => { excess = 1; break; } + } + } + + let mut excess_data = vec![]; + let excess_address_data = if addr_readpos < addrlen { + let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize]; + r.read_exact(&mut excess_address_data[excess..])?; + if excess == 1 { + excess_address_data[0] = f; + } + excess_address_data + } else { + if excess == 1 { + excess_data.push(f); + } + Vec::new() + }; + + Ok(UnsignedNodeAnnouncement { + features: features, + timestamp: timestamp, + node_id: node_id, + rgb: rgb, + alias: alias, + addresses: addresses, + excess_address_data: excess_address_data, + excess_data: { + r.read_to_end(&mut excess_data)?; + excess_data + }, + }) + } +} + +impl_writeable!(NodeAnnouncement, { + signature, + contents +}); + #[cfg(test)] mod tests { use hex; From 283834b33f182ff363e2c4d80da94a7cd2e1d19a Mon Sep 17 00:00:00 2001 From: Yuntai Kyong Date: Sat, 1 Sep 2018 16:21:39 +0900 Subject: [PATCH 03/12] Add fuzz targets for Writeable messages --- fuzz/Cargo.toml | 105 +++++++++++++++++- fuzz/fuzz_targets/msg_targets/gen_target.sh | 3 + .../msg_targets/gen_target_writeable.sh | 36 ++++++ .../msg_targets/msg_accept_channel_target.rs | 2 - .../msg_accept_channel_target_writeable.rs | 44 ++++++++ .../msg_announcement_signatures_target.rs | 2 - ...nnouncement_signatures_target_writeable.rs | 44 ++++++++ .../msg_channel_announcement_target.rs | 2 - ...g_channel_announcement_target_writeable.rs | 44 ++++++++ .../msg_channel_reestablish_target.rs | 2 - ...sg_channel_reestablish_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_channel_update_target.rs | 2 - .../msg_channel_update_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_closing_signed_target.rs | 2 - .../msg_closing_signed_target_writeable.rs | 44 ++++++++ .../msg_commitment_signed_target.rs | 2 - .../msg_commitment_signed_target_writeable.rs | 44 ++++++++ .../msg_decoded_onion_error_packet_target.rs | 2 - ...ded_onion_error_packet_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_error_message_target.rs | 2 - .../msg_error_message_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_funding_created_target.rs | 2 - .../msg_funding_created_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_funding_locked_target.rs | 2 - .../msg_funding_locked_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_funding_signed_target.rs | 2 - .../msg_funding_signed_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_init_target.rs | 2 - .../msg_targets/msg_init_target_writeable.rs | 44 ++++++++ .../msg_node_announcement_target.rs | 2 - .../msg_node_announcement_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_onion_hop_data_target.rs | 2 - .../msg_onion_hop_data_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_open_channel_target.rs | 2 - .../msg_open_channel_target_writeable.rs | 44 ++++++++ .../{ => msg_targets}/msg_ping_target.rs | 7 +- .../msg_targets/msg_ping_target_writeable.rs | 44 ++++++++ .../{ => msg_targets}/msg_pong_target.rs | 7 +- .../msg_targets/msg_pong_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_revoke_and_ack_target.rs | 2 - .../msg_revoke_and_ack_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_shutdown_target.rs | 2 - .../msg_shutdown_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_target_template.txt | 2 - .../msg_targets/msg_update_add_htlc_target.rs | 2 - .../msg_update_add_htlc_target_writeable.rs | 44 ++++++++ .../msg_update_fail_htlc_target.rs | 2 - .../msg_update_fail_htlc_target_writeable.rs | 44 ++++++++ .../msg_update_fail_malformed_htlc_target.rs | 2 - ...te_fail_malformed_htlc_target_writeable.rs | 44 ++++++++ .../msg_targets/msg_update_fee_target.rs | 2 - .../msg_update_fee_target_writeable.rs | 44 ++++++++ .../msg_update_fulfill_htlc_target.rs | 2 - ...sg_update_fulfill_htlc_target_writeable.rs | 44 ++++++++ fuzz/fuzz_targets/msg_targets/utils.rs | 96 ++++++++++++++++ fuzz/travis-fuzz.sh | 3 +- 56 files changed, 1346 insertions(+), 59 deletions(-) create mode 100755 fuzz/fuzz_targets/msg_targets/gen_target_writeable.sh create mode 100644 fuzz/fuzz_targets/msg_targets/msg_accept_channel_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_channel_update_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_closing_signed_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_error_message_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_funding_created_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_funding_locked_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_funding_signed_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_init_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_node_announcement_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_open_channel_target_writeable.rs rename fuzz/fuzz_targets/{ => msg_targets}/msg_ping_target.rs (84%) create mode 100644 fuzz/fuzz_targets/msg_targets/msg_ping_target_writeable.rs rename fuzz/fuzz_targets/{ => msg_targets}/msg_pong_target.rs (84%) create mode 100644 fuzz/fuzz_targets/msg_targets/msg_pong_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_shutdown_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_update_fee_target_writeable.rs create mode 100644 fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target_writeable.rs diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml index 3cd249ea821..145d125562c 100644 --- a/fuzz/Cargo.toml +++ b/fuzz/Cargo.toml @@ -54,11 +54,11 @@ path = "fuzz_targets/chanmon_deser_target.rs" # message fuzz targets [[bin]] name = "msg_ping_target" -path = "fuzz_targets/msg_ping_target.rs" +path = "fuzz_targets/msg_targets/msg_ping_target.rs" [[bin]] name = "msg_pong_target" -path = "fuzz_targets/msg_pong_target.rs" +path = "fuzz_targets/msg_targets/msg_pong_target.rs" [[bin]] name = "msg_error_message_target" @@ -151,3 +151,104 @@ path = "fuzz_targets/msg_targets/msg_node_announcement_target.rs" [[bin]] name = "msg_onion_hop_data_target" path = "fuzz_targets/msg_targets/msg_onion_hop_data_target.rs" + +# message fuzz targets with Writeable +[[bin]] +name = "msg_accept_channel_target_writeable" +path = "fuzz_targets/msg_targets/msg_accept_channel_target_writeable.rs" + +[[bin]] +name = "msg_announcement_signatures_target_writeable" +path = "fuzz_targets/msg_targets/msg_announcement_signatures_target_writeable.rs" + +[[bin]] +name = "msg_channel_reestablish_target_writeable" +path = "fuzz_targets/msg_targets/msg_channel_reestablish_target_writeable.rs" + +[[bin]] +name = "msg_closing_signed_target_writeable" +path = "fuzz_targets/msg_targets/msg_closing_signed_target_writeable.rs" + +[[bin]] +name = "msg_commitment_signed_target_writeable" +path = "fuzz_targets/msg_targets/msg_commitment_signed_target_writeable.rs" + +[[bin]] +name = "msg_decoded_onion_error_packet_target_writeable" +path = "fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target_writeable.rs" + +[[bin]] +name = "msg_funding_created_target_writeable" +path = "fuzz_targets/msg_targets/msg_funding_created_target_writeable.rs" + +[[bin]] +name = "msg_funding_locked_target_writeable" +path = "fuzz_targets/msg_targets/msg_funding_locked_target_writeable.rs" + +[[bin]] +name = "msg_funding_signed_target_writeable" +path = "fuzz_targets/msg_targets/msg_funding_signed_target_writeable.rs" + +[[bin]] +name = "msg_init_target_writeable" +path = "fuzz_targets/msg_targets/msg_init_target_writeable.rs" + +[[bin]] +name = "msg_open_channel_target_writeable" +path = "fuzz_targets/msg_targets/msg_open_channel_target_writeable.rs" + +[[bin]] +name = "msg_revoke_and_ack_target_writeable" +path = "fuzz_targets/msg_targets/msg_revoke_and_ack_target_writeable.rs" + +[[bin]] +name = "msg_shutdown_target_writeable" +path = "fuzz_targets/msg_targets/msg_shutdown_target_writeable.rs" + +[[bin]] +name = "msg_update_fail_htlc_target_writeable" +path = "fuzz_targets/msg_targets/msg_update_fail_htlc_target_writeable.rs" + +[[bin]] +name = "msg_update_fail_malformed_htlc_target_writeable" +path = "fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target_writeable.rs" + +[[bin]] +name = "msg_update_fee_target_writeable" +path = "fuzz_targets/msg_targets/msg_update_fee_target_writeable.rs" + +[[bin]] +name = "msg_update_fulfill_htlc_target_writeable" +path = "fuzz_targets/msg_targets/msg_update_fulfill_htlc_target_writeable.rs" + +[[bin]] +name = "msg_channel_announcement_target_writeable" +path = "fuzz_targets/msg_targets/msg_channel_announcement_target_writeable.rs" + +[[bin]] +name = "msg_channel_update_target_writeable" +path = "fuzz_targets/msg_targets/msg_channel_update_target_writeable.rs" + +[[bin]] +name = "msg_node_announcement_target_writeable" +path = "fuzz_targets/msg_targets/msg_node_announcement_target_writeable.rs" + +[[bin]] +name = "msg_update_add_htlc_target_writeable" +path = "fuzz_targets/msg_targets/msg_update_add_htlc_target_writeable.rs" + +[[bin]] +name = "msg_error_message_target_writeable" +path = "fuzz_targets/msg_targets/msg_error_message_target_writeable.rs" + +[[bin]] +name = "msg_onion_hop_data_target_writeable" +path = "fuzz_targets/msg_targets/msg_onion_hop_data_target_writeable.rs" + +[[bin]] +name = "msg_ping_target_writeable" +path = "fuzz_targets/msg_targets/msg_ping_target_writeable.rs" + +[[bin]] +name = "msg_pong_target_writeable" +path = "fuzz_targets/msg_targets/msg_pong_target_writeable.rs" diff --git a/fuzz/fuzz_targets/msg_targets/gen_target.sh b/fuzz/fuzz_targets/msg_targets/gen_target.sh index 32f071e85cd..cfd100f3dfe 100755 --- a/fuzz/fuzz_targets/msg_targets/gen_target.sh +++ b/fuzz/fuzz_targets/msg_targets/gen_target.sh @@ -31,3 +31,6 @@ GEN_TEST NodeAnnouncement test_msg_exact "" GEN_TEST UpdateAddHTLC test_msg_hole ", 85, 33" GEN_TEST ErrorMessage test_msg_hole ", 32, 2" GEN_TEST OnionHopData test_msg_hole ", 1+8+8+4, 12" + +GEN_TEST Ping test_msg_simple "" +GEN_TEST Pong test_msg_simple "" diff --git a/fuzz/fuzz_targets/msg_targets/gen_target_writeable.sh b/fuzz/fuzz_targets/msg_targets/gen_target_writeable.sh new file mode 100755 index 00000000000..5ac3af0af03 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/gen_target_writeable.sh @@ -0,0 +1,36 @@ +#!/bin/sh + +GEN_TEST() { + tn=$(echo $1 | sed 's/\([a-z0-9]\)\([A-Z]\)/\1_\2/g') + fn=msg_$(echo $tn | tr '[:upper:]' '[:lower:]')_target_writeable.rs + cat msg_target_template.txt | sed s/MSG_TARGET/$1/ | sed "s/TEST_MSG/$2/" | sed "s/EXTRA_ARGS/$3/" > $fn +} + +GEN_TEST AcceptChannel test_msg_writeable "" +GEN_TEST AnnouncementSignatures test_msg_writeable "" +GEN_TEST ChannelReestablish test_msg_writeable "" +GEN_TEST ClosingSigned test_msg_writeable "" +GEN_TEST CommitmentSigned test_msg_writeable "" +GEN_TEST DecodedOnionErrorPacket test_msg_writeable "" +GEN_TEST FundingCreated test_msg_writeable "" +GEN_TEST FundingLocked test_msg_writeable "" +GEN_TEST FundingSigned test_msg_writeable "" +GEN_TEST Init test_msg_writeable "" +GEN_TEST OpenChannel test_msg_writeable "" +GEN_TEST RevokeAndACK test_msg_writeable "" +GEN_TEST Shutdown test_msg_writeable "" +GEN_TEST UpdateFailHTLC test_msg_writeable "" +GEN_TEST UpdateFailMalformedHTLC test_msg_writeable "" +GEN_TEST UpdateFee test_msg_writeable "" +GEN_TEST UpdateFulfillHTLC test_msg_writeable "" + +GEN_TEST ChannelAnnouncement test_msg_writeable_exact "" +GEN_TEST ChannelUpdate test_msg_writeable_exact "" +GEN_TEST NodeAnnouncement test_msg_writeable_exact "" + +GEN_TEST UpdateAddHTLC test_msg_writeable_hole ", 85, 33" +GEN_TEST ErrorMessage test_msg_writeable_hole ", 32, 2" +GEN_TEST OnionHopData test_msg_writeable_hole ", 1+8+8+4, 12" + +GEN_TEST Ping test_msg_writeable_simple "" +GEN_TEST Pong test_msg_writeable_simple "" diff --git a/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target.rs b/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target.rs index d7f0a881380..ef3ae4cdf4e 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target_writeable.rs new file mode 100644 index 00000000000..745fa08554e --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_accept_channel_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::AcceptChannel, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target.rs b/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target.rs index 33c52b33e9e..f32aad1a198 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target_writeable.rs new file mode 100644 index 00000000000..1f5d40e70f0 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_announcement_signatures_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::AnnouncementSignatures, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target.rs index 1252cfe79de..e814c4fae52 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target_writeable.rs new file mode 100644 index 00000000000..1f2b731bb66 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_announcement_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_exact!(msgs::ChannelAnnouncement, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target.rs index 38f9160450f..8532ac12050 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target_writeable.rs new file mode 100644 index 00000000000..e72d987620f --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_reestablish_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::ChannelReestablish, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_update_target.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_update_target.rs index c488fb6da97..8968ee33ea0 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_channel_update_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_update_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_channel_update_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_channel_update_target_writeable.rs new file mode 100644 index 00000000000..4de1e3cabb1 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_channel_update_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_exact!(msgs::ChannelUpdate, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target.rs b/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target.rs index 504e1e37633..70d96920940 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target_writeable.rs new file mode 100644 index 00000000000..cb59cae82e4 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_closing_signed_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::ClosingSigned, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target.rs b/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target.rs index 701dd1fb9e2..c70437b8409 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target_writeable.rs new file mode 100644 index 00000000000..536179ae15d --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_commitment_signed_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::CommitmentSigned, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target.rs b/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target.rs index 56a5fb9f676..173f13d3fde 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target_writeable.rs new file mode 100644 index 00000000000..da8da651e02 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_decoded_onion_error_packet_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::DecodedOnionErrorPacket, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_error_message_target.rs b/fuzz/fuzz_targets/msg_targets/msg_error_message_target.rs index 97e15c3c4b7..f565e80f919 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_error_message_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_error_message_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_error_message_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_error_message_target_writeable.rs new file mode 100644 index 00000000000..2b5a0f3b6f6 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_error_message_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_hole!(msgs::ErrorMessage, data, 32, 2); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_created_target.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_created_target.rs index 7289267c23b..b9c67ae3350 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_funding_created_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_created_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_created_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_created_target_writeable.rs new file mode 100644 index 00000000000..812f1cbde1f --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_created_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::FundingCreated, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target.rs index bfafdf48979..499be0049dc 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target_writeable.rs new file mode 100644 index 00000000000..0a2261ad10c --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_locked_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::FundingLocked, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target.rs index 6a2b6ac3a7d..2f63bd0bd16 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target_writeable.rs new file mode 100644 index 00000000000..f24f0c311dd --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_funding_signed_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::FundingSigned, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_init_target.rs b/fuzz/fuzz_targets/msg_targets/msg_init_target.rs index 8a5ee76f5b5..2013a540650 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_init_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_init_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_init_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_init_target_writeable.rs new file mode 100644 index 00000000000..fa773a4134c --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_init_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::Init, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target.rs b/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target.rs index 54b9cb684b5..1a0c9e062f2 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target_writeable.rs new file mode 100644 index 00000000000..84b7442c7fd --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_node_announcement_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_exact!(msgs::NodeAnnouncement, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target.rs b/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target.rs index 70849c18981..398dd2886bf 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target_writeable.rs new file mode 100644 index 00000000000..458daa50bc0 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_onion_hop_data_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_hole!(msgs::OnionHopData, data, 1+8+8+4, 12); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_open_channel_target.rs b/fuzz/fuzz_targets/msg_targets/msg_open_channel_target.rs index 737bc2f0c63..01082d8b77a 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_open_channel_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_open_channel_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_open_channel_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_open_channel_target_writeable.rs new file mode 100644 index 00000000000..d5f61387330 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_open_channel_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::OpenChannel, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_ping_target.rs b/fuzz/fuzz_targets/msg_targets/msg_ping_target.rs similarity index 84% rename from fuzz/fuzz_targets/msg_ping_target.rs rename to fuzz/fuzz_targets/msg_targets/msg_ping_target.rs index c9fb3418917..4a792f60399 100644 --- a/fuzz/fuzz_targets/msg_ping_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_ping_target.rs @@ -3,16 +3,15 @@ extern crate lightning; +use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable, Ping}; +mod utils; #[inline] pub fn do_test(data: &[u8]) { reset_rng_state(); - if let Ok(msg) = Ping::decode(data) { - let _ = msg.encode(); - } + test_msg_simple!(msgs::Ping, data); } #[cfg(feature = "afl")] diff --git a/fuzz/fuzz_targets/msg_targets/msg_ping_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_ping_target_writeable.rs new file mode 100644 index 00000000000..05d960d9e5b --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_ping_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_simple!(msgs::Ping, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_pong_target.rs b/fuzz/fuzz_targets/msg_targets/msg_pong_target.rs similarity index 84% rename from fuzz/fuzz_targets/msg_pong_target.rs rename to fuzz/fuzz_targets/msg_targets/msg_pong_target.rs index d4572d33064..ae5d22a3309 100644 --- a/fuzz/fuzz_targets/msg_pong_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_pong_target.rs @@ -3,16 +3,15 @@ extern crate lightning; +use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable, Pong}; +mod utils; #[inline] pub fn do_test(data: &[u8]) { reset_rng_state(); - if let Ok(msg) = Pong::decode(data) { - let _ = msg.encode(); - } + test_msg_simple!(msgs::Pong, data); } #[cfg(feature = "afl")] diff --git a/fuzz/fuzz_targets/msg_targets/msg_pong_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_pong_target_writeable.rs new file mode 100644 index 00000000000..b147fd4af18 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_pong_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_simple!(msgs::Pong, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target.rs b/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target.rs index 6086d279cb2..804e4ba4b2f 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target_writeable.rs new file mode 100644 index 00000000000..260e8254c2d --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_revoke_and_ack_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::RevokeAndACK, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_shutdown_target.rs b/fuzz/fuzz_targets/msg_targets/msg_shutdown_target.rs index 29243dab6ae..4cc58f28d59 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_shutdown_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_shutdown_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_shutdown_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_shutdown_target_writeable.rs new file mode 100644 index 00000000000..e4ed2d5871c --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_shutdown_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::Shutdown, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_target_template.txt b/fuzz/fuzz_targets/msg_targets/msg_target_template.txt index 6053c041cf7..d3bda1aa335 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_target_template.txt +++ b/fuzz/fuzz_targets/msg_targets/msg_target_template.txt @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target.rs b/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target.rs index 64806f20fa4..cfccc21a3f4 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target_writeable.rs new file mode 100644 index 00000000000..0d7e0908a50 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_update_add_htlc_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable_hole!(msgs::UpdateAddHTLC, data, 85, 33); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target.rs index 27eaf123e7f..90827f31c95 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target_writeable.rs new file mode 100644 index 00000000000..1bbfcc130ee --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fail_htlc_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::UpdateFailHTLC, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target.rs index eb6dc94aa1d..a045dea6038 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target_writeable.rs new file mode 100644 index 00000000000..4ae38747263 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fail_malformed_htlc_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::UpdateFailMalformedHTLC, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fee_target.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fee_target.rs index eec1d262459..6f5ff3e47a9 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_update_fee_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fee_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fee_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fee_target_writeable.rs new file mode 100644 index 00000000000..23e63b56939 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fee_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::UpdateFee, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target.rs index 3dd87b30ca5..c5dd3235657 100644 --- a/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target.rs +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target.rs @@ -6,8 +6,6 @@ extern crate lightning; use lightning::ln::msgs; use lightning::util::reset_rng_state; -use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; - mod utils; #[inline] diff --git a/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target_writeable.rs b/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target_writeable.rs new file mode 100644 index 00000000000..1fb43ea57c1 --- /dev/null +++ b/fuzz/fuzz_targets/msg_targets/msg_update_fulfill_htlc_target_writeable.rs @@ -0,0 +1,44 @@ +// This file is auto-generated by gen_target.sh based on msg_target_template.txt +// To modify it, modify msg_target_template.txt and run gen_target.sh instead. + +extern crate lightning; + +use lightning::ln::msgs; +use lightning::util::reset_rng_state; + +mod utils; + +#[inline] +pub fn do_test(data: &[u8]) { + reset_rng_state(); + test_msg_writeable!(msgs::UpdateFulfillHTLC, data); +} + +#[cfg(feature = "afl")] +#[macro_use] extern crate afl; +#[cfg(feature = "afl")] +fn main() { + fuzz!(|data| { + do_test(data); + }); +} + +#[cfg(feature = "honggfuzz")] +#[macro_use] extern crate honggfuzz; +#[cfg(feature = "honggfuzz")] +fn main() { + loop { + fuzz!(|data| { + do_test(data); + }); + } +} + +extern crate hex; +#[cfg(test)] +mod tests { + #[test] + fn duplicate_crash() { + super::do_test(&::hex::decode("00").unwrap()); + } +} diff --git a/fuzz/fuzz_targets/msg_targets/utils.rs b/fuzz/fuzz_targets/msg_targets/utils.rs index 64bfd89326b..d13c8c67eab 100644 --- a/fuzz/fuzz_targets/msg_targets/utils.rs +++ b/fuzz/fuzz_targets/msg_targets/utils.rs @@ -4,6 +4,7 @@ macro_rules! test_msg { ($MsgType: path, $data: ident) => { { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; if let Ok(msg) = <$MsgType as MsgDecodable>::decode($data){ let enc = msg.encode(); assert_eq!(&$data[..enc.len()], &enc[..]); @@ -12,10 +13,23 @@ macro_rules! test_msg { } } +#[macro_export] +macro_rules! test_msg_simple { + ($MsgType: path, $data: ident) => { + { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; + if let Ok(msg) = <$MsgType as MsgDecodable>::decode($data){ + let _ = msg.encode(); + } + } + } +} + #[macro_export] macro_rules! test_msg_exact { ($MsgType: path, $data: ident) => { { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; if let Ok(msg) = <$MsgType as MsgDecodable>::decode($data){ let enc = msg.encode(); assert_eq!(&$data[..], &enc[..]); @@ -28,6 +42,7 @@ macro_rules! test_msg_exact { macro_rules! test_msg_hole { ($MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => { { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; if let Ok(msg) = <$MsgType as MsgDecodable>::decode($data){ let enc = msg.encode(); assert_eq!(&$data[..$hole], &enc[..$hole]); @@ -36,3 +51,84 @@ macro_rules! test_msg_hole { } } } + +#[macro_export] +macro_rules! test_msg_writeable { + ($MsgType: path, $data: ident) => { + { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; + use lightning::util::ser::{Writer, Reader, Writeable, Readable}; + let mut r = Reader::new(::std::io::Cursor::new($data)); + if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { + let p = r.get_ref().position() as usize; + let mut w = Writer::new(::std::io::Cursor::new(vec![])); + msg.write(&mut w).unwrap(); + + let buf = w.into_inner().into_inner(); + assert_eq!(&r.into_inner().into_inner()[..p], &buf[..p]); + + let encoded = <$MsgType as MsgDecodable>::decode(&buf[..]).unwrap().encode(); + assert_eq!(&$data[..p], &encoded[..]); + } + } + } +} + +#[macro_export] +macro_rules! test_msg_writeable_simple { + ($MsgType: path, $data: ident) => { + { + use lightning::util::ser::{Writer, Reader, Writeable, Readable}; + let mut r = Reader::new(::std::io::Cursor::new($data)); + if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { + msg.write(&mut Writer::new(::std::io::Cursor::new(vec![]))).unwrap(); + } + } + } +} + +#[macro_export] +macro_rules! test_msg_writeable_exact { + ($MsgType: path, $data: ident) => { + { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; + use lightning::util::ser::{Writer, Reader, Writeable, Readable}; + let mut r = Reader::new(::std::io::Cursor::new($data)); + if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { + let mut w = Writer::new(::std::io::Cursor::new(vec![])); + msg.write(&mut w).unwrap(); + + let buf = w.into_inner().into_inner(); + assert_eq!(&r.into_inner().into_inner()[..], &buf[..]); + + let encoded = <$MsgType as MsgDecodable>::decode(&buf[..]).unwrap().encode(); + assert_eq!(&$data[..], &encoded[..]); + } + } + } +} + +#[macro_export] +macro_rules! test_msg_writeable_hole { + ($MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => { + { + use lightning::ln::msgs::{MsgEncodable, MsgDecodable}; + use lightning::util::ser::{Writer, Reader, Writeable, Readable}; + let mut r = Reader::new(::std::io::Cursor::new($data)); + if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { + let mut w = Writer::new(::std::io::Cursor::new(vec![])); + msg.write(&mut w).unwrap(); + let p = w.get_ref().position() as usize; + + let buf = w.into_inner().into_inner(); + eprintln!("buf({})", buf.len()); + assert_eq!(&r.get_ref().get_ref()[..$hole], &buf[..$hole]); + assert_eq!(&r.get_ref().get_ref()[$hole+$hole_len..p], &buf[$hole+$hole_len..]); + + let encoded = <$MsgType as MsgDecodable>::decode(&buf[..]).unwrap().encode(); + assert_eq!(&$data[..$hole], &encoded[..$hole]); + assert_eq!(&$data[$hole+$hole_len..p], &encoded[$hole+$hole_len..]); + } + } + } +} diff --git a/fuzz/travis-fuzz.sh b/fuzz/travis-fuzz.sh index 86b57fa0b04..a9eeb0b95eb 100755 --- a/fuzz/travis-fuzz.sh +++ b/fuzz/travis-fuzz.sh @@ -4,11 +4,12 @@ set -e pushd fuzz_targets/msg_targets rm *_target.rs ./gen_target.sh +./gen_target_writeable.sh [ "$(git diff)" != "" ] && exit 1 popd cargo install --force honggfuzz -for TARGET in fuzz_targets/*.rs fuzz_targets/msg_targets/*_target.rs; do +for TARGET in fuzz_targets/*.rs fuzz_targets/msg_targets/*_target.rs fuzz_targets/msg_targets/*_target_writeable.rs; do FILENAME=$(basename $TARGET) FILE="${FILENAME%.*}" HFUZZ_BUILD_ARGS="--features honggfuzz_fuzz" HFUZZ_RUN_ARGS="-N1000000 --exit_upon_crash -v" cargo hfuzz run $FILE From 398200e7d1ff49013980d7adc0f942f39a36c167 Mon Sep 17 00:00:00 2001 From: Yuntai Kyong Date: Mon, 10 Sep 2018 16:01:39 +0900 Subject: [PATCH 04/12] Fixes in Writeable/Readable un-fuzz-target only for get_ref() and inner_into() move up use indentation fixes remvoe unused implementation --- src/util/ser.rs | 188 +++++++++++++++--------------------------------- 1 file changed, 58 insertions(+), 130 deletions(-) diff --git a/src/util/ser.rs b/src/util/ser.rs index 7630b5abc6b..01232067270 100644 --- a/src/util/ser.rs +++ b/src/util/ser.rs @@ -11,6 +11,8 @@ use bitcoin::blockdata::script::Script; use std::marker::Sized; use ln::msgs::DecodeError; +use util::byte_utils::{be64_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be64}; + const MAX_BUF_SIZE: usize = 16 * 1024; pub struct Writer { writer: W } @@ -27,40 +29,22 @@ pub trait Readable fn read(reader: &mut Reader) -> Result; } -macro_rules! writer_fn { - ($name:ident, $val_type:ty, $convfn:ident) => { - #[inline] - fn $name(&mut self, v: $val_type) -> Result<(), DecodeError> { - Ok(self.writer.write_all(&$convfn(v))?) - } - } -} - -macro_rules! reader_fn { - ($name:ident, $val_type:ty, $val_size: expr, $convfn:ident) => { - #[inline] - fn $name(&mut self) -> Result<$val_type, DecodeError> { - let mut buf = [0; $val_size]; - self.reader.read_exact(&mut buf)?; - Ok($convfn(&buf)) - } - } -} - -use util::byte_utils::{be64_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be64}; impl Writer { - #[cfg(feature = "fuzztarget")] pub fn new(writer: W) -> Writer { return Writer { writer } } - #[cfg(feature = "fuzztarget")] pub fn into_inner(self) -> W { self.writer } - #[cfg(feature = "fuzztarget")] pub fn get_ref(&self) -> &W { &self.writer } - writer_fn!(write_u64, u64, be64_to_array); - writer_fn!(write_u32, u32, be32_to_array); - writer_fn!(write_u16, u16, be16_to_array); + fn write_u64(&mut self, v: u64) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&be64_to_array(v))?) + } + fn write_u32(&mut self, v: u32) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&be32_to_array(v))?) + } + fn write_u16(&mut self, v: u16) -> Result<(), DecodeError> { + Ok(self.writer.write_all(&be16_to_array(v))?) + } fn write_u8(&mut self, v: u8) -> Result<(), DecodeError> { Ok(self.writer.write_all(&[v])?) } @@ -73,17 +57,29 @@ impl Writer { } impl Reader { - #[cfg(feature = "fuzztarget")] pub fn new(reader: R) -> Reader { return Reader { reader } } - #[cfg(feature = "fuzztarget")] - pub fn into_inner(self) -> R { self.reader } + pub fn into_inner(self) -> R { self.reader } pub fn get_ref(&self) -> &R { &self.reader } - reader_fn!(read_u16, u16, 2, slice_to_be16); - reader_fn!(read_u32, u32, 4, slice_to_be32); - reader_fn!(read_u64, u64, 8, slice_to_be64); + fn read_u64(&mut self) -> Result { + let mut buf = [0; 8]; + self.reader.read_exact(&mut buf)?; + Ok(slice_to_be64(&buf)) + } + + fn read_u32(&mut self) -> Result { + let mut buf = [0; 4]; + self.reader.read_exact(&mut buf)?; + Ok(slice_to_be32(&buf)) + } + + fn read_u16(&mut self) -> Result { + let mut buf = [0; 2]; + self.reader.read_exact(&mut buf)?; + Ok(slice_to_be16(&buf)) + } fn read_u8(&mut self) -> Result { let mut buf = [0; 1]; @@ -148,7 +144,7 @@ macro_rules! impl_array { T: Readable + Copy, { #[inline] - fn read(r: &mut Reader) -> Result<[T; $size], DecodeError> { + fn read(r: &mut Reader) -> Result { let mut ret = [T::read(r)?; $size]; for item in ret.iter_mut().take($size).skip(1) { *item = T::read(r)?; } Ok(ret) @@ -162,48 +158,6 @@ impl_array!(32); // for channel id & hmac impl_array!(33); // for PublicKey impl_array!(64); // for Signature -// Tuples -macro_rules! tuple_encode { - ($($x:ident),*) => ( - impl),*> Writeable for ($($x),*) { - #[inline] - #[allow(non_snake_case)] - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { - let &($(ref $x),*) = self; - $( $x.write(w)?; )* - Ok(()) - } - } - impl),*> Readable for ($($x),*) { - #[inline] - #[allow(non_snake_case)] - fn read(r: &mut Reader) -> Result<($($x),*), DecodeError> { - Ok(($({let $x = $x::read(r)?; $x }),*)) - } - } - ); -} - -tuple_encode!(T0, T1); -tuple_encode!(T0, T1, T2, T3); -tuple_encode!(T0, T1, T2, T3, T4, T5); -tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7); - -/* -// References -impl> Writeable for Box { - #[inline] - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { (**self).write(w) } -} - -impl> Readable for Box { - #[inline] - fn read(r: &mut Reader) -> Result, DecodeError> { - Ok(Box::new(T::read(r)?)) - } -} -*/ - // HashMap impl Writeable for HashMap where W: Write, @@ -227,7 +181,7 @@ impl Readable for HashMap V: Readable { #[inline] - fn read(r: &mut Reader) -> Result, DecodeError> { + fn read(r: &mut Reader) -> Result { let len: u16 = Readable::read(r)?; let mut ret = HashMap::with_capacity(len as usize); for _ in 0..len { @@ -237,20 +191,6 @@ impl Readable for HashMap } } - -// don't want [u8; sz] be encoded thru this -// to dump slice with size-prefix use vec -/* -impl> Writeable for [T] { - #[inline] - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { - (self.len() as u16).write(w)?; - for c in self.iter() { c.write(w)?; } - Ok(()) - } -} -*/ - // Vectors impl> Writeable for Vec { #[inline] @@ -272,7 +212,7 @@ impl> Writeable for Vec { impl> Readable for Vec { #[inline] - fn read(r: &mut Reader) -> Result, DecodeError> { + fn read(r: &mut Reader) -> Result { let len: u16 = Readable::read(r)?; let byte_size = (len as usize) .checked_mul(mem::size_of::()) @@ -286,40 +226,6 @@ impl> Readable for Vec { } } -impl Writeable for Option - where W: Write, - T: ::std::ops::Index<::std::ops::RangeFull, Output=[u8]> -{ - #[inline] - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { - if let &Some(ref data) = self { - data[..].to_vec().write(w)?; - } else { - 0u16.write(w)?; - } - Ok(()) - } -} - -impl Readable for Option - where R: Read, - T: From>, -{ - #[inline] - fn read(r: &mut Reader) -> Result, DecodeError> { - match >::read(r)? as usize { - 0 => { - Ok(None) - }, - len => { - let mut buf = vec![0; len]; - r.read_exact(&mut buf)?; - Ok(Some(T::from(buf))) - } - } - } -} - impl Writeable for Script { fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { self.to_bytes().to_vec().write(w) @@ -327,7 +233,7 @@ impl Writeable for Script { } impl Readable for Script { - fn read(r: &mut Reader) -> Result { + fn read(r: &mut Reader) -> Result { let len = >::read(r)? as usize; let mut buf = vec![0; len]; r.read_exact(&mut buf)?; @@ -335,6 +241,28 @@ impl Readable for Script { } } +impl Writeable for Option