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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
use chrono::{offset::Utc, DateTime};
/// Common types for arguments of sq.
use clap::{ArgEnum, Args};
use openpgp::fmt::hex;
use openpgp::types::SymmetricAlgorithm;
use sequoia_openpgp as openpgp;
#[derive(Debug, Args)]
pub struct IoArgs {
#[clap(value_name = "FILE", help = "Reads from FILE or stdin if omitted")]
pub input: Option<String>,
#[clap(
short,
long,
value_name = "FILE",
help = "Writes to FILE or stdout if omitted"
)]
pub output: Option<String>,
}
#[derive(ArgEnum, Debug, Clone)]
pub enum ArmorKind {
Auto,
Message,
#[clap(name = "cert")]
PublicKey,
#[clap(name = "key")]
SecretKey,
#[clap(name = "sig")]
Signature,
File,
}
impl From<ArmorKind> for Option<openpgp::armor::Kind> {
fn from(c: ArmorKind) -> Self {
match c {
ArmorKind::Auto => None,
ArmorKind::Message => Some(openpgp::armor::Kind::Message),
ArmorKind::PublicKey => Some(openpgp::armor::Kind::PublicKey),
ArmorKind::SecretKey => Some(openpgp::armor::Kind::SecretKey),
ArmorKind::Signature => Some(openpgp::armor::Kind::Signature),
ArmorKind::File => Some(openpgp::armor::Kind::File),
}
}
}
#[derive(ArgEnum, Clone, Debug)]
pub enum NetworkPolicy {
Offline,
Anonymized,
Encrypted,
Insecure,
}
impl From<NetworkPolicy> for sequoia_net::Policy {
fn from(kp: NetworkPolicy) -> Self {
match kp {
NetworkPolicy::Offline => sequoia_net::Policy::Offline,
NetworkPolicy::Anonymized => sequoia_net::Policy::Anonymized,
NetworkPolicy::Encrypted => sequoia_net::Policy::Encrypted,
NetworkPolicy::Insecure => sequoia_net::Policy::Insecure,
}
}
}
/// Holds a session key as parsed from the command line, with an optional
/// algorithm specifier.
///
/// This struct does not implement [`Display`] to prevent accidental leaking
/// of key material. If you are sure you want to print a session key, use
/// [`display_sensitive`].
///
/// [`Display`]: std::fmt::Display
/// [`display_sensitive`]: SessionKey::display_sensitive
#[derive(Debug, Clone)]
pub struct SessionKey {
pub session_key: openpgp::crypto::SessionKey,
pub symmetric_algo: Option<SymmetricAlgorithm>,
}
impl std::str::FromStr for SessionKey {
type Err = anyhow::Error;
/// Parse a session key. The format is: an optional prefix specifying the
/// symmetric algorithm as a number, followed by a colon, followed by the
/// session key in hexadecimal representation.
fn from_str(sk: &str) -> anyhow::Result<Self> {
let result = if let Some((algo, sk)) = sk.split_once(':') {
let algo = SymmetricAlgorithm::from(algo.parse::<u8>()?);
let dsk = hex::decode_pretty(sk)?.into();
SessionKey {
session_key: dsk,
symmetric_algo: Some(algo),
}
} else {
let dsk = hex::decode_pretty(sk)?.into();
SessionKey {
session_key: dsk,
symmetric_algo: None,
}
};
Ok(result)
}
}
impl SessionKey {
/// Returns an object that implements Display for explicitly opting into
/// printing a `SessionKey`.
pub fn display_sensitive(&self) -> SessionKeyDisplay {
SessionKeyDisplay { csk: self }
}
}
/// Helper struct for intentionally printing session keys with format! and {}.
///
/// This struct implements the `Display` trait to print the session key. This
/// construct requires the user to explicitly call
/// [`SessionKey::display_sensitive`]. By requiring the user to opt-in, this
/// will hopefully reduce that the chance that the session key is inadvertently
/// leaked, e.g., in a log that may be publicly posted.
pub struct SessionKeyDisplay<'a> {
csk: &'a SessionKey,
}
/// Print the session key without prefix in hexadecimal representation.
impl<'a> std::fmt::Display for SessionKeyDisplay<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let sk = self.csk;
write!(f, "{}", hex::encode(&sk.session_key))
}
}
#[derive(Debug)]
pub struct Time {
pub time: DateTime<Utc>,
}
impl std::str::FromStr for Time {
type Err = anyhow::Error;
fn from_str(s: &str) -> anyhow::Result<Time> {
let time =
Time::parse_iso8601(s, chrono::NaiveTime::from_hms(0, 0, 0))?;
Ok(Time { time })
}
}
impl Time {
/// Parses the given string depicting a ISO 8601 timestamp.
fn parse_iso8601(
s: &str,
pad_date_with: chrono::NaiveTime,
) -> anyhow::Result<DateTime<Utc>> {
// If you modify this function this function, synchronize the
// changes with the copy in sqv.rs!
for f in &[
"%Y-%m-%dT%H:%M:%S%#z",
"%Y-%m-%dT%H:%M:%S",
"%Y-%m-%dT%H:%M%#z",
"%Y-%m-%dT%H:%M",
"%Y-%m-%dT%H%#z",
"%Y-%m-%dT%H",
"%Y%m%dT%H%M%S%#z",
"%Y%m%dT%H%M%S",
"%Y%m%dT%H%M%#z",
"%Y%m%dT%H%M",
"%Y%m%dT%H%#z",
"%Y%m%dT%H",
] {
if f.ends_with("%#z") {
if let Ok(d) = DateTime::parse_from_str(s, *f) {
return Ok(d.into());
}
} else if let Ok(d) = chrono::NaiveDateTime::parse_from_str(s, *f) {
return Ok(DateTime::from_utc(d, Utc));
}
}
for f in &["%Y-%m-%d", "%Y-%m", "%Y-%j", "%Y%m%d", "%Y%m", "%Y%j", "%Y"]
{
if let Ok(d) = chrono::NaiveDate::parse_from_str(s, *f) {
return Ok(DateTime::from_utc(d.and_time(pad_date_with), Utc));
}
}
Err(anyhow::anyhow!("Malformed ISO8601 timestamp: {}", s))
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_parse_iso8601() -> anyhow::Result<()> {
let z = chrono::NaiveTime::from_hms(0, 0, 0);
Time::parse_iso8601("2017-03-04T13:25:35Z", z)?;
Time::parse_iso8601("2017-03-04T13:25:35+08:30", z)?;
Time::parse_iso8601("2017-03-04T13:25:35", z)?;
Time::parse_iso8601("2017-03-04T13:25Z", z)?;
Time::parse_iso8601("2017-03-04T13:25", z)?;
// CliTime::parse_iso8601("2017-03-04T13Z", z)?; // XXX: chrono doesn't like
// CliTime::parse_iso8601("2017-03-04T13", z)?; // ditto
Time::parse_iso8601("2017-03-04", z)?;
// CliTime::parse_iso8601("2017-03", z)?; // ditto
Time::parse_iso8601("2017-031", z)?;
Time::parse_iso8601("20170304T132535Z", z)?;
Time::parse_iso8601("20170304T132535+0830", z)?;
Time::parse_iso8601("20170304T132535", z)?;
Time::parse_iso8601("20170304T1325Z", z)?;
Time::parse_iso8601("20170304T1325", z)?;
// CliTime::parse_iso8601("20170304T13Z", z)?; // ditto
// CliTime::parse_iso8601("20170304T13", z)?; // ditto
Time::parse_iso8601("20170304", z)?;
// CliTime::parse_iso8601("201703", z)?; // ditto
Time::parse_iso8601("2017031", z)?;
// CliTime::parse_iso8601("2017", z)?; // ditto
Ok(())
}
}
|
