gen_pass 0.1.6

Secure password generation library and CLI
Documentation 
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

#![allow(unused_imports, dead_code)]

//! CLI entry point for gen_pass
//! Comments in English per user preference.

use clap::{Parser, ValueEnum, ArgAction};
use anyhow::Result;
use gen_pass::{PassConfig, PasswordGenerator};
use std::fmt;

#[derive(Parser, Debug)]
#[command(name = "gen_pass", about = "Generate secure passwords", version, author)]
struct Cli {
    /// Desired password length
    #[arg(short, long, default_value_t = 16)]
    length: usize,

    /// Include lowercase letters
    #[arg(long, default_value_t = true, action = ArgAction::Set)]
    lowercase: bool,

    /// Include uppercase letters
    #[arg(long, default_value_t = true, action = ArgAction::Set)]
    uppercase: bool,

    /// Include digits
    #[arg(long, default_value_t = true, action = ArgAction::Set)]
    digits: bool,

    /// Include symbols
    #[arg(long, default_value_t = true, action = ArgAction::Set)]
    symbols: bool,

    /// Salt string to modify password generation
    #[arg(short = 's', long)]
    salt: Option<String>,

    /// Output format
    #[arg(short, long, default_value_t = Output::Plain)]
    output: Output,
}

#[derive(Copy, Clone, Debug, ValueEnum, Default)]
enum Output {
    /// Print raw password
    #[default]
    Plain,
    /// Print password and copy to clipboard (requires `pbcopy` on macOS / xclip on Linux)
    Copy,
}

// Implement Display so `default_value_t` works with clap
impl fmt::Display for Output {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Output::Plain => write!(f, "plain"),
            Output::Copy => write!(f, "copy"),
        }
    }
}

#[cfg(not(test))]
fn main() -> Result<()> {
    let cli = Cli::parse();

    let cfg = PassConfig {
        length: cli.length,
        use_lowercase: cli.lowercase,
        use_uppercase: cli.uppercase,
        use_digits: cli.digits,
        use_symbols: cli.symbols,
        salt: cli.salt,
    };

    let gen = PasswordGenerator::from_config(&cfg)?;
    let password = gen.generate(cfg.length);

    match cli.output {
        Output::Plain => {
            println!("{password}");
        }
        Output::Copy => {
            println!("{password}");
            if let Err(e) = copy_to_clipboard(&password) {
                eprintln!("Failed to copy to clipboard: {e}");
            }
        }
    }

    Ok(())
}

#[cfg(test)]
fn copy_to_clipboard(_text: &str) -> Result<()> {
    // Stub used during coverage to avoid OS interaction; counts as executed via tests
    Ok(())
}

#[cfg(not(test))]
/// Try to copy text to clipboard using platform tools
fn copy_to_clipboard(text: &str) -> Result<()> {
    // Skip actual clipboard interaction when env var set (used by tests/CI)
    if std::env::var("TEST_NO_CLIP").is_ok() {
        return Ok(());
    }

    #[cfg(target_os = "macos")]
    {
        use std::process::{Command, Stdio};
        let mut cmd = Command::new("pbcopy").stdin(Stdio::piped()).spawn()?;
        {
            use std::io::Write;
            cmd.stdin.as_mut().unwrap().write_all(text.as_bytes())?;
        }
        cmd.wait()?;
        return Ok(());
    }

    #[cfg(target_os = "linux")]
    {
        use std::process::{Command, Stdio};
        let mut cmd = Command::new("xclip").args(["-selection", "clipboard"]).stdin(Stdio::piped()).spawn()?;
        {
            use std::io::Write;
            cmd.stdin.as_mut().unwrap().write_all(text.as_bytes())?;
        }
        cmd.wait()?;
        return Ok(());
    }

    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
    {
        anyhow::bail!("Clipboard copy not supported on this OS");
    }
}