Manipulate an Onion packet for testing Bolt 4

Author: philipr-za

src/ln/channelmanager.rs

@@ -949,7 +949,7 @@ impl ChannelManager {
 		if msg.onion_routing_packet.version != 0 {
 			//TODO: Spec doesn't indicate if we should only hash hop_data here (and in other
 			//sha256_of_onion error data packets), or the entire onion_routing_packet. Either way,
-			//the hash doesn't really serve any purpuse - in the case of hashing all data, the
+			//the hash doesn't really serve any purpose - in the case of hashing all data, the
 			//receiving node would have to brute force to figure out which version was put in the
 			//packet by the node that send us the message, in the case of hashing the hop_data, the
 			//node knows the HMAC matched, so they already know what is there...
@@ -3222,7 +3222,7 @@ mod tests {
 	use util::logger::Logger;
 	use util::ser::{Writeable, Writer, ReadableArgs};
 	use util::config::UserConfig;
-
+	use util::rng;
 	use bitcoin::util::hash::{BitcoinHash, Sha256dHash};
 	use bitcoin::blockdata::block::{Block, BlockHeader};
 	use bitcoin::blockdata::transaction::{Transaction, TxOut};
@@ -7532,4 +7532,58 @@ mod tests {
 			assert_eq!(msg.channel_id, channel_id);
 		} else { panic!("Unexpected result"); }
 	}
+
+	#[test]
+	///Test that forwarding an onion packet with version other than 0 fails
+	fn test_bolt4_onion_packet_version_error() {
+		let nodes = create_network(3);
+
+		let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
+		let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
+
+		let expected_route = vec!(&nodes[1], &nodes[2]);
+		let value = 1000000;
+
+		let our_payment_preimage = route_payment(&nodes[0], &expected_route, value).0;
+		let route = nodes[0].router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), value, TEST_FINAL_CLTV).unwrap();
+
+		let secp_ctx = Secp256k1::new();
+		let session_priv = SecretKey::from_slice(&secp_ctx, &{
+			let mut session_key = [0; 32];
+			rng::fill_bytes(&mut session_key);
+			session_key
+		}).expect("RNG is bad!");
+
+		let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
+
+		let onion_keys = ChannelManager::construct_onion_keys(&secp_ctx, &route, &session_priv).unwrap();
+
+		let (onion_payloads, htlc_msat, htlc_cltv) = ChannelManager::build_onion_payloads(&route, cur_height).unwrap();
+		let mut onion_packet = ChannelManager::construct_onion_packet(onion_payloads, onion_keys, &our_payment_preimage);
+
+		onion_packet.version = 1;
+
+		let mut channel_state = nodes[0].node.channel_state.lock().unwrap();
+		let (update_add, commitment_signed, chan_monitor) = {
+			let chan = channel_state.by_id.get_mut(&chan_1.2).unwrap();
+			chan.send_htlc_and_commit(htlc_msat, our_payment_preimage.clone(), htlc_cltv, super::channel_held_info::HTLCSource::OutboundRoute {
+				route: route.clone(),
+				session_priv: session_priv.clone(),
+				first_hop_htlc_msat: htlc_msat,
+			}, onion_packet).unwrap().unwrap()//.map_err(|he| APIError::ChannelUnavailable{err: he.err}).unwrap()
+		};
+
+		println!("Mesg: {:?}", update_add.onion_routing_packet.version);
+
+		let res = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(),&update_add);
+		//This does create a PendingHTLCStatus::Fail situation that seems is maybe sent back to the node
+		//and is finally handled in channel::revoke_and_ack(...)
+
+		println!("Bolt4: {:?}", res);
+
+
+		assert!(false);
+	}
+
 }
+