sequoia-sq 1.4.0

Command-line frontends for Sequoia
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

//! Common password-related functionality such as prompting.

use openpgp::crypto::Password;
use openpgp::Result;
use sequoia_openpgp as openpgp;

use crate::Sq;

/// Prompt to repeat a password.
const REPEAT_PROMPT: &str = "Please repeat the password";


/// Wraps `rpassword::prompt_password`.
fn prompt_password(sq: &Sq, prompt: impl ToString) -> Result<String> {
    if sq.batch {
        Err(anyhow::anyhow!("cannot prompt for password in batch mode"))
    } else {
        Ok(rpassword::prompt_password(prompt)?)
    }
}


/// Prompts the user to enter a new password.
///
/// This function is intended for creating artifacts.  For example, if
/// a new key or subkey is generated, or a message should be encrypted
/// using a password.  The cost of mistyping is high, so we prompt
/// twice.
///
/// If the two entered passwords match, the result is returned.
///
/// If the passwords differ or no password was entered, an error
/// message is printed and the process is repeated.
pub fn prompt_for_new(sq: &Sq, reason: &str) -> Result<Password> {
    prompt_for_new_internal(sq, reason, false)
        .map(|p| p.expect("is not None"))
}

/// Prompts the user to enter an optional new password.
///
/// This function is intended for creating artifacts.  For example, if
/// a new key or subkey is generated, or a message should be encrypted
/// using a password.  The cost of mistyping is high, so we prompt
/// twice.
///
/// If the two entered passwords match, the result is returned.  If no
/// password was entered, `Ok(None)` is returned.
///
/// If the passwords differ, an error message is printed and the
/// process is repeated.
pub fn prompt_for_new_or_none(sq: &Sq, reason: &str)
                              -> Result<Option<Password>>
{
    prompt_for_new_internal(sq, reason, true)
}

/// Prompts the user to enter a new password.
///
/// This function is intended for creating artifacts.  For example, if
/// a new key or subkey is generated, or a message should be encrypted
/// using a password.  The cost of mistyping is high, so we prompt
/// twice.
///
/// If the two entered passwords match, the result is returned.  If
/// `allow_none` is `true`, and no password was entered, `Ok(None)` is
/// returned.
///
/// If the passwords differ or `allow_none` is `false` and no password
/// was entered, an error message is printed and the process is
/// repeated.
fn prompt_for_new_internal(
    sq: &Sq,
    reason: &str,
    allow_none: bool,
) -> Result<Option<Password>> {
    let mut prompt = format!("Please enter the password to protect {}", reason);
    if allow_none {
        prompt.push_str(" (press enter to not use a password)");
    }

    let width = prompt.len().max(REPEAT_PROMPT.len());
    let p0 = format!("{:>1$}: ", prompt, width);
    let p1 = format!("{:>1$}: ", REPEAT_PROMPT, width);

    loop {
        let password = prompt_password(sq, &p0)?;

        if password.is_empty() && ! allow_none {
            weprintln!("Password required.  Please try again.");
            weprintln!();
            continue;
        }

        let password_repeat = prompt_password(sq, &p1)?;

        if password != password_repeat {
            weprintln!("The passwords do not match.  Please try again.");
            weprintln!();
            continue;
        }

        return if password.is_empty() {
            Ok(None)
        } else {
            Ok(Some(password.into()))
        };
    }
}

/// Prompts once for a password to unlock an existing object.
///
/// This function is intended for consuming artifacts.  For example,
/// if a key or subkey is locked and must be unlocked, or a message
/// should be decrypted using a password.
pub fn prompt_to_unlock(sq: &Sq, reason: &str) -> Result<Password> {
    let prompt =
        format!("Please enter the password to decrypt {}: ", reason);
    let password = prompt_password(sq, &prompt)?;
    Ok(password.into())
}

/// Prompts once for a password to unlock an existing object.
///
/// This function is intended for consuming artifacts.  For example,
/// if a key or subkey is locked and must be unlocked, or a message
/// should be decrypted using a password.
pub fn prompt_to_unlock_or_cancel(sq: &Sq, reason: &str)
                                  -> Result<Option<Password>>
{
    let password =
        prompt_to_unlock(sq, &format!("{} (blank to skip)", reason))?;
    Ok(if password.map(|p| p.is_empty()) { None } else { Some(password) })
}