b2sum: better validation of the args like in tests/cksum/b2sum

Author: sylvestre

src/uu/cksum/locales/en-US.ftl

@@ -33,3 +33,5 @@ cksum-help-zero = end each output line with NUL, not newline, and disable file n
 # Error messages
 cksum-error-is-directory = { $file }: Is a directory
 cksum-error-failed-to-read-input = failed to read input
+cksum-error-invalid-length = invalid length: { $length }
+cksum-error-max-digest-length = maximum digest length for '{ $algorithm }' is { $max_bits } bits

src/uu/cksum/locales/fr-FR.ftl

@@ -33,3 +33,5 @@ cksum-help-zero = terminer chaque ligne de sortie avec NUL, pas un saut de ligne
 # Messages d'erreur
 cksum-error-is-directory = { $file } : Est un répertoire
 cksum-error-failed-to-read-input = échec de la lecture de l'entrée
+cksum-error-invalid-length = longueur invalide : { $length }
+cksum-error-max-digest-length = longueur maximale de condensé pour '{ $algorithm }' est { $max_bits } bits

src/uu/cksum/src/cksum.rs

@@ -6,7 +6,7 @@
 // spell-checker:ignore (ToDO) fname, algo
 
 use clap::builder::ValueParser;
-use clap::{Arg, ArgAction, Command, value_parser};
+use clap::{Arg, ArgAction, Command};
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{BufReader, Read, Write, stdin, stdout};
@@ -15,8 +15,8 @@ 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, calculate_blake2b_length, detect_algo, digest_reader,
-    perform_checksum_validation,
+    ChecksumVerbose, SUPPORTED_ALGORITHMS, detect_algo, digest_reader, perform_checksum_validation,
+    validate_blake2b_length_with_fluent,
 };
 use uucore::translate;
 
@@ -250,12 +250,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     };
 
-    let input_length = matches.get_one::<usize>(options::LENGTH);
+    let input_length = matches.get_one::<String>(options::LENGTH);
 
     let length = match input_length {
-        Some(length) => {
+        Some(length_str) => {
             if algo_name == ALGORITHM_OPTIONS_BLAKE2B {
-                calculate_blake2b_length(*length)?
+                validate_blake2b_length_with_fluent(length_str, "cksum")?
             } else {
                 return Err(ChecksumError::LengthOnlyForBlake2b.into());
             }
@@ -378,7 +378,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::LENGTH)
                 .long(options::LENGTH)
-                .value_parser(value_parser!(usize))
+                .value_parser(ValueParser::string())
                 .short('l')
                 .help(translate!("cksum-help-length"))
                 .action(ArgAction::Set),

src/uu/hashsum/locales/en-US.ftl

@@ -40,3 +40,5 @@ hashsum-help-b3sum = work with BLAKE3
 
 # Error messages
 hashsum-error-failed-to-read-input = failed to read input
+hashsum-error-invalid-length = invalid length: { $length }
+hashsum-error-max-digest-length = maximum digest length for '{ $algorithm }' is { $max_bits } bits

src/uu/hashsum/locales/fr-FR.ftl

@@ -37,3 +37,5 @@ hashsum-help-b3sum = travailler avec BLAKE3
 
 # Messages d'erreur
 hashsum-error-failed-to-read-input = échec de la lecture de l'entrée
+hashsum-error-invalid-length = longueur invalide : { $length }
+hashsum-error-max-digest-length = longueur maximale de condensé pour '{ $algorithm }' est { $max_bits } bits

src/uu/hashsum/src/hashsum.rs

@@ -7,7 +7,6 @@
 
 use clap::ArgAction;
 use clap::builder::ValueParser;
-use clap::value_parser;
 use clap::{Arg, ArgMatches, Command};
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
@@ -19,12 +18,12 @@ use uucore::checksum::ChecksumError;
 use uucore::checksum::ChecksumOptions;
 use uucore::checksum::ChecksumVerbose;
 use uucore::checksum::HashAlgorithm;
-use uucore::checksum::calculate_blake2b_length;
 use uucore::checksum::create_sha3;
 use uucore::checksum::detect_algo;
 use uucore::checksum::digest_reader;
 use uucore::checksum::escape_filename;
 use uucore::checksum::perform_checksum_validation;
+use uucore::checksum::validate_blake2b_length;
 use uucore::error::{FromIo, UResult};
 use uucore::format_usage;
 use uucore::sum::{Digest, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
@@ -185,14 +184,14 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     //        least somewhat better from a user's perspective.
     let matches = uucore::clap_localization::handle_clap_result(command, args)?;
 
-    let input_length: Option<&usize> = if binary_name == "b2sum" {
-        matches.get_one::<usize>(options::LENGTH)
+    let input_length: Option<&String> = if binary_name == "b2sum" {
+        matches.get_one::<String>(options::LENGTH)
     } else {
         None
     };
 
     let length = match input_length {
-        Some(length) => calculate_blake2b_length(*length)?,
+        Some(length_str) => validate_blake2b_length(length_str, "hashsum")?,
         None => None,
     };
 
@@ -427,7 +426,7 @@ fn uu_app_opt_length(command: Command) -> Command {
     command.arg(
         Arg::new(options::LENGTH)
             .long(options::LENGTH)
-            .value_parser(value_parser!(usize))
+            .value_parser(ValueParser::string())
             .short('l')
             .help(translate!("hashsum-help-length"))
             .overrides_with(options::LENGTH)

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

@@ -17,6 +17,7 @@ use std::{
 };
 
 use crate::{
+    display::Quotable as DisplayQuotable,
     error::{FromIo, UError, UResult, USimpleError},
     os_str_as_bytes, os_str_from_bytes,
     quoting_style::{QuotingStyle, locale_aware_escape_name},
@@ -25,7 +26,7 @@ use crate::{
         Blake2b, Blake3, Bsd, CRC32B, Crc, Digest, DigestWriter, Md5, Sha1, Sha3_224, Sha3_256,
         Sha3_384, Sha3_512, Sha224, Sha256, Sha384, Sha512, Shake128, Shake256, Sm3, SysV,
     },
-    util_name,
+    translate, util_name,
 };
 use thiserror::Error;
 
@@ -1185,22 +1186,47 @@ pub fn digest_reader<T: Read>(
     }
 }
 
+/// Validates and calculates the length of the digest from a string input.
+/// This function handles very large numbers that might not fit in usize.
+pub fn validate_blake2b_length_str(length_str: &str) -> UResult<Option<usize>> {
+    // First try to parse as u128 to handle very large numbers
+    match length_str.parse::<u128>() {
+        Ok(length_u128) => {
+            if length_u128 > usize::MAX as u128 {
+                // For very large numbers, always show the max length error
+                show_error!("invalid length: '{length_str}'");
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "maximum digest length for 'BLAKE2b' is 512 bits",
+                )
+                .into());
+            }
+            let length = length_u128 as usize;
+            calculate_blake2b_length(length)
+        }
+        Err(_) => {
+            show_error!("invalid length: '{length_str}'");
+            Err(io::Error::new(io::ErrorKind::InvalidInput, "invalid length").into())
+        }
+    }
+}
+
 /// Calculates the length of the digest.
 pub fn calculate_blake2b_length(length: usize) -> UResult<Option<usize>> {
     match length {
         0 => Ok(None),
-        n if n % 8 != 0 => {
-            show_error!("invalid length: \u{2018}{length}\u{2019}");
-            Err(io::Error::new(io::ErrorKind::InvalidInput, "length is not a multiple of 8").into())
-        }
         n if n > 512 => {
-            show_error!("invalid length: \u{2018}{length}\u{2019}");
+            show_error!("invalid length: '{length}'");
             Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
-                "maximum digest length for \u{2018}BLAKE2b\u{2019} is 512 bits",
+                "maximum digest length for 'BLAKE2b' is 512 bits",
             )
             .into())
         }
+        n if n % 8 != 0 => {
+            show_error!("invalid length: '{length}'");
+            Err(io::Error::new(io::ErrorKind::InvalidInput, "length is not a multiple of 8").into())
+        }
         n => {
             // Divide by 8, as our blake2b implementation expects bytes instead of bits.
             if n == 512 {
@@ -1214,6 +1240,78 @@ pub fn calculate_blake2b_length(length: usize) -> UResult<Option<usize>> {
     }
 }
 
+/// Validate BLAKE2b length with Fluent error messages
+/// This function is used by utilities that need localized error messages
+pub fn validate_blake2b_length(
+    length_str: &str,
+    utility_name: &str,
+) -> UResult<Option<usize>> {
+    // First try to parse as u128 to handle very large numbers
+    match length_str.parse::<u128>() {
+        Ok(length_u128) => {
+            if length_u128 > usize::MAX as u128 {
+                // For very large numbers, always show the max length error
+                // Use the original string to avoid precision issues
+                let error_key = format!("{}-error-invalid-length", utility_name);
+                let max_key = format!("{}-error-max-digest-length", utility_name);
+                show_error!(
+                    "{}",
+                    translate!(&error_key, "length" => DisplayQuotable::quote(length_str))
+                );
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    translate!(&max_key, "algorithm" => "BLAKE2b", "max_bits" => 512),
+                )
+                .into());
+            }
+            let length = length_u128 as usize;
+            match length {
+                0 => Ok(None),
+                n if n > 512 => {
+                    let error_key = format!("{}-error-invalid-length", utility_name);
+                    let max_key = format!("{}-error-max-digest-length", utility_name);
+                    show_error!(
+                        "{}",
+                        translate!(&error_key, "length" => DisplayQuotable::quote(length_str))
+                    );
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        translate!(&max_key, "algorithm" => "BLAKE2b", "max_bits" => 512),
+                    )
+                    .into())
+                }
+                n if n % 8 != 0 => {
+                    let error_key = format!("{}-error-invalid-length", utility_name);
+                    show_error!(
+                        "{}",
+                        translate!(&error_key, "length" => DisplayQuotable::quote(length_str))
+                    );
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "length is not a multiple of 8",
+                    )
+                    .into())
+                }
+                n => {
+                    // Divide by 8, as our blake2b implementation expects bytes instead of bits.
+                    if n == 512 {
+                        // When length is 512, it is blake2b's default.
+                        // So, don't show it
+                        Ok(None)
+                    } else {
+                        Ok(Some(n / 8))
+                    }
+                }
+            }
+        }
+        Err(_) => {
+            let error_key = format!("{}-error-invalid-length", utility_name);
+            show_error!("{}", translate!(&error_key, "length" => length_str.quote()));
+            Err(io::Error::new(io::ErrorKind::InvalidInput, "invalid length").into())
+        }
+    }
+}
+
 pub fn unescape_filename(filename: &[u8]) -> (Vec<u8>, &'static str) {
     let mut unescaped = Vec::with_capacity(filename.len());
     let mut byte_iter = filename.iter().peekable();

tests/by-util/test_cksum.rs

@@ -394,6 +394,31 @@ fn test_length_greater_than_512() {
         .stderr_is_fixture("length_larger_than_512.expected");
 }
 
+#[test]
+fn test_length_513_shows_max_length_error() {
+    // Test that length 513 shows "maximum digest length" error before "not multiple of 8" error
+    new_ucmd!()
+        .arg("--length=513")
+        .arg("--algorithm=blake2b")
+        .arg("/dev/null")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("maximum digest length for 'BLAKE2b' is 512 bits");
+}
+
+#[test]
+fn test_length_very_large_number() {
+    // Test that very large numbers like UINTMAX_OFLOW show proper error messages
+    new_ucmd!()
+        .arg("--length=18446744073709551616")
+        .arg("--algorithm=blake2b")
+        .arg("/dev/null")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("invalid length: '18446744073709551616'")
+        .stderr_contains("maximum digest length for 'BLAKE2b' is 512 bits");
+}
+
 #[test]
 fn test_length_is_zero() {
     new_ucmd!()

tests/by-util/test_hashsum.rs

@@ -269,7 +269,24 @@ fn test_invalid_b2sum_length_option_too_large() {
         .ccmd("b2sum")
         .arg("--length=513")
         .arg(at.subdir.join("testf"))
-        .fails_with_code(1);
+        .fails_with_code(1)
+        .stderr_contains("maximum digest length for 'BLAKE2b' is 512 bits");
+}
+
+#[test]
+fn test_invalid_b2sum_length_very_large_number() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=18446744073709551616")
+        .arg(at.subdir.join("testf"))
+        .fails_with_code(1)
+        .stderr_contains("invalid length: '18446744073709551616'")
+        .stderr_contains("maximum digest length for 'BLAKE2b' is 512 bits");
 }
 
 #[test]

tests/fixtures/cksum/length_larger_than_512.expected

@@ -1,2 +1,2 @@
-cksum: invalid length: ‘1024’
-cksum: maximum digest length for ‘BLAKE2b’ is 512 bits
+cksum: invalid length: '1024'
+cksum: maximum digest length for 'BLAKE2b' is 512 bits