Properly perform checksums on partition table arrays when partition names contains garbage data after the null terminator

[Cyanoxygen]

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.

Current checksuming logic uses processed partition names which ignores garbage data after the null terminator, and reports an CRC error if such partition table is encountered:

(This test program uses gptman to scan for ESP partition(s).)

You can easily recreate this issue using either parted or GParted, first name a partition with a longer name, then rename it with a shorter name. You can see the remining bytes are not zeroed:

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

[cecton]

Hello and thank you so much for your contribution 🙏

I like it thanks! But I think you got the wrong approach on fixing this issue. The partition name is store in a public struct called PartitionName for which we have the entire control over the implementation. I think we should leverage that and improve this struct to also store the original 72 bytes in it so we can checksum the original bytes. This approach will also avoid breaking the API and I can even make a patch release for this.

What do you think about it?

/// A wrapper type for `String` that represents a partition's name.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PartitionName(String); // <-- 2 fields, one for the parsed string, one for the original bytes

impl PartitionName {
    /// Extracts a string slice containing the entire `PartitionName`.
    pub fn as_str(&self) -> &str {
        self.0.as_str() // <-- keep returning the parsed string normally
    }
}

impl From<&str> for PartitionName {
    fn from(value: &str) -> PartitionName {
        PartitionName(value.to_string()) // <-- also generate the field for the UTF-16 bytes
    }
}

impl Serialize for PartitionName {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
// ... serialize the byte fields instead of the string
    }
}

[Cyanoxygen]

I think we should leverage that and improve this struct to also store the original 72 bytes in it so we can checksum the original bytes. This approach will also avoid breaking the API and I can even make a patch release for this.

Yes, sure! I thought it probably would be better for it to store a copy of the raw bytes so it keeps exactly what it is. Now that you are okay with just leveraging PartitionName (and since dumped contents are actually packed), I'll try to do what you suggested!

[Cyanoxygen]

Hi @cecton,

I've updated the code according your suggestion. It takes a rather dirty (I think) approach to deserialize UTF-16 characters.

[Cyanoxygen]

@cecton PR has been updated. Thanks!

[cecton]

Last bit sorry 🙏

[Cyanoxygen]

Last bit sorry 🙏

It's okay. I'll update it tomorrow.