Skip to content

Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
jkczyz merged 9 commits into from
Oct 19, 2022
Merged

Support custom onion messages #1748

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
a031ff9
Specify full import path in decode_tlv macro
valentinewallace Oct 7, 2022
a40e32b
ser: Add MaybeReadableArgs trait
valentinewallace Oct 17, 2022
2a8179e
Optionally parameterize decode_tlv_stream with custom decode closure
valentinewallace Oct 17, 2022
75fd0f3
Parameterize OnionMessenger by new CustomOnionMessageHandler trait
valentinewallace Oct 17, 2022
333be69
Tweak OnionMessenger log on inbound onion message receipt
valentinewallace Oct 18, 2022
87b637c
Fix accidental newline in OnionMessenger docs
valentinewallace Oct 18, 2022
ec538d1
Update send_onion_message API to take new OnionMessageContents enum
valentinewallace Oct 18, 2022
7664957
Implement sending and receiving custom onion messages
valentinewallace Oct 18, 2022
4905268
Disallow sending invalid custom OM TLVs
valentinewallace Oct 18, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
58 changes: 46 additions & 12 deletions fuzz/src/onion_message.rs
View file
Open in desktop

Large diffs are not rendered by default.

21 changes: 19 additions & 2 deletions lightning/src/ln/peer_handler.rs
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
InitFeatures::empty()
}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
type CustomMessage = Infallible;
fn handle_custom_message(&self, _msg: Self::CustomMessage) {
// Since we always return `None` in the read the handle method should never be called.
unreachable!();
}
}
impl MaybeReadableArgs<u64> for Infallible {
fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
Ok(None)
}
}

impl CustomOnionMessageContents for Infallible {
fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
type Target = IgnoringMessageHandler;
fn deref(&self) -> &Self { self }
Expand Down
108 changes: 91 additions & 17 deletions lightning/src/onion_message/functional_tests.rs
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
keys_manager: Arc<test_utils::TestKeysInterface>,
messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
fn tlv_type(&self) -> u64 {
CUSTOM_MESSAGE_TYPE
}
}

impl Writeable for TestCustomMessage {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
if message_type == CUSTOM_MESSAGE_TYPE {
let mut buf = Vec::new();
buffer.read_to_end(&mut buf)?;
assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
return Ok(Some(TestCustomMessage {}))
}
Ok(None)
}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
type CustomMessage = TestCustomMessage;
fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
let mut nodes = Vec::new();
for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
nodes.push(MessengerNode {
keys_manager: keys_manager.clone(),
messenger: OnionMessenger::new(keys_manager, logger.clone()),
messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
logger,
});
}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
let nodes = create_nodes(2);
let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
let nodes = create_nodes(3);
let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
let nodes = create_nodes(5);
let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

let secp_ctx = Secp256k1::new();
let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
let nodes = create_nodes(4);
let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

let secp_ctx = Secp256k1::new();
let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
// Make sure we error as expected if a packet is too big to send.
let nodes = create_nodes(2);
let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

let hop_node_id = nodes[1].get_node_pk();
let hops = [hop_node_id; 400];
let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
let nodes = create_nodes(3);
let test_msg = TestCustomMessage {};

// 0 hops
let secp_ctx = Secp256k1::new();
let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
blinded_route.blinded_hops.clear();
let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
assert_eq!(err, SendError::TooFewBlindedHops);

// 1 hop
let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
blinded_route.blinded_hops.remove(0);
assert_eq!(blinded_route.blinded_hops.len(), 1);
let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
let nodes = create_nodes(4);
let test_msg = TestCustomMessage {};
let secp_ctx = Secp256k1::new();

// Destination::Node
let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
pass_along_path(&nodes, None);
// Make sure the last node successfully decoded the reply path.
nodes[3].logger.assert_log_contains(
"lightning::onion_message::messenger".to_string(),
format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

// Destination::BlindedRoute
let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
pass_along_path(&nodes, None);
nodes[3].logger.assert_log_contains(
"lightning::onion_message::messenger".to_string(),
format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
let nodes = create_nodes(2);

struct InvalidCustomMessage{}
impl CustomOnionMessageContents for InvalidCustomMessage {
fn tlv_type(&self) -> u64 {
// Onion message contents must have a TLV >= 64.
63
}
}

impl Writeable for InvalidCustomMessage {
fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
}

impl MaybeReadableArgs<u64> for InvalidCustomMessage {
fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
unreachable!()
}
}

let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
let nodes = create_nodes(2);
let test_msg = TestCustomMessage {};
for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
}
let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
assert_eq!(err, SendError::BufferFull);
}
Loading
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Support custom onion messages by valentinewallace · Pull Request #1748 · lightningdevkit/rust-lightning · GitHub
Skip to content
Support custom onion messages#1748

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

jkczyz
merged 9 commits into

from

Oct 19, 2022
 Merged


Support custom onion messages
#1748
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


9 commits


Select commit
Hold shift + click to select a range
a031ff9

Specify full import path in decode_tlv macro


valentinewallace Oct 7, 2022
a40e32b

ser: Add MaybeReadableArgs trait


valentinewallace Oct 17, 2022
2a8179e

Optionally parameterize decode_tlv_stream with custom decode closure


valentinewallace Oct 17, 2022
75fd0f3

Parameterize OnionMessenger by new CustomOnionMessageHandler trait


valentinewallace Oct 17, 2022
333be69

Tweak OnionMessenger log on inbound onion message receipt


valentinewallace Oct 18, 2022
87b637c

Fix accidental newline in OnionMessenger docs


valentinewallace Oct 18, 2022
ec538d1

Update send_onion_message API to take new OnionMessageContents enum


valentinewallace Oct 18, 2022
7664957

Implement sending and receiving custom onion messages


valentinewallace Oct 18, 2022
4905268

Disallow sending invalid custom OM TLVs


valentinewallace Oct 18, 2022

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


58 changes: 46 additions & 12 deletions
fuzz/src/onion_message.rs

View file


Open in desktop


Large diffs are not rendered by default.


21 changes: 19 additions & 2 deletions
lightning/src/ln/peer_handler.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -21,11 +21,11 @@ use ln::features::{InitFeatures, NodeFeatures};
use ln::msgs;
use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
use util::ser::{VecWriter, Writeable, Writer};
use util::ser::{MaybeReadableArgs, VecWriter, Writeable, Writer};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
use routing::gossip::{NetworkGraph, P2PGossipSync};
use util::atomic_counter::AtomicCounter;
use util::crypto::sign;
Expand DownExpand Up@@ -95,6 +95,23 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 InitFeatures::empty()
	}
}
impl CustomOnionMessageHandler for IgnoringMessageHandler {
	type CustomMessage = Infallible;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {
 // Since we always return `None` in the read the handle method should never be called.
 unreachable!();
	}
}
impl MaybeReadableArgs<u64> for Infallible {
	fn read<R: io::Read>(_buffer: &mut R, _msg_type: u64) -> Result<Option<Self>, msgs::DecodeError> where Self: Sized {
 Ok(None)
	}
}

impl CustomOnionMessageContents for Infallible {
	fn tlv_type(&self) -> u64 { unreachable!(); }
}

impl Deref for IgnoringMessageHandler {
	type Target = IgnoringMessageHandler;
	fn deref(&self) -> &Self { self }
Expand Down

108 changes: 91 additions & 17 deletions
lightning/src/onion_message/functional_tests.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -11,19 +11,21 @@

use chain::keysinterface::{KeysInterface, Recipient};
use ln::features::InitFeatures;
use ln::msgs::{self, OnionMessageHandler};
use super::{BlindedRoute, Destination, OnionMessenger, SendError};
use ln::msgs::{self, DecodeError, OnionMessageHandler};
use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError};
use util::enforcing_trait_impls::EnforcingSigner;
use util::ser::{MaybeReadableArgs, Writeable, Writer};
use util::test_utils;

use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1};

use io;
use sync::Arc;

struct MessengerNode {
	keys_manager: Arc<test_utils::TestKeysInterface>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>>,
	messenger: OnionMessenger<EnforcingSigner, Arc<test_utils::TestKeysInterface>, Arc<test_utils::TestLogger>, Arc<TestCustomMessageHandler>>,
	logger: Arc<test_utils::TestLogger>,
}

Expand All@@ -34,6 +36,43 @@ impl MessengerNode {
	}
}

#[derive(Clone)]
struct TestCustomMessage {}

const CUSTOM_MESSAGE_TYPE: u64 = 4242;
const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];

impl CustomOnionMessageContents for TestCustomMessage {
	fn tlv_type(&self) -> u64 {
 CUSTOM_MESSAGE_TYPE
	}
}

impl Writeable for TestCustomMessage {
	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 Ok(CUSTOM_MESSAGE_CONTENTS.write(w)?)
	}
}

impl MaybeReadableArgs<u64> for TestCustomMessage {
	fn read<R: io::Read>(buffer: &mut R, message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 if message_type == CUSTOM_MESSAGE_TYPE {
 let mut buf = Vec::new();
 buffer.read_to_end(&mut buf)?;
 assert_eq!(buf, CUSTOM_MESSAGE_CONTENTS);
 return Ok(Some(TestCustomMessage {}))
 }
 Ok(None)
	}
}

struct TestCustomMessageHandler {}

impl CustomOnionMessageHandler for TestCustomMessageHandler {
	type CustomMessage = TestCustomMessage;
	fn handle_custom_message(&self, _msg: Self::CustomMessage) {}
}

fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
	let mut nodes = Vec::new();
	for i in 0..num_messengers {
Expand All@@ -42,7 +81,7 @@ fn create_nodes(num_messengers: u8) -> Vec<MessengerNode> {
 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet));
 nodes.push(MessengerNode {
 keys_manager: keys_manager.clone(),
 messenger: OnionMessenger::new(keys_manager, logger.clone()),
 messenger: OnionMessenger::new(keys_manager, logger.clone(), Arc::new(TestCustomMessageHandler {})),
 logger,
 });
	}
Expand DownExpand Up@@ -80,103 +119,138 @@ fn pass_along_path(path: &Vec<MessengerNode>, expected_path_id: Option<[u8; 32]>
#[test]
fn one_hop() {
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_hops() {
	let nodes = create_nodes(3);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk()], Destination::Node(nodes[2].get_node_pk()), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn two_unblinded_two_blinded() {
	let nodes = create_nodes(5);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn three_blinded_hops() {
	let nodes = create_nodes(4);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let secp_ctx = Secp256k1::new();
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap();
	pass_along_path(&nodes, None);
}

#[test]
fn too_big_packet_error() {
	// Make sure we error as expected if a packet is too big to send.
	let nodes = create_nodes(2);
	let test_msg = OnionMessageContents::Custom(TestCustomMessage {});

	let hop_node_id = nodes[1].get_node_pk();
	let hops = [hop_node_id; 400];
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&hops, Destination::Node(hop_node_id), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::TooBigPacket);
}

#[test]
fn invalid_blinded_route_error() {
	// Make sure we error as expected if a provided blinded route has 0 or 1 hops.
	let nodes = create_nodes(3);
	let test_msg = TestCustomMessage {};

	// 0 hops
	let secp_ctx = Secp256k1::new();
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.clear();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);

	// 1 hop
	let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
	blinded_route.blinded_hops.remove(0);
	assert_eq!(blinded_route.blinded_hops.len(), 1);
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::TooFewBlindedHops);
}

#[test]
fn reply_path() {
	let nodes = create_nodes(4);
	let test_msg = TestCustomMessage {};
	let secp_ctx = Secp256k1::new();

	// Destination::Node
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	// Make sure the last node successfully decoded the reply path.
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 1);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 1);

	// Destination::BlindedRoute
	let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
	let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();

	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), Some(reply_path)).unwrap();
	nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
	pass_along_path(&nodes, None);
	nodes[3].logger.assert_log_contains(
 "lightning::onion_message::messenger".to_string(),
 format!("Received an onion message with path_id: None and reply_path").to_string(), 2);
 format!("Received an onion message with path_id None and a reply_path").to_string(), 2);
}

#[test]
fn invalid_custom_message_type() {
	let nodes = create_nodes(2);

	struct InvalidCustomMessage{}
	impl CustomOnionMessageContents for InvalidCustomMessage {
 fn tlv_type(&self) -> u64 {
 // Onion message contents must have a TLV >= 64.
 63
 }
	}

	impl Writeable for InvalidCustomMessage {
 fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
	}

	impl MaybeReadableArgs<u64> for InvalidCustomMessage {
 fn read<R: io::Read>(_buffer: &mut R, _message_type: u64) -> Result<Option<Self>, DecodeError> where Self: Sized {
 unreachable!()
 }
	}

	let test_msg = OnionMessageContents::Custom(InvalidCustomMessage {});
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), test_msg, None).unwrap_err();
	assert_eq!(err, SendError::InvalidMessage);
}

#[test]
fn peer_buffer_full() {
	let nodes = create_nodes(2);
	let test_msg = TestCustomMessage {};
	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap();
 nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), None).unwrap();
	}
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), None).unwrap_err();
	let err = nodes[0].messenger.send_onion_message(&[], Destination::Node(nodes[1].get_node_pk()), OnionMessageContents::Custom(test_msg), None).unwrap_err();
	assert_eq!(err, SendError::BufferFull);
}
Loading