fill gaps on write

Author: vgough

src/crypto/file.rs

@@ -22,6 +22,18 @@ impl<T: FileExt> WriteAt for T {
     }
 }
 
+/// Trait for querying file length.
+/// Needed to detect writes past EOF that would create sparse holes.
+pub trait FileLen {
+    fn file_len(&self) -> io::Result<u64>;
+}
+
+impl FileLen for std::fs::File {
+    fn file_len(&self) -> io::Result<u64> {
+        self.metadata().map(|m| m.len())
+    }
+}
+
 /// Decodes encrypted files.
 ///
 /// Handles block-by-block decryption and MAC verification.
@@ -217,7 +229,7 @@ impl<'a, F: ReadAt> FileDecoder<'a, F> {
 }
 
 /// Encodes encrypted files (writes).
-pub struct FileEncoder<'a, F: ReadAt + WriteAt> {
+pub struct FileEncoder<'a, F: ReadAt + WriteAt + FileLen> {
     cipher: &'a SslCipher,
     file: &'a F,
     file_iv: u64,
@@ -226,7 +238,7 @@ pub struct FileEncoder<'a, F: ReadAt + WriteAt> {
     block_mac_bytes: u64,
 }
 
-impl<'a, F: ReadAt + WriteAt> FileEncoder<'a, F> {
+impl<'a, F: ReadAt + WriteAt + FileLen> FileEncoder<'a, F> {
     pub fn new(
         cipher: &'a SslCipher,
         file: &'a F,
@@ -273,14 +285,6 @@ impl<'a, F: ReadAt + WriteAt> FileEncoder<'a, F> {
     }
 
     pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
-        let size = buf.len() as u64;
-        let mut bytes_remaining = size;
-        let mut total_written = 0;
-        let mut current_offset = offset;
-
-        // Usage in `FileDecoder::read_at`: `self.block_size - self.block_mac_bytes`.
-        // I will follow `FileDecoder` convention here to avoid breaking things, assuming `self.block_size` = ON DISK SIZE.
-
         if self.block_size <= self.block_mac_bytes {
             return Err(io::Error::other(
                 "Invalid config: block_size must be > block_mac_bytes",
@@ -299,6 +303,57 @@ impl<'a, F: ReadAt + WriteAt> FileEncoder<'a, F> {
             ));
         }
 
+        // Detect and fill gaps to prevent sparse files.
+        // Sparse files cause MAC verification failures because reading a block
+        // that partially spans a hole returns zeros that weren't properly encrypted.
+        let physical_size = self.file.file_len()?;
+        let current_logical_size = FileDecoder::<F>::calculate_logical_size(
+            physical_size,
+            self.header_size,
+            self.block_size,
+            self.block_mac_bytes,
+        );
+
+        if offset > current_logical_size {
+            // Fill the gap with encrypted zeros
+            let gap_size = offset - current_logical_size;
+            let zeros = vec![0u8; gap_size as usize];
+            // Recursively call write_at to fill the gap with properly encrypted zeros
+            self.write_at_internal(
+                &zeros,
+                current_logical_size,
+                data_block_size,
+                physical_block_size,
+                physical_block_size_usize,
+                mac_len_usize,
+            )?;
+        }
+
+        // Now write the actual data
+        self.write_at_internal(
+            buf,
+            offset,
+            data_block_size,
+            physical_block_size,
+            physical_block_size_usize,
+            mac_len_usize,
+        )
+    }
+
+    fn write_at_internal(
+        &self,
+        buf: &[u8],
+        offset: u64,
+        data_block_size: u64,
+        physical_block_size: u64,
+        physical_block_size_usize: usize,
+        mac_len_usize: usize,
+    ) -> io::Result<usize> {
+        let size = buf.len() as u64;
+        let mut bytes_remaining = size;
+        let mut total_written = 0;
+        let mut current_offset = offset;
+
         while bytes_remaining > 0 {
             let block_num = current_offset / data_block_size;
             let block_offset = current_offset % data_block_size;