works

Author: joostjager

fuzz/src/process_onion_failure.rs

@@ -30,10 +30,35 @@ fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 		let logger: Arc<dyn Logger> =
 				Arc::new(test_logger::TestLogger::new("".to_owned(), out));
 
-		let first_hop_htlc_msat_bytes = match get_slice!(8).try_into() {
-			Ok(val) => val,
-			Err(_) => return,
-		};
+		macro_rules! get_u64 {
+			() => {
+				match get_slice!(8).try_into() {
+					Ok(val) => u64::from_be_bytes(val),
+					Err(_) => return,
+				}
+			};
+		}
+
+		macro_rules! get_u32 {
+			() => {
+				match get_slice!(4).try_into() {
+					Ok(val) => u32::from_be_bytes(val),
+					Err(_) => return,
+				}
+			};
+		}
+
+		macro_rules! get_bool {
+			() => {
+				get_slice!(1)[0] != 0
+			};
+		}
+
+		macro_rules! get_u8 {
+			() => {
+				get_slice!(1)[0]
+			};
+		}
 
 		let session_priv = match SecretKey::from_slice(get_slice!(32)) {
 			Ok(val) => val,
@@ -54,74 +79,60 @@ fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 			};
 		}
 
-		let path = Path {
-			hops: vec![
-				// Bob
-				RouteHop {
-					pubkey: get_pubkey!(),
-					node_features: NodeFeatures::empty(),
-					short_channel_id: 0,
-					channel_features: ChannelFeatures::empty(),
-					fee_msat: 3_000,
-					cltv_expiry_delta: 24,
-					maybe_announced_channel: false,
-				},
-
-				// Carol
-				RouteHop {
-					pubkey: get_pubkey!(),
-					node_features: NodeFeatures::empty(),
-					short_channel_id: (572330 << 40) + (42 << 16) + 2821,
-					channel_features: ChannelFeatures::empty(),
-					fee_msat: 153_000,
-					cltv_expiry_delta: 0,
-					maybe_announced_channel: false,
-				},
-			],
-			blinded_tail: Some(BlindedTail {
-				trampoline_hops: vec![
-					// Carol's pubkey
-					TrampolineHop {
-						pubkey: get_pubkey!(),
-						node_features: Features::empty(),
-						fee_msat: 2_500,
-						cltv_expiry_delta: 24,
-					},
-
-					// Dave's pubkey
-					TrampolineHop {
-						pubkey: get_pubkey!(),
-						node_features: Features::empty(),
-						fee_msat: 2_500,
-						cltv_expiry_delta: 24,
-					},
+		let mut hops = Vec::<RouteHop>::new();
+		let hop_count = get_slice!(1)[0] as usize;
+		for i in 0..hop_count {
+			hops.push(RouteHop {
+				pubkey: get_pubkey!(),
+				node_features: NodeFeatures::empty(),
+				short_channel_id: get_u64!(),
+				channel_features: ChannelFeatures::empty(),
+				fee_msat: get_u64!(),
+				cltv_expiry_delta: get_u32!(),
+				maybe_announced_channel: get_bool!(),
+			});
+		}
 
-					// Emily's pubkey
-					TrampolineHop {
+		let blinded_tail = match get_bool!() {
+			true => {
+				let mut trampoline_hops = Vec::<TrampolineHop>::new();
+				let trampoline_hop_count = get_slice!(1)[0] as usize;
+				for i in 0..trampoline_hop_count {
+					trampoline_hops.push(TrampolineHop {
 						pubkey: get_pubkey!(),
-						node_features: Features::empty(),
-						fee_msat: 150_500,
-						cltv_expiry_delta: 36,
-					},
-				],
-
-				// Dummy blinded hop (because LDK doesn't allow unblinded Trampoline receives)
-				hops: vec![
-					// Emily's dummy blinded node id
-					BlindedHop {
+						node_features: NodeFeatures::empty(),
+						fee_msat: get_u64!(),
+						cltv_expiry_delta: get_u32!(),
+					});
+				}
+				let mut blinded_hops = Vec::<BlindedHop>::new();
+				let blinded_hop_count = get_slice!(1)[0] as usize;
+				for i in 0..blinded_hop_count {
+					blinded_hops.push(BlindedHop {
 						blinded_node_id: get_pubkey!(),
-						encrypted_payload: vec![],
-					}
-				],
-				blinding_point: get_pubkey!(),
-				excess_final_cltv_expiry_delta: 0,
-				final_value_msat: 150_000_000,
-			})};
+						encrypted_payload: get_slice!(get_u8!()).to_vec(),
+					});
+				}
+				Some(BlindedTail{
+					trampoline_hops,
+					hops: blinded_hops,
+					blinding_point: get_pubkey!(),
+					excess_final_cltv_expiry_delta: get_u32!(),
+					final_value_msat: get_u64!(),
+				})
+			},
+			false => None,
+		};
+
+		let path = Path {
+			hops,
+			blinded_tail,
+		};
 
 		let htlc_source = HTLCSource::OutboundRoute {
 			path,
 			session_priv,
-			first_hop_htlc_msat: u64::from_be_bytes(first_hop_htlc_msat_bytes),
+			first_hop_htlc_msat: get_u64!(),
 			payment_id,
 		};
 

lightning/src/ln/onion_utils.rs

@@ -991,6 +991,19 @@ where
 		_ => unreachable!(),
 	};
 
+	if encrypted_packet.data.len() < 32 {
+		return DecodedOnionFailure {
+			network_update: None,
+			short_channel_id: None,
+			payment_failed_permanently: false,
+			failed_within_blinded_path: false,
+			#[cfg(any(test, feature = "_test_utils"))]
+			onion_error_code: None,
+			#[cfg(any(test, feature = "_test_utils"))]
+			onion_error_data: None,
+		};
+	}
+
 	// Learnings from the HTLC failure to inform future payment retries and scoring.
 	struct FailureLearnings {
 		network_update: Option<NetworkUpdate>,
@@ -999,7 +1012,6 @@ where
 		failed_within_blinded_path: bool,
 	}
 	let mut res: Option<FailureLearnings> = None;
-	let mut htlc_msat = *first_hop_htlc_msat;
 	let mut _error_code_ret = None;
 	let mut _error_packet_ret = None;
 	let mut is_from_final_non_blinded_node = false;
@@ -1138,16 +1150,13 @@ where
 			}
 		};
 
-		let amt_to_forward = htlc_msat - route_hop.fee_msat();
-		htlc_msat = amt_to_forward;
-
 		crypt_failure_packet(shared_secret.as_ref(), &mut encrypted_packet);
 
 		let um = gen_um_from_shared_secret(shared_secret.as_ref());
 		let mut hmac = HmacEngine::<Sha256>::new(&um);
 		hmac.input(&encrypted_packet.data[32..]);
 
-		if !fixed_time_eq(&Hmac::from_engine(hmac).to_byte_array(), &encrypted_packet.data[..32]) {
+		if &Hmac::from_engine(hmac).to_byte_array() != &encrypted_packet.data[..32] {
 			continue;
 		}