X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=fuzz%2Ffuzz_targets%2Frouter_target.rs;h=9d06c19d6386336cb4f95cbac7e769f86c2d65b8;hb=cd21a357d85eec93668f2526e300746a921cbad2;hp=452369e5308dd7b5fcc3203d72792194caa7a59e;hpb=1b8f4acb275621d52316ae1e5f1059b15f3a120e;p=rust-lightning diff --git a/fuzz/fuzz_targets/router_target.rs b/fuzz/fuzz_targets/router_target.rs index 452369e5..9d06c19d 100644 --- a/fuzz/fuzz_targets/router_target.rs +++ b/fuzz/fuzz_targets/router_target.rs @@ -1,22 +1,29 @@ extern crate bitcoin; +extern crate bitcoin_hashes; extern crate lightning; extern crate secp256k1; +use bitcoin_hashes::sha256d::Hash as Sha256dHash; +use bitcoin::blockdata::script::{Script, Builder}; +use bitcoin::blockdata::block::Block; +use bitcoin::blockdata::transaction::Transaction; + +use lightning::chain::chaininterface::{ChainError,ChainWatchInterface}; use lightning::ln::channelmanager::ChannelDetails; use lightning::ln::msgs; -use lightning::ln::msgs::{MsgDecodable, RoutingMessageHandler}; +use lightning::ln::msgs::{RoutingMessageHandler}; use lightning::ln::router::{Router, RouteHint}; -use lightning::util::reset_rng_state; use lightning::util::logger::Logger; +use lightning::util::ser::Readable; use secp256k1::key::PublicKey; -use secp256k1::Secp256k1; mod utils; use utils::test_logger; use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; #[inline] pub fn slice_to_be16(v: &[u8]) -> u16 { @@ -44,46 +51,92 @@ pub fn slice_to_be64(v: &[u8]) -> u64 { ((v[7] as u64) << 8*0) } + +struct InputData { + data: Vec, + read_pos: AtomicUsize, +} +impl InputData { + fn get_slice(&self, len: usize) -> Option<&[u8]> { + let old_pos = self.read_pos.fetch_add(len, Ordering::AcqRel); + if self.data.len() < old_pos + len { + return None; + } + Some(&self.data[old_pos..old_pos + len]) + } + fn get_slice_nonadvancing(&self, len: usize) -> Option<&[u8]> { + let old_pos = self.read_pos.load(Ordering::Acquire); + if self.data.len() < old_pos + len { + return None; + } + Some(&self.data[old_pos..old_pos + len]) + } +} + +struct DummyChainWatcher { + input: Arc, +} + +impl ChainWatchInterface for DummyChainWatcher { + fn install_watch_tx(&self, _txid: &Sha256dHash, _script_pub_key: &Script) { } + fn install_watch_outpoint(&self, _outpoint: (Sha256dHash, u32), _out_script: &Script) { } + fn watch_all_txn(&self) { } + fn filter_block<'a>(&self, _block: &'a Block) -> (Vec<&'a Transaction>, Vec) { + (Vec::new(), Vec::new()) + } + fn reentered(&self) -> usize { 0 } + + fn get_chain_utxo(&self, _genesis_hash: Sha256dHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> { + match self.input.get_slice(2) { + Some(&[0, _]) => Err(ChainError::NotSupported), + Some(&[1, _]) => Err(ChainError::NotWatched), + Some(&[2, _]) => Err(ChainError::UnknownTx), + Some(&[_, x]) => Ok((Builder::new().push_int(x as i64).into_script().to_v0_p2wsh(), 0)), + None => Err(ChainError::UnknownTx), + _ => unreachable!(), + } + } +} + #[inline] pub fn do_test(data: &[u8]) { - reset_rng_state(); - - let mut read_pos = 0; + let input = Arc::new(InputData { + data: data.to_vec(), + read_pos: AtomicUsize::new(0), + }); macro_rules! get_slice_nonadvancing { ($len: expr) => { - { - if data.len() < read_pos + $len as usize { - return; - } - &data[read_pos..read_pos + $len as usize] + match input.get_slice_nonadvancing($len as usize) { + Some(slice) => slice, + None => return, } } } macro_rules! get_slice { ($len: expr) => { - { - let res = get_slice_nonadvancing!($len); - read_pos += $len; - res + match input.get_slice($len as usize) { + Some(slice) => slice, + None => return, } } } macro_rules! decode_msg { - ($MsgType: path, $len: expr) => { - match <($MsgType)>::decode(get_slice!($len)) { + ($MsgType: path, $len: expr) => {{ + let mut reader = ::std::io::Cursor::new(get_slice!($len)); + match <($MsgType)>::read(&mut reader) { Ok(msg) => msg, Err(e) => match e { - msgs::DecodeError::UnknownRealmByte => return, - msgs::DecodeError::BadPublicKey => return, - msgs::DecodeError::BadSignature => return, - msgs::DecodeError::BadText => return, + msgs::DecodeError::UnknownVersion => return, + msgs::DecodeError::UnknownRequiredFeature => return, + msgs::DecodeError::InvalidValue => return, msgs::DecodeError::ExtraAddressesPerType => return, msgs::DecodeError::BadLengthDescriptor => return, msgs::DecodeError::ShortRead => panic!("We picked the length..."), + msgs::DecodeError::Io(e) => panic!(format!("{}", e)), } } - } + }} } macro_rules! decode_msg_with_len16 { @@ -95,20 +148,22 @@ pub fn do_test(data: &[u8]) { } } - let secp_ctx = Secp256k1::new(); macro_rules! get_pubkey { () => { - match PublicKey::from_slice(&secp_ctx, get_slice!(33)) { + match PublicKey::from_slice(get_slice!(33)) { Ok(key) => key, Err(_) => return, } } } - let logger: Arc = Arc::new(test_logger::TestLogger{}); + let logger: Arc = Arc::new(test_logger::TestLogger::new("".to_owned())); + let chain_monitor = Arc::new(DummyChainWatcher { + input: Arc::clone(&input), + }); let our_pubkey = get_pubkey!(); - let router = Router::new(our_pubkey.clone(), Arc::clone(&logger)); + let router = Router::new(our_pubkey.clone(), chain_monitor, Arc::clone(&logger)); loop { match get_slice!(1)[0] { @@ -133,7 +188,7 @@ pub fn do_test(data: &[u8]) { }, 1 => { let short_channel_id = slice_to_be64(get_slice!(8)); - router.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed {short_channel_id}); + router.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed {short_channel_id, is_permanent: false}); }, _ => return, } @@ -152,6 +207,9 @@ pub fn do_test(data: &[u8]) { remote_network_id: get_pubkey!(), channel_value_satoshis: slice_to_be64(get_slice!(8)), user_id: 0, + inbound_capacity_msat: 0, + is_live: true, + outbound_capacity_msat: 0, }); } Some(&first_hops_vec[..])