X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Fmessenger.rs;h=7487caf45c750cb428e0937c1dfe9192dfb3b8ac;hb=f2b315e9c9e9d77ef5abb5068d6e8e37f24bc419;hp=b884c2ffebd9f90abdbb6051e83e5c802aad4f8a;hpb=2f0ddf0763767fbdd22dafbe4574228c6be88b1e;p=rust-lightning diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs index b884c2ff..7487caf4 100644 --- a/lightning/src/onion_message/messenger.rs +++ b/lightning/src/onion_message/messenger.rs @@ -15,13 +15,13 @@ use bitcoin::hashes::hmac::{Hmac, HmacEngine}; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::secp256k1::{self, PublicKey, Scalar, Secp256k1, SecretKey}; -use crate::chain::keysinterface::{KeysInterface, KeysManager, Recipient}; +use crate::chain::keysinterface::{EntropySource, KeysManager, NodeSigner, Recipient}; use crate::ln::features::{InitFeatures, NodeFeatures}; use crate::ln::msgs::{self, OnionMessageHandler}; use crate::ln::onion_utils; use crate::ln::peer_handler::IgnoringMessageHandler; -use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs}; -pub use super::packet::{CustomOnionMessageContents, OnionMessageContents}; +use super::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs}; +use super::packet::{CustomOnionMessageContents, OnionMessageContents}; use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload, ReceiveControlTlvs, SMALL_PACKET_HOP_DATA_LEN}; use super::utils; use crate::util::events::OnionMessageProvider; @@ -43,15 +43,16 @@ use crate::prelude::*; /// # extern crate bitcoin; /// # use bitcoin::hashes::_export::_core::time::Duration; /// # use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; -/// # use lightning::chain::keysinterface::{InMemorySigner, KeysManager, KeysInterface}; -/// # use lightning::ln::msgs::DecodeError; +/// # use lightning::chain::keysinterface::KeysManager; /// # use lightning::ln::peer_handler::IgnoringMessageHandler; -/// # use lightning::onion_message::{BlindedRoute, CustomOnionMessageContents, Destination, OnionMessageContents, OnionMessenger}; +/// # use lightning::onion_message::blinded_path::BlindedPath; +/// # use lightning::onion_message::messenger::{Destination, OnionMessenger}; +/// # use lightning::onion_message::packet::{CustomOnionMessageContents, OnionMessageContents}; /// # use lightning::util::logger::{Logger, Record}; /// # use lightning::util::ser::{Writeable, Writer}; /// # use lightning::io; /// # use std::sync::Arc; -/// # struct FakeLogger {}; +/// # struct FakeLogger; /// # impl Logger for FakeLogger { /// # fn log(&self, record: &Record) { unimplemented!() } /// # } @@ -67,7 +68,7 @@ use crate::prelude::*; /// # let your_custom_message_handler = IgnoringMessageHandler {}; /// // Create the onion messenger. This must use the same `keys_manager` as is passed to your /// // ChannelManager. -/// let onion_messenger = OnionMessenger::new(&keys_manager, logger, your_custom_message_handler); +/// let onion_messenger = OnionMessenger::new(&keys_manager, &keys_manager, logger, &your_custom_message_handler); /// /// # struct YourCustomMessage {} /// impl Writeable for YourCustomMessage { @@ -89,27 +90,29 @@ use crate::prelude::*; /// let message = OnionMessageContents::Custom(your_custom_message); /// onion_messenger.send_onion_message(&intermediate_hops, Destination::Node(destination_node_id), message, reply_path); /// -/// // Create a blinded route to yourself, for someone to send an onion message to. +/// // Create a blinded path to yourself, for someone to send an onion message to. /// # let your_node_id = hop_node_id1; /// let hops = [hop_node_id3, hop_node_id4, your_node_id]; -/// let blinded_route = BlindedRoute::new(&hops, &keys_manager, &secp_ctx).unwrap(); +/// let blinded_path = BlindedPath::new(&hops, &keys_manager, &secp_ctx).unwrap(); /// -/// // Send a custom onion message to a blinded route. +/// // Send a custom onion message to a blinded path. /// # let intermediate_hops = [hop_node_id1, hop_node_id2]; /// let reply_path = None; /// # let your_custom_message = YourCustomMessage {}; /// let message = OnionMessageContents::Custom(your_custom_message); -/// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedRoute(blinded_route), message, reply_path); +/// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedPath(blinded_path), message, reply_path); /// ``` /// /// [offers]: /// [`OnionMessenger`]: crate::onion_message::OnionMessenger -pub struct OnionMessenger - where K::Target: KeysInterface, - L::Target: Logger, - CMH:: Target: CustomOnionMessageHandler, +pub struct OnionMessenger + where ES::Target: EntropySource, + NS::Target: NodeSigner, + L::Target: Logger, + CMH:: Target: CustomOnionMessageHandler, { - keys_manager: K, + entropy_source: ES, + node_signer: NS, logger: L, pending_messages: Mutex>>, secp_ctx: Secp256k1, @@ -122,15 +125,15 @@ pub struct OnionMessenger pub enum Destination { /// We're sending this onion message to a node. Node(PublicKey), - /// We're sending this onion message to a blinded route. - BlindedRoute(BlindedRoute), + /// We're sending this onion message to a blinded path. + BlindedPath(BlindedPath), } impl Destination { pub(super) fn num_hops(&self) -> usize { match self { Destination::Node(_) => 1, - Destination::BlindedRoute(BlindedRoute { blinded_hops, .. }) => blinded_hops.len(), + Destination::BlindedPath(BlindedPath { blinded_hops, .. }) => blinded_hops.len(), } } } @@ -145,7 +148,7 @@ pub enum SendError { /// Because implementations such as Eclair will drop onion messages where the message packet /// exceeds 32834 bytes, we refuse to send messages where the packet exceeds this size. TooBigPacket, - /// The provided [`Destination`] was an invalid [`BlindedRoute`], due to having fewer than two + /// The provided [`Destination`] was an invalid [`BlindedPath`], due to having fewer than two /// blinded hops. TooFewBlindedHops, /// Our next-hop peer was offline or does not support onion message forwarding. @@ -154,15 +157,15 @@ pub enum SendError { InvalidMessage, /// Our next-hop peer's buffer was full or our total outbound buffer was full. BufferFull, - /// Failed to retrieve our node id from the provided [`KeysInterface`]. + /// Failed to retrieve our node id from the provided [`NodeSigner`]. /// - /// [`KeysInterface`]: crate::chain::keysinterface::KeysInterface + /// [`NodeSigner`]: crate::chain::keysinterface::NodeSigner GetNodeIdFailed, - /// We attempted to send to a blinded route where we are the introduction node, and failed to - /// advance the blinded route to make the second hop the new introduction node. Either - /// [`KeysInterface::ecdh`] failed, we failed to tweak the current blinding point to get the + /// We attempted to send to a blinded path where we are the introduction node, and failed to + /// advance the blinded path to make the second hop the new introduction node. Either + /// [`NodeSigner::ecdh`] failed, we failed to tweak the current blinding point to get the /// new blinding point, or we were attempting to send to ourselves. - BlindedRouteAdvanceFailed, + BlindedPathAdvanceFailed, } /// Handler for custom onion messages. If you are using [`SimpleArcOnionMessenger`], @@ -186,18 +189,20 @@ pub trait CustomOnionMessageHandler { fn read_custom_message(&self, message_type: u64, buffer: &mut R) -> Result, msgs::DecodeError>; } -impl OnionMessenger - where K::Target: KeysInterface, - L::Target: Logger, - CMH::Target: CustomOnionMessageHandler, +impl OnionMessenger + where ES::Target: EntropySource, + NS::Target: NodeSigner, + L::Target: Logger, + CMH::Target: CustomOnionMessageHandler, { /// Constructs a new `OnionMessenger` to send, forward, and delegate received onion messages to /// their respective handlers. - pub fn new(keys_manager: K, logger: L, custom_handler: CMH) -> Self { + pub fn new(entropy_source: ES, node_signer: NS, logger: L, custom_handler: CMH) -> Self { let mut secp_ctx = Secp256k1::new(); - secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes()); + secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes()); OnionMessenger { - keys_manager, + entropy_source, + node_signer, pending_messages: Mutex::new(HashMap::new()), secp_ctx, logger, @@ -207,8 +212,8 @@ impl OnionMessenger /// Send an onion message with contents `message` to `destination`, routing it through `intermediate_nodes`. /// See [`OnionMessenger`] for example usage. - pub fn send_onion_message(&self, intermediate_nodes: &[PublicKey], mut destination: Destination, message: OnionMessageContents, reply_path: Option) -> Result<(), SendError> { - if let Destination::BlindedRoute(BlindedRoute { ref blinded_hops, .. }) = destination { + pub fn send_onion_message(&self, intermediate_nodes: &[PublicKey], mut destination: Destination, message: OnionMessageContents, reply_path: Option) -> Result<(), SendError> { + if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination { if blinded_hops.len() < 2 { return Err(SendError::TooFewBlindedHops); } @@ -216,27 +221,27 @@ impl OnionMessenger let OnionMessageContents::Custom(ref msg) = message; if msg.tlv_type() < 64 { return Err(SendError::InvalidMessage) } - // If we are sending straight to a blinded route and we are the introduction node, we need to - // advance the blinded route by 1 hop so the second hop is the new introduction node. + // If we are sending straight to a blinded path and we are the introduction node, we need to + // advance the blinded path by 1 hop so the second hop is the new introduction node. if intermediate_nodes.len() == 0 { - if let Destination::BlindedRoute(ref mut blinded_route) = destination { - let our_node_id = self.keys_manager.get_node_id(Recipient::Node) + if let Destination::BlindedPath(ref mut blinded_path) = destination { + let our_node_id = self.node_signer.get_node_id(Recipient::Node) .map_err(|()| SendError::GetNodeIdFailed)?; - if blinded_route.introduction_node_id == our_node_id { - blinded_route.advance_by_one(&self.keys_manager, &self.secp_ctx) - .map_err(|()| SendError::BlindedRouteAdvanceFailed)?; + if blinded_path.introduction_node_id == our_node_id { + blinded_path.advance_by_one(&self.node_signer, &self.secp_ctx) + .map_err(|()| SendError::BlindedPathAdvanceFailed)?; } } } - let blinding_secret_bytes = self.keys_manager.get_secure_random_bytes(); + let blinding_secret_bytes = self.entropy_source.get_secure_random_bytes(); let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted"); let (introduction_node_id, blinding_point) = if intermediate_nodes.len() != 0 { (intermediate_nodes[0], PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret)) } else { match destination { Destination::Node(pk) => (pk, PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret)), - Destination::BlindedRoute(BlindedRoute { introduction_node_id, blinding_point, .. }) => + Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) => (introduction_node_id, blinding_point), } }; @@ -244,7 +249,7 @@ impl OnionMessenger &self.secp_ctx, intermediate_nodes, destination, message, reply_path, &blinding_secret) .map_err(|e| SendError::Secp256k1(e))?; - let prng_seed = self.keys_manager.get_secure_random_bytes(); + let prng_seed = self.entropy_source.get_secure_random_bytes(); let onion_routing_packet = construct_onion_message_packet( packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?; @@ -295,16 +300,17 @@ fn outbound_buffer_full(peer_node_id: &PublicKey, buffer: &HashMap OnionMessageHandler for OnionMessenger - where K::Target: KeysInterface, - L::Target: Logger, - CMH::Target: CustomOnionMessageHandler + Sized, +impl OnionMessageHandler for OnionMessenger + where ES::Target: EntropySource, + NS::Target: NodeSigner, + L::Target: Logger, + CMH::Target: CustomOnionMessageHandler + Sized, { /// Handle an incoming onion message. Currently, if a message was destined for us we will log, but /// soon we'll delegate the onion message to a handler that can generate invoices or send /// payments. fn handle_onion_message(&self, _peer_node_id: &PublicKey, msg: &msgs::OnionMessage) { - let control_tlvs_ss = match self.keys_manager.ecdh(Recipient::Node, &msg.blinding_point, None) { + let control_tlvs_ss = match self.node_signer.ecdh(Recipient::Node, &msg.blinding_point, None) { Ok(ss) => ss, Err(e) => { log_error!(self.logger, "Failed to retrieve node secret: {:?}", e); @@ -317,7 +323,7 @@ impl OnionMessageHandler for OnionMessenger ss.secret_bytes(), @@ -346,7 +352,7 @@ impl OnionMessageHandler for OnionMessenger pk, @@ -413,7 +419,7 @@ impl OnionMessageHandler for OnionMessenger Result<(), ()> { + fn peer_connected(&self, their_node_id: &PublicKey, init: &msgs::Init, _inbound: bool) -> Result<(), ()> { if init.features.supports_onion_messages() { let mut peers = self.pending_messages.lock().unwrap(); peers.insert(their_node_id.clone(), VecDeque::new()); @@ -421,7 +427,7 @@ impl OnionMessageHandler for OnionMessenger OnionMessageHandler for OnionMessenger OnionMessageProvider for OnionMessenger - where K::Target: KeysInterface, - L::Target: Logger, - CMH::Target: CustomOnionMessageHandler, +impl OnionMessageProvider for OnionMessenger + where ES::Target: EntropySource, + NS::Target: NodeSigner, + L::Target: Logger, + CMH::Target: CustomOnionMessageHandler, { fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option { let mut pending_msgs = self.pending_messages.lock().unwrap(); @@ -462,7 +469,7 @@ impl OnionMessageProvider for OnionMessenger = OnionMessenger, Arc, IgnoringMessageHandler>; +pub type SimpleArcOnionMessenger = OnionMessenger, Arc, Arc, IgnoringMessageHandler>; /// Useful for simplifying the parameters of [`SimpleRefChannelManager`] and /// [`SimpleRefPeerManager`]. See their docs for more details. /// @@ -470,19 +477,19 @@ pub type SimpleArcOnionMessenger = OnionMessenger, Arc, I /// /// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager /// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager -pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<&'a KeysManager, &'b L, IgnoringMessageHandler>; +pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<&'a KeysManager, &'a KeysManager, &'b L, IgnoringMessageHandler>; /// Construct onion packet payloads and keys for sending an onion message along the given /// `unblinded_path` to the given `destination`. fn packet_payloads_and_keys( secp_ctx: &Secp256k1, unblinded_path: &[PublicKey], destination: Destination, - message: OnionMessageContents, mut reply_path: Option, session_priv: &SecretKey + message: OnionMessageContents, mut reply_path: Option, session_priv: &SecretKey ) -> Result<(Vec<(Payload, [u8; 32])>, Vec), secp256k1::Error> { let num_hops = unblinded_path.len() + destination.num_hops(); let mut payloads = Vec::with_capacity(num_hops); let mut onion_packet_keys = Vec::with_capacity(num_hops); - let (mut intro_node_id_blinding_pt, num_blinded_hops) = if let Destination::BlindedRoute(BlindedRoute { + let (mut intro_node_id_blinding_pt, num_blinded_hops) = if let Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, blinded_hops }) = &destination { (Some((*introduction_node_id, *blinding_point)), blinded_hops.len()) } else { (None, 0) }; let num_unblinded_hops = num_hops - num_blinded_hops;