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")]
@@ -279,6 +285,42 @@ pub fn create_sha3(bits: usize) -> UResult<HashAlgorithm> {
     }
 }
 
+/// Create a SHA-2 `HashAlgorithm` based on the specified output size in bits.
+///
+/// # Arguments
+///
+/// * `bits` - The output size in bits for the SHA-2 algorithm.
+///
+/// # Returns
+///
+/// Returns a `UResult` with an `HashAlgorithm` or an `Err` if an unsupported
+/// output size is provided.
+pub fn create_sha2(bits: usize) -> UResult<HashAlgorithm> {
+    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()),
+    }
+}
+
 #[allow(clippy::comparison_chain)]
 fn print_cksum_report(res: &ChecksumResult) {
     if res.bad_format == 1 {
@@ -458,11 +500,14 @@ pub fn detect_algo(algo: &str, length: Option<usize>) -> UResult<HashAlgorithm>
                 bits,
             })
         }
+        ALGORITHM_OPTIONS_SHA2 => {
+            let bits = length.ok_or(ChecksumError::BitsRequiredForSha2)?;
+            create_sha2(bits)
+        }
         _ if algo.starts_with("sha3") => {
             let bits = length.ok_or(ChecksumError::BitsRequiredForSha3)?;
             create_sha3(bits)
         }
-
         _ => Err(ChecksumError::UnknownAlgorithm.into()),
     }
 }
@@ -1434,6 +1479,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
@@ -1464,6 +1521,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

@@ -2316,4 +2316,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");
+    }
 }