passless-rs 0.12.0

FIDO2 security token emulator
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

//! Directory created, ready for GPG key selection

use super::gpg_key_selected::GpgKeySelected;
use crate::notification::{
    YesNoResult, show_error_notification, show_info_notification, show_yes_no_notification,
};

use crate::storage::pass::GpgBackend;

use passless_core::error::{Error, Result};

use std::path::PathBuf;

use log::{debug, info, warn};
use prs_lib::crypto::{self, Config, IsContext, Proto};

pub struct DirectoryCreated {
    pub(super) store_path: PathBuf,
    pub(super) gpg_backend: GpgBackend,
}

impl DirectoryCreated {
    pub fn select_gpg_key(self) -> Result<GpgKeySelected> {
        let fingerprint = select_gpg_key_interactive(self.gpg_backend)?;

        Ok(GpgKeySelected {
            store_path: self.store_path,
            fingerprint,
        })
    }
}

fn select_gpg_key_interactive(_gpg_backend: GpgBackend) -> Result<String> {
    let config = Config {
        proto: Proto::Gpg,
        gpg_tty: false,
        verbose: false,
    };

    let mut context = crypto::context(&config).map_err(|e| {
        let msg = format!("Failed to create crypto context: {:?}", e);
        let _ = show_error_notification("GPG Error", &msg);
        Error::Storage(msg)
    })?;

    let private_keys = context.keys_private().map_err(|e| {
        let msg = format!("Failed to list GPG keys: {:?}", e);
        let _ = show_error_notification("GPG Error", &msg);
        Error::Storage(msg)
    })?;

    if private_keys.is_empty() {
        warn!("No GPG keys found");
        let _ = show_error_notification(
            "No GPG Keys Found",
            "No GPG keys found on your system.\n\n\
             Please generate a GPG key first using:\n\
             gpg --full-generate-key\n\n\
             Then restart passless to complete initialization.",
        );
        return Err(Error::Config("No GPG keys found".to_string()));
    }

    if private_keys.len() == 1 {
        let key = &private_keys[0];
        let fingerprint = key.fingerprint(false);
        info!("Using only available GPG key: {}", fingerprint);

        return match show_yes_no_notification(
            "GPG Key Selection",
            &format!(
                "Found GPG key:\n{}\n\nUse this key for the password store?",
                key
            ),
        ) {
            Ok(YesNoResult::Accepted) => Ok(fingerprint),
            Ok(YesNoResult::Denied) => Err(Error::Config("Key selection cancelled".to_string())),
            Err(e) => Err(Error::Config(format!(
                "Failed to show key selection: {}",
                e
            ))),
        };
    }

    info!("Multiple GPG keys found, prompting user to select");

    let key_list: String = private_keys
        .iter()
        .enumerate()
        .map(|(i, k)| format!("{}. {}", i + 1, k))
        .collect::<Vec<_>>()
        .join("\n");

    let _ = show_info_notification(
        "Multiple GPG Keys Found",
        &format!(
            "Found {} GPG keys on your system:\n\n{}\n\nYou will be asked to select one.",
            private_keys.len(),
            key_list
        ),
    );

    for (i, key) in private_keys.iter().enumerate() {
        let fingerprint = key.fingerprint(false);
        let short_fingerprint = key.fingerprint(true);

        match show_yes_no_notification(
            &format!("GPG Key Selection ({}/{})", i + 1, private_keys.len()),
            &format!(
                "Use this GPG key?\n\n{}\n\nFingerprint: {}",
                key, short_fingerprint
            ),
        ) {
            Ok(YesNoResult::Accepted) => {
                info!("User selected GPG key: {}", fingerprint);
                return Ok(fingerprint);
            }
            Ok(YesNoResult::Denied) => {
                debug!("User declined key {}, showing next", i + 1);
                continue;
            }
            Err(e) => {
                warn!("Failed to show key selection: {}", e);
                return Err(Error::Config(format!(
                    "Failed to show key selection: {}",
                    e
                )));
            }
        }
    }

    warn!("No GPG key was selected");
    let _ = show_error_notification(
        "No Key Selected",
        "No GPG key was selected. Initialization cancelled.",
    );
    Err(Error::Config("No key selected".to_string()))
}