shaha 0.2.1

Hash database builder and reverse lookup tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::io::{self, BufRead, IsTerminal};

use anyhow::{anyhow, bail, Result};
use clap::{Args, ValueEnum};

use crate::hasher;

#[derive(Args)]
pub struct HashArgs {
    /// Text to hash (reads from stdin if omitted)
    pub input: Option<String>,

    /// Hash algorithms to use
    #[arg(short, long, default_value = "sha256", value_parser = hasher::algo_value_parser())]
    pub algo: Vec<String>,

    /// Output format
    #[arg(short, long, default_value = "plain")]
    pub format: OutputFormat,
}

#[derive(Clone, ValueEnum)]
pub enum OutputFormat {
    Plain,
    Json,
}

pub fn run(args: HashArgs) -> Result<()> {
    let hashers: Vec<Box<dyn hasher::Hasher>> = args
        .algo
        .iter()
        .map(|name| {
            hasher::get_hasher(name)
                .ok_or_else(|| anyhow!("Unsupported algorithm: {name}"))
        })
        .collect::<Result<Vec<_>>>()?;

    let inputs = collect_inputs(&args)?;

    if inputs.is_empty() {
        bail!("No input provided. Pass text as argument or pipe via stdin.");
    }

    match args.format {
        OutputFormat::Plain => print_plain(&inputs, &hashers),
        OutputFormat::Json => print_json(&inputs, &hashers)?,
    }

    Ok(())
}

fn collect_inputs(args: &HashArgs) -> Result<Vec<String>> {
    if let Some(ref text) = args.input {
        return Ok(vec![text.clone()]);
    }

    if io::stdin().is_terminal() {
        return Ok(vec![]);
    }

    let reader = io::stdin().lock();
    let lines: Vec<String> = reader
        .lines()
        .collect::<std::result::Result<Vec<_>, _>>()?
        .into_iter()
        .filter(|line| !line.is_empty())
        .collect();

    Ok(lines)
}

fn print_plain(inputs: &[String], hashers: &[Box<dyn hasher::Hasher>]) {
    let single_algo = hashers.len() == 1;
    let single_input = inputs.len() == 1;

    for input in inputs {
        for hasher in hashers {
            let hash = hex::encode(hasher.hash(input.as_bytes()));

            if single_input && single_algo {
                println!("{hash}");
            } else if single_algo {
                println!("{hash}  {input}");
            } else if single_input {
                println!("{hash}  {}", hasher.name());
            } else {
                println!("{hash}  {}  {input}", hasher.name());
            }
        }
    }
}

fn print_json(inputs: &[String], hashers: &[Box<dyn hasher::Hasher>]) -> Result<()> {
    #[derive(serde::Serialize)]
    struct JsonHash {
        input: String,
        algorithm: String,
        hash: String,
    }

    let results: Vec<JsonHash> = inputs
        .iter()
        .flat_map(|input| {
            hashers.iter().map(move |hasher| JsonHash {
                input: input.clone(),
                algorithm: hasher.name().to_string(),
                hash: hex::encode(hasher.hash(input.as_bytes())),
            })
        })
        .collect();

    println!("{}", serde_json::to_string_pretty(&results)?);
    Ok(())
}