cksum: Add support for blake3

Author: RenjiSann

src/uu/cksum/src/cksum.rs

@@ -61,11 +61,14 @@ fn maybe_sanitize_length(
         // validation is performed on this length, any value is valid. If the
         // given length is not a multiple of 8, the last byte of the output
         // will have its extra bits set to zero.
-        (Some(AlgoKind::Shake128 | AlgoKind::Shake256), Some(len)) => match len.parse::<usize>() {
-            Ok(0) => Ok(None),
-            Ok(l) => Ok(Some(l)),
-            Err(_) => Err(ChecksumError::InvalidLength(len.into()).into()),
-        },
+        // For BLAKE3, the length is interpreted as a byte length.
+        (Some(AlgoKind::Shake128 | AlgoKind::Shake256 | AlgoKind::Blake3), Some(len)) => {
+            match len.parse::<usize>() {
+                Ok(0) => Ok(None),
+                Ok(l) => Ok(Some(l)),
+                Err(_) => Err(ChecksumError::InvalidLength(len.into()).into()),
+            }
+        }
 
         // For BLAKE2b, if a length is provided, validate it.
         (Some(AlgoKind::Blake2b), Some(len)) => calculate_blake2b_length_str(len),

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

@@ -115,6 +115,8 @@ impl AlgoKind {
             ALGORITHM_OPTIONS_SHA384 => Sha384,
             ALGORITHM_OPTIONS_SHA512 => Sha512,
 
+            // Extensions not in GNU as of version 9.10
+            ALGORITHM_OPTIONS_BLAKE3 => Blake3,
             ALGORITHM_OPTIONS_SHAKE128 => Shake128,
             ALGORITHM_OPTIONS_SHAKE256 => Shake256,
             _ => return Err(ChecksumError::UnknownAlgorithm(algo.as_ref().to_string()).into()),
@@ -245,11 +247,12 @@ pub enum SizedAlgoKind {
     Md5,
     Sm3,
     Sha1,
-    Blake3,
     Sha2(ShaLength),
     Sha3(ShaLength),
     // Note: we store Blake2b's length as BYTES.
     Blake2b(Option<usize>),
+    // Note: we store Blake3's length as BYTES.
+    Blake3(Option<usize>),
     Shake128(Option<usize>),
     Shake256(Option<usize>),
 }
@@ -266,7 +269,6 @@ impl SizedAlgoKind {
                 | ak::Md5
                 | ak::Sm3
                 | ak::Sha1
-                | ak::Blake3
                 | ak::Sha224
                 | ak::Sha256
                 | ak::Sha384
@@ -281,8 +283,8 @@ impl SizedAlgoKind {
             (ak::Md5, _) => Ok(Self::Md5),
             (ak::Sm3, _) => Ok(Self::Sm3),
             (ak::Sha1, _) => Ok(Self::Sha1),
-            (ak::Blake3, _) => Ok(Self::Blake3),
 
+            (ak::Blake3, l) => Ok(Self::Blake3(l)),
             (ak::Shake128, l) => Ok(Self::Shake128(l)),
             (ak::Shake256, l) => Ok(Self::Shake256(l)),
             (ak::Sha2, Some(l)) => Ok(Self::Sha2(ShaLength::try_from(l)?)),
@@ -305,19 +307,22 @@ impl SizedAlgoKind {
     }
 
     pub fn to_tag(self) -> String {
-        use SizedAlgoKind::*;
         match self {
-            Md5 => "MD5".into(),
-            Sm3 => "SM3".into(),
-            Sha1 => "SHA1".into(),
-            Blake3 => "BLAKE3".into(),
-            Sha2(len) => format!("SHA{}", len.as_usize()),
-            Sha3(len) => format!("SHA3-{}", len.as_usize()),
-            Blake2b(Some(byte_len)) => format!("BLAKE2b-{}", byte_len * 8),
-            Blake2b(None) => "BLAKE2b".into(),
-            Shake128(_) => "SHAKE128".into(),
-            Shake256(_) => "SHAKE256".into(),
-            Sysv | Bsd | Crc | Crc32b => panic!("Should not be used for tagging"),
+            Self::Md5 => "MD5".into(),
+            Self::Sm3 => "SM3".into(),
+            Self::Sha1 => "SHA1".into(),
+            Self::Sha2(len) => format!("SHA{}", len.as_usize()),
+            Self::Sha3(len) => format!("SHA3-{}", len.as_usize()),
+            Self::Blake2b(Some(byte_len)) => format!("BLAKE2b-{}", byte_len * 8),
+            Self::Blake2b(None) => "BLAKE2b".into(),
+            Self::Blake3(byte_len) => {
+                format!("BLAKE3-{}", byte_len.unwrap_or(Blake3::DEFAULT_BYTE_SIZE))
+            }
+            Self::Shake128(_) => "SHAKE128".into(),
+            Self::Shake256(_) => "SHAKE256".into(),
+            Self::Sysv | Self::Bsd | Self::Crc | Self::Crc32b => {
+                panic!("Should not be used for tagging")
+            }
         }
     }
 
@@ -331,7 +336,6 @@ impl SizedAlgoKind {
             Self::Md5 => Box::new(Md5::default()),
             Self::Sm3 => Box::new(Sm3::default()),
             Self::Sha1 => Box::new(Sha1::default()),
-            Self::Blake3 => Box::new(Blake3::default()),
             Self::Sha2(Len224) => Box::new(Sha224::default()),
             Self::Sha2(Len256) => Box::new(Sha256::default()),
             Self::Sha2(Len384) => Box::new(Sha384::default()),
@@ -343,6 +347,9 @@ impl SizedAlgoKind {
             Self::Blake2b(len_opt) => {
                 Box::new(len_opt.map(Blake2b::with_output_bytes).unwrap_or_default())
             }
+            Self::Blake3(len_opt) => {
+                Box::new(len_opt.map(Blake3::with_output_bytes).unwrap_or_default())
+            }
             Self::Shake128(len_opt) => {
                 Box::new(len_opt.map(Shake128::with_output_bits).unwrap_or_default())
             }
@@ -361,7 +368,7 @@ impl SizedAlgoKind {
             Self::Md5 => 128,
             Self::Sm3 => 512,
             Self::Sha1 => 160,
-            Self::Blake3 => 256,
+            Self::Blake3(len) => len.unwrap_or(Blake3::DEFAULT_BYTE_SIZE) * 8,
             Self::Sha2(len) => len.as_usize(),
             Self::Sha3(len) => len.as_usize(),
             Self::Blake2b(len) => len.unwrap_or(Blake2b::DEFAULT_BYTE_SIZE * 8),

src/uucore/src/lib/features/sum.rs

@@ -68,7 +68,8 @@ pub trait Digest {
     }
 
     fn result(&mut self) -> DigestOutput {
-        let mut buf: Vec<u8> = vec![0; self.output_bytes()];
+        let out_bytes: usize = self.output_bytes();
+        let mut buf: Vec<u8> = vec![0; out_bytes];
         self.hash_finalize(&mut buf);
         DigestOutput::Vec(buf)
     }
@@ -122,25 +123,48 @@ impl Digest for Blake2b {
     }
 }
 
-#[derive(Default)]
-pub struct Blake3(blake3::Hasher);
+pub struct Blake3 {
+    digest: blake3::Hasher,
+    byte_size: usize,
+}
+
+impl Blake3 {
+    /// Default length for the BLAKE3 digest in bytes.
+    pub const DEFAULT_BYTE_SIZE: usize = 32;
+
+    pub fn with_output_bytes(output_bytes: usize) -> Self {
+        Self {
+            digest: blake3::Hasher::new(),
+            byte_size: output_bytes,
+        }
+    }
+}
+
+impl Default for Blake3 {
+    fn default() -> Self {
+        Self {
+            digest: Default::default(),
+            byte_size: Self::DEFAULT_BYTE_SIZE,
+        }
+    }
+}
 
 impl Digest for Blake3 {
     fn hash_update(&mut self, input: &[u8]) {
-        self.0.update(input);
+        self.digest.update(input);
     }
 
     fn hash_finalize(&mut self, out: &mut [u8]) {
-        let hash_result = &self.0.finalize();
-        out.copy_from_slice(hash_result.as_bytes());
+        let hash_result = &self.digest.finalize();
+        out.copy_from_slice(&hash_result.as_bytes()[..self.byte_size]);
     }
 
     fn reset(&mut self) {
-        *self = Self::default();
+        *self = Self::with_output_bytes(self.output_bytes());
     }
 
     fn output_bits(&self) -> usize {
-        256
+        self.byte_size * 8
     }
 }