118 lines
5.2 KiB
Rust
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);
|
|
}
|