X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=fuzz%2Fsrc%2Frouter.rs;h=afe028131c1de0a3a79eb30e975a9cc6e72097a9;hb=59778dac488cff735004671cdefb3f4ac1f920fd;hp=31732257c3f1a1c099161c8b982f1f5f35d701b2;hpb=b66e3c53768f6bc7bc43064f1818051d22477c63;p=rust-lightning diff --git a/fuzz/src/router.rs b/fuzz/src/router.rs index 31732257..afe02813 100644 --- a/fuzz/src/router.rs +++ b/fuzz/src/router.rs @@ -7,18 +7,23 @@ // You may not use this file except in accordance with one or both of these // licenses. +use bitcoin::blockdata::constants::ChainHash; use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::transaction::TxOut; -use bitcoin::hash_types::BlockHash; +use lightning::blinded_path::{BlindedHop, BlindedPath, IntroductionNode}; use lightning::chain::transaction::OutPoint; +use lightning::ln::ChannelId; use lightning::ln::channelmanager::{self, ChannelDetails, ChannelCounterparty}; +use lightning::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures}; use lightning::ln::msgs; +use lightning::offers::invoice::BlindedPayInfo; use lightning::routing::gossip::{NetworkGraph, RoutingFees}; use lightning::routing::utxo::{UtxoFuture, UtxoLookup, UtxoLookupError, UtxoResult}; use lightning::routing::router::{find_route, PaymentParameters, RouteHint, RouteHintHop, RouteParameters}; use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; use lightning::util::config::UserConfig; +use lightning::util::hash_tables::*; use lightning::util::ser::Readable; use bitcoin::hashes::Hash; @@ -28,7 +33,6 @@ use bitcoin::network::constants::Network; use crate::utils::test_logger; use std::convert::TryInto; -use hashbrown::HashSet; use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -85,7 +89,7 @@ struct FuzzChainSource<'a, 'b, Out: test_logger::Output> { net_graph: &'a NetworkGraph<&'b test_logger::TestLogger>, } impl UtxoLookup for FuzzChainSource<'_, '_, Out> { - fn get_utxo(&self, _genesis_hash: &BlockHash, _short_channel_id: u64) -> UtxoResult { + fn get_utxo(&self, _chain_hash: &ChainHash, _short_channel_id: u64) -> UtxoResult { let input_slice = self.input.get_slice(2); if input_slice.is_none() { return UtxoResult::Sync(Err(UtxoLookupError::UnknownTx)); } let input_slice = input_slice.unwrap(); @@ -153,6 +157,7 @@ pub fn do_test(data: &[u8], out: Out) { msgs::DecodeError::ShortRead => panic!("We picked the length..."), msgs::DecodeError::Io(e) => panic!("{:?}", e), msgs::DecodeError::UnsupportedCompression => return, + msgs::DecodeError::DangerousValue => return, } } }} @@ -194,9 +199,98 @@ pub fn do_test(data: &[u8], out: Out) { net_graph: &net_graph, }; - let mut node_pks = HashSet::new(); + let mut node_pks = new_hash_map(); let mut scid = 42; + macro_rules! first_hops { + ($first_hops_vec: expr) => { + match get_slice!(1)[0] { + 0 => None, + count => { + for _ in 0..count { + scid += 1; + 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: ChannelId::new_zero(), + 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), + 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), + next_outbound_htlc_minimum_msat: 0, + inbound_htlc_minimum_msat: None, + inbound_htlc_maximum_msat: None, + config: None, + feerate_sat_per_1000_weight: None, + channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown), + pending_inbound_htlcs: Vec::new(), + pending_outbound_htlcs: Vec::new(), + }); + } + Some(&$first_hops_vec[..]) + }, + } + } + } + + macro_rules! last_hops { + ($last_hops: expr) => { + 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.push(RouteHint(vec![RouteHintHop { + src_node_id: *rnid, + short_channel_id: scid, + fees: RoutingFees { + base_msat: slice_to_be32(get_slice!(4)), + proportional_millionths: slice_to_be32(get_slice!(4)), + }, + cltv_expiry_delta: slice_to_be16(get_slice!(2)), + htlc_minimum_msat: Some(slice_to_be64(get_slice!(8))), + htlc_maximum_msat: None, + }])); + } + } + } + + macro_rules! find_routes { + ($first_hops: expr, $node_pks: expr, $route_params: expr) => { + let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &net_graph, &logger); + let random_seed_bytes: [u8; 32] = [get_slice!(1)[0]; 32]; + for (target, ()) in $node_pks { + let final_value_msat = slice_to_be64(get_slice!(8)); + let final_cltv_expiry_delta = slice_to_be32(get_slice!(4)); + let route_params = $route_params(final_value_msat, final_cltv_expiry_delta, target); + let _ = find_route(&our_pubkey, &route_params, &net_graph, + $first_hops.map(|c| c.iter().collect::>()).as_ref().map(|a| a.as_slice()), + &logger, &scorer, &ProbabilisticScoringFeeParameters::default(), &random_seed_bytes); + } + } + } + loop { match get_slice!(1)[0] { 0 => { @@ -206,20 +300,20 @@ pub fn do_test(data: &[u8], out: Out) { return; } let msg = decode_msg_with_len16!(msgs::UnsignedNodeAnnouncement, 288); - node_pks.insert(get_pubkey_from_node_id!(msg.node_id)); + node_pks.insert(get_pubkey_from_node_id!(msg.node_id), ()); let _ = net_graph.update_node_from_unsigned_announcement(&msg); }, 1 => { let msg = decode_msg_with_len16!(msgs::UnsignedChannelAnnouncement, 32+8+33*4); - node_pks.insert(get_pubkey_from_node_id!(msg.node_id_1)); - node_pks.insert(get_pubkey_from_node_id!(msg.node_id_2)); + node_pks.insert(get_pubkey_from_node_id!(msg.node_id_1), ()); + node_pks.insert(get_pubkey_from_node_id!(msg.node_id_2), ()); let _ = net_graph.update_channel_from_unsigned_announcement:: <&FuzzChainSource<'_, '_, Out>>(&msg, &None); }, 2 => { let msg = decode_msg_with_len16!(msgs::UnsignedChannelAnnouncement, 32+8+33*4); - node_pks.insert(get_pubkey_from_node_id!(msg.node_id_1)); - node_pks.insert(get_pubkey_from_node_id!(msg.node_id_2)); + node_pks.insert(get_pubkey_from_node_id!(msg.node_id_1), ()); + node_pks.insert(get_pubkey_from_node_id!(msg.node_id_2), ()); let _ = net_graph.update_channel_from_unsigned_announcement(&msg, &Some(&chain_source)); }, 3 => { @@ -230,86 +324,58 @@ pub fn do_test(data: &[u8], out: Out) { net_graph.channel_failed_permanent(short_channel_id); }, _ if node_pks.is_empty() => {}, - _ => { + x if x < 250 => { let mut first_hops_vec = Vec::new(); - let first_hops = match get_slice!(1)[0] { - 0 => None, - count => { - for _ in 0..count { - scid += 1; - 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), - 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), - next_outbound_htlc_minimum_msat: 0, - inbound_htlc_minimum_msat: None, - inbound_htlc_maximum_msat: None, - config: None, - feerate_sat_per_1000_weight: None, - channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown), - }); - } - Some(&first_hops_vec[..]) - }, - }; + // Use macros here and in the blinded match arm to ensure values are fetched from the fuzz + // input in the same order, for better coverage. + let first_hops = first_hops!(first_hops_vec); 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.push(RouteHint(vec![RouteHintHop { - src_node_id: *rnid, - short_channel_id: scid, - fees: RoutingFees { - base_msat: slice_to_be32(get_slice!(4)), - proportional_millionths: slice_to_be32(get_slice!(4)), - }, - cltv_expiry_delta: slice_to_be16(get_slice!(2)), - htlc_minimum_msat: Some(slice_to_be64(get_slice!(8))), - htlc_maximum_msat: None, - }])); - } - } - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &net_graph, &logger); - let random_seed_bytes: [u8; 32] = [get_slice!(1)[0]; 32]; - for target in node_pks.iter() { - let final_value_msat = slice_to_be64(get_slice!(8)); - let final_cltv_expiry_delta = slice_to_be32(get_slice!(4)); - let route_params = RouteParameters { - payment_params: PaymentParameters::from_node_id(*target, final_cltv_expiry_delta) + last_hops!(last_hops); + find_routes!(first_hops, node_pks.iter(), |final_amt, final_delta, target: &PublicKey| { + RouteParameters::from_payment_params_and_value( + PaymentParameters::from_node_id(*target, final_delta) .with_route_hints(last_hops.clone()).unwrap(), - final_value_msat, - }; - let _ = find_route(&our_pubkey, &route_params, &net_graph, - first_hops.map(|c| c.iter().collect::>()).as_ref().map(|a| a.as_slice()), - &logger, &scorer, &ProbabilisticScoringFeeParameters::default(), &random_seed_bytes); - } + final_amt) + }); }, + x => { + let mut first_hops_vec = Vec::new(); + let first_hops = first_hops!(first_hops_vec); + let mut last_hops_unblinded = Vec::new(); + last_hops!(last_hops_unblinded); + let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap(); + let last_hops: Vec<(BlindedPayInfo, BlindedPath)> = last_hops_unblinded.into_iter().map(|hint| { + let hop = &hint.0[0]; + let payinfo = BlindedPayInfo { + fee_base_msat: hop.fees.base_msat, + fee_proportional_millionths: hop.fees.proportional_millionths, + htlc_minimum_msat: hop.htlc_minimum_msat.unwrap(), + htlc_maximum_msat: hop.htlc_minimum_msat.unwrap().saturating_mul(100), + cltv_expiry_delta: hop.cltv_expiry_delta, + features: BlindedHopFeatures::empty(), + }; + let num_blinded_hops = x % 250; + let mut blinded_hops = Vec::new(); + for _ in 0..num_blinded_hops { + blinded_hops.push(BlindedHop { + blinded_node_id: dummy_pk, + encrypted_payload: Vec::new() + }); + } + (payinfo, BlindedPath { + introduction_node: IntroductionNode::NodeId(hop.src_node_id), + blinding_point: dummy_pk, + blinded_hops, + }) + }).collect(); + let mut features = Bolt12InvoiceFeatures::empty(); + features.set_basic_mpp_optional(); + find_routes!(first_hops, [(dummy_pk, ())].iter(), |final_amt, _, _| { + RouteParameters::from_payment_params_and_value(PaymentParameters::blinded(last_hops.clone()) + .with_bolt12_features(features.clone()).unwrap(), + final_amt) + }); + } } } }