chroe: properly perform checksums on partition table arrays

Some partitioning tools like ones based on libparted (parted and
GParted) don't wipe the entire GPT partition name field before writing
new partition names. Additionally, it is not guaranteed to be properly
zeroed since the UEFI specification does not clearly state that.

Use a dedicated raw buffer which directly read or write to the disk to
perform checksums without explicit string handling.

Signed-off-by: Xinhui Yang <[email protected]>

Author: Cyanoxygen

src/lib.rs

@@ -305,14 +305,16 @@ impl GPTHeader {
     }
 
     /// Generate the CRC32 checksum of the partition entry array.
-    pub fn generate_partition_entry_array_crc32(&self, partitions: &[GPTPartitionEntry]) -> u32 {
+    pub fn generate_partition_entry_array_crc32(
+        &self,
+        partitions_raw: &[RawPartitionEntry],
+    ) -> u32 {
         let mut clone = self.clone();
         clone.partition_entry_array_crc32 = 0;
         let crc = Crc::<u32>::new(&CRC_32_ISO_HDLC);
         let mut digest = crc.digest();
         let mut wrote = 0;
-        for x in partitions {
-            let data = encode_to_vec(x, legacy()).expect("could not serialize");
+        for data in partitions_raw {
             digest.update(&data);
             wrote += data.len();
         }
@@ -326,7 +328,21 @@ impl GPTHeader {
 
     /// Update the CRC32 checksum of the partition entry array.
     pub fn update_partition_entry_array_crc32(&mut self, partitions: &[GPTPartitionEntry]) {
-        self.partition_entry_array_crc32 = self.generate_partition_entry_array_crc32(partitions);
+        // Dump the partitions into raw bytes.
+        let mut partitions_raw = Vec::new();
+        for i in 0usize..self.number_of_partition_entries as usize {
+            let mut cur_raw = vec![0; self.size_of_partition_entry as usize];
+            if let Some(entry) = partitions.get(i) {
+                let data = encode_to_vec(entry, legacy()).expect("could not serialize");
+                cur_raw.copy_from_slice(&data);
+            } else {
+                cur_raw.copy_from_slice(&vec![0; self.size_of_partition_entry as usize]);
+            };
+            partitions_raw.push(cur_raw);
+        }
+        // Use raw bytes for checksuming.
+        self.partition_entry_array_crc32 =
+            self.generate_partition_entry_array_crc32(&partitions_raw);
     }
 
     /// Updates the header to match the specifications of the seeker given in argument.
@@ -450,6 +466,12 @@ impl Serialize for PartitionName {
     }
 }
 
+/// Raw bytes containing all partition entries for checksuming, to
+/// accommodate extreme (but common) situations like improperly zeroed
+/// partition names. Tools based on libparted usually exhibit this behavior.
+/// Note: using Vec instead of static array; entry size is variable.
+type RawPartitionEntry = Vec<u8>;
+
 /// A GPT partition's entry in the partition array.
 ///
 /// # Examples
@@ -660,6 +682,7 @@ pub struct GPT {
     /// GPT partition header (disk GUID, first/last usable LBA, etc...)
     pub header: GPTHeader,
     partitions: Vec<GPTPartitionEntry>,
+    partitions_raw: Vec<RawPartitionEntry>,
     /// Partitions alignment (in sectors)
     ///
     /// This field change the behavior of the methods `get_maximum_partition_size()`,
@@ -699,6 +722,7 @@ impl GPT {
             sector_size,
             header,
             partitions,
+            partitions_raw: vec![],
             align: DEFAULT_ALIGN,
         })
     }
@@ -744,15 +768,22 @@ impl GPT {
         })?;
 
         let mut partitions = Vec::with_capacity(header.number_of_partition_entries as usize);
+        let mut partitions_raw = Vec::new();
         for i in 0..header.number_of_partition_entries {
             reader.seek(SeekFrom::Start(
                 header.partition_entry_lba * sector_size
                     + u64::from(i) * u64::from(header.size_of_partition_entry),
             ))?;
-            partitions.push(GPTPartitionEntry::read_from(&mut reader)?);
+
+            let mut raw_entry = vec![0; header.size_of_partition_entry as usize];
+            // Read to raw buffer
+            reader.read_exact(&mut raw_entry.as_mut_slice())?;
+
+            partitions.push(GPTPartitionEntry::read_from(&mut raw_entry.as_slice())?);
+            partitions_raw.push(raw_entry);
         }
 
-        let sum = header.generate_partition_entry_array_crc32(&partitions);
+        let sum = header.generate_partition_entry_array_crc32(&partitions_raw);
         if header.partition_entry_array_crc32 != sum {
             return Err(Error::InvalidPartitionEntryArrayChecksum(
                 header.partition_entry_array_crc32,
@@ -766,6 +797,7 @@ impl GPT {
             sector_size,
             header,
             partitions,
+            partitions_raw,
             align,
         })
     }
@@ -1374,6 +1406,7 @@ mod test {
             let mut unused = 0;
             let mut used = 0;
             let mut partitions = Vec::new();
+            let mut partitions_raw = Vec::new();
             for i in 0..gpt.number_of_partition_entries {
                 f.seek(SeekFrom::Start(
                     gpt.partition_entry_lba * ss
@@ -1400,6 +1433,7 @@ mod test {
                 assert_eq!(data1, data2);
 
                 partitions.push(partition);
+                partitions_raw.push(data2);
             }
             assert_eq!(unused, 126);
             assert_eq!(used, 2);
@@ -1413,7 +1447,10 @@ mod test {
             let sum = gpt.partition_entry_array_crc32;
             gpt.update_partition_entry_array_crc32(&partitions);
             assert_eq!(gpt.partition_entry_array_crc32, sum);
-            assert_eq!(gpt.generate_partition_entry_array_crc32(&partitions), sum);
+            assert_eq!(
+                gpt.generate_partition_entry_array_crc32(&partitions_raw),
+                sum
+            );
             assert_ne!(gpt.partition_entry_array_crc32, 0);
         }