Merge pull request #1472 from TheBlueMatt/2022-06-less-secp-ctx

Pull secp256k1 contexts from per-peer to per-PeerManager

diff --combined lightning/src/ln/peer_handler.rs
index 4b777b0b99446e0d4781e6029592b60ee0e24ff7,bfa3a45de903ed31d244846afea17c7afdde7b78..f128f6c5259802466cf99f27496b554d7b88f9ea
--- 1/lightning/src/ln/peer_handler.rs
--- 2/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@@ -15,7 -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::{SecretKey,PublicKey};
+ use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey};
  
  use ln::features::InitFeatures;
  use ln::msgs;
@@@ -258,13 -258,8 +258,13 @@@ pub trait SocketDescriptor : cmp::Eq + 
  /// 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 {
@@@ -455,6 -450,7 +455,7 @@@ pub struct PeerManager<Descriptor: Sock
        peer_counter: AtomicCounter,
  
        logger: L,
+       secp_ctx: Secp256k1<secp256k1::SignOnly>
  }
  
  enum MessageHandlingError {
@@@ -573,6 -569,10 +574,10 @@@ impl<Descriptor: SocketDescriptor, CM: 
                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()),
@@@ -584,6 -584,7 +589,7 @@@
                        peer_counter: AtomicCounter::new(),
                        logger,
                        custom_message_handler,
+                       secp_ctx,
                }
        }
  
@@@ -628,7 -629,7 +634,7 @@@
        /// [`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();
@@@ -675,7 -676,7 +681,7 @@@
        ///
        /// [`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();
@@@ -940,14 -941,16 +946,16 @@@
                                                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;