checksum: fix GNU test cksum-base64-untagged.sh

Author: RenjiSann

src/uucore/src/lib/features/checksum/validate.rs

@@ -296,27 +296,7 @@ impl LineFormat {
             SubCase::OpenSSL => ByteSliceExt::rsplit_once(after_paren, b")= ")?,
         };
 
-        fn is_valid_checksum(checksum: &[u8]) -> bool {
-            if checksum.is_empty() {
-                return false;
-            }
-
-            let mut parts = checksum.splitn(2, |&b| b == b'=');
-            let main = parts.next().unwrap(); // Always exists since checksum isn't empty
-            let padding = parts.next().unwrap_or_default(); // Empty if no '='
-
-            main.iter()
-                .all(|&b| b.is_ascii_alphanumeric() || b == b'+' || b == b'/')
-                && !main.is_empty()
-                && padding.len() <= 2
-                && padding.iter().all(|&b| b == b'=')
-        }
-        if !is_valid_checksum(checksum) {
-            return None;
-        }
-        // SAFETY: we just validated the contents of checksum, we can unsafely make a
-        // String from it
-        let checksum_utf8 = unsafe { String::from_utf8_unchecked(checksum.to_vec()) };
+        let checksum_utf8 = Self::validate_checksum_format(checksum)?;
 
         Some(LineInfo {
             algo_name: Some(algo_utf8),
@@ -336,12 +316,8 @@ impl LineFormat {
     fn parse_untagged(line: &[u8]) -> Option<LineInfo> {
         let space_idx = line.iter().position(|&b| b == b' ')?;
         let checksum = &line[..space_idx];
-        if !checksum.iter().all(|&b| b.is_ascii_hexdigit()) || checksum.is_empty() {
-            return None;
-        }
-        // SAFETY: we just validated the contents of checksum, we can unsafely make a
-        // String from it
-        let checksum_utf8 = unsafe { String::from_utf8_unchecked(checksum.to_vec()) };
+
+        let checksum_utf8 = Self::validate_checksum_format(checksum)?;
 
         let rest = &line[space_idx..];
         let filename = rest
@@ -388,6 +364,34 @@ impl LineFormat {
             format: Self::SingleSpace,
         })
     }
+
+    /// Ensure that the given checksum is syntactically valid (that it is either
+    /// hexadecimal or base64 encoded).
+    fn validate_checksum_format(checksum: &[u8]) -> Option<String> {
+        if checksum.is_empty() {
+            return None;
+        }
+
+        let mut parts = checksum.splitn(2, |&b| b == b'=');
+        let main = parts.next().unwrap(); // Always exists since checksum isn't empty
+        let padding = parts.next().unwrap_or_default(); // Empty if no '='
+
+        if main.is_empty()
+            || !main
+                .iter()
+                .all(|&b| b.is_ascii_alphanumeric() || b == b'+' || b == b'/')
+        {
+            return None;
+        }
+
+        if padding.len() > 2 || padding.iter().any(|&b| b != b'=') {
+            return None;
+        }
+
+        // SAFETY: we just validated the contents of checksum, we can unsafely make a
+        // String from it
+        Some(unsafe { String::from_utf8_unchecked(checksum.to_vec()) })
+    }
 }
 
 // Helper trait for byte slice operations
@@ -1039,7 +1043,13 @@ mod tests {
                 b"b064a020db8018f18ff5ae367d01b212   ",
                 Some((b"b064a020db8018f18ff5ae367d01b212", b" ")),
             ),
-            (b"invalidchecksum  test", None),
+            // base64 checksums are accepted
+            (
+                b"b21lbGV0dGUgZHUgZnJvbWFnZQ==   ",
+                Some((b"b21lbGV0dGUgZHUgZnJvbWFnZQ==", b" ")),
+            ),
+            // Invalid checksums fail
+            (b"inva|idchecksum  test", None),
         ];
 
         for (input, expected) in test_cases {