Files
2026-11-14 02:39:39 +01:00

118 lines
5.2 KiB
Rust

//! Fixed guest read-only persistence witness. No keys, job, grants or clock query.
#[cfg(windows)]
fn main() -> anyhow::Result<()> {
use anyhow::ensure;
use serde_json::json;
use sha2::{Digest, Sha256};
use std::{fs, os::windows::io::AsRawHandle, path::Path};
use windows_sys::Win32::Storage::FileSystem::{
BY_HANDLE_FILE_INFORMATION, GetFileInformationByHandle,
};
let state = Path::new(r"C:\ProgramData\RustDiscovery\state");
rmm_agent_windows::native::private_path(state, true)?;
let path = state.join("telemetry.sqlite");
rmm_agent_windows::native::private_path(&path, false)?;
let file = fs::File::open(&path)?;
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
// SAFETY: live read-only file handle and correctly sized writable structure.
ensure!(
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0,
"DATABASE_FILE_ID"
);
let db =
rusqlite::Connection::open_with_flags(&path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)?;
db.execute_batch("BEGIN DEFERRED")?;
ensure!(
db.query_row("PRAGMA integrity_check", [], |r| r.get::<_, String>(0))? == "ok",
"JOURNAL_INTEGRITY"
);
let sequence: i64 =
db.query_row("SELECT value FROM metadata WHERE key='sequence'", [], |r| {
r.get(0)
})?;
let agent: String = db.query_row("SELECT agent FROM identity", [], |r| r.get(0))?;
ensure!(
agent == "63ea15b2-0643-403d-b5b4-cba1288dbea3" && sequence >= 0,
"FIXED_EXISTING_IDENTITY"
);
let identity: Vec<String> = db
.prepare("SELECT agent FROM identity ORDER BY agent")?
.query_map([], |r| r.get(0))?
.collect::<rusqlite::Result<_>>()?;
let metadata: Vec<(String, i64)> = db
.prepare("SELECT key,value FROM metadata ORDER BY key")?
.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?
.collect::<rusqlite::Result<_>>()?;
let mut events = Vec::new();
for row in db
.prepare("SELECT id,payload FROM events ORDER BY id")?
.query_map([], |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, Vec<u8>>(1)?))
})?
{
let (id, bytes) = row?;
ensure!(
events.len() < 8 && bytes.len() <= 512 * 1024,
"LEGACY_EVENT_LIMIT"
);
events.push(json!({"id":id,"payload_sha256":format!("{:x}",Sha256::digest(&bytes)),"bytes":bytes.len()}));
}
let schema:Vec<(String,String,String)>=db.prepare("SELECT type,name,sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%' ORDER BY type,name")?.query_map([],|r|Ok((r.get(0)?,r.get(1)?,r.get::<_,Option<String>>(2)?.unwrap_or_default())))?.collect::<rusqlite::Result<_>>()?;
ensure!(schema.len() <= 64, "SCHEMA_LIMIT");
let mut counts = serde_json::Map::new();
for table in [
"job_attempts",
"job_events",
"reconcile_requests",
"reconcile_results",
"reconcile_receipts",
"reconcile_outcomes",
] {
if schema
.iter()
.any(|(kind, name, _)| kind == "table" && name == table)
{
let count: i64 =
db.query_row(&format!("SELECT count(*) FROM {table}"), [], |r| r.get(0))?;
counts.insert(table.into(), json!(count));
}
}
let counter = if schema.iter().any(|(_, name, _)| name == "counter") {
Some(db.query_row("SELECT seq FROM counter WHERE id=1", [], |r| {
r.get::<_, i64>(0)
})?)
} else {
None
};
if let Some(counter) = counter {
ensure!(counter == sequence, "COUNTER_ALIAS");
}
let page_size: i64 = db.query_row("PRAGMA page_size", [], |r| r.get(0))?;
let page_count: i64 = db.query_row("PRAGMA page_count", [], |r| r.get(0))?;
ensure!(
page_size == 4096 && page_count > 0 && page_count <= 262144,
"FINITE_FILE_BUDGET"
);
db.execute_batch("ROLLBACK")?;
let hash = |value: &serde_json::Value| -> anyhow::Result<String> {
Ok(format!("{:x}", Sha256::digest(serde_json::to_vec(value)?)))
};
let value = json!({"read_only":true,"integrity":"ok","agent_id":agent,"sequence":sequence,
"pending_inventory_events":events.len(),"legacy_events":events,"identity_sha256":hash(&json!(identity))?,
"metadata_sha256":hash(&json!(metadata))?,"events_sha256":hash(&json!(events))?,
"schema":schema,"core_counts":counts,"counter":counter,"page_size":page_size,"page_count":page_count,
"database_file_id":{"volume":info.dwVolumeSerialNumber,"high":info.nFileIndexHigh,"low":info.nFileIndexLow},
"database_creation":{"high":info.ftCreationTime.dwHighDateTime,"low":info.ftCreationTime.dwLowDateTime},
"consumption_exists":state.join("consumption.sqlite").try_exists()?,"jobs_directory_exists":state.join("jobs").try_exists()?,
"private_key_read":false,"clock_queried":false,"jobs_created":false});
let encoded = serde_json::to_string(&value)?;
ensure!(encoded.len() <= 32768, "WITNESS_OUTPUT_LIMIT");
println!("{encoded}");
Ok(())
}
#[cfg(not(windows))]
fn main() {
eprintln!("Native Windows-only read-only state witness");
std::process::exit(1);
}