X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=f128f6c5259802466cf99f27496b554d7b88f9ea;hb=3de59cef259935e481d33d75883a257e65be414c;hp=be3b3aeda36085a4d2d53f01294f1214cb2c4ff0;hpb=46009a5f83e539fc103ea164a3c765a7f014f09a;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index be3b3aed..f128f6c5 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -15,7 +15,7 @@
 //! call into the provided message handlers (probably a ChannelManager and NetGraphmsgHandler) with messages
 //! they should handle, and encoding/sending response messages.
 
-use bitcoin::secp256k1::key::{SecretKey,PublicKey};
+use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey};
 
 use ln::features::InitFeatures;
 use ln::msgs;
@@ -258,8 +258,13 @@ pub trait SocketDescriptor : cmp::Eq + hash::Hash + Clone {
 /// descriptor.
 #[derive(Clone)]
 pub struct PeerHandleError {
-	/// Used to indicate that we probably can't make any future connections to this peer, implying
-	/// we should go ahead and force-close any channels we have with it.
+	/// Used to indicate that we probably can't make any future connections to this peer (e.g.
+	/// because we required features that our peer was missing, or vice versa).
+	///
+	/// While LDK's [`ChannelManager`] will not do it automatically, you likely wish to force-close
+	/// any channels with this peer or check for new versions of LDK.
+	///
+	/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	pub no_connection_possible: bool,
 }
 impl fmt::Debug for PeerHandleError {
@@ -450,6 +455,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: De
 	peer_counter: AtomicCounter,
 
 	logger: L,
+	secp_ctx: Secp256k1<secp256k1::SignOnly>
 }
 
 enum MessageHandlingError {
@@ -568,6 +574,10 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
 		let mut ephemeral_key_midstate = Sha256::engine();
 		ephemeral_key_midstate.input(ephemeral_random_data);
 
+		let mut secp_ctx = Secp256k1::signing_only();
+		let ephemeral_hash = Sha256::from_engine(ephemeral_key_midstate.clone()).into_inner();
+		secp_ctx.seeded_randomize(&ephemeral_hash);
+
 		PeerManager {
 			message_handler,
 			peers: FairRwLock::new(HashMap::new()),
@@ -579,6 +589,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
 			peer_counter: AtomicCounter::new(),
 			logger,
 			custom_message_handler,
+			secp_ctx,
 		}
 	}
 
@@ -623,7 +634,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
 	/// [`socket_disconnected()`]: PeerManager::socket_disconnected
 	pub fn new_outbound_connection(&self, their_node_id: PublicKey, descriptor: Descriptor, remote_network_address: Option<NetAddress>) -> Result<Vec<u8>, PeerHandleError> {
 		let mut peer_encryptor = PeerChannelEncryptor::new_outbound(their_node_id.clone(), self.get_ephemeral_key());
-		let res = peer_encryptor.get_act_one().to_vec();
+		let res = peer_encryptor.get_act_one(&self.secp_ctx).to_vec();
 		let pending_read_buffer = [0; 50].to_vec(); // Noise act two is 50 bytes
 
 		let mut peers = self.peers.write().unwrap();
@@ -670,7 +681,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
 	///
 	/// [`socket_disconnected()`]: PeerManager::socket_disconnected
 	pub fn new_inbound_connection(&self, descriptor: Descriptor, remote_network_address: Option<NetAddress>) -> Result<(), PeerHandleError> {
-		let peer_encryptor = PeerChannelEncryptor::new_inbound(&self.our_node_secret);
+		let peer_encryptor = PeerChannelEncryptor::new_inbound(&self.our_node_secret, &self.secp_ctx);
 		let pending_read_buffer = [0; 50].to_vec(); // Noise act one is 50 bytes
 
 		let mut peers = self.peers.write().unwrap();
@@ -935,14 +946,16 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
 						let next_step = peer.channel_encryptor.get_noise_step();
 						match next_step {
 							NextNoiseStep::ActOne => {
-								let act_two = try_potential_handleerror!(peer,
-									peer.channel_encryptor.process_act_one_with_keys(&peer.pending_read_buffer[..], &self.our_node_secret, self.get_ephemeral_key())).to_vec();
+								let act_two = try_potential_handleerror!(peer, peer.channel_encryptor
+									.process_act_one_with_keys(&peer.pending_read_buffer[..],
+										&self.our_node_secret, self.get_ephemeral_key(), &self.secp_ctx)).to_vec();
 								peer.pending_outbound_buffer.push_back(act_two);
 								peer.pending_read_buffer = [0; 66].to_vec(); // act three is 66 bytes long
 							},
 							NextNoiseStep::ActTwo => {
 								let (act_three, their_node_id) = try_potential_handleerror!(peer,
-									peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..], &self.our_node_secret));
+									peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..],
+										&self.our_node_secret, &self.secp_ctx));
 								peer.pending_outbound_buffer.push_back(act_three.to_vec());
 								peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes
 								peer.pending_read_is_header = true;
@@ -1839,7 +1852,7 @@ mod tests {
 	use util::test_utils;
 
 	use bitcoin::secp256k1::Secp256k1;
-	use bitcoin::secp256k1::key::{SecretKey, PublicKey};
+	use bitcoin::secp256k1::{SecretKey, PublicKey};
 
 	use prelude::*;
 	use sync::{Arc, Mutex};