1use std::fs::{self, OpenOptions};
2use std::io::{ErrorKind, Write};
3use std::os::unix::ffi::OsStrExt;
4use std::os::unix::fs::{DirBuilderExt, MetadataExt, OpenOptionsExt};
5use std::path::{Path, PathBuf};
6
7use anyhow::{Context, Result, bail};
8use base64::Engine;
9use base64::engine::general_purpose::STANDARD;
10use ed25519_dalek::SigningKey;
11use rand_core::{OsRng, RngCore};
12use sha2::{Digest, Sha256};
13
14use crate::ssh::write_atomic;
15
16const KEY_DIR_PREFIX: &str = "second-brain-ssh-";
17const KEY_FILE: &str = "id";
18const CREATE_ATTEMPTS: usize = 3;
19
20pub struct EphemeralIdentity {
26 path: PathBuf,
27}
28
29impl EphemeralIdentity {
30 pub fn create(data_dir: &Path, key: &SigningKey, comment: &str) -> Result<Self> {
31 Self::create_in(&runtime_base(), data_dir, key, comment)
32 }
33
34 pub(crate) fn create_in(
35 base: &Path,
36 data_dir: &Path,
37 key: &SigningKey,
38 comment: &str,
39 ) -> Result<Self> {
40 let dir = create_private_dir(base, data_dir)?;
41 let path = dir.join(KEY_FILE);
42 let written = OpenOptions::new()
43 .write(true)
44 .create_new(true)
45 .mode(0o600)
46 .open(&path)
47 .and_then(|mut file| file.write_all(identity_pem(key, comment).as_bytes()))
48 .with_context(|| format!("writing {}", path.display()));
49 if let Err(e) = written {
50 let _ = fs::remove_file(&path);
51 let _ = fs::remove_dir(&dir);
52 return Err(e);
53 }
54 Ok(Self { path })
55 }
56
57 pub fn path(&self) -> &Path {
58 &self.path
59 }
60}
61
62impl Drop for EphemeralIdentity {
63 fn drop(&mut self) {
64 if let Err(e) = fs::remove_file(&self.path)
65 && e.kind() != ErrorKind::NotFound
66 {
67 tracing::warn!("removing the ssh key file {}: {e}", self.path.display());
68 }
69 if let Some(dir) = self.path.parent()
70 && let Err(e) = fs::remove_dir(dir)
71 && e.kind() != ErrorKind::NotFound
72 {
73 tracing::warn!("removing {}: {e}", dir.display());
74 }
75 }
76}
77
78pub fn sweep_ephemeral_identities(data_dir: &Path) -> Result<usize> {
81 sweep_ephemeral_identities_in(&runtime_base(), data_dir)
82}
83
84pub(crate) fn sweep_ephemeral_identities_in(base: &Path, data_dir: &Path) -> Result<usize> {
85 let owner = fs::metadata(data_dir)
86 .with_context(|| format!("reading {}", data_dir.display()))?
87 .uid();
88 let prefix = format!("{}-", key_dir_stem(data_dir));
89 let entries = match fs::read_dir(base) {
90 Ok(entries) => entries,
91 Err(e) if e.kind() == ErrorKind::NotFound => return Ok(0),
92 Err(e) => return Err(e).with_context(|| format!("listing {}", base.display())),
93 };
94 let mut removed = 0;
95 for entry in entries {
96 let entry = entry.with_context(|| format!("listing {}", base.display()))?;
97 if !entry.file_name().to_string_lossy().starts_with(&prefix) {
98 continue;
99 }
100 let dir = entry.path();
101 let meta =
102 fs::symlink_metadata(&dir).with_context(|| format!("reading {}", dir.display()))?;
103 if !meta.is_dir() || meta.uid() != owner {
104 continue;
105 }
106 match fs::remove_file(dir.join(KEY_FILE)) {
107 Ok(()) => {}
108 Err(e) if e.kind() == ErrorKind::NotFound => {}
109 Err(e) => {
110 return Err(e).with_context(|| format!("removing the key in {}", dir.display()));
111 }
112 }
113 fs::remove_dir(&dir).with_context(|| format!("removing {}", dir.display()))?;
114 removed += 1;
115 }
116 Ok(removed)
117}
118
119fn runtime_base() -> PathBuf {
120 if let Some(dir) = std::env::var_os("XDG_RUNTIME_DIR").map(PathBuf::from)
121 && dir.is_absolute()
122 && dir.is_dir()
123 {
124 return dir;
125 }
126 let shm = Path::new("/dev/shm");
127 if shm.is_dir() {
128 return shm.to_path_buf();
129 }
130 std::env::temp_dir()
131}
132
133fn key_dir_stem(data_dir: &Path) -> String {
134 let digest = Sha256::digest(data_dir.as_os_str().as_bytes());
135 format!("{KEY_DIR_PREFIX}{}", &hex(&digest)[..16])
136}
137
138fn create_private_dir(base: &Path, data_dir: &Path) -> Result<PathBuf> {
141 let stem = key_dir_stem(data_dir);
142 let mut suffix = [0u8; 16];
143 for _ in 0..CREATE_ATTEMPTS {
144 OsRng.fill_bytes(&mut suffix);
145 let dir = base.join(format!("{stem}-{}", hex(&suffix)));
146 match fs::DirBuilder::new().mode(0o700).create(&dir) {
147 Ok(()) => return Ok(dir),
148 Err(e) if e.kind() == ErrorKind::AlreadyExists => {}
149 Err(e) => return Err(e).with_context(|| format!("creating {}", dir.display())),
150 }
151 }
152 bail!(
153 "could not create a new ssh key directory in {}",
154 base.display()
155 )
156}
157
158fn hex(bytes: &[u8]) -> String {
159 bytes.iter().map(|b| format!("{b:02x}")).collect()
160}
161
162const PEM_LABEL: &str = concat!("OPENSSH ", "PRIVATE KEY");
163
164const KEY_TYPE: &[u8] = b"ssh-ed25519";
165const MAGIC: &[u8] = b"openssh-key-v1\0";
166const BLOCK: usize = 8;
167
168fn put_string(buf: &mut Vec<u8>, bytes: &[u8]) {
169 buf.extend_from_slice(&(bytes.len() as u32).to_be_bytes());
170 buf.extend_from_slice(bytes);
171}
172
173fn public_blob(key: &SigningKey) -> Vec<u8> {
174 let mut blob = Vec::new();
175 put_string(&mut blob, KEY_TYPE);
176 put_string(&mut blob, key.verifying_key().as_bytes());
177 blob
178}
179
180pub fn public_line(key: &SigningKey) -> String {
181 format!("ssh-ed25519 {}", STANDARD.encode(public_blob(key)))
182}
183
184fn identity_pem(key: &SigningKey, comment: &str) -> String {
185 let public = key.verifying_key();
186 let digest = Sha256::digest(public.as_bytes());
187 let check = &digest[..4];
188
189 let mut private = Vec::new();
190 private.extend_from_slice(check);
191 private.extend_from_slice(check);
192 put_string(&mut private, KEY_TYPE);
193 put_string(&mut private, public.as_bytes());
194 let mut pair = Vec::with_capacity(64);
195 pair.extend_from_slice(&key.to_bytes());
196 pair.extend_from_slice(public.as_bytes());
197 put_string(&mut private, &pair);
198 put_string(&mut private, comment.as_bytes());
199 let mut pad = 1u8;
200 while private.len() % BLOCK != 0 {
201 private.push(pad);
202 pad += 1;
203 }
204
205 let mut body = Vec::new();
206 body.extend_from_slice(MAGIC);
207 put_string(&mut body, b"none");
208 put_string(&mut body, b"none");
209 put_string(&mut body, b"");
210 body.extend_from_slice(&1u32.to_be_bytes());
211 put_string(&mut body, &public_blob(key));
212 put_string(&mut body, &private);
213
214 let encoded = STANDARD.encode(&body);
215 let mut pem = format!("-----BEGIN {PEM_LABEL}-----\n");
216 for chunk in encoded.as_bytes().chunks(70) {
217 pem.push_str(std::str::from_utf8(chunk).expect("base64 is ascii"));
218 pem.push('\n');
219 }
220 pem.push_str(&format!("-----END {PEM_LABEL}-----\n"));
221 pem
222}
223
224pub fn write_identity_file(path: &Path, key: &SigningKey, comment: &str) -> Result<bool> {
227 let pem = identity_pem(key, comment);
228 match fs::read(path) {
229 Ok(existing) if existing == pem.as_bytes() => return Ok(false),
230 Ok(_) => {}
231 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
232 Err(e) => return Err(e).with_context(|| format!("reading {}", path.display())),
233 }
234 write_atomic(path, pem.as_bytes(), Some(0o600))?;
235 Ok(true)
236}
237
238#[cfg(test)]
239mod tests {
240 use super::*;
241 use std::fs;
242 use std::os::unix::fs::PermissionsExt;
243 use std::process::Command;
244
245 fn key() -> SigningKey {
246 SigningKey::from_bytes(&[7u8; 32])
247 }
248
249 #[test]
250 fn rewrite_of_same_key_writes_nothing() {
251 let dir = tempfile::tempdir().unwrap();
252 let path = dir.path().join("id");
253 assert!(write_identity_file(&path, &key(), "sb").unwrap());
254 let first = fs::read(&path).unwrap();
255 assert!(!write_identity_file(&path, &key(), "sb").unwrap());
256 assert_eq!(fs::read(&path).unwrap(), first);
257 let other = SigningKey::from_bytes(&[8u8; 32]);
258 assert!(write_identity_file(&path, &other, "sb").unwrap());
259 }
260
261 #[test]
262 fn file_is_private_openssh_pem() {
263 let dir = tempfile::tempdir().unwrap();
264 let path = dir.path().join("keys").join("id");
265 write_identity_file(&path, &key(), "sb").unwrap();
266 let mode = |p: &Path| fs::metadata(p).unwrap().permissions().mode() & 0o777;
267 assert_eq!(mode(&path), 0o600);
268 assert_eq!(mode(path.parent().unwrap()), 0o700);
269 let text = fs::read_to_string(&path).unwrap();
270 assert!(text.starts_with(&format!("-----BEGIN {PEM_LABEL}-----\n")));
271 assert!(text.ends_with(&format!("-----END {PEM_LABEL}-----\n")));
272 assert!(
273 text.lines()
274 .all(|l| l.len() <= 70 || l.starts_with("-----"))
275 );
276 }
277
278 #[test]
279 fn public_line_shape() {
280 let line = public_line(&key());
281 assert!(line.starts_with("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI"));
282 assert_eq!(line.split(' ').count(), 2);
283 }
284
285 #[test]
286 fn ssh_keygen_derives_the_same_public_key() {
287 let dir = tempfile::tempdir().unwrap();
288 let path = dir.path().join("id");
289 write_identity_file(&path, &key(), "sb").unwrap();
290 let out = match Command::new("ssh-keygen")
291 .arg("-y")
292 .arg("-f")
293 .arg(&path)
294 .output()
295 {
296 Ok(out) => out,
297 Err(e) => {
298 eprintln!("skipping ssh-keygen check: {e}");
299 return;
300 }
301 };
302 assert!(
303 out.status.success(),
304 "{}",
305 String::from_utf8_lossy(&out.stderr)
306 );
307 let printed = String::from_utf8_lossy(&out.stdout);
308 let mut fields = printed.split_whitespace();
309 let got = format!("{} {}", fields.next().unwrap(), fields.next().unwrap());
310 assert_eq!(got, public_line(&key()));
311 }
312
313 fn private_mode(path: &Path) -> u32 {
314 fs::metadata(path).unwrap().permissions().mode() & 0o777
315 }
316
317 #[test]
318 fn an_ephemeral_identity_is_a_private_file_outside_the_data_dir_removed_on_drop() {
319 let base = tempfile::tempdir().unwrap();
320 let data_dir = tempfile::tempdir().unwrap();
321 let identity =
322 EphemeralIdentity::create_in(base.path(), data_dir.path(), &key(), "sb").unwrap();
323 let path = identity.path().to_path_buf();
324 assert!(path.starts_with(base.path()));
325 assert_eq!(private_mode(&path), 0o600);
326 assert_eq!(private_mode(path.parent().unwrap()), 0o700);
327 assert_eq!(
328 fs::read_to_string(&path).unwrap(),
329 identity_pem(&key(), "sb")
330 );
331
332 let second =
333 EphemeralIdentity::create_in(base.path(), data_dir.path(), &key(), "sb").unwrap();
334 assert_ne!(second.path().parent(), path.parent());
335 drop(identity);
336 assert!(!path.parent().unwrap().exists());
337 assert!(second.path().exists());
338 drop(second);
339 assert_eq!(fs::read_dir(base.path()).unwrap().count(), 0);
340 }
341
342 #[test]
343 fn directories_another_user_made_first_do_not_stop_a_new_identity() {
344 let base = tempfile::tempdir().unwrap();
345 let data_dir = tempfile::tempdir().unwrap();
346 let stem = key_dir_stem(data_dir.path());
347 for name in [stem.clone(), format!("{stem}-00")] {
348 let squatted = base.path().join(name);
349 fs::create_dir(&squatted).unwrap();
350 fs::set_permissions(&squatted, fs::Permissions::from_mode(0o777)).unwrap();
351 }
352 let identity =
353 EphemeralIdentity::create_in(base.path(), data_dir.path(), &key(), "sb").unwrap();
354 assert_eq!(private_mode(identity.path().parent().unwrap()), 0o700);
355 }
356
357 #[test]
358 fn identities_left_by_a_killed_process_are_swept_for_their_data_dir_only() {
359 let base = tempfile::tempdir().unwrap();
360 let mine = tempfile::tempdir().unwrap();
361 let other = tempfile::tempdir().unwrap();
362 let left = EphemeralIdentity::create_in(base.path(), mine.path(), &key(), "sb").unwrap();
363 let left_dir = left.path().parent().unwrap().to_path_buf();
364 std::mem::forget(left);
365 let others = EphemeralIdentity::create_in(base.path(), other.path(), &key(), "sb").unwrap();
366
367 assert_eq!(
368 sweep_ephemeral_identities_in(base.path(), mine.path()).unwrap(),
369 1
370 );
371 assert!(!left_dir.exists());
372 assert!(others.path().exists());
373 assert_eq!(
374 sweep_ephemeral_identities_in(base.path(), mine.path()).unwrap(),
375 0
376 );
377 }
378
379 #[test]
380 fn the_sweep_never_follows_a_symlink() {
381 let base = tempfile::tempdir().unwrap();
382 let data_dir = tempfile::tempdir().unwrap();
383 let elsewhere = tempfile::tempdir().unwrap();
384 fs::write(elsewhere.path().join(KEY_FILE), "kept").unwrap();
385 std::os::unix::fs::symlink(
386 elsewhere.path(),
387 base.path()
388 .join(format!("{}-ff", key_dir_stem(data_dir.path()))),
389 )
390 .unwrap();
391
392 assert_eq!(
393 sweep_ephemeral_identities_in(base.path(), data_dir.path()).unwrap(),
394 0
395 );
396 assert!(elsewhere.path().join(KEY_FILE).exists());
397 }
398}