passgen-cli 0.2.0

Password generator with a regular-expression-like syntax
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
136
137
138
139

use clap::{Args, Parser, ValueEnum};
use passgen::random::Random;
use std::{path::PathBuf, str::FromStr};

#[derive(Clone)]
pub struct WordlistSpec {
    pub name: String,
    pub path: PathBuf,
}

#[derive(thiserror::Error, Debug)]
pub enum WordlistSpecParseError {
    #[error("missing colon")]
    MissingColon,
}

impl FromStr for WordlistSpec {
    type Err = WordlistSpecParseError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let (name, path) = input
            .split_once(':')
            .ok_or(WordlistSpecParseError::MissingColon)?;
        Ok(Self {
            name: name.into(),
            path: path.into(),
        })
    }
}

#[derive(ValueEnum, Clone)]
pub enum Format {
    Text,
    Json,
    Csv,
}

/// Generate random sequences from a regex-like pattern.
#[derive(Parser)]
#[command(author, version)]
pub struct Options {
    /// Use the given named preset instead of specifying a pattern.
    #[clap(short, long)]
    pub preset: Option<String>,

    /// Amount of sequences to generate.
    #[clap(short, long, default_value = "1")]
    pub amount: usize,

    /// Source of randomness to use.
    ///
    /// Possible sources are:
    ///
    /// `system`: use the secure system random number generator (default)
    ///
    /// `null`: use a dummy randomness source (insecure)
    ///
    /// `xoshiro:<seed>`: use the xoshiro randomness source with the given seed (insecure)
    #[clap(short, long)]
    pub random: Option<Random>,

    #[clap(flatten)]
    pub master: MasterOptions,

    /// Output format to use when emitting generated sequences.
    ///
    /// This defaults to a text-based format, but you can also specify 'json' or 'csv'.
    #[clap(short, long, default_value = "text")]
    pub format: Format,

    /// Amount of threads to use, enables multi-threaded generation.
    #[clap(short = 'j', long)]
    pub threads: Option<usize>,

    /// Enable debug log output.
    #[clap(short, long)]
    pub verbose: Option<usize>,

    /// Load wordlist for generating wordlist or markov-chain based words.
    ///
    /// The format of this is `<name>:<path>`. For example, to load a wordlist with the name
    /// `english` that is located at `/usr/share/dict/words`, specify `-w
    /// english:/usr/share/dict/words`.
    #[clap(short, long)]
    pub wordlist: Vec<WordlistSpec>,

    #[clap(required_unless_present("preset"))]
    pub pattern: Option<String>,

    /// Load configuration file.
    pub config: Vec<PathBuf>,
}

/// Options for master-pass mode.
#[derive(Args)]
#[group()]
pub struct MasterOptions {
    /// Set the master passphrase to use for generating passwords.
    ///
    /// In master passphrase mode, Passgen uses the master passphrase you supply here to generate
    /// deterministic outputs. With this functionality, you can use Passgen as a password manager,
    /// only having to remember a single master passphrase and using it to generate unique
    /// passphrases per domain and login.
    ///
    /// This also enables the master-passphrase randomness source. You cannot combine this with
    /// any other randomness source.
    #[clap(short, long, conflicts_with("random"))]
    pub master: Option<String>,

    /// Set the domain for the master passphrase mode.
    ///
    /// Requires that you specify a master passphrase.
    #[clap(short, long, requires("master"))]
    pub domain: Option<String>,

    /// Set the token for the master passphrase.
    ///
    /// This allows you to generate multiple, unique passphrases for a single domain, for example
    /// if you have multiple accounts.
    #[clap(short, long, requires("master"))]
    pub token: Option<String>,
}

impl Options {
    pub fn random(&self) -> Random {
        self.master
            .random()
            .or(self.random.clone())
            .unwrap_or_default()
    }
}

impl MasterOptions {
    pub fn random(&self) -> Option<Random> {
        self.master
            .as_deref()
            .map(|master| Random::from_master_pass(master, self.domain.as_deref().unwrap_or("")))
    }
}