Qualify tenant-scoped bootstrap rotation and fresh Windows scripting

This commit is contained in:
2026-11-17 16:19:08 +01:00
parent 81fcd9c8f8
commit fbd24b6d75
26 changed files with 877 additions and 118 deletions
@@ -7,6 +7,10 @@ fn main() -> anyhow::Result<()> {
Some(flag) if flag == "--release-service" && args.next().is_none() => {
rmm_agent_windows::release_service::dispatch()
}
Some(flag) if flag == "--release-capabilities" && args.next().is_none() => {
println!("release-job-lock/1");
Ok(())
}
Some(flag) if flag == "--verify-bootstrap" => {
let release = rmm_updater::verify_bootstrap_files(
rmm_agent_windows::release_platform::VERIFY,
+8 -4
View File
@@ -1432,7 +1432,8 @@ impl Server {
/// Blocking SDK call; run on the agent's bounded blocking worker, never heartbeat reactor.
pub fn execution_timeout(action: &rmm_domain::jobs::Action, seconds: u32) -> Result<Duration> {
ensure!(
(1..=action.windows_system_runtime_limit(120, Some(rmm_domain::jobs::WINDOWS_UPDATE_MAX_SECONDS))).contains(&seconds),
(1..=action.windows_system_runtime_limit(120, Some(rmm_domain::jobs::WINDOWS_UPDATE_MAX_SECONDS)))
.contains(&seconds),
"SYSTEM_EXECUTION_TIMEOUT_BOUND"
);
Ok(Duration::from_secs(u64::from(seconds) + 5))
@@ -1455,9 +1456,12 @@ fn exchange_fixed(pin: &Pin, call: &Call, timeout: Duration, time_only: bool) ->
anyhow::bail!("HELPER_CALL_TIMEOUT_BOUND");
};
let job = pin.binding.job(&request.job_bytes)?;
ensure!(job.execution_identity == "system" && job.action.is_windows_update_template()
&& execution_timeout(&job.action, job.max_runtime_seconds)? == timeout,
"HELPER_CALL_TIMEOUT_BOUND");
ensure!(
job.execution_identity == "system"
&& job.action.is_windows_update_template()
&& execution_timeout(&job.action, job.max_runtime_seconds)? == timeout,
"HELPER_CALL_TIMEOUT_BOUND"
);
} else {
ensure!(timeout >= Duration::from_secs(1), "HELPER_CALL_TIMEOUT_BOUND");
}
+4 -2
View File
@@ -116,8 +116,9 @@ impl Settings {
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
&& job.max_runtime_seconds <= job.action.windows_system_runtime_limit(self.max_runtime_seconds, self.windows_update_max_runtime_seconds)
&& self.allowed_script_profiles.as_deref()
&& (self.allowed_script_profiles.as_deref()
== Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1])
|| (self.windows_update_max_runtime_seconds.is_some() && job.action.is_windows_update_template()))
}
fn permits_reboot(&self, job: &JobPayload) -> bool {
self.schema_version == 4
@@ -146,7 +147,8 @@ impl Settings {
|v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]
)
&& (self.schema_version == 4 || !self.allow_reboot)
&& rmm_domain::jobs::valid_windows_update_limit(self.windows_update_max_runtime_seconds, self.allowed_script_profiles.as_deref())
&& (self.schema_version >= 3 || self.windows_update_max_runtime_seconds.is_none())
&& rmm_domain::jobs::valid_windows_update_limit(self.windows_update_max_runtime_seconds)
&& (1..=120).contains(&self.max_runtime_seconds)
&& self.allowed_services.len() <= 16,
"SYSTEM_POLICY_PROFILE"
+33 -3
View File
@@ -52,6 +52,8 @@ struct Endpoint {
ca_file: PathBuf,
#[serde(default)]
enable_jobs: bool,
#[serde(default)]
localservice_time_policy: Option<PathBuf>,
}
#[derive(Deserialize)]
struct Health {
@@ -349,16 +351,36 @@ async fn stage(device: &Device, release: &Published, active: &Installed) -> Resu
result
}
fn exclusive_job_gate() -> Result<Option<fs::File>> {
use std::os::windows::fs::OpenOptionsExt;
let path = data("release-job.lock");
job_binding::check_admin_readonly(&path)?;
match fs::OpenOptions::new().read(true).share_mode(0).open(path) {
Ok(file) => Ok(Some(file)),
Err(error) if error.raw_os_error() == Some(32) => Ok(None),
Err(error) => Err(error.into()),
}
}
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.
// Additional SYSTEM helper pins need their separately coordinated handoff.
ensure!(
!config.enable_jobs,
!config.enable_jobs
|| config.localservice_time_policy.as_ref() == Some(&data("job-time.json")),
"job-enabled pair requires coordinated helper handoff"
);
if data(INTENT).try_exists()? {
let _job_gate = if config.enable_jobs {
let Some(file) = exclusive_job_gate()? else {
return Ok(());
};
Some(file)
} else {
None
};
let t: Transition = read_record(INTENT)?;
if active.release_id == t.new.release_id {
fs::remove_file(data(INTENT))?;
@@ -414,6 +436,14 @@ async fn cycle() -> Result<()> {
"current agent version not confirmed"
);
let new = stage(&device, &release, &active).await?;
let _job_gate = if config.enable_jobs {
let Some(file) = exclusive_job_gate()? else {
return Ok(());
};
Some(file)
} else {
None
};
let t = Transition { old: active, new };
write_record(INTENT, &t)?;
let start = chrono::Utc::now();
@@ -9,7 +9,10 @@ $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 ($config.PSObject.Properties['enable_jobs'] -and $config.enable_jobs) {
if (-not $config.PSObject.Properties['localservice_time_policy'] -or
$config.localservice_time_policy -cne (Join-Path (Split-Path $configPath) 'job-time.json')) { throw 'Job-enabled pair requires a coordinated helper 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) {
+63 -5
View File
@@ -36,6 +36,8 @@ struct Config {
transport: String,
#[serde(default)]
job_binding_file: Option<PathBuf>,
#[serde(default)]
localservice_time_policy: Option<PathBuf>,
// Explicit protected opt-in only; this flag never qualifies a clock or pins.
#[serde(default)]
enable_jobs: bool,
@@ -88,13 +90,20 @@ fn rotation_file_id(path: &Path) -> Result<[u32; 3]> {
impl Config {
fn profile_enabled(&self, profile: rmm_domain::jobs::WindowsExecutionProfile) -> bool {
self.enable_jobs
&& self.job_binding_file.is_some()
&& (self.job_binding_file.is_some() || self.localservice_time_policy.is_some())
&& cfg!(feature = "system-helper")
&& self.windows_execution_profile == Some(profile)
}
fn read(path: &Path) -> Result<Self> {
let raw = protected_read(path, 32768)?;
let config: Self = serde_json::from_slice(&raw)?;
if let Some(policy) = &config.localservice_time_policy {
let parent = path.parent().context("CONFIG_PARENT")?;
ensure!(policy == &parent.join("job-time.json")
&& config.job_binding_file.is_none()
&& config.profile_enabled(rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned)
&& !config.windows_echo_probe_only, "INVALID_ENROLLED_LOCALSERVICE_CONFIGURATION");
}
if config.windows_echo_probe_only {
ensure!(
config.profile_enabled(
@@ -593,6 +602,7 @@ impl HelperControl {
struct Agent {
config: Config,
reported_version: String,
release_job_guard: Option<fs::File>,
identity: EnrollmentResponse,
ca: Vec<u8>,
journal: Journal,
@@ -802,12 +812,14 @@ impl Agent {
&identity.certificate_pem,
&identity.private_key_pem,
)?;
let helper = rmm_agent_windows::helper_runtime::Client::discover(
let helper = if self.config.localservice_time_policy.is_some() {
None
} else { rmm_agent_windows::helper_runtime::Client::discover(
&self.identity.agent_id,
&self.identity.asset_id,
self.binding.as_ref(),
self.helper_lane.clone(),
)?;
)? };
let clock = self.clock.native.source();
let stop = Arc::new(AtomicBool::new(false));
let mut tasks = Vec::new();
@@ -828,6 +840,7 @@ impl Agent {
.chain(helper_receipt.iter())
.cloned()
.collect();
let installed_localservice = self.config.localservice_time_policy.is_some();
tasks.push(tokio::spawn(async move {
let mut own_report = RefreshReport::default();
while !own_stop.load(Ordering::SeqCst) {
@@ -857,7 +870,12 @@ impl Agent {
let _ = own_clock.close_generation(generation);
}
own_report.record(&own_state, "agent", &result);
tokio::time::sleep(mode.interval(result.is_ok())).await;
let interval = if installed_localservice && result.is_ok() {
Duration::from_secs(5)
} else {
mode.interval(result.is_ok())
};
tokio::time::sleep(interval).await;
}
let _ = own_clock.close_generation(generation);
}));
@@ -1359,7 +1377,32 @@ impl Agent {
}));
Ok(false)
}
fn reserve_release_gate(&mut self) -> Result<bool> {
let Some(policy) = &self.config.localservice_time_policy else { return Ok(true) };
if self.release_job_guard.is_some() { return Ok(true) }
use std::os::windows::fs::OpenOptionsExt;
use windows_sys::Win32::Storage::FileSystem::FILE_SHARE_READ;
let path = policy.with_file_name("release-job.lock");
rmm_agent_windows::job_binding::check_admin_readonly(&path)?;
match fs::OpenOptions::new().read(true).share_mode(FILE_SHARE_READ).open(path) {
Ok(file) => { self.release_job_guard = Some(file); Ok(true) }
Err(error) if error.raw_os_error() == Some(32) => Ok(false),
Err(error) => Err(error.into()),
}
}
fn release_idle_gate(&mut self) -> Result<()> {
if self.release_job_guard.is_some() && self.running.is_none() && self.deferred_permit.is_none() {
let idle: bool = self.journal.connection().query_row(
"SELECT NOT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','awaiting_reboot'))",
[], |row| row.get(0))?;
if idle { self.release_job_guard.take(); }
}
Ok(())
}
fn supported_job(&self, job: &rmm_domain::jobs::JobPayload) -> bool {
if self.config.localservice_time_policy.is_some() && job.execution_identity != "agent_service" {
return false;
}
if self.config.windows_echo_probe_only
&& !self
.config
@@ -2577,7 +2620,7 @@ impl Agent {
let prefetched=self.prefetch_update(generation,&offer,&job).await?;
#[cfg(not(feature="system-helper"))]
let prefetched=true;
if prefetched {
if prefetched && self.reserve_release_gate()? {
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?;
@@ -2632,6 +2675,7 @@ impl Agent {
}
}
}
self.release_idle_gate()?;
if readiness_at.elapsed() >= Duration::from_secs(5) {
readiness_at = Instant::now();
if self
@@ -2832,6 +2876,10 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
journal.pin_identity(&identity.agent_id)?;
let boot = native::boot_id().await?;
let binding=config.job_binding_file.as_deref().map(readonly_binding).transpose()?;
#[cfg(feature = "system-helper")]
let binding = if let Some(policy) = &config.localservice_time_policy {
Some(rmm_agent_windows::signed_clock::enrolled_binding(policy, &identity)?)
} else { binding };
if let Some(binding)=&binding {
ensure!(binding.agent_id.to_string()==identity.agent_id && binding.asset_id.to_string()==identity.asset_id,"ENROLLMENT_JOB_BINDING_MISMATCH");
native::private_path(&config.state_directory.join("jobs"),true)?;
@@ -2845,6 +2893,11 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
for child in fs::read_dir(&config.state_directory)? { let child=child?;native::private_path(&child.path(),child.file_type()?.is_dir())?; }
let (ledger,ledger_file)=match &binding {Some(binding)=>{let (db,file)=open_ledger(&config.state_directory,binding)?;(Some(db),Some(file))},None=>(None,None)};
let clock=JobClock::new(config.enable_jobs);
#[cfg(feature = "system-helper")]
let clock = if let Some(policy) = &config.localservice_time_policy {
let binding = binding.clone().context("JOB_BINDING_REQUIRED")?;
JobClock { enabled: true, native: rmm_agent_windows::signed_clock::RuntimeClock::enrolled_local_service(binding,policy.clone()).for_generation(0) }
} else { clock };
let mut config=config;
if config.enable_jobs {
config.echo_scope=rmm_agent_windows::echo_probe::installed(journal.connection(),binding.as_ref().context("JOB_BINDING_REQUIRED")?)?;
@@ -2864,6 +2917,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
let mut agent = Agent {
config,
reported_version: installed_version()?,
release_job_guard: None,
identity,
ca,
journal,
@@ -2954,6 +3008,10 @@ pub fn main() -> Result<()> {
ensure!(args.len() == 2, "EVENT_LOG_WORKER_ARGUMENTS");
return rmm_agent_windows::event_log_job::worker(Path::new(&args[1]));
}
if args == ["--release-capabilities"] {
println!("enrolled-localservice/1");
return Ok(());
}
if args == ["--help"] {
println!(
"Development Windows service. --service --config ABSOLUTE_PATH. Jobs disabled by default; require qualified clock, provisioned signing binding, signed Sync and WebUI-authorized grant. No approval bypass."
+174 -6
View File
@@ -176,6 +176,7 @@ impl UpdaterConfiguration {
enum CaptureMode {
Physical { base_error_ns: u64 },
TrustedOsActiveGuest,
EnrolledLocalService,
}
fn digest(value: &str) -> bool {
value.len() == 64
@@ -476,7 +477,9 @@ fn bracket_sample(
// This is a software bracket in trusted nominal OS units, not a
// physical accuracy bound. Checked multiplication by100 is exact, so
// there is no conversion rounding remainder or invented base constant.
CaptureMode::TrustedOsActiveGuest => width.max(unbiased_width),
CaptureMode::TrustedOsActiveGuest | CaptureMode::EnrolledLocalService => {
width.max(unbiased_width)
}
};
ensure!(
capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS,
@@ -778,14 +781,58 @@ mod installed {
challenge: Challenge,
}
struct HeldEvidence {
received_ticks: Sample,
evidence: VerifiedEvidence,
epoch: u64,
}
/// Own-process role proof, protected held configuration, private challenge
/// and native timers. No constructor accepts agent-reported helper times.
enum ClockOwner {
Service(Box<PeerProof>),
EnrolledLocalService,
}
#[derive(serde::Deserialize)]
#[serde(deny_unknown_fields)]
struct LocalPolicy {
schema_version: u32,
key_generation: u64,
server_instance: Uuid,
public_keys_hex: BTreeMap<String, String>,
tenant_id: Uuid,
job_signing_public_key_hex: String,
}
pub fn enrolled_binding(
policy: &Path,
registration: &rmm_protocol::EnrollmentResponse,
) -> Result<rmm_agent_core::auth::Binding> {
crate::job_binding::check_admin_readonly(policy)?;
ensure!(
std::fs::metadata(policy)?.len() <= MAX_CONFIG_BYTES as u64,
"TIME_NATIVE_CONFIG_SIZE"
);
let p: LocalPolicy = serde_json::from_slice(&std::fs::read(policy)?)?;
ensure!(
p.schema_version == 1 && !p.tenant_id.is_nil() && digest(&p.job_signing_public_key_hex),
"INSTALLED_JOB_TRUST"
);
let binding = rmm_agent_core::auth::Binding {
tenant_id: p.tenant_id,
agent_id: Uuid::parse_str(&registration.agent_id)?,
asset_id: Uuid::parse_str(&registration.asset_id)?,
enrollment_generation: 1,
assignment_version: 1,
public_key_hex: p.job_signing_public_key_hex,
};
ensure!(
!binding.agent_id.is_nil() && !binding.asset_id.is_nil(),
"INSTALLED_DEVICE_IDENTITY"
);
Ok(binding)
}
pub struct SignedClock {
verifier: Verifier,
own_process: PeerProof,
owner: ClockOwner,
files: Vec<PinnedFile>,
config_sha256: String,
boot_id: Uuid,
@@ -891,7 +938,7 @@ mod installed {
files.push(config_file);
let mut value = Self {
verifier: Verifier::new(context, pins)?,
own_process,
owner: ClockOwner::Service(Box::new(own_process)),
files,
config_sha256: hash(&raw),
boot_id,
@@ -910,6 +957,88 @@ mod installed {
failure_fence.armed = false;
Ok(value)
}
/// An enrolled LocalService never supplies time evidence for a helper.
/// Its public broker pins and job binding are installed by the HTTPS
/// bootstrap; every usable reading still needs a current signed challenge.
async fn open_local_service(
generation: u64,
binding: &rmm_agent_core::auth::Binding,
policy_file: &Path,
) -> Result<Self> {
let mut failure_fence = ConstructorFailureFence { armed: true };
crate::native::require_local_service()?;
let readers = [crate::native::service_sid()?];
let parent = PinnedFile::open(
policy_file.parent().context("TIME_POLICY_PARENT")?,
true,
&readers,
&[],
false,
)?;
let mut config_file = PinnedFile::open(policy_file, false, &readers, &[], false)?;
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 p: LocalPolicy = serde_json::from_slice(&raw)?;
ensure!(
p.schema_version == 1
&& !p.public_keys_hex.is_empty()
&& p.public_keys_hex.len() <= 8,
"TIME_LOCAL_SERVICE_POLICY"
);
let keys = p
.public_keys_hex
.into_iter()
.map(|(id, key)| Ok((id, independent_time_key(&key, &binding.public_key_hex)?)))
.collect::<Result<BTreeMap<_, _>>>()?;
ensure!(
p.tenant_id == binding.tenant_id
&& p.job_signing_public_key_hex == binding.public_key_hex,
"TIME_POLICY_BINDING"
);
let pins = Pins::new(p.key_generation, p.server_instance, keys)?;
let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?;
let context = Context {
tenant_id: binding.tenant_id,
asset_id: binding.asset_id,
agent_id: binding.agent_id,
enrollment_generation: binding.enrollment_generation,
assignment_generation: binding.assignment_version,
connection_generation: generation,
windows_boot_id: boot_id,
verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4),
role: Role::Agent,
binding_schema: 1,
helper_image_sha256: None,
updater_image_sha256: None,
};
let hash = hash(&raw);
let mut clock = Self {
verifier: Verifier::new(context, pins)?,
owner: ClockOwner::EnrolledLocalService,
files: vec![parent, config_file],
config_sha256: hash.clone(),
boot_id,
connection_generation: generation,
capture_mode: CaptureMode::EnrolledLocalService,
pending: None,
latest: None,
own_updater_configuration: None,
};
clock.recheck()?;
{
let mut state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
state.accept_configuration(p.key_generation, &hash)?;
state.accept_connection(generation)?;
}
observed(boot_id, clock.capture_mode)?;
failure_fence.armed = false;
Ok(clock)
}
/// 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> {
@@ -1011,7 +1140,7 @@ mod installed {
let capture_mode = CaptureMode::TrustedOsActiveGuest;
let mut value = Self {
verifier: Verifier::new(context, pins)?,
own_process,
owner: ClockOwner::Service(Box::new(own_process)),
files: vec![root, policy_file, config_file],
config_sha256: hash(&raw),
boot_id,
@@ -1032,7 +1161,10 @@ mod installed {
}
fn recheck(&mut self) -> Result<()> {
let result = (|| {
self.own_process.check()?;
match &mut self.owner {
ClockOwner::Service(process) => process.check()?,
ClockOwner::EnrolledLocalService => crate::native::require_local_service()?,
}
if let Some((pin, expected)) = &self.own_updater_configuration {
ensure!(
crate::update_native::services::updater_configuration_sha256(pin)?
@@ -1141,6 +1273,7 @@ mod installed {
state.active = None;
self.latest = Some(HeldEvidence {
evidence,
received_ticks: received,
epoch: pending.epoch,
});
let comparison = Comparison {
@@ -1179,6 +1312,25 @@ mod installed {
self.recheck()?;
let (sample, current_epoch) = observed(self.boot_id, self.capture_mode)?;
ensure!(epoch == current_epoch, "TIME_NATIVE_EVIDENCE_INVALIDATED");
if self.capture_mode == CaptureMode::EnrolledLocalService {
let previous = self
.latest
.as_ref()
.context("TIME_NATIVE_NO_EVIDENCE")?
.received_ticks;
let wall = sample
.interrupt_ns
.checked_sub(previous.interrupt_ns)
.context("TIME_INTERRUPT_RESET")?;
let awake = sample
.unbiased_ns
.checked_sub(previous.unbiased_ns)
.context("TIME_AWAKE_RESET")?;
ensure!(
wall <= 15 * SECOND_NS && wall.abs_diff(awake) <= 10_000_000,
"TIME_LOCAL_SERVICE_STALE_OR_SUSPENDED"
);
}
let state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
@@ -1233,6 +1385,7 @@ mod installed {
#[derive(Clone)]
pub struct RuntimeClock {
role: Role,
local_policy: Option<(rmm_agent_core::auth::Binding, std::path::PathBuf)>,
state: Arc<Mutex<Option<(u64, SignedClock)>>>,
}
#[derive(Clone)]
@@ -1244,9 +1397,18 @@ mod installed {
pub fn new(role: Role) -> Self {
Self {
role,
local_policy: None,
state: Arc::new(Mutex::new(None)),
}
}
pub fn enrolled_local_service(
binding: rmm_agent_core::auth::Binding,
policy: std::path::PathBuf,
) -> Self {
let mut value = Self::new(Role::Agent);
value.local_policy = Some((binding, policy));
value
}
pub fn for_generation(&self, generation: u64) -> BoundClock {
BoundClock {
source: self.clone(),
@@ -1261,7 +1423,12 @@ mod installed {
pub async fn open_connection(&self, generation: u64) -> Result<()> {
ensure!(generation > 0, "TIME_RUNTIME_GENERATION");
self.close()?;
let clock = SignedClock::open(self.role, generation).await?;
let clock = match &self.local_policy {
Some((binding, policy)) => {
SignedClock::open_local_service(generation, binding, policy).await?
}
None => SignedClock::open(self.role, generation).await?,
};
let mut state = self
.state
.lock()
@@ -1378,6 +1545,7 @@ mod installed {
#[cfg(all(windows, feature = "system-helper"))]
pub use installed::{
BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClock, UPDATER_CONFIG_PATH,
enrolled_binding,
};
#[cfg(test)]
@@ -80,19 +80,13 @@ pub fn qualified(
for action in q.actions {
match action.as_str() {
"run_script" => {
ensure!(
settings.schema_version >= 3
&& settings.allowed_script_profiles.as_deref()
== Some(&[
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1
])
&& crate::actions::powershell().is_ok(),
"system script qualification policy"
);
if settings.windows_update_max_runtime_seconds.is_some() {
caps.push(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY.to_owned());
}
caps.extend(["system:run_script", "script.full_maintenance/1"].map(str::to_string));
let general = settings.allowed_script_profiles.as_deref() ==
Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]);
let windows_update = settings.windows_update_max_runtime_seconds.is_some();
ensure!(settings.schema_version >= 3 && (general || windows_update), "system script qualification policy");
caps.push("system:run_script".into());
if general { caps.push(rmm_domain::jobs::FULL_MAINTENANCE_CAPABILITY.to_owned()); }
if windows_update { caps.push(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY.to_owned()); }
}
"set_service_state" => {
ensure!(
+12 -2
View File
@@ -121,7 +121,12 @@ pub(crate) fn execute(
.as_ref()
.is_none_or(|s| output.stdout == s.as_bytes());
let interrupted = output.interrupted || began.elapsed() >= timeout || observe(false).is_err();
let success = !interrupted && output.exit_code == Some(0) && expected && !output.truncated;
let windows_update = job.action.is_windows_update_template();
let reboot = if windows_update && !interrupted && !output.truncated {
rmm_domain::jobs::windows_update_reboot_report(&output.stdout)
} else { None };
let success = !interrupted && output.exit_code == Some(0) && expected && !output.truncated
&& (!windows_update || reboot.is_some());
let mut evidence = serde_json::json!({"postconditions_passed":success,"interpreter":"powershell",
"script_sha256":hash(script_utf8.as_bytes()),"privileged_script_profile":"full_maintenance_v1",
"execution_sid":"S-1-5-18","output_encoding":"raw_native_bytes","comparison":"exact_utf8_bytes",
@@ -133,6 +138,9 @@ pub(crate) fn execute(
evidence["execution_policy_requested"] = "RemoteSigned".into();
evidence["execution_policy_scope"] = "process".into();
}
if windows_update {
evidence["windows_update_reboot_required"] = serde_json::json!(reboot);
}
Ok(Outcome {
state: if interrupted {
"unknown"
@@ -146,13 +154,15 @@ pub(crate) fn execute(
stderr: output.stderr,
exit_code: output.exit_code,
output_truncated: output.truncated,
reboot_required: false,
reboot_required: reboot.unwrap_or(false),
error_code: if success {
""
} else if interrupted {
"SYSTEM_SCRIPT_INTERRUPTED_EFFECT_UNKNOWN"
} else if output.truncated {
"OUTPUT_LIMIT_REACHED"
} else if windows_update && output.exit_code == Some(0) && reboot.is_none() {
"WINDOWS_UPDATE_SUMMARY_MISSING"
} else if !expected {
"STDOUT_POSTCONDITION_FAILED"
} else {
@@ -215,7 +215,8 @@ pub fn render(input: Inputs<'_>) -> Result<CodePairTransition> {
ensure!(
matches!(settings.schema_version, 1..=4)
&& (settings.schema_version == 4 || !settings.allow_reboot)
&& rmm_domain::jobs::valid_windows_update_limit(settings.windows_update_max_runtime_seconds, settings.allowed_script_profiles.as_deref())
&& (settings.schema_version >= 3 || settings.windows_update_max_runtime_seconds.is_none())
&& rmm_domain::jobs::valid_windows_update_limit(settings.windows_update_max_runtime_seconds)
&& (1..=120).contains(&settings.max_runtime_seconds)
&& settings.allowed_services.len() <= 16
&& (settings.schema_version >= 2 || settings.allowed_msi_recipe_sha256.is_none())
+4 -10
View File
@@ -60,14 +60,8 @@ pub const WINDOWS_UPDATE_SCRIPT_SHA256: &str =
"0fa5f513a06b6cf902a3f9ac1989987642c181eedd6c305b3912771bd10f2ebf";
pub const WINDOWS_UPDATE_MAX_SECONDS: u32 = 3600;
pub const WINDOWS_UPDATE_LONG_CAPABILITY: &str = "script.windows_update.long/1";
pub fn valid_windows_update_limit(
limit: Option<u32>,
profiles: Option<&[PrivilegedScriptProfile]>,
) -> bool {
limit.is_none_or(|seconds| {
(121..=WINDOWS_UPDATE_MAX_SECONDS).contains(&seconds)
&& profiles == Some(&[PrivilegedScriptProfile::FullMaintenanceV1][..])
})
pub fn valid_windows_update_limit(limit: Option<u32>) -> bool {
limit.is_none_or(|seconds| (121..=WINDOWS_UPDATE_MAX_SECONDS).contains(&seconds))
}
/// Only the built-in template's final ASCII JSON object describes the host's
/// restart state. Earlier lines can include per-update results and native titles.
@@ -489,7 +483,7 @@ impl Action {
let has = |cap: &str| capabilities.iter().any(|c| c == cap);
if !has(self.name())
|| (self.full_maintenance()
&& !(has(FULL_MAINTENANCE_CAPABILITY)
&& !((has(FULL_MAINTENANCE_CAPABILITY) || (self.is_windows_update_template() && has(WINDOWS_UPDATE_LONG_CAPABILITY)))
&& has("rmm.sync.v1")
&& has(&format!("{}:run_script", identity))
&& has(if identity == "root" {
@@ -843,7 +837,7 @@ mod tests {
None
);
assert_eq!(windows_update_reboot_report(b"partial"), None);
assert!(!valid_windows_update_limit(Some(3600), None));
assert!(!valid_windows_update_limit(Some(3601)));
}
#[test]
fn windows_system_scm_is_explicit_and_preserves_linux_service_bytes() {
+1 -1
View File
@@ -238,7 +238,7 @@ fn verify_envelope_with_keyring(
keyring_generation: config.generation,
protocol_major: 1,
state_schema: 1,
updater_version: 1,
updater_version: if binding.is_none() && decoded.manifest.platform == Platform::WindowsGnuX64 { 2 } else { 1 },
minimum_release_sequence: 0,
active_release: None,
};
+21 -1
View File
@@ -123,7 +123,7 @@ try {
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
Get-Download ('/agent/v1/bootstrap/updater' + $query + '&sha256=' + $meta.updater.sha256) $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++) {
@@ -145,6 +145,25 @@ try {
$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'}
$localJobs = $verified.minimum_updater_version -ge 2
if ($localJobs) {
$features = & $agentPath --release-capabilities
if ($LASTEXITCODE -ne 0 -or $features -cne 'enrolled-localservice/1') { throw 'Signed agent lacks its required LocalService profile.' }
$features = & $updater --release-capabilities
if ($LASTEXITCODE -ne 0 -or $features -cne 'release-job-lock/1') { throw 'Stable updater lacks coordinated job draining.' }
$trust = $meta.windows_time_trust
if (-not $trust -or $meta.job_signing_public_key_hex -cnotmatch '^[0-9a-f]{64}$' -or
$trust.key_generation -lt 1 -or @($trust.public_keys_hex.PSObject.Properties).Count -notin (1..8)) { throw 'Missing enrolled Windows job trust.' }
foreach ($key in $trust.public_keys_hex.PSObject.Properties) {
if ($key.Value -cnotmatch '^[0-9a-f]{64}$' -or $key.Value -ceq $meta.job_signing_public_key_hex) { throw 'Invalid independent time signing key.' }
}
$policy = [ordered]@{schema_version=1; tenant_id=$tenant; job_signing_public_key_hex=$meta.job_signing_public_key_hex; key_generation=$trust.key_generation; server_instance=(Get-Id $trust.server_instance); public_keys_hex=$trust.public_keys_hex}
Set-Text (Join-Path $dataStage 'job-time.json') ($policy | ConvertTo-Json -Depth 8 -Compress)
Set-Text (Join-Path $dataStage 'release-job.lock') ''
$config['enable_jobs'] = $true
$config['localservice_time_policy'] = Join-Path $data 'job-time.json'
$config['windows_execution_profile'] = 'powershell_51_remote_signed'
}
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)
@@ -165,6 +184,7 @@ try {
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'))
if ($localJobs) { [void][IO.Directory]::CreateDirectory((Join-Path $state 'jobs'), (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)) {
+10 -3
View File
@@ -117,7 +117,10 @@ def device_get(route, size=None, digest=None):
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()
busy, = conn.execute(
"SELECT EXISTS(SELECT 1 FROM job_attempts "
"WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))"
).fetchone()
print('busy' if busy else 'idle')
@@ -248,7 +251,7 @@ def enable():
else:
save(path, data.encode())
service('daemon-reload')
service('enable', '--now', SERVICE, TIMER)
service('enable', '--now', SERVICE)
def enrollment_token(path):
@@ -279,6 +282,7 @@ def install(base, token_file):
save_token(ROOT, token, pwd.getpwnam('rmm-discovery').pw_gid)
enable()
require(healthy(read(ROOT / 'current/manifest.json')['version'], 0), 'awaiting authenticated device heartbeat')
service('enable', '--now', TIMER)
(ROOT / 'first.token').unlink(missing_ok=True)
return
require(not STATE.exists() and not any((UNIT_DIR/name).exists() for name in units()),
@@ -302,7 +306,7 @@ def install(base, token_file):
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'])
remote((base, token), '/agent/v1/bootstrap/updater?platform=' + PLATFORM + '&sha256=' + doc['updater']['sha256'], updater, doc['updater'])
updater.chmod(0o755)
releases = staging / 'releases'
releases.mkdir()
@@ -318,6 +322,9 @@ def install(base, token_file):
os.rename(staging, ROOT)
enable()
require(healthy(manifest['version'], 0), 'installed, awaiting authenticated device heartbeat')
# OnBootSec may already be in the past on a running machine. The first
# timer check can run immediately once the device has reported its platform.
service('enable', '--now', TIMER)
(ROOT / 'first.token').unlink(missing_ok=True)
+32 -5
View File
@@ -9,14 +9,41 @@ struct Config {
updater_sha256: String,
updater_bytes: u64,
}
fn config(platform: Platform) -> Result<Config, Error> {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Pin { sha256: String, bytes: u64 }
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Previous { pin: Pin, expires_at: i64 }
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TenantPins { current: Pin, previous: Vec<Previous> }
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct UpdaterQuery { platform: Platform, sha256: Option<String> }
fn config(platform: Platform, tenant: Uuid, wanted: Option<&str>) -> 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 path = FsPath::new(&path);
let mut config: Config = serde_json::from_slice(&protected_file(path, 8192)?)?;
let scoped = path.with_extension(format!("{tenant}.json"));
if scoped.try_exists().map_err(|_| fail("BOOTSTRAP_CONFIGURATION_INVALID"))? {
let pins: TenantPins = serde_json::from_slice(&protected_file(&scoped, 32768)?)?;
let selected = match wanted {
Some(digest) if pins.current.sha256 != digest => pins.previous.into_iter()
.find(|p| p.pin.sha256 == digest && p.expires_at > chrono::Utc::now().timestamp())
.map(|p| p.pin).ok_or_else(missing)?,
_ => pins.current,
};
config.updater_sha256 = selected.sha256;
config.updater_bytes = selected.bytes;
}
if wanted.is_some_and(|digest| digest != config.updater_sha256) { return Err(missing()); }
let url = url::Url::parse(&config.gateway_origin).map_err(|_| invalid())?;
if url.scheme() != "https"
|| url.domain().is_none()
@@ -143,7 +170,7 @@ pub(super) async fn current(
Query(q): Query<Current>,
) -> Result<Response, Error> {
let t = token_tenant(&s, &headers).await?;
let c = config(q.platform)?;
let c = config(q.platform, t, None)?;
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)?;
@@ -187,9 +214,9 @@ pub(super) async fn artifact(
pub(super) async fn updater(
State(s): State<crate::State>,
headers: HeaderMap,
Query(q): Query<Current>,
Query(q): Query<UpdaterQuery>,
) -> Result<Response, Error> {
let tenant = token_tenant(&s, &headers).await?;
let c = config(q.platform)?;
let c = config(q.platform, tenant, q.sha256.as_deref())?;
verified_binary(tenant, c.updater_sha256, c.updater_bytes).await
}
+3 -6
View File
@@ -124,10 +124,7 @@ impl SystemScope {
.allowed_script_profiles
.as_deref()
.is_none_or(|v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1])
&& rmm_domain::jobs::valid_windows_update_limit(
self.windows_update_max_runtime_seconds,
self.allowed_script_profiles.as_deref(),
)
&& rmm_domain::jobs::valid_windows_update_limit(self.windows_update_max_runtime_seconds)
&& (1..=120).contains(&self.max_runtime_seconds)
}
fn permits(
@@ -184,11 +181,11 @@ impl SystemScope {
Action::RunScript { .. } => {
allow_scripts
&& job.action.full_maintenance()
&& self.allowed_script_profiles.as_ref().is_some_and(|v| {
&& (self.allowed_script_profiles.as_ref().is_some_and(|v| {
v.contains(
&rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
)
})
}) || (self.windows_update_max_runtime_seconds.is_some() && job.action.is_windows_update_template()))
&& job.action.validate()
&& job
.action
+3 -1
View File
@@ -221,6 +221,7 @@ fn current_keyring(file: &UpdateKeyringFile) -> Result<UpdateKeyring> {
match key.platform {
Platform::LinuxX64 => ReleasePlatform::LinuxX64,
Platform::WindowsX64 => ReleasePlatform::WindowsX64,
Platform::WindowsGnuX64 => ReleasePlatform::WindowsGnuX64,
},
key.first_sequence,
key.last_sequence,
@@ -309,6 +310,7 @@ fn verify_record_release(
let platform = match record.platform {
Platform::LinuxX64 => ReleasePlatform::LinuxX64,
Platform::WindowsX64 => ReleasePlatform::WindowsX64,
Platform::WindowsGnuX64 => ReleasePlatform::WindowsGnuX64,
};
let envelope: &ReleaseEnvelope = &record.release_envelope;
verify_release(
@@ -402,7 +404,7 @@ fn verify_update(
job.execution_identity
== match record.platform {
Platform::LinuxX64 => "root",
Platform::WindowsX64 => "system",
Platform::WindowsX64 | Platform::WindowsGnuX64 => "system",
}
&& update.release_envelope == record.release_envelope
&& agent_update::handoff_matches_job(&header, &job)
+2 -1
View File
@@ -44,7 +44,8 @@ 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..])?;
let release =
rmm_updater::verify_bootstrap_files(rmm_updater::Platform::LinuxX64, &args[1..])?;
println!("{}", serde_json::to_string(release.manifest())?);
return Ok(());
}
+53 -18
View File
@@ -1,8 +1,16 @@
//! Local verification for the separately distributed stable bootstrap updater.
use crate::{ArtifactRole, Platform, SignedRelease, TrustedContext, TrustedUpdateKey, UpdateKeyring, VerifiedRelease};
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}};
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();
@@ -19,26 +27,53 @@ pub fn verify_bootstrap_files(platform: Platform, args: &[OsString]) -> Result<V
};
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 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 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,
platform,
now_utc_seconds: SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
keyring_generation: config.generation,
protocol_major: 1,
state_schema: 1,
updater_version: if platform == Platform::WindowsGnuX64 { 2 } else { 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)?;
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)
+28 -1
View File
@@ -1,7 +1,9 @@
"""Retry coverage for the HTTPS Linux bootstrap without installing on the test host."""
from contextlib import ExitStack
from contextlib import ExitStack, redirect_stdout
from importlib.util import module_from_spec, spec_from_file_location
import io
import json
import sqlite3
from pathlib import Path
import tempfile
import unittest
@@ -29,12 +31,26 @@ class EnrollmentRetry(unittest.TestCase):
for field, value in [('ROOT',root),('STATE',self.state)]:
self.stack.enter_context(patch.object(lifecycle,field,value))
self.enable = self.stack.enter_context(patch.object(lifecycle,'enable'))
self.service = self.stack.enter_context(patch.object(lifecycle,'service'))
self.healthy = self.stack.enter_context(patch.object(lifecycle,'healthy',return_value=True))
self.save = self.stack.enter_context(patch.object(lifecycle,'save_token'))
self.stack.enter_context(patch.object(lifecycle.pwd,'getpwnam'))
self.token = folder / 'retry.token'
self.token.write_text('0' * 64)
def test_unresolved_effects_delay_release_without_blocking_closed_jobs(self):
with sqlite3.connect(self.state / 'journal.sqlite') as db:
db.execute('CREATE TABLE job_attempts (state TEXT)')
for state, expected in [('running','busy'), ('unknown','busy'), ('awaiting_reboot','busy'),
('closed_unknown','idle'), ('accepted','idle'), ('succeeded','idle')]:
with self.subTest(state=state):
db.execute('DELETE FROM job_attempts')
db.execute('INSERT INTO job_attempts VALUES(?)', (state,))
db.commit()
with redirect_stdout(io.StringIO()) as output:
lifecycle.device_idle()
self.assertEqual(output.getvalue().strip(), expected)
def bootstrap_tenant(self, tenant):
def answer(source, route, target):
self.assertEqual(source, (self.base,'0' * 64))
@@ -57,6 +73,17 @@ class EnrollmentRetry(unittest.TestCase):
self.save.assert_called_once()
self.healthy.assert_called_once_with('1.0',0)
def test_timer_starts_only_after_confirmed_first_connection(self):
self.bootstrap_tenant(self.tenant)
self.healthy.return_value = False
with self.assertRaisesRegex(ValueError, 'awaiting authenticated device heartbeat'):
lifecycle.install(self.base,self.token)
self.enable.assert_called_once()
self.service.assert_not_called()
self.healthy.return_value = True
lifecycle.install(self.base,self.token)
self.service.assert_called_once_with('enable','--now',lifecycle.TIMER)
def test_token_for_another_tenant_cannot_replace_initial_token(self):
self.bootstrap_tenant('22222222-2222-4222-8222-222222222222')
with self.assertRaisesRegex(ValueError,'different enrollment tenant'):
+229
View File
@@ -0,0 +1,229 @@
"""Exercise release publication and fresh enrollment on disposable loopback TLS/PostgreSQL."""
import argparse
import base64
from contextlib import ExitStack
import hashlib
import http.client
from http.cookies import SimpleCookie
import json
import os
from pathlib import Path
import secrets
import shutil
import socket
import ssl
import subprocess
import sys
import tempfile
import time
from types import SimpleNamespace
from urllib.parse import urlencode
import uuid
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tools'))
import agent_release as release
TENANT = '11111111-1111-4111-8111-111111111111'
def run(*cmd, data=None):
return subprocess.run(cmd, input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True).stdout
def test(binary, directory, stack):
db = 'rmm-bootstrap-' + uuid.uuid4().hex[:12]
password = secrets.token_hex(24)
run('docker','run','-d','--name',db,'-e','POSTGRES_PASSWORD=' + password,'-p','127.0.0.1::5432','postgres:17.6-bookworm')
stack.callback(run,'docker','rm','-f',db)
for _ in range(80):
if b'init process complete' in run('docker','logs',db) and subprocess.run(
['docker','exec',db,'pg_isready','-U','postgres'],stdout=subprocess.DEVNULL).returncode == 0:
break
time.sleep(.25)
port = run('docker','port',db,'5432/tcp').decode().strip().split(':')[-1]
def sql(role, database, script):
return run('docker','exec','-i',db,'psql','-XAtq','-v','ON_ERROR_STOP=1','-U',role,'-d',database,data=script.encode()).decode().strip()
sql('postgres','postgres', f"""CREATE ROLE rmm_migrator LOGIN NOSUPERUSER NOBYPASSRLS PASSWORD '{password}';
CREATE ROLE rmm_app LOGIN NOSUPERUSER NOBYPASSRLS PASSWORD '{password}';
CREATE DATABASE rmm OWNER rmm_migrator;""")
sql('postgres','rmm','ALTER SCHEMA public OWNER TO rmm_migrator; REVOKE CREATE ON SCHEMA public FROM PUBLIC;')
for migration in sorted((ROOT/'migrations').glob('*.sql')):
sql('rmm_migrator','rmm',migration.read_text())
assert sql('rmm_migrator','rmm',"SELECT NOT rolsuper AND NOT rolbypassrls FROM pg_roles WHERE rolname=current_user") == 't'
def permissions():
return sql('rmm_app','rmm',f"""BEGIN; SET LOCAL app.tenant_id='{TENANT}';
SELECT ('devices:enroll'=ANY(permissions))::int FROM memberships WHERE principal='simulated-testprincipal-a'; COMMIT;""")
assert permissions() == '1', 'migration 0025 must grant devices:enroll through tenant RLS'
print('Migrations and enrollment permission verified with NOSUPERUSER NOBYPASSRLS migration owner')
artifacts = directory/'bin'
artifacts.mkdir()
files = ('/bin/true','/bin/false','/usr/bin/env')
state = directory/'release'
def make_release(sequence):
for name, system_file in zip(release.FILES[release.LINUX], files):
shutil.copyfile(system_file,artifacts/name)
helper=artifacts/release.FILES[release.LINUX][1]
with helper.open('ab') as f: f.write(bytes([sequence]))
hashes={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in artifacts.iterdir()}
receipt=directory/'receipt.json'
receipt.write_text(json.dumps({'sha256':hashes,'target':release.LINUX}))
release.prepare(SimpleNamespace(artifacts=artifacts,build_receipt=receipt,service_uid=os.getuid(),state=state,
sequence=sequence,version='test.'+str(sequence),gateway='https://localhost',days=1))
env=json.loads((state/'prepared/linux'/str(sequence)/'envelope.json').read_bytes())
return env, json.loads(base64.urlsafe_b64decode(env['payload_bytes']+'==='))
a, ma = make_release(1)
tls=directory/'tls'
tls.mkdir()
run('openssl','req','-x509','-newkey','ec','-pkeyopt','ec_paramgen_curve:prime256v1','-nodes','-days','1',
'-subj','/CN=Test CA','-addext','basicConstraints=critical,CA:TRUE','-keyout',str(tls/'ca.key'),'-out',str(tls/'ca.pem'))
def csr(name):
run('openssl','req','-new','-newkey','ec','-pkeyopt','ec_paramgen_curve:prime256v1','-nodes','-subj','/CN='+name,
'-keyout',str(tls/(name+'.key')),'-out',str(tls/(name+'.csr')))
csr('server')
extensions=tls/'san'
extensions.write_text('subjectAltName=DNS:localhost\nextendedKeyUsage=serverAuth\n')
run('openssl','x509','-req','-in',str(tls/'server.csr'),'-CA',str(tls/'ca.pem'),'-CAkey',str(tls/'ca.key'),
'-CAcreateserial','-days','1','-extfile',str(extensions),'-out',str(tls/'server.pem'))
csr('device')
with socket.socket() as s:
s.bind(('127.0.0.1',0)); http_port=s.getsockname()[1]
origin='https://localhost:'+str(http_port)
env=dict(os.environ,DATABASE_URL=f'postgres://rmm_app:{password}@127.0.0.1:{port}/rmm',
RMM_PROFILE='development',RMM_DEV_AUTH='true',RMM_DEV_USERNAME='acceptance',RMM_DEV_PASSWORD=secrets.token_hex(24),
RMM_VIEWER_A=secrets.token_hex(24),RMM_VIEWER_B=secrets.token_hex(24),RMM_SERVER_ROLE='all',
RMM_LISTEN_ADDR=f'127.0.0.1:{http_port}',RMM_UI_ORIGIN=origin,RMM_TLS_DIR=str(tls),
RMM_JOB_KEY_FILE=str(directory/'job-keys/key.pem'),RMM_AGENT_UPDATE_ARTIFACT_DIR=str(state/'objects'),
RMM_AGENT_UPDATE_LINUX_KEYRING_FILE=str(state/'config/linux-keyring.json'),
RMM_AGENT_BOOTSTRAP_LINUX_FILE=str(state/'config/linux-bootstrap.json'),RMM_BOOTSTRAP_ORIGIN=origin)
log=stack.enter_context((directory/'server.log').open('w+'))
server=subprocess.Popen([binary],cwd=directory,env=env,stdout=log,stderr=log)
def stop_server():
if server.poll() is None:
server.terminate()
server.wait(timeout=15)
stack.callback(stop_server)
ctx=ssl.create_default_context(cafile=str(tls/'ca.pem'))
def ask(method,path,body=None,headers=None,status=200):
conn=http.client.HTTPSConnection('localhost',http_port,context=ctx,timeout=10)
try:
headers=dict(headers or {})
if isinstance(body,dict):
body=json.dumps(body).encode();headers['Content-Type']='application/json'
conn.request(method,path,body=body,headers=headers)
response=conn.getresponse();raw=response.read()
expected=(status,) if isinstance(status,int) else status
assert response.status in expected, (method,path.split('?')[0],response.status,expected)
return response.headers, json.loads(raw) if response.getheader('content-type','').startswith('application/json') else raw
finally:
conn.close()
for _ in range(70):
if server.poll() is not None:
log.seek(0); raise RuntimeError(log.read())
try:
ask('GET','/healthz')
break
except OSError:
time.sleep(.1)
hdr,_=ask('POST','/auth/dev/login',{'username':'acceptance','password':env['RMM_DEV_PASSWORD']},{'Origin':origin})
cookie=SimpleCookie(hdr['set-cookie'])['__Host-rmm_session'].value
auth={'Cookie':'__Host-rmm_session='+cookie,'Origin':origin}
_,session=ask('GET','/auth/session',headers=auth)
auth['X-CSRF-Token']=session['csrf_token']
path='/api/v1/tenants/'+TENANT
def upload(blob, data, status=200):
query=urlencode({'artifact_id':blob['artifact_id'],'sha256':blob['sha256'],'size_bytes':blob['bytes']})
ask('POST',path+'/agent-update-artifacts?'+query,data,{**auth,'Content-Type':'application/octet-stream'},status)
def stable_blob(data):
return {'artifact_id':str(uuid.uuid4()),'sha256':hashlib.sha256(data).hexdigest(),'bytes':len(data)}
original_worker=(artifacts/'rmm-agent-updater').read_bytes()
original=stable_blob(original_worker)
upload(original,original_worker)
def send_pair(manifest):
for name,blob in zip(release.FILES[release.LINUX],manifest['artifacts']):
upload(blob,(artifacts/name).read_bytes())
send_pair(ma)
ask('POST',path+'/agent-releases',a,auth)
ask('POST',path+'/agent-releases',a,auth)
b,mb=make_release(2)
upload(mb['artifacts'][0],(artifacts/'rmm-agent').read_bytes())
ask('POST',path+'/agent-releases',b,auth,404)
partial=mb['artifacts'][1]
upload(partial,(artifacts/'rmm-privileged-helper').read_bytes()[:-1],400)
ask('POST',path+'/agent-releases',b,auth,404)
h,token=ask('POST',path+'/enrollment-tokens',{},auth)
assert 'no-store' in h['Cache-Control']
bootstrap='/agent/v1/bootstrap/current?platform='+release.LINUX
credential={'Authorization':'Enrollment '+token['token']}
_,active=ask('GET',bootstrap,headers=credential)
assert active['manifest']['release_id']==ma['release_id'] and active['job_signing_public_key_hex']
assert active['tenant_id']==TENANT
ask('GET',bootstrap,headers={'Authorization':'Enrollment '+'0'*64},status=401)
blob=ma['artifacts'][0]
download=f"/agent/v1/bootstrap/releases/{ma['release_id']}/artifacts/{blob['artifact_id']}?platform={release.LINUX}"
_,raw=ask('GET',download,headers=credential)
assert hashlib.sha256(raw).hexdigest()==blob['sha256']
def updater(digest=None, status=200):
return ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX+('&sha256='+digest if digest else ''),
headers=credential,status=status)[1]
assert updater()==original_worker
replacement_worker=original_worker+b'test-new-worker'
new=stable_blob(replacement_worker)
pin={'sha256':new['sha256'],'bytes':new['bytes']}
try:
release.rotate_pin(state,'linux',TENANT,original['sha256'],pin)
raise AssertionError('missing upload changed pointer')
except FileNotFoundError:
pass
assert updater()==original_worker
upload(new,replacement_worker)
try:
release.rotate_pin(state,'linux',TENANT,'0'*64,pin)
raise AssertionError('unexpected predecessor accepted')
except ValueError:
pass
assert updater()==original_worker
release.rotate_pin(state,'linux',TENANT,original['sha256'],pin)
release.rotate_pin(state,'linux',TENANT,original['sha256'],pin)
assert updater()==replacement_worker and updater(original['sha256'])==original_worker
assert ask('GET',bootstrap,headers=credential)[1]['updater']==pin
updater('0'*64,404)
assert json.loads((state/'config/linux-bootstrap.json').read_bytes())['updater_sha256']==original['sha256']
# Set up B's already published default worker. This fixture has only one
# interactive dev principal (tenant A), so seed the independent tenant directly.
tenant_b='22222222-2222-4222-8222-222222222222'
token_b=secrets.token_hex(32)
sql('rmm_app','rmm',f"BEGIN; SET LOCAL app.tenant_id='{tenant_b}'; SELECT issue_enrollment_token('{hashlib.sha256(token_b.encode()).hexdigest()}'); COMMIT;")
b_store=state/'objects'/tenant_b
b_store.mkdir(mode=0o700)
shutil.copy2(state/'objects'/TENANT/original['sha256'],b_store/original['sha256'])
b_auth={'Authorization':'Enrollment '+token_b}
assert ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX,headers=b_auth)[1]==original_worker
ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX+'&sha256='+new['sha256'],headers=b_auth,status=404)
print('tenant worker rotation rejects missing object and stale predecessor; default and in-flight downloads survive')
install={'token':token['token'],'csr_pem':(tls/'device.csr').read_text()}
_,enrolled=ask('POST','/agent/v1/enroll',install)
assert enrolled['certificate_pem']
ask('POST','/agent/v1/enroll',install,status=401)
ask('GET',bootstrap,headers=credential,status=401)
ask('GET',download,headers=credential,status=401)
ask('GET','/agent/v1/releases/current?platform='+release.LINUX,status=401)
cert = tls/'issued-device.pem'
cert.write_text(enrolled['certificate_pem'])
ctx.load_cert_chain(str(cert),str(tls/'device.key'))
_,trust=ask('GET','/agent/v1/releases/device-trust')
assert trust['job_signing_public_key_hex'] == active['job_signing_public_key_hex']
upload(partial,(artifacts/'rmm-privileged-helper').read_bytes())
ask('POST',path+'/agent-releases',b,auth)
print('A stays current after missing/truncated B; B publishes only after complete retry')
print('Unknown token, second enrollment, post-consumption metadata/object fetch and absent mTLS rejected')
if __name__ == '__main__':
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--server-binary',required=True,type=Path)
args=parser.parse_args()
with ExitStack() as cleanup:
folder=Path(cleanup.enter_context(tempfile.TemporaryDirectory()))
test(args.server_binary.resolve(),folder,cleanup)
+90 -3
View File
@@ -2,6 +2,7 @@
"""Prepare an Ed25519 agent release on the signing host and publish through the catalog API."""
import argparse
import base64
import fcntl
import getpass
import hashlib
import http.client
@@ -50,6 +51,22 @@ def fingerprint(path):
return digest.hexdigest(), size
def verify_native_image(path, target, size):
with path.open('rb') as binary:
header = binary.read(64)
check(len(header) == 64, 'truncated binary header: ' + path.name)
if target == LINUX:
check(header[:6] == b'\x7fELF\x02\x01' and header[16:18] in (b'\x02\x00', b'\x03\x00')
and header[18:20] == b'\x3e\x00', 'Linux x86-64 ELF image required: ' + path.name)
else:
pe = int.from_bytes(header[60:64], 'little')
check(header[:2] == b'MZ' and 64 <= pe <= size - 26, 'Windows PE image required: ' + path.name)
binary.seek(pe)
coff = binary.read(26)
check(coff[:6] == b'PE\0\0\x64\x86' and coff[24:26] == b'\x0b\x02',
'Windows x86-64 PE32+ image required: ' + path.name)
def binaries(folder, receipt):
record = json.loads(receipt.read_text(encoding='utf-8-sig'))
if 'target' in record and 'sha256' in record:
@@ -65,6 +82,7 @@ def binaries(folder, receipt):
for name in FILES[target]:
path = folder / name
digest, size = fingerprint(path)
verify_native_image(path, target, size)
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})
@@ -108,11 +126,22 @@ def https(value):
def prepare(args):
provision_folder(args.state)
provision_folder(args.state/'private')
with (args.state/'private'/'signing.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
prepare_locked(args)
def prepare_locked(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')
minimum = getattr(args, 'minimum_updater_version', 1)
check(minimum in (1,2), 'unknown minimum updater version')
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]
check(minimum == 1 or platform == WINDOWS_GNU, 'version 2 currently applies to the GNU Windows worker')
provision_folder(args.state)
config, private = args.state / 'config', args.state / 'private'
provision_folder(config, args.service_uid)
@@ -146,13 +175,15 @@ def prepare(args):
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')
prior = json.loads((prepared / 'inputs.json').read_bytes())
check(prior.get('version') == args.version and prior.get('blobs') == blobs
and prior.get('minimum_updater_version', 1) == minimum, '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,
'protocol_major': 1, 'state_schema': 1, 'minimum_updater_version': minimum,
'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:
@@ -168,7 +199,7 @@ def prepare(args):
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}))
save_once(output / 'inputs.json', encoded({'version': args.version, 'blobs': blobs, 'minimum_updater_version': minimum}))
output.rename(prepared)
print(prepared / 'envelope.json')
@@ -197,12 +228,59 @@ class Publisher:
conn.close()
def rotate_pin(state, label, tenant, expected, new_pin):
tenant = str(uuid.UUID(tenant))
check(re.fullmatch('[0-9a-f]{64}', expected), 'expected predecessor SHA-256 required')
directory = state/'config'
default = directory/(label + '-bootstrap.json')
path = default.with_suffix('.' + tenant + '.json')
# The already completed upload attests the API read and stored the object.
# Independently reopen the actual tenant object before changing the pin.
sha, size = fingerprint(state/'objects'/tenant/new_pin['sha256'])
check(new_pin == {'sha256':sha,'bytes':size}, 'uploaded stable updater differs')
with (state/'private'/'bootstrap-rotation.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
if path.exists():
pins = json.loads(path.read_bytes())
else:
baseline = json.loads(default.read_bytes())
pins = {'current':{'sha256':baseline['updater_sha256'],'bytes':baseline['updater_bytes']},'previous':[]}
now = int(time.time())
if pins['current'] == new_pin:
prior = pins['previous'][-1]['pin']['sha256'] if pins['previous'] else None
check(expected in (prior, new_pin['sha256']), 'bootstrap predecessor changed')
return
check(pins['current']['sha256'] == expected, 'bootstrap predecessor changed')
previous = [item for item in pins['previous'] if item['expires_at'] > now
and item['pin'] not in (new_pin,pins['current'])]
previous.append({'pin':pins['current'],'expires_at':now+900})
raw = encoded({'current':new_pin,'previous':previous})
check(len(raw) <= 32768, 'too many concurrent bootstrap rotations')
with tempfile.NamedTemporaryFile(dir=directory,delete=False) as f:
try:
f.write(raw)
os.fchmod(f.fileno(),0o600)
os.fchown(f.fileno(),default.stat().st_uid,default.stat().st_gid)
f.flush()
os.fsync(f.fileno())
os.replace(f.name,path)
finally:
Path(f.name).unlink(missing_ok=True)
fd = os.open(directory,os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
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')
check(bool(args.rotate_bootstrap_from) == bool(args.bootstrap_state), 'rotation needs previous SHA and local signing state')
check(not (args.rotate_bootstrap_from and args.bootstrap_worker), 'a rotation uses the new receipt-bound stable worker')
client = Publisher(args.origin, args.ca)
if args.dev_login_file:
path = args.dev_login_file
@@ -222,6 +300,7 @@ def publish(args):
if args.bootstrap_worker:
paths[2] = args.bootstrap_worker
sha, size = fingerprint(paths[2])
verify_native_image(paths[2], platform, size)
name = FILES[platform][2]
blobs[2] = {'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, platform + '/' + name + '/' + sha)),
'sha256': sha, 'bytes': size}
@@ -231,6 +310,11 @@ def publish(args):
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')
if args.rotate_bootstrap_from:
stable = blobs[2]
label = {LINUX:'linux', WINDOWS:'windows', WINDOWS_GNU:'windows-gnu'}[platform]
rotate_pin(args.bootstrap_state,label,tenant,args.rotate_bootstrap_from,
{'sha256':stable['sha256'],'bytes':stable['bytes']})
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,
@@ -253,9 +337,12 @@ def main():
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('--minimum-updater-version',type=int,default=1)
cmd.add_argument('--service-uid', type=int, default=os.getuid())
else:
cmd.add_argument('--origin', required=True)
cmd.add_argument('--bootstrap-state',type=Path,help='Local signing host state for an explicit stable updater rotation')
cmd.add_argument('--rotate-bootstrap-from',help='Compare-and-swap the tenant pin from this SHA-256 after verified upload')
cmd.add_argument('--bootstrap-worker', type=Path, help='Pinned initial stable updater when publishing subsequent code pairs')
cmd.add_argument('--ca', type=Path)
cmd.add_argument('--tenant', required=True)
+16 -3
View File
@@ -20,6 +20,7 @@ def on_server(options):
from pathlib import Path
import shutil
import subprocess
import uuid
import tempfile
os.umask(0o077)
@@ -49,7 +50,7 @@ def on_server(options):
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)
'--service-uid','10001','--minimum-updater-version',str(options['minimum']),'--sequence',str(options['sequence']),'--version',options['version']],check=True)
if options['label'].startswith('windows'):
import re
import uuid
@@ -91,10 +92,20 @@ def on_server(options):
with tempfile.NamedTemporaryFile(mode='w', dir=state) as auth:
json.dump({'username':env['RMM_DEV_USERNAME'],'password':env['RMM_DEV_PASSWORD']},auth)
auth.flush()
label=options['label']
tenant=str(uuid.UUID(options['tenant']))
pin=(state/'config'/(label+'-bootstrap.json')).with_suffix('.'+tenant+'.json')
if options['rotate']:
selection=['--rotate-bootstrap-from',options['rotate'],'--bootstrap-state',str(state)]
elif pin.is_file():
sha=json.loads(pin.read_bytes())['current']['sha256']
selection=['--bootstrap-worker',str(state/'objects'/tenant/sha)]
else:
selection=['--bootstrap-worker',str(state/'bootstrap-workers'/label)]
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,'--bootstrap-worker',str(state/'bootstrap-workers'/options['label'])],check=True)
'--dev-login-file',auth.name,*selection],check=True)
def main():
import inspect
@@ -103,6 +114,8 @@ def main():
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('--minimum-updater-version',type=int,default=1)
parser.add_argument('--rotate-bootstrap-from',help='Rotate only this tenant from the given previous worker SHA-256')
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')
@@ -114,7 +127,7 @@ def main():
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',
'minimum':args.minimum_updater_version,'rotate':args.rotate_bootstrap_from,'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'
+59 -26
View File
@@ -7,7 +7,6 @@ import json
from pathlib import Path
import re
import subprocess
import sys
def sha(data):
@@ -29,6 +28,39 @@ def write_atomic(path, data, mode=0o644):
tmp.unlink(missing_ok=True)
def pack_web(dist):
if not (dist / 'index.html').is_file():
raise ValueError('A built WebUI directory with index.html is required')
files = {}
for file in dist.rglob('*'):
if file.is_symlink():
raise ValueError('Web build contains a symlink')
if file.is_file():
files[file.relative_to(dist).as_posix()] = base64.b64encode(file.read_bytes()).decode()
return files
def stage_web(dist, files):
if 'index.html' not in files:
raise ValueError('Web build has no index.html')
for name, encoded in files.items():
path = dist / name
if Path(name).is_absolute() or '..' in Path(name).parts or path.resolve() != path:
raise ValueError('Invalid WebUI asset path')
if name != 'index.html':
write_atomic(path, base64.b64decode(encoded, validate=True))
return base64.b64decode(files['index.html'], validate=True)
def publish_index(root, dist, index):
write_atomic(dist / 'index.html', index)
actual = subprocess.check_output(['curl','--noproxy','*','--max-time','10','--cacert',
str(root/'devstate/api-pki/ca.pem'),'--silent','--fail','https://localhost:18443/'])
if actual != index:
raise RuntimeError('Served index differs')
return sha(actual)
def web_files(revision):
"""Build the exact Git revision using the local locked frontend dependencies."""
import tempfile
@@ -40,16 +72,14 @@ def web_files(revision):
subprocess.run(['tar','-xf',archive,'-C',work],check=True)
(work/'web/node_modules').symlink_to(root/'web/node_modules',target_is_directory=True)
subprocess.run(['npm','run','build'],cwd=work/'web',check=True)
dist = work/'web/dist'
return {str(file.relative_to(dist)):base64.b64encode(file.read_bytes()).decode()
for file in dist.rglob('*') if file.is_file()}
return pack_web(work / 'web/dist')
def activate(payload):
import fcntl
import time
revision = payload['revision']
if not re.fullmatch('[0-9a-f]{40}', revision):
if not payload['web_only'] and not re.fullmatch('[0-9a-f]{40}', revision):
raise ValueError('Invalid Git revision')
def run(*command):
return subprocess.check_output(list(command),text=True).strip()
@@ -58,10 +88,19 @@ def activate(payload):
root = Path('/opt/rust-discovery')
work = root/'devstate/mvp-deploy'
work.mkdir(exist_ok=True,mode=0o700)
role_dir = work/revision
role_dir.mkdir(exist_ok=True,mode=0o700)
with (work/'deployment.lock').open('a') as lock:
fcntl.flock(lock,fcntl.LOCK_EX)
active = inspect('api')
dist = next(Path(m['Source']) for m in active['Mounts'] if m['Destination'] == '/web')
if dist != root / 'web/dist' or active['Config']['Labels']['com.docker.compose.project'] != 'rust-discovery-server':
raise RuntimeError('Unexpected development WebUI deployment')
index = stage_web(dist, payload['web'])
if payload['web_only']:
print(json.dumps(dict(revision=revision, web_index_sha256=publish_index(root, dist, index),
api_container=active['Id'], web_only=True)))
return
role_dir = work / revision
role_dir.mkdir(exist_ok=True, mode=0o700)
matches = list((Path.home()/'rmm-dev-build/server-arm64/artifacts'/revision).glob('*/manifest.json'))
if len(matches) != 1:
raise RuntimeError('Expected one ARM64 build manifest for this revision')
@@ -70,7 +109,6 @@ def activate(payload):
if (manifest['revision'] != revision or manifest['target'] != 'aarch64-unknown-linux-gnu'
or sha(binary) != manifest['sha256']['rmm-server'] or sha(matches[0].read_bytes()) != matches[0].parent.name):
raise RuntimeError('Server build digest mismatch')
active = inspect('api')
if inspect('gateway')['Image'] != active['Image']:
raise RuntimeError('API and Gateway have different base images')
labels = active['Config']['Labels']
@@ -111,13 +149,6 @@ def activate(payload):
raise RuntimeError('Dev admin/gateway boundary changed')
if config['postgres'].get('ports'):
raise RuntimeError('Unexpected public database')
dist=next(Path(m['Source']) for m in active['Mounts'] if m['Destination']=='/web')
assets={name:base64.b64decode(data,validate=True) for name,data in payload['web'].items()}
if 'index.html' not in assets or any(Path(n).is_absolute() or '..' in Path(n).parts for n in assets):
raise ValueError('Invalid WebUI asset set')
for name,data in assets.items():
if name!='index.html':
write_atomic(dist/name,data)
run(*compose,'run','--no-deps','-T','--rm','migrate')
sql = ['docker','exec','rust-discovery-server-postgres-1','psql','-X','-qAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-c']
recorded = dict(line.split('|') for line in run(*sql,"SELECT version,encode(checksum,'hex') FROM _sqlx_migrations WHERE success").splitlines())
@@ -136,12 +167,7 @@ def activate(payload):
live=run('docker','exec','rust-discovery-server-'+role+'-1','sha256sum','/usr/local/bin/rmm-server').split()[0]
if live!=sha(binary):
raise RuntimeError(role+' running digest differs')
write_atomic(dist/'index.html',assets['index.html'])
index=subprocess.check_output(['curl','--noproxy','*','--cacert',str(root/'devstate/api-pki/ca.pem'),
'--silent','--fail','https://localhost:18443/'])
if index!=assets['index.html']:
raise RuntimeError('Served index differs')
print(json.dumps(dict(revision=revision,server_sha256=sha(binary),web_index_sha256=sha(index),
print(json.dumps(dict(revision=revision,server_sha256=sha(binary),web_index_sha256=publish_index(root, dist, index),
image=inspect('api')['Image'],api_health='ok',gateway_health='ok')))
@@ -150,13 +176,20 @@ def main():
import inspect
import shlex
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--ref',required=True)
parser.add_argument('--ref', help='Exact Git revision for the server and WebUI')
parser.add_argument('--web-only', action='store_true', help='Only activate built web assets')
parser.add_argument('--web-dist', type=Path, help='Use an existing WebUI build with --web-only')
parser.add_argument('--overlay',action='append',default=[],help='Deploy and use this compose overlay from the selected Git revision')
args=parser.parse_args()
revision=subprocess.check_output(['git','rev-parse','--verify','--end-of-options',args.ref+'^{commit}'],text=True).strip()
web=web_files(revision)
if args.web_dist and (not args.web_only or args.ref) or args.web_only and args.overlay:
parser.error('Choose --web-only with either --web-dist or --ref and no compose overlay')
if not args.web_dist and not args.ref:
parser.error('--ref or --web-only --web-dist is required')
revision = None if args.web_dist else subprocess.check_output(
['git','rev-parse','--verify','--end-of-options',args.ref+'^{commit}'],text=True).strip()
web = pack_web(args.web_dist.resolve(strict=True)) if args.web_dist else web_files(revision)
source=Path(inspect.getfile(activate)).read_text().rsplit('\nif __name__ ==', 1)[0]
names=subprocess.check_output(['git','ls-tree','--name-only','-r',revision,'migrations'],text=True).splitlines()
names=subprocess.check_output(['git','ls-tree','--name-only','-r',revision,'migrations'],text=True).splitlines() if not args.web_only else []
migrations={str(int(Path(n).name.split('_',1)[0])):hashlib.sha384(subprocess.check_output(['git','show',revision+':'+n])).hexdigest()
for n in names if n.endswith('.sql')}
overlays = {}
@@ -165,7 +198,7 @@ def main():
parser.error('Expected a server overlay filename from deploy/')
raw = subprocess.check_output(['git', 'show', revision + ':deploy/' + name])
overlays[name] = base64.b64encode(raw).decode()
payload=json.dumps(dict(revision=revision,web=web,overlays=overlays,migrations=migrations))
payload=json.dumps(dict(revision=revision,web=web,web_only=args.web_only,overlays=overlays,migrations=migrations))
cmd=source+'\nactivate(json.loads('+repr(payload)+'))\n'
subprocess.run(ssh_prefix('server')+[shlex.join(['python3','-I','-'])],input=cmd,text=True,check=True)
+12
View File
@@ -1,3 +1,4 @@
import { windowsUpdateScriptHash } from './script-console';
import { expect, it, vi } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server';
import { ConsoleOutput, outputBytes, outputText } from './console-output';
@@ -25,3 +26,14 @@ it('distinguishes no result, empty bytes, invalid encoding, invalid bytes and mi
const bytes = outputBytes([239, 187, 191, 65, 13, 10]);
expect(outputText(bytes).text).toBe('\\ufeffA\\u000d\n'); expect(Array.from(bytes)).toEqual([239, 187, 191, 65, 13, 10]);
});
it('shows unknown restart state for an incomplete Windows Update summary', () => {
function rendered(hash: string) {
const result = { stdout: [], stderr: [], reboot_required: false, evidence: {
script_sha256: hash, windows_update_reboot_required: null
}};
return renderToStaticMarkup(<ConsoleOutput job={{ result }}/>);
}
expect(rendered(windowsUpdateScriptHash)).toContain('Neustartbedarf: unknown');
expect(rendered('ordinary script')).toContain('Neustartbedarf: false');
});
+3 -2
View File
@@ -1,3 +1,4 @@
import { windowsUpdateScriptHash } from './script-console';
import { record, RecordValue, stringField } from './api';
/** The wire format carries bytes, not an encoding declaration. Never guess a
@@ -45,8 +46,8 @@ export function ConsoleOutput({ job }: { job: RecordValue }) {
function Result({ value }: { value: unknown }) {
try {
const result = record(value, 'Jobergebnis');
const evidence = result.evidence && typeof result.evidence === 'object' ? record(result.evidence) : {};
const reboot = Object.hasOwn(evidence, 'windows_update_reboot_required') ? evidence.windows_update_reboot_required : result.reboot_required;
const evidence = result.evidence && typeof result.evidence === 'object' && !Array.isArray(result.evidence) ? record(result.evidence) : {};
const reboot = evidence.script_sha256 === windowsUpdateScriptHash && Object.hasOwn(evidence, 'windows_update_reboot_required') ? evidence.windows_update_reboot_required : result.reboot_required;
return <><p>Exitcode: {typeof result.exit_code === 'number' && Number.isInteger(result.exit_code) ? result.exit_code : 'unknown / nicht gemeldet'} · Fehlercode: {typeof result.error_code === 'string' && result.error_code ? result.error_code : 'nicht gemeldet'}</p>
<p className={result.output_truncated === false ? 'muted' : 'warning'}>Ausgabe begrenzt: {typeof result.output_truncated === 'boolean' ? String(result.output_truncated) : 'unknown'}. {result.output_truncated === true ? 'Die gespeicherten Bytes sind nur ein Ausschnitt.' : result.output_truncated !== false ? 'Vollständigkeit ist nicht bestätigt.' : 'Keine Trunkierung gemeldet.'}</p>
<p>Neustartbedarf: {typeof reboot === 'boolean' ? String(reboot) : 'unknown'}. Ein Exitcode 0 bestätigt Prozessabschluss; fachliche Nachbedingungen stehen im vollständigen Ergebnis.</p>