X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fonion_utils.rs;h=d55077770f3baae35e2dab9c2f95fd2136071a50;hb=e9be7e272f98023e3eb74e7a1fc67a7a8377d5fa;hp=03ba8877176b37ee30588f427680631b99f0b49a;hpb=cf13f78cd1957753f694642361fae1e0daa5b98a;p=rust-lightning

diff --git a/lightning/src/ln/onion_utils.rs b/lightning/src/ln/onion_utils.rs
index 03ba8877..d5507777 100644
--- a/lightning/src/ln/onion_utils.rs
+++ b/lightning/src/ln/onion_utils.rs
@@ -91,15 +91,18 @@ pub(super) fn gen_pad_from_shared_secret(shared_secret: &[u8]) -> [u8; 32] {
 	Hmac::from_engine(hmac).into_inner()
 }
 
-pub(crate) fn next_hop_packet_pubkey<T: secp256k1::Signing + secp256k1::Verification>(secp_ctx: &Secp256k1<T>, packet_pubkey: PublicKey, packet_shared_secret: &[u8; 32]) -> Result<PublicKey, secp256k1::Error> {
+/// Calculates a pubkey for the next hop, such as the next hop's packet pubkey or blinding point.
+pub(crate) fn next_hop_pubkey<T: secp256k1::Signing + secp256k1::Verification>(
+	secp_ctx: &Secp256k1<T>, curr_pubkey: PublicKey, shared_secret: &[u8]
+) -> Result<PublicKey, secp256k1::Error> {
 	let blinding_factor = {
 		let mut sha = Sha256::engine();
-		sha.input(&packet_pubkey.serialize()[..]);
-		sha.input(packet_shared_secret);
+		sha.input(&curr_pubkey.serialize()[..]);
+		sha.input(shared_secret);
 		Sha256::from_engine(sha).into_inner()
 	};
 
-	packet_pubkey.mul_tweak(secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap())
+	curr_pubkey.mul_tweak(secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap())
 }
 
 // can only fail if an intermediary hop has an invalid public key or session_priv is invalid
@@ -393,15 +396,22 @@ pub(super) fn build_first_hop_failure_packet(shared_secret: &[u8], failure_type:
 	encrypt_failure_packet(shared_secret, &failure_packet.encode()[..])
 }
 
+pub(crate) struct DecodedOnionFailure {
+	pub(crate) network_update: Option<NetworkUpdate>,
+	pub(crate) short_channel_id: Option<u64>,
+	pub(crate) payment_retryable: bool,
+	#[cfg(test)]
+	pub(crate) onion_error_code: Option<u16>,
+	#[cfg(test)]
+	pub(crate) onion_error_data: Option<Vec<u8>>,
+}
+
 /// Process failure we got back from upstream on a payment we sent (implying htlc_source is an
 /// OutboundRoute).
-/// Returns update, a boolean indicating that the payment itself failed, the short channel id of
-/// the responsible channel, and the error code.
 #[inline]
 pub(super) fn process_onion_failure<T: secp256k1::Signing, L: Deref>(
 	secp_ctx: &Secp256k1<T>, logger: &L, htlc_source: &HTLCSource, mut packet_decrypted: Vec<u8>
-) -> (Option<NetworkUpdate>, Option<u64>, bool, Option<u16>, Option<Vec<u8>>)
-where L::Target: Logger {
+) -> DecodedOnionFailure where L::Target: Logger {
 	let (path, session_priv, first_hop_htlc_msat) = if let &HTLCSource::OutboundRoute {
 		ref path, ref session_priv, ref first_hop_htlc_msat, ..
 	} = htlc_source {
@@ -576,6 +586,8 @@ where L::Target: Logger {
 									msg: chan_update,
 								})
 							} else {
+								// The node in question intentionally encoded a 0-length channel update. This is
+								// likely due to https://github.com/ElementsProject/lightning/issues/6200.
 								network_update = Some(NetworkUpdate::ChannelFailure {
 									short_channel_id: route_hop.short_channel_id,
 									is_permanent: false,
@@ -629,12 +641,24 @@ where L::Target: Logger {
 			log_info!(logger, "Onion Error[from {}: {}({:#x})] {}", route_hop.pubkey, title, error_code, description);
 		}
 	}).expect("Route that we sent via spontaneously grew invalid keys in the middle of it?");
-	if let Some((channel_update, short_channel_id, payment_retryable)) = res {
-		(channel_update, short_channel_id, payment_retryable, error_code_ret, error_packet_ret)
+	if let Some((network_update, short_channel_id, payment_retryable)) = res {
+		DecodedOnionFailure {
+			network_update, short_channel_id, payment_retryable,
+			#[cfg(test)]
+			onion_error_code: error_code_ret,
+			#[cfg(test)]
+			onion_error_data: error_packet_ret
+		}
 	} else {
 		// only not set either packet unparseable or hmac does not match with any
 		// payment not retryable only when garbage is from the final node
-		(None, None, !is_from_final_node, None, None)
+		DecodedOnionFailure {
+			network_update: None, short_channel_id: None, payment_retryable: !is_from_final_node,
+			#[cfg(test)]
+			onion_error_code: None,
+			#[cfg(test)]
+			onion_error_data: None
+		}
 	}
 }
 
@@ -758,12 +782,12 @@ impl HTLCFailReason {
 
 	pub(super) fn decode_onion_failure<T: secp256k1::Signing, L: Deref>(
 		&self, secp_ctx: &Secp256k1<T>, logger: &L, htlc_source: &HTLCSource
-	) -> (Option<NetworkUpdate>, Option<u64>, bool, Option<u16>, Option<Vec<u8>>)
-	where L::Target: Logger {
+	) -> DecodedOnionFailure where L::Target: Logger {
 		match self.0 {
 			HTLCFailReasonRepr::LightningError { ref err } => {
 				process_onion_failure(secp_ctx, logger, &htlc_source, err.data.clone())
 			},
+			#[allow(unused)]
 			HTLCFailReasonRepr::Reason { ref failure_code, ref data, .. } => {
 				// we get a fail_malformed_htlc from the first hop
 				// TODO: We'd like to generate a NetworkUpdate for temporary
@@ -771,7 +795,15 @@ impl HTLCFailReason {
 				// generally ignores its view of our own channels as we provide them via
 				// ChannelDetails.
 				if let &HTLCSource::OutboundRoute { ref path, .. } = htlc_source {
-					(None, Some(path.hops[0].short_channel_id), true, Some(*failure_code), Some(data.clone()))
+					DecodedOnionFailure {
+						network_update: None,
+						payment_retryable: true,
+						short_channel_id: Some(path.hops[0].short_channel_id),
+						#[cfg(test)]
+						onion_error_code: Some(*failure_code),
+						#[cfg(test)]
+						onion_error_data: Some(data.clone()),
+					}
 				} else { unreachable!(); }
 			}
 		}