use std::path::PathBuf;
use std::sync::Arc;
use std::time::{Duration, Instant};
use anyhow::Result;
use chrono::Utc;
use second_brain_core::keys::{
self, DeviceKeys, KeyStorage, StoreEncryption, WrapRefresh, encrypt_store, rotate_store_key,
};
use second_brain_core::sqlite_store::encrypt_migration::{
NotReopened, ReadsHeld, Rewrite, remove_plaintext_copies,
};
use second_brain_core::sqlite_store::{SqliteStore, VacuumSpace};
use tokio::task::JoinHandle;
use tokio::time::MissedTickBehavior;
use crate::health::{EncryptionState, Health};
use crate::write_gate::WriteGate;
pub const TICK: Duration = Duration::from_secs(60);
const RETRY_AFTER_FAILURE: Duration = Duration::from_secs(24 * 3600);
const RETRY_AFTER_HELD_READS: Duration = Duration::from_secs(3600);
pub const PLAINTEXT_COPY_LIFETIME: Duration = Duration::from_secs(24 * 3600);
const NOTICE_SHOWN_FOR_MICROS: i64 = 7 * 24 * 3600 * 1_000_000;
pub struct StoreEncryptor {
pub store: Arc<SqliteStore>,
pub gate: Arc<WriteGate>,
pub health: Arc<Health>,
pub data_dir: PathBuf,
pub storage: KeyStorage,
pub space: fn(&SqliteStore) -> Result<VacuumSpace>,
in_data_dir: bool,
pending: bool,
waiting_for_space: bool,
last_writes: Option<u64>,
retry_at: Option<Instant>,
}
#[derive(Debug, PartialEq, Eq)]
pub enum Tick {
Idle,
NotQuiet,
NoSpace,
Encrypted(Duration),
Rotated(Duration),
Failed(String),
}
impl StoreEncryptor {
pub fn new(
store: Arc<SqliteStore>,
gate: Arc<WriteGate>,
health: Arc<Health>,
data_dir: PathBuf,
storage: KeyStorage,
encryption: StoreEncryption,
) -> Self {
let in_data_dir = keys::store_in_data_dir(&store, &data_dir);
if !in_data_dir {
tracing::info!(
"the store is outside {}, so its key files are left to the dir it is in",
data_dir.display()
);
}
let pending = encryption == StoreEncryption::Pending;
let state = match encryption {
StoreEncryption::Encrypted => EncryptionState::Encrypted,
StoreEncryption::Pending => EncryptionState::Pending,
_ => EncryptionState::Plaintext,
};
health.encryption(state, None, Utc::now());
if let Ok(Some(record)) = store.encrypted_record() {
let recent = Utc::now().timestamp_micros() - record.at_micros < NOTICE_SHOWN_FOR_MICROS;
health.encryption_migrated(record.pause_ms, recent, Utc::now());
}
Self {
store,
gate,
health,
data_dir,
storage,
space: SqliteStore::rewrite_space,
in_data_dir,
pending,
waiting_for_space: false,
last_writes: None,
retry_at: None,
}
}
pub fn spawn(mut self) -> JoinHandle<()> {
tokio::spawn(async move {
let mut interval = tokio::time::interval(TICK);
interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
loop {
interval.tick().await;
let ticked = tokio::task::spawn_blocking(move || {
let outcome = self.tick(Instant::now());
(self, outcome)
})
.await;
match ticked {
Ok((encryptor, outcome)) => {
self = encryptor;
log(&outcome);
}
Err(e) => {
tracing::error!("store encryption tick panicked: {e}");
return;
}
}
}
})
}
pub fn tick(&mut self, now: Instant) -> Tick {
if let Err(e) = remove_plaintext_copies(&self.data_dir, Some(PLAINTEXT_COPY_LIFETIME)) {
tracing::warn!("cannot remove old plaintext copies: {e:#}");
}
if !self.in_data_dir {
return Tick::Idle;
}
let writes = self.store.write_count();
let quiet = self.last_writes == Some(writes);
self.last_writes = Some(writes);
let device = match keys::load_device_keys_in(&self.data_dir, &self.storage) {
Ok(Some(device)) => device,
Ok(None) => return Tick::Idle,
Err(e) => return Tick::Failed(format!("{e:#}")),
};
if self.store.is_encrypted() {
self.refresh_wrap(&device);
}
let due = if self.pending {
true
} else if self.store.is_encrypted() {
match (
self.store.revocations_after_store_key(),
self.store.retirements_after_store_key(),
) {
(Ok(revoked), Ok(retired)) => !revoked.is_empty() || !retired.is_empty(),
(Err(e), _) | (_, Err(e)) => return Tick::Failed(format!("{e:#}")),
}
} else {
false
};
if !due || self.retry_at.is_some_and(|at| now < at) {
return Tick::Idle;
}
let space = match (self.space)(&self.store) {
Ok(space) => space,
Err(e) => return Tick::Failed(format!("{e:#}")),
};
if !space.fits() {
if self.pending {
self.waiting_for_space = true;
self.health
.encryption(EncryptionState::WaitingForSpace, Some(space), Utc::now());
}
return Tick::NoSpace;
}
if std::mem::take(&mut self.waiting_for_space) {
self.health
.encryption(EncryptionState::Pending, None, Utc::now());
}
if !quiet {
return Tick::NotQuiet;
}
let outcome = self.rewrite(&device);
match outcome {
Ok(tick) => {
self.last_writes = Some(self.store.write_count());
tick
}
Err(e) => {
if e.downcast_ref::<NotReopened>().is_some() {
tracing::error!("{e:#}");
std::process::exit(1);
}
let message = format!("{e:#}");
self.retry_at = Some(now + retry_after(&e));
let state = if self.pending {
EncryptionState::Pending
} else {
EncryptionState::Encrypted
};
self.health.encryption(state, None, Utc::now());
self.health.encryption_failed(&message, Utc::now());
Tick::Failed(message)
}
}
}
fn rewrite(&mut self, device: &DeviceKeys) -> Result<Tick> {
let _closed = self.gate.close();
if self.pending {
self.health
.encryption(EncryptionState::Encrypting, None, Utc::now());
let Rewrite { pause, .. } = encrypt_store(&self.store, &self.data_dir, device)?;
self.pending = false;
self.health
.encryption(EncryptionState::Encrypted, None, Utc::now());
self.health.encryption_migrated(
u64::try_from(pause.as_millis()).unwrap_or(u64::MAX),
true,
Utc::now(),
);
Ok(Tick::Encrypted(pause))
} else {
self.health
.encryption(EncryptionState::Rotating, None, Utc::now());
let Rewrite { pause, .. } = rotate_store_key(&self.store, &self.data_dir, device)?;
self.health
.encryption(EncryptionState::Encrypted, None, Utc::now());
Ok(Tick::Rotated(pause))
}
}
fn refresh_wrap(&self, device: &DeviceKeys) {
match keys::refresh_store_key_wrap(&self.store, &self.data_dir, device) {
Ok(WrapRefresh::Written) => {
tracing::info!("store.key.wrapped follows the newest epoch")
}
Ok(_) => {}
Err(e) => tracing::warn!("cannot refresh store.key.wrapped: {e:#}"),
}
}
}
fn retry_after(error: &anyhow::Error) -> Duration {
if error.downcast_ref::<ReadsHeld>().is_some() {
RETRY_AFTER_HELD_READS
} else {
RETRY_AFTER_FAILURE
}
}
fn log(outcome: &Tick) {
match outcome {
Tick::Encrypted(pause) => tracing::info!(
pause_ms = pause.as_millis() as u64,
"the store is encrypted; writes waited for the rewrite"
),
Tick::Rotated(pause) => tracing::info!(
pause_ms = pause.as_millis() as u64,
"the store key was rotated after a revocation or a recovery phrase retirement"
),
Tick::Failed(e) => tracing::warn!("store encryption: {e}"),
Tick::NoSpace => tracing::warn!("store encryption waits for disk space"),
Tick::Idle | Tick::NotQuiet => {}
}
}
#[cfg(test)]
mod tests {
use std::collections::BTreeSet;
use std::path::Path;
use second_brain_core::keys::{
KeyStorage, RecoveryPhrase, Retirement, Revocation, STORE_KEY_FILE, found_identity,
load_device_keys_in, open_device_store, read_store_key,
};
use second_brain_core::schema::{Memory, MemoryType};
use second_brain_core::sqlite_store::encrypt_migration::{FileState, db_file_state};
use second_brain_core::store::Store;
use super::*;
fn remember(store: &SqliteStore, content: &str) {
store
.store_memory(&Memory::new(
content.to_string(),
MemoryType::Semantic,
"test".to_string(),
String::new(),
))
.unwrap();
}
fn encryptor(dir: &Path) -> (StoreEncryptor, Arc<Health>) {
let opened = open_device_store(
&dir.join("brain.db"),
dir,
"machine-a".to_string(),
&KeyStorage::File,
)
.unwrap();
let store = Arc::new(opened.store);
keys::ensure_device_keys(&store, dir).unwrap();
let health = Arc::new(Health::new(Utc::now(), None));
let encryptor = StoreEncryptor::new(
store,
Arc::new(WriteGate::default()),
health.clone(),
dir.to_path_buf(),
KeyStorage::File,
opened.encryption,
);
(encryptor, health)
}
fn plaintext_data_dir() -> tempfile::TempDir {
let dir = tempfile::tempdir().unwrap();
let store = SqliteStore::open(&dir.path().join("brain.db"), "machine-a".into()).unwrap();
remember(&store, "written before the upgrade");
dir
}
#[test]
fn a_plaintext_store_is_encrypted_after_a_minute_with_no_write() {
let dir = plaintext_data_dir();
let (mut enc, health) = encryptor(dir.path());
assert_eq!(health.report().encryption.state, EncryptionState::Pending);
let t0 = Instant::now();
assert_eq!(enc.tick(t0), Tick::NotQuiet);
remember(&enc.store, "a write in the first minute");
assert_eq!(enc.tick(t0 + TICK), Tick::NotQuiet);
assert!(matches!(enc.tick(t0 + TICK * 2), Tick::Encrypted(_)));
let report = health.report().encryption;
assert_eq!(report.state, EncryptionState::Encrypted);
assert!(report.migration_pause_ms.is_some());
assert!(report.notice.is_some_and(|n| n.contains("full-disk")));
assert!(enc.store.is_encrypted());
assert_eq!(enc.store.memory_count().unwrap(), 2);
assert_eq!(enc.tick(t0 + TICK * 3), Tick::Idle);
drop(enc);
assert_eq!(
db_file_state(&dir.path().join("brain.db")).unwrap(),
FileState::Encrypted
);
let (_again, health) = encryptor(dir.path());
let report = health.report().encryption;
assert_eq!(report.state, EncryptionState::Encrypted);
assert!(report.notice.is_some(), "the notice survives a restart");
}
fn no_room(_: &SqliteStore) -> Result<VacuumSpace> {
Ok(VacuumSpace {
path: PathBuf::from("/data"),
needed_bytes: 5_000_000_000,
free_bytes: 1_000_000_000,
})
}
#[test]
fn a_disk_without_room_holds_the_migration_and_says_how_much_it_needs() {
let dir = plaintext_data_dir();
let (mut enc, health) = encryptor(dir.path());
enc.space = no_room;
let t0 = Instant::now();
enc.tick(t0);
assert_eq!(enc.tick(t0 + TICK), Tick::NoSpace);
let report = health.report();
assert_eq!(report.encryption.state, EncryptionState::WaitingForSpace);
let reason = report.reason.unwrap_or_default();
assert!(
reason.contains("encryption pending, needs 5000 MB"),
"{reason}"
);
assert!(!enc.store.is_encrypted());
}
#[test]
fn the_space_notice_clears_once_room_frees_without_waiting_for_a_quiet_minute() {
let dir = plaintext_data_dir();
let (mut enc, health) = encryptor(dir.path());
enc.space = no_room;
let t0 = Instant::now();
assert_eq!(enc.tick(t0), Tick::NoSpace);
assert_eq!(
health.report().encryption.state,
EncryptionState::WaitingForSpace
);
enc.space = SqliteStore::rewrite_space;
remember(&enc.store, "a write that keeps the minute busy");
assert_eq!(enc.tick(t0 + TICK), Tick::NotQuiet);
let report = health.report();
assert_eq!(report.encryption.state, EncryptionState::Pending);
assert!(
!report.reason.unwrap_or_default().contains("needs"),
"the space reason is gone"
);
}
#[test]
fn a_revocation_of_another_device_rotates_the_store_key() {
let dir = tempfile::tempdir().unwrap();
let (mut enc, _health) = encryptor(dir.path());
assert!(enc.store.is_encrypted());
let device = load_device_keys_in(dir.path(), &KeyStorage::File)
.unwrap()
.unwrap();
let founded = found_identity(&enc.store, &device, "machine-a", &[], 1).unwrap();
let t0 = Instant::now();
enc.tick(t0);
assert_eq!(enc.tick(t0 + TICK), Tick::Idle, "nothing to rotate for");
let before = read_store_key(&dir.path().join(STORE_KEY_FILE), &device)
.unwrap()
.unwrap();
let signed = Revocation {
identity_tag: founded.tag.as_str().to_string(),
revoker: "machine-a".to_string(),
target: "lost-laptop".to_string(),
keep: BTreeSet::new(),
created_at_micros: 2,
}
.sign(device.signing_key());
enc.store
.put_revocation(&signed, &device.verifying_key())
.unwrap();
assert_eq!(enc.tick(t0 + TICK * 2), Tick::NotQuiet);
let rotated = enc.tick(t0 + TICK * 3);
assert!(matches!(rotated, Tick::Rotated(_)), "{rotated:?}");
let after = read_store_key(&dir.path().join(STORE_KEY_FILE), &device)
.unwrap()
.unwrap();
assert_ne!(after.expose(), before.expose());
assert_eq!(
enc.tick(t0 + TICK * 4),
Tick::Idle,
"one rotation per revocation"
);
}
#[test]
fn a_retired_phrase_rotates_the_store_key_once_and_a_made_up_one_does_not() {
let dir = tempfile::tempdir().unwrap();
let (mut enc, _health) = encryptor(dir.path());
let device = load_device_keys_in(dir.path(), &KeyStorage::File)
.unwrap()
.unwrap();
let phrase = RecoveryPhrase::generate().unwrap();
let founded = found_identity(
&enc.store,
&device,
"machine-a",
&[phrase.recipient().unwrap()],
1,
)
.unwrap();
let t0 = Instant::now();
enc.tick(t0);
assert_eq!(enc.tick(t0 + TICK), Tick::Idle, "nothing to rotate for");
let key_now = || {
read_store_key(&dir.path().join(STORE_KEY_FILE), &device)
.unwrap()
.unwrap()
};
let store = enc.store.clone();
let retire = |fingerprint: String| {
let signed = Retirement {
identity_tag: founded.tag.as_str().to_string(),
retirer: "machine-a".to_string(),
fingerprint,
created_at_micros: 2,
}
.sign(device.signing_key());
store
.put_retirement(&signed, &device.verifying_key())
.unwrap();
store.mark_rotating_retirements(&founded.tag).unwrap();
};
let before = key_now();
retire("00112233445566ff".to_string());
for i in 2..5 {
assert_eq!(enc.tick(t0 + TICK * i), Tick::Idle, "made up");
}
assert_eq!(key_now().expose(), before.expose());
retire(phrase.fingerprint().unwrap());
let ticks: Vec<Tick> = (5..8).map(|i| enc.tick(t0 + TICK * i)).collect();
let rotations = ticks
.iter()
.filter(|t| matches!(t, Tick::Rotated(_)))
.count();
assert_eq!(rotations, 1, "one rotation per retirement: {ticks:?}");
assert_ne!(key_now().expose(), before.expose());
}
#[test]
fn held_reads_retry_within_the_hour_and_other_failures_the_next_day() {
let held = anyhow::Error::from(ReadsHeld(Duration::from_secs(30)))
.context("rotating the store key");
assert_eq!(retry_after(&held), RETRY_AFTER_HELD_READS);
assert_eq!(
retry_after(&anyhow::anyhow!("the copy failed its check")),
RETRY_AFTER_FAILURE
);
}
#[test]
fn a_store_outside_the_data_dir_is_left_alone() {
let data = tempfile::tempdir().unwrap();
let elsewhere = tempfile::tempdir().unwrap();
let opened = open_device_store(
&elsewhere.path().join("copy.db"),
data.path(),
"m".into(),
&KeyStorage::File,
)
.unwrap();
let store = Arc::new(opened.store);
keys::ensure_device_keys(&store, data.path()).unwrap();
let health = Arc::new(Health::new(Utc::now(), None));
let mut enc = StoreEncryptor::new(
store,
Arc::new(WriteGate::default()),
health.clone(),
data.path().to_path_buf(),
KeyStorage::File,
opened.encryption,
);
let t0 = Instant::now();
for i in 0..3 {
assert_eq!(enc.tick(t0 + TICK * i), Tick::Idle);
}
assert_eq!(health.report().encryption.state, EncryptionState::Plaintext);
}
#[test]
fn an_encrypted_copy_outside_the_data_dir_is_neither_rewrapped_nor_rotated() {
let data = tempfile::tempdir().unwrap();
let elsewhere = tempfile::tempdir().unwrap();
let opened = open_device_store(
&elsewhere.path().join("brain.db"),
elsewhere.path(),
"m".into(),
&KeyStorage::File,
)
.unwrap();
assert_eq!(opened.encryption, StoreEncryption::Encrypted);
let store = Arc::new(opened.store);
keys::ensure_device_keys(&store, data.path()).unwrap();
let device = load_device_keys_in(data.path(), &KeyStorage::File)
.unwrap()
.unwrap();
let founded = found_identity(&store, &device, "m", &[], 1).unwrap();
let signed = Revocation {
identity_tag: founded.tag.as_str().to_string(),
revoker: "m".to_string(),
target: "lost-laptop".to_string(),
keep: BTreeSet::new(),
created_at_micros: 2,
}
.sign(device.signing_key());
store
.put_revocation(&signed, &device.verifying_key())
.unwrap();
let health = Arc::new(Health::new(Utc::now(), None));
let mut enc = StoreEncryptor::new(
store,
Arc::new(WriteGate::default()),
health,
data.path().to_path_buf(),
KeyStorage::File,
opened.encryption,
);
let t0 = Instant::now();
for i in 0..3 {
assert_eq!(enc.tick(t0 + TICK * i), Tick::Idle);
}
assert!(!data.path().join(keys::WRAPPED_STORE_KEY_FILE).exists());
}
#[test]
fn old_plaintext_copies_are_removed_by_the_tick() {
let dir = tempfile::tempdir().unwrap();
let (mut enc, _health) = encryptor(dir.path());
let copy = enc.store.write_plaintext_copy(dir.path()).unwrap();
enc.tick(Instant::now());
assert!(copy.exists(), "a fresh copy stays for its lifetime");
let old = std::time::SystemTime::now() - PLAINTEXT_COPY_LIFETIME * 2;
std::fs::File::options()
.write(true)
.open(©)
.unwrap()
.set_modified(old)
.unwrap();
enc.tick(Instant::now());
assert!(!copy.exists());
}
}