Introduce Parsing mechanism

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -71,9 +71,9 @@ use crate::ln::msgs::{
 	MessageSendEvent,
 };
 use crate::ln::onion_payment::{
-	check_incoming_htlc_cltv, create_fwd_pending_htlc_info, create_recv_pending_htlc_info,
-	decode_incoming_update_add_htlc_onion, invalid_payment_err_data, ForwardInfo, HopConnector,
-	InboundHTLCErr, NextPacketDetails,
+	check_incoming_htlc_cltv, create_fwd_pending_htlc_info, create_new_update_add_htlc,
+	create_recv_pending_htlc_info, decode_incoming_update_add_htlc_onion, invalid_payment_err_data,
+	ForwardInfo, HopConnector, InboundHTLCErr, NextPacketDetails,
 };
 use crate::ln::onion_utils::{self};
 use crate::ln::onion_utils::{
@@ -6550,6 +6550,7 @@ where
 	pub(crate) fn process_pending_update_add_htlcs(&self) -> bool {
 		let mut should_persist = false;
 		let mut decode_update_add_htlcs = new_hash_map();
+		let mut dummy_update_add_htlcs = new_hash_map();
 		mem::swap(&mut decode_update_add_htlcs, &mut self.decode_update_add_htlcs.lock().unwrap());
 
 		let get_htlc_failure_type = |outgoing_scid_opt: Option<u64>, payment_hash: PaymentHash| {
@@ -6613,7 +6614,39 @@ where
 						&*self.logger,
 						&self.secp_ctx,
 					) {
-						Ok(decoded_onion) => decoded_onion,
+						Ok(decoded_onion) => match decoded_onion {
+							(
+								onion_utils::Hop::Dummy {
+									intro_node_blinding_point,
+									next_hop_hmac,
+									new_packet_bytes,
+									..
+								},
+								Some(NextPacketDetails { next_packet_pubkey, forward_info }),
+							) => {
+								debug_assert!(
+										forward_info.is_none(),
+										"Dummy hops must not contain any forward info, since they are not actually forwarded."
+									);
+								let new_update_add_htlc = create_new_update_add_htlc(
+									update_add_htlc.clone(),
+									&*self.node_signer,
+									&self.secp_ctx,
+									intro_node_blinding_point,
+									next_packet_pubkey,
+									next_hop_hmac,
+									new_packet_bytes,
+								);
+
+								dummy_update_add_htlcs
+									.entry(incoming_scid_alias)
+									.or_insert_with(Vec::new)
+									.push(new_update_add_htlc);
+
+								continue;
+							},
+							_ => decoded_onion,
+						},
 
 						Err((htlc_fail, reason)) => {
 							let failure_type = HTLCHandlingFailureType::InvalidOnion;
@@ -6770,6 +6803,11 @@ where
 				));
 			}
 		}
+
+		// Replace the decode queue with the peeled dummy HTLCs so they can be processed in the next iteration.
+		let mut decode_update_add_htlc_source = self.decode_update_add_htlcs.lock().unwrap();
+		mem::swap(&mut *decode_update_add_htlc_source, &mut dummy_update_add_htlcs);
+
 		should_persist
 	}
 

lightning/src/ln/onion_payment.rs

@@ -15,7 +15,7 @@ use crate::ln::channelmanager::{
 	BlindedFailure, BlindedForward, HTLCFailureMsg, PendingHTLCInfo, PendingHTLCRouting,
 	CLTV_FAR_FAR_AWAY, MIN_CLTV_EXPIRY_DELTA,
 };
-use crate::ln::msgs;
+use crate::ln::msgs::{self, OnionPacket, UpdateAddHTLC};
 use crate::ln::onion_utils;
 use crate::ln::onion_utils::{HTLCFailReason, LocalHTLCFailureReason, ONION_DATA_LEN};
 use crate::sign::{NodeSigner, Recipient};
@@ -668,6 +668,32 @@ where
 	Ok((next_hop, next_packet_details))
 }
 
+pub(super) fn create_new_update_add_htlc<NS: Deref, T: secp256k1::Verification>(
+	msg: msgs::UpdateAddHTLC, node_signer: NS, secp_ctx: &Secp256k1<T>,
+	intro_node_blinding_point: Option<PublicKey>,
+	new_packet_pubkey: Result<PublicKey, secp256k1::Error>, next_hop_hmac: [u8; 32],
+	new_packet_bytes: [u8; 1300],
+) -> UpdateAddHTLC
+where
+	NS::Target: NodeSigner,
+{
+	let new_packet = OnionPacket {
+		version: 0,
+		public_key: new_packet_pubkey,
+		hop_data: new_packet_bytes,
+		hmac: next_hop_hmac,
+	};
+
+	let next_blinding_point =
+		intro_node_blinding_point.or(msg.blinding_point).and_then(|blinding_point| {
+			let encrypted_tlvs_ss =
+				node_signer.ecdh(Recipient::Node, &blinding_point, None).unwrap().secret_bytes();
+			onion_utils::next_hop_pubkey(&secp_ctx, blinding_point, &encrypted_tlvs_ss).ok()
+		});
+
+	UpdateAddHTLC { onion_routing_packet: new_packet, blinding_point: next_blinding_point, ..msg }
+}
+
 pub(super) fn check_incoming_htlc_cltv(
 	cur_height: u32, outgoing_cltv_value: u32, cltv_expiry: u32,
 ) -> Result<(), LocalHTLCFailureReason> {

lightning/src/ln/onion_utils.rs

@@ -2339,6 +2339,18 @@ where
 	let shared_secret =
 		node_signer.ecdh(recipient, hop_pubkey, blinded_node_id_tweak.as_ref()).unwrap();
 
+	let check_authentication = |payment_tlvs_authenticated: bool| -> Result<(), OnionDecodeErr> {
+		if !payment_tlvs_authenticated {
+			return Err(OnionDecodeErr::Relay {
+				err_msg: "Final Node OnionHopData provided for us as an intermediary node",
+				reason: LocalHTLCFailureReason::InvalidOnionPayload,
+				shared_secret,
+				trampoline_shared_secret: None,
+			});
+		}
+		Ok(())
+	};
+
 	let decoded_hop: Result<(msgs::InboundOnionPayload, Option<_>), _> = decode_next_hop(
 		shared_secret.secret_bytes(),
 		hop_data,
@@ -2363,6 +2375,18 @@ where
 						new_packet_bytes,
 					})
 				},
+				msgs::InboundOnionPayload::Dummy {
+					intro_node_blinding_point,
+					payment_tlvs_authenticated,
+				} => {
+					check_authentication(payment_tlvs_authenticated)?;
+					Ok(Hop::Dummy {
+						intro_node_blinding_point,
+						shared_secret,
+						next_hop_hmac,
+						new_packet_bytes,
+					})
+				},
 				_ => {
 					if blinding_point.is_some() {
 						return Err(OnionDecodeErr::Malformed {