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 holding the entire partition name field
without any conversion for performing checksums and serializations.

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

Author: Cyanoxygen

src/lib.rs

@@ -378,24 +378,35 @@ impl GPTHeader {
 
 /// A wrapper type for `String` that represents a partition's name.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PartitionName(String);
+pub struct PartitionName {
+    string: String,
+    raw_buf: [u8; 72],
+}
 
 impl PartitionName {
     /// Extracts a string slice containing the entire `PartitionName`.
     pub fn as_str(&self) -> &str {
-        self.0.as_str()
+        &self.string
     }
 }
 
 impl std::fmt::Display for PartitionName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
+        write!(f, "{}", &self.string)
     }
 }
 
 impl From<&str> for PartitionName {
     fn from(value: &str) -> PartitionName {
-        PartitionName(value.to_string())
+        let utf16_converted = value.encode_utf16();
+        let mut raw_buf = [0; 72];
+        for (idx, chr) in utf16_converted.into_iter().take(36).enumerate() {
+            raw_buf[idx * 2..=idx * 2 + 1].copy_from_slice(&chr.to_le_bytes());
+        }
+        PartitionName {
+            string: value.to_string(),
+            raw_buf,
+        }
     }
 }
 
@@ -412,18 +423,28 @@ impl<'de> Visitor<'de> for UTF16LEVisitor {
     where
         A: SeqAccess<'de>,
     {
-        let mut v = Vec::new();
+        let mut v: Vec<u16> = Vec::new();
+        let mut raw_buf = [0; 72];
         let mut end = false;
-        loop {
-            match seq.next_element()? {
-                Some(0) => end = true,
-                Some(x) if !end => v.push(x),
-                Some(_) => {}
-                None => break,
+        let mut idx = 0;
+        while let Some(x) = seq.next_element()? {
+            if idx >= 72 {
+                break;
+            }
+            if x == 0 {
+                end = true;
+            }
+            if !end {
+                v.push(x);
             }
-        }
 
-        Ok(PartitionName(String::from_utf16_lossy(&v)))
+            raw_buf[idx..=idx + 1].copy_from_slice(&x.to_le_bytes());
+            idx += 2;
+        }
+        Ok(PartitionName {
+            string: String::from_utf16_lossy(&v),
+            raw_buf,
+        })
     }
 }
 
@@ -441,9 +462,9 @@ impl Serialize for PartitionName {
     where
         S: Serializer,
     {
-        let s = self.0.encode_utf16();
-        let mut seq = serializer.serialize_tuple(36)?;
-        for x in s.chain([0].iter().cycle().cloned()).take(36) {
+        // Favor using the content in the raw buffer in case there is garbage left (used for the CRC)
+        let mut seq = serializer.serialize_tuple(72)?;
+        for x in self.raw_buf {
             seq.serialize_element(&x)?;
         }
         seq.end()