Skip to main content

second_brain_sync/
ssh_identity.rs

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
20/// This device's ssh private key in a 0600 file, for one ssh transport to
21/// pass to `ssh -i`, removed with its directory on drop. Each identity gets a
22/// fresh 0700 directory with a random name under `$XDG_RUNTIME_DIR` or
23/// `/dev/shm` (both RAM) when one exists, else the temp dir, which is disk on
24/// macOS; a directory another user made first is never used.
25pub 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
78/// Removes the key directories a killed daemon on `data_dir` left; returns
79/// how many. Only real directories owned by `data_dir`'s owner are touched.
80pub 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
138/// mkdir fails on any existing name, a symlink included, so the directory
139/// returned is new and this process's own.
140fn 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
224/// Writes `key` as an unencrypted OpenSSH private key, byte for byte the same
225/// for the same key and comment. Returns false when the file already held it.
226pub 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}