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