[go: up one dir, main page]

keyring 2.0.0-rc.1

Cross-platform library for managing passwords/credentials
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

extern crate keyring;

use clap::Parser;
use rpassword::prompt_password;

use keyring::{Entry, Error};

#[derive(Debug, Parser)]
#[clap(author = "github.com/hwchen/keyring-rs")]
/// Keyring CLI: A command-line interface to platform secure storage
pub struct Cli {
    #[clap(short, long, value_parser)]
    /// The target for the entry.
    pub target: Option<String>,

    #[clap(short, long, value_parser, default_value = "keyring-cli")]
    /// The service name for the entry
    pub service: String,

    #[clap(short, long, value_parser, default_value = "")]
    /// The user to store/retrieve the password for [default: user's login name]
    pub user: String,

    #[clap(subcommand)]
    pub command: Command,
}

#[derive(Debug, Parser)]
pub enum Command {
    /// Set the password in the secure store
    Set {
        #[clap(value_parser)]
        /// The password to set. If not specified, the password
        /// is collected interactively from the terminal
        password: Option<String>,
    },
    /// Get the password from the secure store
    Get,
    /// Delete the entry from the secure store
    Delete,
}

fn main() {
    let mut args: Cli = Cli::parse();
    if args.user.is_empty() {
        args.user = whoami::username()
    }
    execute_args(&args);
}

fn execute_args(args: &Cli) {
    let entry = if let Some(target) = &args.target {
        Entry::new_with_target(target, &args.service, &args.user)
            .unwrap_or_else(|err| panic!("Couldn't create entry: {err:?}"))
    } else {
        Entry::new(&args.service, &args.user)
            .unwrap_or_else(|err| panic!("Couldn't create entry: {err:?}"))
    };
    match &args.command {
        Command::Set {
            password: Some(password),
        } => execute_set_password(args, &entry, password),
        Command::Set { password: None } => {
            if let Ok(password) = prompt_password("Password: ") {
                execute_set_password(args, &entry, &password)
            } else {
                eprintln!("(Failed to read password, so none set.)")
            }
        }
        Command::Get => execute_get_password(args, &entry),
        Command::Delete => execute_delete_password(args, &entry),
    }
}

fn execute_set_password(args: &Cli, entry: &Entry, password: &str) {
    match entry.set_password(password) {
        Ok(()) => {
            println!(
                "(Password for '{}@{}' set successfully)",
                &args.user, &args.service
            )
        }
        Err(err) => {
            eprintln!(
                "Couldn't set password for '{}@{}': {:?}",
                &args.user, &args.service, err
            );
        }
    }
}

fn execute_get_password(args: &Cli, entry: &Entry) {
    match entry.get_password() {
        Ok(password) => {
            println!(
                "The password for '{}@{}' is '{}'",
                &args.user, &args.service, &password
            );
        }
        Err(Error::NoEntry) => {
            eprintln!("(No password found for '{}@{}')", &args.user, &args.service);
        }
        Err(err) => {
            eprintln!(
                "Couldn't get password for '{}@{}': {:?}",
                &args.user, &args.service, err
            );
        }
    }
}

fn execute_delete_password(args: &Cli, entry: &Entry) {
    match entry.delete_password() {
        Ok(()) => println!("(Password for '{}@{}' deleted)", &args.user, &args.service),
        Err(Error::NoEntry) => {
            eprintln!("(No password for '{}@{}' found)", &args.user, &args.service);
        }
        Err(err) => {
            eprintln!(
                "Couldn't delete password for '{}@{}': {:?}",
                &args.user, &args.service, err
            );
        }
    }
}