//! Fixed, preprovisioned confidential delegation journal. Never log request bytes. use crate::helper_ipc::{self as ipc, FileIdentity, PinnedFile}; use anyhow::{Result, ensure}; use chrono::{DateTime, Utc}; use rmm_agent_core::{ auth::Request, helper_reconcile::{NoDispatchObservation, NoStartAnchor}, }; use rmm_domain::jobs::{ExecutionPermitPayload, hash}; use rusqlite::{Connection, OpenFlags, OptionalExtension, TransactionBehavior, params}; use serde::{Deserialize, Serialize}; use std::{path::Path, time::Duration}; use uuid::Uuid; pub const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents"; pub const DB: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"; const ACTOR_RW: u32 = 0x0012_019f; const SCHEMA:&str="CREATE TABLE IF NOT EXISTS system_intent_meta(id INTEGER PRIMARY KEY CHECK(id=1),file_identity BLOB NOT NULL); CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1)),UNIQUE(job,attempt)); CREATE TABLE IF NOT EXISTS system_intent_mirrors(id TEXT PRIMARY KEY,outcome_sha256 TEXT NOT NULL,mirror_observed_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS system_intent_denial_resumes(id TEXT NOT NULL,agent_instance TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(id,agent_instance)); CREATE TRIGGER IF NOT EXISTS system_intents_no_delete BEFORE DELETE ON system_intents BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR NOT ((NEW.phase=OLD.phase AND NEW.cancel_requested=1 AND OLD.cancel_requested IN (0,1)) OR (OLD.phase='prepared' AND NEW.phase IN ('known_no_dispatch','may_have_dispatched') AND NEW.cancel_requested=OLD.cancel_requested)) BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_mirrors_no_delete BEFORE DELETE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_mirrors_no_update BEFORE UPDATE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_delete BEFORE DELETE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_update BEFORE UPDATE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;"; const LEGACY_INTENTS_TABLE: &str = "CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),UNIQUE(job,attempt));"; const LEGACY_MONOTONIC: &str = "CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;"; const CLAIM_RESUME: &str = "INSERT OR IGNORE INTO system_intent_denial_resumes(id,agent_instance,observed_at) VALUES(?1,?2,?3)"; fn initialize_schema(db: &mut Connection) -> Result<()> { let exists: bool = db.query_row( "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='system_intents')", [], |r| r.get(0), )?; if exists { let columns = db .prepare("PRAGMA table_info(system_intents)")? .query_map([], |r| r.get::<_, String>(1))? .collect::>>()?; if !columns.iter().any(|name| name == "cancel_requested") { ensure!( columns == [ "id", "job", "attempt", "grant_id", "body", "digest", "phase" ], "SYSTEM_INTENT_LEGACY_SCHEMA" ); let old:String=db.query_row("SELECT sql FROM sqlite_master WHERE type='trigger' AND name='system_intents_monotonic'",[],|r|r.get(0))?; let normalize = |s: &str| { s.replace("IF NOT EXISTS ", "") .trim_end_matches(';') .split_whitespace() .collect::>() .join(" ") }; ensure!( normalize(&old) == normalize(LEGACY_MONOTONIC), "SYSTEM_INTENT_LEGACY_TRIGGER" ); let table: String = db.query_row( "SELECT sql FROM sqlite_master WHERE type='table' AND name='system_intents'", [], |r| r.get(0), )?; ensure!( normalize(&table) == normalize(LEGACY_INTENTS_TABLE), "SYSTEM_INTENT_LEGACY_SCHEMA" ); let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; tx.execute_batch("ALTER TABLE system_intents ADD COLUMN cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1));DROP TRIGGER system_intents_monotonic;")?; tx.execute_batch(SCHEMA)?; tx.commit()?; } } db.execute_batch(SCHEMA)?; Ok(()) } #[derive(Clone, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Intent { pub schema_version: u32, pub id: Uuid, pub request: Request, pub anchor: NoStartAnchor, pub original_boot_id: Uuid, pub agent_instance: Uuid, pub connection_generation: u64, pub recorded_at: DateTime, pub policy_sha256: String, pub helper_binary_sha256: String, } impl Intent { pub fn digest(&self) -> Result { Ok(hash(&serde_json::to_vec(self)?)) } pub fn permit(&self) -> Result { Ok(serde_json::from_slice(&self.request.permit_bytes)?) } fn validate(&self) -> Result<()> { ensure!( self.schema_version == 1 && !self.id.is_nil() && !self.agent_instance.is_nil() && !self.original_boot_id.is_nil() && self.original_boot_id == self.anchor.boot_id() && self.connection_generation == self.anchor.connection_generation() && ipc::digest(&self.policy_sha256) && ipc::digest(&self.helper_binary_sha256) && serde_json::to_vec(self)?.len() <= 196608, "SYSTEM_INTENT_BINDING" ); let p = self.permit()?; ensure!( p.execution_identity == "system" && p.authorization_id == self.request.authorization_id && p.plan_hash == self.request.plan_hash && p.job_payload_hash == hash(&self.request.job_bytes), "SYSTEM_INTENT_REQUEST_BINDING" ); Ok(()) } } #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum Phase { Prepared, KnownNoDispatch, MayHaveDispatched, } impl Phase { fn parse(s: &str) -> Result { match s { "prepared" => Ok(Self::Prepared), "known_no_dispatch" => Ok(Self::KnownNoDispatch), "may_have_dispatched" => Ok(Self::MayHaveDispatched), _ => anyhow::bail!("SYSTEM_INTENT_PHASE"), } } fn name(self) -> &'static str { match self { Self::Prepared => "prepared", Self::KnownNoDispatch => "known_no_dispatch", Self::MayHaveDispatched => "may_have_dispatched", } } } fn advance(db: &mut Connection, id: Uuid, desired: Phase) -> Result<(usize, Phase)> { let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; let changed = tx.execute( "UPDATE system_intents SET phase=?2 WHERE id=?1 AND phase='prepared'", params![id.to_string(), desired.name()], )?; let phase: String = tx.query_row( "SELECT phase FROM system_intents WHERE id=?1", [id.to_string()], |r| r.get(0), )?; tx.commit()?; Ok((changed, Phase::parse(&phase)?)) } pub struct Store { db: Connection, files: Vec, identity: FileIdentity, } impl Store { /// Bootstrap, never LocalService, creates both fixed leaves and their ACLs. /// PERSIST retains the precreated rollback journal, requiring no Actor delete /// or directory-create rights. A hot journal on the read-only side refuses. pub fn open(write: bool) -> Result { let actor = ipc::service_sid(crate::SERVICE_NAME)?; let root = PinnedFile::open_read_shared(Path::new(ROOT), true, std::slice::from_ref(&actor), &[])?; let mut files = vec![root]; for path in [DB, &format!("{DB}-journal")] { let mut file = if write { PinnedFile::open( Path::new(path), false, &[], std::slice::from_ref(&actor), true, )? } else { PinnedFile::open_read_shared( Path::new(path), false, &[], std::slice::from_ref(&actor), )? }; file.limit_writer_rights(ACTOR_RW)?; files.push(file); } let identity = files[1].identity; let flags = if write { OpenFlags::SQLITE_OPEN_READ_WRITE } else { OpenFlags::SQLITE_OPEN_READ_ONLY }; let mut db = Connection::open_with_flags(DB, flags)?; db.busy_timeout(Duration::from_millis(250))?; if write { rmm_agent_core::ledger::bounded_journal_capacity(&db)?; let mode: String = db.query_row("PRAGMA journal_mode=PERSIST", [], |r| r.get(0))?; ensure!(mode == "persist", "SYSTEM_INTENT_JOURNAL_MODE"); db.execute_batch("PRAGMA synchronous=FULL;PRAGMA temp_store=MEMORY;PRAGMA journal_size_limit=1048576;")?; initialize_schema(&mut db)?; db.execute( "INSERT OR IGNORE INTO system_intent_meta VALUES(1,?1)", [serde_json::to_vec(&identity)?], )?; } let stored: Vec = db.query_row( "SELECT file_identity FROM system_intent_meta WHERE id=1", [], |r| r.get(0), )?; ensure!( stored == serde_json::to_vec(&identity)?, "SYSTEM_INTENT_FILE_REPLACED" ); ensure!( db.query_row("PRAGMA integrity_check", [], |r| r.get::<_, String>(0))? == "ok", "SYSTEM_INTENT_INTEGRITY" ); let mut value = Self { db, files, identity, }; value.check()?; Ok(value) } pub fn check(&mut self) -> Result<()> { for file in &mut self.files { file.check()?; } ensure!( ipc::file_identity(&self.files[1].file)? == self.identity, "SYSTEM_INTENT_FILE_REPLACED" ); Ok(()) } pub fn prepare(&mut self, intent: &Intent) -> Result<()> { self.check()?; intent.validate()?; let tx = self .db .transaction_with_behavior(TransactionBehavior::Immediate)?; let count: u64 = tx.query_row("SELECT count(*) FROM system_intents", [], |r| r.get(0))?; ensure!(count < 10000, "SYSTEM_INTENT_CAPACITY_BLOCKED"); let busy:bool=tx.query_row("SELECT EXISTS(SELECT 1 FROM system_intents i WHERE NOT EXISTS(SELECT 1 FROM system_intent_mirrors m WHERE m.id=i.id))",[],|r|r.get(0))?; ensure!(!busy, "SYSTEM_DELEGATION_UNRESOLVED"); let p = intent.permit()?; tx.execute("INSERT INTO system_intents(id,job,attempt,grant_id,body,digest,phase) VALUES(?1,?2,?3,?4,?5,?6,'prepared')",params![intent.id.to_string(),p.job_id.to_string(),p.attempt_id.to_string(),p.grant_id.to_string(),serde_json::to_vec(intent)?,intent.digest()?])?; tx.commit()?; self.check() } pub fn load(&self, id: Uuid) -> Result<(Intent, Phase)> { let (body, digest, phase): (Vec, String, String) = self.db.query_row( "SELECT body,digest,phase FROM system_intents WHERE id=?1", [id.to_string()], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)), )?; ensure!( body.len() <= 196608 && hash(&body) == digest, "SYSTEM_INTENT_DIGEST" ); let intent: Intent = serde_json::from_slice(&body)?; intent.validate()?; ensure!(intent.id == id, "SYSTEM_INTENT_ID"); Ok((intent, Phase::parse(&phase)?)) } /// Both cancellation and dispatcher use this same transaction/CAS. A known /// non-dispatch can never follow the conservative may-dispatch marker. pub fn decide(&mut self, id: Uuid, dispatch: bool) -> Result { self.check()?; let desired = if dispatch { Phase::MayHaveDispatched } else { Phase::KnownNoDispatch }; let (changed, phase) = advance(&mut self.db, id, desired)?; self.check()?; ensure!( changed == 1 || phase != Phase::MayHaveDispatched, "SYSTEM_EXECUTE_REDELIVERY_FORBIDDEN" ); Ok(phase) } pub fn cancel_before_dispatch(&mut self, id: Uuid) -> Result { self.check()?; self.db.execute( "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", [id.to_string()], )?; let (_, phase) = advance(&mut self.db, id, Phase::KnownNoDispatch)?; self.check()?; Ok(phase) } /// Denial only. Original phase/request/anchor never changes, even after IPC. pub fn deny(&mut self, original: &Request, boot: Uuid) -> Result<()> { self.check()?; let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?; let intent = self.by_grant(permit.grant_id)?; ensure!( serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)? && intent.original_boot_id == boot, "SYSTEM_CANCEL_ORIGINAL_BINDING" ); self.db.execute( "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", [intent.id.to_string()], )?; self.check() } /// Open a new ordinary RO connection for each observation. No long-lived /// SQLite read transaction or immutable-mode shortcut may hide actor denial. pub fn require_not_denied( original: &Request, boot: Uuid, generation: u64, policy: &str, binary: &str, ) -> Result<()> { let mut store = Self::open(false)?; let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?; let intent = store.by_grant(permit.grant_id)?; let (_, phase) = store.load(intent.id)?; ensure!( serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)? && intent.original_boot_id == boot && intent.connection_generation == generation && phase == Phase::MayHaveDispatched && intent.policy_sha256 == policy && intent.helper_binary_sha256 == binary, "SYSTEM_CANCEL_ORIGINAL_BINDING" ); let denied: i64 = store.db.query_row( "SELECT cancel_requested FROM system_intents WHERE id=?1", [intent.id.to_string()], |r| r.get(0), )?; ensure!(denied == 0, "SYSTEM_MSI_CANCELLED_OR_FENCED"); store.check() } pub fn pending(&self) -> Result> { let mut rows=self.db.prepare("SELECT i.id FROM system_intents i WHERE NOT EXISTS(SELECT 1 FROM system_intent_mirrors m WHERE m.id=i.id) ORDER BY i.rowid LIMIT 2")?; let ids = rows .query_map([], |r| r.get::<_, String>(0))? .collect::>>()?; ensure!(ids.len() <= 1, "SYSTEM_MULTIPLE_PENDING_DELEGATIONS"); ids.into_iter() .map(|id| self.load(Uuid::parse_str(&id)?).map(|v| v.0)) .collect() } pub fn by_grant(&self, grant: Uuid) -> Result { let id: String = self.db.query_row( "SELECT id FROM system_intents WHERE grant_id=?1", [grant.to_string()], |r| r.get(0), )?; Ok(self.load(Uuid::parse_str(&id)?)?.0) } /// One deny-only attempt per NEW process instance. Original intent/anchor /// bytes and the historical helper process binding are never rewritten. pub fn claim_denial_resume( &mut self, id: Uuid, instance: Uuid, boot: Uuid, observed_at: DateTime, ) -> Result { self.check()?; let (intent, phase) = self.load(id)?; ensure!( phase == Phase::KnownNoDispatch && intent.original_boot_id == boot && intent.agent_instance != instance && !instance.is_nil() && observed_at >= intent.recorded_at, "SYSTEM_DENIAL_RESUME_BINDING" ); let changed = self.db.execute( CLAIM_RESUME, params![ id.to_string(), instance.to_string(), observed_at.to_rfc3339() ], )?; self.check()?; Ok(changed == 1) } pub fn mirrored( &mut self, id: Uuid, outcome_sha256: &str, observed_at: DateTime, ) -> Result<()> { self.check()?; ensure!(ipc::digest(outcome_sha256), "SYSTEM_MIRROR_HASH"); let old: Option = self .db .query_row( "SELECT outcome_sha256 FROM system_intent_mirrors WHERE id=?1", [id.to_string()], |r| r.get(0), ) .optional()?; if let Some(old) = old { ensure!(old == outcome_sha256, "SYSTEM_MIRROR_CONFLICT"); return Ok(()); } self.db.execute( "INSERT INTO system_intent_mirrors VALUES(?1,?2,?3)", params![id.to_string(), outcome_sha256, observed_at.to_rfc3339()], )?; self.check() } pub fn verify_no_dispatch( &mut self, id: Uuid, digest: &str, original: &Request, anchor: &NoStartAnchor, ) -> Result { self.check()?; let (intent, phase) = self.load(id)?; ensure!( phase == Phase::KnownNoDispatch && intent.digest()? == digest && serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)? && serde_json::to_vec(&intent.anchor)? == serde_json::to_vec(anchor)?, "SYSTEM_NO_DISPATCH_PROOF_INVALID" ); self.check()?; Ok(NoDispatchObservation { intent_id: id, intent_sha256: digest.into(), intent_recorded_at: intent.recorded_at, original_boot_id: intent.original_boot_id, }) } } #[cfg(test)] mod tests { use super::*; #[test] fn cancel_and_dispatch_cas_are_exclusive_and_history_cannot_be_rewritten() { let mut db = Connection::open_in_memory().unwrap(); db.execute_batch(SCHEMA).unwrap(); let cancelled = Uuid::new_v4(); let dispatched = Uuid::new_v4(); for id in [cancelled, dispatched] { db.execute( "INSERT INTO system_intents(id,job,attempt,grant_id,body,digest,phase) VALUES(?1,?1,?1,?1,x'01','immutable','prepared')", [id.to_string()], ) .unwrap(); } assert_eq!( advance(&mut db, cancelled, Phase::KnownNoDispatch).unwrap(), (1, Phase::KnownNoDispatch) ); assert_eq!( advance(&mut db, cancelled, Phase::MayHaveDispatched).unwrap(), (0, Phase::KnownNoDispatch) ); assert_eq!( advance(&mut db, dispatched, Phase::MayHaveDispatched).unwrap(), (1, Phase::MayHaveDispatched) ); assert_eq!( advance(&mut db, dispatched, Phase::KnownNoDispatch).unwrap(), (0, Phase::MayHaveDispatched) ); for _ in 0..2 { db.execute( "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", [dispatched.to_string()], ) .unwrap(); } assert_eq!( db.query_row( "SELECT phase,cancel_requested FROM system_intents WHERE id=?1", [dispatched.to_string()], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)) ) .unwrap(), ("may_have_dispatched".into(), 1) ); assert!( db.execute( "UPDATE system_intents SET cancel_requested=0 WHERE id=?1", [dispatched.to_string()] ) .is_err() ); assert!( db.execute( "UPDATE system_intents SET phase='prepared' WHERE id=?1", [dispatched.to_string()] ) .is_err() ); assert!( db.execute( "UPDATE system_intents SET body=x'02' WHERE id=?1", [cancelled.to_string()] ) .is_err() ); assert!( db.execute( "DELETE FROM system_intents WHERE id=?1", [cancelled.to_string()] ) .is_err() ); let retained: u64 = db .query_row("SELECT count(*) FROM system_intents", [], |r| r.get(0)) .unwrap(); assert_eq!(retained, 2); let resumed = Uuid::new_v4(); let args = params![ cancelled.to_string(), resumed.to_string(), Utc::now().to_rfc3339() ]; assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 1); assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 0); } #[test] fn additive_denial_column_preserves_original_legacy_intents_and_rejects_unknown_trigger() { let mut db = Connection::open_in_memory().unwrap(); db.execute_batch(LEGACY_INTENTS_TABLE).unwrap(); db.execute_batch(LEGACY_MONOTONIC).unwrap(); db.execute("INSERT INTO system_intents VALUES('id','job','attempt','grant',x'0102','original','may_have_dispatched')",[]).unwrap(); initialize_schema(&mut db).unwrap(); initialize_schema(&mut db).unwrap(); assert_eq!( db.query_row( "SELECT body,digest,phase,cancel_requested FROM system_intents", [], |r| Ok(( r.get::<_, Vec>(0)?, r.get::<_, String>(1)?, r.get::<_, String>(2)?, r.get::<_, i64>(3)? )) ) .unwrap(), ( vec![1, 2], "original".into(), "may_have_dispatched".into(), 0 ) ); db.execute("UPDATE system_intents SET cancel_requested=1", []) .unwrap(); assert!( db.execute("UPDATE system_intents SET body=x'03'", []) .is_err() ); assert!( db.execute("UPDATE system_intents SET cancel_requested=0", []) .is_err() ); let mut foreign = Connection::open_in_memory().unwrap(); foreign.execute_batch("CREATE TABLE system_intents(id,job,attempt,grant_id,body,digest,phase);CREATE TRIGGER system_intents_monotonic BEFORE UPDATE ON system_intents BEGIN SELECT 1;END;").unwrap(); assert!(initialize_schema(&mut foreign).is_err()); } }