Integrate signed agent catalog, tenant enrollment and HTTPS installers

This commit is contained in:
2026-11-17 15:56:18 +01:00
parent 689f326460
commit 7fd17272d5
70 changed files with 12982 additions and 327 deletions
@@ -7,6 +7,10 @@
#[path = "../src/helper_ipc.rs"]
pub mod helper_ipc;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_admission { pub use rmm_agent_windows::update_admission::Accepted; }
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_observer { pub use rmm_agent_windows::update_observer::{Request,Response}; }
#[cfg(all(windows, feature = "system-helper"))]
pub use rmm_agent_windows::SERVICE_NAME;
#[cfg(all(windows, feature = "system-helper"))]
mod platform {
@@ -0,0 +1,532 @@
//! One reviewed development bootstrap: normal stop of the exact old agent,
//! while an existing SQLite reservation excludes a new Sync/permit journal
//! commit. No job, approval, SQL row change, helper stop, reset or force kill.
#[cfg(all(windows, feature = "system-helper"))]
mod platform {
use anyhow::{Context, Result, ensure};
use prost::Message;
use rmm_agent_core::{
auth::{Binding, Outcome, Request},
crypto::DalekVerifier,
helper_reconcile::SignedResponse,
reconcile::{Channel, verify_response_with},
};
use rmm_agent_windows::{
helper_ipc::{self as ipc, PeerProof, PinnedFile},
native,
};
use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload};
use rmm_protocol::{SyncRequest, SyncResponse,Envelope,Payload};
use rusqlite::{Connection, OpenFlags};
use serde_json::json;
use std::{
fs::{File, OpenOptions},
io::{Read, Write},
mem::{size_of, zeroed},
os::windows::fs::OpenOptionsExt,
path::Path,
ptr,
time::{Duration, Instant},
};
use uuid::Uuid;
use windows_sys::Win32::{
Foundation::*, Security::*, Storage::FileSystem::*, System::Services::*,
};
const AGENT: &str = "9651b2e518b315029cebfa432261a57f0a305aeddde29c56ac22a5ccbc417b32";
const HELPER: &str = "59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e";
const PIN: &str = "9d46dffe88f565b8b04554335d9669f5c83211b32419908a579b1cd4560443ec";
const SETTINGS: &str = "4c073cd3d4badb09d8c0f1c270b4cee9df533df416550f68bf3e336e3da7673c";
const CONFIG: &str = "5cd4cb9802d0dd20b961de7e3cd4e5874a1e9a72fc57b577e075e2d2918baac6";
const CASE: &str = "c6c80ac4-a52e-4b69-8170-466bcf52049d";
const JOB: &str = "0a50aae9-a784-4535-b62f-ef24c301d546";
const ATTEMPT: &str = "78295f74-4565-459a-87b0-641a8b95feec";
const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state";
const HELPER_STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state";
struct Handle(SC_HANDLE);
impl Drop for Handle {
fn drop(&mut self) {
unsafe {
CloseServiceHandle(self.0);
}
}
}
fn admin() -> Result<()> {
let mut sid = [0usize; 16];
let mut len = std::mem::size_of_val(&sid) as u32;
let mut member = 0;
ensure!(
unsafe {
CreateWellKnownSid(
WinBuiltinAdministratorsSid,
ptr::null_mut(),
sid.as_mut_ptr().cast(),
&mut len,
)
} != 0
&& unsafe {
CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member)
} != 0
&& member != 0,
"QUIESCENT_ADMIN_REQUIRED"
);
Ok(())
}
fn service(stop:bool) -> Result<Handle> {
let manager =
Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
ensure!(!manager.0.is_null(), "QUIESCENT_SCM_MANAGER");
let h = Handle(unsafe {
OpenServiceW(
manager.0,
ipc::wide(rmm_agent_windows::SERVICE_NAME).as_ptr(),
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | if stop {SERVICE_STOP}else{0},
)
});
ensure!(!h.0.is_null(), "QUIESCENT_SCM_AGENT");
Ok(h)
}
fn status(h: &Handle) -> Result<SERVICE_STATUS_PROCESS> {
let mut s = unsafe { zeroed() };
let mut n = 0;
ensure!(
unsafe {
QueryServiceStatusEx(
h.0,
SC_STATUS_PROCESS_INFO,
(&mut s as *mut SERVICE_STATUS_PROCESS).cast(),
size_of::<SERVICE_STATUS_PROCESS>() as u32,
&mut n,
)
} != 0,
"QUIESCENT_SCM_STATUS"
);
Ok(s)
}
fn protected(path: &Path, readers: &[String], expected: &str) -> Result<(PinnedFile, Vec<u8>)> {
let mut file = PinnedFile::open(path, false, readers, &[], false)?;
ensure!(
file.file.metadata()?.len() <= 65536,
"QUIESCENT_PUBLIC_FILE_LIMIT"
);
let mut raw = Vec::new();
(&mut file.file).take(65537).read_to_end(&mut raw)?;
ensure!(
raw.len() <= 65536 && hash(&raw) == expected,
"QUIESCENT_PUBLIC_HASH"
);
file.check()?;
Ok((file, raw))
}
fn hold_agent(path: &Path) -> Result<File> {
native::private_path(path, false)?;
Ok(OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(path)?)
}
fn check_id(file: &File, path: &Path) -> Result<()> {
let actual = hold_agent(path)?;
ensure!(
ipc::file_identity(file)? == ipc::file_identity(&actual)?,
"QUIESCENT_DATABASE_REPLACED"
);
Ok(())
}
fn receipt(dir: &Path, name: &str, value: &serde_json::Value) -> Result<()> {
let bytes = serde_json::to_vec(value)?;
ensure!(bytes.len() <= 16384, "QUIESCENT_RECEIPT_LIMIT");
let path = dir.join(name);
let mut f = OpenOptions::new()
.write(true)
.create_new(true)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH)
.open(&path)?;
f.write_all(&bytes)?;
f.sync_all()?;
drop(f);
let mut read = PinnedFile::open(&path, false, &[], &[], false)?;
ensure!(read.sha256()? == hash(&bytes), "QUIESCENT_RECEIPT_READBACK");
Ok(())
}
struct Idle {
decision: Uuid,
checkpoint: u64,
helper_checkpoint: u64,
request_sha256: String,
response_sha256: String,
original_echo_job: Uuid,
pending_request:Option<String>,
pending_request_sha256:Option<String>,
}
fn idle(
db: &Connection,
consumption: &Connection,
helper: &Connection,
intents: &Connection,
binding: &Binding,
) -> Result<Idle> {
let (journal,checkpoint,generation,last,pending,helper_id,helper_cp,fault):(String,u64,u64,String,Option<String>,String,u64,Option<String>)=db.query_row("SELECT journal_id,checkpoint,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?,r.get(7)?)))?;
ensure!(fault.is_none(),"QUIESCENT_AGENT_FAULT");
let (helper_journal, helper_last, helper_fault,helper_agent_cp): (String, String, Option<String>,u64) = helper
.query_row(
"SELECT journal_id,last_decision,fault,agent_checkpoint FROM helper_sync_meta WHERE id=1",
[],
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?,r.get(3)?)),
)?;
ensure!(
helper_fault.is_none() && helper_last == last && helper_journal == helper_id,
"QUIESCENT_HELPER_HEAD_DIFFERS"
);
let (raw_response, raw_request, applied_cp): (Vec<u8>, Vec<u8>, u64) = helper.query_row(
"SELECT response,request,checkpoint FROM helper_sync_decisions WHERE decision_id=?1",
[&last],
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
)?;
ensure!(
applied_cp == helper_cp,
"QUIESCENT_HELPER_APPLIED_CHECKPOINT"
);
let signed: SignedResponse = serde_json::from_slice(&raw_response)?;
let parsed: ReconcileDecisionPayload = serde_json::from_slice(&signed.decision_bytes)?;
let (agent_request, agent_response): (Vec<u8>, Vec<u8>) = db.query_row(
"SELECT request,response FROM reconcile_requests WHERE id=?1",
[parsed.request_id.to_string()],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
let response = SyncResponse::decode(agent_response.as_slice())?;
let request = SyncRequest::decode(agent_request.as_slice())?;
ensure!(
raw_request == agent_request
&& signed.decision_bytes == response.decision_bytes
&& signed.signature == response.signature,
"QUIESCENT_RAW_SIGNED_CONTROL_DIFFERS"
);
let verified = verify_response_with(
&DalekVerifier,
binding,
&request,
&Channel {
connection_generation: parsed.connection_generation,
boot_id: parsed.boot_id,
},
&response,
parsed.issued_at,
)?;
ensure!(
verified.decision_id.to_string() == last
&& verified.journal_id.to_string() == journal
&& verified.checkpoint == helper_agent_cp
&& verified.checkpoint<=checkpoint
&& verified.connection_generation<=generation
&& verified.helper_journal_id.map(|id| id.to_string()) == Some(helper_id.clone())
&& verified.helper_checkpoint == helper_cp
&& verified.ready
&& verified.helper_ready
&& verified.reason == "CONSISTENT",
"QUIESCENT_SIGNED_HEAD_BINDING"
);
let pending_request=if let Some(id)=pending.as_ref() {
let (request_raw,envelope_raw,row_generation,response):(Vec<u8>,Vec<u8>,u64,Option<Vec<u8>>)=db.query_row("SELECT request,envelope,generation,response FROM reconcile_requests WHERE id=?1",[id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?)))?;
ensure!(response.is_none() && request_raw.len()<=rmm_domain::MAX_MESSAGE && envelope_raw.len()<=rmm_domain::MAX_MESSAGE,"QUIESCENT_ONLY_UNRESPONDED_CONTROL");
let request=SyncRequest::decode(request_raw.as_slice())?;
let envelope=Envelope::decode(envelope_raw.as_slice())?;
ensure!(request.encode_to_vec()==request_raw && envelope.encode_to_vec()==envelope_raw
&& request.request_id==*id && request.journal_id==journal && request.checkpoint==checkpoint
&& request.previous_decision_id==last && request.helper_previous_decision_id==last
&& request.helper_journal_id==helper_id && request.helper_checkpoint>=helper_cp
&& request.assignment_version==binding.assignment_version && request.journal_complete
&& request.durable_message_ids.is_empty() && request.attempts.len()==2
&& row_generation==generation && envelope.connection_generation==generation
&& envelope.agent_id==binding.agent_id.to_string() && envelope.enrollment_generation==binding.enrollment_generation
&& envelope.boot_id==verified.boot_id.to_string() && envelope.sequence==checkpoint
&& rmm_protocol::valid_envelope(&envelope,&binding.agent_id.to_string(),generation)
&& matches!(envelope.payload,Some(Payload::SyncRequest(ref body)) if body==&request),"QUIESCENT_PENDING_CONTROL_BINDING");
Some(request)
}else {
ensure!(verified.checkpoint==checkpoint && verified.connection_generation==generation,"QUIESCENT_WITHOUT_PENDING_EXACT_HEAD");
None
};
let busy:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))",[],|r|r.get(0))?;
ensure!(!busy, "QUIESCENT_EFFECT_PENDING");
let (scope, original) = rmm_agent_windows::echo_probe::archive(db, binding)?
.context("QUIESCENT_ECHO_ARCHIVE_MISSING")?;
ensure!(
rmm_agent_windows::echo_completion::installed(db, binding, &scope, &original)?,
"QUIESCENT_ECHO_COMPLETION_MISSING"
);
let (total,echo,pending_new):(u64,u64,u64)=db.query_row("SELECT count(*),sum(job=?1 AND attempt=?2 AND state='succeeded'),sum(job=?3 AND attempt=?4 AND state IN ('accepted','expired') AND grant_id='') FROM job_attempts",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string(),JOB,ATTEMPT],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
ensure!(
total == 2 && echo == 1 && pending_new == 1,
"QUIESCENT_EXPECTED_TWO_JOB_HISTORY"
);
if let Some(request)=&pending_request {
let echo=request.attempts.iter().filter(|r|r.job_id==scope.job_id.to_string() && r.attempt_id==scope.attempt_id.to_string()).collect::<Vec<_>>();
let new=request.attempts.iter().filter(|r|r.job_id==JOB && r.attempt_id==ATTEMPT).collect::<Vec<_>>();
ensure!(echo.len()==1 && new.len()==1,"QUIESCENT_PENDING_EXPECTED_ATTEMPTS");
let old=echo[0];let new=new[0];
let old_grant:String=db.query_row("SELECT grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|r.get(0))?;
ensure!(old.state=="succeeded" && old.consumption=="consumed" && old.grant_id==old_grant
&& !old.grant_id.is_empty() && old.job_payload_hash==scope.job_payload_hash && old.update_handoff_bytes.is_empty()
&& matches!(new.state.as_str(),"accepted"|"expired") && new.consumption=="unconsumed" && new.grant_id.is_empty()
&& new.update_handoff_bytes.is_empty(),"QUIESCENT_PENDING_NO_NEW_EFFECT");
}
let (total, new): (u64, u64) = consumption.query_row(
"SELECT count(*),COALESCE(sum(job=?1 OR attempt=?2),0) FROM consumed",
[JOB, ATTEMPT],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
ensure!(total == 1 && new == 0, "QUIESCENT_CONSUMPTION_CHANGED");
let (start,outcome,finished):(Vec<u8>,Vec<u8>,Vec<u8>)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.job=?1 AND c.attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
let start: serde_json::Value = serde_json::from_slice(&start)?;
let request: Request = serde_json::from_value(start["request"].clone())?;
let at = serde_json::from_value(start["reserved_at"].clone())?;
let (job, _) = binding.verify_with(&request, at, &DalekVerifier)?;
let o: Outcome = serde_json::from_slice(&outcome)?;
ensure!(
scope.matches_job(&job)
&& o.state == "succeeded"
&& o.evidence["postconditions_passed"] == true
&& outcome == finished,
"QUIESCENT_ORIGINAL_ECHO_EVIDENCE"
);
ensure!(
helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, u64>(0))? == 0
&& intents.query_row("SELECT count(*) FROM system_intents", [], |r| r
.get::<_, u64>(0))?
== 0,
"QUIESCENT_HELPER_WORK_PRESENT"
);
Ok(Idle {
decision: verified.decision_id,
checkpoint,
helper_checkpoint: helper_cp,
request_sha256: hash(&raw_request),
response_sha256: hash(&raw_response),
original_echo_job: scope.job_id,
pending_request:pending,
pending_request_sha256:pending_request.as_ref().map(|r|hash(&r.encode_to_vec())),
})
}
fn safe_error(error:&anyhow::Error)->serde_json::Value {
for cause in error.chain() {
let text=cause.to_string();
if text.starts_with("QUIESCENT_") && text.bytes().all(|b|b.is_ascii_uppercase()||b==b'_') {return json!({"code":text});}
if let Some(sql)=cause.downcast_ref::<rusqlite::Error>() {
return match sql {
rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),
rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),
rusqlite::Error::InvalidColumnIndex(index)=>json!({"code":"SQLITE_COLUMN_INDEX","index":index}),
rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),
_=>json!({"code":"SQLITE_READ_FAILED"}),
};
}
}
json!({"code":"SIGNED_OR_ARCHIVED_EVIDENCE_CHECK_FAILED"})
}
fn safe_metadata(db:&Connection,consumed:&Connection,helper:&Connection,intents:&Connection)->Result<serde_json::Value> {
let agent=db.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault IS NOT NULL FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({
"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault_present":r.get::<_,bool>(5)?})))?;
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,fault IS NOT NULL,agent_checkpoint FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({
"current_capture_checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"fault_present":r.get::<_,bool>(3)?,"agent_checkpoint":r.get::<_,u64>(4)?})))?;
let mut q=db.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
let jobs=q.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
let counts=json!({"events":db.query_row("SELECT count(*) FROM events",[],|r|r.get::<_,u64>(0))?,"job_events":db.query_row("SELECT count(*) FROM job_events",[],|r|r.get::<_,u64>(0))?,
"agent_consumed":consumed.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"agent_execution_evidence":consumed.query_row("SELECT count(*) FROM execution_evidence",[],|r|r.get::<_,u64>(0))?,
"helper_consumed":helper.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"helper_intents":intents.query_row("SELECT count(*) FROM system_intents",[],|r|r.get::<_,u64>(0))?});
Ok(json!({"agent":agent,"helper":helper_meta,"jobs":jobs,"counts":counts}))
}
pub fn run() -> Result<()> {
let args=std::env::args().skip(1).collect::<Vec<_>>();
let read_only=args==["--read-idle-check"];
ensure!(read_only || args==["--stop-known-idle-agent"],"QUIESCENT_ARGUMENTS");
admin()?;
let bootstrap = PinnedFile::open(
Path::new(r"C:\ProgramData\RustDiscoveryBootstrap"),
true,
&[],
&[],
false,
)?;
let dir = bootstrap.path.join(format!("quiescent-stop-{CASE}"));
let mut dir_guard=if read_only {None}else{
std::fs::create_dir(&dir)?;
Some(PinnedFile::open(&dir,true,&[],&[],false)?)
};
let readers = [
ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let (mut pin_guard, raw) = protected(
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"),
&readers,
PIN,
)?;
let pin: ipc::Pin = serde_json::from_slice(&raw)?;
pin.validate()?;
ensure!(
pin.agent.binary_sha256 == AGENT && pin.helper.binary_sha256 == HELPER,
"QUIESCENT_EXACT_PAIR"
);
let (mut settings_guard, _) = protected(
Path::new(r"C:\ProgramData\RustDiscoverySystem\helper.json"),
&readers,
SETTINGS,
)?;
let (mut config_guard, raw) = protected(
Path::new(r"C:\ProgramData\RustDiscovery\config.json"),
&[readers[0].clone()],
CONFIG,
)?;
let cfg: serde_json::Value = serde_json::from_slice(&raw)?;
ensure!(
cfg["enable_jobs"] == true
&& cfg.get("windows_echo_probe_only").is_none_or(|v|v==false)
&& cfg["state_directory"] == AGENT_STATE,
"QUIESCENT_EXACT_CONFIGURATION"
);
let agent_service = service(!read_only)?;
let before = status(&agent_service)?;
ensure!(
before.dwCurrentState == SERVICE_RUNNING,
"QUIESCENT_AGENT_NOT_RUNNING"
);
let mut peer = PeerProof::for_service(&pin.agent, before.dwProcessId)?;
let helper_manager=Handle(unsafe{OpenSCManagerW(ptr::null(),ptr::null(),SC_MANAGER_CONNECT)});
ensure!(!helper_manager.0.is_null(),"QUIESCENT_HELPER_SCM_MANAGER");
let helper_service=Handle(unsafe{OpenServiceW(helper_manager.0,ipc::wide(ipc::HELPER_SERVICE).as_ptr(),SERVICE_QUERY_STATUS|SERVICE_QUERY_CONFIG)});
ensure!(!helper_service.0.is_null(),"QUIESCENT_HELPER_SCM");
let helper_before=status(&helper_service)?;
ensure!(helper_before.dwCurrentState==SERVICE_RUNNING,"QUIESCENT_HELPER_NOT_RUNNING");
let mut helper_peer=PeerProof::for_service(&pin.helper,helper_before.dwProcessId)?;
// Keep original journal/sidecar names and ledger against replacement.
let journal_path = Path::new(AGENT_STATE).join("telemetry.sqlite");
let journal_file = hold_agent(&journal_path)?;
let _wal = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-wal"))?;
let _shm = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-shm"))?;
let consumption_path = Path::new(AGENT_STATE).join("consumption.sqlite");
let consumption_file = hold_agent(&consumption_path)?;
let helper_writer = ipc::service_sid(ipc::HELPER_SERVICE)?;
let mut helper_file = PinnedFile::open_read_shared(
&Path::new(HELPER_STATE).join("ledger.sqlite"),
false,
&[],
std::slice::from_ref(&helper_writer),
)?;
let mut intent_file = PinnedFile::open_read_shared(
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"),
false,
&[],
&[readers[0].clone()],
)?;
let db = Connection::open_with_flags(&journal_path, if read_only {OpenFlags::SQLITE_OPEN_READ_ONLY}else{OpenFlags::SQLITE_OPEN_READ_WRITE})?;
db.busy_timeout(Duration::from_millis(20))?;
let consumed =
Connection::open_with_flags(&consumption_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
let helper =
Connection::open_with_flags(&helper_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
let intents =
Connection::open_with_flags(&intent_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
if read_only {
let mut observations=Vec::new();
for _ in 0..10 {
db.execute_batch("BEGIN")?;helper.execute_batch("BEGIN")?;
let checked=idle(&db,&consumed,&helper,&intents,&pin.binding);
let metadata=safe_metadata(&db,&consumed,&helper,&intents)?;
let error=checked.as_ref().err().map(safe_error);
helper.execute_batch("ROLLBACK")?;db.execute_batch("ROLLBACK")?;
observations.push(json!({"observed_at":chrono::Utc::now(),"idle_check_passed":checked.is_ok(),"error":error,"metadata":metadata}));
std::thread::sleep(Duration::from_millis(100));
}
peer.check()?;helper_peer.check()?;
println!("{}",serde_json::to_string(&json!({"schema_version":1,"mode":"read_idle_check","read_only":true,"quiescence_reservation_held":false,"stop_requested":false,"case_created":false,"sql_data_changed":false,"samples":observations}))?);
return Ok(());
}
let until = Instant::now() + Duration::from_secs(30);
let locked = loop {
if Instant::now() >= until {
anyhow::bail!("QUIESCENT_HEAD_NOT_OBSERVED_NO_STOP");
}
if db.execute_batch("BEGIN IMMEDIATE").is_err() {
std::thread::sleep(Duration::from_millis(25));
continue;
}
helper.execute_batch("BEGIN")?;
let value = idle(&db, &consumed, &helper, &intents, &pin.binding);
helper.execute_batch("ROLLBACK")?;
match value {
Ok(value) => break value,
Err(_) => {
db.execute_batch("ROLLBACK")?;
std::thread::sleep(Duration::from_millis(25));
}
}
};
// All final observations occur while new agent writes remain excluded.
peer.check()?;
helper_peer.check()?;
pin_guard.check()?;
settings_guard.check()?;
config_guard.check()?;
dir_guard.as_mut().context("QUIESCENT_CASE_GUARD")?.check()?;
check_id(&journal_file, &journal_path)?;
check_id(&consumption_file, &consumption_path)?;
helper_file.check()?;
intent_file.check()?;
let current = status(&agent_service)?;
ensure!(
current.dwCurrentState == SERVICE_RUNNING && current.dwProcessId == before.dwProcessId,
"QUIESCENT_ORIGINAL_PROCESS_CHANGED"
);
receipt(
&dir,
"stop-intent.json",
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"agent_sha256":AGENT,"helper_sha256":HELPER,"pin_sha256":PIN,"config_sha256":CONFIG,
"agent_pid":before.dwProcessId,"journal_file_id":ipc::file_identity(&journal_file)?,"consumption_file_id":ipc::file_identity(&consumption_file)?,"helper_ledger_file_id":helper_file.identity,"decision_id":locked.decision,
"checkpoint":locked.checkpoint,"helper_applied_checkpoint":locked.helper_checkpoint,"signed_request_sha256":locked.request_sha256,"signed_helper_response_sha256":locked.response_sha256,"original_echo_job":locked.original_echo_job,
"pending_job":JOB,"pending_control_request":locked.pending_request,"pending_control_request_sha256":locked.pending_request_sha256,"new_grants":0,"helper_consumptions":0,"helper_intents":0,"sql_data_changed":false,"agent_journal_immediate_reservation_held":true,"stop_service_only":rmm_agent_windows::SERVICE_NAME,"force_kill":false}),
)?;
let mut returned: SERVICE_STATUS = unsafe { zeroed() };
let stop_ok =
unsafe { ControlService(agent_service.0, SERVICE_CONTROL_STOP, &mut returned) } != 0;
let error = if stop_ok {
None
} else {
Some(unsafe { GetLastError() })
};
let wait = Instant::now() + Duration::from_secs(125);
let mut final_status = status(&agent_service)?;
while stop_ok && final_status.dwCurrentState != SERVICE_STOPPED && Instant::now() < wait {
std::thread::sleep(Duration::from_millis(50));
final_status = status(&agent_service)?;
}
let stopped = stop_ok && final_status.dwCurrentState == SERVICE_STOPPED;
helper_peer.check()?;
// Still held through the confirmed stop (or bounded honest failure).
check_id(&journal_file, &journal_path)?;
check_id(&consumption_file, &consumption_path)?;
receipt(
&dir,
"stop-result.json",
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"normal_stop_requested_once":stop_ok,"native_error":error,"stopped":stopped,"state":final_status.dwCurrentState,"pid":final_status.dwProcessId,
"sql_data_changed":false,"job_executed":false,"helper_stopped":false,"reset":false,"force_kill":false,"reservation_held_until_observation":true}),
)?;
db.execute_batch("ROLLBACK")?;
ensure!(stopped, "QUIESCENT_STOP_UNCONFIRMED_NO_FORCE");
println!("{{\"case_id\":\"{CASE}\",\"stopped\":true,\"sql_data_changed\":false}}");
Ok(())
}
}
#[cfg(all(windows, feature = "system-helper"))]
fn main() {
if let Err(error) = platform::run() {
eprintln!("{}", error);
std::process::exit(1);
}
}
#[cfg(not(all(windows, feature = "system-helper")))]
fn main() {
eprintln!("Windows SYSTEM-helper SDK bootstrap only");
std::process::exit(1);
}
@@ -0,0 +1,47 @@
//! Administrator bootstrap metadata READ ONLY. Never stops a service, opens a
//! writable SQLite connection, repairs history, reads keys, or executes jobs.
#[cfg(windows)]
mod native {
use anyhow::{Result,ensure};
use prost::Message;
use rusqlite::{Connection,OpenFlags};
use serde_json::{Value,json};
use std::{path::Path,time::Duration};
use windows_sys::Win32::{Foundation::CloseHandle,Security::{GetTokenInformation,TOKEN_ELEVATION,TOKEN_QUERY,TokenElevation},System::Threading::{GetCurrentProcess,OpenProcessToken}};
fn db(path:&str)->Result<Connection>{ensure!(Path::new(path).is_file(),"SYNC_DIAGNOSTIC_FILE_MISSING");let db=Connection::open_with_flags(path,OpenFlags::SQLITE_OPEN_READ_ONLY|OpenFlags::SQLITE_OPEN_NO_MUTEX)?;db.busy_timeout(Duration::from_millis(500))?;Ok(db)}
fn requests(db:&Connection)->Result<Value>{
let mut stmt=db.prepare("SELECT id,generation,length(request),response IS NOT NULL,request FROM reconcile_requests ORDER BY rowid DESC LIMIT 2")?;
let rows=stmt.query_map([],|r|Ok((r.get::<_,String>(0)?,r.get::<_,u64>(1)?,r.get::<_,u64>(2)?,r.get::<_,bool>(3)?,r.get::<_,Vec<u8>>(4)?)))?.collect::<rusqlite::Result<Vec<_>>>()?;
Ok(json!(rows.into_iter().map(|(id,generation,bytes,response,raw)|{
let decoded=rmm_protocol::SyncRequest::decode(raw.as_slice()).ok();
json!({"request_id":id,"generation":generation,"request_bytes":bytes,"response_present":response,"decoded":decoded.map(|r|json!({"request_id":r.request_id,"checkpoint":r.checkpoint,"previous_decision_id":r.previous_decision_id,"helper_checkpoint":r.helper_checkpoint}))})
}).collect::<Vec<_>>()))
}
fn sample()->Result<Value>{
let agent=db(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite")?;
let helper=db(r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite")?;
let meta=agent.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault":r.get::<_,Option<String>>(5)?})))?;
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,agent_checkpoint,fault FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"agent_checkpoint":r.get::<_,u64>(3)?,"fault":r.get::<_,Option<String>>(4)?})))?;
let mut stmt=helper.prepare("SELECT decision_id,checkpoint,length(response),length(request) FROM helper_sync_decisions ORDER BY rowid DESC LIMIT 2")?;
let decisions=stmt.query_map([],|r|Ok(json!({"decision_id":r.get::<_,String>(0)?,"checkpoint":r.get::<_,u64>(1)?,"response_bytes":r.get::<_,u64>(2)?,"request_bytes":r.get::<_,u64>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
let mut stmt=agent.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
let jobs=stmt.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
Ok(json!({"agent":meta,"requests":requests(&agent)?,"helper":helper_meta,"helper_decisions":decisions,"jobs":jobs}))
}
fn error(e:&anyhow::Error)->Value {
for cause in e.chain(){if let Some(sql)=cause.downcast_ref::<rusqlite::Error>(){return match sql {rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),_=>json!({"code":"SQLITE_READ_FAILED"})};}}
json!({"code":"READ_DIAGNOSTIC_FAILED"})
}
pub fn run()->Result<()> {
ensure!(std::env::args().count()==1,"SYNC_DIAGNOSTIC_NO_ARGUMENTS");
let mut token=std::ptr::null_mut();ensure!(unsafe{OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&mut token)}!=0,"SYNC_DIAGNOSTIC_TOKEN");
let mut elevation=TOKEN_ELEVATION{TokenIsElevated:0};let mut size=0;
let okay=unsafe{GetTokenInformation(token,TokenElevation,&mut elevation as *mut _ as *mut _,std::mem::size_of::<TOKEN_ELEVATION>() as u32,&mut size)};unsafe{CloseHandle(token)};
ensure!(okay!=0&&elevation.TokenIsElevated!=0,"SYNC_DIAGNOSTIC_ADMIN");
let mut samples=vec![];
for _ in 0..3 {samples.push(sample().unwrap_or_else(|e|json!({"error":error(&e)})));std::thread::sleep(Duration::from_millis(100));}
println!("{}",serde_json::to_string(&json!({"schema_version":1,"read_only":true,"utc":chrono::Utc::now(),"samples":samples}))?);Ok(())
}
}
#[cfg(windows)]fn main(){if native::run().is_err(){eprintln!("SYNC_DIAGNOSTIC_FAILED");std::process::exit(1);}}
#[cfg(not(windows))]fn main(){eprintln!("Windows only");std::process::exit(1);}
@@ -0,0 +1,245 @@
//! Administrative typed metadata only; no writes, effects, jobs, or readiness.
#[cfg(all(windows, feature = "system-helper"))]
mod sdk {
use anyhow::{Result, ensure};
use rmm_agent_windows::{helper_ipc as ipc, helper_system, signed_clock, update_state};
use rmm_domain::{
agent_update::{ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile},
agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy},
jobs::hash,
};
use serde::Deserialize;
use std::io::Read;
#[derive(Deserialize)]
#[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)]
enum Input {
ReadMetadata {
updater_sha256: Option<String>,
},
RenderPair {
settings: Vec<u8>,
agent_sha256: String,
helper_sha256: String,
},
RenderUpdaterClock {
pair_profile: Vec<u8>,
updater_sha256: String,
policy_sha256: String,
service_configuration_sha256: String,
qualification_sha256: String,
},
CanonicalRelease {
manifest: ReleaseManifest,
},
CanonicalRecord {
record: InstalledReleaseRecord,
},
CanonicalPolicy {
policy: Box<LocalUpdatePolicy>,
},
ValidatePublicBundle {
record: Vec<u8>,
policy: Vec<u8>,
keyring: Vec<u8>,
health_pin: Vec<u8>,
},
ValidateRelease {
envelope: ReleaseEnvelope,
},
}
fn bytes(raw: Vec<u8>) -> serde_json::Value {
serde_json::json!({"sha256":hash(&raw),"bytes":raw})
}
fn read_metadata(updater_sha256: Option<String>) -> Result<serde_json::Value> {
use rmm_agent_core::helper_reconcile::BootSource;
use rmm_agent_windows::update_native::{Budget, Role, files, services};
let boot = helper_system::WindowsBoot::capture()?;
let budget = Budget::new(
&boot,
boot.current_boot()?,
std::time::Duration::from_secs(30),
)?;
let (settings, _held) = helper_system::read_settings()?;
let mut running =
services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?;
let retained = update_state::RetainedSet::bootstrap_metadata()?;
let mut observed = Vec::new();
for role in [
Role::Agent,
Role::Helper,
Role::Settings,
Role::Pin,
Role::TimeProfile,
] {
observed.push(serde_json::json!({"role":role,"proof":files::observe(role,&budget)?}));
}
let updater = if let Some(sha) = updater_sha256 {
ensure!(ipc::digest(&sha), "BOOTSTRAP_UPDATER_IMAGE");
let pin = ipc::PeerPin {
service_name: rmm_agent_windows::update_ipc::SERVICE.into(),
service_sid: ipc::service_sid(rmm_agent_windows::update_ipc::SERVICE)?,
user_sid: "S-1-5-18".into(),
binary: rmm_agent_windows::update_ipc::BINARY.into(),
binary_sha256: sha,
};
let readers = [pin.service_sid.clone()];
let mut image = ipc::PinnedFile::open(&pin.binary, false, &readers, &[], false)?;
ensure!(
image.sha256()? == pin.binary_sha256,
"BOOTSTRAP_REGISTERED_UPDATER_IMAGE"
);
let definition = services::updater_bootstrap_definition(&pin)?;
image.check()?;
Some(
serde_json::json!({"pin":pin,"configuration_sha256":hash(&serde_json::to_vec(&definition)?),"configuration":definition,"running_not_qualified":true}),
)
} else {
None
};
running.check(&budget)?;
Ok(
serde_json::json!({"schema_version":1,"read_only":true,"boot_id":boot.current_boot()?,
"binding":settings.binding,"services":running.proofs(),"files":observed,"retained":retained,
"reader_contract_sha256":hash(update_state::READER_CONTRACT),"updater":updater,
"readiness_created":false,"target_mutated":false,"qualification_created":false}),
)
}
fn run(input: Input) -> Result<serde_json::Value> {
Ok(match input {
Input::ReadMetadata { updater_sha256 } => read_metadata(updater_sha256)?,
Input::RenderPair {
settings,
agent_sha256,
helper_sha256,
} => {
ensure!(
ipc::digest(&agent_sha256) && ipc::digest(&helper_sha256),
"BOOTSTRAP_PAIR_DIGESTS"
);
let mut s: helper_system::Settings = serde_json::from_slice(&settings)?;
s.validate()?;
s.agent.binary_sha256 = agent_sha256;
s.helper.binary_sha256 = helper_sha256;
s.validate()?;
let raw = serde_json::to_vec(&s)?;
let pin = s.pin()?;
ensure!(pin.policy_sha256 == hash(&raw), "BOOTSTRAP_CANONICAL_PAIR");
serde_json::json!({"settings":bytes(raw),"pin":bytes(serde_json::to_vec(&pin)?),"shape_only":true})
}
Input::RenderUpdaterClock {
pair_profile,
updater_sha256,
policy_sha256,
service_configuration_sha256,
qualification_sha256,
} => {
ensure!(
[
&updater_sha256,
&policy_sha256,
&service_configuration_sha256,
&qualification_sha256
]
.iter()
.all(|s| ipc::digest(s)),
"BOOTSTRAP_UPDATER_CLOCK_DIGESTS"
);
let profile: signed_clock::Configuration = serde_json::from_slice(&pair_profile)?;
let signed_clock::Configuration::TrustedOs(p) = profile else {
anyhow::bail!("BOOTSTRAP_EXPLICIT_ACTIVE_GUEST_PROFILE_REQUIRED")
};
ensure!(
p.schema_version == 2
&& p.trusted_os_active_guest.qualifications.len() == 2
&& p.trusted_os_active_guest.qualifications[0].role
== rmm_time_attestation::Role::Agent
&& p.trusted_os_active_guest.qualifications[1].role
== rmm_time_attestation::Role::SystemHelper,
"BOOTSTRAP_ORIGINAL_PAIR_PROFILE"
);
let mut guest = p.trusted_os_active_guest;
guest.qualifications = vec![signed_clock::RoleQualification {
role: rmm_time_attestation::Role::Updater,
binary_sha256: updater_sha256,
qualification_sha256,
}];
let new = signed_clock::UpdaterConfiguration {
schema_version: 3,
key_generation: p.key_generation,
server_instance: p.server_instance,
binding: p.binding,
public_keys_hex: p.public_keys_hex,
updater_policy_sha256: policy_sha256,
updater_service_configuration_sha256: service_configuration_sha256,
trusted_os_active_guest: guest,
};
serde_json::json!({"profile":bytes(serde_json::to_vec(&new)?),"shape_only":true,"qualification_created":false})
}
Input::CanonicalRelease { manifest } => {
ensure!(manifest.validate(), "BOOTSTRAP_RELEASE_SHAPE");
bytes(serde_json::to_vec(&manifest)?)
}
Input::CanonicalRecord { record } => bytes(record.bytes().map_err(anyhow::Error::msg)?),
Input::CanonicalPolicy { policy } => {
ensure!(
policy.validate() && policy.schema_version == 2,
"BOOTSTRAP_WINDOWS_POLICY_SHAPE"
);
bytes(serde_json::to_vec(&policy)?)
}
Input::ValidateRelease { envelope } => {
let decoded = envelope.decode().map_err(anyhow::Error::msg)?;
serde_json::json!({"manifest":decoded.manifest,"manifest_sha256":hash(&decoded.payload_bytes),"shape_only_not_signature_verified":true})
}
Input::ValidatePublicBundle {
record,
policy,
keyring,
health_pin,
} => {
let installed =
InstalledReleaseRecord::from_bytes(&record).map_err(anyhow::Error::msg)?;
let (policy, policy_sha256) =
LocalUpdatePolicy::from_bytes(&policy).map_err(anyhow::Error::msg)?;
let keys: UpdateKeyringFile = serde_json::from_slice(&keyring)?;
let health: HealthKeyPin = serde_json::from_slice(&health_pin)?;
ensure!(
keys.validate()
&& health.validate()
&& policy.schema_version == 2
&& policy.initial_record_sha256 == hash(&record)
&& policy.initial_activation_floor == installed.activation_floor,
"BOOTSTRAP_WINDOWS_PUBLIC_BUNDLE_SHAPE"
);
serde_json::json!({"record_sha256":hash(&record),"policy_sha256":policy_sha256,"keyring_sha256":hash(&keyring),"health_pin_sha256":hash(&health_pin),"shape_only_not_signature_verified":true})
}
})
}
pub fn main() -> Result<()> {
let mut raw = Vec::new();
std::io::stdin()
.take(512 * 1024 + 1)
.read_to_end(&mut raw)?;
ensure!(
!raw.is_empty() && raw.len() <= 512 * 1024,
"BOOTSTRAP_METADATA_FRAME_LIMIT"
);
println!(
"{}",
serde_json::to_string(&run(serde_json::from_slice(&raw)?)?)?
);
Ok(())
}
}
#[cfg(all(windows, feature = "system-helper"))]
fn main() {
if sdk::main().is_err() {
eprintln!("WINDOWS_BOOTSTRAP_METADATA_FAILED");
std::process::exit(1)
}
}
#[cfg(not(all(windows, feature = "system-helper")))]
fn main() {
eprintln!("Windows/system-helper required; no operation executed");
std::process::exit(2)
}