Implement check channel_announcement is on Bitcoin Mainnet or Testnet

Add test on valid channel_announcement + test utilities

Fix typo

Author: Antoine Riard

src/chain/transaction.rs

@@ -13,7 +13,7 @@ pub struct OutPoint {
 }
 
 impl OutPoint {
-	/// Creates a new `OutPoint` from the txid an the index.
+	/// Creates a new `OutPoint` from the txid and the index.
 	pub fn new(txid: Sha256dHash, index: u16) -> OutPoint {
 		OutPoint { txid, index }
 	}

src/ln/channel.rs

@@ -2000,6 +2000,16 @@ impl Channel {
 		self.channel_value_satoshis
 	}
 
+	#[cfg(test)]
+	pub fn get_local_keys(&self) -> &ChannelKeys {
+		&self.local_keys
+	}
+
+	#[cfg(test)]
+	pub fn get_secp_ctx(&self) -> &Secp256k1<secp256k1::All> {
+		&self.secp_ctx
+	}
+
 	/// Allowed in any state (including after shutdown)
 	pub fn get_channel_update_count(&self) -> u32 {
 		self.channel_update_count

src/ln/channelmanager.rs

@@ -2096,13 +2096,14 @@ mod tests {
 	use bitcoin::util::hash::Sha256dHash;
 	use bitcoin::blockdata::block::{Block, BlockHeader};
 	use bitcoin::blockdata::transaction::{Transaction, TxOut};
+	use bitcoin::blockdata::constants::genesis_block;
 	use bitcoin::network::constants::Network;
 	use bitcoin::network::serialize::serialize;
 	use bitcoin::network::serialize::BitcoinHash;
 
 	use hex;
 
-	use secp256k1::Secp256k1;
+	use secp256k1::{Secp256k1, Message};
 	use secp256k1::key::{PublicKey,SecretKey};
 
 	use crypto::sha2::Sha256;
@@ -3239,4 +3240,90 @@ mod tests {
 		assert_eq!(channel_state.by_id.len(), 0);
 		assert_eq!(channel_state.short_to_id.len(), 0);
 	}
+
+	#[test]
+	fn test_invalid_channel_announcement() {
+		//Test BOLT 7 channel_announcement msg requirement for final node, gather data to build customed channel_announcement msgs
+		let nodes = create_network(2);
+
+		let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1]);
+
+		let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
+		let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
+		let as_chan = a_channel_lock.by_id.get(&chan_announcement.3).unwrap();
+		let bs_chan = b_channel_lock.by_id.get(&chan_announcement.3).unwrap();
+
+		let _ = nodes[0].router.remove_channel_info(as_chan.get_short_channel_id().unwrap(), genesis_block(Network::Testnet).header.bitcoin_hash());
+
+		let as_bitcoin_key = PublicKey::from_secret_key(&as_chan.get_secp_ctx(), &as_chan.get_local_keys().funding_key);
+		let bs_bitcoin_key = PublicKey::from_secret_key(&bs_chan.get_secp_ctx(), &bs_chan.get_local_keys().funding_key);
+
+		let as_network_key = nodes[0].node.get_our_node_id();
+		let bs_network_key = nodes[1].node.get_our_node_id();
+
+		let were_node_one = as_bitcoin_key.serialize()[..] < bs_bitcoin_key.serialize()[..];
+
+		let mut unsigned_msg;
+		let mut chan_announcement;
+
+		macro_rules! dummy_unsigned_msg {
+			() => {
+				unsigned_msg = msgs::UnsignedChannelAnnouncement {
+					features: msgs::GlobalFeatures::new(),
+					chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
+					short_channel_id: as_chan.get_short_channel_id().unwrap(),
+					node_id_1: if were_node_one { as_network_key } else { bs_network_key },
+					node_id_2: if !were_node_one { bs_network_key } else { as_network_key },
+					bitcoin_key_1: if were_node_one { as_bitcoin_key } else { bs_bitcoin_key },
+					bitcoin_key_2: if !were_node_one { bs_bitcoin_key } else { as_bitcoin_key },
+				};
+			}
+		}
+
+		macro_rules! sign_msg {
+			() => {
+				let msghash = Message::from_slice(&Sha256dHash::from_data(&unsigned_msg.encode()[..])[..]).unwrap();
+				let as_bitcoin_sig = as_chan.get_secp_ctx().sign(&msghash, &as_chan.get_local_keys().funding_key);
+				let bs_bitcoin_sig = bs_chan.get_secp_ctx().sign(&msghash, &bs_chan.get_local_keys().funding_key);
+				let as_node_sig = as_chan.get_secp_ctx().sign(&msghash, &nodes[0].node.our_network_key);
+				let bs_node_sig = bs_chan.get_secp_ctx().sign(&msghash, &nodes[1].node.our_network_key);
+				chan_announcement = msgs::ChannelAnnouncement {
+					node_signature_1 : if were_node_one { as_node_sig } else { bs_node_sig},
+					node_signature_2 : if !were_node_one { bs_node_sig } else { as_node_sig},
+					bitcoin_signature_1: if were_node_one { as_bitcoin_sig } else { bs_bitcoin_sig },
+					bitcoin_signature_2 : if !were_node_one { bs_bitcoin_sig } else { as_bitcoin_sig },
+					contents: unsigned_msg
+				}
+			}
+		}
+
+		dummy_unsigned_msg!();
+		unsigned_msg.features = msgs::GlobalFeatures::dummy_new(vec!(0xff, 0xff, 0xff, 0xff));
+		sign_msg!();
+		match nodes[0].router.handle_channel_announcement(&chan_announcement) {
+			Ok(_) => assert!(false),
+			Err(_) => assert!(true),
+		}
+
+		//TODO: test short_channel_id correspond to a P2WSH and that output isn't spent
+
+		dummy_unsigned_msg!();
+		sign_msg!();
+		assert_eq!(nodes[0].router.handle_channel_announcement(&chan_announcement).unwrap(), true);
+		let _ = nodes[0].router.remove_channel_info(as_chan.get_short_channel_id().unwrap(), genesis_block(Network::Testnet).header.bitcoin_hash());
+
+		dummy_unsigned_msg!();
+		unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
+		sign_msg!();
+		assert_eq!(nodes[0].router.handle_channel_announcement(&chan_announcement).unwrap(), true);
+		let _ = nodes[0].router.remove_channel_info(as_chan.get_short_channel_id().unwrap(), genesis_block(Network::Bitcoin).header.bitcoin_hash());
+
+		dummy_unsigned_msg!();
+		unsigned_msg.chain_hash = Sha256dHash::from_data(&[1,2,3,4,5,6,7,8,9]);
+		sign_msg!();
+		match nodes[0].router.handle_channel_announcement(&chan_announcement) {
+			Ok(_) => assert!(false),
+			Err(_) => assert!(true),
+		}
+	}
 }

src/ln/msgs.rs

@@ -120,6 +120,13 @@ impl GlobalFeatures {
 		}
 	}
 
+	#[cfg(test)]
+	pub fn dummy_new(v: Vec<u8>) -> GlobalFeatures {
+		GlobalFeatures {
+			flags: v,
+		}
+	}
+
 	pub fn requires_unknown_bits(&self) -> bool {
 		for &byte in self.flags.iter() {
 			if (byte & 0x55) != 0 {

src/ln/router.rs

@@ -3,6 +3,9 @@ use secp256k1::{Secp256k1,Message};
 use secp256k1;
 
 use bitcoin::util::hash::Sha256dHash;
+use bitcoin::blockdata::constants::genesis_block;
+use bitcoin::network::constants::Network;
+use bitcoin::network::serialize::BitcoinHash;
 
 use ln::channelmanager;
 use ln::msgs::{ErrorAction,HandleError,RoutingMessageHandler,MsgEncodable,NetAddress,GlobalFeatures};
@@ -197,13 +200,15 @@ impl RoutingMessageHandler for Router {
 		secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.bitcoin_signature_1, &msg.contents.bitcoin_key_1);
 		secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.bitcoin_signature_2, &msg.contents.bitcoin_key_2);
 
-		//TODO: Call blockchain thing to ask if the short_channel_id is valid
-		//TODO: Only allow bitcoin chain_hash
-
 		if msg.contents.features.requires_unknown_bits() {
 			return Err(HandleError{err: "Channel announcement required unknown feature flags", action: None});
 		}
 
+		//TODO: Call blockchain thing to ask if the short_channel_id is valid
+		if msg.contents.chain_hash != genesis_block(Network::Bitcoin).header.bitcoin_hash() && msg.contents.chain_hash != genesis_block(Network::Testnet).header.bitcoin_hash() {
+			return Err(HandleError{err: "Channel announced on an unknown chain", action: Some(ErrorAction::IgnoreError)});
+		}
+
 		let mut network = self.network_map.write().unwrap();
 
 		match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {