rs-password-utils 0.2.0

Password utilities, writen in Rust
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

// Copyright 2020 astonbitecode
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
extern crate docopt;
extern crate rpassword;

use docopt::Docopt;
use zeroize::Zeroize;

use rs_password_utils::{dice, pwned};
use std::str::FromStr;

const USAGE: &'static str = "
Password utilities, written in Rust.

Usage:
  rs-password-utils pwned
  rs-password-utils dice [(-w <count>)]
  rs-password-utils [-h]

Options:
  -w --words    The amount of words that should comprise the passphrase
  -h --help     Show this screen.
";

#[tokio::main]
async fn main() -> Result<(), rs_password_utils::PasswordUtilsError> {
    let args = Docopt::new(USAGE)
        .and_then(|dopt| dopt.parse())
        .unwrap_or_else(|e| e.exit());

    if args.find("pwned").unwrap().as_bool() {
        println!("Please type a password and press enter.");
        let mut pass = rpassword::read_password()?;
        pwned::check_pwned(&pass).await.map(|pwned_response| {
            match pwned_response {
                pwned::PwnedResponse::Ok => println!("The password is not found among leaked passwords."),
                pwned::PwnedResponse::Pwned(times) => println!("The password is leaked!!! It was found in {} breaches. Stop using it and replace it with another one!", times)
            }
        })?;
        // Zeroize the password String
        pass.zeroize();
    } else if args.find("dice").unwrap().as_bool() {
        let arg_w = args.find("-w");
        let arg_words = args.find("--words");
        let usize_arg: usize = if (arg_w.is_some() && arg_w.unwrap().as_bool()) ||
            (arg_words.is_some() && arg_words.unwrap().as_bool()) {
            let arg = args.get_str("<count>");
            FromStr::from_str(arg)?
        } else {
            6
        };

        let mut pass = dice::generate(usize_arg);
        println!("{}", pass);
        // Zeroize the password String
        pass.zeroize();
    }

    Ok(())
}