Introduce ProtocolEncrypt

Author: devrandom

lightning/src/chain/keysinterface.rs

@@ -392,16 +392,33 @@ pub enum Recipient {
 	PhantomNode,
 }
 
+/// A transport and onion encryptor / decryptor that uses the node key
+pub trait ProtocolEncrypt {
+	/// Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
+	///
+	/// This method must return the same value each time it is called with a given `Recipient`
+	/// parameter.
+	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()>;
+}
+
 /// A trait to describe an object which can get user secrets and key material.
 pub trait KeysInterface {
 	/// A type which implements Sign which will be returned by get_channel_signer.
 	type Signer : Sign;
+	/// A type which implements ProtoconCnrypt which will be returned by get_protocol_keys.
+	type ProtocolEncryptor: ProtocolEncrypt;
+
+	/// A protocol encryptor / decryptor that uses the node secret key
+	fn get_protocol_keys(&self) -> Self::ProtocolEncryptor;
 
 	/// Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
 	///
 	/// This method must return the same value each time it is called with a given `Recipient`
 	/// parameter.
-	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()>;
+	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
+		self.get_protocol_keys().get_node_secret(recipient)
+	}
+
 	/// Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	///
 	/// This method should return a different value each time it is called, to avoid linking
@@ -828,6 +845,21 @@ impl ReadableArgs<SecretKey> for InMemorySigner {
 	}
 }
 
+/// A protocol encryptor that keeps the key in memory
+pub struct InMemoryProtocolEncryptor {
+	/// Private key of our node secret, used for signing channel announcements
+	pub node_secret: SecretKey,
+}
+
+impl ProtocolEncrypt for InMemoryProtocolEncryptor {
+	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
+		match recipient {
+			Recipient::Node => Ok(self.node_secret.clone()),
+			Recipient::PhantomNode => Err(())
+		}
+	}
+}
+
 /// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
 /// and derives keys from that.
 ///
@@ -1122,12 +1154,10 @@ impl KeysManager {
 
 impl KeysInterface for KeysManager {
 	type Signer = InMemorySigner;
+	type ProtocolEncryptor = InMemoryProtocolEncryptor;
 
-	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
-		match recipient {
-			Recipient::Node => Ok(self.node_secret.clone()),
-			Recipient::PhantomNode => Err(())
-		}
+	fn get_protocol_keys(&self) -> Self::ProtocolEncryptor {
+		InMemoryProtocolEncryptor { node_secret: self.node_secret }
 	}
 
 	fn get_inbound_payment_key_material(&self) -> KeyMaterial {
@@ -1170,7 +1200,7 @@ impl KeysInterface for KeysManager {
 	fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result<RecoverableSignature, ()> {
 		let preimage = construct_invoice_preimage(&hrp_bytes, &invoice_data);
 		let secret = match recipient {
-			Recipient::Node => self.get_node_secret(Recipient::Node)?,
+			Recipient::Node => self.get_protocol_keys().get_node_secret(Recipient::Node)?,
 			Recipient::PhantomNode => return Err(()),
 		};
 		Ok(self.secp_ctx.sign_recoverable(&hash_to_message!(&Sha256::hash(&preimage)), &secret))
@@ -1204,13 +1234,32 @@ pub struct PhantomKeysManager {
 	phantom_secret: SecretKey,
 }
 
-impl KeysInterface for PhantomKeysManager {
-	type Signer = InMemorySigner;
+/// A protocol encryptor that keeps the key in memory, with phantom node support
+pub struct PhantomProtocolEncryptor {
+	/// Private key of our node secret
+	pub node_secret: SecretKey,
+	/// Private key of our phantom node secret
+	pub phantom_secret: SecretKey,
+}
 
+impl ProtocolEncrypt for PhantomProtocolEncryptor {
 	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
 		match recipient {
-			Recipient::Node => self.inner.get_node_secret(Recipient::Node),
-			Recipient::PhantomNode => Ok(self.phantom_secret.clone()),
+			Recipient::Node => Ok(self.node_secret.clone()),
+			Recipient::PhantomNode => Ok(self.phantom_secret.clone())
+		}
+	}
+}
+
+
+impl KeysInterface for PhantomKeysManager {
+	type Signer = InMemorySigner;
+	type ProtocolEncryptor = PhantomProtocolEncryptor;
+
+	fn get_protocol_keys(&self) -> Self::ProtocolEncryptor {
+		PhantomProtocolEncryptor {
+			node_secret: self.inner.node_secret,
+			phantom_secret: self.phantom_secret,
 		}
 	}
 

lightning/src/ln/channel.rs

@@ -6271,7 +6271,7 @@ mod tests {
 	use ln::chan_utils::{ChannelPublicKeys, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters, htlc_success_tx_weight, htlc_timeout_tx_weight};
 	use chain::BestBlock;
 	use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
-	use chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface, BaseSign};
+	use chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface, BaseSign, InMemoryProtocolEncryptor};
 	use chain::transaction::OutPoint;
 	use util::config::UserConfig;
 	use util::enforcing_trait_impls::EnforcingSigner;
@@ -6318,8 +6318,9 @@ mod tests {
 	}
 	impl KeysInterface for Keys {
 		type Signer = InMemorySigner;
+		type ProtocolEncryptor = InMemoryProtocolEncryptor;
 
-		fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { panic!(); }
+		fn get_protocol_keys(&self) -> Self::ProtocolEncryptor { panic!(); }
 		fn get_inbound_payment_key_material(&self) -> KeyMaterial { panic!(); }
 		fn get_destination_script(&self) -> Script {
 			let secp_ctx = Secp256k1::signing_only();

lightning/src/util/test_utils.rs

@@ -47,7 +47,7 @@ use sync::{Mutex, Arc};
 use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use core::{cmp, mem};
 use bitcoin::bech32::u5;
-use chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial};
+use chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, InMemoryProtocolEncryptor, PhantomProtocolEncryptor};
 
 pub struct TestVecWriter(pub Vec<u8>);
 impl Writer for TestVecWriter {
@@ -70,7 +70,9 @@ pub struct OnlyReadsKeysInterface {}
 impl keysinterface::KeysInterface for OnlyReadsKeysInterface {
 	type Signer = EnforcingSigner;
 
-	fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { unreachable!(); }
+	type ProtocolEncryptor = InMemoryProtocolEncryptor;
+
+	fn get_protocol_keys(&self) -> Self::ProtocolEncryptor { unreachable!(); }
 	fn get_inbound_payment_key_material(&self) -> KeyMaterial { unreachable!(); }
 	fn get_destination_script(&self) -> Script { unreachable!(); }
 	fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!(); }
@@ -485,10 +487,12 @@ pub struct TestKeysInterface {
 
 impl keysinterface::KeysInterface for TestKeysInterface {
 	type Signer = EnforcingSigner;
+	type ProtocolEncryptor = PhantomProtocolEncryptor;
 
-	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
-		self.backing.get_node_secret(recipient)
+	fn get_protocol_keys(&self) -> Self::ProtocolEncryptor {
+		self.backing.get_protocol_keys()
 	}
+
 	fn get_inbound_payment_key_material(&self) -> keysinterface::KeyMaterial {
 		self.backing.get_inbound_payment_key_material()
 	}