X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=fuzz%2Fsrc%2Fchanmon_consistency.rs;h=cc17ecc5b0e22b4dc7d312e742ee7c83e57bd434;hb=a343cf94368f33171f1c146ac79777cb4edea055;hp=9cdeace668a7b60b7428224eb8f7c3d95a16d2f4;hpb=edab29e8d834db2b2015b5aaff1c6ff3828ab048;p=rust-lightning

diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs
index 9cdeace6..cc17ecc5 100644
--- a/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@ -24,12 +24,14 @@ use bitcoin_hashes::sha256d::Hash as Sha256d;
 use lightning::chain::chaininterface;
 use lightning::chain::transaction::OutPoint;
 use lightning::chain::chaininterface::{BroadcasterInterface,ConfirmationTarget,ChainListener,FeeEstimator,ChainWatchInterfaceUtil};
-use lightning::chain::keysinterface::{InMemoryChannelKeys, KeysInterface};
+use lightning::chain::keysinterface::{KeysInterface, InMemoryChannelKeys};
 use lightning::ln::channelmonitor;
 use lightning::ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, HTLCUpdate};
 use lightning::ln::channelmanager::{ChannelManager, PaymentHash, PaymentPreimage, ChannelManagerReadArgs};
 use lightning::ln::router::{Route, RouteHop};
-use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, LightningError, UpdateAddHTLC, LocalFeatures};
+use lightning::ln::features::InitFeatures;
+use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, UpdateAddHTLC};
+use lightning::util::enforcing_trait_impls::EnforcingChannelKeys;
 use lightning::util::events;
 use lightning::util::logger::Logger;
 use lightning::util::config::UserConfig;
@@ -130,7 +132,7 @@ struct KeyProvider {
 	channel_id: atomic::AtomicU8,
 }
 impl KeysInterface for KeyProvider {
-	type ChanKeySigner = InMemoryChannelKeys;
+	type ChanKeySigner = EnforcingChannelKeys;
 
 	fn get_node_secret(&self) -> SecretKey {
 		SecretKey::from_slice(&[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, 1, self.node_id]).unwrap()
@@ -148,15 +150,16 @@ impl KeysInterface for KeyProvider {
 		PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[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, 3, self.node_id]).unwrap())
 	}
 
-	fn get_channel_keys(&self, _inbound: bool) -> InMemoryChannelKeys {
-		InMemoryChannelKeys {
+	fn get_channel_keys(&self, _inbound: bool) -> EnforcingChannelKeys {
+		EnforcingChannelKeys::new(InMemoryChannelKeys {
 			funding_key:               SecretKey::from_slice(&[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, 4, self.node_id]).unwrap(),
 			revocation_base_key:       SecretKey::from_slice(&[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, 5, self.node_id]).unwrap(),
 			payment_base_key:          SecretKey::from_slice(&[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, 6, self.node_id]).unwrap(),
 			delayed_payment_base_key:  SecretKey::from_slice(&[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, 7, self.node_id]).unwrap(),
 			htlc_base_key:             SecretKey::from_slice(&[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, 8, self.node_id]).unwrap(),
 			commitment_seed: [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, 9, self.node_id],
-		}
+			remote_funding_pubkey: None,
+		})
 	}
 
 	fn get_onion_rand(&self) -> (SecretKey, [u8; 32]) {
@@ -211,7 +214,7 @@ pub fn do_test(data: &[u8]) {
 				monitor.latest_good_update.lock().unwrap().insert(outpoint, monitor_ser);
 			}
 			let mut monitor_refs = HashMap::new();
-			for (outpoint, monitor) in monitors.iter() {
+			for (outpoint, monitor) in monitors.iter_mut() {
 				monitor_refs.insert(*outpoint, monitor);
 			}
 
@@ -222,10 +225,10 @@ pub fn do_test(data: &[u8]) {
 				tx_broadcaster: broadcast.clone(),
 				logger,
 				default_config: config,
-				channel_monitors: &monitor_refs,
+				channel_monitors: &mut monitor_refs,
 			};
 
-			let res = (<(Sha256d, ChannelManager<InMemoryChannelKeys>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor);
+			let res = (<(Sha256d, ChannelManager<EnforcingChannelKeys>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor);
 			for (_, was_good) in $old_monitors.latest_updates_good_at_last_ser.lock().unwrap().iter() {
 				if !was_good {
 					// If the last time we updated a monitor we didn't successfully update (and we
@@ -251,7 +254,7 @@ pub fn do_test(data: &[u8]) {
 				} else { panic!("Wrong event type"); }
 			};
 
-			$dest.handle_open_channel(&$source.get_our_node_id(), LocalFeatures::new(), &open_channel).unwrap();
+			$dest.handle_open_channel(&$source.get_our_node_id(), InitFeatures::supported(), &open_channel);
 			let accept_channel = {
 				let events = $dest.get_and_clear_pending_msg_events();
 				assert_eq!(events.len(), 1);
@@ -260,7 +263,7 @@ pub fn do_test(data: &[u8]) {
 				} else { panic!("Wrong event type"); }
 			};
 
-			$source.handle_accept_channel(&$dest.get_our_node_id(), LocalFeatures::new(), &accept_channel).unwrap();
+			$source.handle_accept_channel(&$dest.get_our_node_id(), InitFeatures::supported(), &accept_channel);
 			{
 				let events = $source.get_and_clear_pending_events();
 				assert_eq!(events.len(), 1);
@@ -281,7 +284,7 @@ pub fn do_test(data: &[u8]) {
 					msg.clone()
 				} else { panic!("Wrong event type"); }
 			};
-			$dest.handle_funding_created(&$source.get_our_node_id(), &funding_created).unwrap();
+			$dest.handle_funding_created(&$source.get_our_node_id(), &funding_created);
 
 			let funding_signed = {
 				let events = $dest.get_and_clear_pending_msg_events();
@@ -290,7 +293,7 @@ pub fn do_test(data: &[u8]) {
 					msg.clone()
 				} else { panic!("Wrong event type"); }
 			};
-			$source.handle_funding_signed(&$dest.get_our_node_id(), &funding_signed).unwrap();
+			$source.handle_funding_signed(&$dest.get_our_node_id(), &funding_signed);
 
 			{
 				let events = $source.get_and_clear_pending_events();
@@ -329,7 +332,7 @@ pub fn do_test(data: &[u8]) {
 					if let events::MessageSendEvent::SendFundingLocked { ref node_id, ref msg } = event {
 						for node in $nodes.iter() {
 							if node.get_our_node_id() == *node_id {
-								node.handle_funding_locked(&$nodes[idx].get_our_node_id(), msg).unwrap();
+								node.handle_funding_locked(&$nodes[idx].get_our_node_id(), msg);
 							}
 						}
 					} else { panic!("Wrong event type"); }
@@ -380,16 +383,6 @@ pub fn do_test(data: &[u8]) {
 	let mut node_c_ser = VecWriter(Vec::new());
 	nodes[2].write(&mut node_c_ser).unwrap();
 
-	macro_rules! test_err {
-		($res: expr) => {
-			match $res {
-				Ok(()) => {},
-				Err(LightningError { action: ErrorAction::IgnoreError, .. }) => { },
-				_ => { $res.unwrap() },
-			}
-		}
-	}
-
 	macro_rules! test_return {
 		() => { {
 			assert_eq!(nodes[0].list_channels().len(), 1);
@@ -469,7 +462,7 @@ pub fn do_test(data: &[u8]) {
 									assert!(update_fee.is_none());
 									for update_add in update_add_htlcs {
 										if !$corrupt_forward {
-											test_err!(dest.handle_update_add_htlc(&nodes[$node].get_our_node_id(), &update_add));
+											dest.handle_update_add_htlc(&nodes[$node].get_our_node_id(), &update_add);
 										} else {
 											// Corrupt the update_add_htlc message so that its HMAC
 											// check will fail and we generate a
@@ -478,33 +471,33 @@ pub fn do_test(data: &[u8]) {
 											let mut msg_ser = update_add.encode();
 											msg_ser[1000] ^= 0xff;
 											let new_msg = UpdateAddHTLC::read(&mut Cursor::new(&msg_ser)).unwrap();
-											test_err!(dest.handle_update_add_htlc(&nodes[$node].get_our_node_id(), &new_msg));
+											dest.handle_update_add_htlc(&nodes[$node].get_our_node_id(), &new_msg);
 										}
 									}
 									for update_fulfill in update_fulfill_htlcs {
-										test_err!(dest.handle_update_fulfill_htlc(&nodes[$node].get_our_node_id(), &update_fulfill));
+										dest.handle_update_fulfill_htlc(&nodes[$node].get_our_node_id(), &update_fulfill);
 									}
 									for update_fail in update_fail_htlcs {
-										test_err!(dest.handle_update_fail_htlc(&nodes[$node].get_our_node_id(), &update_fail));
+										dest.handle_update_fail_htlc(&nodes[$node].get_our_node_id(), &update_fail);
 									}
 									for update_fail_malformed in update_fail_malformed_htlcs {
-										test_err!(dest.handle_update_fail_malformed_htlc(&nodes[$node].get_our_node_id(), &update_fail_malformed));
+										dest.handle_update_fail_malformed_htlc(&nodes[$node].get_our_node_id(), &update_fail_malformed);
 									}
-									test_err!(dest.handle_commitment_signed(&nodes[$node].get_our_node_id(), &commitment_signed));
+									dest.handle_commitment_signed(&nodes[$node].get_our_node_id(), &commitment_signed);
 								}
 							}
 						},
 						events::MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 							for dest in nodes.iter() {
 								if dest.get_our_node_id() == *node_id {
-									test_err!(dest.handle_revoke_and_ack(&nodes[$node].get_our_node_id(), msg));
+									dest.handle_revoke_and_ack(&nodes[$node].get_our_node_id(), msg);
 								}
 							}
 						},
 						events::MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => {
 							for dest in nodes.iter() {
 								if dest.get_our_node_id() == *node_id {
-									test_err!(dest.handle_channel_reestablish(&nodes[$node].get_our_node_id(), msg));
+									dest.handle_channel_reestablish(&nodes[$node].get_our_node_id(), msg);
 								}
 							}
 						},
@@ -515,6 +508,10 @@ pub fn do_test(data: &[u8]) {
 							// Can be generated due to a payment forward being rejected due to a
 							// channel having previously failed a monitor update
 						},
+						events::MessageSendEvent::HandleError { action: ErrorAction::IgnoreError, .. } => {
+							// Can be generated at any processing step to send back an error, disconnect
+							// peer or just ignore
+						},
 						_ => panic!("Unhandled message event"),
 					}
 				}
@@ -531,6 +528,7 @@ pub fn do_test(data: &[u8]) {
 							events::MessageSendEvent::SendChannelReestablish { .. } => {},
 							events::MessageSendEvent::SendFundingLocked { .. } => {},
 							events::MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
+							events::MessageSendEvent::HandleError { action: ErrorAction::IgnoreError, .. } => {},
 							_ => panic!("Unhandled message event"),
 						}
 					}
@@ -543,6 +541,7 @@ pub fn do_test(data: &[u8]) {
 							events::MessageSendEvent::SendChannelReestablish { .. } => {},
 							events::MessageSendEvent::SendFundingLocked { .. } => {},
 							events::MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
+							events::MessageSendEvent::HandleError { action: ErrorAction::IgnoreError, .. } => {},
 							_ => panic!("Unhandled message event"),
 						}
 					}
@@ -564,6 +563,7 @@ pub fn do_test(data: &[u8]) {
 						},
 						events::MessageSendEvent::SendFundingLocked { .. } => false,
 						events::MessageSendEvent::PaymentFailureNetworkUpdate { .. } => false,
+						events::MessageSendEvent::HandleError { action: ErrorAction::IgnoreError, .. } => false,
 						_ => panic!("Unhandled message event"),
 					};
 					if push { msg_sink.push(event); }
@@ -742,11 +742,3 @@ pub fn do_test(data: &[u8]) {
 pub extern "C" fn chanmon_consistency_run(data: *const u8, datalen: usize) {
 	do_test(unsafe { std::slice::from_raw_parts(data, datalen) });
 }
-
-#[cfg(test)]
-mod tests {
-	#[test]
-	fn duplicate_crash() {
-		super::do_test(&::hex::decode("00").unwrap());
-	}
-}