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
|
use std::{
fs::File,
io,
path::PathBuf,
};
use anyhow::Context;
use sequoia_openpgp as openpgp;
use openpgp::{
Result,
armor,
cert::{
Cert,
CertParser,
},
parse::Parse,
serialize::Serialize,
};
use crate::{
open_or_stdin,
create_or_stdout_pgp,
};
pub fn dispatch(m: &clap::ArgMatches, force: bool) -> Result<()> {
match m.subcommand() {
("join", Some(m)) => {
// XXX: Armor type selection is a bit problematic. If any
// of the certificates contain a secret key, it would be
// better to use Kind::SecretKey here. However, this
// requires buffering all certs, which has its own
// problems.
let mut output = create_or_stdout_pgp(m.value_of("output"),
force,
m.is_present("binary"),
armor::Kind::PublicKey)?;
filter(m.values_of("input"), &mut output, |c| Some(c))?;
output.finalize()
},
("list", Some(m)) => {
let mut input = open_or_stdin(m.value_of("input"))?;
list(&mut input)
},
("split", Some(m)) => {
let mut input = open_or_stdin(m.value_of("input"))?;
let prefix =
// The prefix is either specified explicitly...
m.value_of("prefix").map(|p| p.to_owned())
.unwrap_or(
// ... or we derive it from the input file...
m.value_of("input").and_then(|i| {
let p = PathBuf::from(i);
// (but only use the filename)
p.file_name().map(|f| String::from(f.to_string_lossy()))
})
// ... or we use a generic prefix...
.unwrap_or(String::from("output"))
// ... finally, add a hyphen to the derived prefix.
+ "-");
split(&mut input, &prefix)
},
_ => unreachable!(),
}
}
/// Joins cert(ring)s into a certring, applying a filter.
fn filter<F>(inputs: Option<clap::Values>, output: &mut dyn io::Write,
mut filter: F)
-> Result<()>
where F: FnMut(Cert) -> Option<Cert>,
{
if let Some(inputs) = inputs {
for name in inputs {
for cert in CertParser::from_file(name)? {
let cert = cert.context(
format!("Malformed certificate in certring {:?}", name))?;
if let Some(cert) = filter(cert) {
cert.serialize(output)?;
}
}
}
} else {
for cert in CertParser::from_reader(io::stdin())? {
let cert = cert.context("Malformed certificate in certring")?;
if let Some(cert) = filter(cert) {
cert.serialize(output)?;
}
}
}
Ok(())
}
/// Lists certs in a certring.
fn list(input: &mut (dyn io::Read + Sync + Send))
-> Result<()> {
for (i, cert) in CertParser::from_reader(input)?.enumerate() {
let cert = cert.context("Malformed certificate in certring")?;
print!("{}. {:X}", i, cert.fingerprint());
// Try to be more helpful by including the first userid in the
// listing.
if let Some(email) = cert.userids().nth(0)
.and_then(|uid| uid.email().unwrap_or(None))
{
print!(" {}", email);
}
println!();
}
Ok(())
}
/// Splits a certring into individual certs.
fn split(input: &mut (dyn io::Read + Sync + Send), prefix: &str)
-> Result<()> {
for (i, cert) in CertParser::from_reader(input)?.enumerate() {
let cert = cert.context("Malformed certificate in certring")?;
let filename = format!(
"{}{}-{:X}",
prefix,
i,
cert.fingerprint());
// Try to be more helpful by including the first userid in the
// filename.
let mut sink = if let Some(f) = cert.userids().nth(0)
.and_then(|uid| uid.email().unwrap_or(None))
.and_then(to_filename_fragment)
{
let filename_email = format!("{}-{}", filename, f);
if let Ok(s) = File::create(filename_email) {
s
} else {
// Degrade gracefully in case our sanitization
// produced an invalid filename on this system.
File::create(&filename)
.context(format!("Writing cert to {:?} failed", filename))?
}
} else {
File::create(&filename)
.context(format!("Writing cert to {:?} failed", filename))?
};
cert.armored().serialize(&mut sink)?;
}
Ok(())
}
/// Sanitizes a string to a safe filename fragment.
fn to_filename_fragment<S: AsRef<str>>(s: S) -> Option<String> {
let mut r = String::with_capacity(s.as_ref().len());
s.as_ref().chars().filter_map(|c| match c {
'/' | ':' | '\\' => None,
c if c.is_ascii_whitespace() => None,
c if c.is_ascii() => Some(c),
_ => None,
}).for_each(|c| r.push(c));
if r.len() > 0 {
Some(r)
} else {
None
}
}
|
