Merge pull request #4722 from TheBlueMatt/2026-06-0.2-backports-3

TheBlueMatt · web-flow · commit 5dcfd9efa2e2 · 2026-06-19T00:38:32.000Z
diff --git a/lightning-invoice/src/lib.rs b/lightning-invoice/src/lib.rs
@@ -1498,17 +1498,22 @@ impl Bolt11Invoice {
 		self.signed_invoice.features()
 	}
 
-	/// Recover the payee's public key (only to be used if none was included in the invoice)
+	/// Get the invoice's payee public key.
+	///
+	/// This uses the explicitly included payee public key, if present, otherwise it recovers the
+	/// payee public key from the signature. Prefer [`Self::get_payee_pub_key`] for clarity.
 	pub fn recover_payee_pub_key(&self) -> PublicKey {
-		self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
+		self.get_payee_pub_key()
 	}
 
-	/// Recover the payee's public key if one was included in the invoice, otherwise return the
-	/// recovered public key from the signature
+	/// Get the invoice's payee public key, preferring an explicitly included payee public key and
+	/// falling back to recovering the key from the signature.
 	pub fn get_payee_pub_key(&self) -> PublicKey {
 		match self.payee_pub_key() {
 			Some(pk) => *pk,
-			None => self.recover_payee_pub_key(),
+			None => {
+				self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
+			},
 		}
 	}
 
@@ -2044,6 +2049,44 @@ mod test {
 		assert!(new_signed.check_signature());
 	}
 
+	#[test]
+	fn recover_payee_pub_key_uses_included_payee_pub_key() {
+		use crate::*;
+		use bitcoin::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
+		use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
+		use core::time::Duration;
+
+		let secp_ctx = Secp256k1::new();
+		let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
+		let public_key = PublicKey::from_secret_key(&secp_ctx, &private_key);
+
+		let invoice = InvoiceBuilder::new(Currency::Bitcoin)
+			.description("Test".to_string())
+			.payment_hash(sha256::Hash::from_slice(&[0; 32][..]).unwrap())
+			.payment_secret(PaymentSecret([21; 32]))
+			.payee_pub_key(public_key)
+			.min_final_cltv_expiry_delta(144)
+			.duration_since_epoch(Duration::from_secs(1234567))
+			.build_signed(|hash| secp_ctx.sign_ecdsa_recoverable(hash, &private_key))
+			.unwrap();
+
+		let signed_raw = invoice.into_signed_raw();
+		let (raw_invoice, hash, signature) = signed_raw.into_parts();
+		let (_orig_rid, sig_bytes) = signature.0.serialize_compact();
+		let bad_rid = RecoveryId::from_i32(2).unwrap();
+		let bad_sig = RecoverableSignature::from_compact(&sig_bytes, bad_rid).unwrap();
+		let bad_signed_raw = SignedRawBolt11Invoice {
+			raw_invoice,
+			hash,
+			signature: Bolt11InvoiceSignature(bad_sig),
+		};
+		let bad_invoice = Bolt11Invoice::from_signed(bad_signed_raw).unwrap();
+
+		assert_eq!(bad_invoice.payee_pub_key(), Some(&public_key));
+		assert_eq!(bad_invoice.recover_payee_pub_key(), public_key);
+		assert_eq!(bad_invoice.get_payee_pub_key(), public_key);
+	}
+
 	#[test]
 	fn test_check_feature_bits() {
 		use crate::TaggedField::*;
diff --git a/lightning-rapid-gossip-sync/src/lib.rs b/lightning-rapid-gossip-sync/src/lib.rs
@@ -153,6 +153,10 @@ where
 	/// Sync gossip data from a file.
 	/// Returns the last sync timestamp to be used the next time rapid sync data is queried.
 	///
+	/// You should consider the gossip data source as semi-trusted. It is generally the case that it
+	/// can DoS the client either by omitting data which leads to pathfinding failure or by bloating
+	/// the graph such that it leads to eventual OOM on the client.
+	///
 	/// `network_graph`: The network graph to apply the updates to
 	///
 	/// `sync_path`: Path to the file where the gossip update data is located
@@ -172,6 +176,10 @@ where
 	/// Update network graph from binary data.
 	/// Returns the last sync timestamp to be used the next time rapid sync data is queried.
 	///
+	/// You should consider the gossip data source as semi-trusted. It is generally the case that it
+	/// can DoS the client either by omitting data which leads to pathfinding failure or by bloating
+	/// the graph such that it leads to eventual OOM on the client.
+	///
 	/// `update_data`: `&[u8]` binary stream that comprises the update data
 	#[cfg(feature = "std")]
 	pub fn update_network_graph(&self, update_data: &[u8]) -> Result<u32, GraphSyncError> {
@@ -182,6 +190,10 @@ where
 	/// Update network graph from binary data.
 	/// Returns the last sync timestamp to be used the next time rapid sync data is queried.
 	///
+	/// You should consider the gossip data source as semi-trusted. It is generally the case that it
+	/// can DoS the client either by omitting data which leads to pathfinding failure or by bloating
+	/// the graph such that it leads to eventual OOM on the client.
+	///
 	/// `update_data`: `&[u8]` binary stream that comprises the update data
 	/// `current_time_unix`: `Option<u64>` optional current timestamp to verify data age
 	pub fn update_network_graph_no_std(
diff --git a/lightning-rapid-gossip-sync/src/processing.rs b/lightning-rapid-gossip-sync/src/processing.rs
@@ -9,7 +9,9 @@ use lightning::ln::msgs::{
 	DecodeError, ErrorAction, LightningError, SocketAddress, UnsignedChannelUpdate,
 	UnsignedNodeAnnouncement,
 };
-use lightning::routing::gossip::{NetworkGraph, NodeAlias, NodeId};
+use lightning::routing::gossip::{
+	NetworkGraph, NodeAlias, NodeId, CHAN_COUNT_ESTIMATE, NODE_COUNT_ESTIMATE,
+};
 use lightning::util::logger::Logger;
 use lightning::util::ser::{BigSize, FixedLengthReader, Readable};
 use lightning::{log_debug, log_given_level, log_gossip, log_trace, log_warn};
@@ -115,17 +117,27 @@ where
 			}
 		};
 
+		const MAX_NODE_COUNT: u32 = (NODE_COUNT_ESTIMATE as u32) * 10;
+		const MAX_CHANNEL_COUNT: u64 = (CHAN_COUNT_ESTIMATE as u64) * 10;
+
 		let node_id_count: u32 = Readable::read(read_cursor)?;
+		if node_id_count > MAX_NODE_COUNT {
+			return Err(LightningError {
+				err: "RGS data contained nonsense number of nodes to update".to_owned(),
+				action: ErrorAction::IgnoreError,
+			}
+			.into());
+		}
 		let mut node_ids: Vec<NodeId> = Vec::with_capacity(core::cmp::min(
 			node_id_count,
 			MAX_INITIAL_NODE_ID_VECTOR_CAPACITY,
 		) as usize);
-
 		let network_graph = &self.network_graph;
 		let mut node_modifications: Vec<UnsignedNodeAnnouncement> = Vec::new();
 
+		let read_only_network_graph = network_graph.read_only();
+
 		if parse_node_details {
-			let read_only_network_graph = network_graph.read_only();
 			for _ in 0..node_id_count {
 				let mut pubkey_bytes = [0u8; 33];
 				read_cursor.read_exact(&mut pubkey_bytes)?;
@@ -237,9 +249,12 @@ where
 			}
 		}
 
+		let original_graph_channel_count = read_only_network_graph.channels().len() as u32;
+		core::mem::drop(read_only_network_graph);
+
 		let mut previous_scid: u64 = 0;
 		let announcement_count: u32 = Readable::read(read_cursor)?;
-		for _ in 0..announcement_count {
+		for i in 0..announcement_count {
 			let features = Readable::read(read_cursor)?;
 
 			// handle SCID
@@ -284,6 +299,10 @@ where
 				}
 			}
 
+			if (original_graph_channel_count as u64) + (i as u64) > MAX_CHANNEL_COUNT {
+				continue;
+			}
+
 			let announcement_result = network_graph.add_channel_from_partial_announcement(
 				short_channel_id,
 				funding_sats,
@@ -329,6 +348,13 @@ where
 		previous_scid = 0;
 
 		let update_count: u32 = Readable::read(read_cursor)?;
+		if update_count as u64 > MAX_CHANNEL_COUNT {
+			return Err(LightningError {
+				err: "RGS data contained nonsense number of channels to update".to_owned(),
+				action: ErrorAction::IgnoreError,
+			}
+			.into());
+		}
 		log_debug!(self.logger, "Processing RGS update from {} with {} nodes, {} channel announcements and {} channel updates.",
 			latest_seen_timestamp, node_id_count, announcement_count, update_count);
 		if update_count == 0 {
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
@@ -1959,9 +1959,12 @@ where
 
 		let tx_abort = should_ack.then(|| {
 			let logger = WithChannelContext::from(logger, &self.context(), None);
-			let reason =
-				types::string::UntrustedString(String::from_utf8_lossy(&msg.data).to_string());
-			log_info!(logger, "Counterparty failed interactive transaction negotiation: {reason}");
+			let reason = String::from_utf8_lossy(&msg.data);
+			log_info!(
+				logger,
+				"Counterparty failed interactive transaction negotiation: {}",
+				log_msg!(reason)
+			);
 			msgs::TxAbort {
 				channel_id: msg.channel_id,
 				data: "Acknowledged tx_abort".to_string().into_bytes(),
diff --git a/lightning/src/ln/invoice_utils.rs b/lightning/src/ln/invoice_utils.rs
@@ -1288,7 +1288,7 @@ mod test {
 		assert!(!invoice.features().unwrap().supports_basic_mpp());
 
 		let payment_params = PaymentParameters::from_node_id(
-			invoice.recover_payee_pub_key(),
+			invoice.get_payee_pub_key(),
 			invoice.min_final_cltv_expiry_delta() as u32,
 		)
 		.with_bolt11_features(invoice.features().unwrap().clone())
@@ -1350,7 +1350,7 @@ mod test {
 			payment_secret,
 			payment_amt,
 			payment_preimage_opt,
-			invoice.recover_payee_pub_key(),
+			invoice.get_payee_pub_key(),
 		);
 		do_claim_payment_along_route(ClaimAlongRouteArgs::new(
 			&nodes[0],
diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
@@ -45,7 +45,6 @@ use crate::onion_message::packet::OnionMessageContents;
 use crate::routing::gossip::{NodeAlias, NodeId};
 use crate::sign::{NodeSigner, Recipient};
 use crate::types::features::{InitFeatures, NodeFeatures};
-use crate::types::string::PrintableString;
 use crate::util::atomic_counter::AtomicCounter;
 use crate::util::logger::{Level, Logger, WithContext};
 use crate::util::ser::{VecWriter, Writeable, Writer};
@@ -2415,7 +2414,7 @@ where
 					logger,
 					"Got Err message from {}: {}",
 					their_node_id,
-					PrintableString(&msg.data)
+					log_msg!(msg.data)
 				);
 				self.message_handler.chan_handler.handle_error(their_node_id, &msg);
 				if msg.channel_id.is_zero() {
@@ -2427,7 +2426,7 @@ where
 					logger,
 					"Got warning message from {}: {}",
 					their_node_id,
-					PrintableString(&msg.data)
+					log_msg!(msg.data)
 				);
 			},
 
@@ -3213,7 +3212,7 @@ where
 								msgs::ErrorAction::DisconnectPeer { msg } => {
 									if let Some(msg) = msg.as_ref() {
 										log_trace!(logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}",
-											node_id, msg.data);
+											node_id, log_msg!(msg.data));
 									} else {
 										log_trace!(logger, "Handling DisconnectPeer HandleError event in peer_handler for node {}",
 											node_id);
@@ -3228,7 +3227,7 @@ where
 								},
 								msgs::ErrorAction::DisconnectPeerWithWarning { msg } => {
 									log_trace!(logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}",
-										node_id, msg.data);
+										node_id, log_msg!(msg.data));
 									// We do not have the peers write lock, so we just store that we're
 									// about to disconnect the peer and do it after we finish
 									// processing most messages.
@@ -3254,7 +3253,7 @@ where
 								msgs::ErrorAction::SendErrorMessage { ref msg } => {
 									log_trace!(logger, "Handling SendErrorMessage HandleError event in peer_handler for node {} with message {}",
 											node_id,
-											msg.data);
+											log_msg!(msg.data));
 									self.enqueue_message(
 										&mut *get_peer_for_forwarding!(&node_id)?,
 										msg,
@@ -3266,7 +3265,7 @@ where
 								} => {
 									log_given_level!(logger, *log_level, "Handling SendWarningMessage HandleError event in peer_handler for node {} with message {}",
 											node_id,
-											msg.data);
+											log_msg!(msg.data));
 									self.enqueue_message(
 										&mut *get_peer_for_forwarding!(&node_id)?,
 										msg,
diff --git a/lightning/src/onion_message/dns_resolution.rs b/lightning/src/onion_message/dns_resolution.rs
@@ -520,7 +520,8 @@ impl OMNameResolver {
 					.filter_map(|data| String::from_utf8(data).ok())
 					.filter(|data_string| data_string.len() > URI_PREFIX.len())
 					.filter(|data_string| {
-						data_string[..URI_PREFIX.len()].eq_ignore_ascii_case(URI_PREFIX)
+						let pfx = &data_string.as_bytes()[..URI_PREFIX.len()];
+						pfx.eq_ignore_ascii_case(URI_PREFIX.as_bytes())
 					});
 				// Check that there is exactly one TXT record that begins with
 				// bitcoin: as required by BIP 353 (and is valid UTF-8).
diff --git a/lightning/src/routing/gossip.rs b/lightning/src/routing/gossip.rs
@@ -1757,14 +1757,16 @@ where
 	}
 }
 
-// In Jan, 2025 there were about 49K channels.
-// We over-allocate by a bit because 20% more is better than the double we get if we're slightly
-// too low
-const CHAN_COUNT_ESTIMATE: usize = 60_000;
-// In Jan, 2025 there were about 15K nodes
-// We over-allocate by a bit because 33% more is better than the double we get if we're slightly
-// too low
-const NODE_COUNT_ESTIMATE: usize = 20_000;
+/// In Jan, 2025 there were about 49K channels.
+///
+/// We over-allocate by a bit because 20% more is better than the double we get if we're slightly
+/// too low
+pub const CHAN_COUNT_ESTIMATE: usize = 60_000;
+/// In Jan, 2025 there were about 15K nodes
+///
+/// We over-allocate by a bit because 33% more is better than the double we get if we're slightly
+/// too low
+pub const NODE_COUNT_ESTIMATE: usize = 20_000;
 
 impl<L: Deref> NetworkGraph<L>
 where
diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs
diff --git a/lightning/src/util/macro_logger.rs b/lightning/src/util/macro_logger.rs
diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
diff --git a/possiblyrandom/src/lib.rs b/possiblyrandom/src/lib.rs
