Skip to main content

second_brain_core/keys/
restore.rs

1use std::collections::BTreeSet;
2use std::fs;
3use std::io::{self, ErrorKind};
4use std::path::{Path, PathBuf};
5
6use anyhow::{Context, Result, anyhow, bail, ensure};
7
8use super::aside::{RESTORE_MARKER, aside_path, carry_over, create_private_dir};
9use super::device::sync_dir;
10use super::hardware::{HardwareSource, SystemHardware};
11use super::storage::create_device_keys_with;
12use super::{
13    DEVICE_KEY_FILE, DEVICE_PUB_FILE, DeviceKeys, HARDWARE_BINDING_FILE, HeldEpoch, IdentityTag,
14    KeyStorage, NEXT_STORE_KEY_FILE, RecoveryPhrase, SEALED_DEVICE_KEY_FILE, STORE_KEY_FILE,
15    StoreKey, WRAPPED_STORE_KEY_FILE, found_identity, refresh_wrapped_store_key,
16    unwrap_store_key_with_epochs, unwrap_store_key_with_phrase, wrap, wrap_for_recovery,
17    write_store_key,
18};
19use crate::machine::MachineIdentity;
20use crate::sqlite_store::SqliteStore;
21use crate::sqlite_store::encrypt_migration::{
22    FileState, PLAINTEXT_COPY_PREFIX, RewriteTo, db_file_state,
23};
24use crate::store::StoreAdmin;
25use crate::write_queue;
26
27const DB_FILE: &str = "brain.db";
28const MACHINE_FILE: &str = "machine.toml";
29const CONFIG_FILE: &str = "config.toml";
30
31/// Files a backup never brings along: what names the old device, its keys
32/// or its peers, and what belongs to the host it ran on.
33const LEFT_BEHIND: &[&str] = &[
34    MACHINE_FILE,
35    DEVICE_KEY_FILE,
36    SEALED_DEVICE_KEY_FILE,
37    HARDWARE_BINDING_FILE,
38    DEVICE_PUB_FILE,
39    "sync.key",
40    "migrated-peers.json",
41    "api.token",
42    ".api.token.lock",
43    "sync-peers",
44    "clock-reading",
45    "service.json",
46    "brain.db-shm",
47    STORE_KEY_FILE,
48    NEXT_STORE_KEY_FILE,
49    "brain.db.enc",
50    "brain.db.enc-journal",
51    "brain.db.enc-wal",
52    "brain.db.enc-shm",
53];
54
55/// Temporary files the key writers leave on a crash, which may hold the old
56/// device's secret.
57const LEFT_BEHIND_PREFIXES: &[&str] = &[".device.key.", ".store.key.", PLAINTEXT_COPY_PREFIX];
58
59/// True for a top-level data-dir entry a backup never carries.
60pub fn left_behind(name: &str) -> bool {
61    LEFT_BEHIND.contains(&name) || LEFT_BEHIND_PREFIXES.iter().any(|p| name.starts_with(p))
62}
63
64/// Host files the data dir being replaced keeps across a restore.
65const HOST_FILES: &[&str] = &["service.json"];
66
67pub struct RestoreRequest<'a> {
68    /// A copy of a device's data dir.
69    pub backup: &'a Path,
70    /// The data dir to restore into; an existing one is moved aside.
71    pub data_dir: &'a Path,
72    pub phrase: &'a RecoveryPhrase,
73    pub storage: &'a KeyStorage,
74    pub now_micros: i64,
75}
76
77/// What opens a backup's keys.
78#[derive(Clone, Copy)]
79#[non_exhaustive]
80pub enum BackupKeys<'a> {
81    /// A recovery phrase the backed-up device trusted.
82    Phrase(&'a RecoveryPhrase),
83    /// Epochs of `K_id`: handed over by a surviving device through
84    /// `sb pair --restore-keys`, or this device's own past epochs.
85    Epochs(&'a [HeldEpoch]),
86}
87
88pub struct BackupRestore<'a> {
89    /// A copy of a device's data dir.
90    pub backup: &'a Path,
91    /// The data dir to restore into; an existing one is moved aside.
92    pub data_dir: &'a Path,
93    pub keys: BackupKeys<'a>,
94    pub storage: &'a KeyStorage,
95    pub now_micros: i64,
96}
97
98#[derive(Debug)]
99#[non_exhaustive]
100pub struct Restored {
101    pub machine: MachineIdentity,
102    pub identity: IdentityTag,
103    /// The identities whose epochs the phrase or the given epochs opened,
104    /// kept decrypt-only.
105    pub opened: Vec<IdentityTag>,
106    /// The phrase of the new identity, to be shown to the user once.
107    pub phrase: RecoveryPhrase,
108    /// Where the data dir that was replaced now lives.
109    pub moved_aside: Option<PathBuf>,
110}
111
112/// Restores a data-dir backup as a new device of a new identity: the copy
113/// gets a fresh machine id and device keys first, the phrase opens the
114/// backup's epochs (kept decrypt-only, wrapped to the new device), and then
115/// the new identity is founded with a new phrase. Nothing in `data_dir`
116/// changes until the restored copy is complete; the old one is then moved
117/// aside, where the daemon deletes it after 90 days. The daemon must not be
118/// running.
119pub fn restore_backup(req: &RestoreRequest<'_>) -> Result<Restored> {
120    restore_backup_with(&BackupRestore {
121        backup: req.backup,
122        data_dir: req.data_dir,
123        keys: BackupKeys::Phrase(req.phrase),
124        storage: req.storage,
125        now_micros: req.now_micros,
126    })
127}
128
129/// `restore_backup` with the backup's keys opened by a phrase or by epochs
130/// of `K_id`, which are kept decrypt-only the same way.
131pub fn restore_backup_with(req: &BackupRestore<'_>) -> Result<Restored> {
132    restore_with_hardware(req, &SystemHardware)
133}
134
135fn restore_with_hardware(
136    req: &BackupRestore<'_>,
137    hardware: &dyn HardwareSource,
138) -> Result<Restored> {
139    let backup = check_backup(req.backup)?;
140    if let Ok(target) = fs::canonicalize(req.data_dir) {
141        ensure!(
142            target != backup,
143            "the backup is the data dir itself; restore from a copy"
144        );
145    }
146    let parent = parent_of(req.data_dir)?;
147    fs::create_dir_all(&parent).with_context(|| format!("creating {}", parent.display()))?;
148    let base = dir_name(req.data_dir)?;
149    let staging_prefix = format!(".{base}.restoring-");
150    remove_stale_staging(&parent, &staging_prefix, &backup);
151    let staging = parent.join(format!("{staging_prefix}{}", uuid::Uuid::new_v4().simple()));
152    let restored = match prepare(req, &backup, &staging, hardware) {
153        Ok(restored) => restored,
154        Err(e) => return Err(with_staging_removed(e, &staging)),
155    };
156    let moved_aside = match swap_in(req.data_dir, &staging, &base, req.now_micros, rename) {
157        Ok(moved) => moved,
158        Err(Swap::Untouched(e)) => return Err(with_staging_removed(e, &staging)),
159        Err(Swap::Stranded(e)) => return Err(e),
160    };
161    if let Err(e) = sync_dir(&parent) {
162        tracing::warn!("the restore is in place but not yet flushed to disk: {e:#}");
163    }
164    Ok(Restored {
165        moved_aside,
166        ..restored
167    })
168}
169
170/// Queued writes that the backup's plain device key opens follow the
171/// restore; the daemon sets the rest aside as unreadable. The backup is only
172/// read, so a key sealed to the old host's TPM is not tried.
173fn reseal_backup_queue(backup: &Path, staging: &Path, device: &DeviceKeys) -> Result<()> {
174    let queue = staging.join(write_queue::DIR_NAME);
175    if !queue.is_dir() {
176        return Ok(());
177    }
178    let old = match DeviceKeys::load(&backup.join(DEVICE_KEY_FILE)) {
179        Ok(Some(old)) => old,
180        Ok(None) => return Ok(()),
181        Err(e) => {
182            tracing::warn!("sealed queued writes in the backup stay unreadable: {e:#}");
183            return Ok(());
184        }
185    };
186    write_queue::reseal_dir(&queue, old.age_identity(), &[device.age_recipient()])?;
187    Ok(())
188}
189
190/// The canonical path of `backup` when it holds a store, so a caller can
191/// refuse a wrong path before it asks for keys.
192pub fn check_backup(backup: &Path) -> Result<PathBuf> {
193    let canonical = fs::canonicalize(backup)
194        .with_context(|| format!("reading the backup {}", backup.display()))?;
195    ensure!(
196        canonical.join(DB_FILE).is_file(),
197        "{} holds no {DB_FILE}; name a copy of a second-brain data dir",
198        canonical.display()
199    );
200    Ok(canonical)
201}
202
203fn prepare(
204    req: &BackupRestore<'_>,
205    backup: &Path,
206    staging: &Path,
207    hardware: &dyn HardwareSource,
208) -> Result<Restored> {
209    if let BackupKeys::Epochs(held) = req.keys {
210        ensure!(
211            !held.is_empty(),
212            "no key epoch was given, so the backup cannot be opened"
213        );
214    }
215    create_private_dir(staging)?;
216    copy_tree(backup, staging, true)?;
217    let machine = MachineIdentity::load_or_create(staging)?;
218    let device = create_device_keys_with(staging, req.storage, hardware)?;
219    reseal_backup_queue(backup, staging, &device)?;
220    let store = open_backup_store(&staging.join(DB_FILE), staging, req.keys, &machine.id)
221        .context("opening the restored database")?;
222    store.register_machine(&machine)?;
223
224    let reopened;
225    let old_epochs: &[HeldEpoch] = match req.keys {
226        BackupKeys::Phrase(phrase) => {
227            reopened =
228                reopen_old_epochs(&store, phrase, &device, req.now_micros).with_context(|| {
229                    format!("opening {} with the recovery phrase", backup.display())
230                })?;
231            &reopened
232        }
233        BackupKeys::Epochs(held) => {
234            keep_epochs(&store, held, &device, req.now_micros)?;
235            held
236        }
237    };
238
239    let phrase = RecoveryPhrase::generate()?;
240    let recipient = phrase.recipient()?;
241    let founded = found_identity(
242        &store,
243        &device,
244        &machine.name,
245        std::slice::from_ref(&recipient),
246        req.now_micros,
247    )?;
248    for held in old_epochs {
249        wrap_for_recovery(
250            &store,
251            &held.identity,
252            &[(held.epoch, &held.key)],
253            std::slice::from_ref(&recipient),
254        )?;
255    }
256    if cfg!(feature = "encryption") {
257        rekey_restored(&store, staging, &device)?;
258    }
259    drop(store);
260    let opened: BTreeSet<&str> = old_epochs.iter().map(|h| h.identity.as_str()).collect();
261    let opened = opened
262        .into_iter()
263        .map(|t| IdentityTag::from(t.to_string()))
264        .collect();
265    sync_tree(staging)?;
266    Ok(Restored {
267        machine,
268        identity: founded.tag,
269        opened,
270        phrase,
271        moved_aside: None,
272    })
273}
274
275/// An encrypted backup opens under the store key its `store.key.wrapped`
276/// gives up to the phrase or an epoch; a plaintext one, from before the
277/// migration, opens as it is.
278fn open_backup_store(
279    db: &Path,
280    staging: &Path,
281    keys: BackupKeys<'_>,
282    machine_id: &str,
283) -> Result<SqliteStore> {
284    match db_file_state(db)? {
285        FileState::Encrypted => {
286            let unwrapped = match keys {
287                BackupKeys::Phrase(phrase) => unwrap_store_key_with_phrase(staging, phrase)?,
288                BackupKeys::Epochs(held) => unwrap_store_key_with_epochs(staging, held)?,
289            };
290            let key = unwrapped.ok_or_else(|| {
291                anyhow!(
292                    "the backup's {DB_FILE} is encrypted but it holds no \
293                     {WRAPPED_STORE_KEY_FILE}; restore a copy of the whole data dir"
294                )
295            })?;
296            SqliteStore::open_with_key(db, machine_id.to_string(), &key)
297        }
298        _ => SqliteStore::open(db, machine_id.to_string()),
299    }
300}
301
302/// Moves the restored store to a store key of its own, so whoever holds
303/// the backup's key or the old identity's `K_id` opens no copy of the
304/// restored device's store.
305fn rekey_restored(store: &SqliteStore, staging: &Path, device: &DeviceKeys) -> Result<()> {
306    let key = StoreKey::generate()?;
307    write_store_key(staging, STORE_KEY_FILE, &key, device)?;
308    store
309        .rewrite_under_key(RewriteTo::Key(&key))
310        .context("rewriting the restored store under a new store key")?;
311    refresh_wrapped_store_key(store, staging, device, &key)
312        .context("wrapping the new store key to the new identity")?;
313    Ok(())
314}
315
316/// Opens every envelope the phrase can open and wraps that epoch to the new
317/// device under its old identity, where it only decrypts.
318fn reopen_old_epochs(
319    store: &SqliteStore,
320    phrase: &RecoveryPhrase,
321    device: &DeviceKeys,
322    now_micros: i64,
323) -> Result<Vec<HeldEpoch>> {
324    let identity = phrase.identity()?;
325    let own = store.machine_id().to_string();
326    let recipient = device.age_recipient();
327    let mut opened = Vec::new();
328    for envelope in store.recovery_envelopes(&phrase.recipient()?)? {
329        let key = match envelope.open(&identity) {
330            Ok(key) => key,
331            Err(e) => {
332                tracing::warn!("skipping a recovery envelope the phrase cannot open: {e:#}");
333                continue;
334            }
335        };
336        let rewrapped = wrap(
337            &key,
338            envelope.epoch.number,
339            &envelope.identity_tag,
340            &recipient,
341            Some(own.clone()),
342        )?;
343        store.put_keys_durably(
344            &envelope.identity_tag,
345            &[envelope.epoch],
346            &[rewrapped],
347            now_micros,
348        )?;
349        opened.push(HeldEpoch::new(envelope.identity_tag, envelope.epoch, key));
350    }
351    if opened.is_empty() {
352        bail!(
353            "this recovery phrase opens no key in the backup; check the phrase, or restore a \
354             backup of a device that trusted it"
355        );
356    }
357    Ok(opened)
358}
359
360/// Wraps each epoch to the new device under its own identity, where it
361/// only decrypts.
362fn keep_epochs(
363    store: &SqliteStore,
364    held: &[HeldEpoch],
365    device: &DeviceKeys,
366    now_micros: i64,
367) -> Result<()> {
368    let own = store.machine_id().to_string();
369    let recipient = device.age_recipient();
370    for h in held {
371        let envelope = wrap(
372            &h.key,
373            h.epoch.number,
374            &h.identity,
375            &recipient,
376            Some(own.clone()),
377        )?;
378        store.put_keys_durably(&h.identity, &[h.epoch], &[envelope], now_micros)?;
379    }
380    Ok(())
381}
382
383enum Swap {
384    /// `data_dir` is as it was; the staged copy can go.
385    Untouched(anyhow::Error),
386    /// Neither copy is at `data_dir`; the error names where both are.
387    Stranded(anyhow::Error),
388}
389
390fn rename(from: &Path, to: &Path) -> io::Result<()> {
391    fs::rename(from, to)
392}
393
394fn swap_in(
395    data_dir: &Path,
396    staging: &Path,
397    base: &str,
398    now_micros: i64,
399    rename: impl Fn(&Path, &Path) -> io::Result<()>,
400) -> Result<Option<PathBuf>, Swap> {
401    let parent = parent_of(data_dir).map_err(Swap::Untouched)?;
402    let moved_aside = match fs::symlink_metadata(data_dir) {
403        Ok(_) => {
404            let carried = HOST_FILES
405                .iter()
406                .try_for_each(|name| carry_over(&data_dir.join(name), &staging.join(name)))
407                .and_then(|()| {
408                    if staging.join(CONFIG_FILE).exists() {
409                        return Ok(());
410                    }
411                    carry_over(&data_dir.join(CONFIG_FILE), &staging.join(CONFIG_FILE))
412                })
413                .and_then(|()| sync_dir(staging));
414            carried.map_err(Swap::Untouched)?;
415            let aside = aside_path(&parent, base, RESTORE_MARKER, now_micros);
416            rename(data_dir, &aside)
417                .with_context(|| {
418                    format!("moving {} aside to {}", data_dir.display(), aside.display())
419                })
420                .map_err(Swap::Untouched)?;
421            Some(aside)
422        }
423        Err(e) if e.kind() == ErrorKind::NotFound => None,
424        Err(e) => {
425            return Err(Swap::Untouched(
426                anyhow!(e).context(format!("reading {}", data_dir.display())),
427            ));
428        }
429    };
430    let Err(e) = rename(staging, data_dir) else {
431        return Ok(moved_aside);
432    };
433    let error = anyhow!(e).context(format!(
434        "moving the restored copy {} into {}",
435        staging.display(),
436        data_dir.display()
437    ));
438    let Some(aside) = moved_aside else {
439        return Err(Swap::Untouched(error));
440    };
441    match rename(&aside, data_dir) {
442        Ok(()) => Err(Swap::Untouched(error)),
443        Err(back) => Err(Swap::Stranded(error.context(format!(
444            "the previous data dir is at {} and could not be moved back ({back}); the restored \
445             copy is at {}",
446            aside.display(),
447            staging.display()
448        )))),
449    }
450}
451
452/// Flushes every file and directory under `dir`, so a power cut after the
453/// swap cannot keep the rename but lose what it points to.
454fn sync_tree(dir: &Path) -> Result<()> {
455    for entry in fs::read_dir(dir).with_context(|| format!("reading {}", dir.display()))? {
456        let entry = entry?;
457        let path = entry.path();
458        let kind = entry.file_type()?;
459        if kind.is_dir() {
460            sync_tree(&path)?;
461        } else if kind.is_file() {
462            fs::File::open(&path)
463                .and_then(|f| f.sync_all())
464                .with_context(|| format!("syncing {}", path.display()))?;
465        }
466    }
467    sync_dir(dir)
468}
469
470fn copy_tree(from: &Path, to: &Path, top: bool) -> Result<()> {
471    for entry in fs::read_dir(from).with_context(|| format!("reading {}", from.display()))? {
472        let entry = entry?;
473        let name = entry.file_name();
474        if top && name.to_str().is_some_and(left_behind) {
475            continue;
476        }
477        let source = entry.path();
478        let target = to.join(&name);
479        let kind = entry.file_type()?;
480        if kind.is_dir() {
481            fs::create_dir(&target).with_context(|| format!("creating {}", target.display()))?;
482            copy_tree(&source, &target, false)?;
483        } else if kind.is_file() {
484            fs::copy(&source, &target)
485                .with_context(|| format!("copying {} to {}", source.display(), target.display()))?;
486        } else if kind.is_symlink() {
487            copy_symlink(&source, &target)?;
488        } else {
489            tracing::warn!("restore skips {}, which is not a file", source.display());
490        }
491    }
492    Ok(())
493}
494
495#[cfg(unix)]
496fn copy_symlink(source: &Path, target: &Path) -> Result<()> {
497    let link = fs::read_link(source).with_context(|| format!("reading {}", source.display()))?;
498    std::os::unix::fs::symlink(&link, target)
499        .with_context(|| format!("linking {} to {}", target.display(), link.display()))
500}
501
502#[cfg(not(unix))]
503fn copy_symlink(source: &Path, _target: &Path) -> Result<()> {
504    tracing::warn!("restore skips the link {}", source.display());
505    Ok(())
506}
507
508/// Removes copies a restore cut short by a crash left beside the data dir,
509/// except `backup`, which may be one of them after a failed swap.
510fn remove_stale_staging(parent: &Path, prefix: &str, backup: &Path) {
511    let Ok(entries) = fs::read_dir(parent) else {
512        return;
513    };
514    for entry in entries.flatten() {
515        if !entry.file_name().to_string_lossy().starts_with(prefix)
516            || fs::canonicalize(entry.path()).is_ok_and(|p| p == backup)
517        {
518            continue;
519        }
520        if let Err(e) = fs::remove_dir_all(entry.path()) {
521            tracing::warn!(
522                "cannot remove the partial restore {}: {e}",
523                entry.path().display()
524            );
525        }
526    }
527}
528
529fn with_staging_removed(error: anyhow::Error, staging: &Path) -> anyhow::Error {
530    match fs::remove_dir_all(staging) {
531        Ok(()) => error,
532        Err(e) if e.kind() == ErrorKind::NotFound => error,
533        Err(e) => error.context(format!(
534            "also failed to remove the partial restore {}: {e}",
535            staging.display()
536        )),
537    }
538}
539
540fn parent_of(path: &Path) -> Result<PathBuf> {
541    match path.parent() {
542        Some(dir) if !dir.as_os_str().is_empty() => Ok(dir.to_path_buf()),
543        Some(_) => Ok(PathBuf::from(".")),
544        None => bail!("{} has no parent directory", path.display()),
545    }
546}
547
548fn dir_name(path: &Path) -> Result<String> {
549    path.file_name()
550        .map(|n| n.to_string_lossy().into_owned())
551        .ok_or_else(|| anyhow!("{} has no directory name", path.display()))
552}
553
554#[cfg(test)]
555mod tests {
556    use super::*;
557
558    #[test]
559    fn left_behind_names_the_old_devices_files_and_key_temporaries() {
560        for name in LEFT_BEHIND {
561            assert!(left_behind(name), "{name}");
562        }
563        for name in [
564            ".device.key.tmp1",
565            ".store.key.x",
566            &format!("{PLAINTEXT_COPY_PREFIX}abc"),
567        ] {
568            assert!(left_behind(name), "{name}");
569        }
570        for name in [
571            "brain.db",
572            "store.key.wrapped",
573            "transcripts",
574            "brain.indexes",
575            "queue",
576        ] {
577            assert!(!left_behind(name), "{name}");
578        }
579    }
580
581    use crate::keys::{DeviceRecord, Epoch, IdentityKey, create_device_keys};
582    use crate::schema::{Memory, MemoryType};
583    use crate::store::Store;
584
585    const NOW: i64 = 1_793_600_000_000_000;
586
587    struct OldDevice {
588        dir: tempfile::TempDir,
589        tag: IdentityTag,
590        phrase: RecoveryPhrase,
591        memory: Memory,
592    }
593
594    fn open_restored(data_dir: &Path, machine_id: &str) -> SqliteStore {
595        let db = data_dir.join(DB_FILE);
596        if db_file_state(&db).unwrap() != FileState::Encrypted {
597            return SqliteStore::open(&db, machine_id.to_string()).unwrap();
598        }
599        let device = super::super::load_device_keys(data_dir).unwrap().unwrap();
600        let key = super::super::store_key_for(&db, &device).unwrap();
601        SqliteStore::open_with_key(&db, machine_id.to_string(), &key).unwrap()
602    }
603
604    #[cfg(feature = "encryption")]
605    #[test]
606    fn an_encrypted_backup_opens_with_the_phrase_and_comes_back_under_a_new_store_key() {
607        let old = old_device();
608        let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
609        let old_device_keys = super::super::load_device_keys(old.dir.path())
610            .unwrap()
611            .unwrap();
612        {
613            let store =
614                SqliteStore::open(&old.dir.path().join(DB_FILE), old_machine.id.clone()).unwrap();
615            super::super::encrypt_store(&store, old.dir.path(), &old_device_keys).unwrap();
616        }
617        assert!(old.dir.path().join(WRAPPED_STORE_KEY_FILE).exists());
618        let old_store_key =
619            super::super::read_store_key(&old.dir.path().join(STORE_KEY_FILE), &old_device_keys)
620                .unwrap()
621                .unwrap();
622
623        let home = tempfile::tempdir().unwrap();
624        let data_dir = home.path().join(".second-brain");
625        let restored = restore_backup(&RestoreRequest {
626            backup: old.dir.path(),
627            data_dir: &data_dir,
628            phrase: &old.phrase,
629            storage: &KeyStorage::File,
630            now_micros: NOW,
631        })
632        .unwrap();
633
634        let db = data_dir.join(DB_FILE);
635        assert_eq!(db_file_state(&db).unwrap(), FileState::Encrypted);
636        assert!(
637            SqliteStore::open_with_key(&db, restored.machine.id.clone(), &old_store_key).is_err(),
638            "the backup's store key must not open the restored store"
639        );
640        let store = open_restored(&data_dir, &restored.machine.id);
641        assert_eq!(
642            store.get_memory(old.memory.id).unwrap().unwrap().content,
643            old.memory.content
644        );
645        let new_key = super::super::unwrap_store_key_with_phrase(&data_dir, &restored.phrase)
646            .unwrap()
647            .expect("the restored data dir wraps its store key to the new phrase");
648        assert!(SqliteStore::open_with_key(&db, restored.machine.id.clone(), &new_key).is_ok());
649        assert!(
650            super::super::unwrap_store_key_with_phrase(&data_dir, &old.phrase).is_err(),
651            "the old phrase opens no store key of the new identity"
652        );
653    }
654
655    const SEALED_ENTRY: &str = "0000000000000000001-0b5c2f9e-5d0e-4c1a-9a57-0c7f4f1f2a10.sealed";
656
657    fn queued_forget() -> write_queue::Entry {
658        write_queue::Entry {
659            tool: "forget".to_string(),
660            method: "DELETE".to_string(),
661            path: "/v1/memory/m-1".to_string(),
662            query: Some("hard=false&reason=wrong".to_string()),
663            body: None,
664        }
665    }
666
667    /// A data dir of a device that synced with a peer under a migrated
668    /// identity and trusted one recovery phrase.
669    fn old_device() -> OldDevice {
670        let dir = tempfile::tempdir().unwrap();
671        let path = dir.path();
672        let machine = MachineIdentity::load_or_create(path).unwrap();
673        let device = create_device_keys(path, &KeyStorage::File).unwrap();
674        let store = SqliteStore::open(&path.join(DB_FILE), machine.id.clone()).unwrap();
675        store.register_machine(&machine).unwrap();
676
677        let epoch0 = IdentityKey::generate().unwrap();
678        let epoch1 = IdentityKey::generate().unwrap();
679        let tag = IdentityTag::migrated(&epoch0.key_id());
680        let epochs = [
681            Epoch {
682                number: 0,
683                key_id: epoch0.key_id(),
684            },
685            Epoch {
686                number: 1,
687                key_id: epoch1.key_id(),
688            },
689        ];
690        let own = machine.id.clone();
691        let envelopes = [
692            wrap(&epoch0, 0, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
693            wrap(&epoch1, 1, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
694        ];
695        let row = DeviceRecord {
696            machine_id: own.clone(),
697            identity_tag: tag.as_str().to_string(),
698            version: 1,
699            name: machine.name.clone(),
700            age_recipient: device.age_recipient().to_string(),
701            ssh_public_key: device.ssh_public_key(),
702            signing_public_key: device.verifying_key().to_bytes(),
703            recovery_fingerprints: Vec::new(),
704            ssh_login: None,
705            ssh_port: None,
706            ssh_host_key: None,
707        }
708        .sign(&own, device.signing_key());
709        store
710            .insert_first_device_record(&row, &own, &device.verifying_key())
711            .unwrap();
712        store
713            .put_keys_durably(&tag, &epochs, &envelopes, NOW)
714            .unwrap();
715
716        let phrase = RecoveryPhrase::generate().unwrap();
717        let held = [(epochs[0], &epoch0), (epochs[1], &epoch1)];
718        wrap_for_recovery(&store, &tag, &held, &[phrase.recipient().unwrap()]).unwrap();
719
720        let memory = Memory::new(
721            "the restored store keeps this".to_string(),
722            MemoryType::Semantic,
723            "test".to_string(),
724            String::new(),
725        );
726        store.store_memory(&memory).unwrap();
727        store.record_peer_ack("old-peer", 3, NOW).unwrap();
728        store.pin_peer("old-peer", 2).unwrap();
729        assert_eq!(store.peer_acks().unwrap().len(), 1);
730        drop(store);
731
732        fs::write(path.join("sync-peers"), "someone@old-peer\n").unwrap();
733        fs::write(path.join(".device.key.0123.tmp"), "half-written key").unwrap();
734        fs::write(path.join("api.token"), "old-token").unwrap();
735        fs::write(path.join(DEVICE_PUB_FILE), "age1old\n").unwrap();
736        fs::write(path.join("service.json"), "{\"from\":\"backup\"}").unwrap();
737        fs::create_dir(path.join("queue")).unwrap();
738        fs::write(path.join("queue").join("pending.json"), "{}").unwrap();
739        fs::write(
740            path.join("queue").join(SEALED_ENTRY),
741            queued_forget()
742                .to_sealed_file(&[device.age_recipient()])
743                .unwrap(),
744        )
745        .unwrap();
746        OldDevice {
747            dir,
748            tag,
749            phrase,
750            memory,
751        }
752    }
753
754    fn pins(store: &SqliteStore) -> i64 {
755        store
756            .conn()
757            .query_row("SELECT COUNT(*) FROM peer_pins", [], |r| r.get(0))
758            .unwrap()
759    }
760
761    #[test]
762    fn the_phrase_restores_a_backup_under_a_new_machine_id_and_identity() {
763        let old = old_device();
764        let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
765        let old_key = fs::read(old.dir.path().join(DEVICE_KEY_FILE)).unwrap();
766
767        let home = tempfile::tempdir().unwrap();
768        let data_dir = home.path().join(".second-brain");
769        fs::create_dir(&data_dir).unwrap();
770        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
771        SqliteStore::open(&data_dir.join(DB_FILE), fresh.id.clone()).unwrap();
772        fs::write(data_dir.join("service.json"), "{\"from\":\"host\"}").unwrap();
773
774        let typed = RecoveryPhrase::parse(&old.phrase.expose_text()).unwrap();
775        let restored = restore_backup(&RestoreRequest {
776            backup: old.dir.path(),
777            data_dir: &data_dir,
778            phrase: &typed,
779            storage: &KeyStorage::File,
780            now_micros: NOW,
781        })
782        .unwrap();
783
784        let machine = MachineIdentity::load_or_create(&data_dir).unwrap();
785        assert_eq!(machine.id, restored.machine.id);
786        assert_ne!(machine.id, old_machine.id);
787        assert_ne!(machine.id, fresh.id);
788        assert_ne!(fs::read(data_dir.join(DEVICE_KEY_FILE)).unwrap(), old_key);
789        assert!(!data_dir.join("sync-peers").exists());
790        assert!(!data_dir.join(".device.key.0123.tmp").exists());
791        assert!(!data_dir.join("api.token").exists());
792        assert!(!data_dir.join(DEVICE_PUB_FILE).exists());
793        assert_eq!(
794            fs::read_to_string(data_dir.join("service.json")).unwrap(),
795            "{\"from\":\"host\"}"
796        );
797        assert!(data_dir.join("queue").join("pending.json").exists());
798        let sealed = fs::read(data_dir.join("queue").join(SEALED_ENTRY)).unwrap();
799        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
800        let opened = write_queue::open(&sealed, Some(device.age_identity())).unwrap();
801        assert_eq!(opened, queued_forget());
802        let aside = restored.moved_aside.clone().unwrap();
803        assert!(aside.join(DB_FILE).exists());
804        assert_eq!(
805            MachineIdentity::load_or_create(&aside).unwrap().id,
806            fresh.id
807        );
808        assert!(
809            old.dir.path().join("sync-peers").exists(),
810            "the backup is untouched"
811        );
812
813        let expected = if cfg!(feature = "encryption") {
814            FileState::Encrypted
815        } else {
816            FileState::Plaintext
817        };
818        assert_eq!(db_file_state(&data_dir.join(DB_FILE)).unwrap(), expected);
819        let store = open_restored(&data_dir, &machine.id);
820        assert_eq!(
821            store.get_memory(old.memory.id).unwrap().unwrap().content,
822            old.memory.content
823        );
824        let row = store.device_record(&machine.id).unwrap().unwrap();
825        assert_eq!(row.current.record.identity_tag, restored.identity.as_str());
826        assert!(restored.identity.as_str().starts_with("f-"));
827        assert_ne!(restored.identity, old.tag);
828        assert_eq!(restored.opened, vec![old.tag.clone()]);
829        assert_eq!(
830            row.current.record.recovery_fingerprints,
831            vec![restored.phrase.fingerprint().unwrap()]
832        );
833
834        assert!(
835            store.peer_acks().unwrap().is_empty(),
836            "old neighbours are cleared"
837        );
838        assert_eq!(pins(&store), 0);
839
840        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
841        let mine = store.envelopes_for_machine(&machine.id).unwrap();
842        let old_epochs: Vec<u32> = mine
843            .iter()
844            .filter(|e| e.identity_tag == old.tag)
845            .map(|e| e.epoch.number)
846            .collect();
847        assert_eq!(
848            old_epochs,
849            vec![0, 1],
850            "old epochs stay readable on the new device"
851        );
852        for envelope in &mine {
853            envelope.open(device.age_identity()).unwrap();
854        }
855        let new_epochs = store.key_epochs(&restored.identity).unwrap();
856        assert_eq!(new_epochs.len(), 1);
857        assert_eq!(new_epochs[0].epoch.number, 1);
858
859        let shown = RecoveryPhrase::parse(&restored.phrase.expose_text()).unwrap();
860        let recipients = store.recovery_recipients(&restored.identity).unwrap();
861        assert_eq!(recipients.len(), 1);
862        assert_eq!(
863            recipients[0].to_string(),
864            shown.recipient().unwrap().to_string()
865        );
866        let envelope = store
867            .recovery_envelopes(&shown.recipient().unwrap())
868            .unwrap();
869        assert_eq!(envelope.len(), 3, "the new epoch and both old ones");
870        envelope[0].open(&shown.identity().unwrap()).unwrap();
871        assert!(
872            store
873                .recovery_recipients(&restored.identity)
874                .unwrap()
875                .iter()
876                .all(|r| r.to_string() != old.phrase.recipient().unwrap().to_string()),
877            "the old phrase is not trusted by the new identity"
878        );
879        let leftovers: Vec<_> = fs::read_dir(home.path())
880            .unwrap()
881            .filter_map(|e| e.ok())
882            .filter(|e| e.file_name().to_string_lossy().contains("restoring"))
883            .collect();
884        assert!(leftovers.is_empty());
885    }
886
887    #[test]
888    fn a_second_restore_with_the_new_phrase_opens_every_earlier_identity() {
889        let old = old_device();
890        let first_home = tempfile::tempdir().unwrap();
891        let first_dir = first_home.path().join(".second-brain");
892        let first = restore_backup(&RestoreRequest {
893            backup: old.dir.path(),
894            data_dir: &first_dir,
895            phrase: &old.phrase,
896            storage: &KeyStorage::File,
897            now_micros: NOW,
898        })
899        .unwrap();
900
901        let second_home = tempfile::tempdir().unwrap();
902        let second_dir = second_home.path().join(".second-brain");
903        let second = restore_backup(&RestoreRequest {
904            backup: &first_dir,
905            data_dir: &second_dir,
906            phrase: &first.phrase,
907            storage: &KeyStorage::File,
908            now_micros: NOW,
909        })
910        .unwrap();
911        let opened: BTreeSet<&str> = second.opened.iter().map(IdentityTag::as_str).collect();
912        assert_eq!(
913            opened,
914            BTreeSet::from([old.tag.as_str(), first.identity.as_str()])
915        );
916
917        let store = open_restored(&second_dir, &second.machine.id);
918        let device = super::super::load_device_keys(&second_dir)
919            .unwrap()
920            .unwrap();
921        let mine = store.envelopes_for_machine(&second.machine.id).unwrap();
922        let held = |tag: &IdentityTag| -> Vec<u32> {
923            mine.iter()
924                .filter(|e| &e.identity_tag == tag)
925                .map(|e| {
926                    e.open(device.age_identity()).unwrap();
927                    e.epoch.number
928                })
929                .collect()
930        };
931        assert_eq!(held(&old.tag), vec![0, 1]);
932        assert_eq!(held(&first.identity), vec![1]);
933        assert_eq!(held(&second.identity), vec![1]);
934        let last = store
935            .recovery_envelopes(&second.phrase.recipient().unwrap())
936            .unwrap();
937        assert_eq!(last.len(), 4, "every epoch reaches the newest phrase");
938    }
939
940    #[test]
941    fn a_restore_from_a_stranded_copy_keeps_that_copy() {
942        let old = old_device();
943        let home = tempfile::tempdir().unwrap();
944        let stranded = home.path().join("..second-brain.restoring-0123");
945        fs::create_dir(&stranded).unwrap();
946        copy_tree(old.dir.path(), &stranded, false).unwrap();
947        restore_backup(&RestoreRequest {
948            backup: &stranded,
949            data_dir: &home.path().join(".second-brain"),
950            phrase: &old.phrase,
951            storage: &KeyStorage::File,
952            now_micros: NOW,
953        })
954        .unwrap();
955        assert!(stranded.join(DB_FILE).exists());
956    }
957
958    #[test]
959    fn a_restore_binds_the_new_device_keys_to_this_hardware_not_the_backups() {
960        use crate::keys::{
961            HardwareCheck, HardwareId, check_hardware_with, read_binding, write_binding,
962        };
963
964        struct Here;
965        impl HardwareSource for Here {
966            fn read(&self, _data_dir: &Path) -> HardwareId {
967                HardwareId::parse("disk:the-new-hardware")
968            }
969        }
970
971        let old = old_device();
972        write_binding(
973            old.dir.path(),
974            &HardwareId::parse("disk:the-backups-hardware"),
975        )
976        .unwrap();
977        let home = tempfile::tempdir().unwrap();
978        let data_dir = home.path().join(".second-brain");
979        let restored = restore_with_hardware(
980            &BackupRestore {
981                backup: old.dir.path(),
982                data_dir: &data_dir,
983                keys: BackupKeys::Phrase(&old.phrase),
984                storage: &KeyStorage::File,
985                now_micros: NOW,
986            },
987            &Here,
988        )
989        .unwrap();
990        assert_eq!(
991            read_binding(&data_dir).unwrap(),
992            Some(HardwareId::parse("disk:the-new-hardware"))
993        );
994        assert_eq!(
995            check_hardware_with(&data_dir, &data_dir, &KeyStorage::File, &Here).unwrap(),
996            HardwareCheck::Bound
997        );
998        assert_eq!(
999            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1000            restored.machine.id
1001        );
1002    }
1003
1004    #[test]
1005    fn a_restore_into_a_missing_data_dir_creates_it() {
1006        let old = old_device();
1007        let home = tempfile::tempdir().unwrap();
1008        let data_dir = home.path().join(".second-brain");
1009        let stale = home.path().join("..second-brain.restoring-0123");
1010        fs::create_dir(&stale).unwrap();
1011        fs::write(stale.join(DB_FILE), "left by a crash").unwrap();
1012        let restored = restore_backup(&RestoreRequest {
1013            backup: old.dir.path(),
1014            data_dir: &data_dir,
1015            phrase: &old.phrase,
1016            storage: &KeyStorage::File,
1017            now_micros: NOW,
1018        })
1019        .unwrap();
1020        assert!(restored.moved_aside.is_none());
1021        assert!(!stale.exists(), "a crashed restore's copy is removed");
1022        assert!(data_dir.join(DB_FILE).exists());
1023        assert!(!data_dir.join("service.json").exists());
1024    }
1025
1026    fn handed_from(old: &OldDevice) -> Vec<HeldEpoch> {
1027        let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1028        let device = super::super::load_device_keys(old.dir.path())
1029            .unwrap()
1030            .unwrap();
1031        let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1032        let held = super::super::every_held_epoch(&store, &device).unwrap();
1033        let transit = DeviceKeys::generate().unwrap();
1034        let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1035        super::super::open_handed(&envelopes, &transit).unwrap()
1036    }
1037
1038    #[cfg(feature = "encryption")]
1039    #[test]
1040    fn epochs_a_surviving_device_hands_over_restore_an_encrypted_backup_as_a_new_identity() {
1041        let old = old_device();
1042        let backup = tempfile::tempdir().unwrap();
1043        {
1044            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1045            let device = super::super::load_device_keys(old.dir.path())
1046                .unwrap()
1047                .unwrap();
1048            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1049            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1050        }
1051        copy_tree(old.dir.path(), backup.path(), false).unwrap();
1052        let held = {
1053            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1054            let device = super::super::load_device_keys(old.dir.path())
1055                .unwrap()
1056                .unwrap();
1057            let key = super::super::store_key_for(&old.dir.path().join(DB_FILE), &device).unwrap();
1058            let store = SqliteStore::open_with_key(&old.dir.path().join(DB_FILE), machine.id, &key)
1059                .unwrap();
1060            let held = super::super::every_held_epoch(&store, &device).unwrap();
1061            let transit = DeviceKeys::generate().unwrap();
1062            let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1063            super::super::open_handed(&envelopes, &transit).unwrap()
1064        };
1065
1066        let home = tempfile::tempdir().unwrap();
1067        let data_dir = home.path().join(".second-brain");
1068        let restored = restore_backup_with(&BackupRestore {
1069            backup: backup.path(),
1070            data_dir: &data_dir,
1071            keys: BackupKeys::Epochs(&held),
1072            storage: &KeyStorage::File,
1073            now_micros: NOW,
1074        })
1075        .unwrap();
1076
1077        assert_ne!(restored.identity, old.tag);
1078        assert_eq!(restored.opened, vec![old.tag.clone()]);
1079        let store = open_restored(&data_dir, &restored.machine.id);
1080        assert_eq!(
1081            store.get_memory(old.memory.id).unwrap().unwrap().content,
1082            old.memory.content
1083        );
1084        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
1085        let kept: Vec<u32> = store
1086            .envelopes_for_machine(&restored.machine.id)
1087            .unwrap()
1088            .iter()
1089            .filter(|e| e.identity_tag == old.tag)
1090            .map(|e| e.epoch.number)
1091            .collect();
1092        assert_eq!(kept, vec![0, 1], "the handed epochs stay decrypt-only");
1093        let opened = super::super::every_held_epoch(&store, &device).unwrap();
1094        assert_eq!(opened.len(), 3, "both old epochs and the new identity's");
1095        let recovery = store
1096            .recovery_envelopes(&restored.phrase.recipient().unwrap())
1097            .unwrap();
1098        assert_eq!(recovery.len(), 3, "the new phrase opens the old epochs too");
1099    }
1100
1101    #[cfg(feature = "encryption")]
1102    #[test]
1103    fn a_surviving_device_restores_onto_itself_with_its_own_past_epochs() {
1104        let old = old_device();
1105        {
1106            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1107            let device = super::super::load_device_keys(old.dir.path())
1108                .unwrap()
1109                .unwrap();
1110            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1111            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1112        }
1113        let backup = tempfile::tempdir().unwrap();
1114        copy_tree(old.dir.path(), backup.path(), false).unwrap();
1115        let own = super::super::every_held_epoch_in(old.dir.path(), &KeyStorage::File).unwrap();
1116        assert_eq!(own.len(), 2);
1117
1118        let restored = restore_backup_with(&BackupRestore {
1119            backup: backup.path(),
1120            data_dir: old.dir.path(),
1121            keys: BackupKeys::Epochs(&own),
1122            storage: &KeyStorage::File,
1123            now_micros: NOW,
1124        })
1125        .unwrap();
1126
1127        let aside = restored
1128            .moved_aside
1129            .clone()
1130            .expect("its own store moves aside");
1131        assert!(aside.to_string_lossy().contains(".before-restore-"));
1132        assert!(aside.join(DB_FILE).exists());
1133        assert!(aside.join(DEVICE_KEY_FILE).exists());
1134        assert_eq!(restored.opened, vec![old.tag.clone()]);
1135        assert_eq!(
1136            db_file_state(&backup.path().join(DB_FILE)).unwrap(),
1137            FileState::Encrypted,
1138            "the backup opens only through the wrapped store key"
1139        );
1140        let store = open_restored(old.dir.path(), &restored.machine.id);
1141        assert_eq!(
1142            store.get_memory(old.memory.id).unwrap().unwrap().content,
1143            old.memory.content
1144        );
1145        fs::remove_dir_all(&aside).unwrap();
1146    }
1147
1148    #[cfg(feature = "encryption")]
1149    #[test]
1150    fn a_live_backup_of_the_store_and_its_wrapped_key_restores_with_own_epochs() {
1151        let old = old_device();
1152        let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1153        let device = super::super::load_device_keys(old.dir.path())
1154            .unwrap()
1155            .unwrap();
1156        {
1157            let store =
1158                SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id.clone()).unwrap();
1159            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1160        }
1161        let live = open_restored(old.dir.path(), &machine.id);
1162        let backup = tempfile::tempdir().unwrap();
1163        live.vacuum_into(&backup.path().join(DB_FILE)).unwrap();
1164        fs::copy(
1165            old.dir.path().join(WRAPPED_STORE_KEY_FILE),
1166            backup.path().join(WRAPPED_STORE_KEY_FILE),
1167        )
1168        .unwrap();
1169        let own = super::super::every_held_epoch_in(old.dir.path(), &KeyStorage::File).unwrap();
1170
1171        let home = tempfile::tempdir().unwrap();
1172        let data_dir = home.path().join(".second-brain");
1173        let restored = restore_backup_with(&BackupRestore {
1174            backup: backup.path(),
1175            data_dir: &data_dir,
1176            keys: BackupKeys::Epochs(&own),
1177            storage: &KeyStorage::File,
1178            now_micros: NOW,
1179        })
1180        .unwrap();
1181        let store = open_restored(&data_dir, &restored.machine.id);
1182        assert_eq!(store.live_counts().unwrap(), live.live_counts().unwrap());
1183    }
1184
1185    #[cfg(feature = "encryption")]
1186    #[test]
1187    fn handed_epochs_that_do_not_seal_the_backup_change_nothing() {
1188        let old = old_device();
1189        {
1190            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1191            let device = super::super::load_device_keys(old.dir.path())
1192                .unwrap()
1193                .unwrap();
1194            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1195            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1196        }
1197        let held = handed_from(&old_device());
1198        let home = tempfile::tempdir().unwrap();
1199        let data_dir = home.path().join(".second-brain");
1200        fs::create_dir(&data_dir).unwrap();
1201        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1202
1203        let err = restore_backup_with(&BackupRestore {
1204            backup: old.dir.path(),
1205            data_dir: &data_dir,
1206            keys: BackupKeys::Epochs(&held),
1207            storage: &KeyStorage::File,
1208            now_micros: NOW,
1209        })
1210        .unwrap_err();
1211
1212        assert!(
1213            format!("{err:#}").contains("none of the keys at hand"),
1214            "{err:#}"
1215        );
1216        assert_eq!(
1217            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1218            fresh.id
1219        );
1220        let names: Vec<String> = fs::read_dir(home.path())
1221            .unwrap()
1222            .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1223            .collect();
1224        assert_eq!(names, vec![".second-brain".to_string()]);
1225    }
1226
1227    #[test]
1228    fn no_handed_epochs_change_nothing() {
1229        let old = old_device();
1230        let home = tempfile::tempdir().unwrap();
1231        let data_dir = home.path().join(".second-brain");
1232        fs::create_dir(&data_dir).unwrap();
1233        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1234
1235        let err = restore_backup_with(&BackupRestore {
1236            backup: old.dir.path(),
1237            data_dir: &data_dir,
1238            keys: BackupKeys::Epochs(&[]),
1239            storage: &KeyStorage::File,
1240            now_micros: NOW,
1241        })
1242        .unwrap_err();
1243
1244        assert!(format!("{err:#}").contains("no key"), "{err:#}");
1245        assert_eq!(
1246            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1247            fresh.id
1248        );
1249    }
1250
1251    #[test]
1252    fn a_wrong_phrase_changes_nothing() {
1253        let old = old_device();
1254        let home = tempfile::tempdir().unwrap();
1255        let data_dir = home.path().join(".second-brain");
1256        fs::create_dir(&data_dir).unwrap();
1257        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1258
1259        let other = RecoveryPhrase::generate().unwrap();
1260        let err = restore_backup(&RestoreRequest {
1261            backup: old.dir.path(),
1262            data_dir: &data_dir,
1263            phrase: &other,
1264            storage: &KeyStorage::File,
1265            now_micros: NOW,
1266        })
1267        .unwrap_err();
1268        assert!(format!("{err:#}").contains("opens no key"), "{err:#}");
1269        assert_eq!(
1270            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1271            fresh.id
1272        );
1273        let names: Vec<String> = fs::read_dir(home.path())
1274            .unwrap()
1275            .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1276            .collect();
1277        assert_eq!(names, vec![".second-brain".to_string()]);
1278    }
1279
1280    #[test]
1281    fn a_directory_without_a_store_is_not_a_backup() {
1282        let empty = tempfile::tempdir().unwrap();
1283        let home = tempfile::tempdir().unwrap();
1284        let phrase = RecoveryPhrase::generate().unwrap();
1285        let err = restore_backup(&RestoreRequest {
1286            backup: empty.path(),
1287            data_dir: &home.path().join(".second-brain"),
1288            phrase: &phrase,
1289            storage: &KeyStorage::File,
1290            now_micros: NOW,
1291        })
1292        .unwrap_err();
1293        assert!(format!("{err:#}").contains("holds no brain.db"), "{err:#}");
1294    }
1295
1296    /// A rename that fails on calls `first..=last`, counting from 1.
1297    fn failing(first: usize, last: usize) -> impl Fn(&Path, &Path) -> io::Result<()> {
1298        let calls = std::cell::Cell::new(0);
1299        move |from, to| {
1300            calls.set(calls.get() + 1);
1301            if (first..=last).contains(&calls.get()) {
1302                return Err(io::Error::other("injected rename failure"));
1303            }
1304            fs::rename(from, to)
1305        }
1306    }
1307
1308    fn dirs_with_marker(home: &Path) -> (PathBuf, PathBuf) {
1309        let data_dir = home.join(".second-brain");
1310        let staging = home.join(".second-brain.restoring-test");
1311        fs::create_dir(&data_dir).unwrap();
1312        fs::write(data_dir.join("marker"), "old").unwrap();
1313        fs::create_dir(&staging).unwrap();
1314        fs::write(staging.join("marker"), "restored").unwrap();
1315        (data_dir, staging)
1316    }
1317
1318    #[test]
1319    fn a_failed_swap_puts_the_old_data_dir_back() {
1320        let home = tempfile::tempdir().unwrap();
1321        let (data_dir, staging) = dirs_with_marker(home.path());
1322        let Err(Swap::Untouched(err)) =
1323            swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 2))
1324        else {
1325            panic!("the swap must fail with the data dir back in place");
1326        };
1327        assert!(format!("{err:#}").contains("injected"), "{err:#}");
1328        assert_eq!(fs::read_to_string(data_dir.join("marker")).unwrap(), "old");
1329        assert!(staging.join("marker").exists());
1330    }
1331
1332    #[test]
1333    fn a_swap_that_cannot_move_back_names_both_copies_and_keeps_them() {
1334        let home = tempfile::tempdir().unwrap();
1335        let (data_dir, staging) = dirs_with_marker(home.path());
1336        let Err(Swap::Stranded(err)) =
1337            swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 3))
1338        else {
1339            panic!("the swap must report both copies");
1340        };
1341        let shown = format!("{err:#}");
1342        assert!(shown.contains(&staging.display().to_string()), "{shown}");
1343        assert!(shown.contains("before-restore"), "{shown}");
1344        assert!(staging.join("marker").exists());
1345    }
1346}