Use arbitrary config object in full_stack_target

fuzz/src/full_stack.rs

@@ -53,7 +53,7 @@ use lightning::util::config::{UserConfig, MaxDustHTLCExposure};
 use lightning::util::errors::APIError;
 use lightning::util::test_channel_signer::{TestChannelSigner, EnforcementState};
 use lightning::util::logger::Logger;
-use lightning::util::ser::{ReadableArgs, Writeable};
+use lightning::util::ser::{Readable, ReadableArgs, Writeable};
 
 use crate::utils::test_logger;
 use crate::utils::test_persister::TestPersister;
@@ -439,7 +439,17 @@ impl SignerProvider for KeyProvider {
 }
 
 #[inline]
-pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
+pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
+	if data.len() < 32 { return; }
+
+	let our_network_key = match SecretKey::from_slice(&data[..32]) {
+		Ok(key) => key,
+		Err(e) => {eprintln!("1 {:?}", e); return},
+	};
+	data = &data[32..];
+
+	let config: UserConfig = if let Ok(config) = Readable::read(&mut data) { config } else { return; };
+
 	let input = Arc::new(InputData {
 		data: data.to_vec(),
 		read_pos: AtomicUsize::new(0),
@@ -467,10 +477,6 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 		}
 	}
 
-	let our_network_key = match SecretKey::from_slice(get_slice!(32)) {
-		Ok(key) => key,
-		Err(_) => return,
-	};
 
 	let inbound_payment_key = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42];
 
@@ -484,10 +490,6 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 		counter: AtomicU64::new(0),
 		signer_state: RefCell::new(HashMap::new())
 	});
-	let mut config = UserConfig::default();
-	config.channel_config.forwarding_fee_proportional_millionths =  slice_to_be32(get_slice!(4));
-	config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253);
-	config.channel_handshake_config.announced_channel = get_slice!(1)[0] != 0;
 	let network = Network::Bitcoin;
 	let best_block_timestamp = genesis_block(network).header.time;
 	let params = ChainParameters {

lightning/src/util/config.rs

@@ -13,6 +13,9 @@
 use crate::ln::channel::MAX_FUNDING_SATOSHIS_NO_WUMBO;
 use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, MAX_LOCAL_BREAKDOWN_TIMEOUT};
 
+#[cfg(fuzzing)]
+use crate::util::ser::Readable;
+
 /// Configuration we set when applicable.
 ///
 /// Default::default() provides sane defaults.
@@ -210,6 +213,27 @@ impl Default for ChannelHandshakeConfig {
 	}
 }
 
+// When fuzzing, we want to allow the fuzzer to pick any configuration parameters. Thus, we
+// implement Readable here in a naive way (which is a bit easier for the fuzzer to handle). We
+// don't really want to ever expose this to users (if we did we'd want to use TLVs).
+#[cfg(fuzzing)]
+impl Readable for ChannelHandshakeConfig {
+	fn read<R: crate::io::Read>(reader: &mut R) -> Result<Self, crate::ln::msgs::DecodeError> {
+		Ok(Self {
+			minimum_depth: Readable::read(reader)?,
+			our_to_self_delay: Readable::read(reader)?,
+			our_htlc_minimum_msat: Readable::read(reader)?,
+			max_inbound_htlc_value_in_flight_percent_of_channel: Readable::read(reader)?,
+			negotiate_scid_privacy: Readable::read(reader)?,
+			announced_channel: Readable::read(reader)?,
+			commit_upfront_shutdown_pubkey: Readable::read(reader)?,
+			their_channel_reserve_proportional_millionths: Readable::read(reader)?,
+			negotiate_anchors_zero_fee_htlc_tx: Readable::read(reader)?,
+			our_max_accepted_htlcs: Readable::read(reader)?,
+		})
+	}
+}
+
 /// Optional channel limits which are applied during channel creation.
 ///
 /// These limits are only applied to our counterparty's limits, not our own.
@@ -315,6 +339,27 @@ impl Default for ChannelHandshakeLimits {
 	}
 }
 
+// When fuzzing, we want to allow the fuzzer to pick any configuration parameters. Thus, we
+// implement Readable here in a naive way (which is a bit easier for the fuzzer to handle). We
+// don't really want to ever expose this to users (if we did we'd want to use TLVs).
+#[cfg(fuzzing)]
+impl Readable for ChannelHandshakeLimits {
+	fn read<R: crate::io::Read>(reader: &mut R) -> Result<Self, crate::ln::msgs::DecodeError> {
+		Ok(Self {
+			min_funding_satoshis: Readable::read(reader)?,
+			max_funding_satoshis: Readable::read(reader)?,
+			max_htlc_minimum_msat: Readable::read(reader)?,
+			min_max_htlc_value_in_flight_msat: Readable::read(reader)?,
+			max_channel_reserve_satoshis: Readable::read(reader)?,
+			min_max_accepted_htlcs: Readable::read(reader)?,
+			trust_own_funding_0conf: Readable::read(reader)?,
+			max_minimum_depth: Readable::read(reader)?,
+			force_announced_channel_preference: Readable::read(reader)?,
+			their_to_self_delay: Readable::read(reader)?,
+		})
+	}
+}
+
 /// Options for how to set the max dust HTLC exposure allowed on a channel. See
 /// [`ChannelConfig::max_dust_htlc_exposure`] for details.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -781,3 +826,22 @@ impl Default for UserConfig {
 		}
 	}
 }
+
+// When fuzzing, we want to allow the fuzzer to pick any configuration parameters. Thus, we
+// implement Readable here in a naive way (which is a bit easier for the fuzzer to handle). We
+// don't really want to ever expose this to users (if we did we'd want to use TLVs).
+#[cfg(fuzzing)]
+impl Readable for UserConfig {
+	fn read<R: crate::io::Read>(reader: &mut R) -> Result<Self, crate::ln::msgs::DecodeError> {
+		Ok(Self {
+			channel_handshake_config: Readable::read(reader)?,
+			channel_handshake_limits: Readable::read(reader)?,
+			channel_config: Readable::read(reader)?,
+			accept_forwards_to_priv_channels: Readable::read(reader)?,
+			accept_inbound_channels: Readable::read(reader)?,
+			manually_accept_inbound_channels: Readable::read(reader)?,
+			accept_intercept_htlcs: Readable::read(reader)?,
+			accept_mpp_keysend: Readable::read(reader)?,
+		})
+	}
+}