optionally truncate extracted ME binary

This essentially behaves like me_cleaner, but may result in a smaller file.

Signed-off-by: Daniel Maslowski <[email protected]>

Author: orangecms

src/clean.rs

@@ -1,4 +1,5 @@
 use intel_fw::{
+    EMPTY,
     ifd::{IFD, IfdError},
     me::ME,
     part::part::ClearOptions,
@@ -19,7 +20,7 @@ pub fn clean(
     me: &ME,
     data: &mut [u8],
     options: Options,
-) -> Result<Vec<u8>, String> {
+) -> Result<(Vec<u8>, Option<Vec<u8>>), String> {
     if (options.disable_me || options.disable_me_only)
         && let Ok(ifd) = ifd
     {
@@ -36,7 +37,7 @@ pub fn clean(
             data[..size].copy_from_slice(&new_ifd);
         }
         if options.disable_me_only {
-            return Ok(data.to_vec());
+            return Ok((data.to_vec(), None));
         }
     }
     let mut new_me = me.clone();
@@ -55,7 +56,12 @@ pub fn clean(
         Ok(cleaned) => {
             let size = cleaned.len();
             data[me.base..me.base + size].copy_from_slice(&cleaned);
-            Ok(data.to_vec())
+
+            // Fill up to fully cover the FPT area, clear out remaining bytes.
+            let original_size = new_me.fpt_area.original_size;
+            data[me.base + size..me.base + original_size].fill(EMPTY);
+
+            Ok((data.to_vec(), Some(cleaned)))
         }
         Err(e) => Err(e),
     }

src/main.rs

@@ -220,7 +220,7 @@ fn main() -> Result<(), io::Error> {
                     parts_force_deletion: blacklist.unwrap_or(vec![]),
                 };
                 match clean::clean(&fw.ifd, &me, &mut data, opts) {
-                    Ok(data) => {
+                    Ok((data, me_data)) => {
                         if let Some(f) = output {
                             let mut f = fs::File::create(f)?;
                             f.write_all(&data)?;
@@ -235,8 +235,12 @@ fn main() -> Result<(), io::Error> {
                             }
                             if let Some(f) = extract_me {
                                 let mut f = fs::File::create(f)?;
-                                let me_range = ifd.regions.me_range();
-                                f.write_all(&data[me_range])?;
+                                if truncate && let Some(me_data) = me_data {
+                                    f.write_all(&me_data)?;
+                                } else {
+                                    let me_range = ifd.regions.me_range();
+                                    f.write_all(&data[me_range])?;
+                                }
                             }
                         }
                     }

src/me.rs

@@ -191,16 +191,12 @@ impl FPTArea {
         }
 
         let mut res = self.partitions.to_vec()?;
+        // Round to next 4k
+        let min_size = res.len().next_multiple_of(4096);
         if debug {
-            println!("  Minimum size: {:08x}", res.len());
-        }
-        // Restore the original size, so that the resulting slice fully covers
-        // the FPT area. The resulting bytes can be used to overwrite the region
-        // in a given image, e.g., after cleaning or other partition changes.
-        res.resize(self.original_size, EMPTY);
-        if debug {
-            println!(" Restored size: {:08x}", res.len());
+            println!("  Minimum size: {:08x}", min_size);
         }
+        res.resize(min_size, EMPTY);
 
         // Any range within the FPT area may be non-covered.
         for u in &self.non_covered {