fixup: Add OurPeerStorage for serialized Peer Storage backups

Author: adi2011

lightning/src/ln/our_peer_storage.rs

@@ -7,20 +7,13 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-//! `OurPeerStorage` enables versioned and timestamped storage of serialized channel data.
+//! `OurPeerStorage` enables versioned storage of serialized channel data.
 //! It supports encryption and decryption to maintain data integrity and security during
 //! transmission.
 
 use crate::crypto::chacha20poly1305rfc::ChaCha20Poly1305RFC;
-
-use crate::util::ser::{Readable, VecWriter, Writeable, Writer};
-
-use crate::io::{self, Error};
-use crate::ln::msgs::DecodeError;
 use crate::prelude::*;
 
-use bitcoin::secp256k1::SecretKey;
-
 /// [`OurPeerStorage`] is used to store channel information that allows for the creation of a
 /// `peer_storage` backup. It includes versioning and timestamping for comparison between
 /// instances of [`OurPeerStorage`].
@@ -30,8 +23,7 @@ use bitcoin::secp256k1::SecretKey;
 ///
 /// # Key Methods
 /// - `create_from_data`: Returns an encrypted [`OurPeerStorage`] instance created from the provided data.
-/// - `get_ser_channels`: Retrieves the serialized channel data.
-/// - `decrypt_our_peer_storage`: Decrypts the ciphertext using the key and returns [`OurPeerStorage`] populated with data.
+/// - `decrypt_our_peer_storage`: Decrypts the [`OurPeerStorage::encrypted_data`] using the key and returns decrypted data.
 ///
 /// # Usage
 /// This structure can be used for securely managing and exchanging peer storage backups. It
@@ -47,14 +39,16 @@ use bitcoin::secp256k1::SecretKey;
 /// ```
 #[derive(PartialEq)]
 pub struct OurPeerStorage {
-	version: u8,
-	ser_channels: Vec<u8>,
+	encrypted_data: Vec<u8>,
 }
 
 impl OurPeerStorage {
-	/// Get `ser_channels` field from [`OurPeerStorage`]
-	pub fn get_ser_channels(&self) -> Vec<u8> {
-		self.ser_channels.clone()
+	pub fn new(encrypted_data: Vec<u8>) -> Self {
+		Self { encrypted_data }
+	}
+
+	pub fn encrypted_data(&self) -> Vec<u8> {
+		self.encrypted_data.clone()
 	}
 
 	/// Creates a serialised representation of [`OurPeerStorage`] from the given `ser_channels` data.
@@ -63,31 +57,28 @@ impl OurPeerStorage {
 	/// (serialised channel information), and returns a serialised [`OurPeerStorage`] as a `Vec<u8>`.
 	///
 	/// The resulting serialised data is intended to be directly used for transmission to the peers.
-	pub fn create_from_data(key: SecretKey, ser_channels: Vec<u8>) -> Vec<u8> {
-		let our_peer_storage = Self { version: 1, ser_channels };
-
+	pub fn create_from_data(key: [u8; 32], ser_channels: Vec<u8>) -> OurPeerStorage {
 		let n = 0u64;
-		let mut peer_storage = VecWriter(Vec::new());
-		our_peer_storage.write(&mut peer_storage).unwrap();
-		let mut res = vec![0; peer_storage.0.len() + 16];
 
-		let plaintext = &peer_storage.0[..];
+		let mut res = vec![0; ser_channels.len() + 16];
+
+		let plaintext = &ser_channels[..];
 		let mut nonce = [0; 12];
 		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
 
-		let mut chacha = ChaCha20Poly1305RFC::new(&key.secret_bytes(), &nonce, b"");
+		let mut chacha = ChaCha20Poly1305RFC::new(&key, &nonce, b"");
 		let mut tag = [0; 16];
 		chacha.encrypt(plaintext, &mut res[0..plaintext.len()], &mut tag);
 		res[plaintext.len()..].copy_from_slice(&tag);
-		res
+
+		Self { encrypted_data: res }
 	}
 
 	/// Decrypt `OurPeerStorage` using the `key`, result is stored inside the `res`.
 	/// Returns an error if the the `cyphertext` is not correct.
-	pub fn decrypt_our_peer_storage(
-		cyphertext: &[u8], key: SecretKey,
-	) -> Result<OurPeerStorage, ()> {
+	pub fn decrypt_our_peer_storage(&self, key: [u8; 32]) -> Result<Vec<u8>, ()> {
 		const MIN_CYPHERTEXT_LEN: usize = 16;
+		let cyphertext = &self.encrypted_data[..];
 
 		let mut res = vec![0; cyphertext.len() - 16];
 		// Ensure the cyphertext is at least as large as the MIN_CYPHERTEXT_LEN.
@@ -99,7 +90,7 @@ impl OurPeerStorage {
 		let mut nonce = [0; 12];
 		nonce[4..].copy_from_slice(&n.to_le_bytes()[..]);
 
-		let mut chacha = ChaCha20Poly1305RFC::new(&key.secret_bytes(), &nonce, b"");
+		let mut chacha = ChaCha20Poly1305RFC::new(&key, &nonce, b"");
 		if chacha
 			.variable_time_decrypt(
 				&cyphertext[0..cyphertext.len() - 16],
@@ -110,27 +101,7 @@ impl OurPeerStorage {
 		{
 			return Err(());
 		}
-		let our_peer_storage =
-			<OurPeerStorage as Readable>::read(&mut ::bitcoin::io::Cursor::new(res)).unwrap();
-
-		Ok(our_peer_storage)
-	}
-}
-
-impl Writeable for OurPeerStorage {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-		write_ver_prefix!(writer, self.version, 1);
-		self.ser_channels.write(writer)?;
-		Ok(())
-	}
-}
-
-impl Readable for OurPeerStorage {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let ver = read_ver_prefix!(reader, 1u8);
-		let ser_channels = <Vec<u8> as Readable>::read(reader)?;
 
-		let ps = OurPeerStorage { version: ver, ser_channels };
-		Ok(ps)
+		Ok(res)
 	}
 }