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
+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() {