Qualify Windows system delegation and crash-safe mirror adapter on native VM
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 07:43:36 +01:00
parent 655572aa5b
commit 4aff116b84
13 changed files with 3115 additions and 115 deletions
@@ -246,10 +246,11 @@ mod platform {
// Actor directories are read-only. Bootstrap precreates just the fixed
// writable leaves with SYSTEM/Admin ownership, so SID19 cannot gain
// owner-implied WRITE_DAC or forge a different actor's receipts.
let _parent = ipc::PinnedFile::open(&directory, true, &roles, &[], false)?;
let _parent = ipc::PinnedFile::open_read_shared(&directory, true, &roles, &[])?;
let path = directory.join(name);
if folder != "controller" {
let mut output = ipc::PinnedFile::open(&path, false, &[], &roles, true)?;
output.limit_writer_rights(0x0012_019f)?;
ensure!(
output.file.metadata()?.len() == 0,
"CONTROL_REPORT_ALREADY_WRITTEN"
@@ -0,0 +1,721 @@
//! Fixed read-only helper persistence witness for bootstrap preservation only.
//! No keys, request/row values, jobs, migrations, IPC or clock queries are emitted.
#[cfg(windows)]
mod platform {
use anyhow::{Result, ensure};
use rusqlite::{Connection, OpenFlags, types::ValueRef};
use serde::Serialize;
use serde_json::json;
use sha2::{Digest, Sha256};
use std::{
collections::{BTreeMap, BTreeSet},
fs::File,
io::Read,
mem::{size_of, zeroed},
os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle},
path::{Path, PathBuf},
ptr,
time::Duration,
};
use windows_sys::Win32::{
Foundation::*,
Security::{Authorization::*, *},
Storage::FileSystem::*,
System::Threading::*,
};
const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
const STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state";
const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite";
const LOCK: &str = r"C:\ProgramData\RustDiscoverySystem\state\executor.lock";
const ACTOR: &str = "S-1-5-80-2738667961-1084496008-3886777835-2738042298-1934696263";
const HELPER: &str = "S-1-5-80-1378800304-2783697212-3564778230-1646893514-1341434273";
const MAX_CELL: usize = 1024 * 1024;
const MAX_ROWS: usize = 10000;
const MAX_ROW_BYTES: usize = 32 * 1024 * 1024;
const READ_MASK: u32 = 0x0012_00a9;
fn wide(value: &Path) -> Vec<u16> {
use std::os::windows::ffi::OsStrExt;
value.as_os_str().encode_wide().chain(Some(0)).collect()
}
fn owned(raw: HANDLE) -> Result<OwnedHandle> {
ensure!(
!raw.is_null() && raw != INVALID_HANDLE_VALUE,
"STATE_HANDLE"
);
// SAFETY: successful CreateFile/OpenToken returned a unique owned handle.
Ok(unsafe { OwnedHandle::from_raw_handle(raw) })
}
struct Local(*mut std::ffi::c_void);
impl Drop for Local {
fn drop(&mut self) {
// SAFETY: this buffer was allocated by the security APIs for LocalFree.
unsafe { LocalFree(self.0) };
}
}
fn sid_text(sid: PSID) -> Result<String> {
ensure!(
!sid.is_null() && unsafe { IsValidSid(sid) } != 0,
"STATE_SID"
);
let mut text = ptr::null_mut();
ensure!(
unsafe { ConvertSidToStringSidW(sid, &mut text) } != 0,
"STATE_SID"
);
let _memory = Local(text.cast());
let mut count = 0;
while count < 256 && unsafe { *text.add(count) } != 0 {
count += 1;
}
ensure!((1..256).contains(&count), "STATE_SID_BOUND");
Ok(String::from_utf16(unsafe {
std::slice::from_raw_parts(text, count)
})?)
}
fn administrator() -> Result<()> {
let mut thread = ptr::null_mut();
if unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut thread) } != 0 {
let _thread = owned(thread)?;
anyhow::bail!("STATE_IMPERSONATION_FORBIDDEN");
}
ensure!(
unsafe { GetLastError() } == ERROR_NO_TOKEN,
"STATE_THREAD_TOKEN"
);
let mut storage = [0usize; 16];
let mut size = size_of::<[usize; 16]>() as u32;
ensure!(
unsafe {
CreateWellKnownSid(
WinBuiltinAdministratorsSid,
ptr::null_mut(),
storage.as_mut_ptr().cast(),
&mut size,
)
} != 0,
"STATE_ADMIN_SID"
);
let mut enabled = 0;
ensure!(
unsafe {
CheckTokenMembership(
ptr::null_mut(),
storage.as_ptr().cast_mut().cast(),
&mut enabled,
)
} != 0
&& enabled != 0,
"STATE_ADMINISTRATOR_REQUIRED"
);
Ok(())
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
struct FileId {
// Strings preserve every 64-bit digit through PowerShell JSON parsing.
volume_serial: String,
id_hex: String,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
struct Metadata {
file_id: FileId,
creation_filetime: String,
bytes: u64,
links: u32,
attributes: u32,
owner_sid: String,
acl_sha256: String,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Role {
Public,
Private,
IntentDirectory,
IntentLeaf,
}
fn security(raw: HANDLE, role: Role, directory: bool) -> Result<(String, String)> {
let mut owner = ptr::null_mut();
let mut acl = ptr::null_mut();
let mut descriptor = ptr::null_mut();
let parts =
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
ensure!(
unsafe {
GetSecurityInfo(
raw,
SE_FILE_OBJECT,
parts,
&mut owner,
ptr::null_mut(),
&mut acl,
ptr::null_mut(),
&mut descriptor,
)
} == 0,
"STATE_FILE_SECURITY"
);
let _descriptor = Local(descriptor);
ensure!(
!owner.is_null() && !acl.is_null() && !descriptor.is_null(),
"STATE_NULL_DACL"
);
let owner = sid_text(owner)?;
ensure!(
matches!(owner.as_str(), "S-1-5-18" | "S-1-5-32-544"),
"STATE_OWNER"
);
let mut control = 0;
let mut revision = 0;
ensure!(
unsafe { GetSecurityDescriptorControl(descriptor, &mut control, &mut revision) } != 0
// The original helper creates ledger/lock with inherited ACEs.
// Their protected parent remains held and checked by run().
&& ((role == Role::Private && !directory)
|| control & SE_DACL_PROTECTED != 0)
&& unsafe { IsValidAcl(acl) } != 0,
"STATE_PROTECTED_DACL"
);
ensure!(
unsafe { (*acl).AceCount } > 0 && unsafe { (*acl).AceCount } <= 16,
"STATE_ACL_BOUND"
);
let mut seen = BTreeSet::new();
for n in 0..unsafe { (*acl).AceCount } {
let mut raw_ace = ptr::null_mut();
ensure!(
unsafe { GetAce(acl, n.into(), &mut raw_ace) } != 0,
"STATE_ACE"
);
let ace = unsafe { &*raw_ace.cast::<ACCESS_ALLOWED_ACE>() };
ensure!(
ace.Header.AceType == 0
&& ace.Header.AceSize as usize >= size_of::<ACCESS_ALLOWED_ACE>()
&& u32::from(ace.Header.AceFlags) & INHERIT_ONLY_ACE == 0,
"STATE_ACE_TYPE"
);
let sid = ptr::addr_of!(ace.SidStart).cast_mut().cast();
let name = sid_text(sid)?;
ensure!(
unsafe { GetLengthSid(sid) } as usize + 8 <= ace.Header.AceSize as usize,
"STATE_ACE_SID_SIZE"
);
let writer = matches!(name.as_str(), "S-1-5-18" | "S-1-5-32-544")
|| (role == Role::Private && name == HELPER);
let reader = (role == Role::Public && matches!(name.as_str(), ACTOR | HELPER))
|| (role == Role::IntentDirectory && name == ACTOR);
ensure!(
if writer {
ace.Mask == FILE_ALL_ACCESS
} else if role == Role::IntentLeaf && name == ACTOR {
ace.Mask == 0x0012_019f
} else {
reader && ace.Mask & !READ_MASK == 0 && ace.Mask & 0x0002_0089 == 0x0002_0089
},
"STATE_EXACT_FILE_ROLES"
);
seen.insert(name);
}
ensure!(
seen.contains("S-1-5-18") && seen.contains("S-1-5-32-544"),
"STATE_REQUIRED_FILE_ROLES"
);
if matches!(role, Role::Public | Role::Private) {
ensure!(seen.contains(HELPER), "STATE_REQUIRED_HELPER_ROLE");
}
if role != Role::Private {
ensure!(seen.contains(ACTOR), "STATE_REQUIRED_AGENT_READER");
}
let mut sddl = ptr::null_mut();
let mut size = 0;
ensure!(
unsafe {
ConvertSecurityDescriptorToStringSecurityDescriptorW(
descriptor,
SDDL_REVISION_1,
parts,
&mut sddl,
&mut size,
)
} != 0,
"STATE_SECURITY_ENCODING"
);
let _sddl = Local(sddl.cast());
ensure!((1..=16384).contains(&size), "STATE_SECURITY_BOUND");
let text = unsafe { std::slice::from_raw_parts(sddl, size as usize) };
ensure!(text.last() == Some(&0), "STATE_SECURITY_TERMINATOR");
let text = String::from_utf16(&text[..text.len() - 1])?;
Ok((owner, format!("{:x}", Sha256::digest(text.as_bytes()))))
}
fn metadata(raw: HANDLE, directory: bool, role: Role) -> Result<Metadata> {
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
let mut id: FILE_ID_INFO = unsafe { zeroed() };
ensure!(
unsafe { GetFileInformationByHandle(raw, &mut info) } != 0
&& unsafe {
GetFileInformationByHandleEx(
raw,
FileIdInfo,
(&mut id as *mut FILE_ID_INFO).cast(),
size_of::<FILE_ID_INFO>() as u32,
)
} != 0,
"STATE_FILE_INFORMATION"
);
ensure!(
info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
&& (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory
&& (directory || info.nNumberOfLinks == 1),
"STATE_REGULAR_FILE"
);
let bytes = (u64::from(info.nFileSizeHigh) << 32) | u64::from(info.nFileSizeLow);
ensure!(directory || bytes <= 1024 * 1024 * 1024, "STATE_FILE_SIZE");
let (owner_sid, acl_sha256) = security(raw, role, directory)?;
Ok(Metadata {
file_id: FileId {
volume_serial: id.VolumeSerialNumber.to_string(),
id_hex: id
.FileId
.Identifier
.iter()
.map(|b| format!("{b:02x}"))
.collect(),
},
creation_filetime: ((u64::from(info.ftCreationTime.dwHighDateTime) << 32)
| u64::from(info.ftCreationTime.dwLowDateTime))
.to_string(),
bytes,
links: info.nNumberOfLinks,
attributes: info.dwFileAttributes,
owner_sid,
acl_sha256,
})
}
fn open(path: &Path, directory: bool, attributes_only: bool) -> Result<OwnedHandle> {
owned(unsafe {
CreateFileW(
wide(path).as_ptr(),
if attributes_only {
FILE_READ_ATTRIBUTES
} else {
GENERIC_READ
},
FILE_SHARE_READ | FILE_SHARE_WRITE,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT
| if directory {
FILE_FLAG_BACKUP_SEMANTICS
} else {
0
},
ptr::null_mut(),
)
})
}
struct Held {
file: File,
path: PathBuf,
directory: bool,
role: Role,
initial: Metadata,
}
impl Held {
fn open(path: &Path, directory: bool, role: Role) -> Result<Self> {
for ancestor in path.ancestors().skip(1) {
let handle = open(ancestor, true, true)?;
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
ensure!(
unsafe { GetFileInformationByHandle(handle.as_raw_handle(), &mut info) } != 0
&& info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
&& info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0,
"STATE_ANCESTOR"
);
}
let file: File = open(path, directory, false)?.into();
let initial = metadata(file.as_raw_handle(), directory, role)?;
Ok(Self {
file,
path: path.into(),
directory,
role,
initial,
})
}
fn check(&self) -> Result<()> {
ensure!(
metadata(self.file.as_raw_handle(), self.directory, self.role)? == self.initial,
"STATE_HELD_FILE_CHANGED"
);
let current = open(&self.path, self.directory, false)?;
ensure!(
metadata(current.as_raw_handle(), self.directory, self.role)? == self.initial,
"STATE_FILE_PATH_CHANGED"
);
Ok(())
}
}
struct Table {
name: &'static str,
create: &'static str,
query: &'static str,
types: &'static [u8],
}
// Lowercase types allow NULL; uppercase types require a value. All query
// identifiers/orderings are compile-time constants, never DB/user strings.
const TABLES: &[Table] = &[
Table {
name: "consumed",
create: "CREATE TABLE consumed(grant_id TEXT PRIMARY KEY, agent TEXT NOT NULL, generation INTEGER NOT NULL, job TEXT NOT NULL, attempt TEXT NOT NULL, result BLOB, UNIQUE(agent,generation,job,attempt))",
query: "SELECT grant_id,agent,generation,job,attempt,result FROM consumed INDEXED BY sqlite_autoindex_consumed_1 ORDER BY grant_id LIMIT 10001",
types: b"TTITTb",
},
Table {
name: "execution_evidence",
create: "CREATE TABLE execution_evidence(grant_id TEXT PRIMARY KEY, start BLOB NOT NULL, outcome BLOB)",
query: "SELECT grant_id,start,outcome FROM execution_evidence INDEXED BY sqlite_autoindex_execution_evidence_1 ORDER BY grant_id LIMIT 10001",
types: b"TBb",
},
Table {
name: "windows_helper_files",
create: "CREATE TABLE windows_helper_files(id INTEGER PRIMARY KEY CHECK(id=1),ledger BLOB NOT NULL,executor_lock BLOB NOT NULL,binding_sha256 TEXT NOT NULL)",
query: "SELECT id,ledger,executor_lock,binding_sha256 FROM windows_helper_files ORDER BY id LIMIT 10001",
types: b"IBBT",
},
Table {
name: "helper_sync_meta",
create: "CREATE TABLE helper_sync_meta(id INTEGER PRIMARY KEY CHECK(id=1),journal_id TEXT NOT NULL,checkpoint INTEGER NOT NULL DEFAULT 0,generation INTEGER NOT NULL DEFAULT 0,binding_sha256 TEXT NOT NULL,last_decision TEXT,fault TEXT,agent_journal_id TEXT,agent_checkpoint INTEGER NOT NULL DEFAULT 0)",
query: "SELECT id,journal_id,checkpoint,generation,binding_sha256,last_decision,fault,agent_journal_id,agent_checkpoint FROM helper_sync_meta ORDER BY id LIMIT 10001",
types: b"ITIITtttI",
},
Table {
name: "helper_sync_rows",
create: "CREATE TABLE helper_sync_rows(grant_id TEXT PRIMARY KEY,revision INTEGER NOT NULL,fingerprint TEXT NOT NULL)",
query: "SELECT grant_id,revision,fingerprint FROM helper_sync_rows INDEXED BY sqlite_autoindex_helper_sync_rows_1 ORDER BY grant_id LIMIT 10001",
types: b"TIT",
},
Table {
name: "helper_sync_captures",
create: "CREATE TABLE helper_sync_captures(checkpoint INTEGER PRIMARY KEY,snapshot BLOB NOT NULL,fingerprint TEXT NOT NULL,captured_at TEXT NOT NULL)",
query: "SELECT checkpoint,snapshot,fingerprint,captured_at FROM helper_sync_captures ORDER BY checkpoint LIMIT 10001",
types: b"IBTT",
},
Table {
name: "helper_sync_decisions",
create: "CREATE TABLE helper_sync_decisions(decision_id TEXT PRIMARY KEY,checkpoint INTEGER NOT NULL,response BLOB NOT NULL,request BLOB NOT NULL,fingerprint TEXT NOT NULL)",
query: "SELECT decision_id,checkpoint,response,request,fingerprint FROM helper_sync_decisions INDEXED BY sqlite_autoindex_helper_sync_decisions_1 ORDER BY decision_id LIMIT 10001",
types: b"TIBBT",
},
];
fn normalized(sql: &str) -> String {
sql.chars()
.filter(|c| !c.is_ascii_whitespace())
.collect::<String>()
.to_ascii_uppercase()
.replace("IFNOTEXISTS", "")
}
fn schema(db: &Connection) -> Result<(BTreeSet<String>, String)> {
let mut entries = Vec::new();
let mut present = BTreeSet::new();
let mut indexes = BTreeSet::new();
// Bound and sort the catalog in Rust, never via a disk-backed SQL sort.
let mut statement =
db.prepare("SELECT type,name,tbl_name,sql FROM sqlite_master LIMIT 33")?;
let mut rows = statement.query([])?;
while let Some(row) = rows.next()? {
ensure!(entries.len() < 32, "STATE_SCHEMA_BOUND");
let kind: String = row.get(0)?;
let name: String = row.get(1)?;
let parent: String = row.get(2)?;
let sql: Option<String> = row.get(3)?;
ensure!(
name.len() <= 96
&& parent.len() <= 96
&& sql.as_ref().is_none_or(|s| s.len() <= 4096),
"STATE_SCHEMA_BOUND"
);
if kind == "table" {
let table = TABLES
.iter()
.find(|t| t.name == name)
.ok_or_else(|| anyhow::anyhow!("STATE_UNEXPECTED_TABLE"))?;
ensure!(
parent == name
&& sql
.as_ref()
.is_some_and(|s| normalized(s) == normalized(table.create)),
"STATE_TABLE_SCHEMA_CHANGED"
);
present.insert(name.clone());
} else {
ensure!(
kind == "index" && sql.is_none() && TABLES.iter().any(|t| t.name == parent),
"STATE_UNEXPECTED_SCHEMA_OBJECT"
);
indexes.insert((parent.clone(), name.clone()));
}
entries.push((kind, name, parent, sql));
}
ensure!(
present.contains("consumed")
&& present.contains("execution_evidence")
&& present.contains("windows_helper_files"),
"STATE_REQUIRED_SCHEMA"
);
let sync = present
.iter()
.filter(|n| n.starts_with("helper_sync_"))
.count();
ensure!(sync == 0 || sync == 4, "STATE_PARTIAL_SYNC_SCHEMA");
let expected: BTreeSet<_> = [
"consumed",
"execution_evidence",
"helper_sync_rows",
"helper_sync_decisions",
]
.into_iter()
.filter(|n| present.contains(*n))
.flat_map(|name| {
let mut names = vec![(name.to_string(), format!("sqlite_autoindex_{name}_1"))];
if name == "consumed" {
names.push((name.to_string(), "sqlite_autoindex_consumed_2".into()));
}
names
})
.collect();
ensure!(indexes == expected, "STATE_INDEX_SCHEMA_CHANGED");
entries.sort();
Ok((
present,
format!("{:x}", Sha256::digest(serde_json::to_vec(&entries)?)),
))
}
fn table_rows(
db: &Connection,
table: &Table,
remaining: &mut usize,
) -> Result<serde_json::Value> {
let mut hash = Sha256::new();
hash.update(b"rmm.bootstrap.helper-table.v1\0");
hash.update(table.name.as_bytes());
hash.update([0]);
let mut count = 0usize;
let mut statement = db.prepare(table.query)?;
ensure!(
statement.column_count() == table.types.len(),
"STATE_ROW_COLUMNS"
);
let mut rows = statement.query([])?;
while let Some(row) = rows.next()? {
ensure!(count < MAX_ROWS, "STATE_ROW_COUNT_BOUND");
hash.update(b"R");
for (column, expected) in table.types.iter().enumerate() {
let value = row.get_ref(column)?;
match value {
ValueRef::Null => {
ensure!(expected.is_ascii_lowercase(), "STATE_ROW_NULL");
hash.update(b"N");
}
ValueRef::Integer(n) => {
ensure!(expected.eq_ignore_ascii_case(&b'I'), "STATE_ROW_TYPE");
hash.update(b"I");
hash.update(n.to_le_bytes());
}
ValueRef::Text(bytes) | ValueRef::Blob(bytes) => {
let tag = if matches!(value, ValueRef::Text(_)) {
b'T'
} else {
b'B'
};
ensure!(
expected.eq_ignore_ascii_case(&tag)
&& bytes.len() <= MAX_CELL
&& bytes.len() <= *remaining,
"STATE_ROW_TYPE_OR_BOUND"
);
if tag == b'T' {
std::str::from_utf8(bytes)?;
}
*remaining -= bytes.len();
hash.update([tag]);
hash.update((bytes.len() as u64).to_le_bytes());
hash.update(bytes);
}
ValueRef::Real(_) => anyhow::bail!("STATE_ROW_TYPE"),
}
}
count += 1;
}
hash.update((count as u64).to_le_bytes());
Ok(json!({"rows":count,"rows_sha256":format!("{:x}",hash.finalize())}))
}
fn sqlite_handle(db: &Connection) -> Result<HANDLE> {
let mut handle: HANDLE = ptr::null_mut();
// SAFETY: same-thread live SQLite connection, documented native-handle
// output operation only. Borrowed VFS handle is never closed or changed.
let code = unsafe {
rusqlite::ffi::sqlite3_file_control(
db.handle(),
c"main".as_ptr(),
rusqlite::ffi::SQLITE_FCNTL_WIN32_GET_HANDLE,
(&mut handle as *mut HANDLE).cast(),
)
};
ensure!(
code == rusqlite::ffi::SQLITE_OK && !handle.is_null() && handle != INVALID_HANDLE_VALUE,
"STATE_SQLITE_NATIVE_HANDLE"
);
ensure!(
unsafe { rusqlite::ffi::sqlite3_db_readonly(db.handle(), c"main".as_ptr()) } == 1,
"STATE_SQLITE_READONLY"
);
Ok(handle)
}
fn absent(path: &Path) -> Result<bool> {
match std::fs::symlink_metadata(path) {
Ok(_) => Ok(false),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(true),
Err(_) => anyhow::bail!("STATE_PATH_QUERY_FAILED"),
}
}
fn intent_metadata() -> Result<(Vec<Held>, serde_json::Value)> {
let path = Path::new(ROOT).join("agent-intents");
if absent(&path)? {
return Ok((Vec::new(), serde_json::Value::Null));
}
let directory = Held::open(&path, true, Role::IntentDirectory)?;
let names: BTreeSet<_> = std::fs::read_dir(&path)?
.map(|entry| entry.map(|item| item.file_name()))
.collect::<std::io::Result<_>>()?;
let expected: BTreeSet<_> = ["system-intents.sqlite", "system-intents.sqlite-journal"]
.into_iter()
.map(std::ffi::OsString::from)
.collect();
ensure!(names == expected, "STATE_ZERO_INTENT_LEAVES_ONLY");
let database = Held::open(&path.join("system-intents.sqlite"), false, Role::IntentLeaf)?;
let journal = Held::open(
&path.join("system-intents.sqlite-journal"),
false,
Role::IntentLeaf,
)?;
ensure!(
database.initial.bytes == 0 && journal.initial.bytes == 0,
"STATE_UNINITIALIZED_INTENT_ONLY"
);
let value = json!({"directory":directory.initial,"leaves":{"database":database.initial,"journal":journal.initial},"sqlite_initialized":false});
Ok((vec![directory, database, journal], value))
}
pub fn run() -> Result<()> {
ensure!(std::env::args_os().len() == 1, "STATE_FIXED_NO_ARGUMENTS");
administrator()?;
let roots = [
Held::open(Path::new(ROOT), true, Role::Public)?,
Held::open(Path::new(STATE), true, Role::Private)?,
];
let ledger = Held::open(Path::new(LEDGER), false, Role::Private)?;
let lock = Held::open(Path::new(LOCK), false, Role::Private)?;
ensure!(lock.initial.bytes <= 4096, "STATE_LOCK_SIZE");
let settings = Held::open(&Path::new(ROOT).join("helper.json"), false, Role::Public)?;
let pin = Held::open(&Path::new(ROOT).join("agent-pin.json"), false, Role::Public)?;
let (intent_files, intent_store) = intent_metadata()?;
ensure!(
settings.initial.bytes <= 32768 && pin.initial.bytes <= 16384,
"STATE_PUBLIC_FILE_SIZE"
);
// Refuse every existing sidecar, including a possibly hot rollback
// journal. Never ask an administrator-owned reader to recover it. Check
// the real header before SQLite can consider WAL/shared-memory paths.
for suffix in ["-journal", "-wal", "-shm"] {
ensure!(
absent(Path::new(&format!("{LEDGER}{suffix}")))?,
"STATE_SIDECAR_PRESENT"
);
}
let mut header = [0u8; 100];
(&ledger.file).read_exact(&mut header)?;
ensure!(
&header[..16] == b"SQLite format 3\0" && header[16..20] == [16, 0, 1, 1],
"STATE_ROLLBACK_HEADER_REQUIRED"
);
// No URI/nolock/immutable shortcut: retain normal SQLite locking and
// change detection. Read-only mode refuses a journal needing recovery.
let db = Connection::open_with_flags(LEDGER, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
db.busy_timeout(Duration::from_millis(250))?;
// Connection-only allocation limits, never PRAGMA or file mutations.
unsafe {
rusqlite::ffi::sqlite3_limit(
db.handle(),
rusqlite::ffi::SQLITE_LIMIT_LENGTH,
MAX_CELL as i32,
);
rusqlite::ffi::sqlite3_limit(db.handle(), rusqlite::ffi::SQLITE_LIMIT_SQL_LENGTH, 4096);
rusqlite::ffi::sqlite3_limit(db.handle(), rusqlite::ffi::SQLITE_LIMIT_COLUMN, 32);
rusqlite::ffi::sqlite3_limit(db.handle(), rusqlite::ffi::SQLITE_LIMIT_ATTACHED, 0);
}
db.execute_batch("BEGIN DEFERRED")?;
ensure!(
metadata(sqlite_handle(&db)?, false, Role::Private)? == ledger.initial,
"STATE_CONNECTED_FILE_CHANGED"
);
let integrity: String = db.query_row("PRAGMA integrity_check", [], |r| r.get(0))?;
ensure!(integrity == "ok", "STATE_HELPER_INTEGRITY");
let page_size: u64 = db.query_row("PRAGMA page_size", [], |r| r.get(0))?;
let page_count: u64 = db.query_row("PRAGMA page_count", [], |r| r.get(0))?;
let journal_mode: String = db.query_row("PRAGMA journal_mode", [], |r| r.get(0))?;
ensure!(
page_size == 4096
&& (1..=262144).contains(&page_count)
&& page_size * page_count == ledger.initial.bytes
&& journal_mode == "delete",
"STATE_HELPER_STORAGE_PROFILE"
);
let (present, schema_sha256) = schema(&db)?;
let absent_tables: Vec<_> = TABLES
.iter()
.filter(|table| !present.contains(table.name))
.map(|table| table.name)
.collect();
let mut tables = BTreeMap::new();
let mut remaining = MAX_ROW_BYTES;
for table in TABLES.iter().filter(|t| present.contains(t.name)) {
tables.insert(table.name, table_rows(&db, table, &mut remaining)?);
}
ensure!(
metadata(sqlite_handle(&db)?, false, Role::Private)? == ledger.initial,
"STATE_CONNECTED_FILE_CHANGED"
);
for held in roots
.iter()
.chain([&ledger, &lock, &settings, &pin])
.chain(intent_files.iter())
{
held.check()?;
}
if intent_files.is_empty() {
ensure!(
absent(&Path::new(ROOT).join("agent-intents"))?,
"STATE_INTENT_STORE_APPEARED"
);
}
db.execute_batch("ROLLBACK")?;
let value = json!({"schema_version":1,"type":"rmm.windows.system-state-witness","read_only":true,"bootstrap_administrator":true,
"helper_ledger":{"file":ledger.initial,"integrity":"ok","page_size":page_size,"page_count":page_count,"journal_mode":journal_mode,"schema_sha256":schema_sha256,"tables":tables,"absent_tables":absent_tables,"connected_native_file_id_verified":true},
"executor_lock":lock.initial,"public_metadata":{"helper_settings":settings.initial,"agent_pin":pin.initial},"intent_store":intent_store,
"private_key_read":false,"private_rows_returned":false,"clock_queried":false,"jobs_created":false});
let encoded = serde_json::to_string(&value)?;
ensure!(encoded.len() <= 32768, "STATE_REPORT_BOUND");
println!("{encoded}");
Ok(())
}
}
fn main() {
#[cfg(windows)]
if platform::run().is_ok() {
return;
}
// Never print SQLite/OS errors, paths, SQL or private row material.
eprintln!("SYSTEM_STATE_WITNESS_REFUSED");
std::process::exit(2);
}
+414
View File
@@ -0,0 +1,414 @@
//! 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')),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 OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') 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 CLAIM_RESUME: &str = "INSERT OR IGNORE INTO system_intent_denial_resumes(id,agent_instance,observed_at) VALUES(?1,?2,?3)";
#[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<Utc>,
pub policy_sha256: String,
pub helper_binary_sha256: String,
}
impl Intent {
pub fn digest(&self) -> Result<String> {
Ok(hash(&serde_json::to_vec(self)?))
}
pub fn permit(&self) -> Result<ExecutionPermitPayload> {
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<Self> {
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<PinnedFile>,
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<Self> {
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 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;")?;
db.execute_batch(SCHEMA)?;
db.execute(
"INSERT OR IGNORE INTO system_intent_meta VALUES(1,?1)",
[serde_json::to_vec(&identity)?],
)?;
}
let stored: Vec<u8> = 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<u8>, 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<Phase> {
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<Phase> {
self.check()?;
let (_, phase) = advance(&mut self.db, id, Phase::KnownNoDispatch)?;
self.check()?;
Ok(phase)
}
pub fn pending(&self) -> Result<Vec<Intent>> {
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::<rusqlite::Result<Vec<_>>>()?;
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<Intent> {
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<Utc>,
) -> Result<bool> {
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<Utc>,
) -> Result<()> {
self.check()?;
ensure!(ipc::digest(outcome_sha256), "SYSTEM_MIRROR_HASH");
let old: Option<String> = 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<NoDispatchObservation> {
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 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)
);
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);
}
}
+336 -74
View File
@@ -3,7 +3,7 @@
use anyhow::{Context, Result, ensure};
use rmm_agent_core::{
auth::{Binding, Outcome, Request},
helper_reconcile::{SignedResponse, Snapshot},
helper_reconcile::{NoStartAnchor, SignedResponse, Snapshot},
};
use rmm_domain::jobs::hash;
use serde::{Deserialize, Serialize, de::DeserializeOwned};
@@ -34,6 +34,176 @@ pub const FRAME_LIMIT: usize = 1024 * 1024;
pub const CLIENT_PIPE_RIGHTS: u32 = 0x0012_0083; // data R/W, attributes R, RC, synchronize; no bit4
const READ_MASK: u32 = 0x0012_00a9;
/// Static diagnostic contexts only; no caller input or error text is serialized.
#[derive(Clone, Copy, Debug)]
pub enum Stage {
DiscoverPin,
ClientSelfRole,
ClientOpenPipe,
ClientHelperPeer,
ClientSendFrame,
ClientReadReply,
ClientReplyBinding,
ClientReport,
ServerConnect,
ServerReadHeader,
ServerClientPeer,
ServerImpersonate,
ServerVerifyToken,
ServerReadBody,
ServerCallBinding,
ServerRecheckPeer,
ServerReply,
Unclassified,
}
impl Stage {
fn name(self) -> &'static str {
match self {
Self::DiscoverPin => "discover_pin",
Self::ClientSelfRole => "client_self_role",
Self::ClientOpenPipe => "client_open_pipe",
Self::ClientHelperPeer => "client_helper_peer",
Self::ClientSendFrame => "client_send_frame",
Self::ClientReadReply => "client_read_reply",
Self::ClientReplyBinding => "client_reply_binding",
Self::ClientReport => "client_report",
Self::ServerConnect => "server_connect",
Self::ServerReadHeader => "server_read_header",
Self::ServerClientPeer => "server_client_peer",
Self::ServerImpersonate => "server_impersonate",
Self::ServerVerifyToken => "server_verify_client_token",
Self::ServerReadBody => "server_read_body",
Self::ServerCallBinding => "server_call_binding",
Self::ServerRecheckPeer => "server_recheck_peer",
Self::ServerReply => "server_reply",
Self::Unclassified => "unclassified",
}
}
}
impl std::fmt::Display for Stage {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.name())
}
}
#[derive(Clone, Copy, Debug, Serialize)]
pub struct Diagnostic {
pub stage: &'static str,
pub code: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
pub win32: Option<u32>,
}
impl std::fmt::Display for Diagnostic {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.code)
}
}
impl std::error::Error for Diagnostic {}
#[derive(Debug)]
struct CapturedWin32(u32);
impl std::fmt::Display for CapturedWin32 {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("WIN32_CAPTURED")
}
}
impl std::error::Error for CapturedWin32 {}
fn api_failure(code: &'static str) -> anyhow::Error {
let captured = unsafe { GetLastError() };
anyhow::anyhow!(code).context(CapturedWin32(captured))
}
fn known_code(text: &str) -> Option<&'static str> {
const CODES: &[&str] = &[
"HELPER_BINARY_HASH",
"HELPER_CALL_BINDING",
"HELPER_EMPTY_DACL",
"HELPER_EXCESSIVE_WRITER_RIGHTS",
"HELPER_FILE_ID",
"HELPER_FILE_ID_CHANGED",
"HELPER_FILE_INFORMATION",
"HELPER_FILE_TYPE",
"HELPER_FRAME_CAPACITY",
"HELPER_FRAME_EMPTY",
"HELPER_FRAME_LENGTH",
"HELPER_HANDLE",
"HELPER_IMAGE_PARENT",
"HELPER_IMAGE_SIZE",
"HELPER_IMPERSONATED_SELF",
"HELPER_LOCAL_ABSOLUTE_PATH",
"HELPER_NETWORK_AGENT_ADMIN_FORBIDDEN",
"HELPER_NULL_DACL",
"HELPER_PATH_ACE",
"HELPER_PATH_ACE_TYPE",
"HELPER_PATH_OWNER",
"HELPER_PATH_REPLACED",
"HELPER_PATH_SECURITY",
"HELPER_PATH_WRITABLE_OR_FOREIGN",
"HELPER_PEER_RESTARTED",
"HELPER_PEER_TOKEN_QUERY",
"HELPER_PEER_TOKEN_RECHECK",
"HELPER_PIN_PROFILE",
"HELPER_PIPE_CONNECT",
"HELPER_PIPE_EOF",
"HELPER_PIPE_IMPERSONATED_TOKEN",
"HELPER_PIPE_IMPERSONATION",
"HELPER_PIPE_IO",
"HELPER_PIPE_SCM_PID",
"HELPER_PIPE_TIMEOUT",
"HELPER_PIPE_UNAVAILABLE_OR_BUSY",
"HELPER_PROCESS_IDENTITY",
"HELPER_PROCESS_IMAGE",
"HELPER_PROCESS_IMAGE_BINDING",
"HELPER_PROCESS_IMAGE_IDENTITY",
"HELPER_PROCESS_TIME",
"HELPER_PROCESS_TOKEN_IDENTITY",
"HELPER_REPARSE_ANCESTOR",
"HELPER_REPLY_BINDING",
"HELPER_REPLY_OPERATION",
"HELPER_SCM_CONFIG",
"HELPER_SCM_CONFIG_SIZE",
"HELPER_SCM_IMAGE_BINDING",
"HELPER_SCM_MANAGER",
"HELPER_SCM_NOT_RUNNING",
"HELPER_SCM_SERVICE",
"HELPER_SELF_TOKEN",
"HELPER_SERVICE_SID_NOT_ENABLED",
"HELPER_THREAD_TOKEN_UNVERIFIED",
"HELPER_TOKEN_GROUPS_SIZE",
"HELPER_TOKEN_INFORMATION",
"HELPER_TOKEN_SIZE",
"HELPER_TOKEN_USER",
"SYSTEM_LEDGER_OR_LOCK_REPLACED",
"SYSTEM_HELD_FILE_CHANGED",
"SYSTEM_DB_FILE_ID",
"SYSTEM_CALL_BINDING",
];
CODES.iter().copied().find(|code| *code == text)
}
pub fn diagnostic(error: &anyhow::Error) -> Diagnostic {
if let Some(value) = error.downcast_ref::<Diagnostic>() {
return *value;
}
let code = error
.chain()
.find_map(|cause| known_code(&cause.to_string()))
.unwrap_or("UNCLASSIFIED_IO_OR_CODEC");
Diagnostic {
stage: error
.downcast_ref::<Stage>()
.copied()
.unwrap_or(Stage::Unclassified)
.name(),
code,
win32: error.downcast_ref::<CapturedWin32>().map(|v| v.0),
}
}
pub fn remote_denial(stage: Stage, code: &str) -> anyhow::Error {
Diagnostic {
stage: stage.name(),
code: known_code(code).unwrap_or("UNCLASSIFIED_REMOTE_DENIAL"),
win32: None,
}
.into()
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PeerPin {
@@ -118,6 +288,12 @@ pub enum Operation {
generation: u64,
request: Request,
},
Abandon {
anchor: Box<NoStartAnchor>,
request: Request,
intent_id: Uuid,
intent_sha256: String,
},
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
@@ -155,10 +331,14 @@ pub enum ReplyBody {
snapshot: Snapshot,
unlocked_grants: Vec<Uuid>,
ready: bool,
no_start_anchor: Option<Box<NoStartAnchor>>,
},
Executed {
outcome: Outcome,
},
Abandoned {
outcome: Outcome,
},
Denied {
code: String,
},
@@ -191,10 +371,9 @@ pub fn wide(s: impl AsRef<std::ffi::OsStr>) -> Vec<u16> {
s.as_ref().encode_wide().chain(Some(0)).collect()
}
fn owned(raw: HANDLE) -> Result<OwnedHandle> {
ensure!(
!raw.is_null() && raw != INVALID_HANDLE_VALUE,
"HELPER_HANDLE"
);
if raw.is_null() || raw == INVALID_HANDLE_VALUE {
return Err(api_failure("HELPER_HANDLE"));
}
Ok(unsafe { OwnedHandle::from_raw_handle(raw) })
}
fn sid_text(sid: PSID) -> Result<String> {
@@ -323,7 +502,12 @@ pub fn require_self(peer: &PeerPin) -> Result<()> {
let token = owned(token)?;
verify_token(token.as_raw_handle(), &peer.user_sid, &peer.service_sid)
}
fn check_acl(handle: HANDLE, readers: &[String], writers: &[String]) -> Result<()> {
fn check_acl(
handle: HANDLE,
readers: &[String],
writers: &[String],
writer_mask: Option<u32>,
) -> Result<()> {
let mut owner = ptr::null_mut();
let mut acl = ptr::null_mut();
let mut descriptor = ptr::null_mut();
@@ -365,6 +549,12 @@ fn check_acl(handle: HANDLE, readers: &[String], writers: &[String]) -> Result<(
let sid = sid_text(ptr::addr_of!(ace.SidStart).cast_mut().cast())?;
let privileged =
matches!(sid.as_str(), "S-1-5-18" | "S-1-5-32-544") || writers.contains(&sid);
if writers.contains(&sid) && !matches!(sid.as_str(), "S-1-5-18" | "S-1-5-32-544") {
ensure!(
writer_mask.is_none_or(|mask| ace.Mask & !mask == 0),
"HELPER_EXCESSIVE_WRITER_RIGHTS"
);
}
ensure!(
privileged || (readers.contains(&sid) && ace.Mask & !READ_MASK == 0),
"HELPER_PATH_WRITABLE_OR_FOREIGN"
@@ -384,6 +574,7 @@ pub struct PinnedFile {
readers: Vec<String>,
writers: Vec<String>,
directory: bool,
writer_mask: Option<u32>,
}
impl PinnedFile {
pub fn open(
@@ -392,6 +583,28 @@ impl PinnedFile {
readers: &[String],
writers: &[String],
write: bool,
) -> Result<Self> {
Self::open_impl(path, directory, readers, writers, write, false)
}
pub(crate) fn open_read_shared(
path: &Path,
directory: bool,
readers: &[String],
writers: &[String],
) -> Result<Self> {
Self::open_impl(path, directory, readers, writers, false, true)
}
pub(crate) fn limit_writer_rights(&mut self, mask: u32) -> Result<()> {
self.writer_mask = Some(mask);
self.check()
}
fn open_impl(
path: &Path,
directory: bool,
readers: &[String],
writers: &[String],
write: bool,
share_write: bool,
) -> Result<Self> {
ensure!(
path.is_absolute()
@@ -427,7 +640,12 @@ impl PinnedFile {
} else {
GENERIC_READ
},
FILE_SHARE_READ | if write { FILE_SHARE_WRITE } else { 0 },
FILE_SHARE_READ
| if write || share_write {
FILE_SHARE_WRITE
} else {
0
},
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT
@@ -448,6 +666,7 @@ impl PinnedFile {
readers: readers.into(),
writers: writers.into(),
directory,
writer_mask: None,
};
value.check()?;
Ok(value)
@@ -467,7 +686,12 @@ impl PinnedFile {
file_identity(&self.file)? == self.identity,
"HELPER_FILE_ID_CHANGED"
);
check_acl(self.file.as_raw_handle(), &self.readers, &self.writers)?;
check_acl(
self.file.as_raw_handle(),
&self.readers,
&self.writers,
self.writer_mask,
)?;
let raw = unsafe {
CreateFileW(
wide(&self.path).as_ptr(),
@@ -877,10 +1101,30 @@ impl IoEvent {
}
let mut count = 0;
let complete = unsafe { GetOverlappedResult(pipe, &self.overlapped, &mut count, 0) };
if complete == 0 && unsafe { GetLastError() } == ERROR_IO_INCOMPLETE {
std::process::abort();
if complete == 0 {
let error = api_failure("HELPER_PIPE_IO");
if error
.downcast_ref::<CapturedWin32>()
.is_some_and(|v| v.0 == ERROR_IO_INCOMPLETE)
{
std::process::abort();
}
return Err(error);
}
Ok(count)
}
fn completed(&self, pipe: HANDLE) -> Result<u32> {
let mut count = 0;
if unsafe { GetOverlappedResult(pipe, &self.overlapped, &mut count, 0) } == 0 {
let error = api_failure("HELPER_PIPE_IO");
if error
.downcast_ref::<CapturedWin32>()
.is_some_and(|v| v.0 == ERROR_IO_INCOMPLETE)
{
std::process::abort();
}
return Err(error);
}
ensure!(complete != 0, "HELPER_PIPE_IO");
Ok(count)
}
}
@@ -890,14 +1134,13 @@ fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> R
ensure!(Instant::now() < deadline, "HELPER_PIPE_TIMEOUT");
let mut operation = IoEvent::new()?;
let part = &mut bytes[offset..];
let mut done = 0;
let ok = unsafe {
if write {
WriteFile(
pipe,
part.as_ptr(),
part.len().try_into()?,
&mut done,
ptr::null_mut(),
&mut operation.overlapped,
)
} else {
@@ -905,18 +1148,21 @@ fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> R
pipe,
part.as_mut_ptr(),
part.len().try_into()?,
&mut done,
ptr::null_mut(),
&mut operation.overlapped,
)
}
};
let count = if ok != 0 {
done
// ReadFile/WriteFile are always OVERLAPPED here. Their direct
// byte-counter is unspecified for async handles, even on TRUE.
// Obtain completion bytes from this exact held OVERLAPPED instead.
operation.completed(pipe)?
} else {
ensure!(
unsafe { GetLastError() } == ERROR_IO_PENDING,
"HELPER_PIPE_IO"
);
let error = unsafe { GetLastError() };
if error != ERROR_IO_PENDING {
return Err(anyhow::anyhow!("HELPER_PIPE_IO").context(CapturedWin32(error)));
}
operation.wait(pipe, deadline)?
};
ensure!(count > 0 && count as usize <= part.len(), "HELPER_PIPE_EOF");
@@ -1000,37 +1246,42 @@ impl Server {
}
pub fn receive(&self) -> Result<Option<Received>> {
let pipe = self.pipe.as_raw_handle();
let mut connect = IoEvent::new()?;
let mut connect = IoEvent::new().context(Stage::ServerConnect)?;
let connected = unsafe { ConnectNamedPipe(pipe, &mut connect.overlapped) };
if connected == 0 {
let error = unsafe { GetLastError() };
if error == ERROR_IO_PENDING {
if connect
.wait(pipe, Instant::now() + Duration::from_millis(250))
.is_err()
if let Err(error) = connect.wait(pipe, Instant::now() + Duration::from_millis(250))
{
unsafe {
DisconnectNamedPipe(pipe);
if diagnostic(&error).code == "HELPER_PIPE_TIMEOUT" {
unsafe {
DisconnectNamedPipe(pipe);
};
return Ok(None);
}
return Ok(None);
return Err(error).context(Stage::ServerConnect);
}
} else {
ensure!(error == ERROR_PIPE_CONNECTED, "HELPER_PIPE_CONNECT");
if error != ERROR_PIPE_CONNECTED {
return Err(
anyhow::anyhow!("HELPER_PIPE_CONNECT").context(CapturedWin32(error))
)
.context(Stage::ServerConnect);
}
}
}
let deadline = Instant::now() + Duration::from_secs(5);
let len = length(pipe, deadline)?;
let mut peer = PeerProof::capture(pipe, &self.pin.agent, true)?;
ensure!(
unsafe { ImpersonateNamedPipeClient(pipe) } != 0,
"HELPER_PIPE_IMPERSONATION"
);
let len = length(pipe, deadline).context(Stage::ServerReadHeader)?;
let mut peer =
PeerProof::capture(pipe, &self.pin.agent, true).context(Stage::ServerClientPeer)?;
if unsafe { ImpersonateNamedPipeClient(pipe) } == 0 {
return Err(api_failure("HELPER_PIPE_IMPERSONATION")).context(Stage::ServerImpersonate);
}
let auth = (|| {
let mut token = ptr::null_mut();
ensure!(
unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0,
"HELPER_PIPE_IMPERSONATED_TOKEN"
);
if unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } == 0 {
return Err(api_failure("HELPER_PIPE_IMPERSONATED_TOKEN"));
}
let token = owned(token)?;
verify_token(
token.as_raw_handle(),
@@ -1041,17 +1292,17 @@ impl Server {
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
auth?;
require_self(&self.pin.helper)?;
let call: Call = body(pipe, len, deadline)?;
ensure!(
call.schema_version == 1
&& !call.challenge.is_nil()
&& call.policy_sha256 == self.pin.policy_sha256
&& binding_hash(&call.binding)? == binding_hash(&self.pin.binding)?,
"HELPER_CALL_BINDING"
);
peer.check()?;
auth.context(Stage::ServerVerifyToken)?;
require_self(&self.pin.helper).context(Stage::ServerVerifyToken)?;
let call: Call = body(pipe, len, deadline).context(Stage::ServerReadBody)?;
if !(call.schema_version == 1
&& !call.challenge.is_nil()
&& call.policy_sha256 == self.pin.policy_sha256
&& binding_hash(&call.binding)? == binding_hash(&self.pin.binding)?)
{
return Err(anyhow::anyhow!("HELPER_CALL_BINDING")).context(Stage::ServerCallBinding);
}
peer.check().context(Stage::ServerRecheckPeer)?;
Ok(Some(Received { call, peer }))
}
pub fn reply(&self, value: &Reply) -> Result<()> {
@@ -1060,6 +1311,7 @@ impl Server {
value,
Instant::now() + Duration::from_secs(5),
)
.context(Stage::ServerReply)
}
pub fn disconnect(&self) {
unsafe {
@@ -1070,7 +1322,7 @@ impl Server {
/// Blocking SDK call; run on the agent's bounded blocking worker, never heartbeat reactor.
pub fn exchange(pin: &Pin, call: &Call, timeout: Duration) -> Result<Reply> {
pin.validate()?;
require_self(&pin.agent)?;
require_self(&pin.agent).context(Stage::ClientSelfRole)?;
ensure!(
(Duration::from_secs(1)..=Duration::from_secs(125)).contains(&timeout),
"HELPER_CALL_TIMEOUT_BOUND"
@@ -1087,31 +1339,33 @@ pub fn exchange(pin: &Pin, call: &Call, timeout: Duration) -> Result<Reply> {
ptr::null_mut(),
)
})
.context("HELPER_PIPE_UNAVAILABLE_OR_BUSY")?;
let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.helper, false)?;
send(pipe.as_raw_handle(), call, deadline)?;
let len = length(pipe.as_raw_handle(), deadline)?;
let reply: Reply = body(pipe.as_raw_handle(), len, deadline)?;
peer.check()?;
ensure!(
reply.schema_version == 1
&& reply.challenge == call.challenge
&& reply.binding_sha256 == binding_hash(&pin.binding)?
&& reply.policy_sha256 == pin.policy_sha256
&& reply.helper_binary_sha256 == pin.helper.binary_sha256,
"HELPER_REPLY_BINDING"
);
ensure!(
matches!(
(&call.operation, &reply.body),
(_, ReplyBody::Denied { .. })
| (Operation::Probe { .. }, ReplyBody::Probe { .. })
| (Operation::Snapshot { .. }, ReplyBody::Snapshot { .. })
| (Operation::Apply { .. }, ReplyBody::Applied { .. })
| (Operation::Execute { .. }, ReplyBody::Executed { .. })
),
"HELPER_REPLY_OPERATION"
);
.context("HELPER_PIPE_UNAVAILABLE_OR_BUSY")
.context(Stage::ClientOpenPipe)?;
let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.helper, false)
.context(Stage::ClientHelperPeer)?;
send(pipe.as_raw_handle(), call, deadline).context(Stage::ClientSendFrame)?;
let len = length(pipe.as_raw_handle(), deadline).context(Stage::ClientReadReply)?;
let reply: Reply = body(pipe.as_raw_handle(), len, deadline).context(Stage::ClientReadReply)?;
peer.check().context(Stage::ClientHelperPeer)?;
if !(reply.schema_version == 1
&& reply.challenge == call.challenge
&& reply.binding_sha256 == binding_hash(&pin.binding)?
&& reply.policy_sha256 == pin.policy_sha256
&& reply.helper_binary_sha256 == pin.helper.binary_sha256)
{
return Err(anyhow::anyhow!("HELPER_REPLY_BINDING")).context(Stage::ClientReplyBinding);
}
if !matches!(
(&call.operation, &reply.body),
(_, ReplyBody::Denied { .. })
| (Operation::Probe { .. }, ReplyBody::Probe { .. })
| (Operation::Snapshot { .. }, ReplyBody::Snapshot { .. })
| (Operation::Apply { .. }, ReplyBody::Applied { .. })
| (Operation::Execute { .. }, ReplyBody::Executed { .. })
| (Operation::Abandon { .. }, ReplyBody::Abandoned { .. })
) {
return Err(anyhow::anyhow!("HELPER_REPLY_OPERATION")).context(Stage::ClientReplyBinding);
}
Ok(reply)
}
@@ -1155,6 +1409,14 @@ mod tests {
assert!(
serde_json::from_str::<Operation>(r#"{"operation":"probe","ready":true}"#).is_err()
);
let caller =
anyhow::anyhow!("caller-payload-private-marker").context(Stage::ServerReadBody);
let encoded = serde_json::to_string(&diagnostic(&caller)).unwrap();
assert!(!encoded.contains("caller-payload-private-marker"));
assert_eq!(diagnostic(&caller).stage, "server_read_body");
assert_eq!(diagnostic(&caller).code, "UNCLASSIFIED_IO_OR_CODEC");
let remote = remote_denial(Stage::ClientReplyBinding, "caller-payload-private-marker");
assert_eq!(diagnostic(&remote).code, "UNCLASSIFIED_REMOTE_DENIAL");
}
#[test]
fn reconfigured_service_cannot_adopt_an_old_running_identity() {
+513 -12
View File
@@ -2,7 +2,12 @@
//! advertised here. Each actual IPC runs on one bounded blocking lane.
use crate::{helper_ipc as ipc, native};
use anyhow::{Context, Result, ensure};
use rmm_agent_core::{auth::Binding, helper_reconcile::Snapshot, reconcile::HelperSnapshot};
use rmm_agent_core::{
auth::{Binding, Outcome, Request},
helper_reconcile::{NoStartAnchor, Snapshot},
reconcile::HelperSnapshot,
};
use rmm_domain::jobs::{Action, JobPayload};
use rmm_protocol::{SyncAttempt, SyncResponse};
use serde_json::json;
use std::{
@@ -12,6 +17,8 @@ use std::{
time::Duration,
};
use tokio::sync::Semaphore;
#[path = "helper_intent.rs"]
pub mod intent;
pub const PIN_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\agent-pin.json";
const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
const PROBE_FILE: &str = "helper-probe.json";
@@ -20,6 +27,16 @@ pub struct Client {
pin: ipc::Pin,
lane: Arc<Semaphore>,
}
pub struct ControlSnapshot {
pub raw: Snapshot,
pub no_start_anchor: Option<NoStartAnchor>,
}
pub struct BoundOutcome {
pub job_id: uuid::Uuid,
pub attempt_id: uuid::Uuid,
pub grant_id: uuid::Uuid,
pub outcome: Outcome,
}
impl Client {
/// Missing pin is deliberately passive. A present but invalid pin is refused;
/// no endpoint/key/policy is discovered from the pipe itself.
@@ -72,12 +89,13 @@ impl Client {
tokio::task::spawn_blocking(move || {
let _permit = permit;
let result=(|| {
let client=Self::discover(&agent_id,&asset_id,binding.as_ref(),lane)?;
let client=Self::discover(&agent_id,&asset_id,binding.as_ref(),lane).context(ipc::Stage::DiscoverPin)?;
if let Some(client)=&client {client.probe_blocking(&state)?;}
Ok(client)
})();
if result.is_err() || matches!(&result,Ok(None)) && state.join(PROBE_FILE).try_exists()? {
write_current_probe(&state,&json!({"schema_version":1,"source":"actual_local_service_runtime","agent_process_id":std::process::id(),"agent_id":agent_id,"asset_id":asset_id,"observed_at":chrono::Utc::now(),"authenticated_pipe_exchange":false,"system_capability_advertised":false,"helper_ready":false,"no_jobs":true,"code":"HELPER_NOT_AVAILABLE"}))?;
let diagnostic=result.as_ref().err().map(ipc::diagnostic).unwrap_or(ipc::Diagnostic{stage:"discover_pin",code:"HELPER_PIN_NOT_CONFIGURED",win32:None});
write_current_probe(&state,&json!({"schema_version":1,"source":"actual_local_service_runtime","agent_process_id":std::process::id(),"agent_id":agent_id,"asset_id":asset_id,"observed_at":chrono::Utc::now(),"authenticated_pipe_exchange":false,"system_capability_advertised":false,"helper_ready":false,"no_jobs":true,"code":"HELPER_NOT_AVAILABLE","diagnostic":diagnostic}))?;
}
result
})
@@ -100,7 +118,135 @@ impl Client {
pub fn pin_hash(&self) -> &str {
&self.pin.policy_sha256
}
pub fn helper_binary_hash(&self) -> &str {
&self.pin.helper.binary_sha256
}
/// Import only independently authenticated raw helper evidence. c+start is
/// atomic through the existing core API. A crash before outcome persistence
/// stays locked; the next fresh snapshot repairs that exact start idempotently.
pub fn mirror(
&self,
snapshot: &Snapshot,
ledger: &mut rusqlite::Connection,
observed_at: chrono::DateTime<chrono::Utc>,
) -> Result<Vec<BoundOutcome>> {
use rmm_agent_core::{crypto::DalekVerifier, ledger as core_ledger};
use rusqlite::OptionalExtension;
if !Path::new(intent::DB).try_exists()? {
// Optional provisioning must not block the unprivileged provider.
// Retained SYSTEM consumption, however, may never lose its store.
let mut rows = ledger.prepare("SELECT start FROM execution_evidence")?;
for row in rows.query_map([], |r| r.get::<_, Vec<u8>>(0))? {
let value: serde_json::Value = serde_json::from_slice(&row?)?;
let request: Request = serde_json::from_value(value["request"].clone())?;
ensure!(
self.pin.binding.job(&request.job_bytes)?.execution_identity != "system",
"SYSTEM_INTENT_STORE_MISSING"
);
}
return Ok(Vec::new());
}
let mut store = intent::Store::open(true)?;
for intent in store.pending()? {
self.pin.binding.verify_historical_for_denial_with(
&intent.request,
rmm_agent_core::auth::HelperIdentity::System,
&DalekVerifier,
)?;
let job = self.pin.binding.job(&intent.request.job_bytes)?;
let permit = intent.permit()?;
ensure!(
self.supports_system(&job)
&& intent.policy_sha256 == self.pin.policy_sha256
&& intent.helper_binary_sha256 == self.pin.helper.binary_sha256
&& snapshot.boot_id == intent.original_boot_id
&& snapshot.journal_id == intent.anchor.journal_id()
&& snapshot.checkpoint >= intent.anchor.checkpoint()
&& observed_at >= intent.recorded_at
&& observed_at >= snapshot.captured_at,
"SYSTEM_MIRROR_CONTEXT"
);
let mut matches = snapshot
.attempts
.iter()
.filter(|a| a.job_id == job.job_id && a.attempt_id == job.attempt_id);
let row = matches
.next()
.context("SYSTEM_DELEGATION_NO_HELPER_EVIDENCE")?;
ensure!(matches.next().is_none(), "SYSTEM_DUPLICATE_HELPER_ATTEMPT");
let outcome =
verified_mirror_row(row, &job, &permit, &intent.request, intent.original_boot_id)?;
let existing:Option<(String,u64,String,String,Vec<u8>)>=ledger.query_row("SELECT c.agent,c.generation,c.job,c.attempt,e.start FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",[permit.grant_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?))).optional()?;
if let Some((agent, generation, j, a, start)) = existing {
let start: serde_json::Value = serde_json::from_slice(&start)?;
let request: Request = serde_json::from_value(start["request"].clone())?;
ensure!(
agent == job.agent_id.to_string()
&& generation == job.enrollment_generation
&& j == job.job_id.to_string()
&& a == job.attempt_id.to_string()
&& serde_json::to_vec(&request)? == serde_json::to_vec(&intent.request)?
&& start["previous_boot_id"] == intent.original_boot_id.to_string()
&& serde_json::from_value::<chrono::DateTime<chrono::Utc>>(
start["reserved_at"].clone()
)? == intent.recorded_at,
"SYSTEM_MIRROR_LOCAL_START_CONFLICT"
);
} else {
core_ledger::begin_execution(
ledger,
&permit,
&intent.request,
intent.original_boot_id,
intent.recorded_at,
)?;
}
core_ledger::persist_outcome(ledger, &permit, &outcome)?;
store.mirrored(intent.id, &row.outcome_sha256, observed_at)?;
}
let mut unknowns = Vec::new();
for row in snapshot
.attempts
.iter()
.filter(|row| row.state == "unknown")
{
let intent = store.by_grant(row.grant_id)?;
self.pin.binding.verify_historical_for_denial_with(
&intent.request,
rmm_agent_core::auth::HelperIdentity::System,
&DalekVerifier,
)?;
let job = self.pin.binding.job(&intent.request.job_bytes)?;
let permit = intent.permit()?;
ensure!(
self.supports_system(&job)
&& intent.policy_sha256 == self.pin.policy_sha256
&& intent.helper_binary_sha256 == self.pin.helper.binary_sha256
&& snapshot.boot_id == intent.original_boot_id
&& snapshot.journal_id == intent.anchor.journal_id()
&& snapshot.checkpoint >= intent.anchor.checkpoint(),
"SYSTEM_MIRROR_CONTEXT"
);
let outcome =
verified_mirror_row(row, &job, &permit, &intent.request, intent.original_boot_id)?;
unknowns.push(BoundOutcome {
job_id: job.job_id,
attempt_id: job.attempt_id,
grant_id: permit.grant_id,
outcome,
});
}
store.check()?;
Ok(unknowns)
}
async fn call(&self, operation: ipc::Operation) -> Result<ipc::Reply> {
self.call_bounded(operation, Duration::from_secs(5)).await
}
async fn call_bounded(
&self,
operation: ipc::Operation,
timeout: Duration,
) -> Result<ipc::Reply> {
let permit = self
.lane
.clone()
@@ -111,17 +257,20 @@ impl Client {
let _permit = permit;
client.check_pin()?;
let call = ipc::Call::new(&client.pin, operation);
let reply = ipc::exchange(&client.pin, &call, Duration::from_secs(5))?;
let reply = ipc::exchange(&client.pin, &call, timeout)?;
client.check_pin()?;
Ok(reply)
})
.await?
}
fn probe_blocking(&self, state: &Path) -> Result<()> {
self.check_pin()?;
self.check_pin().context(ipc::Stage::DiscoverPin)?;
let pin = &self.pin;
let call = ipc::Call::new(pin, ipc::Operation::Probe {});
let reply = ipc::exchange(pin, &call, Duration::from_secs(5))?;
if let ipc::ReplyBody::Denied { code } = &reply.body {
return Err(ipc::remote_denial(ipc::Stage::ClientReplyBinding, code));
}
let ipc::ReplyBody::Probe {
clock_qualified,
ready,
@@ -133,22 +282,123 @@ impl Client {
};
let value = json!({"schema_version":1,"source":"actual_local_service_runtime","agent_process_id":std::process::id(),"agent_service":crate::SERVICE_NAME,"agent_id":pin.binding.agent_id,"asset_id":pin.binding.asset_id,"challenge":reply.challenge,"observed_at":chrono::Utc::now(),"helper_service":ipc::HELPER_SERVICE,"verified_helper_user_sid":pin.helper.user_sid,"verified_helper_service_sid":pin.helper.service_sid,"helper_binary_sha256":reply.helper_binary_sha256,"policy_sha256":reply.policy_sha256,"authenticated_pipe_exchange":true,"client_service_pid_verified_by_helper":true,"ledger_file_id":ledger,"executor_lock_file_id":lock,"helper_clock_qualified":clock_qualified,"helper_ready":ready,"system_capability_advertised":false,"no_jobs":true});
self.check_pin()?;
write_current_probe(state, &value)
write_current_probe(state, &value).context(ipc::Stage::ClientReport)
}
pub async fn snapshot(&self, generation: u64, boot: uuid::Uuid) -> Result<HelperSnapshot> {
/// Pure admission shape only; no capability or qualification is asserted.
pub fn supports_system(&self, job: &JobPayload) -> bool {
system_shape(job)
&& self.pin.binding.tenant_id == job.tenant_id
&& self.pin.binding.asset_id == job.asset_id
&& self.pin.binding.agent_id == job.agent_id
&& self.pin.binding.enrollment_generation == job.enrollment_generation
&& self.pin.binding.assignment_version == job.assignment_version
}
/// Delegate ONCE. A lost reply is unknown and must be recovered by signed
/// Snapshot/Apply, never by resending Execute. A timed-out blocking call
/// retains its one lane permit until it actually returns; no replacement.
pub async fn delegate(
&self,
intent: intent::Intent,
admit: impl Fn() -> Result<()> + Send + 'static,
) -> Result<()> {
let job = self.pin.binding.job(&intent.request.job_bytes)?;
ensure!(
intent.connection_generation > 0 && self.supports_system(&job),
"SYSTEM_TYPED_SERVICE_REQUIRED"
);
let timeout = execution_timeout(job.max_runtime_seconds)?;
let permit = self
.lane
.clone()
.try_acquire_owned()
.context("HELPER_CONTROL_BUSY")?;
let client = self.clone();
tokio::time::timeout(
timeout,
tokio::task::spawn_blocking(move || {
let _permit = permit;
client.check_pin()?;
let mut store = intent::Store::open(true)?;
let (retained, _) = store.load(intent.id)?;
ensure!(
retained.digest()? == intent.digest()?,
"SYSTEM_INTENT_CHANGED"
);
let phase = store.decide(intent.id, admit().is_ok())?;
let operation = match phase {
intent::Phase::KnownNoDispatch => ipc::Operation::Abandon {
anchor: Box::new(intent.anchor.clone()),
request: intent.request.clone(),
intent_id: intent.id,
intent_sha256: intent.digest()?,
},
intent::Phase::MayHaveDispatched => {
admit()?;
ipc::Operation::Execute {
generation: intent.connection_generation,
request: intent.request.clone(),
}
}
intent::Phase::Prepared => anyhow::bail!("SYSTEM_INTENT_NOT_DURABLE"),
};
let call = ipc::Call::new(&client.pin, operation);
let reply = ipc::exchange(&client.pin, &call, timeout)?;
client.check_pin()?;
let outcome = match reply.body {
ipc::ReplyBody::Executed { outcome }
| ipc::ReplyBody::Abandoned { outcome } => outcome,
_ => anyhow::bail!("SYSTEM_HELPER_DELEGATION_DENIED"),
};
checked_outcome(&job, &outcome)?;
// A reply is never the consumption/mirror witness. Every outcome,
// including a successful reply, requires a fresh raw snapshot.
Ok::<_, anyhow::Error>(())
}),
)
.await
.context("SYSTEM_HELPER_REPLY_UNKNOWN")??
}
pub async fn resume_denial(&self, intent: intent::Intent) -> Result<()> {
let store = intent::Store::open(false)?;
let (retained, phase) = store.load(intent.id)?;
ensure!(
phase == intent::Phase::KnownNoDispatch && retained.digest()? == intent.digest()?,
"SYSTEM_DENIAL_RESUME_BINDING"
);
let operation = ipc::Operation::Abandon {
anchor: Box::new(intent.anchor.clone()),
request: intent.request.clone(),
intent_id: intent.id,
intent_sha256: intent.digest()?,
};
// Receipt is persisted by the runtime before this method. A timeout
// cannot release the blocking lane or cause another Abandon this process.
let reply = tokio::time::timeout(Duration::from_secs(5), self.call(operation))
.await
.context("SYSTEM_ABANDON_REPLY_UNKNOWN")??;
ensure!(
matches!(reply.body, ipc::ReplyBody::Abandoned { .. }),
"SYSTEM_ABANDON_DENIED"
);
Ok(())
}
pub async fn snapshot(&self, generation: u64, boot: uuid::Uuid) -> Result<ControlSnapshot> {
let reply = self.call(ipc::Operation::Snapshot { generation }).await?;
let ipc::ReplyBody::Snapshot { snapshot } = reply.body else {
anyhow::bail!("HELPER_SNAPSHOT_DENIED");
};
ensure!(snapshot.boot_id == boot, "HELPER_BOOT_MISMATCH");
Ok(map_snapshot(&snapshot))
Ok(ControlSnapshot {
raw: snapshot,
no_start_anchor: None,
})
}
pub async fn apply(
&self,
response: &SyncResponse,
request_bytes: Vec<u8>,
boot: uuid::Uuid,
) -> Result<HelperSnapshot> {
) -> Result<ControlSnapshot> {
let reply = self
.call(ipc::Operation::Apply {
response: rmm_agent_core::helper_reconcile::SignedResponse {
@@ -158,14 +408,112 @@ impl Client {
request_bytes,
})
.await?;
let ipc::ReplyBody::Applied { snapshot, .. } = reply.body else {
let ipc::ReplyBody::Applied {
snapshot,
no_start_anchor,
..
} = reply.body
else {
anyhow::bail!("HELPER_APPLY_DENIED");
};
ensure!(snapshot.boot_id == boot, "HELPER_BOOT_MISMATCH");
Ok(map_snapshot(&snapshot))
if let Some(anchor) = &no_start_anchor {
ensure!(
anchor.journal_id() == snapshot.journal_id
&& anchor.checkpoint() == snapshot.checkpoint
&& Some(anchor.decision_id()) == snapshot.previous_decision_id
&& anchor.boot_id() == boot,
"SYSTEM_ANCHOR_SNAPSHOT_BINDING"
);
}
Ok(ControlSnapshot {
raw: snapshot,
no_start_anchor: no_start_anchor.map(|a| *a),
})
}
}
fn map_snapshot(s: &Snapshot) -> HelperSnapshot {
fn verified_mirror_row(
row: &rmm_agent_core::helper_reconcile::LocalAttempt,
job: &JobPayload,
permit: &rmm_domain::jobs::ExecutionPermitPayload,
request: &Request,
boot: uuid::Uuid,
) -> Result<Outcome> {
use rmm_domain::{
jobs::hash,
reconciliation::{ReconciledOutcome, canonical_outcome_bytes},
};
ensure!(
row.job_id == job.job_id
&& row.attempt_id == job.attempt_id
&& row.job_payload_hash == permit.job_payload_hash
&& row.grant_id == permit.grant_id
&& row.authorization_id == permit.authorization_id
&& row.plan_hash == permit.plan_hash
&& row.action == permit.action
&& row.execution_identity == "system"
&& row.original_boot_id == boot
&& row.original_request_sha256 == hash(&serde_json::to_vec(request)?)
&& row.consumption == "consumed"
&& !row.outcome_bytes.is_empty(),
"SYSTEM_MIRROR_ORIGINAL_TUPLE"
);
let canonical: ReconciledOutcome = serde_json::from_slice(&row.outcome_bytes)?;
ensure!(
canonical_outcome_bytes(&canonical)? == row.outcome_bytes
&& hash(&row.outcome_bytes) == row.outcome_sha256
&& canonical.state == row.state,
"SYSTEM_MIRROR_CANONICAL_OUTCOME"
);
let outcome: Outcome = serde_json::from_slice(&row.outcome_bytes)?;
checked_outcome(job, &outcome)?;
Ok(outcome)
}
fn system_shape(job: &JobPayload) -> bool {
job.execution_identity == "system"
&& (1..=120).contains(&job.max_runtime_seconds)
&& (1..=65536).contains(&job.max_output_bytes)
&& matches!(&job.action,Action::SetServiceState{unit,state} if unit.starts_with("RmmDiscoveryFixture")&&unit.len()>"RmmDiscoveryFixture".len()&&unit.len()<=80&&unit.bytes().all(|b|b.is_ascii_alphanumeric()||b"_-".contains(&b))&&matches!(state.as_str(),"running"|"stopped"))
}
fn execution_timeout(seconds: u32) -> Result<Duration> {
ensure!(
(1..=120).contains(&seconds),
"SYSTEM_EXECUTION_TIMEOUT_BOUND"
);
Ok(Duration::from_secs(u64::from(seconds) + 5))
}
pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> {
ensure!(
matches!(
outcome.state.as_str(),
"succeeded" | "failed" | "cancelled" | "expired" | "unknown"
) && !outcome.reboot_required
&& outcome
.stdout
.len()
.checked_add(outcome.stderr.len())
.is_some_and(|n| n <= job.max_output_bytes as usize),
"SYSTEM_EXECUTE_OUTCOME_SCOPE"
);
if outcome.state == "succeeded" {
let Action::SetServiceState { unit, state } = &job.action else {
anyhow::bail!("SYSTEM_TYPED_SERVICE_REQUIRED");
};
let wanted = if state == "running" { 4 } else { 1 };
ensure!(
outcome.exit_code == Some(0)
&& !outcome.output_truncated
&& outcome.evidence["postconditions_passed"] == true
&& outcome.evidence["provider"] == "windows.scm/1"
&& outcome.evidence["service"] == unit.as_str()
&& outcome.evidence["requested_state"] == wanted
&& outcome.evidence["final_status"]["state"] == wanted,
"SYSTEM_SERVICE_POSTCONDITION_BINDING"
);
}
Ok(())
}
pub fn map_snapshot(s: &Snapshot) -> HelperSnapshot {
HelperSnapshot {
journal_id: s.journal_id,
checkpoint: s.checkpoint,
@@ -221,3 +569,156 @@ fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn system_route_binds_original_request_shape_budget_and_reply_scope() {
let id = uuid::Uuid::new_v4();
let now = chrono::Utc::now();
let mut job = JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
action: Action::SetServiceState {
unit: "RmmDiscoveryFixtureService".into(),
state: "running".into(),
},
execution_identity: "system".into(),
not_before: now,
start_before: now + chrono::Duration::seconds(60),
max_runtime_seconds: 30,
max_output_bytes: 1024,
};
assert!(system_shape(&job));
for identity in ["root", "agent_service"] {
job.execution_identity = identity.into();
assert!(!system_shape(&job));
}
job.execution_identity = "system".into();
job.action = Action::SetServiceState {
unit: "RmmDiscoveryFixtureService".into(),
state: "restarted".into(),
};
assert!(!system_shape(&job));
job.action = Action::SetServiceState {
unit: "RmmDiscoveryWindows".into(),
state: "stopped".into(),
};
assert!(!system_shape(&job));
assert_eq!(execution_timeout(120).unwrap(), Duration::from_secs(125));
assert!(execution_timeout(0).is_err());
assert!(execution_timeout(121).is_err());
let mut outcome = Outcome::unknown("LOST_REPLY");
assert!(checked_outcome(&job, &outcome).is_ok());
outcome.reboot_required = true;
assert!(checked_outcome(&job, &outcome).is_err());
outcome.reboot_required = false;
outcome.stdout = vec![0; 1025];
assert!(checked_outcome(&job, &outcome).is_err());
job.action = Action::SetServiceState {
unit: "RmmDiscoveryFixtureService".into(),
state: "running".into(),
};
outcome.stdout.clear();
outcome.state = "succeeded".into();
outcome.exit_code = Some(0);
assert!(checked_outcome(&job, &outcome).is_err());
outcome.evidence = json!({"postconditions_passed":true,"provider":"windows.scm/1","service":"RmmDiscoveryFixtureService","requested_state":4,"final_status":{"state":4}});
assert!(checked_outcome(&job, &outcome).is_ok());
outcome.evidence["final_status"]["state"] = json!(1);
assert!(checked_outcome(&job, &outcome).is_err());
let request = Request {
job_bytes: vec![b' ', b'{', b'}', b'\n'],
permit_bytes: vec![0, 1, 2, 255],
signature: vec![7; 64],
plan_hash: "ab".repeat(32),
authorization_id: id,
};
let operation = ipc::Operation::Execute {
generation: 73,
request: request.clone(),
};
let ipc::Operation::Execute {
generation,
request: retained,
} = serde_json::from_slice(&serde_json::to_vec(&operation).unwrap()).unwrap()
else {
panic!("typed execute required")
};
assert_eq!(generation, 73);
assert_eq!(
serde_json::to_vec(&retained).unwrap(),
serde_json::to_vec(&request).unwrap()
);
// Pure mirror-binding negatives, not a signature/OS authentication proof.
let permit = rmm_domain::jobs::ExecutionPermitPayload {
domain: "rmm.execution-permit".into(),
schema_version: 1,
grant_id: id,
authorization_id: id,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
plan_hash: request.plan_hash.clone(),
job_payload_hash: rmm_domain::jobs::hash(&request.job_bytes),
action: "set_service_state".into(),
execution_identity: "system".into(),
not_before: now,
start_before: now + chrono::Duration::seconds(60),
max_runtime_seconds: 30,
key_id: "cd".repeat(32),
};
let canonical: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_value(
serde_json::to_value(Outcome::unknown("RETAINED_UNKNOWN")).unwrap(),
)
.unwrap();
let bytes = rmm_domain::reconciliation::canonical_outcome_bytes(&canonical).unwrap();
let row = rmm_agent_core::helper_reconcile::LocalAttempt {
job_id: id,
attempt_id: id,
job_payload_hash: permit.job_payload_hash.clone(),
grant_id: id,
authorization_id: id,
plan_hash: permit.plan_hash.clone(),
action: permit.action.clone(),
execution_identity: "system".into(),
revision: 1,
original_boot_id: id,
consumption: "consumed".into(),
state: "unknown".into(),
outcome_sha256: rmm_domain::jobs::hash(&bytes),
outcome_bytes: bytes,
original_request_sha256: rmm_domain::jobs::hash(&serde_json::to_vec(&request).unwrap()),
};
assert!(verified_mirror_row(&row, &job, &permit, &request, id).is_ok());
for field in [
"authorization_id",
"original_request_sha256",
"original_boot_id",
"outcome_sha256",
] {
let mut changed = serde_json::to_value(&row).unwrap();
changed[field] = if field.ends_with("sha256") {
json!("ef".repeat(32))
} else {
json!(uuid::Uuid::new_v4())
};
let changed = serde_json::from_value(changed).unwrap();
assert!(
verified_mirror_row(&changed, &job, &permit, &request, id).is_err(),
"{field}"
);
}
}
}
+160 -6
View File
@@ -25,7 +25,10 @@ use fs2::FileExt;
use rmm_agent_core::{
auth::{Binding, HelperIdentity, Outcome, Request},
crypto::DalekVerifier,
helper_reconcile::{BootSource, ExecutorLedgerGuard, HelperSync},
helper_reconcile::{
BootSource, ExecutorLedgerGuard, HelperSync, NoDispatchObservation, NoStartAnchor,
NoStartGuard,
},
ledger,
};
use rmm_domain::jobs::{Action, ExecutionPermitPayload, JobPayload, hash};
@@ -275,6 +278,48 @@ impl ExecutorLedgerGuard for LedgerGuard {
}
}
/// All data other than the immutable intent reference comes from held local
/// handles. The IPC caller cannot manufacture a NoDispatchObservation.
struct DenialGuard<'a> {
ledger: &'a LedgerGuard,
pin: &'a Pin,
intent: Option<(Uuid, &'a str)>,
}
impl ExecutorLedgerGuard for DenialGuard<'_> {
fn check(&self, db: &Connection) -> Result<()> {
ipc::require_self(&self.pin.helper)?;
self.ledger.check(db)
}
}
impl NoStartGuard for DenialGuard<'_> {
fn live_instance_sha256(&self) -> Result<String> {
let pid = std::process::id();
let peer = ipc::PeerProof::for_service(&self.pin.helper, pid)?;
Ok(hash(&serde_json::to_vec(&(
peer.identity(),
self.ledger.ledger.identity,
self.ledger.lock.identity,
))?))
}
fn verify_no_dispatch(
&self,
original: &Request,
anchor: &NoStartAnchor,
) -> Result<NoDispatchObservation> {
let (id, digest) = self
.intent
.context("SYSTEM_NO_DISPATCH_REFERENCE_REQUIRED")?;
let mut store = crate::helper_runtime::intent::Store::open(false)?;
let (intent, _) = store.load(id)?;
ensure!(
intent.policy_sha256 == self.pin.policy_sha256
&& intent.helper_binary_sha256 == self.pin.helper.binary_sha256,
"SYSTEM_NO_DISPATCH_PIN_BINDING"
);
store.verify_no_dispatch(id, digest, original, anchor)
}
}
struct ServiceHandle(SC_HANDLE);
impl Drop for ServiceHandle {
fn drop(&mut self) {
@@ -727,6 +772,7 @@ pub struct SystemHelper {
clock: NativeClock,
boot: WindowsBoot,
sync: Option<HelperSync<DalekVerifier>>,
last_diagnostic: Option<Instant>,
}
impl SystemHelper {
pub fn open() -> Result<Self> {
@@ -749,11 +795,59 @@ impl SystemHelper {
clock,
boot,
sync,
last_diagnostic: None,
})
}
pub fn pin(&self) -> &Pin {
&self.pin
}
/// One bounded private bootstrap diagnostic, never inventory or payload.
/// Diagnostic failure is intentionally ignored by the service loop; the
/// original security failure still closes Sync and disconnects the pipe.
fn record_pipe_error(&mut self, error: &anyhow::Error) -> Result<()> {
if self
.last_diagnostic
.is_some_and(|at| at.elapsed() < Duration::from_secs(30))
{
return Ok(());
}
self.last_diagnostic = Some(Instant::now());
self.recheck()?;
let path = Path::new(STATE_ROOT).join("pipe-last-error.json");
let pending = Path::new(STATE_ROOT).join(".pipe-last-error.pending");
let writers = vec![self.settings.helper.service_sid.clone()];
if path.try_exists()? {
let _old = PinnedFile::open(&path, false, &[], &writers, false)?;
}
let diagnostic = ipc::diagnostic(error);
let bytes = serde_json::to_vec(
&serde_json::json!({"pid":std::process::id(),"observed_at_utc":chrono::Utc::now(),"diagnostic":diagnostic}),
)?;
ensure!(bytes.len() <= 1024, "SYSTEM_DIAGNOSTIC_BOUND");
use std::io::Write;
let mut file = OpenOptions::new()
.write(true)
.create_new(true)
.open(&pending)?;
let identity = ipc::file_identity(&file)?;
let result = (|| -> Result<()> {
{
let _check = PinnedFile::open_read_shared(&pending, false, &[], &writers)?;
}
file.write_all(&bytes)?;
file.sync_all()?;
Ok(())
})();
drop(file);
result?;
std::fs::rename(&pending, &path)?;
let saved = PinnedFile::open(&path, false, &[], &writers, false)?;
ensure!(
saved.identity == identity,
"SYSTEM_DIAGNOSTIC_FILE_REPLACED"
);
Ok(())
}
fn recheck(&mut self) -> Result<()> {
ipc::require_self(&self.settings.helper)?;
for file in &mut self.files {
@@ -829,10 +923,33 @@ impl SystemHelper {
&self.clock,
&self.boot,
)?;
let no_start_anchor = if value.ready && self.settings.enable_effects {
let guard = DenialGuard {
ledger: &self.guard,
pin: &self.pin,
intent: None,
};
let generation = self
.sync
.as_ref()
.unwrap()
.active_generation()
.context("SYSTEM_READY_GENERATION_REQUIRED")?;
Some(Box::new(self.sync.as_ref().unwrap().no_start_anchor(
&self.db,
&guard,
generation,
&self.clock,
&self.boot,
)?))
} else {
None
};
Ok(ReplyBody::Applied {
snapshot: value.snapshot,
unlocked_grants: value.unlocked_grants,
ready: value.ready && self.settings.enable_effects,
no_start_anchor,
})
}
Operation::Execute {
@@ -841,6 +958,40 @@ impl SystemHelper {
} => Ok(ReplyBody::Executed {
outcome: self.execute(*generation, request, peer)?,
}),
Operation::Abandon {
anchor,
request,
intent_id,
intent_sha256,
} => {
ensure!(
!intent_id.is_nil() && ipc::digest(intent_sha256),
"SYSTEM_NO_DISPATCH_REFERENCE_REQUIRED"
);
let job = self.settings.binding.job(&request.job_bytes)?;
ensure!(
job.execution_identity == "system"
&& job.max_runtime_seconds <= self.settings.max_runtime_seconds
&& matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)),
"SYSTEM_ABANDON_POLICY_DENIED"
);
self.sync()?;
let guard = DenialGuard {
ledger: &self.guard,
pin: &self.pin,
intent: Some((*intent_id, intent_sha256)),
};
Ok(ReplyBody::Abandoned {
outcome: self.sync.as_mut().unwrap().abandon_no_start(
&mut self.db,
&guard,
anchor,
request,
&self.clock,
&self.boot,
)?,
})
}
};
let response = response?;
peer.check()?;
@@ -1028,19 +1179,22 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
match server.receive() {
Ok(Some(mut incoming)) => {
let reply = helper.handle(&incoming.call, &mut incoming.peer);
if server.reply(&reply).is_err()
&& let Some(sync) = &mut helper.sync
{
sync.close();
if let Err(error) = server.reply(&reply) {
if let Some(sync) = &mut helper.sync {
sync.close();
}
server.disconnect();
let _diagnostic = helper.record_pipe_error(&error);
}
server.disconnect();
}
Ok(None) => {}
Err(_) => {
Err(error) => {
if let Some(sync) = &mut helper.sync {
sync.close();
}
server.disconnect();
let _diagnostic = helper.record_pipe_error(&error);
}
}
}
+452 -19
View File
@@ -135,14 +135,20 @@ impl SyncClock for JobClock {
#[derive(Default)]
struct EffectFence {
generation: AtomicU64,
helper_generation: AtomicU64,
deadline: AtomicI64,
}
impl EffectFence {
fn close(&self) {
self.generation.store(0, Ordering::SeqCst);
self.helper_generation.store(0, Ordering::SeqCst);
}
fn allows(&self, generation: u64, clock: &impl SyncClock) -> bool {
self.generation.load(Ordering::SeqCst) == generation
self.allows_identity(generation, false, clock)
}
fn allows_identity(&self, generation: u64, helper: bool, clock: &impl SyncClock) -> bool {
(!helper || self.helper_generation.load(Ordering::SeqCst) == generation)
&& self.generation.load(Ordering::SeqCst) == generation
&& generation > 0
&& clock.now().is_ok_and(|now| {
(now + chrono::Duration::seconds(2)).timestamp_millis()
@@ -151,6 +157,48 @@ impl EffectFence {
}
}
type Completion = (JobOffer, ExecutionPermitPayload, Outcome);
#[cfg(feature = "system-helper")]
fn needs_bound_outcome(
db: &Connection,
bound: &rmm_agent_windows::helper_runtime::BoundOutcome,
) -> Result<bool> {
use rmm_domain::reconciliation::{ReconciledOutcome, canonical_outcome_bytes};
// Archiving is durable retention only: no ACK, event deletion or unlock.
reconcile::archive_events(db)?;
let (state, revision, grant): (String, u64, String) = db.query_row(
"SELECT state,revision,grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![bound.job_id.to_string(), bound.attempt_id.to_string()],
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
)?;
let bytes:Option<Vec<u8>>=db.query_row("SELECT envelope FROM reconcile_results WHERE job=?1 AND attempt=?2 ORDER BY revision DESC LIMIT 1",rusqlite::params![bound.job_id.to_string(),bound.attempt_id.to_string()],|r|r.get(0)).optional()?;
if state == bound.outcome.state
&& grant == bound.grant_id.to_string()
&& let Some(bytes) = bytes
{
let envelope = Envelope::decode(bytes.as_slice())?;
if let Some(Payload::JobResult(r)) = envelope.payload
&& r.revision == revision
&& r.grant_id == grant
{
let saved = ReconciledOutcome {
state: r.state,
stdout: r.stdout,
stderr: r.stderr,
exit_code: r.exit_code,
output_truncated: r.output_truncated,
reboot_required: r.reboot_required,
evidence: serde_json::from_str(&r.evidence_json)?,
error_code: r.error_code,
};
let actual: ReconciledOutcome =
serde_json::from_value(serde_json::to_value(&bound.outcome)?)?;
if canonical_outcome_bytes(&saved)? == canonical_outcome_bytes(&actual)? {
return Ok(false);
}
}
}
Ok(true)
}
struct Running {
offer: JobOffer,
grant: ExecutionPermitPayload,
@@ -338,26 +386,40 @@ fn open_ledger(directory: &Path, binding: &Binding) -> Result<(Connection, fs::F
Ok((db, file))
}
#[cfg(feature = "system-helper")]
type MirrorCompletion = (
Connection,
Result<(
rmm_agent_windows::helper_runtime::ControlSnapshot,
Vec<rmm_agent_windows::helper_runtime::BoundOutcome>,
)>,
);
#[cfg(feature = "system-helper")]
enum HelperControl {
Snapshot(
u64,
tokio::task::JoinHandle<Result<reconcile::HelperSnapshot>>,
tokio::task::JoinHandle<Result<rmm_agent_windows::helper_runtime::ControlSnapshot>>,
),
Apply(
u64,
tokio::task::JoinHandle<Result<reconcile::HelperSnapshot>>,
tokio::task::JoinHandle<Result<rmm_agent_windows::helper_runtime::ControlSnapshot>>,
),
Mirror(u64, tokio::task::JoinHandle<MirrorCompletion>),
}
#[cfg(feature = "system-helper")]
impl HelperControl {
fn finished(&self) -> bool {
match self {
Self::Snapshot(_, t) | Self::Apply(_, t) => t.is_finished(),
Self::Mirror(_, t) => t.is_finished(),
}
}
fn abort(self) {
fn abort(self) -> Option<Self> {
match self {
Self::Snapshot(_, t) | Self::Apply(_, t) => t.abort(),
Self::Snapshot(_, t) | Self::Apply(_, t) => {
t.abort();
None
}
mirror @ Self::Mirror(..) => Some(mirror),
}
}
}
@@ -389,6 +451,8 @@ struct Agent {
#[cfg(feature = "system-helper")]
helper_control: Option<HelperControl>,
#[cfg(feature = "system-helper")]
helper_anchor: Option<rmm_agent_core::helper_reconcile::NoStartAnchor>,
#[cfg(feature = "system-helper")]
helper_checked: bool,
#[cfg(feature = "system-helper")]
helper_refused: bool,
@@ -408,8 +472,9 @@ impl Agent {
#[cfg(feature = "system-helper")]
{
self.prepared_request = None;
self.helper_anchor = None;
if let Some(control) = self.helper_control.take() {
control.abort();
self.helper_control = control.abort();
}
}
self.deferred_permit = None;
@@ -446,15 +511,69 @@ impl Agent {
HelperControl::Snapshot(expected, task) => {
ensure!(expected == generation, "HELPER_CHANNEL_CHANGED");
let snapshot = task.await??;
self.send_sync(channel, generation, Some(&snapshot)).await?;
let helper = self
.helper
.clone()
.context("WINDOWS_HELPER_NOT_CONFIGURED")?;
let observed_at = self.clock.now()?;
let mut ledger = self.ledger.take().context("LEDGER_REQUIRED")?;
self.helper_control = Some(HelperControl::Mirror(
generation,
tokio::task::spawn_blocking(move || {
let result = helper
.mirror(&snapshot.raw, &mut ledger, observed_at)
.map(|unknowns| (snapshot, unknowns));
(ledger, result)
}),
));
}
HelperControl::Mirror(expected, task) => {
// Always restore ownership, including after reconnect. A
// stale generation may discard its snapshot, never its DB.
let (ledger, result) = task.await?;
self.ledger = Some(ledger);
let (snapshot, unknowns) = result?;
for bound in unknowns {
if needs_bound_outcome(self.journal.connection(), &bound)? {
let bytes: Vec<u8> = self.journal.connection().query_row(
"SELECT offer FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![
bound.job_id.to_string(),
bound.attempt_id.to_string()
],
|r| r.get(0),
)?;
self.record(
generation,
&JobOffer::decode(bytes.as_slice())?,
&bound.grant_id.to_string(),
bound.outcome,
)?;
}
}
if expected != generation {
self.close_gate();
return Ok(());
}
self.send_sync(
channel,
generation,
Some(&rmm_agent_windows::helper_runtime::map_snapshot(
&snapshot.raw,
)),
)
.await?;
}
HelperControl::Apply(expected, task) => {
ensure!(expected == generation, "HELPER_CHANNEL_CHANGED");
let snapshot = task.await??;
self.helper_anchor = snapshot.no_start_anchor;
self.sync
.as_mut()
.context("SYNC_NOT_CONFIGURED")?
.confirm_helper(&snapshot)?;
.confirm_helper(&rmm_agent_windows::helper_runtime::map_snapshot(
&snapshot.raw,
))?;
self.open_fence(generation)?;
}
}
@@ -493,6 +612,7 @@ impl Agent {
&& self.helper_control.is_none()
&& !self.prepared
&& self.running.is_none()
&& !self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))?
&& self.helper_probe_at.elapsed() >= Duration::from_secs(30)
{
let agent = self.identity.agent_id.clone();
@@ -516,14 +636,45 @@ impl Agent {
})
}
fn ready(&self, generation: u64) -> bool {
self.ready_identity(generation, false)
}
fn ready_identity(&self, generation: u64, helper: bool) -> bool {
#[cfg(feature = "system-helper")]
if helper
&& !self.helper_anchor.as_ref().is_some_and(|a| {
a.connection_generation() == generation && a.boot_id().to_string() == self.boot
})
{
return false;
}
self.config.enable_jobs
&& !self.helper_control_pending()
&& self.channel(generation).is_ok_and(|channel| {
self.sync
.as_ref()
.is_some_and(|sync| sync.can_start(&channel, false, &self.clock))
.is_some_and(|sync| sync.can_start(&channel, helper, &self.clock))
})
}
fn supported_job(&self, job: &rmm_domain::jobs::JobPayload) -> bool {
if native::require_local_service().is_err() {
return false;
}
if rmm_agent_windows::actions::supported(job) {
return true;
}
#[cfg(feature = "system-helper")]
{
Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file()
&& self
.helper
.as_ref()
.is_some_and(|helper| helper.supports_system(job))
}
#[cfg(not(feature = "system-helper"))]
{
false
}
}
fn capabilities(&self) -> Vec<String> {
let mut caps: Vec<String> = CAPABILITIES.iter().map(|c| c.to_string()).collect();
if self.config.enable_jobs
@@ -559,6 +710,72 @@ impl Agent {
let Some(binding) = self.binding.clone() else {
return Ok(());
};
#[cfg(feature = "system-helper")]
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
let mut intents = rmm_agent_windows::helper_runtime::intent::Store::open(true)?;
let pending = intents.pending()?;
if let Some(intent) = pending.first() {
let p = intent.permit()?;
let incompatible:bool=self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot') AND NOT(job=?1 AND attempt=?2))",rusqlite::params![p.job_id.to_string(),p.attempt_id.to_string()],|r|r.get(0))?;
ensure!(!incompatible, "SYSTEM_PENDING_INTENT_CONFLICT");
binding.verify_historical_for_denial_with(
&intent.request,
reconcile::HelperIdentity::System,
&rmm_agent_core::crypto::DalekVerifier,
)?;
let bytes: Vec<u8> = self.journal.connection().query_row(
"SELECT offer FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![p.job_id.to_string(), p.attempt_id.to_string()],
|r| r.get(0),
)?;
let offer = JobOffer::decode(bytes.as_slice())?;
ensure!(
offer.payload_bytes == intent.request.job_bytes
&& offer.plan_hash == intent.request.plan_hash
&& offer.authorization_id == intent.request.authorization_id.to_string(),
"SYSTEM_PENDING_INTENT_BINDING"
);
// Even prepared-only intents are never executed after restart.
// Snapshot/explicit bound denial recovery is the only route.
intents.check()?;
let ledger = self.ledger.as_ref().context("LEDGER_REQUIRED")?;
let consumed: bool = ledger.query_row(
"SELECT EXISTS(SELECT 1 FROM consumed WHERE grant_id=?1)",
[p.grant_id.to_string()],
|r| r.get(0),
)?;
let actual = if consumed {
jobs::recover_interrupted_outcome(
ledger,
&binding,
&offer,
&p.grant_id.to_string(),
)?
} else {
None
};
if let Some(actual) = &actual {
let bound = rmm_agent_windows::helper_runtime::BoundOutcome {
job_id: p.job_id,
attempt_id: p.attempt_id,
grant_id: p.grant_id,
outcome: actual.clone(),
};
if !needs_bound_outcome(self.journal.connection(), &bound)? {
return Ok(());
}
}
self.record(
0,
&offer,
&p.grant_id.to_string(),
actual.unwrap_or_else(|| {
Outcome::unknown("SYSTEM_DELEGATION_INTERRUPTED_REQUIRES_HELPER_EVIDENCE")
}),
)?;
return Ok(());
}
}
let interrupted = jobs::interrupted(
self.journal.connection(),
self.ledger.as_ref().context("LEDGER_REQUIRED")?,
@@ -610,9 +827,38 @@ impl Agent {
if let Some(helper) = self.helper.clone() {
ensure!(self.helper_control.is_none(), "HELPER_CONTROL_PENDING");
let boot = self.channel(generation)?.boot_id;
let instance = Uuid::parse_str(&self.instance)?;
let clock = self.clock.clone();
self.helper_control = Some(HelperControl::Snapshot(
generation,
tokio::spawn(async move { helper.snapshot(generation, boot).await }),
tokio::spawn(async move {
let denial_resume = tokio::task::spawn_blocking(move || -> Result<_> {
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
use rmm_agent_windows::helper_runtime::intent::{Phase, Store};
let mut store = Store::open(true)?;
if let Some(intent) = store.pending()?.first() {
let (_, phase) = store.load(intent.id)?;
if phase == Phase::KnownNoDispatch
&& intent.agent_instance != instance
&& store.claim_denial_resume(
intent.id,
instance,
boot,
clock.now()?,
)?
{
return Ok(Some(intent.clone()));
}
}
}
Ok(None)
})
.await??;
if let Some(intent) = denial_resume {
let _denial = helper.resume_denial(intent).await;
}
helper.snapshot(generation, boot).await
}),
));
return Ok(());
}
@@ -694,6 +940,14 @@ impl Agent {
.deadline
.store(deadline.timestamp_millis(), Ordering::SeqCst);
self.fence.generation.store(generation, Ordering::SeqCst);
self.fence.helper_generation.store(
if self.ready_identity(generation, true) {
generation
} else {
0
},
Ordering::SeqCst,
);
}
Ok(())
}
@@ -708,6 +962,19 @@ impl Agent {
&& running.grant == grant,
"EXECUTOR_COMPLETION_BINDING"
);
if grant.execution_identity == "system" {
// No local consumption or definitive result from an IPC outcome.
// Import only a fresh raw helper snapshot before the next Sync.
self.record(
generation,
&offer,
&grant.grant_id.to_string(),
Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"),
)?;
self.running = None;
self.close_gate();
return Ok(());
}
ledger::persist_outcome(
self.ledger.as_ref().context("LEDGER_REQUIRED")?,
&grant,
@@ -725,6 +992,9 @@ impl Agent {
&outcome,
)?;
self.running = None;
if grant.execution_identity == "system" {
self.close_gate();
}
Ok(())
}
fn permit(&mut self, generation: u64, permit: ExecutionPermit) -> Result<()> {
@@ -764,10 +1034,82 @@ impl Agent {
return Ok(());
}
let (job, grant) = verified_window(&binding, &request, &self.clock)?;
ensure!(self.supported_job(&job), "UNSUPPORTED_CAPABILITY");
let system = job.execution_identity == "system";
ensure!(
rmm_agent_windows::actions::supported(&job),
"UNSUPPORTED_CAPABILITY"
self.ready_identity(generation, system),
"SYSTEM_HELPER_SYNC_REQUIRED"
);
let cancelled: bool = self.journal.connection().query_row(
"SELECT cancel_requested FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![offer.job_id, offer.attempt_id],
|r| r.get(0),
)?;
#[cfg(feature = "system-helper")]
if system {
use rmm_agent_windows::helper_runtime::intent::{Intent, Store};
let helper = self
.helper
.clone()
.context("WINDOWS_HELPER_NOT_CONFIGURED")?;
let intent = Intent {
schema_version: 1,
id: Uuid::new_v4(),
request: request.clone(),
anchor: self
.helper_anchor
.clone()
.context("SYSTEM_READY_ANCHOR_REQUIRED")?,
original_boot_id: Uuid::parse_str(&self.boot)?,
agent_instance: Uuid::parse_str(&self.instance)?,
connection_generation: generation,
recorded_at: self.clock.now()?,
policy_sha256: helper.pin_hash().into(),
helper_binary_sha256: helper.helper_binary_hash().into(),
};
let mut store = Store::open(true)?;
store.prepare(&intent)?;
if cancelled {
store.decide(intent.id, false)?;
}
let cancelled = Arc::new(AtomicBool::new(cancelled));
let worker_cancel = cancelled.clone();
let clock = self.clock.clone();
let fence = self.fence.clone();
let completed = self.completed_tx.clone();
let work_offer = offer.clone();
let work_grant = grant.clone();
let worker = tokio::spawn(async move {
let _result = helper
.delegate(intent, move || {
ensure!(
!worker_cancel.load(Ordering::SeqCst),
"CANCELLED_BEFORE_DISPATCH"
);
ensure!(
fence.allows_identity(generation, true, &clock),
"FENCED_BEFORE_DISPATCH"
);
verified_window(&binding, &request, &clock)?;
Ok(())
})
.await;
let _ = completed
.send((
work_offer,
work_grant,
Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"),
))
.await;
});
self.running = Some(Running {
offer,
grant,
cancel: cancelled,
worker,
});
return Ok(());
}
let started_at = self.clock.now()?;
let ledger = self.ledger.as_mut().context("LEDGER_REQUIRED")?;
ledger::begin_execution(
@@ -777,11 +1119,6 @@ impl Agent {
Uuid::parse_str(&self.boot)?,
started_at,
)?;
let cancelled: bool = self.journal.connection().query_row(
"SELECT cancel_requested FROM job_attempts WHERE job=?1 AND attempt=?2",
rusqlite::params![offer.job_id, offer.attempt_id],
|r| r.get(0),
)?;
if cancelled {
let outcome = jobs::no_start("cancelled", "CANCELLED_BEFORE_EFFECT");
ledger::persist_outcome(
@@ -1016,7 +1353,7 @@ impl Agent {
if let Some(offer)=jobs::next_at(self.journal.connection(),now)? {
let job=self.binding.as_ref().context("JOB_BINDING_REQUIRED")?.job(&offer.payload_bytes)?;
if now>=job.start_before {self.record(generation,&offer,"",jobs::no_start("expired","START_DEADLINE_EXPIRED"))?;needs_sync=true;}
else if now-chrono::Duration::seconds(2)>=job.not_before {
else if now-chrono::Duration::seconds(2)>=job.not_before && self.ready_identity(generation,job.execution_identity=="system") {
jobs::reserve_request(self.journal.connection(),&offer)?;
let request=self.envelope(generation,Payload::ExecutionPermitRequest(ExecutionPermitRequest{job_id:offer.job_id,attempt_id:offer.attempt_id,job_payload_hash:offer.job_payload_hash,assignment_version:job.assignment_version}))?;
channel.send(&request).await?;
@@ -1039,8 +1376,9 @@ impl Agent {
ensure!(self.config.enable_jobs,"UNSUPPORTED_EXECUTION_CAPABILITY");
let binding=self.binding.as_ref().context("JOB_BINDING_REQUIRED")?.clone();
let accepted=self.envelope(generation,Payload::JobAccepted(JobAccepted{job_id:offer.job_id.clone(),attempt_id:offer.attempt_id.clone(),job_payload_hash:offer.job_payload_hash.clone(),journal_proof:rmm_domain::jobs::hash(&offer.encode_to_vec())}))?;
let supported=self.supported_job(&binding.job(&offer.payload_bytes)?);
let tx=self.journal.connection_mut().transaction()?;
let fresh=jobs::accept(&tx,&binding,&offer,rmm_agent_windows::actions::supported)?;
let fresh=jobs::accept(&tx,&binding,&offer,|_|supported)?;
jobs::event(&tx,&accepted)?;tx.commit()?;needs_sync|=fresh;
},
Some(Payload::ExecutionPermit(permit))=>self.permit(generation,permit)?,
@@ -1049,6 +1387,11 @@ impl Agent {
if let Some((bytes,state,grant))=row {
self.journal.connection().execute("UPDATE job_attempts SET cancel_requested=1 WHERE job=?1 AND attempt=?2",rusqlite::params![cancel.job_id,cancel.attempt_id])?;
if let Some(running)=&self.running && running.offer.job_id==cancel.job_id && running.offer.attempt_id==cancel.attempt_id {running.cancel.store(true,Ordering::SeqCst);}
#[cfg(feature="system-helper")]
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
let mut store=rmm_agent_windows::helper_runtime::intent::Store::open(true)?;
if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.cancel_before_dispatch(intent.id)?;}
}
if state=="accepted" {self.record(generation,&JobOffer::decode(bytes.as_slice())?,&grant,jobs::no_start("cancelled","CANCELLED_BEFORE_START"))?;needs_sync=true;}
}
let ack=self.envelope(generation,Payload::Ack(Ack{message_id:message.message_id}))?;channel.send(&ack).await?;
@@ -1158,6 +1501,8 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
#[cfg(feature="system-helper")]
helper_control:None,
#[cfg(feature="system-helper")]
helper_anchor:None,
#[cfg(feature="system-helper")]
helper_checked:false,
#[cfg(feature="system-helper")]
helper_refused:false,
@@ -1242,6 +1587,90 @@ pub fn main() -> Result<()> {
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "system-helper")]
#[test]
fn bound_helper_unknown_repairs_generic_crash_gap_without_ack_or_duplicate_result() {
let path = std::env::temp_dir().join(format!("windows-bound-unknown-{}", Uuid::new_v4()));
fs::create_dir(&path).unwrap();
let journal = Journal::open(&path).unwrap();
let db = journal.connection();
let job = Uuid::new_v4();
let attempt = Uuid::new_v4();
let grant = Uuid::new_v4();
let offer = JobOffer {
job_id: job.to_string(),
attempt_id: attempt.to_string(),
..Default::default()
};
db.execute("INSERT INTO job_attempts(job,attempt,offer,state,revision,grant_id) VALUES(?1,?2,?3,'unknown',1,?4)",rusqlite::params![offer.job_id,offer.attempt_id,offer.encode_to_vec(),grant.to_string()]).unwrap();
let original = Envelope {
message_id: Uuid::new_v4().to_string(),
payload: Some(Payload::JobResult(jobs::result(
&offer,
1,
&grant.to_string(),
Outcome::unknown("GENERIC_REPLY_LOST"),
))),
..Default::default()
};
jobs::event(db, &original).unwrap();
let mut actual = Outcome::unknown("SYSTEM_PREVIOUS_EFFECT_UNRESOLVED");
actual.evidence = serde_json::json!({"retained_helper_evidence":true});
let bound = rmm_agent_windows::helper_runtime::BoundOutcome {
job_id: job,
attempt_id: attempt,
grant_id: grant,
outcome: actual.clone(),
};
// Represents a crash after actual raw-helper outcome persistence but
// before the corresponding journal write, even if mirror receipt exists.
assert!(needs_bound_outcome(db, &bound).unwrap());
assert_eq!(jobs::events(db).unwrap().len(), 1);
let revision = jobs::transition(db, &offer, "unknown", &grant.to_string()).unwrap();
let repaired = Envelope {
message_id: Uuid::new_v4().to_string(),
payload: Some(Payload::JobResult(jobs::result(
&offer,
revision,
&grant.to_string(),
actual,
))),
..Default::default()
};
jobs::event(db, &repaired).unwrap();
assert!(!needs_bound_outcome(db, &bound).unwrap());
assert_eq!(jobs::events(db).unwrap().len(), 2); // retention is never ACK
let mut terminal = bound.outcome.clone();
terminal.state = "failed".into();
let terminal_bound = rmm_agent_windows::helper_runtime::BoundOutcome {
job_id: job,
attempt_id: attempt,
grant_id: grant,
outcome: terminal.clone(),
};
let revision = jobs::transition(db, &offer, "failed", &grant.to_string()).unwrap();
jobs::event(
db,
&Envelope {
message_id: Uuid::new_v4().to_string(),
payload: Some(Payload::JobResult(jobs::result(
&offer,
revision,
&grant.to_string(),
terminal,
))),
..Default::default()
},
)
.unwrap();
// Two restarts after the terminal journal committed but before a
// mirror receipt may never request terminal -> terminal transitions.
assert!(!needs_bound_outcome(db, &terminal_bound).unwrap());
assert!(!needs_bound_outcome(db, &terminal_bound).unwrap());
assert_eq!(jobs::events(db).unwrap().len(), 3);
drop(journal);
fs::remove_dir_all(path).unwrap();
}
#[test]
fn old_passive_configuration_cannot_enable_jobs_or_read_the_clock() {
let config:Config=serde_json::from_value(serde_json::json!({"server_name":"example.invalid","connect_address":"127.0.0.1:443","ca_file":"C:/fixture/ca.pem","state_directory":"C:/fixture/state","enrollment_token_file":"C:/fixture/token","transport":"auto"})).unwrap();
@@ -1319,9 +1748,13 @@ mod tests {
assert!(!fence.allows(1, &Clock(now)));
fence.generation.store(1, Ordering::SeqCst);
assert!(fence.allows(1, &Clock(now)));
assert!(!fence.allows_identity(1, true, &Clock(now)));
fence.helper_generation.store(1, Ordering::SeqCst);
assert!(fence.allows_identity(1, true, &Clock(now)));
assert!(!fence.allows(2, &Clock(now)));
assert!(!fence.allows(1, &Clock(now + chrono::Duration::seconds(1))));
fence.close();
assert!(!fence.allows_identity(1, true, &Clock(now)));
assert!(!fence.allows(1, &Clock(now)));
}
}
+2 -2
View File
@@ -45,7 +45,7 @@ def powershell(script, payload=None, timeout=60, remote_signed=False):
UPLOAD = r'''
$ErrorActionPreference='Stop'
$p=([Console]::In.ReadLine() | ConvertFrom-Json)
if ($p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin|acl)|windows-core-(contracts|reconcile|helper-reconcile))\.exe|(Install-PassiveClient|Build-MsiFixture|Build-NativeMsvc|Install-NativeBuildTools)\.ps1|PassiveStateProbe\.exe|WindowsTlsProbe\.exe|RuntimeStateProbe\.exe)$') {throw 'Artifact allowlist'}
if ($p.name -notmatch '^((rmm-agent-windows|rmm-helper-windows|windows-tests-(lib|bin|acl)|windows-core-(contracts|reconcile|helper-reconcile))\.exe|(Install-PassiveClient|Build-MsiFixture|Build-NativeMsvc|Install-NativeBuildTools)\.ps1|PassiveStateProbe\.exe|WindowsTlsProbe\.exe|RuntimeStateProbe\.exe|SystemStateProbe\.exe)$') {throw 'Artifact allowlist'}
$root='C:\ProgramData\RustDiscoveryBootstrap'
if (!(Test-Path -LiteralPath $root)) {
New-Item -ItemType Directory -Path $root | Out-Null
@@ -68,7 +68,7 @@ if (Test-Path -LiteralPath $path) {throw 'Artifact already exists'}
VERIFY_UPLOAD = r'''
$ErrorActionPreference='Stop'
$p=([Console]::In.ReadLine() | ConvertFrom-Json)
if ($p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin|acl)|windows-core-(contracts|reconcile|helper-reconcile))\.exe|(Install-PassiveClient|Build-MsiFixture|Build-NativeMsvc|Install-NativeBuildTools)\.ps1|PassiveStateProbe\.exe|WindowsTlsProbe\.exe|RuntimeStateProbe\.exe)$') {throw 'Artifact allowlist'}
if ($p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.name -notmatch '^((rmm-agent-windows|rmm-helper-windows|windows-tests-(lib|bin|acl)|windows-core-(contracts|reconcile|helper-reconcile))\.exe|(Install-PassiveClient|Build-MsiFixture|Build-NativeMsvc|Install-NativeBuildTools)\.ps1|PassiveStateProbe\.exe|WindowsTlsProbe\.exe|RuntimeStateProbe\.exe|SystemStateProbe\.exe)$') {throw 'Artifact allowlist'}
$path='C:\ProgramData\RustDiscoveryBootstrap\'+$p.sha256+'\'+$p.name
$hash=(Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant()
if ($hash -cne $p.sha256) {throw 'Artifact hash'}
@@ -0,0 +1,278 @@
#!/usr/bin/env python3
"""Separate source-bound Windows delegation build/native units; no deployment.
Historical feature profiles stay unchanged. Unit execution is create-once;
lost replies permit same-case readback only. No RMM requests or approvals.
"""
import argparse
import base64
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import stat
import subprocess
import uuid
import client_bootstrap as cb
import runtime_feature_upgrade as feature
import runtime_upgrade as previous
import auto_transport_acceptance as auto
require = cb.contract.require
STATE = cb.EVIDENCE / 'system-delegation-acceptance'
CORE = cb.ROOT / 'devstate/core-no-start/build-de37ee99-11bf-465b-9519-45ad8f6e5b87/manifest.json'
CORE_SHA = '1bc082031fcad20d5a519b0004f63d499dbba2ea9ce25d56230d48d2556d474b'
# Final source review must confirm these before a build. No minimum-count proof.
COUNTS = {'lib': 23, 'bin': 7}
NAMES = {'agent': 'rmm-agent-windows.exe', 'helper': 'rmm-helper-windows.exe',
'probe': 'RuntimeStateProbe.exe', 'system_probe': 'SystemStateProbe.exe',
'lib': 'windows-tests-lib.exe', 'bin': 'windows-tests-bin.exe'}
TARGET = previous.TARGET
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(path, value):
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
cb.contract.write_private(path, value)
def sources():
result = feature.source_files()
for path in (cb.ROOT / 'crates').glob('*/Cargo.toml'):
result[str(path.relative_to(cb.ROOT))] = sha(path)
for name in ('deploy/windows/system_delegation_acceptance.py',
'deploy/windows/client_bootstrap.py',
'deploy/windows/system_intent_bootstrap.py'):
result[name] = sha(cb.ROOT / name)
return dict(sorted(result.items()))
def core_proof():
require(sha(CORE) == CORE_SHA, 'exact Linux-first core manifest')
manifest = cb.contract.protected_json(CORE)
result = {'manifest_sha256': CORE_SHA}
for platform, count in (('linux', 80), ('windows', 58)):
path = CORE.parent / (platform + '-passed.json')
proof = cb.contract.protected_json(path)
require(proof['verified'] is True and proof['platform'] == platform
and proof['manifest_sha256'] == CORE_SHA, 'actual same-manifest native core proof')
actual = proof['native']['reports']
require(set(actual) == set(manifest['test_counts'][platform]), 'all core artifacts')
require(sum(len(v['names']) for v in actual.values()) == count, 'full native core lists')
for kind, item in actual.items():
output = base64.b64decode(item['stdout_b64'], validate=True)
n = manifest['test_counts'][platform][kind]
require(item['exit_code'] == 0 and item['timed_out'] is False
and item['names'] == manifest['test_names'][platform][kind]
and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
and re.search(rb'test result: ok\. ' + str(n).encode()
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', output),
'actual complete native core results')
result[platform] = {'proof_sha256': sha(path), 'case_id': proof['case_id']}
for name, digest in manifest['source_files'].items():
if name.startswith(('crates/agent-core/', 'crates/domain/', 'crates/protocol/', 'proto/')):
require(sha(cb.ROOT / name) == digest, 'native-qualified common source unchanged')
return result
def command(args, timeout=600):
value = subprocess.run(args, capture_output=True, timeout=timeout)
if value.returncode:
folder = STATE / ('local-command-failure-' + str(uuid.uuid4()))
folder.mkdir(mode=0o700, parents=True)
save(folder / 'result.json', {'returncode': value.returncode, 'local_build_only': True})
for name, data in (('stdout.bin', value.stdout), ('stderr.bin', value.stderr)):
descriptor = os.open(folder / name, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(descriptor, 'wb') as stream:
stream.write(data)
require(value.returncode == 0, 'local qualification command failed')
return value.stdout
def build():
os.umask(0o077)
before = sources()
common = core_proof()
require(re.search(r'^pub const ADAPTER_QUALIFIED: bool = false;$',
(cb.ROOT / 'crates/agent-windows/src/clock.rs').read_text(), re.M),
'production clock remains closed')
folder = STATE / ('build-' + str(uuid.uuid4()))
folder.mkdir(mode=0o700, parents=True)
save(folder / 'source-before.json', before)
target = STATE / 'target'
target.mkdir(mode=0o700, exist_ok=True)
image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', previous.IMAGE]).decode().strip()
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable build image')
docker = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
'-v', str(cb.ROOT) + ':/src:ro', '-v', str(target) + ':/target',
'-e', 'CARGO_TARGET_DIR=/target', '--entrypoint', 'cargo', image]
options = ['--manifest-path', '/src/Cargo.toml', '--locked', '--offline', '--target', TARGET,
'-p', 'rmm-agent-windows']
command(docker + ['clippy'] + options + ['--all-targets', '--', '-D', 'warnings'])
command(docker + ['clippy'] + options + ['--features', 'system-helper', '--all-targets', '--', '-D', 'warnings'])
command(docker + ['build'] + options + ['--features', 'system-helper', '--bins', '--example',
'runtime_state', '--example', 'system_state', '--release'])
raw = command(docker + ['test'] + options + ['--features', 'system-helper', '--lib', '--bin',
'rmm-agent-windows', '--no-run', '--message-format=json'])
units = {}
for line in raw.splitlines():
try:
item = json.loads(line)
except ValueError:
continue
if item.get('reason') != 'compiler-artifact' or not item.get('profile', {}).get('test') or not item.get('executable'):
continue
if 'rmm-agent-windows' not in item['package_id']:
continue
require('system-helper' in item['features'], 'actual feature unit profile')
kind = 'lib' if 'lib' in item['target']['kind'] else 'bin'
require(kind not in units, 'exact distinct unit artifacts')
units[kind] = target / Path(item['executable']).relative_to('/target')
require(set(units) == set(COUNTS), 'both unit artifacts')
selected = {'agent': (target / TARGET / 'release/rmm-agent-windows.exe', 'rmm-agent-windows.exe'),
'helper': (target / TARGET / 'release/rmm-helper-windows.exe', 'rmm-helper-windows.exe'),
'probe': (target / TARGET / 'release/examples/runtime_state.exe', 'RuntimeStateProbe.exe'),
'system_probe': (target / TARGET / 'release/examples/system_state.exe', 'SystemStateProbe.exe')}
selected.update({kind: (path, 'windows-tests-' + kind + '.exe') for kind, path in units.items()})
artifacts = {}
for kind, (original, name) in selected.items():
path = folder / name
shutil.copyfile(original, path)
path.chmod(0o600)
linked_sha = sha(original)
retained = folder / (name + '.linked')
shutil.copyfile(original, retained)
retained.chmod(0o600)
if kind in COUNTS:
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(folder.resolve()) + ':/artifacts',
'--entrypoint', 'x86_64-w64-mingw32-strip', image, '--strip-debug', '/artifacts/' + name])
require(sha(original) == sha(retained) == linked_sha, 'original link preserved')
data = path.read_bytes()
offset = int.from_bytes(data[60:64], 'little')
require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows AMD64 PE')
artifacts[kind] = {'path': str(path.resolve()), 'name': name, 'sha256': sha(path), 'bytes': len(data),
'original_link_path': str(retained.resolve()), 'original_link_sha256': linked_sha}
require(sources() == before and core_proof() == common, 'sources and common proofs unchanged throughout build')
manifest = {'schema_version': 1, 'type': 'rmm.windows.system-delegation-build', 'source_files': before,
'source_before_after_equal': True, 'artifacts': artifacts, 'native_counts_expected': COUNTS,
'core_native_proofs': common, 'build_image_id': image, 'default_and_feature_alltarget_clippy': True,
'production_clock_qualified': False, 'native_windows_executed': False}
save(folder / 'manifest.json', manifest)
print(json.dumps({'manifest': str((folder / 'manifest.json').resolve()), 'native_executed': False}))
SCRIPT = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('run','read')-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed native delegation unit case'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('delegation-units-'+$p.id)
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Private unit type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty ACL'};foreach($r in $rules){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit ACL'}}}
function WriteNew($path,$value){$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 12 -Compress));$f=[IO.File]::Open($path,'CreateNew','Write','Read');try{$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
Safe $root $true
if($p.action-eq'read'){Safe $case $true;Safe (Join-Path $case 'intent.json') $false;$i=Get-Content -LiteralPath (Join-Path $case 'intent.json') -Raw|ConvertFrom-Json;if($i.manifest_sha256-cne$p.manifest_sha256){throw 'Original native intent'};Safe (Join-Path $case 'result.json') $false;Get-Content -LiteralPath (Join-Path $case 'result.json') -Raw;exit 0}
if(Test-Path -LiteralPath $case){throw 'Existing unit case: readback only'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p
function Run($exe,$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit process start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(30000)){$timed=$true;$c.Kill();$c.WaitForExit()};if($o.Result.Length-gt65536-or$e.Result.Length-gt65536){throw 'Unit output bound'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout=$o.Result;stderr=$e.Result}}finally{$c.Dispose()}}
WriteNew (Join-Path $case 'started.json') @{start_once=$true};$reports=@{}
foreach($kind in @('lib','bin')){$a=$p.artifacts.$kind;if($a.sha256-notmatch'^[a-f0-9]{64}$'-or$a.name-cne('windows-tests-'+$kind+'.exe')){throw 'Fixed unit artifact'};$folder=Join-Path $root $a.sha256;Safe $folder $true;$exe=Join-Path $folder $a.name;Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$a.sha256){throw 'Exact native unit hash'};$listed=Run $exe '--list --format terse';$names=@($listed.stdout-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''}|Sort-Object);if($listed.exit_code-ne0-or$listed.timed_out-or$names.Count-ne$p.counts.$kind){throw 'Exact native count before tests'};$result=Run $exe '--test-threads=1';$v=@{sha256=$a.sha256;names=$names;listed=$listed;result=$result};WriteNew (Join-Path $case ($kind+'-result.json')) $v;$reports[$kind]=$v}
$value=@{manifest_sha256=$p.manifest_sha256;reports=$reports;bootstrap_administrator_units=$true;local_service_proof=$false;rmm_jobs=$false;product_state_writes=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 12 -Compress
'''
def verified(path, current=True):
value = cb.contract.protected_json(path)
require(value['type'] == 'rmm.windows.system-delegation-build' and value['schema_version'] == 1
and value['source_before_after_equal'] is True and value['production_clock_qualified'] is False
and value['default_and_feature_alltarget_clippy'] is True and value['native_counts_expected'] == COUNTS,
'exact delegation build profile')
if current:
require(value['source_files'] == sources() and value['core_native_proofs'] == core_proof(), 'source/native core binding')
require(set(value['artifacts']) == set(NAMES), 'all deployable/test artifacts')
for kind, item in value['artifacts'].items():
binary, linked = Path(item['path']), Path(item['original_link_path'])
require(item['name'] == NAMES[kind] and binary == path.resolve().parent / NAMES[kind]
and linked == path.resolve().parent / (NAMES[kind] + '.linked'), 'fixed artifact paths and names')
for file in (binary, linked):
info = file.lstat()
require(not file.is_symlink() and stat.S_ISREG(info.st_mode) and info.st_uid == os.getuid()
and stat.S_IMODE(info.st_mode) == 0o600, 'private regular retained artifact')
require(binary.resolve().parent == path.resolve().parent
and linked.resolve().parent == path.resolve().parent
and sha(item['path']) == item['sha256']
and sha(item['original_link_path']) == item['original_link_sha256'], 'retained exact artifact/link')
return value
def native(path, ident=None):
manifest = verified(path, current=ident is None)
if ident is None:
ident = str(uuid.uuid4())
folder = STATE / ident
folder.mkdir(mode=0o700)
save(folder / 'intent.json', {'id': ident, 'manifest_path': str(path.resolve()), 'manifest_sha256': sha(path),
'runner_sha256': sha(__file__), 'script_sha256': hashlib.sha256(SCRIPT.encode()).hexdigest()})
save(folder / 'server-before.json', {'counts': auto.scopes(), 'flags': auto.status()})
for kind in COUNTS:
previous.upload(manifest['artifacts'][kind])
save(folder / 'started-local.json', {'start_once': True})
action = 'run'
else:
ident = str(uuid.UUID(ident))
folder = STATE / ident
intent = cb.contract.protected_json(folder / 'intent.json')
require(intent['manifest_sha256'] == sha(path) and intent['manifest_path'] == str(path.resolve())
and intent['runner_sha256'] == sha(__file__)
and intent['script_sha256'] == hashlib.sha256(SCRIPT.encode()).hexdigest()
and (folder / 'started-local.json').exists(), 'same exact started case; readback only')
action = 'read'
result = cb.powershell(SCRIPT, {'id': ident, 'action': action, 'manifest_sha256': sha(path),
'artifacts': {k: manifest['artifacts'][k] for k in COUNTS}, 'counts': COUNTS}, timeout=100)
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
require(result['manifest_sha256'] == sha(path) and set(result['reports']) == set(COUNTS), 'exact native manifest/reports')
for kind, actual in result['reports'].items():
run = actual['result']
listed = actual['listed']
require(actual['sha256'] == manifest['artifacts'][kind]['sha256'] and len(actual['names']) == COUNTS[kind]
and listed['exit_code'] == run['exit_code'] == 0 and not listed['timed_out'] and not run['timed_out']
and len(set(actual['names'])) == COUNTS[kind]
and re.search(r'test result: ok\. ' + str(COUNTS[kind])
+ r' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', run['stdout']),
'every native unit passes, none skipped/filtered')
before = cb.contract.protected_json(folder / 'server-before.json')
require(auto.scopes() == before['counts'] and auto.status() == before['flags'] and auto.flags_disabled(before['flags']),
'both target counts and closed policies unchanged')
proof = {'verified': True, 'case_id': ident, 'manifest_path': str(path.resolve()), 'manifest_sha256': sha(path),
'native': result, 'no_jobs': True, 'clock_adapter_qualified': False, 'local_service_proof': False}
destination = folder / 'passed.json'
if destination.exists():
require(cb.contract.protected_json(destination) == proof, 'retain exact original native proof')
else:
save(destination, proof)
print(json.dumps({'verified': True, 'case_id': ident, 'tests': COUNTS, 'proof': str(destination.resolve())}))
def main():
os.umask(0o077)
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('phase', choices=('build-local', 'native-units', 'readback'))
parser.add_argument('--manifest', type=Path)
parser.add_argument('--case')
args = parser.parse_args()
if args.phase == 'build-local':
require(not (args.manifest or args.case), 'local build only')
build()
else:
require(args.manifest and ((args.phase == 'readback') == bool(args.case)), 'explicit manifest and original readback case')
native(args.manifest, args.case)
if __name__ == '__main__':
try:
main()
except Exception as error:
print('WINDOWS_DELEGATION_QUALIFICATION_INCOMPLETE:' + type(error).__name__)
raise SystemExit(2) from None
+10
View File
@@ -53,6 +53,16 @@ Zugänge und private Rohbelege bleiben gitignoriert.
## Aktuelle Windowsfortsetzung
Neuer SYSTEM-Delegationsadapter unabhängig quellgeprüft und als gemeinsamer
Build `80655271…`/Manifest `71914e2a…` mit70Quellen gebunden. Nativ Windows
23Lib+7Bin ohne Skips bestanden, Fall `5f95361a…`; RawMirror-Unknown und
wiederholter Terminal-Startup idempotent korrigiert. Statische private Pipe-
Diagnose und dokumentierte OVERLAPPED-Bytezählung korrigiert, ursprüngliche
Nativeursache weiter unbewiesen. SSH-Timeout vor erstem Unitstart nur nach
Readonly-Hash-/Abwesenheitsbeleg als erste noch nicht erreichte Phase fortgesetzt.
Neue Artefakte89004ad3/e6aacbdd **noch nicht installiert**; tatsächliche
Agent-/Helper-Runtime2bee/921c unverändert. [Genauer Quellen-/Native-Stand](windows-system-delegation-source.md).
Eigene Intentablage auf dem Windowsgast einmal vorbereitet und separat nur
lesend verifiziert, Fall `f322a4d2…`: geschütztes Verzeichnis und genau zwei
Admin-owned0B-Leaves mit Actor-RW/Synchronize ohne Delete/Owner/DACLrechte.
+1 -1
View File
@@ -11,7 +11,7 @@ bleibt eine eigenständige Abnahme. Dieser Bericht erweitert dessen Umfang nicht
| Passiver Client | SCM-Dienst, Service-SID/ACLs, Enrollment/mTLS/WSS, Inventar mit Quelle/Zeit, Heartbeats und Mandantentrennung nativ bestanden; sieben native Rusttests. | Bestehende Identität und Telemetriehistorie bei allen weiteren Schritten erhalten. |
| HTTPS/Fallback | Explizites HTTPS und automatischer Fallback nach zwei tatsächlichen mTLS-WSS503 unter LocalService nativ bestanden, jeweils mit frischen Heartbeats und Inventar-ACK. Testhooks geschlossen. Anschließend bestehende VM separat dauerhaft auf `auto` gestellt und bevorzugtes WSS erneut mit zwei frischen Heartbeats/ACK geprüft; Identität und ACLs erhalten, 0 Jobs/Grants. | Transportnachweise abgeschlossen; kein automatischer HTTPS→WSS-Switchback nachgewiesen. Installerdefault ebenfalls `auto`, aber keine neue Installationsabnahme. |
| TLS-Lifecycle | Falsche CA, falscher Name und abgelaufenes Clientzertifikat mit gültigen Kontrollen nativ als getrennte Admin-TLS-Proben bestanden. Permanente Identität/Dienst unverändert. | Rotation und Widerruf noch gesondert sicher implementieren und prüfen. Permanente Identität nicht widerrufen oder ersetzen. |
| Signierter Jobkern | Gemeinsamer Core/Helper-Sync und atomare Outcomes nativ zuerst Linux, dann Windows geprüft; letzter Fixturelauf76/54. Default-Windowsdienst mit additiver Journalmigration erhaltend als LocalService aktualisiert; native Unitqualifikation12+6. Jobs bleiben deaktiviert, kein Binding/Ledger angelegt. | Tatsächlichen signierten Dienst-Sync, qualifizierte Uhr und vollständige Startgrenze nachweisen. Passive Migration und Unit-Fixturen ersetzen keinen Jobnachweis. |
| Signierter Jobkern | Gemeinsamer Kern zuletzt nativ Linux80→Windows58 qualifiziert. Neuer enger SYSTEM-Delegationsadapter mit dauerhaftem Intent, deny-only Abandon und unabhängigem RawMirror implementiert; native23+7Units bestanden. Bestehender laufender passiver Client bleibt unverändert; neue Artefakte noch nicht installiert. Jobs bleiben deaktiviert. | Tatsächlichen signierten Dienst-Sync, qualifizierte Uhr und vollständige Startgrenze nachweisen. Units ersetzen keinen LocalService-/SYSTEM- oder Jobnachweis; [Quellenstand](windows-system-delegation-source.md). |
| PowerShell | Begrenzter5.1-Executor implementiert; exakte Skriptbytes, atomarer Prozessbaum, Rohbytes und Unknown bei unklarer Wirkung. Server/UI unterstützen feste Plattformvarianten. Keine tatsächliche Ausführung, Richtlinie derzeit geerbt. | Ausstehende konkrete Richtlinienentscheidung beachten, Encoding/Prozessgrenzen unter LocalService tatsächlich qualifizieren; ausschließlich vollständiger Antrag und tatsächlicher WebUI-Klick. |
| Privilegierte Aktionen | Eigener SYSTEM-Helper nativ installiert und einmal gestartet, Manual/LocalSystem, leere Aktionsliste und Wirkungen/Reboot gesperrt. Die echte LocalService-Agentprobe scheitert derzeit; kein positiver Peer-/Sync-/Wirkungsnachweis. | Fehler ohne Erweiterung der Sicherheitsgrenze diagnostizieren; gegenseitige SID/PID/Binary-/Dateibindung und unabhängigen Sync nativ prüfen. |
| Pakete/Dienste/Logs | Kleines MSI1.0.0 auf der VM erstellt, nur lesend geprüft und nach Download gehasht; keine Installation. Dienst-/Eventlog-/Paketquellen teilweise vorbereitet, keine native Aktionsabnahme. | Unveränderliche Tenantrezepte integrieren; UI-genehmigte MSI-/EXE-Installation/Upgrade/Noop, Dienste und Logs mit unabhängigen Nachbedingungen prüfen. |
+157
View File
@@ -0,0 +1,157 @@
# Windows-SYSTEM-Delegation: Quellenstand
Stand2026-11-14, Spezifikation1.17. Dies ist ein implementierter **Kandidat zur
Sourceprüfung**, keine native Dienst-/IPC-/SCM-Abnahme. Die produktive Clock-
Qualifikation, Jobkonfiguration, Helperwirkung und veröffentlichten Fähigkeiten
bleiben deaktiviert. Der vorhandene Windowsgast und der endgültige Cloudserver
bleiben die Ziele; der Notebookhost bleibt Entwicklungsrechner.
## Implementierter Ablauf
Der Netzwerkagent persistiert vor einer möglichen Übergabe einen eigenen festen
SYSTEM-Intent mit den unveränderten vertraulichen Originalrequestbytes,
Originalgrant, Boot-/Agentinstanz-/Verbindungskontext und dem tatsächlich vom
Helper zurückgegebenen historischen Readyanker. Die Daten werden nicht in
Logs oder MCP-Ausgaben exportiert. Ein Intent ist noch kein Helperverbrauch.
Dispatcher und Cancellation verwenden dieselbe dauerhafte SQLite-CAS:
`prepared` wird ausschließlich `known_no_dispatch` oder `may_have_dispatched`.
Nach einem May-Marker gibt es weder Execute-Redelivery noch eine Umklassifikation
zu bekanntem Nichtstart. Ein weiterer Start bleibt gesperrt. Lokale Consumption
entsteht nicht mehr vor der SYSTEM-Übergabe. Nach einem IPC-Ausgang wird zunächst
ehrliches Unknown mit dem **Originalgrant** gespeichert.
Der separate strikt dekodierte Helpervorgang Abandon führt keinen Fixture-SCM-
oder Provideraufruf aus. Die lokale Allowlist wird nur logisch geprüft. Der
geschützte Adapter liest gezielt den tatsächlichen festen Intentstore und dessen
Known-CAS. Der gemeinsame Helperkern prüft unabhängig Signatur, aktuelle echte
Clock, ursprünglichen Boot, exakten alten Readyanker und erhaltene Lineage.
Zusätzlich bindet der Windowsguard eigene Kernel-PID, Prozessstart, Image-Datei-ID
sowie Ledger-/Lock-Datei-IDs. Ein neuer Nichtstart braucht dieselbe Helperinstanz;
neue Instanzwerte ersetzen niemals den alten Anker. Vorhandene Verbräuche und
Outcomes werden nicht überschrieben.
Ein bereits dauerhaft bekannter Nichtstart darf nach Agentneustart genau einen
deny-only Abandon-Abgleich pro **neuer** Agentinstanz versuchen. Ein eigener
unveränderlicher Resume-Beleg steht vor diesem RPC. Danach folgt immer ein
frischer RawSnapshot. Eine verlorene Antwort erlaubt in derselben Instanz nur
weitere Snapshotabfrage. May-Marker und bloß vorbereitete unterbrochene Intents
bleiben konservativ Unknown/manuell gesperrt.
## Spiegelung und Crashgrenzen
Auch eine erfolgreiche Execute-/Abandonantwort ist kein Mirrorbeleg. Der Adapter
verlangt einen frischen unabhängig authentisierten rohen Helpersnapshot und
prüft das vollständige Originaltupel einschließlich Autorisierung, Plan, Aktion,
Identität, Originalboot und Hash des unveränderten Requestcodecs. Dazu kommen
kanonische Outcomebytes/Hash/Zustand, Output-/Rebootgrenzen und bei Erfolg die
exakten SCM-Nachbedingungen. Fehlender Helperversuch wird nicht ergänzt oder
als Nichtstart umgedeutet.
Die **Helper-Abandontransaktion** schreibt Consumption, Originalstartzeugen und
festen NoEffect-Outcome atomar. Die **Network-Spiegelung** benutzt dagegen die
vorhandenen gemeinsamen APIs: `begin_execution` speichert c+start atomar;
anschließend wird der unabhängig nachgewiesene Outcome persistiert. Ein Crash
dazwischen bleibt gesperrt und wird nur aus einem erneut frisch authentisierten
RawSnapshot fortgesetzt. Eine vorhandene exakt passende Originalzeile wird
idempotent akzeptiert, abweichende Daten werden verweigert. Erst nach vollständiger
Spiegelung darf der unveränderte gemeinsame Sync fortfahren. Keine Missing-Row-
Prüfung wurde für diesen Adapter gelockert.
Ein tatsächlicher gebundener Helper-Unknown wird vor dem gemeinsamen Sync auch
im Jobjournal kanonisch gespeichert. Ein pauschaler Transport-Unknown darf nicht
neben einem anderen tatsächlichen Unknown im Verbrauchsledger stehen bleiben.
Der Abgleich prüft dafür auch bereits gespiegelte Intents erneut anhand des
frischen RawSnapshot. Beim Startup wird ein schon gespeicherter tatsächlicher
Outcome erhalten; ein identischer terminaler Jobjournalbeleg wird nicht erneut
als Zustandsübergang geschrieben. Der neue enge Regressionsfall bildet Unknown-
Abweichung und wiederholten Startup nach der Mirror-Crashlücke ab. Archivierung
ist keine ACK-Verarbeitung und löscht keine ausstehenden Events.
Die Network-Reservierungszeit bleibt der tatsächlich gespeicherte Intentzeitpunkt.
`mirror_observed_at` wird separat gespeichert; weder dieser Wert noch der
Snapshotzeitpunkt wird als unbekannte native Helper-/SCM-Startzeit dargestellt.
## Geschützte Bootstrapgrenze
`deploy/windows/system_intent_bootstrap.py` wurde nach unabhängiger Sourceprüfung
im Fall `f322a4d2-c537-4842-bf04-658ad8f814b0` tatsächlich auf der Windows-VM
ausgeführt. Quelle SHA256 `7597ac0f…`. Sie erzeugte ausschließlich den festen Ordner
`C:\ProgramData\RustDiscoverySystem\agent-intents` und die beiden vorab angelegten
Leaves `system-intents.sqlite` und `system-intents.sqlite-journal`. SYSTEM/Admins
bleiben Besitzer; der Agent-Service-SID erhält Verzeichnis-RX und auf genau den
Leaves Read/Write/Synchronize, keine Owner-/DACL-/Delete-/DeleteChild-Rechte.
Beide Dateien sind tatsächlich0Bytes lang. Native Owner-/ACLprüfung bestand:
Actor-Maske `0x12019f`, keine Directory-Create-/Delete-/Owner-/DACLrechte.
Ursprüngliche Agent-/Helperprozesse5140/6240, Konfiguration, öffentliche Pins
und private Helper-/Geräteschlüsselmetadaten blieben im Vorher-/Nachhervergleich
erhalten. Keine Dienständerung, Joboperation, SQLiteinitialisierung oder Clockänderung.
Der implementierte Helperadapter soll den Store nur lesend öffnen und gehaltene
Dateiidentitäten prüfen; das ist mit der Dateivorbereitung noch nicht nativ belegt.
SQLite-PERSIST erhält das vorab angelegte Rollbackjournal, statt dem Actor
Verzeichnisanlage- oder Löschrechte zu geben. WAL und zusätzliche Dateien werden
nicht verwendet. Der Sourceentscheid folgt der [SQLite-PRAGMA-Dokumentation](https://www.sqlite.org/pragma.html#pragma_journal_mode).
Die tatsächliche Verzeichnis-/Leaf-ACL ist jetzt nativ vorbereitet und geprüft.
PERSIST-/Sharing-/Hotjournalfunktion unter dem Agenttoken bleibt separat offen;
zwei leere Dateien sind ausdrücklich kein SQLite-Funktionsnachweis.
Fehlende oder abweichende Provisionierung verweigert die SYSTEM-Strecke; der
passive Standardclient provisioniert oder repariert nichts.
## Tatsächliche Prüfgrenzen
Die genehmigte Entwicklungsdiagnose ergänzt im vorhandenen privaten
Agent-Probereport ausschließlich feste Stufen-/Codefelder. Der Helper hält
genau `state/pipe-last-error.json` plus eine feste Pendingdatei und versucht
höchstens einen Schreibzugriff je30Sekunden. Inhalt: PID, UTC-Beobachtungszeit,
statische Stufe/Whitelistcode und optional eine unmittelbar am fehlgeschlagenen
API-Aufruf erfasste numerische Win32fehlernummer. Keine Request-/Binding-/Grant-
oder Tokendaten, kein beliebiger Fehlertext, keine Historie und keine zusätzliche
RMM-/MCP-Inventarfähigkeit. Sicherheitsfehler schließen weiterhin Sync und Pipe;
ein fehlgeschlagenes Revert führt weiterhin zum Prozessabbruch. Ein Fehler der
Diagnostik wird nicht als Sicherheitsausnahme behandelt.
Im gleichen Kandidaten ist der belegte Source-APIfehler bei OVERLAPPED-I/O
korrigiert: direkte ReadFile-/WriteFile-Bytezähler sind null, tatsächliche
Completionbytes kommen auch bei sofortigem TRUE aus GetOverlappedResult.
Bestehende Deadline-, Cancel- und Pufferlebensdauer-/Abbruchgrenzen bleiben
erhalten. Grundlage: [ReadFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile)
und [WriteFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefile).
Dies belegt keine tatsächliche Ursache des früheren nativen Probefehlers.
Feature- und Defaultprofile wurden lokal für Windows-GNU mit
`cargo clippy --locked --offline --all-targets -- -D warnings` erfolgreich
crossgeprüft; die neue Bootstrapquelle wurde durch den PowerShell-AST-Parser
geprüft. Eine enge neue CAS-Fixture ist implementiert und crosskompiliert.
Windows-Unitlinks wurden erzeugt; dies ist keine native Testausführung.
Unabhängiger finaler Source-Review bestanden. Ein gemeinsamer Build bindet70
Quellen, beide Alltargets-Clippy-Profile und sechs erhaltene AMD64-PE-Artefakte:
Agent, Helper, zwei Readonlyprobes und beide Unitprogramme. Manifest
`build-80655271-dbe6-474f-89de-014fd5a67c8d`, SHA256 `71914e2a…`;
private gehashte vollständige Quellenkopie zusätzlich erhalten.
Auf der tatsächlichen Windows-VM bestanden danach23Lib+7Bin-Units ohne Skips,
Fall `5f95361a-5b4e-4fa0-aeeb-414a8dfac613`. Anschließender separater Readback
und Prüfung unveränderter zentraler Zähler/geschlossener Flags bestanden.
Bootstrap-Administrator-Units, kein LocalService-/SYSTEM-Runtimebeweis.
Der ursprüngliche SSH-Timeout lag nach der Übertragung vor dem ersten Unitstart.
Nur lesend wurden beide vollständigen Binärhashes/-größen und das Fehlen von
Remote-Testfall/Startmarker nachgewiesen. Danach wurde im selben Fall ausschließlich
die erste noch nicht erreichte Testphase mit zusätzlichem dauerhaftem Intent
fortgesetzt; keine erneute Übertragung oder Testwiederholung. Alter Timeout erhalten.
Noch offen sind die tatsächlichen Agenttoken-/SQLite-/Crash-/Nichtstart-/Mirror-
Nachweise. Die separate positive Agent-/Helper-
Pipeprüfung, TrustedClock und WebUI-genehmigte SYSTEM-SCM-Abnahme bleiben eigene
offene Gates. Frühere native Unit- und passive Transportnachweise werden nicht
als Nachweis dieses neuen Ablaufs umetikettiert.
Der gemeinsame Kernvertrag ist inzwischen separat nativ zuerst auf Cloud-Linux80,
danach Windows58 Prüfungen qualifiziert; siehe [Abandonvertrag](windows-system-abandon.md).
Die Sourcekorrekturen zu tatsächlichen Helper-Unknowns und wiederholtem Startup
erhalten identische kanonische Ergebnisse samt Originalgrant. Statische private
Pipe-Fehlercodes und der dokumentierte OVERLAPPED-Bytezählerpfad sind korrigiert;
die Ursache des ursprünglichen tatsächlichen Verbindungsfehlers bleibt unbewiesen.
Die neuen Adapterunits sind23Lib+7Bin **nativ bestanden**; eine Installation des
damit gebundenen neuen Agenten/Helpers ist noch nicht erfolgt.
+69
View File
@@ -0,0 +1,69 @@
# Fester Nur-Lese-Zeuge für Windows-Helperwartung
Stand2026-11-14: `examples/system_state.rs` ist implementiert. Windows-GNU-
Example-Clippy mit `-D warnings`, Release-Link und AMD64-PE-Prüfung bestanden
im Defaultprofil. **Keine native Ausführung, Dienstwartung oder Erhaltungsabnahme
durch diesen Quellenstand.** Die gemeinsame Artefaktqualifikation des späteren
Wartungsrunners bleibt separat.
`SystemStateProbe.exe` hat keine Argumente und benötigt einen tatsächlich
aktivierten Administratorgruppen-Token ohne Threadimpersonation. Der Bootstrap-
Runner bindet den tatsächlichen Aufrufkontext. Es ist kein LocalService-/SYSTEM-
Pipebeweis, keine RMM-Capability und kein Genehmigungsweg.
Der feste Beobachtungsumfang ist `C:\ProgramData\RustDiscoverySystem`:
- `state\ledger.sqlite`: ausschließlich lesende SQLite-Transaktion,
Integrität, bekannte Schema-/Indexdefinitionen sowie Zeilenzahl und
deterministischer typisierter Hash je erlaubter Tabelle. Pflicht sind
`consumed`, `execution_evidence` und `windows_helper_files`. Die vier
`helper_sync_*`-Tabellen dürfen gemeinsam fehlen; `absent_tables` meldet das
ausdrücklich. Teilweise oder unbekannte Schemas werden verweigert.
- `state\executor.lock`, `helper.json`, `agent-pin.json`: ausschließlich
Dateimetadaten, Owner-/DACL-Prüfung und ACLhash. Keine Pin-/Request-/Schlüssel-
oder privaten Zeileninhalte in der Ausgabe.
- Optional `agent-intents`: entweder vollständig abwesend oder exakt der
vorprovisionierte Ordner mit zwei regulären, leeren festen Leaves. Nur
Metadaten; keine SQLiteöffnung oder Initialisierung dieser Dateien. Ein
bereits initialisierter Intentstore gehört nicht zu diesem Wartungsprofil.
Gehaltene Handles, Wiederöffnung des festen Pfads und die tatsächliche native
SQLite-VFS-Dateikennung müssen übereinstimmen. Volume-ID und FILETIME erscheinen
als Dezimalstrings, damit PowerShell alle64Bit erhält. Der Witness akzeptiert
die vom bestehenden Helper erstellten geerbten Datei-ACEs nur unter
dem gehaltenen geschützten State-Verzeichnis, bei weiterhin exakt geprüften
effektiven Writerrollen und SYSTEM-/Admin-Owner. Andere Schutzdeskriptoren werden
nicht passend geändert; Root-, State- und Intentverzeichnisse bleiben geschützt.
Die Datenbankverbindung
bleibt read-only; es gibt weder Migration noch Schreib-PRAGMA, WAL-Override,
`immutable` oder `nolock`. Bestehende Journal-/WAL-/SHM-Sidecars und ein
abweichender Rollbackheader werden vor der SQLiteöffnung verweigert. Kein
Journal wird repariert, gelöscht oder zurückgesetzt.
Die separate tatsächliche Nur-Lese-Erhebung `acl-readonly-d4795190…` bestätigte
den geschützten State-Ordner mit Administratorowner und die beiden vom Helper
erzeugten SYSTEM-eigenen, ungeschützten Dateien mit genau drei geerbten Full-
Control-ACEs für SYSTEM, Administratoren und Helper-Service-SID. Keine Reparse-
Points, keine Datei-/ACLänderung oder privaten Dateiinhalte gelesen. Die private
Metadatenreceipt hat SHA256 `12e2ca43…`; dies ist **keine native Ausführung**
des neuen vollständigen Witnessprogramms.
Der Reader begrenzt Dateigröße auf1GiB, Schemaobjekte auf32, Zeilen pro Tabelle
auf10000, einzelne Werte auf1MiB, gehashte Text-/Blobwerte insgesamt auf32MiB
und die JSON-Ausgabe auf32768Byte. Synchrone Dateisystem-/Securityabfragen
besitzen dadurch keine harte Zeitgrenze; der separate Bootstrapcontroller muss
seinen eigenen Witnessprozess begrenzen. Fehler geben ausschließlich
`SYSTEM_STATE_WITNESS_REFUSED` aus. Kein Bytehash einer laufenden Datenbank;
einen solchen darf der Wartungsrunner erst nach bestätigtem Ende beider alten
Dienstprozesse separat erheben.
Die native Handleabfrage verwendet die dokumentierte reine
[SQLite-WIN32_GET_HANDLE-Operation](https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html).
Der Handle bleibt Eigentum von SQLite. Der Schutzdescriptor wird nur mit
[GetSecurityInfo](https://learn.microsoft.com/en-us/windows/win32/api/aclapi/nf-aclapi-getsecurityinfo)
gelesen; keine Privilegien oder DACLs werden verändert.
Der bestehende `RuntimeStateProbe.exe` für das Agenttelemetriejournal bleibt
unverändert und wird vom Wartungsrunner gesondert verwendet. Das Notebook
bleibt Entwicklungsrechner; kein Agent, Server, VM-Neustart oder Job wurde
für diesen Quellen-/Crossbuildnachweis gestartet.