Skip to content

Commit 5578d79

Browse files
ViktorTigerstromViktorTigerstrom
committed
Add handle unkown peer test
1 parent 8c175f5 commit 5578d79

File tree

1 file changed

+229
-2
lines changed

1 file changed

+229
-2
lines changed

‎lightning/src/ln/channelmanager.rs

Lines changed: 229 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7478,17 +7478,24 @@ where
74787478
mod tests {
74797479
use bitcoin::hashes::Hash;
74807480
use bitcoin::hashes::sha256::Hash as Sha256;
7481+
use bitcoin::hashes::hex::FromHex;
7482+
use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
7483+
use bitcoin::secp256k1::ecdsa::Signature;
7484+
use bitcoin::secp256k1::ffi::Signature as FFISignature;
7485+
use bitcoin::blockdata::script::Script;
7486+
use bitcoin::Txid;
74817487
use core::time::Duration;
74827488
use core::sync::atomic::Ordering;
74837489
use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
7484-
use crate::ln::channelmanager::{self, inbound_payment, PaymentId, PaymentSendFailure};
7490+
use crate::ln::channelmanager::{self, inbound_payment, PaymentId, PaymentSendFailure, InterceptId};
74857491
use crate::ln::functional_test_utils::*;
74867492
use crate::ln::msgs;
7487-
use crate::ln::msgs::ChannelMessageHandler;
7493+
use crate::ln::msgs::{ChannelMessageHandler, OptionalField};
74887494
use crate::routing::router::{PaymentParameters, RouteParameters, find_route};
74897495
use crate::util::errors::APIError;
74907496
use crate::util::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, ClosureReason};
74917497
use crate::util::test_utils;
7498+
use crate::util::config::ChannelConfig;
74927499
use crate::chain::keysinterface::{EntropySource, KeysInterface};
74937500

74947501
#[test]
@@ -8049,6 +8056,226 @@ mod tests {
80498056
check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
80508057
check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
80518058
}
8059+
8060+
fn check_unkown_peer_msg_event<'a, 'b: 'a, 'c: 'b>(node: &Node<'a, 'b, 'c>, closing_node_id: PublicKey, closed_channel_id: [u8; 32]){
8061+
let close_msg_ev = node.node.get_and_clear_pending_msg_events();
8062+
let expected_error_str = format!("Can't find a peer matching the passed counterparty node_id {}", closing_node_id);
8063+
match close_msg_ev[0] {
8064+
MessageSendEvent::HandleError {
8065+
ref node_id, action: msgs::ErrorAction::SendErrorMessage {
8066+
msg: msgs::ErrorMessage { ref channel_id, ref data }
8067+
}
8068+
} => {
8069+
assert_eq!(*node_id, closing_node_id);
8070+
assert_eq!(*data, expected_error_str);
8071+
assert_eq!(*channel_id, closed_channel_id);
8072+
}
8073+
_ => panic!("Unexpected event"),
8074+
}
8075+
}
8076+
8077+
fn check_not_connected_to_peer_error<T>(res_err: Result<T, APIError>, expected_public_key: PublicKey) {
8078+
let expected_message = format!("Not connected to node: {}", expected_public_key);
8079+
check_api_misuse_error_message(expected_message, res_err)
8080+
}
8081+
8082+
fn check_unkown_peer_error<T>(res_err: Result<T, APIError>, expected_public_key: PublicKey) {
8083+
let expected_message = format!("Can't find a peer matching the passed counterparty node_id {}", expected_public_key);
8084+
check_api_misuse_error_message(expected_message, res_err)
8085+
}
8086+
8087+
fn check_api_misuse_error_message<T>(expected_err_message: String, res_err: Result<T, APIError>) {
8088+
match res_err {
8089+
Err(APIError::APIMisuseError { err }) => {
8090+
assert_eq!(err, expected_err_message);
8091+
},
8092+
Ok(_) => panic!("Unexpected Ok"),
8093+
Err(_) => panic!("Unexpected Error"),
8094+
}
8095+
}
8096+
8097+
#[test]
8098+
fn test_api_calls_with_unkown_counterparty_node() {
8099+
// Tests that our API functions and message handlers that expects a `counterparty_node_id`
8100+
// as input, behaves as expected if the `counterparty_node_id` is an unkown peer in the
8101+
// `ChannelManager::per_peer_state` map.
8102+
let chanmon_cfg = create_chanmon_cfgs(2);
8103+
let node_cfg = create_node_cfgs(2, &chanmon_cfg);
8104+
let node_chanmgr = create_node_chanmgrs(2, &node_cfg, &[None, None]);
8105+
let nodes = create_network(2, &node_cfg, &node_chanmgr);
8106+
8107+
// Boilerplate code to produce `open_channel` and `accept_channel` msgs more densly than
8108+
// creating dummy ones.
8109+
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 500_000_000, 42, None).unwrap();
8110+
let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8111+
nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), channelmanager::provided_init_features(), &open_channel_msg);
8112+
let accept_channel_msg = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
8113+
8114+
// Dummy values
8115+
let channel_id = [4; 32];
8116+
let signature = Signature::from(unsafe { FFISignature::new() });
8117+
let unkown_public_key = PublicKey::from_secret_key(&Secp256k1::signing_only(), &SecretKey::from_slice(&[42; 32]).unwrap());
8118+
let intercept_id = InterceptId([0; 32]);
8119+
8120+
// Dummy msgs
8121+
let funding_created_msg = msgs::FundingCreated {
8122+
temporary_channel_id: open_channel_msg.temporary_channel_id,
8123+
funding_txid: Txid::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap(),
8124+
funding_output_index: 0,
8125+
signature: signature,
8126+
};
8127+
8128+
let funding_signed_msg = msgs::FundingSigned {
8129+
channel_id: channel_id,
8130+
signature: signature,
8131+
};
8132+
8133+
let channel_ready_msg = msgs::ChannelReady {
8134+
channel_id: channel_id,
8135+
next_per_commitment_point: unkown_public_key,
8136+
short_channel_id_alias: None,
8137+
};
8138+
8139+
let announcement_signatures_msg = msgs::AnnouncementSignatures {
8140+
channel_id: channel_id,
8141+
short_channel_id: 0,
8142+
node_signature: signature,
8143+
bitcoin_signature: signature,
8144+
};
8145+
8146+
let channel_reestablish_msg = msgs::ChannelReestablish {
8147+
channel_id: channel_id,
8148+
next_local_commitment_number: 0,
8149+
next_remote_commitment_number: 0,
8150+
data_loss_protect: OptionalField::Absent,
8151+
};
8152+
8153+
let closing_signed_msg = msgs::ClosingSigned {
8154+
channel_id: channel_id,
8155+
fee_satoshis: 1000,
8156+
signature: signature,
8157+
fee_range: None,
8158+
};
8159+
8160+
let shutdown_msg = msgs::Shutdown {
8161+
channel_id: channel_id,
8162+
scriptpubkey: Script::new(),
8163+
};
8164+
8165+
let onion_routing_packet = msgs::OnionPacket {
8166+
version: 255,
8167+
public_key: Ok(unkown_public_key),
8168+
hop_data: [1; 20*65],
8169+
hmac: [2; 32]
8170+
};
8171+
8172+
let update_add_htlc_msg = msgs::UpdateAddHTLC {
8173+
channel_id: channel_id,
8174+
htlc_id: 0,
8175+
amount_msat: 1000000,
8176+
payment_hash: PaymentHash([1; 32]),
8177+
cltv_expiry: 821716,
8178+
onion_routing_packet
8179+
};
8180+
8181+
let commitment_signed_msg = msgs::CommitmentSigned {
8182+
channel_id: channel_id,
8183+
signature: signature,
8184+
htlc_signatures: Vec::new(),
8185+
};
8186+
8187+
let update_fee_msg = msgs::UpdateFee {
8188+
channel_id: channel_id,
8189+
feerate_per_kw: 1000,
8190+
};
8191+
8192+
let malformed_update_msg = msgs::UpdateFailMalformedHTLC{
8193+
channel_id: channel_id,
8194+
htlc_id: 0,
8195+
sha256_of_onion: [1; 32],
8196+
failure_code: 0x8000,
8197+
};
8198+
8199+
let fulfill_update_msg = msgs::UpdateFulfillHTLC{
8200+
channel_id: channel_id,
8201+
htlc_id: 0,
8202+
payment_preimage: PaymentPreimage([1; 32]),
8203+
};
8204+
8205+
let fail_update_msg = msgs::UpdateFailHTLC{
8206+
channel_id: channel_id,
8207+
htlc_id: 0,
8208+
reason: msgs::OnionErrorPacket { data: Vec::new()},
8209+
};
8210+
8211+
let revoke_and_ack_msg = msgs::RevokeAndACK {
8212+
channel_id: channel_id,
8213+
per_commitment_secret: [1; 32],
8214+
next_per_commitment_point: unkown_public_key,
8215+
};
8216+
8217+
// Test the API functions and message handlers.
8218+
check_not_connected_to_peer_error(nodes[0].node.create_channel(unkown_public_key, 1_000_000, 500_000_000, 42, None), unkown_public_key);
8219+
8220+
nodes[1].node.handle_open_channel(&unkown_public_key, channelmanager::provided_init_features(), &open_channel_msg);
8221+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, open_channel_msg.temporary_channel_id);
8222+
8223+
nodes[0].node.handle_accept_channel(&unkown_public_key, channelmanager::provided_init_features(), &accept_channel_msg);
8224+
check_unkown_peer_msg_event(&nodes[0], unkown_public_key, open_channel_msg.temporary_channel_id);
8225+
8226+
check_unkown_peer_error(nodes[0].node.accept_inbound_channel(&open_channel_msg.temporary_channel_id, &unkown_public_key, 42), unkown_public_key);
8227+
nodes[1].node.handle_funding_created(&unkown_public_key, &funding_created_msg);
8228+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, open_channel_msg.temporary_channel_id);
8229+
8230+
nodes[0].node.handle_funding_signed(&unkown_public_key, &funding_signed_msg);
8231+
check_unkown_peer_msg_event(&nodes[0], unkown_public_key, channel_id);
8232+
8233+
nodes[0].node.handle_channel_ready(&unkown_public_key, &channel_ready_msg);
8234+
check_unkown_peer_msg_event(&nodes[0], unkown_public_key, channel_id);
8235+
8236+
nodes[1].node.handle_announcement_signatures(&unkown_public_key, &announcement_signatures_msg);
8237+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8238+
8239+
check_unkown_peer_error(nodes[0].node.close_channel(&channel_id, &unkown_public_key), unkown_public_key);
8240+
8241+
check_unkown_peer_error(nodes[0].node.force_close_broadcasting_latest_txn(&channel_id, &unkown_public_key), unkown_public_key);
8242+
8243+
check_unkown_peer_error(nodes[0].node.force_close_without_broadcasting_txn(&channel_id, &unkown_public_key), unkown_public_key);
8244+
8245+
check_unkown_peer_error(nodes[0].node.forward_intercepted_htlc(intercept_id, &channel_id, unkown_public_key, 1_000_000), unkown_public_key);
8246+
8247+
check_unkown_peer_error(nodes[0].node.update_channel_config(&unkown_public_key, &[channel_id], &ChannelConfig::default()), unkown_public_key);
8248+
8249+
nodes[0].node.handle_shutdown(&unkown_public_key, &channelmanager::provided_init_features(), &shutdown_msg);
8250+
check_unkown_peer_msg_event(&nodes[0], unkown_public_key, channel_id);
8251+
8252+
nodes[1].node.handle_closing_signed(&unkown_public_key, &closing_signed_msg);
8253+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8254+
8255+
nodes[0].node.handle_channel_reestablish(&unkown_public_key, &channel_reestablish_msg);
8256+
check_unkown_peer_msg_event(&nodes[0], unkown_public_key, channel_id);
8257+
8258+
nodes[1].node.handle_update_add_htlc(&unkown_public_key, &update_add_htlc_msg);
8259+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8260+
8261+
nodes[1].node.handle_commitment_signed(&unkown_public_key, &commitment_signed_msg);
8262+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8263+
8264+
nodes[1].node.handle_update_fail_malformed_htlc(&unkown_public_key, &malformed_update_msg);
8265+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8266+
8267+
nodes[1].node.handle_update_fail_htlc(&unkown_public_key, &fail_update_msg);
8268+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8269+
8270+
nodes[1].node.handle_update_fulfill_htlc(&unkown_public_key, &fulfill_update_msg);
8271+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8272+
8273+
nodes[1].node.handle_revoke_and_ack(&unkown_public_key, &revoke_and_ack_msg);
8274+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8275+
8276+
nodes[1].node.handle_update_fee(&unkown_public_key, &update_fee_msg);
8277+
check_unkown_peer_msg_event(&nodes[1], unkown_public_key, channel_id);
8278+
}
80528279
}
80538280

80548281
#[cfg(all(any(test, feature = "_test_utils"), feature = "_bench_unstable"))]

0 commit comments

Comments
 (0)