f: de-macro malformed errors and infer zero-data from error code

Author: arik-so

lightning/src/ln/onion_payment.rs

@@ -473,27 +473,23 @@ where
 	NS::Target: NodeSigner,
 	L::Target: Logger,
 {
-	macro_rules! return_malformed_err {
-		($msg: expr, $err_code: expr, $force_blinding_error: expr) => {
-			{
-				log_info!(logger, "Failed to accept/forward incoming HTLC: {}", $msg);
-				let (sha256_of_onion, failure_code) = if $force_blinding_error || msg.blinding_point.is_some() {
-					([0; 32], INVALID_ONION_BLINDING)
-				} else {
-					(Sha256::hash(&msg.onion_routing_packet.hop_data).to_byte_array(), $err_code)
-				};
-				return Err(HTLCFailureMsg::Malformed(msgs::UpdateFailMalformedHTLC {
-					channel_id: msg.channel_id,
-					htlc_id: msg.htlc_id,
-					sha256_of_onion,
-					failure_code,
-				}));
-			}
-		}
-	}
+	let encode_malformed_error = |message: &str, err_code: u16| {
+		log_info!(logger, "Failed to accept/forward incoming HTLC: {}", message);
+		let (sha256_of_onion, failure_code) = if msg.blinding_point.is_some() || err_code == INVALID_ONION_BLINDING {
+			([0; 32], INVALID_ONION_BLINDING)
+		} else {
+			(Sha256::hash(&msg.onion_routing_packet.hop_data).to_byte_array(), err_code)
+		};
+		return Err(HTLCFailureMsg::Malformed(msgs::UpdateFailMalformedHTLC {
+			channel_id: msg.channel_id,
+			htlc_id: msg.htlc_id,
+			sha256_of_onion,
+			failure_code,
+		}));
+	};
 
 	if let Err(_) = msg.onion_routing_packet.public_key {
-		return_malformed_err!("invalid ephemeral pubkey", 0x8000 | 0x4000 | 6, false);
+		return encode_malformed_error("invalid ephemeral pubkey", 0x8000 | 0x4000 | 6);
 	}
 
 	if msg.onion_routing_packet.version != 0 {
@@ -503,12 +499,12 @@ where
 		//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...
-		return_malformed_err!("Unknown onion packet version", 0x8000 | 0x4000 | 4, false);
+		return encode_malformed_error("Unknown onion packet version", 0x8000 | 0x4000 | 4);
 	}
 
 	let encode_relay_error = |message: &str, err_code: u16, shared_secret: [u8; 32], trampoline_shared_secret: Option<[u8; 32]>, data: &[u8]| {
 		if msg.blinding_point.is_some() {
-			return_malformed_err!(message, INVALID_ONION_BLINDING, false)
+			return encode_malformed_error(message, INVALID_ONION_BLINDING)
 		}
 
 		log_info!(logger, "Failed to accept/forward incoming HTLC: {}", message);
@@ -526,8 +522,8 @@ where
 		msg.payment_hash, msg.blinding_point, node_signer
 	) {
 		Ok(res) => res,
-		Err(onion_utils::OnionDecodeErr::Malformed { err_msg, err_code, trampoline_onion_blinding }) => {
-			return_malformed_err!(err_msg, err_code, trampoline_onion_blinding);
+		Err(onion_utils::OnionDecodeErr::Malformed { err_msg, err_code }) => {
+			return encode_malformed_error(err_msg, err_code);
 		},
 		Err(onion_utils::OnionDecodeErr::Relay { err_msg, err_code, shared_secret, trampoline_shared_secret }) => {
 			return encode_relay_error(err_msg, err_code, shared_secret.secret_bytes(), trampoline_shared_secret.map(|tss| tss.secret_bytes()), &[0; 0]);

lightning/src/ln/onion_utils.rs

@@ -1676,7 +1676,7 @@ pub(crate) enum OnionDecodeErr {
 	///
 	/// If the malformed onion packet was a blinded Trampoline hop, we communicate it up the call
 	/// stack for appropriate error handling.
-	Malformed { err_msg: &'static str, err_code: u16, trampoline_onion_blinding: bool },
+	Malformed { err_msg: &'static str, err_code: u16 },
 	/// We failed to decode the onion payload.
 	///
 	/// If the payload we failed to decode belonged to a Trampoline onion, following the successful
@@ -1735,7 +1735,6 @@ where
 							err_msg:
 								"Final Node OnionHopData provided for us as an intermediary node",
 							err_code: INVALID_ONION_BLINDING,
-							trampoline_onion_blinding: false,
 						});
 					}
 					Err(OnionDecodeErr::Relay {
@@ -1836,15 +1835,13 @@ where
 						Err(OnionDecodeErr::Malformed {
 							err_msg: "Non-final Trampoline onion data provided to us as last hop",
 							err_code: INVALID_ONION_BLINDING,
-							trampoline_onion_blinding: true,
 						})
 					},
 					Ok((msgs::InboundTrampolinePayload::BlindedReceive(_), Some(_))) => {
 						Err(OnionDecodeErr::Malformed {
 							err_msg:
 								"Final Trampoline onion data provided to us as intermediate hop",
 							err_code: INVALID_ONION_BLINDING,
-							trampoline_onion_blinding: true,
 						})
 					},
 					Ok((_, None)) => Err(OnionDecodeErr::Relay {
@@ -1871,7 +1868,6 @@ where
 					return Err(OnionDecodeErr::Malformed {
 						err_msg: "Intermediate Node OnionHopData provided for us as a final node",
 						err_code: INVALID_ONION_BLINDING,
-						trampoline_onion_blinding: false,
 					});
 				}
 				Err(OnionDecodeErr::Relay {
@@ -2006,7 +2002,6 @@ fn decode_next_hop<T, R: ReadableArgs<T>, N: NextPacketBytes>(
 		return Err(OnionDecodeErr::Malformed {
 			err_msg: "HMAC Check failed",
 			err_code: 0x8000 | 0x4000 | 5,
-			trampoline_onion_blinding: false,
 		});
 	}