From 81fcd9c8f8241dee3a96240413e5f075f6ade519 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Tue, 17 Nov 2026 16:08:53 +0100 Subject: [PATCH] Add fresh device trust, installer recovery and scoped patch runtime --- crates/agent-windows/src/helper_ipc.rs | 22 ++++-- crates/agent-windows/src/helper_runtime.rs | 23 +++---- crates/agent-windows/src/helper_system.rs | 21 +++++- .../agent-windows/src/system_capabilities.rs | 3 + .../src/update_native/transition.rs | 3 + crates/domain/src/jobs.rs | 69 ++++++++++++++++++- crates/domain/src/windows_update.ps1 | 47 +++++++++++++ crates/server/src/agent_updates.rs | 1 + crates/server/src/bootstrap/lifecycle.py | 33 +++++++-- crates/server/src/bootstrap/mod.rs | 34 ++++++++- crates/server/src/jobs.rs | 2 + crates/server/src/script_library.rs | 43 +++++++++++- crates/server/src/windows_policy.rs | 40 ++++++++++- deploy/renew_bootstrap_tls.py | 52 ++++++++++++++ deploy/server-bootstrap-tls-renew.service | 8 +++ deploy/server-bootstrap-tls-renew.timer | 10 +++ tests/linux_release_bootstrap.py | 69 +++++++++++++++++++ tools/agent_release.py | 24 +++++-- tools/dev_agent_release.py | 29 +++++++- tools/dev_deploy_server.py | 19 +++-- web/src/console-output.tsx | 4 +- web/src/script-console.test.tsx | 20 ++++++ web/src/script-console.ts | 5 +- web/src/script-library.tsx | 7 +- 24 files changed, 543 insertions(+), 45 deletions(-) create mode 100644 crates/domain/src/windows_update.ps1 create mode 100644 deploy/renew_bootstrap_tls.py create mode 100644 deploy/server-bootstrap-tls-renew.service create mode 100644 deploy/server-bootstrap-tls-renew.timer create mode 100644 tests/linux_release_bootstrap.py diff --git a/crates/agent-windows/src/helper_ipc.rs b/crates/agent-windows/src/helper_ipc.rs index 88e1729..5d34732 100644 --- a/crates/agent-windows/src/helper_ipc.rs +++ b/crates/agent-windows/src/helper_ipc.rs @@ -1430,6 +1430,13 @@ 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 { + ensure!( + (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)) +} pub fn exchange(pin: &Pin, call: &Call, timeout: Duration) -> Result { exchange_fixed(pin, call, timeout, false) } @@ -1443,10 +1450,17 @@ fn exchange_fixed(pin: &Pin, call: &Call, timeout: Duration, time_only: bool) -> ); pin.validate()?; require_self(&pin.agent).context(Stage::ClientSelfRole)?; - ensure!( - (Duration::from_secs(1)..=Duration::from_secs(125)).contains(&timeout), - "HELPER_CALL_TIMEOUT_BOUND" - ); + if timeout > Duration::from_secs(125) { + let Operation::Execute { request, .. } = &call.operation else { + 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"); + } else { + ensure!(timeout >= Duration::from_secs(1), "HELPER_CALL_TIMEOUT_BOUND"); + } let deadline = Instant::now() + timeout; let pipe = owned(unsafe { CreateFileW( diff --git a/crates/agent-windows/src/helper_runtime.rs b/crates/agent-windows/src/helper_runtime.rs index 9789b83..a399f52 100644 --- a/crates/agent-windows/src/helper_runtime.rs +++ b/crates/agent-windows/src/helper_runtime.rs @@ -563,7 +563,7 @@ impl Client { let timeout = if matches!(job.action, Action::UpdateAgent { .. }) { Duration::from_secs(60) } else { - execution_timeout(job.max_runtime_seconds)? + ipc::execution_timeout(&job.action, job.max_runtime_seconds)? }; let permit = self .lane @@ -898,13 +898,6 @@ fn system_shape(job: &JobPayload) -> bool { && (1..=65536).contains(&job.max_output_bytes) && matches!(&job.action,Action::SetServiceState{unit,state} if unit.starts_with("RmmDiscoveryFixture")&&unit.len()>"RmmDiscoveryFixture".len()&&unit.len()<=80&&unit.bytes().all(|b|b.is_ascii_alphanumeric()||b"_-".contains(&b))&&matches!(state.as_str(),"running"|"stopped")) } -fn execution_timeout(seconds: u32) -> Result { - ensure!( - (1..=120).contains(&seconds), - "SYSTEM_EXECUTION_TIMEOUT_BOUND" - ); - Ok(Duration::from_secs(u64::from(seconds) + 5)) -} pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> { if let Action::UpdateAgent { update } = &job.action { ensure!( @@ -1023,11 +1016,15 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> } return Ok(()); } + let windows_update = job.action.is_windows_update_template(); + let reboot_report = if windows_update && !outcome.output_truncated && matches!(outcome.state.as_str(), "succeeded" | "failed") { + rmm_domain::jobs::windows_update_reboot_report(&outcome.stdout) + } else { None }; ensure!( matches!( outcome.state.as_str(), "succeeded" | "failed" | "cancelled" | "expired" | "unknown" - ) && (job.action.windows_msi().is_some() || !outcome.reboot_required) + ) && (job.action.windows_msi().is_some() || outcome.reboot_required == reboot_report.unwrap_or(false)) && outcome .stdout .len() @@ -1092,7 +1089,7 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> system_shape(job) && outcome.exit_code == Some(0) && !outcome.output_truncated - && !outcome.reboot_required + && (!windows_update || (reboot_report.is_some() && e["windows_update_reboot_required"] == serde_json::json!(reboot_report))) && e["postconditions_passed"] == true && e["privileged_script_profile"] == "full_maintenance_v1" && e["execution_sid"] == "S-1-5-18" @@ -1417,9 +1414,9 @@ mod tests { state: "stopped".into(), }; assert!(!system_shape(&job)); - assert_eq!(execution_timeout(120).unwrap(), Duration::from_secs(125)); - assert!(execution_timeout(0).is_err()); - assert!(execution_timeout(121).is_err()); + assert_eq!(ipc::execution_timeout(&job.action, 120).unwrap(), Duration::from_secs(125)); + assert!(ipc::execution_timeout(&job.action, 0).is_err()); + assert!(ipc::execution_timeout(&job.action, 121).is_err()); let mut outcome = Outcome::unknown("LOST_REPLY"); assert!(checked_outcome(&job, &outcome).is_ok()); outcome.reboot_required = true; diff --git a/crates/agent-windows/src/helper_system.rs b/crates/agent-windows/src/helper_system.rs index aaeaba1..0aa86ed 100644 --- a/crates/agent-windows/src/helper_system.rs +++ b/crates/agent-windows/src/helper_system.rs @@ -83,6 +83,8 @@ pub struct Settings { deserialize_with = "rmm_domain::jobs::deserialize_script_profiles" )] pub allowed_script_profiles: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub windows_update_max_runtime_seconds: Option, } fn strict_recipe_hashes<'de, D: serde::Deserializer<'de>>( d: D, @@ -113,7 +115,7 @@ impl Settings { && job .action .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes) - && job.max_runtime_seconds <= self.max_runtime_seconds + && 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() == Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]) } @@ -144,6 +146,7 @@ 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()) && (1..=120).contains(&self.max_runtime_seconds) && self.allowed_services.len() <= 16, "SYSTEM_POLICY_PROFILE" @@ -1167,8 +1170,8 @@ impl SystemHelper { && ((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))) + || self.settings.permits_script(&job) || crate::update_admission::permits_denial( &self.settings.binding, &job @@ -1974,6 +1977,7 @@ mod tests { allow_reboot: false, allowed_msi_recipe_sha256: None, allowed_script_profiles: None, + windows_update_max_runtime_seconds: None, }; let legacy = serde_json::to_value(&settings).unwrap(); assert!(legacy.get("allowed_msi_recipe_sha256").is_none()); @@ -2013,6 +2017,19 @@ mod tests { assert!(!settings.permits_script(&script)); settings.schema_version = 3; assert!(settings.permits_script(&script)); + let generic_script = script.action.clone(); + script.max_runtime_seconds = 3600; + settings.windows_update_max_runtime_seconds = Some(3600); + assert!(!settings.permits_script(&script)); + if let Action::RunScript { script_utf8, windows_execution_profile, .. } = &mut script.action { + *script_utf8 = rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_UTF8.into(); + *windows_execution_profile = Some(rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned); + } + assert!(settings.permits_script(&script)); + settings.windows_update_max_runtime_seconds = None; + assert!(!settings.permits_script(&script)); + script.action = generic_script; + script.max_runtime_seconds = 30; script.execution_identity = "root".into(); assert!(!settings.permits_script(&script)); let mut null = legacy; diff --git a/crates/agent-windows/src/system_capabilities.rs b/crates/agent-windows/src/system_capabilities.rs index b3911e0..8115b97 100644 --- a/crates/agent-windows/src/system_capabilities.rs +++ b/crates/agent-windows/src/system_capabilities.rs @@ -89,6 +89,9 @@ pub fn qualified( && 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)); } "set_service_state" => { diff --git a/crates/agent-windows/src/update_native/transition.rs b/crates/agent-windows/src/update_native/transition.rs index b1ae70c..c23eb2a 100644 --- a/crates/agent-windows/src/update_native/transition.rs +++ b/crates/agent-windows/src/update_native/transition.rs @@ -60,6 +60,8 @@ struct Settings { deserialize_with = "rmm_domain::jobs::deserialize_script_profiles" )] allowed_script_profiles: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + windows_update_max_runtime_seconds: Option, } fn strict_hashes<'de, D: serde::Deserializer<'de>>( d: D, @@ -213,6 +215,7 @@ pub fn render(input: Inputs<'_>) -> Result { 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()) && (1..=120).contains(&settings.max_runtime_seconds) && settings.allowed_services.len() <= 16 && (settings.schema_version >= 2 || settings.allowed_msi_recipe_sha256.is_none()) diff --git a/crates/domain/src/jobs.rs b/crates/domain/src/jobs.rs index d5f2444..787de98 100644 --- a/crates/domain/src/jobs.rs +++ b/crates/domain/src/jobs.rs @@ -54,6 +54,36 @@ pub enum PrivilegedScriptProfile { #[serde(rename = "full_maintenance_v1")] FullMaintenanceV1, } +/// Bytes of the Windows Update Agent PowerShell template seeded by migration 0023. +pub const WINDOWS_UPDATE_SCRIPT_UTF8: &str = include_str!("windows_update.ps1"); +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, + profiles: Option<&[PrivilegedScriptProfile]>, +) -> bool { + limit.is_none_or(|seconds| { + (121..=WINDOWS_UPDATE_MAX_SECONDS).contains(&seconds) + && profiles == Some(&[PrivilegedScriptProfile::FullMaintenanceV1][..]) + }) +} +/// 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. +pub fn windows_update_reboot_report(stdout: &[u8]) -> Option { + let summary = stdout + .rsplit(|byte| *byte == b'\n') + .map(<[u8]>::trim_ascii) + .find(|line| !line.is_empty())?; + let json: serde_json::Value = serde_json::from_slice(summary).ok()?; + let obj = json.as_object()?; + let reboot = obj.get("reboot_required")?.as_bool()?; + (obj.len() == 2 + && (obj.get("found").is_some_and(|v| v.is_u64()) + || (reboot && obj.get("status").and_then(|v| v.as_str()) == Some("restart_pending")))) + .then_some(reboot) +} pub const FULL_MAINTENANCE_CAPABILITY: &str = "script.full_maintenance/1"; pub fn deserialize_privileged_script_profile<'de, D>( d: D, @@ -387,6 +417,20 @@ impl Action { } ) } + pub fn is_windows_update_template(&self) -> bool { + matches!(self, Self::RunScript { + interpreter, script_utf8, arguments, expected_stdout: None, + windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned), + privileged_script_profile: Some(PrivilegedScriptProfile::FullMaintenanceV1), + } if interpreter == "powershell" && arguments.is_empty() && script_utf8 == WINDOWS_UPDATE_SCRIPT_UTF8) + } + pub fn windows_system_runtime_limit(&self, normal: u32, windows_update: Option) -> u32 { + if self.is_windows_update_template() { + windows_update.unwrap_or(normal) + } else { + normal + } + } pub fn valid_execution_identity(&self, identity: &str) -> bool { if let Self::UpdateAgent { update } = self { return update.execution_identity() == Some(identity); @@ -410,7 +454,7 @@ impl Action { || (output_bytes <= 65536 && runtime_seconds <= if self.script_platform() == Some("windows") { - 120 + self.windows_system_runtime_limit(120, Some(WINDOWS_UPDATE_MAX_SECONDS)) } else { 300 })) @@ -779,6 +823,29 @@ impl JobState { mod tests { use super::*; #[test] + fn windows_update_final_report_and_policy_are_exact() { + assert_eq!( + windows_update_reboot_report( + b"ignored \xff\r\n{\"found\":1,\"reboot_required\":true}\r\n" + ), + Some(true) + ); + assert_eq!( + windows_update_reboot_report(br#"{"reboot_required":false,"found":0}"#), + Some(false) + ); + assert_eq!( + windows_update_reboot_report(br#"{"reboot_required":true,"status":"restart_pending"}"#), + Some(true) + ); + assert_eq!( + windows_update_reboot_report(br#"{"id":"an update","reboot_required":true}"#), + None + ); + assert_eq!(windows_update_reboot_report(b"partial"), None); + assert!(!valid_windows_update_limit(Some(3600), None)); + } + #[test] fn windows_system_scm_is_explicit_and_preserves_linux_service_bytes() { let caps: Vec = [ "windows.base/1", diff --git a/crates/domain/src/windows_update.ps1 b/crates/domain/src/windows_update.ps1 new file mode 100644 index 0000000..283da63 --- /dev/null +++ b/crates/domain/src/windows_update.ps1 @@ -0,0 +1,47 @@ +# Install available software updates from the configured Windows Update source. +# See https://learn.microsoft.com/windows/win32/wua_sdk/windows-update-agent-object-model +$ErrorActionPreference = 'Stop' +$session = New-Object -ComObject Microsoft.Update.Session +$session.ClientApplicationID = 'Rust Discovery' +$searcher = $session.CreateUpdateSearcher() +$search = $searcher.Search("IsInstalled=0 and IsHidden=0 and Type='Software'") +if ($search.ResultCode -ne 2) { throw "Update search returned $($search.ResultCode)" } +$failed = $false +$systemInfo = New-Object -ComObject Microsoft.Update.SystemInfo +if ($systemInfo.RebootRequired) { + Write-Output '{"reboot_required":true,"status":"restart_pending"}' + exit 1 +} +foreach ($update in $search.Updates) { + $result = [ordered]@{ id = $update.Identity.UpdateID; title = $update.Title; status = 'pending' } + try { + if ($update.InstallationBehavior.CanRequestUserInput -or !$update.EulaAccepted) { + $result.status = 'operator_input_required' + $failed = $true + } else { + $batch = New-Object -ComObject Microsoft.Update.UpdateColl + [void]$batch.Add($update) + if (!$update.IsDownloaded) { + $downloader = $session.CreateUpdateDownloader() + $downloader.Updates = $batch + $download = $downloader.Download().GetUpdateResult(0) + if ($download.ResultCode -ne 2) { throw "Download HRESULT $($download.HResult)" } + } + $installer = $session.CreateUpdateInstaller() + $installer.AllowSourcePrompts = $false + $installer.Updates = $batch + $install = $installer.Install().GetUpdateResult(0) + $result.status = [int]$install.ResultCode + $result.hresult = $install.HResult + $result.reboot_required = [bool]$install.RebootRequired + if ($install.ResultCode -ne 2) { $failed = $true } + } + } catch { + $result.status = 'failed' + $result.error = $_.Exception.Message + $failed = $true + } + Write-Output ($result | ConvertTo-Json -Compress) +} +Write-Output (@{ found = $search.Updates.Count; reboot_required = [bool]$systemInfo.RebootRequired } | ConvertTo-Json -Compress) +if ($failed) { exit 1 } diff --git a/crates/server/src/agent_updates.rs b/crates/server/src/agent_updates.rs index d572eb6..d9b5baf 100644 --- a/crates/server/src/agent_updates.rs +++ b/crates/server/src/agent_updates.rs @@ -308,6 +308,7 @@ RMM_BOOTSTRAP_PYTHON .route("/agent/v1/bootstrap/updater", get(bootstrap::updater)) .route("/agent/v1/releases/current", get(current)) .route("/agent/v1/releases/installed", get(installed)) + .route("/agent/v1/releases/device-trust", get(bootstrap::device_trust)) .route( "/agent/v1/releases/{release}/artifacts/{artifact}", get(release_artifact), diff --git a/crates/server/src/bootstrap/lifecycle.py b/crates/server/src/bootstrap/lifecycle.py index 7d10b7a..92aa66c 100644 --- a/crates/server/src/bootstrap/lifecycle.py +++ b/crates/server/src/bootstrap/lifecycle.py @@ -176,14 +176,16 @@ def installed(): def healthy(version, baseline, duration=90): until = time.monotonic() + duration + started = time.time() while time.monotonic() < until: try: record = installed() contact = record.get('last_contact_at') if contact: recent = datetime.datetime.fromisoformat(contact.replace('Z', '+00:00')).timestamp() - if (time.time() - 65 < recent <= time.time() + 10 and record['agent_version'] == version - and record['connection_generation'] > baseline): + if (started - 1 <= recent <= time.time() + 10 and record['agent_version'] == version + and record['connection_generation'] > baseline + and subprocess.run(['systemctl', 'is-active', '--quiet', SERVICE], timeout=10).returncode == 0): return True except (subprocess.SubprocessError, ValueError, OSError): pass @@ -249,6 +251,18 @@ def enable(): service('enable', '--now', SERVICE, TIMER) +def enrollment_token(path): + token = Path(path).read_text().strip() if path else getpass.getpass('Einmalcode: ').strip() + require(re.fullmatch('[0-9a-f]{64}', token), 'invalid enrollment token') + return token + + +def save_token(base, token, gid): + path = base / 'first.token' + save(path, token.encode(), 0o440) + os.chown(path, 0, gid) + + def install(base, token_file): require(platform.machine() == 'x86_64', 'Linux x86-64 required') base = origin(base) @@ -256,12 +270,20 @@ def install(base, token_file): config = read(ROOT / 'config.json') require(config['bootstrap'] == base and (ROOT / 'current/manifest.json').is_file(), 'existing installation differs') + if not (STATE / 'identity.json').is_file(): + token = enrollment_token(token_file) + with tempfile.TemporaryDirectory() as work: + metadata = Path(work) / 'bootstrap.json' + remote((base, token), '/agent/v1/bootstrap/current?platform=' + PLATFORM, metadata) + require(read(metadata)['tenant_id'] == config['tenant'], 'different enrollment tenant') + save_token(ROOT, token, pwd.getpwnam('rmm-discovery').pw_gid) enable() + require(healthy(read(ROOT / 'current/manifest.json')['version'], 0), 'awaiting authenticated device heartbeat') + (ROOT / 'first.token').unlink(missing_ok=True) return require(not STATE.exists() and not any((UNIT_DIR/name).exists() for name in units()), 'existing device installation requires migration') - token = Path(token_file).read_text().strip() if token_file else getpass.getpass('Einmalcode: ').strip() - require(re.fullmatch('[0-9a-f]{64}', token), 'invalid enrollment token') + token = enrollment_token(token_file) try: account = pwd.getpwnam('rmm-discovery') except KeyError: @@ -290,8 +312,7 @@ def install(base, token_file): link(staging, manifest['release_id']) save(staging / 'lifecycle.py', Path(__file__).read_bytes()) save(staging / 'release.lock', b'') - save(staging / 'first.token', token.encode(), 0o440) - os.chown(staging / 'first.token', 0, account.pw_gid) + save_token(staging, token, account.pw_gid) staging.chmod(0o755) releases.chmod(0o755) os.rename(staging, ROOT) diff --git a/crates/server/src/bootstrap/mod.rs b/crates/server/src/bootstrap/mod.rs index a74e1f1..1460ae6 100644 --- a/crates/server/src/bootstrap/mod.rs +++ b/crates/server/src/bootstrap/mod.rs @@ -106,6 +106,37 @@ async fn token_tenant(s: &crate::State, h: &HeaderMap) -> Result { .await?; t.ok_or_else(denied) } +#[derive(serde::Deserialize, serde::Serialize)] +#[serde(deny_unknown_fields)] +struct TimeTrust { + key_generation: u64, + server_instance: Uuid, + public_keys_hex: std::collections::BTreeMap, +} +fn device_trust_data(s: &crate::State) -> Result { + let job_public = hex::encode(s.job_signer.public_key()?); + let path = std::env::var_os("RMM_AGENT_BOOTSTRAP_WINDOWS_FILE") + .and_then(|slot| FsPath::new(&slot).parent().map(|p| p.join("windows-time-trust.json"))); + let trust = match path { + Some(path) if path.try_exists().map_err(|_| fail("BOOTSTRAP_TIME_TRUST_INVALID"))? => { + let trust: TimeTrust = serde_json::from_slice(&protected_file(&path, 8192)?)?; + if trust.key_generation == 0 || trust.server_instance.is_nil() + || !(1..=8).contains(&trust.public_keys_hex.len()) + || !trust.public_keys_hex.iter().all(|(id,key)| !id.is_empty() && id.len() <= 64 + && id.bytes().all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b)) + && rmm_domain::agent_update::digest(key) && key != &job_public) { + return Err(fail("BOOTSTRAP_TIME_TRUST_INVALID")); + } + Some(trust) + } + _ => None + }; + Ok(json!({"job_signing_public_key_hex":job_public,"windows_time_trust":trust})) +} +pub(super) async fn device_trust(State(s): State, Extension(peer): Extension, headers: HeaderMap) -> Result { + device(&s, peer, &headers).await?; + Ok(private_json(device_trust_data(&s)?)) +} pub(super) async fn current( State(s): State, headers: HeaderMap, @@ -126,8 +157,9 @@ pub(super) async fn current( .ca .to_pem() .map_err(|_| invalid())?; + let trust = device_trust_data(&s)?; Ok(private_json( - json!({"schema_version":1,"tenant_id":t,"release_envelope":envelope,"manifest":manifest, + json!({"job_signing_public_key_hex":trust["job_signing_public_key_hex"],"windows_time_trust":trust["windows_time_trust"],"schema_version":1,"tenant_id":t,"release_envelope":envelope,"manifest":manifest, "gateway_origin":c.gateway_origin,"ca_pem":String::from_utf8(ca).map_err(|_| invalid())?, "keyring":ring,"updater":{"sha256":c.updater_sha256,"bytes":c.updater_bytes}}), )) diff --git a/crates/server/src/jobs.rs b/crates/server/src/jobs.rs index 764d0ba..b01853b 100644 --- a/crates/server/src/jobs.rs +++ b/crates/server/src/jobs.rs @@ -723,6 +723,7 @@ pub(crate) async fn plan_resolved( artifact_references, script_revision, }; + crate::script_library::validate_plan_bindings(&payload)?; crate::windows_msi_catalog::validate_plan_bindings(&payload)?; crate::agent_updates::validate_plan_bindings(&payload)?; let bytes = encode(&payload)?; @@ -759,6 +760,7 @@ async fn load_plan( Ok((serde_json::from_slice(&bytes)?, h, bytes)) } async fn recheck(tx: &mut Transaction<'_, Postgres>, plan: &PlanPayload) -> Result<()> { + crate::script_library::validate_plan_bindings(plan)?; crate::windows_msi_catalog::validate_plan_bindings(plan)?; crate::agent_updates::validate_plan_bindings(plan)?; policy(tx).await?; diff --git a/crates/server/src/script_library.rs b/crates/server/src/script_library.rs index a83f0a6..b2fa0da 100644 --- a/crates/server/src/script_library.rs +++ b/crates/server/src/script_library.rs @@ -186,6 +186,27 @@ pub async fn plan( jobs::plan_resolved(s, p, tenant, plan, None, Some(reference)).await } +pub(crate) fn validate_plan_bindings(plan: &rmm_domain::jobs::PlanPayload) -> Result<(), Error> { + let Some(reference) = &plan.script_revision else { + if plan.jobs.iter().any(|job| { + job.payload.max_runtime_seconds > 120 && job.payload.action.is_windows_update_template() + }) { + return Err(Error( + StatusCode::CONFLICT, + "WINDOWS_UPDATE_REVISION_REQUIRED", + )); + } + return Ok(()); + }; + if reference.revision_id.is_nil() || reference.version < 1 || reference.name.is_empty() || plan.jobs.is_empty() + || plan.jobs.iter().any(|job| !matches!(&job.payload.action, + Action::RunScript { script_utf8, .. } if hash(script_utf8.as_bytes()) == reference.script_sha256 + && job.script_sha256.as_ref() == Some(&reference.script_sha256))) { + return Err(Error(StatusCode::CONFLICT, "SCRIPT_REVISION_BINDING_MISMATCH")); + } + Ok(()) +} + pub fn routes(r: Router) -> Router { r.route( "/api/v1/tenants/{tenant}/script-revisions", @@ -247,7 +268,13 @@ pub(crate) mod tests { template["script_utf8"].as_str().unwrap().into(), ) .unwrap(); - assert!(native.full_maintenance()); + assert!(native.is_windows_update_template()); + assert_eq!( + template["script_sha256"], + rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_SHA256 + ); + assert!(native.valid_job_limits(3600, 65536)); + assert!(!native.valid_job_limits(3601, 65536)); let v1 = Publish { name: "Agentversion".into(), @@ -335,6 +362,20 @@ pub(crate) mod tests { .unwrap(); tx.commit().await.unwrap(); let bound: rmm_domain::jobs::PlanPayload = serde_json::from_slice(&bytes).unwrap(); + let mut extended = bound.clone(); + extended.jobs[0].payload.action = native; + extended.jobs[0].payload.max_runtime_seconds = 3600; + extended.jobs[0].script_sha256 = + Some(rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_SHA256.into()); + assert_eq!( + validate_plan_bindings(&extended).unwrap_err().1, + "SCRIPT_REVISION_BINDING_MISMATCH" + ); + extended.script_revision = None; + assert_eq!( + validate_plan_bindings(&extended).unwrap_err().1, + "WINDOWS_UPDATE_REVISION_REQUIRED" + ); let reference = bound.script_revision.unwrap(); assert_eq!(reference.revision_id, id); assert_eq!(reference.version, 1); diff --git a/crates/server/src/windows_policy.rs b/crates/server/src/windows_policy.rs index deaf4f7..0daf138 100644 --- a/crates/server/src/windows_policy.rs +++ b/crates/server/src/windows_policy.rs @@ -45,6 +45,8 @@ struct SystemScope { deserialize_with = "rmm_domain::jobs::deserialize_script_profiles" )] allowed_script_profiles: Option>, + #[serde(default)] + windows_update_max_runtime_seconds: Option, #[serde(default, deserialize_with = "strict_optional_reboot")] allow_reboot: Option, } @@ -122,6 +124,10 @@ 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(), + ) && (1..=120).contains(&self.max_runtime_seconds) } fn permits( @@ -154,7 +160,13 @@ impl SystemScope { "helper.binary.sha256:{}", self.helper_binary_sha256 )) - && (1..=self.max_runtime_seconds).contains(&job.max_runtime_seconds) + && (1..=job.action.windows_system_runtime_limit( + self.max_runtime_seconds, + self.windows_update_max_runtime_seconds, + )) + .contains(&job.max_runtime_seconds) + && (job.max_runtime_seconds <= 120 + || has(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY)) && (1..=65536).contains(&job.max_output_bytes) && match &job.action { Action::Reboot { .. } => { @@ -556,6 +568,32 @@ mod tests { policy.schema_version = 3; assert!(policy.permits("selected", &job, &caps, Utc::now())); assert!(!policy.permits("foreign", &job, &caps, Utc::now())); + let general = job.action.clone(); + job.action = Action::RunScript { + interpreter: "powershell".into(), + script_utf8: rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_UTF8.into(), + arguments: vec![], + expected_stdout: None, + windows_execution_profile: Some( + rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned, + ), + privileged_script_profile: Some( + rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1, + ), + }; + caps.push("script.powershell.process_remote_signed/1".into()); + job.max_runtime_seconds = 3600; + assert!(!policy.permits("selected", &job, &caps, Utc::now())); + policy.scopes[0].windows_update_max_runtime_seconds = Some(3600); + assert!(!policy.permits("selected", &job, &caps, Utc::now())); + caps.push(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY.into()); + assert!(policy.permits("selected", &job, &caps, Utc::now())); + policy.scopes[0].windows_update_max_runtime_seconds = Some(1800); + assert!(!policy.permits("selected", &job, &caps, Utc::now())); + policy.scopes[0].windows_update_max_runtime_seconds = Some(3600); + job.action = general; + assert!(!policy.permits("selected", &job, &caps, Utc::now())); + job.max_runtime_seconds = 30; caps.retain(|c| c != rmm_domain::jobs::FULL_MAINTENANCE_CAPABILITY); assert!(!policy.permits("selected", &job, &caps, Utc::now())); } diff --git a/deploy/renew_bootstrap_tls.py b/deploy/renew_bootstrap_tls.py new file mode 100644 index 0000000..0497ca4 --- /dev/null +++ b/deploy/renew_bootstrap_tls.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +"""Renew the development server's public installer certificate before expiry.""" +from pathlib import Path +import os +import subprocess +import tempfile + + +def main(): + state = Path('/opt/rmm-bootstrap-download') + cert = state / 'chain.pem' + host = 'discovery.ease-technologies.de' + def run(*args, **kwargs): + return subprocess.run(args, check=True, timeout=180, **kwargs) + if subprocess.run(['openssl', 'x509', '-in', cert, '-noout', '-checkend', str(30*86400)], + stdout=subprocess.DEVNULL).returncode == 0: + print('Public installer certificate valid beyond renewal window') + return + rules = run('ufw','show','added', capture_output=True, text=True).stdout.splitlines() + rule = ['allow','80/tcp'] + already_open = any(line.split()[:3] == ['ufw',*rule] for line in rules) + run('systemctl','start','rmm-bootstrap-acme.service') + try: + if not already_open: + run('ufw',*rule) + try: + with tempfile.NamedTemporaryFile(dir=state, delete=False) as output: + candidate = Path(output.name) + try: + run('/usr/bin/python3','-I',state/'acme_tiny.py','--account-key',state/'account.key', + '--csr',state/'domain.csr','--acme-dir','/srv/rmm-bootstrap-acme',stdout=output) + output.flush() + run('openssl','verify','-verify_hostname',host,'-CAfile','/etc/ssl/certs/ca-certificates.crt', + '-untrusted',candidate,candidate) + cert_key = run('openssl','x509','-in',candidate,'-noout','-pubkey',capture_output=True).stdout + local_key = run('openssl','pkey','-in',state/'domain.key','-pubout',capture_output=True).stdout + if cert_key != local_key: + raise ValueError('Certificate does not match bootstrap key') + os.fsync(output.fileno()) + os.replace(candidate,cert) + finally: + candidate.unlink(missing_ok=True) + finally: + if not already_open: + run('ufw','delete',*rule) + finally: + run('systemctl','stop','rmm-bootstrap-acme.service') + run('systemctl','restart','rmm-install-ingress.service') + + +if __name__ == '__main__': + main() diff --git a/deploy/server-bootstrap-tls-renew.service b/deploy/server-bootstrap-tls-renew.service new file mode 100644 index 0000000..e5c0089 --- /dev/null +++ b/deploy/server-bootstrap-tls-renew.service @@ -0,0 +1,8 @@ +[Unit] +Description=Renew public Rust Discovery installer TLS certificate + +[Service] +Type=oneshot +ExecStart=/usr/bin/python3 -I /usr/local/libexec/rmm-renew-bootstrap-tls.py +UMask=0077 +TimeoutStartSec=5min diff --git a/deploy/server-bootstrap-tls-renew.timer b/deploy/server-bootstrap-tls-renew.timer new file mode 100644 index 0000000..5bd1b0c --- /dev/null +++ b/deploy/server-bootstrap-tls-renew.timer @@ -0,0 +1,10 @@ +[Unit] +Description=Check public installer TLS certificate daily + +[Timer] +OnCalendar=daily +RandomizedDelaySec=2h +Persistent=true + +[Install] +WantedBy=timers.target diff --git a/tests/linux_release_bootstrap.py b/tests/linux_release_bootstrap.py new file mode 100644 index 0000000..e2cf653 --- /dev/null +++ b/tests/linux_release_bootstrap.py @@ -0,0 +1,69 @@ +"""Retry coverage for the HTTPS Linux bootstrap without installing on the test host.""" +from contextlib import ExitStack +from importlib.util import module_from_spec, spec_from_file_location +import json +from pathlib import Path +import tempfile +import unittest +from unittest.mock import patch + +src = Path(__file__).resolve().parents[1] / 'crates/server/src/bootstrap/lifecycle.py' +spec = spec_from_file_location('rmm_bootstrap_lifecycle', src) +lifecycle = module_from_spec(spec) +spec.loader.exec_module(lifecycle) + + +class EnrollmentRetry(unittest.TestCase): + def setUp(self): + self.stack = ExitStack() + self.addCleanup(self.stack.close) + folder = Path(self.stack.enter_context(tempfile.TemporaryDirectory())) + self.base = 'https://bootstrap.example' + self.tenant = '11111111-1111-4111-8111-111111111111' + root = folder / 'application' + (root / 'current').mkdir(parents=True) + (root / 'config.json').write_text(json.dumps({'bootstrap': self.base, 'tenant': self.tenant})) + (root / 'current/manifest.json').write_text('{"version":"1.0"}') + self.state = folder / 'device' + self.state.mkdir() + 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.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 bootstrap_tenant(self, tenant): + def answer(source, route, target): + self.assertEqual(source, (self.base,'0' * 64)) + target.write_text(json.dumps({'tenant_id': tenant})) + return self.stack.enter_context(patch.object(lifecycle,'remote',side_effect=answer)) + + def test_completed_enrollment_keeps_identity_and_needs_no_token(self): + identity = self.state / 'identity.json' + identity.write_text('{"agent_id":"original"}') + remote = self.bootstrap_tenant(self.tenant) + lifecycle.install(self.base,None) + self.assertEqual(identity.read_text(), '{"agent_id":"original"}') + remote.assert_not_called() + self.save.assert_not_called() + self.enable.assert_called_once() + + def test_expired_initial_token_can_be_replaced_in_same_tenant(self): + self.bootstrap_tenant(self.tenant) + lifecycle.install(self.base,self.token) + self.save.assert_called_once() + self.healthy.assert_called_once_with('1.0',0) + + 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'): + lifecycle.install(self.base,self.token) + self.save.assert_not_called() + self.enable.assert_not_called() + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/agent_release.py b/tools/agent_release.py index 76f8635..fd003ac 100755 --- a/tools/agent_release.py +++ b/tools/agent_release.py @@ -2,7 +2,6 @@ """Prepare an Ed25519 agent release on the signing host and publish through the catalog API.""" import argparse import base64 -import datetime import getpass import hashlib import http.client @@ -11,7 +10,6 @@ import json import os from pathlib import Path import re -import shutil import ssl import subprocess import tempfile @@ -132,11 +130,19 @@ def prepare(args): save_once(config / (label + '-keyring.json'), encoded(ring), args.service_uid) boot = {'gateway_origin': args.gateway.rstrip('/'), 'updater_sha256': blobs[2]['sha256'], 'updater_bytes': blobs[2]['bytes']} boot_path = config / (label + '-bootstrap.json') - # The stable bootstrap worker is provisioned separately from replaceable code. + # Keep the original verified worker available for publication into additional + # tenants, even if a newer build also generated a different worker. + stable = args.state / 'bootstrap-workers' / label + provision_folder(stable.parent) if not boot_path.exists(): save_once(boot_path, encoded(boot), args.service_uid) existing = json.loads(boot_path.read_bytes()) check(existing['gateway_origin'] == boot['gateway_origin'], 'existing gateway origin differs') + if not stable.exists() and boot == existing: + save_once(stable, (args.artifacts / FILES[platform][2]).read_bytes()) + if stable.exists(): + check(fingerprint(stable) == (existing['updater_sha256'], existing['updater_bytes']), + 'stored bootstrap worker differs from protected configuration') prepared = args.state / 'prepared' / label / str(args.sequence) provision_folder(prepared.parent) if prepared.exists(): @@ -212,9 +218,16 @@ def publish(args): tenant = str(uuid.UUID(args.tenant)) check(session['tenant_id'] == tenant and 'catalog:write' in session['permissions'], 'tenant catalog write permission required') path = '/api/v1/tenants/' + tenant - for name, blob in zip(FILES[platform], blobs): + paths = [args.artifacts / name for name in FILES[platform]] + if args.bootstrap_worker: + paths[2] = args.bootstrap_worker + sha, size = fingerprint(paths[2]) + name = FILES[platform][2] + blobs[2] = {'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, platform + '/' + name + '/' + sha)), + 'sha256': sha, 'bytes': size} + for file, blob in zip(paths, blobs): query = urlencode(dict(artifact_id=blob['artifact_id'], sha256=blob['sha256'], size_bytes=blob['bytes'])) - with (args.artifacts / name).open('rb') as data: + with file.open('rb') as data: result = client.request('POST', path + '/agent-update-artifacts?' + query, data, {'Content-Type': 'application/octet-stream', 'Content-Length': str(blob['bytes'])}) check(result['sha256'] == blob['sha256'] and result['size_bytes'] == blob['bytes'], 'artifact receipt differs') @@ -243,6 +256,7 @@ def main(): cmd.add_argument('--service-uid', type=int, default=os.getuid()) else: cmd.add_argument('--origin', required=True) + 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) cmd.add_argument('--envelope', type=Path, required=True) diff --git a/tools/dev_agent_release.py b/tools/dev_agent_release.py index 0b23cd9..a0b5153 100755 --- a/tools/dev_agent_release.py +++ b/tools/dev_agent_release.py @@ -50,6 +50,33 @@ def on_server(options): inputs = ['--artifacts', str(build), '--build-receipt', str(build / options['receipt'])] subprocess.run(['python3', '-I', str(tool), 'prepare', *inputs, '--state', str(state), '--gateway', options['gateway'], '--service-uid','10001','--sequence',str(options['sequence']),'--version',options['version']],check=True) + if options['label'].startswith('windows'): + import re + import uuid + public = Path('/etc/rmm-time-source/time-public-key.json') + if public.exists(): + contents = json.loads(public.read_bytes()) + if (set(contents) != {'schema_version','algorithm','server_instance','key_id','key_generation','public_key_hex'} + or contents['algorithm'] != 'Ed25519' or contents['schema_version'] != 1 or uuid.UUID(contents['server_instance']).int == 0 + or not re.fullmatch('[A-Za-z0-9_-]{1,64}', contents['key_id']) or not re.fullmatch('[0-9a-f]{64}', contents['public_key_hex']) + or type(contents['key_generation']) is not int or contents['key_generation'] <= 0): + raise ValueError('time broker public key information invalid') + expected = {'server_instance':contents['server_instance'],'key_generation':contents['key_generation'], + 'public_keys_hex':{contents['key_id']:contents['public_key_hex']}} + path = state/'config/windows-time-trust.json' + if not path.exists(): + with tempfile.NamedTemporaryFile(mode='w', dir=path.parent,delete=False) as tmp: + json.dump(expected,tmp,separators=(',',':')) + os.fchmod(tmp.fileno(),0o600) + os.fchown(tmp.fileno(),10001,10001) + tmp.flush() + os.fsync(tmp.fileno()) + try: + os.link(tmp.name,path) + finally: + os.unlink(tmp.name) + if json.loads(path.read_bytes()) != expected: + raise ValueError('time trust changed; verify rotation before new publication') if options['prepare_only']: return # Use the ordinary development catalog permission and CSRF-protected API. @@ -67,7 +94,7 @@ def on_server(options): subprocess.run(['python3','-I',str(tool),'publish',*inputs,'--tenant',options['tenant'], '--envelope',str(state/'prepared'/options['label']/str(options['sequence'])/'envelope.json'), '--origin','https://localhost:18443','--ca','/opt/rust-discovery/devstate/api-pki/ca.pem', - '--dev-login-file',auth.name],check=True) + '--dev-login-file',auth.name,'--bootstrap-worker',str(state/'bootstrap-workers'/options['label'])],check=True) def main(): import inspect diff --git a/tools/dev_deploy_server.py b/tools/dev_deploy_server.py index 1c44051..0ec1d0b 100644 --- a/tools/dev_deploy_server.py +++ b/tools/dev_deploy_server.py @@ -95,10 +95,11 @@ def activate(payload): run('docker','build','--network=none','--pull=false','-t',tag,str(context)) overlay=role_dir/'image.compose.yaml' write_atomic(overlay,('services:\n'+''.join(f' {r}:\n image: {tag}\n pull_policy: never\n' for r in ('migrate','api','gateway'))).encode()) - for path in payload['overlays']: - file=(root/'deploy')/path - if not re.fullmatch(r'[\w.-]+\.compose\.yaml',path) or not file.is_file(): - raise ValueError('Dev compose overlay must exist in the deployment directory') + for path, content in payload['overlays'].items(): + file = (root / 'deploy') / path + if not re.fullmatch(r'server\.[\w.-]+\.compose\.yaml', path) or file.is_symlink(): + raise ValueError('Invalid development overlay name') + write_atomic(file, base64.b64decode(content, validate=True)) if file not in base_files: compose.extend(['-f',str(file)]) compose.extend(['-f',str(overlay)]) @@ -150,7 +151,7 @@ def main(): import shlex parser=argparse.ArgumentParser(description=__doc__) parser.add_argument('--ref',required=True) - parser.add_argument('--overlay',action='append',default=[],help='Additional existing compose file in remote deploy/') + 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) @@ -158,7 +159,13 @@ def main(): names=subprocess.check_output(['git','ls-tree','--name-only','-r',revision,'migrations'],text=True).splitlines() 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')} - payload=json.dumps(dict(revision=revision,web=web,overlays=args.overlay,migrations=migrations)) + overlays = {} + for name in args.overlay: + if not re.fullmatch(r'server\.[\w.-]+\.compose\.yaml', name): + 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)) cmd=source+'\nactivate(json.loads('+repr(payload)+'))\n' subprocess.run(ssh_prefix('server')+[shlex.join(['python3','-I','-'])],input=cmd,text=True,check=True) diff --git a/web/src/console-output.tsx b/web/src/console-output.tsx index 510073f..fd87325 100644 --- a/web/src/console-output.tsx +++ b/web/src/console-output.tsx @@ -45,9 +45,11 @@ 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; return <>

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'}

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.'}

-

Neustartbedarf: {typeof result.reboot_required === 'boolean' ? String(result.reboot_required) : 'unknown'}. Ein Exitcode 0 bestätigt Prozessabschluss; fachliche Nachbedingungen stehen im vollständigen Ergebnis.

+

Neustartbedarf: {typeof reboot === 'boolean' ? String(reboot) : 'unknown'}. Ein Exitcode 0 bestätigt Prozessabschluss; fachliche Nachbedingungen stehen im vollständigen Ergebnis.

Ausgabe ist nicht vertrauenswürdiger Text vom Zielgerät. Sie erteilt keine Genehmigung und wird nicht als Anweisung ausgeführt.

; } catch { return

Ergebnisformat unbekannt; vollständige Originaldaten stehen darunter.

; } diff --git a/web/src/script-console.test.tsx b/web/src/script-console.test.tsx index 474204d..08a0e0d 100644 --- a/web/src/script-console.test.tsx +++ b/web/src/script-console.test.tsx @@ -51,6 +51,26 @@ it('shows the immutable library revision and rejects a different catalog script await expect(verifyScriptPlan(await stored('f'.repeat(64)))).rejects.toThrow('Bibliotheksversion'); }); +it('accepts one hour only for the exact Windows Update revision', async () => { + const source = readFileSync(new URL('../../crates/domain/src/windows_update.ps1', import.meta.url), 'utf8'); + async function windowPlan(script: string, fixed: boolean, seconds: number) { + const original = plan('windows_system_full'); + const parsed = record(JSON.parse(new TextDecoder().decode(new Uint8Array(original.plan_payload_bytes as number[])))); + const job = (parsed.jobs as RecordValue[])[0]!, payload = record(job.payload), action = record(payload.action); + action.script_utf8 = script; action.arguments = []; action.expected_stdout = null; payload.max_runtime_seconds = seconds; + job.script_sha256 = await sha256(new TextEncoder().encode(script)); + job.job_payload_hash = await sha256(new TextEncoder().encode(JSON.stringify(payload))); + if (fixed) parsed.script_revision = { revision_id: parsed.plan_id, name: 'Windows-Updates installieren', version: 1, script_sha256: job.script_sha256 }; + const raw = new TextEncoder().encode(JSON.stringify(parsed)); + return { plan_hash: await sha256(raw), plan_payload_bytes: Array.from(raw) }; + } + const valid = await windowPlan(source, true, 3600); + await verifyScriptPlan(valid); expect(scriptPlanJobs(valid)[0]?.runtimeSeconds).toBe(3600); + for (const bad of [await windowPlan(source+'\n',true,3600), await windowPlan(source,false,3600), await windowPlan(source,true,3601)]) { + await expect(verifyScriptPlan(bad)).rejects.toThrow(); + } +}); + it('rejects view, byte and fixed identity/budget/profile tampering before and after display', async () => { for (const alias of ['payload', 'plan_payload', 'jobs', 'resolved_targets']) { const p = plan('linux_root_full'); await verifyScriptPlan(p); p[alias] = []; diff --git a/web/src/script-console.ts b/web/src/script-console.ts index 070ae3f..3174cf1 100644 --- a/web/src/script-console.ts +++ b/web/src/script-console.ts @@ -1,6 +1,7 @@ import { canonicalJson, record, RecordValue, text, windowsScriptProfile, privilegedScriptProfile, fullMaintenanceScriptProfile, validateScriptIdentityProfile } from './api'; import { bytes, hashPattern, parseStrictJson, sha256 } from './safety'; +export const windowsUpdateScriptHash = '0fa5f513a06b6cf902a3f9ac1989987642c181eedd6c305b3912771bd10f2ebf'; export interface ScriptPlanJob { revision?: { id: string; name: string; version: number }; assetId: string; agentId: string; jobId: string; attemptId: string; @@ -99,7 +100,9 @@ export async function verifyScriptPlan(plan: RecordValue): Promise { const notBefore = text(p.not_before, 'Frühester Start'), startBefore = text(p.start_before, 'Startfrist'); if (!Number.isFinite(Date.parse(notBefore)) || !Number.isFinite(Date.parse(startBefore)) || Date.parse(notBefore) >= Date.parse(startBefore) || (plan.expires_at !== undefined && plan.expires_at !== startBefore)) throw new Error('Skriptplan: widersprüchliche feste Fristen'); const full = privilegedProfile === fullMaintenanceScriptProfile; - const runtimeSeconds = integer(p.max_runtime_seconds, 1, full ? interpreter === 'powershell' ? 120 : 300 : 3600), outputBytes = integer(p.max_output_bytes, 1, full ? 65536 : 262144); + const windowsUpdate = revisionHash === windowsUpdateScriptHash && interpreter === 'powershell' && identity === 'system' + && full && windowsProfile === 'powershell_51_remote_signed' && !action.arguments.length && action.expected_stdout === null; + const runtimeSeconds = integer(p.max_runtime_seconds, 1, windowsUpdate ? 3600 : full ? interpreter === 'powershell' ? 120 : 300 : 3600), outputBytes = integer(p.max_output_bytes, 1, full ? 65536 : 262144); const orderedAction = { action: 'run_script', interpreter, script_utf8: script, arguments: action.arguments, expected_stdout: action.expected_stdout, ...(hasWindowsProfile ? { windows_execution_profile: action.windows_execution_profile } : {}), ...(hasPrivilegedProfile ? { privileged_script_profile: action.privileged_script_profile } : {}) }; const ordered = { schema_version: p.schema_version, tenant_id: p.tenant_id, asset_id: assetId, agent_id: agentId, enrollment_generation: p.enrollment_generation, assignment_version: p.assignment_version, job_id: jobId, attempt_id: attemptId, action: orderedAction, execution_identity: identity, not_before: notBefore, start_before: startBefore, max_runtime_seconds: runtimeSeconds, max_output_bytes: outputBytes }; const scriptHash = digest(job.script_sha256), jobHash = digest(job.job_payload_hash); diff --git a/web/src/script-library.tsx b/web/src/script-library.tsx index b81c647..8a7bd17 100644 --- a/web/src/script-library.tsx +++ b/web/src/script-library.tsx @@ -1,6 +1,7 @@ import React, { FormEvent, useEffect, useState } from 'react'; import { objectId, page, record, request, Session, tenantPath, text } from './api'; import { allowed } from './safety'; +import { windowsUpdateScriptHash } from './script-console'; interface Draft { name: string; @@ -79,7 +80,8 @@ export function ScriptLibrary({ tenantId, auth, selected, showPlan }: { tenantId }); } if (!canRead) return null; - const limit = stored?.execution_identity === 'system' ? 120 : stored?.execution_identity === 'root' ? 300 : 3600; + const windowsUpdate = stored?.execution_identity === 'system' && stored.interpreter === 'powershell' && stored.script_sha256 === windowsUpdateScriptHash; + const limit = windowsUpdate ? 3600 : stored?.execution_identity === 'system' ? 120 : stored?.execution_identity === 'root' ? 300 : 3600; return

Skriptbibliothek

{error &&

{error}

}{notice &&

{notice}

} {items.length > 0 && - + }
;