X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=fuzz%2Fsrc%2Frouter.rs;h=095059c5183676232c48b36093a244a9fe69ba3b;hb=7fefa00e090293a020ec7b352e02bc26fa854d25;hp=95abf9718c54bc1a863dd888167ca803f19162d9;hpb=d9c03f26f9d52ca96bc889eae64087a690ff1a22;p=rust-lightning diff --git a/fuzz/src/router.rs b/fuzz/src/router.rs index 95abf971..3e51d0c6 100644 --- a/fuzz/src/router.rs +++ b/fuzz/src/router.rs @@ -11,22 +11,25 @@ use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::transaction::TxOut; use bitcoin::hash_types::BlockHash; -use bitcoin::secp256k1; - use lightning::chain; -use lightning::ln::channelmanager::ChannelDetails; -use lightning::ln::features::InitFeatures; +use lightning::chain::transaction::OutPoint; +use lightning::ln::channelmanager::{self, ChannelDetails, ChannelCounterparty}; use lightning::ln::msgs; -use lightning::routing::router::{get_route, RouteHint}; -use lightning::util::logger::Logger; +use lightning::routing::gossip::{NetworkGraph, RoutingFees}; +use lightning::routing::router::{find_route, PaymentParameters, RouteHint, RouteHintHop, RouteParameters}; +use lightning::routing::scoring::FixedPenaltyScorer; +use lightning::util::config::UserConfig; use lightning::util::ser::Readable; -use lightning::routing::network_graph::{NetworkGraph, RoutingFees}; -use bitcoin::secp256k1::key::PublicKey; +use bitcoin::hashes::Hash; +use bitcoin::secp256k1::PublicKey; +use bitcoin::network::constants::Network; +use bitcoin::blockdata::constants::genesis_block; -use utils::test_logger; +use crate::utils::test_logger; -use std::collections::HashSet; +use std::convert::TryInto; +use hashbrown::HashSet; use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -120,24 +123,28 @@ pub fn do_test(data: &[u8], out: Out) { ($MsgType: path, $len: expr) => {{ let mut reader = ::std::io::Cursor::new(get_slice!($len)); match <$MsgType>::read(&mut reader) { - Ok(msg) => msg, + Ok(msg) => { + assert_eq!(reader.position(), $len as u64); + msg + }, Err(e) => match e { msgs::DecodeError::UnknownVersion => return, msgs::DecodeError::UnknownRequiredFeature => return, msgs::DecodeError::InvalidValue => return, msgs::DecodeError::BadLengthDescriptor => return, msgs::DecodeError::ShortRead => panic!("We picked the length..."), - msgs::DecodeError::Io(e) => panic!(format!("{}", e)), + msgs::DecodeError::Io(e) => panic!("{:?}", e), + msgs::DecodeError::UnsupportedCompression => return, } } }} } macro_rules! decode_msg_with_len16 { - ($MsgType: path, $begin_len: expr, $excess: expr) => { + ($MsgType: path, $excess: expr) => { { - let extra_len = slice_to_be16(&get_slice_nonadvancing!($begin_len as usize + 2)[$begin_len..$begin_len + 2]); - decode_msg!($MsgType, $begin_len as usize + 2 + (extra_len as usize) + $excess) + let extra_len = slice_to_be16(get_slice_nonadvancing!(2)); + decode_msg!($MsgType, 2 + (extra_len as usize) + $excess) } } } @@ -151,10 +158,10 @@ pub fn do_test(data: &[u8], out: Out) { } } - let logger: Arc = Arc::new(test_logger::TestLogger::new("".to_owned(), out)); + let logger = test_logger::TestLogger::new("".to_owned(), out); let our_pubkey = get_pubkey!(); - let mut net_graph = NetworkGraph::new(); + let net_graph = NetworkGraph::new(genesis_block(Network::Bitcoin).header.block_hash(), &logger); let mut node_pks = HashSet::new(); let mut scid = 42; @@ -162,33 +169,33 @@ pub fn do_test(data: &[u8], out: Out) { loop { match get_slice!(1)[0] { 0 => { - let start_len = slice_to_be16(&get_slice_nonadvancing!(64 + 2)[64..64 + 2]) as usize; - let addr_len = slice_to_be16(&get_slice_nonadvancing!(64+start_len+2 + 74)[64+start_len+2 + 72..64+start_len+2 + 74]); + let start_len = slice_to_be16(&get_slice_nonadvancing!(2)[0..2]) as usize; + let addr_len = slice_to_be16(&get_slice_nonadvancing!(start_len+2 + 74)[start_len+2 + 72..start_len+2 + 74]); if addr_len > (37+1)*4 { return; } - let msg = decode_msg_with_len16!(msgs::NodeAnnouncement, 64, 288); - node_pks.insert(msg.contents.node_id); - let _ = net_graph.update_node_from_announcement::(&msg, None); + let msg = decode_msg_with_len16!(msgs::UnsignedNodeAnnouncement, 288); + node_pks.insert(msg.node_id); + let _ = net_graph.update_node_from_unsigned_announcement(&msg); }, 1 => { - let msg = decode_msg_with_len16!(msgs::ChannelAnnouncement, 64*4, 32+8+33*4); - node_pks.insert(msg.contents.node_id_1); - node_pks.insert(msg.contents.node_id_2); - let _ = net_graph.update_channel_from_announcement::(&msg, &None, None); + let msg = decode_msg_with_len16!(msgs::UnsignedChannelAnnouncement, 32+8+33*4); + node_pks.insert(msg.node_id_1); + node_pks.insert(msg.node_id_2); + let _ = net_graph.update_channel_from_unsigned_announcement::<&FuzzChainSource>(&msg, &None); }, 2 => { - let msg = decode_msg_with_len16!(msgs::ChannelAnnouncement, 64*4, 32+8+33*4); - node_pks.insert(msg.contents.node_id_1); - node_pks.insert(msg.contents.node_id_2); - let _ = net_graph.update_channel_from_announcement::(&msg, &Some(&FuzzChainSource { input: Arc::clone(&input) }), None); + let msg = decode_msg_with_len16!(msgs::UnsignedChannelAnnouncement, 32+8+33*4); + node_pks.insert(msg.node_id_1); + node_pks.insert(msg.node_id_2); + let _ = net_graph.update_channel_from_unsigned_announcement(&msg, &Some(&FuzzChainSource { input: Arc::clone(&input) })); }, 3 => { - let _ = net_graph.update_channel(&decode_msg!(msgs::ChannelUpdate, 136), None); + let _ = net_graph.update_channel_unsigned(&decode_msg!(msgs::UnsignedChannelUpdate, 72)); }, 4 => { let short_channel_id = slice_to_be64(get_slice!(8)); - net_graph.close_channel_from_update(short_channel_id, false); + net_graph.channel_failed(short_channel_id, false); }, _ if node_pks.is_empty() => {}, _ => { @@ -198,29 +205,49 @@ pub fn do_test(data: &[u8], out: Out) { count => { for _ in 0..count { scid += 1; - let rnid = node_pks.iter().skip(slice_to_be16(get_slice!(2))as usize % node_pks.len()).next().unwrap(); + let rnid = node_pks.iter().skip(u16::from_be_bytes(get_slice!(2).try_into().unwrap()) as usize % node_pks.len()).next().unwrap(); + let capacity = u64::from_be_bytes(get_slice!(8).try_into().unwrap()); first_hops_vec.push(ChannelDetails { channel_id: [0; 32], + counterparty: ChannelCounterparty { + node_id: *rnid, + features: channelmanager::provided_init_features(&UserConfig::default()), + unspendable_punishment_reserve: 0, + forwarding_info: None, + outbound_htlc_minimum_msat: None, + outbound_htlc_maximum_msat: None, + }, + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), + channel_type: None, short_channel_id: Some(scid), - remote_network_id: *rnid, - counterparty_features: InitFeatures::known(), - channel_value_satoshis: slice_to_be64(get_slice!(8)), - user_id: 0, - inbound_capacity_msat: 0, - is_live: true, - outbound_capacity_msat: 0, + inbound_scid_alias: None, + outbound_scid_alias: None, + channel_value_satoshis: capacity, + user_channel_id: 0, inbound_capacity_msat: 0, + unspendable_punishment_reserve: None, + confirmations_required: None, + confirmations: None, + force_close_spend_delay: None, + is_outbound: true, is_channel_ready: true, + is_usable: true, is_public: true, + balance_msat: 0, + outbound_capacity_msat: capacity.saturating_mul(1000), + next_outbound_htlc_limit_msat: capacity.saturating_mul(1000), + inbound_htlc_minimum_msat: None, + inbound_htlc_maximum_msat: None, + config: None, }); } Some(&first_hops_vec[..]) }, }; - let mut last_hops_vec = Vec::new(); + let mut last_hops = Vec::new(); { let count = get_slice!(1)[0]; for _ in 0..count { scid += 1; let rnid = node_pks.iter().skip(slice_to_be16(get_slice!(2))as usize % node_pks.len()).next().unwrap(); - last_hops_vec.push(RouteHint { + last_hops.push(RouteHint(vec![RouteHintHop { src_node_id: *rnid, short_channel_id: scid, fees: RoutingFees { @@ -228,16 +255,22 @@ pub fn do_test(data: &[u8], out: Out) { proportional_millionths: slice_to_be32(get_slice!(4)), }, cltv_expiry_delta: slice_to_be16(get_slice!(2)), - htlc_minimum_msat: slice_to_be64(get_slice!(8)), - }); + htlc_minimum_msat: Some(slice_to_be64(get_slice!(8))), + htlc_maximum_msat: None, + }])); } } - let last_hops = &last_hops_vec[..]; + let scorer = FixedPenaltyScorer::with_penalty(0); + let random_seed_bytes: [u8; 32] = [get_slice!(1)[0]; 32]; for target in node_pks.iter() { - let _ = get_route(&our_pubkey, &net_graph, target, + let route_params = RouteParameters { + payment_params: PaymentParameters::from_node_id(*target).with_route_hints(last_hops.clone()), + final_value_msat: slice_to_be64(get_slice!(8)), + final_cltv_expiry_delta: slice_to_be32(get_slice!(4)), + }; + let _ = find_route(&our_pubkey, &route_params, &net_graph, first_hops.map(|c| c.iter().collect::>()).as_ref().map(|a| a.as_slice()), - &last_hops.iter().collect::>(), - slice_to_be64(get_slice!(8)), slice_to_be32(get_slice!(4)), Arc::clone(&logger)); + &logger, &scorer, &random_seed_bytes); } }, }