xpwd 1.0.4

A simple and quick password generator for enhanced security.
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

//!# DigitShield crate
//! A command-line password generator built with Rust, offering a swift and effortless solution for creating passwords of varying strengths. Cure your password creation woes with a single command!
use ansi_term::Color::Blue;
use clap::Parser;
use clipboard::ClipboardContext;
use clipboard::ClipboardProvider;
use colored::Colorize;
use notify_rust::Notification;
use xpwd::*;

#[derive(Parser)]
#[clap(name = "xpwd")]
struct Opts {
    #[clap(subcommand)]
    command: Command,
}

#[derive(Parser)]
#[command(
    version,
    about = "Fast, secure, and universal password generator.",
    author = "Code0408"
)]
enum Command {
    #[clap(about = "Generate a secure password of specified length and strength.")]
    Pwd(PasswordArgs),
    #[clap(about = "Check the strength of the password you entered.")]
    Str(StrengthArgs),
    #[clap(about = "Generate a random short passphrase password based on a dictionary.")]
    Pas(PassphraseArgs),
}

#[derive(Parser)]
struct PasswordArgs {
    #[arg(
        short = 'l',
        long = "len",
        default_value_t = 8,
        help = "Length of password"
    )]
    len: usize,

    #[arg(
        short = 'c',
        long = "complex",
        default_value_t = String::from("m"),
        help="Complexity of the password"
    )]
    complex: String,
}

#[derive(Parser)]
struct StrengthArgs {
    #[arg(
        short = 'p',
        long = "password",
        help = "Check strength of your password"
    )]
    password: String,
}

#[derive(Parser)]
struct PassphraseArgs {
    #[arg(short = 'w', long = "world", default_value_t = 3)]
    num_words: usize,
    #[arg(
        short = 'd',
        long = "dictionary",
        help = "Specify the path to your phrase dictionary file."
    )]
    dictionary: String,
}

fn print_infos() {
    println!(
        "{}",
        Blue.paint(
            r#"
               _______           ______
|\     /|     (  ____ )|\     /|(  __  \
( \   / )     | (    )|| )   ( || (  \  )
 \ (_) /_____ | (____)|| | _ | || |   ) |
  ) _ ((_____)|  _____)| |( )| || |   | |
 / ( ) \      | (      | || || || |   ) |
( /   \ )     | )      | () () || (__/  )
|/     \|     |/       (_______)(______/
        "#
        )
    );
}

fn main() {
    print_infos();

    let opts = Opts::parse();

    match opts.command {
        Command::Pwd(PasswordArgs) => {
            let pwd = gen_password(PasswordArgs.len, &PasswordArgs.complex);
            let cmatch = match PasswordArgs.complex.as_str() {
                "s" => "simple".to_string(),
                "m" => "medium".to_string(),
                "c" => "complex".to_string(),
                _ => "unknown".to_string(),
            };

            let datas = vec![(PasswordArgs.len.to_string(), cmatch, pwd.clone())];

            print_data_tables(&datas);
            print_password_strength(pwd.as_str());
            println!("\n\n");

            let mut ctx: ClipboardContext = ClipboardProvider::new().unwrap();
            ctx.set_contents(pwd.to_owned()).unwrap();

            if let Err(e) = Notification::new()
                .body("The password has benn copied to the clipboard!")
                .show()
            {
                eprintln!("err:{}", e);
            }
        }
        Command::Str(StrengthArgs) => print_password_strength(&StrengthArgs.password),

        Command::Pas(PassphraseArgs) => {
            //let path = "resources/dictionary.txt";
            let dic = load_dictionary(&PassphraseArgs.dictionary);
            let res = generate_random_passphrase(&dic, PassphraseArgs.num_words);

            print_data_tables(&vec![(
                PassphraseArgs.num_words.to_string(),
                PassphraseArgs.dictionary.to_string(),
                res.to_string(),
            )]);
        }
    }
}