X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Fmessenger.rs;h=5dc3bb422e67efffc880465ad5ab3769ce48fc7a;hb=refs%2Fheads%2F2024-01-om-direct-export;hp=05ea7a2853cd6bf6c415bde58c4dea0e32acb999;hpb=2d266794c2133782938ce62a96538ef138c85781;p=rust-lightning diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs index 05ea7a28..5dc3bb42 100644 --- a/lightning/src/onion_message/messenger.rs +++ b/lightning/src/onion_message/messenger.rs @@ -7,8 +7,8 @@ // You may not use this file except in accordance with one or both of these // licenses. -//! LDK sends, receives, and forwards onion messages via the [`OnionMessenger`]. See its docs for -//! more information. +//! LDK sends, receives, and forwards onion messages via this [`OnionMessenger`], which lives here, +//! as well as various types, traits, and utilities that it uses. use bitcoin::hashes::{Hash, HashEngine}; use bitcoin::hashes::hmac::{Hmac, HmacEngine}; @@ -19,15 +19,14 @@ use crate::blinded_path::BlindedPath; use crate::blinded_path::message::{advance_path_by_one, ForwardTlvs, ReceiveTlvs}; use crate::blinded_path::utils; use crate::events::{Event, EventHandler, EventsProvider}; -use crate::sign::{EntropySource, KeysManager, NodeSigner, Recipient}; +use crate::sign::{EntropySource, NodeSigner, Recipient}; #[cfg(not(c_bindings))] use crate::ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager}; use crate::ln::features::{InitFeatures, NodeFeatures}; use crate::ln::msgs::{self, OnionMessage, OnionMessageHandler, SocketAddress}; use crate::ln::onion_utils; -use crate::ln::peer_handler::IgnoringMessageHandler; use crate::routing::gossip::{NetworkGraph, NodeId}; -pub use super::packet::OnionMessageContents; +use super::packet::OnionMessageContents; use super::packet::ParsedOnionMessageContents; use super::offers::OffersMessageHandler; use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload, ReceiveControlTlvs, SMALL_PACKET_HOP_DATA_LEN}; @@ -37,9 +36,16 @@ use crate::util::ser::Writeable; use core::fmt; use core::ops::Deref; use crate::io; -use crate::sync::{Arc, Mutex}; +use crate::sync::Mutex; use crate::prelude::*; +#[cfg(not(c_bindings))] +use { + crate::sign::KeysManager, + crate::ln::peer_handler::IgnoringMessageHandler, + crate::sync::Arc, +}; + pub(super) const MAX_TIMER_TICKS: usize = 2; /// A sender, receiver and forwarder of [`OnionMessage`]s. @@ -64,11 +70,12 @@ pub(super) const MAX_TIMER_TICKS: usize = 2; /// # extern crate bitcoin; /// # use bitcoin::hashes::_export::_core::time::Duration; /// # use bitcoin::hashes::hex::FromHex; -/// # use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; +/// # use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey, self}; /// # use lightning::blinded_path::BlindedPath; -/// # use lightning::sign::KeysManager; +/// # use lightning::sign::{EntropySource, KeysManager}; /// # use lightning::ln::peer_handler::IgnoringMessageHandler; -/// # use lightning::onion_message::{OnionMessageContents, Destination, MessageRouter, OnionMessagePath, OnionMessenger}; +/// # use lightning::onion_message::messenger::{Destination, MessageRouter, OnionMessagePath, OnionMessenger}; +/// # use lightning::onion_message::packet::OnionMessageContents; /// # use lightning::util::logger::{Logger, Record}; /// # use lightning::util::ser::{Writeable, Writer}; /// # use lightning::io; @@ -87,9 +94,14 @@ pub(super) const MAX_TIMER_TICKS: usize = 2; /// # Ok(OnionMessagePath { /// # intermediate_nodes: vec![hop_node_id1, hop_node_id2], /// # destination, -/// # addresses: None, +/// # first_node_addresses: None, /// # }) /// # } +/// # fn create_blinded_paths( +/// # &self, _recipient: PublicKey, _peers: Vec, _entropy_source: &ES, _secp_ctx: &Secp256k1 +/// # ) -> Result, ()> { +/// # unreachable!() +/// # } /// # } /// # let seed = [42u8; 32]; /// # let time = Duration::from_secs(123456); @@ -223,6 +235,13 @@ impl OnionMessageRecipient { *self = OnionMessageRecipient::ConnectedPeer(new_pending_messages); } } + + fn is_connected(&self) -> bool { + match self { + OnionMessageRecipient::ConnectedPeer(..) => true, + OnionMessageRecipient::PendingConnection(..) => false, + } + } } /// An [`OnionMessage`] for [`OnionMessenger`] to send. @@ -246,7 +265,7 @@ pub struct PendingOnionMessage { /// /// These are obtained when released from [`OnionMessenger`]'s handlers after which they are /// enqueued for sending. -pub type PendingOnionMessage = (T, Destination, Option); +pub type PendingOnionMessage = (T, Destination, Option); pub(crate) fn new_pending_onion_message( contents: T, destination: Destination, reply_path: Option @@ -263,6 +282,15 @@ pub trait MessageRouter { fn find_path( &self, sender: PublicKey, peers: Vec, destination: Destination ) -> Result; + + /// Creates [`BlindedPath`]s to the `recipient` node. The nodes in `peers` are assumed to be + /// direct peers with the `recipient`. + fn create_blinded_paths< + ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification + >( + &self, recipient: PublicKey, peers: Vec, entropy_source: &ES, + secp_ctx: &Secp256k1 + ) -> Result, ()>; } /// A [`MessageRouter`] that can only route to a directly connected [`Destination`]. @@ -292,7 +320,9 @@ where ) -> Result { let first_node = destination.first_node(); if peers.contains(&first_node) { - Ok(OnionMessagePath { intermediate_nodes: vec![], destination, addresses: None }) + Ok(OnionMessagePath { + intermediate_nodes: vec![], destination, first_node_addresses: None + }) } else { let network_graph = self.network_graph.deref().read_only(); let node_announcement = network_graph @@ -303,13 +333,56 @@ where match node_announcement { Some(node_announcement) if node_announcement.features.supports_onion_messages() => { - let addresses = Some(node_announcement.addresses.clone()); - Ok(OnionMessagePath { intermediate_nodes: vec![], destination, addresses }) + let first_node_addresses = Some(node_announcement.addresses.clone()); + Ok(OnionMessagePath { + intermediate_nodes: vec![], destination, first_node_addresses + }) }, _ => Err(()), } } } + + fn create_blinded_paths< + ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification + >( + &self, recipient: PublicKey, peers: Vec, entropy_source: &ES, + secp_ctx: &Secp256k1 + ) -> Result, ()> { + // Limit the number of blinded paths that are computed. + const MAX_PATHS: usize = 3; + + // Ensure peers have at least three channels so that it is more difficult to infer the + // recipient's node_id. + const MIN_PEER_CHANNELS: usize = 3; + + let network_graph = self.network_graph.deref().read_only(); + let paths = peers.iter() + // Limit to peers with announced channels + .filter(|pubkey| + network_graph + .node(&NodeId::from_pubkey(pubkey)) + .map(|info| &info.channels[..]) + .map(|channels| channels.len() >= MIN_PEER_CHANNELS) + .unwrap_or(false) + ) + .map(|pubkey| vec![*pubkey, recipient]) + .map(|node_pks| BlindedPath::new_for_message(&node_pks, entropy_source, secp_ctx)) + .take(MAX_PATHS) + .collect::, _>>(); + + match paths { + Ok(paths) if !paths.is_empty() => Ok(paths), + _ => { + if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) { + BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx) + .map(|path| vec![path]) + } else { + Err(()) + } + }, + } + } } /// A path for sending an [`OnionMessage`]. @@ -325,7 +398,7 @@ pub struct OnionMessagePath { /// /// Only needs to be set if a connection to the node is required. [`OnionMessenger`] may use /// this to initiate such a connection. - pub addresses: Option>, + pub first_node_addresses: Option>, } impl OnionMessagePath { @@ -459,7 +532,8 @@ pub enum PeeledOnion { /// Creates an [`OnionMessage`] with the given `contents` for sending to the destination of /// `path`. /// -/// Returns both the node id of the peer to send the message to and the message itself. +/// Returns the node id of the peer to send the message to, the message itself, and any addresses +/// need to connect to the first node. pub fn create_onion_message( entropy_source: &ES, node_signer: &NS, secp_ctx: &Secp256k1, path: OnionMessagePath, contents: T, reply_path: Option, @@ -468,7 +542,7 @@ where ES::Target: EntropySource, NS::Target: NodeSigner, { - let OnionMessagePath { intermediate_nodes, mut destination, addresses } = path; + let OnionMessagePath { intermediate_nodes, mut destination, first_node_addresses } = path; if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination { if blinded_hops.is_empty() { return Err(SendError::TooFewBlindedHops); @@ -510,7 +584,7 @@ where packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?; let message = OnionMessage { blinding_point, onion_routing_packet }; - Ok((first_node_id, message, addresses)) + Ok((first_node_id, message, first_node_addresses)) } /// Decode one layer of an incoming [`OnionMessage`]. @@ -724,7 +798,11 @@ where }, hash_map::Entry::Occupied(mut e) => { e.get_mut().enqueue_message(onion_message); - Ok(SendSuccess::Buffered) + if e.get().is_connected() { + Ok(SendSuccess::Buffered) + } else { + Ok(SendSuccess::BufferedAwaitingConnection(first_node_id)) + } }, } } @@ -898,7 +976,8 @@ where fn peer_disconnected(&self, their_node_id: &PublicKey) { match self.message_recipients.lock().unwrap().remove(their_node_id) { Some(OnionMessageRecipient::ConnectedPeer(..)) => {}, - _ => debug_assert!(false), + Some(_) => debug_assert!(false), + None => {}, } }