Merge pull request #184 from dbohdan/hash-file-flag

Add flag `--hash-file`

Author: ifd3f

README.md

@@ -19,6 +19,7 @@ Options:
   -o <OUT>                         Where to write the output. If not supplied, we will search for possible disks and ask you for where you want to burn
   -z, --compression <COMPRESSION>  What compression format the input file is in [default: ask] [possible values: ask, auto, none, gz, bz2, xz]
   -s, --hash <HASH>                The hash of the input file. For more information, see long help (--help) [default: ask]
+      --hash-file <HASH_FILE>      Where to look for the hash of the input file
       --hash-of <HASH_OF>          Is the hash calculated from the raw file, or the compressed file? [possible values: raw, compressed]
       --show-all-disks             If provided, we will show all disks, removable or not
       --interactive <INTERACTIVE>  If we should run in interactive mode or not [default: auto] [possible values: auto, always, never]
@@ -46,7 +47,7 @@ Options:
 There are a couple of ways to install Caligula.
 
 - **Binary release:** You can download pre-built binaries from [the latest Github release](https://github.com/ifd3f/caligula/releases/latest).
-- **Arch Linux:** 
+- **Arch Linux:**
   - [Official repository](https://archlinux.org/packages/extra/x86_64/caligula): `pacman -S caligula`
   - [caligula-bin on the AUR](https://aur.archlinux.org/packages/caligula-bin): We also automatically publish binaries with every release.
   - [caligula-git on the AUR](https://aur.archlinux.org/packages/caligula-git): Build from latest commit on `main` branch

src/hashfile.rs

@@ -34,12 +34,12 @@ const HASH_FILES: [(HashAlg, &str); 24] = [
     (HashAlg::Sha512, "SHA512SUMS"),
 ];
 
-pub fn find_hash(input: &Path) -> Option<(HashAlg, &str, Vec<u8>)> {
+pub fn find_hash_in_standard_files(input: &Path) -> Option<(Vec<HashAlg>, &str, Vec<u8>)> {
     for (alg, hash_file) in HASH_FILES {
         let hash_filepath = input.parent()?.join(hash_file);
         match File::open(&hash_filepath) {
             Ok(file) => match parse_hashfile(BufReader::new(file), input.file_name()?.to_str()?) {
-                Ok(Some(expected_hash)) => return Some((alg, hash_file, expected_hash)),
+                Ok(Some(expected_hash)) => return Some((vec![alg], hash_file, expected_hash)),
                 Ok(None) => tracing::warn!("Hash not found in {}", hash_filepath.display()),
                 Err(e) => tracing::warn!("{e}"),
             },
@@ -50,6 +50,28 @@ pub fn find_hash(input: &Path) -> Option<(HashAlg, &str, Vec<u8>)> {
     None
 }
 
+pub fn find_hash_in_user_file<'a>(
+    input: &Path,
+    hash_filepath: &'a Path,
+) -> Option<(Vec<HashAlg>, &'a str, Vec<u8>)> {
+    match File::open(&hash_filepath) {
+        Ok(file) => match parse_hashfile(BufReader::new(file), input.file_name()?.to_str()?) {
+            Ok(Some(expected_hash)) => {
+                return Some((
+                    HashAlg::detect_from_length(expected_hash.len()).to_vec(),
+                    hash_filepath.file_name()?.to_str()?,
+                    expected_hash,
+                ));
+            }
+            Ok(None) => tracing::warn!("Hash not found in {}", hash_filepath.display()),
+            Err(e) => tracing::warn!("{e}"),
+        },
+        Err(e) => tracing::warn!("{e}"),
+    }
+
+    None
+}
+
 fn parse_hashfile(hash_file: impl BufRead, input_file: &str) -> anyhow::Result<Option<Vec<u8>>> {
     for line in hash_file.lines() {
         match line?.split_once(char::is_whitespace) {

src/ui/cli.rs

@@ -69,6 +69,10 @@ pub struct BurnArgs {
     )]
     pub hash: HashArg,
 
+    /// Where to look for the hash of the input file.
+    #[arg(long, value_parser = parse_path_exists)]
+    pub hash_file: Option<PathBuf>,
+
     /// Is the hash calculated from the raw file, or the compressed file?
     #[arg(long)]
     pub hash_of: Option<HashOf>,

src/ui/simple_ui/ask_hash.rs

@@ -13,31 +13,53 @@ use inquire::{Confirm, Select, Text};
 use crate::{
     compression::{decompress, CompressionFormat},
     hash::{parse_hash_input, FileHashInfo, HashAlg, Hashing},
-    hashfile::find_hash,
+    hashfile::{find_hash_in_standard_files, find_hash_in_user_file},
     ui::cli::{BurnArgs, HashArg, HashOf},
 };
 
 #[tracing::instrument(skip_all, fields(cf))]
 pub fn ask_hash(args: &BurnArgs, cf: CompressionFormat) -> anyhow::Result<Option<FileHashInfo>> {
-    let hash_params = match &args.hash {
-        HashArg::Skip => None,
-        HashArg::Ask => {
-            match find_hash(&args.input) {
-                Some((alg, expected_hashfile, expected_hash))
-                if Confirm::new(&format!(
-                    "Detected hash file {expected_hashfile} in the directory. Do you want to use it?"
-                ))
-                .with_default(true)
-                .prompt()? =>
+    let hash_params = match (&args.hash, &args.hash_file) {
+        (_, Some(hash_file)) => {
+            let Some((algs, _, expected_hash)) = find_hash_in_user_file(&args.input, hash_file)
+            else {
+                eprintln!(
+                    "Could not parse {} as a valid hash file!",
+                    hash_file.to_string_lossy()
+                );
+                exit(-1);
+            };
+
+            eprintln!(
+                "Using user-provided hash file: {}",
+                hash_file.to_string_lossy()
+            );
+            Some(BeginHashParams {
+                expected_hash,
+                alg: ask_alg(&algs)?,
+                hasher_compression: ask_hasher_compression(cf, args.hash_of)?,
+            })
+        }
+        (HashArg::Skip, _) => None,
+        (HashArg::Ask, _) => {
+            match find_hash_in_standard_files(&args.input) {
+                Some((algs, expected_hashfile, expected_hash))
+                    if Confirm::new(&format!(
+                        "Detected hash file {expected_hashfile} in the directory. Do you want to use it?"
+                    ))
+                    .with_default(true)
+                    .prompt()? =>
+                {
                     Some(BeginHashParams {
                         expected_hash,
-                        alg,
+                        alg: ask_alg(&algs)?,
                         hasher_compression: ask_hasher_compression(cf, args.hash_of)?,
-                    }),
-                _ => ask_hash_loop(cf)?
+                    })
+                }
+                _ => ask_hash_loop(cf)?,
             }
         }
-        HashArg::Hash { alg, expected_hash } => Some(BeginHashParams {
+        (HashArg::Hash { alg, expected_hash }, _) => Some(BeginHashParams {
             expected_hash: expected_hash.clone(),
             alg: *alg,
             hasher_compression: ask_hasher_compression(cf, args.hash_of)?,
@@ -109,32 +131,37 @@ fn ask_hash_once(cf: CompressionFormat) -> anyhow::Result<BeginHashParams> {
         },
     };
 
-    let alg = match &algs[..] {
+    let alg = ask_alg(&algs)?;
+
+    let hasher_compression = ask_hasher_compression(cf, None)?;
+
+    Ok(BeginHashParams {
+        expected_hash: hash,
+        alg,
+        hasher_compression,
+    })
+}
+
+#[tracing::instrument]
+fn ask_alg(algs: &[HashAlg]) -> anyhow::Result<HashAlg> {
+    match algs {
         &[] => {
             eprintln!("Could not detect the hash algorithm from your hash!");
             Err(Recoverable::AskAgain)?
         }
         &[only_alg] => {
             eprintln!("Detected {}", only_alg);
-            only_alg
+            Ok(only_alg)
         }
         multiple => {
             let ans = Select::new("Which algorithm is it?", multiple.into()).prompt_skippable()?;
             if let Some(alg) = ans {
-                alg
+                Ok(alg)
             } else {
                 Err(Recoverable::AskAgain)?
             }
         }
-    };
-
-    let hasher_compression = ask_hasher_compression(cf, None)?;
-
-    Ok(BeginHashParams {
-        expected_hash: hash,
-        alg,
-        hasher_compression,
-    })
+    }
 }
 
 #[tracing::instrument]