cksum: add support for sha2

Author: sylvestre

src/uu/cksum/src/cksum.rs

@@ -14,9 +14,9 @@ use std::iter;
 use std::path::Path;
 use uucore::checksum::{
     ALGORITHM_OPTIONS_BLAKE2B, ALGORITHM_OPTIONS_BSD, ALGORITHM_OPTIONS_CRC,
-    ALGORITHM_OPTIONS_CRC32B, ALGORITHM_OPTIONS_SYSV, ChecksumError, ChecksumOptions,
-    ChecksumVerbose, SUPPORTED_ALGORITHMS, detect_algo, digest_reader, perform_checksum_validation,
-    validate_blake2b_length_with_fluent,
+    ALGORITHM_OPTIONS_CRC32B, ALGORITHM_OPTIONS_SHA2, ALGORITHM_OPTIONS_SYSV, ChecksumError,
+    ChecksumOptions, ChecksumVerbose, SUPPORTED_ALGORITHMS, detect_algo, digest_reader,
+    perform_checksum_validation, validate_blake2b_length,
 };
 use uucore::translate;
 
@@ -255,7 +255,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let length = match input_length {
         Some(length_str) => {
             if algo_name == ALGORITHM_OPTIONS_BLAKE2B {
-                validate_blake2b_length_with_fluent(length_str, "cksum")?
+                validate_blake2b_length(length_str, "cksum")?
+            } else if algo_name == ALGORITHM_OPTIONS_SHA2
+                || algo_name.starts_with("sha3")
+                || algo_name == "shake128"
+                || algo_name == "shake256"
+            {
+                // Parse length for sha2, sha3, and shake algorithms
+                Some(
+                    length_str
+                        .parse::<usize>()
+                        .map_err(|_| ChecksumError::InvalidLength)?,
+                )
             } else {
                 return Err(ChecksumError::LengthOnlyForBlake2b.into());
             }

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

@@ -47,14 +47,16 @@ pub const ALGORITHM_OPTIONS_BLAKE3: &str = "blake3";
 pub const ALGORITHM_OPTIONS_SM3: &str = "sm3";
 pub const ALGORITHM_OPTIONS_SHAKE128: &str = "shake128";
 pub const ALGORITHM_OPTIONS_SHAKE256: &str = "shake256";
+pub const ALGORITHM_OPTIONS_SHA2: &str = "sha2";
 
-pub const SUPPORTED_ALGORITHMS: [&str; 16] = [
+pub const SUPPORTED_ALGORITHMS: [&str; 17] = [
     ALGORITHM_OPTIONS_SYSV,
     ALGORITHM_OPTIONS_BSD,
     ALGORITHM_OPTIONS_CRC,
     ALGORITHM_OPTIONS_CRC32B,
     ALGORITHM_OPTIONS_MD5,
     ALGORITHM_OPTIONS_SHA1,
+    ALGORITHM_OPTIONS_SHA2,
     ALGORITHM_OPTIONS_SHA3,
     ALGORITHM_OPTIONS_SHA224,
     ALGORITHM_OPTIONS_SHA256,
@@ -222,6 +224,10 @@ pub enum ChecksumError {
     BitsRequiredForShake128,
     #[error("--bits required for SHAKE256")]
     BitsRequiredForShake256,
+    #[error("--bits required for SHA2")]
+    BitsRequiredForSha2,
+    #[error("Invalid output size for SHA2 (expected 224, 256, 384, or 512), got {0}")]
+    InvalidSha2Length(usize),
     #[error("unknown algorithm: clap should have prevented this case")]
     UnknownAlgorithm,
     #[error("length is not a multiple of 8")]
@@ -462,6 +468,32 @@ pub fn detect_algo(algo: &str, length: Option<usize>) -> UResult<HashAlgorithm>
             let bits = length.ok_or(ChecksumError::BitsRequiredForSha3)?;
             create_sha3(bits)
         }
+        ALGORITHM_OPTIONS_SHA2 => {
+            let bits = length.ok_or(ChecksumError::BitsRequiredForSha2)?;
+            match bits {
+                224 => Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_SHA224,
+                    create_fn: Box::new(|| Box::new(Sha224::new())),
+                    bits: 224,
+                }),
+                256 => Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_SHA256,
+                    create_fn: Box::new(|| Box::new(Sha256::new())),
+                    bits: 256,
+                }),
+                384 => Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_SHA384,
+                    create_fn: Box::new(|| Box::new(Sha384::new())),
+                    bits: 384,
+                }),
+                512 => Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_SHA512,
+                    create_fn: Box::new(|| Box::new(Sha512::new())),
+                    bits: 512,
+                }),
+                _ => Err(ChecksumError::InvalidSha2Length(bits).into()),
+            }
+        }
 
         _ => Err(ChecksumError::UnknownAlgorithm.into()),
     }
@@ -1437,6 +1469,18 @@ mod tests {
             detect_algo(ALGORITHM_OPTIONS_SHA512, None).unwrap().name,
             ALGORITHM_OPTIONS_SHA512
         );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA2, Some(256)).unwrap().name,
+            ALGORITHM_OPTIONS_SHA256
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA2, Some(384)).unwrap().name,
+            ALGORITHM_OPTIONS_SHA384
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA2, Some(512)).unwrap().name,
+            ALGORITHM_OPTIONS_SHA512
+        );
         assert_eq!(
             detect_algo(ALGORITHM_OPTIONS_BLAKE2B, None).unwrap().name,
             ALGORITHM_OPTIONS_BLAKE2B
@@ -1467,6 +1511,7 @@ mod tests {
         assert_eq!(detect_algo("sha3_512", Some(512)).unwrap().name, "SHA3_512");
 
         assert!(detect_algo("sha3_512", None).is_err());
+        assert!(detect_algo(ALGORITHM_OPTIONS_SHA2, None).is_err());
     }
 
     #[test]

tests/by-util/test_cksum.rs

@@ -9,8 +9,9 @@ use uutests::new_ucmd;
 use uutests::util::TestScenario;
 use uutests::util_name;
 
-const ALGOS: [&str; 11] = [
-    "sysv", "bsd", "crc", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b", "sm3",
+const ALGOS: [&str; 12] = [
+    "sysv", "bsd", "crc", "md5", "sha1", "sha2", "sha224", "sha256", "sha384", "sha512", "blake2b",
+    "sm3",
 ];
 
 #[test]
@@ -2316,4 +2317,198 @@ mod format_mix {
             .stdout_contains("bar: OK")
             .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
     }
+
+    #[test]
+    fn test_sha2_requires_length() {
+        // Test that sha2 algorithm requires a length parameter
+        new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("lorem_ipsum.txt")
+            .fails_with_code(1)
+            .no_stdout()
+            .stderr_contains("--bits required for SHA2");
+    }
+
+    #[test]
+    fn test_sha2_with_length_224() {
+        // Test sha2 with 224-bit length (equivalent to sha224)
+        let result_sha2 = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("224")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        let result_sha224 = new_ucmd!()
+            .arg("-a")
+            .arg("sha224")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        // The outputs should be identical (both produce SHA224)
+        assert_eq!(result_sha2, result_sha224);
+        assert!(result_sha2.contains("SHA224"));
+    }
+
+    #[test]
+    fn test_sha2_with_length_256() {
+        // Test sha2 with 256-bit length (equivalent to sha256)
+        let result_sha2 = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("256")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        let result_sha256 = new_ucmd!()
+            .arg("-a")
+            .arg("sha256")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        // The outputs should be identical (both produce SHA256)
+        assert_eq!(result_sha2, result_sha256);
+        assert!(result_sha2.contains("SHA256"));
+    }
+
+    #[test]
+    fn test_sha2_with_length_384() {
+        // Test sha2 with 384-bit length (equivalent to sha384)
+        let result_sha2 = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("384")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        let result_sha384 = new_ucmd!()
+            .arg("-a")
+            .arg("sha384")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        // The outputs should be identical (both produce SHA384)
+        assert_eq!(result_sha2, result_sha384);
+        assert!(result_sha2.contains("SHA384"));
+    }
+
+    #[test]
+    fn test_sha2_with_length_512() {
+        // Test sha2 with 512-bit length (equivalent to sha512)
+        let result_sha2 = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("512")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        let result_sha512 = new_ucmd!()
+            .arg("-a")
+            .arg("sha512")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        // The outputs should be identical (both produce SHA512)
+        assert_eq!(result_sha2, result_sha512);
+        assert!(result_sha2.contains("SHA512"));
+    }
+
+    #[test]
+    fn test_sha2_invalid_length() {
+        // Test sha2 with invalid length parameters
+        new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("128")
+            .pipe_in("test\n")
+            .fails_with_code(1)
+            .stderr_contains("Invalid output size for SHA2");
+
+        new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("1024")
+            .pipe_in("test\n")
+            .fails_with_code(1)
+            .stderr_contains("Invalid output size for SHA2");
+    }
+
+    #[test]
+    fn test_sha2_with_raw_output() {
+        // Test sha2 with raw (binary) output
+        let result = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("256")
+            .arg("--raw")
+            .pipe_in("test\n")
+            .succeeds();
+
+        // Raw output should be binary, not hex - check raw bytes instead of trying to convert to string
+        let stdout_bytes = result.stdout();
+        // Raw output should not be empty and should be exactly 32 bytes for SHA256
+        assert_eq!(stdout_bytes.len(), 32);
+        // Should not contain ASCII text like "SHA256"
+        assert!(!stdout_bytes.starts_with(b"SHA256"));
+    }
+
+    #[test]
+    fn test_sha2_with_base64_output() {
+        // Test sha2 with base64 output
+        let result = new_ucmd!()
+            .arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("256")
+            .arg("--base64")
+            .pipe_in("test\n")
+            .succeeds()
+            .stdout_str()
+            .to_owned();
+
+        // Should contain base64 characters and SHA256 label
+        assert!(result.contains("SHA256"));
+        // Base64 should end with = or == or contain +/
+        assert!(result.contains('=') || result.contains('+') || result.contains('/'));
+    }
+
+    #[test]
+    fn test_sha2_with_file() {
+        // Test sha2 with actual file input
+        let (at, mut ucmd) = at_and_ucmd!();
+        at.write("test_file.txt", "Hello, world!\n");
+
+        ucmd.arg("-a")
+            .arg("sha2")
+            .arg("-l")
+            .arg("256")
+            .arg("test_file.txt")
+            .succeeds()
+            .stdout_contains("SHA256")
+            .stdout_contains("test_file.txt");
+    }
 }