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
Generated
+1
View File
@@ -2458,6 +2458,7 @@ dependencies = [
"anyhow",
"ed25519-dalek",
"hex",
"rmm-domain",
"serde",
"serde_json",
"sha2 0.10.9",
+5
View File
@@ -13,6 +13,11 @@ name = "rmm-helper-windows"
path = "src/bin/rmm-helper-windows.rs"
required-features = ["system-helper"]
[[bin]]
name = "rmm-updater-windows"
path = "src/bin/rmm-updater-windows.rs"
required-features = ["system-helper"]
[dependencies]
anyhow.workspace = true
base64 = "=0.22.1"
@@ -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)
}
@@ -0,0 +1,25 @@
//! Stable updater is installed separately from the two mutable code roles.
#[cfg(windows)]
fn main() -> anyhow::Result<()> {
let mut args = std::env::args_os().skip(1);
match args.next().as_deref() {
None => rmm_agent_windows::update_worker::dispatch(),
Some(flag) if flag == "--release-service" && args.next().is_none() => {
rmm_agent_windows::release_service::dispatch()
}
Some(flag) if flag == "--verify-bootstrap" => {
let release = rmm_updater::verify_bootstrap_files(
rmm_agent_windows::release_platform::VERIFY,
&args.collect::<Vec<_>>(),
)?;
println!("{}", serde_json::to_string(release.manifest())?);
Ok(())
}
_ => anyhow::bail!("unrecognized Windows updater arguments"),
}
}
#[cfg(not(windows))]
fn main() {
eprintln!("Windows stable updater requires a Windows target");
std::process::exit(1);
}
@@ -1,6 +1,7 @@
//! Passive TLS renewal. SQLite commits only public CSR/certificate/version data;
//! private keys stay in immutable, protected files outside the telemetry WAL.
//! The caller must retain the existing exclusive agent-state journal lock.
//! Mutation/current callers retain the exclusive agent-state journal lock.
//! `read_only_current` is the bounded, snapshot-only stable-updater exception.
use anyhow::{Context, Result, ensure};
use rcgen::{CertificateParams, DnType, KeyPair};
use rusqlite::{Connection, OptionalExtension, params};
@@ -119,6 +120,48 @@ impl RotationStore {
private_key_pem: key,
})
}
/// Independent stable-updater mTLS read ONLY. This cannot initialize,
/// rotate, acknowledge, alter selectors, enroll or allocate a generation.
/// Concurrent rotation may make transport fail; it never selects a key
/// from another device or treats old TLS as an execution/sync lease.
pub fn read_only_current(
&self,
db: &Connection,
keys: &impl KeyFiles,
now: i64,
) -> Result<DeviceIdentity> {
ensure!(
unsafe { rusqlite::ffi::sqlite3_db_readonly(db.handle(), c"main".as_ptr()) } == 1
&& db.query_row("PRAGMA query_only", [], |r| r.get::<_, bool>(0))?
&& !db.query_row("PRAGMA trusted_schema", [], |r| r.get::<_, bool>(0))?,
"ROTATION_READ_ONLY_CONNECTION_REQUIRED"
);
let tx = db.unchecked_transaction()?;
for table in ["tls_rotation", "tls_versions"] {
ensure!(
tx.query_row(
"SELECT type FROM sqlite_master WHERE name=?1",
[table],
|r| r.get::<_, String>(0)
)? == "table",
"ROTATION_SELECTOR_MUST_BE_TABLE"
);
}
let (version, _) = self.selector(&tx)?;
let length: u64 = tx.query_row(
"SELECT length(certificate) FROM tls_versions WHERE version=?1",
[version.to_string()],
|r| r.get(0),
)?;
ensure!(length > 0 && length <= 32768, "ROTATION_CERTIFICATE_LIMIT");
let identity = self.current(&tx, keys, now)?;
ensure!(
self.selector(&tx)?.0 == version,
"ROTATION_READ_ONLY_SNAPSHOT_CHANGED"
);
tx.commit()?;
Ok(identity)
}
fn verify(&self, pem: &[u8], key: &[u8], now: i64) -> Result<(i64, i64)> {
ensure!(
pem.len() <= 32768 && key.len() <= 16384,
@@ -590,6 +633,29 @@ mod tests {
.unwrap()
}
#[test]
fn updater_tls_snapshot_requires_read_only_handle_and_preserves_selector() {
let (db, keys, store, _, cert) = setup();
db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON")
.unwrap();
assert!(store.read_only_current(&db, &keys, now()).is_err());
db.execute_batch("PRAGMA query_only=OFF").unwrap();
let path = std::env::temp_dir().join(format!("rmm-tls-read-{}.sqlite", Uuid::new_v4()));
db.execute("VACUUM INTO ?1", [path.to_str().unwrap()])
.unwrap();
let read =
Connection::open_with_flags(&path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap();
assert!(store.read_only_current(&read, &keys, now()).is_err());
read.execute_batch("PRAGMA query_only=ON;PRAGMA trusted_schema=OFF")
.unwrap();
let before = store.selector(&read).unwrap();
let identity = store.read_only_current(&read, &keys, now()).unwrap();
assert_eq!(identity.certificate_pem, cert.as_bytes());
assert_eq!(identity.private_key_pem, keys.read(Uuid::nil()).unwrap());
assert_eq!(store.selector(&read).unwrap(), before);
drop(read);
std::fs::remove_file(path).unwrap();
}
#[test]
fn active_idle_admission_is_atomic_retained_and_cannot_adopt_legacy_pending() {
let (mut db, keys, store, _, _) = setup();
let witness = b"exact independently checked idle context";
+37 -22
View File
@@ -36,8 +36,8 @@ pub const PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-v2";
pub const TIME_PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-Time-v1";
const FRAME_TAG: [u8; 8] = *b"RDPIPC02";
const DRAIN_TAG: [u8; 8] = *b"RDPACK02";
const FRAME_HEADER_LEN: usize = 12;
const DRAIN_RECEIPT_LEN: usize = 56;
pub(crate) const FRAME_HEADER_LEN: usize = 12;
pub(crate) const DRAIN_RECEIPT_LEN: usize = 56;
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;
@@ -302,6 +302,8 @@ pub enum Operation {
generation: u64,
},
Probe {},
UpdateObserve {request:crate::update_observer::Request},
UpdateHealth {request:rmm_agent_core::update_handoff::NativeControlRequest},
Snapshot {
generation: u64,
},
@@ -361,10 +363,17 @@ pub enum ReplyBody {
ready: bool,
ledger: FileIdentity,
lock: FileIdentity,
#[serde(default,skip_serializing_if="Option::is_none")]
reboot_privilege_available:Option<bool>,
/// Passive protocol negotiation only; no update capability/readiness.
#[serde(default,skip_serializing_if="Option::is_none")]
update_observer_configured:Option<bool>,
},
Snapshot {
snapshot: Snapshot,
},
UpdateObservation {response:Box<crate::update_observer::Response>},
UpdateHealth {reply:Box<rmm_agent_core::update_handoff::NativeControlReply>},
Applied {
snapshot: Snapshot,
unlocked_grants: Vec<Uuid>,
@@ -374,6 +383,9 @@ pub enum ReplyBody {
Executed {
outcome: Outcome,
},
UpdateAccepted {
accepted: crate::update_admission::Accepted,
},
Abandoned {
outcome: Outcome,
},
@@ -408,7 +420,7 @@ pub fn binding_hash(b: &Binding) -> Result<String> {
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> {
pub(crate) fn owned(raw: HANDLE) -> Result<OwnedHandle> {
if raw.is_null() || raw == INVALID_HANDLE_VALUE {
return Err(api_failure("HELPER_HANDLE"));
}
@@ -540,7 +552,7 @@ 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(
pub(crate) fn check_acl(
handle: HANDLE,
readers: &[String],
writers: &[String],
@@ -801,7 +813,7 @@ impl Drop for ServiceHandle {
}
}
}
fn service_status(pin: &PeerPin) -> Result<u32> {
pub(crate) fn service_status(pin: &PeerPin) -> Result<u32> {
let manager =
ServiceHandle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
ensure!(!manager.0.is_null(), "HELPER_SCM_MANAGER");
@@ -906,7 +918,7 @@ impl ProcessIdentity {
}
}
impl PeerProof {
fn capture(pipe: HANDLE, pin: &PeerPin, client: bool) -> Result<Self> {
pub(crate) fn capture(pipe: HANDLE, pin: &PeerPin, client: bool) -> Result<Self> {
let mut pid = 0;
ensure!(
unsafe {
@@ -923,7 +935,7 @@ impl PeerProof {
}
/// Internal fixture admission shares the exact same live-process proof as
/// both pipe peers. The caller supplies the PID read from its held SCM handle.
pub(crate) fn for_service(pin: &PeerPin, pid: u32) -> Result<Self> {
pub fn for_service(pin: &PeerPin, pid: u32) -> Result<Self> {
ensure!(pid == service_status(pin)?, "HELPER_PIPE_SCM_PID");
let process =
owned(unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE, 0, pid) })?;
@@ -1040,9 +1052,9 @@ impl PeerProof {
}
}
struct Descriptor(*mut c_void);
pub(crate) struct Descriptor(pub(crate) *mut c_void);
impl Descriptor {
fn from(s: &str) -> Result<Self> {
pub(crate) fn from(s: &str) -> Result<Self> {
let mut descriptor = ptr::null_mut();
ensure!(
unsafe {
@@ -1106,18 +1118,18 @@ fn pipe_descriptor(agent: &str, helper: &str) -> Result<Descriptor> {
))
}
struct IoEvent {
pub(crate) struct IoEvent {
event: OwnedHandle,
overlapped: OVERLAPPED,
pub(crate) overlapped: OVERLAPPED,
}
impl IoEvent {
fn new() -> Result<Self> {
pub(crate) fn new() -> Result<Self> {
let event = owned(unsafe { CreateEventW(ptr::null(), 1, 0, ptr::null()) })?;
let mut overlapped: OVERLAPPED = unsafe { zeroed() };
overlapped.hEvent = event.as_raw_handle();
Ok(Self { event, overlapped })
}
fn wait(&mut self, pipe: HANDLE, deadline: Instant) -> Result<u32> {
pub(crate) fn wait(&mut self, pipe: HANDLE, deadline: Instant) -> Result<u32> {
let left = deadline.saturating_duration_since(Instant::now());
let milliseconds = u32::try_from(left.as_millis().max(1)).unwrap_or(u32::MAX - 1);
if unsafe { WaitForSingleObject(self.event.as_raw_handle(), milliseconds) } != WAIT_OBJECT_0
@@ -1167,7 +1179,7 @@ impl IoEvent {
Ok(count)
}
}
fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> Result<()> {
pub(crate) fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> Result<()> {
let mut offset = 0;
while offset < bytes.len() {
ensure!(Instant::now() < deadline, "HELPER_PIPE_TIMEOUT");
@@ -1222,7 +1234,7 @@ impl Write for LimitedJson {
Ok(())
}
}
fn encode(value: &impl Serialize) -> Result<Vec<u8>> {
pub(crate) fn encode(value: &impl Serialize) -> Result<Vec<u8>> {
let mut writer = LimitedJson(Vec::with_capacity(FRAME_LIMIT));
serde_json::to_writer(&mut writer, value)?;
ensure!(!writer.0.is_empty(), "HELPER_FRAME_EMPTY");
@@ -1235,12 +1247,12 @@ fn frame_header(len: usize) -> Result<[u8; FRAME_HEADER_LEN]> {
header[8..].copy_from_slice(&u32::try_from(len)?.to_be_bytes());
Ok(header)
}
fn send_bytes(pipe: HANDLE, bytes: &mut [u8], deadline: Instant) -> Result<()> {
pub(crate) fn send_bytes(pipe: HANDLE, bytes: &mut [u8], deadline: Instant) -> Result<()> {
let mut header = frame_header(bytes.len())?;
transfer(pipe, &mut header, true, deadline)?;
transfer(pipe, bytes, true, deadline)
}
fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> {
pub(crate) fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> {
send_bytes(pipe, &mut encode(value)?, deadline)
}
fn frame_length(header: [u8; FRAME_HEADER_LEN]) -> Result<usize> {
@@ -1249,30 +1261,30 @@ fn frame_length(header: [u8; FRAME_HEADER_LEN]) -> Result<usize> {
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
Ok(len)
}
fn length(pipe: HANDLE, deadline: Instant) -> Result<usize> {
pub(crate) fn length(pipe: HANDLE, deadline: Instant) -> Result<usize> {
let mut header = [0u8; FRAME_HEADER_LEN];
transfer(pipe, &mut header, false, deadline)?;
frame_length(header)
}
fn body_bytes(pipe: HANDLE, len: usize, deadline: Instant) -> Result<Vec<u8>> {
pub(crate) fn body_bytes(pipe: HANDLE, len: usize, deadline: Instant) -> Result<Vec<u8>> {
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
let mut bytes = vec![0u8; len];
transfer(pipe, &mut bytes, false, deadline)?;
Ok(bytes)
}
fn body<T: DeserializeOwned>(pipe: HANDLE, len: usize, deadline: Instant) -> Result<T> {
pub(crate) fn body<T: DeserializeOwned>(pipe: HANDLE, len: usize, deadline: Instant) -> Result<T> {
Ok(serde_json::from_slice(&body_bytes(pipe, len, deadline)?)?)
}
// This fixed-size receipt only acknowledges receipt of these transport bytes.
// It never acknowledges durable evidence, clears state, or permits an effect.
fn drain_receipt(challenge: Uuid, reply_bytes: &[u8]) -> [u8; DRAIN_RECEIPT_LEN] {
pub(crate) fn drain_receipt(challenge: Uuid, reply_bytes: &[u8]) -> [u8; DRAIN_RECEIPT_LEN] {
let mut receipt = [0; DRAIN_RECEIPT_LEN];
receipt[..8].copy_from_slice(&DRAIN_TAG);
receipt[8..24].copy_from_slice(challenge.as_bytes());
receipt[24..].copy_from_slice(&Sha256::digest(reply_bytes));
receipt
}
fn verify_drain_receipt(
pub(crate) fn verify_drain_receipt(
receipt: &[u8; DRAIN_RECEIPT_LEN],
challenge: Uuid,
reply_bytes: &[u8],
@@ -1470,8 +1482,11 @@ fn exchange_fixed(pin: &Pin, call: &Call, timeout: Duration, time_only: bool) ->
(_, ReplyBody::Denied { .. })
| (Operation::Probe { .. }, ReplyBody::Probe { .. })
| (Operation::Snapshot { .. }, ReplyBody::Snapshot { .. })
| (Operation::UpdateHealth {..},ReplyBody::UpdateHealth{..})
| (Operation::UpdateObserve {..},ReplyBody::UpdateObservation{..})
| (Operation::Apply { .. }, ReplyBody::Applied { .. })
| (Operation::Execute { .. }, ReplyBody::Executed { .. })
| (Operation::Execute { .. }, ReplyBody::UpdateAccepted { .. })
| (Operation::Abandon { .. }, ReplyBody::Abandoned { .. })
| (Operation::TimeBegin { .. }, ReplyBody::TimeChallenge { .. })
| (
+455 -26
View File
@@ -25,8 +25,11 @@ const PROBE_FILE: &str = "helper-probe.json";
#[derive(Clone)]
pub struct Client {
pin: ipc::Pin,
raw_pin_sha256: String,
raw_settings_sha256: String,
lane: Arc<Semaphore>,
qualified_capabilities: Vec<String>,
update_observer_configured:bool,
probed_at: Option<std::time::Instant>,
}
pub struct ControlSnapshot {
@@ -62,6 +65,28 @@ impl Client {
file.file.read_to_end(&mut bytes)?;
let pin: ipc::Pin = serde_json::from_slice(&bytes)?;
pin.validate()?;
let mut settings_file = ipc::PinnedFile::open(
Path::new(crate::helper_system::CONFIG_PATH),
false,
&readers,
&[],
false,
)?;
ensure!(
settings_file.file.metadata()?.len() <= 32768,
"HELPER_SETTINGS_LIMIT"
);
let mut settings_raw = Vec::new();
(&mut settings_file.file)
.take(32769)
.read_to_end(&mut settings_raw)?;
ensure!(settings_raw.len() <= 32768, "HELPER_SETTINGS_LIMIT");
let settings: crate::helper_system::Settings = serde_json::from_slice(&settings_raw)?;
ensure!(
serde_json::to_vec(&settings.pin()?)? == serde_json::to_vec(&pin)?,
"HELPER_CURRENT_SETTINGS_PIN_BINDING"
);
settings_file.check()?;
ensure!(
pin.binding.agent_id.to_string() == agent_id
&& pin.binding.asset_id.to_string() == asset_id
@@ -75,7 +100,15 @@ impl Client {
"HELPER_JOB_BINDING_MISMATCH"
);
}
Ok(Some(Self { pin, lane, qualified_capabilities:vec![], probed_at:None }))
Ok(Some(Self {
raw_pin_sha256: rmm_domain::jobs::hash(&bytes),
raw_settings_sha256: rmm_domain::jobs::hash(&settings_raw),
pin,
lane,
qualified_capabilities: vec![],
update_observer_configured:false,
probed_at: None,
}))
}
pub async fn refresh(
agent_id: String,
@@ -112,7 +145,9 @@ impl Client {
)?
.context("HELPER_PIN_REMOVED")?;
ensure!(
serde_json::to_vec(&current.pin)? == serde_json::to_vec(&self.pin)?,
serde_json::to_vec(&current.pin)? == serde_json::to_vec(&self.pin)?
&& current.raw_pin_sha256 == self.raw_pin_sha256
&& current.raw_settings_sha256 == self.raw_settings_sha256,
"HELPER_PIN_CHANGED"
);
Ok(())
@@ -123,6 +158,32 @@ impl Client {
pub fn helper_binary_hash(&self) -> &str {
&self.pin.helper.binary_sha256
}
fn retained_intent_context(&self, intent: &intent::Intent, job: &JobPayload) -> bool {
if intent.policy_sha256 == self.pin.policy_sha256
&& intent.helper_binary_sha256 == self.pin.helper.binary_sha256
{
return true;
}
let Action::UpdateAgent { update } = &job.action else {
return false;
};
let rmm_domain::agent_update::PeerPinTransition::WindowsCodePairV1 {
new_pin_sha256,
new_settings_sha256,
time_profile: Some(_),
..
} = &update.peer_pin_transition
else {
return false;
};
update.validate()
&& intent.helper_binary_sha256 == update.predecessor.helper_sha256
&& update
.manifest()
.is_ok_and(|manifest| manifest.artifacts[1].sha256 == self.pin.helper.binary_sha256)
&& *new_pin_sha256 == self.raw_pin_sha256
&& *new_settings_sha256 == self.raw_settings_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.
@@ -159,9 +220,9 @@ impl Client {
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
&& self.retained_intent_context(&intent, &job)
&& (snapshot.boot_id == intent.original_boot_id
|| rmm_domain::windows_reboot::supported(&job))
&& snapshot.journal_id == intent.anchor.journal_id()
&& snapshot.checkpoint >= intent.anchor.checkpoint()
&& observed_at >= intent.recorded_at
@@ -176,8 +237,78 @@ impl Client {
.next()
.context("SYSTEM_DELEGATION_NO_HELPER_EVIDENCE")?;
ensure!(matches.next().is_none(), "SYSTEM_DUPLICATE_HELPER_ATTEMPT");
if matches!(job.action, Action::UpdateAgent { .. })
&& !row.update_handoff_bytes.is_empty()
{
let proof = rmm_domain::agent_update::UpdateInflightProof::from_bytes(
&row.update_handoff_bytes,
)
.map_err(anyhow::Error::msg)?;
let key = rmm_domain::agent_update::job_health_public_key(&job)
.map_err(anyhow::Error::msg)?;
let (handoff, _) = rmm_domain::agent_update::verify_inflight_proof(&proof, key)
.map_err(anyhow::Error::msg)?;
ensure!(
rmm_domain::agent_update::handoff_matches_job(&handoff, &job)
&& handoff.attempt.grant_id == permit.grant_id
&& row.job_id == job.job_id
&& row.attempt_id == job.attempt_id
&& row.job_payload_hash == permit.job_payload_hash
&& row.authorization_id == permit.authorization_id
&& row.plan_hash == permit.plan_hash
&& row.action == permit.action
&& row.execution_identity == "system"
&& row.grant_id == permit.grant_id
&& row.original_request_sha256
== rmm_domain::jobs::hash(&serde_json::to_vec(&intent.request)?)
&& row.original_boot_id == intent.original_boot_id
&& handoff.boot_id == intent.original_boot_id
&& row.state == "running"
&& row.consumption == "consumed"
&& row.outcome_bytes.is_empty()
&& row.outcome_sha256.is_empty()
&& snapshot.journal_id == handoff.helper_journal_id,
"UPDATE_MIRROR_ORIGINAL_INFLIGHT"
);
let start = core_ledger::start_witness_bytes(
&permit,
&intent.request,
handoff.boot_id,
proof.delegation.prepared_at,
)?;
ensure!(
rmm_domain::jobs::hash(&start) == handoff.attempt.original_start_witness_sha256,
"UPDATE_MIRROR_ORIGINAL_START"
);
let existing: Option<Vec<u8>> = ledger
.query_row(
"SELECT start FROM execution_evidence WHERE grant_id=?1",
[permit.grant_id.to_string()],
|r| r.get(0),
)
.optional()?;
if let Some(existing) = existing {
ensure!(existing == start, "UPDATE_MIRROR_LOCAL_START_CONFLICT");
} else {
core_ledger::begin_execution(
ledger,
&permit,
&intent.request,
handoff.boot_id,
proof.delegation.prepared_at,
)?;
}
continue;
}
let outcome =
verified_mirror_row(row, &job, &permit, &intent.request, intent.original_boot_id)?;
if rmm_domain::windows_reboot::supported(&job) && outcome.state == "succeeded" {
ensure!(
snapshot.boot_id != intent.original_boot_id
&& outcome.evidence["new_boot_id"] == snapshot.boot_id.to_string(),
"SYSTEM_REBOOT_MIRROR_NEW_BOOT"
);
}
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)?;
@@ -189,9 +320,16 @@ impl Client {
&& 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,
&& {
let at = serde_json::from_value::<chrono::DateTime<chrono::Utc>>(
start["reserved_at"].clone(),
)?;
if matches!(job.action, Action::UpdateAgent { .. }) {
at >= permit.not_before && at < permit.start_before
} else {
at == intent.recorded_at
}
},
"SYSTEM_MIRROR_LOCAL_START_CONFLICT"
);
} else {
@@ -226,10 +364,9 @@ impl Client {
== Some(row.outcome_sha256.as_str());
ensure!(
self.supports_system(&job)
&& ((intent.policy_sha256 == self.pin.policy_sha256
&& intent.helper_binary_sha256 == self.pin.helper.binary_sha256)
|| mirrored)
&& snapshot.boot_id == intent.original_boot_id
&& (self.retained_intent_context(&intent, &job) || mirrored)
&& (snapshot.boot_id == intent.original_boot_id
|| rmm_domain::windows_reboot::supported(&job))
&& snapshot.journal_id == intent.anchor.journal_id()
&& snapshot.checkpoint >= intent.anchor.checkpoint(),
"SYSTEM_MIRROR_CONTEXT"
@@ -358,25 +495,48 @@ impl Client {
ready,
ledger,
lock,
reboot_privilege_available,
update_observer_configured,
} = reply.body
else {
anyhow::bail!("HELPER_PROBE_DENIED");
};
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()?;
// Advertise the static qualification independently of this connection's
// clock warm-up: a capability change forces a reconnect, which resets the
// per-generation clock again. Every start stays gated by helper readiness.
let _ = clock_qualified;
self.qualified_capabilities=crate::system_capabilities::qualified(pin,true)?;
self.probed_at=Some(std::time::Instant::now());
let mut value=value;
value["system_capability_advertised"]=json!(!self.qualified_capabilities.is_empty());
value["qualified_capabilities"]=json!(self.qualified_capabilities);
// Static qualification only; a per-connection clock warm-up must not flap
// advertised capabilities (each change forces a reconnect).
let qualification=crate::system_capabilities::qualified(pin,true,reboot_privilege_available);
let system_qualification_unavailable=qualification.is_err();
// Capability evidence is deny-only. A missing/stale optional record
// cannot remove the separately authenticated control/SignedSync lane.
self.qualified_capabilities=qualification.unwrap_or_default();
self.update_observer_configured=update_observer_configured==Some(true);
self.probed_at = Some(std::time::Instant::now());
let mut value = value;
if system_qualification_unavailable {
value["system_qualification_diagnostic"]="SYSTEM_QUALIFICATION_UNAVAILABLE".into();
}
value["system_capability_advertised"] = json!(!self.qualified_capabilities.is_empty());
value["qualified_capabilities"] = json!(self.qualified_capabilities);
if let Some(available) = reboot_privilege_available {
value["reboot_privilege_available"] = json!(available);
}
write_current_probe(state, &value).context(ipc::Stage::ClientReport)
}
/// An actual recent authenticated Probe negotiates the passive method.
/// Old helpers/missing local policy return false; never probe unknown IPC.
pub fn update_observer_configured(&self)->bool {
self.update_observer_configured && self.probed_at.is_some_and(|at|at.elapsed()<=Duration::from_secs(90))
}
pub fn qualified_capabilities(&self) -> Vec<String> {
if self.probed_at.is_some_and(|at|at.elapsed()<=Duration::from_secs(90)) {self.qualified_capabilities.clone()} else {vec![]}
if self
.probed_at
.is_some_and(|at| at.elapsed() <= Duration::from_secs(90))
{
self.qualified_capabilities.clone()
} else {
vec![]
}
}
/// Pure admission shape only; no capability or qualification is asserted.
pub fn supports_system(&self, job: &JobPayload) -> bool {
@@ -394,13 +554,17 @@ impl Client {
&self,
intent: intent::Intent,
admit: impl Fn() -> Result<()> + Send + 'static,
) -> Result<()> {
) -> Result<Option<crate::update_admission::Accepted>> {
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 timeout = if matches!(job.action, Action::UpdateAgent { .. }) {
Duration::from_secs(60)
} else {
execution_timeout(job.max_runtime_seconds)?
};
let permit = self
.lane
.clone()
@@ -438,6 +602,14 @@ impl Client {
let call = ipc::Call::new(&client.pin, operation);
let reply = ipc::exchange(&client.pin, &call, timeout)?;
client.check_pin()?;
if let ipc::ReplyBody::UpdateAccepted { accepted } = &reply.body {
ensure!(
matches!(job.action, Action::UpdateAgent { .. }),
"UPDATE_ACK_FOR_NONUPDATE"
);
accepted.matches(&intent.request, intent.permit()?.grant_id)?;
return Ok(Some(accepted.clone()));
}
let outcome = match reply.body {
ipc::ReplyBody::Executed { outcome }
| ipc::ReplyBody::Abandoned { outcome } => outcome,
@@ -446,7 +618,7 @@ impl Client {
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>(())
Ok::<_, anyhow::Error>(None)
}),
)
.await
@@ -476,6 +648,101 @@ impl Client {
);
Ok(())
}
/// Independent passive measurements only; returned records grant no job.
pub async fn observe_update(&self,request:crate::update_observer::Request)->Result<crate::update_observer::Response> {
let permit=tokio::time::timeout(Duration::from_secs(5),self.lane.clone().acquire_owned()).await.context("UPDATE_OBSERVER_LANE_BUSY")??;
let client=self.clone();
tokio::task::spawn_blocking(move||->Result<crate::update_observer::Response>{
let _permit=permit;client.check_pin()?;
let reply=ipc::exchange(&client.pin,&ipc::Call::new(&client.pin,ipc::Operation::UpdateObserve{request:request.clone()}),Duration::from_secs(15))?;
client.check_pin()?;
let ipc::ReplyBody::UpdateObservation{response}=reply.body else {anyhow::bail!("UPDATE_OBSERVER_HELPER_DENIED");};
response.validate(request.generation)?;
ensure!(response.observation.predecessor.as_ref().is_some_and(|p|p.agent_sha256==client.pin.agent.binary_sha256 && p.helper_sha256==client.pin.helper.binary_sha256),"UPDATE_OBSERVER_ACTUAL_PAIR");
Ok(*response)
}).await?
}
/// Evidence-only metadata for the already consumed original Update job.
/// No LocalService caller can claim Stop/Finalize through this route.
pub async fn submit_update_health(
&self,
handoff: &rmm_updater_handoff::Handoff,
key: [u8; 32],
receipt: rmm_updater_handoff::SignedHealth,
) -> Result<()> {
use rmm_agent_core::update_handoff::{NativeControlOperation, NativeControlRequest};
handoff.validate()?;
let request = NativeControlRequest {
operation: "agent_update_control_v1".into(),
schema_version: 1,
challenge: uuid::Uuid::new_v4(),
tenant_id: handoff.attempt.tenant_id,
asset_id: handoff.attempt.asset_id,
agent_id: handoff.attempt.agent_id,
enrollment_generation: handoff.attempt.enrollment_generation,
assignment_version: handoff.attempt.assignment_version,
grant_id: handoff.attempt.grant_id,
owner_nonce: handoff.owner_nonce,
handoff_sha256: rmm_domain::jobs::hash(&handoff.bytes()?),
method: NativeControlOperation::Health { receipt },
};
let permit =
tokio::time::timeout(Duration::from_secs(5), self.lane.clone().acquire_owned())
.await
.context("UPDATE_HEALTH_CONTROL_BUSY")??;
let client = self.clone();
tokio::task::spawn_blocking(move || -> Result<()> {
let _permit = permit;
client.check_pin()?;
let reply = ipc::exchange(
&client.pin,
&ipc::Call::new(
&client.pin,
ipc::Operation::UpdateHealth {
request: request.clone(),
},
),
Duration::from_secs(5),
)?;
client.check_pin()?;
let ipc::ReplyBody::UpdateHealth { reply } = reply.body else {
anyhow::bail!("UPDATE_HEALTH_HELPER_DENIED");
};
ensure!(
reply.schema_version == 1
&& reply.challenge == request.challenge
&& !reply.ready
&& reply.grant_id == request.grant_id
&& reply.owner_nonce == request.owner_nonce
&& reply.handoff_sha256 == request.handoff_sha256
&& reply.tenant_id == request.tenant_id
&& reply.asset_id == request.asset_id
&& reply.agent_id == request.agent_id
&& reply.enrollment_generation == request.enrollment_generation
&& reply.assignment_version == request.assignment_version
&& reply.original_start_base64url.is_none()
&& reply.pre_stop_sync_request_base64url.is_none()
&& reply.pre_stop_sync_response_base64url.is_none()
&& reply.claim.is_none()
&& reply.original_outcome_base64url.is_none(),
"UPDATE_HEALTH_REPLY_BINDING"
);
let proof = reply.proof.context("UPDATE_HEALTH_REPLY_PROOF")?;
let (actual, journal) = rmm_domain::agent_update::verify_inflight_proof(&proof, key)
.map_err(anyhow::Error::msg)?;
ensure!(
rmm_domain::jobs::hash(&actual.bytes()?) == request.handoff_sha256
&& matches!(
journal.phase(),
rmm_updater_handoff::Phase::HealthVerified
| rmm_updater_handoff::Phase::RollbackHealthVerified
),
"UPDATE_HEALTH_ORIGINAL_PROOF"
);
Ok(())
})
.await?
}
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 {
@@ -599,6 +866,18 @@ fn verified_mirror_row(
Ok(outcome)
}
fn system_shape(job: &JobPayload) -> bool {
if let Action::UpdateAgent { update } = &job.action {
return job.execution_identity == "system"
&& job.max_runtime_seconds == 600
&& update.validate()
&& update.execution_identity() == Some("system")
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes);
}
if matches!(job.action, Action::Reboot { .. }) {
return rmm_domain::windows_reboot::supported(job);
}
if job.action.full_maintenance() {
return job.execution_identity == "system"
&& job.action.validate()
@@ -627,6 +906,123 @@ fn execution_timeout(seconds: u32) -> Result<Duration> {
Ok(Duration::from_secs(u64::from(seconds) + 5))
}
pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> {
if let Action::UpdateAgent { update } = &job.action {
ensure!(
system_shape(job)
&& outcome.stdout.is_empty()
&& outcome.stderr.is_empty()
&& !outcome.output_truncated
&& !outcome.reboot_required,
"UPDATE_OUTCOME_SCOPE"
);
let evidence = &outcome.evidence;
let data = &evidence["agent_update"];
match outcome.state.as_str() {
"succeeded" => {
ensure!(
outcome.exit_code == Some(0)
&& outcome.error_code.is_empty()
&& evidence["postconditions_passed"] == true
&& data["schema_version"] == 1
&& data["manifest_sha256"] == update.manifest_sha256
&& data["predecessor_record_sha256"]
== update.predecessor.installed_record_sha256
&& data["rolled_back"] == false
&& [
"handoff_sha256",
"installed_record_sha256",
"signed_health_sha256"
]
.iter()
.all(|k| data[*k]
.as_str()
.is_some_and(rmm_domain::agent_update::digest))
&& data["activation_floor"]
== update
.manifest()
.map_err(anyhow::Error::msg)?
.release_sequence,
"UPDATE_SUCCESS_EVIDENCE"
);
}
"failed" if data["rolled_back"] == true => ensure!(
outcome.exit_code.is_none()
&& outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR"
&& evidence["postconditions_passed"] == false
&& data["schema_version"] == 2
&& data["manifest_sha256"] == update.manifest_sha256
&& data["predecessor_record_sha256"]
== update.predecessor.installed_record_sha256
&& data["installed_record_sha256"]
== update.predecessor.installed_record_sha256
&& ["handoff_sha256", "signed_health_sha256"]
.iter()
.all(|k| data[*k]
.as_str()
.is_some_and(rmm_domain::agent_update::digest)),
"UPDATE_ROLLBACK_EVIDENCE"
),
"failed" | "cancelled" | "expired" => ensure!(
evidence["not_started"] == true && !outcome.error_code.is_empty(),
"UPDATE_NO_START_EVIDENCE"
),
"unknown" => ensure!(
evidence["postconditions_passed"] != true && !outcome.error_code.is_empty(),
"UPDATE_UNKNOWN_EVIDENCE"
),
_ => anyhow::bail!("UPDATE_NONTERMINAL_IS_NOT_OUTCOME"),
}
return Ok(());
}
if matches!(job.action, Action::Reboot { .. }) {
ensure!(
rmm_domain::windows_reboot::supported(job)
&& outcome.stdout.is_empty()
&& outcome.stderr.is_empty()
&& outcome.exit_code.is_none()
&& !outcome.output_truncated
&& !outcome.reboot_required,
"SYSTEM_REBOOT_OUTCOME_SCOPE"
);
let e = &outcome.evidence;
match outcome.state.as_str() {
"awaiting_reboot" => ensure!(
e["provider"] == "windows.shutdown/1"
&& e["native_request_accepted"] == true
&& e["postconditions_passed"] == false
&& e["force_apps_closed"] == false
&& e["local_machine_only"] == true
&& e["announcement_seconds"]
== rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS
&& e["automatic_retry"] == false
&& e["previous_boot_id"]
.as_str()
.is_some_and(|s| uuid::Uuid::parse_str(s).is_ok_and(|id| !id.is_nil())),
"SYSTEM_REBOOT_ACCEPTANCE_EVIDENCE"
),
"succeeded" => ensure!(
e["postconditions_passed"] == true
&& e["reconciled_after_reboot"] == true
&& ["new_boot_id", "inventory_message_id"].iter().all(|k| e[k]
.as_str()
.is_some_and(|s| uuid::Uuid::parse_str(s).is_ok_and(|id| !id.is_nil()))),
"SYSTEM_REBOOT_NEW_BOOT_EVIDENCE"
),
"failed" => ensure!(
!outcome.error_code.is_empty() && e["not_started"] == true,
"SYSTEM_REBOOT_NONSTART_EVIDENCE"
),
"unknown" => ensure!(
!outcome.error_code.is_empty(),
"SYSTEM_REBOOT_UNKNOWN_REASON"
),
"cancelled" | "expired" => {
ensure!(e["not_started"] == true, "SYSTEM_REBOOT_NONSTART_EVIDENCE")
}
_ => anyhow::bail!("SYSTEM_REBOOT_OUTCOME_SCOPE"),
}
return Ok(());
}
ensure!(
matches!(
outcome.state.as_str(),
@@ -856,7 +1252,9 @@ pub fn record_verified_time(
rmm_time_attestation::Role::SystemHelper => {
("helper-time-sample.json", ".helper-time.pending")
}
rmm_time_attestation::Role::Updater => anyhow::bail!("TIME_UPDATER_OWN_PROFILE_REQUIRED"),
rmm_time_attestation::Role::Updater => {
anyhow::bail!("TIME_UPDATER_EVIDENCE_NOT_AGENT_OWNED")
}
};
let value = json!({
"schema_version": 1, "agent_pid": std::process::id(), "observed_at": observed_at,
@@ -906,6 +1304,37 @@ fn write_report(state: &Path, name: &str, pending: &str, value: &serde_json::Val
mod tests {
use super::*;
#[test]
fn reboot_acceptance_is_not_success_and_cannot_inherit_another_action() {
let mut job = msi_test_job();
job.action = Action::Reboot {
reason: "Windows-MVP".into(),
dependency_group: "windows-mvp".into(),
reconnect_timeout_seconds: 180,
};
job.max_runtime_seconds = 60;
let old = uuid::Uuid::new_v4();
let mut o = Outcome {
state: "awaiting_reboot".into(),
stdout: vec![],
stderr: vec![],
exit_code: None,
output_truncated: false,
reboot_required: false,
error_code: "EFFECT_REQUIRES_RECONCILIATION".into(),
evidence: json!({"provider":"windows.shutdown/1","native_request_accepted":true,"postconditions_passed":false,"force_apps_closed":false,"local_machine_only":true,"announcement_seconds":5,"automatic_retry":false,"previous_boot_id":old}),
};
checked_outcome(&job, &o).unwrap();
o.state = "succeeded".into();
assert!(checked_outcome(&job, &o).is_err());
o.evidence = json!({"postconditions_passed":true,"reconciled_after_reboot":true,"new_boot_id":uuid::Uuid::new_v4(),"inventory_message_id":uuid::Uuid::new_v4()});
checked_outcome(&job, &o).unwrap();
o.evidence["inventory_message_id"] = json!(null);
assert!(checked_outcome(&job, &o).is_err());
job.execution_identity = "agent_service".into();
assert!(!system_shape(&job));
assert!(checked_outcome(&job, &o).is_err());
}
#[test]
fn msi_scope_requires_bound_independent_postconditions_and_exact_noop_or_installer_exit() {
let job = msi_test_job();
assert!(system_shape(&job));
+257 -81
View File
@@ -105,7 +105,7 @@ impl Settings {
})
}
fn permits_script(&self, job: &JobPayload) -> bool {
self.schema_version == 3
self.schema_version >= 3
&& job.execution_identity == "system"
&& job.action.full_maintenance()
&& job.action.valid_execution_identity("system")
@@ -117,11 +117,17 @@ impl Settings {
&& self.allowed_script_profiles.as_deref()
== Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1])
}
fn permits_reboot(&self, job: &JobPayload) -> bool {
self.schema_version == 4
&& self.allow_reboot
&& rmm_domain::windows_reboot::supported(job)
&& job.max_runtime_seconds <= self.max_runtime_seconds
}
pub fn validate(&self) -> Result<()> {
ensure!(
matches!(self.schema_version, 1..=3)
matches!(self.schema_version, 1..=4)
&& (self.schema_version >= 2 || self.allowed_msi_recipe_sha256.is_none())
&& (self.schema_version == 3 || self.allowed_script_profiles.is_none())
&& (self.schema_version >= 3 || self.allowed_script_profiles.is_none())
&& self
.allowed_msi_recipe_sha256
.as_ref()
@@ -137,7 +143,7 @@ impl Settings {
&& self.allowed_script_profiles.as_deref().is_none_or(
|v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]
)
&& !self.allow_reboot
&& (self.schema_version == 4 || !self.allow_reboot)
&& (1..=120).contains(&self.max_runtime_seconds)
&& self.allowed_services.len() <= 16,
"SYSTEM_POLICY_PROFILE"
@@ -228,14 +234,14 @@ pub fn read_settings() -> Result<(Settings, Vec<PinnedFile>)> {
settings.validate()?;
Ok((settings, vec![root, file]))
}
struct WindowsBoot(Uuid);
pub struct WindowsBoot(Uuid);
impl BootSource for WindowsBoot {
fn current_boot(&self) -> Result<Uuid> {
Ok(self.0)
}
}
impl WindowsBoot {
fn capture() -> Result<Self> {
pub fn capture() -> Result<Self> {
// The exact existing fixed read-only CIM getter, independently called here.
// No caller values, execution-policy flag, or supplied command are accepted.
let rt = tokio::runtime::Builder::new_current_thread()
@@ -306,6 +312,16 @@ impl LedgerGuard {
guard.check(&db)?;
Ok((guard, db))
}
pub(crate) fn update_identity(
&self,
db: &Connection,
) -> Result<crate::update_state::LedgerIdentity> {
self.check(db)?;
Ok(crate::update_state::LedgerIdentity {
ledger: self.ledger.identity,
lock: self.lock.identity,
})
}
fn check_files(&self) -> Result<()> {
for file in [&self.root, &self.lock, &self.ledger] {
ensure!(
@@ -833,6 +849,17 @@ struct UnsettledMsi {
request_sha256: String,
installer: Box<crate::package::Installer>,
}
/// Internal native-control adapter. No caller can construct readiness, choose
/// another database, or replace the real held executor through the wire.
pub(crate) struct UpdateContext<'a> {
pub db:&'a mut Connection,
pub guard:&'a LedgerGuard,
pub binding:&'a Binding,
pub clock:&'a BoundClock,
pub pin:&'a Pin,
pub boot:&'a WindowsBoot,
pub sync:Option<&'a mut HelperSync<DalekVerifier>>,
}
pub struct SystemHelper {
settings: Settings,
pin: Pin,
@@ -845,6 +872,7 @@ pub struct SystemHelper {
last_diagnostic: Option<Instant>,
last_apply_diagnostic: Option<Instant>,
unsettled_msi: Option<UnsettledMsi>,
pending_update_activation: Option<crate::update_admission::Activation>,
}
impl SystemHelper {
pub fn open() -> Result<Self> {
@@ -870,8 +898,13 @@ impl SystemHelper {
last_diagnostic: None,
last_apply_diagnostic: None,
unsettled_msi: None,
pending_update_activation: None,
})
}
pub(crate) fn update_context(&mut self)->UpdateContext<'_> {
UpdateContext{db:&mut self.db,guard:&self.guard,binding:&self.settings.binding,clock:&self.clock,
pin:&self.pin,boot:&self.boot,sync:self.sync.as_mut()}
}
pub fn pin(&self) -> &Pin {
&self.pin
}
@@ -922,54 +955,8 @@ impl SystemHelper {
);
Ok(())
}
// One authenticated control call, same original bytes/capture/deadline.
// Only a typed clock failure proven before BEGIN can be retried.
fn apply_control_with_clock(
&mut self,
response: &rmm_agent_core::helper_reconcile::SignedResponse,
request: &[u8],
issued: chrono::DateTime<chrono::Utc>,
until: chrono::DateTime<chrono::Utc>,
) -> Result<rmm_agent_core::helper_reconcile::Applied> {
let began = Instant::now();
loop {
ensure!(
began.elapsed() < Duration::from_secs(3),
"SYSTEM_APPLY_CLOCK_WAIT_EXPIRED"
);
match crate::job_readiness::response_window(
issued,
until,
began.elapsed(),
self.clock.reading().ok().map(|r| (r.own_wall, r.upper)),
) {
crate::job_readiness::ResponseWindow::WaitForClock => {
std::thread::sleep(Duration::from_millis(20));
continue;
}
crate::job_readiness::ResponseWindow::Expired => {
anyhow::bail!("SYSTEM_APPLY_ORIGINAL_DEADLINE_EXPIRED")
}
crate::job_readiness::ResponseWindow::WithinWindow => {}
}
self.sync()?;
match self.sync.as_mut().unwrap().apply(
&mut self.db,
&self.guard,
response,
request,
&self.clock,
&self.boot,
) {
Ok(value) => return Ok(value),
Err(error)
if rmm_agent_core::helper_reconcile::retryable_precommit_clock(&error) =>
{
std::thread::sleep(Duration::from_millis(20))
}
Err(error) => return Err(error),
}
}
fn wait_apply_clock(&self,issued:chrono::DateTime<chrono::Utc>,until:chrono::DateTime<chrono::Utc>)->Result<()> {
crate::job_readiness::wait_for_helper_apply_clock(&self.clock,issued,until)
}
/// Passive, bounded static denial metadata only. Never feeds a gate.
fn record_apply_error(&mut self,error:&anyhow::Error)->Result<()> {
@@ -1030,6 +1017,13 @@ impl SystemHelper {
| Operation::TimeClose { .. } => {
anyhow::bail!("SYSTEM_TIME_PIPE_REQUIRED")
}
Operation::UpdateObserve{request}=>{
Ok(ReplyBody::UpdateObservation{response:Box::new(crate::update_observer::collect(self.update_context(),request)?)})
}
Operation::UpdateHealth{request}=>{
ensure!(matches!(request.method,rmm_agent_core::update_handoff::NativeControlOperation::Health{..}),"UPDATE_AGENT_HEALTH_ONLY");
Ok(ReplyBody::UpdateHealth{reply:Box::new(crate::update_control::handle_agent_health(self.update_context(),peer,request)?)})
}
Operation::Probe {} => {
let ready = self.settings.enable_effects
&& self
@@ -1042,22 +1036,31 @@ impl SystemHelper {
})
.unwrap_or(false);
Ok(ReplyBody::Probe {
update_observer_configured:Some(crate::update_admission::configured(&self.settings.binding)),
clock_qualified: self.clock.now().is_ok(),
ready,
ledger: self.guard.ledger.identity,
lock: self.guard.lock.identity,
reboot_privilege_available: if self.settings.schema_version == 4
&& self.settings.allow_reboot
{
Some(crate::reboot::privilege_available()?)
} else {
None
},
})
}
Operation::Snapshot { generation } => {
self.clock = self.clock.for_generation(*generation);
self.sync()?;
let snapshot = self.sync.as_mut().unwrap().snapshot(
&mut self.db,
&self.guard,
*generation,
&self.clock,
&self.boot,
)?;
let snapshot = if let Some(grant)=crate::update_control::active_grant(&self.db)? {
let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?;
let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding,
&self.clock,&self.pin,&budget,grant)?;
self.sync.as_mut().unwrap().snapshot(&mut self.db,&guard,*generation,&self.clock,&self.boot)?
} else {
self.sync.as_mut().unwrap().snapshot(&mut self.db,&self.guard,*generation,&self.clock,&self.boot)?
};
Ok(ReplyBody::Snapshot { snapshot })
}
Operation::Apply {
@@ -1068,16 +1071,20 @@ impl SystemHelper {
serde_json::from_slice(&response.decision_bytes)?;
self.clock
.require_generation(decision.connection_generation)?;
// Same authenticated original call, BEFORE any application.
// The independent time pipe continues on its own thread.
// No signature/deadline/lease is relaxed and no Execute retry.
let value = self.apply_control_with_clock(
response,
request_bytes,
decision.issued_at,
decision.valid_until,
)?;
let no_start_anchor = if value.ready && self.settings.enable_effects {
self.wait_apply_clock(decision.issued_at,decision.valid_until)?;
self.sync()?;
let value = if let Some(grant)=crate::update_control::active_grant(&self.db)? {
let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?;
let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding,
&self.clock,&self.pin,&budget,grant)?;
self.sync.as_mut().unwrap().apply(&mut self.db,&guard,response,request_bytes,&self.clock,&self.boot)?
} else {
self.sync.as_mut().unwrap().apply(&mut self.db,&self.guard,response,request_bytes,&self.clock,&self.boot)?
};
let no_start_anchor = if value.ready
&& (self.settings.enable_effects
|| crate::update_admission::configured(&self.settings.binding))
{
let guard = DenialGuard {
ledger: &self.guard,
pin: &self.pin,
@@ -1109,9 +1116,41 @@ impl SystemHelper {
Operation::Execute {
generation,
request,
} => Ok(ReplyBody::Executed {
outcome: self.execute(*generation, request, peer)?,
}),
} => {
let job = self.settings.binding.job(&request.job_bytes)?;
if matches!(job.action, Action::UpdateAgent { .. }) {
ensure!(
self.pending_update_activation.is_none(),
"UPDATE_ACTIVATION_PENDING"
);
self.clock.require_generation(*generation)?;
self.sync()?;
let prepared = crate::update_admission::Prepared::new(
&self.db,
crate::update_admission::Local {
binding: &self.settings.binding,
guard: &self.guard,
clock: &self.clock,
boot: &self.boot,
pin: &self.pin,
generation: *generation,
},
self.sync.as_ref().context("SYSTEM_SYNC_REQUIRED")?,
request,
)?;
peer.check()?;
let accepted = prepared.consume(
&mut self.db,
self.sync.as_mut().context("SYSTEM_SYNC_REQUIRED")?,
)?;
self.pending_update_activation = Some(prepared.into_activation());
Ok(ReplyBody::UpdateAccepted { accepted })
} else {
Ok(ReplyBody::Executed {
outcome: self.execute(*generation, request, peer)?,
})
}
}
Operation::Abandon {
anchor,
request,
@@ -1125,10 +1164,15 @@ impl SystemHelper {
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))
|| self.settings.permits_msi(&job)
|| self.settings.permits_script(&job)),
&& ((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))
|| self.settings.permits_msi(&job)
|| self.settings.permits_script(&job)
|| self.settings.permits_reboot(&job)))
|| crate::update_admission::permits_denial(
&self.settings.binding,
&job
)),
"SYSTEM_ABANDON_POLICY_DENIED"
);
self.sync()?;
@@ -1227,6 +1271,9 @@ impl SystemHelper {
if job.action.windows_msi().is_some() {
return self.execute_msi(generation, request, &job, &permit, peer);
}
if matches!(job.action, Action::Reboot { .. }) {
return self.execute_reboot(generation, request, &job, &permit, peer);
}
let mut provider = PreparedService::prepare(&self.settings, &job)?;
self.recheck()?;
peer.check()?;
@@ -1272,6 +1319,69 @@ impl SystemHelper {
ledger::finish(&self.db, &permit, &outcome)?;
Ok(outcome)
}
fn execute_reboot(
&mut self,
generation: u64,
request: &Request,
job: &JobPayload,
permit: &ExecutionPermitPayload,
peer: &mut ipc::PeerProof,
) -> Result<Outcome> {
ensure!(
self.settings.permits_reboot(job),
"SYSTEM_REBOOT_POLICY_DENIED"
);
self.observe_unsettled_msi()?;
ensure!(
self.unsettled_msi.is_none(),
"SYSTEM_MSI_PREVIOUS_PROCESS_UNSETTLED"
);
let provider = crate::reboot::Prepared::prepare(job)?;
self.recheck()?;
peer.check()?;
let (_, fresh, recorded_at) =
verified_window(&self.settings.binding, request, &self.clock)?;
ensure!(
&fresh == permit && !STOP.load(Ordering::SeqCst),
"SYSTEM_REBOOT_START_FENCED"
);
let boot = self.boot.current_boot()?;
crate::helper_runtime::intent::Store::require_not_denied(
request,
boot,
generation,
&self.pin.policy_sha256,
&self.pin.helper.binary_sha256,
)?;
ledger::begin_execution(&mut self.db, permit, request, boot, recorded_at)?;
self.sync.as_mut().unwrap().close();
let outcome = provider
.request(boot, || {
self.clock.require_generation(generation)?;
self.recheck()?;
peer.check()?;
ensure!(
!STOP.load(Ordering::SeqCst),
"SYSTEM_REBOOT_CANCELLED_BEFORE_REQUEST"
);
verified_window(&self.settings.binding, request, &self.clock)?;
crate::helper_runtime::intent::Store::require_not_denied(
request,
boot,
generation,
&self.pin.policy_sha256,
&self.pin.helper.binary_sha256,
)?;
Ok(())
})
.unwrap_or_else(|_| Outcome::unknown("WINDOWS_REBOOT_REQUEST_UNCONFIRMED"));
ledger::persist_outcome(&self.db, permit, &outcome)?;
self.guard.check(&self.db)?;
// Awaiting/Unknown deliberately keeps consumed.result NULL. Only the
// existing signed new-boot reconciliation may finish the same attempt.
ledger::finish(&self.db, permit, &outcome)?;
Ok(outcome)
}
fn execute_script(
&mut self,
generation: u64,
@@ -1650,30 +1760,76 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
let mut helper = SystemHelper::open()?;
let server = ipc::Server::bind(helper.pin().clone())?;
let time_server = ipc::Server::bind_time(helper.pin().clone())?;
let update_server=crate::update_control::server_pin(&helper.settings.binding,&helper.pin.helper)?
.map(crate::update_control_ipc::Server::bind).transpose()?;
let time_pin = helper.pin().clone();
let time_clock = helper.clock.source();
let time_worker = std::thread::Builder::new()
.name("rmm-helper-time-control".into())
.spawn(move || time_control(time_server, time_pin, time_clock))?;
scm_status(SERVICE_RUNNING, 0);
let mut next_update_unknown=Instant::now();
while !STOP.load(Ordering::SeqCst) {
if Instant::now()>=next_update_unknown {
next_update_unknown=Instant::now()+Duration::from_secs(2);
if let Err(error)=crate::update_control::observe_worker_unknown(helper.update_context()) {
let _diagnostic=helper.record_pipe_error(&error);
}
}
// A failed observation keeps the owned slot and its handles locked.
if helper.observe_unsettled_msi().is_err()
&& let Some(sync) = &mut helper.sync
{
sync.close();
}
if let Some(update_server)=&update_server {
match update_server.receive() {
Ok(Some(mut incoming))=> {
let reply=crate::update_control::handle_updater(helper.update_context(),&mut incoming.peer,&incoming.request);
let result=match reply {
Ok(reply)=>update_server.reply(&mut incoming,&reply),
Err(error)=>Err(error),
};
update_server.disconnect();
if let Err(error)=result {
if let Some(sync)=&mut helper.sync {sync.close();}
let _diagnostic=helper.record_pipe_error(&error);
}
}
Ok(None)=>{},
Err(error)=> {
update_server.disconnect();
if let Some(sync)=&mut helper.sync {sync.close();}
let _diagnostic=helper.record_pipe_error(&error);
}
}
}
match server.receive() {
Ok(Some(mut incoming)) => {
let reply = helper.handle(&incoming.call, &mut incoming.peer);
if let Err(error) = server.reply(&reply, &mut incoming.peer) {
let delivered = server.reply(&reply, &mut incoming.peer);
server.disconnect();
if let Err(error) = delivered {
if let Some(sync) = &mut helper.sync {
sync.close();
}
// Receipt loss cannot trigger an Activate or a retry.
helper.pending_update_activation = None;
let _diagnostic = helper.record_pipe_error(&error);
} else if matches!(reply.body, ReplyBody::UpdateAccepted { .. })
&& let Some(activation) = helper.pending_update_activation.take()
&& let Err(error) = activation.dispatch_after_reply(
&helper.db,
&helper.guard,
&helper.clock,
&helper.boot,
)
{
if let Some(sync) = &mut helper.sync {
sync.close();
}
server.disconnect();
let _diagnostic = helper.record_pipe_error(&error);
}
server.disconnect();
}
Ok(None) => {}
Err(error) => {
@@ -1862,6 +2018,26 @@ mod tests {
let mut null = legacy;
null["allowed_script_profiles"] = serde_json::Value::Null;
assert!(serde_json::from_value::<Settings>(null).is_err());
let mut reboot = job.clone();
reboot.action = Action::Reboot {
reason: "Windows-MVP".into(),
dependency_group: "windows-mvp".into(),
reconnect_timeout_seconds: 180,
};
reboot.max_runtime_seconds = 60;
settings.max_runtime_seconds = 120;
settings.allow_reboot = true;
for v in 1..=3 {
settings.schema_version = v;
assert!(!settings.permits_reboot(&reboot));
}
settings.schema_version = 4;
assert!(settings.permits_reboot(&reboot));
settings.allow_reboot = false;
assert!(!settings.permits_reboot(&reboot));
settings.allow_reboot = true;
reboot.execution_identity = "agent_service".into();
assert!(!settings.permits_reboot(&reboot));
}
#[test]
fn service_adapter_exposes_only_implemented_states() {
+45
View File
@@ -7,6 +7,8 @@ pub mod certificate_rotation;
pub mod clock;
pub mod echo_probe;
pub mod echo_completion;
#[cfg(feature = "system-helper")]
pub mod reboot;
#[cfg(all(windows, feature = "system-helper"))]
pub mod system_capabilities;
pub mod event_log;
@@ -28,6 +30,7 @@ pub mod msi_cache;
#[cfg(windows)]
pub mod native;
pub mod package;
pub mod release_platform;
#[cfg(windows)]
pub mod process;
#[cfg(windows)]
@@ -41,4 +44,46 @@ pub mod update_native;
pub const SERVICE_NAME: &str = "RmmDiscoveryWindows";
pub const CAPABILITIES: &[&str] = &["windows.base/1", "heartbeat/1"];
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_ipc;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_cache;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_trust;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_state;
#[cfg(all(windows, feature = "system-helper"))]
pub mod release_service;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_admission;
pub mod job_readiness;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_original;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_control_ipc;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_owned;
#[cfg(all(windows, feature = "system-helper"))]
pub(crate) mod update_control;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_time_transport;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_worker;
#[cfg(all(windows, feature = "system-helper"))]
pub(crate) mod update_record;
#[cfg(all(windows, feature = "system-helper"))]
pub mod update_observer;
+7
View File
@@ -1,3 +1,10 @@
#[cfg(all(windows, feature = "system-helper"))]
mod update_observation_runtime;
#[cfg(all(windows, feature = "system-helper"))]
#[path = "../../agent/src/agent_update_health.rs"]
mod agent_update_health;
#[cfg(all(windows, feature = "system-helper"))]
mod update_download;
#[cfg(windows)]
#[path = "../../agent/src/https_channel.rs"]
mod https_channel;
+279
View File
@@ -0,0 +1,279 @@
//! Typed local reboot provider. The caller must durably consume the original
//! signed attempt and keep the independent helper gate before `request`.
#[cfg(any(windows, test))]
use rmm_agent_core::auth::Outcome;
#[cfg(any(windows, test))]
use uuid::Uuid;
#[cfg(any(windows, test))]
fn report(previous_boot: Uuid, accepted: bool, native_error: u32) -> Outcome {
Outcome {
state: if accepted {
"awaiting_reboot"
} else {
"failed"
}
.into(),
stdout: vec![],
stderr: vec![],
exit_code: None,
output_truncated: false,
reboot_required: false,
error_code: if accepted {
"EFFECT_REQUIRES_RECONCILIATION"
} else {
"WINDOWS_REBOOT_REQUEST_REJECTED"
}
.into(),
evidence: serde_json::json!({"provider":"windows.shutdown/1","previous_boot_id":previous_boot,"postconditions_passed":false,
"native_request_accepted":accepted,"native_error":native_error,"not_started":!accepted,"force_apps_closed":false,"local_machine_only":true,
"announcement_seconds":rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS,"reconnect_timeout_seconds":rmm_domain::windows_reboot::RECONNECT_SECONDS,
"automatic_retry":false,"success_requires_authenticated_new_boot":true}),
}
}
#[cfg(windows)]
mod native {
use super::*;
use anyhow::{Result, ensure};
use std::{
mem::{size_of, zeroed},
ptr,
};
use windows_sys::Win32::{
Foundation::{
CloseHandle, ERROR_INSUFFICIENT_BUFFER, GetLastError, HANDLE, LUID, SetLastError,
},
Security::{
AdjustTokenPrivileges, GetTokenInformation, LUID_AND_ATTRIBUTES, LookupPrivilegeValueW,
SE_PRIVILEGE_ENABLED, SE_SHUTDOWN_NAME, TOKEN_ADJUST_PRIVILEGES, TOKEN_PRIVILEGES,
TOKEN_QUERY, TokenPrivileges,
},
System::{
Shutdown::{
InitiateSystemShutdownExW, SHTDN_REASON_FLAG_PLANNED,
SHTDN_REASON_MAJOR_APPLICATION, SHTDN_REASON_MINOR_MAINTENANCE,
},
Threading::{GetCurrentProcess, OpenProcessToken},
},
};
struct Token(HANDLE);
impl Drop for Token {
fn drop(&mut self) {
unsafe {
CloseHandle(self.0);
}
}
}
fn open(access: u32) -> Result<Token> {
let mut raw = ptr::null_mut();
ensure!(
unsafe { OpenProcessToken(GetCurrentProcess(), access, &mut raw) } != 0,
"REBOOT_TOKEN_OPEN"
);
Ok(Token(raw))
}
fn luid() -> Result<LUID> {
let mut id = unsafe { zeroed() };
ensure!(
unsafe { LookupPrivilegeValueW(ptr::null(), SE_SHUTDOWN_NAME, &mut id) } != 0,
"REBOOT_PRIVILEGE_NAME"
);
Ok(id)
}
fn present(token: &Token, wanted: &LUID) -> Result<bool> {
let mut size = 0;
unsafe {
GetTokenInformation(token.0, TokenPrivileges, ptr::null_mut(), 0, &mut size);
}
ensure!(
unsafe { GetLastError() } == ERROR_INSUFFICIENT_BUFFER && (4..=65536).contains(&size),
"REBOOT_PRIVILEGE_SIZE"
);
let mut bytes = vec![0u64; (size as usize).div_ceil(8)];
ensure!(
unsafe {
GetTokenInformation(
token.0,
TokenPrivileges,
bytes.as_mut_ptr().cast(),
size,
&mut size,
)
} != 0,
"REBOOT_PRIVILEGE_READ"
);
let p = bytes.as_ptr().cast::<TOKEN_PRIVILEGES>();
let count = unsafe { (*p).PrivilegeCount } as usize;
let offset = std::mem::offset_of!(TOKEN_PRIVILEGES, Privileges);
ensure!(
offset
.checked_add(
count
.checked_mul(size_of::<LUID_AND_ATTRIBUTES>())
.ok_or_else(|| anyhow::anyhow!("REBOOT_PRIVILEGE_OVERFLOW"))?
)
.is_some_and(|v| v <= size as usize),
"REBOOT_PRIVILEGE_BOUNDS"
);
let entries = unsafe {
std::slice::from_raw_parts(
ptr::addr_of!((*p).Privileges).cast::<LUID_AND_ATTRIBUTES>(),
count,
)
};
Ok(entries
.iter()
.any(|x| x.Luid.LowPart == wanted.LowPart && x.Luid.HighPart == wanted.HighPart))
}
/// Read only; does not enable a privilege, call Shutdown or create a job.
pub fn privilege_available() -> Result<bool> {
present(&open(TOKEN_QUERY)?, &luid()?)
}
struct Privilege<'a> {
token: &'a Token,
previous: TOKEN_PRIVILEGES,
restore: bool,
}
impl<'a> Privilege<'a> {
fn enable(token: &'a Token, id: LUID) -> Result<Self> {
let change = TOKEN_PRIVILEGES {
PrivilegeCount: 1,
Privileges: [LUID_AND_ATTRIBUTES {
Luid: id,
Attributes: SE_PRIVILEGE_ENABLED,
}],
};
let mut previous = unsafe { zeroed() };
let mut len = 0;
unsafe {
SetLastError(0);
}
ensure!(
unsafe {
AdjustTokenPrivileges(
token.0,
0,
&change,
size_of::<TOKEN_PRIVILEGES>() as u32,
&mut previous,
&mut len,
)
} != 0
&& unsafe { GetLastError() } == 0,
"REBOOT_PRIVILEGE_ENABLE"
);
Ok(Self {
token,
previous,
restore: true,
})
}
fn restore(&mut self) -> Result<()> {
if self.restore {
ensure!(
unsafe {
AdjustTokenPrivileges(
self.token.0,
0,
&self.previous,
0,
ptr::null_mut(),
ptr::null_mut(),
)
} != 0,
"REBOOT_PRIVILEGE_RESTORE"
);
self.restore = false;
}
Ok(())
}
}
impl Drop for Privilege<'_> {
fn drop(&mut self) {
let _ = self.restore();
}
}
pub(crate) struct Prepared {
token: Token,
luid: LUID,
}
impl Prepared {
pub fn prepare(job: &rmm_domain::jobs::JobPayload) -> Result<Self> {
ensure!(
rmm_domain::windows_reboot::supported(job),
"WINDOWS_REBOOT_FIXED_PROFILE_REQUIRED"
);
let token = open(TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES)?;
let luid = luid()?;
ensure!(
present(&token, &luid)?,
"WINDOWS_REBOOT_PRIVILEGE_UNAVAILABLE"
);
Ok(Self { token, luid })
}
pub fn request(
self,
previous_boot: Uuid,
mut last_gate: impl FnMut() -> Result<()>,
) -> Result<Outcome> {
last_gate()?;
let mut privilege = Privilege::enable(&self.token, self.luid)?;
last_gate()?;
// No remote target, free command, force flag, clock setter or retry.
let message: Vec<u16> = "RustDiscovery: genehmigter Neustart"
.encode_utf16()
.chain(Some(0))
.collect();
let accepted = unsafe {
InitiateSystemShutdownExW(
ptr::null(),
message.as_ptr(),
rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS,
0,
1,
SHTDN_REASON_FLAG_PLANNED
| SHTDN_REASON_MAJOR_APPLICATION
| SHTDN_REASON_MINOR_MAINTENANCE,
)
} != 0;
let code = if accepted {
0
} else {
unsafe { GetLastError() }
};
let restored = privilege.restore();
if accepted && restored.is_err() {
return Ok(Outcome {
evidence: serde_json::json!({"provider":"windows.shutdown/1","previous_boot_id":previous_boot,"native_request_accepted":true,"postconditions_passed":false,"automatic_retry":false}),
..Outcome::unknown("WINDOWS_REBOOT_ACCEPTED_PRIVILEGE_RESTORE_UNCONFIRMED")
});
}
restored?;
Ok(report(previous_boot, accepted, code))
}
}
}
#[cfg(windows)]
pub(crate) use native::Prepared;
#[cfg(windows)]
pub use native::privilege_available;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn native_acceptance_requires_new_boot_instead_of_claiming_success_or_retry() {
let boot = Uuid::new_v4();
let accepted = report(boot, true, 0);
assert_eq!(accepted.state, "awaiting_reboot");
assert!(!accepted.reboot_required);
assert_eq!(accepted.evidence["previous_boot_id"], boot.to_string());
assert_eq!(accepted.evidence["postconditions_passed"], false);
assert_eq!(accepted.evidence["force_apps_closed"], false);
let denied = report(boot, false, 1314);
assert_eq!(denied.state, "failed");
assert_eq!(denied.evidence["not_started"], true);
assert_eq!(denied.evidence["automatic_retry"], false);
}
}
@@ -0,0 +1,14 @@
//! The release catalog distinguishes the two Windows ABIs even on the same CPU.
#[cfg(all(windows, target_env = "gnu"))]
pub const WIRE: rmm_domain::agent_update::Platform =
rmm_domain::agent_update::Platform::WindowsGnuX64;
#[cfg(not(all(windows, target_env = "gnu")))]
pub const WIRE: rmm_domain::agent_update::Platform = rmm_domain::agent_update::Platform::WindowsX64;
#[cfg(all(windows, target_env = "gnu"))]
pub const VERIFY: rmm_updater::Platform = rmm_updater::Platform::WindowsGnuX64;
#[cfg(not(all(windows, target_env = "gnu")))]
pub const VERIFY: rmm_updater::Platform = rmm_updater::Platform::WindowsX64;
#[cfg(all(windows, target_env = "gnu"))]
pub const TRIPLE: &str = "x86_64-pc-windows-gnu";
#[cfg(not(all(windows, target_env = "gnu")))]
pub const TRIPLE: &str = "x86_64-pc-windows-msvc";
+459
View File
@@ -0,0 +1,459 @@
//! Unattended, fixed-role releases for installations made by the HTTPS installer.
use crate::release_platform::{TRIPLE, VERIFY};
use crate::{
certificate_rotation::{ProtectedKeyFiles, RotationStore},
job_binding, native,
};
use anyhow::{Context, Result, ensure};
use reqwest::{Client, Response};
use rmm_domain::agent_update::ReleaseEnvelope;
use rmm_updater::ReleaseManifest;
use rusqlite::{Connection, OpenFlags};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::{
ffi::OsStr,
fs,
io::Write,
net::SocketAddr,
os::windows::ffi::OsStrExt,
path::{Path, PathBuf},
process::Command,
sync::atomic::{AtomicBool, Ordering},
time::Duration,
};
use uuid::Uuid;
pub const SERVICE: &str = "RmmDiscoveryReleasePull";
const AGENT: &str = "rmm-agent-windows.exe";
const HELPER: &str = "rmm-helper-windows.exe";
const ACTIVE: &str = "installed-release.json";
const INTENT: &str = "release-transition.json";
#[derive(Clone, Serialize, Deserialize)]
struct Installed {
schema_version: u32,
tenant_id: Uuid,
release_id: Uuid,
release_sequence: u64,
manifest_sha256: String,
}
#[derive(Serialize, Deserialize)]
struct Transition {
old: Installed,
new: Installed,
}
#[derive(Deserialize)]
struct Endpoint {
server_name: String,
connect_address: SocketAddr,
transport: String,
state_directory: PathBuf,
ca_file: PathBuf,
#[serde(default)]
enable_jobs: bool,
}
#[derive(Deserialize)]
struct Health {
agent_id: Uuid,
agent_version: Option<String>,
connection_generation: u64,
last_contact_at: Option<chrono::DateTime<chrono::Utc>>,
}
#[derive(Deserialize)]
struct Current {
status: String,
release: Option<Published>,
}
#[derive(Deserialize)]
struct Published {
release_envelope: ReleaseEnvelope,
manifest: ReleaseManifest,
}
fn data(name: &str) -> PathBuf {
PathBuf::from(std::env::var_os("ProgramData").unwrap_or_else(|| r"C:\ProgramData".into()))
.join("RustDiscovery")
.join(name)
}
fn releases() -> PathBuf {
PathBuf::from(std::env::var_os("ProgramFiles").unwrap_or_else(|| r"C:\Program Files".into()))
.join("RustDiscovery")
.join("releases")
}
fn generation(id: Uuid) -> PathBuf {
releases().join(id.to_string())
}
fn protected(path: &Path, limit: usize) -> Result<Vec<u8>> {
job_binding::check_admin_readonly(path)?;
ensure!(
fs::metadata(path)?.len() <= limit as u64,
"protected file size"
);
Ok(fs::read(path)?)
}
fn read_record<T: serde::de::DeserializeOwned>(name: &str) -> Result<T> {
Ok(serde_json::from_slice(&protected(&data(name), 8192)?)?)
}
fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
let mut file = fs::File::create_new(path)?;
file.write_all(bytes)?;
file.sync_all()?;
Ok(())
}
fn write_record<T: Serialize>(name: &str, value: &T) -> Result<()> {
use windows_sys::Win32::Storage::FileSystem::{
MOVEFILE_REPLACE_EXISTING, MOVEFILE_WRITE_THROUGH, MoveFileExW,
};
let tmp = data(&format!(".release-{}", Uuid::new_v4()));
let wide = |p: &OsStr| p.encode_wide().chain(Some(0)).collect::<Vec<_>>();
let result = (|| -> Result<()> {
write_new(&tmp, &serde_json::to_vec(value)?)?;
let (from, to) = (wide(tmp.as_os_str()), wide(data(name).as_os_str()));
if unsafe {
MoveFileExW(
from.as_ptr(),
to.as_ptr(),
MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH,
)
} == 0
{
return Err(std::io::Error::last_os_error().into());
}
Ok(())
})();
let _ = fs::remove_file(tmp);
result
}
struct Device {
client: Client,
base: String,
id: Uuid,
}
impl Device {
fn open(config: &Endpoint) -> Result<Self> {
ensure!(
config.transport == "https"
&& config.ca_file == data("server-ca.pem")
&& config.state_directory == data("state"),
"installed HTTPS configuration"
);
let ca = protected(&config.ca_file, 32768)?;
let state = &config.state_directory;
let identity_path = state.join("identity.json");
native::private_path(&identity_path, false)?;
ensure!(
fs::metadata(&identity_path)?.len() <= 32768,
"identity size"
);
let identity: rmm_protocol::EnrollmentResponse =
serde_json::from_slice(&fs::read(identity_path)?)?;
let id = Uuid::parse_str(&identity.agent_id)?;
let db_path = state.join("telemetry.sqlite");
native::private_path(&db_path, false)?;
let db = Connection::open_with_flags(
db_path,
OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
)?;
db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?;
let keys = ProtectedKeyFiles::open(state)?;
let rotation = RotationStore::new(id, 1, ca.clone())?;
let tls = rotation.read_only_current(&db, &keys, chrono::Utc::now().timestamp())?;
let mut pem = tls.certificate_pem;
pem.push(b'\n');
pem.extend_from_slice(&tls.private_key_pem);
let base = reqwest::Url::parse(&format!(
"https://{}:{}",
config.server_name,
config.connect_address.port()
))?;
ensure!(
base.domain() == Some(config.server_name.as_str()),
"invalid gateway hostname"
);
let client = Client::builder()
.https_only(true)
.tls_built_in_root_certs(false)
.add_root_certificate(reqwest::Certificate::from_pem(&ca)?)
.identity(reqwest::Identity::from_pem(&pem)?)
.resolve(&config.server_name, config.connect_address)
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(Duration::from_secs(10))
.timeout(Duration::from_secs(180))
.build()?;
Ok(Self {
client,
base: base.origin().ascii_serialization(),
id,
})
}
async fn get(&self, path: &str, timeout: Duration) -> Result<Response> {
let r = self
.client
.get(format!("{}{path}", self.base))
.timeout(timeout)
.send()
.await?;
ensure!(
r.status() == 200,
"device release service returned {}",
r.status()
);
Ok(r)
}
async fn json<T: serde::de::DeserializeOwned>(&self, path: &str) -> Result<T> {
let mut r = self.get(path, Duration::from_secs(10)).await?;
let mut body = Vec::new();
while let Some(chunk) = r.chunk().await? {
ensure!(
body.len() + chunk.len() <= 131072,
"release response too large"
);
body.extend_from_slice(&chunk);
}
Ok(serde_json::from_slice(&body)?)
}
async fn health(&self) -> Result<Health> {
let value: Health = self.json("/agent/v1/releases/installed").await?;
ensure!(value.agent_id == self.id, "device release identity changed");
Ok(value)
}
async fn download(&self, path: &Path, url: &str, limit: u64) -> Result<()> {
ensure!(
(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&limit),
"release size"
);
let mut r = self.get(url, Duration::from_secs(180)).await?;
ensure!(r.content_length() == Some(limit), "release length");
let mut file = fs::File::create_new(path)?;
let mut count = 0;
while let Some(chunk) = r.chunk().await? {
count += chunk.len() as u64;
ensure!(count <= limit, "release body too large");
file.write_all(&chunk)?;
}
ensure!(count == limit, "truncated release");
file.sync_all()?;
Ok(())
}
}
fn local_manifest(installed: &Installed) -> Result<ReleaseManifest> {
let root = generation(installed.release_id);
let raw = protected(&root.join("manifest.json"), rmm_updater::MAX_MANIFEST_BYTES)?;
ensure!(
hex::encode(Sha256::digest(&raw)) == installed.manifest_sha256,
"changed installed manifest"
);
let m: ReleaseManifest = serde_json::from_slice(&raw)?;
ensure!(
installed.schema_version == 1
&& m.platform == VERIFY
&& m.release_id == installed.release_id
&& m.release_sequence == installed.release_sequence,
"installed release identity"
);
for (expected, name) in m.artifacts.iter().zip([AGENT, HELPER]) {
let path = root.join(name);
job_binding::check_admin_readonly(&path)?;
let mut digest = Sha256::new();
let count = std::io::copy(&mut fs::File::open(path)?, &mut digest)?;
ensure!(
expected.bytes == count && expected.sha256 == hex::encode(digest.finalize()),
"installed release component changed"
);
}
Ok(m)
}
// Only typed release UUIDs enter the fixed SCM command. The actual service path,
// LocalService account and absence of an independently provisioned helper are checked again on the target.
fn select(from: Uuid, to: Uuid) -> Result<()> {
let script = include_str!("release_service_switch.ps1")
.replace("FROM_UUID", &from.to_string())
.replace("TO_UUID", &to.to_string());
let windows = std::env::var_os("SystemRoot").context("Windows directory")?;
let ps = Path::new(&windows).join(r"System32\WindowsPowerShell\v1.0\powershell.exe");
let result = Command::new(ps)
.args([
"-NoLogo",
"-NoProfile",
"-NonInteractive",
"-Command",
&script,
])
.output()?;
ensure!(result.status.success(), "SCM release selection failed");
Ok(())
}
async fn rollback(t: &Transition) -> Result<()> {
local_manifest(&t.old)?;
select(t.new.release_id, t.old.release_id)?;
write_record("rejected-release.json", &t.new)?;
fs::remove_file(data(INTENT))?;
Ok(())
}
async fn stage(device: &Device, release: &Published, active: &Installed) -> Result<Installed> {
let id = release.manifest.release_id;
let tmp = releases().join(format!(".stage-{}", Uuid::new_v4()));
fs::create_dir(&tmp)?;
let result = async {
let env_path = tmp.join("envelope.json");
write_new(&env_path, &serde_json::to_vec(&release.release_envelope)?)?;
for (entry, name) in release.manifest.artifacts.iter().zip([AGENT, HELPER]) {
device
.download(
&tmp.join(name),
&format!("/agent/v1/releases/{id}/artifacts/{}", entry.artifact_id),
entry.bytes,
)
.await?;
}
let paths = [
data("release-keyring.json"),
env_path,
tmp.join(AGENT),
tmp.join(HELPER),
]
.map(PathBuf::into_os_string);
let verified = rmm_updater::verify_bootstrap_files(VERIFY, &paths)?;
ensure!(
verified.manifest() == &release.manifest
&& verified.manifest().release_sequence > active.release_sequence,
"signed release identity"
);
let record = Installed {
schema_version: 1,
tenant_id: active.tenant_id,
release_id: id,
release_sequence: verified.manifest().release_sequence,
manifest_sha256: verified.manifest_sha256().into(),
};
write_new(
&tmp.join("manifest.json"),
&serde_json::to_vec(verified.manifest())?,
)?;
if !generation(id).try_exists()? {
fs::rename(&tmp, generation(id))?;
}
local_manifest(&record)?;
Ok::<_, anyhow::Error>(record)
}
.await;
if tmp.try_exists()? {
fs::remove_dir_all(tmp)?;
}
result
}
async fn cycle() -> Result<()> {
let active: Installed = read_record(ACTIVE)?;
let config: Endpoint = serde_json::from_slice(&protected(&data("config.json"), 32768)?)?;
// Installed passive pairs only. A separately provisioned SYSTEM helper and
// privileged time/profile pins need the existing coordinated handoff.
ensure!(
!config.enable_jobs,
"job-enabled pair requires coordinated helper handoff"
);
if data(INTENT).try_exists()? {
let t: Transition = read_record(INTENT)?;
if active.release_id == t.new.release_id {
fs::remove_file(data(INTENT))?;
} else {
ensure!(
active.release_id == t.old.release_id,
"unexpected activation floor"
);
rollback(&t).await?;
}
}
let device = Device::open(&config)?;
let catalog: Current = device
.json(&format!("/agent/v1/releases/current?platform={TRIPLE}"))
.await?;
let Some(release) = catalog.release else {
ensure!(
catalog.status == "not_configured",
"unexpected release response"
);
return Ok(());
};
let decoded = release
.release_envelope
.decode()
.map_err(|_| anyhow::anyhow!("invalid release envelope"))?;
let candidate = &release.manifest;
ensure!(
catalog.status == "available"
&& candidate.platform == VERIFY
&& candidate.release_sequence >= active.release_sequence,
"invalid release sequence or platform"
);
if candidate.release_sequence == active.release_sequence {
ensure!(
candidate.release_id == active.release_id
&& hex::encode(Sha256::digest(decoded.payload_bytes)) == active.manifest_sha256,
"conflicting equal release"
);
return Ok(());
}
if data("rejected-release.json").try_exists()? {
let rejected: Installed = read_record("rejected-release.json")?;
ensure!(
candidate.release_sequence > rejected.release_sequence,
"previously failed release sequence"
);
}
let old = local_manifest(&active)?;
let before = device.health().await?;
ensure!(
before.agent_version.as_deref() == Some(&old.version),
"current agent version not confirmed"
);
let new = stage(&device, &release, &active).await?;
let t = Transition { old: active, new };
write_record(INTENT, &t)?;
let start = chrono::Utc::now();
let selected = select(t.old.release_id, t.new.release_id);
if selected.is_ok() {
for _ in 0..18 {
if let Ok(h) = device.health().await
&& h.connection_generation > before.connection_generation
&& h.agent_version.as_deref() == Some(&candidate.version)
&& h.last_contact_at.is_some_and(|v| v >= start)
{
write_record(ACTIVE, &t.new)?;
fs::remove_file(data(INTENT))?;
return Ok(());
}
tokio::time::sleep(Duration::from_secs(5)).await;
}
}
rollback(&t).await?;
anyhow::bail!("new release did not reconnect; previous release selected")
}
pub fn dispatch() -> Result<()> {
crate::service::dispatch_named(SERVICE, run)
}
fn run(stop: &'static AtomicBool) -> Result<()> {
let runtime = tokio::runtime::Runtime::new()?;
while !stop.load(Ordering::SeqCst) {
let result = runtime.block_on(cycle());
write_record(
"release-status.json",
&serde_json::json!({"observed_at": chrono::Utc::now(),
"status": if result.is_ok() { "ok" } else { "error" }, "detail": result.err().map(|e| e.to_string())}),
)?;
for _ in 0..300 {
if stop.load(Ordering::SeqCst) {
break;
}
std::thread::sleep(Duration::from_secs(1));
}
}
Ok(())
}
@@ -0,0 +1,28 @@
$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest
function Get-Image([string]$Id) {
$image = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) ('RustDiscovery\releases\' + $Id + '\rmm-agent-windows.exe')
return '"' + $image + '" --service --config "' + $configPath + '"'
}
$configPath = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery\config.json'
$from = Get-Image 'FROM_UUID'
$to = Get-Image 'TO_UUID'
$service = Get-CimInstance -ClassName Win32_Service -Filter "Name='RmmDiscoveryWindows'"
$config = Get-Content -LiteralPath $configPath -Raw | ConvertFrom-Json
if ($config.PSObject.Properties['enable_jobs'] -and $config.enable_jobs) { throw 'Job-enabled agent requires a coordinated handoff.' }
if (-not $service -or $service.StartName -ine 'NT AUTHORITY\LocalService' -or
$service.PathName -cnotin @($from,$to) -or (Get-Service 'RmmDiscoverySystemHelper' -ErrorAction SilentlyContinue)) { throw 'Unexpected service configuration.' }
if ($service.PathName -cne $to) {
$control = Get-Service 'RmmDiscoveryWindows'
if ($control.Status -ne 'Stopped') {
$control.Stop()
$control.WaitForStatus('Stopped', [TimeSpan]::FromSeconds(45))
}
$res = Invoke-CimMethod -InputObject $service -MethodName Change -Arguments @{PathName=$to}
if ($res.ReturnValue -ne 0) { throw 'SCM path change failed.' }
}
$control = Get-Service 'RmmDiscoveryWindows'
if ($control.Status -ne 'Running') {
$control.Start()
$control.WaitForStatus('Running',[TimeSpan]::FromSeconds(45))
}
+375 -48
View File
@@ -386,7 +386,26 @@ impl EffectFence {
})
}
}
type Completion = (JobOffer, ExecutionPermitPayload, Outcome);
enum ExecutorResult {
Outcome(Outcome),
#[cfg(feature = "system-helper")]
UpdatePending(Option<rmm_agent_windows::update_admission::Accepted>),
}
impl From<Outcome> for ExecutorResult {
fn from(value: Outcome) -> Self {
Self::Outcome(value)
}
}
fn interrupted_executor(grant: &ExecutionPermitPayload) -> ExecutorResult {
#[cfg(not(feature="system-helper"))]
let _=grant;
#[cfg(feature = "system-helper")]
if grant.action == "update_agent" {
return ExecutorResult::UpdatePending(None);
}
Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED").into()
}
type Completion = (JobOffer, ExecutionPermitPayload, ExecutorResult);
#[cfg(feature = "system-helper")]
fn needs_bound_outcome(
db: &Connection,
@@ -573,6 +592,7 @@ impl HelperControl {
}
struct Agent {
config: Config,
reported_version: String,
identity: EnrollmentResponse,
ca: Vec<u8>,
journal: Journal,
@@ -591,6 +611,14 @@ struct Agent {
prepared: bool,
deferred_sync: Option<DeferredSync>,
#[cfg(feature = "system-helper")]
update_pending: bool,
#[cfg(feature="system-helper")]
update_observer:crate::update_observation_runtime::Observer,
#[cfg(feature = "system-helper")]
update_health: Option<tokio::task::JoinHandle<Result<()>>>,
#[cfg(feature = "system-helper")]
update_inventory_head: Option<(u64, String)>,
#[cfg(feature = "system-helper")]
prepared_request: Option<Vec<u8>>,
#[cfg(feature = "system-helper")]
helper_apply_unconfirmed: bool,
@@ -617,6 +645,10 @@ struct Agent {
running: Option<Running>,
deferred_permit: Option<(u64, ExecutionPermit)>,
readiness_worker: Option<tokio::task::JoinHandle<Result<()>>>,
#[cfg(feature = "system-helper")]
update_prefetch: Option<(u64, String, String, tokio::task::JoinHandle<Result<()>>)>,
#[cfg(feature = "system-helper")]
update_cached: Option<(u64, String, String)>,
}
impl Agent {
fn rotation_without_effects(&self) -> Result<()> {
@@ -1096,6 +1128,19 @@ impl Agent {
let (ledger, result) = task.await?;
self.ledger = Some(ledger);
let (snapshot, unknowns) = result?;
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
self.update_pending =
rmm_agent_windows::helper_runtime::intent::Store::open(false)?
.pending()?
.iter()
.any(|intent| {
self.binding.as_ref().is_some_and(|binding| {
binding.job(&intent.request.job_bytes).is_ok_and(|job| {
matches!(job.action, Action::UpdateAgent { .. })
})
})
});
}
for bound in unknowns {
if needs_bound_outcome(self.journal.connection(), &bound)? {
let bytes: Vec<u8> = self.journal.connection().query_row(
@@ -1232,6 +1277,88 @@ impl Agent {
.is_some_and(|sync| sync.can_start(&channel, helper, &self.clock))
})
}
#[cfg(feature = "system-helper")]
async fn poll_update_health(&mut self, generation: u64) -> Result<bool> {
if self
.update_health
.as_ref()
.is_some_and(|task| task.is_finished())
{
let task = self.update_health.take().context("UPDATE_HEALTH_TASK")?;
task.await??;
return Ok(true);
}
if !self.update_pending
|| self.update_health.is_some()
|| self.prepared
|| self.helper_control_pending()
|| self.clock.reading().is_err()
{
return Ok(false);
}
let binding = self
.binding
.as_ref()
.context("UPDATE_BINDING_REQUIRED")?
.clone();
let Some(proof) = rmm_agent_core::update_health_inventory::current_proof(
self.journal.connection(),
&binding,
)?
else {
return Ok(true);
};
let decoded = proof.decode().map_err(anyhow::Error::msg)?;
let event = decoded
.events
.last()
.map(|raw| serde_json::from_slice::<rmm_updater_handoff::Event>(raw))
.transpose()?;
if !event.is_some_and(|event| {
matches!(
event.evidence,
rmm_updater_handoff::Evidence::ServicesStarted { .. }
| rmm_updater_handoff::Evidence::RollbackServicesStarted { .. }
)
}) {
return Ok(true);
}
let inventory_key = (generation, proof.head_sha256.clone());
if self.update_inventory_head.as_ref() != Some(&inventory_key)
&& self.queue_inventory(generation)?
{
self.update_inventory_head = Some(inventory_key);
}
let Some(context) = crate::agent_update_health::context(
self.journal.connection(),
&binding,
&proof,
self.clock.now()?,
)?
else {
return Ok(true);
};
let handoff = context.handoff().clone();
let key = context.health_public_key();
let identity = self.certificates.current(
self.journal.connection(),
&self.key_files,
Utc::now().timestamp(),
)?;
let client = crate::https_channel::mtls_client(
self.config.connect_address,
&self.ca,
&identity.certificate_pem,
&identity.private_key_pem,
)?;
let helper = self.helper.clone().context("UPDATE_HELPER_REQUIRED")?;
let address = self.config.connect_address;
self.update_health = Some(tokio::spawn(async move {
let receipt = crate::agent_update_health::request(&client, address, &context).await?;
helper.submit_update_health(&handoff, key, receipt).await
}));
Ok(false)
}
fn supported_job(&self, job: &rmm_domain::jobs::JobPayload) -> bool {
if self.config.windows_echo_probe_only
&& !self
@@ -1278,8 +1405,99 @@ impl Agent {
rmm_agent_windows::echo_probe::permits_offer(scope, offer, job)
})
}
#[cfg(feature = "system-helper")]
async fn prefetch_update(
&mut self,
generation: u64,
offer: &JobOffer,
job: &rmm_domain::jobs::JobPayload,
) -> Result<bool> {
let Action::UpdateAgent { update } = &job.action else {
return Ok(true);
};
ensure!(
update.validate()
&& update.manifest().map_err(anyhow::Error::msg)?.platform
== rmm_agent_windows::release_platform::WIRE,
"UPDATE_PREFETCH_JOB"
);
let key = (generation, offer.job_id.clone(), offer.attempt_id.clone());
if self.update_cached.as_ref() == Some(&key) {
return Ok(true);
}
if self.update_prefetch.as_ref().is_some_and(|(g, j, a, _)| {
(*g, j.as_str(), a.as_str())
!= (generation, offer.job_id.as_str(), offer.attempt_id.as_str())
}) && let Some((_, _, _, task)) = self.update_prefetch.take() {
task.abort();
}
if self
.update_prefetch
.as_ref()
.is_some_and(|(_, _, _, task)| task.is_finished())
{
let (_, _, _, task) = self
.update_prefetch
.take()
.context("UPDATE_PREFETCH_TASK")?;
task.await??;
self.update_cached = Some(key);
return Ok(true);
}
if self.update_prefetch.is_none() {
ensure!(
rmm_agent_windows::update_cache::configured(),
"UPDATE_PREFETCH_NOT_PROVISIONED"
);
let address = self.config.connect_address;
let identity = self.certificates.current(
self.journal.connection(),
&self.key_files,
Utc::now().timestamp(),
)?;
let client = crate::https_channel::mtls_client(
address,
&self.ca,
&identity.certificate_pem,
&identity.private_key_pem,
)?;
let base = format!(
"https://{}:{}",
crate::https_channel::server_name()?,
address.port()
);
let guard_job = job.clone();
let clock = self.clock.clone();
let fence = self.fence.clone();
let job = job.clone();
let manifest = update.manifest().map_err(anyhow::Error::msg)?;
let task = tokio::spawn(crate::update_download::prefetch(
client,
base,
job,
manifest,
move || {
ensure!(
fence.allows_identity(generation, true, &clock)
&& clock.now()? < guard_job.start_before,
"UPDATE_PREFETCH_FENCED"
);
Ok(())
},
));
self.update_prefetch = Some((
generation,
offer.job_id.clone(),
offer.attempt_id.clone(),
task,
));
}
Ok(false)
}
fn capabilities(&self) -> Vec<String> {
let mut caps: Vec<String> = CAPABILITIES.iter().map(|c| c.to_string()).collect();
#[cfg(target_env = "gnu")]
caps.push("agent.release.windows.gnu/1".into());
// queue_update_observation emits the passive update status in every profile.
caps.push("agent.update/1".into());
if self.config.windows_echo_probe_only {
@@ -1307,6 +1525,10 @@ impl Agent {
&& let Some(helper) = &self.helper
{
caps.extend(helper.qualified_capabilities());
if helper.update_observer_configured()
&& self.update_observer.cached().is_some_and(|r|r.observation.predecessor.as_ref().is_some_and(|p|p.helper_sha256==helper.helper_binary_hash())) {
for cap in self.update_observer.capabilities(){if !caps.contains(&cap){caps.push(cap);}}
}
}
}
caps
@@ -1338,6 +1560,13 @@ impl Agent {
let pending = intents.pending()?;
if let Some(intent) = pending.first() {
let p = intent.permit()?;
if matches!(
binding.job(&intent.request.job_bytes)?.action,
Action::UpdateAgent { .. }
) {
self.update_pending = true;
return Ok(());
}
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(
@@ -1496,37 +1725,13 @@ impl Agent {
helper: Option<&reconcile::HelperSnapshot>,
) -> Result<()> {
let context = self.channel(generation)?;
let closed_control_idle = {
#[cfg(feature = "system-helper")]
{
self.running.is_none()
&& !self.prepared
&& self.deferred_sync.is_none()
&& self.deferred_permit.is_none()
&& self.helper_control.is_none()
&& self.helper_probe.is_none()
&& helper.is_some()
&& (if Path::new(rmm_agent_windows::helper_runtime::intent::DB).exists() {
rmm_agent_windows::helper_runtime::intent::Store::open(false)
.and_then(|store| store.pending())
.is_ok_and(|pending| pending.is_empty())
} else {
helper.is_some_and(|snapshot| snapshot.attempts.is_empty())
})
}
#[cfg(not(feature = "system-helper"))]
{
false
}
};
let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?;
let prepared = sync.prepare_with_closed_control_idle(
let prepared = sync.prepare(
self.journal.connection_mut(),
self.ledger.as_ref().context("LEDGER_REQUIRED")?,
context,
helper,
&self.clock,
closed_control_idle,
);
#[cfg(feature = "system-helper")]
if helper.is_some()
@@ -1708,7 +1913,7 @@ impl Agent {
}
Ok(())
}
fn completed(&mut self, generation: u64, (offer, grant, outcome): Completion) -> Result<()> {
fn completed(&mut self, generation: u64, (offer, grant, result): Completion) -> Result<()> {
let running = self
.running
.as_ref()
@@ -1719,6 +1924,48 @@ impl Agent {
&& running.grant == grant,
"EXECUTOR_COMPLETION_BINDING"
);
#[cfg(feature = "system-helper")]
if let ExecutorResult::UpdatePending(accepted) = result {
ensure!(
grant.execution_identity == "system" && grant.action == "update_agent",
"UPDATE_COMPLETION_SCOPE"
);
if let Some(accepted) = accepted {
let intent = rmm_agent_windows::helper_runtime::intent::Store::open(false)?
.by_grant(grant.grant_id)?;
accepted.matches(&intent.request, grant.grant_id)?;
let mut envelope = self.envelope(
generation,
Payload::JobStateChanged(JobStateChanged::default()),
)?;
let tx = self.journal.connection_mut().transaction()?;
let revision =
jobs::transition(&tx, &offer, "running", &grant.grant_id.to_string())?;
envelope.payload = Some(Payload::JobStateChanged(JobStateChanged {
job_id: offer.job_id.clone(),
attempt_id: offer.attempt_id.clone(),
revision,
state: "running".into(),
grant_id: grant.grant_id.to_string(),
}));
jobs::event(&tx, &envelope)?;
tx.commit()?;
}
// Neither a typed handoff ACK nor its loss is an Outcome. Import
// only actual original helper evidence in the next normal Sync.
self.update_pending = true;
self.running = None;
self.close_gate();
return Ok(());
}
#[cfg(not(feature="system-helper"))]
let ExecutorResult::Outcome(outcome)=result;
#[cfg(feature="system-helper")]
let outcome = match result {
ExecutorResult::Outcome(outcome) => outcome,
#[cfg(feature = "system-helper")]
ExecutorResult::UpdatePending(_) => unreachable!("handled update completion"),
};
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.
@@ -1845,6 +2092,10 @@ impl Agent {
let completed = self.completed_tx.clone();
let work_offer = offer.clone();
let work_grant = grant.clone();
let is_update = matches!(job.action, Action::UpdateAgent { .. });
if is_update {
self.update_pending = true;
}
let msi = job.action.windows_msi().cloned();
let address = self.config.connect_address;
let ca = self.ca.clone();
@@ -1912,7 +2163,7 @@ impl Agent {
} else {
true
};
let _result = helper
let result = helper
.delegate(intent, move || {
ensure!(staged, "MSI_DOWNLOAD_NOT_READY");
ensure!(
@@ -1931,7 +2182,11 @@ impl Agent {
.send((
work_offer,
work_grant,
Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"),
if is_update {
ExecutorResult::UpdatePending(result.ok().flatten())
} else {
Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT").into()
},
))
.await;
});
@@ -2054,7 +2309,7 @@ impl Agent {
outcome.error_code = "WINDOWS_FINAL_CLOCK_UNTRUSTED".into();
outcome.evidence["postconditions_passed"] = false.into();
}
let _ = completed.blocking_send((work_offer, work_grant, outcome));
let _ = completed.blocking_send((work_offer, work_grant, outcome.into()));
});
self.running = Some(Running {
offer,
@@ -2078,9 +2333,9 @@ impl Agent {
payload: Some(payload),
})
}
fn queue_inventory(&mut self, generation: u64) -> Result<()> {
fn queue_inventory(&mut self, generation: u64) -> Result<bool> {
if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() {
return Ok(());
return Ok(false);
}
let data = serde_json::to_vec(&native::snapshot()?)?;
ensure!(data.len() <= 32768, "WINDOWS_INVENTORY_LIMIT");
@@ -2097,22 +2352,36 @@ impl Agent {
completeness: "partial".into(),
}),
)?;
if self.binding.is_some() {
jobs::event(self.journal.connection(), &envelope)
if let Some(binding) = &self.binding {
jobs::event(self.journal.connection(), &envelope)?;
let initialized:bool=self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='reconcile_meta')",[],|r|r.get(0))?;
if initialized
&& self.journal.connection().query_row(
"SELECT generation FROM reconcile_meta WHERE id=1",
[],
|r| r.get::<_, u64>(0),
)? == generation
{
rmm_agent_core::update_health_inventory::retain_current(
self.journal.connection(),
&envelope,
binding,
)?;
}
} else {
self.journal.save(&envelope)
self.journal.save(&envelope)?;
}
Ok(true)
}
fn queue_update_observation(&mut self, generation: u64) -> Result<()> {
if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() {
return Ok(());
}
// Schema support is passive only; no qualified updater/helper observer
// is configured by this source checkpoint, so apply remains closed.
#[cfg(feature="system-helper")]
let observation=self.update_observer.observation(generation);
#[cfg(not(feature="system-helper"))]
let observation = rmm_domain::agent_update::AgentUpdateObservation::not_configured(
rmm_domain::agent_update::Platform::WindowsX64,
Utc::now(),
);
rmm_agent_windows::release_platform::WIRE,Utc::now());
let data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?;
let envelope = self.envelope(
generation,
@@ -2190,7 +2459,7 @@ impl Agent {
let hello = self.envelope(
0,
Payload::ClientHello(ClientHello {
agent_version: env!("CARGO_PKG_VERSION").into(),
agent_version: self.reported_version.clone(),
capabilities: advertised.clone(),
}),
)?;
@@ -2254,6 +2523,8 @@ impl Agent {
let mut tick = tokio::time::interval(Duration::from_millis(20));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut readiness_at = Instant::now() - Duration::from_secs(5);
#[cfg(feature = "system-helper")]
let mut update_control_at = Instant::now() - Duration::from_secs(2);
while !stop.load(Ordering::SeqCst) || self.running.is_some() {
if stop.load(Ordering::SeqCst) {
self.close_gate();
@@ -2272,10 +2543,23 @@ impl Agent {
}
if self.running.as_ref().is_some_and(|r|r.worker.is_finished()) {
if let Ok(completion)=self.completed_rx.try_recv(){self.completed(generation,completion)?;}
else {let running=self.running.as_ref().context("RUNNING_REQUIRED")?;self.completed(generation,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?;}
else {let running=self.running.as_ref().context("RUNNING_REQUIRED")?;self.completed(generation,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?;}
needs_sync=true;
}
#[cfg(feature="system-helper")]
if !stop.load(Ordering::SeqCst) && update_control_at.elapsed()>=Duration::from_secs(2) {
update_control_at=Instant::now();
if !self.update_pending && !self.prepared && !self.helper_control_pending() && self.running.is_none() && self.ready(generation) {
let transport=(||->Result<_>{let helper=self.helper.clone().filter(|h|h.update_observer_configured()).context("UPDATE_OBSERVER_NOT_CONFIGURED")?;
let identity=self.certificates.current(self.journal.connection(),&self.key_files,Utc::now().timestamp())?;
Ok((crate::https_channel::mtls_client(self.config.connect_address,&self.ca,&identity.certificate_pem,&identity.private_key_pem)?,self.config.connect_address,helper))})();
self.update_observer.poll(generation,||transport).await;
}
match self.poll_update_health(generation).await {Ok(refresh)=>{needs_sync|=refresh;},Err(_)=>{self.close_gate();needs_sync=true;}}
}
let busy=self.running.is_some() || self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))?;
#[cfg(feature="system-helper")]
let busy=(busy && !(self.update_pending && self.running.is_none())) || self.update_health.is_some();
if !stop.load(Ordering::SeqCst) && !busy {
if capabilities_at.elapsed()>=Duration::from_secs(60) {capabilities_at=Instant::now();if advertised!=self.capabilities(){return Ok(());}}
if self.prepared && self.deferred_sync.is_none() && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;}
@@ -2289,9 +2573,15 @@ impl Agent {
ensure!(self.scope_permits(&offer,&job),"WINDOWS_ECHO_OFFER_OUT_OF_SCOPE");
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 && 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?;
#[cfg(feature="system-helper")]
let prefetched=self.prefetch_update(generation,&offer,&job).await?;
#[cfg(not(feature="system-helper"))]
let prefetched=true;
if prefetched {
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?;
}
}
}
}
@@ -2484,6 +2774,29 @@ impl Agent {
)
}
}
fn installed_version() -> Result<String> {
let executable = std::env::current_exe()?;
let directory = executable.parent().context("AGENT_IMAGE_DIRECTORY")?;
let path = directory.join("manifest.json");
if !path.try_exists()? {
return Ok(env!("CARGO_PKG_VERSION").into());
}
rmm_agent_windows::job_binding::check_admin_readonly(&path)?;
let manifest: rmm_updater::ReleaseManifest =
serde_json::from_slice(&protected_read(&path, rmm_updater::MAX_MANIFEST_BYTES)?)?;
let expected = &manifest.artifacts[0];
let mut digest = Sha256::new();
let bytes = std::io::copy(&mut fs::File::open(executable)?, &mut digest)?;
ensure!(
manifest.platform == rmm_agent_windows::release_platform::VERIFY
&& expected.role == rmm_updater::ArtifactRole::Agent
&& expected.bytes == bytes
&& expected.sha256 == hex::encode(digest.finalize()),
"INSTALLED_AGENT_IMAGE_MISMATCH"
);
Ok(manifest.version)
}
fn service_run(stop: &'static AtomicBool) -> Result<()> {
let arguments: Vec<String> = std::env::args().skip(1).collect();
ensure!(
@@ -2550,6 +2863,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
let (completed_tx,completed_rx)=tokio::sync::mpsc::channel(1);
let mut agent = Agent {
config,
reported_version: installed_version()?,
identity,
ca,
journal,
@@ -2580,7 +2894,20 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
helper_checked:false,
#[cfg(feature="system-helper")]
helper_refused:false,
prepared:false,deferred_sync:None,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None,
prepared:false,deferred_sync:None,
#[cfg(feature="system-helper")]
update_pending:false,
#[cfg(feature="system-helper")]
update_observer:crate::update_observation_runtime::Observer::default(),
#[cfg(feature="system-helper")]
update_health:None,
#[cfg(feature="system-helper")]
update_inventory_head:None,
fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None,
#[cfg(feature="system-helper")]
update_prefetch:None,
#[cfg(feature="system-helper")]
update_cached:None,
};
agent.recover_interrupted()?;
let mut backoff = 1;
@@ -2591,7 +2918,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;}
if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) {
let running=agent.running.as_ref().context("RUNNING_REQUIRED")?;
agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?;
agent.completed(0,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?;
}
if agent.running.is_some() {tokio::select!{Some(completion)=agent.completed_rx.recv()=>agent.completed(0,completion)?,_=tokio::time::sleep(Duration::from_millis(250))=>{}}}
continue;
@@ -2613,7 +2940,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;}
if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) {
let running=agent.running.as_ref().context("RUNNING_REQUIRED")?;
agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?;
agent.completed(0,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?;
}
tokio::time::sleep(Duration::from_millis(250)).await;
}
+7 -2
View File
@@ -12,6 +12,7 @@ static STOP: AtomicBool = AtomicBool::new(false);
static HANDLE: AtomicUsize = AtomicUsize::new(0);
type Runner = fn(&'static AtomicBool) -> Result<()>;
static RUN: OnceLock<Runner> = OnceLock::new();
static NAME: OnceLock<&'static str> = OnceLock::new();
fn status(state: u32, exit: u32) {
let handle = HANDLE.load(Ordering::SeqCst) as SERVICE_STATUS_HANDLE;
if handle.is_null() {
@@ -51,7 +52,7 @@ unsafe extern "system" fn control(
0
}
unsafe extern "system" fn service_main(_count: u32, _args: *mut *mut u16) {
let name = crate::native::wide(crate::SERVICE_NAME);
let name = crate::native::wide(NAME.get().copied().unwrap_or(crate::SERVICE_NAME));
let handle =
unsafe { RegisterServiceCtrlHandlerExW(name.as_ptr(), Some(control), ptr::null_mut()) };
if handle.is_null() {
@@ -64,8 +65,12 @@ unsafe extern "system" fn service_main(_count: u32, _args: *mut *mut u16) {
status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 });
}
pub fn dispatch(run: Runner) -> Result<()> {
dispatch_named(crate::SERVICE_NAME, run)
}
pub fn dispatch_named(name: &'static str, run: Runner) -> Result<()> {
ensure!(NAME.set(name).is_ok(), "SCM_ALREADY_INITIALIZED");
ensure!(RUN.set(run).is_ok(), "SCM_ALREADY_INITIALIZED");
let mut name = crate::native::wide(crate::SERVICE_NAME);
let mut name = crate::native::wide(name);
let table = [
SERVICE_TABLE_ENTRYW {
lpServiceName: name.as_mut_ptr(),
+262 -1
View File
@@ -113,6 +113,65 @@ pub struct RoleQualification {
pub binary_sha256: String,
pub qualification_sha256: String,
}
/// Separately protected stable-updater clock profile. It never loads a helper
/// calibration/qualification as its own image or process evidence.
#[derive(Debug, serde::Deserialize, serde::Serialize)]
#[serde(deny_unknown_fields)]
pub struct UpdaterConfiguration {
pub schema_version: u32,
pub key_generation: u64,
pub server_instance: Uuid,
pub binding: rmm_agent_core::auth::Binding,
pub public_keys_hex: std::collections::BTreeMap<String, String>,
pub updater_policy_sha256: String,
pub updater_service_configuration_sha256: String,
pub trusted_os_active_guest: TrustedOsActiveGuest,
}
impl UpdaterConfiguration {
#[cfg(any(windows, test))]
fn validate(&self, image: &str) -> Result<()> {
let profile = &self.trusted_os_active_guest;
ensure!(
self.schema_version == 3
&& self.key_generation > 0
&& !self.server_instance.is_nil()
&& !self.binding.agent_id.is_nil()
&& !self.binding.asset_id.is_nil()
&& !self.binding.tenant_id.is_nil()
&& self.binding.enrollment_generation > 0
&& self.binding.assignment_version > 0
&& digest(&self.updater_policy_sha256)
&& digest(&self.updater_service_configuration_sha256)
&& matches!(
profile.operating_assumption,
ActiveGuestOperation::NoPauseSaveRestoreSnapshotMigrationHostSuspend
)
&& matches!(profile.platform, TrustedPlatform::KvmQemuHypervClock)
&& digest(&profile.platform_provenance_sha256)
&& profile.qualifications.len() == 1
&& profile.qualifications[0].role == rmm_time_attestation::Role::Updater
&& profile.qualifications[0].binary_sha256 == image
&& digest(&profile.qualifications[0].qualification_sha256),
"TIME_UPDATER_OWN_PROFILE"
);
ensure!(
!self.public_keys_hex.is_empty() && self.public_keys_hex.len() <= 8,
"TIME_UPDATER_KEYS"
);
for (id, public) in &self.public_keys_hex {
ensure!(
!id.is_empty()
&& id.len() <= 64
&& id
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b)),
"TIME_UPDATER_KEY_ID"
);
independent_time_key(public, &self.binding.public_key_hex)?;
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum CaptureMode {
Physical { base_error_ns: u64 },
@@ -159,6 +218,10 @@ impl Configuration {
helper_image: &str,
) -> Result<CaptureMode> {
use rmm_time_attestation::Role;
ensure!(
own_role != Role::Updater,
"TIME_UPDATER_OWN_PROFILE_REQUIRED"
);
ensure!(self.key_generation() > 0, "TIME_NATIVE_CONFIG_PROFILE");
let images = [
(Role::Agent, agent_image),
@@ -663,6 +726,8 @@ mod installed {
};
pub const CONFIG_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\time-attestation.json";
pub const UPDATER_CONFIG_PATH: &str =
r"C:\ProgramData\RustDiscoveryUpdater\time-attestation.json";
const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
const MAX_CONFIG_BYTES: usize = 16_384;
const MAX_REPLY_BYTES: usize = 16_384;
@@ -728,12 +793,16 @@ mod installed {
capture_mode: CaptureMode,
pending: Option<Pending>,
latest: Option<HeldEvidence>,
own_updater_configuration: Option<(ipc::PeerPin, String)>,
}
impl SignedClock {
/// Connection generation is later confirmed by the independently
/// signed server response. It is never itself a ready/sync flag.
pub async fn open(role: Role, connection_generation: u64) -> Result<Self> {
ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION");
if role == Role::Updater {
return Self::open_updater(connection_generation).await;
}
let mut failure_fence = ConstructorFailureFence { armed: true };
let (settings, mut files) = crate::helper_system::read_settings()?;
let own_pin = match role {
@@ -830,6 +899,127 @@ mod installed {
capture_mode,
pending: None,
latest: None,
own_updater_configuration: None,
};
value.recheck()?;
process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
.accept_connection(connection_generation)?;
observed(boot_id, capture_mode)?;
failure_fence.armed = false;
Ok(value)
}
/// Stable-updater-only process proof and separately protected profile.
/// It uses its OWN current SCM process/image/token and challenge.
pub async fn open_updater(connection_generation: u64) -> Result<Self> {
ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION");
let mut failure_fence = ConstructorFailureFence { armed: true };
let readers = vec![
ipc::service_sid(crate::update_ipc::SERVICE)?,
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let root = PinnedFile::open_read_shared(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater"),
true,
&readers,
&[],
)?;
let mut policy_file = PinnedFile::open(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"),
false,
&readers,
&[],
false,
)?;
ensure!(
policy_file.file.metadata()?.len() <= 65536,
"TIME_UPDATER_POLICY_SIZE"
);
let mut policy_raw = Vec::new();
(&mut policy_file.file)
.take(65537)
.read_to_end(&mut policy_raw)?;
let (policy, policy_hash) =
rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&policy_raw)
.map_err(anyhow::Error::msg)?;
let own_pin = crate::update_native::services::updater_pin(&policy)?;
ipc::require_self(&own_pin)?;
let own_process = PeerProof::for_service(&own_pin, unsafe {
windows_sys::Win32::System::Threading::GetCurrentProcessId()
})?;
let service_hash =
crate::update_native::services::updater_configuration_sha256(&own_pin)?;
ensure!(
service_hash == policy.updater_service.unit_sha256,
"TIME_UPDATER_SCM_POLICY"
);
let mut config_file =
PinnedFile::open(Path::new(UPDATER_CONFIG_PATH), false, &readers, &[], false)?;
ensure!(
config_file.file.metadata()?.len() <= MAX_CONFIG_BYTES as u64,
"TIME_NATIVE_CONFIG_SIZE"
);
let mut raw = Vec::new();
(&mut config_file.file)
.take(MAX_CONFIG_BYTES as u64 + 1)
.read_to_end(&mut raw)?;
ensure!(raw.len() <= MAX_CONFIG_BYTES, "TIME_NATIVE_CONFIG_SIZE");
let config: UpdaterConfiguration = serde_json::from_slice(&raw)?;
config.validate(&own_pin.binary_sha256)?;
ensure!(
config.updater_policy_sha256 == policy_hash
&& config.updater_service_configuration_sha256 == service_hash
&& config.binding.tenant_id == policy.tenant_id
&& config.binding.asset_id == policy.asset_id
&& config.binding.agent_id == policy.agent_id
&& config.binding.enrollment_generation == policy.enrollment_generation
&& config.binding.assignment_version == policy.assignment_version,
"TIME_UPDATER_POLICY_BINDING"
);
let keys = config
.public_keys_hex
.iter()
.map(|(id, key)| {
Ok((
id.clone(),
independent_time_key(key, &config.binding.public_key_hex)?,
))
})
.collect::<Result<BTreeMap<_, _>>>()?;
let pins = Pins::new(config.key_generation, config.server_instance, keys)?;
process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
.accept_configuration(config.key_generation, &hash(&raw))?;
let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?;
let context = Context {
tenant_id: config.binding.tenant_id,
asset_id: config.binding.asset_id,
agent_id: config.binding.agent_id,
enrollment_generation: config.binding.enrollment_generation,
assignment_generation: config.binding.assignment_version,
connection_generation,
windows_boot_id: boot_id,
verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4),
role: Role::Updater,
helper_image_sha256: None,
binding_schema: 2,
updater_image_sha256: Some(own_pin.binary_sha256.clone()),
};
let capture_mode = CaptureMode::TrustedOsActiveGuest;
let mut value = Self {
verifier: Verifier::new(context, pins)?,
own_process,
files: vec![root, policy_file, config_file],
config_sha256: hash(&raw),
boot_id,
connection_generation,
capture_mode,
pending: None,
latest: None,
own_updater_configuration: Some((own_pin, service_hash)),
};
value.recheck()?;
process()
@@ -843,6 +1033,13 @@ mod installed {
fn recheck(&mut self) -> Result<()> {
let result = (|| {
self.own_process.check()?;
if let Some((pin, expected)) = &self.own_updater_configuration {
ensure!(
crate::update_native::services::updater_configuration_sha256(pin)?
== *expected,
"TIME_UPDATER_SCM_CHANGED"
);
}
for file in &mut self.files {
file.check()?;
}
@@ -1127,6 +1324,22 @@ mod installed {
fn now(&self) -> Result<chrono::DateTime<chrono::Utc>> {
Ok(self.reading()?.own_wall)
}
fn bounds(&self) -> Result<(chrono::DateTime<chrono::Utc>, chrono::DateTime<chrono::Utc>)> {
ensure!(self.generation > 0, "TIME_RUNTIME_NO_CONNECTION");
let mut state = self
.source
.state
.lock()
.map_err(|_| anyhow::anyhow!("TIME_RUNTIME_POISONED"))?;
let (held, clock) = state.as_mut().context("TIME_RUNTIME_NO_EVIDENCE")?;
ensure!(*held == self.generation, "TIME_RUNTIME_CONNECTION_CHANGED");
clock.with_current_comparison(|value| {
Ok((
chrono::DateTime::from_timestamp_nanos(value.interval().lower_utc_ns()),
chrono::DateTime::from_timestamp_nanos(value.interval().upper_utc_ns()),
))
})
}
fn reading(&self) -> Result<rmm_agent_core::reconcile::ClockReading> {
ensure!(self.generation > 0, "TIME_RUNTIME_NO_CONNECTION");
let mut state = self
@@ -1163,12 +1376,60 @@ mod installed {
}
}
#[cfg(all(windows, feature = "system-helper"))]
pub use installed::{BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClock};
pub use installed::{
BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClock, UPDATER_CONFIG_PATH,
};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn updater_profile_binds_only_its_own_image_and_explicit_active_guest_assumption() {
use serde_json::json;
let job = ed25519_dalek::SigningKey::from_bytes(&[71; 32])
.verifying_key()
.to_bytes();
let time = ed25519_dalek::SigningKey::from_bytes(&[72; 32])
.verifying_key()
.to_bytes();
let hex = |raw: [u8; 32]| raw.iter().map(|b| format!("{b:02x}")).collect::<String>();
let value = json!({"schema_version":3,"key_generation":1,"server_instance":Uuid::new_v4(),
"binding":{"tenant_id":Uuid::new_v4(),"asset_id":Uuid::new_v4(),"agent_id":Uuid::new_v4(),"enrollment_generation":1,"assignment_version":1,"public_key_hex":hex(job)},
"public_keys_hex":{"updater-time":hex(time)},"updater_policy_sha256":"12".repeat(32),"updater_service_configuration_sha256":"13".repeat(32),
"trusted_os_active_guest":{"operating_assumption":"active_guest_no_pause_save_restore_snapshot_migration_host_suspend","platform":"kvm_qemu_hypervclock","platform_provenance_sha256":"14".repeat(32),
"qualifications":[{"role":"updater","binary_sha256":"15".repeat(32),"qualification_sha256":"16".repeat(32)}]}});
let config: UpdaterConfiguration = serde_json::from_value(value.clone()).unwrap();
config.validate(&"15".repeat(32)).unwrap();
assert!(config.validate(&"17".repeat(32)).is_err());
for mutation in ["helper", "second", "policy", "assumption"] {
let mut bad = value.clone();
match mutation {
"helper" => {
bad["trusted_os_active_guest"]["qualifications"][0]["role"] =
json!("system_helper")
}
"second" => {
let q = bad["trusted_os_active_guest"]["qualifications"][0].clone();
bad["trusted_os_active_guest"]["qualifications"]
.as_array_mut()
.unwrap()
.push(q);
}
"policy" => bad["updater_policy_sha256"] = json!("bad"),
_ => bad["trusted_os_active_guest"]["operating_assumption"] = json!(true),
}
let result = serde_json::from_value::<UpdaterConfiguration>(bad);
assert!(
match result {
Err(_) => true,
Ok(c) => c.validate(&"15".repeat(32)).is_err(),
},
"mutation {mutation}"
);
}
}
#[test]
fn passive_sampling_requires_a_profile_and_uses_heartbeat_cadence() {
let dir = std::env::temp_dir().join(Uuid::new_v4().to_string());
+268 -59
View File
@@ -6,7 +6,11 @@ use crate::{
};
use anyhow::{Result, ensure};
use serde::Deserialize;
use std::{collections::BTreeSet, io::Read, path::Path};
use std::{
collections::BTreeSet,
io::Read,
path::{Path, PathBuf},
};
use uuid::Uuid;
pub const PATH: &str = r"C:\ProgramData\RustDiscoverySystem\system-qualification.json";
@@ -27,65 +31,31 @@ struct Qualification {
qualification_reference: Uuid,
actions: Vec<String>,
}
pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result<Vec<String>> {
if !clock_qualified || !Path::new(PATH).try_exists()? {
pub fn qualified(
pin: &Pin,
clock_qualified: bool,
reboot_privilege_available: Option<bool>,
) -> Result<Vec<String>> {
if !clock_qualified {
return Ok(vec![]);
}
let readers = [
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let root = Path::new(PATH)
.parent()
.expect("fixed qualification parent");
let mut dir = PinnedFile::open_read_shared(root, true, &readers, &[])?;
let mut file = PinnedFile::open(Path::new(PATH), false, &readers, &[], false)?;
let mut bytes = vec![];
(&mut file.file).take(16385).read_to_end(&mut bytes)?;
ensure!(bytes.len() <= 16384, "system qualification size");
file.check()?;
dir.check()?;
let q: Qualification = serde_json::from_slice(&bytes)?;
ensure!(
q.schema_version == 1
&& (
q.tenant_id,
q.asset_id,
q.agent_id,
q.enrollment_generation,
q.assignment_version
) == (
pin.binding.tenant_id,
pin.binding.asset_id,
pin.binding.agent_id,
pin.binding.enrollment_generation,
pin.binding.assignment_version
)
&& q.agent_binary_sha256 == pin.agent.binary_sha256
&& q.helper_binary_sha256 == pin.helper.binary_sha256
&& q.policy_sha256 == pin.policy_sha256
&& ipc::digest(&q.native_result_sha256)
&& !q.qualification_reference.is_nil()
&& !q.actions.is_empty()
&& q.actions.len() <= 3
&& q.actions.iter().collect::<BTreeSet<_>>().len() == q.actions.len()
&& q.actions.iter().all(|a| matches!(
a.as_str(),
"run_script" | "set_service_state" | "ensure_package"
)),
"system qualification binding"
);
let mut result = PinnedFile::open(Path::new(RESULT_PATH), false, &readers, &[], false)?;
let mut result_bytes = vec![];
(&mut result.file)
.take(65537)
.read_to_end(&mut result_bytes)?;
ensure!(
result_bytes.len() <= 65536
&& rmm_domain::jobs::hash(&result_bytes) == q.native_result_sha256,
"system native qualification evidence hash"
);
result.check()?;
pin.validate()?;
let ordinary = load_ordinary(pin);
let (q, result_bytes) = match ordinary {
Ok(sources) => sources,
Err(error) => match load_catalog(pin) {
Ok(sources) => sources,
Err(catalog_error) => {
if !Path::new(PATH).try_exists()? && !catalog_directory(pin)?.try_exists()? {
return Ok(vec![]);
}
if catalog_directory(pin)?.try_exists()? {
return Err(catalog_error);
}
return Err(error);
}
},
};
let evidence: serde_json::Value = serde_json::from_slice(&result_bytes)?;
ensure!(
evidence["schema_version"] == 1
@@ -111,7 +81,7 @@ pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result<Vec<String>> {
match action.as_str() {
"run_script" => {
ensure!(
settings.schema_version == 3
settings.schema_version >= 3
&& settings.allowed_script_profiles.as_deref()
== Some(&[
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1
@@ -147,8 +117,247 @@ pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result<Vec<String>> {
.map(str::to_string),
);
}
"reboot" => {
ensure!(
settings.schema_version == 4
&& settings.allow_reboot
&& reboot_privilege_available == Some(true),
"system reboot qualification policy or live token"
);
caps.extend(
[
"reboot",
"system:reboot",
rmm_domain::windows_reboot::CAPABILITY,
]
.map(str::to_string),
);
}
_ => unreachable!("validated qualification action"),
}
}
Ok(caps)
}
fn read(path: &Path, max: u64) -> Result<Vec<u8>> {
let readers = [
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let mut dir = PinnedFile::open_read_shared(
path.parent().expect("fixed qualification parent"),
true,
&readers,
&[],
)?;
let mut file = PinnedFile::open(path, false, &readers, &[], false)?;
ensure!(
file.file.metadata()?.len() <= max,
"system qualification file limit"
);
let mut raw = vec![];
(&mut file.file).take(max + 1).read_to_end(&mut raw)?;
ensure!(raw.len() as u64 <= max, "system qualification file limit");
file.check()?;
dir.check()?;
Ok(raw)
}
fn validate(q: &Qualification, pin: &Pin) -> Result<()> {
ensure!(
q.schema_version == 1
&& (
q.tenant_id,
q.asset_id,
q.agent_id,
q.enrollment_generation,
q.assignment_version
) == (
pin.binding.tenant_id,
pin.binding.asset_id,
pin.binding.agent_id,
pin.binding.enrollment_generation,
pin.binding.assignment_version
)
&& q.agent_binary_sha256 == pin.agent.binary_sha256
&& q.helper_binary_sha256 == pin.helper.binary_sha256
&& q.policy_sha256 == pin.policy_sha256
&& ipc::digest(&q.native_result_sha256)
&& !q.qualification_reference.is_nil()
&& !q.actions.is_empty()
&& q.actions.len() <= 4
&& q.actions.iter().collect::<BTreeSet<_>>().len() == q.actions.len()
&& q.actions.iter().all(|a| matches!(
a.as_str(),
"run_script" | "set_service_state" | "ensure_package" | "reboot"
)),
"system qualification binding"
);
Ok(())
}
fn load_ordinary(pin: &Pin) -> Result<(Qualification, Vec<u8>)> {
let raw = read(Path::new(PATH), 16384)?;
let q: Qualification = serde_json::from_slice(&raw)?;
validate(&q, pin)?;
let result = read(Path::new(RESULT_PATH), 65536)?;
ensure!(
rmm_domain::jobs::hash(&result) == q.native_result_sha256,
"system native qualification evidence hash"
);
Ok((q, result))
}
/// Fixed per-device MVP catalog, provisioned only from actual qualification.
/// It is public metadata/deny-only capability evidence, never a job lease.
pub fn catalog_directory(pin: &Pin) -> Result<PathBuf> {
ensure!(
ipc::digest(&pin.agent.binary_sha256)
&& ipc::digest(&pin.helper.binary_sha256)
&& ipc::digest(&pin.policy_sha256),
"system catalog digest"
);
let key = rmm_domain::jobs::hash(&serde_json::to_vec(&(
&pin.agent.binary_sha256,
&pin.helper.binary_sha256,
&pin.policy_sha256,
))?);
Ok(Path::new(r"C:\ProgramData\RustDiscoverySystem\system-qualification-catalog").join(key))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct CatalogEvidence {
schema_version: u32,
source_manifest_sha256: String,
qualification_sha256: String,
native_result_sha256: String,
start_witness_sha256: String,
outcome_sha256: String,
approval_audit_sha256: String,
plan_id: Uuid,
plan_sha256: String,
job_id: Uuid,
attempt_id: Uuid,
grant_id: Uuid,
authorization_id: Uuid,
operation_id: Uuid,
approval_origin: String,
testsimulation: bool,
}
fn load_catalog(pin: &Pin) -> Result<(Qualification, Vec<u8>)> {
use rmm_domain::jobs::hash;
let directory = catalog_directory(pin)?;
let q_raw = read(&directory.join("qualification.json"), 16384)?;
let q: Qualification = serde_json::from_slice(&q_raw)?;
validate(&q, pin)?;
let result = read(&directory.join("native-result.json"), 65536)?;
let source_manifest = read(&directory.join("source-manifest.json"), 512 * 1024)?;
let source_document:serde_json::Value=serde_json::from_slice(&source_manifest)?;
ensure!(source_document.as_array().is_some_and(|a|!a.is_empty())
|| source_document.as_object().is_some_and(|a|!a.is_empty()),"system catalog source manifest");
let evidence_raw = read(&directory.join("prequalification.json"), 16384)?;
let e: CatalogEvidence = serde_json::from_slice(&evidence_raw)?;
ensure!(
e.schema_version == 1
&& e.source_manifest_sha256 == hash(&source_manifest)
&& e.qualification_sha256 == hash(&q_raw)
&& e.native_result_sha256 == hash(&result)
&& e.native_result_sha256 == q.native_result_sha256
&& [
e.plan_id,
e.job_id,
e.attempt_id,
e.grant_id,
e.authorization_id,
e.operation_id
]
.iter()
.all(|id| !id.is_nil())
&& ipc::digest(&e.plan_sha256)
&& matches!(
(e.testsimulation, e.approval_origin.as_str()),
(true, "dev_test_browser_simulation") | (false, "human_webui")
),
"system catalog qualification provenance"
);
let start = read(&directory.join("start-witness.json"), 512 * 1024)?;
let outcome = read(&directory.join("powershell-outcome.json"), 128 * 1024)?;
let audit = read(&directory.join("approval-audit.json"), 65536)?;
ensure!(
hash(&start) == e.start_witness_sha256
&& hash(&outcome) == e.outcome_sha256
&& hash(&audit) == e.approval_audit_sha256,
"system catalog actual evidence bytes"
);
let start_value: serde_json::Value = serde_json::from_slice(&start)?;
let request: rmm_agent_core::auth::Request =
serde_json::from_value(start_value["request"].clone())?;
let at: chrono::DateTime<chrono::Utc> =
serde_json::from_value(start_value["reserved_at"].clone())?;
let boot: Uuid = serde_json::from_value(start_value["previous_boot_id"].clone())?;
let (job, permit) = pin.binding.verify(&request, at)?;
ensure!(
rmm_agent_core::ledger::start_witness_bytes(&permit, &request, boot, at)? == start
&& (
job.job_id,
job.attempt_id,
permit.grant_id,
permit.authorization_id
) == (e.job_id, e.attempt_id, e.grant_id, e.authorization_id)
&& permit.plan_hash == e.plan_sha256
&& job.execution_identity == "system"
&& job.action.full_maintenance(),
"system catalog actual original SYSTEM job"
);
let rmm_domain::jobs::Action::RunScript {
interpreter,
script_utf8,
..
} = &job.action
else {
anyhow::bail!("system catalog PowerShell qualification required")
};
let parsed: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&outcome)?;
ensure!(
rmm_domain::reconciliation::canonical_outcome_bytes(&parsed)? == outcome
&& parsed.state == "succeeded"
&& parsed.exit_code == Some(0)
&& parsed.error_code.is_empty()
&& !parsed.output_truncated
&& !parsed.reboot_required
&& interpreter == "powershell"
&& parsed.evidence["postconditions_passed"] == true
&& parsed.evidence["execution_sid"] == "S-1-5-18"
&& parsed.evidence["privileged_script_profile"] == "full_maintenance_v1"
&& parsed.evidence["script_sha256"] == hash(script_utf8.as_bytes())
&& parsed.evidence["execution_context"]["schema_version"] == 1
&& parsed.evidence["execution_context"]["tenant_id"]
== pin.binding.tenant_id.to_string()
&& parsed.evidence["execution_context"]["asset_id"] == pin.binding.asset_id.to_string()
&& parsed.evidence["execution_context"]["agent_id"] == pin.binding.agent_id.to_string()
&& parsed.evidence["execution_context"]["agent_binary_sha256"]
== pin.agent.binary_sha256
&& parsed.evidence["execution_context"]["helper_binary_sha256"]
== pin.helper.binary_sha256
&& parsed.evidence["execution_context"]["policy_sha256"] == pin.policy_sha256
&& parsed.evidence["execution_context"]["binding_sha256"]
== ipc::binding_hash(&pin.binding)?
&& parsed.evidence["execution_context"]["rechecked_at_finish"] == true,
"system catalog actual PowerShell outcome"
);
let audit: serde_json::Value = serde_json::from_slice(&audit)?;
ensure!(
audit["tenant_id"] == pin.binding.tenant_id.to_string()
&& audit["event_type"] == "plan_authorization"
&& audit["event_id"]
.as_str()
.is_some_and(|s| Uuid::parse_str(s).is_ok_and(|id| !id.is_nil()))
&& audit["principal"]
.as_str()
.is_some_and(|s| !s.is_empty() && s.len() <= 256)
&& audit["data"]["plan_id"] == e.plan_id.to_string()
&& audit["data"]["plan_hash"] == e.plan_sha256
&& audit["data"]["operation_id"] == e.operation_id.to_string()
&& audit["data"]["decision"] == "approve"
&& audit["data"]["approval_origin"] == e.approval_origin
&& audit["data"]["testsimulation"] == e.testsimulation,
"system catalog actual WebUI approval audit"
);
Ok((q, result))
}
@@ -0,0 +1,670 @@
//! Independently verified SYSTEM admission for an approved code-pair update.
//! This never inherits script, MSI or SCM permissions. Its nonterminal ACK is
//! flushed before the original delegation is dispatched once to the updater.
use crate::{
helper_ipc::{self as ipc, PeerProof},
helper_system::{LedgerGuard, WindowsBoot},
signed_clock::BoundClock,
update_cache, update_ipc,
update_native::{
Budget, DurableEffectFence, Effect, Role,
files::{self, StageDescriptor, Staged},
services, transition,
},
update_state::{BoundFile, Bundle, LedgerIdentity, QualifiedRegistry, RetainedSet},
update_trust::{Protected, TrustState},
};
use anyhow::{Context, Result, ensure};
use rmm_agent_core::{
auth::{Binding, Request},
crypto::DalekVerifier,
helper_reconcile::{BootSource, ExecutorLedgerGuard, HelperSync},
reconcile::SyncClock,
update_handoff::{PreparedHandoff, UpdateAdmissionGuard},
};
use rmm_domain::{
agent_update::{ParticipantRole, PeerPinTransition, ResolvedAgentUpdate, UpdateDelegation},
jobs::{Action, hash},
};
use rmm_updater_handoff::{AttemptBinding, CodePair, FileTransition, Handoff, PinTransition};
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::{cell::RefCell, path::Path, time::Duration};
use uuid::Uuid;
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Accepted {
pub schema_version: u32,
pub operation: String,
pub grant_id: Uuid,
pub owner_nonce: Uuid,
pub handoff_sha256: String,
pub original_request_sha256: String,
pub ready: bool,
pub terminal: bool,
}
impl Accepted {
pub fn matches(&self, request: &Request, grant: Uuid) -> Result<()> {
ensure!(
self.schema_version == 1
&& self.operation == "agent_update_handoff_accepted_v1"
&& self.grant_id == grant
&& !self.owner_nonce.is_nil()
&& ipc::digest(&self.handoff_sha256)
&& self.original_request_sha256 == hash(&serde_json::to_vec(request)?)
&& !self.ready
&& !self.terminal,
"UPDATE_TYPED_HANDOFF_ACK"
);
Ok(())
}
}
pub fn initialize(db: &Connection, guard: &impl ExecutorLedgerGuard) -> Result<()> {
rmm_agent_core::update_handoff::initialize(db, guard)?;
db.execute_batch("CREATE TABLE IF NOT EXISTS windows_update_stage_claims(grant_id TEXT NOT NULL,role TEXT NOT NULL,owner_nonce TEXT NOT NULL,original_request_sha256 TEXT NOT NULL,claimed_at TEXT NOT NULL,PRIMARY KEY(grant_id,role));
CREATE TABLE IF NOT EXISTS windows_update_stage_observations(grant_id TEXT NOT NULL,role TEXT NOT NULL,observation_sha256 TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(grant_id,role),FOREIGN KEY(grant_id,role) REFERENCES windows_update_stage_claims(grant_id,role));
CREATE TRIGGER IF NOT EXISTS windows_update_stage_claim_no_update BEFORE UPDATE ON windows_update_stage_claims BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END;
CREATE TRIGGER IF NOT EXISTS windows_update_stage_claim_no_delete BEFORE DELETE ON windows_update_stage_claims BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END;
CREATE TRIGGER IF NOT EXISTS windows_update_stage_obs_no_update BEFORE UPDATE ON windows_update_stage_observations BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END;
CREATE TRIGGER IF NOT EXISTS windows_update_stage_obs_no_delete BEFORE DELETE ON windows_update_stage_observations BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END;")?;
guard.check(db)
}
pub struct Local<'a> {
pub binding: &'a Binding,
pub guard: &'a LedgerGuard,
pub clock: &'a BoundClock,
pub boot: &'a WindowsBoot,
pub pin: &'a ipc::Pin,
pub generation: u64,
}
fn fresh(
local: &Local<'_>,
request: &Request,
) -> Result<(
rmm_domain::jobs::JobPayload,
rmm_domain::jobs::ExecutionPermitPayload,
)> {
local.clock.require_generation(local.generation)?;
let (lower, upper) = local.clock.bounds()?;
let (job, grant) = local.binding.verify(request, lower)?;
local.binding.verify(request, upper)?;
ensure!(
job.execution_identity == "system"
&& job.max_runtime_seconds == 600
&& matches!(&job.action,Action::UpdateAgent{update} if update.validate() && update.execution_identity()==Some("system")),
"UPDATE_ADMISSION_ACTION"
);
Ok((job, grant))
}
struct StageFence<'a, 'b> {
local: &'a Local<'b>,
db: &'a Connection,
sync: &'a HelperSync<DalekVerifier>,
request: &'a Request,
grant: Uuid,
nonce: Uuid,
trust: &'a TrustState,
pending: Option<String>,
}
impl DurableEffectFence for StageFence<'_, '_> {
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
let Effect::StageFile { role } = effect else {
anyhow::bail!("UPDATE_PREPARE_STAGE_ONLY");
};
ensure!(self.pending.is_none(), "UPDATE_STAGE_PENDING");
self.local.guard.check(self.db)?;
fresh(self.local, self.request)?;
self.trust.recheck_protected()?;
ensure!(
self.sync.can_start(
self.db,
self.local.guard,
self.local.generation,
self.local.clock,
self.local.boot
),
"UPDATE_STAGE_SIGNED_SYNC_REQUIRED"
);
let role = serde_json::to_string(role)?;
self.db.execute(
"INSERT INTO windows_update_stage_claims VALUES(?1,?2,?3,?4,?5)",
rusqlite::params![
self.grant.to_string(),
role,
self.nonce.to_string(),
hash(&serde_json::to_vec(self.request)?),
self.local.clock.now()?.to_rfc3339()
],
)?;
self.pending = Some(role);
Ok(())
}
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
let Effect::StageFile { role } = effect else {
anyhow::bail!("UPDATE_PREPARE_STAGE_ONLY");
};
let role = serde_json::to_string(role)?;
ensure!(
self.pending.as_ref() == Some(&role) && ipc::digest(observation),
"UPDATE_STAGE_OBSERVATION"
);
self.local.guard.check(self.db)?;
fresh(self.local, self.request)?;
self.db.execute(
"INSERT INTO windows_update_stage_observations VALUES(?1,?2,?3,?4)",
rusqlite::params![
self.grant.to_string(),
role,
observation,
self.local.clock.now()?.to_rfc3339()
],
)?;
self.pending = None;
Ok(())
}
}
pub struct Prepared<'a> {
local: Local<'a>,
request: Request,
update: ResolvedAgentUpdate,
bundle: Bundle,
trust: TrustState,
registry: QualifiedRegistry,
retained: RetainedSet,
ledger: LedgerIdentity,
running: RefCell<services::Running>,
updater: RefCell<PeerProof>,
original: RefCell<PeerProof>,
stages: Vec<Staged>,
protected: Vec<Protected>,
sqlite: usize,
}
impl<'a> Prepared<'a> {
pub fn new(
db: &Connection,
local: Local<'a>,
sync: &HelperSync<DalekVerifier>,
request: &Request,
) -> Result<Self> {
local.guard.check(db)?;
let (job, permit) = fresh(&local, request)?;
let Action::UpdateAgent { update } = &job.action else {
unreachable!()
};
let trust = TrustState::load_prepared(update, local.binding, local.clock)?;
trust.qualify_history(db, local.guard, local.binding)?;
initialize(db, local.guard)?;
let boot = local.boot.current_boot()?;
let budget = Budget::new(
local.boot,
boot,
(permit.start_before - local.clock.now()?).to_std()?,
)?;
let registry = QualifiedRegistry::load(&trust)?;
let running = services::Running::observe(
[local.pin.agent.clone(), local.pin.helper.clone()],
&budget,
)?;
let (updater, updater_id) = services::observe_updater(trust.policy(), &budget)?;
let ipc_pin = update_ipc::Pin {
schema_version: 1,
binding: local.binding.clone(),
policy_sha256: update.updater.policy_sha256.clone(),
helper: local.pin.helper.clone(),
updater: services::updater_pin(trust.policy())?,
};
let description = update_ipc::exchange(
&ipc_pin,
&update_ipc::Request::Describe {},
Duration::from_secs(5),
)?;
ensure!(
description.state == update_ipc::State::Described
&& description.head_sha256.is_none()
&& description.updater == updater_id,
"UPDATE_ADMISSION_LIVE_UPDATER"
);
registry.verify_observed(
&running.proofs(),
&services::updater_configuration_sha256(&ipc_pin.updater)?,
)?;
let (original, helper_id) =
update_ipc::observe(&local.pin.helper, ParticipantRole::WindowsHelper)?;
ensure!(
helper_id.pid == std::process::id(),
"UPDATE_ACTUAL_SYSTEM_HELPER"
);
let manifest = update.manifest().map_err(anyhow::Error::msg)?;
ensure!(
manifest.artifacts[0].sha256 != update.predecessor.agent_sha256
|| manifest.artifacts[1].sha256 != update.predecessor.helper_sha256,
"UPDATE_NO_CODE_CHANGE"
);
let readers = [
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let mut protected = Vec::new();
let (f, settings) =
Protected::read_shared(Path::new(Role::Settings.target()), 32768, &readers)?;
protected.push(f);
let (f, pin) = Protected::read_shared(Path::new(Role::Pin.target()), 32768, &readers)?;
protected.push(f);
let (f, time) =
Protected::read_shared(Path::new(Role::TimeProfile.target()), 32768, &readers)?;
protected.push(f);
let (f, candidate_time) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\candidate-time-profile.json"),
32768,
)?;
protected.push(f);
let rendered = transition::render(transition::Inputs {
settings: &settings,
pin: &pin,
time_profile: &time,
qualified_candidate_time_profile: &candidate_time,
target_agent_sha256: &manifest.artifacts[0].sha256,
target_helper_sha256: &manifest.artifacts[1].sha256,
})?;
ensure!(
rendered.proof() == &update.peer_pin_transition,
"UPDATE_APPROVED_WINDOWS_RENDER_CHANGED"
);
let nonce = Uuid::new_v4();
let mut fence = StageFence {
local: &local,
db,
sync,
request,
grant: permit.grant_id,
nonce,
trust: &trust,
pending: None,
};
let mut stages = Vec::new();
for (role, artifact, expected_old) in [
(
Role::Agent,
&manifest.artifacts[0],
&update.predecessor.agent_sha256,
),
(
Role::Helper,
&manifest.artifacts[1],
&update.predecessor.helper_sha256,
),
] {
let original = files::observe(role, &budget)?;
ensure!(
&original.sha256 == expected_old,
"UPDATE_PREDECESSOR_BINARY_CHANGED"
);
let mut source = update_cache::Source::open(artifact)?;
stages.push(Staged::create(
StageDescriptor {
role,
owner_nonce: nonce,
original: &original,
replacement_sha256: &artifact.sha256,
replacement_bytes: artifact.bytes,
},
&mut source.file,
&budget,
&mut fence,
)?);
source.check()?;
}
for (role, bytes) in [
(Role::Settings, rendered.settings_bytes()),
(Role::Pin, rendered.pin_bytes()),
(Role::TimeProfile, rendered.time_profile_bytes()),
] {
let original = files::observe(role, &budget)?;
stages.push(Staged::create(
StageDescriptor {
role,
owner_nonce: nonce,
original: &original,
replacement_sha256: &hash(bytes),
replacement_bytes: bytes.len() as u64,
},
&mut std::io::Cursor::new(bytes),
&budget,
&mut fence,
)?);
}
drop(fence);
let retained = RetainedSet::capture()?;
let ledger = local.guard.update_identity(db)?;
let bound_files = stages
.iter()
.zip([
Role::Agent,
Role::Helper,
Role::Settings,
Role::Pin,
Role::TimeProfile,
])
.map(|(s, role)| BoundFile {
role,
original: s.original().clone(),
staged: s.staged().clone(),
})
.collect::<Vec<_>>();
let PeerPinTransition::WindowsCodePairV1 {
old_pin_sha256,
new_pin_sha256,
..
} = &update.peer_pin_transition
else {
anyhow::bail!("UPDATE_WINDOWS_TRANSITION_REQUIRED");
};
let (helper_journal,checkpoint,decision,agent_journal,generation):(String,u64,String,String,u64)=db.query_row("SELECT journal_id,checkpoint,last_decision,agent_journal_id,generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?)))?;
let (sync_response, sync_request): (Vec<u8>, Vec<u8>) = db.query_row(
"SELECT response,request FROM helper_sync_decisions WHERE decision_id=?1",
[&decision],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
let now = local.clock.now()?;
let consumed_at = u64::try_from(now.timestamp())?;
let start = rmm_agent_core::ledger::start_witness_bytes(&permit, request, boot, now)?;
let h = Handoff {
schema_version: 2,
attempt: AttemptBinding {
tenant_id: permit.tenant_id,
asset_id: permit.asset_id,
agent_id: permit.agent_id,
enrollment_generation: permit.enrollment_generation,
assignment_version: permit.assignment_version,
plan_id: permit
.agent_update_plan_id
.context("UPDATE_PLAN_ID_REQUIRED")?,
plan_sha256: permit.plan_hash.clone(),
job_id: permit.job_id,
attempt_id: permit.attempt_id,
job_payload_sha256: permit.job_payload_hash.clone(),
grant_id: permit.grant_id,
authorization_id: permit.authorization_id,
original_request_sha256: hash(&serde_json::to_vec(request)?),
original_start_witness_sha256: hash(&start),
},
agent_journal_id: agent_journal.parse()?,
helper_journal_id: helper_journal.parse()?,
helper_checkpoint: checkpoint,
previous_decision_id: decision.parse()?,
boot_id: boot,
connection_generation: generation,
owner_nonce: nonce,
updater_sha256: update.updater.binary_sha256.clone(),
updater_policy_sha256: update.updater.policy_sha256.clone(),
predecessor_record_sha256: update.predecessor.installed_record_sha256.clone(),
retained_state_sha256: retained.sha256()?,
ledger_identity_sha256: ledger.sha256()?,
staged_files_sha256: hash(&serde_json::to_vec(&bound_files)?),
predecessor: CodePair {
manifest_sha256: update.predecessor.manifest_sha256.clone(),
agent_sha256: update.predecessor.agent_sha256.clone(),
helper_sha256: update.predecessor.helper_sha256.clone(),
pin_sha256: old_pin_sha256.clone(),
},
target: CodePair {
manifest_sha256: update.manifest_sha256.clone(),
agent_sha256: manifest.artifacts[0].sha256.clone(),
helper_sha256: manifest.artifacts[1].sha256.clone(),
pin_sha256: new_pin_sha256.clone(),
},
pin_transition: PinTransition::WindowsCodePairClockV1,
pin_transition_sha256: hash(&serde_json::to_vec(&update.peer_pin_transition)?),
files: bound_files
.iter()
.map(|f| FileTransition {
role: f.role.handoff_role(),
old_sha256: f.original.sha256.clone(),
new_sha256: f.staged.sha256.clone(),
})
.collect(),
stop_set: vec![
rmm_updater_handoff::Service::WindowsAgent,
rmm_updater_handoff::Service::WindowsHelper,
],
consumed_at,
finish_before: consumed_at
.checked_add(600)
.context("UPDATE_FINISH_OVERFLOW")?,
};
let delegation = UpdateDelegation {
schema_version: 1,
handoff_sha256: hash(&h.bytes()?),
owner_nonce: nonce,
boot_id: boot,
prepared_at: now,
updater: updater_id,
original_helper: helper_id,
};
let bundle = Bundle {
schema_version: 1,
original: request.clone(),
handoff_record: h.bytes()?,
delegation,
files: bound_files,
retained: retained.proofs().to_vec(),
ledger: ledger.clone(),
signed_sync_response: sync_response,
signed_sync_request: sync_request,
};
bundle.write_before_consume()?;
let prepared = Self {
local,
request: request.clone(),
update: update.as_ref().clone(),
bundle,
trust,
registry,
retained,
ledger,
running: RefCell::new(running),
updater: RefCell::new(updater),
original: RefCell::new(original),
stages,
protected,
sqlite: unsafe { db.handle() } as usize,
};
prepared.check(db)?;
Ok(prepared)
}
pub fn consume(
&self,
db: &mut Connection,
sync: &mut HelperSync<DalekVerifier>,
) -> Result<Accepted> {
let h = self.bundle.validate()?;
sync.begin_update_handoff(
db,
self,
self.local.generation,
&PreparedHandoff {
request: &self.request,
handoff: &h,
delegation: &self.bundle.delegation,
recorded_at: self.bundle.delegation.prepared_at,
},
self.local.clock,
self.local.boot,
)?;
Ok(Accepted {
schema_version: 1,
operation: "agent_update_handoff_accepted_v1".into(),
grant_id: h.attempt.grant_id,
owner_nonce: h.owner_nonce,
handoff_sha256: hash(&h.bytes()?),
original_request_sha256: h.attempt.original_request_sha256,
ready: false,
terminal: false,
})
}
pub fn into_activation(self) -> Activation {
Activation {
pin: update_ipc::Pin {
schema_version: 1,
binding: self.local.binding.clone(),
policy_sha256: self.update.updater.policy_sha256.clone(),
helper: self.local.pin.helper.clone(),
updater: services::updater_pin(self.trust.policy()).expect("validated updater pin"),
},
bundle: self.bundle,
trust: self.trust,
registry: self.registry,
retained: self.retained,
running: self.running,
updater: self.updater,
original: self.original,
_stages: self.stages,
_protected: self.protected,
}
}
}
impl ExecutorLedgerGuard for Prepared<'_> {
fn check(&self, db: &Connection) -> Result<()> {
self.local.guard.check(db)?;
ensure!(
unsafe { db.handle() } as usize == self.sqlite
&& self.local.guard.update_identity(db)?.sha256()? == self.ledger.sha256()?,
"UPDATE_ADMISSION_ORIGINAL_LEDGER"
);
self.trust
.recheck_prepared(&self.update, self.local.clock)?;
self.registry.verify()?;
self.retained.verify()?;
let h = self.bundle.validate()?;
let budget = Budget::new(self.local.boot, h.boot_id, Duration::from_secs(1))?;
self.running.try_borrow_mut()?.check(&budget)?;
self.updater.try_borrow_mut()?.check()?;
self.original.try_borrow_mut()?.check()?;
for f in &self.protected {
f.verify()?;
}
for f in &self.bundle.files {
ensure!(
files::observe_bound(f.role, h.owner_nonce, files::Location::Stage, &budget)?
== f.staged,
"UPDATE_ADMISSION_STAGED_CHANGED"
);
}
Ok(())
}
}
impl UpdateAdmissionGuard for Prepared<'_> {
fn health_public_key(&self) -> Result<[u8; 32]> {
Ok(self.trust.health_public_key())
}
fn verify_prepared_update(
&self,
request: &Request,
h: &Handoff,
d: &UpdateDelegation,
_now: chrono::DateTime<chrono::Utc>,
) -> Result<()> {
ensure!(
serde_json::to_vec(request)? == serde_json::to_vec(&self.request)?
&& h.bytes()? == self.bundle.handoff_record
&& d == &self.bundle.delegation,
"UPDATE_ADMISSION_EXACT_PREPARED"
);
Ok(())
}
}
/// Retains all original process/file witnesses until the one dispatch finishes
/// or the original helper is stopped. No restart/replay constructor exists.
pub struct Activation {
pin: update_ipc::Pin,
bundle: Bundle,
trust: TrustState,
registry: QualifiedRegistry,
retained: RetainedSet,
running: RefCell<services::Running>,
updater: RefCell<PeerProof>,
original: RefCell<PeerProof>,
_stages: Vec<Staged>,
_protected: Vec<Protected>,
}
impl Activation {
pub fn dispatch_after_reply(
self,
db: &Connection,
guard: &LedgerGuard,
clock: &BoundClock,
boot: &WindowsBoot,
) -> Result<()> {
guard.check(db)?;
let h = self.bundle.validate()?;
let raw: Vec<u8> = db.query_row(
"SELECT record FROM agent_update_handoffs WHERE grant_id=?1",
[h.attempt.grant_id.to_string()],
|r| r.get(0),
)?;
ensure!(
raw == h.bytes()?
&& rmm_agent_core::update_handoff::read_delegation(db, h.attempt.grant_id)?
== self.bundle.delegation,
"UPDATE_DISPATCH_ORIGINAL_CONSUMED"
);
let now = u64::try_from(clock.now()?.timestamp())?;
ensure!(
now < h.finish_before && boot.current_boot()? == h.boot_id,
"UPDATE_DISPATCH_DEADLINE_BOOT"
);
self.trust.recheck_protected()?;
self.registry.verify()?;
self.retained.verify()?;
let budget = Budget::new(boot, h.boot_id, Duration::from_secs(5))?;
self.running.try_borrow_mut()?.check(&budget)?;
self.original.try_borrow_mut()?.check()?;
self.updater.try_borrow_mut()?.check()?;
let reply = update_ipc::exchange(
&self.pin,
&update_ipc::Request::Activate {
grant_id: h.attempt.grant_id,
owner_nonce: h.owner_nonce,
handoff_sha256: hash(&h.bytes()?),
},
Duration::from_secs(5),
)?;
ensure!(
reply.state == update_ipc::State::Inflight
&& reply.updater == self.bundle.delegation.updater,
"UPDATE_DISPATCH_NOT_ACCEPTED"
);
Ok(())
}
}
/// Presence is a separate protected deny-only local update policy, never a
/// consequence of Full/SCM/MSI settings. This does not advertise capability,
/// attest readiness or authorize an effect.
pub fn configured(binding: &Binding) -> bool {
(|| -> Result<()> {
let (_guard, raw) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"),
65536,
)?;
let (p, _) = rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw)
.map_err(anyhow::Error::msg)?;
ensure!(
p.schema_version == 2
&& p.tenant_id == binding.tenant_id
&& p.asset_id == binding.asset_id
&& p.agent_id == binding.agent_id
&& p.enrollment_generation == binding.enrollment_generation
&& p.assignment_version == binding.assignment_version,
"UPDATE_LOCAL_POLICY_BINDING"
);
Ok(())
})()
.is_ok()
}
pub fn permits_denial(binding: &Binding, job: &rmm_domain::jobs::JobPayload) -> bool {
configured(binding)
&& job.execution_identity == "system"
&& job.max_runtime_seconds == 600
&& matches!(&job.action,Action::UpdateAgent{update} if update.validate() && update.execution_identity()==Some("system"))
}
+221
View File
@@ -0,0 +1,221 @@
//! Public signed artifact bytes only, before any startgrant is requested.
//! This cache grants no execution authority. SYSTEM reopens and hashes each
//! source independently; the writable LocalService source is never a trust pin.
use crate::helper_ipc::{self as ipc, PinnedFile};
use anyhow::{Context, Result, ensure};
use rmm_domain::agent_update::{ArtifactDescriptor, ReleaseManifest};
use sha2::{Digest, Sha256};
use std::{
fs::{File, OpenOptions},
io::{Read, Seek, SeekFrom, Write},
mem::zeroed,
os::windows::{
fs::OpenOptionsExt,
io::{AsRawHandle, FromRawHandle},
},
path::{Path, PathBuf},
ptr,
};
use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*};
pub const ROOT: &str = r"C:\ProgramData\RustDiscovery\state\update-stage";
fn path(a: &ArtifactDescriptor, partial: bool) -> Result<PathBuf> {
ensure!(
!a.artifact_id.is_nil()
&& ipc::digest(&a.sha256)
&& a.bytes > 0
&& a.bytes <= rmm_domain::agent_update::MAX_ARTIFACT_BYTES,
"UPDATE_CACHE_DESCRIPTOR"
);
Ok(Path::new(ROOT).join(format!(
"{}.{}",
a.sha256,
if partial { "part" } else { "bin" }
)))
}
fn regular(f: &File, dir: bool) -> Result<()> {
let mut i: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
ensure!(
unsafe { GetFileInformationByHandle(f.as_raw_handle(), &mut i) } != 0
&& i.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
&& (i.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == dir
&& (dir || i.nNumberOfLinks == 1),
"UPDATE_CACHE_FILE_TYPE"
);
Ok(())
}
fn parents(p: &Path) -> Result<Vec<File>> {
let mut guards = Vec::new();
for parent in p.ancestors().skip(1) {
let h = unsafe {
CreateFileW(
ipc::wide(parent).as_ptr(),
FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
ptr::null_mut(),
)
};
ensure!(h != INVALID_HANDLE_VALUE, "UPDATE_CACHE_NOT_PROVISIONED");
let file = unsafe { File::from_raw_handle(h) };
regular(&file, true)?;
guards.push(file);
}
Ok(guards)
}
fn verify(file: &mut File, a: &ArtifactDescriptor) -> Result<()> {
regular(file, false)?;
ensure!(file.metadata()?.len() == a.bytes, "UPDATE_CACHE_LENGTH");
file.seek(SeekFrom::Start(0))?;
let mut digest = Sha256::new();
let mut bytes = [0; 65536];
let mut length = 0u64;
loop {
let n = file.read(&mut bytes)?;
if n == 0 {
break;
}
length += n as u64;
ensure!(length <= a.bytes, "UPDATE_CACHE_LENGTH");
digest.update(&bytes[..n]);
}
ensure!(
length == a.bytes && format!("{:x}", digest.finalize()) == a.sha256,
"UPDATE_CACHE_DIGEST"
);
file.seek(SeekFrom::Start(0))?;
Ok(())
}
/// An already open independently hashed source. Parent and source handles deny
/// replacement and the source denies data writes until protected staging ends.
pub struct Source {
pub file: File,
_parents: Vec<File>,
identity: ipc::FileIdentity,
descriptor: ArtifactDescriptor,
}
impl Source {
pub fn open(a: &ArtifactDescriptor) -> Result<Self> {
let p = path(a, false)?;
let parents = parents(&p)?;
let mut file = OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(&p)
.context("UPDATE_CACHE_MISSING")?;
verify(&mut file, a)?;
Ok(Self {
identity: ipc::file_identity(&file)?,
file,
_parents: parents,
descriptor: a.clone(),
})
}
pub fn check(&mut self) -> Result<()> {
ensure!(
ipc::file_identity(&self.file)? == self.identity,
"UPDATE_CACHE_IDENTITY"
);
verify(&mut self.file, &self.descriptor)
}
}
pub fn configured() -> bool {
crate::native::private_path(Path::new(ROOT), true).is_ok()
}
pub fn ready(m: &ReleaseManifest) -> Result<bool> {
ensure!(m.validate(), "UPDATE_CACHE_MANIFEST");
for a in &m.artifacts {
if !path(a, false)?.try_exists()? {
return Ok(false);
}
let _ = Source::open(a)?;
}
Ok(true)
}
/// The only resumable operation is a bounded public byte download. No journal,
/// request, consumption, handoff or effect is resumed by this cache.
pub struct Download {
file: File,
descriptor: ArtifactDescriptor,
received: u64,
_parents: Vec<File>,
_root: PinnedFile,
}
impl Download {
pub fn begin(a: &ArtifactDescriptor) -> Result<Self> {
crate::native::require_local_service()?;
let p = path(a, true)?;
let parents = parents(&p)?;
crate::native::private_path(Path::new(ROOT), true)?;
let root = PinnedFile::open(
Path::new(ROOT),
true,
&[crate::native::service_sid()?],
&[crate::native::service_sid()?],
false,
)?;
let mut file = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(&p)?;
regular(&file, false)?;
crate::native::private_path(&p, false)?;
let received = file.metadata()?.len();
ensure!(received <= a.bytes, "UPDATE_CACHE_PARTIAL_OVERSIZE");
file.seek(SeekFrom::Start(received))?;
Ok(Self {
file,
descriptor: a.clone(),
received,
_parents: parents,
_root: root,
})
}
pub fn offset(&self) -> u64 {
self.received
}
pub fn append(&mut self, offset: u64, bytes: &[u8]) -> Result<()> {
ensure!(
offset == self.received
&& !bytes.is_empty()
&& bytes.len() <= 512 * 1024
&& self.received + bytes.len() as u64 <= self.descriptor.bytes,
"UPDATE_CACHE_CHUNK"
);
self._root.check()?;
self.file.write_all(bytes)?;
self.received += bytes.len() as u64;
Ok(())
}
pub fn finish(mut self) -> Result<()> {
ensure!(
self.received == self.descriptor.bytes,
"UPDATE_CACHE_INCOMPLETE"
);
self.file.sync_all()?;
verify(&mut self.file, &self.descriptor)?;
self._root.check()?;
let src = path(&self.descriptor, true)?;
let dst = path(&self.descriptor, false)?;
drop(self.file);
// No replace, no delete of an existing source, and no shell invocation.
ensure!(
unsafe {
MoveFileExW(
ipc::wide(src).as_ptr(),
ipc::wide(dst).as_ptr(),
MOVEFILE_WRITE_THROUGH,
)
} != 0,
"UPDATE_CACHE_PUBLISH"
);
let _ = Source::open(&self.descriptor)?;
Ok(())
}
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,301 @@
//! Reverse stable-updater -> SYSTEM-helper control. A distinct fixed endpoint
//! never broadens the LocalService pipe into an updater effect API. Native
//! control still requires the ORIGINAL guarded journal and phase-specific proof.
use crate::{
helper_ipc::{self as ipc, PeerProof},
update_ipc::Pin,
};
use anyhow::{Result, ensure};
use rmm_agent_core::update_handoff::{
NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService,
};
use std::{
mem::size_of,
os::windows::io::{AsRawHandle, OwnedHandle},
ptr,
time::{Duration, Instant},
};
use windows_sys::Win32::{
Foundation::*,
Security::*,
Storage::FileSystem::*,
System::{Pipes::*, Threading::*},
};
pub const PIPE: &str = r"\\.\pipe\RustDiscovery-System-Update-v1";
fn request_valid(pin: &Pin, r: &NativeControlRequest) -> Result<()> {
ensure!(
r.operation == "agent_update_control_v1"
&& r.schema_version == 1
&& !r.challenge.is_nil()
&& r.tenant_id == pin.binding.tenant_id
&& r.asset_id == pin.binding.asset_id
&& r.agent_id == pin.binding.agent_id
&& r.enrollment_generation == pin.binding.enrollment_generation
&& r.assignment_version == pin.binding.assignment_version
&& !r.grant_id.is_nil()
&& !r.owner_nonce.is_nil()
&& ipc::digest(&r.handoff_sha256),
"UPDATE_CONTROL_REQUEST_BINDING"
);
match &r.method {
NativeControlOperation::ClaimStop {
expected_head_sha256,
service,
} => ensure!(
ipc::digest(expected_head_sha256)
&& matches!(
service,
NativeService::WindowsAgent | NativeService::WindowsHelper
),
"UPDATE_CONTROL_WINDOWS_STOP_ONLY"
),
NativeControlOperation::Health { receipt } => ensure!(
!receipt.payload.is_empty()
&& receipt.payload.len() <= 4096
&& receipt.signature.len() == 64,
"UPDATE_CONTROL_HEALTH_LIMIT"
),
NativeControlOperation::ObserveStarts {
services,
observation_sha256,
} => ensure!(
services.len() == 2 && ipc::digest(observation_sha256),
"UPDATE_CONTROL_START_LIMIT"
),
NativeControlOperation::ReadOriginal | NativeControlOperation::Finalize => {}
}
Ok(())
}
fn reply_valid(r: &NativeControlRequest, v: &NativeControlReply) -> Result<()> {
ensure!(
v.schema_version == 1
&& v.challenge == r.challenge
&& v.tenant_id == r.tenant_id
&& v.asset_id == r.asset_id
&& v.agent_id == r.agent_id
&& v.enrollment_generation == r.enrollment_generation
&& v.assignment_version == r.assignment_version
&& v.grant_id == r.grant_id
&& v.owner_nonce == r.owner_nonce
&& v.handoff_sha256 == r.handoff_sha256
&& !v.ready,
"UPDATE_CONTROL_REPLY_BINDING"
);
if let Some(proof) = &v.proof {
ensure!(
proof.delegation.owner_nonce == r.owner_nonce
&& proof.delegation.handoff_sha256 == r.handoff_sha256,
"UPDATE_CONTROL_PROOF_BINDING"
);
}
ensure!(
v.original_start_base64url
.as_ref()
.is_none_or(|s| s.len() <= 699051)
&& v.original_outcome_base64url
.as_ref()
.is_none_or(|s| s.len() <= 699051),
"UPDATE_CONTROL_REPLY_LIMIT"
);
match (
&v.pre_stop_sync_request_base64url,
&v.pre_stop_sync_response_base64url,
) {
(None, None) => {}
(Some(request), Some(response)) => {
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
ensure!(
matches!(r.method, NativeControlOperation::ReadOriginal)
&& request.len() <= 699051
&& response.len() <= 699051,
"UPDATE_CONTROL_PRESTOP_SCOPE_LIMIT"
);
for raw in [request, response] {
let decoded = URL_SAFE_NO_PAD.decode(raw)?;
ensure!(
!decoded.is_empty()
&& decoded.len() <= 512 * 1024
&& URL_SAFE_NO_PAD.encode(&decoded) == *raw,
"UPDATE_CONTROL_PRESTOP_CANONICAL"
);
}
}
_ => anyhow::bail!("UPDATE_CONTROL_PRESTOP_PAIR_REQUIRED"),
}
match &r.method {
NativeControlOperation::ReadOriginal => ensure!(
v.original_start_base64url.is_some()
&& v.original_outcome_base64url.is_none()
&& v.claim.is_none(),
"UPDATE_CONTROL_READ_REPLY"
),
NativeControlOperation::ClaimStop { .. } => ensure!(
v.claim.is_some()
&& v.original_start_base64url.is_none()
&& v.original_outcome_base64url.is_none(),
"UPDATE_CONTROL_CLAIM_REPLY"
),
NativeControlOperation::ObserveStarts { .. } | NativeControlOperation::Health { .. } => {
ensure!(
v.original_start_base64url.is_none()
&& v.original_outcome_base64url.is_none()
&& v.claim.is_none(),
"UPDATE_CONTROL_PHASE_REPLY"
)
}
NativeControlOperation::Finalize => ensure!(
v.original_start_base64url.is_none() && v.claim.is_none(),
"UPDATE_CONTROL_FINAL_REPLY"
),
}
Ok(())
}
pub trait Engine {
fn handle(
&mut self,
peer: &mut PeerProof,
request: &NativeControlRequest,
) -> Result<NativeControlReply>;
}
pub struct Server {
pin: Pin,
pipe: OwnedHandle,
}
pub struct Received {
pub request: NativeControlRequest,
pub peer: PeerProof,
}
impl Server {
pub fn bind(pin: Pin) -> Result<Self> {
pin.validate()?;
ipc::require_self(&pin.helper)?;
let d = ipc::Descriptor::from(&format!(
"O:SYG:SYD:P(D;;GA;;;NU)(A;;GA;;;SY)(A;;GA;;;BA)(A;;GA;;;{})(A;;0x{:08x};;;{})",
pin.helper.service_sid,
ipc::CLIENT_PIPE_RIGHTS,
pin.updater.service_sid
))?;
let sa = SECURITY_ATTRIBUTES {
nLength: size_of::<SECURITY_ATTRIBUTES>() as u32,
lpSecurityDescriptor: d.0,
bInheritHandle: 0,
};
let pipe = ipc::owned(unsafe {
CreateNamedPipeW(
ipc::wide(PIPE).as_ptr(),
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS,
1,
65536,
65536,
1000,
&sa,
)
})?;
Ok(Self { pin, pipe })
}
pub fn receive(&self) -> Result<Option<Received>> {
ipc::require_self(&self.pin.helper)?;
let pipe = self.pipe.as_raw_handle();
let mut event = ipc::IoEvent::new()?;
if unsafe { ConnectNamedPipe(pipe, &mut event.overlapped) } == 0 {
let error = unsafe { GetLastError() };
if error == ERROR_IO_PENDING {
if let Err(e) = event.wait(pipe, Instant::now() + Duration::from_millis(25)) {
if ipc::diagnostic(&e).code == "HELPER_PIPE_TIMEOUT" {
self.disconnect();
return Ok(None);
}
return Err(e);
}
} else {
ensure!(error == ERROR_PIPE_CONNECTED, "UPDATE_CONTROL_CONNECT");
}
}
let deadline = Instant::now() + Duration::from_secs(5);
let len = ipc::length(pipe, deadline)?;
let mut peer = PeerProof::capture(pipe, &self.pin.updater, true)?;
ensure!(
unsafe { ImpersonateNamedPipeClient(pipe) } != 0,
"UPDATE_CONTROL_IMPERSONATE"
);
let auth = (|| -> Result<()> {
let mut token = ptr::null_mut();
ensure!(
unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0,
"UPDATE_CONTROL_THREAD_TOKEN"
);
let token = ipc::owned(token)?;
ipc::verify_token(
token.as_raw_handle(),
&self.pin.updater.user_sid,
&self.pin.updater.service_sid,
)
})();
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
auth?;
ipc::require_self(&self.pin.helper)?;
let request: NativeControlRequest = ipc::body(pipe, len, deadline)?;
request_valid(&self.pin, &request)?;
peer.check()?;
Ok(Some(Received { request, peer }))
}
pub fn reply(&self, received: &mut Received, reply: &NativeControlReply) -> Result<()> {
reply_valid(&received.request, reply)?;
received.peer.check()?;
let mut raw = ipc::encode(reply)?;
let deadline = Instant::now() + Duration::from_secs(5);
ipc::send_bytes(self.pipe.as_raw_handle(), &mut raw, deadline)?;
let mut receipt = [0; ipc::DRAIN_RECEIPT_LEN];
ipc::transfer(self.pipe.as_raw_handle(), &mut receipt, false, deadline)?;
ipc::verify_drain_receipt(&receipt, received.request.challenge, &raw)?;
received.peer.check()
}
pub fn serve_one(&self, engine: &mut impl Engine) -> Result<bool> {
let result = (|| -> Result<bool> {
let Some(mut received) = self.receive()? else {
return Ok(false);
};
let reply = engine.handle(&mut received.peer, &received.request)?;
self.reply(&mut received, &reply)?;
Ok(true)
})();
self.disconnect();
result
}
pub fn disconnect(&self) {
unsafe {
DisconnectNamedPipe(self.pipe.as_raw_handle());
}
}
}
/// One original request, no reconnect/retry of a possibly committed claim.
pub fn exchange(pin: &Pin, request: &NativeControlRequest) -> Result<NativeControlReply> {
pin.validate()?;
request_valid(pin, request)?;
ipc::require_self(&pin.updater)?;
let pipe = ipc::owned(unsafe {
CreateFileW(
ipc::wide(PIPE).as_ptr(),
ipc::CLIENT_PIPE_RIGHTS,
0,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
ptr::null_mut(),
)
})?;
let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.helper, false)?;
let deadline = Instant::now() + Duration::from_secs(5);
ipc::send(pipe.as_raw_handle(), request, deadline)?;
let length = ipc::length(pipe.as_raw_handle(), deadline)?;
let raw = ipc::body_bytes(pipe.as_raw_handle(), length, deadline)?;
let reply: NativeControlReply = serde_json::from_slice(&raw)?;
reply_valid(request, &reply)?;
peer.check()?;
let mut receipt = ipc::drain_receipt(request.challenge, &raw);
ipc::transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)?;
Ok(reply)
}
+111
View File
@@ -0,0 +1,111 @@
//! mTLS public artifact prefetch for an already approved JobOffer. This runs
//! before the sixty-second startgrant, on its own task and bounded disk lanes.
use anyhow::{Result, ensure};
use reqwest::{Client, StatusCode};
use rmm_agent_windows::update_cache::{self, Download};
use rmm_domain::{
agent_update::ReleaseManifest,
jobs::JobPayload,
};
use std::time::{Duration, Instant};
const CHUNK: u64 = 512 * 1024;
fn metadata(
response: &reqwest::Response,
a: &rmm_domain::agent_update::ArtifactDescriptor,
offset: u64,
length: u64,
) -> Result<()> {
let partial = offset != 0 || length != a.bytes;
ensure!(
response.status()
== if partial {
StatusCode::PARTIAL_CONTENT
} else {
StatusCode::OK
},
"UPDATE_DOWNLOAD_STATUS"
);
let h = response.headers();
ensure!(
h.get("x-artifact-sha256").and_then(|v| v.to_str().ok()) == Some(a.sha256.as_str())
&& h.get("content-type").and_then(|v| v.to_str().ok())
== Some("application/octet-stream")
&& !h.contains_key("content-encoding")
&& h.get("content-length")
.and_then(|v| v.to_str().ok())
.and_then(|v| v.parse::<u64>().ok())
== Some(length),
"UPDATE_DOWNLOAD_METADATA"
);
if partial {
ensure!(
h.get("content-range").and_then(|v| v.to_str().ok())
== Some(format!("bytes {}-{}/{}", offset, offset + length - 1, a.bytes).as_str()),
"UPDATE_DOWNLOAD_RANGE"
);
} else {
ensure!(!h.contains_key("content-range"), "UPDATE_DOWNLOAD_RANGE");
}
Ok(())
}
pub async fn prefetch(
client: Client,
base: String,
job: JobPayload,
manifest: ReleaseManifest,
guard: impl Fn() -> Result<()> + Send + 'static,
) -> Result<()> {
ensure!(
manifest.validate() && manifest.platform == rmm_agent_windows::release_platform::WIRE,
"UPDATE_DOWNLOAD_MANIFEST"
);
let deadline = Instant::now() + Duration::from_secs(600);
for artifact in manifest.artifacts {
guard()?;
let descriptor = artifact.clone();
let exists = tokio::task::spawn_blocking(move || -> Result<bool> {
if update_cache::Source::open(&descriptor).is_ok() {
Ok(true)
} else {
Ok(false)
}
})
.await??;
if exists {
continue;
}
let descriptor = artifact.clone();
let mut stage = tokio::task::spawn_blocking(move || Download::begin(&descriptor)).await??;
while stage.offset() < artifact.bytes {
guard()?;
ensure!(Instant::now() < deadline, "UPDATE_DOWNLOAD_DEADLINE");
let offset = stage.offset();
let length = CHUNK.min(artifact.bytes - offset);
let mut response=client.get(format!("{base}/agent/v1/update-artifacts/{}?job_id={}&attempt_id={}&offset={offset}&length={length}",artifact.artifact_id,job.job_id,job.attempt_id)).send().await?;
metadata(&response, &artifact, offset, length)?;
let mut bytes = Vec::with_capacity(length as usize);
while let Some(chunk) = response.chunk().await? {
ensure!(
bytes.len() + chunk.len() <= length as usize,
"UPDATE_DOWNLOAD_BODY_LIMIT"
);
bytes.extend_from_slice(&chunk);
}
ensure!(
bytes.len() == length as usize,
"UPDATE_DOWNLOAD_BODY_LENGTH"
);
guard()?;
ensure!(Instant::now() < deadline, "UPDATE_DOWNLOAD_DEADLINE");
stage = tokio::task::spawn_blocking(move || -> Result<Download> {
stage.append(offset, &bytes)?;
Ok(stage)
})
.await??;
}
guard()?;
tokio::task::spawn_blocking(move || stage.finish()).await??;
}
guard()?;
Ok(())
}
+419
View File
@@ -0,0 +1,419 @@
//! Stable updater channel, separate from the LocalService agent channel.
//! Mutually pinned service identity is checked before decoding a bounded call.
//! An Activate is never retried by the transport. A response is not readiness.
use crate::helper_ipc::{self as ipc, PeerPin, PeerProof};
use anyhow::{Context, Result, ensure};
use rmm_agent_core::auth::Binding;
use rmm_domain::{
agent_update::{ParticipantIdentity, ParticipantRole},
jobs::hash,
};
use serde::{Deserialize, Serialize};
use std::{
mem::size_of,
os::windows::io::{AsRawHandle, OwnedHandle},
path::Path,
ptr,
time::{Duration, Instant},
};
use uuid::Uuid;
use windows_sys::Win32::{
Foundation::*,
Security::*,
Storage::FileSystem::*,
System::{Pipes::*, Threading::*},
};
pub const SERVICE: &str = "RmmDiscoveryUpdater";
pub const BINARY: &str = r"C:\Program Files\RustDiscovery\rmm-updater-windows.exe";
pub const PIPE: &str = r"\\.\pipe\RustDiscovery-Updater-v1";
const LIMIT: usize = 32768;
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Pin {
pub schema_version: u32,
pub binding: Binding,
pub policy_sha256: String,
pub helper: PeerPin,
pub updater: PeerPin,
}
impl Pin {
pub fn validate(&self) -> Result<()> {
ensure!(
self.schema_version == 1 && ipc::digest(&self.policy_sha256),
"UPDATE_IPC_PIN"
);
self.helper.validate(true)?;
ensure!(
self.updater.service_name == SERVICE
&& self.updater.service_sid == ipc::service_sid(SERVICE)?
&& self.updater.user_sid == "S-1-5-18"
&& self.updater.binary == Path::new(BINARY)
&& ipc::digest(&self.updater.binary_sha256),
"UPDATE_IPC_UPDATER_PIN"
);
ensure!(
!self.binding.agent_id.is_nil()
&& !self.binding.asset_id.is_nil()
&& !self.binding.tenant_id.is_nil()
&& self.binding.enrollment_generation > 0
&& self.binding.assignment_version > 0,
"UPDATE_IPC_BINDING"
);
Ok(())
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(tag = "method", rename_all = "snake_case", deny_unknown_fields)]
pub enum Request {
Describe {},
Activate {
grant_id: Uuid,
owner_nonce: Uuid,
handoff_sha256: String,
},
Read {
grant_id: Uuid,
owner_nonce: Uuid,
handoff_sha256: String,
},
Health {
grant_id: Uuid,
owner_nonce: Uuid,
handoff_sha256: String,
payload_base64url: String,
signature_base64url: String,
},
}
impl Request {
pub fn validate(&self) -> Result<()> {
match self {
Self::Describe {} => {}
Self::Activate {
grant_id,
owner_nonce,
handoff_sha256,
}
| Self::Read {
grant_id,
owner_nonce,
handoff_sha256,
}
| Self::Health {
grant_id,
owner_nonce,
handoff_sha256,
..
} => {
ensure!(
!grant_id.is_nil() && !owner_nonce.is_nil() && ipc::digest(handoff_sha256),
"UPDATE_IPC_ORIGINAL_BINDING"
);
if let Self::Health {
payload_base64url,
signature_base64url,
..
} = self
{
ensure!(
!payload_base64url.is_empty()
&& payload_base64url.len() <= 21846
&& signature_base64url.len() == 86
&& payload_base64url
.bytes()
.chain(signature_base64url.bytes())
.all(|b| b.is_ascii_alphanumeric() || b"-_".contains(&b)),
"UPDATE_IPC_HEALTH_LIMIT"
);
}
}
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum State {
Described,
Inflight,
OutcomePersisted,
Unknown,
NotConfigured,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Response {
pub schema_version: u32,
pub state: State,
pub ready: bool,
pub updater: ParticipantIdentity,
pub head_sha256: Option<String>,
}
impl Response {
fn validate(&self) -> Result<()> {
ensure!(
self.schema_version == 1
&& !self.ready
&& self.updater.validate()
&& self.updater.role == ParticipantRole::WindowsUpdater
&& self.head_sha256.as_ref().is_none_or(|v| ipc::digest(v)),
"UPDATE_IPC_RESPONSE"
);
Ok(())
}
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Call {
schema_version: u32,
challenge: Uuid,
binding_sha256: String,
policy_sha256: String,
request: Request,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Reply {
schema_version: u32,
challenge: Uuid,
binding_sha256: String,
policy_sha256: String,
response: Response,
}
/// The instance digest covers the pinned SCM command and held live process,
/// including image file identity and service SID, rather than PID alone.
pub fn participant(peer: &PeerProof, role: ParticipantRole) -> Result<ParticipantIdentity> {
ensure!(
matches!(
role,
ParticipantRole::WindowsHelper | ParticipantRole::WindowsUpdater
),
"UPDATE_IPC_PARTICIPANT_ROLE"
);
let p = peer.identity();
let expected = if role == ParticipantRole::WindowsHelper {
ipc::HELPER_SERVICE
} else {
SERVICE
};
ensure!(
p.user_sid == "S-1-5-18" && p.service_sid == ipc::service_sid(expected)?,
"UPDATE_IPC_PARTICIPANT_SID"
);
let value = ParticipantIdentity {
role,
pid: p.pid,
birth: p.creation_ticks,
image_sha256: p.image_sha256.clone(),
security_principal: p.user_sid.clone(),
service_instance_sha256: hash(&serde_json::to_vec(p)?),
};
ensure!(value.validate(), "UPDATE_IPC_PARTICIPANT");
Ok(value)
}
pub fn observe(pin: &PeerPin, role: ParticipantRole) -> Result<(PeerProof, ParticipantIdentity)> {
let mut proof = PeerProof::for_service(pin, ipc::service_status(pin)?)?;
proof.check()?;
let value = participant(&proof, role)?;
Ok((proof, value))
}
/// Caller implements all original-ledger, retained-state, clock and one-pass
/// checks. This transport has no default handler or automatic startup replay.
pub trait Engine {
fn handle(&mut self, peer: &ParticipantIdentity, request: Request) -> Result<Response>;
}
pub struct Server {
pipe: OwnedHandle,
pin: Pin,
}
impl Server {
pub fn bind(pin: Pin) -> Result<Self> {
pin.validate()?;
ipc::require_self(&pin.updater)?;
let descriptor = ipc::Descriptor::from(&format!(
"O:SYG:SYD:P(D;;GA;;;NU)(A;;GA;;;SY)(A;;GA;;;BA)(A;;GA;;;{})(A;;0x{:08x};;;{})",
pin.updater.service_sid,
ipc::CLIENT_PIPE_RIGHTS,
pin.helper.service_sid
))?;
let sa = SECURITY_ATTRIBUTES {
nLength: size_of::<SECURITY_ATTRIBUTES>() as u32,
lpSecurityDescriptor: descriptor.0,
bInheritHandle: 0,
};
let pipe = ipc::owned(unsafe {
CreateNamedPipeW(
ipc::wide(PIPE).as_ptr(),
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS,
1,
LIMIT as u32,
LIMIT as u32,
1000,
&sa,
)
})?;
Ok(Self { pipe, pin })
}
pub fn serve_one(&self, engine: &mut impl Engine) -> Result<bool> {
let result = self.serve_connected(engine);
unsafe {
DisconnectNamedPipe(self.pipe.as_raw_handle());
}
result
}
fn serve_connected(&self, engine: &mut impl Engine) -> Result<bool> {
ipc::require_self(&self.pin.updater)?;
let pipe = self.pipe.as_raw_handle();
let mut event = ipc::IoEvent::new()?;
if unsafe { ConnectNamedPipe(pipe, &mut event.overlapped) } == 0 {
let error = unsafe { GetLastError() };
if error == ERROR_IO_PENDING {
if let Err(e) = event.wait(pipe, Instant::now() + Duration::from_millis(250)) {
if ipc::diagnostic(&e).code == "HELPER_PIPE_TIMEOUT" {
return Ok(false);
}
return Err(e);
}
} else {
ensure!(error == ERROR_PIPE_CONNECTED, "UPDATE_IPC_CONNECT");
}
}
let deadline = Instant::now() + Duration::from_secs(5);
let len = ipc::length(pipe, deadline)?;
ensure!(len <= LIMIT, "UPDATE_IPC_FRAME_LIMIT");
let mut peer = PeerProof::capture(pipe, &self.pin.helper, true)?;
ensure!(
unsafe { ImpersonateNamedPipeClient(pipe) } != 0,
"UPDATE_IPC_IMPERSONATE"
);
let auth = (|| -> Result<()> {
let mut token = ptr::null_mut();
ensure!(
unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0,
"UPDATE_IPC_THREAD_TOKEN"
);
let token = ipc::owned(token)?;
ipc::verify_token(
token.as_raw_handle(),
&self.pin.helper.user_sid,
&self.pin.helper.service_sid,
)
})();
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
auth?;
ipc::require_self(&self.pin.updater)?;
let call: Call = ipc::body(pipe, len, deadline)?;
ensure!(
call.schema_version == 1
&& !call.challenge.is_nil()
&& call.binding_sha256 == ipc::binding_hash(&self.pin.binding)?
&& call.policy_sha256 == self.pin.policy_sha256,
"UPDATE_IPC_CALL_BINDING"
);
call.request.validate()?;
peer.check()?;
let response = engine.handle(
&participant(&peer, ParticipantRole::WindowsHelper)?,
call.request,
)?;
response.validate()?;
let (_own, own) = observe(&self.pin.updater, ParticipantRole::WindowsUpdater)?;
ensure!(response.updater == own, "UPDATE_IPC_SELF_RESPONSE");
let reply = Reply {
schema_version: 1,
challenge: call.challenge,
binding_sha256: call.binding_sha256,
policy_sha256: call.policy_sha256,
response,
};
let mut bytes = ipc::encode(&reply)?;
ensure!(bytes.len() <= LIMIT, "UPDATE_IPC_REPLY_LIMIT");
peer.check()?;
let deadline = Instant::now() + Duration::from_secs(5);
ipc::send_bytes(pipe, &mut bytes, deadline)?;
let mut receipt = [0; ipc::DRAIN_RECEIPT_LEN];
ipc::transfer(pipe, &mut receipt, false, deadline)?;
ipc::verify_drain_receipt(&receipt, reply.challenge, &bytes)?;
peer.check()?;
Ok(true)
}
}
/// Bounded blocking lane only. Every failure propagates; no Activate retry.
pub fn exchange(pin: &Pin, request: &Request, timeout: Duration) -> Result<Response> {
pin.validate()?;
request.validate()?;
ipc::require_self(&pin.helper)?;
ensure!(
(Duration::from_secs(1)..=Duration::from_secs(30)).contains(&timeout),
"UPDATE_IPC_TIMEOUT"
);
let deadline = Instant::now() + timeout;
let pipe = ipc::owned(unsafe {
CreateFileW(
ipc::wide(PIPE).as_ptr(),
ipc::CLIENT_PIPE_RIGHTS,
0,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
ptr::null_mut(),
)
})
.context("UPDATE_IPC_UNAVAILABLE")?;
let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.updater, false)?;
let expected = participant(&peer, ParticipantRole::WindowsUpdater)?;
let call = Call {
schema_version: 1,
challenge: Uuid::new_v4(),
binding_sha256: ipc::binding_hash(&pin.binding)?,
policy_sha256: pin.policy_sha256.clone(),
request: request.clone(),
};
let raw = ipc::encode(&call)?;
ensure!(raw.len() <= LIMIT, "UPDATE_IPC_FRAME_LIMIT");
ipc::send(pipe.as_raw_handle(), &call, deadline)?;
let len = ipc::length(pipe.as_raw_handle(), deadline)?;
ensure!(len <= LIMIT, "UPDATE_IPC_FRAME_LIMIT");
let bytes = ipc::body_bytes(pipe.as_raw_handle(), len, deadline)?;
let reply: Reply = serde_json::from_slice(&bytes)?;
peer.check()?;
ensure!(
reply.schema_version == 1
&& reply.challenge == call.challenge
&& reply.binding_sha256 == call.binding_sha256
&& reply.policy_sha256 == call.policy_sha256
&& reply.response.updater == expected,
"UPDATE_IPC_REPLY_BINDING"
);
reply.response.validate()?;
let mut receipt = ipc::drain_receipt(call.challenge, &bytes);
ipc::transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)?;
Ok(reply.response)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn request_cannot_select_a_path_command_service_or_weak_original_binding() {
for raw in [
r#"{"method":"activate","grant_id":"00000000-0000-0000-0000-000000000000","owner_nonce":"00000000-0000-0000-0000-000000000000","handoff_sha256":"00"}"#,
r#"{"method":"describe","path":"C:\\Windows\\cmd.exe"}"#,
r#"{"method":"prepare"}"#,
] {
assert!(
serde_json::from_str::<Request>(raw)
.and_then(|r| r.validate().map_err(serde::de::Error::custom))
.is_err()
);
}
assert!(
serde_json::from_str::<Request>(r#"{"method":"describe"}"#)
.unwrap()
.validate()
.is_ok()
);
}
}
@@ -0,0 +1,417 @@
//! Once-only native service fences. They consume committed ORIGINAL claims,
//! keep real live witnesses, and never open SQLite beside a running helper.
use super::{
Budget, DurableEffectFence, Effect, Service,
services::{Proof, Stopped},
};
use crate::{
helper_ipc::PeerProof, signed_clock::BoundClock, update_ipc, update_original::Original,
update_state::RetainedSet, update_trust::TrustState,
};
use anyhow::{Result, ensure};
use rmm_agent_core::{
auth::Binding,
reconcile::SyncClock,
update_handoff::{NativeEffect, NativeEffectClaim, NativeService},
};
use rmm_domain::{
agent_update::{ParticipantRole, UpdateInflightProof, verify_inflight_proof},
jobs::hash,
};
use rmm_updater_handoff::Phase;
use std::cell::RefCell;
pub struct Context<'a, 'b> {
pub original: &'a Original,
pub binding: &'a Binding,
pub clock: &'a BoundClock,
pub budget: &'a Budget<'b>,
pub updater: &'a RefCell<PeerProof>,
pub retained: &'a RetainedSet,
pub trust: &'a TrustState,
}
impl Context<'_, '_> {
fn check(&self) -> Result<()> {
self.original
.check_current(self.binding, self.clock, self.budget)?;
self.trust
.recheck_prepared(self.original.update(), self.clock)?;
self.retained.verify()?;
let mut updater = self.updater.try_borrow_mut()?;
updater.check()?;
ensure!(
update_ipc::participant(&updater, ParticipantRole::WindowsUpdater)?
== self.original.delegation().updater,
"UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED"
);
let pin = super::services::updater_pin(self.trust.policy())?;
ensure!(
super::services::updater_configuration_sha256(&pin)?
== self.trust.policy().updater_service.unit_sha256,
"UPDATE_UPDATER_CONFIGURATION_CHANGED"
);
Ok(())
}
}
pub struct StopFence<'a, 'b> {
context: Context<'a, 'b>,
claims: [NativeEffectClaim; 2],
proofs: [Proof; 2],
next: usize,
pending: bool,
poisoned: bool,
observations: Vec<String>,
}
/// No deserializer or public constructor: actual successful native stop
/// callbacks and the still-stopped SCM instances create this value.
pub struct StopObservations {
pub(crate) claims: [NativeEffectClaim; 2],
pub(crate) observations: [String; 2],
pub(crate) proofs: [Proof; 2],
}
impl<'a, 'b> StopFence<'a, 'b> {
pub fn new(
context: Context<'a, 'b>,
claims: [NativeEffectClaim; 2],
proofs: [Proof; 2],
proof: &UpdateInflightProof,
) -> Result<Self> {
context.check()?;
let (header, journal) = verify_inflight_proof(proof, context.trust.health_public_key())
.map_err(anyhow::Error::msg)?;
ensure!(
header.bytes()? == context.original.handoff().bytes()?
&& proof.delegation == *context.original.delegation()
&& journal.phase() == Phase::StopIntent,
"UPDATE_STOP_ORIGINAL_PREFIX_REQUIRED"
);
for (index, claim) in claims.iter().enumerate() {
let service = [NativeService::WindowsAgent, NativeService::WindowsHelper][index];
ensure!(
claim.grant_id() == header.attempt.grant_id
&& claim.owner_nonce() == header.owner_nonce
&& claim.head_sha256() == journal.head_sha256()
&& claim.effect() == &NativeEffect::StopService { service }
&& claim.claimed_at() >= context.original.delegation().prepared_at
&& claim.claimed_at() <= context.clock.reading()?.upper,
"UPDATE_STOP_COMMITTED_ORIGINAL_CLAIM_REQUIRED"
);
}
ensure!(
proofs[0].configuration.service == Service::Agent
&& proofs[1].configuration.service == Service::Helper
&& proofs[0].process.image_sha256 == header.predecessor.agent_sha256
&& proofs[1].process.image_sha256 == header.predecessor.helper_sha256,
"UPDATE_ORIGINAL_STOP_PROCESS_PROOFS_REQUIRED"
);
Ok(Self {
context,
claims,
proofs,
next: 0,
pending: false,
poisoned: false,
observations: vec![],
})
}
pub fn finish(self, stopped: &Stopped) -> Result<StopObservations> {
self.context.check()?;
stopped.check(self.context.budget)?;
ensure!(
!self.pending && !self.poisoned && self.next == 2 && stopped.proofs() == self.proofs,
"UPDATE_STOP_NOT_FULLY_OBSERVED"
);
Ok(StopObservations {
claims: self.claims,
observations: self
.observations
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_STOP_OBSERVATIONS_REQUIRED"))?,
proofs: self.proofs,
})
}
}
impl DurableEffectFence for StopFence<'_, '_> {
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
ensure!(
!self.poisoned && !self.pending && self.next < 2,
"UPDATE_STOP_NO_RETRY"
);
self.poisoned = true;
self.context.check()?;
ensure!(
*effect
== Effect::StopService {
service: [Service::Agent, Service::Helper][self.next]
},
"UPDATE_STOP_CLOSED_SEQUENCE"
);
self.pending = true;
Ok(())
}
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
ensure!(
self.poisoned
&& self.pending
&& self.next < 2
&& *effect
== Effect::StopService {
service: [Service::Agent, Service::Helper][self.next]
}
&& observation == hash(&serde_json::to_vec(&self.proofs[self.next])?),
"UPDATE_STOP_ACTUAL_OBSERVATION_REQUIRED"
);
self.context.check()?;
self.observations.push(observation.into());
self.next += 1;
self.pending = false;
self.poisoned = false;
Ok(())
}
}
/// Original reservations returned only after the guarded SQLite connection
/// closes. Holds no mutable connection beside the new helper.
pub struct PreparedStart {
claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>,
proof: UpdateInflightProof,
}
impl PreparedStart {
pub(crate) fn after_closed_connection(
claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>,
proof: UpdateInflightProof,
) -> Self {
Self { claims, proof }
}
pub fn bind<'a, 'b>(
self,
context: Context<'a, 'b>,
released: crate::update_owned::ReleasedFiles,
bundle: &'a crate::update_state::Bundle,
) -> Result<StartFence<'a, 'b>> {
let result = StartFence {
context,
released,
bundle,
reservation: self,
next: 0,
pending: false,
poisoned: false,
};
result.check()?;
Ok(result)
}
}
pub struct StartFence<'a, 'b> {
context: Context<'a, 'b>,
released: crate::update_owned::ReleasedFiles,
bundle: &'a crate::update_state::Bundle,
reservation: PreparedStart,
next: usize,
pending: bool,
poisoned: bool,
}
impl StartFence<'_, '_> {
fn check(&self) -> Result<()> {
self.context.check()?;
self.released.check(self.bundle)?;
let header = self.context.original.handoff();
let (actual, journal) = verify_inflight_proof(
&self.reservation.proof,
self.context.trust.health_public_key(),
)
.map_err(anyhow::Error::msg)?;
ensure!(
actual.bytes()? == header.bytes()?
&& self.reservation.proof.delegation == *self.context.original.delegation()
&& matches!(
journal.phase(),
Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent
),
"UPDATE_RETURN_ORIGINAL_PREFIX_REQUIRED"
);
let rollback = journal.phase() == Phase::RollbackLedgerReturnIntent;
let return_at = self
.reservation
.proof
.decode()
.map_err(anyhow::Error::msg)?
.events
.iter()
.map(|raw| serde_json::from_slice::<rmm_updater_handoff::Event>(raw))
.collect::<std::result::Result<Vec<_>, _>>()?
.into_iter()
.find(|event| {
matches!(
event.evidence,
rmm_updater_handoff::Evidence::LedgerReturnIntent
)
})
.ok_or_else(|| anyhow::anyhow!("UPDATE_ORIGINAL_RETURN_DEADLINE_REQUIRED"))?
.observed_at;
ensure!(
u64::try_from(self.context.clock.reading()?.upper.timestamp())?
< return_at
.checked_add(180)
.ok_or_else(|| anyhow::anyhow!("UPDATE_RETURN_DEADLINE_OVERFLOW"))?,
"UPDATE_ORIGINAL_HEALTH_WINDOW_EXPIRED"
);
let return_claim = &self.reservation.claims.return_ledger;
ensure!(
return_claim.effect()
== &if rollback {
NativeEffect::RollbackReturnLedger
} else {
NativeEffect::ReturnLedger
},
"UPDATE_ORIGINAL_RETURN_CLAIM_REQUIRED"
);
for (index, claim) in self.reservation.claims.starts.iter().enumerate() {
let service = [NativeService::WindowsHelper, NativeService::WindowsAgent][index];
ensure!(
claim.effect()
== &if rollback {
NativeEffect::RollbackStartService { service }
} else {
NativeEffect::StartService { service }
},
"UPDATE_START_ORIGINAL_ORDER"
);
}
for claim in std::iter::once(return_claim).chain(self.reservation.claims.starts.iter()) {
ensure!(
claim.grant_id() == header.attempt.grant_id
&& claim.owner_nonce() == header.owner_nonce
&& claim.head_sha256() == journal.head_sha256()
&& u64::try_from(claim.claimed_at().timestamp())? >= header.consumed_at
&& u64::try_from(claim.claimed_at().timestamp())? < header.finish_before,
"UPDATE_START_COMMITTED_ORIGINAL_CLAIM_REQUIRED"
);
}
for file in &self.bundle.files {
ensure!(
super::files::observe_bound(
file.role,
header.owner_nonce,
super::files::Location::Target,
self.context.budget
)? == if rollback {
file.original.clone()
} else {
file.staged.clone()
},
"UPDATE_RETURN_TARGET_CHANGED"
);
}
Ok(())
}
pub fn finish(self, running: &mut super::services::Running) -> Result<()> {
self.check()?;
ensure!(
!self.pending && !self.poisoned && self.next == 2,
"UPDATE_START_NOT_FULLY_OBSERVED"
);
running.check(self.context.budget)
}
}
impl DurableEffectFence for StartFence<'_, '_> {
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
ensure!(
!self.poisoned && !self.pending && self.next < 2,
"UPDATE_START_NO_RETRY"
);
self.poisoned = true;
self.check()?;
ensure!(
*effect
== Effect::StartService {
service: [Service::Helper, Service::Agent][self.next]
},
"UPDATE_START_CLOSED_SEQUENCE"
);
self.pending = true;
Ok(())
}
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
ensure!(
self.poisoned
&& self.pending
&& self.next < 2
&& *effect
== Effect::StartService {
service: [Service::Helper, Service::Agent][self.next]
},
"UPDATE_START_CALLBACK_CHANGED"
);
self.check()?;
let header = self.context.original.handoff();
let mut pin = if self.next == 0 {
self.bundle_helper_pin()?
} else {
self.bundle_agent_pin()?
};
let (_, journal) = verify_inflight_proof(
&self.reservation.proof,
self.context.trust.health_public_key(),
)
.map_err(anyhow::Error::msg)?;
let pair = if journal.phase() == Phase::RollbackLedgerReturnIntent {
&header.predecessor
} else {
&header.target
};
pin.binary_sha256 = if self.next == 0 {
pair.helper_sha256.clone()
} else {
pair.agent_sha256.clone()
};
let proof = super::services::observe_public(
[Service::Helper, Service::Agent][self.next],
&pin,
self.context.budget,
)?;
ensure!(
hash(&serde_json::to_vec(&proof)?) == observation,
"UPDATE_START_ACTUAL_OBSERVATION_REQUIRED"
);
self.next += 1;
self.pending = false;
self.poisoned = false;
Ok(())
}
}
impl StartFence<'_, '_> {
fn bundle_helper_pin(&self) -> Result<crate::helper_ipc::PeerPin> {
crate::helper_system::read_settings().map(|(s, _)| s.helper)
}
fn bundle_agent_pin(&self) -> Result<crate::helper_ipc::PeerPin> {
crate::helper_system::read_settings().map(|(s, _)| s.agent)
}
}
impl StartFence<'_, '_> {
/// Only failure of the FIRST (helper) native start can produce a new
/// all-stopped token without additional authorized stops. A partially
/// started helper/agent pair does not qualify through this path.
pub fn helper_failed(self, failed: super::services::KnownStartupFailure) -> Result<Stopped> {
self.check()?;
let (_, journal) = verify_inflight_proof(
&self.reservation.proof,
self.context.trust.health_public_key(),
)
.map_err(anyhow::Error::msg)?;
ensure!(
journal.phase() == Phase::LedgerReturnIntent
&& self.next == 0
&& self.pending
&& self.poisoned
&& failed.failure().service() == Service::Helper
&& failed.started().is_empty(),
"UPDATE_HELPER_FAILED_START_LINEAGE_REQUIRED"
);
let mut stopped = failed.into_all_stopped(self.context.budget)?;
stopped.bind_failure(
self.reservation.claims,
self.context.original.delegation().updater.clone(),
)?;
Ok(stopped)
}
}
@@ -276,3 +276,233 @@ impl<G: UpdateParticipantGuard, C: SyncClock> DurableEffectFence for LedgerFence
Ok(())
}
}
/// A distinct one-shot V2 return fence. It cannot be constructed from Unknown,
/// a partial forward replacement, a completed update or a future grant.
pub struct RestoreFence<'a, 'b, G, C> {
db: &'a mut Connection,
guard: &'a G,
clock: &'a C,
budget: &'a Budget<'b>,
original: Handoff,
originals: &'a [Proof; 5],
staged: &'a [Proof; 5],
pending: Option<(Effect, NativeEffectClaim)>,
next: usize,
saved: bool,
poisoned: bool,
}
impl<'a, 'b, G: UpdateParticipantGuard, C: SyncClock> RestoreFence<'a, 'b, G, C> {
pub fn new(input: Inputs<'a, 'b, G, C>) -> Result<Self> {
input.budget.check()?;
input.original.validate()?;
let grant = input.original.attempt.grant_id;
let journal = core::read(input.db, input.guard, grant)?;
ensure!(
input.original.schema_version == 2
&& input.original.pin_transition == PinTransition::WindowsCodePairClockV1
&& input.guard.participant() == Participant::StableUpdater
&& journal.phase() == Phase::RollbackStopped,
"UPDATE_WINDOWS_NO_RESTORE_RESUME"
);
let raw: Vec<u8> = input.db.query_row(
"SELECT record FROM agent_update_handoffs WHERE grant_id=?1",
[grant.to_string()],
|r| r.get(0),
)?;
ensure!(
raw == input.original.bytes()?,
"UPDATE_WINDOWS_ORIGINAL_HANDOFF"
);
for (i, role) in ROLES.iter().copied().enumerate() {
ensure!(
input.original.files[i].role == role.handoff_role()
&& input.original.files[i].old_sha256 == input.originals[i].sha256
&& input.original.files[i].new_sha256 == input.staged[i].sha256
&& files::observe_bound(
role,
input.original.owner_nonce,
Location::Target,
input.budget
)? == input.staged[i]
&& files::observe_bound(
role,
input.original.owner_nonce,
Location::Previous,
input.budget
)? == input.originals[i],
"UPDATE_WINDOWS_RESTORE_FILES"
);
}
Ok(Self {
db: input.db,
guard: input.guard,
clock: input.clock,
budget: input.budget,
original: input.original.clone(),
originals: input.originals,
staged: input.staged,
pending: None,
next: 0,
saved: false,
poisoned: false,
})
}
fn append(&mut self, evidence: Evidence) -> Result<()> {
self.budget.check()?;
let grant = self.original.attempt.grant_id;
let journal = core::read(self.db, self.guard, grant)?;
let raw = journal.prepare(u64::try_from(self.clock.bounds()?.1.timestamp())?, evidence)?;
core::append(self.db, self.guard, grant, journal.head_sha256(), &raw)
}
pub fn finish(mut self) -> Result<()> {
ensure!(
!self.poisoned && self.pending.is_none() && !self.saved && self.next == ROLES.len(),
"UPDATE_WINDOWS_RESTORE_INCOMPLETE"
);
for (i, role) in ROLES.iter().copied().enumerate() {
ensure!(
files::observe_bound(
role,
self.original.owner_nonce,
Location::Target,
self.budget
)? == self.originals[i]
&& files::observe_bound(
role,
self.original.owner_nonce,
Location::Rejected,
self.budget
)? == self.staged[i],
"UPDATE_WINDOWS_RESTORED_STATE_CHANGED"
);
}
self.append(Evidence::PredecessorVerified {
pair: self.original.predecessor.clone(),
retained_state_sha256: self.original.retained_state_sha256.clone(),
predecessor_record_sha256: self.original.predecessor_record_sha256.clone(),
})
}
}
impl<G: UpdateParticipantGuard, C: SyncClock> DurableEffectFence for RestoreFence<'_, '_, G, C> {
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
ensure!(
!self.poisoned && self.pending.is_none() && self.next < ROLES.len(),
"UPDATE_WINDOWS_RESTORE_REENTRY"
);
self.poisoned = true;
self.budget.check()?;
let i = ROLES.len() - 1 - self.next;
let role = ROLES[i];
let effect_kind = match *effect {
Effect::SaveRejectedCandidate { role: r } if r == role && !self.saved => {
ensure!(
files::observe_bound(
role,
self.original.owner_nonce,
Location::Target,
self.budget
)? == self.staged[i]
&& files::observe_bound(
role,
self.original.owner_nonce,
Location::Previous,
self.budget
)? == self.originals[i],
"UPDATE_WINDOWS_RESTORE_FILES_CHANGED"
);
self.append(Evidence::RestoreIntent {
role: role.handoff_role(),
})?;
NativeEffect::SaveRejectedCandidate { role: native(role) }
}
Effect::RestorePredecessor { role: r } if r == role && self.saved => {
ensure!(
files::observe_bound(
role,
self.original.owner_nonce,
Location::Rejected,
self.budget
)? == self.staged[i]
&& files::observe_bound(
role,
self.original.owner_nonce,
Location::Previous,
self.budget
)? == self.originals[i],
"UPDATE_WINDOWS_RESTORE_FILES_CHANGED"
);
NativeEffect::RestorePredecessor { role: native(role) }
}
_ => anyhow::bail!("UPDATE_WINDOWS_RESTORE_SCOPE"),
};
let journal = core::read(self.db, self.guard, self.original.attempt.grant_id)?;
let claim = core::claim_native_effect(
self.db,
self.guard,
self.original.attempt.grant_id,
journal.head_sha256(),
&effect_kind,
self.clock.bounds()?.1,
)?;
self.pending = Some((effect.clone(), claim));
Ok(())
}
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
let (expected, claim) = self
.pending
.take()
.ok_or_else(|| anyhow::anyhow!("UPDATE_WINDOWS_RESTORE_NOT_CLAIMED"))?;
ensure!(
self.poisoned && *effect == expected,
"UPDATE_WINDOWS_RESTORE_CALLBACK_CHANGED"
);
self.budget.check()?;
let i = ROLES.len() - 1 - self.next;
let role = ROLES[i];
let restored = matches!(effect, Effect::RestorePredecessor { .. });
let proof = files::observe_bound(
role,
self.original.owner_nonce,
if restored {
Location::Target
} else {
Location::Rejected
},
self.budget,
)?;
ensure!(
proof
== if restored {
self.originals[i].clone()
} else {
self.staged[i].clone()
}
&& digest(&serde_json::to_vec(&proof)?) == observation,
"UPDATE_WINDOWS_RESTORE_READBACK"
);
core::observe_native_effect(
self.db,
self.guard,
&claim,
observation,
self.clock.bounds()?.1,
)?;
if restored {
self.append(Evidence::PredecessorRestored {
role: role.handoff_role(),
observed_sha256: proof.sha256,
})?;
self.next += 1;
self.saved = false;
} else {
self.append(Evidence::CandidatePreserved {
role: role.handoff_role(),
observation_sha256: observation.into(),
})?;
self.saved = true;
}
self.poisoned = false;
Ok(())
}
}
+206 -11
View File
@@ -2,10 +2,7 @@
//! No archive extraction, free target path, overwrite, replacement of journals,
//! or implicit retry/rollback. A failed rename/readback is an uncertain effect.
use super::{Budget, DurableEffectFence, Effect, Role, digest, valid_digest};
use crate::{
helper_ipc::{self as ipc, FileIdentity, PinnedFile},
job_binding,
};
use crate::helper_ipc::{self as ipc, FileIdentity, PinnedFile};
use anyhow::{Context, Result, ensure};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
@@ -45,6 +42,16 @@ struct Directory {
root: PinnedFile,
ancestors: Vec<File>,
}
fn readers() -> Result<Vec<String>> {
let mut values = vec![
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
if let Ok(updater) = ipc::service_sid(crate::update_ipc::SERVICE) {
values.push(updater);
}
Ok(values)
}
fn regular(file: &File, directory: bool) -> Result<()> {
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
ensure!(
@@ -87,11 +94,7 @@ impl Directory {
let path = Path::new(role.target())
.parent()
.context("UPDATE_TARGET_DIRECTORY")?;
let readers = vec![
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let root = PinnedFile::open_read_shared(path, true, &readers, &[])?;
let root = PinnedFile::open_read_shared(path, true, &readers()?, &[])?;
let mut ancestors = Vec::new();
for ancestor in path.ancestors().skip(1) {
let raw = unsafe {
@@ -123,6 +126,9 @@ impl Directory {
self.root.path.join(name)
}
}
pub(crate) fn security_sha256(file: &File) -> Result<String> {
SecurityDescriptor::read(file)?.hash()
}
struct SecurityDescriptor(*mut core::ffi::c_void);
impl Drop for SecurityDescriptor {
fn drop(&mut self) {
@@ -230,9 +236,13 @@ fn hash_file(file: &mut File, max: u64) -> Result<String> {
}
Ok(format!("{:x}", hash.finalize()))
}
fn proof(file: &mut File, path: &Path, max: u64) -> Result<Proof> {
pub(crate) fn proof(file: &mut File, path: &Path, max: u64) -> Result<Proof> {
regular(file, false)?;
job_binding::check_admin_readonly(path)?;
// The agent-only binding reader rejects the helper service's legitimate
// read ACE. These are the SAME fixed three service readers used by the
// updater; none gets write/delete/owner/DACL rights. Check the held object,
// not an unrelated path-based collector ACL helper.
ipc::check_acl(file.as_raw_handle(), &readers()?, &[], None)?;
let identity = ipc::file_identity(file)?;
let bytes = file.metadata()?.len();
ensure!(bytes > 0 && bytes <= max, "UPDATE_FILE_SIZE");
@@ -291,6 +301,7 @@ pub(crate) enum Location {
Target,
Stage,
Previous,
Rejected,
}
/// Independent readback while the actual swap retains DELETE/write handles.
/// Opening this read-only observer grants no write/delete access or authority.
@@ -309,6 +320,9 @@ pub(crate) fn observe_bound(
Location::Previous => {
directory.child(&format!(".rmm-update-{nonce}-{}.previous", role.label()))
}
Location::Rejected => {
directory.child(&format!(".rmm-update-{nonce}-{}.rejected", role.label()))
}
};
let raw = unsafe {
CreateFileW(
@@ -336,6 +350,12 @@ pub struct StageDescriptor<'a> {
pub replacement_sha256: &'a str,
pub replacement_bytes: u64,
}
pub struct BoundStage<'a> {
pub role: Role,
pub owner_nonce: Uuid,
pub original: &'a Proof,
pub staged: &'a Proof,
}
pub struct Staged {
role: Role,
nonce: Uuid,
@@ -346,6 +366,52 @@ pub struct Staged {
staged: Proof,
}
impl Staged {
/// Reopen only the exact prepared stage in the immutable consumed bundle.
/// A partial publication/old predecessor name is never treated as a stage.
pub fn reopen_bound(bound: BoundStage<'_>, budget: &Budget<'_>) -> Result<Self> {
ensure!(!bound.owner_nonce.is_nil(), "UPDATE_STAGE_NONCE");
budget.check()?;
let mut directory = Directory::open(bound.role)?;
let path = directory.child(&format!(
".rmm-update-{}-{}.stage",
bound.owner_nonce,
bound.role.label()
));
let previous = directory.child(&format!(
".rmm-update-{}-{}.previous",
bound.owner_nonce,
bound.role.label()
));
ensure!(!previous.try_exists()?, "UPDATE_NO_STAGE_RESUME");
ensure!(
observe_bound(bound.role, bound.owner_nonce, Location::Target, budget)?
== *bound.original,
"UPDATE_STAGE_PREDECESSOR_CHANGED"
);
let mut file = open(
&path,
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
OPEN_EXISTING,
ptr::null(),
)?;
ensure!(
proof(&mut file, &path, bound.role.max_bytes())? == *bound.staged
&& bound.original.identity != bound.staged.identity
&& bound.original.identity.volume_serial == bound.staged.identity.volume_serial
&& bound.original.security_sha256 == bound.staged.security_sha256,
"UPDATE_BOUND_STAGE_CHANGED"
);
directory.check()?;
Ok(Self {
role: bound.role,
nonce: bound.owner_nonce,
directory,
path,
file,
original: bound.original.clone(),
staged: bound.staged.clone(),
})
}
/// Source is a bounded stream of already independently release-verified
/// artifact bytes. No URL or caller-chosen destination is accepted. Both
/// code files MUST be fully staged before original activation consumption.
@@ -548,6 +614,53 @@ pub struct Published {
replacement_proof: Proof,
}
impl Published {
/// Reopening exact files is an observation only. The separate V2 restore
/// fence still requires a known failure, original owner and current guard.
pub fn reopen_bound(
bound: BoundStage<'_>,
stopped: &super::services::Stopped,
budget: &Budget<'_>,
) -> Result<Self> {
stopped.check(budget)?;
ensure!(!bound.owner_nonce.is_nil(), "UPDATE_RESTORE_NONCE");
let mut directory = Directory::open(bound.role)?;
let predecessor = directory.child(&format!(
".rmm-update-{}-{}.previous",
bound.owner_nonce,
bound.role.label()
));
let mut original = open(
&predecessor,
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
OPEN_EXISTING,
ptr::null(),
)?;
let mut replacement = open(
Path::new(bound.role.target()),
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
OPEN_EXISTING,
ptr::null(),
)?;
ensure!(
proof(&mut original, &predecessor, bound.role.max_bytes())? == *bound.original
&& proof(
&mut replacement,
Path::new(bound.role.target()),
bound.role.max_bytes()
)? == *bound.staged,
"UPDATE_RESTORE_BOUND_FILES_CHANGED"
);
directory.check()?;
Ok(Self {
role: bound.role,
directory,
original,
predecessor,
original_proof: bound.original.clone(),
replacement,
replacement_proof: bound.staged.clone(),
})
}
pub fn proof(&self) -> &Proof {
&self.replacement_proof
}
@@ -573,4 +686,86 @@ impl Published {
self.verify(budget)?;
Ok((self.original_proof, self.replacement_proof))
}
/// V2-only caller fence: preserve the rejected candidate and restore the
/// exact predecessor with TWO distinct durable intents and readbacks.
pub fn restore(
mut self,
stopped: &super::services::Stopped,
budget: &Budget<'_>,
fence: &mut impl DurableEffectFence,
) -> Result<(Proof, Proof)> {
stopped.check(budget)?;
self.verify(budget)?;
let rejected = self.predecessor.with_extension("rejected");
let save = Effect::SaveRejectedCandidate { role: self.role };
fence.before_effect(&save)?;
budget.check()?;
stopped.check(budget)?;
self.directory.check()?;
rename_new(&self.replacement, &rejected)?;
let saved = proof(&mut self.replacement, &rejected, self.role.max_bytes())?;
ensure!(
saved == self.replacement_proof,
"UPDATE_REJECTED_CANDIDATE_CHANGED"
);
fence.after_effect(&save, &digest(&serde_json::to_vec(&saved)?))?;
let restore = Effect::RestorePredecessor { role: self.role };
fence.before_effect(&restore)?;
budget.check()?;
stopped.check(budget)?;
self.directory.check()?;
rename_new(&self.original, Path::new(self.role.target()))?;
let restored = proof(
&mut self.original,
Path::new(self.role.target()),
self.role.max_bytes(),
)?;
ensure!(
restored == self.original_proof,
"UPDATE_RESTORED_PREDECESSOR_CHANGED"
);
fence.after_effect(&restore, &digest(&serde_json::to_vec(&restored)?))?;
Ok((restored, saved))
}
}
/// Fixed installed-record namespace only; the caller's original native claim
/// remains mandatory. This primitive grants no approval or retry authority.
pub(crate) fn rename_record(file: &File, target: &Path) -> Result<()> {
let root = Path::new(r"C:\ProgramData\RustDiscoveryUpdater");
let name = target.file_name().and_then(|n| n.to_str()).unwrap_or("");
ensure!(
(target.parent() == Some(root) && name == "installed-record.json")
|| (target.parent() == Some(root.join("records").as_path())
&& name.strip_suffix(".json").is_some_and(valid_digest)),
"UPDATE_RECORD_FIXED_NAMESPACE"
);
rename_new(file, target)
}
pub(crate) fn create_record_stage(source: &File, target: &Path) -> Result<File> {
ensure!(
target.parent() == Some(Path::new(r"C:\ProgramData\RustDiscoveryUpdater"))
&& target
.file_name()
.and_then(|n| n.to_str())
.is_some_and(|n| n.starts_with(".rmm-record-") && n.ends_with(".stage")),
"UPDATE_RECORD_FIXED_STAGE"
);
let descriptor = SecurityDescriptor::read(source)?;
let attributes = SECURITY_ATTRIBUTES {
nLength: size_of::<SECURITY_ATTRIBUTES>() as u32,
lpSecurityDescriptor: descriptor.0,
bInheritHandle: 0,
};
let file = open(
target,
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
CREATE_NEW,
&attributes,
)?;
ensure!(
SecurityDescriptor::read(&file)?.hash()? == descriptor.hash()?,
"UPDATE_RECORD_STAGE_SECURITY"
);
Ok(file)
}
@@ -14,6 +14,8 @@ use uuid::Uuid;
#[cfg(windows)]
pub mod fence;
#[cfg(windows)]
pub mod control_fence;
#[cfg(windows)]
pub mod files;
#[cfg(windows)]
pub mod services;
@@ -109,6 +111,10 @@ impl<'a> Budget<'a> {
value.check()?;
Ok(value)
}
pub fn boot_id(&self) -> Result<Uuid> {
self.check()?;
Ok(self.boot_id)
}
pub fn check(&self) -> Result<()> {
ensure!(Instant::now() < self.until, "UPDATE_DEADLINE");
ensure!(
@@ -127,6 +133,7 @@ pub enum Effect {
SavePredecessor { role: Role },
PublishReplacement { role: Role },
RestorePredecessor { role: Role },
SaveRejectedCandidate { role: Role },
StartService { service: Service },
}
@@ -4,6 +4,7 @@
use super::{Budget, DurableEffectFence, Effect, Service, digest};
use crate::helper_ipc::{PeerPin, PeerProof, utf16_pointer, wide};
use anyhow::{Result, ensure};
use rmm_domain::agent_update_provisioning::LocalUpdatePolicy;
use rmm_updater_handoff::{Process, StartedService};
use serde::{Deserialize, Serialize};
use std::{
@@ -11,7 +12,12 @@ use std::{
ptr, thread,
time::Duration,
};
use windows_sys::Win32::System::Services::*;
use windows_sys::Win32::{
Foundation::{
ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, ERROR_SERVICE_LOGON_FAILED, GetLastError,
},
System::Services::*,
};
struct Handle(SC_HANDLE);
impl Drop for Handle {
@@ -115,12 +121,11 @@ fn configuration(handle: &Handle, service: Service, pin: &PeerPin) -> Result<Con
ensure!(
cfg.dwServiceType == SERVICE_WIN32_OWN_PROCESS
&& command == expected
&& cfg.dwStartType
== if service == Service::Agent {
SERVICE_AUTO_START
} else {
SERVICE_DEMAND_START
}
&& if service == Service::Agent {
cfg.dwStartType == SERVICE_AUTO_START
} else {
matches!(cfg.dwStartType, SERVICE_DEMAND_START | SERVICE_AUTO_START)
}
&& (cfg.lpDependencies.is_null() || unsafe { *cfg.lpDependencies } == 0)
&& (cfg.lpLoadOrderGroup.is_null() || unsafe { *cfg.lpLoadOrderGroup } == 0),
"UPDATE_SCM_UNEXPECTED_CONFIGURATION"
@@ -205,6 +210,16 @@ fn observe(service: Service, pin: &PeerPin, budget: &Budget<'_>) -> Result<HeldS
})
}
pub(crate) fn observe_public(
service: Service,
pin: &PeerPin,
budget: &Budget<'_>,
) -> Result<Proof> {
let mut held = observe(service, pin, budget)?;
held.peer.check()?;
Ok(held.proof.clone())
}
/// Observation holds both original processes/images, not a freely constructible
/// Running flag. Drop these witnesses only after confirmed process termination.
pub struct Running {
@@ -262,10 +277,7 @@ impl Running {
loop {
budget.check()?;
let state = status(&service.handle)?;
if state.dwCurrentState == SERVICE_STOPPED
&& state.dwProcessId == 0
&& service.peer.exited()?
{
if state.dwCurrentState == SERVICE_STOPPED && service.peer.exited()? {
break;
}
ensure!(
@@ -283,6 +295,9 @@ impl Running {
proofs[0].configuration.clone(),
proofs[1].configuration.clone(),
],
proofs,
failed_start: None,
failure_binding: None,
};
// Held image handles intentionally close here, after BOTH exact original
// processes have terminated. Neither PID reuse nor SCM state suffices.
@@ -297,8 +312,15 @@ impl Running {
pub struct Stopped {
pins: [PeerPin; 2],
configurations: [Configuration; 2],
proofs: Vec<Proof>,
failed_start: Option<FailedStartProof>,
failure_binding: Option<FailureBinding>,
}
impl Stopped {
pub fn proofs(&self) -> &[Proof] {
&self.proofs
}
pub fn check(&self, budget: &Budget<'_>) -> Result<()> {
budget.check()?;
for (i, service) in [Service::Agent, Service::Helper].into_iter().enumerate() {
@@ -309,7 +331,6 @@ impl Stopped {
let state = status(&handle)?;
ensure!(
state.dwCurrentState == SERVICE_STOPPED
&& state.dwProcessId == 0
&& configuration(&handle, service, &self.pins[i])? == self.configurations[i],
"UPDATE_STOPPED_STATE_CHANGED"
);
@@ -325,6 +346,19 @@ impl Stopped {
budget: &Budget<'_>,
fence: &mut impl DurableEffectFence,
) -> Result<Running> {
match self.start_observed(replacement_pins, budget, fence)? {
StartResult::Running(running) => Ok(*running),
StartResult::KnownFailure(_) => {
anyhow::bail!("UPDATE_KNOWN_STARTUP_FAILURE_REQUIRES_ORIGINAL_ROLLBACK")
}
}
}
pub fn start_observed(
self,
replacement_pins: [PeerPin; 2],
budget: &Budget<'_>,
fence: &mut impl DurableEffectFence,
) -> Result<StartResult> {
self.check(budget)?;
let mut started = Vec::with_capacity(2);
for (i, service) in [(1, Service::Helper), (0, Service::Agent)] {
@@ -354,16 +388,52 @@ impl Stopped {
status(&handle)?.dwCurrentState == SERVICE_STOPPED,
"UPDATE_START_ALREADY_RUNNING"
);
ensure!(
unsafe { StartServiceW(handle.0, 0, ptr::null()) } != 0,
"UPDATE_START_REQUEST_UNCERTAIN"
);
if unsafe { StartServiceW(handle.0, 0, ptr::null()) } == 0 {
let error = unsafe { GetLastError() };
let state = status(&handle)?;
ensure!(
matches!(
error,
ERROR_ACCESS_DENIED | ERROR_PATH_NOT_FOUND | ERROR_SERVICE_LOGON_FAILED
) && state.dwCurrentState == SERVICE_STOPPED,
"UPDATE_START_REQUEST_UNCERTAIN"
);
let failure = FailedStartProof::capture(
service,
&replacement_pins[i],
&handle,
error,
false,
)?;
let mut known = KnownStartupFailure {
original: self,
pins: replacement_pins,
failure,
started,
};
known.verify(budget)?;
return Ok(StartResult::KnownFailure(Box::new(known)));
}
loop {
budget.check()?;
let state = status(&handle)?;
if state.dwCurrentState == SERVICE_RUNNING {
break;
}
if state.dwCurrentState == SERVICE_STOPPED
&& (state.dwWin32ExitCode != 0 || state.dwServiceSpecificExitCode != 0)
{
let failure =
FailedStartProof::capture(service, &replacement_pins[i], &handle, 0, true)?;
let mut known = KnownStartupFailure {
original: self,
pins: replacement_pins,
failure,
started,
};
known.verify(budget)?;
return Ok(StartResult::KnownFailure(Box::new(known)));
}
ensure!(
state.dwCurrentState == SERVICE_START_PENDING,
"UPDATE_START_STATE_UNCERTAIN"
@@ -380,7 +450,7 @@ impl Stopped {
held: started,
};
running.check(budget)?;
Ok(running)
Ok(StartResult::Running(Box::new(running)))
}
}
impl Proof {
@@ -391,3 +461,391 @@ impl Proof {
}
}
}
/// The stable updater is independently pinned and never part of the stop set.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdaterConfiguration {
pub service_name: String,
pub command: String,
pub account: String,
pub start_type: u32,
pub error_control: u32,
pub sid_type: u32,
}
pub fn updater_pin(policy: &LocalUpdatePolicy) -> Result<PeerPin> {
ensure!(
policy.validate()
&& policy.schema_version == 2
&& policy.profile == "windows_code_pair_clock_v1",
"UPDATE_WINDOWS_LOCAL_POLICY"
);
Ok(PeerPin {
service_name: crate::update_ipc::SERVICE.into(),
service_sid: crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)?,
user_sid: "S-1-5-18".into(),
binary: crate::update_ipc::BINARY.into(),
binary_sha256: policy.updater_binary_sha256.clone(),
})
}
pub fn updater_configuration(pin: &PeerPin) -> Result<UpdaterConfiguration> {
updater_configuration_inner(pin, true)
}
/// Bootstrap metadata of an already registered fixed service. This does not
/// authenticate a running updater, qualify its clock, or create readiness.
pub fn updater_bootstrap_definition(pin: &PeerPin) -> Result<UpdaterConfiguration> {
updater_configuration_inner(pin, false)
}
fn updater_configuration_inner(
pin: &PeerPin,
require_running: bool,
) -> Result<UpdaterConfiguration> {
ensure!(
pin.service_name == crate::update_ipc::SERVICE
&& pin.service_sid == crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)?
&& pin.user_sid == "S-1-5-18"
&& pin.binary == std::path::Path::new(crate::update_ipc::BINARY)
&& super::valid_digest(&pin.binary_sha256),
"UPDATE_UPDATER_FIXED_SERVICE"
);
let manager = Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
ensure!(!manager.0.is_null(), "UPDATE_SCM_MANAGER");
let service = Handle(unsafe {
OpenServiceW(
manager.0,
wide(crate::update_ipc::SERVICE).as_ptr(),
SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS,
)
});
ensure!(!service.0.is_null(), "UPDATE_UPDATER_SCM");
let mut needed = 0;
unsafe {
QueryServiceConfigW(service.0, ptr::null_mut(), 0, &mut needed);
}
ensure!((1..=32768).contains(&needed), "UPDATE_SCM_CONFIG_SIZE");
let mut bytes = vec![0usize; (needed as usize).div_ceil(size_of::<usize>())];
ensure!(
unsafe { QueryServiceConfigW(service.0, bytes.as_mut_ptr().cast(), needed, &mut needed) }
!= 0,
"UPDATE_SCM_CONFIG"
);
let cfg = unsafe { &*bytes.as_ptr().cast::<QUERY_SERVICE_CONFIGW>() };
let command = unsafe { utf16_pointer(cfg.lpBinaryPathName) }?;
let account = unsafe { utf16_pointer(cfg.lpServiceStartName) }?;
ensure!(
cfg.dwServiceType == SERVICE_WIN32_OWN_PROCESS
&& cfg.dwStartType == SERVICE_AUTO_START
&& command == format!("\"{}\"", crate::update_ipc::BINARY)
&& account == "LocalSystem"
&& (cfg.lpDependencies.is_null() || unsafe { *cfg.lpDependencies } == 0)
&& (cfg.lpLoadOrderGroup.is_null() || unsafe { *cfg.lpLoadOrderGroup } == 0),
"UPDATE_UPDATER_SCM_CONFIGURATION"
);
let recovery = config2(&service, SERVICE_CONFIG_FAILURE_ACTIONS)?;
ensure!(
unsafe { (*recovery.as_ptr().cast::<SERVICE_FAILURE_ACTIONSW>()).cActions } == 0,
"UPDATE_UPDATER_RECOVERY_ACTIONS"
);
let triggers = config2(&service, SERVICE_CONFIG_TRIGGER_INFO)?;
ensure!(
unsafe { (*triggers.as_ptr().cast::<SERVICE_TRIGGER_INFO>()).cTriggers } == 0,
"UPDATE_UPDATER_TRIGGERS"
);
let sid = config2(&service, SERVICE_CONFIG_SERVICE_SID_INFO)?;
let sid_type = unsafe { (*sid.as_ptr().cast::<SERVICE_SID_INFO>()).dwServiceSidType };
ensure!(
sid_type == SERVICE_SID_TYPE_UNRESTRICTED,
"UPDATE_UPDATER_SERVICE_SID"
);
let mut dependent_bytes = 0;
let mut dependent_count = 0;
ensure!(
unsafe {
EnumDependentServicesW(
service.0,
SERVICE_ACTIVE,
ptr::null_mut(),
0,
&mut dependent_bytes,
&mut dependent_count,
)
} != 0
&& dependent_bytes == 0
&& dependent_count == 0,
"UPDATE_UPDATER_ACTIVE_DEPENDENTS"
);
ensure!(
!require_running || status(&service)?.dwCurrentState == SERVICE_RUNNING,
"UPDATE_UPDATER_NOT_RUNNING"
);
Ok(UpdaterConfiguration {
service_name: pin.service_name.clone(),
command,
account,
start_type: cfg.dwStartType,
error_control: cfg.dwErrorControl,
sid_type,
})
}
pub fn updater_configuration_sha256(pin: &PeerPin) -> Result<String> {
Ok(digest(&serde_json::to_vec(&updater_configuration(pin)?)?))
}
pub fn observe_updater(
policy: &LocalUpdatePolicy,
budget: &Budget<'_>,
) -> Result<(PeerProof, rmm_domain::agent_update::ParticipantIdentity)> {
budget.check()?;
let pin = updater_pin(policy)?;
ensure!(
updater_configuration_sha256(&pin)? == policy.updater_service.unit_sha256,
"UPDATE_UPDATER_SCM_PIN"
);
let (mut peer, identity) = crate::update_ipc::observe(
&pin,
rmm_domain::agent_update::ParticipantRole::WindowsUpdater,
)?;
peer.check()?;
ensure!(
updater_configuration_sha256(&pin)? == policy.updater_service.unit_sha256,
"UPDATE_UPDATER_SCM_PIN"
);
budget.check()?;
Ok((peer, identity))
}
/// The native API actually rejected the start, or the accepted service exited
/// with an observed failure before RUNNING. An ambiguous API error, timeout,
/// lost callback, unknown state or incomplete identity is never this token.
pub enum StartResult {
Running(Box<Running>),
KnownFailure(Box<KnownStartupFailure>),
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct FailedStartProof {
service: Service,
image_sha256: String,
configuration: Configuration,
request_error: u32,
accepted_then_exited: bool,
win32_exit: u32,
service_exit: u32,
}
impl FailedStartProof {
fn capture(
service: Service,
pin: &PeerPin,
handle: &Handle,
error: u32,
accepted_then_exited: bool,
) -> Result<Self> {
let state = status(handle)?;
ensure!(
state.dwCurrentState == SERVICE_STOPPED,
"UPDATE_FAILED_START_NOT_STOPPED"
);
Ok(Self {
service,
image_sha256: pin.binary_sha256.clone(),
configuration: configuration(handle, service, pin)?,
request_error: error,
accepted_then_exited,
win32_exit: state.dwWin32ExitCode,
service_exit: state.dwServiceSpecificExitCode,
})
}
pub fn service(&self) -> Service {
self.service
}
pub fn sha256(&self) -> Result<String> {
Ok(digest(&serde_json::to_vec(self)?))
}
}
pub struct KnownStartupFailure {
original: Stopped,
pins: [PeerPin; 2],
failure: FailedStartProof,
started: Vec<HeldService>,
}
impl KnownStartupFailure {
pub fn failure(&self) -> &FailedStartProof {
&self.failure
}
pub fn started(&self) -> Vec<Proof> {
self.started.iter().map(|s| s.proof.clone()).collect()
}
pub fn verify(&mut self, budget: &Budget<'_>) -> Result<()> {
budget.check()?;
for held in &mut self.started {
held.peer.check()?;
}
let index = match self.failure.service {
Service::Agent => 0,
Service::Helper => 1,
};
let h = handle(
self.failure.service,
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | SERVICE_ENUMERATE_DEPENDENTS,
)?;
ensure!(
FailedStartProof::capture(
self.failure.service,
&self.pins[index],
&h,
self.failure.request_error,
self.failure.accepted_then_exited
)? == self.failure,
"UPDATE_FAILED_START_OBSERVATION_CHANGED"
);
if self.failure.service == Service::Helper {
ensure!(
self.started.is_empty(),
"UPDATE_HELPER_FAILURE_STARTED_AGENT"
);
self.original.check(budget)?;
} else {
ensure!(
self.started.len() == 1 && self.started[0].service == Service::Helper,
"UPDATE_AGENT_FAILURE_HELPER_LINEAGE"
);
}
Ok(())
}
pub(crate) fn into_all_stopped(mut self, budget: &Budget<'_>) -> Result<Stopped> {
self.verify(budget)?;
ensure!(
self.failure.service == Service::Helper && self.started.is_empty(),
"UPDATE_PARTIAL_START_REQUIRES_AUTHORIZED_STOPS"
);
self.original.failed_start = Some(self.failure);
self.original.check(budget)?;
Ok(self.original)
}
}
impl Stopped {
pub(crate) fn failed_start(&self) -> Option<&FailedStartProof> {
self.failed_start.as_ref()
}
}
struct FailureBinding {
claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>,
updater: rmm_domain::agent_update::ParticipantIdentity,
}
impl Stopped {
pub(crate) fn bind_failure(
&mut self,
claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>,
updater: rmm_domain::agent_update::ParticipantIdentity,
) -> Result<()> {
ensure!(
self.failed_start.is_some() && self.failure_binding.is_none(),
"UPDATE_FAILED_START_BINDING_REQUIRED"
);
self.failure_binding = Some(FailureBinding { claims, updater });
Ok(())
}
pub(crate) fn verify_failure_claims(
&self,
db: &rusqlite::Connection,
h: &rmm_updater_handoff::Handoff,
) -> Result<()> {
if let Some(binding) = &self.failure_binding {
for claim in
std::iter::once(&binding.claims.return_ledger).chain(binding.claims.starts.iter())
{
ensure!(
claim.grant_id() == h.attempt.grant_id && claim.owner_nonce() == h.owner_nonce,
"UPDATE_FAILURE_ORIGINAL_RESERVATION_REQUIRED"
);
let raw: Vec<u8> = db.query_row(
"SELECT claim FROM agent_update_native_claims WHERE grant_id=?1 AND claim=?2",
rusqlite::params![h.attempt.grant_id.to_string(), serde_json::to_vec(claim)?],
|r| r.get(0),
)?;
ensure!(
raw == serde_json::to_vec(claim)?,
"UPDATE_FAILURE_RESERVATION_CHANGED"
);
}
}
Ok(())
}
pub(crate) fn failure_observation(
&self,
h: &rmm_updater_handoff::Handoff,
d: &rmm_domain::agent_update::UpdateDelegation,
effect: &rmm_agent_core::update_handoff::NativeEffect,
budget: &Budget<'_>,
) -> Result<String> {
use rmm_agent_core::update_handoff::{NativeEffect as E, NativeService as S};
self.check(budget)?;
let failure = self
.failed_start
.as_ref()
.ok_or_else(|| anyhow::anyhow!("UPDATE_KNOWN_START_FAILURE_REQUIRED"))?;
let binding = self
.failure_binding
.as_ref()
.ok_or_else(|| anyhow::anyhow!("UPDATE_FAILURE_ORIGINAL_START_BINDING_REQUIRED"))?;
ensure!(
failure.service == Service::Helper
&& failure.image_sha256 == h.target.helper_sha256
&& binding.updater == d.updater,
"UPDATE_FAILURE_ACTUAL_ORIGINAL_CONTEXT_REQUIRED"
);
let helper = handle(
Service::Helper,
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | SERVICE_ENUMERATE_DEPENDENTS,
)?;
let mut pin = self.pins[1].clone();
pin.binary_sha256 = failure.image_sha256.clone();
ensure!(
FailedStartProof::capture(
Service::Helper,
&pin,
&helper,
failure.request_error,
failure.accepted_then_exited
)? == *failure,
"UPDATE_FAILED_START_OBSERVATION_CHANGED"
);
let service = match effect {
E::StartService {
service: S::WindowsHelper | S::WindowsAgent,
}
| E::RollbackStopService {
service: S::WindowsHelper | S::WindowsAgent,
} => {
if matches!(
effect,
E::StartService {
service: S::WindowsHelper
} | E::RollbackStopService {
service: S::WindowsHelper
}
) {
S::WindowsHelper
} else {
S::WindowsAgent
}
}
_ => anyhow::bail!("UPDATE_FAILURE_NONSTART_SCOPE_REQUIRED"),
};
ensure!(
binding.claims.starts[0].effect()
== &E::StartService {
service: S::WindowsHelper
}
&& binding.claims.starts[1].effect()
== &E::StartService {
service: S::WindowsAgent
},
"UPDATE_FAILURE_START_SEQUENCE_CHANGED"
);
Ok(digest(&serde_json::to_vec(&(
failure,
&binding.updater,
service,
&binding.claims.starts,
))?))
}
}
@@ -211,12 +211,12 @@ pub fn render(input: Inputs<'_>) -> Result<CodePairTransition> {
let mut settings: Settings = serde_json::from_slice(input.settings)?;
let mut pin: Pin = serde_json::from_slice(input.pin)?;
ensure!(
matches!(settings.schema_version, 1..=3)
&& !settings.allow_reboot
matches!(settings.schema_version, 1..=4)
&& (settings.schema_version == 4 || !settings.allow_reboot)
&& (1..=120).contains(&settings.max_runtime_seconds)
&& settings.allowed_services.len() <= 16
&& (settings.schema_version >= 2 || settings.allowed_msi_recipe_sha256.is_none())
&& (settings.schema_version == 3 || settings.allowed_script_profiles.is_none())
&& (settings.schema_version >= 3 || settings.allowed_script_profiles.is_none())
&& bound_peer(&settings.agent, false)
&& bound_peer(&settings.helper, true)
&& !settings.binding.tenant_id.is_nil()
@@ -0,0 +1,57 @@
//! One bounded passive mTLS catalog/read-only SYSTEM observation actor.
//! Its cache is evidence for planning, never an execution permit.
use anyhow::{Result,ensure};
use rmm_domain::agent_update::{AgentUpdateObservation,ReleaseEnvelope,ReleaseManifest};
use rmm_agent_windows::{helper_runtime::Client,update_observer::{Request,Response}};
use serde::Deserialize;
use std::{net::SocketAddr,time::{Duration,Instant}};
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Catalog {status:String,release:Option<CatalogRelease>,observed_at:chrono::DateTime<chrono::Utc>,server_time:chrono::DateTime<chrono::Utc>,job_created:bool}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct CatalogRelease {release_envelope:ReleaseEnvelope,manifest:ReleaseManifest}
async fn collect(client:reqwest::Client,address:SocketAddr,helper:Client,generation:u64)->Result<Response>{
let url=format!("https://{}:{}/agent/v1/releases/current?platform={}",crate::https_channel::server_name()?,address.port(),rmm_agent_windows::release_platform::TRIPLE);
let response=client.get(&url).send().await?;
ensure!(response.url().as_str()==url,"UPDATE_CATALOG_REDIRECT");
let raw=crate::https_channel::bounded_body(response,64*1024,"application/json").await?;
let catalog:Catalog=serde_json::from_slice(&raw)?;
ensure!(!catalog.job_created && catalog.observed_at.timestamp()>0 && catalog.server_time.timestamp()>0,"UPDATE_CATALOG_NOT_A_JOB");
let candidate=match (catalog.status.as_str(),catalog.release) {
("not_configured",None)=>None,
("available",Some(release))=>{
ensure!(release.release_envelope.decode().map_err(anyhow::Error::msg)?.manifest==release.manifest && release.manifest.platform==rmm_agent_windows::release_platform::WIRE,"UPDATE_CATALOG_UNSIGNED_VIEW");Some(release.release_envelope)
}
_=>anyhow::bail!("UPDATE_CATALOG_RESPONSE_SHAPE"),
};
helper.observe_update(Request{generation,candidate}).await
}
#[derive(Default)]
pub struct Observer {current:Option<Response>,pending:Option<tokio::task::JoinHandle<Result<Response>>>,started:Option<Instant>}
impl Observer {
pub async fn poll(&mut self,generation:u64,transport:impl FnOnce()->Result<(reqwest::Client,SocketAddr,Client)>){
if self.pending.as_ref().is_some_and(|task|task.is_finished()) {
let task=self.pending.take().expect("finished task");
self.current=match task.await {Ok(Ok(value)) if value.validate(generation).is_ok()=>Some(value),_=>None};
}
if self.pending.is_none() && self.started.is_none_or(|at|at.elapsed()>=Duration::from_secs(60)) {
self.started=Some(Instant::now());
if let Ok((client,address,helper))=transport(){self.pending=Some(tokio::spawn(async move{tokio::time::timeout(Duration::from_secs(50),collect(client,address,helper,generation)).await?}));}
else {self.current=None;}
}
}
pub fn cached(&self)->Option<&Response>{
let value=self.current.as_ref()?;
let age=chrono::Utc::now()-value.observation.observed_at;
(value.validate(value.generation).is_ok() && age>=chrono::Duration::zero() && age<=chrono::Duration::seconds(90)).then_some(value)
}
pub fn observation(&self,generation:u64)->AgentUpdateObservation{
self.cached().filter(|v|v.generation==generation).map(|v|v.observation.clone()).unwrap_or_else(||AgentUpdateObservation::not_configured(rmm_agent_windows::release_platform::WIRE,chrono::Utc::now()))
}
pub fn capabilities(&self)->Vec<String>{
let Some(value)=self.cached() else{return vec![];};
let(Some(updater),Some(predecessor))=(&value.observation.updater,&value.observation.predecessor) else{return vec![];};
vec![rmm_domain::agent_update::APPLY_CAPABILITY.into(),rmm_domain::agent_update::CHECK_CAPABILITY.into(),"update_agent".into(),"system:update_agent".into(),"helper.system.v1".into(),format!("updater.binary.sha256:{}",updater.binary_sha256),format!("updater.policy.sha256:{}",updater.policy_sha256),format!("helper.binary.sha256:{}",predecessor.helper_sha256)]
}
}
@@ -0,0 +1,89 @@
//! Passive SYSTEM measurements for the code-pair updater. No staging, journal
//! append, service mutation, approval, grant or repair occurs on this path.
use crate::{
helper_system::UpdateContext,
update_ipc,
update_native::{Budget,Role,services,transition},
update_state::QualifiedRegistry,
update_trust::{Protected,TrustState},
};
use anyhow::{Context,Result,ensure};
use rmm_agent_core::{helper_reconcile::{BootSource,ExecutorLedgerGuard},reconcile::SyncClock};
use rmm_domain::{agent_update::{AgentUpdateObservation,CandidatePreview,CatalogCandidate,CatalogCheckReport,CatalogCheckStatus,ObservationQuality,ReleaseEnvelope,ResolvedAgentUpdate,UpdateProfile,Recovery,HealthProfile},jobs::hash};
use serde::{Deserialize,Serialize};
use std::{path::Path,time::Duration};
use uuid::Uuid;
#[derive(Clone,Debug,Serialize,Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Request { pub generation:u64,pub candidate:Option<ReleaseEnvelope> }
#[derive(Clone,Debug,Serialize,Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Response {
pub generation:u64,
pub observation:AgentUpdateObservation,
pub catalog:CatalogCheckReport,
pub installed_record:Vec<u8>,
}
fn require_sync(ctx:&UpdateContext<'_>,generation:u64)->Result<Uuid>{
ctx.guard.check(ctx.db)?;
ctx.clock.require_generation(generation)?;
ensure!(crate::update_control::active_grant(ctx.db)?.is_none(),"UPDATE_OBSERVE_NO_ACTIVE_HANDOFF");
ensure!(ctx.sync.as_ref().is_some_and(|s|s.can_start(ctx.db,ctx.guard,generation,ctx.clock,ctx.boot)),"UPDATE_OBSERVE_CURRENT_SIGNED_SYNC_REQUIRED");
let decision:String=ctx.db.query_row("SELECT last_decision FROM helper_sync_meta WHERE id=1 AND generation=?1 AND fault IS NULL",[generation],|r|r.get(0))?;
Ok(Uuid::parse_str(&decision)?)
}
pub(crate) fn collect(ctx:UpdateContext<'_>,request:&Request)->Result<Response>{
let decision=require_sync(&ctx,request.generation)?;
let trust=TrustState::load_observed(ctx.binding,ctx.clock)?;
trust.qualify_history(ctx.db,ctx.guard,ctx.binding)?;
let budget=Budget::new(ctx.boot,ctx.boot.current_boot()?,Duration::from_secs(10))?;
let registry=QualifiedRegistry::load(&trust)?;
let mut running=services::Running::observe([ctx.pin.agent.clone(),ctx.pin.helper.clone()],&budget)?;
let(mut updater,updater_identity)=services::observe_updater(trust.policy(),&budget)?;
let pin=update_ipc::Pin{schema_version:1,binding:ctx.binding.clone(),policy_sha256:trust.updater_binding().policy_sha256.clone(),helper:ctx.pin.helper.clone(),updater:services::updater_pin(trust.policy())?};
let description=update_ipc::exchange(&pin,&update_ipc::Request::Describe{},Duration::from_secs(5))?;
ensure!(description.state==update_ipc::State::Described && !description.ready && description.head_sha256.is_none() && description.updater==updater_identity,"UPDATE_OBSERVE_LIVE_UPDATER");
registry.verify_observed(&running.proofs(),&services::updater_configuration_sha256(&pin.updater)?)?;
ensure!(ctx.pin.agent.binary_sha256==trust.predecessor().agent_sha256 && ctx.pin.helper.binary_sha256==trust.predecessor().helper_sha256,"UPDATE_OBSERVE_ACTUAL_PREDECESSOR");
let(_,helper)=update_ipc::observe(&ctx.pin.helper,rmm_domain::agent_update::ParticipantRole::WindowsHelper)?;
ensure!(helper.pid==std::process::id(),"UPDATE_OBSERVE_ACTUAL_SYSTEM_HELPER");
let mut protected=vec![];
let mut previews=vec![];
let mut catalog=CatalogCheckReport{schema_version:1,source_id:"mtls:release-catalog-v1".into(),checked_at:ctx.clock.now()?,status:CatalogCheckStatus::NotConfigured,candidate:None};
if let Some(candidate)=&request.candidate {
trust.verify_candidate(candidate,ctx.clock)?;
let decoded=candidate.decode().map_err(anyhow::Error::msg)?;
let manifest=&decoded.manifest;
catalog.status=if manifest.release_id==trust.predecessor().release_id {CatalogCheckStatus::Current} else {CatalogCheckStatus::Available};
catalog.candidate=Some(CatalogCandidate{release_id:manifest.release_id,release_sequence:manifest.release_sequence,version:manifest.version.clone(),manifest_sha256:hash(&decoded.payload_bytes),keyring_generation:trust.updater_binding().keyring_generation});
if manifest.release_id!=trust.predecessor().release_id {
let readers=[ctx.pin.agent.service_sid.clone(),ctx.pin.helper.service_sid.clone()];
let(f,settings)=Protected::read_shared(Path::new(Role::Settings.target()),32768,&readers)?;protected.push(f);
let(f,pin)=Protected::read_shared(Path::new(Role::Pin.target()),32768,&readers)?;protected.push(f);
let(f,time)=Protected::read_shared(Path::new(Role::TimeProfile.target()),32768,&readers)?;protected.push(f);
let(f,candidate_time)=Protected::read(Path::new(r"C:\ProgramData\RustDiscoveryUpdater\candidate-time-profile.json"),32768)?;protected.push(f);
let rendered=transition::render(transition::Inputs{settings:&settings,pin:&pin,time_profile:&time,qualified_candidate_time_profile:&candidate_time,target_agent_sha256:&manifest.artifacts[0].sha256,target_helper_sha256:&manifest.artifacts[1].sha256})?;
let update=ResolvedAgentUpdate{schema_version:1,profile:UpdateProfile::FixedCodePairV1,release_envelope:candidate.clone(),release_envelope_sha256:candidate.sha256().map_err(anyhow::Error::msg)?,manifest_sha256:hash(&decoded.payload_bytes),predecessor:trust.predecessor().clone(),updater:trust.updater_binding().clone(),peer_pin_transition:rendered.proof().clone(),recovery:Recovery::RestoreExactPredecessorOnce,health_profile:HealthProfile::MtlsInventorySyncV1,health_timeout_seconds:180,no_reboot:true};
ensure!(update.validate(),"UPDATE_OBSERVE_RENDERED_PLAN");
previews.push(CandidatePreview{release_id:manifest.release_id,manifest_sha256:update.manifest_sha256,peer_pin_transition:update.peer_pin_transition});
}
}
running.check(&budget)?;updater.check()?;registry.verify()?;trust.recheck_protected()?;
for file in protected {file.verify()?;}
ensure!(require_sync(&ctx,request.generation)?==decision,"UPDATE_OBSERVE_SIGNED_HEAD_CHANGED");
let observed_at=ctx.clock.now()?;
let observed_at=observed_at-chrono::Duration::nanoseconds(i64::from(observed_at.timestamp_subsec_nanos()%1_000_000));
let observation=AgentUpdateObservation{schema_version:1,platform:crate::release_platform::WIRE,observed_at,quality:ObservationQuality::Valid,predecessor:Some(trust.predecessor().clone()),updater:Some(trust.updater_binding().clone()),activation_floor:Some(trust.activation_floor()),rolled_back:false,helper_observation_sha256:Some(hash(&serde_json::to_vec(&(running.proofs(),updater_identity,decision,request.generation,&previews))?)),signed_sync_decision_id:Some(decision),candidate_previews:previews};
ensure!(observation.validate() && catalog.validate(observed_at,observed_at),"UPDATE_OBSERVE_OUTPUT_SHAPE");
Ok(Response{generation:request.generation,observation,catalog,installed_record:trust.installed_raw().to_vec()})
}
impl Response {
pub fn validate(&self,generation:u64)->Result<()> {
ensure!(self.generation==generation && self.observation.platform==crate::release_platform::WIRE && self.observation.quality==ObservationQuality::Valid && self.observation.validate() && self.catalog.validate(self.observation.observed_at,self.observation.observed_at),"UPDATE_OBSERVE_RESPONSE");
let record=rmm_domain::agent_update_provisioning::InstalledReleaseRecord::from_bytes(&self.installed_record).map_err(anyhow::Error::msg)?;
let predecessor=self.observation.predecessor.as_ref().context("UPDATE_OBSERVE_PREDECESSOR")?;
let manifest=record.release_envelope.decode().map_err(anyhow::Error::msg)?.manifest;
ensure!(hash(&self.installed_record)==predecessor.installed_record_sha256 && record.manifest_sha256==predecessor.manifest_sha256 && manifest.release_id==predecessor.release_id && manifest.release_sequence==predecessor.release_sequence && manifest.artifacts[0].sha256==predecessor.agent_sha256 && manifest.artifacts[1].sha256==predecessor.helper_sha256 && Some(record.activation_floor)==self.observation.activation_floor && record.rolled_back==self.observation.rolled_back,"UPDATE_OBSERVE_RECORD_BINDING");
Ok(())
}
}
+196
View File
@@ -0,0 +1,196 @@
//! Independently reverify the retained ORIGINAL request, never an IPC-supplied
//! approval bit, a replacement request or a renewed start window.
//! Windows SYSTEM/code-pair-clock profile only; no Linux or four-file fallback.
use crate::update_native::Budget;
use anyhow::{Result, ensure};
use rmm_agent_core::{
auth::{Binding, Request},
reconcile::SyncClock,
};
use rmm_domain::{
agent_update::{ParticipantRole, ResolvedAgentUpdate, UpdateDelegation},
jobs::{Action, ExecutionPermitPayload, JobPayload, hash},
};
use rmm_updater_handoff::{Handoff, PinTransition, Service};
pub struct Original {
request: Request,
permit: ExecutionPermitPayload,
job: JobPayload,
update: ResolvedAgentUpdate,
handoff: Handoff,
delegation: UpdateDelegation,
start_bytes: Vec<u8>,
}
impl Original {
/// `start_bytes` must come from execution_evidence.start in the SAME
/// existing guarded ledger. This is validation only; callers must re-read
/// and compare that immutable row at each subsequent guarded operation.
pub fn verify(
binding: &Binding,
start_bytes: &[u8],
record: &[u8],
delegation: UpdateDelegation,
clock: &impl SyncClock,
budget: &Budget<'_>,
) -> Result<Self> {
let result = Self::verify_retained(binding, start_bytes, record, delegation)?;
result.check_current(binding, clock, budget)?;
Ok(result)
}
/// Historical evidence ONLY. Never supplies current boot/time/owner trust,
/// health authority, a new lease or permission for any native effect.
pub fn verify_retained(
binding: &Binding,
start_bytes: &[u8],
record: &[u8],
delegation: UpdateDelegation,
) -> Result<Self> {
ensure!(
!start_bytes.is_empty()
&& start_bytes.len() <= 512 * 1024
&& !record.is_empty()
&& record.len() <= rmm_updater_handoff::MAX_RECORD_BYTES,
"UPDATE_ORIGINAL_LIMIT"
);
let handoff: Handoff = serde_json::from_slice(record)?;
handoff.validate()?;
ensure!(
handoff.bytes()? == record
&& delegation.validate()
&& delegation.handoff_sha256 == hash(record)
&& delegation.owner_nonce == handoff.owner_nonce
&& delegation.boot_id == handoff.boot_id
&& delegation.updater.role == ParticipantRole::WindowsUpdater
&& delegation.updater.image_sha256 == handoff.updater_sha256
&& delegation.original_helper.image_sha256 == handoff.predecessor.helper_sha256
&& u64::try_from(delegation.prepared_at.timestamp())? == handoff.consumed_at,
"UPDATE_ORIGINAL_DELEGATION"
);
let start: serde_json::Value = serde_json::from_slice(start_bytes)?;
let request: Request = serde_json::from_value(start["request"].clone())?;
ensure!(
hash(start_bytes) == handoff.attempt.original_start_witness_sha256
&& hash(&serde_json::to_vec(&request)?) == handoff.attempt.original_request_sha256,
"UPDATE_ORIGINAL_START_CHANGED"
);
// Original consumption happened at the immutable prepared_at. It must
// have had a valid live start grant THEN. Current checks below constrain
// this one already consumed attempt; they grant no new start window.
let (job, permit) = binding.verify(&request, delegation.prepared_at)?;
ensure!(
rmm_agent_core::ledger::start_witness_bytes(
&permit,
&request,
handoff.boot_id,
delegation.prepared_at
)? == start_bytes,
"UPDATE_ORIGINAL_START_CHANGED"
);
ensure!(
job.execution_identity == "system"
&& permit.action == "update_agent"
&& Some(handoff.attempt.plan_id) == permit.agent_update_plan_id
&& handoff.attempt.tenant_id == permit.tenant_id
&& handoff.attempt.asset_id == permit.asset_id
&& handoff.attempt.agent_id == permit.agent_id
&& handoff.attempt.enrollment_generation == permit.enrollment_generation
&& handoff.attempt.assignment_version == permit.assignment_version
&& handoff.attempt.job_id == permit.job_id
&& handoff.attempt.attempt_id == permit.attempt_id
&& handoff.attempt.grant_id == permit.grant_id
&& handoff.attempt.authorization_id == permit.authorization_id
&& handoff.attempt.plan_sha256 == permit.plan_hash
&& handoff.attempt.job_payload_sha256 == permit.job_payload_hash,
"UPDATE_ORIGINAL_JOB_BINDING"
);
let Action::UpdateAgent { update } = &job.action else {
anyhow::bail!("UPDATE_ACTION_REQUIRED")
};
ensure!(
rmm_domain::agent_update::handoff_matches_job(&handoff, &job)
&& update.validate()
&& update.manifest_sha256 == handoff.target.manifest_sha256
&& update.predecessor.manifest_sha256 == handoff.predecessor.manifest_sha256
&& update.predecessor.agent_sha256 == handoff.predecessor.agent_sha256
&& update.predecessor.helper_sha256 == handoff.predecessor.helper_sha256
&& update.predecessor.installed_record_sha256 == handoff.predecessor_record_sha256
&& update.updater.binary_sha256 == handoff.updater_sha256
&& update.updater.policy_sha256 == handoff.updater_policy_sha256
&& matches!(
handoff.pin_transition,
PinTransition::WindowsCodePairClockV1
)
&& handoff.stop_set == [Service::WindowsAgent, Service::WindowsHelper],
"UPDATE_ORIGINAL_CODE_POLICY_BINDING"
);
let update = update.as_ref().clone();
let decoded = update
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
ensure!(
decoded.manifest.artifacts[0].sha256 == handoff.target.agent_sha256
&& decoded.manifest.artifacts[1].sha256 == handoff.target.helper_sha256,
"UPDATE_ORIGINAL_TARGET_PAIR"
);
let result = Self {
request,
permit,
job,
update,
handoff,
delegation,
start_bytes: start_bytes.to_vec(),
};
Ok(result)
}
pub fn check_current(
&self,
binding: &Binding,
clock: &impl SyncClock,
budget: &Budget<'_>,
) -> Result<()> {
ensure!(
budget.boot_id()? == self.handoff.boot_id,
"UPDATE_ORIGINAL_BOOT_CHANGED"
);
// Budget independently pins the actual native boot and monotonic
// lifetime. The trusted clock must cover its entire signed interval,
// rather than treating the local wall clock as a lower bound.
let (lower, upper) = clock.bounds()?;
ensure!(
lower <= upper
&& lower >= self.delegation.prepared_at
&& u64::try_from(upper.timestamp())? < self.handoff.finish_before
&& upper
< self.job.start_before
+ chrono::Duration::seconds(i64::from(self.job.max_runtime_seconds))
&& self.handoff.finish_before
<= self.handoff.consumed_at + u64::from(self.job.max_runtime_seconds),
"UPDATE_ORIGINAL_EXPIRED"
);
let (job, permit) = binding.verify(&self.request, self.delegation.prepared_at)?;
ensure!(
serde_json::to_vec(&job)? == serde_json::to_vec(&self.job)?
&& serde_json::to_vec(&permit)? == serde_json::to_vec(&self.permit)?,
"UPDATE_ORIGINAL_CHANGED"
);
Ok(())
}
pub fn handoff(&self) -> &Handoff {
&self.handoff
}
pub fn delegation(&self) -> &UpdateDelegation {
&self.delegation
}
pub fn update(&self) -> &ResolvedAgentUpdate {
&self.update
}
pub fn permit(&self) -> &ExecutionPermitPayload {
&self.permit
}
pub fn start_bytes(&self) -> &[u8] {
&self.start_bytes
}
}
+830
View File
@@ -0,0 +1,830 @@
//! Stable updater ownership of the existing SYSTEM ledger. No CREATE, schema
//! initialization, replayed activation, replacement ledger or reset is allowed.
use crate::{
helper_ipc::{self as ipc, PeerProof, PinnedFile},
signed_clock::BoundClock,
update_ipc,
update_native::{
Budget, Role,
files::{self, Location},
services::Stopped,
},
update_original::Original,
update_state::{AgentStateFile, Bundle, QualifiedRegistry, RetainedSet},
update_trust::TrustState,
};
use anyhow::{Context, Result, ensure};
use fs2::FileExt;
use rmm_agent_core::{
auth::Binding,
helper_reconcile::ExecutorLedgerGuard,
reconcile::SyncClock,
update_handoff::{
self as core, NativeEffect, NativeEffectStage, NativeFileRole, NativeService, Participant,
UpdateParticipantGuard,
},
};
use rmm_domain::{
agent_update::{ParticipantRole, UpdateDelegation},
jobs::hash,
};
use rmm_updater_handoff::{Event, Evidence, Handoff, Phase};
use rusqlite::{Connection, OpenFlags};
use std::{cell::RefCell, path::Path, time::Duration};
const ROOT: &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 AGENT_LOCK: &str = r"C:\ProgramData\RustDiscovery\state\agent.lock";
/// These are the TWO original locks used by the registered helper and agent,
/// acquired only after their exact original instances have terminated.
pub struct ClosedFiles {
root: RefCell<PinnedFile>,
ledger: RefCell<PinnedFile>,
executor: RefCell<PinnedFile>,
agent: RefCell<AgentStateFile>,
}
impl ClosedFiles {
pub fn acquire(bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result<Self> {
bundle.validate()?;
stopped.check(budget)?;
let helper = ipc::service_sid(ipc::HELPER_SERVICE)?;
let root = PinnedFile::open(
Path::new(ROOT),
true,
&[],
std::slice::from_ref(&helper),
true,
)?;
let executor = PinnedFile::open(
Path::new(LOCK),
false,
&[],
std::slice::from_ref(&helper),
true,
)?;
ensure!(
executor.identity == bundle.ledger.lock,
"UPDATE_ORIGINAL_LOCK_IDENTITY"
);
executor
.file
.try_lock_exclusive()
.context("UPDATE_ORIGINAL_EXECUTOR_BUSY")?;
let agent = AgentStateFile::lock()?;
let expected_agent = bundle
.retained
.iter()
.find(|p| p.spec.path == Path::new(AGENT_LOCK))
.context("UPDATE_ORIGINAL_AGENT_LOCK_REQUIRED")?;
ensure!(
agent.identity == expected_agent.spec.identity,
"UPDATE_ORIGINAL_AGENT_LOCK_IDENTITY"
);
agent
.file
.try_lock_exclusive()
.context("UPDATE_ORIGINAL_AGENT_BUSY")?;
let ledger = PinnedFile::open(Path::new(LEDGER), false, &[], &[helper], true)?;
ensure!(
ledger.identity == bundle.ledger.ledger,
"UPDATE_ORIGINAL_LEDGER_IDENTITY"
);
stopped.check(budget)?;
let value = Self {
root: RefCell::new(root),
ledger: RefCell::new(ledger),
executor: RefCell::new(executor),
agent: RefCell::new(agent),
};
value.verify(bundle, stopped, budget)?;
Ok(value)
}
fn verify(&self, bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result<()> {
stopped.check(budget)?;
for file in [&self.root, &self.ledger, &self.executor] {
file.try_borrow_mut()?.check()?;
}
self.agent.try_borrow()?.check()?;
ensure!(
self.ledger.try_borrow()?.identity == bundle.ledger.ledger
&& self.executor.try_borrow()?.identity == bundle.ledger.lock,
"UPDATE_OWNED_LEDGER_REPLACED"
);
Ok(())
}
}
/// Produced by consuming both actually-held original locks after the SQLite
/// connection has closed; the retained handles continue to pin their names.
pub struct ReleasedFiles {
files: ClosedFiles,
}
impl ReleasedFiles {
pub(crate) fn check(&self, bundle: &Bundle) -> Result<()> {
for file in [&self.files.root, &self.files.ledger, &self.files.executor] {
file.try_borrow_mut()?.check()?;
}
self.files.agent.try_borrow()?.check()?;
ensure!(
self.files.ledger.try_borrow()?.identity == bundle.ledger.ledger
&& self.files.executor.try_borrow()?.identity == bundle.ledger.lock,
"UPDATE_RELEASED_FILES_CHANGED"
);
Ok(())
}
}
impl ClosedFiles {
pub fn release(
self,
bundle: &Bundle,
stopped: &Stopped,
budget: &Budget<'_>,
) -> Result<ReleasedFiles> {
self.verify(bundle, stopped, budget)?;
FileExt::unlock(&self.executor.try_borrow()?.file)?;
FileExt::unlock(&self.agent.try_borrow()?.file)?;
let result = ReleasedFiles { files: self };
result.check(bundle)?;
Ok(result)
}
}
pub struct Inputs<'a, 'b> {
pub closed: &'a ClosedFiles,
pub stopped: &'a Stopped,
pub bundle: &'a Bundle,
pub bundle_recheck: &'a dyn Fn() -> Result<()>,
pub original: &'a Original,
pub binding: &'a Binding,
pub clock: &'a BoundClock,
pub budget: &'a Budget<'b>,
pub updater: &'a RefCell<PeerProof>,
pub retained: &'a RetainedSet,
pub registry: &'a QualifiedRegistry,
pub trust: &'a TrustState,
}
pub struct Guard<'a, 'b> {
input: Inputs<'a, 'b>,
sqlite: usize,
return_before: Option<u64>,
}
pub struct OwnedLedger<'a, 'b> {
db: Connection,
guard: Guard<'a, 'b>,
}
impl<'a, 'b> OwnedLedger<'a, 'b> {
pub fn open(input: Inputs<'a, 'b>) -> Result<Self> {
input
.closed
.verify(input.bundle, input.stopped, input.budget)?;
ensure!(
input.bundle.ledger.sha256()? == input.original.handoff().ledger_identity_sha256
&& input.retained.sha256()? == input.original.handoff().retained_state_sha256,
"UPDATE_ORIGINAL_STATE_BINDING"
);
let db = Connection::open_with_flags(
LEDGER,
OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_NO_MUTEX,
)?;
db.busy_timeout(Duration::ZERO)?;
ensure!(
db.query_row("PRAGMA journal_mode", [], |r| r.get::<_, String>(0))? == "delete"
&& db.query_row("PRAGMA synchronous", [], |r| r.get::<_, u32>(0))? >= 2,
"UPDATE_LEDGER_DURABILITY_REQUIRED"
);
let sqlite = unsafe { db.handle() } as usize;
let (count, max): (usize, Option<usize>) = db.query_row(
"SELECT count(*),max(length(event)) FROM agent_update_handoff_events WHERE grant_id=?1",
[input.original.permit().grant_id.to_string()],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
ensure!(
count <= rmm_updater_handoff::MAX_V2_EVENTS
&& max.is_none_or(|n| n <= rmm_updater_handoff::MAX_EVENT_BYTES),
"UPDATE_ORIGINAL_EVENT_LIMIT"
);
let mut query = db.prepare(
"SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence",
)?;
let rows = query
.query_map([input.original.permit().grant_id.to_string()], |r| {
r.get::<_, Vec<u8>>(0)
})?
.collect::<rusqlite::Result<Vec<_>>>()?;
drop(query);
let mut return_before = None;
for raw in rows {
let event: Event = serde_json::from_slice(&raw)?;
if matches!(event.evidence, Evidence::LedgerReturnIntent) {
ensure!(
return_before.is_none(),
"UPDATE_MULTIPLE_ORIGINAL_RETURN_EVENTS"
);
return_before = Some(
event
.observed_at
.checked_add(180)
.context("UPDATE_RETURN_DEADLINE_OVERFLOW")?,
);
}
}
let guard = Guard {
input,
sqlite,
return_before,
};
guard.check(&db)?;
core::read(&db, &guard, guard.input.original.permit().grant_id)?;
guard
.input
.trust
.qualify_history(&db, &guard, guard.input.binding)?;
db.execute_batch("PRAGMA foreign_keys=ON")?;
ensure!(
db.query_row("PRAGMA foreign_keys", [], |r| r.get::<_, bool>(0))?,
"UPDATE_LEDGER_FOREIGN_KEYS_REQUIRED"
);
rmm_agent_core::ledger::bounded_journal_capacity(&db)?;
Ok(Self { db, guard })
}
pub fn record_stops(
&mut self,
observations: crate::update_native::control_fence::StopObservations,
) -> Result<()> {
self.guard.effect_window()?;
ensure!(
self.guard.input.stopped.proofs() == observations.proofs,
"UPDATE_STOP_SOURCE_CHANGED"
);
for (claim, observed) in observations.claims.iter().zip(&observations.observations) {
core::observe_native_effect(
&mut self.db,
&self.guard,
claim,
observed,
self.guard.input.clock.reading()?.upper,
)?;
}
self.append(Evidence::AllStopped {
observation_sha256: hash(&serde_json::to_vec(self.guard.input.stopped.proofs())?),
})?;
let owner = &self.guard.input.original.delegation().updater;
self.append(Evidence::UpdaterOwnsLedger {
process: rmm_updater_handoff::Process {
pid: owner.pid,
birth: owner.birth,
image_sha256: owner.image_sha256.clone(),
},
ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?,
})
}
fn append(&mut self, evidence: Evidence) -> Result<()> {
let grant = self.guard.input.original.permit().grant_id;
let journal = core::read(&self.db, &self.guard, grant)?;
let event = journal.prepare(
u64::try_from(self.guard.input.clock.reading()?.upper.timestamp())?,
evidence,
)?;
core::append(
&mut self.db,
&self.guard,
grant,
journal.head_sha256(),
&event,
)
}
pub fn prepare_return_and_close(
mut self,
) -> Result<crate::update_native::control_fence::PreparedStart> {
self.guard.effect_window()?;
let grant = self.guard.input.original.permit().grant_id;
let journal = core::read(&self.db, &self.guard, grant)?;
ensure!(
journal.phase() == Phase::PairVerified,
"UPDATE_VERIFIED_PAIR_REQUIRED"
);
let now = self.guard.input.clock.reading()?.upper;
let event = journal.prepare(
u64::try_from(now.timestamp())?,
Evidence::LedgerReturnIntent,
)?;
let claims = core::prepare_windows_return_and_starts(
&mut self.db,
&self.guard,
grant,
journal.head_sha256(),
&event,
now,
)?;
let proof = core::current_proof(&self.db, &self.guard, grant)?
.context("UPDATE_RETURN_PREFIX_REQUIRED")?;
self.close()?;
Ok(
crate::update_native::control_fence::PreparedStart::after_closed_connection(
claims, proof,
),
)
}
pub fn parts(&mut self) -> (&mut Connection, &Guard<'a, 'b>) {
(&mut self.db, &self.guard)
}
pub fn close(self) -> Result<()> {
self.guard.check(&self.db)?;
self.db.close().map_err(|(_, error)| error)?;
self.guard.input.closed.verify(
self.guard.input.bundle,
self.guard.input.stopped,
self.guard.input.budget,
)
}
}
impl Guard<'_, '_> {
fn current(&self) -> Result<()> {
let i = &self.input;
(i.bundle_recheck)()?;
i.closed.verify(i.bundle, i.stopped, i.budget)?;
Original::verify_retained(
i.binding,
i.original.start_bytes(),
&i.original.handoff().bytes()?,
i.original.delegation().clone(),
)?;
i.trust.recheck_protected()?;
let updater_pin = crate::update_native::services::updater_pin(i.trust.policy())?;
let updater_configuration =
crate::update_native::services::updater_configuration_sha256(&updater_pin)?;
ensure!(
updater_configuration == i.trust.policy().updater_service.unit_sha256,
"UPDATE_UPDATER_CONFIGURATION_CHANGED"
);
i.registry
.verify_observed(i.stopped.proofs(), &updater_configuration)?;
i.retained.verify()?;
let mut updater = i.updater.try_borrow_mut()?;
updater.check()?;
ensure!(
update_ipc::participant(&updater, ParticipantRole::WindowsUpdater)?
== i.original.delegation().updater,
"UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED"
);
Ok(())
}
fn effect_window(&self) -> Result<()> {
self.current()?;
let i = &self.input;
i.original.check_current(i.binding, i.clock, i.budget)?;
if let Some(until) = self.return_before {
ensure!(
u64::try_from(i.clock.reading()?.upper.timestamp())? < until,
"UPDATE_ORIGINAL_HEALTH_WINDOW_EXPIRED"
);
}
i.trust.recheck_prepared(i.original.update(), i.clock)
}
fn same(&self, h: &Handoff, d: &UpdateDelegation) -> Result<()> {
ensure!(
h.bytes()? == self.input.original.handoff().bytes()?
&& d == self.input.original.delegation(),
"UPDATE_ORIGINAL_OWNER_CHANGED"
);
self.current()
}
fn file(&self, role: Role, location: Location, candidate: bool) -> Result<()> {
let bound = self
.input
.bundle
.files
.iter()
.find(|v| v.role == role)
.context("UPDATE_ORIGINAL_ROLE_REQUIRED")?;
let expected = if candidate {
&bound.staged
} else {
&bound.original
};
ensure!(
files::observe_bound(
role,
self.input.original.handoff().owner_nonce,
location,
self.input.budget
)? == *expected,
"UPDATE_OWNED_FILE_CHANGED"
);
Ok(())
}
fn pair(&self, candidate: bool) -> Result<()> {
for f in &self.input.bundle.files {
self.file(f.role, Location::Target, candidate)?;
self.file(
f.role,
if candidate {
Location::Previous
} else {
Location::Rejected
},
!candidate,
)?;
}
Ok(())
}
}
impl ExecutorLedgerGuard for Guard<'_, '_> {
fn check(&self, db: &Connection) -> Result<()> {
self.current()?;
self.input
.stopped
.verify_failure_claims(db, self.input.original.handoff())?;
ensure!(
unsafe { db.handle() } as usize == self.sqlite && db.path() == Some(LEDGER),
"UPDATE_OWNED_SQLITE_CONNECTION_CHANGED"
);
let start: Vec<u8> = db.query_row(
"SELECT start FROM execution_evidence WHERE grant_id=?1",
[self.input.original.permit().grant_id.to_string()],
|r| r.get(0),
)?;
ensure!(
start == self.input.original.start_bytes(),
"UPDATE_ORIGINAL_START_CHANGED"
);
let other: u64 = db.query_row(
"SELECT count(*) FROM consumed WHERE result IS NULL AND grant_id<>?1",
[self.input.original.permit().grant_id.to_string()],
|r| r.get(0),
)?;
ensure!(other == 0, "UPDATE_OTHER_UNRESOLVED_ATTEMPT");
Ok(())
}
fn check_update_owner(
&self,
h: &Handoff,
d: &UpdateDelegation,
phase: Phase,
_events: &[Event],
) -> Result<()> {
ensure!(
!matches!(
phase,
Phase::HandoffConsumed
| Phase::ServicesStarted
| Phase::HealthVerified
| Phase::RollbackServicesStarted
| Phase::RollbackHealthVerified
| Phase::OutcomePersisted
),
"UPDATE_STABLE_WRITER_PHASE"
);
self.same(h, d)?;
self.effect_window()
}
}
fn role(r: NativeFileRole) -> Result<Role> {
Ok(match r {
NativeFileRole::AgentBinary => Role::Agent,
NativeFileRole::HelperBinary => Role::Helper,
NativeFileRole::WindowsSettings => Role::Settings,
NativeFileRole::WindowsPin => Role::Pin,
NativeFileRole::WindowsTimeProfile => Role::TimeProfile,
_ => anyhow::bail!("UPDATE_WINDOWS_FILE_ROLE_REQUIRED"),
})
}
impl UpdateParticipantGuard for Guard<'_, '_> {
fn participant(&self) -> Participant {
Participant::StableUpdater
}
fn verify_native_effect(
&self,
h: &Handoff,
d: &UpdateDelegation,
effect: &NativeEffect,
stage: NativeEffectStage,
) -> Result<()> {
self.same(h, d)?;
self.effect_window()?;
match (effect, stage) {
(
NativeEffect::StartService { .. } | NativeEffect::RollbackStopService { .. },
NativeEffectStage::ObserveNonstart,
) => self
.input
.stopped
.failure_observation(h, d, effect, self.input.budget)
.map(|_| ()),
(NativeEffect::StopService { service }, NativeEffectStage::Observe) => {
let expected = match service {
NativeService::WindowsAgent => super::update_native::Service::Agent,
NativeService::WindowsHelper => super::update_native::Service::Helper,
_ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_REQUIRED"),
};
ensure!(
self.input
.stopped
.proofs()
.iter()
.any(|p| p.configuration.service == expected),
"UPDATE_STOPPED_ORIGINAL_SERVICE_REQUIRED"
);
self.input.stopped.check(self.input.budget)
}
(NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Claim) => {
self.file(role(*r)?, Location::Target, false)?;
self.file(role(*r)?, Location::Stage, true)
}
(NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Observe) => {
self.file(role(*r)?, Location::Previous, false)
}
(NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Claim) => {
self.file(role(*r)?, Location::Previous, false)?;
self.file(role(*r)?, Location::Stage, true)
}
(NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Observe) => {
self.file(role(*r)?, Location::Target, true)
}
(NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Claim) => {
self.file(role(*r)?, Location::Target, true)?;
self.file(role(*r)?, Location::Previous, false)
}
(NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Observe) => {
self.file(role(*r)?, Location::Rejected, true)
}
(NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Claim) => {
self.file(role(*r)?, Location::Previous, false)?;
self.file(role(*r)?, Location::Rejected, true)
}
(NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Observe) => {
self.file(role(*r)?, Location::Target, false)
}
(NativeEffect::ReturnLedger, NativeEffectStage::Claim) => self.pair(true),
(NativeEffect::RollbackReturnLedger, NativeEffectStage::Claim) => self.pair(false),
(
NativeEffect::StartService {
service: NativeService::WindowsHelper | NativeService::WindowsAgent,
},
NativeEffectStage::ReserveFutureStart,
) => self.pair(true),
(
NativeEffect::RollbackStartService {
service: NativeService::WindowsHelper | NativeService::WindowsAgent,
},
NativeEffectStage::ReserveFutureStart,
) => self.pair(false),
_ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EFFECT_NOT_QUALIFIED"),
}
}
fn native_observation_sha256(
&self,
h: &Handoff,
d: &UpdateDelegation,
effect: &NativeEffect,
stage: NativeEffectStage,
) -> Result<String> {
self.same(h, d)?;
self.effect_window()?;
ensure!(
stage == NativeEffectStage::ObserveNonstart,
"UPDATE_KNOWN_NONSTART_STAGE_REQUIRED"
);
self.input
.stopped
.failure_observation(h, d, effect, self.input.budget)
}
fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> {
self.same(h, d)?;
if matches!(event.evidence, Evidence::Unknown { .. }) {
return Ok(());
}
self.effect_window()?;
match &event.evidence {
Evidence::AllStopped { observation_sha256 } => ensure!(
*observation_sha256 == hash(&serde_json::to_vec(self.input.stopped.proofs())?),
"UPDATE_STOPPED_OBSERVATION_CHANGED"
),
Evidence::UpdaterOwnsLedger {
process,
ledger_identity_sha256,
} => ensure!(
process.pid == d.updater.pid
&& process.birth == d.updater.birth
&& process.image_sha256 == d.updater.image_sha256
&& *ledger_identity_sha256 == self.input.bundle.ledger.sha256()?,
"UPDATE_UPDATER_OWNER_OBSERVATION_CHANGED"
),
Evidence::ReplaceIntent { role: r } => {
let r = self
.input
.bundle
.files
.iter()
.find(|v| v.role.handoff_role() == *r)
.context("UPDATE_ORIGINAL_ROLE_REQUIRED")?
.role;
self.file(r, Location::Target, false)?;
self.file(r, Location::Stage, true)?;
}
Evidence::Replaced {
role: r,
observed_sha256,
} => {
let f = self
.input
.bundle
.files
.iter()
.find(|v| v.role.handoff_role() == *r)
.context("UPDATE_ORIGINAL_ROLE_REQUIRED")?;
ensure!(
*observed_sha256 == f.staged.sha256,
"UPDATE_REPLACED_HASH_CHANGED"
);
self.file(f.role, Location::Target, true)?;
self.file(f.role, Location::Previous, false)?;
}
Evidence::PairVerified {
pair,
retained_state_sha256,
} => {
ensure!(
*pair == h.target && *retained_state_sha256 == self.input.retained.sha256()?,
"UPDATE_PAIR_OBSERVATION_CHANGED"
);
self.pair(true)?;
}
Evidence::LedgerReturnIntent => self.pair(true)?,
Evidence::RollbackIntent {
cause:
rmm_updater_handoff::RollbackCause::StartupFailed {
service: rmm_updater_handoff::Service::WindowsHelper,
},
failure_observation_sha256,
} => {
let failed = self
.input
.stopped
.failed_start()
.context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?;
ensure!(
*failure_observation_sha256 == failed.sha256()?,
"UPDATE_ACTUAL_HELPER_FAILURE_CHANGED"
);
self.input.stopped.failure_observation(
h,
d,
&NativeEffect::StartService {
service: NativeService::WindowsHelper,
},
self.input.budget,
)?;
self.pair(true)?;
}
Evidence::RollbackStopped {
process,
ledger_identity_sha256,
observation_sha256,
} => {
let failed = self
.input
.stopped
.failed_start()
.context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?;
ensure!(
process.pid == d.updater.pid
&& process.birth == d.updater.birth
&& process.image_sha256 == d.updater.image_sha256
&& *ledger_identity_sha256 == self.input.bundle.ledger.sha256()?
&& *observation_sha256
== hash(&serde_json::to_vec(&(failed, self.input.stopped.proofs()))?),
"UPDATE_ACTUAL_ROLLBACK_STOPPED_CHANGED"
);
self.input.stopped.check(self.input.budget)?;
}
Evidence::RestoreIntent { role: r }
| Evidence::CandidatePreserved { role: r, .. }
| Evidence::PredecessorRestored { role: r, .. } => {
let bound = self
.input
.bundle
.files
.iter()
.find(|f| f.role.handoff_role() == *r)
.context("UPDATE_ORIGINAL_RESTORE_ROLE_REQUIRED")?;
match &event.evidence {
Evidence::RestoreIntent { .. } => {
self.file(bound.role, Location::Target, true)?;
self.file(bound.role, Location::Previous, false)?;
}
Evidence::CandidatePreserved {
observation_sha256, ..
} => {
self.file(bound.role, Location::Rejected, true)?;
self.file(bound.role, Location::Previous, false)?;
ensure!(
*observation_sha256 == hash(&serde_json::to_vec(&bound.staged)?),
"UPDATE_ACTUAL_PRESERVED_CANDIDATE_CHANGED"
);
}
Evidence::PredecessorRestored {
observed_sha256, ..
} => {
self.file(bound.role, Location::Target, false)?;
self.file(bound.role, Location::Rejected, true)?;
ensure!(
*observed_sha256 == bound.original.sha256,
"UPDATE_ACTUAL_RESTORED_PREDECESSOR_CHANGED"
);
}
_ => unreachable!(),
}
}
Evidence::PredecessorVerified {
pair,
retained_state_sha256,
predecessor_record_sha256,
} => {
ensure!(
*pair == h.predecessor
&& *retained_state_sha256 == self.input.retained.sha256()?
&& *predecessor_record_sha256 == hash(self.input.trust.installed_raw()),
"UPDATE_PREDECESSOR_OBSERVATION_CHANGED"
);
self.pair(false)?;
}
Evidence::RollbackLedgerReturnIntent => self.pair(false)?,
// Failed-start/rollback events require a retained native failure
// source; a caller-provided reason or hash is never sufficient.
_ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EVENT_NOT_QUALIFIED"),
}
Ok(())
}
}
impl OwnedLedger<'_, '_> {
pub fn begin_failed_helper_rollback(&mut self) -> Result<()> {
self.guard.effect_window()?;
let failed = self
.guard
.input
.stopped
.failed_start()
.context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?;
ensure!(
failed.service() == crate::update_native::Service::Helper,
"UPDATE_HELPER_FAILURE_REQUIRED"
);
let grant = self.guard.input.original.permit().grant_id;
let journal = core::read(&self.db, &self.guard, grant)?;
core::begin_rollback(
&mut self.db,
&self.guard,
grant,
journal.head_sha256(),
&rmm_updater_handoff::RollbackCause::StartupFailed {
service: rmm_updater_handoff::Service::WindowsHelper,
},
&failed.sha256()?,
self.guard.input.clock.reading()?.upper,
)?;
let owner = &self.guard.input.original.delegation().updater;
self.append(Evidence::RollbackStopped {
process: rmm_updater_handoff::Process {
pid: owner.pid,
birth: owner.birth,
image_sha256: owner.image_sha256.clone(),
},
ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?,
observation_sha256: hash(&serde_json::to_vec(&(
failed,
self.guard.input.stopped.proofs(),
))?),
})
}
pub fn prepare_rollback_return_and_close(
mut self,
) -> Result<crate::update_native::control_fence::PreparedStart> {
self.guard.effect_window()?;
let grant = self.guard.input.original.permit().grant_id;
let journal = core::read(&self.db, &self.guard, grant)?;
ensure!(
journal.phase() == Phase::PredecessorVerified,
"UPDATE_VERIFIED_PREDECESSOR_REQUIRED"
);
let now = self.guard.input.clock.reading()?.upper;
let event = journal.prepare(
u64::try_from(now.timestamp())?,
Evidence::RollbackLedgerReturnIntent,
)?;
let claims = core::prepare_windows_rollback_return_and_starts(
&mut self.db,
&self.guard,
grant,
journal.head_sha256(),
&event,
now,
)?;
let proof = core::current_proof(&self.db, &self.guard, grant)?
.context("UPDATE_ROLLBACK_RETURN_PREFIX_REQUIRED")?;
self.close()?;
Ok(
crate::update_native::control_fence::PreparedStart::after_closed_connection(
claims, proof,
),
)
}
}
+354
View File
@@ -0,0 +1,354 @@
//! Private Windows installed-record builder and fixed handle-based namespace.
//! Public metadata assembly is never permission to publish a record/floor.
use crate::{
helper_ipc::PinnedFile,
update_native::files::{self, Proof},
update_original::Original,
};
use anyhow::{Result, ensure};
use ed25519_dalek::{Signature, VerifyingKey};
use rmm_agent_core::update_handoff::{NativeEffect, NativeEffectClaim};
use rmm_domain::{
agent_update::ResolvedAgentUpdate,
agent_update_provisioning::{InstalledReleaseRecord, MAX_RECORD_BYTES},
jobs::hash,
};
use rmm_updater_handoff::{
Event, Evidence, HEALTH_DOMAIN, HealthReceipt, Journal, Phase, SignedHealth,
};
use std::{
fs::{File, OpenOptions},
io::Write,
os::windows::fs::OpenOptionsExt,
path::{Path, PathBuf},
};
use uuid::Uuid;
use windows_sys::Win32::Storage::FileSystem::*;
const ROOT: &str = r"C:\ProgramData\RustDiscoveryUpdater";
const CURRENT: &str = r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json";
const RECORDS: &str = r"C:\ProgramData\RustDiscoveryUpdater\records";
pub(crate) struct BuiltRecord {
record: InstalledReleaseRecord,
raw: Vec<u8>,
prior_raw: Vec<u8>,
old_sha256: String,
sha256: String,
grant_id: Uuid,
owner_nonce: Uuid,
}
impl BuiltRecord {
pub(crate) fn build(
original: &Original,
prior_raw: &[u8],
journal: &Journal,
health_event_raw: &[u8],
) -> Result<Self> {
let header = original.handoff();
let handoff_sha256 = hash(&header.bytes()?);
ensure!(
journal.phase() == Phase::HealthVerified
&& journal.handoff_sha256() == handoff_sha256
&& !health_event_raw.is_empty()
&& health_event_raw.len() <= rmm_updater_handoff::MAX_EVENT_BYTES
&& hash(health_event_raw) == journal.head_sha256(),
"UPDATE_RECORD_HEALTH_HEAD"
);
let event: Event = serde_json::from_slice(health_event_raw)?;
ensure!(
serde_json::to_vec(&event)? == health_event_raw
&& event.handoff_sha256 == handoff_sha256
&& event.boot_id == header.boot_id,
"UPDATE_RECORD_HEALTH_EVENT"
);
let Evidence::HealthVerified { receipt: signed } = &event.evidence else {
anyhow::bail!("UPDATE_RECORD_HEALTH_REQUIRED")
};
ensure!(
!signed.payload.is_empty()
&& signed.payload.len() <= 4096
&& signed.signature.len() == 64,
"UPDATE_RECORD_HEALTH_LIMIT"
);
let receipt: HealthReceipt = serde_json::from_slice(&signed.payload)?;
ensure!(
serde_json::to_vec(&receipt)? == signed.payload,
"UPDATE_RECORD_HEALTH_NONCANONICAL"
);
// Journal possession is not independent key trust. Authenticate the
// exact receipt again with the ORIGINAL signed job's external key pin.
let raw: [u8; 32] = hex::decode(&original.update().updater.health_public_key_hex)?
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_RECORD_HEALTH_KEY"))?;
let public = VerifyingKey::from_bytes(&raw)?;
ensure!(!public.is_weak(), "UPDATE_RECORD_HEALTH_KEY");
let mut message = HEALTH_DOMAIN.to_vec();
message.extend_from_slice(&signed.payload);
public.verify_strict(&message, &Signature::from_slice(&signed.signature)?)?;
ensure!(
receipt.schema_version == 1
&& receipt.handoff_sha256 == handoff_sha256
&& receipt.owner_nonce == header.owner_nonce
&& receipt.boot_id == header.boot_id
&& receipt.helper_journal_id == header.helper_journal_id
&& receipt.agent_journal_id == header.agent_journal_id
&& receipt.connection_generation > header.connection_generation
&& !receipt.ready
&& receipt.issued_at >= header.consumed_at
&& receipt.issued_at <= event.observed_at
&& event.observed_at < receipt.valid_until
&& receipt.valid_until <= header.finish_before,
"UPDATE_RECORD_HEALTH_BINDING"
);
Self::assemble(
original.update(),
prior_raw,
&handoff_sha256,
signed,
&receipt,
header.attempt.grant_id,
header.owner_nonce,
)
}
fn assemble(
update: &ResolvedAgentUpdate,
prior_raw: &[u8],
handoff_sha256: &str,
signed: &SignedHealth,
receipt: &HealthReceipt,
grant_id: Uuid,
owner_nonce: Uuid,
) -> Result<Self> {
ensure!(
update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(),
"UPDATE_RECORD_INPUT"
);
let record = rmm_domain::agent_update_provisioning::assemble_updated_record(
update,
prior_raw,
handoff_sha256,
signed,
receipt,
)
.map_err(anyhow::Error::msg)?;
let old_sha256 = hash(prior_raw);
let raw = record.bytes().map_err(anyhow::Error::msg)?;
let sha256 = hash(&raw);
ensure!(sha256 != old_sha256, "UPDATE_RECORD_SAME_BYTES");
Ok(Self {
record,
raw,
prior_raw: prior_raw.to_vec(),
old_sha256,
sha256,
grant_id,
owner_nonce,
})
}
pub(crate) fn record(&self) -> &InstalledReleaseRecord {
&self.record
}
pub(crate) fn sha256(&self) -> &str {
&self.sha256
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
enum State {
Staged,
Archived,
Published,
}
pub(crate) struct Transition {
built: BuiltRecord,
root: std::cell::RefCell<PinnedFile>,
records: std::cell::RefCell<PinnedFile>,
old_proof: Proof,
new_proof: Proof,
new: File,
old: Option<File>,
stage: PathBuf,
archive: PathBuf,
state: State,
}
fn open(path: &Path, delete: bool) -> Result<File> {
let mut options = OpenOptions::new();
options
.read(true)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH);
if delete {
options
.access_mode(FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE)
.share_mode(FILE_SHARE_READ);
}
Ok(options.open(path)?)
}
fn read(path: &Path) -> Result<Proof> {
files::proof(&mut open(path, false)?, path, MAX_RECORD_BYTES as u64)
}
impl Transition {
pub(crate) fn prepare(built: BuiltRecord) -> Result<Self> {
let root = PinnedFile::open(Path::new(ROOT), true, &[], &[], false)?;
let records = PinnedFile::open(Path::new(RECORDS), true, &[], &[], false)?;
let mut original = open(Path::new(CURRENT), false)?;
let old_proof = files::proof(&mut original, Path::new(CURRENT), MAX_RECORD_BYTES as u64)?;
ensure!(
old_proof.sha256 == built.old_sha256,
"UPDATE_RECORD_ORIGINAL_FILE_REQUIRED"
);
let stage = Path::new(ROOT).join(format!(".rmm-record-{}.stage", built.owner_nonce));
let archive = Path::new(RECORDS).join(format!("{}.json", built.old_sha256));
ensure!(
!archive.try_exists()?,
"UPDATE_RECORD_ARCHIVE_ALREADY_PRESENT"
);
let mut new = files::create_record_stage(&original, &stage)?;
new.write_all(&built.raw)?;
new.sync_all()?;
let new_proof = files::proof(&mut new, &stage, MAX_RECORD_BYTES as u64)?;
ensure!(
new_proof.sha256 == built.sha256
&& new_proof.security_sha256 == old_proof.security_sha256
&& new_proof.identity != old_proof.identity,
"UPDATE_RECORD_STAGE_BINDING"
);
let result = Self {
built,
root: std::cell::RefCell::new(root),
records: std::cell::RefCell::new(records),
old_proof,
new_proof,
new,
old: None,
stage,
archive,
state: State::Staged,
};
result.verify()?;
Ok(result)
}
pub(crate) fn verify(&self) -> Result<()> {
self.root.try_borrow_mut()?.check()?;
self.records.try_borrow_mut()?.check()?;
match self.state {
State::Staged => ensure!(
read(Path::new(CURRENT))? == self.old_proof
&& read(&self.stage)? == self.new_proof
&& !self.archive.try_exists()?,
"UPDATE_RECORD_STAGED_NAMESPACE_CHANGED"
),
State::Archived => ensure!(
read(&self.archive)? == self.old_proof
&& read(&self.stage)? == self.new_proof
&& !Path::new(CURRENT).try_exists()?,
"UPDATE_RECORD_ARCHIVED_NAMESPACE_CHANGED"
),
State::Published => ensure!(
read(&self.archive)? == self.old_proof
&& read(Path::new(CURRENT))? == self.new_proof
&& !self.stage.try_exists()?,
"UPDATE_RECORD_PUBLISHED_NAMESPACE_CHANGED"
),
}
Ok(())
}
pub(crate) fn verify_original(&self, raw: &[u8]) -> Result<()> {
ensure!(
self.built.prior_raw == raw && hash(raw) == self.old_proof.sha256,
"UPDATE_RECORD_PREDECESSOR_CHANGED"
);
self.verify()
}
pub(crate) fn effect(&self) -> Result<NativeEffect> {
let old_sha256 = self.built.old_sha256.clone();
let new_sha256 = self.built.sha256.clone();
Ok(match self.state {
State::Staged => NativeEffect::SaveInstalledRecord {
old_sha256,
new_sha256,
},
State::Archived => NativeEffect::PublishInstalledRecord {
old_sha256,
new_sha256,
},
State::Published => anyhow::bail!("UPDATE_RECORD_ALREADY_PUBLISHED"),
})
}
pub(crate) fn verify_effect(&self, effect: &NativeEffect, observed: bool) -> Result<()> {
self.verify()?;
let expected = match (self.state, observed) {
(State::Staged, false) | (State::Archived, true) => NativeEffect::SaveInstalledRecord {
old_sha256: self.built.old_sha256.clone(),
new_sha256: self.built.sha256.clone(),
},
(State::Archived, false) | (State::Published, true) => {
NativeEffect::PublishInstalledRecord {
old_sha256: self.built.old_sha256.clone(),
new_sha256: self.built.sha256.clone(),
}
}
_ => anyhow::bail!("UPDATE_RECORD_EFFECT_PHASE"),
};
ensure!(
*effect == expected,
"UPDATE_RECORD_EXACT_NATIVE_EFFECT_REQUIRED"
);
Ok(())
}
pub(crate) fn apply(&mut self, claim: &NativeEffectClaim) -> Result<()> {
self.verify_effect(claim.effect(), false)?;
ensure!(
claim.grant_id() == self.built.grant_id
&& claim.owner_nonce() == self.built.owner_nonce,
"UPDATE_RECORD_ORIGINAL_CLAIM_REQUIRED"
);
match self.state {
State::Staged => {
let mut old = open(Path::new(CURRENT), true)?;
ensure!(
files::proof(&mut old, Path::new(CURRENT), MAX_RECORD_BYTES as u64)?
== self.old_proof,
"UPDATE_RECORD_OLD_HANDLE_CHANGED"
);
files::rename_record(&old, &self.archive)?;
ensure!(
files::proof(&mut old, &self.archive, MAX_RECORD_BYTES as u64)?
== self.old_proof,
"UPDATE_RECORD_ARCHIVE_READBACK"
);
self.old = Some(old);
self.state = State::Archived;
}
State::Archived => {
files::rename_record(&self.new, Path::new(CURRENT))?;
ensure!(
files::proof(&mut self.new, Path::new(CURRENT), MAX_RECORD_BYTES as u64)?
== self.new_proof,
"UPDATE_RECORD_PUBLISH_READBACK"
);
self.state = State::Published;
}
State::Published => anyhow::bail!("UPDATE_RECORD_NO_RETRY"),
}
self.verify()
}
pub(crate) fn observation(&self) -> Result<String> {
self.verify()?;
Ok(hash(&serde_json::to_vec(&(
self.state,
&self.old_proof,
&self.new_proof,
))?))
}
pub(crate) fn built(&self) -> &BuiltRecord {
&self.built
}
pub(crate) fn published(&self) -> Result<()> {
ensure!(
self.state == State::Published,
"UPDATE_RECORD_PUBLICATION_REQUIRED"
);
self.verify()
}
}
+727
View File
@@ -0,0 +1,727 @@
//! Original update state witnesses, never key contents or recovery authority.
//! The local retained list and compatible-reader registry are protected files;
//! none of their paths, identities or qualification hashes come from a job.
use crate::{
helper_ipc::{self as ipc, FileIdentity, PinnedFile},
update_native::{Role, files},
update_trust::{Protected, TrustState},
};
use anyhow::{Result, ensure};
use rmm_agent_core::auth::Request;
use rmm_domain::{
agent_update::UpdateDelegation, agent_update_provisioning::ActivationEvidence, jobs::hash,
};
use rmm_updater_handoff::Handoff;
use serde::{Deserialize, Serialize};
use std::{
fs::{File, OpenOptions},
io::Write,
mem::zeroed,
os::windows::{
fs::OpenOptionsExt,
io::{AsRawHandle, FromRawHandle},
},
path::{Path, PathBuf},
ptr,
};
use uuid::Uuid;
use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*};
pub const ROOT: &str = r"C:\ProgramData\RustDiscoveryUpdater";
const RETAINED: &str = r"C:\ProgramData\RustDiscoveryUpdater\retained-files.json";
const ATTEMPTS: &str = r"C:\ProgramData\RustDiscoveryUpdater\attempts";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Retention {
MutableDatabase,
ImmutableMetadata,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Spec {
pub path: PathBuf,
pub identity: FileIdentity,
pub retention: Retention,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Metadata {
pub bytes: u64,
pub created: u64,
pub modified: u64,
pub attributes: u32,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RetainedProof {
pub spec: Spec,
pub security_sha256: String,
pub immutable_metadata: Option<Metadata>,
}
struct Held {
file: File,
parents: Vec<File>,
proof: RetainedProof,
}
fn info(file: &File, dir: bool) -> Result<Metadata> {
let mut v: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
ensure!(
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut v) } != 0
&& v.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
&& (v.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == dir
&& (dir || v.nNumberOfLinks == 1),
"UPDATE_RETAINED_FILE_TYPE"
);
Ok(Metadata {
bytes: (u64::from(v.nFileSizeHigh) << 32) | u64::from(v.nFileSizeLow),
created: (u64::from(v.ftCreationTime.dwHighDateTime) << 32)
| u64::from(v.ftCreationTime.dwLowDateTime),
modified: (u64::from(v.ftLastWriteTime.dwHighDateTime) << 32)
| u64::from(v.ftLastWriteTime.dwLowDateTime),
attributes: v.dwFileAttributes,
})
}
fn open_meta(path: &Path, dir: bool) -> Result<File> {
// Do not request FILE_READ_DATA, even for the retained private TLS key.
let h = unsafe {
CreateFileW(
ipc::wide(path).as_ptr(),
FILE_READ_ATTRIBUTES | READ_CONTROL,
FILE_SHARE_READ | FILE_SHARE_WRITE,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | if dir { FILE_FLAG_BACKUP_SEMANTICS } else { 0 },
ptr::null_mut(),
)
};
ensure!(h != INVALID_HANDLE_VALUE, "UPDATE_RETAINED_OPEN");
let file = unsafe { File::from_raw_handle(h) };
info(&file, dir)?;
Ok(file)
}
fn fixed_namespace(path: &Path) -> bool {
path.is_absolute()
&& !path.to_string_lossy().starts_with(r"\\")
&& !path.to_string_lossy().contains("..")
&& [
r"C:\ProgramData\RustDiscovery\state",
r"C:\ProgramData\RustDiscoverySystem\state",
r"C:\ProgramData\RustDiscoverySystem\agent-intents",
]
.iter()
.any(|root| path.starts_with(root))
&& !path.as_os_str().to_string_lossy().contains('\0')
}
fn protected_metadata(file: &File, path: &Path) -> Result<()> {
if path.starts_with(r"C:\ProgramData\RustDiscovery\state") {
crate::native::private_path(path, false)
} else {
let writer = if path.starts_with(r"C:\ProgramData\RustDiscoverySystem\agent-intents") {
crate::SERVICE_NAME
} else {
ipc::HELPER_SERVICE
};
ipc::check_acl(
file.as_raw_handle(),
&[],
&[ipc::service_sid(writer)?],
None,
)
}
}
impl Held {
fn open(spec: Spec) -> Result<Self> {
ensure!(
fixed_namespace(&spec.path),
"UPDATE_RETAINED_FIXED_NAMESPACE"
);
let mut parents = Vec::new();
for parent in spec.path.ancestors().skip(1) {
parents.push(open_meta(parent, true)?);
}
let file = open_meta(&spec.path, false)?;
ensure!(
ipc::file_identity(&file)? == spec.identity,
"UPDATE_RETAINED_FILE_IDENTITY"
);
protected_metadata(&file, &spec.path)?;
let metadata = info(&file, false)?;
let proof = RetainedProof {
security_sha256: files::security_sha256(&file)?,
immutable_metadata: (spec.retention == Retention::ImmutableMetadata)
.then_some(metadata),
spec,
};
let held = Self {
file,
parents,
proof,
};
held.verify()?;
Ok(held)
}
fn verify(&self) -> Result<()> {
for parent in &self.parents {
info(parent, true)?;
}
let named = open_meta(&self.proof.spec.path, false)?;
protected_metadata(&named, &self.proof.spec.path)?;
ensure!(
ipc::file_identity(&named)? == self.proof.spec.identity
&& ipc::file_identity(&self.file)? == self.proof.spec.identity
&& files::security_sha256(&named)? == self.proof.security_sha256
&& self
.proof
.immutable_metadata
.as_ref()
.is_none_or(|v| info(&named, false).is_ok_and(|actual| &actual == v)),
"UPDATE_RETAINED_CHANGED"
);
Ok(())
}
}
/// Held access to the two fixed, LocalService-created agent state files.
/// The agent's existing private ACL contract permits its LocalService file
/// owner; SYSTEM helper policy files continue to use the stricter PinnedFile.
/// This pins names and security, and does not grant an executor/update effect.
pub(crate) struct AgentStateFile {
pub(crate) file: File,
pub(crate) identity: FileIdentity,
held: Held,
}
impl AgentStateFile {
pub(crate) fn journal() -> Result<Self> {
Self::open(
Path::new(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite"),
false,
)
}
pub(crate) fn lock() -> Result<Self> {
Self::open(
Path::new(r"C:\ProgramData\RustDiscovery\state\agent.lock"),
true,
)
}
fn open(path: &Path, write: bool) -> Result<Self> {
crate::native::private_path(Path::new(r"C:\ProgramData\RustDiscovery\state"), true)?;
let file = OpenOptions::new()
.read(true)
.write(write)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(path)?;
info(&file, false)?;
let identity = ipc::file_identity(&file)?;
let held = Held::open(Spec {
path: path.into(),
identity,
retention: Retention::MutableDatabase,
})?;
let result = Self {
file,
identity,
held,
};
result.check()?;
Ok(result)
}
pub(crate) fn check(&self) -> Result<()> {
self.held.verify()?;
info(&self.file, false)?;
ensure!(
ipc::file_identity(&self.file)? == self.identity
&& files::security_sha256(&self.file)? == self.held.proof.security_sha256,
"UPDATE_AGENT_STATE_CHANGED"
);
Ok(())
}
}
fn key_paths() -> Result<std::collections::BTreeSet<PathBuf>> {
let mut keys = std::collections::BTreeSet::new();
for entry in std::fs::read_dir(r"C:\ProgramData\RustDiscovery\state")? {
let entry = entry?;
let path = entry.path();
if path.extension().is_some_and(|v| v == "key") {
let name = path
.file_name()
.and_then(|v| v.to_str())
.ok_or_else(|| anyhow::anyhow!("UPDATE_RETAINED_KEY_NAME"))?;
ensure!(
name == "device.key"
|| name
.strip_prefix("device-")
.and_then(|v| v.strip_suffix(".key"))
.is_some_and(|v| Uuid::parse_str(v).is_ok_and(|id| id.to_string() == v)),
"UPDATE_RETAINED_KEY_NAME"
);
ensure!(
keys.len() < 64 && keys.insert(path),
"UPDATE_RETAINED_KEY_LIMIT"
);
}
}
ensure!(!keys.is_empty(), "UPDATE_RETAINED_KEYS_MISSING");
Ok(keys)
}
const MANDATORY: [(&str, Retention); 9] = [
(
r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite",
Retention::MutableDatabase,
),
(
r"C:\ProgramData\RustDiscovery\state\consumption.sqlite",
Retention::MutableDatabase,
),
(
r"C:\ProgramData\RustDiscovery\state\agent.lock",
Retention::ImmutableMetadata,
),
(
r"C:\ProgramData\RustDiscovery\state\identity.json",
Retention::ImmutableMetadata,
),
(
r"C:\ProgramData\RustDiscovery\state\device.key",
Retention::ImmutableMetadata,
),
(
r"C:\ProgramData\RustDiscovery\state\device.pem",
Retention::ImmutableMetadata,
),
(
r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite",
Retention::MutableDatabase,
),
(
r"C:\ProgramData\RustDiscoverySystem\state\executor.lock",
Retention::ImmutableMetadata,
),
(
r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite",
Retention::MutableDatabase,
),
];
pub struct RetainedSet {
config: Protected,
files: Vec<Held>,
proofs: Vec<RetainedProof>,
}
impl RetainedSet {
/// Administrative read-only metadata, not an admitted retained set or lease.
/// The original key data and mutable SQLite contents are never read here.
pub fn bootstrap_metadata() -> Result<Vec<RetainedProof>> {
let mut specs = MANDATORY
.iter()
.map(|(p, r)| (PathBuf::from(p), *r))
.collect::<std::collections::BTreeMap<_, _>>();
for key in key_paths()? {
specs.insert(key, Retention::ImmutableMetadata);
}
ensure!(specs.len() <= 64, "UPDATE_RETAINED_LIMIT");
let mut held = Vec::new();
for (path, retention) in specs {
let file = open_meta(&path, false)?;
held.push(Held::open(Spec {
identity: ipc::file_identity(&file)?,
path,
retention,
})?);
}
for file in &held {
file.verify()?;
}
Ok(held.iter().map(|file| file.proof.clone()).collect())
}
pub fn capture() -> Result<Self> {
let (config, raw) = Protected::read(Path::new(RETAINED), 65536)?;
let specs: Vec<Spec> = serde_json::from_slice(&raw)?;
ensure!(
!specs.is_empty() && specs.len() <= 64,
"UPDATE_RETAINED_LIMIT"
);
let mut files = Vec::new();
for spec in specs {
ensure!(
!files.iter().any(|h: &Held| h.proof.spec.path == spec.path),
"UPDATE_RETAINED_DUPLICATE"
);
files.push(Held::open(spec)?);
}
for (path, retention) in MANDATORY {
ensure!(
files
.iter()
.any(|h| h.proof.spec.path == Path::new(path)
&& h.proof.spec.retention == retention),
"UPDATE_RETAINED_MANDATORY"
);
}
// Read only names/metadata, never another role's SQLite or key data.
// Include EVERY immutable private key namespace member, so the current
// selector cannot name an unretained key; accepted jobs prevent normal
// TLS rotation and verify() rejects an added/removed key meanwhile.
for key in key_paths()? {
ensure!(
files.iter().any(|h| h.proof.spec.path == key
&& h.proof.spec.retention == Retention::ImmutableMetadata),
"UPDATE_RETAINED_TLS_KEYS"
);
}
let proofs = files.iter().map(|h| h.proof.clone()).collect();
let value = Self {
config,
files,
proofs,
};
value.verify()?;
Ok(value)
}
/// Reopen exactly the original public metadata set; no local JSON edit can
/// substitute a new key, journal inode or immutable identity after consume.
pub fn reopen(proofs: &[RetainedProof]) -> Result<Self> {
let result = Self::capture()?;
ensure!(
result.proofs == proofs,
"UPDATE_RETAINED_ORIGINAL_SET_CHANGED"
);
Ok(result)
}
pub fn verify(&self) -> Result<()> {
self.config.verify()?;
for f in &self.files {
f.verify()?;
}
let actual = key_paths()?;
let expected = self
.files
.iter()
.filter(|f| {
f.proof.spec.path.parent() == Some(Path::new(r"C:\ProgramData\RustDiscovery\state"))
&& f.proof.spec.path.extension().is_some_and(|v| v == "key")
})
.map(|f| f.proof.spec.path.clone())
.collect::<std::collections::BTreeSet<_>>();
ensure!(actual == expected, "UPDATE_RETAINED_TLS_NAMESPACE_CHANGED");
Ok(())
}
pub fn proofs(&self) -> &[RetainedProof] {
&self.proofs
}
pub fn sha256(&self) -> Result<String> {
Ok(hash(&serde_json::to_vec(&self.proofs)?))
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BoundFile {
pub role: Role,
pub original: files::Proof,
pub staged: files::Proof,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LedgerIdentity {
pub ledger: FileIdentity,
pub lock: FileIdentity,
}
impl LedgerIdentity {
pub fn sha256(&self) -> Result<String> {
Ok(hash(&serde_json::to_vec(self)?))
}
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Bundle {
pub schema_version: u32,
pub original: Request,
pub handoff_record: Vec<u8>,
pub delegation: UpdateDelegation,
pub files: Vec<BoundFile>,
pub retained: Vec<RetainedProof>,
pub ledger: LedgerIdentity,
/// ORIGINAL retained signed decision and request, not a claimed ready bit.
pub signed_sync_response: Vec<u8>,
pub signed_sync_request: Vec<u8>,
}
impl Bundle {
pub fn validate(&self) -> Result<Handoff> {
ensure!(
self.schema_version == 1 && self.handoff_record.len() <= 65536,
"UPDATE_BUNDLE_SCHEMA"
);
let h: Handoff = serde_json::from_slice(&self.handoff_record)?;
h.validate()?;
ensure!(
h.bytes()? == self.handoff_record
&& h.pin_transition == rmm_updater_handoff::PinTransition::WindowsCodePairClockV1
&& self.delegation.validate()
&& self.delegation.handoff_sha256 == hash(&self.handoff_record)
&& self.delegation.owner_nonce == h.owner_nonce
&& self.delegation.boot_id == h.boot_id
&& hash(&serde_json::to_vec(&self.original)?) == h.attempt.original_request_sha256
&& hash(&serde_json::to_vec(&self.files)?) == h.staged_files_sha256
&& hash(&serde_json::to_vec(&self.retained)?) == h.retained_state_sha256
&& self.ledger.sha256()? == h.ledger_identity_sha256
&& self.files.iter().map(|f| f.role).collect::<Vec<_>>()
== [
Role::Agent,
Role::Helper,
Role::Settings,
Role::Pin,
Role::TimeProfile
]
&& self.signed_sync_response.len() <= 1048576
&& self.signed_sync_request.len() <= 1048576,
"UPDATE_BUNDLE_BINDING"
);
for (f, t) in self.files.iter().zip(&h.files) {
ensure!(
f.role.handoff_role() == t.role
&& f.original.sha256 == t.old_sha256
&& f.staged.sha256 == t.new_sha256,
"UPDATE_BUNDLE_FILE_BINDING"
);
}
Ok(h)
}
pub fn write_before_consume(&self) -> Result<()> {
let h = self.validate()?;
let raw = serde_json::to_vec(self)?;
ensure!(raw.len() <= 3 * 1024 * 1024, "UPDATE_BUNDLE_SIZE");
let mut root = PinnedFile::open(Path::new(ATTEMPTS), true, &[], &[], false)?;
let directory = Path::new(ATTEMPTS).join(h.attempt.grant_id.to_string());
// Inherit only the separately provisioned SYS/Admin private ACL.
// No pre-existing/partial directory is reused or repaired.
std::fs::create_dir(&directory)?;
let mut dir = PinnedFile::open(&directory, true, &[], &[], false)?;
let path = directory.join("bundle.json");
let mut file = 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)?;
file.write_all(&raw)?;
file.sync_all()?;
drop(file);
let mut published = PinnedFile::open(&path, false, &[], &[], false)?;
ensure!(
published.sha256()? == hash(&raw),
"UPDATE_BUNDLE_WRITE_CHANGED"
);
published.check()?;
dir.check()?;
root.check()
}
pub fn load(grant: Uuid) -> Result<(Self, impl Fn() -> Result<()>)> {
ensure!(!grant.is_nil(), "UPDATE_BUNDLE_GRANT");
let path = Path::new(ATTEMPTS)
.join(grant.to_string())
.join("bundle.json");
let (file, raw) = Protected::read(&path, 3 * 1024 * 1024)?;
let value: Self = serde_json::from_slice(&raw)?;
let handoff = value.validate()?;
ensure!(
handoff.attempt.grant_id == grant,
"UPDATE_BUNDLE_WRONG_GRANT"
);
Ok((value, move || file.verify()))
}
}
/// Every registered reader is an explicit decoder-compatible baseline service.
/// This protected registry is not a claim of global future process absence.
/// Worker additionally proves all registered original instances have stopped
/// and holds BOTH original executor/journal locks before opening mutable state.
pub const READER_CONTRACT:&[u8]=b"rmm.windows-shared-readers.v2\0agent:existing-agent.lock-before-agent-sqlite-and-held-for-process-lifetime;helper:existing-executor.lock-before-helper-sqlite-and-every-sql-or-effect;all-registered-readers:original-update-handoff-v2-inflight-decoder-compatible;updater:both-original-locks-only-after-registered-instances-stopped;scope:no-global-future-exec-absence-promise\n";
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Reader {
pub service: String,
pub binary_sha256: String,
pub configuration_sha256: String,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct RegistryFile {
schema_version: u32,
profile: String,
bootstrap_receipt_sha256: String,
reader_contract_sha256: String,
readers: Vec<Reader>,
}
pub struct QualifiedRegistry {
file: Protected,
qualification: Protected,
readers: Vec<Reader>,
}
impl QualifiedRegistry {
pub fn load(trust: &TrustState) -> Result<Self> {
let p = trust.policy();
ensure!(
p.schema_version == 2 && p.profile == "windows_code_pair_clock_v1",
"UPDATE_READER_POLICY"
);
let (file, raw) = Protected::read(Path::new(&p.registry_path), 65536)?;
ensure!(
hash(&raw) == p.reader_registry_sha256,
"UPDATE_READER_REGISTRY_HASH"
);
let r: RegistryFile = serde_json::from_slice(&raw)?;
let baseline = p.initial_baseline.decode().map_err(anyhow::Error::msg)?;
let ActivationEvidence::Bootstrap {
qualification_receipt_sha256,
} = baseline.record.activation_evidence
else {
anyhow::bail!("UPDATE_READER_BASELINE_REQUIRED");
};
let initial = baseline
.record
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
ensure!(
r.schema_version == 1
&& r.profile == "windows_compatible_readers_v2"
&& r.bootstrap_receipt_sha256 == qualification_receipt_sha256
&& r.reader_contract_sha256 == hash(READER_CONTRACT)
&& r.readers
.iter()
.map(|v| v.service.as_str())
.collect::<Vec<_>>()
== [
crate::SERVICE_NAME,
ipc::HELPER_SERVICE,
crate::update_ipc::SERVICE
]
&& r.readers[0].binary_sha256 == initial.manifest.artifacts[0].sha256
&& r.readers[1].binary_sha256 == initial.manifest.artifacts[1].sha256
&& r.readers[2].binary_sha256 == p.updater_binary_sha256
&& r.readers
.iter()
.all(|v| ipc::digest(&v.binary_sha256) && ipc::digest(&v.configuration_sha256))
&& r.readers[0].configuration_sha256 == p.services[0].unit_sha256
&& r.readers[1].configuration_sha256 == p.services[1].unit_sha256
&& r.readers[2].configuration_sha256 == p.updater_service.unit_sha256,
"UPDATE_READER_REGISTRY_BINDING"
);
let (qualification, qraw) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\bootstrap-qualification.json"),
65536,
)?;
ensure!(
hash(&qraw) == qualification_receipt_sha256,
"UPDATE_READER_QUALIFICATION_PIN"
);
// Raw real native evidence is covered by the separately signed baseline
// receipt hash; parsing a label here never creates native qualification.
Ok(Self {
file,
qualification,
readers: r.readers,
})
}
pub fn verify(&self) -> Result<()> {
self.file.verify()?;
self.qualification.verify()
}
pub fn verify_observed(
&self,
pair: &[crate::update_native::services::Proof],
updater_configuration_sha256: &str,
) -> Result<()> {
self.verify()?;
ensure!(pair.len() == 2, "UPDATE_READER_PAIR");
for (proof, reader) in pair.iter().zip(&self.readers) {
ensure!(
proof.configuration.service.name() == reader.service
&& hash(&serde_json::to_vec(&proof.configuration)?)
== reader.configuration_sha256,
"UPDATE_READER_SCM_CONFIGURATION"
);
// For later releases the signed installed record/approved exact
// predecessor supplies current binary pins. This is the original
// compatible reader contract, not a permanent initial image pin.
}
ensure!(
self.readers[2].configuration_sha256 == updater_configuration_sha256,
"UPDATE_READER_STABLE_UPDATER_CONFIGURATION"
);
self.verify()
}
}
/// One-way uncertainty report from the actual original stable worker. It never
/// asserts readiness, missing effects, a new start window or recovery rights.
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Uncertain {
schema_version: u32,
grant_id: Uuid,
owner_nonce: Uuid,
handoff_sha256: String,
delegation_sha256: String,
worker: rmm_domain::agent_update::ParticipantIdentity,
}
impl Uncertain {
pub(crate) fn write(
grant: Uuid,
worker: &rmm_domain::agent_update::ParticipantIdentity,
) -> Result<()> {
let (bundle, recheck) = Bundle::load(grant)?;
let h = bundle.validate()?;
ensure!(
&bundle.delegation.updater == worker,
"UPDATE_UNKNOWN_ORIGINAL_WORKER_REQUIRED"
);
let value = Self {
schema_version: 1,
grant_id: grant,
owner_nonce: h.owner_nonce,
handoff_sha256: hash(&h.bytes()?),
delegation_sha256: hash(&serde_json::to_vec(&bundle.delegation)?),
worker: worker.clone(),
};
let raw = serde_json::to_vec(&value)?;
ensure!(raw.len() <= 4096, "UPDATE_UNKNOWN_REPORT_LIMIT");
let directory = Path::new(ATTEMPTS).join(grant.to_string());
let mut root = PinnedFile::open(&directory, true, &[], &[], false)?;
let path = directory.join("uncertain.json");
let mut file = OpenOptions::new()
.read(true)
.write(true)
.create_new(true)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH)
.open(&path)?;
ipc::check_acl(file.as_raw_handle(), &[], &[], None)?;
file.write_all(&raw)?;
file.sync_all()?;
drop(file);
let (published, bytes) = Protected::read(&path, 4096)?;
ensure!(bytes == raw, "UPDATE_UNKNOWN_REPORT_WRITE_CHANGED");
published.verify()?;
root.check()?;
recheck()
}
pub(crate) fn read(header: &Handoff, delegation: &UpdateDelegation) -> Result<bool> {
let path = Path::new(ATTEMPTS)
.join(header.attempt.grant_id.to_string())
.join("uncertain.json");
if !path.try_exists()? {
return Ok(false);
}
let (file, raw) = Protected::read(&path, 4096)?;
let value: Self = serde_json::from_slice(&raw)?;
ensure!(
serde_json::to_vec(&value)? == raw
&& value.schema_version == 1
&& value.grant_id == header.attempt.grant_id
&& value.owner_nonce == header.owner_nonce
&& value.handoff_sha256 == hash(&header.bytes()?)
&& value.delegation_sha256 == hash(&serde_json::to_vec(delegation)?)
&& value.worker == delegation.updater,
"UPDATE_UNKNOWN_REPORT_ORIGINAL_CONTEXT_REQUIRED"
);
file.verify()?;
Ok(true)
}
}
@@ -0,0 +1,164 @@
//! Stable-updater-only time transport. Reuses the enrolled device's selected
//! certificate without enrollment, rotation, ClientHello, or inventory changes.
//! SignedClock still independently verifies its OWN role/image/nonce/context.
use crate::{
certificate_rotation::{ProtectedKeyFiles, RotationStore},
helper_ipc as ipc,
update_trust::Protected,
};
use anyhow::{Context, Result, ensure};
use rmm_agent_core::auth::Binding;
use rusqlite::{Connection, OpenFlags};
use std::{
net::{IpAddr, Ipv4Addr, SocketAddr},
path::Path,
time::Duration,
};
const STATE: &str = r"C:\ProgramData\RustDiscovery\state";
const CONFIG: &str = r"C:\ProgramData\RustDiscovery\config.json";
const CA: &str = r"C:\ProgramData\RustDiscovery\server-ca.pem";
const JOURNAL: &str = r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite";
const DOMAIN: &str = "discovery.ease-technologies.de";
pub struct Transport {
client: reqwest::Client,
configuration: Protected,
ca: Protected,
address: SocketAddr,
}
impl Transport {
pub fn open(binding: &Binding) -> Result<Self> {
let readers = vec![
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
ipc::service_sid(crate::update_ipc::SERVICE)?,
];
let (configuration, raw) = Protected::read_shared(Path::new(CONFIG), 16384, &readers)?;
let value: serde_json::Value = serde_json::from_slice(&raw)?;
let fields = value.as_object().context("UPDATE_TIME_CONFIG_OBJECT")?;
ensure!(
fields.keys().all(|key| matches!(
key.as_str(),
"server_name"
| "connect_address"
| "ca_file"
| "state_directory"
| "enrollment_token_file"
| "transport"
| "job_binding_file"
| "enable_jobs"
| "windows_echo_probe_only"
| "windows_execution_profile"
)),
"UPDATE_TIME_CONFIG_UNKNOWN_FIELD"
);
ensure!(
value["server_name"].as_str() == Some(DOMAIN)
&& value["ca_file"].as_str() == Some(CA)
&& value["state_directory"].as_str() == Some(STATE)
&& matches!(value["transport"].as_str(), Some("auto" | "https")),
"UPDATE_TIME_FIXED_ENDPOINT"
);
let address: SocketAddr = value["connect_address"]
.as_str()
.context("UPDATE_TIME_ADDRESS")?
.parse()?;
ensure!(
address.ip() == IpAddr::V4(Ipv4Addr::new(88, 99, 80, 202)) && address.port() == 443,
"UPDATE_TIME_FIXED_ADDRESS"
);
let (ca, ca_bytes) = Protected::read_shared(Path::new(CA), 65536, &readers)?;
crate::native::private_path(Path::new(STATE), true)?;
crate::native::private_path(Path::new(JOURNAL), false)?;
let journal_pin = crate::update_state::AgentStateFile::journal()?;
let db = Connection::open_with_flags(
JOURNAL,
OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
)?;
db.busy_timeout(Duration::ZERO)?;
unsafe {
rusqlite::ffi::sqlite3_limit(db.handle(), rusqlite::ffi::SQLITE_LIMIT_LENGTH, 65536);
}
db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?;
let keys = ProtectedKeyFiles::open(Path::new(STATE))?;
let rotation = RotationStore::new(
binding.agent_id,
binding.enrollment_generation,
ca_bytes.clone(),
)?;
let identity = rotation.read_only_current(&db, &keys, chrono::Utc::now().timestamp())?;
let mut pem = identity.certificate_pem;
pem.push(b'\n');
pem.extend_from_slice(&identity.private_key_pem);
let client = reqwest::Client::builder()
.https_only(true)
.tls_built_in_root_certs(false)
.add_root_certificate(reqwest::Certificate::from_pem(&ca_bytes)?)
.identity(reqwest::Identity::from_pem(&pem)?)
.resolve(DOMAIN, address)
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(Duration::from_millis(650))
.timeout(Duration::from_millis(650))
.pool_max_idle_per_host(1)
.build()?;
db.close().map_err(|(_, error)| error)?;
journal_pin.check()?;
configuration.verify()?;
ca.verify()?;
Ok(Self {
client,
configuration,
ca,
address,
})
}
pub async fn compare(&mut self, request: &rmm_time_attestation::Request) -> Result<Vec<u8>> {
request.validate()?;
ensure!(
request.context.role == rmm_time_attestation::Role::Updater,
"UPDATE_TIME_OWN_ROLE_REQUIRED"
);
self.configuration.verify()?;
self.ca.verify()?;
let client = self.client.clone();
let address = self.address;
let body = tokio::time::timeout(Duration::from_millis(650), async move {
let mut response = client
.post(format!(
"https://{DOMAIN}:{}/agent/v1/time-attestation",
address.port()
))
.json(request)
.send()
.await?;
ensure!(
response.status() == reqwest::StatusCode::OK
&& response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|h| h.to_str().ok())
== Some("application/json")
&& !response
.headers()
.contains_key(reqwest::header::CONTENT_ENCODING)
&& response.content_length().is_none_or(|n| n <= 16384),
"UPDATE_TIME_HTTP_PROFILE"
);
let mut body = vec![];
while let Some(chunk) = response.chunk().await? {
ensure!(
chunk.len() <= 16384usize.saturating_sub(body.len()),
"UPDATE_TIME_BODY_LIMIT"
);
body.extend_from_slice(&chunk);
}
ensure!(!body.is_empty(), "UPDATE_TIME_EMPTY_RESPONSE");
Ok::<Vec<u8>, anyhow::Error>(body)
})
.await
.context("UPDATE_TIME_HTTP_DEADLINE")??;
self.configuration.verify()?;
self.ca.verify()?;
Ok(body)
}
}
+627
View File
@@ -0,0 +1,627 @@
//! Shared Windows protected update trust. No network input provisions a key,
//! policy, floor, baseline or compatible-reader qualification. SYSTEM helper
//! and stable updater each open these exact files independently.
use crate::helper_ipc::{self as ipc, PinnedFile};
use anyhow::{Context, Result, ensure};
use ed25519_dalek::{Signature, VerifyingKey};
use rmm_agent_core::{auth::Binding, helper_reconcile::ExecutorLedgerGuard, reconcile::SyncClock};
use rmm_domain::{
agent_update::{ResolvedAgentUpdate, UpdateKeyringFile},
agent_update_provisioning::{
ActivationEvidence, BASELINE_SIGNATURE_DOMAIN, HealthKeyPin, InstalledReleaseRecord,
LocalUpdatePolicy,
},
jobs::hash,
};
use rmm_updater::{
ActiveRelease, SignedRelease, TrustedContext, TrustedUpdateKey,
UpdateKeyring, verify_release,
};
use std::{cell::RefCell, io::Read, path::Path};
pub(crate) struct Protected {
file: RefCell<PinnedFile>,
root: RefCell<PinnedFile>,
sha256: String,
}
impl Protected {
pub(crate) fn read(path: &Path, max: u64) -> Result<(Self, Vec<u8>)> {
Self::read_shared(path, max, &[])
}
pub(crate) fn read_shared(
path: &Path,
max: u64,
readers: &[String],
) -> Result<(Self, Vec<u8>)> {
let root = PinnedFile::open(
path.parent().context("UPDATE_TRUST_PARENT")?,
true,
readers,
&[],
false,
)?;
let mut file = PinnedFile::open(path, false, readers, &[], false)?;
ensure!(
file.file.metadata()?.len() <= max,
"UPDATE_TRUST_FILE_LIMIT"
);
let mut raw = Vec::new();
(&mut file.file).take(max + 1).read_to_end(&mut raw)?;
ensure!(raw.len() as u64 <= max, "UPDATE_TRUST_FILE_LIMIT");
file.check()?;
Ok((
Self {
file: RefCell::new(file),
root: RefCell::new(root),
sha256: hash(&raw),
},
raw,
))
}
pub(crate) fn verify(&self) -> Result<()> {
self.root.try_borrow_mut()?.check()?;
let mut file = self.file.try_borrow_mut()?;
file.check()?;
ensure!(file.sha256()? == self.sha256, "UPDATE_TRUST_BYTES_CHANGED");
Ok(())
}
}
pub struct TrustState {
updater_binding: rmm_domain::agent_update::UpdaterBinding,
predecessor: rmm_domain::agent_update::Predecessor,
protected: Vec<Protected>,
policy: LocalUpdatePolicy,
installed: InstalledReleaseRecord,
installed_raw: Vec<u8>,
installed_pin: RefCell<Option<Protected>>,
keyring: UpdateKeyring,
keyring_file: UpdateKeyringFile,
baseline_signer_revoked: bool,
health_public_key: [u8; 32],
}
impl TrustState {
pub fn load_prepared(
update: &ResolvedAgentUpdate,
binding: &Binding,
clock: &crate::signed_clock::BoundClock,
) -> Result<Self> {
ensure!(
update.validate() && update.execution_identity() == Some("system"),
"UPDATE_PREPARED_ACTION"
);
let state = Self::load_inputs(Some(update), binding, clock.now()?)?;
state.recheck_prepared(update, clock)?;
Ok(state)
}
pub fn load_retained(
update: &ResolvedAgentUpdate,
binding: &Binding,
prepared_at: chrono::DateTime<chrono::Utc>,
) -> Result<Self> {
ensure!(
update.validate() && update.execution_identity() == Some("system"),
"UPDATE_RETAINED_ACTION"
);
Self::load_inputs(Some(update), binding, prepared_at)
}
/// Passive protected originals only. No candidate, staging, admission or
/// synthetic execution plan is used to discover the installed trust state.
pub fn load_observed(
binding: &Binding,
clock: &crate::signed_clock::BoundClock,
) -> Result<Self> {
let state = Self::load_inputs(None, binding, clock.now()?)?;
ensure!(
!state.baseline_signer_revoked,
"UPDATE_BASELINE_SIGNER_REVOKED"
);
verify_installed_release(
&state.keyring,
&state.installed,
state.updater_binding.keyring_generation,
)?;
state.recheck_protected()?;
Ok(state)
}
fn load_inputs(
expected: Option<&ResolvedAgentUpdate>,
binding: &Binding,
prepared_at: chrono::DateTime<chrono::Utc>,
) -> Result<Self> {
let mut protected = Vec::new();
let (file, raw) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"),
65536,
)?;
let (policy, policy_hash) =
LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?;
ensure!(
policy.schema_version == 2
&& policy.profile == "windows_code_pair_clock_v1"
&& policy.tenant_id == binding.tenant_id
&& policy.asset_id == binding.asset_id
&& policy.agent_id == binding.agent_id
&& policy.enrollment_generation == binding.enrollment_generation
&& policy.assignment_version == binding.assignment_version,
"UPDATE_PROTECTED_POLICY_CHANGED"
);
protected.push(file);
let (file, raw) = Protected::read(Path::new(&policy.registry_path), 65536)?;
ensure!(
hash(&raw) == policy.reader_registry_sha256,
"UPDATE_PROTECTED_READER_REGISTRY_CHANGED"
);
protected.push(file);
let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?;
let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?;
ensure!(keys.validate(), "UPDATE_PROTECTED_KEYRING_CHANGED");
let keyring_sha256 = hash(&raw);
protected.push(file);
let job_key = hex::decode(&binding.public_key_hex)?;
let mut trusted = Vec::new();
let mut historical_keys = Vec::new();
let mut baseline_key = None;
for entry in &keys.keys {
ensure!(
entry.platform == crate::release_platform::WIRE,
"UPDATE_KEY_PLATFORM"
);
let public: [u8; 32] = hex::decode(&entry.public_key_hex)?
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_KEY_SIZE"))?;
ensure!(
public.as_slice() != job_key,
"UPDATE_JOB_RELEASE_KEYS_NOT_SEPARATE"
);
if hash(&public) == policy.initial_baseline.key_id {
baseline_key = Some((entry, public));
}
trusted.push(TrustedUpdateKey::new(
public,
crate::release_platform::VERIFY,
entry.first_sequence,
entry.last_sequence,
entry.revoked,
)?);
historical_keys.push(TrustedUpdateKey::new(
public,
crate::release_platform::VERIFY,
entry.first_sequence,
entry.last_sequence,
false,
)?);
}
let keyring = UpdateKeyring::new(keys.generation, trusted)?;
let historical = UpdateKeyring::new(keys.generation, historical_keys)?;
let baseline = policy
.initial_baseline
.decode()
.map_err(anyhow::Error::msg)?;
let (baseline_entry, public) = baseline_key.context("UPDATE_BASELINE_KEY_NOT_TRUSTED")?;
ensure!(
baseline
.record
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?
.manifest
.release_sequence
>= baseline_entry.first_sequence
&& baseline
.record
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?
.manifest
.release_sequence
<= baseline_entry.last_sequence,
"UPDATE_BASELINE_KEY_REVOKED_OR_RANGE"
);
let public = VerifyingKey::from_bytes(&public)?;
ensure!(!public.is_weak(), "UPDATE_BASELINE_WEAK_KEY");
let mut message = BASELINE_SIGNATURE_DOMAIN.to_vec();
message.extend_from_slice(&baseline.payload_bytes);
public.verify_strict(&message, &Signature::from_bytes(&baseline.signature))?;
let (file, raw) = Protected::read(Path::new(&policy.health_pin_path), 4096)?;
let health: HealthKeyPin = serde_json::from_slice(&raw)?;
let health_public_key = health.public_key().map_err(anyhow::Error::msg)?;
ensure!(
!VerifyingKey::from_bytes(&health_public_key)?.is_weak()
&& health_public_key.as_slice() != job_key
&& keys
.keys
.iter()
.all(|key| key.public_key_hex != hex::encode(health_public_key)),
"UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED"
);
let updater_binding = rmm_domain::agent_update::UpdaterBinding {
binary_sha256: policy.updater_binary_sha256.clone(),
policy_sha256: policy_hash,
keyring_generation: keys.generation,
keyring_sha256,
health_public_key_hex: hex::encode(health_public_key),
health_key_pin_sha256: hash(&raw),
};
protected.push(file);
let (file, raw) = Protected::read(Path::new(&policy.installed_record_path), 32768)?;
let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?;
ensure!(
!installed.rolled_back
&& installed.activation_floor >= policy.initial_activation_floor
&& installed.activated_at <= u64::try_from(prepared_at.timestamp())?,
"UPDATE_INSTALLED_FLOOR_OR_TIME"
);
if matches!(
installed.activation_evidence,
ActivationEvidence::Bootstrap { .. }
) {
ensure!(
raw == baseline.payload_bytes
&& hash(&raw) == policy.initial_record_sha256
&& installed.activation_floor == policy.initial_activation_floor,
"UPDATE_INSTALLED_BASELINE_CHANGED"
);
}
let active = installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
let predecessor = rmm_domain::agent_update::Predecessor {
release_id: active.manifest.release_id,
release_sequence: active.manifest.release_sequence,
manifest_sha256: installed.manifest_sha256.clone(),
installed_record_sha256: hash(&raw),
agent_sha256: active.manifest.artifacts[0].sha256.clone(),
helper_sha256: active.manifest.artifacts[1].sha256.clone(),
};
verify_installed_release(&historical, &installed, keys.generation)?;
if let Some(update) = expected {
ensure!(
update.updater == updater_binding && update.predecessor == predecessor,
"UPDATE_INSTALLED_PREDECESSOR_OR_TRUST_BINDING"
);
verify(
&historical,
&update.release_envelope,
&TrustedContext {
platform: crate::release_platform::VERIFY,
now_utc_seconds: u64::try_from(prepared_at.timestamp())?,
keyring_generation: keys.generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: installed.manifest_sha256.clone(),
}),
},
)?;
}
let installed_pin = RefCell::new(Some(file));
let baseline_signer_revoked = baseline_entry.revoked;
Ok(Self {
updater_binding,
predecessor,
protected,
policy,
installed,
installed_raw: raw,
installed_pin,
keyring,
keyring_file: keys,
baseline_signer_revoked,
health_public_key,
})
}
pub fn recheck_prepared(
&self,
update: &ResolvedAgentUpdate,
clock: &crate::signed_clock::BoundClock,
) -> Result<()> {
self.recheck_protected()?;
self.recheck_crypto(update, clock)
}
pub(crate) fn recheck_crypto(
&self,
update: &ResolvedAgentUpdate,
clock: &crate::signed_clock::BoundClock,
) -> Result<()> {
ensure!(
update.updater == self.updater_binding && update.predecessor == self.predecessor,
"UPDATE_TRUST_CONTEXT_CHANGED"
);
ensure!(
!self.baseline_signer_revoked,
"UPDATE_BASELINE_SIGNER_REVOKED"
);
verify_installed_release(
&self.keyring,
&self.installed,
update.updater.keyring_generation,
)?;
let active = self
.installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
let (lower, upper) = clock.bounds()?;
for now in [lower, upper] {
verify(
&self.keyring,
&update.release_envelope,
&TrustedContext {
platform: crate::release_platform::VERIFY,
now_utc_seconds: u64::try_from(now.timestamp())?,
keyring_generation: update.updater.keyring_generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: self.installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: self.installed.manifest_sha256.clone(),
}),
},
)?;
}
Ok(())
}
pub fn recheck_protected(&self) -> Result<()> {
self.recheck_other_protected()?;
self.installed_pin
.try_borrow()?
.as_ref()
.context("UPDATE_INSTALLED_NAMESPACE_PROOF_REQUIRED")?
.verify()
}
pub(crate) fn recheck_other_protected(&self) -> Result<()> {
for p in &self.protected {
p.verify()?;
}
Ok(())
}
pub(crate) fn release_installed_pin(
&self,
claim: &rmm_agent_core::update_handoff::NativeEffectClaim,
new_sha256: &str,
) -> Result<()> {
ensure!(
claim.effect()
== &rmm_agent_core::update_handoff::NativeEffect::SaveInstalledRecord {
old_sha256: hash(&self.installed_raw),
new_sha256: new_sha256.into()
},
"UPDATE_RECORD_ORIGINAL_SAVE_CLAIM_REQUIRED"
);
self.recheck_protected()?;
self.installed_pin
.try_borrow_mut()?
.take()
.context("UPDATE_RECORD_PIN_ALREADY_RELEASED")?;
Ok(())
}
pub fn qualify_history(
&self,
db: &rusqlite::Connection,
guard: &impl ExecutorLedgerGuard,
binding: &Binding,
) -> Result<()> {
self.recheck_protected()?;
let baseline = self
.policy
.initial_baseline
.decode()
.map_err(anyhow::Error::msg)?;
let baseline_hash = hash(&baseline.payload_bytes);
let mut records = Vec::new();
let mut held = Vec::new();
let mut seen = std::collections::BTreeSet::new();
let mut next = self.installed.previous_record_sha256.clone();
let mut total = self.installed_raw.len() + baseline.payload_bytes.len();
while let Some(digest) = next {
ensure!(
ipc::digest(&digest) && seen.insert(digest.clone()) && seen.len() < 64,
"UPDATE_RECORD_ARCHIVE_CHAIN"
);
if digest == baseline_hash {
break;
}
let (file, raw) = Protected::read(
&Path::new(r"C:\ProgramData\RustDiscoveryUpdater\records")
.join(format!("{digest}.json")),
32768,
)?;
ensure!(hash(&raw) == digest, "UPDATE_RECORD_ARCHIVE_HASH");
total = total
.checked_add(raw.len())
.context("UPDATE_RECORD_ARCHIVE_SIZE")?;
ensure!(total <= 2 * 1024 * 1024, "UPDATE_RECORD_ARCHIVE_SIZE");
let record = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?;
next = record.previous_record_sha256;
records.push(raw);
held.push(file);
}
let record = rmm_update_history::verify_history(
db,
guard,
binding,
&self.keyring_file,
&self.policy.initial_baseline,
&records,
&self.installed_raw,
)?;
ensure!(
record.bytes().map_err(anyhow::Error::msg)? == self.installed_raw,
"UPDATE_HISTORY_ACTIVE_CHANGED"
);
for file in held {
file.verify()?;
}
self.recheck_protected()
}
pub fn predecessor(&self) -> &rmm_domain::agent_update::Predecessor {
&self.predecessor
}
pub fn updater_binding(&self) -> &rmm_domain::agent_update::UpdaterBinding {
&self.updater_binding
}
pub fn activation_floor(&self) -> u64 {
self.installed.activation_floor
}
pub fn verify_candidate(
&self,
envelope: &rmm_domain::agent_update::ReleaseEnvelope,
clock: &crate::signed_clock::BoundClock,
) -> Result<()> {
self.recheck_protected()?;
ensure!(
!self.baseline_signer_revoked,
"UPDATE_BASELINE_SIGNER_REVOKED"
);
let active = self
.installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?
.manifest;
let (lower, upper) = clock.bounds()?;
for now in [lower, upper] {
verify(
&self.keyring,
envelope,
&TrustedContext {
platform: crate::release_platform::VERIFY,
now_utc_seconds: u64::try_from(now.timestamp())?,
keyring_generation: self.updater_binding.keyring_generation,
protocol_major: active.protocol_major,
state_schema: active.state_schema,
updater_version: 1,
minimum_release_sequence: self.installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.release_sequence,
manifest_sha256: self.installed.manifest_sha256.clone(),
}),
},
)?;
}
self.recheck_protected()
}
pub fn policy(&self) -> &LocalUpdatePolicy {
&self.policy
}
pub fn installed_raw(&self) -> &[u8] {
&self.installed_raw
}
pub fn health_public_key(&self) -> [u8; 32] {
self.health_public_key
}
}
fn verify(
keyring: &UpdateKeyring,
envelope: &rmm_domain::agent_update::ReleaseEnvelope,
context: &TrustedContext,
) -> Result<()> {
let decoded = envelope.decode().map_err(anyhow::Error::msg)?;
verify_release(
SignedRelease {
schema_version: envelope.schema_version,
key_id: &envelope.key_id,
payload_bytes: &decoded.payload_bytes,
signature: &decoded.signature,
},
keyring,
context,
)?;
Ok(())
}
fn verify_installed_release(
keyring: &UpdateKeyring,
installed: &InstalledReleaseRecord,
generation: u64,
) -> Result<()> {
let active = installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
verify(
keyring,
&installed.release_envelope,
&TrustedContext {
platform: crate::release_platform::VERIFY,
now_utc_seconds: installed.activated_at,
keyring_generation: generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: installed.manifest_sha256.clone(),
}),
},
)
}
/// A released worker READ pin is not an observed record-save effect. Its exact
/// original identity/bytes/security must reappear under the archive namespace.
pub(crate) struct ReleasedRecordReadPin {
original: crate::update_native::files::Proof,
}
impl ReleasedRecordReadPin {
pub(crate) fn verify_archive(&self) -> Result<()> {
let path = Path::new(r"C:\ProgramData\RustDiscoveryUpdater\records")
.join(format!("{}.json", self.original.sha256));
let (file, raw) = Protected::read(&path, 32768)?;
ensure!(
hash(&raw) == self.original.sha256,
"UPDATE_WORKER_ARCHIVE_BYTES_CHANGED"
);
let mut handle = file.file.try_borrow_mut()?;
ensure!(
crate::update_native::files::proof(&mut handle.file, &path, 32768)? == self.original,
"UPDATE_WORKER_ARCHIVE_IDENTITY_CHANGED"
);
Ok(())
}
}
impl TrustState {
/// Only after actual authenticated HealthVerified, release this worker's
/// old-name READ handle so the independent helper can commit its native
/// Save/Observe and Publish/Observe. ALL other trust handles remain held;
/// no filesystem mutation, floor change or effect observation happens here.
pub(crate) fn release_worker_record_pin_after_health(
&self,
header: &rmm_updater_handoff::Handoff,
proof: &rmm_domain::agent_update::UpdateInflightProof,
) -> Result<ReleasedRecordReadPin> {
let (actual, journal) =
rmm_domain::agent_update::verify_inflight_proof(proof, self.health_public_key)
.map_err(anyhow::Error::msg)?;
ensure!(
journal.phase() == rmm_updater_handoff::Phase::HealthVerified
&& actual.bytes()? == header.bytes()?
&& header.predecessor_record_sha256 == hash(&self.installed_raw)
&& header.updater_sha256 == self.policy.updater_binary_sha256,
"UPDATE_ACTUAL_HEALTH_BEFORE_WORKER_READ_PIN_RELEASE"
);
self.recheck_protected()?;
let pin = self
.installed_pin
.try_borrow_mut()?
.take()
.context("UPDATE_WORKER_RECORD_PIN_ALREADY_RELEASED")?;
let mut file = pin.file.try_borrow_mut()?;
let original = crate::update_native::files::proof(
&mut file.file,
Path::new(&self.policy.installed_record_path),
32768,
)?;
ensure!(
original.sha256 == hash(&self.installed_raw),
"UPDATE_WORKER_ORIGINAL_RECORD_CHANGED"
);
drop(file);
drop(pin);
Ok(ReleasedRecordReadPin { original })
}
}
+799
View File
@@ -0,0 +1,799 @@
//! Stable, separately provisioned SCM updater. Activation is one live pass:
//! only a successfully drained reply releases the queued original; no startup
//! scan resumes effects, and a duplicate activation is always denied.
use crate::{
helper_ipc::{self as ipc, PeerProof},
helper_system::{self, WindowsBoot},
signed_clock::{BoundClock, RuntimeClock, UpdaterConfiguration},
update_ipc::{self, Pin, Request, Response, State},
update_native::{
self as native, Budget, control_fence,
files::{BoundStage, Staged},
services,
},
update_original::Original,
update_owned,
update_state::{Bundle, QualifiedRegistry, RetainedSet},
update_time_transport::Transport,
update_trust::{Protected, TrustState},
};
use anyhow::{Context, Result, ensure};
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use rmm_agent_core::{
auth::Binding,
helper_reconcile::BootSource,
reconcile::SyncClock,
update_handoff::{
NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService,
},
};
use rmm_domain::{
agent_update::{ParticipantIdentity, ParticipantRole, verify_inflight_proof},
jobs::hash,
};
use rmm_updater_handoff::Phase;
use std::{
cell::RefCell,
collections::BTreeMap,
path::Path,
sync::{
Arc,
atomic::{AtomicBool, AtomicU64, Ordering},
},
time::Duration,
};
use uuid::Uuid;
struct Worker {
binding: Binding,
policy: rmm_domain::agent_update_provisioning::LocalUpdatePolicy,
policy_file: Protected,
profile_file: Protected,
pin: Pin,
own: RefCell<PeerProof>,
identity: ParticipantIdentity,
clock: RuntimeClock,
generation: Arc<AtomicU64>,
pending: Option<Uuid>,
current: Option<Uuid>,
seen: BTreeMap<Uuid, (Uuid, String)>,
state: State,
}
impl Worker {
fn open(clock: RuntimeClock, generation: Arc<AtomicU64>) -> Result<Self> {
let (policy_file, raw) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"),
65536,
)?;
let (policy, policy_sha256) =
rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw)
.map_err(anyhow::Error::msg)?;
let (profile_file, raw) =
Protected::read(Path::new(crate::signed_clock::UPDATER_CONFIG_PATH), 16384)?;
let profile: UpdaterConfiguration = serde_json::from_slice(&raw)?;
ensure!(
policy.schema_version == 2
&& profile.schema_version == 3
&& profile.updater_policy_sha256 == policy_sha256
&& policy.tenant_id == profile.binding.tenant_id
&& policy.asset_id == profile.binding.asset_id
&& policy.agent_id == profile.binding.agent_id
&& policy.enrollment_generation == profile.binding.enrollment_generation
&& policy.assignment_version == profile.binding.assignment_version,
"UPDATE_WORKER_PROTECTED_BINDING"
);
let boot = WindowsBoot::capture()?;
let budget = Budget::new(&boot, boot.current_boot()?, Duration::from_secs(5))?;
let (own, identity) = services::observe_updater(&policy, &budget)?;
let (settings, _) = helper_system::read_settings()?;
ensure!(
serde_json::to_vec(&settings.binding)? == serde_json::to_vec(&profile.binding)?,
"UPDATE_WORKER_HELPER_BINDING"
);
let pin = Pin {
schema_version: 1,
binding: profile.binding.clone(),
policy_sha256,
helper: settings.helper,
updater: services::updater_pin(&policy)?,
};
pin.validate()?;
Ok(Self {
binding: profile.binding,
policy,
policy_file,
profile_file,
pin,
own: RefCell::new(own),
identity,
clock,
generation,
pending: None,
current: None,
seen: BTreeMap::new(),
state: State::NotConfigured,
})
}
fn check(&self) -> Result<()> {
self.policy_file.verify()?;
self.profile_file.verify()?;
let mut own = self.own.try_borrow_mut()?;
own.check()?;
ensure!(
update_ipc::participant(&own, ParticipantRole::WindowsUpdater)? == self.identity
&& services::updater_configuration_sha256(&self.pin.updater)?
== self.policy.updater_service.unit_sha256,
"UPDATE_WORKER_OWN_INSTANCE_CHANGED"
);
Ok(())
}
fn bound_clock(&self) -> BoundClock {
self.clock
.for_generation(self.generation.load(Ordering::SeqCst))
}
fn request(
&self,
h: &rmm_updater_handoff::Handoff,
method: NativeControlOperation,
) -> Result<NativeControlReply> {
self.check()?;
let r = NativeControlRequest {
operation: "agent_update_control_v1".into(),
schema_version: 1,
challenge: Uuid::new_v4(),
tenant_id: self.binding.tenant_id,
asset_id: self.binding.asset_id,
agent_id: self.binding.agent_id,
enrollment_generation: self.binding.enrollment_generation,
assignment_version: self.binding.assignment_version,
grant_id: h.attempt.grant_id,
owner_nonce: h.owner_nonce,
handoff_sha256: hash(&h.bytes()?),
method,
};
crate::update_control_ipc::exchange(&self.pin, &r)
}
fn drive(&mut self, grant: Uuid) -> Result<()> {
self.check()?;
let (bundle, bundle_recheck) = Bundle::load(grant)?;
let h = bundle.validate()?;
ensure!(
h.schema_version == 2 && bundle.delegation.updater == self.identity,
"UPDATE_WORKER_ORIGINAL_OWNER_REQUIRED"
);
let mut reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
let start = URL_SAFE_NO_PAD.decode(
reply
.original_start_base64url
.as_ref()
.context("UPDATE_ORIGINAL_START_REQUIRED")?,
)?;
let boot = WindowsBoot::capture()?;
let budget = Budget::new(&boot, h.boot_id, Duration::from_secs(600))?;
let clock = self.bound_clock();
clock.require_generation(h.connection_generation)?;
let original = Original::verify(
&self.binding,
&start,
&bundle.handoff_record,
bundle.delegation.clone(),
&clock,
&budget,
)?;
let trust = TrustState::load_prepared(original.update(), &self.binding, &clock)?;
let retained = RetainedSet::reopen(&bundle.retained)?;
let registry = QualifiedRegistry::load(&trust)?;
let (settings, _) = helper_system::read_settings()?;
let mut running =
services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?;
registry.verify_observed(
&running.proofs(),
&services::updater_configuration_sha256(&self.pin.updater)?,
)?;
running.check(&budget)?;
while !pre_stop_context(&self.binding, &original, &trust, &clock, &reply)? {
original.check_current(&self.binding, &clock, &budget)?;
std::thread::sleep(Duration::from_millis(100));
reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
}
let proof = reply
.proof
.as_ref()
.context("UPDATE_ORIGINAL_PREFIX_REQUIRED")?;
let (_, journal) =
verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?;
ensure!(
journal.phase() == Phase::StopIntent,
"UPDATE_NO_REENTER_OR_RESUME"
);
let mut claims = vec![];
for service in [NativeService::WindowsAgent, NativeService::WindowsHelper] {
claims.push(
self.request(
&h,
NativeControlOperation::ClaimStop {
expected_head_sha256: journal.head_sha256().into(),
service,
},
)?
.claim
.context("UPDATE_ORIGINAL_STOP_CLAIM_REQUIRED")?,
);
}
let context = || control_fence::Context {
original: &original,
binding: &self.binding,
clock: &clock,
budget: &budget,
updater: &self.own,
retained: &retained,
trust: &trust,
};
let proofs = running
.proofs()
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_TWO_ORIGINAL_SERVICES_REQUIRED"))?;
let mut stop = control_fence::StopFence::new(
context(),
claims
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_TWO_STOP_CLAIMS_REQUIRED"))?,
proofs,
proof,
)?;
let stopped = running.stop(&budget, &mut stop)?;
let observations = stop.finish(&stopped)?;
let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?;
let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs {
closed: &closed,
stopped: &stopped,
bundle: &bundle,
bundle_recheck: &bundle_recheck,
original: &original,
binding: &self.binding,
clock: &clock,
budget: &budget,
updater: &self.own,
retained: &retained,
registry: &registry,
trust: &trust,
})?;
ledger.record_stops(observations)?;
let originals = bundle
.files
.iter()
.map(|f| f.original.clone())
.collect::<Vec<_>>()
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?;
let stages = bundle
.files
.iter()
.map(|f| f.staged.clone())
.collect::<Vec<_>>()
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?;
let (db, guard) = ledger.parts();
let mut fence = native::fence::LedgerFence::new(native::fence::Inputs {
db,
guard,
clock: &clock,
budget: &budget,
original: &h,
originals: &originals,
staged: &stages,
})?;
let mut published = vec![];
for f in &bundle.files {
let stage = Staged::reopen_bound(
BoundStage {
role: f.role,
owner_nonce: h.owner_nonce,
original: &f.original,
staged: &f.staged,
},
&budget,
)?;
published.push(stage.publish(&stopped, &budget, &mut fence)?);
}
fence.finish()?;
for file in published {
file.release(&budget)?;
}
let prepared = ledger.prepare_return_and_close()?;
let released = closed.release(&bundle, &stopped, &budget)?;
let mut start_fence = prepared.bind(context(), released, &bundle)?;
let (settings, _) = helper_system::read_settings()?;
let result = stopped.start_observed(
[settings.agent, settings.helper.clone()],
&budget,
&mut start_fence,
)?;
let (mut started, rolled_back) = match result {
services::StartResult::Running(mut running) => {
start_fence.finish(&mut running)?;
(running, false)
}
services::StartResult::KnownFailure(failed) => {
// Only first-helper failure has no started candidate reader.
// Partial starts require separately authorized stops; this
// branch cannot infer those from a caller reason or timeout.
let stopped = start_fence.helper_failed(*failed)?;
let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?;
let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs {
closed: &closed,
stopped: &stopped,
bundle: &bundle,
bundle_recheck: &bundle_recheck,
original: &original,
binding: &self.binding,
clock: &clock,
budget: &budget,
updater: &self.own,
retained: &retained,
registry: &registry,
trust: &trust,
})?;
ledger.begin_failed_helper_rollback()?;
let (db, guard) = ledger.parts();
let mut fence = native::fence::RestoreFence::new(native::fence::Inputs {
db,
guard,
clock: &clock,
budget: &budget,
original: &h,
originals: &originals,
staged: &stages,
})?;
for f in bundle.files.iter().rev() {
native::files::Published::reopen_bound(
BoundStage {
role: f.role,
owner_nonce: h.owner_nonce,
original: &f.original,
staged: &f.staged,
},
&stopped,
&budget,
)?
.restore(&stopped, &budget, &mut fence)?;
}
fence.finish()?;
let prepared = ledger.prepare_rollback_return_and_close()?;
let released = closed.release(&bundle, &stopped, &budget)?;
let mut fence = prepared.bind(context(), released, &bundle)?;
let (settings, _) = helper_system::read_settings()?;
let result = stopped.start_observed(
[settings.agent, settings.helper],
&budget,
&mut fence,
)?;
let services::StartResult::Running(mut running) = result else {
anyhow::bail!("UPDATE_PREDECESSOR_START_FAILED_NO_SECOND_RETURN")
};
fence.finish(&mut running)?;
(running, true)
}
};
self.pin.helper = helper_system::read_settings()?.0.helper;
let health_key = trust.health_public_key();
let proof = started.proofs();
self.request(
&h,
NativeControlOperation::ObserveStarts {
services: proof.iter().map(|p| p.started()).collect(),
observation_sha256: hash(&serde_json::to_vec(&proof)?),
},
)?;
loop {
original.check_current(&self.binding, &clock, &budget)?;
started.check(&budget)?;
let reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
let proof = reply.proof.context("UPDATE_ACTIVE_PREFIX_REQUIRED")?;
let (_, journal) =
verify_inflight_proof(&proof, health_key).map_err(anyhow::Error::msg)?;
if journal.phase()
== if rolled_back {
Phase::RollbackHealthVerified
} else {
Phase::HealthVerified
}
{
trust.recheck_prepared(original.update(), &clock)?;
let released = if rolled_back {
None
} else {
Some(trust.release_worker_record_pin_after_health(&h, &proof)?)
};
let reply = self.request(&h, NativeControlOperation::Finalize)?;
if rolled_back {
verify_rollback_outcome(&original, &trust, &proof, &reply)?;
trust.recheck_protected()?;
} else {
verify_final_record(&original, &trust, &proof, &reply)?;
released
.context("UPDATE_WORKER_READ_PIN_RELEASE_REQUIRED")?
.verify_archive()?;
trust.recheck_other_protected()?;
}
self.state = State::OutcomePersisted;
return Ok(());
}
ensure!(
journal.phase()
== if rolled_back {
Phase::RollbackServicesStarted
} else {
Phase::ServicesStarted
},
"UPDATE_UNEXPECTED_POST_START_PHASE"
);
std::thread::sleep(Duration::from_millis(100));
}
}
}
// This is evidence of one already applied original control context, not a new
// grant/approval/start window. Absent witness means bounded no-effect waiting.
fn pre_stop_context(
binding: &Binding,
original: &Original,
trust: &TrustState,
clock: &BoundClock,
reply: &NativeControlReply,
) -> Result<bool> {
use prost::Message;
let (Some(raw), Some(signed)) = (
&reply.pre_stop_sync_request_base64url,
&reply.pre_stop_sync_response_base64url,
) else {
return Ok(false);
};
let raw = URL_SAFE_NO_PAD.decode(raw)?;
let signed = URL_SAFE_NO_PAD.decode(signed)?;
ensure!(
raw.len() <= 512 * 1024 && signed.len() <= 512 * 1024,
"UPDATE_PRE_STOP_SYNC_LIMIT"
);
let request = rmm_protocol::SyncRequest::decode(raw.as_slice())?;
let signed: rmm_agent_core::helper_reconcile::SignedResponse = serde_json::from_slice(&signed)?;
let response = rmm_protocol::SyncResponse {
decision_bytes: signed.decision_bytes,
signature: signed.signature,
};
let decision: rmm_domain::reconciliation::ReconcileDecisionPayload =
serde_json::from_slice(&response.decision_bytes)?;
clock.require_generation(decision.connection_generation)?;
let (lower, upper) = clock.bounds()?;
ensure!(
request.encode_to_vec() == raw
&& decision.issued_at <= lower
&& upper < decision.valid_until
&& !request.previous_decision_id.is_empty()
&& request.previous_decision_id == request.helper_previous_decision_id,
"UPDATE_PRE_STOP_CURRENT_CONFIRMED_CONTEXT_REQUIRED"
);
let verified = rmm_agent_core::reconcile::verify_response(
binding,
&request,
&rmm_agent_core::reconcile::Channel {
connection_generation: decision.connection_generation,
boot_id: original.handoff().boot_id,
},
&response,
lower,
)?;
let proof = reply
.proof
.as_ref()
.context("UPDATE_PRE_STOP_PREFIX_REQUIRED")?;
let expected = rmm_domain::agent_update::inflight_decision(proof, trust.health_public_key())
.map_err(anyhow::Error::msg)?;
let (header, journal) =
verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?;
ensure!(
header.bytes()? == original.handoff().bytes()?
&& journal.phase() == Phase::StopIntent
&& verified
.attempts
.iter()
.any(|a| a.job_id == original.permit().job_id
&& a.attempt_id == original.permit().attempt_id
&& a.update_inflight.as_ref() == Some(&expected)
&& !a.unlock),
"UPDATE_PRE_STOP_EXACT_ORIGINAL_ACK_REQUIRED"
);
let proof_bytes = proof.bytes().map_err(anyhow::Error::msg)?;
ensure!(
request
.attempts
.iter()
.any(|a| a.job_id == original.permit().job_id.to_string()
&& a.attempt_id == original.permit().attempt_id.to_string()
&& a.update_handoff_bytes == proof_bytes),
"UPDATE_PRE_STOP_EXACT_ORIGINAL_REQUEST_REQUIRED"
);
Ok(true)
}
impl update_ipc::Engine for Worker {
fn handle(&mut self, peer: &ParticipantIdentity, request: Request) -> Result<Response> {
self.check()?;
match request {
Request::Describe {} => {
if self.pending.is_none()
&& self.state != State::Unknown
&& self.state != State::OutcomePersisted
{
self.state = if self.bound_clock().now().is_ok() {
State::Described
} else {
State::NotConfigured
};
}
}
Request::Activate {
grant_id,
owner_nonce,
handoff_sha256,
} => {
ensure!(
self.pending.is_none() && !self.seen.contains_key(&grant_id),
"UPDATE_ACTIVATION_NO_REPLAY"
);
let (bundle, recheck) = Bundle::load(grant_id)?;
let h = bundle.validate()?;
ensure!(
h.schema_version == 2
&& h.owner_nonce == owner_nonce
&& hash(&h.bytes()?) == handoff_sha256
&& bundle.delegation.original_helper == *peer
&& bundle.delegation.updater == self.identity,
"UPDATE_ACTIVATION_ORIGINAL_BINDING"
);
self.bound_clock()
.require_generation(h.connection_generation)?;
self.bound_clock().now()?;
recheck()?;
ensure!(
matches!(self.state, State::Described | State::OutcomePersisted)
&& self.seen.len() < 64,
"UPDATE_WORKER_NOT_AVAILABLE_FOR_NEW_ATTEMPT"
);
self.seen.insert(grant_id, (owner_nonce, handoff_sha256));
self.pending = Some(grant_id);
self.current = Some(grant_id);
self.state = State::Inflight;
}
Request::Read {
grant_id,
owner_nonce,
handoff_sha256,
} => ensure!(
self.current == Some(grant_id)
&& self.seen.get(&grant_id) == Some(&(owner_nonce, handoff_sha256)),
"UPDATE_NO_ACTIVE_ORIGINAL"
),
Request::Health { .. } => anyhow::bail!("UPDATE_AGENT_HEALTH_USES_SYSTEM_CONTROL"),
}
Ok(Response {
schema_version: 1,
state: self.state,
ready: false,
updater: self.identity.clone(),
head_sha256: None,
})
}
}
fn current_generation_hint() -> Result<u64> {
const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite";
let file = ipc::PinnedFile::open(
Path::new(LEDGER),
false,
&[],
&[ipc::service_sid(ipc::HELPER_SERVICE)?],
true,
)?;
let db = rusqlite::Connection::open_with_flags(
LEDGER,
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
)?;
db.busy_timeout(Duration::ZERO)?;
db.execute_batch("PRAGMA query_only=ON;PRAGMA trusted_schema=OFF")?;
let generation: u64 = db.query_row(
"SELECT generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL",
[],
|r| r.get(0),
)?;
ensure!(generation > 0, "UPDATE_TIME_GENERATION_HINT_MISSING");
db.close().map_err(|(_, error)| error)?;
ensure!(
ipc::file_identity(&file.file)? == file.identity,
"UPDATE_TIME_HINT_FILE_CHANGED"
);
// Hint only: independent server context/signature/nonce validates it.
Ok(generation)
}
pub fn dispatch() -> Result<()> {
crate::service::dispatch_named(update_ipc::SERVICE, run)
}
fn run(stop: &'static AtomicBool) -> Result<()> {
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(2)
.enable_all()
.build()?;
let clock = RuntimeClock::new(rmm_time_attestation::Role::Updater);
let generation = Arc::new(AtomicU64::new(current_generation_hint()?));
let mut worker = Worker::open(clock.clone(), generation.clone())?;
let binding = worker.binding.clone();
let time_clock = clock.clone();
let time_generation = generation.clone();
let time_task = runtime.spawn(async move {
loop {
if stop.load(Ordering::SeqCst) {
break;
}
let generation = time_generation.load(Ordering::SeqCst);
let result = async {
if !time_clock.configured_for(generation) {
time_clock.open_connection(generation).await?;
}
let mut transport = Transport::open(&binding)?;
let request = time_clock.begin(generation)?;
let response = transport.compare(&request).await?;
time_clock.complete(generation, &response)
}
.await;
if result.is_err() {
let _ = time_clock.close_generation(generation);
}
tokio::time::sleep(Duration::from_millis(if result.is_ok() {
250
} else {
1000
}))
.await;
}
});
let mut server = update_ipc::Server::bind(worker.pin.clone())?;
while !stop.load(Ordering::SeqCst) {
let delivered = server.serve_one(&mut worker);
match delivered {
Ok(true) => {
if let Some(grant) = worker.pending.take() {
// Only this successful drain receipt allows a live pass.
let result = worker.drive(grant);
if result.is_err() {
worker.state = State::Unknown;
let _report =
crate::update_state::Uncertain::write(grant, &worker.identity);
}
drop(server);
let (settings, _) = helper_system::read_settings()?;
worker.pin.helper = settings.helper;
server = update_ipc::Server::bind(worker.pin.clone())?;
generation.store(current_generation_hint()?, Ordering::SeqCst);
}
}
Ok(false) => {}
Err(_) => {
// Lost reply/receipt can never execute the queued original.
if let Some(grant) = worker.pending.take() {
worker.state = State::Unknown;
let _report = crate::update_state::Uncertain::write(grant, &worker.identity);
}
}
}
}
time_task.abort();
clock.close()?;
Ok(())
}
fn verify_final_record(
original: &Original,
trust: &TrustState,
proof: &rmm_domain::agent_update::UpdateInflightProof,
reply: &NativeControlReply,
) -> Result<()> {
let encoded = reply
.original_outcome_base64url
.as_ref()
.context("UPDATE_ORIGINAL_FINAL_OUTCOME_REQUIRED")?;
let raw = URL_SAFE_NO_PAD.decode(encoded)?;
let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?;
ensure!(
rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw
&& outcome.state == "succeeded"
&& !outcome.reboot_required
&& outcome.error_code.is_empty()
&& outcome.exit_code == Some(0)
&& outcome.evidence["postconditions_passed"] == true,
"UPDATE_ORIGINAL_FINAL_OUTCOME_CHANGED"
);
let event_raw = URL_SAFE_NO_PAD.decode(
proof
.events
.last()
.context("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED")?,
)?;
let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?;
let rmm_updater_handoff::Evidence::HealthVerified { receipt: signed } = event.evidence else {
anyhow::bail!("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED")
};
let receipt: rmm_updater_handoff::HealthReceipt = serde_json::from_slice(&signed.payload)?;
let expected = rmm_domain::agent_update_provisioning::assemble_updated_record(
original.update(),
trust.installed_raw(),
&hash(&original.handoff().bytes()?),
&signed,
&receipt,
)
.map_err(anyhow::Error::msg)?
.bytes()
.map_err(anyhow::Error::msg)?;
let (file, actual) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"),
32768,
)?;
let evidence = &outcome.evidence["agent_update"];
ensure!(
actual == expected
&& evidence["handoff_sha256"] == hash(&original.handoff().bytes()?)
&& evidence["installed_record_sha256"] == hash(&actual)
&& evidence["manifest_sha256"] == original.handoff().target.manifest_sha256
&& evidence["predecessor_record_sha256"]
== original.handoff().predecessor_record_sha256
&& evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?)
&& evidence["rolled_back"] == false,
"UPDATE_ORIGINAL_RECORD_AND_OUTCOME_CHANGED"
);
file.verify()
}
fn verify_rollback_outcome(
original: &Original,
trust: &TrustState,
proof: &rmm_domain::agent_update::UpdateInflightProof,
reply: &NativeControlReply,
) -> Result<()> {
let raw = URL_SAFE_NO_PAD.decode(
reply
.original_outcome_base64url
.as_ref()
.context("UPDATE_ORIGINAL_ROLLBACK_OUTCOME_REQUIRED")?,
)?;
let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?;
let event_raw = URL_SAFE_NO_PAD.decode(
proof
.events
.last()
.context("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED")?,
)?;
let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?;
let rmm_updater_handoff::Evidence::RollbackHealthVerified { receipt: signed } = event.evidence
else {
anyhow::bail!("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED")
};
let evidence = &outcome.evidence["agent_update"];
ensure!(
rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw
&& outcome.state == "failed"
&& outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR"
&& !outcome.reboot_required
&& outcome.evidence["postconditions_passed"] == false
&& evidence["rolled_back"] == true
&& evidence["handoff_sha256"] == hash(&original.handoff().bytes()?)
&& evidence["predecessor_record_sha256"]
== original.handoff().predecessor_record_sha256
&& evidence["installed_record_sha256"] == original.handoff().predecessor_record_sha256
&& evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?),
"UPDATE_ROLLBACK_OUTCOME_CHANGED"
);
let (file, raw) = Protected::read(
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"),
32768,
)?;
ensure!(
raw == trust.installed_raw(),
"UPDATE_ROLLBACK_CHANGED_RECORD_OR_FLOOR"
);
file.verify()
}
+1 -1
View File
@@ -320,7 +320,7 @@ pub fn context(
rmm_domain::jobs::Action::UpdateAgent { ref update } => {
match update.manifest().map_err(anyhow::Error::msg)?.platform {
update::Platform::LinuxX64 => "linux.base",
update::Platform::WindowsX64 => "windows.base",
update::Platform::WindowsX64 | update::Platform::WindowsGnuX64 => "windows.base",
}
}
_ => anyhow::bail!("UPDATE_HEALTH_ACTION"),
@@ -60,7 +60,7 @@ fn fixture(platform: Platform, full: bool) -> serde_json::Value {
Platform::LinuxX64 => PeerPinTransition::UnchangedGeneralPinV1 {
general_pin_sha256: "10".repeat(32),
},
Platform::WindowsX64 => PeerPinTransition::WindowsCodePairV1 {
Platform::WindowsX64 | Platform::WindowsGnuX64 => PeerPinTransition::WindowsCodePairV1 {
old_settings_sha256: "11".repeat(32),
new_settings_sha256: "12".repeat(32),
old_pin_sha256: "13".repeat(32),
@@ -111,7 +111,7 @@ fn fixture(platform: Platform, full: bool) -> serde_json::Value {
},
execution_identity: match platform {
Platform::LinuxX64 => "root",
Platform::WindowsX64 => "system",
Platform::WindowsX64 | Platform::WindowsGnuX64 => "system",
}
.into(),
not_before: "2030-01-01T12:00:00Z".parse().unwrap(),
+3 -1
View File
@@ -52,6 +52,8 @@ pub enum Platform {
LinuxX64,
#[serde(rename = "x86_64-pc-windows-msvc")]
WindowsX64,
#[serde(rename = "x86_64-pc-windows-gnu")]
WindowsGnuX64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
@@ -707,7 +709,7 @@ impl ResolvedAgentUpdate {
pub fn execution_identity(&self) -> Option<&'static str> {
self.manifest().ok().map(|m| match m.platform {
Platform::LinuxX64 => "root",
Platform::WindowsX64 => "system",
Platform::WindowsX64 | Platform::WindowsGnuX64 => "system",
})
}
}
+1 -6
View File
@@ -66,12 +66,7 @@ pub fn validate_for_scope(
.map_err(|_| "INVALID_AGENT_UPDATE_OBSERVATION")?
!= update
|| !typed.agent_update.validate()
|| typed.agent_update.platform
!= if scope == "linux.base" {
crate::agent_update::Platform::LinuxX64
} else {
crate::agent_update::Platform::WindowsX64
}
|| (typed.agent_update.platform == crate::agent_update::Platform::LinuxX64) != (scope == "linux.base")
|| typed.agent_update.observed_at - now > chrono::Duration::seconds(45)
|| now - typed.agent_update.observed_at > chrono::Duration::hours(72)
{
+6 -1
View File
@@ -63,7 +63,12 @@ pub async fn open(
);
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?;
control_lock(&mut tx, tenant, agent).await?;
let generation:i64=sqlx::query_scalar("UPDATE agent_installations SET connection_generation=connection_generation+1,capabilities=$2,transport=$3,connection_boot_id=$4,restore_blocked=restore_blocked OR $5<=last_sequence,sequence_regressed=sequence_regressed OR $5<=last_sequence,sync_required=$6,sync_ready=NOT $6,helper_sync_ready=false,last_sequence=$5 WHERE agent_id=$1 AND revoked_at IS NULL RETURNING connection_generation").bind(agent).bind(serde_json::to_value(&client.capabilities)?).bind(transport).bind(Uuid::parse_str(&e.boot_id)?).bind(i64::try_from(e.sequence)?).bind(client.capabilities.iter().any(|c|c=="rmm.sync.v1")).fetch_one(&mut *tx).await?;
anyhow::ensure!(
client.agent_version.len() <= 64
&& client.agent_version.bytes().all(|b| b.is_ascii_graphic()),
"invalid agent version"
);
let generation:i64=sqlx::query_scalar("UPDATE agent_installations SET connection_generation=connection_generation+1,capabilities=$2,transport=$3,connection_boot_id=$4,restore_blocked=restore_blocked OR $5<=last_sequence,sequence_regressed=sequence_regressed OR $5<=last_sequence,sync_required=$6,sync_ready=NOT $6,helper_sync_ready=false,last_sequence=$5,reported_agent_version=NULLIF($7,'') WHERE agent_id=$1 AND revoked_at IS NULL RETURNING connection_generation").bind(agent).bind(serde_json::to_value(&client.capabilities)?).bind(transport).bind(Uuid::parse_str(&e.boot_id)?).bind(i64::try_from(e.sequence)?).bind(client.capabilities.iter().any(|c|c=="rmm.sync.v1")).bind(&client.agent_version).fetch_one(&mut *tx).await?;
tx.commit().await?;
Ok(reply(
e,
+1 -1
View File
@@ -419,7 +419,7 @@ async fn issue(
)?;
let scope = match action.manifest().map_err(|_| denied())?.platform {
update::Platform::LinuxX64 => "linux.base",
update::Platform::WindowsX64 => "windows.base",
update::Platform::WindowsX64 | update::Platform::WindowsGnuX64 => "windows.base",
};
// Health requires a fresh real base inventory of the restarted platform;
// a not_configured update observation cannot stand in for that evidence.
+133 -25
View File
@@ -1,5 +1,7 @@
//! Tenant release publication and update-only bounded object transport.
//! Catalog metadata and passive checks never create/approve an execution job.
#[path = "bootstrap/mod.rs"]
mod bootstrap;
use crate::{
jobs::Error,
update_artifact_store::{MAX_CHUNK_BYTES, UpdateArtifacts},
@@ -42,6 +44,7 @@ pub fn platform_name(platform: Platform) -> &'static str {
match platform {
Platform::LinuxX64 => "x86_64-unknown-linux-gnu",
Platform::WindowsX64 => "x86_64-pc-windows-msvc",
Platform::WindowsGnuX64 => "x86_64-pc-windows-gnu",
}
}
pub fn protected_file(path: &FsPath, maximum: u64) -> Result<Vec<u8>, Error> {
@@ -122,9 +125,11 @@ pub fn store() -> Result<UpdateArtifacts, Error> {
}
Ok(UpdateArtifacts::new(
&std::env::var("RMM_PROFILE").unwrap_or_default(),
path.parent()
.ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?
.join("agent-update-artifacts"),
match std::env::var_os("RMM_AGENT_UPDATE_ARTIFACT_DIR") {
Some(value) if FsPath::new(&value).is_absolute() => value.into(),
Some(_) => return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
None => path.parent().ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?.join("agent-update-artifacts"),
},
metadata.uid(),
)?)
}
@@ -132,6 +137,7 @@ fn verifier_platform(platform: Platform) -> rmm_updater::Platform {
match platform {
Platform::LinuxX64 => rmm_updater::Platform::LinuxX64,
Platform::WindowsX64 => rmm_updater::Platform::WindowsX64,
Platform::WindowsGnuX64 => rmm_updater::Platform::WindowsGnuX64,
}
}
/// Network input can choose only one of two statically named protected
@@ -143,6 +149,7 @@ fn keyring_path_with(
let name = match platform {
Platform::LinuxX64 => "RMM_AGENT_UPDATE_LINUX_KEYRING_FILE",
Platform::WindowsX64 => "RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE",
Platform::WindowsGnuX64 => "RMM_AGENT_UPDATE_WINDOWS_GNU_KEYRING_FILE",
};
if let Some(path) = lookup(name)? {
if path.is_empty() || !FsPath::new(&path).is_absolute() {
@@ -161,12 +168,10 @@ pub fn verify_envelope(
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
) -> Result<ReleaseManifest, Error> {
let platform = envelope.decode().map_err(|_| invalid())?.manifest.platform;
let path = keyring_path_with(platform, |name| match std::env::var(name) {
Ok(value) => Ok(Some(value)),
Err(std::env::VarError::NotPresent) => Ok(None),
Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
})?;
let raw = protected_file(&path, 16384)?;
if platform == Platform::WindowsGnuX64 && std::env::var("RMM_PROFILE").as_deref() != Ok("development") {
return Err(fail("AGENT_UPDATE_DEVELOPMENT_CHANNEL_REQUIRED"));
}
let raw = keyring_bytes(platform)?;
verify_envelope_with_keyring(
envelope,
binding,
@@ -177,6 +182,14 @@ pub fn verify_envelope(
.map_err(|_| invalid())?,
)
}
fn keyring_bytes(platform: Platform) -> Result<Vec<u8>, Error> {
let path = keyring_path_with(platform, |name| match std::env::var(name) {
Ok(value) => Ok(Some(value)),
Err(std::env::VarError::NotPresent) => Ok(None),
Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
})?;
protected_file(&path, 16384)
}
fn verify_envelope_with_keyring(
envelope: &ReleaseEnvelope,
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
@@ -242,6 +255,7 @@ fn verify_envelope_with_keyring(
}
pub fn routes(router: Router<crate::State>) -> Router<crate::State> {
router
.route("/api/v1/tenants/{tenant}/enrollment-tokens", post(bootstrap::issue))
.route(
"/api/v1/tenants/{tenant}/agent-releases",
get(list).post(import),
@@ -253,7 +267,20 @@ pub fn routes(router: Router<crate::State>) -> Router<crate::State> {
}
pub fn gateway_routes(router: Router<crate::State>) -> Router<crate::State> {
router
.route("/install/linux.sh", get(|| async { ([("content-type", "text/x-shellscript")], concat!(include_str!("bootstrap/install.sh"),include_str!("bootstrap/lifecycle.py"),"
RMM_BOOTSTRAP_PYTHON
/usr/bin/python3 -I \"$file\" install \"$@\"
")) }))
.route("/install/windows.ps1", get(|| async { ([("content-type", "text/plain; charset=utf-8")], include_str!("bootstrap/install.ps1")) }))
.route("/agent/v1/bootstrap/current", get(bootstrap::current))
.route("/agent/v1/bootstrap/releases/{release}/artifacts/{artifact}", get(bootstrap::artifact))
.route("/agent/v1/bootstrap/updater", get(bootstrap::updater))
.route("/agent/v1/releases/current", get(current))
.route("/agent/v1/releases/installed", get(installed))
.route(
"/agent/v1/releases/{release}/artifacts/{artifact}",
get(release_artifact),
)
.route("/agent/v1/update-artifacts/{artifact}", get(download))
}
#[derive(Deserialize)]
@@ -412,12 +439,26 @@ pub async fn import(
let sequence = i64::try_from(m.release_sequence).map_err(|_| invalid())?;
resolve_artifacts(&mut tx, t, &m.artifacts).await?;
let manifest_sha = hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes);
sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)")
.bind(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(raw)
let inserted = sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) ON CONFLICT DO NOTHING")
.bind(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(&raw)
.bind(m.artifacts[0].artifact_id).bind(&m.artifacts[0].sha256).bind(m.artifacts[0].bytes as i64)
.bind(m.artifacts[1].artifact_id).bind(&m.artifacts[1].sha256).bind(m.artifacts[1].bytes as i64).execute(&mut *tx).await?;
if inserted.rows_affected() == 0 {
let stored: Option<Vec<u8>> = sqlx::query_scalar(
"SELECT envelope FROM agent_update_releases WHERE release_id=$1 AND platform=$2 AND release_sequence=$3",
)
.bind(m.release_id)
.bind(platform_name(m.platform))
.bind(sequence)
.fetch_optional(&mut *tx)
.await?;
if stored.as_deref() != Some(raw.as_slice()) {
return Err(fail("AGENT_UPDATE_RELEASE_CONFLICT"));
}
} else {
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'agent_update_release_imported',$4,now())").bind(t).bind(Uuid::new_v4()).bind(p.name)
.bind(json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"testsimulation":p.testsimulation})).execute(&mut *tx).await?;
}
tx.commit().await?;
Ok(Json(
json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"release_envelope":envelope,"manifest":m}),
@@ -496,6 +537,86 @@ async fn device(
.await
.map_err(|status| Error(status, "UNAUTHENTICATED"))
}
async fn installed(State(s): State<crate::State>, Extension(peer): Extension<crate::Peer>, headers: HeaderMap) -> Result<Response, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let row = sqlx::query("SELECT reported_agent_version,connection_generation,last_contact_at FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL").bind(agent).fetch_one(&mut *tx).await?;
tx.commit().await?;
Ok(([("cache-control","private, no-store")], Json(json!({"agent_id":agent,
"agent_version":row.get::<Option<String>,_>("reported_agent_version"),
"connection_generation":row.get::<i64,_>("connection_generation"),
"last_contact_at":row.get::<Option<chrono::DateTime<chrono::Utc>>,_>("last_contact_at")}))).into_response())
}
async fn check_device_platform(
tx: &mut Transaction<'_, Postgres>,
agent: Uuid,
platform: Platform,
) -> Result<(), Error> {
let caps: Value = sqlx::query_scalar(
"SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL",
)
.bind(agent)
.fetch_one(&mut **tx)
.await?;
let caps: Vec<String> = serde_json::from_value(caps)?;
let expected = match platform {
Platform::LinuxX64 => "linux.base/1",
Platform::WindowsX64 if caps.iter().any(|c| c == "agent.release.windows.gnu/1") => return Err(missing()),
Platform::WindowsX64 => "windows.base/1",
Platform::WindowsGnuX64 => "agent.release.windows.gnu/1",
};
if !caps.iter().any(|c| c == expected) {
return Err(missing());
}
Ok(())
}
/// A published release grants access to its two fixed binaries for authenticated
/// devices of its own tenant and platform. A catalog write first verifies both
/// objects. Fetching rechecks the live signing trust and the actual object.
async fn release_artifact(
State(s): State<crate::State>,
Extension(peer): Extension<crate::Peer>,
headers: HeaderMap,
Path((release, artifact)): Path<(Uuid, Uuid)>,
) -> Result<Response, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let (_, manifest) = checked_release(&mut tx, release).await?;
check_device_platform(&mut tx, agent, manifest.platform).await?;
let descriptor = manifest.artifacts.into_iter()
.find(|entry| entry.artifact_id == artifact).ok_or_else(missing)?;
tx.commit().await?;
verified_binary(tenant, descriptor.sha256, descriptor.bytes).await
}
async fn verified_binary(tenant: Uuid, sha256: String, size: u64) -> Result<Response, Error> {
use tokio::io::AsyncReadExt;
let digest = sha256.clone();
let file = tokio::task::spawn_blocking(move || -> Result<std::fs::File, Error> {
Ok(store()?.verified_file(tenant, &digest, size)?)
})
.await
.map_err(|_| fail("AGENT_UPDATE_ARTIFACT_UNAVAILABLE"))??;
let reader = tokio::fs::File::from_std(file).take(size);
let stream = futures_util::stream::try_unfold(reader, |mut reader| async move {
let mut chunk = vec![0; 64 * 1024];
let count = reader.read(&mut chunk).await?;
chunk.truncate(count);
Ok::<_, std::io::Error>((count != 0).then_some((chunk, reader)))
});
let mut response = Response::new(Body::from_stream(stream));
let headers = response.headers_mut();
headers.insert("content-type", HeaderValue::from_static("application/octet-stream"));
headers.insert("content-length", HeaderValue::from(size));
headers.insert("content-disposition", HeaderValue::from_static("attachment"));
headers.insert("x-content-type-options", HeaderValue::from_static("nosniff"));
headers.insert("cache-control", HeaderValue::from_static("private, no-store"));
headers.insert("x-artifact-sha256", HeaderValue::from_str(&sha256).map_err(|_| invalid())?);
Ok(response)
}
async fn current(
State(s): State<crate::State>,
Extension(peer): Extension<crate::Peer>,
@@ -504,20 +625,7 @@ async fn current(
) -> Result<Json<Value>, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let caps: Value = sqlx::query_scalar(
"SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL",
)
.bind(agent)
.fetch_one(&mut *tx)
.await?;
let caps: Vec<String> = serde_json::from_value(caps)?;
let expected = match q.platform {
Platform::LinuxX64 => "linux.base/1",
Platform::WindowsX64 => "windows.base/1",
};
if !caps.iter().any(|c| c == expected) {
return Err(missing());
}
check_device_platform(&mut tx, agent, q.platform).await?;
let ids:Vec<Uuid>=sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1").bind(platform_name(q.platform)).fetch_all(&mut *tx).await?;
let release = if let Some(id) = ids.first() {
let (envelope, manifest) = checked_release(&mut tx, *id).await?;
+2 -2
View File
@@ -128,7 +128,7 @@ async fn device_list(
.map_err(|e| e.0)?;
let mut page =
crate::pagination::Cursor::parse(state, &principal, "devices:agent_id:asc", query)?;
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.reported_agent_version,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
.bind(asset)
.bind(page.as_of).bind(page.last).bind(i64::from(page.limit)+1)
.fetch_all(&mut *tx).await.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
@@ -141,7 +141,7 @@ async fn device_list(
let revoked: Option<chrono::DateTime<Utc>> = r.get("revoked_at");
let age = last.map(|t| (Utc::now()-t).num_seconds());
let presence = if revoked.is_some() { "revoked" } else { match age { None=>"never_seen",Some(n) if n<90=>"online",Some(n) if n<180=>"stale",_=>"unreachable" } };
json!({"agent_id":r.get::<Uuid,_>("agent_id"),"asset_id":r.get::<Uuid,_>("asset_id"),"certificate_sha256":r.get::<String,_>("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::<Option<String>,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::<Option<chrono::DateTime<Utc>>,_>("last_authenticated_at"),"capabilities":r.get::<Value,_>("capabilities"),"enrollment_generation":r.get::<i64,_>("enrollment_generation"),"assignment_version":r.get::<i64,_>("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::<Option<Value>,_>("data"),"observed_at":r.get::<Option<chrono::DateTime<Utc>>,_>("observed_at"),"received_at":r.get::<Option<chrono::DateTime<Utc>>,_>("received_at"),"source_id":r.get::<Option<String>,_>("source_id"),"quality":if r.get::<Option<Value>,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"})
json!({"agent_id":r.get::<Uuid,_>("agent_id"),"asset_id":r.get::<Uuid,_>("asset_id"),"agent_version":r.get::<Option<String>,_>("reported_agent_version"),"certificate_sha256":r.get::<String,_>("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::<Option<String>,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::<Option<chrono::DateTime<Utc>>,_>("last_authenticated_at"),"capabilities":r.get::<Value,_>("capabilities"),"enrollment_generation":r.get::<i64,_>("enrollment_generation"),"assignment_version":r.get::<i64,_>("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::<Option<Value>,_>("data"),"observed_at":r.get::<Option<chrono::DateTime<Utc>>,_>("observed_at"),"received_at":r.get::<Option<chrono::DateTime<Utc>>,_>("received_at"),"source_id":r.get::<Option<String>,_>("source_id"),"quality":if r.get::<Option<Value>,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"})
}).collect::<Vec<_>>();
let next = if truncated {
Some(page.next(state, rows[usize::from(page.limit) - 1].get("agent_id"))?)
+205
View File
@@ -0,0 +1,205 @@
#requires -Version 5.1
#requires -RunAsAdministrator
[CmdletBinding()]
param(
[Parameter(Mandatory)][Uri]$BootstrapBase,
[Security.SecureString]$EnrollmentToken,
[ValidateSet('x86_64-pc-windows-msvc','x86_64-pc-windows-gnu')]
[string]$Platform = 'x86_64-pc-windows-msvc'
)
$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest
if ($PSVersionTable.PSEdition -ne 'Desktop' -or -not [Environment]::Is64BitProcess -or
$env:PROCESSOR_ARCHITECTURE -ne 'AMD64') { throw 'Use 64-bit Windows PowerShell on x64 Windows.' }
function Get-Origin([Uri]$Uri) {
if (-not $Uri.IsAbsoluteUri -or $Uri.Scheme -cne 'https' -or $Uri.HostNameType -ne 'Dns' -or
$Uri.UserInfo -or $Uri.Fragment -or $Uri.Query -or $Uri.AbsolutePath -cne '/') { throw 'A DNS HTTPS origin is required.' }
return $Uri.GetLeftPart([UriPartial]::Authority)
}
function Get-Id([string]$Value) {
$id = [Guid]::ParseExact($Value, 'D')
if ($id -eq [Guid]::Empty) { throw 'Empty release identifier.' }
return $id.ToString('D')
}
function Get-Download([string]$Path, [string]$File, [long]$Limit, [bool]$Exact) {
if ($Limit -lt 1 -or $Limit -gt 268435456) { throw 'Invalid bootstrap file size.' }
$request = [Net.HttpWebRequest]::Create($origin + $Path)
$request.AllowAutoRedirect = $false
$request.Timeout = 60000
$request.ReadWriteTimeout = 60000
$request.Headers['Authorization'] = 'Enrollment ' + $token
$response = $null
try {
$response = $request.GetResponse()
if ([int]$response.StatusCode -ne 200 -or $response.ContentLength -gt $Limit) { throw 'Unexpected bootstrap response.' }
$source = $response.GetResponseStream()
$dest = [IO.File]::Open($File, [IO.FileMode]::CreateNew, [IO.FileAccess]::Write, [IO.FileShare]::None)
try {
$buffer = New-Object byte[] 65536
[long]$total = 0
while (($n = $source.Read($buffer, 0, $buffer.Length)) -gt 0) {
$total += $n
if ($total -gt $Limit) { throw 'Bootstrap response too large.' }
$dest.Write($buffer, 0, $n)
}
if ($Exact -and $total -ne $Limit) { throw 'Incomplete bootstrap download.' }
$dest.Flush($true)
} finally { $dest.Dispose(); $source.Dispose() }
} finally { if ($response) { $response.Dispose() } }
}
function Get-DirectoryAcl($ServiceSid, [string]$Rights) {
$acl = New-Object Security.AccessControl.DirectorySecurity
$acl.SetAccessRuleProtection($true, $false)
$acl.SetOwner($administrators)
foreach ($sid in @($administrators, $system)) {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($sid, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow'))
}
if ($ServiceSid) {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($ServiceSid, $Rights, 'ContainerInherit,ObjectInherit', 'None', 'Allow'))
}
return $acl
}
function Set-Text([string]$Path, [string]$Value) {
[IO.File]::WriteAllText($Path, $Value, $utf8)
}
function Get-Hash([string]$Path) {
return (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant()
}
$origin = Get-Origin $BootstrapBase
$app = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) 'RustDiscovery'
$data = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery'
$state = Join-Path $data 'state'
$identity = Join-Path $state 'identity.json'
$serviceName = 'RmmDiscoveryWindows'
$releaseService = 'RmmDiscoveryReleasePull'
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue
if ($service -and (Test-Path -LiteralPath $identity -PathType Leaf)) {
Write-Output "Rust Discovery is already enrolled. Agent service: $($service.Status)."
return
}
if ($service -or (Get-Service $releaseService -ErrorAction SilentlyContinue) -or (Test-Path -LiteralPath $app) -or (Test-Path -LiteralPath $data)) {
throw 'Existing incomplete installation. Inspect the service and enrollment state before retrying.'
}
if (-not $EnrollmentToken) { $EnrollmentToken = Read-Host 'One-time enrollment token' -AsSecureString }
$ptr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($EnrollmentToken)
try { $token = [Runtime.InteropServices.Marshal]::PtrToStringBSTR($ptr) }
finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ptr) }
if ($token -cnotmatch '^[0-9a-f]{64}$') { throw 'Invalid one-time enrollment token.' }
$query = '?platform=' + $platform
$utf8 = New-Object Text.UTF8Encoding($false)
$administrators = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$system = [Security.Principal.SecurityIdentifier]::new('S-1-5-18')
$stage = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) ('RustDiscovery-install-' + [Guid]::NewGuid().ToString('N'))
[void][IO.Directory]::CreateDirectory($stage, (Get-DirectoryAcl $null ''))
$madeApp = $false
$madeData = $false
$madeService = $false
$madeReleaseService = $false
$startRequested = $false
try {
[Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
$metaPath = Join-Path $stage 'metadata.json'
Get-Download ('/agent/v1/bootstrap/current' + $query) $metaPath 131072 $false
$meta = [IO.File]::ReadAllText($metaPath) | ConvertFrom-Json
if ($meta.schema_version -ne 1 -or $meta.manifest.platform -cne $platform -or
$meta.manifest.artifacts.Count -ne 2 -or $meta.updater.sha256 -cnotmatch '^[0-9a-f]{64}$' -or
$meta.ca_pem.Length -gt 32768 -or $meta.ca_pem -notmatch '-----BEGIN CERTIFICATE-----') { throw 'Invalid bootstrap metadata.' }
$releaseId = Get-Id $meta.manifest.release_id
$tenant = Get-Id $meta.tenant_id
$gateway = [Uri](Get-Origin ([Uri]$meta.gateway_origin))
$addresses = @([Net.Dns]::GetHostAddresses($gateway.DnsSafeHost) | Sort-Object { $_.AddressFamily -ne [Net.Sockets.AddressFamily]::InterNetwork })
if (-not $addresses.Count) { throw 'Could not resolve the device gateway.' }
$endpoint = [Net.IPEndPoint]::new($addresses[0], $gateway.Port)
$appStage = Join-Path $stage 'application'
$dataStage = Join-Path $stage 'data'
$images = Join-Path $appStage ('releases\' + $releaseId)
$private = Get-DirectoryAcl $null ''
[void][IO.Directory]::CreateDirectory($appStage, $private)
[void][IO.Directory]::CreateDirectory($images)
[void][IO.Directory]::CreateDirectory($dataStage, $private)
$ring = Join-Path $dataStage 'release-keyring.json'
$envelope = Join-Path $images 'envelope.json'
Set-Text $ring ($meta.keyring | ConvertTo-Json -Depth 16 -Compress)
Set-Text $envelope ($meta.release_envelope | ConvertTo-Json -Depth 16 -Compress)
$updater = Join-Path $appStage 'rmm-updater-windows.exe'
Get-Download ('/agent/v1/bootstrap/updater' + $query) $updater $meta.updater.bytes $true
if ((Get-Hash $updater) -cne $meta.updater.sha256) { throw 'Bootstrap updater digest mismatch.' }
$roles = @('agent', 'helper')
for ($i = 0; $i -lt $roles.Count; $i++) {
$descriptor = $meta.manifest.artifacts[$i]
if ($descriptor.role -cne $roles[$i]) { throw 'Unexpected release role.' }
$id = Get-Id $descriptor.artifact_id
$file = Join-Path $images ('rmm-' + $roles[$i] + '-windows.exe')
Get-Download ("/agent/v1/bootstrap/releases/$releaseId/artifacts/$id" + $query) $file $descriptor.bytes $true
}
$agentPath = Join-Path $images 'rmm-agent-windows.exe'
$helperPath = Join-Path $images 'rmm-helper-windows.exe'
$canonical = & $updater --verify-bootstrap $ring $envelope $agentPath $helperPath
if ($LASTEXITCODE -ne 0 -or -not $canonical -or @($canonical).Count -ne 1) { throw 'Signed Windows release verification failed.' }
$verified = $canonical | ConvertFrom-Json
if ($verified.platform -cne $platform -or $verified.release_id -cne $releaseId) { throw 'Release identity mismatch.' }
Set-Text (Join-Path $images 'manifest.json') $canonical
$configPath = Join-Path $data 'config.json'
$tokenPath = Join-Path $state 'enrollment.token'
$ca = Join-Path $data 'server-ca.pem'
Set-Text (Join-Path $dataStage 'server-ca.pem') $meta.ca_pem
$config = [ordered]@{server_name=$gateway.DnsSafeHost; connect_address=$endpoint.ToString(); ca_file=$ca; state_directory=$state; enrollment_token_file=$tokenPath; transport='https'}
Set-Text (Join-Path $dataStage 'config.json') ($config | ConvertTo-Json -Compress)
$baseline = [ordered]@{schema_version=1; tenant_id=$tenant; release_id=$releaseId; release_sequence=$verified.release_sequence; manifest_sha256=(Get-Hash (Join-Path $images 'manifest.json'))}
Set-Text (Join-Path $dataStage 'installed-release.json') ($baseline | ConvertTo-Json -Compress)
[IO.Directory]::Move($appStage, $app)
$madeApp = $true
[IO.Directory]::Move($dataStage, $data)
$madeData = $true
$liveAgent = Join-Path $app ("releases\$releaseId\rmm-agent-windows.exe")
$binary = '"' + $liveAgent + '" --service --config "' + $configPath + '"'
New-Service -Name $serviceName -BinaryPathName $binary -StartupType Manual -Description 'Rust Discovery HTTPS pull agent' | Out-Null
$madeService = $true
$sc = Join-Path $env:SystemRoot 'System32\sc.exe'
& $sc config $serviceName start= auto obj= 'NT AUTHORITY\LocalService' | Out-Null
if ($LASTEXITCODE -ne 0) { throw 'SCM agent identity configuration failed.' }
& $sc sidtype $serviceName unrestricted | Out-Null
if ($LASTEXITCODE -ne 0) { throw 'SCM service SID configuration failed.' }
$sid = ([Security.Principal.NTAccount]::new('NT SERVICE', $serviceName)).Translate([Security.Principal.SecurityIdentifier])
Set-Acl -LiteralPath $app -AclObject (Get-DirectoryAcl $sid 'ReadAndExecute')
Set-Acl -LiteralPath $data -AclObject (Get-DirectoryAcl $sid 'ReadAndExecute')
[void][IO.Directory]::CreateDirectory($state, (Get-DirectoryAcl $sid 'Modify'))
# Agent-side private-path checks authenticate the owner as well as the DACL.
foreach ($root in @($app, $data)) {
foreach ($item in @(Get-ChildItem -LiteralPath $root -Recurse -Force)) {
$acl = Get-Acl -LiteralPath $item.FullName
$acl.SetOwner($administrators)
Set-Acl -LiteralPath $item.FullName -AclObject $acl
}
}
Set-Text $tokenPath $token
$tokenAcl = Get-Acl -LiteralPath $tokenPath
$tokenAcl.SetOwner($administrators)
Set-Acl -LiteralPath $tokenPath -AclObject $tokenAcl
$updaterBinary = '"' + (Join-Path $app 'rmm-updater-windows.exe') + '" --release-service'
New-Service -Name $releaseService -BinaryPathName $updaterBinary -StartupType Automatic -Description 'Rust Discovery signed Windows release polling' | Out-Null
$madeReleaseService = $true
$startRequested = $true
Start-Service $serviceName
$until = [DateTime]::UtcNow.AddSeconds(120)
while (-not (Test-Path -LiteralPath $identity -PathType Leaf)) {
if ([DateTime]::UtcNow -ge $until -or (Get-Service $serviceName).Status -ne 'Running') {
throw 'Enrollment has not completed. Installed configuration and device key are retained.'
}
Start-Sleep -Seconds 2
}
Start-Service $releaseService
Write-Output "Enrolled Rust Discovery agent $($verified.version) over HTTPS."
} catch {
if (-not $startRequested) {
if ($madeReleaseService) { & (Join-Path $env:SystemRoot 'System32\sc.exe') delete $releaseService | Out-Null }
if ($madeService) { & (Join-Path $env:SystemRoot 'System32\sc.exe') delete $serviceName | Out-Null }
if ($madeData) { Remove-Item -LiteralPath $data -Recurse -Force }
if ($madeApp) { Remove-Item -LiteralPath $app -Recurse -Force }
}
throw
} finally {
$token = $null
Remove-Item -LiteralPath $stage -Recurse -Force
}
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Usage: sudo sh linux.sh https://bootstrap.example
set -eu
umask 077
file=$(mktemp)
trap 'rm -f "$file"' EXIT
cat >"$file" <<'RMM_BOOTSTRAP_PYTHON'
+400
View File
@@ -0,0 +1,400 @@
"""Bootstrap a Linux systemd client and maintain its signed release pair."""
import argparse
import datetime
import fcntl
import getpass
import hashlib
import json
import os
from pathlib import Path
import platform
import pwd
import re
import shutil
import socket
import sqlite3
import ssl
import subprocess
import sys
import tempfile
import time
from urllib.parse import urlsplit
import urllib.request
import uuid
ROOT = Path('/opt/rust-discovery-client')
STATE = Path('/var/lib/rmm-discovery')
SERVICE = 'rmm-discovery-agent.service'
TIMER = 'rmm-discovery-update.timer'
PLATFORM = 'x86_64-unknown-linux-gnu'
MAX_BINARY = 256 * 1024 * 1024
UNIT_DIR = Path('/etc/systemd/system')
def require(condition, message):
if not condition:
raise ValueError(message)
def origin(value):
parsed = urlsplit(value)
require(parsed.scheme == 'https' and parsed.hostname and parsed.username is None
and parsed.password is None and not parsed.query and not parsed.fragment
and parsed.path in ('', '/'), 'HTTPS origin required')
return 'https://' + parsed.netloc
def canonical_id(value):
require(str(uuid.UUID(value)) == value, 'invalid object identifier')
return value
def save(path, value, mode=0o644):
data = json.dumps(value, separators=(',', ':')).encode() if not isinstance(value, bytes) else value
with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as tmp:
tmp.write(data)
os.fchmod(tmp.fileno(), mode)
tmp.flush()
os.fsync(tmp.fileno())
os.replace(tmp.name, path)
fd = os.open(path.parent, os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
def read(path):
return json.loads(path.read_bytes())
class NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, *_):
raise ValueError('unexpected HTTP redirect')
def retrieve(base, route, target, *, context, token=None, size=None, expected=None):
request = urllib.request.Request(origin(base) + route)
if token:
request.add_header('Authorization', 'Enrollment ' + token)
client = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect(),
urllib.request.HTTPSHandler(context=context))
limit = 65536 if size is None else size
require(type(limit) is int and 0 < limit <= MAX_BINARY, 'download size outside profile')
digest = hashlib.sha256()
count = 0
with client.open(request, timeout=30) as response:
require(response.status == 200, 'download rejected')
while True:
chunk = response.read(min(65536, limit + 1 - count))
if not chunk:
break
count += len(chunk)
require(count <= limit, 'download larger than descriptor')
digest.update(chunk)
target.write(chunk)
if size is not None:
require(count == size and digest.hexdigest() == expected, 'download hash or size mismatch')
def as_device(action, *args, stdout=None):
return subprocess.run(['/usr/sbin/runuser', '-u', 'rmm-discovery', '--', sys.executable, '-I',
str(ROOT / 'lifecycle.py'), action, *map(str, args)],
stdout=stdout, check=True, timeout=240)
def device_get(route, size=None, digest=None):
config = read(ROOT / 'config.json')
version = canonical_id(read(STATE / 'certificates/current.json')['version'])
pair = STATE / 'certificates/versions' / version
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.load_verify_locations(cafile=str(ROOT / 'gateway-ca.pem'))
ctx.load_cert_chain(str(pair / 'device.pem'), str(pair / 'device.key'))
retrieve(config['gateway'], route, sys.stdout.buffer, context=ctx,
size=int(size) if size is not None else None, expected=digest)
def device_idle():
# The root worker holds the admission lock before consulting this journal.
with sqlite3.connect(f'file:{STATE}/journal.sqlite?mode=ro', uri=True) as conn:
busy, = conn.execute("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))").fetchone()
print('busy' if busy else 'idle')
def remote(source, route, target, descriptor=None):
size = digest = None
if descriptor:
size, digest = descriptor['bytes'], descriptor['sha256']
require(type(size) is int and 0 < size <= MAX_BINARY and re.fullmatch('[0-9a-f]{64}', digest),
'invalid binary descriptor')
with target.open('xb') as output:
if source:
base, token = source
retrieve(base, route, output, context=ssl.create_default_context(), token=token, size=size, expected=digest)
else:
args = [size, digest] if descriptor else []
as_device('fetch', route, *args, stdout=output)
output.flush()
os.fsync(output.fileno())
def pair(folder, doc, source, updater):
manifest = doc['manifest']
release_id = canonical_id(manifest['release_id'])
prefix = '/agent/v1/bootstrap/releases' if source else '/agent/v1/releases'
suffix = '?platform=' + PLATFORM if source else ''
save(folder / 'envelope.json', doc['release_envelope'])
for artifact, role in zip(manifest['artifacts'], ('agent', 'helper'), strict=True):
require(artifact['role'] == role, 'incorrect artifact role')
aid = canonical_id(artifact['artifact_id'])
remote(source, f'{prefix}/{release_id}/artifacts/{aid}{suffix}', folder / role, artifact)
(folder / role).chmod(0o755)
ring = updater.parent / 'keyring.json'
verified = subprocess.check_output([updater, '--verify-bootstrap', ring, folder / 'envelope.json',
folder / 'agent', folder / 'helper'], timeout=120)
require(json.loads(verified) == manifest, 'metadata differs from signed release')
save(folder / 'manifest.json', verified)
folder.chmod(0o755)
return manifest
def link(base, name):
target = base / 'current.next'
target.unlink(missing_ok=True)
target.symlink_to('releases/' + canonical_id(name))
os.replace(target, base / 'current')
fd = os.open(base, os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
def installed():
return json.loads(as_device('fetch', '/agent/v1/releases/installed', stdout=subprocess.PIPE).stdout)
def healthy(version, baseline, duration=90):
until = time.monotonic() + duration
while time.monotonic() < until:
try:
record = installed()
contact = record.get('last_contact_at')
if contact:
recent = datetime.datetime.fromisoformat(contact.replace('Z', '+00:00')).timestamp()
if (time.time() - 65 < recent <= time.time() + 10 and record['agent_version'] == version
and record['connection_generation'] > baseline):
return True
except (subprocess.SubprocessError, ValueError, OSError):
pass
time.sleep(2)
return False
def service(*args):
subprocess.run(['systemctl', *args], check=True, timeout=60)
def units():
program = '/usr/bin/python3 -I ' + str(ROOT / 'lifecycle.py')
return {
SERVICE: f"""[Unit]
Description=Rust Discovery Linux agent
Wants=network-online.target
After=network-online.target time-sync.target
[Service]
User=rmm-discovery
Group=rmm-discovery
StateDirectory=rmm-discovery
StateDirectoryMode=0700
UMask=0077
ExecStart={program} run-agent
Restart=on-failure
RestartSec=5
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
[Install]
WantedBy=multi-user.target
""",
'rmm-discovery-update.service': f"""[Unit]
Description=Check and activate a signed Rust Discovery agent release
After=network-online.target
[Service]
Type=oneshot
ExecStart={program} update
UMask=0077
""",
TIMER: """[Unit]
Description=Periodic Rust Discovery agent release check
[Timer]
OnBootSec=1min
OnUnitActiveSec=5min
RandomizedDelaySec=20
[Install]
WantedBy=timers.target
""",
}
def enable():
for name, data in units().items():
path = UNIT_DIR / name
if path.exists():
require(path.read_bytes() == data.encode(), 'service file conflict: ' + name)
else:
save(path, data.encode())
service('daemon-reload')
service('enable', '--now', SERVICE, TIMER)
def install(base, token_file):
require(platform.machine() == 'x86_64', 'Linux x86-64 required')
base = origin(base)
if ROOT.exists():
config = read(ROOT / 'config.json')
require(config['bootstrap'] == base and (ROOT / 'current/manifest.json').is_file(),
'existing installation differs')
enable()
return
require(not STATE.exists() and not any((UNIT_DIR/name).exists() for name in units()),
'existing device installation requires migration')
token = Path(token_file).read_text().strip() if token_file else getpass.getpass('Einmalcode: ').strip()
require(re.fullmatch('[0-9a-f]{64}', token), 'invalid enrollment token')
try:
account = pwd.getpwnam('rmm-discovery')
except KeyError:
subprocess.run(['useradd', '--system', '--user-group', '--no-create-home', '--shell', '/usr/sbin/nologin',
'rmm-discovery'], check=True)
account = pwd.getpwnam('rmm-discovery')
require(account.pw_uid != 0 and account.pw_gid != 0, 'dedicated unprivileged service account required')
with tempfile.TemporaryDirectory(prefix='.rmm-', dir=ROOT.parent) as work:
staging = Path(work) / 'installation'
staging.mkdir()
remote((base, token), '/agent/v1/bootstrap/current?platform=' + PLATFORM, staging / 'bootstrap.json')
doc = read(staging / 'bootstrap.json')
require(doc['schema_version'] == 1, 'unknown bootstrap profile')
save(staging / 'keyring.json', doc['keyring'])
save(staging / 'gateway-ca.pem', doc['ca_pem'].encode())
save(staging / 'config.json', {'bootstrap': base, 'gateway': origin(doc['gateway_origin']),
'tenant': canonical_id(doc['tenant_id'])})
updater = staging / 'updater'
remote((base, token), '/agent/v1/bootstrap/updater?platform=' + PLATFORM, updater, doc['updater'])
updater.chmod(0o755)
releases = staging / 'releases'
releases.mkdir()
folder = releases / canonical_id(doc['manifest']['release_id'])
folder.mkdir()
manifest = pair(folder, doc, (base, token), updater)
link(staging, manifest['release_id'])
save(staging / 'lifecycle.py', Path(__file__).read_bytes())
save(staging / 'release.lock', b'')
save(staging / 'first.token', token.encode(), 0o440)
os.chown(staging / 'first.token', 0, account.pw_gid)
staging.chmod(0o755)
releases.chmod(0o755)
os.rename(staging, ROOT)
enable()
require(healthy(manifest['version'], 0), 'installed, awaiting authenticated device heartbeat')
(ROOT / 'first.token').unlink(missing_ok=True)
def run_agent():
conf = read(ROOT / 'config.json')
url = urlsplit(conf['gateway'])
# Resolve again on each service start. TLS identity always uses the configured DNS name.
address = socket.getaddrinfo(url.hostname, url.port or 443, type=socket.SOCK_STREAM)[0][4][0]
if ':' in address:
address = '[' + address + ']'
os.environ.update(RMM_AGENT_STATE=str(STATE), RMM_CA_FILE=str(ROOT / 'gateway-ca.pem'),
RMM_CONNECT_ADDR=f'{address}:{url.port or 443}', RMM_SERVER_NAME=url.hostname,
RMM_TRANSPORT='https', RMM_ENROLLMENT_TOKEN_FILE=str(ROOT / 'first.token'),
RMM_ENROLLMENT_TENANT=conf['tenant'], RMM_JOB_SIGNING_KEY_BOOTSTRAP='1',
RMM_RELEASE_LOCK=str(ROOT / 'release.lock'),
RMM_INSTALLED_RELEASE_VERSION=read(ROOT / 'current/manifest.json')['version'])
exe = str(ROOT / 'current/agent')
os.execv(exe, [exe])
def revert(intent):
# Persist failed sequence before restoring. An interruption re-enters recovery.
save(ROOT / 'failed.json', {'release_sequence': intent['sequence'], 'reason': 'activation_unconfirmed'})
link(ROOT, intent['previous'])
service('restart', SERVICE)
(ROOT / 'pending.json').unlink()
raise RuntimeError('release activation unconfirmed; predecessor selected')
def update():
with (ROOT / 'release.lock').open('rb') as lock:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
pending = ROOT / 'pending.json'
if pending.exists():
revert(read(pending))
active = read(ROOT / 'current/manifest.json')
with tempfile.TemporaryDirectory(prefix='.incoming-', dir=ROOT / 'releases') as work:
staging = Path(work) / 'generation'
staging.mkdir()
remote(None, '/agent/v1/releases/current?platform=' + PLATFORM, staging / 'current.json')
response = read(staging / 'current.json')
if response['status'] == 'not_configured':
return
require(response['status'] == 'available', 'unexpected release status')
doc = response['release']
if doc['release_envelope'] == read(ROOT / 'current/envelope.json'):
return
floor = active['release_sequence']
if (ROOT / 'failed.json').exists():
floor = max(floor, read(ROOT / 'failed.json')['release_sequence'])
manifest = pair(staging, doc, None, ROOT / 'updater')
require(manifest['release_sequence'] > floor, 'release sequence previously activated or rejected')
# Guard only this device while it is being changed. A fresh offer may
# remain queued while the worker temporarily owns the admission lock.
if as_device('idle', stdout=subprocess.PIPE).stdout.strip() != b'idle':
return
previous_health = installed()
release = canonical_id(manifest['release_id'])
dest = ROOT / 'releases' / release
if dest.exists():
# A previous check may have staged this version before a crash.
require(read(dest / 'envelope.json') == doc['release_envelope'], 'release id conflict')
subprocess.run([ROOT / 'updater', '--verify-bootstrap', ROOT / 'keyring.json', dest / 'envelope.json',
dest / 'agent', dest / 'helper'], stdout=subprocess.DEVNULL, check=True)
else:
(staging / 'current.json').unlink()
os.rename(staging, dest)
intent = {'previous': active['release_id'], 'sequence': manifest['release_sequence']}
save(pending, intent)
link(ROOT, release)
service('restart', SERVICE)
if not healthy(manifest['version'], previous_health['connection_generation']):
revert(intent)
pending.unlink()
(ROOT / 'first.token').unlink(missing_ok=True)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('install', 'update', 'run-agent', 'fetch', 'idle'))
parser.add_argument('values', nargs='*')
parser.add_argument('--token-file')
args = parser.parse_args()
if args.action in ('install', 'update'):
require(os.geteuid() == 0, 'administrative installation required')
os.umask(0o022)
if args.action == 'install':
require(len(args.values) == 1, 'one HTTPS bootstrap origin required')
install(args.values[0], args.token_file)
elif args.action == 'update':
update()
elif args.action == 'run-agent':
run_agent()
elif args.action == 'fetch':
device_get(*args.values)
else:
device_idle()
if __name__ == '__main__':
main()
+88
View File
@@ -0,0 +1,88 @@
//! Fresh-device bootstrap. Public scripts contain no credentials. Downloads use
//! the tenant's one-time enrollment token until the final enrollment consumes it.
use super::*;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Config {
gateway_origin: String,
updater_sha256: String,
updater_bytes: u64,
}
fn config(platform: Platform) -> Result<Config, Error> {
let slot = match platform {
Platform::LinuxX64 => "RMM_AGENT_BOOTSTRAP_LINUX_FILE",
Platform::WindowsX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_FILE",
Platform::WindowsGnuX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_GNU_FILE",
};
let path = std::env::var(slot).map_err(|_| fail("BOOTSTRAP_NOT_CONFIGURED"))?;
let config: Config = serde_json::from_slice(&protected_file(FsPath::new(&path), 8192)?)?;
let url = url::Url::parse(&config.gateway_origin).map_err(|_| invalid())?;
if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty()
|| url.password().is_some() || url.query().is_some() || url.fragment().is_some()
|| url.path() != "/" || !rmm_domain::agent_update::digest(&config.updater_sha256)
|| !(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&config.updater_bytes) {
return Err(fail("BOOTSTRAP_CONFIGURATION_INVALID"));
}
Ok(config)
}
fn private_json(body: Value) -> Response {
([("cache-control", "private, no-store")], Json(body)).into_response()
}
pub(super) async fn issue(State(s): State<crate::State>, headers: HeaderMap, Path(t): Path<Uuid>) -> Result<Response, Error> {
let p = s.auth.principal(&s, &headers, true).await.map_err(|status| Error(status, crate::auth::error_code(status)))?;
crate::jobs::scope(&p, t, true)?;
if p.session_hash.is_none() { return Err(Error(StatusCode::FORBIDDEN, "INTERACTIVE_AUTH_REQUIRED")); }
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
crate::permissions::require_principal(&mut tx, &p, "devices:enroll").await?;
let bootstrap_origin = std::env::var("RMM_BOOTSTRAP_ORIGIN").ok().map(|raw| {
let url = url::Url::parse(&raw).map_err(|_| invalid())?;
if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty() || url.password().is_some()
|| url.path() != "/" || url.query().is_some() || url.fragment().is_some() { return Err(invalid()); }
Ok(url.origin().ascii_serialization())
}).transpose()?;
let mut bytes = [0; 32];
openssl::rand::rand_bytes(&mut bytes).map_err(|_| fail("TOKEN_GENERATION_FAILED"))?;
let token = hex::encode(bytes);
let expires: chrono::DateTime<chrono::Utc> = sqlx::query_scalar("SELECT issue_enrollment_token($1)")
.bind(hash(token.as_bytes())).fetch_one(&mut *tx).await?;
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'enrollment_token_issued',$4,now())")
.bind(t).bind(Uuid::new_v4()).bind(p.name).bind(json!({"expires_at":expires})).execute(&mut *tx).await?;
tx.commit().await?;
Ok(private_json(json!({"token":token,"expires_at":expires,"bootstrap_origin":bootstrap_origin})))
}
async fn token_tenant(s: &crate::State, h: &HeaderMap) -> Result<Uuid, Error> {
let denied = || Error(StatusCode::UNAUTHORIZED, "ENROLLMENT_TOKEN_REQUIRED");
let token = h.get("authorization").and_then(|v| v.to_str().ok()).and_then(|v| v.strip_prefix("Enrollment ")).filter(|v| rmm_domain::agent_update::digest(v)).ok_or_else(denied)?;
let t: Option<Uuid> = sqlx::query_scalar("SELECT bootstrap_enrollment_tenant($1)")
.bind(hash(token.as_bytes())).fetch_one(&s.pool).await?;
t.ok_or_else(denied)
}
pub(super) async fn current(State(s): State<crate::State>, headers: HeaderMap, Query(q): Query<Current>) -> Result<Response, Error> {
let t = token_tenant(&s, &headers).await?;
let c = config(q.platform)?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
let release: Uuid = sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1")
.bind(platform_name(q.platform)).fetch_optional(&mut *tx).await?.ok_or_else(missing)?;
let (envelope, manifest) = checked_release(&mut tx, release).await?;
tx.commit().await?;
let ring: Value = serde_json::from_slice(&keyring_bytes(q.platform)?)?;
let ca = s.signer.as_ref().ok_or_else(missing)?.ca.to_pem().map_err(|_| invalid())?;
Ok(private_json(json!({"schema_version":1,"tenant_id":t,"release_envelope":envelope,"manifest":manifest,
"gateway_origin":c.gateway_origin,"ca_pem":String::from_utf8(ca).map_err(|_| invalid())?,
"keyring":ring,"updater":{"sha256":c.updater_sha256,"bytes":c.updater_bytes}})))
}
pub(super) async fn artifact(State(s): State<crate::State>, headers: HeaderMap, Path((id, artifact)): Path<(Uuid,Uuid)>, Query(q): Query<Current>) -> Result<Response, Error> {
let tenant = token_tenant(&s, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let (_, manifest) = checked_release(&mut tx, id).await?;
if manifest.platform != q.platform { return Err(missing()); }
let d = manifest.artifacts.into_iter().find(|v| v.artifact_id == artifact).ok_or_else(missing)?;
tx.commit().await?;
verified_binary(tenant, d.sha256, d.bytes).await
}
pub(super) async fn updater(State(s): State<crate::State>, headers: HeaderMap, Query(q): Query<Current>) -> Result<Response, Error> {
let tenant = token_tenant(&s, &headers).await?;
let c = config(q.platform)?;
verified_binary(tenant, c.updater_sha256, c.updater_bytes).await
}
+14 -11
View File
@@ -1091,7 +1091,11 @@ pub async fn operation(
"needs_attention"
} else if c("succeeded") == n {
"succeeded"
} else if c("succeeded") + c("failed") + c("cancelled") + c("expired") + c("closed_unknown")
} else if c("succeeded")
+ c("failed")
+ c("cancelled")
+ c("expired")
+ c("closed_unknown")
== n
{
if c("succeeded") > 0 {
@@ -1242,12 +1246,13 @@ pub async fn close_unknown(
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?;
crate::permissions::require_principal(&mut tx, p, "plans:approve").await?;
let row =
sqlx::query("SELECT attempt_id,state,revision,result FROM jobs WHERE job_id=$1 FOR UPDATE")
.bind(id)
.fetch_optional(&mut *tx)
.await?
.ok_or_else(missing)?;
let row = sqlx::query(
"SELECT attempt_id,state,revision,result FROM jobs WHERE job_id=$1 FOR UPDATE",
)
.bind(id)
.fetch_optional(&mut *tx)
.await?
.ok_or_else(missing)?;
if row.get::<Uuid, _>("attempt_id") != input.attempt_id
|| row.get::<i64, _>("revision") != input.revision
{
@@ -1287,11 +1292,9 @@ pub async fn close_unknown(
.bind(tenant)
.bind(Uuid::new_v4())
.bind(&p.name)
.bind(
json!({"job_id":id,"attempt_id":input.attempt_id,"grant_id":grant,"closure_id":closure,
.bind(json!({"job_id":id,"attempt_id":input.attempt_id,"grant_id":grant,"closure_id":closure,
"original_revision":input.revision,"reason":input.reason,"session_hash":session,
"approval_origin":p.approval_origin(),"testsimulation":p.testsimulation}),
)
"approval_origin":p.approval_origin(),"testsimulation":p.testsimulation}))
.execute(&mut *tx)
.await?;
tx.commit().await?;
+1 -1
View File
@@ -98,7 +98,7 @@ impl UpdateArtifacts {
hasher: Sha256::new(),
})
}
fn verified_file(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result<File> {
pub(crate) fn verified_file(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result<File> {
ensure!(descriptor(hash, bytes), "bounded update object descriptor");
let parent = self.parent(tenant)?;
let mut file = OpenOptions::new()
+1 -1
View File
@@ -516,5 +516,5 @@ pub(super) async fn test_fixed_echo(
tx.rollback().await.unwrap();
}
}
crate::windows_echo_completion::test_completed_echo(admin, s, &p, &w).await;
crate::windows_echo_completion::test_completed_echo(admin,s,&p,&w).await;
}
+5
View File
@@ -43,6 +43,11 @@ mod linux {
}
pub fn run() -> Result<()> {
let args: Vec<_> = std::env::args_os().skip(1).collect();
if args.first().is_some_and(|arg| arg == "--verify-bootstrap") {
let release = rmm_updater::verify_bootstrap_files(rmm_updater::Platform::LinuxX64, &args[1..])?;
println!("{}", serde_json::to_string(release.manifest())?);
return Ok(());
}
if args == [OsStr::new("--help")] {
println!(
"rmm-agent-updater --serve\nFixed protected local binding/policy and authenticated Fullhelper IPC only. No automatic activation or startup replay. A failed/ambiguous pass stops closed; operator recovery must inspect the original handoff."
+1
View File
@@ -12,3 +12,4 @@ serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
uuid.workspace = true
rmm-domain = { path = "../domain" }
+45
View File
@@ -0,0 +1,45 @@
//! Local verification for the separately distributed stable bootstrap updater.
use crate::{ArtifactRole, Platform, SignedRelease, TrustedContext, TrustedUpdateKey, UpdateKeyring, VerifiedRelease};
use anyhow::{Context, Result, ensure};
use rmm_domain::agent_update::{Platform as WirePlatform, ReleaseEnvelope, UpdateKeyringFile};
use std::{ffi::OsString, fs::File, io::Read, time::{SystemTime, UNIX_EPOCH}};
fn bounded(path: &OsString, limit: u64) -> Result<Vec<u8>> {
let mut bytes = Vec::new();
File::open(path)?.take(limit + 1).read_to_end(&mut bytes)?;
ensure!(bytes.len() as u64 <= limit, "bootstrap metadata too large");
Ok(bytes)
}
/// Arguments are four local files in order: pinned keyring, envelope, agent,
/// helper. The caller owns the protected staging directory and activation floor.
pub fn verify_bootstrap_files(platform: Platform, args: &[OsString]) -> Result<VerifiedRelease> {
let [keyring, envelope, agent, helper] = args else {
anyhow::bail!("four local paths required: KEYRING ENVELOPE AGENT HELPER");
};
let config: UpdateKeyringFile = serde_json::from_slice(&bounded(keyring, 16384)?)?;
ensure!(config.validate(), "invalid bootstrap keyring");
let keys = config.keys.into_iter().map(|key| {
let platform = match key.platform {
WirePlatform::LinuxX64 => Platform::LinuxX64,
WirePlatform::WindowsX64 => Platform::WindowsX64,
WirePlatform::WindowsGnuX64 => Platform::WindowsGnuX64,
};
let raw = hex::decode(key.public_key_hex)?.try_into().ok().context("Ed25519 public key length")?;
TrustedUpdateKey::new(raw, platform, key.first_sequence, key.last_sequence, key.revoked)
}).collect::<Result<Vec<_>>>()?;
let ring = UpdateKeyring::new(config.generation, keys)?;
let envelope: ReleaseEnvelope = serde_json::from_slice(&bounded(envelope, 32768)?)?;
let decoded = envelope.decode().map_err(|_| anyhow::anyhow!("invalid release envelope"))?;
let context = TrustedContext {
platform, now_utc_seconds: SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
keyring_generation: config.generation, protocol_major: 1, state_schema: 1,
updater_version: 1, minimum_release_sequence: 0, active_release: None,
};
let release = crate::verify_release(SignedRelease {schema_version: envelope.schema_version,
key_id: &envelope.key_id, payload_bytes: &decoded.payload_bytes,
signature: &decoded.signature}, &ring, &context)?;
release.verify_artifact(ArtifactRole::Agent, File::open(agent)?)?;
release.verify_artifact(ArtifactRole::Helper, File::open(helper)?)?;
Ok(release)
}
+3
View File
@@ -3,8 +3,11 @@
//!
//! See docs/agent-updater-proposal.md for the separate, unfinished integration.
mod bootstrap;
mod manifest;
pub use bootstrap::verify_bootstrap_files;
pub use manifest::{
ActiveRelease, ArtifactDescriptor, ArtifactRole, MAX_ARTIFACT_BYTES, MAX_MANIFEST_BYTES,
Platform, RELEASE_SIGNATURE_DOMAIN, ReleaseManifest, ReleaseRelation, SignedRelease,
+2
View File
@@ -18,6 +18,8 @@ pub enum Platform {
LinuxX64,
#[serde(rename = "x86_64-pc-windows-msvc")]
WindowsX64,
#[serde(rename = "x86_64-pc-windows-gnu")]
WindowsGnuX64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+40
View File
@@ -0,0 +1,40 @@
worker_processes 1;
pid /run/rmm-install-ingress/nginx.pid;
error_log stderr warn;
events { worker_connections 128; }
http {
access_log off;
client_body_temp_path /run/rmm-install-ingress/client;
proxy_temp_path /run/rmm-install-ingress/proxy;
fastcgi_temp_path /run/rmm-install-ingress/fastcgi;
uwsgi_temp_path /run/rmm-install-ingress/uwsgi;
scgi_temp_path /run/rmm-install-ingress/scgi;
client_max_body_size 1k;
server_tokens off;
keepalive_timeout 10;
server {
listen 0.0.0.0:8443 ssl;
listen [::]:8443 ssl;
server_name discovery.ease-technologies.de;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_certificate /run/credentials/rmm-install-ingress.service/chain.pem;
ssl_certificate_key /run/credentials/rmm-install-ingress.service/key.pem;
proxy_ssl_trusted_certificate /run/credentials/rmm-install-ingress.service/gateway-ca.pem;
proxy_ssl_name discovery.ease-technologies.de;
proxy_ssl_server_name on;
proxy_ssl_verify on;
proxy_buffering off;
proxy_pass_request_body off;
proxy_pass_request_headers off;
proxy_set_header Host discovery.ease-technologies.de;
proxy_set_header Content-Length "";
proxy_set_header Authorization $http_authorization;
location ~ "^/(install/(linux\.sh|windows\.ps1)|agent/v1/bootstrap/(current|updater|releases/[0-9a-f-]{36}/artifacts/[0-9a-f-]{36}))$" {
limit_except GET { deny all; }
proxy_pass https://127.0.0.1:18444$uri$is_args$args;
}
location / { return 404; }
}
}
+22
View File
@@ -0,0 +1,22 @@
[Unit]
Description=Public HTTPS installer and tenant bootstrap downloads
After=network-online.target docker.service
[Service]
DynamicUser=true
RuntimeDirectory=rmm-install-ingress
LoadCredential=chain.pem:/opt/rmm-bootstrap-download/chain.pem
LoadCredential=key.pem:/opt/rmm-bootstrap-download/domain.key
LoadCredential=gateway-ca.pem:/opt/rust-discovery/devstate/pki/ca.pem
ExecStart=/usr/sbin/nginx -c /etc/rmm-install-ingress.conf -g "daemon off;"
Restart=on-failure
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
PrivateDevices=true
CapabilityBoundingSet=
UMask=0077
[Install]
WantedBy=multi-user.target
+22
View File
@@ -0,0 +1,22 @@
x-release-environment: &release-environment
RMM_AGENT_UPDATE_ARTIFACT_DIR: /release-objects
RMM_AGENT_UPDATE_LINUX_KEYRING_FILE: /release-config/linux-keyring.json
RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE: /release-config/windows-keyring.json
RMM_AGENT_BOOTSTRAP_LINUX_FILE: /release-config/linux-bootstrap.json
RMM_AGENT_BOOTSTRAP_WINDOWS_FILE: /release-config/windows-bootstrap.json
RMM_AGENT_UPDATE_WINDOWS_GNU_KEYRING_FILE: /release-config/windows-gnu-keyring.json
RMM_AGENT_BOOTSTRAP_WINDOWS_GNU_FILE: /release-config/windows-gnu-bootstrap.json
services:
api:
environment:
<<: *release-environment
RMM_BOOTSTRAP_ORIGIN: ${RMM_BOOTSTRAP_ORIGIN:-https://discovery.ease-technologies.de:8443}
volumes:
- ../devstate/mvp-releases/config:/release-config:ro
- ../devstate/mvp-releases/objects:/release-objects:rw
gateway:
environment: *release-environment
volumes:
- ../devstate/mvp-releases/config:/release-config:ro
- ../devstate/mvp-releases/objects:/release-objects:ro
+22
View File
@@ -0,0 +1,22 @@
-- Pre-enrollment downloads and final enrollment share one short-lived credential.
-- Only the final enrollment consumes it. Table access stays with the DB owner.
CREATE FUNCTION bootstrap_enrollment_tenant(digest text) RETURNS uuid
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog AS $$
SELECT tenant_id FROM public.enrollment_tokens
WHERE token_hash = digest AND consumed_at IS NULL AND expires_at > now();
$$;
CREATE FUNCTION issue_enrollment_token(digest text) RETURNS timestamptz
LANGUAGE sql SECURITY DEFINER SET search_path = pg_catalog AS $$
INSERT INTO public.enrollment_tokens (token_hash,tenant_id,expires_at)
SELECT digest, current_setting('app.tenant_id')::uuid, now() + interval '15 minutes'
WHERE digest ~ '^[0-9a-f]{64}$' RETURNING expires_at;
$$;
REVOKE ALL ON FUNCTION bootstrap_enrollment_tenant(text), issue_enrollment_token(text) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION bootstrap_enrollment_tenant(text), issue_enrollment_token(text) TO rmm_app;
UPDATE memberships SET permissions = array_append(permissions,'devices:enroll')
WHERE 'devices:revoke' = ANY(permissions) AND NOT ('devices:enroll' = ANY(permissions));
ALTER TABLE agent_installations ADD COLUMN reported_agent_version text;
GRANT UPDATE(reported_agent_version) ON agent_installations TO rmm_app;
ALTER TABLE agent_update_releases DROP CONSTRAINT agent_update_releases_platform_check;
ALTER TABLE agent_update_releases ADD CHECK (platform IN
('x86_64-unknown-linux-gnu','x86_64-pc-windows-msvc','x86_64-pc-windows-gnu'));
+257
View File
@@ -0,0 +1,257 @@
#!/usr/bin/env python3
"""Prepare an Ed25519 agent release on the signing host and publish through the catalog API."""
import argparse
import base64
import datetime
import getpass
import hashlib
import http.client
from http.cookies import SimpleCookie
import json
import os
from pathlib import Path
import re
import shutil
import ssl
import subprocess
import tempfile
import time
from urllib.parse import urlencode, urlsplit
import uuid
LINUX = 'x86_64-unknown-linux-gnu'
WINDOWS = 'x86_64-pc-windows-msvc'
FILES = {LINUX: ('rmm-agent', 'rmm-privileged-helper', 'rmm-agent-updater'),
WINDOWS: ('rmm-agent-windows.exe', 'rmm-helper-windows.exe', 'rmm-updater-windows.exe')}
WINDOWS_GNU = 'x86_64-pc-windows-gnu'
FILES[WINDOWS_GNU] = FILES[WINDOWS]
LIMIT = 256 * 1024 * 1024
PREFIX = b'rmm.agent-release.v1\0'
def check(test, message):
if not test:
raise ValueError(message)
def encoded(value):
return json.dumps(value, separators=(',', ':'), ensure_ascii=False).encode()
def b64(data):
return base64.urlsafe_b64encode(data).rstrip(b'=').decode()
def fingerprint(path):
digest = hashlib.sha256()
size = path.stat().st_size
check(path.is_file() and 0 < size <= LIMIT, 'invalid release binary size')
with path.open('rb') as f:
for block in iter(lambda: f.read(1024 * 1024), b''):
digest.update(block)
return digest.hexdigest(), size
def binaries(folder, receipt):
record = json.loads(receipt.read_text(encoding='utf-8-sig'))
if 'target' in record and 'sha256' in record:
target, hashes = record['target'], record['sha256']
else:
check(record.get('completed') is True and record['stage'] == 'built_not_deployed', 'completed MSVC receipt required')
target = WINDOWS
entries = record['artifacts']
check(all(entries[name[:-4]]['build_target'] == target for name in FILES[target]), 'incorrect build target')
hashes = {name: entries[name[:-4]]['sha256'] for name in FILES[target]}
check(target in FILES, 'unknown release target')
result = []
for name in FILES[target]:
path = folder / name
digest, size = fingerprint(path)
check(digest == hashes[name], 'file differs from build receipt: ' + name)
result.append({'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, target + '/' + name + '/' + digest)),
'sha256': digest, 'bytes': size})
return target, result
def openssl(*args):
return subprocess.check_output(['openssl', *map(str, args)], stderr=subprocess.DEVNULL, timeout=20)
def save_once(path, raw, uid=None):
if path.exists():
check(path.read_bytes() == raw, 'existing configuration differs: ' + path.name)
return
with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as f:
try:
f.write(raw)
os.fchmod(f.fileno(), 0o600)
if uid is not None:
os.fchown(f.fileno(), uid, uid)
f.flush()
os.fsync(f.fileno())
os.link(f.name, path)
finally:
os.unlink(f.name)
def provision_folder(path, uid=None):
path.mkdir(mode=0o700, parents=True, exist_ok=True)
check(path.is_dir() and not path.is_symlink(), 'release state directory required')
if uid is not None and path.stat().st_uid != uid:
os.chown(path, uid, uid)
os.chmod(path, 0o700)
def https(value):
url = urlsplit(value)
check(url.scheme == 'https' and url.hostname and not url.username and not url.password
and url.path in ('', '/') and not url.query and not url.fragment, 'HTTPS origin required')
return url
def prepare(args):
https(args.gateway)
check(0 < args.sequence < 2**63 and re.fullmatch('[A-Za-z0-9.+_-]{1,64}', args.version), 'invalid release version/sequence')
check(0 < args.days <= 3650, 'invalid validity in days')
platform, blobs = binaries(args.artifacts, args.build_receipt)
label = {LINUX:'linux', WINDOWS:'windows', WINDOWS_GNU:'windows-gnu'}[platform]
provision_folder(args.state)
config, private = args.state / 'config', args.state / 'private'
provision_folder(config, args.service_uid)
provision_folder(args.state / 'objects', args.service_uid)
provision_folder(private)
key = private / (label + '.pem')
if not key.exists():
save_once(key, openssl('genpkey', '-algorithm', 'ED25519'))
check(not key.is_symlink() and key.stat().st_mode & 0o077 == 0, 'private release key permissions')
public = openssl('pkey', '-in', key, '-pubout', '-outform', 'DER')
check(len(public) == 44 and public[:12] == bytes.fromhex('302a300506032b6570032100'), 'Ed25519 key required')
pub = public[12:]
ring = {'schema_version': 1, 'generation': 1, 'keys': [{'public_key_hex': pub.hex(), 'platform': platform,
'first_sequence': 1, 'last_sequence': 2**63-1, 'revoked': False}]}
save_once(config / (label + '-keyring.json'), encoded(ring), args.service_uid)
boot = {'gateway_origin': args.gateway.rstrip('/'), 'updater_sha256': blobs[2]['sha256'], 'updater_bytes': blobs[2]['bytes']}
boot_path = config / (label + '-bootstrap.json')
# The stable bootstrap worker is provisioned separately from replaceable code.
if not boot_path.exists():
save_once(boot_path, encoded(boot), args.service_uid)
existing = json.loads(boot_path.read_bytes())
check(existing['gateway_origin'] == boot['gateway_origin'], 'existing gateway origin differs')
prepared = args.state / 'prepared' / label / str(args.sequence)
provision_folder(prepared.parent)
if prepared.exists():
check(json.loads((prepared / 'inputs.json').read_bytes()) == {'version': args.version, 'blobs': blobs}, 'sequence already bound')
print(prepared / 'envelope.json')
return
now = int(time.time())
manifest = {'schema_version': 1, 'release_id': str(uuid.uuid4()), 'release_sequence': args.sequence,
'version': args.version, 'platform': platform, 'published_at': now, 'expires_at': now + args.days * 86400,
'protocol_major': 1, 'state_schema': 1, 'minimum_updater_version': 1,
'artifacts': [dict(role=role, **blob) for role, blob in zip(('agent', 'helper'), blobs[:2])]}
raw = encoded(manifest)
with tempfile.TemporaryDirectory(dir=prepared.parent) as tmpdir:
work = Path(tmpdir)
msg = work / 'message'
msg.write_bytes(PREFIX + raw)
sig = openssl('pkeyutl', '-sign', '-rawin', '-inkey', key, '-in', msg)
(work / 'public.der').write_bytes(public)
(work / 'signature').write_bytes(sig)
openssl('pkeyutl', '-verify', '-rawin', '-pubin', '-keyform', 'DER', '-inkey', work / 'public.der',
'-in', msg, '-sigfile', work / 'signature')
output = work / 'release'
output.mkdir()
env = {'schema_version': 1, 'key_id': hashlib.sha256(pub).hexdigest(), 'payload_bytes': b64(raw), 'signature': b64(sig)}
save_once(output / 'envelope.json', encoded(env))
save_once(output / 'inputs.json', encoded({'version': args.version, 'blobs': blobs}))
output.rename(prepared)
print(prepared / 'envelope.json')
class Publisher:
def __init__(self, address, ca):
self.origin = address.rstrip('/')
self.url = https(self.origin)
self.ctx = ssl.create_default_context(cafile=ca)
self.headers = {'Origin': self.origin}
def request(self, method, route, body=None, headers=None):
conn = http.client.HTTPSConnection(self.url.hostname, self.url.port or 443, context=self.ctx, timeout=180)
try:
conn.request(method, route, body=body, headers={**self.headers, **(headers or {})})
reply = conn.getresponse()
data = reply.read(1048577)
check(200 <= reply.status < 300, f'{method} {route.split("?")[0]} returned HTTP {reply.status}')
check(len(data) <= 1048576, 'response exceeds limit')
if reply.getheader('Set-Cookie'):
cookie = SimpleCookie(reply.getheader('Set-Cookie'))
token = cookie['__Host-rmm_session'].value
self.headers['Cookie'] = '__Host-rmm_session=' + token
return json.loads(data) if data else None
finally:
conn.close()
def publish(args):
platform, blobs = binaries(args.artifacts, args.build_receipt)
env = json.loads(args.envelope.read_bytes())
manifest = json.loads(base64.urlsafe_b64decode(env['payload_bytes'] + '==='))
check(manifest['platform'] == platform and manifest['artifacts'] == [dict(role=role, **blob)
for role, blob in zip(('agent', 'helper'), blobs[:2])], 'input files differ from release envelope')
client = Publisher(args.origin, args.ca)
if args.dev_login_file:
path = args.dev_login_file
check(path.stat().st_mode & 0o077 == 0, 'dev login file requires private permissions')
credentials = json.loads(path.read_bytes())
login = {k: credentials[k] for k in ('username','password')}
else:
login = {'username': args.dev_username, 'password': getpass.getpass('Development WebUI password: ')}
client.request('POST', '/auth/dev/login', encoded(login), {'Content-Type': 'application/json'})
session = client.request('GET', '/auth/session')
client.headers['X-CSRF-Token'] = session['csrf_token']
try:
tenant = str(uuid.UUID(args.tenant))
check(session['tenant_id'] == tenant and 'catalog:write' in session['permissions'], 'tenant catalog write permission required')
path = '/api/v1/tenants/' + tenant
for name, blob in zip(FILES[platform], blobs):
query = urlencode(dict(artifact_id=blob['artifact_id'], sha256=blob['sha256'], size_bytes=blob['bytes']))
with (args.artifacts / name).open('rb') as data:
result = client.request('POST', path + '/agent-update-artifacts?' + query, data,
{'Content-Type': 'application/octet-stream', 'Content-Length': str(blob['bytes'])})
check(result['sha256'] == blob['sha256'] and result['size_bytes'] == blob['bytes'], 'artifact receipt differs')
result = client.request('POST', path + '/agent-releases', encoded(env), {'Content-Type': 'application/json'})
check(result['release_envelope'] == env, 'published envelope changed')
print(json.dumps({'release_id': result['release_id'], 'version': manifest['version'], 'platform': platform,
'manifest_sha256': result['manifest_sha256']}))
finally:
client.request('POST', '/auth/logout', b'{}', {'Content-Type':'application/json'})
def main():
parser = argparse.ArgumentParser(description=__doc__)
sub = parser.add_subparsers(required=True)
for name, fn in (('prepare', prepare), ('publish', publish)):
cmd = sub.add_parser(name)
cmd.set_defaults(run=fn)
cmd.add_argument('--artifacts', type=Path, required=True)
cmd.add_argument('--build-receipt', type=Path, required=True)
if name == 'prepare':
cmd.add_argument('--state', type=Path, required=True)
cmd.add_argument('--gateway', required=True)
cmd.add_argument('--sequence', type=int, required=True)
cmd.add_argument('--version', required=True)
cmd.add_argument('--days', type=int, default=90)
cmd.add_argument('--service-uid', type=int, default=os.getuid())
else:
cmd.add_argument('--origin', required=True)
cmd.add_argument('--ca', type=Path)
cmd.add_argument('--tenant', required=True)
cmd.add_argument('--envelope', type=Path, required=True)
auth = cmd.add_mutually_exclusive_group(required=True)
auth.add_argument('--dev-username')
auth.add_argument('--dev-login-file', type=Path)
args = parser.parse_args()
args.run(args)
if __name__ == '__main__':
main()
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Stage a build on the development server, sign there, and publish over the loopback HTTPS management API."""
import argparse
import hashlib
import json
from pathlib import Path
import shlex
import subprocess
import sys
import agent_release
from dev_stage import ssh_prefix
ROOT = Path(__file__).resolve().parents[1]
def on_server(options):
import hashlib
import json
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
os.umask(0o077)
state = Path('/opt/rust-discovery/devstate/mvp-releases')
stage = Path.home() / 'rmm-dev-stage'
tool = stage / options['tool'] / 'agent_release.py'
if hashlib.sha256(tool.read_bytes()).hexdigest() != options['tool']:
raise ValueError('staged release tool differs')
build = state / 'builds' / options['label'] / str(options['sequence'])
build.mkdir(parents=True, exist_ok=True)
for name, digest in options['files'].items():
source = stage / digest / name
dest = build / name
if hashlib.sha256(source.read_bytes()).hexdigest() != digest:
raise ValueError('staged build differs: ' + name)
if not dest.exists():
with tempfile.NamedTemporaryFile(dir=build, delete=False) as tmp:
with source.open('rb') as f:
shutil.copyfileobj(f, tmp)
tmp.flush()
os.fsync(tmp.fileno())
try:
os.link(tmp.name, dest)
finally:
os.unlink(tmp.name)
if hashlib.sha256(dest.read_bytes()).hexdigest() != digest:
raise ValueError('sequence already contains different build: ' + name)
inputs = ['--artifacts', str(build), '--build-receipt', str(build / options['receipt'])]
subprocess.run(['python3', '-I', str(tool), 'prepare', *inputs, '--state', str(state), '--gateway', options['gateway'],
'--service-uid','10001','--sequence',str(options['sequence']),'--version',options['version']],check=True)
if options['prepare_only']:
return
# Use the ordinary development catalog permission and CSRF-protected API.
# Credentials are read within the dev server and never returned over SSH.
cid = subprocess.check_output(['docker','ps','-q','--filter','label=com.docker.compose.project=rust-discovery-server',
'--filter','label=com.docker.compose.service=api']).decode().strip().splitlines()
if len(cid) != 1:
raise ValueError('expected one running development API')
env = dict(x.partition('=')[::2] for x in json.loads(subprocess.check_output(['docker','inspect',cid[0]]))[0]['Config']['Env'])
if env.get('RMM_PROFILE') != 'development' or env.get('RMM_DEV_AUTH') != 'true':
raise ValueError('explicit dev API required')
with tempfile.NamedTemporaryFile(mode='w', dir=state) as auth:
json.dump({'username':env['RMM_DEV_USERNAME'],'password':env['RMM_DEV_PASSWORD']},auth)
auth.flush()
subprocess.run(['python3','-I',str(tool),'publish',*inputs,'--tenant',options['tenant'],
'--envelope',str(state/'prepared'/options['label']/str(options['sequence'])/'envelope.json'),
'--origin','https://localhost:18443','--ca','/opt/rust-discovery/devstate/api-pki/ca.pem',
'--dev-login-file',auth.name],check=True)
def main():
import inspect
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--artifacts',type=Path,required=True)
parser.add_argument('--build-receipt',type=Path,required=True)
parser.add_argument('--sequence',type=int,required=True)
parser.add_argument('--version',required=True)
parser.add_argument('--gateway',default='https://discovery.ease-technologies.de')
parser.add_argument('--tenant',default='11111111-1111-4111-8111-111111111111')
parser.add_argument('--prepare-only',action='store_true')
args=parser.parse_args()
platform, _ = agent_release.binaries(args.artifacts,args.build_receipt)
files=[*(args.artifacts/name for name in agent_release.FILES[platform]),args.build_receipt]
tool=Path(agent_release.__file__).resolve()
if args.build_receipt.name in agent_release.FILES[platform]:
raise ValueError('build receipt and binary names must differ')
params={'files':{f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in files},'tool':hashlib.sha256(tool.read_bytes()).hexdigest(),
'receipt':args.build_receipt.name,'sequence':args.sequence,'version':args.version,'tenant':args.tenant,
'gateway':args.gateway,'prepare_only':args.prepare_only,'label':{agent_release.LINUX:'linux',
agent_release.WINDOWS:'windows',agent_release.WINDOWS_GNU:'windows-gnu'}[platform]}
subprocess.run([sys.executable,str(ROOT/'tools/dev_stage.py'),'server',*map(str,files),str(tool)],check=True)
command=inspect.getsource(on_server)+'\non_server('+repr(params)+')\n'
subprocess.run([*ssh_prefix('server'),shlex.join(['python3','-I','-'])],input=command,text=True,check=True)
if __name__=='__main__':
main()
+1 -1
View File
@@ -25,7 +25,7 @@ export function releaseEnvelope(value: unknown): ReleaseView {
if (!bytes.length || bytes.length > 16384 || signature.length !== 64) throw new Error('Agentupdate: Manifest-/Signaturlimit');
const m = record(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)));
exact(m, ['schema_version', 'release_id', 'release_sequence', 'version', 'platform', 'published_at', 'expires_at', 'protocol_major', 'state_schema', 'minimum_updater_version', 'artifacts']);
if (m.schema_version !== 1 || !['x86_64-unknown-linux-gnu', 'x86_64-pc-windows-msvc'].includes(String(m.platform)) || typeof m.version !== 'string' || !/^[A-Za-z0-9.+_-]{1,64}$/.test(m.version)
if (m.schema_version !== 1 || !['x86_64-unknown-linux-gnu', 'x86_64-pc-windows-msvc', 'x86_64-pc-windows-gnu'].includes(String(m.platform)) || typeof m.version !== 'string' || !/^[A-Za-z0-9.+_-]{1,64}$/.test(m.version)
|| !Array.isArray(m.artifacts) || m.artifacts.length !== 2) throw new Error('Agentupdate: festes x64-Codepaar erforderlich');
const artifacts = m.artifacts.map((value, index) => { const a = record(value); exact(a, ['role', 'artifact_id', 'sha256', 'bytes']); if (a.role !== ['agent', 'helper'][index]) throw new Error('Agentupdate: Agent-/Helperreihenfolge'); return { role: a.role, artifact_id: uuid(a.artifact_id), sha256: digest(a.sha256), bytes: integer(a.bytes, 1, 268435456) }; });
if (artifacts[0]!.artifact_id === artifacts[1]!.artifact_id) throw new Error('Agentupdate: doppelte Artefakt-ID');
+24 -3
View File
@@ -176,15 +176,18 @@ function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session
function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [cursor, setCursor] = useState<string | null>(null), [revision, setRevision] = useState(0), [source, setSource] = useState('{}'), [busy, setBusy] = useState(false), [error, setError] = useState<string | null>(null), [receipts, setReceipts] = useState<unknown[]>([]);
const [enrollment, setEnrollment] = useState<{ token: string; expires: string; origin: string | null } | null>(null);
const [enrollmentError, setEnrollmentError] = useState<string | null>(null);
const [issuing, setIssuing] = useState(false);
const list = useResource(async signal => {
const result = page(await request(tenantPath(tenantId, `/agent-releases${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal }));
const items: RecordValue[] = [];
for (const item of result.items) { const release = await verifyReleaseMetadata(item.release_envelope, item.manifest_sha256); if (item.release_id !== release.manifest.release_id) throw new Error('Release-ID widerspricht originalem Manifest'); items.push({ release_id: item.release_id, manifest_sha256: item.manifest_sha256, manifest: release.manifest, signature_and_time_valid: item.signature_and_time_valid === true }); }
return { ...result, items };
}, [tenantId, cursor, revision]);
return <section><h2>Signierter Agent-Releasekatalog</h2><p>Feste Release-ID für update_agent verwenden. Die Planung löst Vorgänger und Peerpinübergang aus frischen gespeicherten Gerätebeobachtungen auf. Ein Katalogeintrag oder passiver Versionscheck erteilt keine Ausführungserlaubnis; fehlende Qualifikation bleibt gesperrt.</p><ErrorBox error={list.error}/>
return <section><h2>Signierter Agent-Releasekatalog</h2><p>Installierte Clients können hier veröffentlichte Versionen beim nächsten regulären Abruf beziehen. Jedes signierte Manifest bindet eine Plattform sowie die genauen Agent- und Helperdateien.</p><ErrorBox error={list.error}/>
{list.data && <><PageStatus data={list.data}/><JsonView value={list.data.items} label="Feste Agent-/Helper-Releases und Manifesthashes"/><button disabled={!cursor} onClick={() => setCursor(null)}>Erste Releaseseite</button><button disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste Releaseseite</button></>}
<details><summary>Signiertes festes Release mit Agent und Helper veröffentlichen</summary><p>Nur Katalogverwaltung mit catalog:write. Kein Gerätejob und keine Freigabe zur Installation. Dateien werden gegen die festen signierten Längen/Hashes geprüft; erst beide vollständigen Importe erlauben die Releaseveröffentlichung. Bei Fehler keine automatische Wiederholung; vorhandene Teilimportbelege bleiben sichtbar.</p>
<details><summary>Signiertes festes Release mit Agent und Helper veröffentlichen</summary><p>Der Server prüft Signatur, Größe und SHA-256 beider Dateien. Erst nach dem vollständigen Upload wird die neue Version für Geräte sichtbar.</p>
<form onSubmit={async event => { event.preventDefault(); setBusy(true); setError(null); setReceipts([]); const form = new FormData(event.currentTarget); try {
if (!allowed(auth, 'catalog:write')) throw new Error('catalog:write unbekannt/nicht erteilt');
const release = releaseEnvelope(parseStrictJson(source)), artifacts = release.manifest.artifacts as RecordValue[];
@@ -198,9 +201,27 @@ function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Sessi
} catch (error) { setError(errorText(error)); } finally { setBusy(false); } }}>
<label>Vollständiger signierter Release-Envelope JSON<textarea rows={8} value={source} onChange={e => setSource(e.target.value)} spellCheck={false}/></label>
<label>Exakte Agentdatei<input type="file" name="agent_file" required/></label><label>Exakte Helperdatei<input type="file" name="helper_file" required/></label>
<button disabled={busy || !allowed(auth, 'catalog:write')}>Signiertes Codepaar im Katalog veröffentlichen · keine Installation</button><ErrorBox error={error}/>{receipts.length > 0 && <JsonView value={receipts} label="Tatsächliche Teilimport- und Veröffentlichungsbelege"/>}
<button disabled={busy || !allowed(auth, 'catalog:write')}>Release für Clients veröffentlichen</button><ErrorBox error={error}/>{receipts.length > 0 && <JsonView value={receipts} label="Tatsächliche Teilimport- und Veröffentlichungsbelege"/>}
</form>
</details>
<details onToggle={event => { if (!event.currentTarget.open) setEnrollment(null); }}>
<summary>Neues Gerät aufnehmen</summary>
<p>Das HTTPS-Installationsskript fragt auf dem Gerät nach dem Einmalcode. Er gilt für den ausgewählten Mandanten und läuft nach 15 Minuten ab.</p>
<button disabled={issuing || !allowed(auth, 'devices:enroll')} onClick={async () => {
setIssuing(true); setEnrollment(null); setEnrollmentError(null);
try {
const result = record(await request(tenantPath(tenantId, '/enrollment-tokens'), { body: {}, csrf: auth.csrf_token }));
if (typeof result.token !== 'string' || !/^[a-f0-9]{64}$/.test(result.token) || typeof result.expires_at !== 'string') throw new Error('Ungültiger Einmalcode');
setEnrollment({ token: result.token, expires: result.expires_at, origin: typeof result.bootstrap_origin === 'string' ? new URL(result.bootstrap_origin).origin : null });
} catch (error) { setEnrollmentError(errorText(error)); } finally { setIssuing(false); }
}}>Einmalcode erstellen</button>
<ErrorBox error={enrollmentError}/>
{enrollment && <><label>Einmalcode gültig bis {new Date(enrollment.expires).toLocaleString()}<input readOnly value={enrollment.token}/></label><button onClick={() => setEnrollment(null)}>Code ausblenden</button>
{enrollment.origin && <><p>Linux, mit einem Administratorkonto ausführen</p><pre>{`curl --fail --show-error --silent '${enrollment.origin}/install/linux.sh' -o linux.sh && sudo sh linux.sh '${enrollment.origin}'`}</pre>
<p>Windows, in einer administrativen Windows PowerShell ausführen</p><pre>{`Invoke-WebRequest -UseBasicParsing '${enrollment.origin}/install/windows.ps1' -OutFile .\\windows.ps1
.\\windows.ps1 -BootstrapBase '${enrollment.origin}'`}</pre></>}
</>}
</details>
</section>;
}