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
|
/// Command-line parser for sq.
use clap::{Command, CommandFactory, Parser, Subcommand};
#[cfg(feature = "autocrypt")]
pub mod autocrypt;
pub mod armor;
pub mod certify;
pub mod dane;
mod dearmor;
mod decrypt;
pub mod encrypt;
pub mod inspect;
pub mod key;
pub mod keyring;
pub mod keyserver;
mod output_versions;
pub mod packet;
pub mod revoke;
mod sign;
mod verify;
pub mod wkd;
pub mod keystore;
pub mod types;
pub fn build() -> Command<'static> {
let sq_version = Box::leak(
format!(
"{} (sequoia-openpgp {}, using {})",
env!("CARGO_PKG_VERSION"),
sequoia_openpgp::VERSION,
sequoia_openpgp::crypto::backend()
)
.into_boxed_str(),
) as &str;
SqCommand::command().version(sq_version)
}
/// Defines the CLI.
#[derive(Parser, Debug)]
#[clap(
name = "sq",
about = "A command-line frontend for Sequoia, an implementation of OpenPGP",
long_about = "A command-line frontend for Sequoia, an implementation of OpenPGP
Functionality is grouped and available using subcommands. Currently,
this interface is completely stateless. Therefore, you need to supply
all configuration and certificates explicitly on each invocation.
OpenPGP data can be provided in binary or ASCII armored form. This
will be handled automatically. Emitted OpenPGP data is ASCII armored
by default.
We use the term \"certificate\", or cert for short, to refer to OpenPGP
keys that do not contain secrets. Conversely, we use the term \"key\"
to refer to OpenPGP keys that do contain secrets.
",
subcommand_required = true,
arg_required_else_help = true,
disable_colored_help = true,
setting(clap::AppSettings::DeriveDisplayOrder)
)]
pub struct SqCommand {
#[clap(
short = 'f',
long = "force",
help = "Overwrites existing files"
)]
pub force: bool,
#[clap(
long = "output-format",
value_name = "FORMAT",
possible_values = ["human-readable", "json"],
default_value = "human-readable",
env = "SQ_OUTPUT_FORMAT",
help = "Produces output in FORMAT, if possible",
)]
pub output_format: String,
#[clap(
long = "output-version",
value_name = "VERSION",
env = "SQ_OUTPUT_VERSION",
help = "Produces output variant VERSION.",
long_help = "Produces output variant VERSION, such as 0.0.0. \
The default is the newest version. The output version \
is separate from the version of the sq program. To see \
the current supported versions, use output-versions \
subcommand."
)]
pub output_version: Option<String>,
#[clap(
long = "known-notation",
value_name = "NOTATION",
multiple_occurrences = true,
help = "Adds NOTATION to the list of known notations",
long_help = "Adds NOTATION to the list of known notations. \
This is used when validating signatures. \
Signatures that have unknown notations with the \
critical bit set are considered invalid."
)]
// TODO is this the right type?
pub known_notation: Vec<String>,
#[clap(subcommand)]
pub subcommand: SqSubcommands,
}
/// The order of top-level subcommands is:
///
/// - Encryption & decryption
/// - Signing & verification
/// - Key & cert-ring management
/// - Key discovery & networking
/// - Armor
/// - Inspection & packet manipulation
///
/// The order is derived from the order of variants in this enum.
#[derive(Debug, Subcommand)]
pub enum SqSubcommands {
Encrypt(encrypt::Command),
Decrypt(decrypt::Command),
Sign(sign::Command),
Verify(verify::Command),
Key(key::Command),
Keyring(keyring::Command),
Certify(certify::Command),
Keystore(keystore::Command),
#[cfg(feature = "autocrypt")]
Autocrypt(autocrypt::Command),
Keyserver(keyserver::Command),
Wkd(wkd::Command),
Dane(dane::Command),
Armor(armor::Command),
Dearmor(dearmor::Command),
Inspect(inspect::Command),
Packet(packet::Command),
Revoke(revoke::Command),
OutputVersions(output_versions::Command),
}
|
