argon2-cli 0.1.1

Generate Argon2 hashes from command line
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use clap::{ArgGroup, Parser};
use std::io::{self, BufRead, IsTerminal, Write};
use argon2::password_hash::SaltString;

// Usage:  argon2 [-h] salt [-i|-d|-id] [-t iterations] [-m log2(memory in KiB) | -k memory in KiB] [-p parallelism] [-l hash length] [-e|-r] [-v (10|13)]
#[derive(Parser, Debug)]
#[command(name = "argon2", about = "(Rust implementation)", disable_help_flag = false)]
#[command(group(ArgGroup::new("variant").args(&["i", "d", "id"])))]
#[command(group(ArgGroup::new("memory").args(&["m", "k"])))]
#[command(group(ArgGroup::new("output_format").args(&["e", "r"])))]
struct Args {
    /// The salt to use, at least 8 characters
    salt: String,

    /// Use Argon2i (this is the default)
    #[arg(short = 'i', long, default_value_t = false)]
    i: bool,

    /// Use Argon2d instead of Argon2i
    #[arg(short = 'd', long, default_value_t = false)]
    d: bool,

    /// Use Argon2id instead of Argon2i
    #[arg(long = "id", default_value_t = false)]
    id: bool,

    /// Sets the number of iterations to N (default = 3)
    #[arg(short = 't', default_value_t = 3)]
    t: u32,

    /// Sets the memory usage of 2^N KiB (default 12)
    #[arg(short = 'm', default_value_t = 12)]
    m: u32,

    /// Sets the memory usage of N KiB (default 4096)
    #[arg(short = 'k')]
    k: Option<u32>,

    /// Sets parallelism to N threads (default 1)
    #[arg(short = 'p', default_value_t = 1)]
    p: u32,

    /// Sets hash output length to N bytes (default 32)
    #[arg(short = 'l', default_value_t = 32)]
    l: u32,

    /// Output only encoded hash
    #[arg(short = 'e', default_value_t = false)]
    e: bool,

    /// Output only the raw bytes of the hash
    #[arg(short = 'r', default_value_t = false)]
    r: bool,

    /// Argon2 version (defaults to the most recent version, currently 13)
    #[arg(short = 'v', default_value_t = 13)]
    v: u32, // Unimplemented: version selection not supported, always uses v13
}

fn get_input() -> io::Result<String> {
    let stdin = io::stdin();

    if stdin.is_terminal() {
        print!("Enter password: ");
        io::stdout().flush()?;

        let mut input = String::new();
        stdin.read_line(&mut input)?;
        Ok(input.trim().to_string())
    } else {
        let lines: Vec<String> = stdin.lock().lines().collect::<Result<_, _>>()?;
        Ok(lines.join("\n"))
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Handle the non-standard `-id` flag which conflicts with clap's short flag clustering
    let args_env = std::env::args();
    let new_args: Vec<String> = args_env.map(|arg| {
        if arg == "-id" {
            "--id".to_string()
        } else {
            arg
        }
    }).collect();

    let args = Args::parse_from(new_args);

    let password = get_input().unwrap_or_else(|e| {
        eprintln!("Error reading input: {}", e);
        std::process::exit(1);
    });
    
    // Select algorithm variant
    let algorithm = if args.d {
        argon2::Algorithm::Argon2d
    } else if args.id {
        argon2::Algorithm::Argon2id
    } else {
        argon2::Algorithm::Argon2i
    };

    // Calculate memory cost
    let memory_kib = if let Some(k) = args.k {
        k
    } else {
        1 << args.m
    };

    let params = argon2::Params::new(
        memory_kib,
        args.t,
        args.p,
        Some(args.l as usize),
    ).map_err(|e| format!("Invalid parameters: {}", e))?;

    // Encode salt to PHC string format
    let salt_string = SaltString::encode_b64(args.salt.as_bytes())
        .map_err(|e| format!("Invalid salt: {}", e))?;

    let argon2 = argon2::Argon2::new(
        algorithm,
        argon2::Version::V0x13,
        params,
    );

    let start = std::time::Instant::now();
    
    let password_bytes = password.as_bytes();
    
    use argon2::PasswordHasher;
    let password_hash = argon2.hash_password(password_bytes, salt_string.as_salt())
        .map_err(|e| format!("Hashing failed: {}", e))?;
    
    let duration = start.elapsed();

    // Generate output based on flags
    if args.e {
        println!("{}", password_hash);
    } else if args.r {
        if let Some(hash) = password_hash.hash {
             io::stdout().write_all(hash.as_bytes())?;
        }
    } else {
        println!("Type:           {:?}", algorithm);
        println!("Iterations:     {}", args.t);
        println!("Memory:         {} KiB", memory_kib);
        println!("Parallelism:    {}", args.p);
        
        if let Some(hash) = password_hash.hash {
            println!("Hash:           {}", hex::encode(hash.as_bytes()));
        }
        println!("Encoded:        {}", password_hash);
        
        println!("{:.3} seconds", duration.as_secs_f64());
        println!("Verification ok");
    }

    Ok(())
}